blob: 7578c1ab9e0be9ec3260c4cce41b78287f213bce [file] [log] [blame]
David Howellsec268152007-04-26 15:49:28 -07001/* /proc interface for AFS
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 *
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/slab.h>
13#include <linux/module.h>
14#include <linux/proc_fs.h>
15#include <linux/seq_file.h>
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +040016#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <asm/uaccess.h>
18#include "internal.h"
19
20static struct proc_dir_entry *proc_afs;
21
22
23static int afs_proc_cells_open(struct inode *inode, struct file *file);
24static void *afs_proc_cells_start(struct seq_file *p, loff_t *pos);
25static void *afs_proc_cells_next(struct seq_file *p, void *v, loff_t *pos);
26static void afs_proc_cells_stop(struct seq_file *p, void *v);
27static int afs_proc_cells_show(struct seq_file *m, void *v);
28static ssize_t afs_proc_cells_write(struct file *file, const char __user *buf,
29 size_t size, loff_t *_pos);
30
31static 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,
36};
37
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -080038static const struct file_operations afs_proc_cells_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070039 .open = afs_proc_cells_open,
40 .read = seq_read,
41 .write = afs_proc_cells_write,
42 .llseek = seq_lseek,
43 .release = seq_release,
Denis V. Lunev21ac2952008-04-29 01:02:07 -070044 .owner = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -070045};
46
47static int afs_proc_rootcell_open(struct inode *inode, struct file *file);
48static int afs_proc_rootcell_release(struct inode *inode, struct file *file);
49static ssize_t afs_proc_rootcell_read(struct file *file, char __user *buf,
50 size_t size, loff_t *_pos);
51static ssize_t afs_proc_rootcell_write(struct file *file,
52 const char __user *buf,
53 size_t size, loff_t *_pos);
54
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -080055static const struct file_operations afs_proc_rootcell_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 .open = afs_proc_rootcell_open,
57 .read = afs_proc_rootcell_read,
58 .write = afs_proc_rootcell_write,
59 .llseek = no_llseek,
Denis V. Lunev21ac2952008-04-29 01:02:07 -070060 .release = afs_proc_rootcell_release,
61 .owner = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -070062};
63
64static int afs_proc_cell_volumes_open(struct inode *inode, struct file *file);
65static int afs_proc_cell_volumes_release(struct inode *inode,
66 struct file *file);
67static void *afs_proc_cell_volumes_start(struct seq_file *p, loff_t *pos);
68static void *afs_proc_cell_volumes_next(struct seq_file *p, void *v,
69 loff_t *pos);
70static void afs_proc_cell_volumes_stop(struct seq_file *p, void *v);
71static int afs_proc_cell_volumes_show(struct seq_file *m, void *v);
72
73static 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
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -080080static const struct file_operations afs_proc_cell_volumes_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 .open = afs_proc_cell_volumes_open,
82 .read = seq_read,
83 .llseek = seq_lseek,
84 .release = afs_proc_cell_volumes_release,
Denis V. Lunev21ac2952008-04-29 01:02:07 -070085 .owner = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -070086};
87
88static int afs_proc_cell_vlservers_open(struct inode *inode,
89 struct file *file);
90static int afs_proc_cell_vlservers_release(struct inode *inode,
91 struct file *file);
92static void *afs_proc_cell_vlservers_start(struct seq_file *p, loff_t *pos);
93static void *afs_proc_cell_vlservers_next(struct seq_file *p, void *v,
94 loff_t *pos);
95static void afs_proc_cell_vlservers_stop(struct seq_file *p, void *v);
96static int afs_proc_cell_vlservers_show(struct seq_file *m, void *v);
97
98static 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,
103};
104
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800105static const struct file_operations afs_proc_cell_vlservers_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 .open = afs_proc_cell_vlservers_open,
107 .read = seq_read,
108 .llseek = seq_lseek,
109 .release = afs_proc_cell_vlservers_release,
Denis V. Lunev21ac2952008-04-29 01:02:07 -0700110 .owner = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111};
112
113static int afs_proc_cell_servers_open(struct inode *inode, struct file *file);
114static int afs_proc_cell_servers_release(struct inode *inode,
115 struct file *file);
116static void *afs_proc_cell_servers_start(struct seq_file *p, loff_t *pos);
117static void *afs_proc_cell_servers_next(struct seq_file *p, void *v,
118 loff_t *pos);
119static void afs_proc_cell_servers_stop(struct seq_file *p, void *v);
120static int afs_proc_cell_servers_show(struct seq_file *m, void *v);
121
122static 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,
127};
128
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800129static const struct file_operations afs_proc_cell_servers_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 .open = afs_proc_cell_servers_open,
131 .read = seq_read,
132 .llseek = seq_lseek,
133 .release = afs_proc_cell_servers_release,
Denis V. Lunev21ac2952008-04-29 01:02:07 -0700134 .owner = THIS_MODULE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135};
136
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137/*
138 * initialise the /proc/fs/afs/ directory
139 */
140int afs_proc_init(void)
141{
142 struct proc_dir_entry *p;
143
144 _enter("");
145
146 proc_afs = proc_mkdir("fs/afs", NULL);
147 if (!proc_afs)
David Howellsec268152007-04-26 15:49:28 -0700148 goto error_dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 proc_afs->owner = THIS_MODULE;
150
Denis V. Lunev21ac2952008-04-29 01:02:07 -0700151 p = proc_create("cells", 0, proc_afs, &afs_proc_cells_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 if (!p)
David Howellsec268152007-04-26 15:49:28 -0700153 goto error_cells;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
Denis V. Lunev21ac2952008-04-29 01:02:07 -0700155 p = proc_create("rootcell", 0, proc_afs, &afs_proc_rootcell_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 if (!p)
David Howellsec268152007-04-26 15:49:28 -0700157 goto error_rootcell;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
159 _leave(" = 0");
160 return 0;
161
David Howellsec268152007-04-26 15:49:28 -0700162error_rootcell:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 remove_proc_entry("cells", proc_afs);
David Howellsec268152007-04-26 15:49:28 -0700164error_cells:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 remove_proc_entry("fs/afs", NULL);
David Howellsec268152007-04-26 15:49:28 -0700166error_dir:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 _leave(" = -ENOMEM");
168 return -ENOMEM;
David Howellsec268152007-04-26 15:49:28 -0700169}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171/*
172 * clean up the /proc/fs/afs/ directory
173 */
174void afs_proc_cleanup(void)
175{
David Howellsec268152007-04-26 15:49:28 -0700176 remove_proc_entry("rootcell", proc_afs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 remove_proc_entry("cells", proc_afs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 remove_proc_entry("fs/afs", NULL);
David Howellsec268152007-04-26 15:49:28 -0700179}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181/*
182 * open "/proc/fs/afs/cells" which provides a summary of extant cells
183 */
184static int afs_proc_cells_open(struct inode *inode, struct file *file)
185{
186 struct seq_file *m;
187 int ret;
188
189 ret = seq_open(file, &afs_proc_cells_ops);
190 if (ret < 0)
191 return ret;
192
193 m = file->private_data;
194 m->private = PDE(inode)->data;
195
196 return 0;
David Howellsec268152007-04-26 15:49:28 -0700197}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199/*
200 * set up the iterator to start reading from the cells list and return the
201 * first item
202 */
203static void *afs_proc_cells_start(struct seq_file *m, loff_t *_pos)
204{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 /* lock the list against modification */
206 down_read(&afs_proc_cells_sem);
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700207 return seq_list_start_head(&afs_proc_cells, *_pos);
David Howellsec268152007-04-26 15:49:28 -0700208}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210/*
211 * move to next cell in cells list
212 */
213static void *afs_proc_cells_next(struct seq_file *p, void *v, loff_t *pos)
214{
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700215 return seq_list_next(v, &afs_proc_cells, pos);
David Howellsec268152007-04-26 15:49:28 -0700216}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218/*
219 * clean up after reading from the cells list
220 */
221static void afs_proc_cells_stop(struct seq_file *p, void *v)
222{
223 up_read(&afs_proc_cells_sem);
David Howellsec268152007-04-26 15:49:28 -0700224}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226/*
227 * display a header line followed by a load of cell lines
228 */
229static int afs_proc_cells_show(struct seq_file *m, void *v)
230{
231 struct afs_cell *cell = list_entry(v, struct afs_cell, proc_link);
232
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700233 if (v == &afs_proc_cells) {
David Howellsec268152007-04-26 15:49:28 -0700234 /* display header on line 1 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 seq_puts(m, "USE NAME\n");
236 return 0;
237 }
238
239 /* display one cell per line on subsequent lines */
David Howellsec268152007-04-26 15:49:28 -0700240 seq_printf(m, "%3d %s\n",
241 atomic_read(&cell->usage), cell->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 return 0;
David Howellsec268152007-04-26 15:49:28 -0700243}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245/*
246 * handle writes to /proc/fs/afs/cells
247 * - to add cells: echo "add <cellname> <IP>[:<IP>][:<IP>]"
248 */
249static ssize_t afs_proc_cells_write(struct file *file, const char __user *buf,
250 size_t size, loff_t *_pos)
251{
252 char *kbuf, *name, *args;
253 int ret;
254
255 /* start by dragging the command into memory */
256 if (size <= 1 || size >= PAGE_SIZE)
257 return -EINVAL;
258
259 kbuf = kmalloc(size + 1, GFP_KERNEL);
260 if (!kbuf)
261 return -ENOMEM;
262
263 ret = -EFAULT;
264 if (copy_from_user(kbuf, buf, size) != 0)
265 goto done;
266 kbuf[size] = 0;
267
268 /* trim to first NL */
269 name = memchr(kbuf, '\n', size);
270 if (name)
271 *name = 0;
272
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;
282
283 args = strchr(name, ' ');
284 if (!args)
285 goto inval;
286 do {
287 *args++ = 0;
288 } while(*args == ' ');
289 if (!*args)
290 goto inval;
291
292 /* determine command to perform */
293 _debug("cmd=%s name=%s args=%s", kbuf, name, args);
294
295 if (strcmp(kbuf, "add") == 0) {
296 struct afs_cell *cell;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
David Howells08e0e7c2007-04-26 15:55:03 -0700298 cell = afs_cell_create(name, args);
299 if (IS_ERR(cell)) {
300 ret = PTR_ERR(cell);
301 goto done;
302 }
303
304 afs_put_cell(cell);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 printk("kAFS: Added new cell '%s'\n", name);
David Howellsec268152007-04-26 15:49:28 -0700306 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 goto inval;
308 }
309
310 ret = size;
311
David Howellsec268152007-04-26 15:49:28 -0700312done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 kfree(kbuf);
314 _leave(" = %d", ret);
315 return ret;
316
David Howellsec268152007-04-26 15:49:28 -0700317inval:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 ret = -EINVAL;
319 printk("kAFS: Invalid Command on /proc/fs/afs/cells file\n");
320 goto done;
David Howellsec268152007-04-26 15:49:28 -0700321}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323/*
324 * Stubs for /proc/fs/afs/rootcell
325 */
326static int afs_proc_rootcell_open(struct inode *inode, struct file *file)
327{
328 return 0;
329}
330
331static int afs_proc_rootcell_release(struct inode *inode, struct file *file)
332{
333 return 0;
334}
335
336static ssize_t afs_proc_rootcell_read(struct file *file, char __user *buf,
337 size_t size, loff_t *_pos)
338{
339 return 0;
340}
341
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342/*
343 * handle writes to /proc/fs/afs/rootcell
344 * - to initialize rootcell: echo "cell.name:192.168.231.14"
345 */
346static ssize_t afs_proc_rootcell_write(struct file *file,
347 const char __user *buf,
348 size_t size, loff_t *_pos)
349{
350 char *kbuf, *s;
351 int ret;
352
353 /* start by dragging the command into memory */
354 if (size <= 1 || size >= PAGE_SIZE)
355 return -EINVAL;
356
357 ret = -ENOMEM;
358 kbuf = kmalloc(size + 1, GFP_KERNEL);
359 if (!kbuf)
360 goto nomem;
361
362 ret = -EFAULT;
363 if (copy_from_user(kbuf, buf, size) != 0)
364 goto infault;
365 kbuf[size] = 0;
366
367 /* trim to first NL */
368 s = memchr(kbuf, '\n', size);
369 if (s)
370 *s = 0;
371
372 /* determine command to perform */
373 _debug("rootcell=%s", kbuf);
374
375 ret = afs_cell_init(kbuf);
376 if (ret >= 0)
377 ret = size; /* consume everything, always */
378
David Howellsec268152007-04-26 15:49:28 -0700379infault:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 kfree(kbuf);
David Howellsec268152007-04-26 15:49:28 -0700381nomem:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 _leave(" = %d", ret);
383 return ret;
David Howellsec268152007-04-26 15:49:28 -0700384}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386/*
387 * initialise /proc/fs/afs/<cell>/
388 */
389int afs_proc_cell_setup(struct afs_cell *cell)
390{
391 struct proc_dir_entry *p;
392
393 _enter("%p{%s}", cell, cell->name);
394
395 cell->proc_dir = proc_mkdir(cell->name, proc_afs);
396 if (!cell->proc_dir)
David Howellsec268152007-04-26 15:49:28 -0700397 goto error_dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398
Denis V. Lunev21ac2952008-04-29 01:02:07 -0700399 p = proc_create_data("servers", 0, cell->proc_dir,
400 &afs_proc_cell_servers_fops, cell);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 if (!p)
David Howellsec268152007-04-26 15:49:28 -0700402 goto error_servers;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
Denis V. Lunev21ac2952008-04-29 01:02:07 -0700404 p = proc_create_data("vlservers", 0, cell->proc_dir,
405 &afs_proc_cell_vlservers_fops, cell);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 if (!p)
David Howellsec268152007-04-26 15:49:28 -0700407 goto error_vlservers;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Denis V. Lunev21ac2952008-04-29 01:02:07 -0700409 p = proc_create_data("volumes", 0, cell->proc_dir,
410 &afs_proc_cell_volumes_fops, cell);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 if (!p)
David Howellsec268152007-04-26 15:49:28 -0700412 goto error_volumes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
414 _leave(" = 0");
415 return 0;
416
David Howellsec268152007-04-26 15:49:28 -0700417error_volumes:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 remove_proc_entry("vlservers", cell->proc_dir);
David Howellsec268152007-04-26 15:49:28 -0700419error_vlservers:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 remove_proc_entry("servers", cell->proc_dir);
David Howellsec268152007-04-26 15:49:28 -0700421error_servers:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 remove_proc_entry(cell->name, proc_afs);
David Howellsec268152007-04-26 15:49:28 -0700423error_dir:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 _leave(" = -ENOMEM");
425 return -ENOMEM;
David Howellsec268152007-04-26 15:49:28 -0700426}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428/*
429 * remove /proc/fs/afs/<cell>/
430 */
431void afs_proc_cell_remove(struct afs_cell *cell)
432{
433 _enter("");
434
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);
439
440 _leave("");
David Howellsec268152007-04-26 15:49:28 -0700441}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443/*
444 * open "/proc/fs/afs/<cell>/volumes" which provides a summary of extant cells
445 */
446static int afs_proc_cell_volumes_open(struct inode *inode, struct file *file)
447{
448 struct afs_cell *cell;
449 struct seq_file *m;
450 int ret;
451
David Howells08e0e7c2007-04-26 15:55:03 -0700452 cell = PDE(inode)->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 if (!cell)
454 return -ENOENT;
455
456 ret = seq_open(file, &afs_proc_cell_volumes_ops);
457 if (ret < 0)
458 return ret;
459
460 m = file->private_data;
461 m->private = cell;
462
463 return 0;
David Howellsec268152007-04-26 15:49:28 -0700464}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466/*
467 * close the file and release the ref to the cell
468 */
469static int afs_proc_cell_volumes_release(struct inode *inode, struct file *file)
470{
David Howells08e0e7c2007-04-26 15:55:03 -0700471 return seq_release(inode, file);
David Howellsec268152007-04-26 15:49:28 -0700472}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474/*
475 * set up the iterator to start reading from the cells list and return the
476 * first item
477 */
478static void *afs_proc_cell_volumes_start(struct seq_file *m, loff_t *_pos)
479{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 struct afs_cell *cell = m->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
482 _enter("cell=%p pos=%Ld", cell, *_pos);
483
484 /* lock the list against modification */
485 down_read(&cell->vl_sem);
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700486 return seq_list_start_head(&cell->vl_list, *_pos);
David Howellsec268152007-04-26 15:49:28 -0700487}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489/*
490 * move to next cell in cells list
491 */
492static void *afs_proc_cell_volumes_next(struct seq_file *p, void *v,
493 loff_t *_pos)
494{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 struct afs_cell *cell = p->private;
496
497 _enter("cell=%p pos=%Ld", cell, *_pos);
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700498 return seq_list_next(v, &cell->vl_list, _pos);
David Howellsec268152007-04-26 15:49:28 -0700499}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501/*
502 * clean up after reading from the cells list
503 */
504static void afs_proc_cell_volumes_stop(struct seq_file *p, void *v)
505{
506 struct afs_cell *cell = p->private;
507
508 up_read(&cell->vl_sem);
David Howellsec268152007-04-26 15:49:28 -0700509}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
Adrian Bunkc1206a22007-10-16 23:26:41 -0700511static const char afs_vlocation_states[][4] = {
David Howells08e0e7c2007-04-26 15:55:03 -0700512 [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",
519};
520
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521/*
522 * display a header line followed by a load of volume lines
523 */
524static int afs_proc_cell_volumes_show(struct seq_file *m, void *v)
525{
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700526 struct afs_cell *cell = m->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 struct afs_vlocation *vlocation =
528 list_entry(v, struct afs_vlocation, link);
529
530 /* display header on line 1 */
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700531 if (v == &cell->vl_list) {
David Howells08e0e7c2007-04-26 15:55:03 -0700532 seq_puts(m, "USE STT VLID[0] VLID[1] VLID[2] NAME\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 return 0;
534 }
535
536 /* display one cell per line on subsequent lines */
David Howells08e0e7c2007-04-26 15:55:03 -0700537 seq_printf(m, "%3d %s %08x %08x %08x %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 atomic_read(&vlocation->usage),
David Howells08e0e7c2007-04-26 15:55:03 -0700539 afs_vlocation_states[vlocation->state],
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 vlocation->vldb.vid[0],
541 vlocation->vldb.vid[1],
542 vlocation->vldb.vid[2],
David Howellsec268152007-04-26 15:49:28 -0700543 vlocation->vldb.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
545 return 0;
David Howellsec268152007-04-26 15:49:28 -0700546}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548/*
549 * open "/proc/fs/afs/<cell>/vlservers" which provides a list of volume
550 * location server
551 */
552static int afs_proc_cell_vlservers_open(struct inode *inode, struct file *file)
553{
554 struct afs_cell *cell;
555 struct seq_file *m;
556 int ret;
557
David Howells08e0e7c2007-04-26 15:55:03 -0700558 cell = PDE(inode)->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 if (!cell)
560 return -ENOENT;
561
David Howells08e0e7c2007-04-26 15:55:03 -0700562 ret = seq_open(file, &afs_proc_cell_vlservers_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 if (ret<0)
564 return ret;
565
566 m = file->private_data;
567 m->private = cell;
568
569 return 0;
David Howellsec268152007-04-26 15:49:28 -0700570}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572/*
573 * close the file and release the ref to the cell
574 */
575static int afs_proc_cell_vlservers_release(struct inode *inode,
576 struct file *file)
577{
David Howells08e0e7c2007-04-26 15:55:03 -0700578 return seq_release(inode, file);
David Howellsec268152007-04-26 15:49:28 -0700579}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581/*
582 * set up the iterator to start reading from the cells list and return the
583 * first item
584 */
585static void *afs_proc_cell_vlservers_start(struct seq_file *m, loff_t *_pos)
586{
587 struct afs_cell *cell = m->private;
588 loff_t pos = *_pos;
589
590 _enter("cell=%p pos=%Ld", cell, *_pos);
591
592 /* lock the list against modification */
593 down_read(&cell->vl_sem);
594
595 /* allow for the header line */
596 if (!pos)
597 return (void *) 1;
598 pos--;
599
600 if (pos >= cell->vl_naddrs)
601 return NULL;
602
603 return &cell->vl_addrs[pos];
David Howellsec268152007-04-26 15:49:28 -0700604}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606/*
607 * move to next cell in cells list
608 */
609static void *afs_proc_cell_vlservers_next(struct seq_file *p, void *v,
610 loff_t *_pos)
611{
612 struct afs_cell *cell = p->private;
613 loff_t pos;
614
615 _enter("cell=%p{nad=%u} pos=%Ld", cell, cell->vl_naddrs, *_pos);
616
617 pos = *_pos;
618 (*_pos)++;
619 if (pos >= cell->vl_naddrs)
620 return NULL;
621
622 return &cell->vl_addrs[pos];
David Howellsec268152007-04-26 15:49:28 -0700623}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625/*
626 * clean up after reading from the cells list
627 */
628static void afs_proc_cell_vlservers_stop(struct seq_file *p, void *v)
629{
630 struct afs_cell *cell = p->private;
631
632 up_read(&cell->vl_sem);
David Howellsec268152007-04-26 15:49:28 -0700633}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635/*
636 * display a header line followed by a load of volume lines
637 */
638static int afs_proc_cell_vlservers_show(struct seq_file *m, void *v)
639{
640 struct in_addr *addr = v;
641
642 /* display header on line 1 */
643 if (v == (struct in_addr *) 1) {
644 seq_puts(m, "ADDRESS\n");
645 return 0;
646 }
647
648 /* display one cell per line on subsequent lines */
Harvey Harrisonbe859402008-10-31 00:56:28 -0700649 seq_printf(m, "%pI4\n", &addr->s_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 return 0;
David Howellsec268152007-04-26 15:49:28 -0700651}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653/*
654 * open "/proc/fs/afs/<cell>/servers" which provides a summary of active
655 * servers
656 */
657static int afs_proc_cell_servers_open(struct inode *inode, struct file *file)
658{
659 struct afs_cell *cell;
660 struct seq_file *m;
661 int ret;
662
David Howells08e0e7c2007-04-26 15:55:03 -0700663 cell = PDE(inode)->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 if (!cell)
665 return -ENOENT;
666
667 ret = seq_open(file, &afs_proc_cell_servers_ops);
668 if (ret < 0)
669 return ret;
670
671 m = file->private_data;
672 m->private = cell;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 return 0;
David Howellsec268152007-04-26 15:49:28 -0700674}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676/*
677 * close the file and release the ref to the cell
678 */
679static int afs_proc_cell_servers_release(struct inode *inode,
680 struct file *file)
681{
David Howells08e0e7c2007-04-26 15:55:03 -0700682 return seq_release(inode, file);
David Howellsec268152007-04-26 15:49:28 -0700683}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685/*
686 * set up the iterator to start reading from the cells list and return the
687 * first item
688 */
689static void *afs_proc_cell_servers_start(struct seq_file *m, loff_t *_pos)
David Howells08e0e7c2007-04-26 15:55:03 -0700690 __acquires(m->private->servers_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 struct afs_cell *cell = m->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
694 _enter("cell=%p pos=%Ld", cell, *_pos);
695
696 /* lock the list against modification */
David Howells08e0e7c2007-04-26 15:55:03 -0700697 read_lock(&cell->servers_lock);
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700698 return seq_list_start_head(&cell->servers, *_pos);
David Howellsec268152007-04-26 15:49:28 -0700699}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701/*
702 * move to next cell in cells list
703 */
704static void *afs_proc_cell_servers_next(struct seq_file *p, void *v,
705 loff_t *_pos)
706{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 struct afs_cell *cell = p->private;
708
709 _enter("cell=%p pos=%Ld", cell, *_pos);
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700710 return seq_list_next(v, &cell->servers, _pos);
David Howellsec268152007-04-26 15:49:28 -0700711}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713/*
714 * clean up after reading from the cells list
715 */
716static void afs_proc_cell_servers_stop(struct seq_file *p, void *v)
David Howells08e0e7c2007-04-26 15:55:03 -0700717 __releases(p->private->servers_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718{
719 struct afs_cell *cell = p->private;
720
David Howells08e0e7c2007-04-26 15:55:03 -0700721 read_unlock(&cell->servers_lock);
David Howellsec268152007-04-26 15:49:28 -0700722}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724/*
725 * display a header line followed by a load of volume lines
726 */
727static int afs_proc_cell_servers_show(struct seq_file *m, void *v)
728{
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700729 struct afs_cell *cell = m->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 struct afs_server *server = list_entry(v, struct afs_server, link);
731 char ipaddr[20];
732
733 /* display header on line 1 */
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700734 if (v == &cell->servers) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 seq_puts(m, "USE ADDR STATE\n");
736 return 0;
737 }
738
739 /* display one cell per line on subsequent lines */
Harvey Harrisonbe859402008-10-31 00:56:28 -0700740 sprintf(ipaddr, "%pI4", &server->addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 seq_printf(m, "%3d %-15.15s %5d\n",
David Howellsec268152007-04-26 15:49:28 -0700742 atomic_read(&server->usage), ipaddr, server->fs_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743
744 return 0;
David Howellsec268152007-04-26 15:49:28 -0700745}