1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | /* |
3 | * Simple zone file system for zoned block devices. |
4 | * |
5 | * Copyright (C) 2019 Western Digital Corporation or its affiliates. |
6 | */ |
7 | #ifndef __ZONEFS_H__ |
8 | #define __ZONEFS_H__ |
9 | |
10 | #include <linux/fs.h> |
11 | #include <linux/magic.h> |
12 | #include <linux/uuid.h> |
13 | #include <linux/mutex.h> |
14 | #include <linux/rwsem.h> |
15 | #include <linux/kobject.h> |
16 | |
17 | /* |
18 | * Maximum length of file names: this only needs to be large enough to fit |
19 | * the zone group directory names and a decimal zone number for file names. |
20 | * 16 characters is plenty. |
21 | */ |
22 | #define ZONEFS_NAME_MAX 16 |
23 | |
24 | /* |
25 | * Zone types: ZONEFS_ZTYPE_SEQ is used for all sequential zone types |
26 | * defined in linux/blkzoned.h, that is, BLK_ZONE_TYPE_SEQWRITE_REQ and |
27 | * BLK_ZONE_TYPE_SEQWRITE_PREF. |
28 | */ |
29 | enum zonefs_ztype { |
30 | ZONEFS_ZTYPE_CNV, |
31 | ZONEFS_ZTYPE_SEQ, |
32 | ZONEFS_ZTYPE_MAX, |
33 | }; |
34 | |
35 | static inline enum zonefs_ztype zonefs_zone_type(struct blk_zone *zone) |
36 | { |
37 | if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL) |
38 | return ZONEFS_ZTYPE_CNV; |
39 | return ZONEFS_ZTYPE_SEQ; |
40 | } |
41 | |
42 | #define ZONEFS_ZONE_INIT_MODE (1U << 0) |
43 | #define ZONEFS_ZONE_OPEN (1U << 1) |
44 | #define ZONEFS_ZONE_ACTIVE (1U << 2) |
45 | #define ZONEFS_ZONE_OFFLINE (1U << 3) |
46 | #define ZONEFS_ZONE_READONLY (1U << 4) |
47 | #define ZONEFS_ZONE_CNV (1U << 31) |
48 | |
49 | /* |
50 | * In-memory per-file inode zone data. |
51 | */ |
52 | struct zonefs_zone { |
53 | /* Zone state flags */ |
54 | unsigned int z_flags; |
55 | |
56 | /* Zone start sector (512B unit) */ |
57 | sector_t z_sector; |
58 | |
59 | /* Zone size (bytes) */ |
60 | loff_t z_size; |
61 | |
62 | /* Zone capacity (file maximum size, bytes) */ |
63 | loff_t z_capacity; |
64 | |
65 | /* Write pointer offset in the zone (sequential zones only, bytes) */ |
66 | loff_t z_wpoffset; |
67 | |
68 | /* Saved inode uid, gid and access rights */ |
69 | umode_t z_mode; |
70 | kuid_t z_uid; |
71 | kgid_t z_gid; |
72 | }; |
73 | |
74 | /* |
75 | * In memory zone group information: all zones of a group are exposed |
76 | * as files, one file per zone. |
77 | */ |
78 | struct zonefs_zone_group { |
79 | struct inode *g_inode; |
80 | unsigned int g_nr_zones; |
81 | struct zonefs_zone *g_zones; |
82 | }; |
83 | |
84 | /* |
85 | * In-memory inode data. |
86 | */ |
87 | struct zonefs_inode_info { |
88 | struct inode i_vnode; |
89 | |
90 | /* |
91 | * To serialise fully against both syscall and mmap based IO and |
92 | * sequential file truncation, two locks are used. For serializing |
93 | * zonefs_seq_file_truncate() against zonefs_iomap_begin(), that is, |
94 | * file truncate operations against block mapping, i_truncate_mutex is |
95 | * used. i_truncate_mutex also protects against concurrent accesses |
96 | * and changes to the inode private data, and in particular changes to |
97 | * a sequential file size on completion of direct IO writes. |
98 | * Serialization of mmap read IOs with truncate and syscall IO |
99 | * operations is done with invalidate_lock in addition to |
100 | * i_truncate_mutex. Only zonefs_seq_file_truncate() takes both lock |
101 | * (invalidate_lock first, i_truncate_mutex second). |
102 | */ |
103 | struct mutex i_truncate_mutex; |
104 | |
105 | /* guarded by i_truncate_mutex */ |
106 | unsigned int i_wr_refcnt; |
107 | }; |
108 | |
109 | static inline struct zonefs_inode_info *ZONEFS_I(struct inode *inode) |
110 | { |
111 | return container_of(inode, struct zonefs_inode_info, i_vnode); |
112 | } |
113 | |
114 | static inline bool zonefs_zone_is_cnv(struct zonefs_zone *z) |
115 | { |
116 | return z->z_flags & ZONEFS_ZONE_CNV; |
117 | } |
118 | |
119 | static inline bool zonefs_zone_is_seq(struct zonefs_zone *z) |
120 | { |
121 | return !zonefs_zone_is_cnv(z); |
122 | } |
123 | |
124 | static inline struct zonefs_zone *zonefs_inode_zone(struct inode *inode) |
125 | { |
126 | return inode->i_private; |
127 | } |
128 | |
129 | static inline bool zonefs_inode_is_cnv(struct inode *inode) |
130 | { |
131 | return zonefs_zone_is_cnv(z: zonefs_inode_zone(inode)); |
132 | } |
133 | |
134 | static inline bool zonefs_inode_is_seq(struct inode *inode) |
135 | { |
136 | return zonefs_zone_is_seq(z: zonefs_inode_zone(inode)); |
137 | } |
138 | |
139 | /* |
140 | * On-disk super block (block 0). |
141 | */ |
142 | #define ZONEFS_LABEL_LEN 64 |
143 | #define ZONEFS_UUID_SIZE 16 |
144 | #define ZONEFS_SUPER_SIZE 4096 |
145 | |
146 | struct zonefs_super { |
147 | |
148 | /* Magic number */ |
149 | __le32 s_magic; |
150 | |
151 | /* Checksum */ |
152 | __le32 s_crc; |
153 | |
154 | /* Volume label */ |
155 | char s_label[ZONEFS_LABEL_LEN]; |
156 | |
157 | /* 128-bit uuid */ |
158 | __u8 s_uuid[ZONEFS_UUID_SIZE]; |
159 | |
160 | /* Features */ |
161 | __le64 s_features; |
162 | |
163 | /* UID/GID to use for files */ |
164 | __le32 s_uid; |
165 | __le32 s_gid; |
166 | |
167 | /* File permissions */ |
168 | __le32 s_perm; |
169 | |
170 | /* Padding to ZONEFS_SUPER_SIZE bytes */ |
171 | __u8 s_reserved[3988]; |
172 | |
173 | } __packed; |
174 | |
175 | /* |
176 | * Feature flags: specified in the s_features field of the on-disk super |
177 | * block struct zonefs_super and in-memory in the s_feartures field of |
178 | * struct zonefs_sb_info. |
179 | */ |
180 | enum zonefs_features { |
181 | /* |
182 | * Aggregate contiguous conventional zones into a single file. |
183 | */ |
184 | ZONEFS_F_AGGRCNV = 1ULL << 0, |
185 | /* |
186 | * Use super block specified UID for files instead of default 0. |
187 | */ |
188 | ZONEFS_F_UID = 1ULL << 1, |
189 | /* |
190 | * Use super block specified GID for files instead of default 0. |
191 | */ |
192 | ZONEFS_F_GID = 1ULL << 2, |
193 | /* |
194 | * Use super block specified file permissions instead of default 640. |
195 | */ |
196 | ZONEFS_F_PERM = 1ULL << 3, |
197 | }; |
198 | |
199 | #define ZONEFS_F_DEFINED_FEATURES \ |
200 | (ZONEFS_F_AGGRCNV | ZONEFS_F_UID | ZONEFS_F_GID | ZONEFS_F_PERM) |
201 | |
202 | /* |
203 | * Mount options for zone write pointer error handling. |
204 | */ |
205 | #define ZONEFS_MNTOPT_ERRORS_RO (1 << 0) /* Make zone file readonly */ |
206 | #define ZONEFS_MNTOPT_ERRORS_ZRO (1 << 1) /* Make zone file offline */ |
207 | #define ZONEFS_MNTOPT_ERRORS_ZOL (1 << 2) /* Make zone file offline */ |
208 | #define ZONEFS_MNTOPT_ERRORS_REPAIR (1 << 3) /* Remount read-only */ |
209 | #define ZONEFS_MNTOPT_ERRORS_MASK \ |
210 | (ZONEFS_MNTOPT_ERRORS_RO | ZONEFS_MNTOPT_ERRORS_ZRO | \ |
211 | ZONEFS_MNTOPT_ERRORS_ZOL | ZONEFS_MNTOPT_ERRORS_REPAIR) |
212 | #define ZONEFS_MNTOPT_EXPLICIT_OPEN (1 << 4) /* Explicit open/close of zones on open/close */ |
213 | |
214 | /* |
215 | * In-memory Super block information. |
216 | */ |
217 | struct zonefs_sb_info { |
218 | |
219 | unsigned long s_mount_opts; |
220 | |
221 | spinlock_t s_lock; |
222 | |
223 | unsigned long long s_features; |
224 | kuid_t s_uid; |
225 | kgid_t s_gid; |
226 | umode_t s_perm; |
227 | uuid_t s_uuid; |
228 | unsigned int s_zone_sectors_shift; |
229 | |
230 | struct zonefs_zone_group s_zgroup[ZONEFS_ZTYPE_MAX]; |
231 | |
232 | loff_t s_blocks; |
233 | loff_t s_used_blocks; |
234 | |
235 | unsigned int s_max_wro_seq_files; |
236 | atomic_t s_wro_seq_files; |
237 | |
238 | unsigned int s_max_active_seq_files; |
239 | atomic_t s_active_seq_files; |
240 | |
241 | bool s_sysfs_registered; |
242 | struct kobject s_kobj; |
243 | struct completion s_kobj_unregister; |
244 | }; |
245 | |
246 | static inline struct zonefs_sb_info *ZONEFS_SB(struct super_block *sb) |
247 | { |
248 | return sb->s_fs_info; |
249 | } |
250 | |
251 | #define zonefs_info(sb, format, args...) \ |
252 | pr_info("zonefs (%s): " format, sb->s_id, ## args) |
253 | #define zonefs_err(sb, format, args...) \ |
254 | pr_err("zonefs (%s) ERROR: " format, sb->s_id, ## args) |
255 | #define zonefs_warn(sb, format, args...) \ |
256 | pr_warn("zonefs (%s) WARNING: " format, sb->s_id, ## args) |
257 | |
258 | /* In super.c */ |
259 | void zonefs_inode_account_active(struct inode *inode); |
260 | int zonefs_inode_zone_mgmt(struct inode *inode, enum req_op op); |
261 | void zonefs_i_size_write(struct inode *inode, loff_t isize); |
262 | void zonefs_update_stats(struct inode *inode, loff_t new_isize); |
263 | void __zonefs_io_error(struct inode *inode, bool write); |
264 | |
265 | static inline void zonefs_io_error(struct inode *inode, bool write) |
266 | { |
267 | struct zonefs_inode_info *zi = ZONEFS_I(inode); |
268 | |
269 | mutex_lock(&zi->i_truncate_mutex); |
270 | __zonefs_io_error(inode, write); |
271 | mutex_unlock(lock: &zi->i_truncate_mutex); |
272 | } |
273 | |
274 | /* In super.c */ |
275 | extern const struct inode_operations zonefs_dir_inode_operations; |
276 | extern const struct file_operations zonefs_dir_operations; |
277 | |
278 | /* In file.c */ |
279 | extern const struct address_space_operations zonefs_file_aops; |
280 | extern const struct file_operations zonefs_file_operations; |
281 | int zonefs_file_truncate(struct inode *inode, loff_t isize); |
282 | |
283 | /* In sysfs.c */ |
284 | int zonefs_sysfs_register(struct super_block *sb); |
285 | void zonefs_sysfs_unregister(struct super_block *sb); |
286 | int zonefs_sysfs_init(void); |
287 | void zonefs_sysfs_exit(void); |
288 | |
289 | #endif |
290 | |