diff --git a/kmod/src/data.c b/kmod/src/data.c
index 3ecb3341..9e136c08 100644
--- a/kmod/src/data.c
+++ b/kmod/src/data.c
@@ -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;
 
diff --git a/kmod/src/dir.c b/kmod/src/dir.c
index 8581a8a5..5ac19786 100644
--- a/kmod/src/dir.c
+++ b/kmod/src/dir.c
@@ -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;
 
diff --git a/kmod/src/inode.c b/kmod/src/inode.c
index 1b9761b6..df96b762 100644
--- a/kmod/src/inode.c
+++ b/kmod/src/inode.c
@@ -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);
 
diff --git a/kmod/src/lock.c b/kmod/src/lock.c
index 360fe216..cd1e1aef 100644
--- a/kmod/src/lock.c
+++ b/kmod/src/lock.c
@@ -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
diff --git a/kmod/src/lock.h b/kmod/src/lock.h
index d47f9a7c..20dcaa46 100644
--- a/kmod/src/lock.h
+++ b/kmod/src/lock.h
@@ -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);
diff --git a/kmod/src/server.c b/kmod/src/server.c
index 427a6463..aa2d7588 100644
--- a/kmod/src/server.c
+++ b/kmod/src/server.c
@@ -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;
 
diff --git a/kmod/src/xattr.c b/kmod/src/xattr.c
index ad24cda9..6174a011 100644
--- a/kmod/src/xattr.c
+++ b/kmod/src/xattr.c
@@ -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;