Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/fs/befs/linuxvfs.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us