Skip to contentSkip to conversation

Case insensitiveness as a mountpoint

PATCH New Gabriel Krisman Bertazi 1 participant 14 messages May 22, 2018

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

cover Case insensitiveness as a mountpoint

Hi,

[[Just for recording at the ML. i am not proposing it for merge with the mountpoint design.]]

Just for completeness, this is the code I mentioned at LSFMM, which implements case-insensitive lookups as an attribute of the mountpoint, allowing support for simultaneous case-insensitive and senstive views of the filesystem.

It supports a single ci mountpoint like this:

mount -o ignorecase,encoding=utf8n-10.0.0 /dev/vda /mnt

It allows simultaneous views via a bind,remount, by supporting the parameter ignorecase. Like this:

mount -o ignorecase,encoding=utf8n-10.0.0 /dev/vda /mnt mount -o bind /mnt /mnt-ci
mount -o remount,bind,ignorecase none /mnt-ci

This patchset also enables ext4 ci support, which requires the utf8n implementation I submitted on the other patchset. utf8n is the only encoding supported by this ext4 code, but ascii can be trivially supported with a short patch to implement casefold/strcmp operations. Attempts to mount with other encodings will succeed but will trigger failures when attempting to access the filesystem. This could be improved at the fs layer to provide an error message at mount time.

The patchset for utf8n is awaiting review for merge at:
https://marc.info/?l=linux-fsdevel&m=152692428419075&w=2

Since the vfs/ext4 support in this patchset is just for the record, and I am not proposing to push this patchset current state anymore, feel free to ignore review for this.

If you want an easy way to fetch all the changes required to build this code, including the ucd source files used to generate the decodification tree, you can fetch directly from:

https://gitlab.collabora.com/krisman/linux.git -b vfs-ms_casefold-smart

Gabriel Krisman Bertazi (13):
vfs: Add support for mounting with MS_CASEFOLD
vfs: Propagate LOOKUP_CASEFOLD after doing parent lookups
vfs: Add support for positive dentries CI lookups in the dentry cache
vfs: Allow bind,remount with MS_CASEFOLD
vfs: Handle case-exact lookup in d_add_ci
vfs: Add Support for hard negative dentries in the dcache
vfs: Handle MNT_CASEFOLD in /proc/mounts
fscrypt: Introduce charset-based matching functions
ext4: Include encoding information on the superblock
ext4: Plumb LOOK_CASEFOLD up to ext4 comparison functions
ext4: Support charset name matching
ext4: Implement ext4 dcache hooks for custom charsets
ext4: Notify VFS of support for casefolded mountpoints

 fs/dcache.c                     | 95 +++++++++++++++++++++++---------
 fs/ext4/dir.c                   | 48 ++++++++++++++++
 fs/ext4/ext4.h                  |  9 ++-
 fs/ext4/inline.c                |  7 ++-
 fs/ext4/namei.c                 | 93 +++++++++++++++++++++----------
 fs/ext4/super.c                 | 49 ++++++++++++++++-
 fs/namei.c                      | 98 +++++++++++++++++++++++++++++----
 fs/namespace.c                  | 34 +++++++++---
 fs/proc_namespace.c             |  1 +
 include/linux/dcache.h          | 24 ++++++--
 include/linux/fs.h              |  2 +
 include/linux/fscrypt.h         |  1 +
 include/linux/fscrypt_notsupp.h | 16 ++++++
 include/linux/fscrypt_supp.h    | 27 +++++++++
 include/linux/mount.h           |  1 +
 include/linux/namei.h           |  1 +
 include/uapi/linux/fs.h         |  1 +
 17 files changed, 423 insertions(+), 84 deletions(-)
Signature · 1 line
2.17.0
#1 lore raw

PATCH 1/13 vfs: Add support for mounting with MS_CASEFOLD

At this point, negative dentries are ignored for LOOKUP_CASEFOLD. This will be addressed later in the series.

---
 fs/namei.c              | 27 +++++++++++++++++++++++++--
 fs/namespace.c          | 11 ++++++++++-
 include/linux/fs.h      |  2 ++
 include/linux/mount.h   |  1 +
 include/linux/namei.h   |  1 +
 include/uapi/linux/fs.h |  1 +
 6 files changed, 40 insertions(+), 3 deletions(-)
fs/namei.c +25 -2
index 921ae32dbc80..ddd5c9e9ab3c 100644
@@ -761,8 +761,15 @@ static inline int d_revalidate(struct dentry *dentry, unsigned int flags)
 {
 	if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE))
 		return dentry->d_op->d_revalidate(dentry, flags);
-	else
-		return 1;
+
+	/* Completely ignore negative dentries
+	   for LOOKUP_CASEFOLD. */
+	if (unlikely(flags & LOOKUP_CASEFOLD)) {
+		if (d_is_negative(dentry))
+			return 0;
+	}
+
+	return 1;
 }
 
 /**
@@ -1159,6 +1166,15 @@ static int follow_automount(struct path *path, struct nameidata *nd,
 
 }
 
+static void set_casefold_lookup(struct nameidata *nd, struct path *path)
+{
+	if (path && path->mnt &&
+	    path->mnt->mnt_flags & MNT_CASEFOLD)
+		nd->flags |= LOOKUP_CASEFOLD;
+	else
+		nd->flags &= ~LOOKUP_CASEFOLD;
+}
+
 /*
  * Handle a dentry that is managed in some way.
  * - Flagged for transit management (autofs)
@@ -1202,6 +1218,7 @@ static int follow_managed(struct path *path, struct nameidata *nd)
 				path->mnt = mounted;
 				path->dentry = dget(mounted->mnt_root);
 				need_mntput = true;
+				set_casefold_lookup(nd, path);
 				continue;
 			}
 
@@ -1288,6 +1305,7 @@ static bool __follow_mount_rcu(struct nameidata *nd, struct path *path,
 		path->mnt = &mounted->mnt;
 		path->dentry = mounted->mnt.mnt_root;
 		nd->flags |= LOOKUP_JUMPED;
+		set_casefold_lookup(nd, path);
 		*seqp = read_seqcount_begin(&path->dentry->d_seq);
 		/*
 		 * Update the inode too. We don't need to re-check the
@@ -1336,6 +1354,7 @@ static int follow_dotdot_rcu(struct nameidata *nd)
 			nd->path.mnt = &mparent->mnt;
 			inode = inode2;
 			nd->seq = seq;
+			set_casefold_lookup(nd, &nd->path);
 		}
 	}
 	while (unlikely(d_mountpoint(nd->path.dentry))) {
@@ -1350,6 +1369,7 @@ static int follow_dotdot_rcu(struct nameidata *nd)
 		inode = nd->path.dentry->d_inode;
 		nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
 	}
+	set_casefold_lookup(nd, &nd->path);
 	nd->inode = inode;
 	return 0;
 }
@@ -2143,6 +2163,7 @@ static const char *path_init(struct nameidata *nd, unsigned flags)
 		} else {
 			path_get(&nd->path);
 		}
+		set_casefold_lookup(nd, &nd->path);
 		return s;
 	}
 
@@ -2177,6 +2198,7 @@ static const char *path_init(struct nameidata *nd, unsigned flags)
 			get_fs_pwd(current->fs, &nd->path);
 			nd->inode = nd->path.dentry->d_inode;
 		}
+		set_casefold_lookup(nd, &nd->path);
 		return s;
 	} else {
 		/* Caller must check execute permissions on the starting path component */
@@ -2205,6 +2227,7 @@ static const char *path_init(struct nameidata *nd, unsigned flags)
 			nd->inode = nd->path.dentry->d_inode;
 		}
 		fdput(f);
+		set_casefold_lookup(nd, &nd->path);
 		return s;
 	}
 }
fs/namespace.c +10 -1
index 9d1374ab6e06..0053e29b73cc 100644
@@ -2509,6 +2509,12 @@ static int do_new_mount(struct path *path, const char *fstype, int sb_flags,
 	if (!type)
 		return -ENODEV;
 
+	if (mnt_flags & MNT_CASEFOLD &&
+	    !(type->fs_flags & FS_HAS_CASEFOLD)) {
+		put_filesystem(type);
+		return -EINVAL;
+	}
+
 	mnt = vfs_kern_mount(type, sb_flags, name, data);
 	if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
 	    !mnt->mnt_sb->s_subtype)
@@ -2809,6 +2815,8 @@ long do_mount(const char *dev_name, const char __user *dir_name,
 		mnt_flags |= MNT_NODIRATIME;
 	if (flags & MS_STRICTATIME)
 		mnt_flags &= ~(MNT_RELATIME | MNT_NOATIME);
+	if (flags & MS_CASEFOLD)
+		mnt_flags |= MNT_CASEFOLD;
 	if (flags & SB_RDONLY)
 		mnt_flags |= MNT_READONLY;
 
@@ -2827,7 +2835,8 @@ long do_mount(const char *dev_name, const char __user *dir_name,
 			    SB_SILENT |
 			    SB_POSIXACL |
 			    SB_LAZYTIME |
-			    SB_I_VERSION);
+			    SB_I_VERSION |
+			    SB_CASEFOLD);
 
 	if (flags & MS_REMOUNT)
 		retval = do_remount(&path, flags, sb_flags, mnt_flags,
include/linux/fs.h +2 -0
index 2a815560fda0..743d38876a51 100644
@@ -1287,6 +1287,7 @@ extern int send_sigurg(struct fown_struct *fown);
 #define SB_SYNCHRONOUS	16	/* Writes are synced at once */
 #define SB_MANDLOCK	64	/* Allow mandatory locks on an FS */
 #define SB_DIRSYNC	128	/* Directory modifications are synchronous */
+#define SB_CASEFOLD	256	/* Directory lookups are case-insensitive */
 #define SB_NOATIME	1024	/* Do not update access times. */
 #define SB_NODIRATIME	2048	/* Do not update directory access times */
 #define SB_SILENT	32768
@@ -2069,6 +2070,7 @@ struct file_system_type {
 #define FS_BINARY_MOUNTDATA	2
 #define FS_HAS_SUBTYPE		4
 #define FS_USERNS_MOUNT		8	/* Can be mounted by userns root */
+#define FS_HAS_CASEFOLD	        16
 #define FS_RENAME_DOES_D_MOVE	32768	/* FS will handle d_move() during rename() internally. */
 	struct dentry *(*mount) (struct file_system_type *, int,
 		       const char *, void *);
include/linux/mount.h +1 -0
index 45b1f56c6c2f..05f5d6f71108 100644
@@ -52,6 +52,7 @@ struct mnt_namespace;
 			    MNT_DOOMED | MNT_SYNC_UMOUNT | MNT_MARKED)
 
 #define MNT_INTERNAL	0x4000
+#define MNT_CASEFOLD	0x8000
 
 #define MNT_LOCK_ATIME		0x040000
 #define MNT_LOCK_NOEXEC		0x080000
include/linux/namei.h +1 -0
index a982bb7cd480..fb74ab4c86f3 100644
@@ -46,6 +46,7 @@ enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
 #define LOOKUP_ROOT		0x2000
 #define LOOKUP_EMPTY		0x4000
 #define LOOKUP_DOWN		0x8000
+#define LOOKUP_CASEFOLD	      0x010000
 
 extern int path_pts(struct path *path);
 
include/uapi/linux/fs.h +1 -0
index d2a8313fabd7..7fa23e5f49d6 100644
@@ -113,6 +113,7 @@ struct inodes_stat_t {
 #define MS_REMOUNT	32	/* Alter flags of a mounted FS */
 #define MS_MANDLOCK	64	/* Allow mandatory locks on an FS */
 #define MS_DIRSYNC	128	/* Directory modifications are synchronous */
+#define MS_CASEFOLD	256	/* Directory lookups are case-insensitive */
 #define MS_NOATIME	1024	/* Do not update access times. */
 #define MS_NODIRATIME	2048	/* Do not update directory access times */
 #define MS_BIND		4096
Signature · 1 line
2.17.0
#2 lore raw

PATCH 2/13 vfs: Propagate LOOKUP_CASEFOLD after doing parent lookups

In reply to Gabriel Krisman Bertazi

filename_parentat() is executed in order to quickly access a child dentry for creation, unlinking or rename, outside the path_walk path. Although, if the parent was accessed via a CI mount, we need to make sure the child will also be searched in a CI manner, so the nameidata flag from the first search needs to be propageted to the following child __lookup_hash call.

---
 fs/namei.c | 61 +++++++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 54 insertions(+), 7 deletions(-)
fs/namei.c +54 -7
index ddd5c9e9ab3c..135a9a4e676b 100644
@@ -2369,7 +2369,7 @@ static int path_parentat(struct nameidata *nd, unsigned flags,
 
 static struct filename *filename_parentat(int dfd, struct filename *name,
 				unsigned int flags, struct path *parent,
-				struct qstr *last, int *type)
+				struct qstr *last, int *type, bool *foldtree)
 {
 	int retval;
 	struct nameidata nd;
@@ -2385,6 +2385,7 @@ static struct filename *filename_parentat(int dfd, struct filename *name,
 	if (likely(!retval)) {
 		*last = nd.last;
 		*type = nd.last_type;
+		*foldtree = !!(nd.flags & LOOKUP_CASEFOLD);
 		audit_inode(name, parent->dentry, LOOKUP_PARENT);
 	} else {
 		putname(name);
@@ -2401,9 +2402,14 @@ struct dentry *kern_path_locked(const char *name, struct path *path)
 	struct dentry *d;
 	struct qstr last;
 	int type;
+	bool foldtree = false;
 
 	filename = filename_parentat(AT_FDCWD, getname_kernel(name), 0, path,
-				    &last, &type);
+				     &last, &type, &foldtree);
+
+	/* kernel path don't care about foldtree.  Root cannot be folded. */
+	WARN_ON(foldtree);
+
 	if (IS_ERR(filename))
 		return ERR_CAST(filename);
 	if (unlikely(type != LAST_NORM)) {
@@ -3620,6 +3626,7 @@ static struct dentry *filename_create(int dfd, struct filename *name,
 	int err2;
 	int error;
 	bool is_dir = (lookup_flags & LOOKUP_DIRECTORY);
+	bool foldtree = false;
 
 	/*
 	 * Note that only LOOKUP_REVAL and LOOKUP_DIRECTORY matter here. Any
@@ -3627,7 +3634,8 @@ static struct dentry *filename_create(int dfd, struct filename *name,
 	 */
 	lookup_flags &= LOOKUP_REVAL;
 
-	name = filename_parentat(dfd, name, lookup_flags, path, &last, &type);
+	name = filename_parentat(dfd, name, lookup_flags, path, &last,
+				 &type, &foldtree);
 	if (IS_ERR(name))
 		return ERR_CAST(name);
 
@@ -3644,6 +3652,16 @@ static struct dentry *filename_create(int dfd, struct filename *name,
 	 * Do the final lookup.
 	 */
 	lookup_flags |= LOOKUP_CREATE | LOOKUP_EXCL;
+
+	/* If parent is a casefold mountpoint, search for an existing
+	 * dentry with LOOKUP_CASEFOLD.
+	 * LOOKUP_CASEFOLD needs to be explicitly cleared in case it is
+	 * doing retry. */
+	if (foldtree)
+		lookup_flags |= LOOKUP_CASEFOLD;
+	else
+		lookup_flags &= ~LOOKUP_CASEFOLD;
+
 	inode_lock_nested(path->dentry->d_inode, I_MUTEX_PARENT);
 	dentry = __lookup_hash(&last, path->dentry, lookup_flags);
 	if (IS_ERR(dentry))
@@ -3904,9 +3922,10 @@ static long do_rmdir(int dfd, const char __user *pathname)
 	struct qstr last;
 	int type;
 	unsigned int lookup_flags = 0;
+	bool foldtree;
 retry:
 	name = filename_parentat(dfd, getname(pathname), lookup_flags,
-				&path, &last, &type);
+				 &path, &last, &type, &foldtree);
 	if (IS_ERR(name))
 		return PTR_ERR(name);
 
@@ -3926,6 +3945,13 @@ static long do_rmdir(int dfd, const char __user *pathname)
 	if (error)
 		goto exit1;
 
+	/* LOOKUP_CASEFOLD needs to be explicitly cleared in case it is
+	 * doing retry. */
+	if (foldtree)
+		lookup_flags |= LOOKUP_CASEFOLD;
+	else
+		lookup_flags &= ~LOOKUP_CASEFOLD;
+
 	inode_lock_nested(path.dentry->d_inode, I_MUTEX_PARENT);
 	dentry = __lookup_hash(&last, path.dentry, lookup_flags);
 	error = PTR_ERR(dentry);
@@ -4033,8 +4059,10 @@ long do_unlinkat(int dfd, struct filename *name)
 	struct inode *inode = NULL;
 	struct inode *delegated_inode = NULL;
 	unsigned int lookup_flags = 0;
+	bool foldtree = false;
 retry:
-	name = filename_parentat(dfd, name, lookup_flags, &path, &last, &type);
+	name = filename_parentat(dfd, name, lookup_flags, &path, &last, &type,
+				 &foldtree);
 	if (IS_ERR(name))
 		return PTR_ERR(name);
 
@@ -4045,6 +4073,13 @@ long do_unlinkat(int dfd, struct filename *name)
 	error = mnt_want_write(path.mnt);
 	if (error)
 		goto exit1;
+
+	/* LOOKUP_CASEFOLD needs to be explicitly cleared in case it is
+	 * doing retry. */
+	if (foldtree)
+		lookup_flags |= LOOKUP_CASEFOLD;
+	else
+		lookup_flags &= ~LOOKUP_CASEFOLD;
 retry_deleg:
 	inode_lock_nested(path.dentry->d_inode, I_MUTEX_PARENT);
 	dentry = __lookup_hash(&last, path.dentry, lookup_flags);
@@ -4514,6 +4549,7 @@ SYSCALL_DEFINE5(renameat2, int, olddfd, const char __user *, oldname,
 	struct filename *to;
 	unsigned int lookup_flags = 0, target_flags = LOOKUP_RENAME_TARGET;
 	bool should_retry = false;
+	bool foldtree = false;
 	int error;
 
 	if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
@@ -4531,14 +4567,14 @@ SYSCALL_DEFINE5(renameat2, int, olddfd, const char __user *, oldname,
 
 retry:
 	from = filename_parentat(olddfd, getname(oldname), lookup_flags,
-				&old_path, &old_last, &old_type);
+				 &old_path, &old_last, &old_type, &foldtree);
 	if (IS_ERR(from)) {
 		error = PTR_ERR(from);
 		goto exit;
 	}
 
 	to = filename_parentat(newdfd, getname(newname), lookup_flags,
-				&new_path, &new_last, &new_type);
+			       &new_path, &new_last, &new_type, &foldtree);
 	if (IS_ERR(to)) {
 		error = PTR_ERR(to);
 		goto exit1;
@@ -4561,6 +4597,17 @@ SYSCALL_DEFINE5(renameat2, int, olddfd, const char __user *, oldname,
 	if (error)
 		goto exit2;
 
+	/* Since rename(2) doesn't work across mountpoints, we are sure
+	 * that foldtree for TO and FROM are the same.
+	 *
+	 * LOOKUP_CASEFOLD needs to be explicitly cleared in case it is
+	 * doing retry. */
+	if (foldtree)
+		lookup_flags |= LOOKUP_CASEFOLD;
+	else
+		lookup_flags &= ~LOOKUP_CASEFOLD;
+
+
 retry_deleg:
 	trap = lock_rename(new_path.dentry, old_path.dentry);
 
Signature · 1 line
2.17.0
#3 lore raw

PATCH 3/13 vfs: Add support for positive dentries CI lookups in the dentry cache

In reply to Gabriel Krisman Bertazi

Negative dentries are still invalidated, triggering a lookup in the disk.

---
 fs/dcache.c            | 43 +++++++++++++++++++++++++++++++++---------
 fs/namei.c             |  5 +++--
 include/linux/dcache.h |  8 ++++++--
 3 files changed, 43 insertions(+), 13 deletions(-)
fs/dcache.c +34 -9
index 7c38f39958bc..4bd28d7caa53 100644
@@ -2049,6 +2049,16 @@ struct dentry *d_obtain_root(struct inode *inode)
 }
 EXPORT_SYMBOL(d_obtain_root);
 
+static inline bool d_same_name_ci(const struct dentry *dentry,
+				  const struct dentry *parent,
+				  const struct qstr *name)
+{
+	return parent->d_op->d_compare_ci(dentry,
+					  dentry->d_name.len,
+					  dentry->d_name.name,
+					  name) == 0;
+}
+
 /**
  * d_add_ci - lookup or allocate new dentry with case-exact name
  * @inode:  the inode case-insensitive lookup has found
@@ -2122,6 +2132,7 @@ static inline bool d_same_name(const struct dentry *dentry,
  * @parent: parent dentry
  * @name: qstr of name we wish to find
  * @seqp: returns d_seq value at the point where the dentry was found
+ * @ci_lookup: Whether d_lookup_rcu should do a CI lookup
  * Returns: dentry, or NULL
  *
  * __d_lookup_rcu is the dcache lookup function for rcu-walk name
@@ -2148,7 +2159,7 @@ static inline bool d_same_name(const struct dentry *dentry,
  */
 struct dentry *__d_lookup_rcu(const struct dentry *parent,
 				const struct qstr *name,
-				unsigned *seqp)
+				unsigned *seqp, int ci_lookup)
 {
 	u64 hashlen = name->hash_len;
 	const unsigned char *str = name->name;
@@ -2215,9 +2226,16 @@ struct dentry *__d_lookup_rcu(const struct dentry *parent,
 				cpu_relax();
 				goto seqretry;
 			}
-			if (parent->d_op->d_compare(dentry,
-						    tlen, tname, name) != 0)
-				continue;
+
+			if (ci_lookup) {
+				if (parent->d_op->d_compare_ci(dentry, tlen,
+							       tname, name) != 0)
+					continue;
+			} else {
+				if (parent->d_op->d_compare(dentry, tlen,
+							    tname, name) != 0)
+					continue;
+			}
 		} else {
 			if (dentry->d_name.hash_len != hashlen)
 				continue;
@@ -2248,7 +2266,7 @@ struct dentry *d_lookup(const struct dentry *parent, const struct qstr *name)
 
 	do {
 		seq = read_seqbegin(&rename_lock);
-		dentry = __d_lookup(parent, name);
+		dentry = __d_lookup(parent, name, 0);
 		if (dentry)
 			break;
 	} while (read_seqretry(&rename_lock, seq));
@@ -2260,6 +2278,7 @@ EXPORT_SYMBOL(d_lookup);
  * __d_lookup - search for a dentry (racy)
  * @parent: parent dentry
  * @name: qstr of name we wish to find
+ * @ci_lookup: Whether d_lookup_rcu should do a CI lookup
  * Returns: dentry, or NULL
  *
  * __d_lookup is like d_lookup, however it may (rarely) return a
@@ -2271,7 +2290,8 @@ EXPORT_SYMBOL(d_lookup);
  *
  * __d_lookup callers must be commented.
  */
-struct dentry *__d_lookup(const struct dentry *parent, const struct qstr *name)
+struct dentry *__d_lookup(const struct dentry *parent, const struct qstr *name,
+			  int ci_lookup)
 {
 	unsigned int hash = name->hash;
 	struct hlist_bl_head *b = d_hash(hash);
@@ -2312,8 +2332,13 @@ struct dentry *__d_lookup(const struct dentry *parent, const struct qstr *name)
 		if (d_unhashed(dentry))
 			goto next;
 
-		if (!d_same_name(dentry, parent, name))
-			goto next;
+		if (ci_lookup) {
+			if (!d_same_name_ci(dentry, parent, name))
+				goto next;
+		} else {
+			if (!d_same_name(dentry, parent, name))
+				goto next;
+		}
 
 		dentry->d_lockref.count++;
 		found = dentry;
@@ -2476,7 +2501,7 @@ struct dentry *d_alloc_parallel(struct dentry *parent,
 	rcu_read_lock();
 	seq = smp_load_acquire(&parent->d_inode->i_dir_seq) & ~1;
 	r_seq = read_seqbegin(&rename_lock);
-	dentry = __d_lookup_rcu(parent, name, &d_seq);
+	dentry = __d_lookup_rcu(parent, name, &d_seq, 0);
 	if (unlikely(dentry)) {
 		if (!lockref_get_not_dead(&dentry->d_lockref)) {
 			rcu_read_unlock();
fs/namei.c +3 -2
index 135a9a4e676b..1ebe5e775a9a 100644
@@ -1540,6 +1540,7 @@ static int lookup_fast(struct nameidata *nd,
 	struct dentry *dentry, *parent = nd->path.dentry;
 	int status = 1;
 	int err;
+	int ci_lookup = (nd->flags & LOOKUP_CASEFOLD);
 
 	/*
 	 * Rename seqlock is not required here because in the off chance
@@ -1549,7 +1550,7 @@ static int lookup_fast(struct nameidata *nd,
 	if (nd->flags & LOOKUP_RCU) {
 		unsigned seq;
 		bool negative;
-		dentry = __d_lookup_rcu(parent, &nd->last, &seq);
+		dentry = __d_lookup_rcu(parent, &nd->last, &seq, ci_lookup);
 		if (unlikely(!dentry)) {
 			if (unlazy_walk(nd))
 				return -ECHILD;
@@ -1595,7 +1596,7 @@ static int lookup_fast(struct nameidata *nd,
 			/* we'd been told to redo it in non-rcu mode */
 			status = d_revalidate(dentry, nd->flags);
 	} else {
-		dentry = __d_lookup(parent, &nd->last);
+		dentry = __d_lookup(parent, &nd->last, ci_lookup);
 		if (unlikely(!dentry))
 			return 0;
 		status = d_revalidate(dentry, nd->flags);
include/linux/dcache.h +6 -2
index 82a99d366aec..a4ce5ea207ad 100644
@@ -139,6 +139,8 @@ struct dentry_operations {
 	int (*d_hash)(const struct dentry *, struct qstr *);
 	int (*d_compare)(const struct dentry *,
 			unsigned int, const char *, const struct qstr *);
+	int (*d_compare_ci)(const struct dentry *,
+			    unsigned int, const char *, const struct qstr *);
 	int (*d_delete)(const struct dentry *);
 	int (*d_init)(struct dentry *);
 	void (*d_release)(struct dentry *);
@@ -282,9 +284,11 @@ extern struct dentry *d_ancestor(struct dentry *, struct dentry *);
 /* appendix may either be NULL or be used for transname suffixes */
 extern struct dentry *d_lookup(const struct dentry *, const struct qstr *);
 extern struct dentry *d_hash_and_lookup(struct dentry *, struct qstr *);
-extern struct dentry *__d_lookup(const struct dentry *, const struct qstr *);
+extern struct dentry *__d_lookup(const struct dentry *, const struct qstr *,
+				 int ci_lookup);
 extern struct dentry *__d_lookup_rcu(const struct dentry *parent,
-				const struct qstr *name, unsigned *seq);
+				const struct qstr *name, unsigned *seq,
+				int ci_lookup);
 
 static inline unsigned d_count(const struct dentry *dentry)
 {
Signature · 1 line
2.17.0
#4 lore raw

PATCH 4/13 vfs: Allow bind,remount with MS_CASEFOLD

In reply to Gabriel Krisman Bertazi
---
 fs/namespace.c | 23 +++++++++++++++++------
 1 file changed, 17 insertions(+), 6 deletions(-)
fs/namespace.c +17 -6
index 0053e29b73cc..127d3028c1e8 100644
@@ -2261,17 +2261,28 @@ static int do_loopback(struct path *path, const char *old_name,
 static int change_mount_flags(struct vfsmount *mnt, int ms_flags)
 {
 	int error = 0;
-	int readonly_request = 0;
+	int readonly_request = 0, casefold_request = 0;
 
 	if (ms_flags & MS_RDONLY)
 		readonly_request = 1;
-	if (readonly_request == __mnt_is_readonly(mnt))
-		return 0;
+	if (ms_flags & MS_CASEFOLD)
+		casefold_request = 1;
+
+	if (readonly_request != __mnt_is_readonly(mnt)) {
+		if (readonly_request)
+			error = mnt_make_readonly(real_mount(mnt));
+		else
+			__mnt_unmake_readonly(real_mount(mnt));
+		if (error)
+			goto out;
+	}
 
-	if (readonly_request)
-		error = mnt_make_readonly(real_mount(mnt));
+	if (casefold_request)
+		mnt->mnt_flags |= MNT_CASEFOLD;
 	else
-		__mnt_unmake_readonly(real_mount(mnt));
+		mnt->mnt_flags &= ~MNT_CASEFOLD;
+
+out:
 	return error;
 }
 
Signature · 1 line
2.17.0
#5 lore raw

PATCH 5/13 vfs: Handle case-exact lookup in d_add_ci

In reply to Gabriel Krisman Bertazi

This prevents a soft hang if called d_add_ci is called from the FS layer, when doing a CI search but the result dentry is the exact match.

---
 fs/dcache.c | 33 ++++++++++++++++++---------------
 1 file changed, 18 insertions(+), 15 deletions(-)
fs/dcache.c +18 -15
index 4bd28d7caa53..30c5eff31e88 100644
@@ -2049,6 +2049,20 @@ struct dentry *d_obtain_root(struct inode *inode)
 }
 EXPORT_SYMBOL(d_obtain_root);
 
+static inline bool d_same_name(const struct dentry *dentry,
+				const struct dentry *parent,
+				const struct qstr *name)
+{
+	if (likely(!(parent->d_flags & DCACHE_OP_COMPARE))) {
+		if (dentry->d_name.len != name->len)
+			return false;
+		return dentry_cmp(dentry, name->name, name->len) == 0;
+	}
+	return parent->d_op->d_compare(dentry,
+				       dentry->d_name.len, dentry->d_name.name,
+				       name) == 0;
+}
+
 static inline bool d_same_name_ci(const struct dentry *dentry,
 				  const struct dentry *parent,
 				  const struct qstr *name)
@@ -2080,6 +2094,10 @@ struct dentry *d_add_ci(struct dentry *dentry, struct inode *inode,
 {
 	struct dentry *found, *res;
 
+	/* Trivial case: CI search is exact match.  */
+	if (d_same_name(dentry, dentry->d_parent, name))
+		return d_splice_alias(inode, dentry);
+
 	/*
 	 * First check if a dentry matching the name already exists,
 	 * if not go ahead and create it now.
@@ -2112,21 +2130,6 @@ struct dentry *d_add_ci(struct dentry *dentry, struct inode *inode,
 }
 EXPORT_SYMBOL(d_add_ci);
 
-
-static inline bool d_same_name(const struct dentry *dentry,
-				const struct dentry *parent,
-				const struct qstr *name)
-{
-	if (likely(!(parent->d_flags & DCACHE_OP_COMPARE))) {
-		if (dentry->d_name.len != name->len)
-			return false;
-		return dentry_cmp(dentry, name->name, name->len) == 0;
-	}
-	return parent->d_op->d_compare(dentry,
-				       dentry->d_name.len, dentry->d_name.name,
-				       name) == 0;
-}
-
 /**
  * __d_lookup_rcu - search for a dentry (racy, store-free)
  * @parent: parent dentry
Signature · 1 line
2.17.0
#6 lore raw

PATCH 6/13 vfs: Add Support for hard negative dentries in the dcache

In reply to Gabriel Krisman Bertazi

A hard negative dentry is created after an unsuccessful case-insensitive(CI) lookup operation, to indicate that there is not any file in that directory whose casefolded name matches the casefolded searched name.

Hard negative dentries are the CI counterpart of the existing negative dentries for the case-isensitive lookup case. For clarity, this patch denotes the old negative dentry as "soft negative dentry" where applicable. In places where it doesn't matter whether it is a hard or soft dentry, the wrapper d_is_negative() can still be used.

Despite being the counterpart of soft negative dentries, a hard dentry actually express a much stronger constraint, asserting that there is no name in the filesystem that would match the string being searched, AFTER a casefold() operation. A hard negative dentry allows the dcache to return a -ENOENT immediately during a dcache lookup , eliminating the need to go to the disk for every CI operation. The hard negative dentry definition also encloses the soft dentry constraint, such that we can also use a hard negative dentry to return ENOENT after a Case sensitive(CS) lookup.

Special care must be taken to invalidate (or at least demote) Hard dentries once a matching file is created in the disk. The file being created might not have the exact name as the hard dentry (but it must have an exact casefold match), but this still means the dentry must be invalidated. This is handled by invalidating the dentry found in lookup_open, only if it is a hard negative. Unless we are doing a creation, there is no need to invalidate it elsewhere.

Soft dentries could be promoted to hard dentries after a LOOKUP_CASEFOLD operation, but for simplifying the code, we don't do the promotion explicitly, instead we invalidate the soft dentry and recreate it during the following lookup as a hard dentry. Likewise, hard dentries could be demoted when a inexact-case match is created. For this case, the current code also invalidates the dentry and creates a new one.

Filesystems who want to expose CI operations must make sure their revalidate() functions no longer reject any type of negative dentries, they can only reject soft negatives. If they do reject negative dentries, say in the transition phase, there is no problem, they will be basically ignoring this feature and paying the cost to hit the disk everytime.

A function called d_add_ci_negative_dentry is also added in this series, as a helper for user filesystems, when they hit an inexisting file during a LOOKUP_CASEFOLD operation. An example of usage comes later in the series, with the patches that add LOOKUP_CASEFOLD support for the EXT4 filesystem.

This patch reduces the time of doing an inexact-name lookup of 10k inexistant but already dcached files, down to 0.007 seconds in my test vm, which is pretty similar to issuing the same operation to a CS filesystem without this patch series.

---
 fs/dcache.c            | 29 +++++++++++++++++++++--------
 fs/namei.c             |  7 +++++--
 include/linux/dcache.h | 16 ++++++++++++++--
 3 files changed, 40 insertions(+), 12 deletions(-)
fs/dcache.c +21 -8
index 30c5eff31e88..a68af63c8a96 100644
@@ -1784,12 +1784,17 @@ void d_set_fallthru(struct dentry *dentry)
 }
 EXPORT_SYMBOL(d_set_fallthru);
 
-static unsigned d_flags_for_inode(struct inode *inode)
+static unsigned d_flags_for_inode(struct dentry *dentry, struct inode *inode)
 {
 	unsigned add_flags = DCACHE_REGULAR_TYPE;
 
-	if (!inode)
-		return DCACHE_MISS_TYPE;
+	if (!inode) {
+		/* hard negative dentries get set beforehand. */
+		if (d_is_hard_negative(dentry))
+			return DCACHE_HARD_NEGATIVE_TYPE;
+		else
+			return DCACHE_MISS_TYPE;
+	}
 
 	if (S_ISDIR(inode->i_mode)) {
 		add_flags = DCACHE_DIRECTORY_TYPE;
@@ -1821,7 +1826,7 @@ static unsigned d_flags_for_inode(struct inode *inode)
 
 static void __d_instantiate(struct dentry *dentry, struct inode *inode)
 {
-	unsigned add_flags = d_flags_for_inode(inode);
+	unsigned add_flags = d_flags_for_inode(dentry, inode);
 	WARN_ON(d_in_lookup(dentry));
 
 	spin_lock(&dentry->d_lock);
@@ -1948,7 +1953,7 @@ static struct dentry *__d_instantiate_anon(struct dentry *dentry,
 	}
 
 	/* attach a disconnected dentry */
-	add_flags = d_flags_for_inode(inode);
+	add_flags = d_flags_for_inode(dentry, inode);
 
 	if (disconnected)
 		add_flags |= DCACHE_DISCONNECTED;
@@ -2130,6 +2135,14 @@ struct dentry *d_add_ci(struct dentry *dentry, struct inode *inode,
 }
 EXPORT_SYMBOL(d_add_ci);
 
+struct dentry *d_add_ci_negative_dentry(struct dentry *dentry)
+{
+	/* Mark the dentry as hard negative. */
+	dentry->d_flags |= DCACHE_HARD_NEGATIVE_TYPE;
+
+	return d_splice_alias(NULL, dentry);
+}
+
 /**
  * __d_lookup_rcu - search for a dentry (racy, store-free)
  * @parent: parent dentry
@@ -2230,7 +2243,7 @@ struct dentry *__d_lookup_rcu(const struct dentry *parent,
 				goto seqretry;
 			}
 
-			if (ci_lookup) {
+			if (ci_lookup || d_is_hard_negative(dentry)) {
 				if (parent->d_op->d_compare_ci(dentry, tlen,
 							       tname, name) != 0)
 					continue;
@@ -2335,7 +2348,7 @@ struct dentry *__d_lookup(const struct dentry *parent, const struct qstr *name,
 		if (d_unhashed(dentry))
 			goto next;
 
-		if (ci_lookup) {
+		if (ci_lookup || d_is_hard_negative(dentry)) {
 			if (!d_same_name_ci(dentry, parent, name))
 				goto next;
 		} else {
@@ -2618,7 +2631,7 @@ static inline void __d_add(struct dentry *dentry, struct inode *inode)
 		__d_lookup_done(dentry);
 	}
 	if (inode) {
-		unsigned add_flags = d_flags_for_inode(inode);
+		unsigned add_flags = d_flags_for_inode(dentry, inode);
 		hlist_add_head(&dentry->d_u.d_alias, &inode->i_dentry);
 		raw_write_seqcount_begin(&dentry->d_seq);
 		__d_set_inode_and_type(dentry, inode, add_flags);
fs/namei.c +5 -2
index 1ebe5e775a9a..69726d2f6f81 100644
@@ -765,7 +765,7 @@ static inline int d_revalidate(struct dentry *dentry, unsigned int flags)
 	/* Completely ignore negative dentries
 	   for LOOKUP_CASEFOLD. */
 	if (unlikely(flags & LOOKUP_CASEFOLD)) {
-		if (d_is_negative(dentry))
+		if (d_is_soft_negative(dentry))
 			return 0;
 	}
 
@@ -3142,7 +3142,9 @@ static int lookup_open(struct nameidata *nd, struct path *path,
 			dentry = d_alloc_parallel(dir, &nd->last, &wq);
 			if (IS_ERR(dentry))
 				return PTR_ERR(dentry);
-		}
+		} else if (d_is_hard_negative(dentry))
+			goto invalidate;
+
 		if (d_in_lookup(dentry))
 			break;
 
@@ -3151,6 +3153,7 @@ static int lookup_open(struct nameidata *nd, struct path *path,
 			break;
 		if (error)
 			goto out_dput;
+invalidate:
 		d_invalidate(dentry);
 		dput(dentry);
 		dentry = NULL;
include/linux/dcache.h +14 -2
index a4ce5ea207ad..f215bcc2f60b 100644
@@ -206,13 +206,14 @@ struct dentry_operations {
 #define DCACHE_LRU_LIST			0x00080000
 
 #define DCACHE_ENTRY_TYPE		0x00700000
-#define DCACHE_MISS_TYPE		0x00000000 /* Negative dentry (maybe fallthru to nowhere) */
+#define DCACHE_MISS_TYPE		0x00000000 /* Soft negative dentry (maybe fallthru to nowhere) */
 #define DCACHE_WHITEOUT_TYPE		0x00100000 /* Whiteout dentry (stop pathwalk) */
 #define DCACHE_DIRECTORY_TYPE		0x00200000 /* Normal directory */
 #define DCACHE_AUTODIR_TYPE		0x00300000 /* Lookupless directory (presumed automount) */
 #define DCACHE_REGULAR_TYPE		0x00400000 /* Regular file type (or fallthru to such) */
 #define DCACHE_SPECIAL_TYPE		0x00500000 /* Other file type (or fallthru to such) */
 #define DCACHE_SYMLINK_TYPE		0x00600000 /* Symlink (or fallthru to such) */
+#define DCACHE_HARD_NEGATIVE_TYPE	0x00700000 /* Hard negative dentry */
 
 #define DCACHE_MAY_FREE			0x00800000
 #define DCACHE_FALLTHRU			0x01000000 /* Fall through to lower layer */
@@ -244,6 +245,7 @@ extern struct dentry * d_alloc_parallel(struct dentry *, const struct qstr *,
 					wait_queue_head_t *);
 extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
 extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *);
+extern struct dentry * d_add_ci_negative_dentry(struct dentry *);
 extern struct dentry * d_exact_alias(struct dentry *, struct inode *);
 extern struct dentry *d_find_any_alias(struct inode *inode);
 extern struct dentry * d_obtain_alias(struct inode *);
@@ -444,12 +446,22 @@ static inline bool d_is_file(const struct dentry *dentry)
 	return d_is_reg(dentry) || d_is_special(dentry);
 }
 
-static inline bool d_is_negative(const struct dentry *dentry)
+static inline bool d_is_soft_negative(const struct dentry *dentry)
 {
 	// TODO: check d_is_whiteout(dentry) also.
 	return d_is_miss(dentry);
 }
 
+static inline bool d_is_hard_negative(const struct dentry *dentry)
+{
+	return __d_entry_type(dentry) == DCACHE_HARD_NEGATIVE_TYPE;
+}
+
+static inline bool d_is_negative(const struct dentry *dentry)
+{
+	return d_is_soft_negative(dentry) || d_is_hard_negative(dentry);
+}
+extern const struct inode_operations ext4_dir_inode_operations;
 static inline bool d_is_positive(const struct dentry *dentry)
 {
 	return !d_is_negative(dentry);
Signature · 1 line
2.17.0
#7 lore raw

PATCH 7/13 vfs: Handle MNT_CASEFOLD in /proc/mounts

In reply to Gabriel Krisman Bertazi
---
 fs/proc_namespace.c | 1 +
 1 file changed, 1 insertion(+)
fs/proc_namespace.c +1 -0
index e16fb8f2049e..95d5b987c8b5 100644
@@ -70,6 +70,7 @@ static void show_mnt_opts(struct seq_file *m, struct vfsmount *mnt)
 		{ MNT_NOATIME, ",noatime" },
 		{ MNT_NODIRATIME, ",nodiratime" },
 		{ MNT_RELATIME, ",relatime" },
+		{ MNT_CASEFOLD, ",ignorecase" },
 		{ 0, NULL }
 	};
 	const struct proc_fs_info *fs_infop;
Signature · 1 line
2.17.0
#8 lore raw

PATCH 8/13 fscrypt: Introduce charset-based matching functions

In reply to Gabriel Krisman Bertazi

Changes since RFC v1:
- Send length of both strings to comparison functions.
- Change length type to size_t.

---
 include/linux/fscrypt.h         |  1 +
 include/linux/fscrypt_notsupp.h | 16 ++++++++++++++++
 include/linux/fscrypt_supp.h    | 27 +++++++++++++++++++++++++++
 3 files changed, 44 insertions(+)
include/linux/fscrypt.h +1 -0
index 952ab97af325..96559f7bfc63 100644
@@ -15,6 +15,7 @@
 #define _LINUX_FSCRYPT_H
 
 #include <linux/fs.h>
+#include <linux/nls.h>
 
 #define FS_CRYPTO_BLOCK_SIZE		16
 
include/linux/fscrypt_notsupp.h +16 -0
index 44b50c04bae9..f38824aa3250 100644
@@ -159,6 +159,22 @@ static inline bool fscrypt_match_name(const struct fscrypt_name *fname,
 	return !memcmp(de_name, fname->disk_name.name, fname->disk_name.len);
 }
 
+static inline bool fscrypt_charset_match_name(struct nls_table *charset,
+					      const struct fscrypt_name *fname,
+					      const u8 *de_name,
+					      u32 de_name_len, bool ignorecase)
+{
+	if (!ignorecase) {
+		return !nls_strncmp(charset, (char *) de_name, de_name_len,
+				    fname->disk_name.name,
+				    fname->disk_name.len);
+	}
+
+	return !nls_strncasecmp(charset, (char *) de_name,
+				(size_t) de_name_len, fname->disk_name.name,
+				(size_t) fname->disk_name.len);
+}
+
 /* bio.c */
 static inline void fscrypt_decrypt_bio_pages(struct fscrypt_ctx *ctx,
 					     struct bio *bio)
include/linux/fscrypt_supp.h +27 -0
index 477a7a6504d2..8c55678ce9ce 100644
@@ -187,6 +187,33 @@ static inline bool fscrypt_match_name(const struct fscrypt_name *fname,
 	return !memcmp(de_name, fname->disk_name.name, fname->disk_name.len);
 }
 
+static inline bool fscrypt_charset_match_name(struct nls_table *charset,
+					      const struct fscrypt_name *fname,
+					      const u8 *de_name,
+					      u32 de_name_len, bool ignorecase)
+{
+	if (unlikely(!fname->disk_name.name)) {
+		const struct fscrypt_digested_name *n =
+			(const void *)fname->crypto_buf.name;
+		if (WARN_ON_ONCE(fname->usr_fname->name[0] != '_'))
+			return false;
+		if (de_name_len <= FSCRYPT_FNAME_MAX_UNDIGESTED_SIZE)
+			return false;
+		return !memcmp(FSCRYPT_FNAME_DIGEST(de_name, de_name_len),
+			       n->digest, FSCRYPT_FNAME_DIGEST_SIZE);
+	}
+
+	if (!ignorecase) {
+		return !nls_strncmp(charset, (char *) de_name, de_name_len,
+				    fname->disk_name.name,
+				    fname->disk_name.len);
+	}
+
+	return !nls_strncasecmp(charset, (char *) de_name, de_name_len,
+				fname->disk_name.name,
+				fname->disk_name.len);
+}
+
 /* bio.c */
 extern void fscrypt_decrypt_bio_pages(struct fscrypt_ctx *, struct bio *);
 extern void fscrypt_pullback_bio_page(struct page **, bool);
Signature · 1 line
2.17.0
#9 lore raw

PATCH 9/13 ext4: Include encoding information on the superblock

In reply to Gabriel Krisman Bertazi
---
 fs/ext4/ext4.h  |  1 +
 fs/ext4/super.c | 45 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+)
fs/ext4/ext4.h +1 -0
index 3241475a1733..22f49d7d3efc 100644
@@ -1366,6 +1366,7 @@ struct ext4_sb_info {
 	struct kobject s_kobj;
 	struct completion s_kobj_unregister;
 	struct super_block *s_sb;
+	struct nls_table *encoding;
 
 	/* Journaling */
 	struct journal_s *s_journal;
fs/ext4/super.c +45 -0

90 lines not on this page · raw message

Signature · 1 line
2.17.0
#10 lore raw

PATCH 10/13 ext4: Plumb LOOK_CASEFOLD up to ext4 comparison functions

In reply to Gabriel Krisman Bertazi

We also ignore the flags when creating a file, this means we allow files to be created who only differ by case folding.

---
 fs/ext4/ext4.h   |  6 ++++--
 fs/ext4/inline.c |  7 ++++---
 fs/ext4/namei.c  | 50 +++++++++++++++++++++++++++---------------------
 3 files changed, 36 insertions(+), 27 deletions(-)
fs/ext4/ext4.h +4 -2
index 22f49d7d3efc..ebda06e4cb24 100644
@@ -2505,7 +2505,8 @@ extern int ext4_search_dir(struct buffer_head *bh,
 			   struct inode *dir,
 			   struct ext4_filename *fname,
 			   unsigned int offset,
-			   struct ext4_dir_entry_2 **res_dir);
+			   struct ext4_dir_entry_2 **res_dir,
+			   unsigned int flags);
 extern int ext4_generic_delete_entry(handle_t *handle,
 				     struct inode *dir,
 				     struct ext4_dir_entry_2 *de_del,
@@ -2991,7 +2992,8 @@ extern int htree_inlinedir_to_tree(struct file *dir_file,
 extern struct buffer_head *ext4_find_inline_entry(struct inode *dir,
 					struct ext4_filename *fname,
 					struct ext4_dir_entry_2 **res_dir,
-					int *has_inline_data);
+					int *has_inline_data,
+					unsigned int flags);
 extern int ext4_delete_inline_entry(handle_t *handle,
 				    struct inode *dir,
 				    struct ext4_dir_entry_2 *de_del,
fs/ext4/inline.c +4 -3
index 70cf4c7b268a..273d28a9c0b7 100644
@@ -1612,7 +1612,8 @@ int ext4_try_create_inline_dir(handle_t *handle, struct inode *parent,
 struct buffer_head *ext4_find_inline_entry(struct inode *dir,
 					struct ext4_filename *fname,
 					struct ext4_dir_entry_2 **res_dir,
-					int *has_inline_data)
+					int *has_inline_data,
+					unsigned int flags)
 {
 	int ret;
 	struct ext4_iloc iloc;
@@ -1632,7 +1633,7 @@ struct buffer_head *ext4_find_inline_entry(struct inode *dir,
 						EXT4_INLINE_DOTDOT_SIZE;
 	inline_size = EXT4_MIN_INLINE_DATA_SIZE - EXT4_INLINE_DOTDOT_SIZE;
 	ret = ext4_search_dir(iloc.bh, inline_start, inline_size,
-			      dir, fname, 0, res_dir);
+			      dir, fname, 0, res_dir, flags);
 	if (ret == 1)
 		goto out_find;
 	if (ret < 0)
@@ -1645,7 +1646,7 @@ struct buffer_head *ext4_find_inline_entry(struct inode *dir,
 	inline_size = ext4_get_inline_size(dir) - EXT4_MIN_INLINE_DATA_SIZE;
 
 	ret = ext4_search_dir(iloc.bh, inline_start, inline_size,
-			      dir, fname, 0, res_dir);
+			      dir, fname, 0, res_dir, flags);
 	if (ret == 1)
 		goto out_find;
 
fs/ext4/namei.c +28 -22

184 lines not on this page · raw message

Signature · 1 line
2.17.0
#11 lore raw

PATCH 11/13 ext4: Support charset name matching

In reply to Gabriel Krisman Bertazi

Implement generic caseless lookup based on the mount flags using the charset library.

---
 fs/ext4/namei.c | 47 +++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 39 insertions(+), 8 deletions(-)
fs/ext4/namei.c +39 -8
index 3373017e9315..ad7330b82740 100644
@@ -1259,7 +1259,8 @@ static void dx_insert_block(struct dx_frame *frame, u32 hash, ext4_lblk_t block)
  *
  * Return: %true if the directory entry matches, otherwise %false.
  */
-static inline bool ext4_match(const struct ext4_filename *fname,
+static inline bool ext4_match(struct nls_table *charset,
+			      const struct ext4_filename *fname,
 			      const struct ext4_dir_entry_2 *de,
 			      bool casefold)
 {
@@ -1273,7 +1274,8 @@ static inline bool ext4_match(const struct ext4_filename *fname,
 #ifdef CONFIG_EXT4_FS_ENCRYPTION
 	f.crypto_buf = fname->crypto_buf;
 #endif
-	return fscrypt_match_name(&f, de->name, de->name_len);
+	return fscrypt_charset_match_name(charset, &f, de->name,
+					  de->name_len, casefold);
 }
 
 /*
@@ -1287,6 +1289,7 @@ int ext4_search_dir(struct buffer_head *bh, char *search_buf, int buf_size,
 	struct ext4_dir_entry_2 * de;
 	char * dlimit;
 	int de_len;
+	struct super_block *sb = dir->i_sb;
 
 	de = (struct ext4_dir_entry_2 *)search_buf;
 	dlimit = search_buf + buf_size;
@@ -1294,7 +1297,9 @@ int ext4_search_dir(struct buffer_head *bh, char *search_buf, int buf_size,
 		/* this code is executed quadratically often */
 		/* do minimal checking `by hand' */
 		if ((char *) de + de->name_len <= dlimit &&
-		    ext4_match(fname, de, flags & LOOKUP_CASEFOLD)) {
+		    ext4_match(EXT4_SB(sb)->encoding, fname, de,
+			       flags & LOOKUP_CASEFOLD)) {
+
 			/* found a match - just to be sure, do
 			 * a full check */
 			if (ext4_check_dir_entry(dir, NULL, de, bh, bh->b_data,
@@ -1395,11 +1400,13 @@ static struct buffer_head * ext4_find_entry (struct inode *dir,
 	if (is_dx(dir)) {
 		ret = ext4_dx_find_entry(dir, &fname, res_dir, flags);
 		/*
-		 * On success, or if the error was file not found,
-		 * return.  Otherwise, fall back to doing a search the
-		 * old fashioned way.
+		 * On success, or if the file cannot be found, return.
+		 * If an error occurred, or if the file was not found
+		 * but we can do case-insensitive lookups, fall back to
+		 * the linear search.
 		 */
-		if (!IS_ERR(ret) || PTR_ERR(ret) != ERR_BAD_DX_DIR)
+		if ((!IS_ERR(ret) && (ret || !(flags & LOOKUP_CASEFOLD))) ||
+		    (IS_ERR(ret) && PTR_ERR(ret) != ERR_BAD_DX_DIR))
 			goto cleanup_and_exit;
 		dxtrace(printk(KERN_DEBUG "ext4_find_entry: dx failed, "
 			       "falling back\n"));
@@ -1592,6 +1599,29 @@ static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsi
 			return ERR_PTR(-EPERM);
 		}
 	}
+
+	if (flags & LOOKUP_CASEFOLD) {
+		struct dentry *new;
+		struct qstr ciname;
+		char *name;
+
+		if (!de)
+			return d_add_ci_negative_dentry(dentry);
+
+		name = kmalloc((sizeof(char) * de->name_len) + 1,
+			       GFP_NOFS);
+		if (!name)
+			return ERR_PTR(-ENOMEM);
+
+		memcpy(name, de->name, de->name_len);
+		name[de->name_len] = '\0';
+		ciname.len = de->name_len;
+		ciname.name = name;
+		new = d_add_ci(dentry, inode, &ciname);
+		kfree(name);
+		return new;
+	}
+
 	return d_splice_alias(inode, dentry);
 }
 
@@ -1795,6 +1825,7 @@ int ext4_find_dest_de(struct inode *dir, struct inode *inode,
 	int nlen, rlen;
 	unsigned int offset = 0;
 	char *top;
+	struct super_block *sb = dir->i_sb;
 
 	de = (struct ext4_dir_entry_2 *)buf;
 	top = buf + buf_size - reclen;
@@ -1802,7 +1833,7 @@ int ext4_find_dest_de(struct inode *dir, struct inode *inode,
 		if (ext4_check_dir_entry(dir, NULL, de, bh,
 					 buf, buf_size, offset))
 			return -EFSCORRUPTED;
-		if (ext4_match(fname, de, false))
+		if (ext4_match(EXT4_SB(sb)->encoding, fname, de, false))
 			return -EEXIST;
 		nlen = EXT4_DIR_REC_LEN(de->name_len);
 		rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
Signature · 1 line
2.17.0
#12 lore raw

PATCH 12/13 ext4: Implement ext4 dcache hooks for custom charsets

In reply to Gabriel Krisman Bertazi

Changes from RFC v1:
- Handle errors from charset_normalize/casefold (Olaf Weber)
- Send length of both strings to comparison functions.
- Cast length type to size_t

---
 fs/ext4/dir.c   | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 fs/ext4/ext4.h  |  2 ++
 fs/ext4/super.c |  2 ++
 3 files changed, 52 insertions(+)
fs/ext4/dir.c +48 -0
index da87cf757f7d..02911f2681ab 100644
@@ -26,6 +26,7 @@
 #include <linux/buffer_head.h>
 #include <linux/slab.h>
 #include <linux/iversion.h>
+#include <linux/nls.h>
 #include "ext4.h"
 #include "xattr.h"
 
@@ -662,3 +663,50 @@ const struct file_operations ext4_dir_operations = {
 	.open		= ext4_dir_open,
 	.release	= ext4_release_dir,
 };
+
+static int ext4_d_compare(const struct dentry *dentry, unsigned int len,
+			  const char *str, const struct qstr *name)
+{
+	struct nls_table *charset = EXT4_SB(dentry->d_sb)->encoding;
+	size_t nlen = strlen(name->name);
+
+	return nls_strncmp(charset, str, len, name->name, nlen);
+}
+
+static int ext4_d_compare_ci(const struct dentry *dentry, unsigned int len,
+			     const char *str, const struct qstr *name)
+{
+	struct nls_table *charset = EXT4_SB(dentry->d_sb)->encoding;
+	size_t nlen = strlen(name->name);
+
+	return nls_strncasecmp(charset, str, len, name->name, nlen);
+}
+
+static int ext4_d_ci_hash(const struct dentry *dentry, struct qstr *q)
+{
+	unsigned long hash;
+	int i, len;
+	unsigned char *folded = NULL;
+	const struct nls_table *charset = EXT4_SB(dentry->d_sb)->encoding;
+
+	len = nls_casefold(charset, q->name, q->len, &folded);
+
+	if (len < 0) {
+		kfree(folded);
+		return -EINVAL;
+	}
+
+	hash = init_name_hash(dentry);
+	for (i = 0; i < len; i++)
+		hash = partial_name_hash(folded[i], hash);
+	q->hash = end_name_hash(hash);
+
+	kfree(folded);
+	return 0;
+}
+
+const struct dentry_operations ext4_dentry_ops = {
+	.d_hash = ext4_d_ci_hash,
+	.d_compare = ext4_d_compare,
+	.d_compare_ci = ext4_d_compare_ci,
+};
fs/ext4/ext4.h +2 -0
index ebda06e4cb24..eb193d66565a 100644
@@ -2939,6 +2939,8 @@ static inline void ext4_unlock_group(struct super_block *sb,
 
 /* dir.c */
 extern const struct file_operations ext4_dir_operations;
+extern const struct dentry_operations ext4_dentry_ops;
+extern const struct dentry_operations ext4_ci_dentry_ops;
 
 /* file.c */
 extern const struct inode_operations ext4_file_inode_operations;
fs/ext4/super.c +2 -0
index bbf0a5c4104b..e73976986dcb 100644
@@ -4241,6 +4241,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
 		iput(root);
 		goto failed_mount4;
 	}
+
+	sb->s_d_op = &ext4_dentry_ops;
 	sb->s_root = d_make_root(root);
 	if (!sb->s_root) {
 		ext4_msg(sb, KERN_ERR, "get root dentry failed");
Signature · 1 line
2.17.0
#13 lore raw

PATCH 13/13 ext4: Notify VFS of support for casefolded mountpoints

In reply to Gabriel Krisman Bertazi

This effectively enables case-insensitive lookups for ext4.

---
 fs/ext4/super.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
fs/ext4/super.c +1 -1
index e73976986dcb..dda63227c48e 100644
@@ -5827,7 +5827,7 @@ static struct file_system_type ext4_fs_type = {
 	.name		= "ext4",
 	.mount		= ext4_mount,
 	.kill_sb	= kill_block_super,
-	.fs_flags	= FS_REQUIRES_DEV,
+	.fs_flags	= FS_REQUIRES_DEV | FS_HAS_CASEFOLD,
 };
 MODULE_ALIAS_FS("ext4");
 
Signature · 1 line
2.17.0