372568ce57d49b2c1af90bffa0750e5e6a1b6bf0
[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_uiotom(nfsm_info_t info, struct uio *uiop, int len)
721 {
722         int error;
723
724         if ((error = nfsm_uiotombuf(uiop, &info->mb, len, &info->bpos)) != 0) {
725                 m_freem(info->mreq);
726                 info->mreq = NULL;
727                 return (error);
728         }
729         return(0);
730 }
731
732 /*
733  * Caller is expected to abort if a negative value is returned.  This
734  * function sets *errorp.  Caller should not modify the error code.
735  *
736  * We load up the remaining info fields and run the request state
737  * machine until it is done.
738  */
739 int
740 nfsm_request(nfsm_info_t info, struct vnode *vp, int procnum,
741              thread_t td, struct ucred *cred, int *errorp)
742 {
743         info->state = NFSM_STATE_SETUP;
744         info->procnum = procnum;
745         info->vp = vp;
746         info->td = td;
747         info->cred = cred;
748
749         *errorp = nfs_request(info, NFSM_STATE_DONE);
750         if (*errorp) {
751                 if ((*errorp & NFSERR_RETERR) == 0)
752                         return(-1);
753                 *errorp &= ~NFSERR_RETERR;
754         }
755         return(0);
756 }
757
758 /*
759  * Caller is expected to abort if a non-zero error is returned.
760  */
761 int
762 nfsm_strtom(nfsm_info_t info, const void *data, int len, int maxlen)
763 {
764         u_int32_t *tl;
765         int error;
766         int n;
767
768         if (len > maxlen) {
769                 m_freem(info->mreq);
770                 info->mreq = NULL;
771                 return(ENAMETOOLONG);
772         }
773         n = nfsm_rndup(len) + NFSX_UNSIGNED;
774         if (n <= M_TRAILINGSPACE(info->mb)) {
775                 tl = nfsm_build(info, n);
776                 *tl++ = txdr_unsigned(len);
777                 *(tl + ((n >> 2) - 2)) = 0;
778                 bcopy(data, tl, len);
779                 error = 0;
780         } else {
781                 error = nfsm_strtmbuf(&info->mb, &info->bpos, data, len);
782                 if (error) {
783                         m_freem(info->mreq);
784                         info->mreq = NULL;
785                 }
786         }
787         return (error);
788 }
789
790 /*
791  * Caller is expected to abort if a negative value is returned.  This
792  * function sets *errorp.  Caller should not modify the error code.
793  */
794 int
795 nfsm_reply(nfsm_info_t info,
796            struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
797            int siz, int *errorp)
798 {
799         nfsd->nd_repstat = *errorp;
800         if (*errorp && !(nfsd->nd_flag & ND_NFSV3))
801                 siz = 0;
802         nfs_rephead(siz, nfsd, slp, *errorp, &info->mreq,
803                     &info->mb, &info->bpos);
804         if (info->mrep != NULL) {
805                 m_freem(info->mrep);
806                 info->mrep = NULL;
807         }
808         if (*errorp && (!(nfsd->nd_flag & ND_NFSV3) || *errorp == EBADRPC)) {
809                 *errorp = 0;
810                 return(-1);
811         }
812         return(0);
813 }
814
815 void
816 nfsm_writereply(nfsm_info_t info,
817                 struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
818                 int error, int siz)
819 {
820         nfsd->nd_repstat = error;
821         if (error && !(info->v3))
822                 siz = 0;
823         nfs_rephead(siz, nfsd, slp, error, &info->mreq, &info->mb, &info->bpos);
824 }
825
826 /*
827  * Caller is expected to abort if a non-zero error is returned.
828  */
829 int
830 nfsm_adv(nfsm_info_t info, int len)
831 {
832         int error;
833         int n;
834
835         n = mtod(info->md, caddr_t) + info->md->m_len - info->dpos;
836         if (n >= len) {
837                 info->dpos += len;
838                 error = 0;
839         } else if ((error = nfs_adv(&info->md, &info->dpos, len, n)) != 0) {
840                 m_freem(info->mrep);
841                 info->mrep = NULL;
842         }
843         return (error);
844 }
845
846 /*
847  * Caller is expected to abort if a negative length is returned, but also
848  * call nfsm_reply(0) if -2 is returned.
849  *
850  * This function sets *errorp.  Caller should not modify the error code.
851  */
852 int
853 nfsm_srvmtofh(nfsm_info_t info, struct nfsrv_descript *nfsd,
854               fhandle_t *fhp, int *errorp)
855 {
856         u_int32_t *tl;
857         int fhlen;
858
859         if (nfsd->nd_flag & ND_NFSV3) {
860                 tl = nfsm_dissect(info, NFSX_UNSIGNED);
861                 if (tl == NULL) {
862                         *errorp = EBADRPC;
863                         return(-1);
864                 }
865                 fhlen = fxdr_unsigned(int, *tl);
866                 if (fhlen != 0 && fhlen != NFSX_V3FH) {
867                         *errorp = EBADRPC;
868                         return(-2);
869                 }
870         } else {
871                 fhlen = NFSX_V2FH;
872         }
873         if (fhlen != 0) {
874                 tl = nfsm_dissect(info, fhlen);
875                 if (tl == NULL) {
876                         *errorp = EBADRPC;
877                         return(-1);
878                 }
879                 bcopy(tl, fhp, fhlen);
880         } else {
881                 bzero(fhp, NFSX_V3FH);
882         }
883         return(0);
884 }
885
886 void *
887 _nfsm_clget(nfsm_info_t info, struct mbuf *mp1, struct mbuf *mp2,
888            char *bp, char *be)
889 {
890         u_int32_t *tl;
891
892         if (bp >= be) {
893                 if (mp1 == info->mb)
894                         mp1->m_len += bp - info->bpos;
895                 mp1 = m_getcl(MB_WAIT, MT_DATA, 0);
896                 mp1->m_len = MCLBYTES;
897                 mp2->m_next = mp1;
898                 mp2 = mp1;
899                 bp = mtod(mp1, caddr_t);
900                 be = bp + mp1->m_len;
901         }
902         tl = (u_int32_t *)bp;
903         return (tl);
904 }
905
906 int
907 nfsm_srvsattr(nfsm_info_t info, struct vattr *vap)
908 {
909         u_int32_t *tl;
910         int error = 0;
911
912         NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
913         if (*tl == nfs_true) {
914                 NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
915                 vap->va_mode = nfstov_mode(*tl);
916         }
917         NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
918         if (*tl == nfs_true) {
919                 NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
920                 vap->va_uid = fxdr_unsigned(uid_t, *tl);
921         }
922         NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
923         if (*tl == nfs_true) {
924                 NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
925                 vap->va_gid = fxdr_unsigned(gid_t, *tl);
926         }
927         NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
928         if (*tl == nfs_true) {
929                 NULLOUT(tl = nfsm_dissect(info, 2 * NFSX_UNSIGNED));
930                 vap->va_size = fxdr_hyper(tl);
931         }
932         NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
933         switch (fxdr_unsigned(int, *tl)) {
934         case NFSV3SATTRTIME_TOCLIENT:
935                 NULLOUT(tl = nfsm_dissect(info, 2 * NFSX_UNSIGNED));
936                 fxdr_nfsv3time(tl, &vap->va_atime);
937                 break;
938         case NFSV3SATTRTIME_TOSERVER:
939                 getnanotime(&vap->va_atime);
940                 break;
941         };
942         NULLOUT(tl = nfsm_dissect(info, NFSX_UNSIGNED));
943         switch (fxdr_unsigned(int, *tl)) {
944         case NFSV3SATTRTIME_TOCLIENT:
945                 NULLOUT(tl = nfsm_dissect(info, 2 * NFSX_UNSIGNED));
946                 fxdr_nfsv3time(tl, &vap->va_mtime);
947                 break;
948         case NFSV3SATTRTIME_TOSERVER:
949                 getnanotime(&vap->va_mtime);
950                 break;
951         }
952 nfsmout:
953         return (error);
954 }
955
956 /*
957  * copies mbuf chain to the uio scatter/gather list
958  */
959 int
960 nfsm_mbuftouio(struct mbuf **mrep, struct uio *uiop, int siz, caddr_t *dpos)
961 {
962         char *mbufcp, *uiocp;
963         int xfer, left, len;
964         struct mbuf *mp;
965         long uiosiz, rem;
966         int error = 0;
967
968         mp = *mrep;
969         mbufcp = *dpos;
970         len = mtod(mp, caddr_t)+mp->m_len-mbufcp;
971         rem = nfsm_rndup(siz)-siz;
972         while (siz > 0) {
973                 if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL)
974                         return (EFBIG);
975                 left = uiop->uio_iov->iov_len;
976                 uiocp = uiop->uio_iov->iov_base;
977                 if (left > siz)
978                         left = siz;
979                 uiosiz = left;
980                 while (left > 0) {
981                         while (len == 0) {
982                                 mp = mp->m_next;
983                                 if (mp == NULL)
984                                         return (EBADRPC);
985                                 mbufcp = mtod(mp, caddr_t);
986                                 len = mp->m_len;
987                         }
988                         xfer = (left > len) ? len : left;
989 #ifdef notdef
990                         /* Not Yet.. */
991                         if (uiop->uio_iov->iov_op != NULL)
992                                 (*(uiop->uio_iov->iov_op))
993                                 (mbufcp, uiocp, xfer);
994                         else
995 #endif
996                         if (uiop->uio_segflg == UIO_SYSSPACE)
997                                 bcopy(mbufcp, uiocp, xfer);
998                         else
999                                 copyout(mbufcp, uiocp, xfer);
1000                         left -= xfer;
1001                         len -= xfer;
1002                         mbufcp += xfer;
1003                         uiocp += xfer;
1004                         uiop->uio_offset += xfer;
1005                         uiop->uio_resid -= xfer;
1006                 }
1007                 if (uiop->uio_iov->iov_len <= siz) {
1008                         uiop->uio_iovcnt--;
1009                         uiop->uio_iov++;
1010                 } else {
1011                         uiop->uio_iov->iov_base = (char *)uiop->uio_iov->iov_base + uiosiz;
1012                         uiop->uio_iov->iov_len -= uiosiz;
1013                 }
1014                 siz -= uiosiz;
1015         }
1016         *dpos = mbufcp;
1017         *mrep = mp;
1018         if (rem > 0) {
1019                 if (len < rem)
1020                         error = nfs_adv(mrep, dpos, rem, len);
1021                 else
1022                         *dpos += rem;
1023         }
1024         return (error);
1025 }
1026
1027 /*
1028  * copies a uio scatter/gather list to an mbuf chain.
1029  * NOTE: can ony handle iovcnt == 1
1030  */
1031 int
1032 nfsm_uiotombuf(struct uio *uiop, struct mbuf **mq, int siz, caddr_t *bpos)
1033 {
1034         char *uiocp;
1035         struct mbuf *mp, *mp2;
1036         int xfer, left, mlen;
1037         int uiosiz, rem;
1038         boolean_t getcluster;
1039         char *cp;
1040
1041 #ifdef DIAGNOSTIC
1042         if (uiop->uio_iovcnt != 1)
1043                 panic("nfsm_uiotombuf: iovcnt != 1");
1044 #endif
1045
1046         if (siz >= MINCLSIZE)
1047                 getcluster = TRUE;
1048         else
1049                 getcluster = FALSE;
1050         rem = nfsm_rndup(siz) - siz;
1051         mp = mp2 = *mq;
1052         while (siz > 0) {
1053                 left = uiop->uio_iov->iov_len;
1054                 uiocp = uiop->uio_iov->iov_base;
1055                 if (left > siz)
1056                         left = siz;
1057                 uiosiz = left;
1058                 while (left > 0) {
1059                         mlen = M_TRAILINGSPACE(mp);
1060                         if (mlen == 0) {
1061                                 if (getcluster)
1062                                         mp = m_getcl(MB_WAIT, MT_DATA, 0);
1063                                 else
1064                                         mp = m_get(MB_WAIT, MT_DATA);
1065                                 mp->m_len = 0;
1066                                 mp2->m_next = mp;
1067                                 mp2 = mp;
1068                                 mlen = M_TRAILINGSPACE(mp);
1069                         }
1070                         xfer = (left > mlen) ? mlen : left;
1071 #ifdef notdef
1072                         /* Not Yet.. */
1073                         if (uiop->uio_iov->iov_op != NULL)
1074                                 (*(uiop->uio_iov->iov_op))
1075                                 (uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
1076                         else
1077 #endif
1078                         if (uiop->uio_segflg == UIO_SYSSPACE)
1079                                 bcopy(uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
1080                         else
1081                                 copyin(uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
1082                         mp->m_len += xfer;
1083                         left -= xfer;
1084                         uiocp += xfer;
1085                         uiop->uio_offset += xfer;
1086                         uiop->uio_resid -= xfer;
1087                 }
1088                 uiop->uio_iov->iov_base = (char *)uiop->uio_iov->iov_base + uiosiz;
1089                 uiop->uio_iov->iov_len -= uiosiz;
1090                 siz -= uiosiz;
1091         }
1092         if (rem > 0) {
1093                 if (rem > M_TRAILINGSPACE(mp)) {
1094                         MGET(mp, MB_WAIT, MT_DATA);
1095                         mp->m_len = 0;
1096                         mp2->m_next = mp;
1097                 }
1098                 cp = mtod(mp, caddr_t)+mp->m_len;
1099                 for (left = 0; left < rem; left++)
1100                         *cp++ = '\0';
1101                 mp->m_len += rem;
1102                 *bpos = cp;
1103         } else
1104                 *bpos = mtod(mp, caddr_t)+mp->m_len;
1105         *mq = mp;
1106         return (0);
1107 }
1108
1109 /*
1110  * Help break down an mbuf chain by setting the first siz bytes contiguous
1111  * pointed to by returned val.
1112  * This is used by the macros nfsm_dissect and nfsm_dissecton for tough
1113  * cases. (The macros use the vars. dpos and dpos2)
1114  */
1115 int
1116 nfsm_disct(struct mbuf **mdp, caddr_t *dposp, int siz, int left, caddr_t *cp2)
1117 {
1118         struct mbuf *mp, *mp2;
1119         int siz2, xfer;
1120         caddr_t p;
1121
1122         mp = *mdp;
1123         while (left == 0) {
1124                 *mdp = mp = mp->m_next;
1125                 if (mp == NULL)
1126                         return (EBADRPC);
1127                 left = mp->m_len;
1128                 *dposp = mtod(mp, caddr_t);
1129         }
1130         if (left >= siz) {
1131                 *cp2 = *dposp;
1132                 *dposp += siz;
1133         } else if (mp->m_next == NULL) {
1134                 return (EBADRPC);
1135         } else if (siz > MHLEN) {
1136                 panic("nfs S too big");
1137         } else {
1138                 MGET(mp2, MB_WAIT, MT_DATA);
1139                 mp2->m_next = mp->m_next;
1140                 mp->m_next = mp2;
1141                 mp->m_len -= left;
1142                 mp = mp2;
1143                 *cp2 = p = mtod(mp, caddr_t);
1144                 bcopy(*dposp, p, left);         /* Copy what was left */
1145                 siz2 = siz-left;
1146                 p += left;
1147                 mp2 = mp->m_next;
1148                 /* Loop around copying up the siz2 bytes */
1149                 while (siz2 > 0) {
1150                         if (mp2 == NULL)
1151                                 return (EBADRPC);
1152                         xfer = (siz2 > mp2->m_len) ? mp2->m_len : siz2;
1153                         if (xfer > 0) {
1154                                 bcopy(mtod(mp2, caddr_t), p, xfer);
1155                                 mp2->m_len -= xfer;
1156                                 mp2->m_data += xfer;
1157                                 p += xfer;
1158                                 siz2 -= xfer;
1159                         }
1160                         if (siz2 > 0)
1161                                 mp2 = mp2->m_next;
1162                 }
1163                 mp->m_len = siz;
1164                 *mdp = mp2;
1165                 *dposp = mtod(mp2, caddr_t);
1166         }
1167         return (0);
1168 }
1169
1170 /*
1171  * Advance the position in the mbuf chain.
1172  */
1173 int
1174 nfs_adv(struct mbuf **mdp, caddr_t *dposp, int offs, int left)
1175 {
1176         struct mbuf *m;
1177         int s;
1178
1179         m = *mdp;
1180         s = left;
1181         while (s < offs) {
1182                 offs -= s;
1183                 m = m->m_next;
1184                 if (m == NULL)
1185                         return (EBADRPC);
1186                 s = m->m_len;
1187         }
1188         *mdp = m;
1189         *dposp = mtod(m, caddr_t)+offs;
1190         return (0);
1191 }
1192
1193 /*
1194  * Copy a string into mbufs for the hard cases...
1195  */
1196 int
1197 nfsm_strtmbuf(struct mbuf **mb, char **bpos, const char *cp, long siz)
1198 {
1199         struct mbuf *m1 = NULL, *m2;
1200         long left, xfer, len, tlen;
1201         u_int32_t *tl;
1202         int putsize;
1203
1204         putsize = 1;
1205         m2 = *mb;
1206         left = M_TRAILINGSPACE(m2);
1207         if (left > 0) {
1208                 tl = ((u_int32_t *)(*bpos));
1209                 *tl++ = txdr_unsigned(siz);
1210                 putsize = 0;
1211                 left -= NFSX_UNSIGNED;
1212                 m2->m_len += NFSX_UNSIGNED;
1213                 if (left > 0) {
1214                         bcopy(cp, (caddr_t) tl, left);
1215                         siz -= left;
1216                         cp += left;
1217                         m2->m_len += left;
1218                         left = 0;
1219                 }
1220         }
1221         /* Loop around adding mbufs */
1222         while (siz > 0) {
1223                 int msize;
1224
1225                 m1 = m_getl(siz, MB_WAIT, MT_DATA, 0, &msize);
1226                 m1->m_len = msize;
1227                 m2->m_next = m1;
1228                 m2 = m1;
1229                 tl = mtod(m1, u_int32_t *);
1230                 tlen = 0;
1231                 if (putsize) {
1232                         *tl++ = txdr_unsigned(siz);
1233                         m1->m_len -= NFSX_UNSIGNED;
1234                         tlen = NFSX_UNSIGNED;
1235                         putsize = 0;
1236                 }
1237                 if (siz < m1->m_len) {
1238                         len = nfsm_rndup(siz);
1239                         xfer = siz;
1240                         if (xfer < len)
1241                                 *(tl+(xfer>>2)) = 0;
1242                 } else {
1243                         xfer = len = m1->m_len;
1244                 }
1245                 bcopy(cp, (caddr_t) tl, xfer);
1246                 m1->m_len = len+tlen;
1247                 siz -= xfer;
1248                 cp += xfer;
1249         }
1250         *mb = m1;
1251         *bpos = mtod(m1, caddr_t)+m1->m_len;
1252         return (0);
1253 }
1254
1255 /*
1256  * A fiddled version of m_adj() that ensures null fill to a long
1257  * boundary and only trims off the back end
1258  */
1259 void
1260 nfsm_adj(struct mbuf *mp, int len, int nul)
1261 {
1262         struct mbuf *m;
1263         int count, i;
1264         char *cp;
1265
1266         /*
1267          * Trim from tail.  Scan the mbuf chain,
1268          * calculating its length and finding the last mbuf.
1269          * If the adjustment only affects this mbuf, then just
1270          * adjust and return.  Otherwise, rescan and truncate
1271          * after the remaining size.
1272          */
1273         count = 0;
1274         m = mp;
1275         for (;;) {
1276                 count += m->m_len;
1277                 if (m->m_next == NULL)
1278                         break;
1279                 m = m->m_next;
1280         }
1281         if (m->m_len > len) {
1282                 m->m_len -= len;
1283                 if (nul > 0) {
1284                         cp = mtod(m, caddr_t)+m->m_len-nul;
1285                         for (i = 0; i < nul; i++)
1286                                 *cp++ = '\0';
1287                 }
1288                 return;
1289         }
1290         count -= len;
1291         if (count < 0)
1292                 count = 0;
1293         /*
1294          * Correct length for chain is "count".
1295          * Find the mbuf with last data, adjust its length,
1296          * and toss data from remaining mbufs on chain.
1297          */
1298         for (m = mp; m; m = m->m_next) {
1299                 if (m->m_len >= count) {
1300                         m->m_len = count;
1301                         if (nul > 0) {
1302                                 cp = mtod(m, caddr_t)+m->m_len-nul;
1303                                 for (i = 0; i < nul; i++)
1304                                         *cp++ = '\0';
1305                         }
1306                         break;
1307                 }
1308                 count -= m->m_len;
1309         }
1310         for (m = m->m_next;m;m = m->m_next)
1311                 m->m_len = 0;
1312 }
1313
1314 /*
1315  * Make these functions instead of macros, so that the kernel text size
1316  * doesn't get too big...
1317  */
1318 void
1319 nfsm_srvwcc_data(nfsm_info_t info, struct nfsrv_descript *nfsd,
1320                  int before_ret, struct vattr *before_vap,
1321                  int after_ret, struct vattr *after_vap)
1322 {
1323         u_int32_t *tl;
1324
1325         /*
1326          * before_ret is 0 if before_vap is valid, non-zero if it isn't.
1327          */
1328         if (before_ret) {
1329                 tl = nfsm_build(info, NFSX_UNSIGNED);
1330                 *tl = nfs_false;
1331         } else {
1332                 tl = nfsm_build(info, 7 * NFSX_UNSIGNED);
1333                 *tl++ = nfs_true;
1334                 txdr_hyper(before_vap->va_size, tl);
1335                 tl += 2;
1336                 txdr_nfsv3time(&(before_vap->va_mtime), tl);
1337                 tl += 2;
1338                 txdr_nfsv3time(&(before_vap->va_ctime), tl);
1339         }
1340         nfsm_srvpostop_attr(info, nfsd, after_ret, after_vap);
1341 }
1342
1343 void
1344 nfsm_srvpostop_attr(nfsm_info_t info, struct nfsrv_descript *nfsd,
1345                    int after_ret, struct vattr *after_vap)
1346 {
1347         struct nfs_fattr *fp;
1348         u_int32_t *tl;
1349
1350         if (after_ret) {
1351                 tl = nfsm_build(info, NFSX_UNSIGNED);
1352                 *tl = nfs_false;
1353         } else {
1354                 tl = nfsm_build(info, NFSX_UNSIGNED + NFSX_V3FATTR);
1355                 *tl++ = nfs_true;
1356                 fp = (struct nfs_fattr *)tl;
1357                 nfsm_srvfattr(nfsd, after_vap, fp);
1358         }
1359 }
1360
1361 void
1362 nfsm_srvfattr(struct nfsrv_descript *nfsd, struct vattr *vap,
1363               struct nfs_fattr *fp)
1364 {
1365         /*
1366          * NFS seems to truncate nlink to 16 bits, don't let it overflow.
1367          */
1368         if (vap->va_nlink > 65535)
1369                 fp->fa_nlink = 65535;
1370         else
1371                 fp->fa_nlink = txdr_unsigned(vap->va_nlink);
1372         fp->fa_uid = txdr_unsigned(vap->va_uid);
1373         fp->fa_gid = txdr_unsigned(vap->va_gid);
1374         if (nfsd->nd_flag & ND_NFSV3) {
1375                 fp->fa_type = vtonfsv3_type(vap->va_type);
1376                 fp->fa_mode = vtonfsv3_mode(vap->va_mode);
1377                 txdr_hyper(vap->va_size, &fp->fa3_size);
1378                 txdr_hyper(vap->va_bytes, &fp->fa3_used);
1379                 fp->fa3_rdev.specdata1 = txdr_unsigned(vap->va_rmajor);
1380                 fp->fa3_rdev.specdata2 = txdr_unsigned(vap->va_rminor);
1381                 fp->fa3_fsid.nfsuquad[0] = 0;
1382                 fp->fa3_fsid.nfsuquad[1] = txdr_unsigned(vap->va_fsid);
1383                 txdr_hyper(vap->va_fileid, &fp->fa3_fileid);
1384                 txdr_nfsv3time(&vap->va_atime, &fp->fa3_atime);
1385                 txdr_nfsv3time(&vap->va_mtime, &fp->fa3_mtime);
1386                 txdr_nfsv3time(&vap->va_ctime, &fp->fa3_ctime);
1387         } else {
1388                 fp->fa_type = vtonfsv2_type(vap->va_type);
1389                 fp->fa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
1390                 fp->fa2_size = txdr_unsigned(vap->va_size);
1391                 fp->fa2_blocksize = txdr_unsigned(vap->va_blocksize);
1392                 if (vap->va_type == VFIFO)
1393                         fp->fa2_rdev = 0xffffffff;
1394                 else
1395                         fp->fa2_rdev = txdr_unsigned(makeudev(vap->va_rmajor, vap->va_rminor));
1396                 fp->fa2_blocks = txdr_unsigned(vap->va_bytes / NFS_FABLKSIZE);
1397                 fp->fa2_fsid = txdr_unsigned(vap->va_fsid);
1398                 fp->fa2_fileid = txdr_unsigned(vap->va_fileid);
1399                 txdr_nfsv2time(&vap->va_atime, &fp->fa2_atime);
1400                 txdr_nfsv2time(&vap->va_mtime, &fp->fa2_mtime);
1401                 txdr_nfsv2time(&vap->va_ctime, &fp->fa2_ctime);
1402         }
1403 }