[PATCH] Make most file operations structs in fs/ const
[linux-2.6.git] / fs / afs / proc.c
1 /* proc.c: /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/sched.h>
13 #include <linux/slab.h>
14 #include <linux/module.h>
15 #include <linux/proc_fs.h>
16 #include <linux/seq_file.h>
17 #include "cell.h"
18 #include "volume.h"
19 #include <asm/uaccess.h>
20 #include "internal.h"
21
22 static struct proc_dir_entry *proc_afs;
23
24
25 static int afs_proc_cells_open(struct inode *inode, struct file *file);
26 static void *afs_proc_cells_start(struct seq_file *p, loff_t *pos);
27 static void *afs_proc_cells_next(struct seq_file *p, void *v, loff_t *pos);
28 static void afs_proc_cells_stop(struct seq_file *p, void *v);
29 static int afs_proc_cells_show(struct seq_file *m, void *v);
30 static ssize_t afs_proc_cells_write(struct file *file, const char __user *buf,
31                                     size_t size, loff_t *_pos);
32
33 static struct seq_operations afs_proc_cells_ops = {
34         .start  = afs_proc_cells_start,
35         .next   = afs_proc_cells_next,
36         .stop   = afs_proc_cells_stop,
37         .show   = afs_proc_cells_show,
38 };
39
40 static const struct file_operations afs_proc_cells_fops = {
41         .open           = afs_proc_cells_open,
42         .read           = seq_read,
43         .write          = afs_proc_cells_write,
44         .llseek         = seq_lseek,
45         .release        = seq_release,
46 };
47
48 static int afs_proc_rootcell_open(struct inode *inode, struct file *file);
49 static int afs_proc_rootcell_release(struct inode *inode, struct file *file);
50 static ssize_t afs_proc_rootcell_read(struct file *file, char __user *buf,
51                                       size_t size, loff_t *_pos);
52 static ssize_t afs_proc_rootcell_write(struct file *file,
53                                        const char __user *buf,
54                                        size_t size, loff_t *_pos);
55
56 static const struct file_operations afs_proc_rootcell_fops = {
57         .open           = afs_proc_rootcell_open,
58         .read           = afs_proc_rootcell_read,
59         .write          = afs_proc_rootcell_write,
60         .llseek         = no_llseek,
61         .release        = afs_proc_rootcell_release
62 };
63
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);
72
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,
78 };
79
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 };
86
87 static int afs_proc_cell_vlservers_open(struct inode *inode,
88                                         struct file *file);
89 static int afs_proc_cell_vlservers_release(struct inode *inode,
90                                            struct file *file);
91 static void *afs_proc_cell_vlservers_start(struct seq_file *p, loff_t *pos);
92 static void *afs_proc_cell_vlservers_next(struct seq_file *p, void *v,
93                                           loff_t *pos);
94 static void afs_proc_cell_vlservers_stop(struct seq_file *p, void *v);
95 static int afs_proc_cell_vlservers_show(struct seq_file *m, void *v);
96
97 static struct seq_operations afs_proc_cell_vlservers_ops = {
98         .start  = afs_proc_cell_vlservers_start,
99         .next   = afs_proc_cell_vlservers_next,
100         .stop   = afs_proc_cell_vlservers_stop,
101         .show   = afs_proc_cell_vlservers_show,
102 };
103
104 static const struct file_operations afs_proc_cell_vlservers_fops = {
105         .open           = afs_proc_cell_vlservers_open,
106         .read           = seq_read,
107         .llseek         = seq_lseek,
108         .release        = afs_proc_cell_vlservers_release,
109 };
110
111 static int afs_proc_cell_servers_open(struct inode *inode, struct file *file);
112 static int afs_proc_cell_servers_release(struct inode *inode,
113                                          struct file *file);
114 static void *afs_proc_cell_servers_start(struct seq_file *p, loff_t *pos);
115 static void *afs_proc_cell_servers_next(struct seq_file *p, void *v,
116                                         loff_t *pos);
117 static void afs_proc_cell_servers_stop(struct seq_file *p, void *v);
118 static int afs_proc_cell_servers_show(struct seq_file *m, void *v);
119
120 static struct seq_operations afs_proc_cell_servers_ops = {
121         .start  = afs_proc_cell_servers_start,
122         .next   = afs_proc_cell_servers_next,
123         .stop   = afs_proc_cell_servers_stop,
124         .show   = afs_proc_cell_servers_show,
125 };
126
127 static const struct file_operations afs_proc_cell_servers_fops = {
128         .open           = afs_proc_cell_servers_open,
129         .read           = seq_read,
130         .llseek         = seq_lseek,
131         .release        = afs_proc_cell_servers_release,
132 };
133
134 /*****************************************************************************/
135 /*
136  * initialise the /proc/fs/afs/ directory
137  */
138 int afs_proc_init(void)
139 {
140         struct proc_dir_entry *p;
141
142         _enter("");
143
144         proc_afs = proc_mkdir("fs/afs", NULL);
145         if (!proc_afs)
146                 goto error;
147         proc_afs->owner = THIS_MODULE;
148
149         p = create_proc_entry("cells", 0, proc_afs);
150         if (!p)
151                 goto error_proc;
152         p->proc_fops = &afs_proc_cells_fops;
153         p->owner = THIS_MODULE;
154
155         p = create_proc_entry("rootcell", 0, proc_afs);
156         if (!p)
157                 goto error_cells;
158         p->proc_fops = &afs_proc_rootcell_fops;
159         p->owner = THIS_MODULE;
160
161         _leave(" = 0");
162         return 0;
163
164  error_cells:
165         remove_proc_entry("cells", proc_afs);
166  error_proc:
167         remove_proc_entry("fs/afs", NULL);
168  error:
169         _leave(" = -ENOMEM");
170         return -ENOMEM;
171
172 } /* end afs_proc_init() */
173
174 /*****************************************************************************/
175 /*
176  * clean up the /proc/fs/afs/ directory
177  */
178 void afs_proc_cleanup(void)
179 {
180         remove_proc_entry("cells", proc_afs);
181
182         remove_proc_entry("fs/afs", NULL);
183
184 } /* end afs_proc_cleanup() */
185
186 /*****************************************************************************/
187 /*
188  * open "/proc/fs/afs/cells" which provides a summary of extant cells
189  */
190 static int afs_proc_cells_open(struct inode *inode, struct file *file)
191 {
192         struct seq_file *m;
193         int ret;
194
195         ret = seq_open(file, &afs_proc_cells_ops);
196         if (ret < 0)
197                 return ret;
198
199         m = file->private_data;
200         m->private = PDE(inode)->data;
201
202         return 0;
203 } /* end afs_proc_cells_open() */
204
205 /*****************************************************************************/
206 /*
207  * set up the iterator to start reading from the cells list and return the
208  * first item
209  */
210 static void *afs_proc_cells_start(struct seq_file *m, loff_t *_pos)
211 {
212         struct list_head *_p;
213         loff_t pos = *_pos;
214
215         /* lock the list against modification */
216         down_read(&afs_proc_cells_sem);
217
218         /* allow for the header line */
219         if (!pos)
220                 return (void *) 1;
221         pos--;
222
223         /* find the n'th element in the list */
224         list_for_each(_p, &afs_proc_cells)
225                 if (!pos--)
226                         break;
227
228         return _p != &afs_proc_cells ? _p : NULL;
229 } /* end afs_proc_cells_start() */
230
231 /*****************************************************************************/
232 /*
233  * move to next cell in cells list
234  */
235 static void *afs_proc_cells_next(struct seq_file *p, void *v, loff_t *pos)
236 {
237         struct list_head *_p;
238
239         (*pos)++;
240
241         _p = v;
242         _p = v == (void *) 1 ? afs_proc_cells.next : _p->next;
243
244         return _p != &afs_proc_cells ? _p : NULL;
245 } /* end afs_proc_cells_next() */
246
247 /*****************************************************************************/
248 /*
249  * clean up after reading from the cells list
250  */
251 static void afs_proc_cells_stop(struct seq_file *p, void *v)
252 {
253         up_read(&afs_proc_cells_sem);
254
255 } /* end afs_proc_cells_stop() */
256
257 /*****************************************************************************/
258 /*
259  * display a header line followed by a load of cell lines
260  */
261 static int afs_proc_cells_show(struct seq_file *m, void *v)
262 {
263         struct afs_cell *cell = list_entry(v, struct afs_cell, proc_link);
264
265         /* display header on line 1 */
266         if (v == (void *) 1) {
267                 seq_puts(m, "USE NAME\n");
268                 return 0;
269         }
270
271         /* display one cell per line on subsequent lines */
272         seq_printf(m, "%3d %s\n", atomic_read(&cell->usage), cell->name);
273
274         return 0;
275 } /* end afs_proc_cells_show() */
276
277 /*****************************************************************************/
278 /*
279  * handle writes to /proc/fs/afs/cells
280  * - to add cells: echo "add <cellname> <IP>[:<IP>][:<IP>]"
281  */
282 static ssize_t afs_proc_cells_write(struct file *file, const char __user *buf,
283                                     size_t size, loff_t *_pos)
284 {
285         char *kbuf, *name, *args;
286         int ret;
287
288         /* start by dragging the command into memory */
289         if (size <= 1 || size >= PAGE_SIZE)
290                 return -EINVAL;
291
292         kbuf = kmalloc(size + 1, GFP_KERNEL);
293         if (!kbuf)
294                 return -ENOMEM;
295
296         ret = -EFAULT;
297         if (copy_from_user(kbuf, buf, size) != 0)
298                 goto done;
299         kbuf[size] = 0;
300
301         /* trim to first NL */
302         name = memchr(kbuf, '\n', size);
303         if (name)
304                 *name = 0;
305
306         /* split into command, name and argslist */
307         name = strchr(kbuf, ' ');
308         if (!name)
309                 goto inval;
310         do {
311                 *name++ = 0;
312         } while(*name == ' ');
313         if (!*name)
314                 goto inval;
315
316         args = strchr(name, ' ');
317         if (!args)
318                 goto inval;
319         do {
320                 *args++ = 0;
321         } while(*args == ' ');
322         if (!*args)
323                 goto inval;
324
325         /* determine command to perform */
326         _debug("cmd=%s name=%s args=%s", kbuf, name, args);
327
328         if (strcmp(kbuf, "add") == 0) {
329                 struct afs_cell *cell;
330                 ret = afs_cell_create(name, args, &cell);
331                 if (ret < 0)
332                         goto done;
333
334                 printk("kAFS: Added new cell '%s'\n", name);
335         }
336         else {
337                 goto inval;
338         }
339
340         ret = size;
341
342  done:
343         kfree(kbuf);
344         _leave(" = %d", ret);
345         return ret;
346
347  inval:
348         ret = -EINVAL;
349         printk("kAFS: Invalid Command on /proc/fs/afs/cells file\n");
350         goto done;
351 } /* end afs_proc_cells_write() */
352
353 /*****************************************************************************/
354 /*
355  * Stubs for /proc/fs/afs/rootcell
356  */
357 static int afs_proc_rootcell_open(struct inode *inode, struct file *file)
358 {
359         return 0;
360 }
361
362 static int afs_proc_rootcell_release(struct inode *inode, struct file *file)
363 {
364         return 0;
365 }
366
367 static ssize_t afs_proc_rootcell_read(struct file *file, char __user *buf,
368                                       size_t size, loff_t *_pos)
369 {
370         return 0;
371 }
372
373 /*****************************************************************************/
374 /*
375  * handle writes to /proc/fs/afs/rootcell
376  * - to initialize rootcell: echo "cell.name:192.168.231.14"
377  */
378 static ssize_t afs_proc_rootcell_write(struct file *file,
379                                        const char __user *buf,
380                                        size_t size, loff_t *_pos)
381 {
382         char *kbuf, *s;
383         int ret;
384
385         /* start by dragging the command into memory */
386         if (size <= 1 || size >= PAGE_SIZE)
387                 return -EINVAL;
388
389         ret = -ENOMEM;
390         kbuf = kmalloc(size + 1, GFP_KERNEL);
391         if (!kbuf)
392                 goto nomem;
393
394         ret = -EFAULT;
395         if (copy_from_user(kbuf, buf, size) != 0)
396                 goto infault;
397         kbuf[size] = 0;
398
399         /* trim to first NL */
400         s = memchr(kbuf, '\n', size);
401         if (s)
402                 *s = 0;
403
404         /* determine command to perform */
405         _debug("rootcell=%s", kbuf);
406
407         ret = afs_cell_init(kbuf);
408         if (ret >= 0)
409                 ret = size;     /* consume everything, always */
410
411  infault:
412         kfree(kbuf);
413  nomem:
414         _leave(" = %d", ret);
415         return ret;
416 } /* end afs_proc_rootcell_write() */
417
418 /*****************************************************************************/
419 /*
420  * initialise /proc/fs/afs/<cell>/
421  */
422 int afs_proc_cell_setup(struct afs_cell *cell)
423 {
424         struct proc_dir_entry *p;
425
426         _enter("%p{%s}", cell, cell->name);
427
428         cell->proc_dir = proc_mkdir(cell->name, proc_afs);
429         if (!cell->proc_dir)
430                 return -ENOMEM;
431
432         p = create_proc_entry("servers", 0, cell->proc_dir);
433         if (!p)
434                 goto error_proc;
435         p->proc_fops = &afs_proc_cell_servers_fops;
436         p->owner = THIS_MODULE;
437         p->data = cell;
438
439         p = create_proc_entry("vlservers", 0, cell->proc_dir);
440         if (!p)
441                 goto error_servers;
442         p->proc_fops = &afs_proc_cell_vlservers_fops;
443         p->owner = THIS_MODULE;
444         p->data = cell;
445
446         p = create_proc_entry("volumes", 0, cell->proc_dir);
447         if (!p)
448                 goto error_vlservers;
449         p->proc_fops = &afs_proc_cell_volumes_fops;
450         p->owner = THIS_MODULE;
451         p->data = cell;
452
453         _leave(" = 0");
454         return 0;
455
456  error_vlservers:
457         remove_proc_entry("vlservers", cell->proc_dir);
458  error_servers:
459         remove_proc_entry("servers", cell->proc_dir);
460  error_proc:
461         remove_proc_entry(cell->name, proc_afs);
462         _leave(" = -ENOMEM");
463         return -ENOMEM;
464 } /* end afs_proc_cell_setup() */
465
466 /*****************************************************************************/
467 /*
468  * remove /proc/fs/afs/<cell>/
469  */
470 void afs_proc_cell_remove(struct afs_cell *cell)
471 {
472         _enter("");
473
474         remove_proc_entry("volumes", cell->proc_dir);
475         remove_proc_entry("vlservers", cell->proc_dir);
476         remove_proc_entry("servers", cell->proc_dir);
477         remove_proc_entry(cell->name, proc_afs);
478
479         _leave("");
480 } /* end afs_proc_cell_remove() */
481
482 /*****************************************************************************/
483 /*
484  * open "/proc/fs/afs/<cell>/volumes" which provides a summary of extant cells
485  */
486 static int afs_proc_cell_volumes_open(struct inode *inode, struct file *file)
487 {
488         struct afs_cell *cell;
489         struct seq_file *m;
490         int ret;
491
492         cell = afs_get_cell_maybe((struct afs_cell **) &PDE(inode)->data);
493         if (!cell)
494                 return -ENOENT;
495
496         ret = seq_open(file, &afs_proc_cell_volumes_ops);
497         if (ret < 0)
498                 return ret;
499
500         m = file->private_data;
501         m->private = cell;
502
503         return 0;
504 } /* end afs_proc_cell_volumes_open() */
505
506 /*****************************************************************************/
507 /*
508  * close the file and release the ref to the cell
509  */
510 static int afs_proc_cell_volumes_release(struct inode *inode, struct file *file)
511 {
512         struct afs_cell *cell = PDE(inode)->data;
513         int ret;
514
515         ret = seq_release(inode,file);
516
517         afs_put_cell(cell);
518
519         return ret;
520 } /* end afs_proc_cell_volumes_release() */
521
522 /*****************************************************************************/
523 /*
524  * set up the iterator to start reading from the cells list and return the
525  * first item
526  */
527 static void *afs_proc_cell_volumes_start(struct seq_file *m, loff_t *_pos)
528 {
529         struct list_head *_p;
530         struct afs_cell *cell = m->private;
531         loff_t pos = *_pos;
532
533         _enter("cell=%p pos=%Ld", cell, *_pos);
534
535         /* lock the list against modification */
536         down_read(&cell->vl_sem);
537
538         /* allow for the header line */
539         if (!pos)
540                 return (void *) 1;
541         pos--;
542
543         /* find the n'th element in the list */
544         list_for_each(_p, &cell->vl_list)
545                 if (!pos--)
546                         break;
547
548         return _p != &cell->vl_list ? _p : NULL;
549 } /* end afs_proc_cell_volumes_start() */
550
551 /*****************************************************************************/
552 /*
553  * move to next cell in cells list
554  */
555 static void *afs_proc_cell_volumes_next(struct seq_file *p, void *v,
556                                         loff_t *_pos)
557 {
558         struct list_head *_p;
559         struct afs_cell *cell = p->private;
560
561         _enter("cell=%p pos=%Ld", cell, *_pos);
562
563         (*_pos)++;
564
565         _p = v;
566         _p = v == (void *) 1 ? cell->vl_list.next : _p->next;
567
568         return _p != &cell->vl_list ? _p : NULL;
569 } /* end afs_proc_cell_volumes_next() */
570
571 /*****************************************************************************/
572 /*
573  * clean up after reading from the cells list
574  */
575 static void afs_proc_cell_volumes_stop(struct seq_file *p, void *v)
576 {
577         struct afs_cell *cell = p->private;
578
579         up_read(&cell->vl_sem);
580
581 } /* end afs_proc_cell_volumes_stop() */
582
583 /*****************************************************************************/
584 /*
585  * display a header line followed by a load of volume lines
586  */
587 static int afs_proc_cell_volumes_show(struct seq_file *m, void *v)
588 {
589         struct afs_vlocation *vlocation =
590                 list_entry(v, struct afs_vlocation, link);
591
592         /* display header on line 1 */
593         if (v == (void *) 1) {
594                 seq_puts(m, "USE VLID[0]  VLID[1]  VLID[2]  NAME\n");
595                 return 0;
596         }
597
598         /* display one cell per line on subsequent lines */
599         seq_printf(m, "%3d %08x %08x %08x %s\n",
600                    atomic_read(&vlocation->usage),
601                    vlocation->vldb.vid[0],
602                    vlocation->vldb.vid[1],
603                    vlocation->vldb.vid[2],
604                    vlocation->vldb.name
605                    );
606
607         return 0;
608 } /* end afs_proc_cell_volumes_show() */
609
610 /*****************************************************************************/
611 /*
612  * open "/proc/fs/afs/<cell>/vlservers" which provides a list of volume
613  * location server
614  */
615 static int afs_proc_cell_vlservers_open(struct inode *inode, struct file *file)
616 {
617         struct afs_cell *cell;
618         struct seq_file *m;
619         int ret;
620
621         cell = afs_get_cell_maybe((struct afs_cell**)&PDE(inode)->data);
622         if (!cell)
623                 return -ENOENT;
624
625         ret = seq_open(file,&afs_proc_cell_vlservers_ops);
626         if (ret<0)
627                 return ret;
628
629         m = file->private_data;
630         m->private = cell;
631
632         return 0;
633 } /* end afs_proc_cell_vlservers_open() */
634
635 /*****************************************************************************/
636 /*
637  * close the file and release the ref to the cell
638  */
639 static int afs_proc_cell_vlservers_release(struct inode *inode,
640                                            struct file *file)
641 {
642         struct afs_cell *cell = PDE(inode)->data;
643         int ret;
644
645         ret = seq_release(inode,file);
646
647         afs_put_cell(cell);
648
649         return ret;
650 } /* end afs_proc_cell_vlservers_release() */
651
652 /*****************************************************************************/
653 /*
654  * set up the iterator to start reading from the cells list and return the
655  * first item
656  */
657 static void *afs_proc_cell_vlservers_start(struct seq_file *m, loff_t *_pos)
658 {
659         struct afs_cell *cell = m->private;
660         loff_t pos = *_pos;
661
662         _enter("cell=%p pos=%Ld", cell, *_pos);
663
664         /* lock the list against modification */
665         down_read(&cell->vl_sem);
666
667         /* allow for the header line */
668         if (!pos)
669                 return (void *) 1;
670         pos--;
671
672         if (pos >= cell->vl_naddrs)
673                 return NULL;
674
675         return &cell->vl_addrs[pos];
676 } /* end afs_proc_cell_vlservers_start() */
677
678 /*****************************************************************************/
679 /*
680  * move to next cell in cells list
681  */
682 static void *afs_proc_cell_vlservers_next(struct seq_file *p, void *v,
683                                           loff_t *_pos)
684 {
685         struct afs_cell *cell = p->private;
686         loff_t pos;
687
688         _enter("cell=%p{nad=%u} pos=%Ld", cell, cell->vl_naddrs, *_pos);
689
690         pos = *_pos;
691         (*_pos)++;
692         if (pos >= cell->vl_naddrs)
693                 return NULL;
694
695         return &cell->vl_addrs[pos];
696 } /* end afs_proc_cell_vlservers_next() */
697
698 /*****************************************************************************/
699 /*
700  * clean up after reading from the cells list
701  */
702 static void afs_proc_cell_vlservers_stop(struct seq_file *p, void *v)
703 {
704         struct afs_cell *cell = p->private;
705
706         up_read(&cell->vl_sem);
707
708 } /* end afs_proc_cell_vlservers_stop() */
709
710 /*****************************************************************************/
711 /*
712  * display a header line followed by a load of volume lines
713  */
714 static int afs_proc_cell_vlservers_show(struct seq_file *m, void *v)
715 {
716         struct in_addr *addr = v;
717
718         /* display header on line 1 */
719         if (v == (struct in_addr *) 1) {
720                 seq_puts(m, "ADDRESS\n");
721                 return 0;
722         }
723
724         /* display one cell per line on subsequent lines */
725         seq_printf(m, "%u.%u.%u.%u\n", NIPQUAD(addr->s_addr));
726
727         return 0;
728 } /* end afs_proc_cell_vlservers_show() */
729
730 /*****************************************************************************/
731 /*
732  * open "/proc/fs/afs/<cell>/servers" which provides a summary of active
733  * servers
734  */
735 static int afs_proc_cell_servers_open(struct inode *inode, struct file *file)
736 {
737         struct afs_cell *cell;
738         struct seq_file *m;
739         int ret;
740
741         cell = afs_get_cell_maybe((struct afs_cell **) &PDE(inode)->data);
742         if (!cell)
743                 return -ENOENT;
744
745         ret = seq_open(file, &afs_proc_cell_servers_ops);
746         if (ret < 0)
747                 return ret;
748
749         m = file->private_data;
750         m->private = cell;
751
752         return 0;
753 } /* end afs_proc_cell_servers_open() */
754
755 /*****************************************************************************/
756 /*
757  * close the file and release the ref to the cell
758  */
759 static int afs_proc_cell_servers_release(struct inode *inode,
760                                          struct file *file)
761 {
762         struct afs_cell *cell = PDE(inode)->data;
763         int ret;
764
765         ret = seq_release(inode, file);
766
767         afs_put_cell(cell);
768
769         return ret;
770 } /* end afs_proc_cell_servers_release() */
771
772 /*****************************************************************************/
773 /*
774  * set up the iterator to start reading from the cells list and return the
775  * first item
776  */
777 static void *afs_proc_cell_servers_start(struct seq_file *m, loff_t *_pos)
778 {
779         struct list_head *_p;
780         struct afs_cell *cell = m->private;
781         loff_t pos = *_pos;
782
783         _enter("cell=%p pos=%Ld", cell, *_pos);
784
785         /* lock the list against modification */
786         read_lock(&cell->sv_lock);
787
788         /* allow for the header line */
789         if (!pos)
790                 return (void *) 1;
791         pos--;
792
793         /* find the n'th element in the list */
794         list_for_each(_p, &cell->sv_list)
795                 if (!pos--)
796                         break;
797
798         return _p != &cell->sv_list ? _p : NULL;
799 } /* end afs_proc_cell_servers_start() */
800
801 /*****************************************************************************/
802 /*
803  * move to next cell in cells list
804  */
805 static void *afs_proc_cell_servers_next(struct seq_file *p, void *v,
806                                         loff_t *_pos)
807 {
808         struct list_head *_p;
809         struct afs_cell *cell = p->private;
810
811         _enter("cell=%p pos=%Ld", cell, *_pos);
812
813         (*_pos)++;
814
815         _p = v;
816         _p = v == (void *) 1 ? cell->sv_list.next : _p->next;
817
818         return _p != &cell->sv_list ? _p : NULL;
819 } /* end afs_proc_cell_servers_next() */
820
821 /*****************************************************************************/
822 /*
823  * clean up after reading from the cells list
824  */
825 static void afs_proc_cell_servers_stop(struct seq_file *p, void *v)
826 {
827         struct afs_cell *cell = p->private;
828
829         read_unlock(&cell->sv_lock);
830
831 } /* end afs_proc_cell_servers_stop() */
832
833 /*****************************************************************************/
834 /*
835  * display a header line followed by a load of volume lines
836  */
837 static int afs_proc_cell_servers_show(struct seq_file *m, void *v)
838 {
839         struct afs_server *server = list_entry(v, struct afs_server, link);
840         char ipaddr[20];
841
842         /* display header on line 1 */
843         if (v == (void *) 1) {
844                 seq_puts(m, "USE ADDR            STATE\n");
845                 return 0;
846         }
847
848         /* display one cell per line on subsequent lines */
849         sprintf(ipaddr, "%u.%u.%u.%u", NIPQUAD(server->addr));
850         seq_printf(m, "%3d %-15.15s %5d\n",
851                    atomic_read(&server->usage),
852                    ipaddr,
853                    server->fs_state
854                    );
855
856         return 0;
857 } /* end afs_proc_cell_servers_show() */