Branch data     Line data    Source code

       1                 :            : /*
       2                 :            :  * Resizable simple ram filesystem for Linux.
       3                 :            :  *
       4                 :            :  * Copyright (C) 2000 Linus Torvalds.
       5                 :            :  *               2000 Transmeta Corp.
       6                 :            :  *
       7                 :            :  * Usage limits added by David Gibson, Linuxcare Australia.
       8                 :            :  * This file is released under the GPL.
       9                 :            :  */
      10                 :            : 
      11                 :            : /*
      12                 :            :  * NOTE! This filesystem is probably most useful
      13                 :            :  * not as a real filesystem, but as an example of
      14                 :            :  * how virtual filesystems can be written.
      15                 :            :  *
      16                 :            :  * It doesn't get much simpler than this. Consider
      17                 :            :  * that this file implements the full semantics of
      18                 :            :  * a POSIX-compliant read-write filesystem.
      19                 :            :  *
      20                 :            :  * Note in particular how the filesystem does not
      21                 :            :  * need to implement any data structures of its own
      22                 :            :  * to keep track of the virtual data: using the VFS
      23                 :            :  * caches is sufficient.
      24                 :            :  */
      25                 :            : 
      26                 :            : #include <linux/fs.h>
      27                 :            : #include <linux/pagemap.h>
      28                 :            : #include <linux/highmem.h>
      29                 :            : #include <linux/time.h>
      30                 :            : #include <linux/init.h>
      31                 :            : #include <linux/string.h>
      32                 :            : #include <linux/backing-dev.h>
      33                 :            : #include <linux/ramfs.h>
      34                 :            : #include <linux/sched.h>
      35                 :            : #include <linux/parser.h>
      36                 :            : #include <linux/magic.h>
      37                 :            : #include <linux/slab.h>
      38                 :            : #include <linux/uaccess.h>
      39                 :            : #include <linux/fs_context.h>
      40                 :            : #include <linux/fs_parser.h>
      41                 :            : #include "internal.h"
      42                 :            : 
      43                 :            : struct ramfs_mount_opts {
      44                 :            :         umode_t mode;
      45                 :            : };
      46                 :            : 
      47                 :            : struct ramfs_fs_info {
      48                 :            :         struct ramfs_mount_opts mount_opts;
      49                 :            : };
      50                 :            : 
      51                 :            : #define RAMFS_DEFAULT_MODE      0755
      52                 :            : 
      53                 :            : static const struct super_operations ramfs_ops;
      54                 :            : static const struct inode_operations ramfs_dir_inode_operations;
      55                 :            : 
      56                 :            : static const struct address_space_operations ramfs_aops = {
      57                 :            :         .readpage       = simple_readpage,
      58                 :            :         .write_begin    = simple_write_begin,
      59                 :            :         .write_end      = simple_write_end,
      60                 :            :         .set_page_dirty = __set_page_dirty_no_writeback,
      61                 :            : };
      62                 :            : 
      63                 :          3 : struct inode *ramfs_get_inode(struct super_block *sb,
      64                 :            :                                 const struct inode *dir, umode_t mode, dev_t dev)
      65                 :            : {
      66                 :          3 :         struct inode * inode = new_inode(sb);
      67                 :            : 
      68                 :          3 :         if (inode) {
      69                 :          3 :                 inode->i_ino = get_next_ino();
      70                 :          3 :                 inode_init_owner(inode, dir, mode);
      71                 :          3 :                 inode->i_mapping->a_ops = &ramfs_aops;
      72                 :          3 :                 mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER);
      73                 :          3 :                 mapping_set_unevictable(inode->i_mapping);
      74                 :          3 :                 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
      75                 :          3 :                 switch (mode & S_IFMT) {
      76                 :            :                 default:
      77                 :          3 :                         init_special_inode(inode, mode, dev);
      78                 :          3 :                         break;
      79                 :            :                 case S_IFREG:
      80                 :          0 :                         inode->i_op = &ramfs_file_inode_operations;
      81                 :          0 :                         inode->i_fop = &ramfs_file_operations;
      82                 :          0 :                         break;
      83                 :            :                 case S_IFDIR:
      84                 :          3 :                         inode->i_op = &ramfs_dir_inode_operations;
      85                 :          3 :                         inode->i_fop = &simple_dir_operations;
      86                 :            : 
      87                 :            :                         /* directory inodes start off with i_nlink == 2 (for "." entry) */
      88                 :          3 :                         inc_nlink(inode);
      89                 :          3 :                         break;
      90                 :            :                 case S_IFLNK:
      91                 :          0 :                         inode->i_op = &page_symlink_inode_operations;
      92                 :          0 :                         inode_nohighmem(inode);
      93                 :          0 :                         break;
      94                 :            :                 }
      95                 :            :         }
      96                 :          3 :         return inode;
      97                 :            : }
      98                 :            : 
      99                 :            : /*
     100                 :            :  * File creation. Allocate an inode, and we're done..
     101                 :            :  */
     102                 :            : /* SMP-safe */
     103                 :            : static int
     104                 :          3 : ramfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
     105                 :            : {
     106                 :          3 :         struct inode * inode = ramfs_get_inode(dir->i_sb, dir, mode, dev);
     107                 :            :         int error = -ENOSPC;
     108                 :            : 
     109                 :          3 :         if (inode) {
     110                 :          3 :                 d_instantiate(dentry, inode);
     111                 :            :                 dget(dentry);   /* Extra count - pin the dentry in core */
     112                 :            :                 error = 0;
     113                 :          3 :                 dir->i_mtime = dir->i_ctime = current_time(dir);
     114                 :            :         }
     115                 :          3 :         return error;
     116                 :            : }
     117                 :            : 
     118                 :          3 : static int ramfs_mkdir(struct inode * dir, struct dentry * dentry, umode_t mode)
     119                 :            : {
     120                 :          3 :         int retval = ramfs_mknod(dir, dentry, mode | S_IFDIR, 0);
     121                 :          3 :         if (!retval)
     122                 :          3 :                 inc_nlink(dir);
     123                 :          3 :         return retval;
     124                 :            : }
     125                 :            : 
     126                 :          0 : static int ramfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl)
     127                 :            : {
     128                 :          0 :         return ramfs_mknod(dir, dentry, mode | S_IFREG, 0);
     129                 :            : }
     130                 :            : 
     131                 :          0 : static int ramfs_symlink(struct inode * dir, struct dentry *dentry, const char * symname)
     132                 :            : {
     133                 :            :         struct inode *inode;
     134                 :            :         int error = -ENOSPC;
     135                 :            : 
     136                 :          0 :         inode = ramfs_get_inode(dir->i_sb, dir, S_IFLNK|S_IRWXUGO, 0);
     137                 :          0 :         if (inode) {
     138                 :          0 :                 int l = strlen(symname)+1;
     139                 :          0 :                 error = page_symlink(inode, symname, l);
     140                 :          0 :                 if (!error) {
     141                 :          0 :                         d_instantiate(dentry, inode);
     142                 :            :                         dget(dentry);
     143                 :          0 :                         dir->i_mtime = dir->i_ctime = current_time(dir);
     144                 :            :                 } else
     145                 :          0 :                         iput(inode);
     146                 :            :         }
     147                 :          0 :         return error;
     148                 :            : }
     149                 :            : 
     150                 :            : static const struct inode_operations ramfs_dir_inode_operations = {
     151                 :            :         .create         = ramfs_create,
     152                 :            :         .lookup         = simple_lookup,
     153                 :            :         .link           = simple_link,
     154                 :            :         .unlink         = simple_unlink,
     155                 :            :         .symlink        = ramfs_symlink,
     156                 :            :         .mkdir          = ramfs_mkdir,
     157                 :            :         .rmdir          = simple_rmdir,
     158                 :            :         .mknod          = ramfs_mknod,
     159                 :            :         .rename         = simple_rename,
     160                 :            : };
     161                 :            : 
     162                 :            : /*
     163                 :            :  * Display the mount options in /proc/mounts.
     164                 :            :  */
     165                 :          0 : static int ramfs_show_options(struct seq_file *m, struct dentry *root)
     166                 :            : {
     167                 :          0 :         struct ramfs_fs_info *fsi = root->d_sb->s_fs_info;
     168                 :            : 
     169                 :          0 :         if (fsi->mount_opts.mode != RAMFS_DEFAULT_MODE)
     170                 :          0 :                 seq_printf(m, ",mode=%o", fsi->mount_opts.mode);
     171                 :          0 :         return 0;
     172                 :            : }
     173                 :            : 
     174                 :            : static const struct super_operations ramfs_ops = {
     175                 :            :         .statfs         = simple_statfs,
     176                 :            :         .drop_inode     = generic_delete_inode,
     177                 :            :         .show_options   = ramfs_show_options,
     178                 :            : };
     179                 :            : 
     180                 :            : enum ramfs_param {
     181                 :            :         Opt_mode,
     182                 :            : };
     183                 :            : 
     184                 :            : static const struct fs_parameter_spec ramfs_param_specs[] = {
     185                 :            :         fsparam_u32oct("mode",        Opt_mode),
     186                 :            :         {}
     187                 :            : };
     188                 :            : 
     189                 :            : const struct fs_parameter_description ramfs_fs_parameters = {
     190                 :            :         .name           = "ramfs",
     191                 :            :         .specs          = ramfs_param_specs,
     192                 :            : };
     193                 :            : 
     194                 :          3 : static int ramfs_parse_param(struct fs_context *fc, struct fs_parameter *param)
     195                 :            : {
     196                 :            :         struct fs_parse_result result;
     197                 :          3 :         struct ramfs_fs_info *fsi = fc->s_fs_info;
     198                 :            :         int opt;
     199                 :            : 
     200                 :          3 :         opt = fs_parse(fc, &ramfs_fs_parameters, param, &result);
     201                 :          3 :         if (opt < 0) {
     202                 :            :                 /*
     203                 :            :                  * We might like to report bad mount options here;
     204                 :            :                  * but traditionally ramfs has ignored all mount options,
     205                 :            :                  * and as it is used as a !CONFIG_SHMEM simple substitute
     206                 :            :                  * for tmpfs, better continue to ignore other mount options.
     207                 :            :                  */
     208                 :          3 :                 if (opt == -ENOPARAM)
     209                 :            :                         opt = 0;
     210                 :          3 :                 return opt;
     211                 :            :         }
     212                 :            : 
     213                 :          0 :         switch (opt) {
     214                 :            :         case Opt_mode:
     215                 :          0 :                 fsi->mount_opts.mode = result.uint_32 & S_IALLUGO;
     216                 :          0 :                 break;
     217                 :            :         }
     218                 :            : 
     219                 :            :         return 0;
     220                 :            : }
     221                 :            : 
     222                 :          3 : static int ramfs_fill_super(struct super_block *sb, struct fs_context *fc)
     223                 :            : {
     224                 :          3 :         struct ramfs_fs_info *fsi = sb->s_fs_info;
     225                 :            :         struct inode *inode;
     226                 :            : 
     227                 :          3 :         sb->s_maxbytes               = MAX_LFS_FILESIZE;
     228                 :          3 :         sb->s_blocksize              = PAGE_SIZE;
     229                 :          3 :         sb->s_blocksize_bits = PAGE_SHIFT;
     230                 :          3 :         sb->s_magic          = RAMFS_MAGIC;
     231                 :          3 :         sb->s_op             = &ramfs_ops;
     232                 :          3 :         sb->s_time_gran              = 1;
     233                 :            : 
     234                 :          3 :         inode = ramfs_get_inode(sb, NULL, S_IFDIR | fsi->mount_opts.mode, 0);
     235                 :          3 :         sb->s_root = d_make_root(inode);
     236                 :          3 :         if (!sb->s_root)
     237                 :            :                 return -ENOMEM;
     238                 :            : 
     239                 :          3 :         return 0;
     240                 :            : }
     241                 :            : 
     242                 :          3 : static int ramfs_get_tree(struct fs_context *fc)
     243                 :            : {
     244                 :          3 :         return get_tree_nodev(fc, ramfs_fill_super);
     245                 :            : }
     246                 :            : 
     247                 :          3 : static void ramfs_free_fc(struct fs_context *fc)
     248                 :            : {
     249                 :          3 :         kfree(fc->s_fs_info);
     250                 :          3 : }
     251                 :            : 
     252                 :            : static const struct fs_context_operations ramfs_context_ops = {
     253                 :            :         .free           = ramfs_free_fc,
     254                 :            :         .parse_param    = ramfs_parse_param,
     255                 :            :         .get_tree       = ramfs_get_tree,
     256                 :            : };
     257                 :            : 
     258                 :          3 : int ramfs_init_fs_context(struct fs_context *fc)
     259                 :            : {
     260                 :            :         struct ramfs_fs_info *fsi;
     261                 :            : 
     262                 :          3 :         fsi = kzalloc(sizeof(*fsi), GFP_KERNEL);
     263                 :          3 :         if (!fsi)
     264                 :            :                 return -ENOMEM;
     265                 :            : 
     266                 :          3 :         fsi->mount_opts.mode = RAMFS_DEFAULT_MODE;
     267                 :          3 :         fc->s_fs_info = fsi;
     268                 :          3 :         fc->ops = &ramfs_context_ops;
     269                 :          3 :         return 0;
     270                 :            : }
     271                 :            : 
     272                 :          0 : static void ramfs_kill_sb(struct super_block *sb)
     273                 :            : {
     274                 :          0 :         kfree(sb->s_fs_info);
     275                 :          0 :         kill_litter_super(sb);
     276                 :          0 : }
     277                 :            : 
     278                 :            : static struct file_system_type ramfs_fs_type = {
     279                 :            :         .name           = "ramfs",
     280                 :            :         .init_fs_context = ramfs_init_fs_context,
     281                 :            :         .parameters     = &ramfs_fs_parameters,
     282                 :            :         .kill_sb        = ramfs_kill_sb,
     283                 :            :         .fs_flags       = FS_USERNS_MOUNT,
     284                 :            : };
     285                 :            : 
     286                 :          3 : static int __init init_ramfs_fs(void)
     287                 :            : {
     288                 :          3 :         return register_filesystem(&ramfs_fs_type);
     289                 :            : }
     290                 :            : fs_initcall(init_ramfs_fs);