NFS - implement async state machine for nfs_readrpc_bio()
[dragonfly.git] / sys / vfs / nfs / nfsm_subs.c
1 /*
2  * Copyright (c) 2009 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
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
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34 /*
35  * Copyright (c) 1989, 1993
36  *      The Regents of the University of California.  All rights reserved.
37  *
38  * This code is derived from software contributed to Berkeley by
39  * Rick Macklem at The University of Guelph.
40  *
41  * Redistribution and use in source and binary forms, with or without
42  * modification, are permitted provided that the following conditions
43  * are met:
44  * 1. Redistributions of source code must retain the above copyright
45  *    notice, this list of conditions and the following disclaimer.
46  * 2. Redistributions in binary form must reproduce the above copyright
47  *    notice, this list of conditions and the following disclaimer in the
48  *    documentation and/or other materials provided with the distribution.
49  * 3. All advertising materials mentioning features or use of this software
50  *    must display the following acknowledgement:
51  *      This product includes software developed by the University of
52  *      California, Berkeley and its contributors.
53  * 4. Neither the name of the University nor the names of its contributors
54  *    may be used to endorse or promote products derived from this software
55  *    without specific prior written permission.
56  *
57  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
58  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
59  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
60  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
61  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
62  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
63  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
64  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
65  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
66  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
67  * SUCH DAMAGE.
68  */
69
70 /*
71  * These functions support the macros and help fiddle mbuf chains for
72  * the nfs op functions. They do things like create the rpc header and
73  * copy data between mbuf chains and uio lists.
74  */
75 #include <sys/param.h>
76 #include <sys/systm.h>
77 #include <sys/kernel.h>
78 #include <sys/buf.h>
79 #include <sys/proc.h>
80 #include <sys/mount.h>
81 #include <sys/vnode.h>
82 #include <sys/nlookup.h>
83 #include <sys/namei.h>
84 #include <sys/mbuf.h>
85 #include <sys/socket.h>
86 #include <sys/stat.h>
87 #include <sys/malloc.h>
88 #include <sys/sysent.h>
89 #include <sys/syscall.h>
90 #include <sys/conf.h>
91 #include <sys/objcache.h>
92
93 #include <vm/vm.h>
94 #include <vm/vm_object.h>
95 #include <vm/vm_extern.h>
96 #include <vm/vm_zone.h>
97
98 #include <sys/buf2.h>
99
100 #include "rpcv2.h"
101 #include "nfsproto.h"
102 #include "nfs.h"
103 #include "nfsmount.h"
104 #include "nfsnode.h"
105 #include "xdr_subs.h"
106 #include "nfsm_subs.h"
107 #include "nfsrtt.h"
108
109 #include <netinet/in.h>
110
111 static u_int32_t nfs_xid = 0;
112
113 /*
114  * Create the header for an rpc request packet
115  * The hsiz is the size of the rest of the nfs request header.
116  * (just used to decide if a cluster is a good idea)
117  */
118 void
119 nfsm_reqhead(nfsm_info_t info, struct vnode *vp, u_long procid, int hsiz)
120 {
121         info->mb = m_getl(hsiz, MB_WAIT, MT_DATA, 0, NULL);
122         info->mb->m_len = 0;
123         info->mreq = info->mb;
124         info->bpos = mtod(info->mb, caddr_t);
125 }
126
127 /*
128  * Build the RPC header and fill in the authorization info.
129  * The authorization string argument is only used when the credentials
130  * come from outside of the kernel.
131  * Returns the head of the mbuf list.
132  */
133 struct mbuf *
134 nfsm_rpchead(struct ucred *cr, int nmflag, int procid, int auth_type,
135              int auth_len, char *auth_str, int verf_len, char *verf_str,
136              struct mbuf *mrest, int mrest_len, struct mbuf **mbp,
137              u_int32_t *xidp)
138 {
139         struct nfsm_info info;
140         struct mbuf *mb2;
141         u_int32_t *tl;
142         int siz, grpsiz, authsiz, dsiz;
143         int i;
144
145         authsiz = nfsm_rndup(auth_len);
146         dsiz = authsiz + 10 * NFSX_UNSIGNED;
147         info.mb = m_getl(dsiz, MB_WAIT, MT_DATA, M_PKTHDR, NULL);
148         if (dsiz < MINCLSIZE) {
149                 if (dsiz < MHLEN)
150                         MH_ALIGN(info.mb, dsiz);
151                 else
152                         MH_ALIGN(info.mb, 8 * NFSX_UNSIGNED);
153         }
154         info.mb->m_len = info.mb->m_pkthdr.len = 0;
155         info.mreq = info.mb;
156         info.bpos = mtod(info.mb, caddr_t);
157
158         /*
159          * First the RPC header.
160          */
161         tl = nfsm_build(&info, 8 * NFSX_UNSIGNED);
162
163         /* Get a pretty random xid to start with */
164         if (!nfs_xid)
165                 nfs_xid = krandom();
166         /*
167          * Skip zero xid if it should ever happen.
168          */
169         if (++nfs_xid == 0)
170                 nfs_xid++;
171
172         *tl++ = *xidp = txdr_unsigned(nfs_xid);
173         *tl++ = rpc_call;
174         *tl++ = rpc_vers;
175         *tl++ = txdr_unsigned(NFS_PROG);
176         if (nmflag & NFSMNT_NFSV3)
177                 *tl++ = txdr_unsigned(NFS_VER3);
178         else
179                 *tl++ = txdr_unsigned(NFS_VER2);
180         if (nmflag & NFSMNT_NFSV3)
181                 *tl++ = txdr_unsigned(procid);
182         else
183                 *tl++ = txdr_unsigned(nfsv2_procid[procid]);
184
185         /*
186          * And then the authorization cred.
187          */
188         *tl++ = txdr_unsigned(auth_type);
189         *tl = txdr_unsigned(authsiz);
190         switch (auth_type) {
191         case RPCAUTH_UNIX:
192                 tl = nfsm_build(&info, auth_len);
193                 *tl++ = 0;              /* stamp ?? */
194                 *tl++ = 0;              /* NULL hostname */
195                 *tl++ = txdr_unsigned(cr->cr_uid);
196                 *tl++ = txdr_unsigned(cr->cr_groups[0]);
197                 grpsiz = (auth_len >> 2) - 5;
198                 *tl++ = txdr_unsigned(grpsiz);
199                 for (i = 1; i <= grpsiz; i++)
200                         *tl++ = txdr_unsigned(cr->cr_groups[i]);
201                 break;
202         case RPCAUTH_KERB4:
203                 siz = auth_len;
204                 while (siz > 0) {
205                         if (M_TRAILINGSPACE(info.mb) == 0) {
206                                 mb2 = m_getl(siz, MB_WAIT, MT_DATA, 0, NULL);
207                                 mb2->m_len = 0;
208                                 info.mb->m_next = mb2;
209                                 info.mb = mb2;
210                                 info.bpos = mtod(info.mb, caddr_t);
211                         }
212                         i = min(siz, M_TRAILINGSPACE(info.mb));
213                         bcopy(auth_str, info.bpos, i);
214                         info.mb->m_len += i;
215                         auth_str += i;
216                         info.bpos += i;
217                         siz -= i;
218                 }
219                 if ((siz = (nfsm_rndup(auth_len) - auth_len)) > 0) {
220                         for (i = 0; i < siz; i++)
221                                 *info.bpos++ = '\0';
222                         info.mb->m_len += siz;
223                 }
224                 break;
225         };
226
227         /*
228          * And the verifier...
229          */
230         tl = nfsm_build(&info, 2 * NFSX_UNSIGNED);
231         if (verf_str) {
232                 *tl++ = txdr_unsigned(RPCAUTH_KERB4);
233                 *tl = txdr_unsigned(verf_len);
234                 siz = verf_len;
235                 while (siz > 0) {
236                         if (M_TRAILINGSPACE(info.mb) == 0) {
237                                 mb2 = m_getl(siz, MB_WAIT, MT_DATA,
238                                                   0, NULL);
239                                 mb2->m_len = 0;
240                                 info.mb->m_next = mb2;
241                                 info.mb = mb2;
242                                 info.bpos = mtod(info.mb, caddr_t);
243                         }
244                         i = min(siz, M_TRAILINGSPACE(info.mb));
245                         bcopy(verf_str, info.bpos, i);
246                         info.mb->m_len += i;
247                         verf_str += i;
248                         info.bpos += i;
249                         siz -= i;
250                 }
251                 if ((siz = (nfsm_rndup(verf_len) - verf_len)) > 0) {
252                         for (i = 0; i < siz; i++)
253                                 *info.bpos++ = '\0';
254                         info.mb->m_len += siz;
255                 }
256         } else {
257                 *tl++ = txdr_unsigned(RPCAUTH_NULL);
258                 *tl = 0;
259         }
260         info.mb->m_next = mrest;
261         info.mreq->m_pkthdr.len = authsiz + 10 * NFSX_UNSIGNED + mrest_len;
262         info.mreq->m_pkthdr.rcvif = NULL;
263         *mbp = info.mb;
264         return (info.mreq);
265 }
266
267 void *
268 nfsm_build(nfsm_info_t info, int bytes)
269 {
270         struct mbuf *mb2;
271         void *ptr;
272
273         if (bytes > M_TRAILINGSPACE(info->mb)) {
274                 MGET(mb2, MB_WAIT, MT_DATA);
275                 if (bytes > MLEN)
276                         panic("build > MLEN");
277                 info->mb->m_next = mb2;
278                 info->mb = mb2;
279                 info->mb->m_len = 0;
280                 info->bpos = mtod(info->mb, caddr_t);
281         }
282         ptr = info->bpos;
283         info->mb->m_len += bytes;
284         info->bpos += bytes;
285         return (ptr);
286 }
287
288 /*
289  *
290  * If NULL returned caller is expected to abort with an EBADRPC error.
291  * Caller will usually use the NULLOUT macro.
292  */
293 void *
294 nfsm_dissect(nfsm_info_t info, int bytes)
295 {
296         caddr_t cp2;
297         void *ptr;
298         int error;
299         int n;
300
301         n = mtod(info->md, caddr_t) + info->md->m_len - info->dpos;
302         if (bytes <= n) {
303                 ptr = info->dpos;
304                 info->dpos += bytes;
305         } else {
306                 error = nfsm_disct(&info->md, &info->dpos, bytes, n, &cp2);
307                 if (error) {
308                         m_freem(info->mrep);
309                         info->mrep = NULL;
310                         ptr = NULL;
311                 } else {
312                         ptr = cp2;
313                 }
314         }
315         return (ptr);
316 }
317
318 /*
319  *
320  * Caller is expected to abort if non-zero error is returned.
321  */
322 int
323 nfsm_fhtom(nfsm_info_t info, struct vnode *vp)
324 {
325         u_int32_t *tl;
326         caddr_t cp;
327         int error;
328         int n;
329
330         if (info->v3) {
331                 n = nfsm_rndup(VTONFS(vp)->n_fhsize) + NFSX_UNSIGNED;
332                 if (n <= M_TRAILINGSPACE(info->mb)) {
333                         tl = nfsm_build(info, n);
334                         *tl++ = txdr_unsigned(VTONFS(vp)->n_fhsize);
335                         *(tl + ((n >> 2) - 2)) = 0;
336                         bcopy((caddr_t)VTONFS(vp)->n_fhp,(caddr_t)tl,
337                                 VTONFS(vp)->n_fhsize);
338                         error = 0;
339                 } else if ((error = nfsm_strtmbuf(&info->mb, &info->bpos,
340                                                 (caddr_t)VTONFS(vp)->n_fhp,
341                                                 VTONFS(vp)->n_fhsize)) != 0) {
342                         m_freem(info->mreq);
343                         info->mreq = NULL;
344                 }
345         } else {
346                 cp = nfsm_build(info, NFSX_V2FH);
347                 bcopy(VTONFS(vp)->n_fhp, cp, NFSX_V2FH);
348                 error = 0;
349         }
350         return (error);
351 }
352
353 void
354 nfsm_srvfhtom(nfsm_info_t info, fhandle_t *fhp)
355 {
356         u_int32_t *tl;
357
358         if (info->v3) {
359                 tl = nfsm_build(info, NFSX_UNSIGNED + NFSX_V3FH);
360                 *tl++ = txdr_unsigned(NFSX_V3FH);
361                 bcopy(fhp, tl, NFSX_V3FH);
362         } else {
363                 tl = nfsm_build(info, NFSX_V2FH);
364                 bcopy(fhp, tl, NFSX_V2FH);
365         }
366 }
367
368 void
369 nfsm_srvpostop_fh(nfsm_info_t info, fhandle_t *fhp)
370 {
371         u_int32_t *tl;
372
373         tl = nfsm_build(info, 2 * NFSX_UNSIGNED + NFSX_V3FH);
374         *tl++ = nfs_true;
375         *tl++ = txdr_unsigned(NFSX_V3FH);
376         bcopy(fhp, tl, NFSX_V3FH);
377 }
378
379 /*
380  * Caller is expected to abort if non-zero error is returned.
381  *
382  * NOTE: (*vpp) may be loaded with a valid vnode even if (*gotvpp)
383  *       winds up 0.  The caller is responsible for dealing with (*vpp).
384  */
385 int
386 nfsm_mtofh(nfsm_info_t info, struct vnode *dvp, struct vnode **vpp, int *gotvpp)
387 {
388         struct nfsnode *ttnp;
389         nfsfh_t *ttfhp;
390         u_int32_t *tl;
391         int ttfhsize;
392         int error = 0;
393
394         if (info->v3) {
395                 tl = nfsm_dissect(info, NFSX_UNSIGNED);
396                 if (tl == NULL)
397                         return(EBADRPC);
398                 *gotvpp = fxdr_unsigned(int, *tl);
399         } else {
400                 *gotvpp = 1;
401         }
402         if (*gotvpp) {
403                 NEGATIVEOUT(ttfhsize = nfsm_getfh(info, &ttfhp));
404                 error = nfs_nget(dvp->v_mount, ttfhp, ttfhsize, &ttnp);
405                 if (error) {
406                         m_freem(info->mrep);
407                         info->mrep = NULL;
408                         return (error);
409                 }
410                 *vpp = NFSTOV(ttnp);
411         }
412         if (info->v3) {
413                 tl = nfsm_dissect(info, NFSX_UNSIGNED);
414                 if (tl == NULL)
415                         return (EBADRPC);
416                 if (*gotvpp) {
417                         *gotvpp = fxdr_unsigned(int, *tl);
418                 } else if (fxdr_unsigned(int, *tl)) {
419                         error = nfsm_adv(info, NFSX_V3FATTR);
420                         if (error)
421                                 return (error);
422                 }
423         }
424         if (*gotvpp)
425                 error = nfsm_loadattr(info, *vpp, NULL);
426 nfsmout:
427         return (error);
428 }
429
430 /*
431  *
432  * Caller is expected to abort with EBADRPC if a negative length is returned.
433  */
434 int
435 nfsm_getfh(nfsm_info_t info, nfsfh_t **fhpp)
436 {
437         u_int32_t *tl;
438         int n;
439
440         *fhpp = NULL;
441         if (info->v3) {
442                 tl = nfsm_dissect(info, NFSX_UNSIGNED);
443                 if (tl == NULL)
444                         return(-1);
445                 if ((n = fxdr_unsigned(int, *tl)) <= 0 || n > NFSX_V3FHMAX) {
446                         m_freem(info->mrep);
447                         info->mrep = NULL;
448                         return(-1);
449                 }
450         } else {
451                 n = NFSX_V2FH;
452         }
453         *fhpp = nfsm_dissect(info, nfsm_rndup(n));
454         if (*fhpp == NULL)
455                 return(-1);
456         return(n);
457 }
458
459 /*
460  * Caller is expected to abort if a non-zero error is returned.
461  */
462 int
463 nfsm_loadattr(nfsm_info_t info, struct vnode *vp, struct vattr *vap)
464 {
465         int error;
466
467         error = nfs_loadattrcache(vp, &info->md, &info->dpos, vap, 0);
468         if (error) {
469                 m_freem(info->mrep);
470                 info->mrep = NULL;
471                 return (error);
472         }
473         return (0);
474 }
475
476 /*
477  * Caller is expected to abort if a non-zero error is returned.
478  */
479 int
480 nfsm_postop_attr(nfsm_info_t info, struct vnode *vp, int *attrp, int lflags)
481 {
482         u_int32_t *tl;
483         int error;
484
485         tl = nfsm_dissect(info, NFSX_UNSIGNED);
486         if (tl == NULL)
487                 return(EBADRPC);
488         *attrp = fxdr_unsigned(int, *tl);
489         if (*attrp) {
490                 error = nfs_loadattrcache(vp, &info->md, &info->dpos,
491                                           NULL, lflags);
492                 if (error) {
493                         *attrp = 0;
494                         m_freem(info->mrep);
495                         info->mrep = NULL;
496                         return (error);
497                 }
498         }
499         return (0);
500 }
501
502 /*
503  * Caller is expected to abort if a non-zero error is returned.
504  */
505 int
506 nfsm_wcc_data(nfsm_info_t info, struct vnode *vp, int *attrp)
507 {
508         u_int32_t *tl;
509         int error;
510         int ttattrf;
511         int ttretf = 0;
512
513         tl = nfsm_dissect(info, NFSX_UNSIGNED);
514         if (tl == NULL)
515                 return (EBADRPC);
516         if (*tl == nfs_true) {
517                 tl = nfsm_dissect(info, 6 * NFSX_UNSIGNED);
518                 if (tl == NULL)
519                         return (EBADRPC);
520                 if (*attrp) {
521                         ttretf = (VTONFS(vp)->n_mtime ==
522                                 fxdr_unsigned(u_int32_t, *(tl + 2)));
523                         if (ttretf == 0)
524                                 VTONFS(vp)->n_flag |= NRMODIFIED;
525                 }
526                 error = nfsm_postop_attr(info, vp, &ttattrf,
527                                  NFS_LATTR_NOSHRINK|NFS_LATTR_NOMTIMECHECK);
528                 if (error)
529                         return(error);
530         } else {
531                 error = nfsm_postop_attr(info, vp, &ttattrf,
532                                          NFS_LATTR_NOSHRINK);
533                 if (error)
534                         return(error);
535         }
536         if (*attrp)
537                 *attrp = ttretf;
538         else
539                 *attrp = ttattrf;
540         return(0);
541 }
542
543 /*
544  * This function updates the attribute cache based on data returned in the
545  * NFS reply for NFS RPCs that modify the target file.  If the RPC succeeds
546  * a 'before' and 'after' mtime is returned that allows us to determine if
547  * the new mtime attribute represents our modification or someone else's
548  * modification.
549  *
550  * The flag argument returns non-0 if the original times matched, zero if
551  * they did not match.  NRMODIFIED is automatically set if the before time
552  * does not match the original n_mtime, and n_mtime is automatically updated
553  * to the new after time (by nfsm_postop_attr()).
554  *
555  * If full is true, set all fields, otherwise just set mode and time fields
556  */
557 void
558 nfsm_v3attrbuild(nfsm_info_t info, struct vattr *vap, int full)
559 {
560         u_int32_t *tl;
561
562         if (vap->va_mode != (mode_t)VNOVAL) {
563                 tl = nfsm_build(info, 2 * NFSX_UNSIGNED);
564                 *tl++ = nfs_true;
565                 *tl = txdr_unsigned(vap->va_mode);
566         } else {
567                 tl = nfsm_build(info, NFSX_UNSIGNED);
568                 *tl = nfs_false;
569         }
570         if (full && vap->va_uid != (uid_t)VNOVAL) {
571                 tl = nfsm_build(info, 2 * NFSX_UNSIGNED);
572                 *tl++ = nfs_true;
573                 *tl = txdr_unsigned(vap->va_uid);
574         } else {
575                 tl = nfsm_build(info, NFSX_UNSIGNED);
576                 *tl = nfs_false;
577         }
578         if (full && vap->va_gid != (gid_t)VNOVAL) {
579                 tl = nfsm_build(info, 2 * NFSX_UNSIGNED);
580                 *tl++ = nfs_true;
581                 *tl = txdr_unsigned(vap->va_gid);
582         } else {
583                 tl = nfsm_build(info, NFSX_UNSIGNED);
584                 *tl = nfs_false;
585         }
586         if (full && vap->va_size != VNOVAL) {
587                 tl = nfsm_build(info, 3 * NFSX_UNSIGNED);
588                 *tl++ = nfs_true;
589                 txdr_hyper(vap->va_size, tl);
590         } else {
591                 tl = nfsm_build(info, NFSX_UNSIGNED);
592                 *tl = nfs_false;
593         }
594         if (vap->va_atime.tv_sec != VNOVAL) {
595                 if (vap->va_atime.tv_sec != time_second) {
596                         tl = nfsm_build(info, 3 * NFSX_UNSIGNED);
597                         *tl++ = txdr_unsigned(NFSV3SATTRTIME_TOCLIENT);
598                         txdr_nfsv3time(&vap->va_atime, tl);
599                 } else {
600                         tl = nfsm_build(info, NFSX_UNSIGNED);
601                         *tl = txdr_unsigned(NFSV3SATTRTIME_TOSERVER);
602                 }
603         } else {
604                 tl = nfsm_build(info, NFSX_UNSIGNED);
605                 *tl = txdr_unsigned(NFSV3SATTRTIME_DONTCHANGE);
606         }
607         if (vap->va_mtime.tv_sec != VNOVAL) {
608                 if (vap->va_mtime.tv_sec != time_second) {
609                         tl = nfsm_build(info, 3 * NFSX_UNSIGNED);
610                         *tl++ = txdr_unsigned(NFSV3SATTRTIME_TOCLIENT);
611                         txdr_nfsv3time(&vap->va_mtime, tl);
612                 } else {
613                         tl = nfsm_build(info, NFSX_UNSIGNED);
614                         *tl = txdr_unsigned(NFSV3SATTRTIME_TOSERVER);
615                 }
616         } else {
617                 tl = nfsm_build(info, NFSX_UNSIGNED);
618                 *tl = txdr_unsigned(NFSV3SATTRTIME_DONTCHANGE);
619         }
620 }
621
622 /*
623  * Caller is expected to abort with EBADRPC if a negative length is returned.
624  */
625 int
626 nfsm_strsiz(nfsm_info_t info, int maxlen)
627 {
628         u_int32_t *tl;
629         int len;
630
631         tl = nfsm_dissect(info, NFSX_UNSIGNED);
632         if (tl == NULL)
633                 return(-1);
634         len = fxdr_unsigned(int32_t, *tl);
635         if (len < 0 || len > maxlen)
636                 return(-1);
637         return (len);
638 }
639
640 /*
641  * Caller is expected to abort if a negative length is returned, but also
642  * call nfsm_reply(0) if -2 is returned.
643  *
644  * This function sets *errorp.  Caller should not modify the error code.
645  */
646 int
647 nfsm_srvstrsiz(nfsm_info_t info, int maxlen, int *errorp)
648 {
649         u_int32_t *tl;
650         int len;
651
652         tl = nfsm_dissect(info, NFSX_UNSIGNED);
653         if (tl == NULL) {
654                 *errorp = EBADRPC;
655                 return(-1);
656         }
657         len = fxdr_unsigned(int32_t,*tl);
658         if (len > maxlen || len <= 0) {
659                 *errorp = EBADRPC;
660                 return(-2);
661         }
662         return(len);
663 }
664
665 /*
666  * Caller is expected to abort if a negative length is returned, but also
667  * call nfsm_reply(0) if -2 is returned.
668  *
669  * This function sets *errorp.  Caller should not modify the error code.
670  */
671 int
672 nfsm_srvnamesiz(nfsm_info_t info, int *errorp)
673 {
674         u_int32_t *tl;
675         int len;
676
677         tl = nfsm_dissect(info, NFSX_UNSIGNED);
678         if (tl == NULL) {
679                 *errorp = EBADRPC;
680                 return(-1);
681         }
682
683         /*
684          * In this case if *errorp is not EBADRPC and we are NFSv3,
685          * nfsm_reply() will not return a negative number.  But all
686          * call cases assume len is valid so we really do want
687          * to return -1.
688          */
689         len = fxdr_unsigned(int32_t,*tl);
690         if (len > NFS_MAXNAMLEN)
691                 *errorp = NFSERR_NAMETOL;
692         if (len <= 0)
693                 *errorp = EBADRPC;
694         if (*errorp)
695                 return(-2);
696         return (len);
697 }
698
699 /*
700  * Caller is expected to abort if a non-zero error is returned.
701  */
702 int
703 nfsm_mtouio(nfsm_info_t info, struct uio *uiop, int len)
704 {
705         int error;
706
707         if (len > 0 &&
708            (error = nfsm_mbuftouio(&info->md, uiop, len, &info->dpos)) != 0) {
709                 m_freem(info->mrep);
710                 info->mrep = NULL;
711                 return(error);
712         }
713         return(0);
714 }
715
716 /*
717  * Caller is expected to abort if a non-zero error is returned.
718  */
719 int
720 nfsm_mtobio(nfsm_info_t info, struct bio *bio, int len)
721 {
722         int error;
723
724         if (len > 0 &&
725            (error = nfsm_mbuftobio(&info->md, bio, len, &info->dpos)) != 0) {
726                 m_freem(info->mrep);
727                 info->mrep = NULL;
728                 return(error);
729        }
730        return (0);
731 }
732
733 /*
734  * Caller is expected to abort if a non-zero error is returned.
735  */
736 int
737 nfsm_uiotom(nfsm_info_t info, struct uio *uiop, int len)
738 {
739         int error;
740
741         if ((error = nfsm_uiotombuf(uiop, &info->mb, len, &info->bpos)) != 0) {
742                 m_freem(info->mreq);
743                 info->mreq = NULL;
744                 return (error);
745         }
746         return(0);
747 }
748
749 /*
750  * Caller is expected to abort if a negative value is returned.  This
751  * function sets *errorp.  Caller should not modify the error code.
752  *
753  * We load up the remaining info fields and run the request state
754  * machine until it is done.
755  *
756  * This call runs the entire state machine and does not return until
757  * the command is complete.
758  */
759 int
760 nfsm_request(nfsm_info_t info, struct vnode *vp, int procnum,
761              thread_t td, struct ucred *cred, int *errorp)
762 {
763         info->state = NFSM_STATE_SETUP;
764         info->procnum = procnum;
765         info->vp = vp;
766         info->td = td;
767         info->cred = cred;
768         info->async = 0;
769         info->bio = NULL;
770         info->nmp = VFSTONFS(vp->v_mount);
771
772         *errorp = nfs_request(info, NFSM_STATE_SETUP, NFSM_STATE_DONE);
773         if (*errorp) {
774                 if ((*errorp & NFSERR_RETERR) == 0)
775                         return(-1);
776                 *errorp &= ~NFSERR_RETERR;
777         }
778         return(0);
779 }
780
781 /*
782  * This call starts the state machine through the initial transmission.
783  * Completion is via the bio.  The info structure must have installed
784  * a 'done' callback.
785  *
786  * If we are unable to do the initial tx we generate the bio completion
787  * ourselves.
788  */
789 void
790 nfsm_request_bio(nfsm_info_t info, struct vnode *vp, int procnum,
791              thread_t td, struct ucred *cred)
792 {
793         struct buf *bp;
794         int error;
795
796         info->state = NFSM_STATE_SETUP;
797         info->procnum = procnum;
798         info->vp = vp;
799         info->td = td;
800         info->cred = cred;
801         info->async = 1;
802         info->nmp = VFSTONFS(vp->v_mount);
803
804         error = nfs_request(info, NFSM_STATE_SETUP, NFSM_STATE_WAITREPLY);
805         if (error != EINPROGRESS) {
806                 kprintf("nfsm_request_bio: early abort %d\n", error);
807                 bp = info->bio->bio_buf;
808                 if (error)
809                         bp->b_flags |= B_ERROR;
810                 bp->b_error = error;
811                 biodone(info->bio);
812         }
813 }
814
815 /*
816  * Caller is expected to abort if a non-zero error is returned.
817  */
818 int
819 nfsm_strtom(nfsm_info_t info, const void *data, int len, int maxlen)
820 {
821         u_int32_t *tl;
822         int error;
823         int n;
824
825         if (len > maxlen) {
826                 m_freem(info->mreq);
827                 info->mreq = NULL;
828                 return(ENAMETOOLONG);
829         }
830         n = nfsm_rndup(len) + NFSX_UNSIGNED;
831         if (n <= M_TRAILINGSPACE(info->mb)) {
832                 tl = nfsm_build(info, n);
833                 *tl++ = txdr_unsigned(len);
834                 *(tl + ((n >> 2) - 2)) = 0;
835                 bcopy(data, tl, len);
836                 error = 0;
837         } else {
838                 error = nfsm_strtmbuf(&info->mb, &info->bpos, data, len);
839                 if (error) {
840                         m_freem(info->mreq);
841                         info->mreq = NULL;
842                 }
843         }
844         return (error);
845 }
846
847 /*
848  * Caller is expected to abort if a negative value is returned.  This
849  * function sets *errorp.  Caller should not modify the error code.
850  */
851 int
852 nfsm_reply(nfsm_info_t info,
853            struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
854            int siz, int *errorp)
855 {
856         nfsd->nd_repstat = *errorp;
857         if (*errorp && !(nfsd->nd_flag & ND_NFSV3))
858                 siz = 0;
859         nfs_rephead(siz, nfsd, slp, *errorp, &info->mreq,
860                     &info->mb, &info->bpos);
861         if (info->mrep != NULL) {
862                 m_freem(info->mrep);
863                 info->mrep = NULL;
864         }
865         if (*errorp && (!(nfsd->nd_flag & ND_NFSV3) || *errorp == EBADRPC)) {
866                 *errorp = 0;
867                 return(-1);
868         }
869         return(0);
870 }
871
872 void
873 nfsm_writereply(nfsm_info_t info,
874                 struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
875                 int error, int siz)
876 {
877         nfsd->nd_repstat = error;
878         if (error && !(info->v3))
879                 siz = 0;
880         nfs_rephead(siz, nfsd, slp, error, &info->mreq, &info->mb, &info->bpos);
881 }
882
883 /*
884  * Caller is expected to abort if a non-zero error is returned.
885  */
886 int
887 nfsm_adv(nfsm_info_t info, int len)
888 {
889         int error;
890         int n;
891
892         n = mtod(info->md, caddr_t) + info->md->m_len - info->dpos;
893         if (n >= len) {
894                 info->dpos += len;
895                 error = 0;
896         } else if ((error = nfs_adv(&info->md, &info->dpos, len, n)) != 0) {
897                 m_freem(info->mrep);
898                 info->mrep = NULL;
899         }
900         return (error);
901 }
902
903 /*
904  * Caller is expected to abort if a negative length is returned, but also
905  * call nfsm_reply(0) if -2 is returned.
906  *
907  * This function sets *errorp.  Caller should not modify the error code.
908  */
909 int
910 nfsm_srvmtofh(nfsm_info_t info, struct nfsrv_descript *nfsd,
911               fhandle_t *fhp, int *errorp)
912 {
913         u_int32_t *tl;
914         int fhlen;
915
916         if (nfsd->nd_flag & ND_NFSV3) {
917                 tl = nfsm_dissect(info, NFSX_UNSIGNED);
918                 if (tl == NULL) {
919                         *errorp = EBADRPC;
920                         return(-1);
921                 }
922                 fhlen = fxdr_unsigned(int, *tl);
923                 if (fhlen != 0 && fhlen != NFSX_V3FH) {
924                         *errorp = EBADRPC;
925                         return(-2);
926                 }
927         } else {
928                 fhlen = NFSX_V2FH;
929         }
930         if (fhlen != 0) {
931                 tl = nfsm_dissect(info, fhlen);
932                 if (tl == NULL) {
933                         *errorp = EBADRPC;
934                         return(-1);
935                 }
936                 bcopy(tl, fhp, fhlen);
937         } else {
938                 bzero(fhp, NFSX_V3FH);
939         }
940         return(0);
941 }
942
943 void *
944 _nfsm_clget(nfsm_info_t info, struct mbuf *mp1, struct mbuf *mp2,
945            char *bp, char *be)
946 {
947         u_int32_t *tl;
948
949         if (bp >= be) {
950                 if (mp1 == info->mb)
951                         mp1->m_len += bp - info->bpos;
952                 mp1 = m_getcl(MB_WAIT, MT_DATA, 0);
953                 mp1->m_len = MCLBYTES;
954                 mp2->m_next = mp1;
955                 mp2 = mp1;
956                 bp = mtod(mp1, caddr_t);
957                 be = bp + mp1->m_len;
958         }
959         tl = (u_int32_t *)bp;
960         return (tl);
961 }
962
963 int
964 nfsm_srvsattr(nfsm_info_t info, struct vattr *vap)
965 {
966         u_int32_t *tl;
967         int error = 0;
968
969         NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
970         if (*tl == nfs_true) {
971                 NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
972                 vap->va_mode = nfstov_mode(*tl);
973         }
974         NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
975         if (*tl == nfs_true) {
976                 NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
977                 vap->va_uid = fxdr_unsigned(uid_t, *tl);
978         }
979         NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
980         if (*tl == nfs_true) {
981                 NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
982                 vap->va_gid = fxdr_unsigned(gid_t, *tl);
983         }
984         NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
985         if (*tl == nfs_true) {
986                 NULLOUT(tl = nfsm_dissect(info, 2 * NFSX_UNSIGNED));
987                 vap->va_size = fxdr_hyper(tl);
988         }
989         NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
990         switch (fxdr_unsigned(int, *tl)) {
991         case NFSV3SATTRTIME_TOCLIENT:
992                 NULLOUT(tl = nfsm_dissect(info, 2 * NFSX_UNSIGNED));
993                 fxdr_nfsv3time(tl, &vap->va_atime);
994                 break;
995         case NFSV3SATTRTIME_TOSERVER:
996                 getnanotime(&vap->va_atime);
997                 break;
998         };
999         NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
1000         switch (fxdr_unsigned(int, *tl)) {
1001         case NFSV3SATTRTIME_TOCLIENT:
1002                 NULLOUT(tl = nfsm_dissect(info, 2 * NFSX_UNSIGNED));
1003                 fxdr_nfsv3time(tl, &vap->va_mtime);
1004                 break;
1005         case NFSV3SATTRTIME_TOSERVER:
1006                 getnanotime(&vap->va_mtime);
1007                 break;
1008         }
1009 nfsmout:
1010         return (error);
1011 }
1012
1013 /*
1014  * copies mbuf chain to the uio scatter/gather list
1015  */
1016 int
1017 nfsm_mbuftouio(struct mbuf **mrep, struct uio *uiop, int siz, caddr_t *dpos)
1018 {
1019         char *mbufcp, *uiocp;
1020         int xfer, left, len;
1021         struct mbuf *mp;
1022         long uiosiz, rem;
1023         int error = 0;
1024
1025         mp = *mrep;
1026         mbufcp = *dpos;
1027         len = mtod(mp, caddr_t)+mp->m_len-mbufcp;
1028         rem = nfsm_rndup(siz)-siz;
1029         while (siz > 0) {
1030                 if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL)
1031                         return (EFBIG);
1032                 left = uiop->uio_iov->iov_len;
1033                 uiocp = uiop->uio_iov->iov_base;
1034                 if (left > siz)
1035                         left = siz;
1036                 uiosiz = left;
1037                 while (left > 0) {
1038                         while (len == 0) {
1039                                 mp = mp->m_next;
1040                                 if (mp == NULL)
1041                                         return (EBADRPC);
1042                                 mbufcp = mtod(mp, caddr_t);
1043                                 len = mp->m_len;
1044                         }
1045                         xfer = (left > len) ? len : left;
1046 #ifdef notdef
1047                         /* Not Yet.. */
1048                         if (uiop->uio_iov->iov_op != NULL)
1049                                 (*(uiop->uio_iov->iov_op))
1050                                 (mbufcp, uiocp, xfer);
1051                         else
1052 #endif
1053                         if (uiop->uio_segflg == UIO_SYSSPACE)
1054                                 bcopy(mbufcp, uiocp, xfer);
1055                         else
1056                                 copyout(mbufcp, uiocp, xfer);
1057                         left -= xfer;
1058                         len -= xfer;
1059                         mbufcp += xfer;
1060                         uiocp += xfer;
1061                         uiop->uio_offset += xfer;
1062                         uiop->uio_resid -= xfer;
1063                 }
1064                 if (uiop->uio_iov->iov_len <= siz) {
1065                         uiop->uio_iovcnt--;
1066                         uiop->uio_iov++;
1067                 } else {
1068                         uiop->uio_iov->iov_base = (char *)uiop->uio_iov->iov_base + uiosiz;
1069                         uiop->uio_iov->iov_len -= uiosiz;
1070                 }
1071                 siz -= uiosiz;
1072         }
1073         *dpos = mbufcp;
1074         *mrep = mp;
1075         if (rem > 0) {
1076                 if (len < rem)
1077                         error = nfs_adv(mrep, dpos, rem, len);
1078                 else
1079                         *dpos += rem;
1080         }
1081         return (error);
1082 }
1083
1084 /*
1085  * copies mbuf chain to the bio buffer
1086  */
1087 int
1088 nfsm_mbuftobio(struct mbuf **mrep, struct bio *bio, int size, caddr_t *dpos)
1089 {
1090         struct buf *bp = bio->bio_buf;
1091         char *mbufcp;
1092         char *bio_cp;
1093         int xfer, len;
1094         struct mbuf *mp;
1095         long rem;
1096         int error = 0;
1097         int bio_left;
1098
1099         mp = *mrep;
1100         mbufcp = *dpos;
1101         len = mtod(mp, caddr_t) + mp->m_len - mbufcp;
1102         rem = nfsm_rndup(size) - size;
1103
1104         bio_left = bp->b_bcount;
1105         bio_cp = bp->b_data;
1106
1107         while (size > 0) {
1108                 while (len == 0) {
1109                         mp = mp->m_next;
1110                         if (mp == NULL)
1111                                 return (EBADRPC);
1112                         mbufcp = mtod(mp, caddr_t);
1113                         len = mp->m_len;
1114                 }
1115                 if ((xfer = len) > size)
1116                         xfer = size;
1117                 if (bio_left) {
1118                         if (xfer > bio_left)
1119                                 xfer = bio_left;
1120                         bcopy(mbufcp, bio_cp, xfer);
1121                 } else {
1122                         /*
1123                          * Not enough buffer space in the bio.
1124                          */
1125                         return(EFBIG);
1126                 }
1127                 size -= xfer;
1128                 bio_left -= xfer;
1129                 bio_cp += xfer;
1130                 len -= xfer;
1131                 mbufcp += xfer;
1132         }
1133         *dpos = mbufcp;
1134         *mrep = mp;
1135         if (rem > 0) {
1136                 if (len < rem)
1137                         error = nfs_adv(mrep, dpos, rem, len);
1138                 else
1139                         *dpos += rem;
1140         }
1141         return (error);
1142 }
1143
1144 /*
1145  * copies a uio scatter/gather list to an mbuf chain.
1146  * NOTE: can ony handle iovcnt == 1
1147  */
1148 int
1149 nfsm_uiotombuf(struct uio *uiop, struct mbuf **mq, int siz, caddr_t *bpos)
1150 {
1151         char *uiocp;
1152         struct mbuf *mp, *mp2;
1153         int xfer, left, mlen;
1154         int uiosiz, rem;
1155         boolean_t getcluster;
1156         char *cp;
1157
1158 #ifdef DIAGNOSTIC
1159         if (uiop->uio_iovcnt != 1)
1160                 panic("nfsm_uiotombuf: iovcnt != 1");
1161 #endif
1162
1163         if (siz >= MINCLSIZE)
1164                 getcluster = TRUE;
1165         else
1166                 getcluster = FALSE;
1167         rem = nfsm_rndup(siz) - siz;
1168         mp = mp2 = *mq;
1169         while (siz > 0) {
1170                 left = uiop->uio_iov->iov_len;
1171                 uiocp = uiop->uio_iov->iov_base;
1172                 if (left > siz)
1173                         left = siz;
1174                 uiosiz = left;
1175                 while (left > 0) {
1176                         mlen = M_TRAILINGSPACE(mp);
1177                         if (mlen == 0) {
1178                                 if (getcluster)
1179                                         mp = m_getcl(MB_WAIT, MT_DATA, 0);
1180                                 else
1181                                         mp = m_get(MB_WAIT, MT_DATA);
1182                                 mp->m_len = 0;
1183                                 mp2->m_next = mp;
1184                                 mp2 = mp;
1185                                 mlen = M_TRAILINGSPACE(mp);
1186                         }
1187                         xfer = (left > mlen) ? mlen : left;
1188 #ifdef notdef
1189                         /* Not Yet.. */
1190                         if (uiop->uio_iov->iov_op != NULL)
1191                                 (*(uiop->uio_iov->iov_op))
1192                                 (uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
1193                         else
1194 #endif
1195                         if (uiop->uio_segflg == UIO_SYSSPACE)
1196                                 bcopy(uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
1197                         else
1198                                 copyin(uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
1199                         mp->m_len += xfer;
1200                         left -= xfer;
1201                         uiocp += xfer;
1202                         uiop->uio_offset += xfer;
1203                         uiop->uio_resid -= xfer;
1204                 }
1205                 uiop->uio_iov->iov_base = (char *)uiop->uio_iov->iov_base + uiosiz;
1206                 uiop->uio_iov->iov_len -= uiosiz;
1207                 siz -= uiosiz;
1208         }
1209         if (rem > 0) {
1210                 if (rem > M_TRAILINGSPACE(mp)) {
1211                         MGET(mp, MB_WAIT, MT_DATA);
1212                         mp->m_len = 0;
1213                         mp2->m_next = mp;
1214                 }
1215                 cp = mtod(mp, caddr_t)+mp->m_len;
1216                 for (left = 0; left < rem; left++)
1217                         *cp++ = '\0';
1218                 mp->m_len += rem;
1219                 *bpos = cp;
1220         } else
1221                 *bpos = mtod(mp, caddr_t)+mp->m_len;
1222         *mq = mp;
1223         return (0);
1224 }
1225
1226 /*
1227  * Help break down an mbuf chain by setting the first siz bytes contiguous
1228  * pointed to by returned val.
1229  * This is used by the macros nfsm_dissect and nfsm_dissecton for tough
1230  * cases. (The macros use the vars. dpos and dpos2)
1231  */
1232 int
1233 nfsm_disct(struct mbuf **mdp, caddr_t *dposp, int siz, int left, caddr_t *cp2)
1234 {
1235         struct mbuf *mp, *mp2;
1236         int siz2, xfer;
1237         caddr_t p;
1238
1239         mp = *mdp;
1240         while (left == 0) {
1241                 *mdp = mp = mp->m_next;
1242                 if (mp == NULL)
1243                         return (EBADRPC);
1244                 left = mp->m_len;
1245                 *dposp = mtod(mp, caddr_t);
1246         }
1247         if (left >= siz) {
1248                 *cp2 = *dposp;
1249                 *dposp += siz;
1250         } else if (mp->m_next == NULL) {
1251                 return (EBADRPC);
1252         } else if (siz > MHLEN) {
1253                 panic("nfs S too big");
1254         } else {
1255                 MGET(mp2, MB_WAIT, MT_DATA);
1256                 mp2->m_next = mp->m_next;
1257                 mp->m_next = mp2;
1258                 mp->m_len -= left;
1259                 mp = mp2;
1260                 *cp2 = p = mtod(mp, caddr_t);
1261                 bcopy(*dposp, p, left);         /* Copy what was left */
1262                 siz2 = siz-left;
1263                 p += left;
1264                 mp2 = mp->m_next;
1265                 /* Loop around copying up the siz2 bytes */
1266                 while (siz2 > 0) {
1267                         if (mp2 == NULL)
1268                                 return (EBADRPC);
1269                         xfer = (siz2 > mp2->m_len) ? mp2->m_len : siz2;
1270                         if (xfer > 0) {
1271                                 bcopy(mtod(mp2, caddr_t), p, xfer);
1272                                 mp2->m_len -= xfer;
1273                                 mp2->m_data += xfer;
1274                                 p += xfer;
1275                                 siz2 -= xfer;
1276                         }
1277                         if (siz2 > 0)
1278                                 mp2 = mp2->m_next;
1279                 }
1280                 mp->m_len = siz;
1281                 *mdp = mp2;
1282                 *dposp = mtod(mp2, caddr_t);
1283         }
1284         return (0);
1285 }
1286
1287 /*
1288  * Advance the position in the mbuf chain.
1289  */
1290 int
1291 nfs_adv(struct mbuf **mdp, caddr_t *dposp, int offs, int left)
1292 {
1293         struct mbuf *m;
1294         int s;
1295
1296         m = *mdp;
1297         s = left;
1298         while (s < offs) {
1299                 offs -= s;
1300                 m = m->m_next;
1301                 if (m == NULL)
1302                         return (EBADRPC);
1303                 s = m->m_len;
1304         }
1305         *mdp = m;
1306         *dposp = mtod(m, caddr_t)+offs;
1307         return (0);
1308 }
1309
1310 /*
1311  * Copy a string into mbufs for the hard cases...
1312  */
1313 int
1314 nfsm_strtmbuf(struct mbuf **mb, char **bpos, const char *cp, long siz)
1315 {
1316         struct mbuf *m1 = NULL, *m2;
1317         long left, xfer, len, tlen;
1318         u_int32_t *tl;
1319         int putsize;
1320
1321         putsize = 1;
1322         m2 = *mb;
1323         left = M_TRAILINGSPACE(m2);
1324         if (left > 0) {
1325                 tl = ((u_int32_t *)(*bpos));
1326                 *tl++ = txdr_unsigned(siz);
1327                 putsize = 0;
1328                 left -= NFSX_UNSIGNED;
1329                 m2->m_len += NFSX_UNSIGNED;
1330                 if (left > 0) {
1331                         bcopy(cp, (caddr_t) tl, left);
1332                         siz -= left;
1333                         cp += left;
1334                         m2->m_len += left;
1335                         left = 0;
1336                 }
1337         }
1338         /* Loop around adding mbufs */
1339         while (siz > 0) {
1340                 int msize;
1341
1342                 m1 = m_getl(siz, MB_WAIT, MT_DATA, 0, &msize);
1343                 m1->m_len = msize;
1344                 m2->m_next = m1;
1345                 m2 = m1;
1346                 tl = mtod(m1, u_int32_t *);
1347                 tlen = 0;
1348                 if (putsize) {
1349                         *tl++ = txdr_unsigned(siz);
1350                         m1->m_len -= NFSX_UNSIGNED;
1351                         tlen = NFSX_UNSIGNED;
1352                         putsize = 0;
1353                 }
1354                 if (siz < m1->m_len) {
1355                         len = nfsm_rndup(siz);
1356                         xfer = siz;
1357                         if (xfer < len)
1358                                 *(tl+(xfer>>2)) = 0;
1359                 } else {
1360                         xfer = len = m1->m_len;
1361                 }
1362                 bcopy(cp, (caddr_t) tl, xfer);
1363                 m1->m_len = len+tlen;
1364                 siz -= xfer;
1365                 cp += xfer;
1366         }
1367         *mb = m1;
1368         *bpos = mtod(m1, caddr_t)+m1->m_len;
1369         return (0);
1370 }
1371
1372 /*
1373  * A fiddled version of m_adj() that ensures null fill to a long
1374  * boundary and only trims off the back end
1375  */
1376 void
1377 nfsm_adj(struct mbuf *mp, int len, int nul)
1378 {
1379         struct mbuf *m;
1380         int count, i;
1381         char *cp;
1382
1383         /*
1384          * Trim from tail.  Scan the mbuf chain,
1385          * calculating its length and finding the last mbuf.
1386          * If the adjustment only affects this mbuf, then just
1387          * adjust and return.  Otherwise, rescan and truncate
1388          * after the remaining size.
1389          */
1390         count = 0;
1391         m = mp;
1392         for (;;) {
1393                 count += m->m_len;
1394                 if (m->m_next == NULL)
1395                         break;
1396                 m = m->m_next;
1397         }
1398         if (m->m_len > len) {
1399                 m->m_len -= len;
1400                 if (nul > 0) {
1401                         cp = mtod(m, caddr_t)+m->m_len-nul;
1402                         for (i = 0; i < nul; i++)
1403                                 *cp++ = '\0';
1404                 }
1405                 return;
1406         }
1407         count -= len;
1408         if (count < 0)
1409                 count = 0;
1410         /*
1411          * Correct length for chain is "count".
1412          * Find the mbuf with last data, adjust its length,
1413          * and toss data from remaining mbufs on chain.
1414          */
1415         for (m = mp; m; m = m->m_next) {
1416                 if (m->m_len >= count) {
1417                         m->m_len = count;
1418                         if (nul > 0) {
1419                                 cp = mtod(m, caddr_t)+m->m_len-nul;
1420                                 for (i = 0; i < nul; i++)
1421                                         *cp++ = '\0';
1422                         }
1423                         break;
1424                 }
1425                 count -= m->m_len;
1426         }
1427         for (m = m->m_next;m;m = m->m_next)
1428                 m->m_len = 0;
1429 }
1430
1431 /*
1432  * Make these functions instead of macros, so that the kernel text size
1433  * doesn't get too big...
1434  */
1435 void
1436 nfsm_srvwcc_data(nfsm_info_t info, struct nfsrv_descript *nfsd,
1437                  int before_ret, struct vattr *before_vap,
1438                  int after_ret, struct vattr *after_vap)
1439 {
1440         u_int32_t *tl;
1441
1442         /*
1443          * before_ret is 0 if before_vap is valid, non-zero if it isn't.
1444          */
1445         if (before_ret) {
1446                 tl = nfsm_build(info, NFSX_UNSIGNED);
1447                 *tl = nfs_false;
1448         } else {
1449                 tl = nfsm_build(info, 7 * NFSX_UNSIGNED);
1450                 *tl++ = nfs_true;
1451                 txdr_hyper(before_vap->va_size, tl);
1452                 tl += 2;
1453                 txdr_nfsv3time(&(before_vap->va_mtime), tl);
1454                 tl += 2;
1455                 txdr_nfsv3time(&(before_vap->va_ctime), tl);
1456         }
1457         nfsm_srvpostop_attr(info, nfsd, after_ret, after_vap);
1458 }
1459
1460 void
1461 nfsm_srvpostop_attr(nfsm_info_t info, struct nfsrv_descript *nfsd,
1462                    int after_ret, struct vattr *after_vap)
1463 {
1464         struct nfs_fattr *fp;
1465         u_int32_t *tl;
1466
1467         if (after_ret) {
1468                 tl = nfsm_build(info, NFSX_UNSIGNED);
1469                 *tl = nfs_false;
1470         } else {
1471                 tl = nfsm_build(info, NFSX_UNSIGNED + NFSX_V3FATTR);
1472                 *tl++ = nfs_true;
1473                 fp = (struct nfs_fattr *)tl;
1474                 nfsm_srvfattr(nfsd, after_vap, fp);
1475         }
1476 }
1477
1478 void
1479 nfsm_srvfattr(struct nfsrv_descript *nfsd, struct vattr *vap,
1480               struct nfs_fattr *fp)
1481 {
1482         /*
1483          * NFS seems to truncate nlink to 16 bits, don't let it overflow.
1484          */
1485         if (vap->va_nlink > 65535)
1486                 fp->fa_nlink = 65535;
1487         else
1488                 fp->fa_nlink = txdr_unsigned(vap->va_nlink);
1489         fp->fa_uid = txdr_unsigned(vap->va_uid);
1490         fp->fa_gid = txdr_unsigned(vap->va_gid);
1491         if (nfsd->nd_flag & ND_NFSV3) {
1492                 fp->fa_type = vtonfsv3_type(vap->va_type);
1493                 fp->fa_mode = vtonfsv3_mode(vap->va_mode);
1494                 txdr_hyper(vap->va_size, &fp->fa3_size);
1495                 txdr_hyper(vap->va_bytes, &fp->fa3_used);
1496                 fp->fa3_rdev.specdata1 = txdr_unsigned(vap->va_rmajor);
1497                 fp->fa3_rdev.specdata2 = txdr_unsigned(vap->va_rminor);
1498                 fp->fa3_fsid.nfsuquad[0] = 0;
1499                 fp->fa3_fsid.nfsuquad[1] = txdr_unsigned(vap->va_fsid);
1500                 txdr_hyper(vap->va_fileid, &fp->fa3_fileid);
1501                 txdr_nfsv3time(&vap->va_atime, &fp->fa3_atime);
1502                 txdr_nfsv3time(&vap->va_mtime, &fp->fa3_mtime);
1503                 txdr_nfsv3time(&vap->va_ctime, &fp->fa3_ctime);
1504         } else {
1505                 fp->fa_type = vtonfsv2_type(vap->va_type);
1506                 fp->fa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
1507                 fp->fa2_size = txdr_unsigned(vap->va_size);
1508                 fp->fa2_blocksize = txdr_unsigned(vap->va_blocksize);
1509                 if (vap->va_type == VFIFO)
1510                         fp->fa2_rdev = 0xffffffff;
1511                 else
1512                         fp->fa2_rdev = txdr_unsigned(makeudev(vap->va_rmajor, vap->va_rminor));
1513                 fp->fa2_blocks = txdr_unsigned(vap->va_bytes / NFS_FABLKSIZE);
1514                 fp->fa2_fsid = txdr_unsigned(vap->va_fsid);
1515                 fp->fa2_fileid = txdr_unsigned(vap->va_fileid);
1516                 txdr_nfsv2time(&vap->va_atime, &fp->fa2_atime);
1517                 txdr_nfsv2time(&vap->va_mtime, &fp->fa2_mtime);
1518                 txdr_nfsv2time(&vap->va_ctime, &fp->fa2_ctime);
1519         }
1520 }