erofs: move erofs out of staging

EROFS filesystem has been merged into linux-staging for a year.

EROFS is designed to be a better solution of saving extra storage
space with guaranteed end-to-end performance for read-only files
with the help of reduced metadata, fixed-sized output compression
and decompression inplace technologies.

In the past year, EROFS was greatly improved by many people as
a staging driver, self-tested, betaed by a large number of our
internal users, successfully applied to almost all in-service
HUAWEI smartphones as the part of EMUI 9.1 and proven to be stable
enough to be moved out of staging.

EROFS is a self-contained filesystem driver. Although there are
still some TODOs to be more generic, we have a dedicated team
actively keeping on working on EROFS in order to make it better
with the evolution of Linux kernel as the other in-kernel filesystems.

As Pavel suggested, it's better to do as one commit since git
can do moves and all histories will be saved in this way.

Let's promote it from staging and enhance it more actively as
a "real" part of kernel for more wider scenarios!

Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
Cc: Theodore Ts'o <tytso@mit.edu>
Cc: Pavel Machek <pavel@denx.de>
Cc: David Sterba <dsterba@suse.cz>
Cc: Amir Goldstein <amir73il@gmail.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Darrick J . Wong <darrick.wong@oracle.com>
Cc: Dave Chinner <david@fromorbit.com>
Cc: Jaegeuk Kim <jaegeuk@kernel.org>
Cc: Jan Kara <jack@suse.cz>
Cc: Richard Weinberger <richard@nod.at>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Chao Yu <yuchao0@huawei.com>
Cc: Miao Xie <miaoxie@huawei.com>
Cc: Li Guifu <bluce.liguifu@huawei.com>
Cc: Fang Wei <fangwei1@huawei.com>
Signed-off-by: Gao Xiang <gaoxiang25@huawei.com>
Link: https://lore.kernel.org/r/20190822213659.5501-1-hsiangkao@aol.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

1 files changed, 251 insertions, 0 deletions

diff --git a/fs/erofs/namei.c b/fs/erofs/namei.c
new file mode 100644
index 000000000000..8832b5d95d91
--- /dev/null
+++ b/fs/erofs/namei.c
@@ -0,0 +1,251 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2017-2018 HUAWEI, Inc.
+ *             http://www.huawei.com/
+ * Created by Gao Xiang <gaoxiang25@huawei.com>
+ */
+#include "xattr.h"
+
+#include <trace/events/erofs.h>
+
+struct erofs_qstr {
+        const unsigned char *name;
+        const unsigned char *end;
+};
+
+/* based on the end of qn is accurate and it must have the trailing '\0' */
+static inline int dirnamecmp(const struct erofs_qstr *qn,
+                             const struct erofs_qstr *qd,
+                             unsigned int *matched)
+{
+        unsigned int i = *matched;
+
+        /*
+         * on-disk error, let's only BUG_ON in the debugging mode.
+         * otherwise, it will return 1 to just skip the invalid name
+         * and go on (in consideration of the lookup performance).
+         */
+        DBG_BUGON(qd->name > qd->end);
+
+        /* qd could not have trailing '\0' */
+        /* However it is absolutely safe if < qd->end */
+        while (qd->name + i < qd->end && qd->name[i] != '\0') {
+                if (qn->name[i] != qd->name[i]) {
+                        *matched = i;
+                        return qn->name[i] > qd->name[i] ? 1 : -1;
+                }
+                ++i;
+        }
+        *matched = i;
+        /* See comments in __d_alloc on the terminating NUL character */
+        return qn->name[i] == '\0' ? 0 : 1;
+}
+
+#define nameoff_from_disk(off, sz)      (le16_to_cpu(off) & ((sz) - 1))
+
+static struct erofs_dirent *find_target_dirent(struct erofs_qstr *name,
+                                               u8 *data,
+                                               unsigned int dirblksize,
+                                               const int ndirents)
+{
+        int head, back;
+        unsigned int startprfx, endprfx;
+        struct erofs_dirent *const de = (struct erofs_dirent *)data;
+
+        /* since the 1st dirent has been evaluated previously */
+        head = 1;
+        back = ndirents - 1;
+        startprfx = endprfx = 0;
+
+        while (head <= back) {
+                const int mid = head + (back - head) / 2;
+                const int nameoff = nameoff_from_disk(de[mid].nameoff,
+                                                      dirblksize);
+                unsigned int matched = min(startprfx, endprfx);
+                struct erofs_qstr dname = {
+                        .name = data + nameoff,
+                        .end = unlikely(mid >= ndirents - 1) ?
+                                data + dirblksize :
+                                data + nameoff_from_disk(de[mid + 1].nameoff,
+                                                         dirblksize)
+                };
+
+                /* string comparison without already matched prefix */
+                int ret = dirnamecmp(name, &dname, &matched);
+
+                if (unlikely(!ret)) {
+                        return de + mid;
+                } else if (ret > 0) {
+                        head = mid + 1;
+                        startprfx = matched;
+                } else {
+                        back = mid - 1;
+                        endprfx = matched;
+                }
+        }
+
+        return ERR_PTR(-ENOENT);
+}
+
+static struct page *find_target_block_classic(struct inode *dir,
+                                              struct erofs_qstr *name,
+                                              int *_ndirents)
+{
+        unsigned int startprfx, endprfx;
+        int head, back;
+        struct address_space *const mapping = dir->i_mapping;
+        struct page *candidate = ERR_PTR(-ENOENT);
+
+        startprfx = endprfx = 0;
+        head = 0;
+        back = inode_datablocks(dir) - 1;
+
+        while (head <= back) {
+                const int mid = head + (back - head) / 2;
+                struct page *page = read_mapping_page(mapping, mid, NULL);
+
+                if (!IS_ERR(page)) {
+                        struct erofs_dirent *de = kmap_atomic(page);
+                        const int nameoff = nameoff_from_disk(de->nameoff,
+                                                              EROFS_BLKSIZ);
+                        const int ndirents = nameoff / sizeof(*de);
+                        int diff;
+                        unsigned int matched;
+                        struct erofs_qstr dname;
+
+                        if (unlikely(!ndirents)) {
+                                kunmap_atomic(de);
+                                put_page(page);
+                                errln("corrupted dir block %d @ nid %llu",
+                                      mid, EROFS_V(dir)->nid);
+                                DBG_BUGON(1);
+                                page = ERR_PTR(-EFSCORRUPTED);
+                                goto out;
+                        }
+
+                        matched = min(startprfx, endprfx);
+
+                        dname.name = (u8 *)de + nameoff;
+                        if (ndirents == 1)
+                                dname.end = (u8 *)de + EROFS_BLKSIZ;
+                        else
+                                dname.end = (u8 *)de +
+                                        nameoff_from_disk(de[1].nameoff,
+                                                          EROFS_BLKSIZ);
+
+                        /* string comparison without already matched prefix */
+                        diff = dirnamecmp(name, &dname, &matched);
+                        kunmap_atomic(de);
+
+                        if (unlikely(!diff)) {
+                                *_ndirents = 0;
+                                goto out;
+                        } else if (diff > 0) {
+                                head = mid + 1;
+                                startprfx = matched;
+
+                                if (!IS_ERR(candidate))
+                                        put_page(candidate);
+                                candidate = page;
+                                *_ndirents = ndirents;
+                        } else {
+                                put_page(page);
+
+                                back = mid - 1;
+                                endprfx = matched;
+                        }
+                        continue;
+                }
+out:            /* free if the candidate is valid */
+                if (!IS_ERR(candidate))
+                        put_page(candidate);
+                return page;
+        }
+        return candidate;
+}
+
+int erofs_namei(struct inode *dir,
+                struct qstr *name,
+                erofs_nid_t *nid, unsigned int *d_type)
+{
+        int ndirents;
+        struct page *page;
+        void *data;
+        struct erofs_dirent *de;
+        struct erofs_qstr qn;
+
+        if (unlikely(!dir->i_size))
+                return -ENOENT;
+
+        qn.name = name->name;
+        qn.end = name->name + name->len;
+
+        ndirents = 0;
+        page = find_target_block_classic(dir, &qn, &ndirents);
+
+        if (IS_ERR(page))
+                return PTR_ERR(page);
+
+        data = kmap_atomic(page);
+        /* the target page has been mapped */
+        if (ndirents)
+                de = find_target_dirent(&qn, data, EROFS_BLKSIZ, ndirents);
+        else
+                de = (struct erofs_dirent *)data;
+
+        if (!IS_ERR(de)) {
+                *nid = le64_to_cpu(de->nid);
+                *d_type = de->file_type;
+        }
+
+        kunmap_atomic(data);
+        put_page(page);
+
+        return PTR_ERR_OR_ZERO(de);
+}
+
+/* NOTE: i_mutex is already held by vfs */
+static struct dentry *erofs_lookup(struct inode *dir,
+                                   struct dentry *dentry,
+                                   unsigned int flags)
+{
+        int err;
+        erofs_nid_t nid;
+        unsigned int d_type;
+        struct inode *inode;
+
+        DBG_BUGON(!d_really_is_negative(dentry));
+        /* dentry must be unhashed in lookup, no need to worry about */
+        DBG_BUGON(!d_unhashed(dentry));
+
+        trace_erofs_lookup(dir, dentry, flags);
+
+        /* file name exceeds fs limit */
+        if (unlikely(dentry->d_name.len > EROFS_NAME_LEN))
+                return ERR_PTR(-ENAMETOOLONG);
+
+        /* false uninitialized warnings on gcc 4.8.x */
+        err = erofs_namei(dir, &dentry->d_name, &nid, &d_type);
+
+        if (err == -ENOENT) {
+                /* negative dentry */
+                inode = NULL;
+        } else if (unlikely(err)) {
+                inode = ERR_PTR(err);
+        } else {
+                debugln("%s, %s (nid %llu) found, d_type %u", __func__,
+                        dentry->d_name.name, nid, d_type);
+                inode = erofs_iget(dir->i_sb, nid, d_type == FT_DIR);
+        }
+        return d_splice_alias(inode, dentry);
+}
+
+const struct inode_operations erofs_dir_iops = {
+        .lookup = erofs_lookup,
+        .getattr = erofs_getattr,
+#ifdef CONFIG_EROFS_FS_XATTR
+        .listxattr = erofs_listxattr,
+#endif
+        .get_acl = erofs_get_acl,
+};
+