Linux 2.6.26-rc5
[linux-2.6/openmoko-kernel/knife-kernel.git] / fs / afs / proc.c
blob9f7d1ae70269ac9de86404e5b6eb36b6a4d34f29
1 /* /proc interface for AFS
3 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
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.
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 <asm/uaccess.h>
18 #include "internal.h"
20 static struct proc_dir_entry *proc_afs;
23 static int afs_proc_cells_open(struct inode *inode, struct file *file);
24 static void *afs_proc_cells_start(struct seq_file *p, loff_t *pos);
25 static void *afs_proc_cells_next(struct seq_file *p, void *v, loff_t *pos);
26 static void afs_proc_cells_stop(struct seq_file *p, void *v);
27 static int afs_proc_cells_show(struct seq_file *m, void *v);
28 static ssize_t afs_proc_cells_write(struct file *file, const char __user *buf,
29 size_t size, loff_t *_pos);
31 static struct seq_operations afs_proc_cells_ops = {
32 .start = afs_proc_cells_start,
33 .next = afs_proc_cells_next,
34 .stop = afs_proc_cells_stop,
35 .show = afs_proc_cells_show,
38 static const struct file_operations afs_proc_cells_fops = {
39 .open = afs_proc_cells_open,
40 .read = seq_read,
41 .write = afs_proc_cells_write,
42 .llseek = seq_lseek,
43 .release = seq_release,
44 .owner = THIS_MODULE,
47 static int afs_proc_rootcell_open(struct inode *inode, struct file *file);
48 static int afs_proc_rootcell_release(struct inode *inode, struct file *file);
49 static ssize_t afs_proc_rootcell_read(struct file *file, char __user *buf,
50 size_t size, loff_t *_pos);
51 static ssize_t afs_proc_rootcell_write(struct file *file,
52 const char __user *buf,
53 size_t size, loff_t *_pos);
55 static const struct file_operations afs_proc_rootcell_fops = {
56 .open = afs_proc_rootcell_open,
57 .read = afs_proc_rootcell_read,
58 .write = afs_proc_rootcell_write,
59 .llseek = no_llseek,
60 .release = afs_proc_rootcell_release,
61 .owner = THIS_MODULE,
64 static int afs_proc_cell_volumes_open(struct inode *inode, struct file *file);
65 static int afs_proc_cell_volumes_release(struct inode *inode,
66 struct file *file);
67 static void *afs_proc_cell_volumes_start(struct seq_file *p, loff_t *pos);
68 static void *afs_proc_cell_volumes_next(struct seq_file *p, void *v,
69 loff_t *pos);
70 static void afs_proc_cell_volumes_stop(struct seq_file *p, void *v);
71 static int afs_proc_cell_volumes_show(struct seq_file *m, void *v);
73 static struct seq_operations afs_proc_cell_volumes_ops = {
74 .start = afs_proc_cell_volumes_start,
75 .next = afs_proc_cell_volumes_next,
76 .stop = afs_proc_cell_volumes_stop,
77 .show = afs_proc_cell_volumes_show,
80 static const struct file_operations afs_proc_cell_volumes_fops = {
81 .open = afs_proc_cell_volumes_open,
82 .read = seq_read,
83 .llseek = seq_lseek,
84 .release = afs_proc_cell_volumes_release,
85 .owner = THIS_MODULE,
88 static int afs_proc_cell_vlservers_open(struct inode *inode,
89 struct file *file);
90 static int afs_proc_cell_vlservers_release(struct inode *inode,
91 struct file *file);
92 static void *afs_proc_cell_vlservers_start(struct seq_file *p, loff_t *pos);
93 static void *afs_proc_cell_vlservers_next(struct seq_file *p, void *v,
94 loff_t *pos);
95 static void afs_proc_cell_vlservers_stop(struct seq_file *p, void *v);
96 static int afs_proc_cell_vlservers_show(struct seq_file *m, void *v);
98 static struct seq_operations afs_proc_cell_vlservers_ops = {
99 .start = afs_proc_cell_vlservers_start,
100 .next = afs_proc_cell_vlservers_next,
101 .stop = afs_proc_cell_vlservers_stop,
102 .show = afs_proc_cell_vlservers_show,
105 static const struct file_operations afs_proc_cell_vlservers_fops = {
106 .open = afs_proc_cell_vlservers_open,
107 .read = seq_read,
108 .llseek = seq_lseek,
109 .release = afs_proc_cell_vlservers_release,
110 .owner = THIS_MODULE,
113 static int afs_proc_cell_servers_open(struct inode *inode, struct file *file);
114 static int afs_proc_cell_servers_release(struct inode *inode,
115 struct file *file);
116 static void *afs_proc_cell_servers_start(struct seq_file *p, loff_t *pos);
117 static void *afs_proc_cell_servers_next(struct seq_file *p, void *v,
118 loff_t *pos);
119 static void afs_proc_cell_servers_stop(struct seq_file *p, void *v);
120 static int afs_proc_cell_servers_show(struct seq_file *m, void *v);
122 static struct seq_operations afs_proc_cell_servers_ops = {
123 .start = afs_proc_cell_servers_start,
124 .next = afs_proc_cell_servers_next,
125 .stop = afs_proc_cell_servers_stop,
126 .show = afs_proc_cell_servers_show,
129 static const struct file_operations afs_proc_cell_servers_fops = {
130 .open = afs_proc_cell_servers_open,
131 .read = seq_read,
132 .llseek = seq_lseek,
133 .release = afs_proc_cell_servers_release,
134 .owner = THIS_MODULE,
138 * initialise the /proc/fs/afs/ directory
140 int afs_proc_init(void)
142 struct proc_dir_entry *p;
144 _enter("");
146 proc_afs = proc_mkdir("fs/afs", NULL);
147 if (!proc_afs)
148 goto error_dir;
149 proc_afs->owner = THIS_MODULE;
151 p = proc_create("cells", 0, proc_afs, &afs_proc_cells_fops);
152 if (!p)
153 goto error_cells;
155 p = proc_create("rootcell", 0, proc_afs, &afs_proc_rootcell_fops);
156 if (!p)
157 goto error_rootcell;
159 _leave(" = 0");
160 return 0;
162 error_rootcell:
163 remove_proc_entry("cells", proc_afs);
164 error_cells:
165 remove_proc_entry("fs/afs", NULL);
166 error_dir:
167 _leave(" = -ENOMEM");
168 return -ENOMEM;
172 * clean up the /proc/fs/afs/ directory
174 void afs_proc_cleanup(void)
176 remove_proc_entry("rootcell", proc_afs);
177 remove_proc_entry("cells", proc_afs);
178 remove_proc_entry("fs/afs", NULL);
182 * open "/proc/fs/afs/cells" which provides a summary of extant cells
184 static int afs_proc_cells_open(struct inode *inode, struct file *file)
186 struct seq_file *m;
187 int ret;
189 ret = seq_open(file, &afs_proc_cells_ops);
190 if (ret < 0)
191 return ret;
193 m = file->private_data;
194 m->private = PDE(inode)->data;
196 return 0;
200 * set up the iterator to start reading from the cells list and return the
201 * first item
203 static void *afs_proc_cells_start(struct seq_file *m, loff_t *_pos)
205 /* lock the list against modification */
206 down_read(&afs_proc_cells_sem);
207 return seq_list_start_head(&afs_proc_cells, *_pos);
211 * move to next cell in cells list
213 static void *afs_proc_cells_next(struct seq_file *p, void *v, loff_t *pos)
215 return seq_list_next(v, &afs_proc_cells, pos);
219 * clean up after reading from the cells list
221 static void afs_proc_cells_stop(struct seq_file *p, void *v)
223 up_read(&afs_proc_cells_sem);
227 * display a header line followed by a load of cell lines
229 static int afs_proc_cells_show(struct seq_file *m, void *v)
231 struct afs_cell *cell = list_entry(v, struct afs_cell, proc_link);
233 if (v == &afs_proc_cells) {
234 /* display header on line 1 */
235 seq_puts(m, "USE NAME\n");
236 return 0;
239 /* display one cell per line on subsequent lines */
240 seq_printf(m, "%3d %s\n",
241 atomic_read(&cell->usage), cell->name);
242 return 0;
246 * handle writes to /proc/fs/afs/cells
247 * - to add cells: echo "add <cellname> <IP>[:<IP>][:<IP>]"
249 static ssize_t afs_proc_cells_write(struct file *file, const char __user *buf,
250 size_t size, loff_t *_pos)
252 char *kbuf, *name, *args;
253 int ret;
255 /* start by dragging the command into memory */
256 if (size <= 1 || size >= PAGE_SIZE)
257 return -EINVAL;
259 kbuf = kmalloc(size + 1, GFP_KERNEL);
260 if (!kbuf)
261 return -ENOMEM;
263 ret = -EFAULT;
264 if (copy_from_user(kbuf, buf, size) != 0)
265 goto done;
266 kbuf[size] = 0;
268 /* trim to first NL */
269 name = memchr(kbuf, '\n', size);
270 if (name)
271 *name = 0;
273 /* split into command, name and argslist */
274 name = strchr(kbuf, ' ');
275 if (!name)
276 goto inval;
277 do {
278 *name++ = 0;
279 } while(*name == ' ');
280 if (!*name)
281 goto inval;
283 args = strchr(name, ' ');
284 if (!args)
285 goto inval;
286 do {
287 *args++ = 0;
288 } while(*args == ' ');
289 if (!*args)
290 goto inval;
292 /* determine command to perform */
293 _debug("cmd=%s name=%s args=%s", kbuf, name, args);
295 if (strcmp(kbuf, "add") == 0) {
296 struct afs_cell *cell;
298 cell = afs_cell_create(name, args);
299 if (IS_ERR(cell)) {
300 ret = PTR_ERR(cell);
301 goto done;
304 afs_put_cell(cell);
305 printk("kAFS: Added new cell '%s'\n", name);
306 } else {
307 goto inval;
310 ret = size;
312 done:
313 kfree(kbuf);
314 _leave(" = %d", ret);
315 return ret;
317 inval:
318 ret = -EINVAL;
319 printk("kAFS: Invalid Command on /proc/fs/afs/cells file\n");
320 goto done;
324 * Stubs for /proc/fs/afs/rootcell
326 static int afs_proc_rootcell_open(struct inode *inode, struct file *file)
328 return 0;
331 static int afs_proc_rootcell_release(struct inode *inode, struct file *file)
333 return 0;
336 static ssize_t afs_proc_rootcell_read(struct file *file, char __user *buf,
337 size_t size, loff_t *_pos)
339 return 0;
343 * handle writes to /proc/fs/afs/rootcell
344 * - to initialize rootcell: echo "cell.name:192.168.231.14"
346 static ssize_t afs_proc_rootcell_write(struct file *file,
347 const char __user *buf,
348 size_t size, loff_t *_pos)
350 char *kbuf, *s;
351 int ret;
353 /* start by dragging the command into memory */
354 if (size <= 1 || size >= PAGE_SIZE)
355 return -EINVAL;
357 ret = -ENOMEM;
358 kbuf = kmalloc(size + 1, GFP_KERNEL);
359 if (!kbuf)
360 goto nomem;
362 ret = -EFAULT;
363 if (copy_from_user(kbuf, buf, size) != 0)
364 goto infault;
365 kbuf[size] = 0;
367 /* trim to first NL */
368 s = memchr(kbuf, '\n', size);
369 if (s)
370 *s = 0;
372 /* determine command to perform */
373 _debug("rootcell=%s", kbuf);
375 ret = afs_cell_init(kbuf);
376 if (ret >= 0)
377 ret = size; /* consume everything, always */
379 infault:
380 kfree(kbuf);
381 nomem:
382 _leave(" = %d", ret);
383 return ret;
387 * initialise /proc/fs/afs/<cell>/
389 int afs_proc_cell_setup(struct afs_cell *cell)
391 struct proc_dir_entry *p;
393 _enter("%p{%s}", cell, cell->name);
395 cell->proc_dir = proc_mkdir(cell->name, proc_afs);
396 if (!cell->proc_dir)
397 goto error_dir;
399 p = proc_create_data("servers", 0, cell->proc_dir,
400 &afs_proc_cell_servers_fops, cell);
401 if (!p)
402 goto error_servers;
404 p = proc_create_data("vlservers", 0, cell->proc_dir,
405 &afs_proc_cell_vlservers_fops, cell);
406 if (!p)
407 goto error_vlservers;
409 p = proc_create_data("volumes", 0, cell->proc_dir,
410 &afs_proc_cell_volumes_fops, cell);
411 if (!p)
412 goto error_volumes;
414 _leave(" = 0");
415 return 0;
417 error_volumes:
418 remove_proc_entry("vlservers", cell->proc_dir);
419 error_vlservers:
420 remove_proc_entry("servers", cell->proc_dir);
421 error_servers:
422 remove_proc_entry(cell->name, proc_afs);
423 error_dir:
424 _leave(" = -ENOMEM");
425 return -ENOMEM;
429 * remove /proc/fs/afs/<cell>/
431 void afs_proc_cell_remove(struct afs_cell *cell)
433 _enter("");
435 remove_proc_entry("volumes", cell->proc_dir);
436 remove_proc_entry("vlservers", cell->proc_dir);
437 remove_proc_entry("servers", cell->proc_dir);
438 remove_proc_entry(cell->name, proc_afs);
440 _leave("");
444 * open "/proc/fs/afs/<cell>/volumes" which provides a summary of extant cells
446 static int afs_proc_cell_volumes_open(struct inode *inode, struct file *file)
448 struct afs_cell *cell;
449 struct seq_file *m;
450 int ret;
452 cell = PDE(inode)->data;
453 if (!cell)
454 return -ENOENT;
456 ret = seq_open(file, &afs_proc_cell_volumes_ops);
457 if (ret < 0)
458 return ret;
460 m = file->private_data;
461 m->private = cell;
463 return 0;
467 * close the file and release the ref to the cell
469 static int afs_proc_cell_volumes_release(struct inode *inode, struct file *file)
471 return seq_release(inode, file);
475 * set up the iterator to start reading from the cells list and return the
476 * first item
478 static void *afs_proc_cell_volumes_start(struct seq_file *m, loff_t *_pos)
480 struct afs_cell *cell = m->private;
482 _enter("cell=%p pos=%Ld", cell, *_pos);
484 /* lock the list against modification */
485 down_read(&cell->vl_sem);
486 return seq_list_start_head(&cell->vl_list, *_pos);
490 * move to next cell in cells list
492 static void *afs_proc_cell_volumes_next(struct seq_file *p, void *v,
493 loff_t *_pos)
495 struct afs_cell *cell = p->private;
497 _enter("cell=%p pos=%Ld", cell, *_pos);
498 return seq_list_next(v, &cell->vl_list, _pos);
502 * clean up after reading from the cells list
504 static void afs_proc_cell_volumes_stop(struct seq_file *p, void *v)
506 struct afs_cell *cell = p->private;
508 up_read(&cell->vl_sem);
511 static const char afs_vlocation_states[][4] = {
512 [AFS_VL_NEW] = "New",
513 [AFS_VL_CREATING] = "Crt",
514 [AFS_VL_VALID] = "Val",
515 [AFS_VL_NO_VOLUME] = "NoV",
516 [AFS_VL_UPDATING] = "Upd",
517 [AFS_VL_VOLUME_DELETED] = "Del",
518 [AFS_VL_UNCERTAIN] = "Unc",
522 * display a header line followed by a load of volume lines
524 static int afs_proc_cell_volumes_show(struct seq_file *m, void *v)
526 struct afs_cell *cell = m->private;
527 struct afs_vlocation *vlocation =
528 list_entry(v, struct afs_vlocation, link);
530 /* display header on line 1 */
531 if (v == &cell->vl_list) {
532 seq_puts(m, "USE STT VLID[0] VLID[1] VLID[2] NAME\n");
533 return 0;
536 /* display one cell per line on subsequent lines */
537 seq_printf(m, "%3d %s %08x %08x %08x %s\n",
538 atomic_read(&vlocation->usage),
539 afs_vlocation_states[vlocation->state],
540 vlocation->vldb.vid[0],
541 vlocation->vldb.vid[1],
542 vlocation->vldb.vid[2],
543 vlocation->vldb.name);
545 return 0;
549 * open "/proc/fs/afs/<cell>/vlservers" which provides a list of volume
550 * location server
552 static int afs_proc_cell_vlservers_open(struct inode *inode, struct file *file)
554 struct afs_cell *cell;
555 struct seq_file *m;
556 int ret;
558 cell = PDE(inode)->data;
559 if (!cell)
560 return -ENOENT;
562 ret = seq_open(file, &afs_proc_cell_vlservers_ops);
563 if (ret<0)
564 return ret;
566 m = file->private_data;
567 m->private = cell;
569 return 0;
573 * close the file and release the ref to the cell
575 static int afs_proc_cell_vlservers_release(struct inode *inode,
576 struct file *file)
578 return seq_release(inode, file);
582 * set up the iterator to start reading from the cells list and return the
583 * first item
585 static void *afs_proc_cell_vlservers_start(struct seq_file *m, loff_t *_pos)
587 struct afs_cell *cell = m->private;
588 loff_t pos = *_pos;
590 _enter("cell=%p pos=%Ld", cell, *_pos);
592 /* lock the list against modification */
593 down_read(&cell->vl_sem);
595 /* allow for the header line */
596 if (!pos)
597 return (void *) 1;
598 pos--;
600 if (pos >= cell->vl_naddrs)
601 return NULL;
603 return &cell->vl_addrs[pos];
607 * move to next cell in cells list
609 static void *afs_proc_cell_vlservers_next(struct seq_file *p, void *v,
610 loff_t *_pos)
612 struct afs_cell *cell = p->private;
613 loff_t pos;
615 _enter("cell=%p{nad=%u} pos=%Ld", cell, cell->vl_naddrs, *_pos);
617 pos = *_pos;
618 (*_pos)++;
619 if (pos >= cell->vl_naddrs)
620 return NULL;
622 return &cell->vl_addrs[pos];
626 * clean up after reading from the cells list
628 static void afs_proc_cell_vlservers_stop(struct seq_file *p, void *v)
630 struct afs_cell *cell = p->private;
632 up_read(&cell->vl_sem);
636 * display a header line followed by a load of volume lines
638 static int afs_proc_cell_vlservers_show(struct seq_file *m, void *v)
640 struct in_addr *addr = v;
642 /* display header on line 1 */
643 if (v == (struct in_addr *) 1) {
644 seq_puts(m, "ADDRESS\n");
645 return 0;
648 /* display one cell per line on subsequent lines */
649 seq_printf(m, "%u.%u.%u.%u\n", NIPQUAD(addr->s_addr));
650 return 0;
654 * open "/proc/fs/afs/<cell>/servers" which provides a summary of active
655 * servers
657 static int afs_proc_cell_servers_open(struct inode *inode, struct file *file)
659 struct afs_cell *cell;
660 struct seq_file *m;
661 int ret;
663 cell = PDE(inode)->data;
664 if (!cell)
665 return -ENOENT;
667 ret = seq_open(file, &afs_proc_cell_servers_ops);
668 if (ret < 0)
669 return ret;
671 m = file->private_data;
672 m->private = cell;
673 return 0;
677 * close the file and release the ref to the cell
679 static int afs_proc_cell_servers_release(struct inode *inode,
680 struct file *file)
682 return seq_release(inode, file);
686 * set up the iterator to start reading from the cells list and return the
687 * first item
689 static void *afs_proc_cell_servers_start(struct seq_file *m, loff_t *_pos)
690 __acquires(m->private->servers_lock)
692 struct afs_cell *cell = m->private;
694 _enter("cell=%p pos=%Ld", cell, *_pos);
696 /* lock the list against modification */
697 read_lock(&cell->servers_lock);
698 return seq_list_start_head(&cell->servers, *_pos);
702 * move to next cell in cells list
704 static void *afs_proc_cell_servers_next(struct seq_file *p, void *v,
705 loff_t *_pos)
707 struct afs_cell *cell = p->private;
709 _enter("cell=%p pos=%Ld", cell, *_pos);
710 return seq_list_next(v, &cell->servers, _pos);
714 * clean up after reading from the cells list
716 static void afs_proc_cell_servers_stop(struct seq_file *p, void *v)
717 __releases(p->private->servers_lock)
719 struct afs_cell *cell = p->private;
721 read_unlock(&cell->servers_lock);
725 * display a header line followed by a load of volume lines
727 static int afs_proc_cell_servers_show(struct seq_file *m, void *v)
729 struct afs_cell *cell = m->private;
730 struct afs_server *server = list_entry(v, struct afs_server, link);
731 char ipaddr[20];
733 /* display header on line 1 */
734 if (v == &cell->servers) {
735 seq_puts(m, "USE ADDR STATE\n");
736 return 0;
739 /* display one cell per line on subsequent lines */
740 sprintf(ipaddr, "%u.%u.%u.%u", NIPQUAD(server->addr));
741 seq_printf(m, "%3d %-15.15s %5d\n",
742 atomic_read(&server->usage), ipaddr, server->fs_state);
744 return 0;