1484 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Simple file system for zoned block devices exposing zones as files.4 *5 * Copyright (C) 2019 Western Digital Corporation or its affiliates.6 */7#include <linux/module.h>8#include <linux/pagemap.h>9#include <linux/magic.h>10#include <linux/iomap.h>11#include <linux/init.h>12#include <linux/slab.h>13#include <linux/blkdev.h>14#include <linux/statfs.h>15#include <linux/writeback.h>16#include <linux/quotaops.h>17#include <linux/seq_file.h>18#include <linux/uio.h>19#include <linux/mman.h>20#include <linux/sched/mm.h>21#include <linux/crc32.h>22#include <linux/task_io_accounting_ops.h>23#include <linux/fs_parser.h>24#include <linux/fs_context.h>25 26#include "zonefs.h"27 28#define CREATE_TRACE_POINTS29#include "trace.h"30 31/*32 * Get the name of a zone group directory.33 */34static const char *zonefs_zgroup_name(enum zonefs_ztype ztype)35{36 switch (ztype) {37 case ZONEFS_ZTYPE_CNV:38 return "cnv";39 case ZONEFS_ZTYPE_SEQ:40 return "seq";41 default:42 WARN_ON_ONCE(1);43 return "???";44 }45}46 47/*48 * Manage the active zone count.49 */50static void zonefs_account_active(struct super_block *sb,51 struct zonefs_zone *z)52{53 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);54 55 if (zonefs_zone_is_cnv(z))56 return;57 58 /*59 * For zones that transitioned to the offline or readonly condition,60 * we only need to clear the active state.61 */62 if (z->z_flags & (ZONEFS_ZONE_OFFLINE | ZONEFS_ZONE_READONLY))63 goto out;64 65 /*66 * If the zone is active, that is, if it is explicitly open or67 * partially written, check if it was already accounted as active.68 */69 if ((z->z_flags & ZONEFS_ZONE_OPEN) ||70 (z->z_wpoffset > 0 && z->z_wpoffset < z->z_capacity)) {71 if (!(z->z_flags & ZONEFS_ZONE_ACTIVE)) {72 z->z_flags |= ZONEFS_ZONE_ACTIVE;73 atomic_inc(&sbi->s_active_seq_files);74 }75 return;76 }77 78out:79 /* The zone is not active. If it was, update the active count */80 if (z->z_flags & ZONEFS_ZONE_ACTIVE) {81 z->z_flags &= ~ZONEFS_ZONE_ACTIVE;82 atomic_dec(&sbi->s_active_seq_files);83 }84}85 86/*87 * Manage the active zone count. Called with zi->i_truncate_mutex held.88 */89void zonefs_inode_account_active(struct inode *inode)90{91 lockdep_assert_held(&ZONEFS_I(inode)->i_truncate_mutex);92 93 return zonefs_account_active(inode->i_sb, zonefs_inode_zone(inode));94}95 96/*97 * Execute a zone management operation.98 */99static int zonefs_zone_mgmt(struct super_block *sb,100 struct zonefs_zone *z, enum req_op op)101{102 int ret;103 104 /*105 * With ZNS drives, closing an explicitly open zone that has not been106 * written will change the zone state to "closed", that is, the zone107 * will remain active. Since this can then cause failure of explicit108 * open operation on other zones if the drive active zone resources109 * are exceeded, make sure that the zone does not remain active by110 * resetting it.111 */112 if (op == REQ_OP_ZONE_CLOSE && !z->z_wpoffset)113 op = REQ_OP_ZONE_RESET;114 115 trace_zonefs_zone_mgmt(sb, z, op);116 ret = blkdev_zone_mgmt(sb->s_bdev, op, z->z_sector,117 z->z_size >> SECTOR_SHIFT);118 if (ret) {119 zonefs_err(sb,120 "Zone management operation %s at %llu failed %d\n",121 blk_op_str(op), z->z_sector, ret);122 return ret;123 }124 125 return 0;126}127 128int zonefs_inode_zone_mgmt(struct inode *inode, enum req_op op)129{130 lockdep_assert_held(&ZONEFS_I(inode)->i_truncate_mutex);131 132 return zonefs_zone_mgmt(inode->i_sb, zonefs_inode_zone(inode), op);133}134 135void zonefs_i_size_write(struct inode *inode, loff_t isize)136{137 struct zonefs_zone *z = zonefs_inode_zone(inode);138 139 i_size_write(inode, isize);140 141 /*142 * A full zone is no longer open/active and does not need143 * explicit closing.144 */145 if (isize >= z->z_capacity) {146 struct zonefs_sb_info *sbi = ZONEFS_SB(inode->i_sb);147 148 if (z->z_flags & ZONEFS_ZONE_ACTIVE)149 atomic_dec(&sbi->s_active_seq_files);150 z->z_flags &= ~(ZONEFS_ZONE_OPEN | ZONEFS_ZONE_ACTIVE);151 }152}153 154void zonefs_update_stats(struct inode *inode, loff_t new_isize)155{156 struct super_block *sb = inode->i_sb;157 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);158 loff_t old_isize = i_size_read(inode);159 loff_t nr_blocks;160 161 if (new_isize == old_isize)162 return;163 164 spin_lock(&sbi->s_lock);165 166 /*167 * This may be called for an update after an IO error.168 * So beware of the values seen.169 */170 if (new_isize < old_isize) {171 nr_blocks = (old_isize - new_isize) >> sb->s_blocksize_bits;172 if (sbi->s_used_blocks > nr_blocks)173 sbi->s_used_blocks -= nr_blocks;174 else175 sbi->s_used_blocks = 0;176 } else {177 sbi->s_used_blocks +=178 (new_isize - old_isize) >> sb->s_blocksize_bits;179 if (sbi->s_used_blocks > sbi->s_blocks)180 sbi->s_used_blocks = sbi->s_blocks;181 }182 183 spin_unlock(&sbi->s_lock);184}185 186/*187 * Check a zone condition. Return the amount of written (and still readable)188 * data in the zone.189 */190static loff_t zonefs_check_zone_condition(struct super_block *sb,191 struct zonefs_zone *z,192 struct blk_zone *zone)193{194 switch (zone->cond) {195 case BLK_ZONE_COND_OFFLINE:196 zonefs_warn(sb, "Zone %llu: offline zone\n",197 z->z_sector);198 z->z_flags |= ZONEFS_ZONE_OFFLINE;199 return 0;200 case BLK_ZONE_COND_READONLY:201 /*202 * The write pointer of read-only zones is invalid, so we cannot203 * determine the zone wpoffset (inode size). We thus keep the204 * zone wpoffset as is, which leads to an empty file205 * (wpoffset == 0) on mount. For a runtime error, this keeps206 * the inode size as it was when last updated so that the user207 * can recover data.208 */209 zonefs_warn(sb, "Zone %llu: read-only zone\n",210 z->z_sector);211 z->z_flags |= ZONEFS_ZONE_READONLY;212 if (zonefs_zone_is_cnv(z))213 return z->z_capacity;214 return z->z_wpoffset;215 case BLK_ZONE_COND_FULL:216 /* The write pointer of full zones is invalid. */217 return z->z_capacity;218 default:219 if (zonefs_zone_is_cnv(z))220 return z->z_capacity;221 return (zone->wp - zone->start) << SECTOR_SHIFT;222 }223}224 225/*226 * Check a zone condition and adjust its inode access permissions for227 * offline and readonly zones.228 */229static void zonefs_inode_update_mode(struct inode *inode)230{231 struct zonefs_zone *z = zonefs_inode_zone(inode);232 233 if (z->z_flags & ZONEFS_ZONE_OFFLINE) {234 /* Offline zones cannot be read nor written */235 inode->i_flags |= S_IMMUTABLE;236 inode->i_mode &= ~0777;237 } else if (z->z_flags & ZONEFS_ZONE_READONLY) {238 /* Readonly zones cannot be written */239 inode->i_flags |= S_IMMUTABLE;240 if (z->z_flags & ZONEFS_ZONE_INIT_MODE)241 inode->i_mode &= ~0777;242 else243 inode->i_mode &= ~0222;244 }245 246 z->z_flags &= ~ZONEFS_ZONE_INIT_MODE;247 z->z_mode = inode->i_mode;248}249 250static int zonefs_io_error_cb(struct blk_zone *zone, unsigned int idx,251 void *data)252{253 struct blk_zone *z = data;254 255 *z = *zone;256 return 0;257}258 259static void zonefs_handle_io_error(struct inode *inode, struct blk_zone *zone,260 bool write)261{262 struct zonefs_zone *z = zonefs_inode_zone(inode);263 struct super_block *sb = inode->i_sb;264 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);265 loff_t isize, data_size;266 267 /*268 * Check the zone condition: if the zone is not "bad" (offline or269 * read-only), read errors are simply signaled to the IO issuer as long270 * as there is no inconsistency between the inode size and the amount of271 * data writen in the zone (data_size).272 */273 data_size = zonefs_check_zone_condition(sb, z, zone);274 isize = i_size_read(inode);275 if (!(z->z_flags & (ZONEFS_ZONE_READONLY | ZONEFS_ZONE_OFFLINE)) &&276 !write && isize == data_size)277 return;278 279 /*280 * At this point, we detected either a bad zone or an inconsistency281 * between the inode size and the amount of data written in the zone.282 * For the latter case, the cause may be a write IO error or an external283 * action on the device. Two error patterns exist:284 * 1) The inode size is lower than the amount of data in the zone:285 * a write operation partially failed and data was writen at the end286 * of the file. This can happen in the case of a large direct IO287 * needing several BIOs and/or write requests to be processed.288 * 2) The inode size is larger than the amount of data in the zone:289 * this can happen with a deferred write error with the use of the290 * device side write cache after getting successful write IO291 * completions. Other possibilities are (a) an external corruption,292 * e.g. an application reset the zone directly, or (b) the device293 * has a serious problem (e.g. firmware bug).294 *295 * In all cases, warn about inode size inconsistency and handle the296 * IO error according to the zone condition and to the mount options.297 */298 if (isize != data_size)299 zonefs_warn(sb,300 "inode %lu: invalid size %lld (should be %lld)\n",301 inode->i_ino, isize, data_size);302 303 /*304 * First handle bad zones signaled by hardware. The mount options305 * errors=zone-ro and errors=zone-offline result in changing the306 * zone condition to read-only and offline respectively, as if the307 * condition was signaled by the hardware.308 */309 if ((z->z_flags & ZONEFS_ZONE_OFFLINE) ||310 (sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_ZOL)) {311 zonefs_warn(sb, "inode %lu: read/write access disabled\n",312 inode->i_ino);313 if (!(z->z_flags & ZONEFS_ZONE_OFFLINE))314 z->z_flags |= ZONEFS_ZONE_OFFLINE;315 zonefs_inode_update_mode(inode);316 data_size = 0;317 } else if ((z->z_flags & ZONEFS_ZONE_READONLY) ||318 (sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_ZRO)) {319 zonefs_warn(sb, "inode %lu: write access disabled\n",320 inode->i_ino);321 if (!(z->z_flags & ZONEFS_ZONE_READONLY))322 z->z_flags |= ZONEFS_ZONE_READONLY;323 zonefs_inode_update_mode(inode);324 data_size = isize;325 } else if (sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_RO &&326 data_size > isize) {327 /* Do not expose garbage data */328 data_size = isize;329 }330 331 /*332 * If the filesystem is mounted with the explicit-open mount option, we333 * need to clear the ZONEFS_ZONE_OPEN flag if the zone transitioned to334 * the read-only or offline condition, to avoid attempting an explicit335 * close of the zone when the inode file is closed.336 */337 if ((sbi->s_mount_opts & ZONEFS_MNTOPT_EXPLICIT_OPEN) &&338 (z->z_flags & (ZONEFS_ZONE_READONLY | ZONEFS_ZONE_OFFLINE)))339 z->z_flags &= ~ZONEFS_ZONE_OPEN;340 341 /*342 * If error=remount-ro was specified, any error result in remounting343 * the volume as read-only.344 */345 if ((sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_RO) && !sb_rdonly(sb)) {346 zonefs_warn(sb, "remounting filesystem read-only\n");347 sb->s_flags |= SB_RDONLY;348 }349 350 /*351 * Update block usage stats and the inode size to prevent access to352 * invalid data.353 */354 zonefs_update_stats(inode, data_size);355 zonefs_i_size_write(inode, data_size);356 z->z_wpoffset = data_size;357 zonefs_inode_account_active(inode);358}359 360/*361 * When an file IO error occurs, check the file zone to see if there is a change362 * in the zone condition (e.g. offline or read-only). For a failed write to a363 * sequential zone, the zone write pointer position must also be checked to364 * eventually correct the file size and zonefs inode write pointer offset365 * (which can be out of sync with the drive due to partial write failures).366 */367void __zonefs_io_error(struct inode *inode, bool write)368{369 struct zonefs_zone *z = zonefs_inode_zone(inode);370 struct super_block *sb = inode->i_sb;371 unsigned int noio_flag;372 struct blk_zone zone;373 int ret;374 375 /*376 * Conventional zone have no write pointer and cannot become read-only377 * or offline. So simply fake a report for a single or aggregated zone378 * and let zonefs_handle_io_error() correct the zone inode information379 * according to the mount options.380 */381 if (!zonefs_zone_is_seq(z)) {382 zone.start = z->z_sector;383 zone.len = z->z_size >> SECTOR_SHIFT;384 zone.wp = zone.start + zone.len;385 zone.type = BLK_ZONE_TYPE_CONVENTIONAL;386 zone.cond = BLK_ZONE_COND_NOT_WP;387 zone.capacity = zone.len;388 goto handle_io_error;389 }390 391 /*392 * Memory allocations in blkdev_report_zones() can trigger a memory393 * reclaim which may in turn cause a recursion into zonefs as well as394 * struct request allocations for the same device. The former case may395 * end up in a deadlock on the inode truncate mutex, while the latter396 * may prevent IO forward progress. Executing the report zones under397 * the GFP_NOIO context avoids both problems.398 */399 noio_flag = memalloc_noio_save();400 ret = blkdev_report_zones(sb->s_bdev, z->z_sector, 1,401 zonefs_io_error_cb, &zone);402 memalloc_noio_restore(noio_flag);403 404 if (ret != 1) {405 zonefs_err(sb, "Get inode %lu zone information failed %d\n",406 inode->i_ino, ret);407 zonefs_warn(sb, "remounting filesystem read-only\n");408 sb->s_flags |= SB_RDONLY;409 return;410 }411 412handle_io_error:413 zonefs_handle_io_error(inode, &zone, write);414}415 416static struct kmem_cache *zonefs_inode_cachep;417 418static struct inode *zonefs_alloc_inode(struct super_block *sb)419{420 struct zonefs_inode_info *zi;421 422 zi = alloc_inode_sb(sb, zonefs_inode_cachep, GFP_KERNEL);423 if (!zi)424 return NULL;425 426 inode_init_once(&zi->i_vnode);427 mutex_init(&zi->i_truncate_mutex);428 zi->i_wr_refcnt = 0;429 430 return &zi->i_vnode;431}432 433static void zonefs_free_inode(struct inode *inode)434{435 kmem_cache_free(zonefs_inode_cachep, ZONEFS_I(inode));436}437 438/*439 * File system stat.440 */441static int zonefs_statfs(struct dentry *dentry, struct kstatfs *buf)442{443 struct super_block *sb = dentry->d_sb;444 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);445 enum zonefs_ztype t;446 447 buf->f_type = ZONEFS_MAGIC;448 buf->f_bsize = sb->s_blocksize;449 buf->f_namelen = ZONEFS_NAME_MAX;450 451 spin_lock(&sbi->s_lock);452 453 buf->f_blocks = sbi->s_blocks;454 if (WARN_ON(sbi->s_used_blocks > sbi->s_blocks))455 buf->f_bfree = 0;456 else457 buf->f_bfree = buf->f_blocks - sbi->s_used_blocks;458 buf->f_bavail = buf->f_bfree;459 460 for (t = 0; t < ZONEFS_ZTYPE_MAX; t++) {461 if (sbi->s_zgroup[t].g_nr_zones)462 buf->f_files += sbi->s_zgroup[t].g_nr_zones + 1;463 }464 buf->f_ffree = 0;465 466 spin_unlock(&sbi->s_lock);467 468 buf->f_fsid = uuid_to_fsid(sbi->s_uuid.b);469 470 return 0;471}472 473enum {474 Opt_errors, Opt_explicit_open,475};476 477struct zonefs_context {478 unsigned long s_mount_opts;479};480 481static const struct constant_table zonefs_param_errors[] = {482 {"remount-ro", ZONEFS_MNTOPT_ERRORS_RO},483 {"zone-ro", ZONEFS_MNTOPT_ERRORS_ZRO},484 {"zone-offline", ZONEFS_MNTOPT_ERRORS_ZOL},485 {"repair", ZONEFS_MNTOPT_ERRORS_REPAIR},486 {}487};488 489static const struct fs_parameter_spec zonefs_param_spec[] = {490 fsparam_enum ("errors", Opt_errors, zonefs_param_errors),491 fsparam_flag ("explicit-open", Opt_explicit_open),492 {}493};494 495static int zonefs_parse_param(struct fs_context *fc, struct fs_parameter *param)496{497 struct zonefs_context *ctx = fc->fs_private;498 struct fs_parse_result result;499 int opt;500 501 opt = fs_parse(fc, zonefs_param_spec, param, &result);502 if (opt < 0)503 return opt;504 505 switch (opt) {506 case Opt_errors:507 ctx->s_mount_opts &= ~ZONEFS_MNTOPT_ERRORS_MASK;508 ctx->s_mount_opts |= result.uint_32;509 break;510 case Opt_explicit_open:511 ctx->s_mount_opts |= ZONEFS_MNTOPT_EXPLICIT_OPEN;512 break;513 default:514 return -EINVAL;515 }516 517 return 0;518}519 520static int zonefs_show_options(struct seq_file *seq, struct dentry *root)521{522 struct zonefs_sb_info *sbi = ZONEFS_SB(root->d_sb);523 524 if (sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_RO)525 seq_puts(seq, ",errors=remount-ro");526 if (sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_ZRO)527 seq_puts(seq, ",errors=zone-ro");528 if (sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_ZOL)529 seq_puts(seq, ",errors=zone-offline");530 if (sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_REPAIR)531 seq_puts(seq, ",errors=repair");532 533 return 0;534}535 536static int zonefs_inode_setattr(struct mnt_idmap *idmap,537 struct dentry *dentry, struct iattr *iattr)538{539 struct inode *inode = d_inode(dentry);540 int ret;541 542 if (unlikely(IS_IMMUTABLE(inode)))543 return -EPERM;544 545 ret = setattr_prepare(&nop_mnt_idmap, dentry, iattr);546 if (ret)547 return ret;548 549 /*550 * Since files and directories cannot be created nor deleted, do not551 * allow setting any write attributes on the sub-directories grouping552 * files by zone type.553 */554 if ((iattr->ia_valid & ATTR_MODE) && S_ISDIR(inode->i_mode) &&555 (iattr->ia_mode & 0222))556 return -EPERM;557 558 if (((iattr->ia_valid & ATTR_UID) &&559 !uid_eq(iattr->ia_uid, inode->i_uid)) ||560 ((iattr->ia_valid & ATTR_GID) &&561 !gid_eq(iattr->ia_gid, inode->i_gid))) {562 ret = dquot_transfer(&nop_mnt_idmap, inode, iattr);563 if (ret)564 return ret;565 }566 567 if (iattr->ia_valid & ATTR_SIZE) {568 ret = zonefs_file_truncate(inode, iattr->ia_size);569 if (ret)570 return ret;571 }572 573 setattr_copy(&nop_mnt_idmap, inode, iattr);574 575 if (S_ISREG(inode->i_mode)) {576 struct zonefs_zone *z = zonefs_inode_zone(inode);577 578 z->z_mode = inode->i_mode;579 z->z_uid = inode->i_uid;580 z->z_gid = inode->i_gid;581 }582 583 return 0;584}585 586static const struct inode_operations zonefs_file_inode_operations = {587 .setattr = zonefs_inode_setattr,588};589 590static long zonefs_fname_to_fno(const struct qstr *fname)591{592 const char *name = fname->name;593 unsigned int len = fname->len;594 long fno = 0, shift = 1;595 const char *rname;596 char c = *name;597 unsigned int i;598 599 /*600 * File names are always a base-10 number string without any601 * leading 0s.602 */603 if (!isdigit(c))604 return -ENOENT;605 606 if (len > 1 && c == '0')607 return -ENOENT;608 609 if (len == 1)610 return c - '0';611 612 for (i = 0, rname = name + len - 1; i < len; i++, rname--) {613 c = *rname;614 if (!isdigit(c))615 return -ENOENT;616 fno += (c - '0') * shift;617 shift *= 10;618 }619 620 return fno;621}622 623static struct inode *zonefs_get_file_inode(struct inode *dir,624 struct dentry *dentry)625{626 struct zonefs_zone_group *zgroup = dir->i_private;627 struct super_block *sb = dir->i_sb;628 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);629 struct zonefs_zone *z;630 struct inode *inode;631 ino_t ino;632 long fno;633 634 /* Get the file number from the file name */635 fno = zonefs_fname_to_fno(&dentry->d_name);636 if (fno < 0)637 return ERR_PTR(fno);638 639 if (!zgroup->g_nr_zones || fno >= zgroup->g_nr_zones)640 return ERR_PTR(-ENOENT);641 642 z = &zgroup->g_zones[fno];643 ino = z->z_sector >> sbi->s_zone_sectors_shift;644 inode = iget_locked(sb, ino);645 if (!inode)646 return ERR_PTR(-ENOMEM);647 if (!(inode->i_state & I_NEW)) {648 WARN_ON_ONCE(inode->i_private != z);649 return inode;650 }651 652 inode->i_ino = ino;653 inode->i_mode = z->z_mode;654 inode_set_mtime_to_ts(inode,655 inode_set_atime_to_ts(inode, inode_set_ctime_to_ts(inode, inode_get_ctime(dir))));656 inode->i_uid = z->z_uid;657 inode->i_gid = z->z_gid;658 inode->i_size = z->z_wpoffset;659 inode->i_blocks = z->z_capacity >> SECTOR_SHIFT;660 inode->i_private = z;661 662 inode->i_op = &zonefs_file_inode_operations;663 inode->i_fop = &zonefs_file_operations;664 inode->i_mapping->a_ops = &zonefs_file_aops;665 mapping_set_large_folios(inode->i_mapping);666 667 /* Update the inode access rights depending on the zone condition */668 zonefs_inode_update_mode(inode);669 670 unlock_new_inode(inode);671 672 return inode;673}674 675static struct inode *zonefs_get_zgroup_inode(struct super_block *sb,676 enum zonefs_ztype ztype)677{678 struct inode *root = d_inode(sb->s_root);679 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);680 struct inode *inode;681 ino_t ino = bdev_nr_zones(sb->s_bdev) + ztype + 1;682 683 inode = iget_locked(sb, ino);684 if (!inode)685 return ERR_PTR(-ENOMEM);686 if (!(inode->i_state & I_NEW))687 return inode;688 689 inode->i_ino = ino;690 inode_init_owner(&nop_mnt_idmap, inode, root, S_IFDIR | 0555);691 inode->i_size = sbi->s_zgroup[ztype].g_nr_zones;692 inode_set_mtime_to_ts(inode,693 inode_set_atime_to_ts(inode, inode_set_ctime_to_ts(inode, inode_get_ctime(root))));694 inode->i_private = &sbi->s_zgroup[ztype];695 set_nlink(inode, 2);696 697 inode->i_op = &zonefs_dir_inode_operations;698 inode->i_fop = &zonefs_dir_operations;699 700 unlock_new_inode(inode);701 702 return inode;703}704 705 706static struct inode *zonefs_get_dir_inode(struct inode *dir,707 struct dentry *dentry)708{709 struct super_block *sb = dir->i_sb;710 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);711 const char *name = dentry->d_name.name;712 enum zonefs_ztype ztype;713 714 /*715 * We only need to check for the "seq" directory and716 * the "cnv" directory if we have conventional zones.717 */718 if (dentry->d_name.len != 3)719 return ERR_PTR(-ENOENT);720 721 for (ztype = 0; ztype < ZONEFS_ZTYPE_MAX; ztype++) {722 if (sbi->s_zgroup[ztype].g_nr_zones &&723 memcmp(name, zonefs_zgroup_name(ztype), 3) == 0)724 break;725 }726 if (ztype == ZONEFS_ZTYPE_MAX)727 return ERR_PTR(-ENOENT);728 729 return zonefs_get_zgroup_inode(sb, ztype);730}731 732static struct dentry *zonefs_lookup(struct inode *dir, struct dentry *dentry,733 unsigned int flags)734{735 struct inode *inode;736 737 if (dentry->d_name.len > ZONEFS_NAME_MAX)738 return ERR_PTR(-ENAMETOOLONG);739 740 if (dir == d_inode(dir->i_sb->s_root))741 inode = zonefs_get_dir_inode(dir, dentry);742 else743 inode = zonefs_get_file_inode(dir, dentry);744 745 return d_splice_alias(inode, dentry);746}747 748static int zonefs_readdir_root(struct file *file, struct dir_context *ctx)749{750 struct inode *inode = file_inode(file);751 struct super_block *sb = inode->i_sb;752 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);753 enum zonefs_ztype ztype = ZONEFS_ZTYPE_CNV;754 ino_t base_ino = bdev_nr_zones(sb->s_bdev) + 1;755 756 if (ctx->pos >= inode->i_size)757 return 0;758 759 if (!dir_emit_dots(file, ctx))760 return 0;761 762 if (ctx->pos == 2) {763 if (!sbi->s_zgroup[ZONEFS_ZTYPE_CNV].g_nr_zones)764 ztype = ZONEFS_ZTYPE_SEQ;765 766 if (!dir_emit(ctx, zonefs_zgroup_name(ztype), 3,767 base_ino + ztype, DT_DIR))768 return 0;769 ctx->pos++;770 }771 772 if (ctx->pos == 3 && ztype != ZONEFS_ZTYPE_SEQ) {773 ztype = ZONEFS_ZTYPE_SEQ;774 if (!dir_emit(ctx, zonefs_zgroup_name(ztype), 3,775 base_ino + ztype, DT_DIR))776 return 0;777 ctx->pos++;778 }779 780 return 0;781}782 783static int zonefs_readdir_zgroup(struct file *file,784 struct dir_context *ctx)785{786 struct inode *inode = file_inode(file);787 struct zonefs_zone_group *zgroup = inode->i_private;788 struct super_block *sb = inode->i_sb;789 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);790 struct zonefs_zone *z;791 int fname_len;792 char *fname;793 ino_t ino;794 int f;795 796 /*797 * The size of zone group directories is equal to the number798 * of zone files in the group and does note include the "." and799 * ".." entries. Hence the "+ 2" here.800 */801 if (ctx->pos >= inode->i_size + 2)802 return 0;803 804 if (!dir_emit_dots(file, ctx))805 return 0;806 807 fname = kmalloc(ZONEFS_NAME_MAX, GFP_KERNEL);808 if (!fname)809 return -ENOMEM;810 811 for (f = ctx->pos - 2; f < zgroup->g_nr_zones; f++) {812 z = &zgroup->g_zones[f];813 ino = z->z_sector >> sbi->s_zone_sectors_shift;814 fname_len = snprintf(fname, ZONEFS_NAME_MAX - 1, "%u", f);815 if (!dir_emit(ctx, fname, fname_len, ino, DT_REG))816 break;817 ctx->pos++;818 }819 820 kfree(fname);821 822 return 0;823}824 825static int zonefs_readdir(struct file *file, struct dir_context *ctx)826{827 struct inode *inode = file_inode(file);828 829 if (inode == d_inode(inode->i_sb->s_root))830 return zonefs_readdir_root(file, ctx);831 832 return zonefs_readdir_zgroup(file, ctx);833}834 835const struct inode_operations zonefs_dir_inode_operations = {836 .lookup = zonefs_lookup,837 .setattr = zonefs_inode_setattr,838};839 840const struct file_operations zonefs_dir_operations = {841 .llseek = generic_file_llseek,842 .read = generic_read_dir,843 .iterate_shared = zonefs_readdir,844};845 846struct zonefs_zone_data {847 struct super_block *sb;848 unsigned int nr_zones[ZONEFS_ZTYPE_MAX];849 sector_t cnv_zone_start;850 struct blk_zone *zones;851};852 853static int zonefs_get_zone_info_cb(struct blk_zone *zone, unsigned int idx,854 void *data)855{856 struct zonefs_zone_data *zd = data;857 struct super_block *sb = zd->sb;858 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);859 860 /*861 * We do not care about the first zone: it contains the super block862 * and not exposed as a file.863 */864 if (!idx)865 return 0;866 867 /*868 * Count the number of zones that will be exposed as files.869 * For sequential zones, we always have as many files as zones.870 * FOr conventional zones, the number of files depends on if we have871 * conventional zones aggregation enabled.872 */873 switch (zone->type) {874 case BLK_ZONE_TYPE_CONVENTIONAL:875 if (sbi->s_features & ZONEFS_F_AGGRCNV) {876 /* One file per set of contiguous conventional zones */877 if (!(sbi->s_zgroup[ZONEFS_ZTYPE_CNV].g_nr_zones) ||878 zone->start != zd->cnv_zone_start)879 sbi->s_zgroup[ZONEFS_ZTYPE_CNV].g_nr_zones++;880 zd->cnv_zone_start = zone->start + zone->len;881 } else {882 /* One file per zone */883 sbi->s_zgroup[ZONEFS_ZTYPE_CNV].g_nr_zones++;884 }885 break;886 case BLK_ZONE_TYPE_SEQWRITE_REQ:887 case BLK_ZONE_TYPE_SEQWRITE_PREF:888 sbi->s_zgroup[ZONEFS_ZTYPE_SEQ].g_nr_zones++;889 break;890 default:891 zonefs_err(zd->sb, "Unsupported zone type 0x%x\n",892 zone->type);893 return -EIO;894 }895 896 memcpy(&zd->zones[idx], zone, sizeof(struct blk_zone));897 898 return 0;899}900 901static int zonefs_get_zone_info(struct zonefs_zone_data *zd)902{903 struct block_device *bdev = zd->sb->s_bdev;904 int ret;905 906 zd->zones = kvcalloc(bdev_nr_zones(bdev), sizeof(struct blk_zone),907 GFP_KERNEL);908 if (!zd->zones)909 return -ENOMEM;910 911 /* Get zones information from the device */912 ret = blkdev_report_zones(bdev, 0, BLK_ALL_ZONES,913 zonefs_get_zone_info_cb, zd);914 if (ret < 0) {915 zonefs_err(zd->sb, "Zone report failed %d\n", ret);916 return ret;917 }918 919 if (ret != bdev_nr_zones(bdev)) {920 zonefs_err(zd->sb, "Invalid zone report (%d/%u zones)\n",921 ret, bdev_nr_zones(bdev));922 return -EIO;923 }924 925 return 0;926}927 928static inline void zonefs_free_zone_info(struct zonefs_zone_data *zd)929{930 kvfree(zd->zones);931}932 933/*934 * Create a zone group and populate it with zone files.935 */936static int zonefs_init_zgroup(struct super_block *sb,937 struct zonefs_zone_data *zd,938 enum zonefs_ztype ztype)939{940 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);941 struct zonefs_zone_group *zgroup = &sbi->s_zgroup[ztype];942 struct blk_zone *zone, *next, *end;943 struct zonefs_zone *z;944 unsigned int n = 0;945 int ret;946 947 /* Allocate the zone group. If it is empty, we have nothing to do. */948 if (!zgroup->g_nr_zones)949 return 0;950 951 zgroup->g_zones = kvcalloc(zgroup->g_nr_zones,952 sizeof(struct zonefs_zone), GFP_KERNEL);953 if (!zgroup->g_zones)954 return -ENOMEM;955 956 /*957 * Initialize the zone groups using the device zone information.958 * We always skip the first zone as it contains the super block959 * and is not use to back a file.960 */961 end = zd->zones + bdev_nr_zones(sb->s_bdev);962 for (zone = &zd->zones[1]; zone < end; zone = next) {963 964 next = zone + 1;965 if (zonefs_zone_type(zone) != ztype)966 continue;967 968 if (WARN_ON_ONCE(n >= zgroup->g_nr_zones))969 return -EINVAL;970 971 /*972 * For conventional zones, contiguous zones can be aggregated973 * together to form larger files. Note that this overwrites the974 * length of the first zone of the set of contiguous zones975 * aggregated together. If one offline or read-only zone is976 * found, assume that all zones aggregated have the same977 * condition.978 */979 if (ztype == ZONEFS_ZTYPE_CNV &&980 (sbi->s_features & ZONEFS_F_AGGRCNV)) {981 for (; next < end; next++) {982 if (zonefs_zone_type(next) != ztype)983 break;984 zone->len += next->len;985 zone->capacity += next->capacity;986 if (next->cond == BLK_ZONE_COND_READONLY &&987 zone->cond != BLK_ZONE_COND_OFFLINE)988 zone->cond = BLK_ZONE_COND_READONLY;989 else if (next->cond == BLK_ZONE_COND_OFFLINE)990 zone->cond = BLK_ZONE_COND_OFFLINE;991 }992 }993 994 z = &zgroup->g_zones[n];995 if (ztype == ZONEFS_ZTYPE_CNV)996 z->z_flags |= ZONEFS_ZONE_CNV;997 z->z_sector = zone->start;998 z->z_size = zone->len << SECTOR_SHIFT;999 if (z->z_size > bdev_zone_sectors(sb->s_bdev) << SECTOR_SHIFT &&1000 !(sbi->s_features & ZONEFS_F_AGGRCNV)) {1001 zonefs_err(sb,1002 "Invalid zone size %llu (device zone sectors %llu)\n",1003 z->z_size,1004 bdev_zone_sectors(sb->s_bdev) << SECTOR_SHIFT);1005 return -EINVAL;1006 }1007 1008 z->z_capacity = min_t(loff_t, MAX_LFS_FILESIZE,1009 zone->capacity << SECTOR_SHIFT);1010 z->z_wpoffset = zonefs_check_zone_condition(sb, z, zone);1011 1012 z->z_mode = S_IFREG | sbi->s_perm;1013 z->z_uid = sbi->s_uid;1014 z->z_gid = sbi->s_gid;1015 1016 /*1017 * Let zonefs_inode_update_mode() know that we will need1018 * special initialization of the inode mode the first time1019 * it is accessed.1020 */1021 z->z_flags |= ZONEFS_ZONE_INIT_MODE;1022 1023 sb->s_maxbytes = max(z->z_capacity, sb->s_maxbytes);1024 sbi->s_blocks += z->z_capacity >> sb->s_blocksize_bits;1025 sbi->s_used_blocks += z->z_wpoffset >> sb->s_blocksize_bits;1026 1027 /*1028 * For sequential zones, make sure that any open zone is closed1029 * first to ensure that the initial number of open zones is 0,1030 * in sync with the open zone accounting done when the mount1031 * option ZONEFS_MNTOPT_EXPLICIT_OPEN is used.1032 */1033 if (ztype == ZONEFS_ZTYPE_SEQ &&1034 (zone->cond == BLK_ZONE_COND_IMP_OPEN ||1035 zone->cond == BLK_ZONE_COND_EXP_OPEN)) {1036 ret = zonefs_zone_mgmt(sb, z, REQ_OP_ZONE_CLOSE);1037 if (ret)1038 return ret;1039 }1040 1041 zonefs_account_active(sb, z);1042 1043 n++;1044 }1045 1046 if (WARN_ON_ONCE(n != zgroup->g_nr_zones))1047 return -EINVAL;1048 1049 zonefs_info(sb, "Zone group \"%s\" has %u file%s\n",1050 zonefs_zgroup_name(ztype),1051 zgroup->g_nr_zones,1052 str_plural(zgroup->g_nr_zones));1053 1054 return 0;1055}1056 1057static void zonefs_free_zgroups(struct super_block *sb)1058{1059 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);1060 enum zonefs_ztype ztype;1061 1062 if (!sbi)1063 return;1064 1065 for (ztype = 0; ztype < ZONEFS_ZTYPE_MAX; ztype++) {1066 kvfree(sbi->s_zgroup[ztype].g_zones);1067 sbi->s_zgroup[ztype].g_zones = NULL;1068 }1069}1070 1071/*1072 * Create a zone group and populate it with zone files.1073 */1074static int zonefs_init_zgroups(struct super_block *sb)1075{1076 struct zonefs_zone_data zd;1077 enum zonefs_ztype ztype;1078 int ret;1079 1080 /* First get the device zone information */1081 memset(&zd, 0, sizeof(struct zonefs_zone_data));1082 zd.sb = sb;1083 ret = zonefs_get_zone_info(&zd);1084 if (ret)1085 goto cleanup;1086 1087 /* Allocate and initialize the zone groups */1088 for (ztype = 0; ztype < ZONEFS_ZTYPE_MAX; ztype++) {1089 ret = zonefs_init_zgroup(sb, &zd, ztype);1090 if (ret) {1091 zonefs_info(sb,1092 "Zone group \"%s\" initialization failed\n",1093 zonefs_zgroup_name(ztype));1094 break;1095 }1096 }1097 1098cleanup:1099 zonefs_free_zone_info(&zd);1100 if (ret)1101 zonefs_free_zgroups(sb);1102 1103 return ret;1104}1105 1106/*1107 * Read super block information from the device.1108 */1109static int zonefs_read_super(struct super_block *sb)1110{1111 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);1112 struct zonefs_super *super;1113 u32 crc, stored_crc;1114 struct page *page;1115 struct bio_vec bio_vec;1116 struct bio bio;1117 int ret;1118 1119 page = alloc_page(GFP_KERNEL);1120 if (!page)1121 return -ENOMEM;1122 1123 bio_init(&bio, sb->s_bdev, &bio_vec, 1, REQ_OP_READ);1124 bio.bi_iter.bi_sector = 0;1125 __bio_add_page(&bio, page, PAGE_SIZE, 0);1126 1127 ret = submit_bio_wait(&bio);1128 if (ret)1129 goto free_page;1130 1131 super = page_address(page);1132 1133 ret = -EINVAL;1134 if (le32_to_cpu(super->s_magic) != ZONEFS_MAGIC)1135 goto free_page;1136 1137 stored_crc = le32_to_cpu(super->s_crc);1138 super->s_crc = 0;1139 crc = crc32(~0U, (unsigned char *)super, sizeof(struct zonefs_super));1140 if (crc != stored_crc) {1141 zonefs_err(sb, "Invalid checksum (Expected 0x%08x, got 0x%08x)",1142 crc, stored_crc);1143 goto free_page;1144 }1145 1146 sbi->s_features = le64_to_cpu(super->s_features);1147 if (sbi->s_features & ~ZONEFS_F_DEFINED_FEATURES) {1148 zonefs_err(sb, "Unknown features set 0x%llx\n",1149 sbi->s_features);1150 goto free_page;1151 }1152 1153 if (sbi->s_features & ZONEFS_F_UID) {1154 sbi->s_uid = make_kuid(current_user_ns(),1155 le32_to_cpu(super->s_uid));1156 if (!uid_valid(sbi->s_uid)) {1157 zonefs_err(sb, "Invalid UID feature\n");1158 goto free_page;1159 }1160 }1161 1162 if (sbi->s_features & ZONEFS_F_GID) {1163 sbi->s_gid = make_kgid(current_user_ns(),1164 le32_to_cpu(super->s_gid));1165 if (!gid_valid(sbi->s_gid)) {1166 zonefs_err(sb, "Invalid GID feature\n");1167 goto free_page;1168 }1169 }1170 1171 if (sbi->s_features & ZONEFS_F_PERM)1172 sbi->s_perm = le32_to_cpu(super->s_perm);1173 1174 if (memchr_inv(super->s_reserved, 0, sizeof(super->s_reserved))) {1175 zonefs_err(sb, "Reserved area is being used\n");1176 goto free_page;1177 }1178 1179 import_uuid(&sbi->s_uuid, super->s_uuid);1180 ret = 0;1181 1182free_page:1183 __free_page(page);1184 1185 return ret;1186}1187 1188static const struct super_operations zonefs_sops = {1189 .alloc_inode = zonefs_alloc_inode,1190 .free_inode = zonefs_free_inode,1191 .statfs = zonefs_statfs,1192 .show_options = zonefs_show_options,1193};1194 1195static int zonefs_get_zgroup_inodes(struct super_block *sb)1196{1197 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);1198 struct inode *dir_inode;1199 enum zonefs_ztype ztype;1200 1201 for (ztype = 0; ztype < ZONEFS_ZTYPE_MAX; ztype++) {1202 if (!sbi->s_zgroup[ztype].g_nr_zones)1203 continue;1204 1205 dir_inode = zonefs_get_zgroup_inode(sb, ztype);1206 if (IS_ERR(dir_inode))1207 return PTR_ERR(dir_inode);1208 1209 sbi->s_zgroup[ztype].g_inode = dir_inode;1210 }1211 1212 return 0;1213}1214 1215static void zonefs_release_zgroup_inodes(struct super_block *sb)1216{1217 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);1218 enum zonefs_ztype ztype;1219 1220 if (!sbi)1221 return;1222 1223 for (ztype = 0; ztype < ZONEFS_ZTYPE_MAX; ztype++) {1224 if (sbi->s_zgroup[ztype].g_inode) {1225 iput(sbi->s_zgroup[ztype].g_inode);1226 sbi->s_zgroup[ztype].g_inode = NULL;1227 }1228 }1229}1230 1231/*1232 * Check that the device is zoned. If it is, get the list of zones and create1233 * sub-directories and files according to the device zone configuration and1234 * format options.1235 */1236static int zonefs_fill_super(struct super_block *sb, struct fs_context *fc)1237{1238 struct zonefs_sb_info *sbi;1239 struct zonefs_context *ctx = fc->fs_private;1240 struct inode *inode;1241 enum zonefs_ztype ztype;1242 int ret;1243 1244 if (!bdev_is_zoned(sb->s_bdev)) {1245 zonefs_err(sb, "Not a zoned block device\n");1246 return -EINVAL;1247 }1248 1249 /*1250 * Initialize super block information: the maximum file size is updated1251 * when the zone files are created so that the format option1252 * ZONEFS_F_AGGRCNV which increases the maximum file size of a file1253 * beyond the zone size is taken into account.1254 */1255 sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);1256 if (!sbi)1257 return -ENOMEM;1258 1259 spin_lock_init(&sbi->s_lock);1260 sb->s_fs_info = sbi;1261 sb->s_magic = ZONEFS_MAGIC;1262 sb->s_maxbytes = 0;1263 sb->s_op = &zonefs_sops;1264 sb->s_time_gran = 1;1265 1266 /*1267 * The block size is set to the device zone write granularity to ensure1268 * that write operations are always aligned according to the device1269 * interface constraints.1270 */1271 sb_set_blocksize(sb, bdev_zone_write_granularity(sb->s_bdev));1272 sbi->s_zone_sectors_shift = ilog2(bdev_zone_sectors(sb->s_bdev));1273 sbi->s_uid = GLOBAL_ROOT_UID;1274 sbi->s_gid = GLOBAL_ROOT_GID;1275 sbi->s_perm = 0640;1276 sbi->s_mount_opts = ctx->s_mount_opts;1277 1278 atomic_set(&sbi->s_wro_seq_files, 0);1279 sbi->s_max_wro_seq_files = bdev_max_open_zones(sb->s_bdev);1280 atomic_set(&sbi->s_active_seq_files, 0);1281 sbi->s_max_active_seq_files = bdev_max_active_zones(sb->s_bdev);1282 1283 ret = zonefs_read_super(sb);1284 if (ret)1285 return ret;1286 1287 zonefs_info(sb, "Mounting %u zones", bdev_nr_zones(sb->s_bdev));1288 1289 if (!sbi->s_max_wro_seq_files &&1290 !sbi->s_max_active_seq_files &&1291 sbi->s_mount_opts & ZONEFS_MNTOPT_EXPLICIT_OPEN) {1292 zonefs_info(sb,1293 "No open and active zone limits. Ignoring explicit_open mount option\n");1294 sbi->s_mount_opts &= ~ZONEFS_MNTOPT_EXPLICIT_OPEN;1295 }1296 1297 /* Initialize the zone groups */1298 ret = zonefs_init_zgroups(sb);1299 if (ret)1300 goto cleanup;1301 1302 /* Create the root directory inode */1303 ret = -ENOMEM;1304 inode = new_inode(sb);1305 if (!inode)1306 goto cleanup;1307 1308 inode->i_ino = bdev_nr_zones(sb->s_bdev);1309 inode->i_mode = S_IFDIR | 0555;1310 simple_inode_init_ts(inode);1311 inode->i_op = &zonefs_dir_inode_operations;1312 inode->i_fop = &zonefs_dir_operations;1313 inode->i_size = 2;1314 set_nlink(inode, 2);1315 for (ztype = 0; ztype < ZONEFS_ZTYPE_MAX; ztype++) {1316 if (sbi->s_zgroup[ztype].g_nr_zones) {1317 inc_nlink(inode);1318 inode->i_size++;1319 }1320 }1321 1322 sb->s_root = d_make_root(inode);1323 if (!sb->s_root)1324 goto cleanup;1325 1326 /*1327 * Take a reference on the zone groups directory inodes1328 * to keep them in the inode cache.1329 */1330 ret = zonefs_get_zgroup_inodes(sb);1331 if (ret)1332 goto cleanup;1333 1334 ret = zonefs_sysfs_register(sb);1335 if (ret)1336 goto cleanup;1337 1338 return 0;1339 1340cleanup:1341 zonefs_release_zgroup_inodes(sb);1342 zonefs_free_zgroups(sb);1343 1344 return ret;1345}1346 1347static void zonefs_kill_super(struct super_block *sb)1348{1349 struct zonefs_sb_info *sbi = ZONEFS_SB(sb);1350 1351 /* Release the reference on the zone group directory inodes */1352 zonefs_release_zgroup_inodes(sb);1353 1354 kill_block_super(sb);1355 1356 zonefs_sysfs_unregister(sb);1357 zonefs_free_zgroups(sb);1358 kfree(sbi);1359}1360 1361static void zonefs_free_fc(struct fs_context *fc)1362{1363 struct zonefs_context *ctx = fc->fs_private;1364 1365 kfree(ctx);1366}1367 1368static int zonefs_get_tree(struct fs_context *fc)1369{1370 return get_tree_bdev(fc, zonefs_fill_super);1371}1372 1373static int zonefs_reconfigure(struct fs_context *fc)1374{1375 struct zonefs_context *ctx = fc->fs_private;1376 struct super_block *sb = fc->root->d_sb;1377 struct zonefs_sb_info *sbi = sb->s_fs_info;1378 1379 sync_filesystem(fc->root->d_sb);1380 /* Copy new options from ctx into sbi. */1381 sbi->s_mount_opts = ctx->s_mount_opts;1382 1383 return 0;1384}1385 1386static const struct fs_context_operations zonefs_context_ops = {1387 .parse_param = zonefs_parse_param,1388 .get_tree = zonefs_get_tree,1389 .reconfigure = zonefs_reconfigure,1390 .free = zonefs_free_fc,1391};1392 1393/*1394 * Set up the filesystem mount context.1395 */1396static int zonefs_init_fs_context(struct fs_context *fc)1397{1398 struct zonefs_context *ctx;1399 1400 ctx = kzalloc(sizeof(struct zonefs_context), GFP_KERNEL);1401 if (!ctx)1402 return -ENOMEM;1403 ctx->s_mount_opts = ZONEFS_MNTOPT_ERRORS_RO;1404 fc->ops = &zonefs_context_ops;1405 fc->fs_private = ctx;1406 1407 return 0;1408}1409 1410/*1411 * File system definition and registration.1412 */1413static struct file_system_type zonefs_type = {1414 .owner = THIS_MODULE,1415 .name = "zonefs",1416 .kill_sb = zonefs_kill_super,1417 .fs_flags = FS_REQUIRES_DEV,1418 .init_fs_context = zonefs_init_fs_context,1419 .parameters = zonefs_param_spec,1420};1421 1422static int __init zonefs_init_inodecache(void)1423{1424 zonefs_inode_cachep = kmem_cache_create("zonefs_inode_cache",1425 sizeof(struct zonefs_inode_info), 0,1426 SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT,1427 NULL);1428 if (zonefs_inode_cachep == NULL)1429 return -ENOMEM;1430 return 0;1431}1432 1433static void zonefs_destroy_inodecache(void)1434{1435 /*1436 * Make sure all delayed rcu free inodes are flushed before we1437 * destroy the inode cache.1438 */1439 rcu_barrier();1440 kmem_cache_destroy(zonefs_inode_cachep);1441}1442 1443static int __init zonefs_init(void)1444{1445 int ret;1446 1447 BUILD_BUG_ON(sizeof(struct zonefs_super) != ZONEFS_SUPER_SIZE);1448 1449 ret = zonefs_init_inodecache();1450 if (ret)1451 return ret;1452 1453 ret = zonefs_sysfs_init();1454 if (ret)1455 goto destroy_inodecache;1456 1457 ret = register_filesystem(&zonefs_type);1458 if (ret)1459 goto sysfs_exit;1460 1461 return 0;1462 1463sysfs_exit:1464 zonefs_sysfs_exit();1465destroy_inodecache:1466 zonefs_destroy_inodecache();1467 1468 return ret;1469}1470 1471static void __exit zonefs_exit(void)1472{1473 unregister_filesystem(&zonefs_type);1474 zonefs_sysfs_exit();1475 zonefs_destroy_inodecache();1476}1477 1478MODULE_AUTHOR("Damien Le Moal");1479MODULE_DESCRIPTION("Zone file system for zoned block devices");1480MODULE_LICENSE("GPL");1481MODULE_ALIAS_FS("zonefs");1482module_init(zonefs_init);1483module_exit(zonefs_exit);1484