1 // SPDX-License-Identifier: GPL-2.0
3 * Simple file system for zoned block devices exposing zones as files.
5 * Copyright (C) 2019 Western Digital Corporation or its affiliates.
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/parser.h>
19 #include <linux/uio.h>
20 #include <linux/mman.h>
21 #include <linux/sched/mm.h>
22 #include <linux/crc32.h>
23 #include <linux/task_io_accounting_ops.h>
27 #define CREATE_TRACE_POINTS
30 static inline int zonefs_zone_mgmt(struct inode
*inode
,
33 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
36 lockdep_assert_held(&zi
->i_truncate_mutex
);
38 trace_zonefs_zone_mgmt(inode
, op
);
39 ret
= blkdev_zone_mgmt(inode
->i_sb
->s_bdev
, op
, zi
->i_zsector
,
40 zi
->i_zone_size
>> SECTOR_SHIFT
, GFP_NOFS
);
42 zonefs_err(inode
->i_sb
,
43 "Zone management operation %s at %llu failed %d\n",
44 blk_op_str(op
), zi
->i_zsector
, ret
);
51 static inline void zonefs_i_size_write(struct inode
*inode
, loff_t isize
)
53 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
55 i_size_write(inode
, isize
);
57 * A full zone is no longer open/active and does not need
60 if (isize
>= zi
->i_max_size
)
61 zi
->i_flags
&= ~ZONEFS_ZONE_OPEN
;
64 static int zonefs_iomap_begin(struct inode
*inode
, loff_t offset
, loff_t length
,
65 unsigned int flags
, struct iomap
*iomap
,
68 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
69 struct super_block
*sb
= inode
->i_sb
;
72 /* All I/Os should always be within the file maximum size */
73 if (WARN_ON_ONCE(offset
+ length
> zi
->i_max_size
))
77 * Sequential zones can only accept direct writes. This is already
78 * checked when writes are issued, so warn if we see a page writeback
81 if (WARN_ON_ONCE(zi
->i_ztype
== ZONEFS_ZTYPE_SEQ
&&
82 (flags
& IOMAP_WRITE
) && !(flags
& IOMAP_DIRECT
)))
86 * For conventional zones, all blocks are always mapped. For sequential
87 * zones, all blocks after always mapped below the inode size (zone
88 * write pointer) and unwriten beyond.
90 mutex_lock(&zi
->i_truncate_mutex
);
91 isize
= i_size_read(inode
);
93 iomap
->type
= IOMAP_UNWRITTEN
;
95 iomap
->type
= IOMAP_MAPPED
;
96 if (flags
& IOMAP_WRITE
)
97 length
= zi
->i_max_size
- offset
;
99 length
= min(length
, isize
- offset
);
100 mutex_unlock(&zi
->i_truncate_mutex
);
102 iomap
->offset
= ALIGN_DOWN(offset
, sb
->s_blocksize
);
103 iomap
->length
= ALIGN(offset
+ length
, sb
->s_blocksize
) - iomap
->offset
;
104 iomap
->bdev
= inode
->i_sb
->s_bdev
;
105 iomap
->addr
= (zi
->i_zsector
<< SECTOR_SHIFT
) + iomap
->offset
;
107 trace_zonefs_iomap_begin(inode
, iomap
);
112 static const struct iomap_ops zonefs_iomap_ops
= {
113 .iomap_begin
= zonefs_iomap_begin
,
116 static int zonefs_readpage(struct file
*unused
, struct page
*page
)
118 return iomap_readpage(page
, &zonefs_iomap_ops
);
121 static void zonefs_readahead(struct readahead_control
*rac
)
123 iomap_readahead(rac
, &zonefs_iomap_ops
);
127 * Map blocks for page writeback. This is used only on conventional zone files,
128 * which implies that the page range can only be within the fixed inode size.
130 static int zonefs_map_blocks(struct iomap_writepage_ctx
*wpc
,
131 struct inode
*inode
, loff_t offset
)
133 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
135 if (WARN_ON_ONCE(zi
->i_ztype
!= ZONEFS_ZTYPE_CNV
))
137 if (WARN_ON_ONCE(offset
>= i_size_read(inode
)))
140 /* If the mapping is already OK, nothing needs to be done */
141 if (offset
>= wpc
->iomap
.offset
&&
142 offset
< wpc
->iomap
.offset
+ wpc
->iomap
.length
)
145 return zonefs_iomap_begin(inode
, offset
, zi
->i_max_size
- offset
,
146 IOMAP_WRITE
, &wpc
->iomap
, NULL
);
149 static const struct iomap_writeback_ops zonefs_writeback_ops
= {
150 .map_blocks
= zonefs_map_blocks
,
153 static int zonefs_writepage(struct page
*page
, struct writeback_control
*wbc
)
155 struct iomap_writepage_ctx wpc
= { };
157 return iomap_writepage(page
, wbc
, &wpc
, &zonefs_writeback_ops
);
160 static int zonefs_writepages(struct address_space
*mapping
,
161 struct writeback_control
*wbc
)
163 struct iomap_writepage_ctx wpc
= { };
165 return iomap_writepages(mapping
, wbc
, &wpc
, &zonefs_writeback_ops
);
168 static int zonefs_swap_activate(struct swap_info_struct
*sis
,
169 struct file
*swap_file
, sector_t
*span
)
171 struct inode
*inode
= file_inode(swap_file
);
172 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
174 if (zi
->i_ztype
!= ZONEFS_ZTYPE_CNV
) {
175 zonefs_err(inode
->i_sb
,
176 "swap file: not a conventional zone file\n");
180 return iomap_swapfile_activate(sis
, swap_file
, span
, &zonefs_iomap_ops
);
183 static const struct address_space_operations zonefs_file_aops
= {
184 .readpage
= zonefs_readpage
,
185 .readahead
= zonefs_readahead
,
186 .writepage
= zonefs_writepage
,
187 .writepages
= zonefs_writepages
,
188 .set_page_dirty
= __set_page_dirty_nobuffers
,
189 .releasepage
= iomap_releasepage
,
190 .invalidatepage
= iomap_invalidatepage
,
191 .migratepage
= iomap_migrate_page
,
192 .is_partially_uptodate
= iomap_is_partially_uptodate
,
193 .error_remove_page
= generic_error_remove_page
,
194 .direct_IO
= noop_direct_IO
,
195 .swap_activate
= zonefs_swap_activate
,
198 static void zonefs_update_stats(struct inode
*inode
, loff_t new_isize
)
200 struct super_block
*sb
= inode
->i_sb
;
201 struct zonefs_sb_info
*sbi
= ZONEFS_SB(sb
);
202 loff_t old_isize
= i_size_read(inode
);
205 if (new_isize
== old_isize
)
208 spin_lock(&sbi
->s_lock
);
211 * This may be called for an update after an IO error.
212 * So beware of the values seen.
214 if (new_isize
< old_isize
) {
215 nr_blocks
= (old_isize
- new_isize
) >> sb
->s_blocksize_bits
;
216 if (sbi
->s_used_blocks
> nr_blocks
)
217 sbi
->s_used_blocks
-= nr_blocks
;
219 sbi
->s_used_blocks
= 0;
221 sbi
->s_used_blocks
+=
222 (new_isize
- old_isize
) >> sb
->s_blocksize_bits
;
223 if (sbi
->s_used_blocks
> sbi
->s_blocks
)
224 sbi
->s_used_blocks
= sbi
->s_blocks
;
227 spin_unlock(&sbi
->s_lock
);
231 * Check a zone condition and adjust its file inode access permissions for
232 * offline and readonly zones. Return the inode size corresponding to the
233 * amount of readable data in the zone.
235 static loff_t
zonefs_check_zone_condition(struct inode
*inode
,
236 struct blk_zone
*zone
, bool warn
,
239 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
241 switch (zone
->cond
) {
242 case BLK_ZONE_COND_OFFLINE
:
244 * Dead zone: make the inode immutable, disable all accesses
245 * and set the file size to 0 (zone wp set to zone start).
248 zonefs_warn(inode
->i_sb
, "inode %lu: offline zone\n",
250 inode
->i_flags
|= S_IMMUTABLE
;
251 inode
->i_mode
&= ~0777;
252 zone
->wp
= zone
->start
;
254 case BLK_ZONE_COND_READONLY
:
256 * The write pointer of read-only zones is invalid. If such a
257 * zone is found during mount, the file size cannot be retrieved
258 * so we treat the zone as offline (mount == true case).
259 * Otherwise, keep the file size as it was when last updated
260 * so that the user can recover data. In both cases, writes are
261 * always disabled for the zone.
264 zonefs_warn(inode
->i_sb
, "inode %lu: read-only zone\n",
266 inode
->i_flags
|= S_IMMUTABLE
;
268 zone
->cond
= BLK_ZONE_COND_OFFLINE
;
269 inode
->i_mode
&= ~0777;
270 zone
->wp
= zone
->start
;
273 inode
->i_mode
&= ~0222;
274 return i_size_read(inode
);
275 case BLK_ZONE_COND_FULL
:
276 /* The write pointer of full zones is invalid. */
277 return zi
->i_max_size
;
279 if (zi
->i_ztype
== ZONEFS_ZTYPE_CNV
)
280 return zi
->i_max_size
;
281 return (zone
->wp
- zone
->start
) << SECTOR_SHIFT
;
285 struct zonefs_ioerr_data
{
290 static int zonefs_io_error_cb(struct blk_zone
*zone
, unsigned int idx
,
293 struct zonefs_ioerr_data
*err
= data
;
294 struct inode
*inode
= err
->inode
;
295 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
296 struct super_block
*sb
= inode
->i_sb
;
297 struct zonefs_sb_info
*sbi
= ZONEFS_SB(sb
);
298 loff_t isize
, data_size
;
301 * Check the zone condition: if the zone is not "bad" (offline or
302 * read-only), read errors are simply signaled to the IO issuer as long
303 * as there is no inconsistency between the inode size and the amount of
304 * data writen in the zone (data_size).
306 data_size
= zonefs_check_zone_condition(inode
, zone
, true, false);
307 isize
= i_size_read(inode
);
308 if (zone
->cond
!= BLK_ZONE_COND_OFFLINE
&&
309 zone
->cond
!= BLK_ZONE_COND_READONLY
&&
310 !err
->write
&& isize
== data_size
)
314 * At this point, we detected either a bad zone or an inconsistency
315 * between the inode size and the amount of data written in the zone.
316 * For the latter case, the cause may be a write IO error or an external
317 * action on the device. Two error patterns exist:
318 * 1) The inode size is lower than the amount of data in the zone:
319 * a write operation partially failed and data was writen at the end
320 * of the file. This can happen in the case of a large direct IO
321 * needing several BIOs and/or write requests to be processed.
322 * 2) The inode size is larger than the amount of data in the zone:
323 * this can happen with a deferred write error with the use of the
324 * device side write cache after getting successful write IO
325 * completions. Other possibilities are (a) an external corruption,
326 * e.g. an application reset the zone directly, or (b) the device
327 * has a serious problem (e.g. firmware bug).
329 * In all cases, warn about inode size inconsistency and handle the
330 * IO error according to the zone condition and to the mount options.
332 if (zi
->i_ztype
== ZONEFS_ZTYPE_SEQ
&& isize
!= data_size
)
333 zonefs_warn(sb
, "inode %lu: invalid size %lld (should be %lld)\n",
334 inode
->i_ino
, isize
, data_size
);
337 * First handle bad zones signaled by hardware. The mount options
338 * errors=zone-ro and errors=zone-offline result in changing the
339 * zone condition to read-only and offline respectively, as if the
340 * condition was signaled by the hardware.
342 if (zone
->cond
== BLK_ZONE_COND_OFFLINE
||
343 sbi
->s_mount_opts
& ZONEFS_MNTOPT_ERRORS_ZOL
) {
344 zonefs_warn(sb
, "inode %lu: read/write access disabled\n",
346 if (zone
->cond
!= BLK_ZONE_COND_OFFLINE
) {
347 zone
->cond
= BLK_ZONE_COND_OFFLINE
;
348 data_size
= zonefs_check_zone_condition(inode
, zone
,
351 } else if (zone
->cond
== BLK_ZONE_COND_READONLY
||
352 sbi
->s_mount_opts
& ZONEFS_MNTOPT_ERRORS_ZRO
) {
353 zonefs_warn(sb
, "inode %lu: write access disabled\n",
355 if (zone
->cond
!= BLK_ZONE_COND_READONLY
) {
356 zone
->cond
= BLK_ZONE_COND_READONLY
;
357 data_size
= zonefs_check_zone_condition(inode
, zone
,
363 * If the filesystem is mounted with the explicit-open mount option, we
364 * need to clear the ZONEFS_ZONE_OPEN flag if the zone transitioned to
365 * the read-only or offline condition, to avoid attempting an explicit
366 * close of the zone when the inode file is closed.
368 if ((sbi
->s_mount_opts
& ZONEFS_MNTOPT_EXPLICIT_OPEN
) &&
369 (zone
->cond
== BLK_ZONE_COND_OFFLINE
||
370 zone
->cond
== BLK_ZONE_COND_READONLY
))
371 zi
->i_flags
&= ~ZONEFS_ZONE_OPEN
;
374 * If error=remount-ro was specified, any error result in remounting
375 * the volume as read-only.
377 if ((sbi
->s_mount_opts
& ZONEFS_MNTOPT_ERRORS_RO
) && !sb_rdonly(sb
)) {
378 zonefs_warn(sb
, "remounting filesystem read-only\n");
379 sb
->s_flags
|= SB_RDONLY
;
383 * Update block usage stats and the inode size to prevent access to
386 zonefs_update_stats(inode
, data_size
);
387 zonefs_i_size_write(inode
, data_size
);
388 zi
->i_wpoffset
= data_size
;
394 * When an file IO error occurs, check the file zone to see if there is a change
395 * in the zone condition (e.g. offline or read-only). For a failed write to a
396 * sequential zone, the zone write pointer position must also be checked to
397 * eventually correct the file size and zonefs inode write pointer offset
398 * (which can be out of sync with the drive due to partial write failures).
400 static void __zonefs_io_error(struct inode
*inode
, bool write
)
402 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
403 struct super_block
*sb
= inode
->i_sb
;
404 struct zonefs_sb_info
*sbi
= ZONEFS_SB(sb
);
405 unsigned int noio_flag
;
406 unsigned int nr_zones
=
407 zi
->i_zone_size
>> (sbi
->s_zone_sectors_shift
+ SECTOR_SHIFT
);
408 struct zonefs_ioerr_data err
= {
415 * Memory allocations in blkdev_report_zones() can trigger a memory
416 * reclaim which may in turn cause a recursion into zonefs as well as
417 * struct request allocations for the same device. The former case may
418 * end up in a deadlock on the inode truncate mutex, while the latter
419 * may prevent IO forward progress. Executing the report zones under
420 * the GFP_NOIO context avoids both problems.
422 noio_flag
= memalloc_noio_save();
423 ret
= blkdev_report_zones(sb
->s_bdev
, zi
->i_zsector
, nr_zones
,
424 zonefs_io_error_cb
, &err
);
426 zonefs_err(sb
, "Get inode %lu zone information failed %d\n",
428 memalloc_noio_restore(noio_flag
);
431 static void zonefs_io_error(struct inode
*inode
, bool write
)
433 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
435 mutex_lock(&zi
->i_truncate_mutex
);
436 __zonefs_io_error(inode
, write
);
437 mutex_unlock(&zi
->i_truncate_mutex
);
440 static int zonefs_file_truncate(struct inode
*inode
, loff_t isize
)
442 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
448 * Only sequential zone files can be truncated and truncation is allowed
449 * only down to a 0 size, which is equivalent to a zone reset, and to
450 * the maximum file size, which is equivalent to a zone finish.
452 if (zi
->i_ztype
!= ZONEFS_ZTYPE_SEQ
)
456 op
= REQ_OP_ZONE_RESET
;
457 else if (isize
== zi
->i_max_size
)
458 op
= REQ_OP_ZONE_FINISH
;
462 inode_dio_wait(inode
);
464 /* Serialize against page faults */
465 filemap_invalidate_lock(inode
->i_mapping
);
467 /* Serialize against zonefs_iomap_begin() */
468 mutex_lock(&zi
->i_truncate_mutex
);
470 old_isize
= i_size_read(inode
);
471 if (isize
== old_isize
)
474 ret
= zonefs_zone_mgmt(inode
, op
);
479 * If the mount option ZONEFS_MNTOPT_EXPLICIT_OPEN is set,
480 * take care of open zones.
482 if (zi
->i_flags
& ZONEFS_ZONE_OPEN
) {
484 * Truncating a zone to EMPTY or FULL is the equivalent of
485 * closing the zone. For a truncation to 0, we need to
486 * re-open the zone to ensure new writes can be processed.
487 * For a truncation to the maximum file size, the zone is
488 * closed and writes cannot be accepted anymore, so clear
492 ret
= zonefs_zone_mgmt(inode
, REQ_OP_ZONE_OPEN
);
494 zi
->i_flags
&= ~ZONEFS_ZONE_OPEN
;
497 zonefs_update_stats(inode
, isize
);
498 truncate_setsize(inode
, isize
);
499 zi
->i_wpoffset
= isize
;
502 mutex_unlock(&zi
->i_truncate_mutex
);
503 filemap_invalidate_unlock(inode
->i_mapping
);
508 static int zonefs_inode_setattr(struct user_namespace
*mnt_userns
,
509 struct dentry
*dentry
, struct iattr
*iattr
)
511 struct inode
*inode
= d_inode(dentry
);
514 if (unlikely(IS_IMMUTABLE(inode
)))
517 ret
= setattr_prepare(&init_user_ns
, dentry
, iattr
);
522 * Since files and directories cannot be created nor deleted, do not
523 * allow setting any write attributes on the sub-directories grouping
524 * files by zone type.
526 if ((iattr
->ia_valid
& ATTR_MODE
) && S_ISDIR(inode
->i_mode
) &&
527 (iattr
->ia_mode
& 0222))
530 if (((iattr
->ia_valid
& ATTR_UID
) &&
531 !uid_eq(iattr
->ia_uid
, inode
->i_uid
)) ||
532 ((iattr
->ia_valid
& ATTR_GID
) &&
533 !gid_eq(iattr
->ia_gid
, inode
->i_gid
))) {
534 ret
= dquot_transfer(inode
, iattr
);
539 if (iattr
->ia_valid
& ATTR_SIZE
) {
540 ret
= zonefs_file_truncate(inode
, iattr
->ia_size
);
545 setattr_copy(&init_user_ns
, inode
, iattr
);
550 static const struct inode_operations zonefs_file_inode_operations
= {
551 .setattr
= zonefs_inode_setattr
,
554 static int zonefs_file_fsync(struct file
*file
, loff_t start
, loff_t end
,
557 struct inode
*inode
= file_inode(file
);
560 if (unlikely(IS_IMMUTABLE(inode
)))
564 * Since only direct writes are allowed in sequential files, page cache
565 * flush is needed only for conventional zone files.
567 if (ZONEFS_I(inode
)->i_ztype
== ZONEFS_ZTYPE_CNV
)
568 ret
= file_write_and_wait_range(file
, start
, end
);
570 ret
= blkdev_issue_flush(inode
->i_sb
->s_bdev
);
573 zonefs_io_error(inode
, true);
578 static vm_fault_t
zonefs_filemap_page_mkwrite(struct vm_fault
*vmf
)
580 struct inode
*inode
= file_inode(vmf
->vma
->vm_file
);
581 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
584 if (unlikely(IS_IMMUTABLE(inode
)))
585 return VM_FAULT_SIGBUS
;
588 * Sanity check: only conventional zone files can have shared
589 * writeable mappings.
591 if (WARN_ON_ONCE(zi
->i_ztype
!= ZONEFS_ZTYPE_CNV
))
592 return VM_FAULT_NOPAGE
;
594 sb_start_pagefault(inode
->i_sb
);
595 file_update_time(vmf
->vma
->vm_file
);
597 /* Serialize against truncates */
598 filemap_invalidate_lock_shared(inode
->i_mapping
);
599 ret
= iomap_page_mkwrite(vmf
, &zonefs_iomap_ops
);
600 filemap_invalidate_unlock_shared(inode
->i_mapping
);
602 sb_end_pagefault(inode
->i_sb
);
606 static const struct vm_operations_struct zonefs_file_vm_ops
= {
607 .fault
= filemap_fault
,
608 .map_pages
= filemap_map_pages
,
609 .page_mkwrite
= zonefs_filemap_page_mkwrite
,
612 static int zonefs_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
615 * Conventional zones accept random writes, so their files can support
616 * shared writable mappings. For sequential zone files, only read
617 * mappings are possible since there are no guarantees for write
618 * ordering between msync() and page cache writeback.
620 if (ZONEFS_I(file_inode(file
))->i_ztype
== ZONEFS_ZTYPE_SEQ
&&
621 (vma
->vm_flags
& VM_SHARED
) && (vma
->vm_flags
& VM_MAYWRITE
))
625 vma
->vm_ops
= &zonefs_file_vm_ops
;
630 static loff_t
zonefs_file_llseek(struct file
*file
, loff_t offset
, int whence
)
632 loff_t isize
= i_size_read(file_inode(file
));
635 * Seeks are limited to below the zone size for conventional zones
636 * and below the zone write pointer for sequential zones. In both
637 * cases, this limit is the inode size.
639 return generic_file_llseek_size(file
, offset
, whence
, isize
, isize
);
642 static int zonefs_file_write_dio_end_io(struct kiocb
*iocb
, ssize_t size
,
643 int error
, unsigned int flags
)
645 struct inode
*inode
= file_inode(iocb
->ki_filp
);
646 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
649 zonefs_io_error(inode
, true);
653 if (size
&& zi
->i_ztype
!= ZONEFS_ZTYPE_CNV
) {
655 * Note that we may be seeing completions out of order,
656 * but that is not a problem since a write completed
657 * successfully necessarily means that all preceding writes
658 * were also successful. So we can safely increase the inode
659 * size to the write end location.
661 mutex_lock(&zi
->i_truncate_mutex
);
662 if (i_size_read(inode
) < iocb
->ki_pos
+ size
) {
663 zonefs_update_stats(inode
, iocb
->ki_pos
+ size
);
664 zonefs_i_size_write(inode
, iocb
->ki_pos
+ size
);
666 mutex_unlock(&zi
->i_truncate_mutex
);
672 static const struct iomap_dio_ops zonefs_write_dio_ops
= {
673 .end_io
= zonefs_file_write_dio_end_io
,
676 static ssize_t
zonefs_file_dio_append(struct kiocb
*iocb
, struct iov_iter
*from
)
678 struct inode
*inode
= file_inode(iocb
->ki_filp
);
679 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
680 struct block_device
*bdev
= inode
->i_sb
->s_bdev
;
687 max
= queue_max_zone_append_sectors(bdev_get_queue(bdev
));
688 max
= ALIGN_DOWN(max
<< SECTOR_SHIFT
, inode
->i_sb
->s_blocksize
);
689 iov_iter_truncate(from
, max
);
691 nr_pages
= iov_iter_npages(from
, BIO_MAX_VECS
);
695 bio
= bio_alloc(GFP_NOFS
, nr_pages
);
696 bio_set_dev(bio
, bdev
);
697 bio
->bi_iter
.bi_sector
= zi
->i_zsector
;
698 bio
->bi_write_hint
= iocb
->ki_hint
;
699 bio
->bi_ioprio
= iocb
->ki_ioprio
;
700 bio
->bi_opf
= REQ_OP_ZONE_APPEND
| REQ_SYNC
| REQ_IDLE
;
701 if (iocb
->ki_flags
& IOCB_DSYNC
)
702 bio
->bi_opf
|= REQ_FUA
;
704 ret
= bio_iov_iter_get_pages(bio
, from
);
708 size
= bio
->bi_iter
.bi_size
;
709 task_io_account_write(size
);
711 if (iocb
->ki_flags
& IOCB_HIPRI
)
712 bio_set_polled(bio
, iocb
);
714 ret
= submit_bio_wait(bio
);
716 zonefs_file_write_dio_end_io(iocb
, size
, ret
, 0);
717 trace_zonefs_file_dio_append(inode
, size
, ret
);
720 bio_release_pages(bio
, false);
724 iocb
->ki_pos
+= size
;
732 * Do not exceed the LFS limits nor the file zone size. If pos is under the
733 * limit it becomes a short access. If it exceeds the limit, return -EFBIG.
735 static loff_t
zonefs_write_check_limits(struct file
*file
, loff_t pos
,
738 struct inode
*inode
= file_inode(file
);
739 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
740 loff_t limit
= rlimit(RLIMIT_FSIZE
);
741 loff_t max_size
= zi
->i_max_size
;
743 if (limit
!= RLIM_INFINITY
) {
745 send_sig(SIGXFSZ
, current
, 0);
748 count
= min(count
, limit
- pos
);
751 if (!(file
->f_flags
& O_LARGEFILE
))
752 max_size
= min_t(loff_t
, MAX_NON_LFS
, max_size
);
754 if (unlikely(pos
>= max_size
))
757 return min(count
, max_size
- pos
);
760 static ssize_t
zonefs_write_checks(struct kiocb
*iocb
, struct iov_iter
*from
)
762 struct file
*file
= iocb
->ki_filp
;
763 struct inode
*inode
= file_inode(file
);
764 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
767 if (IS_SWAPFILE(inode
))
770 if (!iov_iter_count(from
))
773 if ((iocb
->ki_flags
& IOCB_NOWAIT
) && !(iocb
->ki_flags
& IOCB_DIRECT
))
776 if (iocb
->ki_flags
& IOCB_APPEND
) {
777 if (zi
->i_ztype
!= ZONEFS_ZTYPE_SEQ
)
779 mutex_lock(&zi
->i_truncate_mutex
);
780 iocb
->ki_pos
= zi
->i_wpoffset
;
781 mutex_unlock(&zi
->i_truncate_mutex
);
784 count
= zonefs_write_check_limits(file
, iocb
->ki_pos
,
785 iov_iter_count(from
));
789 iov_iter_truncate(from
, count
);
790 return iov_iter_count(from
);
794 * Handle direct writes. For sequential zone files, this is the only possible
795 * write path. For these files, check that the user is issuing writes
796 * sequentially from the end of the file. This code assumes that the block layer
797 * delivers write requests to the device in sequential order. This is always the
798 * case if a block IO scheduler implementing the ELEVATOR_F_ZBD_SEQ_WRITE
799 * elevator feature is being used (e.g. mq-deadline). The block layer always
800 * automatically select such an elevator for zoned block devices during the
801 * device initialization.
803 static ssize_t
zonefs_file_dio_write(struct kiocb
*iocb
, struct iov_iter
*from
)
805 struct inode
*inode
= file_inode(iocb
->ki_filp
);
806 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
807 struct super_block
*sb
= inode
->i_sb
;
808 bool sync
= is_sync_kiocb(iocb
);
813 * For async direct IOs to sequential zone files, refuse IOCB_NOWAIT
814 * as this can cause write reordering (e.g. the first aio gets EAGAIN
815 * on the inode lock but the second goes through but is now unaligned).
817 if (zi
->i_ztype
== ZONEFS_ZTYPE_SEQ
&& !sync
&&
818 (iocb
->ki_flags
& IOCB_NOWAIT
))
821 if (iocb
->ki_flags
& IOCB_NOWAIT
) {
822 if (!inode_trylock(inode
))
828 count
= zonefs_write_checks(iocb
, from
);
834 if ((iocb
->ki_pos
| count
) & (sb
->s_blocksize
- 1)) {
839 /* Enforce sequential writes (append only) in sequential zones */
840 if (zi
->i_ztype
== ZONEFS_ZTYPE_SEQ
) {
841 mutex_lock(&zi
->i_truncate_mutex
);
842 if (iocb
->ki_pos
!= zi
->i_wpoffset
) {
843 mutex_unlock(&zi
->i_truncate_mutex
);
847 mutex_unlock(&zi
->i_truncate_mutex
);
852 ret
= zonefs_file_dio_append(iocb
, from
);
854 ret
= iomap_dio_rw(iocb
, from
, &zonefs_iomap_ops
,
855 &zonefs_write_dio_ops
, 0);
856 if (zi
->i_ztype
== ZONEFS_ZTYPE_SEQ
&&
857 (ret
> 0 || ret
== -EIOCBQUEUED
)) {
860 mutex_lock(&zi
->i_truncate_mutex
);
861 zi
->i_wpoffset
+= count
;
862 mutex_unlock(&zi
->i_truncate_mutex
);
871 static ssize_t
zonefs_file_buffered_write(struct kiocb
*iocb
,
872 struct iov_iter
*from
)
874 struct inode
*inode
= file_inode(iocb
->ki_filp
);
875 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
879 * Direct IO writes are mandatory for sequential zone files so that the
880 * write IO issuing order is preserved.
882 if (zi
->i_ztype
!= ZONEFS_ZTYPE_CNV
)
885 if (iocb
->ki_flags
& IOCB_NOWAIT
) {
886 if (!inode_trylock(inode
))
892 ret
= zonefs_write_checks(iocb
, from
);
896 ret
= iomap_file_buffered_write(iocb
, from
, &zonefs_iomap_ops
);
899 else if (ret
== -EIO
)
900 zonefs_io_error(inode
, true);
905 ret
= generic_write_sync(iocb
, ret
);
910 static ssize_t
zonefs_file_write_iter(struct kiocb
*iocb
, struct iov_iter
*from
)
912 struct inode
*inode
= file_inode(iocb
->ki_filp
);
914 if (unlikely(IS_IMMUTABLE(inode
)))
917 if (sb_rdonly(inode
->i_sb
))
920 /* Write operations beyond the zone size are not allowed */
921 if (iocb
->ki_pos
>= ZONEFS_I(inode
)->i_max_size
)
924 if (iocb
->ki_flags
& IOCB_DIRECT
) {
925 ssize_t ret
= zonefs_file_dio_write(iocb
, from
);
930 return zonefs_file_buffered_write(iocb
, from
);
933 static int zonefs_file_read_dio_end_io(struct kiocb
*iocb
, ssize_t size
,
934 int error
, unsigned int flags
)
937 zonefs_io_error(file_inode(iocb
->ki_filp
), false);
944 static const struct iomap_dio_ops zonefs_read_dio_ops
= {
945 .end_io
= zonefs_file_read_dio_end_io
,
948 static ssize_t
zonefs_file_read_iter(struct kiocb
*iocb
, struct iov_iter
*to
)
950 struct inode
*inode
= file_inode(iocb
->ki_filp
);
951 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
952 struct super_block
*sb
= inode
->i_sb
;
956 /* Offline zones cannot be read */
957 if (unlikely(IS_IMMUTABLE(inode
) && !(inode
->i_mode
& 0777)))
960 if (iocb
->ki_pos
>= zi
->i_max_size
)
963 if (iocb
->ki_flags
& IOCB_NOWAIT
) {
964 if (!inode_trylock_shared(inode
))
967 inode_lock_shared(inode
);
970 /* Limit read operations to written data */
971 mutex_lock(&zi
->i_truncate_mutex
);
972 isize
= i_size_read(inode
);
973 if (iocb
->ki_pos
>= isize
) {
974 mutex_unlock(&zi
->i_truncate_mutex
);
978 iov_iter_truncate(to
, isize
- iocb
->ki_pos
);
979 mutex_unlock(&zi
->i_truncate_mutex
);
981 if (iocb
->ki_flags
& IOCB_DIRECT
) {
982 size_t count
= iov_iter_count(to
);
984 if ((iocb
->ki_pos
| count
) & (sb
->s_blocksize
- 1)) {
988 file_accessed(iocb
->ki_filp
);
989 ret
= iomap_dio_rw(iocb
, to
, &zonefs_iomap_ops
,
990 &zonefs_read_dio_ops
, 0);
992 ret
= generic_file_read_iter(iocb
, to
);
994 zonefs_io_error(inode
, false);
998 inode_unlock_shared(inode
);
1003 static inline bool zonefs_file_use_exp_open(struct inode
*inode
, struct file
*file
)
1005 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
1006 struct zonefs_sb_info
*sbi
= ZONEFS_SB(inode
->i_sb
);
1008 if (!(sbi
->s_mount_opts
& ZONEFS_MNTOPT_EXPLICIT_OPEN
))
1011 if (zi
->i_ztype
!= ZONEFS_ZTYPE_SEQ
)
1014 if (!(file
->f_mode
& FMODE_WRITE
))
1020 static int zonefs_open_zone(struct inode
*inode
)
1022 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
1023 struct zonefs_sb_info
*sbi
= ZONEFS_SB(inode
->i_sb
);
1026 mutex_lock(&zi
->i_truncate_mutex
);
1028 if (!zi
->i_wr_refcnt
) {
1029 if (atomic_inc_return(&sbi
->s_open_zones
) > sbi
->s_max_open_zones
) {
1030 atomic_dec(&sbi
->s_open_zones
);
1035 if (i_size_read(inode
) < zi
->i_max_size
) {
1036 ret
= zonefs_zone_mgmt(inode
, REQ_OP_ZONE_OPEN
);
1038 atomic_dec(&sbi
->s_open_zones
);
1041 zi
->i_flags
|= ZONEFS_ZONE_OPEN
;
1048 mutex_unlock(&zi
->i_truncate_mutex
);
1053 static int zonefs_file_open(struct inode
*inode
, struct file
*file
)
1057 ret
= generic_file_open(inode
, file
);
1061 if (zonefs_file_use_exp_open(inode
, file
))
1062 return zonefs_open_zone(inode
);
1067 static void zonefs_close_zone(struct inode
*inode
)
1069 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
1072 mutex_lock(&zi
->i_truncate_mutex
);
1074 if (!zi
->i_wr_refcnt
) {
1075 struct zonefs_sb_info
*sbi
= ZONEFS_SB(inode
->i_sb
);
1076 struct super_block
*sb
= inode
->i_sb
;
1079 * If the file zone is full, it is not open anymore and we only
1080 * need to decrement the open count.
1082 if (!(zi
->i_flags
& ZONEFS_ZONE_OPEN
))
1085 ret
= zonefs_zone_mgmt(inode
, REQ_OP_ZONE_CLOSE
);
1087 __zonefs_io_error(inode
, false);
1089 * Leaving zones explicitly open may lead to a state
1090 * where most zones cannot be written (zone resources
1091 * exhausted). So take preventive action by remounting
1094 if (zi
->i_flags
& ZONEFS_ZONE_OPEN
&&
1095 !(sb
->s_flags
& SB_RDONLY
)) {
1096 zonefs_warn(sb
, "closing zone failed, remounting filesystem read-only\n");
1097 sb
->s_flags
|= SB_RDONLY
;
1100 zi
->i_flags
&= ~ZONEFS_ZONE_OPEN
;
1102 atomic_dec(&sbi
->s_open_zones
);
1104 mutex_unlock(&zi
->i_truncate_mutex
);
1107 static int zonefs_file_release(struct inode
*inode
, struct file
*file
)
1110 * If we explicitly open a zone we must close it again as well, but the
1111 * zone management operation can fail (either due to an IO error or as
1112 * the zone has gone offline or read-only). Make sure we don't fail the
1113 * close(2) for user-space.
1115 if (zonefs_file_use_exp_open(inode
, file
))
1116 zonefs_close_zone(inode
);
1121 static const struct file_operations zonefs_file_operations
= {
1122 .open
= zonefs_file_open
,
1123 .release
= zonefs_file_release
,
1124 .fsync
= zonefs_file_fsync
,
1125 .mmap
= zonefs_file_mmap
,
1126 .llseek
= zonefs_file_llseek
,
1127 .read_iter
= zonefs_file_read_iter
,
1128 .write_iter
= zonefs_file_write_iter
,
1129 .splice_read
= generic_file_splice_read
,
1130 .splice_write
= iter_file_splice_write
,
1131 .iopoll
= iomap_dio_iopoll
,
1134 static struct kmem_cache
*zonefs_inode_cachep
;
1136 static struct inode
*zonefs_alloc_inode(struct super_block
*sb
)
1138 struct zonefs_inode_info
*zi
;
1140 zi
= kmem_cache_alloc(zonefs_inode_cachep
, GFP_KERNEL
);
1144 inode_init_once(&zi
->i_vnode
);
1145 mutex_init(&zi
->i_truncate_mutex
);
1146 zi
->i_wr_refcnt
= 0;
1148 return &zi
->i_vnode
;
1151 static void zonefs_free_inode(struct inode
*inode
)
1153 kmem_cache_free(zonefs_inode_cachep
, ZONEFS_I(inode
));
1159 static int zonefs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
1161 struct super_block
*sb
= dentry
->d_sb
;
1162 struct zonefs_sb_info
*sbi
= ZONEFS_SB(sb
);
1163 enum zonefs_ztype t
;
1165 buf
->f_type
= ZONEFS_MAGIC
;
1166 buf
->f_bsize
= sb
->s_blocksize
;
1167 buf
->f_namelen
= ZONEFS_NAME_MAX
;
1169 spin_lock(&sbi
->s_lock
);
1171 buf
->f_blocks
= sbi
->s_blocks
;
1172 if (WARN_ON(sbi
->s_used_blocks
> sbi
->s_blocks
))
1175 buf
->f_bfree
= buf
->f_blocks
- sbi
->s_used_blocks
;
1176 buf
->f_bavail
= buf
->f_bfree
;
1178 for (t
= 0; t
< ZONEFS_ZTYPE_MAX
; t
++) {
1179 if (sbi
->s_nr_files
[t
])
1180 buf
->f_files
+= sbi
->s_nr_files
[t
] + 1;
1184 spin_unlock(&sbi
->s_lock
);
1186 buf
->f_fsid
= uuid_to_fsid(sbi
->s_uuid
.b
);
1192 Opt_errors_ro
, Opt_errors_zro
, Opt_errors_zol
, Opt_errors_repair
,
1193 Opt_explicit_open
, Opt_err
,
1196 static const match_table_t tokens
= {
1197 { Opt_errors_ro
, "errors=remount-ro"},
1198 { Opt_errors_zro
, "errors=zone-ro"},
1199 { Opt_errors_zol
, "errors=zone-offline"},
1200 { Opt_errors_repair
, "errors=repair"},
1201 { Opt_explicit_open
, "explicit-open" },
1205 static int zonefs_parse_options(struct super_block
*sb
, char *options
)
1207 struct zonefs_sb_info
*sbi
= ZONEFS_SB(sb
);
1208 substring_t args
[MAX_OPT_ARGS
];
1214 while ((p
= strsep(&options
, ",")) != NULL
) {
1220 token
= match_token(p
, tokens
, args
);
1223 sbi
->s_mount_opts
&= ~ZONEFS_MNTOPT_ERRORS_MASK
;
1224 sbi
->s_mount_opts
|= ZONEFS_MNTOPT_ERRORS_RO
;
1226 case Opt_errors_zro
:
1227 sbi
->s_mount_opts
&= ~ZONEFS_MNTOPT_ERRORS_MASK
;
1228 sbi
->s_mount_opts
|= ZONEFS_MNTOPT_ERRORS_ZRO
;
1230 case Opt_errors_zol
:
1231 sbi
->s_mount_opts
&= ~ZONEFS_MNTOPT_ERRORS_MASK
;
1232 sbi
->s_mount_opts
|= ZONEFS_MNTOPT_ERRORS_ZOL
;
1234 case Opt_errors_repair
:
1235 sbi
->s_mount_opts
&= ~ZONEFS_MNTOPT_ERRORS_MASK
;
1236 sbi
->s_mount_opts
|= ZONEFS_MNTOPT_ERRORS_REPAIR
;
1238 case Opt_explicit_open
:
1239 sbi
->s_mount_opts
|= ZONEFS_MNTOPT_EXPLICIT_OPEN
;
1249 static int zonefs_show_options(struct seq_file
*seq
, struct dentry
*root
)
1251 struct zonefs_sb_info
*sbi
= ZONEFS_SB(root
->d_sb
);
1253 if (sbi
->s_mount_opts
& ZONEFS_MNTOPT_ERRORS_RO
)
1254 seq_puts(seq
, ",errors=remount-ro");
1255 if (sbi
->s_mount_opts
& ZONEFS_MNTOPT_ERRORS_ZRO
)
1256 seq_puts(seq
, ",errors=zone-ro");
1257 if (sbi
->s_mount_opts
& ZONEFS_MNTOPT_ERRORS_ZOL
)
1258 seq_puts(seq
, ",errors=zone-offline");
1259 if (sbi
->s_mount_opts
& ZONEFS_MNTOPT_ERRORS_REPAIR
)
1260 seq_puts(seq
, ",errors=repair");
1265 static int zonefs_remount(struct super_block
*sb
, int *flags
, char *data
)
1267 sync_filesystem(sb
);
1269 return zonefs_parse_options(sb
, data
);
1272 static const struct super_operations zonefs_sops
= {
1273 .alloc_inode
= zonefs_alloc_inode
,
1274 .free_inode
= zonefs_free_inode
,
1275 .statfs
= zonefs_statfs
,
1276 .remount_fs
= zonefs_remount
,
1277 .show_options
= zonefs_show_options
,
1280 static const struct inode_operations zonefs_dir_inode_operations
= {
1281 .lookup
= simple_lookup
,
1282 .setattr
= zonefs_inode_setattr
,
1285 static void zonefs_init_dir_inode(struct inode
*parent
, struct inode
*inode
,
1286 enum zonefs_ztype type
)
1288 struct super_block
*sb
= parent
->i_sb
;
1290 inode
->i_ino
= blkdev_nr_zones(sb
->s_bdev
->bd_disk
) + type
+ 1;
1291 inode_init_owner(&init_user_ns
, inode
, parent
, S_IFDIR
| 0555);
1292 inode
->i_op
= &zonefs_dir_inode_operations
;
1293 inode
->i_fop
= &simple_dir_operations
;
1294 set_nlink(inode
, 2);
1298 static void zonefs_init_file_inode(struct inode
*inode
, struct blk_zone
*zone
,
1299 enum zonefs_ztype type
)
1301 struct super_block
*sb
= inode
->i_sb
;
1302 struct zonefs_sb_info
*sbi
= ZONEFS_SB(sb
);
1303 struct zonefs_inode_info
*zi
= ZONEFS_I(inode
);
1305 inode
->i_ino
= zone
->start
>> sbi
->s_zone_sectors_shift
;
1306 inode
->i_mode
= S_IFREG
| sbi
->s_perm
;
1309 zi
->i_zsector
= zone
->start
;
1310 zi
->i_zone_size
= zone
->len
<< SECTOR_SHIFT
;
1312 zi
->i_max_size
= min_t(loff_t
, MAX_LFS_FILESIZE
,
1313 zone
->capacity
<< SECTOR_SHIFT
);
1314 zi
->i_wpoffset
= zonefs_check_zone_condition(inode
, zone
, true, true);
1316 inode
->i_uid
= sbi
->s_uid
;
1317 inode
->i_gid
= sbi
->s_gid
;
1318 inode
->i_size
= zi
->i_wpoffset
;
1319 inode
->i_blocks
= zi
->i_max_size
>> SECTOR_SHIFT
;
1321 inode
->i_op
= &zonefs_file_inode_operations
;
1322 inode
->i_fop
= &zonefs_file_operations
;
1323 inode
->i_mapping
->a_ops
= &zonefs_file_aops
;
1325 sb
->s_maxbytes
= max(zi
->i_max_size
, sb
->s_maxbytes
);
1326 sbi
->s_blocks
+= zi
->i_max_size
>> sb
->s_blocksize_bits
;
1327 sbi
->s_used_blocks
+= zi
->i_wpoffset
>> sb
->s_blocksize_bits
;
1330 static struct dentry
*zonefs_create_inode(struct dentry
*parent
,
1331 const char *name
, struct blk_zone
*zone
,
1332 enum zonefs_ztype type
)
1334 struct inode
*dir
= d_inode(parent
);
1335 struct dentry
*dentry
;
1336 struct inode
*inode
;
1338 dentry
= d_alloc_name(parent
, name
);
1342 inode
= new_inode(parent
->d_sb
);
1346 inode
->i_ctime
= inode
->i_mtime
= inode
->i_atime
= dir
->i_ctime
;
1348 zonefs_init_file_inode(inode
, zone
, type
);
1350 zonefs_init_dir_inode(dir
, inode
, type
);
1351 d_add(dentry
, inode
);
1362 struct zonefs_zone_data
{
1363 struct super_block
*sb
;
1364 unsigned int nr_zones
[ZONEFS_ZTYPE_MAX
];
1365 struct blk_zone
*zones
;
1369 * Create a zone group and populate it with zone files.
1371 static int zonefs_create_zgroup(struct zonefs_zone_data
*zd
,
1372 enum zonefs_ztype type
)
1374 struct super_block
*sb
= zd
->sb
;
1375 struct zonefs_sb_info
*sbi
= ZONEFS_SB(sb
);
1376 struct blk_zone
*zone
, *next
, *end
;
1377 const char *zgroup_name
;
1383 /* If the group is empty, there is nothing to do */
1384 if (!zd
->nr_zones
[type
])
1387 file_name
= kmalloc(ZONEFS_NAME_MAX
, GFP_KERNEL
);
1391 if (type
== ZONEFS_ZTYPE_CNV
)
1392 zgroup_name
= "cnv";
1394 zgroup_name
= "seq";
1396 dir
= zonefs_create_inode(sb
->s_root
, zgroup_name
, NULL
, type
);
1403 * The first zone contains the super block: skip it.
1405 end
= zd
->zones
+ blkdev_nr_zones(sb
->s_bdev
->bd_disk
);
1406 for (zone
= &zd
->zones
[1]; zone
< end
; zone
= next
) {
1409 if (zonefs_zone_type(zone
) != type
)
1413 * For conventional zones, contiguous zones can be aggregated
1414 * together to form larger files. Note that this overwrites the
1415 * length of the first zone of the set of contiguous zones
1416 * aggregated together. If one offline or read-only zone is
1417 * found, assume that all zones aggregated have the same
1420 if (type
== ZONEFS_ZTYPE_CNV
&&
1421 (sbi
->s_features
& ZONEFS_F_AGGRCNV
)) {
1422 for (; next
< end
; next
++) {
1423 if (zonefs_zone_type(next
) != type
)
1425 zone
->len
+= next
->len
;
1426 zone
->capacity
+= next
->capacity
;
1427 if (next
->cond
== BLK_ZONE_COND_READONLY
&&
1428 zone
->cond
!= BLK_ZONE_COND_OFFLINE
)
1429 zone
->cond
= BLK_ZONE_COND_READONLY
;
1430 else if (next
->cond
== BLK_ZONE_COND_OFFLINE
)
1431 zone
->cond
= BLK_ZONE_COND_OFFLINE
;
1433 if (zone
->capacity
!= zone
->len
) {
1434 zonefs_err(sb
, "Invalid conventional zone capacity\n");
1441 * Use the file number within its group as file name.
1443 snprintf(file_name
, ZONEFS_NAME_MAX
- 1, "%u", n
);
1444 if (!zonefs_create_inode(dir
, file_name
, zone
, type
)) {
1452 zonefs_info(sb
, "Zone group \"%s\" has %u file%s\n",
1453 zgroup_name
, n
, n
> 1 ? "s" : "");
1455 sbi
->s_nr_files
[type
] = n
;
1464 static int zonefs_get_zone_info_cb(struct blk_zone
*zone
, unsigned int idx
,
1467 struct zonefs_zone_data
*zd
= data
;
1470 * Count the number of usable zones: the first zone at index 0 contains
1471 * the super block and is ignored.
1473 switch (zone
->type
) {
1474 case BLK_ZONE_TYPE_CONVENTIONAL
:
1475 zone
->wp
= zone
->start
+ zone
->len
;
1477 zd
->nr_zones
[ZONEFS_ZTYPE_CNV
]++;
1479 case BLK_ZONE_TYPE_SEQWRITE_REQ
:
1480 case BLK_ZONE_TYPE_SEQWRITE_PREF
:
1482 zd
->nr_zones
[ZONEFS_ZTYPE_SEQ
]++;
1485 zonefs_err(zd
->sb
, "Unsupported zone type 0x%x\n",
1490 memcpy(&zd
->zones
[idx
], zone
, sizeof(struct blk_zone
));
1495 static int zonefs_get_zone_info(struct zonefs_zone_data
*zd
)
1497 struct block_device
*bdev
= zd
->sb
->s_bdev
;
1500 zd
->zones
= kvcalloc(blkdev_nr_zones(bdev
->bd_disk
),
1501 sizeof(struct blk_zone
), GFP_KERNEL
);
1505 /* Get zones information from the device */
1506 ret
= blkdev_report_zones(bdev
, 0, BLK_ALL_ZONES
,
1507 zonefs_get_zone_info_cb
, zd
);
1509 zonefs_err(zd
->sb
, "Zone report failed %d\n", ret
);
1513 if (ret
!= blkdev_nr_zones(bdev
->bd_disk
)) {
1514 zonefs_err(zd
->sb
, "Invalid zone report (%d/%u zones)\n",
1515 ret
, blkdev_nr_zones(bdev
->bd_disk
));
1522 static inline void zonefs_cleanup_zone_info(struct zonefs_zone_data
*zd
)
1528 * Read super block information from the device.
1530 static int zonefs_read_super(struct super_block
*sb
)
1532 struct zonefs_sb_info
*sbi
= ZONEFS_SB(sb
);
1533 struct zonefs_super
*super
;
1534 u32 crc
, stored_crc
;
1536 struct bio_vec bio_vec
;
1540 page
= alloc_page(GFP_KERNEL
);
1544 bio_init(&bio
, &bio_vec
, 1);
1545 bio
.bi_iter
.bi_sector
= 0;
1546 bio
.bi_opf
= REQ_OP_READ
;
1547 bio_set_dev(&bio
, sb
->s_bdev
);
1548 bio_add_page(&bio
, page
, PAGE_SIZE
, 0);
1550 ret
= submit_bio_wait(&bio
);
1557 if (le32_to_cpu(super
->s_magic
) != ZONEFS_MAGIC
)
1560 stored_crc
= le32_to_cpu(super
->s_crc
);
1562 crc
= crc32(~0U, (unsigned char *)super
, sizeof(struct zonefs_super
));
1563 if (crc
!= stored_crc
) {
1564 zonefs_err(sb
, "Invalid checksum (Expected 0x%08x, got 0x%08x)",
1569 sbi
->s_features
= le64_to_cpu(super
->s_features
);
1570 if (sbi
->s_features
& ~ZONEFS_F_DEFINED_FEATURES
) {
1571 zonefs_err(sb
, "Unknown features set 0x%llx\n",
1576 if (sbi
->s_features
& ZONEFS_F_UID
) {
1577 sbi
->s_uid
= make_kuid(current_user_ns(),
1578 le32_to_cpu(super
->s_uid
));
1579 if (!uid_valid(sbi
->s_uid
)) {
1580 zonefs_err(sb
, "Invalid UID feature\n");
1585 if (sbi
->s_features
& ZONEFS_F_GID
) {
1586 sbi
->s_gid
= make_kgid(current_user_ns(),
1587 le32_to_cpu(super
->s_gid
));
1588 if (!gid_valid(sbi
->s_gid
)) {
1589 zonefs_err(sb
, "Invalid GID feature\n");
1594 if (sbi
->s_features
& ZONEFS_F_PERM
)
1595 sbi
->s_perm
= le32_to_cpu(super
->s_perm
);
1597 if (memchr_inv(super
->s_reserved
, 0, sizeof(super
->s_reserved
))) {
1598 zonefs_err(sb
, "Reserved area is being used\n");
1602 import_uuid(&sbi
->s_uuid
, super
->s_uuid
);
1614 * Check that the device is zoned. If it is, get the list of zones and create
1615 * sub-directories and files according to the device zone configuration and
1618 static int zonefs_fill_super(struct super_block
*sb
, void *data
, int silent
)
1620 struct zonefs_zone_data zd
;
1621 struct zonefs_sb_info
*sbi
;
1622 struct inode
*inode
;
1623 enum zonefs_ztype t
;
1626 if (!bdev_is_zoned(sb
->s_bdev
)) {
1627 zonefs_err(sb
, "Not a zoned block device\n");
1632 * Initialize super block information: the maximum file size is updated
1633 * when the zone files are created so that the format option
1634 * ZONEFS_F_AGGRCNV which increases the maximum file size of a file
1635 * beyond the zone size is taken into account.
1637 sbi
= kzalloc(sizeof(*sbi
), GFP_KERNEL
);
1641 spin_lock_init(&sbi
->s_lock
);
1642 sb
->s_fs_info
= sbi
;
1643 sb
->s_magic
= ZONEFS_MAGIC
;
1645 sb
->s_op
= &zonefs_sops
;
1646 sb
->s_time_gran
= 1;
1649 * The block size is set to the device zone write granularity to ensure
1650 * that write operations are always aligned according to the device
1651 * interface constraints.
1653 sb_set_blocksize(sb
, bdev_zone_write_granularity(sb
->s_bdev
));
1654 sbi
->s_zone_sectors_shift
= ilog2(bdev_zone_sectors(sb
->s_bdev
));
1655 sbi
->s_uid
= GLOBAL_ROOT_UID
;
1656 sbi
->s_gid
= GLOBAL_ROOT_GID
;
1658 sbi
->s_mount_opts
= ZONEFS_MNTOPT_ERRORS_RO
;
1659 sbi
->s_max_open_zones
= bdev_max_open_zones(sb
->s_bdev
);
1660 atomic_set(&sbi
->s_open_zones
, 0);
1661 if (!sbi
->s_max_open_zones
&&
1662 sbi
->s_mount_opts
& ZONEFS_MNTOPT_EXPLICIT_OPEN
) {
1663 zonefs_info(sb
, "No open zones limit. Ignoring explicit_open mount option\n");
1664 sbi
->s_mount_opts
&= ~ZONEFS_MNTOPT_EXPLICIT_OPEN
;
1667 ret
= zonefs_read_super(sb
);
1671 ret
= zonefs_parse_options(sb
, data
);
1675 memset(&zd
, 0, sizeof(struct zonefs_zone_data
));
1677 ret
= zonefs_get_zone_info(&zd
);
1681 zonefs_info(sb
, "Mounting %u zones",
1682 blkdev_nr_zones(sb
->s_bdev
->bd_disk
));
1684 /* Create root directory inode */
1686 inode
= new_inode(sb
);
1690 inode
->i_ino
= blkdev_nr_zones(sb
->s_bdev
->bd_disk
);
1691 inode
->i_mode
= S_IFDIR
| 0555;
1692 inode
->i_ctime
= inode
->i_mtime
= inode
->i_atime
= current_time(inode
);
1693 inode
->i_op
= &zonefs_dir_inode_operations
;
1694 inode
->i_fop
= &simple_dir_operations
;
1695 set_nlink(inode
, 2);
1697 sb
->s_root
= d_make_root(inode
);
1701 /* Create and populate files in zone groups directories */
1702 for (t
= 0; t
< ZONEFS_ZTYPE_MAX
; t
++) {
1703 ret
= zonefs_create_zgroup(&zd
, t
);
1709 zonefs_cleanup_zone_info(&zd
);
1714 static struct dentry
*zonefs_mount(struct file_system_type
*fs_type
,
1715 int flags
, const char *dev_name
, void *data
)
1717 return mount_bdev(fs_type
, flags
, dev_name
, data
, zonefs_fill_super
);
1720 static void zonefs_kill_super(struct super_block
*sb
)
1722 struct zonefs_sb_info
*sbi
= ZONEFS_SB(sb
);
1725 d_genocide(sb
->s_root
);
1726 kill_block_super(sb
);
1731 * File system definition and registration.
1733 static struct file_system_type zonefs_type
= {
1734 .owner
= THIS_MODULE
,
1736 .mount
= zonefs_mount
,
1737 .kill_sb
= zonefs_kill_super
,
1738 .fs_flags
= FS_REQUIRES_DEV
,
1741 static int __init
zonefs_init_inodecache(void)
1743 zonefs_inode_cachep
= kmem_cache_create("zonefs_inode_cache",
1744 sizeof(struct zonefs_inode_info
), 0,
1745 (SLAB_RECLAIM_ACCOUNT
| SLAB_MEM_SPREAD
| SLAB_ACCOUNT
),
1747 if (zonefs_inode_cachep
== NULL
)
1752 static void zonefs_destroy_inodecache(void)
1755 * Make sure all delayed rcu free inodes are flushed before we
1756 * destroy the inode cache.
1759 kmem_cache_destroy(zonefs_inode_cachep
);
1762 static int __init
zonefs_init(void)
1766 BUILD_BUG_ON(sizeof(struct zonefs_super
) != ZONEFS_SUPER_SIZE
);
1768 ret
= zonefs_init_inodecache();
1772 ret
= register_filesystem(&zonefs_type
);
1774 zonefs_destroy_inodecache();
1781 static void __exit
zonefs_exit(void)
1783 zonefs_destroy_inodecache();
1784 unregister_filesystem(&zonefs_type
);
1787 MODULE_AUTHOR("Damien Le Moal");
1788 MODULE_DESCRIPTION("Zone file system for zoned block devices");
1789 MODULE_LICENSE("GPL");
1790 module_init(zonefs_init
);
1791 module_exit(zonefs_exit
);