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