mirrors/scoutfs
1
0
Fork 0
mirror of https://github.com/versity/scoutfs.git synced 2026-02-07 11:10:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

scoutfs: refactor inode locking function

Browse Source 
This is based on Mark Fasheh <mfasheh@versity.com>'s series that
introduced inode refreshing after locking and a trylock for readpage.

Rework the inode locking function so that it's more clearly named and
takes flags and the inode struct.

We have callers that want to lock the logical inode but aren't doing
anything with the vfs inode so we provide that specific entry point.

Signed-off-by: Zach Brown <zab@versity.com>
This commit is contained in:
Zach Brown
2017-08-23 12:31:59 -07:00
parent e2befc8736
commit 51e03dcb7a
7 changed files with 32 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
kmod/src/data.c
View File

@@ -1187,8 +1187,7 @@ int scoutfs_data_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
/* XXX overkill? */
mutex_lock(&inode->i_mutex);
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_PR, scoutfs_ino(inode),
&inode_lock);
ret = scoutfs_lock_inode(sb, DLM_LOCK_PR, 0, inode, &inode_lock);
if (ret)
goto out;

33
kmod/src/dir.c
View File

@@ -259,8 +259,7 @@ static struct dentry *scoutfs_lookup(struct inode *dir, struct dentry *dentry,
goto out;
}
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_PR, scoutfs_ino(dir),
&dir_lock);
ret = scoutfs_lock_inode(sb, DLM_LOCK_PR, 0, dir, &dir_lock);
if (ret)
goto out;
@@ -350,8 +349,7 @@ static int scoutfs_readdir(struct file *file, void *dirent, filldir_t filldir)
if (!dir_emit_dots(file, dirent, filldir))
return 0;
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_PR, scoutfs_ino(inode),
&dir_lock);
ret = scoutfs_lock_inode(sb, DLM_LOCK_PR, 0, inode, &dir_lock);
if (ret)
return ret;
@@ -502,8 +500,7 @@ static int scoutfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
if (ret)
return ret;
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_EX, scoutfs_ino(dir),
&dir_lock);
ret = scoutfs_lock_inode(sb, DLM_LOCK_EX, 0, dir, &dir_lock);
if (ret)
return ret;
@@ -519,8 +516,7 @@ static int scoutfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
}
/* Now that we have ino from scoutfs_new_inode, allocate a lock */
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_EX, scoutfs_ino(inode),
&inode_lock);
ret = scoutfs_lock_inode(sb, DLM_LOCK_EX, 0, inode, &inode_lock);
if (ret)
goto out;
@@ -578,13 +574,11 @@ static int scoutfs_link(struct dentry *old_dentry,
if (inode->i_nlink >= SCOUTFS_LINK_MAX)
return -EMLINK;
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_EX, scoutfs_ino(dir),
&dir_lock);
ret = scoutfs_lock_inode(sb, DLM_LOCK_EX, 0, dir, &dir_lock);
if (ret)
return ret;
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_EX, scoutfs_ino(inode),
&inode_lock);
ret = scoutfs_lock_inode(sb, DLM_LOCK_EX, 0, inode, &inode_lock);
if (ret)
goto out_unlock;
@@ -640,13 +634,11 @@ static int scoutfs_unlink(struct inode *dir, struct dentry *dentry)
if (S_ISDIR(inode->i_mode) && i_size_read(inode))
return -ENOTEMPTY;
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_EX, scoutfs_ino(dir),
&dir_lock);
ret = scoutfs_lock_inode(sb, DLM_LOCK_EX, 0, dir, &dir_lock);
if (ret)
return ret;
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_EX, scoutfs_ino(inode),
&inode_lock);
ret = scoutfs_lock_inode(sb, DLM_LOCK_EX, 0, inode, &inode_lock);
if (ret)
goto out;
@@ -812,8 +804,7 @@ static void *scoutfs_follow_link(struct dentry *dentry, struct nameidata *nd)
if (size > PATH_MAX)
return ERR_PTR(-ENAMETOOLONG);
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_PR, scoutfs_ino(inode),
&inode_lock);
ret = scoutfs_lock_inode(sb, DLM_LOCK_PR, 0, inode, &inode_lock);
if (ret)
return ERR_PTR(ret);
@@ -881,8 +872,7 @@ static int scoutfs_symlink(struct inode *dir, struct dentry *dentry,
if (ret)
return ret;
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_EX, scoutfs_ino(dir),
&dir_lock);
ret = scoutfs_lock_inode(sb, DLM_LOCK_EX, 0, dir, &dir_lock);
if (ret)
return ret;
@@ -897,8 +887,7 @@ static int scoutfs_symlink(struct inode *dir, struct dentry *dentry,
goto out;
}
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_EX, scoutfs_ino(inode),
&inode_lock);
ret = scoutfs_lock_inode(sb, DLM_LOCK_EX, 0, inode, &inode_lock);
if (ret)
goto out;

5
kmod/src/inode.c
View File

@@ -275,8 +275,7 @@ static int scoutfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
struct scoutfs_lock *lock = NULL;
int ret;
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_PR, scoutfs_ino(inode),
&lock);
ret = scoutfs_lock_inode(sb, DLM_LOCK_PR, 0, inode, &lock);
if (ret)
return ret;
@@ -393,7 +392,7 @@ struct inode *scoutfs_iget(struct super_block *sb, u64 ino)
struct scoutfs_lock *lock = NULL;
int ret;
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_PR, ino, &lock);
ret = scoutfs_lock_ino(sb, DLM_LOCK_PR, 0, ino, &lock);
if (ret)
return ERR_PTR(ret);

11
kmod/src/lock.c
View File

@@ -23,6 +23,7 @@
#include "msg.h"
#include "cmp.h"
#include "dlmglue.h"
#include "inode.h"
#define LN_FMT "%u.%u.%llu.%llu"
#define LN_ARG(name) \
@@ -478,8 +479,8 @@ out:
#endif
}
int scoutfs_lock_ino_group(struct super_block *sb, int mode, u64 ino,
struct scoutfs_lock **ret_lock)
int scoutfs_lock_ino(struct super_block *sb, int mode, int flags, u64 ino,
struct scoutfs_lock **ret_lock)
{
struct scoutfs_lock_name lock_name;
struct scoutfs_inode_key start_ikey;
@@ -508,6 +509,12 @@ int scoutfs_lock_ino_group(struct super_block *sb, int mode, u64 ino,
&end, ret_lock);
}
int scoutfs_lock_inode(struct super_block *sb, int mode, int flags,
struct inode *inode, struct scoutfs_lock **ret_lock)
{
return scoutfs_lock_ino(sb, mode, flags, scoutfs_ino(inode), ret_lock);
}
/*
* map inode index items to locks. The idea is to not have to
* constantly get locks over a reasonable distribution of items, but

6
kmod/src/lock.h
View File

@@ -26,8 +26,10 @@ struct scoutfs_lock {
struct ocfs2_lock_res lockres;
};
int scoutfs_lock_ino_group(struct super_block *sb, int mode, u64 ino,
struct scoutfs_lock **ret_lock);
int scoutfs_lock_inode(struct super_block *sb, int mode, int flags,
struct inode *inode, struct scoutfs_lock **ret_lock);
int scoutfs_lock_ino(struct super_block *sb, int mode, int flags, u64 ino,
struct scoutfs_lock **ret_lock);
int scoutfs_lock_inode_index(struct super_block *sb, int mode,
u8 type, u64 major, u64 ino,
struct scoutfs_lock **ret_lock);

2
kmod/src/server.c
View File

@@ -888,7 +888,7 @@ static void scoutfs_server_func(struct work_struct *work)
init_waitqueue_head(&waitq);
/* lock attempt will return -ESHUTDOWN once we should not queue */
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_EX, ~0ULL, &lock);
ret = scoutfs_lock_ino(sb, DLM_LOCK_EX, 0, ~0ULL, &lock);
if (ret)
goto out;

8
kmod/src/xattr.c
View File

@@ -178,7 +178,7 @@ ssize_t scoutfs_getxattr(struct dentry *dentry, const char *name, void *buffer,
goto out;
}
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_PR, scoutfs_ino(inode), &lck);
ret = scoutfs_lock_inode(sb, DLM_LOCK_PR, 0, inode, &lck);
if (ret)
goto out;
@@ -289,7 +289,7 @@ static int scoutfs_xattr_set(struct dentry *dentry, const char *name,
goto out;
}
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_EX, scoutfs_ino(inode), &lck);
ret = scoutfs_lock_inode(sb, DLM_LOCK_EX, 0, inode, &lck);
if (ret)
goto out;
@@ -386,7 +386,7 @@ ssize_t scoutfs_listxattr(struct dentry *dentry, char *buffer, size_t size)
xkey = key->data;
xkey->name[0] = '\0';
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_PR, scoutfs_ino(inode), &lck);
ret = scoutfs_lock_inode(sb, DLM_LOCK_PR, 0, inode, &lck);
if (ret)
goto out;
@@ -469,7 +469,7 @@ int scoutfs_xattr_drop(struct super_block *sb, u64 ino)
}
/* while we read to delete we need to writeback others */
ret = scoutfs_lock_ino_group(sb, DLM_LOCK_EX, ino, &lck);
ret = scoutfs_lock_ino(sb, DLM_LOCK_EX, 0, ino, &lck);
if (ret)
goto out;