1 // SPDX-License-Identifier: GPL-2.0 2 /* 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/fs.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> 24 25 #include "zonefs.h" 26 27 #define CREATE_TRACE_POINTS 28 #include "trace.h" 29 30 static inline int zonefs_zone_mgmt(struct inode *inode, 31 enum req_opf op) 32 { 33 struct zonefs_inode_info *zi = ZONEFS_I(inode); 34 int ret; 35 36 lockdep_assert_held(&zi->i_truncate_mutex); 37 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); 41 if (ret) { 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); 45 return ret; 46 } 47 48 return 0; 49 } 50 51 static inline void zonefs_i_size_write(struct inode *inode, loff_t isize) 52 { 53 struct zonefs_inode_info *zi = ZONEFS_I(inode); 54 55 i_size_write(inode, isize); 56 /* 57 * A full zone is no longer open/active and does not need 58 * explicit closing. 59 */ 60 if (isize >= zi->i_max_size) 61 zi->i_flags &= ~ZONEFS_ZONE_OPEN; 62 } 63 64 static int zonefs_iomap_begin(struct inode *inode, loff_t offset, loff_t length, 65 unsigned int flags, struct iomap *iomap, 66 struct iomap *srcmap) 67 { 68 struct zonefs_inode_info *zi = ZONEFS_I(inode); 69 struct super_block *sb = inode->i_sb; 70 loff_t isize; 71 72 /* All I/Os should always be within the file maximum size */ 73 if (WARN_ON_ONCE(offset + length > zi->i_max_size)) 74 return -EIO; 75 76 /* 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 79 * operation. 80 */ 81 if (WARN_ON_ONCE(zi->i_ztype == ZONEFS_ZTYPE_SEQ && 82 (flags & IOMAP_WRITE) && !(flags & IOMAP_DIRECT))) 83 return -EIO; 84 85 /* 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. 89 */ 90 mutex_lock(&zi->i_truncate_mutex); 91 isize = i_size_read(inode); 92 if (offset >= isize) 93 iomap->type = IOMAP_UNWRITTEN; 94 else 95 iomap->type = IOMAP_MAPPED; 96 if (flags & IOMAP_WRITE) 97 length = zi->i_max_size - offset; 98 else 99 length = min(length, isize - offset); 100 mutex_unlock(&zi->i_truncate_mutex); 101 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; 106 107 trace_zonefs_iomap_begin(inode, iomap); 108 109 return 0; 110 } 111 112 static const struct iomap_ops zonefs_iomap_ops = { 113 .iomap_begin = zonefs_iomap_begin, 114 }; 115 116 static int zonefs_readpage(struct file *unused, struct page *page) 117 { 118 return iomap_readpage(page, &zonefs_iomap_ops); 119 } 120 121 static void zonefs_readahead(struct readahead_control *rac) 122 { 123 iomap_readahead(rac, &zonefs_iomap_ops); 124 } 125 126 /* 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. 129 */ 130 static int zonefs_map_blocks(struct iomap_writepage_ctx *wpc, 131 struct inode *inode, loff_t offset) 132 { 133 struct zonefs_inode_info *zi = ZONEFS_I(inode); 134 135 if (WARN_ON_ONCE(zi->i_ztype != ZONEFS_ZTYPE_CNV)) 136 return -EIO; 137 if (WARN_ON_ONCE(offset >= i_size_read(inode))) 138 return -EIO; 139 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) 143 return 0; 144 145 return zonefs_iomap_begin(inode, offset, zi->i_max_size - offset, 146 IOMAP_WRITE, &wpc->iomap, NULL); 147 } 148 149 static const struct iomap_writeback_ops zonefs_writeback_ops = { 150 .map_blocks = zonefs_map_blocks, 151 }; 152 153 static int zonefs_writepage(struct page *page, struct writeback_control *wbc) 154 { 155 struct iomap_writepage_ctx wpc = { }; 156 157 return iomap_writepage(page, wbc, &wpc, &zonefs_writeback_ops); 158 } 159 160 static int zonefs_writepages(struct address_space *mapping, 161 struct writeback_control *wbc) 162 { 163 struct iomap_writepage_ctx wpc = { }; 164 165 return iomap_writepages(mapping, wbc, &wpc, &zonefs_writeback_ops); 166 } 167 168 static const struct address_space_operations zonefs_file_aops = { 169 .readpage = zonefs_readpage, 170 .readahead = zonefs_readahead, 171 .writepage = zonefs_writepage, 172 .writepages = zonefs_writepages, 173 .set_page_dirty = iomap_set_page_dirty, 174 .releasepage = iomap_releasepage, 175 .invalidatepage = iomap_invalidatepage, 176 .migratepage = iomap_migrate_page, 177 .is_partially_uptodate = iomap_is_partially_uptodate, 178 .error_remove_page = generic_error_remove_page, 179 .direct_IO = noop_direct_IO, 180 }; 181 182 static void zonefs_update_stats(struct inode *inode, loff_t new_isize) 183 { 184 struct super_block *sb = inode->i_sb; 185 struct zonefs_sb_info *sbi = ZONEFS_SB(sb); 186 loff_t old_isize = i_size_read(inode); 187 loff_t nr_blocks; 188 189 if (new_isize == old_isize) 190 return; 191 192 spin_lock(&sbi->s_lock); 193 194 /* 195 * This may be called for an update after an IO error. 196 * So beware of the values seen. 197 */ 198 if (new_isize < old_isize) { 199 nr_blocks = (old_isize - new_isize) >> sb->s_blocksize_bits; 200 if (sbi->s_used_blocks > nr_blocks) 201 sbi->s_used_blocks -= nr_blocks; 202 else 203 sbi->s_used_blocks = 0; 204 } else { 205 sbi->s_used_blocks += 206 (new_isize - old_isize) >> sb->s_blocksize_bits; 207 if (sbi->s_used_blocks > sbi->s_blocks) 208 sbi->s_used_blocks = sbi->s_blocks; 209 } 210 211 spin_unlock(&sbi->s_lock); 212 } 213 214 /* 215 * Check a zone condition and adjust its file inode access permissions for 216 * offline and readonly zones. Return the inode size corresponding to the 217 * amount of readable data in the zone. 218 */ 219 static loff_t zonefs_check_zone_condition(struct inode *inode, 220 struct blk_zone *zone, bool warn, 221 bool mount) 222 { 223 struct zonefs_inode_info *zi = ZONEFS_I(inode); 224 225 switch (zone->cond) { 226 case BLK_ZONE_COND_OFFLINE: 227 /* 228 * Dead zone: make the inode immutable, disable all accesses 229 * and set the file size to 0 (zone wp set to zone start). 230 */ 231 if (warn) 232 zonefs_warn(inode->i_sb, "inode %lu: offline zone\n", 233 inode->i_ino); 234 inode->i_flags |= S_IMMUTABLE; 235 inode->i_mode &= ~0777; 236 zone->wp = zone->start; 237 return 0; 238 case BLK_ZONE_COND_READONLY: 239 /* 240 * The write pointer of read-only zones is invalid. If such a 241 * zone is found during mount, the file size cannot be retrieved 242 * so we treat the zone as offline (mount == true case). 243 * Otherwise, keep the file size as it was when last updated 244 * so that the user can recover data. In both cases, writes are 245 * always disabled for the zone. 246 */ 247 if (warn) 248 zonefs_warn(inode->i_sb, "inode %lu: read-only zone\n", 249 inode->i_ino); 250 inode->i_flags |= S_IMMUTABLE; 251 if (mount) { 252 zone->cond = BLK_ZONE_COND_OFFLINE; 253 inode->i_mode &= ~0777; 254 zone->wp = zone->start; 255 return 0; 256 } 257 inode->i_mode &= ~0222; 258 return i_size_read(inode); 259 case BLK_ZONE_COND_FULL: 260 /* The write pointer of full zones is invalid. */ 261 return zi->i_max_size; 262 default: 263 if (zi->i_ztype == ZONEFS_ZTYPE_CNV) 264 return zi->i_max_size; 265 return (zone->wp - zone->start) << SECTOR_SHIFT; 266 } 267 } 268 269 struct zonefs_ioerr_data { 270 struct inode *inode; 271 bool write; 272 }; 273 274 static int zonefs_io_error_cb(struct blk_zone *zone, unsigned int idx, 275 void *data) 276 { 277 struct zonefs_ioerr_data *err = data; 278 struct inode *inode = err->inode; 279 struct zonefs_inode_info *zi = ZONEFS_I(inode); 280 struct super_block *sb = inode->i_sb; 281 struct zonefs_sb_info *sbi = ZONEFS_SB(sb); 282 loff_t isize, data_size; 283 284 /* 285 * Check the zone condition: if the zone is not "bad" (offline or 286 * read-only), read errors are simply signaled to the IO issuer as long 287 * as there is no inconsistency between the inode size and the amount of 288 * data writen in the zone (data_size). 289 */ 290 data_size = zonefs_check_zone_condition(inode, zone, true, false); 291 isize = i_size_read(inode); 292 if (zone->cond != BLK_ZONE_COND_OFFLINE && 293 zone->cond != BLK_ZONE_COND_READONLY && 294 !err->write && isize == data_size) 295 return 0; 296 297 /* 298 * At this point, we detected either a bad zone or an inconsistency 299 * between the inode size and the amount of data written in the zone. 300 * For the latter case, the cause may be a write IO error or an external 301 * action on the device. Two error patterns exist: 302 * 1) The inode size is lower than the amount of data in the zone: 303 * a write operation partially failed and data was writen at the end 304 * of the file. This can happen in the case of a large direct IO 305 * needing several BIOs and/or write requests to be processed. 306 * 2) The inode size is larger than the amount of data in the zone: 307 * this can happen with a deferred write error with the use of the 308 * device side write cache after getting successful write IO 309 * completions. Other possibilities are (a) an external corruption, 310 * e.g. an application reset the zone directly, or (b) the device 311 * has a serious problem (e.g. firmware bug). 312 * 313 * In all cases, warn about inode size inconsistency and handle the 314 * IO error according to the zone condition and to the mount options. 315 */ 316 if (zi->i_ztype == ZONEFS_ZTYPE_SEQ && isize != data_size) 317 zonefs_warn(sb, "inode %lu: invalid size %lld (should be %lld)\n", 318 inode->i_ino, isize, data_size); 319 320 /* 321 * First handle bad zones signaled by hardware. The mount options 322 * errors=zone-ro and errors=zone-offline result in changing the 323 * zone condition to read-only and offline respectively, as if the 324 * condition was signaled by the hardware. 325 */ 326 if (zone->cond == BLK_ZONE_COND_OFFLINE || 327 sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_ZOL) { 328 zonefs_warn(sb, "inode %lu: read/write access disabled\n", 329 inode->i_ino); 330 if (zone->cond != BLK_ZONE_COND_OFFLINE) { 331 zone->cond = BLK_ZONE_COND_OFFLINE; 332 data_size = zonefs_check_zone_condition(inode, zone, 333 false, false); 334 } 335 } else if (zone->cond == BLK_ZONE_COND_READONLY || 336 sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_ZRO) { 337 zonefs_warn(sb, "inode %lu: write access disabled\n", 338 inode->i_ino); 339 if (zone->cond != BLK_ZONE_COND_READONLY) { 340 zone->cond = BLK_ZONE_COND_READONLY; 341 data_size = zonefs_check_zone_condition(inode, zone, 342 false, false); 343 } 344 } 345 346 /* 347 * If the filesystem is mounted with the explicit-open mount option, we 348 * need to clear the ZONEFS_ZONE_OPEN flag if the zone transitioned to 349 * the read-only or offline condition, to avoid attempting an explicit 350 * close of the zone when the inode file is closed. 351 */ 352 if ((sbi->s_mount_opts & ZONEFS_MNTOPT_EXPLICIT_OPEN) && 353 (zone->cond == BLK_ZONE_COND_OFFLINE || 354 zone->cond == BLK_ZONE_COND_READONLY)) 355 zi->i_flags &= ~ZONEFS_ZONE_OPEN; 356 357 /* 358 * If error=remount-ro was specified, any error result in remounting 359 * the volume as read-only. 360 */ 361 if ((sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_RO) && !sb_rdonly(sb)) { 362 zonefs_warn(sb, "remounting filesystem read-only\n"); 363 sb->s_flags |= SB_RDONLY; 364 } 365 366 /* 367 * Update block usage stats and the inode size to prevent access to 368 * invalid data. 369 */ 370 zonefs_update_stats(inode, data_size); 371 zonefs_i_size_write(inode, data_size); 372 zi->i_wpoffset = data_size; 373 374 return 0; 375 } 376 377 /* 378 * When an file IO error occurs, check the file zone to see if there is a change 379 * in the zone condition (e.g. offline or read-only). For a failed write to a 380 * sequential zone, the zone write pointer position must also be checked to 381 * eventually correct the file size and zonefs inode write pointer offset 382 * (which can be out of sync with the drive due to partial write failures). 383 */ 384 static void __zonefs_io_error(struct inode *inode, bool write) 385 { 386 struct zonefs_inode_info *zi = ZONEFS_I(inode); 387 struct super_block *sb = inode->i_sb; 388 struct zonefs_sb_info *sbi = ZONEFS_SB(sb); 389 unsigned int noio_flag; 390 unsigned int nr_zones = 391 zi->i_zone_size >> (sbi->s_zone_sectors_shift + SECTOR_SHIFT); 392 struct zonefs_ioerr_data err = { 393 .inode = inode, 394 .write = write, 395 }; 396 int ret; 397 398 /* 399 * Memory allocations in blkdev_report_zones() can trigger a memory 400 * reclaim which may in turn cause a recursion into zonefs as well as 401 * struct request allocations for the same device. The former case may 402 * end up in a deadlock on the inode truncate mutex, while the latter 403 * may prevent IO forward progress. Executing the report zones under 404 * the GFP_NOIO context avoids both problems. 405 */ 406 noio_flag = memalloc_noio_save(); 407 ret = blkdev_report_zones(sb->s_bdev, zi->i_zsector, nr_zones, 408 zonefs_io_error_cb, &err); 409 if (ret != nr_zones) 410 zonefs_err(sb, "Get inode %lu zone information failed %d\n", 411 inode->i_ino, ret); 412 memalloc_noio_restore(noio_flag); 413 } 414 415 static void zonefs_io_error(struct inode *inode, bool write) 416 { 417 struct zonefs_inode_info *zi = ZONEFS_I(inode); 418 419 mutex_lock(&zi->i_truncate_mutex); 420 __zonefs_io_error(inode, write); 421 mutex_unlock(&zi->i_truncate_mutex); 422 } 423 424 static int zonefs_file_truncate(struct inode *inode, loff_t isize) 425 { 426 struct zonefs_inode_info *zi = ZONEFS_I(inode); 427 loff_t old_isize; 428 enum req_opf op; 429 int ret = 0; 430 431 /* 432 * Only sequential zone files can be truncated and truncation is allowed 433 * only down to a 0 size, which is equivalent to a zone reset, and to 434 * the maximum file size, which is equivalent to a zone finish. 435 */ 436 if (zi->i_ztype != ZONEFS_ZTYPE_SEQ) 437 return -EPERM; 438 439 if (!isize) 440 op = REQ_OP_ZONE_RESET; 441 else if (isize == zi->i_max_size) 442 op = REQ_OP_ZONE_FINISH; 443 else 444 return -EPERM; 445 446 inode_dio_wait(inode); 447 448 /* Serialize against page faults */ 449 down_write(&zi->i_mmap_sem); 450 451 /* Serialize against zonefs_iomap_begin() */ 452 mutex_lock(&zi->i_truncate_mutex); 453 454 old_isize = i_size_read(inode); 455 if (isize == old_isize) 456 goto unlock; 457 458 ret = zonefs_zone_mgmt(inode, op); 459 if (ret) 460 goto unlock; 461 462 /* 463 * If the mount option ZONEFS_MNTOPT_EXPLICIT_OPEN is set, 464 * take care of open zones. 465 */ 466 if (zi->i_flags & ZONEFS_ZONE_OPEN) { 467 /* 468 * Truncating a zone to EMPTY or FULL is the equivalent of 469 * closing the zone. For a truncation to 0, we need to 470 * re-open the zone to ensure new writes can be processed. 471 * For a truncation to the maximum file size, the zone is 472 * closed and writes cannot be accepted anymore, so clear 473 * the open flag. 474 */ 475 if (!isize) 476 ret = zonefs_zone_mgmt(inode, REQ_OP_ZONE_OPEN); 477 else 478 zi->i_flags &= ~ZONEFS_ZONE_OPEN; 479 } 480 481 zonefs_update_stats(inode, isize); 482 truncate_setsize(inode, isize); 483 zi->i_wpoffset = isize; 484 485 unlock: 486 mutex_unlock(&zi->i_truncate_mutex); 487 up_write(&zi->i_mmap_sem); 488 489 return ret; 490 } 491 492 static int zonefs_inode_setattr(struct dentry *dentry, struct iattr *iattr) 493 { 494 struct inode *inode = d_inode(dentry); 495 int ret; 496 497 if (unlikely(IS_IMMUTABLE(inode))) 498 return -EPERM; 499 500 ret = setattr_prepare(dentry, iattr); 501 if (ret) 502 return ret; 503 504 /* 505 * Since files and directories cannot be created nor deleted, do not 506 * allow setting any write attributes on the sub-directories grouping 507 * files by zone type. 508 */ 509 if ((iattr->ia_valid & ATTR_MODE) && S_ISDIR(inode->i_mode) && 510 (iattr->ia_mode & 0222)) 511 return -EPERM; 512 513 if (((iattr->ia_valid & ATTR_UID) && 514 !uid_eq(iattr->ia_uid, inode->i_uid)) || 515 ((iattr->ia_valid & ATTR_GID) && 516 !gid_eq(iattr->ia_gid, inode->i_gid))) { 517 ret = dquot_transfer(inode, iattr); 518 if (ret) 519 return ret; 520 } 521 522 if (iattr->ia_valid & ATTR_SIZE) { 523 ret = zonefs_file_truncate(inode, iattr->ia_size); 524 if (ret) 525 return ret; 526 } 527 528 setattr_copy(inode, iattr); 529 530 return 0; 531 } 532 533 static const struct inode_operations zonefs_file_inode_operations = { 534 .setattr = zonefs_inode_setattr, 535 }; 536 537 static int zonefs_file_fsync(struct file *file, loff_t start, loff_t end, 538 int datasync) 539 { 540 struct inode *inode = file_inode(file); 541 int ret = 0; 542 543 if (unlikely(IS_IMMUTABLE(inode))) 544 return -EPERM; 545 546 /* 547 * Since only direct writes are allowed in sequential files, page cache 548 * flush is needed only for conventional zone files. 549 */ 550 if (ZONEFS_I(inode)->i_ztype == ZONEFS_ZTYPE_CNV) 551 ret = file_write_and_wait_range(file, start, end); 552 if (!ret) 553 ret = blkdev_issue_flush(inode->i_sb->s_bdev); 554 555 if (ret) 556 zonefs_io_error(inode, true); 557 558 return ret; 559 } 560 561 static vm_fault_t zonefs_filemap_fault(struct vm_fault *vmf) 562 { 563 struct zonefs_inode_info *zi = ZONEFS_I(file_inode(vmf->vma->vm_file)); 564 vm_fault_t ret; 565 566 down_read(&zi->i_mmap_sem); 567 ret = filemap_fault(vmf); 568 up_read(&zi->i_mmap_sem); 569 570 return ret; 571 } 572 573 static vm_fault_t zonefs_filemap_page_mkwrite(struct vm_fault *vmf) 574 { 575 struct inode *inode = file_inode(vmf->vma->vm_file); 576 struct zonefs_inode_info *zi = ZONEFS_I(inode); 577 vm_fault_t ret; 578 579 if (unlikely(IS_IMMUTABLE(inode))) 580 return VM_FAULT_SIGBUS; 581 582 /* 583 * Sanity check: only conventional zone files can have shared 584 * writeable mappings. 585 */ 586 if (WARN_ON_ONCE(zi->i_ztype != ZONEFS_ZTYPE_CNV)) 587 return VM_FAULT_NOPAGE; 588 589 sb_start_pagefault(inode->i_sb); 590 file_update_time(vmf->vma->vm_file); 591 592 /* Serialize against truncates */ 593 down_read(&zi->i_mmap_sem); 594 ret = iomap_page_mkwrite(vmf, &zonefs_iomap_ops); 595 up_read(&zi->i_mmap_sem); 596 597 sb_end_pagefault(inode->i_sb); 598 return ret; 599 } 600 601 static const struct vm_operations_struct zonefs_file_vm_ops = { 602 .fault = zonefs_filemap_fault, 603 .map_pages = filemap_map_pages, 604 .page_mkwrite = zonefs_filemap_page_mkwrite, 605 }; 606 607 static int zonefs_file_mmap(struct file *file, struct vm_area_struct *vma) 608 { 609 /* 610 * Conventional zones accept random writes, so their files can support 611 * shared writable mappings. For sequential zone files, only read 612 * mappings are possible since there are no guarantees for write 613 * ordering between msync() and page cache writeback. 614 */ 615 if (ZONEFS_I(file_inode(file))->i_ztype == ZONEFS_ZTYPE_SEQ && 616 (vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_MAYWRITE)) 617 return -EINVAL; 618 619 file_accessed(file); 620 vma->vm_ops = &zonefs_file_vm_ops; 621 622 return 0; 623 } 624 625 static loff_t zonefs_file_llseek(struct file *file, loff_t offset, int whence) 626 { 627 loff_t isize = i_size_read(file_inode(file)); 628 629 /* 630 * Seeks are limited to below the zone size for conventional zones 631 * and below the zone write pointer for sequential zones. In both 632 * cases, this limit is the inode size. 633 */ 634 return generic_file_llseek_size(file, offset, whence, isize, isize); 635 } 636 637 static int zonefs_file_write_dio_end_io(struct kiocb *iocb, ssize_t size, 638 int error, unsigned int flags) 639 { 640 struct inode *inode = file_inode(iocb->ki_filp); 641 struct zonefs_inode_info *zi = ZONEFS_I(inode); 642 643 if (error) { 644 zonefs_io_error(inode, true); 645 return error; 646 } 647 648 if (size && zi->i_ztype != ZONEFS_ZTYPE_CNV) { 649 /* 650 * Note that we may be seeing completions out of order, 651 * but that is not a problem since a write completed 652 * successfully necessarily means that all preceding writes 653 * were also successful. So we can safely increase the inode 654 * size to the write end location. 655 */ 656 mutex_lock(&zi->i_truncate_mutex); 657 if (i_size_read(inode) < iocb->ki_pos + size) { 658 zonefs_update_stats(inode, iocb->ki_pos + size); 659 zonefs_i_size_write(inode, iocb->ki_pos + size); 660 } 661 mutex_unlock(&zi->i_truncate_mutex); 662 } 663 664 return 0; 665 } 666 667 static const struct iomap_dio_ops zonefs_write_dio_ops = { 668 .end_io = zonefs_file_write_dio_end_io, 669 }; 670 671 static ssize_t zonefs_file_dio_append(struct kiocb *iocb, struct iov_iter *from) 672 { 673 struct inode *inode = file_inode(iocb->ki_filp); 674 struct zonefs_inode_info *zi = ZONEFS_I(inode); 675 struct block_device *bdev = inode->i_sb->s_bdev; 676 unsigned int max; 677 struct bio *bio; 678 ssize_t size; 679 int nr_pages; 680 ssize_t ret; 681 682 max = queue_max_zone_append_sectors(bdev_get_queue(bdev)); 683 max = ALIGN_DOWN(max << SECTOR_SHIFT, inode->i_sb->s_blocksize); 684 iov_iter_truncate(from, max); 685 686 nr_pages = iov_iter_npages(from, BIO_MAX_PAGES); 687 if (!nr_pages) 688 return 0; 689 690 bio = bio_alloc(GFP_NOFS, nr_pages); 691 if (!bio) 692 return -ENOMEM; 693 694 bio_set_dev(bio, bdev); 695 bio->bi_iter.bi_sector = zi->i_zsector; 696 bio->bi_write_hint = iocb->ki_hint; 697 bio->bi_ioprio = iocb->ki_ioprio; 698 bio->bi_opf = REQ_OP_ZONE_APPEND | REQ_SYNC | REQ_IDLE; 699 if (iocb->ki_flags & IOCB_DSYNC) 700 bio->bi_opf |= REQ_FUA; 701 702 ret = bio_iov_iter_get_pages(bio, from); 703 if (unlikely(ret)) 704 goto out_release; 705 706 size = bio->bi_iter.bi_size; 707 task_io_account_write(size); 708 709 if (iocb->ki_flags & IOCB_HIPRI) 710 bio_set_polled(bio, iocb); 711 712 ret = submit_bio_wait(bio); 713 714 zonefs_file_write_dio_end_io(iocb, size, ret, 0); 715 trace_zonefs_file_dio_append(inode, size, ret); 716 717 out_release: 718 bio_release_pages(bio, false); 719 bio_put(bio); 720 721 if (ret >= 0) { 722 iocb->ki_pos += size; 723 return size; 724 } 725 726 return ret; 727 } 728 729 /* 730 * Handle direct writes. For sequential zone files, this is the only possible 731 * write path. For these files, check that the user is issuing writes 732 * sequentially from the end of the file. This code assumes that the block layer 733 * delivers write requests to the device in sequential order. This is always the 734 * case if a block IO scheduler implementing the ELEVATOR_F_ZBD_SEQ_WRITE 735 * elevator feature is being used (e.g. mq-deadline). The block layer always 736 * automatically select such an elevator for zoned block devices during the 737 * device initialization. 738 */ 739 static ssize_t zonefs_file_dio_write(struct kiocb *iocb, struct iov_iter *from) 740 { 741 struct inode *inode = file_inode(iocb->ki_filp); 742 struct zonefs_inode_info *zi = ZONEFS_I(inode); 743 struct super_block *sb = inode->i_sb; 744 bool sync = is_sync_kiocb(iocb); 745 bool append = false; 746 size_t count; 747 ssize_t ret; 748 749 /* 750 * For async direct IOs to sequential zone files, refuse IOCB_NOWAIT 751 * as this can cause write reordering (e.g. the first aio gets EAGAIN 752 * on the inode lock but the second goes through but is now unaligned). 753 */ 754 if (zi->i_ztype == ZONEFS_ZTYPE_SEQ && !sync && 755 (iocb->ki_flags & IOCB_NOWAIT)) 756 return -EOPNOTSUPP; 757 758 if (iocb->ki_flags & IOCB_NOWAIT) { 759 if (!inode_trylock(inode)) 760 return -EAGAIN; 761 } else { 762 inode_lock(inode); 763 } 764 765 ret = generic_write_checks(iocb, from); 766 if (ret <= 0) 767 goto inode_unlock; 768 769 iov_iter_truncate(from, zi->i_max_size - iocb->ki_pos); 770 count = iov_iter_count(from); 771 772 if ((iocb->ki_pos | count) & (sb->s_blocksize - 1)) { 773 ret = -EINVAL; 774 goto inode_unlock; 775 } 776 777 /* Enforce sequential writes (append only) in sequential zones */ 778 if (zi->i_ztype == ZONEFS_ZTYPE_SEQ) { 779 mutex_lock(&zi->i_truncate_mutex); 780 if (iocb->ki_pos != zi->i_wpoffset) { 781 mutex_unlock(&zi->i_truncate_mutex); 782 ret = -EINVAL; 783 goto inode_unlock; 784 } 785 mutex_unlock(&zi->i_truncate_mutex); 786 append = sync; 787 } 788 789 if (append) 790 ret = zonefs_file_dio_append(iocb, from); 791 else 792 ret = iomap_dio_rw(iocb, from, &zonefs_iomap_ops, 793 &zonefs_write_dio_ops, 0); 794 if (zi->i_ztype == ZONEFS_ZTYPE_SEQ && 795 (ret > 0 || ret == -EIOCBQUEUED)) { 796 if (ret > 0) 797 count = ret; 798 mutex_lock(&zi->i_truncate_mutex); 799 zi->i_wpoffset += count; 800 mutex_unlock(&zi->i_truncate_mutex); 801 } 802 803 inode_unlock: 804 inode_unlock(inode); 805 806 return ret; 807 } 808 809 static ssize_t zonefs_file_buffered_write(struct kiocb *iocb, 810 struct iov_iter *from) 811 { 812 struct inode *inode = file_inode(iocb->ki_filp); 813 struct zonefs_inode_info *zi = ZONEFS_I(inode); 814 ssize_t ret; 815 816 /* 817 * Direct IO writes are mandatory for sequential zone files so that the 818 * write IO issuing order is preserved. 819 */ 820 if (zi->i_ztype != ZONEFS_ZTYPE_CNV) 821 return -EIO; 822 823 if (iocb->ki_flags & IOCB_NOWAIT) { 824 if (!inode_trylock(inode)) 825 return -EAGAIN; 826 } else { 827 inode_lock(inode); 828 } 829 830 ret = generic_write_checks(iocb, from); 831 if (ret <= 0) 832 goto inode_unlock; 833 834 iov_iter_truncate(from, zi->i_max_size - iocb->ki_pos); 835 836 ret = iomap_file_buffered_write(iocb, from, &zonefs_iomap_ops); 837 if (ret > 0) 838 iocb->ki_pos += ret; 839 else if (ret == -EIO) 840 zonefs_io_error(inode, true); 841 842 inode_unlock: 843 inode_unlock(inode); 844 if (ret > 0) 845 ret = generic_write_sync(iocb, ret); 846 847 return ret; 848 } 849 850 static ssize_t zonefs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) 851 { 852 struct inode *inode = file_inode(iocb->ki_filp); 853 854 if (unlikely(IS_IMMUTABLE(inode))) 855 return -EPERM; 856 857 if (sb_rdonly(inode->i_sb)) 858 return -EROFS; 859 860 /* Write operations beyond the zone size are not allowed */ 861 if (iocb->ki_pos >= ZONEFS_I(inode)->i_max_size) 862 return -EFBIG; 863 864 if (iocb->ki_flags & IOCB_DIRECT) { 865 ssize_t ret = zonefs_file_dio_write(iocb, from); 866 if (ret != -ENOTBLK) 867 return ret; 868 } 869 870 return zonefs_file_buffered_write(iocb, from); 871 } 872 873 static int zonefs_file_read_dio_end_io(struct kiocb *iocb, ssize_t size, 874 int error, unsigned int flags) 875 { 876 if (error) { 877 zonefs_io_error(file_inode(iocb->ki_filp), false); 878 return error; 879 } 880 881 return 0; 882 } 883 884 static const struct iomap_dio_ops zonefs_read_dio_ops = { 885 .end_io = zonefs_file_read_dio_end_io, 886 }; 887 888 static ssize_t zonefs_file_read_iter(struct kiocb *iocb, struct iov_iter *to) 889 { 890 struct inode *inode = file_inode(iocb->ki_filp); 891 struct zonefs_inode_info *zi = ZONEFS_I(inode); 892 struct super_block *sb = inode->i_sb; 893 loff_t isize; 894 ssize_t ret; 895 896 /* Offline zones cannot be read */ 897 if (unlikely(IS_IMMUTABLE(inode) && !(inode->i_mode & 0777))) 898 return -EPERM; 899 900 if (iocb->ki_pos >= zi->i_max_size) 901 return 0; 902 903 if (iocb->ki_flags & IOCB_NOWAIT) { 904 if (!inode_trylock_shared(inode)) 905 return -EAGAIN; 906 } else { 907 inode_lock_shared(inode); 908 } 909 910 /* Limit read operations to written data */ 911 mutex_lock(&zi->i_truncate_mutex); 912 isize = i_size_read(inode); 913 if (iocb->ki_pos >= isize) { 914 mutex_unlock(&zi->i_truncate_mutex); 915 ret = 0; 916 goto inode_unlock; 917 } 918 iov_iter_truncate(to, isize - iocb->ki_pos); 919 mutex_unlock(&zi->i_truncate_mutex); 920 921 if (iocb->ki_flags & IOCB_DIRECT) { 922 size_t count = iov_iter_count(to); 923 924 if ((iocb->ki_pos | count) & (sb->s_blocksize - 1)) { 925 ret = -EINVAL; 926 goto inode_unlock; 927 } 928 file_accessed(iocb->ki_filp); 929 ret = iomap_dio_rw(iocb, to, &zonefs_iomap_ops, 930 &zonefs_read_dio_ops, 0); 931 } else { 932 ret = generic_file_read_iter(iocb, to); 933 if (ret == -EIO) 934 zonefs_io_error(inode, false); 935 } 936 937 inode_unlock: 938 inode_unlock_shared(inode); 939 940 return ret; 941 } 942 943 static inline bool zonefs_file_use_exp_open(struct inode *inode, struct file *file) 944 { 945 struct zonefs_inode_info *zi = ZONEFS_I(inode); 946 struct zonefs_sb_info *sbi = ZONEFS_SB(inode->i_sb); 947 948 if (!(sbi->s_mount_opts & ZONEFS_MNTOPT_EXPLICIT_OPEN)) 949 return false; 950 951 if (zi->i_ztype != ZONEFS_ZTYPE_SEQ) 952 return false; 953 954 if (!(file->f_mode & FMODE_WRITE)) 955 return false; 956 957 return true; 958 } 959 960 static int zonefs_open_zone(struct inode *inode) 961 { 962 struct zonefs_inode_info *zi = ZONEFS_I(inode); 963 struct zonefs_sb_info *sbi = ZONEFS_SB(inode->i_sb); 964 int ret = 0; 965 966 mutex_lock(&zi->i_truncate_mutex); 967 968 zi->i_wr_refcnt++; 969 if (zi->i_wr_refcnt == 1) { 970 971 if (atomic_inc_return(&sbi->s_open_zones) > sbi->s_max_open_zones) { 972 atomic_dec(&sbi->s_open_zones); 973 ret = -EBUSY; 974 goto unlock; 975 } 976 977 if (i_size_read(inode) < zi->i_max_size) { 978 ret = zonefs_zone_mgmt(inode, REQ_OP_ZONE_OPEN); 979 if (ret) { 980 zi->i_wr_refcnt--; 981 atomic_dec(&sbi->s_open_zones); 982 goto unlock; 983 } 984 zi->i_flags |= ZONEFS_ZONE_OPEN; 985 } 986 } 987 988 unlock: 989 mutex_unlock(&zi->i_truncate_mutex); 990 991 return ret; 992 } 993 994 static int zonefs_file_open(struct inode *inode, struct file *file) 995 { 996 int ret; 997 998 ret = generic_file_open(inode, file); 999 if (ret) 1000 return ret; 1001 1002 if (zonefs_file_use_exp_open(inode, file)) 1003 return zonefs_open_zone(inode); 1004 1005 return 0; 1006 } 1007 1008 static void zonefs_close_zone(struct inode *inode) 1009 { 1010 struct zonefs_inode_info *zi = ZONEFS_I(inode); 1011 int ret = 0; 1012 1013 mutex_lock(&zi->i_truncate_mutex); 1014 zi->i_wr_refcnt--; 1015 if (!zi->i_wr_refcnt) { 1016 struct zonefs_sb_info *sbi = ZONEFS_SB(inode->i_sb); 1017 struct super_block *sb = inode->i_sb; 1018 1019 /* 1020 * If the file zone is full, it is not open anymore and we only 1021 * need to decrement the open count. 1022 */ 1023 if (!(zi->i_flags & ZONEFS_ZONE_OPEN)) 1024 goto dec; 1025 1026 ret = zonefs_zone_mgmt(inode, REQ_OP_ZONE_CLOSE); 1027 if (ret) { 1028 __zonefs_io_error(inode, false); 1029 /* 1030 * Leaving zones explicitly open may lead to a state 1031 * where most zones cannot be written (zone resources 1032 * exhausted). So take preventive action by remounting 1033 * read-only. 1034 */ 1035 if (zi->i_flags & ZONEFS_ZONE_OPEN && 1036 !(sb->s_flags & SB_RDONLY)) { 1037 zonefs_warn(sb, "closing zone failed, remounting filesystem read-only\n"); 1038 sb->s_flags |= SB_RDONLY; 1039 } 1040 } 1041 zi->i_flags &= ~ZONEFS_ZONE_OPEN; 1042 dec: 1043 atomic_dec(&sbi->s_open_zones); 1044 } 1045 mutex_unlock(&zi->i_truncate_mutex); 1046 } 1047 1048 static int zonefs_file_release(struct inode *inode, struct file *file) 1049 { 1050 /* 1051 * If we explicitly open a zone we must close it again as well, but the 1052 * zone management operation can fail (either due to an IO error or as 1053 * the zone has gone offline or read-only). Make sure we don't fail the 1054 * close(2) for user-space. 1055 */ 1056 if (zonefs_file_use_exp_open(inode, file)) 1057 zonefs_close_zone(inode); 1058 1059 return 0; 1060 } 1061 1062 static const struct file_operations zonefs_file_operations = { 1063 .open = zonefs_file_open, 1064 .release = zonefs_file_release, 1065 .fsync = zonefs_file_fsync, 1066 .mmap = zonefs_file_mmap, 1067 .llseek = zonefs_file_llseek, 1068 .read_iter = zonefs_file_read_iter, 1069 .write_iter = zonefs_file_write_iter, 1070 .splice_read = generic_file_splice_read, 1071 .splice_write = iter_file_splice_write, 1072 .iopoll = iomap_dio_iopoll, 1073 }; 1074 1075 static struct kmem_cache *zonefs_inode_cachep; 1076 1077 static struct inode *zonefs_alloc_inode(struct super_block *sb) 1078 { 1079 struct zonefs_inode_info *zi; 1080 1081 zi = kmem_cache_alloc(zonefs_inode_cachep, GFP_KERNEL); 1082 if (!zi) 1083 return NULL; 1084 1085 inode_init_once(&zi->i_vnode); 1086 mutex_init(&zi->i_truncate_mutex); 1087 init_rwsem(&zi->i_mmap_sem); 1088 zi->i_wr_refcnt = 0; 1089 1090 return &zi->i_vnode; 1091 } 1092 1093 static void zonefs_free_inode(struct inode *inode) 1094 { 1095 kmem_cache_free(zonefs_inode_cachep, ZONEFS_I(inode)); 1096 } 1097 1098 /* 1099 * File system stat. 1100 */ 1101 static int zonefs_statfs(struct dentry *dentry, struct kstatfs *buf) 1102 { 1103 struct super_block *sb = dentry->d_sb; 1104 struct zonefs_sb_info *sbi = ZONEFS_SB(sb); 1105 enum zonefs_ztype t; 1106 u64 fsid; 1107 1108 buf->f_type = ZONEFS_MAGIC; 1109 buf->f_bsize = sb->s_blocksize; 1110 buf->f_namelen = ZONEFS_NAME_MAX; 1111 1112 spin_lock(&sbi->s_lock); 1113 1114 buf->f_blocks = sbi->s_blocks; 1115 if (WARN_ON(sbi->s_used_blocks > sbi->s_blocks)) 1116 buf->f_bfree = 0; 1117 else 1118 buf->f_bfree = buf->f_blocks - sbi->s_used_blocks; 1119 buf->f_bavail = buf->f_bfree; 1120 1121 for (t = 0; t < ZONEFS_ZTYPE_MAX; t++) { 1122 if (sbi->s_nr_files[t]) 1123 buf->f_files += sbi->s_nr_files[t] + 1; 1124 } 1125 buf->f_ffree = 0; 1126 1127 spin_unlock(&sbi->s_lock); 1128 1129 fsid = le64_to_cpup((void *)sbi->s_uuid.b) ^ 1130 le64_to_cpup((void *)sbi->s_uuid.b + sizeof(u64)); 1131 buf->f_fsid = u64_to_fsid(fsid); 1132 1133 return 0; 1134 } 1135 1136 enum { 1137 Opt_errors_ro, Opt_errors_zro, Opt_errors_zol, Opt_errors_repair, 1138 Opt_explicit_open, Opt_err, 1139 }; 1140 1141 static const match_table_t tokens = { 1142 { Opt_errors_ro, "errors=remount-ro"}, 1143 { Opt_errors_zro, "errors=zone-ro"}, 1144 { Opt_errors_zol, "errors=zone-offline"}, 1145 { Opt_errors_repair, "errors=repair"}, 1146 { Opt_explicit_open, "explicit-open" }, 1147 { Opt_err, NULL} 1148 }; 1149 1150 static int zonefs_parse_options(struct super_block *sb, char *options) 1151 { 1152 struct zonefs_sb_info *sbi = ZONEFS_SB(sb); 1153 substring_t args[MAX_OPT_ARGS]; 1154 char *p; 1155 1156 if (!options) 1157 return 0; 1158 1159 while ((p = strsep(&options, ",")) != NULL) { 1160 int token; 1161 1162 if (!*p) 1163 continue; 1164 1165 token = match_token(p, tokens, args); 1166 switch (token) { 1167 case Opt_errors_ro: 1168 sbi->s_mount_opts &= ~ZONEFS_MNTOPT_ERRORS_MASK; 1169 sbi->s_mount_opts |= ZONEFS_MNTOPT_ERRORS_RO; 1170 break; 1171 case Opt_errors_zro: 1172 sbi->s_mount_opts &= ~ZONEFS_MNTOPT_ERRORS_MASK; 1173 sbi->s_mount_opts |= ZONEFS_MNTOPT_ERRORS_ZRO; 1174 break; 1175 case Opt_errors_zol: 1176 sbi->s_mount_opts &= ~ZONEFS_MNTOPT_ERRORS_MASK; 1177 sbi->s_mount_opts |= ZONEFS_MNTOPT_ERRORS_ZOL; 1178 break; 1179 case Opt_errors_repair: 1180 sbi->s_mount_opts &= ~ZONEFS_MNTOPT_ERRORS_MASK; 1181 sbi->s_mount_opts |= ZONEFS_MNTOPT_ERRORS_REPAIR; 1182 break; 1183 case Opt_explicit_open: 1184 sbi->s_mount_opts |= ZONEFS_MNTOPT_EXPLICIT_OPEN; 1185 break; 1186 default: 1187 return -EINVAL; 1188 } 1189 } 1190 1191 return 0; 1192 } 1193 1194 static int zonefs_show_options(struct seq_file *seq, struct dentry *root) 1195 { 1196 struct zonefs_sb_info *sbi = ZONEFS_SB(root->d_sb); 1197 1198 if (sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_RO) 1199 seq_puts(seq, ",errors=remount-ro"); 1200 if (sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_ZRO) 1201 seq_puts(seq, ",errors=zone-ro"); 1202 if (sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_ZOL) 1203 seq_puts(seq, ",errors=zone-offline"); 1204 if (sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_REPAIR) 1205 seq_puts(seq, ",errors=repair"); 1206 1207 return 0; 1208 } 1209 1210 static int zonefs_remount(struct super_block *sb, int *flags, char *data) 1211 { 1212 sync_filesystem(sb); 1213 1214 return zonefs_parse_options(sb, data); 1215 } 1216 1217 static const struct super_operations zonefs_sops = { 1218 .alloc_inode = zonefs_alloc_inode, 1219 .free_inode = zonefs_free_inode, 1220 .statfs = zonefs_statfs, 1221 .remount_fs = zonefs_remount, 1222 .show_options = zonefs_show_options, 1223 }; 1224 1225 static const struct inode_operations zonefs_dir_inode_operations = { 1226 .lookup = simple_lookup, 1227 .setattr = zonefs_inode_setattr, 1228 }; 1229 1230 static void zonefs_init_dir_inode(struct inode *parent, struct inode *inode, 1231 enum zonefs_ztype type) 1232 { 1233 struct super_block *sb = parent->i_sb; 1234 1235 inode->i_ino = blkdev_nr_zones(sb->s_bdev->bd_disk) + type + 1; 1236 inode_init_owner(inode, parent, S_IFDIR | 0555); 1237 inode->i_op = &zonefs_dir_inode_operations; 1238 inode->i_fop = &simple_dir_operations; 1239 set_nlink(inode, 2); 1240 inc_nlink(parent); 1241 } 1242 1243 static void zonefs_init_file_inode(struct inode *inode, struct blk_zone *zone, 1244 enum zonefs_ztype type) 1245 { 1246 struct super_block *sb = inode->i_sb; 1247 struct zonefs_sb_info *sbi = ZONEFS_SB(sb); 1248 struct zonefs_inode_info *zi = ZONEFS_I(inode); 1249 1250 inode->i_ino = zone->start >> sbi->s_zone_sectors_shift; 1251 inode->i_mode = S_IFREG | sbi->s_perm; 1252 1253 zi->i_ztype = type; 1254 zi->i_zsector = zone->start; 1255 zi->i_zone_size = zone->len << SECTOR_SHIFT; 1256 1257 zi->i_max_size = min_t(loff_t, MAX_LFS_FILESIZE, 1258 zone->capacity << SECTOR_SHIFT); 1259 zi->i_wpoffset = zonefs_check_zone_condition(inode, zone, true, true); 1260 1261 inode->i_uid = sbi->s_uid; 1262 inode->i_gid = sbi->s_gid; 1263 inode->i_size = zi->i_wpoffset; 1264 inode->i_blocks = zi->i_max_size >> SECTOR_SHIFT; 1265 1266 inode->i_op = &zonefs_file_inode_operations; 1267 inode->i_fop = &zonefs_file_operations; 1268 inode->i_mapping->a_ops = &zonefs_file_aops; 1269 1270 sb->s_maxbytes = max(zi->i_max_size, sb->s_maxbytes); 1271 sbi->s_blocks += zi->i_max_size >> sb->s_blocksize_bits; 1272 sbi->s_used_blocks += zi->i_wpoffset >> sb->s_blocksize_bits; 1273 } 1274 1275 static struct dentry *zonefs_create_inode(struct dentry *parent, 1276 const char *name, struct blk_zone *zone, 1277 enum zonefs_ztype type) 1278 { 1279 struct inode *dir = d_inode(parent); 1280 struct dentry *dentry; 1281 struct inode *inode; 1282 1283 dentry = d_alloc_name(parent, name); 1284 if (!dentry) 1285 return NULL; 1286 1287 inode = new_inode(parent->d_sb); 1288 if (!inode) 1289 goto dput; 1290 1291 inode->i_ctime = inode->i_mtime = inode->i_atime = dir->i_ctime; 1292 if (zone) 1293 zonefs_init_file_inode(inode, zone, type); 1294 else 1295 zonefs_init_dir_inode(dir, inode, type); 1296 d_add(dentry, inode); 1297 dir->i_size++; 1298 1299 return dentry; 1300 1301 dput: 1302 dput(dentry); 1303 1304 return NULL; 1305 } 1306 1307 struct zonefs_zone_data { 1308 struct super_block *sb; 1309 unsigned int nr_zones[ZONEFS_ZTYPE_MAX]; 1310 struct blk_zone *zones; 1311 }; 1312 1313 /* 1314 * Create a zone group and populate it with zone files. 1315 */ 1316 static int zonefs_create_zgroup(struct zonefs_zone_data *zd, 1317 enum zonefs_ztype type) 1318 { 1319 struct super_block *sb = zd->sb; 1320 struct zonefs_sb_info *sbi = ZONEFS_SB(sb); 1321 struct blk_zone *zone, *next, *end; 1322 const char *zgroup_name; 1323 char *file_name; 1324 struct dentry *dir; 1325 unsigned int n = 0; 1326 int ret; 1327 1328 /* If the group is empty, there is nothing to do */ 1329 if (!zd->nr_zones[type]) 1330 return 0; 1331 1332 file_name = kmalloc(ZONEFS_NAME_MAX, GFP_KERNEL); 1333 if (!file_name) 1334 return -ENOMEM; 1335 1336 if (type == ZONEFS_ZTYPE_CNV) 1337 zgroup_name = "cnv"; 1338 else 1339 zgroup_name = "seq"; 1340 1341 dir = zonefs_create_inode(sb->s_root, zgroup_name, NULL, type); 1342 if (!dir) { 1343 ret = -ENOMEM; 1344 goto free; 1345 } 1346 1347 /* 1348 * The first zone contains the super block: skip it. 1349 */ 1350 end = zd->zones + blkdev_nr_zones(sb->s_bdev->bd_disk); 1351 for (zone = &zd->zones[1]; zone < end; zone = next) { 1352 1353 next = zone + 1; 1354 if (zonefs_zone_type(zone) != type) 1355 continue; 1356 1357 /* 1358 * For conventional zones, contiguous zones can be aggregated 1359 * together to form larger files. Note that this overwrites the 1360 * length of the first zone of the set of contiguous zones 1361 * aggregated together. If one offline or read-only zone is 1362 * found, assume that all zones aggregated have the same 1363 * condition. 1364 */ 1365 if (type == ZONEFS_ZTYPE_CNV && 1366 (sbi->s_features & ZONEFS_F_AGGRCNV)) { 1367 for (; next < end; next++) { 1368 if (zonefs_zone_type(next) != type) 1369 break; 1370 zone->len += next->len; 1371 zone->capacity += next->capacity; 1372 if (next->cond == BLK_ZONE_COND_READONLY && 1373 zone->cond != BLK_ZONE_COND_OFFLINE) 1374 zone->cond = BLK_ZONE_COND_READONLY; 1375 else if (next->cond == BLK_ZONE_COND_OFFLINE) 1376 zone->cond = BLK_ZONE_COND_OFFLINE; 1377 } 1378 if (zone->capacity != zone->len) { 1379 zonefs_err(sb, "Invalid conventional zone capacity\n"); 1380 ret = -EINVAL; 1381 goto free; 1382 } 1383 } 1384 1385 /* 1386 * Use the file number within its group as file name. 1387 */ 1388 snprintf(file_name, ZONEFS_NAME_MAX - 1, "%u", n); 1389 if (!zonefs_create_inode(dir, file_name, zone, type)) { 1390 ret = -ENOMEM; 1391 goto free; 1392 } 1393 1394 n++; 1395 } 1396 1397 zonefs_info(sb, "Zone group \"%s\" has %u file%s\n", 1398 zgroup_name, n, n > 1 ? "s" : ""); 1399 1400 sbi->s_nr_files[type] = n; 1401 ret = 0; 1402 1403 free: 1404 kfree(file_name); 1405 1406 return ret; 1407 } 1408 1409 static int zonefs_get_zone_info_cb(struct blk_zone *zone, unsigned int idx, 1410 void *data) 1411 { 1412 struct zonefs_zone_data *zd = data; 1413 1414 /* 1415 * Count the number of usable zones: the first zone at index 0 contains 1416 * the super block and is ignored. 1417 */ 1418 switch (zone->type) { 1419 case BLK_ZONE_TYPE_CONVENTIONAL: 1420 zone->wp = zone->start + zone->len; 1421 if (idx) 1422 zd->nr_zones[ZONEFS_ZTYPE_CNV]++; 1423 break; 1424 case BLK_ZONE_TYPE_SEQWRITE_REQ: 1425 case BLK_ZONE_TYPE_SEQWRITE_PREF: 1426 if (idx) 1427 zd->nr_zones[ZONEFS_ZTYPE_SEQ]++; 1428 break; 1429 default: 1430 zonefs_err(zd->sb, "Unsupported zone type 0x%x\n", 1431 zone->type); 1432 return -EIO; 1433 } 1434 1435 memcpy(&zd->zones[idx], zone, sizeof(struct blk_zone)); 1436 1437 return 0; 1438 } 1439 1440 static int zonefs_get_zone_info(struct zonefs_zone_data *zd) 1441 { 1442 struct block_device *bdev = zd->sb->s_bdev; 1443 int ret; 1444 1445 zd->zones = kvcalloc(blkdev_nr_zones(bdev->bd_disk), 1446 sizeof(struct blk_zone), GFP_KERNEL); 1447 if (!zd->zones) 1448 return -ENOMEM; 1449 1450 /* Get zones information from the device */ 1451 ret = blkdev_report_zones(bdev, 0, BLK_ALL_ZONES, 1452 zonefs_get_zone_info_cb, zd); 1453 if (ret < 0) { 1454 zonefs_err(zd->sb, "Zone report failed %d\n", ret); 1455 return ret; 1456 } 1457 1458 if (ret != blkdev_nr_zones(bdev->bd_disk)) { 1459 zonefs_err(zd->sb, "Invalid zone report (%d/%u zones)\n", 1460 ret, blkdev_nr_zones(bdev->bd_disk)); 1461 return -EIO; 1462 } 1463 1464 return 0; 1465 } 1466 1467 static inline void zonefs_cleanup_zone_info(struct zonefs_zone_data *zd) 1468 { 1469 kvfree(zd->zones); 1470 } 1471 1472 /* 1473 * Read super block information from the device. 1474 */ 1475 static int zonefs_read_super(struct super_block *sb) 1476 { 1477 struct zonefs_sb_info *sbi = ZONEFS_SB(sb); 1478 struct zonefs_super *super; 1479 u32 crc, stored_crc; 1480 struct page *page; 1481 struct bio_vec bio_vec; 1482 struct bio bio; 1483 int ret; 1484 1485 page = alloc_page(GFP_KERNEL); 1486 if (!page) 1487 return -ENOMEM; 1488 1489 bio_init(&bio, &bio_vec, 1); 1490 bio.bi_iter.bi_sector = 0; 1491 bio.bi_opf = REQ_OP_READ; 1492 bio_set_dev(&bio, sb->s_bdev); 1493 bio_add_page(&bio, page, PAGE_SIZE, 0); 1494 1495 ret = submit_bio_wait(&bio); 1496 if (ret) 1497 goto free_page; 1498 1499 super = kmap(page); 1500 1501 ret = -EINVAL; 1502 if (le32_to_cpu(super->s_magic) != ZONEFS_MAGIC) 1503 goto unmap; 1504 1505 stored_crc = le32_to_cpu(super->s_crc); 1506 super->s_crc = 0; 1507 crc = crc32(~0U, (unsigned char *)super, sizeof(struct zonefs_super)); 1508 if (crc != stored_crc) { 1509 zonefs_err(sb, "Invalid checksum (Expected 0x%08x, got 0x%08x)", 1510 crc, stored_crc); 1511 goto unmap; 1512 } 1513 1514 sbi->s_features = le64_to_cpu(super->s_features); 1515 if (sbi->s_features & ~ZONEFS_F_DEFINED_FEATURES) { 1516 zonefs_err(sb, "Unknown features set 0x%llx\n", 1517 sbi->s_features); 1518 goto unmap; 1519 } 1520 1521 if (sbi->s_features & ZONEFS_F_UID) { 1522 sbi->s_uid = make_kuid(current_user_ns(), 1523 le32_to_cpu(super->s_uid)); 1524 if (!uid_valid(sbi->s_uid)) { 1525 zonefs_err(sb, "Invalid UID feature\n"); 1526 goto unmap; 1527 } 1528 } 1529 1530 if (sbi->s_features & ZONEFS_F_GID) { 1531 sbi->s_gid = make_kgid(current_user_ns(), 1532 le32_to_cpu(super->s_gid)); 1533 if (!gid_valid(sbi->s_gid)) { 1534 zonefs_err(sb, "Invalid GID feature\n"); 1535 goto unmap; 1536 } 1537 } 1538 1539 if (sbi->s_features & ZONEFS_F_PERM) 1540 sbi->s_perm = le32_to_cpu(super->s_perm); 1541 1542 if (memchr_inv(super->s_reserved, 0, sizeof(super->s_reserved))) { 1543 zonefs_err(sb, "Reserved area is being used\n"); 1544 goto unmap; 1545 } 1546 1547 import_uuid(&sbi->s_uuid, super->s_uuid); 1548 ret = 0; 1549 1550 unmap: 1551 kunmap(page); 1552 free_page: 1553 __free_page(page); 1554 1555 return ret; 1556 } 1557 1558 /* 1559 * Check that the device is zoned. If it is, get the list of zones and create 1560 * sub-directories and files according to the device zone configuration and 1561 * format options. 1562 */ 1563 static int zonefs_fill_super(struct super_block *sb, void *data, int silent) 1564 { 1565 struct zonefs_zone_data zd; 1566 struct zonefs_sb_info *sbi; 1567 struct inode *inode; 1568 enum zonefs_ztype t; 1569 int ret; 1570 1571 if (!bdev_is_zoned(sb->s_bdev)) { 1572 zonefs_err(sb, "Not a zoned block device\n"); 1573 return -EINVAL; 1574 } 1575 1576 /* 1577 * Initialize super block information: the maximum file size is updated 1578 * when the zone files are created so that the format option 1579 * ZONEFS_F_AGGRCNV which increases the maximum file size of a file 1580 * beyond the zone size is taken into account. 1581 */ 1582 sbi = kzalloc(sizeof(*sbi), GFP_KERNEL); 1583 if (!sbi) 1584 return -ENOMEM; 1585 1586 spin_lock_init(&sbi->s_lock); 1587 sb->s_fs_info = sbi; 1588 sb->s_magic = ZONEFS_MAGIC; 1589 sb->s_maxbytes = 0; 1590 sb->s_op = &zonefs_sops; 1591 sb->s_time_gran = 1; 1592 1593 /* 1594 * The block size is set to the device zone write granularity to ensure 1595 * that write operations are always aligned according to the device 1596 * interface constraints. 1597 */ 1598 sb_set_blocksize(sb, bdev_zone_write_granularity(sb->s_bdev)); 1599 sbi->s_zone_sectors_shift = ilog2(bdev_zone_sectors(sb->s_bdev)); 1600 sbi->s_uid = GLOBAL_ROOT_UID; 1601 sbi->s_gid = GLOBAL_ROOT_GID; 1602 sbi->s_perm = 0640; 1603 sbi->s_mount_opts = ZONEFS_MNTOPT_ERRORS_RO; 1604 sbi->s_max_open_zones = bdev_max_open_zones(sb->s_bdev); 1605 atomic_set(&sbi->s_open_zones, 0); 1606 if (!sbi->s_max_open_zones && 1607 sbi->s_mount_opts & ZONEFS_MNTOPT_EXPLICIT_OPEN) { 1608 zonefs_info(sb, "No open zones limit. Ignoring explicit_open mount option\n"); 1609 sbi->s_mount_opts &= ~ZONEFS_MNTOPT_EXPLICIT_OPEN; 1610 } 1611 1612 ret = zonefs_read_super(sb); 1613 if (ret) 1614 return ret; 1615 1616 ret = zonefs_parse_options(sb, data); 1617 if (ret) 1618 return ret; 1619 1620 memset(&zd, 0, sizeof(struct zonefs_zone_data)); 1621 zd.sb = sb; 1622 ret = zonefs_get_zone_info(&zd); 1623 if (ret) 1624 goto cleanup; 1625 1626 zonefs_info(sb, "Mounting %u zones", 1627 blkdev_nr_zones(sb->s_bdev->bd_disk)); 1628 1629 /* Create root directory inode */ 1630 ret = -ENOMEM; 1631 inode = new_inode(sb); 1632 if (!inode) 1633 goto cleanup; 1634 1635 inode->i_ino = blkdev_nr_zones(sb->s_bdev->bd_disk); 1636 inode->i_mode = S_IFDIR | 0555; 1637 inode->i_ctime = inode->i_mtime = inode->i_atime = current_time(inode); 1638 inode->i_op = &zonefs_dir_inode_operations; 1639 inode->i_fop = &simple_dir_operations; 1640 set_nlink(inode, 2); 1641 1642 sb->s_root = d_make_root(inode); 1643 if (!sb->s_root) 1644 goto cleanup; 1645 1646 /* Create and populate files in zone groups directories */ 1647 for (t = 0; t < ZONEFS_ZTYPE_MAX; t++) { 1648 ret = zonefs_create_zgroup(&zd, t); 1649 if (ret) 1650 break; 1651 } 1652 1653 cleanup: 1654 zonefs_cleanup_zone_info(&zd); 1655 1656 return ret; 1657 } 1658 1659 static struct dentry *zonefs_mount(struct file_system_type *fs_type, 1660 int flags, const char *dev_name, void *data) 1661 { 1662 return mount_bdev(fs_type, flags, dev_name, data, zonefs_fill_super); 1663 } 1664 1665 static void zonefs_kill_super(struct super_block *sb) 1666 { 1667 struct zonefs_sb_info *sbi = ZONEFS_SB(sb); 1668 1669 if (sb->s_root) 1670 d_genocide(sb->s_root); 1671 kill_block_super(sb); 1672 kfree(sbi); 1673 } 1674 1675 /* 1676 * File system definition and registration. 1677 */ 1678 static struct file_system_type zonefs_type = { 1679 .owner = THIS_MODULE, 1680 .name = "zonefs", 1681 .mount = zonefs_mount, 1682 .kill_sb = zonefs_kill_super, 1683 .fs_flags = FS_REQUIRES_DEV, 1684 }; 1685 1686 static int __init zonefs_init_inodecache(void) 1687 { 1688 zonefs_inode_cachep = kmem_cache_create("zonefs_inode_cache", 1689 sizeof(struct zonefs_inode_info), 0, 1690 (SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD | SLAB_ACCOUNT), 1691 NULL); 1692 if (zonefs_inode_cachep == NULL) 1693 return -ENOMEM; 1694 return 0; 1695 } 1696 1697 static void zonefs_destroy_inodecache(void) 1698 { 1699 /* 1700 * Make sure all delayed rcu free inodes are flushed before we 1701 * destroy the inode cache. 1702 */ 1703 rcu_barrier(); 1704 kmem_cache_destroy(zonefs_inode_cachep); 1705 } 1706 1707 static int __init zonefs_init(void) 1708 { 1709 int ret; 1710 1711 BUILD_BUG_ON(sizeof(struct zonefs_super) != ZONEFS_SUPER_SIZE); 1712 1713 ret = zonefs_init_inodecache(); 1714 if (ret) 1715 return ret; 1716 1717 ret = register_filesystem(&zonefs_type); 1718 if (ret) { 1719 zonefs_destroy_inodecache(); 1720 return ret; 1721 } 1722 1723 return 0; 1724 } 1725 1726 static void __exit zonefs_exit(void) 1727 { 1728 zonefs_destroy_inodecache(); 1729 unregister_filesystem(&zonefs_type); 1730 } 1731 1732 MODULE_AUTHOR("Damien Le Moal"); 1733 MODULE_DESCRIPTION("Zone file system for zoned block devices"); 1734 MODULE_LICENSE("GPL"); 1735 module_init(zonefs_init); 1736 module_exit(zonefs_exit); 1737