~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nsfs.c

Version: ~ [ linux-5.6 ] ~ [ linux-5.5.13 ] ~ [ linux-5.4.28 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.113 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 #include <linux/mount.h>
  2 #include <linux/file.h>
  3 #include <linux/fs.h>
  4 #include <linux/proc_ns.h>
  5 #include <linux/magic.h>
  6 #include <linux/ktime.h>
  7 #include <linux/seq_file.h>
  8 #include <linux/user_namespace.h>
  9 #include <linux/nsfs.h>
 10 #include <linux/uaccess.h>
 11 
 12 static struct vfsmount *nsfs_mnt;
 13 
 14 static long ns_ioctl(struct file *filp, unsigned int ioctl,
 15                         unsigned long arg);
 16 static const struct file_operations ns_file_operations = {
 17         .llseek         = no_llseek,
 18         .unlocked_ioctl = ns_ioctl,
 19 };
 20 
 21 static char *ns_dname(struct dentry *dentry, char *buffer, int buflen)
 22 {
 23         struct inode *inode = d_inode(dentry);
 24         const struct proc_ns_operations *ns_ops = dentry->d_fsdata;
 25 
 26         return dynamic_dname(dentry, buffer, buflen, "%s:[%lu]",
 27                 ns_ops->name, inode->i_ino);
 28 }
 29 
 30 static void ns_prune_dentry(struct dentry *dentry)
 31 {
 32         struct inode *inode = d_inode(dentry);
 33         if (inode) {
 34                 struct ns_common *ns = inode->i_private;
 35                 atomic_long_set(&ns->stashed, 0);
 36         }
 37 }
 38 
 39 const struct dentry_operations ns_dentry_operations =
 40 {
 41         .d_prune        = ns_prune_dentry,
 42         .d_delete       = always_delete_dentry,
 43         .d_dname        = ns_dname,
 44 };
 45 
 46 static void nsfs_evict(struct inode *inode)
 47 {
 48         struct ns_common *ns = inode->i_private;
 49         clear_inode(inode);
 50         ns->ops->put(ns);
 51 }
 52 
 53 static void *__ns_get_path(struct path *path, struct ns_common *ns)
 54 {
 55         struct vfsmount *mnt = nsfs_mnt;
 56         struct qstr qname = { .name = "", };
 57         struct dentry *dentry;
 58         struct inode *inode;
 59         unsigned long d;
 60 
 61         rcu_read_lock();
 62         d = atomic_long_read(&ns->stashed);
 63         if (!d)
 64                 goto slow;
 65         dentry = (struct dentry *)d;
 66         if (!lockref_get_not_dead(&dentry->d_lockref))
 67                 goto slow;
 68         rcu_read_unlock();
 69         ns->ops->put(ns);
 70 got_it:
 71         path->mnt = mntget(mnt);
 72         path->dentry = dentry;
 73         return NULL;
 74 slow:
 75         rcu_read_unlock();
 76         inode = new_inode_pseudo(mnt->mnt_sb);
 77         if (!inode) {
 78                 ns->ops->put(ns);
 79                 return ERR_PTR(-ENOMEM);
 80         }
 81         inode->i_ino = ns->inum;
 82         inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
 83         inode->i_flags |= S_IMMUTABLE;
 84         inode->i_mode = S_IFREG | S_IRUGO;
 85         inode->i_fop = &ns_file_operations;
 86         inode->i_private = ns;
 87 
 88         dentry = d_alloc_pseudo(mnt->mnt_sb, &qname);
 89         if (!dentry) {
 90                 iput(inode);
 91                 return ERR_PTR(-ENOMEM);
 92         }
 93         d_instantiate(dentry, inode);
 94         dentry->d_flags |= DCACHE_RCUACCESS;
 95         dentry->d_fsdata = (void *)ns->ops;
 96         d = atomic_long_cmpxchg(&ns->stashed, 0, (unsigned long)dentry);
 97         if (d) {
 98                 d_delete(dentry);       /* make sure ->d_prune() does nothing */
 99                 dput(dentry);
100                 cpu_relax();
101                 return ERR_PTR(-EAGAIN);
102         }
103         goto got_it;
104 }
105 
106 void *ns_get_path(struct path *path, struct task_struct *task,
107                         const struct proc_ns_operations *ns_ops)
108 {
109         struct ns_common *ns;
110         void *ret;
111 
112 again:
113         ns = ns_ops->get(task);
114         if (!ns)
115                 return ERR_PTR(-ENOENT);
116 
117         ret = __ns_get_path(path, ns);
118         if (IS_ERR(ret) && PTR_ERR(ret) == -EAGAIN)
119                 goto again;
120         return ret;
121 }
122 
123 int open_related_ns(struct ns_common *ns,
124                    struct ns_common *(*get_ns)(struct ns_common *ns))
125 {
126         struct path path = {};
127         struct file *f;
128         void *err;
129         int fd;
130 
131         fd = get_unused_fd_flags(O_CLOEXEC);
132         if (fd < 0)
133                 return fd;
134 
135         while (1) {
136                 struct ns_common *relative;
137 
138                 relative = get_ns(ns);
139                 if (IS_ERR(relative)) {
140                         put_unused_fd(fd);
141                         return PTR_ERR(relative);
142                 }
143 
144                 err = __ns_get_path(&path, relative);
145                 if (IS_ERR(err) && PTR_ERR(err) == -EAGAIN)
146                         continue;
147                 break;
148         }
149         if (IS_ERR(err)) {
150                 put_unused_fd(fd);
151                 return PTR_ERR(err);
152         }
153 
154         f = dentry_open(&path, O_RDONLY, current_cred());
155         path_put(&path);
156         if (IS_ERR(f)) {
157                 put_unused_fd(fd);
158                 fd = PTR_ERR(f);
159         } else
160                 fd_install(fd, f);
161 
162         return fd;
163 }
164 
165 static long ns_ioctl(struct file *filp, unsigned int ioctl,
166                         unsigned long arg)
167 {
168         struct user_namespace *user_ns;
169         struct ns_common *ns = get_proc_ns(file_inode(filp));
170         uid_t __user *argp;
171         uid_t uid;
172 
173         switch (ioctl) {
174         case NS_GET_USERNS:
175                 return open_related_ns(ns, ns_get_owner);
176         case NS_GET_PARENT:
177                 if (!ns->ops->get_parent)
178                         return -EINVAL;
179                 return open_related_ns(ns, ns->ops->get_parent);
180         case NS_GET_NSTYPE:
181                 return ns->ops->type;
182         case NS_GET_OWNER_UID:
183                 if (ns->ops->type != CLONE_NEWUSER)
184                         return -EINVAL;
185                 user_ns = container_of(ns, struct user_namespace, ns);
186                 argp = (uid_t __user *) arg;
187                 uid = from_kuid_munged(current_user_ns(), user_ns->owner);
188                 return put_user(uid, argp);
189         default:
190                 return -ENOTTY;
191         }
192 }
193 
194 int ns_get_name(char *buf, size_t size, struct task_struct *task,
195                         const struct proc_ns_operations *ns_ops)
196 {
197         struct ns_common *ns;
198         int res = -ENOENT;
199         ns = ns_ops->get(task);
200         if (ns) {
201                 res = snprintf(buf, size, "%s:[%u]", ns_ops->name, ns->inum);
202                 ns_ops->put(ns);
203         }
204         return res;
205 }
206 
207 struct file *proc_ns_fget(int fd)
208 {
209         struct file *file;
210 
211         file = fget(fd);
212         if (!file)
213                 return ERR_PTR(-EBADF);
214 
215         if (file->f_op != &ns_file_operations)
216                 goto out_invalid;
217 
218         return file;
219 
220 out_invalid:
221         fput(file);
222         return ERR_PTR(-EINVAL);
223 }
224 
225 static int nsfs_show_path(struct seq_file *seq, struct dentry *dentry)
226 {
227         struct inode *inode = d_inode(dentry);
228         const struct proc_ns_operations *ns_ops = dentry->d_fsdata;
229 
230         seq_printf(seq, "%s:[%lu]", ns_ops->name, inode->i_ino);
231         return 0;
232 }
233 
234 static const struct super_operations nsfs_ops = {
235         .statfs = simple_statfs,
236         .evict_inode = nsfs_evict,
237         .show_path = nsfs_show_path,
238 };
239 static struct dentry *nsfs_mount(struct file_system_type *fs_type,
240                         int flags, const char *dev_name, void *data)
241 {
242         return mount_pseudo(fs_type, "nsfs:", &nsfs_ops,
243                         &ns_dentry_operations, NSFS_MAGIC);
244 }
245 static struct file_system_type nsfs = {
246         .name = "nsfs",
247         .mount = nsfs_mount,
248         .kill_sb = kill_anon_super,
249 };
250 
251 void __init nsfs_init(void)
252 {
253         nsfs_mnt = kern_mount(&nsfs);
254         if (IS_ERR(nsfs_mnt))
255                 panic("can't set nsfs up\n");
256         nsfs_mnt->mnt_sb->s_flags &= ~MS_NOUSER;
257 }
258 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp