/* * BKL held by caller. * dentry->d_inode->i_{sem,mutex} down */ STATIC int base0fs_removexattr(struct dentry *dentry, const char *name) { struct dentry *lower_dentry = NULL; int err = -ENOTSUPP; char *encoded_name; print_entry_location(); lower_dentry = DENTRY_TO_LOWER(dentry); BUG_ON(!lower_dentry); BUG_ON(!lower_dentry->d_inode); BUG_ON(!lower_dentry->d_inode->i_op); fist_dprint(18, "removexattr: name=\"%s\"\n", name); if (lower_dentry->d_inode->i_op->removexattr) { encoded_name = (char *)name; lock_inode(lower_dentry->d_inode); /* lock_kernel() already done by caller. */ err = lower_dentry->d_inode->i_op->removexattr(lower_dentry, encoded_name); /* unlock_kernel() will be done by caller. */ unlock_inode(lower_dentry->d_inode); } out: print_exit_status(err); return err; }
/* * BKL held by caller. * dentry->d_inode->i_{sem,mutex} down */ STATIC ssize_t base0fs_listxattr(struct dentry *dentry, char *list, size_t size) { struct dentry *lower_dentry = NULL; int err = -ENOTSUPP; char *encoded_list = NULL; print_entry_location(); lower_dentry = DENTRY_TO_LOWER(dentry); BUG_ON(!lower_dentry); BUG_ON(!lower_dentry->d_inode); BUG_ON(!lower_dentry->d_inode->i_op); if (lower_dentry->d_inode->i_op->listxattr) { encoded_list = list; lock_inode(lower_dentry->d_inode); /* lock_kernel() already done by caller. */ err = lower_dentry->d_inode->i_op->listxattr(lower_dentry, encoded_list, size); /* unlock_kernel() will be done by caller. */ unlock_inode(lower_dentry->d_inode); } out: print_exit_status(err); return err; }
static void read_inode(register struct inode *inode) { register struct super_block *sb = inode->i_sb; register struct super_operations *sop = sb->s_op; lock_inode(inode); if (sb && sop && sop->read_inode) sop->read_inode(inode); unlock_inode(inode); }
static void read_inode(register struct inode *inode) { struct super_block *sb = inode->i_sb; register struct super_operations *sop; lock_inode(inode); if (sb && (sop = sb->s_op) && sop->read_inode) { sop->read_inode(inode); if (inode->i_op == NULL) set_ops(inode); } unlock_inode(inode); }
static void write_inode(register struct inode *inode) { register struct super_block *sb = inode->i_sb; if (inode->i_dirt) { wait_on_inode(inode); if (inode->i_dirt) { if (!sb || !sb->s_op || !sb->s_op->write_inode) inode->i_dirt = 0; else { inode->i_lock = 1; sb->s_op->write_inode(inode); unlock_inode(inode); } } } }
static void write_inode(register struct inode *inode) { register struct super_block *sb = inode->i_sb; if (!inode->i_dirt) return; wait_on_inode(inode); if (!inode->i_dirt) return; if (!sb || !sb->s_op || !sb->s_op->write_inode) { inode->i_dirt = 0; return; } inode->i_lock = 1; sb->s_op->write_inode(inode); unlock_inode(inode); }
void gs_later_ttl() { register Inodenum i; register Inode * ip; for (i = 1, ip = Inode_table + 1; i < Superblock.s_numinodes; i++, ip++) { /* Have a peek .... */ if ( GLOBAL_TTL(i)==L_UNKNOWN && ip->i_flags&I_INUSE ) { /* We have an unknown global ttl and a file. The file must * have been unknown thus far. */ lock_inode(i,L_READ) ; if ( ip->i_flags&I_INUSE ) { /* The file is still there, set its lifetime */ gs_set_ttl(i) ; } unlock_inode(i); } } gs_age_sweep() ; }
void gs_first_ttl() { register Inodenum i; register Inode * ip; if ( !init_done ) { bwarn("awkward lifetime initialize"); } for (i = 1, ip = Inode_table + 1; i < Superblock.s_numinodes; i++, ip++) { /* Have a peek .... */ if ( ip->i_flags&I_INUSE ) { lock_inode(i,L_READ) ; if ( ip->i_flags&I_INUSE ) { /* The file is still there, set its lifetime */ SET_LOCAL_TTL(i,MAX_LIFETIME) ; SET_GLOBAL_TTL(i,MAX_LIFETIME) ; } unlock_inode(i); } } }
/* * BKL held by caller. * dentry->d_inode->i_{sem,mutex} down */ STATIC ssize_t base0fs_getxattr(struct dentry *dentry, const char *name, void *value, size_t size) { struct dentry *lower_dentry = NULL; int err = -ENOTSUPP; /* Define these anyway so we don't need as much ifdef'ed code. */ char *encoded_name = NULL; char *encoded_value = NULL; print_entry_location(); lower_dentry = DENTRY_TO_LOWER(dentry); BUG_ON(!lower_dentry); BUG_ON(!lower_dentry->d_inode); BUG_ON(!lower_dentry->d_inode->i_op); fist_dprint(18, "getxattr: name=\"%s\", value %d bytes\n", name, (int) size); if (lower_dentry->d_inode->i_op->getxattr) { encoded_name = (char *)name; encoded_value = (char *)value; lock_inode(lower_dentry->d_inode); /* lock_kernel() already done by caller. */ err = lower_dentry->d_inode->i_op->getxattr(lower_dentry, encoded_name, encoded_value, size); /* unlock_kernel() will be done by caller. */ unlock_inode(lower_dentry->d_inode); } out: print_exit_status(err); return err; }
static inline void unlock_dir(struct dentry *dir) { unlock_inode(dir->d_inode); dput(dir); }
STATIC struct dentry * base0fs_lookup(inode_t *dir, struct dentry *dentry, struct nameidata* nd_unused_in_this_fxn /* XXX: fix code if ever used */ ) { int err = 0; struct dentry *lower_dir_dentry; struct dentry *lower_dentry = NULL; struct vfsmount *lower_mount; const char *name; vnode_t *this_vnode; struct dentry *this_dir; unsigned int namelen; print_entry_location(); lower_dir_dentry = base0fs_lower_dentry(dentry->d_parent); /* CPW: Moved below print_entry_location */ name = dentry->d_name.name; namelen = dentry->d_name.len; fist_checkinode(dir, "base0fs_lookup"); this_vnode = dir; this_dir = lower_dir_dentry; fist_print_dentry("base0fs_lookup IN", dentry); fist_print_dentry("base0fs_lookup: dentry->d_parent IN", dentry->d_parent); fist_print_dentry("base0fs_lookup: lower_dir_dentry IN", lower_dir_dentry); fist_print_inode("base0fs_lookup: dir IN", dir); if (lower_dir_dentry->d_inode) fist_print_inode("base0fs_lookup: lower_dir_dentry->d_inode", lower_dir_dentry->d_inode); /* must initialize dentry operations */ dentry->d_op = &base0fs_dops; ; /* increase refcount of base dentry (lookup_one[_len] will decrement) */ // THIS IS RIGHT! (don't "fix" it) // NO THIS IS WRONG IN 2.3.99-pre6. lookup_one[_len] will NOT decrement // dget(lower_dir_dentry); lock_inode(lower_dir_dentry->d_inode); /* will allocate a new lower dentry if needed */ lower_dentry = lookup_one_len(name, lower_dir_dentry, namelen); unlock_inode(lower_dir_dentry->d_inode); if (IS_ERR(lower_dentry)) { /* * this produces an unusual dentry: one that has neither an * inode, nor a private structure attached to it. All cleanup * methods (d_delete, d_release, etc) must be prepared to deal * with such dentries. Ion 09/29/2001 */ err = PTR_ERR(lower_dentry); goto out; } lower_mount = mntget(DENTRY_TO_LVFSMNT(dentry->d_parent)); ; if (lower_dentry->d_inode && lower_dentry->d_inode->i_sb) { struct super_block *lower_sb = lower_dentry->d_inode->i_sb; if (lower_sb->s_dev == sProcDev || lower_sb->s_dev == sDevDev) { d_drop(dentry); /* Don't leak our dentry. */ return lower_dentry; } } /* update parent directory's atime */ fist_copy_attr_atime(dir, lower_dir_dentry->d_inode); /* link the upper and lower dentries */ DENTRY_TO_PRIVATE_SM(dentry) = (struct base0fs_dentry_info *) KMALLOC(sizeof(struct base0fs_dentry_info), GFP_KERNEL); if (!DENTRY_TO_PRIVATE(dentry)) { err = -ENOMEM; goto out_dput; } DENTRY_TO_PRIVATE(dentry)->wdi_dentry = lower_dentry; DENTRY_TO_PRIVATE(dentry)->wdi_mnt = lower_mount; /* lookup is special: it needs to handle negative dentries */ if (!lower_dentry->d_inode) { d_add(dentry, NULL); fist_print_dentry("base0fs_lookup OUT lower_dentry", lower_dentry); goto out; } fist_dprint(6, "lookup \"%s\" -> inode %lu\n", name, lower_dentry->d_inode->i_ino); err = base0fs_interpose(lower_dentry, dentry, dir->i_sb, 1); if (err) goto out_free; fist_checkinode(dentry->d_inode, "base0fs_lookup OUT: dentry->d_inode:"); fist_checkinode(dir, "base0fs_lookup OUT: dir"); fist_print_dentry("base0fs_lookup OUT lower_dentry", lower_dentry); fist_print_inode("base0fs_lookup OUT lower_inode", lower_dentry->d_inode); /* All is well */ goto out; out_free: d_drop(dentry); /* so that our bad dentry will get destroyed */ KFREE(DENTRY_TO_PRIVATE(dentry)); DENTRY_TO_PRIVATE_SM(dentry) = NULL; /* be safe */ out_dput: if (lower_dentry) dput(lower_dentry); out: fist_print_dentry("base0fs_lookup OUT", dentry); print_exit_status(err); return ERR_PTR(err); }