]>
Commit | Line | Data |
---|---|---|
d2912cb1 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
1da177e4 LT |
2 | /* |
3 | * linux/fs/adfs/super.c | |
4 | * | |
5 | * Copyright (C) 1997-1999 Russell King | |
1da177e4 LT |
6 | */ |
7 | #include <linux/module.h> | |
1da177e4 | 8 | #include <linux/init.h> |
1da177e4 | 9 | #include <linux/parser.h> |
e11400b0 MS |
10 | #include <linux/mount.h> |
11 | #include <linux/seq_file.h> | |
5a0e3ad6 | 12 | #include <linux/slab.h> |
608ba50b | 13 | #include <linux/statfs.h> |
c010d1ff | 14 | #include <linux/user_namespace.h> |
621c1f42 | 15 | #include <linux/blkdev.h> |
1da177e4 LT |
16 | #include "adfs.h" |
17 | #include "dir_f.h" | |
18 | #include "dir_fplus.h" | |
19 | ||
421d3c0f RK |
20 | #define ADFS_SB_FLAGS SB_NOATIME |
21 | ||
e11400b0 MS |
22 | #define ADFS_DEFAULT_OWNER_MASK S_IRWXU |
23 | #define ADFS_DEFAULT_OTHER_MASK (S_IRWXG | S_IRWXO) | |
24 | ||
1da177e4 LT |
25 | void __adfs_error(struct super_block *sb, const char *function, const char *fmt, ...) |
26 | { | |
2e67080d | 27 | struct va_format vaf; |
1da177e4 LT |
28 | va_list args; |
29 | ||
30 | va_start(args, fmt); | |
2e67080d RK |
31 | vaf.fmt = fmt; |
32 | vaf.va = &args; | |
1da177e4 | 33 | |
2e67080d | 34 | printk(KERN_CRIT "ADFS-fs error (device %s)%s%s: %pV\n", |
1da177e4 | 35 | sb->s_id, function ? ": " : "", |
2e67080d RK |
36 | function ? function : "", &vaf); |
37 | ||
38 | va_end(args); | |
1da177e4 LT |
39 | } |
40 | ||
ceb3b106 RK |
41 | void adfs_msg(struct super_block *sb, const char *pfx, const char *fmt, ...) |
42 | { | |
43 | struct va_format vaf; | |
44 | va_list args; | |
45 | ||
46 | va_start(args, fmt); | |
47 | vaf.fmt = fmt; | |
48 | vaf.va = &args; | |
49 | printk("%sADFS-fs (%s): %pV\n", pfx, sb->s_id, &vaf); | |
50 | va_end(args); | |
1da177e4 LT |
51 | } |
52 | ||
53 | static int adfs_checkdiscrecord(struct adfs_discrecord *dr) | |
54 | { | |
8616108d | 55 | unsigned int max_idlen; |
1da177e4 LT |
56 | int i; |
57 | ||
58 | /* sector size must be 256, 512 or 1024 bytes */ | |
59 | if (dr->log2secsize != 8 && | |
60 | dr->log2secsize != 9 && | |
61 | dr->log2secsize != 10) | |
62 | return 1; | |
63 | ||
64 | /* idlen must be at least log2secsize + 3 */ | |
65 | if (dr->idlen < dr->log2secsize + 3) | |
66 | return 1; | |
67 | ||
68 | /* we cannot have such a large disc that we | |
69 | * are unable to represent sector offsets in | |
70 | * 32 bits. This works out at 2.0 TB. | |
71 | */ | |
72 | if (le32_to_cpu(dr->disc_size_high) >> dr->log2secsize) | |
73 | return 1; | |
74 | ||
8616108d RK |
75 | /* |
76 | * Maximum idlen is limited to 16 bits for new directories by | |
77 | * the three-byte storage of an indirect disc address. For | |
78 | * big directories, idlen must be no greater than 19 v2 [1.0] | |
79 | */ | |
80 | max_idlen = dr->format_version ? 19 : 16; | |
81 | if (dr->idlen > max_idlen) | |
1da177e4 LT |
82 | return 1; |
83 | ||
84 | /* reserved bytes should be zero */ | |
85 | for (i = 0; i < sizeof(dr->unused52); i++) | |
86 | if (dr->unused52[i] != 0) | |
87 | return 1; | |
88 | ||
89 | return 0; | |
90 | } | |
91 | ||
1da177e4 LT |
92 | static void adfs_put_super(struct super_block *sb) |
93 | { | |
1da177e4 LT |
94 | struct adfs_sb_info *asb = ADFS_SB(sb); |
95 | ||
7b195267 | 96 | adfs_free_map(sb); |
2d1d9b5b | 97 | kfree_rcu(asb, rcu); |
1da177e4 LT |
98 | } |
99 | ||
34c80b1d | 100 | static int adfs_show_options(struct seq_file *seq, struct dentry *root) |
e11400b0 | 101 | { |
34c80b1d | 102 | struct adfs_sb_info *asb = ADFS_SB(root->d_sb); |
e11400b0 | 103 | |
c010d1ff EB |
104 | if (!uid_eq(asb->s_uid, GLOBAL_ROOT_UID)) |
105 | seq_printf(seq, ",uid=%u", from_kuid_munged(&init_user_ns, asb->s_uid)); | |
106 | if (!gid_eq(asb->s_gid, GLOBAL_ROOT_GID)) | |
107 | seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, asb->s_gid)); | |
e11400b0 MS |
108 | if (asb->s_owner_mask != ADFS_DEFAULT_OWNER_MASK) |
109 | seq_printf(seq, ",ownmask=%o", asb->s_owner_mask); | |
110 | if (asb->s_other_mask != ADFS_DEFAULT_OTHER_MASK) | |
111 | seq_printf(seq, ",othmask=%o", asb->s_other_mask); | |
da23ef05 SS |
112 | if (asb->s_ftsuffix != 0) |
113 | seq_printf(seq, ",ftsuffix=%u", asb->s_ftsuffix); | |
e11400b0 MS |
114 | |
115 | return 0; | |
116 | } | |
117 | ||
da23ef05 | 118 | enum {Opt_uid, Opt_gid, Opt_ownmask, Opt_othmask, Opt_ftsuffix, Opt_err}; |
1da177e4 | 119 | |
a447c093 | 120 | static const match_table_t tokens = { |
1da177e4 LT |
121 | {Opt_uid, "uid=%u"}, |
122 | {Opt_gid, "gid=%u"}, | |
123 | {Opt_ownmask, "ownmask=%o"}, | |
124 | {Opt_othmask, "othmask=%o"}, | |
da23ef05 | 125 | {Opt_ftsuffix, "ftsuffix=%u"}, |
1da177e4 LT |
126 | {Opt_err, NULL} |
127 | }; | |
128 | ||
4c5762f5 RK |
129 | static int parse_options(struct super_block *sb, struct adfs_sb_info *asb, |
130 | char *options) | |
1da177e4 LT |
131 | { |
132 | char *p; | |
1da177e4 LT |
133 | int option; |
134 | ||
135 | if (!options) | |
136 | return 0; | |
137 | ||
138 | while ((p = strsep(&options, ",")) != NULL) { | |
139 | substring_t args[MAX_OPT_ARGS]; | |
140 | int token; | |
141 | if (!*p) | |
142 | continue; | |
143 | ||
144 | token = match_token(p, tokens, args); | |
145 | switch (token) { | |
146 | case Opt_uid: | |
147 | if (match_int(args, &option)) | |
148 | return -EINVAL; | |
c010d1ff EB |
149 | asb->s_uid = make_kuid(current_user_ns(), option); |
150 | if (!uid_valid(asb->s_uid)) | |
151 | return -EINVAL; | |
1da177e4 LT |
152 | break; |
153 | case Opt_gid: | |
154 | if (match_int(args, &option)) | |
155 | return -EINVAL; | |
c010d1ff EB |
156 | asb->s_gid = make_kgid(current_user_ns(), option); |
157 | if (!gid_valid(asb->s_gid)) | |
158 | return -EINVAL; | |
1da177e4 LT |
159 | break; |
160 | case Opt_ownmask: | |
161 | if (match_octal(args, &option)) | |
162 | return -EINVAL; | |
163 | asb->s_owner_mask = option; | |
164 | break; | |
165 | case Opt_othmask: | |
166 | if (match_octal(args, &option)) | |
167 | return -EINVAL; | |
168 | asb->s_other_mask = option; | |
169 | break; | |
da23ef05 SS |
170 | case Opt_ftsuffix: |
171 | if (match_int(args, &option)) | |
172 | return -EINVAL; | |
173 | asb->s_ftsuffix = option; | |
174 | break; | |
1da177e4 | 175 | default: |
ceb3b106 RK |
176 | adfs_msg(sb, KERN_ERR, |
177 | "unrecognised mount option \"%s\" or missing value", | |
178 | p); | |
1da177e4 LT |
179 | return -EINVAL; |
180 | } | |
181 | } | |
182 | return 0; | |
183 | } | |
184 | ||
185 | static int adfs_remount(struct super_block *sb, int *flags, char *data) | |
186 | { | |
4c5762f5 RK |
187 | struct adfs_sb_info temp_asb; |
188 | int ret; | |
189 | ||
02b9984d | 190 | sync_filesystem(sb); |
421d3c0f | 191 | *flags |= ADFS_SB_FLAGS; |
4c5762f5 RK |
192 | |
193 | temp_asb = *ADFS_SB(sb); | |
194 | ret = parse_options(sb, &temp_asb, data); | |
195 | if (ret == 0) | |
196 | *ADFS_SB(sb) = temp_asb; | |
197 | ||
198 | return ret; | |
1da177e4 LT |
199 | } |
200 | ||
726c3342 | 201 | static int adfs_statfs(struct dentry *dentry, struct kstatfs *buf) |
1da177e4 | 202 | { |
accb4012 CL |
203 | struct super_block *sb = dentry->d_sb; |
204 | struct adfs_sb_info *sbi = ADFS_SB(sb); | |
205 | u64 id = huge_encode_dev(sb->s_bdev->bd_dev); | |
1da177e4 | 206 | |
e6160e46 RK |
207 | adfs_map_statfs(sb, buf); |
208 | ||
1da177e4 | 209 | buf->f_type = ADFS_SUPER_MAGIC; |
accb4012 CL |
210 | buf->f_namelen = sbi->s_namelen; |
211 | buf->f_bsize = sb->s_blocksize; | |
1da177e4 | 212 | buf->f_ffree = (long)(buf->f_bfree * buf->f_files) / (long)buf->f_blocks; |
6d1349c7 | 213 | buf->f_fsid = u64_to_fsid(id); |
1da177e4 LT |
214 | |
215 | return 0; | |
216 | } | |
217 | ||
e18b890b | 218 | static struct kmem_cache *adfs_inode_cachep; |
1da177e4 LT |
219 | |
220 | static struct inode *adfs_alloc_inode(struct super_block *sb) | |
221 | { | |
222 | struct adfs_inode_info *ei; | |
d96f1845 | 223 | ei = kmem_cache_alloc(adfs_inode_cachep, GFP_KERNEL); |
1da177e4 LT |
224 | if (!ei) |
225 | return NULL; | |
226 | return &ei->vfs_inode; | |
227 | } | |
228 | ||
8f05a795 | 229 | static void adfs_free_inode(struct inode *inode) |
1da177e4 LT |
230 | { |
231 | kmem_cache_free(adfs_inode_cachep, ADFS_I(inode)); | |
232 | } | |
233 | ||
f3520642 RK |
234 | static int adfs_drop_inode(struct inode *inode) |
235 | { | |
236 | /* always drop inodes if we are read-only */ | |
237 | return !IS_ENABLED(CONFIG_ADFS_FS_RW) || IS_RDONLY(inode); | |
238 | } | |
239 | ||
51cc5068 | 240 | static void init_once(void *foo) |
1da177e4 LT |
241 | { |
242 | struct adfs_inode_info *ei = (struct adfs_inode_info *) foo; | |
243 | ||
a35afb83 | 244 | inode_init_once(&ei->vfs_inode); |
1da177e4 | 245 | } |
20c2df83 | 246 | |
894122db | 247 | static int __init init_inodecache(void) |
1da177e4 LT |
248 | { |
249 | adfs_inode_cachep = kmem_cache_create("adfs_inode_cache", | |
250 | sizeof(struct adfs_inode_info), | |
fffb60f9 | 251 | 0, (SLAB_RECLAIM_ACCOUNT| |
5d097056 | 252 | SLAB_MEM_SPREAD|SLAB_ACCOUNT), |
20c2df83 | 253 | init_once); |
1da177e4 LT |
254 | if (adfs_inode_cachep == NULL) |
255 | return -ENOMEM; | |
256 | return 0; | |
257 | } | |
258 | ||
259 | static void destroy_inodecache(void) | |
260 | { | |
8c0a8537 KS |
261 | /* |
262 | * Make sure all delayed rcu free inodes are flushed before we | |
263 | * destroy cache. | |
264 | */ | |
265 | rcu_barrier(); | |
1a1d92c1 | 266 | kmem_cache_destroy(adfs_inode_cachep); |
1da177e4 LT |
267 | } |
268 | ||
ee9b6d61 | 269 | static const struct super_operations adfs_sops = { |
1da177e4 | 270 | .alloc_inode = adfs_alloc_inode, |
8f05a795 | 271 | .free_inode = adfs_free_inode, |
f3520642 | 272 | .drop_inode = adfs_drop_inode, |
1da177e4 LT |
273 | .write_inode = adfs_write_inode, |
274 | .put_super = adfs_put_super, | |
275 | .statfs = adfs_statfs, | |
276 | .remount_fs = adfs_remount, | |
e11400b0 | 277 | .show_options = adfs_show_options, |
1da177e4 LT |
278 | }; |
279 | ||
e3858e12 RK |
280 | static int adfs_probe(struct super_block *sb, unsigned int offset, int silent, |
281 | int (*validate)(struct super_block *sb, | |
282 | struct buffer_head *bh, | |
283 | struct adfs_discrecord **bhp)) | |
1da177e4 | 284 | { |
e3858e12 | 285 | struct adfs_sb_info *asb = ADFS_SB(sb); |
1da177e4 LT |
286 | struct adfs_discrecord *dr; |
287 | struct buffer_head *bh; | |
e3858e12 RK |
288 | unsigned int blocksize = BLOCK_SIZE; |
289 | int ret, try; | |
290 | ||
291 | for (try = 0; try < 2; try++) { | |
292 | /* try to set the requested block size */ | |
293 | if (sb->s_blocksize != blocksize && | |
294 | !sb_set_blocksize(sb, blocksize)) { | |
295 | if (!silent) | |
296 | adfs_msg(sb, KERN_ERR, | |
297 | "error: unsupported blocksize"); | |
298 | return -EINVAL; | |
299 | } | |
300 | ||
301 | /* read the buffer */ | |
302 | bh = sb_bread(sb, offset >> sb->s_blocksize_bits); | |
303 | if (!bh) { | |
304 | adfs_msg(sb, KERN_ERR, | |
305 | "error: unable to read block %u, try %d", | |
306 | offset >> sb->s_blocksize_bits, try); | |
307 | return -EIO; | |
308 | } | |
309 | ||
310 | /* validate it */ | |
311 | ret = validate(sb, bh, &dr); | |
312 | if (ret) { | |
313 | brelse(bh); | |
314 | return ret; | |
315 | } | |
316 | ||
317 | /* does the block size match the filesystem block size? */ | |
318 | blocksize = 1 << dr->log2secsize; | |
319 | if (sb->s_blocksize == blocksize) { | |
320 | asb->s_map = adfs_read_map(sb, dr); | |
321 | brelse(bh); | |
322 | return PTR_ERR_OR_ZERO(asb->s_map); | |
323 | } | |
324 | ||
325 | brelse(bh); | |
326 | } | |
327 | ||
328 | return -EIO; | |
329 | } | |
330 | ||
331 | static int adfs_validate_bblk(struct super_block *sb, struct buffer_head *bh, | |
332 | struct adfs_discrecord **drp) | |
333 | { | |
334 | struct adfs_discrecord *dr; | |
1da177e4 | 335 | unsigned char *b_data; |
e3858e12 RK |
336 | |
337 | b_data = bh->b_data + (ADFS_DISCRECORD % sb->s_blocksize); | |
338 | if (adfs_checkbblk(b_data)) | |
339 | return -EILSEQ; | |
340 | ||
341 | /* Do some sanity checks on the ADFS disc record */ | |
342 | dr = (struct adfs_discrecord *)(b_data + ADFS_DR_OFFSET); | |
343 | if (adfs_checkdiscrecord(dr)) | |
344 | return -EILSEQ; | |
345 | ||
346 | *drp = dr; | |
347 | return 0; | |
348 | } | |
349 | ||
08ead1b8 RK |
350 | static int adfs_validate_dr0(struct super_block *sb, struct buffer_head *bh, |
351 | struct adfs_discrecord **drp) | |
352 | { | |
353 | struct adfs_discrecord *dr; | |
354 | ||
355 | /* Do some sanity checks on the ADFS disc record */ | |
356 | dr = (struct adfs_discrecord *)(bh->b_data + 4); | |
357 | if (adfs_checkdiscrecord(dr) || dr->nzones_high || dr->nzones != 1) | |
358 | return -EILSEQ; | |
359 | ||
360 | *drp = dr; | |
361 | return 0; | |
362 | } | |
363 | ||
e3858e12 RK |
364 | static int adfs_fill_super(struct super_block *sb, void *data, int silent) |
365 | { | |
366 | struct adfs_discrecord *dr; | |
367 | struct object_info root_obj; | |
1da177e4 LT |
368 | struct adfs_sb_info *asb; |
369 | struct inode *root; | |
b7964106 | 370 | int ret = -EINVAL; |
1da177e4 | 371 | |
421d3c0f | 372 | sb->s_flags |= ADFS_SB_FLAGS; |
1da177e4 | 373 | |
f8314dc6 | 374 | asb = kzalloc(sizeof(*asb), GFP_KERNEL); |
4688a066 | 375 | if (!asb) |
1da177e4 | 376 | return -ENOMEM; |
eeeb9dd9 | 377 | |
1da177e4 | 378 | sb->s_fs_info = asb; |
f6f14a0d | 379 | sb->s_magic = ADFS_SUPER_MAGIC; |
eeeb9dd9 | 380 | sb->s_time_gran = 10000000; |
1da177e4 LT |
381 | |
382 | /* set default options */ | |
c010d1ff EB |
383 | asb->s_uid = GLOBAL_ROOT_UID; |
384 | asb->s_gid = GLOBAL_ROOT_GID; | |
e11400b0 MS |
385 | asb->s_owner_mask = ADFS_DEFAULT_OWNER_MASK; |
386 | asb->s_other_mask = ADFS_DEFAULT_OTHER_MASK; | |
da23ef05 | 387 | asb->s_ftsuffix = 0; |
1da177e4 | 388 | |
4c5762f5 | 389 | if (parse_options(sb, asb, data)) |
1da177e4 LT |
390 | goto error; |
391 | ||
e3858e12 | 392 | /* Try to probe the filesystem boot block */ |
08ead1b8 RK |
393 | ret = adfs_probe(sb, ADFS_DISCRECORD, 1, adfs_validate_bblk); |
394 | if (ret == -EILSEQ) | |
395 | ret = adfs_probe(sb, 0, silent, adfs_validate_dr0); | |
e3858e12 | 396 | if (ret == -EILSEQ) { |
1da177e4 | 397 | if (!silent) |
ceb3b106 | 398 | adfs_msg(sb, KERN_ERR, |
e3858e12 RK |
399 | "error: can't find an ADFS filesystem on dev %s.", |
400 | sb->s_id); | |
b7964106 | 401 | ret = -EINVAL; |
1da177e4 | 402 | } |
e3858e12 RK |
403 | if (ret) |
404 | goto error; | |
1da177e4 | 405 | |
e3858e12 | 406 | /* set up enough so that we can read an inode */ |
1da177e4 LT |
407 | sb->s_op = &adfs_sops; |
408 | ||
1dfdfc94 | 409 | dr = adfs_map_discrecord(asb->s_map); |
1da177e4 | 410 | |
5ed70bb4 | 411 | root_obj.parent_id = root_obj.indaddr = le32_to_cpu(dr->root); |
1da177e4 | 412 | root_obj.name_len = 0; |
da23ef05 SS |
413 | /* Set root object date as 01 Jan 1987 00:00:00 */ |
414 | root_obj.loadaddr = 0xfff0003f; | |
415 | root_obj.execaddr = 0xec22c000; | |
1da177e4 LT |
416 | root_obj.size = ADFS_NEWDIR_SIZE; |
417 | root_obj.attr = ADFS_NDA_DIRECTORY | ADFS_NDA_OWNER_READ | | |
418 | ADFS_NDA_OWNER_WRITE | ADFS_NDA_PUBLIC_READ; | |
419 | ||
420 | /* | |
421 | * If this is a F+ disk with variable length directories, | |
422 | * get the root_size from the disc record. | |
423 | */ | |
cb88b5a3 | 424 | if (dr->format_version) { |
1da177e4 LT |
425 | root_obj.size = le32_to_cpu(dr->root_size); |
426 | asb->s_dir = &adfs_fplus_dir_ops; | |
427 | asb->s_namelen = ADFS_FPLUS_NAME_LEN; | |
428 | } else { | |
429 | asb->s_dir = &adfs_f_dir_ops; | |
430 | asb->s_namelen = ADFS_F_NAME_LEN; | |
431 | } | |
da23ef05 SS |
432 | /* |
433 | * ,xyz hex filetype suffix may be added by driver | |
434 | * to files that have valid RISC OS filetype | |
435 | */ | |
436 | if (asb->s_ftsuffix) | |
437 | asb->s_namelen += 4; | |
1da177e4 | 438 | |
96e13914 | 439 | sb->s_d_op = &adfs_dentry_operations; |
1da177e4 | 440 | root = adfs_iget(sb, &root_obj); |
48fde701 | 441 | sb->s_root = d_make_root(root); |
1da177e4 | 442 | if (!sb->s_root) { |
7b195267 | 443 | adfs_free_map(sb); |
1da177e4 | 444 | adfs_error(sb, "get root inode failed\n"); |
b7964106 | 445 | ret = -EIO; |
1da177e4 | 446 | goto error; |
96e13914 | 447 | } |
1da177e4 LT |
448 | return 0; |
449 | ||
1da177e4 LT |
450 | error: |
451 | sb->s_fs_info = NULL; | |
452 | kfree(asb); | |
b7964106 | 453 | return ret; |
1da177e4 LT |
454 | } |
455 | ||
152a0836 AV |
456 | static struct dentry *adfs_mount(struct file_system_type *fs_type, |
457 | int flags, const char *dev_name, void *data) | |
1da177e4 | 458 | { |
152a0836 | 459 | return mount_bdev(fs_type, flags, dev_name, data, adfs_fill_super); |
1da177e4 LT |
460 | } |
461 | ||
462 | static struct file_system_type adfs_fs_type = { | |
463 | .owner = THIS_MODULE, | |
464 | .name = "adfs", | |
152a0836 | 465 | .mount = adfs_mount, |
1da177e4 LT |
466 | .kill_sb = kill_block_super, |
467 | .fs_flags = FS_REQUIRES_DEV, | |
468 | }; | |
7f78e035 | 469 | MODULE_ALIAS_FS("adfs"); |
1da177e4 LT |
470 | |
471 | static int __init init_adfs_fs(void) | |
472 | { | |
473 | int err = init_inodecache(); | |
474 | if (err) | |
475 | goto out1; | |
476 | err = register_filesystem(&adfs_fs_type); | |
477 | if (err) | |
478 | goto out; | |
479 | return 0; | |
480 | out: | |
481 | destroy_inodecache(); | |
482 | out1: | |
483 | return err; | |
484 | } | |
485 | ||
486 | static void __exit exit_adfs_fs(void) | |
487 | { | |
488 | unregister_filesystem(&adfs_fs_type); | |
489 | destroy_inodecache(); | |
490 | } | |
491 | ||
492 | module_init(init_adfs_fs) | |
493 | module_exit(exit_adfs_fs) | |
608ba50b | 494 | MODULE_LICENSE("GPL"); |