![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nfs_vnops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / nfs|
Return to nfs_vnops.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / nfs |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
26: /*
27: * Copyright (c) 1989, 1993
28: * The Regents of the University of California. All rights reserved.
29: *
30: * This code is derived from software contributed to Berkeley by
31: * Rick Macklem at The University of Guelph.
32: *
33: * Redistribution and use in source and binary forms, with or without
34: * modification, are permitted provided that the following conditions
35: * are met:
36: * 1. Redistributions of source code must retain the above copyright
37: * notice, this list of conditions and the following disclaimer.
38: * 2. Redistributions in binary form must reproduce the above copyright
39: * notice, this list of conditions and the following disclaimer in the
40: * documentation and/or other materials provided with the distribution.
41: * 3. All advertising materials mentioning features or use of this software
42: * must display the following acknowledgement:
43: * This product includes software developed by the University of
44: * California, Berkeley and its contributors.
45: * 4. Neither the name of the University nor the names of its contributors
46: * may be used to endorse or promote products derived from this software
47: * without specific prior written permission.
48: *
49: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59: * SUCH DAMAGE.
60: *
61: * @(#)nfs_vnops.c 8.16 (Berkeley) 5/27/95
62: * FreeBSD-Id: nfs_vnops.c,v 1.72 1997/11/07 09:20:48 phk Exp $
63: */
64:
65:
66: /*
67: * vnode op calls for Sun NFS version 2 and 3
68: */
69:
70: #include <mach_nbc.h>
71: #include <sys/param.h>
72: #include <sys/kernel.h>
73: #include <sys/systm.h>
74: #include <sys/resourcevar.h>
75: #include <sys/proc.h>
76: #include <sys/mount.h>
77: #include <sys/buf.h>
78: #include <sys/malloc.h>
79: #include <sys/mbuf.h>
80: #include <sys/conf.h>
81: #include <sys/namei.h>
82: #include <sys/vnode.h>
83: #include <sys/dirent.h>
84: #include <sys/fcntl.h>
85: #include <sys/lockf.h>
86: #include <ufs/ufs/dir.h>
87:
88: #include <sys/vm.h>
89: #include <machine/spl.h>
90:
91: #include <miscfs/fifofs/fifo.h>
92: #include <miscfs/specfs/specdev.h>
93:
94: #include <nfs/rpcv2.h>
95: #include <nfs/nfsproto.h>
96: #include <nfs/nfs.h>
97: #include <nfs/nfsnode.h>
98: #include <nfs/nfsmount.h>
99: #include <nfs/xdr_subs.h>
100: #include <nfs/nfsm_subs.h>
101: #include <nfs/nqnfs.h>
102:
103: #include <net/if.h>
104: #include <netinet/in.h>
105: #include <netinet/in_var.h>
106: #include <kern/mapfs.h>
107:
108: #define TRUE 1
109: #define FALSE 0
110:
111: /* XXX CSM 11/25/97 Revisit when Ramesh merges vm with buffer cache
112: * Ifdef for FreeBSD-current merged buffer cache. It is unfortunate that these
113: * calls are not in getblk() and brelse() so that they would not be necessary
114: * here.
115: */
116: #ifndef B_VMIO
117: #define vfs_busy_pages(bp, f)
118: #define vfs_unbusy_pages(bp)
119: #endif
120:
121: static int nfsspec_read __P((struct vop_read_args *));
122: static int nfsspec_write __P((struct vop_write_args *));
123: static int nfsfifo_read __P((struct vop_read_args *));
124: static int nfsfifo_write __P((struct vop_write_args *));
125: static int nfsspec_close __P((struct vop_close_args *));
126: static int nfsfifo_close __P((struct vop_close_args *));
127: #define nfs_poll vop_nopoll
128: static int nfs_ioctl __P((struct vop_ioctl_args *));
129: static int nfs_select __P((struct vop_select_args *));
130: static int nfs_flush __P((struct vnode *,struct ucred *,int,struct proc *,int));
131: static int nfs_setattrrpc __P((struct vnode *,struct vattr *,struct ucred *,struct proc *));
132: static int nfs_lookup __P((struct vop_lookup_args *));
133: static int nfs_create __P((struct vop_create_args *));
134: static int nfs_mknod __P((struct vop_mknod_args *));
135: static int nfs_open __P((struct vop_open_args *));
136: static int nfs_close __P((struct vop_close_args *));
137: static int nfs_access __P((struct vop_access_args *));
138: static int nfs_getattr __P((struct vop_getattr_args *));
139: static int nfs_setattr __P((struct vop_setattr_args *));
140: static int nfs_read __P((struct vop_read_args *));
141: static int nfs_mmap __P((struct vop_mmap_args *));
142: static int nfs_fsync __P((struct vop_fsync_args *));
143: static int nfs_remove __P((struct vop_remove_args *));
144: static int nfs_link __P((struct vop_link_args *));
145: static int nfs_rename __P((struct vop_rename_args *));
146: static int nfs_mkdir __P((struct vop_mkdir_args *));
147: static int nfs_rmdir __P((struct vop_rmdir_args *));
148: static int nfs_symlink __P((struct vop_symlink_args *));
149: static int nfs_readdir __P((struct vop_readdir_args *));
150: static int nfs_bmap __P((struct vop_bmap_args *));
151: static int nfs_strategy __P((struct vop_strategy_args *));
152: static int nfs_lookitup __P((struct vnode *,char *,int,struct ucred *,struct proc *,struct nfsnode **));
153: static int nfs_sillyrename __P((struct vnode *,struct vnode *,struct componentname *));
154: static int nfsspec_access __P((struct vop_access_args *));
155: static int nfs_readlink __P((struct vop_readlink_args *));
156: static int nfs_print __P((struct vop_print_args *));
157: static int nfs_pathconf __P((struct vop_pathconf_args *));
158: static int nfs_advlock __P((struct vop_advlock_args *));
159: static int nfs_blkatoff __P((struct vop_blkatoff_args *));
160: static int nfs_bwrite __P((struct vop_bwrite_args *));
161: static int nfs_valloc __P((struct vop_valloc_args *));
162: static int nfs_vfree __P((struct vop_vfree_args *));
163: static int nfs_truncate __P((struct vop_truncate_args *));
164: static int nfs_update __P((struct vop_update_args *));
165: static int nfs_pagein __P((struct vop_pagein_args *));
166: static int nfs_pageout __P((struct vop_pageout_args *));
167: /*
168: * Global vfs data structures for nfs
169: */
170: vop_t **nfsv2_vnodeop_p;
171: static struct vnodeopv_entry_desc nfsv2_vnodeop_entries[] = {
172: { &vop_default_desc, (vop_t *)vn_default_error },
173: { &vop_lookup_desc, (vop_t *)nfs_lookup }, /* lookup */
174: { &vop_create_desc, (vop_t *)nfs_create }, /* create */
175: { &vop_mknod_desc, (vop_t *)nfs_mknod }, /* mknod */
176: { &vop_open_desc, (vop_t *)nfs_open }, /* open */
177: { &vop_close_desc, (vop_t *)nfs_close }, /* close */
178: { &vop_access_desc, (vop_t *)nfs_access }, /* access */
179: { &vop_getattr_desc, (vop_t *)nfs_getattr }, /* getattr */
180: { &vop_setattr_desc, (vop_t *)nfs_setattr }, /* setattr */
181: { &vop_read_desc, (vop_t *)nfs_read }, /* read */
182: { &vop_write_desc, (vop_t *)nfs_write }, /* write */
183: { &vop_lease_desc, (vop_t *)nfs_lease_check }, /* lease */
184: { &vop_ioctl_desc, (vop_t *)nfs_ioctl }, /* ioctl */
185: { &vop_select_desc, (vop_t *)nfs_select }, /* select */
186: { &vop_revoke_desc, (vop_t *)nfs_revoke }, /* revoke */
187: { &vop_mmap_desc, (vop_t *)nfs_mmap }, /* mmap */
188: { &vop_fsync_desc, (vop_t *)nfs_fsync }, /* fsync */
189: { &vop_seek_desc, (vop_t *)nfs_seek }, /* seek */
190: { &vop_remove_desc, (vop_t *)nfs_remove }, /* remove */
191: { &vop_link_desc, (vop_t *)nfs_link }, /* link */
192: { &vop_rename_desc, (vop_t *)nfs_rename }, /* rename */
193: { &vop_mkdir_desc, (vop_t *)nfs_mkdir }, /* mkdir */
194: { &vop_rmdir_desc, (vop_t *)nfs_rmdir }, /* rmdir */
195: { &vop_symlink_desc, (vop_t *)nfs_symlink }, /* symlink */
196: { &vop_readdir_desc, (vop_t *)nfs_readdir }, /* readdir */
197: { &vop_readlink_desc, (vop_t *)nfs_readlink }, /* readlink */
198: { &vop_abortop_desc, (vop_t *)nfs_abortop }, /* abortop */
199: { &vop_inactive_desc, (vop_t *)nfs_inactive }, /* inactive */
200: { &vop_reclaim_desc, (vop_t *)nfs_reclaim }, /* reclaim */
201: { &vop_lock_desc, (vop_t *)nfs_lock }, /* lock */
202: { &vop_unlock_desc, (vop_t *)nfs_unlock }, /* unlock */
203: { &vop_bmap_desc, (vop_t *)nfs_bmap }, /* bmap */
204: { &vop_strategy_desc, (vop_t *)nfs_strategy }, /* strategy */
205: { &vop_print_desc, (vop_t *)nfs_print }, /* print */
206: { &vop_islocked_desc, (vop_t *)nfs_islocked }, /* islocked */
207: { &vop_pathconf_desc, (vop_t *)nfs_pathconf }, /* pathconf */
208: { &vop_advlock_desc, (vop_t *)nfs_advlock }, /* advlock */
209: { &vop_blkatoff_desc, (vop_t *)nfs_blkatoff }, /* blkatoff */
210: { &vop_valloc_desc, (vop_t *)nfs_valloc }, /* valloc */
211: { &vop_reallocblks_desc, (vop_t *)nfs_reallocblks }, /* reallocblks */
212: { &vop_vfree_desc, (vop_t *)nfs_vfree }, /* vfree */
213: { &vop_truncate_desc, (vop_t *)nfs_truncate }, /* truncate */
214: { &vop_update_desc, (vop_t *)nfs_update }, /* update */
215: { &vop_bwrite_desc, (vop_t *)nfs_bwrite }, /* bwrite */
216: { &vop_pagein_desc, nfs_pagein }, /* Pagein */
217: { &vop_pageout_desc, nfs_pageout }, /* Pageout */
218: { NULL, NULL }
219: };
220: struct vnodeopv_desc nfsv2_vnodeop_opv_desc =
221: { &nfsv2_vnodeop_p, nfsv2_vnodeop_entries };
222: #ifdef __FreeBSD__
223: VNODEOP_SET(nfsv2_vnodeop_opv_desc);
224: #endif
225:
226: /*
227: * Special device vnode ops
228: */
229: vop_t **spec_nfsv2nodeop_p;
230: static struct vnodeopv_entry_desc spec_nfsv2nodeop_entries[] = {
231: { &vop_default_desc, (vop_t *)vn_default_error },
232: { &vop_lookup_desc, (vop_t *)spec_lookup }, /* lookup */
233: { &vop_create_desc, (vop_t *)spec_create }, /* create */
234: { &vop_mknod_desc, (vop_t *)spec_mknod }, /* mknod */
235: { &vop_open_desc, (vop_t *)spec_open }, /* open */
236: { &vop_close_desc, (vop_t *)nfsspec_close }, /* close */
237: { &vop_access_desc, (vop_t *)nfsspec_access }, /* access */
238: { &vop_getattr_desc, (vop_t *)nfs_getattr }, /* getattr */
239: { &vop_setattr_desc, (vop_t *)nfs_setattr }, /* setattr */
240: { &vop_read_desc, (vop_t *)nfsspec_read }, /* read */
241: { &vop_write_desc, (vop_t *)nfsspec_write }, /* write */
242: { &vop_lease_desc, (vop_t *)spec_lease_check }, /* lease */
243: { &vop_ioctl_desc, (vop_t *)spec_ioctl }, /* ioctl */
244: { &vop_select_desc, (vop_t *)spec_select }, /* select */
245: { &vop_revoke_desc, (vop_t *)spec_revoke }, /* revoke */
246: { &vop_mmap_desc, (vop_t *)spec_mmap }, /* mmap */
247: { &vop_fsync_desc, (vop_t *)nfs_fsync }, /* fsync */
248: { &vop_seek_desc, (vop_t *)spec_seek }, /* seek */
249: { &vop_remove_desc, (vop_t *)spec_remove }, /* remove */
250: { &vop_link_desc, (vop_t *)spec_link }, /* link */
251: { &vop_rename_desc, (vop_t *)spec_rename }, /* rename */
252: { &vop_mkdir_desc, (vop_t *)spec_mkdir }, /* mkdir */
253: { &vop_rmdir_desc, (vop_t *)spec_rmdir }, /* rmdir */
254: { &vop_symlink_desc, (vop_t *)spec_symlink }, /* symlink */
255: { &vop_readdir_desc, (vop_t *)spec_readdir }, /* readdir */
256: { &vop_readlink_desc, (vop_t *)spec_readlink }, /* readlink */
257: { &vop_abortop_desc, (vop_t *)spec_abortop }, /* abortop */
258: { &vop_inactive_desc, (vop_t *)nfs_inactive }, /* inactive */
259: { &vop_reclaim_desc, (vop_t *)nfs_reclaim }, /* reclaim */
260: { &vop_lock_desc, (vop_t *)nfs_lock }, /* lock */
261: { &vop_unlock_desc, (vop_t *)nfs_unlock }, /* unlock */
262: { &vop_bmap_desc, (vop_t *)spec_bmap }, /* bmap */
263: { &vop_strategy_desc, (vop_t *)spec_strategy }, /* strategy */
264: { &vop_print_desc, (vop_t *)nfs_print }, /* print */
265: { &vop_islocked_desc, (vop_t *)nfs_islocked }, /* islocked */
266: { &vop_pathconf_desc, (vop_t *)spec_pathconf }, /* pathconf */
267: { &vop_advlock_desc, (vop_t *)spec_advlock }, /* advlock */
268: { &vop_blkatoff_desc, (vop_t *)spec_blkatoff }, /* blkatoff */
269: { &vop_valloc_desc, (vop_t *)spec_valloc }, /* valloc */
270: { &vop_reallocblks_desc, (vop_t *)spec_reallocblks }, /* reallocblks */
271: { &vop_vfree_desc, (vop_t *)spec_vfree }, /* vfree */
272: { &vop_truncate_desc, (vop_t *)spec_truncate }, /* truncate */
273: { &vop_update_desc, (vop_t *)nfs_update }, /* update */
274: { &vop_bwrite_desc, (vop_t *)vn_bwrite }, /* bwrite */
275: #ifdef NeXT
276: { &vop_devblocksize_desc, spec_devblocksize }, /* devblocksize */
277: #endif /* NeXT */
278: { &vop_pagein_desc, nfs_pagein }, /* Pagein */
279: { &vop_pageout_desc, nfs_pageout }, /* Pageout */
280: { NULL, NULL }
281: };
282: struct vnodeopv_desc spec_nfsv2nodeop_opv_desc =
283: { &spec_nfsv2nodeop_p, spec_nfsv2nodeop_entries };
284: #ifdef __FreeBSD__
285: VNODEOP_SET(spec_nfsv2nodeop_opv_desc);
286: #endif
287:
288: vop_t **fifo_nfsv2nodeop_p;
289: static struct vnodeopv_entry_desc fifo_nfsv2nodeop_entries[] = {
290: { &vop_default_desc, (vop_t *)vn_default_error },
291: { &vop_lookup_desc, (vop_t *)fifo_lookup }, /* lookup */
292: { &vop_create_desc, (vop_t *)fifo_create }, /* create */
293: { &vop_mknod_desc, (vop_t *)fifo_mknod }, /* mknod */
294: { &vop_open_desc, (vop_t *)fifo_open }, /* open */
295: { &vop_close_desc, (vop_t *)nfsfifo_close }, /* close */
296: { &vop_access_desc, (vop_t *)nfsspec_access }, /* access */
297: { &vop_getattr_desc, (vop_t *)nfs_getattr }, /* getattr */
298: { &vop_setattr_desc, (vop_t *)nfs_setattr }, /* setattr */
299: { &vop_read_desc, (vop_t *)nfsfifo_read }, /* read */
300: { &vop_write_desc, (vop_t *)nfsfifo_write }, /* write */
301: { &vop_lease_desc, (vop_t *)fifo_lease_check }, /* lease */
302: { &vop_ioctl_desc, (vop_t *)fifo_ioctl }, /* ioctl */
303: { &vop_select_desc, (vop_t *)fifo_select }, /* select */
304: { &vop_revoke_desc, (vop_t *)fifo_revoke }, /* revoke */
305: { &vop_mmap_desc, (vop_t *)fifo_mmap }, /* mmap */
306: { &vop_fsync_desc, (vop_t *)nfs_fsync }, /* fsync */
307: { &vop_seek_desc, (vop_t *)fifo_seek }, /* seek */
308: { &vop_remove_desc, (vop_t *)fifo_remove }, /* remove */
309: { &vop_link_desc, (vop_t *)fifo_link }, /* link */
310: { &vop_rename_desc, (vop_t *)fifo_rename }, /* rename */
311: { &vop_mkdir_desc, (vop_t *)fifo_mkdir }, /* mkdir */
312: { &vop_rmdir_desc, (vop_t *)fifo_rmdir }, /* rmdir */
313: { &vop_symlink_desc, (vop_t *)fifo_symlink }, /* symlink */
314: { &vop_readdir_desc, (vop_t *)fifo_readdir }, /* readdir */
315: { &vop_readlink_desc, (vop_t *)fifo_readlink }, /* readlink */
316: { &vop_abortop_desc, (vop_t *)fifo_abortop }, /* abortop */
317: { &vop_inactive_desc, (vop_t *)nfs_inactive }, /* inactive */
318: { &vop_reclaim_desc, (vop_t *)nfs_reclaim }, /* reclaim */
319: { &vop_lock_desc, (vop_t *)nfs_lock }, /* lock */
320: { &vop_unlock_desc, (vop_t *)nfs_unlock }, /* unlock */
321: { &vop_bmap_desc, (vop_t *)fifo_bmap }, /* bmap */
322: { &vop_strategy_desc, (vop_t *)fifo_badop }, /* strategy */
323: { &vop_print_desc, (vop_t *)nfs_print }, /* print */
324: { &vop_islocked_desc, (vop_t *)nfs_islocked }, /* islocked */
325: { &vop_pathconf_desc, (vop_t *)fifo_pathconf }, /* pathconf */
326: { &vop_advlock_desc, (vop_t *)fifo_advlock }, /* advlock */
327: { &vop_blkatoff_desc, (vop_t *)fifo_blkatoff }, /* blkatoff */
328: { &vop_valloc_desc, (vop_t *)fifo_valloc }, /* valloc */
329: { &vop_reallocblks_desc, (vop_t *)fifo_reallocblks }, /* reallocblks */
330: { &vop_vfree_desc, (vop_t *)fifo_vfree }, /* vfree */
331: { &vop_truncate_desc, (vop_t *)fifo_truncate }, /* truncate */
332: { &vop_update_desc, (vop_t *)nfs_update }, /* update */
333: { &vop_bwrite_desc, (vop_t *)vn_bwrite }, /* bwrite */
334: { &vop_pagein_desc, nfs_pagein }, /* Pagein */
335: { &vop_pageout_desc, nfs_pageout }, /* Pageout */
336: { NULL, NULL }
337: };
338: struct vnodeopv_desc fifo_nfsv2nodeop_opv_desc =
339: { &fifo_nfsv2nodeop_p, fifo_nfsv2nodeop_entries };
340: #ifdef __FreeBSD__
341: VNODEOP_SET(fifo_nfsv2nodeop_opv_desc);
342: #endif
343:
344: static int nfs_commit __P((struct vnode *vp, u_quad_t offset, int cnt,
345: struct ucred *cred, struct proc *procp));
346: static int nfs_mknodrpc __P((struct vnode *dvp, struct vnode **vpp,
347: struct componentname *cnp,
348: struct vattr *vap));
349: static int nfs_removerpc __P((struct vnode *dvp, char *name, int namelen,
350: struct ucred *cred, struct proc *proc));
351: static int nfs_renamerpc __P((struct vnode *fdvp, char *fnameptr,
352: int fnamelen, struct vnode *tdvp,
353: char *tnameptr, int tnamelen,
354: struct ucred *cred, struct proc *proc));
355: static int nfs_renameit __P((struct vnode *sdvp,
356: struct componentname *scnp,
357: struct sillyrename *sp));
358:
359: /*
360: * Global variables
361: */
362: extern u_long nfs_true, nfs_false;
363: extern struct nfsstats nfsstats;
364: extern nfstype nfsv3_type[9];
365: struct proc *nfs_iodwant[NFS_MAXASYNCDAEMON];
366: struct nfsmount *nfs_iodmount[NFS_MAXASYNCDAEMON];
367: int nfs_numasync = 0;
368: #define DIRHDSIZ (sizeof (struct dirent) - (MAXNAMLEN + 1))
369:
370: /*
371: * nfs access vnode op.
372: * For nfs version 2, just return ok. File accesses may fail later.
373: * For nfs version 3, use the access rpc to check accessibility. If file modes
374: * are changed on the server, accesses might still fail later.
375: */
376: static int
377: nfs_access(ap)
378: struct vop_access_args /* {
379: struct vnode *a_vp;
380: int a_mode;
381: struct ucred *a_cred;
382: struct proc *a_p;
383: } */ *ap;
384: {
385: register struct vnode *vp = ap->a_vp;
386: register u_long *tl;
387: register caddr_t cp;
388: register int t1, t2;
389: caddr_t bpos, dpos, cp2;
390: int error = 0, attrflag;
391: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
392: u_long mode, rmode;
393: int v3 = NFS_ISV3(vp);
394:
395: /*
396: * For nfs v3, do an access rpc, otherwise you are stuck emulating
397: * ufs_access() locally using the vattr. This may not be correct,
398: * since the server may apply other access criteria such as
399: * client uid-->server uid mapping that we do not know about, but
400: * this is better than just returning anything that is lying about
401: * in the cache.
402: */
403: if (v3) {
404: nfsstats.rpccnt[NFSPROC_ACCESS]++;
405: nfsm_reqhead(vp, NFSPROC_ACCESS, NFSX_FH(v3) + NFSX_UNSIGNED);
406: nfsm_fhtom(vp, v3);
407: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
408: if (ap->a_mode & VREAD)
409: mode = NFSV3ACCESS_READ;
410: else
411: mode = 0;
412: if (vp->v_type == VDIR) {
413: if (ap->a_mode & VWRITE)
414: mode |= (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND |
415: NFSV3ACCESS_DELETE);
416: if (ap->a_mode & VEXEC)
417: mode |= NFSV3ACCESS_LOOKUP;
418: } else {
419: if (ap->a_mode & VWRITE)
420: mode |= (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND);
421: if (ap->a_mode & VEXEC)
422: mode |= NFSV3ACCESS_EXECUTE;
423: }
424: *tl = txdr_unsigned(mode);
425: nfsm_request(vp, NFSPROC_ACCESS, ap->a_p, ap->a_cred);
426: nfsm_postop_attr(vp, attrflag);
427: if (!error) {
428: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
429: rmode = fxdr_unsigned(u_long, *tl);
430: /*
431: * The NFS V3 spec does not clarify whether or not
432: * the returned access bits can be a superset of
433: * the ones requested, so...
434: */
435: if ((rmode & mode) != mode)
436: error = EACCES;
437: }
438: nfsm_reqdone;
439: return (error);
440: } else
441: return (nfsspec_access(ap));
442: /* CSM - moved EROFS check down per NetBSD rev 1.71. So you
443: * get the correct error value with layered filesystems. */
444: /*
445: * Disallow write attempts on filesystems mounted read-only;
446: * unless the file is a socket, fifo, or a block or character
447: * device resident on the filesystem.
448: */
449: if ((ap->a_mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
450: switch (vp->v_type) {
451: case VREG: case VDIR: case VLNK:
452: return (EROFS);
453: }
454: }
455: }
456:
457: /*
458: * nfs open vnode op
459: * Check to see if the type is ok
460: * and that deletion is not in progress.
461: * For paged in text files, you will need to flush the page cache
462: * if consistency is lost.
463: */
464: /* ARGSUSED */
465: static int
466: nfs_open(ap)
467: struct vop_open_args /* {
468: struct vnode *a_vp;
469: int a_mode;
470: struct ucred *a_cred;
471: struct proc *a_p;
472: } */ *ap;
473: {
474: register struct vnode *vp = ap->a_vp;
475: struct nfsnode *np = VTONFS(vp);
476: struct nfsmount *nmp = VFSTONFS(vp->v_mount);
477: struct vattr vattr;
478: int error;
479:
480: if (vp->v_type != VREG && vp->v_type != VDIR && vp->v_type != VLNK)
481: { printf("open eacces vtyp=%d\n",vp->v_type);
482: return (EACCES);
483: }
484: /*
485: * Get a valid lease. If cached data is stale, flush it.
486: */
487: if (nmp->nm_flag & NFSMNT_NQNFS) {
488: if (NQNFS_CKINVALID(vp, np, ND_READ)) {
489: do {
490: error = nqnfs_getlease(vp, ND_READ, ap->a_cred,
491: ap->a_p);
492: } while (error == NQNFS_EXPIRED);
493: if (error)
494: return (error);
495: if (np->n_lrev != np->n_brev ||
496: (np->n_flag & NQNFSNONCACHE)) {
497: if ((error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred,
498: ap->a_p, 1)) == EINTR)
499: return (error);
500: (void) vnode_uncache(vp);
501: np->n_brev = np->n_lrev;
502: }
503: }
504: } else {
505: if (np->n_flag & NMODIFIED) {
506: if ((error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred,
507: ap->a_p, 1)) == EINTR)
508: return (error);
509: (void) vnode_uncache(vp);
510: np->n_attrstamp = 0;
511: if (vp->v_type == VDIR)
512: np->n_direofoffset = 0;
513: error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_p);
514: if (error)
515: return (error);
516: np->n_mtime = vattr.va_mtime.tv_sec;
517: } else {
518: error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_p);
519: if (error)
520: return (error);
521: if (np->n_mtime != vattr.va_mtime.tv_sec) {
522: if (vp->v_type == VDIR)
523: np->n_direofoffset = 0;
524: if ((error = nfs_vinvalbuf(vp, V_SAVE,
525: ap->a_cred, ap->a_p, 1)) == EINTR)
526: return (error);
527: (void) vnode_uncache(vp);
528: np->n_mtime = vattr.va_mtime.tv_sec;
529: }
530: }
531: }
532: if ((nmp->nm_flag & NFSMNT_NQNFS) == 0)
533: np->n_attrstamp = 0; /* For Open/Close consistency */
534: return (0);
535: }
536:
537: /*
538: * nfs close vnode op
539: * What an NFS client should do upon close after writing is a debatable issue.
540: * Most NFS clients push delayed writes to the server upon close, basically for
541: * two reasons:
542: * 1 - So that any write errors may be reported back to the client process
543: * doing the close system call. By far the two most likely errors are
544: * NFSERR_NOSPC and NFSERR_DQUOT to indicate space allocation failure.
545: * 2 - To put a worst case upper bound on cache inconsistency between
546: * multiple clients for the file.
547: * There is also a consistency problem for Version 2 of the protocol w.r.t.
548: * not being able to tell if other clients are writing a file concurrently,
549: * since there is no way of knowing if the changed modify time in the reply
550: * is only due to the write for this client.
551: * (NFS Version 3 provides weak cache consistency data in the reply that
552: * should be sufficient to detect and handle this case.)
553: *
554: * The current code does the following:
555: * for NFS Version 2 - play it safe and flush/invalidate all dirty buffers
556: * for NFS Version 3 - flush dirty buffers to the server but don't invalidate
557: * or commit them (this satisfies 1 and 2 except for the
558: * case where the server crashes after this close but
559: * before the commit RPC, which is felt to be "good
560: * enough". Changing the last argument to nfs_flush() to
561: * a 1 would force a commit operation, if it is felt a
562: * commit is necessary now.
563: * for NQNFS - do nothing now, since 2 is dealt with via leases and
564: * 1 should be dealt with via an fsync() system call for
565: * cases where write errors are important.
566: */
567: /* ARGSUSED */
568: static int
569: nfs_close(ap)
570: struct vop_close_args /* {
571: struct vnodeop_desc *a_desc;
572: struct vnode *a_vp;
573: int a_fflag;
574: struct ucred *a_cred;
575: struct proc *a_p;
576: } */ *ap;
577: {
578: register struct vnode *vp = ap->a_vp;
579: register struct nfsnode *np = VTONFS(vp);
580: int error = 0;
581:
582: if (vp->v_type == VREG) {
583: #if DIAGNOSTIC
584: register struct sillyrename *sp = np->n_sillyrename;
585: if (sp)
586: kprintf("nfs_close: %s, dvp=%x, vp=%x, ap=%x, np=%x, sp=%x\n",
587: &sp->s_name[0], (unsigned)(sp->s_dvp), (unsigned)vp,
588: (unsigned)ap, (unsigned)np, (unsigned)sp);
589: #endif
590: if ((VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NQNFS) == 0 &&
591: (np->n_flag & NMODIFIED)) {
592: if (NFS_ISV3(vp)) {
593: error = nfs_flush(vp, ap->a_cred, MNT_WAIT, ap->a_p, 0);
594: np->n_flag &= ~NMODIFIED;
595: } else
596: error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_p, 1);
597: np->n_attrstamp = 0;
598: }
599: if (np->n_flag & NWRITEERR) {
600: np->n_flag &= ~NWRITEERR;
601: error = np->n_error;
602: }
603: }
604: return (error);
605: }
606:
607: /*
608: * nfs getattr call from vfs.
609: */
610: static int
611: nfs_getattr(ap)
612: struct vop_getattr_args /* {
613: struct vnode *a_vp;
614: struct vattr *a_vap;
615: struct ucred *a_cred;
616: struct proc *a_p;
617: } */ *ap;
618: {
619: register struct vnode *vp = ap->a_vp;
620: register struct nfsnode *np = VTONFS(vp);
621: register caddr_t cp;
622: register u_long *tl;
623: register int t1, t2;
624: caddr_t bpos, dpos;
625: int error = 0;
626: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
627: int v3 = NFS_ISV3(vp);
628:
629: /*
630: * Update local times for special files.
631: */
632: if (np->n_flag & (NACC | NUPD))
633: np->n_flag |= NCHG;
634: /*
635: * First look in the cache.
636: */
637: if (nfs_getattrcache(vp, ap->a_vap) == 0)
638: return (0);
639: nfsstats.rpccnt[NFSPROC_GETATTR]++;
640: nfsm_reqhead(vp, NFSPROC_GETATTR, NFSX_FH(v3));
641: nfsm_fhtom(vp, v3);
642: nfsm_request(vp, NFSPROC_GETATTR, ap->a_p, ap->a_cred);
643: if (!error) {
644: nfsm_loadattr(vp, ap->a_vap);
645: #if MACH_NBC
646: if (np->n_mtime != ap->a_vap->va_mtime.tv_sec) {
647: NFSTRACE(NFSTRC_GA_INV, vp);
648: if (vp->v_type == VDIR)
649: nfs_invaldir(vp);
650: error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred,
651: ap->a_p, 1);
652: if (!error) {
653: NFSTRACE(NFSTRC_GA_INV1, vp);
654: np->n_mtime = ap->a_vap->va_mtime.tv_sec;
655: } else {
656: NFSTRACE(NFSTRC_GA_INV2, error);
657: }
658: }
659: #endif /* MACH_NBC */
660: }
661: nfsm_reqdone;
662: return (error);
663: }
664:
665: /*
666: * nfs setattr call.
667: */
668: static int
669: nfs_setattr(ap)
670: struct vop_setattr_args /* {
671: struct vnodeop_desc *a_desc;
672: struct vnode *a_vp;
673: struct vattr *a_vap;
674: struct ucred *a_cred;
675: struct proc *a_p;
676: } */ *ap;
677: {
678: register struct vnode *vp = ap->a_vp;
679: register struct nfsnode *np = VTONFS(vp);
680: register struct vattr *vap = ap->a_vap;
681: int error = 0;
682: u_quad_t tsize;
683:
684: #ifndef nolint
685: tsize = (u_quad_t)0;
686: #endif
687: /*
688: * Disallow write attempts if the filesystem is mounted read-only.
689: */
690: if ((vap->va_flags != VNOVAL || vap->va_uid != (uid_t)VNOVAL ||
691: vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL ||
692: vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL) &&
693: (vp->v_mount->mnt_flag & MNT_RDONLY))
694: return (EROFS);
695: if (vap->va_size != VNOVAL) {
696: switch (vp->v_type) {
697: case VDIR:
698: return (EISDIR);
699: case VCHR:
700: case VBLK:
701: case VSOCK:
702: case VFIFO:
703: if (vap->va_mtime.tv_sec == VNOVAL &&
704: vap->va_atime.tv_sec == VNOVAL &&
705: vap->va_mode == (u_short)VNOVAL &&
706: vap->va_uid == (uid_t)VNOVAL &&
707: vap->va_gid == (gid_t)VNOVAL)
708: return (0);
709: vap->va_size = VNOVAL;
710: break;
711: default:
712: /*
713: * Disallow write attempts if the filesystem is
714: * mounted read-only.
715: */
716: if (vp->v_mount->mnt_flag & MNT_RDONLY)
717: return (EROFS);
718: np->n_flag |= NMODIFIED;
719: /*
720: * save n_size first as mapfs_trunc can trigger
721: * size change via nfs_bio
722: */
723: tsize = np->n_size;
724: #if MACH_NBC
725: if ((vp->v_type == VREG) && (vp->v_vm_info)
726: && vp->v_vm_info->mapped) {
727: error = mapfs_trunc(vp,vap->va_size);
728: if (error) {
729: #if DIAGNOSTIC
730: kprintf("nfs_setattr: mapfs_trunc %d\n",
731: error);
732: #endif /* DIAGNOSTIC */
733: return (error);
734: }
735: } else {
736: #endif /* MACH_NBC */
737: vnode_pager_setsize(vp, (u_long)vap->va_size);
738: #if MACH_NBC
739: }
740: #endif /* MACH_NBC */
741: if (vap->va_size == 0)
742: error = nfs_vinvalbuf(vp, 0,
743: ap->a_cred, ap->a_p, 1);
744: else
745: error = nfs_vinvalbuf(vp, V_SAVE,
746: ap->a_cred, ap->a_p, 1);
747: if (error) {
748: #if DIAGNOSTIC
749: kprintf("nfs_setattr: nfs_vinvalbuf %d\n",
750: error);
751: #endif /* DIAGNOSTIC */
752: return (error);
753: }
754: np->n_size = np->n_vattr.va_size = vap->va_size;
755:
756: };
757: } else if ((vap->va_mtime.tv_sec != VNOVAL ||
758: vap->va_atime.tv_sec != VNOVAL) && (np->n_flag & NMODIFIED) &&
759: vp->v_type == VREG &&
760: (error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred,
761: ap->a_p, 1)) == EINTR)
762: return (error);
763: error = nfs_setattrrpc(vp, vap, ap->a_cred, ap->a_p);
764: if (error && vap->va_size != VNOVAL) {
765: /* make every effort to resync file size w/ server... */
766: int err = 0; /* preserve "error" for return */
767:
768: #if DIAGNOSTIC
769: kprintf("nfs_setattr: nfs_setattrrpc %d\n", error);
770: #endif /* DIAGNOSTIC */
771: np->n_size = np->n_vattr.va_size = tsize;
772: #if MACH_NBC
773: if (vp->v_type == VREG && vp->v_vm_info &&
774: vp->v_vm_info->mapped) {
775: err = mapfs_trunc(vp, tsize);
776: #if DIAGNOSTIC
777: if (err)
778: kprintf("nfs_setattr mapfs_trunc %d\n", err);
779: #endif /* DIAGNOSTIC */
780: } else {
781: #endif /* MACH_NBC */
782: vnode_pager_setsize(vp, (u_long)np->n_size);
783: #if MACH_NBC
784: }
785: #endif /* MACH_NBC */
786: vap->va_size = tsize;
787: err = nfs_setattrrpc(vp, vap, ap->a_cred, ap->a_p);
788: #if DIAGNOSTIC
789: if (err)
790: kprintf("nfs_setattr nfs_setattrrpc %d\n", err);
791: #endif /* DIAGNOSTIC */
792: }
793: return (error);
794: }
795:
796: /*
797: * Do an nfs setattr rpc.
798: */
799: static int
800: nfs_setattrrpc(vp, vap, cred, procp)
801: register struct vnode *vp;
802: register struct vattr *vap;
803: struct ucred *cred;
804: struct proc *procp;
805: {
806: register struct nfsv2_sattr *sp;
807: register caddr_t cp;
808: register long t1, t2;
809: caddr_t bpos, dpos, cp2;
810: u_long *tl;
811: int error = 0, wccflag = NFSV3_WCCRATTR;
812: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
813: int v3 = NFS_ISV3(vp);
814:
815: nfsstats.rpccnt[NFSPROC_SETATTR]++;
816: nfsm_reqhead(vp, NFSPROC_SETATTR, NFSX_FH(v3) + NFSX_SATTR(v3));
817: nfsm_fhtom(vp, v3);
818: if (v3) {
819: if (vap->va_mode != (u_short)VNOVAL) {
820: nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
821: *tl++ = nfs_true;
822: *tl = txdr_unsigned(vap->va_mode);
823: } else {
824: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
825: *tl = nfs_false;
826: }
827: if (vap->va_uid != (uid_t)VNOVAL) {
828: nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
829: *tl++ = nfs_true;
830: *tl = txdr_unsigned(vap->va_uid);
831: } else {
832: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
833: *tl = nfs_false;
834: }
835: if (vap->va_gid != (gid_t)VNOVAL) {
836: nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
837: *tl++ = nfs_true;
838: *tl = txdr_unsigned(vap->va_gid);
839: } else {
840: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
841: *tl = nfs_false;
842: }
843: if (vap->va_size != VNOVAL) {
844: nfsm_build(tl, u_long *, 3 * NFSX_UNSIGNED);
845: *tl++ = nfs_true;
846: txdr_hyper(&vap->va_size, tl);
847: } else {
848: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
849: *tl = nfs_false;
850: }
851: if (vap->va_atime.tv_sec != VNOVAL) {
852: if (vap->va_atime.tv_sec != time.tv_sec) {
853: nfsm_build(tl, u_long *, 3 * NFSX_UNSIGNED);
854: *tl++ = txdr_unsigned(NFSV3SATTRTIME_TOCLIENT);
855: txdr_nfsv3time(&vap->va_atime, tl);
856: } else {
857: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
858: *tl = txdr_unsigned(NFSV3SATTRTIME_TOSERVER);
859: }
860: } else {
861: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
862: *tl = txdr_unsigned(NFSV3SATTRTIME_DONTCHANGE);
863: }
864: if (vap->va_mtime.tv_sec != VNOVAL) {
865: if (vap->va_mtime.tv_sec != time.tv_sec) {
866: nfsm_build(tl, u_long *, 3 * NFSX_UNSIGNED);
867: *tl++ = txdr_unsigned(NFSV3SATTRTIME_TOCLIENT);
868: txdr_nfsv3time(&vap->va_mtime, tl);
869: } else {
870: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
871: *tl = txdr_unsigned(NFSV3SATTRTIME_TOSERVER);
872: }
873: } else {
874: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
875: *tl = txdr_unsigned(NFSV3SATTRTIME_DONTCHANGE);
876: }
877: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
878: *tl = nfs_false;
879: } else {
880: nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
881: if (vap->va_mode == (u_short)VNOVAL)
882: sp->sa_mode = VNOVAL;
883: else
884: sp->sa_mode = vtonfsv2_mode(vp->v_type, vap->va_mode);
885: if (vap->va_uid == (uid_t)VNOVAL)
886: sp->sa_uid = VNOVAL;
887: else
888: sp->sa_uid = txdr_unsigned(vap->va_uid);
889: if (vap->va_gid == (gid_t)VNOVAL)
890: sp->sa_gid = VNOVAL;
891: else
892: sp->sa_gid = txdr_unsigned(vap->va_gid);
893: sp->sa_size = txdr_unsigned(vap->va_size);
894: txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
895: txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
896: }
897: nfsm_request(vp, NFSPROC_SETATTR, procp, cred);
898: if (v3) {
899: nfsm_wcc_data(vp, wccflag);
900: if (!wccflag)
901: VTONFS(vp)->n_attrstamp = 0;
902: } else
903: nfsm_loadattr(vp, (struct vattr *)0);
904: nfsm_reqdone;
905: return (error);
906: }
907:
908: /*
909: * nfs lookup call, one step at a time...
910: * First look in cache
911: * If not found, unlock the directory nfsnode and do the rpc
912: */
913: static int
914: nfs_lookup(ap)
915: struct vop_lookup_args /* {
916: struct vnodeop_desc *a_desc;
917: struct vnode *a_dvp;
918: struct vnode **a_vpp;
919: struct componentname *a_cnp;
920: } */ *ap;
921: {
922: register struct componentname *cnp = ap->a_cnp;
923: register struct vnode *dvp = ap->a_dvp;
924: register struct vnode **vpp = ap->a_vpp;
925: register int flags = cnp->cn_flags;
926: register struct vnode *newvp;
927: register u_long *tl;
928: register caddr_t cp;
929: register long t1, t2;
930: struct nfsmount *nmp;
931: caddr_t bpos, dpos, cp2;
932: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
933: long len;
934: nfsfh_t *fhp;
935: struct nfsnode *np;
936: int lockparent, wantparent, error = 0, attrflag, fhsize;
937: int v3 = NFS_ISV3(dvp);
938: struct proc *p = cnp->cn_proc;
939:
940: if ((flags & ISLASTCN) && (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
941: (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
942: return (EROFS);
943: *vpp = NULLVP;
944: if (dvp->v_type != VDIR)
945: return (ENOTDIR);
946: lockparent = flags & LOCKPARENT;
947: wantparent = flags & (LOCKPARENT|WANTPARENT);
948: nmp = VFSTONFS(dvp->v_mount);
949: np = VTONFS(dvp);
950: if ((error = cache_lookup(dvp, vpp, cnp)) && error != ENOENT) {
951: struct vattr vattr;
952: int vpid;
953:
954: if ((error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, p))) {
955: *vpp = NULLVP;
956: return (error);
957: }
958:
959: newvp = *vpp;
960: vpid = newvp->v_id;
961: /*
962: * See the comment starting `Step through' in ufs/ufs_lookup.c
963: * for an explanation of the locking protocol
964: */
965: if (dvp == newvp) {
966: VREF(newvp);
967: error = 0;
968: } else if (flags & ISDOTDOT) {
969: VOP_UNLOCK(dvp, 0, p);
970: error = vget(newvp, LK_EXCLUSIVE, p);
971: if (!error && lockparent && (flags & ISLASTCN))
972: error = vn_lock(dvp, LK_EXCLUSIVE, p);
973: } else {
974: error = vget(newvp, LK_EXCLUSIVE, p);
975: if (!lockparent || error || !(flags & ISLASTCN))
976: VOP_UNLOCK(dvp, 0, p);
977: }
978: if (!error) {
979: if (vpid == newvp->v_id) {
980: if (!VOP_GETATTR(newvp, &vattr, cnp->cn_cred, p)
981: && vattr.va_ctime.tv_sec == VTONFS(newvp)->n_ctime) {
982: nfsstats.lookupcache_hits++;
983: if (cnp->cn_nameiop != LOOKUP &&
984: (flags & ISLASTCN))
985: cnp->cn_flags |= SAVENAME;
986: return (0);
987: }
988: cache_purge(newvp);
989: }
990: vput(newvp);
991: if (lockparent && dvp != newvp && (flags & ISLASTCN))
992: VOP_UNLOCK(dvp, 0, p);
993: }
994: error = vn_lock(dvp, LK_EXCLUSIVE, p);
995: *vpp = NULLVP;
996: if (error)
997: return (error);
998: }
999: error = 0;
1000: newvp = NULLVP;
1001: nfsstats.lookupcache_misses++;
1002: nfsstats.rpccnt[NFSPROC_LOOKUP]++;
1003: len = cnp->cn_namelen;
1004: nfsm_reqhead(dvp, NFSPROC_LOOKUP,
1005: NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len));
1006: nfsm_fhtom(dvp, v3);
1007: nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN);
1008: nfsm_request(dvp, NFSPROC_LOOKUP, cnp->cn_proc, cnp->cn_cred);
1009: if (error) {
1010: nfsm_postop_attr(dvp, attrflag);
1011: m_freem(mrep);
1012: goto nfsmout;
1013: }
1014: nfsm_getfh(fhp, fhsize, v3);
1015:
1016: /*
1017: * Handle RENAME case...
1018: */
1019: if (cnp->cn_nameiop == RENAME && wantparent && (flags & ISLASTCN)) {
1020: if (NFS_CMPFH(np, fhp, fhsize)) {
1021: m_freem(mrep);
1022: return (EISDIR);
1023: }
1024: if ((error = nfs_nget(dvp->v_mount, fhp, fhsize, &np))) {
1025: m_freem(mrep);
1026: return (error);
1027: }
1028: newvp = NFSTOV(np);
1029: if (v3) {
1030: nfsm_postop_attr(newvp, attrflag);
1031: nfsm_postop_attr(dvp, attrflag);
1032: } else
1033: nfsm_loadattr(newvp, (struct vattr *)0);
1034: *vpp = newvp;
1035: m_freem(mrep);
1036: cnp->cn_flags |= SAVENAME;
1037: if (!lockparent)
1038: VOP_UNLOCK(dvp, 0, p);
1039: return (0);
1040: }
1041:
1042: if (flags & ISDOTDOT) {
1043: VOP_UNLOCK(dvp, 0, p);
1044: error = nfs_nget(dvp->v_mount, fhp, fhsize, &np);
1045: if (error) {
1046: vn_lock(dvp, LK_EXCLUSIVE + LK_RETRY, p);
1047: return (error);
1048: }
1049: newvp = NFSTOV(np);
1050: if (lockparent && (flags & ISLASTCN) &&
1051: (error = vn_lock(dvp, LK_EXCLUSIVE, p))) {
1052: vput(newvp);
1053: return (error);
1054: }
1055: } else if (NFS_CMPFH(np, fhp, fhsize)) {
1056: VREF(dvp);
1057: newvp = dvp;
1058: } else {
1059: if ((error = nfs_nget(dvp->v_mount, fhp, fhsize, &np))) {
1060: m_freem(mrep);
1061: return (error);
1062: }
1063: if (!lockparent || !(flags & ISLASTCN))
1064: VOP_UNLOCK(dvp, 0, p);
1065: newvp = NFSTOV(np);
1066: }
1067: if (v3) {
1068: nfsm_postop_attr(newvp, attrflag);
1069: nfsm_postop_attr(dvp, attrflag);
1070: } else
1071: nfsm_loadattr(newvp, (struct vattr *)0);
1072: if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
1073: cnp->cn_flags |= SAVENAME;
1074: if ((cnp->cn_flags & MAKEENTRY) &&
1075: (cnp->cn_nameiop != DELETE || !(flags & ISLASTCN))) {
1076: np->n_ctime = np->n_vattr.va_ctime.tv_sec;
1077: cache_enter(dvp, newvp, cnp);
1078: }
1079: *vpp = newvp;
1080: nfsm_reqdone;
1081: if (error) {
1082: if (newvp != NULLVP) {
1083: vrele(newvp);
1084: *vpp = NULLVP;
1085: }
1086: if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME) &&
1087: (flags & ISLASTCN) && error == ENOENT) {
1088: if (!lockparent)
1089: VOP_UNLOCK(dvp, 0, p);
1090: if (dvp->v_mount->mnt_flag & MNT_RDONLY)
1091: error = EROFS;
1092: else
1093: error = EJUSTRETURN;
1094: }
1095: if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
1096: cnp->cn_flags |= SAVENAME;
1097: }
1098: return (error);
1099: }
1100:
1101: /*
1102: * nfs read call.
1103: * Just call nfs_bioread() to do the work.
1104: */
1105: static int
1106: nfs_read(ap)
1107: struct vop_read_args /* {
1108: struct vnode *a_vp;
1109: struct uio *a_uio;
1110: int a_ioflag;
1111: struct ucred *a_cred;
1112: } */ *ap;
1113: {
1114: register struct vnode *vp = ap->a_vp;
1115:
1116: if (vp->v_type != VREG)
1117: return (EPERM);
1118: return (nfs_bioread(vp, ap->a_uio, ap->a_ioflag, ap->a_cred, 0));
1119: }
1120:
1121: /*
1122: * nfs readlink call
1123: */
1124: static int
1125: nfs_readlink(ap)
1126: struct vop_readlink_args /* {
1127: struct vnode *a_vp;
1128: struct uio *a_uio;
1129: struct ucred *a_cred;
1130: } */ *ap;
1131: {
1132: register struct vnode *vp = ap->a_vp;
1133:
1134: if (vp->v_type != VLNK)
1135: return (EPERM);
1136: return (nfs_bioread(vp, ap->a_uio, 0, ap->a_cred, 0));
1137: }
1138:
1139: /*
1140: * Do a readlink rpc.
1141: * Called by nfs_doio() from below the buffer cache.
1142: */
1143: int
1144: nfs_readlinkrpc(vp, uiop, cred)
1145: register struct vnode *vp;
1146: struct uio *uiop;
1147: struct ucred *cred;
1148: {
1149: register u_long *tl;
1150: register caddr_t cp;
1151: register long t1, t2;
1152: caddr_t bpos, dpos, cp2;
1153: int error = 0, len, attrflag;
1154: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1155: int v3 = NFS_ISV3(vp);
1156:
1157: nfsstats.rpccnt[NFSPROC_READLINK]++;
1158: nfsm_reqhead(vp, NFSPROC_READLINK, NFSX_FH(v3));
1159: nfsm_fhtom(vp, v3);
1160: nfsm_request(vp, NFSPROC_READLINK, uiop->uio_procp, cred);
1161: if (v3)
1162: nfsm_postop_attr(vp, attrflag);
1163: if (!error) {
1164: nfsm_strsiz(len, NFS_MAXPATHLEN);
1165: nfsm_mtouio(uiop, len);
1166: }
1167: nfsm_reqdone;
1168: return (error);
1169: }
1170:
1171: /*
1172: * nfs read rpc call
1173: * Ditto above
1174: */
1175: int
1176: nfs_readrpc(vp, uiop, cred)
1177: register struct vnode *vp;
1178: struct uio *uiop;
1179: struct ucred *cred;
1180: {
1181: register u_long *tl;
1182: register caddr_t cp;
1183: register long t1, t2;
1184: caddr_t bpos, dpos, cp2;
1185: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1186: struct nfsmount *nmp;
1187: int error = 0, len, retlen, tsiz, eof, attrflag;
1188: int v3 = NFS_ISV3(vp);
1189:
1190: #ifndef nolint
1191: eof = 0;
1192: #endif
1193: nmp = VFSTONFS(vp->v_mount);
1194: tsiz = uiop->uio_resid;
1195: if (uiop->uio_offset + tsiz > 0xffffffff && !v3)
1196: return (EFBIG);
1197: while (tsiz > 0) {
1198: nfsstats.rpccnt[NFSPROC_READ]++;
1199: len = (tsiz > nmp->nm_rsize) ? nmp->nm_rsize : tsiz;
1200: nfsm_reqhead(vp, NFSPROC_READ, NFSX_FH(v3) + NFSX_UNSIGNED * 3);
1201: nfsm_fhtom(vp, v3);
1202: nfsm_build(tl, u_long *, NFSX_UNSIGNED * 3);
1203: if (v3) {
1204: txdr_hyper(&uiop->uio_offset, tl);
1205: *(tl + 2) = txdr_unsigned(len);
1206: } else {
1207: *tl++ = txdr_unsigned(uiop->uio_offset);
1208: *tl++ = txdr_unsigned(len);
1209: *tl = 0;
1210: }
1211: nfsm_request(vp, NFSPROC_READ, uiop->uio_procp, cred);
1212: if (v3) {
1213: nfsm_postop_attr(vp, attrflag);
1214: if (error) {
1215: m_freem(mrep);
1216: goto nfsmout;
1217: }
1218: nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
1219: eof = fxdr_unsigned(int, *(tl + 1));
1220: } else
1221: nfsm_loadattr(vp, (struct vattr *)0);
1222: nfsm_strsiz(retlen, nmp->nm_rsize);
1223: nfsm_mtouio(uiop, retlen);
1224: m_freem(mrep);
1225: tsiz -= retlen;
1226: if (v3) {
1227: if (eof || retlen == 0)
1228: tsiz = 0;
1229: } else if (retlen < len)
1230: tsiz = 0;
1231: }
1232: nfsmout:
1233: return (error);
1234: }
1235:
1236: /*
1237: * nfs write call
1238: */
1239: int
1240: nfs_writerpc(vp, uiop, cred, iomode, must_commit)
1241: register struct vnode *vp;
1242: register struct uio *uiop;
1243: struct ucred *cred;
1244: int *iomode, *must_commit;
1245: {
1246: register u_long *tl;
1247: register caddr_t cp;
1248: register int t1, t2, backup;
1249: caddr_t bpos, dpos, cp2;
1250: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1251: struct nfsmount *nmp = VFSTONFS(vp->v_mount);
1252: int error = 0, len, tsiz, wccflag = NFSV3_WCCRATTR, rlen, commit;
1253: int v3 = NFS_ISV3(vp), committed = NFSV3WRITE_FILESYNC;
1254:
1255: #if DIAGNOSTIC
1256: if (uiop->uio_iovcnt != 1)
1257: panic("nfs: writerpc iovcnt > 1");
1258: #endif
1259: *must_commit = 0;
1260: tsiz = uiop->uio_resid;
1261: if (uiop->uio_offset + tsiz > 0xffffffff && !v3)
1262: return (EFBIG);
1263: while (tsiz > 0) {
1264: nfsstats.rpccnt[NFSPROC_WRITE]++;
1265: len = (tsiz > nmp->nm_wsize) ? nmp->nm_wsize : tsiz;
1266: nfsm_reqhead(vp, NFSPROC_WRITE,
1267: NFSX_FH(v3) + 5 * NFSX_UNSIGNED + nfsm_rndup(len));
1268: nfsm_fhtom(vp, v3);
1269: if (v3) {
1270: nfsm_build(tl, u_long *, 5 * NFSX_UNSIGNED);
1271: txdr_hyper(&uiop->uio_offset, tl);
1272: tl += 2;
1273: *tl++ = txdr_unsigned(len);
1274: *tl++ = txdr_unsigned(*iomode);
1275: } else {
1276: nfsm_build(tl, u_long *, 4 * NFSX_UNSIGNED);
1277: *++tl = txdr_unsigned(uiop->uio_offset);
1278: tl += 2;
1279: }
1280: *tl = txdr_unsigned(len);
1281: nfsm_uiotom(uiop, len);
1282: nfsm_request(vp, NFSPROC_WRITE, uiop->uio_procp, cred);
1283: if (v3) {
1284: wccflag = NFSV3_WCCCHK;
1285: nfsm_wcc_data(vp, wccflag);
1286: if (!error) {
1287: nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED +
1288: NFSX_V3WRITEVERF);
1289: rlen = fxdr_unsigned(int, *tl++);
1290: if (rlen == 0) {
1291: error = NFSERR_IO;
1292: break;
1293: } else if (rlen < len) {
1294: backup = len - rlen;
1295: uiop->uio_iov->iov_base -= backup;
1296: uiop->uio_iov->iov_len += backup;
1297: uiop->uio_offset -= backup;
1298: uiop->uio_resid += backup;
1299: len = rlen;
1300: }
1301: commit = fxdr_unsigned(int, *tl++);
1302:
1303: /*
1304: * Return the lowest committment level
1305: * obtained by any of the RPCs.
1306: */
1307: if (committed == NFSV3WRITE_FILESYNC)
1308: committed = commit;
1309: else if (committed == NFSV3WRITE_DATASYNC &&
1310: commit == NFSV3WRITE_UNSTABLE)
1311: committed = commit;
1312: if ((nmp->nm_flag & NFSMNT_HASWRITEVERF) == 0) {
1313: bcopy((caddr_t)tl, (caddr_t)nmp->nm_verf,
1314: NFSX_V3WRITEVERF);
1315: nmp->nm_flag |= NFSMNT_HASWRITEVERF;
1316: } else if (bcmp((caddr_t)tl,
1317: (caddr_t)nmp->nm_verf, NFSX_V3WRITEVERF)) {
1318: *must_commit = 1;
1319: bcopy((caddr_t)tl, (caddr_t)nmp->nm_verf,
1320: NFSX_V3WRITEVERF);
1321: }
1322: }
1323: } else
1324: nfsm_loadattr(vp, (struct vattr *)0);
1325: if (wccflag)
1326: VTONFS(vp)->n_mtime = VTONFS(vp)->n_vattr.va_mtime.tv_sec;
1327: m_freem(mrep);
1328: tsiz -= len;
1329: }
1330: nfsmout:
1331: if (vp->v_mount->mnt_flag & MNT_ASYNC)
1332: committed = NFSV3WRITE_FILESYNC;
1333: *iomode = committed;
1334: if (error)
1335: uiop->uio_resid = tsiz;
1336: return (error);
1337: }
1338:
1339: /*
1340: * nfs mknod rpc
1341: * For NFS v2 this is a kludge. Use a create rpc but with the IFMT bits of the
1342: * mode set to specify the file type and the size field for rdev.
1343: */
1344: static int
1345: nfs_mknodrpc(dvp, vpp, cnp, vap)
1346: register struct vnode *dvp;
1347: register struct vnode **vpp;
1348: register struct componentname *cnp;
1349: register struct vattr *vap;
1350: {
1351: register struct nfsv2_sattr *sp;
1352: register struct nfsv3_sattr *sp3;
1353: register u_long *tl;
1354: register caddr_t cp;
1355: register long t1, t2;
1356: struct vnode *newvp = (struct vnode *)0;
1357: struct nfsnode *np = (struct nfsnode *)0;
1358: struct vattr vattr;
1359: char *cp2;
1360: caddr_t bpos, dpos;
1361: int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0;
1362: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1363: u_long rdev;
1364: int v3 = NFS_ISV3(dvp);
1365:
1366: if (vap->va_type == VCHR || vap->va_type == VBLK)
1367: rdev = txdr_unsigned(vap->va_rdev);
1368: else if (vap->va_type == VFIFO || vap->va_type == VSOCK)
1369: rdev = 0xffffffff;
1370: else {
1371: VOP_ABORTOP(dvp, cnp);
1372: vput(dvp);
1373: return (EOPNOTSUPP);
1374: }
1375: if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc))) {
1376: VOP_ABORTOP(dvp, cnp);
1377: vput(dvp);
1378: return (error);
1379: }
1380: nfsstats.rpccnt[NFSPROC_MKNOD]++;
1381: nfsm_reqhead(dvp, NFSPROC_MKNOD, NFSX_FH(v3) + 4 * NFSX_UNSIGNED +
1382: + nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(v3));
1383: nfsm_fhtom(dvp, v3);
1384: nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
1385: if (v3) {
1386: nfsm_build(tl, u_long *, NFSX_UNSIGNED + NFSX_V3SRVSATTR);
1387: *tl++ = vtonfsv3_type(vap->va_type);
1388: sp3 = (struct nfsv3_sattr *)tl;
1389: nfsm_v3sattr(sp3, vap, cnp->cn_cred->cr_uid, vattr.va_gid);
1390: if (vap->va_type == VCHR || vap->va_type == VBLK) {
1391: nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
1392: *tl++ = txdr_unsigned(major(vap->va_rdev));
1393: *tl = txdr_unsigned(minor(vap->va_rdev));
1394: }
1395: } else {
1396: nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
1397: sp->sa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
1398: sp->sa_uid = txdr_unsigned(cnp->cn_cred->cr_uid);
1399: sp->sa_gid = txdr_unsigned(vattr.va_gid);
1400: sp->sa_size = rdev;
1401: txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
1402: txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
1403: }
1404: nfsm_request(dvp, NFSPROC_MKNOD, cnp->cn_proc, cnp->cn_cred);
1405: if (!error) {
1406: nfsm_mtofh(dvp, newvp, v3, gotvp);
1407: if (!gotvp) {
1408: if (newvp) {
1409: vput(newvp);
1410: newvp = (struct vnode *)0;
1411: }
1412: error = nfs_lookitup(dvp, cnp->cn_nameptr,
1413: cnp->cn_namelen, cnp->cn_cred, cnp->cn_proc, &np);
1414: if (!error)
1415: newvp = NFSTOV(np);
1416: }
1417: }
1418: if (v3)
1419: nfsm_wcc_data(dvp, wccflag);
1420: nfsm_reqdone;
1421: if (error) {
1422: if (newvp)
1423: vput(newvp);
1424: } else {
1425: if (cnp->cn_flags & MAKEENTRY)
1426: cache_enter(dvp, newvp, cnp);
1427: *vpp = newvp;
1428: }
1429: FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1430: VTONFS(dvp)->n_flag |= NMODIFIED;
1431: if (!wccflag)
1432: VTONFS(dvp)->n_attrstamp = 0;
1433: vput(dvp);
1434: return (error);
1435: }
1436:
1437: /*
1438: * nfs mknod vop
1439: * just call nfs_mknodrpc() to do the work.
1440: */
1441: /* ARGSUSED */
1442: static int
1443: nfs_mknod(ap)
1444: struct vop_mknod_args /* {
1445: struct vnode *a_dvp;
1446: struct vnode **a_vpp;
1447: struct componentname *a_cnp;
1448: struct vattr *a_vap;
1449: } */ *ap;
1450: {
1451: struct vnode *newvp;
1452: int error;
1453:
1454: error = nfs_mknodrpc(ap->a_dvp, &newvp, ap->a_cnp, ap->a_vap);
1455: if (!error)
1456: vput(newvp);
1457: return (error);
1458: }
1459:
1460: static u_long create_verf;
1461: /*
1462: * nfs file create call
1463: */
1464: static int
1465: nfs_create(ap)
1466: struct vop_create_args /* {
1467: struct vnode *a_dvp;
1468: struct vnode **a_vpp;
1469: struct componentname *a_cnp;
1470: struct vattr *a_vap;
1471: } */ *ap;
1472: {
1473: register struct vnode *dvp = ap->a_dvp;
1474: register struct vattr *vap = ap->a_vap;
1475: register struct componentname *cnp = ap->a_cnp;
1476: register struct nfsv2_sattr *sp;
1477: register struct nfsv3_sattr *sp3;
1478: register u_long *tl;
1479: register caddr_t cp;
1480: register long t1, t2;
1481: struct nfsnode *np = (struct nfsnode *)0;
1482: struct vnode *newvp = (struct vnode *)0;
1483: caddr_t bpos, dpos, cp2;
1484: int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0, fmode = 0;
1485: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1486: struct vattr vattr;
1487: int v3 = NFS_ISV3(dvp);
1488:
1489: /*
1490: * Oops, not for me..
1491: */
1492: if (vap->va_type == VSOCK)
1493: return (nfs_mknodrpc(dvp, ap->a_vpp, cnp, vap));
1494:
1495: if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc))) {
1496: VOP_ABORTOP(dvp, cnp);
1497: vput(dvp);
1498: return (error);
1499: }
1500: if (vap->va_vaflags & VA_EXCLUSIVE)
1501: fmode |= O_EXCL;
1502: again:
1503: nfsstats.rpccnt[NFSPROC_CREATE]++;
1504: nfsm_reqhead(dvp, NFSPROC_CREATE, NFSX_FH(v3) + 2 * NFSX_UNSIGNED +
1505: nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(v3));
1506: nfsm_fhtom(dvp, v3);
1507: nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
1508: if (v3) {
1509: nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1510: if (fmode & O_EXCL) {
1511: *tl = txdr_unsigned(NFSV3CREATE_EXCLUSIVE);
1512: nfsm_build(tl, u_long *, NFSX_V3CREATEVERF);
1513: #ifdef notyet
1514: if (!TAILQ_EMPTY(&in_ifaddrhead))
1515: *tl++ = IA_SIN(in_ifaddrhead.tqh_first)->sin_addr.s_addr;
1516: #else
1517: if (in_ifaddr)
1518: *tl++ = IA_SIN(in_ifaddr)->sin_addr.s_addr;
1519: #endif
1520: else
1521: *tl++ = create_verf;
1522: *tl = ++create_verf;
1523: } else {
1524: *tl = txdr_unsigned(NFSV3CREATE_UNCHECKED);
1525: nfsm_build(tl, u_long *, NFSX_V3SRVSATTR);
1526: sp3 = (struct nfsv3_sattr *)tl;
1527: nfsm_v3sattr(sp3, vap, cnp->cn_cred->cr_uid, vattr.va_gid);
1528: }
1529: } else {
1530: nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
1531: sp->sa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
1532: sp->sa_uid = txdr_unsigned(cnp->cn_cred->cr_uid);
1533: sp->sa_gid = txdr_unsigned(vattr.va_gid);
1534: sp->sa_size = 0;
1535: txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
1536: txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
1537: }
1538: nfsm_request(dvp, NFSPROC_CREATE, cnp->cn_proc, cnp->cn_cred);
1539: if (!error) {
1540: nfsm_mtofh(dvp, newvp, v3, gotvp);
1541: if (!gotvp) {
1542: if (newvp) {
1543: vput(newvp);
1544: newvp = (struct vnode *)0;
1545: }
1546: error = nfs_lookitup(dvp, cnp->cn_nameptr,
1547: cnp->cn_namelen, cnp->cn_cred, cnp->cn_proc, &np);
1548: if (!error)
1549: newvp = NFSTOV(np);
1550: }
1551: }
1552: if (v3)
1553: nfsm_wcc_data(dvp, wccflag);
1554: nfsm_reqdone;
1555: if (error) {
1556: if (v3 && (fmode & O_EXCL) && error == NFSERR_NOTSUPP) {
1557: fmode &= ~O_EXCL;
1558: goto again;
1559: }
1560: if (newvp)
1561: vput(newvp);
1562: } else if (v3 && (fmode & O_EXCL))
1563: error = nfs_setattrrpc(newvp, vap, cnp->cn_cred, cnp->cn_proc);
1564: if (!error) {
1565: if (cnp->cn_flags & MAKEENTRY)
1566: cache_enter(dvp, newvp, cnp);
1567: *ap->a_vpp = newvp;
1568: }
1569: FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1570: VTONFS(dvp)->n_flag |= NMODIFIED;
1571: if (!wccflag)
1572: VTONFS(dvp)->n_attrstamp = 0;
1573: vput(dvp);
1574: return (error);
1575: }
1576:
1577: /*
1578: * nfs file remove call
1579: * To try and make nfs semantics closer to ufs semantics, a file that has
1580: * other processes using the vnode is renamed instead of removed and then
1581: * removed later on the last close.
1582: * - If v_usecount > 1
1583: * If a rename is not already in the works
1584: * call nfs_sillyrename() to set it up
1585: * else
1586: * do the remove rpc
1587: */
1588: static int
1589: nfs_remove(ap)
1590: struct vop_remove_args /* {
1591: struct vnodeop_desc *a_desc;
1592: struct vnode * a_dvp;
1593: struct vnode * a_vp;
1594: struct componentname * a_cnp;
1595: } */ *ap;
1596: {
1597: register struct vnode *vp = ap->a_vp;
1598: register struct vnode *dvp = ap->a_dvp;
1599: register struct componentname *cnp = ap->a_cnp;
1600: register struct nfsnode *np = VTONFS(vp);
1601: int error = 0;
1602: struct vattr vattr;
1603:
1604: #if DIAGNOSTIC
1605: if ((cnp->cn_flags & HASBUF) == 0)
1606: panic("nfs_remove: no name");
1607: if (vp->v_usecount < 1)
1608: panic("nfs_remove: bad v_usecount");
1609: #endif
1610: if (vp->v_usecount == 1 || (np->n_sillyrename &&
1611: VOP_GETATTR(vp, &vattr, cnp->cn_cred, cnp->cn_proc) == 0 &&
1612: vattr.va_nlink > 1)) {
1613: /*
1614: * Purge the name cache so that the chance of a lookup for
1615: * the name succeeding while the remove is in progress is
1616: * minimized. Without node locking it can still happen, such
1617: * that an I/O op returns ESTALE, but since you get this if
1618: * another host removes the file..
1619: */
1620: cache_purge(vp);
1621: /*
1622: * throw away biocache buffers, mainly to avoid
1623: * unnecessary delayed writes later.
1624: */
1625: error = nfs_vinvalbuf(vp, 0, cnp->cn_cred, cnp->cn_proc, 1);
1626: /* Do the rpc */
1627: if (error != EINTR)
1628: error = nfs_removerpc(dvp, cnp->cn_nameptr,
1629: cnp->cn_namelen, cnp->cn_cred, cnp->cn_proc);
1630: /*
1631: * Kludge City: If the first reply to the remove rpc is lost..
1632: * the reply to the retransmitted request will be ENOENT
1633: * since the file was in fact removed
1634: * Therefore, we cheat and return success.
1635: */
1636: if (error == ENOENT)
1637: error = 0;
1638: } else if (!np->n_sillyrename)
1639: error = nfs_sillyrename(dvp, vp, cnp);
1640: FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1641: np->n_attrstamp = 0;
1642: vput(dvp);
1643: if (vp == dvp)
1644: vrele(vp);
1645: else
1646: vput(vp);
1647: return (error);
1648: }
1649:
1650: /*
1651: * nfs file remove rpc called from nfs_inactive
1652: */
1653: int
1654: nfs_removeit(sp)
1655: register struct sillyrename *sp;
1656: {
1657:
1658: return (nfs_removerpc(sp->s_dvp, sp->s_name, sp->s_namlen, sp->s_cred,
1659: (struct proc *)0));
1660: }
1661:
1662: /*
1663: * Nfs remove rpc, called from nfs_remove() and nfs_removeit().
1664: */
1665: static int
1666: nfs_removerpc(dvp, name, namelen, cred, proc)
1667: register struct vnode *dvp;
1668: char *name;
1669: int namelen;
1670: struct ucred *cred;
1671: struct proc *proc;
1672: {
1673: register u_long *tl;
1674: register caddr_t cp;
1675: register long t1, t2;
1676: caddr_t bpos, dpos, cp2;
1677: int error = 0, wccflag = NFSV3_WCCRATTR;
1678: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1679: int v3 = NFS_ISV3(dvp);
1680:
1681: nfsstats.rpccnt[NFSPROC_REMOVE]++;
1682: nfsm_reqhead(dvp, NFSPROC_REMOVE,
1683: NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(namelen));
1684: nfsm_fhtom(dvp, v3);
1685: nfsm_strtom(name, namelen, NFS_MAXNAMLEN);
1686: nfsm_request(dvp, NFSPROC_REMOVE, proc, cred);
1687: if (v3)
1688: nfsm_wcc_data(dvp, wccflag);
1689: nfsm_reqdone;
1690: VTONFS(dvp)->n_flag |= NMODIFIED;
1691: if (!wccflag)
1692: VTONFS(dvp)->n_attrstamp = 0;
1693: return (error);
1694: }
1695:
1696: /*
1697: * nfs file rename call
1698: */
1699: static int
1700: nfs_rename(ap)
1701: struct vop_rename_args /* {
1702: struct vnode *a_fdvp;
1703: struct vnode *a_fvp;
1704: struct componentname *a_fcnp;
1705: struct vnode *a_tdvp;
1706: struct vnode *a_tvp;
1707: struct componentname *a_tcnp;
1708: } */ *ap;
1709: {
1710: register struct vnode *fvp = ap->a_fvp;
1711: register struct vnode *tvp = ap->a_tvp;
1712: register struct vnode *fdvp = ap->a_fdvp;
1713: register struct vnode *tdvp = ap->a_tdvp;
1714: register struct componentname *tcnp = ap->a_tcnp;
1715: register struct componentname *fcnp = ap->a_fcnp;
1716: int error;
1717:
1718: #if DIAGNOSTIC
1719: if ((tcnp->cn_flags & HASBUF) == 0 ||
1720: (fcnp->cn_flags & HASBUF) == 0)
1721: panic("nfs_rename: no name");
1722: #endif
1723: /* Check for cross-device rename */
1724: if ((fvp->v_mount != tdvp->v_mount) ||
1725: (tvp && (fvp->v_mount != tvp->v_mount))) {
1726: error = EXDEV;
1727: goto out;
1728: }
1729:
1730: /*
1731: * If the tvp exists and is in use, sillyrename it before doing the
1732: * rename of the new file over it.
1733: * XXX Can't sillyrename a directory.
1734: */
1735: if (tvp && tvp->v_usecount > 1 && !VTONFS(tvp)->n_sillyrename &&
1736: tvp->v_type != VDIR && !nfs_sillyrename(tdvp, tvp, tcnp)) {
1737: vput(tvp);
1738: tvp = NULL;
1739: }
1740:
1741: error = nfs_renamerpc(fdvp, fcnp->cn_nameptr, fcnp->cn_namelen,
1742: tdvp, tcnp->cn_nameptr, tcnp->cn_namelen, tcnp->cn_cred,
1743: tcnp->cn_proc);
1744:
1745: if (fvp->v_type == VDIR) {
1746: if (tvp != NULL && tvp->v_type == VDIR)
1747: cache_purge(tdvp);
1748: cache_purge(fdvp);
1749: }
1750: out:
1751: if (tdvp == tvp)
1752: vrele(tdvp);
1753: else
1754: vput(tdvp);
1755: if (tvp)
1756: vput(tvp);
1757: vrele(fdvp);
1758: vrele(fvp);
1759: /*
1760: * Kludge: Map ENOENT => 0 assuming that it is a reply to a retry.
1761: */
1762: if (error == ENOENT)
1763: error = 0;
1764: return (error);
1765: }
1766:
1767: /*
1768: * nfs file rename rpc called from nfs_remove() above
1769: */
1770: static int
1771: nfs_renameit(sdvp, scnp, sp)
1772: struct vnode *sdvp;
1773: struct componentname *scnp;
1774: register struct sillyrename *sp;
1775: {
1776: return (nfs_renamerpc(sdvp, scnp->cn_nameptr, scnp->cn_namelen,
1777: sdvp, sp->s_name, sp->s_namlen, scnp->cn_cred, scnp->cn_proc));
1778: }
1779:
1780: /*
1781: * Do an nfs rename rpc. Called from nfs_rename() and nfs_renameit().
1782: */
1783: static int
1784: nfs_renamerpc(fdvp, fnameptr, fnamelen, tdvp, tnameptr, tnamelen, cred, proc)
1785: register struct vnode *fdvp;
1786: char *fnameptr;
1787: int fnamelen;
1788: register struct vnode *tdvp;
1789: char *tnameptr;
1790: int tnamelen;
1791: struct ucred *cred;
1792: struct proc *proc;
1793: {
1794: register u_long *tl;
1795: register caddr_t cp;
1796: register long t1, t2;
1797: caddr_t bpos, dpos, cp2;
1798: int error = 0, fwccflag = NFSV3_WCCRATTR, twccflag = NFSV3_WCCRATTR;
1799: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1800: int v3 = NFS_ISV3(fdvp);
1801:
1802: nfsstats.rpccnt[NFSPROC_RENAME]++;
1803: nfsm_reqhead(fdvp, NFSPROC_RENAME,
1804: (NFSX_FH(v3) + NFSX_UNSIGNED)*2 + nfsm_rndup(fnamelen) +
1805: nfsm_rndup(tnamelen));
1806: nfsm_fhtom(fdvp, v3);
1807: nfsm_strtom(fnameptr, fnamelen, NFS_MAXNAMLEN);
1808: nfsm_fhtom(tdvp, v3);
1809: nfsm_strtom(tnameptr, tnamelen, NFS_MAXNAMLEN);
1810: nfsm_request(fdvp, NFSPROC_RENAME, proc, cred);
1811: if (v3) {
1812: nfsm_wcc_data(fdvp, fwccflag);
1813: nfsm_wcc_data(tdvp, twccflag);
1814: }
1815: nfsm_reqdone;
1816: VTONFS(fdvp)->n_flag |= NMODIFIED;
1817: VTONFS(tdvp)->n_flag |= NMODIFIED;
1818: if (!fwccflag)
1819: VTONFS(fdvp)->n_attrstamp = 0;
1820: if (!twccflag)
1821: VTONFS(tdvp)->n_attrstamp = 0;
1822: return (error);
1823: }
1824:
1825: /*
1826: * nfs hard link create call
1827: */
1828: static int
1829: nfs_link(ap)
1830: struct vop_link_args /* {
1831: struct vnode *a_vp;
1832: struct vnode *a_tdvp;
1833: struct componentname *a_cnp;
1834: } */ *ap;
1835: {
1836: register struct vnode *vp = ap->a_vp;
1837: register struct vnode *tdvp = ap->a_tdvp;
1838: register struct componentname *cnp = ap->a_cnp;
1839: register u_long *tl;
1840: register caddr_t cp;
1841: register long t1, t2;
1842: caddr_t bpos, dpos, cp2;
1843: int error = 0, wccflag = NFSV3_WCCRATTR, attrflag = 0;
1844: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1845: int v3 = NFS_ISV3(vp);
1846:
1847: if (vp->v_mount != tdvp->v_mount) {
1848: VOP_ABORTOP(vp, cnp);
1849: if (tdvp == vp)
1850: vrele(tdvp);
1851: else
1852: vput(tdvp);
1853: return (EXDEV);
1854: }
1855:
1856: /*
1857: * Push all writes to the server, so that the attribute cache
1858: * doesn't get "out of sync" with the server.
1859: * XXX There should be a better way!
1860: */
1861: VOP_FSYNC(vp, cnp->cn_cred, MNT_WAIT, cnp->cn_proc);
1862:
1863: nfsstats.rpccnt[NFSPROC_LINK]++;
1864: nfsm_reqhead(vp, NFSPROC_LINK,
1865: NFSX_FH(v3)*2 + NFSX_UNSIGNED + nfsm_rndup(cnp->cn_namelen));
1866: nfsm_fhtom(vp, v3);
1867: nfsm_fhtom(tdvp, v3);
1868: nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
1869: nfsm_request(vp, NFSPROC_LINK, cnp->cn_proc, cnp->cn_cred);
1870: if (v3) {
1871: nfsm_postop_attr(vp, attrflag);
1872: nfsm_wcc_data(tdvp, wccflag);
1873: }
1874: nfsm_reqdone;
1875: FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1876: VTONFS(tdvp)->n_flag |= NMODIFIED;
1877: if (!attrflag)
1878: VTONFS(vp)->n_attrstamp = 0;
1879: if (!wccflag)
1880: VTONFS(tdvp)->n_attrstamp = 0;
1881: vput(tdvp);
1882: /*
1883: * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
1884: */
1885: if (error == EEXIST)
1886: error = 0;
1887: return (error);
1888: }
1889:
1890: /*
1891: * nfs symbolic link create call
1892: */
1893: static int
1894: nfs_symlink(ap)
1895: struct vop_symlink_args /* {
1896: struct vnode *a_dvp;
1897: struct vnode **a_vpp;
1898: struct componentname *a_cnp;
1899: struct vattr *a_vap;
1900: char *a_target;
1901: } */ *ap;
1902: {
1903: register struct vnode *dvp = ap->a_dvp;
1904: register struct vattr *vap = ap->a_vap;
1905: register struct componentname *cnp = ap->a_cnp;
1906: register struct nfsv2_sattr *sp;
1907: register struct nfsv3_sattr *sp3;
1908: register u_long *tl;
1909: register caddr_t cp;
1910: register long t1, t2;
1911: caddr_t bpos, dpos, cp2;
1912: int slen, error = 0, wccflag = NFSV3_WCCRATTR, gotvp;
1913: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1914: struct vnode *newvp = (struct vnode *)0;
1915: int v3 = NFS_ISV3(dvp);
1916:
1917: nfsstats.rpccnt[NFSPROC_SYMLINK]++;
1918: slen = strlen(ap->a_target);
1919: nfsm_reqhead(dvp, NFSPROC_SYMLINK, NFSX_FH(v3) + 2*NFSX_UNSIGNED +
1920: nfsm_rndup(cnp->cn_namelen) + nfsm_rndup(slen) + NFSX_SATTR(v3));
1921: nfsm_fhtom(dvp, v3);
1922: nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
1923: if (v3) {
1924: nfsm_build(sp3, struct nfsv3_sattr *, NFSX_V3SRVSATTR);
1925: nfsm_v3sattr(sp3, vap, cnp->cn_cred->cr_uid,
1926: cnp->cn_cred->cr_gid);
1927: }
1928: nfsm_strtom(ap->a_target, slen, NFS_MAXPATHLEN);
1929: if (!v3) {
1930: nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
1931: sp->sa_mode = vtonfsv2_mode(VLNK, vap->va_mode);
1932: sp->sa_uid = txdr_unsigned(cnp->cn_cred->cr_uid);
1933: sp->sa_gid = txdr_unsigned(cnp->cn_cred->cr_gid);
1934: sp->sa_size = -1;
1935: txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
1936: txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
1937: }
1938: nfsm_request(dvp, NFSPROC_SYMLINK, cnp->cn_proc, cnp->cn_cred);
1939: if (v3) {
1940: if (!error)
1941: nfsm_mtofh(dvp, newvp, v3, gotvp);
1942: nfsm_wcc_data(dvp, wccflag);
1943: }
1944: nfsm_reqdone;
1945: if (newvp)
1946: vput(newvp);
1947: FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1948: VTONFS(dvp)->n_flag |= NMODIFIED;
1949: if (!wccflag)
1950: VTONFS(dvp)->n_attrstamp = 0;
1951: vput(dvp);
1952: /*
1953: * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
1954: */
1955: if (error == EEXIST)
1956: error = 0;
1957: return (error);
1958: }
1959:
1960: /*
1961: * nfs make dir call
1962: */
1963: static int
1964: nfs_mkdir(ap)
1965: struct vop_mkdir_args /* {
1966: struct vnode *a_dvp;
1967: struct vnode **a_vpp;
1968: struct componentname *a_cnp;
1969: struct vattr *a_vap;
1970: } */ *ap;
1971: {
1972: register struct vnode *dvp = ap->a_dvp;
1973: register struct vattr *vap = ap->a_vap;
1974: register struct componentname *cnp = ap->a_cnp;
1975: register struct nfsv2_sattr *sp;
1976: register struct nfsv3_sattr *sp3;
1977: register u_long *tl;
1978: register caddr_t cp;
1979: register long t1, t2;
1980: register int len;
1981: struct nfsnode *np = (struct nfsnode *)0;
1982: struct vnode *newvp = (struct vnode *)0;
1983: caddr_t bpos, dpos, cp2;
1984: int error = 0, wccflag = NFSV3_WCCRATTR;
1985: int gotvp = 0;
1986: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
1987: struct vattr vattr;
1988: int v3 = NFS_ISV3(dvp);
1989:
1990: if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc))) {
1991: VOP_ABORTOP(dvp, cnp);
1992: vput(dvp);
1993: return (error);
1994: }
1995: len = cnp->cn_namelen;
1996: nfsstats.rpccnt[NFSPROC_MKDIR]++;
1997: nfsm_reqhead(dvp, NFSPROC_MKDIR,
1998: NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len) + NFSX_SATTR(v3));
1999: nfsm_fhtom(dvp, v3);
2000: nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN);
2001: if (v3) {
2002: nfsm_build(sp3, struct nfsv3_sattr *, NFSX_V3SRVSATTR);
2003: nfsm_v3sattr(sp3, vap, cnp->cn_cred->cr_uid, vattr.va_gid);
2004: } else {
2005: nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
2006: sp->sa_mode = vtonfsv2_mode(VDIR, vap->va_mode);
2007: sp->sa_uid = txdr_unsigned(cnp->cn_cred->cr_uid);
2008: sp->sa_gid = txdr_unsigned(vattr.va_gid);
2009: sp->sa_size = -1;
2010: txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
2011: txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
2012: }
2013: nfsm_request(dvp, NFSPROC_MKDIR, cnp->cn_proc, cnp->cn_cred);
2014: if (!error)
2015: nfsm_mtofh(dvp, newvp, v3, gotvp);
2016: if (v3)
2017: nfsm_wcc_data(dvp, wccflag);
2018: nfsm_reqdone;
2019: VTONFS(dvp)->n_flag |= NMODIFIED;
2020: if (!wccflag)
2021: VTONFS(dvp)->n_attrstamp = 0;
2022: /*
2023: * Kludge: Map EEXIST => 0 assuming that you have a reply to a retry
2024: * if we can succeed in looking up the directory.
2025: */
2026: if (error == EEXIST || (!error && !gotvp)) {
2027: if (newvp) {
2028: vrele(newvp);
2029: newvp = (struct vnode *)0;
2030: }
2031: error = nfs_lookitup(dvp, cnp->cn_nameptr, len, cnp->cn_cred,
2032: cnp->cn_proc, &np);
2033: if (!error) {
2034: newvp = NFSTOV(np);
2035: if (newvp->v_type != VDIR)
2036: error = EEXIST;
2037: }
2038: }
2039: if (error) {
2040: if (newvp)
2041: vrele(newvp);
2042: } else
2043: *ap->a_vpp = newvp;
2044: FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
2045: vput(dvp);
2046: return (error);
2047: }
2048:
2049: /*
2050: * nfs remove directory call
2051: */
2052: static int
2053: nfs_rmdir(ap)
2054: struct vop_rmdir_args /* {
2055: struct vnode *a_dvp;
2056: struct vnode *a_vp;
2057: struct componentname *a_cnp;
2058: } */ *ap;
2059: {
2060: register struct vnode *vp = ap->a_vp;
2061: register struct vnode *dvp = ap->a_dvp;
2062: register struct componentname *cnp = ap->a_cnp;
2063: register u_long *tl;
2064: register caddr_t cp;
2065: register long t1, t2;
2066: caddr_t bpos, dpos, cp2;
2067: int error = 0, wccflag = NFSV3_WCCRATTR;
2068: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
2069: int v3 = NFS_ISV3(dvp);
2070:
2071: nfsstats.rpccnt[NFSPROC_RMDIR]++;
2072: nfsm_reqhead(dvp, NFSPROC_RMDIR,
2073: NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(cnp->cn_namelen));
2074: nfsm_fhtom(dvp, v3);
2075: nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
2076: nfsm_request(dvp, NFSPROC_RMDIR, cnp->cn_proc, cnp->cn_cred);
2077: if (v3)
2078: nfsm_wcc_data(dvp, wccflag);
2079: nfsm_reqdone;
2080: FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
2081: VTONFS(dvp)->n_flag |= NMODIFIED;
2082: if (!wccflag)
2083: VTONFS(dvp)->n_attrstamp = 0;
2084: cache_purge(dvp);
2085: cache_purge(vp);
2086: vput(vp);
2087: vput(dvp);
2088: /*
2089: * Kludge: Map ENOENT => 0 assuming that you have a reply to a retry.
2090: */
2091: if (error == ENOENT)
2092: error = 0;
2093: return (error);
2094: }
2095:
2096: /*
2097: * nfs readdir call
2098: */
2099: static int
2100: nfs_readdir(ap)
2101: struct vop_readdir_args /* {
2102: struct vnode *a_vp;
2103: struct uio *a_uio;
2104: struct ucred *a_cred;
2105: } */ *ap;
2106: {
2107: register struct vnode *vp = ap->a_vp;
2108: register struct nfsnode *np = VTONFS(vp);
2109: register struct uio *uio = ap->a_uio;
2110: int tresid, error;
2111: struct vattr vattr;
2112:
2113: if (vp->v_type != VDIR)
2114: return (EPERM);
2115: /*
2116: * First, check for hit on the EOF offset cache
2117: */
2118: if (np->n_direofoffset > 0 && uio->uio_offset >= np->n_direofoffset &&
2119: (np->n_flag & NMODIFIED) == 0) {
2120: if (VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NQNFS) {
2121: if (NQNFS_CKCACHABLE(vp, ND_READ)) {
2122: nfsstats.direofcache_hits++;
2123: return (0);
2124: }
2125: } else if (VOP_GETATTR(vp, &vattr, ap->a_cred, uio->uio_procp) == 0 &&
2126: np->n_mtime == vattr.va_mtime.tv_sec) {
2127: nfsstats.direofcache_hits++;
2128: return (0);
2129: }
2130: }
2131:
2132: /*
2133: * Call nfs_bioread() to do the real work.
2134: */
2135: tresid = uio->uio_resid;
2136: error = nfs_bioread(vp, uio, 0, ap->a_cred, 0);
2137:
2138: if (!error && uio->uio_resid == tresid)
2139: nfsstats.direofcache_misses++;
2140: return (error);
2141: }
2142:
2143: /*
2144: * Readdir rpc call.
2145: * Called from below the buffer cache by nfs_doio().
2146: */
2147: int
2148: nfs_readdirrpc(vp, uiop, cred)
2149: struct vnode *vp;
2150: register struct uio *uiop;
2151: struct ucred *cred;
2152:
2153: {
2154: register int len, left;
2155: register struct dirent *dp;
2156: register u_long *tl;
2157: register caddr_t cp;
2158: register long t1, t2;
2159: register nfsuint64 *cookiep;
2160: caddr_t bpos, dpos, cp2;
2161: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
2162: nfsuint64 cookie;
2163: struct nfsmount *nmp = VFSTONFS(vp->v_mount);
2164: struct nfsnode *dnp = VTONFS(vp);
2165: u_quad_t fileno;
2166: int error = 0, tlen, more_dirs = 1, blksiz = 0, bigenough = 1;
2167: int attrflag;
2168: int v3 = NFS_ISV3(vp);
2169:
2170: #ifndef nolint
2171: dp = (struct dirent *)0;
2172: #endif
2173: #if DIAGNOSTIC
2174: if (uiop->uio_iovcnt != 1 || (uiop->uio_offset & (NFS_DIRBLKSIZ - 1)) ||
2175: (uiop->uio_resid & (NFS_DIRBLKSIZ - 1)))
2176: panic("nfs readdirrpc bad uio");
2177: #endif
2178:
2179: /*
2180: * If there is no cookie, assume directory was stale.
2181: */
2182: cookiep = nfs_getcookie(dnp, uiop->uio_offset, 0);
2183: if (cookiep)
2184: cookie = *cookiep;
2185: else
2186: return (NFSERR_BAD_COOKIE);
2187: /*
2188: * Loop around doing readdir rpc's of size nm_readdirsize
2189: * truncated to a multiple of DIRBLKSIZ.
2190: * The stopping criteria is EOF or buffer full.
2191: */
2192: while (more_dirs && bigenough) {
2193: nfsstats.rpccnt[NFSPROC_READDIR]++;
2194: nfsm_reqhead(vp, NFSPROC_READDIR, NFSX_FH(v3) +
2195: NFSX_READDIR(v3));
2196: nfsm_fhtom(vp, v3);
2197: if (v3) {
2198: nfsm_build(tl, u_long *, 5 * NFSX_UNSIGNED);
2199: *tl++ = cookie.nfsuquad[0];
2200: *tl++ = cookie.nfsuquad[1];
2201: *tl++ = dnp->n_cookieverf.nfsuquad[0];
2202: *tl++ = dnp->n_cookieverf.nfsuquad[1];
2203: } else {
2204: nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
2205: *tl++ = cookie.nfsuquad[0];
2206: }
2207: *tl = txdr_unsigned(nmp->nm_readdirsize);
2208: nfsm_request(vp, NFSPROC_READDIR, uiop->uio_procp, cred);
2209: if (v3) {
2210: nfsm_postop_attr(vp, attrflag);
2211: if (!error) {
2212: nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
2213: dnp->n_cookieverf.nfsuquad[0] = *tl++;
2214: dnp->n_cookieverf.nfsuquad[1] = *tl;
2215: } else {
2216: m_freem(mrep);
2217: goto nfsmout;
2218: }
2219: }
2220: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
2221: more_dirs = fxdr_unsigned(int, *tl);
2222:
2223: /* loop thru the dir entries, doctoring them to 4bsd form */
2224: while (more_dirs && bigenough) {
2225: if (v3) {
2226: nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
2227: fxdr_hyper(tl, &fileno);
2228: len = fxdr_unsigned(int, *(tl + 2));
2229: } else {
2230: nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
2231: fileno = fxdr_unsigned(u_quad_t, *tl++);
2232: len = fxdr_unsigned(int, *tl);
2233: }
2234: if (len <= 0 || len > NFS_MAXNAMLEN) {
2235: error = EBADRPC;
2236: m_freem(mrep);
2237: goto nfsmout;
2238: }
2239: tlen = nfsm_rndup(len);
2240: if (tlen == len)
2241: tlen += 4; /* To ensure null termination */
2242: left = DIRBLKSIZ - blksiz;
2243: if ((tlen + DIRHDSIZ) > left) {
2244: dp->d_reclen += left;
2245: uiop->uio_iov->iov_base += left;
2246: uiop->uio_iov->iov_len -= left;
2247: uiop->uio_offset += left;
2248: uiop->uio_resid -= left;
2249: blksiz = 0;
2250: }
2251: if ((tlen + DIRHDSIZ) > uiop->uio_resid)
2252: bigenough = 0;
2253: if (bigenough) {
2254: dp = (struct dirent *)uiop->uio_iov->iov_base;
2255: dp->d_fileno = (int)fileno;
2256: dp->d_namlen = len;
2257: dp->d_reclen = tlen + DIRHDSIZ;
2258: dp->d_type = DT_UNKNOWN;
2259: blksiz += dp->d_reclen;
2260: if (blksiz == DIRBLKSIZ)
2261: blksiz = 0;
2262: uiop->uio_offset += DIRHDSIZ;
2263: uiop->uio_resid -= DIRHDSIZ;
2264: uiop->uio_iov->iov_base += DIRHDSIZ;
2265: uiop->uio_iov->iov_len -= DIRHDSIZ;
2266: nfsm_mtouio(uiop, len);
2267: cp = uiop->uio_iov->iov_base;
2268: tlen -= len;
2269: *cp = '\0'; /* null terminate */
2270: uiop->uio_iov->iov_base += tlen;
2271: uiop->uio_iov->iov_len -= tlen;
2272: uiop->uio_offset += tlen;
2273: uiop->uio_resid -= tlen;
2274: } else
2275: nfsm_adv(nfsm_rndup(len));
2276: if (v3) {
2277: nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
2278: } else {
2279: nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
2280: }
2281: if (bigenough) {
2282: cookie.nfsuquad[0] = *tl++;
2283: if (v3)
2284: cookie.nfsuquad[1] = *tl++;
2285: } else if (v3)
2286: tl += 2;
2287: else
2288: tl++;
2289: more_dirs = fxdr_unsigned(int, *tl);
2290: }
2291: /*
2292: * If at end of rpc data, get the eof boolean
2293: */
2294: if (!more_dirs) {
2295: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
2296: more_dirs = (fxdr_unsigned(int, *tl) == 0);
2297: }
2298: m_freem(mrep);
2299: }
2300: /*
2301: * Fill last record, iff any, out to a multiple of DIRBLKSIZ
2302: * by increasing d_reclen for the last record.
2303: */
2304: if (blksiz > 0) {
2305: left = DIRBLKSIZ - blksiz;
2306: dp->d_reclen += left;
2307: uiop->uio_iov->iov_base += left;
2308: uiop->uio_iov->iov_len -= left;
2309: uiop->uio_offset += left;
2310: uiop->uio_resid -= left;
2311: }
2312:
2313: /*
2314: * We are now either at the end of the directory or have filled the
2315: * block.
2316: */
2317: if (bigenough)
2318: dnp->n_direofoffset = uiop->uio_offset;
2319: else {
2320: if (uiop->uio_resid > 0)
2321: printf("EEK! readdirrpc resid > 0\n");
2322: cookiep = nfs_getcookie(dnp, uiop->uio_offset, 1);
2323: *cookiep = cookie;
2324: }
2325: nfsmout:
2326: return (error);
2327: }
2328:
2329: /*
2330: * NFS V3 readdir plus RPC. Used in place of nfs_readdirrpc().
2331: */
2332: int
2333: nfs_readdirplusrpc(vp, uiop, cred)
2334: struct vnode *vp;
2335: register struct uio *uiop;
2336: struct ucred *cred;
2337: {
2338: register int len, left;
2339: register struct dirent *dp;
2340: register u_long *tl;
2341: register caddr_t cp;
2342: register long t1, t2;
2343: register struct vnode *newvp;
2344: register nfsuint64 *cookiep;
2345: caddr_t bpos, dpos, cp2, dpossav1, dpossav2;
2346: struct mbuf *mreq, *mrep, *md, *mb, *mb2, *mdsav1, *mdsav2;
2347: struct nameidata nami, *ndp = &nami;
2348: struct componentname *cnp = &ndp->ni_cnd;
2349: nfsuint64 cookie;
2350: struct nfsmount *nmp = VFSTONFS(vp->v_mount);
2351: struct nfsnode *dnp = VTONFS(vp), *np;
2352: nfsfh_t *fhp;
2353: u_quad_t fileno;
2354: int error = 0, tlen, more_dirs = 1, blksiz = 0, doit, bigenough = 1, i;
2355: int attrflag, fhsize;
2356:
2357: #ifndef nolint
2358: dp = (struct dirent *)0;
2359: #endif
2360: #if DIAGNOSTIC
2361: if (uiop->uio_iovcnt != 1 || (uiop->uio_offset & (DIRBLKSIZ - 1)) ||
2362: (uiop->uio_resid & (DIRBLKSIZ - 1)))
2363: panic("nfs readdirplusrpc bad uio");
2364: #endif
2365: ndp->ni_dvp = vp;
2366: newvp = NULLVP;
2367:
2368: /*
2369: * If there is no cookie, assume directory was stale.
2370: */
2371: cookiep = nfs_getcookie(dnp, uiop->uio_offset, 0);
2372: if (cookiep)
2373: cookie = *cookiep;
2374: else
2375: return (NFSERR_BAD_COOKIE);
2376: /*
2377: * Loop around doing readdir rpc's of size nm_readdirsize
2378: * truncated to a multiple of DIRBLKSIZ.
2379: * The stopping criteria is EOF or buffer full.
2380: */
2381: while (more_dirs && bigenough) {
2382: nfsstats.rpccnt[NFSPROC_READDIRPLUS]++;
2383: nfsm_reqhead(vp, NFSPROC_READDIRPLUS,
2384: NFSX_FH(1) + 6 * NFSX_UNSIGNED);
2385: nfsm_fhtom(vp, 1);
2386: nfsm_build(tl, u_long *, 6 * NFSX_UNSIGNED);
2387: *tl++ = cookie.nfsuquad[0];
2388: *tl++ = cookie.nfsuquad[1];
2389: *tl++ = dnp->n_cookieverf.nfsuquad[0];
2390: *tl++ = dnp->n_cookieverf.nfsuquad[1];
2391: *tl++ = txdr_unsigned(nmp->nm_readdirsize);
2392: *tl = txdr_unsigned(nmp->nm_rsize);
2393: nfsm_request(vp, NFSPROC_READDIRPLUS, uiop->uio_procp, cred);
2394: nfsm_postop_attr(vp, attrflag);
2395: if (error) {
2396: m_freem(mrep);
2397: goto nfsmout;
2398: }
2399: nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
2400: dnp->n_cookieverf.nfsuquad[0] = *tl++;
2401: dnp->n_cookieverf.nfsuquad[1] = *tl++;
2402: more_dirs = fxdr_unsigned(int, *tl);
2403:
2404: /* loop thru the dir entries, doctoring them to 4bsd form */
2405: while (more_dirs && bigenough) {
2406: nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
2407: fxdr_hyper(tl, &fileno);
2408: len = fxdr_unsigned(int, *(tl + 2));
2409: if (len <= 0 || len > NFS_MAXNAMLEN) {
2410: error = EBADRPC;
2411: m_freem(mrep);
2412: goto nfsmout;
2413: }
2414: tlen = nfsm_rndup(len);
2415: if (tlen == len)
2416: tlen += 4; /* To ensure null termination*/
2417: left = DIRBLKSIZ - blksiz;
2418: if ((tlen + DIRHDSIZ) > left) {
2419: dp->d_reclen += left;
2420: uiop->uio_iov->iov_base += left;
2421: uiop->uio_iov->iov_len -= left;
2422: uiop->uio_offset += left;
2423: uiop->uio_resid -= left;
2424: blksiz = 0;
2425: }
2426: if ((tlen + DIRHDSIZ) > uiop->uio_resid)
2427: bigenough = 0;
2428: if (bigenough) {
2429: dp = (struct dirent *)uiop->uio_iov->iov_base;
2430: dp->d_fileno = (int)fileno;
2431: dp->d_namlen = len;
2432: dp->d_reclen = tlen + DIRHDSIZ;
2433: dp->d_type = DT_UNKNOWN;
2434: blksiz += dp->d_reclen;
2435: if (blksiz == DIRBLKSIZ)
2436: blksiz = 0;
2437: uiop->uio_offset += DIRHDSIZ;
2438: uiop->uio_resid -= DIRHDSIZ;
2439: uiop->uio_iov->iov_base += DIRHDSIZ;
2440: uiop->uio_iov->iov_len -= DIRHDSIZ;
2441: cnp->cn_nameptr = uiop->uio_iov->iov_base;
2442: cnp->cn_namelen = len;
2443: nfsm_mtouio(uiop, len);
2444: cp = uiop->uio_iov->iov_base;
2445: tlen -= len;
2446: *cp = '\0';
2447: uiop->uio_iov->iov_base += tlen;
2448: uiop->uio_iov->iov_len -= tlen;
2449: uiop->uio_offset += tlen;
2450: uiop->uio_resid -= tlen;
2451: } else
2452: nfsm_adv(nfsm_rndup(len));
2453: nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
2454: if (bigenough) {
2455: cookie.nfsuquad[0] = *tl++;
2456: cookie.nfsuquad[1] = *tl++;
2457: } else
2458: tl += 2;
2459:
2460: /*
2461: * Since the attributes are before the file handle
2462: * (sigh), we must skip over the attributes and then
2463: * come back and get them.
2464: */
2465: attrflag = fxdr_unsigned(int, *tl);
2466: if (attrflag) {
2467: dpossav1 = dpos;
2468: mdsav1 = md;
2469: nfsm_adv(NFSX_V3FATTR);
2470: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
2471: doit = fxdr_unsigned(int, *tl);
2472: if (doit) {
2473: nfsm_getfh(fhp, fhsize, 1);
2474: if (NFS_CMPFH(dnp, fhp, fhsize)) {
2475: VREF(vp);
2476: newvp = vp;
2477: np = dnp;
2478: } else {
2479: if ((error = nfs_nget(vp->v_mount, fhp,
2480: fhsize, &np)))
2481: doit = 0;
2482: else
2483: newvp = NFSTOV(np);
2484: }
2485: }
2486: if (doit) {
2487: dpossav2 = dpos;
2488: dpos = dpossav1;
2489: mdsav2 = md;
2490: md = mdsav1;
2491: nfsm_loadattr(newvp, (struct vattr *)0);
2492: dpos = dpossav2;
2493: md = mdsav2;
2494: dp->d_type =
2495: IFTODT(VTTOIF(np->n_vattr.va_type));
2496: ndp->ni_vp = newvp;
2497: cnp->cn_hash = 0;
2498: for (cp = cnp->cn_nameptr, i = 1; i <= len;
2499: i++, cp++)
2500: cnp->cn_hash += (unsigned char)*cp * i;
2501: if (cnp->cn_namelen <= NCHNAMLEN)
2502: cache_enter(ndp->ni_dvp, ndp->ni_vp, cnp);
2503: }
2504: } else {
2505: /* Just skip over the file handle */
2506: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
2507: i = fxdr_unsigned(int, *tl);
2508: nfsm_adv(nfsm_rndup(i));
2509: }
2510: if (newvp != NULLVP) {
2511: vrele(newvp);
2512: newvp = NULLVP;
2513: }
2514: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
2515: more_dirs = fxdr_unsigned(int, *tl);
2516: }
2517: /*
2518: * If at end of rpc data, get the eof boolean
2519: */
2520: if (!more_dirs) {
2521: nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
2522: more_dirs = (fxdr_unsigned(int, *tl) == 0);
2523: }
2524: m_freem(mrep);
2525: }
2526: /*
2527: * Fill last record, iff any, out to a multiple of NFS_DIRBLKSIZ
2528: * by increasing d_reclen for the last record.
2529: */
2530: if (blksiz > 0) {
2531: left = DIRBLKSIZ - blksiz;
2532: dp->d_reclen += left;
2533: uiop->uio_iov->iov_base += left;
2534: uiop->uio_iov->iov_len -= left;
2535: uiop->uio_offset += left;
2536: uiop->uio_resid -= left;
2537: }
2538:
2539: /*
2540: * We are now either at the end of the directory or have filled the
2541: * block.
2542: */
2543: if (bigenough)
2544: dnp->n_direofoffset = uiop->uio_offset;
2545: else {
2546: if (uiop->uio_resid > 0)
2547: printf("EEK! readdirplusrpc resid > 0\n");
2548: cookiep = nfs_getcookie(dnp, uiop->uio_offset, 1);
2549: *cookiep = cookie;
2550: }
2551: nfsmout:
2552: if (newvp != NULLVP) {
2553: if (newvp == vp)
2554: vrele(newvp);
2555: else
2556: vput(newvp);
2557: newvp = NULLVP;
2558: }
2559: return (error);
2560: }
2561:
2562: /*
2563: * Silly rename. To make the NFS filesystem that is stateless look a little
2564: * more like the "ufs" a remove of an active vnode is translated to a rename
2565: * to a funny looking filename that is removed by nfs_inactive on the
2566: * nfsnode. There is the potential for another process on a different client
2567: * to create the same funny name between the nfs_lookitup() fails and the
2568: * nfs_rename() completes, but...
2569: */
2570: static int
2571: nfs_sillyrename(dvp, vp, cnp)
2572: struct vnode *dvp, *vp;
2573: struct componentname *cnp;
2574: {
2575: register struct sillyrename *sp;
2576: struct nfsnode *np;
2577: int error;
2578: short pid;
2579: struct cred *cred;
2580:
2581: cache_purge(dvp);
2582: np = VTONFS(vp);
2583: #if DIAGNOSTIC
2584: if (vp->v_type == VDIR)
2585: panic("nfs: sillyrename dir");
2586: #endif
2587: MALLOC_ZONE(sp, struct sillyrename *,
2588: sizeof (struct sillyrename), M_NFSREQ, M_WAITOK);
2589: sp->s_cred = crdup(cnp->cn_cred);
2590: sp->s_dvp = dvp;
2591: VREF(dvp);
2592:
2593: /* Fudge together a funny name */
2594: pid = cnp->cn_proc->p_pid;
2595: sp->s_namlen = sprintf(sp->s_name, ".nfsA%04x4.4", pid);
2596:
2597: /* Try lookitups until we get one that isn't there */
2598: while (nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
2599: cnp->cn_proc, (struct nfsnode **)0) == 0) {
2600: sp->s_name[4]++;
2601: if (sp->s_name[4] > 'z') {
2602: error = EINVAL;
2603: goto bad;
2604: }
2605: }
2606: if ((error = nfs_renameit(dvp, cnp, sp)))
2607: goto bad;
2608: error = nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
2609: cnp->cn_proc, &np);
2610: #if DIAGNOSTIC
2611: kprintf("sillyrename: %s, vp=%x, np=%x, dvp=%x\n",
2612: &sp->s_name[0], (unsigned)vp, (unsigned)np, (unsigned)dvp);
2613: #endif
2614: np->n_sillyrename = sp;
2615: return (0);
2616: bad:
2617: vrele(sp->s_dvp);
2618: cred = sp->s_cred;
2619: sp->s_cred = NOCRED;
2620: crfree(cred);
2621: _FREE_ZONE((caddr_t)sp, sizeof (struct sillyrename), M_NFSREQ);
2622: return (error);
2623: }
2624:
2625: /*
2626: * Look up a file name and optionally either update the file handle or
2627: * allocate an nfsnode, depending on the value of npp.
2628: * npp == NULL --> just do the lookup
2629: * *npp == NULL --> allocate a new nfsnode and make sure attributes are
2630: * handled too
2631: * *npp != NULL --> update the file handle in the vnode
2632: */
2633: static int
2634: nfs_lookitup(dvp, name, len, cred, procp, npp)
2635: register struct vnode *dvp;
2636: char *name;
2637: int len;
2638: struct ucred *cred;
2639: struct proc *procp;
2640: struct nfsnode **npp;
2641: {
2642: register u_long *tl;
2643: register caddr_t cp;
2644: register long t1, t2;
2645: struct vnode *newvp = (struct vnode *)0;
2646: struct nfsnode *np, *dnp = VTONFS(dvp);
2647: caddr_t bpos, dpos, cp2;
2648: int error = 0, fhlen, attrflag;
2649: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
2650: nfsfh_t *nfhp;
2651: int v3 = NFS_ISV3(dvp);
2652:
2653: nfsstats.rpccnt[NFSPROC_LOOKUP]++;
2654: nfsm_reqhead(dvp, NFSPROC_LOOKUP,
2655: NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len));
2656: nfsm_fhtom(dvp, v3);
2657: nfsm_strtom(name, len, NFS_MAXNAMLEN);
2658: nfsm_request(dvp, NFSPROC_LOOKUP, procp, cred);
2659: if (npp && !error) {
2660: nfsm_getfh(nfhp, fhlen, v3);
2661: if (*npp) {
2662: np = *npp;
2663: if (np->n_fhsize > NFS_SMALLFH && fhlen <= NFS_SMALLFH) {
2664: _FREE_ZONE((caddr_t)np->n_fhp,
2665: np->n_fhsize, M_NFSBIGFH);
2666: np->n_fhp = &np->n_fh;
2667: } else if (np->n_fhsize <= NFS_SMALLFH && fhlen>NFS_SMALLFH)
2668: MALLOC_ZONE(np->n_fhp, nfsfh_t *,
2669: fhlen, M_NFSBIGFH, M_WAITOK);
2670: bcopy((caddr_t)nfhp, (caddr_t)np->n_fhp, fhlen);
2671: np->n_fhsize = fhlen;
2672: newvp = NFSTOV(np);
2673: } else if (NFS_CMPFH(dnp, nfhp, fhlen)) {
2674: VREF(dvp);
2675: newvp = dvp;
2676: } else {
2677: error = nfs_nget(dvp->v_mount, nfhp, fhlen, &np);
2678: if (error) {
2679: m_freem(mrep);
2680: return (error);
2681: }
2682: newvp = NFSTOV(np);
2683: }
2684: if (v3) {
2685: nfsm_postop_attr(newvp, attrflag);
2686: if (!attrflag && *npp == NULL) {
2687: m_freem(mrep);
2688: if (newvp == dvp)
2689: vrele(newvp);
2690: else
2691: vput(newvp);
2692: return (ENOENT);
2693: }
2694: } else
2695: nfsm_loadattr(newvp, (struct vattr *)0);
2696: }
2697: nfsm_reqdone;
2698: if (npp && *npp == NULL) {
2699: if (error) {
2700: if (newvp)
2701: if (newvp == dvp)
2702: vrele(newvp);
2703: else
2704: vput(newvp);
2705: } else
2706: *npp = np;
2707: }
2708: return (error);
2709: }
2710:
2711: /*
2712: * Nfs Version 3 commit rpc
2713: */
2714: static int
2715: nfs_commit(vp, offset, cnt, cred, procp)
2716: register struct vnode *vp;
2717: u_quad_t offset;
2718: int cnt;
2719: struct ucred *cred;
2720: struct proc *procp;
2721: {
2722: register caddr_t cp;
2723: register u_long *tl;
2724: register int t1, t2;
2725: register struct nfsmount *nmp = VFSTONFS(vp->v_mount);
2726: caddr_t bpos, dpos, cp2;
2727: int error = 0, wccflag = NFSV3_WCCRATTR;
2728: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
2729:
2730: if ((nmp->nm_flag & NFSMNT_HASWRITEVERF) == 0)
2731: return (0);
2732: nfsstats.rpccnt[NFSPROC_COMMIT]++;
2733: nfsm_reqhead(vp, NFSPROC_COMMIT, NFSX_FH(1));
2734: nfsm_fhtom(vp, 1);
2735: nfsm_build(tl, u_long *, 3 * NFSX_UNSIGNED);
2736: txdr_hyper(&offset, tl);
2737: tl += 2;
2738: *tl = txdr_unsigned(cnt);
2739: nfsm_request(vp, NFSPROC_COMMIT, procp, cred);
2740: nfsm_wcc_data(vp, wccflag);
2741: if (!error) {
2742: nfsm_dissect(tl, u_long *, NFSX_V3WRITEVERF);
2743: if (bcmp((caddr_t)nmp->nm_verf, (caddr_t)tl,
2744: NFSX_V3WRITEVERF)) {
2745: bcopy((caddr_t)tl, (caddr_t)nmp->nm_verf,
2746: NFSX_V3WRITEVERF);
2747: error = NFSERR_STALEWRITEVERF;
2748: }
2749: }
2750: nfsm_reqdone;
2751: return (error);
2752: }
2753:
2754: /*
2755: * Kludge City..
2756: * - make nfs_bmap() essentially a no-op that does no translation
2757: * - do nfs_strategy() by doing I/O with nfs_readrpc/nfs_writerpc
2758: * (Maybe I could use the process's page mapping, but I was concerned that
2759: * Kernel Write might not be enabled and also figured copyout() would do
2760: * a lot more work than bcopy() and also it currently happens in the
2761: * context of the swapper process (2).
2762: */
2763: static int
2764: nfs_bmap(ap)
2765: struct vop_bmap_args /* {
2766: struct vnode *a_vp;
2767: daddr_t a_bn;
2768: struct vnode **a_vpp;
2769: daddr_t *a_bnp;
2770: int *a_runp;
2771: int *a_runb;
2772: } */ *ap;
2773: {
2774: register struct vnode *vp = ap->a_vp;
2775: #ifdef NeXT
2776: #warning nfs_bmap hardcoded devblocksize
2777: int devBlockSize=1024;
2778: #endif /* NeXT */
2779:
2780: if (ap->a_vpp != NULL)
2781: *ap->a_vpp = vp;
2782: if (ap->a_bnp != NULL)
2783: #ifdef NeXT
2784: *ap->a_bnp = ap->a_bn * btodb(vp->v_mount->mnt_stat.f_iosize,
2785: devBlockSize);
2786: #else
2787: *ap->a_bnp = ap->a_bn * btodb(vp->v_mount->mnt_stat.f_iosize);
2788: #endif /* NeXT */
2789: if (ap->a_runp != NULL)
2790: *ap->a_runp = 0;
2791: #ifdef notyet
2792: if (ap->a_runb != NULL)
2793: *ap->a_runb = 0;
2794: #endif
2795: return (0);
2796: }
2797:
2798: /*
2799: * Strategy routine.
2800: * For async requests when nfsiod(s) are running, queue the request by
2801: * calling nfs_asyncio(), otherwise just all nfs_doio() to do the
2802: * request.
2803: */
2804: static int
2805: nfs_strategy(ap)
2806: struct vop_strategy_args *ap;
2807: {
2808: register struct buf *bp = ap->a_bp;
2809: struct ucred *cr;
2810: struct proc *p;
2811: int error = 0;
2812:
2813: if (bp->b_flags & B_PHYS)
2814: panic("nfs physio");
2815: if (bp->b_flags & B_ASYNC)
2816: p = (struct proc *)0;
2817: else
2818: p = current_proc(); /* XXX */
2819: if (bp->b_flags & B_READ)
2820: cr = bp->b_rcred;
2821: else
2822: cr = bp->b_wcred;
2823: /*
2824: * If the op is asynchronous and an i/o daemon is waiting
2825: * queue the request, wake it up and wait for completion
2826: * otherwise just do it ourselves.
2827: */
2828: if ((bp->b_flags & B_ASYNC) == 0 ||
2829: nfs_asyncio(bp, NOCRED))
2830: error = nfs_doio(bp, cr, p);
2831: return (error);
2832: }
2833:
2834: /*
2835: * Mmap a file
2836: *
2837: * NB Currently unsupported.
2838: */
2839: /* ARGSUSED */
2840: static int
2841: nfs_mmap(ap)
2842: struct vop_mmap_args /* {
2843: struct vnode *a_vp;
2844: int a_fflags;
2845: struct ucred *a_cred;
2846: struct proc *a_p;
2847: } */ *ap;
2848: {
2849:
2850: return (EINVAL);
2851: }
2852:
2853: /*
2854: * fsync vnode op. Just call nfs_flush() with commit == 1.
2855: */
2856: /* ARGSUSED */
2857: static int
2858: nfs_fsync(ap)
2859: struct vop_fsync_args /* {
2860: struct vnodeop_desc *a_desc;
2861: struct vnode * a_vp;
2862: struct ucred * a_cred;
2863: int a_waitfor;
2864: struct proc * a_p;
2865: } */ *ap;
2866: {
2867:
2868: return (nfs_flush(ap->a_vp, ap->a_cred, ap->a_waitfor, ap->a_p, 1));
2869: }
2870:
2871: /*
2872: * Flush all the blocks associated with a vnode.
2873: * Walk through the buffer pool and push any dirty pages
2874: * associated with the vnode.
2875: */
2876: static int
2877: nfs_flush(vp, cred, waitfor, p, commit)
2878: register struct vnode *vp;
2879: struct ucred *cred;
2880: int waitfor;
2881: struct proc *p;
2882: int commit;
2883: {
2884: register struct nfsnode *np = VTONFS(vp);
2885: register struct buf *bp;
2886: register int i;
2887: struct buf *nbp;
2888: struct nfsmount *nmp = VFSTONFS(vp->v_mount);
2889: int s, error = 0, slptimeo = 0, slpflag = 0, retv, bvecpos;
2890: int passone = 1;
2891: u_quad_t off, endoff, toff;
2892: struct ucred* wcred = NULL;
2893: struct buf **bvec = NULL;
2894: #ifndef NFS_COMMITBVECSIZ
2895: #define NFS_COMMITBVECSIZ 20
2896: #endif
2897: struct buf *bvec_on_stack[NFS_COMMITBVECSIZ];
2898: int bvecsize = 0, bveccount;
2899:
2900: if (nmp->nm_flag & NFSMNT_INT)
2901: slpflag = PCATCH;
2902: if (!commit)
2903: passone = 0;
2904: /*
2905: * A b_flags == (B_DELWRI | B_NEEDCOMMIT) block has been written to the
2906: * server, but nas not been committed to stable storage on the server
2907: * yet. On the first pass, the byte range is worked out and the commit
2908: * rpc is done. On the second pass, nfs_writebp() is called to do the
2909: * job.
2910: */
2911: again:
2912: if (vp->v_dirtyblkhd.lh_first)
2913: np->n_flag |= NMODIFIED;
2914: off = (u_quad_t)-1;
2915: endoff = 0;
2916: bvecpos = 0;
2917: if (NFS_ISV3(vp) && commit) {
2918: s = splbio();
2919: /*
2920: * Count up how many buffers waiting for a commit.
2921: */
2922: bveccount = 0;
2923: for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) {
2924: nbp = bp->b_vnbufs.le_next;
2925: if ((bp->b_flags & (B_BUSY | B_DELWRI | B_NEEDCOMMIT))
2926: == (B_DELWRI | B_NEEDCOMMIT))
2927: bveccount++;
2928: }
2929: /*
2930: * Allocate space to remember the list of bufs to commit. It is
2931: * important to use M_NOWAIT here to avoid a race with nfs_write.
2932: * If we can't get memory (for whatever reason), we will end up
2933: * committing the buffers one-by-one in the loop below.
2934: */
2935: if (bveccount > NFS_COMMITBVECSIZ) {
2936: if (bvec != NULL && bvec != bvec_on_stack)
2937: _FREE(bvec, M_TEMP);
2938: MALLOC(bvec, struct buf **,
2939: bveccount * sizeof(struct buf *), M_TEMP, M_NOWAIT);
2940: if (bvec == NULL) {
2941: bvec = bvec_on_stack;
2942: bvecsize = NFS_COMMITBVECSIZ;
2943: } else
2944: bvecsize = bveccount;
2945: } else {
2946: bvec = bvec_on_stack;
2947: bvecsize = NFS_COMMITBVECSIZ;
2948: }
2949: for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) {
2950: nbp = bp->b_vnbufs.le_next;
2951: if (bvecpos >= bvecsize)
2952: break;
2953: if ((bp->b_flags & (B_BUSY | B_DELWRI | B_NEEDCOMMIT))
2954: != (B_DELWRI | B_NEEDCOMMIT))
2955: continue;
2956: bremfree(bp);
2957: /*
2958: * Work out if all buffers are using the same cred
2959: * so we can deal with them all with one commit.
2960: */
2961: if (wcred == NULL)
2962: wcred = bp->b_wcred;
2963: else if (wcred != bp->b_wcred)
2964: wcred = NOCRED;
2965: bp->b_flags |= (B_BUSY | B_WRITEINPROG);
2966: vfs_busy_pages(bp, 1);
2967: /*
2968: * A list of these buffers is kept so that the
2969: * second loop knows which buffers have actually
2970: * been committed. This is necessary, since there
2971: * may be a race between the commit rpc and new
2972: * uncommitted writes on the file.
2973: */
2974: bvec[bvecpos++] = bp;
2975: toff = ((u_quad_t)bp->b_blkno) * DEV_BSIZE +
2976: bp->b_dirtyoff;
2977: if (toff < off)
2978: off = toff;
2979: toff += (u_quad_t)(bp->b_dirtyend - bp->b_dirtyoff);
2980: if (toff > endoff)
2981: endoff = toff;
2982: }
2983: splx(s);
2984: }
2985: if (bvecpos > 0) {
2986: /*
2987: * Commit data on the server, as required.
2988: * If all bufs are using the same wcred, then use that with
2989: * one call for all of them, otherwise commit each one
2990: * separately.
2991: */
2992: if (wcred != NOCRED)
2993: retv = nfs_commit(vp, off, (int)(endoff - off),
2994: wcred, p);
2995: else {
2996: retv = 0;
2997: for (i = 0; i < bvecpos; i++) {
2998: off_t off, size;
2999: bp = bvec[i];
3000: off = ((u_quad_t)bp->b_blkno) * DEV_BSIZE +
3001: bp->b_dirtyoff;
3002: size = (u_quad_t)(bp->b_dirtyend
3003: - bp->b_dirtyoff);
3004: retv = nfs_commit(vp, off, (int)size,
3005: bp->b_wcred, p);
3006: if (retv) break;
3007: }
3008: }
3009:
3010: if (retv == NFSERR_STALEWRITEVERF)
3011: nfs_clearcommit(vp->v_mount);
3012: /*
3013: * Now, either mark the blocks I/O done or mark the
3014: * blocks dirty, depending on whether the commit
3015: * succeeded.
3016: */
3017: for (i = 0; i < bvecpos; i++) {
3018: bp = bvec[i];
3019: bp->b_flags &= ~(B_NEEDCOMMIT | B_WRITEINPROG);
3020: if (retv) {
3021: vfs_unbusy_pages(bp);
3022: brelse(bp);
3023: } else {
3024: vp->v_numoutput++;
3025: bp->b_flags |= B_ASYNC;
3026: /* XXX CSM 12/4/97 Revisit when buffer cache upgraded */
3027: #ifdef notyet
3028: if (bp->b_flags & B_DELWRI) {
3029: --numdirtybuffers;
3030: if (needsbuffer) {
3031: vfs_bio_need_satisfy();
3032: }
3033: }
3034: #endif
3035: s = splbio();
3036: bp->b_flags &= ~(B_READ|B_DONE|B_ERROR|B_DELWRI);
3037: bp->b_dirtyoff = bp->b_dirtyend = 0;
3038: reassignbuf(bp, vp);
3039: splx(s);
3040: biodone(bp);
3041: }
3042: }
3043: }
3044:
3045: /*
3046: * Start/do any write(s) that are required.
3047: */
3048: loop:
3049: s = splbio();
3050: for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = nbp) {
3051: nbp = bp->b_vnbufs.le_next;
3052: if (bp->b_flags & B_BUSY) {
3053: if (waitfor != MNT_WAIT || passone)
3054: continue;
3055: bp->b_flags |= B_WANTED;
3056: error = tsleep((caddr_t)bp, slpflag | (PRIBIO + 1),
3057: "nfsfsync", slptimeo);
3058: splx(s);
3059: if (error) {
3060: if (nfs_sigintr(nmp, (struct nfsreq *)0, p)) {
3061: error = EINTR;
3062: goto done;
3063: }
3064: if (slpflag == PCATCH) {
3065: slpflag = 0;
3066: slptimeo = 2 * hz;
3067: }
3068: }
3069: goto loop;
3070: }
3071: if ((bp->b_flags & B_DELWRI) == 0)
3072: panic("nfs_fsync: not dirty");
3073: if ((passone || !commit) && (bp->b_flags & B_NEEDCOMMIT))
3074: continue;
3075: bremfree(bp);
3076: if (passone || !commit)
3077: bp->b_flags |= (B_BUSY|B_ASYNC);
3078: else
3079: bp->b_flags |= (B_BUSY|B_ASYNC|B_WRITEINPROG|B_NEEDCOMMIT);
3080: splx(s);
3081: VOP_BWRITE(bp);
3082: goto loop;
3083: }
3084: splx(s);
3085: if (passone) {
3086: passone = 0;
3087: goto again;
3088: }
3089: if (waitfor == MNT_WAIT) {
3090: while (vp->v_numoutput) {
3091: vp->v_flag |= VBWAIT;
3092: error = tsleep((caddr_t)&vp->v_numoutput,
3093: slpflag | (PRIBIO + 1), "nfsfsync", slptimeo);
3094: if (error) {
3095: if (nfs_sigintr(nmp, (struct nfsreq *)0, p)) {
3096: error = EINTR;
3097: goto done;
3098: }
3099: if (slpflag == PCATCH) {
3100: slpflag = 0;
3101: slptimeo = 2 * hz;
3102: }
3103: }
3104: }
3105: if (vp->v_dirtyblkhd.lh_first && commit) {
3106: goto loop;
3107: }
3108: }
3109: if (np->n_flag & NWRITEERR) {
3110: error = np->n_error;
3111: np->n_flag &= ~NWRITEERR;
3112: }
3113: done:
3114: if (bvec != NULL && bvec != bvec_on_stack)
3115: _FREE(bvec, M_TEMP);
3116: return (error);
3117: }
3118:
3119: /*
3120: * Return POSIX pathconf information applicable to nfs.
3121: *
3122: * The NFS V2 protocol doesn't support this, so just return EINVAL
3123: * for V2.
3124: */
3125: /* ARGSUSED */
3126: static int
3127: nfs_pathconf(ap)
3128: struct vop_pathconf_args /* {
3129: struct vnode *a_vp;
3130: int a_name;
3131: int *a_retval;
3132: } */ *ap;
3133: {
3134:
3135: return (EINVAL);
3136: }
3137:
3138: /*
3139: * NFS advisory byte-level locks.
3140: * Currently unsupported.
3141: */
3142: static int
3143: nfs_advlock(ap)
3144: struct vop_advlock_args /* {
3145: struct vnode *a_vp;
3146: caddr_t a_id;
3147: int a_op;
3148: struct flock *a_fl;
3149: int a_flags;
3150: } */ *ap;
3151: {
3152: #ifdef __FreeBSD__
3153: register struct nfsnode *np = VTONFS(ap->a_vp);
3154:
3155: /*
3156: * The following kludge is to allow diskless support to work
3157: * until a real NFS lockd is implemented. Basically, just pretend
3158: * that this is a local lock.
3159: */
3160: return (lf_advlock(ap, &(np->n_lockf), np->n_size));
3161: #else
3162: #if DIAGNOSTIC
3163: printf("nfs_advlock: unimplemented!!");
3164: #endif
3165: return (EOPNOTSUPP);
3166: #endif
3167: }
3168:
3169: /*
3170: * Print out the contents of an nfsnode.
3171: */
3172: static int
3173: nfs_print(ap)
3174: struct vop_print_args /* {
3175: struct vnode *a_vp;
3176: } */ *ap;
3177: {
3178: register struct vnode *vp = ap->a_vp;
3179: register struct nfsnode *np = VTONFS(vp);
3180:
3181: printf("tag VT_NFS, fileid %ld fsid 0x%lx",
3182: np->n_vattr.va_fileid, np->n_vattr.va_fsid);
3183: if (vp->v_type == VFIFO)
3184: fifo_printinfo(vp);
3185: printf("\n");
3186: return (0);
3187: }
3188:
3189: /*
3190: * NFS directory offset lookup.
3191: * Currently unsupported.
3192: */
3193: static int
3194: nfs_blkatoff(ap)
3195: struct vop_blkatoff_args /* {
3196: struct vnode *a_vp;
3197: off_t a_offset;
3198: char **a_res;
3199: struct buf **a_bpp;
3200: } */ *ap;
3201: {
3202:
3203: #if DIAGNOSTIC
3204: printf("nfs_blkatoff: unimplemented!!");
3205: #endif
3206: return (EOPNOTSUPP);
3207: }
3208:
3209: /*
3210: * NFS flat namespace allocation.
3211: * Currently unsupported.
3212: */
3213: static int
3214: nfs_valloc(ap)
3215: struct vop_valloc_args /* {
3216: struct vnode *a_pvp;
3217: int a_mode;
3218: struct ucred *a_cred;
3219: struct vnode **a_vpp;
3220: } */ *ap;
3221: {
3222:
3223: return (EOPNOTSUPP);
3224: }
3225:
3226: /*
3227: * NFS flat namespace free.
3228: * Currently unsupported.
3229: */
3230: static int
3231: nfs_vfree(ap)
3232: struct vop_vfree_args /* {
3233: struct vnode *a_pvp;
3234: ino_t a_ino;
3235: int a_mode;
3236: } */ *ap;
3237: {
3238:
3239: #if DIAGNOSTIC
3240: printf("nfs_vfree: unimplemented!!");
3241: #endif
3242: return (EOPNOTSUPP);
3243: }
3244:
3245: /*
3246: * NFS file truncation.
3247: */
3248: static int
3249: nfs_truncate(ap)
3250: struct vop_truncate_args /* {
3251: struct vnode *a_vp;
3252: off_t a_length;
3253: int a_flags;
3254: struct ucred *a_cred;
3255: struct proc *a_p;
3256: } */ *ap;
3257: {
3258:
3259: /* Use nfs_setattr */
3260: #if DIAGNOSTIC
3261: printf("nfs_truncate: unimplemented!!");
3262: #endif
3263: return (EOPNOTSUPP);
3264: }
3265:
3266: /*
3267: * NFS update.
3268: */
3269: static int
3270: nfs_update(ap)
3271: struct vop_update_args /* {
3272: struct vnode *a_vp;
3273: struct timeval *a_ta;
3274: struct timeval *a_tm;
3275: int a_waitfor;
3276: } */ *ap;
3277: {
3278:
3279: /* Use nfs_setattr */
3280: #if DIAGNOSTIC
3281: printf("nfs_update: unimplemented!!");
3282: #endif
3283: return (EOPNOTSUPP);
3284: }
3285:
3286: /*
3287: * Just call nfs_writebp() with the force argument set to 1.
3288: */
3289: static int
3290: nfs_bwrite(ap)
3291: struct vop_bwrite_args /* {
3292: struct vnode *a_bp;
3293: } */ *ap;
3294: {
3295:
3296: return (nfs_writebp(ap->a_bp, 1));
3297: }
3298:
3299: /*
3300: * This is a clone of vn_bwrite(), except that B_WRITEINPROG isn't set unless
3301: * the force flag is one and it also handles the B_NEEDCOMMIT flag.
3302: */
3303: int
3304: nfs_writebp(bp, force)
3305: register struct buf *bp;
3306: int force;
3307: {
3308: int s;
3309: register int oldflags = bp->b_flags, retv = 1;
3310: off_t off;
3311:
3312: if(!(bp->b_flags & B_BUSY))
3313: panic("nfs_writebp: buffer is not busy???");
3314:
3315: /* XXX CSM 12/4/97 Revisit when buffer cache upgraded */
3316: #ifdef notyet
3317: if (bp->b_flags & B_DELWRI) {
3318: --numdirtybuffers;
3319: if (needsbuffer)
3320: vfs_bio_need_satisfy();
3321: }
3322: #endif
3323: s = splbio();
3324: bp->b_flags &= ~(B_READ|B_DONE|B_ERROR|B_DELWRI);
3325:
3326: if ((oldflags & (B_ASYNC|B_DELWRI)) == (B_ASYNC|B_DELWRI)) {
3327: reassignbuf(bp, bp->b_vp);
3328: }
3329:
3330: bp->b_vp->v_numoutput++;
3331: current_proc()->p_stats->p_ru.ru_oublock++;
3332: splx(s);
3333:
3334: /*
3335: * If B_NEEDCOMMIT is set, a commit rpc may do the trick. If not
3336: * an actual write will have to be scheduled via. VOP_STRATEGY().
3337: * If B_WRITEINPROG is already set, then push it with a write anyhow.
3338: */
3339: vfs_busy_pages(bp, 1);
3340: if ((oldflags & (B_NEEDCOMMIT | B_WRITEINPROG)) == B_NEEDCOMMIT) {
3341: off = ((u_quad_t)bp->b_blkno) * DEV_BSIZE + bp->b_dirtyoff;
3342: bp->b_flags |= B_WRITEINPROG;
3343: retv = nfs_commit(bp->b_vp, off, bp->b_dirtyend-bp->b_dirtyoff,
3344: bp->b_wcred, bp->b_proc);
3345: bp->b_flags &= ~B_WRITEINPROG;
3346: if (!retv) {
3347: bp->b_dirtyoff = bp->b_dirtyend = 0;
3348: bp->b_flags &= ~B_NEEDCOMMIT;
3349: biodone(bp);
3350: } else if (retv == NFSERR_STALEWRITEVERF)
3351: nfs_clearcommit(bp->b_vp->v_mount);
3352: }
3353: if (retv) {
3354: if (force)
3355: bp->b_flags |= B_WRITEINPROG;
3356: VOP_STRATEGY(bp);
3357: }
3358:
3359: if( (oldflags & B_ASYNC) == 0) {
3360: int rtval = biowait(bp);
3361:
3362: if (oldflags & B_DELWRI) {
3363: s = splbio();
3364: reassignbuf(bp, bp->b_vp);
3365: splx(s);
3366: }
3367: brelse(bp);
3368: return (rtval);
3369: }
3370:
3371: return (0);
3372: }
3373:
3374: /*
3375: * nfs special file access vnode op.
3376: * Essentially just get vattr and then imitate iaccess() since the device is
3377: * local to the client.
3378: */
3379: static int
3380: nfsspec_access(ap)
3381: struct vop_access_args /* {
3382: struct vnode *a_vp;
3383: int a_mode;
3384: struct ucred *a_cred;
3385: struct proc *a_p;
3386: } */ *ap;
3387: {
3388: register struct vattr *vap;
3389: register gid_t *gp;
3390: register struct ucred *cred = ap->a_cred;
3391: struct vnode *vp = ap->a_vp;
3392: mode_t mode = ap->a_mode;
3393: struct vattr vattr;
3394: register int i;
3395: int error;
3396:
3397: /*
3398: * Disallow write attempts on filesystems mounted read-only;
3399: * unless the file is a socket, fifo, or a block or character
3400: * device resident on the filesystem.
3401: */
3402: if ((mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
3403: switch (vp->v_type) {
3404: case VREG: case VDIR: case VLNK:
3405: return (EROFS);
3406: }
3407: }
3408: /*
3409: * If you're the super-user,
3410: * you always get access.
3411: */
3412: if (cred->cr_uid == 0)
3413: return (0);
3414: vap = &vattr;
3415: error = VOP_GETATTR(vp, vap, cred, ap->a_p);
3416: if (error)
3417: return (error);
3418: /*
3419: * Access check is based on only one of owner, group, public.
3420: * If not owner, then check group. If not a member of the
3421: * group, then check public access.
3422: */
3423: if (cred->cr_uid != vap->va_uid) {
3424: mode >>= 3;
3425: gp = cred->cr_groups;
3426: for (i = 0; i < cred->cr_ngroups; i++, gp++)
3427: if (vap->va_gid == *gp)
3428: goto found;
3429: mode >>= 3;
3430: found:
3431: ;
3432: }
3433: error = (vap->va_mode & mode) == mode ? 0 : EACCES;
3434: return (error);
3435: }
3436:
3437: /*
3438: * Read wrapper for special devices.
3439: */
3440: static int
3441: nfsspec_read(ap)
3442: struct vop_read_args /* {
3443: struct vnode *a_vp;
3444: struct uio *a_uio;
3445: int a_ioflag;
3446: struct ucred *a_cred;
3447: } */ *ap;
3448: {
3449: register struct nfsnode *np = VTONFS(ap->a_vp);
3450:
3451: /*
3452: * Set access flag.
3453: */
3454: np->n_flag |= NACC;
3455: np->n_atim.tv_sec = time.tv_sec;
3456: np->n_atim.tv_nsec = time.tv_usec * 1000;
3457: return (VOCALL(spec_vnodeop_p, VOFFSET(vop_read), ap));
3458: }
3459:
3460: /*
3461: * Write wrapper for special devices.
3462: */
3463: static int
3464: nfsspec_write(ap)
3465: struct vop_write_args /* {
3466: struct vnode *a_vp;
3467: struct uio *a_uio;
3468: int a_ioflag;
3469: struct ucred *a_cred;
3470: } */ *ap;
3471: {
3472: register struct nfsnode *np = VTONFS(ap->a_vp);
3473:
3474: /*
3475: * Set update flag.
3476: */
3477: np->n_flag |= NUPD;
3478: np->n_mtim.tv_sec = time.tv_sec;
3479: np->n_mtim.tv_nsec = time.tv_usec * 1000;
3480: return (VOCALL(spec_vnodeop_p, VOFFSET(vop_write), ap));
3481: }
3482:
3483: /*
3484: * Close wrapper for special devices.
3485: *
3486: * Update the times on the nfsnode then do device close.
3487: */
3488: static int
3489: nfsspec_close(ap)
3490: struct vop_close_args /* {
3491: struct vnode *a_vp;
3492: int a_fflag;
3493: struct ucred *a_cred;
3494: struct proc *a_p;
3495: } */ *ap;
3496: {
3497: register struct vnode *vp = ap->a_vp;
3498: register struct nfsnode *np = VTONFS(vp);
3499: struct vattr vattr;
3500:
3501: if (np->n_flag & (NACC | NUPD)) {
3502: np->n_flag |= NCHG;
3503: if (vp->v_usecount == 1 &&
3504: (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
3505: VATTR_NULL(&vattr);
3506: if (np->n_flag & NACC)
3507: vattr.va_atime = np->n_atim;
3508: if (np->n_flag & NUPD)
3509: vattr.va_mtime = np->n_mtim;
3510: (void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_p);
3511: }
3512: }
3513: return (VOCALL(spec_vnodeop_p, VOFFSET(vop_close), ap));
3514: }
3515:
3516: /*
3517: * Read wrapper for fifos.
3518: */
3519: static int
3520: nfsfifo_read(ap)
3521: struct vop_read_args /* {
3522: struct vnode *a_vp;
3523: struct uio *a_uio;
3524: int a_ioflag;
3525: struct ucred *a_cred;
3526: } */ *ap;
3527: {
3528: extern int (**fifo_vnodeop_p)();
3529: register struct nfsnode *np = VTONFS(ap->a_vp);
3530:
3531: /*
3532: * Set access flag.
3533: */
3534: np->n_flag |= NACC;
3535: np->n_atim.tv_sec = time.tv_sec;
3536: np->n_atim.tv_nsec = time.tv_usec * 1000;
3537: return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_read), ap));
3538: }
3539:
3540: /*
3541: * Write wrapper for fifos.
3542: */
3543: static int
3544: nfsfifo_write(ap)
3545: struct vop_write_args /* {
3546: struct vnode *a_vp;
3547: struct uio *a_uio;
3548: int a_ioflag;
3549: struct ucred *a_cred;
3550: } */ *ap;
3551: {
3552: extern int (**fifo_vnodeop_p)();
3553: register struct nfsnode *np = VTONFS(ap->a_vp);
3554:
3555: /*
3556: * Set update flag.
3557: */
3558: np->n_flag |= NUPD;
3559: np->n_mtim.tv_sec = time.tv_sec;
3560: np->n_mtim.tv_nsec = time.tv_usec * 1000;
3561: return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_write), ap));
3562: }
3563:
3564: /*
3565: * Close wrapper for fifos.
3566: *
3567: * Update the times on the nfsnode then do fifo close.
3568: */
3569: static int
3570: nfsfifo_close(ap)
3571: struct vop_close_args /* {
3572: struct vnode *a_vp;
3573: int a_fflag;
3574: struct ucred *a_cred;
3575: struct proc *a_p;
3576: } */ *ap;
3577: {
3578: register struct vnode *vp = ap->a_vp;
3579: register struct nfsnode *np = VTONFS(vp);
3580: struct vattr vattr;
3581: extern int (**fifo_vnodeop_p)();
3582:
3583: if (np->n_flag & (NACC | NUPD)) {
3584: if (np->n_flag & NACC) {
3585: np->n_atim.tv_sec = time.tv_sec;
3586: np->n_atim.tv_nsec = time.tv_usec * 1000;
3587: }
3588: if (np->n_flag & NUPD) {
3589: np->n_mtim.tv_sec = time.tv_sec;
3590: np->n_mtim.tv_nsec = time.tv_usec * 1000;
3591: }
3592: np->n_flag |= NCHG;
3593: if (vp->v_usecount == 1 &&
3594: (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
3595: VATTR_NULL(&vattr);
3596: if (np->n_flag & NACC)
3597: vattr.va_atime = np->n_atim;
3598: if (np->n_flag & NUPD)
3599: vattr.va_mtime = np->n_mtim;
3600: (void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_p);
3601: }
3602: }
3603: return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_close), ap));
3604: }
3605:
3606: static int
3607: nfs_ioctl(ap)
3608: struct vop_ioctl_args *ap;
3609: {
3610:
3611: /*
3612: * XXX we were once bogusly enoictl() which returned this (ENOTTY).
3613: * Probably we should return ENODEV.
3614: */
3615: return (ENOTTY);
3616: }
3617:
3618: static int
3619: nfs_select(ap)
3620: struct vop_select_args *ap;
3621: {
3622:
3623: /*
3624: * We were once bogusly seltrue() which returns 1. Is this right?
3625: */
3626: return (1);
3627: }
3628: /* Pagein */
3629: nfs_pagein(ap)
3630: struct vop_pagein_args /* {
3631: struct vnode *a_vp;
3632: struct uio *a_uio;
3633: int a_ioflag;
3634: struct ucred *a_cred;
3635: } */ *ap;
3636: {
3637: struct vnode *vp=ap->a_vp;
3638: struct vm_info * vmp=vp->v_vm_info;
3639: struct ucred *reader_cred=ap->a_cred;
3640: if ((vp->v_vm_info) && vp->v_vm_info->cred) {
3641: reader_cred = vp->v_vm_info->cred;
3642: }
3643:
3644: return (VOP_READ(ap->a_vp, ap->a_uio, ap->a_ioflag, reader_cred));
3645: }
3646:
3647: /* Pageout */
3648: nfs_pageout(ap)
3649: struct vop_pageout_args /* {
3650: struct vnode *a_vp;
3651: struct uio *a_uio;
3652: int a_ioflag;
3653: struct ucred *a_cred;
3654: } */ *ap;
3655: {
3656: struct vnode *vp=ap->a_vp;
3657: struct vm_info * vmp=vp->v_vm_info;
3658: struct ucred *writer_cred=ap->a_cred;
3659: if ((vp->v_vm_info) && vp->v_vm_info->cred) {
3660: writer_cred = vp->v_vm_info->cred;
3661: }
3662:
3663: return (VOP_WRITE(ap->a_vp, ap->a_uio, ap->a_ioflag, writer_cred));
3664: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.