本文整理汇总了C++中d_make_root函数的典型用法代码示例。如果您正苦于以下问题:C++ d_make_root函数的具体用法?C++ d_make_root怎么用?C++ d_make_root使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了d_make_root函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: oprofilefs_fill_super
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;
}
示例2: kernfs_fill_super
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;
}
示例3: orangefs_fill_sb
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;
}
示例4: sjfs_fill_super
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;
}
示例5: dumpfs_read_sb
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);
}
示例6: aufs_fill_sb
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;
}
示例7: aufs_fill_sb
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;
}
示例8: sjfs_fill_super
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;
}
示例9: ext4_read_super
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;
}
示例10: proxyfs_fs_fill_super
/** \<\<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;
}
示例11: ramfs_fill_super
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;
}
示例12: sysfs_fill_super
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;
}
示例13: configfs_fill_super
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;
}
示例14: gatorfs_fill_super
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;
}
示例15: efivarfs_fill_super
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;
}