kernel/bpf/inode.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Minimal file system backend for holding eBPF maps and programs,
0004  * used by bpf(2) object pinning.
0005  *
0006  * Authors:
0007  *
0008  *  Daniel Borkmann <daniel@iogearbox.net>
0009  */
0010
0011 #include <linux/init.h>
0012 #include <linux/magic.h>
0013 #include <linux/major.h>
0014 #include <linux/mount.h>
0015 #include <linux/namei.h>
0016 #include <linux/fs.h>
0017 #include <linux/fs_context.h>
0018 #include <linux/fs_parser.h>
0019 #include <linux/kdev_t.h>
0020 #include <linux/filter.h>
0021 #include <linux/bpf.h>
0022 #include <linux/bpf_trace.h>
0023 #include "preload/bpf_preload.h"
0024
0025 enum bpf_type {
0026     BPF_TYPE_UNSPEC = 0,
0027     BPF_TYPE_PROG,
0028     BPF_TYPE_MAP,
0029     BPF_TYPE_LINK,
0030 };
0031
0032 static void *bpf_any_get(void *raw, enum bpf_type type)
0033 {
0034     switch (type) {
0035     case BPF_TYPE_PROG:
0036         bpf_prog_inc(raw);
0037         break;
0038     case BPF_TYPE_MAP:
0039         bpf_map_inc_with_uref(raw);
0040         break;
0041     case BPF_TYPE_LINK:
0042         bpf_link_inc(raw);
0043         break;
0044     default:
0045         WARN_ON_ONCE(1);
0046         break;
0047     }
0048
0049     return raw;
0050 }
0051
0052 static void bpf_any_put(void *raw, enum bpf_type type)
0053 {
0054     switch (type) {
0055     case BPF_TYPE_PROG:
0056         bpf_prog_put(raw);
0057         break;
0058     case BPF_TYPE_MAP:
0059         bpf_map_put_with_uref(raw);
0060         break;
0061     case BPF_TYPE_LINK:
0062         bpf_link_put(raw);
0063         break;
0064     default:
0065         WARN_ON_ONCE(1);
0066         break;
0067     }
0068 }
0069
0070 static void *bpf_fd_probe_obj(u32 ufd, enum bpf_type *type)
0071 {
0072     void *raw;
0073
0074     raw = bpf_map_get_with_uref(ufd);
0075     if (!IS_ERR(raw)) {
0076         *type = BPF_TYPE_MAP;
0077         return raw;
0078     }
0079
0080     raw = bpf_prog_get(ufd);
0081     if (!IS_ERR(raw)) {
0082         *type = BPF_TYPE_PROG;
0083         return raw;
0084     }
0085
0086     raw = bpf_link_get_from_fd(ufd);
0087     if (!IS_ERR(raw)) {
0088         *type = BPF_TYPE_LINK;
0089         return raw;
0090     }
0091
0092     return ERR_PTR(-EINVAL);
0093 }
0094
0095 static const struct inode_operations bpf_dir_iops;
0096
0097 static const struct inode_operations bpf_prog_iops = { };
0098 static const struct inode_operations bpf_map_iops  = { };
0099 static const struct inode_operations bpf_link_iops  = { };
0100
0101 static struct inode *bpf_get_inode(struct super_block *sb,
0102                    const struct inode *dir,
0103                    umode_t mode)
0104 {
0105     struct inode *inode;
0106
0107     switch (mode & S_IFMT) {
0108     case S_IFDIR:
0109     case S_IFREG:
0110     case S_IFLNK:
0111         break;
0112     default:
0113         return ERR_PTR(-EINVAL);
0114     }
0115
0116     inode = new_inode(sb);
0117     if (!inode)
0118         return ERR_PTR(-ENOSPC);
0119
0120     inode->i_ino = get_next_ino();
0121     inode->i_atime = current_time(inode);
0122     inode->i_mtime = inode->i_atime;
0123     inode->i_ctime = inode->i_atime;
0124
0125     inode_init_owner(&init_user_ns, inode, dir, mode);
0126
0127     return inode;
0128 }
0129
0130 static int bpf_inode_type(const struct inode *inode, enum bpf_type *type)
0131 {
0132     *type = BPF_TYPE_UNSPEC;
0133     if (inode->i_op == &bpf_prog_iops)
0134         *type = BPF_TYPE_PROG;
0135     else if (inode->i_op == &bpf_map_iops)
0136         *type = BPF_TYPE_MAP;
0137     else if (inode->i_op == &bpf_link_iops)
0138         *type = BPF_TYPE_LINK;
0139     else
0140         return -EACCES;
0141
0142     return 0;
0143 }
0144
0145 static void bpf_dentry_finalize(struct dentry *dentry, struct inode *inode,
0146                 struct inode *dir)
0147 {
0148     d_instantiate(dentry, inode);
0149     dget(dentry);
0150
0151     dir->i_mtime = current_time(dir);
0152     dir->i_ctime = dir->i_mtime;
0153 }
0154
0155 static int bpf_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
0156              struct dentry *dentry, umode_t mode)
0157 {
0158     struct inode *inode;
0159
0160     inode = bpf_get_inode(dir->i_sb, dir, mode | S_IFDIR);
0161     if (IS_ERR(inode))
0162         return PTR_ERR(inode);
0163
0164     inode->i_op = &bpf_dir_iops;
0165     inode->i_fop = &simple_dir_operations;
0166
0167     inc_nlink(inode);
0168     inc_nlink(dir);
0169
0170     bpf_dentry_finalize(dentry, inode, dir);
0171     return 0;
0172 }
0173
0174 struct map_iter {
0175     void *key;
0176     bool done;
0177 };
0178
0179 static struct map_iter *map_iter(struct seq_file *m)
0180 {
0181     return m->private;
0182 }
0183
0184 static struct bpf_map *seq_file_to_map(struct seq_file *m)
0185 {
0186     return file_inode(m->file)->i_private;
0187 }
0188
0189 static void map_iter_free(struct map_iter *iter)
0190 {
0191     if (iter) {
0192         kfree(iter->key);
0193         kfree(iter);
0194     }
0195 }
0196
0197 static struct map_iter *map_iter_alloc(struct bpf_map *map)
0198 {
0199     struct map_iter *iter;
0200
0201     iter = kzalloc(sizeof(*iter), GFP_KERNEL | __GFP_NOWARN);
0202     if (!iter)
0203         goto error;
0204
0205     iter->key = kzalloc(map->key_size, GFP_KERNEL | __GFP_NOWARN);
0206     if (!iter->key)
0207         goto error;
0208
0209     return iter;
0210
0211 error:
0212     map_iter_free(iter);
0213     return NULL;
0214 }
0215
0216 static void *map_seq_next(struct seq_file *m, void *v, loff_t *pos)
0217 {
0218     struct bpf_map *map = seq_file_to_map(m);
0219     void *key = map_iter(m)->key;
0220     void *prev_key;
0221
0222     (*pos)++;
0223     if (map_iter(m)->done)
0224         return NULL;
0225
0226     if (unlikely(v == SEQ_START_TOKEN))
0227         prev_key = NULL;
0228     else
0229         prev_key = key;
0230
0231     rcu_read_lock();
0232     if (map->ops->map_get_next_key(map, prev_key, key)) {
0233         map_iter(m)->done = true;
0234         key = NULL;
0235     }
0236     rcu_read_unlock();
0237     return key;
0238 }
0239
0240 static void *map_seq_start(struct seq_file *m, loff_t *pos)
0241 {
0242     if (map_iter(m)->done)
0243         return NULL;
0244
0245     return *pos ? map_iter(m)->key : SEQ_START_TOKEN;
0246 }
0247
0248 static void map_seq_stop(struct seq_file *m, void *v)
0249 {
0250 }
0251
0252 static int map_seq_show(struct seq_file *m, void *v)
0253 {
0254     struct bpf_map *map = seq_file_to_map(m);
0255     void *key = map_iter(m)->key;
0256
0257     if (unlikely(v == SEQ_START_TOKEN)) {
0258         seq_puts(m, "# WARNING!! The output is for debug purpose only\n");
0259         seq_puts(m, "# WARNING!! The output format will change\n");
0260     } else {
0261         map->ops->map_seq_show_elem(map, key, m);
0262     }
0263
0264     return 0;
0265 }
0266
0267 static const struct seq_operations bpffs_map_seq_ops = {
0268     .start  = map_seq_start,
0269     .next   = map_seq_next,
0270     .show   = map_seq_show,
0271     .stop   = map_seq_stop,
0272 };
0273
0274 static int bpffs_map_open(struct inode *inode, struct file *file)
0275 {
0276     struct bpf_map *map = inode->i_private;
0277     struct map_iter *iter;
0278     struct seq_file *m;
0279     int err;
0280
0281     iter = map_iter_alloc(map);
0282     if (!iter)
0283         return -ENOMEM;
0284
0285     err = seq_open(file, &bpffs_map_seq_ops);
0286     if (err) {
0287         map_iter_free(iter);
0288         return err;
0289     }
0290
0291     m = file->private_data;
0292     m->private = iter;
0293
0294     return 0;
0295 }
0296
0297 static int bpffs_map_release(struct inode *inode, struct file *file)
0298 {
0299     struct seq_file *m = file->private_data;
0300
0301     map_iter_free(map_iter(m));
0302
0303     return seq_release(inode, file);
0304 }
0305
0306 /* bpffs_map_fops should only implement the basic
0307  * read operation for a BPF map.  The purpose is to
0308  * provide a simple user intuitive way to do
0309  * "cat bpffs/pathto/a-pinned-map".
0310  *
0311  * Other operations (e.g. write, lookup...) should be realized by
0312  * the userspace tools (e.g. bpftool) through the
0313  * BPF_OBJ_GET_INFO_BY_FD and the map's lookup/update
0314  * interface.
0315  */
0316 static const struct file_operations bpffs_map_fops = {
0317     .open       = bpffs_map_open,
0318     .read       = seq_read,
0319     .release    = bpffs_map_release,
0320 };
0321
0322 static int bpffs_obj_open(struct inode *inode, struct file *file)
0323 {
0324     return -EIO;
0325 }
0326
0327 static const struct file_operations bpffs_obj_fops = {
0328     .open       = bpffs_obj_open,
0329 };
0330
0331 static int bpf_mkobj_ops(struct dentry *dentry, umode_t mode, void *raw,
0332              const struct inode_operations *iops,
0333              const struct file_operations *fops)
0334 {
0335     struct inode *dir = dentry->d_parent->d_inode;
0336     struct inode *inode = bpf_get_inode(dir->i_sb, dir, mode);
0337     if (IS_ERR(inode))
0338         return PTR_ERR(inode);
0339
0340     inode->i_op = iops;
0341     inode->i_fop = fops;
0342     inode->i_private = raw;
0343
0344     bpf_dentry_finalize(dentry, inode, dir);
0345     return 0;
0346 }
0347
0348 static int bpf_mkprog(struct dentry *dentry, umode_t mode, void *arg)
0349 {
0350     return bpf_mkobj_ops(dentry, mode, arg, &bpf_prog_iops,
0351                  &bpffs_obj_fops);
0352 }
0353
0354 static int bpf_mkmap(struct dentry *dentry, umode_t mode, void *arg)
0355 {
0356     struct bpf_map *map = arg;
0357
0358     return bpf_mkobj_ops(dentry, mode, arg, &bpf_map_iops,
0359                  bpf_map_support_seq_show(map) ?
0360                  &bpffs_map_fops : &bpffs_obj_fops);
0361 }
0362
0363 static int bpf_mklink(struct dentry *dentry, umode_t mode, void *arg)
0364 {
0365     struct bpf_link *link = arg;
0366
0367     return bpf_mkobj_ops(dentry, mode, arg, &bpf_link_iops,
0368                  bpf_link_is_iter(link) ?
0369                  &bpf_iter_fops : &bpffs_obj_fops);
0370 }
0371
0372 static struct dentry *
0373 bpf_lookup(struct inode *dir, struct dentry *dentry, unsigned flags)
0374 {
0375     /* Dots in names (e.g. "/sys/fs/bpf/foo.bar") are reserved for future
0376      * extensions. That allows popoulate_bpffs() create special files.
0377      */
0378     if ((dir->i_mode & S_IALLUGO) &&
0379         strchr(dentry->d_name.name, '.'))
0380         return ERR_PTR(-EPERM);
0381
0382     return simple_lookup(dir, dentry, flags);
0383 }
0384
0385 static int bpf_symlink(struct user_namespace *mnt_userns, struct inode *dir,
0386                struct dentry *dentry, const char *target)
0387 {
0388     char *link = kstrdup(target, GFP_USER | __GFP_NOWARN);
0389     struct inode *inode;
0390
0391     if (!link)
0392         return -ENOMEM;
0393
0394     inode = bpf_get_inode(dir->i_sb, dir, S_IRWXUGO | S_IFLNK);
0395     if (IS_ERR(inode)) {
0396         kfree(link);
0397         return PTR_ERR(inode);
0398     }
0399
0400     inode->i_op = &simple_symlink_inode_operations;
0401     inode->i_link = link;
0402
0403     bpf_dentry_finalize(dentry, inode, dir);
0404     return 0;
0405 }
0406
0407 static const struct inode_operations bpf_dir_iops = {
0408     .lookup     = bpf_lookup,
0409     .mkdir      = bpf_mkdir,
0410     .symlink    = bpf_symlink,
0411     .rmdir      = simple_rmdir,
0412     .rename     = simple_rename,
0413     .link       = simple_link,
0414     .unlink     = simple_unlink,
0415 };
0416
0417 /* pin iterator link into bpffs */
0418 static int bpf_iter_link_pin_kernel(struct dentry *parent,
0419                     const char *name, struct bpf_link *link)
0420 {
0421     umode_t mode = S_IFREG | S_IRUSR;
0422     struct dentry *dentry;
0423     int ret;
0424
0425     inode_lock(parent->d_inode);
0426     dentry = lookup_one_len(name, parent, strlen(name));
0427     if (IS_ERR(dentry)) {
0428         inode_unlock(parent->d_inode);
0429         return PTR_ERR(dentry);
0430     }
0431     ret = bpf_mkobj_ops(dentry, mode, link, &bpf_link_iops,
0432                 &bpf_iter_fops);
0433     dput(dentry);
0434     inode_unlock(parent->d_inode);
0435     return ret;
0436 }
0437
0438 static int bpf_obj_do_pin(const char __user *pathname, void *raw,
0439               enum bpf_type type)
0440 {
0441     struct dentry *dentry;
0442     struct inode *dir;
0443     struct path path;
0444     umode_t mode;
0445     int ret;
0446
0447     dentry = user_path_create(AT_FDCWD, pathname, &path, 0);
0448     if (IS_ERR(dentry))
0449         return PTR_ERR(dentry);
0450
0451     mode = S_IFREG | ((S_IRUSR | S_IWUSR) & ~current_umask());
0452
0453     ret = security_path_mknod(&path, dentry, mode, 0);
0454     if (ret)
0455         goto out;
0456
0457     dir = d_inode(path.dentry);
0458     if (dir->i_op != &bpf_dir_iops) {
0459         ret = -EPERM;
0460         goto out;
0461     }
0462
0463     switch (type) {
0464     case BPF_TYPE_PROG:
0465         ret = vfs_mkobj(dentry, mode, bpf_mkprog, raw);
0466         break;
0467     case BPF_TYPE_MAP:
0468         ret = vfs_mkobj(dentry, mode, bpf_mkmap, raw);
0469         break;
0470     case BPF_TYPE_LINK:
0471         ret = vfs_mkobj(dentry, mode, bpf_mklink, raw);
0472         break;
0473     default:
0474         ret = -EPERM;
0475     }
0476 out:
0477     done_path_create(&path, dentry);
0478     return ret;
0479 }
0480
0481 int bpf_obj_pin_user(u32 ufd, const char __user *pathname)
0482 {
0483     enum bpf_type type;
0484     void *raw;
0485     int ret;
0486
0487     raw = bpf_fd_probe_obj(ufd, &type);
0488     if (IS_ERR(raw))
0489         return PTR_ERR(raw);
0490
0491     ret = bpf_obj_do_pin(pathname, raw, type);
0492     if (ret != 0)
0493         bpf_any_put(raw, type);
0494
0495     return ret;
0496 }
0497
0498 static void *bpf_obj_do_get(const char __user *pathname,
0499                 enum bpf_type *type, int flags)
0500 {
0501     struct inode *inode;
0502     struct path path;
0503     void *raw;
0504     int ret;
0505
0506     ret = user_path_at(AT_FDCWD, pathname, LOOKUP_FOLLOW, &path);
0507     if (ret)
0508         return ERR_PTR(ret);
0509
0510     inode = d_backing_inode(path.dentry);
0511     ret = path_permission(&path, ACC_MODE(flags));
0512     if (ret)
0513         goto out;
0514
0515     ret = bpf_inode_type(inode, type);
0516     if (ret)
0517         goto out;
0518
0519     raw = bpf_any_get(inode->i_private, *type);
0520     if (!IS_ERR(raw))
0521         touch_atime(&path);
0522
0523     path_put(&path);
0524     return raw;
0525 out:
0526     path_put(&path);
0527     return ERR_PTR(ret);
0528 }
0529
0530 int bpf_obj_get_user(const char __user *pathname, int flags)
0531 {
0532     enum bpf_type type = BPF_TYPE_UNSPEC;
0533     int f_flags;
0534     void *raw;
0535     int ret;
0536
0537     f_flags = bpf_get_file_flag(flags);
0538     if (f_flags < 0)
0539         return f_flags;
0540
0541     raw = bpf_obj_do_get(pathname, &type, f_flags);
0542     if (IS_ERR(raw))
0543         return PTR_ERR(raw);
0544
0545     if (type == BPF_TYPE_PROG)
0546         ret = bpf_prog_new_fd(raw);
0547     else if (type == BPF_TYPE_MAP)
0548         ret = bpf_map_new_fd(raw, f_flags);
0549     else if (type == BPF_TYPE_LINK)
0550         ret = (f_flags != O_RDWR) ? -EINVAL : bpf_link_new_fd(raw);
0551     else
0552         return -ENOENT;
0553
0554     if (ret < 0)
0555         bpf_any_put(raw, type);
0556     return ret;
0557 }
0558
0559 static struct bpf_prog *__get_prog_inode(struct inode *inode, enum bpf_prog_type type)
0560 {
0561     struct bpf_prog *prog;
0562     int ret = inode_permission(&init_user_ns, inode, MAY_READ);
0563     if (ret)
0564         return ERR_PTR(ret);
0565
0566     if (inode->i_op == &bpf_map_iops)
0567         return ERR_PTR(-EINVAL);
0568     if (inode->i_op == &bpf_link_iops)
0569         return ERR_PTR(-EINVAL);
0570     if (inode->i_op != &bpf_prog_iops)
0571         return ERR_PTR(-EACCES);
0572
0573     prog = inode->i_private;
0574
0575     ret = security_bpf_prog(prog);
0576     if (ret < 0)
0577         return ERR_PTR(ret);
0578
0579     if (!bpf_prog_get_ok(prog, &type, false))
0580         return ERR_PTR(-EINVAL);
0581
0582     bpf_prog_inc(prog);
0583     return prog;
0584 }
0585
0586 struct bpf_prog *bpf_prog_get_type_path(const char *name, enum bpf_prog_type type)
0587 {
0588     struct bpf_prog *prog;
0589     struct path path;
0590     int ret = kern_path(name, LOOKUP_FOLLOW, &path);
0591     if (ret)
0592         return ERR_PTR(ret);
0593     prog = __get_prog_inode(d_backing_inode(path.dentry), type);
0594     if (!IS_ERR(prog))
0595         touch_atime(&path);
0596     path_put(&path);
0597     return prog;
0598 }
0599 EXPORT_SYMBOL(bpf_prog_get_type_path);
0600
0601 /*
0602  * Display the mount options in /proc/mounts.
0603  */
0604 static int bpf_show_options(struct seq_file *m, struct dentry *root)
0605 {
0606     umode_t mode = d_inode(root)->i_mode & S_IALLUGO & ~S_ISVTX;
0607
0608     if (mode != S_IRWXUGO)
0609         seq_printf(m, ",mode=%o", mode);
0610     return 0;
0611 }
0612
0613 static void bpf_free_inode(struct inode *inode)
0614 {
0615     enum bpf_type type;
0616
0617     if (S_ISLNK(inode->i_mode))
0618         kfree(inode->i_link);
0619     if (!bpf_inode_type(inode, &type))
0620         bpf_any_put(inode->i_private, type);
0621     free_inode_nonrcu(inode);
0622 }
0623
0624 static const struct super_operations bpf_super_ops = {
0625     .statfs     = simple_statfs,
0626     .drop_inode = generic_delete_inode,
0627     .show_options   = bpf_show_options,
0628     .free_inode = bpf_free_inode,
0629 };
0630
0631 enum {
0632     OPT_MODE,
0633 };
0634
0635 static const struct fs_parameter_spec bpf_fs_parameters[] = {
0636     fsparam_u32oct  ("mode",            OPT_MODE),
0637     {}
0638 };
0639
0640 struct bpf_mount_opts {
0641     umode_t mode;
0642 };
0643
0644 static int bpf_parse_param(struct fs_context *fc, struct fs_parameter *param)
0645 {
0646     struct bpf_mount_opts *opts = fc->fs_private;
0647     struct fs_parse_result result;
0648     int opt;
0649
0650     opt = fs_parse(fc, bpf_fs_parameters, param, &result);
0651     if (opt < 0) {
0652         /* We might like to report bad mount options here, but
0653          * traditionally we've ignored all mount options, so we'd
0654          * better continue to ignore non-existing options for bpf.
0655          */
0656         if (opt == -ENOPARAM) {
0657             opt = vfs_parse_fs_param_source(fc, param);
0658             if (opt != -ENOPARAM)
0659                 return opt;
0660
0661             return 0;
0662         }
0663
0664         if (opt < 0)
0665             return opt;
0666     }
0667
0668     switch (opt) {
0669     case OPT_MODE:
0670         opts->mode = result.uint_32 & S_IALLUGO;
0671         break;
0672     }
0673
0674     return 0;
0675 }
0676
0677 struct bpf_preload_ops *bpf_preload_ops;
0678 EXPORT_SYMBOL_GPL(bpf_preload_ops);
0679
0680 static bool bpf_preload_mod_get(void)
0681 {
0682     /* If bpf_preload.ko wasn't loaded earlier then load it now.
0683      * When bpf_preload is built into vmlinux the module's __init
0684      * function will populate it.
0685      */
0686     if (!bpf_preload_ops) {
0687         request_module("bpf_preload");
0688         if (!bpf_preload_ops)
0689             return false;
0690     }
0691     /* And grab the reference, so the module doesn't disappear while the
0692      * kernel is interacting with the kernel module and its UMD.
0693      */
0694     if (!try_module_get(bpf_preload_ops->owner)) {
0695         pr_err("bpf_preload module get failed.\n");
0696         return false;
0697     }
0698     return true;
0699 }
0700
0701 static void bpf_preload_mod_put(void)
0702 {
0703     if (bpf_preload_ops)
0704         /* now user can "rmmod bpf_preload" if necessary */
0705         module_put(bpf_preload_ops->owner);
0706 }
0707
0708 static DEFINE_MUTEX(bpf_preload_lock);
0709
0710 static int populate_bpffs(struct dentry *parent)
0711 {
0712     struct bpf_preload_info objs[BPF_PRELOAD_LINKS] = {};
0713     int err = 0, i;
0714
0715     /* grab the mutex to make sure the kernel interactions with bpf_preload
0716      * are serialized
0717      */
0718     mutex_lock(&bpf_preload_lock);
0719
0720     /* if bpf_preload.ko wasn't built into vmlinux then load it */
0721     if (!bpf_preload_mod_get())
0722         goto out;
0723
0724     err = bpf_preload_ops->preload(objs);
0725     if (err)
0726         goto out_put;
0727     for (i = 0; i < BPF_PRELOAD_LINKS; i++) {
0728         bpf_link_inc(objs[i].link);
0729         err = bpf_iter_link_pin_kernel(parent,
0730                            objs[i].link_name, objs[i].link);
0731         if (err) {
0732             bpf_link_put(objs[i].link);
0733             goto out_put;
0734         }
0735     }
0736 out_put:
0737     bpf_preload_mod_put();
0738 out:
0739     mutex_unlock(&bpf_preload_lock);
0740     return err;
0741 }
0742
0743 static int bpf_fill_super(struct super_block *sb, struct fs_context *fc)
0744 {
0745     static const struct tree_descr bpf_rfiles[] = { { "" } };
0746     struct bpf_mount_opts *opts = fc->fs_private;
0747     struct inode *inode;
0748     int ret;
0749
0750     ret = simple_fill_super(sb, BPF_FS_MAGIC, bpf_rfiles);
0751     if (ret)
0752         return ret;
0753
0754     sb->s_op = &bpf_super_ops;
0755
0756     inode = sb->s_root->d_inode;
0757     inode->i_op = &bpf_dir_iops;
0758     inode->i_mode &= ~S_IALLUGO;
0759     populate_bpffs(sb->s_root);
0760     inode->i_mode |= S_ISVTX | opts->mode;
0761     return 0;
0762 }
0763
0764 static int bpf_get_tree(struct fs_context *fc)
0765 {
0766     return get_tree_nodev(fc, bpf_fill_super);
0767 }
0768
0769 static void bpf_free_fc(struct fs_context *fc)
0770 {
0771     kfree(fc->fs_private);
0772 }
0773
0774 static const struct fs_context_operations bpf_context_ops = {
0775     .free       = bpf_free_fc,
0776     .parse_param    = bpf_parse_param,
0777     .get_tree   = bpf_get_tree,
0778 };
0779
0780 /*
0781  * Set up the filesystem mount context.
0782  */
0783 static int bpf_init_fs_context(struct fs_context *fc)
0784 {
0785     struct bpf_mount_opts *opts;
0786
0787     opts = kzalloc(sizeof(struct bpf_mount_opts), GFP_KERNEL);
0788     if (!opts)
0789         return -ENOMEM;
0790
0791     opts->mode = S_IRWXUGO;
0792
0793     fc->fs_private = opts;
0794     fc->ops = &bpf_context_ops;
0795     return 0;
0796 }
0797
0798 static struct file_system_type bpf_fs_type = {
0799     .owner      = THIS_MODULE,
0800     .name       = "bpf",
0801     .init_fs_context = bpf_init_fs_context,
0802     .parameters = bpf_fs_parameters,
0803     .kill_sb    = kill_litter_super,
0804 };
0805
0806 static int __init bpf_init(void)
0807 {
0808     int ret;
0809
0810     ret = sysfs_create_mount_point(fs_kobj, "bpf");
0811     if (ret)
0812         return ret;
0813
0814     ret = register_filesystem(&bpf_fs_type);
0815     if (ret)
0816         sysfs_remove_mount_point(fs_kobj, "bpf");
0817
0818     return ret;
0819 }
0820 fs_initcall(bpf_init);