static int oprofilefs_fill_super(struct super_block *sb, void *data, int silent) { struct inode *root_inode; struct dentry *root_dentry; sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; sb->s_magic = OPROFILEFS_MAGIC; sb->s_op = &s_ops; sb->s_time_gran = 1; root_inode = oprofilefs_get_inode(sb, S_IFDIR | 0755); if (!root_inode) return -ENOMEM; root_inode->i_op = &simple_dir_inode_operations; root_inode->i_fop = &simple_dir_operations; root_dentry = d_make_root(root_inode); if (!root_dentry) return -ENOMEM; sb->s_root = root_dentry; oprofile_create_files(sb, root_dentry); // FIXME: verify kill_litter_super removes our dentries return 0; }
static int kernfs_fill_super(struct super_block *sb) { struct kernfs_super_info *info = kernfs_info(sb); struct inode *inode; struct dentry *root; sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; sb->s_magic = SYSFS_MAGIC; sb->s_op = &kernfs_sops; sb->s_time_gran = 1; /* get root inode, initialize and unlock it */ mutex_lock(&kernfs_mutex); inode = kernfs_get_inode(sb, info->root->kn); mutex_unlock(&kernfs_mutex); if (!inode) { pr_debug("kernfs: could not get root inode\n"); return -ENOMEM; } /* instantiate and link root dentry */ root = d_make_root(inode); if (!root) { pr_debug("%s: could not get root dentry!\n", __func__); return -ENOMEM; } kernfs_get(info->root->kn); root->d_fsdata = info->root->kn; sb->s_root = root; sb->s_d_op = &kernfs_dops; return 0; }
static int orangefs_fill_sb(struct super_block *sb, struct orangefs_fs_mount_response *fs_mount, void *data, int silent) { int ret = -EINVAL; struct inode *root = NULL; struct dentry *root_dentry = NULL; struct orangefs_object_kref root_object; /* alloc and init our private orangefs sb info */ sb->s_fs_info = kzalloc(sizeof(struct orangefs_sb_info_s), GFP_KERNEL); if (!ORANGEFS_SB(sb)) return -ENOMEM; ORANGEFS_SB(sb)->sb = sb; ORANGEFS_SB(sb)->root_khandle = fs_mount->root_khandle; ORANGEFS_SB(sb)->fs_id = fs_mount->fs_id; ORANGEFS_SB(sb)->id = fs_mount->id; if (data) { ret = parse_mount_options(sb, data, silent); if (ret) return ret; } /* Hang the xattr handlers off the superblock */ sb->s_xattr = orangefs_xattr_handlers; sb->s_magic = ORANGEFS_SUPER_MAGIC; sb->s_op = &orangefs_s_ops; sb->s_d_op = &orangefs_dentry_operations; sb->s_blocksize = orangefs_bufmap_size_query(); sb->s_blocksize_bits = orangefs_bufmap_shift_query(); sb->s_maxbytes = MAX_LFS_FILESIZE; root_object.khandle = ORANGEFS_SB(sb)->root_khandle; root_object.fs_id = ORANGEFS_SB(sb)->fs_id; gossip_debug(GOSSIP_SUPER_DEBUG, "get inode %pU, fsid %d\n", &root_object.khandle, root_object.fs_id); root = orangefs_iget(sb, &root_object); if (IS_ERR(root)) return PTR_ERR(root); gossip_debug(GOSSIP_SUPER_DEBUG, "Allocated root inode [%p] with mode %x\n", root, root->i_mode); /* allocates and places root dentry in dcache */ root_dentry = d_make_root(root); if (!root_dentry) return -ENOMEM; sb->s_export_op = &orangefs_export_ops; sb->s_root = root_dentry; return 0; }
static int devpts_fill_super(struct super_block *s, void *data, int silent) { struct inode *inode; s->s_blocksize = 1024; s->s_blocksize_bits = 10; s->s_magic = DEVPTS_SUPER_MAGIC; s->s_op = &devpts_sops; s->s_time_gran = 1; s->s_fs_info = new_pts_fs_info(); if (!s->s_fs_info) goto fail; inode = new_inode(s); if (!inode) goto fail; inode->i_ino = 1; inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR; inode->i_op = &simple_dir_inode_operations; inode->i_fop = &simple_dir_operations; set_nlink(inode, 2); s->s_root = d_make_root(inode); if (s->s_root) return 0; printk(KERN_ERR "devpts: get root dentry failed\n"); fail: return -ENOMEM; }
int sjfs_fill_super(struct super_block *sb, void *data, int silent) { struct inode *inode; struct dentry *root; printk("sjfs_fill_super\n"); sb->s_maxbytes = MAX_LFS_FILESIZE; sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; sb->s_magic = SJFS_MAGIC; sb->s_op = &sjfs_sops; sb->s_time_gran = 1; save_mount_options(sb, data); // for generic_show_options inode = ramfs2_get_inode(sb, NULL, S_IFDIR | S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH, 0); if (!inode) return -ENOMEM; root = d_make_root(inode); if (!root) return -ENOMEM; sb->s_root = root; return 0; }
static int dumpfs_read_sb(struct super_block *sb, void *data, int silent) { int err = 0; struct inode *inode; struct buffer_head *bh; struct dumpfs_sb_info *sbi; dumpfs_super_block_t *ds; char *dev_name = (char *)data; if (!dev_name) { err = -EINVAL; goto out; } /* * dev_name is device_name or file that needs to be mounted * mount -t dumpfs /mnt/filename /mnt/dumpfs, dev_name points * to /mnt/filename. */ /* connect dumpfs superblock later */ sbi = kzalloc(sizeof(struct dumpfs_sb_info), GFP_KERNEL); if (!sbi) { err = -ENOMEM; goto out; } sb->s_fs_info = sbi; /* read the superblock from the disk */ if (!(bh = sb_bread(sb, 0))) { goto free; } ds = (dumpfs_super_block_t *)bh->b_data; sb->s_magic = ds->s_magic; sb->s_time_gran = 1; sb->s_op = &dumpfs_sops; sbi->s_buf = ds; printk(KERN_INFO "sbi->s_buf %p\n", sb->s_fs_info); inode = dumpfs_iget(sb, DUMPFS_ROOT_INUM); if (IS_ERR(inode)) { printk(KERN_INFO "%d \n", __LINE__); err = PTR_ERR(inode); goto out; } printk(KERN_INFO "inode %p magic %x\n", inode, ds->s_magic); sb->s_root = d_make_root(inode); if (!sb->s_root) { err = -ENOMEM; goto free; } d_rehash(sb->s_root); d_set_d_op(sb->s_root, &dumpfs_dops); goto out; free: printk(KERN_INFO "Failed free superblock"); kfree(sb->s_fs_info); out: return (err); }
static int aufs_fill_sb(struct super_block *sb, void *data, int silent) { struct aufs_super_block *asb = aufs_super_block_read(sb); struct inode *root; if (!asb) return -EINVAL; sb->s_magic = asb->asb_magic; sb->s_fs_info = asb; sb->s_op = &aufs_super_ops; if (sb_set_blocksize(sb, asb->asb_block_size) == 0) { pr_err("device does not support block size %lu\n", (unsigned long)asb->asb_block_size); return -EINVAL; } root = aufs_inode_get(sb, asb->asb_root_inode); if (IS_ERR(root)) return PTR_ERR(root); sb->s_root = d_make_root(root); if (!sb->s_root) { pr_err("aufs cannot create root\n"); return -ENOMEM; } return 0; }
static int aufs_fill_sb(struct super_block *sb, void *data, int silent) { struct inode *root = NULL; sb->s_magic = AUFS_MAGIC_NUMBER; sb->s_op = &aufs_super_ops; root = new_inode(sb); if (!root) { pr_err("inode allocation failed\n"); return -ENOMEM; } root->i_ino = 0; root->i_sb = sb; root->i_atime = root->i_mtime = root->i_ctime = CURRENT_TIME; inode_init_owner(root, NULL, S_IFDIR); sb->s_root = d_make_root(root); if (!sb->s_root) { pr_err("root creation failed\n"); return -ENOMEM; } return 0; }
int sjfs_fill_super(struct super_block *sb, void *data, int silent) { struct inode *inode; struct dentry *root; sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; sb->s_magic = SJFS_MAGIC; sb->s_op = &sjfs_sops; sb->s_time_gran = 1; save_mount_options(sb, data); // for generic_show_options inode = new_inode(sb); if (!inode) return -ENOMEM; inode->i_ino = 1; inode->i_mode = S_IFDIR | 0755; inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; inode->i_op = &sjfs_iops; // simple_dir_inode_operations inode->i_fop = &sjfs_fops; // simple_dir_operations set_nlink(inode, 2); root = d_make_root(inode); if (!root) return -ENOMEM; sb->s_root = root; return 0; }
static int ext4_read_super(struct super_block *sb, void *data, int flags) { int ret; struct inode *in; struct dentry *root; ret = ext4_fill_super(sb); if (ret < 0) { // ... return ret; } GEN_DBG("\n"); in = ext4_iget(sb, 2); if (!in) { // ... return -EINVAL; } root = d_make_root(in); if (!root) return EINVAL; sb->s_root = root; return 0; }
/** \<\<private\>\> Fill proxyfs superblock * * @param sb - pointer to superblock * @param data - mount options etc... * @param silent - * * @return Zero on success */ static int proxyfs_fs_fill_super(struct super_block *sb, void *data, int silent) { struct inode *rootinode; sb->s_blocksize = 1024; sb->s_blocksize_bits = 10; sb->s_magic = 0x28021985; sb->s_op = &proxyfs_sops; // super block operations sb->s_type = &proxyfs; // file_system_type sb->s_fs_info = data; // proxyfs_client task rootinode = iget_locked(sb, 0xFFFFFFFF); // allocate an inode rootinode->i_op = &rootinode_iops; // set the inode ops //rootinode->i_fop = &rootinode_fops; rootinode->i_mode = S_IFDIR | S_IRUSR | S_IXUSR; rootinode->i_mtime = rootinode->i_atime = rootinode->i_ctime = CURRENT_TIME; //Fix change call function from d_alloc_root to d_make_root for kernel 3.x.x by Jiri Rakosnik if( !(sb->s_root = d_make_root(rootinode)) ){ iput(rootinode); return -ENOMEM; } unlock_new_inode(rootinode); return 0; }
int ramfs_fill_super(struct super_block *sb, void *data, int silent) { struct ramfs_fs_info *fsi; struct inode *inode; int err; save_mount_options(sb, data); fsi = kzalloc(sizeof(struct ramfs_fs_info), GFP_KERNEL); sb->s_fs_info = fsi; if (!fsi) return -ENOMEM; err = ramfs_parse_options(data, &fsi->mount_opts); if (err) return err; sb->s_maxbytes = MAX_LFS_FILESIZE; sb->s_blocksize = PAGE_SIZE; sb->s_blocksize_bits = PAGE_SHIFT; sb->s_magic = RAMFS_MAGIC; sb->s_op = &ramfs_ops; sb->s_time_gran = 1; inode = ramfs_get_inode(sb, NULL, S_IFDIR | fsi->mount_opts.mode, 0); sb->s_root = d_make_root(inode); if (!sb->s_root) return -ENOMEM; return 0; }
/** * \<\<public\>\> Initializes a root entry instance. * * @param *self - pointer to this instance * @param *sb - pointer to the super block of the filesystem * @param *mode - file type and access rights for the inode * @param *entry_ops - custom operations of the child class * @param *i_ops - inode operations * @param *f_ops - file operations(also stored in the new inode) * @return 0 upon success */ int tcmi_ctlfs_rootentry_init(struct tcmi_ctlfs_entry *self, struct super_block *sb, mode_t mode, struct tcmi_ctlfs_ops *entry_ops, const struct inode_operations *i_ops, const struct file_operations *f_ops) { struct dentry *root; struct inode *inode; mdbg(INFO3, "Initializing a root entry"); if (!(inode = tcmi_ctlfs_get_inode(NULL, sb, mode, i_ops, f_ops))) { mdbg(ERR1, "Failed to allocate inode for root dentry!"); goto exit0; } /* try allocating the dentry */ //Replaced function d_alloc_root to d_make_root for kernel 3.x | by Jiri Rakosnik if (!(root = d_make_root(inode))) { mdbg(ERR1, "Failed to allocate a root dentry!"); goto exit1; } /* Initialize the dentry */ root->d_fsdata = (void *)self; root->d_op = &tcmi_ctlfs_dentry_ops; self->dentry = root; sb->s_root = root; /* Custom operations of the child class */ self->entry_ops = entry_ops; return 0; /* error handling*/ exit1: iput(inode); exit0: return -ENOSPC; }
static int sysfs_fill_super(struct super_block *sb, void *data, int silent) { struct inode *inode; struct dentry *root; sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; sb->s_magic = SYSFS_MAGIC; sb->s_op = &sysfs_ops; sb->s_time_gran = 1; /* get root inode, initialize and unlock it */ mutex_lock(&sysfs_mutex); inode = sysfs_get_inode(sb, &sysfs_root); mutex_unlock(&sysfs_mutex); if (!inode) { pr_debug("sysfs: could not get root inode\n"); return -ENOMEM; } /* instantiate and link root dentry */ root = d_make_root(inode); if (!root) { pr_debug("%s: could not get root dentry!\n",__func__); return -ENOMEM; } root->d_fsdata = &sysfs_root; sb->s_root = root; return 0; }
static int configfs_fill_super(struct super_block *sb, void *data, int silent) { struct inode *inode; struct dentry *root; sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; sb->s_magic = CONFIGFS_MAGIC; sb->s_op = &configfs_ops; sb->s_time_gran = 1; inode = configfs_new_inode(S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO, &configfs_root, sb); if (inode) { inode->i_op = &configfs_root_inode_operations; inode->i_fop = &configfs_dir_operations; /* directory inodes start off with i_nlink == 2 (for "." entry) */ inc_nlink(inode); } else { pr_debug("could not get root inode\n"); return -ENOMEM; } root = d_make_root(inode); if (!root) { pr_debug("%s: could not get root dentry!\n",__func__); return -ENOMEM; } config_group_init(&configfs_root_group); configfs_root_group.cg_item.ci_dentry = root; root->d_fsdata = &configfs_root; sb->s_root = root; sb->s_d_op = &configfs_dentry_ops; /* the rest get that */ return 0; }
static int gatorfs_fill_super(struct super_block *sb, void *data, int silent) { struct inode *root_inode; struct dentry *root_dentry; sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; sb->s_magic = gatorfs_MAGIC; sb->s_op = &s_ops; sb->s_time_gran = 1; root_inode = gatorfs_get_inode(sb, S_IFDIR | 0755); if (!root_inode) return -ENOMEM; root_inode->i_op = &simple_dir_inode_operations; root_inode->i_fop = &simple_dir_operations; root_dentry = d_make_root(root_inode); if (!root_dentry) { return -ENOMEM; } sb->s_root = root_dentry; gator_op_create_files(sb, root_dentry); return 0; }
static int efivarfs_fill_super(struct super_block *sb, void *data, int silent) { struct inode *inode = NULL; struct dentry *root; int err; efivarfs_sb = sb; sb->s_maxbytes = MAX_LFS_FILESIZE; sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; sb->s_magic = EFIVARFS_MAGIC; sb->s_op = &efivarfs_ops; sb->s_d_op = &efivarfs_d_ops; sb->s_time_gran = 1; inode = efivarfs_get_inode(sb, NULL, S_IFDIR | 0755, 0, true); if (!inode) return -ENOMEM; inode->i_op = &efivarfs_dir_inode_operations; root = d_make_root(inode); sb->s_root = root; if (!root) return -ENOMEM; INIT_LIST_HEAD(&efivarfs_list); err = efivar_init(efivarfs_callback, (void *)sb, false, true, &efivarfs_list); if (err) __efivar_entry_iter(efivarfs_destroy, &efivarfs_list, NULL, NULL); return err; }
static int cifs_read_super(struct super_block *sb) { struct inode *inode; struct cifs_sb_info *cifs_sb; struct cifs_tcon *tcon; int rc = 0; cifs_sb = CIFS_SB(sb); tcon = cifs_sb_master_tcon(cifs_sb); if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL) sb->s_flags |= MS_POSIXACL; if (tcon->ses->capabilities & tcon->ses->server->vals->cap_large_files) sb->s_maxbytes = MAX_LFS_FILESIZE; else sb->s_maxbytes = MAX_NON_LFS; /* BB FIXME fix time_gran to be larger for LANMAN sessions */ sb->s_time_gran = 100; sb->s_magic = CIFS_MAGIC_NUMBER; sb->s_op = &cifs_super_ops; sb->s_xattr = cifs_xattr_handlers; sb->s_bdi = &cifs_sb->bdi; sb->s_blocksize = CIFS_MAX_MSGSIZE; sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */ inode = cifs_root_iget(sb); if (IS_ERR(inode)) { rc = PTR_ERR(inode); goto out_no_root; } if (tcon->nocase) sb->s_d_op = &cifs_ci_dentry_ops; else sb->s_d_op = &cifs_dentry_ops; sb->s_root = d_make_root(inode); if (!sb->s_root) { rc = -ENOMEM; goto out_no_root; } #ifdef CONFIG_CIFS_NFSD_EXPORT if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) { cifs_dbg(FYI, "export ops supported\n"); sb->s_export_op = &cifs_export_ops; } #endif /* CONFIG_CIFS_NFSD_EXPORT */ return 0; out_no_root: cifs_dbg(VFS, "%s: get root inode failed\n", __func__); return rc; }
static int cifs_read_super(struct super_block *sb) { struct inode *inode; struct cifs_sb_info *cifs_sb; int rc = 0; cifs_sb = CIFS_SB(sb); if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL) sb->s_flags |= MS_POSIXACL; if (cifs_sb_master_tcon(cifs_sb)->ses->capabilities & CAP_LARGE_FILES) sb->s_maxbytes = MAX_LFS_FILESIZE; else sb->s_maxbytes = MAX_NON_LFS; /* BB FIXME fix time_gran to be larger for LANMAN sessions */ sb->s_time_gran = 100; sb->s_magic = CIFS_MAGIC_NUMBER; sb->s_op = &cifs_super_ops; sb->s_bdi = &cifs_sb->bdi; sb->s_blocksize = CIFS_MAX_MSGSIZE; sb->s_blocksize_bits = 14; /* default 2**14 = CIFS_MAX_MSGSIZE */ inode = cifs_root_iget(sb); if (IS_ERR(inode)) { rc = PTR_ERR(inode); goto out_no_root; } sb->s_root = d_make_root(inode); if (!sb->s_root) { rc = -ENOMEM; goto out_no_root; } /* do that *after* d_alloc_root() - we want NULL ->d_op for root here */ if (cifs_sb_master_tcon(cifs_sb)->nocase) sb->s_d_op = &cifs_ci_dentry_ops; else sb->s_d_op = &cifs_dentry_ops; #ifdef CONFIG_CIFS_NFSD_EXPORT if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) { cFYI(1, "export ops supported"); sb->s_export_op = &cifs_export_ops; } #endif /* CONFIG_CIFS_NFSD_EXPORT */ return 0; out_no_root: cERROR(1, "cifs_read_super: get root inode failed"); return rc; }
static int sfs_fill_super(struct super_block *sb, void *data, int silent) { sfs_info_t *info; printk(KERN_INFO "sfs: sfs_fill_super\n"); if (!(info = (sfs_info_t *)(kzalloc(sizeof(sfs_info_t), GFP_KERNEL)))) return -ENOMEM; info->vfs_sb = sb; if (init_browsing(info) < 0) { kfree(info); return -EIO; } /* Updating the VFS super_block */ sb->s_magic = info->sb.type; sb->s_blocksize = info->sb.block_size; sb->s_blocksize_bits = get_bit_pos(info->sb.block_size); sb->s_type = &sfs; // file_system_type sb->s_op = &sfs_sops; // super block operations sfs_root_inode = iget_locked(sb, ROOT_INODE_NUM); // obtain an inode from VFS if (!sfs_root_inode) { shut_browsing(info); kfree(info); return -EACCES; } if (sfs_root_inode->i_state & I_NEW) // allocated fresh now { printk(KERN_INFO "sfs: Got new root inode, let's fill in\n"); sfs_root_inode->i_op = &sfs_iops; // inode operations sfs_root_inode->i_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO; sfs_root_inode->i_fop = &sfs_fops; // file operations sfs_root_inode->i_mapping->a_ops = &sfs_aops; // address operations unlock_new_inode(sfs_root_inode); } else { printk(KERN_INFO "sfs: Got root inode from inode cache\n"); } #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0)) sb->s_root = d_alloc_root(sfs_root_inode); #else sb->s_root = d_make_root(sfs_root_inode); #endif if (!sb->s_root) { iget_failed(sfs_root_inode); shut_browsing(info); kfree(info); return -ENOMEM; } return 0; }
static int __init my_init(void) { // Call target function struct inode* i = NULL; struct dentry* d = d_make_root(i); dput(d); return 0; }
/* This function, as the name implies, Makes the super_block valid and * fills filesystem specific information in the super block */ int simplefs_fill_super(struct super_block *sb, void *data, int silent) { struct inode *root_inode; struct buffer_head *bh; struct simplefs_super_block *sb_disk; bh = (struct buffer_head *)sb_bread(sb, SIMPLEFS_SUPERBLOCK_BLOCK_NUMBER); sb_disk = (struct simplefs_super_block *)bh->b_data; /* FIXME: bh->b_data is probably leaking */ printk(KERN_INFO "The magic number obtained in disk is: [%llu]\n", sb_disk->magic); if (unlikely(sb_disk->magic != SIMPLEFS_MAGIC)) { printk(KERN_ERR "The filesystem that you try to mount is not of type simplefs. Magicnumber mismatch."); return -EPERM; } if (unlikely(sb_disk->block_size != SIMPLEFS_DEFAULT_BLOCK_SIZE)) { printk(KERN_ERR "simplefs seem to be formatted using a non-standard block size."); return -EPERM; } printk(KERN_INFO "simplefs filesystem of version [%llu] formatted with a block size of [%llu] detected in the device.\n", sb_disk->version, sb_disk->block_size); /* A magic number that uniquely identifies our filesystem type */ sb->s_magic = SIMPLEFS_MAGIC; /* For all practical purposes, we will be using this s_fs_info as the super block */ sb->s_fs_info = sb_disk; root_inode = new_inode(sb); root_inode->i_ino = SIMPLEFS_ROOTDIR_INODE_NUMBER; inode_init_owner(root_inode, NULL, S_IFDIR); root_inode->i_sb = sb; root_inode->i_op = &simplefs_inode_ops; root_inode->i_fop = &simplefs_dir_operations; root_inode->i_atime = root_inode->i_mtime = root_inode->i_ctime = CURRENT_TIME; root_inode->i_private = simplefs_get_inode(sb, SIMPLEFS_ROOTDIR_INODE_NUMBER); sb->s_root = d_make_root(root_inode); if (!sb->s_root) return -ENOMEM; return 0; }
int axfs_fill_super(struct super_block *sb, void *data, int silent) { struct axfs_super *sbi; struct inode *root; int err; struct axfs_super *sbi_in = (struct axfs_super *)data; sbi = axfs_get_sbi(); if (IS_ERR(sbi)) return PTR_ERR(sbi); sb->s_fs_info = (void *)sbi; memcpy(sbi, sbi_in, sizeof(*sbi)); /* fully populate the incore superblock structures */ err = axfs_do_fill_super(sb); if (err) goto out; sb->s_flags |= MS_RDONLY; /* Setup the VFS super block now */ sb->s_op = &axfs_sops; root = axfs_create_vfs_inode(sb, 0); if (!root) { err = -EINVAL; goto out; } #if LINUX_VERSION_CODE > KERNEL_VERSION(3,3,0) sb->s_root = d_make_root(root); #else sb->s_root = d_alloc_root(root); #endif if (!sb->s_root) { #if LINUX_VERSION_CODE > KERNEL_VERSION(3,3,0) #else iput(root); #endif err = -EINVAL; goto out; } err = axfs_init_profiling(sbi); if (err) goto out; return 0; out: axfs_put_super(sb); return err; }
/* afs_root - stat the root of the file system. AFS global held on entry. */ static int afs_root(struct super_block *afsp) { afs_int32 code = 0; struct vcache *tvp = 0; AFS_STATCNT(afs_root); if (afs_globalVp && (afs_globalVp->f.states & CStatd)) { tvp = afs_globalVp; } else { struct vrequest *treq = NULL; cred_t *credp = crref(); if (afs_globalVp) { afs_PutVCache(afs_globalVp); afs_globalVp = NULL; } if (!(code = afs_CreateReq(&treq, credp)) && !(code = afs_CheckInit())) { tvp = afs_GetVCache(&afs_rootFid, treq, NULL, NULL); if (tvp) { struct inode *ip = AFSTOV(tvp); struct vattr *vattr = NULL; code = afs_CreateAttr(&vattr); if (!code) { afs_getattr(tvp, vattr, credp); afs_fill_inode(ip, vattr); /* setup super_block and mount point inode. */ afs_globalVp = tvp; #if defined(HAVE_LINUX_D_MAKE_ROOT) afsp->s_root = d_make_root(ip); #else afsp->s_root = d_alloc_root(ip); #endif #if !defined(STRUCT_SUPER_BLOCK_HAS_S_D_OP) afsp->s_root->d_op = &afs_dentry_operations; #endif afs_DestroyAttr(vattr); } } else code = EIO; } crfree(credp); afs_DestroyReq(treq); } afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, afs_globalVp, ICL_TYPE_INT32, code); return code; }
static int dedupfs_fill_superblock(struct super_block *sb, void *data, int silent) { struct inode *root_inode; struct buffer_head *bh; struct dedupfs_super_block *sb_disk; bh = (struct buffer_head *)sb_bread(sb, DEDUPFS_SUPERBLOCK_BLOCK_NUMBER); sb_disk = (struct dedupfs_super_block *)bh->b_data; brelse(bh); printk(KERN_INFO "The magic number obtained in disk is: [%d]\n", sb_disk->magic); if (sb_disk->magic != DEDUPFS_MAGIC_NUMBER) { printk(KERN_ERR "The filesystem that you try to mount is not of " "type dedupfs\n"); return -EPERM; } if (sb_disk->block_size != DEDUPFS_DEFAULT_BLOCK_SIZE) { printk(KERN_ERR "dedupfs was formatted using a non-standard block size\n" ); return -EPERM; } /* A magic number that uniquely identifies our filesystem type */ sb->s_magic = DEDUPFS_MAGIC_NUMBER; /* For all practical purposes, we will be using this s_fs_info as the super block */ sb->s_fs_info = sb_disk; root_inode = dedupfs_allocate_inode(sb, DEDUPFS_ROOT_INODE_NUMBER, NULL, S_IFDIR); root_inode->i_op = &dedupfs_inode_ops; root_inode->i_fop = &dedupfs_dir_operations; root_inode->i_private = dedupfs_get_inode(sb, DEDUPFS_ROOT_INODE_NUMBER); sb->s_root = d_make_root(root_inode); if (!sb->s_root) { printk(KERN_ERR "root creation failed\n"); return -ENOMEM; } return 0; }
static int samplefs_fill_super(struct super_block * sb, void * data, int silent) { struct inode * inode; struct samplefs_sb_info * sfs_sb; sb->s_maxbytes = MAX_LFS_FILESIZE; /* NB: may be too large for mem */ sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; sb->s_magic = SAMPLEFS_MAGIC; sb->s_op = &samplefs_super_ops; sb->s_time_gran = 1; /* 1 nanosecond time granularity */ printk(KERN_INFO "samplefs: fill super\n"); inode = samplefs_get_inode(sb, S_IFDIR | 0755, 0); /* inode = iget(sb, SAMPLEFS_ROOT_I); was oopsing here */ if (!inode) return -ENOMEM; #ifdef CONFIG_SAMPLEFS_DEBUG printk(KERN_INFO "samplefs: about to alloc s_fs_info\n"); #endif sb->s_fs_info = kzalloc(sizeof(struct samplefs_sb_info), GFP_KERNEL); sfs_sb = SFS_SB(sb); if (!sfs_sb) { iput(inode); return -ENOMEM; } printk(KERN_INFO "samplefs: about to alloc root inode\n"); sb->s_root = d_make_root(inode); if (!sb->s_root) { iput(inode); kfree(sfs_sb); return -ENOMEM; } /* below not needed for many fs - but an example of per fs sb data */ sfs_sb->local_nls = load_nls_default(); samplefs_parse_mount_options(data, sfs_sb); /* FS-FILLIN your filesystem specific mount logic/checks here */ return 0; }
static int devpts_fill_super(struct super_block *s, void *data, int silent) { struct inode *inode; int error; s->s_iflags &= ~SB_I_NODEV; s->s_blocksize = 1024; s->s_blocksize_bits = 10; s->s_magic = DEVPTS_SUPER_MAGIC; s->s_op = &devpts_sops; s->s_time_gran = 1; error = -ENOMEM; s->s_fs_info = new_pts_fs_info(s); if (!s->s_fs_info) goto fail; error = parse_mount_options(data, PARSE_MOUNT, &DEVPTS_SB(s)->mount_opts); if (error) goto fail; error = -ENOMEM; inode = new_inode(s); if (!inode) goto fail; inode->i_ino = 1; inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode); inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR; inode->i_op = &simple_dir_inode_operations; inode->i_fop = &simple_dir_operations; set_nlink(inode, 2); s->s_root = d_make_root(inode); if (!s->s_root) { pr_err("get root dentry failed\n"); goto fail; } error = mknod_ptmx(s); if (error) goto fail_dput; return 0; fail_dput: dput(s->s_root); s->s_root = NULL; fail: return error; }
static int dlmfs_fill_super(struct super_block * sb, void * data, int silent) { sb->s_maxbytes = MAX_LFS_FILESIZE; sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; sb->s_magic = DLMFS_MAGIC; sb->s_op = &dlmfs_ops; sb->s_root = d_make_root(dlmfs_get_root_inode(sb)); if (!sb->s_root) return -ENOMEM; return 0; }
static int complete_read_super(struct super_block *sb, int silent, int size) { struct sysv_sb_info *sbi = SYSV_SB(sb); struct inode *root_inode; char *found = flavour_names[sbi->s_type]; u_char n_bits = size+8; int bsize = 1 << n_bits; int bsize_4 = bsize >> 2; sbi->s_firstinodezone = 2; flavour_setup[sbi->s_type](sbi, &sb->s_max_links); sbi->s_truncate = 1; sbi->s_ndatazones = sbi->s_nzones - sbi->s_firstdatazone; sbi->s_inodes_per_block = bsize >> 6; sbi->s_inodes_per_block_1 = (bsize >> 6)-1; sbi->s_inodes_per_block_bits = n_bits-6; sbi->s_ind_per_block = bsize_4; sbi->s_ind_per_block_2 = bsize_4*bsize_4; sbi->s_toobig_block = 10 + bsize_4 * (1 + bsize_4 * (1 + bsize_4)); sbi->s_ind_per_block_bits = n_bits-2; sbi->s_ninodes = (sbi->s_firstdatazone - sbi->s_firstinodezone) << sbi->s_inodes_per_block_bits; if (!silent) printk("VFS: Found a %s FS (block size = %ld) on device %s\n", found, sb->s_blocksize, sb->s_id); sb->s_magic = SYSV_MAGIC_BASE + sbi->s_type; /* set up enough so that it can read an inode */ sb->s_op = &sysv_sops; if (sbi->s_forced_ro) sb->s_flags |= MS_RDONLY; if (sbi->s_truncate) sb->s_d_op = &sysv_dentry_operations; root_inode = sysv_iget(sb, SYSV_ROOT_INO); if (IS_ERR(root_inode)) { printk("SysV FS: get root inode failed\n"); return 0; } sb->s_root = d_make_root(root_inode); if (!sb->s_root) { printk("SysV FS: get root dentry failed\n"); return 0; } return 1; }
static int gfs_fill_super (struct super_block *sb, void *data, int silent) { struct gfs_super_info *si; struct inode *inode; int r = -ENOMEM; if(!sb_set_blocksize(sb, 512)) return -EFAULT; sb->s_magic = GFS_MAGIC+1; sb->s_op = &gfs_s_ops; si = kzalloc(sizeof(*si), GFP_KERNEL); if(!si) return -ENOMEM; sb->s_fs_info = si; si->s_vfs_sb = sb; r = gfs_fill_super_info(si, 0); if(r) goto out; r = gfs_sysfs_init_sb(si); if(r) goto out; inode = gfs_iget(sb, si->s_ino_root); if(!inode) goto out_sysfs; si->s_root_inode = GFS_INODE(inode); sb->s_root = d_make_root(inode); if (!sb->s_root) goto out_iput; return 0; out_iput: iput(inode); out_sysfs: gfs_sysfs_exit_sb(si); out: kfree(si); PVAR(r,"%d"); return r; }