static int amfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) { int err; struct dentry *lower_dentry; struct dentry *lower_parent_dentry = NULL; struct path lower_path; amfs_get_lower_path(dentry, &lower_path); lower_dentry = lower_path.dentry; lower_parent_dentry = lock_parent(lower_dentry); err = vfs_mkdir(lower_parent_dentry->d_inode, lower_dentry, mode); if (err) goto out; err = amfs_interpose(dentry, dir->i_sb, &lower_path); if (err) goto out; fsstack_copy_attr_times(dir, amfs_lower_inode(dir)); fsstack_copy_inode_size(dir, lower_parent_dentry->d_inode); /* update number of links on parent directory */ set_nlink(dir, amfs_lower_inode(dir)->i_nlink); out: unlock_dir(lower_parent_dentry); amfs_put_lower_path(dentry, &lower_path); return err; }
static int amfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev) { int err; struct dentry *lower_dentry; struct dentry *lower_parent_dentry = NULL; struct path lower_path; amfs_get_lower_path(dentry, &lower_path); lower_dentry = lower_path.dentry; lower_parent_dentry = lock_parent(lower_dentry); err = vfs_mknod(lower_parent_dentry->d_inode, lower_dentry, mode, dev); if (err) goto out; err = amfs_interpose(dentry, dir->i_sb, &lower_path); if (err) goto out; fsstack_copy_attr_times(dir, amfs_lower_inode(dir)); fsstack_copy_inode_size(dir, lower_parent_dentry->d_inode); out: unlock_dir(lower_parent_dentry); amfs_put_lower_path(dentry, &lower_path); return err; }
static int amfs_unlink(struct inode *dir, struct dentry *dentry) { int err; struct dentry *lower_dentry; struct inode *lower_dir_inode = amfs_lower_inode(dir); struct dentry *lower_dir_dentry; struct path lower_path; /*************Check if trying to delete pattern file**************/ if (dentry->d_inode->i_ino == AMFS_SB(dentry->d_sb)->inode_no) { err = -EPERM; goto out_err; } /* here I am not allowing user to delete pattern db file. This will only * work if pattern db lies inside the directory which is being mounted */ /**********************XATTR ENDS HERE**************/ amfs_get_lower_path(dentry, &lower_path); lower_dentry = lower_path.dentry; dget(lower_dentry); lower_dir_dentry = lock_parent(lower_dentry); err = vfs_unlink(lower_dir_inode, lower_dentry, NULL); /* * Note: unlinking on top of NFS can cause silly-renamed files. * Trying to delete such files results in EBUSY from NFS * below. Silly-renamed files will get deleted by NFS later on, so * we just need to detect them here and treat such EBUSY errors as * if the upper file was successfully deleted. */ if (err == -EBUSY && lower_dentry->d_flags & DCACHE_NFSFS_RENAMED) err = 0; if (err) goto out; fsstack_copy_attr_times(dir, lower_dir_inode); fsstack_copy_inode_size(dir, lower_dir_inode); set_nlink(dentry->d_inode, amfs_lower_inode(dentry->d_inode)->i_nlink); dentry->d_inode->i_ctime = dir->i_ctime; d_drop(dentry); /* this is needed, else LTP fails (VFS won't do it) */ out: unlock_dir(lower_dir_dentry); dput(lower_dentry); amfs_put_lower_path(dentry, &lower_path); out_err: return err; }
static int amfs_permission(struct inode *inode, int mask) { struct inode *lower_inode; int err; lower_inode = amfs_lower_inode(inode); err = inode_permission(lower_inode, mask); return err; }
static int amfs_inode_test(struct inode *inode, void *candidate_lower_inode) { struct inode *current_lower_inode = amfs_lower_inode(inode); // printk("\n lookup.c->amfs_inode_test"); //aditi if (current_lower_inode == (struct inode *)candidate_lower_inode) return 1; /* found a match */ else return 0; /* no match */ }
struct dentry *amfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) { int err; struct dentry *ret, *parent; struct path lower_parent_path; parent = dget_parent(dentry); amfs_get_lower_path(parent, &lower_parent_path); /* allocate dentry private data. We free it in ->d_release */ err = new_dentry_private_data(dentry); // printk("\n lookup.c-> dentry *amfs_lookup"); //aditi if (err) { ret = ERR_PTR(err); goto out; } ret = __amfs_lookup(dentry, flags, &lower_parent_path); if (IS_ERR(ret)) goto out; if (ret) dentry = ret; if (dentry->d_inode) fsstack_copy_attr_times(dentry->d_inode, amfs_lower_inode(dentry->d_inode)); /* update parent directory's atime */ fsstack_copy_attr_atime(parent->d_inode, amfs_lower_inode(parent->d_inode)); out: amfs_put_lower_path(parent, &lower_parent_path); dput(parent); return ret; }
static int amfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) { int err; struct dentry *lower_dentry; struct dentry *lower_parent_dentry = NULL; struct path lower_path; /* char* value = NULL; value = kzalloc(5,__GFP_WAIT); if(value==NULL){ err = -ENOMEM; goto out_err; } if(amfs_getxattr(dentry, AMFS_XATTR_NAME , value,5) > 0){ if(!strncmp(value,AMFS_BADFILE,3)){ err = -EPERM; goto freevalue; } }else if(amfs_getxattr(dentry, AMFS_XATTR_NAME, value, 5) != -ENODATA){ err = amfs_getxattr(dentry, AMFS_XATTR_NAME, value, 5); goto freevalue; } */ amfs_get_lower_path(dentry, &lower_path); lower_dentry = lower_path.dentry; lower_parent_dentry = lock_parent(lower_dentry); err = vfs_symlink(lower_parent_dentry->d_inode, lower_dentry, symname); if (err) goto out; err = amfs_interpose(dentry, dir->i_sb, &lower_path); if (err) goto out; fsstack_copy_attr_times(dir, amfs_lower_inode(dir)); fsstack_copy_inode_size(dir, lower_parent_dentry->d_inode); out: unlock_dir(lower_parent_dentry); amfs_put_lower_path(dentry, &lower_path); return err; }
static int amfs_setattr(struct dentry *dentry, struct iattr *ia) { int err; struct dentry *lower_dentry; struct inode *inode; struct inode *lower_inode; struct path lower_path; struct iattr lower_ia; inode = dentry->d_inode; /* * Check if user has permission to change inode. We don't check if * this user can change the lower inode: that should happen when * calling notify_change on the lower inode. */ err = inode_change_ok(inode, ia); if (err) goto out_err; amfs_get_lower_path(dentry, &lower_path); lower_dentry = lower_path.dentry; lower_inode = amfs_lower_inode(inode); /* prepare our own lower struct iattr (with the lower file) */ memcpy(&lower_ia, ia, sizeof(lower_ia)); if (ia->ia_valid & ATTR_FILE) lower_ia.ia_file = amfs_lower_file(ia->ia_file); /* * If shrinking, first truncate upper level to cancel writing dirty * pages beyond the new eof; and also if its' maxbytes is more * limiting (fail with -EFBIG before making any change to the lower * level). There is no need to vmtruncate the upper level * afterwards in the other cases: we fsstack_copy_inode_size from * the lower level. */ if (ia->ia_valid & ATTR_SIZE) { err = inode_newsize_ok(inode, ia->ia_size); if (err) goto out; truncate_setsize(inode, ia->ia_size); } /* * mode change is for clearing setuid/setgid bits. Allow lower fs * to interpret this in its own way. */ if (lower_ia.ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) lower_ia.ia_valid &= ~ATTR_MODE; /* notify the (possibly copied-up) lower inode */ /* * Note: we use lower_dentry->d_inode, because lower_inode may be * unlinked (no inode->i_sb and i_ino==0. This happens if someone * tries to open(), unlink(), then ftruncate() a file. */ mutex_lock(&lower_dentry->d_inode->i_mutex); err = notify_change(lower_dentry, &lower_ia, /* note: lower_ia */ NULL); mutex_unlock(&lower_dentry->d_inode->i_mutex); if (err) goto out; /* get attributes from the lower inode */ fsstack_copy_attr_all(inode, lower_inode); /* * Not running fsstack_copy_inode_size(inode, lower_inode), because * VFS should update our inode size, and notify_change on * lower_inode should update its size. */ out: amfs_put_lower_path(dentry, &lower_path); out_err: return err; }
static int amfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry) { struct dentry *lower_old_dentry; struct dentry *lower_new_dentry; struct dentry *lower_dir_dentry; u64 file_size_save; int err; struct path lower_old_path, lower_new_path; char *value = NULL; if (old_dentry->d_inode->i_ino == AMFS_SB(old_dentry->d_sb)->inode_no) { err = -EPERM; goto out_err; } /************XATTR************/ value = kzalloc(5, __GFP_WAIT); if (value == NULL) { err = -ENOMEM; goto out_err; } if (amfs_getxattr(old_dentry, AMFS_XATTR_NAME, value, 5) > 0) { if (!strncmp(value, AMFS_BADFILE, 3)) { err = -EPERM; goto freevalue; } } else if (amfs_getxattr(old_dentry, AMFS_XATTR_NAME, value, 5) != -ENODATA){ err = amfs_getxattr(old_dentry, AMFS_XATTR_NAME, value, 5); goto freevalue; } /************XATTR***********/ file_size_save = i_size_read(old_dentry->d_inode); amfs_get_lower_path(old_dentry, &lower_old_path); amfs_get_lower_path(new_dentry, &lower_new_path); lower_old_dentry = lower_old_path.dentry; lower_new_dentry = lower_new_path.dentry; lower_dir_dentry = lock_parent(lower_new_dentry); err = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode, lower_new_dentry, NULL); if (err || !lower_new_dentry->d_inode) goto out; err = amfs_interpose(new_dentry, dir->i_sb, &lower_new_path); if (err) goto out; fsstack_copy_attr_times(dir, lower_new_dentry->d_inode); fsstack_copy_inode_size(dir, lower_new_dentry->d_inode); set_nlink(old_dentry->d_inode, amfs_lower_inode(old_dentry->d_inode)->i_nlink); i_size_write(new_dentry->d_inode, file_size_save); out: unlock_dir(lower_dir_dentry); amfs_put_lower_path(old_dentry, &lower_old_path); amfs_put_lower_path(new_dentry, &lower_new_path); freevalue: kfree(value); out_err: return err; }