struct vnode * vn_initialize( struct inode *inode) { struct vnode *vp = LINVFS_GET_VP(inode); XFS_STATS_INC(vn_active); XFS_STATS_INC(vn_alloc); vp->v_flag = VMODIFIED; spinlock_init(&vp->v_lock, "v_lock"); spin_lock(&vnumber_lock); if (!++vn_generation) /* v_number shouldn't be zero */ vn_generation++; vp->v_number = vn_generation; spin_unlock(&vnumber_lock); ASSERT(VN_CACHED(vp) == 0); /* Initialize the first behavior and the behavior chain head. */ vn_bhv_head_init(VN_BHV_HEAD(vp), "vnode"); #ifdef XFS_VNODE_TRACE vp->v_trace = ktrace_alloc(VNODE_TRACE_SIZE, KM_SLEEP); #endif /* XFS_VNODE_TRACE */ vn_trace_exit(vp, "vn_initialize", (inst_t *)__return_address); return vp; }
/* * Get a reference on a vnode. */ vnode_t * vn_get( struct vnode *vp, vmap_t *vmap) { struct inode *inode; XFS_STATS_INC(vn_get); inode = LINVFS_GET_IP(vp); if (inode->i_state & I_FREEING) return NULL; inode = VFS_GET_INODE(vmap->v_vfsp, vmap->v_ino, IGET_NOALLOC); if (!inode) /* Inode not present */ return NULL; /* We do not want to create new inodes via vn_get, * returning NULL here is OK. */ if (inode->i_state & I_NEW) { vn_mark_bad(vp); unlock_new_inode(inode); iput(inode); return NULL; } vn_trace_exit(vp, "vn_get", (inst_t *)__return_address); return vp; }
/* * Call VOP_INACTIVE on last reference. */ void vn_rele( struct vnode *vp) { int vcnt; int cache; XFS_STATS_INC(vn_rele); VN_LOCK(vp); vn_trace_entry(vp, "vn_rele", (inst_t *)__return_address); vcnt = vn_count(vp); /* * Since we always get called from put_inode we know * that i_count won't be decremented after we * return. */ if (!vcnt) { /* * As soon as we turn this on, noone can find us in vn_get * until we turn off VINACT or VRECLM */ vp->v_flag |= VINACT; VN_UNLOCK(vp, 0); /* * Do not make the VOP_INACTIVE call if there * are no behaviors attached to the vnode to call. */ if (vp->v_fbhv) VOP_INACTIVE(vp, NULL, cache); VN_LOCK(vp); if (vp->v_flag & VWAIT) sv_broadcast(vptosync(vp)); vp->v_flag &= ~(VINACT|VWAIT|VRECLM|VMODIFIED); } VN_UNLOCK(vp, 0); vn_trace_exit(vp, "vn_rele", (inst_t *)__return_address); }
static int xfs_vn_allocate(xfs_mount_t *mp, xfs_inode_t *ip, struct xfs_vnode **vpp) { struct vnode *vp; struct xfs_vnode *vdata; int error; /* Use zone allocator here? */ vdata = kmem_zalloc(sizeof(*vdata), KM_SLEEP); error = getnewvnode("xfs", XVFSTOMNT(XFS_MTOVFS(mp)), &xfs_vnops, &vp); if (error) { kmem_free(vdata, sizeof(*vdata)); return (error); } vp->v_vnlock->lk_flags |= LK_CANRECURSE; vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, curthread); error = insmntque(vp, XVFSTOMNT(XFS_MTOVFS(mp))); if (error != 0) { kmem_free(vdata, sizeof(*vdata)); return (error); } vp->v_data = (void *)vdata; vdata->v_number= 0; vdata->v_inode = ip; vdata->v_vfsp = XFS_MTOVFS(mp); vdata->v_vnode = vp; vn_bhv_head_init(VN_BHV_HEAD(vdata), "vnode"); #ifdef CONFIG_XFS_VNODE_TRACING vp->v_trace = ktrace_alloc(VNODE_TRACE_SIZE, KM_SLEEP); #endif /* CONFIG_XFS_VNODE_TRACING */ vn_trace_exit(vp, "vn_initialize", (inst_t *)__return_address); if (error == 0) *vpp = vdata; return (error); }
/* * Finish the removal of a vnode. */ void vn_remove( struct vnode *vp) { vmap_t vmap; /* Make sure we don't do this to the same vnode twice */ if (!(vp->v_fbhv)) return; XFS_STATS_INC(vn_remove); vn_trace_exit(vp, "vn_remove", (inst_t *)__return_address); /* * After the following purge the vnode * will no longer exist. */ VMAP(vp, vmap); vn_purge(vp, &vmap); }
/* * Get a reference on a vnode. */ vnode_t * vn_get( struct vnode *vp, vmap_t *vmap) { struct inode *inode; XFS_STATS_INC(vn_get); inode = LINVFS_GET_IP(vp); if (inode->i_state & I_FREEING) return NULL; inode = ilookup(vmap->v_vfsp->vfs_super, vmap->v_ino); if (!inode) /* Inode not present */ return NULL; vn_trace_exit(vp, "vn_get", (inst_t *)__return_address); return vp; }
/* * Look up an inode by number in the given file system. * The inode is looked up in the hash table for the file system * represented by the mount point parameter mp. Each bucket of * the hash table is guarded by an individual semaphore. * * If the inode is found in the hash table, its corresponding vnode * is obtained with a call to vn_get(). This call takes care of * coordination with the reclamation of the inode and vnode. Note * that the vmap structure is filled in while holding the hash lock. * This gives us the state of the inode/vnode when we found it and * is used for coordination in vn_get(). * * If it is not in core, read it in from the file system's device and * add the inode into the hash table. * * The inode is locked according to the value of the lock_flags parameter. * This flag parameter indicates how and if the inode's IO lock and inode lock * should be taken. * * mp -- the mount point structure for the current file system. It points * to the inode hash table. * tp -- a pointer to the current transaction if there is one. This is * simply passed through to the xfs_iread() call. * ino -- the number of the inode desired. This is the unique identifier * within the file system for the inode being requested. * lock_flags -- flags indicating how to lock the inode. See the comment * for xfs_ilock() for a list of valid values. * bno -- the block number starting the buffer containing the inode, * if known (as by bulkstat), else 0. */ int xfs_iget( xfs_mount_t *mp, xfs_trans_t *tp, xfs_ino_t ino, uint flags, uint lock_flags, xfs_inode_t **ipp, xfs_daddr_t bno) { xfs_ihash_t *ih; xfs_inode_t *ip; xfs_inode_t *iq; xfs_vnode_t *vp; ulong version; int error; /* REFERENCED */ int newnode; xfs_chash_t *ch; xfs_chashlist_t *chl, *chlnew; vmap_t vmap; SPLDECL(s); XFS_STATS_INC(xs_ig_attempts); ih = XFS_IHASH(mp, ino); again: read_lock(&ih->ih_lock); for (ip = ih->ih_next; ip != NULL; ip = ip->i_next) { if (ip->i_ino == ino) { vp = XFS_ITOV(ip); VMAP(vp, vmap); /* * Inode cache hit: if ip is not at the front of * its hash chain, move it there now. * Do this with the lock held for update, but * do statistics after releasing the lock. */ if (ip->i_prevp != &ih->ih_next && rwlock_trypromote(&ih->ih_lock)) { if ((iq = ip->i_next)) { iq->i_prevp = ip->i_prevp; } *ip->i_prevp = iq; iq = ih->ih_next; iq->i_prevp = &ip->i_next; ip->i_next = iq; ip->i_prevp = &ih->ih_next; ih->ih_next = ip; write_unlock(&ih->ih_lock); } else { read_unlock(&ih->ih_lock); } XFS_STATS_INC(xs_ig_found); /* * Get a reference to the vnode/inode. * vn_get() takes care of coordination with * the file system inode release and reclaim * functions. If it returns NULL, the inode * has been reclaimed so just start the search * over again. We probably won't find it, * but we could be racing with another cpu * looking for the same inode so we have to at * least look. */ if (!(vp = vn_get(vp, &vmap))) { XFS_STATS_INC(xs_ig_frecycle); goto again; } if (lock_flags != 0) { ip->i_flags &= ~XFS_IRECLAIM; xfs_ilock(ip, lock_flags); } newnode = (ip->i_d.di_mode == 0); if (newnode) { xfs_iocore_inode_reinit(ip); } ip->i_flags &= ~XFS_ISTALE; vn_trace_exit(vp, "xfs_iget.found", (inst_t *)__return_address); goto return_ip; } } /* * Inode cache miss: save the hash chain version stamp and unlock * the chain, so we don't deadlock in vn_alloc. */ XFS_STATS_INC(xs_ig_missed); version = ih->ih_version; read_unlock(&ih->ih_lock); /* * Read the disk inode attributes into a new inode structure and get * a new vnode for it. This should also initialize i_ino and i_mount. */ error = xfs_iread(mp, tp, ino, &ip, bno); if (error) { return error; } error = xfs_vn_allocate(mp, ip, &vp); if (error) { return error; } vn_trace_exit(vp, "xfs_iget.alloc", (inst_t *)__return_address); xfs_inode_lock_init(ip, vp); xfs_iocore_inode_init(ip); if (lock_flags != 0) { xfs_ilock(ip, lock_flags); } /* * Put ip on its hash chain, unless someone else hashed a duplicate * after we released the hash lock. */ write_lock(&ih->ih_lock); if (ih->ih_version != version) { for (iq = ih->ih_next; iq != NULL; iq = iq->i_next) { if (iq->i_ino == ino) { write_unlock(&ih->ih_lock); xfs_idestroy(ip); XFS_STATS_INC(xs_ig_dup); goto again; } } } /* * These values _must_ be set before releasing ihlock! */ ip->i_hash = ih; if ((iq = ih->ih_next)) { iq->i_prevp = &ip->i_next; } ip->i_next = iq; ip->i_prevp = &ih->ih_next; ih->ih_next = ip; ip->i_udquot = ip->i_gdquot = NULL; ih->ih_version++; write_unlock(&ih->ih_lock); /* * put ip on its cluster's hash chain */ ASSERT(ip->i_chash == NULL && ip->i_cprev == NULL && ip->i_cnext == NULL); chlnew = NULL; ch = XFS_CHASH(mp, ip->i_blkno); chlredo: s = mutex_spinlock(&ch->ch_lock); for (chl = ch->ch_list; chl != NULL; chl = chl->chl_next) { if (chl->chl_blkno == ip->i_blkno) { /* insert this inode into the doubly-linked list * where chl points */ if ((iq = chl->chl_ip)) { ip->i_cprev = iq->i_cprev; iq->i_cprev->i_cnext = ip; iq->i_cprev = ip; ip->i_cnext = iq; } else { ip->i_cnext = ip; ip->i_cprev = ip; } chl->chl_ip = ip; ip->i_chash = chl; break; } } /* no hash list found for this block; add a new hash list */ if (chl == NULL) { if (chlnew == NULL) { mutex_spinunlock(&ch->ch_lock, s); ASSERT(xfs_chashlist_zone != NULL); chlnew = (xfs_chashlist_t *) kmem_zone_alloc(xfs_chashlist_zone, KM_SLEEP); ASSERT(chlnew != NULL); goto chlredo; } else { ip->i_cnext = ip; ip->i_cprev = ip; ip->i_chash = chlnew; chlnew->chl_ip = ip; chlnew->chl_blkno = ip->i_blkno; chlnew->chl_next = ch->ch_list; ch->ch_list = chlnew; chlnew = NULL; } } else { if (chlnew != NULL) { kmem_zone_free(xfs_chashlist_zone, chlnew); } } mutex_spinunlock(&ch->ch_lock, s); /* * Link ip to its mount and thread it on the mount's inode list. */ XFS_MOUNT_ILOCK(mp); if ((iq = mp->m_inodes)) { ASSERT(iq->i_mprev->i_mnext == iq); ip->i_mprev = iq->i_mprev; iq->i_mprev->i_mnext = ip; iq->i_mprev = ip; ip->i_mnext = iq; } else { ip->i_mnext = ip; ip->i_mprev = ip; } mp->m_inodes = ip; XFS_MOUNT_IUNLOCK(mp); newnode = 1; return_ip: ASSERT(ip->i_df.if_ext_max == XFS_IFORK_DSIZE(ip) / sizeof(xfs_bmbt_rec_t)); ASSERT(((ip->i_d.di_flags & XFS_DIFLAG_REALTIME) != 0) == ((ip->i_iocore.io_flags & XFS_IOCORE_RT) != 0)); *ipp = ip; /* * If we have a real type for an on-disk inode, we can set ops(&unlock) * now. If it's a new inode being created, xfs_ialloc will handle it. */ XVFS_INIT_VNODE(XFS_MTOVFS(mp), vp, XFS_ITOBHV(ip), 1); return 0; }
STATIC int linvfs_fill_super( struct super_block *sb, void *data, int silent) { vnode_t *rootvp; struct vfs *vfsp = vfs_allocate(); struct xfs_mount_args *args = xfs_args_allocate(sb); struct kstatfs statvfs; int error; vfsp->vfs_super = sb; LINVFS_SET_VFS(sb, vfsp); if (sb->s_flags & MS_RDONLY) vfsp->vfs_flag |= VFS_RDONLY; bhv_insert_all_vfsops(vfsp); VFS_PARSEARGS(vfsp, (char *)data, args, 0, error); if (error) { bhv_remove_all_vfsops(vfsp, 1); goto fail_vfsop; } sb_min_blocksize(sb, BBSIZE); sb->s_export_op = &linvfs_export_ops; sb->s_qcop = &linvfs_qops; sb->s_op = &linvfs_sops; VFS_MOUNT(vfsp, args, NULL, error); if (error) { bhv_remove_all_vfsops(vfsp, 1); goto fail_vfsop; } VFS_STATVFS(vfsp, &statvfs, NULL, error); if (error) goto fail_unmount; sb->s_dirt = 1; sb->s_magic = statvfs.f_type; sb->s_blocksize = statvfs.f_bsize; sb->s_blocksize_bits = ffs(statvfs.f_bsize) - 1; sb->s_maxbytes = xfs_max_file_offset(sb->s_blocksize_bits); set_posix_acl_flag(sb); VFS_ROOT(vfsp, &rootvp, error); if (error) goto fail_unmount; sb->s_root = d_alloc_root(LINVFS_GET_IP(rootvp)); if (!sb->s_root) goto fail_vnrele; if (is_bad_inode(sb->s_root->d_inode)) goto fail_vnrele; if (linvfs_start_syncd(vfsp)) goto fail_vnrele; vn_trace_exit(rootvp, __FUNCTION__, (inst_t *)__return_address); kmem_free(args, sizeof(*args)); return 0; fail_vnrele: if (sb->s_root) { dput(sb->s_root); sb->s_root = NULL; } else { VN_RELE(rootvp); } fail_unmount: VFS_UNMOUNT(vfsp, 0, NULL, error); fail_vfsop: vfs_deallocate(vfsp); kmem_free(args, sizeof(*args)); return -error; }