1 /* /proc interface for AFS
2 *
3 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 */
11
12 #include <linux/slab.h>
13 #include <linux/module.h>
14 #include <linux/proc_fs.h>
15 #include <linux/seq_file.h>
16 #include <linux/sched.h>
17 #include <linux/uaccess.h>
18 #include "internal.h"
19
20 static inline struct afs_net *afs_proc2net(struct file *f)
21 {
22 return &__afs_net;
23 }
24
25 static inline struct afs_net *afs_seq2net(struct seq_file *m)
26 {
27 return &__afs_net; // TODO: use seq_file_net(m)
28 }
29
30 static int afs_proc_cells_open(struct inode *inode, struct file *file);
31 static void *afs_proc_cells_start(struct seq_file *p, loff_t *pos);
32 static void *afs_proc_cells_next(struct seq_file *p, void *v, loff_t *pos);
33 static void afs_proc_cells_stop(struct seq_file *p, void *v);
34 static int afs_proc_cells_show(struct seq_file *m, void *v);
35 static ssize_t afs_proc_cells_write(struct file *file, const char __user *buf,
36 size_t size, loff_t *_pos);
37
38 static const struct seq_operations afs_proc_cells_ops = {
39 .start = afs_proc_cells_start,
40 .next = afs_proc_cells_next,
41 .stop = afs_proc_cells_stop,
42 .show = afs_proc_cells_show,
43 };
44
45 static const struct file_operations afs_proc_cells_fops = {
46 .open = afs_proc_cells_open,
47 .read = seq_read,
48 .write = afs_proc_cells_write,
49 .llseek = seq_lseek,
50 .release = seq_release,
51 };
52
53 static ssize_t afs_proc_rootcell_read(struct file *file, char __user *buf,
54 size_t size, loff_t *_pos);
55 static ssize_t afs_proc_rootcell_write(struct file *file,
56 const char __user *buf,
57 size_t size, loff_t *_pos);
58
59 static const struct file_operations afs_proc_rootcell_fops = {
60 .read = afs_proc_rootcell_read,
61 .write = afs_proc_rootcell_write,
62 .llseek = no_llseek,
63 };
64
65 static int afs_proc_cell_volumes_open(struct inode *inode, struct file *file);
66 static void *afs_proc_cell_volumes_start(struct seq_file *p, loff_t *pos);
67 static void *afs_proc_cell_volumes_next(struct seq_file *p, void *v,
68 loff_t *pos);
69 static void afs_proc_cell_volumes_stop(struct seq_file *p, void *v);
70 static int afs_proc_cell_volumes_show(struct seq_file *m, void *v);
71
72 static const struct seq_operations afs_proc_cell_volumes_ops = {
73 .start = afs_proc_cell_volumes_start,
74 .next = afs_proc_cell_volumes_next,
75 .stop = afs_proc_cell_volumes_stop,
76 .show = afs_proc_cell_volumes_show,
77 };
78
79 static const struct file_operations afs_proc_cell_volumes_fops = {
80 .open = afs_proc_cell_volumes_open,
81 .read = seq_read,
82 .llseek = seq_lseek,
83 .release = seq_release,
84 };
85
86 static int afs_proc_cell_vlservers_open(struct inode *inode,
87 struct file *file);
88 static void *afs_proc_cell_vlservers_start(struct seq_file *p, loff_t *pos);
89 static void *afs_proc_cell_vlservers_next(struct seq_file *p, void *v,
90 loff_t *pos);
91 static void afs_proc_cell_vlservers_stop(struct seq_file *p, void *v);
92 static int afs_proc_cell_vlservers_show(struct seq_file *m, void *v);
93
94 static const struct seq_operations afs_proc_cell_vlservers_ops = {
95 .start = afs_proc_cell_vlservers_start,
96 .next = afs_proc_cell_vlservers_next,
97 .stop = afs_proc_cell_vlservers_stop,
98 .show = afs_proc_cell_vlservers_show,
99 };
100
101 static const struct file_operations afs_proc_cell_vlservers_fops = {
102 .open = afs_proc_cell_vlservers_open,
103 .read = seq_read,
104 .llseek = seq_lseek,
105 .release = seq_release,
106 };
107
108 static int afs_proc_servers_open(struct inode *inode, struct file *file);
109 static void *afs_proc_servers_start(struct seq_file *p, loff_t *pos);
110 static void *afs_proc_servers_next(struct seq_file *p, void *v,
111 loff_t *pos);
112 static void afs_proc_servers_stop(struct seq_file *p, void *v);
113 static int afs_proc_servers_show(struct seq_file *m, void *v);
114
115 static const struct seq_operations afs_proc_servers_ops = {
116 .start = afs_proc_servers_start,
117 .next = afs_proc_servers_next,
118 .stop = afs_proc_servers_stop,
119 .show = afs_proc_servers_show,
120 };
121
122 static const struct file_operations afs_proc_servers_fops = {
123 .open = afs_proc_servers_open,
124 .read = seq_read,
125 .llseek = seq_lseek,
126 .release = seq_release,
127 };
128
129 /*
130 * initialise the /proc/fs/afs/ directory
131 */
132 int afs_proc_init(struct afs_net *net)
133 {
134 _enter("");
135
136 net->proc_afs = proc_mkdir("fs/afs", NULL);
137 if (!net->proc_afs)
138 goto error_dir;
139
140 if (!proc_create("cells", 0644, net->proc_afs, &afs_proc_cells_fops) ||
141 !proc_create("rootcell", 0644, net->proc_afs, &afs_proc_rootcell_fops) ||
142 !proc_create("servers", 0644, net->proc_afs, &afs_proc_servers_fops))
143 goto error_tree;
144
145 _leave(" = 0");
146 return 0;
147
148 error_tree:
149 proc_remove(net->proc_afs);
150 error_dir:
151 _leave(" = -ENOMEM");
152 return -ENOMEM;
153 }
154
155 /*
156 * clean up the /proc/fs/afs/ directory
157 */
158 void afs_proc_cleanup(struct afs_net *net)
159 {
160 proc_remove(net->proc_afs);
161 net->proc_afs = NULL;
162 }
163
164 /*
165 * open "/proc/fs/afs/cells" which provides a summary of extant cells
166 */
167 static int afs_proc_cells_open(struct inode *inode, struct file *file)
168 {
169 struct seq_file *m;
170 int ret;
171
172 ret = seq_open(file, &afs_proc_cells_ops);
173 if (ret < 0)
174 return ret;
175
176 m = file->private_data;
177 m->private = PDE_DATA(inode);
178 return 0;
179 }
180
181 /*
182 * set up the iterator to start reading from the cells list and return the
183 * first item
184 */
185 static void *afs_proc_cells_start(struct seq_file *m, loff_t *_pos)
186 {
187 struct afs_net *net = afs_seq2net(m);
188
189 rcu_read_lock();
190 return seq_list_start_head(&net->proc_cells, *_pos);
191 }
192
193 /*
194 * move to next cell in cells list
195 */
196 static void *afs_proc_cells_next(struct seq_file *m, void *v, loff_t *pos)
197 {
198 struct afs_net *net = afs_seq2net(m);
199
200 return seq_list_next(v, &net->proc_cells, pos);
201 }
202
203 /*
204 * clean up after reading from the cells list
205 */
206 static void afs_proc_cells_stop(struct seq_file *m, void *v)
207 {
208 rcu_read_unlock();
209 }
210
211 /*
212 * display a header line followed by a load of cell lines
213 */
214 static int afs_proc_cells_show(struct seq_file *m, void *v)
215 {
216 struct afs_cell *cell = list_entry(v, struct afs_cell, proc_link);
217 struct afs_net *net = afs_seq2net(m);
218
219 if (v == &net->proc_cells) {
220 /* display header on line 1 */
221 seq_puts(m, "USE NAME\n");
222 return 0;
223 }
224
225 /* display one cell per line on subsequent lines */
226 seq_printf(m, "%3u %s\n", atomic_read(&cell->usage), cell->name);
227 return 0;
228 }
229
230 /*
231 * handle writes to /proc/fs/afs/cells
232 * - to add cells: echo "add <cellname> <IP>[:<IP>][:<IP>]"
233 */
234 static ssize_t afs_proc_cells_write(struct file *file, const char __user *buf,
235 size_t size, loff_t *_pos)
236 {
237 struct afs_net *net = afs_proc2net(file);
238 char *kbuf, *name, *args;
239 int ret;
240
241 /* start by dragging the command into memory */
242 if (size <= 1 || size >= PAGE_SIZE)
243 return -EINVAL;
244
245 kbuf = memdup_user_nul(buf, size);
246 if (IS_ERR(kbuf))
247 return PTR_ERR(kbuf);
248
249 /* trim to first NL */
250 name = memchr(kbuf, '\n', size);
251 if (name)
252 *name = 0;
253
254 /* split into command, name and argslist */
255 name = strchr(kbuf, ' ');
256 if (!name)
257 goto inval;
258 do {
259 *name++ = 0;
260 } while(*name == ' ');
261 if (!*name)
262 goto inval;
263
264 args = strchr(name, ' ');
265 if (!args)
266 goto inval;
267 do {
268 *args++ = 0;
269 } while(*args == ' ');
270 if (!*args)
271 goto inval;
272
273 /* determine command to perform */
274 _debug("cmd=%s name=%s args=%s", kbuf, name, args);
275
276 if (strcmp(kbuf, "add") == 0) {
277 struct afs_cell *cell;
278
279 cell = afs_lookup_cell(net, name, strlen(name), args, true);
280 if (IS_ERR(cell)) {
281 ret = PTR_ERR(cell);
282 goto done;
283 }
284
285 set_bit(AFS_CELL_FL_NO_GC, &cell->flags);
286 printk("kAFS: Added new cell '%s'\n", name);
287 } else {
288 goto inval;
289 }
290
291 ret = size;
292
293 done:
294 kfree(kbuf);
295 _leave(" = %d", ret);
296 return ret;
297
298 inval:
299 ret = -EINVAL;
300 printk("kAFS: Invalid Command on /proc/fs/afs/cells file\n");
301 goto done;
302 }
303
304 static ssize_t afs_proc_rootcell_read(struct file *file, char __user *buf,
305 size_t size, loff_t *_pos)
306 {
307 return 0;
308 }
309
310 /*
311 * handle writes to /proc/fs/afs/rootcell
312 * - to initialize rootcell: echo "cell.name:192.168.231.14"
313 */
314 static ssize_t afs_proc_rootcell_write(struct file *file,
315 const char __user *buf,
316 size_t size, loff_t *_pos)
317 {
318 struct afs_net *net = afs_proc2net(file);
319 char *kbuf, *s;
320 int ret;
321
322 /* start by dragging the command into memory */
323 if (size <= 1 || size >= PAGE_SIZE)
324 return -EINVAL;
325
326 kbuf = memdup_user_nul(buf, size);
327 if (IS_ERR(kbuf))
328 return PTR_ERR(kbuf);
329
330 /* trim to first NL */
331 s = memchr(kbuf, '\n', size);
332 if (s)
333 *s = 0;
334
335 /* determine command to perform */
336 _debug("rootcell=%s", kbuf);
337
338 ret = afs_cell_init(net, kbuf);
339 if (ret >= 0)
340 ret = size; /* consume everything, always */
341
342 kfree(kbuf);
343 _leave(" = %d", ret);
344 return ret;
345 }
346
347 /*
348 * initialise /proc/fs/afs/<cell>/
349 */
350 int afs_proc_cell_setup(struct afs_net *net, struct afs_cell *cell)
351 {
352 struct proc_dir_entry *dir;
353
354 _enter("%p{%s},%p", cell, cell->name, net->proc_afs);
355
356 dir = proc_mkdir(cell->name, net->proc_afs);
357 if (!dir)
358 goto error_dir;
359
360 if (!proc_create_data("vlservers", 0, dir,
361 &afs_proc_cell_vlservers_fops, cell) ||
362 !proc_create_data("volumes", 0, dir,
363 &afs_proc_cell_volumes_fops, cell))
364 goto error_tree;
365
366 _leave(" = 0");
367 return 0;
368
369 error_tree:
370 remove_proc_subtree(cell->name, net->proc_afs);
371 error_dir:
372 _leave(" = -ENOMEM");
373 return -ENOMEM;
374 }
375
376 /*
377 * remove /proc/fs/afs/<cell>/
378 */
379 void afs_proc_cell_remove(struct afs_net *net, struct afs_cell *cell)
380 {
381 _enter("");
382
383 remove_proc_subtree(cell->name, net->proc_afs);
384
385 _leave("");
386 }
387
388 /*
389 * open "/proc/fs/afs/<cell>/volumes" which provides a summary of extant cells
390 */
391 static int afs_proc_cell_volumes_open(struct inode *inode, struct file *file)
392 {
393 struct afs_cell *cell;
394 struct seq_file *m;
395 int ret;
396
397 cell = PDE_DATA(inode);
398 if (!cell)
399 return -ENOENT;
400
401 ret = seq_open(file, &afs_proc_cell_volumes_ops);
402 if (ret < 0)
403 return ret;
404
405 m = file->private_data;
406 m->private = cell;
407
408 return 0;
409 }
410
411 /*
412 * set up the iterator to start reading from the cells list and return the
413 * first item
414 */
415 static void *afs_proc_cell_volumes_start(struct seq_file *m, loff_t *_pos)
416 {
417 struct afs_cell *cell = m->private;
418
419 _enter("cell=%p pos=%Ld", cell, *_pos);
420
421 read_lock(&cell->proc_lock);
422 return seq_list_start_head(&cell->proc_volumes, *_pos);
423 }
424
425 /*
426 * move to next cell in cells list
427 */
428 static void *afs_proc_cell_volumes_next(struct seq_file *p, void *v,
429 loff_t *_pos)
430 {
431 struct afs_cell *cell = p->private;
432
433 _enter("cell=%p pos=%Ld", cell, *_pos);
434 return seq_list_next(v, &cell->proc_volumes, _pos);
435 }
436
437 /*
438 * clean up after reading from the cells list
439 */
440 static void afs_proc_cell_volumes_stop(struct seq_file *p, void *v)
441 {
442 struct afs_cell *cell = p->private;
443
444 read_unlock(&cell->proc_lock);
445 }
446
447 static const char afs_vol_types[3][3] = {
448 [AFSVL_RWVOL] = "RW",
449 [AFSVL_ROVOL] = "RO",
450 [AFSVL_BACKVOL] = "BK",
451 };
452
453 /*
454 * display a header line followed by a load of volume lines
455 */
456 static int afs_proc_cell_volumes_show(struct seq_file *m, void *v)
457 {
458 struct afs_cell *cell = m->private;
459 struct afs_volume *vol = list_entry(v, struct afs_volume, proc_link);
460
461 /* Display header on line 1 */
462 if (v == &cell->proc_volumes) {
463 seq_puts(m, "USE VID TY\n");
464 return 0;
465 }
466
467 seq_printf(m, "%3d %08x %s\n",
468 atomic_read(&vol->usage), vol->vid,
469 afs_vol_types[vol->type]);
470
471 return 0;
472 }
473
474 /*
475 * open "/proc/fs/afs/<cell>/vlservers" which provides a list of volume
476 * location server
477 */
478 static int afs_proc_cell_vlservers_open(struct inode *inode, struct file *file)
479 {
480 struct afs_cell *cell;
481 struct seq_file *m;
482 int ret;
483
484 cell = PDE_DATA(inode);
485 if (!cell)
486 return -ENOENT;
487
488 ret = seq_open(file, &afs_proc_cell_vlservers_ops);
489 if (ret<0)
490 return ret;
491
492 m = file->private_data;
493 m->private = cell;
494
495 return 0;
496 }
497
498 /*
499 * set up the iterator to start reading from the cells list and return the
500 * first item
501 */
502 static void *afs_proc_cell_vlservers_start(struct seq_file *m, loff_t *_pos)
503 {
504 struct afs_addr_list *alist;
505 struct afs_cell *cell = m->private;
506 loff_t pos = *_pos;
507
508 rcu_read_lock();
509
510 alist = rcu_dereference(cell->vl_addrs);
511
512 /* allow for the header line */
513 if (!pos)
514 return (void *) 1;
515 pos--;
516
517 if (!alist || pos >= alist->nr_addrs)
518 return NULL;
519
520 return alist->addrs + pos;
521 }
522
523 /*
524 * move to next cell in cells list
525 */
526 static void *afs_proc_cell_vlservers_next(struct seq_file *p, void *v,
527 loff_t *_pos)
528 {
529 struct afs_addr_list *alist;
530 struct afs_cell *cell = p->private;
531 loff_t pos;
532
533 alist = rcu_dereference(cell->vl_addrs);
534
535 pos = *_pos;
536 (*_pos)++;
537 if (!alist || pos >= alist->nr_addrs)
538 return NULL;
539
540 return alist->addrs + pos;
541 }
542
543 /*
544 * clean up after reading from the cells list
545 */
546 static void afs_proc_cell_vlservers_stop(struct seq_file *p, void *v)
547 {
548 rcu_read_unlock();
549 }
550
551 /*
552 * display a header line followed by a load of volume lines
553 */
554 static int afs_proc_cell_vlservers_show(struct seq_file *m, void *v)
555 {
556 struct sockaddr_rxrpc *addr = v;
557
558 /* display header on line 1 */
559 if (v == (void *)1) {
560 seq_puts(m, "ADDRESS\n");
561 return 0;
562 }
563
564 /* display one cell per line on subsequent lines */
565 seq_printf(m, "%pISp\n", &addr->transport);
566 return 0;
567 }
568
569 /*
570 * open "/proc/fs/afs/servers" which provides a summary of active
571 * servers
572 */
573 static int afs_proc_servers_open(struct inode *inode, struct file *file)
574 {
575 return seq_open(file, &afs_proc_servers_ops);
576 }
577
578 /*
579 * Set up the iterator to start reading from the server list and return the
580 * first item.
581 */
582 static void *afs_proc_servers_start(struct seq_file *m, loff_t *_pos)
583 {
584 struct afs_net *net = afs_seq2net(m);
585
586 rcu_read_lock();
587 return seq_hlist_start_head_rcu(&net->fs_proc, *_pos);
588 }
589
590 /*
591 * move to next cell in cells list
592 */
593 static void *afs_proc_servers_next(struct seq_file *m, void *v, loff_t *_pos)
594 {
595 struct afs_net *net = afs_seq2net(m);
596
597 return seq_hlist_next_rcu(v, &net->fs_proc, _pos);
598 }
599
600 /*
601 * clean up after reading from the cells list
602 */
603 static void afs_proc_servers_stop(struct seq_file *p, void *v)
604 {
605 rcu_read_unlock();
606 }
607
608 /*
609 * display a header line followed by a load of volume lines
610 */
611 static int afs_proc_servers_show(struct seq_file *m, void *v)
612 {
613 struct afs_server *server;
614 struct afs_addr_list *alist;
615
616 if (v == SEQ_START_TOKEN) {
617 seq_puts(m, "UUID USE ADDR\n");
618 return 0;
619 }
620
621 server = list_entry(v, struct afs_server, proc_link);
622 alist = rcu_dereference(server->addresses);
623 seq_printf(m, "%pU %3d %pISp\n",
624 &server->uuid,
625 atomic_read(&server->usage),
626 &alist->addrs[alist->index].transport);
627 return 0;
628 }
629
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.