![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to volfs_vnops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / miscfs / volfs|
Return to volfs_vnops.c CVS log | Up to [Apple XNU] / XNU / bsd / miscfs / volfs |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * Copyright (c) 1998-1999 Apple Computer, Inc. All Rights Reserved. ! 24: * ! 25: * Modification History: ! 26: * ! 27: * 2/10/2000 Clark Warner Added copyfile ! 28: * 5/24/1999 Don Brady Fixed security hole in get_fsvnode. ! 29: * 11/18/1998 Don Brady Special case 2 to mean the root of a file system. ! 30: * 9/28/1998 Umesh Vaishampayan Use the default vnode ops. Cleanup ! 31: * header includes. ! 32: * 11/12/1998 Scott Roberts validfsnode only checks to see if the volfs mount flag is set ! 33: * 8/5/1998 Don Brady fix validfsnode logic to handle a "bad" VFS_GET ! 34: * 7/5/1998 Don Brady In volfs_reclaim set vp->v_data to NULL after private data is free (VFS expects a NULL). ! 35: * 4/5/1998 Don Brady Changed lockstatus calls to VOP_ISLOCKED (radar #2231108); ! 36: * 3/25/1998 Pat Dirks Added include for sys/attr.h, which is no longer included indirectly. ! 37: */ ! 38: ! 39: #include <mach/mach_types.h> ! 40: ! 41: #include <sys/param.h> ! 42: #include <sys/systm.h> ! 43: #include <sys/resourcevar.h> ! 44: #include <sys/kernel.h> ! 45: #include <sys/file.h> ! 46: #include <sys/stat.h> ! 47: #include <sys/buf.h> ! 48: #include <sys/proc.h> ! 49: #include <sys/conf.h> ! 50: #include <sys/mount.h> ! 51: #include <sys/vnode.h> ! 52: #include <sys/malloc.h> ! 53: #include <sys/dirent.h> ! 54: #include <sys/namei.h> ! 55: #include <sys/attr.h> ! 56: ! 57: #include <sys/vm.h> ! 58: #include <sys/errno.h> ! 59: #include <vfs/vfs_support.h> ! 60: ! 61: #include "volfs.h" ! 62: ! 63: /* ! 64: * volfs acts as a bridge between the requirements of the MacOS API and the Unix API. ! 65: * MacOS applications describe files by a <Volume ID><Directory ID><File Name> triple. ! 66: * The Unix API describes files by pathname. Volfs is a virtual file system that sits over ! 67: * the HFS VFS interface and allows files to be described by a <Volume ID>/<Directory ID>/<File Name> ! 68: * pathname. ! 69: * ! 70: * The root of the volfs filesystem consists of directories named the volume ID's of all the ! 71: * currently mounted filesystems which support the VFS vget() routine. Each of those directories ! 72: * supports the lookup by file ID of all files and directories within the filesystem. When a ! 73: * file or directory is resolved its vnode from that filesystem rather than a volfs vnode is returned ! 74: * allowing immediate access to the target file or directory. ! 75: * ! 76: * Readdir on the root of the volfs filesystem returns the list of available file systems. Readdir ! 77: * on a filesystem node, however, returns only . and .. since it is not practical to list all ! 78: * of the file ID's in a timely fashion and furthermore VFS does not provide a mechanism for ! 79: * enumerating all of the file id's. ! 80: * ! 81: * Volume ID's are taken from the low 32 bits of the f_fsid field, formatted as a base 10 ASCII ! 82: * string with no leading zeros (volume ID 1 is represented as "1"). ! 83: * ! 84: * File ID's are created in same manner, with their 32 bits formatted as a base 10 ASCII ! 85: * string with no leading zeros. ! 86: * ! 87: * Volfs does create a security hole since it is possible to bypass directory permissions higher ! 88: * in the namespace tree. This security hole is about the same as the one created by NFS which uses ! 89: * a similar mechanism. ! 90: */ ! 91: ! 92: /* Global vfs data structures for volfs. */ ! 93: int (**volfs_vnodeop_p) (); ! 94: struct vnodeopv_entry_desc volfs_vnodeop_entries[] = { ! 95: {&vop_default_desc, vn_default_error}, ! 96: {&vop_strategy_desc, err_strategy}, /* strategy */ ! 97: {&vop_bwrite_desc, err_bwrite}, /* bwrite */ ! 98: {&vop_lookup_desc, volfs_lookup}, /* lookup */ ! 99: {&vop_create_desc, err_create}, /* create */ ! 100: {&vop_whiteout_desc, err_whiteout}, /* whiteout */ ! 101: {&vop_mknod_desc, err_mknod}, /* mknod */ ! 102: {&vop_mkcomplex_desc, err_mkcomplex}, /* mkcomplex */ ! 103: {&vop_open_desc, nop_open}, /* open */ ! 104: {&vop_close_desc, nop_close}, /* close */ ! 105: {&vop_access_desc, volfs_access}, /* access */ ! 106: {&vop_getattr_desc, volfs_getattr}, /* getattr */ ! 107: {&vop_setattr_desc, err_setattr}, /* setattr */ ! 108: {&vop_getattrlist_desc, err_getattrlist}, /* getattrlist */ ! 109: {&vop_setattrlist_desc, err_setattrlist}, /* setattrlist */ ! 110: {&vop_read_desc, err_read}, /* read */ ! 111: {&vop_write_desc, err_write}, /* write */ ! 112: {&vop_lease_desc, err_lease}, /* lease */ ! 113: {&vop_ioctl_desc, err_ioctl}, /* ioctl */ ! 114: {&vop_select_desc, volfs_select}, /* select */ ! 115: {&vop_exchange_desc, err_exchange}, /* exchange */ ! 116: {&vop_revoke_desc, nop_revoke}, /* revoke */ ! 117: {&vop_mmap_desc, err_mmap}, /* mmap */ ! 118: {&vop_fsync_desc, err_fsync}, /* fsync */ ! 119: {&vop_seek_desc, nop_seek}, /* seek */ ! 120: {&vop_remove_desc, err_remove}, /* remove */ ! 121: {&vop_link_desc, err_link}, /* link */ ! 122: {&vop_rename_desc, err_rename}, /* rename */ ! 123: {&vop_mkdir_desc, err_mkdir}, /* mkdir */ ! 124: {&vop_rmdir_desc, volfs_rmdir}, /* rmdir */ ! 125: {&vop_symlink_desc, err_symlink}, /* symlink */ ! 126: {&vop_readdir_desc, volfs_readdir}, /* readdir */ ! 127: {&vop_readdirattr_desc, err_readdirattr}, /* readdirattr */ ! 128: {&vop_readlink_desc, err_readlink}, /* readlink */ ! 129: {&vop_abortop_desc, err_abortop}, /* abortop */ ! 130: {&vop_inactive_desc, err_inactive}, /* inactive */ ! 131: {&vop_reclaim_desc, volfs_reclaim}, /* reclaim */ ! 132: {&vop_lock_desc, volfs_lock}, /* lock */ ! 133: {&vop_unlock_desc, volfs_unlock}, /* unlock */ ! 134: {&vop_bmap_desc, err_bmap}, /* bmap */ ! 135: {&vop_print_desc, err_print}, /* print */ ! 136: {&vop_islocked_desc, volfs_islocked}, /* islocked */ ! 137: {&vop_pathconf_desc, volfs_pathconf}, /* pathconf */ ! 138: {&vop_advlock_desc, err_advlock}, /* advlock */ ! 139: {&vop_blkatoff_desc, err_blkatoff}, /* blkatoff */ ! 140: {&vop_valloc_desc, err_valloc}, /* valloc */ ! 141: {&vop_reallocblks_desc, err_reallocblks}, /* reallocblks */ ! 142: {&vop_vfree_desc, err_vfree}, /* vfree */ ! 143: {&vop_truncate_desc, err_truncate}, /* truncate */ ! 144: {&vop_allocate_desc, err_allocate}, /* allocate */ ! 145: {&vop_update_desc, err_update}, /* update */ ! 146: {&vop_pgrd_desc, err_pgrd}, /* pgrd */ ! 147: {&vop_pgwr_desc, err_pgwr}, /* pgwr */ ! 148: {&vop_pagein_desc, err_pagein}, /* pagein */ ! 149: {&vop_pageout_desc, err_pageout}, /* pageout */ ! 150: {&vop_devblocksize_desc, err_devblocksize}, /* devblocksize */ ! 151: {&vop_searchfs_desc, err_searchfs}, /* searchfs */ ! 152: {&vop_copyfile_desc, err_copyfile }, /* Copyfile */ ! 153: {(struct vnodeop_desc *) NULL, (int (*) ()) NULL} ! 154: }; ! 155: ! 156: /* ! 157: * Oh what a tangled web we weave. This structure will be used by ! 158: * bsd/vfs/vfs_conf.c to actually do the initialization of volfs_vnodeop_p ! 159: */ ! 160: struct vnodeopv_desc volfs_vnodeop_opv_desc = ! 161: {&volfs_vnodeop_p, volfs_vnodeop_entries}; ! 162: ! 163: ! 164: static int validfsnode(struct mount *fsnode); ! 165: ! 166: #if DBG_VOP_TEST_LOCKS ! 167: static void DbgVopTest (int max, int error, VopDbgStoreRec *VopDbgStore, char *funcname); ! 168: #endif /* DBG_VOP_TEST_LOCKS */ ! 169: ! 170: ! 171: /* ! 172: * volfs_reclaim - Reclaim a vnode so that it can be used for other purposes. ! 173: * ! 174: * Locking policy: ignored ! 175: */ ! 176: int ! 177: volfs_reclaim(ap) ! 178: struct vop_reclaim_args /* { struct vnode *a_vp; struct proc *a_p; } */ *ap; ! 179: { ! 180: struct vnode *vp = ap->a_vp; ! 181: void *data = vp->v_data; ! 182: ! 183: DBG_FUNC_NAME("volfs_reclaim"); ! 184: DBG_VOP_LOCKS_DECL(1); ! 185: DBG_VOP_PRINT_FUNCNAME();DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP(("\n")); ! 186: ! 187: DBG_VOP_LOCKS_INIT(0, vp, VOPDBG_UNLOCKED, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_ZERO); ! 188: ! 189: vp->v_data = NULL; ! 190: FREE(data, M_VOLFSNODE); ! 191: ! 192: DBG_VOP_LOCKS_TEST(0); ! 193: return (0); ! 194: } ! 195: ! 196: /* ! 197: * volfs_access - same access policy for all vnodes and all users (file/directory vnodes ! 198: * for the actual file systems are handled by actual file system) ! 199: * ! 200: * Locking policy: a_vp locked on input and output ! 201: */ ! 202: int ! 203: volfs_access(ap) ! 204: struct vop_access_args /* { struct vnode *a_vp; int a_mode; struct ! 205: ucred *a_cred; struct proc *a_p; } */ *ap; ! 206: { ! 207: int ret_err; ! 208: DBG_FUNC_NAME("volfs_access"); ! 209: DBG_VOP_LOCKS_DECL(1); ! 210: DBG_VOP_PRINT_FUNCNAME();DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP(("\n")); ! 211: ! 212: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS); ! 213: ! 214: /* ! 215: * We don't need to check credentials! FS is read-only for everyone ! 216: */ ! 217: if (ap->a_mode == VREAD || ap->a_mode == VEXEC) ! 218: ret_err = 0; ! 219: else ! 220: ret_err = EACCES; ! 221: ! 222: DBG_VOP_LOCKS_TEST(ret_err); ! 223: return (ret_err); ! 224: } ! 225: ! 226: /* ! 227: * volfs_getattr - fill in the attributes for this vnode ! 228: * ! 229: * Locking policy: don't change anything ! 230: */ ! 231: int ! 232: volfs_getattr(ap) ! 233: struct vop_getattr_args /* { struct vnode *a_vp; struct vattr *a_vap; ! 234: struct ucred *a_cred; struct proc *a_p; } */ *ap; ! 235: { ! 236: struct volfs_vndata *priv_data; ! 237: struct vnode *a_vp; ! 238: struct vattr *a_vap; ! 239: int numMounts = 0; ! 240: DBG_FUNC_NAME("volfs_getattr"); ! 241: DBG_VOP_LOCKS_DECL(1); ! 242: DBG_VOP_PRINT_FUNCNAME();DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP(("\n")); ! 243: ! 244: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_SAME, VOPDBG_SAME, VOPDBG_SAME, VOPDBG_POS); ! 245: ! 246: a_vp = ap->a_vp; ! 247: a_vap = ap->a_vap; ! 248: ! 249: priv_data = a_vp->v_data; ! 250: ! 251: a_vap->va_type = VDIR; ! 252: a_vap->va_mode = 0444; /* Yup, hard - coded to read - only */ ! 253: a_vap->va_nlink = 2; ! 254: a_vap->va_uid = 0; /* Always owned by root */ ! 255: a_vap->va_gid = 0; /* Always part of group 0 */ ! 256: a_vap->va_fsid = (int) a_vp->v_mount->mnt_stat.f_fsid.val[0]; ! 257: a_vap->va_fileid = priv_data->nodeID; ! 258: ! 259: /* ! 260: * If it's the root vnode calculate its size based on the number of eligible ! 261: * file systems ! 262: */ ! 263: if (priv_data->vnode_type == VOLFS_ROOT) ! 264: { ! 265: register struct mount *mp, *nmp; ! 266: ! 267: simple_lock(&mountlist_slock); ! 268: for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) { ! 269: if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, ap->a_p)) { ! 270: nmp = mp->mnt_list.cqe_next; ! 271: continue; ! 272: } ! 273: ! 274: if (mp != a_vp->v_mount && validfsnode(mp)) ! 275: numMounts++; ! 276: ! 277: simple_lock(&mountlist_slock); ! 278: nmp = mp->mnt_list.cqe_next; ! 279: vfs_unbusy(mp, ap->a_p); ! 280: } ! 281: simple_unlock(&mountlist_slock); ! 282: ! 283: DBG_VOP(("found %d file systems that volfs can support\n", numMounts)); ! 284: a_vap->va_size = (numMounts + 2) * VLFSDIRENTLEN; ! 285: } ! 286: else ! 287: { ! 288: a_vap->va_size = 2 * VLFSDIRENTLEN; ! 289: } ! 290: DBG_VOP(("va_size = %d, VLFSDIRENTLEN = %ld\n", (int) a_vap->va_size, VLFSDIRENTLEN)); ! 291: a_vap->va_blocksize = 512; ! 292: ! 293: a_vap->va_atime.tv_sec = boottime.tv_sec; ! 294: a_vap->va_atime.tv_nsec = 0; ! 295: ! 296: a_vap->va_mtime.tv_sec = boottime.tv_sec; ! 297: a_vap->va_mtime.tv_nsec = 0; ! 298: ! 299: a_vap->va_ctime.tv_sec = boottime.tv_sec; ! 300: a_vap->va_ctime.tv_nsec = 0; ! 301: ! 302: a_vap->va_gen = 0; ! 303: a_vap->va_flags = 0; ! 304: a_vap->va_rdev = 0; ! 305: a_vap->va_bytes = a_vap->va_size; ! 306: a_vap->va_filerev = 0; ! 307: a_vap->va_vaflags = 0; ! 308: ! 309: DBG_VOP_LOCKS_TEST(0); ! 310: return (0); ! 311: } ! 312: ! 313: /* ! 314: * volfs_select - just say OK. Only possible op is readdir ! 315: * ! 316: * Locking policy: ignore ! 317: */ ! 318: int ! 319: volfs_select(ap) ! 320: struct vop_select_args /* { struct vnode *a_vp; int a_which; int ! 321: * a_fflags; struct ucred *a_cred; struct ! 322: proc *a_p; } */ *ap; ! 323: { ! 324: DBG_VOP(("volfs_select called\n")); ! 325: ! 326: return (1); ! 327: } ! 328: ! 329: /* ! 330: * vofls_rmdir - not possible to remove directories in volfs ! 331: * ! 332: * Locking policy: a_dvp & a_vp - locked on entry, unlocked on exit ! 333: */ ! 334: int ! 335: volfs_rmdir(ap) ! 336: struct vop_rmdir_args /* { struct vnode *a_dvp; struct vnode *a_vp; ! 337: struct componentname *a_cnp; } */ *ap; ! 338: { ! 339: DBG_VOP(("volfs_rmdir called\n")); ! 340: if (ap->a_dvp == ap->a_vp) { ! 341: (void) nop_rmdir(ap); ! 342: return (EINVAL); ! 343: } else ! 344: return (err_rmdir(ap)); ! 345: } ! 346: ! 347: /* ! 348: * volfs_readdir - Get directory entries ! 349: * ! 350: * Directory listings are only produced for the root volfs node. Filesystems ! 351: * just return . & .. ! 352: * Filesystems contained within the volfs root are named by the decimal ! 353: * equivalent of the f_fsid.val[0] from their mount structure (typically ! 354: * the device id of the volume). The maximum length for a name, then is ! 355: * 10 characters. ! 356: * ! 357: * Locking policy: a_vp locked on entry and exit ! 358: */ ! 359: int ! 360: volfs_readdir(ap) ! 361: struct vop_readdir_args /* { struct vnode *a_vp; struct uio *a_uio; ! 362: * struct ucred *a_cred; int *a_eofflag; int ! 363: *ncookies; u_long **a_cookies; } */ *ap; ! 364: { ! 365: struct volfs_vndata *priv_data; ! 366: register struct uio *uio = ap->a_uio; ! 367: int error = 0; ! 368: size_t count, lost; ! 369: int rec_offset; ! 370: struct dirent local_dir; ! 371: int i; ! 372: int starting_resid; ! 373: off_t off; ! 374: DBG_FUNC_NAME("volfs_readdir"); ! 375: DBG_VOP_LOCKS_DECL(1); ! 376: ! 377: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_LOCKED, VOPDBG_POS); ! 378: DBG_VOP_PRINT_FUNCNAME();DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP(("\n")); ! 379: ! 380: DBG_VOP(("\tuio_offset = %d, uio_resid = %d\n", (int) uio->uio_offset, uio->uio_resid)); ! 381: /* We assume it's all one big buffer... */ ! 382: if (uio->uio_iovcnt > 1) ! 383: DBG_VOP(("\tuio->uio_iovcnt = %d?\n", uio->uio_iovcnt)); ! 384: ! 385: off = uio->uio_offset; ! 386: priv_data = ap->a_vp->v_data; ! 387: starting_resid = uio->uio_resid; ! 388: count = uio->uio_resid; ! 389: ! 390: /* Make sure we don't return partial entries. */ ! 391: count -= (uio->uio_offset + count) & (VLFSDIRENTLEN - 1); ! 392: if (count <= 0) ! 393: { ! 394: DBG_VOP(("volfs_readdir: Not enough buffer to read in entries\n")); ! 395: DBG_VOP_LOCKS_TEST(EINVAL); ! 396: return (EINVAL); ! 397: } ! 398: /* ! 399: * Make sure we're starting on a directory boundary ! 400: */ ! 401: if (off & (VLFSDIRENTLEN - 1)) ! 402: { ! 403: DBG_VOP_LOCKS_TEST(EINVAL); ! 404: return (EINVAL); ! 405: } ! 406: rec_offset = off / VLFSDIRENTLEN; ! 407: lost = uio->uio_resid - count; ! 408: uio->uio_resid = count; ! 409: uio->uio_iov->iov_len = count; ! 410: ! 411: local_dir.d_reclen = VLFSDIRENTLEN; ! 412: /* ! 413: * We must synthesize . and .. ! 414: */ ! 415: DBG_VOP(("\tstarting ... uio_offset = %d, uio_resid = %d\n", ! 416: (int) uio->uio_offset, uio->uio_resid)); ! 417: if (rec_offset == 0) ! 418: { ! 419: DBG_VOP(("\tAdding .\n")); ! 420: /* ! 421: * Synthesize . ! 422: */ ! 423: local_dir.d_fileno = priv_data->nodeID; ! 424: local_dir.d_type = DT_DIR; ! 425: local_dir.d_namlen = 1; ! 426: local_dir.d_name[0] = '.'; ! 427: for (i = 1; i < MAXVLFSNAMLEN; i++) ! 428: local_dir.d_name[i] = 0; ! 429: error = uiomove((char *) &local_dir, VLFSDIRENTLEN, uio); ! 430: DBG_VOP(("\t after adding ., uio_offset = %d, uio_resid = %d\n", ! 431: (int) uio->uio_offset, uio->uio_resid)); ! 432: rec_offset++; ! 433: } ! 434: if (rec_offset == 1) ! 435: { ! 436: DBG_VOP(("\tAdding ..\n")); ! 437: /* ! 438: * Synthesize .. ! 439: * We only have two levels in the volfs hierarchy. Root's ! 440: * .. points to itself and the second level points to root, ! 441: * hence we've hardcoded d_fileno for .. here ! 442: */ ! 443: local_dir.d_fileno = ROOT_DIRID; ! 444: local_dir.d_type = DT_DIR; ! 445: local_dir.d_namlen = 2; ! 446: local_dir.d_name[0] = '.'; ! 447: local_dir.d_name[1] = '.'; ! 448: for (i = 2; i < MAXVLFSNAMLEN; i++) ! 449: local_dir.d_name[i] = 0; ! 450: error = uiomove((char *) &local_dir, VLFSDIRENTLEN, uio); ! 451: rec_offset++; ! 452: DBG_VOP(("\t after adding .., uio_offset = %d, uio_resid = %d\n", ! 453: (int) uio->uio_offset, uio->uio_resid)); ! 454: } ! 455: ! 456: /* ! 457: * OK, we've given them the . & .. entries. If this is a ! 458: * filesystem node then we've gone as far as we're going ! 459: * to go ! 460: */ ! 461: if (priv_data->vnode_type == VOLFS_FSNODE) ! 462: { ! 463: *ap->a_eofflag = 1; /* we got all the way to the end */ ! 464: DBG_VOP_LOCKS_TEST(error); ! 465: return (error); ! 466: } ! 467: ! 468: if (rec_offset > 1) { ! 469: register struct mount *mp, *nmp; ! 470: int validnodeindex; ! 471: struct proc *p = uio->uio_procp; ! 472: ! 473: validnodeindex = 1; /* we always have "." and ".." */ ! 474: ! 475: simple_lock(&mountlist_slock); ! 476: for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) { ! 477: if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, p)) { ! 478: nmp = mp->mnt_list.cqe_next; ! 479: continue; ! 480: } ! 481: ! 482: if (mp != ap->a_vp->v_mount && validfsnode(mp)) ! 483: validnodeindex++; ! 484: ! 485: if (rec_offset == validnodeindex) ! 486: { ! 487: local_dir.d_fileno = mp->mnt_stat.f_fsid.val[0]; ! 488: local_dir.d_type = DT_DIR; ! 489: local_dir.d_reclen = VLFSDIRENTLEN; ! 490: DBG_VOP(("\tAdding dir entry %d for offset %d\n", mp->mnt_stat.f_fsid.val[0], rec_offset)); ! 491: local_dir.d_namlen = sprintf(&local_dir.d_name[0], "%d", ! 492: (mp->mnt_flag & MNT_ROMANONLY) ? mp->mnt_stat.f_fsid.val[0] | VOLFS_ROMANONLY : mp->mnt_stat.f_fsid.val[0] ); ! 493: ! 494: error = uiomove((char *) &local_dir, VLFSDIRENTLEN, uio); ! 495: DBG_VOP(("\t after adding entry '%s', uio_offset = %d, uio_resid = %d\n", ! 496: &local_dir.d_name[0], (int) uio->uio_offset, uio->uio_resid)); ! 497: rec_offset++; ! 498: } ! 499: ! 500: simple_lock(&mountlist_slock); ! 501: nmp = mp->mnt_list.cqe_next; ! 502: vfs_unbusy(mp, p); ! 503: } ! 504: simple_unlock(&mountlist_slock); ! 505: ! 506: if (mp == (void *) &mountlist) ! 507: *ap->a_eofflag = 1; /* we got all the way to the end */ ! 508: } ! 509: ! 510: uio->uio_resid += lost; ! 511: if (starting_resid == uio->uio_resid) ! 512: uio->uio_offset = 0; ! 513: ! 514: DBG_VOP(("\tExiting, uio_offset = %d, uio_resid = %d, ap->a_eofflag = %d\n", ! 515: (int) uio->uio_offset, uio->uio_resid, *ap->a_eofflag)); ! 516: ! 517: DBG_VOP_LOCKS_TEST(error); ! 518: return (error); ! 519: } ! 520: ! 521: ! 522: /* ! 523: * validfsnode - test to see if a file system supports VGET ! 524: * ! 525: * This can cause context switching, so caller should be lock safe ! 526: */ ! 527: static int ! 528: validfsnode(struct mount *fsnode) ! 529: { ! 530: ! 531: /* ! 532: * Just check to see if the the mount flag is set, if it is we assume the ! 533: * file system supports all of volfs symantecs ! 534: */ ! 535: ! 536: if (fsnode->mnt_flag & MNT_DOVOLFS) ! 537: return 1; ! 538: else ! 539: return 0; ! 540: } ! 541: ! 542: /* ! 543: * volfs_lock - Lock an inode. ! 544: * If its already locked, set the WANT bit and sleep. ! 545: * ! 546: * Locking policy: handled by lockmgr ! 547: */ ! 548: int ! 549: volfs_lock(ap) ! 550: struct vop_lock_args /* { struct vnode *a_vp; int a_flags; struct ! 551: proc *a_p; } */ *ap; ! 552: { ! 553: int retval; ! 554: struct volfs_vndata *priv_data; ! 555: DBG_FUNC_NAME("volfs_lock"); ! 556: DBG_VOP_LOCKS_DECL(1); ! 557: DBG_VOP_PRINT_FUNCNAME();DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP(("\n")); ! 558: ! 559: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_UNLOCKED, VOPDBG_LOCKED, VOPDBG_UNLOCKED, VOPDBG_ZERO); ! 560: ! 561: priv_data = (struct volfs_vndata *) ap->a_vp->v_data; ! 562: retval = lockmgr(&priv_data->lock, ap->a_flags, &ap->a_vp->v_interlock, ap->a_p); ! 563: DBG_VOP_LOCKS_TEST(retval); ! 564: return (retval); ! 565: } ! 566: ! 567: /* ! 568: * volfs_unlock - Unlock an inode. ! 569: * ! 570: * Locking policy: handled by lockmgr ! 571: */ ! 572: int ! 573: volfs_unlock(ap) ! 574: struct vop_unlock_args /* { struct vnode *a_vp; int a_flags; struct ! 575: proc *a_p; } */ *ap; ! 576: { ! 577: int retval; ! 578: struct volfs_vndata *priv_data; ! 579: DBG_FUNC_NAME("volfs_unlock"); ! 580: DBG_VOP_LOCKS_DECL(1); ! 581: DBG_VOP_PRINT_FUNCNAME();DBG_VOP_PRINT_VNODE_INFO(ap->a_vp);DBG_VOP(("\n")); ! 582: ! 583: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_LOCKED, VOPDBG_UNLOCKED, VOPDBG_LOCKED, VOPDBG_ZERO); ! 584: ! 585: priv_data = (struct volfs_vndata *) ap->a_vp->v_data; ! 586: retval = lockmgr(&priv_data->lock, ap->a_flags | LK_RELEASE, ! 587: &ap->a_vp->v_interlock, ap->a_p); ! 588: ! 589: DBG_VOP_LOCKS_TEST(retval); ! 590: return (retval); ! 591: } ! 592: ! 593: /* ! 594: * volfs_islocked - Check for a locked inode. ! 595: * ! 596: * Locking policy: ignore ! 597: */ ! 598: int ! 599: volfs_islocked(ap) ! 600: struct vop_islocked_args /* { struct vnode *a_vp; } */ *ap; ! 601: { ! 602: int retval; ! 603: struct volfs_vndata *priv_data; ! 604: ! 605: DBG_FUNC_NAME("volfs_islocked"); ! 606: DBG_VOP_LOCKS_DECL(1); ! 607: //DBG_VOP_PRINT_FUNCNAME();DBG_VOP(("\n")); ! 608: ! 609: DBG_VOP_LOCKS_INIT(0,ap->a_vp, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_ZERO); ! 610: priv_data = (struct volfs_vndata *) ap->a_vp->v_data; ! 611: retval = lockstatus(&priv_data->lock); ! 612: ! 613: DBG_VOP_LOCKS_TEST(retval); ! 614: return (retval); ! 615: } ! 616: ! 617: /* ! 618: * volfs_pathconf - Return POSIX pathconf information applicable to ufs filesystems. ! 619: * ! 620: * Locking policy: a_vp locked on input and output ! 621: */ ! 622: int ! 623: volfs_pathconf(ap) ! 624: struct vop_pathconf_args /* { struct vnode *a_vp; int a_name; int ! 625: *a_retval; } */ *ap; ! 626: { ! 627: DBG_VOP(("volfs_pathconf called\n")); ! 628: ! 629: switch (ap->a_name) ! 630: { ! 631: case _PC_LINK_MAX: ! 632: *ap->a_retval = LINK_MAX; ! 633: return (0); ! 634: case _PC_NAME_MAX: ! 635: *ap->a_retval = NAME_MAX; ! 636: return (0); ! 637: case _PC_PATH_MAX: ! 638: *ap->a_retval = PATH_MAX; ! 639: return (0); ! 640: case _PC_PIPE_BUF: ! 641: *ap->a_retval = PIPE_BUF; ! 642: return (0); ! 643: case _PC_CHOWN_RESTRICTED: ! 644: *ap->a_retval = 1; ! 645: return (0); ! 646: case _PC_NO_TRUNC: ! 647: *ap->a_retval = 1; ! 648: return (0); ! 649: default: ! 650: return (EINVAL); ! 651: } ! 652: /* NOTREACHED */ ! 653: } ! 654: ! 655: /* ! 656: * get_fsvnode - internal routine to create a vnode for a file system. Called with mount pointer, ! 657: * id of filesystem to lookup and pointer to vnode pointer to fill in ! 658: */ ! 659: static int ! 660: get_fsvnode(our_mount, id, ret_vnode) ! 661: struct mount *our_mount; ! 662: int id; ! 663: struct vnode **ret_vnode; ! 664: { ! 665: register struct mount *mp; ! 666: struct mount *cur_mount; ! 667: struct vnode *cur_vnode; ! 668: struct volfs_vndata *cur_privdata; ! 669: int retval; ! 670: ! 671: //DBG_VOP(("volfs: get_fsvnode called\n")); ! 672: ! 673: /* ! 674: * OK, first look up the matching mount on the list of mounted file systems ! 675: */ ! 676: cur_mount = NULL; ! 677: simple_lock(&mountlist_slock); ! 678: for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = mp->mnt_list.cqe_next) ! 679: { ! 680: if (validfsnode(mp) && mp->mnt_stat.f_fsid.val[0] == id) ! 681: { ! 682: cur_mount = mp; ! 683: break; ! 684: } ! 685: } ! 686: simple_unlock(&mountlist_slock); ! 687: ! 688: if (cur_mount == NULL) { ! 689: /* ! 690: * No mounted file system by the specified ID currently exists in the system. ! 691: * ! 692: * XXX We could deal with a vnode that is still hanging about for an FS that ! 693: * does not exists or has been unmounted now, or count on the update below ! 694: * to happen later... ! 695: */ ! 696: *ret_vnode = NULL; ! 697: return ENOENT; ! 698: }; ! 699: ! 700: /* ! 701: * Now search the list attached to the mount structure to ! 702: * see if this vnode is already floating around ! 703: */ ! 704: search_vnodelist: ! 705: cur_vnode = our_mount->mnt_vnodelist.lh_first; ! 706: while (cur_vnode != NULL) ! 707: { ! 708: cur_privdata = (struct volfs_vndata *) cur_vnode->v_data; ! 709: if (cur_privdata->nodeID == id) ! 710: { ! 711: if (cur_privdata->fs_mount != cur_mount) { ! 712: DBG_VOP(("volfs get_fsvnode: Updating fs_mount for vnode 0x%08lX (id = %d) from 0x%08lX to 0x%08lX...\n", ! 713: (unsigned long)cur_vnode, ! 714: cur_privdata->nodeID, ! 715: (unsigned long)cur_privdata->fs_mount, ! 716: (unsigned long)cur_mount)); ! 717: cur_privdata->fs_mount = cur_mount; ! 718: }; ! 719: break; ! 720: } ! 721: cur_vnode = cur_vnode->v_mntvnodes.le_next; ! 722: } ! 723: ! 724: //DBG_VOP(("\tfinal cur_mount: 0x%x\n",cur_mount)); ! 725: if (cur_vnode) { ! 726: /* If vget returns an error, cur_vnode will not be what we think it is, try again */ ! 727: if (vget(cur_vnode, LK_EXCLUSIVE, current_proc()) != 0) { ! 728: goto search_vnodelist; ! 729: }; ! 730: } ! 731: else ! 732: { ! 733: MALLOC(cur_privdata, struct volfs_vndata *, ! 734: sizeof(struct volfs_vndata), M_VOLFSNODE, M_WAITOK); ! 735: retval = getnewvnode(VT_VOLFS, our_mount, volfs_vnodeop_p, &cur_vnode); ! 736: if (retval != 0) { ! 737: FREE(cur_privdata, M_VOLFSNODE); ! 738: return retval; ! 739: }; ! 740: ! 741: cur_privdata->vnode_type = VOLFS_FSNODE; ! 742: cur_privdata->nodeID = id; ! 743: ! 744: cur_privdata->fs_mount = cur_mount; ! 745: lockinit(&cur_privdata->lock, PINOD, "volfsnode", 0, 0); ! 746: lockmgr(&cur_privdata->lock, LK_EXCLUSIVE, (struct slock *)0, current_proc()); ! 747: cur_vnode->v_data = cur_privdata; ! 748: cur_vnode->v_type = VDIR; ! 749: DBG_VOP(("get_fsvnode returned with new node of ")); ! 750: DBG_VOP_PRINT_VNODE_INFO(cur_vnode);DBG_VOP(("\n")); ! 751: } ! 752: ! 753: *ret_vnode = cur_vnode; ! 754: ! 755: return (0); ! 756: } ! 757: ! 758: ! 759: ! 760: /* ! 761: * get_filevnode - returns the vnode for the given id within a filesystem. The parent vnode ! 762: * is a filesystem, id is the 32-bit id of the file/directory and ret_vnode is a pointer ! 763: * to a vnode pointer ! 764: */ ! 765: static int ! 766: get_filevnode(parent_fs, id, ret_vnode) ! 767: struct mount *parent_fs; ! 768: u_int id; ! 769: struct vnode **ret_vnode; ! 770: { ! 771: int retval; ! 772: ! 773: DBG_VOP(("get_filevnode called for ID %d\n", id)); ! 774: ! 775: /* ! 776: * Special case 2 to mean the root of a file system ! 777: */ ! 778: if (id == 2) ! 779: retval = VFS_ROOT(parent_fs, ret_vnode); ! 780: else ! 781: retval = VFS_VGET(parent_fs, &id, ret_vnode); ! 782: ! 783: return (retval); ! 784: } ! 785: ! 786: ! 787: int ! 788: volfs_lookup(ap) ! 789: struct vop_lookup_args /* { struct vnode *a_dvp; struct vnode ! 790: **a_vpp; struct componentname *a_cnp; } */ *ap; ! 791: { ! 792: struct volfs_vndata *priv_data; ! 793: char *cnp; ! 794: long namelen; ! 795: struct mount *parent_fs; ! 796: int unlocked_parent = 0; ! 797: int ret_err = ENOENT; ! 798: DBG_FUNC_NAME("volfs_lookup"); ! 799: DBG_VOP_LOCKS_DECL(2); ! 800: ! 801: DBG_VOP(("volfs_lookup called, name = %s, namelen = %ld\n", ap->a_cnp->cn_nameptr, ap->a_cnp->cn_namelen)); ! 802: ! 803: DBG_VOP_LOCKS_INIT(0,ap->a_dvp, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_IGNORE, VOPDBG_POS); ! 804: DBG_VOP_LOCKS_INIT(1,*ap->a_vpp, VOPDBG_IGNORE, VOPDBG_LOCKED, VOPDBG_IGNORE, VOPDBG_POS); ! 805: DBG_VOP_PRINT_FUNCNAME();DBG_VOP(("\n")); ! 806: DBG_VOP(("\t"));DBG_VOP_PRINT_CPN_INFO(ap->a_cnp);DBG_VOP(("\n")); ! 807: if (ap->a_cnp->cn_flags & LOCKPARENT) ! 808: DBG_VOP(("\tLOCKPARENT is set\n")); ! 809: if (ap->a_cnp->cn_flags & ISLASTCN) ! 810: { ! 811: DBG_VOP(("\tISLASTCN is set\n")); ! 812: if (ap->a_cnp->cn_nameiop == DELETE || ap->a_cnp->cn_nameiop == RENAME) /* XXX PPD Shouldn't we check for CREATE, too? */ ! 813: { ! 814: ret_err = EROFS; ! 815: goto Err_Exit; ! 816: } ! 817: } ! 818: priv_data = ap->a_dvp->v_data; ! 819: cnp = ap->a_cnp->cn_nameptr; ! 820: namelen = ap->a_cnp->cn_namelen; ! 821: ! 822: #if VOLFS_DEBUG ! 823: switch (priv_data->vnode_type) { ! 824: case VOLFS_ROOT: ! 825: DBG_VOP(("\tparent directory (vnode 0x%08lX) vnode_type is VOLFS_ROOT.\n", (unsigned long)ap->a_dvp)); ! 826: break; ! 827: ! 828: case VOLFS_FSNODE: ! 829: DBG_VOP(("\tparent directory (vnode 0x%08lX) vnode_type is VOLFS_FSNODE, nodeID = %d, fs_mount = 0x%08lX.\n", ! 830: (unsigned long)ap->a_dvp, ! 831: priv_data->nodeID, ! 832: (unsigned long)priv_data->fs_mount)); ! 833: ! 834: default: ! 835: DBG_VOP(("\tparent directory (vnode 0x%08lX) has unknown vnode_type (%d), nodeID = %d.\n", ! 836: (unsigned long)ap->a_dvp, ! 837: priv_data->vnode_type, ! 838: priv_data->nodeID)); ! 839: }; ! 840: #endif /* VOLFS_DEBUG */ ! 841: ! 842: /* first check for "." and ".." */ ! 843: if (cnp[0] == '.') ! 844: { ! 845: if (namelen == 1) ! 846: { ! 847: /* "." requested */ ! 848: *ap->a_vpp = ap->a_dvp; ! 849: VREF(*ap->a_vpp); ! 850: DBG_VOP_LOCKS_TEST(0); ! 851: return (0); ! 852: } ! 853: else if (cnp[1] == '.' && namelen == 2) ! 854: { ! 855: /* ".." requested */ ! 856: ret_err = volfs_root(ap->a_dvp->v_mount, ap->a_vpp); ! 857: } ! 858: } ! 859: ! 860: /* then look for special file system root symbol ('@') */ ! 861: else if (cnp[0] == '@') ! 862: { ! 863: if ((namelen == 1) && (priv_data->vnode_type != VOLFS_ROOT)) { ! 864: parent_fs = priv_data->fs_mount; ! 865: if (!(ap->a_cnp->cn_flags & LOCKPARENT) || !(ap->a_cnp->cn_flags & ISLASTCN)) { ! 866: VOP_UNLOCK(ap->a_dvp, 0, ap->a_cnp->cn_proc); ! 867: unlocked_parent = 1; ! 868: }; ! 869: ret_err = VFS_ROOT(parent_fs, ap->a_vpp); ! 870: } else { ! 871: DBG_VOP(("volfs_lookup: pathname = '@' but namelen = %ld and parent vnode_type = %d.\n", namelen, priv_data->vnode_type)); ! 872: *ap->a_vpp = NULL; ! 873: ret_err = ENOENT; ! 874: }; ! 875: } ! 876: ! 877: /* finally, just look for numeric ids... */ ! 878: else if (namelen <= 10 && cnp[0] > '0' && cnp[0] <= '9') /* 10 digits max lead digit must be 1 - 9 */ ! 879: { ! 880: char *check_ptr; ! 881: u_long id; ! 882: ! 883: id = strtol(cnp, &check_ptr, 10); ! 884: ! 885: /* ! 886: * strtol will leave us at the first non-numeric character. ! 887: * we've checked to make sure the component name does ! 888: * begin with a numeric so check_ptr must wind up on ! 889: * the terminating null or there was other junk following the ! 890: * number ! 891: */ ! 892: if ((check_ptr - cnp) == namelen) ! 893: { ! 894: if (priv_data->vnode_type == VOLFS_ROOT) ! 895: ret_err = get_fsvnode(ap->a_dvp->v_mount, id & ~VOLFS_VOLIDFLAGS, ap->a_vpp); ! 896: else { ! 897: parent_fs = priv_data->fs_mount; ! 898: if (!(ap->a_cnp->cn_flags & LOCKPARENT) || !(ap->a_cnp->cn_flags & ISLASTCN)) { ! 899: VOP_UNLOCK(ap->a_dvp, 0, ap->a_cnp->cn_proc); ! 900: unlocked_parent = 1; ! 901: }; ! 902: ret_err = get_filevnode(parent_fs, id, ap->a_vpp); ! 903: } ! 904: } ! 905: ! 906: } ! 907: ! 908: if (!unlocked_parent && (!(ap->a_cnp->cn_flags & LOCKPARENT) || !(ap->a_cnp->cn_flags & ISLASTCN))) { ! 909: VOP_UNLOCK(ap->a_dvp, 0, ap->a_cnp->cn_proc); ! 910: }; ! 911: ! 912: /* XXX PPD Should we do something special in case LOCKLEAF isn't set? */ ! 913: ! 914: Err_Exit: ! 915: ! 916: DBG_VOP_UPDATE_VP(1, *ap->a_vpp); ! 917: DBG_VOP_LOCKS_TEST(ret_err); ! 918: ! 919: return (ret_err); ! 920: } ! 921: ! 922: #if DBG_VOP_TEST_LOCKS ! 923: ! 924: #if 0 ! 925: static void DbgLookupTest( char *funcname, struct componentname *cnp, struct vnode *dvp, struct vnode *vp) ! 926: { ! 927: int flags = cnp->cn_flags; ! 928: int nameiop = cnp->cn_nameiop; ! 929: ! 930: DBG_VOP (("%s: Action:", funcname)); ! 931: switch (nameiop) ! 932: { ! 933: case LOOKUP: ! 934: PRINTIT ("LOOKUP"); ! 935: break; ! 936: case CREATE: ! 937: PRINTIT ("CREATE"); ! 938: break; ! 939: case DELETE: ! 940: PRINTIT ("DELETE"); ! 941: break; ! 942: case RENAME: ! 943: PRINTIT ("RENAME"); ! 944: break; ! 945: default: ! 946: PRINTIT ("!!!UNKNOWN!!!!"); ! 947: break; ! 948: } ! 949: PRINTIT(" flags: 0x%x ",flags ); ! 950: if (flags & LOCKPARENT) ! 951: PRINTIT (" Lock Parent"); ! 952: if (flags & ISLASTCN) ! 953: PRINTIT (" Last Action"); ! 954: PRINTIT("\n"); ! 955: ! 956: if (dvp) ! 957: { ! 958: PRINTIT ("%s: Parent vnode exited ", funcname); ! 959: if (VOP_ISLOCKED(dvp)) ! 960: PRINTIT("LOCKED\n"); ! 961: else ! 962: PRINTIT("UNLOCKED\n"); ! 963: } ! 964: if (vp && vp==dvp) ! 965: { ! 966: PRINTIT ("%s: Found and Parent are the same\n", funcname); ! 967: } ! 968: else if (vp) ! 969: { ! 970: PRINTIT ("%s: Found vnode exited ", funcname); ! 971: if (VOP_ISLOCKED(vp)) ! 972: PRINTIT("LOCKED\n"); ! 973: else ! 974: PRINTIT("UNLOCKED\n"); ! 975: } ! 976: else ! 977: PRINTIT ("%s: Found vnode exited NULL\n", funcname); ! 978: ! 979: ! 980: } ! 981: #endif ! 982: ! 983: static void DbgVopTest( int maxSlots, ! 984: int retval, ! 985: VopDbgStoreRec *VopDbgStore, ! 986: char *funcname) ! 987: { ! 988: int index; ! 989: ! 990: for (index = 0; index < maxSlots; index++) ! 991: { ! 992: if (VopDbgStore[index].id != index) { ! 993: PRINTIT("%s: DBG_VOP_LOCK: invalid id field (%d) in target entry (#%d).\n", funcname, VopDbgStore[index].id, index); ! 994: return; ! 995: }; ! 996: ! 997: if ((VopDbgStore[index].vp != NULL) && ! 998: ((VopDbgStore[index].vp->v_data==NULL))) ! 999: continue; ! 1000: ! 1001: switch (VopDbgStore[index].inState) ! 1002: { ! 1003: case VOPDBG_IGNORE: ! 1004: case VOPDBG_SAME: ! 1005: /* Do Nothing !!! */ ! 1006: break; ! 1007: case VOPDBG_LOCKED: ! 1008: case VOPDBG_UNLOCKED: ! 1009: case VOPDBG_LOCKNOTNIL: ! 1010: { ! 1011: if (VopDbgStore[index].vp == NULL && (VopDbgStore[index].inState != VOPDBG_LOCKNOTNIL)) { ! 1012: PRINTIT ("%s: InState check: Null vnode ptr in entry #%d\n", funcname, index); ! 1013: } else if (VopDbgStore[index].vp != NULL) { ! 1014: switch (VopDbgStore[index].inState) ! 1015: { ! 1016: case VOPDBG_LOCKED: ! 1017: case VOPDBG_LOCKNOTNIL: ! 1018: if (VopDbgStore[index].inValue == 0) ! 1019: { ! 1020: PRINTIT ("%s: %d Entry: not LOCKED:", funcname, index); DBG_VOP(("\n")); ! 1021: } ! 1022: break; ! 1023: case VOPDBG_UNLOCKED: ! 1024: if (VopDbgStore[index].inValue != 0) ! 1025: { ! 1026: PRINTIT ("%s: %d Entry: not UNLOCKED:", funcname, index); DBG_VOP(("\n")); ! 1027: } ! 1028: break; ! 1029: } ! 1030: } ! 1031: break; ! 1032: } ! 1033: default: ! 1034: PRINTIT ("%s: DBG_VOP_LOCK on entry: bad lock test value: %d\n", funcname, VopDbgStore[index].errState); ! 1035: } ! 1036: ! 1037: ! 1038: if (retval != 0) ! 1039: { ! 1040: switch (VopDbgStore[index].errState) ! 1041: { ! 1042: case VOPDBG_IGNORE: ! 1043: /* Do Nothing !!! */ ! 1044: break; ! 1045: case VOPDBG_LOCKED: ! 1046: case VOPDBG_UNLOCKED: ! 1047: case VOPDBG_SAME: ! 1048: { ! 1049: if (VopDbgStore[index].vp == NULL) { ! 1050: PRINTIT ("%s: ErrState check: Null vnode ptr in entry #%d\n", funcname, index); ! 1051: } else { ! 1052: VopDbgStore[index].outValue = VOP_ISLOCKED(VopDbgStore[index].vp); ! 1053: switch (VopDbgStore[index].errState) ! 1054: { ! 1055: case VOPDBG_LOCKED: ! 1056: if (VopDbgStore[index].outValue == 0) ! 1057: { ! 1058: PRINTIT ("%s: %d Error: not LOCKED:", funcname, index); DBG_VOP(("\n")); ! 1059: } ! 1060: break; ! 1061: case VOPDBG_UNLOCKED: ! 1062: if (VopDbgStore[index].outValue != 0) ! 1063: { ! 1064: PRINTIT ("%s: %d Error: not UNLOCKED:", funcname, index); DBG_VOP(("\n")); ! 1065: } ! 1066: break; ! 1067: case VOPDBG_SAME: ! 1068: if (VopDbgStore[index].outValue != VopDbgStore[index].inValue) ! 1069: PRINTIT ("%s: Error: In/Out locks are DIFFERENT: 0x%x, inis %d and out is %d\n", funcname, (u_int)VopDbgStore[index].vp, VopDbgStore[index].inValue, VopDbgStore[index].outValue); ! 1070: break; ! 1071: } ! 1072: } ! 1073: break; ! 1074: } ! 1075: case VOPDBG_LOCKNOTNIL: ! 1076: if (VopDbgStore[index].vp != NULL) { ! 1077: VopDbgStore[index].outValue = VOP_ISLOCKED(VopDbgStore[index].vp); ! 1078: if (VopDbgStore[index].outValue == 0) ! 1079: PRINTIT ("%s: Error: %d Not LOCKED: 0x%x\n", funcname, index, (u_int)VopDbgStore[index].vp); ! 1080: } ! 1081: break; ! 1082: default: ! 1083: PRINTIT ("%s: Error: bad lock test value: %d\n", funcname, VopDbgStore[index].errState); ! 1084: } ! 1085: } ! 1086: else ! 1087: { ! 1088: switch (VopDbgStore[index].outState) ! 1089: { ! 1090: case VOPDBG_IGNORE: ! 1091: /* Do Nothing !!! */ ! 1092: break; ! 1093: case VOPDBG_LOCKED: ! 1094: case VOPDBG_UNLOCKED: ! 1095: case VOPDBG_SAME: ! 1096: if (VopDbgStore[index].vp == NULL) { ! 1097: PRINTIT ("%s: OutState: Null vnode ptr in entry #%d\n", funcname, index); ! 1098: }; ! 1099: if (VopDbgStore[index].vp != NULL) ! 1100: { ! 1101: VopDbgStore[index].outValue = VOP_ISLOCKED(VopDbgStore[index].vp); ! 1102: switch (VopDbgStore[index].outState) ! 1103: { ! 1104: case VOPDBG_LOCKED: ! 1105: if (VopDbgStore[index].outValue == 0) ! 1106: { ! 1107: PRINTIT ("%s: %d Out: not LOCKED:", funcname, index); DBG_VOP(("\n")); ! 1108: } ! 1109: break; ! 1110: case VOPDBG_UNLOCKED: ! 1111: if (VopDbgStore[index].outValue != 0) ! 1112: { ! 1113: PRINTIT ("%s: %d Out: not UNLOCKED:", funcname, index); DBG_VOP(("\n")); ! 1114: } ! 1115: break; ! 1116: case VOPDBG_SAME: ! 1117: if (VopDbgStore[index].outValue != VopDbgStore[index].inValue) ! 1118: PRINTIT ("%s: Out: In/Out locks are DIFFERENT: 0x%x, inis %d and out is %d\n", funcname, (u_int)VopDbgStore[index].vp, VopDbgStore[index].inValue, VopDbgStore[index].outValue); ! 1119: break; ! 1120: } ! 1121: } ! 1122: break; ! 1123: case VOPDBG_LOCKNOTNIL: ! 1124: if (VopDbgStore[index].vp != NULL) { ! 1125: if (&((struct volfs_vndata *)(VopDbgStore[index].vp->v_data))->lock == NULL) ! 1126: PRINTIT ("%s: DBG_VOP_LOCK on out: Null lock on vnode 0x%x\n", funcname, (u_int)VopDbgStore[index].vp); ! 1127: else { ! 1128: VopDbgStore[index].outValue = VOP_ISLOCKED(VopDbgStore[index].vp); ! 1129: if (VopDbgStore[index].outValue == 0) ! 1130: { ! 1131: PRINTIT ("%s: DBG_VOP_LOCK on out: Should be LOCKED:", funcname); DBG_VOP(("\n")); ! 1132: } ! 1133: } ! 1134: } ! 1135: break; ! 1136: default: ! 1137: PRINTIT ("%s: DBG_VOP_LOCK on out: bad lock test value: %d\n", funcname, VopDbgStore[index].outState); ! 1138: } ! 1139: } ! 1140: ! 1141: VopDbgStore[index].id = -1; /* Invalidate the entry to allow panic-free re-use */ ! 1142: } ! 1143: } ! 1144: ! 1145: #endif /* DBG_VOP_TEST_LOCKS */ ! 1146:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.