]> git.saurik.com Git - apple/xnu.git/blob - bsd/nfs/nfs_vnops.c
projects / apple / xnu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
xnu-792.17.14.tar.gz
[apple/xnu.git] / bsd / nfs / nfs_vnops.c
1 /*
2 * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
29 /*
30 * Copyright (c) 1989, 1993
31 * The Regents of the University of California. All rights reserved.
32 *
33 * This code is derived from software contributed to Berkeley by
34 * Rick Macklem at The University of Guelph.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
38 * are met:
39 * 1. Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
41 * 2. Redistributions in binary form must reproduce the above copyright
42 * notice, this list of conditions and the following disclaimer in the
43 * documentation and/or other materials provided with the distribution.
44 * 3. All advertising materials mentioning features or use of this software
45 * must display the following acknowledgement:
46 * This product includes software developed by the University of
47 * California, Berkeley and its contributors.
48 * 4. Neither the name of the University nor the names of its contributors
49 * may be used to endorse or promote products derived from this software
50 * without specific prior written permission.
51 *
52 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
53 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
54 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
55 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
56 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
57 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
58 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
59 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
60 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
61 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
62 * SUCH DAMAGE.
63 *
64 * @(#)nfs_vnops.c 8.16 (Berkeley) 5/27/95
65 * FreeBSD-Id: nfs_vnops.c,v 1.72 1997/11/07 09:20:48 phk Exp $
66 */
67
68
69 /*
70 * vnode op calls for Sun NFS version 2 and 3
71 */
72 #include <sys/param.h>
73 #include <sys/kernel.h>
74 #include <sys/systm.h>
75 #include <sys/resourcevar.h>
76 #include <sys/proc_internal.h>
77 #include <sys/kauth.h>
78 #include <sys/mount_internal.h>
79 #include <sys/malloc.h>
80 #include <sys/kpi_mbuf.h>
81 #include <sys/conf.h>
82 #include <sys/vnode_internal.h>
83 #include <sys/dirent.h>
84 #include <sys/fcntl.h>
85 #include <sys/lockf.h>
86 #include <sys/ubc_internal.h>
87 #include <sys/attr.h>
88 #include <sys/signalvar.h>
89 #include <sys/uio_internal.h>
90
91 #include <vfs/vfs_support.h>
92
93 #include <sys/vm.h>
94
95 #include <sys/time.h>
96 #include <kern/clock.h>
97 #include <libkern/OSAtomic.h>
98
99 #include <miscfs/fifofs/fifo.h>
100 #include <miscfs/specfs/specdev.h>
101
102 #include <nfs/rpcv2.h>
103 #include <nfs/nfsproto.h>
104 #include <nfs/nfs.h>
105 #include <nfs/nfsnode.h>
106 #include <nfs/nfsmount.h>
107 #include <nfs/nfs_lock.h>
108 #include <nfs/xdr_subs.h>
109 #include <nfs/nfsm_subs.h>
110
111 #include <net/if.h>
112 #include <netinet/in.h>
113 #include <netinet/in_var.h>
114 #include <vm/vm_kern.h>
115
116 #include <kern/task.h>
117 #include <kern/sched_prim.h>
118
119 #include <sys/kdebug.h>
120
121 #define FSDBG(A, B, C, D, E) \
122 KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, (A))) | DBG_FUNC_NONE, \
123 (int)(B), (int)(C), (int)(D), (int)(E), 0)
124 #define FSDBG_TOP(A, B, C, D, E) \
125 KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, (A))) | DBG_FUNC_START, \
126 (int)(B), (int)(C), (int)(D), (int)(E), 0)
127 #define FSDBG_BOT(A, B, C, D, E) \
128 KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, (A))) | DBG_FUNC_END, \
129 (int)(B), (int)(C), (int)(D), (int)(E), 0)
130
131 static int nfsspec_read(struct vnop_read_args *);
132 static int nfsspec_write(struct vnop_write_args *);
133 static int nfsfifo_read(struct vnop_read_args *);
134 static int nfsfifo_write(struct vnop_write_args *);
135 static int nfsspec_close(struct vnop_close_args *);
136 static int nfsfifo_close(struct vnop_close_args *);
137 static int nfs_ioctl(struct vnop_ioctl_args *);
138 static int nfs_select(struct vnop_select_args *);
139 static int nfs_setattrrpc(vnode_t,struct vnode_attr *,kauth_cred_t,proc_t);
140 static int nfs_lookup(struct vnop_lookup_args *);
141 static int nfs_create(struct vnop_create_args *);
142 static int nfs_mknod(struct vnop_mknod_args *);
143 static int nfs_open(struct vnop_open_args *);
144 static int nfs_close(struct vnop_close_args *);
145 static int nfs_access(struct vnop_access_args *);
146 static int nfs_vnop_getattr(struct vnop_getattr_args *);
147 static int nfs_setattr(struct vnop_setattr_args *);
148 static int nfs_read(struct vnop_read_args *);
149 static int nfs_mmap(struct vnop_mmap_args *);
150 static int nfs_fsync(struct vnop_fsync_args *);
151 static int nfs_remove(struct vnop_remove_args *);
152 static int nfs_link(struct vnop_link_args *);
153 static int nfs_rename(struct vnop_rename_args *);
154 static int nfs_mkdir(struct vnop_mkdir_args *);
155 static int nfs_rmdir(struct vnop_rmdir_args *);
156 static int nfs_symlink(struct vnop_symlink_args *);
157 static int nfs_readdir(struct vnop_readdir_args *);
158 static int nfs_lookitup(vnode_t,char *,int,kauth_cred_t,proc_t,struct nfsnode **);
159 static int nfs_sillyrename(vnode_t,vnode_t,struct componentname *,kauth_cred_t,proc_t);
160 static int nfs_readlink(struct vnop_readlink_args *);
161 static int nfs_pathconf(struct vnop_pathconf_args *);
162 static int nfs_advlock(struct vnop_advlock_args *);
163 static int nfs_pagein(struct vnop_pagein_args *);
164 static int nfs_pageout(struct vnop_pageout_args *);
165 static int nfs_blktooff(struct vnop_blktooff_args *);
166 static int nfs_offtoblk(struct vnop_offtoblk_args *);
167 static int nfs_blockmap(struct vnop_blockmap_args *);
168
169 /*
170 * Global vfs data structures for nfs
171 */
172 vnop_t **nfsv2_vnodeop_p;
173 static struct vnodeopv_entry_desc nfsv2_vnodeop_entries[] = {
174 { &vnop_default_desc, (vnop_t *)vn_default_error },
175 { &vnop_lookup_desc, (vnop_t *)nfs_lookup }, /* lookup */
176 { &vnop_create_desc, (vnop_t *)nfs_create }, /* create */
177 { &vnop_mknod_desc, (vnop_t *)nfs_mknod }, /* mknod */
178 { &vnop_open_desc, (vnop_t *)nfs_open }, /* open */
179 { &vnop_close_desc, (vnop_t *)nfs_close }, /* close */
180 { &vnop_access_desc, (vnop_t *)nfs_access }, /* access */
181 { &vnop_getattr_desc, (vnop_t *)nfs_vnop_getattr }, /* getattr */
182 { &vnop_setattr_desc, (vnop_t *)nfs_setattr }, /* setattr */
183 { &vnop_read_desc, (vnop_t *)nfs_read }, /* read */
184 { &vnop_write_desc, (vnop_t *)nfs_write }, /* write */
185 { &vnop_ioctl_desc, (vnop_t *)nfs_ioctl }, /* ioctl */
186 { &vnop_select_desc, (vnop_t *)nfs_select }, /* select */
187 { &vnop_revoke_desc, (vnop_t *)nfs_revoke }, /* revoke */
188 { &vnop_mmap_desc, (vnop_t *)nfs_mmap }, /* mmap */
189 { &vnop_fsync_desc, (vnop_t *)nfs_fsync }, /* fsync */
190 { &vnop_remove_desc, (vnop_t *)nfs_remove }, /* remove */
191 { &vnop_link_desc, (vnop_t *)nfs_link }, /* link */
192 { &vnop_rename_desc, (vnop_t *)nfs_rename }, /* rename */
193 { &vnop_mkdir_desc, (vnop_t *)nfs_mkdir }, /* mkdir */
194 { &vnop_rmdir_desc, (vnop_t *)nfs_rmdir }, /* rmdir */
195 { &vnop_symlink_desc, (vnop_t *)nfs_symlink }, /* symlink */
196 { &vnop_readdir_desc, (vnop_t *)nfs_readdir }, /* readdir */
197 { &vnop_readlink_desc, (vnop_t *)nfs_readlink }, /* readlink */
198 { &vnop_inactive_desc, (vnop_t *)nfs_inactive }, /* inactive */
199 { &vnop_reclaim_desc, (vnop_t *)nfs_reclaim }, /* reclaim */
200 { &vnop_strategy_desc, (vnop_t *)err_strategy }, /* strategy */
201 { &vnop_pathconf_desc, (vnop_t *)nfs_pathconf }, /* pathconf */
202 { &vnop_advlock_desc, (vnop_t *)nfs_advlock }, /* advlock */
203 { &vnop_bwrite_desc, (vnop_t *)err_bwrite }, /* bwrite */
204 { &vnop_pagein_desc, (vnop_t *)nfs_pagein }, /* Pagein */
205 { &vnop_pageout_desc, (vnop_t *)nfs_pageout }, /* Pageout */
206 { &vnop_copyfile_desc, (vnop_t *)err_copyfile }, /* Copyfile */
207 { &vnop_blktooff_desc, (vnop_t *)nfs_blktooff }, /* blktooff */
208 { &vnop_offtoblk_desc, (vnop_t *)nfs_offtoblk }, /* offtoblk */
209 { &vnop_blockmap_desc, (vnop_t *)nfs_blockmap }, /* blockmap */
210 { NULL, NULL }
211 };
212 struct vnodeopv_desc nfsv2_vnodeop_opv_desc =
213 { &nfsv2_vnodeop_p, nfsv2_vnodeop_entries };
214 #ifdef __FreeBSD__
215 VNODEOP_SET(nfsv2_vnodeop_opv_desc);
216 #endif
217
218 /*
219 * Special device vnode ops
220 */
221 vnop_t **spec_nfsv2nodeop_p;
222 static struct vnodeopv_entry_desc spec_nfsv2nodeop_entries[] = {
223 { &vnop_default_desc, (vnop_t *)vn_default_error },
224 { &vnop_lookup_desc, (vnop_t *)spec_lookup }, /* lookup */
225 { &vnop_create_desc, (vnop_t *)spec_create }, /* create */
226 { &vnop_mknod_desc, (vnop_t *)spec_mknod }, /* mknod */
227 { &vnop_open_desc, (vnop_t *)spec_open }, /* open */
228 { &vnop_close_desc, (vnop_t *)nfsspec_close }, /* close */
229 { &vnop_getattr_desc, (vnop_t *)nfs_vnop_getattr }, /* getattr */
230 { &vnop_setattr_desc, (vnop_t *)nfs_setattr }, /* setattr */
231 { &vnop_read_desc, (vnop_t *)nfsspec_read }, /* read */
232 { &vnop_write_desc, (vnop_t *)nfsspec_write }, /* write */
233 { &vnop_ioctl_desc, (vnop_t *)spec_ioctl }, /* ioctl */
234 { &vnop_select_desc, (vnop_t *)spec_select }, /* select */
235 { &vnop_revoke_desc, (vnop_t *)spec_revoke }, /* revoke */
236 { &vnop_mmap_desc, (vnop_t *)spec_mmap }, /* mmap */
237 { &vnop_fsync_desc, (vnop_t *)nfs_fsync }, /* fsync */
238 { &vnop_remove_desc, (vnop_t *)spec_remove }, /* remove */
239 { &vnop_link_desc, (vnop_t *)spec_link }, /* link */
240 { &vnop_rename_desc, (vnop_t *)spec_rename }, /* rename */
241 { &vnop_mkdir_desc, (vnop_t *)spec_mkdir }, /* mkdir */
242 { &vnop_rmdir_desc, (vnop_t *)spec_rmdir }, /* rmdir */
243 { &vnop_symlink_desc, (vnop_t *)spec_symlink }, /* symlink */
244 { &vnop_readdir_desc, (vnop_t *)spec_readdir }, /* readdir */
245 { &vnop_readlink_desc, (vnop_t *)spec_readlink }, /* readlink */
246 { &vnop_inactive_desc, (vnop_t *)nfs_inactive }, /* inactive */
247 { &vnop_reclaim_desc, (vnop_t *)nfs_reclaim }, /* reclaim */
248 { &vnop_strategy_desc, (vnop_t *)spec_strategy }, /* strategy */
249 { &vnop_pathconf_desc, (vnop_t *)spec_pathconf }, /* pathconf */
250 { &vnop_advlock_desc, (vnop_t *)spec_advlock }, /* advlock */
251 { &vnop_bwrite_desc, (vnop_t *)vn_bwrite }, /* bwrite */
252 { &vnop_pagein_desc, (vnop_t *)nfs_pagein }, /* Pagein */
253 { &vnop_pageout_desc, (vnop_t *)nfs_pageout }, /* Pageout */
254 { &vnop_blktooff_desc, (vnop_t *)nfs_blktooff }, /* blktooff */
255 { &vnop_offtoblk_desc, (vnop_t *)nfs_offtoblk }, /* offtoblk */
256 { &vnop_blockmap_desc, (vnop_t *)nfs_blockmap }, /* blockmap */
257 { NULL, NULL }
258 };
259 struct vnodeopv_desc spec_nfsv2nodeop_opv_desc =
260 { &spec_nfsv2nodeop_p, spec_nfsv2nodeop_entries };
261 #ifdef __FreeBSD__
262 VNODEOP_SET(spec_nfsv2nodeop_opv_desc);
263 #endif
264
265 vnop_t **fifo_nfsv2nodeop_p;
266 static struct vnodeopv_entry_desc fifo_nfsv2nodeop_entries[] = {
267 { &vnop_default_desc, (vnop_t *)vn_default_error },
268 { &vnop_lookup_desc, (vnop_t *)fifo_lookup }, /* lookup */
269 { &vnop_create_desc, (vnop_t *)fifo_create }, /* create */
270 { &vnop_mknod_desc, (vnop_t *)fifo_mknod }, /* mknod */
271 { &vnop_open_desc, (vnop_t *)fifo_open }, /* open */
272 { &vnop_close_desc, (vnop_t *)nfsfifo_close }, /* close */
273 { &vnop_getattr_desc, (vnop_t *)nfs_vnop_getattr }, /* getattr */
274 { &vnop_setattr_desc, (vnop_t *)nfs_setattr }, /* setattr */
275 { &vnop_read_desc, (vnop_t *)nfsfifo_read }, /* read */
276 { &vnop_write_desc, (vnop_t *)nfsfifo_write }, /* write */
277 { &vnop_ioctl_desc, (vnop_t *)fifo_ioctl }, /* ioctl */
278 { &vnop_select_desc, (vnop_t *)fifo_select }, /* select */
279 { &vnop_revoke_desc, (vnop_t *)fifo_revoke }, /* revoke */
280 { &vnop_mmap_desc, (vnop_t *)fifo_mmap }, /* mmap */
281 { &vnop_fsync_desc, (vnop_t *)nfs_fsync }, /* fsync */
282 { &vnop_remove_desc, (vnop_t *)fifo_remove }, /* remove */
283 { &vnop_link_desc, (vnop_t *)fifo_link }, /* link */
284 { &vnop_rename_desc, (vnop_t *)fifo_rename }, /* rename */
285 { &vnop_mkdir_desc, (vnop_t *)fifo_mkdir }, /* mkdir */
286 { &vnop_rmdir_desc, (vnop_t *)fifo_rmdir }, /* rmdir */
287 { &vnop_symlink_desc, (vnop_t *)fifo_symlink }, /* symlink */
288 { &vnop_readdir_desc, (vnop_t *)fifo_readdir }, /* readdir */
289 { &vnop_readlink_desc, (vnop_t *)fifo_readlink }, /* readlink */
290 { &vnop_inactive_desc, (vnop_t *)nfs_inactive }, /* inactive */
291 { &vnop_reclaim_desc, (vnop_t *)nfs_reclaim }, /* reclaim */
292 { &vnop_strategy_desc, (vnop_t *)fifo_strategy }, /* strategy */
293 { &vnop_pathconf_desc, (vnop_t *)fifo_pathconf }, /* pathconf */
294 { &vnop_advlock_desc, (vnop_t *)fifo_advlock }, /* advlock */
295 { &vnop_bwrite_desc, (vnop_t *)vn_bwrite }, /* bwrite */
296 { &vnop_pagein_desc, (vnop_t *)nfs_pagein }, /* Pagein */
297 { &vnop_pageout_desc, (vnop_t *)nfs_pageout }, /* Pageout */
298 { &vnop_blktooff_desc, (vnop_t *)nfs_blktooff }, /* blktooff */
299 { &vnop_offtoblk_desc, (vnop_t *)nfs_offtoblk }, /* offtoblk */
300 { &vnop_blockmap_desc, (vnop_t *)nfs_blockmap }, /* blockmap */
301 { NULL, NULL }
302 };
303 struct vnodeopv_desc fifo_nfsv2nodeop_opv_desc =
304 { &fifo_nfsv2nodeop_p, fifo_nfsv2nodeop_entries };
305 #ifdef __FreeBSD__
306 VNODEOP_SET(fifo_nfsv2nodeop_opv_desc);
307 #endif
308
309 static int nfs_mknodrpc(vnode_t dvp, vnode_t *vpp,
310 struct componentname *cnp,
311 struct vnode_attr *vap,
312 kauth_cred_t cred, proc_t p);
313 static int nfs_removerpc(vnode_t dvp, char *name, int namelen,
314 kauth_cred_t cred, proc_t proc);
315 static int nfs_renamerpc(vnode_t fdvp, char *fnameptr,
316 int fnamelen, vnode_t tdvp,
317 char *tnameptr, int tnamelen,
318 kauth_cred_t cred, proc_t proc);
319
320 /*
321 * Global variables
322 */
323 extern u_long nfs_xdrneg1;
324 extern u_long nfs_true, nfs_false;
325 extern struct nfsstats nfsstats;
326 extern nfstype nfsv3_type[9];
327 proc_t nfs_iodwant[NFS_MAXASYNCDAEMON];
328 struct nfsmount *nfs_iodmount[NFS_MAXASYNCDAEMON];
329
330 lck_grp_t *nfs_iod_lck_grp;
331 lck_grp_attr_t *nfs_iod_lck_grp_attr;
332 lck_attr_t *nfs_iod_lck_attr;
333 lck_mtx_t *nfs_iod_mutex;
334
335 int nfs_numasync = 0;
336 int nfs_ioddelwri = 0;
337
338 #define DIRHDSIZ (sizeof (struct dirent) - (MAXNAMLEN + 1))
339
340 static int nfsaccess_cache_timeout = NFS_MAXATTRTIMO;
341 /* SYSCTL_INT(_vfs_nfs, OID_AUTO, access_cache_timeout, CTLFLAG_RW,
342 &nfsaccess_cache_timeout, 0, "NFS ACCESS cache timeout");
343 */
344 #define NFSV3ACCESS_ALL (NFSV3ACCESS_READ | NFSV3ACCESS_MODIFY \
345 | NFSV3ACCESS_EXTEND | NFSV3ACCESS_EXECUTE \
346 | NFSV3ACCESS_DELETE | NFSV3ACCESS_LOOKUP)
347
348
349 /*
350 * the following are needed only by nfs_pageout to know how to handle errors
351 * see nfs_pageout comments on explanation of actions.
352 * the errors here are copied from errno.h and errors returned by servers
353 * are expected to match the same numbers here. If not, our actions maybe
354 * erroneous.
355 */
356 enum actiontype {NOACTION, DUMP, DUMPANDLOG, RETRY, RETRYWITHSLEEP, SEVER};
357
358 static int errorcount[ELAST+1]; /* better be zeros when initialized */
359
360 static const short errortooutcome[ELAST+1] = {
361 NOACTION,
362 DUMP, /* EPERM 1 Operation not permitted */
363 DUMP, /* ENOENT 2 No such file or directory */
364 DUMPANDLOG, /* ESRCH 3 No such process */
365 RETRY, /* EINTR 4 Interrupted system call */
366 DUMP, /* EIO 5 Input/output error */
367 DUMP, /* ENXIO 6 Device not configured */
368 DUMPANDLOG, /* E2BIG 7 Argument list too long */
369 DUMPANDLOG, /* ENOEXEC 8 Exec format error */
370 DUMPANDLOG, /* EBADF 9 Bad file descriptor */
371 DUMPANDLOG, /* ECHILD 10 No child processes */
372 DUMPANDLOG, /* EDEADLK 11 Resource deadlock avoided - was EAGAIN */
373 RETRY, /* ENOMEM 12 Cannot allocate memory */
374 DUMP, /* EACCES 13 Permission denied */
375 DUMPANDLOG, /* EFAULT 14 Bad address */
376 DUMPANDLOG, /* ENOTBLK 15 POSIX - Block device required */
377 RETRY, /* EBUSY 16 Device busy */
378 DUMP, /* EEXIST 17 File exists */
379 DUMP, /* EXDEV 18 Cross-device link */
380 DUMP, /* ENODEV 19 Operation not supported by device */
381 DUMP, /* ENOTDIR 20 Not a directory */
382 DUMP, /* EISDIR 21 Is a directory */
383 DUMP, /* EINVAL 22 Invalid argument */
384 DUMPANDLOG, /* ENFILE 23 Too many open files in system */
385 DUMPANDLOG, /* EMFILE 24 Too many open files */
386 DUMPANDLOG, /* ENOTTY 25 Inappropriate ioctl for device */
387 DUMPANDLOG, /* ETXTBSY 26 Text file busy - POSIX */
388 DUMP, /* EFBIG 27 File too large */
389 DUMP, /* ENOSPC 28 No space left on device */
390 DUMPANDLOG, /* ESPIPE 29 Illegal seek */
391 DUMP, /* EROFS 30 Read-only file system */
392 DUMP, /* EMLINK 31 Too many links */
393 RETRY, /* EPIPE 32 Broken pipe */
394 /* math software */
395 DUMPANDLOG, /* EDOM 33 Numerical argument out of domain */
396 DUMPANDLOG, /* ERANGE 34 Result too large */
397 RETRY, /* EAGAIN/EWOULDBLOCK 35 Resource temporarily unavailable */
398 DUMPANDLOG, /* EINPROGRESS 36 Operation now in progress */
399 DUMPANDLOG, /* EALREADY 37 Operation already in progress */
400 /* ipc/network software -- argument errors */
401 DUMPANDLOG, /* ENOTSOC 38 Socket operation on non-socket */
402 DUMPANDLOG, /* EDESTADDRREQ 39 Destination address required */
403 DUMPANDLOG, /* EMSGSIZE 40 Message too long */
404 DUMPANDLOG, /* EPROTOTYPE 41 Protocol wrong type for socket */
405 DUMPANDLOG, /* ENOPROTOOPT 42 Protocol not available */
406 DUMPANDLOG, /* EPROTONOSUPPORT 43 Protocol not supported */
407 DUMPANDLOG, /* ESOCKTNOSUPPORT 44 Socket type not supported */
408 DUMPANDLOG, /* ENOTSUP 45 Operation not supported */
409 DUMPANDLOG, /* EPFNOSUPPORT 46 Protocol family not supported */
410 DUMPANDLOG, /* EAFNOSUPPORT 47 Address family not supported by protocol family */
411 DUMPANDLOG, /* EADDRINUSE 48 Address already in use */
412 DUMPANDLOG, /* EADDRNOTAVAIL 49 Can't assign requested address */
413 /* ipc/network software -- operational errors */
414 RETRY, /* ENETDOWN 50 Network is down */
415 RETRY, /* ENETUNREACH 51 Network is unreachable */
416 RETRY, /* ENETRESET 52 Network dropped connection on reset */
417 RETRY, /* ECONNABORTED 53 Software caused connection abort */
418 RETRY, /* ECONNRESET 54 Connection reset by peer */
419 RETRY, /* ENOBUFS 55 No buffer space available */
420 RETRY, /* EISCONN 56 Socket is already connected */
421 RETRY, /* ENOTCONN 57 Socket is not connected */
422 RETRY, /* ESHUTDOWN 58 Can't send after socket shutdown */
423 RETRY, /* ETOOMANYREFS 59 Too many references: can't splice */
424 RETRY, /* ETIMEDOUT 60 Operation timed out */
425 RETRY, /* ECONNREFUSED 61 Connection refused */
426
427 DUMPANDLOG, /* ELOOP 62 Too many levels of symbolic links */
428 DUMP, /* ENAMETOOLONG 63 File name too long */
429 RETRY, /* EHOSTDOWN 64 Host is down */
430 RETRY, /* EHOSTUNREACH 65 No route to host */
431 DUMP, /* ENOTEMPTY 66 Directory not empty */
432 /* quotas & mush */
433 DUMPANDLOG, /* PROCLIM 67 Too many processes */
434 DUMPANDLOG, /* EUSERS 68 Too many users */
435 DUMPANDLOG, /* EDQUOT 69 Disc quota exceeded */
436 /* Network File System */
437 DUMP, /* ESTALE 70 Stale NFS file handle */
438 DUMP, /* EREMOTE 71 Too many levels of remote in path */
439 DUMPANDLOG, /* EBADRPC 72 RPC struct is bad */
440 DUMPANDLOG, /* ERPCMISMATCH 73 RPC version wrong */
441 DUMPANDLOG, /* EPROGUNAVAIL 74 RPC prog. not avail */
442 DUMPANDLOG, /* EPROGMISMATCH 75 Program version wrong */
443 DUMPANDLOG, /* EPROCUNAVAIL 76 Bad procedure for program */
444
445 DUMPANDLOG, /* ENOLCK 77 No locks available */
446 DUMPANDLOG, /* ENOSYS 78 Function not implemented */
447 DUMPANDLOG, /* EFTYPE 79 Inappropriate file type or format */
448 DUMPANDLOG, /* EAUTH 80 Authentication error */
449 DUMPANDLOG, /* ENEEDAUTH 81 Need authenticator */
450 /* Intelligent device errors */
451 DUMPANDLOG, /* EPWROFF 82 Device power is off */
452 DUMPANDLOG, /* EDEVERR 83 Device error, e.g. paper out */
453 DUMPANDLOG, /* EOVERFLOW 84 Value too large to be stored in data type */
454 /* Program loading errors */
455 DUMPANDLOG, /* EBADEXEC 85 Bad executable */
456 DUMPANDLOG, /* EBADARCH 86 Bad CPU type in executable */
457 DUMPANDLOG, /* ESHLIBVERS 87 Shared library version mismatch */
458 DUMPANDLOG, /* EBADMACHO 88 Malformed Macho file */
459 };
460
461
462 static short
463 nfs_pageouterrorhandler(int error)
464 {
465 if (error > ELAST)
466 return(DUMP);
467 else
468 return(errortooutcome[error]);
469 }
470
471 static int
472 nfs3_access_otw(vnode_t vp,
473 int wmode,
474 proc_t p,
475 kauth_cred_t cred)
476 {
477 const int v3 = 1;
478 u_long *tl;
479 int error = 0, attrflag;
480
481 mbuf_t mreq, mrep, md, mb, mb2;
482 caddr_t bpos, dpos, cp2;
483 register long t1, t2;
484 register caddr_t cp;
485 u_int32_t rmode;
486 struct nfsnode *np = VTONFS(vp);
487 u_int64_t xid;
488 struct timeval now;
489
490 nfsm_reqhead(NFSX_FH(v3) + NFSX_UNSIGNED);
491 if (error)
492 return (error);
493 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_ACCESS]);
494 nfsm_fhtom(vp, v3);
495 nfsm_build(tl, u_long *, NFSX_UNSIGNED);
496 *tl = txdr_unsigned(wmode);
497 nfsm_request(vp, NFSPROC_ACCESS, p, cred, &xid);
498 if (mrep) {
499 nfsm_postop_attr_update(vp, 1, attrflag, &xid);
500 }
501 if (!error) {
502 nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
503 rmode = fxdr_unsigned(u_int32_t, *tl);
504 np->n_mode = rmode;
505 np->n_modeuid = kauth_cred_getuid(cred);
506 microuptime(&now);
507 np->n_modestamp = now.tv_sec;
508 }
509 nfsm_reqdone;
510 return error;
511 }
512
513 /*
514 * nfs access vnode op.
515 * For nfs version 2, just return ok. File accesses may fail later.
516 * For nfs version 3, use the access rpc to check accessibility. If file modes
517 * are changed on the server, accesses might still fail later.
518 */
519 static int
520 nfs_access(ap)
521 struct vnop_access_args /* {
522 struct vnodeop_desc *a_desc;
523 vnode_t a_vp;
524 int a_mode;
525 vfs_context_t a_context;
526 } */ *ap;
527 {
528 vnode_t vp = ap->a_vp;
529 int error = 0, dorpc;
530 u_long mode, wmode;
531 int v3 = NFS_ISV3(vp);
532 struct nfsnode *np = VTONFS(vp);
533 struct timeval now;
534 kauth_cred_t cred;
535
536 /*
537 * For nfs v3, do an access rpc, otherwise you are stuck emulating
538 * ufs_access() locally using the vattr. This may not be correct,
539 * since the server may apply other access criteria such as
540 * client uid-->server uid mapping that we do not know about, but
541 * this is better than just returning anything that is lying about
542 * in the cache.
543 */
544 if (v3) {
545 /*
546 * Convert KAUTH primitives to NFS access rights.
547 */
548 mode = 0;
549 if (vnode_isdir(vp)) {
550 /* directory */
551 if (ap->a_action &
552 (KAUTH_VNODE_LIST_DIRECTORY |
553 KAUTH_VNODE_READ_EXTATTRIBUTES))
554 mode |= NFSV3ACCESS_READ;
555 if (ap->a_action & KAUTH_VNODE_SEARCH)
556 mode |= NFSV3ACCESS_LOOKUP;
557 if (ap->a_action &
558 (KAUTH_VNODE_ADD_FILE |
559 KAUTH_VNODE_ADD_SUBDIRECTORY))
560 mode |= NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND;
561 if (ap->a_action & KAUTH_VNODE_DELETE_CHILD)
562 mode |= NFSV3ACCESS_MODIFY;
563 } else {
564 /* file */
565 if (ap->a_action &
566 (KAUTH_VNODE_READ_DATA |
567 KAUTH_VNODE_READ_EXTATTRIBUTES))
568 mode |= NFSV3ACCESS_READ;
569 if (ap->a_action & KAUTH_VNODE_WRITE_DATA)
570 mode |= NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND;
571 if (ap->a_action & KAUTH_VNODE_APPEND_DATA)
572 mode |= NFSV3ACCESS_EXTEND;
573 if (ap->a_action & KAUTH_VNODE_EXECUTE)
574 mode |= NFSV3ACCESS_EXECUTE;
575 }
576 /* common */
577 if (ap->a_action & KAUTH_VNODE_DELETE)
578 mode |= NFSV3ACCESS_DELETE;
579 if (ap->a_action &
580 (KAUTH_VNODE_WRITE_ATTRIBUTES |
581 KAUTH_VNODE_WRITE_EXTATTRIBUTES |
582 KAUTH_VNODE_WRITE_SECURITY))
583 mode |= NFSV3ACCESS_MODIFY;
584 /* XXX this is pretty dubious */
585 if (ap->a_action & KAUTH_VNODE_CHANGE_OWNER)
586 mode |= NFSV3ACCESS_MODIFY;
587
588 /* if caching, always ask for every right */
589 if (nfsaccess_cache_timeout > 0) {
590 wmode = NFSV3ACCESS_READ | NFSV3ACCESS_MODIFY |
591 NFSV3ACCESS_EXTEND | NFSV3ACCESS_EXECUTE |
592 NFSV3ACCESS_DELETE | NFSV3ACCESS_LOOKUP;
593 } else
594 wmode = mode;
595
596 cred = vfs_context_ucred(ap->a_context);
597
598 /*
599 * Does our cached result allow us to give a definite yes to
600 * this request?
601 */
602 dorpc = 1;
603 if (NMODEVALID(np)) {
604 microuptime(&now);
605 if ((now.tv_sec < (np->n_modestamp + nfsaccess_cache_timeout)) &&
606 (kauth_cred_getuid(cred) == np->n_modeuid) &&
607 ((np->n_mode & mode) == mode)) {
608 /* OSAddAtomic(1, (SInt32*)&nfsstats.accesscache_hits); */
609 dorpc = 0;
610 }
611 }
612 if (dorpc) {
613 /* Either a no, or a don't know. Go to the wire. */
614 /* OSAddAtomic(1, (SInt32*)&nfsstats.accesscache_misses); */
615 error = nfs3_access_otw(vp, wmode, vfs_context_proc(ap->a_context), cred);
616 }
617 if (!error) {
618 /*
619 * If we asked for DELETE but didn't get it, the server
620 * may simply not support returning that bit (possible
621 * on UNIX systems). So, we'll assume that it is OK,
622 * and just let any subsequent delete action fail if it
623 * really isn't deletable.
624 */
625 if ((mode & NFSV3ACCESS_DELETE) &&
626 !(np->n_mode & NFSV3ACCESS_DELETE))
627 np->n_mode |= NFSV3ACCESS_DELETE;
628 if ((np->n_mode & mode) != mode)
629 error = EACCES;
630 }
631 } else {
632 /* v2 */
633 if ((ap->a_action & KAUTH_VNODE_WRITE_RIGHTS) && vfs_isrdonly(vnode_mount(vp))) {
634 error = EROFS;
635 } else {
636 error = 0;
637 }
638 }
639
640 return (error);
641 }
642
643 /*
644 * nfs open vnode op
645 * Check to see if the type is ok
646 * and that deletion is not in progress.
647 * For paged in text files, you will need to flush the page cache
648 * if consistency is lost.
649 */
650 /* ARGSUSED */
651
652 static int
653 nfs_open(ap)
654 struct vnop_open_args /* {
655 struct vnodeop_desc *a_desc;
656 vnode_t a_vp;
657 int a_mode;
658 vfs_context_t a_context;
659 } */ *ap;
660 {
661 vnode_t vp = ap->a_vp;
662 struct nfsnode *np = VTONFS(vp);
663 struct nfs_vattr nvattr;
664 kauth_cred_t cred;
665 proc_t p;
666 enum vtype vtype;
667 int error;
668
669 vtype = vnode_vtype(vp);
670 if (vtype != VREG && vtype != VDIR && vtype != VLNK) {
671 return (EACCES);
672 }
673
674 cred = vfs_context_ucred(ap->a_context);
675 p = vfs_context_proc(ap->a_context);
676
677 if (np->n_flag & NNEEDINVALIDATE) {
678 np->n_flag &= ~NNEEDINVALIDATE;
679 nfs_vinvalbuf(vp, V_SAVE|V_IGNORE_WRITEERR, cred, p, 1);
680 }
681 if (np->n_flag & NMODIFIED) {
682 if ((error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1)) == EINTR)
683 return (error);
684 NATTRINVALIDATE(np);
685 if (vtype == VDIR)
686 np->n_direofoffset = 0;
687 error = nfs_getattr(vp, &nvattr, cred, p);
688 if (error)
689 return (error);
690 if (vtype == VDIR) {
691 /* if directory changed, purge any name cache entries */
692 if (nfstimespeccmp(&np->n_ncmtime, &nvattr.nva_mtime, !=))
693 cache_purge(vp);
694 np->n_ncmtime = nvattr.nva_mtime;
695 }
696 np->n_mtime = nvattr.nva_mtime;
697 } else {
698 error = nfs_getattr(vp, &nvattr, cred, p);
699 if (error)
700 return (error);
701 if (nfstimespeccmp(&np->n_mtime, &nvattr.nva_mtime, !=)) {
702 if (vtype == VDIR) {
703 np->n_direofoffset = 0;
704 nfs_invaldir(vp);
705 /* purge name cache entries */
706 if (nfstimespeccmp(&np->n_ncmtime, &nvattr.nva_mtime, !=))
707 cache_purge(vp);
708 }
709 if ((error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1)) == EINTR)
710 return (error);
711 if (vtype == VDIR)
712 np->n_ncmtime = nvattr.nva_mtime;
713 np->n_mtime = nvattr.nva_mtime;
714 }
715 }
716 NATTRINVALIDATE(np); /* For Open/Close consistency */
717 return (0);
718 }
719
720 /*
721 * nfs close vnode op
722 * What an NFS client should do upon close after writing is a debatable issue.
723 * Most NFS clients push delayed writes to the server upon close, basically for
724 * two reasons:
725 * 1 - So that any write errors may be reported back to the client process
726 * doing the close system call. By far the two most likely errors are
727 * NFSERR_NOSPC and NFSERR_DQUOT to indicate space allocation failure.
728 * 2 - To put a worst case upper bound on cache inconsistency between
729 * multiple clients for the file.
730 * There is also a consistency problem for Version 2 of the protocol w.r.t.
731 * not being able to tell if other clients are writing a file concurrently,
732 * since there is no way of knowing if the changed modify time in the reply
733 * is only due to the write for this client.
734 * (NFS Version 3 provides weak cache consistency data in the reply that
735 * should be sufficient to detect and handle this case.)
736 *
737 * The current code does the following:
738 * for NFS Version 2 - play it safe and flush/invalidate all dirty buffers
739 * for NFS Version 3 - flush dirty buffers to the server but don't invalidate
740 * them.
741 */
742 /* ARGSUSED */
743 static int
744 nfs_close(ap)
745 struct vnop_close_args /* {
746 struct vnodeop_desc *a_desc;
747 vnode_t a_vp;
748 int a_fflag;
749 vfs_context_t a_context;
750 } */ *ap;
751 {
752 vnode_t vp = ap->a_vp;
753 struct nfsnode *np = VTONFS(vp);
754 struct nfsmount *nmp;
755 kauth_cred_t cred;
756 proc_t p;
757 int error = 0;
758
759 cred = vfs_context_ucred(ap->a_context);
760 p = vfs_context_proc(ap->a_context);
761
762 if (vnode_vtype(vp) == VREG) {
763 #if DIAGNOSTIC
764 register struct sillyrename *sp = np->n_sillyrename;
765 if (sp)
766 kprintf("nfs_close: %s, dvp=%x, vp=%x, ap=%x, np=%x, sp=%x\n",
767 &sp->s_name[0], (unsigned)(sp->s_dvp), (unsigned)vp,
768 (unsigned)ap, (unsigned)np, (unsigned)sp);
769 #endif
770 nmp = VFSTONFS(vnode_mount(vp));
771 if (!nmp)
772 return (ENXIO);
773 if (np->n_flag & NNEEDINVALIDATE) {
774 np->n_flag &= ~NNEEDINVALIDATE;
775 nfs_vinvalbuf(vp, V_SAVE|V_IGNORE_WRITEERR, cred, p, 1);
776 }
777 if (np->n_flag & NMODIFIED) {
778 if (NFS_ISV3(vp)) {
779 error = nfs_flush(vp, MNT_WAIT, cred, p, 0);
780 /*
781 * We cannot clear the NMODIFIED bit in np->n_flag due to
782 * potential races with other processes
783 * NMODIFIED is a hint
784 */
785 /* np->n_flag &= ~NMODIFIED; */
786 } else {
787 error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
788 }
789 NATTRINVALIDATE(np);
790 }
791 if (np->n_flag & NWRITEERR) {
792 np->n_flag &= ~NWRITEERR;
793 error = np->n_error;
794 }
795 }
796 return (error);
797 }
798
799
800 int
801 nfs_getattr_no_vnode(
802 mount_t mp,
803 u_char *fhp,
804 int fhsize,
805 kauth_cred_t cred,
806 proc_t p,
807 struct nfs_vattr *nvap,
808 u_int64_t *xidp)
809 {
810 mbuf_t mreq, mrep, md, mb, mb2;
811 caddr_t bpos, dpos;
812 int t2;
813 u_long *tl;
814 caddr_t cp;
815 struct nfsmount *nmp = VFSTONFS(mp);
816 int v3 = (nmp->nm_flag & NFSMNT_NFSV3);
817 int hsiz;
818 int error = 0;
819
820 // XXX fix this to use macros once the macros get cleaned up
821 //nfsm_reqhead(NFSX_FH(v3));
822 hsiz = NFSX_FH(v3);
823 mb = NULL;
824 if (hsiz >= nfs_mbuf_minclsize)
825 error = mbuf_mclget(MBUF_WAITOK, MBUF_TYPE_DATA, &mb);
826 else
827 error = mbuf_get(MBUF_WAITOK, MBUF_TYPE_DATA, &mb);
828 if (error)
829 return (error);
830 bpos = mbuf_data(mb);
831 mreq = mb;
832 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_GETATTR]);
833 //nfsm_fhtom(vp, v3);
834 if (v3) {
835 t2 = nfsm_rndup(fhsize) + NFSX_UNSIGNED;
836 if (t2 <= mbuf_trailingspace(mb)) {
837 nfsm_build(tl, u_long *, t2);
838 *tl++ = txdr_unsigned(fhsize);
839 *(tl + ((t2>>2) - 2)) = 0;
840 bcopy((caddr_t)fhp,(caddr_t)tl, fhsize);
841 } else if ((t2 = nfsm_strtmbuf(&mb, &bpos, (caddr_t)fhp, fhsize))) {
842 error = t2;
843 mbuf_freem(mreq);
844 goto nfsmout;
845 }
846 } else {
847 nfsm_build(cp, caddr_t, NFSX_V2FH);
848 bcopy((caddr_t)fhp, cp, NFSX_V2FH);
849 }
850 //nfsm_request(vp, NFSPROC_GETATTR, p, cred, xidp);
851 if ((error = nfs_request(NULL, mp, mreq, NFSPROC_GETATTR, p, cred, &mrep, &md, &dpos, xidp))) {
852 if (error & NFSERR_RETERR)
853 error &= ~NFSERR_RETERR;
854 else
855 goto nfsmout;
856 }
857 if (!error) {
858 //nfsm_loadattr(vp, nvap, xidp);
859 error = nfs_parsefattr(&md, &dpos, v3, nvap);
860 if (error) {
861 mbuf_freem(mrep);
862 goto nfsmout;
863 }
864 }
865 nfsm_reqdone;
866 return (error);
867 }
868
869 /*
870 * nfs getattr call from vfs.
871 */
872 int
873 nfs_getattr(
874 vnode_t vp,
875 struct nfs_vattr *nvap,
876 kauth_cred_t cred,
877 proc_t p)
878 {
879 struct nfsnode *np = VTONFS(vp);
880 caddr_t cp;
881 u_long *tl;
882 int t1, t2;
883 caddr_t bpos, dpos;
884 int error = 0;
885 mbuf_t mreq, mrep, md, mb, mb2;
886 int v3;
887 u_int64_t xid;
888 int avoidfloods;
889
890 FSDBG_TOP(513, np->n_size, np, np->n_vattr.nva_size, np->n_flag);
891
892 /*
893 * Update local times for special files.
894 */
895 if (np->n_flag & (NACC | NUPD))
896 np->n_flag |= NCHG;
897 /*
898 * First look in the cache.
899 */
900 if ((error = nfs_getattrcache(vp, nvap)) == 0) {
901 FSDBG_BOT(513, np->n_size, 0, np->n_vattr.nva_size, np->n_flag);
902 return (0);
903 }
904 if (error != ENOENT) {
905 FSDBG_BOT(513, np->n_size, error, np->n_vattr.nva_size,
906 np->n_flag);
907 return (error);
908 }
909
910 if (!VFSTONFS(vnode_mount(vp))) {
911 FSDBG_BOT(513, np->n_size, ENXIO, np->n_vattr.nva_size, np->n_flag);
912 return (ENXIO);
913 }
914 v3 = NFS_ISV3(vp);
915 error = 0;
916
917 /*
918 * Try to get both the attributes and access info by making an
919 * ACCESS call and seeing if it returns updated attributes.
920 * But don't bother if we aren't caching access info or if the
921 * attributes returned wouldn't be cached.
922 */
923 if (v3 && (nfsaccess_cache_timeout > 0) &&
924 (nfs_attrcachetimeout(vp) > 0)) {
925 /* OSAddAtomic(1, (SInt32*)&nfsstats.accesscache_misses); */
926 if ((error = nfs3_access_otw(vp, NFSV3ACCESS_ALL, p, cred)))
927 return (error);
928 if ((error = nfs_getattrcache(vp, nvap)) == 0)
929 return (0);
930 if (error != ENOENT)
931 return (error);
932 error = 0;
933 }
934 avoidfloods = 0;
935 tryagain:
936 nfsm_reqhead(NFSX_FH(v3));
937 if (error) {
938 FSDBG_BOT(513, np->n_size, error, np->n_vattr.nva_size, np->n_flag);
939 return (error);
940 }
941 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_GETATTR]);
942 nfsm_fhtom(vp, v3);
943 nfsm_request(vp, NFSPROC_GETATTR, p, cred, &xid);
944 if (!error) {
945 nfsm_loadattr(vp, v3, nvap, &xid);
946 if (!xid) { /* out-of-order rpc - attributes were dropped */
947 mbuf_freem(mrep);
948 mrep = NULL;
949 FSDBG(513, -1, np, np->n_xid << 32, np->n_xid);
950 if (avoidfloods++ < 100)
951 goto tryagain;
952 /*
953 * avoidfloods>1 is bizarre. at 100 pull the plug
954 */
955 panic("nfs_getattr: getattr flood\n");
956 }
957 if (nfstimespeccmp(&np->n_mtime, &nvap->nva_mtime, !=)) {
958 enum vtype vtype = vnode_vtype(vp);
959 FSDBG(513, -1, np, -1, vp);
960 if (vtype == VDIR) {
961 nfs_invaldir(vp);
962 /* purge name cache entries */
963 if (nfstimespeccmp(&np->n_ncmtime, &nvap->nva_mtime, !=))
964 cache_purge(vp);
965 }
966 error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
967 FSDBG(513, -1, np, -2, error);
968 if (!error) {
969 if (vtype == VDIR)
970 np->n_ncmtime = nvap->nva_mtime;
971 np->n_mtime = nvap->nva_mtime;
972 }
973 }
974 }
975 nfsm_reqdone;
976
977 FSDBG_BOT(513, np->n_size, -1, np->n_vattr.nva_size, error);
978 return (error);
979 }
980
981
982 static int
983 nfs_vnop_getattr(
984 struct vnop_getattr_args /* {
985 struct vnodeop_desc *a_desc;
986 vnode_t a_vp;
987 struct vnode_attr *a_vap;
988 vfs_context_t a_context;
989 } */ *ap)
990 {
991 int error;
992 struct nfs_vattr nva;
993 struct vnode_attr *vap = ap->a_vap;
994
995 error = nfs_getattr(ap->a_vp, &nva,
996 vfs_context_ucred(ap->a_context),
997 vfs_context_proc(ap->a_context));
998 if (error)
999 return (error);
1000
1001 /* copy nva to *a_vap */
1002 VATTR_RETURN(vap, va_type, nva.nva_type);
1003 VATTR_RETURN(vap, va_mode, nva.nva_mode);
1004 VATTR_RETURN(vap, va_rdev, nva.nva_rdev);
1005 VATTR_RETURN(vap, va_uid, nva.nva_uid);
1006 VATTR_RETURN(vap, va_gid, nva.nva_gid);
1007 VATTR_RETURN(vap, va_nlink, nva.nva_nlink);
1008 VATTR_RETURN(vap, va_fileid, nva.nva_fileid);
1009 VATTR_RETURN(vap, va_data_size, nva.nva_size);
1010 VATTR_RETURN(vap, va_data_alloc, nva.nva_bytes);
1011 VATTR_RETURN(vap, va_iosize, nva.nva_blocksize); /* should this just be f_iosize? */
1012 VATTR_RETURN(vap, va_fsid, nva.nva_fsid);
1013 vap->va_access_time.tv_sec = nva.nva_atime.tv_sec;
1014 vap->va_access_time.tv_nsec = nva.nva_atime.tv_nsec;
1015 VATTR_SET_SUPPORTED(vap, va_access_time);
1016 vap->va_modify_time.tv_sec = nva.nva_mtime.tv_sec;
1017 vap->va_modify_time.tv_nsec = nva.nva_mtime.tv_nsec;
1018 VATTR_SET_SUPPORTED(vap, va_modify_time);
1019 vap->va_change_time.tv_sec = nva.nva_ctime.tv_sec;
1020 vap->va_change_time.tv_nsec = nva.nva_ctime.tv_nsec;
1021 VATTR_SET_SUPPORTED(vap, va_change_time);
1022
1023 return (error);
1024 }
1025
1026 /*
1027 * nfs setattr call.
1028 */
1029 static int
1030 nfs_setattr(ap)
1031 struct vnop_setattr_args /* {
1032 struct vnodeop_desc *a_desc;
1033 vnode_t a_vp;
1034 struct vnode_attr *a_vap;
1035 vfs_context_t a_context;
1036 } */ *ap;
1037 {
1038 vnode_t vp = ap->a_vp;
1039 struct nfsnode *np = VTONFS(vp);
1040 struct vnode_attr *vap = ap->a_vap;
1041 int error = 0;
1042 u_quad_t tsize;
1043 kauth_cred_t cred;
1044 proc_t p;
1045
1046 #ifndef nolint
1047 tsize = (u_quad_t)0;
1048 #endif
1049
1050 /* Setting of flags is not supported. */
1051 if (VATTR_IS_ACTIVE(vap, va_flags))
1052 return (ENOTSUP);
1053
1054 cred = vfs_context_ucred(ap->a_context);
1055 p = vfs_context_proc(ap->a_context);
1056
1057 VATTR_SET_SUPPORTED(vap, va_mode);
1058 VATTR_SET_SUPPORTED(vap, va_uid);
1059 VATTR_SET_SUPPORTED(vap, va_gid);
1060 VATTR_SET_SUPPORTED(vap, va_data_size);
1061 VATTR_SET_SUPPORTED(vap, va_access_time);
1062 VATTR_SET_SUPPORTED(vap, va_modify_time);
1063
1064 /* Disallow write attempts if the filesystem is mounted read-only. */
1065 if ((VATTR_IS_ACTIVE(vap, va_flags) || VATTR_IS_ACTIVE(vap, va_mode) ||
1066 VATTR_IS_ACTIVE(vap, va_uid) || VATTR_IS_ACTIVE(vap, va_gid) ||
1067 VATTR_IS_ACTIVE(vap, va_access_time) ||
1068 VATTR_IS_ACTIVE(vap, va_modify_time)) &&
1069 vnode_vfsisrdonly(vp))
1070 return (EROFS);
1071
1072 if (VATTR_IS_ACTIVE(vap, va_data_size)) {
1073 switch (vnode_vtype(vp)) {
1074 case VDIR:
1075 return (EISDIR);
1076 case VCHR:
1077 case VBLK:
1078 case VSOCK:
1079 case VFIFO:
1080 if (!VATTR_IS_ACTIVE(vap, va_modify_time) &&
1081 !VATTR_IS_ACTIVE(vap, va_access_time) &&
1082 !VATTR_IS_ACTIVE(vap, va_mode) &&
1083 !VATTR_IS_ACTIVE(vap, va_uid) &&
1084 !VATTR_IS_ACTIVE(vap, va_gid))
1085 return (0);
1086 VATTR_CLEAR_ACTIVE(vap, va_data_size);
1087 break;
1088 default:
1089 /*
1090 * Disallow write attempts if the filesystem is
1091 * mounted read-only.
1092 */
1093 if (vnode_vfsisrdonly(vp))
1094 return (EROFS);
1095 FSDBG_TOP(512, np->n_size, vap->va_data_size,
1096 np->n_vattr.nva_size, np->n_flag);
1097 if (np->n_flag & NMODIFIED) {
1098 if (vap->va_data_size == 0)
1099 error = nfs_vinvalbuf(vp, 0, cred, p, 1);
1100 else
1101 error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
1102 if (error) {
1103 printf("nfs_setattr: nfs_vinvalbuf %d\n", error);
1104 FSDBG_BOT(512, np->n_size, vap->va_data_size,
1105 np->n_vattr.nva_size, -1);
1106 return (error);
1107 }
1108 } else if (np->n_size > vap->va_data_size) { /* shrinking? */
1109 daddr64_t obn, bn;
1110 int biosize, neweofoff, mustwrite;
1111 struct nfsbuf *bp;
1112
1113 biosize = vfs_statfs(vnode_mount(vp))->f_iosize;
1114 obn = (np->n_size - 1) / biosize;
1115 bn = vap->va_data_size / biosize;
1116 for ( ; obn >= bn; obn--) {
1117 if (!nfs_buf_is_incore(vp, obn))
1118 continue;
1119 error = nfs_buf_get(vp, obn, biosize, 0, NBLK_READ, &bp);
1120 if (error)
1121 continue;
1122 if (obn != bn) {
1123 FSDBG(512, bp, bp->nb_flags, 0, obn);
1124 SET(bp->nb_flags, NB_INVAL);
1125 nfs_buf_release(bp, 1);
1126 continue;
1127 }
1128 mustwrite = 0;
1129 neweofoff = vap->va_data_size - NBOFF(bp);
1130 /* check for any dirty data before the new EOF */
1131 if (bp->nb_dirtyend && bp->nb_dirtyoff < neweofoff) {
1132 /* clip dirty range to EOF */
1133 if (bp->nb_dirtyend > neweofoff)
1134 bp->nb_dirtyend = neweofoff;
1135 mustwrite++;
1136 }
1137 bp->nb_dirty &= (1 << round_page_32(neweofoff)/PAGE_SIZE) - 1;
1138 if (bp->nb_dirty)
1139 mustwrite++;
1140 if (!mustwrite) {
1141 FSDBG(512, bp, bp->nb_flags, 0, obn);
1142 SET(bp->nb_flags, NB_INVAL);
1143 nfs_buf_release(bp, 1);
1144 continue;
1145 }
1146 /* gotta write out dirty data before invalidating */
1147 /* (NB_STABLE indicates that data writes should be FILESYNC) */
1148 /* (NB_NOCACHE indicates buffer should be discarded) */
1149 CLR(bp->nb_flags, (NB_DONE | NB_ERROR | NB_INVAL | NB_ASYNC | NB_READ));
1150 SET(bp->nb_flags, NB_STABLE | NB_NOCACHE);
1151 if (bp->nb_wcred == NOCRED) {
1152 kauth_cred_ref(cred);
1153 bp->nb_wcred = cred;
1154 }
1155 error = nfs_buf_write(bp);
1156 // Note: bp has been released
1157 if (error) {
1158 FSDBG(512, bp, 0xd00dee, 0xbad, error);
1159 np->n_error = error;
1160 np->n_flag |= NWRITEERR;
1161 /*
1162 * There was a write error and we need to
1163 * invalidate attrs and flush buffers in
1164 * order to sync up with the server.
1165 * (if this write was extending the file,
1166 * we may no longer know the correct size)
1167 */
1168 NATTRINVALIDATE(np);
1169 nfs_vinvalbuf(vp, V_SAVE|V_IGNORE_WRITEERR, cred, p, 1);
1170 error = 0;
1171 }
1172 }
1173 }
1174 tsize = np->n_size;
1175 np->n_size = np->n_vattr.nva_size = vap->va_data_size;
1176 ubc_setsize(vp, (off_t)vap->va_data_size); /* XXX error? */
1177 }
1178 } else if ((VATTR_IS_ACTIVE(vap, va_modify_time) ||
1179 VATTR_IS_ACTIVE(vap, va_access_time)) &&
1180 (np->n_flag & NMODIFIED) && (vnode_vtype(vp) == VREG)) {
1181 error = nfs_vinvalbuf(vp, V_SAVE, cred, p, 1);
1182 if (error == EINTR)
1183 return (error);
1184 }
1185 if (VATTR_IS_ACTIVE(vap, va_mode)) {
1186 NMODEINVALIDATE(np);
1187 }
1188 error = nfs_setattrrpc(vp, vap, cred, p);
1189 FSDBG_BOT(512, np->n_size, vap->va_data_size, np->n_vattr.nva_size, error);
1190 if (error && VATTR_IS_ACTIVE(vap, va_data_size)) {
1191 /* make every effort to resync file size w/ server... */
1192 int err; /* preserve "error" for return */
1193
1194 np->n_size = np->n_vattr.nva_size = tsize;
1195 ubc_setsize(vp, (off_t)np->n_size); /* XXX check error */
1196 vap->va_data_size = tsize;
1197 err = nfs_setattrrpc(vp, vap, cred, p);
1198 printf("nfs_setattr: nfs_setattrrpc %d %d\n", error, err);
1199 }
1200 return (error);
1201 }
1202
1203 /*
1204 * Do an nfs setattr rpc.
1205 */
1206 static int
1207 nfs_setattrrpc(vp, vap, cred, procp)
1208 vnode_t vp;
1209 struct vnode_attr *vap;
1210 kauth_cred_t cred;
1211 proc_t procp;
1212 {
1213 register struct nfsv2_sattr *sp;
1214 register caddr_t cp;
1215 register long t1, t2;
1216 caddr_t bpos, dpos, cp2;
1217 u_long *tl;
1218 int error = 0, wccpostattr = 0;
1219 mbuf_t mreq, mrep, md, mb, mb2;
1220 int v3;
1221 u_int64_t xid;
1222 struct timeval now;
1223
1224 if (!VFSTONFS(vnode_mount(vp)))
1225 return (ENXIO);
1226 v3 = NFS_ISV3(vp);
1227
1228 nfsm_reqhead(NFSX_FH(v3) + NFSX_SATTR(v3));
1229 if (error)
1230 return (error);
1231 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_SETATTR]);
1232 nfsm_fhtom(vp, v3);
1233 if (v3) {
1234 if (VATTR_IS_ACTIVE(vap, va_mode)) {
1235 nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
1236 *tl++ = nfs_true;
1237 *tl = txdr_unsigned(vap->va_mode);
1238 } else {
1239 nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1240 *tl = nfs_false;
1241 }
1242 if (VATTR_IS_ACTIVE(vap, va_uid)) {
1243 nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
1244 *tl++ = nfs_true;
1245 *tl = txdr_unsigned(vap->va_uid);
1246 } else {
1247 nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1248 *tl = nfs_false;
1249 }
1250 if (VATTR_IS_ACTIVE(vap, va_gid)) {
1251 nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
1252 *tl++ = nfs_true;
1253 *tl = txdr_unsigned(vap->va_gid);
1254 } else {
1255 nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1256 *tl = nfs_false;
1257 }
1258 if (VATTR_IS_ACTIVE(vap, va_data_size)) {
1259 nfsm_build(tl, u_long *, 3 * NFSX_UNSIGNED);
1260 *tl++ = nfs_true;
1261 txdr_hyper(&vap->va_data_size, tl);
1262 } else {
1263 nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1264 *tl = nfs_false;
1265 }
1266 microtime(&now);
1267 if (VATTR_IS_ACTIVE(vap, va_access_time)) {
1268 if (vap->va_access_time.tv_sec != now.tv_sec) {
1269 nfsm_build(tl, u_long *, 3 * NFSX_UNSIGNED);
1270 *tl++ = txdr_unsigned(NFSV3SATTRTIME_TOCLIENT);
1271 txdr_nfsv3time(&vap->va_access_time, tl);
1272 } else {
1273 nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1274 *tl = txdr_unsigned(NFSV3SATTRTIME_TOSERVER);
1275 }
1276 } else {
1277 nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1278 *tl = txdr_unsigned(NFSV3SATTRTIME_DONTCHANGE);
1279 }
1280 if (VATTR_IS_ACTIVE(vap, va_modify_time)) {
1281 if (vap->va_modify_time.tv_sec != now.tv_sec) {
1282 nfsm_build(tl, u_long *, 3 * NFSX_UNSIGNED);
1283 *tl++ = txdr_unsigned(NFSV3SATTRTIME_TOCLIENT);
1284 txdr_nfsv3time(&vap->va_modify_time, tl);
1285 } else {
1286 nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1287 *tl = txdr_unsigned(NFSV3SATTRTIME_TOSERVER);
1288 }
1289 } else {
1290 nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1291 *tl = txdr_unsigned(NFSV3SATTRTIME_DONTCHANGE);
1292 }
1293 nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1294 *tl = nfs_false;
1295 } else {
1296 struct timespec neg1time = { -1, -1 };
1297 nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
1298 if (VATTR_IS_ACTIVE(vap, va_mode))
1299 sp->sa_mode = vtonfsv2_mode(vnode_vtype(vp), vap->va_mode);
1300 else
1301 sp->sa_mode = nfs_xdrneg1;
1302 if (VATTR_IS_ACTIVE(vap, va_uid))
1303 sp->sa_uid = txdr_unsigned(vap->va_uid);
1304 else
1305 sp->sa_uid = nfs_xdrneg1;
1306 if (VATTR_IS_ACTIVE(vap, va_gid))
1307 sp->sa_gid = txdr_unsigned(vap->va_gid);
1308 else
1309 sp->sa_gid = nfs_xdrneg1;
1310 if (VATTR_IS_ACTIVE(vap, va_data_size))
1311 sp->sa_size = txdr_unsigned(vap->va_data_size);
1312 else
1313 sp->sa_size = nfs_xdrneg1;
1314 if (VATTR_IS_ACTIVE(vap, va_access_time)) {
1315 txdr_nfsv2time(&vap->va_access_time, &sp->sa_atime);
1316 } else {
1317 txdr_nfsv2time(&neg1time, &sp->sa_atime);
1318 }
1319 if (VATTR_IS_ACTIVE(vap, va_modify_time)) {
1320 txdr_nfsv2time(&vap->va_modify_time, &sp->sa_mtime);
1321 } else {
1322 txdr_nfsv2time(&neg1time, &sp->sa_mtime);
1323 }
1324 }
1325 nfsm_request(vp, NFSPROC_SETATTR, procp, cred, &xid);
1326 if (v3) {
1327 struct timespec premtime = { 0, 0 };
1328 if (mrep) {
1329 nfsm_wcc_data(vp, &premtime, wccpostattr, &xid);
1330 }
1331 /* if file hadn't changed, update cached mtime */
1332 if (nfstimespeccmp(&VTONFS(vp)->n_mtime, &premtime, ==)) {
1333 VTONFS(vp)->n_mtime = VTONFS(vp)->n_vattr.nva_mtime;
1334 }
1335 /* if directory hadn't changed, update namecache mtime */
1336 if ((vnode_vtype(vp) == VDIR) &&
1337 nfstimespeccmp(&VTONFS(vp)->n_ncmtime, &premtime, ==)) {
1338 VTONFS(vp)->n_ncmtime = VTONFS(vp)->n_vattr.nva_mtime;
1339 }
1340 if (!wccpostattr)
1341 NATTRINVALIDATE(VTONFS(vp));
1342 } else {
1343 if (mrep) {
1344 nfsm_loadattr(vp, v3, NULL, &xid);
1345 }
1346 }
1347 nfsm_reqdone;
1348 return (error);
1349 }
1350
1351 /*
1352 * nfs lookup call, one step at a time...
1353 * First look in cache
1354 * If not found, unlock the directory nfsnode and do the rpc
1355 */
1356 static int
1357 nfs_lookup(ap)
1358 struct vnop_lookup_args /* {
1359 struct vnodeop_desc *a_desc;
1360 vnode_t a_dvp;
1361 vnode_t *a_vpp;
1362 struct componentname *a_cnp;
1363 vfs_context_t a_context;
1364 } */ *ap;
1365 {
1366 struct componentname *cnp = ap->a_cnp;
1367 vnode_t dvp = ap->a_dvp;
1368 vnode_t *vpp = ap->a_vpp;
1369 int flags = cnp->cn_flags;
1370 vnode_t newvp;
1371 u_long *tl;
1372 caddr_t cp;
1373 long t1, t2;
1374 caddr_t bpos, dpos, cp2;
1375 mbuf_t mreq, mrep, md, mb, mb2;
1376 long len;
1377 u_char *fhp;
1378 struct nfsnode *dnp, *np;
1379 int wantparent, error, attrflag, dattrflag, fhsize, fhisdvp;
1380 int v3 = NFS_ISV3(dvp);
1381 u_int64_t xid, dxid;
1382 struct nfs_vattr nvattr;
1383 kauth_cred_t cred;
1384 proc_t p;
1385 int ngflags;
1386
1387 *vpp = NULLVP;
1388
1389 cred = vfs_context_ucred(ap->a_context);
1390 p = vfs_context_proc(ap->a_context);
1391
1392 wantparent = flags & (LOCKPARENT|WANTPARENT);
1393 dnp = VTONFS(dvp);
1394
1395 error = nfs_getattr(dvp, &nvattr, cred, p);
1396 if (error)
1397 goto error_return;
1398 if (nfstimespeccmp(&dnp->n_ncmtime, &nvattr.nva_mtime, !=)) {
1399 /*
1400 * This directory has changed on us.
1401 * Purge any name cache entries.
1402 */
1403 cache_purge(dvp);
1404 dnp->n_ncmtime = nvattr.nva_mtime;
1405 }
1406
1407 error = cache_lookup(dvp, vpp, cnp);
1408 switch (error) {
1409 case ENOENT:
1410 /* negative cache entry same as cache miss */
1411 error = 0;
1412 /* FALLTHROUGH */
1413 case 0:
1414 /* cache miss */
1415 break;
1416 case -1:
1417 /* cache hit, not really an error */
1418 {
1419 struct vnop_access_args naa;
1420
1421 OSAddAtomic(1, (SInt32*)&nfsstats.lookupcache_hits);
1422
1423 /* check for directory access */
1424 naa.a_vp = dvp;
1425 naa.a_action = KAUTH_VNODE_SEARCH;
1426 naa.a_context = ap->a_context;
1427
1428 /* compute actual success/failure based on accessibility */
1429 error = nfs_access(&naa);
1430 }
1431 /* FALLTHROUGH */
1432 default:
1433 /* unexpected error from cache_lookup */
1434 goto error_return;
1435 }
1436
1437 /* check for lookup of "." */
1438 if ((cnp->cn_nameptr[0] == '.') && (cnp->cn_namelen == 1)) {
1439 /* skip lookup, we know who we are */
1440 fhisdvp = 1;
1441 fhp = NULL;
1442 fhsize = 0;
1443 mrep = NULL;
1444 goto found;
1445 }
1446
1447 /* do we know this name is too long? */
1448 if (v3) {
1449 /* For NFSv3: need uniform pathconf info to test pc_namemax */
1450 struct nfsmount *nmp = VFSTONFS(vnode_mount(dvp));
1451 if (!nmp) {
1452 error = ENXIO;
1453 goto error_return;
1454 }
1455 if (((nmp->nm_state & (NFSSTA_GOTFSINFO|NFSSTA_GOTPATHCONF)) ==
1456 (NFSSTA_GOTFSINFO|NFSSTA_GOTPATHCONF)) &&
1457 (nmp->nm_fsinfo.fsproperties & NFSV3FSINFO_HOMOGENEOUS) &&
1458 (cnp->cn_namelen > (long)nmp->nm_fsinfo.namemax)) {
1459 error = ENAMETOOLONG;
1460 goto error_return;
1461 }
1462 } else if (cnp->cn_namelen > NFS_MAXNAMLEN) {
1463 error = ENAMETOOLONG;
1464 goto error_return;
1465 }
1466
1467 error = 0;
1468 newvp = NULLVP;
1469
1470 OSAddAtomic(1, (SInt32*)&nfsstats.lookupcache_misses);
1471 len = cnp->cn_namelen;
1472 nfsm_reqhead(NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len));
1473 if (error)
1474 goto error_return;
1475 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_LOOKUP]);
1476 nfsm_fhtom(dvp, v3);
1477 nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN, v3);
1478 /* nfsm_request for NFSv2 causes you to goto to nfsmout upon errors */
1479 nfsm_request(dvp, NFSPROC_LOOKUP, p, cred, &xid);
1480
1481 if (error) {
1482 if (mrep) {
1483 nfsm_postop_attr_update(dvp, v3, dattrflag, &xid);
1484 mbuf_freem(mrep);
1485 }
1486 goto nfsmout;
1487 }
1488
1489 /* get the filehandle */
1490 nfsm_getfh(fhp, fhsize, v3);
1491 /* is the file handle the same as this directory's file handle? */
1492 fhisdvp = NFS_CMPFH(dnp, fhp, fhsize);
1493
1494 /* get attributes */
1495 if (v3) {
1496 dxid = xid;
1497 nfsm_postop_attr_get(v3, attrflag, &nvattr);
1498 nfsm_postop_attr_update(dvp, v3, dattrflag, &dxid);
1499 if (!attrflag && (!fhisdvp || !dattrflag)) {
1500 /* We need valid attributes in order */
1501 /* to call nfs_nget/vnode_create(). */
1502 error = nfs_getattr_no_vnode(vnode_mount(dvp),
1503 fhp, fhsize, cred, p, &nvattr, &xid);
1504 if (error) {
1505 mbuf_freem(mrep);
1506 goto error_return;
1507 }
1508 }
1509 } else {
1510 nfsm_attr_get(v3, &nvattr);
1511 }
1512
1513 found:
1514
1515 /*
1516 * Handle RENAME case...
1517 */
1518 if (cnp->cn_nameiop == RENAME && wantparent && (flags & ISLASTCN)) {
1519 if (fhisdvp) {
1520 mbuf_freem(mrep);
1521 error = EISDIR;
1522 goto error_return;
1523 }
1524 error = nfs_nget(vnode_mount(dvp), dvp, cnp, fhp, fhsize,
1525 &nvattr, &xid, 0, &np);
1526 if (error) {
1527 mbuf_freem(mrep);
1528 goto error_return;
1529 }
1530 *vpp = NFSTOV(np);
1531 mbuf_freem(mrep);
1532
1533 goto error_return;
1534 }
1535
1536 if ((cnp->cn_flags & MAKEENTRY) &&
1537 (cnp->cn_nameiop != DELETE || !(flags & ISLASTCN)))
1538 ngflags = NG_MAKEENTRY;
1539 else
1540 ngflags = 0;
1541
1542 if (fhisdvp) {
1543 error = vnode_get(dvp);
1544 if (error) {
1545 mbuf_freem(mrep);
1546 goto error_return;
1547 }
1548 newvp = dvp;
1549 /* test fhp to see if we have valid attributes in nvattr */
1550 if (fhp && (dnp->n_xid <= xid)) {
1551 error = nfs_loadattrcache(dnp, &nvattr, &xid, 0);
1552 if (error) {
1553 vnode_put(dvp);
1554 mbuf_freem(mrep);
1555 goto error_return;
1556 }
1557 }
1558 } else {
1559 error = nfs_nget(vnode_mount(dvp), dvp, cnp, fhp, fhsize,
1560 &nvattr, &xid, ngflags, &np);
1561 if (error) {
1562 mbuf_freem(mrep);
1563 goto error_return;
1564 }
1565 newvp = NFSTOV(np);
1566 }
1567 *vpp = newvp;
1568 // if (error == 0 && *vpp != NULL && *vpp != dvp)
1569 // nfs_unlock(VTONFS(*vpp));
1570
1571 nfsm_reqdone;
1572 if (error) {
1573 if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME) &&
1574 (flags & ISLASTCN) && error == ENOENT) {
1575 if (vnode_mount(dvp) && vnode_vfsisrdonly(dvp))
1576 error = EROFS;
1577 else
1578 error = EJUSTRETURN;
1579 }
1580 }
1581 error_return:
1582 if (error && *vpp) {
1583 vnode_put(*vpp);
1584 *vpp = NULLVP;
1585 }
1586 return (error);
1587 }
1588
1589 /*
1590 * nfs read call.
1591 * Just call nfs_bioread() to do the work.
1592 */
1593 static int
1594 nfs_read(ap)
1595 struct vnop_read_args /* {
1596 struct vnodeop_desc *a_desc;
1597 vnode_t a_vp;
1598 struct uio *a_uio;
1599 int a_ioflag;
1600 vfs_context_t a_context;
1601 } */ *ap;
1602 {
1603 if (vnode_vtype(ap->a_vp) != VREG)
1604 return (EPERM);
1605 return (nfs_bioread(ap->a_vp, ap->a_uio, ap->a_ioflag,
1606 vfs_context_ucred(ap->a_context),
1607 vfs_context_proc(ap->a_context)));
1608 }
1609
1610
1611 /*
1612 * nfs readlink call
1613 */
1614 static int
1615 nfs_readlink(ap)
1616 struct vnop_readlink_args /* {
1617 struct vnodeop_desc *a_desc;
1618 vnode_t a_vp;
1619 struct uio *a_uio;
1620 vfs_context_t a_context;
1621 } */ *ap;
1622 {
1623 if (vnode_vtype(ap->a_vp) != VLNK)
1624 return (EPERM);
1625 return (nfs_bioread(ap->a_vp, ap->a_uio, 0,
1626 vfs_context_ucred(ap->a_context),
1627 vfs_context_proc(ap->a_context)));
1628 }
1629
1630 /*
1631 * Do a readlink rpc.
1632 * Called by nfs_doio() from below the buffer cache.
1633 */
1634 int
1635 nfs_readlinkrpc(
1636 vnode_t vp,
1637 struct uio *uiop,
1638 kauth_cred_t cred,
1639 proc_t p)
1640 {
1641 register u_long *tl;
1642 register caddr_t cp;
1643 register long t1, t2;
1644 caddr_t bpos, dpos, cp2;
1645 int error = 0, len, attrflag;
1646 mbuf_t mreq, mrep, md, mb, mb2;
1647 int v3;
1648 u_int64_t xid;
1649
1650 if (!VFSTONFS(vnode_mount(vp)))
1651 return (ENXIO);
1652 v3 = NFS_ISV3(vp);
1653
1654 nfsm_reqhead(NFSX_FH(v3));
1655 if (error)
1656 return (error);
1657 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_READLINK]);
1658 nfsm_fhtom(vp, v3);
1659 nfsm_request(vp, NFSPROC_READLINK, p, cred, &xid);
1660 if (v3 && mrep)
1661 nfsm_postop_attr_update(vp, v3, attrflag, &xid);
1662 if (!error) {
1663 nfsm_strsiz(len, NFS_MAXPATHLEN, v3);
1664 if (len >= NFS_MAXPATHLEN) {
1665 struct nfsnode *np = VTONFS(vp);
1666 #if DIAGNOSTIC
1667 if (!np)
1668 panic("nfs_readlinkrpc: null np");
1669 #endif
1670 if (np->n_size && np->n_size < NFS_MAXPATHLEN)
1671 len = np->n_size;
1672 }
1673 nfsm_mtouio(uiop, len);
1674 }
1675 nfsm_reqdone;
1676 return (error);
1677 }
1678
1679 /*
1680 * nfs read rpc call
1681 * Ditto above
1682 */
1683 int
1684 nfs_readrpc(
1685 vnode_t vp,
1686 struct uio *uiop,
1687 kauth_cred_t cred,
1688 proc_t p)
1689 {
1690 register u_long *tl;
1691 register caddr_t cp;
1692 register long t1, t2;
1693 caddr_t bpos, dpos, cp2;
1694 mbuf_t mreq, mrep, md, mb, mb2;
1695 struct nfsmount *nmp;
1696 int error = 0, len, retlen, tsiz, eof = 0, attrflag;
1697 int v3, nmrsize;
1698 u_int64_t xid;
1699
1700 FSDBG_TOP(536, vp, uiop->uio_offset, uio_uio_resid(uiop), 0);
1701 nmp = VFSTONFS(vnode_mount(vp));
1702 if (!nmp)
1703 return (ENXIO);
1704 v3 = NFS_ISV3(vp);
1705 nmrsize = nmp->nm_rsize;
1706
1707 // LP64todo - fix this
1708 tsiz = uio_uio_resid(uiop);
1709 if (((u_int64_t)uiop->uio_offset + (unsigned int)tsiz > 0xffffffff) && !v3) {
1710 FSDBG_BOT(536, vp, uiop->uio_offset, uio_uio_resid(uiop), EFBIG);
1711 return (EFBIG);
1712 }
1713 while (tsiz > 0) {
1714 len = (tsiz > nmrsize) ? nmrsize : tsiz;
1715 nfsm_reqhead(NFSX_FH(v3) + NFSX_UNSIGNED * 3);
1716 if (error)
1717 break;
1718 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_READ]);
1719 nfsm_fhtom(vp, v3);
1720 nfsm_build(tl, u_long *, NFSX_UNSIGNED * 3);
1721 if (v3) {
1722 txdr_hyper(&uiop->uio_offset, tl);
1723 *(tl + 2) = txdr_unsigned(len);
1724 } else {
1725 *tl++ = txdr_unsigned(uiop->uio_offset);
1726 *tl++ = txdr_unsigned(len);
1727 *tl = 0;
1728 }
1729 FSDBG(536, vp, uiop->uio_offset, len, 0);
1730 nfsm_request(vp, NFSPROC_READ, p, cred, &xid);
1731 if (v3) {
1732 if (mrep) {
1733 nfsm_postop_attr_update(vp, v3, attrflag, &xid);
1734 }
1735 if (error) {
1736 mbuf_freem(mrep);
1737 goto nfsmout;
1738 }
1739 nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
1740 eof = fxdr_unsigned(int, *(tl + 1));
1741 } else {
1742 if (mrep) {
1743 nfsm_loadattr(vp, v3, NULL, &xid);
1744 }
1745 }
1746 if (mrep) {
1747 nfsm_strsiz(retlen, nmrsize, 0);
1748 nfsm_mtouio(uiop, retlen);
1749 mbuf_freem(mrep);
1750 } else {
1751 retlen = 0;
1752 }
1753 tsiz -= retlen;
1754 if (v3) {
1755 if (eof || retlen == 0)
1756 tsiz = 0;
1757 } else if (retlen < len)
1758 tsiz = 0;
1759 }
1760 nfsmout:
1761 FSDBG_BOT(536, vp, eof, uio_uio_resid(uiop), error);
1762 return (error);
1763 }
1764
1765 /*
1766 * nfs write call
1767 */
1768 int
1769 nfs_writerpc(
1770 vnode_t vp,
1771 struct uio *uiop,
1772 kauth_cred_t cred,
1773 proc_t p,
1774 int *iomode,
1775 uint64_t *wverfp)
1776 {
1777 register u_long *tl;
1778 register caddr_t cp;
1779 register int t1, t2, backup;
1780 caddr_t bpos, dpos, cp2;
1781 mbuf_t mreq, mrep, md, mb, mb2;
1782 struct nfsmount *nmp;
1783 int error = 0, len, tsiz, updatemtime = 0, wccpostattr = 0, rlen, commit;
1784 int v3, committed = NFSV3WRITE_FILESYNC;
1785 u_int64_t xid, wverf;
1786 mount_t mp;
1787
1788 #if DIAGNOSTIC
1789 if (uiop->uio_iovcnt != 1)
1790 panic("nfs_writerpc: iovcnt > 1");
1791 #endif
1792 FSDBG_TOP(537, vp, uiop->uio_offset, uio_uio_resid(uiop), *iomode);
1793 nmp = VFSTONFS(vnode_mount(vp));
1794 if (!nmp)
1795 return (ENXIO);
1796 v3 = NFS_ISV3(vp);
1797 // LP64todo - fix this
1798 tsiz = uio_uio_resid(uiop);
1799 if (((u_int64_t)uiop->uio_offset + (unsigned int)tsiz > 0xffffffff) && !v3) {
1800 FSDBG_BOT(537, vp, uiop->uio_offset, uio_uio_resid(uiop), EFBIG);
1801 return (EFBIG);
1802 }
1803 while (tsiz > 0) {
1804 nmp = VFSTONFS(vnode_mount(vp));
1805 if (!nmp) {
1806 error = ENXIO;
1807 break;
1808 }
1809 len = (tsiz > nmp->nm_wsize) ? nmp->nm_wsize : tsiz;
1810 nfsm_reqhead(NFSX_FH(v3) + 5 * NFSX_UNSIGNED + nfsm_rndup(len));
1811 if (error)
1812 break;
1813 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_WRITE]);
1814 nfsm_fhtom(vp, v3);
1815 if (v3) {
1816 nfsm_build(tl, u_long *, 5 * NFSX_UNSIGNED);
1817 txdr_hyper(&uiop->uio_offset, tl);
1818 tl += 2;
1819 *tl++ = txdr_unsigned(len);
1820 *tl++ = txdr_unsigned(*iomode);
1821 } else {
1822 nfsm_build(tl, u_long *, 4 * NFSX_UNSIGNED);
1823 *++tl = txdr_unsigned(uiop->uio_offset);
1824 tl += 2;
1825 }
1826 *tl = txdr_unsigned(len);
1827 FSDBG(537, vp, uiop->uio_offset, len, 0);
1828 nfsm_uiotom(uiop, len);
1829 nfsm_request(vp, NFSPROC_WRITE, p, cred, &xid);
1830 nmp = VFSTONFS(vnode_mount(vp));
1831 if (!nmp)
1832 error = ENXIO;
1833 if (v3) {
1834 if (mrep) {
1835 struct timespec premtime;
1836 nfsm_wcc_data(vp, &premtime, wccpostattr, &xid);
1837 if (nfstimespeccmp(&VTONFS(vp)->n_mtime, &premtime, ==))
1838 updatemtime = 1;
1839 }
1840 if (!error) {
1841 nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED +
1842 NFSX_V3WRITEVERF);
1843 rlen = fxdr_unsigned(int, *tl++);
1844 if (rlen <= 0) {
1845 error = NFSERR_IO;
1846 break;
1847 } else if (rlen < len) {
1848 backup = len - rlen;
1849 uio_iov_base_add(uiop, -backup);
1850 uio_iov_len_add(uiop, backup);
1851 uiop->uio_offset -= backup;
1852 uio_uio_resid_add(uiop, backup);
1853 len = rlen;
1854 }
1855 commit = fxdr_unsigned(int, *tl++);
1856
1857 /*
1858 * Return the lowest committment level
1859 * obtained by any of the RPCs.
1860 */
1861 if (committed == NFSV3WRITE_FILESYNC)
1862 committed = commit;
1863 else if (committed == NFSV3WRITE_DATASYNC &&
1864 commit == NFSV3WRITE_UNSTABLE)
1865 committed = commit;
1866 fxdr_hyper(tl, &wverf);
1867 if (wverfp)
1868 *wverfp = wverf;
1869 if ((nmp->nm_state & NFSSTA_HASWRITEVERF) == 0) {
1870 nmp->nm_verf = wverf;
1871 nmp->nm_state |= NFSSTA_HASWRITEVERF;
1872 } else if (wverf != nmp->nm_verf) {
1873 nmp->nm_verf = wverf;
1874 }
1875 }
1876 } else {
1877 if (mrep) {
1878 nfsm_loadattr(vp, v3, NULL, &xid);
1879 }
1880 }
1881
1882 if (updatemtime)
1883 VTONFS(vp)->n_mtime = VTONFS(vp)->n_vattr.nva_mtime;
1884 mbuf_freem(mrep);
1885 /*
1886 * we seem to have a case where we end up looping on shutdown
1887 * and taking down nfs servers. For V3, error cases, there is
1888 * no way to terminate loop, if the len was 0, meaning,
1889 * nmp->nm_wsize was trashed. FreeBSD has this fix in it.
1890 * Let's try it.
1891 */
1892 if (error)
1893 break;
1894 tsiz -= len;
1895 }
1896 nfsmout:
1897 if ((mp = vnode_mount(vp)) && (vfs_flags(mp) & MNT_ASYNC))
1898 committed = NFSV3WRITE_FILESYNC;
1899 *iomode = committed;
1900 if (error)
1901 uio_uio_resid_set(uiop, tsiz);
1902 FSDBG_BOT(537, vp, committed, uio_uio_resid(uiop), error);
1903 return (error);
1904 }
1905
1906 /*
1907 * nfs mknod rpc
1908 * For NFS v2 this is a kludge. Use a create rpc but with the IFMT bits of the
1909 * mode set to specify the file type and the size field for rdev.
1910 */
1911 static int
1912 nfs_mknodrpc(
1913 vnode_t dvp,
1914 vnode_t *vpp,
1915 struct componentname *cnp,
1916 struct vnode_attr *vap,
1917 kauth_cred_t cred,
1918 proc_t p)
1919 {
1920 register struct nfsv2_sattr *sp;
1921 register u_long *tl;
1922 register caddr_t cp;
1923 register long t1, t2;
1924 vnode_t newvp = (vnode_t)0;
1925 struct nfsnode *np = (struct nfsnode *)0;
1926 struct nfs_vattr nvattr;
1927 char *cp2;
1928 caddr_t bpos, dpos;
1929 int error = 0, wccpostattr = 0, gotvp = 0;
1930 struct timespec premtime = { 0, 0 };
1931 mbuf_t mreq, mrep, md, mb, mb2;
1932 u_long rdev;
1933 u_int64_t xid;
1934 int v3 = NFS_ISV3(dvp);
1935 int gotuid, gotgid;
1936
1937 if (!VATTR_IS_ACTIVE(vap, va_type))
1938 return (EINVAL);
1939 if (vap->va_type == VCHR || vap->va_type == VBLK) {
1940 if (!VATTR_IS_ACTIVE(vap, va_rdev))
1941 return (EINVAL);
1942 rdev = txdr_unsigned(vap->va_rdev);
1943 } else if (vap->va_type == VFIFO || vap->va_type == VSOCK)
1944 rdev = 0xffffffff;
1945 else {
1946 return (ENOTSUP);
1947 }
1948 nfsm_reqhead(NFSX_FH(v3) + 4 * NFSX_UNSIGNED +
1949 nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(v3));
1950 if (error)
1951 return (error);
1952
1953 VATTR_SET_SUPPORTED(vap, va_mode);
1954 VATTR_SET_SUPPORTED(vap, va_uid);
1955 VATTR_SET_SUPPORTED(vap, va_gid);
1956 VATTR_SET_SUPPORTED(vap, va_data_size);
1957 VATTR_SET_SUPPORTED(vap, va_access_time);
1958 VATTR_SET_SUPPORTED(vap, va_modify_time);
1959 gotuid = VATTR_IS_ACTIVE(vap, va_uid);
1960 gotgid = VATTR_IS_ACTIVE(vap, va_gid);
1961
1962 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_MKNOD]);
1963 nfsm_fhtom(dvp, v3);
1964 nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN, v3);
1965 if (v3) {
1966 nfsm_build(tl, u_long *, NFSX_UNSIGNED);
1967 *tl++ = vtonfsv3_type(vap->va_type);
1968 nfsm_v3sattr(vap);
1969 if (vap->va_type == VCHR || vap->va_type == VBLK) {
1970 nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
1971 *tl++ = txdr_unsigned(major(vap->va_rdev));
1972 *tl = txdr_unsigned(minor(vap->va_rdev));
1973 }
1974 } else {
1975 struct timespec neg1time = { -1, -1 };
1976 nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
1977 sp->sa_mode = vtonfsv2_mode(vap->va_type,
1978 (VATTR_IS_ACTIVE(vap, va_mode) ? vap->va_mode : 0600));
1979 sp->sa_uid = gotuid ? (u_long)txdr_unsigned(vap->va_uid) : nfs_xdrneg1;
1980 sp->sa_gid = gotgid ? (u_long)txdr_unsigned(vap->va_gid) : nfs_xdrneg1;
1981 sp->sa_size = rdev;
1982 if (VATTR_IS_ACTIVE(vap, va_access_time)) {
1983 txdr_nfsv2time(&vap->va_access_time, &sp->sa_atime);
1984 } else {
1985 txdr_nfsv2time(&neg1time, &sp->sa_atime);
1986 }
1987 if (VATTR_IS_ACTIVE(vap, va_modify_time)) {
1988 txdr_nfsv2time(&vap->va_modify_time, &sp->sa_mtime);
1989 } else {
1990 txdr_nfsv2time(&neg1time, &sp->sa_mtime);
1991 }
1992 }
1993 nfsm_request(dvp, NFSPROC_MKNOD, p, cred, &xid);
1994 /* XXX no EEXIST kludge here? */
1995 if (!error) {
1996 nfsm_mtofh(dvp, cnp, newvp, v3, &xid, gotvp);
1997 if (!gotvp) {
1998 error = nfs_lookitup(dvp, cnp->cn_nameptr,
1999 cnp->cn_namelen, cred, p, &np);
2000 if (!error)
2001 newvp = NFSTOV(np);
2002 }
2003 }
2004 if (v3 && mrep)
2005 nfsm_wcc_data(dvp, &premtime, wccpostattr, &xid);
2006 if (!error && (gotuid || gotgid) &&
2007 (!newvp || nfs_getattrcache(newvp, &nvattr) ||
2008 (gotuid && (nvattr.nva_uid != vap->va_uid)) ||
2009 (gotgid && (nvattr.nva_gid != vap->va_gid)))) {
2010 /* clear ID bits if server didn't use them (or we can't tell) */
2011 VATTR_CLEAR_SUPPORTED(vap, va_uid);
2012 VATTR_CLEAR_SUPPORTED(vap, va_gid);
2013 }
2014 nfsm_reqdone;
2015 if (error) {
2016 if (newvp)
2017 vnode_put(newvp);
2018 } else {
2019 *vpp = newvp;
2020 }
2021 VTONFS(dvp)->n_flag |= NMODIFIED;
2022 /* if directory hadn't changed, update namecache mtime */
2023 if (nfstimespeccmp(&VTONFS(dvp)->n_ncmtime, &premtime, ==))
2024 VTONFS(dvp)->n_ncmtime = VTONFS(dvp)->n_vattr.nva_mtime;
2025 if (!wccpostattr)
2026 NATTRINVALIDATE(VTONFS(dvp));
2027 return (error);
2028 }
2029
2030 /*
2031 * nfs mknod vop
2032 * just call nfs_mknodrpc() to do the work.
2033 */
2034 /* ARGSUSED */
2035 static int
2036 nfs_mknod(ap)
2037 struct vnop_mknod_args /* {
2038 struct vnodeop_desc *a_desc;
2039 vnode_t a_dvp;
2040 vnode_t *a_vpp;
2041 struct componentname *a_cnp;
2042 struct vnode_attr *a_vap;
2043 vfs_context_t a_context;
2044 } */ *ap;
2045 {
2046 int error;
2047
2048 error = nfs_mknodrpc(ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap,
2049 vfs_context_ucred(ap->a_context),
2050 vfs_context_proc(ap->a_context));
2051
2052 return (error);
2053 }
2054
2055 static u_long create_verf;
2056 /*
2057 * nfs file create call
2058 */
2059 static int
2060 nfs_create(ap)
2061 struct vnop_create_args /* {
2062 struct vnodeop_desc *a_desc;
2063 vnode_t a_dvp;
2064 vnode_t *a_vpp;
2065 struct componentname *a_cnp;
2066 struct vnode_attr *a_vap;
2067 vfs_context_t a_context;
2068 } */ *ap;
2069 {
2070 vnode_t dvp = ap->a_dvp;
2071 struct vnode_attr *vap = ap->a_vap;
2072 struct componentname *cnp = ap->a_cnp;
2073 struct nfs_vattr nvattr;
2074 struct nfsv2_sattr *sp;
2075 u_long *tl;
2076 caddr_t cp;
2077 long t1, t2;
2078 struct nfsnode *np = (struct nfsnode *)0;
2079 vnode_t newvp = (vnode_t)0;
2080 caddr_t bpos, dpos, cp2;
2081 int error = 0, wccpostattr = 0, gotvp = 0, fmode = 0;
2082 struct timespec premtime = { 0, 0 };
2083 mbuf_t mreq, mrep, md, mb, mb2;
2084 int v3 = NFS_ISV3(dvp);
2085 int gotuid, gotgid;
2086 u_int64_t xid;
2087 kauth_cred_t cred;
2088 proc_t p;
2089
2090 cred = vfs_context_ucred(ap->a_context);
2091 p = vfs_context_proc(ap->a_context);
2092
2093 if (!VATTR_IS_ACTIVE(vap, va_type))
2094 return (EINVAL);
2095
2096 /*
2097 * Oops, not for me..
2098 */
2099 if (vap->va_type == VSOCK)
2100 return (nfs_mknodrpc(dvp, ap->a_vpp, cnp, vap, cred, p));
2101
2102 VATTR_SET_SUPPORTED(vap, va_mode);
2103 VATTR_SET_SUPPORTED(vap, va_uid);
2104 VATTR_SET_SUPPORTED(vap, va_gid);
2105 VATTR_SET_SUPPORTED(vap, va_data_size);
2106 VATTR_SET_SUPPORTED(vap, va_access_time);
2107 VATTR_SET_SUPPORTED(vap, va_modify_time);
2108 gotuid = VATTR_IS_ACTIVE(vap, va_uid);
2109 gotgid = VATTR_IS_ACTIVE(vap, va_gid);
2110
2111 if (vap->va_vaflags & VA_EXCLUSIVE)
2112 fmode |= O_EXCL;
2113 again:
2114 nfsm_reqhead(NFSX_FH(v3) + 2 * NFSX_UNSIGNED +
2115 nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(v3));
2116 if (error)
2117 return (error);
2118 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_CREATE]);
2119 nfsm_fhtom(dvp, v3);
2120 nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN, v3);
2121 if (v3) {
2122 nfsm_build(tl, u_long *, NFSX_UNSIGNED);
2123 if (fmode & O_EXCL) {
2124 *tl = txdr_unsigned(NFSV3CREATE_EXCLUSIVE);
2125 nfsm_build(tl, u_long *, NFSX_V3CREATEVERF);
2126 if (!TAILQ_EMPTY(&in_ifaddrhead))
2127 *tl++ = IA_SIN(in_ifaddrhead.tqh_first)->sin_addr.s_addr;
2128 else
2129 *tl++ = create_verf;
2130 *tl = ++create_verf;
2131 } else {
2132 *tl = txdr_unsigned(NFSV3CREATE_UNCHECKED);
2133 nfsm_v3sattr(vap);
2134 }
2135 } else {
2136 struct timespec neg1time = { -1, -1 };
2137 nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
2138 sp->sa_mode = vtonfsv2_mode(vap->va_type,
2139 (VATTR_IS_ACTIVE(vap, va_mode) ? vap->va_mode : 0600));
2140 sp->sa_uid = gotuid ? (u_long)txdr_unsigned(vap->va_uid) : nfs_xdrneg1;
2141 sp->sa_gid = gotgid ? (u_long)txdr_unsigned(vap->va_gid) : nfs_xdrneg1;
2142 sp->sa_size = 0;
2143 if (VATTR_IS_ACTIVE(vap, va_access_time)) {
2144 txdr_nfsv2time(&vap->va_access_time, &sp->sa_atime);
2145 } else {
2146 txdr_nfsv2time(&neg1time, &sp->sa_atime);
2147 }
2148 if (VATTR_IS_ACTIVE(vap, va_modify_time)) {
2149 txdr_nfsv2time(&vap->va_modify_time, &sp->sa_mtime);
2150 } else {
2151 txdr_nfsv2time(&neg1time, &sp->sa_mtime);
2152 }
2153 }
2154 nfsm_request(dvp, NFSPROC_CREATE, p, cred, &xid);
2155 if (!error) {
2156 nfsm_mtofh(dvp, cnp, newvp, v3, &xid, gotvp);
2157 if (!gotvp) {
2158 error = nfs_lookitup(dvp, cnp->cn_nameptr,
2159 cnp->cn_namelen, cred, p, &np);
2160 if (!error)
2161 newvp = NFSTOV(np);
2162 }
2163 }
2164 if (v3 && mrep)
2165 nfsm_wcc_data(dvp, &premtime, wccpostattr, &xid);
2166 nfsm_reqdone;
2167 if (error) {
2168 if (v3 && (fmode & O_EXCL) && error == NFSERR_NOTSUPP) {
2169 fmode &= ~O_EXCL;
2170 goto again;
2171 }
2172 if (newvp)
2173 vnode_put(newvp);
2174 } else if (v3 && (fmode & O_EXCL)) {
2175 error = nfs_setattrrpc(newvp, vap, cred, p);
2176 if (error && (gotuid || gotgid)) {
2177 /* it's possible the server didn't like our attempt to set IDs. */
2178 /* so, let's try it again without those */
2179 VATTR_CLEAR_ACTIVE(vap, va_uid);
2180 VATTR_CLEAR_ACTIVE(vap, va_gid);
2181 error = nfs_setattrrpc(newvp, vap, cred, p);
2182 }
2183 if (error)
2184 vnode_put(newvp);
2185 }
2186 if (!error) {
2187 *ap->a_vpp = newvp;
2188 }
2189 VTONFS(dvp)->n_flag |= NMODIFIED;
2190 /* if directory hadn't changed, update namecache mtime */
2191 if (nfstimespeccmp(&VTONFS(dvp)->n_ncmtime, &premtime, ==))
2192 VTONFS(dvp)->n_ncmtime = VTONFS(dvp)->n_vattr.nva_mtime;
2193 if (!wccpostattr)
2194 NATTRINVALIDATE(VTONFS(dvp));
2195 if (!error && (gotuid || gotgid) &&
2196 (!newvp || nfs_getattrcache(newvp, &nvattr) ||
2197 (gotuid && (nvattr.nva_uid != vap->va_uid)) ||
2198 (gotgid && (nvattr.nva_gid != vap->va_gid)))) {
2199 /* clear ID bits if server didn't use them (or we can't tell) */
2200 VATTR_CLEAR_SUPPORTED(vap, va_uid);
2201 VATTR_CLEAR_SUPPORTED(vap, va_gid);
2202 }
2203 return (error);
2204 }
2205
2206 /*
2207 * nfs file remove call
2208 * To try and make nfs semantics closer to ufs semantics, a file that has
2209 * other processes using the vnode is renamed instead of removed and then
2210 * removed later on the last close.
2211 * - If vnode_isinuse()
2212 * If a rename is not already in the works
2213 * call nfs_sillyrename() to set it up
2214 * else
2215 * do the remove rpc
2216 */
2217 static int
2218 nfs_remove(ap)
2219 struct vnop_remove_args /* {
2220 struct vnodeop_desc *a_desc;
2221 vnode_t a_dvp;
2222 vnode_t a_vp;
2223 struct componentname *a_cnp;
2224 int a_flags;
2225 vfs_context_t a_context;
2226 } */ *ap;
2227 {
2228 vnode_t vp = ap->a_vp;
2229 vnode_t dvp = ap->a_dvp;
2230 struct componentname *cnp = ap->a_cnp;
2231 struct nfsnode *np = VTONFS(vp);
2232 int error = 0, gofree = 0;
2233 struct nfs_vattr nvattr;
2234 kauth_cred_t cred;
2235 proc_t p;
2236
2237 cred = vfs_context_ucred(ap->a_context);
2238 p = vfs_context_proc(ap->a_context);
2239
2240 gofree = vnode_isinuse(vp, 0) ? 0 : 1;
2241 if ((ap->a_flags & VNODE_REMOVE_NODELETEBUSY) && !gofree) {
2242 /* Caller requested Carbon delete semantics, but file is busy */
2243 return (EBUSY);
2244 }
2245 if (gofree || (np->n_sillyrename &&
2246 nfs_getattr(vp, &nvattr, cred, p) == 0 &&
2247 nvattr.nva_nlink > 1)) {
2248 /*
2249 * Purge the name cache so that the chance of a lookup for
2250 * the name succeeding while the remove is in progress is
2251 * minimized.
2252 */
2253 cache_purge(vp);
2254 /*
2255 * throw away biocache buffers, mainly to avoid
2256 * unnecessary delayed writes later.
2257 */
2258 error = nfs_vinvalbuf(vp, 0, cred, p, 1);
2259 np->n_size = 0;
2260 ubc_setsize(vp, (off_t)0); /* XXX check error */
2261 /* Do the rpc */
2262 if (error != EINTR)
2263 error = nfs_removerpc(dvp, cnp->cn_nameptr,
2264 cnp->cn_namelen, cred, p);
2265 /*
2266 * Kludge City: If the first reply to the remove rpc is lost..
2267 * the reply to the retransmitted request will be ENOENT
2268 * since the file was in fact removed
2269 * Therefore, we cheat and return success.
2270 */
2271 if (error == ENOENT)
2272 error = 0;
2273 if (!error) {
2274 /*
2275 * remove nfsnode from hash now so we can't accidentally find it
2276 * again if another object gets created with the same filehandle
2277 * before this vnode gets reclaimed
2278 */
2279 lck_mtx_lock(nfs_node_hash_mutex);
2280 LIST_REMOVE(np, n_hash);
2281 np->n_flag &= ~NHASHED;
2282 lck_mtx_unlock(nfs_node_hash_mutex);
2283 }
2284 if (!error && !np->n_sillyrename) {
2285 /* clear flags now: won't get nfs_inactive for recycled vnode */
2286 /* clear all flags other than these */
2287 np->n_flag &= (NMODIFIED | NFLUSHINPROG | NFLUSHWANT | NHASHED);
2288 vnode_recycle(vp);
2289 }
2290 } else if (!np->n_sillyrename) {
2291 error = nfs_sillyrename(dvp, vp, cnp, cred, p);
2292 }
2293 NATTRINVALIDATE(np);
2294
2295 return (error);
2296 }
2297
2298 /*
2299 * nfs file remove rpc called from nfs_inactive
2300 */
2301 int
2302 nfs_removeit(struct sillyrename *sp)
2303 {
2304 return (nfs_removerpc(sp->s_dvp, sp->s_name, sp->s_namlen, sp->s_cred, NULL));
2305 }
2306
2307 /*
2308 * Nfs remove rpc, called from nfs_remove() and nfs_removeit().
2309 */
2310 static int
2311 nfs_removerpc(dvp, name, namelen, cred, proc)
2312 vnode_t dvp;
2313 char *name;
2314 int namelen;
2315 kauth_cred_t cred;
2316 proc_t proc;
2317 {
2318 register u_long *tl;
2319 register caddr_t cp;
2320 register long t1, t2;
2321 caddr_t bpos, dpos, cp2;
2322 int error = 0, wccpostattr = 0;
2323 struct timespec premtime = { 0, 0 };
2324 mbuf_t mreq, mrep, md, mb, mb2;
2325 int v3;
2326 u_int64_t xid;
2327
2328 if (!VFSTONFS(vnode_mount(dvp)))
2329 return (ENXIO);
2330 v3 = NFS_ISV3(dvp);
2331
2332 nfsm_reqhead(NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(namelen));
2333 if (error)
2334 return (error);
2335 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_REMOVE]);
2336 nfsm_fhtom(dvp, v3);
2337 nfsm_strtom(name, namelen, NFS_MAXNAMLEN, v3);
2338 nfsm_request(dvp, NFSPROC_REMOVE, proc, cred, &xid);
2339 if (v3 && mrep)
2340 nfsm_wcc_data(dvp, &premtime, wccpostattr, &xid);
2341 nfsm_reqdone;
2342 VTONFS(dvp)->n_flag |= NMODIFIED;
2343 /* if directory hadn't changed, update namecache mtime */
2344 if (nfstimespeccmp(&VTONFS(dvp)->n_ncmtime, &premtime, ==))
2345 VTONFS(dvp)->n_ncmtime = VTONFS(dvp)->n_vattr.nva_mtime;
2346 if (!wccpostattr)
2347 NATTRINVALIDATE(VTONFS(dvp));
2348 return (error);
2349 }
2350
2351 /*
2352 * nfs file rename call
2353 */
2354 static int
2355 nfs_rename(ap)
2356 struct vnop_rename_args /* {
2357 struct vnodeop_desc *a_desc;
2358 vnode_t a_fdvp;
2359 vnode_t a_fvp;
2360 struct componentname *a_fcnp;
2361 vnode_t a_tdvp;
2362 vnode_t a_tvp;
2363 struct componentname *a_tcnp;
2364 vfs_context_t a_context;
2365 } */ *ap;
2366 {
2367 vnode_t fvp = ap->a_fvp;
2368 vnode_t tvp = ap->a_tvp;
2369 vnode_t fdvp = ap->a_fdvp;
2370 vnode_t tdvp = ap->a_tdvp;
2371 struct componentname *tcnp = ap->a_tcnp;
2372 struct componentname *fcnp = ap->a_fcnp;
2373 int error, inuse=0;
2374 mount_t fmp, tdmp, tmp;
2375 struct nfsnode *tnp;
2376 kauth_cred_t cred;
2377 proc_t p;
2378
2379 cred = vfs_context_ucred(ap->a_context);
2380 p = vfs_context_proc(ap->a_context);
2381
2382 tnp = tvp ? VTONFS(tvp) : NULL;
2383
2384 /* Check for cross-device rename */
2385 fmp = vnode_mount(fvp);
2386 tmp = tvp ? vnode_mount(tvp) : NULL;
2387 tdmp = vnode_mount(tdvp);
2388 if ((fmp != tdmp) || (tvp && (fmp != tmp))) {
2389 error = EXDEV;
2390 goto out;
2391 }
2392
2393 /*
2394 * If the tvp exists and is in use, sillyrename it before doing the
2395 * rename of the new file over it.
2396 * XXX Can't sillyrename a directory.
2397 * Don't sillyrename if source and target are same vnode (hard
2398 * links or case-variants)
2399 */
2400 if (tvp && tvp != fvp) {
2401 inuse = vnode_isinuse(tvp, 0);
2402 }
2403 if (inuse && !tnp->n_sillyrename && vnode_vtype(tvp) != VDIR) {
2404 if ((error = nfs_sillyrename(tdvp, tvp, tcnp, cred, p))) {
2405 /* sillyrename failed. Instead of pressing on, return error */
2406 goto out; /* should not be ENOENT. */
2407 } else {
2408 /* sillyrename succeeded.*/
2409 tvp = NULL;
2410 }
2411 }
2412
2413 error = nfs_renamerpc(fdvp, fcnp->cn_nameptr, fcnp->cn_namelen,
2414 tdvp, tcnp->cn_nameptr, tcnp->cn_namelen, cred, p);
2415
2416 /*
2417 * Kludge: Map ENOENT => 0 assuming that it is a reply to a retry.
2418 */
2419 if (error == ENOENT)
2420 error = 0;
2421
2422 if (!error && tvp && tvp != fvp && !tnp->n_sillyrename) {
2423 /*
2424 * remove nfsnode from hash now so we can't accidentally find it
2425 * again if another object gets created with the same filehandle
2426 * before this vnode gets reclaimed
2427 */
2428 lck_mtx_lock(nfs_node_hash_mutex);
2429 LIST_REMOVE(tnp, n_hash);
2430 tnp->n_flag &= ~NHASHED;
2431 lck_mtx_unlock(nfs_node_hash_mutex);
2432 }
2433
2434 /* purge the old name cache entries and enter the new one */
2435 cache_purge(fvp);
2436 if (tvp) {
2437 cache_purge(tvp);
2438 if (!error && !tnp->n_sillyrename) {
2439 /* clear flags now: won't get nfs_inactive for recycled vnode */
2440 /* clear all flags other than these */
2441 tnp->n_flag &= (NMODIFIED | NFLUSHINPROG | NFLUSHWANT | NHASHED);
2442 vnode_recycle(tvp);
2443 }
2444 }
2445 if (!error)
2446 cache_enter(tdvp, fvp, tcnp);
2447
2448 out:
2449 /*
2450 * Kludge: Map ENOENT => 0 assuming that it is a reply to a retry.
2451 */
2452 if (error == ENOENT)
2453 error = 0;
2454 return (error);
2455 }
2456
2457 /*
2458 * Do an nfs rename rpc. Called from nfs_rename() and nfs_sillyrename().
2459 */
2460 static int
2461 nfs_renamerpc(fdvp, fnameptr, fnamelen, tdvp, tnameptr, tnamelen, cred, proc)
2462 vnode_t fdvp;
2463 char *fnameptr;
2464 int fnamelen;
2465 vnode_t tdvp;
2466 char *tnameptr;
2467 int tnamelen;
2468 kauth_cred_t cred;
2469 proc_t proc;
2470 {
2471 register u_long *tl;
2472 register caddr_t cp;
2473 register long t1, t2;
2474 caddr_t bpos, dpos, cp2;
2475 int error = 0, fwccpostattr = 0, twccpostattr = 0;
2476 struct timespec fpremtime = { 0, 0 }, tpremtime = { 0, 0 };
2477 mbuf_t mreq, mrep, md, mb, mb2;
2478 int v3;
2479 u_int64_t xid;
2480
2481 if (!VFSTONFS(vnode_mount(fdvp)))
2482 return (ENXIO);
2483 v3 = NFS_ISV3(fdvp);
2484
2485 nfsm_reqhead((NFSX_FH(v3) + NFSX_UNSIGNED)*2 + nfsm_rndup(fnamelen) +
2486 nfsm_rndup(tnamelen));
2487 if (error)
2488 return (error);
2489 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_RENAME]);
2490 nfsm_fhtom(fdvp, v3);
2491 nfsm_strtom(fnameptr, fnamelen, NFS_MAXNAMLEN, v3);
2492 nfsm_fhtom(tdvp, v3);
2493 nfsm_strtom(tnameptr, tnamelen, NFS_MAXNAMLEN, v3);
2494 nfsm_request(fdvp, NFSPROC_RENAME, proc, cred, &xid);
2495 if (v3 && mrep) {
2496 u_int64_t txid = xid;
2497
2498 nfsm_wcc_data(fdvp, &fpremtime, fwccpostattr, &xid);
2499 nfsm_wcc_data(tdvp, &tpremtime, twccpostattr, &txid);
2500 }
2501 nfsm_reqdone;
2502 VTONFS(fdvp)->n_flag |= NMODIFIED;
2503 /* if directory hadn't changed, update namecache mtime */
2504 if (nfstimespeccmp(&VTONFS(fdvp)->n_ncmtime, &fpremtime, ==))
2505 VTONFS(fdvp)->n_ncmtime = VTONFS(fdvp)->n_vattr.nva_mtime;
2506 if (!fwccpostattr)
2507 NATTRINVALIDATE(VTONFS(fdvp));
2508 VTONFS(tdvp)->n_flag |= NMODIFIED;
2509 /* if directory hadn't changed, update namecache mtime */
2510 if (nfstimespeccmp(&VTONFS(tdvp)->n_ncmtime, &tpremtime, ==))
2511 VTONFS(tdvp)->n_ncmtime = VTONFS(tdvp)->n_vattr.nva_mtime;
2512 if (!twccpostattr)
2513 NATTRINVALIDATE(VTONFS(tdvp));
2514 return (error);
2515 }
2516
2517 /*
2518 * nfs hard link create call
2519 */
2520 static int
2521 nfs_link(ap)
2522 struct vnop_link_args /* {
2523 struct vnodeop_desc *a_desc;
2524 vnode_t a_vp;
2525 vnode_t a_tdvp;
2526 struct componentname *a_cnp;
2527 vfs_context_t a_context;
2528 } */ *ap;
2529 {
2530 vnode_t vp = ap->a_vp;
2531 vnode_t tdvp = ap->a_tdvp;
2532 struct componentname *cnp = ap->a_cnp;
2533 u_long *tl;
2534 caddr_t cp;
2535 long t1, t2;
2536 caddr_t bpos, dpos, cp2;
2537 int error = 0, wccpostattr = 0, attrflag = 0;
2538 struct timespec premtime = { 0, 0 };
2539 mbuf_t mreq, mrep, md, mb, mb2;
2540 int v3;
2541 u_int64_t xid;
2542 kauth_cred_t cred;
2543 proc_t p;
2544
2545 if (vnode_mount(vp) != vnode_mount(tdvp)) {
2546 return (EXDEV);
2547 }
2548
2549 cred = vfs_context_ucred(ap->a_context);
2550 p = vfs_context_proc(ap->a_context);
2551
2552 v3 = NFS_ISV3(vp);
2553
2554 /*
2555 * Push all writes to the server, so that the attribute cache
2556 * doesn't get "out of sync" with the server.
2557 * XXX There should be a better way!
2558 */
2559 nfs_flush(vp, MNT_WAIT, cred, p, 0);
2560
2561 nfsm_reqhead(NFSX_FH(v3)*2 + NFSX_UNSIGNED + nfsm_rndup(cnp->cn_namelen));
2562 if (error)
2563 return (error);
2564 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_LINK]);
2565 nfsm_fhtom(vp, v3);
2566 nfsm_fhtom(tdvp, v3);
2567 nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN, v3);
2568 nfsm_request(vp, NFSPROC_LINK, p, cred, &xid);
2569 if (v3 && mrep) {
2570 u_int64_t txid = xid;
2571
2572 nfsm_postop_attr_update(vp, v3, attrflag, &xid);
2573 nfsm_wcc_data(tdvp, &premtime, wccpostattr, &txid);
2574 }
2575 nfsm_reqdone;
2576
2577 VTONFS(tdvp)->n_flag |= NMODIFIED;
2578 if (!attrflag)
2579 NATTRINVALIDATE(VTONFS(vp));
2580 /* if directory hadn't changed, update namecache mtime */
2581 if (nfstimespeccmp(&VTONFS(tdvp)->n_ncmtime, &premtime, ==))
2582 VTONFS(tdvp)->n_ncmtime = VTONFS(tdvp)->n_vattr.nva_mtime;
2583 if (!wccpostattr)
2584 NATTRINVALIDATE(VTONFS(tdvp));
2585 /*
2586 * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
2587 */
2588 if (error == EEXIST)
2589 error = 0;
2590 return (error);
2591 }
2592
2593 /*
2594 * nfs symbolic link create call
2595 */
2596 static int
2597 nfs_symlink(ap)
2598 struct vnop_symlink_args /* {
2599 struct vnodeop_desc *a_desc;
2600 vnode_t a_dvp;
2601 vnode_t *a_vpp;
2602 struct componentname *a_cnp;
2603 struct vnode_attr *a_vap;
2604 char *a_target;
2605 vfs_context_t a_context;
2606 } */ *ap;
2607 {
2608 vnode_t dvp = ap->a_dvp;
2609 struct vnode_attr *vap = ap->a_vap;
2610 struct componentname *cnp = ap->a_cnp;
2611 struct nfs_vattr nvattr;
2612 struct nfsv2_sattr *sp;
2613 u_long *tl;
2614 caddr_t cp;
2615 long t1, t2;
2616 caddr_t bpos, dpos, cp2;
2617 int slen, error = 0, wccpostattr = 0, gotvp = 0;
2618 struct timespec premtime = { 0, 0 };
2619 mbuf_t mreq, mrep, md, mb, mb2;
2620 vnode_t newvp = (vnode_t)0;
2621 int v3 = NFS_ISV3(dvp);
2622 int gotuid, gotgid;
2623 u_int64_t xid;
2624 kauth_cred_t cred;
2625 proc_t p;
2626 struct nfsnode *np = NULL;
2627
2628 cred = vfs_context_ucred(ap->a_context);
2629 p = vfs_context_proc(ap->a_context);
2630
2631 slen = strlen(ap->a_target);
2632 nfsm_reqhead(NFSX_FH(v3) + 2*NFSX_UNSIGNED +
2633 nfsm_rndup(cnp->cn_namelen) + nfsm_rndup(slen) + NFSX_SATTR(v3));
2634 if (error)
2635 return (error);
2636
2637 VATTR_SET_SUPPORTED(vap, va_mode);
2638 VATTR_SET_SUPPORTED(vap, va_uid);
2639 VATTR_SET_SUPPORTED(vap, va_gid);
2640 VATTR_SET_SUPPORTED(vap, va_data_size);
2641 VATTR_SET_SUPPORTED(vap, va_access_time);
2642 VATTR_SET_SUPPORTED(vap, va_modify_time);
2643 gotuid = VATTR_IS_ACTIVE(vap, va_uid);
2644 gotgid = VATTR_IS_ACTIVE(vap, va_gid);
2645
2646 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_SYMLINK]);
2647 nfsm_fhtom(dvp, v3);
2648 nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN, v3);
2649 if (v3) {
2650 nfsm_v3sattr(vap);
2651 }
2652 nfsm_strtom(ap->a_target, slen, NFS_MAXPATHLEN, v3);
2653 if (!v3) {
2654 struct timespec neg1time = { -1, -1 };
2655 nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
2656 sp->sa_mode = vtonfsv2_mode(VLNK,
2657 (VATTR_IS_ACTIVE(vap, va_mode) ? vap->va_mode : 0600));
2658 sp->sa_uid = gotuid ? (u_long)txdr_unsigned(vap->va_uid) : nfs_xdrneg1;
2659 sp->sa_gid = gotgid ? (u_long)txdr_unsigned(vap->va_gid) : nfs_xdrneg1;
2660 sp->sa_size = nfs_xdrneg1;
2661 if (VATTR_IS_ACTIVE(vap, va_access_time)) {
2662 txdr_nfsv2time(&vap->va_access_time, &sp->sa_atime);
2663 } else {
2664 txdr_nfsv2time(&neg1time, &sp->sa_atime);
2665 }
2666 if (VATTR_IS_ACTIVE(vap, va_modify_time)) {
2667 txdr_nfsv2time(&vap->va_modify_time, &sp->sa_mtime);
2668 } else {
2669 txdr_nfsv2time(&neg1time, &sp->sa_mtime);
2670 }
2671 }
2672 nfsm_request(dvp, NFSPROC_SYMLINK, p, cred, &xid);
2673 if (v3 && mrep) {
2674 u_int64_t dxid = xid;
2675
2676 if (!error)
2677 nfsm_mtofh(dvp, cnp, newvp, v3, &xid, gotvp);
2678 nfsm_wcc_data(dvp, &premtime, wccpostattr, &dxid);
2679 }
2680 nfsm_reqdone;
2681
2682 VTONFS(dvp)->n_flag |= NMODIFIED;
2683 /* if directory hadn't changed, update namecache mtime */
2684 if (nfstimespeccmp(&VTONFS(dvp)->n_ncmtime, &premtime, ==))
2685 VTONFS(dvp)->n_ncmtime = VTONFS(dvp)->n_vattr.nva_mtime;
2686 if (!wccpostattr)
2687 NATTRINVALIDATE(VTONFS(dvp));
2688
2689 /*
2690 * Kludge: Map EEXIST => 0 assuming that you have a reply to a retry
2691 * if we can succeed in looking up the symlink.
2692 */
2693 if ((error == EEXIST) || (!error && !gotvp)) {
2694 if (newvp) {
2695 vnode_put(newvp);
2696 newvp = NULL;
2697 }
2698 error = nfs_lookitup(dvp, cnp->cn_nameptr, cnp->cn_namelen, cred, p, &np);
2699 if (!error) {
2700 newvp = NFSTOV(np);
2701 if (vnode_vtype(newvp) != VLNK)
2702 error = EEXIST;
2703 }
2704 }
2705 if (!error && (gotuid || gotgid) &&
2706 (!newvp || nfs_getattrcache(newvp, &nvattr) ||
2707 (gotuid && (nvattr.nva_uid != vap->va_uid)) ||
2708 (gotgid && (nvattr.nva_gid != vap->va_gid)))) {
2709 /* clear ID bits if server didn't use them (or we can't tell) */
2710 VATTR_CLEAR_SUPPORTED(vap, va_uid);
2711 VATTR_CLEAR_SUPPORTED(vap, va_gid);
2712 }
2713 if (error) {
2714 if (newvp)
2715 vnode_put(newvp);
2716 } else {
2717 *ap->a_vpp = newvp;
2718 }
2719 return (error);
2720 }
2721
2722 /*
2723 * nfs make dir call
2724 */
2725 static int
2726 nfs_mkdir(ap)
2727 struct vnop_mkdir_args /* {
2728 struct vnodeop_desc *a_desc;
2729 vnode_t a_dvp;
2730 vnode_t *a_vpp;
2731 struct componentname *a_cnp;
2732 struct vnode_attr *a_vap;
2733 vfs_context_t a_context;
2734 } */ *ap;
2735 {
2736 vnode_t dvp = ap->a_dvp;
2737 struct vnode_attr *vap = ap->a_vap;
2738 struct componentname *cnp = ap->a_cnp;
2739 struct nfs_vattr nvattr;
2740 struct nfsv2_sattr *sp;
2741 u_long *tl;
2742 caddr_t cp;
2743 long t1, t2;
2744 int len;
2745 struct nfsnode *np = (struct nfsnode *)0;
2746 vnode_t newvp = (vnode_t)0;
2747 caddr_t bpos, dpos, cp2;
2748 int error = 0, wccpostattr = 0;
2749 struct timespec premtime = { 0, 0 };
2750 int gotvp = 0;
2751 mbuf_t mreq, mrep, md, mb, mb2;
2752 int v3 = NFS_ISV3(dvp);
2753 int gotuid, gotgid;
2754 u_int64_t xid, dxid;
2755 kauth_cred_t cred;
2756 proc_t p;
2757
2758 cred = vfs_context_ucred(ap->a_context);
2759 p = vfs_context_proc(ap->a_context);
2760
2761 len = cnp->cn_namelen;
2762 nfsm_reqhead(NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len) + NFSX_SATTR(v3));
2763 if (error)
2764 return (error);
2765
2766 VATTR_SET_SUPPORTED(vap, va_mode);
2767 VATTR_SET_SUPPORTED(vap, va_uid);
2768 VATTR_SET_SUPPORTED(vap, va_gid);
2769 VATTR_SET_SUPPORTED(vap, va_data_size);
2770 VATTR_SET_SUPPORTED(vap, va_access_time);
2771 VATTR_SET_SUPPORTED(vap, va_modify_time);
2772 gotuid = VATTR_IS_ACTIVE(vap, va_uid);
2773 gotgid = VATTR_IS_ACTIVE(vap, va_gid);
2774
2775 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_MKDIR]);
2776 nfsm_fhtom(dvp, v3);
2777 nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN, v3);
2778 if (v3) {
2779 nfsm_v3sattr(vap);
2780 } else {
2781 struct timespec neg1time = { -1, -1 };
2782 nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
2783 sp->sa_mode = vtonfsv2_mode(VDIR,
2784 (VATTR_IS_ACTIVE(vap, va_mode) ? vap->va_mode : 0600));
2785 sp->sa_uid = gotuid ? (u_long)txdr_unsigned(vap->va_uid) : nfs_xdrneg1;
2786 sp->sa_gid = gotgid ? (u_long)txdr_unsigned(vap->va_gid) : nfs_xdrneg1;
2787 sp->sa_size = nfs_xdrneg1;
2788 if (VATTR_IS_ACTIVE(vap, va_access_time)) {
2789 txdr_nfsv2time(&vap->va_access_time, &sp->sa_atime);
2790 } else {
2791 txdr_nfsv2time(&neg1time, &sp->sa_atime);
2792 }
2793 if (VATTR_IS_ACTIVE(vap, va_modify_time)) {
2794 txdr_nfsv2time(&vap->va_modify_time, &sp->sa_mtime);
2795 } else {
2796 txdr_nfsv2time(&neg1time, &sp->sa_mtime);
2797 }
2798 }
2799 nfsm_request(dvp, NFSPROC_MKDIR, p, cred, &xid);
2800 dxid = xid;
2801 if (!error)
2802 nfsm_mtofh(dvp, cnp, newvp, v3, &xid, gotvp);
2803 if (v3 && mrep)
2804 nfsm_wcc_data(dvp, &premtime, wccpostattr, &dxid);
2805 nfsm_reqdone;
2806 VTONFS(dvp)->n_flag |= NMODIFIED;
2807 /* if directory hadn't changed, update namecache mtime */
2808 if (nfstimespeccmp(&VTONFS(dvp)->n_ncmtime, &premtime, ==))
2809 VTONFS(dvp)->n_ncmtime = VTONFS(dvp)->n_vattr.nva_mtime;
2810 if (!wccpostattr)
2811 NATTRINVALIDATE(VTONFS(dvp));
2812 /*
2813 * Kludge: Map EEXIST => 0 assuming that you have a reply to a retry
2814 * if we can succeed in looking up the directory.
2815 */
2816 if (error == EEXIST || (!error && !gotvp)) {
2817 if (newvp) {
2818 vnode_put(newvp);
2819 newvp = NULL;
2820 }
2821 error = nfs_lookitup(dvp, cnp->cn_nameptr, len, cred, p, &np);
2822 if (!error) {
2823 newvp = NFSTOV(np);
2824 if (vnode_vtype(newvp) != VDIR)
2825 error = EEXIST;
2826 }
2827 }
2828 if (!error && (gotuid || gotgid) &&
2829 (!newvp || nfs_getattrcache(newvp, &nvattr) ||
2830 (gotuid && (nvattr.nva_uid != vap->va_uid)) ||
2831 (gotgid && (nvattr.nva_gid != vap->va_gid)))) {
2832 /* clear ID bits if server didn't use them (or we can't tell) */
2833 VATTR_CLEAR_SUPPORTED(vap, va_uid);
2834 VATTR_CLEAR_SUPPORTED(vap, va_gid);
2835 }
2836 if (error) {
2837 if (newvp)
2838 vnode_put(newvp);
2839 } else {
2840 *ap->a_vpp = newvp;
2841 }
2842 return (error);
2843 }
2844
2845 /*
2846 * nfs remove directory call
2847 */
2848 static int
2849 nfs_rmdir(ap)
2850 struct vnop_rmdir_args /* {
2851 struct vnodeop_desc *a_desc;
2852 vnode_t a_dvp;
2853 vnode_t a_vp;
2854 struct componentname *a_cnp;
2855 vfs_context_t a_context;
2856 } */ *ap;
2857 {
2858 vnode_t vp = ap->a_vp;
2859 vnode_t dvp = ap->a_dvp;
2860 struct componentname *cnp = ap->a_cnp;
2861 u_long *tl;
2862 caddr_t cp;
2863 long t1, t2;
2864 caddr_t bpos, dpos, cp2;
2865 int error = 0, wccpostattr = 0;
2866 struct timespec premtime = { 0, 0 };
2867 mbuf_t mreq, mrep, md, mb, mb2;
2868 int v3 = NFS_ISV3(dvp);
2869 u_int64_t xid;
2870 kauth_cred_t cred;
2871 proc_t p;
2872
2873 cred = vfs_context_ucred(ap->a_context);
2874 p = vfs_context_proc(ap->a_context);
2875
2876 nfsm_reqhead(NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(cnp->cn_namelen));
2877 if (error)
2878 return (error);
2879 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_RMDIR]);
2880 nfsm_fhtom(dvp, v3);
2881 nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN, v3);
2882 nfsm_request(dvp, NFSPROC_RMDIR, p, cred, &xid);
2883 if (v3 && mrep)
2884 nfsm_wcc_data(dvp, &premtime, wccpostattr, &xid);
2885 nfsm_reqdone;
2886 VTONFS(dvp)->n_flag |= NMODIFIED;
2887 /* if directory hadn't changed, update namecache mtime */
2888 if (nfstimespeccmp(&VTONFS(dvp)->n_ncmtime, &premtime, ==))
2889 VTONFS(dvp)->n_ncmtime = VTONFS(dvp)->n_vattr.nva_mtime;
2890 if (!wccpostattr)
2891 NATTRINVALIDATE(VTONFS(dvp));
2892 cache_purge(vp);
2893 /*
2894 * Kludge: Map ENOENT => 0 assuming that you have a reply to a retry.
2895 */
2896 if (error == ENOENT)
2897 error = 0;
2898 if (!error) {
2899 /*
2900 * remove nfsnode from hash now so we can't accidentally find it
2901 * again if another object gets created with the same filehandle
2902 * before this vnode gets reclaimed
2903 */
2904 lck_mtx_lock(nfs_node_hash_mutex);
2905 LIST_REMOVE(VTONFS(vp), n_hash);
2906 VTONFS(vp)->n_flag &= ~NHASHED;
2907 lck_mtx_unlock(nfs_node_hash_mutex);
2908 }
2909 return (error);
2910 }
2911
2912 /*
2913 * nfs readdir call
2914 */
2915 static int
2916 nfs_readdir(ap)
2917 struct vnop_readdir_args /* {
2918 struct vnodeop_desc *a_desc;
2919 vnode_t a_vp;
2920 struct uio *a_uio;
2921 int *a_eofflag;
2922 int *a_ncookies;
2923 u_long **a_cookies;
2924 vfs_context_t a_context;
2925 } */ *ap;
2926 {
2927 vnode_t vp = ap->a_vp;
2928 struct nfsnode *np = VTONFS(vp);
2929 struct uio *uio = ap->a_uio;
2930 int tresid, error;
2931 struct nfs_vattr nvattr;
2932 kauth_cred_t cred;
2933 proc_t p;
2934
2935 if (vnode_vtype(vp) != VDIR)
2936 return (EPERM);
2937
2938 cred = vfs_context_ucred(ap->a_context);
2939 p = vfs_context_proc(ap->a_context);
2940
2941 /*
2942 * First, check for hit on the EOF offset cache
2943 */
2944 if (np->n_direofoffset > 0 && uio->uio_offset >= np->n_direofoffset &&
2945 (np->n_flag & NMODIFIED) == 0) {
2946 if (!nfs_getattr(vp, &nvattr, cred, p)) {
2947 if (nfstimespeccmp(&np->n_mtime, &nvattr.nva_mtime, ==)) {
2948 OSAddAtomic(1, (SInt32*)&nfsstats.direofcache_hits);
2949 return (0);
2950 }
2951 if (nfstimespeccmp(&np->n_ncmtime, &nvattr.nva_mtime, !=)) {
2952 /* directory changed, purge any name cache entries */
2953 cache_purge(vp);
2954 }
2955 }
2956 }
2957
2958 /*
2959 * Call nfs_bioread() to do the real work.
2960 */
2961 // LP64todo - fix this
2962 tresid = uio_uio_resid(uio);
2963 error = nfs_bioread(vp, uio, 0, cred, p);
2964
2965 if (!error && uio_uio_resid(uio) == tresid)
2966 OSAddAtomic(1, (SInt32*)&nfsstats.direofcache_misses);
2967 return (error);
2968 }
2969
2970 /*
2971 * Readdir rpc call.
2972 * Called from below the buffer cache by nfs_doio().
2973 */
2974 int
2975 nfs_readdirrpc(
2976 vnode_t vp,
2977 struct uio *uiop,
2978 kauth_cred_t cred,
2979 proc_t p)
2980 {
2981 register int len, skiplen, left;
2982 register struct dirent *dp;
2983 register u_long *tl;
2984 register caddr_t cp;
2985 register long t1, t2;
2986 register nfsuint64 *cookiep;
2987 caddr_t bpos, dpos, cp2;
2988 mbuf_t mreq, mrep, md, mb, mb2;
2989 nfsuint64 cookie;
2990 struct nfsmount *nmp;
2991 struct nfsnode *dnp = VTONFS(vp);
2992 u_quad_t fileno;
2993 int error = 0, tlen, more_dirs = 1, blksiz = 0, bigenough = 1;
2994 int attrflag;
2995 int v3, nmreaddirsize;
2996 u_int64_t xid;
2997
2998 #ifndef nolint
2999 dp = (struct dirent *)0;
3000 #endif
3001 #if DIAGNOSTIC
3002 if (uiop->uio_iovcnt != 1 || (uiop->uio_offset & (NFS_DIRBLKSIZ - 1)) ||
3003 (uio_uio_resid(uiop) & (NFS_DIRBLKSIZ - 1)))
3004 panic("nfs_readdirrpc: bad uio");
3005 #endif
3006 nmp = VFSTONFS(vnode_mount(vp));
3007 if (!nmp)
3008 return (ENXIO);
3009 v3 = NFS_ISV3(vp);
3010 nmreaddirsize = nmp->nm_readdirsize;
3011
3012 /*
3013 * If there is no cookie, assume directory was stale.
3014 */
3015 cookiep = nfs_getcookie(dnp, uiop->uio_offset, 0);
3016 if (cookiep)
3017 cookie = *cookiep;
3018 else
3019 return (NFSERR_BAD_COOKIE);
3020 /*
3021 * Loop around doing readdir rpc's of size nm_readdirsize
3022 * truncated to a multiple of DIRBLKSIZ.
3023 * The stopping criteria is EOF or buffer full.
3024 */
3025 while (more_dirs && bigenough) {
3026 nfsm_reqhead(NFSX_FH(v3) + NFSX_READDIR(v3));
3027 if (error)
3028 goto nfsmout;
3029 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_READDIR]);
3030 nfsm_fhtom(vp, v3);
3031 if (v3) {
3032 nfsm_build(tl, u_long *, 5 * NFSX_UNSIGNED);
3033 *tl++ = cookie.nfsuquad[0];
3034 *tl++ = cookie.nfsuquad[1];
3035 *tl++ = dnp->n_cookieverf.nfsuquad[0];
3036 *tl++ = dnp->n_cookieverf.nfsuquad[1];
3037 } else {
3038 nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED);
3039 *tl++ = cookie.nfsuquad[0];
3040 }
3041 *tl = txdr_unsigned(nmreaddirsize);
3042 nfsm_request(vp, NFSPROC_READDIR, p, cred, &xid);
3043 if (v3) {
3044 if (mrep) {
3045 nfsm_postop_attr_update(vp, v3, attrflag, &xid);
3046 }
3047 if (!error) {
3048 nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
3049 dnp->n_cookieverf.nfsuquad[0] = *tl++;
3050 dnp->n_cookieverf.nfsuquad[1] = *tl;
3051 } else {
3052 mbuf_freem(mrep);
3053 goto nfsmout;
3054 }
3055 } else if (!mrep) {
3056 // XXX assert error?
3057 goto nfsmout;
3058 }
3059 nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
3060 more_dirs = fxdr_unsigned(int, *tl);
3061
3062 /* loop thru the dir entries, doctoring them to 4bsd form */
3063 while (more_dirs && bigenough) {
3064 if (v3) {
3065 nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
3066 fxdr_hyper(tl, &fileno);
3067 len = fxdr_unsigned(int, *(tl + 2));
3068 } else {
3069 nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
3070 fileno = fxdr_unsigned(u_quad_t, *tl++);
3071 len = fxdr_unsigned(int, *tl);
3072 }
3073 /* Note: v3 supports longer names, but struct dirent doesn't */
3074 /* so we just truncate the names to fit */
3075 if (len <= 0) {
3076 error = EBADRPC;
3077 mbuf_freem(mrep);
3078 goto nfsmout;
3079 }
3080 if (len > MAXNAMLEN) {
3081 skiplen = len - MAXNAMLEN;
3082 len = MAXNAMLEN;
3083 } else {
3084 skiplen = 0;
3085 }
3086 tlen = nfsm_rndup(len);
3087 if (tlen == len)
3088 tlen += 4; /* To ensure null termination */
3089 left = DIRBLKSIZ - blksiz;
3090 if ((tlen + (int)DIRHDSIZ) > left) {
3091 dp->d_reclen += left;
3092 uio_iov_base_add(uiop, left);
3093 uio_iov_len_add(uiop, -left);
3094 uiop->uio_offset += left;
3095 uio_uio_resid_add(uiop, -left);
3096 blksiz = 0;
3097 }
3098 if ((tlen + (int)DIRHDSIZ) > uio_uio_resid(uiop))
3099 bigenough = 0;
3100 if (bigenough) {
3101 // LP64todo - fix this!
3102 dp = (struct dirent *) CAST_DOWN(caddr_t, uio_iov_base(uiop));
3103 dp->d_fileno = (int)fileno;
3104 dp->d_namlen = len;
3105 dp->d_reclen = tlen + DIRHDSIZ;
3106 dp->d_type = DT_UNKNOWN;
3107 blksiz += dp->d_reclen;
3108 if (blksiz == DIRBLKSIZ)
3109 blksiz = 0;
3110 uiop->uio_offset += DIRHDSIZ;
3111 #if LP64KERN
3112 uio_uio_resid_add(uiop, -((int64_t)DIRHDSIZ));
3113 uio_iov_len_add(uiop, -((int64_t)DIRHDSIZ));
3114 #else
3115 uio_uio_resid_add(uiop, -((int)DIRHDSIZ));
3116 uio_iov_len_add(uiop, -((int)DIRHDSIZ));
3117 #endif
3118 uio_iov_base_add(uiop, DIRHDSIZ);
3119 nfsm_mtouio(uiop, len);
3120 // LP64todo - fix this!
3121 cp = CAST_DOWN(caddr_t, uio_iov_base(uiop));
3122 tlen -= len;
3123 *cp = '\0'; /* null terminate */
3124 uio_iov_base_add(uiop, tlen);
3125 uio_iov_len_add(uiop, -tlen);
3126 uiop->uio_offset += tlen;
3127 uio_uio_resid_add(uiop, -tlen);
3128 } else {
3129 nfsm_adv(nfsm_rndup(len));
3130 }
3131 if (skiplen)
3132 nfsm_adv(nfsm_rndup(skiplen));
3133 if (v3) {
3134 nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
3135 } else {
3136 nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED);
3137 }
3138 if (bigenough) {
3139 cookie.nfsuquad[0] = *tl++;
3140 if (v3)
3141 cookie.nfsuquad[1] = *tl++;
3142 } else if (v3)
3143 tl += 2;
3144 else
3145 tl++;
3146 more_dirs = fxdr_unsigned(int, *tl);
3147 }
3148 /*
3149 * If at end of rpc data, get the eof boolean
3150 */
3151 if (!more_dirs) {
3152 nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
3153 more_dirs = (fxdr_unsigned(int, *tl) == 0);
3154 }
3155 mbuf_freem(mrep);
3156 }
3157 /*
3158 * Fill last record, iff any, out to a multiple of DIRBLKSIZ
3159 * by increasing d_reclen for the last record.
3160 */
3161 if (blksiz > 0) {
3162 left = DIRBLKSIZ - blksiz;
3163 dp->d_reclen += left;
3164 uio_iov_base_add(uiop, left);
3165 uio_iov_len_add(uiop, -left);
3166 uiop->uio_offset += left;
3167 uio_uio_resid_add(uiop, -left);
3168 }
3169
3170 /*
3171 * We are now either at the end of the directory or have filled the
3172 * block.
3173 */
3174 if (bigenough)
3175 dnp->n_direofoffset = uiop->uio_offset;
3176 else {
3177 if (uio_uio_resid(uiop) > 0)
3178 printf("EEK! readdirrpc resid > 0\n");
3179 cookiep = nfs_getcookie(dnp, uiop->uio_offset, 1);
3180 if (cookiep)
3181 *cookiep = cookie;
3182 }
3183 nfsmout:
3184 return (error);
3185 }
3186
3187 /*
3188 * NFS V3 readdir plus RPC. Used in place of nfs_readdirrpc().
3189 */
3190 int
3191 nfs_readdirplusrpc(
3192 vnode_t vp,
3193 struct uio *uiop,
3194 kauth_cred_t cred,
3195 proc_t p)
3196 {
3197 int len, skiplen, left;
3198 struct dirent *dp;
3199 u_long *tl;
3200 caddr_t cp;
3201 long t1, t2;
3202 vnode_t newvp;
3203 nfsuint64 *cookiep;
3204 caddr_t bpos, dpos, cp2;
3205 mbuf_t mreq, mrep, md, mb, mb2;
3206 struct componentname cn, *cnp = &cn;
3207 nfsuint64 cookie;
3208 struct nfsmount *nmp;
3209 struct nfsnode *dnp = VTONFS(vp), *np;
3210 u_char *fhp;
3211 u_quad_t fileno;
3212 int error = 0, tlen, more_dirs = 1, blksiz = 0, doit, bigenough = 1, i;
3213 int attrflag, fhsize, nmreaddirsize, nmrsize;
3214 u_int64_t xid, savexid;
3215 struct nfs_vattr nvattr;
3216
3217 #ifndef nolint
3218 dp = (struct dirent *)0;
3219 #endif
3220 #if DIAGNOSTIC
3221 if (uiop->uio_iovcnt != 1 || (uiop->uio_offset & (DIRBLKSIZ - 1)) ||
3222 (uio_uio_resid(uiop) & (DIRBLKSIZ - 1)))
3223 panic("nfs_readdirplusrpc: bad uio");
3224 #endif
3225 nmp = VFSTONFS(vnode_mount(vp));
3226 if (!nmp)
3227 return (ENXIO);
3228 nmreaddirsize = nmp->nm_readdirsize;
3229 nmrsize = nmp->nm_rsize;
3230
3231 bzero(cnp, sizeof(*cnp));
3232 newvp = NULLVP;
3233
3234 /*
3235 * If there is no cookie, assume directory was stale.
3236 */
3237 cookiep = nfs_getcookie(dnp, uiop->uio_offset, 0);
3238 if (cookiep)
3239 cookie = *cookiep;
3240 else
3241 return (NFSERR_BAD_COOKIE);
3242 /*
3243 * Loop around doing readdir rpc's of size nm_readdirsize
3244 * truncated to a multiple of DIRBLKSIZ.
3245 * The stopping criteria is EOF or buffer full.
3246 */
3247 while (more_dirs && bigenough) {
3248 nfsm_reqhead(NFSX_FH(1) + 6 * NFSX_UNSIGNED);
3249 if (error)
3250 goto nfsmout;
3251 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_READDIRPLUS]);
3252 nfsm_fhtom(vp, 1);
3253 nfsm_build(tl, u_long *, 6 * NFSX_UNSIGNED);
3254 *tl++ = cookie.nfsuquad[0];
3255 *tl++ = cookie.nfsuquad[1];
3256 *tl++ = dnp->n_cookieverf.nfsuquad[0];
3257 *tl++ = dnp->n_cookieverf.nfsuquad[1];
3258 *tl++ = txdr_unsigned(nmreaddirsize);
3259 *tl = txdr_unsigned(nmrsize);
3260 nfsm_request(vp, NFSPROC_READDIRPLUS, p, cred, &xid);
3261 savexid = xid;
3262 if (mrep) {
3263 nfsm_postop_attr_update(vp, 1, attrflag, &xid);
3264 }
3265 if (error) {
3266 mbuf_freem(mrep);
3267 goto nfsmout;
3268 }
3269 nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
3270 dnp->n_cookieverf.nfsuquad[0] = *tl++;
3271 dnp->n_cookieverf.nfsuquad[1] = *tl++;
3272 more_dirs = fxdr_unsigned(int, *tl);
3273
3274 /* loop thru the dir entries, doctoring them to 4bsd form */
3275 while (more_dirs && bigenough) {
3276 nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
3277 fxdr_hyper(tl, &fileno);
3278 len = fxdr_unsigned(int, *(tl + 2));
3279 /* Note: v3 supports longer names, but struct dirent doesn't */
3280 /* so we just truncate the names to fit */
3281 if (len <= 0) {
3282 error = EBADRPC;
3283 mbuf_freem(mrep);
3284 goto nfsmout;
3285 }
3286 if (len > MAXNAMLEN) {
3287 skiplen = len - MAXNAMLEN;
3288 len = MAXNAMLEN;
3289 } else {
3290 skiplen = 0;
3291 }
3292 tlen = nfsm_rndup(len);
3293 if (tlen == len)
3294 tlen += 4; /* To ensure null termination*/
3295 left = DIRBLKSIZ - blksiz;
3296 if ((tlen + (int)DIRHDSIZ) > left) {
3297 dp->d_reclen += left;
3298 uio_iov_base_add(uiop, left);
3299 uio_iov_len_add(uiop, -left);
3300 uiop->uio_offset += left;
3301 uio_uio_resid_add(uiop, -left);
3302 blksiz = 0;
3303 }
3304 if ((tlen + (int)DIRHDSIZ) > uio_uio_resid(uiop))
3305 bigenough = 0;
3306 if (bigenough) {
3307 // LP64todo - fix this!
3308 dp = (struct dirent *) CAST_DOWN(caddr_t, uio_iov_base(uiop));
3309 dp->d_fileno = (int)fileno;
3310 dp->d_namlen = len;
3311 dp->d_reclen = tlen + DIRHDSIZ;
3312 dp->d_type = DT_UNKNOWN;
3313 blksiz += dp->d_reclen;
3314 if (blksiz == DIRBLKSIZ)
3315 blksiz = 0;
3316 uiop->uio_offset += DIRHDSIZ;
3317 #if LP64KERN
3318 uio_uio_resid_add(uiop, -((int64_t)DIRHDSIZ));
3319 uio_iov_len_add(uiop, -((int64_t)DIRHDSIZ));
3320 #else
3321 uio_uio_resid_add(uiop, -((int)DIRHDSIZ));
3322 uio_iov_len_add(uiop, -((int)DIRHDSIZ));
3323 #endif
3324 uio_iov_base_add(uiop, DIRHDSIZ);
3325 // LP64todo - fix this!
3326 cnp->cn_nameptr = CAST_DOWN(caddr_t, uio_iov_base(uiop));
3327 cnp->cn_namelen = len;
3328 nfsm_mtouio(uiop, len);
3329 cp = CAST_DOWN(caddr_t, uio_iov_base(uiop));
3330 tlen -= len;
3331 *cp = '\0';
3332 uio_iov_base_add(uiop, tlen);
3333 uio_iov_len_add(uiop, -tlen);
3334 uiop->uio_offset += tlen;
3335 uio_uio_resid_add(uiop, -tlen);
3336 } else {
3337 nfsm_adv(nfsm_rndup(len));
3338 }
3339 if (skiplen)
3340 nfsm_adv(nfsm_rndup(skiplen));
3341 nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED);
3342 if (bigenough) {
3343 cookie.nfsuquad[0] = *tl++;
3344 cookie.nfsuquad[1] = *tl++;
3345 } else
3346 tl += 2;
3347
3348 /*
3349 * Since the attributes are before the file handle
3350 * (sigh), we must skip over the attributes and then
3351 * come back and get them.
3352 */
3353 attrflag = fxdr_unsigned(int, *tl);
3354 if (attrflag) {
3355 /* grab attributes */
3356 nfsm_attr_get(1, &nvattr);
3357 dp->d_type = IFTODT(VTTOIF(nvattr.nva_type));
3358 /* check for file handle */
3359 nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
3360 doit = fxdr_unsigned(int, *tl);
3361 if (doit) {
3362 nfsm_getfh(fhp, fhsize, 1);
3363 if (NFS_CMPFH(dnp, fhp, fhsize)) {
3364 error = vnode_ref(vp);
3365 if (error) {
3366 doit = 0;
3367 } else {
3368 newvp = vp;
3369 np = dnp;
3370 }
3371 } else if (!bigenough ||
3372 (cnp->cn_namelen == 2 &&
3373 cnp->cn_nameptr[1] == '.' &&
3374 cnp->cn_nameptr[0] == '.')) {
3375 /*
3376 * XXXmacko I don't think this ".." thing is a problem anymore.
3377 * don't doit if we can't guarantee
3378 * that this entry is NOT ".." because
3379 * we would have to drop the lock on
3380 * the directory before getting the
3381 * lock on the ".." vnode... and we
3382 * don't want to drop the dvp lock in
3383 * the middle of a readdirplus.
3384 */
3385 doit = 0;
3386 } else {
3387 cnp->cn_hash = 0;
3388
3389 error = nfs_nget(vnode_mount(vp), vp, cnp,
3390 fhp, fhsize, &nvattr, &xid,
3391 NG_MAKEENTRY, &np);
3392 if (error)
3393 doit = 0;
3394 else
3395 newvp = NFSTOV(np);
3396 }
3397 }
3398 /* update attributes if not already updated */
3399 if (doit && bigenough && (np->n_xid <= savexid)) {
3400 xid = savexid;
3401 nfs_loadattrcache(np, &nvattr, &xid, 0);
3402 /* any error can be ignored */
3403 }
3404 } else {
3405 /* Just skip over the file handle */
3406 nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
3407 i = fxdr_unsigned(int, *tl);
3408 nfsm_adv(nfsm_rndup(i));
3409 }
3410 if (newvp != NULLVP) {
3411 if (newvp == vp)
3412 vnode_rele(newvp);
3413 else
3414 vnode_put(newvp);
3415 newvp = NULLVP;
3416 }
3417 nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
3418 more_dirs = fxdr_unsigned(int, *tl);
3419 }
3420 /*
3421 * If at end of rpc data, get the eof boolean
3422 */
3423 if (!more_dirs) {
3424 nfsm_dissect(tl, u_long *, NFSX_UNSIGNED);
3425 more_dirs = (fxdr_unsigned(int, *tl) == 0);
3426 }
3427 mbuf_freem(mrep);
3428 }
3429 /*
3430 * Fill last record, iff any, out to a multiple of NFS_DIRBLKSIZ
3431 * by increasing d_reclen for the last record.
3432 */
3433 if (blksiz > 0) {
3434 left = DIRBLKSIZ - blksiz;
3435 dp->d_reclen += left;
3436 uio_iov_base_add(uiop, left);
3437 uio_iov_len_add(uiop, -left);
3438 uiop->uio_offset += left;
3439 uio_uio_resid_add(uiop, -left);
3440 }
3441
3442 /*
3443 * We are now either at the end of the directory or have filled the
3444 * block.
3445 */
3446 if (bigenough)
3447 dnp->n_direofoffset = uiop->uio_offset;
3448 else {
3449 if (uio_uio_resid(uiop) > 0)
3450 printf("EEK! readdirplusrpc resid > 0\n");
3451 cookiep = nfs_getcookie(dnp, uiop->uio_offset, 1);
3452 if (cookiep)
3453 *cookiep = cookie;
3454 }
3455 nfsmout:
3456 return (error);
3457 }
3458
3459 /*
3460 * Silly rename. To make the NFS filesystem that is stateless look a little
3461 * more like the "ufs" a remove of an active vnode is translated to a rename
3462 * to a funny looking filename that is removed by nfs_inactive on the
3463 * nfsnode. There is the potential for another process on a different client
3464 * to create the same funny name between the nfs_lookitup() fails and the
3465 * nfs_rename() completes, but...
3466 */
3467
3468 /* format of "random" names and next name to try */
3469 /* (note: shouldn't exceed size of sillyrename.s_name) */
3470 static char sillyrename_name[] = ".nfsAAA%04x4.4";
3471
3472 static int
3473 nfs_sillyrename(
3474 vnode_t dvp,
3475 vnode_t vp,
3476 struct componentname *cnp,
3477 kauth_cred_t cred,
3478 proc_t p)
3479 {
3480 register struct sillyrename *sp;
3481 struct nfsnode *np;
3482 int error;
3483 short pid;
3484 kauth_cred_t tmpcred;
3485 int i, j, k;
3486
3487 cache_purge(vp);
3488 np = VTONFS(vp);
3489 #if DIAGNOSTIC
3490 if (vnode_vtype(vp) == VDIR)
3491 panic("nfs_sillyrename: dir");
3492 #endif
3493 MALLOC_ZONE(sp, struct sillyrename *,
3494 sizeof (struct sillyrename), M_NFSREQ, M_WAITOK);
3495 if (!sp)
3496 return (ENOMEM);
3497 kauth_cred_ref(cred);
3498 sp->s_cred = cred;
3499 sp->s_dvp = dvp;
3500 error = vnode_ref(dvp);
3501 if (error)
3502 goto bad_norele;
3503
3504 /* Fudge together a funny name */
3505 pid = proc_pid(p);
3506 sp->s_namlen = sprintf(sp->s_name, sillyrename_name, pid);
3507
3508 /* Try lookitups until we get one that isn't there */
3509 i = j = k = 0;
3510 while (nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred, p, NULL) == 0) {
3511 if (sp->s_name[4]++ >= 'z')
3512 sp->s_name[4] = 'A';
3513 if (++i > ('z' - 'A' + 1)) {
3514 i = 0;
3515 if (sp->s_name[5]++ >= 'z')
3516 sp->s_name[5] = 'A';
3517 if (++j > ('z' - 'A' + 1)) {
3518 j = 0;
3519 if (sp->s_name[6]++ >= 'z')
3520 sp->s_name[6] = 'A';
3521 if (++k > ('z' - 'A' + 1)) {
3522 error = EINVAL;
3523 goto bad;
3524 }
3525 }
3526 }
3527 }
3528 /* make note of next "random" name to try */
3529 if ((sillyrename_name[4] = (sp->s_name[4] + 1)) > 'z') {
3530 sillyrename_name[4] = 'A';
3531 if ((sillyrename_name[5] = (sp->s_name[5] + 1)) > 'z') {
3532 sillyrename_name[5] = 'A';
3533 if ((sillyrename_name[6] = (sp->s_name[6] + 1)) > 'z')
3534 sillyrename_name[6] = 'A';
3535 }
3536 }
3537 /* now, do the rename */
3538 error = nfs_renamerpc(dvp, cnp->cn_nameptr, cnp->cn_namelen,
3539 dvp, sp->s_name, sp->s_namlen, sp->s_cred, p);
3540 if (error)
3541 goto bad;
3542 error = nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred, p, &np);
3543 #if DIAGNOSTIC
3544 kprintf("sillyrename: %s, vp=%x, np=%x, dvp=%x\n",
3545 &sp->s_name[0], (unsigned)vp, (unsigned)np, (unsigned)dvp);
3546 #endif
3547 np->n_sillyrename = sp;
3548 return (0);
3549 bad:
3550 vnode_rele(sp->s_dvp);
3551 bad_norele:
3552 tmpcred = sp->s_cred;
3553 sp->s_cred = NOCRED;
3554 kauth_cred_rele(tmpcred);
3555 FREE_ZONE((caddr_t)sp, sizeof (struct sillyrename), M_NFSREQ);
3556 return (error);
3557 }
3558
3559 /*
3560 * Look up a file name and optionally either update the file handle or
3561 * allocate an nfsnode, depending on the value of npp.
3562 * npp == NULL --> just do the lookup
3563 * *npp == NULL --> allocate a new nfsnode and make sure attributes are
3564 * handled too
3565 * *npp != NULL --> update the file handle in the vnode
3566 */
3567 static int
3568 nfs_lookitup(dvp, name, len, cred, procp, npp)
3569 vnode_t dvp;
3570 char *name;
3571 int len;
3572 kauth_cred_t cred;
3573 proc_t procp;
3574 struct nfsnode **npp;
3575 {
3576 u_long *tl;
3577 caddr_t cp;
3578 long t1, t2;
3579 vnode_t newvp = (vnode_t)0;
3580 struct nfsnode *np, *dnp = VTONFS(dvp);
3581 caddr_t bpos, dpos, cp2;
3582 int error = 0, fhlen, attrflag;
3583 mbuf_t mreq, mrep, md, mb, mb2;
3584 u_char *nfhp;
3585 int v3;
3586 u_int64_t xid, dxid, savedxid;
3587 struct nfs_vattr nvattr;
3588
3589 if (!VFSTONFS(vnode_mount(dvp)))
3590 return (ENXIO);
3591 v3 = NFS_ISV3(dvp);
3592
3593 nfsm_reqhead(NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len));
3594 if (error)
3595 return (error);
3596 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_LOOKUP]);
3597 nfsm_fhtom(dvp, v3);
3598 nfsm_strtom(name, len, NFS_MAXNAMLEN, v3);
3599 nfsm_request(dvp, NFSPROC_LOOKUP, procp, cred, &xid);
3600 if (npp && !error) {
3601 savedxid = xid;
3602 nfsm_getfh(nfhp, fhlen, v3);
3603 /* get attributes */
3604 if (v3) {
3605 nfsm_postop_attr_get(v3, attrflag, &nvattr);
3606 if (!attrflag) {
3607 /* We need valid attributes in order */
3608 /* to call nfs_nget/vnode_create(). */
3609 error = nfs_getattr_no_vnode(vnode_mount(dvp),
3610 nfhp, fhlen, cred, procp, &nvattr, &xid);
3611 if (error) {
3612 mbuf_freem(mrep);
3613 goto nfsmout;
3614 }
3615 }
3616 dxid = savedxid;
3617 nfsm_postop_attr_update(dvp, v3, attrflag, &dxid);
3618 } else {
3619 nfsm_attr_get(v3, &nvattr);
3620 }
3621 if (*npp) {
3622 np = *npp;
3623 if (fhlen != np->n_fhsize) {
3624 u_char *oldbuf = (np->n_fhsize > NFS_SMALLFH) ? np->n_fhp : NULL;
3625 if (fhlen > NFS_SMALLFH) {
3626 MALLOC_ZONE(np->n_fhp, u_char *, fhlen, M_NFSBIGFH, M_WAITOK);
3627 if (!np->n_fhp) {
3628 np->n_fhp = oldbuf;
3629 error = ENOMEM;
3630 mbuf_freem(mrep);
3631 goto nfsmout;
3632 }
3633 } else {
3634 np->n_fhp = &np->n_fh[0];
3635 }
3636 if (oldbuf) {
3637 FREE_ZONE(oldbuf, np->n_fhsize, M_NFSBIGFH);
3638 }
3639 }
3640 bcopy(nfhp, np->n_fhp, fhlen);
3641 np->n_fhsize = fhlen;
3642 newvp = NFSTOV(np);
3643 error = nfs_loadattrcache(np, &nvattr, &xid, 0);
3644 if (error) {
3645 mbuf_freem(mrep);
3646 goto nfsmout;
3647 }
3648 } else if (NFS_CMPFH(dnp, nfhp, fhlen)) {
3649 newvp = dvp;
3650 if (dnp->n_xid <= savedxid) {
3651 dxid = savedxid;
3652 error = nfs_loadattrcache(dnp, &nvattr, &dxid, 0);
3653 if (error) {
3654 mbuf_freem(mrep);
3655 goto nfsmout;
3656 }
3657 }
3658 } else {
3659 struct componentname cn, *cnp = &cn;
3660 bzero(cnp, sizeof(*cnp));
3661 cnp->cn_nameptr = name;
3662 cnp->cn_namelen = len;
3663
3664 error = nfs_nget(vnode_mount(dvp), dvp, cnp, nfhp, fhlen,
3665 &nvattr, &xid, NG_MAKEENTRY, &np);
3666 if (error) {
3667 mbuf_freem(mrep);
3668 return (error);
3669 }
3670 newvp = NFSTOV(np);
3671 }
3672 }
3673 nfsm_reqdone;
3674 if (npp && *npp == NULL) {
3675 if (error) {
3676 if (newvp) {
3677 if (newvp == dvp)
3678 vnode_rele(newvp);
3679 else
3680 vnode_put(newvp);
3681 }
3682 } else
3683 *npp = np;
3684 }
3685 return (error);
3686 }
3687
3688 /*
3689 * Nfs Version 3 commit rpc
3690 */
3691 int
3692 nfs_commit(vp, offset, count, cred, procp)
3693 vnode_t vp;
3694 u_quad_t offset;
3695 u_int32_t count;
3696 kauth_cred_t cred;
3697 proc_t procp;
3698 {
3699 caddr_t cp;
3700 u_long *tl;
3701 int t1, t2;
3702 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
3703 caddr_t bpos, dpos, cp2;
3704 int error = 0, wccpostattr = 0;
3705 struct timespec premtime = { 0, 0 };
3706 mbuf_t mreq, mrep, md, mb, mb2;
3707 u_int64_t xid, wverf;
3708
3709 FSDBG(521, vp, offset, count, nmp->nm_state);
3710 if (!nmp)
3711 return (ENXIO);
3712 if ((nmp->nm_state & NFSSTA_HASWRITEVERF) == 0)
3713 return (0);
3714 nfsm_reqhead(NFSX_FH(1));
3715 if (error)
3716 return (error);
3717 OSAddAtomic(1, (SInt32*)&nfsstats.rpccnt[NFSPROC_COMMIT]);
3718 nfsm_fhtom(vp, 1);
3719 nfsm_build(tl, u_long *, 3 * NFSX_UNSIGNED);
3720 txdr_hyper(&offset, tl);
3721 tl += 2;
3722 *tl = txdr_unsigned(count);
3723 nfsm_request(vp, NFSPROC_COMMIT, procp, cred, &xid);
3724 if (mrep) {
3725 nfsm_wcc_data(vp, &premtime, wccpostattr, &xid);
3726 /* XXX can we do anything useful with the wcc info? */
3727 }
3728 if (!error) {
3729 nfsm_dissect(tl, u_long *, NFSX_V3WRITEVERF);
3730 fxdr_hyper(tl, &wverf);
3731 if (wverf != nmp->nm_verf) {
3732 nmp->nm_verf = wverf;
3733 error = NFSERR_STALEWRITEVERF;
3734 }
3735 }
3736 nfsm_reqdone;
3737 return (error);
3738 }
3739
3740 static int
3741 nfs_blockmap(
3742 __unused struct vnop_blockmap_args /* {
3743 struct vnodeop_desc *a_desc;
3744 vnode_t a_vp;
3745 off_t a_foffset;
3746 size_t a_size;
3747 daddr64_t *a_bpn;
3748 size_t *a_run;
3749 void *a_poff;
3750 int a_flags;
3751 } */ *ap)
3752 {
3753 return (ENOTSUP);
3754 }
3755
3756 /*
3757 * Mmap a file
3758 *
3759 * NB Currently unsupported.
3760 */
3761 /*ARGSUSED*/
3762 static int
3763 nfs_mmap(
3764 __unused struct vnop_mmap_args /* {
3765 struct vnodeop_desc *a_desc;
3766 vnode_t a_vp;
3767 int a_fflags;
3768 kauth_cred_t a_cred;
3769 proc_t a_p;
3770 } */ *ap)
3771 {
3772
3773 return (EINVAL);
3774 }
3775
3776 /*
3777 * fsync vnode op. Just call nfs_flush() with commit == 1.
3778 */
3779 /* ARGSUSED */
3780 static int
3781 nfs_fsync(ap)
3782 struct vnop_fsync_args /* {
3783 struct vnodeop_desc *a_desc;
3784 vnode_t a_vp;
3785 int a_waitfor;
3786 vfs_context_t a_context;
3787 } */ *ap;
3788 {
3789 kauth_cred_t cred = vfs_context_ucred(ap->a_context);
3790 proc_t p = vfs_context_proc(ap->a_context);
3791 struct nfsnode *np = VTONFS(ap->a_vp);
3792 int error;
3793
3794 np->n_flag |= NWRBUSY;
3795 error = nfs_flush(ap->a_vp, ap->a_waitfor, cred, p, 0);
3796 np->n_flag &= ~NWRBUSY;
3797 return (error);
3798 }
3799
3800 int
3801 nfs_flushcommits(vnode_t vp, proc_t p, int nowait)
3802 {
3803 struct nfsnode *np = VTONFS(vp);
3804 struct nfsbuf *bp;
3805 struct nfsbuflists blist, commitlist;
3806 int error = 0, retv, wcred_set, flags;
3807 u_quad_t off, endoff, toff;
3808 u_int32_t count;
3809 kauth_cred_t wcred = NULL;
3810
3811 FSDBG_TOP(557, vp, np, 0, 0);
3812
3813 /*
3814 * A nb_flags == (NB_DELWRI | NB_NEEDCOMMIT) block has been written to the
3815 * server, but nas not been committed to stable storage on the server
3816 * yet. The byte range is worked out for as many nfsbufs as we can handle
3817 * and the commit rpc is done.
3818 */
3819 if (!LIST_EMPTY(&np->n_dirtyblkhd))
3820 np->n_flag |= NMODIFIED;
3821
3822 off = (u_quad_t)-1;
3823 endoff = 0;
3824 wcred_set = 0;
3825 LIST_INIT(&commitlist);
3826
3827 if (!VFSTONFS(vnode_mount(vp))) {
3828 error = ENXIO;
3829 goto done;
3830 }
3831 if (!NFS_ISV3(vp)) {
3832 error = EINVAL;
3833 goto done;
3834 }
3835
3836 flags = NBI_DIRTY;
3837 if (nowait)
3838 flags |= NBI_NOWAIT;
3839 lck_mtx_lock(nfs_buf_mutex);
3840 if (!nfs_buf_iterprepare(np, &blist, flags)) {
3841 while ((bp = LIST_FIRST(&blist))) {
3842 LIST_REMOVE(bp, nb_vnbufs);
3843 LIST_INSERT_HEAD(&np->n_dirtyblkhd, bp, nb_vnbufs);
3844 error = nfs_buf_acquire(bp, NBAC_NOWAIT, 0, 0);
3845 if (error)
3846 continue;
3847 if (ISSET(bp->nb_flags, NB_NEEDCOMMIT))
3848 nfs_buf_check_write_verifier(np, bp);
3849 if (((bp->nb_flags & (NB_DELWRI | NB_NEEDCOMMIT))
3850 != (NB_DELWRI | NB_NEEDCOMMIT))) {
3851 nfs_buf_drop(bp);
3852 continue;
3853 }
3854 nfs_buf_remfree(bp);
3855 lck_mtx_unlock(nfs_buf_mutex);
3856 /*
3857 * we need a upl to see if the page has been
3858 * dirtied (think mmap) since the unstable write, and
3859 * also to prevent vm from paging it during our commit rpc
3860 */
3861 if (!ISSET(bp->nb_flags, NB_PAGELIST)) {
3862 retv = nfs_buf_upl_setup(bp);
3863 if (retv) {
3864 /* unable to create upl */
3865 /* vm object must no longer exist */
3866 /* this could be fatal if we need */
3867 /* to write the data again, we'll see... */
3868 printf("nfs_flushcommits: upl create failed %d\n", retv);
3869 bp->nb_valid = bp->nb_dirty = 0;
3870 }
3871 }
3872 nfs_buf_upl_check(bp);
3873 lck_mtx_lock(nfs_buf_mutex);
3874
3875 FSDBG(557, bp, bp->nb_flags, bp->nb_valid, bp->nb_dirty);
3876 FSDBG(557, bp->nb_validoff, bp->nb_validend,
3877 bp->nb_dirtyoff, bp->nb_dirtyend);
3878
3879 /*
3880 * We used to check for dirty pages here; if there were any
3881 * we'd abort the commit and force the entire buffer to be
3882 * written again.
3883 *
3884 * Instead of doing that, we now go ahead and commit the dirty
3885 * range, and then leave the buffer around with dirty pages
3886 * that will be written out later.
3887 */
3888
3889 /*
3890 * Work out if all buffers are using the same cred
3891 * so we can deal with them all with one commit.
3892 *
3893 * XXX creds in bp's must be obtained by kauth_cred_ref on
3894 * the same original cred in order for them to be equal.
3895 */
3896 if (wcred_set == 0) {
3897 wcred = bp->nb_wcred;
3898 if (wcred == NOCRED)
3899 panic("nfs: needcommit w/out wcred");
3900 wcred_set = 1;
3901 } else if ((wcred_set == 1) && wcred != bp->nb_wcred) {
3902 wcred_set = -1;
3903 }
3904 SET(bp->nb_flags, NB_WRITEINPROG);
3905
3906 /*
3907 * A list of these buffers is kept so that the
3908 * second loop knows which buffers have actually
3909 * been committed. This is necessary, since there
3910 * may be a race between the commit rpc and new
3911 * uncommitted writes on the file.
3912 */
3913 LIST_REMOVE(bp, nb_vnbufs);
3914 LIST_INSERT_HEAD(&commitlist, bp, nb_vnbufs);
3915 toff = NBOFF(bp) + bp->nb_dirtyoff;
3916 if (toff < off)
3917 off = toff;
3918 toff += (u_quad_t)(bp->nb_dirtyend - bp->nb_dirtyoff);
3919 if (toff > endoff)
3920 endoff = toff;
3921 }
3922 nfs_buf_itercomplete(np, &blist, NBI_DIRTY);
3923 }
3924 lck_mtx_unlock(nfs_buf_mutex);
3925
3926 if (LIST_EMPTY(&commitlist)) {
3927 error = ENOBUFS;
3928 goto done;
3929 }
3930
3931 /*
3932 * Commit data on the server, as required.
3933 * If all bufs are using the same wcred, then use that with
3934 * one call for all of them, otherwise commit each one
3935 * separately.
3936 */
3937 if (wcred_set == 1) {
3938 /*
3939 * Note, it's possible the commit range could be >2^32-1.
3940 * If it is, we'll send one commit that covers the whole file.
3941 */
3942 if ((endoff - off) > 0xffffffff)
3943 count = 0;
3944 else
3945 count = (endoff - off);
3946 retv = nfs_commit(vp, off, count, wcred, p);
3947 } else {
3948 retv = 0;
3949 LIST_FOREACH(bp, &commitlist, nb_vnbufs) {
3950 toff = NBOFF(bp) + bp->nb_dirtyoff;
3951 count = bp->nb_dirtyend - bp->nb_dirtyoff;
3952 retv = nfs_commit(vp, toff, count, bp->nb_wcred, p);
3953 if (retv)
3954 break;
3955 }
3956 }
3957
3958 /*
3959 * Now, either mark the blocks I/O done or mark the
3960 * blocks dirty, depending on whether the commit
3961 * succeeded.
3962 */
3963 while ((bp = LIST_FIRST(&commitlist))) {
3964 LIST_REMOVE(bp, nb_vnbufs);
3965 FSDBG(557, bp, retv, bp->nb_flags, bp->nb_dirty);
3966 CLR(bp->nb_flags, (NB_NEEDCOMMIT | NB_WRITEINPROG));
3967 np->n_needcommitcnt--;
3968 CHECK_NEEDCOMMITCNT(np);
3969
3970 if (retv) {
3971 /* move back to dirty list */
3972 lck_mtx_lock(nfs_buf_mutex);
3973 LIST_INSERT_HEAD(&VTONFS(vp)->n_dirtyblkhd, bp, nb_vnbufs);
3974 lck_mtx_unlock(nfs_buf_mutex);
3975 nfs_buf_release(bp, 1);
3976 continue;
3977 }
3978
3979 vnode_startwrite(vp);
3980 if (ISSET(bp->nb_flags, NB_DELWRI)) {
3981 OSAddAtomic(-1, (SInt32*)&nfs_nbdwrite);
3982 NFSBUFCNTCHK(0);
3983 wakeup(&nfs_nbdwrite);
3984 }
3985 CLR(bp->nb_flags, (NB_READ|NB_DONE|NB_ERROR|NB_DELWRI));
3986 /* if block still has dirty pages, we don't want it to */
3987 /* be released in nfs_buf_iodone(). So, don't set NB_ASYNC. */
3988 if (!bp->nb_dirty)
3989 SET(bp->nb_flags, NB_ASYNC);
3990
3991 /* move to clean list */
3992 lck_mtx_lock(nfs_buf_mutex);
3993 LIST_INSERT_HEAD(&VTONFS(vp)->n_cleanblkhd, bp, nb_vnbufs);
3994 lck_mtx_unlock(nfs_buf_mutex);
3995
3996 bp->nb_dirtyoff = bp->nb_dirtyend = 0;
3997
3998 nfs_buf_iodone(bp);
3999 if (bp->nb_dirty) {
4000 /* throw it back in as a delayed write buffer */
4001 CLR(bp->nb_flags, NB_DONE);
4002 nfs_buf_write_delayed(bp, p);
4003 }
4004 }
4005
4006 done:
4007 FSDBG_BOT(557, vp, np, 0, error);
4008 return (error);
4009 }
4010
4011 /*
4012 * Flush all the blocks associated with a vnode.
4013 * Walk through the buffer pool and push any dirty pages
4014 * associated with the vnode.
4015 */
4016 int
4017 nfs_flush(
4018 vnode_t vp,
4019 int waitfor,
4020 __unused kauth_cred_t cred,
4021 proc_t p,
4022 int ignore_writeerr)
4023 {
4024 struct nfsnode *np = VTONFS(vp);
4025 struct nfsbuf *bp;
4026 struct nfsbuflists blist;
4027 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
4028 int error = 0, error2, slptimeo = 0, slpflag = 0;
4029 int flags, passone = 1;
4030
4031 FSDBG_TOP(517, vp, np, waitfor, 0);
4032
4033 if (!nmp) {
4034 error = ENXIO;
4035 goto done;
4036 }
4037 if (nmp->nm_flag & NFSMNT_INT)
4038 slpflag = PCATCH;
4039
4040 /*
4041 * On the first pass, start async/unstable writes on all
4042 * delayed write buffers. Then wait for all writes to complete
4043 * and call nfs_flushcommits() to commit any uncommitted buffers.
4044 * On all subsequent passes, start STABLE writes on any remaining
4045 * dirty buffers. Then wait for all writes to complete.
4046 */
4047 again:
4048 lck_mtx_lock(nfs_buf_mutex);
4049 FSDBG(518, LIST_FIRST(&np->n_dirtyblkhd), np->n_flag, 0, 0);
4050 if (!LIST_EMPTY(&np->n_dirtyblkhd))
4051 np->n_flag |= NMODIFIED;
4052 if (!VFSTONFS(vnode_mount(vp))) {
4053 lck_mtx_unlock(nfs_buf_mutex);
4054 error = ENXIO;
4055 goto done;
4056 }
4057
4058 /* Start/do any write(s) that are required. */
4059 if (!nfs_buf_iterprepare(np, &blist, NBI_DIRTY)) {
4060 while ((bp = LIST_FIRST(&blist))) {
4061 LIST_REMOVE(bp, nb_vnbufs);
4062 LIST_INSERT_HEAD(&np->n_dirtyblkhd, bp, nb_vnbufs);
4063 flags = (passone || (waitfor != MNT_WAIT)) ? NBAC_NOWAIT : 0;
4064 if (flags != NBAC_NOWAIT)
4065 nfs_buf_refget(bp);
4066 while ((error = nfs_buf_acquire(bp, flags, slpflag, slptimeo))) {
4067 FSDBG(524, bp, flags, bp->nb_lflags, bp->nb_flags);
4068 if (error == EBUSY)
4069 break;
4070 if (error) {
4071 error2 = nfs_sigintr(VFSTONFS(vnode_mount(vp)), NULL, p);
4072 if (error2) {
4073 if (flags != NBAC_NOWAIT)
4074 nfs_buf_refrele(bp);
4075 nfs_buf_itercomplete(np, &blist, NBI_DIRTY);
4076 lck_mtx_unlock(nfs_buf_mutex);
4077 error = error2;
4078 goto done;
4079 }
4080 if (slpflag == PCATCH) {
4081 slpflag = 0;
4082 slptimeo = 2 * hz;
4083 }
4084 }
4085 }
4086 if (flags != NBAC_NOWAIT)
4087 nfs_buf_refrele(bp);
4088 if (error == EBUSY)
4089 continue;
4090 if (!bp->nb_vp) {
4091 /* buffer is no longer valid */
4092 nfs_buf_drop(bp);
4093 continue;
4094 }
4095 if (ISSET(bp->nb_flags, NB_NEEDCOMMIT))
4096 nfs_buf_check_write_verifier(np, bp);
4097 if (!ISSET(bp->nb_flags, NB_DELWRI))
4098 panic("nfs_flush: not dirty");
4099 FSDBG(525, bp, passone, bp->nb_lflags, bp->nb_flags);
4100 if ((passone || (waitfor != MNT_WAIT)) &&
4101 ISSET(bp->nb_flags, NB_NEEDCOMMIT)) {
4102 nfs_buf_drop(bp);
4103 continue;
4104 }
4105 nfs_buf_remfree(bp);
4106 lck_mtx_unlock(nfs_buf_mutex);
4107 if (ISSET(bp->nb_flags, NB_ERROR)) {
4108 np->n_error = bp->nb_error ? bp->nb_error : EIO;
4109 np->n_flag |= NWRITEERR;
4110 nfs_buf_release(bp, 1);
4111 lck_mtx_lock(nfs_buf_mutex);
4112 continue;
4113 }
4114 SET(bp->nb_flags, NB_ASYNC);
4115 if (!passone) {
4116 /* NB_STABLE forces this to be written FILESYNC */
4117 SET(bp->nb_flags, NB_STABLE);
4118 }
4119 nfs_buf_write(bp);
4120 lck_mtx_lock(nfs_buf_mutex);
4121 }
4122 nfs_buf_itercomplete(np, &blist, NBI_DIRTY);
4123 }
4124 lck_mtx_unlock(nfs_buf_mutex);
4125
4126 if (waitfor == MNT_WAIT) {
4127 while ((error = vnode_waitforwrites(vp, 0, slpflag, slptimeo, "nfsflush"))) {
4128 error2 = nfs_sigintr(VFSTONFS(vnode_mount(vp)), NULL, p);
4129 if (error2) {
4130 error = error2;
4131 goto done;
4132 }
4133 if (slpflag == PCATCH) {
4134 slpflag = 0;
4135 slptimeo = 2 * hz;
4136 }
4137 }
4138 }
4139
4140 if (NFS_ISV3(vp)) {
4141 /* loop while it looks like there are still buffers to be */
4142 /* commited and nfs_flushcommits() seems to be handling them. */
4143 while (np->n_needcommitcnt)
4144 if (nfs_flushcommits(vp, p, 0))
4145 break;
4146 }
4147
4148 if (passone) {
4149 passone = 0;
4150 goto again;
4151 }
4152
4153 if (waitfor == MNT_WAIT) {
4154 if (!LIST_EMPTY(&np->n_dirtyblkhd))
4155 goto again;
4156 /* if we have no dirty blocks, we can clear the modified flag */
4157 np->n_flag &= ~NMODIFIED;
4158 }
4159
4160 FSDBG(526, np->n_flag, np->n_error, 0, 0);
4161 if (!ignore_writeerr && (np->n_flag & NWRITEERR)) {
4162 error = np->n_error;
4163 np->n_flag &= ~NWRITEERR;
4164 }
4165 done:
4166 FSDBG_BOT(517, vp, np, error, 0);
4167 return (error);
4168 }
4169
4170 /*
4171 * Do an nfs pathconf rpc.
4172 */
4173 int
4174 nfs_pathconfrpc(
4175 vnode_t vp,
4176 struct nfsv3_pathconf *pc,
4177 kauth_cred_t cred,
4178 proc_t procp)
4179 {
4180 mbuf_t mreq, mrep, md, mb, mb2;
4181 caddr_t bpos, dpos, cp, cp2;
4182 int32_t t1, t2;
4183 u_long *tl;
4184 u_int64_t xid;
4185 int attrflag, error = 0;
4186 struct nfsv3_pathconf *mpc;
4187
4188 /* fetch pathconf info from server */
4189 nfsm_reqhead(NFSX_FH(1));
4190 if (error)
4191 return (error);
4192 nfsm_fhtom(vp, 1);
4193 nfsm_request(vp, NFSPROC_PATHCONF, procp, cred, &xid);
4194 nfsm_postop_attr_update(vp, 1, attrflag, &xid);
4195 if (!error) {
4196 nfsm_dissect(mpc, struct nfsv3_pathconf *, NFSX_V3PATHCONF);
4197 pc->pc_linkmax = fxdr_unsigned(long, mpc->pc_linkmax);
4198 pc->pc_namemax = fxdr_unsigned(long, mpc->pc_namemax);
4199 pc->pc_chownrestricted = fxdr_unsigned(long, mpc->pc_chownrestricted);
4200 pc->pc_notrunc = fxdr_unsigned(long, mpc->pc_notrunc);
4201 pc->pc_caseinsensitive = fxdr_unsigned(long, mpc->pc_caseinsensitive);
4202 pc->pc_casepreserving = fxdr_unsigned(long, mpc->pc_casepreserving);
4203 }
4204 nfsm_reqdone;
4205
4206 return (error);
4207 }
4208
4209 void
4210 nfs_pathconf_cache(struct nfsmount *nmp, struct nfsv3_pathconf *pc)
4211 {
4212 nmp->nm_state |= NFSSTA_GOTPATHCONF;
4213 nmp->nm_fsinfo.linkmax = pc->pc_linkmax;
4214 nmp->nm_fsinfo.namemax = pc->pc_namemax;
4215 nmp->nm_fsinfo.pcflags = 0;
4216 if (pc->pc_notrunc)
4217 nmp->nm_fsinfo.pcflags |= NFSPCINFO_NOTRUNC;
4218 if (pc->pc_chownrestricted)
4219 nmp->nm_fsinfo.pcflags |= NFSPCINFO_CHOWN_RESTRICTED;
4220 if (pc->pc_caseinsensitive)
4221 nmp->nm_fsinfo.pcflags |= NFSPCINFO_CASE_INSENSITIVE;
4222 if (pc->pc_casepreserving)
4223 nmp->nm_fsinfo.pcflags |= NFSPCINFO_CASE_PRESERVING;
4224 }
4225
4226 /*
4227 * Return POSIX pathconf information applicable to nfs.
4228 *
4229 * The NFS V2 protocol doesn't support this, so just return EINVAL
4230 * for V2.
4231 */
4232 /* ARGSUSED */
4233 static int
4234 nfs_pathconf(ap)
4235 struct vnop_pathconf_args /* {
4236 struct vnodeop_desc *a_desc;
4237 vnode_t a_vp;
4238 int a_name;
4239 register_t *a_retval;
4240 vfs_context_t a_context;
4241 } */ *ap;
4242 {
4243 vnode_t vp = ap->a_vp;
4244 struct nfsmount *nmp;
4245 struct nfsv3_pathconf pc;
4246 int error = 0, cached;
4247
4248 nmp = VFSTONFS(vnode_mount(vp));
4249 if (!nmp)
4250 return (ENXIO);
4251 if (!NFS_ISV3(vp))
4252 return (EINVAL);
4253
4254 switch (ap->a_name) {
4255 case _PC_LINK_MAX:
4256 case _PC_NAME_MAX:
4257 case _PC_CHOWN_RESTRICTED:
4258 case _PC_NO_TRUNC:
4259 case _PC_CASE_SENSITIVE:
4260 case _PC_CASE_PRESERVING:
4261 break;
4262 default:
4263 /* don't bother contacting the server if we know the answer */
4264 return (EINVAL);
4265 }
4266
4267 if (!(nmp->nm_state & NFSSTA_GOTPATHCONF)) {
4268 /* no pathconf info cached */
4269 kauth_cred_t cred = vfs_context_ucred(ap->a_context);
4270 proc_t p = vfs_context_proc(ap->a_context);
4271 error = nfs_pathconfrpc(vp, &pc, cred, p);
4272 if (error)
4273 return (error);
4274 nmp = VFSTONFS(vnode_mount(vp));
4275 if (!nmp)
4276 return (ENXIO);
4277 if (!(nmp->nm_state & NFSSTA_GOTFSINFO)) {
4278 nfs_fsinfo(nmp, vp, cred, p);
4279 nmp = VFSTONFS(vnode_mount(vp));
4280 if (!nmp)
4281 return (ENXIO);
4282 }
4283 if ((nmp->nm_state & NFSSTA_GOTFSINFO) &&
4284 (nmp->nm_fsinfo.fsproperties & NFSV3FSINFO_HOMOGENEOUS)) {
4285 /* all files have the same pathconf info, */
4286 /* so cache a copy of the results */
4287 nfs_pathconf_cache(nmp, &pc);
4288 }
4289 }
4290
4291 cached = (nmp->nm_state & NFSSTA_GOTPATHCONF);
4292
4293 switch (ap->a_name) {
4294 case _PC_LINK_MAX:
4295 *ap->a_retval = cached ? nmp->nm_fsinfo.linkmax : pc.pc_linkmax;
4296 break;
4297 case _PC_NAME_MAX:
4298 *ap->a_retval = cached ? nmp->nm_fsinfo.namemax : pc.pc_namemax;
4299 break;
4300 case _PC_CHOWN_RESTRICTED:
4301 if (cached)
4302 *ap->a_retval = (nmp->nm_fsinfo.pcflags & NFSPCINFO_CHOWN_RESTRICTED) ? 1 : 0;
4303 else
4304 *ap->a_retval = pc.pc_chownrestricted;
4305 break;
4306 case _PC_NO_TRUNC:
4307 if (cached)
4308 *ap->a_retval = (nmp->nm_fsinfo.pcflags & NFSPCINFO_NOTRUNC) ? 1 : 0;
4309 else
4310 *ap->a_retval = pc.pc_notrunc;
4311 break;
4312 case _PC_CASE_SENSITIVE:
4313 if (cached)
4314 *ap->a_retval = (nmp->nm_fsinfo.pcflags & NFSPCINFO_CASE_INSENSITIVE) ? 0 : 1;
4315 else
4316 *ap->a_retval = !pc.pc_caseinsensitive;
4317 break;
4318 case _PC_CASE_PRESERVING:
4319 if (cached)
4320 *ap->a_retval = (nmp->nm_fsinfo.pcflags & NFSPCINFO_CASE_PRESERVING) ? 1 : 0;
4321 else
4322 *ap->a_retval = pc.pc_casepreserving;
4323 break;
4324 default:
4325 error = EINVAL;
4326 }
4327
4328 return (error);
4329 }
4330
4331 /*
4332 * NFS advisory byte-level locks (client)
4333 */
4334 static int
4335 nfs_advlock(ap)
4336 struct vnop_advlock_args /* {
4337 struct vnodeop_desc *a_desc;
4338 vnode_t a_vp;
4339 caddr_t a_id;
4340 int a_op;
4341 struct flock *a_fl;
4342 int a_flags;
4343 vfs_context_t a_context;
4344 } */ *ap;
4345 {
4346 return (nfs_dolock(ap));
4347 }
4348
4349 /*
4350 * write (or commit) the given NFS buffer
4351 */
4352 int
4353 nfs_buf_write(struct nfsbuf *bp)
4354 {
4355 int oldflags = bp->nb_flags, rv = 0;
4356 vnode_t vp = bp->nb_vp;
4357 struct nfsnode *np = VTONFS(vp);
4358 kauth_cred_t cr;
4359 proc_t p = current_proc(); // XXX
4360
4361 FSDBG_TOP(553, bp, NBOFF(bp), bp->nb_flags, 0);
4362
4363 if (!ISSET(bp->nb_lflags, NBL_BUSY))
4364 panic("nfs_buf_write: buffer is not busy???");
4365
4366 CLR(bp->nb_flags, (NB_READ|NB_DONE|NB_ERROR|NB_DELWRI));
4367 if (ISSET(oldflags, NB_DELWRI)) {
4368 OSAddAtomic(-1, (SInt32*)&nfs_nbdwrite);
4369 NFSBUFCNTCHK(0);
4370 wakeup(&nfs_nbdwrite);
4371 }
4372
4373 /* move to clean list */
4374 if (ISSET(oldflags, (NB_ASYNC|NB_DELWRI))) {
4375 lck_mtx_lock(nfs_buf_mutex);
4376 if (bp->nb_vnbufs.le_next != NFSNOLIST)
4377 LIST_REMOVE(bp, nb_vnbufs);
4378 LIST_INSERT_HEAD(&VTONFS(vp)->n_cleanblkhd, bp, nb_vnbufs);
4379 lck_mtx_unlock(nfs_buf_mutex);
4380 }
4381 vnode_startwrite(vp);
4382
4383 if (p && p->p_stats)
4384 p->p_stats->p_ru.ru_oublock++;
4385
4386 /*
4387 * For async requests when nfsiod(s) are running, queue the request by
4388 * calling nfs_asyncio(), otherwise just all nfs_doio() to do the request.
4389 */
4390 if (ISSET(bp->nb_flags, NB_ASYNC))
4391 p = NULL;
4392 if (ISSET(bp->nb_flags, NB_READ))
4393 cr = bp->nb_rcred;
4394 else
4395 cr = bp->nb_wcred;
4396 if (!ISSET(bp->nb_flags, NB_ASYNC) || nfs_asyncio(bp, NOCRED))
4397 rv = nfs_doio(bp, cr, p);
4398
4399 if ((oldflags & NB_ASYNC) == 0) {
4400 rv = nfs_buf_iowait(bp);
4401 /* move to clean list */
4402 if (oldflags & NB_DELWRI) {
4403 lck_mtx_lock(nfs_buf_mutex);
4404 if (bp->nb_vnbufs.le_next != NFSNOLIST)
4405 LIST_REMOVE(bp, nb_vnbufs);
4406 LIST_INSERT_HEAD(&VTONFS(vp)->n_cleanblkhd, bp, nb_vnbufs);
4407 lck_mtx_unlock(nfs_buf_mutex);
4408 }
4409 oldflags = bp->nb_flags;
4410 FSDBG_BOT(553, bp, NBOFF(bp), bp->nb_flags, rv);
4411 if (cr) {
4412 kauth_cred_ref(cr);
4413 }
4414 nfs_buf_release(bp, 1);
4415 if (ISSET(oldflags, NB_ERROR) && !(np->n_flag & NFLUSHINPROG)) {
4416 /*
4417 * There was a write error and we need to
4418 * invalidate attrs and flush buffers in
4419 * order to sync up with the server.
4420 * (if this write was extending the file,
4421 * we may no longer know the correct size)
4422 *
4423 * But we couldn't call vinvalbuf while holding
4424 * the buffer busy. So we call vinvalbuf() after
4425 * releasing the buffer.
4426 */
4427 nfs_vinvalbuf(vp, V_SAVE|V_IGNORE_WRITEERR, cr, p, 1);
4428 }
4429 if (cr)
4430 kauth_cred_rele(cr);
4431 return (rv);
4432 }
4433
4434 FSDBG_BOT(553, bp, NBOFF(bp), bp->nb_flags, rv);
4435 return (rv);
4436 }
4437
4438 /*
4439 * Read wrapper for special devices.
4440 */
4441 static int
4442 nfsspec_read(ap)
4443 struct vnop_read_args /* {
4444 struct vnodeop_desc *a_desc;
4445 vnode_t a_vp;
4446 struct uio *a_uio;
4447 int a_ioflag;
4448 vfs_context_t a_context;
4449 } */ *ap;
4450 {
4451 register struct nfsnode *np = VTONFS(ap->a_vp);
4452 struct timeval now;
4453
4454 /*
4455 * Set access flag.
4456 */
4457 np->n_flag |= NACC;
4458 microtime(&now);
4459 np->n_atim.tv_sec = now.tv_sec;
4460 np->n_atim.tv_nsec = now.tv_usec * 1000;
4461 return (VOCALL(spec_vnodeop_p, VOFFSET(vnop_read), ap));
4462 }
4463
4464 /*
4465 * Write wrapper for special devices.
4466 */
4467 static int
4468 nfsspec_write(ap)
4469 struct vnop_write_args /* {
4470 struct vnodeop_desc *a_desc;
4471 vnode_t a_vp;
4472 struct uio *a_uio;
4473 int a_ioflag;
4474 vfs_context_t a_context;
4475 } */ *ap;
4476 {
4477 register struct nfsnode *np = VTONFS(ap->a_vp);
4478 struct timeval now;
4479
4480 /*
4481 * Set update flag.
4482 */
4483 np->n_flag |= NUPD;
4484 microtime(&now);
4485 np->n_mtim.tv_sec = now.tv_sec;
4486 np->n_mtim.tv_nsec = now.tv_usec * 1000;
4487 return (VOCALL(spec_vnodeop_p, VOFFSET(vnop_write), ap));
4488 }
4489
4490 /*
4491 * Close wrapper for special devices.
4492 *
4493 * Update the times on the nfsnode then do device close.
4494 */
4495 static int
4496 nfsspec_close(ap)
4497 struct vnop_close_args /* {
4498 struct vnodeop_desc *a_desc;
4499 vnode_t a_vp;
4500 int a_fflag;
4501 vfs_context_t a_context;
4502 } */ *ap;
4503 {
4504 vnode_t vp = ap->a_vp;
4505 struct nfsnode *np = VTONFS(vp);
4506 struct vnode_attr vattr;
4507 mount_t mp;
4508
4509 if (np->n_flag & (NACC | NUPD)) {
4510 np->n_flag |= NCHG;
4511 if (!vnode_isinuse(vp, 1) && (mp = vnode_mount(vp)) && !vfs_isrdonly(mp)) {
4512 VATTR_INIT(&vattr);
4513 if (np->n_flag & NACC) {
4514 vattr.va_access_time = np->n_atim;
4515 VATTR_SET_ACTIVE(&vattr, va_access_time);
4516 }
4517 if (np->n_flag & NUPD) {
4518 vattr.va_modify_time = np->n_mtim;
4519 VATTR_SET_ACTIVE(&vattr, va_modify_time);
4520 }
4521 vnode_setattr(vp, &vattr, ap->a_context);
4522 }
4523 }
4524 return (VOCALL(spec_vnodeop_p, VOFFSET(vnop_close), ap));
4525 }
4526
4527 extern vnop_t **fifo_vnodeop_p;
4528
4529 /*
4530 * Read wrapper for fifos.
4531 */
4532 static int
4533 nfsfifo_read(ap)
4534 struct vnop_read_args /* {
4535 struct vnodeop_desc *a_desc;
4536 vnode_t a_vp;
4537 struct uio *a_uio;
4538 int a_ioflag;
4539 vfs_context_t a_context;
4540 } */ *ap;
4541 {
4542 register struct nfsnode *np = VTONFS(ap->a_vp);
4543 struct timeval now;
4544
4545 /*
4546 * Set access flag.
4547 */
4548 np->n_flag |= NACC;
4549 microtime(&now);
4550 np->n_atim.tv_sec = now.tv_sec;
4551 np->n_atim.tv_nsec = now.tv_usec * 1000;
4552 return (VOCALL(fifo_vnodeop_p, VOFFSET(vnop_read), ap));
4553 }
4554
4555 /*
4556 * Write wrapper for fifos.
4557 */
4558 static int
4559 nfsfifo_write(ap)
4560 struct vnop_write_args /* {
4561 struct vnodeop_desc *a_desc;
4562 vnode_t a_vp;
4563 struct uio *a_uio;
4564 int a_ioflag;
4565 vfs_context_t a_context;
4566 } */ *ap;
4567 {
4568 register struct nfsnode *np = VTONFS(ap->a_vp);
4569 struct timeval now;
4570
4571 /*
4572 * Set update flag.
4573 */
4574 np->n_flag |= NUPD;
4575 microtime(&now);
4576 np->n_mtim.tv_sec = now.tv_sec;
4577 np->n_mtim.tv_nsec = now.tv_usec * 1000;
4578 return (VOCALL(fifo_vnodeop_p, VOFFSET(vnop_write), ap));
4579 }
4580
4581 /*
4582 * Close wrapper for fifos.
4583 *
4584 * Update the times on the nfsnode then do fifo close.
4585 */
4586 static int
4587 nfsfifo_close(ap)
4588 struct vnop_close_args /* {
4589 struct vnodeop_desc *a_desc;
4590 vnode_t a_vp;
4591 int a_fflag;
4592 vfs_context_t a_context;
4593 } */ *ap;
4594 {
4595 vnode_t vp = ap->a_vp;
4596 struct nfsnode *np = VTONFS(vp);
4597 struct vnode_attr vattr;
4598 struct timeval now;
4599 mount_t mp;
4600
4601 if (np->n_flag & (NACC | NUPD)) {
4602 microtime(&now);
4603 if (np->n_flag & NACC) {
4604 np->n_atim.tv_sec = now.tv_sec;
4605 np->n_atim.tv_nsec = now.tv_usec * 1000;
4606 }
4607 if (np->n_flag & NUPD) {
4608 np->n_mtim.tv_sec = now.tv_sec;
4609 np->n_mtim.tv_nsec = now.tv_usec * 1000;
4610 }
4611 np->n_flag |= NCHG;
4612 if (!vnode_isinuse(vp, 1) && (mp = vnode_mount(vp)) && !vfs_isrdonly(mp)) {
4613 VATTR_INIT(&vattr);
4614 if (np->n_flag & NACC) {
4615 vattr.va_access_time = np->n_atim;
4616 VATTR_SET_ACTIVE(&vattr, va_access_time);
4617 }
4618 if (np->n_flag & NUPD) {
4619 vattr.va_modify_time = np->n_mtim;
4620 VATTR_SET_ACTIVE(&vattr, va_modify_time);
4621 }
4622 vnode_setattr(vp, &vattr, ap->a_context);
4623 }
4624 }
4625 return (VOCALL(fifo_vnodeop_p, VOFFSET(vnop_close), ap));
4626 }
4627
4628 /*ARGSUSED*/
4629 static int
4630 nfs_ioctl(
4631 __unused struct vnop_ioctl_args /* {
4632 struct vnodeop_desc *a_desc;
4633 vnode_t a_vp;
4634 u_long a_command;
4635 caddr_t a_data;
4636 int a_fflag;
4637 kauth_cred_t a_cred;
4638 proc_t a_p;
4639 } */ *ap)
4640 {
4641
4642 /*
4643 * XXX we were once bogusly enoictl() which returned this (ENOTTY).
4644 * Probably we should return ENODEV.
4645 */
4646 return (ENOTTY);
4647 }
4648
4649 /*ARGSUSED*/
4650 static int
4651 nfs_select(
4652 __unused struct vnop_select_args /* {
4653 struct vnodeop_desc *a_desc;
4654 vnode_t a_vp;
4655 int a_which;
4656 int a_fflags;
4657 kauth_cred_t a_cred;
4658 void *a_wql;
4659 proc_t a_p;
4660 } */ *ap)
4661 {
4662
4663 /*
4664 * We were once bogusly seltrue() which returns 1. Is this right?
4665 */
4666 return (1);
4667 }
4668
4669 /*
4670 * Vnode op for pagein using getblk_pages
4671 * derived from nfs_bioread()
4672 * No read aheads are started from pagein operation
4673 */
4674 static int
4675 nfs_pagein(ap)
4676 struct vnop_pagein_args /* {
4677 struct vnodeop_desc *a_desc;
4678 vnode_t a_vp;
4679 upl_t a_pl;
4680 vm_offset_t a_pl_offset;
4681 off_t a_f_offset;
4682 size_t a_size;
4683 int a_flags;
4684 vfs_context_t a_context;
4685 } */ *ap;
4686 {
4687 vnode_t vp = ap->a_vp;
4688 upl_t pl = ap->a_pl;
4689 size_t size= ap->a_size;
4690 off_t f_offset = ap->a_f_offset;
4691 vm_offset_t pl_offset = ap->a_pl_offset;
4692 int flags = ap->a_flags;
4693 kauth_cred_t cred;
4694 proc_t p;
4695 struct nfsnode *np = VTONFS(vp);
4696 int biosize, xsize, iosize;
4697 struct nfsmount *nmp;
4698 int error = 0;
4699 vm_offset_t ioaddr;
4700 struct uio auio;
4701 struct iovec_32 aiov;
4702 struct uio * uio = &auio;
4703 int nofreeupl = flags & UPL_NOCOMMIT;
4704 upl_page_info_t *plinfo;
4705
4706 FSDBG(322, vp, f_offset, size, flags);
4707 if (pl == (upl_t)NULL)
4708 panic("nfs_pagein: no upl");
4709
4710 if (UBCINVALID(vp)) {
4711 printf("nfs_pagein: invalid vnode 0x%x", (int)vp);
4712 if (!nofreeupl)
4713 (void) ubc_upl_abort(pl, 0);
4714 return (EPERM);
4715 }
4716 UBCINFOCHECK("nfs_pagein", vp);
4717
4718 if (size <= 0) {
4719 printf("nfs_pagein: invalid size %d", size);
4720 if (!nofreeupl)
4721 (void) ubc_upl_abort(pl, 0);
4722 return (EINVAL);
4723 }
4724 if (f_offset < 0 || f_offset >= (off_t)np->n_size || (f_offset & PAGE_MASK_64)) {
4725 if (!nofreeupl)
4726 ubc_upl_abort_range(pl, pl_offset, size,
4727 UPL_ABORT_ERROR | UPL_ABORT_FREE_ON_EMPTY);
4728 return (EINVAL);
4729 }
4730
4731 cred = ubc_getcred(vp);
4732 if (cred == NOCRED)
4733 cred = vfs_context_ucred(ap->a_context);
4734 p = vfs_context_proc(ap->a_context);
4735
4736 auio.uio_offset = f_offset;
4737 #if 1 /* LP64todo - can't use new segment flags until the drivers are ready */
4738 auio.uio_segflg = UIO_SYSSPACE;
4739 #else
4740 auio.uio_segflg = UIO_SYSSPACE32;
4741 #endif
4742 auio.uio_rw = UIO_READ;
4743 auio.uio_procp = p;
4744
4745 nmp = VFSTONFS(vnode_mount(vp));
4746 if (!nmp) {
4747 if (!nofreeupl)
4748 ubc_upl_abort_range(pl, pl_offset, size,
4749 UPL_ABORT_ERROR | UPL_ABORT_FREE_ON_EMPTY);
4750 return (ENXIO);
4751 }
4752 if ((nmp->nm_flag & NFSMNT_NFSV3) && !(nmp->nm_state & NFSSTA_GOTFSINFO))
4753 (void)nfs_fsinfo(nmp, vp, cred, p);
4754 biosize = vfs_statfs(vnode_mount(vp))->f_iosize;
4755
4756 plinfo = ubc_upl_pageinfo(pl);
4757 ubc_upl_map(pl, &ioaddr);
4758 ioaddr += pl_offset;
4759 xsize = size;
4760
4761 do {
4762 /*
4763 * It would be nice to be able to issue all these requests
4764 * in parallel instead of waiting for each one to complete
4765 * before sending the next one.
4766 * XXX Should we align these requests to block boundaries?
4767 */
4768 iosize = min(biosize, xsize);
4769 aiov.iov_len = iosize;
4770 aiov.iov_base = (uintptr_t)ioaddr;
4771 auio.uio_iovs.iov32p = &aiov;
4772 auio.uio_iovcnt = 1;
4773 uio_uio_resid_set(&auio, iosize);
4774
4775 FSDBG(322, uio->uio_offset, uio_uio_resid(uio), ioaddr, xsize);
4776 /*
4777 * With UBC we get here only when the file data is not in the VM
4778 * page cache, so go ahead and read in.
4779 */
4780 #ifdef UPL_DEBUG
4781 upl_ubc_alias_set(pl, current_thread(), 2);
4782 #endif /* UPL_DEBUG */
4783 OSAddAtomic(1, (SInt32*)&nfsstats.pageins);
4784
4785 error = nfs_readrpc(vp, uio, cred, p);
4786
4787 if (!error) {
4788 if (uio_uio_resid(uio)) {
4789 /*
4790 * If uio_resid > 0, there is a hole in the file
4791 * and no writes after the hole have been pushed
4792 * to the server yet... or we're at the EOF
4793 * Just zero fill the rest of the valid area.
4794 */
4795 // LP64todo - fix this
4796 int zcnt = uio_uio_resid(uio);
4797 int zoff = iosize - zcnt;
4798 bzero((char *)ioaddr + zoff, zcnt);
4799
4800 FSDBG(324, uio->uio_offset, zoff, zcnt, ioaddr);
4801 uio->uio_offset += zcnt;
4802 }
4803 ioaddr += iosize;
4804 xsize -= iosize;
4805 } else {
4806 FSDBG(322, uio->uio_offset, uio_uio_resid(uio), error, -1);
4807 }
4808
4809 nmp = VFSTONFS(vnode_mount(vp));
4810 } while (error == 0 && xsize > 0);
4811
4812 ubc_upl_unmap(pl);
4813
4814 if (!nofreeupl) {
4815 if (error)
4816 ubc_upl_abort_range(pl, pl_offset, size,
4817 UPL_ABORT_ERROR |
4818 UPL_ABORT_FREE_ON_EMPTY);
4819 else
4820 ubc_upl_commit_range(pl, pl_offset, size,
4821 UPL_COMMIT_CLEAR_DIRTY |
4822 UPL_COMMIT_FREE_ON_EMPTY);
4823 }
4824 return (error);
4825 }
4826
4827
4828 /*
4829 * Vnode op for pageout using UPL
4830 * Derived from nfs_write()
4831 * File size changes are not permitted in pageout.
4832 */
4833 static int
4834 nfs_pageout(ap)
4835 struct vnop_pageout_args /* {
4836 struct vnodeop_desc *a_desc;
4837 vnode_t a_vp;
4838 upl_t a_pl;
4839 vm_offset_t a_pl_offset;
4840 off_t a_f_offset;
4841 size_t a_size;
4842 int a_flags;
4843 vfs_context_t a_context;
4844 } */ *ap;
4845 {
4846 vnode_t vp = ap->a_vp;
4847 upl_t pl = ap->a_pl;
4848 size_t size= ap->a_size;
4849 off_t f_offset = ap->a_f_offset;
4850 vm_offset_t pl_offset = ap->a_pl_offset;
4851 int flags = ap->a_flags;
4852 struct nfsnode *np = VTONFS(vp);
4853 kauth_cred_t cred;
4854 proc_t p;
4855 struct nfsbuf *bp;
4856 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
4857 daddr64_t lbn;
4858 int error = 0, iomode;
4859 off_t off;
4860 vm_offset_t ioaddr;
4861 struct uio auio;
4862 struct iovec_32 aiov;
4863 int nofreeupl = flags & UPL_NOCOMMIT;
4864 size_t biosize, iosize, pgsize, xsize;
4865
4866 FSDBG(323, f_offset, size, pl, pl_offset);
4867
4868 if (pl == (upl_t)NULL)
4869 panic("nfs_pageout: no upl");
4870
4871 if (UBCINVALID(vp)) {
4872 printf("nfs_pageout: invalid vnode 0x%x", (int)vp);
4873 if (!nofreeupl)
4874 ubc_upl_abort(pl, 0);
4875 return (EIO);
4876 }
4877 UBCINFOCHECK("nfs_pageout", vp);
4878
4879 if (size <= 0) {
4880 printf("nfs_pageout: invalid size %d", size);
4881 if (!nofreeupl)
4882 ubc_upl_abort(pl, 0);
4883 return (EINVAL);
4884 }
4885
4886 if (!nmp) {
4887 if (!nofreeupl)
4888 ubc_upl_abort(pl, UPL_ABORT_DUMP_PAGES|UPL_ABORT_FREE_ON_EMPTY);
4889 return (ENXIO);
4890 }
4891 biosize = vfs_statfs(vnode_mount(vp))->f_iosize;
4892
4893 /*
4894 * Check to see whether the buffer is incore.
4895 * If incore and not busy, invalidate it from the cache.
4896 */
4897 for (iosize = 0; iosize < size; iosize += xsize) {
4898 off = f_offset + iosize;
4899 /* need make sure we do things on block boundaries */
4900 xsize = biosize - (off % biosize);
4901 if (off + xsize > f_offset + size)
4902 xsize = f_offset + size - off;
4903 lbn = ubc_offtoblk(vp, off);
4904 lck_mtx_lock(nfs_buf_mutex);
4905 if ((bp = nfs_buf_incore(vp, lbn))) {
4906 FSDBG(323, off, bp, bp->nb_lflags, bp->nb_flags);
4907 if (nfs_buf_acquire(bp, NBAC_NOWAIT, 0, 0)) {
4908 lck_mtx_unlock(nfs_buf_mutex);
4909 /* no panic. just tell vm we are busy */
4910 if (!nofreeupl)
4911 ubc_upl_abort(pl, 0);
4912 return (EBUSY);
4913 }
4914 if (bp->nb_dirtyend > 0) {
4915 /*
4916 * if there's a dirty range in the buffer, check
4917 * to see if it extends beyond the pageout region
4918 *
4919 * if the dirty region lies completely within the
4920 * pageout region, we just invalidate the buffer
4921 * because it's all being written out now anyway.
4922 *
4923 * if any of the dirty region lies outside the
4924 * pageout region, we'll try to clip the dirty
4925 * region to eliminate the portion that's being
4926 * paged out. If that's not possible, because
4927 * the dirty region extends before and after the
4928 * pageout region, then we'll just return EBUSY.
4929 */
4930 off_t boff, start, end;
4931 boff = NBOFF(bp);
4932 start = off;
4933 end = off + xsize;
4934 /* clip end to EOF */
4935 if (end > (off_t)np->n_size)
4936 end = np->n_size;
4937 start -= boff;
4938 end -= boff;
4939 if ((bp->nb_dirtyoff < start) &&
4940 (bp->nb_dirtyend > end)) {
4941 /* not gonna be able to clip the dirty region */
4942 FSDBG(323, vp, bp, 0xd00deebc, EBUSY);
4943 nfs_buf_drop(bp);
4944 lck_mtx_unlock(nfs_buf_mutex);
4945 if (!nofreeupl)
4946 ubc_upl_abort(pl, 0);
4947 return (EBUSY);
4948 }
4949 if ((bp->nb_dirtyoff < start) ||
4950 (bp->nb_dirtyend > end)) {
4951 /* clip dirty region, if necessary */
4952 if (bp->nb_dirtyoff < start)
4953 bp->nb_dirtyend = min(bp->nb_dirtyend, start);
4954 if (bp->nb_dirtyend > end)
4955 bp->nb_dirtyoff = max(bp->nb_dirtyoff, end);
4956 FSDBG(323, bp, bp->nb_dirtyoff, bp->nb_dirtyend, 0xd00dee00);
4957 /* we're leaving this block dirty */
4958 nfs_buf_drop(bp);
4959 lck_mtx_unlock(nfs_buf_mutex);
4960 continue;
4961 }
4962 }
4963 nfs_buf_remfree(bp);
4964 lck_mtx_unlock(nfs_buf_mutex);
4965 SET(bp->nb_flags, NB_INVAL);
4966 if (ISSET(bp->nb_flags, NB_NEEDCOMMIT)) {
4967 CLR(bp->nb_flags, NB_NEEDCOMMIT);
4968 np->n_needcommitcnt--;
4969 CHECK_NEEDCOMMITCNT(np);
4970 }
4971 nfs_buf_release(bp, 1);
4972 } else {
4973 lck_mtx_unlock(nfs_buf_mutex);
4974 }
4975 }
4976
4977 cred = ubc_getcred(vp);
4978 if (cred == NOCRED)
4979 cred = vfs_context_ucred(ap->a_context);
4980 p = vfs_context_proc(ap->a_context);
4981
4982 if (np->n_flag & NWRITEERR) {
4983 np->n_flag &= ~NWRITEERR;
4984 if (!nofreeupl)
4985 ubc_upl_abort_range(pl, pl_offset, size,
4986 UPL_ABORT_FREE_ON_EMPTY);
4987 return (np->n_error);
4988 }
4989 if ((nmp->nm_flag & NFSMNT_NFSV3) && !(nmp->nm_state & NFSSTA_GOTFSINFO))
4990 nfs_fsinfo(nmp, vp, cred, p);
4991
4992 if (f_offset < 0 || f_offset >= (off_t)np->n_size ||
4993 f_offset & PAGE_MASK_64 || size & PAGE_MASK_64) {
4994 if (!nofreeupl)
4995 ubc_upl_abort_range(pl, pl_offset, size,
4996 UPL_ABORT_FREE_ON_EMPTY);
4997 return (EINVAL);
4998 }
4999
5000 ubc_upl_map(pl, &ioaddr);
5001 ioaddr += pl_offset;
5002
5003 if ((u_quad_t)f_offset + size > np->n_size)
5004 xsize = np->n_size - f_offset;
5005 else
5006 xsize = size;
5007
5008 pgsize = round_page_64(xsize);
5009 if (size > pgsize) {
5010 if (!nofreeupl)
5011 ubc_upl_abort_range(pl, pl_offset + pgsize,
5012 size - pgsize,
5013 UPL_ABORT_FREE_ON_EMPTY);
5014 }
5015
5016 /*
5017 * check for partial page and clear the
5018 * contents past end of the file before
5019 * releasing it in the VM page cache
5020 */
5021 if ((u_quad_t)f_offset < np->n_size && (u_quad_t)f_offset + size > np->n_size) {
5022 size_t io = np->n_size - f_offset;
5023 bzero((caddr_t)(ioaddr + io), size - io);
5024 FSDBG(321, np->n_size, f_offset, f_offset + io, size - io);
5025 }
5026
5027 auio.uio_offset = f_offset;
5028 #if 1 /* LP64todo - can't use new segment flags until the drivers are ready */
5029 auio.uio_segflg = UIO_SYSSPACE;
5030 #else
5031 auio.uio_segflg = UIO_SYSSPACE32;
5032 #endif
5033 auio.uio_rw = UIO_READ;
5034 auio.uio_procp = p;
5035
5036 do {
5037 /*
5038 * It would be nice to be able to issue all these requests
5039 * in parallel instead of waiting for each one to complete
5040 * before sending the next one.
5041 * XXX Should we align these requests to block boundaries?
5042 */
5043 iosize = min(biosize, xsize);
5044 uio_uio_resid_set(&auio, iosize);
5045 aiov.iov_len = iosize;
5046 aiov.iov_base = (uintptr_t)ioaddr;
5047 auio.uio_iovs.iov32p = &aiov;
5048 auio.uio_iovcnt = 1;
5049
5050 FSDBG(323, auio.uio_offset, uio_uio_resid(&auio), ioaddr, xsize);
5051 OSAddAtomic(1, (SInt32*)&nfsstats.pageouts);
5052
5053 vnode_startwrite(vp);
5054
5055 /* NMODIFIED would be set here if doing unstable writes */
5056 iomode = NFSV3WRITE_FILESYNC;
5057 error = nfs_writerpc(vp, &auio, cred, p, &iomode, NULL);
5058 vnode_writedone(vp);
5059 if (error)
5060 goto cleanup;
5061 /* Note: no need to check uio_resid, because */
5062 /* it'll only be set if there was an error. */
5063 ioaddr += iosize;
5064 xsize -= iosize;
5065 } while (xsize > 0);
5066
5067 cleanup:
5068 ubc_upl_unmap(pl);
5069 /*
5070 * We've had several different solutions on what to do when the pageout
5071 * gets an error. If we don't handle it, and return an error to the
5072 * caller, vm, it will retry . This can end in endless looping
5073 * between vm and here doing retries of the same page. Doing a dump
5074 * back to vm, will get it out of vm's knowledge and we lose whatever
5075 * data existed. This is risky, but in some cases necessary. For
5076 * example, the initial fix here was to do that for ESTALE. In that case
5077 * the server is telling us that the file is no longer the same. We
5078 * would not want to keep paging out to that. We also saw some 151
5079 * errors from Auspex server and NFSv3 can return errors higher than
5080 * ELAST. Those along with NFS known server errors we will "dump" from
5081 * vm. Errors we don't expect to occur, we dump and log for further
5082 * analysis. Errors that could be transient, networking ones,
5083 * we let vm "retry". Lastly, errors that we retry, but may have potential
5084 * to storm the network, we "retrywithsleep". "sever" will be used in
5085 * in the future to dump all pages of object for cases like ESTALE.
5086 * All this is the basis for the states returned and first guesses on
5087 * error handling. Tweaking expected as more statistics are gathered.
5088 * Note, in the long run we may need another more robust solution to
5089 * have some kind of persistant store when the vm cannot dump nor keep
5090 * retrying as a solution, but this would be a file architectural change
5091 */
5092
5093 if (!nofreeupl) { /* otherwise stacked file system has to handle this */
5094 if (error) {
5095 int abortflags = 0;
5096 short action = nfs_pageouterrorhandler(error);
5097
5098 switch (action) {
5099 case DUMP:
5100 abortflags = UPL_ABORT_DUMP_PAGES|UPL_ABORT_FREE_ON_EMPTY;
5101 break;
5102 case DUMPANDLOG:
5103 abortflags = UPL_ABORT_DUMP_PAGES|UPL_ABORT_FREE_ON_EMPTY;
5104 if (error <= ELAST &&
5105 (errorcount[error] % 100 == 0))
5106 printf("nfs_pageout: unexpected error %d. dumping vm page\n", error);
5107 errorcount[error]++;
5108 break;
5109 case RETRY:
5110 abortflags = UPL_ABORT_FREE_ON_EMPTY;
5111 break;
5112 case RETRYWITHSLEEP:
5113 abortflags = UPL_ABORT_FREE_ON_EMPTY;
5114 /* pri unused. PSOCK for placeholder. */
5115 tsleep(&lbolt, PSOCK, "nfspageout", 0);
5116 break;
5117 case SEVER: /* not implemented */
5118 default:
5119 printf("nfs_pageout: action %d not expected\n", action);
5120 break;
5121 }
5122
5123 ubc_upl_abort_range(pl, pl_offset, size, abortflags);
5124 /* return error in all cases above */
5125
5126 } else
5127 ubc_upl_commit_range(pl, pl_offset, pgsize,
5128 UPL_COMMIT_CLEAR_DIRTY |
5129 UPL_COMMIT_FREE_ON_EMPTY);
5130 }
5131 return (error);
5132 }
5133
5134 /* Blktooff derives file offset given a logical block number */
5135 static int
5136 nfs_blktooff(ap)
5137 struct vnop_blktooff_args /* {
5138 struct vnodeop_desc *a_desc;
5139 vnode_t a_vp;
5140 daddr64_t a_lblkno;
5141 off_t *a_offset;
5142 } */ *ap;
5143 {
5144 int biosize;
5145 vnode_t vp = ap->a_vp;
5146 mount_t mp = vnode_mount(vp);
5147
5148 if (!mp)
5149 return (ENXIO);
5150
5151 biosize = vfs_statfs(mp)->f_iosize;
5152
5153 *ap->a_offset = (off_t)(ap->a_lblkno * biosize);
5154
5155 return (0);
5156 }
5157
5158 static int
5159 nfs_offtoblk(ap)
5160 struct vnop_offtoblk_args /* {
5161 struct vnodeop_desc *a_desc;
5162 vnode_t a_vp;
5163 off_t a_offset;
5164 daddr64_t *a_lblkno;
5165 } */ *ap;
5166 {
5167 int biosize;
5168 vnode_t vp = ap->a_vp;
5169 mount_t mp = vnode_mount(vp);
5170
5171 if (!mp)
5172 return (ENXIO);
5173
5174 biosize = vfs_statfs(mp)->f_iosize;
5175
5176 *ap->a_lblkno = (daddr64_t)(ap->a_offset / biosize);
5177
5178 return (0);
5179 }
5180
mirror of XNU