From c9930327943f934dec73baf8f0172b6ea0c08259 Mon Sep 17 00:00:00 2001 From: Erez Zadok Date: Fri, 4 Sep 2015 22:32:26 -0400 Subject: [PATCH] Wrapfs: use d_inode macro Signed-off-by: Erez Zadok --- fs/wrapfs/file.c | 14 +++--- fs/wrapfs/inode.c | 108 ++++++++++++++++++++++----------------------- fs/wrapfs/lookup.c | 12 ++--- fs/wrapfs/main.c | 2 +- fs/wrapfs/wrapfs.h | 4 +- 5 files changed, 70 insertions(+), 70 deletions(-) diff --git a/fs/wrapfs/file.c b/fs/wrapfs/file.c index d9798ae7c729..16516fdfa084 100644 --- a/fs/wrapfs/file.c +++ b/fs/wrapfs/file.c @@ -22,7 +22,7 @@ static ssize_t wrapfs_read(struct file *file, char __user *buf, err = vfs_read(lower_file, buf, count, ppos); /* update our inode atime upon a successful lower read */ if (err >= 0) - fsstack_copy_attr_atime(dentry->d_inode, + fsstack_copy_attr_atime(d_inode(dentry), file_inode(lower_file)); return err; @@ -40,9 +40,9 @@ static ssize_t wrapfs_write(struct file *file, const char __user *buf, err = vfs_write(lower_file, buf, count, ppos); /* update our inode times+sizes upon a successful lower write */ if (err >= 0) { - fsstack_copy_inode_size(dentry->d_inode, + fsstack_copy_inode_size(d_inode(dentry), file_inode(lower_file)); - fsstack_copy_attr_times(dentry->d_inode, + fsstack_copy_attr_times(d_inode(dentry), file_inode(lower_file)); } @@ -59,7 +59,7 @@ static int wrapfs_readdir(struct file *file, struct dir_context *ctx) err = iterate_dir(lower_file, ctx); file->f_pos = lower_file->f_pos; if (err >= 0) /* copy the atime */ - fsstack_copy_attr_atime(dentry->d_inode, + fsstack_copy_attr_atime(d_inode(dentry), file_inode(lower_file)); return err; } @@ -309,7 +309,7 @@ wrapfs_read_iter(struct kiocb *iocb, struct iov_iter *iter) fput(lower_file); /* update upper inode atime as needed */ if (err >= 0 || err == -EIOCBQUEUED) - fsstack_copy_attr_atime(file->f_path.dentry->d_inode, + fsstack_copy_attr_atime(d_inode(file->f_path.dentry), file_inode(lower_file)); out: return err; @@ -337,9 +337,9 @@ wrapfs_write_iter(struct kiocb *iocb, struct iov_iter *iter) fput(lower_file); /* update upper inode times/sizes as needed */ if (err >= 0 || err == -EIOCBQUEUED) { - fsstack_copy_inode_size(file->f_path.dentry->d_inode, + fsstack_copy_inode_size(d_inode(file->f_path.dentry), file_inode(lower_file)); - fsstack_copy_attr_times(file->f_path.dentry->d_inode, + fsstack_copy_attr_times(d_inode(file->f_path.dentry), file_inode(lower_file)); } out: diff --git a/fs/wrapfs/inode.c b/fs/wrapfs/inode.c index 0c1568a8f296..ae3b9fd7e28e 100644 --- a/fs/wrapfs/inode.c +++ b/fs/wrapfs/inode.c @@ -23,7 +23,7 @@ static int wrapfs_create(struct inode *dir, struct dentry *dentry, lower_dentry = lower_path.dentry; lower_parent_dentry = lock_parent(lower_dentry); - err = vfs_create(lower_parent_dentry->d_inode, lower_dentry, mode, + err = vfs_create(d_inode(lower_parent_dentry), lower_dentry, mode, want_excl); if (err) goto out; @@ -31,7 +31,7 @@ static int wrapfs_create(struct inode *dir, struct dentry *dentry, if (err) goto out; fsstack_copy_attr_times(dir, wrapfs_lower_inode(dir)); - fsstack_copy_inode_size(dir, lower_parent_dentry->d_inode); + fsstack_copy_inode_size(dir, d_inode(lower_parent_dentry)); out: unlock_dir(lower_parent_dentry); @@ -49,26 +49,26 @@ static int wrapfs_link(struct dentry *old_dentry, struct inode *dir, int err; struct path lower_old_path, lower_new_path; - file_size_save = i_size_read(old_dentry->d_inode); + file_size_save = i_size_read(d_inode(old_dentry)); wrapfs_get_lower_path(old_dentry, &lower_old_path); wrapfs_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, + err = vfs_link(lower_old_dentry, d_inode(lower_dir_dentry), lower_new_dentry, NULL); - if (err || !lower_new_dentry->d_inode) + if (err || !d_inode(lower_new_dentry)) goto out; err = wrapfs_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, - wrapfs_lower_inode(old_dentry->d_inode)->i_nlink); - i_size_write(new_dentry->d_inode, file_size_save); + fsstack_copy_attr_times(dir, d_inode(lower_new_dentry)); + fsstack_copy_inode_size(dir, d_inode(lower_new_dentry)); + set_nlink(d_inode(old_dentry), + wrapfs_lower_inode(d_inode(old_dentry))->i_nlink); + i_size_write(d_inode(new_dentry), file_size_save); out: unlock_dir(lower_dir_dentry); wrapfs_put_lower_path(old_dentry, &lower_old_path); @@ -104,9 +104,9 @@ static int wrapfs_unlink(struct inode *dir, struct dentry *dentry) goto out; fsstack_copy_attr_times(dir, lower_dir_inode); fsstack_copy_inode_size(dir, lower_dir_inode); - set_nlink(dentry->d_inode, - wrapfs_lower_inode(dentry->d_inode)->i_nlink); - dentry->d_inode->i_ctime = dir->i_ctime; + set_nlink(d_inode(dentry), + wrapfs_lower_inode(d_inode(dentry))->i_nlink); + d_inode(dentry)->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); @@ -127,14 +127,14 @@ static int wrapfs_symlink(struct inode *dir, struct dentry *dentry, lower_dentry = lower_path.dentry; lower_parent_dentry = lock_parent(lower_dentry); - err = vfs_symlink(lower_parent_dentry->d_inode, lower_dentry, symname); + err = vfs_symlink(d_inode(lower_parent_dentry), lower_dentry, symname); if (err) goto out; err = wrapfs_interpose(dentry, dir->i_sb, &lower_path); if (err) goto out; fsstack_copy_attr_times(dir, wrapfs_lower_inode(dir)); - fsstack_copy_inode_size(dir, lower_parent_dentry->d_inode); + fsstack_copy_inode_size(dir, d_inode(lower_parent_dentry)); out: unlock_dir(lower_parent_dentry); @@ -153,7 +153,7 @@ static int wrapfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) lower_dentry = lower_path.dentry; lower_parent_dentry = lock_parent(lower_dentry); - err = vfs_mkdir(lower_parent_dentry->d_inode, lower_dentry, mode); + err = vfs_mkdir(d_inode(lower_parent_dentry), lower_dentry, mode); if (err) goto out; @@ -162,7 +162,7 @@ static int wrapfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) goto out; fsstack_copy_attr_times(dir, wrapfs_lower_inode(dir)); - fsstack_copy_inode_size(dir, lower_parent_dentry->d_inode); + fsstack_copy_inode_size(dir, d_inode(lower_parent_dentry)); /* update number of links on parent directory */ set_nlink(dir, wrapfs_lower_inode(dir)->i_nlink); @@ -183,16 +183,16 @@ static int wrapfs_rmdir(struct inode *dir, struct dentry *dentry) lower_dentry = lower_path.dentry; lower_dir_dentry = lock_parent(lower_dentry); - err = vfs_rmdir(lower_dir_dentry->d_inode, lower_dentry); + err = vfs_rmdir(d_inode(lower_dir_dentry), 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); + if (d_inode(dentry)) + clear_nlink(d_inode(dentry)); + fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry)); + fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry)); + set_nlink(dir, d_inode(lower_dir_dentry)->i_nlink); out: unlock_dir(lower_dir_dentry); @@ -212,7 +212,7 @@ static int wrapfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, lower_dentry = lower_path.dentry; lower_parent_dentry = lock_parent(lower_dentry); - err = vfs_mknod(lower_parent_dentry->d_inode, lower_dentry, mode, dev); + err = vfs_mknod(d_inode(lower_parent_dentry), lower_dentry, mode, dev); if (err) goto out; @@ -220,7 +220,7 @@ static int wrapfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, if (err) goto out; fsstack_copy_attr_times(dir, wrapfs_lower_inode(dir)); - fsstack_copy_inode_size(dir, lower_parent_dentry->d_inode); + fsstack_copy_inode_size(dir, d_inode(lower_parent_dentry)); out: unlock_dir(lower_parent_dentry); @@ -262,19 +262,19 @@ static int wrapfs_rename(struct inode *old_dir, struct dentry *old_dentry, goto out; } - err = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry, - lower_new_dir_dentry->d_inode, lower_new_dentry, + err = vfs_rename(d_inode(lower_old_dir_dentry), lower_old_dentry, + d_inode(lower_new_dir_dentry), 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); + fsstack_copy_attr_all(new_dir, d_inode(lower_new_dir_dentry)); + fsstack_copy_inode_size(new_dir, d_inode(lower_new_dir_dentry)); if (new_dir != old_dir) { fsstack_copy_attr_all(old_dir, - lower_old_dir_dentry->d_inode); + d_inode(lower_old_dir_dentry)); fsstack_copy_inode_size(old_dir, - lower_old_dir_dentry->d_inode); + d_inode(lower_old_dir_dentry)); } out: @@ -294,17 +294,17 @@ static int wrapfs_readlink(struct dentry *dentry, char __user *buf, int bufsiz) wrapfs_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) { + if (!d_inode(lower_dentry)->i_op || + !d_inode(lower_dentry)->i_op->readlink) { err = -EINVAL; goto out; } - err = lower_dentry->d_inode->i_op->readlink(lower_dentry, + err = d_inode(lower_dentry)->i_op->readlink(lower_dentry, buf, bufsiz); if (err < 0) goto out; - fsstack_copy_attr_atime(dentry->d_inode, lower_dentry->d_inode); + fsstack_copy_attr_atime(d_inode(dentry), d_inode(lower_dentry)); out: wrapfs_put_lower_path(dentry, &lower_path); @@ -359,7 +359,7 @@ static int wrapfs_setattr(struct dentry *dentry, struct iattr *ia) struct path lower_path; struct iattr lower_ia; - inode = dentry->d_inode; + inode = d_inode(dentry); /* * Check if user has permission to change inode. We don't check if @@ -403,14 +403,14 @@ static int wrapfs_setattr(struct dentry *dentry, struct iattr *ia) /* notify the (possibly copied-up) lower inode */ /* - * Note: we use lower_dentry->d_inode, because lower_inode may be + * Note: we use d_inode(lower_dentry), 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); + mutex_lock(&d_inode(lower_dentry)->i_mutex); err = notify_change(lower_dentry, &lower_ia, /* note: lower_ia */ NULL); - mutex_unlock(&lower_dentry->d_inode->i_mutex); + mutex_unlock(&d_inode(lower_dentry)->i_mutex); if (err) goto out; @@ -439,9 +439,9 @@ static int wrapfs_getattr(struct vfsmount *mnt, struct dentry *dentry, 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); + fsstack_copy_attr_all(d_inode(dentry), + d_inode(lower_path.dentry)); + generic_fillattr(d_inode(dentry), stat); stat->blocks = lower_stat.blocks; out: wrapfs_put_lower_path(dentry, &lower_path); @@ -457,13 +457,13 @@ wrapfs_setxattr(struct dentry *dentry, const char *name, const void *value, wrapfs_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) { + if (!d_inode(lower_dentry)->i_op || + !d_inode(lower_dentry)->i_op->setxattr) { err = -EINVAL; goto out; } - err = lower_dentry->d_inode->i_op->setxattr(lower_dentry, + err = d_inode(lower_dentry)->i_op->setxattr(lower_dentry, name, value, size, flags); out: wrapfs_put_lower_path(dentry, &lower_path); @@ -480,13 +480,13 @@ wrapfs_getxattr(struct dentry *dentry, const char *name, void *buffer, wrapfs_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) { + if (!d_inode(lower_dentry)->i_op || + !d_inode(lower_dentry)->i_op->getxattr) { err = -EINVAL; goto out; } - err = lower_dentry->d_inode->i_op->getxattr(lower_dentry, + err = d_inode(lower_dentry)->i_op->getxattr(lower_dentry, name, buffer, size); out: wrapfs_put_lower_path(dentry, &lower_path); @@ -502,13 +502,13 @@ wrapfs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size) wrapfs_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) { + if (!d_inode(lower_dentry)->i_op || + !d_inode(lower_dentry)->i_op->listxattr) { err = -EINVAL; goto out; } - err = lower_dentry->d_inode->i_op->listxattr(lower_dentry, + err = d_inode(lower_dentry)->i_op->listxattr(lower_dentry, buffer, buffer_size); out: wrapfs_put_lower_path(dentry, &lower_path); @@ -524,13 +524,13 @@ wrapfs_removexattr(struct dentry *dentry, const char *name) wrapfs_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) { + if (!d_inode(lower_dentry)->i_op || + !d_inode(lower_dentry)->i_op->removexattr) { err = -EINVAL; goto out; } - err = lower_dentry->d_inode->i_op->removexattr(lower_dentry, + err = d_inode(lower_dentry)->i_op->removexattr(lower_dentry, name); out: wrapfs_put_lower_path(dentry, &lower_path); diff --git a/fs/wrapfs/lookup.c b/fs/wrapfs/lookup.c index cf76558c3248..7e6d51f1268a 100644 --- a/fs/wrapfs/lookup.c +++ b/fs/wrapfs/lookup.c @@ -159,7 +159,7 @@ int wrapfs_interpose(struct dentry *dentry, struct super_block *sb, struct inode *lower_inode; struct super_block *lower_sb; - lower_inode = lower_path->dentry->d_inode; + lower_inode = d_inode(lower_path->dentry); lower_sb = wrapfs_lower_super(sb); /* check that the lower file system didn't cross a mount point */ @@ -290,12 +290,12 @@ struct dentry *wrapfs_lookup(struct inode *dir, struct dentry *dentry, goto out; if (ret) dentry = ret; - if (dentry->d_inode) - fsstack_copy_attr_times(dentry->d_inode, - wrapfs_lower_inode(dentry->d_inode)); + if (d_inode(dentry)) + fsstack_copy_attr_times(d_inode(dentry), + wrapfs_lower_inode(d_inode(dentry))); /* update parent directory's atime */ - fsstack_copy_attr_atime(parent->d_inode, - wrapfs_lower_inode(parent->d_inode)); + fsstack_copy_attr_atime(d_inode(parent), + wrapfs_lower_inode(d_inode(parent))); out: wrapfs_put_lower_path(parent, &lower_parent_path); diff --git a/fs/wrapfs/main.c b/fs/wrapfs/main.c index 5ce79304f6ed..c479c3bc0866 100644 --- a/fs/wrapfs/main.c +++ b/fs/wrapfs/main.c @@ -65,7 +65,7 @@ static int wrapfs_read_super(struct super_block *sb, void *raw_data, int silent) sb->s_op = &wrapfs_sops; /* get a new inode and allocate our root dentry */ - inode = wrapfs_iget(sb, lower_path.dentry->d_inode); + inode = wrapfs_iget(sb, d_inode(lower_path.dentry)); if (IS_ERR(inode)) { err = PTR_ERR(inode); goto out_sput; diff --git a/fs/wrapfs/wrapfs.h b/fs/wrapfs/wrapfs.h index 24928834a563..7d1d4ef3843a 100644 --- a/fs/wrapfs/wrapfs.h +++ b/fs/wrapfs/wrapfs.h @@ -192,13 +192,13 @@ static inline void wrapfs_put_reset_lower_path(const struct dentry *dent) static inline struct dentry *lock_parent(struct dentry *dentry) { struct dentry *dir = dget_parent(dentry); - mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT); + mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT); return dir; } static inline void unlock_dir(struct dentry *dir) { - mutex_unlock(&dir->d_inode->i_mutex); + mutex_unlock(&d_inode(dir)->i_mutex); dput(dir); } #endif /* not _WRAPFS_H_ */ -- 2.34.1