1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * linux/fs/befs/linuxvfs.c |
4 | * |
5 | * Copyright (C) 2001 Will Dyson <will_dyson@pobox.com |
6 | * |
7 | */ |
8 | |
9 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
10 | |
11 | #include <linux/module.h> |
12 | #include <linux/slab.h> |
13 | #include <linux/fs.h> |
14 | #include <linux/errno.h> |
15 | #include <linux/stat.h> |
16 | #include <linux/nls.h> |
17 | #include <linux/buffer_head.h> |
18 | #include <linux/vfs.h> |
19 | #include <linux/parser.h> |
20 | #include <linux/namei.h> |
21 | #include <linux/sched.h> |
22 | #include <linux/cred.h> |
23 | #include <linux/exportfs.h> |
24 | #include <linux/seq_file.h> |
25 | #include <linux/blkdev.h> |
26 | |
27 | #include "befs.h" |
28 | #include "btree.h" |
29 | #include "inode.h" |
30 | #include "datastream.h" |
31 | #include "super.h" |
32 | #include "io.h" |
33 | |
34 | MODULE_DESCRIPTION("BeOS File System (BeFS) driver" ); |
35 | MODULE_AUTHOR("Will Dyson" ); |
36 | MODULE_LICENSE("GPL" ); |
37 | |
38 | /* The units the vfs expects inode->i_blocks to be in */ |
39 | #define VFS_BLOCK_SIZE 512 |
40 | |
41 | static int befs_readdir(struct file *, struct dir_context *); |
42 | static int befs_get_block(struct inode *, sector_t, struct buffer_head *, int); |
43 | static int befs_read_folio(struct file *file, struct folio *folio); |
44 | static sector_t befs_bmap(struct address_space *mapping, sector_t block); |
45 | static struct dentry *befs_lookup(struct inode *, struct dentry *, |
46 | unsigned int); |
47 | static struct inode *befs_iget(struct super_block *, unsigned long); |
48 | static struct inode *befs_alloc_inode(struct super_block *sb); |
49 | static void befs_free_inode(struct inode *inode); |
50 | static void befs_destroy_inodecache(void); |
51 | static int befs_symlink_read_folio(struct file *, struct folio *); |
52 | static int befs_utf2nls(struct super_block *sb, const char *in, int in_len, |
53 | char **out, int *out_len); |
54 | static int befs_nls2utf(struct super_block *sb, const char *in, int in_len, |
55 | char **out, int *out_len); |
56 | static void befs_put_super(struct super_block *); |
57 | static int befs_remount(struct super_block *, int *, char *); |
58 | static int befs_statfs(struct dentry *, struct kstatfs *); |
59 | static int befs_show_options(struct seq_file *, struct dentry *); |
60 | static int parse_options(char *, struct befs_mount_options *); |
61 | static struct dentry *befs_fh_to_dentry(struct super_block *sb, |
62 | struct fid *fid, int fh_len, int fh_type); |
63 | static struct dentry *befs_fh_to_parent(struct super_block *sb, |
64 | struct fid *fid, int fh_len, int fh_type); |
65 | static struct dentry *befs_get_parent(struct dentry *child); |
66 | |
67 | static const struct super_operations befs_sops = { |
68 | .alloc_inode = befs_alloc_inode, /* allocate a new inode */ |
69 | .free_inode = befs_free_inode, /* deallocate an inode */ |
70 | .put_super = befs_put_super, /* uninit super */ |
71 | .statfs = befs_statfs, /* statfs */ |
72 | .remount_fs = befs_remount, |
73 | .show_options = befs_show_options, |
74 | }; |
75 | |
76 | /* slab cache for befs_inode_info objects */ |
77 | static struct kmem_cache *befs_inode_cachep; |
78 | |
79 | static const struct file_operations befs_dir_operations = { |
80 | .read = generic_read_dir, |
81 | .iterate_shared = befs_readdir, |
82 | .llseek = generic_file_llseek, |
83 | }; |
84 | |
85 | static const struct inode_operations befs_dir_inode_operations = { |
86 | .lookup = befs_lookup, |
87 | }; |
88 | |
89 | static const struct address_space_operations befs_aops = { |
90 | .read_folio = befs_read_folio, |
91 | .bmap = befs_bmap, |
92 | }; |
93 | |
94 | static const struct address_space_operations befs_symlink_aops = { |
95 | .read_folio = befs_symlink_read_folio, |
96 | }; |
97 | |
98 | static const struct export_operations befs_export_operations = { |
99 | .encode_fh = generic_encode_ino32_fh, |
100 | .fh_to_dentry = befs_fh_to_dentry, |
101 | .fh_to_parent = befs_fh_to_parent, |
102 | .get_parent = befs_get_parent, |
103 | }; |
104 | |
105 | /* |
106 | * Called by generic_file_read() to read a folio of data |
107 | * |
108 | * In turn, simply calls a generic block read function and |
109 | * passes it the address of befs_get_block, for mapping file |
110 | * positions to disk blocks. |
111 | */ |
112 | static int befs_read_folio(struct file *file, struct folio *folio) |
113 | { |
114 | return block_read_full_folio(folio, befs_get_block); |
115 | } |
116 | |
117 | static sector_t |
118 | befs_bmap(struct address_space *mapping, sector_t block) |
119 | { |
120 | return generic_block_bmap(mapping, block, befs_get_block); |
121 | } |
122 | |
123 | /* |
124 | * Generic function to map a file position (block) to a |
125 | * disk offset (passed back in bh_result). |
126 | * |
127 | * Used by many higher level functions. |
128 | * |
129 | * Calls befs_fblock2brun() in datastream.c to do the real work. |
130 | */ |
131 | |
132 | static int |
133 | befs_get_block(struct inode *inode, sector_t block, |
134 | struct buffer_head *bh_result, int create) |
135 | { |
136 | struct super_block *sb = inode->i_sb; |
137 | befs_data_stream *ds = &BEFS_I(inode)->i_data.ds; |
138 | befs_block_run run = BAD_IADDR; |
139 | int res; |
140 | ulong disk_off; |
141 | |
142 | befs_debug(sb, fmt: "---> befs_get_block() for inode %lu, block %ld" , |
143 | (unsigned long)inode->i_ino, (long)block); |
144 | if (create) { |
145 | befs_error(sb, fmt: "befs_get_block() was asked to write to " |
146 | "block %ld in inode %lu" , (long)block, |
147 | (unsigned long)inode->i_ino); |
148 | return -EPERM; |
149 | } |
150 | |
151 | res = befs_fblock2brun(sb, data: ds, fblock: block, run: &run); |
152 | if (res != BEFS_OK) { |
153 | befs_error(sb, |
154 | fmt: "<--- %s for inode %lu, block %ld ERROR" , |
155 | __func__, (unsigned long)inode->i_ino, |
156 | (long)block); |
157 | return -EFBIG; |
158 | } |
159 | |
160 | disk_off = (ulong) iaddr2blockno(sb, iaddr: &run); |
161 | |
162 | map_bh(bh: bh_result, sb: inode->i_sb, block: disk_off); |
163 | |
164 | befs_debug(sb, fmt: "<--- %s for inode %lu, block %ld, disk address %lu" , |
165 | __func__, (unsigned long)inode->i_ino, (long)block, |
166 | (unsigned long)disk_off); |
167 | |
168 | return 0; |
169 | } |
170 | |
171 | static struct dentry * |
172 | befs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) |
173 | { |
174 | struct inode *inode; |
175 | struct super_block *sb = dir->i_sb; |
176 | const befs_data_stream *ds = &BEFS_I(inode: dir)->i_data.ds; |
177 | befs_off_t offset; |
178 | int ret; |
179 | int utfnamelen; |
180 | char *utfname; |
181 | const char *name = dentry->d_name.name; |
182 | |
183 | befs_debug(sb, fmt: "---> %s name %pd inode %ld" , __func__, |
184 | dentry, dir->i_ino); |
185 | |
186 | /* Convert to UTF-8 */ |
187 | if (BEFS_SB(super: sb)->nls) { |
188 | ret = |
189 | befs_nls2utf(sb, in: name, strlen(name), out: &utfname, out_len: &utfnamelen); |
190 | if (ret < 0) { |
191 | befs_debug(sb, fmt: "<--- %s ERROR" , __func__); |
192 | return ERR_PTR(error: ret); |
193 | } |
194 | ret = befs_btree_find(sb, ds, key: utfname, value: &offset); |
195 | kfree(objp: utfname); |
196 | |
197 | } else { |
198 | ret = befs_btree_find(sb, ds, key: name, value: &offset); |
199 | } |
200 | |
201 | if (ret == BEFS_BT_NOT_FOUND) { |
202 | befs_debug(sb, fmt: "<--- %s %pd not found" , __func__, dentry); |
203 | inode = NULL; |
204 | } else if (ret != BEFS_OK || offset == 0) { |
205 | befs_error(sb, fmt: "<--- %s Error" , __func__); |
206 | inode = ERR_PTR(error: -ENODATA); |
207 | } else { |
208 | inode = befs_iget(dir->i_sb, (ino_t) offset); |
209 | } |
210 | befs_debug(sb, fmt: "<--- %s" , __func__); |
211 | |
212 | return d_splice_alias(inode, dentry); |
213 | } |
214 | |
215 | static int |
216 | befs_readdir(struct file *file, struct dir_context *ctx) |
217 | { |
218 | struct inode *inode = file_inode(f: file); |
219 | struct super_block *sb = inode->i_sb; |
220 | const befs_data_stream *ds = &BEFS_I(inode)->i_data.ds; |
221 | befs_off_t value; |
222 | int result; |
223 | size_t keysize; |
224 | char keybuf[BEFS_NAME_LEN + 1]; |
225 | |
226 | befs_debug(sb, fmt: "---> %s name %pD, inode %ld, ctx->pos %lld" , |
227 | __func__, file, inode->i_ino, ctx->pos); |
228 | |
229 | while (1) { |
230 | result = befs_btree_read(sb, ds, key_no: ctx->pos, BEFS_NAME_LEN + 1, |
231 | keybuf, keysize: &keysize, value: &value); |
232 | |
233 | if (result == BEFS_ERR) { |
234 | befs_debug(sb, fmt: "<--- %s ERROR" , __func__); |
235 | befs_error(sb, fmt: "IO error reading %pD (inode %lu)" , |
236 | file, inode->i_ino); |
237 | return -EIO; |
238 | |
239 | } else if (result == BEFS_BT_END) { |
240 | befs_debug(sb, fmt: "<--- %s END" , __func__); |
241 | return 0; |
242 | |
243 | } else if (result == BEFS_BT_EMPTY) { |
244 | befs_debug(sb, fmt: "<--- %s Empty directory" , __func__); |
245 | return 0; |
246 | } |
247 | |
248 | /* Convert to NLS */ |
249 | if (BEFS_SB(super: sb)->nls) { |
250 | char *nlsname; |
251 | int nlsnamelen; |
252 | |
253 | result = |
254 | befs_utf2nls(sb, in: keybuf, in_len: keysize, out: &nlsname, |
255 | out_len: &nlsnamelen); |
256 | if (result < 0) { |
257 | befs_debug(sb, fmt: "<--- %s ERROR" , __func__); |
258 | return result; |
259 | } |
260 | if (!dir_emit(ctx, name: nlsname, namelen: nlsnamelen, |
261 | ino: (ino_t) value, DT_UNKNOWN)) { |
262 | kfree(objp: nlsname); |
263 | return 0; |
264 | } |
265 | kfree(objp: nlsname); |
266 | } else { |
267 | if (!dir_emit(ctx, name: keybuf, namelen: keysize, |
268 | ino: (ino_t) value, DT_UNKNOWN)) |
269 | return 0; |
270 | } |
271 | ctx->pos++; |
272 | } |
273 | } |
274 | |
275 | static struct inode * |
276 | befs_alloc_inode(struct super_block *sb) |
277 | { |
278 | struct befs_inode_info *bi; |
279 | |
280 | bi = alloc_inode_sb(sb, cache: befs_inode_cachep, GFP_KERNEL); |
281 | if (!bi) |
282 | return NULL; |
283 | return &bi->vfs_inode; |
284 | } |
285 | |
286 | static void befs_free_inode(struct inode *inode) |
287 | { |
288 | kmem_cache_free(s: befs_inode_cachep, objp: BEFS_I(inode)); |
289 | } |
290 | |
291 | static void init_once(void *foo) |
292 | { |
293 | struct befs_inode_info *bi = (struct befs_inode_info *) foo; |
294 | |
295 | inode_init_once(&bi->vfs_inode); |
296 | } |
297 | |
298 | static struct inode *befs_iget(struct super_block *sb, unsigned long ino) |
299 | { |
300 | struct buffer_head *bh; |
301 | befs_inode *raw_inode; |
302 | struct befs_sb_info *befs_sb = BEFS_SB(super: sb); |
303 | struct befs_inode_info *befs_ino; |
304 | struct inode *inode; |
305 | |
306 | befs_debug(sb, fmt: "---> %s inode = %lu" , __func__, ino); |
307 | |
308 | inode = iget_locked(sb, ino); |
309 | if (!inode) |
310 | return ERR_PTR(error: -ENOMEM); |
311 | if (!(inode->i_state & I_NEW)) |
312 | return inode; |
313 | |
314 | befs_ino = BEFS_I(inode); |
315 | |
316 | /* convert from vfs's inode number to befs's inode number */ |
317 | befs_ino->i_inode_num = blockno2iaddr(sb, blockno: inode->i_ino); |
318 | |
319 | befs_debug(sb, fmt: " real inode number [%u, %hu, %hu]" , |
320 | befs_ino->i_inode_num.allocation_group, |
321 | befs_ino->i_inode_num.start, befs_ino->i_inode_num.len); |
322 | |
323 | bh = sb_bread(sb, block: inode->i_ino); |
324 | if (!bh) { |
325 | befs_error(sb, fmt: "unable to read inode block - " |
326 | "inode = %lu" , inode->i_ino); |
327 | goto unacquire_none; |
328 | } |
329 | |
330 | raw_inode = (befs_inode *) bh->b_data; |
331 | |
332 | befs_dump_inode(sb, raw_inode); |
333 | |
334 | if (befs_check_inode(sb, raw_inode, inode: inode->i_ino) != BEFS_OK) { |
335 | befs_error(sb, fmt: "Bad inode: %lu" , inode->i_ino); |
336 | goto unacquire_bh; |
337 | } |
338 | |
339 | inode->i_mode = (umode_t) fs32_to_cpu(sb, n: raw_inode->mode); |
340 | |
341 | /* |
342 | * set uid and gid. But since current BeOS is single user OS, so |
343 | * you can change by "uid" or "gid" options. |
344 | */ |
345 | |
346 | inode->i_uid = befs_sb->mount_opts.use_uid ? |
347 | befs_sb->mount_opts.uid : |
348 | make_kuid(from: &init_user_ns, uid: fs32_to_cpu(sb, n: raw_inode->uid)); |
349 | inode->i_gid = befs_sb->mount_opts.use_gid ? |
350 | befs_sb->mount_opts.gid : |
351 | make_kgid(from: &init_user_ns, gid: fs32_to_cpu(sb, n: raw_inode->gid)); |
352 | |
353 | set_nlink(inode, nlink: 1); |
354 | |
355 | /* |
356 | * BEFS's time is 64 bits, but current VFS is 32 bits... |
357 | * BEFS don't have access time. Nor inode change time. VFS |
358 | * doesn't have creation time. |
359 | * Also, the lower 16 bits of the last_modified_time and |
360 | * create_time are just a counter to help ensure uniqueness |
361 | * for indexing purposes. (PFD, page 54) |
362 | */ |
363 | |
364 | inode_set_mtime(inode, |
365 | sec: fs64_to_cpu(sb, n: raw_inode->last_modified_time) >> 16, |
366 | nsec: 0);/* lower 16 bits are not a time */ |
367 | inode_set_ctime_to_ts(inode, ts: inode_get_mtime(inode)); |
368 | inode_set_atime_to_ts(inode, ts: inode_get_mtime(inode)); |
369 | |
370 | befs_ino->i_inode_num = fsrun_to_cpu(sb, n: raw_inode->inode_num); |
371 | befs_ino->i_parent = fsrun_to_cpu(sb, n: raw_inode->parent); |
372 | befs_ino->i_attribute = fsrun_to_cpu(sb, n: raw_inode->attributes); |
373 | befs_ino->i_flags = fs32_to_cpu(sb, n: raw_inode->flags); |
374 | |
375 | if (S_ISLNK(inode->i_mode) && !(befs_ino->i_flags & BEFS_LONG_SYMLINK)){ |
376 | inode->i_size = 0; |
377 | inode->i_blocks = befs_sb->block_size / VFS_BLOCK_SIZE; |
378 | strscpy(befs_ino->i_data.symlink, raw_inode->data.symlink, |
379 | BEFS_SYMLINK_LEN); |
380 | } else { |
381 | int num_blks; |
382 | |
383 | befs_ino->i_data.ds = |
384 | fsds_to_cpu(sb, n: &raw_inode->data.datastream); |
385 | |
386 | num_blks = befs_count_blocks(sb, ds: &befs_ino->i_data.ds); |
387 | inode->i_blocks = |
388 | num_blks * (befs_sb->block_size / VFS_BLOCK_SIZE); |
389 | inode->i_size = befs_ino->i_data.ds.size; |
390 | } |
391 | |
392 | inode->i_mapping->a_ops = &befs_aops; |
393 | |
394 | if (S_ISREG(inode->i_mode)) { |
395 | inode->i_fop = &generic_ro_fops; |
396 | } else if (S_ISDIR(inode->i_mode)) { |
397 | inode->i_op = &befs_dir_inode_operations; |
398 | inode->i_fop = &befs_dir_operations; |
399 | } else if (S_ISLNK(inode->i_mode)) { |
400 | if (befs_ino->i_flags & BEFS_LONG_SYMLINK) { |
401 | inode->i_op = &page_symlink_inode_operations; |
402 | inode_nohighmem(inode); |
403 | inode->i_mapping->a_ops = &befs_symlink_aops; |
404 | } else { |
405 | inode->i_link = befs_ino->i_data.symlink; |
406 | inode->i_op = &simple_symlink_inode_operations; |
407 | } |
408 | } else { |
409 | befs_error(sb, fmt: "Inode %lu is not a regular file, " |
410 | "directory or symlink. THAT IS WRONG! BeFS has no " |
411 | "on disk special files" , inode->i_ino); |
412 | goto unacquire_bh; |
413 | } |
414 | |
415 | brelse(bh); |
416 | befs_debug(sb, fmt: "<--- %s" , __func__); |
417 | unlock_new_inode(inode); |
418 | return inode; |
419 | |
420 | unacquire_bh: |
421 | brelse(bh); |
422 | |
423 | unacquire_none: |
424 | iget_failed(inode); |
425 | befs_debug(sb, fmt: "<--- %s - Bad inode" , __func__); |
426 | return ERR_PTR(error: -EIO); |
427 | } |
428 | |
429 | /* Initialize the inode cache. Called at fs setup. |
430 | * |
431 | * Taken from NFS implementation by Al Viro. |
432 | */ |
433 | static int __init |
434 | befs_init_inodecache(void) |
435 | { |
436 | befs_inode_cachep = kmem_cache_create_usercopy(name: "befs_inode_cache" , |
437 | size: sizeof(struct befs_inode_info), align: 0, |
438 | SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT, |
439 | offsetof(struct befs_inode_info, |
440 | i_data.symlink), |
441 | sizeof_field(struct befs_inode_info, |
442 | i_data.symlink), |
443 | ctor: init_once); |
444 | if (befs_inode_cachep == NULL) |
445 | return -ENOMEM; |
446 | |
447 | return 0; |
448 | } |
449 | |
450 | /* Called at fs teardown. |
451 | * |
452 | * Taken from NFS implementation by Al Viro. |
453 | */ |
454 | static void |
455 | befs_destroy_inodecache(void) |
456 | { |
457 | /* |
458 | * Make sure all delayed rcu free inodes are flushed before we |
459 | * destroy cache. |
460 | */ |
461 | rcu_barrier(); |
462 | kmem_cache_destroy(s: befs_inode_cachep); |
463 | } |
464 | |
465 | /* |
466 | * The inode of symbolic link is different to data stream. |
467 | * The data stream become link name. Unless the LONG_SYMLINK |
468 | * flag is set. |
469 | */ |
470 | static int befs_symlink_read_folio(struct file *unused, struct folio *folio) |
471 | { |
472 | struct inode *inode = folio->mapping->host; |
473 | struct super_block *sb = inode->i_sb; |
474 | struct befs_inode_info *befs_ino = BEFS_I(inode); |
475 | befs_data_stream *data = &befs_ino->i_data.ds; |
476 | befs_off_t len = data->size; |
477 | char *link = folio_address(folio); |
478 | |
479 | if (len == 0 || len > PAGE_SIZE) { |
480 | befs_error(sb, fmt: "Long symlink with illegal length" ); |
481 | goto fail; |
482 | } |
483 | befs_debug(sb, fmt: "Follow long symlink" ); |
484 | |
485 | if (befs_read_lsymlink(sb, data, buff: link, len) != len) { |
486 | befs_error(sb, fmt: "Failed to read entire long symlink" ); |
487 | goto fail; |
488 | } |
489 | link[len - 1] = '\0'; |
490 | folio_mark_uptodate(folio); |
491 | folio_unlock(folio); |
492 | return 0; |
493 | fail: |
494 | folio_set_error(folio); |
495 | folio_unlock(folio); |
496 | return -EIO; |
497 | } |
498 | |
499 | /* |
500 | * UTF-8 to NLS charset convert routine |
501 | * |
502 | * Uses uni2char() / char2uni() rather than the nls tables directly |
503 | */ |
504 | static int |
505 | befs_utf2nls(struct super_block *sb, const char *in, |
506 | int in_len, char **out, int *out_len) |
507 | { |
508 | struct nls_table *nls = BEFS_SB(super: sb)->nls; |
509 | int i, o; |
510 | unicode_t uni; |
511 | int unilen, utflen; |
512 | char *result; |
513 | /* The utf8->nls conversion won't make the final nls string bigger |
514 | * than the utf one, but if the string is pure ascii they'll have the |
515 | * same width and an extra char is needed to save the additional \0 |
516 | */ |
517 | int maxlen = in_len + 1; |
518 | |
519 | befs_debug(sb, fmt: "---> %s" , __func__); |
520 | |
521 | if (!nls) { |
522 | befs_error(sb, fmt: "%s called with no NLS table loaded" , __func__); |
523 | return -EINVAL; |
524 | } |
525 | |
526 | *out = result = kmalloc(size: maxlen, GFP_NOFS); |
527 | if (!*out) |
528 | return -ENOMEM; |
529 | |
530 | for (i = o = 0; i < in_len; i += utflen, o += unilen) { |
531 | |
532 | /* convert from UTF-8 to Unicode */ |
533 | utflen = utf8_to_utf32(s: &in[i], len: in_len - i, pu: &uni); |
534 | if (utflen < 0) |
535 | goto conv_err; |
536 | |
537 | /* convert from Unicode to nls */ |
538 | if (uni > MAX_WCHAR_T) |
539 | goto conv_err; |
540 | unilen = nls->uni2char(uni, &result[o], in_len - o); |
541 | if (unilen < 0) |
542 | goto conv_err; |
543 | } |
544 | result[o] = '\0'; |
545 | *out_len = o; |
546 | |
547 | befs_debug(sb, fmt: "<--- %s" , __func__); |
548 | |
549 | return o; |
550 | |
551 | conv_err: |
552 | befs_error(sb, fmt: "Name using character set %s contains a character that " |
553 | "cannot be converted to unicode." , nls->charset); |
554 | befs_debug(sb, fmt: "<--- %s" , __func__); |
555 | kfree(objp: result); |
556 | return -EILSEQ; |
557 | } |
558 | |
559 | /** |
560 | * befs_nls2utf - Convert NLS string to utf8 encodeing |
561 | * @sb: Superblock |
562 | * @in: Input string buffer in NLS format |
563 | * @in_len: Length of input string in bytes |
564 | * @out: The output string in UTF-8 format |
565 | * @out_len: Length of the output buffer |
566 | * |
567 | * Converts input string @in, which is in the format of the loaded NLS map, |
568 | * into a utf8 string. |
569 | * |
570 | * The destination string @out is allocated by this function and the caller is |
571 | * responsible for freeing it with kfree() |
572 | * |
573 | * On return, *@out_len is the length of @out in bytes. |
574 | * |
575 | * On success, the return value is the number of utf8 characters written to |
576 | * the output buffer @out. |
577 | * |
578 | * On Failure, a negative number coresponding to the error code is returned. |
579 | */ |
580 | |
581 | static int |
582 | befs_nls2utf(struct super_block *sb, const char *in, |
583 | int in_len, char **out, int *out_len) |
584 | { |
585 | struct nls_table *nls = BEFS_SB(super: sb)->nls; |
586 | int i, o; |
587 | wchar_t uni; |
588 | int unilen, utflen; |
589 | char *result; |
590 | /* |
591 | * There are nls characters that will translate to 3-chars-wide UTF-8 |
592 | * characters, an additional byte is needed to save the final \0 |
593 | * in special cases |
594 | */ |
595 | int maxlen = (3 * in_len) + 1; |
596 | |
597 | befs_debug(sb, fmt: "---> %s\n" , __func__); |
598 | |
599 | if (!nls) { |
600 | befs_error(sb, fmt: "%s called with no NLS table loaded." , |
601 | __func__); |
602 | return -EINVAL; |
603 | } |
604 | |
605 | *out = result = kmalloc(size: maxlen, GFP_NOFS); |
606 | if (!*out) { |
607 | *out_len = 0; |
608 | return -ENOMEM; |
609 | } |
610 | |
611 | for (i = o = 0; i < in_len; i += unilen, o += utflen) { |
612 | |
613 | /* convert from nls to unicode */ |
614 | unilen = nls->char2uni(&in[i], in_len - i, &uni); |
615 | if (unilen < 0) |
616 | goto conv_err; |
617 | |
618 | /* convert from unicode to UTF-8 */ |
619 | utflen = utf32_to_utf8(u: uni, s: &result[o], maxlen: 3); |
620 | if (utflen <= 0) |
621 | goto conv_err; |
622 | } |
623 | |
624 | result[o] = '\0'; |
625 | *out_len = o; |
626 | |
627 | befs_debug(sb, fmt: "<--- %s" , __func__); |
628 | |
629 | return i; |
630 | |
631 | conv_err: |
632 | befs_error(sb, fmt: "Name using character set %s contains a character that " |
633 | "cannot be converted to unicode." , nls->charset); |
634 | befs_debug(sb, fmt: "<--- %s" , __func__); |
635 | kfree(objp: result); |
636 | return -EILSEQ; |
637 | } |
638 | |
639 | static struct inode *befs_nfs_get_inode(struct super_block *sb, uint64_t ino, |
640 | uint32_t generation) |
641 | { |
642 | /* No need to handle i_generation */ |
643 | return befs_iget(sb, ino); |
644 | } |
645 | |
646 | /* |
647 | * Map a NFS file handle to a corresponding dentry |
648 | */ |
649 | static struct dentry *befs_fh_to_dentry(struct super_block *sb, |
650 | struct fid *fid, int fh_len, int fh_type) |
651 | { |
652 | return generic_fh_to_dentry(sb, fid, fh_len, fh_type, |
653 | get_inode: befs_nfs_get_inode); |
654 | } |
655 | |
656 | /* |
657 | * Find the parent for a file specified by NFS handle |
658 | */ |
659 | static struct dentry *befs_fh_to_parent(struct super_block *sb, |
660 | struct fid *fid, int fh_len, int fh_type) |
661 | { |
662 | return generic_fh_to_parent(sb, fid, fh_len, fh_type, |
663 | get_inode: befs_nfs_get_inode); |
664 | } |
665 | |
666 | static struct dentry *befs_get_parent(struct dentry *child) |
667 | { |
668 | struct inode *parent; |
669 | struct befs_inode_info *befs_ino = BEFS_I(inode: d_inode(dentry: child)); |
670 | |
671 | parent = befs_iget(sb: child->d_sb, |
672 | ino: (unsigned long)befs_ino->i_parent.start); |
673 | return d_obtain_alias(parent); |
674 | } |
675 | |
676 | enum { |
677 | Opt_uid, Opt_gid, Opt_charset, Opt_debug, Opt_err, |
678 | }; |
679 | |
680 | static const match_table_t befs_tokens = { |
681 | {Opt_uid, "uid=%d" }, |
682 | {Opt_gid, "gid=%d" }, |
683 | {Opt_charset, "iocharset=%s" }, |
684 | {Opt_debug, "debug" }, |
685 | {Opt_err, NULL} |
686 | }; |
687 | |
688 | static int |
689 | parse_options(char *options, struct befs_mount_options *opts) |
690 | { |
691 | char *p; |
692 | substring_t args[MAX_OPT_ARGS]; |
693 | int option; |
694 | kuid_t uid; |
695 | kgid_t gid; |
696 | |
697 | /* Initialize options */ |
698 | opts->uid = GLOBAL_ROOT_UID; |
699 | opts->gid = GLOBAL_ROOT_GID; |
700 | opts->use_uid = 0; |
701 | opts->use_gid = 0; |
702 | opts->iocharset = NULL; |
703 | opts->debug = 0; |
704 | |
705 | if (!options) |
706 | return 1; |
707 | |
708 | while ((p = strsep(&options, "," )) != NULL) { |
709 | int token; |
710 | |
711 | if (!*p) |
712 | continue; |
713 | |
714 | token = match_token(p, befs_tokens, args); |
715 | switch (token) { |
716 | case Opt_uid: |
717 | if (match_int(&args[0], &option)) |
718 | return 0; |
719 | uid = INVALID_UID; |
720 | if (option >= 0) |
721 | uid = make_kuid(current_user_ns(), option); |
722 | if (!uid_valid(uid)) { |
723 | pr_err("Invalid uid %d, " |
724 | "using default\n" , option); |
725 | break; |
726 | } |
727 | opts->uid = uid; |
728 | opts->use_uid = 1; |
729 | break; |
730 | case Opt_gid: |
731 | if (match_int(&args[0], &option)) |
732 | return 0; |
733 | gid = INVALID_GID; |
734 | if (option >= 0) |
735 | gid = make_kgid(current_user_ns(), option); |
736 | if (!gid_valid(gid)) { |
737 | pr_err("Invalid gid %d, " |
738 | "using default\n" , option); |
739 | break; |
740 | } |
741 | opts->gid = gid; |
742 | opts->use_gid = 1; |
743 | break; |
744 | case Opt_charset: |
745 | kfree(opts->iocharset); |
746 | opts->iocharset = match_strdup(&args[0]); |
747 | if (!opts->iocharset) { |
748 | pr_err("allocation failure for " |
749 | "iocharset string\n" ); |
750 | return 0; |
751 | } |
752 | break; |
753 | case Opt_debug: |
754 | opts->debug = 1; |
755 | break; |
756 | default: |
757 | pr_err("Unrecognized mount option \"%s\" " |
758 | "or missing value\n" , p); |
759 | return 0; |
760 | } |
761 | } |
762 | return 1; |
763 | } |
764 | |
765 | static int befs_show_options(struct seq_file *m, struct dentry *root) |
766 | { |
767 | struct befs_sb_info *befs_sb = BEFS_SB(super: root->d_sb); |
768 | struct befs_mount_options *opts = &befs_sb->mount_opts; |
769 | |
770 | if (!uid_eq(left: opts->uid, GLOBAL_ROOT_UID)) |
771 | seq_printf(m, ",uid=%u" , |
772 | from_kuid_munged(&init_user_ns, opts->uid)); |
773 | if (!gid_eq(opts->gid, GLOBAL_ROOT_GID)) |
774 | seq_printf(m, ",gid=%u" , |
775 | from_kgid_munged(&init_user_ns, opts->gid)); |
776 | if (opts->iocharset) |
777 | seq_printf(m, ",charset=%s" , opts->iocharset); |
778 | if (opts->debug) |
779 | seq_puts(m, ",debug" ); |
780 | return 0; |
781 | } |
782 | |
783 | /* This function has the responsibiltiy of getting the |
784 | * filesystem ready for unmounting. |
785 | * Basically, we free everything that we allocated in |
786 | * befs_read_inode |
787 | */ |
788 | static void |
789 | befs_put_super(struct super_block *sb) |
790 | { |
791 | kfree(objp: BEFS_SB(super: sb)->mount_opts.iocharset); |
792 | BEFS_SB(super: sb)->mount_opts.iocharset = NULL; |
793 | unload_nls(BEFS_SB(super: sb)->nls); |
794 | kfree(objp: sb->s_fs_info); |
795 | sb->s_fs_info = NULL; |
796 | } |
797 | |
798 | /* Allocate private field of the superblock, fill it. |
799 | * |
800 | * Finish filling the public superblock fields |
801 | * Make the root directory |
802 | * Load a set of NLS translations if needed. |
803 | */ |
804 | static int |
805 | befs_fill_super(struct super_block *sb, void *data, int silent) |
806 | { |
807 | struct buffer_head *bh; |
808 | struct befs_sb_info *befs_sb; |
809 | befs_super_block *disk_sb; |
810 | struct inode *root; |
811 | long ret = -EINVAL; |
812 | const unsigned long sb_block = 0; |
813 | const off_t x86_sb_off = 512; |
814 | int blocksize; |
815 | |
816 | sb->s_fs_info = kzalloc(size: sizeof(*befs_sb), GFP_KERNEL); |
817 | if (sb->s_fs_info == NULL) |
818 | goto unacquire_none; |
819 | |
820 | befs_sb = BEFS_SB(super: sb); |
821 | |
822 | if (!parse_options(options: (char *) data, opts: &befs_sb->mount_opts)) { |
823 | if (!silent) |
824 | befs_error(sb, fmt: "cannot parse mount options" ); |
825 | goto unacquire_priv_sbp; |
826 | } |
827 | |
828 | befs_debug(sb, fmt: "---> %s" , __func__); |
829 | |
830 | if (!sb_rdonly(sb)) { |
831 | befs_warning(sb, |
832 | fmt: "No write support. Marking filesystem read-only" ); |
833 | sb->s_flags |= SB_RDONLY; |
834 | } |
835 | |
836 | /* |
837 | * Set dummy blocksize to read super block. |
838 | * Will be set to real fs blocksize later. |
839 | * |
840 | * Linux 2.4.10 and later refuse to read blocks smaller than |
841 | * the logical block size for the device. But we also need to read at |
842 | * least 1k to get the second 512 bytes of the volume. |
843 | */ |
844 | blocksize = sb_min_blocksize(sb, 1024); |
845 | if (!blocksize) { |
846 | if (!silent) |
847 | befs_error(sb, fmt: "unable to set blocksize" ); |
848 | goto unacquire_priv_sbp; |
849 | } |
850 | |
851 | bh = sb_bread(sb, block: sb_block); |
852 | if (!bh) { |
853 | if (!silent) |
854 | befs_error(sb, fmt: "unable to read superblock" ); |
855 | goto unacquire_priv_sbp; |
856 | } |
857 | |
858 | /* account for offset of super block on x86 */ |
859 | disk_sb = (befs_super_block *) bh->b_data; |
860 | if ((disk_sb->magic1 == BEFS_SUPER_MAGIC1_LE) || |
861 | (disk_sb->magic1 == BEFS_SUPER_MAGIC1_BE)) { |
862 | befs_debug(sb, fmt: "Using PPC superblock location" ); |
863 | } else { |
864 | befs_debug(sb, fmt: "Using x86 superblock location" ); |
865 | disk_sb = |
866 | (befs_super_block *) ((void *) bh->b_data + x86_sb_off); |
867 | } |
868 | |
869 | if ((befs_load_sb(sb, disk_sb) != BEFS_OK) || |
870 | (befs_check_sb(sb) != BEFS_OK)) |
871 | goto unacquire_bh; |
872 | |
873 | befs_dump_super_block(sb, disk_sb); |
874 | |
875 | brelse(bh); |
876 | |
877 | if (befs_sb->num_blocks > ~((sector_t)0)) { |
878 | if (!silent) |
879 | befs_error(sb, fmt: "blocks count: %llu is larger than the host can use" , |
880 | befs_sb->num_blocks); |
881 | goto unacquire_priv_sbp; |
882 | } |
883 | |
884 | /* |
885 | * set up enough so that it can read an inode |
886 | * Fill in kernel superblock fields from private sb |
887 | */ |
888 | sb->s_magic = BEFS_SUPER_MAGIC; |
889 | /* Set real blocksize of fs */ |
890 | sb_set_blocksize(sb, (ulong) befs_sb->block_size); |
891 | sb->s_op = &befs_sops; |
892 | sb->s_export_op = &befs_export_operations; |
893 | sb->s_time_min = 0; |
894 | sb->s_time_max = 0xffffffffffffll; |
895 | root = befs_iget(sb, ino: iaddr2blockno(sb, iaddr: &(befs_sb->root_dir))); |
896 | if (IS_ERR(ptr: root)) { |
897 | ret = PTR_ERR(ptr: root); |
898 | goto unacquire_priv_sbp; |
899 | } |
900 | sb->s_root = d_make_root(root); |
901 | if (!sb->s_root) { |
902 | if (!silent) |
903 | befs_error(sb, fmt: "get root inode failed" ); |
904 | goto unacquire_priv_sbp; |
905 | } |
906 | |
907 | /* load nls library */ |
908 | if (befs_sb->mount_opts.iocharset) { |
909 | befs_debug(sb, fmt: "Loading nls: %s" , |
910 | befs_sb->mount_opts.iocharset); |
911 | befs_sb->nls = load_nls(charset: befs_sb->mount_opts.iocharset); |
912 | if (!befs_sb->nls) { |
913 | befs_warning(sb, fmt: "Cannot load nls %s" |
914 | " loading default nls" , |
915 | befs_sb->mount_opts.iocharset); |
916 | befs_sb->nls = load_nls_default(); |
917 | } |
918 | /* load default nls if none is specified in mount options */ |
919 | } else { |
920 | befs_debug(sb, fmt: "Loading default nls" ); |
921 | befs_sb->nls = load_nls_default(); |
922 | } |
923 | |
924 | return 0; |
925 | |
926 | unacquire_bh: |
927 | brelse(bh); |
928 | |
929 | unacquire_priv_sbp: |
930 | kfree(objp: befs_sb->mount_opts.iocharset); |
931 | kfree(objp: sb->s_fs_info); |
932 | sb->s_fs_info = NULL; |
933 | |
934 | unacquire_none: |
935 | return ret; |
936 | } |
937 | |
938 | static int |
939 | befs_remount(struct super_block *sb, int *flags, char *data) |
940 | { |
941 | sync_filesystem(sb); |
942 | if (!(*flags & SB_RDONLY)) |
943 | return -EINVAL; |
944 | return 0; |
945 | } |
946 | |
947 | static int |
948 | befs_statfs(struct dentry *dentry, struct kstatfs *buf) |
949 | { |
950 | struct super_block *sb = dentry->d_sb; |
951 | u64 id = huge_encode_dev(dev: sb->s_bdev->bd_dev); |
952 | |
953 | befs_debug(sb, fmt: "---> %s" , __func__); |
954 | |
955 | buf->f_type = BEFS_SUPER_MAGIC; |
956 | buf->f_bsize = sb->s_blocksize; |
957 | buf->f_blocks = BEFS_SB(super: sb)->num_blocks; |
958 | buf->f_bfree = BEFS_SB(super: sb)->num_blocks - BEFS_SB(super: sb)->used_blocks; |
959 | buf->f_bavail = buf->f_bfree; |
960 | buf->f_files = 0; /* UNKNOWN */ |
961 | buf->f_ffree = 0; /* UNKNOWN */ |
962 | buf->f_fsid = u64_to_fsid(v: id); |
963 | buf->f_namelen = BEFS_NAME_LEN; |
964 | |
965 | befs_debug(sb, fmt: "<--- %s" , __func__); |
966 | |
967 | return 0; |
968 | } |
969 | |
970 | static struct dentry * |
971 | befs_mount(struct file_system_type *fs_type, int flags, const char *dev_name, |
972 | void *data) |
973 | { |
974 | return mount_bdev(fs_type, flags, dev_name, data, fill_super: befs_fill_super); |
975 | } |
976 | |
977 | static struct file_system_type befs_fs_type = { |
978 | .owner = THIS_MODULE, |
979 | .name = "befs" , |
980 | .mount = befs_mount, |
981 | .kill_sb = kill_block_super, |
982 | .fs_flags = FS_REQUIRES_DEV, |
983 | }; |
984 | MODULE_ALIAS_FS("befs" ); |
985 | |
986 | static int __init |
987 | init_befs_fs(void) |
988 | { |
989 | int err; |
990 | |
991 | pr_info("version: %s\n" , BEFS_VERSION); |
992 | |
993 | err = befs_init_inodecache(); |
994 | if (err) |
995 | goto unacquire_none; |
996 | |
997 | err = register_filesystem(&befs_fs_type); |
998 | if (err) |
999 | goto unacquire_inodecache; |
1000 | |
1001 | return 0; |
1002 | |
1003 | unacquire_inodecache: |
1004 | befs_destroy_inodecache(); |
1005 | |
1006 | unacquire_none: |
1007 | return err; |
1008 | } |
1009 | |
1010 | static void __exit |
1011 | exit_befs_fs(void) |
1012 | { |
1013 | befs_destroy_inodecache(); |
1014 | |
1015 | unregister_filesystem(&befs_fs_type); |
1016 | } |
1017 | |
1018 | /* |
1019 | * Macros that typecheck the init and exit functions, |
1020 | * ensures that they are called at init and cleanup, |
1021 | * and eliminates warnings about unused functions. |
1022 | */ |
1023 | module_init(init_befs_fs) |
1024 | module_exit(exit_befs_fs) |
1025 | |