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