1 /*-
2 * Copyright (c) 1989, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * This code is derived from software contributed to Berkeley by
6 * Rick Macklem at The University of Guelph.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 4. Neither the name of the University nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 *
32 */
33
34 #include <sys/cdefs.h>
35 __FBSDID("$FreeBSD: releng/10.4/sys/fs/nfsclient/nfs_clrpcops.c 321634 2017-07-27 23:15:24Z rmacklem $");
36
37 /*
38 * Rpc op calls, generally called from the vnode op calls or through the
39 * buffer cache, for NFS v2, 3 and 4.
40 * These do not normally make any changes to vnode arguments or use
41 * structures that might change between the VFS variants. The returned
42 * arguments are all at the end, after the NFSPROC_T *p one.
43 */
44
45 #ifndef APPLEKEXT
46 #include "opt_inet6.h"
47
48 #include <fs/nfs/nfsport.h>
49 #include <sys/sysctl.h>
50
51 SYSCTL_DECL(_vfs_nfs);
52
53 static int nfsignore_eexist = 0;
54 SYSCTL_INT(_vfs_nfs, OID_AUTO, ignore_eexist, CTLFLAG_RW,
55 &nfsignore_eexist, 0, "NFS ignore EEXIST replies for mkdir/symlink");
56
57 /*
58 * Global variables
59 */
60 extern int nfs_numnfscbd;
61 extern struct timeval nfsboottime;
62 extern u_int32_t newnfs_false, newnfs_true;
63 extern nfstype nfsv34_type[9];
64 extern int nfsrv_useacl;
65 extern char nfsv4_callbackaddr[INET6_ADDRSTRLEN];
66 extern int nfscl_debuglevel;
67 NFSCLSTATEMUTEX;
68 int nfstest_outofseq = 0;
69 int nfscl_assumeposixlocks = 1;
70 int nfscl_enablecallb = 0;
71 short nfsv4_cbport = NFSV4_CBPORT;
72 int nfstest_openallsetattr = 0;
73 #endif /* !APPLEKEXT */
74
75 #define DIRHDSIZ (sizeof (struct dirent) - (MAXNAMLEN + 1))
76
77 /*
78 * nfscl_getsameserver() can return one of three values:
79 * NFSDSP_USETHISSESSION - Use this session for the DS.
80 * NFSDSP_SEQTHISSESSION - Use the nfsclds_sequence field of this dsp for new
81 * session.
82 * NFSDSP_NOTFOUND - No matching server was found.
83 */
84 enum nfsclds_state {
85 NFSDSP_USETHISSESSION = 0,
86 NFSDSP_SEQTHISSESSION = 1,
87 NFSDSP_NOTFOUND = 2,
88 };
89
90 static int nfsrpc_setattrrpc(vnode_t , struct vattr *, nfsv4stateid_t *,
91 struct ucred *, NFSPROC_T *, struct nfsvattr *, int *, void *);
92 static int nfsrpc_readrpc(vnode_t , struct uio *, struct ucred *,
93 nfsv4stateid_t *, NFSPROC_T *, struct nfsvattr *, int *, void *);
94 static int nfsrpc_writerpc(vnode_t , struct uio *, int *, int *,
95 struct ucred *, nfsv4stateid_t *, NFSPROC_T *, struct nfsvattr *, int *,
96 void *);
97 static int nfsrpc_createv23(vnode_t , char *, int, struct vattr *,
98 nfsquad_t, int, struct ucred *, NFSPROC_T *, struct nfsvattr *,
99 struct nfsvattr *, struct nfsfh **, int *, int *, void *);
100 static int nfsrpc_createv4(vnode_t , char *, int, struct vattr *,
101 nfsquad_t, int, struct nfsclowner *, struct nfscldeleg **, struct ucred *,
102 NFSPROC_T *, struct nfsvattr *, struct nfsvattr *, struct nfsfh **, int *,
103 int *, void *, int *);
104 static int nfsrpc_locku(struct nfsrv_descript *, struct nfsmount *,
105 struct nfscllockowner *, u_int64_t, u_int64_t,
106 u_int32_t, struct ucred *, NFSPROC_T *, int);
107 static int nfsrpc_setaclrpc(vnode_t, struct ucred *, NFSPROC_T *,
108 struct acl *, nfsv4stateid_t *, void *);
109 static int nfsrpc_getlayout(struct nfsmount *, vnode_t, struct nfsfh *, int,
110 uint32_t *, nfsv4stateid_t *, uint64_t, struct nfscllayout **,
111 struct ucred *, NFSPROC_T *);
112 static int nfsrpc_fillsa(struct nfsmount *, struct sockaddr_storage *,
113 struct nfsclds **, NFSPROC_T *);
114 static void nfscl_initsessionslots(struct nfsclsession *);
115 static int nfscl_doflayoutio(vnode_t, struct uio *, int *, int *, int *,
116 nfsv4stateid_t *, int, struct nfscldevinfo *, struct nfscllayout *,
117 struct nfsclflayout *, uint64_t, uint64_t, int, struct ucred *,
118 NFSPROC_T *);
119 static int nfsrpc_readds(vnode_t, struct uio *, nfsv4stateid_t *, int *,
120 struct nfsclds *, uint64_t, int, struct nfsfh *, struct ucred *,
121 NFSPROC_T *);
122 static int nfsrpc_writeds(vnode_t, struct uio *, int *, int *,
123 nfsv4stateid_t *, struct nfsclds *, uint64_t, int,
124 struct nfsfh *, int, struct ucred *, NFSPROC_T *);
125 static enum nfsclds_state nfscl_getsameserver(struct nfsmount *,
126 struct nfsclds *, struct nfsclds **);
127 static int nfsrpc_commitds(vnode_t, uint64_t, int, struct nfsclds *,
128 struct nfsfh *, struct ucred *, NFSPROC_T *);
129
130 /*
131 * nfs null call from vfs.
132 */
133 APPLESTATIC int
134 nfsrpc_null(vnode_t vp, struct ucred *cred, NFSPROC_T *p)
135 {
136 int error;
137 struct nfsrv_descript nfsd, *nd = &nfsd;
138
139 NFSCL_REQSTART(nd, NFSPROC_NULL, vp);
140 error = nfscl_request(nd, vp, p, cred, NULL);
141 if (nd->nd_repstat && !error)
142 error = nd->nd_repstat;
143 mbuf_freem(nd->nd_mrep);
144 return (error);
145 }
146
147 /*
148 * nfs access rpc op.
149 * For nfs version 3 and 4, use the access rpc to check accessibility. If file
150 * modes are changed on the server, accesses might still fail later.
151 */
152 APPLESTATIC int
153 nfsrpc_access(vnode_t vp, int acmode, struct ucred *cred,
154 NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp)
155 {
156 int error;
157 u_int32_t mode, rmode;
158
159 if (acmode & VREAD)
160 mode = NFSACCESS_READ;
161 else
162 mode = 0;
163 if (vnode_vtype(vp) == VDIR) {
164 if (acmode & VWRITE)
165 mode |= (NFSACCESS_MODIFY | NFSACCESS_EXTEND |
166 NFSACCESS_DELETE);
167 if (acmode & VEXEC)
168 mode |= NFSACCESS_LOOKUP;
169 } else {
170 if (acmode & VWRITE)
171 mode |= (NFSACCESS_MODIFY | NFSACCESS_EXTEND);
172 if (acmode & VEXEC)
173 mode |= NFSACCESS_EXECUTE;
174 }
175
176 /*
177 * Now, just call nfsrpc_accessrpc() to do the actual RPC.
178 */
179 error = nfsrpc_accessrpc(vp, mode, cred, p, nap, attrflagp, &rmode,
180 NULL);
181
182 /*
183 * The NFS V3 spec does not clarify whether or not
184 * the returned access bits can be a superset of
185 * the ones requested, so...
186 */
187 if (!error && (rmode & mode) != mode)
188 error = EACCES;
189 return (error);
190 }
191
192 /*
193 * The actual rpc, separated out for Darwin.
194 */
195 APPLESTATIC int
196 nfsrpc_accessrpc(vnode_t vp, u_int32_t mode, struct ucred *cred,
197 NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp, u_int32_t *rmodep,
198 void *stuff)
199 {
200 u_int32_t *tl;
201 u_int32_t supported, rmode;
202 int error;
203 struct nfsrv_descript nfsd, *nd = &nfsd;
204 nfsattrbit_t attrbits;
205
206 *attrflagp = 0;
207 supported = mode;
208 NFSCL_REQSTART(nd, NFSPROC_ACCESS, vp);
209 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
210 *tl = txdr_unsigned(mode);
211 if (nd->nd_flag & ND_NFSV4) {
212 /*
213 * And do a Getattr op.
214 */
215 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
216 *tl = txdr_unsigned(NFSV4OP_GETATTR);
217 NFSGETATTR_ATTRBIT(&attrbits);
218 (void) nfsrv_putattrbit(nd, &attrbits);
219 }
220 error = nfscl_request(nd, vp, p, cred, stuff);
221 if (error)
222 return (error);
223 if (nd->nd_flag & ND_NFSV3) {
224 error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
225 if (error)
226 goto nfsmout;
227 }
228 if (!nd->nd_repstat) {
229 if (nd->nd_flag & ND_NFSV4) {
230 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
231 supported = fxdr_unsigned(u_int32_t, *tl++);
232 } else {
233 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
234 }
235 rmode = fxdr_unsigned(u_int32_t, *tl);
236 if (nd->nd_flag & ND_NFSV4)
237 error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
238
239 /*
240 * It's not obvious what should be done about
241 * unsupported access modes. For now, be paranoid
242 * and clear the unsupported ones.
243 */
244 rmode &= supported;
245 *rmodep = rmode;
246 } else
247 error = nd->nd_repstat;
248 nfsmout:
249 mbuf_freem(nd->nd_mrep);
250 return (error);
251 }
252
253 /*
254 * nfs open rpc
255 */
256 APPLESTATIC int
257 nfsrpc_open(vnode_t vp, int amode, struct ucred *cred, NFSPROC_T *p)
258 {
259 struct nfsclopen *op;
260 struct nfscldeleg *dp;
261 struct nfsfh *nfhp;
262 struct nfsnode *np = VTONFS(vp);
263 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
264 u_int32_t mode, clidrev;
265 int ret, newone, error, expireret = 0, retrycnt;
266
267 /*
268 * For NFSv4, Open Ops are only done on Regular Files.
269 */
270 if (vnode_vtype(vp) != VREG)
271 return (0);
272 mode = 0;
273 if (amode & FREAD)
274 mode |= NFSV4OPEN_ACCESSREAD;
275 if (amode & FWRITE)
276 mode |= NFSV4OPEN_ACCESSWRITE;
277 nfhp = np->n_fhp;
278
279 retrycnt = 0;
280 #ifdef notdef
281 { char name[100]; int namel;
282 namel = (np->n_v4->n4_namelen < 100) ? np->n_v4->n4_namelen : 99;
283 bcopy(NFS4NODENAME(np->n_v4), name, namel);
284 name[namel] = '\0';
285 printf("rpcopen p=0x%x name=%s",p->p_pid,name);
286 if (nfhp->nfh_len > 0) printf(" fh=0x%x\n",nfhp->nfh_fh[12]);
287 else printf(" fhl=0\n");
288 }
289 #endif
290 do {
291 dp = NULL;
292 error = nfscl_open(vp, nfhp->nfh_fh, nfhp->nfh_len, mode, 1,
293 cred, p, NULL, &op, &newone, &ret, 1);
294 if (error) {
295 return (error);
296 }
297 if (nmp->nm_clp != NULL)
298 clidrev = nmp->nm_clp->nfsc_clientidrev;
299 else
300 clidrev = 0;
301 if (ret == NFSCLOPEN_DOOPEN) {
302 if (np->n_v4 != NULL) {
303 error = nfsrpc_openrpc(nmp, vp, np->n_v4->n4_data,
304 np->n_v4->n4_fhlen, np->n_fhp->nfh_fh,
305 np->n_fhp->nfh_len, mode, op,
306 NFS4NODENAME(np->n_v4), np->n_v4->n4_namelen, &dp,
307 0, 0x0, cred, p, 0, 0);
308 if (dp != NULL) {
309 #ifdef APPLE
310 OSBitAndAtomic((int32_t)~NDELEGMOD, (UInt32 *)&np->n_flag);
311 #else
312 NFSLOCKNODE(np);
313 np->n_flag &= ~NDELEGMOD;
314 /*
315 * Invalidate the attribute cache, so that
316 * attributes that pre-date the issue of a
317 * delegation are not cached, since the
318 * cached attributes will remain valid while
319 * the delegation is held.
320 */
321 NFSINVALATTRCACHE(np);
322 NFSUNLOCKNODE(np);
323 #endif
324 (void) nfscl_deleg(nmp->nm_mountp,
325 op->nfso_own->nfsow_clp,
326 nfhp->nfh_fh, nfhp->nfh_len, cred, p, &dp);
327 }
328 } else {
329 error = EIO;
330 }
331 newnfs_copyincred(cred, &op->nfso_cred);
332 } else if (ret == NFSCLOPEN_SETCRED)
333 /*
334 * This is a new local open on a delegation. It needs
335 * to have credentials so that an open can be done
336 * against the server during recovery.
337 */
338 newnfs_copyincred(cred, &op->nfso_cred);
339
340 /*
341 * nfso_opencnt is the count of how many VOP_OPEN()s have
342 * been done on this Open successfully and a VOP_CLOSE()
343 * is expected for each of these.
344 * If error is non-zero, don't increment it, since the Open
345 * hasn't succeeded yet.
346 */
347 if (!error)
348 op->nfso_opencnt++;
349 nfscl_openrelease(nmp, op, error, newone);
350 if (error == NFSERR_GRACE || error == NFSERR_STALECLIENTID ||
351 error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
352 error == NFSERR_BADSESSION) {
353 (void) nfs_catnap(PZERO, error, "nfs_open");
354 } else if ((error == NFSERR_EXPIRED || error == NFSERR_BADSTATEID)
355 && clidrev != 0) {
356 expireret = nfscl_hasexpired(nmp->nm_clp, clidrev, p);
357 retrycnt++;
358 }
359 } while (error == NFSERR_GRACE || error == NFSERR_STALECLIENTID ||
360 error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
361 error == NFSERR_BADSESSION ||
362 ((error == NFSERR_EXPIRED || error == NFSERR_BADSTATEID) &&
363 expireret == 0 && clidrev != 0 && retrycnt < 4));
364 if (error && retrycnt >= 4)
365 error = EIO;
366 return (error);
367 }
368
369 /*
370 * the actual open rpc
371 */
372 APPLESTATIC int
373 nfsrpc_openrpc(struct nfsmount *nmp, vnode_t vp, u_int8_t *nfhp, int fhlen,
374 u_int8_t *newfhp, int newfhlen, u_int32_t mode, struct nfsclopen *op,
375 u_int8_t *name, int namelen, struct nfscldeleg **dpp,
376 int reclaim, u_int32_t delegtype, struct ucred *cred, NFSPROC_T *p,
377 int syscred, int recursed)
378 {
379 u_int32_t *tl;
380 struct nfsrv_descript nfsd, *nd = &nfsd;
381 struct nfscldeleg *dp, *ndp = NULL;
382 struct nfsvattr nfsva;
383 u_int32_t rflags, deleg;
384 nfsattrbit_t attrbits;
385 int error, ret, acesize, limitby;
386 struct nfsclsession *tsep;
387
388 dp = *dpp;
389 *dpp = NULL;
390 nfscl_reqstart(nd, NFSPROC_OPEN, nmp, nfhp, fhlen, NULL, NULL);
391 NFSM_BUILD(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
392 *tl++ = txdr_unsigned(op->nfso_own->nfsow_seqid);
393 *tl++ = txdr_unsigned(mode & NFSV4OPEN_ACCESSBOTH);
394 *tl++ = txdr_unsigned((mode >> NFSLCK_SHIFT) & NFSV4OPEN_DENYBOTH);
395 tsep = nfsmnt_mdssession(nmp);
396 *tl++ = tsep->nfsess_clientid.lval[0];
397 *tl = tsep->nfsess_clientid.lval[1];
398 (void) nfsm_strtom(nd, op->nfso_own->nfsow_owner, NFSV4CL_LOCKNAMELEN);
399 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
400 *tl++ = txdr_unsigned(NFSV4OPEN_NOCREATE);
401 if (reclaim) {
402 *tl = txdr_unsigned(NFSV4OPEN_CLAIMPREVIOUS);
403 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
404 *tl = txdr_unsigned(delegtype);
405 } else {
406 if (dp != NULL) {
407 *tl = txdr_unsigned(NFSV4OPEN_CLAIMDELEGATECUR);
408 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID);
409 if (NFSHASNFSV4N(nmp))
410 *tl++ = 0;
411 else
412 *tl++ = dp->nfsdl_stateid.seqid;
413 *tl++ = dp->nfsdl_stateid.other[0];
414 *tl++ = dp->nfsdl_stateid.other[1];
415 *tl = dp->nfsdl_stateid.other[2];
416 } else {
417 *tl = txdr_unsigned(NFSV4OPEN_CLAIMNULL);
418 }
419 (void) nfsm_strtom(nd, name, namelen);
420 }
421 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
422 *tl = txdr_unsigned(NFSV4OP_GETATTR);
423 NFSZERO_ATTRBIT(&attrbits);
424 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_CHANGE);
425 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_TIMEMODIFY);
426 (void) nfsrv_putattrbit(nd, &attrbits);
427 if (syscred)
428 nd->nd_flag |= ND_USEGSSNAME;
429 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, vp, p, cred,
430 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
431 if (error)
432 return (error);
433 NFSCL_INCRSEQID(op->nfso_own->nfsow_seqid, nd);
434 if (!nd->nd_repstat) {
435 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID +
436 6 * NFSX_UNSIGNED);
437 op->nfso_stateid.seqid = *tl++;
438 op->nfso_stateid.other[0] = *tl++;
439 op->nfso_stateid.other[1] = *tl++;
440 op->nfso_stateid.other[2] = *tl;
441 rflags = fxdr_unsigned(u_int32_t, *(tl + 6));
442 error = nfsrv_getattrbits(nd, &attrbits, NULL, NULL);
443 if (error)
444 goto nfsmout;
445 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
446 deleg = fxdr_unsigned(u_int32_t, *tl);
447 if (deleg == NFSV4OPEN_DELEGATEREAD ||
448 deleg == NFSV4OPEN_DELEGATEWRITE) {
449 if (!(op->nfso_own->nfsow_clp->nfsc_flags &
450 NFSCLFLAGS_FIRSTDELEG))
451 op->nfso_own->nfsow_clp->nfsc_flags |=
452 (NFSCLFLAGS_FIRSTDELEG | NFSCLFLAGS_GOTDELEG);
453 MALLOC(ndp, struct nfscldeleg *,
454 sizeof (struct nfscldeleg) + newfhlen,
455 M_NFSCLDELEG, M_WAITOK);
456 LIST_INIT(&ndp->nfsdl_owner);
457 LIST_INIT(&ndp->nfsdl_lock);
458 ndp->nfsdl_clp = op->nfso_own->nfsow_clp;
459 ndp->nfsdl_fhlen = newfhlen;
460 NFSBCOPY(newfhp, ndp->nfsdl_fh, newfhlen);
461 newnfs_copyincred(cred, &ndp->nfsdl_cred);
462 nfscl_lockinit(&ndp->nfsdl_rwlock);
463 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID +
464 NFSX_UNSIGNED);
465 ndp->nfsdl_stateid.seqid = *tl++;
466 ndp->nfsdl_stateid.other[0] = *tl++;
467 ndp->nfsdl_stateid.other[1] = *tl++;
468 ndp->nfsdl_stateid.other[2] = *tl++;
469 ret = fxdr_unsigned(int, *tl);
470 if (deleg == NFSV4OPEN_DELEGATEWRITE) {
471 ndp->nfsdl_flags = NFSCLDL_WRITE;
472 /*
473 * Indicates how much the file can grow.
474 */
475 NFSM_DISSECT(tl, u_int32_t *,
476 3 * NFSX_UNSIGNED);
477 limitby = fxdr_unsigned(int, *tl++);
478 switch (limitby) {
479 case NFSV4OPEN_LIMITSIZE:
480 ndp->nfsdl_sizelimit = fxdr_hyper(tl);
481 break;
482 case NFSV4OPEN_LIMITBLOCKS:
483 ndp->nfsdl_sizelimit =
484 fxdr_unsigned(u_int64_t, *tl++);
485 ndp->nfsdl_sizelimit *=
486 fxdr_unsigned(u_int64_t, *tl);
487 break;
488 default:
489 error = NFSERR_BADXDR;
490 goto nfsmout;
491 };
492 } else {
493 ndp->nfsdl_flags = NFSCLDL_READ;
494 }
495 if (ret)
496 ndp->nfsdl_flags |= NFSCLDL_RECALL;
497 error = nfsrv_dissectace(nd, &ndp->nfsdl_ace, &ret,
498 &acesize, p);
499 if (error)
500 goto nfsmout;
501 } else if (deleg != NFSV4OPEN_DELEGATENONE) {
502 error = NFSERR_BADXDR;
503 goto nfsmout;
504 }
505 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
506 error = nfsv4_loadattr(nd, NULL, &nfsva, NULL,
507 NULL, 0, NULL, NULL, NULL, NULL, NULL, 0,
508 NULL, NULL, NULL, p, cred);
509 if (error)
510 goto nfsmout;
511 if (ndp != NULL) {
512 ndp->nfsdl_change = nfsva.na_filerev;
513 ndp->nfsdl_modtime = nfsva.na_mtime;
514 ndp->nfsdl_flags |= NFSCLDL_MODTIMESET;
515 }
516 if (!reclaim && (rflags & NFSV4OPEN_RESULTCONFIRM)) {
517 do {
518 ret = nfsrpc_openconfirm(vp, newfhp, newfhlen, op,
519 cred, p);
520 if (ret == NFSERR_DELAY)
521 (void) nfs_catnap(PZERO, ret, "nfs_open");
522 } while (ret == NFSERR_DELAY);
523 error = ret;
524 }
525 if ((rflags & NFSV4OPEN_LOCKTYPEPOSIX) ||
526 nfscl_assumeposixlocks)
527 op->nfso_posixlock = 1;
528 else
529 op->nfso_posixlock = 0;
530
531 /*
532 * If the server is handing out delegations, but we didn't
533 * get one because an OpenConfirm was required, try the
534 * Open again, to get a delegation. This is a harmless no-op,
535 * from a server's point of view.
536 */
537 if (!reclaim && (rflags & NFSV4OPEN_RESULTCONFIRM) &&
538 (op->nfso_own->nfsow_clp->nfsc_flags & NFSCLFLAGS_GOTDELEG)
539 && !error && dp == NULL && ndp == NULL && !recursed) {
540 do {
541 ret = nfsrpc_openrpc(nmp, vp, nfhp, fhlen, newfhp,
542 newfhlen, mode, op, name, namelen, &ndp, 0, 0x0,
543 cred, p, syscred, 1);
544 if (ret == NFSERR_DELAY)
545 (void) nfs_catnap(PZERO, ret, "nfs_open2");
546 } while (ret == NFSERR_DELAY);
547 if (ret) {
548 if (ndp != NULL)
549 FREE((caddr_t)ndp, M_NFSCLDELEG);
550 if (ret == NFSERR_STALECLIENTID ||
551 ret == NFSERR_STALEDONTRECOVER ||
552 ret == NFSERR_BADSESSION)
553 error = ret;
554 }
555 }
556 }
557 if (nd->nd_repstat != 0 && error == 0)
558 error = nd->nd_repstat;
559 if (error == NFSERR_STALECLIENTID)
560 nfscl_initiate_recovery(op->nfso_own->nfsow_clp);
561 nfsmout:
562 if (!error)
563 *dpp = ndp;
564 else if (ndp != NULL)
565 FREE((caddr_t)ndp, M_NFSCLDELEG);
566 mbuf_freem(nd->nd_mrep);
567 return (error);
568 }
569
570 /*
571 * open downgrade rpc
572 */
573 APPLESTATIC int
574 nfsrpc_opendowngrade(vnode_t vp, u_int32_t mode, struct nfsclopen *op,
575 struct ucred *cred, NFSPROC_T *p)
576 {
577 u_int32_t *tl;
578 struct nfsrv_descript nfsd, *nd = &nfsd;
579 int error;
580
581 NFSCL_REQSTART(nd, NFSPROC_OPENDOWNGRADE, vp);
582 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID + 3 * NFSX_UNSIGNED);
583 if (NFSHASNFSV4N(VFSTONFS(vnode_mount(vp))))
584 *tl++ = 0;
585 else
586 *tl++ = op->nfso_stateid.seqid;
587 *tl++ = op->nfso_stateid.other[0];
588 *tl++ = op->nfso_stateid.other[1];
589 *tl++ = op->nfso_stateid.other[2];
590 *tl++ = txdr_unsigned(op->nfso_own->nfsow_seqid);
591 *tl++ = txdr_unsigned(mode & NFSV4OPEN_ACCESSBOTH);
592 *tl = txdr_unsigned((mode >> NFSLCK_SHIFT) & NFSV4OPEN_DENYBOTH);
593 error = nfscl_request(nd, vp, p, cred, NULL);
594 if (error)
595 return (error);
596 NFSCL_INCRSEQID(op->nfso_own->nfsow_seqid, nd);
597 if (!nd->nd_repstat) {
598 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID);
599 op->nfso_stateid.seqid = *tl++;
600 op->nfso_stateid.other[0] = *tl++;
601 op->nfso_stateid.other[1] = *tl++;
602 op->nfso_stateid.other[2] = *tl;
603 }
604 if (nd->nd_repstat && error == 0)
605 error = nd->nd_repstat;
606 if (error == NFSERR_STALESTATEID)
607 nfscl_initiate_recovery(op->nfso_own->nfsow_clp);
608 nfsmout:
609 mbuf_freem(nd->nd_mrep);
610 return (error);
611 }
612
613 /*
614 * V4 Close operation.
615 */
616 APPLESTATIC int
617 nfsrpc_close(vnode_t vp, int doclose, NFSPROC_T *p)
618 {
619 struct nfsclclient *clp;
620 int error;
621
622 if (vnode_vtype(vp) != VREG)
623 return (0);
624 if (doclose)
625 error = nfscl_doclose(vp, &clp, p);
626 else
627 error = nfscl_getclose(vp, &clp);
628 if (error)
629 return (error);
630
631 nfscl_clientrelease(clp);
632 return (0);
633 }
634
635 /*
636 * Close the open.
637 */
638 APPLESTATIC void
639 nfsrpc_doclose(struct nfsmount *nmp, struct nfsclopen *op, NFSPROC_T *p)
640 {
641 struct nfsrv_descript nfsd, *nd = &nfsd;
642 struct nfscllockowner *lp, *nlp;
643 struct nfscllock *lop, *nlop;
644 struct ucred *tcred;
645 u_int64_t off = 0, len = 0;
646 u_int32_t type = NFSV4LOCKT_READ;
647 int error, do_unlock, trycnt;
648
649 tcred = newnfs_getcred();
650 newnfs_copycred(&op->nfso_cred, tcred);
651 /*
652 * (Theoretically this could be done in the same
653 * compound as the close, but having multiple
654 * sequenced Ops in the same compound might be
655 * too scary for some servers.)
656 */
657 if (op->nfso_posixlock) {
658 off = 0;
659 len = NFS64BITSSET;
660 type = NFSV4LOCKT_READ;
661 }
662
663 /*
664 * Since this function is only called from VOP_INACTIVE(), no
665 * other thread will be manipulating this Open. As such, the
666 * lock lists are not being changed by other threads, so it should
667 * be safe to do this without locking.
668 */
669 LIST_FOREACH(lp, &op->nfso_lock, nfsl_list) {
670 do_unlock = 1;
671 LIST_FOREACH_SAFE(lop, &lp->nfsl_lock, nfslo_list, nlop) {
672 if (op->nfso_posixlock == 0) {
673 off = lop->nfslo_first;
674 len = lop->nfslo_end - lop->nfslo_first;
675 if (lop->nfslo_type == F_WRLCK)
676 type = NFSV4LOCKT_WRITE;
677 else
678 type = NFSV4LOCKT_READ;
679 }
680 if (do_unlock) {
681 trycnt = 0;
682 do {
683 error = nfsrpc_locku(nd, nmp, lp, off,
684 len, type, tcred, p, 0);
685 if ((nd->nd_repstat == NFSERR_GRACE ||
686 nd->nd_repstat == NFSERR_DELAY) &&
687 error == 0)
688 (void) nfs_catnap(PZERO,
689 (int)nd->nd_repstat,
690 "nfs_close");
691 } while ((nd->nd_repstat == NFSERR_GRACE ||
692 nd->nd_repstat == NFSERR_DELAY) &&
693 error == 0 && trycnt++ < 5);
694 if (op->nfso_posixlock)
695 do_unlock = 0;
696 }
697 nfscl_freelock(lop, 0);
698 }
699 /*
700 * Do a ReleaseLockOwner.
701 * The lock owner name nfsl_owner may be used by other opens for
702 * other files but the lock_owner4 name that nfsrpc_rellockown()
703 * puts on the wire has the file handle for this file appended
704 * to it, so it can be done now.
705 */
706 (void)nfsrpc_rellockown(nmp, lp, lp->nfsl_open->nfso_fh,
707 lp->nfsl_open->nfso_fhlen, tcred, p);
708 }
709
710 /*
711 * There could be other Opens for different files on the same
712 * OpenOwner, so locking is required.
713 */
714 NFSLOCKCLSTATE();
715 nfscl_lockexcl(&op->nfso_own->nfsow_rwlock, NFSCLSTATEMUTEXPTR);
716 NFSUNLOCKCLSTATE();
717 do {
718 error = nfscl_tryclose(op, tcred, nmp, p);
719 if (error == NFSERR_GRACE)
720 (void) nfs_catnap(PZERO, error, "nfs_close");
721 } while (error == NFSERR_GRACE);
722 NFSLOCKCLSTATE();
723 nfscl_lockunlock(&op->nfso_own->nfsow_rwlock);
724
725 LIST_FOREACH_SAFE(lp, &op->nfso_lock, nfsl_list, nlp)
726 nfscl_freelockowner(lp, 0);
727 nfscl_freeopen(op, 0);
728 NFSUNLOCKCLSTATE();
729 NFSFREECRED(tcred);
730 }
731
732 /*
733 * The actual Close RPC.
734 */
735 APPLESTATIC int
736 nfsrpc_closerpc(struct nfsrv_descript *nd, struct nfsmount *nmp,
737 struct nfsclopen *op, struct ucred *cred, NFSPROC_T *p,
738 int syscred)
739 {
740 u_int32_t *tl;
741 int error;
742
743 nfscl_reqstart(nd, NFSPROC_CLOSE, nmp, op->nfso_fh,
744 op->nfso_fhlen, NULL, NULL);
745 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED + NFSX_STATEID);
746 *tl++ = txdr_unsigned(op->nfso_own->nfsow_seqid);
747 if (NFSHASNFSV4N(nmp))
748 *tl++ = 0;
749 else
750 *tl++ = op->nfso_stateid.seqid;
751 *tl++ = op->nfso_stateid.other[0];
752 *tl++ = op->nfso_stateid.other[1];
753 *tl = op->nfso_stateid.other[2];
754 if (syscred)
755 nd->nd_flag |= ND_USEGSSNAME;
756 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
757 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
758 if (error)
759 return (error);
760 NFSCL_INCRSEQID(op->nfso_own->nfsow_seqid, nd);
761 if (nd->nd_repstat == 0)
762 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID);
763 error = nd->nd_repstat;
764 if (error == NFSERR_STALESTATEID)
765 nfscl_initiate_recovery(op->nfso_own->nfsow_clp);
766 nfsmout:
767 mbuf_freem(nd->nd_mrep);
768 return (error);
769 }
770
771 /*
772 * V4 Open Confirm RPC.
773 */
774 APPLESTATIC int
775 nfsrpc_openconfirm(vnode_t vp, u_int8_t *nfhp, int fhlen,
776 struct nfsclopen *op, struct ucred *cred, NFSPROC_T *p)
777 {
778 u_int32_t *tl;
779 struct nfsrv_descript nfsd, *nd = &nfsd;
780 struct nfsmount *nmp;
781 int error;
782
783 nmp = VFSTONFS(vnode_mount(vp));
784 if (NFSHASNFSV4N(nmp))
785 return (0); /* No confirmation for NFSv4.1. */
786 nfscl_reqstart(nd, NFSPROC_OPENCONFIRM, nmp, nfhp, fhlen, NULL, NULL);
787 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED + NFSX_STATEID);
788 *tl++ = op->nfso_stateid.seqid;
789 *tl++ = op->nfso_stateid.other[0];
790 *tl++ = op->nfso_stateid.other[1];
791 *tl++ = op->nfso_stateid.other[2];
792 *tl = txdr_unsigned(op->nfso_own->nfsow_seqid);
793 error = nfscl_request(nd, vp, p, cred, NULL);
794 if (error)
795 return (error);
796 NFSCL_INCRSEQID(op->nfso_own->nfsow_seqid, nd);
797 if (!nd->nd_repstat) {
798 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID);
799 op->nfso_stateid.seqid = *tl++;
800 op->nfso_stateid.other[0] = *tl++;
801 op->nfso_stateid.other[1] = *tl++;
802 op->nfso_stateid.other[2] = *tl;
803 }
804 error = nd->nd_repstat;
805 if (error == NFSERR_STALESTATEID)
806 nfscl_initiate_recovery(op->nfso_own->nfsow_clp);
807 nfsmout:
808 mbuf_freem(nd->nd_mrep);
809 return (error);
810 }
811
812 /*
813 * Do the setclientid and setclientid confirm RPCs. Called from nfs_statfs()
814 * when a mount has just occurred and when the server replies NFSERR_EXPIRED.
815 */
816 APPLESTATIC int
817 nfsrpc_setclient(struct nfsmount *nmp, struct nfsclclient *clp, int reclaim,
818 struct ucred *cred, NFSPROC_T *p)
819 {
820 u_int32_t *tl;
821 struct nfsrv_descript nfsd;
822 struct nfsrv_descript *nd = &nfsd;
823 nfsattrbit_t attrbits;
824 u_int8_t *cp = NULL, *cp2, addr[INET6_ADDRSTRLEN + 9];
825 u_short port;
826 int error, isinet6 = 0, callblen;
827 nfsquad_t confirm;
828 u_int32_t lease;
829 static u_int32_t rev = 0;
830 struct nfsclds *dsp;
831 struct nfsclsession *tsep;
832
833 if (nfsboottime.tv_sec == 0)
834 NFSSETBOOTTIME(nfsboottime);
835 clp->nfsc_rev = rev++;
836 if (NFSHASNFSV4N(nmp)) {
837 /*
838 * Either there was no previous session or the
839 * previous session has failed, so...
840 * do an ExchangeID followed by the CreateSession.
841 */
842 error = nfsrpc_exchangeid(nmp, clp, &nmp->nm_sockreq,
843 NFSV4EXCH_USEPNFSMDS | NFSV4EXCH_USENONPNFS, &dsp, cred, p);
844 NFSCL_DEBUG(1, "aft exch=%d\n", error);
845 if (error == 0)
846 error = nfsrpc_createsession(nmp, &dsp->nfsclds_sess,
847 &nmp->nm_sockreq,
848 dsp->nfsclds_sess.nfsess_sequenceid, 1, cred, p);
849 if (error == 0) {
850 NFSLOCKMNT(nmp);
851 /*
852 * The old sessions cannot be safely free'd
853 * here, since they may still be used by
854 * in-progress RPCs.
855 */
856 tsep = NULL;
857 if (TAILQ_FIRST(&nmp->nm_sess) != NULL)
858 tsep = NFSMNT_MDSSESSION(nmp);
859 TAILQ_INSERT_HEAD(&nmp->nm_sess, dsp,
860 nfsclds_list);
861 /*
862 * Wake up RPCs waiting for a slot on the
863 * old session. These will then fail with
864 * NFSERR_BADSESSION and be retried with the
865 * new session by nfsv4_setsequence().
866 * Also wakeup() processes waiting for the
867 * new session.
868 */
869 if (tsep != NULL)
870 wakeup(&tsep->nfsess_slots);
871 wakeup(&nmp->nm_sess);
872 NFSUNLOCKMNT(nmp);
873 } else
874 nfscl_freenfsclds(dsp);
875 NFSCL_DEBUG(1, "aft createsess=%d\n", error);
876 if (error == 0 && reclaim == 0) {
877 error = nfsrpc_reclaimcomplete(nmp, cred, p);
878 NFSCL_DEBUG(1, "aft reclaimcomp=%d\n", error);
879 if (error == NFSERR_COMPLETEALREADY ||
880 error == NFSERR_NOTSUPP)
881 /* Ignore this error. */
882 error = 0;
883 }
884 return (error);
885 }
886
887 /*
888 * Allocate a single session structure for NFSv4.0, because some of
889 * the fields are used by NFSv4.0 although it doesn't do a session.
890 */
891 dsp = malloc(sizeof(struct nfsclds), M_NFSCLDS, M_WAITOK | M_ZERO);
892 mtx_init(&dsp->nfsclds_mtx, "nfsds", NULL, MTX_DEF);
893 mtx_init(&dsp->nfsclds_sess.nfsess_mtx, "nfssession", NULL, MTX_DEF);
894 NFSLOCKMNT(nmp);
895 TAILQ_INSERT_HEAD(&nmp->nm_sess, dsp, nfsclds_list);
896 tsep = NFSMNT_MDSSESSION(nmp);
897 NFSUNLOCKMNT(nmp);
898
899 nfscl_reqstart(nd, NFSPROC_SETCLIENTID, nmp, NULL, 0, NULL, NULL);
900 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
901 *tl++ = txdr_unsigned(nfsboottime.tv_sec);
902 *tl = txdr_unsigned(clp->nfsc_rev);
903 (void) nfsm_strtom(nd, clp->nfsc_id, clp->nfsc_idlen);
904
905 /*
906 * set up the callback address
907 */
908 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
909 *tl = txdr_unsigned(NFS_CALLBCKPROG);
910 callblen = strlen(nfsv4_callbackaddr);
911 if (callblen == 0)
912 cp = nfscl_getmyip(nmp, &isinet6);
913 if (nfscl_enablecallb && nfs_numnfscbd > 0 &&
914 (callblen > 0 || cp != NULL)) {
915 port = htons(nfsv4_cbport);
916 cp2 = (u_int8_t *)&port;
917 #ifdef INET6
918 if ((callblen > 0 &&
919 strchr(nfsv4_callbackaddr, ':')) || isinet6) {
920 char ip6buf[INET6_ADDRSTRLEN], *ip6add;
921
922 (void) nfsm_strtom(nd, "tcp6", 4);
923 if (callblen == 0) {
924 ip6_sprintf(ip6buf, (struct in6_addr *)cp);
925 ip6add = ip6buf;
926 } else {
927 ip6add = nfsv4_callbackaddr;
928 }
929 snprintf(addr, INET6_ADDRSTRLEN + 9, "%s.%d.%d",
930 ip6add, cp2[0], cp2[1]);
931 } else
932 #endif
933 {
934 (void) nfsm_strtom(nd, "tcp", 3);
935 if (callblen == 0)
936 snprintf(addr, INET6_ADDRSTRLEN + 9,
937 "%d.%d.%d.%d.%d.%d", cp[0], cp[1],
938 cp[2], cp[3], cp2[0], cp2[1]);
939 else
940 snprintf(addr, INET6_ADDRSTRLEN + 9,
941 "%s.%d.%d", nfsv4_callbackaddr,
942 cp2[0], cp2[1]);
943 }
944 (void) nfsm_strtom(nd, addr, strlen(addr));
945 } else {
946 (void) nfsm_strtom(nd, "tcp", 3);
947 (void) nfsm_strtom(nd, "0.0.0.0.0.0", 11);
948 }
949 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
950 *tl = txdr_unsigned(clp->nfsc_cbident);
951 nd->nd_flag |= ND_USEGSSNAME;
952 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
953 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
954 if (error)
955 return (error);
956 if (nd->nd_repstat == 0) {
957 NFSM_DISSECT(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
958 tsep->nfsess_clientid.lval[0] = *tl++;
959 tsep->nfsess_clientid.lval[1] = *tl++;
960 confirm.lval[0] = *tl++;
961 confirm.lval[1] = *tl;
962 mbuf_freem(nd->nd_mrep);
963 nd->nd_mrep = NULL;
964
965 /*
966 * and confirm it.
967 */
968 nfscl_reqstart(nd, NFSPROC_SETCLIENTIDCFRM, nmp, NULL, 0, NULL,
969 NULL);
970 NFSM_BUILD(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
971 *tl++ = tsep->nfsess_clientid.lval[0];
972 *tl++ = tsep->nfsess_clientid.lval[1];
973 *tl++ = confirm.lval[0];
974 *tl = confirm.lval[1];
975 nd->nd_flag |= ND_USEGSSNAME;
976 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p,
977 cred, NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
978 if (error)
979 return (error);
980 mbuf_freem(nd->nd_mrep);
981 nd->nd_mrep = NULL;
982 if (nd->nd_repstat == 0) {
983 nfscl_reqstart(nd, NFSPROC_GETATTR, nmp, nmp->nm_fh,
984 nmp->nm_fhsize, NULL, NULL);
985 NFSZERO_ATTRBIT(&attrbits);
986 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_LEASETIME);
987 (void) nfsrv_putattrbit(nd, &attrbits);
988 nd->nd_flag |= ND_USEGSSNAME;
989 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p,
990 cred, NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
991 if (error)
992 return (error);
993 if (nd->nd_repstat == 0) {
994 error = nfsv4_loadattr(nd, NULL, NULL, NULL, NULL, 0, NULL,
995 NULL, NULL, NULL, NULL, 0, NULL, &lease, NULL, p, cred);
996 if (error)
997 goto nfsmout;
998 clp->nfsc_renew = NFSCL_RENEW(lease);
999 clp->nfsc_expire = NFSD_MONOSEC + clp->nfsc_renew;
1000 clp->nfsc_clientidrev++;
1001 if (clp->nfsc_clientidrev == 0)
1002 clp->nfsc_clientidrev++;
1003 }
1004 }
1005 }
1006 error = nd->nd_repstat;
1007 nfsmout:
1008 mbuf_freem(nd->nd_mrep);
1009 return (error);
1010 }
1011
1012 /*
1013 * nfs getattr call.
1014 */
1015 APPLESTATIC int
1016 nfsrpc_getattr(vnode_t vp, struct ucred *cred, NFSPROC_T *p,
1017 struct nfsvattr *nap, void *stuff)
1018 {
1019 struct nfsrv_descript nfsd, *nd = &nfsd;
1020 int error;
1021 nfsattrbit_t attrbits;
1022
1023 NFSCL_REQSTART(nd, NFSPROC_GETATTR, vp);
1024 if (nd->nd_flag & ND_NFSV4) {
1025 NFSGETATTR_ATTRBIT(&attrbits);
1026 (void) nfsrv_putattrbit(nd, &attrbits);
1027 }
1028 error = nfscl_request(nd, vp, p, cred, stuff);
1029 if (error)
1030 return (error);
1031 if (!nd->nd_repstat)
1032 error = nfsm_loadattr(nd, nap);
1033 else
1034 error = nd->nd_repstat;
1035 mbuf_freem(nd->nd_mrep);
1036 return (error);
1037 }
1038
1039 /*
1040 * nfs getattr call with non-vnode arguemnts.
1041 */
1042 APPLESTATIC int
1043 nfsrpc_getattrnovp(struct nfsmount *nmp, u_int8_t *fhp, int fhlen, int syscred,
1044 struct ucred *cred, NFSPROC_T *p, struct nfsvattr *nap, u_int64_t *xidp,
1045 uint32_t *leasep)
1046 {
1047 struct nfsrv_descript nfsd, *nd = &nfsd;
1048 int error, vers = NFS_VER2;
1049 nfsattrbit_t attrbits;
1050
1051 nfscl_reqstart(nd, NFSPROC_GETATTR, nmp, fhp, fhlen, NULL, NULL);
1052 if (nd->nd_flag & ND_NFSV4) {
1053 vers = NFS_VER4;
1054 NFSGETATTR_ATTRBIT(&attrbits);
1055 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_LEASETIME);
1056 (void) nfsrv_putattrbit(nd, &attrbits);
1057 } else if (nd->nd_flag & ND_NFSV3) {
1058 vers = NFS_VER3;
1059 }
1060 if (syscred)
1061 nd->nd_flag |= ND_USEGSSNAME;
1062 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
1063 NFS_PROG, vers, NULL, 1, xidp, NULL);
1064 if (error)
1065 return (error);
1066 if (nd->nd_repstat == 0) {
1067 if ((nd->nd_flag & ND_NFSV4) != 0)
1068 error = nfsv4_loadattr(nd, NULL, nap, NULL, NULL, 0,
1069 NULL, NULL, NULL, NULL, NULL, 0, NULL, leasep, NULL,
1070 NULL, NULL);
1071 else
1072 error = nfsm_loadattr(nd, nap);
1073 } else
1074 error = nd->nd_repstat;
1075 mbuf_freem(nd->nd_mrep);
1076 return (error);
1077 }
1078
1079 /*
1080 * Do an nfs setattr operation.
1081 */
1082 APPLESTATIC int
1083 nfsrpc_setattr(vnode_t vp, struct vattr *vap, NFSACL_T *aclp,
1084 struct ucred *cred, NFSPROC_T *p, struct nfsvattr *rnap, int *attrflagp,
1085 void *stuff)
1086 {
1087 int error, expireret = 0, openerr, retrycnt;
1088 u_int32_t clidrev = 0, mode;
1089 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
1090 struct nfsfh *nfhp;
1091 nfsv4stateid_t stateid;
1092 void *lckp;
1093
1094 if (nmp->nm_clp != NULL)
1095 clidrev = nmp->nm_clp->nfsc_clientidrev;
1096 if (vap != NULL && NFSATTRISSET(u_quad_t, vap, va_size))
1097 mode = NFSV4OPEN_ACCESSWRITE;
1098 else
1099 mode = NFSV4OPEN_ACCESSREAD;
1100 retrycnt = 0;
1101 do {
1102 lckp = NULL;
1103 openerr = 1;
1104 if (NFSHASNFSV4(nmp)) {
1105 nfhp = VTONFS(vp)->n_fhp;
1106 error = nfscl_getstateid(vp, nfhp->nfh_fh,
1107 nfhp->nfh_len, mode, 0, cred, p, &stateid, &lckp);
1108 if (error && vnode_vtype(vp) == VREG &&
1109 (mode == NFSV4OPEN_ACCESSWRITE ||
1110 nfstest_openallsetattr)) {
1111 /*
1112 * No Open stateid, so try and open the file
1113 * now.
1114 */
1115 if (mode == NFSV4OPEN_ACCESSWRITE)
1116 openerr = nfsrpc_open(vp, FWRITE, cred,
1117 p);
1118 else
1119 openerr = nfsrpc_open(vp, FREAD, cred,
1120 p);
1121 if (!openerr)
1122 (void) nfscl_getstateid(vp,
1123 nfhp->nfh_fh, nfhp->nfh_len,
1124 mode, 0, cred, p, &stateid, &lckp);
1125 }
1126 }
1127 if (vap != NULL)
1128 error = nfsrpc_setattrrpc(vp, vap, &stateid, cred, p,
1129 rnap, attrflagp, stuff);
1130 else
1131 error = nfsrpc_setaclrpc(vp, cred, p, aclp, &stateid,
1132 stuff);
1133 if (error == NFSERR_OPENMODE && mode == NFSV4OPEN_ACCESSREAD) {
1134 NFSLOCKMNT(nmp);
1135 nmp->nm_state |= NFSSTA_OPENMODE;
1136 NFSUNLOCKMNT(nmp);
1137 }
1138 if (error == NFSERR_STALESTATEID)
1139 nfscl_initiate_recovery(nmp->nm_clp);
1140 if (lckp != NULL)
1141 nfscl_lockderef(lckp);
1142 if (!openerr)
1143 (void) nfsrpc_close(vp, 0, p);
1144 if (error == NFSERR_GRACE || error == NFSERR_STALESTATEID ||
1145 error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
1146 error == NFSERR_OLDSTATEID || error == NFSERR_BADSESSION) {
1147 (void) nfs_catnap(PZERO, error, "nfs_setattr");
1148 } else if ((error == NFSERR_EXPIRED ||
1149 error == NFSERR_BADSTATEID) && clidrev != 0) {
1150 expireret = nfscl_hasexpired(nmp->nm_clp, clidrev, p);
1151 }
1152 retrycnt++;
1153 } while (error == NFSERR_GRACE || error == NFSERR_STALESTATEID ||
1154 error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
1155 error == NFSERR_BADSESSION ||
1156 (error == NFSERR_OLDSTATEID && retrycnt < 20) ||
1157 ((error == NFSERR_EXPIRED || error == NFSERR_BADSTATEID) &&
1158 expireret == 0 && clidrev != 0 && retrycnt < 4) ||
1159 (error == NFSERR_OPENMODE && mode == NFSV4OPEN_ACCESSREAD &&
1160 retrycnt < 4));
1161 if (error && retrycnt >= 4)
1162 error = EIO;
1163 return (error);
1164 }
1165
1166 static int
1167 nfsrpc_setattrrpc(vnode_t vp, struct vattr *vap,
1168 nfsv4stateid_t *stateidp, struct ucred *cred, NFSPROC_T *p,
1169 struct nfsvattr *rnap, int *attrflagp, void *stuff)
1170 {
1171 u_int32_t *tl;
1172 struct nfsrv_descript nfsd, *nd = &nfsd;
1173 int error;
1174 nfsattrbit_t attrbits;
1175
1176 *attrflagp = 0;
1177 NFSCL_REQSTART(nd, NFSPROC_SETATTR, vp);
1178 if (nd->nd_flag & ND_NFSV4)
1179 nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSTATEID);
1180 vap->va_type = vnode_vtype(vp);
1181 nfscl_fillsattr(nd, vap, vp, NFSSATTR_FULL, 0);
1182 if (nd->nd_flag & ND_NFSV3) {
1183 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
1184 *tl = newnfs_false;
1185 } else if (nd->nd_flag & ND_NFSV4) {
1186 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
1187 *tl = txdr_unsigned(NFSV4OP_GETATTR);
1188 NFSGETATTR_ATTRBIT(&attrbits);
1189 (void) nfsrv_putattrbit(nd, &attrbits);
1190 }
1191 error = nfscl_request(nd, vp, p, cred, stuff);
1192 if (error)
1193 return (error);
1194 if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4))
1195 error = nfscl_wcc_data(nd, vp, rnap, attrflagp, NULL, stuff);
1196 if ((nd->nd_flag & (ND_NFSV4 | ND_NOMOREDATA)) == ND_NFSV4 && !error)
1197 error = nfsrv_getattrbits(nd, &attrbits, NULL, NULL);
1198 if (!(nd->nd_flag & ND_NFSV3) && !nd->nd_repstat && !error)
1199 error = nfscl_postop_attr(nd, rnap, attrflagp, stuff);
1200 mbuf_freem(nd->nd_mrep);
1201 if (nd->nd_repstat && !error)
1202 error = nd->nd_repstat;
1203 return (error);
1204 }
1205
1206 /*
1207 * nfs lookup rpc
1208 */
1209 APPLESTATIC int
1210 nfsrpc_lookup(vnode_t dvp, char *name, int len, struct ucred *cred,
1211 NFSPROC_T *p, struct nfsvattr *dnap, struct nfsvattr *nap,
1212 struct nfsfh **nfhpp, int *attrflagp, int *dattrflagp, void *stuff)
1213 {
1214 u_int32_t *tl;
1215 struct nfsrv_descript nfsd, *nd = &nfsd;
1216 struct nfsmount *nmp;
1217 struct nfsnode *np;
1218 struct nfsfh *nfhp;
1219 nfsattrbit_t attrbits;
1220 int error = 0, lookupp = 0;
1221
1222 *attrflagp = 0;
1223 *dattrflagp = 0;
1224 if (vnode_vtype(dvp) != VDIR)
1225 return (ENOTDIR);
1226 nmp = VFSTONFS(vnode_mount(dvp));
1227 if (len > NFS_MAXNAMLEN)
1228 return (ENAMETOOLONG);
1229 if (NFSHASNFSV4(nmp) && len == 1 &&
1230 name[0] == '.') {
1231 /*
1232 * Just return the current dir's fh.
1233 */
1234 np = VTONFS(dvp);
1235 MALLOC(nfhp, struct nfsfh *, sizeof (struct nfsfh) +
1236 np->n_fhp->nfh_len, M_NFSFH, M_WAITOK);
1237 nfhp->nfh_len = np->n_fhp->nfh_len;
1238 NFSBCOPY(np->n_fhp->nfh_fh, nfhp->nfh_fh, nfhp->nfh_len);
1239 *nfhpp = nfhp;
1240 return (0);
1241 }
1242 if (NFSHASNFSV4(nmp) && len == 2 &&
1243 name[0] == '.' && name[1] == '.') {
1244 lookupp = 1;
1245 NFSCL_REQSTART(nd, NFSPROC_LOOKUPP, dvp);
1246 } else {
1247 NFSCL_REQSTART(nd, NFSPROC_LOOKUP, dvp);
1248 (void) nfsm_strtom(nd, name, len);
1249 }
1250 if (nd->nd_flag & ND_NFSV4) {
1251 NFSGETATTR_ATTRBIT(&attrbits);
1252 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1253 *tl++ = txdr_unsigned(NFSV4OP_GETFH);
1254 *tl = txdr_unsigned(NFSV4OP_GETATTR);
1255 (void) nfsrv_putattrbit(nd, &attrbits);
1256 }
1257 error = nfscl_request(nd, dvp, p, cred, stuff);
1258 if (error)
1259 return (error);
1260 if (nd->nd_repstat) {
1261 /*
1262 * When an NFSv4 Lookupp returns ENOENT, it means that
1263 * the lookup is at the root of an fs, so return this dir.
1264 */
1265 if (nd->nd_repstat == NFSERR_NOENT && lookupp) {
1266 np = VTONFS(dvp);
1267 MALLOC(nfhp, struct nfsfh *, sizeof (struct nfsfh) +
1268 np->n_fhp->nfh_len, M_NFSFH, M_WAITOK);
1269 nfhp->nfh_len = np->n_fhp->nfh_len;
1270 NFSBCOPY(np->n_fhp->nfh_fh, nfhp->nfh_fh, nfhp->nfh_len);
1271 *nfhpp = nfhp;
1272 mbuf_freem(nd->nd_mrep);
1273 return (0);
1274 }
1275 if (nd->nd_flag & ND_NFSV3)
1276 error = nfscl_postop_attr(nd, dnap, dattrflagp, stuff);
1277 else if ((nd->nd_flag & (ND_NFSV4 | ND_NOMOREDATA)) ==
1278 ND_NFSV4) {
1279 /* Load the directory attributes. */
1280 error = nfsm_loadattr(nd, dnap);
1281 if (error == 0)
1282 *dattrflagp = 1;
1283 }
1284 goto nfsmout;
1285 }
1286 if ((nd->nd_flag & (ND_NFSV4 | ND_NOMOREDATA)) == ND_NFSV4) {
1287 /* Load the directory attributes. */
1288 error = nfsm_loadattr(nd, dnap);
1289 if (error != 0)
1290 goto nfsmout;
1291 *dattrflagp = 1;
1292 /* Skip over the Lookup and GetFH operation status values. */
1293 NFSM_DISSECT(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
1294 }
1295 error = nfsm_getfh(nd, nfhpp);
1296 if (error)
1297 goto nfsmout;
1298
1299 error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
1300 if ((nd->nd_flag & ND_NFSV3) && !error)
1301 error = nfscl_postop_attr(nd, dnap, dattrflagp, stuff);
1302 nfsmout:
1303 mbuf_freem(nd->nd_mrep);
1304 if (!error && nd->nd_repstat)
1305 error = nd->nd_repstat;
1306 return (error);
1307 }
1308
1309 /*
1310 * Do a readlink rpc.
1311 */
1312 APPLESTATIC int
1313 nfsrpc_readlink(vnode_t vp, struct uio *uiop, struct ucred *cred,
1314 NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp, void *stuff)
1315 {
1316 u_int32_t *tl;
1317 struct nfsrv_descript nfsd, *nd = &nfsd;
1318 struct nfsnode *np = VTONFS(vp);
1319 nfsattrbit_t attrbits;
1320 int error, len, cangetattr = 1;
1321
1322 *attrflagp = 0;
1323 NFSCL_REQSTART(nd, NFSPROC_READLINK, vp);
1324 if (nd->nd_flag & ND_NFSV4) {
1325 /*
1326 * And do a Getattr op.
1327 */
1328 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
1329 *tl = txdr_unsigned(NFSV4OP_GETATTR);
1330 NFSGETATTR_ATTRBIT(&attrbits);
1331 (void) nfsrv_putattrbit(nd, &attrbits);
1332 }
1333 error = nfscl_request(nd, vp, p, cred, stuff);
1334 if (error)
1335 return (error);
1336 if (nd->nd_flag & ND_NFSV3)
1337 error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
1338 if (!nd->nd_repstat && !error) {
1339 NFSM_STRSIZ(len, NFS_MAXPATHLEN);
1340 /*
1341 * This seems weird to me, but must have been added to
1342 * FreeBSD for some reason. The only thing I can think of
1343 * is that there was/is some server that replies with
1344 * more link data than it should?
1345 */
1346 if (len == NFS_MAXPATHLEN) {
1347 NFSLOCKNODE(np);
1348 if (np->n_size > 0 && np->n_size < NFS_MAXPATHLEN) {
1349 len = np->n_size;
1350 cangetattr = 0;
1351 }
1352 NFSUNLOCKNODE(np);
1353 }
1354 error = nfsm_mbufuio(nd, uiop, len);
1355 if ((nd->nd_flag & ND_NFSV4) && !error && cangetattr)
1356 error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
1357 }
1358 if (nd->nd_repstat && !error)
1359 error = nd->nd_repstat;
1360 nfsmout:
1361 mbuf_freem(nd->nd_mrep);
1362 return (error);
1363 }
1364
1365 /*
1366 * Read operation.
1367 */
1368 APPLESTATIC int
1369 nfsrpc_read(vnode_t vp, struct uio *uiop, struct ucred *cred,
1370 NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp, void *stuff)
1371 {
1372 int error, expireret = 0, retrycnt;
1373 u_int32_t clidrev = 0;
1374 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
1375 struct nfsnode *np = VTONFS(vp);
1376 struct ucred *newcred;
1377 struct nfsfh *nfhp = NULL;
1378 nfsv4stateid_t stateid;
1379 void *lckp;
1380
1381 if (nmp->nm_clp != NULL)
1382 clidrev = nmp->nm_clp->nfsc_clientidrev;
1383 newcred = cred;
1384 if (NFSHASNFSV4(nmp)) {
1385 nfhp = np->n_fhp;
1386 newcred = NFSNEWCRED(cred);
1387 }
1388 retrycnt = 0;
1389 do {
1390 lckp = NULL;
1391 if (NFSHASNFSV4(nmp))
1392 (void)nfscl_getstateid(vp, nfhp->nfh_fh, nfhp->nfh_len,
1393 NFSV4OPEN_ACCESSREAD, 0, newcred, p, &stateid,
1394 &lckp);
1395 error = nfsrpc_readrpc(vp, uiop, newcred, &stateid, p, nap,
1396 attrflagp, stuff);
1397 if (error == NFSERR_OPENMODE) {
1398 NFSLOCKMNT(nmp);
1399 nmp->nm_state |= NFSSTA_OPENMODE;
1400 NFSUNLOCKMNT(nmp);
1401 }
1402 if (error == NFSERR_STALESTATEID)
1403 nfscl_initiate_recovery(nmp->nm_clp);
1404 if (lckp != NULL)
1405 nfscl_lockderef(lckp);
1406 if (error == NFSERR_GRACE || error == NFSERR_STALESTATEID ||
1407 error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
1408 error == NFSERR_OLDSTATEID || error == NFSERR_BADSESSION) {
1409 (void) nfs_catnap(PZERO, error, "nfs_read");
1410 } else if ((error == NFSERR_EXPIRED ||
1411 error == NFSERR_BADSTATEID) && clidrev != 0) {
1412 expireret = nfscl_hasexpired(nmp->nm_clp, clidrev, p);
1413 }
1414 retrycnt++;
1415 } while (error == NFSERR_GRACE || error == NFSERR_STALESTATEID ||
1416 error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
1417 error == NFSERR_BADSESSION ||
1418 (error == NFSERR_OLDSTATEID && retrycnt < 20) ||
1419 ((error == NFSERR_EXPIRED || error == NFSERR_BADSTATEID) &&
1420 expireret == 0 && clidrev != 0 && retrycnt < 4) ||
1421 (error == NFSERR_OPENMODE && retrycnt < 4));
1422 if (error && retrycnt >= 4)
1423 error = EIO;
1424 if (NFSHASNFSV4(nmp))
1425 NFSFREECRED(newcred);
1426 return (error);
1427 }
1428
1429 /*
1430 * The actual read RPC.
1431 */
1432 static int
1433 nfsrpc_readrpc(vnode_t vp, struct uio *uiop, struct ucred *cred,
1434 nfsv4stateid_t *stateidp, NFSPROC_T *p, struct nfsvattr *nap,
1435 int *attrflagp, void *stuff)
1436 {
1437 u_int32_t *tl;
1438 int error = 0, len, retlen, tsiz, eof = 0;
1439 struct nfsrv_descript nfsd;
1440 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
1441 struct nfsrv_descript *nd = &nfsd;
1442 int rsize;
1443 off_t tmp_off;
1444
1445 *attrflagp = 0;
1446 tsiz = uio_uio_resid(uiop);
1447 tmp_off = uiop->uio_offset + tsiz;
1448 NFSLOCKMNT(nmp);
1449 if (tmp_off > nmp->nm_maxfilesize || tmp_off < uiop->uio_offset) {
1450 NFSUNLOCKMNT(nmp);
1451 return (EFBIG);
1452 }
1453 rsize = nmp->nm_rsize;
1454 NFSUNLOCKMNT(nmp);
1455 nd->nd_mrep = NULL;
1456 while (tsiz > 0) {
1457 *attrflagp = 0;
1458 len = (tsiz > rsize) ? rsize : tsiz;
1459 NFSCL_REQSTART(nd, NFSPROC_READ, vp);
1460 if (nd->nd_flag & ND_NFSV4)
1461 nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSTATEID);
1462 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED * 3);
1463 if (nd->nd_flag & ND_NFSV2) {
1464 *tl++ = txdr_unsigned(uiop->uio_offset);
1465 *tl++ = txdr_unsigned(len);
1466 *tl = 0;
1467 } else {
1468 txdr_hyper(uiop->uio_offset, tl);
1469 *(tl + 2) = txdr_unsigned(len);
1470 }
1471 /*
1472 * Since I can't do a Getattr for NFSv4 for Write, there
1473 * doesn't seem any point in doing one here, either.
1474 * (See the comment in nfsrpc_writerpc() for more info.)
1475 */
1476 error = nfscl_request(nd, vp, p, cred, stuff);
1477 if (error)
1478 return (error);
1479 if (nd->nd_flag & ND_NFSV3) {
1480 error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
1481 } else if (!nd->nd_repstat && (nd->nd_flag & ND_NFSV2)) {
1482 error = nfsm_loadattr(nd, nap);
1483 if (!error)
1484 *attrflagp = 1;
1485 }
1486 if (nd->nd_repstat || error) {
1487 if (!error)
1488 error = nd->nd_repstat;
1489 goto nfsmout;
1490 }
1491 if (nd->nd_flag & ND_NFSV3) {
1492 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1493 eof = fxdr_unsigned(int, *(tl + 1));
1494 } else if (nd->nd_flag & ND_NFSV4) {
1495 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
1496 eof = fxdr_unsigned(int, *tl);
1497 }
1498 NFSM_STRSIZ(retlen, len);
1499 error = nfsm_mbufuio(nd, uiop, retlen);
1500 if (error)
1501 goto nfsmout;
1502 mbuf_freem(nd->nd_mrep);
1503 nd->nd_mrep = NULL;
1504 tsiz -= retlen;
1505 if (!(nd->nd_flag & ND_NFSV2)) {
1506 if (eof || retlen == 0)
1507 tsiz = 0;
1508 } else if (retlen < len)
1509 tsiz = 0;
1510 }
1511 return (0);
1512 nfsmout:
1513 if (nd->nd_mrep != NULL)
1514 mbuf_freem(nd->nd_mrep);
1515 return (error);
1516 }
1517
1518 /*
1519 * nfs write operation
1520 * When called_from_strategy != 0, it should return EIO for an error that
1521 * indicates recovery is in progress, so that the buffer will be left
1522 * dirty and be written back to the server later. If it loops around,
1523 * the recovery thread could get stuck waiting for the buffer and recovery
1524 * will then deadlock.
1525 */
1526 APPLESTATIC int
1527 nfsrpc_write(vnode_t vp, struct uio *uiop, int *iomode, int *must_commit,
1528 struct ucred *cred, NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp,
1529 void *stuff, int called_from_strategy)
1530 {
1531 int error, expireret = 0, retrycnt, nostateid;
1532 u_int32_t clidrev = 0;
1533 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
1534 struct nfsnode *np = VTONFS(vp);
1535 struct ucred *newcred;
1536 struct nfsfh *nfhp = NULL;
1537 nfsv4stateid_t stateid;
1538 void *lckp;
1539
1540 *must_commit = 0;
1541 if (nmp->nm_clp != NULL)
1542 clidrev = nmp->nm_clp->nfsc_clientidrev;
1543 newcred = cred;
1544 if (NFSHASNFSV4(nmp)) {
1545 newcred = NFSNEWCRED(cred);
1546 nfhp = np->n_fhp;
1547 }
1548 retrycnt = 0;
1549 do {
1550 lckp = NULL;
1551 nostateid = 0;
1552 if (NFSHASNFSV4(nmp)) {
1553 (void)nfscl_getstateid(vp, nfhp->nfh_fh, nfhp->nfh_len,
1554 NFSV4OPEN_ACCESSWRITE, 0, newcred, p, &stateid,
1555 &lckp);
1556 if (stateid.other[0] == 0 && stateid.other[1] == 0 &&
1557 stateid.other[2] == 0) {
1558 nostateid = 1;
1559 NFSCL_DEBUG(1, "stateid0 in write\n");
1560 }
1561 }
1562
1563 /*
1564 * If there is no stateid for NFSv4, it means this is an
1565 * extraneous write after close. Basically a poorly
1566 * implemented buffer cache. Just don't do the write.
1567 */
1568 if (nostateid)
1569 error = 0;
1570 else
1571 error = nfsrpc_writerpc(vp, uiop, iomode, must_commit,
1572 newcred, &stateid, p, nap, attrflagp, stuff);
1573 if (error == NFSERR_STALESTATEID)
1574 nfscl_initiate_recovery(nmp->nm_clp);
1575 if (lckp != NULL)
1576 nfscl_lockderef(lckp);
1577 if (error == NFSERR_GRACE || error == NFSERR_STALESTATEID ||
1578 error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
1579 error == NFSERR_OLDSTATEID || error == NFSERR_BADSESSION) {
1580 (void) nfs_catnap(PZERO, error, "nfs_write");
1581 } else if ((error == NFSERR_EXPIRED ||
1582 error == NFSERR_BADSTATEID) && clidrev != 0) {
1583 expireret = nfscl_hasexpired(nmp->nm_clp, clidrev, p);
1584 }
1585 retrycnt++;
1586 } while (error == NFSERR_GRACE || error == NFSERR_DELAY ||
1587 ((error == NFSERR_STALESTATEID || error == NFSERR_BADSESSION ||
1588 error == NFSERR_STALEDONTRECOVER) && called_from_strategy == 0) ||
1589 (error == NFSERR_OLDSTATEID && retrycnt < 20) ||
1590 ((error == NFSERR_EXPIRED || error == NFSERR_BADSTATEID) &&
1591 expireret == 0 && clidrev != 0 && retrycnt < 4));
1592 if (error != 0 && (retrycnt >= 4 ||
1593 ((error == NFSERR_STALESTATEID || error == NFSERR_BADSESSION ||
1594 error == NFSERR_STALEDONTRECOVER) && called_from_strategy != 0)))
1595 error = EIO;
1596 if (NFSHASNFSV4(nmp))
1597 NFSFREECRED(newcred);
1598 return (error);
1599 }
1600
1601 /*
1602 * The actual write RPC.
1603 */
1604 static int
1605 nfsrpc_writerpc(vnode_t vp, struct uio *uiop, int *iomode,
1606 int *must_commit, struct ucred *cred, nfsv4stateid_t *stateidp,
1607 NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp, void *stuff)
1608 {
1609 u_int32_t *tl;
1610 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
1611 struct nfsnode *np = VTONFS(vp);
1612 int error = 0, len, tsiz, rlen, commit, committed = NFSWRITE_FILESYNC;
1613 int wccflag = 0, wsize;
1614 int32_t backup;
1615 struct nfsrv_descript nfsd;
1616 struct nfsrv_descript *nd = &nfsd;
1617 nfsattrbit_t attrbits;
1618 off_t tmp_off;
1619
1620 KASSERT(uiop->uio_iovcnt == 1, ("nfs: writerpc iovcnt > 1"));
1621 *attrflagp = 0;
1622 tsiz = uio_uio_resid(uiop);
1623 tmp_off = uiop->uio_offset + tsiz;
1624 NFSLOCKMNT(nmp);
1625 if (tmp_off > nmp->nm_maxfilesize || tmp_off < uiop->uio_offset) {
1626 NFSUNLOCKMNT(nmp);
1627 return (EFBIG);
1628 }
1629 wsize = nmp->nm_wsize;
1630 NFSUNLOCKMNT(nmp);
1631 nd->nd_mrep = NULL; /* NFSv2 sometimes does a write with */
1632 nd->nd_repstat = 0; /* uio_resid == 0, so the while is not done */
1633 while (tsiz > 0) {
1634 *attrflagp = 0;
1635 len = (tsiz > wsize) ? wsize : tsiz;
1636 NFSCL_REQSTART(nd, NFSPROC_WRITE, vp);
1637 if (nd->nd_flag & ND_NFSV4) {
1638 nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSTATEID);
1639 NFSM_BUILD(tl, u_int32_t *, NFSX_HYPER+2*NFSX_UNSIGNED);
1640 txdr_hyper(uiop->uio_offset, tl);
1641 tl += 2;
1642 *tl++ = txdr_unsigned(*iomode);
1643 *tl = txdr_unsigned(len);
1644 } else if (nd->nd_flag & ND_NFSV3) {
1645 NFSM_BUILD(tl, u_int32_t *, NFSX_HYPER+3*NFSX_UNSIGNED);
1646 txdr_hyper(uiop->uio_offset, tl);
1647 tl += 2;
1648 *tl++ = txdr_unsigned(len);
1649 *tl++ = txdr_unsigned(*iomode);
1650 *tl = txdr_unsigned(len);
1651 } else {
1652 u_int32_t x;
1653
1654 NFSM_BUILD(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
1655 /*
1656 * Not sure why someone changed this, since the
1657 * RFC clearly states that "beginoffset" and
1658 * "totalcount" are ignored, but it wouldn't
1659 * surprise me if there's a busted server out there.
1660 */
1661 /* Set both "begin" and "current" to non-garbage. */
1662 x = txdr_unsigned((u_int32_t)uiop->uio_offset);
1663 *tl++ = x; /* "begin offset" */
1664 *tl++ = x; /* "current offset" */
1665 x = txdr_unsigned(len);
1666 *tl++ = x; /* total to this offset */
1667 *tl = x; /* size of this write */
1668
1669 }
1670 nfsm_uiombuf(nd, uiop, len);
1671 /*
1672 * Although it is tempting to do a normal Getattr Op in the
1673 * NFSv4 compound, the result can be a nearly hung client
1674 * system if the Getattr asks for Owner and/or OwnerGroup.
1675 * It occurs when the client can't map either the Owner or
1676 * Owner_group name in the Getattr reply to a uid/gid. When
1677 * there is a cache miss, the kernel does an upcall to the
1678 * nfsuserd. Then, it can try and read the local /etc/passwd
1679 * or /etc/group file. It can then block in getnewbuf(),
1680 * waiting for dirty writes to be pushed to the NFS server.
1681 * The only reason this doesn't result in a complete
1682 * deadlock, is that the upcall times out and allows
1683 * the write to complete. However, progress is so slow
1684 * that it might just as well be deadlocked.
1685 * As such, we get the rest of the attributes, but not
1686 * Owner or Owner_group.
1687 * nb: nfscl_loadattrcache() needs to be told that these
1688 * partial attributes from a write rpc are being
1689 * passed in, via a argument flag.
1690 */
1691 if (nd->nd_flag & ND_NFSV4) {
1692 NFSWRITEGETATTR_ATTRBIT(&attrbits);
1693 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
1694 *tl = txdr_unsigned(NFSV4OP_GETATTR);
1695 (void) nfsrv_putattrbit(nd, &attrbits);
1696 }
1697 error = nfscl_request(nd, vp, p, cred, stuff);
1698 if (error)
1699 return (error);
1700 if (nd->nd_repstat) {
1701 /*
1702 * In case the rpc gets retried, roll
1703 * the uio fileds changed by nfsm_uiombuf()
1704 * back.
1705 */
1706 uiop->uio_offset -= len;
1707 uio_uio_resid_add(uiop, len);
1708 uio_iov_base_add(uiop, -len);
1709 uio_iov_len_add(uiop, len);
1710 }
1711 if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4)) {
1712 error = nfscl_wcc_data(nd, vp, nap, attrflagp,
1713 &wccflag, stuff);
1714 if (error)
1715 goto nfsmout;
1716 }
1717 if (!nd->nd_repstat) {
1718 if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4)) {
1719 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED
1720 + NFSX_VERF);
1721 rlen = fxdr_unsigned(int, *tl++);
1722 if (rlen == 0) {
1723 error = NFSERR_IO;
1724 goto nfsmout;
1725 } else if (rlen < len) {
1726 backup = len - rlen;
1727 uio_iov_base_add(uiop, -(backup));
1728 uio_iov_len_add(uiop, backup);
1729 uiop->uio_offset -= backup;
1730 uio_uio_resid_add(uiop, backup);
1731 len = rlen;
1732 }
1733 commit = fxdr_unsigned(int, *tl++);
1734
1735 /*
1736 * Return the lowest committment level
1737 * obtained by any of the RPCs.
1738 */
1739 if (committed == NFSWRITE_FILESYNC)
1740 committed = commit;
1741 else if (committed == NFSWRITE_DATASYNC &&
1742 commit == NFSWRITE_UNSTABLE)
1743 committed = commit;
1744 NFSLOCKMNT(nmp);
1745 if (!NFSHASWRITEVERF(nmp)) {
1746 NFSBCOPY((caddr_t)tl,
1747 (caddr_t)&nmp->nm_verf[0],
1748 NFSX_VERF);
1749 NFSSETWRITEVERF(nmp);
1750 } else if (NFSBCMP(tl, nmp->nm_verf,
1751 NFSX_VERF)) {
1752 *must_commit = 1;
1753 NFSBCOPY(tl, nmp->nm_verf, NFSX_VERF);
1754 }
1755 NFSUNLOCKMNT(nmp);
1756 }
1757 if (nd->nd_flag & ND_NFSV4)
1758 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1759 if (nd->nd_flag & (ND_NFSV2 | ND_NFSV4)) {
1760 error = nfsm_loadattr(nd, nap);
1761 if (!error)
1762 *attrflagp = NFS_LATTR_NOSHRINK;
1763 }
1764 } else {
1765 error = nd->nd_repstat;
1766 }
1767 if (error)
1768 goto nfsmout;
1769 NFSWRITERPC_SETTIME(wccflag, np, nap, (nd->nd_flag & ND_NFSV4));
1770 mbuf_freem(nd->nd_mrep);
1771 nd->nd_mrep = NULL;
1772 tsiz -= len;
1773 }
1774 nfsmout:
1775 if (nd->nd_mrep != NULL)
1776 mbuf_freem(nd->nd_mrep);
1777 *iomode = committed;
1778 if (nd->nd_repstat && !error)
1779 error = nd->nd_repstat;
1780 return (error);
1781 }
1782
1783 /*
1784 * nfs mknod rpc
1785 * For NFS v2 this is a kludge. Use a create rpc but with the IFMT bits of the
1786 * mode set to specify the file type and the size field for rdev.
1787 */
1788 APPLESTATIC int
1789 nfsrpc_mknod(vnode_t dvp, char *name, int namelen, struct vattr *vap,
1790 u_int32_t rdev, enum vtype vtyp, struct ucred *cred, NFSPROC_T *p,
1791 struct nfsvattr *dnap, struct nfsvattr *nnap, struct nfsfh **nfhpp,
1792 int *attrflagp, int *dattrflagp, void *dstuff)
1793 {
1794 u_int32_t *tl;
1795 int error = 0;
1796 struct nfsrv_descript nfsd, *nd = &nfsd;
1797 nfsattrbit_t attrbits;
1798
1799 *nfhpp = NULL;
1800 *attrflagp = 0;
1801 *dattrflagp = 0;
1802 if (namelen > NFS_MAXNAMLEN)
1803 return (ENAMETOOLONG);
1804 NFSCL_REQSTART(nd, NFSPROC_MKNOD, dvp);
1805 if (nd->nd_flag & ND_NFSV4) {
1806 if (vtyp == VBLK || vtyp == VCHR) {
1807 NFSM_BUILD(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
1808 *tl++ = vtonfsv34_type(vtyp);
1809 *tl++ = txdr_unsigned(NFSMAJOR(rdev));
1810 *tl = txdr_unsigned(NFSMINOR(rdev));
1811 } else {
1812 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
1813 *tl = vtonfsv34_type(vtyp);
1814 }
1815 }
1816 (void) nfsm_strtom(nd, name, namelen);
1817 if (nd->nd_flag & ND_NFSV3) {
1818 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
1819 *tl = vtonfsv34_type(vtyp);
1820 }
1821 if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4))
1822 nfscl_fillsattr(nd, vap, dvp, 0, 0);
1823 if ((nd->nd_flag & ND_NFSV3) &&
1824 (vtyp == VCHR || vtyp == VBLK)) {
1825 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1826 *tl++ = txdr_unsigned(NFSMAJOR(rdev));
1827 *tl = txdr_unsigned(NFSMINOR(rdev));
1828 }
1829 if (nd->nd_flag & ND_NFSV4) {
1830 NFSGETATTR_ATTRBIT(&attrbits);
1831 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1832 *tl++ = txdr_unsigned(NFSV4OP_GETFH);
1833 *tl = txdr_unsigned(NFSV4OP_GETATTR);
1834 (void) nfsrv_putattrbit(nd, &attrbits);
1835 }
1836 if (nd->nd_flag & ND_NFSV2)
1837 nfscl_fillsattr(nd, vap, dvp, NFSSATTR_SIZERDEV, rdev);
1838 error = nfscl_request(nd, dvp, p, cred, dstuff);
1839 if (error)
1840 return (error);
1841 if (nd->nd_flag & ND_NFSV4)
1842 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
1843 if (!nd->nd_repstat) {
1844 if (nd->nd_flag & ND_NFSV4) {
1845 NFSM_DISSECT(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
1846 error = nfsrv_getattrbits(nd, &attrbits, NULL, NULL);
1847 if (error)
1848 goto nfsmout;
1849 }
1850 error = nfscl_mtofh(nd, nfhpp, nnap, attrflagp);
1851 if (error)
1852 goto nfsmout;
1853 }
1854 if (nd->nd_flag & ND_NFSV3)
1855 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
1856 if (!error && nd->nd_repstat)
1857 error = nd->nd_repstat;
1858 nfsmout:
1859 mbuf_freem(nd->nd_mrep);
1860 return (error);
1861 }
1862
1863 /*
1864 * nfs file create call
1865 * Mostly just call the approriate routine. (I separated out v4, so that
1866 * error recovery wouldn't be as difficult.)
1867 */
1868 APPLESTATIC int
1869 nfsrpc_create(vnode_t dvp, char *name, int namelen, struct vattr *vap,
1870 nfsquad_t cverf, int fmode, struct ucred *cred, NFSPROC_T *p,
1871 struct nfsvattr *dnap, struct nfsvattr *nnap, struct nfsfh **nfhpp,
1872 int *attrflagp, int *dattrflagp, void *dstuff)
1873 {
1874 int error = 0, newone, expireret = 0, retrycnt, unlocked;
1875 struct nfsclowner *owp;
1876 struct nfscldeleg *dp;
1877 struct nfsmount *nmp = VFSTONFS(vnode_mount(dvp));
1878 u_int32_t clidrev;
1879
1880 if (NFSHASNFSV4(nmp)) {
1881 retrycnt = 0;
1882 do {
1883 dp = NULL;
1884 error = nfscl_open(dvp, NULL, 0, (NFSV4OPEN_ACCESSWRITE |
1885 NFSV4OPEN_ACCESSREAD), 0, cred, p, &owp, NULL, &newone,
1886 NULL, 1);
1887 if (error)
1888 return (error);
1889 if (nmp->nm_clp != NULL)
1890 clidrev = nmp->nm_clp->nfsc_clientidrev;
1891 else
1892 clidrev = 0;
1893 error = nfsrpc_createv4(dvp, name, namelen, vap, cverf, fmode,
1894 owp, &dp, cred, p, dnap, nnap, nfhpp, attrflagp, dattrflagp,
1895 dstuff, &unlocked);
1896 /*
1897 * There is no need to invalidate cached attributes here,
1898 * since new post-delegation issue attributes are always
1899 * returned by nfsrpc_createv4() and these will update the
1900 * attribute cache.
1901 */
1902 if (dp != NULL)
1903 (void) nfscl_deleg(nmp->nm_mountp, owp->nfsow_clp,
1904 (*nfhpp)->nfh_fh, (*nfhpp)->nfh_len, cred, p, &dp);
1905 nfscl_ownerrelease(nmp, owp, error, newone, unlocked);
1906 if (error == NFSERR_GRACE || error == NFSERR_STALECLIENTID ||
1907 error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
1908 error == NFSERR_BADSESSION) {
1909 (void) nfs_catnap(PZERO, error, "nfs_open");
1910 } else if ((error == NFSERR_EXPIRED ||
1911 error == NFSERR_BADSTATEID) && clidrev != 0) {
1912 expireret = nfscl_hasexpired(nmp->nm_clp, clidrev, p);
1913 retrycnt++;
1914 }
1915 } while (error == NFSERR_GRACE || error == NFSERR_STALECLIENTID ||
1916 error == NFSERR_STALEDONTRECOVER || error == NFSERR_DELAY ||
1917 error == NFSERR_BADSESSION ||
1918 ((error == NFSERR_EXPIRED || error == NFSERR_BADSTATEID) &&
1919 expireret == 0 && clidrev != 0 && retrycnt < 4));
1920 if (error && retrycnt >= 4)
1921 error = EIO;
1922 } else {
1923 error = nfsrpc_createv23(dvp, name, namelen, vap, cverf,
1924 fmode, cred, p, dnap, nnap, nfhpp, attrflagp, dattrflagp,
1925 dstuff);
1926 }
1927 return (error);
1928 }
1929
1930 /*
1931 * The create rpc for v2 and 3.
1932 */
1933 static int
1934 nfsrpc_createv23(vnode_t dvp, char *name, int namelen, struct vattr *vap,
1935 nfsquad_t cverf, int fmode, struct ucred *cred, NFSPROC_T *p,
1936 struct nfsvattr *dnap, struct nfsvattr *nnap, struct nfsfh **nfhpp,
1937 int *attrflagp, int *dattrflagp, void *dstuff)
1938 {
1939 u_int32_t *tl;
1940 int error = 0;
1941 struct nfsrv_descript nfsd, *nd = &nfsd;
1942
1943 *nfhpp = NULL;
1944 *attrflagp = 0;
1945 *dattrflagp = 0;
1946 if (namelen > NFS_MAXNAMLEN)
1947 return (ENAMETOOLONG);
1948 NFSCL_REQSTART(nd, NFSPROC_CREATE, dvp);
1949 (void) nfsm_strtom(nd, name, namelen);
1950 if (nd->nd_flag & ND_NFSV3) {
1951 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
1952 if (fmode & O_EXCL) {
1953 *tl = txdr_unsigned(NFSCREATE_EXCLUSIVE);
1954 NFSM_BUILD(tl, u_int32_t *, NFSX_VERF);
1955 *tl++ = cverf.lval[0];
1956 *tl = cverf.lval[1];
1957 } else {
1958 *tl = txdr_unsigned(NFSCREATE_UNCHECKED);
1959 nfscl_fillsattr(nd, vap, dvp, 0, 0);
1960 }
1961 } else {
1962 nfscl_fillsattr(nd, vap, dvp, NFSSATTR_SIZE0, 0);
1963 }
1964 error = nfscl_request(nd, dvp, p, cred, dstuff);
1965 if (error)
1966 return (error);
1967 if (nd->nd_repstat == 0) {
1968 error = nfscl_mtofh(nd, nfhpp, nnap, attrflagp);
1969 if (error)
1970 goto nfsmout;
1971 }
1972 if (nd->nd_flag & ND_NFSV3)
1973 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
1974 if (nd->nd_repstat != 0 && error == 0)
1975 error = nd->nd_repstat;
1976 nfsmout:
1977 mbuf_freem(nd->nd_mrep);
1978 return (error);
1979 }
1980
1981 static int
1982 nfsrpc_createv4(vnode_t dvp, char *name, int namelen, struct vattr *vap,
1983 nfsquad_t cverf, int fmode, struct nfsclowner *owp, struct nfscldeleg **dpp,
1984 struct ucred *cred, NFSPROC_T *p, struct nfsvattr *dnap,
1985 struct nfsvattr *nnap, struct nfsfh **nfhpp, int *attrflagp,
1986 int *dattrflagp, void *dstuff, int *unlockedp)
1987 {
1988 u_int32_t *tl;
1989 int error = 0, deleg, newone, ret, acesize, limitby;
1990 struct nfsrv_descript nfsd, *nd = &nfsd;
1991 struct nfsclopen *op;
1992 struct nfscldeleg *dp = NULL;
1993 struct nfsnode *np;
1994 struct nfsfh *nfhp;
1995 nfsattrbit_t attrbits;
1996 nfsv4stateid_t stateid;
1997 u_int32_t rflags;
1998 struct nfsmount *nmp;
1999 struct nfsclsession *tsep;
2000
2001 nmp = VFSTONFS(dvp->v_mount);
2002 np = VTONFS(dvp);
2003 *unlockedp = 0;
2004 *nfhpp = NULL;
2005 *dpp = NULL;
2006 *attrflagp = 0;
2007 *dattrflagp = 0;
2008 if (namelen > NFS_MAXNAMLEN)
2009 return (ENAMETOOLONG);
2010 NFSCL_REQSTART(nd, NFSPROC_CREATE, dvp);
2011 /*
2012 * For V4, this is actually an Open op.
2013 */
2014 NFSM_BUILD(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
2015 *tl++ = txdr_unsigned(owp->nfsow_seqid);
2016 *tl++ = txdr_unsigned(NFSV4OPEN_ACCESSWRITE |
2017 NFSV4OPEN_ACCESSREAD);
2018 *tl++ = txdr_unsigned(NFSV4OPEN_DENYNONE);
2019 tsep = nfsmnt_mdssession(nmp);
2020 *tl++ = tsep->nfsess_clientid.lval[0];
2021 *tl = tsep->nfsess_clientid.lval[1];
2022 (void) nfsm_strtom(nd, owp->nfsow_owner, NFSV4CL_LOCKNAMELEN);
2023 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2024 *tl++ = txdr_unsigned(NFSV4OPEN_CREATE);
2025 if (fmode & O_EXCL) {
2026 if (NFSHASNFSV4N(nmp)) {
2027 if (NFSHASSESSPERSIST(nmp)) {
2028 /* Use GUARDED for persistent sessions. */
2029 *tl = txdr_unsigned(NFSCREATE_GUARDED);
2030 nfscl_fillsattr(nd, vap, dvp, 0, 0);
2031 } else {
2032 /* Otherwise, use EXCLUSIVE4_1. */
2033 *tl = txdr_unsigned(NFSCREATE_EXCLUSIVE41);
2034 NFSM_BUILD(tl, u_int32_t *, NFSX_VERF);
2035 *tl++ = cverf.lval[0];
2036 *tl = cverf.lval[1];
2037 nfscl_fillsattr(nd, vap, dvp, 0, 0);
2038 }
2039 } else {
2040 /* NFSv4.0 */
2041 *tl = txdr_unsigned(NFSCREATE_EXCLUSIVE);
2042 NFSM_BUILD(tl, u_int32_t *, NFSX_VERF);
2043 *tl++ = cverf.lval[0];
2044 *tl = cverf.lval[1];
2045 }
2046 } else {
2047 *tl = txdr_unsigned(NFSCREATE_UNCHECKED);
2048 nfscl_fillsattr(nd, vap, dvp, 0, 0);
2049 }
2050 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2051 *tl = txdr_unsigned(NFSV4OPEN_CLAIMNULL);
2052 (void) nfsm_strtom(nd, name, namelen);
2053 /* Get the new file's handle and attributes. */
2054 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2055 *tl++ = txdr_unsigned(NFSV4OP_GETFH);
2056 *tl = txdr_unsigned(NFSV4OP_GETATTR);
2057 NFSGETATTR_ATTRBIT(&attrbits);
2058 (void) nfsrv_putattrbit(nd, &attrbits);
2059 /* Get the directory's post-op attributes. */
2060 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2061 *tl = txdr_unsigned(NFSV4OP_PUTFH);
2062 (void) nfsm_fhtom(nd, np->n_fhp->nfh_fh, np->n_fhp->nfh_len, 0);
2063 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2064 *tl = txdr_unsigned(NFSV4OP_GETATTR);
2065 (void) nfsrv_putattrbit(nd, &attrbits);
2066 error = nfscl_request(nd, dvp, p, cred, dstuff);
2067 if (error)
2068 return (error);
2069 NFSCL_INCRSEQID(owp->nfsow_seqid, nd);
2070 if (nd->nd_repstat == 0) {
2071 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID +
2072 6 * NFSX_UNSIGNED);
2073 stateid.seqid = *tl++;
2074 stateid.other[0] = *tl++;
2075 stateid.other[1] = *tl++;
2076 stateid.other[2] = *tl;
2077 rflags = fxdr_unsigned(u_int32_t, *(tl + 6));
2078 (void) nfsrv_getattrbits(nd, &attrbits, NULL, NULL);
2079 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2080 deleg = fxdr_unsigned(int, *tl);
2081 if (deleg == NFSV4OPEN_DELEGATEREAD ||
2082 deleg == NFSV4OPEN_DELEGATEWRITE) {
2083 if (!(owp->nfsow_clp->nfsc_flags &
2084 NFSCLFLAGS_FIRSTDELEG))
2085 owp->nfsow_clp->nfsc_flags |=
2086 (NFSCLFLAGS_FIRSTDELEG | NFSCLFLAGS_GOTDELEG);
2087 MALLOC(dp, struct nfscldeleg *,
2088 sizeof (struct nfscldeleg) + NFSX_V4FHMAX,
2089 M_NFSCLDELEG, M_WAITOK);
2090 LIST_INIT(&dp->nfsdl_owner);
2091 LIST_INIT(&dp->nfsdl_lock);
2092 dp->nfsdl_clp = owp->nfsow_clp;
2093 newnfs_copyincred(cred, &dp->nfsdl_cred);
2094 nfscl_lockinit(&dp->nfsdl_rwlock);
2095 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID +
2096 NFSX_UNSIGNED);
2097 dp->nfsdl_stateid.seqid = *tl++;
2098 dp->nfsdl_stateid.other[0] = *tl++;
2099 dp->nfsdl_stateid.other[1] = *tl++;
2100 dp->nfsdl_stateid.other[2] = *tl++;
2101 ret = fxdr_unsigned(int, *tl);
2102 if (deleg == NFSV4OPEN_DELEGATEWRITE) {
2103 dp->nfsdl_flags = NFSCLDL_WRITE;
2104 /*
2105 * Indicates how much the file can grow.
2106 */
2107 NFSM_DISSECT(tl, u_int32_t *,
2108 3 * NFSX_UNSIGNED);
2109 limitby = fxdr_unsigned(int, *tl++);
2110 switch (limitby) {
2111 case NFSV4OPEN_LIMITSIZE:
2112 dp->nfsdl_sizelimit = fxdr_hyper(tl);
2113 break;
2114 case NFSV4OPEN_LIMITBLOCKS:
2115 dp->nfsdl_sizelimit =
2116 fxdr_unsigned(u_int64_t, *tl++);
2117 dp->nfsdl_sizelimit *=
2118 fxdr_unsigned(u_int64_t, *tl);
2119 break;
2120 default:
2121 error = NFSERR_BADXDR;
2122 goto nfsmout;
2123 };
2124 } else {
2125 dp->nfsdl_flags = NFSCLDL_READ;
2126 }
2127 if (ret)
2128 dp->nfsdl_flags |= NFSCLDL_RECALL;
2129 error = nfsrv_dissectace(nd, &dp->nfsdl_ace, &ret,
2130 &acesize, p);
2131 if (error)
2132 goto nfsmout;
2133 } else if (deleg != NFSV4OPEN_DELEGATENONE) {
2134 error = NFSERR_BADXDR;
2135 goto nfsmout;
2136 }
2137 error = nfscl_mtofh(nd, nfhpp, nnap, attrflagp);
2138 if (error)
2139 goto nfsmout;
2140 /* Get rid of the PutFH and Getattr status values. */
2141 NFSM_DISSECT(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
2142 /* Load the directory attributes. */
2143 error = nfsm_loadattr(nd, dnap);
2144 if (error)
2145 goto nfsmout;
2146 *dattrflagp = 1;
2147 if (dp != NULL && *attrflagp) {
2148 dp->nfsdl_change = nnap->na_filerev;
2149 dp->nfsdl_modtime = nnap->na_mtime;
2150 dp->nfsdl_flags |= NFSCLDL_MODTIMESET;
2151 }
2152 /*
2153 * We can now complete the Open state.
2154 */
2155 nfhp = *nfhpp;
2156 if (dp != NULL) {
2157 dp->nfsdl_fhlen = nfhp->nfh_len;
2158 NFSBCOPY(nfhp->nfh_fh, dp->nfsdl_fh, nfhp->nfh_len);
2159 }
2160 /*
2161 * Get an Open structure that will be
2162 * attached to the OpenOwner, acquired already.
2163 */
2164 error = nfscl_open(dvp, nfhp->nfh_fh, nfhp->nfh_len,
2165 (NFSV4OPEN_ACCESSWRITE | NFSV4OPEN_ACCESSREAD), 0,
2166 cred, p, NULL, &op, &newone, NULL, 0);
2167 if (error)
2168 goto nfsmout;
2169 op->nfso_stateid = stateid;
2170 newnfs_copyincred(cred, &op->nfso_cred);
2171 if ((rflags & NFSV4OPEN_RESULTCONFIRM)) {
2172 do {
2173 ret = nfsrpc_openconfirm(dvp, nfhp->nfh_fh,
2174 nfhp->nfh_len, op, cred, p);
2175 if (ret == NFSERR_DELAY)
2176 (void) nfs_catnap(PZERO, ret, "nfs_create");
2177 } while (ret == NFSERR_DELAY);
2178 error = ret;
2179 }
2180
2181 /*
2182 * If the server is handing out delegations, but we didn't
2183 * get one because an OpenConfirm was required, try the
2184 * Open again, to get a delegation. This is a harmless no-op,
2185 * from a server's point of view.
2186 */
2187 if ((rflags & NFSV4OPEN_RESULTCONFIRM) &&
2188 (owp->nfsow_clp->nfsc_flags & NFSCLFLAGS_GOTDELEG) &&
2189 !error && dp == NULL) {
2190 do {
2191 ret = nfsrpc_openrpc(VFSTONFS(vnode_mount(dvp)), dvp,
2192 np->n_fhp->nfh_fh, np->n_fhp->nfh_len,
2193 nfhp->nfh_fh, nfhp->nfh_len,
2194 (NFSV4OPEN_ACCESSWRITE | NFSV4OPEN_ACCESSREAD), op,
2195 name, namelen, &dp, 0, 0x0, cred, p, 0, 1);
2196 if (ret == NFSERR_DELAY)
2197 (void) nfs_catnap(PZERO, ret, "nfs_crt2");
2198 } while (ret == NFSERR_DELAY);
2199 if (ret) {
2200 if (dp != NULL) {
2201 FREE((caddr_t)dp, M_NFSCLDELEG);
2202 dp = NULL;
2203 }
2204 if (ret == NFSERR_STALECLIENTID ||
2205 ret == NFSERR_STALEDONTRECOVER ||
2206 ret == NFSERR_BADSESSION)
2207 error = ret;
2208 }
2209 }
2210 nfscl_openrelease(nmp, op, error, newone);
2211 *unlockedp = 1;
2212 }
2213 if (nd->nd_repstat != 0 && error == 0)
2214 error = nd->nd_repstat;
2215 if (error == NFSERR_STALECLIENTID)
2216 nfscl_initiate_recovery(owp->nfsow_clp);
2217 nfsmout:
2218 if (!error)
2219 *dpp = dp;
2220 else if (dp != NULL)
2221 FREE((caddr_t)dp, M_NFSCLDELEG);
2222 mbuf_freem(nd->nd_mrep);
2223 return (error);
2224 }
2225
2226 /*
2227 * Nfs remove rpc
2228 */
2229 APPLESTATIC int
2230 nfsrpc_remove(vnode_t dvp, char *name, int namelen, vnode_t vp,
2231 struct ucred *cred, NFSPROC_T *p, struct nfsvattr *dnap, int *dattrflagp,
2232 void *dstuff)
2233 {
2234 u_int32_t *tl;
2235 struct nfsrv_descript nfsd, *nd = &nfsd;
2236 struct nfsnode *np;
2237 struct nfsmount *nmp;
2238 nfsv4stateid_t dstateid;
2239 int error, ret = 0, i;
2240
2241 *dattrflagp = 0;
2242 if (namelen > NFS_MAXNAMLEN)
2243 return (ENAMETOOLONG);
2244 nmp = VFSTONFS(vnode_mount(dvp));
2245 tryagain:
2246 if (NFSHASNFSV4(nmp) && ret == 0) {
2247 ret = nfscl_removedeleg(vp, p, &dstateid);
2248 if (ret == 1) {
2249 NFSCL_REQSTART(nd, NFSPROC_RETDELEGREMOVE, vp);
2250 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID +
2251 NFSX_UNSIGNED);
2252 if (NFSHASNFSV4N(nmp))
2253 *tl++ = 0;
2254 else
2255 *tl++ = dstateid.seqid;
2256 *tl++ = dstateid.other[0];
2257 *tl++ = dstateid.other[1];
2258 *tl++ = dstateid.other[2];
2259 *tl = txdr_unsigned(NFSV4OP_PUTFH);
2260 np = VTONFS(dvp);
2261 (void) nfsm_fhtom(nd, np->n_fhp->nfh_fh,
2262 np->n_fhp->nfh_len, 0);
2263 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2264 *tl = txdr_unsigned(NFSV4OP_REMOVE);
2265 }
2266 } else {
2267 ret = 0;
2268 }
2269 if (ret == 0)
2270 NFSCL_REQSTART(nd, NFSPROC_REMOVE, dvp);
2271 (void) nfsm_strtom(nd, name, namelen);
2272 error = nfscl_request(nd, dvp, p, cred, dstuff);
2273 if (error)
2274 return (error);
2275 if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4)) {
2276 /* For NFSv4, parse out any Delereturn replies. */
2277 if (ret > 0 && nd->nd_repstat != 0 &&
2278 (nd->nd_flag & ND_NOMOREDATA)) {
2279 /*
2280 * If the Delegreturn failed, try again without
2281 * it. The server will Recall, as required.
2282 */
2283 mbuf_freem(nd->nd_mrep);
2284 goto tryagain;
2285 }
2286 for (i = 0; i < (ret * 2); i++) {
2287 if ((nd->nd_flag & (ND_NFSV4 | ND_NOMOREDATA)) ==
2288 ND_NFSV4) {
2289 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2290 if (*(tl + 1))
2291 nd->nd_flag |= ND_NOMOREDATA;
2292 }
2293 }
2294 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
2295 }
2296 if (nd->nd_repstat && !error)
2297 error = nd->nd_repstat;
2298 nfsmout:
2299 mbuf_freem(nd->nd_mrep);
2300 return (error);
2301 }
2302
2303 /*
2304 * Do an nfs rename rpc.
2305 */
2306 APPLESTATIC int
2307 nfsrpc_rename(vnode_t fdvp, vnode_t fvp, char *fnameptr, int fnamelen,
2308 vnode_t tdvp, vnode_t tvp, char *tnameptr, int tnamelen, struct ucred *cred,
2309 NFSPROC_T *p, struct nfsvattr *fnap, struct nfsvattr *tnap,
2310 int *fattrflagp, int *tattrflagp, void *fstuff, void *tstuff)
2311 {
2312 u_int32_t *tl;
2313 struct nfsrv_descript nfsd, *nd = &nfsd;
2314 struct nfsmount *nmp;
2315 struct nfsnode *np;
2316 nfsattrbit_t attrbits;
2317 nfsv4stateid_t fdstateid, tdstateid;
2318 int error = 0, ret = 0, gottd = 0, gotfd = 0, i;
2319
2320 *fattrflagp = 0;
2321 *tattrflagp = 0;
2322 nmp = VFSTONFS(vnode_mount(fdvp));
2323 if (fnamelen > NFS_MAXNAMLEN || tnamelen > NFS_MAXNAMLEN)
2324 return (ENAMETOOLONG);
2325 tryagain:
2326 if (NFSHASNFSV4(nmp) && ret == 0) {
2327 ret = nfscl_renamedeleg(fvp, &fdstateid, &gotfd, tvp,
2328 &tdstateid, &gottd, p);
2329 if (gotfd && gottd) {
2330 NFSCL_REQSTART(nd, NFSPROC_RETDELEGRENAME2, fvp);
2331 } else if (gotfd) {
2332 NFSCL_REQSTART(nd, NFSPROC_RETDELEGRENAME1, fvp);
2333 } else if (gottd) {
2334 NFSCL_REQSTART(nd, NFSPROC_RETDELEGRENAME1, tvp);
2335 }
2336 if (gotfd) {
2337 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID);
2338 if (NFSHASNFSV4N(nmp))
2339 *tl++ = 0;
2340 else
2341 *tl++ = fdstateid.seqid;
2342 *tl++ = fdstateid.other[0];
2343 *tl++ = fdstateid.other[1];
2344 *tl = fdstateid.other[2];
2345 if (gottd) {
2346 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2347 *tl = txdr_unsigned(NFSV4OP_PUTFH);
2348 np = VTONFS(tvp);
2349 (void) nfsm_fhtom(nd, np->n_fhp->nfh_fh,
2350 np->n_fhp->nfh_len, 0);
2351 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2352 *tl = txdr_unsigned(NFSV4OP_DELEGRETURN);
2353 }
2354 }
2355 if (gottd) {
2356 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID);
2357 if (NFSHASNFSV4N(nmp))
2358 *tl++ = 0;
2359 else
2360 *tl++ = tdstateid.seqid;
2361 *tl++ = tdstateid.other[0];
2362 *tl++ = tdstateid.other[1];
2363 *tl = tdstateid.other[2];
2364 }
2365 if (ret > 0) {
2366 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2367 *tl = txdr_unsigned(NFSV4OP_PUTFH);
2368 np = VTONFS(fdvp);
2369 (void) nfsm_fhtom(nd, np->n_fhp->nfh_fh,
2370 np->n_fhp->nfh_len, 0);
2371 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2372 *tl = txdr_unsigned(NFSV4OP_SAVEFH);
2373 }
2374 } else {
2375 ret = 0;
2376 }
2377 if (ret == 0)
2378 NFSCL_REQSTART(nd, NFSPROC_RENAME, fdvp);
2379 if (nd->nd_flag & ND_NFSV4) {
2380 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2381 *tl = txdr_unsigned(NFSV4OP_GETATTR);
2382 NFSWCCATTR_ATTRBIT(&attrbits);
2383 (void) nfsrv_putattrbit(nd, &attrbits);
2384 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2385 *tl = txdr_unsigned(NFSV4OP_PUTFH);
2386 (void) nfsm_fhtom(nd, VTONFS(tdvp)->n_fhp->nfh_fh,
2387 VTONFS(tdvp)->n_fhp->nfh_len, 0);
2388 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2389 *tl = txdr_unsigned(NFSV4OP_GETATTR);
2390 (void) nfsrv_putattrbit(nd, &attrbits);
2391 nd->nd_flag |= ND_V4WCCATTR;
2392 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2393 *tl = txdr_unsigned(NFSV4OP_RENAME);
2394 }
2395 (void) nfsm_strtom(nd, fnameptr, fnamelen);
2396 if (!(nd->nd_flag & ND_NFSV4))
2397 (void) nfsm_fhtom(nd, VTONFS(tdvp)->n_fhp->nfh_fh,
2398 VTONFS(tdvp)->n_fhp->nfh_len, 0);
2399 (void) nfsm_strtom(nd, tnameptr, tnamelen);
2400 error = nfscl_request(nd, fdvp, p, cred, fstuff);
2401 if (error)
2402 return (error);
2403 if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4)) {
2404 /* For NFSv4, parse out any Delereturn replies. */
2405 if (ret > 0 && nd->nd_repstat != 0 &&
2406 (nd->nd_flag & ND_NOMOREDATA)) {
2407 /*
2408 * If the Delegreturn failed, try again without
2409 * it. The server will Recall, as required.
2410 */
2411 mbuf_freem(nd->nd_mrep);
2412 goto tryagain;
2413 }
2414 for (i = 0; i < (ret * 2); i++) {
2415 if ((nd->nd_flag & (ND_NFSV4 | ND_NOMOREDATA)) ==
2416 ND_NFSV4) {
2417 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2418 if (*(tl + 1)) {
2419 if (i == 0 && ret > 1) {
2420 /*
2421 * If the Delegreturn failed, try again
2422 * without it. The server will Recall, as
2423 * required.
2424 * If ret > 1, the first iteration of this
2425 * loop is the second DelegReturn result.
2426 */
2427 mbuf_freem(nd->nd_mrep);
2428 goto tryagain;
2429 } else {
2430 nd->nd_flag |= ND_NOMOREDATA;
2431 }
2432 }
2433 }
2434 }
2435 /* Now, the first wcc attribute reply. */
2436 if ((nd->nd_flag & (ND_NFSV4 | ND_NOMOREDATA)) == ND_NFSV4) {
2437 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2438 if (*(tl + 1))
2439 nd->nd_flag |= ND_NOMOREDATA;
2440 }
2441 error = nfscl_wcc_data(nd, fdvp, fnap, fattrflagp, NULL,
2442 fstuff);
2443 /* and the second wcc attribute reply. */
2444 if ((nd->nd_flag & (ND_NFSV4 | ND_NOMOREDATA)) == ND_NFSV4 &&
2445 !error) {
2446 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2447 if (*(tl + 1))
2448 nd->nd_flag |= ND_NOMOREDATA;
2449 }
2450 if (!error)
2451 error = nfscl_wcc_data(nd, tdvp, tnap, tattrflagp,
2452 NULL, tstuff);
2453 }
2454 if (nd->nd_repstat && !error)
2455 error = nd->nd_repstat;
2456 nfsmout:
2457 mbuf_freem(nd->nd_mrep);
2458 return (error);
2459 }
2460
2461 /*
2462 * nfs hard link create rpc
2463 */
2464 APPLESTATIC int
2465 nfsrpc_link(vnode_t dvp, vnode_t vp, char *name, int namelen,
2466 struct ucred *cred, NFSPROC_T *p, struct nfsvattr *dnap,
2467 struct nfsvattr *nap, int *attrflagp, int *dattrflagp, void *dstuff)
2468 {
2469 u_int32_t *tl;
2470 struct nfsrv_descript nfsd, *nd = &nfsd;
2471 nfsattrbit_t attrbits;
2472 int error = 0;
2473
2474 *attrflagp = 0;
2475 *dattrflagp = 0;
2476 if (namelen > NFS_MAXNAMLEN)
2477 return (ENAMETOOLONG);
2478 NFSCL_REQSTART(nd, NFSPROC_LINK, vp);
2479 if (nd->nd_flag & ND_NFSV4) {
2480 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2481 *tl = txdr_unsigned(NFSV4OP_PUTFH);
2482 }
2483 (void) nfsm_fhtom(nd, VTONFS(dvp)->n_fhp->nfh_fh,
2484 VTONFS(dvp)->n_fhp->nfh_len, 0);
2485 if (nd->nd_flag & ND_NFSV4) {
2486 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2487 *tl = txdr_unsigned(NFSV4OP_GETATTR);
2488 NFSWCCATTR_ATTRBIT(&attrbits);
2489 (void) nfsrv_putattrbit(nd, &attrbits);
2490 nd->nd_flag |= ND_V4WCCATTR;
2491 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2492 *tl = txdr_unsigned(NFSV4OP_LINK);
2493 }
2494 (void) nfsm_strtom(nd, name, namelen);
2495 error = nfscl_request(nd, vp, p, cred, dstuff);
2496 if (error)
2497 return (error);
2498 if (nd->nd_flag & ND_NFSV3) {
2499 error = nfscl_postop_attr(nd, nap, attrflagp, dstuff);
2500 if (!error)
2501 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp,
2502 NULL, dstuff);
2503 } else if ((nd->nd_flag & (ND_NFSV4 | ND_NOMOREDATA)) == ND_NFSV4) {
2504 /*
2505 * First, parse out the PutFH and Getattr result.
2506 */
2507 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2508 if (!(*(tl + 1)))
2509 NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2510 if (*(tl + 1))
2511 nd->nd_flag |= ND_NOMOREDATA;
2512 /*
2513 * Get the pre-op attributes.
2514 */
2515 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
2516 }
2517 if (nd->nd_repstat && !error)
2518 error = nd->nd_repstat;
2519 nfsmout:
2520 mbuf_freem(nd->nd_mrep);
2521 return (error);
2522 }
2523
2524 /*
2525 * nfs symbolic link create rpc
2526 */
2527 APPLESTATIC int
2528 nfsrpc_symlink(vnode_t dvp, char *name, int namelen, char *target,
2529 struct vattr *vap, struct ucred *cred, NFSPROC_T *p, struct nfsvattr *dnap,
2530 struct nfsvattr *nnap, struct nfsfh **nfhpp, int *attrflagp,
2531 int *dattrflagp, void *dstuff)
2532 {
2533 u_int32_t *tl;
2534 struct nfsrv_descript nfsd, *nd = &nfsd;
2535 struct nfsmount *nmp;
2536 int slen, error = 0;
2537
2538 *nfhpp = NULL;
2539 *attrflagp = 0;
2540 *dattrflagp = 0;
2541 nmp = VFSTONFS(vnode_mount(dvp));
2542 slen = strlen(target);
2543 if (slen > NFS_MAXPATHLEN || namelen > NFS_MAXNAMLEN)
2544 return (ENAMETOOLONG);
2545 NFSCL_REQSTART(nd, NFSPROC_SYMLINK, dvp);
2546 if (nd->nd_flag & ND_NFSV4) {
2547 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2548 *tl = txdr_unsigned(NFLNK);
2549 (void) nfsm_strtom(nd, target, slen);
2550 }
2551 (void) nfsm_strtom(nd, name, namelen);
2552 if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4))
2553 nfscl_fillsattr(nd, vap, dvp, 0, 0);
2554 if (!(nd->nd_flag & ND_NFSV4))
2555 (void) nfsm_strtom(nd, target, slen);
2556 if (nd->nd_flag & ND_NFSV2)
2557 nfscl_fillsattr(nd, vap, dvp, NFSSATTR_SIZENEG1, 0);
2558 error = nfscl_request(nd, dvp, p, cred, dstuff);
2559 if (error)
2560 return (error);
2561 if (nd->nd_flag & ND_NFSV4)
2562 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
2563 if ((nd->nd_flag & ND_NFSV3) && !error) {
2564 if (!nd->nd_repstat)
2565 error = nfscl_mtofh(nd, nfhpp, nnap, attrflagp);
2566 if (!error)
2567 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp,
2568 NULL, dstuff);
2569 }
2570 if (nd->nd_repstat && !error)
2571 error = nd->nd_repstat;
2572 mbuf_freem(nd->nd_mrep);
2573 /*
2574 * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
2575 * Only do this if vfs.nfs.ignore_eexist is set.
2576 * Never do this for NFSv4.1 or later minor versions, since sessions
2577 * should guarantee "exactly once" RPC semantics.
2578 */
2579 if (error == EEXIST && nfsignore_eexist != 0 && (!NFSHASNFSV4(nmp) ||
2580 nmp->nm_minorvers == 0))
2581 error = 0;
2582 return (error);
2583 }
2584
2585 /*
2586 * nfs make dir rpc
2587 */
2588 APPLESTATIC int
2589 nfsrpc_mkdir(vnode_t dvp, char *name, int namelen, struct vattr *vap,
2590 struct ucred *cred, NFSPROC_T *p, struct nfsvattr *dnap,
2591 struct nfsvattr *nnap, struct nfsfh **nfhpp, int *attrflagp,
2592 int *dattrflagp, void *dstuff)
2593 {
2594 u_int32_t *tl;
2595 struct nfsrv_descript nfsd, *nd = &nfsd;
2596 nfsattrbit_t attrbits;
2597 int error = 0;
2598 struct nfsfh *fhp;
2599 struct nfsmount *nmp;
2600
2601 *nfhpp = NULL;
2602 *attrflagp = 0;
2603 *dattrflagp = 0;
2604 nmp = VFSTONFS(vnode_mount(dvp));
2605 fhp = VTONFS(dvp)->n_fhp;
2606 if (namelen > NFS_MAXNAMLEN)
2607 return (ENAMETOOLONG);
2608 NFSCL_REQSTART(nd, NFSPROC_MKDIR, dvp);
2609 if (nd->nd_flag & ND_NFSV4) {
2610 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2611 *tl = txdr_unsigned(NFDIR);
2612 }
2613 (void) nfsm_strtom(nd, name, namelen);
2614 nfscl_fillsattr(nd, vap, dvp, NFSSATTR_SIZENEG1, 0);
2615 if (nd->nd_flag & ND_NFSV4) {
2616 NFSGETATTR_ATTRBIT(&attrbits);
2617 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2618 *tl++ = txdr_unsigned(NFSV4OP_GETFH);
2619 *tl = txdr_unsigned(NFSV4OP_GETATTR);
2620 (void) nfsrv_putattrbit(nd, &attrbits);
2621 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2622 *tl = txdr_unsigned(NFSV4OP_PUTFH);
2623 (void) nfsm_fhtom(nd, fhp->nfh_fh, fhp->nfh_len, 0);
2624 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2625 *tl = txdr_unsigned(NFSV4OP_GETATTR);
2626 (void) nfsrv_putattrbit(nd, &attrbits);
2627 }
2628 error = nfscl_request(nd, dvp, p, cred, dstuff);
2629 if (error)
2630 return (error);
2631 if (nd->nd_flag & ND_NFSV4)
2632 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
2633 if (!nd->nd_repstat && !error) {
2634 if (nd->nd_flag & ND_NFSV4) {
2635 NFSM_DISSECT(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
2636 error = nfsrv_getattrbits(nd, &attrbits, NULL, NULL);
2637 }
2638 if (!error)
2639 error = nfscl_mtofh(nd, nfhpp, nnap, attrflagp);
2640 if (error == 0 && (nd->nd_flag & ND_NFSV4) != 0) {
2641 /* Get rid of the PutFH and Getattr status values. */
2642 NFSM_DISSECT(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
2643 /* Load the directory attributes. */
2644 error = nfsm_loadattr(nd, dnap);
2645 if (error == 0)
2646 *dattrflagp = 1;
2647 }
2648 }
2649 if ((nd->nd_flag & ND_NFSV3) && !error)
2650 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
2651 if (nd->nd_repstat && !error)
2652 error = nd->nd_repstat;
2653 nfsmout:
2654 mbuf_freem(nd->nd_mrep);
2655 /*
2656 * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
2657 * Only do this if vfs.nfs.ignore_eexist is set.
2658 * Never do this for NFSv4.1 or later minor versions, since sessions
2659 * should guarantee "exactly once" RPC semantics.
2660 */
2661 if (error == EEXIST && nfsignore_eexist != 0 && (!NFSHASNFSV4(nmp) ||
2662 nmp->nm_minorvers == 0))
2663 error = 0;
2664 return (error);
2665 }
2666
2667 /*
2668 * nfs remove directory call
2669 */
2670 APPLESTATIC int
2671 nfsrpc_rmdir(vnode_t dvp, char *name, int namelen, struct ucred *cred,
2672 NFSPROC_T *p, struct nfsvattr *dnap, int *dattrflagp, void *dstuff)
2673 {
2674 struct nfsrv_descript nfsd, *nd = &nfsd;
2675 int error = 0;
2676
2677 *dattrflagp = 0;
2678 if (namelen > NFS_MAXNAMLEN)
2679 return (ENAMETOOLONG);
2680 NFSCL_REQSTART(nd, NFSPROC_RMDIR, dvp);
2681 (void) nfsm_strtom(nd, name, namelen);
2682 error = nfscl_request(nd, dvp, p, cred, dstuff);
2683 if (error)
2684 return (error);
2685 if (nd->nd_flag & (ND_NFSV3 | ND_NFSV4))
2686 error = nfscl_wcc_data(nd, dvp, dnap, dattrflagp, NULL, dstuff);
2687 if (nd->nd_repstat && !error)
2688 error = nd->nd_repstat;
2689 mbuf_freem(nd->nd_mrep);
2690 /*
2691 * Kludge: Map ENOENT => 0 assuming that you have a reply to a retry.
2692 */
2693 if (error == ENOENT)
2694 error = 0;
2695 return (error);
2696 }
2697
2698 /*
2699 * Readdir rpc.
2700 * Always returns with either uio_resid unchanged, if you are at the
2701 * end of the directory, or uio_resid == 0, with all DIRBLKSIZ chunks
2702 * filled in.
2703 * I felt this would allow caching of directory blocks more easily
2704 * than returning a pertially filled block.
2705 * Directory offset cookies:
2706 * Oh my, what to do with them...
2707 * I can think of three ways to deal with them:
2708 * 1 - have the layer above these RPCs maintain a map between logical
2709 * directory byte offsets and the NFS directory offset cookies
2710 * 2 - pass the opaque directory offset cookies up into userland
2711 * and let the libc functions deal with them, via the system call
2712 * 3 - return them to userland in the "struct dirent", so future versions
2713 * of libc can use them and do whatever is necessary to amke things work
2714 * above these rpc calls, in the meantime
2715 * For now, I do #3 by "hiding" the directory offset cookies after the
2716 * d_name field in struct dirent. This is space inside d_reclen that
2717 * will be ignored by anything that doesn't know about them.
2718 * The directory offset cookies are filled in as the last 8 bytes of
2719 * each directory entry, after d_name. Someday, the userland libc
2720 * functions may be able to use these. In the meantime, it satisfies
2721 * OpenBSD's requirements for cookies being returned.
2722 * If expects the directory offset cookie for the read to be in uio_offset
2723 * and returns the one for the next entry after this directory block in
2724 * there, as well.
2725 */
2726 APPLESTATIC int
2727 nfsrpc_readdir(vnode_t vp, struct uio *uiop, nfsuint64 *cookiep,
2728 struct ucred *cred, NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp,
2729 int *eofp, void *stuff)
2730 {
2731 int len, left;
2732 struct dirent *dp = NULL;
2733 u_int32_t *tl;
2734 nfsquad_t cookie, ncookie;
2735 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
2736 struct nfsnode *dnp = VTONFS(vp);
2737 struct nfsvattr nfsva;
2738 struct nfsrv_descript nfsd, *nd = &nfsd;
2739 int error = 0, tlen, more_dirs = 1, blksiz = 0, bigenough = 1;
2740 int reqsize, tryformoredirs = 1, readsize, eof = 0, gotmnton = 0;
2741 long dotfileid, dotdotfileid = 0;
2742 u_int32_t fakefileno = 0xffffffff, rderr;
2743 char *cp;
2744 nfsattrbit_t attrbits, dattrbits;
2745 u_int32_t *tl2 = NULL;
2746 size_t tresid;
2747
2748 KASSERT(uiop->uio_iovcnt == 1 &&
2749 (uio_uio_resid(uiop) & (DIRBLKSIZ - 1)) == 0,
2750 ("nfs readdirrpc bad uio"));
2751
2752 /*
2753 * There is no point in reading a lot more than uio_resid, however
2754 * adding one additional DIRBLKSIZ makes sense. Since uio_resid
2755 * and nm_readdirsize are both exact multiples of DIRBLKSIZ, this
2756 * will never make readsize > nm_readdirsize.
2757 */
2758 readsize = nmp->nm_readdirsize;
2759 if (readsize > uio_uio_resid(uiop))
2760 readsize = uio_uio_resid(uiop) + DIRBLKSIZ;
2761
2762 *attrflagp = 0;
2763 if (eofp)
2764 *eofp = 0;
2765 tresid = uio_uio_resid(uiop);
2766 cookie.lval[0] = cookiep->nfsuquad[0];
2767 cookie.lval[1] = cookiep->nfsuquad[1];
2768 nd->nd_mrep = NULL;
2769
2770 /*
2771 * For NFSv4, first create the "." and ".." entries.
2772 */
2773 if (NFSHASNFSV4(nmp)) {
2774 reqsize = 6 * NFSX_UNSIGNED;
2775 NFSGETATTR_ATTRBIT(&dattrbits);
2776 NFSZERO_ATTRBIT(&attrbits);
2777 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_FILEID);
2778 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_TYPE);
2779 if (NFSISSET_ATTRBIT(&dnp->n_vattr.na_suppattr,
2780 NFSATTRBIT_MOUNTEDONFILEID)) {
2781 NFSSETBIT_ATTRBIT(&attrbits,
2782 NFSATTRBIT_MOUNTEDONFILEID);
2783 gotmnton = 1;
2784 } else {
2785 /*
2786 * Must fake it. Use the fileno, except when the
2787 * fsid is != to that of the directory. For that
2788 * case, generate a fake fileno that is not the same.
2789 */
2790 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_FSID);
2791 gotmnton = 0;
2792 }
2793
2794 /*
2795 * Joy, oh joy. For V4 we get to hand craft '.' and '..'.
2796 */
2797 if (uiop->uio_offset == 0) {
2798 NFSCL_REQSTART(nd, NFSPROC_LOOKUPP, vp);
2799 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2800 *tl++ = txdr_unsigned(NFSV4OP_GETFH);
2801 *tl = txdr_unsigned(NFSV4OP_GETATTR);
2802 (void) nfsrv_putattrbit(nd, &attrbits);
2803 error = nfscl_request(nd, vp, p, cred, stuff);
2804 if (error)
2805 return (error);
2806 dotfileid = 0; /* Fake out the compiler. */
2807 if ((nd->nd_flag & ND_NOMOREDATA) == 0) {
2808 error = nfsm_loadattr(nd, &nfsva);
2809 if (error != 0)
2810 goto nfsmout;
2811 dotfileid = nfsva.na_fileid;
2812 }
2813 if (nd->nd_repstat == 0) {
2814 NFSM_DISSECT(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
2815 len = fxdr_unsigned(int, *(tl + 4));
2816 if (len > 0 && len <= NFSX_V4FHMAX)
2817 error = nfsm_advance(nd, NFSM_RNDUP(len), -1);
2818 else
2819 error = EPERM;
2820 if (!error) {
2821 NFSM_DISSECT(tl, u_int32_t *, 2*NFSX_UNSIGNED);
2822 nfsva.na_mntonfileno = 0xffffffff;
2823 error = nfsv4_loadattr(nd, NULL, &nfsva, NULL,
2824 NULL, 0, NULL, NULL, NULL, NULL, NULL, 0,
2825 NULL, NULL, NULL, p, cred);
2826 if (error) {
2827 dotdotfileid = dotfileid;
2828 } else if (gotmnton) {
2829 if (nfsva.na_mntonfileno != 0xffffffff)
2830 dotdotfileid = nfsva.na_mntonfileno;
2831 else
2832 dotdotfileid = nfsva.na_fileid;
2833 } else if (nfsva.na_filesid[0] ==
2834 dnp->n_vattr.na_filesid[0] &&
2835 nfsva.na_filesid[1] ==
2836 dnp->n_vattr.na_filesid[1]) {
2837 dotdotfileid = nfsva.na_fileid;
2838 } else {
2839 do {
2840 fakefileno--;
2841 } while (fakefileno ==
2842 nfsva.na_fileid);
2843 dotdotfileid = fakefileno;
2844 }
2845 }
2846 } else if (nd->nd_repstat == NFSERR_NOENT) {
2847 /*
2848 * Lookupp returns NFSERR_NOENT when we are
2849 * at the root, so just use the current dir.
2850 */
2851 nd->nd_repstat = 0;
2852 dotdotfileid = dotfileid;
2853 } else {
2854 error = nd->nd_repstat;
2855 }
2856 mbuf_freem(nd->nd_mrep);
2857 if (error)
2858 return (error);
2859 nd->nd_mrep = NULL;
2860 dp = (struct dirent *) CAST_DOWN(caddr_t, uio_iov_base(uiop));
2861 dp->d_type = DT_DIR;
2862 dp->d_fileno = dotfileid;
2863 dp->d_namlen = 1;
2864 dp->d_name[0] = '.';
2865 dp->d_name[1] = '\0';
2866 dp->d_reclen = DIRENT_SIZE(dp) + NFSX_HYPER;
2867 /*
2868 * Just make these offset cookie 0.
2869 */
2870 tl = (u_int32_t *)&dp->d_name[4];
2871 *tl++ = 0;
2872 *tl = 0;
2873 blksiz += dp->d_reclen;
2874 uio_uio_resid_add(uiop, -(dp->d_reclen));
2875 uiop->uio_offset += dp->d_reclen;
2876 uio_iov_base_add(uiop, dp->d_reclen);
2877 uio_iov_len_add(uiop, -(dp->d_reclen));
2878 dp = (struct dirent *) CAST_DOWN(caddr_t, uio_iov_base(uiop));
2879 dp->d_type = DT_DIR;
2880 dp->d_fileno = dotdotfileid;
2881 dp->d_namlen = 2;
2882 dp->d_name[0] = '.';
2883 dp->d_name[1] = '.';
2884 dp->d_name[2] = '\0';
2885 dp->d_reclen = DIRENT_SIZE(dp) + NFSX_HYPER;
2886 /*
2887 * Just make these offset cookie 0.
2888 */
2889 tl = (u_int32_t *)&dp->d_name[4];
2890 *tl++ = 0;
2891 *tl = 0;
2892 blksiz += dp->d_reclen;
2893 uio_uio_resid_add(uiop, -(dp->d_reclen));
2894 uiop->uio_offset += dp->d_reclen;
2895 uio_iov_base_add(uiop, dp->d_reclen);
2896 uio_iov_len_add(uiop, -(dp->d_reclen));
2897 }
2898 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_RDATTRERROR);
2899 } else {
2900 reqsize = 5 * NFSX_UNSIGNED;
2901 }
2902
2903
2904 /*
2905 * Loop around doing readdir rpc's of size readsize.
2906 * The stopping criteria is EOF or buffer full.
2907 */
2908 while (more_dirs && bigenough) {
2909 *attrflagp = 0;
2910 NFSCL_REQSTART(nd, NFSPROC_READDIR, vp);
2911 if (nd->nd_flag & ND_NFSV2) {
2912 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2913 *tl++ = cookie.lval[1];
2914 *tl = txdr_unsigned(readsize);
2915 } else {
2916 NFSM_BUILD(tl, u_int32_t *, reqsize);
2917 *tl++ = cookie.lval[0];
2918 *tl++ = cookie.lval[1];
2919 if (cookie.qval == 0) {
2920 *tl++ = 0;
2921 *tl++ = 0;
2922 } else {
2923 NFSLOCKNODE(dnp);
2924 *tl++ = dnp->n_cookieverf.nfsuquad[0];
2925 *tl++ = dnp->n_cookieverf.nfsuquad[1];
2926 NFSUNLOCKNODE(dnp);
2927 }
2928 if (nd->nd_flag & ND_NFSV4) {
2929 *tl++ = txdr_unsigned(readsize);
2930 *tl = txdr_unsigned(readsize);
2931 (void) nfsrv_putattrbit(nd, &attrbits);
2932 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
2933 *tl = txdr_unsigned(NFSV4OP_GETATTR);
2934 (void) nfsrv_putattrbit(nd, &dattrbits);
2935 } else {
2936 *tl = txdr_unsigned(readsize);
2937 }
2938 }
2939 error = nfscl_request(nd, vp, p, cred, stuff);
2940 if (error)
2941 return (error);
2942 if (!(nd->nd_flag & ND_NFSV2)) {
2943 if (nd->nd_flag & ND_NFSV3)
2944 error = nfscl_postop_attr(nd, nap, attrflagp,
2945 stuff);
2946 if (!nd->nd_repstat && !error) {
2947 NFSM_DISSECT(tl, u_int32_t *, NFSX_HYPER);
2948 NFSLOCKNODE(dnp);
2949 dnp->n_cookieverf.nfsuquad[0] = *tl++;
2950 dnp->n_cookieverf.nfsuquad[1] = *tl;
2951 NFSUNLOCKNODE(dnp);
2952 }
2953 }
2954 if (nd->nd_repstat || error) {
2955 if (!error)
2956 error = nd->nd_repstat;
2957 goto nfsmout;
2958 }
2959 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
2960 more_dirs = fxdr_unsigned(int, *tl);
2961 if (!more_dirs)
2962 tryformoredirs = 0;
2963
2964 /* loop thru the dir entries, doctoring them to 4bsd form */
2965 while (more_dirs && bigenough) {
2966 if (nd->nd_flag & ND_NFSV4) {
2967 NFSM_DISSECT(tl, u_int32_t *, 3*NFSX_UNSIGNED);
2968 ncookie.lval[0] = *tl++;
2969 ncookie.lval[1] = *tl++;
2970 len = fxdr_unsigned(int, *tl);
2971 } else if (nd->nd_flag & ND_NFSV3) {
2972 NFSM_DISSECT(tl, u_int32_t *, 3*NFSX_UNSIGNED);
2973 nfsva.na_fileid = fxdr_hyper(tl);
2974 tl += 2;
2975 len = fxdr_unsigned(int, *tl);
2976 } else {
2977 NFSM_DISSECT(tl, u_int32_t *, 2*NFSX_UNSIGNED);
2978 nfsva.na_fileid =
2979 fxdr_unsigned(long, *tl++);
2980 len = fxdr_unsigned(int, *tl);
2981 }
2982 if (len <= 0 || len > NFS_MAXNAMLEN) {
2983 error = EBADRPC;
2984 goto nfsmout;
2985 }
2986 tlen = NFSM_RNDUP(len);
2987 if (tlen == len)
2988 tlen += 4; /* To ensure null termination */
2989 left = DIRBLKSIZ - blksiz;
2990 if ((int)(tlen + DIRHDSIZ + NFSX_HYPER) > left) {
2991 dp->d_reclen += left;
2992 uio_iov_base_add(uiop, left);
2993 uio_iov_len_add(uiop, -(left));
2994 uio_uio_resid_add(uiop, -(left));
2995 uiop->uio_offset += left;
2996 blksiz = 0;
2997 }
2998 if ((int)(tlen + DIRHDSIZ + NFSX_HYPER) > uio_uio_resid(uiop))
2999 bigenough = 0;
3000 if (bigenough) {
3001 dp = (struct dirent *) CAST_DOWN(caddr_t, uio_iov_base(uiop));
3002 dp->d_namlen = len;
3003 dp->d_reclen = tlen + DIRHDSIZ + NFSX_HYPER;
3004 dp->d_type = DT_UNKNOWN;
3005 blksiz += dp->d_reclen;
3006 if (blksiz == DIRBLKSIZ)
3007 blksiz = 0;
3008 uio_uio_resid_add(uiop, -(DIRHDSIZ));
3009 uiop->uio_offset += DIRHDSIZ;
3010 uio_iov_base_add(uiop, DIRHDSIZ);
3011 uio_iov_len_add(uiop, -(DIRHDSIZ));
3012 error = nfsm_mbufuio(nd, uiop, len);
3013 if (error)
3014 goto nfsmout;
3015 cp = CAST_DOWN(caddr_t, uio_iov_base(uiop));
3016 tlen -= len;
3017 *cp = '\0'; /* null terminate */
3018 cp += tlen; /* points to cookie storage */
3019 tl2 = (u_int32_t *)cp;
3020 uio_iov_base_add(uiop, (tlen + NFSX_HYPER));
3021 uio_iov_len_add(uiop, -(tlen + NFSX_HYPER));
3022 uio_uio_resid_add(uiop, -(tlen + NFSX_HYPER));
3023 uiop->uio_offset += (tlen + NFSX_HYPER);
3024 } else {
3025 error = nfsm_advance(nd, NFSM_RNDUP(len), -1);
3026 if (error)
3027 goto nfsmout;
3028 }
3029 if (nd->nd_flag & ND_NFSV4) {
3030 rderr = 0;
3031 nfsva.na_mntonfileno = 0xffffffff;
3032 error = nfsv4_loadattr(nd, NULL, &nfsva, NULL,
3033 NULL, 0, NULL, NULL, NULL, NULL, NULL, 0,
3034 NULL, NULL, &rderr, p, cred);
3035 if (error)
3036 goto nfsmout;
3037 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
3038 } else if (nd->nd_flag & ND_NFSV3) {
3039 NFSM_DISSECT(tl, u_int32_t *, 3*NFSX_UNSIGNED);
3040 ncookie.lval[0] = *tl++;
3041 ncookie.lval[1] = *tl++;
3042 } else {
3043 NFSM_DISSECT(tl, u_int32_t *, 2*NFSX_UNSIGNED);
3044 ncookie.lval[0] = 0;
3045 ncookie.lval[1] = *tl++;
3046 }
3047 if (bigenough) {
3048 if (nd->nd_flag & ND_NFSV4) {
3049 if (rderr) {
3050 dp->d_fileno = 0;
3051 } else {
3052 if (gotmnton) {
3053 if (nfsva.na_mntonfileno != 0xffffffff)
3054 dp->d_fileno = nfsva.na_mntonfileno;
3055 else
3056 dp->d_fileno = nfsva.na_fileid;
3057 } else if (nfsva.na_filesid[0] ==
3058 dnp->n_vattr.na_filesid[0] &&
3059 nfsva.na_filesid[1] ==
3060 dnp->n_vattr.na_filesid[1]) {
3061 dp->d_fileno = nfsva.na_fileid;
3062 } else {
3063 do {
3064 fakefileno--;
3065 } while (fakefileno ==
3066 nfsva.na_fileid);
3067 dp->d_fileno = fakefileno;
3068 }
3069 dp->d_type = vtonfs_dtype(nfsva.na_type);
3070 }
3071 } else {
3072 dp->d_fileno = nfsva.na_fileid;
3073 }
3074 *tl2++ = cookiep->nfsuquad[0] = cookie.lval[0] =
3075 ncookie.lval[0];
3076 *tl2 = cookiep->nfsuquad[1] = cookie.lval[1] =
3077 ncookie.lval[1];
3078 }
3079 more_dirs = fxdr_unsigned(int, *tl);
3080 }
3081 /*
3082 * If at end of rpc data, get the eof boolean
3083 */
3084 if (!more_dirs) {
3085 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
3086 eof = fxdr_unsigned(int, *tl);
3087 if (tryformoredirs)
3088 more_dirs = !eof;
3089 if (nd->nd_flag & ND_NFSV4) {
3090 error = nfscl_postop_attr(nd, nap, attrflagp,
3091 stuff);
3092 if (error)
3093 goto nfsmout;
3094 }
3095 }
3096 mbuf_freem(nd->nd_mrep);
3097 nd->nd_mrep = NULL;
3098 }
3099 /*
3100 * Fill last record, iff any, out to a multiple of DIRBLKSIZ
3101 * by increasing d_reclen for the last record.
3102 */
3103 if (blksiz > 0) {
3104 left = DIRBLKSIZ - blksiz;
3105 dp->d_reclen += left;
3106 uio_iov_base_add(uiop, left);
3107 uio_iov_len_add(uiop, -(left));
3108 uio_uio_resid_add(uiop, -(left));
3109 uiop->uio_offset += left;
3110 }
3111
3112 /*
3113 * If returning no data, assume end of file.
3114 * If not bigenough, return not end of file, since you aren't
3115 * returning all the data
3116 * Otherwise, return the eof flag from the server.
3117 */
3118 if (eofp) {
3119 if (tresid == ((size_t)(uio_uio_resid(uiop))))
3120 *eofp = 1;
3121 else if (!bigenough)
3122 *eofp = 0;
3123 else
3124 *eofp = eof;
3125 }
3126
3127 /*
3128 * Add extra empty records to any remaining DIRBLKSIZ chunks.
3129 */
3130 while (uio_uio_resid(uiop) > 0 && ((size_t)(uio_uio_resid(uiop))) != tresid) {
3131 dp = (struct dirent *) CAST_DOWN(caddr_t, uio_iov_base(uiop));
3132 dp->d_type = DT_UNKNOWN;
3133 dp->d_fileno = 0;
3134 dp->d_namlen = 0;
3135 dp->d_name[0] = '\0';
3136 tl = (u_int32_t *)&dp->d_name[4];
3137 *tl++ = cookie.lval[0];
3138 *tl = cookie.lval[1];
3139 dp->d_reclen = DIRBLKSIZ;
3140 uio_iov_base_add(uiop, DIRBLKSIZ);
3141 uio_iov_len_add(uiop, -(DIRBLKSIZ));
3142 uio_uio_resid_add(uiop, -(DIRBLKSIZ));
3143 uiop->uio_offset += DIRBLKSIZ;
3144 }
3145
3146 nfsmout:
3147 if (nd->nd_mrep != NULL)
3148 mbuf_freem(nd->nd_mrep);
3149 return (error);
3150 }
3151
3152 #ifndef APPLE
3153 /*
3154 * NFS V3 readdir plus RPC. Used in place of nfsrpc_readdir().
3155 * (Also used for NFS V4 when mount flag set.)
3156 * (ditto above w.r.t. multiple of DIRBLKSIZ, etc.)
3157 */
3158 APPLESTATIC int
3159 nfsrpc_readdirplus(vnode_t vp, struct uio *uiop, nfsuint64 *cookiep,
3160 struct ucred *cred, NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp,
3161 int *eofp, void *stuff)
3162 {
3163 int len, left;
3164 struct dirent *dp = NULL;
3165 u_int32_t *tl;
3166 vnode_t newvp = NULLVP;
3167 struct nfsrv_descript nfsd, *nd = &nfsd;
3168 struct nameidata nami, *ndp = &nami;
3169 struct componentname *cnp = &ndp->ni_cnd;
3170 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
3171 struct nfsnode *dnp = VTONFS(vp), *np;
3172 struct nfsvattr nfsva;
3173 struct nfsfh *nfhp;
3174 nfsquad_t cookie, ncookie;
3175 int error = 0, tlen, more_dirs = 1, blksiz = 0, bigenough = 1;
3176 int attrflag, tryformoredirs = 1, eof = 0, gotmnton = 0;
3177 int isdotdot = 0, unlocknewvp = 0;
3178 long dotfileid, dotdotfileid = 0, fileno = 0;
3179 char *cp;
3180 nfsattrbit_t attrbits, dattrbits;
3181 size_t tresid;
3182 u_int32_t *tl2 = NULL, fakefileno = 0xffffffff, rderr;
3183 struct timespec dctime;
3184
3185 KASSERT(uiop->uio_iovcnt == 1 &&
3186 (uio_uio_resid(uiop) & (DIRBLKSIZ - 1)) == 0,
3187 ("nfs readdirplusrpc bad uio"));
3188 timespecclear(&dctime);
3189 *attrflagp = 0;
3190 if (eofp != NULL)
3191 *eofp = 0;
3192 ndp->ni_dvp = vp;
3193 nd->nd_mrep = NULL;
3194 cookie.lval[0] = cookiep->nfsuquad[0];
3195 cookie.lval[1] = cookiep->nfsuquad[1];
3196 tresid = uio_uio_resid(uiop);
3197
3198 /*
3199 * For NFSv4, first create the "." and ".." entries.
3200 */
3201 if (NFSHASNFSV4(nmp)) {
3202 NFSGETATTR_ATTRBIT(&dattrbits);
3203 NFSZERO_ATTRBIT(&attrbits);
3204 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_FILEID);
3205 if (NFSISSET_ATTRBIT(&dnp->n_vattr.na_suppattr,
3206 NFSATTRBIT_MOUNTEDONFILEID)) {
3207 NFSSETBIT_ATTRBIT(&attrbits,
3208 NFSATTRBIT_MOUNTEDONFILEID);
3209 gotmnton = 1;
3210 } else {
3211 /*
3212 * Must fake it. Use the fileno, except when the
3213 * fsid is != to that of the directory. For that
3214 * case, generate a fake fileno that is not the same.
3215 */
3216 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_FSID);
3217 gotmnton = 0;
3218 }
3219
3220 /*
3221 * Joy, oh joy. For V4 we get to hand craft '.' and '..'.
3222 */
3223 if (uiop->uio_offset == 0) {
3224 NFSCL_REQSTART(nd, NFSPROC_LOOKUPP, vp);
3225 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
3226 *tl++ = txdr_unsigned(NFSV4OP_GETFH);
3227 *tl = txdr_unsigned(NFSV4OP_GETATTR);
3228 (void) nfsrv_putattrbit(nd, &attrbits);
3229 error = nfscl_request(nd, vp, p, cred, stuff);
3230 if (error)
3231 return (error);
3232 dotfileid = 0; /* Fake out the compiler. */
3233 if ((nd->nd_flag & ND_NOMOREDATA) == 0) {
3234 error = nfsm_loadattr(nd, &nfsva);
3235 if (error != 0)
3236 goto nfsmout;
3237 dctime = nfsva.na_ctime;
3238 dotfileid = nfsva.na_fileid;
3239 }
3240 if (nd->nd_repstat == 0) {
3241 NFSM_DISSECT(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
3242 len = fxdr_unsigned(int, *(tl + 4));
3243 if (len > 0 && len <= NFSX_V4FHMAX)
3244 error = nfsm_advance(nd, NFSM_RNDUP(len), -1);
3245 else
3246 error = EPERM;
3247 if (!error) {
3248 NFSM_DISSECT(tl, u_int32_t *, 2*NFSX_UNSIGNED);
3249 nfsva.na_mntonfileno = 0xffffffff;
3250 error = nfsv4_loadattr(nd, NULL, &nfsva, NULL,
3251 NULL, 0, NULL, NULL, NULL, NULL, NULL, 0,
3252 NULL, NULL, NULL, p, cred);
3253 if (error) {
3254 dotdotfileid = dotfileid;
3255 } else if (gotmnton) {
3256 if (nfsva.na_mntonfileno != 0xffffffff)
3257 dotdotfileid = nfsva.na_mntonfileno;
3258 else
3259 dotdotfileid = nfsva.na_fileid;
3260 } else if (nfsva.na_filesid[0] ==
3261 dnp->n_vattr.na_filesid[0] &&
3262 nfsva.na_filesid[1] ==
3263 dnp->n_vattr.na_filesid[1]) {
3264 dotdotfileid = nfsva.na_fileid;
3265 } else {
3266 do {
3267 fakefileno--;
3268 } while (fakefileno ==
3269 nfsva.na_fileid);
3270 dotdotfileid = fakefileno;
3271 }
3272 }
3273 } else if (nd->nd_repstat == NFSERR_NOENT) {
3274 /*
3275 * Lookupp returns NFSERR_NOENT when we are
3276 * at the root, so just use the current dir.
3277 */
3278 nd->nd_repstat = 0;
3279 dotdotfileid = dotfileid;
3280 } else {
3281 error = nd->nd_repstat;
3282 }
3283 mbuf_freem(nd->nd_mrep);
3284 if (error)
3285 return (error);
3286 nd->nd_mrep = NULL;
3287 dp = (struct dirent *)uio_iov_base(uiop);
3288 dp->d_type = DT_DIR;
3289 dp->d_fileno = dotfileid;
3290 dp->d_namlen = 1;
3291 dp->d_name[0] = '.';
3292 dp->d_name[1] = '\0';
3293 dp->d_reclen = DIRENT_SIZE(dp) + NFSX_HYPER;
3294 /*
3295 * Just make these offset cookie 0.
3296 */
3297 tl = (u_int32_t *)&dp->d_name[4];
3298 *tl++ = 0;
3299 *tl = 0;
3300 blksiz += dp->d_reclen;
3301 uio_uio_resid_add(uiop, -(dp->d_reclen));
3302 uiop->uio_offset += dp->d_reclen;
3303 uio_iov_base_add(uiop, dp->d_reclen);
3304 uio_iov_len_add(uiop, -(dp->d_reclen));
3305 dp = (struct dirent *)uio_iov_base(uiop);
3306 dp->d_type = DT_DIR;
3307 dp->d_fileno = dotdotfileid;
3308 dp->d_namlen = 2;
3309 dp->d_name[0] = '.';
3310 dp->d_name[1] = '.';
3311 dp->d_name[2] = '\0';
3312 dp->d_reclen = DIRENT_SIZE(dp) + NFSX_HYPER;
3313 /*
3314 * Just make these offset cookie 0.
3315 */
3316 tl = (u_int32_t *)&dp->d_name[4];
3317 *tl++ = 0;
3318 *tl = 0;
3319 blksiz += dp->d_reclen;
3320 uio_uio_resid_add(uiop, -(dp->d_reclen));
3321 uiop->uio_offset += dp->d_reclen;
3322 uio_iov_base_add(uiop, dp->d_reclen);
3323 uio_iov_len_add(uiop, -(dp->d_reclen));
3324 }
3325 NFSREADDIRPLUS_ATTRBIT(&attrbits);
3326 if (gotmnton)
3327 NFSSETBIT_ATTRBIT(&attrbits,
3328 NFSATTRBIT_MOUNTEDONFILEID);
3329 }
3330
3331 /*
3332 * Loop around doing readdir rpc's of size nm_readdirsize.
3333 * The stopping criteria is EOF or buffer full.
3334 */
3335 while (more_dirs && bigenough) {
3336 *attrflagp = 0;
3337 NFSCL_REQSTART(nd, NFSPROC_READDIRPLUS, vp);
3338 NFSM_BUILD(tl, u_int32_t *, 6 * NFSX_UNSIGNED);
3339 *tl++ = cookie.lval[0];
3340 *tl++ = cookie.lval[1];
3341 if (cookie.qval == 0) {
3342 *tl++ = 0;
3343 *tl++ = 0;
3344 } else {
3345 NFSLOCKNODE(dnp);
3346 *tl++ = dnp->n_cookieverf.nfsuquad[0];
3347 *tl++ = dnp->n_cookieverf.nfsuquad[1];
3348 NFSUNLOCKNODE(dnp);
3349 }
3350 *tl++ = txdr_unsigned(nmp->nm_readdirsize);
3351 *tl = txdr_unsigned(nmp->nm_readdirsize);
3352 if (nd->nd_flag & ND_NFSV4) {
3353 (void) nfsrv_putattrbit(nd, &attrbits);
3354 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
3355 *tl = txdr_unsigned(NFSV4OP_GETATTR);
3356 (void) nfsrv_putattrbit(nd, &dattrbits);
3357 }
3358 error = nfscl_request(nd, vp, p, cred, stuff);
3359 if (error)
3360 return (error);
3361 if (nd->nd_flag & ND_NFSV3)
3362 error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
3363 if (nd->nd_repstat || error) {
3364 if (!error)
3365 error = nd->nd_repstat;
3366 goto nfsmout;
3367 }
3368 if ((nd->nd_flag & ND_NFSV3) != 0 && *attrflagp != 0)
3369 dctime = nap->na_ctime;
3370 NFSM_DISSECT(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
3371 NFSLOCKNODE(dnp);
3372 dnp->n_cookieverf.nfsuquad[0] = *tl++;
3373 dnp->n_cookieverf.nfsuquad[1] = *tl++;
3374 NFSUNLOCKNODE(dnp);
3375 more_dirs = fxdr_unsigned(int, *tl);
3376 if (!more_dirs)
3377 tryformoredirs = 0;
3378
3379 /* loop thru the dir entries, doctoring them to 4bsd form */
3380 while (more_dirs && bigenough) {
3381 NFSM_DISSECT(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
3382 if (nd->nd_flag & ND_NFSV4) {
3383 ncookie.lval[0] = *tl++;
3384 ncookie.lval[1] = *tl++;
3385 } else {
3386 fileno = fxdr_unsigned(long, *++tl);
3387 tl++;
3388 }
3389 len = fxdr_unsigned(int, *tl);
3390 if (len <= 0 || len > NFS_MAXNAMLEN) {
3391 error = EBADRPC;
3392 goto nfsmout;
3393 }
3394 tlen = NFSM_RNDUP(len);
3395 if (tlen == len)
3396 tlen += 4; /* To ensure null termination */
3397 left = DIRBLKSIZ - blksiz;
3398 if ((tlen + DIRHDSIZ + NFSX_HYPER) > left) {
3399 dp->d_reclen += left;
3400 uio_iov_base_add(uiop, left);
3401 uio_iov_len_add(uiop, -(left));
3402 uio_uio_resid_add(uiop, -(left));
3403 uiop->uio_offset += left;
3404 blksiz = 0;
3405 }
3406 if ((tlen + DIRHDSIZ + NFSX_HYPER) > uio_uio_resid(uiop))
3407 bigenough = 0;
3408 if (bigenough) {
3409 dp = (struct dirent *)uio_iov_base(uiop);
3410 dp->d_namlen = len;
3411 dp->d_reclen = tlen + DIRHDSIZ + NFSX_HYPER;
3412 dp->d_type = DT_UNKNOWN;
3413 blksiz += dp->d_reclen;
3414 if (blksiz == DIRBLKSIZ)
3415 blksiz = 0;
3416 uio_uio_resid_add(uiop, -(DIRHDSIZ));
3417 uiop->uio_offset += DIRHDSIZ;
3418 uio_iov_base_add(uiop, DIRHDSIZ);
3419 uio_iov_len_add(uiop, -(DIRHDSIZ));
3420 cnp->cn_nameptr = uio_iov_base(uiop);
3421 cnp->cn_namelen = len;
3422 NFSCNHASHZERO(cnp);
3423 error = nfsm_mbufuio(nd, uiop, len);
3424 if (error)
3425 goto nfsmout;
3426 cp = uio_iov_base(uiop);
3427 tlen -= len;
3428 *cp = '\0';
3429 cp += tlen; /* points to cookie storage */
3430 tl2 = (u_int32_t *)cp;
3431 if (len == 2 && cnp->cn_nameptr[0] == '.' &&
3432 cnp->cn_nameptr[1] == '.')
3433 isdotdot = 1;
3434 else
3435 isdotdot = 0;
3436 uio_iov_base_add(uiop, (tlen + NFSX_HYPER));
3437 uio_iov_len_add(uiop, -(tlen + NFSX_HYPER));
3438 uio_uio_resid_add(uiop, -(tlen + NFSX_HYPER));
3439 uiop->uio_offset += (tlen + NFSX_HYPER);
3440 } else {
3441 error = nfsm_advance(nd, NFSM_RNDUP(len), -1);
3442 if (error)
3443 goto nfsmout;
3444 }
3445 nfhp = NULL;
3446 if (nd->nd_flag & ND_NFSV3) {
3447 NFSM_DISSECT(tl, u_int32_t *, 3*NFSX_UNSIGNED);
3448 ncookie.lval[0] = *tl++;
3449 ncookie.lval[1] = *tl++;
3450 attrflag = fxdr_unsigned(int, *tl);
3451 if (attrflag) {
3452 error = nfsm_loadattr(nd, &nfsva);
3453 if (error)
3454 goto nfsmout;
3455 }
3456 NFSM_DISSECT(tl,u_int32_t *,NFSX_UNSIGNED);
3457 if (*tl) {
3458 error = nfsm_getfh(nd, &nfhp);
3459 if (error)
3460 goto nfsmout;
3461 }
3462 if (!attrflag && nfhp != NULL) {
3463 FREE((caddr_t)nfhp, M_NFSFH);
3464 nfhp = NULL;
3465 }
3466 } else {
3467 rderr = 0;
3468 nfsva.na_mntonfileno = 0xffffffff;
3469 error = nfsv4_loadattr(nd, NULL, &nfsva, &nfhp,
3470 NULL, 0, NULL, NULL, NULL, NULL, NULL, 0,
3471 NULL, NULL, &rderr, p, cred);
3472 if (error)
3473 goto nfsmout;
3474 }
3475
3476 if (bigenough) {
3477 if (nd->nd_flag & ND_NFSV4) {
3478 if (rderr) {
3479 dp->d_fileno = 0;
3480 } else if (gotmnton) {
3481 if (nfsva.na_mntonfileno != 0xffffffff)
3482 dp->d_fileno = nfsva.na_mntonfileno;
3483 else
3484 dp->d_fileno = nfsva.na_fileid;
3485 } else if (nfsva.na_filesid[0] ==
3486 dnp->n_vattr.na_filesid[0] &&
3487 nfsva.na_filesid[1] ==
3488 dnp->n_vattr.na_filesid[1]) {
3489 dp->d_fileno = nfsva.na_fileid;
3490 } else {
3491 do {
3492 fakefileno--;
3493 } while (fakefileno ==
3494 nfsva.na_fileid);
3495 dp->d_fileno = fakefileno;
3496 }
3497 } else {
3498 dp->d_fileno = fileno;
3499 }
3500 *tl2++ = cookiep->nfsuquad[0] = cookie.lval[0] =
3501 ncookie.lval[0];
3502 *tl2 = cookiep->nfsuquad[1] = cookie.lval[1] =
3503 ncookie.lval[1];
3504
3505 if (nfhp != NULL) {
3506 if (NFSRV_CMPFH(nfhp->nfh_fh, nfhp->nfh_len,
3507 dnp->n_fhp->nfh_fh, dnp->n_fhp->nfh_len)) {
3508 VREF(vp);
3509 newvp = vp;
3510 unlocknewvp = 0;
3511 FREE((caddr_t)nfhp, M_NFSFH);
3512 np = dnp;
3513 } else if (isdotdot != 0) {
3514 /*
3515 * Skip doing a nfscl_nget() call for "..".
3516 * There's a race between acquiring the nfs
3517 * node here and lookups that look for the
3518 * directory being read (in the parent).
3519 * It would try to get a lock on ".." here,
3520 * owning the lock on the directory being
3521 * read. Lookup will hold the lock on ".."
3522 * and try to acquire the lock on the
3523 * directory being read.
3524 * If the directory is unlocked/relocked,
3525 * then there is a LOR with the buflock
3526 * vp is relocked.
3527 */
3528 free(nfhp, M_NFSFH);
3529 } else {
3530 error = nfscl_nget(vnode_mount(vp), vp,
3531 nfhp, cnp, p, &np, NULL, LK_EXCLUSIVE);
3532 if (!error) {
3533 newvp = NFSTOV(np);
3534 unlocknewvp = 1;
3535 }
3536 }
3537 nfhp = NULL;
3538 if (newvp != NULLVP) {
3539 error = nfscl_loadattrcache(&newvp,
3540 &nfsva, NULL, NULL, 0, 0);
3541 if (error) {
3542 if (unlocknewvp)
3543 vput(newvp);
3544 else
3545 vrele(newvp);
3546 goto nfsmout;
3547 }
3548 dp->d_type =
3549 vtonfs_dtype(np->n_vattr.na_type);
3550 ndp->ni_vp = newvp;
3551 NFSCNHASH(cnp, HASHINIT);
3552 if (cnp->cn_namelen <= NCHNAMLEN &&
3553 (newvp->v_type != VDIR ||
3554 dctime.tv_sec != 0)) {
3555 cache_enter_time(ndp->ni_dvp,
3556 ndp->ni_vp, cnp,
3557 &nfsva.na_ctime,
3558 newvp->v_type != VDIR ? NULL :
3559 &dctime);
3560 }
3561 if (unlocknewvp)
3562 vput(newvp);
3563 else
3564 vrele(newvp);
3565 newvp = NULLVP;
3566 }
3567 }
3568 } else if (nfhp != NULL) {
3569 FREE((caddr_t)nfhp, M_NFSFH);
3570 }
3571 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
3572 more_dirs = fxdr_unsigned(int, *tl);
3573 }
3574 /*
3575 * If at end of rpc data, get the eof boolean
3576 */
3577 if (!more_dirs) {
3578 NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
3579 eof = fxdr_unsigned(int, *tl);
3580 if (tryformoredirs)
3581 more_dirs = !eof;
3582 if (nd->nd_flag & ND_NFSV4) {
3583 error = nfscl_postop_attr(nd, nap, attrflagp,
3584 stuff);
3585 if (error)
3586 goto nfsmout;
3587 }
3588 }
3589 mbuf_freem(nd->nd_mrep);
3590 nd->nd_mrep = NULL;
3591 }
3592 /*
3593 * Fill last record, iff any, out to a multiple of DIRBLKSIZ
3594 * by increasing d_reclen for the last record.
3595 */
3596 if (blksiz > 0) {
3597 left = DIRBLKSIZ - blksiz;
3598 dp->d_reclen += left;
3599 uio_iov_base_add(uiop, left);
3600 uio_iov_len_add(uiop, -(left));
3601 uio_uio_resid_add(uiop, -(left));
3602 uiop->uio_offset += left;
3603 }
3604
3605 /*
3606 * If returning no data, assume end of file.
3607 * If not bigenough, return not end of file, since you aren't
3608 * returning all the data
3609 * Otherwise, return the eof flag from the server.
3610 */
3611 if (eofp != NULL) {
3612 if (tresid == uio_uio_resid(uiop))
3613 *eofp = 1;
3614 else if (!bigenough)
3615 *eofp = 0;
3616 else
3617 *eofp = eof;
3618 }
3619
3620 /*
3621 * Add extra empty records to any remaining DIRBLKSIZ chunks.
3622 */
3623 while (uio_uio_resid(uiop) > 0 && uio_uio_resid(uiop) != tresid) {
3624 dp = (struct dirent *)uio_iov_base(uiop);
3625 dp->d_type = DT_UNKNOWN;
3626 dp->d_fileno = 0;
3627 dp->d_namlen = 0;
3628 dp->d_name[0] = '\0';
3629 tl = (u_int32_t *)&dp->d_name[4];
3630 *tl++ = cookie.lval[0];
3631 *tl = cookie.lval[1];
3632 dp->d_reclen = DIRBLKSIZ;
3633 uio_iov_base_add(uiop, DIRBLKSIZ);
3634 uio_iov_len_add(uiop, -(DIRBLKSIZ));
3635 uio_uio_resid_add(uiop, -(DIRBLKSIZ));
3636 uiop->uio_offset += DIRBLKSIZ;
3637 }
3638
3639 nfsmout:
3640 if (nd->nd_mrep != NULL)
3641 mbuf_freem(nd->nd_mrep);
3642 return (error);
3643 }
3644 #endif /* !APPLE */
3645
3646 /*
3647 * Nfs commit rpc
3648 */
3649 APPLESTATIC int
3650 nfsrpc_commit(vnode_t vp, u_quad_t offset, int cnt, struct ucred *cred,
3651 NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp, void *stuff)
3652 {
3653 u_int32_t *tl;
3654 struct nfsrv_descript nfsd, *nd = &nfsd;
3655 nfsattrbit_t attrbits;
3656 int error;
3657 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
3658
3659 *attrflagp = 0;
3660 NFSCL_REQSTART(nd, NFSPROC_COMMIT, vp);
3661 NFSM_BUILD(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
3662 txdr_hyper(offset, tl);
3663 tl += 2;
3664 *tl = txdr_unsigned(cnt);
3665 if (nd->nd_flag & ND_NFSV4) {
3666 /*
3667 * And do a Getattr op.
3668 */
3669 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
3670 *tl = txdr_unsigned(NFSV4OP_GETATTR);
3671 NFSGETATTR_ATTRBIT(&attrbits);
3672 (void) nfsrv_putattrbit(nd, &attrbits);
3673 }
3674 error = nfscl_request(nd, vp, p, cred, stuff);
3675 if (error)
3676 return (error);
3677 error = nfscl_wcc_data(nd, vp, nap, attrflagp, NULL, stuff);
3678 if (!error && !nd->nd_repstat) {
3679 NFSM_DISSECT(tl, u_int32_t *, NFSX_VERF);
3680 NFSLOCKMNT(nmp);
3681 if (NFSBCMP(nmp->nm_verf, tl, NFSX_VERF)) {
3682 NFSBCOPY(tl, nmp->nm_verf, NFSX_VERF);
3683 nd->nd_repstat = NFSERR_STALEWRITEVERF;
3684 }
3685 NFSUNLOCKMNT(nmp);
3686 if (nd->nd_flag & ND_NFSV4)
3687 error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
3688 }
3689 nfsmout:
3690 if (!error && nd->nd_repstat)
3691 error = nd->nd_repstat;
3692 mbuf_freem(nd->nd_mrep);
3693 return (error);
3694 }
3695
3696 /*
3697 * NFS byte range lock rpc.
3698 * (Mostly just calls one of the three lower level RPC routines.)
3699 */
3700 APPLESTATIC int
3701 nfsrpc_advlock(vnode_t vp, off_t size, int op, struct flock *fl,
3702 int reclaim, struct ucred *cred, NFSPROC_T *p, void *id, int flags)
3703 {
3704 struct nfscllockowner *lp;
3705 struct nfsclclient *clp;
3706 struct nfsfh *nfhp;
3707 struct nfsrv_descript nfsd, *nd = &nfsd;
3708 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
3709 u_int64_t off, len;
3710 off_t start, end;
3711 u_int32_t clidrev = 0;
3712 int error = 0, newone = 0, expireret = 0, retrycnt, donelocally;
3713 int callcnt, dorpc;
3714
3715 /*
3716 * Convert the flock structure into a start and end and do POSIX
3717 * bounds checking.
3718 */
3719 switch (fl->l_whence) {
3720 case SEEK_SET:
3721 case SEEK_CUR:
3722 /*
3723 * Caller is responsible for adding any necessary offset
3724 * when SEEK_CUR is used.
3725 */
3726 start = fl->l_start;
3727 off = fl->l_start;
3728 break;
3729 case SEEK_END:
3730 start = size + fl->l_start;
3731 off = size + fl->l_start;
3732 break;
3733 default:
3734 return (EINVAL);
3735 };
3736 if (start < 0)
3737 return (EINVAL);
3738 if (fl->l_len != 0) {
3739 end = start + fl->l_len - 1;
3740 if (end < start)
3741 return (EINVAL);
3742 }
3743
3744 len = fl->l_len;
3745 if (len == 0)
3746 len = NFS64BITSSET;
3747 retrycnt = 0;
3748 do {
3749 nd->nd_repstat = 0;
3750 if (op == F_GETLK) {
3751 error = nfscl_getcl(vnode_mount(vp), cred, p, 1, &clp);
3752 if (error)
3753 return (error);
3754 error = nfscl_lockt(vp, clp, off, len, fl, p, id, flags);
3755 if (!error) {
3756 clidrev = clp->nfsc_clientidrev;
3757 error = nfsrpc_lockt(nd, vp, clp, off, len, fl, cred,
3758 p, id, flags);
3759 } else if (error == -1) {
3760 error = 0;
3761 }
3762 nfscl_clientrelease(clp);
3763 } else if (op == F_UNLCK && fl->l_type == F_UNLCK) {
3764 /*
3765 * We must loop around for all lockowner cases.
3766 */
3767 callcnt = 0;
3768 error = nfscl_getcl(vnode_mount(vp), cred, p, 1, &clp);
3769 if (error)
3770 return (error);
3771 do {
3772 error = nfscl_relbytelock(vp, off, len, cred, p, callcnt,
3773 clp, id, flags, &lp, &dorpc);
3774 /*
3775 * If it returns a NULL lp, we're done.
3776 */
3777 if (lp == NULL) {
3778 if (callcnt == 0)
3779 nfscl_clientrelease(clp);
3780 else
3781 nfscl_releasealllocks(clp, vp, p, id, flags);
3782 return (error);
3783 }
3784 if (nmp->nm_clp != NULL)
3785 clidrev = nmp->nm_clp->nfsc_clientidrev;
3786 else
3787 clidrev = 0;
3788 /*
3789 * If the server doesn't support Posix lock semantics,
3790 * only allow locks on the entire file, since it won't
3791 * handle overlapping byte ranges.
3792 * There might still be a problem when a lock
3793 * upgrade/downgrade (read<->write) occurs, since the
3794 * server "might" expect an unlock first?
3795 */
3796 if (dorpc && (lp->nfsl_open->nfso_posixlock ||
3797 (off == 0 && len == NFS64BITSSET))) {
3798 /*
3799 * Since the lock records will go away, we must
3800 * wait for grace and delay here.
3801 */
3802 do {
3803 error = nfsrpc_locku(nd, nmp, lp, off, len,
3804 NFSV4LOCKT_READ, cred, p, 0);
3805 if ((nd->nd_repstat == NFSERR_GRACE ||
3806 nd->nd_repstat == NFSERR_DELAY) &&
3807 error == 0)
3808 (void) nfs_catnap(PZERO, (int)nd->nd_repstat,
3809 "nfs_advlock");
3810 } while ((nd->nd_repstat == NFSERR_GRACE ||
3811 nd->nd_repstat == NFSERR_DELAY) && error == 0);
3812 }
3813 callcnt++;
3814 } while (error == 0 && nd->nd_repstat == 0);
3815 nfscl_releasealllocks(clp, vp, p, id, flags);
3816 } else if (op == F_SETLK) {
3817 error = nfscl_getbytelock(vp, off, len, fl->l_type, cred, p,
3818 NULL, 0, id, flags, NULL, NULL, &lp, &newone, &donelocally);
3819 if (error || donelocally) {
3820 return (error);
3821 }
3822 if (nmp->nm_clp != NULL)
3823 clidrev = nmp->nm_clp->nfsc_clientidrev;
3824 else
3825 clidrev = 0;
3826 nfhp = VTONFS(vp)->n_fhp;
3827 if (!lp->nfsl_open->nfso_posixlock &&
3828 (off != 0 || len != NFS64BITSSET)) {
3829 error = EINVAL;
3830 } else {
3831 error = nfsrpc_lock(nd, nmp, vp, nfhp->nfh_fh,
3832 nfhp->nfh_len, lp, newone, reclaim, off,
3833 len, fl->l_type, cred, p, 0);
3834 }
3835 if (!error)
3836 error = nd->nd_repstat;
3837 nfscl_lockrelease(lp, error, newone);
3838 } else {
3839 error = EINVAL;
3840 }
3841 if (!error)
3842 error = nd->nd_repstat;
3843 if (error == NFSERR_GRACE || error == NFSERR_STALESTATEID ||
3844 error == NFSERR_STALEDONTRECOVER ||
3845 error == NFSERR_STALECLIENTID || error == NFSERR_DELAY ||
3846 error == NFSERR_BADSESSION) {
3847 (void) nfs_catnap(PZERO, error, "nfs_advlock");
3848 } else if ((error == NFSERR_EXPIRED || error == NFSERR_BADSTATEID)
3849 && clidrev != 0) {
3850 expireret = nfscl_hasexpired(nmp->nm_clp, clidrev, p);
3851 retrycnt++;
3852 }
3853 } while (error == NFSERR_GRACE ||
3854 error == NFSERR_STALECLIENTID || error == NFSERR_DELAY ||
3855 error == NFSERR_STALEDONTRECOVER || error == NFSERR_STALESTATEID ||
3856 error == NFSERR_BADSESSION ||
3857 ((error == NFSERR_EXPIRED || error == NFSERR_BADSTATEID) &&
3858 expireret == 0 && clidrev != 0 && retrycnt < 4));
3859 if (error && retrycnt >= 4)
3860 error = EIO;
3861 return (error);
3862 }
3863
3864 /*
3865 * The lower level routine for the LockT case.
3866 */
3867 APPLESTATIC int
3868 nfsrpc_lockt(struct nfsrv_descript *nd, vnode_t vp,
3869 struct nfsclclient *clp, u_int64_t off, u_int64_t len, struct flock *fl,
3870 struct ucred *cred, NFSPROC_T *p, void *id, int flags)
3871 {
3872 u_int32_t *tl;
3873 int error, type, size;
3874 uint8_t own[NFSV4CL_LOCKNAMELEN + NFSX_V4FHMAX];
3875 struct nfsnode *np;
3876 struct nfsmount *nmp;
3877 struct nfsclsession *tsep;
3878
3879 nmp = VFSTONFS(vp->v_mount);
3880 NFSCL_REQSTART(nd, NFSPROC_LOCKT, vp);
3881 NFSM_BUILD(tl, u_int32_t *, 7 * NFSX_UNSIGNED);
3882 if (fl->l_type == F_RDLCK)
3883 *tl++ = txdr_unsigned(NFSV4LOCKT_READ);
3884 else
3885 *tl++ = txdr_unsigned(NFSV4LOCKT_WRITE);
3886 txdr_hyper(off, tl);
3887 tl += 2;
3888 txdr_hyper(len, tl);
3889 tl += 2;
3890 tsep = nfsmnt_mdssession(nmp);
3891 *tl++ = tsep->nfsess_clientid.lval[0];
3892 *tl = tsep->nfsess_clientid.lval[1];
3893 nfscl_filllockowner(id, own, flags);
3894 np = VTONFS(vp);
3895 NFSBCOPY(np->n_fhp->nfh_fh, &own[NFSV4CL_LOCKNAMELEN],
3896 np->n_fhp->nfh_len);
3897 (void)nfsm_strtom(nd, own, NFSV4CL_LOCKNAMELEN + np->n_fhp->nfh_len);
3898 error = nfscl_request(nd, vp, p, cred, NULL);
3899 if (error)
3900 return (error);
3901 if (nd->nd_repstat == 0) {
3902 fl->l_type = F_UNLCK;
3903 } else if (nd->nd_repstat == NFSERR_DENIED) {
3904 nd->nd_repstat = 0;
3905 fl->l_whence = SEEK_SET;
3906 NFSM_DISSECT(tl, u_int32_t *, 8 * NFSX_UNSIGNED);
3907 fl->l_start = fxdr_hyper(tl);
3908 tl += 2;
3909 len = fxdr_hyper(tl);
3910 tl += 2;
3911 if (len == NFS64BITSSET)
3912 fl->l_len = 0;
3913 else
3914 fl->l_len = len;
3915 type = fxdr_unsigned(int, *tl++);
3916 if (type == NFSV4LOCKT_WRITE)
3917 fl->l_type = F_WRLCK;
3918 else
3919 fl->l_type = F_RDLCK;
3920 /*
3921 * XXX For now, I have no idea what to do with the
3922 * conflicting lock_owner, so I'll just set the pid == 0
3923 * and skip over the lock_owner.
3924 */
3925 fl->l_pid = (pid_t)0;
3926 tl += 2;
3927 size = fxdr_unsigned(int, *tl);
3928 if (size < 0 || size > NFSV4_OPAQUELIMIT)
3929 error = EBADRPC;
3930 if (!error)
3931 error = nfsm_advance(nd, NFSM_RNDUP(size), -1);
3932 } else if (nd->nd_repstat == NFSERR_STALECLIENTID)
3933 nfscl_initiate_recovery(clp);
3934 nfsmout:
3935 mbuf_freem(nd->nd_mrep);
3936 return (error);
3937 }
3938
3939 /*
3940 * Lower level function that performs the LockU RPC.
3941 */
3942 static int
3943 nfsrpc_locku(struct nfsrv_descript *nd, struct nfsmount *nmp,
3944 struct nfscllockowner *lp, u_int64_t off, u_int64_t len,
3945 u_int32_t type, struct ucred *cred, NFSPROC_T *p, int syscred)
3946 {
3947 u_int32_t *tl;
3948 int error;
3949
3950 nfscl_reqstart(nd, NFSPROC_LOCKU, nmp, lp->nfsl_open->nfso_fh,
3951 lp->nfsl_open->nfso_fhlen, NULL, NULL);
3952 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID + 6 * NFSX_UNSIGNED);
3953 *tl++ = txdr_unsigned(type);
3954 *tl = txdr_unsigned(lp->nfsl_seqid);
3955 if (nfstest_outofseq &&
3956 (arc4random() % nfstest_outofseq) == 0)
3957 *tl = txdr_unsigned(lp->nfsl_seqid + 1);
3958 tl++;
3959 if (NFSHASNFSV4N(nmp))
3960 *tl++ = 0;
3961 else
3962 *tl++ = lp->nfsl_stateid.seqid;
3963 *tl++ = lp->nfsl_stateid.other[0];
3964 *tl++ = lp->nfsl_stateid.other[1];
3965 *tl++ = lp->nfsl_stateid.other[2];
3966 txdr_hyper(off, tl);
3967 tl += 2;
3968 txdr_hyper(len, tl);
3969 if (syscred)
3970 nd->nd_flag |= ND_USEGSSNAME;
3971 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
3972 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
3973 NFSCL_INCRSEQID(lp->nfsl_seqid, nd);
3974 if (error)
3975 return (error);
3976 if (nd->nd_repstat == 0) {
3977 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID);
3978 lp->nfsl_stateid.seqid = *tl++;
3979 lp->nfsl_stateid.other[0] = *tl++;
3980 lp->nfsl_stateid.other[1] = *tl++;
3981 lp->nfsl_stateid.other[2] = *tl;
3982 } else if (nd->nd_repstat == NFSERR_STALESTATEID)
3983 nfscl_initiate_recovery(lp->nfsl_open->nfso_own->nfsow_clp);
3984 nfsmout:
3985 mbuf_freem(nd->nd_mrep);
3986 return (error);
3987 }
3988
3989 /*
3990 * The actual Lock RPC.
3991 */
3992 APPLESTATIC int
3993 nfsrpc_lock(struct nfsrv_descript *nd, struct nfsmount *nmp, vnode_t vp,
3994 u_int8_t *nfhp, int fhlen, struct nfscllockowner *lp, int newone,
3995 int reclaim, u_int64_t off, u_int64_t len, short type, struct ucred *cred,
3996 NFSPROC_T *p, int syscred)
3997 {
3998 u_int32_t *tl;
3999 int error, size;
4000 uint8_t own[NFSV4CL_LOCKNAMELEN + NFSX_V4FHMAX];
4001 struct nfsclsession *tsep;
4002
4003 nfscl_reqstart(nd, NFSPROC_LOCK, nmp, nfhp, fhlen, NULL, NULL);
4004 NFSM_BUILD(tl, u_int32_t *, 7 * NFSX_UNSIGNED);
4005 if (type == F_RDLCK)
4006 *tl++ = txdr_unsigned(NFSV4LOCKT_READ);
4007 else
4008 *tl++ = txdr_unsigned(NFSV4LOCKT_WRITE);
4009 *tl++ = txdr_unsigned(reclaim);
4010 txdr_hyper(off, tl);
4011 tl += 2;
4012 txdr_hyper(len, tl);
4013 tl += 2;
4014 if (newone) {
4015 *tl = newnfs_true;
4016 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID +
4017 2 * NFSX_UNSIGNED + NFSX_HYPER);
4018 *tl++ = txdr_unsigned(lp->nfsl_open->nfso_own->nfsow_seqid);
4019 if (NFSHASNFSV4N(nmp))
4020 *tl++ = 0;
4021 else
4022 *tl++ = lp->nfsl_open->nfso_stateid.seqid;
4023 *tl++ = lp->nfsl_open->nfso_stateid.other[0];
4024 *tl++ = lp->nfsl_open->nfso_stateid.other[1];
4025 *tl++ = lp->nfsl_open->nfso_stateid.other[2];
4026 *tl++ = txdr_unsigned(lp->nfsl_seqid);
4027 tsep = nfsmnt_mdssession(nmp);
4028 *tl++ = tsep->nfsess_clientid.lval[0];
4029 *tl = tsep->nfsess_clientid.lval[1];
4030 NFSBCOPY(lp->nfsl_owner, own, NFSV4CL_LOCKNAMELEN);
4031 NFSBCOPY(nfhp, &own[NFSV4CL_LOCKNAMELEN], fhlen);
4032 (void)nfsm_strtom(nd, own, NFSV4CL_LOCKNAMELEN + fhlen);
4033 } else {
4034 *tl = newnfs_false;
4035 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID + NFSX_UNSIGNED);
4036 if (NFSHASNFSV4N(nmp))
4037 *tl++ = 0;
4038 else
4039 *tl++ = lp->nfsl_stateid.seqid;
4040 *tl++ = lp->nfsl_stateid.other[0];
4041 *tl++ = lp->nfsl_stateid.other[1];
4042 *tl++ = lp->nfsl_stateid.other[2];
4043 *tl = txdr_unsigned(lp->nfsl_seqid);
4044 if (nfstest_outofseq &&
4045 (arc4random() % nfstest_outofseq) == 0)
4046 *tl = txdr_unsigned(lp->nfsl_seqid + 1);
4047 }
4048 if (syscred)
4049 nd->nd_flag |= ND_USEGSSNAME;
4050 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, vp, p, cred,
4051 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4052 if (error)
4053 return (error);
4054 if (newone)
4055 NFSCL_INCRSEQID(lp->nfsl_open->nfso_own->nfsow_seqid, nd);
4056 NFSCL_INCRSEQID(lp->nfsl_seqid, nd);
4057 if (nd->nd_repstat == 0) {
4058 NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID);
4059 lp->nfsl_stateid.seqid = *tl++;
4060 lp->nfsl_stateid.other[0] = *tl++;
4061 lp->nfsl_stateid.other[1] = *tl++;
4062 lp->nfsl_stateid.other[2] = *tl;
4063 } else if (nd->nd_repstat == NFSERR_DENIED) {
4064 NFSM_DISSECT(tl, u_int32_t *, 8 * NFSX_UNSIGNED);
4065 size = fxdr_unsigned(int, *(tl + 7));
4066 if (size < 0 || size > NFSV4_OPAQUELIMIT)
4067 error = EBADRPC;
4068 if (!error)
4069 error = nfsm_advance(nd, NFSM_RNDUP(size), -1);
4070 } else if (nd->nd_repstat == NFSERR_STALESTATEID)
4071 nfscl_initiate_recovery(lp->nfsl_open->nfso_own->nfsow_clp);
4072 nfsmout:
4073 mbuf_freem(nd->nd_mrep);
4074 return (error);
4075 }
4076
4077 /*
4078 * nfs statfs rpc
4079 * (always called with the vp for the mount point)
4080 */
4081 APPLESTATIC int
4082 nfsrpc_statfs(vnode_t vp, struct nfsstatfs *sbp, struct nfsfsinfo *fsp,
4083 struct ucred *cred, NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp,
4084 void *stuff)
4085 {
4086 u_int32_t *tl = NULL;
4087 struct nfsrv_descript nfsd, *nd = &nfsd;
4088 struct nfsmount *nmp;
4089 nfsattrbit_t attrbits;
4090 int error;
4091
4092 *attrflagp = 0;
4093 nmp = VFSTONFS(vnode_mount(vp));
4094 if (NFSHASNFSV4(nmp)) {
4095 /*
4096 * For V4, you actually do a getattr.
4097 */
4098 NFSCL_REQSTART(nd, NFSPROC_GETATTR, vp);
4099 NFSSTATFS_GETATTRBIT(&attrbits);
4100 (void) nfsrv_putattrbit(nd, &attrbits);
4101 nd->nd_flag |= ND_USEGSSNAME;
4102 error = nfscl_request(nd, vp, p, cred, stuff);
4103 if (error)
4104 return (error);
4105 if (nd->nd_repstat == 0) {
4106 error = nfsv4_loadattr(nd, NULL, nap, NULL, NULL, 0,
4107 NULL, NULL, sbp, fsp, NULL, 0, NULL, NULL, NULL, p,
4108 cred);
4109 if (!error) {
4110 nmp->nm_fsid[0] = nap->na_filesid[0];
4111 nmp->nm_fsid[1] = nap->na_filesid[1];
4112 NFSSETHASSETFSID(nmp);
4113 *attrflagp = 1;
4114 }
4115 } else {
4116 error = nd->nd_repstat;
4117 }
4118 if (error)
4119 goto nfsmout;
4120 } else {
4121 NFSCL_REQSTART(nd, NFSPROC_FSSTAT, vp);
4122 error = nfscl_request(nd, vp, p, cred, stuff);
4123 if (error)
4124 return (error);
4125 if (nd->nd_flag & ND_NFSV3) {
4126 error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
4127 if (error)
4128 goto nfsmout;
4129 }
4130 if (nd->nd_repstat) {
4131 error = nd->nd_repstat;
4132 goto nfsmout;
4133 }
4134 NFSM_DISSECT(tl, u_int32_t *,
4135 NFSX_STATFS(nd->nd_flag & ND_NFSV3));
4136 }
4137 if (NFSHASNFSV3(nmp)) {
4138 sbp->sf_tbytes = fxdr_hyper(tl); tl += 2;
4139 sbp->sf_fbytes = fxdr_hyper(tl); tl += 2;
4140 sbp->sf_abytes = fxdr_hyper(tl); tl += 2;
4141 sbp->sf_tfiles = fxdr_hyper(tl); tl += 2;
4142 sbp->sf_ffiles = fxdr_hyper(tl); tl += 2;
4143 sbp->sf_afiles = fxdr_hyper(tl); tl += 2;
4144 sbp->sf_invarsec = fxdr_unsigned(u_int32_t, *tl);
4145 } else if (NFSHASNFSV4(nmp) == 0) {
4146 sbp->sf_tsize = fxdr_unsigned(u_int32_t, *tl++);
4147 sbp->sf_bsize = fxdr_unsigned(u_int32_t, *tl++);
4148 sbp->sf_blocks = fxdr_unsigned(u_int32_t, *tl++);
4149 sbp->sf_bfree = fxdr_unsigned(u_int32_t, *tl++);
4150 sbp->sf_bavail = fxdr_unsigned(u_int32_t, *tl);
4151 }
4152 nfsmout:
4153 mbuf_freem(nd->nd_mrep);
4154 return (error);
4155 }
4156
4157 /*
4158 * nfs pathconf rpc
4159 */
4160 APPLESTATIC int
4161 nfsrpc_pathconf(vnode_t vp, struct nfsv3_pathconf *pc,
4162 struct ucred *cred, NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp,
4163 void *stuff)
4164 {
4165 struct nfsrv_descript nfsd, *nd = &nfsd;
4166 struct nfsmount *nmp;
4167 u_int32_t *tl;
4168 nfsattrbit_t attrbits;
4169 int error;
4170
4171 *attrflagp = 0;
4172 nmp = VFSTONFS(vnode_mount(vp));
4173 if (NFSHASNFSV4(nmp)) {
4174 /*
4175 * For V4, you actually do a getattr.
4176 */
4177 NFSCL_REQSTART(nd, NFSPROC_GETATTR, vp);
4178 NFSPATHCONF_GETATTRBIT(&attrbits);
4179 (void) nfsrv_putattrbit(nd, &attrbits);
4180 nd->nd_flag |= ND_USEGSSNAME;
4181 error = nfscl_request(nd, vp, p, cred, stuff);
4182 if (error)
4183 return (error);
4184 if (nd->nd_repstat == 0) {
4185 error = nfsv4_loadattr(nd, NULL, nap, NULL, NULL, 0,
4186 pc, NULL, NULL, NULL, NULL, 0, NULL, NULL, NULL, p,
4187 cred);
4188 if (!error)
4189 *attrflagp = 1;
4190 } else {
4191 error = nd->nd_repstat;
4192 }
4193 } else {
4194 NFSCL_REQSTART(nd, NFSPROC_PATHCONF, vp);
4195 error = nfscl_request(nd, vp, p, cred, stuff);
4196 if (error)
4197 return (error);
4198 error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
4199 if (nd->nd_repstat && !error)
4200 error = nd->nd_repstat;
4201 if (!error) {
4202 NFSM_DISSECT(tl, u_int32_t *, NFSX_V3PATHCONF);
4203 pc->pc_linkmax = fxdr_unsigned(u_int32_t, *tl++);
4204 pc->pc_namemax = fxdr_unsigned(u_int32_t, *tl++);
4205 pc->pc_notrunc = fxdr_unsigned(u_int32_t, *tl++);
4206 pc->pc_chownrestricted =
4207 fxdr_unsigned(u_int32_t, *tl++);
4208 pc->pc_caseinsensitive =
4209 fxdr_unsigned(u_int32_t, *tl++);
4210 pc->pc_casepreserving = fxdr_unsigned(u_int32_t, *tl);
4211 }
4212 }
4213 nfsmout:
4214 mbuf_freem(nd->nd_mrep);
4215 return (error);
4216 }
4217
4218 /*
4219 * nfs version 3 fsinfo rpc call
4220 */
4221 APPLESTATIC int
4222 nfsrpc_fsinfo(vnode_t vp, struct nfsfsinfo *fsp, struct ucred *cred,
4223 NFSPROC_T *p, struct nfsvattr *nap, int *attrflagp, void *stuff)
4224 {
4225 u_int32_t *tl;
4226 struct nfsrv_descript nfsd, *nd = &nfsd;
4227 int error;
4228
4229 *attrflagp = 0;
4230 NFSCL_REQSTART(nd, NFSPROC_FSINFO, vp);
4231 error = nfscl_request(nd, vp, p, cred, stuff);
4232 if (error)
4233 return (error);
4234 error = nfscl_postop_attr(nd, nap, attrflagp, stuff);
4235 if (nd->nd_repstat && !error)
4236 error = nd->nd_repstat;
4237 if (!error) {
4238 NFSM_DISSECT(tl, u_int32_t *, NFSX_V3FSINFO);
4239 fsp->fs_rtmax = fxdr_unsigned(u_int32_t, *tl++);
4240 fsp->fs_rtpref = fxdr_unsigned(u_int32_t, *tl++);
4241 fsp->fs_rtmult = fxdr_unsigned(u_int32_t, *tl++);
4242 fsp->fs_wtmax = fxdr_unsigned(u_int32_t, *tl++);
4243 fsp->fs_wtpref = fxdr_unsigned(u_int32_t, *tl++);
4244 fsp->fs_wtmult = fxdr_unsigned(u_int32_t, *tl++);
4245 fsp->fs_dtpref = fxdr_unsigned(u_int32_t, *tl++);
4246 fsp->fs_maxfilesize = fxdr_hyper(tl);
4247 tl += 2;
4248 fxdr_nfsv3time(tl, &fsp->fs_timedelta);
4249 tl += 2;
4250 fsp->fs_properties = fxdr_unsigned(u_int32_t, *tl);
4251 }
4252 nfsmout:
4253 mbuf_freem(nd->nd_mrep);
4254 return (error);
4255 }
4256
4257 /*
4258 * This function performs the Renew RPC.
4259 */
4260 APPLESTATIC int
4261 nfsrpc_renew(struct nfsclclient *clp, struct nfsclds *dsp, struct ucred *cred,
4262 NFSPROC_T *p)
4263 {
4264 u_int32_t *tl;
4265 struct nfsrv_descript nfsd;
4266 struct nfsrv_descript *nd = &nfsd;
4267 struct nfsmount *nmp;
4268 int error;
4269 struct nfssockreq *nrp;
4270 struct nfsclsession *tsep;
4271
4272 nmp = clp->nfsc_nmp;
4273 if (nmp == NULL)
4274 return (0);
4275 if (dsp == NULL)
4276 nfscl_reqstart(nd, NFSPROC_RENEW, nmp, NULL, 0, NULL, NULL);
4277 else
4278 nfscl_reqstart(nd, NFSPROC_RENEW, nmp, NULL, 0, NULL,
4279 &dsp->nfsclds_sess);
4280 if (!NFSHASNFSV4N(nmp)) {
4281 /* NFSv4.1 just uses a Sequence Op and not a Renew. */
4282 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
4283 tsep = nfsmnt_mdssession(nmp);
4284 *tl++ = tsep->nfsess_clientid.lval[0];
4285 *tl = tsep->nfsess_clientid.lval[1];
4286 }
4287 nrp = NULL;
4288 if (dsp != NULL)
4289 nrp = dsp->nfsclds_sockp;
4290 if (nrp == NULL)
4291 /* If NULL, use the MDS socket. */
4292 nrp = &nmp->nm_sockreq;
4293 nd->nd_flag |= ND_USEGSSNAME;
4294 if (dsp == NULL)
4295 error = newnfs_request(nd, nmp, NULL, nrp, NULL, p, cred,
4296 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4297 else
4298 error = newnfs_request(nd, nmp, NULL, nrp, NULL, p, cred,
4299 NFS_PROG, NFS_VER4, NULL, 1, NULL, &dsp->nfsclds_sess);
4300 if (error)
4301 return (error);
4302 error = nd->nd_repstat;
4303 mbuf_freem(nd->nd_mrep);
4304 return (error);
4305 }
4306
4307 /*
4308 * This function performs the Releaselockowner RPC.
4309 */
4310 APPLESTATIC int
4311 nfsrpc_rellockown(struct nfsmount *nmp, struct nfscllockowner *lp,
4312 uint8_t *fh, int fhlen, struct ucred *cred, NFSPROC_T *p)
4313 {
4314 struct nfsrv_descript nfsd, *nd = &nfsd;
4315 u_int32_t *tl;
4316 int error;
4317 uint8_t own[NFSV4CL_LOCKNAMELEN + NFSX_V4FHMAX];
4318 struct nfsclsession *tsep;
4319
4320 if (NFSHASNFSV4N(nmp)) {
4321 /* For NFSv4.1, do a FreeStateID. */
4322 nfscl_reqstart(nd, NFSPROC_FREESTATEID, nmp, NULL, 0, NULL,
4323 NULL);
4324 nfsm_stateidtom(nd, &lp->nfsl_stateid, NFSSTATEID_PUTSTATEID);
4325 } else {
4326 nfscl_reqstart(nd, NFSPROC_RELEASELCKOWN, nmp, NULL, 0, NULL,
4327 NULL);
4328 NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
4329 tsep = nfsmnt_mdssession(nmp);
4330 *tl++ = tsep->nfsess_clientid.lval[0];
4331 *tl = tsep->nfsess_clientid.lval[1];
4332 NFSBCOPY(lp->nfsl_owner, own, NFSV4CL_LOCKNAMELEN);
4333 NFSBCOPY(fh, &own[NFSV4CL_LOCKNAMELEN], fhlen);
4334 (void)nfsm_strtom(nd, own, NFSV4CL_LOCKNAMELEN + fhlen);
4335 }
4336 nd->nd_flag |= ND_USEGSSNAME;
4337 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
4338 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4339 if (error)
4340 return (error);
4341 error = nd->nd_repstat;
4342 mbuf_freem(nd->nd_mrep);
4343 return (error);
4344 }
4345
4346 /*
4347 * This function performs the Compound to get the mount pt FH.
4348 */
4349 APPLESTATIC int
4350 nfsrpc_getdirpath(struct nfsmount *nmp, u_char *dirpath, struct ucred *cred,
4351 NFSPROC_T *p)
4352 {
4353 u_int32_t *tl;
4354 struct nfsrv_descript nfsd;
4355 struct nfsrv_descript *nd = &nfsd;
4356 u_char *cp, *cp2;
4357 int error, cnt, len, setnil;
4358 u_int32_t *opcntp;
4359
4360 nfscl_reqstart(nd, NFSPROC_PUTROOTFH, nmp, NULL, 0, &opcntp, NULL);
4361 cp = dirpath;
4362 cnt = 0;
4363 do {
4364 setnil = 0;
4365 while (*cp == '/')
4366 cp++;
4367 cp2 = cp;
4368 while (*cp2 != '\0' && *cp2 != '/')
4369 cp2++;
4370 if (*cp2 == '/') {
4371 setnil = 1;
4372 *cp2 = '\0';
4373 }
4374 if (cp2 != cp) {
4375 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
4376 *tl = txdr_unsigned(NFSV4OP_LOOKUP);
4377 nfsm_strtom(nd, cp, strlen(cp));
4378 cnt++;
4379 }
4380 if (setnil)
4381 *cp2++ = '/';
4382 cp = cp2;
4383 } while (*cp != '\0');
4384 if (NFSHASNFSV4N(nmp))
4385 /* Has a Sequence Op done by nfscl_reqstart(). */
4386 *opcntp = txdr_unsigned(3 + cnt);
4387 else
4388 *opcntp = txdr_unsigned(2 + cnt);
4389 NFSM_BUILD(tl, u_int32_t *, NFSX_UNSIGNED);
4390 *tl = txdr_unsigned(NFSV4OP_GETFH);
4391 nd->nd_flag |= ND_USEGSSNAME;
4392 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
4393 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4394 if (error)
4395 return (error);
4396 if (nd->nd_repstat == 0) {
4397 NFSM_DISSECT(tl, u_int32_t *, (3 + 2 * cnt) * NFSX_UNSIGNED);
4398 tl += (2 + 2 * cnt);
4399 if ((len = fxdr_unsigned(int, *tl)) <= 0 ||
4400 len > NFSX_FHMAX) {
4401 nd->nd_repstat = NFSERR_BADXDR;
4402 } else {
4403 nd->nd_repstat = nfsrv_mtostr(nd, nmp->nm_fh, len);
4404 if (nd->nd_repstat == 0)
4405 nmp->nm_fhsize = len;
4406 }
4407 }
4408 error = nd->nd_repstat;
4409 nfsmout:
4410 mbuf_freem(nd->nd_mrep);
4411 return (error);
4412 }
4413
4414 /*
4415 * This function performs the Delegreturn RPC.
4416 */
4417 APPLESTATIC int
4418 nfsrpc_delegreturn(struct nfscldeleg *dp, struct ucred *cred,
4419 struct nfsmount *nmp, NFSPROC_T *p, int syscred)
4420 {
4421 u_int32_t *tl;
4422 struct nfsrv_descript nfsd;
4423 struct nfsrv_descript *nd = &nfsd;
4424 int error;
4425
4426 nfscl_reqstart(nd, NFSPROC_DELEGRETURN, nmp, dp->nfsdl_fh,
4427 dp->nfsdl_fhlen, NULL, NULL);
4428 NFSM_BUILD(tl, u_int32_t *, NFSX_STATEID);
4429 if (NFSHASNFSV4N(nmp))
4430 *tl++ = 0;
4431 else
4432 *tl++ = dp->nfsdl_stateid.seqid;
4433 *tl++ = dp->nfsdl_stateid.other[0];
4434 *tl++ = dp->nfsdl_stateid.other[1];
4435 *tl = dp->nfsdl_stateid.other[2];
4436 if (syscred)
4437 nd->nd_flag |= ND_USEGSSNAME;
4438 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
4439 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4440 if (error)
4441 return (error);
4442 error = nd->nd_repstat;
4443 mbuf_freem(nd->nd_mrep);
4444 return (error);
4445 }
4446
4447 /*
4448 * nfs getacl call.
4449 */
4450 APPLESTATIC int
4451 nfsrpc_getacl(vnode_t vp, struct ucred *cred, NFSPROC_T *p,
4452 struct acl *aclp, void *stuff)
4453 {
4454 struct nfsrv_descript nfsd, *nd = &nfsd;
4455 int error;
4456 nfsattrbit_t attrbits;
4457 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
4458
4459 if (nfsrv_useacl == 0 || !NFSHASNFSV4(nmp))
4460 return (EOPNOTSUPP);
4461 NFSCL_REQSTART(nd, NFSPROC_GETACL, vp);
4462 NFSZERO_ATTRBIT(&attrbits);
4463 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_ACL);
4464 (void) nfsrv_putattrbit(nd, &attrbits);
4465 error = nfscl_request(nd, vp, p, cred, stuff);
4466 if (error)
4467 return (error);
4468 if (!nd->nd_repstat)
4469 error = nfsv4_loadattr(nd, vp, NULL, NULL, NULL, 0, NULL,
4470 NULL, NULL, NULL, aclp, 0, NULL, NULL, NULL, p, cred);
4471 else
4472 error = nd->nd_repstat;
4473 mbuf_freem(nd->nd_mrep);
4474 return (error);
4475 }
4476
4477 /*
4478 * nfs setacl call.
4479 */
4480 APPLESTATIC int
4481 nfsrpc_setacl(vnode_t vp, struct ucred *cred, NFSPROC_T *p,
4482 struct acl *aclp, void *stuff)
4483 {
4484 int error;
4485 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
4486
4487 if (nfsrv_useacl == 0 || !NFSHASNFSV4(nmp))
4488 return (EOPNOTSUPP);
4489 error = nfsrpc_setattr(vp, NULL, aclp, cred, p, NULL, NULL, stuff);
4490 return (error);
4491 }
4492
4493 /*
4494 * nfs setacl call.
4495 */
4496 static int
4497 nfsrpc_setaclrpc(vnode_t vp, struct ucred *cred, NFSPROC_T *p,
4498 struct acl *aclp, nfsv4stateid_t *stateidp, void *stuff)
4499 {
4500 struct nfsrv_descript nfsd, *nd = &nfsd;
4501 int error;
4502 nfsattrbit_t attrbits;
4503 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
4504
4505 if (!NFSHASNFSV4(nmp))
4506 return (EOPNOTSUPP);
4507 NFSCL_REQSTART(nd, NFSPROC_SETACL, vp);
4508 nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSTATEID);
4509 NFSZERO_ATTRBIT(&attrbits);
4510 NFSSETBIT_ATTRBIT(&attrbits, NFSATTRBIT_ACL);
4511 (void) nfsv4_fillattr(nd, vnode_mount(vp), vp, aclp, NULL, NULL, 0,
4512 &attrbits, NULL, NULL, 0, 0, 0, 0, (uint64_t)0);
4513 error = nfscl_request(nd, vp, p, cred, stuff);
4514 if (error)
4515 return (error);
4516 /* Don't care about the pre/postop attributes */
4517 mbuf_freem(nd->nd_mrep);
4518 return (nd->nd_repstat);
4519 }
4520
4521 /*
4522 * Do the NFSv4.1 Exchange ID.
4523 */
4524 int
4525 nfsrpc_exchangeid(struct nfsmount *nmp, struct nfsclclient *clp,
4526 struct nfssockreq *nrp, uint32_t exchflags, struct nfsclds **dspp,
4527 struct ucred *cred, NFSPROC_T *p)
4528 {
4529 uint32_t *tl, v41flags;
4530 struct nfsrv_descript nfsd;
4531 struct nfsrv_descript *nd = &nfsd;
4532 struct nfsclds *dsp;
4533 struct timespec verstime;
4534 int error, len;
4535
4536 *dspp = NULL;
4537 nfscl_reqstart(nd, NFSPROC_EXCHANGEID, nmp, NULL, 0, NULL, NULL);
4538 NFSM_BUILD(tl, uint32_t *, 2 * NFSX_UNSIGNED);
4539 *tl++ = txdr_unsigned(nfsboottime.tv_sec); /* Client owner */
4540 *tl = txdr_unsigned(clp->nfsc_rev);
4541 (void) nfsm_strtom(nd, clp->nfsc_id, clp->nfsc_idlen);
4542
4543 NFSM_BUILD(tl, uint32_t *, 3 * NFSX_UNSIGNED);
4544 *tl++ = txdr_unsigned(exchflags);
4545 *tl++ = txdr_unsigned(NFSV4EXCH_SP4NONE);
4546
4547 /* Set the implementation id4 */
4548 *tl = txdr_unsigned(1);
4549 (void) nfsm_strtom(nd, "freebsd.org", strlen("freebsd.org"));
4550 (void) nfsm_strtom(nd, version, strlen(version));
4551 NFSM_BUILD(tl, uint32_t *, NFSX_V4TIME);
4552 verstime.tv_sec = 1293840000; /* Jan 1, 2011 */
4553 verstime.tv_nsec = 0;
4554 txdr_nfsv4time(&verstime, tl);
4555 nd->nd_flag |= ND_USEGSSNAME;
4556 error = newnfs_request(nd, nmp, NULL, nrp, NULL, p, cred,
4557 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4558 NFSCL_DEBUG(1, "exchangeid err=%d reps=%d\n", error,
4559 (int)nd->nd_repstat);
4560 if (error != 0)
4561 return (error);
4562 if (nd->nd_repstat == 0) {
4563 NFSM_DISSECT(tl, uint32_t *, 6 * NFSX_UNSIGNED + NFSX_HYPER);
4564 len = fxdr_unsigned(int, *(tl + 7));
4565 if (len < 0 || len > NFSV4_OPAQUELIMIT) {
4566 error = NFSERR_BADXDR;
4567 goto nfsmout;
4568 }
4569 dsp = malloc(sizeof(struct nfsclds) + len + 1, M_NFSCLDS,
4570 M_WAITOK | M_ZERO);
4571 dsp->nfsclds_expire = NFSD_MONOSEC + clp->nfsc_renew;
4572 dsp->nfsclds_servownlen = len;
4573 dsp->nfsclds_sess.nfsess_clientid.lval[0] = *tl++;
4574 dsp->nfsclds_sess.nfsess_clientid.lval[1] = *tl++;
4575 dsp->nfsclds_sess.nfsess_sequenceid =
4576 fxdr_unsigned(uint32_t, *tl++);
4577 v41flags = fxdr_unsigned(uint32_t, *tl);
4578 if ((v41flags & NFSV4EXCH_USEPNFSMDS) != 0 &&
4579 NFSHASPNFSOPT(nmp)) {
4580 NFSCL_DEBUG(1, "set PNFS\n");
4581 NFSLOCKMNT(nmp);
4582 nmp->nm_state |= NFSSTA_PNFS;
4583 NFSUNLOCKMNT(nmp);
4584 dsp->nfsclds_flags |= NFSCLDS_MDS;
4585 }
4586 if ((v41flags & NFSV4EXCH_USEPNFSDS) != 0)
4587 dsp->nfsclds_flags |= NFSCLDS_DS;
4588 if (len > 0)
4589 nd->nd_repstat = nfsrv_mtostr(nd,
4590 dsp->nfsclds_serverown, len);
4591 if (nd->nd_repstat == 0) {
4592 mtx_init(&dsp->nfsclds_mtx, "nfsds", NULL, MTX_DEF);
4593 mtx_init(&dsp->nfsclds_sess.nfsess_mtx, "nfssession",
4594 NULL, MTX_DEF);
4595 nfscl_initsessionslots(&dsp->nfsclds_sess);
4596 *dspp = dsp;
4597 } else
4598 free(dsp, M_NFSCLDS);
4599 }
4600 error = nd->nd_repstat;
4601 nfsmout:
4602 mbuf_freem(nd->nd_mrep);
4603 return (error);
4604 }
4605
4606 /*
4607 * Do the NFSv4.1 Create Session.
4608 */
4609 int
4610 nfsrpc_createsession(struct nfsmount *nmp, struct nfsclsession *sep,
4611 struct nfssockreq *nrp, uint32_t sequenceid, int mds, struct ucred *cred,
4612 NFSPROC_T *p)
4613 {
4614 uint32_t crflags, maxval, *tl;
4615 struct nfsrv_descript nfsd;
4616 struct nfsrv_descript *nd = &nfsd;
4617 int error, irdcnt;
4618
4619 /* Make sure nm_rsize, nm_wsize is set. */
4620 if (nmp->nm_rsize > NFS_MAXBSIZE || nmp->nm_rsize == 0)
4621 nmp->nm_rsize = NFS_MAXBSIZE;
4622 if (nmp->nm_wsize > NFS_MAXBSIZE || nmp->nm_wsize == 0)
4623 nmp->nm_wsize = NFS_MAXBSIZE;
4624 nfscl_reqstart(nd, NFSPROC_CREATESESSION, nmp, NULL, 0, NULL, NULL);
4625 NFSM_BUILD(tl, uint32_t *, 4 * NFSX_UNSIGNED);
4626 *tl++ = sep->nfsess_clientid.lval[0];
4627 *tl++ = sep->nfsess_clientid.lval[1];
4628 *tl++ = txdr_unsigned(sequenceid);
4629 crflags = (NFSMNT_RDONLY(nmp->nm_mountp) ? 0 : NFSV4CRSESS_PERSIST);
4630 if (nfscl_enablecallb != 0 && nfs_numnfscbd > 0 && mds != 0)
4631 crflags |= NFSV4CRSESS_CONNBACKCHAN;
4632 *tl = txdr_unsigned(crflags);
4633
4634 /* Fill in fore channel attributes. */
4635 NFSM_BUILD(tl, uint32_t *, 7 * NFSX_UNSIGNED);
4636 *tl++ = 0; /* Header pad size */
4637 *tl++ = txdr_unsigned(nmp->nm_wsize + NFS_MAXXDR);/* Max request size */
4638 *tl++ = txdr_unsigned(nmp->nm_rsize + NFS_MAXXDR);/* Max reply size */
4639 *tl++ = txdr_unsigned(4096); /* Max response size cached */
4640 *tl++ = txdr_unsigned(20); /* Max operations */
4641 *tl++ = txdr_unsigned(64); /* Max slots */
4642 *tl = 0; /* No rdma ird */
4643
4644 /* Fill in back channel attributes. */
4645 NFSM_BUILD(tl, uint32_t *, 7 * NFSX_UNSIGNED);
4646 *tl++ = 0; /* Header pad size */
4647 *tl++ = txdr_unsigned(10000); /* Max request size */
4648 *tl++ = txdr_unsigned(10000); /* Max response size */
4649 *tl++ = txdr_unsigned(4096); /* Max response size cached */
4650 *tl++ = txdr_unsigned(4); /* Max operations */
4651 *tl++ = txdr_unsigned(NFSV4_CBSLOTS); /* Max slots */
4652 *tl = 0; /* No rdma ird */
4653
4654 NFSM_BUILD(tl, uint32_t *, 8 * NFSX_UNSIGNED);
4655 *tl++ = txdr_unsigned(NFS_CALLBCKPROG); /* Call back prog # */
4656
4657 /* Allow AUTH_SYS callbacks as uid, gid == 0. */
4658 *tl++ = txdr_unsigned(1); /* Auth_sys only */
4659 *tl++ = txdr_unsigned(AUTH_SYS); /* AUTH_SYS type */
4660 *tl++ = txdr_unsigned(nfsboottime.tv_sec); /* time stamp */
4661 *tl++ = 0; /* Null machine name */
4662 *tl++ = 0; /* Uid == 0 */
4663 *tl++ = 0; /* Gid == 0 */
4664 *tl = 0; /* No additional gids */
4665 nd->nd_flag |= ND_USEGSSNAME;
4666 error = newnfs_request(nd, nmp, NULL, nrp, NULL, p, cred, NFS_PROG,
4667 NFS_VER4, NULL, 1, NULL, NULL);
4668 if (error != 0)
4669 return (error);
4670 if (nd->nd_repstat == 0) {
4671 NFSM_DISSECT(tl, uint32_t *, NFSX_V4SESSIONID +
4672 2 * NFSX_UNSIGNED);
4673 bcopy(tl, sep->nfsess_sessionid, NFSX_V4SESSIONID);
4674 tl += NFSX_V4SESSIONID / NFSX_UNSIGNED;
4675 sep->nfsess_sequenceid = fxdr_unsigned(uint32_t, *tl++);
4676 crflags = fxdr_unsigned(uint32_t, *tl);
4677 if ((crflags & NFSV4CRSESS_PERSIST) != 0 && mds != 0) {
4678 NFSLOCKMNT(nmp);
4679 nmp->nm_state |= NFSSTA_SESSPERSIST;
4680 NFSUNLOCKMNT(nmp);
4681 }
4682
4683 /* Get the fore channel slot count. */
4684 NFSM_DISSECT(tl, uint32_t *, 7 * NFSX_UNSIGNED);
4685 tl++; /* Skip the header pad size. */
4686
4687 /* Make sure nm_wsize is small enough. */
4688 maxval = fxdr_unsigned(uint32_t, *tl++);
4689 while (maxval < nmp->nm_wsize + NFS_MAXXDR) {
4690 if (nmp->nm_wsize > 8096)
4691 nmp->nm_wsize /= 2;
4692 else
4693 break;
4694 }
4695
4696 /* Make sure nm_rsize is small enough. */
4697 maxval = fxdr_unsigned(uint32_t, *tl++);
4698 while (maxval < nmp->nm_rsize + NFS_MAXXDR) {
4699 if (nmp->nm_rsize > 8096)
4700 nmp->nm_rsize /= 2;
4701 else
4702 break;
4703 }
4704
4705 sep->nfsess_maxcache = fxdr_unsigned(int, *tl++);
4706 tl++;
4707 sep->nfsess_foreslots = fxdr_unsigned(uint16_t, *tl++);
4708 NFSCL_DEBUG(4, "fore slots=%d\n", (int)sep->nfsess_foreslots);
4709 irdcnt = fxdr_unsigned(int, *tl);
4710 if (irdcnt > 0)
4711 NFSM_DISSECT(tl, uint32_t *, irdcnt * NFSX_UNSIGNED);
4712
4713 /* and the back channel slot count. */
4714 NFSM_DISSECT(tl, uint32_t *, 7 * NFSX_UNSIGNED);
4715 tl += 5;
4716 sep->nfsess_backslots = fxdr_unsigned(uint16_t, *tl);
4717 NFSCL_DEBUG(4, "back slots=%d\n", (int)sep->nfsess_backslots);
4718 }
4719 error = nd->nd_repstat;
4720 nfsmout:
4721 mbuf_freem(nd->nd_mrep);
4722 return (error);
4723 }
4724
4725 /*
4726 * Do the NFSv4.1 Destroy Session.
4727 */
4728 int
4729 nfsrpc_destroysession(struct nfsmount *nmp, struct nfsclclient *clp,
4730 struct ucred *cred, NFSPROC_T *p)
4731 {
4732 uint32_t *tl;
4733 struct nfsrv_descript nfsd;
4734 struct nfsrv_descript *nd = &nfsd;
4735 int error;
4736 struct nfsclsession *tsep;
4737
4738 nfscl_reqstart(nd, NFSPROC_DESTROYSESSION, nmp, NULL, 0, NULL, NULL);
4739 NFSM_BUILD(tl, uint32_t *, NFSX_V4SESSIONID);
4740 tsep = nfsmnt_mdssession(nmp);
4741 bcopy(tsep->nfsess_sessionid, tl, NFSX_V4SESSIONID);
4742 nd->nd_flag |= ND_USEGSSNAME;
4743 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
4744 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4745 if (error != 0)
4746 return (error);
4747 error = nd->nd_repstat;
4748 mbuf_freem(nd->nd_mrep);
4749 return (error);
4750 }
4751
4752 /*
4753 * Do the NFSv4.1 Destroy Client.
4754 */
4755 int
4756 nfsrpc_destroyclient(struct nfsmount *nmp, struct nfsclclient *clp,
4757 struct ucred *cred, NFSPROC_T *p)
4758 {
4759 uint32_t *tl;
4760 struct nfsrv_descript nfsd;
4761 struct nfsrv_descript *nd = &nfsd;
4762 int error;
4763 struct nfsclsession *tsep;
4764
4765 nfscl_reqstart(nd, NFSPROC_DESTROYCLIENT, nmp, NULL, 0, NULL, NULL);
4766 NFSM_BUILD(tl, uint32_t *, 2 * NFSX_UNSIGNED);
4767 tsep = nfsmnt_mdssession(nmp);
4768 *tl++ = tsep->nfsess_clientid.lval[0];
4769 *tl = tsep->nfsess_clientid.lval[1];
4770 nd->nd_flag |= ND_USEGSSNAME;
4771 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
4772 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4773 if (error != 0)
4774 return (error);
4775 error = nd->nd_repstat;
4776 mbuf_freem(nd->nd_mrep);
4777 return (error);
4778 }
4779
4780 /*
4781 * Do the NFSv4.1 LayoutGet.
4782 */
4783 int
4784 nfsrpc_layoutget(struct nfsmount *nmp, uint8_t *fhp, int fhlen, int iomode,
4785 uint64_t offset, uint64_t len, uint64_t minlen, int layoutlen,
4786 nfsv4stateid_t *stateidp, int *retonclosep, struct nfsclflayouthead *flhp,
4787 struct ucred *cred, NFSPROC_T *p, void *stuff)
4788 {
4789 uint32_t *tl;
4790 struct nfsrv_descript nfsd, *nd = &nfsd;
4791 struct nfsfh *nfhp;
4792 struct nfsclflayout *flp, *prevflp, *tflp;
4793 int cnt, error, gotiomode, fhcnt, nfhlen, i, j;
4794 uint8_t *cp;
4795 uint64_t retlen;
4796
4797 flp = NULL;
4798 gotiomode = -1;
4799 nfscl_reqstart(nd, NFSPROC_LAYOUTGET, nmp, fhp, fhlen, NULL, NULL);
4800 NFSM_BUILD(tl, uint32_t *, 4 * NFSX_UNSIGNED + 3 * NFSX_HYPER +
4801 NFSX_STATEID);
4802 *tl++ = newnfs_false; /* Don't signal availability. */
4803 *tl++ = txdr_unsigned(NFSLAYOUT_NFSV4_1_FILES);
4804 *tl++ = txdr_unsigned(iomode);
4805 txdr_hyper(offset, tl);
4806 tl += 2;
4807 txdr_hyper(len, tl);
4808 tl += 2;
4809 txdr_hyper(minlen, tl);
4810 tl += 2;
4811 *tl++ = txdr_unsigned(stateidp->seqid);
4812 NFSCL_DEBUG(4, "layget seq=%d\n", (int)stateidp->seqid);
4813 *tl++ = stateidp->other[0];
4814 *tl++ = stateidp->other[1];
4815 *tl++ = stateidp->other[2];
4816 *tl = txdr_unsigned(layoutlen);
4817 nd->nd_flag |= ND_USEGSSNAME;
4818 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
4819 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4820 if (error != 0)
4821 return (error);
4822 if (nd->nd_repstat == 0) {
4823 NFSM_DISSECT(tl, uint32_t *, 2 * NFSX_UNSIGNED + NFSX_STATEID);
4824 if (*tl++ != 0)
4825 *retonclosep = 1;
4826 else
4827 *retonclosep = 0;
4828 stateidp->seqid = fxdr_unsigned(uint32_t, *tl++);
4829 NFSCL_DEBUG(4, "retoncls=%d stseq=%d\n", *retonclosep,
4830 (int)stateidp->seqid);
4831 stateidp->other[0] = *tl++;
4832 stateidp->other[1] = *tl++;
4833 stateidp->other[2] = *tl++;
4834 cnt = fxdr_unsigned(int, *tl);
4835 NFSCL_DEBUG(4, "layg cnt=%d\n", cnt);
4836 if (cnt <= 0 || cnt > 10000) {
4837 /* Don't accept more than 10000 layouts in reply. */
4838 error = NFSERR_BADXDR;
4839 goto nfsmout;
4840 }
4841 for (i = 0; i < cnt; i++) {
4842 /* Dissect all the way to the file handle cnt. */
4843 NFSM_DISSECT(tl, uint32_t *, 3 * NFSX_HYPER +
4844 6 * NFSX_UNSIGNED + NFSX_V4DEVICEID);
4845 fhcnt = fxdr_unsigned(int, *(tl + 11 +
4846 NFSX_V4DEVICEID / NFSX_UNSIGNED));
4847 NFSCL_DEBUG(4, "fhcnt=%d\n", fhcnt);
4848 if (fhcnt < 0 || fhcnt > 100) {
4849 /* Don't accept more than 100 file handles. */
4850 error = NFSERR_BADXDR;
4851 goto nfsmout;
4852 }
4853 if (fhcnt > 1)
4854 flp = malloc(sizeof(*flp) + (fhcnt - 1) *
4855 sizeof(struct nfsfh *),
4856 M_NFSFLAYOUT, M_WAITOK);
4857 else
4858 flp = malloc(sizeof(*flp),
4859 M_NFSFLAYOUT, M_WAITOK);
4860 flp->nfsfl_flags = 0;
4861 flp->nfsfl_fhcnt = 0;
4862 flp->nfsfl_devp = NULL;
4863 flp->nfsfl_off = fxdr_hyper(tl); tl += 2;
4864 retlen = fxdr_hyper(tl); tl += 2;
4865 if (flp->nfsfl_off + retlen < flp->nfsfl_off)
4866 flp->nfsfl_end = UINT64_MAX - flp->nfsfl_off;
4867 else
4868 flp->nfsfl_end = flp->nfsfl_off + retlen;
4869 flp->nfsfl_iomode = fxdr_unsigned(int, *tl++);
4870 if (gotiomode == -1)
4871 gotiomode = flp->nfsfl_iomode;
4872 NFSCL_DEBUG(4, "layg reqiom=%d retiom=%d\n", iomode,
4873 (int)flp->nfsfl_iomode);
4874 if (fxdr_unsigned(int, *tl++) !=
4875 NFSLAYOUT_NFSV4_1_FILES) {
4876 printf("NFSv4.1: got non-files layout\n");
4877 error = NFSERR_BADXDR;
4878 goto nfsmout;
4879 }
4880 NFSBCOPY(++tl, flp->nfsfl_dev, NFSX_V4DEVICEID);
4881 tl += (NFSX_V4DEVICEID / NFSX_UNSIGNED);
4882 flp->nfsfl_util = fxdr_unsigned(uint32_t, *tl++);
4883 NFSCL_DEBUG(4, "flutil=0x%x\n", flp->nfsfl_util);
4884 flp->nfsfl_stripe1 = fxdr_unsigned(uint32_t, *tl++);
4885 flp->nfsfl_patoff = fxdr_hyper(tl); tl += 2;
4886 if (fxdr_unsigned(int, *tl) != fhcnt) {
4887 printf("EEK! bad fhcnt\n");
4888 error = NFSERR_BADXDR;
4889 goto nfsmout;
4890 }
4891 for (j = 0; j < fhcnt; j++) {
4892 NFSM_DISSECT(tl, uint32_t *, NFSX_UNSIGNED);
4893 nfhlen = fxdr_unsigned(int, *tl);
4894 if (nfhlen <= 0 || nfhlen > NFSX_V4FHMAX) {
4895 error = NFSERR_BADXDR;
4896 goto nfsmout;
4897 }
4898 nfhp = malloc(sizeof(*nfhp) + nfhlen - 1,
4899 M_NFSFH, M_WAITOK);
4900 flp->nfsfl_fh[j] = nfhp;
4901 flp->nfsfl_fhcnt++;
4902 nfhp->nfh_len = nfhlen;
4903 NFSM_DISSECT(cp, uint8_t *, NFSM_RNDUP(nfhlen));
4904 NFSBCOPY(cp, nfhp->nfh_fh, nfhlen);
4905 }
4906 if (flp->nfsfl_iomode == gotiomode) {
4907 /* Keep the list in increasing offset order. */
4908 tflp = LIST_FIRST(flhp);
4909 prevflp = NULL;
4910 while (tflp != NULL &&
4911 tflp->nfsfl_off < flp->nfsfl_off) {
4912 prevflp = tflp;
4913 tflp = LIST_NEXT(tflp, nfsfl_list);
4914 }
4915 if (prevflp == NULL)
4916 LIST_INSERT_HEAD(flhp, flp, nfsfl_list);
4917 else
4918 LIST_INSERT_AFTER(prevflp, flp,
4919 nfsfl_list);
4920 } else {
4921 printf("nfscl_layoutget(): got wrong iomode\n");
4922 nfscl_freeflayout(flp);
4923 }
4924 flp = NULL;
4925 }
4926 }
4927 if (nd->nd_repstat != 0 && error == 0)
4928 error = nd->nd_repstat;
4929 nfsmout:
4930 if (error != 0 && flp != NULL)
4931 nfscl_freeflayout(flp);
4932 mbuf_freem(nd->nd_mrep);
4933 return (error);
4934 }
4935
4936 /*
4937 * Do the NFSv4.1 Get Device Info.
4938 */
4939 int
4940 nfsrpc_getdeviceinfo(struct nfsmount *nmp, uint8_t *deviceid, int layouttype,
4941 uint32_t *notifybitsp, struct nfscldevinfo **ndip, struct ucred *cred,
4942 NFSPROC_T *p)
4943 {
4944 uint32_t cnt, *tl;
4945 struct nfsrv_descript nfsd;
4946 struct nfsrv_descript *nd = &nfsd;
4947 struct sockaddr_storage ss;
4948 struct nfsclds *dsp = NULL, **dspp;
4949 struct nfscldevinfo *ndi;
4950 int addrcnt, bitcnt, error, i, isudp, j, pos, safilled, stripecnt;
4951 uint8_t stripeindex;
4952
4953 *ndip = NULL;
4954 ndi = NULL;
4955 nfscl_reqstart(nd, NFSPROC_GETDEVICEINFO, nmp, NULL, 0, NULL, NULL);
4956 NFSM_BUILD(tl, uint32_t *, NFSX_V4DEVICEID + 3 * NFSX_UNSIGNED);
4957 NFSBCOPY(deviceid, tl, NFSX_V4DEVICEID);
4958 tl += (NFSX_V4DEVICEID / NFSX_UNSIGNED);
4959 *tl++ = txdr_unsigned(layouttype);
4960 *tl++ = txdr_unsigned(100000);
4961 if (notifybitsp != NULL && *notifybitsp != 0) {
4962 *tl = txdr_unsigned(1); /* One word of bits. */
4963 NFSM_BUILD(tl, uint32_t *, NFSX_UNSIGNED);
4964 *tl = txdr_unsigned(*notifybitsp);
4965 } else
4966 *tl = txdr_unsigned(0);
4967 nd->nd_flag |= ND_USEGSSNAME;
4968 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
4969 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
4970 if (error != 0)
4971 return (error);
4972 if (nd->nd_repstat == 0) {
4973 NFSM_DISSECT(tl, uint32_t *, 3 * NFSX_UNSIGNED);
4974 if (layouttype != fxdr_unsigned(int, *tl++))
4975 printf("EEK! devinfo layout type not same!\n");
4976 stripecnt = fxdr_unsigned(int, *++tl);
4977 NFSCL_DEBUG(4, "stripecnt=%d\n", stripecnt);
4978 if (stripecnt < 1 || stripecnt > 4096) {
4979 printf("NFS devinfo stripecnt %d: out of range\n",
4980 stripecnt);
4981 error = NFSERR_BADXDR;
4982 goto nfsmout;
4983 }
4984 NFSM_DISSECT(tl, uint32_t *, (stripecnt + 1) * NFSX_UNSIGNED);
4985 addrcnt = fxdr_unsigned(int, *(tl + stripecnt));
4986 NFSCL_DEBUG(4, "addrcnt=%d\n", addrcnt);
4987 if (addrcnt < 1 || addrcnt > 128) {
4988 printf("NFS devinfo addrcnt %d: out of range\n",
4989 addrcnt);
4990 error = NFSERR_BADXDR;
4991 goto nfsmout;
4992 }
4993
4994 /*
4995 * Now we know how many stripe indices and addresses, so
4996 * we can allocate the structure the correct size.
4997 */
4998 i = (stripecnt * sizeof(uint8_t)) / sizeof(struct nfsclds *)
4999 + 1;
5000 NFSCL_DEBUG(4, "stripeindices=%d\n", i);
5001 ndi = malloc(sizeof(*ndi) + (addrcnt + i) *
5002 sizeof(struct nfsclds *), M_NFSDEVINFO, M_WAITOK | M_ZERO);
5003 NFSBCOPY(deviceid, ndi->nfsdi_deviceid, NFSX_V4DEVICEID);
5004 ndi->nfsdi_refcnt = 0;
5005 ndi->nfsdi_stripecnt = stripecnt;
5006 ndi->nfsdi_addrcnt = addrcnt;
5007 /* Fill in the stripe indices. */
5008 for (i = 0; i < stripecnt; i++) {
5009 stripeindex = fxdr_unsigned(uint8_t, *tl++);
5010 NFSCL_DEBUG(4, "stripeind=%d\n", stripeindex);
5011 if (stripeindex >= addrcnt) {
5012 printf("NFS devinfo stripeindex %d: too big\n",
5013 (int)stripeindex);
5014 error = NFSERR_BADXDR;
5015 goto nfsmout;
5016 }
5017 nfsfldi_setstripeindex(ndi, i, stripeindex);
5018 }
5019
5020 /* Now, dissect the server address(es). */
5021 safilled = 0;
5022 for (i = 0; i < addrcnt; i++) {
5023 NFSM_DISSECT(tl, uint32_t *, NFSX_UNSIGNED);
5024 cnt = fxdr_unsigned(uint32_t, *tl);
5025 if (cnt == 0) {
5026 printf("NFS devinfo 0 len addrlist\n");
5027 error = NFSERR_BADXDR;
5028 goto nfsmout;
5029 }
5030 dspp = nfsfldi_addr(ndi, i);
5031 pos = arc4random() % cnt; /* Choose one. */
5032 safilled = 0;
5033 for (j = 0; j < cnt; j++) {
5034 error = nfsv4_getipaddr(nd, &ss, &isudp);
5035 if (error != 0 && error != EPERM) {
5036 error = NFSERR_BADXDR;
5037 goto nfsmout;
5038 }
5039 if (error == 0 && isudp == 0) {
5040 /*
5041 * The algorithm is:
5042 * - use "pos" entry if it is of the
5043 * same af_family or none of them
5044 * is of the same af_family
5045 * else
5046 * - use the first one of the same
5047 * af_family.
5048 */
5049 if ((safilled == 0 && ss.ss_family ==
5050 nmp->nm_nam->sa_family) ||
5051 (j == pos &&
5052 (safilled == 0 || ss.ss_family ==
5053 nmp->nm_nam->sa_family)) ||
5054 (safilled == 1 && ss.ss_family ==
5055 nmp->nm_nam->sa_family)) {
5056 error = nfsrpc_fillsa(nmp, &ss,
5057 &dsp, p);
5058 if (error == 0) {
5059 *dspp = dsp;
5060 if (ss.ss_family ==
5061 nmp->nm_nam->sa_family)
5062 safilled = 2;
5063 else
5064 safilled = 1;
5065 }
5066 }
5067 }
5068 }
5069 if (safilled == 0)
5070 break;
5071 }
5072
5073 /* And the notify bits. */
5074 NFSM_DISSECT(tl, uint32_t *, NFSX_UNSIGNED);
5075 if (safilled != 0) {
5076 bitcnt = fxdr_unsigned(int, *tl);
5077 if (bitcnt > 0) {
5078 NFSM_DISSECT(tl, uint32_t *, NFSX_UNSIGNED);
5079 if (notifybitsp != NULL)
5080 *notifybitsp =
5081 fxdr_unsigned(uint32_t, *tl);
5082 }
5083 *ndip = ndi;
5084 } else
5085 error = EPERM;
5086 }
5087 if (nd->nd_repstat != 0)
5088 error = nd->nd_repstat;
5089 nfsmout:
5090 if (error != 0 && ndi != NULL)
5091 nfscl_freedevinfo(ndi);
5092 mbuf_freem(nd->nd_mrep);
5093 return (error);
5094 }
5095
5096 /*
5097 * Do the NFSv4.1 LayoutCommit.
5098 */
5099 int
5100 nfsrpc_layoutcommit(struct nfsmount *nmp, uint8_t *fh, int fhlen, int reclaim,
5101 uint64_t off, uint64_t len, uint64_t lastbyte, nfsv4stateid_t *stateidp,
5102 int layouttype, int layoutupdatecnt, uint8_t *layp, struct ucred *cred,
5103 NFSPROC_T *p, void *stuff)
5104 {
5105 uint32_t *tl;
5106 struct nfsrv_descript nfsd, *nd = &nfsd;
5107 int error, outcnt, i;
5108 uint8_t *cp;
5109
5110 nfscl_reqstart(nd, NFSPROC_LAYOUTCOMMIT, nmp, fh, fhlen, NULL, NULL);
5111 NFSM_BUILD(tl, uint32_t *, 5 * NFSX_UNSIGNED + 3 * NFSX_HYPER +
5112 NFSX_STATEID);
5113 txdr_hyper(off, tl);
5114 tl += 2;
5115 txdr_hyper(len, tl);
5116 tl += 2;
5117 if (reclaim != 0)
5118 *tl++ = newnfs_true;
5119 else
5120 *tl++ = newnfs_false;
5121 *tl++ = txdr_unsigned(stateidp->seqid);
5122 *tl++ = stateidp->other[0];
5123 *tl++ = stateidp->other[1];
5124 *tl++ = stateidp->other[2];
5125 *tl++ = newnfs_true;
5126 if (lastbyte < off)
5127 lastbyte = off;
5128 else if (lastbyte >= (off + len))
5129 lastbyte = off + len - 1;
5130 txdr_hyper(lastbyte, tl);
5131 tl += 2;
5132 *tl++ = newnfs_false;
5133 *tl++ = txdr_unsigned(layouttype);
5134 *tl = txdr_unsigned(layoutupdatecnt);
5135 if (layoutupdatecnt > 0) {
5136 KASSERT(layouttype != NFSLAYOUT_NFSV4_1_FILES,
5137 ("Must be nil for Files Layout"));
5138 outcnt = NFSM_RNDUP(layoutupdatecnt);
5139 NFSM_BUILD(cp, uint8_t *, outcnt);
5140 NFSBCOPY(layp, cp, layoutupdatecnt);
5141 cp += layoutupdatecnt;
5142 for (i = 0; i < (outcnt - layoutupdatecnt); i++)
5143 *cp++ = 0x0;
5144 }
5145 nd->nd_flag |= ND_USEGSSNAME;
5146 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
5147 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
5148 if (error != 0)
5149 return (error);
5150 error = nd->nd_repstat;
5151 mbuf_freem(nd->nd_mrep);
5152 return (error);
5153 }
5154
5155 /*
5156 * Do the NFSv4.1 LayoutReturn.
5157 */
5158 int
5159 nfsrpc_layoutreturn(struct nfsmount *nmp, uint8_t *fh, int fhlen, int reclaim,
5160 int layouttype, uint32_t iomode, int layoutreturn, uint64_t offset,
5161 uint64_t len, nfsv4stateid_t *stateidp, int layoutcnt, uint32_t *layp,
5162 struct ucred *cred, NFSPROC_T *p, void *stuff)
5163 {
5164 uint32_t *tl;
5165 struct nfsrv_descript nfsd, *nd = &nfsd;
5166 int error, outcnt, i;
5167 uint8_t *cp;
5168
5169 nfscl_reqstart(nd, NFSPROC_LAYOUTRETURN, nmp, fh, fhlen, NULL, NULL);
5170 NFSM_BUILD(tl, uint32_t *, 4 * NFSX_UNSIGNED);
5171 if (reclaim != 0)
5172 *tl++ = newnfs_true;
5173 else
5174 *tl++ = newnfs_false;
5175 *tl++ = txdr_unsigned(layouttype);
5176 *tl++ = txdr_unsigned(iomode);
5177 *tl = txdr_unsigned(layoutreturn);
5178 if (layoutreturn == NFSLAYOUTRETURN_FILE) {
5179 NFSM_BUILD(tl, uint32_t *, 2 * NFSX_HYPER + NFSX_STATEID +
5180 NFSX_UNSIGNED);
5181 txdr_hyper(offset, tl);
5182 tl += 2;
5183 txdr_hyper(len, tl);
5184 tl += 2;
5185 NFSCL_DEBUG(4, "layoutret stseq=%d\n", (int)stateidp->seqid);
5186 *tl++ = txdr_unsigned(stateidp->seqid);
5187 *tl++ = stateidp->other[0];
5188 *tl++ = stateidp->other[1];
5189 *tl++ = stateidp->other[2];
5190 *tl = txdr_unsigned(layoutcnt);
5191 if (layoutcnt > 0) {
5192 outcnt = NFSM_RNDUP(layoutcnt);
5193 NFSM_BUILD(cp, uint8_t *, outcnt);
5194 NFSBCOPY(layp, cp, layoutcnt);
5195 cp += layoutcnt;
5196 for (i = 0; i < (outcnt - layoutcnt); i++)
5197 *cp++ = 0x0;
5198 }
5199 }
5200 nd->nd_flag |= ND_USEGSSNAME;
5201 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
5202 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
5203 if (error != 0)
5204 return (error);
5205 if (nd->nd_repstat == 0) {
5206 NFSM_DISSECT(tl, uint32_t *, NFSX_UNSIGNED);
5207 if (*tl != 0) {
5208 NFSM_DISSECT(tl, uint32_t *, NFSX_STATEID);
5209 stateidp->seqid = fxdr_unsigned(uint32_t, *tl++);
5210 stateidp->other[0] = *tl++;
5211 stateidp->other[1] = *tl++;
5212 stateidp->other[2] = *tl;
5213 }
5214 } else
5215 error = nd->nd_repstat;
5216 nfsmout:
5217 mbuf_freem(nd->nd_mrep);
5218 return (error);
5219 }
5220
5221 /*
5222 * Acquire a layout and devinfo, if possible. The caller must have acquired
5223 * a reference count on the nfsclclient structure before calling this.
5224 * Return the layout in lypp with a reference count on it, if successful.
5225 */
5226 static int
5227 nfsrpc_getlayout(struct nfsmount *nmp, vnode_t vp, struct nfsfh *nfhp,
5228 int iomode, uint32_t *notifybitsp, nfsv4stateid_t *stateidp, uint64_t off,
5229 struct nfscllayout **lypp, struct ucred *cred, NFSPROC_T *p)
5230 {
5231 struct nfscllayout *lyp;
5232 struct nfsclflayout *flp, *tflp;
5233 struct nfscldevinfo *dip;
5234 struct nfsclflayouthead flh;
5235 int error = 0, islocked, layoutlen, recalled, retonclose;
5236 nfsv4stateid_t stateid;
5237 struct nfsclsession *tsep;
5238
5239 *lypp = NULL;
5240 /*
5241 * If lyp is returned non-NULL, there will be a refcnt (shared lock)
5242 * on it, iff flp != NULL or a lock (exclusive lock) on it iff
5243 * flp == NULL.
5244 */
5245 lyp = nfscl_getlayout(nmp->nm_clp, nfhp->nfh_fh, nfhp->nfh_len,
5246 off, &flp, &recalled);
5247 islocked = 0;
5248 if (lyp == NULL || flp == NULL) {
5249 if (recalled != 0)
5250 return (EIO);
5251 LIST_INIT(&flh);
5252 tsep = nfsmnt_mdssession(nmp);
5253 layoutlen = tsep->nfsess_maxcache -
5254 (NFSX_STATEID + 3 * NFSX_UNSIGNED);
5255 if (lyp == NULL) {
5256 stateid.seqid = 0;
5257 stateid.other[0] = stateidp->other[0];
5258 stateid.other[1] = stateidp->other[1];
5259 stateid.other[2] = stateidp->other[2];
5260 error = nfsrpc_layoutget(nmp, nfhp->nfh_fh,
5261 nfhp->nfh_len, iomode, (uint64_t)0, UINT64_MAX,
5262 (uint64_t)0, layoutlen, &stateid, &retonclose,
5263 &flh, cred, p, NULL);
5264 } else {
5265 islocked = 1;
5266 stateid.seqid = lyp->nfsly_stateid.seqid;
5267 stateid.other[0] = lyp->nfsly_stateid.other[0];
5268 stateid.other[1] = lyp->nfsly_stateid.other[1];
5269 stateid.other[2] = lyp->nfsly_stateid.other[2];
5270 error = nfsrpc_layoutget(nmp, nfhp->nfh_fh,
5271 nfhp->nfh_len, iomode, off, UINT64_MAX,
5272 (uint64_t)0, layoutlen, &stateid, &retonclose,
5273 &flh, cred, p, NULL);
5274 }
5275 if (error == 0)
5276 LIST_FOREACH(tflp, &flh, nfsfl_list) {
5277 error = nfscl_adddevinfo(nmp, NULL, tflp);
5278 if (error != 0) {
5279 error = nfsrpc_getdeviceinfo(nmp,
5280 tflp->nfsfl_dev,
5281 NFSLAYOUT_NFSV4_1_FILES,
5282 notifybitsp, &dip, cred, p);
5283 if (error != 0)
5284 break;
5285 error = nfscl_adddevinfo(nmp, dip,
5286 tflp);
5287 if (error != 0)
5288 printf(
5289 "getlayout: cannot add\n");
5290 }
5291 }
5292 if (error == 0) {
5293 /*
5294 * nfscl_layout() always returns with the nfsly_lock
5295 * set to a refcnt (shared lock).
5296 */
5297 error = nfscl_layout(nmp, vp, nfhp->nfh_fh,
5298 nfhp->nfh_len, &stateid, retonclose, &flh, &lyp,
5299 cred, p);
5300 if (error == 0)
5301 *lypp = lyp;
5302 } else if (islocked != 0)
5303 nfsv4_unlock(&lyp->nfsly_lock, 0);
5304 } else
5305 *lypp = lyp;
5306 return (error);
5307 }
5308
5309 /*
5310 * Do a TCP connection plus exchange id and create session.
5311 * If successful, a "struct nfsclds" is linked into the list for the
5312 * mount point and a pointer to it is returned.
5313 */
5314 static int
5315 nfsrpc_fillsa(struct nfsmount *nmp, struct sockaddr_storage *ssp,
5316 struct nfsclds **dspp, NFSPROC_T *p)
5317 {
5318 struct sockaddr_in *msad, *sad, *ssd;
5319 struct sockaddr_in6 *msad6, *sad6, *ssd6;
5320 struct nfsclclient *clp;
5321 struct nfssockreq *nrp;
5322 struct nfsclds *dsp, *tdsp;
5323 int error;
5324 enum nfsclds_state retv;
5325 uint32_t sequenceid;
5326
5327 KASSERT(nmp->nm_sockreq.nr_cred != NULL,
5328 ("nfsrpc_fillsa: NULL nr_cred"));
5329 NFSLOCKCLSTATE();
5330 clp = nmp->nm_clp;
5331 NFSUNLOCKCLSTATE();
5332 if (clp == NULL)
5333 return (EPERM);
5334 if (ssp->ss_family == AF_INET) {
5335 ssd = (struct sockaddr_in *)ssp;
5336 NFSLOCKMNT(nmp);
5337
5338 /*
5339 * Check to see if we already have a session for this
5340 * address that is usable for a DS.
5341 * Note that the MDS's address is in a different place
5342 * than the sessions already acquired for DS's.
5343 */
5344 msad = (struct sockaddr_in *)nmp->nm_sockreq.nr_nam;
5345 tdsp = TAILQ_FIRST(&nmp->nm_sess);
5346 while (tdsp != NULL) {
5347 if (msad != NULL && msad->sin_family == AF_INET &&
5348 ssd->sin_addr.s_addr == msad->sin_addr.s_addr &&
5349 ssd->sin_port == msad->sin_port &&
5350 (tdsp->nfsclds_flags & NFSCLDS_DS) != 0 &&
5351 tdsp->nfsclds_sess.nfsess_defunct == 0) {
5352 *dspp = tdsp;
5353 NFSUNLOCKMNT(nmp);
5354 NFSCL_DEBUG(4, "fnd same addr\n");
5355 return (0);
5356 }
5357 tdsp = TAILQ_NEXT(tdsp, nfsclds_list);
5358 if (tdsp != NULL && tdsp->nfsclds_sockp != NULL)
5359 msad = (struct sockaddr_in *)
5360 tdsp->nfsclds_sockp->nr_nam;
5361 else
5362 msad = NULL;
5363 }
5364 NFSUNLOCKMNT(nmp);
5365
5366 /* No IP address match, so look for new/trunked one. */
5367 sad = malloc(sizeof(*sad), M_SONAME, M_WAITOK | M_ZERO);
5368 sad->sin_len = sizeof(*sad);
5369 sad->sin_family = AF_INET;
5370 sad->sin_port = ssd->sin_port;
5371 sad->sin_addr.s_addr = ssd->sin_addr.s_addr;
5372 nrp = malloc(sizeof(*nrp), M_NFSSOCKREQ, M_WAITOK | M_ZERO);
5373 nrp->nr_nam = (struct sockaddr *)sad;
5374 } else if (ssp->ss_family == AF_INET6) {
5375 ssd6 = (struct sockaddr_in6 *)ssp;
5376 NFSLOCKMNT(nmp);
5377
5378 /*
5379 * Check to see if we already have a session for this
5380 * address that is usable for a DS.
5381 * Note that the MDS's address is in a different place
5382 * than the sessions already acquired for DS's.
5383 */
5384 msad6 = (struct sockaddr_in6 *)nmp->nm_sockreq.nr_nam;
5385 tdsp = TAILQ_FIRST(&nmp->nm_sess);
5386 while (tdsp != NULL) {
5387 if (msad6 != NULL && msad6->sin6_family == AF_INET6 &&
5388 IN6_ARE_ADDR_EQUAL(&ssd6->sin6_addr,
5389 &msad6->sin6_addr) &&
5390 ssd6->sin6_port == msad6->sin6_port &&
5391 (tdsp->nfsclds_flags & NFSCLDS_DS) != 0 &&
5392 tdsp->nfsclds_sess.nfsess_defunct == 0) {
5393 *dspp = tdsp;
5394 NFSUNLOCKMNT(nmp);
5395 return (0);
5396 }
5397 tdsp = TAILQ_NEXT(tdsp, nfsclds_list);
5398 if (tdsp != NULL && tdsp->nfsclds_sockp != NULL)
5399 msad6 = (struct sockaddr_in6 *)
5400 tdsp->nfsclds_sockp->nr_nam;
5401 else
5402 msad6 = NULL;
5403 }
5404 NFSUNLOCKMNT(nmp);
5405
5406 /* No IP address match, so look for new/trunked one. */
5407 sad6 = malloc(sizeof(*sad6), M_SONAME, M_WAITOK | M_ZERO);
5408 sad6->sin6_len = sizeof(*sad6);
5409 sad6->sin6_family = AF_INET6;
5410 sad6->sin6_port = ssd6->sin6_port;
5411 NFSBCOPY(&ssd6->sin6_addr, &sad6->sin6_addr,
5412 sizeof(struct in6_addr));
5413 nrp = malloc(sizeof(*nrp), M_NFSSOCKREQ, M_WAITOK | M_ZERO);
5414 nrp->nr_nam = (struct sockaddr *)sad6;
5415 } else
5416 return (EPERM);
5417
5418 nrp->nr_sotype = SOCK_STREAM;
5419 mtx_init(&nrp->nr_mtx, "nfssock", NULL, MTX_DEF);
5420 nrp->nr_prog = NFS_PROG;
5421 nrp->nr_vers = NFS_VER4;
5422
5423 /*
5424 * Use the credentials that were used for the mount, which are
5425 * in nmp->nm_sockreq.nr_cred for newnfs_connect() etc.
5426 * Ref. counting the credentials with crhold() is probably not
5427 * necessary, since nm_sockreq.nr_cred won't be crfree()'d until
5428 * unmount, but I did it anyhow.
5429 */
5430 nrp->nr_cred = crhold(nmp->nm_sockreq.nr_cred);
5431 error = newnfs_connect(nmp, nrp, NULL, p, 0);
5432 NFSCL_DEBUG(3, "DS connect=%d\n", error);
5433
5434 /* Now, do the exchangeid and create session. */
5435 if (error == 0) {
5436 error = nfsrpc_exchangeid(nmp, clp, nrp, NFSV4EXCH_USEPNFSDS,
5437 &dsp, nrp->nr_cred, p);
5438 NFSCL_DEBUG(3, "DS exchangeid=%d\n", error);
5439 if (error != 0)
5440 newnfs_disconnect(nrp);
5441 }
5442 if (error == 0) {
5443 dsp->nfsclds_sockp = nrp;
5444 NFSLOCKMNT(nmp);
5445 retv = nfscl_getsameserver(nmp, dsp, &tdsp);
5446 NFSCL_DEBUG(3, "getsame ret=%d\n", retv);
5447 if (retv == NFSDSP_USETHISSESSION) {
5448 NFSUNLOCKMNT(nmp);
5449 /*
5450 * If there is already a session for this server,
5451 * use it.
5452 */
5453 (void)newnfs_disconnect(nrp);
5454 nfscl_freenfsclds(dsp);
5455 *dspp = tdsp;
5456 return (0);
5457 }
5458 if (retv == NFSDSP_SEQTHISSESSION)
5459 sequenceid = tdsp->nfsclds_sess.nfsess_sequenceid;
5460 else
5461 sequenceid = dsp->nfsclds_sess.nfsess_sequenceid;
5462 NFSUNLOCKMNT(nmp);
5463 error = nfsrpc_createsession(nmp, &dsp->nfsclds_sess,
5464 nrp, sequenceid, 0, nrp->nr_cred, p);
5465 NFSCL_DEBUG(3, "DS createsess=%d\n", error);
5466 } else {
5467 NFSFREECRED(nrp->nr_cred);
5468 NFSFREEMUTEX(&nrp->nr_mtx);
5469 free(nrp->nr_nam, M_SONAME);
5470 free(nrp, M_NFSSOCKREQ);
5471 }
5472 if (error == 0) {
5473 NFSCL_DEBUG(3, "add DS session\n");
5474 /*
5475 * Put it at the end of the list. That way the list
5476 * is ordered by when the entry was added. This matters
5477 * since the one done first is the one that should be
5478 * used for sequencid'ing any subsequent create sessions.
5479 */
5480 NFSLOCKMNT(nmp);
5481 TAILQ_INSERT_TAIL(&nmp->nm_sess, dsp, nfsclds_list);
5482 NFSUNLOCKMNT(nmp);
5483 *dspp = dsp;
5484 } else if (dsp != NULL) {
5485 newnfs_disconnect(nrp);
5486 nfscl_freenfsclds(dsp);
5487 }
5488 return (error);
5489 }
5490
5491 /*
5492 * Do the NFSv4.1 Reclaim Complete.
5493 */
5494 int
5495 nfsrpc_reclaimcomplete(struct nfsmount *nmp, struct ucred *cred, NFSPROC_T *p)
5496 {
5497 uint32_t *tl;
5498 struct nfsrv_descript nfsd;
5499 struct nfsrv_descript *nd = &nfsd;
5500 int error;
5501
5502 nfscl_reqstart(nd, NFSPROC_RECLAIMCOMPL, nmp, NULL, 0, NULL, NULL);
5503 NFSM_BUILD(tl, uint32_t *, NFSX_UNSIGNED);
5504 *tl = newnfs_false;
5505 nd->nd_flag |= ND_USEGSSNAME;
5506 error = newnfs_request(nd, nmp, NULL, &nmp->nm_sockreq, NULL, p, cred,
5507 NFS_PROG, NFS_VER4, NULL, 1, NULL, NULL);
5508 if (error != 0)
5509 return (error);
5510 error = nd->nd_repstat;
5511 mbuf_freem(nd->nd_mrep);
5512 return (error);
5513 }
5514
5515 /*
5516 * Initialize the slot tables for a session.
5517 */
5518 static void
5519 nfscl_initsessionslots(struct nfsclsession *sep)
5520 {
5521 int i;
5522
5523 for (i = 0; i < NFSV4_CBSLOTS; i++) {
5524 if (sep->nfsess_cbslots[i].nfssl_reply != NULL)
5525 m_freem(sep->nfsess_cbslots[i].nfssl_reply);
5526 NFSBZERO(&sep->nfsess_cbslots[i], sizeof(struct nfsslot));
5527 }
5528 for (i = 0; i < 64; i++)
5529 sep->nfsess_slotseq[i] = 0;
5530 sep->nfsess_slots = 0;
5531 }
5532
5533 /*
5534 * Called to try and do an I/O operation via an NFSv4.1 Data Server (DS).
5535 */
5536 int
5537 nfscl_doiods(vnode_t vp, struct uio *uiop, int *iomode, int *must_commit,
5538 uint32_t rwaccess, int docommit, struct ucred *cred, NFSPROC_T *p)
5539 {
5540 struct nfsnode *np = VTONFS(vp);
5541 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
5542 struct nfscllayout *layp;
5543 struct nfscldevinfo *dip;
5544 struct nfsclflayout *rflp;
5545 nfsv4stateid_t stateid;
5546 struct ucred *newcred;
5547 uint64_t lastbyte, len, off, oresid, xfer;
5548 int eof, error, iolaymode, recalled;
5549 void *lckp;
5550
5551 if (!NFSHASPNFS(nmp) || nfscl_enablecallb == 0 || nfs_numnfscbd == 0 ||
5552 (np->n_flag & NNOLAYOUT) != 0)
5553 return (EIO);
5554 /* Now, get a reference cnt on the clientid for this mount. */
5555 if (nfscl_getref(nmp) == 0)
5556 return (EIO);
5557
5558 /* Find an appropriate stateid. */
5559 newcred = NFSNEWCRED(cred);
5560 error = nfscl_getstateid(vp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len,
5561 rwaccess, 1, newcred, p, &stateid, &lckp);
5562 if (error != 0) {
5563 NFSFREECRED(newcred);
5564 nfscl_relref(nmp);
5565 return (error);
5566 }
5567 /* Search for a layout for this file. */
5568 off = uiop->uio_offset;
5569 layp = nfscl_getlayout(nmp->nm_clp, np->n_fhp->nfh_fh,
5570 np->n_fhp->nfh_len, off, &rflp, &recalled);
5571 if (layp == NULL || rflp == NULL) {
5572 if (recalled != 0) {
5573 NFSFREECRED(newcred);
5574 nfscl_relref(nmp);
5575 return (EIO);
5576 }
5577 if (layp != NULL) {
5578 nfscl_rellayout(layp, (rflp == NULL) ? 1 : 0);
5579 layp = NULL;
5580 }
5581 /* Try and get a Layout, if it is supported. */
5582 if (rwaccess == NFSV4OPEN_ACCESSWRITE ||
5583 (np->n_flag & NWRITEOPENED) != 0)
5584 iolaymode = NFSLAYOUTIOMODE_RW;
5585 else
5586 iolaymode = NFSLAYOUTIOMODE_READ;
5587 error = nfsrpc_getlayout(nmp, vp, np->n_fhp, iolaymode,
5588 NULL, &stateid, off, &layp, newcred, p);
5589 if (error != 0) {
5590 NFSLOCKNODE(np);
5591 np->n_flag |= NNOLAYOUT;
5592 NFSUNLOCKNODE(np);
5593 if (lckp != NULL)
5594 nfscl_lockderef(lckp);
5595 NFSFREECRED(newcred);
5596 if (layp != NULL)
5597 nfscl_rellayout(layp, 0);
5598 nfscl_relref(nmp);
5599 return (error);
5600 }
5601 }
5602
5603 /*
5604 * Loop around finding a layout that works for the first part of
5605 * this I/O operation, and then call the function that actually
5606 * does the RPC.
5607 */
5608 eof = 0;
5609 len = (uint64_t)uiop->uio_resid;
5610 while (len > 0 && error == 0 && eof == 0) {
5611 off = uiop->uio_offset;
5612 error = nfscl_findlayoutforio(layp, off, rwaccess, &rflp);
5613 if (error == 0) {
5614 oresid = xfer = (uint64_t)uiop->uio_resid;
5615 if (xfer > (rflp->nfsfl_end - rflp->nfsfl_off))
5616 xfer = rflp->nfsfl_end - rflp->nfsfl_off;
5617 dip = nfscl_getdevinfo(nmp->nm_clp, rflp->nfsfl_dev,
5618 rflp->nfsfl_devp);
5619 if (dip != NULL) {
5620 error = nfscl_doflayoutio(vp, uiop, iomode,
5621 must_commit, &eof, &stateid, rwaccess, dip,
5622 layp, rflp, off, xfer, docommit, newcred,
5623 p);
5624 nfscl_reldevinfo(dip);
5625 lastbyte = off + xfer - 1;
5626 if (error == 0) {
5627 NFSLOCKCLSTATE();
5628 if (lastbyte > layp->nfsly_lastbyte)
5629 layp->nfsly_lastbyte = lastbyte;
5630 NFSUNLOCKCLSTATE();
5631 } else if (error == NFSERR_OPENMODE &&
5632 rwaccess == NFSV4OPEN_ACCESSREAD) {
5633 NFSLOCKMNT(nmp);
5634 nmp->nm_state |= NFSSTA_OPENMODE;
5635 NFSUNLOCKMNT(nmp);
5636 }
5637 } else
5638 error = EIO;
5639 if (error == 0)
5640 len -= (oresid - (uint64_t)uiop->uio_resid);
5641 }
5642 }
5643 if (lckp != NULL)
5644 nfscl_lockderef(lckp);
5645 NFSFREECRED(newcred);
5646 nfscl_rellayout(layp, 0);
5647 nfscl_relref(nmp);
5648 return (error);
5649 }
5650
5651 /*
5652 * Find a file layout that will handle the first bytes of the requested
5653 * range and return the information from it needed to to the I/O operation.
5654 */
5655 int
5656 nfscl_findlayoutforio(struct nfscllayout *lyp, uint64_t off, uint32_t rwaccess,
5657 struct nfsclflayout **retflpp)
5658 {
5659 struct nfsclflayout *flp, *nflp, *rflp;
5660 uint32_t rw;
5661
5662 rflp = NULL;
5663 rw = rwaccess;
5664 /* For reading, do the Read list first and then the Write list. */
5665 do {
5666 if (rw == NFSV4OPEN_ACCESSREAD)
5667 flp = LIST_FIRST(&lyp->nfsly_flayread);
5668 else
5669 flp = LIST_FIRST(&lyp->nfsly_flayrw);
5670 while (flp != NULL) {
5671 nflp = LIST_NEXT(flp, nfsfl_list);
5672 if (flp->nfsfl_off > off)
5673 break;
5674 if (flp->nfsfl_end > off &&
5675 (rflp == NULL || rflp->nfsfl_end < flp->nfsfl_end))
5676 rflp = flp;
5677 flp = nflp;
5678 }
5679 if (rw == NFSV4OPEN_ACCESSREAD)
5680 rw = NFSV4OPEN_ACCESSWRITE;
5681 else
5682 rw = 0;
5683 } while (rw != 0);
5684 if (rflp != NULL) {
5685 /* This one covers the most bytes starting at off. */
5686 *retflpp = rflp;
5687 return (0);
5688 }
5689 return (EIO);
5690 }
5691
5692 /*
5693 * Do I/O using an NFSv4.1 file layout.
5694 */
5695 static int
5696 nfscl_doflayoutio(vnode_t vp, struct uio *uiop, int *iomode, int *must_commit,
5697 int *eofp, nfsv4stateid_t *stateidp, int rwflag, struct nfscldevinfo *dp,
5698 struct nfscllayout *lyp, struct nfsclflayout *flp, uint64_t off,
5699 uint64_t len, int docommit, struct ucred *cred, NFSPROC_T *p)
5700 {
5701 uint64_t io_off, rel_off, stripe_unit_size, transfer, xfer;
5702 int commit_thru_mds, error, stripe_index, stripe_pos;
5703 struct nfsnode *np;
5704 struct nfsfh *fhp;
5705 struct nfsclds **dspp;
5706
5707 np = VTONFS(vp);
5708 rel_off = off - flp->nfsfl_patoff;
5709 stripe_unit_size = (flp->nfsfl_util >> 6) & 0x3ffffff;
5710 stripe_pos = (rel_off / stripe_unit_size + flp->nfsfl_stripe1) %
5711 dp->nfsdi_stripecnt;
5712 transfer = stripe_unit_size - (rel_off % stripe_unit_size);
5713 error = 0;
5714
5715 /* Loop around, doing I/O for each stripe unit. */
5716 while (len > 0 && error == 0) {
5717 stripe_index = nfsfldi_stripeindex(dp, stripe_pos);
5718 dspp = nfsfldi_addr(dp, stripe_index);
5719 if (len > transfer && docommit == 0)
5720 xfer = transfer;
5721 else
5722 xfer = len;
5723 if ((flp->nfsfl_util & NFSFLAYUTIL_DENSE) != 0) {
5724 /* Dense layout. */
5725 if (stripe_pos >= flp->nfsfl_fhcnt)
5726 return (EIO);
5727 fhp = flp->nfsfl_fh[stripe_pos];
5728 io_off = (rel_off / (stripe_unit_size *
5729 dp->nfsdi_stripecnt)) * stripe_unit_size +
5730 rel_off % stripe_unit_size;
5731 } else {
5732 /* Sparse layout. */
5733 if (flp->nfsfl_fhcnt > 1) {
5734 if (stripe_index >= flp->nfsfl_fhcnt)
5735 return (EIO);
5736 fhp = flp->nfsfl_fh[stripe_index];
5737 } else if (flp->nfsfl_fhcnt == 1)
5738 fhp = flp->nfsfl_fh[0];
5739 else
5740 fhp = np->n_fhp;
5741 io_off = off;
5742 }
5743 if ((flp->nfsfl_util & NFSFLAYUTIL_COMMIT_THRU_MDS) != 0) {
5744 commit_thru_mds = 1;
5745 if (docommit != 0)
5746 error = EIO;
5747 } else {
5748 commit_thru_mds = 0;
5749 mtx_lock(&np->n_mtx);
5750 np->n_flag |= NDSCOMMIT;
5751 mtx_unlock(&np->n_mtx);
5752 }
5753 if (docommit != 0) {
5754 if (error == 0)
5755 error = nfsrpc_commitds(vp, io_off, xfer,
5756 *dspp, fhp, cred, p);
5757 if (error == 0) {
5758 /*
5759 * Set both eof and uio_resid = 0 to end any
5760 * loops.
5761 */
5762 *eofp = 1;
5763 uiop->uio_resid = 0;
5764 } else {
5765 mtx_lock(&np->n_mtx);
5766 np->n_flag &= ~NDSCOMMIT;
5767 mtx_unlock(&np->n_mtx);
5768 }
5769 } else if (rwflag == FREAD)
5770 error = nfsrpc_readds(vp, uiop, stateidp, eofp, *dspp,
5771 io_off, xfer, fhp, cred, p);
5772 else {
5773 error = nfsrpc_writeds(vp, uiop, iomode, must_commit,
5774 stateidp, *dspp, io_off, xfer, fhp, commit_thru_mds,
5775 cred, p);
5776 if (error == 0) {
5777 NFSLOCKCLSTATE();
5778 lyp->nfsly_flags |= NFSLY_WRITTEN;
5779 NFSUNLOCKCLSTATE();
5780 }
5781 }
5782 if (error == 0) {
5783 transfer = stripe_unit_size;
5784 stripe_pos = (stripe_pos + 1) % dp->nfsdi_stripecnt;
5785 len -= xfer;
5786 off += xfer;
5787 }
5788 }
5789 return (error);
5790 }
5791
5792 /*
5793 * The actual read RPC done to a DS.
5794 */
5795 static int
5796 nfsrpc_readds(vnode_t vp, struct uio *uiop, nfsv4stateid_t *stateidp, int *eofp,
5797 struct nfsclds *dsp, uint64_t io_off, int len, struct nfsfh *fhp,
5798 struct ucred *cred, NFSPROC_T *p)
5799 {
5800 uint32_t *tl;
5801 int error, retlen;
5802 struct nfsrv_descript nfsd;
5803 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
5804 struct nfsrv_descript *nd = &nfsd;
5805 struct nfssockreq *nrp;
5806
5807 nd->nd_mrep = NULL;
5808 nfscl_reqstart(nd, NFSPROC_READDS, nmp, fhp->nfh_fh, fhp->nfh_len,
5809 NULL, &dsp->nfsclds_sess);
5810 nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSEQIDZERO);
5811 NFSM_BUILD(tl, uint32_t *, NFSX_UNSIGNED * 3);
5812 txdr_hyper(io_off, tl);
5813 *(tl + 2) = txdr_unsigned(len);
5814 nrp = dsp->nfsclds_sockp;
5815 if (nrp == NULL)
5816 /* If NULL, use the MDS socket. */
5817 nrp = &nmp->nm_sockreq;
5818 error = newnfs_request(nd, nmp, NULL, nrp, vp, p, cred,
5819 NFS_PROG, NFS_VER4, NULL, 1, NULL, &dsp->nfsclds_sess);
5820 if (error != 0)
5821 return (error);
5822 if (nd->nd_repstat != 0) {
5823 error = nd->nd_repstat;
5824 goto nfsmout;
5825 }
5826 NFSM_DISSECT(tl, uint32_t *, NFSX_UNSIGNED);
5827 *eofp = fxdr_unsigned(int, *tl);
5828 NFSM_STRSIZ(retlen, len);
5829 error = nfsm_mbufuio(nd, uiop, retlen);
5830 nfsmout:
5831 if (nd->nd_mrep != NULL)
5832 mbuf_freem(nd->nd_mrep);
5833 return (error);
5834 }
5835
5836 /*
5837 * The actual write RPC done to a DS.
5838 */
5839 static int
5840 nfsrpc_writeds(vnode_t vp, struct uio *uiop, int *iomode, int *must_commit,
5841 nfsv4stateid_t *stateidp, struct nfsclds *dsp, uint64_t io_off, int len,
5842 struct nfsfh *fhp, int commit_thru_mds, struct ucred *cred, NFSPROC_T *p)
5843 {
5844 uint32_t *tl;
5845 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
5846 int error, rlen, commit, committed = NFSWRITE_FILESYNC;
5847 int32_t backup;
5848 struct nfsrv_descript nfsd;
5849 struct nfsrv_descript *nd = &nfsd;
5850 struct nfssockreq *nrp;
5851
5852 KASSERT(uiop->uio_iovcnt == 1, ("nfs: writerpc iovcnt > 1"));
5853 nd->nd_mrep = NULL;
5854 nfscl_reqstart(nd, NFSPROC_WRITEDS, nmp, fhp->nfh_fh, fhp->nfh_len,
5855 NULL, &dsp->nfsclds_sess);
5856 nfsm_stateidtom(nd, stateidp, NFSSTATEID_PUTSEQIDZERO);
5857 NFSM_BUILD(tl, uint32_t *, NFSX_HYPER + 2 * NFSX_UNSIGNED);
5858 txdr_hyper(io_off, tl);
5859 tl += 2;
5860 *tl++ = txdr_unsigned(*iomode);
5861 *tl = txdr_unsigned(len);
5862 nfsm_uiombuf(nd, uiop, len);
5863 nrp = dsp->nfsclds_sockp;
5864 if (nrp == NULL)
5865 /* If NULL, use the MDS socket. */
5866 nrp = &nmp->nm_sockreq;
5867 error = newnfs_request(nd, nmp, NULL, nrp, vp, p, cred,
5868 NFS_PROG, NFS_VER4, NULL, 1, NULL, &dsp->nfsclds_sess);
5869 if (error != 0)
5870 return (error);
5871 if (nd->nd_repstat != 0) {
5872 /*
5873 * In case the rpc gets retried, roll
5874 * the uio fileds changed by nfsm_uiombuf()
5875 * back.
5876 */
5877 uiop->uio_offset -= len;
5878 uio_uio_resid_add(uiop, len);
5879 uio_iov_base_add(uiop, -len);
5880 uio_iov_len_add(uiop, len);
5881 error = nd->nd_repstat;
5882 } else {
5883 NFSM_DISSECT(tl, uint32_t *, 2 * NFSX_UNSIGNED + NFSX_VERF);
5884 rlen = fxdr_unsigned(int, *tl++);
5885 if (rlen == 0) {
5886 error = NFSERR_IO;
5887 goto nfsmout;
5888 } else if (rlen < len) {
5889 backup = len - rlen;
5890 uio_iov_base_add(uiop, -(backup));
5891 uio_iov_len_add(uiop, backup);
5892 uiop->uio_offset -= backup;
5893 uio_uio_resid_add(uiop, backup);
5894 len = rlen;
5895 }
5896 commit = fxdr_unsigned(int, *tl++);
5897
5898 /*
5899 * Return the lowest committment level
5900 * obtained by any of the RPCs.
5901 */
5902 if (committed == NFSWRITE_FILESYNC)
5903 committed = commit;
5904 else if (committed == NFSWRITE_DATASYNC &&
5905 commit == NFSWRITE_UNSTABLE)
5906 committed = commit;
5907 if (commit_thru_mds != 0) {
5908 NFSLOCKMNT(nmp);
5909 if (!NFSHASWRITEVERF(nmp)) {
5910 NFSBCOPY(tl, nmp->nm_verf, NFSX_VERF);
5911 NFSSETWRITEVERF(nmp);
5912 } else if (NFSBCMP(tl, nmp->nm_verf, NFSX_VERF)) {
5913 *must_commit = 1;
5914 NFSBCOPY(tl, nmp->nm_verf, NFSX_VERF);
5915 }
5916 NFSUNLOCKMNT(nmp);
5917 } else {
5918 NFSLOCKDS(dsp);
5919 if ((dsp->nfsclds_flags & NFSCLDS_HASWRITEVERF) == 0) {
5920 NFSBCOPY(tl, dsp->nfsclds_verf, NFSX_VERF);
5921 dsp->nfsclds_flags |= NFSCLDS_HASWRITEVERF;
5922 } else if (NFSBCMP(tl, dsp->nfsclds_verf, NFSX_VERF)) {
5923 *must_commit = 1;
5924 NFSBCOPY(tl, dsp->nfsclds_verf, NFSX_VERF);
5925 }
5926 NFSUNLOCKDS(dsp);
5927 }
5928 }
5929 nfsmout:
5930 if (nd->nd_mrep != NULL)
5931 mbuf_freem(nd->nd_mrep);
5932 *iomode = committed;
5933 if (nd->nd_repstat != 0 && error == 0)
5934 error = nd->nd_repstat;
5935 return (error);
5936 }
5937
5938 /*
5939 * Free up the nfsclds structure.
5940 */
5941 void
5942 nfscl_freenfsclds(struct nfsclds *dsp)
5943 {
5944 int i;
5945
5946 if (dsp == NULL)
5947 return;
5948 if (dsp->nfsclds_sockp != NULL) {
5949 NFSFREECRED(dsp->nfsclds_sockp->nr_cred);
5950 NFSFREEMUTEX(&dsp->nfsclds_sockp->nr_mtx);
5951 free(dsp->nfsclds_sockp->nr_nam, M_SONAME);
5952 free(dsp->nfsclds_sockp, M_NFSSOCKREQ);
5953 }
5954 NFSFREEMUTEX(&dsp->nfsclds_mtx);
5955 NFSFREEMUTEX(&dsp->nfsclds_sess.nfsess_mtx);
5956 for (i = 0; i < NFSV4_CBSLOTS; i++) {
5957 if (dsp->nfsclds_sess.nfsess_cbslots[i].nfssl_reply != NULL)
5958 m_freem(
5959 dsp->nfsclds_sess.nfsess_cbslots[i].nfssl_reply);
5960 }
5961 free(dsp, M_NFSCLDS);
5962 }
5963
5964 static enum nfsclds_state
5965 nfscl_getsameserver(struct nfsmount *nmp, struct nfsclds *newdsp,
5966 struct nfsclds **retdspp)
5967 {
5968 struct nfsclds *dsp, *cur_dsp;
5969
5970 /*
5971 * Search the list of nfsclds structures for one with the same
5972 * server.
5973 */
5974 cur_dsp = NULL;
5975 TAILQ_FOREACH(dsp, &nmp->nm_sess, nfsclds_list) {
5976 if (dsp->nfsclds_servownlen == newdsp->nfsclds_servownlen &&
5977 dsp->nfsclds_servownlen != 0 &&
5978 !NFSBCMP(dsp->nfsclds_serverown, newdsp->nfsclds_serverown,
5979 dsp->nfsclds_servownlen) &&
5980 dsp->nfsclds_sess.nfsess_defunct == 0) {
5981 NFSCL_DEBUG(4, "fnd same fdsp=%p dsp=%p flg=0x%x\n",
5982 TAILQ_FIRST(&nmp->nm_sess), dsp,
5983 dsp->nfsclds_flags);
5984 /* Server major id matches. */
5985 if ((dsp->nfsclds_flags & NFSCLDS_DS) != 0) {
5986 *retdspp = dsp;
5987 return (NFSDSP_USETHISSESSION);
5988 }
5989
5990 /*
5991 * Note the first match, so it can be used for
5992 * sequence'ing new sessions.
5993 */
5994 if (cur_dsp == NULL)
5995 cur_dsp = dsp;
5996 }
5997 }
5998 if (cur_dsp != NULL) {
5999 *retdspp = cur_dsp;
6000 return (NFSDSP_SEQTHISSESSION);
6001 }
6002 return (NFSDSP_NOTFOUND);
6003 }
6004
6005 /*
6006 * NFS commit rpc to a NFSv4.1 DS.
6007 */
6008 static int
6009 nfsrpc_commitds(vnode_t vp, uint64_t offset, int cnt, struct nfsclds *dsp,
6010 struct nfsfh *fhp, struct ucred *cred, NFSPROC_T *p)
6011 {
6012 uint32_t *tl;
6013 struct nfsrv_descript nfsd, *nd = &nfsd;
6014 struct nfsmount *nmp = VFSTONFS(vnode_mount(vp));
6015 struct nfssockreq *nrp;
6016 int error;
6017
6018 nd->nd_mrep = NULL;
6019 nfscl_reqstart(nd, NFSPROC_COMMITDS, nmp, fhp->nfh_fh, fhp->nfh_len,
6020 NULL, &dsp->nfsclds_sess);
6021 NFSM_BUILD(tl, uint32_t *, NFSX_HYPER + NFSX_UNSIGNED);
6022 txdr_hyper(offset, tl);
6023 tl += 2;
6024 *tl = txdr_unsigned(cnt);
6025 nrp = dsp->nfsclds_sockp;
6026 if (nrp == NULL)
6027 /* If NULL, use the MDS socket. */
6028 nrp = &nmp->nm_sockreq;
6029 error = newnfs_request(nd, nmp, NULL, nrp, vp, p, cred,
6030 NFS_PROG, NFS_VER4, NULL, 1, NULL, &dsp->nfsclds_sess);
6031 if (error != 0)
6032 return (error);
6033 if (nd->nd_repstat == 0) {
6034 NFSM_DISSECT(tl, u_int32_t *, NFSX_VERF);
6035 NFSLOCKDS(dsp);
6036 if (NFSBCMP(tl, dsp->nfsclds_verf, NFSX_VERF)) {
6037 NFSBCOPY(tl, dsp->nfsclds_verf, NFSX_VERF);
6038 error = NFSERR_STALEWRITEVERF;
6039 }
6040 NFSUNLOCKDS(dsp);
6041 }
6042 nfsmout:
6043 if (error == 0 && nd->nd_repstat != 0)
6044 error = nd->nd_repstat;
6045 mbuf_freem(nd->nd_mrep);
6046 return (error);
6047 }
6048
Cache object: db4cb1c13d6591c8376740a5413c6608
|