![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nfs_subs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / nfs|
Return to nfs_subs.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / nfs |
1.1 ! root 1: /* ! 2: * Copyright (c) 1989 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * This code is derived from software contributed to Berkeley by ! 6: * Rick Macklem at The University of Guelph. ! 7: * ! 8: * Redistribution is only permitted until one year after the first shipment ! 9: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and ! 10: * binary forms are permitted provided that: (1) source distributions retain ! 11: * this entire copyright notice and comment, and (2) distributions including ! 12: * binaries display the following acknowledgement: This product includes ! 13: * software developed by the University of California, Berkeley and its ! 14: * contributors'' in the documentation or other materials provided with the ! 15: * distribution and in all advertising materials mentioning features or use ! 16: * of this software. Neither the name of the University nor the names of ! 17: * its contributors may be used to endorse or promote products derived from ! 18: * this software without specific prior written permission. ! 19: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 20: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 21: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 22: * ! 23: * @(#)nfs_subs.c 7.29 (Berkeley) 7/26/90 ! 24: */ ! 25: ! 26: /* ! 27: * These functions support the macros and help fiddle mbuf chains for ! 28: * the nfs op functions. They do things like create the rpc header and ! 29: * copy data between mbuf chains and uio lists. ! 30: */ ! 31: #include "param.h" ! 32: #include "user.h" ! 33: #include "proc.h" ! 34: #include "systm.h" ! 35: #include "kernel.h" ! 36: #include "mount.h" ! 37: #include "file.h" ! 38: #include "vnode.h" ! 39: #include "mbuf.h" ! 40: #include "errno.h" ! 41: #include "map.h" ! 42: #include "rpcv2.h" ! 43: #include "nfsv2.h" ! 44: #include "nfsnode.h" ! 45: #include "nfs.h" ! 46: #include "nfsiom.h" ! 47: #include "xdr_subs.h" ! 48: #include "nfsm_subs.h" ! 49: ! 50: #define TRUE 1 ! 51: #define FALSE 0 ! 52: ! 53: /* ! 54: * Data items converted to xdr at startup, since they are constant ! 55: * This is kinda hokey, but may save a little time doing byte swaps ! 56: */ ! 57: u_long nfs_procids[NFS_NPROCS]; ! 58: u_long nfs_xdrneg1; ! 59: u_long rpc_call, rpc_vers, rpc_reply, rpc_msgdenied, ! 60: rpc_mismatch, rpc_auth_unix, rpc_msgaccepted; ! 61: u_long nfs_vers, nfs_prog, nfs_true, nfs_false; ! 62: /* And other global data */ ! 63: static u_long *rpc_uidp = (u_long *)0; ! 64: static u_long nfs_xid = 1; ! 65: static char *rpc_unixauth; ! 66: extern long hostid; ! 67: enum vtype ntov_type[7] = { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VNON }; ! 68: extern struct proc *nfs_iodwant[NFS_MAXASYNCDAEMON]; ! 69: extern struct map nfsmap[NFS_MSIZ]; ! 70: extern struct nfsreq nfsreqh; ! 71: ! 72: /* Function ret types */ ! 73: static char *nfs_unixauth(); ! 74: ! 75: /* ! 76: * Maximum number of groups passed through to NFS server. ! 77: * According to RFC1057 it should be 16. ! 78: * For release 3.X systems, the maximum value is 8. ! 79: * For some other servers, the maximum value is 10. ! 80: */ ! 81: int numgrps = 8; ! 82: ! 83: /* ! 84: * Create the header for an rpc request packet ! 85: * The function nfs_unixauth() creates a unix style authorization string ! 86: * and returns a ptr to it. ! 87: * The hsiz is the size of the rest of the nfs request header. ! 88: * (just used to decide if a cluster is a good idea) ! 89: * nb: Note that the prog, vers and procid args are already in xdr byte order ! 90: */ ! 91: struct mbuf *nfsm_reqh(prog, vers, procid, cred, hsiz, bpos, mb, retxid) ! 92: u_long prog; ! 93: u_long vers; ! 94: u_long procid; ! 95: struct ucred *cred; ! 96: int hsiz; ! 97: caddr_t *bpos; ! 98: struct mbuf **mb; ! 99: u_long *retxid; ! 100: { ! 101: register struct mbuf *mreq, *m; ! 102: register u_long *p; ! 103: struct mbuf *m1; ! 104: char *ap; ! 105: int asiz, siz; ! 106: ! 107: NFSMGETHDR(mreq); ! 108: asiz = ((((cred->cr_ngroups - 1) > numgrps) ? numgrps : ! 109: (cred->cr_ngroups - 1)) << 2); ! 110: #ifdef FILLINHOST ! 111: asiz += nfsm_rndup(hostnamelen)+(9*NFSX_UNSIGNED); ! 112: #else ! 113: asiz += 9*NFSX_UNSIGNED; ! 114: #endif ! 115: ! 116: /* If we need a lot, alloc a cluster ?? */ ! 117: if ((asiz+hsiz+RPC_SIZ) > MHLEN) ! 118: MCLGET(mreq, M_WAIT); ! 119: mreq->m_len = NFSMSIZ(mreq); ! 120: siz = mreq->m_len; ! 121: m1 = mreq; ! 122: /* ! 123: * Alloc enough mbufs ! 124: * We do it now to avoid all sleeps after the call to nfs_unixauth() ! 125: */ ! 126: while ((asiz+RPC_SIZ) > siz) { ! 127: MGET(m, M_WAIT, MT_DATA); ! 128: m1->m_next = m; ! 129: m->m_len = MLEN; ! 130: siz += MLEN; ! 131: m1 = m; ! 132: } ! 133: p = mtod(mreq, u_long *); ! 134: *p++ = *retxid = txdr_unsigned(++nfs_xid); ! 135: *p++ = rpc_call; ! 136: *p++ = rpc_vers; ! 137: *p++ = prog; ! 138: *p++ = vers; ! 139: *p++ = procid; ! 140: ! 141: /* Now we can call nfs_unixauth() and copy it in */ ! 142: ap = nfs_unixauth(cred); ! 143: m = mreq; ! 144: siz = m->m_len-RPC_SIZ; ! 145: if (asiz <= siz) { ! 146: bcopy(ap, (caddr_t)p, asiz); ! 147: m->m_len = asiz+RPC_SIZ; ! 148: } else { ! 149: bcopy(ap, (caddr_t)p, siz); ! 150: ap += siz; ! 151: asiz -= siz; ! 152: while (asiz > 0) { ! 153: siz = (asiz > MLEN) ? MLEN : asiz; ! 154: m = m->m_next; ! 155: bcopy(ap, mtod(m, caddr_t), siz); ! 156: m->m_len = siz; ! 157: asiz -= siz; ! 158: ap += siz; ! 159: } ! 160: } ! 161: ! 162: /* Finally, return values */ ! 163: *mb = m; ! 164: *bpos = mtod(m, caddr_t)+m->m_len; ! 165: return (mreq); ! 166: } ! 167: ! 168: /* ! 169: * copies mbuf chain to the uio scatter/gather list ! 170: */ ! 171: nfsm_mbuftouio(mrep, uiop, siz, dpos) ! 172: struct mbuf **mrep; ! 173: register struct uio *uiop; ! 174: int siz; ! 175: caddr_t *dpos; ! 176: { ! 177: register char *mbufcp, *uiocp; ! 178: register int xfer, left, len; ! 179: register struct mbuf *mp; ! 180: long uiosiz, rem; ! 181: int error = 0; ! 182: ! 183: mp = *mrep; ! 184: mbufcp = *dpos; ! 185: len = mtod(mp, caddr_t)+mp->m_len-mbufcp; ! 186: rem = nfsm_rndup(siz)-siz; ! 187: while (siz > 0) { ! 188: if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL) ! 189: return (EFBIG); ! 190: left = uiop->uio_iov->iov_len; ! 191: uiocp = uiop->uio_iov->iov_base; ! 192: if (left > siz) ! 193: left = siz; ! 194: uiosiz = left; ! 195: while (left > 0) { ! 196: while (len == 0) { ! 197: mp = mp->m_next; ! 198: if (mp == NULL) ! 199: return (EBADRPC); ! 200: mbufcp = mtod(mp, caddr_t); ! 201: len = mp->m_len; ! 202: } ! 203: xfer = (left > len) ? len : left; ! 204: #ifdef notdef ! 205: /* Not Yet.. */ ! 206: if (uiop->uio_iov->iov_op != NULL) ! 207: (*(uiop->uio_iov->iov_op)) ! 208: (mbufcp, uiocp, xfer); ! 209: else ! 210: #endif ! 211: if (uiop->uio_segflg == UIO_SYSSPACE) ! 212: bcopy(mbufcp, uiocp, xfer); ! 213: else ! 214: copyout(mbufcp, uiocp, xfer); ! 215: left -= xfer; ! 216: len -= xfer; ! 217: mbufcp += xfer; ! 218: uiocp += xfer; ! 219: uiop->uio_offset += xfer; ! 220: uiop->uio_resid -= xfer; ! 221: } ! 222: if (uiop->uio_iov->iov_len <= siz) { ! 223: uiop->uio_iovcnt--; ! 224: uiop->uio_iov++; ! 225: } else { ! 226: uiop->uio_iov->iov_base += uiosiz; ! 227: uiop->uio_iov->iov_len -= uiosiz; ! 228: } ! 229: siz -= uiosiz; ! 230: } ! 231: *dpos = mbufcp; ! 232: *mrep = mp; ! 233: if (rem > 0) { ! 234: if (len < rem) ! 235: error = nfs_adv(mrep, dpos, rem, len); ! 236: else ! 237: *dpos += rem; ! 238: } ! 239: return (error); ! 240: } ! 241: ! 242: /* ! 243: * copies a uio scatter/gather list to an mbuf chain... ! 244: */ ! 245: nfsm_uiotombuf(uiop, mq, siz, bpos) ! 246: register struct uio *uiop; ! 247: struct mbuf **mq; ! 248: int siz; ! 249: caddr_t *bpos; ! 250: { ! 251: register char *uiocp; ! 252: register struct mbuf *mp, *mp2; ! 253: register int xfer, left, len; ! 254: int uiosiz, clflg, rem; ! 255: char *cp; ! 256: ! 257: if (siz > MLEN) /* or should it >= MCLBYTES ?? */ ! 258: clflg = 1; ! 259: else ! 260: clflg = 0; ! 261: rem = nfsm_rndup(siz)-siz; ! 262: mp2 = *mq; ! 263: while (siz > 0) { ! 264: if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL) ! 265: return (EINVAL); ! 266: left = uiop->uio_iov->iov_len; ! 267: uiocp = uiop->uio_iov->iov_base; ! 268: if (left > siz) ! 269: left = siz; ! 270: uiosiz = left; ! 271: while (left > 0) { ! 272: MGET(mp, M_WAIT, MT_DATA); ! 273: if (clflg) ! 274: MCLGET(mp, M_WAIT); ! 275: mp->m_len = NFSMSIZ(mp); ! 276: mp2->m_next = mp; ! 277: mp2 = mp; ! 278: xfer = (left > mp->m_len) ? mp->m_len : left; ! 279: #ifdef notdef ! 280: /* Not Yet.. */ ! 281: if (uiop->uio_iov->iov_op != NULL) ! 282: (*(uiop->uio_iov->iov_op)) ! 283: (uiocp, mtod(mp, caddr_t), xfer); ! 284: else ! 285: #endif ! 286: if (uiop->uio_segflg == UIO_SYSSPACE) ! 287: bcopy(uiocp, mtod(mp, caddr_t), xfer); ! 288: else ! 289: copyin(uiocp, mtod(mp, caddr_t), xfer); ! 290: len = mp->m_len; ! 291: mp->m_len = xfer; ! 292: left -= xfer; ! 293: uiocp += xfer; ! 294: uiop->uio_offset += xfer; ! 295: uiop->uio_resid -= xfer; ! 296: } ! 297: if (uiop->uio_iov->iov_len <= siz) { ! 298: uiop->uio_iovcnt--; ! 299: uiop->uio_iov++; ! 300: } else { ! 301: uiop->uio_iov->iov_base += uiosiz; ! 302: uiop->uio_iov->iov_len -= uiosiz; ! 303: } ! 304: siz -= uiosiz; ! 305: } ! 306: if (rem > 0) { ! 307: if (rem > (len-mp->m_len)) { ! 308: MGET(mp, M_WAIT, MT_DATA); ! 309: mp->m_len = 0; ! 310: mp2->m_next = mp; ! 311: } ! 312: cp = mtod(mp, caddr_t)+mp->m_len; ! 313: for (left = 0; left < rem; left++) ! 314: *cp++ = '\0'; ! 315: mp->m_len += rem; ! 316: *bpos = cp; ! 317: } else ! 318: *bpos = mtod(mp, caddr_t)+mp->m_len; ! 319: *mq = mp; ! 320: return (0); ! 321: } ! 322: ! 323: /* ! 324: * Help break down an mbuf chain by setting the first siz bytes contiguous ! 325: * pointed to by returned val. ! 326: * If Updateflg == True we can overwrite the first part of the mbuf data ! 327: * This is used by the macros nfsm_disect and nfsm_disecton for tough ! 328: * cases. (The macros use the vars. dpos and dpos2) ! 329: */ ! 330: nfsm_disct(mdp, dposp, siz, left, updateflg, cp2) ! 331: struct mbuf **mdp; ! 332: caddr_t *dposp; ! 333: int siz; ! 334: int left; ! 335: int updateflg; ! 336: caddr_t *cp2; ! 337: { ! 338: register struct mbuf *mp, *mp2; ! 339: register int siz2, xfer; ! 340: register caddr_t p; ! 341: ! 342: mp = *mdp; ! 343: while (left == 0) { ! 344: *mdp = mp = mp->m_next; ! 345: if (mp == NULL) ! 346: return (EBADRPC); ! 347: left = mp->m_len; ! 348: *dposp = mtod(mp, caddr_t); ! 349: } ! 350: if (left >= siz) { ! 351: *cp2 = *dposp; ! 352: *dposp += siz; ! 353: } else if (mp->m_next == NULL) { ! 354: return (EBADRPC); ! 355: } else if (siz > MHLEN) { ! 356: panic("nfs S too big"); ! 357: } else { ! 358: /* Iff update, you can overwrite, else must alloc new mbuf */ ! 359: if (updateflg) { ! 360: NFSMINOFF(mp); ! 361: } else { ! 362: MGET(mp2, M_WAIT, MT_DATA); ! 363: mp2->m_next = mp->m_next; ! 364: mp->m_next = mp2; ! 365: mp->m_len -= left; ! 366: mp = mp2; ! 367: } ! 368: *cp2 = p = mtod(mp, caddr_t); ! 369: bcopy(*dposp, p, left); /* Copy what was left */ ! 370: siz2 = siz-left; ! 371: p += left; ! 372: mp2 = mp->m_next; ! 373: /* Loop around copying up the siz2 bytes */ ! 374: while (siz2 > 0) { ! 375: if (mp2 == NULL) ! 376: return (EBADRPC); ! 377: xfer = (siz2 > mp2->m_len) ? mp2->m_len : siz2; ! 378: if (xfer > 0) { ! 379: bcopy(mtod(mp2, caddr_t), p, xfer); ! 380: NFSMADV(mp2, xfer); ! 381: mp2->m_len -= xfer; ! 382: p += xfer; ! 383: siz2 -= xfer; ! 384: } ! 385: if (siz2 > 0) ! 386: mp2 = mp2->m_next; ! 387: } ! 388: mp->m_len = siz; ! 389: *mdp = mp2; ! 390: *dposp = mtod(mp2, caddr_t); ! 391: } ! 392: return (0); ! 393: } ! 394: ! 395: /* ! 396: * Advance the position in the mbuf chain. ! 397: */ ! 398: nfs_adv(mdp, dposp, offs, left) ! 399: struct mbuf **mdp; ! 400: caddr_t *dposp; ! 401: int offs; ! 402: int left; ! 403: { ! 404: register struct mbuf *m; ! 405: register int s; ! 406: ! 407: m = *mdp; ! 408: s = left; ! 409: while (s < offs) { ! 410: offs -= s; ! 411: m = m->m_next; ! 412: if (m == NULL) ! 413: return (EBADRPC); ! 414: s = m->m_len; ! 415: } ! 416: *mdp = m; ! 417: *dposp = mtod(m, caddr_t)+offs; ! 418: return (0); ! 419: } ! 420: ! 421: /* ! 422: * Copy a string into mbufs for the hard cases... ! 423: */ ! 424: nfsm_strtmbuf(mb, bpos, cp, siz) ! 425: struct mbuf **mb; ! 426: char **bpos; ! 427: char *cp; ! 428: long siz; ! 429: { ! 430: register struct mbuf *m1, *m2; ! 431: long left, xfer, len, tlen; ! 432: u_long *p; ! 433: int putsize; ! 434: ! 435: putsize = 1; ! 436: m2 = *mb; ! 437: left = NFSMSIZ(m2)-m2->m_len; ! 438: if (left > 0) { ! 439: p = ((u_long *)(*bpos)); ! 440: *p++ = txdr_unsigned(siz); ! 441: putsize = 0; ! 442: left -= NFSX_UNSIGNED; ! 443: m2->m_len += NFSX_UNSIGNED; ! 444: if (left > 0) { ! 445: bcopy(cp, (caddr_t) p, left); ! 446: siz -= left; ! 447: cp += left; ! 448: m2->m_len += left; ! 449: left = 0; ! 450: } ! 451: } ! 452: /* Loop arround adding mbufs */ ! 453: while (siz > 0) { ! 454: MGET(m1, M_WAIT, MT_DATA); ! 455: if (siz > MLEN) ! 456: MCLGET(m1, M_WAIT); ! 457: m1->m_len = NFSMSIZ(m1); ! 458: m2->m_next = m1; ! 459: m2 = m1; ! 460: p = mtod(m1, u_long *); ! 461: tlen = 0; ! 462: if (putsize) { ! 463: *p++ = txdr_unsigned(siz); ! 464: m1->m_len -= NFSX_UNSIGNED; ! 465: tlen = NFSX_UNSIGNED; ! 466: putsize = 0; ! 467: } ! 468: if (siz < m1->m_len) { ! 469: len = nfsm_rndup(siz); ! 470: xfer = siz; ! 471: if (xfer < len) ! 472: *(p+(xfer>>2)) = 0; ! 473: } else { ! 474: xfer = len = m1->m_len; ! 475: } ! 476: bcopy(cp, (caddr_t) p, xfer); ! 477: m1->m_len = len+tlen; ! 478: siz -= xfer; ! 479: cp += xfer; ! 480: } ! 481: *mb = m1; ! 482: *bpos = mtod(m1, caddr_t)+m1->m_len; ! 483: return (0); ! 484: } ! 485: ! 486: /* ! 487: * Called once to initialize data structures... ! 488: */ ! 489: nfs_init() ! 490: { ! 491: register int i; ! 492: ! 493: rpc_vers = txdr_unsigned(RPC_VER2); ! 494: rpc_call = txdr_unsigned(RPC_CALL); ! 495: rpc_reply = txdr_unsigned(RPC_REPLY); ! 496: rpc_msgdenied = txdr_unsigned(RPC_MSGDENIED); ! 497: rpc_msgaccepted = txdr_unsigned(RPC_MSGACCEPTED); ! 498: rpc_mismatch = txdr_unsigned(RPC_MISMATCH); ! 499: rpc_auth_unix = txdr_unsigned(RPCAUTH_UNIX); ! 500: nfs_vers = txdr_unsigned(NFS_VER2); ! 501: nfs_prog = txdr_unsigned(NFS_PROG); ! 502: nfs_true = txdr_unsigned(TRUE); ! 503: nfs_false = txdr_unsigned(FALSE); ! 504: /* Loop thru nfs procids */ ! 505: for (i = 0; i < NFS_NPROCS; i++) ! 506: nfs_procids[i] = txdr_unsigned(i); ! 507: /* Ensure async daemons disabled */ ! 508: for (i = 0; i < NFS_MAXASYNCDAEMON; i++) ! 509: nfs_iodwant[i] = (struct proc *)0; ! 510: nfs_xdrneg1 = txdr_unsigned(-1); ! 511: nfs_nhinit(); /* Init the nfsnode table */ ! 512: nfsrv_initcache(); /* Init the server request cache */ ! 513: rminit(nfsmap, (long)NFS_MAPREG, (long)1, "nfs mapreg", NFS_MSIZ); ! 514: ! 515: /* ! 516: * Initialize reply list and start timer ! 517: */ ! 518: nfsreqh.r_prev = nfsreqh.r_next = &nfsreqh; ! 519: nfs_timer(); ! 520: } ! 521: ! 522: /* ! 523: * Fill in the rest of the rpc_unixauth and return it ! 524: */ ! 525: static char *nfs_unixauth(cr) ! 526: register struct ucred *cr; ! 527: { ! 528: register u_long *p; ! 529: register int i; ! 530: int ngr; ! 531: ! 532: /* Maybe someday there should be a cache of AUTH_SHORT's */ ! 533: if ((p = rpc_uidp) == NULL) { ! 534: #ifdef FILLINHOST ! 535: i = nfsm_rndup(hostnamelen)+(25*NFSX_UNSIGNED); ! 536: #else ! 537: i = 25*NFSX_UNSIGNED; ! 538: #endif ! 539: MALLOC(p, u_long *, i, M_TEMP, M_WAITOK); ! 540: bzero((caddr_t)p, i); ! 541: rpc_unixauth = (caddr_t)p; ! 542: *p++ = txdr_unsigned(RPCAUTH_UNIX); ! 543: p++; /* Fill in size later */ ! 544: *p++ = hostid; ! 545: #ifdef FILLINHOST ! 546: *p++ = txdr_unsigned(hostnamelen); ! 547: i = nfsm_rndup(hostnamelen); ! 548: bcopy(hostname, (caddr_t)p, hostnamelen); ! 549: p += (i>>2); ! 550: #else ! 551: *p++ = 0; ! 552: #endif ! 553: rpc_uidp = p; ! 554: } ! 555: *p++ = txdr_unsigned(cr->cr_uid); ! 556: *p++ = txdr_unsigned(cr->cr_groups[0]); ! 557: ngr = ((cr->cr_ngroups - 1) > numgrps) ? numgrps : (cr->cr_ngroups - 1); ! 558: *p++ = txdr_unsigned(ngr); ! 559: for (i = 1; i <= ngr; i++) ! 560: *p++ = txdr_unsigned(cr->cr_groups[i]); ! 561: /* And add the AUTH_NULL */ ! 562: *p++ = 0; ! 563: *p = 0; ! 564: i = (((caddr_t)p)-rpc_unixauth)-12; ! 565: p = (u_long *)(rpc_unixauth+4); ! 566: *p = txdr_unsigned(i); ! 567: return (rpc_unixauth); ! 568: } ! 569: ! 570: /* ! 571: * Attribute cache routines. ! 572: * nfs_loadattrcache() - loads or updates the cache contents from attributes ! 573: * that are on the mbuf list ! 574: * nfs_getattrcache() - returns valid attributes if found in cache, returns ! 575: * error otherwise ! 576: */ ! 577: ! 578: /* ! 579: * Load the attribute cache (that lives in the nfsnode entry) with ! 580: * the values on the mbuf list and ! 581: * Iff vap not NULL ! 582: * copy the attributes to *vaper ! 583: */ ! 584: nfs_loadattrcache(vpp, mdp, dposp, vaper) ! 585: struct vnode **vpp; ! 586: struct mbuf **mdp; ! 587: caddr_t *dposp; ! 588: struct vattr *vaper; ! 589: { ! 590: register struct vnode *vp = *vpp; ! 591: register struct vattr *vap; ! 592: register struct nfsv2_fattr *fp; ! 593: extern struct vnodeops spec_nfsv2nodeops; ! 594: register struct nfsnode *np; ! 595: register long t1; ! 596: caddr_t dpos, cp2; ! 597: int error = 0; ! 598: struct mbuf *md; ! 599: enum vtype type; ! 600: long rdev; ! 601: struct timeval mtime; ! 602: struct vnode *nvp; ! 603: ! 604: md = *mdp; ! 605: dpos = *dposp; ! 606: t1 = (mtod(md, caddr_t)+md->m_len)-dpos; ! 607: if (error = nfsm_disct(&md, &dpos, NFSX_FATTR, t1, TRUE, &cp2)) ! 608: return (error); ! 609: fp = (struct nfsv2_fattr *)cp2; ! 610: type = nfstov_type(fp->fa_type); ! 611: rdev = fxdr_unsigned(long, fp->fa_rdev); ! 612: fxdr_time(&fp->fa_mtime, &mtime); ! 613: /* ! 614: * If v_type == VNON it is a new node, so fill in the v_type, ! 615: * n_mtime fields. Check to see if it represents a special ! 616: * device, and if so, check for a possible alias. Once the ! 617: * correct vnode has been obtained, fill in the rest of the ! 618: * information. ! 619: */ ! 620: np = VTONFS(vp); ! 621: if (vp->v_type == VNON) { ! 622: if (type == VCHR && rdev == 0xffffffff) ! 623: vp->v_type = type = VFIFO; ! 624: else ! 625: vp->v_type = type; ! 626: if (vp->v_type == VFIFO) { ! 627: #ifdef FIFO ! 628: extern struct vnodeops fifo_nfsv2nodeops; ! 629: vp->v_op = &fifo_nfsv2nodeops; ! 630: #else ! 631: return (EOPNOTSUPP); ! 632: #endif /* FIFO */ ! 633: } ! 634: if (vp->v_type == VCHR || vp->v_type == VBLK) { ! 635: vp->v_op = &spec_nfsv2nodeops; ! 636: if (nvp = checkalias(vp, (dev_t)rdev, vp->v_mount)) { ! 637: /* ! 638: * Reinitialize aliased node. ! 639: */ ! 640: np = VTONFS(nvp); ! 641: np->n_vnode = nvp; ! 642: np->n_flag = 0; ! 643: nfs_lock(nvp); ! 644: bcopy((caddr_t)&VTONFS(vp)->n_fh, ! 645: (caddr_t)&np->n_fh, NFSX_FH); ! 646: insque(np, nfs_hash(&np->n_fh)); ! 647: np->n_attrstamp = 0; ! 648: np->n_sillyrename = (struct sillyrename *)0; ! 649: /* ! 650: * Discard unneeded vnode and update actual one ! 651: */ ! 652: vput(vp); ! 653: *vpp = nvp; ! 654: } ! 655: } ! 656: np->n_mtime = mtime.tv_sec; ! 657: } ! 658: vap = &np->n_vattr; ! 659: vap->va_type = type; ! 660: vap->va_mode = nfstov_mode(fp->fa_mode); ! 661: vap->va_nlink = fxdr_unsigned(u_short, fp->fa_nlink); ! 662: vap->va_uid = fxdr_unsigned(uid_t, fp->fa_uid); ! 663: vap->va_gid = fxdr_unsigned(gid_t, fp->fa_gid); ! 664: vap->va_size = fxdr_unsigned(u_long, fp->fa_size); ! 665: if ((np->n_flag & NMODIFIED) == 0 || vap->va_size > np->n_size) ! 666: np->n_size = vap->va_size; ! 667: vap->va_size_rsv = 0; ! 668: vap->va_blocksize = fxdr_unsigned(long, fp->fa_blocksize); ! 669: vap->va_rdev = (dev_t)rdev; ! 670: vap->va_bytes = fxdr_unsigned(long, fp->fa_blocks) * NFS_FABLKSIZE; ! 671: vap->va_bytes_rsv = 0; ! 672: vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; ! 673: vap->va_fileid = fxdr_unsigned(long, fp->fa_fileid); ! 674: vap->va_atime.tv_sec = fxdr_unsigned(long, fp->fa_atime.tv_sec); ! 675: vap->va_atime.tv_usec = 0; ! 676: vap->va_flags = fxdr_unsigned(u_long, fp->fa_atime.tv_usec); ! 677: vap->va_mtime = mtime; ! 678: vap->va_ctime.tv_sec = fxdr_unsigned(long, fp->fa_ctime.tv_sec); ! 679: vap->va_ctime.tv_usec = 0; ! 680: vap->va_gen = fxdr_unsigned(u_long, fp->fa_ctime.tv_usec); ! 681: np->n_attrstamp = time.tv_sec; ! 682: *dposp = dpos; ! 683: *mdp = md; ! 684: if (vaper != NULL) { ! 685: bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(*vap)); ! 686: if ((np->n_flag & NMODIFIED) && (np->n_size > vap->va_size)) ! 687: vaper->va_size = np->n_size; ! 688: } ! 689: return (0); ! 690: } ! 691: ! 692: /* ! 693: * Check the time stamp ! 694: * If the cache is valid, copy contents to *vap and return 0 ! 695: * otherwise return an error ! 696: */ ! 697: nfs_getattrcache(vp, vap) ! 698: register struct vnode *vp; ! 699: struct vattr *vap; ! 700: { ! 701: register struct nfsnode *np; ! 702: ! 703: np = VTONFS(vp); ! 704: if ((time.tv_sec-np->n_attrstamp) < NFS_ATTRTIMEO) { ! 705: nfsstats.attrcache_hits++; ! 706: bcopy((caddr_t)&np->n_vattr,(caddr_t)vap,sizeof(struct vattr)); ! 707: if ((np->n_flag & NMODIFIED) == 0) ! 708: np->n_size = vap->va_size; ! 709: else if (np->n_size > vap->va_size) ! 710: vap->va_size = np->n_size; ! 711: return (0); ! 712: } else { ! 713: nfsstats.attrcache_misses++; ! 714: return (ENOENT); ! 715: } ! 716: } ! 717: ! 718: /* ! 719: * Set up nameidata for a namei() call and do it ! 720: */ ! 721: nfs_namei(ndp, fhp, len, mdp, dposp) ! 722: register struct nameidata *ndp; ! 723: fhandle_t *fhp; ! 724: int len; ! 725: struct mbuf **mdp; ! 726: caddr_t *dposp; ! 727: { ! 728: register int i, rem; ! 729: register struct mbuf *md; ! 730: register char *cp; ! 731: struct vnode *dp; ! 732: int flag; ! 733: int error; ! 734: ! 735: if ((ndp->ni_nameiop & HASBUF) == 0) { ! 736: flag = ndp->ni_nameiop & OPFLAG; ! 737: /* ! 738: * Copy the name from the mbuf list to the d_name field of ndp ! 739: * and set the various ndp fields appropriately. ! 740: */ ! 741: cp = *dposp; ! 742: md = *mdp; ! 743: rem = mtod(md, caddr_t)+md->m_len-cp; ! 744: ndp->ni_hash = 0; ! 745: for (i = 0; i < len;) { ! 746: while (rem == 0) { ! 747: md = md->m_next; ! 748: if (md == NULL) ! 749: return (EBADRPC); ! 750: cp = mtod(md, caddr_t); ! 751: rem = md->m_len; ! 752: } ! 753: if (*cp == '\0' || *cp == '/') ! 754: return (EINVAL); ! 755: if (*cp & 0200) ! 756: if ((*cp&0377) == ('/'|0200) || flag != DELETE) ! 757: return (EINVAL); ! 758: ndp->ni_dent.d_name[i++] = *cp; ! 759: ndp->ni_hash += (unsigned char)*cp * i; ! 760: cp++; ! 761: rem--; ! 762: } ! 763: *mdp = md; ! 764: *dposp = cp; ! 765: len = nfsm_rndup(len)-len; ! 766: if (len > 0) { ! 767: if (rem < len) { ! 768: if (error = nfs_adv(mdp, dposp, len, rem)) ! 769: return (error); ! 770: } else ! 771: *dposp += len; ! 772: } ! 773: } else ! 774: i = len; ! 775: ndp->ni_namelen = i; ! 776: ndp->ni_dent.d_namlen = i; ! 777: ndp->ni_dent.d_name[i] = '\0'; ! 778: ndp->ni_segflg = UIO_SYSSPACE; ! 779: ndp->ni_pathlen = 1; ! 780: ndp->ni_pnbuf = ndp->ni_dirp = ndp->ni_ptr = &ndp->ni_dent.d_name[0]; ! 781: ndp->ni_next = &ndp->ni_dent.d_name[i]; ! 782: ndp->ni_nameiop |= (NOCROSSMOUNT | REMOTE | HASBUF); ! 783: ! 784: if (error = nfsrv_fhtovp(fhp, FALSE, &dp, ndp->ni_cred)) ! 785: return (error); ! 786: if (dp->v_type != VDIR) { ! 787: vrele(dp); ! 788: return (ENOTDIR); ! 789: } ! 790: /* ! 791: * Must set current directory here to avoid confusion in namei() ! 792: * called from rename() ! 793: */ ! 794: ndp->ni_cdir = dp; ! 795: ndp->ni_rdir = NULLVP; ! 796: ! 797: /* ! 798: * And call namei() to do the real work ! 799: */ ! 800: error = namei(ndp); ! 801: vrele(dp); ! 802: return (error); ! 803: } ! 804: ! 805: /* ! 806: * A fiddled version of m_adj() that ensures null fill to a long ! 807: * boundary and only trims off the back end ! 808: */ ! 809: nfsm_adj(mp, len, nul) ! 810: struct mbuf *mp; ! 811: register int len; ! 812: int nul; ! 813: { ! 814: register struct mbuf *m; ! 815: register int count, i; ! 816: register char *cp; ! 817: ! 818: /* ! 819: * Trim from tail. Scan the mbuf chain, ! 820: * calculating its length and finding the last mbuf. ! 821: * If the adjustment only affects this mbuf, then just ! 822: * adjust and return. Otherwise, rescan and truncate ! 823: * after the remaining size. ! 824: */ ! 825: count = 0; ! 826: m = mp; ! 827: for (;;) { ! 828: count += m->m_len; ! 829: if (m->m_next == (struct mbuf *)0) ! 830: break; ! 831: m = m->m_next; ! 832: } ! 833: if (m->m_len > len) { ! 834: m->m_len -= len; ! 835: if (nul > 0) { ! 836: cp = mtod(m, caddr_t)+m->m_len-nul; ! 837: for (i = 0; i < nul; i++) ! 838: *cp++ = '\0'; ! 839: } ! 840: return; ! 841: } ! 842: count -= len; ! 843: if (count < 0) ! 844: count = 0; ! 845: /* ! 846: * Correct length for chain is "count". ! 847: * Find the mbuf with last data, adjust its length, ! 848: * and toss data from remaining mbufs on chain. ! 849: */ ! 850: for (m = mp; m; m = m->m_next) { ! 851: if (m->m_len >= count) { ! 852: m->m_len = count; ! 853: if (nul > 0) { ! 854: cp = mtod(m, caddr_t)+m->m_len-nul; ! 855: for (i = 0; i < nul; i++) ! 856: *cp++ = '\0'; ! 857: } ! 858: break; ! 859: } ! 860: count -= m->m_len; ! 861: } ! 862: while (m = m->m_next) ! 863: m->m_len = 0; ! 864: } ! 865: ! 866: /* ! 867: * nfsrv_fhtovp() - convert a fh to a vnode ptr (optionally locked) ! 868: * - look up fsid in mount list (if not found ret error) ! 869: * - check that it is exported ! 870: * - get vp by calling VFS_FHTOVP() macro ! 871: * - if not lockflag unlock it with VOP_UNLOCK() ! 872: * - if cred->cr_uid == 0 set it to m_exroot ! 873: */ ! 874: nfsrv_fhtovp(fhp, lockflag, vpp, cred) ! 875: fhandle_t *fhp; ! 876: int lockflag; ! 877: struct vnode **vpp; ! 878: struct ucred *cred; ! 879: { ! 880: register struct mount *mp; ! 881: ! 882: if ((mp = getvfs(&fhp->fh_fsid)) == NULL) ! 883: return (ESTALE); ! 884: if ((mp->mnt_flag & MNT_EXPORTED) == 0) ! 885: return (EACCES); ! 886: if (VFS_FHTOVP(mp, &fhp->fh_fid, vpp)) ! 887: return (ESTALE); ! 888: if (cred->cr_uid == 0) ! 889: cred->cr_uid = mp->mnt_exroot; ! 890: if (!lockflag) ! 891: VOP_UNLOCK(*vpp); ! 892: return (0); ! 893: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.