LCOV - code coverage report
Current view: top level - lkbce/fs/configfs - mount.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 41 67 61.2 %
Date: 2017-01-25 Functions: 4 7 57.1 %

          Line data    Source code
       1             : /* -*- mode: c; c-basic-offset: 8; -*-
       2             :  * vim: noexpandtab sw=8 ts=8 sts=0:
       3             :  *
       4             :  * mount.c - operations for initializing and mounting configfs.
       5             :  *
       6             :  * This program is free software; you can redistribute it and/or
       7             :  * modify it under the terms of the GNU General Public
       8             :  * License as published by the Free Software Foundation; either
       9             :  * version 2 of the License, or (at your option) any later version.
      10             :  *
      11             :  * This program is distributed in the hope that it will be useful,
      12             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14             :  * General Public License for more details.
      15             :  *
      16             :  * You should have received a copy of the GNU General Public
      17             :  * License along with this program; if not, write to the
      18             :  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
      19             :  * Boston, MA 021110-1307, USA.
      20             :  *
      21             :  * Based on sysfs:
      22             :  *      sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel
      23             :  *
      24             :  * configfs Copyright (C) 2005 Oracle.  All rights reserved.
      25             :  */
      26             : 
      27             : #include <linux/fs.h>
      28             : #include <linux/module.h>
      29             : #include <linux/mount.h>
      30             : #include <linux/pagemap.h>
      31             : #include <linux/init.h>
      32             : 
      33             : #include <linux/configfs.h>
      34             : #include "configfs_internal.h"
      35             : 
      36             : /* Random magic number */
      37             : #define CONFIGFS_MAGIC 0x62656570
      38             : 
      39           1 : struct vfsmount * configfs_mount = NULL;
      40           1 : struct super_block * configfs_sb = NULL;
      41             : struct kmem_cache *configfs_dir_cachep;
      42           1 : static int configfs_mnt_count = 0;
      43             : 
      44           1 : static const struct super_operations configfs_ops = {
      45             :         .statfs         = simple_statfs,
      46             :         .drop_inode     = generic_delete_inode,
      47             : };
      48             : 
      49           1 : static struct config_group configfs_root_group = {
      50             :         .cg_item = {
      51             :                 .ci_namebuf     = "root",
      52             :                 .ci_name        = configfs_root_group.cg_item.ci_namebuf,
      53             :         },
      54             : };
      55             : 
      56             : int configfs_is_root(struct config_item *item)
      57             : {
      58           4 :         return item == &configfs_root_group.cg_item;
      59             : }
      60             : 
      61           1 : static struct configfs_dirent configfs_root = {
      62             :         .s_sibling      = LIST_HEAD_INIT(configfs_root.s_sibling),
      63             :         .s_children     = LIST_HEAD_INIT(configfs_root.s_children),
      64             :         .s_element      = &configfs_root_group.cg_item,
      65             :         .s_type         = CONFIGFS_ROOT,
      66             :         .s_iattr        = NULL,
      67             : };
      68             : 
      69             : static int configfs_fill_super(struct super_block *sb, void *data, int silent)
      70             : {
      71           0 :         struct inode *inode;
      72           0 :         struct dentry *root;
      73             : 
      74           0 :         sb->s_blocksize = PAGE_CACHE_SIZE;
      75           0 :         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
      76           0 :         sb->s_magic = CONFIGFS_MAGIC;
      77           0 :         sb->s_op = &configfs_ops;
      78           0 :         sb->s_time_gran = 1;
      79           0 :         configfs_sb = sb;
      80             : 
      81           0 :         inode = configfs_new_inode(S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO,
      82             :                                    &configfs_root);
      83           0 :         if (inode) {
      84           0 :                 inode->i_op = &configfs_dir_inode_operations;
      85           0 :                 inode->i_fop = &configfs_dir_operations;
      86             :                 /* directory inodes start off with i_nlink == 2 (for "." entry) */
      87           0 :                 inc_nlink(inode);
      88             :         } else {
      89             :                 pr_debug("configfs: could not get root inode\n");
      90           0 :                 return -ENOMEM;
      91             :         }
      92             : 
      93           0 :         root = d_alloc_root(inode);
      94           0 :         if (!root) {
      95             :                 pr_debug("%s: could not get root dentry!\n",__func__);
      96           0 :                 iput(inode);
      97           0 :                 return -ENOMEM;
      98             :         }
      99           0 :         config_group_init(&configfs_root_group);
     100           0 :         configfs_root_group.cg_item.ci_dentry = root;
     101           0 :         root->d_fsdata = &configfs_root;
     102           0 :         sb->s_root = root;
     103           0 :         return 0;
     104             : }
     105             : 
     106             : static int configfs_get_sb(struct file_system_type *fs_type,
     107             :         int flags, const char *dev_name, void *data, struct vfsmount *mnt)
     108             : {
     109           3 :         return get_sb_single(fs_type, flags, data, configfs_fill_super, mnt);
     110             : }
     111             : 
     112           1 : static struct file_system_type configfs_fs_type = {
     113             :         .owner          = THIS_MODULE,
     114             :         .name           = "configfs",
     115             :         .get_sb         = configfs_get_sb,
     116             :         .kill_sb        = kill_litter_super,
     117             : };
     118             : 
     119             : int configfs_pin_fs(void)
     120             : {
     121           0 :         return simple_pin_fs(&configfs_fs_type, &configfs_mount,
     122             :                              &configfs_mnt_count);
     123             : }
     124             : 
     125             : void configfs_release_fs(void)
     126             : {
     127           0 :         simple_release_fs(&configfs_mount, &configfs_mnt_count);
     128           0 : }
     129             : 
     130             : 
     131           1 : static struct kobject *config_kobj;
     132             : 
     133             : static int __init configfs_init(void)
     134             : {
     135           2 :         int err = -ENOMEM;
     136             : 
     137           1 :         configfs_dir_cachep = kmem_cache_create("configfs_dir_cache",
     138             :                                                 sizeof(struct configfs_dirent),
     139             :                                                 0, 0, NULL);
     140           2 :         if (!configfs_dir_cachep)
     141           1 :                 goto out;
     142             : 
     143           1 :         config_kobj = kobject_create_and_add("config", kernel_kobj);
     144           2 :         if (!config_kobj) {
     145           1 :                 kmem_cache_destroy(configfs_dir_cachep);
     146           1 :                 configfs_dir_cachep = NULL;
     147           1 :                 goto out;
     148             :         }
     149             : 
     150           2 :         err = register_filesystem(&configfs_fs_type);
     151           2 :         if (err) {
     152           1 :                 printk(KERN_ERR "configfs: Unable to register filesystem!\n");
     153           1 :                 kobject_put(config_kobj);
     154           1 :                 kmem_cache_destroy(configfs_dir_cachep);
     155           1 :                 configfs_dir_cachep = NULL;
     156           1 :                 goto out;
     157             :         }
     158             : 
     159           2 :         err = configfs_inode_init();
     160           2 :         if (err) {
     161           2 :                 unregister_filesystem(&configfs_fs_type);
     162           1 :                 kobject_put(config_kobj);
     163           1 :                 kmem_cache_destroy(configfs_dir_cachep);
     164           1 :                 configfs_dir_cachep = NULL;
     165             :         }
     166             : out:
     167           4 :         return err;
     168             : }
     169           2 : 
     170             : static void __exit configfs_exit(void)
     171             : {
     172           4 :         unregister_filesystem(&configfs_fs_type);
     173           2 :         kobject_put(config_kobj);
     174           2 :         kmem_cache_destroy(configfs_dir_cachep);
     175           2 :         configfs_dir_cachep = NULL;
     176           4 :         configfs_inode_exit();
     177           2 : }
     178             : 
     179             : MODULE_AUTHOR("Oracle");
     180             : MODULE_LICENSE("GPL");
     181             : MODULE_VERSION("0.0.2");
     182             : MODULE_DESCRIPTION("Simple RAM filesystem for user driven kernel subsystem configuration.");
     183             : 
     184             : module_init(configfs_init);
     185             : module_exit(configfs_exit);

Generated by: LCOV version 1.10