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