Hi, Damien, Did you consider creating a shared library? I bet that would also ease application adoption for the use cases you're interested in, and would have similar performance. -Jeff Damien Le Moal <damien.lemoal@xxxxxxx> writes: > zonefs is a very simple file system exposing each zone of a zoned > block device as a file. This is intended to simplify implementation of > application zoned block device raw access support by allowing switching > to the well known POSIX file API rather than relying on direct block > device file ioctls and read/write. Zonefs, for instance, greatly > simplifies the implementation of LSM (log-structured merge) tree > structures (such as used in RocksDB and LevelDB) on zoned block devices > by allowing SSTables to be stored in a zone file similarly to a regular > file system architecture, hence reducing the amount of change needed in > the application. > > Due to its simplicity, zonefs is in fact closer to a raw block device > access interface than to a full feature POSIX file system. This RFC > implementation uses Christoph's work on generic iomap writepage > implementation and is based on Christoph's gfs2 tree available at > http://git.infradead.org/users/hch/misc.git/shortlog/refs/heads/gfs2-iomap > > Zonefs on-disk metadata is reduced to a super block to store a magic > number, a uuid and optional features flags and values. On mount, zonefs > uses blkdev_report_zones() to obtain the device zone configuration and > populates the mount point with a static file tree solely based on this > information. E.g. file sizes come from zone write pointer offset managed > by the device itself. > > The zone files created on mount have the following characteristics. > 1) Files representing zones of the same type are grouped together > under a common directory: > * For conventional zones, the directory "cnv" is used. > * For sequential write zones, the directory "seq" is used. > These two directories are the only directories that exist in zonefs. > Users cannot create other directories and cannot rename nor delete > the "cnv" and "seq" directories. > 2) The name of zone files is by default the number of the file within > the zone type directory, in order of increasing zone start sector. > 3) The size of conventional zone files is fixed to the device zone size. > Conventional zone files cannot be truncated. > 4) The size of sequential zone files represent the file zone write > pointer position relative to the zone start sector. Truncating these > files is allowed only down to 0, in wich case, the zone is reset to > rewind the file zone write pointer position to the start of the zone. > 5) All read and write operations to files are not allowed beyond the > file zone size. Any access exceeding the zone size is failed with > the -EFBIG error. > 6) Creating, deleting, renaming or modifying any attribute of files > and directories is not allowed. The only exception being the file > size of sequential zone files which can be modified by write > operations or truncation to 0. > > Several optional features of zonefs can be enabled at format time. > * Conventional zone aggregation: contiguous conventional zones can be > agregated into a single larger file instead of multiple per-zone > files. > * File naming: the default file number file name can be switched to > using the base-10 value of the file zone start sector. > * File ownership: The owner UID and GID of zone files is by default 0 > (root) but can be changed to any valid UID/GID. > * File access permissions: the default 640 access permissions can be > changed. > > The mkzonefs tool is used to format zonefs. This tool will be available > on Github at: > > https://github.com/westerndigitalcorporation/zonefs-tools > > Example: the following formats a host-managed SMR HDD with the > conventional zone aggregation feature enabled. > > mkzonefs -o aggr_cnv /dev/sdX > mount -t zonefs /dev/sdX /mnt > ls -l /mnt/ > total 0 > dr-xr-xr-x 2 root root 0 Apr 11 13:00 cnv > dr-xr-xr-x 2 root root 0 Apr 11 13:00 seq > > ls -l /mnt/cnv > total 137363456 > -rw-rw---- 1 root root 140660178944 Apr 11 13:00 0 > > ls -Fal -v /mnt/seq > total 14511243264 > dr-xr-xr-x 2 root root 15942528 Jul 10 11:53 ./ > drwxr-xr-x 4 root root 1152 Jul 10 11:53 ../ > -rw-r----- 1 root root 0 Jul 10 11:53 0 > -rw-r----- 1 root root 33554432 Jul 10 13:43 1 > -rw-r----- 1 root root 0 Jul 10 11:53 2 > -rw-r----- 1 root root 0 Jul 10 11:53 3 > ... > > The aggregated conventional zone file can be used as a regular file. > Operations such as the following work. > > mkfs.ext4 /mnt/cnv/0 > mount -o loop /mnt/cnv/0 /data > > Contains contributions from Johannes Thumshirn <jthumshirn@xxxxxxx> > and Christoph Hellwig <hch@xxxxxx>. > > Signed-off-by: Damien Le Moal <damien.lemoal@xxxxxxx> > --- > fs/Kconfig | 2 + > fs/Makefile | 1 + > fs/zonefs/Kconfig | 9 + > fs/zonefs/Makefile | 4 + > fs/zonefs/super.c | 1004 ++++++++++++++++++++++++++++++++++++ > fs/zonefs/zonefs.h | 190 +++++++ > include/uapi/linux/magic.h | 1 + > 7 files changed, 1211 insertions(+) > create mode 100644 fs/zonefs/Kconfig > create mode 100644 fs/zonefs/Makefile > create mode 100644 fs/zonefs/super.c > create mode 100644 fs/zonefs/zonefs.h > > diff --git a/fs/Kconfig b/fs/Kconfig > index f1046cf6ad85..e48cc0e0efbb 100644 > --- a/fs/Kconfig > +++ b/fs/Kconfig > @@ -41,6 +41,7 @@ source "fs/ocfs2/Kconfig" > source "fs/btrfs/Kconfig" > source "fs/nilfs2/Kconfig" > source "fs/f2fs/Kconfig" > +source "fs/zonefs/Kconfig" > > config FS_DAX > bool "Direct Access (DAX) support" > @@ -262,6 +263,7 @@ source "fs/romfs/Kconfig" > source "fs/pstore/Kconfig" > source "fs/sysv/Kconfig" > source "fs/ufs/Kconfig" > +source "fs/ufs/Kconfig" > > endif # MISC_FILESYSTEMS > > diff --git a/fs/Makefile b/fs/Makefile > index c9aea23aba56..02fcd528991b 100644 > --- a/fs/Makefile > +++ b/fs/Makefile > @@ -130,3 +130,4 @@ obj-$(CONFIG_F2FS_FS) += f2fs/ > obj-$(CONFIG_CEPH_FS) += ceph/ > obj-$(CONFIG_PSTORE) += pstore/ > obj-$(CONFIG_EFIVAR_FS) += efivarfs/ > +obj-$(CONFIG_ZONEFS_FS) += zonefs/ > diff --git a/fs/zonefs/Kconfig b/fs/zonefs/Kconfig > new file mode 100644 > index 000000000000..6490547e9763 > --- /dev/null > +++ b/fs/zonefs/Kconfig > @@ -0,0 +1,9 @@ > +config ZONEFS_FS > + tristate "zonefs filesystem support" > + depends on BLOCK > + depends on BLK_DEV_ZONED > + help > + zonefs is a simple File System which exposes zones of a zoned block > + device as files. > + > + If unsure, say N. > diff --git a/fs/zonefs/Makefile b/fs/zonefs/Makefile > new file mode 100644 > index 000000000000..75a380aa1ae1 > --- /dev/null > +++ b/fs/zonefs/Makefile > @@ -0,0 +1,4 @@ > +# SPDX-License-Identifier: GPL-2.0 > +obj-$(CONFIG_ZONEFS_FS) += zonefs.o > + > +zonefs-y := super.o > diff --git a/fs/zonefs/super.c b/fs/zonefs/super.c > new file mode 100644 > index 000000000000..0bf56f378a77 > --- /dev/null > +++ b/fs/zonefs/super.c > @@ -0,0 +1,1004 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Simple zone file system for zoned block devices. > + * > + * Copyright (C) 2019 Western Digital Corporation or its affiliates. > + */ > +#include <linux/module.h> > +#include <linux/fs.h> > +#include <linux/magic.h> > +#include <linux/iomap.h> > +#include <linux/init.h> > +#include <linux/slab.h> > +#include <linux/blkdev.h> > +#include <linux/statfs.h> > +#include <linux/writeback.h> > +#include <linux/quotaops.h> > +#include <linux/seq_file.h> > +#include <linux/parser.h> > +#include <linux/uio.h> > +#include <linux/mman.h> > +#include <linux/sched/mm.h> > + > +#include "zonefs.h" > + > +static int zonefs_iomap_begin(struct inode *inode, loff_t offset, loff_t length, > + unsigned int flags, struct iomap *iomap) > +{ > + struct zonefs_sb_info *sbi = ZONEFS_SB(inode->i_sb); > + loff_t max_isize = zonefs_file_max_size(inode); > + loff_t isize = i_size_read(inode); > + > + /* > + * For sequential zones, enforce direct IO writes. This is already > + * checked when writes are issued, so warn about this here if we > + * get buffered write to a sequential file inode. > + */ > + if (WARN_ON_ONCE(zonefs_file_is_seq(inode) && (flags & IOMAP_WRITE) && > + (!(flags & IOMAP_DIRECT)))) > + return -EIO; > + > + /* An IO cannot exceed the zone size */ > + if (offset >= max_isize) > + return -EFBIG; > + > + /* All blocks are always mapped */ > + if (offset >= i_size_read(inode)) { > + length = min(length, max_isize - offset); > + iomap->type = IOMAP_UNWRITTEN; > + } else { > + length = min(length, isize - offset); > + iomap->type = IOMAP_MAPPED; > + } > + iomap->offset = offset & (~sbi->s_blocksize_mask); > + iomap->length = (offset + length + sbi->s_blocksize_mask) & > + (~sbi->s_blocksize_mask); > + iomap->addr = zonefs_file_addr(inode) + iomap->offset; > + iomap->bdev = inode->i_sb->s_bdev; > + > + return 0; > +} > + > +static const struct iomap_ops zonefs_iomap_ops = { > + .iomap_begin = zonefs_iomap_begin, > +}; > + > +static int zonefs_readpage(struct file *unused, struct page *page) > +{ > + return iomap_readpage(page, &zonefs_iomap_ops); > +} > + > +static int zonefs_readpages(struct file *unused, struct address_space *mapping, > + struct list_head *pages, unsigned int nr_pages) > +{ > + return iomap_readpages(mapping, pages, nr_pages, &zonefs_iomap_ops); > +} > + > +static int zonefs_map_blocks(struct iomap_writepage_ctx *wpc, > + struct inode *inode, loff_t offset) > +{ > + if (offset >= wpc->iomap.offset && > + offset < wpc->iomap.offset + wpc->iomap.length) > + return 0; > + > + memset(&wpc->iomap, 0, sizeof(wpc->iomap)); > + return zonefs_iomap_begin(inode, offset, INT_MAX, 0, &wpc->iomap); > +} > + > +static const struct iomap_writeback_ops zonefs_writeback_ops = { > + .map_blocks = zonefs_map_blocks, > +}; > + > +static int zonefs_writepage(struct page *page, struct writeback_control *wbc) > +{ > + struct iomap_writepage_ctx wpc = { }; > + > + return iomap_writepage(page, wbc, &wpc, &zonefs_writeback_ops); > +} > + > +static int zonefs_writepages(struct address_space *mapping, > + struct writeback_control *wbc) > +{ > + struct iomap_writepage_ctx wpc = { }; > + > + return iomap_writepages(mapping, wbc, &wpc, &zonefs_writeback_ops); > +} > + > +static const struct address_space_operations zonefs_file_aops = { > + .readpage = zonefs_readpage, > + .readpages = zonefs_readpages, > + .writepage = zonefs_writepage, > + .writepages = zonefs_writepages, > + .set_page_dirty = iomap_set_page_dirty, > + .releasepage = iomap_releasepage, > + .invalidatepage = iomap_invalidatepage, > + .migratepage = iomap_migrate_page, > + .is_partially_uptodate = iomap_is_partially_uptodate, > + .error_remove_page = generic_error_remove_page, > + .direct_IO = noop_direct_IO, > +}; > + > +static int zonefs_truncate_seqfile(struct inode *inode) > +{ > + struct zonefs_inode_info *zi = ZONEFS_I(inode); > + int ret; > + > + /* Serialize against page faults */ > + down_write(&zi->i_mmap_sem); > + > + ret = blkdev_reset_zones(inode->i_sb->s_bdev, > + zonefs_file_addr(inode) >> SECTOR_SHIFT, > + zonefs_file_max_size(inode) >> SECTOR_SHIFT, > + GFP_KERNEL); > + if (ret) { > + zonefs_err(inode->i_sb, > + "zonefs: Reset zone at %llu failed %d", > + zonefs_file_addr(inode) >> SECTOR_SHIFT, > + ret); > + } else { > + truncate_setsize(inode, 0); > + zi->i_wpoffset = 0; > + } > + > + up_write(&zi->i_mmap_sem); > + > + return ret; > +} > + > +static int zonefs_inode_setattr(struct dentry *dentry, struct iattr *iattr) > +{ > + struct inode *inode = d_inode(dentry); > + int ret; > + > + ret = setattr_prepare(dentry, iattr); > + if (ret) > + return ret; > + > + if ((iattr->ia_valid & ATTR_UID && > + !uid_eq(iattr->ia_uid, inode->i_uid)) || > + (iattr->ia_valid & ATTR_GID && > + !gid_eq(iattr->ia_gid, inode->i_gid))) { > + ret = dquot_transfer(inode, iattr); > + if (ret) > + return ret; > + } > + > + if (iattr->ia_valid & ATTR_SIZE) { > + /* The size of conventional zone files cannot be changed */ > + if (zonefs_file_is_conv(inode)) > + return -EPERM; > + > + /* > + * For sequential zone files, we can only allow truncating to > + * 0 size which is equivalent to a zone reset. > + */ > + if (iattr->ia_size != 0) > + return -EPERM; > + > + ret = zonefs_truncate_seqfile(inode); > + if (ret) > + return ret; > + } > + > + setattr_copy(inode, iattr); > + > + return 0; > +} > + > +static const struct inode_operations zonefs_file_inode_operations = { > + .setattr = zonefs_inode_setattr, > +}; > + > +/* > + * Open a file. > + */ > +static int zonefs_file_open(struct inode *inode, struct file *file) > +{ > + /* > + * Note: here we can do an explicit open of the file zone, > + * on the first open of the inode. The explicit close can be > + * done on the last release (close) call for the inode. > + */ > + > + return generic_file_open(inode, file); > +} > + > +static int zonefs_file_fsync(struct file *file, loff_t start, loff_t end, > + int datasync) > +{ > + struct inode *inode = file_inode(file); > + int ret; > + > + /* > + * Since only direct writes are allowed in sequential files, we only > + * need a device flush for these files. > + */ > + if (zonefs_file_is_seq(inode)) > + goto flush; > + > + ret = file_write_and_wait_range(file, start, end); > + if (ret == 0) > + ret = file_check_and_advance_wb_err(file); > + if (ret) > + return ret; > + > +flush: > + return blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL); > +} > + > +static vm_fault_t zonefs_filemap_fault(struct vm_fault *vmf) > +{ > + struct zonefs_inode_info *zi = ZONEFS_I(file_inode(vmf->vma->vm_file)); > + vm_fault_t ret; > + > + down_read(&zi->i_mmap_sem); > + ret = filemap_fault(vmf); > + up_read(&zi->i_mmap_sem); > + > + return ret; > +} > + > +static vm_fault_t zonefs_filemap_page_mkwrite(struct vm_fault *vmf) > +{ > + struct inode *inode = file_inode(vmf->vma->vm_file); > + struct zonefs_inode_info *zi = ZONEFS_I(inode); > + vm_fault_t ret; > + > + sb_start_pagefault(inode->i_sb); > + file_update_time(vmf->vma->vm_file); > + > + /* Serialize against truncates */ > + down_read(&zi->i_mmap_sem); > + ret = iomap_page_mkwrite(vmf, &zonefs_iomap_ops); > + up_read(&zi->i_mmap_sem); > + > + sb_end_pagefault(inode->i_sb); > + return ret; > +} > + > +static const struct vm_operations_struct zonefs_file_vm_ops = { > + .fault = zonefs_filemap_fault, > + .map_pages = filemap_map_pages, > + .page_mkwrite = zonefs_filemap_page_mkwrite, > +}; > + > +static int zonefs_file_mmap(struct file *file, struct vm_area_struct *vma) > +{ > + /* > + * Conventional zone files can be mmap-ed READ/WRITE. > + * For sequential zone files, only readonly mappings are possible. > + */ > + if (zonefs_file_is_seq(file_inode(file)) && > + (vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_MAYWRITE)) > + return -EINVAL; > + > + file_accessed(file); > + vma->vm_ops = &zonefs_file_vm_ops; > + > + return 0; > +} > + > +static loff_t zonefs_file_llseek(struct file *file, loff_t offset, int whence) > +{ > + loff_t isize = i_size_read(file_inode(file)); > + > + /* > + * Seeks are limited to below the zone size for conventional zones > + * and below the zone write pointer for sequential zones. In both > + * cases, this limit is the inode size. > + */ > + return generic_file_llseek_size(file, offset, whence, isize, isize); > +} > + > +static ssize_t zonefs_file_read_iter(struct kiocb *iocb, struct iov_iter *to) > +{ > + struct inode *inode = file_inode(iocb->ki_filp); > + struct zonefs_sb_info *sbi = ZONEFS_SB(inode->i_sb); > + loff_t max_pos = zonefs_file_max_size(inode); > + size_t count; > + ssize_t ret = 0; > + > + /* > + * Check that the read operation does not go beyond the maximum > + * file size. > + */ > + if (iocb->ki_pos >= zonefs_file_max_size(inode)) > + return -EFBIG; > + > + /* > + * For sequential zones, limit reads to written data. > + */ > + if (zonefs_file_is_seq(inode)) > + max_pos = i_size_read(inode); > + if (iocb->ki_pos >= max_pos) > + return 0; > + > + iov_iter_truncate(to, max_pos - iocb->ki_pos); > + count = iov_iter_count(to); > + if (!count) > + return 0; > + > + /* Direct IO reads must be aligned to device physical sector size */ > + if ((iocb->ki_flags & IOCB_DIRECT) && > + ((iocb->ki_pos | count) & sbi->s_blocksize_mask)) > + return -EINVAL; > + > + if (iocb->ki_flags & IOCB_NOWAIT) { > + if (!inode_trylock_shared(inode)) > + return -EAGAIN; > + } else { > + inode_lock_shared(inode); > + } > + > + if (iocb->ki_flags & IOCB_DIRECT) { > + file_accessed(iocb->ki_filp); > + ret = iomap_dio_rw(iocb, to, &zonefs_iomap_ops, NULL); > + } else { > + ret = generic_file_read_iter(iocb, to); > + } > + > + inode_unlock_shared(inode); > + > + return ret; > +} > + > +/* > + * We got a write error: get the sequenial zone information from the device to > + * figure out where the zone write pointer is and verify the inode size against > + * it. > + */ > +static int zonefs_write_failed(struct inode *inode, int error) > +{ > + struct super_block *sb = inode->i_sb; > + struct zonefs_inode_info *zi = ZONEFS_I(inode); > + sector_t sector = zi->i_addr >> SECTOR_SHIFT; > + unsigned int noio_flag; > + struct blk_zone zone; > + int n = 1, ret; > + > + zonefs_warn(sb, "Updating inode zone %llu info\n", sector); > + > + noio_flag = memalloc_noio_save(); > + ret = blkdev_report_zones(sb->s_bdev, sector, &zone, &n); > + memalloc_noio_restore(noio_flag); > + > + if (!n) > + ret = -EIO; > + if (ret) { > + zonefs_err(sb, "Get zone %llu report failed %d\n", > + sector, ret); > + return ret; > + } > + > + zi->i_wpoffset = (zone.wp - zone.start) << SECTOR_SHIFT; > + if (i_size_read(inode) != zi->i_wpoffset) { > + i_size_write(inode, zi->i_wpoffset); > + truncate_pagecache(inode, zi->i_wpoffset); > + } > + > + return error; > +} > + > +static int zonefs_update_size(struct inode *inode, loff_t new_pos) > +{ > + struct zonefs_inode_info *zi = ZONEFS_I(inode); > + > + zi->i_wpoffset = new_pos; > + if (new_pos > i_size_read(inode)) > + i_size_write(inode, new_pos); > + return 0; > +} > + > +static int zonefs_dio_seqwrite_end_io(struct kiocb *iocb, ssize_t size, > + unsigned int flags) > +{ > + struct inode *inode = file_inode(iocb->ki_filp); > + int ret; > + > + inode_lock(inode); > + if (size < 0) > + ret = zonefs_write_failed(inode, size); > + else > + ret = zonefs_update_size(inode, iocb->ki_pos + size); > + inode_unlock(inode); > + return ret; > +} > + > +static ssize_t zonefs_file_dio_aio_write(struct kiocb *iocb, > + struct iov_iter *from) > +{ > + struct inode *inode = file_inode(iocb->ki_filp); > + struct zonefs_inode_info *zi = ZONEFS_I(inode); > + size_t count; > + > + /* > + * The size of conventional zone files is fixed to the zone size. > + * So only direct writes to sequential zones need adjusting the > + * inode size on IO completion. > + */ > + if (zonefs_file_is_conv(inode)) > + return iomap_dio_rw(iocb, from, &zonefs_iomap_ops, NULL); > + > + /* Enforce append only sequential writes */ > + count = iov_iter_count(from); > + if (iocb->ki_pos != zi->i_wpoffset) { > + zonefs_err(inode->i_sb, > + "Unaligned write at %llu + %zu (wp %llu)\n", > + iocb->ki_pos, count, zi->i_wpoffset); > + return -EINVAL; > + } > + > + if (is_sync_kiocb(iocb)) { > + /* > + * Don't use the end_io callback for synchronous iocbs, > + * as we'd deadlock on i_rwsem. Instead perform the same > + * actions manually here. > + */ > + count = iomap_dio_rw(iocb, from, &zonefs_iomap_ops, NULL); > + if (count < 0) > + return zonefs_write_failed(inode, count); > + zonefs_update_size(inode, iocb->ki_pos); > + return count; > + } > + > + return iomap_dio_rw(iocb, from, &zonefs_iomap_ops, > + zonefs_dio_seqwrite_end_io); > +} > + > +static ssize_t zonefs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) > +{ > + struct inode *inode = file_inode(iocb->ki_filp); > + struct zonefs_sb_info *sbi = ZONEFS_SB(inode->i_sb); > + size_t count; > + ssize_t ret; > + > + /* > + * Check that the read operation does not go beyond the file > + * zone boundary. > + */ > + if (iocb->ki_pos >= zonefs_file_max_size(inode)) > + return -EFBIG; > + iov_iter_truncate(from, zonefs_file_max_size(inode) - iocb->ki_pos); > + count = iov_iter_count(from); > + > + if (!count) > + return 0; > + > + /* > + * Direct IO writes are mandatory for sequential zones so that write IO > + * order is preserved. The direct writes also must be aligned to > + * device physical sector size. > + */ > + if (iocb->ki_flags & IOCB_DIRECT) { > + if ((iocb->ki_pos | count) & sbi->s_blocksize_mask) > + return -EINVAL; > + } else { > + if (zonefs_file_is_seq(inode)) > + return -EOPNOTSUPP; > + } > + > + if (iocb->ki_flags & IOCB_NOWAIT) { > + if (!inode_trylock(inode)) > + return -EAGAIN; > + } else { > + inode_lock(inode); > + } > + > + ret = generic_write_checks(iocb, from); > + if (ret <= 0) > + goto out; > + > + if (iocb->ki_flags & IOCB_DIRECT) > + ret = zonefs_file_dio_aio_write(iocb, from); > + else > + ret = iomap_file_buffered_write(iocb, from, &zonefs_iomap_ops); > + > +out: > + inode_unlock(inode); > + > + if (ret > 0 && (!(iocb->ki_flags & IOCB_DIRECT))) { > + iocb->ki_pos += ret; > + ret = generic_write_sync(iocb, ret); > + } > + > + return ret; > +} > + > +static const struct file_operations zonefs_file_operations = { > + .open = zonefs_file_open, > + .fsync = zonefs_file_fsync, > + .mmap = zonefs_file_mmap, > + .llseek = zonefs_file_llseek, > + .read_iter = zonefs_file_read_iter, > + .write_iter = zonefs_file_write_iter, > + .splice_read = generic_file_splice_read, > + .splice_write = iter_file_splice_write, > + .iopoll = iomap_dio_iopoll, > +}; > + > + > +static struct kmem_cache *zonefs_inode_cachep; > + > +static struct inode *zonefs_alloc_inode(struct super_block *sb) > +{ > + struct zonefs_inode_info *zi; > + > + zi = kmem_cache_alloc(zonefs_inode_cachep, GFP_KERNEL); > + if (!zi) > + return NULL; > + > + init_rwsem(&zi->i_mmap_sem); > + inode_init_once(&zi->i_vnode); > + > + return &zi->i_vnode; > +} > + > +static void zonefs_destroy_cb(struct rcu_head *head) > +{ > + struct inode *inode = container_of(head, struct inode, i_rcu); > + > + kmem_cache_free(zonefs_inode_cachep, ZONEFS_I(inode)); > +} > + > +static void zonefs_destroy_inode(struct inode *inode) > +{ > + call_rcu(&inode->i_rcu, zonefs_destroy_cb); > +} > + > +static struct dentry *zonefs_create_inode(struct dentry *parent, > + const char *name, > + struct blk_zone *zone) > +{ > + struct zonefs_sb_info *sbi = ZONEFS_SB(parent->d_sb); > + struct inode *dir = d_inode(parent); > + struct dentry *dentry; > + struct inode *inode; > + > + dentry = d_alloc_name(parent, name); > + if (!dentry) > + return NULL; > + > + inode = new_inode(parent->d_sb); > + if (!inode) > + goto out_dput; > + > + inode->i_ino = get_next_ino(); > + if (zone) { > + struct zonefs_inode_info *zi = ZONEFS_I(inode); > + > + /* Zone file */ > + inode->i_mode = S_IFREG | sbi->s_perm; > + if (zonefs_zone_readonly(zone)) > + inode->i_mode &= ~S_IWUGO; > + inode->i_uid = sbi->s_uid; > + inode->i_gid = sbi->s_gid; > + zi->i_ztype = zonefs_zone_type(zone); > + zi->i_addr = zone->start << SECTOR_SHIFT; > + zi->i_max_size = zone->len << SECTOR_SHIFT; > + inode->i_blocks = zone->len; > + if (zonefs_file_is_conv(inode)) > + zi->i_wpoffset = zi->i_max_size; > + else > + zi->i_wpoffset = > + (zone->wp - zone->start) << SECTOR_SHIFT; > + inode->i_size = zi->i_wpoffset; > + inode->i_fop = &zonefs_file_operations; > + inode->i_op = &zonefs_file_inode_operations; > + inode->i_mapping->a_ops = &zonefs_file_aops; > + inode->i_mapping->a_ops = &zonefs_file_aops; > + } else { > + /* Zone group directory */ > + inode_init_owner(inode, dir, S_IFDIR | 0555); > + inode->i_fop = &simple_dir_operations; > + inode->i_op = &simple_dir_inode_operations; > + set_nlink(inode, 2); > + inc_nlink(dir); > + } > + inode->i_ctime = inode->i_mtime = inode->i_atime = dir->i_ctime; > + > + d_add(dentry, inode); > + d_inode(parent)->i_size += sizeof(struct dentry); > + > + return dentry; > + > +out_dput: > + dput(dentry); > + return NULL; > +} > + > +/* > + * File system stat. > + */ > +static int zonefs_statfs(struct dentry *dentry, struct kstatfs *buf) > +{ > + struct super_block *sb = dentry->d_sb; > + struct zonefs_sb_info *sbi = ZONEFS_SB(sb); > + sector_t nr_sectors = sb->s_bdev->bd_part->nr_sects; > + enum zonefs_ztype t; > + > + buf->f_type = ZONEFS_MAGIC; > + buf->f_bsize = dentry->d_sb->s_blocksize; > + buf->f_namelen = ZONEFS_NAME_MAX; > + > + buf->f_blocks = nr_sectors >> (sb->s_blocksize_bits - SECTOR_SHIFT); > + buf->f_bfree = 0; > + buf->f_bavail = 0; > + > + buf->f_files = sbi->s_nr_zones[ZONEFS_ZTYPE_ALL] - 1; > + for (t = ZONEFS_ZTYPE_ALL; t < ZONEFS_ZTYPE_MAX; t++) { > + if (sbi->s_nr_zones[t]) > + buf->f_files++; > + } > + buf->f_ffree = 0; > + > + /* buf->f_fsid = 0; uuid, see ext2 */ > + buf->f_namelen = ZONEFS_NAME_MAX; > + > + return 0; > +} > + > +static const struct super_operations zonefs_sops = { > + .alloc_inode = zonefs_alloc_inode, > + .destroy_inode = zonefs_destroy_inode, > + .statfs = zonefs_statfs, > +}; > + > +static char *zgroups_name[ZONEFS_ZTYPE_MAX] = { > + NULL, > + "cnv", > + "seq" > +}; > + > +/* > + * Create a zone group and populate it with zone files. > + */ > +static int zonefs_create_zgroup(struct super_block *sb, struct blk_zone *zones, > + enum zonefs_ztype type) > +{ > + struct zonefs_sb_info *sbi = ZONEFS_SB(sb); > + struct blk_zone *zone, *next, *end; > + char name[ZONEFS_NAME_MAX]; > + unsigned int nr_files = 0; > + struct dentry *dir; > + > + /* If the group is empty, nothing to do */ > + if (!sbi->s_nr_zones[type]) > + return 0; > + > + dir = zonefs_create_inode(sb->s_root, zgroups_name[type], NULL); > + if (!dir) > + return -ENOMEM; > + > + /* > + * Note: The first zone contains the super block: skip it. > + */ > + end = zones + sbi->s_nr_zones[ZONEFS_ZTYPE_ALL]; > + for (zone = &zones[1]; zone < end; zone = next) { > + > + next = zone + 1; > + if (zonefs_zone_type(zone) != type) > + continue; > + > + /* Ignore offline zones */ > + if (zonefs_zone_offline(zone)) > + continue; > + > + /* > + * For conventional zones, contiguous zones can be aggregated > + * together to form larger files. > + * Note that this overwrites the length of the first zone of > + * the set of contiguous zones aggregated together. > + * Only zones with the same condition can be agreggated so that > + * offline zones are excluded and readonly zones are aggregated > + * together into a read only file. > + */ > + if (type == ZONEFS_ZTYPE_CNV && > + zonefs_has_feature(sbi, ZONEFS_F_AGRCNV)) { > + for (; next < end; next++) { > + if (zonefs_zone_type(next) != type || > + next->cond != zone->cond) > + break; > + zone->len += next->len; > + } > + } > + > + if (zonefs_has_feature(sbi, ZONEFS_F_STARTSECT_NAME)) > + /* Use zone start sector as file names */ > + snprintf(name, ZONEFS_NAME_MAX - 1, "%llu", > + zone->start); > + else > + /* Use file number as file names */ > + snprintf(name, ZONEFS_NAME_MAX - 1, "%u", nr_files); > + nr_files++; > + > + if (!zonefs_create_inode(dir, name, zone)) > + return -ENOMEM; > + } > + > + zonefs_info(sb, "Zone group %d (%s), %u zones -> %u file%s\n", > + type, zgroups_name[type], sbi->s_nr_zones[type], > + nr_files, nr_files > 1 ? "s" : ""); > + > + return 0; > +} > + > +static struct blk_zone *zonefs_get_zone_info(struct super_block *sb) > +{ > + struct zonefs_sb_info *sbi = ZONEFS_SB(sb); > + struct block_device *bdev = sb->s_bdev; > + sector_t nr_sectors = bdev->bd_part->nr_sects; > + unsigned int i, n, nr_zones = 0; > + struct blk_zone *zones, *zone; > + sector_t sector = 0; > + int ret; > + > + sbi->s_blocksize_mask = sb->s_blocksize - 1; > + sbi->s_nr_zones[ZONEFS_ZTYPE_ALL] = blkdev_nr_zones(bdev); > + zones = kvcalloc(sbi->s_nr_zones[ZONEFS_ZTYPE_ALL], > + sizeof(struct blk_zone), GFP_KERNEL); > + if (!zones) > + return ERR_PTR(-ENOMEM); > + > + /* Get zones information */ > + zone = zones; > + while (nr_zones < sbi->s_nr_zones[ZONEFS_ZTYPE_ALL] && > + sector < nr_sectors) { > + > + n = sbi->s_nr_zones[ZONEFS_ZTYPE_ALL] - nr_zones; > + ret = blkdev_report_zones(bdev, sector, zone, &n); > + if (ret) { > + zonefs_err(sb, "Zone report failed %d\n", ret); > + goto err; > + } > + if (!n) { > + zonefs_err(sb, "No zones reported\n"); > + ret = -EIO; > + goto err; > + } > + > + for (i = 0; i < n; i++) { > + switch (zone->type) { > + case BLK_ZONE_TYPE_CONVENTIONAL: > + zone->wp = zone->start + zone->len; > + if (zone > zones) > + sbi->s_nr_zones[ZONEFS_ZTYPE_CNV]++; > + break; > + case BLK_ZONE_TYPE_SEQWRITE_REQ: > + case BLK_ZONE_TYPE_SEQWRITE_PREF: > + if (zone > zones) > + sbi->s_nr_zones[ZONEFS_ZTYPE_SEQ]++; > + break; > + default: > + zonefs_err(sb, "Unsupported zone type 0x%x\n", > + zone->type); > + ret = -EIO; > + goto err; > + } > + sector += zone->len; > + zone++; > + } > + > + nr_zones += n; > + } > + > + if (sector < nr_sectors || > + nr_zones < sbi->s_nr_zones[ZONEFS_ZTYPE_ALL]) { > + zonefs_err(sb, "Incomplete zone report\n"); > + ret = -EIO; > + goto err; > + } > + > + return zones; > + > +err: > + kvfree(zones); > + return ERR_PTR(ret); > +} > + > +/* > + * Read super block information from the device. > + */ > +static int zonefs_read_super(struct super_block *sb) > +{ > + struct zonefs_sb_info *sbi = ZONEFS_SB(sb); > + struct zonefs_super *super; > + struct bio bio; > + struct bio_vec bio_vec; > + struct page *page; > + int ret; > + > + page = alloc_page(GFP_KERNEL); > + if (!page) > + return -ENOMEM; > + > + bio_init(&bio, &bio_vec, 1); > + bio.bi_iter.bi_sector = 0; > + bio_set_dev(&bio, sb->s_bdev); > + bio_set_op_attrs(&bio, REQ_OP_READ, 0); > + bio_add_page(&bio, page, PAGE_SIZE, 0); > + > + ret = submit_bio_wait(&bio); > + if (ret) > + goto out; > + > + ret = -EINVAL; > + super = page_address(page); > + if (le32_to_cpu(super->s_magic) != ZONEFS_MAGIC) > + goto out; > + if (le32_to_cpu(super->s_version) != ZONEFS_VERSION) > + goto out; > + sbi->s_features = le64_to_cpu(super->s_features); > + if (zonefs_has_feature(sbi, ZONEFS_F_UID)) { > + sbi->s_uid = make_kuid(current_user_ns(), > + le32_to_cpu(super->s_uid)); > + if (!uid_valid(sbi->s_uid)) > + goto out; > + } > + if (zonefs_has_feature(sbi, ZONEFS_F_GID)) { > + sbi->s_gid = make_kgid(current_user_ns(), > + le32_to_cpu(super->s_gid)); > + if (!gid_valid(sbi->s_gid)) > + goto out; > + } > + if (zonefs_has_feature(sbi, ZONEFS_F_PERM)) > + sbi->s_perm = le32_to_cpu(super->s_perm); > + > + ret = 0; > + > +out: > + __free_page(page); > + > + return ret; > +} > + > +/* > + * Check that the device is zoned. If it is, get the list of zones and create > + * sub-directories and files according to the device zone configuration. > + */ > +static int zonefs_fill_super(struct super_block *sb, void *data, int silent) > +{ > + struct zonefs_sb_info *sbi; > + struct blk_zone *zones; > + struct inode *inode; > + enum zonefs_ztype t; > + int ret; > + > + /* Check device type */ > + if (!bdev_is_zoned(sb->s_bdev)) { > + zonefs_err(sb, "Not a zoned block device\n"); > + return -EINVAL; > + } > + > + /* Initialize super block information */ > + sbi = kzalloc(sizeof(*sbi), GFP_KERNEL); > + if (!sbi) > + return -ENOMEM; > + > + sb->s_fs_info = sbi; > + sb->s_magic = ZONEFS_MAGIC; > + sb->s_maxbytes = MAX_LFS_FILESIZE; > + sb_set_blocksize(sb, bdev_physical_block_size(sb->s_bdev)); > + sb->s_op = &zonefs_sops; > + sb->s_time_gran = 1; > + > + /* Set defaults */ > + sbi->s_uid = GLOBAL_ROOT_UID; > + sbi->s_gid = GLOBAL_ROOT_GID; > + sbi->s_perm = S_IRUSR | S_IWUSR | S_IRGRP; /* 0640 */ > + > + ret = zonefs_read_super(sb); > + if (ret) > + return ret; > + > + zones = zonefs_get_zone_info(sb); > + if (IS_ERR(zones)) > + return PTR_ERR(zones); > + > + pr_info("zonefs: Mounting %s, %u zones", > + sb->s_id, sbi->s_nr_zones[ZONEFS_ZTYPE_ALL]); > + > + /* Create root directory inode */ > + ret = -ENOMEM; > + inode = new_inode(sb); > + if (!inode) > + goto out; > + inode->i_ino = get_next_ino(); > + inode->i_mode = S_IFDIR | 0755; > + inode->i_ctime = inode->i_mtime = inode->i_atime = current_time(inode); > + inode->i_op = &simple_dir_inode_operations; > + inode->i_fop = &simple_dir_operations; > + inode->i_size = sizeof(struct dentry) * 2; > + set_nlink(inode, 2); > + sb->s_root = d_make_root(inode); > + if (!sb->s_root) > + goto out; > + > + /* Create and populate zone groups */ > + for (t = ZONEFS_ZTYPE_CNV; t < ZONEFS_ZTYPE_MAX; t++) { > + ret = zonefs_create_zgroup(sb, zones, t); > + if (ret) > + break; > + } > + > +out: > + kvfree(zones); > + > + return ret; > +} > + > +static struct dentry *zonefs_mount(struct file_system_type *fs_type, > + int flags, const char *dev_name, void *data) > +{ > + return mount_bdev(fs_type, flags, dev_name, data, zonefs_fill_super); > +} > + > +static void zonefs_kill_super(struct super_block *sb) > +{ > + struct zonefs_sb_info *sbi = ZONEFS_SB(sb); > + > + kfree(sbi); > + if (sb->s_root) > + d_genocide(sb->s_root); > + kill_block_super(sb); > +} > + > +/* > + * File system definition and registration. > + */ > +static struct file_system_type zonefs_type = { > + .owner = THIS_MODULE, > + .name = "zonefs", > + .mount = zonefs_mount, > + .kill_sb = zonefs_kill_super, > + .fs_flags = FS_REQUIRES_DEV, > +}; > + > +static int __init zonefs_init_inodecache(void) > +{ > + zonefs_inode_cachep = kmem_cache_create("zonefs_inode_cache", > + sizeof(struct zonefs_inode_info), 0, > + (SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD | SLAB_ACCOUNT), > + NULL); > + if (zonefs_inode_cachep == NULL) > + return -ENOMEM; > + return 0; > +} > + > +static void zonefs_destroy_inodecache(void) > +{ > + /* > + * Make sure all delayed rcu free inodes are flushed before we > + * destroy the inode cache. > + */ > + rcu_barrier(); > + kmem_cache_destroy(zonefs_inode_cachep); > +} > + > +static int __init zonefs_init(void) > +{ > + int ret; > + > + ret = zonefs_init_inodecache(); > + if (ret) > + return ret; > + > + ret = register_filesystem(&zonefs_type); > + if (ret) { > + zonefs_destroy_inodecache(); > + return ret; > + } > + > + return 0; > +} > + > +static void __exit zonefs_exit(void) > +{ > + zonefs_destroy_inodecache(); > + unregister_filesystem(&zonefs_type); > +} > + > +MODULE_AUTHOR("Damien Le Moal"); > +MODULE_DESCRIPTION("Zone file system for zoned block devices"); > +MODULE_LICENSE("GPL"); > +module_init(zonefs_init); > +module_exit(zonefs_exit); > diff --git a/fs/zonefs/zonefs.h b/fs/zonefs/zonefs.h > new file mode 100644 > index 000000000000..91a9081c0d77 > --- /dev/null > +++ b/fs/zonefs/zonefs.h > @@ -0,0 +1,190 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Simple zone file system for zoned block devices. > + * > + * Copyright (C) 2019 Western Digital Corporation or its affiliates. > + */ > +#ifndef __ZONEFS_H__ > +#define __ZONEFS_H__ > + > +#include <linux/fs.h> > +#include <linux/magic.h> > + > +/* > + * Maximum length of file names: this only needs to be large enough to fit > + * the zone group directory names and a decimal value of the start sector of > + * the zones for file names. 16 characterse is plenty. > + */ > +#define ZONEFS_NAME_MAX 16 > + > +/* > + * Zone types: ZONEFS_ZTYPE_SEQWRITE is used for all sequential zone types > + * defined in linux/blkzoned.h, that is, BLK_ZONE_TYPE_SEQWRITE_REQ and > + * BLK_ZONE_TYPE_SEQWRITE_PREF. > + */ > +enum zonefs_ztype { > + ZONEFS_ZTYPE_ALL = 0, > + ZONEFS_ZTYPE_CNV, > + ZONEFS_ZTYPE_SEQ, > + ZONEFS_ZTYPE_MAX, > +}; > + > +static inline enum zonefs_ztype zonefs_zone_type(struct blk_zone *zone) > +{ > + if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL) > + return ZONEFS_ZTYPE_CNV; > + return ZONEFS_ZTYPE_SEQ; > +} > + > +static inline bool zonefs_zone_offline(struct blk_zone *zone) > +{ > + return zone->cond == BLK_ZONE_COND_OFFLINE; > +} > + > +static inline bool zonefs_zone_readonly(struct blk_zone *zone) > +{ > + return zone->cond == BLK_ZONE_COND_READONLY; > +} > + > +/* > + * Inode private data. > + */ > +struct zonefs_inode_info { > + struct inode i_vnode; > + enum zonefs_ztype i_ztype; > + loff_t i_addr; > + loff_t i_wpoffset; > + loff_t i_max_size; > + struct rw_semaphore i_mmap_sem; > +}; > + > +static inline struct zonefs_inode_info *ZONEFS_I(struct inode *inode) > +{ > + return container_of(inode, struct zonefs_inode_info, i_vnode); > +} > + > +static inline bool zonefs_file_is_conv(struct inode *inode) > +{ > + return ZONEFS_I(inode)->i_ztype == ZONEFS_ZTYPE_CNV; > +} > + > +static inline bool zonefs_file_is_seq(struct inode *inode) > +{ > + return ZONEFS_I(inode)->i_ztype == ZONEFS_ZTYPE_SEQ; > +} > + > +/* > + * Address (byte offset) on disk of a file zone. > + */ > +static inline loff_t zonefs_file_addr(struct inode *inode) > +{ > + return ZONEFS_I(inode)->i_addr; > +} > + > +/* > + * Maximum possible size of a file (i.e. the zone size). > + */ > +static inline loff_t zonefs_file_max_size(struct inode *inode) > +{ > + return ZONEFS_I(inode)->i_max_size; > +} > + > +/* > + * On-disk super block (block 0). > + */ > +struct zonefs_super { > + > + /* Magic number */ > + __le32 s_magic; /* 4 */ > + > + /* Metadata version number */ > + __le32 s_version; /* 8 */ > + > + /* Features */ > + __le64 s_features; /* 16 */ > + > + /* 128-bit uuid */ > + __u8 s_uuid[16]; /* 32 */ > + > + /* UID/GID to use for files */ > + __le32 s_uid; /* 36 */ > + __le32 s_gid; /* 40 */ > + > + /* File permissions */ > + __le32 s_perm; /* 44 */ > + > + /* Padding to 4K */ > + __u8 s_reserved[4052]; /* 4096 */ > + > +} __attribute__ ((packed)); > + > +/* > + * Metadata version. > + */ > +#define ZONEFS_VERSION 1 > + > +/* > + * Feature flags. > + */ > +enum zonefs_features { > + /* > + * Use a zone start sector value as file name. > + */ > + ZONEFS_F_STARTSECT_NAME, > + /* > + * Aggregate contiguous conventional zones into a single file. > + */ > + ZONEFS_F_AGRCNV, > + /* > + * Use super block specified UID for files instead of default. > + */ > + ZONEFS_F_UID, > + /* > + * Use super block specified GID for files instead of default. > + */ > + ZONEFS_F_GID, > + /* > + * Use super block specified file permissions instead of default 640. > + */ > + ZONEFS_F_PERM, > +}; > + > +/* > + * In-memory Super block information. > + */ > +struct zonefs_sb_info { > + /* > + * Mount options. > + */ > + unsigned long s_mnt_opt; > + unsigned long long s_features; > + kuid_t s_uid; /* File owner UID */ > + kgid_t s_gid; /* File owner GID */ > + umode_t s_perm; /* File permissions */ > + > + /* > + * Device information. > + */ > + loff_t s_blocksize_mask; > + unsigned int s_nr_zones[ZONEFS_ZTYPE_MAX]; > +}; > + > +static inline struct zonefs_sb_info *ZONEFS_SB(struct super_block *sb) > +{ > + return sb->s_fs_info; > +} > + > +static inline bool zonefs_has_feature(struct zonefs_sb_info *sbi, > + enum zonefs_features f) > +{ > + return sbi->s_features & (1ULL << f); > +} > + > +#define zonefs_info(sb, format, args...) \ > + pr_info("zonefs (%s): " format, sb->s_id, ## args) > +#define zonefs_err(sb, format, args...) \ > + pr_err("zonefs (%s) ERROR: " format, sb->s_id, ## args) > +#define zonefs_warn(sb, format, args...) \ > + pr_warn("zonefs (%s) WARN: " format, sb->s_id, ## args) > + > +#endif > diff --git a/include/uapi/linux/magic.h b/include/uapi/linux/magic.h > index f8c00045d537..57b627429f41 100644 > --- a/include/uapi/linux/magic.h > +++ b/include/uapi/linux/magic.h > @@ -86,6 +86,7 @@ > #define NSFS_MAGIC 0x6e736673 > #define BPF_FS_MAGIC 0xcafe4a11 > #define AAFS_MAGIC 0x5a3c69f0 > +#define ZONEFS_MAGIC 0x5a4f4653 > > /* Since UDF 2.01 is ISO 13346 based... */ > #define UDF_SUPER_MAGIC 0x15013346
