Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * net/sunrpc/rpc_pipe.c
4 : : *
5 : : * Userland/kernel interface for rpcauth_gss.
6 : : * Code shamelessly plagiarized from fs/nfsd/nfsctl.c
7 : : * and fs/sysfs/inode.c
8 : : *
9 : : * Copyright (c) 2002, Trond Myklebust <trond.myklebust@fys.uio.no>
10 : : *
11 : : */
12 : : #include <linux/module.h>
13 : : #include <linux/slab.h>
14 : : #include <linux/string.h>
15 : : #include <linux/pagemap.h>
16 : : #include <linux/mount.h>
17 : : #include <linux/fs_context.h>
18 : : #include <linux/namei.h>
19 : : #include <linux/fsnotify.h>
20 : : #include <linux/kernel.h>
21 : : #include <linux/rcupdate.h>
22 : : #include <linux/utsname.h>
23 : :
24 : : #include <asm/ioctls.h>
25 : : #include <linux/poll.h>
26 : : #include <linux/wait.h>
27 : : #include <linux/seq_file.h>
28 : :
29 : : #include <linux/sunrpc/clnt.h>
30 : : #include <linux/workqueue.h>
31 : : #include <linux/sunrpc/rpc_pipe_fs.h>
32 : : #include <linux/sunrpc/cache.h>
33 : : #include <linux/nsproxy.h>
34 : : #include <linux/notifier.h>
35 : :
36 : : #include "netns.h"
37 : : #include "sunrpc.h"
38 : :
39 : : #define RPCDBG_FACILITY RPCDBG_DEBUG
40 : :
41 : : #define NET_NAME(net) ((net == &init_net) ? " (init_net)" : "")
42 : :
43 : : static struct file_system_type rpc_pipe_fs_type;
44 : : static const struct rpc_pipe_ops gssd_dummy_pipe_ops;
45 : :
46 : : static struct kmem_cache *rpc_inode_cachep __read_mostly;
47 : :
48 : : #define RPC_UPCALL_TIMEOUT (30*HZ)
49 : :
50 : : static BLOCKING_NOTIFIER_HEAD(rpc_pipefs_notifier_list);
51 : :
52 : 3 : int rpc_pipefs_notifier_register(struct notifier_block *nb)
53 : : {
54 : 3 : return blocking_notifier_chain_cond_register(&rpc_pipefs_notifier_list, nb);
55 : : }
56 : : EXPORT_SYMBOL_GPL(rpc_pipefs_notifier_register);
57 : :
58 : 0 : void rpc_pipefs_notifier_unregister(struct notifier_block *nb)
59 : : {
60 : 0 : blocking_notifier_chain_unregister(&rpc_pipefs_notifier_list, nb);
61 : 0 : }
62 : : EXPORT_SYMBOL_GPL(rpc_pipefs_notifier_unregister);
63 : :
64 : 0 : static void rpc_purge_list(wait_queue_head_t *waitq, struct list_head *head,
65 : : void (*destroy_msg)(struct rpc_pipe_msg *), int err)
66 : : {
67 : : struct rpc_pipe_msg *msg;
68 : :
69 : 0 : if (list_empty(head))
70 : 0 : return;
71 : : do {
72 : 0 : msg = list_entry(head->next, struct rpc_pipe_msg, list);
73 : 0 : list_del_init(&msg->list);
74 : 0 : msg->errno = err;
75 : 0 : destroy_msg(msg);
76 : 0 : } while (!list_empty(head));
77 : :
78 : 0 : if (waitq)
79 : 0 : wake_up(waitq);
80 : : }
81 : :
82 : : static void
83 : 0 : rpc_timeout_upcall_queue(struct work_struct *work)
84 : : {
85 : 0 : LIST_HEAD(free_list);
86 : : struct rpc_pipe *pipe =
87 : : container_of(work, struct rpc_pipe, queue_timeout.work);
88 : : void (*destroy_msg)(struct rpc_pipe_msg *);
89 : : struct dentry *dentry;
90 : :
91 : : spin_lock(&pipe->lock);
92 : 0 : destroy_msg = pipe->ops->destroy_msg;
93 : 0 : if (pipe->nreaders == 0) {
94 : 0 : list_splice_init(&pipe->pipe, &free_list);
95 : 0 : pipe->pipelen = 0;
96 : : }
97 : 0 : dentry = dget(pipe->dentry);
98 : : spin_unlock(&pipe->lock);
99 : 0 : rpc_purge_list(dentry ? &RPC_I(d_inode(dentry))->waitq : NULL,
100 : : &free_list, destroy_msg, -ETIMEDOUT);
101 : 0 : dput(dentry);
102 : 0 : }
103 : :
104 : 0 : ssize_t rpc_pipe_generic_upcall(struct file *filp, struct rpc_pipe_msg *msg,
105 : : char __user *dst, size_t buflen)
106 : : {
107 : 0 : char *data = (char *)msg->data + msg->copied;
108 : 0 : size_t mlen = min(msg->len - msg->copied, buflen);
109 : : unsigned long left;
110 : :
111 : : left = copy_to_user(dst, data, mlen);
112 : 0 : if (left == mlen) {
113 : 0 : msg->errno = -EFAULT;
114 : 0 : return -EFAULT;
115 : : }
116 : :
117 : 0 : mlen -= left;
118 : 0 : msg->copied += mlen;
119 : 0 : msg->errno = 0;
120 : 0 : return mlen;
121 : : }
122 : : EXPORT_SYMBOL_GPL(rpc_pipe_generic_upcall);
123 : :
124 : : /**
125 : : * rpc_queue_upcall - queue an upcall message to userspace
126 : : * @pipe: upcall pipe on which to queue given message
127 : : * @msg: message to queue
128 : : *
129 : : * Call with an @inode created by rpc_mkpipe() to queue an upcall.
130 : : * A userspace process may then later read the upcall by performing a
131 : : * read on an open file for this inode. It is up to the caller to
132 : : * initialize the fields of @msg (other than @msg->list) appropriately.
133 : : */
134 : : int
135 : 0 : rpc_queue_upcall(struct rpc_pipe *pipe, struct rpc_pipe_msg *msg)
136 : : {
137 : : int res = -EPIPE;
138 : : struct dentry *dentry;
139 : :
140 : : spin_lock(&pipe->lock);
141 : 0 : if (pipe->nreaders) {
142 : 0 : list_add_tail(&msg->list, &pipe->pipe);
143 : 0 : pipe->pipelen += msg->len;
144 : : res = 0;
145 : 0 : } else if (pipe->flags & RPC_PIPE_WAIT_FOR_OPEN) {
146 : 0 : if (list_empty(&pipe->pipe))
147 : 0 : queue_delayed_work(rpciod_workqueue,
148 : : &pipe->queue_timeout,
149 : : RPC_UPCALL_TIMEOUT);
150 : 0 : list_add_tail(&msg->list, &pipe->pipe);
151 : 0 : pipe->pipelen += msg->len;
152 : : res = 0;
153 : : }
154 : 0 : dentry = dget(pipe->dentry);
155 : : spin_unlock(&pipe->lock);
156 : 0 : if (dentry) {
157 : 0 : wake_up(&RPC_I(d_inode(dentry))->waitq);
158 : 0 : dput(dentry);
159 : : }
160 : 0 : return res;
161 : : }
162 : : EXPORT_SYMBOL_GPL(rpc_queue_upcall);
163 : :
164 : : static inline void
165 : : rpc_inode_setowner(struct inode *inode, void *private)
166 : : {
167 : 0 : RPC_I(inode)->private = private;
168 : : }
169 : :
170 : : static void
171 : 0 : rpc_close_pipes(struct inode *inode)
172 : : {
173 : 0 : struct rpc_pipe *pipe = RPC_I(inode)->pipe;
174 : : int need_release;
175 : 0 : LIST_HEAD(free_list);
176 : :
177 : : inode_lock(inode);
178 : : spin_lock(&pipe->lock);
179 : 0 : need_release = pipe->nreaders != 0 || pipe->nwriters != 0;
180 : 0 : pipe->nreaders = 0;
181 : 0 : list_splice_init(&pipe->in_upcall, &free_list);
182 : 0 : list_splice_init(&pipe->pipe, &free_list);
183 : 0 : pipe->pipelen = 0;
184 : 0 : pipe->dentry = NULL;
185 : : spin_unlock(&pipe->lock);
186 : 0 : rpc_purge_list(&RPC_I(inode)->waitq, &free_list, pipe->ops->destroy_msg, -EPIPE);
187 : 0 : pipe->nwriters = 0;
188 : 0 : if (need_release && pipe->ops->release_pipe)
189 : 0 : pipe->ops->release_pipe(inode);
190 : 0 : cancel_delayed_work_sync(&pipe->queue_timeout);
191 : : rpc_inode_setowner(inode, NULL);
192 : 0 : RPC_I(inode)->pipe = NULL;
193 : : inode_unlock(inode);
194 : 0 : }
195 : :
196 : : static struct inode *
197 : 3 : rpc_alloc_inode(struct super_block *sb)
198 : : {
199 : : struct rpc_inode *rpci;
200 : 3 : rpci = kmem_cache_alloc(rpc_inode_cachep, GFP_KERNEL);
201 : 3 : if (!rpci)
202 : : return NULL;
203 : 3 : return &rpci->vfs_inode;
204 : : }
205 : :
206 : : static void
207 : 0 : rpc_free_inode(struct inode *inode)
208 : : {
209 : 0 : kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
210 : 0 : }
211 : :
212 : : static int
213 : 0 : rpc_pipe_open(struct inode *inode, struct file *filp)
214 : : {
215 : : struct rpc_pipe *pipe;
216 : : int first_open;
217 : : int res = -ENXIO;
218 : :
219 : : inode_lock(inode);
220 : 0 : pipe = RPC_I(inode)->pipe;
221 : 0 : if (pipe == NULL)
222 : : goto out;
223 : 0 : first_open = pipe->nreaders == 0 && pipe->nwriters == 0;
224 : 0 : if (first_open && pipe->ops->open_pipe) {
225 : 0 : res = pipe->ops->open_pipe(inode);
226 : 0 : if (res)
227 : : goto out;
228 : : }
229 : 0 : if (filp->f_mode & FMODE_READ)
230 : 0 : pipe->nreaders++;
231 : 0 : if (filp->f_mode & FMODE_WRITE)
232 : 0 : pipe->nwriters++;
233 : : res = 0;
234 : : out:
235 : : inode_unlock(inode);
236 : 0 : return res;
237 : : }
238 : :
239 : : static int
240 : 0 : rpc_pipe_release(struct inode *inode, struct file *filp)
241 : : {
242 : : struct rpc_pipe *pipe;
243 : : struct rpc_pipe_msg *msg;
244 : : int last_close;
245 : :
246 : : inode_lock(inode);
247 : 0 : pipe = RPC_I(inode)->pipe;
248 : 0 : if (pipe == NULL)
249 : : goto out;
250 : 0 : msg = filp->private_data;
251 : 0 : if (msg != NULL) {
252 : : spin_lock(&pipe->lock);
253 : 0 : msg->errno = -EAGAIN;
254 : 0 : list_del_init(&msg->list);
255 : : spin_unlock(&pipe->lock);
256 : 0 : pipe->ops->destroy_msg(msg);
257 : : }
258 : 0 : if (filp->f_mode & FMODE_WRITE)
259 : 0 : pipe->nwriters --;
260 : 0 : if (filp->f_mode & FMODE_READ) {
261 : 0 : pipe->nreaders --;
262 : 0 : if (pipe->nreaders == 0) {
263 : 0 : LIST_HEAD(free_list);
264 : : spin_lock(&pipe->lock);
265 : 0 : list_splice_init(&pipe->pipe, &free_list);
266 : 0 : pipe->pipelen = 0;
267 : : spin_unlock(&pipe->lock);
268 : 0 : rpc_purge_list(&RPC_I(inode)->waitq, &free_list,
269 : 0 : pipe->ops->destroy_msg, -EAGAIN);
270 : : }
271 : : }
272 : 0 : last_close = pipe->nwriters == 0 && pipe->nreaders == 0;
273 : 0 : if (last_close && pipe->ops->release_pipe)
274 : 0 : pipe->ops->release_pipe(inode);
275 : : out:
276 : : inode_unlock(inode);
277 : 0 : return 0;
278 : : }
279 : :
280 : : static ssize_t
281 : 0 : rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
282 : : {
283 : : struct inode *inode = file_inode(filp);
284 : : struct rpc_pipe *pipe;
285 : : struct rpc_pipe_msg *msg;
286 : : int res = 0;
287 : :
288 : : inode_lock(inode);
289 : 0 : pipe = RPC_I(inode)->pipe;
290 : 0 : if (pipe == NULL) {
291 : : res = -EPIPE;
292 : : goto out_unlock;
293 : : }
294 : 0 : msg = filp->private_data;
295 : 0 : if (msg == NULL) {
296 : : spin_lock(&pipe->lock);
297 : 0 : if (!list_empty(&pipe->pipe)) {
298 : 0 : msg = list_entry(pipe->pipe.next,
299 : : struct rpc_pipe_msg,
300 : : list);
301 : 0 : list_move(&msg->list, &pipe->in_upcall);
302 : 0 : pipe->pipelen -= msg->len;
303 : 0 : filp->private_data = msg;
304 : 0 : msg->copied = 0;
305 : : }
306 : : spin_unlock(&pipe->lock);
307 : 0 : if (msg == NULL)
308 : : goto out_unlock;
309 : : }
310 : : /* NOTE: it is up to the callback to update msg->copied */
311 : 0 : res = pipe->ops->upcall(filp, msg, buf, len);
312 : 0 : if (res < 0 || msg->len == msg->copied) {
313 : 0 : filp->private_data = NULL;
314 : : spin_lock(&pipe->lock);
315 : 0 : list_del_init(&msg->list);
316 : : spin_unlock(&pipe->lock);
317 : 0 : pipe->ops->destroy_msg(msg);
318 : : }
319 : : out_unlock:
320 : : inode_unlock(inode);
321 : 0 : return res;
322 : : }
323 : :
324 : : static ssize_t
325 : 0 : rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *offset)
326 : : {
327 : : struct inode *inode = file_inode(filp);
328 : : int res;
329 : :
330 : : inode_lock(inode);
331 : : res = -EPIPE;
332 : 0 : if (RPC_I(inode)->pipe != NULL)
333 : 0 : res = RPC_I(inode)->pipe->ops->downcall(filp, buf, len);
334 : : inode_unlock(inode);
335 : 0 : return res;
336 : : }
337 : :
338 : : static __poll_t
339 : 0 : rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
340 : : {
341 : : struct inode *inode = file_inode(filp);
342 : : struct rpc_inode *rpci = RPC_I(inode);
343 : : __poll_t mask = EPOLLOUT | EPOLLWRNORM;
344 : :
345 : 0 : poll_wait(filp, &rpci->waitq, wait);
346 : :
347 : : inode_lock(inode);
348 : 0 : if (rpci->pipe == NULL)
349 : : mask |= EPOLLERR | EPOLLHUP;
350 : 0 : else if (filp->private_data || !list_empty(&rpci->pipe->pipe))
351 : : mask |= EPOLLIN | EPOLLRDNORM;
352 : : inode_unlock(inode);
353 : 0 : return mask;
354 : : }
355 : :
356 : : static long
357 : 0 : rpc_pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
358 : : {
359 : : struct inode *inode = file_inode(filp);
360 : : struct rpc_pipe *pipe;
361 : : int len;
362 : :
363 : 0 : switch (cmd) {
364 : : case FIONREAD:
365 : : inode_lock(inode);
366 : 0 : pipe = RPC_I(inode)->pipe;
367 : 0 : if (pipe == NULL) {
368 : : inode_unlock(inode);
369 : 0 : return -EPIPE;
370 : : }
371 : : spin_lock(&pipe->lock);
372 : 0 : len = pipe->pipelen;
373 : 0 : if (filp->private_data) {
374 : : struct rpc_pipe_msg *msg;
375 : : msg = filp->private_data;
376 : 0 : len += msg->len - msg->copied;
377 : : }
378 : : spin_unlock(&pipe->lock);
379 : : inode_unlock(inode);
380 : 0 : return put_user(len, (int __user *)arg);
381 : : default:
382 : : return -EINVAL;
383 : : }
384 : : }
385 : :
386 : : static const struct file_operations rpc_pipe_fops = {
387 : : .owner = THIS_MODULE,
388 : : .llseek = no_llseek,
389 : : .read = rpc_pipe_read,
390 : : .write = rpc_pipe_write,
391 : : .poll = rpc_pipe_poll,
392 : : .unlocked_ioctl = rpc_pipe_ioctl,
393 : : .open = rpc_pipe_open,
394 : : .release = rpc_pipe_release,
395 : : };
396 : :
397 : : static int
398 : 0 : rpc_show_info(struct seq_file *m, void *v)
399 : : {
400 : 0 : struct rpc_clnt *clnt = m->private;
401 : :
402 : : rcu_read_lock();
403 : 0 : seq_printf(m, "RPC server: %s\n",
404 : 0 : rcu_dereference(clnt->cl_xprt)->servername);
405 : 0 : seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_program->name,
406 : : clnt->cl_prog, clnt->cl_vers);
407 : 0 : seq_printf(m, "address: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR));
408 : 0 : seq_printf(m, "protocol: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PROTO));
409 : 0 : seq_printf(m, "port: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PORT));
410 : : rcu_read_unlock();
411 : 0 : return 0;
412 : : }
413 : :
414 : : static int
415 : 0 : rpc_info_open(struct inode *inode, struct file *file)
416 : : {
417 : : struct rpc_clnt *clnt = NULL;
418 : 0 : int ret = single_open(file, rpc_show_info, NULL);
419 : :
420 : 0 : if (!ret) {
421 : 0 : struct seq_file *m = file->private_data;
422 : :
423 : 0 : spin_lock(&file->f_path.dentry->d_lock);
424 : 0 : if (!d_unhashed(file->f_path.dentry))
425 : 0 : clnt = RPC_I(inode)->private;
426 : 0 : if (clnt != NULL && atomic_inc_not_zero(&clnt->cl_count)) {
427 : 0 : spin_unlock(&file->f_path.dentry->d_lock);
428 : 0 : m->private = clnt;
429 : : } else {
430 : 0 : spin_unlock(&file->f_path.dentry->d_lock);
431 : 0 : single_release(inode, file);
432 : : ret = -EINVAL;
433 : : }
434 : : }
435 : 0 : return ret;
436 : : }
437 : :
438 : : static int
439 : 0 : rpc_info_release(struct inode *inode, struct file *file)
440 : : {
441 : 0 : struct seq_file *m = file->private_data;
442 : 0 : struct rpc_clnt *clnt = (struct rpc_clnt *)m->private;
443 : :
444 : 0 : if (clnt)
445 : 0 : rpc_release_client(clnt);
446 : 0 : return single_release(inode, file);
447 : : }
448 : :
449 : : static const struct file_operations rpc_info_operations = {
450 : : .owner = THIS_MODULE,
451 : : .open = rpc_info_open,
452 : : .read = seq_read,
453 : : .llseek = seq_lseek,
454 : : .release = rpc_info_release,
455 : : };
456 : :
457 : :
458 : : /*
459 : : * Description of fs contents.
460 : : */
461 : : struct rpc_filelist {
462 : : const char *name;
463 : : const struct file_operations *i_fop;
464 : : umode_t mode;
465 : : };
466 : :
467 : : static struct inode *
468 : 3 : rpc_get_inode(struct super_block *sb, umode_t mode)
469 : : {
470 : 3 : struct inode *inode = new_inode(sb);
471 : 3 : if (!inode)
472 : : return NULL;
473 : 3 : inode->i_ino = get_next_ino();
474 : 3 : inode->i_mode = mode;
475 : 3 : inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
476 : 3 : switch (mode & S_IFMT) {
477 : : case S_IFDIR:
478 : 3 : inode->i_fop = &simple_dir_operations;
479 : 3 : inode->i_op = &simple_dir_inode_operations;
480 : 3 : inc_nlink(inode);
481 : : default:
482 : : break;
483 : : }
484 : 3 : return inode;
485 : : }
486 : :
487 : 3 : static int __rpc_create_common(struct inode *dir, struct dentry *dentry,
488 : : umode_t mode,
489 : : const struct file_operations *i_fop,
490 : : void *private)
491 : : {
492 : : struct inode *inode;
493 : :
494 : 3 : d_drop(dentry);
495 : 3 : inode = rpc_get_inode(dir->i_sb, mode);
496 : 3 : if (!inode)
497 : : goto out_err;
498 : 3 : inode->i_ino = iunique(dir->i_sb, 100);
499 : 3 : if (i_fop)
500 : 3 : inode->i_fop = i_fop;
501 : 3 : if (private)
502 : : rpc_inode_setowner(inode, private);
503 : 3 : d_add(dentry, inode);
504 : 3 : return 0;
505 : : out_err:
506 : 0 : printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %pd\n",
507 : : __FILE__, __func__, dentry);
508 : 0 : dput(dentry);
509 : 0 : return -ENOMEM;
510 : : }
511 : :
512 : 3 : static int __rpc_create(struct inode *dir, struct dentry *dentry,
513 : : umode_t mode,
514 : : const struct file_operations *i_fop,
515 : : void *private)
516 : : {
517 : : int err;
518 : :
519 : 3 : err = __rpc_create_common(dir, dentry, S_IFREG | mode, i_fop, private);
520 : 3 : if (err)
521 : : return err;
522 : 3 : fsnotify_create(dir, dentry);
523 : 3 : return 0;
524 : : }
525 : :
526 : 3 : static int __rpc_mkdir(struct inode *dir, struct dentry *dentry,
527 : : umode_t mode,
528 : : const struct file_operations *i_fop,
529 : : void *private)
530 : : {
531 : : int err;
532 : :
533 : 3 : err = __rpc_create_common(dir, dentry, S_IFDIR | mode, i_fop, private);
534 : 3 : if (err)
535 : : return err;
536 : 3 : inc_nlink(dir);
537 : 3 : fsnotify_mkdir(dir, dentry);
538 : 3 : return 0;
539 : : }
540 : :
541 : : static void
542 : 3 : init_pipe(struct rpc_pipe *pipe)
543 : : {
544 : 3 : pipe->nreaders = 0;
545 : 3 : pipe->nwriters = 0;
546 : 3 : INIT_LIST_HEAD(&pipe->in_upcall);
547 : 3 : INIT_LIST_HEAD(&pipe->in_downcall);
548 : 3 : INIT_LIST_HEAD(&pipe->pipe);
549 : 3 : pipe->pipelen = 0;
550 : 3 : INIT_DELAYED_WORK(&pipe->queue_timeout,
551 : : rpc_timeout_upcall_queue);
552 : 3 : pipe->ops = NULL;
553 : 3 : spin_lock_init(&pipe->lock);
554 : 3 : pipe->dentry = NULL;
555 : 3 : }
556 : :
557 : 0 : void rpc_destroy_pipe_data(struct rpc_pipe *pipe)
558 : : {
559 : 1 : kfree(pipe);
560 : 0 : }
561 : : EXPORT_SYMBOL_GPL(rpc_destroy_pipe_data);
562 : :
563 : 3 : struct rpc_pipe *rpc_mkpipe_data(const struct rpc_pipe_ops *ops, int flags)
564 : : {
565 : : struct rpc_pipe *pipe;
566 : :
567 : 3 : pipe = kzalloc(sizeof(struct rpc_pipe), GFP_KERNEL);
568 : 3 : if (!pipe)
569 : : return ERR_PTR(-ENOMEM);
570 : 3 : init_pipe(pipe);
571 : 3 : pipe->ops = ops;
572 : 3 : pipe->flags = flags;
573 : 3 : return pipe;
574 : : }
575 : : EXPORT_SYMBOL_GPL(rpc_mkpipe_data);
576 : :
577 : 3 : static int __rpc_mkpipe_dentry(struct inode *dir, struct dentry *dentry,
578 : : umode_t mode,
579 : : const struct file_operations *i_fop,
580 : : void *private,
581 : : struct rpc_pipe *pipe)
582 : : {
583 : : struct rpc_inode *rpci;
584 : : int err;
585 : :
586 : 3 : err = __rpc_create_common(dir, dentry, S_IFIFO | mode, i_fop, private);
587 : 3 : if (err)
588 : : return err;
589 : : rpci = RPC_I(d_inode(dentry));
590 : 3 : rpci->private = private;
591 : 3 : rpci->pipe = pipe;
592 : 3 : fsnotify_create(dir, dentry);
593 : 3 : return 0;
594 : : }
595 : :
596 : 0 : static int __rpc_rmdir(struct inode *dir, struct dentry *dentry)
597 : : {
598 : : int ret;
599 : :
600 : : dget(dentry);
601 : 0 : ret = simple_rmdir(dir, dentry);
602 : 0 : if (!ret)
603 : 0 : fsnotify_rmdir(dir, dentry);
604 : 0 : d_delete(dentry);
605 : 0 : dput(dentry);
606 : 0 : return ret;
607 : : }
608 : :
609 : 0 : static int __rpc_unlink(struct inode *dir, struct dentry *dentry)
610 : : {
611 : : int ret;
612 : :
613 : : dget(dentry);
614 : 0 : ret = simple_unlink(dir, dentry);
615 : 0 : if (!ret)
616 : 0 : fsnotify_unlink(dir, dentry);
617 : 0 : d_delete(dentry);
618 : 0 : dput(dentry);
619 : 0 : return ret;
620 : : }
621 : :
622 : 0 : static int __rpc_rmpipe(struct inode *dir, struct dentry *dentry)
623 : : {
624 : : struct inode *inode = d_inode(dentry);
625 : :
626 : 0 : rpc_close_pipes(inode);
627 : 0 : return __rpc_unlink(dir, dentry);
628 : : }
629 : :
630 : 3 : static struct dentry *__rpc_lookup_create_exclusive(struct dentry *parent,
631 : : const char *name)
632 : : {
633 : 3 : struct qstr q = QSTR_INIT(name, strlen(name));
634 : 3 : struct dentry *dentry = d_hash_and_lookup(parent, &q);
635 : 3 : if (!dentry) {
636 : 3 : dentry = d_alloc(parent, &q);
637 : 3 : if (!dentry)
638 : : return ERR_PTR(-ENOMEM);
639 : : }
640 : 3 : if (d_really_is_negative(dentry))
641 : : return dentry;
642 : 0 : dput(dentry);
643 : 0 : return ERR_PTR(-EEXIST);
644 : : }
645 : :
646 : : /*
647 : : * FIXME: This probably has races.
648 : : */
649 : 0 : static void __rpc_depopulate(struct dentry *parent,
650 : : const struct rpc_filelist *files,
651 : : int start, int eof)
652 : : {
653 : : struct inode *dir = d_inode(parent);
654 : : struct dentry *dentry;
655 : : struct qstr name;
656 : : int i;
657 : :
658 : 0 : for (i = start; i < eof; i++) {
659 : 0 : name.name = files[i].name;
660 : 0 : name.len = strlen(files[i].name);
661 : 0 : dentry = d_hash_and_lookup(parent, &name);
662 : :
663 : 0 : if (dentry == NULL)
664 : 0 : continue;
665 : 0 : if (d_really_is_negative(dentry))
666 : : goto next;
667 : 0 : switch (d_inode(dentry)->i_mode & S_IFMT) {
668 : : default:
669 : 0 : BUG();
670 : : case S_IFREG:
671 : 0 : __rpc_unlink(dir, dentry);
672 : 0 : break;
673 : : case S_IFDIR:
674 : 0 : __rpc_rmdir(dir, dentry);
675 : : }
676 : : next:
677 : 0 : dput(dentry);
678 : : }
679 : 0 : }
680 : :
681 : 0 : static void rpc_depopulate(struct dentry *parent,
682 : : const struct rpc_filelist *files,
683 : : int start, int eof)
684 : : {
685 : : struct inode *dir = d_inode(parent);
686 : :
687 : : inode_lock_nested(dir, I_MUTEX_CHILD);
688 : 0 : __rpc_depopulate(parent, files, start, eof);
689 : : inode_unlock(dir);
690 : 0 : }
691 : :
692 : 3 : static int rpc_populate(struct dentry *parent,
693 : : const struct rpc_filelist *files,
694 : : int start, int eof,
695 : : void *private)
696 : : {
697 : : struct inode *dir = d_inode(parent);
698 : : struct dentry *dentry;
699 : : int i, err;
700 : :
701 : : inode_lock(dir);
702 : 3 : for (i = start; i < eof; i++) {
703 : 3 : dentry = __rpc_lookup_create_exclusive(parent, files[i].name);
704 : : err = PTR_ERR(dentry);
705 : 3 : if (IS_ERR(dentry))
706 : : goto out_bad;
707 : 3 : switch (files[i].mode & S_IFMT) {
708 : : default:
709 : 0 : BUG();
710 : : case S_IFREG:
711 : 3 : err = __rpc_create(dir, dentry,
712 : : files[i].mode,
713 : : files[i].i_fop,
714 : : private);
715 : 3 : break;
716 : : case S_IFDIR:
717 : 3 : err = __rpc_mkdir(dir, dentry,
718 : : files[i].mode,
719 : : NULL,
720 : : private);
721 : : }
722 : 3 : if (err != 0)
723 : : goto out_bad;
724 : : }
725 : : inode_unlock(dir);
726 : 3 : return 0;
727 : : out_bad:
728 : 0 : __rpc_depopulate(parent, files, start, eof);
729 : : inode_unlock(dir);
730 : 0 : printk(KERN_WARNING "%s: %s failed to populate directory %pd\n",
731 : : __FILE__, __func__, parent);
732 : 0 : return err;
733 : : }
734 : :
735 : 0 : static struct dentry *rpc_mkdir_populate(struct dentry *parent,
736 : : const char *name, umode_t mode, void *private,
737 : : int (*populate)(struct dentry *, void *), void *args_populate)
738 : : {
739 : : struct dentry *dentry;
740 : : struct inode *dir = d_inode(parent);
741 : : int error;
742 : :
743 : : inode_lock_nested(dir, I_MUTEX_PARENT);
744 : 0 : dentry = __rpc_lookup_create_exclusive(parent, name);
745 : 0 : if (IS_ERR(dentry))
746 : : goto out;
747 : 0 : error = __rpc_mkdir(dir, dentry, mode, NULL, private);
748 : 0 : if (error != 0)
749 : : goto out_err;
750 : 0 : if (populate != NULL) {
751 : 0 : error = populate(dentry, args_populate);
752 : 0 : if (error)
753 : : goto err_rmdir;
754 : : }
755 : : out:
756 : : inode_unlock(dir);
757 : 0 : return dentry;
758 : : err_rmdir:
759 : 0 : __rpc_rmdir(dir, dentry);
760 : : out_err:
761 : : dentry = ERR_PTR(error);
762 : 0 : goto out;
763 : : }
764 : :
765 : 0 : static int rpc_rmdir_depopulate(struct dentry *dentry,
766 : : void (*depopulate)(struct dentry *))
767 : : {
768 : : struct dentry *parent;
769 : : struct inode *dir;
770 : : int error;
771 : :
772 : 0 : parent = dget_parent(dentry);
773 : : dir = d_inode(parent);
774 : : inode_lock_nested(dir, I_MUTEX_PARENT);
775 : 0 : if (depopulate != NULL)
776 : 0 : depopulate(dentry);
777 : 0 : error = __rpc_rmdir(dir, dentry);
778 : : inode_unlock(dir);
779 : 0 : dput(parent);
780 : 0 : return error;
781 : : }
782 : :
783 : : /**
784 : : * rpc_mkpipe - make an rpc_pipefs file for kernel<->userspace communication
785 : : * @parent: dentry of directory to create new "pipe" in
786 : : * @name: name of pipe
787 : : * @private: private data to associate with the pipe, for the caller's use
788 : : * @pipe: &rpc_pipe containing input parameters
789 : : *
790 : : * Data is made available for userspace to read by calls to
791 : : * rpc_queue_upcall(). The actual reads will result in calls to
792 : : * @ops->upcall, which will be called with the file pointer,
793 : : * message, and userspace buffer to copy to.
794 : : *
795 : : * Writes can come at any time, and do not necessarily have to be
796 : : * responses to upcalls. They will result in calls to @msg->downcall.
797 : : *
798 : : * The @private argument passed here will be available to all these methods
799 : : * from the file pointer, via RPC_I(file_inode(file))->private.
800 : : */
801 : 3 : struct dentry *rpc_mkpipe_dentry(struct dentry *parent, const char *name,
802 : : void *private, struct rpc_pipe *pipe)
803 : : {
804 : : struct dentry *dentry;
805 : : struct inode *dir = d_inode(parent);
806 : : umode_t umode = S_IFIFO | 0600;
807 : : int err;
808 : :
809 : 3 : if (pipe->ops->upcall == NULL)
810 : : umode &= ~0444;
811 : 3 : if (pipe->ops->downcall == NULL)
812 : 0 : umode &= ~0222;
813 : :
814 : : inode_lock_nested(dir, I_MUTEX_PARENT);
815 : 3 : dentry = __rpc_lookup_create_exclusive(parent, name);
816 : 3 : if (IS_ERR(dentry))
817 : : goto out;
818 : 3 : err = __rpc_mkpipe_dentry(dir, dentry, umode, &rpc_pipe_fops,
819 : : private, pipe);
820 : 3 : if (err)
821 : : goto out_err;
822 : : out:
823 : : inode_unlock(dir);
824 : 3 : return dentry;
825 : : out_err:
826 : : dentry = ERR_PTR(err);
827 : 0 : printk(KERN_WARNING "%s: %s() failed to create pipe %pd/%s (errno = %d)\n",
828 : : __FILE__, __func__, parent, name,
829 : : err);
830 : 0 : goto out;
831 : : }
832 : : EXPORT_SYMBOL_GPL(rpc_mkpipe_dentry);
833 : :
834 : : /**
835 : : * rpc_unlink - remove a pipe
836 : : * @dentry: dentry for the pipe, as returned from rpc_mkpipe
837 : : *
838 : : * After this call, lookups will no longer find the pipe, and any
839 : : * attempts to read or write using preexisting opens of the pipe will
840 : : * return -EPIPE.
841 : : */
842 : : int
843 : 0 : rpc_unlink(struct dentry *dentry)
844 : : {
845 : : struct dentry *parent;
846 : : struct inode *dir;
847 : : int error = 0;
848 : :
849 : 0 : parent = dget_parent(dentry);
850 : : dir = d_inode(parent);
851 : : inode_lock_nested(dir, I_MUTEX_PARENT);
852 : : error = __rpc_rmpipe(dir, dentry);
853 : : inode_unlock(dir);
854 : 0 : dput(parent);
855 : 0 : return error;
856 : : }
857 : : EXPORT_SYMBOL_GPL(rpc_unlink);
858 : :
859 : : /**
860 : : * rpc_init_pipe_dir_head - initialise a struct rpc_pipe_dir_head
861 : : * @pdh: pointer to struct rpc_pipe_dir_head
862 : : */
863 : 0 : void rpc_init_pipe_dir_head(struct rpc_pipe_dir_head *pdh)
864 : : {
865 : 0 : INIT_LIST_HEAD(&pdh->pdh_entries);
866 : 0 : pdh->pdh_dentry = NULL;
867 : 0 : }
868 : : EXPORT_SYMBOL_GPL(rpc_init_pipe_dir_head);
869 : :
870 : : /**
871 : : * rpc_init_pipe_dir_object - initialise a struct rpc_pipe_dir_object
872 : : * @pdo: pointer to struct rpc_pipe_dir_object
873 : : * @pdo_ops: pointer to const struct rpc_pipe_dir_object_ops
874 : : * @pdo_data: pointer to caller-defined data
875 : : */
876 : 0 : void rpc_init_pipe_dir_object(struct rpc_pipe_dir_object *pdo,
877 : : const struct rpc_pipe_dir_object_ops *pdo_ops,
878 : : void *pdo_data)
879 : : {
880 : 0 : INIT_LIST_HEAD(&pdo->pdo_head);
881 : 0 : pdo->pdo_ops = pdo_ops;
882 : 0 : pdo->pdo_data = pdo_data;
883 : 0 : }
884 : : EXPORT_SYMBOL_GPL(rpc_init_pipe_dir_object);
885 : :
886 : : static int
887 : : rpc_add_pipe_dir_object_locked(struct net *net,
888 : : struct rpc_pipe_dir_head *pdh,
889 : : struct rpc_pipe_dir_object *pdo)
890 : : {
891 : : int ret = 0;
892 : :
893 : 0 : if (pdh->pdh_dentry)
894 : 0 : ret = pdo->pdo_ops->create(pdh->pdh_dentry, pdo);
895 : 0 : if (ret == 0)
896 : 0 : list_add_tail(&pdo->pdo_head, &pdh->pdh_entries);
897 : : return ret;
898 : : }
899 : :
900 : : static void
901 : : rpc_remove_pipe_dir_object_locked(struct net *net,
902 : : struct rpc_pipe_dir_head *pdh,
903 : : struct rpc_pipe_dir_object *pdo)
904 : : {
905 : 0 : if (pdh->pdh_dentry)
906 : 0 : pdo->pdo_ops->destroy(pdh->pdh_dentry, pdo);
907 : : list_del_init(&pdo->pdo_head);
908 : : }
909 : :
910 : : /**
911 : : * rpc_add_pipe_dir_object - associate a rpc_pipe_dir_object to a directory
912 : : * @net: pointer to struct net
913 : : * @pdh: pointer to struct rpc_pipe_dir_head
914 : : * @pdo: pointer to struct rpc_pipe_dir_object
915 : : *
916 : : */
917 : : int
918 : 0 : rpc_add_pipe_dir_object(struct net *net,
919 : : struct rpc_pipe_dir_head *pdh,
920 : : struct rpc_pipe_dir_object *pdo)
921 : : {
922 : : int ret = 0;
923 : :
924 : 0 : if (list_empty(&pdo->pdo_head)) {
925 : 0 : struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
926 : :
927 : 0 : mutex_lock(&sn->pipefs_sb_lock);
928 : : ret = rpc_add_pipe_dir_object_locked(net, pdh, pdo);
929 : 0 : mutex_unlock(&sn->pipefs_sb_lock);
930 : : }
931 : 0 : return ret;
932 : : }
933 : : EXPORT_SYMBOL_GPL(rpc_add_pipe_dir_object);
934 : :
935 : : /**
936 : : * rpc_remove_pipe_dir_object - remove a rpc_pipe_dir_object from a directory
937 : : * @net: pointer to struct net
938 : : * @pdh: pointer to struct rpc_pipe_dir_head
939 : : * @pdo: pointer to struct rpc_pipe_dir_object
940 : : *
941 : : */
942 : : void
943 : 0 : rpc_remove_pipe_dir_object(struct net *net,
944 : : struct rpc_pipe_dir_head *pdh,
945 : : struct rpc_pipe_dir_object *pdo)
946 : : {
947 : 0 : if (!list_empty(&pdo->pdo_head)) {
948 : 0 : struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
949 : :
950 : 0 : mutex_lock(&sn->pipefs_sb_lock);
951 : : rpc_remove_pipe_dir_object_locked(net, pdh, pdo);
952 : 0 : mutex_unlock(&sn->pipefs_sb_lock);
953 : : }
954 : 0 : }
955 : : EXPORT_SYMBOL_GPL(rpc_remove_pipe_dir_object);
956 : :
957 : : /**
958 : : * rpc_find_or_alloc_pipe_dir_object
959 : : * @net: pointer to struct net
960 : : * @pdh: pointer to struct rpc_pipe_dir_head
961 : : * @match: match struct rpc_pipe_dir_object to data
962 : : * @alloc: allocate a new struct rpc_pipe_dir_object
963 : : * @data: user defined data for match() and alloc()
964 : : *
965 : : */
966 : : struct rpc_pipe_dir_object *
967 : 0 : rpc_find_or_alloc_pipe_dir_object(struct net *net,
968 : : struct rpc_pipe_dir_head *pdh,
969 : : int (*match)(struct rpc_pipe_dir_object *, void *),
970 : : struct rpc_pipe_dir_object *(*alloc)(void *),
971 : : void *data)
972 : : {
973 : 0 : struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
974 : : struct rpc_pipe_dir_object *pdo;
975 : :
976 : 0 : mutex_lock(&sn->pipefs_sb_lock);
977 : 0 : list_for_each_entry(pdo, &pdh->pdh_entries, pdo_head) {
978 : 0 : if (!match(pdo, data))
979 : 0 : continue;
980 : : goto out;
981 : : }
982 : 0 : pdo = alloc(data);
983 : 0 : if (!pdo)
984 : : goto out;
985 : : rpc_add_pipe_dir_object_locked(net, pdh, pdo);
986 : : out:
987 : 0 : mutex_unlock(&sn->pipefs_sb_lock);
988 : 0 : return pdo;
989 : : }
990 : : EXPORT_SYMBOL_GPL(rpc_find_or_alloc_pipe_dir_object);
991 : :
992 : : static void
993 : : rpc_create_pipe_dir_objects(struct rpc_pipe_dir_head *pdh)
994 : : {
995 : : struct rpc_pipe_dir_object *pdo;
996 : : struct dentry *dir = pdh->pdh_dentry;
997 : :
998 : 0 : list_for_each_entry(pdo, &pdh->pdh_entries, pdo_head)
999 : 0 : pdo->pdo_ops->create(dir, pdo);
1000 : : }
1001 : :
1002 : : static void
1003 : : rpc_destroy_pipe_dir_objects(struct rpc_pipe_dir_head *pdh)
1004 : : {
1005 : : struct rpc_pipe_dir_object *pdo;
1006 : : struct dentry *dir = pdh->pdh_dentry;
1007 : :
1008 : 0 : list_for_each_entry(pdo, &pdh->pdh_entries, pdo_head)
1009 : 0 : pdo->pdo_ops->destroy(dir, pdo);
1010 : : }
1011 : :
1012 : : enum {
1013 : : RPCAUTH_info,
1014 : : RPCAUTH_EOF
1015 : : };
1016 : :
1017 : : static const struct rpc_filelist authfiles[] = {
1018 : : [RPCAUTH_info] = {
1019 : : .name = "info",
1020 : : .i_fop = &rpc_info_operations,
1021 : : .mode = S_IFREG | 0400,
1022 : : },
1023 : : };
1024 : :
1025 : 0 : static int rpc_clntdir_populate(struct dentry *dentry, void *private)
1026 : : {
1027 : 0 : return rpc_populate(dentry,
1028 : : authfiles, RPCAUTH_info, RPCAUTH_EOF,
1029 : : private);
1030 : : }
1031 : :
1032 : 0 : static void rpc_clntdir_depopulate(struct dentry *dentry)
1033 : : {
1034 : 0 : rpc_depopulate(dentry, authfiles, RPCAUTH_info, RPCAUTH_EOF);
1035 : 0 : }
1036 : :
1037 : : /**
1038 : : * rpc_create_client_dir - Create a new rpc_client directory in rpc_pipefs
1039 : : * @dentry: the parent of new directory
1040 : : * @name: the name of new directory
1041 : : * @rpc_client: rpc client to associate with this directory
1042 : : *
1043 : : * This creates a directory at the given @path associated with
1044 : : * @rpc_clnt, which will contain a file named "info" with some basic
1045 : : * information about the client, together with any "pipes" that may
1046 : : * later be created using rpc_mkpipe().
1047 : : */
1048 : 0 : struct dentry *rpc_create_client_dir(struct dentry *dentry,
1049 : : const char *name,
1050 : : struct rpc_clnt *rpc_client)
1051 : : {
1052 : : struct dentry *ret;
1053 : :
1054 : 0 : ret = rpc_mkdir_populate(dentry, name, 0555, NULL,
1055 : : rpc_clntdir_populate, rpc_client);
1056 : 0 : if (!IS_ERR(ret)) {
1057 : 0 : rpc_client->cl_pipedir_objects.pdh_dentry = ret;
1058 : 0 : rpc_create_pipe_dir_objects(&rpc_client->cl_pipedir_objects);
1059 : : }
1060 : 0 : return ret;
1061 : : }
1062 : :
1063 : : /**
1064 : : * rpc_remove_client_dir - Remove a directory created with rpc_create_client_dir()
1065 : : * @rpc_client: rpc_client for the pipe
1066 : : */
1067 : 0 : int rpc_remove_client_dir(struct rpc_clnt *rpc_client)
1068 : : {
1069 : 0 : struct dentry *dentry = rpc_client->cl_pipedir_objects.pdh_dentry;
1070 : :
1071 : 0 : if (dentry == NULL)
1072 : : return 0;
1073 : 0 : rpc_destroy_pipe_dir_objects(&rpc_client->cl_pipedir_objects);
1074 : 0 : rpc_client->cl_pipedir_objects.pdh_dentry = NULL;
1075 : 0 : return rpc_rmdir_depopulate(dentry, rpc_clntdir_depopulate);
1076 : : }
1077 : :
1078 : : static const struct rpc_filelist cache_pipefs_files[3] = {
1079 : : [0] = {
1080 : : .name = "channel",
1081 : : .i_fop = &cache_file_operations_pipefs,
1082 : : .mode = S_IFREG | 0600,
1083 : : },
1084 : : [1] = {
1085 : : .name = "content",
1086 : : .i_fop = &content_file_operations_pipefs,
1087 : : .mode = S_IFREG | 0400,
1088 : : },
1089 : : [2] = {
1090 : : .name = "flush",
1091 : : .i_fop = &cache_flush_operations_pipefs,
1092 : : .mode = S_IFREG | 0600,
1093 : : },
1094 : : };
1095 : :
1096 : 0 : static int rpc_cachedir_populate(struct dentry *dentry, void *private)
1097 : : {
1098 : 0 : return rpc_populate(dentry,
1099 : : cache_pipefs_files, 0, 3,
1100 : : private);
1101 : : }
1102 : :
1103 : 0 : static void rpc_cachedir_depopulate(struct dentry *dentry)
1104 : : {
1105 : 0 : rpc_depopulate(dentry, cache_pipefs_files, 0, 3);
1106 : 0 : }
1107 : :
1108 : 0 : struct dentry *rpc_create_cache_dir(struct dentry *parent, const char *name,
1109 : : umode_t umode, struct cache_detail *cd)
1110 : : {
1111 : 0 : return rpc_mkdir_populate(parent, name, umode, NULL,
1112 : : rpc_cachedir_populate, cd);
1113 : : }
1114 : :
1115 : 0 : void rpc_remove_cache_dir(struct dentry *dentry)
1116 : : {
1117 : 0 : rpc_rmdir_depopulate(dentry, rpc_cachedir_depopulate);
1118 : 0 : }
1119 : :
1120 : : /*
1121 : : * populate the filesystem
1122 : : */
1123 : : static const struct super_operations s_ops = {
1124 : : .alloc_inode = rpc_alloc_inode,
1125 : : .free_inode = rpc_free_inode,
1126 : : .statfs = simple_statfs,
1127 : : };
1128 : :
1129 : : #define RPCAUTH_GSSMAGIC 0x67596969
1130 : :
1131 : : /*
1132 : : * We have a single directory with 1 node in it.
1133 : : */
1134 : : enum {
1135 : : RPCAUTH_lockd,
1136 : : RPCAUTH_mount,
1137 : : RPCAUTH_nfs,
1138 : : RPCAUTH_portmap,
1139 : : RPCAUTH_statd,
1140 : : RPCAUTH_nfsd4_cb,
1141 : : RPCAUTH_cache,
1142 : : RPCAUTH_nfsd,
1143 : : RPCAUTH_gssd,
1144 : : RPCAUTH_RootEOF
1145 : : };
1146 : :
1147 : : static const struct rpc_filelist files[] = {
1148 : : [RPCAUTH_lockd] = {
1149 : : .name = "lockd",
1150 : : .mode = S_IFDIR | 0555,
1151 : : },
1152 : : [RPCAUTH_mount] = {
1153 : : .name = "mount",
1154 : : .mode = S_IFDIR | 0555,
1155 : : },
1156 : : [RPCAUTH_nfs] = {
1157 : : .name = "nfs",
1158 : : .mode = S_IFDIR | 0555,
1159 : : },
1160 : : [RPCAUTH_portmap] = {
1161 : : .name = "portmap",
1162 : : .mode = S_IFDIR | 0555,
1163 : : },
1164 : : [RPCAUTH_statd] = {
1165 : : .name = "statd",
1166 : : .mode = S_IFDIR | 0555,
1167 : : },
1168 : : [RPCAUTH_nfsd4_cb] = {
1169 : : .name = "nfsd4_cb",
1170 : : .mode = S_IFDIR | 0555,
1171 : : },
1172 : : [RPCAUTH_cache] = {
1173 : : .name = "cache",
1174 : : .mode = S_IFDIR | 0555,
1175 : : },
1176 : : [RPCAUTH_nfsd] = {
1177 : : .name = "nfsd",
1178 : : .mode = S_IFDIR | 0555,
1179 : : },
1180 : : [RPCAUTH_gssd] = {
1181 : : .name = "gssd",
1182 : : .mode = S_IFDIR | 0555,
1183 : : },
1184 : : };
1185 : :
1186 : : /*
1187 : : * This call can be used only in RPC pipefs mount notification hooks.
1188 : : */
1189 : 0 : struct dentry *rpc_d_lookup_sb(const struct super_block *sb,
1190 : : const unsigned char *dir_name)
1191 : : {
1192 : 0 : struct qstr dir = QSTR_INIT(dir_name, strlen(dir_name));
1193 : 0 : return d_hash_and_lookup(sb->s_root, &dir);
1194 : : }
1195 : : EXPORT_SYMBOL_GPL(rpc_d_lookup_sb);
1196 : :
1197 : 3 : int rpc_pipefs_init_net(struct net *net)
1198 : : {
1199 : 3 : struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1200 : :
1201 : 3 : sn->gssd_dummy = rpc_mkpipe_data(&gssd_dummy_pipe_ops, 0);
1202 : 3 : if (IS_ERR(sn->gssd_dummy))
1203 : 0 : return PTR_ERR(sn->gssd_dummy);
1204 : :
1205 : 3 : mutex_init(&sn->pipefs_sb_lock);
1206 : 3 : sn->pipe_version = -1;
1207 : 3 : return 0;
1208 : : }
1209 : :
1210 : 1 : void rpc_pipefs_exit_net(struct net *net)
1211 : : {
1212 : 1 : struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1213 : :
1214 : 1 : rpc_destroy_pipe_data(sn->gssd_dummy);
1215 : 1 : }
1216 : :
1217 : : /*
1218 : : * This call will be used for per network namespace operations calls.
1219 : : * Note: Function will be returned with pipefs_sb_lock taken if superblock was
1220 : : * found. This lock have to be released by rpc_put_sb_net() when all operations
1221 : : * will be completed.
1222 : : */
1223 : 0 : struct super_block *rpc_get_sb_net(const struct net *net)
1224 : : {
1225 : 0 : struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1226 : :
1227 : 0 : mutex_lock(&sn->pipefs_sb_lock);
1228 : 0 : if (sn->pipefs_sb)
1229 : : return sn->pipefs_sb;
1230 : 0 : mutex_unlock(&sn->pipefs_sb_lock);
1231 : 0 : return NULL;
1232 : : }
1233 : : EXPORT_SYMBOL_GPL(rpc_get_sb_net);
1234 : :
1235 : 0 : void rpc_put_sb_net(const struct net *net)
1236 : : {
1237 : 0 : struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1238 : :
1239 : 0 : WARN_ON(sn->pipefs_sb == NULL);
1240 : 0 : mutex_unlock(&sn->pipefs_sb_lock);
1241 : 0 : }
1242 : : EXPORT_SYMBOL_GPL(rpc_put_sb_net);
1243 : :
1244 : : static const struct rpc_filelist gssd_dummy_clnt_dir[] = {
1245 : : [0] = {
1246 : : .name = "clntXX",
1247 : : .mode = S_IFDIR | 0555,
1248 : : },
1249 : : };
1250 : :
1251 : : static ssize_t
1252 : 0 : dummy_downcall(struct file *filp, const char __user *src, size_t len)
1253 : : {
1254 : 0 : return -EINVAL;
1255 : : }
1256 : :
1257 : : static const struct rpc_pipe_ops gssd_dummy_pipe_ops = {
1258 : : .upcall = rpc_pipe_generic_upcall,
1259 : : .downcall = dummy_downcall,
1260 : : };
1261 : :
1262 : : /*
1263 : : * Here we present a bogus "info" file to keep rpc.gssd happy. We don't expect
1264 : : * that it will ever use this info to handle an upcall, but rpc.gssd expects
1265 : : * that this file will be there and have a certain format.
1266 : : */
1267 : : static int
1268 : 0 : rpc_dummy_info_show(struct seq_file *m, void *v)
1269 : : {
1270 : 0 : seq_printf(m, "RPC server: %s\n", utsname()->nodename);
1271 : 0 : seq_printf(m, "service: foo (1) version 0\n");
1272 : 0 : seq_printf(m, "address: 127.0.0.1\n");
1273 : 0 : seq_printf(m, "protocol: tcp\n");
1274 : 0 : seq_printf(m, "port: 0\n");
1275 : 0 : return 0;
1276 : : }
1277 : 0 : DEFINE_SHOW_ATTRIBUTE(rpc_dummy_info);
1278 : :
1279 : : static const struct rpc_filelist gssd_dummy_info_file[] = {
1280 : : [0] = {
1281 : : .name = "info",
1282 : : .i_fop = &rpc_dummy_info_fops,
1283 : : .mode = S_IFREG | 0400,
1284 : : },
1285 : : };
1286 : :
1287 : : /**
1288 : : * rpc_gssd_dummy_populate - create a dummy gssd pipe
1289 : : * @root: root of the rpc_pipefs filesystem
1290 : : * @pipe_data: pipe data created when netns is initialized
1291 : : *
1292 : : * Create a dummy set of directories and a pipe that gssd can hold open to
1293 : : * indicate that it is up and running.
1294 : : */
1295 : : static struct dentry *
1296 : 3 : rpc_gssd_dummy_populate(struct dentry *root, struct rpc_pipe *pipe_data)
1297 : : {
1298 : : int ret = 0;
1299 : : struct dentry *gssd_dentry;
1300 : : struct dentry *clnt_dentry = NULL;
1301 : : struct dentry *pipe_dentry = NULL;
1302 : 3 : struct qstr q = QSTR_INIT(files[RPCAUTH_gssd].name,
1303 : : strlen(files[RPCAUTH_gssd].name));
1304 : :
1305 : : /* We should never get this far if "gssd" doesn't exist */
1306 : 3 : gssd_dentry = d_hash_and_lookup(root, &q);
1307 : 3 : if (!gssd_dentry)
1308 : : return ERR_PTR(-ENOENT);
1309 : :
1310 : 3 : ret = rpc_populate(gssd_dentry, gssd_dummy_clnt_dir, 0, 1, NULL);
1311 : 3 : if (ret) {
1312 : : pipe_dentry = ERR_PTR(ret);
1313 : 0 : goto out;
1314 : : }
1315 : :
1316 : 3 : q.name = gssd_dummy_clnt_dir[0].name;
1317 : 3 : q.len = strlen(gssd_dummy_clnt_dir[0].name);
1318 : 3 : clnt_dentry = d_hash_and_lookup(gssd_dentry, &q);
1319 : 3 : if (!clnt_dentry) {
1320 : 0 : __rpc_depopulate(gssd_dentry, gssd_dummy_clnt_dir, 0, 1);
1321 : : pipe_dentry = ERR_PTR(-ENOENT);
1322 : 0 : goto out;
1323 : : }
1324 : :
1325 : 3 : ret = rpc_populate(clnt_dentry, gssd_dummy_info_file, 0, 1, NULL);
1326 : 3 : if (ret) {
1327 : 0 : __rpc_depopulate(gssd_dentry, gssd_dummy_clnt_dir, 0, 1);
1328 : : pipe_dentry = ERR_PTR(ret);
1329 : 0 : goto out;
1330 : : }
1331 : :
1332 : 3 : pipe_dentry = rpc_mkpipe_dentry(clnt_dentry, "gssd", NULL, pipe_data);
1333 : 3 : if (IS_ERR(pipe_dentry)) {
1334 : 0 : __rpc_depopulate(clnt_dentry, gssd_dummy_info_file, 0, 1);
1335 : 0 : __rpc_depopulate(gssd_dentry, gssd_dummy_clnt_dir, 0, 1);
1336 : : }
1337 : : out:
1338 : 3 : dput(clnt_dentry);
1339 : 3 : dput(gssd_dentry);
1340 : 3 : return pipe_dentry;
1341 : : }
1342 : :
1343 : : static void
1344 : 0 : rpc_gssd_dummy_depopulate(struct dentry *pipe_dentry)
1345 : : {
1346 : 0 : struct dentry *clnt_dir = pipe_dentry->d_parent;
1347 : 0 : struct dentry *gssd_dir = clnt_dir->d_parent;
1348 : :
1349 : : dget(pipe_dentry);
1350 : 0 : __rpc_rmpipe(d_inode(clnt_dir), pipe_dentry);
1351 : 0 : __rpc_depopulate(clnt_dir, gssd_dummy_info_file, 0, 1);
1352 : 0 : __rpc_depopulate(gssd_dir, gssd_dummy_clnt_dir, 0, 1);
1353 : 0 : dput(pipe_dentry);
1354 : 0 : }
1355 : :
1356 : : static int
1357 : 3 : rpc_fill_super(struct super_block *sb, struct fs_context *fc)
1358 : : {
1359 : : struct inode *inode;
1360 : : struct dentry *root, *gssd_dentry;
1361 : 3 : struct net *net = sb->s_fs_info;
1362 : 3 : struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1363 : : int err;
1364 : :
1365 : 3 : sb->s_blocksize = PAGE_SIZE;
1366 : 3 : sb->s_blocksize_bits = PAGE_SHIFT;
1367 : 3 : sb->s_magic = RPCAUTH_GSSMAGIC;
1368 : 3 : sb->s_op = &s_ops;
1369 : 3 : sb->s_d_op = &simple_dentry_operations;
1370 : 3 : sb->s_time_gran = 1;
1371 : :
1372 : 3 : inode = rpc_get_inode(sb, S_IFDIR | 0555);
1373 : 3 : sb->s_root = root = d_make_root(inode);
1374 : 3 : if (!root)
1375 : : return -ENOMEM;
1376 : 3 : if (rpc_populate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF, NULL))
1377 : : return -ENOMEM;
1378 : :
1379 : 3 : gssd_dentry = rpc_gssd_dummy_populate(root, sn->gssd_dummy);
1380 : 3 : if (IS_ERR(gssd_dentry)) {
1381 : 0 : __rpc_depopulate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF);
1382 : 0 : return PTR_ERR(gssd_dentry);
1383 : : }
1384 : :
1385 : : dprintk("RPC: sending pipefs MOUNT notification for net %x%s\n",
1386 : : net->ns.inum, NET_NAME(net));
1387 : 3 : mutex_lock(&sn->pipefs_sb_lock);
1388 : 3 : sn->pipefs_sb = sb;
1389 : 3 : err = blocking_notifier_call_chain(&rpc_pipefs_notifier_list,
1390 : : RPC_PIPEFS_MOUNT,
1391 : : sb);
1392 : 3 : if (err)
1393 : : goto err_depopulate;
1394 : 3 : mutex_unlock(&sn->pipefs_sb_lock);
1395 : 3 : return 0;
1396 : :
1397 : : err_depopulate:
1398 : 0 : rpc_gssd_dummy_depopulate(gssd_dentry);
1399 : 0 : blocking_notifier_call_chain(&rpc_pipefs_notifier_list,
1400 : : RPC_PIPEFS_UMOUNT,
1401 : : sb);
1402 : 0 : sn->pipefs_sb = NULL;
1403 : 0 : __rpc_depopulate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF);
1404 : 0 : mutex_unlock(&sn->pipefs_sb_lock);
1405 : 0 : return err;
1406 : : }
1407 : :
1408 : : bool
1409 : 0 : gssd_running(struct net *net)
1410 : : {
1411 : 0 : struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1412 : 0 : struct rpc_pipe *pipe = sn->gssd_dummy;
1413 : :
1414 : 0 : return pipe->nreaders || pipe->nwriters;
1415 : : }
1416 : : EXPORT_SYMBOL_GPL(gssd_running);
1417 : :
1418 : 3 : static int rpc_fs_get_tree(struct fs_context *fc)
1419 : : {
1420 : 3 : return get_tree_keyed(fc, rpc_fill_super, get_net(fc->net_ns));
1421 : : }
1422 : :
1423 : 3 : static void rpc_fs_free_fc(struct fs_context *fc)
1424 : : {
1425 : 3 : if (fc->s_fs_info)
1426 : 0 : put_net(fc->s_fs_info);
1427 : 3 : }
1428 : :
1429 : : static const struct fs_context_operations rpc_fs_context_ops = {
1430 : : .free = rpc_fs_free_fc,
1431 : : .get_tree = rpc_fs_get_tree,
1432 : : };
1433 : :
1434 : 3 : static int rpc_init_fs_context(struct fs_context *fc)
1435 : : {
1436 : 3 : put_user_ns(fc->user_ns);
1437 : 3 : fc->user_ns = get_user_ns(fc->net_ns->user_ns);
1438 : 3 : fc->ops = &rpc_fs_context_ops;
1439 : 3 : return 0;
1440 : : }
1441 : :
1442 : 0 : static void rpc_kill_sb(struct super_block *sb)
1443 : : {
1444 : 0 : struct net *net = sb->s_fs_info;
1445 : 0 : struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1446 : :
1447 : 0 : mutex_lock(&sn->pipefs_sb_lock);
1448 : 0 : if (sn->pipefs_sb != sb) {
1449 : 0 : mutex_unlock(&sn->pipefs_sb_lock);
1450 : 0 : goto out;
1451 : : }
1452 : 0 : sn->pipefs_sb = NULL;
1453 : : dprintk("RPC: sending pipefs UMOUNT notification for net %x%s\n",
1454 : : net->ns.inum, NET_NAME(net));
1455 : 0 : blocking_notifier_call_chain(&rpc_pipefs_notifier_list,
1456 : : RPC_PIPEFS_UMOUNT,
1457 : : sb);
1458 : 0 : mutex_unlock(&sn->pipefs_sb_lock);
1459 : : out:
1460 : 0 : kill_litter_super(sb);
1461 : 0 : put_net(net);
1462 : 0 : }
1463 : :
1464 : : static struct file_system_type rpc_pipe_fs_type = {
1465 : : .owner = THIS_MODULE,
1466 : : .name = "rpc_pipefs",
1467 : : .init_fs_context = rpc_init_fs_context,
1468 : : .kill_sb = rpc_kill_sb,
1469 : : };
1470 : : MODULE_ALIAS_FS("rpc_pipefs");
1471 : : MODULE_ALIAS("rpc_pipefs");
1472 : :
1473 : : static void
1474 : 3 : init_once(void *foo)
1475 : : {
1476 : : struct rpc_inode *rpci = (struct rpc_inode *) foo;
1477 : :
1478 : 3 : inode_init_once(&rpci->vfs_inode);
1479 : 3 : rpci->private = NULL;
1480 : 3 : rpci->pipe = NULL;
1481 : 3 : init_waitqueue_head(&rpci->waitq);
1482 : 3 : }
1483 : :
1484 : 3 : int register_rpc_pipefs(void)
1485 : : {
1486 : : int err;
1487 : :
1488 : 3 : rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
1489 : : sizeof(struct rpc_inode),
1490 : : 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
1491 : : SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1492 : : init_once);
1493 : 3 : if (!rpc_inode_cachep)
1494 : : return -ENOMEM;
1495 : 3 : err = rpc_clients_notifier_register();
1496 : 3 : if (err)
1497 : : goto err_notifier;
1498 : 3 : err = register_filesystem(&rpc_pipe_fs_type);
1499 : 3 : if (err)
1500 : : goto err_register;
1501 : : return 0;
1502 : :
1503 : : err_register:
1504 : 0 : rpc_clients_notifier_unregister();
1505 : : err_notifier:
1506 : 0 : kmem_cache_destroy(rpc_inode_cachep);
1507 : 0 : return err;
1508 : : }
1509 : :
1510 : 0 : void unregister_rpc_pipefs(void)
1511 : : {
1512 : 0 : rpc_clients_notifier_unregister();
1513 : 0 : kmem_cache_destroy(rpc_inode_cachep);
1514 : 0 : unregister_filesystem(&rpc_pipe_fs_type);
1515 : 0 : }
|
