+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * Copyright (C) 2022, Alibaba Cloud
- * Copyright (C) 2022, Bytedance Inc. All rights reserved.
- */
-#include <linux/fscache.h>
-#include "internal.h"
-
-static DEFINE_MUTEX(erofs_domain_list_lock);
-static DEFINE_MUTEX(erofs_domain_cookies_lock);
-static LIST_HEAD(erofs_domain_list);
-static LIST_HEAD(erofs_domain_cookies_list);
-static struct vfsmount *erofs_pseudo_mnt;
-
-struct erofs_fscache_io {
- struct netfs_cache_resources cres;
- struct iov_iter iter;
- netfs_io_terminated_t end_io;
- void *private;
- refcount_t ref;
-};
-
-struct erofs_fscache_rq {
- struct address_space *mapping; /* The mapping being accessed */
- loff_t start; /* Start position */
- size_t len; /* Length of the request */
- size_t submitted; /* Length of submitted */
- short error; /* 0 or error that occurred */
- refcount_t ref;
-};
-
-static bool erofs_fscache_io_put(struct erofs_fscache_io *io)
-{
- if (!refcount_dec_and_test(&io->ref))
- return false;
- if (io->cres.ops)
- io->cres.ops->end_operation(&io->cres);
- kfree(io);
- return true;
-}
-
-static void erofs_fscache_req_complete(struct erofs_fscache_rq *req)
-{
- struct folio *folio;
- bool failed = req->error;
- pgoff_t start_page = req->start / PAGE_SIZE;
- pgoff_t last_page = ((req->start + req->len) / PAGE_SIZE) - 1;
-
- XA_STATE(xas, &req->mapping->i_pages, start_page);
-
- rcu_read_lock();
- xas_for_each(&xas, folio, last_page) {
- if (xas_retry(&xas, folio))
- continue;
- if (!failed)
- folio_mark_uptodate(folio);
- folio_unlock(folio);
- }
- rcu_read_unlock();
-}
-
-static void erofs_fscache_req_put(struct erofs_fscache_rq *req)
-{
- if (!refcount_dec_and_test(&req->ref))
- return;
- erofs_fscache_req_complete(req);
- kfree(req);
-}
-
-static struct erofs_fscache_rq *erofs_fscache_req_alloc(struct address_space *mapping,
- loff_t start, size_t len)
-{
- struct erofs_fscache_rq *req = kzalloc_obj(*req);
-
- if (!req)
- return NULL;
- req->mapping = mapping;
- req->start = start;
- req->len = len;
- refcount_set(&req->ref, 1);
- return req;
-}
-
-static void erofs_fscache_req_io_put(struct erofs_fscache_io *io)
-{
- struct erofs_fscache_rq *req = io->private;
-
- if (erofs_fscache_io_put(io))
- erofs_fscache_req_put(req);
-}
-
-static void erofs_fscache_req_end_io(void *priv, ssize_t transferred_or_error)
-{
- struct erofs_fscache_io *io = priv;
- struct erofs_fscache_rq *req = io->private;
-
- if (IS_ERR_VALUE(transferred_or_error))
- req->error = transferred_or_error;
- erofs_fscache_req_io_put(io);
-}
-
-static struct erofs_fscache_io *erofs_fscache_req_io_alloc(struct erofs_fscache_rq *req)
-{
- struct erofs_fscache_io *io = kzalloc_obj(*io);
-
- if (!io)
- return NULL;
- io->end_io = erofs_fscache_req_end_io;
- io->private = req;
- refcount_inc(&req->ref);
- refcount_set(&io->ref, 1);
- return io;
-}
-
-/*
- * Read data from fscache described by cookie at pstart physical address
- * offset, and fill the read data into buffer described by io->iter.
- */
-static int erofs_fscache_read_io_async(struct fscache_cookie *cookie,
- loff_t pstart, struct erofs_fscache_io *io)
-{
- enum netfs_io_source source;
- struct netfs_cache_resources *cres = &io->cres;
- struct iov_iter *iter = &io->iter;
- int ret;
-
- ret = fscache_begin_read_operation(cres, cookie);
- if (ret)
- return ret;
-
- while (iov_iter_count(iter)) {
- size_t orig_count = iov_iter_count(iter), len = orig_count;
- unsigned long flags = 1 << NETFS_SREQ_ONDEMAND;
-
- source = cres->ops->prepare_ondemand_read(cres,
- pstart, &len, LLONG_MAX, &flags, 0);
- if (WARN_ON(len == 0))
- source = NETFS_INVALID_READ;
- if (source != NETFS_READ_FROM_CACHE) {
- erofs_err(NULL, "prepare_ondemand_read failed (source %d)", source);
- return -EIO;
- }
-
- iov_iter_truncate(iter, len);
- refcount_inc(&io->ref);
- ret = fscache_read(cres, pstart, iter, NETFS_READ_HOLE_FAIL,
- io->end_io, io);
- if (ret == -EIOCBQUEUED)
- ret = 0;
- if (ret) {
- erofs_err(NULL, "fscache_read failed (ret %d)", ret);
- return ret;
- }
- if (WARN_ON(iov_iter_count(iter)))
- return -EIO;
-
- iov_iter_reexpand(iter, orig_count - len);
- pstart += len;
- }
- return 0;
-}
-
-struct erofs_fscache_bio {
- struct erofs_fscache_io io;
- struct bio bio; /* w/o bdev to share bio_add_page/endio() */
- struct bio_vec bvecs[BIO_MAX_VECS];
-};
-
-static void erofs_fscache_bio_endio(void *priv, ssize_t transferred_or_error)
-{
- struct erofs_fscache_bio *io = priv;
-
- if (IS_ERR_VALUE(transferred_or_error))
- io->bio.bi_status = errno_to_blk_status(transferred_or_error);
- bio_endio(&io->bio);
- BUILD_BUG_ON(offsetof(struct erofs_fscache_bio, io) != 0);
- erofs_fscache_io_put(&io->io);
-}
-
-struct bio *erofs_fscache_bio_alloc(struct erofs_map_dev *mdev)
-{
- struct erofs_fscache_bio *io;
-
- io = kmalloc_obj(*io, GFP_KERNEL | __GFP_NOFAIL);
- bio_init(&io->bio, NULL, io->bvecs, BIO_MAX_VECS, REQ_OP_READ);
- io->io.private = mdev->m_dif->fscache->cookie;
- io->io.end_io = erofs_fscache_bio_endio;
- refcount_set(&io->io.ref, 1);
- return &io->bio;
-}
-
-void erofs_fscache_submit_bio(struct bio *bio)
-{
- struct erofs_fscache_bio *io = container_of(bio,
- struct erofs_fscache_bio, bio);
- int ret;
-
- iov_iter_bvec(&io->io.iter, ITER_DEST, io->bvecs, bio->bi_vcnt,
- bio->bi_iter.bi_size);
- ret = erofs_fscache_read_io_async(io->io.private,
- bio->bi_iter.bi_sector << 9, &io->io);
- erofs_fscache_io_put(&io->io);
- if (!ret)
- return;
- bio->bi_status = errno_to_blk_status(ret);
- bio_endio(bio);
-}
-
-static int erofs_fscache_meta_read_folio(struct file *data, struct folio *folio)
-{
- struct erofs_fscache *ctx = folio->mapping->host->i_private;
- int ret = -ENOMEM;
- struct erofs_fscache_rq *req;
- struct erofs_fscache_io *io;
-
- req = erofs_fscache_req_alloc(folio->mapping,
- folio_pos(folio), folio_size(folio));
- if (!req) {
- folio_unlock(folio);
- return ret;
- }
-
- io = erofs_fscache_req_io_alloc(req);
- if (!io) {
- req->error = ret;
- goto out;
- }
- iov_iter_xarray(&io->iter, ITER_DEST, &folio->mapping->i_pages,
- folio_pos(folio), folio_size(folio));
-
- ret = erofs_fscache_read_io_async(ctx->cookie, folio_pos(folio), io);
- if (ret)
- req->error = ret;
-
- erofs_fscache_req_io_put(io);
-out:
- erofs_fscache_req_put(req);
- return ret;
-}
-
-static int erofs_fscache_data_read_slice(struct erofs_fscache_rq *req)
-{
- struct address_space *mapping = req->mapping;
- struct inode *inode = mapping->host;
- struct super_block *sb = inode->i_sb;
- struct erofs_fscache_io *io;
- struct erofs_map_blocks map;
- struct erofs_map_dev mdev;
- loff_t pos = req->start + req->submitted;
- size_t count;
- int ret;
-
- map.m_la = pos;
- ret = erofs_map_blocks(inode, &map);
- if (ret)
- return ret;
-
- if (map.m_flags & EROFS_MAP_META) {
- struct erofs_buf buf = __EROFS_BUF_INITIALIZER;
- struct iov_iter iter;
- size_t size = map.m_llen;
- void *src;
-
- src = erofs_read_metabuf(&buf, sb, map.m_pa,
- erofs_inode_in_metabox(inode));
- if (IS_ERR(src))
- return PTR_ERR(src);
-
- iov_iter_xarray(&iter, ITER_DEST, &mapping->i_pages, pos, PAGE_SIZE);
- if (copy_to_iter(src, size, &iter) != size) {
- erofs_put_metabuf(&buf);
- return -EFAULT;
- }
- iov_iter_zero(PAGE_SIZE - size, &iter);
- erofs_put_metabuf(&buf);
- req->submitted += PAGE_SIZE;
- return 0;
- }
-
- count = req->len - req->submitted;
- if (!(map.m_flags & EROFS_MAP_MAPPED)) {
- struct iov_iter iter;
-
- iov_iter_xarray(&iter, ITER_DEST, &mapping->i_pages, pos, count);
- iov_iter_zero(count, &iter);
- req->submitted += count;
- return 0;
- }
-
- count = min_t(size_t, map.m_llen - (pos - map.m_la), count);
- DBG_BUGON(!count || count % PAGE_SIZE);
-
- mdev = (struct erofs_map_dev) {
- .m_deviceid = map.m_deviceid,
- .m_pa = map.m_pa,
- };
- ret = erofs_map_dev(sb, &mdev);
- if (ret)
- return ret;
-
- io = erofs_fscache_req_io_alloc(req);
- if (!io)
- return -ENOMEM;
- iov_iter_xarray(&io->iter, ITER_DEST, &mapping->i_pages, pos, count);
- ret = erofs_fscache_read_io_async(mdev.m_dif->fscache->cookie,
- mdev.m_pa + (pos - map.m_la), io);
- erofs_fscache_req_io_put(io);
-
- req->submitted += count;
- return ret;
-}
-
-static int erofs_fscache_data_read(struct erofs_fscache_rq *req)
-{
- int ret;
-
- do {
- ret = erofs_fscache_data_read_slice(req);
- if (ret)
- req->error = ret;
- } while (!ret && req->submitted < req->len);
- return ret;
-}
-
-static int erofs_fscache_read_folio(struct file *file, struct folio *folio)
-{
- struct erofs_fscache_rq *req;
- int ret;
-
- req = erofs_fscache_req_alloc(folio->mapping,
- folio_pos(folio), folio_size(folio));
- if (!req) {
- folio_unlock(folio);
- return -ENOMEM;
- }
-
- ret = erofs_fscache_data_read(req);
- erofs_fscache_req_put(req);
- return ret;
-}
-
-static void erofs_fscache_readahead(struct readahead_control *rac)
-{
- struct erofs_fscache_rq *req;
-
- if (!readahead_count(rac))
- return;
-
- req = erofs_fscache_req_alloc(rac->mapping,
- readahead_pos(rac), readahead_length(rac));
- if (!req)
- return;
-
- /* The request completion will drop refs on the folios. */
- while (readahead_folio(rac))
- ;
-
- erofs_fscache_data_read(req);
- erofs_fscache_req_put(req);
-}
-
-static const struct address_space_operations erofs_fscache_meta_aops = {
- .read_folio = erofs_fscache_meta_read_folio,
-};
-
-const struct address_space_operations erofs_fscache_access_aops = {
- .read_folio = erofs_fscache_read_folio,
- .readahead = erofs_fscache_readahead,
-};
-
-static void erofs_fscache_domain_put(struct erofs_domain *domain)
-{
- mutex_lock(&erofs_domain_list_lock);
- if (refcount_dec_and_test(&domain->ref)) {
- list_del(&domain->list);
- if (list_empty(&erofs_domain_list)) {
- kern_unmount(erofs_pseudo_mnt);
- erofs_pseudo_mnt = NULL;
- }
- fscache_relinquish_volume(domain->volume, NULL, false);
- mutex_unlock(&erofs_domain_list_lock);
- kfree_sensitive(domain->domain_id);
- kfree(domain);
- return;
- }
- mutex_unlock(&erofs_domain_list_lock);
-}
-
-static int erofs_fscache_register_volume(struct super_block *sb)
-{
- struct erofs_sb_info *sbi = EROFS_SB(sb);
- char *domain_id = sbi->domain_id;
- struct fscache_volume *volume;
- char *name;
- int ret = 0;
-
- name = kasprintf(GFP_KERNEL, "erofs,%s",
- domain_id ? domain_id : sbi->fsid);
- if (!name)
- return -ENOMEM;
-
- volume = fscache_acquire_volume(name, NULL, NULL, 0);
- if (IS_ERR_OR_NULL(volume)) {
- erofs_err(sb, "failed to register volume for %s", name);
- ret = volume ? PTR_ERR(volume) : -EOPNOTSUPP;
- volume = NULL;
- }
-
- sbi->volume = volume;
- kfree(name);
- return ret;
-}
-
-static int erofs_fscache_init_domain(struct super_block *sb)
-{
- int err;
- struct erofs_domain *domain;
- struct erofs_sb_info *sbi = EROFS_SB(sb);
-
- domain = kzalloc_obj(struct erofs_domain);
- if (!domain)
- return -ENOMEM;
-
- domain->domain_id = kstrdup(sbi->domain_id, GFP_KERNEL);
- if (!domain->domain_id) {
- kfree(domain);
- return -ENOMEM;
- }
-
- err = erofs_fscache_register_volume(sb);
- if (err)
- goto out;
-
- if (!erofs_pseudo_mnt) {
- struct vfsmount *mnt = kern_mount(&erofs_anon_fs_type);
- if (IS_ERR(mnt)) {
- err = PTR_ERR(mnt);
- goto out;
- }
- erofs_pseudo_mnt = mnt;
- }
-
- domain->volume = sbi->volume;
- refcount_set(&domain->ref, 1);
- list_add(&domain->list, &erofs_domain_list);
- sbi->domain = domain;
- return 0;
-out:
- kfree_sensitive(domain->domain_id);
- kfree(domain);
- return err;
-}
-
-static int erofs_fscache_register_domain(struct super_block *sb)
-{
- int err;
- struct erofs_domain *domain;
- struct erofs_sb_info *sbi = EROFS_SB(sb);
-
- mutex_lock(&erofs_domain_list_lock);
- list_for_each_entry(domain, &erofs_domain_list, list) {
- if (!strcmp(domain->domain_id, sbi->domain_id)) {
- sbi->domain = domain;
- sbi->volume = domain->volume;
- refcount_inc(&domain->ref);
- mutex_unlock(&erofs_domain_list_lock);
- return 0;
- }
- }
- err = erofs_fscache_init_domain(sb);
- mutex_unlock(&erofs_domain_list_lock);
- return err;
-}
-
-static struct erofs_fscache *erofs_fscache_acquire_cookie(struct super_block *sb,
- char *name, unsigned int flags)
-{
- struct fscache_volume *volume = EROFS_SB(sb)->volume;
- struct erofs_fscache *ctx;
- struct fscache_cookie *cookie;
- struct super_block *isb;
- struct inode *inode;
- int ret;
-
- ctx = kzalloc_obj(*ctx);
- if (!ctx)
- return ERR_PTR(-ENOMEM);
- INIT_LIST_HEAD(&ctx->node);
- refcount_set(&ctx->ref, 1);
-
- cookie = fscache_acquire_cookie(volume, FSCACHE_ADV_WANT_CACHE_SIZE,
- name, strlen(name), NULL, 0, 0);
- if (!cookie) {
- erofs_err(sb, "failed to get cookie for %s", name);
- ret = -EINVAL;
- goto err;
- }
- fscache_use_cookie(cookie, false);
-
- /*
- * Allocate anonymous inode in global pseudo mount for shareable blobs,
- * so that they are accessible among erofs fs instances.
- */
- isb = flags & EROFS_REG_COOKIE_SHARE ? erofs_pseudo_mnt->mnt_sb : sb;
- inode = new_inode(isb);
- if (!inode) {
- erofs_err(sb, "failed to get anon inode for %s", name);
- ret = -ENOMEM;
- goto err_cookie;
- }
-
- inode->i_size = OFFSET_MAX;
- inode->i_mapping->a_ops = &erofs_fscache_meta_aops;
- mapping_set_gfp_mask(inode->i_mapping, GFP_KERNEL);
- inode->i_blkbits = EROFS_SB(sb)->blkszbits;
- inode->i_private = ctx;
-
- ctx->cookie = cookie;
- ctx->inode = inode;
- return ctx;
-
-err_cookie:
- fscache_unuse_cookie(cookie, NULL, NULL);
- fscache_relinquish_cookie(cookie, false);
-err:
- kfree(ctx);
- return ERR_PTR(ret);
-}
-
-static void erofs_fscache_relinquish_cookie(struct erofs_fscache *ctx)
-{
- fscache_unuse_cookie(ctx->cookie, NULL, NULL);
- fscache_relinquish_cookie(ctx->cookie, false);
- iput(ctx->inode);
- kfree(ctx->name);
- kfree(ctx);
-}
-
-static struct erofs_fscache *erofs_domain_init_cookie(struct super_block *sb,
- char *name, unsigned int flags)
-{
- struct erofs_fscache *ctx;
- struct erofs_domain *domain = EROFS_SB(sb)->domain;
-
- ctx = erofs_fscache_acquire_cookie(sb, name, flags);
- if (IS_ERR(ctx))
- return ctx;
-
- ctx->name = kstrdup(name, GFP_KERNEL);
- if (!ctx->name) {
- erofs_fscache_relinquish_cookie(ctx);
- return ERR_PTR(-ENOMEM);
- }
-
- refcount_inc(&domain->ref);
- ctx->domain = domain;
- list_add(&ctx->node, &erofs_domain_cookies_list);
- return ctx;
-}
-
-static struct erofs_fscache *erofs_domain_register_cookie(struct super_block *sb,
- char *name, unsigned int flags)
-{
- struct erofs_fscache *ctx;
- struct erofs_domain *domain = EROFS_SB(sb)->domain;
-
- flags |= EROFS_REG_COOKIE_SHARE;
- mutex_lock(&erofs_domain_cookies_lock);
- list_for_each_entry(ctx, &erofs_domain_cookies_list, node) {
- if (ctx->domain != domain || strcmp(ctx->name, name))
- continue;
- if (!(flags & EROFS_REG_COOKIE_NEED_NOEXIST)) {
- refcount_inc(&ctx->ref);
- } else {
- erofs_err(sb, "%s already exists in domain %s", name,
- domain->domain_id);
- ctx = ERR_PTR(-EEXIST);
- }
- mutex_unlock(&erofs_domain_cookies_lock);
- return ctx;
- }
- ctx = erofs_domain_init_cookie(sb, name, flags);
- mutex_unlock(&erofs_domain_cookies_lock);
- return ctx;
-}
-
-struct erofs_fscache *erofs_fscache_register_cookie(struct super_block *sb,
- char *name,
- unsigned int flags)
-{
- if (EROFS_SB(sb)->domain_id)
- return erofs_domain_register_cookie(sb, name, flags);
- return erofs_fscache_acquire_cookie(sb, name, flags);
-}
-
-void erofs_fscache_unregister_cookie(struct erofs_fscache *ctx)
-{
- struct erofs_domain *domain = NULL;
-
- if (!ctx)
- return;
- if (!ctx->domain)
- return erofs_fscache_relinquish_cookie(ctx);
-
- mutex_lock(&erofs_domain_cookies_lock);
- if (refcount_dec_and_test(&ctx->ref)) {
- domain = ctx->domain;
- list_del(&ctx->node);
- erofs_fscache_relinquish_cookie(ctx);
- }
- mutex_unlock(&erofs_domain_cookies_lock);
- if (domain)
- erofs_fscache_domain_put(domain);
-}
-
-int erofs_fscache_register_fs(struct super_block *sb)
-{
- int ret;
- struct erofs_sb_info *sbi = EROFS_SB(sb);
- struct erofs_fscache *fscache;
- unsigned int flags = 0;
-
- if (sbi->domain_id)
- ret = erofs_fscache_register_domain(sb);
- else
- ret = erofs_fscache_register_volume(sb);
- if (ret)
- return ret;
-
- /*
- * When shared domain is enabled, using NEED_NOEXIST to guarantee
- * the primary data blob (aka fsid) is unique in the shared domain.
- *
- * For non-shared-domain case, fscache_acquire_volume() invoked by
- * erofs_fscache_register_volume() has already guaranteed
- * the uniqueness of primary data blob.
- *
- * Acquired domain/volume will be relinquished in kill_sb() on error.
- */
- if (sbi->domain_id)
- flags |= EROFS_REG_COOKIE_NEED_NOEXIST;
- fscache = erofs_fscache_register_cookie(sb, sbi->fsid, flags);
- if (IS_ERR(fscache))
- return PTR_ERR(fscache);
-
- sbi->dif0.fscache = fscache;
- return 0;
-}
-
-void erofs_fscache_unregister_fs(struct super_block *sb)
-{
- struct erofs_sb_info *sbi = EROFS_SB(sb);
-
- erofs_fscache_unregister_cookie(sbi->dif0.fscache);
-
- if (sbi->domain)
- erofs_fscache_domain_put(sbi->domain);
- else
- fscache_relinquish_volume(sbi->volume, NULL, false);
-
- sbi->dif0.fscache = NULL;
- sbi->volume = NULL;
- sbi->domain = NULL;
-}
struct erofs_device_info *dif, erofs_off_t *pos)
{
struct erofs_sb_info *sbi = EROFS_SB(sb);
- struct erofs_fscache *fscache;
struct erofs_deviceslot *dis;
struct file *file;
bool _48bit;
return -ENOMEM;
}
- if (erofs_is_fscache_mode(sb)) {
- fscache = erofs_fscache_register_cookie(sb, dif->path, 0);
- if (IS_ERR(fscache))
- return PTR_ERR(fscache);
- dif->fscache = fscache;
- } else if (!sbi->devs->flatdev) {
+ if (!sbi->devs->flatdev) {
file = erofs_is_fileio_mode(sbi) ?
filp_open(dif->path, O_RDONLY | O_LARGEFILE, 0) :
bdev_file_open_by_path(dif->path,
if (!ondisk_extradevs)
return 0;
- if (!sbi->devs->extra_devices && !erofs_is_fscache_mode(sb))
+ if (!sbi->devs->extra_devices)
sbi->devs->flatdev = true;
sbi->device_id_mask = roundup_pow_of_two(ondisk_extradevs + 1) - 1;
erofs_info(sb, "EXPERIMENTAL 48-bit layout support in use. Use at your own risk!");
if (erofs_sb_has_metabox(sbi))
erofs_info(sb, "EXPERIMENTAL metadata compression support in use. Use at your own risk!");
- if (erofs_is_fscache_mode(sb))
- erofs_info(sb, "[deprecated] fscache-based on-demand read feature in use. Use at your own risk!");
out:
erofs_put_metabuf(&buf);
return ret;
enum {
Opt_user_xattr, Opt_acl, Opt_cache_strategy, Opt_dax, Opt_dax_enum,
- Opt_device, Opt_fsid, Opt_domain_id, Opt_directio, Opt_fsoffset,
- Opt_inode_share,
+ Opt_device, Opt_domain_id, Opt_directio, Opt_fsoffset, Opt_inode_share,
};
static const struct constant_table erofs_param_cache_strategy[] = {
fsparam_flag("dax", Opt_dax),
fsparam_enum("dax", Opt_dax_enum, erofs_dax_param_enums),
fsparam_string("device", Opt_device),
- fsparam_string("fsid", Opt_fsid),
fsparam_string("domain_id", Opt_domain_id),
fsparam_flag_no("directio", Opt_directio),
fsparam_u64("fsoffset", Opt_fsoffset),
}
++sbi->devs->extra_devices;
break;
-#ifdef CONFIG_EROFS_FS_ONDEMAND
- case Opt_fsid:
- kfree(sbi->fsid);
- sbi->fsid = kstrdup(param->string, GFP_KERNEL);
- if (!sbi->fsid)
- return -ENOMEM;
- break;
-#endif
-#if defined(CONFIG_EROFS_FS_ONDEMAND) || defined(CONFIG_EROFS_FS_PAGE_CACHE_SHARE)
case Opt_domain_id:
- kfree_sensitive(sbi->domain_id);
- sbi->domain_id = no_free_ptr(param->string);
- break;
-#else
- case Opt_fsid:
- case Opt_domain_id:
- errorfc(fc, "%s option not supported", erofs_fs_parameters[opt].name);
+ if (!IS_ENABLED(CONFIG_EROFS_FS_PAGE_CACHE_SHARE)) {
+ errorfc(fc, "%s option not supported", erofs_fs_parameters[opt].name);
+ } else {
+ kfree_sensitive(sbi->domain_id);
+ sbi->domain_id = no_free_ptr(param->string);
+ }
break;
-#endif
case Opt_directio:
if (!IS_ENABLED(CONFIG_EROFS_FS_BACKED_BY_FILE))
errorfc(fc, "%s option not supported", erofs_fs_parameters[opt].name);
{
struct erofs_sb_info *sbi = EROFS_SB(sb);
- if (sbi->domain_id && sbi->fsid)
- super_set_sysfs_name_generic(sb, "%s,%s", sbi->domain_id,
- sbi->fsid);
- else if (sbi->fsid)
- super_set_sysfs_name_generic(sb, "%s", sbi->fsid);
- else if (erofs_is_fileio_mode(sbi))
+ if (erofs_is_fileio_mode(sbi))
super_set_sysfs_name_generic(sb, "%s",
bdi_dev_name(sb->s_bdi));
else
sb->s_blocksize = PAGE_SIZE;
sb->s_blocksize_bits = PAGE_SHIFT;
- if (erofs_is_fscache_mode(sb)) {
- err = erofs_fscache_register_fs(sb);
- if (err)
- return err;
- }
err = super_setup_bdi(sb);
if (err)
return err;
return err;
if (sb->s_blocksize_bits != sbi->blkszbits) {
- if (erofs_is_fscache_mode(sb)) {
- errorfc(fc, "unsupported blksize for fscache mode");
- return -EINVAL;
- }
-
if (erofs_is_fileio_mode(sbi)) {
sb->s_blocksize = 1 << sbi->blkszbits;
sb->s_blocksize_bits = sbi->blkszbits;
return -EINVAL;
}
}
-
- if (sbi->dif0.fsoff) {
- if (sbi->dif0.fsoff & (sb->s_blocksize - 1))
- return invalfc(fc, "fsoffset %llu is not aligned to block size %lu",
- sbi->dif0.fsoff, sb->s_blocksize);
- if (erofs_is_fscache_mode(sb))
- return invalfc(fc, "cannot use fsoffset in fscache mode");
- }
+ if (sbi->dif0.fsoff & (sb->s_blocksize - 1))
+ return invalfc(fc, "fsoffset %llu is not aligned to block size %lu",
+ sbi->dif0.fsoff, sb->s_blocksize);
if (test_opt(&sbi->opt, DAX_ALWAYS) && sbi->blkszbits != PAGE_SHIFT) {
erofs_info(sb, "unsupported blocksize for DAX");
static int erofs_fc_get_tree(struct fs_context *fc)
{
- struct erofs_sb_info *sbi = fc->s_fs_info;
int ret;
- if (IS_ENABLED(CONFIG_EROFS_FS_ONDEMAND) && sbi->fsid)
- return get_tree_nodev(fc, erofs_fc_fill_super);
-
ret = get_tree_bdev_flags(fc, erofs_fc_fill_super,
IS_ENABLED(CONFIG_EROFS_FS_BACKED_BY_FILE) ?
GET_TREE_BDEV_QUIET_LOOKUP : 0);
if (IS_ENABLED(CONFIG_EROFS_FS_BACKED_BY_FILE) && ret == -ENOTBLK) {
+ struct erofs_sb_info *sbi = fc->s_fs_info;
struct file *file;
if (!fc->source)
DBG_BUGON(!sb_rdonly(sb));
- if (new_sbi->fsid || new_sbi->domain_id)
- erofs_info(sb, "ignoring reconfiguration for fsid|domain_id.");
+ if (new_sbi->domain_id)
+ erofs_info(sb, "ignoring reconfiguration for domain_id.");
if (test_opt(&new_sbi->opt, POSIX_ACL))
fc->sb_flags |= SB_POSIXACL;
fs_put_dax(dif->dax_dev, NULL);
if (dif->file)
fput(dif->file);
- erofs_fscache_unregister_cookie(dif->fscache);
- dif->fscache = NULL;
kfree(dif->path);
kfree(dif);
return 0;
static void erofs_sb_free(struct erofs_sb_info *sbi)
{
erofs_free_dev_context(sbi->devs);
- kfree(sbi->fsid);
kfree_sensitive(sbi->domain_id);
if (sbi->dif0.file)
fput(sbi->dif0.file);
{
struct erofs_sb_info *sbi = EROFS_SB(sb);
- if ((IS_ENABLED(CONFIG_EROFS_FS_ONDEMAND) && sbi->fsid) ||
- sbi->dif0.file)
+ if (sbi->dif0.file)
kill_anon_super(sb);
else
kill_block_super(sb);
erofs_drop_internal_inodes(sbi);
fs_put_dax(sbi->dif0.dax_dev, NULL);
- erofs_fscache_unregister_fs(sb);
erofs_sb_free(sbi);
sb->s_fs_info = NULL;
}
erofs_drop_internal_inodes(sbi);
erofs_free_dev_context(sbi->devs);
sbi->devs = NULL;
- erofs_fscache_unregister_fs(sb);
}
static struct file_system_type erofs_fs_type = {
};
MODULE_ALIAS_FS("erofs");
-#if defined(CONFIG_EROFS_FS_ONDEMAND) || defined(CONFIG_EROFS_FS_PAGE_CACHE_SHARE)
+#ifdef CONFIG_EROFS_FS_PAGE_CACHE_SHARE
static void erofs_free_anon_inode(struct inode *inode)
{
struct erofs_inode *vi = EROFS_I(inode);
-#ifdef CONFIG_EROFS_FS_PAGE_CACHE_SHARE
kfree(vi->fingerprint.opaque);
-#endif
kmem_cache_free(erofs_inode_cachep, vi);
}
seq_puts(seq, ",dax=never");
if (erofs_is_fileio_mode(sbi) && test_opt(opt, DIRECT_IO))
seq_puts(seq, ",directio");
- if (IS_ENABLED(CONFIG_EROFS_FS_ONDEMAND)) {
- if (sbi->fsid)
- seq_printf(seq, ",fsid=%s", sbi->fsid);
- if (sbi->domain_id)
- seq_printf(seq, ",domain_id=%s", sbi->domain_id);
- }
if (sbi->dif0.fsoff)
seq_printf(seq, ",fsoffset=%llu", sbi->dif0.fsoff);
if (test_opt(opt, INODE_SHARE))
projects / thirdparty / kernel / linux.git / commitdiff
