Annotation of prex/usr/server/fs/vfs/vfs_vnode.c, Revision 1.1
1.1 ! nbrk 1: /*
! 2: * Copyright (c) 2005-2008, Kohsuke Ohtani
! 3: * All rights reserved.
! 4: *
! 5: * Redistribution and use in source and binary forms, with or without
! 6: * modification, are permitted provided that the following conditions
! 7: * are met:
! 8: * 1. Redistributions of source code must retain the above copyright
! 9: * notice, this list of conditions and the following disclaimer.
! 10: * 2. Redistributions in binary form must reproduce the above copyright
! 11: * notice, this list of conditions and the following disclaimer in the
! 12: * documentation and/or other materials provided with the distribution.
! 13: * 3. Neither the name of the author nor the names of any co-contributors
! 14: * may be used to endorse or promote products derived from this software
! 15: * without specific prior written permission.
! 16: *
! 17: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
! 18: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 19: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 20: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
! 21: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 22: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 23: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 24: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 25: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 26: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 27: * SUCH DAMAGE.
! 28: */
! 29:
! 30: /*
! 31: * vnode.c - vnode service
! 32: */
! 33:
! 34: #include <prex/prex.h>
! 35: #include <sys/list.h>
! 36: #include <sys/vnode.h>
! 37: #include <sys/mount.h>
! 38:
! 39: #include <limits.h>
! 40: #include <unistd.h>
! 41: #include <string.h>
! 42: #include <stdlib.h>
! 43: #include <stdio.h>
! 44: #include <errno.h>
! 45:
! 46: #include "vfs.h"
! 47:
! 48: /*
! 49: * Memo:
! 50: *
! 51: * Function Ref count Lock
! 52: * ---------- --------- ----------
! 53: * vn_lock * Lock
! 54: * vn_unlock * Unlock
! 55: * vget 1 Lock
! 56: * vput -1 Unlock
! 57: * vref +1 *
! 58: * vrele -1 *
! 59: */
! 60:
! 61: #define VNODE_BUCKETS 32 /* size of vnode hash table */
! 62:
! 63: /*
! 64: * vnode table.
! 65: * All active (opened) vnodes are stored on this hash table.
! 66: * They can be accessed by its path name.
! 67: */
! 68: static struct list vnode_table[VNODE_BUCKETS];
! 69:
! 70: /*
! 71: * Global lock to access all vnodes and vnode table.
! 72: * If a vnode is already locked, there is no need to
! 73: * lock this global lock to access internal data.
! 74: */
! 75: #if CONFIG_FS_THREADS > 1
! 76: static mutex_t vnode_lock = MUTEX_INITIALIZER;
! 77: #define VNODE_LOCK() mutex_lock(&vnode_lock)
! 78: #define VNODE_UNLOCK() mutex_unlock(&vnode_lock)
! 79: #else
! 80: #define VNODE_LOCK()
! 81: #define VNODE_UNLOCK()
! 82: #endif
! 83:
! 84:
! 85: /*
! 86: * Get the hash value from the mount point and path name.
! 87: */
! 88: static u_int
! 89: vn_hash(mount_t mp, char *path)
! 90: {
! 91: u_int val = 0;
! 92:
! 93: if (path) {
! 94: while (*path)
! 95: val = ((val << 5) + val) + *path++;
! 96: }
! 97: return (val ^ (u_int)mp) & (VNODE_BUCKETS - 1);
! 98: }
! 99:
! 100: /*
! 101: * Returns locked vnode for specified mount point and path.
! 102: * vn_lock() will increment the reference count of vnode.
! 103: */
! 104: vnode_t
! 105: vn_lookup(mount_t mp, char *path)
! 106: {
! 107: list_t head, n;
! 108: vnode_t vp;
! 109:
! 110: VNODE_LOCK();
! 111: head = &vnode_table[vn_hash(mp, path)];
! 112: for (n = list_first(head); n != head; n = list_next(n)) {
! 113: vp = list_entry(n, struct vnode, v_link);
! 114: if (vp->v_mount == mp &&
! 115: !strncmp(vp->v_path, path, PATH_MAX)) {
! 116: vp->v_refcnt++;
! 117: VNODE_UNLOCK();
! 118: mutex_lock(&vp->v_lock);
! 119: vp->v_nrlocks++;
! 120: return vp;
! 121: }
! 122: }
! 123: VNODE_UNLOCK();
! 124: return NULL; /* not found */
! 125: }
! 126:
! 127: /*
! 128: * Lock vnode
! 129: */
! 130: void
! 131: vn_lock(vnode_t vp)
! 132: {
! 133: ASSERT(vp);
! 134: ASSERT(vp->v_refcnt > 0);
! 135:
! 136: mutex_lock(&vp->v_lock);
! 137: vp->v_nrlocks++;
! 138: DPRINTF(VFSDB_VNODE, ("vn_lock: %s\n", vp->v_path));
! 139: }
! 140:
! 141: /*
! 142: * Unlock vnode
! 143: */
! 144: void
! 145: vn_unlock(vnode_t vp)
! 146: {
! 147: ASSERT(vp);
! 148: ASSERT(vp->v_refcnt > 0);
! 149: ASSERT(vp->v_nrlocks > 0);
! 150:
! 151: DPRINTF(VFSDB_VNODE, ("vn_unlock: %s\n", vp->v_path));
! 152: vp->v_nrlocks--;
! 153: mutex_unlock(&vp->v_lock);
! 154: }
! 155:
! 156: /*
! 157: * Allocate new vnode for specified path.
! 158: * Increment its reference count and lock it.
! 159: */
! 160: vnode_t
! 161: vget(mount_t mp, char *path)
! 162: {
! 163: vnode_t vp;
! 164: int err;
! 165:
! 166: DPRINTF(VFSDB_VNODE, ("vget: %s\n", path));
! 167:
! 168: if (!(vp = malloc(sizeof(struct vnode))))
! 169: return NULL;
! 170: memset(vp, 0, sizeof(struct vnode));
! 171:
! 172: if (!(vp->v_path = malloc(strlen(path) + 1))) {
! 173: free(vp);
! 174: return NULL;
! 175: }
! 176: vp->v_mount = mp;
! 177: vp->v_refcnt = 1;
! 178: vp->v_op = mp->m_op->vfs_vnops;
! 179: strcpy(vp->v_path, path);
! 180: mutex_init(&vp->v_lock);
! 181: vp->v_nrlocks = 0;
! 182:
! 183: /*
! 184: * Request to allocate fs specific data for vnode.
! 185: */
! 186: if ((err = VFS_VGET(mp, vp)) != 0) {
! 187: mutex_destroy(&vp->v_lock);
! 188: free(vp->v_path);
! 189: free(vp);
! 190: return NULL;
! 191: }
! 192: vfs_busy(vp->v_mount);
! 193: mutex_lock(&vp->v_lock);
! 194: vp->v_nrlocks++;
! 195:
! 196: VNODE_LOCK();
! 197: list_insert(&vnode_table[vn_hash(mp, path)], &vp->v_link);
! 198: VNODE_UNLOCK();
! 199: return vp;
! 200: }
! 201:
! 202: /*
! 203: * Unlock vnode and decrement its reference count.
! 204: */
! 205: void
! 206: vput(vnode_t vp)
! 207: {
! 208: ASSERT(vp);
! 209: ASSERT(vp->v_nrlocks > 0);
! 210: ASSERT(vp->v_refcnt > 0);
! 211: DPRINTF(VFSDB_VNODE, ("vput: ref=%d %s\n", vp->v_refcnt,
! 212: vp->v_path));
! 213:
! 214: vp->v_refcnt--;
! 215: if (vp->v_refcnt > 0) {
! 216: vn_unlock(vp);
! 217: return;
! 218: }
! 219: VNODE_LOCK();
! 220: list_remove(&vp->v_link);
! 221: VNODE_UNLOCK();
! 222:
! 223: /*
! 224: * Deallocate fs specific vnode data
! 225: */
! 226: VOP_INACTIVE(vp);
! 227: vfs_unbusy(vp->v_mount);
! 228: vp->v_nrlocks--;
! 229: ASSERT(vp->v_nrlocks == 0);
! 230: mutex_unlock(&vp->v_lock);
! 231: mutex_destroy(&vp->v_lock);
! 232: free(vp->v_path);
! 233: free(vp);
! 234: }
! 235:
! 236: /*
! 237: * Increment the reference count on an active vnode.
! 238: */
! 239: void
! 240: vref(vnode_t vp)
! 241: {
! 242: ASSERT(vp);
! 243: ASSERT(vp->v_refcnt > 0); /* Need vget */
! 244:
! 245: VNODE_LOCK();
! 246: DPRINTF(VFSDB_VNODE, ("vref: ref=%d %s\n", vp->v_refcnt,
! 247: vp->v_path));
! 248: vp->v_refcnt++;
! 249: VNODE_UNLOCK();
! 250: }
! 251:
! 252: /*
! 253: * Decrement the reference count of unlocked vnode.
! 254: * Any code in the system which is using vnode should call vrele()
! 255: * when it is finished with the vnode.
! 256: * If count drops to zero, call inactive routine and return to freelist.
! 257: */
! 258: void
! 259: vrele(vnode_t vp)
! 260: {
! 261: ASSERT(vp);
! 262: ASSERT(vp->v_nrlocks == 0);
! 263: ASSERT(vp->v_refcnt > 0);
! 264:
! 265: VNODE_LOCK();
! 266: DPRINTF(VFSDB_VNODE, ("vrele: ref=%d %s\n", vp->v_refcnt,
! 267: vp->v_path));
! 268: vp->v_refcnt--;
! 269: if (vp->v_refcnt > 0) {
! 270: VNODE_UNLOCK();
! 271: return;
! 272: }
! 273: list_remove(&vp->v_link);
! 274: VNODE_UNLOCK();
! 275:
! 276: /*
! 277: * Deallocate fs specific vnode data
! 278: */
! 279: VOP_INACTIVE(vp);
! 280: vfs_unbusy(vp->v_mount);
! 281: mutex_destroy(&vp->v_lock);
! 282: free(vp->v_path);
! 283: free(vp);
! 284: }
! 285:
! 286: /*
! 287: * vgone() is called when unlocked vnode is no longer valid.
! 288: */
! 289: void
! 290: vgone(vnode_t vp)
! 291: {
! 292: ASSERT(vp->v_nrlocks == 0);
! 293:
! 294: VNODE_LOCK();
! 295: DPRINTF(VFSDB_VNODE, ("vgone: %s\n", vp->v_path));
! 296: list_remove(&vp->v_link);
! 297: vfs_unbusy(vp->v_mount);
! 298: mutex_destroy(&vp->v_lock);
! 299: free(vp->v_path);
! 300: free(vp);
! 301: VNODE_UNLOCK();
! 302: }
! 303:
! 304: /*
! 305: * Return reference count.
! 306: */
! 307: int
! 308: vcount(vnode_t vp)
! 309: {
! 310: int count;
! 311:
! 312: vn_lock(vp);
! 313: count = vp->v_refcnt;
! 314: vn_unlock(vp);
! 315: return count;
! 316: }
! 317:
! 318: /*
! 319: * Remove all vnode in the vnode table for unmount.
! 320: */
! 321: void
! 322: vflush(mount_t mp)
! 323: {
! 324: int i;
! 325: list_t head, n;
! 326: vnode_t vp;
! 327:
! 328: VNODE_LOCK();
! 329: for (i = 0; i < VNODE_BUCKETS; i++) {
! 330: head = &vnode_table[i];
! 331: for (n = list_first(head); n != head; n = list_next(n)) {
! 332: vp = list_entry(n, struct vnode, v_link);
! 333: if (vp->v_mount == mp) {
! 334: /* XXX: */
! 335: }
! 336: }
! 337: }
! 338: VNODE_UNLOCK();
! 339: }
! 340:
! 341: int
! 342: vn_stat(vnode_t vp, struct stat *st)
! 343: {
! 344: mode_t mode;
! 345:
! 346: memset(st, 0, sizeof(struct stat));
! 347:
! 348: st->st_ino = (ino_t)vp;
! 349: st->st_size = vp->v_size;
! 350: mode = vp->v_mode;
! 351: switch (vp->v_type) {
! 352: case VREG:
! 353: mode |= S_IFREG;
! 354: break;
! 355: case VDIR:
! 356: mode |= S_IFDIR;
! 357: break;
! 358: case VBLK:
! 359: mode |= S_IFBLK;
! 360: break;
! 361: case VCHR:
! 362: mode |= S_IFCHR;
! 363: break;
! 364: case VLNK:
! 365: mode |= S_IFLNK;
! 366: break;
! 367: case VSOCK:
! 368: mode |= S_IFSOCK;
! 369: break;
! 370: case VFIFO:
! 371: mode |= S_IFIFO;
! 372: break;
! 373: default:
! 374: return EBADF;
! 375: };
! 376: st->st_mode = mode;
! 377: st->st_blksize = BSIZE;
! 378: st->st_blocks = vp->v_size / S_BLKSIZE;
! 379: st->st_uid = 0;
! 380: st->st_gid = 0;
! 381: if (vp->v_type == VCHR || vp->v_type == VBLK)
! 382: st->st_rdev = (dev_t)vp->v_data;
! 383:
! 384: return 0;
! 385: }
! 386:
! 387: #ifdef DEBUG
! 388: /*
! 389: * Dump all all vnode.
! 390: */
! 391: void
! 392: vnode_dump(void)
! 393: {
! 394: int i;
! 395: list_t head, n;
! 396: vnode_t vp;
! 397: mount_t mp;
! 398: char type[][6] = { "VNON ", "VREG ", "VDIR ", "VBLK ", "VCHR ",
! 399: "VLNK ", "VSOCK", "VFIFO" };
! 400:
! 401: VNODE_LOCK();
! 402: dprintf("Dump vnode\n");
! 403: dprintf(" vnode mount type refcnt blkno path\n");
! 404: dprintf(" -------- -------- ----- ------ -------- ------------------------------\n");
! 405:
! 406: for (i = 0; i < VNODE_BUCKETS; i++) {
! 407: head = &vnode_table[i];
! 408: for (n = list_first(head); n != head; n = list_next(n)) {
! 409: vp = list_entry(n, struct vnode, v_link);
! 410: mp = vp->v_mount;
! 411:
! 412: dprintf(" %08x %08x %s %6d %8d %s%s\n", (u_int)vp,
! 413: (u_int)mp, type[vp->v_type], vp->v_refcnt,
! 414: (u_int)vp->v_blkno,
! 415: (strlen(mp->m_path) == 1) ? "\0" : mp->m_path,
! 416: vp->v_path);
! 417: }
! 418: }
! 419: dprintf("\n");
! 420: VNODE_UNLOCK();
! 421: }
! 422: #endif
! 423:
! 424: int
! 425: vop_nullop(void)
! 426: {
! 427:
! 428: return 0;
! 429: }
! 430:
! 431: int
! 432: vop_einval(void)
! 433: {
! 434:
! 435: return EINVAL;
! 436: }
! 437:
! 438: void
! 439: vnode_init(void)
! 440: {
! 441: int i;
! 442:
! 443: for (i = 0; i < VNODE_BUCKETS; i++)
! 444: list_init(&vnode_table[i]);
! 445: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to vfs_vnode.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex / usr / server / fs / vfs