nfs_vnops.c revision 1.46 1 1.46 mycroft /* $NetBSD: nfs_vnops.c,v 1.46 1994/12/27 19:13:21 mycroft Exp $ */
2 1.34 cgd
3 1.1 cgd /*
4 1.32 mycroft * Copyright (c) 1989, 1993
5 1.32 mycroft * The Regents of the University of California. All rights reserved.
6 1.1 cgd *
7 1.1 cgd * This code is derived from software contributed to Berkeley by
8 1.1 cgd * Rick Macklem at The University of Guelph.
9 1.1 cgd *
10 1.1 cgd * Redistribution and use in source and binary forms, with or without
11 1.1 cgd * modification, are permitted provided that the following conditions
12 1.1 cgd * are met:
13 1.1 cgd * 1. Redistributions of source code must retain the above copyright
14 1.1 cgd * notice, this list of conditions and the following disclaimer.
15 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
16 1.1 cgd * notice, this list of conditions and the following disclaimer in the
17 1.1 cgd * documentation and/or other materials provided with the distribution.
18 1.1 cgd * 3. All advertising materials mentioning features or use of this software
19 1.1 cgd * must display the following acknowledgement:
20 1.1 cgd * This product includes software developed by the University of
21 1.1 cgd * California, Berkeley and its contributors.
22 1.1 cgd * 4. Neither the name of the University nor the names of its contributors
23 1.1 cgd * may be used to endorse or promote products derived from this software
24 1.1 cgd * without specific prior written permission.
25 1.1 cgd *
26 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 1.1 cgd * SUCH DAMAGE.
37 1.1 cgd *
38 1.43 mycroft * @(#)nfs_vnops.c 8.10 (Berkeley) 8/11/94
39 1.1 cgd */
40 1.1 cgd
41 1.1 cgd /*
42 1.1 cgd * vnode op calls for sun nfs version 2
43 1.1 cgd */
44 1.1 cgd
45 1.16 mycroft #include <sys/param.h>
46 1.16 mycroft #include <sys/proc.h>
47 1.16 mycroft #include <sys/kernel.h>
48 1.16 mycroft #include <sys/systm.h>
49 1.16 mycroft #include <sys/mount.h>
50 1.16 mycroft #include <sys/buf.h>
51 1.16 mycroft #include <sys/malloc.h>
52 1.16 mycroft #include <sys/mbuf.h>
53 1.16 mycroft #include <sys/conf.h>
54 1.16 mycroft #include <sys/namei.h>
55 1.16 mycroft #include <sys/vnode.h>
56 1.32 mycroft #include <sys/map.h>
57 1.32 mycroft #include <sys/dirent.h>
58 1.32 mycroft #include <sys/lockf.h>
59 1.1 cgd
60 1.32 mycroft #include <vm/vm.h>
61 1.31 cgd
62 1.32 mycroft #include <miscfs/specfs/specdev.h>
63 1.32 mycroft #include <miscfs/fifofs/fifo.h>
64 1.32 mycroft
65 1.32 mycroft #include <nfs/rpcv2.h>
66 1.16 mycroft #include <nfs/nfsv2.h>
67 1.16 mycroft #include <nfs/nfs.h>
68 1.16 mycroft #include <nfs/nfsnode.h>
69 1.16 mycroft #include <nfs/nfsmount.h>
70 1.16 mycroft #include <nfs/xdr_subs.h>
71 1.16 mycroft #include <nfs/nfsm_subs.h>
72 1.32 mycroft #include <nfs/nqnfs.h>
73 1.27 pk
74 1.1 cgd /* Defs */
75 1.1 cgd #define TRUE 1
76 1.1 cgd #define FALSE 0
77 1.1 cgd
78 1.1 cgd /*
79 1.1 cgd * Global vfs data structures for nfs
80 1.1 cgd */
81 1.32 mycroft int (**nfsv2_vnodeop_p)();
82 1.32 mycroft struct vnodeopv_entry_desc nfsv2_vnodeop_entries[] = {
83 1.32 mycroft { &vop_default_desc, vn_default_error },
84 1.32 mycroft { &vop_lookup_desc, nfs_lookup }, /* lookup */
85 1.32 mycroft { &vop_create_desc, nfs_create }, /* create */
86 1.32 mycroft { &vop_mknod_desc, nfs_mknod }, /* mknod */
87 1.32 mycroft { &vop_open_desc, nfs_open }, /* open */
88 1.32 mycroft { &vop_close_desc, nfs_close }, /* close */
89 1.32 mycroft { &vop_access_desc, nfs_access }, /* access */
90 1.32 mycroft { &vop_getattr_desc, nfs_getattr }, /* getattr */
91 1.32 mycroft { &vop_setattr_desc, nfs_setattr }, /* setattr */
92 1.32 mycroft { &vop_read_desc, nfs_read }, /* read */
93 1.32 mycroft { &vop_write_desc, nfs_write }, /* write */
94 1.43 mycroft { &vop_lease_desc, nfs_lease_check }, /* lease */
95 1.32 mycroft { &vop_ioctl_desc, nfs_ioctl }, /* ioctl */
96 1.32 mycroft { &vop_select_desc, nfs_select }, /* select */
97 1.32 mycroft { &vop_mmap_desc, nfs_mmap }, /* mmap */
98 1.32 mycroft { &vop_fsync_desc, nfs_fsync }, /* fsync */
99 1.32 mycroft { &vop_seek_desc, nfs_seek }, /* seek */
100 1.32 mycroft { &vop_remove_desc, nfs_remove }, /* remove */
101 1.32 mycroft { &vop_link_desc, nfs_link }, /* link */
102 1.32 mycroft { &vop_rename_desc, nfs_rename }, /* rename */
103 1.32 mycroft { &vop_mkdir_desc, nfs_mkdir }, /* mkdir */
104 1.32 mycroft { &vop_rmdir_desc, nfs_rmdir }, /* rmdir */
105 1.32 mycroft { &vop_symlink_desc, nfs_symlink }, /* symlink */
106 1.32 mycroft { &vop_readdir_desc, nfs_readdir }, /* readdir */
107 1.32 mycroft { &vop_readlink_desc, nfs_readlink }, /* readlink */
108 1.32 mycroft { &vop_abortop_desc, nfs_abortop }, /* abortop */
109 1.32 mycroft { &vop_inactive_desc, nfs_inactive }, /* inactive */
110 1.32 mycroft { &vop_reclaim_desc, nfs_reclaim }, /* reclaim */
111 1.32 mycroft { &vop_lock_desc, nfs_lock }, /* lock */
112 1.32 mycroft { &vop_unlock_desc, nfs_unlock }, /* unlock */
113 1.32 mycroft { &vop_bmap_desc, nfs_bmap }, /* bmap */
114 1.32 mycroft { &vop_strategy_desc, nfs_strategy }, /* strategy */
115 1.32 mycroft { &vop_print_desc, nfs_print }, /* print */
116 1.32 mycroft { &vop_islocked_desc, nfs_islocked }, /* islocked */
117 1.32 mycroft { &vop_pathconf_desc, nfs_pathconf }, /* pathconf */
118 1.32 mycroft { &vop_advlock_desc, nfs_advlock }, /* advlock */
119 1.32 mycroft { &vop_blkatoff_desc, nfs_blkatoff }, /* blkatoff */
120 1.32 mycroft { &vop_valloc_desc, nfs_valloc }, /* valloc */
121 1.32 mycroft { &vop_reallocblks_desc, nfs_reallocblks }, /* reallocblks */
122 1.32 mycroft { &vop_vfree_desc, nfs_vfree }, /* vfree */
123 1.32 mycroft { &vop_truncate_desc, nfs_truncate }, /* truncate */
124 1.32 mycroft { &vop_update_desc, nfs_update }, /* update */
125 1.32 mycroft { &vop_bwrite_desc, vn_bwrite },
126 1.32 mycroft { (struct vnodeop_desc*)NULL, (int(*)())NULL }
127 1.1 cgd };
128 1.32 mycroft struct vnodeopv_desc nfsv2_vnodeop_opv_desc =
129 1.32 mycroft { &nfsv2_vnodeop_p, nfsv2_vnodeop_entries };
130 1.1 cgd
131 1.1 cgd /*
132 1.1 cgd * Special device vnode ops
133 1.1 cgd */
134 1.32 mycroft int (**spec_nfsv2nodeop_p)();
135 1.32 mycroft struct vnodeopv_entry_desc spec_nfsv2nodeop_entries[] = {
136 1.32 mycroft { &vop_default_desc, vn_default_error },
137 1.32 mycroft { &vop_lookup_desc, spec_lookup }, /* lookup */
138 1.32 mycroft { &vop_create_desc, spec_create }, /* create */
139 1.32 mycroft { &vop_mknod_desc, spec_mknod }, /* mknod */
140 1.32 mycroft { &vop_open_desc, spec_open }, /* open */
141 1.32 mycroft { &vop_close_desc, nfsspec_close }, /* close */
142 1.32 mycroft { &vop_access_desc, nfsspec_access }, /* access */
143 1.32 mycroft { &vop_getattr_desc, nfs_getattr }, /* getattr */
144 1.32 mycroft { &vop_setattr_desc, nfs_setattr }, /* setattr */
145 1.32 mycroft { &vop_read_desc, nfsspec_read }, /* read */
146 1.32 mycroft { &vop_write_desc, nfsspec_write }, /* write */
147 1.43 mycroft { &vop_lease_desc, spec_lease_check }, /* lease */
148 1.32 mycroft { &vop_ioctl_desc, spec_ioctl }, /* ioctl */
149 1.32 mycroft { &vop_select_desc, spec_select }, /* select */
150 1.32 mycroft { &vop_mmap_desc, spec_mmap }, /* mmap */
151 1.32 mycroft { &vop_fsync_desc, nfs_fsync }, /* fsync */
152 1.32 mycroft { &vop_seek_desc, spec_seek }, /* seek */
153 1.32 mycroft { &vop_remove_desc, spec_remove }, /* remove */
154 1.32 mycroft { &vop_link_desc, spec_link }, /* link */
155 1.32 mycroft { &vop_rename_desc, spec_rename }, /* rename */
156 1.32 mycroft { &vop_mkdir_desc, spec_mkdir }, /* mkdir */
157 1.32 mycroft { &vop_rmdir_desc, spec_rmdir }, /* rmdir */
158 1.32 mycroft { &vop_symlink_desc, spec_symlink }, /* symlink */
159 1.32 mycroft { &vop_readdir_desc, spec_readdir }, /* readdir */
160 1.32 mycroft { &vop_readlink_desc, spec_readlink }, /* readlink */
161 1.32 mycroft { &vop_abortop_desc, spec_abortop }, /* abortop */
162 1.32 mycroft { &vop_inactive_desc, nfs_inactive }, /* inactive */
163 1.32 mycroft { &vop_reclaim_desc, nfs_reclaim }, /* reclaim */
164 1.32 mycroft { &vop_lock_desc, nfs_lock }, /* lock */
165 1.32 mycroft { &vop_unlock_desc, nfs_unlock }, /* unlock */
166 1.32 mycroft { &vop_bmap_desc, spec_bmap }, /* bmap */
167 1.32 mycroft { &vop_strategy_desc, spec_strategy }, /* strategy */
168 1.32 mycroft { &vop_print_desc, nfs_print }, /* print */
169 1.32 mycroft { &vop_islocked_desc, nfs_islocked }, /* islocked */
170 1.32 mycroft { &vop_pathconf_desc, spec_pathconf }, /* pathconf */
171 1.32 mycroft { &vop_advlock_desc, spec_advlock }, /* advlock */
172 1.32 mycroft { &vop_blkatoff_desc, spec_blkatoff }, /* blkatoff */
173 1.32 mycroft { &vop_valloc_desc, spec_valloc }, /* valloc */
174 1.32 mycroft { &vop_reallocblks_desc, spec_reallocblks }, /* reallocblks */
175 1.32 mycroft { &vop_vfree_desc, spec_vfree }, /* vfree */
176 1.32 mycroft { &vop_truncate_desc, spec_truncate }, /* truncate */
177 1.32 mycroft { &vop_update_desc, nfs_update }, /* update */
178 1.32 mycroft { &vop_bwrite_desc, vn_bwrite },
179 1.32 mycroft { (struct vnodeop_desc*)NULL, (int(*)())NULL }
180 1.1 cgd };
181 1.32 mycroft struct vnodeopv_desc spec_nfsv2nodeop_opv_desc =
182 1.32 mycroft { &spec_nfsv2nodeop_p, spec_nfsv2nodeop_entries };
183 1.1 cgd
184 1.1 cgd #ifdef FIFO
185 1.32 mycroft int (**fifo_nfsv2nodeop_p)();
186 1.32 mycroft struct vnodeopv_entry_desc fifo_nfsv2nodeop_entries[] = {
187 1.32 mycroft { &vop_default_desc, vn_default_error },
188 1.32 mycroft { &vop_lookup_desc, fifo_lookup }, /* lookup */
189 1.32 mycroft { &vop_create_desc, fifo_create }, /* create */
190 1.32 mycroft { &vop_mknod_desc, fifo_mknod }, /* mknod */
191 1.32 mycroft { &vop_open_desc, fifo_open }, /* open */
192 1.32 mycroft { &vop_close_desc, nfsfifo_close }, /* close */
193 1.32 mycroft { &vop_access_desc, nfsspec_access }, /* access */
194 1.32 mycroft { &vop_getattr_desc, nfs_getattr }, /* getattr */
195 1.32 mycroft { &vop_setattr_desc, nfs_setattr }, /* setattr */
196 1.32 mycroft { &vop_read_desc, nfsfifo_read }, /* read */
197 1.32 mycroft { &vop_write_desc, nfsfifo_write }, /* write */
198 1.43 mycroft { &vop_lease_desc, fifo_lease_check }, /* lease */
199 1.32 mycroft { &vop_ioctl_desc, fifo_ioctl }, /* ioctl */
200 1.32 mycroft { &vop_select_desc, fifo_select }, /* select */
201 1.32 mycroft { &vop_mmap_desc, fifo_mmap }, /* mmap */
202 1.32 mycroft { &vop_fsync_desc, nfs_fsync }, /* fsync */
203 1.32 mycroft { &vop_seek_desc, fifo_seek }, /* seek */
204 1.32 mycroft { &vop_remove_desc, fifo_remove }, /* remove */
205 1.32 mycroft { &vop_link_desc, fifo_link }, /* link */
206 1.32 mycroft { &vop_rename_desc, fifo_rename }, /* rename */
207 1.32 mycroft { &vop_mkdir_desc, fifo_mkdir }, /* mkdir */
208 1.32 mycroft { &vop_rmdir_desc, fifo_rmdir }, /* rmdir */
209 1.32 mycroft { &vop_symlink_desc, fifo_symlink }, /* symlink */
210 1.32 mycroft { &vop_readdir_desc, fifo_readdir }, /* readdir */
211 1.32 mycroft { &vop_readlink_desc, fifo_readlink }, /* readlink */
212 1.32 mycroft { &vop_abortop_desc, fifo_abortop }, /* abortop */
213 1.32 mycroft { &vop_inactive_desc, nfs_inactive }, /* inactive */
214 1.32 mycroft { &vop_reclaim_desc, nfs_reclaim }, /* reclaim */
215 1.32 mycroft { &vop_lock_desc, nfs_lock }, /* lock */
216 1.32 mycroft { &vop_unlock_desc, nfs_unlock }, /* unlock */
217 1.32 mycroft { &vop_bmap_desc, fifo_bmap }, /* bmap */
218 1.32 mycroft { &vop_strategy_desc, fifo_badop }, /* strategy */
219 1.32 mycroft { &vop_print_desc, nfs_print }, /* print */
220 1.32 mycroft { &vop_islocked_desc, nfs_islocked }, /* islocked */
221 1.32 mycroft { &vop_pathconf_desc, fifo_pathconf }, /* pathconf */
222 1.32 mycroft { &vop_advlock_desc, fifo_advlock }, /* advlock */
223 1.32 mycroft { &vop_blkatoff_desc, fifo_blkatoff }, /* blkatoff */
224 1.32 mycroft { &vop_valloc_desc, fifo_valloc }, /* valloc */
225 1.32 mycroft { &vop_reallocblks_desc, fifo_reallocblks }, /* reallocblks */
226 1.32 mycroft { &vop_vfree_desc, fifo_vfree }, /* vfree */
227 1.32 mycroft { &vop_truncate_desc, fifo_truncate }, /* truncate */
228 1.32 mycroft { &vop_update_desc, nfs_update }, /* update */
229 1.32 mycroft { &vop_bwrite_desc, vn_bwrite },
230 1.32 mycroft { (struct vnodeop_desc*)NULL, (int(*)())NULL }
231 1.1 cgd };
232 1.32 mycroft struct vnodeopv_desc fifo_nfsv2nodeop_opv_desc =
233 1.32 mycroft { &fifo_nfsv2nodeop_p, fifo_nfsv2nodeop_entries };
234 1.1 cgd #endif /* FIFO */
235 1.1 cgd
236 1.32 mycroft void nqnfs_clientlease();
237 1.32 mycroft
238 1.1 cgd /*
239 1.32 mycroft * Global variables
240 1.1 cgd */
241 1.1 cgd extern u_long nfs_procids[NFS_NPROCS];
242 1.32 mycroft extern u_long nfs_prog, nfs_vers, nfs_true, nfs_false;
243 1.1 cgd struct proc *nfs_iodwant[NFS_MAXASYNCDAEMON];
244 1.1 cgd int nfs_numasync = 0;
245 1.32 mycroft #define DIRHDSIZ (sizeof (struct dirent) - (MAXNAMLEN + 1))
246 1.1 cgd
247 1.1 cgd /*
248 1.1 cgd * nfs null call from vfs.
249 1.1 cgd */
250 1.32 mycroft int
251 1.32 mycroft nfs_null(vp, cred, procp)
252 1.1 cgd struct vnode *vp;
253 1.1 cgd struct ucred *cred;
254 1.32 mycroft struct proc *procp;
255 1.1 cgd {
256 1.1 cgd caddr_t bpos, dpos;
257 1.1 cgd int error = 0;
258 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb;
259 1.1 cgd
260 1.32 mycroft nfsm_reqhead(vp, NFSPROC_NULL, 0);
261 1.32 mycroft nfsm_request(vp, NFSPROC_NULL, procp, cred);
262 1.1 cgd nfsm_reqdone;
263 1.1 cgd return (error);
264 1.1 cgd }
265 1.1 cgd
266 1.1 cgd /*
267 1.1 cgd * nfs access vnode op.
268 1.32 mycroft * For nfs, just return ok. File accesses may fail later.
269 1.32 mycroft * For nqnfs, use the access rpc to check accessibility. If file modes are
270 1.32 mycroft * changed on the server, accesses might still fail later.
271 1.1 cgd */
272 1.32 mycroft int
273 1.32 mycroft nfs_access(ap)
274 1.32 mycroft struct vop_access_args /* {
275 1.32 mycroft struct vnode *a_vp;
276 1.32 mycroft int a_mode;
277 1.32 mycroft struct ucred *a_cred;
278 1.32 mycroft struct proc *a_p;
279 1.32 mycroft } */ *ap;
280 1.1 cgd {
281 1.32 mycroft register struct vnode *vp = ap->a_vp;
282 1.32 mycroft register u_long *tl;
283 1.32 mycroft register caddr_t cp;
284 1.32 mycroft caddr_t bpos, dpos;
285 1.32 mycroft int error = 0;
286 1.32 mycroft struct mbuf *mreq, *mrep, *md, *mb, *mb2;
287 1.1 cgd
288 1.1 cgd /*
289 1.32 mycroft * For nqnfs, do an access rpc, otherwise you are stuck emulating
290 1.32 mycroft * ufs_access() locally using the vattr. This may not be correct,
291 1.32 mycroft * since the server may apply other access criteria such as
292 1.32 mycroft * client uid-->server uid mapping that we do not know about, but
293 1.32 mycroft * this is better than just returning anything that is lying about
294 1.32 mycroft * in the cache.
295 1.32 mycroft */
296 1.32 mycroft if (VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NQNFS) {
297 1.32 mycroft nfsstats.rpccnt[NQNFSPROC_ACCESS]++;
298 1.32 mycroft nfsm_reqhead(vp, NQNFSPROC_ACCESS, NFSX_FH + 3 * NFSX_UNSIGNED);
299 1.32 mycroft nfsm_fhtom(vp);
300 1.32 mycroft nfsm_build(tl, u_long *, 3 * NFSX_UNSIGNED);
301 1.32 mycroft if (ap->a_mode & VREAD)
302 1.32 mycroft *tl++ = nfs_true;
303 1.32 mycroft else
304 1.32 mycroft *tl++ = nfs_false;
305 1.32 mycroft if (ap->a_mode & VWRITE)
306 1.32 mycroft *tl++ = nfs_true;
307 1.32 mycroft else
308 1.32 mycroft *tl++ = nfs_false;
309 1.32 mycroft if (ap->a_mode & VEXEC)
310 1.32 mycroft *tl = nfs_true;
311 1.32 mycroft else
312 1.32 mycroft *tl = nfs_false;
313 1.32 mycroft nfsm_request(vp, NQNFSPROC_ACCESS, ap->a_p, ap->a_cred);
314 1.32 mycroft nfsm_reqdone;
315 1.1 cgd return (error);
316 1.32 mycroft } else
317 1.32 mycroft return (nfsspec_access(ap));
318 1.1 cgd }
319 1.1 cgd
320 1.1 cgd /*
321 1.1 cgd * nfs open vnode op
322 1.32 mycroft * Check to see if the type is ok
323 1.32 mycroft * and that deletion is not in progress.
324 1.32 mycroft * For paged in text files, you will need to flush the page cache
325 1.32 mycroft * if consistency is lost.
326 1.1 cgd */
327 1.1 cgd /* ARGSUSED */
328 1.32 mycroft int
329 1.32 mycroft nfs_open(ap)
330 1.32 mycroft struct vop_open_args /* {
331 1.32 mycroft struct vnode *a_vp;
332 1.32 mycroft int a_mode;
333 1.32 mycroft struct ucred *a_cred;
334 1.32 mycroft struct proc *a_p;
335 1.32 mycroft } */ *ap;
336 1.1 cgd {
337 1.32 mycroft register struct vnode *vp = ap->a_vp;
338 1.32 mycroft struct nfsnode *np = VTONFS(vp);
339 1.32 mycroft struct nfsmount *nmp = VFSTONFS(vp->v_mount);
340 1.32 mycroft struct vattr vattr;
341 1.32 mycroft int error;
342 1.1 cgd
343 1.32 mycroft if (vp->v_type != VREG && vp->v_type != VDIR && vp->v_type != VLNK)
344 1.1 cgd return (EACCES);
345 1.32 mycroft if (vp->v_flag & VTEXT) {
346 1.32 mycroft /*
347 1.32 mycroft * Get a valid lease. If cached data is stale, flush it.
348 1.32 mycroft */
349 1.32 mycroft if (nmp->nm_flag & NFSMNT_NQNFS) {
350 1.32 mycroft if (NQNFS_CKINVALID(vp, np, NQL_READ)) {
351 1.32 mycroft do {
352 1.32 mycroft error = nqnfs_getlease(vp, NQL_READ, ap->a_cred, ap->a_p);
353 1.32 mycroft } while (error == NQNFS_EXPIRED);
354 1.32 mycroft if (error)
355 1.32 mycroft return (error);
356 1.32 mycroft if (np->n_lrev != np->n_brev ||
357 1.32 mycroft (np->n_flag & NQNFSNONCACHE)) {
358 1.32 mycroft if ((error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred,
359 1.32 mycroft ap->a_p, 1)) == EINTR)
360 1.32 mycroft return (error);
361 1.32 mycroft (void) vnode_pager_uncache(vp);
362 1.32 mycroft np->n_brev = np->n_lrev;
363 1.32 mycroft }
364 1.32 mycroft }
365 1.32 mycroft } else {
366 1.32 mycroft if (np->n_flag & NMODIFIED) {
367 1.32 mycroft if ((error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred,
368 1.32 mycroft ap->a_p, 1)) == EINTR)
369 1.32 mycroft return (error);
370 1.32 mycroft (void) vnode_pager_uncache(vp);
371 1.32 mycroft np->n_attrstamp = 0;
372 1.32 mycroft np->n_direofoffset = 0;
373 1.32 mycroft if (error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_p))
374 1.32 mycroft return (error);
375 1.32 mycroft np->n_mtime = vattr.va_mtime.ts_sec;
376 1.32 mycroft } else {
377 1.32 mycroft if (error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_p))
378 1.32 mycroft return (error);
379 1.32 mycroft if (np->n_mtime != vattr.va_mtime.ts_sec) {
380 1.32 mycroft np->n_direofoffset = 0;
381 1.32 mycroft if ((error = nfs_vinvalbuf(vp, V_SAVE,
382 1.32 mycroft ap->a_cred, ap->a_p, 1)) == EINTR)
383 1.32 mycroft return (error);
384 1.32 mycroft (void) vnode_pager_uncache(vp);
385 1.32 mycroft np->n_mtime = vattr.va_mtime.ts_sec;
386 1.32 mycroft }
387 1.32 mycroft }
388 1.32 mycroft }
389 1.32 mycroft } else if ((nmp->nm_flag & NFSMNT_NQNFS) == 0)
390 1.32 mycroft np->n_attrstamp = 0; /* For Open/Close consistency */
391 1.32 mycroft return (0);
392 1.1 cgd }
393 1.1 cgd
394 1.1 cgd /*
395 1.1 cgd * nfs close vnode op
396 1.1 cgd * For reg files, invalidate any buffer cache entries.
397 1.1 cgd */
398 1.1 cgd /* ARGSUSED */
399 1.32 mycroft int
400 1.32 mycroft nfs_close(ap)
401 1.32 mycroft struct vop_close_args /* {
402 1.32 mycroft struct vnodeop_desc *a_desc;
403 1.32 mycroft struct vnode *a_vp;
404 1.32 mycroft int a_fflag;
405 1.32 mycroft struct ucred *a_cred;
406 1.32 mycroft struct proc *a_p;
407 1.32 mycroft } */ *ap;
408 1.1 cgd {
409 1.32 mycroft register struct vnode *vp = ap->a_vp;
410 1.1 cgd register struct nfsnode *np = VTONFS(vp);
411 1.1 cgd int error = 0;
412 1.1 cgd
413 1.32 mycroft if (vp->v_type == VREG) {
414 1.32 mycroft if ((VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NQNFS) == 0 &&
415 1.32 mycroft (np->n_flag & NMODIFIED)) {
416 1.32 mycroft error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_p, 1);
417 1.1 cgd np->n_attrstamp = 0;
418 1.32 mycroft }
419 1.32 mycroft if (np->n_flag & NWRITEERR) {
420 1.32 mycroft np->n_flag &= ~NWRITEERR;
421 1.32 mycroft error = np->n_error;
422 1.32 mycroft }
423 1.1 cgd }
424 1.1 cgd return (error);
425 1.1 cgd }
426 1.1 cgd
427 1.1 cgd /*
428 1.1 cgd * nfs getattr call from vfs.
429 1.1 cgd */
430 1.32 mycroft int
431 1.32 mycroft nfs_getattr(ap)
432 1.32 mycroft struct vop_getattr_args /* {
433 1.32 mycroft struct vnode *a_vp;
434 1.32 mycroft struct vattr *a_vap;
435 1.32 mycroft struct ucred *a_cred;
436 1.32 mycroft struct proc *a_p;
437 1.32 mycroft } */ *ap;
438 1.1 cgd {
439 1.32 mycroft register struct vnode *vp = ap->a_vp;
440 1.32 mycroft register struct nfsnode *np = VTONFS(vp);
441 1.1 cgd register caddr_t cp;
442 1.1 cgd caddr_t bpos, dpos;
443 1.1 cgd int error = 0;
444 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
445 1.1 cgd
446 1.32 mycroft /*
447 1.32 mycroft * Update local times for special files.
448 1.32 mycroft */
449 1.32 mycroft if (np->n_flag & (NACC | NUPD))
450 1.32 mycroft np->n_flag |= NCHG;
451 1.32 mycroft /*
452 1.32 mycroft * First look in the cache.
453 1.32 mycroft */
454 1.32 mycroft if (nfs_getattrcache(vp, ap->a_vap) == 0)
455 1.1 cgd return (0);
456 1.1 cgd nfsstats.rpccnt[NFSPROC_GETATTR]++;
457 1.32 mycroft nfsm_reqhead(vp, NFSPROC_GETATTR, NFSX_FH);
458 1.1 cgd nfsm_fhtom(vp);
459 1.32 mycroft nfsm_request(vp, NFSPROC_GETATTR, ap->a_p, ap->a_cred);
460 1.32 mycroft nfsm_loadattr(vp, ap->a_vap);
461 1.1 cgd nfsm_reqdone;
462 1.1 cgd return (error);
463 1.1 cgd }
464 1.1 cgd
465 1.1 cgd /*
466 1.1 cgd * nfs setattr call.
467 1.1 cgd */
468 1.32 mycroft int
469 1.32 mycroft nfs_setattr(ap)
470 1.32 mycroft struct vop_setattr_args /* {
471 1.32 mycroft struct vnodeop_desc *a_desc;
472 1.32 mycroft struct vnode *a_vp;
473 1.32 mycroft struct vattr *a_vap;
474 1.32 mycroft struct ucred *a_cred;
475 1.32 mycroft struct proc *a_p;
476 1.32 mycroft } */ *ap;
477 1.1 cgd {
478 1.1 cgd register struct nfsv2_sattr *sp;
479 1.1 cgd register caddr_t cp;
480 1.1 cgd register long t1;
481 1.32 mycroft caddr_t bpos, dpos, cp2;
482 1.32 mycroft u_long *tl;
483 1.32 mycroft int error = 0, isnq;
484 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
485 1.32 mycroft register struct vnode *vp = ap->a_vp;
486 1.32 mycroft register struct nfsnode *np = VTONFS(vp);
487 1.32 mycroft register struct vattr *vap = ap->a_vap;
488 1.32 mycroft u_quad_t frev, tsize;
489 1.1 cgd
490 1.35 mycroft if (vap->va_size != VNOVAL) {
491 1.35 mycroft switch (vp->v_type) {
492 1.35 mycroft case VDIR:
493 1.35 mycroft return (EISDIR);
494 1.35 mycroft case VCHR:
495 1.35 mycroft case VBLK:
496 1.35 mycroft if (vap->va_mtime.ts_sec == VNOVAL &&
497 1.35 mycroft vap->va_atime.ts_sec == VNOVAL &&
498 1.35 mycroft vap->va_mode == (u_short)VNOVAL &&
499 1.35 mycroft vap->va_uid == VNOVAL &&
500 1.35 mycroft vap->va_gid == VNOVAL)
501 1.35 mycroft return (0);
502 1.35 mycroft vap->va_size = VNOVAL;
503 1.35 mycroft break;
504 1.35 mycroft default:
505 1.32 mycroft if (np->n_flag & NMODIFIED) {
506 1.35 mycroft if (vap->va_size == 0)
507 1.35 mycroft error = nfs_vinvalbuf(vp, 0,
508 1.35 mycroft ap->a_cred, ap->a_p, 1);
509 1.35 mycroft else
510 1.35 mycroft error = nfs_vinvalbuf(vp, V_SAVE,
511 1.35 mycroft ap->a_cred, ap->a_p, 1);
512 1.35 mycroft if (error)
513 1.35 mycroft return (error);
514 1.32 mycroft }
515 1.32 mycroft tsize = np->n_size;
516 1.32 mycroft np->n_size = np->n_vattr.va_size = vap->va_size;
517 1.32 mycroft vnode_pager_setsize(vp, (u_long)np->n_size);
518 1.35 mycroft }
519 1.35 mycroft } else if ((vap->va_mtime.ts_sec != VNOVAL ||
520 1.35 mycroft vap->va_atime.ts_sec != VNOVAL) && (np->n_flag & NMODIFIED)) {
521 1.35 mycroft error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_p, 1);
522 1.35 mycroft if (error == EINTR)
523 1.32 mycroft return (error);
524 1.32 mycroft }
525 1.1 cgd nfsstats.rpccnt[NFSPROC_SETATTR]++;
526 1.32 mycroft isnq = (VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NQNFS);
527 1.32 mycroft nfsm_reqhead(vp, NFSPROC_SETATTR, NFSX_FH+NFSX_SATTR(isnq));
528 1.1 cgd nfsm_fhtom(vp);
529 1.32 mycroft nfsm_build(sp, struct nfsv2_sattr *, NFSX_SATTR(isnq));
530 1.32 mycroft if (vap->va_mode == (u_short)-1)
531 1.1 cgd sp->sa_mode = VNOVAL;
532 1.1 cgd else
533 1.1 cgd sp->sa_mode = vtonfs_mode(vp->v_type, vap->va_mode);
534 1.32 mycroft if (vap->va_uid == (uid_t)-1)
535 1.1 cgd sp->sa_uid = VNOVAL;
536 1.1 cgd else
537 1.1 cgd sp->sa_uid = txdr_unsigned(vap->va_uid);
538 1.32 mycroft if (vap->va_gid == (gid_t)-1)
539 1.1 cgd sp->sa_gid = VNOVAL;
540 1.1 cgd else
541 1.1 cgd sp->sa_gid = txdr_unsigned(vap->va_gid);
542 1.32 mycroft if (isnq) {
543 1.32 mycroft txdr_hyper(&vap->va_size, &sp->sa_nqsize);
544 1.32 mycroft txdr_nqtime(&vap->va_atime, &sp->sa_nqatime);
545 1.32 mycroft txdr_nqtime(&vap->va_mtime, &sp->sa_nqmtime);
546 1.32 mycroft sp->sa_nqflags = txdr_unsigned(vap->va_flags);
547 1.32 mycroft sp->sa_nqrdev = VNOVAL;
548 1.24 mycroft } else {
549 1.32 mycroft sp->sa_nfssize = txdr_unsigned(vap->va_size);
550 1.32 mycroft txdr_nfstime(&vap->va_atime, &sp->sa_nfsatime);
551 1.32 mycroft txdr_nfstime(&vap->va_mtime, &sp->sa_nfsmtime);
552 1.24 mycroft }
553 1.32 mycroft nfsm_request(vp, NFSPROC_SETATTR, ap->a_p, ap->a_cred);
554 1.32 mycroft nfsm_loadattr(vp, (struct vattr *)0);
555 1.32 mycroft if ((VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NQNFS) &&
556 1.32 mycroft NQNFS_CKCACHABLE(vp, NQL_WRITE)) {
557 1.32 mycroft nfsm_dissect(tl, u_long *, 2*NFSX_UNSIGNED);
558 1.32 mycroft fxdr_hyper(tl, &frev);
559 1.32 mycroft if (frev > np->n_brev)
560 1.32 mycroft np->n_brev = frev;
561 1.24 mycroft }
562 1.32 mycroft nfsm_reqdone;
563 1.32 mycroft if (error) {
564 1.32 mycroft np->n_size = np->n_vattr.va_size = tsize;
565 1.32 mycroft vnode_pager_setsize(vp, (u_long)np->n_size);
566 1.1 cgd }
567 1.1 cgd return (error);
568 1.1 cgd }
569 1.1 cgd
570 1.1 cgd /*
571 1.1 cgd * nfs lookup call, one step at a time...
572 1.1 cgd * First look in cache
573 1.1 cgd * If not found, unlock the directory nfsnode and do the rpc
574 1.1 cgd */
575 1.32 mycroft int
576 1.32 mycroft nfs_lookup(ap)
577 1.32 mycroft struct vop_lookup_args /* {
578 1.32 mycroft struct vnodeop_desc *a_desc;
579 1.32 mycroft struct vnode *a_dvp;
580 1.32 mycroft struct vnode **a_vpp;
581 1.32 mycroft struct componentname *a_cnp;
582 1.32 mycroft } */ *ap;
583 1.32 mycroft {
584 1.32 mycroft register struct componentname *cnp = ap->a_cnp;
585 1.32 mycroft register struct vnode *dvp = ap->a_dvp;
586 1.32 mycroft register struct vnode **vpp = ap->a_vpp;
587 1.32 mycroft register int flags = cnp->cn_flags;
588 1.1 cgd register struct vnode *vdp;
589 1.1 cgd register u_long *tl;
590 1.1 cgd register caddr_t cp;
591 1.1 cgd register long t1, t2;
592 1.32 mycroft struct nfsmount *nmp;
593 1.1 cgd caddr_t bpos, dpos, cp2;
594 1.32 mycroft time_t reqtime;
595 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
596 1.1 cgd struct vnode *newvp;
597 1.1 cgd long len;
598 1.1 cgd nfsv2fh_t *fhp;
599 1.1 cgd struct nfsnode *np;
600 1.32 mycroft int lockparent, wantparent, error = 0;
601 1.32 mycroft int nqlflag, cachable;
602 1.32 mycroft u_quad_t frev;
603 1.1 cgd
604 1.32 mycroft *vpp = NULL;
605 1.32 mycroft if (dvp->v_type != VDIR)
606 1.1 cgd return (ENOTDIR);
607 1.32 mycroft lockparent = flags & LOCKPARENT;
608 1.32 mycroft wantparent = flags & (LOCKPARENT|WANTPARENT);
609 1.32 mycroft nmp = VFSTONFS(dvp->v_mount);
610 1.32 mycroft np = VTONFS(dvp);
611 1.32 mycroft if ((error = cache_lookup(dvp, vpp, cnp)) && error != ENOENT) {
612 1.1 cgd struct vattr vattr;
613 1.1 cgd int vpid;
614 1.1 cgd
615 1.32 mycroft vdp = *vpp;
616 1.1 cgd vpid = vdp->v_id;
617 1.1 cgd /*
618 1.1 cgd * See the comment starting `Step through' in ufs/ufs_lookup.c
619 1.1 cgd * for an explanation of the locking protocol
620 1.1 cgd */
621 1.32 mycroft if (dvp == vdp) {
622 1.1 cgd VREF(vdp);
623 1.1 cgd error = 0;
624 1.32 mycroft } else
625 1.30 cgd error = vget(vdp, 1);
626 1.1 cgd if (!error) {
627 1.1 cgd if (vpid == vdp->v_id) {
628 1.32 mycroft if (nmp->nm_flag & NFSMNT_NQNFS) {
629 1.32 mycroft if ((nmp->nm_flag & NFSMNT_NQLOOKLEASE) == 0) {
630 1.32 mycroft nfsstats.lookupcache_hits++;
631 1.32 mycroft if (cnp->cn_nameiop != LOOKUP &&
632 1.32 mycroft (flags & ISLASTCN))
633 1.32 mycroft cnp->cn_flags |= SAVENAME;
634 1.32 mycroft return (0);
635 1.32 mycroft } else if (NQNFS_CKCACHABLE(dvp, NQL_READ)) {
636 1.32 mycroft if (np->n_lrev != np->n_brev ||
637 1.32 mycroft (np->n_flag & NMODIFIED)) {
638 1.32 mycroft np->n_direofoffset = 0;
639 1.32 mycroft cache_purge(dvp);
640 1.32 mycroft error = nfs_vinvalbuf(dvp, 0,
641 1.32 mycroft cnp->cn_cred, cnp->cn_proc,
642 1.32 mycroft 1);
643 1.32 mycroft if (error == EINTR)
644 1.32 mycroft return (error);
645 1.32 mycroft np->n_brev = np->n_lrev;
646 1.32 mycroft } else {
647 1.32 mycroft nfsstats.lookupcache_hits++;
648 1.32 mycroft if (cnp->cn_nameiop != LOOKUP &&
649 1.32 mycroft (flags & ISLASTCN))
650 1.32 mycroft cnp->cn_flags |= SAVENAME;
651 1.32 mycroft return (0);
652 1.32 mycroft }
653 1.32 mycroft }
654 1.32 mycroft } else if (!VOP_GETATTR(vdp, &vattr, cnp->cn_cred, cnp->cn_proc) &&
655 1.30 cgd vattr.va_ctime.ts_sec == VTONFS(vdp)->n_ctime) {
656 1.1 cgd nfsstats.lookupcache_hits++;
657 1.32 mycroft if (cnp->cn_nameiop != LOOKUP &&
658 1.32 mycroft (flags & ISLASTCN))
659 1.32 mycroft cnp->cn_flags |= SAVENAME;
660 1.1 cgd return (0);
661 1.1 cgd }
662 1.1 cgd cache_purge(vdp);
663 1.1 cgd }
664 1.32 mycroft vrele(vdp);
665 1.1 cgd }
666 1.32 mycroft *vpp = NULLVP;
667 1.32 mycroft }
668 1.1 cgd error = 0;
669 1.1 cgd nfsstats.lookupcache_misses++;
670 1.1 cgd nfsstats.rpccnt[NFSPROC_LOOKUP]++;
671 1.32 mycroft len = cnp->cn_namelen;
672 1.32 mycroft nfsm_reqhead(dvp, NFSPROC_LOOKUP, NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(len));
673 1.32 mycroft
674 1.32 mycroft /*
675 1.32 mycroft * For nqnfs optionally piggyback a getlease request for the name
676 1.32 mycroft * being looked up.
677 1.32 mycroft */
678 1.32 mycroft if (nmp->nm_flag & NFSMNT_NQNFS) {
679 1.32 mycroft nfsm_build(tl, u_long *, NFSX_UNSIGNED);
680 1.32 mycroft if ((nmp->nm_flag & NFSMNT_NQLOOKLEASE) &&
681 1.32 mycroft ((cnp->cn_flags & MAKEENTRY) &&
682 1.32 mycroft (cnp->cn_nameiop != DELETE || !(flags & ISLASTCN))))
683 1.32 mycroft *tl = txdr_unsigned(nmp->nm_leaseterm);
684 1.32 mycroft else
685 1.32 mycroft *tl = 0;
686 1.32 mycroft }
687 1.32 mycroft nfsm_fhtom(dvp);
688 1.32 mycroft nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN);
689 1.32 mycroft reqtime = time.tv_sec;
690 1.32 mycroft nfsm_request(dvp, NFSPROC_LOOKUP, cnp->cn_proc, cnp->cn_cred);
691 1.1 cgd nfsmout:
692 1.1 cgd if (error) {
693 1.32 mycroft if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME) &&
694 1.32 mycroft (flags & ISLASTCN) && error == ENOENT)
695 1.14 cgd error = EJUSTRETURN;
696 1.32 mycroft if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
697 1.32 mycroft cnp->cn_flags |= SAVENAME;
698 1.1 cgd return (error);
699 1.1 cgd }
700 1.32 mycroft if (nmp->nm_flag & NFSMNT_NQNFS) {
701 1.32 mycroft nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
702 1.32 mycroft if (*tl) {
703 1.32 mycroft nqlflag = fxdr_unsigned(int, *tl);
704 1.32 mycroft nfsm_dissect(tl, u_long *, 4*NFSX_UNSIGNED);
705 1.32 mycroft cachable = fxdr_unsigned(int, *tl++);
706 1.32 mycroft reqtime += fxdr_unsigned(int, *tl++);
707 1.32 mycroft fxdr_hyper(tl, &frev);
708 1.32 mycroft } else
709 1.32 mycroft nqlflag = 0;
710 1.32 mycroft }
711 1.32 mycroft nfsm_dissect(fhp, nfsv2fh_t *, NFSX_FH);
712 1.1 cgd
713 1.1 cgd /*
714 1.32 mycroft * Handle RENAME case...
715 1.1 cgd */
716 1.32 mycroft if (cnp->cn_nameiop == RENAME && wantparent && (flags & ISLASTCN)) {
717 1.32 mycroft if (!bcmp(np->n_fh.fh_bytes, (caddr_t)fhp, NFSX_FH)) {
718 1.1 cgd m_freem(mrep);
719 1.1 cgd return (EISDIR);
720 1.1 cgd }
721 1.32 mycroft if (error = nfs_nget(dvp->v_mount, fhp, &np)) {
722 1.1 cgd m_freem(mrep);
723 1.1 cgd return (error);
724 1.1 cgd }
725 1.1 cgd newvp = NFSTOV(np);
726 1.1 cgd if (error =
727 1.1 cgd nfs_loadattrcache(&newvp, &md, &dpos, (struct vattr *)0)) {
728 1.32 mycroft vrele(newvp);
729 1.1 cgd m_freem(mrep);
730 1.1 cgd return (error);
731 1.1 cgd }
732 1.32 mycroft *vpp = newvp;
733 1.1 cgd m_freem(mrep);
734 1.32 mycroft cnp->cn_flags |= SAVENAME;
735 1.1 cgd return (0);
736 1.1 cgd }
737 1.1 cgd
738 1.32 mycroft if (!bcmp(np->n_fh.fh_bytes, (caddr_t)fhp, NFSX_FH)) {
739 1.32 mycroft VREF(dvp);
740 1.32 mycroft newvp = dvp;
741 1.1 cgd } else {
742 1.32 mycroft if (error = nfs_nget(dvp->v_mount, fhp, &np)) {
743 1.1 cgd m_freem(mrep);
744 1.1 cgd return (error);
745 1.1 cgd }
746 1.1 cgd newvp = NFSTOV(np);
747 1.1 cgd }
748 1.1 cgd if (error = nfs_loadattrcache(&newvp, &md, &dpos, (struct vattr *)0)) {
749 1.32 mycroft vrele(newvp);
750 1.1 cgd m_freem(mrep);
751 1.1 cgd return (error);
752 1.1 cgd }
753 1.1 cgd m_freem(mrep);
754 1.32 mycroft *vpp = newvp;
755 1.32 mycroft if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
756 1.32 mycroft cnp->cn_flags |= SAVENAME;
757 1.32 mycroft if ((cnp->cn_flags & MAKEENTRY) &&
758 1.32 mycroft (cnp->cn_nameiop != DELETE || !(flags & ISLASTCN))) {
759 1.32 mycroft if ((nmp->nm_flag & NFSMNT_NQNFS) == 0)
760 1.32 mycroft np->n_ctime = np->n_vattr.va_ctime.ts_sec;
761 1.32 mycroft else if (nqlflag && reqtime > time.tv_sec)
762 1.32 mycroft nqnfs_clientlease(nmp, np, nqlflag, cachable, reqtime,
763 1.32 mycroft frev);
764 1.32 mycroft cache_enter(dvp, *vpp, cnp);
765 1.1 cgd }
766 1.32 mycroft return (0);
767 1.1 cgd }
768 1.1 cgd
769 1.1 cgd /*
770 1.1 cgd * nfs read call.
771 1.1 cgd * Just call nfs_bioread() to do the work.
772 1.1 cgd */
773 1.32 mycroft int
774 1.32 mycroft nfs_read(ap)
775 1.32 mycroft struct vop_read_args /* {
776 1.32 mycroft struct vnode *a_vp;
777 1.32 mycroft struct uio *a_uio;
778 1.32 mycroft int a_ioflag;
779 1.32 mycroft struct ucred *a_cred;
780 1.32 mycroft } */ *ap;
781 1.1 cgd {
782 1.32 mycroft register struct vnode *vp = ap->a_vp;
783 1.32 mycroft
784 1.1 cgd if (vp->v_type != VREG)
785 1.1 cgd return (EPERM);
786 1.32 mycroft return (nfs_bioread(vp, ap->a_uio, ap->a_ioflag, ap->a_cred));
787 1.1 cgd }
788 1.1 cgd
789 1.1 cgd /*
790 1.1 cgd * nfs readlink call
791 1.1 cgd */
792 1.32 mycroft int
793 1.32 mycroft nfs_readlink(ap)
794 1.32 mycroft struct vop_readlink_args /* {
795 1.32 mycroft struct vnode *a_vp;
796 1.32 mycroft struct uio *a_uio;
797 1.32 mycroft struct ucred *a_cred;
798 1.32 mycroft } */ *ap;
799 1.1 cgd {
800 1.32 mycroft register struct vnode *vp = ap->a_vp;
801 1.32 mycroft
802 1.1 cgd if (vp->v_type != VLNK)
803 1.1 cgd return (EPERM);
804 1.32 mycroft return (nfs_bioread(vp, ap->a_uio, 0, ap->a_cred));
805 1.1 cgd }
806 1.1 cgd
807 1.1 cgd /*
808 1.1 cgd * Do a readlink rpc.
809 1.1 cgd * Called by nfs_doio() from below the buffer cache.
810 1.1 cgd */
811 1.32 mycroft int
812 1.1 cgd nfs_readlinkrpc(vp, uiop, cred)
813 1.1 cgd register struct vnode *vp;
814 1.1 cgd struct uio *uiop;
815 1.1 cgd struct ucred *cred;
816 1.1 cgd {
817 1.1 cgd register u_long *tl;
818 1.1 cgd register caddr_t cp;
819 1.1 cgd register long t1;
820 1.1 cgd caddr_t bpos, dpos, cp2;
821 1.1 cgd int error = 0;
822 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
823 1.1 cgd long len;
824 1.1 cgd
825 1.1 cgd nfsstats.rpccnt[NFSPROC_READLINK]++;
826 1.32 mycroft nfsm_reqhead(vp, NFSPROC_READLINK, NFSX_FH);
827 1.1 cgd nfsm_fhtom(vp);
828 1.32 mycroft nfsm_request(vp, NFSPROC_READLINK, uiop->uio_procp, cred);
829 1.1 cgd nfsm_strsiz(len, NFS_MAXPATHLEN);
830 1.1 cgd nfsm_mtouio(uiop, len);
831 1.1 cgd nfsm_reqdone;
832 1.1 cgd return (error);
833 1.1 cgd }
834 1.1 cgd
835 1.1 cgd /*
836 1.1 cgd * nfs read rpc call
837 1.1 cgd * Ditto above
838 1.1 cgd */
839 1.32 mycroft int
840 1.1 cgd nfs_readrpc(vp, uiop, cred)
841 1.1 cgd register struct vnode *vp;
842 1.1 cgd struct uio *uiop;
843 1.1 cgd struct ucred *cred;
844 1.1 cgd {
845 1.1 cgd register u_long *tl;
846 1.1 cgd register caddr_t cp;
847 1.1 cgd register long t1;
848 1.1 cgd caddr_t bpos, dpos, cp2;
849 1.1 cgd int error = 0;
850 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
851 1.1 cgd struct nfsmount *nmp;
852 1.1 cgd long len, retlen, tsiz;
853 1.1 cgd
854 1.1 cgd nmp = VFSTONFS(vp->v_mount);
855 1.1 cgd tsiz = uiop->uio_resid;
856 1.32 mycroft if (uiop->uio_offset + tsiz > 0xffffffff &&
857 1.32 mycroft (nmp->nm_flag & NFSMNT_NQNFS) == 0)
858 1.32 mycroft return (EFBIG);
859 1.1 cgd while (tsiz > 0) {
860 1.1 cgd nfsstats.rpccnt[NFSPROC_READ]++;
861 1.1 cgd len = (tsiz > nmp->nm_rsize) ? nmp->nm_rsize : tsiz;
862 1.32 mycroft nfsm_reqhead(vp, NFSPROC_READ, NFSX_FH+NFSX_UNSIGNED*3);
863 1.1 cgd nfsm_fhtom(vp);
864 1.1 cgd nfsm_build(tl, u_long *, NFSX_UNSIGNED*3);
865 1.32 mycroft if (nmp->nm_flag & NFSMNT_NQNFS) {
866 1.32 mycroft txdr_hyper(&uiop->uio_offset, tl);
867 1.32 mycroft *(tl + 2) = txdr_unsigned(len);
868 1.32 mycroft } else {
869 1.32 mycroft *tl++ = txdr_unsigned(uiop->uio_offset);
870 1.32 mycroft *tl++ = txdr_unsigned(len);
871 1.32 mycroft *tl = 0;
872 1.32 mycroft }
873 1.32 mycroft nfsm_request(vp, NFSPROC_READ, uiop->uio_procp, cred);
874 1.1 cgd nfsm_loadattr(vp, (struct vattr *)0);
875 1.1 cgd nfsm_strsiz(retlen, nmp->nm_rsize);
876 1.1 cgd nfsm_mtouio(uiop, retlen);
877 1.1 cgd m_freem(mrep);
878 1.1 cgd if (retlen < len)
879 1.1 cgd tsiz = 0;
880 1.1 cgd else
881 1.1 cgd tsiz -= len;
882 1.1 cgd }
883 1.1 cgd nfsmout:
884 1.1 cgd return (error);
885 1.1 cgd }
886 1.1 cgd
887 1.1 cgd /*
888 1.1 cgd * nfs write call
889 1.1 cgd */
890 1.32 mycroft int
891 1.32 mycroft nfs_writerpc(vp, uiop, cred, ioflags)
892 1.1 cgd register struct vnode *vp;
893 1.1 cgd struct uio *uiop;
894 1.1 cgd struct ucred *cred;
895 1.32 mycroft int ioflags;
896 1.1 cgd {
897 1.1 cgd register u_long *tl;
898 1.1 cgd register caddr_t cp;
899 1.1 cgd register long t1;
900 1.32 mycroft caddr_t bpos, dpos, cp2;
901 1.1 cgd int error = 0;
902 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
903 1.1 cgd struct nfsmount *nmp;
904 1.32 mycroft struct nfsnode *np = VTONFS(vp);
905 1.32 mycroft u_quad_t frev;
906 1.1 cgd long len, tsiz;
907 1.1 cgd
908 1.1 cgd nmp = VFSTONFS(vp->v_mount);
909 1.1 cgd tsiz = uiop->uio_resid;
910 1.32 mycroft if (uiop->uio_offset + tsiz > 0xffffffff &&
911 1.32 mycroft (nmp->nm_flag & NFSMNT_NQNFS) == 0)
912 1.32 mycroft return (EFBIG);
913 1.1 cgd while (tsiz > 0) {
914 1.1 cgd nfsstats.rpccnt[NFSPROC_WRITE]++;
915 1.1 cgd len = (tsiz > nmp->nm_wsize) ? nmp->nm_wsize : tsiz;
916 1.32 mycroft nfsm_reqhead(vp, NFSPROC_WRITE,
917 1.32 mycroft NFSX_FH+NFSX_UNSIGNED*4+nfsm_rndup(len));
918 1.1 cgd nfsm_fhtom(vp);
919 1.32 mycroft nfsm_build(tl, u_long *, NFSX_UNSIGNED * 4);
920 1.32 mycroft if (nmp->nm_flag & NFSMNT_NQNFS) {
921 1.32 mycroft txdr_hyper(&uiop->uio_offset, tl);
922 1.32 mycroft tl += 2;
923 1.42 mycroft *tl++ = 0;
924 1.32 mycroft } else {
925 1.32 mycroft *++tl = txdr_unsigned(uiop->uio_offset);
926 1.32 mycroft tl += 2;
927 1.32 mycroft }
928 1.32 mycroft *tl = txdr_unsigned(len);
929 1.1 cgd nfsm_uiotom(uiop, len);
930 1.32 mycroft nfsm_request(vp, NFSPROC_WRITE, uiop->uio_procp, cred);
931 1.1 cgd nfsm_loadattr(vp, (struct vattr *)0);
932 1.32 mycroft if (nmp->nm_flag & NFSMNT_MYWRITE)
933 1.32 mycroft VTONFS(vp)->n_mtime = VTONFS(vp)->n_vattr.va_mtime.ts_sec;
934 1.32 mycroft else if ((nmp->nm_flag & NFSMNT_NQNFS) &&
935 1.32 mycroft NQNFS_CKCACHABLE(vp, NQL_WRITE)) {
936 1.32 mycroft nfsm_dissect(tl, u_long *, 2*NFSX_UNSIGNED);
937 1.32 mycroft fxdr_hyper(tl, &frev);
938 1.32 mycroft if (frev > np->n_brev)
939 1.32 mycroft np->n_brev = frev;
940 1.32 mycroft }
941 1.1 cgd m_freem(mrep);
942 1.1 cgd tsiz -= len;
943 1.1 cgd }
944 1.1 cgd nfsmout:
945 1.32 mycroft if (error)
946 1.32 mycroft uiop->uio_resid = tsiz;
947 1.1 cgd return (error);
948 1.1 cgd }
949 1.1 cgd
950 1.1 cgd /*
951 1.1 cgd * nfs mknod call
952 1.1 cgd * This is a kludge. Use a create rpc but with the IFMT bits of the mode
953 1.1 cgd * set to specify the file type and the size field for rdev.
954 1.1 cgd */
955 1.1 cgd /* ARGSUSED */
956 1.32 mycroft int
957 1.32 mycroft nfs_mknod(ap)
958 1.32 mycroft struct vop_mknod_args /* {
959 1.32 mycroft struct vnode *a_dvp;
960 1.32 mycroft struct vnode **a_vpp;
961 1.32 mycroft struct componentname *a_cnp;
962 1.32 mycroft struct vattr *a_vap;
963 1.32 mycroft } */ *ap;
964 1.32 mycroft {
965 1.32 mycroft register struct vnode *dvp = ap->a_dvp;
966 1.32 mycroft register struct vattr *vap = ap->a_vap;
967 1.32 mycroft register struct componentname *cnp = ap->a_cnp;
968 1.1 cgd register struct nfsv2_sattr *sp;
969 1.1 cgd register u_long *tl;
970 1.1 cgd register caddr_t cp;
971 1.1 cgd register long t1, t2;
972 1.32 mycroft struct vnode *newvp;
973 1.32 mycroft struct vattr vattr;
974 1.32 mycroft char *cp2;
975 1.1 cgd caddr_t bpos, dpos;
976 1.32 mycroft int error = 0, isnq;
977 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
978 1.1 cgd u_long rdev;
979 1.1 cgd
980 1.32 mycroft isnq = (VFSTONFS(dvp->v_mount)->nm_flag & NFSMNT_NQNFS);
981 1.1 cgd if (vap->va_type == VCHR || vap->va_type == VBLK)
982 1.1 cgd rdev = txdr_unsigned(vap->va_rdev);
983 1.1 cgd #ifdef FIFO
984 1.1 cgd else if (vap->va_type == VFIFO)
985 1.1 cgd rdev = 0xffffffff;
986 1.1 cgd #endif /* FIFO */
987 1.1 cgd else {
988 1.32 mycroft VOP_ABORTOP(dvp, cnp);
989 1.32 mycroft vput(dvp);
990 1.1 cgd return (EOPNOTSUPP);
991 1.1 cgd }
992 1.32 mycroft if (error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc)) {
993 1.32 mycroft VOP_ABORTOP(dvp, cnp);
994 1.32 mycroft vput(dvp);
995 1.32 mycroft return (error);
996 1.32 mycroft }
997 1.40 pk newvp = NULLVP;
998 1.1 cgd nfsstats.rpccnt[NFSPROC_CREATE]++;
999 1.32 mycroft nfsm_reqhead(dvp, NFSPROC_CREATE,
1000 1.32 mycroft NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(cnp->cn_namelen)+NFSX_SATTR(isnq));
1001 1.32 mycroft nfsm_fhtom(dvp);
1002 1.32 mycroft nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
1003 1.32 mycroft nfsm_build(sp, struct nfsv2_sattr *, NFSX_SATTR(isnq));
1004 1.1 cgd sp->sa_mode = vtonfs_mode(vap->va_type, vap->va_mode);
1005 1.32 mycroft sp->sa_uid = txdr_unsigned(cnp->cn_cred->cr_uid);
1006 1.32 mycroft sp->sa_gid = txdr_unsigned(vattr.va_gid);
1007 1.32 mycroft if (isnq) {
1008 1.32 mycroft sp->sa_nqrdev = rdev;
1009 1.32 mycroft sp->sa_nqflags = 0;
1010 1.32 mycroft txdr_nqtime(&vap->va_atime, &sp->sa_nqatime);
1011 1.32 mycroft txdr_nqtime(&vap->va_mtime, &sp->sa_nqmtime);
1012 1.32 mycroft } else {
1013 1.32 mycroft sp->sa_nfssize = rdev;
1014 1.32 mycroft txdr_nfstime(&vap->va_atime, &sp->sa_nfsatime);
1015 1.32 mycroft txdr_nfstime(&vap->va_mtime, &sp->sa_nfsmtime);
1016 1.32 mycroft }
1017 1.32 mycroft nfsm_request(dvp, NFSPROC_CREATE, cnp->cn_proc, cnp->cn_cred);
1018 1.32 mycroft nfsm_mtofh(dvp, newvp);
1019 1.1 cgd nfsm_reqdone;
1020 1.32 mycroft if (!error && (cnp->cn_flags & MAKEENTRY))
1021 1.32 mycroft cache_enter(dvp, newvp, cnp);
1022 1.32 mycroft FREE(cnp->cn_pnbuf, M_NAMEI);
1023 1.32 mycroft VTONFS(dvp)->n_flag |= NMODIFIED;
1024 1.32 mycroft VTONFS(dvp)->n_attrstamp = 0;
1025 1.32 mycroft vrele(dvp);
1026 1.40 pk if (newvp != NULLVP)
1027 1.40 pk vrele(newvp);
1028 1.1 cgd return (error);
1029 1.1 cgd }
1030 1.1 cgd
1031 1.1 cgd /*
1032 1.1 cgd * nfs file create call
1033 1.1 cgd */
1034 1.32 mycroft int
1035 1.32 mycroft nfs_create(ap)
1036 1.32 mycroft struct vop_create_args /* {
1037 1.32 mycroft struct vnode *a_dvp;
1038 1.32 mycroft struct vnode **a_vpp;
1039 1.32 mycroft struct componentname *a_cnp;
1040 1.32 mycroft struct vattr *a_vap;
1041 1.32 mycroft } */ *ap;
1042 1.32 mycroft {
1043 1.32 mycroft register struct vnode *dvp = ap->a_dvp;
1044 1.32 mycroft register struct vattr *vap = ap->a_vap;
1045 1.32 mycroft register struct componentname *cnp = ap->a_cnp;
1046 1.1 cgd register struct nfsv2_sattr *sp;
1047 1.1 cgd register u_long *tl;
1048 1.1 cgd register caddr_t cp;
1049 1.1 cgd register long t1, t2;
1050 1.1 cgd caddr_t bpos, dpos, cp2;
1051 1.32 mycroft int error = 0, isnq;
1052 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1053 1.32 mycroft struct vattr vattr;
1054 1.1 cgd
1055 1.32 mycroft if (error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc)) {
1056 1.32 mycroft VOP_ABORTOP(dvp, cnp);
1057 1.32 mycroft vput(dvp);
1058 1.32 mycroft return (error);
1059 1.32 mycroft }
1060 1.1 cgd nfsstats.rpccnt[NFSPROC_CREATE]++;
1061 1.32 mycroft isnq = (VFSTONFS(dvp->v_mount)->nm_flag & NFSMNT_NQNFS);
1062 1.32 mycroft nfsm_reqhead(dvp, NFSPROC_CREATE,
1063 1.32 mycroft NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(cnp->cn_namelen)+NFSX_SATTR(isnq));
1064 1.32 mycroft nfsm_fhtom(dvp);
1065 1.32 mycroft nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
1066 1.32 mycroft nfsm_build(sp, struct nfsv2_sattr *, NFSX_SATTR(isnq));
1067 1.1 cgd sp->sa_mode = vtonfs_mode(vap->va_type, vap->va_mode);
1068 1.32 mycroft sp->sa_uid = txdr_unsigned(cnp->cn_cred->cr_uid);
1069 1.32 mycroft sp->sa_gid = txdr_unsigned(vattr.va_gid);
1070 1.32 mycroft if (isnq) {
1071 1.32 mycroft u_quad_t qval = 0;
1072 1.32 mycroft
1073 1.32 mycroft txdr_hyper(&qval, &sp->sa_nqsize);
1074 1.32 mycroft sp->sa_nqflags = 0;
1075 1.32 mycroft sp->sa_nqrdev = -1;
1076 1.32 mycroft txdr_nqtime(&vap->va_atime, &sp->sa_nqatime);
1077 1.32 mycroft txdr_nqtime(&vap->va_mtime, &sp->sa_nqmtime);
1078 1.32 mycroft } else {
1079 1.32 mycroft sp->sa_nfssize = 0;
1080 1.32 mycroft txdr_nfstime(&vap->va_atime, &sp->sa_nfsatime);
1081 1.32 mycroft txdr_nfstime(&vap->va_mtime, &sp->sa_nfsmtime);
1082 1.32 mycroft }
1083 1.32 mycroft nfsm_request(dvp, NFSPROC_CREATE, cnp->cn_proc, cnp->cn_cred);
1084 1.32 mycroft nfsm_mtofh(dvp, *ap->a_vpp);
1085 1.1 cgd nfsm_reqdone;
1086 1.32 mycroft if (!error && (cnp->cn_flags & MAKEENTRY))
1087 1.32 mycroft cache_enter(dvp, *ap->a_vpp, cnp);
1088 1.32 mycroft FREE(cnp->cn_pnbuf, M_NAMEI);
1089 1.32 mycroft VTONFS(dvp)->n_flag |= NMODIFIED;
1090 1.32 mycroft VTONFS(dvp)->n_attrstamp = 0;
1091 1.32 mycroft vrele(dvp);
1092 1.1 cgd return (error);
1093 1.1 cgd }
1094 1.1 cgd
1095 1.1 cgd /*
1096 1.1 cgd * nfs file remove call
1097 1.1 cgd * To try and make nfs semantics closer to ufs semantics, a file that has
1098 1.1 cgd * other processes using the vnode is renamed instead of removed and then
1099 1.1 cgd * removed later on the last close.
1100 1.1 cgd * - If v_usecount > 1
1101 1.1 cgd * If a rename is not already in the works
1102 1.1 cgd * call nfs_sillyrename() to set it up
1103 1.1 cgd * else
1104 1.1 cgd * do the remove rpc
1105 1.1 cgd */
1106 1.32 mycroft int
1107 1.32 mycroft nfs_remove(ap)
1108 1.32 mycroft struct vop_remove_args /* {
1109 1.32 mycroft struct vnodeop_desc *a_desc;
1110 1.32 mycroft struct vnode * a_dvp;
1111 1.32 mycroft struct vnode * a_vp;
1112 1.32 mycroft struct componentname * a_cnp;
1113 1.32 mycroft } */ *ap;
1114 1.32 mycroft {
1115 1.32 mycroft register struct vnode *vp = ap->a_vp;
1116 1.32 mycroft register struct vnode *dvp = ap->a_dvp;
1117 1.32 mycroft register struct componentname *cnp = ap->a_cnp;
1118 1.32 mycroft register struct nfsnode *np = VTONFS(vp);
1119 1.1 cgd register u_long *tl;
1120 1.1 cgd register caddr_t cp;
1121 1.32 mycroft register long t2;
1122 1.1 cgd caddr_t bpos, dpos;
1123 1.1 cgd int error = 0;
1124 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1125 1.38 pk struct vattr vattr;
1126 1.1 cgd
1127 1.1 cgd if (vp->v_usecount > 1) {
1128 1.1 cgd if (!np->n_sillyrename)
1129 1.32 mycroft error = nfs_sillyrename(dvp, vp, cnp);
1130 1.38 pk else if (VOP_GETATTR(vp, &vattr, cnp->cn_cred, cnp->cn_proc)
1131 1.38 pk == 0 && vattr.va_nlink > 1)
1132 1.38 pk /*
1133 1.38 pk * If we already have a silly name but there are more
1134 1.38 pk * than one links, just proceed with the NFS remove
1135 1.38 pk * request, as the bits will remain available (modulo
1136 1.38 pk * network races). This avoids silently ignoring the
1137 1.38 pk * attempted removal of a non-silly entry.
1138 1.38 pk */
1139 1.38 pk goto doit;
1140 1.20 pk } else {
1141 1.38 pk doit:
1142 1.32 mycroft /*
1143 1.32 mycroft * Purge the name cache so that the chance of a lookup for
1144 1.32 mycroft * the name succeeding while the remove is in progress is
1145 1.32 mycroft * minimized. Without node locking it can still happen, such
1146 1.32 mycroft * that an I/O op returns ESTALE, but since you get this if
1147 1.32 mycroft * another host removes the file..
1148 1.32 mycroft */
1149 1.32 mycroft cache_purge(vp);
1150 1.32 mycroft /*
1151 1.32 mycroft * Throw away biocache buffers. Mainly to avoid
1152 1.32 mycroft * unnecessary delayed writes.
1153 1.32 mycroft */
1154 1.32 mycroft error = nfs_vinvalbuf(vp, 0, cnp->cn_cred, cnp->cn_proc, 1);
1155 1.32 mycroft if (error == EINTR)
1156 1.32 mycroft return (error);
1157 1.32 mycroft /* Do the rpc */
1158 1.1 cgd nfsstats.rpccnt[NFSPROC_REMOVE]++;
1159 1.32 mycroft nfsm_reqhead(dvp, NFSPROC_REMOVE,
1160 1.32 mycroft NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(cnp->cn_namelen));
1161 1.32 mycroft nfsm_fhtom(dvp);
1162 1.32 mycroft nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
1163 1.32 mycroft nfsm_request(dvp, NFSPROC_REMOVE, cnp->cn_proc, cnp->cn_cred);
1164 1.1 cgd nfsm_reqdone;
1165 1.32 mycroft FREE(cnp->cn_pnbuf, M_NAMEI);
1166 1.32 mycroft VTONFS(dvp)->n_flag |= NMODIFIED;
1167 1.32 mycroft VTONFS(dvp)->n_attrstamp = 0;
1168 1.1 cgd /*
1169 1.1 cgd * Kludge City: If the first reply to the remove rpc is lost..
1170 1.1 cgd * the reply to the retransmitted request will be ENOENT
1171 1.1 cgd * since the file was in fact removed
1172 1.1 cgd * Therefore, we cheat and return success.
1173 1.1 cgd */
1174 1.1 cgd if (error == ENOENT)
1175 1.1 cgd error = 0;
1176 1.1 cgd }
1177 1.1 cgd np->n_attrstamp = 0;
1178 1.32 mycroft vrele(dvp);
1179 1.32 mycroft vrele(vp);
1180 1.1 cgd return (error);
1181 1.1 cgd }
1182 1.1 cgd
1183 1.1 cgd /*
1184 1.1 cgd * nfs file remove rpc called from nfs_inactive
1185 1.1 cgd */
1186 1.32 mycroft int
1187 1.32 mycroft nfs_removeit(sp)
1188 1.1 cgd register struct sillyrename *sp;
1189 1.1 cgd {
1190 1.1 cgd register u_long *tl;
1191 1.1 cgd register caddr_t cp;
1192 1.32 mycroft register long t2;
1193 1.1 cgd caddr_t bpos, dpos;
1194 1.1 cgd int error = 0;
1195 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1196 1.1 cgd
1197 1.1 cgd nfsstats.rpccnt[NFSPROC_REMOVE]++;
1198 1.32 mycroft nfsm_reqhead(sp->s_dvp, NFSPROC_REMOVE,
1199 1.1 cgd NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(sp->s_namlen));
1200 1.1 cgd nfsm_fhtom(sp->s_dvp);
1201 1.1 cgd nfsm_strtom(sp->s_name, sp->s_namlen, NFS_MAXNAMLEN);
1202 1.32 mycroft nfsm_request(sp->s_dvp, NFSPROC_REMOVE, NULL, sp->s_cred);
1203 1.1 cgd nfsm_reqdone;
1204 1.1 cgd VTONFS(sp->s_dvp)->n_flag |= NMODIFIED;
1205 1.32 mycroft VTONFS(sp->s_dvp)->n_attrstamp = 0;
1206 1.1 cgd return (error);
1207 1.1 cgd }
1208 1.1 cgd
1209 1.1 cgd /*
1210 1.1 cgd * nfs file rename call
1211 1.1 cgd */
1212 1.32 mycroft int
1213 1.32 mycroft nfs_rename(ap)
1214 1.32 mycroft struct vop_rename_args /* {
1215 1.32 mycroft struct vnode *a_fdvp;
1216 1.32 mycroft struct vnode *a_fvp;
1217 1.32 mycroft struct componentname *a_fcnp;
1218 1.32 mycroft struct vnode *a_tdvp;
1219 1.32 mycroft struct vnode *a_tvp;
1220 1.32 mycroft struct componentname *a_tcnp;
1221 1.32 mycroft } */ *ap;
1222 1.32 mycroft {
1223 1.32 mycroft register struct vnode *fvp = ap->a_fvp;
1224 1.32 mycroft register struct vnode *tvp = ap->a_tvp;
1225 1.32 mycroft register struct vnode *fdvp = ap->a_fdvp;
1226 1.32 mycroft register struct vnode *tdvp = ap->a_tdvp;
1227 1.32 mycroft register struct componentname *tcnp = ap->a_tcnp;
1228 1.32 mycroft register struct componentname *fcnp = ap->a_fcnp;
1229 1.1 cgd register u_long *tl;
1230 1.1 cgd register caddr_t cp;
1231 1.32 mycroft register long t2;
1232 1.1 cgd caddr_t bpos, dpos;
1233 1.1 cgd int error = 0;
1234 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1235 1.17 cgd
1236 1.17 cgd /* Check for cross-device rename */
1237 1.17 cgd if ((fvp->v_mount != tdvp->v_mount) ||
1238 1.17 cgd (tvp && (fvp->v_mount != tvp->v_mount))) {
1239 1.17 cgd error = EXDEV;
1240 1.17 cgd goto out;
1241 1.17 cgd }
1242 1.1 cgd
1243 1.32 mycroft
1244 1.1 cgd nfsstats.rpccnt[NFSPROC_RENAME]++;
1245 1.32 mycroft nfsm_reqhead(fdvp, NFSPROC_RENAME,
1246 1.32 mycroft (NFSX_FH+NFSX_UNSIGNED)*2+nfsm_rndup(fcnp->cn_namelen)+
1247 1.32 mycroft nfsm_rndup(fcnp->cn_namelen)); /* or fcnp->cn_cred?*/
1248 1.32 mycroft nfsm_fhtom(fdvp);
1249 1.32 mycroft nfsm_strtom(fcnp->cn_nameptr, fcnp->cn_namelen, NFS_MAXNAMLEN);
1250 1.32 mycroft nfsm_fhtom(tdvp);
1251 1.32 mycroft nfsm_strtom(tcnp->cn_nameptr, tcnp->cn_namelen, NFS_MAXNAMLEN);
1252 1.32 mycroft nfsm_request(fdvp, NFSPROC_RENAME, tcnp->cn_proc, tcnp->cn_cred);
1253 1.1 cgd nfsm_reqdone;
1254 1.32 mycroft VTONFS(fdvp)->n_flag |= NMODIFIED;
1255 1.32 mycroft VTONFS(fdvp)->n_attrstamp = 0;
1256 1.32 mycroft VTONFS(tdvp)->n_flag |= NMODIFIED;
1257 1.32 mycroft VTONFS(tdvp)->n_attrstamp = 0;
1258 1.32 mycroft if (fvp->v_type == VDIR) {
1259 1.32 mycroft if (tvp != NULL && tvp->v_type == VDIR)
1260 1.32 mycroft cache_purge(tdvp);
1261 1.32 mycroft cache_purge(fdvp);
1262 1.1 cgd }
1263 1.17 cgd out:
1264 1.32 mycroft if (tdvp == tvp)
1265 1.32 mycroft vrele(tdvp);
1266 1.1 cgd else
1267 1.32 mycroft vput(tdvp);
1268 1.32 mycroft if (tvp)
1269 1.32 mycroft vput(tvp);
1270 1.32 mycroft vrele(fdvp);
1271 1.32 mycroft vrele(fvp);
1272 1.1 cgd /*
1273 1.1 cgd * Kludge: Map ENOENT => 0 assuming that it is a reply to a retry.
1274 1.1 cgd */
1275 1.1 cgd if (error == ENOENT)
1276 1.1 cgd error = 0;
1277 1.1 cgd return (error);
1278 1.1 cgd }
1279 1.1 cgd
1280 1.1 cgd /*
1281 1.1 cgd * nfs file rename rpc called from nfs_remove() above
1282 1.1 cgd */
1283 1.32 mycroft int
1284 1.32 mycroft nfs_renameit(sdvp, scnp, sp)
1285 1.32 mycroft struct vnode *sdvp;
1286 1.32 mycroft struct componentname *scnp;
1287 1.1 cgd register struct sillyrename *sp;
1288 1.1 cgd {
1289 1.1 cgd register u_long *tl;
1290 1.1 cgd register caddr_t cp;
1291 1.32 mycroft register long t2;
1292 1.1 cgd caddr_t bpos, dpos;
1293 1.1 cgd int error = 0;
1294 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1295 1.1 cgd
1296 1.1 cgd nfsstats.rpccnt[NFSPROC_RENAME]++;
1297 1.32 mycroft nfsm_reqhead(sdvp, NFSPROC_RENAME,
1298 1.32 mycroft (NFSX_FH+NFSX_UNSIGNED)*2+nfsm_rndup(scnp->cn_namelen)+
1299 1.32 mycroft nfsm_rndup(sp->s_namlen));
1300 1.32 mycroft nfsm_fhtom(sdvp);
1301 1.32 mycroft nfsm_strtom(scnp->cn_nameptr, scnp->cn_namelen, NFS_MAXNAMLEN);
1302 1.32 mycroft nfsm_fhtom(sdvp);
1303 1.1 cgd nfsm_strtom(sp->s_name, sp->s_namlen, NFS_MAXNAMLEN);
1304 1.32 mycroft nfsm_request(sdvp, NFSPROC_RENAME, scnp->cn_proc, scnp->cn_cred);
1305 1.1 cgd nfsm_reqdone;
1306 1.32 mycroft FREE(scnp->cn_pnbuf, M_NAMEI);
1307 1.32 mycroft VTONFS(sdvp)->n_flag |= NMODIFIED;
1308 1.32 mycroft VTONFS(sdvp)->n_attrstamp = 0;
1309 1.1 cgd return (error);
1310 1.1 cgd }
1311 1.1 cgd
1312 1.1 cgd /*
1313 1.1 cgd * nfs hard link create call
1314 1.1 cgd */
1315 1.32 mycroft int
1316 1.32 mycroft nfs_link(ap)
1317 1.32 mycroft struct vop_link_args /* {
1318 1.32 mycroft struct vnode *a_vp;
1319 1.32 mycroft struct vnode *a_tdvp;
1320 1.32 mycroft struct componentname *a_cnp;
1321 1.32 mycroft } */ *ap;
1322 1.32 mycroft {
1323 1.32 mycroft register struct vnode *vp = ap->a_vp;
1324 1.32 mycroft register struct vnode *tdvp = ap->a_tdvp;
1325 1.32 mycroft register struct componentname *cnp = ap->a_cnp;
1326 1.1 cgd register u_long *tl;
1327 1.1 cgd register caddr_t cp;
1328 1.32 mycroft register long t2;
1329 1.1 cgd caddr_t bpos, dpos;
1330 1.1 cgd int error = 0;
1331 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1332 1.1 cgd
1333 1.32 mycroft if (vp->v_mount != tdvp->v_mount) {
1334 1.32 mycroft /*VOP_ABORTOP(vp, cnp);*/
1335 1.32 mycroft if (tdvp == vp)
1336 1.32 mycroft vrele(vp);
1337 1.18 cgd else
1338 1.32 mycroft vput(vp);
1339 1.17 cgd return (EXDEV);
1340 1.17 cgd }
1341 1.32 mycroft
1342 1.36 mycroft /*
1343 1.36 mycroft * Push all writes to the server, so that the attribute cache
1344 1.36 mycroft * doesn't get "out of sync" with the server.
1345 1.36 mycroft * XXX There should be a better way!
1346 1.36 mycroft */
1347 1.36 mycroft VOP_FSYNC(tdvp, cnp->cn_cred, MNT_WAIT, cnp->cn_proc);
1348 1.36 mycroft
1349 1.1 cgd nfsstats.rpccnt[NFSPROC_LINK]++;
1350 1.32 mycroft nfsm_reqhead(tdvp, NFSPROC_LINK,
1351 1.32 mycroft NFSX_FH*2+NFSX_UNSIGNED+nfsm_rndup(cnp->cn_namelen));
1352 1.32 mycroft nfsm_fhtom(tdvp);
1353 1.1 cgd nfsm_fhtom(vp);
1354 1.32 mycroft nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
1355 1.32 mycroft nfsm_request(tdvp, NFSPROC_LINK, cnp->cn_proc, cnp->cn_cred);
1356 1.1 cgd nfsm_reqdone;
1357 1.32 mycroft FREE(cnp->cn_pnbuf, M_NAMEI);
1358 1.32 mycroft VTONFS(tdvp)->n_attrstamp = 0;
1359 1.36 mycroft VTONFS(vp)->n_flag |= NMODIFIED;
1360 1.1 cgd VTONFS(vp)->n_attrstamp = 0;
1361 1.32 mycroft vrele(vp);
1362 1.1 cgd /*
1363 1.1 cgd * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
1364 1.1 cgd */
1365 1.1 cgd if (error == EEXIST)
1366 1.1 cgd error = 0;
1367 1.1 cgd return (error);
1368 1.1 cgd }
1369 1.1 cgd
1370 1.1 cgd /*
1371 1.1 cgd * nfs symbolic link create call
1372 1.1 cgd */
1373 1.32 mycroft /* start here */
1374 1.32 mycroft int
1375 1.32 mycroft nfs_symlink(ap)
1376 1.32 mycroft struct vop_symlink_args /* {
1377 1.32 mycroft struct vnode *a_dvp;
1378 1.32 mycroft struct vnode **a_vpp;
1379 1.32 mycroft struct componentname *a_cnp;
1380 1.32 mycroft struct vattr *a_vap;
1381 1.32 mycroft char *a_target;
1382 1.32 mycroft } */ *ap;
1383 1.32 mycroft {
1384 1.32 mycroft register struct vnode *dvp = ap->a_dvp;
1385 1.32 mycroft register struct vattr *vap = ap->a_vap;
1386 1.32 mycroft register struct componentname *cnp = ap->a_cnp;
1387 1.1 cgd register struct nfsv2_sattr *sp;
1388 1.1 cgd register u_long *tl;
1389 1.1 cgd register caddr_t cp;
1390 1.32 mycroft register long t2;
1391 1.1 cgd caddr_t bpos, dpos;
1392 1.32 mycroft int slen, error = 0, isnq;
1393 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1394 1.1 cgd
1395 1.1 cgd nfsstats.rpccnt[NFSPROC_SYMLINK]++;
1396 1.32 mycroft slen = strlen(ap->a_target);
1397 1.32 mycroft isnq = (VFSTONFS(dvp->v_mount)->nm_flag & NFSMNT_NQNFS);
1398 1.32 mycroft nfsm_reqhead(dvp, NFSPROC_SYMLINK, NFSX_FH+2*NFSX_UNSIGNED+
1399 1.32 mycroft nfsm_rndup(cnp->cn_namelen)+nfsm_rndup(slen)+NFSX_SATTR(isnq));
1400 1.32 mycroft nfsm_fhtom(dvp);
1401 1.32 mycroft nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
1402 1.32 mycroft nfsm_strtom(ap->a_target, slen, NFS_MAXPATHLEN);
1403 1.32 mycroft nfsm_build(sp, struct nfsv2_sattr *, NFSX_SATTR(isnq));
1404 1.1 cgd sp->sa_mode = vtonfs_mode(VLNK, vap->va_mode);
1405 1.32 mycroft sp->sa_uid = txdr_unsigned(cnp->cn_cred->cr_uid);
1406 1.32 mycroft sp->sa_gid = txdr_unsigned(cnp->cn_cred->cr_gid);
1407 1.32 mycroft if (isnq) {
1408 1.32 mycroft quad_t qval = -1;
1409 1.32 mycroft
1410 1.32 mycroft txdr_hyper(&qval, &sp->sa_nqsize);
1411 1.32 mycroft sp->sa_nqflags = 0;
1412 1.32 mycroft txdr_nqtime(&vap->va_atime, &sp->sa_nqatime);
1413 1.32 mycroft txdr_nqtime(&vap->va_mtime, &sp->sa_nqmtime);
1414 1.32 mycroft } else {
1415 1.32 mycroft sp->sa_nfssize = -1;
1416 1.32 mycroft txdr_nfstime(&vap->va_atime, &sp->sa_nfsatime);
1417 1.32 mycroft txdr_nfstime(&vap->va_mtime, &sp->sa_nfsmtime);
1418 1.32 mycroft }
1419 1.32 mycroft nfsm_request(dvp, NFSPROC_SYMLINK, cnp->cn_proc, cnp->cn_cred);
1420 1.1 cgd nfsm_reqdone;
1421 1.32 mycroft FREE(cnp->cn_pnbuf, M_NAMEI);
1422 1.32 mycroft VTONFS(dvp)->n_flag |= NMODIFIED;
1423 1.32 mycroft VTONFS(dvp)->n_attrstamp = 0;
1424 1.32 mycroft vrele(dvp);
1425 1.1 cgd /*
1426 1.1 cgd * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
1427 1.1 cgd */
1428 1.1 cgd if (error == EEXIST)
1429 1.1 cgd error = 0;
1430 1.1 cgd return (error);
1431 1.1 cgd }
1432 1.1 cgd
1433 1.1 cgd /*
1434 1.1 cgd * nfs make dir call
1435 1.1 cgd */
1436 1.32 mycroft int
1437 1.32 mycroft nfs_mkdir(ap)
1438 1.32 mycroft struct vop_mkdir_args /* {
1439 1.32 mycroft struct vnode *a_dvp;
1440 1.32 mycroft struct vnode **a_vpp;
1441 1.32 mycroft struct componentname *a_cnp;
1442 1.32 mycroft struct vattr *a_vap;
1443 1.32 mycroft } */ *ap;
1444 1.32 mycroft {
1445 1.32 mycroft register struct vnode *dvp = ap->a_dvp;
1446 1.32 mycroft register struct vattr *vap = ap->a_vap;
1447 1.32 mycroft register struct componentname *cnp = ap->a_cnp;
1448 1.32 mycroft register struct vnode **vpp = ap->a_vpp;
1449 1.1 cgd register struct nfsv2_sattr *sp;
1450 1.1 cgd register u_long *tl;
1451 1.1 cgd register caddr_t cp;
1452 1.1 cgd register long t1, t2;
1453 1.1 cgd register int len;
1454 1.1 cgd caddr_t bpos, dpos, cp2;
1455 1.32 mycroft int error = 0, firsttry = 1, isnq;
1456 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1457 1.32 mycroft struct vattr vattr;
1458 1.1 cgd
1459 1.32 mycroft if (error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc)) {
1460 1.32 mycroft VOP_ABORTOP(dvp, cnp);
1461 1.32 mycroft vput(dvp);
1462 1.32 mycroft return (error);
1463 1.32 mycroft }
1464 1.32 mycroft len = cnp->cn_namelen;
1465 1.32 mycroft isnq = (VFSTONFS(dvp->v_mount)->nm_flag & NFSMNT_NQNFS);
1466 1.1 cgd nfsstats.rpccnt[NFSPROC_MKDIR]++;
1467 1.32 mycroft nfsm_reqhead(dvp, NFSPROC_MKDIR,
1468 1.32 mycroft NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(len)+NFSX_SATTR(isnq));
1469 1.32 mycroft nfsm_fhtom(dvp);
1470 1.32 mycroft nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN);
1471 1.32 mycroft nfsm_build(sp, struct nfsv2_sattr *, NFSX_SATTR(isnq));
1472 1.1 cgd sp->sa_mode = vtonfs_mode(VDIR, vap->va_mode);
1473 1.32 mycroft sp->sa_uid = txdr_unsigned(cnp->cn_cred->cr_uid);
1474 1.32 mycroft sp->sa_gid = txdr_unsigned(vattr.va_gid);
1475 1.32 mycroft if (isnq) {
1476 1.32 mycroft quad_t qval = -1;
1477 1.32 mycroft
1478 1.32 mycroft txdr_hyper(&qval, &sp->sa_nqsize);
1479 1.32 mycroft sp->sa_nqflags = 0;
1480 1.32 mycroft txdr_nqtime(&vap->va_atime, &sp->sa_nqatime);
1481 1.32 mycroft txdr_nqtime(&vap->va_mtime, &sp->sa_nqmtime);
1482 1.32 mycroft } else {
1483 1.32 mycroft sp->sa_nfssize = -1;
1484 1.32 mycroft txdr_nfstime(&vap->va_atime, &sp->sa_nfsatime);
1485 1.32 mycroft txdr_nfstime(&vap->va_mtime, &sp->sa_nfsmtime);
1486 1.32 mycroft }
1487 1.32 mycroft nfsm_request(dvp, NFSPROC_MKDIR, cnp->cn_proc, cnp->cn_cred);
1488 1.32 mycroft nfsm_mtofh(dvp, *vpp);
1489 1.1 cgd nfsm_reqdone;
1490 1.32 mycroft VTONFS(dvp)->n_flag |= NMODIFIED;
1491 1.32 mycroft VTONFS(dvp)->n_attrstamp = 0;
1492 1.1 cgd /*
1493 1.1 cgd * Kludge: Map EEXIST => 0 assuming that you have a reply to a retry
1494 1.1 cgd * if we can succeed in looking up the directory.
1495 1.1 cgd * "firsttry" is necessary since the macros may "goto nfsmout" which
1496 1.1 cgd * is above the if on errors. (Ugh)
1497 1.1 cgd */
1498 1.1 cgd if (error == EEXIST && firsttry) {
1499 1.1 cgd firsttry = 0;
1500 1.1 cgd error = 0;
1501 1.1 cgd nfsstats.rpccnt[NFSPROC_LOOKUP]++;
1502 1.32 mycroft *vpp = NULL;
1503 1.32 mycroft nfsm_reqhead(dvp, NFSPROC_LOOKUP,
1504 1.1 cgd NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(len));
1505 1.32 mycroft nfsm_fhtom(dvp);
1506 1.32 mycroft nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN);
1507 1.32 mycroft nfsm_request(dvp, NFSPROC_LOOKUP, cnp->cn_proc, cnp->cn_cred);
1508 1.32 mycroft nfsm_mtofh(dvp, *vpp);
1509 1.32 mycroft if ((*vpp)->v_type != VDIR) {
1510 1.32 mycroft vput(*vpp);
1511 1.1 cgd error = EEXIST;
1512 1.1 cgd }
1513 1.1 cgd m_freem(mrep);
1514 1.1 cgd }
1515 1.32 mycroft FREE(cnp->cn_pnbuf, M_NAMEI);
1516 1.32 mycroft vrele(dvp);
1517 1.1 cgd return (error);
1518 1.1 cgd }
1519 1.1 cgd
1520 1.1 cgd /*
1521 1.1 cgd * nfs remove directory call
1522 1.1 cgd */
1523 1.32 mycroft int
1524 1.32 mycroft nfs_rmdir(ap)
1525 1.32 mycroft struct vop_rmdir_args /* {
1526 1.32 mycroft struct vnode *a_dvp;
1527 1.32 mycroft struct vnode *a_vp;
1528 1.32 mycroft struct componentname *a_cnp;
1529 1.32 mycroft } */ *ap;
1530 1.32 mycroft {
1531 1.32 mycroft register struct vnode *vp = ap->a_vp;
1532 1.32 mycroft register struct vnode *dvp = ap->a_dvp;
1533 1.32 mycroft register struct componentname *cnp = ap->a_cnp;
1534 1.1 cgd register u_long *tl;
1535 1.1 cgd register caddr_t cp;
1536 1.32 mycroft register long t2;
1537 1.1 cgd caddr_t bpos, dpos;
1538 1.1 cgd int error = 0;
1539 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1540 1.1 cgd
1541 1.32 mycroft if (dvp == vp) {
1542 1.32 mycroft vrele(dvp);
1543 1.32 mycroft vrele(dvp);
1544 1.32 mycroft FREE(cnp->cn_pnbuf, M_NAMEI);
1545 1.1 cgd return (EINVAL);
1546 1.1 cgd }
1547 1.1 cgd nfsstats.rpccnt[NFSPROC_RMDIR]++;
1548 1.32 mycroft nfsm_reqhead(dvp, NFSPROC_RMDIR,
1549 1.32 mycroft NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(cnp->cn_namelen));
1550 1.32 mycroft nfsm_fhtom(dvp);
1551 1.32 mycroft nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
1552 1.32 mycroft nfsm_request(dvp, NFSPROC_RMDIR, cnp->cn_proc, cnp->cn_cred);
1553 1.1 cgd nfsm_reqdone;
1554 1.32 mycroft FREE(cnp->cn_pnbuf, M_NAMEI);
1555 1.32 mycroft VTONFS(dvp)->n_flag |= NMODIFIED;
1556 1.32 mycroft VTONFS(dvp)->n_attrstamp = 0;
1557 1.32 mycroft cache_purge(dvp);
1558 1.32 mycroft cache_purge(vp);
1559 1.32 mycroft vrele(vp);
1560 1.32 mycroft vrele(dvp);
1561 1.1 cgd /*
1562 1.1 cgd * Kludge: Map ENOENT => 0 assuming that you have a reply to a retry.
1563 1.1 cgd */
1564 1.1 cgd if (error == ENOENT)
1565 1.1 cgd error = 0;
1566 1.1 cgd return (error);
1567 1.1 cgd }
1568 1.1 cgd
1569 1.1 cgd /*
1570 1.1 cgd * nfs readdir call
1571 1.1 cgd * Although cookie is defined as opaque, I translate it to/from net byte
1572 1.1 cgd * order so that it looks more sensible. This appears consistent with the
1573 1.1 cgd * Ultrix implementation of NFS.
1574 1.1 cgd */
1575 1.32 mycroft int
1576 1.32 mycroft nfs_readdir(ap)
1577 1.32 mycroft struct vop_readdir_args /* {
1578 1.32 mycroft struct vnode *a_vp;
1579 1.32 mycroft struct uio *a_uio;
1580 1.32 mycroft struct ucred *a_cred;
1581 1.32 mycroft int *a_eofflag;
1582 1.32 mycroft u_long *a_cookies;
1583 1.32 mycroft int a_ncookies;
1584 1.32 mycroft } */ *ap;
1585 1.1 cgd {
1586 1.32 mycroft register struct vnode *vp = ap->a_vp;
1587 1.1 cgd register struct nfsnode *np = VTONFS(vp);
1588 1.32 mycroft register struct uio *uio = ap->a_uio;
1589 1.1 cgd int tresid, error;
1590 1.1 cgd struct vattr vattr;
1591 1.32 mycroft
1592 1.11 ws /*
1593 1.32 mycroft * We don't allow exporting NFS mounts, and currently local requests
1594 1.32 mycroft * do not need cookies.
1595 1.11 ws */
1596 1.32 mycroft if (ap->a_ncookies)
1597 1.32 mycroft panic("nfs_readdir: not hungry");
1598 1.32 mycroft
1599 1.1 cgd if (vp->v_type != VDIR)
1600 1.1 cgd return (EPERM);
1601 1.1 cgd /*
1602 1.1 cgd * First, check for hit on the EOF offset cache
1603 1.1 cgd */
1604 1.32 mycroft if (uio->uio_offset != 0 && uio->uio_offset == np->n_direofoffset &&
1605 1.32 mycroft (np->n_flag & NMODIFIED) == 0) {
1606 1.32 mycroft if (VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NQNFS) {
1607 1.32 mycroft if (NQNFS_CKCACHABLE(vp, NQL_READ)) {
1608 1.32 mycroft nfsstats.direofcache_hits++;
1609 1.32 mycroft return (0);
1610 1.32 mycroft }
1611 1.32 mycroft } else if (VOP_GETATTR(vp, &vattr, ap->a_cred, uio->uio_procp) == 0 &&
1612 1.32 mycroft np->n_mtime == vattr.va_mtime.ts_sec) {
1613 1.32 mycroft nfsstats.direofcache_hits++;
1614 1.32 mycroft return (0);
1615 1.32 mycroft }
1616 1.1 cgd }
1617 1.1 cgd
1618 1.1 cgd /*
1619 1.1 cgd * Call nfs_bioread() to do the real work.
1620 1.1 cgd */
1621 1.32 mycroft tresid = uio->uio_resid;
1622 1.32 mycroft error = nfs_bioread(vp, uio, 0, ap->a_cred);
1623 1.1 cgd
1624 1.32 mycroft if (!error && uio->uio_resid == tresid)
1625 1.1 cgd nfsstats.direofcache_misses++;
1626 1.1 cgd return (error);
1627 1.1 cgd }
1628 1.1 cgd
1629 1.1 cgd /*
1630 1.1 cgd * Readdir rpc call.
1631 1.1 cgd * Called from below the buffer cache by nfs_doio().
1632 1.1 cgd */
1633 1.32 mycroft int
1634 1.1 cgd nfs_readdirrpc(vp, uiop, cred)
1635 1.1 cgd register struct vnode *vp;
1636 1.1 cgd struct uio *uiop;
1637 1.1 cgd struct ucred *cred;
1638 1.1 cgd {
1639 1.1 cgd register long len;
1640 1.25 ws register struct dirent *dp;
1641 1.1 cgd register u_long *tl;
1642 1.1 cgd register caddr_t cp;
1643 1.1 cgd register long t1;
1644 1.1 cgd long tlen, lastlen;
1645 1.1 cgd caddr_t bpos, dpos, cp2;
1646 1.1 cgd int error = 0;
1647 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1648 1.1 cgd struct mbuf *md2;
1649 1.1 cgd caddr_t dpos2;
1650 1.1 cgd int siz;
1651 1.1 cgd int more_dirs = 1;
1652 1.32 mycroft u_long off, savoff;
1653 1.25 ws struct dirent *savdp;
1654 1.1 cgd struct nfsmount *nmp;
1655 1.1 cgd struct nfsnode *np = VTONFS(vp);
1656 1.1 cgd long tresid;
1657 1.1 cgd
1658 1.1 cgd nmp = VFSTONFS(vp->v_mount);
1659 1.1 cgd tresid = uiop->uio_resid;
1660 1.1 cgd /*
1661 1.1 cgd * Loop around doing readdir rpc's of size uio_resid or nm_rsize,
1662 1.1 cgd * whichever is smaller, truncated to a multiple of NFS_DIRBLKSIZ.
1663 1.1 cgd * The stopping criteria is EOF or buffer full.
1664 1.1 cgd */
1665 1.1 cgd while (more_dirs && uiop->uio_resid >= NFS_DIRBLKSIZ) {
1666 1.1 cgd nfsstats.rpccnt[NFSPROC_READDIR]++;
1667 1.32 mycroft nfsm_reqhead(vp, NFSPROC_READDIR,
1668 1.32 mycroft NFSX_FH + 2 * NFSX_UNSIGNED);
1669 1.1 cgd nfsm_fhtom(vp);
1670 1.32 mycroft nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
1671 1.32 mycroft off = (u_long)uiop->uio_offset;
1672 1.32 mycroft *tl++ = txdr_unsigned(off);
1673 1.1 cgd *tl = txdr_unsigned(((uiop->uio_resid > nmp->nm_rsize) ?
1674 1.1 cgd nmp->nm_rsize : uiop->uio_resid) & ~(NFS_DIRBLKSIZ-1));
1675 1.32 mycroft nfsm_request(vp, NFSPROC_READDIR, uiop->uio_procp, cred);
1676 1.1 cgd siz = 0;
1677 1.32 mycroft nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1678 1.1 cgd more_dirs = fxdr_unsigned(int, *tl);
1679 1.1 cgd
1680 1.1 cgd /* Save the position so that we can do nfsm_mtouio() later */
1681 1.1 cgd dpos2 = dpos;
1682 1.1 cgd md2 = md;
1683 1.1 cgd
1684 1.1 cgd /* loop thru the dir entries, doctoring them to 4bsd form */
1685 1.1 cgd #ifdef lint
1686 1.25 ws dp = (struct dirent *)0;
1687 1.1 cgd #endif /* lint */
1688 1.1 cgd while (more_dirs && siz < uiop->uio_resid) {
1689 1.1 cgd savoff = off; /* Hold onto offset and dp */
1690 1.1 cgd savdp = dp;
1691 1.32 mycroft nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
1692 1.25 ws dp = (struct dirent *)tl;
1693 1.25 ws dp->d_fileno = fxdr_unsigned(u_long, *tl++);
1694 1.1 cgd len = fxdr_unsigned(int, *tl);
1695 1.1 cgd if (len <= 0 || len > NFS_MAXNAMLEN) {
1696 1.1 cgd error = EBADRPC;
1697 1.1 cgd m_freem(mrep);
1698 1.1 cgd goto nfsmout;
1699 1.1 cgd }
1700 1.32 mycroft dp->d_namlen = (u_char)len;
1701 1.32 mycroft dp->d_type = DT_UNKNOWN;
1702 1.1 cgd nfsm_adv(len); /* Point past name */
1703 1.1 cgd tlen = nfsm_rndup(len);
1704 1.1 cgd /*
1705 1.1 cgd * This should not be necessary, but some servers have
1706 1.1 cgd * broken XDR such that these bytes are not null filled.
1707 1.1 cgd */
1708 1.1 cgd if (tlen != len) {
1709 1.1 cgd *dpos = '\0'; /* Null-terminate */
1710 1.1 cgd nfsm_adv(tlen - len);
1711 1.1 cgd len = tlen;
1712 1.1 cgd }
1713 1.32 mycroft nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
1714 1.32 mycroft off = fxdr_unsigned(u_long, *tl);
1715 1.1 cgd *tl++ = 0; /* Ensures null termination of name */
1716 1.1 cgd more_dirs = fxdr_unsigned(int, *tl);
1717 1.32 mycroft dp->d_reclen = len + 4 * NFSX_UNSIGNED;
1718 1.1 cgd siz += dp->d_reclen;
1719 1.1 cgd }
1720 1.1 cgd /*
1721 1.1 cgd * If at end of rpc data, get the eof boolean
1722 1.1 cgd */
1723 1.1 cgd if (!more_dirs) {
1724 1.32 mycroft nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1725 1.1 cgd more_dirs = (fxdr_unsigned(int, *tl) == 0);
1726 1.1 cgd
1727 1.1 cgd /*
1728 1.1 cgd * If at EOF, cache directory offset
1729 1.1 cgd */
1730 1.1 cgd if (!more_dirs)
1731 1.1 cgd np->n_direofoffset = off;
1732 1.1 cgd }
1733 1.1 cgd /*
1734 1.1 cgd * If there is too much to fit in the data buffer, use savoff and
1735 1.1 cgd * savdp to trim off the last record.
1736 1.1 cgd * --> we are not at eof
1737 1.1 cgd */
1738 1.1 cgd if (siz > uiop->uio_resid) {
1739 1.1 cgd off = savoff;
1740 1.1 cgd siz -= dp->d_reclen;
1741 1.1 cgd dp = savdp;
1742 1.1 cgd more_dirs = 0; /* Paranoia */
1743 1.1 cgd }
1744 1.1 cgd if (siz > 0) {
1745 1.1 cgd lastlen = dp->d_reclen;
1746 1.1 cgd md = md2;
1747 1.1 cgd dpos = dpos2;
1748 1.1 cgd nfsm_mtouio(uiop, siz);
1749 1.32 mycroft uiop->uio_offset = (off_t)off;
1750 1.1 cgd } else
1751 1.1 cgd more_dirs = 0; /* Ugh, never happens, but in case.. */
1752 1.1 cgd m_freem(mrep);
1753 1.1 cgd }
1754 1.1 cgd /*
1755 1.1 cgd * Fill last record, iff any, out to a multiple of NFS_DIRBLKSIZ
1756 1.1 cgd * by increasing d_reclen for the last record.
1757 1.1 cgd */
1758 1.1 cgd if (uiop->uio_resid < tresid) {
1759 1.1 cgd len = uiop->uio_resid & (NFS_DIRBLKSIZ - 1);
1760 1.1 cgd if (len > 0) {
1761 1.25 ws dp = (struct dirent *)
1762 1.1 cgd (uiop->uio_iov->iov_base - lastlen);
1763 1.1 cgd dp->d_reclen += len;
1764 1.1 cgd uiop->uio_iov->iov_base += len;
1765 1.1 cgd uiop->uio_iov->iov_len -= len;
1766 1.1 cgd uiop->uio_resid -= len;
1767 1.1 cgd }
1768 1.1 cgd }
1769 1.1 cgd nfsmout:
1770 1.1 cgd return (error);
1771 1.1 cgd }
1772 1.1 cgd
1773 1.32 mycroft /*
1774 1.32 mycroft * Nqnfs readdir_and_lookup RPC. Used in place of nfs_readdirrpc().
1775 1.32 mycroft */
1776 1.32 mycroft int
1777 1.32 mycroft nfs_readdirlookrpc(vp, uiop, cred)
1778 1.32 mycroft struct vnode *vp;
1779 1.32 mycroft register struct uio *uiop;
1780 1.32 mycroft struct ucred *cred;
1781 1.32 mycroft {
1782 1.32 mycroft register int len;
1783 1.32 mycroft register struct dirent *dp;
1784 1.32 mycroft register u_long *tl;
1785 1.32 mycroft register caddr_t cp;
1786 1.32 mycroft register long t1;
1787 1.32 mycroft caddr_t bpos, dpos, cp2;
1788 1.32 mycroft struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1789 1.32 mycroft struct nameidata nami, *ndp = &nami;
1790 1.32 mycroft struct componentname *cnp = &ndp->ni_cnd;
1791 1.32 mycroft u_long off, endoff, fileno;
1792 1.32 mycroft time_t reqtime, ltime;
1793 1.32 mycroft struct nfsmount *nmp;
1794 1.32 mycroft struct nfsnode *np;
1795 1.32 mycroft struct vnode *newvp;
1796 1.32 mycroft nfsv2fh_t *fhp;
1797 1.32 mycroft u_quad_t frev;
1798 1.32 mycroft int error = 0, tlen, more_dirs = 1, tresid, doit, bigenough, i;
1799 1.32 mycroft int cachable;
1800 1.32 mycroft
1801 1.32 mycroft if (uiop->uio_iovcnt != 1)
1802 1.32 mycroft panic("nfs rdirlook");
1803 1.32 mycroft nmp = VFSTONFS(vp->v_mount);
1804 1.32 mycroft tresid = uiop->uio_resid;
1805 1.32 mycroft ndp->ni_dvp = vp;
1806 1.32 mycroft newvp = NULLVP;
1807 1.32 mycroft /*
1808 1.32 mycroft * Loop around doing readdir rpc's of size uio_resid or nm_rsize,
1809 1.32 mycroft * whichever is smaller, truncated to a multiple of NFS_DIRBLKSIZ.
1810 1.32 mycroft * The stopping criteria is EOF or buffer full.
1811 1.32 mycroft */
1812 1.32 mycroft while (more_dirs && uiop->uio_resid >= NFS_DIRBLKSIZ) {
1813 1.32 mycroft nfsstats.rpccnt[NQNFSPROC_READDIRLOOK]++;
1814 1.32 mycroft nfsm_reqhead(vp, NQNFSPROC_READDIRLOOK,
1815 1.32 mycroft NFSX_FH + 3 * NFSX_UNSIGNED);
1816 1.32 mycroft nfsm_fhtom(vp);
1817 1.32 mycroft nfsm_build(tl, u_long *, 3 * NFSX_UNSIGNED);
1818 1.32 mycroft off = (u_long)uiop->uio_offset;
1819 1.32 mycroft *tl++ = txdr_unsigned(off);
1820 1.32 mycroft *tl++ = txdr_unsigned(((uiop->uio_resid > nmp->nm_rsize) ?
1821 1.32 mycroft nmp->nm_rsize : uiop->uio_resid) & ~(NFS_DIRBLKSIZ-1));
1822 1.32 mycroft if (nmp->nm_flag & NFSMNT_NQLOOKLEASE)
1823 1.32 mycroft *tl = txdr_unsigned(nmp->nm_leaseterm);
1824 1.32 mycroft else
1825 1.32 mycroft *tl = 0;
1826 1.32 mycroft reqtime = time.tv_sec;
1827 1.32 mycroft nfsm_request(vp, NQNFSPROC_READDIRLOOK, uiop->uio_procp, cred);
1828 1.32 mycroft nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1829 1.32 mycroft more_dirs = fxdr_unsigned(int, *tl);
1830 1.32 mycroft
1831 1.32 mycroft /* loop thru the dir entries, doctoring them to 4bsd form */
1832 1.32 mycroft bigenough = 1;
1833 1.32 mycroft while (more_dirs && bigenough) {
1834 1.32 mycroft doit = 1;
1835 1.32 mycroft nfsm_dissect(tl, u_long *, 4 * NFSX_UNSIGNED);
1836 1.32 mycroft if (nmp->nm_flag & NFSMNT_NQLOOKLEASE) {
1837 1.32 mycroft cachable = fxdr_unsigned(int, *tl++);
1838 1.32 mycroft ltime = reqtime + fxdr_unsigned(int, *tl++);
1839 1.32 mycroft fxdr_hyper(tl, &frev);
1840 1.32 mycroft }
1841 1.32 mycroft nfsm_dissect(fhp, nfsv2fh_t *, NFSX_FH);
1842 1.32 mycroft if (!bcmp(VTONFS(vp)->n_fh.fh_bytes, (caddr_t)fhp, NFSX_FH)) {
1843 1.32 mycroft VREF(vp);
1844 1.32 mycroft newvp = vp;
1845 1.32 mycroft np = VTONFS(vp);
1846 1.32 mycroft } else {
1847 1.32 mycroft if (error = nfs_nget(vp->v_mount, fhp, &np))
1848 1.32 mycroft doit = 0;
1849 1.32 mycroft newvp = NFSTOV(np);
1850 1.32 mycroft }
1851 1.32 mycroft if (error = nfs_loadattrcache(&newvp, &md, &dpos,
1852 1.32 mycroft (struct vattr *)0))
1853 1.32 mycroft doit = 0;
1854 1.32 mycroft nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
1855 1.32 mycroft fileno = fxdr_unsigned(u_long, *tl++);
1856 1.32 mycroft len = fxdr_unsigned(int, *tl);
1857 1.32 mycroft if (len <= 0 || len > NFS_MAXNAMLEN) {
1858 1.32 mycroft error = EBADRPC;
1859 1.32 mycroft m_freem(mrep);
1860 1.32 mycroft goto nfsmout;
1861 1.32 mycroft }
1862 1.32 mycroft tlen = (len + 4) & ~0x3;
1863 1.32 mycroft if ((tlen + DIRHDSIZ) > uiop->uio_resid)
1864 1.32 mycroft bigenough = 0;
1865 1.32 mycroft if (bigenough && doit) {
1866 1.32 mycroft dp = (struct dirent *)uiop->uio_iov->iov_base;
1867 1.32 mycroft dp->d_fileno = fileno;
1868 1.32 mycroft dp->d_namlen = len;
1869 1.32 mycroft dp->d_reclen = tlen + DIRHDSIZ;
1870 1.32 mycroft dp->d_type =
1871 1.32 mycroft IFTODT(VTTOIF(np->n_vattr.va_type));
1872 1.32 mycroft uiop->uio_resid -= DIRHDSIZ;
1873 1.32 mycroft uiop->uio_iov->iov_base += DIRHDSIZ;
1874 1.32 mycroft uiop->uio_iov->iov_len -= DIRHDSIZ;
1875 1.32 mycroft cnp->cn_nameptr = uiop->uio_iov->iov_base;
1876 1.32 mycroft cnp->cn_namelen = len;
1877 1.32 mycroft ndp->ni_vp = newvp;
1878 1.32 mycroft nfsm_mtouio(uiop, len);
1879 1.32 mycroft cp = uiop->uio_iov->iov_base;
1880 1.32 mycroft tlen -= len;
1881 1.32 mycroft for (i = 0; i < tlen; i++)
1882 1.32 mycroft *cp++ = '\0';
1883 1.32 mycroft uiop->uio_iov->iov_base += tlen;
1884 1.32 mycroft uiop->uio_iov->iov_len -= tlen;
1885 1.32 mycroft uiop->uio_resid -= tlen;
1886 1.32 mycroft cnp->cn_hash = 0;
1887 1.32 mycroft for (cp = cnp->cn_nameptr, i = 1; i <= len; i++, cp++)
1888 1.32 mycroft cnp->cn_hash += (unsigned char)*cp * i;
1889 1.32 mycroft if ((nmp->nm_flag & NFSMNT_NQLOOKLEASE) &&
1890 1.32 mycroft ltime > time.tv_sec)
1891 1.32 mycroft nqnfs_clientlease(nmp, np, NQL_READ,
1892 1.32 mycroft cachable, ltime, frev);
1893 1.32 mycroft if (cnp->cn_namelen <= NCHNAMLEN)
1894 1.32 mycroft cache_enter(ndp->ni_dvp, ndp->ni_vp, cnp);
1895 1.32 mycroft } else {
1896 1.32 mycroft nfsm_adv(nfsm_rndup(len));
1897 1.32 mycroft }
1898 1.32 mycroft if (newvp != NULLVP) {
1899 1.32 mycroft vrele(newvp);
1900 1.32 mycroft newvp = NULLVP;
1901 1.32 mycroft }
1902 1.32 mycroft nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
1903 1.32 mycroft if (bigenough)
1904 1.32 mycroft endoff = off = fxdr_unsigned(u_long, *tl++);
1905 1.32 mycroft else
1906 1.32 mycroft endoff = fxdr_unsigned(u_long, *tl++);
1907 1.32 mycroft more_dirs = fxdr_unsigned(int, *tl);
1908 1.32 mycroft }
1909 1.32 mycroft /*
1910 1.32 mycroft * If at end of rpc data, get the eof boolean
1911 1.32 mycroft */
1912 1.32 mycroft if (!more_dirs) {
1913 1.32 mycroft nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
1914 1.32 mycroft more_dirs = (fxdr_unsigned(int, *tl) == 0);
1915 1.32 mycroft
1916 1.32 mycroft /*
1917 1.32 mycroft * If at EOF, cache directory offset
1918 1.32 mycroft */
1919 1.32 mycroft if (!more_dirs)
1920 1.32 mycroft VTONFS(vp)->n_direofoffset = endoff;
1921 1.32 mycroft }
1922 1.32 mycroft if (uiop->uio_resid < tresid)
1923 1.32 mycroft uiop->uio_offset = (off_t)off;
1924 1.32 mycroft else
1925 1.32 mycroft more_dirs = 0;
1926 1.32 mycroft m_freem(mrep);
1927 1.32 mycroft }
1928 1.32 mycroft /*
1929 1.32 mycroft * Fill last record, iff any, out to a multiple of NFS_DIRBLKSIZ
1930 1.32 mycroft * by increasing d_reclen for the last record.
1931 1.32 mycroft */
1932 1.32 mycroft if (uiop->uio_resid < tresid) {
1933 1.32 mycroft len = uiop->uio_resid & (NFS_DIRBLKSIZ - 1);
1934 1.32 mycroft if (len > 0) {
1935 1.32 mycroft dp->d_reclen += len;
1936 1.32 mycroft uiop->uio_iov->iov_base += len;
1937 1.32 mycroft uiop->uio_iov->iov_len -= len;
1938 1.32 mycroft uiop->uio_resid -= len;
1939 1.32 mycroft }
1940 1.32 mycroft }
1941 1.32 mycroft nfsmout:
1942 1.32 mycroft if (newvp != NULLVP)
1943 1.32 mycroft vrele(newvp);
1944 1.32 mycroft return (error);
1945 1.32 mycroft }
1946 1.1 cgd static char hextoasc[] = "0123456789abcdef";
1947 1.1 cgd
1948 1.1 cgd /*
1949 1.1 cgd * Silly rename. To make the NFS filesystem that is stateless look a little
1950 1.1 cgd * more like the "ufs" a remove of an active vnode is translated to a rename
1951 1.1 cgd * to a funny looking filename that is removed by nfs_inactive on the
1952 1.1 cgd * nfsnode. There is the potential for another process on a different client
1953 1.1 cgd * to create the same funny name between the nfs_lookitup() fails and the
1954 1.1 cgd * nfs_rename() completes, but...
1955 1.1 cgd */
1956 1.32 mycroft int
1957 1.32 mycroft nfs_sillyrename(dvp, vp, cnp)
1958 1.32 mycroft struct vnode *dvp, *vp;
1959 1.32 mycroft struct componentname *cnp;
1960 1.1 cgd {
1961 1.1 cgd register struct nfsnode *np;
1962 1.1 cgd register struct sillyrename *sp;
1963 1.1 cgd int error;
1964 1.1 cgd short pid;
1965 1.1 cgd
1966 1.32 mycroft cache_purge(dvp);
1967 1.32 mycroft np = VTONFS(vp);
1968 1.32 mycroft #ifdef SILLYSEPARATE
1969 1.1 cgd MALLOC(sp, struct sillyrename *, sizeof (struct sillyrename),
1970 1.1 cgd M_NFSREQ, M_WAITOK);
1971 1.32 mycroft #else
1972 1.32 mycroft sp = &np->n_silly;
1973 1.32 mycroft #endif
1974 1.32 mycroft sp->s_cred = crdup(cnp->cn_cred);
1975 1.32 mycroft sp->s_dvp = dvp;
1976 1.32 mycroft VREF(dvp);
1977 1.1 cgd
1978 1.1 cgd /* Fudge together a funny name */
1979 1.32 mycroft pid = cnp->cn_proc->p_pid;
1980 1.1 cgd bcopy(".nfsAxxxx4.4", sp->s_name, 13);
1981 1.1 cgd sp->s_namlen = 12;
1982 1.1 cgd sp->s_name[8] = hextoasc[pid & 0xf];
1983 1.1 cgd sp->s_name[7] = hextoasc[(pid >> 4) & 0xf];
1984 1.1 cgd sp->s_name[6] = hextoasc[(pid >> 8) & 0xf];
1985 1.1 cgd sp->s_name[5] = hextoasc[(pid >> 12) & 0xf];
1986 1.1 cgd
1987 1.1 cgd /* Try lookitups until we get one that isn't there */
1988 1.32 mycroft while (nfs_lookitup(sp, (nfsv2fh_t *)0, cnp->cn_proc) == 0) {
1989 1.1 cgd sp->s_name[4]++;
1990 1.1 cgd if (sp->s_name[4] > 'z') {
1991 1.1 cgd error = EINVAL;
1992 1.1 cgd goto bad;
1993 1.1 cgd }
1994 1.1 cgd }
1995 1.32 mycroft if (error = nfs_renameit(dvp, cnp, sp))
1996 1.1 cgd goto bad;
1997 1.32 mycroft nfs_lookitup(sp, &np->n_fh, cnp->cn_proc);
1998 1.1 cgd np->n_sillyrename = sp;
1999 1.1 cgd return (0);
2000 1.1 cgd bad:
2001 1.1 cgd vrele(sp->s_dvp);
2002 1.1 cgd crfree(sp->s_cred);
2003 1.32 mycroft #ifdef SILLYSEPARATE
2004 1.1 cgd free((caddr_t)sp, M_NFSREQ);
2005 1.32 mycroft #endif
2006 1.1 cgd return (error);
2007 1.1 cgd }
2008 1.1 cgd
2009 1.1 cgd /*
2010 1.1 cgd * Look up a file name for silly rename stuff.
2011 1.1 cgd * Just like nfs_lookup() except that it doesn't load returned values
2012 1.1 cgd * into the nfsnode table.
2013 1.1 cgd * If fhp != NULL it copies the returned file handle out
2014 1.1 cgd */
2015 1.32 mycroft int
2016 1.32 mycroft nfs_lookitup(sp, fhp, procp)
2017 1.1 cgd register struct sillyrename *sp;
2018 1.1 cgd nfsv2fh_t *fhp;
2019 1.32 mycroft struct proc *procp;
2020 1.1 cgd {
2021 1.1 cgd register struct vnode *vp = sp->s_dvp;
2022 1.1 cgd register u_long *tl;
2023 1.1 cgd register caddr_t cp;
2024 1.1 cgd register long t1, t2;
2025 1.1 cgd caddr_t bpos, dpos, cp2;
2026 1.32 mycroft int error = 0, isnq;
2027 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb, *mb2;
2028 1.1 cgd long len;
2029 1.1 cgd
2030 1.32 mycroft isnq = (VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NQNFS);
2031 1.1 cgd nfsstats.rpccnt[NFSPROC_LOOKUP]++;
2032 1.1 cgd len = sp->s_namlen;
2033 1.32 mycroft nfsm_reqhead(vp, NFSPROC_LOOKUP, NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(len));
2034 1.32 mycroft if (isnq) {
2035 1.32 mycroft nfsm_build(tl, u_long *, NFSX_UNSIGNED);
2036 1.32 mycroft *tl = 0;
2037 1.32 mycroft }
2038 1.1 cgd nfsm_fhtom(vp);
2039 1.1 cgd nfsm_strtom(sp->s_name, len, NFS_MAXNAMLEN);
2040 1.32 mycroft nfsm_request(vp, NFSPROC_LOOKUP, procp, sp->s_cred);
2041 1.1 cgd if (fhp != NULL) {
2042 1.32 mycroft if (isnq)
2043 1.32 mycroft nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
2044 1.32 mycroft nfsm_dissect(cp, caddr_t, NFSX_FH);
2045 1.1 cgd bcopy(cp, (caddr_t)fhp, NFSX_FH);
2046 1.1 cgd }
2047 1.1 cgd nfsm_reqdone;
2048 1.1 cgd return (error);
2049 1.1 cgd }
2050 1.1 cgd
2051 1.1 cgd /*
2052 1.1 cgd * Kludge City..
2053 1.1 cgd * - make nfs_bmap() essentially a no-op that does no translation
2054 1.1 cgd * - do nfs_strategy() by faking physical I/O with nfs_readrpc/nfs_writerpc
2055 1.1 cgd * after mapping the physical addresses into Kernel Virtual space in the
2056 1.1 cgd * nfsiobuf area.
2057 1.1 cgd * (Maybe I could use the process's page mapping, but I was concerned that
2058 1.1 cgd * Kernel Write might not be enabled and also figured copyout() would do
2059 1.1 cgd * a lot more work than bcopy() and also it currently happens in the
2060 1.1 cgd * context of the swapper process (2).
2061 1.1 cgd */
2062 1.32 mycroft int
2063 1.32 mycroft nfs_bmap(ap)
2064 1.32 mycroft struct vop_bmap_args /* {
2065 1.32 mycroft struct vnode *a_vp;
2066 1.32 mycroft daddr_t a_bn;
2067 1.32 mycroft struct vnode **a_vpp;
2068 1.32 mycroft daddr_t *a_bnp;
2069 1.32 mycroft int *a_runp;
2070 1.32 mycroft } */ *ap;
2071 1.32 mycroft {
2072 1.32 mycroft register struct vnode *vp = ap->a_vp;
2073 1.32 mycroft
2074 1.32 mycroft if (ap->a_vpp != NULL)
2075 1.32 mycroft *ap->a_vpp = vp;
2076 1.32 mycroft if (ap->a_bnp != NULL)
2077 1.32 mycroft *ap->a_bnp = ap->a_bn * btodb(vp->v_mount->mnt_stat.f_iosize);
2078 1.1 cgd return (0);
2079 1.1 cgd }
2080 1.1 cgd
2081 1.1 cgd /*
2082 1.32 mycroft * Strategy routine.
2083 1.32 mycroft * For async requests when nfsiod(s) are running, queue the request by
2084 1.32 mycroft * calling nfs_asyncio(), otherwise just all nfs_doio() to do the
2085 1.32 mycroft * request.
2086 1.1 cgd */
2087 1.32 mycroft int
2088 1.32 mycroft nfs_strategy(ap)
2089 1.32 mycroft struct vop_strategy_args *ap;
2090 1.1 cgd {
2091 1.32 mycroft register struct buf *bp = ap->a_bp;
2092 1.32 mycroft struct ucred *cr;
2093 1.32 mycroft struct proc *p;
2094 1.1 cgd int error = 0;
2095 1.1 cgd
2096 1.33 pk if ((bp->b_flags & (B_PHYS|B_ASYNC)) == (B_PHYS|B_ASYNC))
2097 1.33 pk panic("nfs physio/async");
2098 1.32 mycroft if (bp->b_flags & B_ASYNC)
2099 1.32 mycroft p = (struct proc *)0;
2100 1.32 mycroft else
2101 1.32 mycroft p = curproc; /* XXX */
2102 1.32 mycroft if (bp->b_flags & B_READ)
2103 1.32 mycroft cr = bp->b_rcred;
2104 1.32 mycroft else
2105 1.32 mycroft cr = bp->b_wcred;
2106 1.1 cgd /*
2107 1.1 cgd * If the op is asynchronous and an i/o daemon is waiting
2108 1.1 cgd * queue the request, wake it up and wait for completion
2109 1.1 cgd * otherwise just do it ourselves.
2110 1.1 cgd */
2111 1.32 mycroft if ((bp->b_flags & B_ASYNC) == 0 ||
2112 1.32 mycroft nfs_asyncio(bp, NOCRED))
2113 1.32 mycroft error = nfs_doio(bp, cr, p);
2114 1.1 cgd return (error);
2115 1.1 cgd }
2116 1.1 cgd
2117 1.1 cgd /*
2118 1.1 cgd * Mmap a file
2119 1.1 cgd *
2120 1.1 cgd * NB Currently unsupported.
2121 1.1 cgd */
2122 1.1 cgd /* ARGSUSED */
2123 1.32 mycroft int
2124 1.32 mycroft nfs_mmap(ap)
2125 1.32 mycroft struct vop_mmap_args /* {
2126 1.32 mycroft struct vnode *a_vp;
2127 1.32 mycroft int a_fflags;
2128 1.32 mycroft struct ucred *a_cred;
2129 1.32 mycroft struct proc *a_p;
2130 1.32 mycroft } */ *ap;
2131 1.1 cgd {
2132 1.1 cgd
2133 1.1 cgd return (EINVAL);
2134 1.1 cgd }
2135 1.1 cgd
2136 1.1 cgd /*
2137 1.1 cgd * Flush all the blocks associated with a vnode.
2138 1.1 cgd * Walk through the buffer pool and push any dirty pages
2139 1.1 cgd * associated with the vnode.
2140 1.1 cgd */
2141 1.1 cgd /* ARGSUSED */
2142 1.32 mycroft int
2143 1.32 mycroft nfs_fsync(ap)
2144 1.32 mycroft struct vop_fsync_args /* {
2145 1.32 mycroft struct vnodeop_desc *a_desc;
2146 1.32 mycroft struct vnode * a_vp;
2147 1.32 mycroft struct ucred * a_cred;
2148 1.32 mycroft int a_waitfor;
2149 1.32 mycroft struct proc * a_p;
2150 1.32 mycroft } */ *ap;
2151 1.1 cgd {
2152 1.32 mycroft register struct vnode *vp = ap->a_vp;
2153 1.1 cgd register struct nfsnode *np = VTONFS(vp);
2154 1.32 mycroft register struct buf *bp;
2155 1.32 mycroft struct buf *nbp;
2156 1.32 mycroft struct nfsmount *nmp;
2157 1.32 mycroft int s, error = 0, slptimeo = 0, slpflag = 0;
2158 1.1 cgd
2159 1.32 mycroft nmp = VFSTONFS(vp->v_mount);
2160 1.32 mycroft if (nmp->nm_flag & NFSMNT_INT)
2161 1.32 mycroft slpflag = PCATCH;
2162 1.32 mycroft loop:
2163 1.32 mycroft s = splbio();
2164 1.32 mycroft for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) {
2165 1.32 mycroft nbp = bp->b_vnbufs.le_next;
2166 1.32 mycroft if (bp->b_flags & B_BUSY) {
2167 1.32 mycroft if (ap->a_waitfor != MNT_WAIT)
2168 1.32 mycroft continue;
2169 1.32 mycroft bp->b_flags |= B_WANTED;
2170 1.32 mycroft error = tsleep((caddr_t)bp, slpflag | (PRIBIO + 1),
2171 1.32 mycroft "nfsfsync", slptimeo);
2172 1.32 mycroft splx(s);
2173 1.32 mycroft if (error) {
2174 1.32 mycroft if (nfs_sigintr(nmp, (struct nfsreq *)0, ap->a_p))
2175 1.32 mycroft return (EINTR);
2176 1.32 mycroft if (slpflag == PCATCH) {
2177 1.32 mycroft slpflag = 0;
2178 1.32 mycroft slptimeo = 2 * hz;
2179 1.32 mycroft }
2180 1.32 mycroft }
2181 1.32 mycroft goto loop;
2182 1.32 mycroft }
2183 1.32 mycroft if ((bp->b_flags & B_DELWRI) == 0)
2184 1.32 mycroft panic("nfs_fsync: not dirty");
2185 1.32 mycroft bremfree(bp);
2186 1.32 mycroft bp->b_flags |= B_BUSY;
2187 1.32 mycroft splx(s);
2188 1.32 mycroft bp->b_flags |= B_ASYNC;
2189 1.32 mycroft VOP_BWRITE(bp);
2190 1.32 mycroft goto loop;
2191 1.32 mycroft }
2192 1.32 mycroft splx(s);
2193 1.32 mycroft if (ap->a_waitfor == MNT_WAIT) {
2194 1.32 mycroft while (vp->v_numoutput) {
2195 1.32 mycroft vp->v_flag |= VBWAIT;
2196 1.32 mycroft error = tsleep((caddr_t)&vp->v_numoutput,
2197 1.32 mycroft slpflag | (PRIBIO + 1), "nfsfsync", slptimeo);
2198 1.32 mycroft if (error) {
2199 1.32 mycroft if (nfs_sigintr(nmp, (struct nfsreq *)0, ap->a_p))
2200 1.32 mycroft return (EINTR);
2201 1.32 mycroft if (slpflag == PCATCH) {
2202 1.32 mycroft slpflag = 0;
2203 1.32 mycroft slptimeo = 2 * hz;
2204 1.32 mycroft }
2205 1.32 mycroft }
2206 1.32 mycroft }
2207 1.32 mycroft if (vp->v_dirtyblkhd.lh_first) {
2208 1.32 mycroft #ifdef DIAGNOSTIC
2209 1.32 mycroft vprint("nfs_fsync: dirty", vp);
2210 1.32 mycroft #endif
2211 1.32 mycroft goto loop;
2212 1.32 mycroft }
2213 1.1 cgd }
2214 1.32 mycroft if (np->n_flag & NWRITEERR) {
2215 1.1 cgd error = np->n_error;
2216 1.32 mycroft np->n_flag &= ~NWRITEERR;
2217 1.32 mycroft }
2218 1.1 cgd return (error);
2219 1.1 cgd }
2220 1.1 cgd
2221 1.1 cgd /*
2222 1.32 mycroft * Return POSIX pathconf information applicable to nfs.
2223 1.32 mycroft *
2224 1.32 mycroft * Currently the NFS protocol does not support getting such
2225 1.32 mycroft * information from the remote server.
2226 1.32 mycroft */
2227 1.32 mycroft /* ARGSUSED */
2228 1.32 mycroft nfs_pathconf(ap)
2229 1.32 mycroft struct vop_pathconf_args /* {
2230 1.32 mycroft struct vnode *a_vp;
2231 1.32 mycroft int a_name;
2232 1.41 cgd register_t *a_retval;
2233 1.32 mycroft } */ *ap;
2234 1.32 mycroft {
2235 1.32 mycroft
2236 1.32 mycroft return (EINVAL);
2237 1.32 mycroft }
2238 1.32 mycroft
2239 1.32 mycroft /*
2240 1.1 cgd * NFS advisory byte-level locks.
2241 1.1 cgd */
2242 1.32 mycroft int
2243 1.32 mycroft nfs_advlock(ap)
2244 1.32 mycroft struct vop_advlock_args /* {
2245 1.32 mycroft struct vnode *a_vp;
2246 1.32 mycroft caddr_t a_id;
2247 1.32 mycroft int a_op;
2248 1.32 mycroft struct flock *a_fl;
2249 1.32 mycroft int a_flags;
2250 1.32 mycroft } */ *ap;
2251 1.1 cgd {
2252 1.32 mycroft register struct nfsnode *np = VTONFS(ap->a_vp);
2253 1.1 cgd
2254 1.32 mycroft return (lf_advlock(&np->n_lockf, np->n_size, ap->a_id, ap->a_op,
2255 1.32 mycroft ap->a_fl, ap->a_flags));
2256 1.1 cgd }
2257 1.1 cgd
2258 1.1 cgd /*
2259 1.1 cgd * Print out the contents of an nfsnode.
2260 1.1 cgd */
2261 1.17 cgd int
2262 1.32 mycroft nfs_print(ap)
2263 1.32 mycroft struct vop_print_args /* {
2264 1.32 mycroft struct vnode *a_vp;
2265 1.32 mycroft } */ *ap;
2266 1.1 cgd {
2267 1.32 mycroft register struct vnode *vp = ap->a_vp;
2268 1.1 cgd register struct nfsnode *np = VTONFS(vp);
2269 1.1 cgd
2270 1.1 cgd printf("tag VT_NFS, fileid %d fsid 0x%x",
2271 1.1 cgd np->n_vattr.va_fileid, np->n_vattr.va_fsid);
2272 1.1 cgd #ifdef FIFO
2273 1.1 cgd if (vp->v_type == VFIFO)
2274 1.1 cgd fifo_printinfo(vp);
2275 1.1 cgd #endif /* FIFO */
2276 1.1 cgd printf("\n");
2277 1.1 cgd }
2278 1.3 glass
2279 1.3 glass /*
2280 1.32 mycroft * NFS directory offset lookup.
2281 1.32 mycroft * Currently unsupported.
2282 1.32 mycroft */
2283 1.32 mycroft int
2284 1.32 mycroft nfs_blkatoff(ap)
2285 1.32 mycroft struct vop_blkatoff_args /* {
2286 1.32 mycroft struct vnode *a_vp;
2287 1.32 mycroft off_t a_offset;
2288 1.32 mycroft char **a_res;
2289 1.32 mycroft struct buf **a_bpp;
2290 1.32 mycroft } */ *ap;
2291 1.32 mycroft {
2292 1.32 mycroft
2293 1.32 mycroft return (EOPNOTSUPP);
2294 1.32 mycroft }
2295 1.32 mycroft
2296 1.32 mycroft /*
2297 1.32 mycroft * NFS flat namespace allocation.
2298 1.32 mycroft * Currently unsupported.
2299 1.32 mycroft */
2300 1.32 mycroft int
2301 1.32 mycroft nfs_valloc(ap)
2302 1.32 mycroft struct vop_valloc_args /* {
2303 1.32 mycroft struct vnode *a_pvp;
2304 1.32 mycroft int a_mode;
2305 1.32 mycroft struct ucred *a_cred;
2306 1.32 mycroft struct vnode **a_vpp;
2307 1.32 mycroft } */ *ap;
2308 1.32 mycroft {
2309 1.32 mycroft
2310 1.32 mycroft return (EOPNOTSUPP);
2311 1.32 mycroft }
2312 1.32 mycroft
2313 1.32 mycroft /*
2314 1.32 mycroft * NFS flat namespace free.
2315 1.32 mycroft * Currently unsupported.
2316 1.32 mycroft */
2317 1.32 mycroft int
2318 1.32 mycroft nfs_vfree(ap)
2319 1.32 mycroft struct vop_vfree_args /* {
2320 1.32 mycroft struct vnode *a_pvp;
2321 1.32 mycroft ino_t a_ino;
2322 1.32 mycroft int a_mode;
2323 1.32 mycroft } */ *ap;
2324 1.32 mycroft {
2325 1.32 mycroft
2326 1.32 mycroft return (EOPNOTSUPP);
2327 1.32 mycroft }
2328 1.32 mycroft
2329 1.32 mycroft /*
2330 1.32 mycroft * NFS file truncation.
2331 1.3 glass */
2332 1.32 mycroft int
2333 1.32 mycroft nfs_truncate(ap)
2334 1.32 mycroft struct vop_truncate_args /* {
2335 1.32 mycroft struct vnode *a_vp;
2336 1.32 mycroft off_t a_length;
2337 1.32 mycroft int a_flags;
2338 1.32 mycroft struct ucred *a_cred;
2339 1.32 mycroft struct proc *a_p;
2340 1.32 mycroft } */ *ap;
2341 1.32 mycroft {
2342 1.32 mycroft
2343 1.32 mycroft /* Use nfs_setattr */
2344 1.32 mycroft printf("nfs_truncate: need to implement!!");
2345 1.32 mycroft return (EOPNOTSUPP);
2346 1.32 mycroft }
2347 1.3 glass
2348 1.3 glass /*
2349 1.32 mycroft * NFS update.
2350 1.32 mycroft */
2351 1.32 mycroft int
2352 1.32 mycroft nfs_update(ap)
2353 1.32 mycroft struct vop_update_args /* {
2354 1.32 mycroft struct vnode *a_vp;
2355 1.32 mycroft struct timeval *a_ta;
2356 1.32 mycroft struct timeval *a_tm;
2357 1.32 mycroft int a_waitfor;
2358 1.32 mycroft } */ *ap;
2359 1.3 glass {
2360 1.32 mycroft
2361 1.32 mycroft /* Use nfs_setattr */
2362 1.32 mycroft printf("nfs_update: need to implement!!");
2363 1.32 mycroft return (EOPNOTSUPP);
2364 1.3 glass }
2365 1.3 glass
2366 1.3 glass /*
2367 1.32 mycroft * nfs special file access vnode op.
2368 1.32 mycroft * Essentially just get vattr and then imitate iaccess() since the device is
2369 1.32 mycroft * local to the client.
2370 1.3 glass */
2371 1.32 mycroft int
2372 1.32 mycroft nfsspec_access(ap)
2373 1.32 mycroft struct vop_access_args /* {
2374 1.32 mycroft struct vnode *a_vp;
2375 1.32 mycroft int a_mode;
2376 1.32 mycroft struct ucred *a_cred;
2377 1.32 mycroft struct proc *a_p;
2378 1.32 mycroft } */ *ap;
2379 1.3 glass {
2380 1.46 mycroft struct vattr va;
2381 1.32 mycroft int error;
2382 1.3 glass
2383 1.46 mycroft if (error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred, ap->a_p))
2384 1.32 mycroft return (error);
2385 1.46 mycroft
2386 1.46 mycroft return (vaccess(va.va_mode, va.va_uid, va.va_gid, ap->a_mode,
2387 1.46 mycroft ap->a_cred));
2388 1.3 glass }
2389 1.22 pk
2390 1.22 pk /*
2391 1.22 pk * Read wrapper for special devices.
2392 1.22 pk */
2393 1.32 mycroft int
2394 1.32 mycroft nfsspec_read(ap)
2395 1.32 mycroft struct vop_read_args /* {
2396 1.32 mycroft struct vnode *a_vp;
2397 1.32 mycroft struct uio *a_uio;
2398 1.32 mycroft int a_ioflag;
2399 1.32 mycroft struct ucred *a_cred;
2400 1.32 mycroft } */ *ap;
2401 1.32 mycroft {
2402 1.32 mycroft register struct nfsnode *np = VTONFS(ap->a_vp);
2403 1.32 mycroft
2404 1.32 mycroft /*
2405 1.32 mycroft * Set access flag.
2406 1.32 mycroft */
2407 1.32 mycroft np->n_flag |= NACC;
2408 1.32 mycroft np->n_atim = time;
2409 1.32 mycroft return (VOCALL(spec_vnodeop_p, VOFFSET(vop_read), ap));
2410 1.22 pk }
2411 1.22 pk
2412 1.22 pk /*
2413 1.22 pk * Write wrapper for special devices.
2414 1.22 pk */
2415 1.32 mycroft int
2416 1.32 mycroft nfsspec_write(ap)
2417 1.32 mycroft struct vop_write_args /* {
2418 1.32 mycroft struct vnode *a_vp;
2419 1.32 mycroft struct uio *a_uio;
2420 1.32 mycroft int a_ioflag;
2421 1.32 mycroft struct ucred *a_cred;
2422 1.32 mycroft } */ *ap;
2423 1.32 mycroft {
2424 1.32 mycroft register struct nfsnode *np = VTONFS(ap->a_vp);
2425 1.32 mycroft
2426 1.32 mycroft /*
2427 1.32 mycroft * Set update flag.
2428 1.32 mycroft */
2429 1.32 mycroft np->n_flag |= NUPD;
2430 1.32 mycroft np->n_mtim = time;
2431 1.32 mycroft return (VOCALL(spec_vnodeop_p, VOFFSET(vop_write), ap));
2432 1.22 pk }
2433 1.22 pk
2434 1.22 pk /*
2435 1.22 pk * Close wrapper for special devices.
2436 1.22 pk *
2437 1.32 mycroft * Update the times on the nfsnode then do device close.
2438 1.22 pk */
2439 1.32 mycroft int
2440 1.32 mycroft nfsspec_close(ap)
2441 1.32 mycroft struct vop_close_args /* {
2442 1.32 mycroft struct vnode *a_vp;
2443 1.32 mycroft int a_fflag;
2444 1.32 mycroft struct ucred *a_cred;
2445 1.32 mycroft struct proc *a_p;
2446 1.32 mycroft } */ *ap;
2447 1.22 pk {
2448 1.32 mycroft register struct vnode *vp = ap->a_vp;
2449 1.32 mycroft register struct nfsnode *np = VTONFS(vp);
2450 1.32 mycroft struct vattr vattr;
2451 1.32 mycroft
2452 1.32 mycroft if (np->n_flag & (NACC | NUPD)) {
2453 1.32 mycroft np->n_flag |= NCHG;
2454 1.32 mycroft if (vp->v_usecount == 1 &&
2455 1.32 mycroft (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
2456 1.32 mycroft VATTR_NULL(&vattr);
2457 1.32 mycroft if (np->n_flag & NACC) {
2458 1.32 mycroft vattr.va_atime.ts_sec = np->n_atim.tv_sec;
2459 1.32 mycroft vattr.va_atime.ts_nsec =
2460 1.32 mycroft np->n_atim.tv_usec * 1000;
2461 1.32 mycroft }
2462 1.32 mycroft if (np->n_flag & NUPD) {
2463 1.32 mycroft vattr.va_mtime.ts_sec = np->n_mtim.tv_sec;
2464 1.32 mycroft vattr.va_mtime.ts_nsec =
2465 1.32 mycroft np->n_mtim.tv_usec * 1000;
2466 1.32 mycroft }
2467 1.32 mycroft (void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_p);
2468 1.32 mycroft }
2469 1.22 pk }
2470 1.32 mycroft return (VOCALL(spec_vnodeop_p, VOFFSET(vop_close), ap));
2471 1.22 pk }
2472 1.22 pk
2473 1.22 pk #ifdef FIFO
2474 1.22 pk /*
2475 1.32 mycroft * Read wrapper for fifos.
2476 1.22 pk */
2477 1.32 mycroft int
2478 1.32 mycroft nfsfifo_read(ap)
2479 1.32 mycroft struct vop_read_args /* {
2480 1.32 mycroft struct vnode *a_vp;
2481 1.32 mycroft struct uio *a_uio;
2482 1.32 mycroft int a_ioflag;
2483 1.32 mycroft struct ucred *a_cred;
2484 1.32 mycroft } */ *ap;
2485 1.22 pk {
2486 1.32 mycroft extern int (**fifo_vnodeop_p)();
2487 1.32 mycroft register struct nfsnode *np = VTONFS(ap->a_vp);
2488 1.32 mycroft
2489 1.22 pk /*
2490 1.32 mycroft * Set access flag.
2491 1.22 pk */
2492 1.32 mycroft np->n_flag |= NACC;
2493 1.32 mycroft np->n_atim = time;
2494 1.32 mycroft return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_read), ap));
2495 1.22 pk }
2496 1.22 pk
2497 1.22 pk /*
2498 1.32 mycroft * Write wrapper for fifos.
2499 1.22 pk */
2500 1.32 mycroft int
2501 1.32 mycroft nfsfifo_write(ap)
2502 1.32 mycroft struct vop_write_args /* {
2503 1.32 mycroft struct vnode *a_vp;
2504 1.32 mycroft struct uio *a_uio;
2505 1.32 mycroft int a_ioflag;
2506 1.32 mycroft struct ucred *a_cred;
2507 1.32 mycroft } */ *ap;
2508 1.22 pk {
2509 1.32 mycroft extern int (**fifo_vnodeop_p)();
2510 1.32 mycroft register struct nfsnode *np = VTONFS(ap->a_vp);
2511 1.32 mycroft
2512 1.22 pk /*
2513 1.32 mycroft * Set update flag.
2514 1.22 pk */
2515 1.32 mycroft np->n_flag |= NUPD;
2516 1.32 mycroft np->n_mtim = time;
2517 1.32 mycroft return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_write), ap));
2518 1.22 pk }
2519 1.22 pk
2520 1.22 pk /*
2521 1.32 mycroft * Close wrapper for fifos.
2522 1.22 pk *
2523 1.32 mycroft * Update the times on the nfsnode then do fifo close.
2524 1.22 pk */
2525 1.32 mycroft int
2526 1.32 mycroft nfsfifo_close(ap)
2527 1.32 mycroft struct vop_close_args /* {
2528 1.32 mycroft struct vnode *a_vp;
2529 1.32 mycroft int a_fflag;
2530 1.32 mycroft struct ucred *a_cred;
2531 1.32 mycroft struct proc *a_p;
2532 1.32 mycroft } */ *ap;
2533 1.22 pk {
2534 1.32 mycroft register struct vnode *vp = ap->a_vp;
2535 1.32 mycroft register struct nfsnode *np = VTONFS(vp);
2536 1.32 mycroft struct vattr vattr;
2537 1.32 mycroft extern int (**fifo_vnodeop_p)();
2538 1.32 mycroft
2539 1.32 mycroft if (np->n_flag & (NACC | NUPD)) {
2540 1.32 mycroft if (np->n_flag & NACC)
2541 1.32 mycroft np->n_atim = time;
2542 1.32 mycroft if (np->n_flag & NUPD)
2543 1.32 mycroft np->n_mtim = time;
2544 1.32 mycroft np->n_flag |= NCHG;
2545 1.32 mycroft if (vp->v_usecount == 1 &&
2546 1.32 mycroft (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
2547 1.32 mycroft VATTR_NULL(&vattr);
2548 1.32 mycroft if (np->n_flag & NACC) {
2549 1.32 mycroft vattr.va_atime.ts_sec = np->n_atim.tv_sec;
2550 1.32 mycroft vattr.va_atime.ts_nsec =
2551 1.32 mycroft np->n_atim.tv_usec * 1000;
2552 1.32 mycroft }
2553 1.32 mycroft if (np->n_flag & NUPD) {
2554 1.32 mycroft vattr.va_mtime.ts_sec = np->n_mtim.tv_sec;
2555 1.32 mycroft vattr.va_mtime.ts_nsec =
2556 1.32 mycroft np->n_mtim.tv_usec * 1000;
2557 1.32 mycroft }
2558 1.32 mycroft (void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_p);
2559 1.32 mycroft }
2560 1.22 pk }
2561 1.32 mycroft return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_close), ap));
2562 1.22 pk }
2563 1.22 pk #endif /* FIFO */
2564