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