Annotation of sys/xfs/xfs_node-bsd.c, Revision 1.1
1.1 ! nbrk 1: /*
! 2: * Copyright (c) 1995 - 2002 Kungliga Tekniska Högskolan
! 3: * (Royal Institute of Technology, Stockholm, Sweden).
! 4: * All rights reserved.
! 5: *
! 6: * Redistribution and use in source and binary forms, with or without
! 7: * modification, are permitted provided that the following conditions
! 8: * are met:
! 9: *
! 10: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: *
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: *
! 17: * 3. Neither the name of the Institute nor the names of its contributors
! 18: * may be used to endorse or promote products derived from this software
! 19: * without specific prior written permission.
! 20: *
! 21: * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 31: * SUCH DAMAGE.
! 32: */
! 33:
! 34: #include <sys/queue.h>
! 35: #include <xfs/xfs_locl.h>
! 36: #include <xfs/xfs_common.h>
! 37: #include <xfs/xfs_fs.h>
! 38: #include <xfs/xfs_deb.h>
! 39: #include <xfs/xfs_vnodeops.h>
! 40:
! 41: RCSID("$arla: xfs_node-bsd.c,v 1.70 2003/02/28 02:01:06 lha Exp $");
! 42:
! 43: extern vop_t **xfs_vnodeop_p;
! 44:
! 45: #ifndef LK_NOPAUSE
! 46: #define LK_NOPAUSE 0
! 47: #endif
! 48:
! 49: /*
! 50: * Allocate a new vnode with handle `handle' in `mp' and return it in
! 51: * `vpp'. Return 0 or error.
! 52: */
! 53:
! 54: int
! 55: xfs_getnewvnode(struct xfs *xfsp, struct vnode **vpp,
! 56: struct xfs_handle *handle)
! 57: {
! 58: struct xfs_node *result, *check;
! 59: int error;
! 60:
! 61: error = getnewvnode(VT_XFS, NNPFS_TO_VFS(xfsp), xfs_vnodeop_p, vpp);
! 62: if (error)
! 63: return error;
! 64:
! 65: result = xfs_alloc(sizeof(*result), M_NNPFS_NODE);
! 66: bzero(result, sizeof(*result));
! 67:
! 68: (*vpp)->v_data = result;
! 69: result->vn = *vpp;
! 70:
! 71: result->handle = *handle;
! 72: result->flags = 0;
! 73: result->tokens = 0;
! 74: result->offset = 0;
! 75: #if defined(HAVE_KERNEL_LOCKMGR) || defined(HAVE_KERNEL_DEBUGLOCKMGR)
! 76: lockinit (&result->lock, PVFS, "xfs_lock", 0, LK_NOPAUSE);
! 77: #else
! 78: result->vnlocks = 0;
! 79: #endif
! 80: result->anonrights = 0;
! 81: result->rd_cred = NULL;
! 82: result->wr_cred = NULL;
! 83:
! 84: #if defined(__NetBSD_Version__) && __NetBSD_Version__ >= 105280000
! 85: genfs_node_init(*vpp, &xfs_genfsops);
! 86: #endif
! 87:
! 88: check = xfs_node_find(&xfsp->nodehead, handle);
! 89: if (check) {
! 90: vput(*vpp);
! 91: *vpp = result->vn;
! 92: return 0;
! 93: }
! 94:
! 95: xfs_insert(&xfs->nodehead, result);
! 96:
! 97: return 0;
! 98: }
! 99:
! 100: /*
! 101: * Create a new xfs_node and make a vget
! 102: *
! 103: * Also prevents creation of duplicates. This happens
! 104: * whenever there are more than one name to a file,
! 105: * "." and ".." are common cases. */
! 106:
! 107: int
! 108: new_xfs_node(struct xfs *xfsp,
! 109: struct xfs_msg_node *node,
! 110: struct xfs_node **xpp,
! 111: d_thread_t *p)
! 112: {
! 113: struct xfs_node *result;
! 114:
! 115: NNPFSDEB(XDEBNODE, ("new_xfs_node (%d,%d,%d,%d)\n",
! 116: node->handle.a,
! 117: node->handle.b,
! 118: node->handle.c,
! 119: node->handle.d));
! 120:
! 121: retry:
! 122: /* Does not allow duplicates */
! 123: result = xfs_node_find(&xfsp->nodehead, &node->handle);
! 124: if (result == 0) {
! 125: int error;
! 126: struct vnode *v;
! 127:
! 128: error = xfs_getnewvnode(xfsp, &v, &node->handle);
! 129: if (error)
! 130: return error;
! 131:
! 132: result = VNODE_TO_XNODE(v);
! 133: result->anonrights = node->anonrights;
! 134:
! 135: xfsp->nnodes++;
! 136: } else {
! 137: /* Node is already cached */
! 138: if(xfs_do_vget(XNODE_TO_VNODE(result), 0, p))
! 139: goto retry;
! 140: }
! 141:
! 142: /* Init other fields */
! 143: xfs_attr2vattr(&node->attr, &result->attr, 1);
! 144: result->vn->v_type = result->attr.va_type;
! 145: result->tokens = node->tokens;
! 146: bcopy(node->id, result->id, sizeof(result->id));
! 147: bcopy(node->rights, result->rights, sizeof(result->rights));
! 148:
! 149: #ifdef __APPLE__
! 150: if (result->vn->v_type == VREG && (!UBCINFOEXISTS(result->vn)))
! 151: ubc_info_init(result->vn);
! 152: #endif
! 153:
! 154: *xpp = result;
! 155: NNPFSDEB(XDEBNODE, ("return: new_xfs_node\n"));
! 156: return 0;
! 157: }
! 158:
! 159: void
! 160: free_xfs_node(struct xfs_node *node)
! 161: {
! 162: struct xfs *xfsp = NNPFS_FROM_XNODE(node);
! 163:
! 164: NNPFSDEB(XDEBNODE, ("free_xfs_node(%lx) (%d,%d,%d,%d)\n",
! 165: (unsigned long)node,
! 166: node->handle.a,
! 167: node->handle.b,
! 168: node->handle.c,
! 169: node->handle.d));
! 170:
! 171: /* XXX Really need to put back dirty data first. */
! 172:
! 173: if (DATA_FROM_XNODE(node)) {
! 174: vrele(DATA_FROM_XNODE(node));
! 175: DATA_FROM_XNODE(node) = NULL;
! 176: }
! 177: xfsp->nnodes--;
! 178: XNODE_TO_VNODE(node)->v_data = NULL;
! 179: if (node->rd_cred) {
! 180: crfree (node->rd_cred);
! 181: node->rd_cred = NULL;
! 182: }
! 183: if (node->wr_cred) {
! 184: crfree (node->wr_cred);
! 185: node->wr_cred = NULL;
! 186: }
! 187:
! 188: xfs_free(node, sizeof(*node), M_NNPFS_NODE);
! 189:
! 190: NNPFSDEB(XDEBNODE, ("free_xfs_node done\n"));
! 191: }
! 192:
! 193: /*
! 194: * FreeBSD 4.4 and newer changed to API to vflush around June 2001
! 195: */
! 196:
! 197: static int
! 198: xfs_vflush(struct mount *mp, int flags)
! 199: {
! 200: #if __FreeBSD__ && __FreeBSD_version > 430000
! 201: return vflush(mp, 0, flags);
! 202: #else
! 203: return vflush(mp, NULL, flags);
! 204: #endif
! 205: }
! 206:
! 207: int
! 208: free_all_xfs_nodes(struct xfs *xfsp, int flags, int unmountp)
! 209: {
! 210: int error = 0;
! 211: struct mount *mp = NNPFS_TO_VFS(xfsp);
! 212:
! 213: if (mp == NULL) {
! 214: NNPFSDEB(XDEBNODE, ("free_all_xfs_nodes already freed\n"));
! 215: return 0;
! 216: }
! 217:
! 218: NNPFSDEB(XDEBNODE, ("free_all_xfs_nodes starting\n"));
! 219:
! 220: xfs_dnlc_purge_mp(mp);
! 221:
! 222: if (xfsp->root) {
! 223: NNPFSDEB(XDEBNODE, ("free_all_xfs_nodes now removing root\n"));
! 224:
! 225: vgone(XNODE_TO_VNODE(xfsp->root));
! 226: xfsp->root = NULL;
! 227: }
! 228:
! 229: NNPFSDEB(XDEBNODE, ("free_all_xfs_nodes root removed\n"));
! 230: NNPFSDEB(XDEBNODE, ("free_all_xfs_nodes now killing all remaining nodes\n"));
! 231:
! 232: /*
! 233: * If we have a syncer vnode, release it (to emulate dounmount)
! 234: * and the create it again when if we are going to need it.
! 235: */
! 236:
! 237: #ifdef HAVE_STRUCT_MOUNT_MNT_SYNCER
! 238: if (!unmountp) {
! 239: if (mp->mnt_syncer != NULL) {
! 240: #ifdef HAVE_KERNEL_VFS_DEALLOCATE_SYNCVNODE
! 241: vfs_deallocate_syncvnode(mp);
! 242: #else
! 243: /*
! 244: * FreeBSD and OpenBSD uses different semantics,
! 245: * FreeBSD does vrele, and OpenBSD does vgone.
! 246: */
! 247: #if defined(__OpenBSD__)
! 248: vgone(mp->mnt_syncer);
! 249: #elif defined(__FreeBSD__)
! 250: vrele(mp->mnt_syncer);
! 251: #else
! 252: #error what os do you use ?
! 253: #endif
! 254: mp->mnt_syncer = NULL;
! 255: #endif
! 256: }
! 257: }
! 258: #endif
! 259: error = xfs_vflush(mp, flags);
! 260: #ifdef HAVE_STRUCT_MOUNT_MNT_SYNCER
! 261: if (!unmountp) {
! 262: NNPFSDEB(XDEBNODE, ("free_all_xfs_nodes not flushing syncer vnode\n"));
! 263: if (mp->mnt_syncer == NULL)
! 264: if (vfs_allocate_syncvnode(mp))
! 265: panic("failed to allocate syncer node when xfs daemon died");
! 266: }
! 267: #endif
! 268:
! 269: if (error) {
! 270: NNPFSDEB(XDEBNODE, ("xfree_all_xfs_nodes: vflush() error == %d\n",
! 271: error));
! 272: return error;
! 273: }
! 274:
! 275: NNPFSDEB(XDEBNODE, ("free_all_xfs_nodes done\n"));
! 276: return error;
! 277: }
! 278:
! 279: void
! 280: vattr2xfs_attr(const struct vattr *va, struct xfs_attr *xa)
! 281: {
! 282: bzero(xa, sizeof(*xa));
! 283: if (va->va_mode != (mode_t)VNOVAL)
! 284: XA_SET_MODE(xa, va->va_mode);
! 285: if (va->va_nlink != VNOVAL)
! 286: XA_SET_NLINK(xa, va->va_nlink);
! 287: if (va->va_size != VNOVAL)
! 288: XA_SET_SIZE(xa, va->va_size);
! 289: if (va->va_uid != VNOVAL)
! 290: XA_SET_UID(xa, va->va_uid);
! 291: if (va->va_gid != VNOVAL)
! 292: XA_SET_GID(xa, va->va_gid);
! 293: if (va->va_atime.tv_sec != VNOVAL)
! 294: XA_SET_ATIME(xa, va->va_atime.tv_sec);
! 295: if (va->va_mtime.tv_sec != VNOVAL)
! 296: XA_SET_MTIME(xa, va->va_mtime.tv_sec);
! 297: if (va->va_ctime.tv_sec != VNOVAL)
! 298: XA_SET_CTIME(xa, va->va_ctime.tv_sec);
! 299: if (va->va_fileid != VNOVAL)
! 300: XA_SET_FILEID(xa, va->va_fileid);
! 301: switch (va->va_type) {
! 302: case VNON:
! 303: xa->xa_type = NNPFS_FILE_NON;
! 304: break;
! 305: case VREG:
! 306: xa->xa_type = NNPFS_FILE_REG;
! 307: break;
! 308: case VDIR:
! 309: xa->xa_type = NNPFS_FILE_DIR;
! 310: break;
! 311: case VBLK:
! 312: xa->xa_type = NNPFS_FILE_BLK;
! 313: break;
! 314: case VCHR:
! 315: xa->xa_type = NNPFS_FILE_CHR;
! 316: break;
! 317: case VLNK:
! 318: xa->xa_type = NNPFS_FILE_LNK;
! 319: break;
! 320: case VSOCK:
! 321: xa->xa_type = NNPFS_FILE_SOCK;
! 322: break;
! 323: case VFIFO:
! 324: xa->xa_type = NNPFS_FILE_FIFO;
! 325: break;
! 326: case VBAD:
! 327: xa->xa_type = NNPFS_FILE_BAD;
! 328: break;
! 329: default:
! 330: panic("xfs_attr2attr: bad value");
! 331: }
! 332: }
! 333:
! 334: #define SET_TIMEVAL(X, S, N) do { (X)->tv_sec = (S); (X)->tv_nsec = (N); } while(0)
! 335:
! 336: void
! 337: xfs_attr2vattr(const struct xfs_attr *xa, struct vattr *va, int clear_node)
! 338: {
! 339: if (clear_node)
! 340: VATTR_NULL(va);
! 341: if (XA_VALID_MODE(xa))
! 342: va->va_mode = xa->xa_mode;
! 343: if (XA_VALID_NLINK(xa))
! 344: va->va_nlink = xa->xa_nlink;
! 345: if (XA_VALID_SIZE(xa)) {
! 346: va->va_size = xa->xa_size;
! 347: va->va_bytes = va->va_size;
! 348: }
! 349: if (XA_VALID_UID(xa))
! 350: va->va_uid = xa->xa_uid;
! 351: if (XA_VALID_GID(xa))
! 352: va->va_gid = xa->xa_gid;
! 353: if (XA_VALID_ATIME(xa)) {
! 354: SET_TIMEVAL(&va->va_atime, xa->xa_atime, 0);
! 355: }
! 356: if (XA_VALID_MTIME(xa)) {
! 357: SET_TIMEVAL(&va->va_mtime, xa->xa_mtime, 0);
! 358: }
! 359: if (XA_VALID_CTIME(xa)) {
! 360: SET_TIMEVAL(&va->va_ctime, xa->xa_ctime, 0);
! 361: }
! 362: if (XA_VALID_FILEID(xa)) {
! 363: va->va_fileid = xa->xa_fileid;
! 364: }
! 365: if (XA_VALID_TYPE(xa)) {
! 366: switch (xa->xa_type) {
! 367: case NNPFS_FILE_NON:
! 368: va->va_type = VNON;
! 369: break;
! 370: case NNPFS_FILE_REG:
! 371: va->va_type = VREG;
! 372: break;
! 373: case NNPFS_FILE_DIR:
! 374: va->va_type = VDIR;
! 375: break;
! 376: case NNPFS_FILE_BLK:
! 377: va->va_type = VBLK;
! 378: break;
! 379: case NNPFS_FILE_CHR:
! 380: va->va_type = VCHR;
! 381: break;
! 382: case NNPFS_FILE_LNK:
! 383: va->va_type = VLNK;
! 384: break;
! 385: case NNPFS_FILE_SOCK:
! 386: va->va_type = VSOCK;
! 387: break;
! 388: case NNPFS_FILE_FIFO:
! 389: va->va_type = VFIFO;
! 390: break;
! 391: case NNPFS_FILE_BAD:
! 392: va->va_type = VBAD;
! 393: break;
! 394: default:
! 395: panic("xfs_attr2vattr: bad value");
! 396: }
! 397: }
! 398: va->va_flags = 0;
! 399: va->va_blocksize = 8192;
! 400: }
! 401:
! 402: /*
! 403: * A single entry DNLC for systems for handling long names that don't
! 404: * get put into the system DNLC.
! 405: */
! 406:
! 407: struct long_entry {
! 408: struct vnode *dvp, *vp;
! 409: char name[MAXNAMLEN + 1];
! 410: size_t len;
! 411: u_long dvpid, vpid;
! 412: };
! 413:
! 414: static struct long_entry tbl;
! 415:
! 416: /*
! 417: * Nuke the `tbl'
! 418: */
! 419:
! 420: static void
! 421: tbl_clear (void)
! 422: {
! 423: tbl.dvp = tbl.vp = NULL;
! 424: tbl.name[0] = '\0';
! 425: tbl.len = 0;
! 426: tbl.dvpid = tbl.vpid = 0;
! 427: }
! 428:
! 429: /*
! 430: * Set the entry in the `tbl'
! 431: */
! 432:
! 433: static void
! 434: tbl_enter (size_t len, const char *name, struct vnode *dvp, struct vnode *vp)
! 435: {
! 436: tbl.len = len;
! 437: bcopy(name, tbl.name, len);
! 438: tbl.dvp = dvp;
! 439: tbl.vp = vp;
! 440: tbl.dvpid = dvp->v_id;
! 441: tbl.vpid = vp->v_id;
! 442: }
! 443:
! 444: /*
! 445: * Lookup in tbl (`dvp', `name', `len') and return result in `res'.
! 446: * Return -1 if successful, otherwise 0.
! 447: */
! 448:
! 449: static int
! 450: tbl_lookup (struct componentname *cnp,
! 451: struct vnode *dvp,
! 452: struct vnode **res)
! 453: {
! 454: if (tbl.dvp == dvp
! 455: && tbl.len == cnp->cn_namelen
! 456: && strncmp(tbl.name, cnp->cn_nameptr, tbl.len) == 0
! 457: && tbl.dvpid == tbl.dvp->v_id
! 458: && tbl.vpid == tbl.vp->v_id) {
! 459:
! 460: *res = tbl.vp;
! 461: return -1;
! 462: } else
! 463: return 0;
! 464: }
! 465:
! 466: /*
! 467: * Store a componentname in the DNLC
! 468: */
! 469:
! 470: int
! 471: xfs_dnlc_enter(struct vnode *dvp,
! 472: xfs_componentname *cnp,
! 473: struct vnode *vp)
! 474: {
! 475: NNPFSDEB(XDEBDNLC, ("xfs_dnlc_enter_cnp(%lx, %lx, %lx)\n",
! 476: (unsigned long)dvp,
! 477: (unsigned long)cnp,
! 478: (unsigned long)vp));
! 479: NNPFSDEB(XDEBDNLC, ("xfs_dnlc_enter: v_id = %lu\n", (u_long)dvp->v_id));
! 480:
! 481: NNPFSDEB(XDEBDNLC, ("xfs_dnlc_enter: calling cache_enter:"
! 482: "dvp = %lx, vp = %lx, cnp = (%s, %ld), "
! 483: "nameiop = %lu, flags = %lx\n",
! 484: (unsigned long)dvp,
! 485: (unsigned long)vp,
! 486: cnp->cn_nameptr, cnp->cn_namelen,
! 487: cnp->cn_nameiop, cnp->cn_flags));
! 488:
! 489: #ifdef NCHNAMLEN
! 490: if (cnp->cn_namelen <= NCHNAMLEN)
! 491: #endif
! 492: {
! 493: /*
! 494: * This is to make sure there's no negative entry already in the dnlc
! 495: */
! 496: u_long save_nameiop;
! 497: u_long save_flags;
! 498: struct vnode *dummy;
! 499:
! 500: save_nameiop = cnp->cn_nameiop;
! 501: save_flags = cnp->cn_flags;
! 502: cnp->cn_nameiop = CREATE;
! 503: cnp->cn_flags &= ~MAKEENTRY;
! 504:
! 505: /*
! 506: * The version number here is not entirely correct, but it's conservative.
! 507: * The real change is sys/kern/vfs_cache:1.20
! 508: */
! 509:
! 510: #if __NetBSD_Version__ >= 104120000 || OpenBSD > 200211
! 511: if (cache_lookup(dvp, &dummy, cnp) != -1) {
! 512: xfs_vfs_unlock(dummy, xfs_cnp_to_proc(cnp));
! 513: printf ("NNPFS PANIC WARNING! xfs_dnlc_enter: %s already in cache\n",
! 514: cnp->cn_nameptr);
! 515: }
! 516: #else
! 517: if (cache_lookup(dvp, &dummy, cnp) != 0) {
! 518: printf ("NNPFS PANIC WARNING! xfs_dnlc_enter: %s already in cache\n",
! 519: cnp->cn_nameptr);
! 520: }
! 521: #endif
! 522:
! 523:
! 524: cnp->cn_nameiop = save_nameiop;
! 525: cnp->cn_flags = save_flags;
! 526: cache_enter(dvp, vp, cnp);
! 527: }
! 528:
! 529: if (vp != NULL)
! 530: tbl_enter (cnp->cn_namelen, cnp->cn_nameptr, dvp, vp);
! 531:
! 532: return 0;
! 533: }
! 534:
! 535:
! 536: static void
! 537: xfs_cnp_init (struct componentname *cn,
! 538: const char *name,
! 539: d_thread_t *proc, struct ucred *cred,
! 540: int nameiop)
! 541: {
! 542: bzero(cn, sizeof(*cn));
! 543: cn->cn_nameptr = (char *)name;
! 544: cn->cn_namelen = strlen(name);
! 545: cn->cn_flags = 0;
! 546: #if __APPLE__
! 547: {
! 548: const unsigned char *p;
! 549: int i;
! 550:
! 551: cn->cn_hash = 0;
! 552: for (p = cn->cn_nameptr, i = 1; *p; ++p, ++i)
! 553: cn->cn_hash += *p * i;
! 554: }
! 555: #elif defined(HAVE_KERNEL_NAMEI_HASH)
! 556: {
! 557: const char *cp = name + cn->cn_namelen;
! 558: cn->cn_hash = namei_hash(name, &cp);
! 559: }
! 560: #elif defined(HAVE_STRUCT_COMPONENTNAME_CN_HASH)
! 561: {
! 562: const unsigned char *p;
! 563:
! 564: cn->cn_hash = 0;
! 565: for (p = cn->cn_nameptr; *p; ++p)
! 566: cn->cn_hash += *p;
! 567: }
! 568: #endif
! 569: cn->cn_nameiop = nameiop;
! 570: #ifdef HAVE_FREEBSD_THREAD
! 571: cn->cn_thread = proc;
! 572: #else
! 573: cn->cn_proc = proc;
! 574: #endif
! 575: cn->cn_cred = cred;
! 576: }
! 577:
! 578:
! 579: /*
! 580: * Store (dvp, name, vp) in the DNLC
! 581: */
! 582:
! 583: int
! 584: xfs_dnlc_enter_name(struct vnode *dvp,
! 585: const char *name,
! 586: struct vnode *vp)
! 587: {
! 588: struct componentname cn;
! 589:
! 590: NNPFSDEB(XDEBDNLC, ("xfs_dnlc_enter_name(%lx, \"%s\", %lx)\n",
! 591: (unsigned long)dvp,
! 592: name,
! 593: (unsigned long)vp));
! 594:
! 595: xfs_cnp_init (&cn, name, NULL, NULL, LOOKUP);
! 596: return xfs_dnlc_enter (dvp, &cn, vp);
! 597: }
! 598:
! 599: /*
! 600: * Lookup (dvp, cnp) in the DNLC and return the result in `res'.
! 601: * Return the result from cache_lookup.
! 602: */
! 603:
! 604: static int
! 605: xfs_dnlc_lookup_int(struct vnode *dvp,
! 606: xfs_componentname *cnp,
! 607: struct vnode **res)
! 608: {
! 609: int error;
! 610: u_long saved_flags;
! 611:
! 612: NNPFSDEB(XDEBDNLC, ("xfs_dnlc_lookup(%lx, \"%s\")\n",
! 613: (unsigned long)dvp, cnp->cn_nameptr));
! 614:
! 615: NNPFSDEB(XDEBDNLC, ("xfs_dnlc_lookup: v_id = %lu\n", (u_long)dvp->v_id));
! 616:
! 617: NNPFSDEB(XDEBDNLC, ("xfs_dnlc_lookup: calling cache_lookup:"
! 618: "dvp = %lx, cnp = (%s, %ld), flags = %lx\n",
! 619: (unsigned long)dvp,
! 620: cnp->cn_nameptr, cnp->cn_namelen,
! 621: cnp->cn_flags));
! 622:
! 623: saved_flags = cnp->cn_flags;
! 624: cnp->cn_flags |= MAKEENTRY | LOCKPARENT | ISLASTCN;
! 625:
! 626: error = cache_lookup(dvp, res, cnp);
! 627:
! 628: cnp->cn_flags = saved_flags;
! 629:
! 630: NNPFSDEB(XDEBDNLC, ("xfs_dnlc_lookup: cache_lookup returned. "
! 631: "error = %d, *res = %lx\n", error,
! 632: (unsigned long)*res));
! 633: return error;
! 634: }
! 635:
! 636: /*
! 637: * do the last (and locking protocol) portion of xnlc_lookup
! 638: *
! 639: * return:
! 640: * -1 for successful
! 641: * 0 for failed
! 642: */
! 643:
! 644: static int
! 645: xfs_dnlc_lock(struct vnode *dvp,
! 646: xfs_componentname *cnp,
! 647: struct vnode **res)
! 648: {
! 649: int error = 0;
! 650:
! 651: /*
! 652: * Try to handle the (complex) BSD locking protocol.
! 653: */
! 654:
! 655: if (*res == dvp) { /* "." */
! 656: VREF(dvp);
! 657: } else if (cnp->cn_flags & ISDOTDOT) { /* ".." */
! 658: u_long vpid = dvp->v_id;
! 659:
! 660: #ifdef HAVE_FREEBSD_THREAD
! 661: xfs_vfs_unlock(dvp, xfs_cnp_to_thread(cnp));
! 662: error = xfs_do_vget(*res, LK_EXCLUSIVE, xfs_cnp_to_thread(cnp));
! 663: xfs_vfs_writelock(dvp, xfs_cnp_to_thread(cnp));
! 664: #else
! 665: xfs_vfs_unlock(dvp, xfs_cnp_to_proc(cnp));
! 666: error = xfs_do_vget(*res, LK_EXCLUSIVE, xfs_cnp_to_proc(cnp));
! 667: xfs_vfs_writelock(dvp, xfs_cnp_to_proc(cnp));
! 668: #endif
! 669:
! 670: if (error == 0 && dvp->v_id != vpid) {
! 671: vput(*res);
! 672: return 0;
! 673: }
! 674: } else {
! 675: #ifdef HAVE_FREEBSD_THREAD
! 676: error = xfs_do_vget(*res, LK_EXCLUSIVE, xfs_cnp_to_thread(cnp));
! 677: #else
! 678: error = xfs_do_vget(*res, LK_EXCLUSIVE, xfs_cnp_to_proc(cnp));
! 679: #endif
! 680: }
! 681:
! 682: if (error == 0)
! 683: return -1;
! 684: else
! 685: return 0;
! 686: }
! 687:
! 688: /*
! 689: * Lookup (`dvp', `cnp') in the DNLC (and the local cache).
! 690: *
! 691: * Return -1 if successful, 0 if not and ENOENT if the entry is known
! 692: * not to exist.
! 693: *
! 694: * On modern NetBSD, cache_lookup has been changed to return 0 for
! 695: * successful and -1 for not.
! 696: * (see the comment above for version information).
! 697: */
! 698:
! 699: #if __NetBSD_Version__ >= 104120000 || defined(__OpenBSD__)
! 700:
! 701: int
! 702: xfs_dnlc_lookup(struct vnode *dvp,
! 703: xfs_componentname *cnp,
! 704: struct vnode **res)
! 705: {
! 706: int error = xfs_dnlc_lookup_int (dvp, cnp, res);
! 707:
! 708: if (error == 0)
! 709: return -1;
! 710: else if (error == ENOENT)
! 711: return error;
! 712:
! 713: error = tbl_lookup (cnp, dvp, res);
! 714:
! 715: if (error != -1)
! 716: return error;
! 717:
! 718: return xfs_dnlc_lock (dvp, cnp, res);
! 719: }
! 720:
! 721: #else /* ! __NetBSD_Version__ >= 104120000 && ! OpenBSD > 200211 */
! 722:
! 723: int
! 724: xfs_dnlc_lookup(struct vnode *dvp,
! 725: xfs_componentname *cnp,
! 726: struct vnode **res)
! 727: {
! 728: int error = xfs_dnlc_lookup_int (dvp, cnp, res);
! 729:
! 730: if (error == 0)
! 731: error = tbl_lookup (cnp, dvp, res);
! 732:
! 733: if (error != -1)
! 734: return error;
! 735:
! 736: return xfs_dnlc_lock (dvp, cnp, res);
! 737: }
! 738:
! 739: #endif /* __NetBSD_Version__ >= 104120000 || OpenBSD > 200211 */
! 740:
! 741: /*
! 742: * Remove one entry from the DNLC
! 743: */
! 744:
! 745: void
! 746: xfs_dnlc_purge (struct vnode *vp)
! 747: {
! 748: NNPFSDEB(XDEBDNLC, ("xfs_dnlc_purge\n"));
! 749:
! 750: if (tbl.dvp == vp || tbl.vp == vp)
! 751: tbl_clear ();
! 752:
! 753: cache_purge(vp);
! 754: }
! 755:
! 756: /*
! 757: * Remove all entries belong to `mp' from the DNLC
! 758: */
! 759:
! 760: void
! 761: xfs_dnlc_purge_mp(struct mount *mp)
! 762: {
! 763: NNPFSDEB(XDEBDNLC, ("xfs_dnlc_purge_mp()\n"));
! 764:
! 765: tbl_clear ();
! 766: cache_purgevfs(mp);
! 767: }
! 768:
! 769: /*
! 770: * Returns 1 if pag has any rights set in the node
! 771: */
! 772:
! 773: int
! 774: xfs_has_pag(const struct xfs_node *xn, xfs_pag_t pag)
! 775: {
! 776: int i;
! 777:
! 778: for (i = 0; i < MAXRIGHTS; i++)
! 779: if (xn->id[i] == pag)
! 780: return 1;
! 781:
! 782: return 0;
! 783: }
! 784:
! 785: void
! 786: xfs_update_write_cred(struct xfs_node *xn, struct ucred *cred)
! 787: {
! 788: if (xn->wr_cred)
! 789: crfree (xn->wr_cred);
! 790: crhold (cred);
! 791: xn->wr_cred = cred;
! 792: }
! 793:
! 794: void
! 795: xfs_update_read_cred(struct xfs_node *xn, struct ucred *cred)
! 796: {
! 797: if (xn->rd_cred)
! 798: crfree (xn->rd_cred);
! 799: crhold (cred);
! 800: xn->rd_cred = cred;
! 801: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to xfs_node-bsd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / xfs