static int amfs_rmdir(struct inode *dir, struct dentry *dentry)
{
struct dentry *lower_dentry;
struct dentry *lower_dir_dentry;
int err;
struct path lower_path;
amfs_get_lower_path(dentry, &lower_path);
lower_dentry = lower_path.dentry;
lower_dir_dentry = lock_parent(lower_dentry);
err = vfs_rmdir(lower_dir_dentry->d_inode, lower_dentry);
if (err)
goto out;
d_drop(dentry); /* drop our dentry on success (why not VFS's job?) */
if (dentry->d_inode)
clear_nlink(dentry->d_inode);
fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
set_nlink(dir, lower_dir_dentry->d_inode->i_nlink);
out:
unlock_dir(lower_dir_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_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_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;
}
/*
* returns: -ERRNO if error (returned to user)
* 0: tell VFS to invalidate dentry
* 1: dentry is valid
*/
static int amfs_d_revalidate(struct dentry *dentry, unsigned int flags)
{
struct path lower_path;
struct dentry *lower_dentry;
int err = 1;
if (flags & LOOKUP_RCU)
return -ECHILD;
amfs_get_lower_path(dentry, &lower_path);
lower_dentry = lower_path.dentry;
if (!(lower_dentry->d_flags & DCACHE_OP_REVALIDATE))
goto out;
err = lower_dentry->d_op->d_revalidate(lower_dentry, flags);
out:
amfs_put_lower_path(dentry, &lower_path);
return err;
}
static int amfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
struct kstat *stat)
{
int err;
struct kstat lower_stat;
struct path lower_path;
amfs_get_lower_path(dentry, &lower_path);
err = vfs_getattr(&lower_path, &lower_stat);
if (err)
goto out;
fsstack_copy_attr_all(dentry->d_inode,
lower_path.dentry->d_inode);
generic_fillattr(dentry->d_inode, stat);
stat->blocks = lower_stat.blocks;
out:
amfs_put_lower_path(dentry, &lower_path);
return err;
}
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;
}
int
amfs_setxattr(struct dentry *dentry, const char *name, const void *value,
size_t size, int flags)
{
int err; struct dentry *lower_dentry;
struct path lower_path;
amfs_get_lower_path(dentry, &lower_path);
lower_dentry = lower_path.dentry;
if (!lower_dentry->d_inode->i_op ||
!lower_dentry->d_inode->i_op->setxattr) {
err = -EINVAL;
goto out;
}
err = vfs_setxattr(lower_dentry, name, value, size, flags);
out:
amfs_put_lower_path(dentry, &lower_path);
return err;
}
static int
amfs_removexattr(struct dentry *dentry, const char *name)
{
int err;
struct dentry *lower_dentry;
struct path lower_path;
amfs_get_lower_path(dentry, &lower_path);
lower_dentry = lower_path.dentry;
if (!lower_dentry->d_inode->i_op ||
!lower_dentry->d_inode->i_op->removexattr) {
err = -EINVAL;
goto out;
}
err = lower_dentry->d_inode->i_op->removexattr(lower_dentry,
name);
out:
amfs_put_lower_path(dentry, &lower_path);
return err;
}
static ssize_t
amfs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
{
int err;
struct dentry *lower_dentry;
struct path lower_path;
amfs_get_lower_path(dentry, &lower_path);
lower_dentry = lower_path.dentry;
if (!lower_dentry->d_inode->i_op ||
!lower_dentry->d_inode->i_op->listxattr) {
err = -EINVAL;
goto out;
}
err = vfs_listxattr(lower_dentry,
buffer, buffer_size);
out:
amfs_put_lower_path(dentry, &lower_path);
return err;
}
ssize_t
amfs_getxattr(struct dentry *dentry, const char *name, void *buffer,
size_t size)
{
int err;
struct dentry *lower_dentry;
struct path lower_path;
amfs_get_lower_path(dentry, &lower_path);
lower_dentry = lower_path.dentry;
if (!lower_dentry->d_inode->i_op ||
!lower_dentry->d_inode->i_op->getxattr) {
err = -EINVAL;
goto out;
}
err = vfs_getxattr(lower_dentry, name, buffer, size);
out:
amfs_put_lower_path(dentry, &lower_path);
return err;
}
static int amfs_readlink(struct dentry *dentry, char __user *buf, int bufsiz)
{
int err;
struct dentry *lower_dentry;
struct path lower_path;
amfs_get_lower_path(dentry, &lower_path);
lower_dentry = lower_path.dentry;
if (!lower_dentry->d_inode->i_op ||
!lower_dentry->d_inode->i_op->readlink) {
err = -EINVAL;
goto out;
}
err = lower_dentry->d_inode->i_op->readlink(lower_dentry,
buf, bufsiz);
if (err < 0)
goto out;
fsstack_copy_attr_atime(dentry->d_inode, lower_dentry->d_inode);
out:
amfs_put_lower_path(dentry, &lower_path);
return err;
}
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_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;
}
/*
* The locking rules in amfs_rename are complex. We could use a simpler
* superblock-level name-space lock for renames and copy-ups.
*/
static int amfs_rename(struct inode *old_dir, struct dentry *old_dentry,
struct inode *new_dir, struct dentry *new_dentry)
{
int err = 0;
struct dentry *lower_old_dentry = NULL;
struct dentry *lower_new_dentry = NULL;
struct dentry *lower_old_dir_dentry = NULL;
struct dentry *lower_new_dir_dentry = NULL;
struct dentry *trap = NULL;
struct path lower_old_path, lower_new_path;
/*******Variable which will help in checking XATTR***************/
char *value = NULL;
if (old_dentry->d_inode->i_ino ==
AMFS_SB(old_dentry->d_sb)->inode_no) {
err = -EPERM;
goto exitcode;
}
value = kzalloc(5, __GFP_WAIT);
if (value == NULL) {
err = -ENOMEM;
goto exitcode;
}
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;
}
/****************************************************************/
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_old_dir_dentry = dget_parent(lower_old_dentry);
lower_new_dir_dentry = dget_parent(lower_new_dentry);
trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
/* source should not be ancestor of target */
if (trap == lower_old_dentry) {
err = -EINVAL;
goto out;
}
/* target should not be ancestor of source */
if (trap == lower_new_dentry) {
err = -ENOTEMPTY;
goto out;
}
err = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry,
lower_new_dir_dentry->d_inode, lower_new_dentry,
NULL, 0);
if (err)
goto out;
fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);
fsstack_copy_inode_size(new_dir, lower_new_dir_dentry->d_inode);
if (new_dir != old_dir) {
fsstack_copy_attr_all(old_dir,
lower_old_dir_dentry->d_inode);
fsstack_copy_inode_size(old_dir,
lower_old_dir_dentry->d_inode);
}
out:
unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
dput(lower_old_dir_dentry);
dput(lower_new_dir_dentry);
amfs_put_lower_path(old_dentry, &lower_old_path);
amfs_put_lower_path(new_dentry, &lower_new_path);
freevalue:
kfree(value);
exitcode:
return err;
}
