blob: 24a905b076fd77268c74978053afef93ba4ef5d9 [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
James Morris88e9d342009-09-22 16:43:43 -070031static const struct seq_operations afs_proc_cells_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 .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,
44};
45
Linus Torvalds1da177e2005-04-16 15:20:36 -070046static ssize_t afs_proc_rootcell_read(struct file *file, char __user *buf,
47 size_t size, loff_t *_pos);
48static ssize_t afs_proc_rootcell_write(struct file *file,
49 const char __user *buf,
50 size_t size, loff_t *_pos);
51
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -080052static const struct file_operations afs_proc_rootcell_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 .read = afs_proc_rootcell_read,
54 .write = afs_proc_rootcell_write,
55 .llseek = no_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -070056};
57
58static int afs_proc_cell_volumes_open(struct inode *inode, struct file *file);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059static void *afs_proc_cell_volumes_start(struct seq_file *p, loff_t *pos);
60static void *afs_proc_cell_volumes_next(struct seq_file *p, void *v,
61 loff_t *pos);
62static void afs_proc_cell_volumes_stop(struct seq_file *p, void *v);
63static int afs_proc_cell_volumes_show(struct seq_file *m, void *v);
64
James Morris88e9d342009-09-22 16:43:43 -070065static const struct seq_operations afs_proc_cell_volumes_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 .start = afs_proc_cell_volumes_start,
67 .next = afs_proc_cell_volumes_next,
68 .stop = afs_proc_cell_volumes_stop,
69 .show = afs_proc_cell_volumes_show,
70};
71
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -080072static const struct file_operations afs_proc_cell_volumes_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 .open = afs_proc_cell_volumes_open,
74 .read = seq_read,
75 .llseek = seq_lseek,
Al Virob42d5702013-11-22 01:53:47 -050076 .release = seq_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -070077};
78
79static int afs_proc_cell_vlservers_open(struct inode *inode,
80 struct file *file);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081static void *afs_proc_cell_vlservers_start(struct seq_file *p, loff_t *pos);
82static void *afs_proc_cell_vlservers_next(struct seq_file *p, void *v,
83 loff_t *pos);
84static void afs_proc_cell_vlservers_stop(struct seq_file *p, void *v);
85static int afs_proc_cell_vlservers_show(struct seq_file *m, void *v);
86
James Morris88e9d342009-09-22 16:43:43 -070087static const struct seq_operations afs_proc_cell_vlservers_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 .start = afs_proc_cell_vlservers_start,
89 .next = afs_proc_cell_vlservers_next,
90 .stop = afs_proc_cell_vlservers_stop,
91 .show = afs_proc_cell_vlservers_show,
92};
93
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -080094static const struct file_operations afs_proc_cell_vlservers_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 .open = afs_proc_cell_vlservers_open,
96 .read = seq_read,
97 .llseek = seq_lseek,
Al Virob42d5702013-11-22 01:53:47 -050098 .release = seq_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -070099};
100
101static int afs_proc_cell_servers_open(struct inode *inode, struct file *file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102static void *afs_proc_cell_servers_start(struct seq_file *p, loff_t *pos);
103static void *afs_proc_cell_servers_next(struct seq_file *p, void *v,
104 loff_t *pos);
105static void afs_proc_cell_servers_stop(struct seq_file *p, void *v);
106static int afs_proc_cell_servers_show(struct seq_file *m, void *v);
107
James Morris88e9d342009-09-22 16:43:43 -0700108static const struct seq_operations afs_proc_cell_servers_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 .start = afs_proc_cell_servers_start,
110 .next = afs_proc_cell_servers_next,
111 .stop = afs_proc_cell_servers_stop,
112 .show = afs_proc_cell_servers_show,
113};
114
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800115static const struct file_operations afs_proc_cell_servers_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 .open = afs_proc_cell_servers_open,
117 .read = seq_read,
118 .llseek = seq_lseek,
Al Virob42d5702013-11-22 01:53:47 -0500119 .release = seq_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120};
121
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122/*
123 * initialise the /proc/fs/afs/ directory
124 */
125int afs_proc_init(void)
126{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 _enter("");
128
129 proc_afs = proc_mkdir("fs/afs", NULL);
130 if (!proc_afs)
David Howellsec268152007-04-26 15:49:28 -0700131 goto error_dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
Pali Rohár1bda2ac2014-01-28 20:26:44 +0000133 if (!proc_create("cells", 0644, proc_afs, &afs_proc_cells_fops) ||
134 !proc_create("rootcell", 0644, proc_afs, &afs_proc_rootcell_fops))
Al Virob42d5702013-11-22 01:53:47 -0500135 goto error_tree;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
137 _leave(" = 0");
138 return 0;
139
Al Virob42d5702013-11-22 01:53:47 -0500140error_tree:
141 remove_proc_subtree("fs/afs", NULL);
David Howellsec268152007-04-26 15:49:28 -0700142error_dir:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 _leave(" = -ENOMEM");
144 return -ENOMEM;
David Howellsec268152007-04-26 15:49:28 -0700145}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147/*
148 * clean up the /proc/fs/afs/ directory
149 */
150void afs_proc_cleanup(void)
151{
Al Virob42d5702013-11-22 01:53:47 -0500152 remove_proc_subtree("fs/afs", NULL);
David Howellsec268152007-04-26 15:49:28 -0700153}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155/*
156 * open "/proc/fs/afs/cells" which provides a summary of extant cells
157 */
158static int afs_proc_cells_open(struct inode *inode, struct file *file)
159{
160 struct seq_file *m;
161 int ret;
162
163 ret = seq_open(file, &afs_proc_cells_ops);
164 if (ret < 0)
165 return ret;
166
167 m = file->private_data;
Al Virod9dda782013-03-31 18:16:14 -0400168 m->private = PDE_DATA(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
170 return 0;
David Howellsec268152007-04-26 15:49:28 -0700171}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173/*
174 * set up the iterator to start reading from the cells list and return the
175 * first item
176 */
177static void *afs_proc_cells_start(struct seq_file *m, loff_t *_pos)
178{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 /* lock the list against modification */
180 down_read(&afs_proc_cells_sem);
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700181 return seq_list_start_head(&afs_proc_cells, *_pos);
David Howellsec268152007-04-26 15:49:28 -0700182}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184/*
185 * move to next cell in cells list
186 */
187static void *afs_proc_cells_next(struct seq_file *p, void *v, loff_t *pos)
188{
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700189 return seq_list_next(v, &afs_proc_cells, pos);
David Howellsec268152007-04-26 15:49:28 -0700190}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192/*
193 * clean up after reading from the cells list
194 */
195static void afs_proc_cells_stop(struct seq_file *p, void *v)
196{
197 up_read(&afs_proc_cells_sem);
David Howellsec268152007-04-26 15:49:28 -0700198}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200/*
201 * display a header line followed by a load of cell lines
202 */
203static int afs_proc_cells_show(struct seq_file *m, void *v)
204{
205 struct afs_cell *cell = list_entry(v, struct afs_cell, proc_link);
206
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700207 if (v == &afs_proc_cells) {
David Howellsec268152007-04-26 15:49:28 -0700208 /* display header on line 1 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 seq_puts(m, "USE NAME\n");
210 return 0;
211 }
212
213 /* display one cell per line on subsequent lines */
David Howellsec268152007-04-26 15:49:28 -0700214 seq_printf(m, "%3d %s\n",
215 atomic_read(&cell->usage), cell->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 return 0;
David Howellsec268152007-04-26 15:49:28 -0700217}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219/*
220 * handle writes to /proc/fs/afs/cells
221 * - to add cells: echo "add <cellname> <IP>[:<IP>][:<IP>]"
222 */
223static ssize_t afs_proc_cells_write(struct file *file, const char __user *buf,
224 size_t size, loff_t *_pos)
225{
226 char *kbuf, *name, *args;
227 int ret;
228
229 /* start by dragging the command into memory */
230 if (size <= 1 || size >= PAGE_SIZE)
231 return -EINVAL;
232
233 kbuf = kmalloc(size + 1, GFP_KERNEL);
234 if (!kbuf)
235 return -ENOMEM;
236
237 ret = -EFAULT;
238 if (copy_from_user(kbuf, buf, size) != 0)
239 goto done;
240 kbuf[size] = 0;
241
242 /* trim to first NL */
243 name = memchr(kbuf, '\n', size);
244 if (name)
245 *name = 0;
246
247 /* split into command, name and argslist */
248 name = strchr(kbuf, ' ');
249 if (!name)
250 goto inval;
251 do {
252 *name++ = 0;
253 } while(*name == ' ');
254 if (!*name)
255 goto inval;
256
257 args = strchr(name, ' ');
258 if (!args)
259 goto inval;
260 do {
261 *args++ = 0;
262 } while(*args == ' ');
263 if (!*args)
264 goto inval;
265
266 /* determine command to perform */
267 _debug("cmd=%s name=%s args=%s", kbuf, name, args);
268
269 if (strcmp(kbuf, "add") == 0) {
270 struct afs_cell *cell;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
wangleibec5eb62010-08-11 09:38:04 +0100272 cell = afs_cell_create(name, strlen(name), args, false);
David Howells08e0e7c2007-04-26 15:55:03 -0700273 if (IS_ERR(cell)) {
274 ret = PTR_ERR(cell);
275 goto done;
276 }
277
278 afs_put_cell(cell);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 printk("kAFS: Added new cell '%s'\n", name);
David Howellsec268152007-04-26 15:49:28 -0700280 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 goto inval;
282 }
283
284 ret = size;
285
David Howellsec268152007-04-26 15:49:28 -0700286done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 kfree(kbuf);
288 _leave(" = %d", ret);
289 return ret;
290
David Howellsec268152007-04-26 15:49:28 -0700291inval:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 ret = -EINVAL;
293 printk("kAFS: Invalid Command on /proc/fs/afs/cells file\n");
294 goto done;
David Howellsec268152007-04-26 15:49:28 -0700295}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297static ssize_t afs_proc_rootcell_read(struct file *file, char __user *buf,
298 size_t size, loff_t *_pos)
299{
300 return 0;
301}
302
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303/*
304 * handle writes to /proc/fs/afs/rootcell
305 * - to initialize rootcell: echo "cell.name:192.168.231.14"
306 */
307static ssize_t afs_proc_rootcell_write(struct file *file,
308 const char __user *buf,
309 size_t size, loff_t *_pos)
310{
311 char *kbuf, *s;
312 int ret;
313
314 /* start by dragging the command into memory */
315 if (size <= 1 || size >= PAGE_SIZE)
316 return -EINVAL;
317
318 ret = -ENOMEM;
319 kbuf = kmalloc(size + 1, GFP_KERNEL);
320 if (!kbuf)
321 goto nomem;
322
323 ret = -EFAULT;
324 if (copy_from_user(kbuf, buf, size) != 0)
325 goto infault;
326 kbuf[size] = 0;
327
328 /* trim to first NL */
329 s = memchr(kbuf, '\n', size);
330 if (s)
331 *s = 0;
332
333 /* determine command to perform */
334 _debug("rootcell=%s", kbuf);
335
336 ret = afs_cell_init(kbuf);
337 if (ret >= 0)
338 ret = size; /* consume everything, always */
339
David Howellsec268152007-04-26 15:49:28 -0700340infault:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 kfree(kbuf);
David Howellsec268152007-04-26 15:49:28 -0700342nomem:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 _leave(" = %d", ret);
344 return ret;
David Howellsec268152007-04-26 15:49:28 -0700345}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347/*
348 * initialise /proc/fs/afs/<cell>/
349 */
350int afs_proc_cell_setup(struct afs_cell *cell)
351{
Al Virob42d5702013-11-22 01:53:47 -0500352 struct proc_dir_entry *dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
354 _enter("%p{%s}", cell, cell->name);
355
Al Virob42d5702013-11-22 01:53:47 -0500356 dir = proc_mkdir(cell->name, proc_afs);
357 if (!dir)
David Howellsec268152007-04-26 15:49:28 -0700358 goto error_dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359
Al Virob42d5702013-11-22 01:53:47 -0500360 if (!proc_create_data("servers", 0, dir,
361 &afs_proc_cell_servers_fops, cell) ||
362 !proc_create_data("vlservers", 0, dir,
363 &afs_proc_cell_vlservers_fops, cell) ||
364 !proc_create_data("volumes", 0, dir,
365 &afs_proc_cell_volumes_fops, cell))
366 goto error_tree;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367
368 _leave(" = 0");
369 return 0;
370
Al Virob42d5702013-11-22 01:53:47 -0500371error_tree:
372 remove_proc_subtree(cell->name, proc_afs);
David Howellsec268152007-04-26 15:49:28 -0700373error_dir:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 _leave(" = -ENOMEM");
375 return -ENOMEM;
David Howellsec268152007-04-26 15:49:28 -0700376}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378/*
379 * remove /proc/fs/afs/<cell>/
380 */
381void afs_proc_cell_remove(struct afs_cell *cell)
382{
383 _enter("");
384
Al Virob42d5702013-11-22 01:53:47 -0500385 remove_proc_subtree(cell->name, proc_afs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386
387 _leave("");
David Howellsec268152007-04-26 15:49:28 -0700388}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390/*
391 * open "/proc/fs/afs/<cell>/volumes" which provides a summary of extant cells
392 */
393static int afs_proc_cell_volumes_open(struct inode *inode, struct file *file)
394{
395 struct afs_cell *cell;
396 struct seq_file *m;
397 int ret;
398
Al Virod9dda782013-03-31 18:16:14 -0400399 cell = PDE_DATA(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 if (!cell)
401 return -ENOENT;
402
403 ret = seq_open(file, &afs_proc_cell_volumes_ops);
404 if (ret < 0)
405 return ret;
406
407 m = file->private_data;
408 m->private = cell;
409
410 return 0;
David Howellsec268152007-04-26 15:49:28 -0700411}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 * set up the iterator to start reading from the cells list and return the
415 * first item
416 */
417static void *afs_proc_cell_volumes_start(struct seq_file *m, loff_t *_pos)
418{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 struct afs_cell *cell = m->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
421 _enter("cell=%p pos=%Ld", cell, *_pos);
422
423 /* lock the list against modification */
424 down_read(&cell->vl_sem);
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700425 return seq_list_start_head(&cell->vl_list, *_pos);
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 * move to next cell in cells list
430 */
431static void *afs_proc_cell_volumes_next(struct seq_file *p, void *v,
432 loff_t *_pos)
433{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 struct afs_cell *cell = p->private;
435
436 _enter("cell=%p pos=%Ld", cell, *_pos);
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700437 return seq_list_next(v, &cell->vl_list, _pos);
David Howellsec268152007-04-26 15:49:28 -0700438}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440/*
441 * clean up after reading from the cells list
442 */
443static void afs_proc_cell_volumes_stop(struct seq_file *p, void *v)
444{
445 struct afs_cell *cell = p->private;
446
447 up_read(&cell->vl_sem);
David Howellsec268152007-04-26 15:49:28 -0700448}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449
Adrian Bunkc1206a22007-10-16 23:26:41 -0700450static const char afs_vlocation_states[][4] = {
David Howells08e0e7c2007-04-26 15:55:03 -0700451 [AFS_VL_NEW] = "New",
452 [AFS_VL_CREATING] = "Crt",
453 [AFS_VL_VALID] = "Val",
454 [AFS_VL_NO_VOLUME] = "NoV",
455 [AFS_VL_UPDATING] = "Upd",
456 [AFS_VL_VOLUME_DELETED] = "Del",
457 [AFS_VL_UNCERTAIN] = "Unc",
458};
459
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460/*
461 * display a header line followed by a load of volume lines
462 */
463static int afs_proc_cell_volumes_show(struct seq_file *m, void *v)
464{
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700465 struct afs_cell *cell = m->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 struct afs_vlocation *vlocation =
467 list_entry(v, struct afs_vlocation, link);
468
469 /* display header on line 1 */
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700470 if (v == &cell->vl_list) {
David Howells08e0e7c2007-04-26 15:55:03 -0700471 seq_puts(m, "USE STT VLID[0] VLID[1] VLID[2] NAME\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 return 0;
473 }
474
475 /* display one cell per line on subsequent lines */
David Howells08e0e7c2007-04-26 15:55:03 -0700476 seq_printf(m, "%3d %s %08x %08x %08x %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 atomic_read(&vlocation->usage),
David Howells08e0e7c2007-04-26 15:55:03 -0700478 afs_vlocation_states[vlocation->state],
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 vlocation->vldb.vid[0],
480 vlocation->vldb.vid[1],
481 vlocation->vldb.vid[2],
David Howellsec268152007-04-26 15:49:28 -0700482 vlocation->vldb.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
484 return 0;
David Howellsec268152007-04-26 15:49:28 -0700485}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487/*
488 * open "/proc/fs/afs/<cell>/vlservers" which provides a list of volume
489 * location server
490 */
491static int afs_proc_cell_vlservers_open(struct inode *inode, struct file *file)
492{
493 struct afs_cell *cell;
494 struct seq_file *m;
495 int ret;
496
Al Virod9dda782013-03-31 18:16:14 -0400497 cell = PDE_DATA(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 if (!cell)
499 return -ENOENT;
500
David Howells08e0e7c2007-04-26 15:55:03 -0700501 ret = seq_open(file, &afs_proc_cell_vlservers_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 if (ret<0)
503 return ret;
504
505 m = file->private_data;
506 m->private = cell;
507
508 return 0;
David Howellsec268152007-04-26 15:49:28 -0700509}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 * set up the iterator to start reading from the cells list and return the
513 * first item
514 */
515static void *afs_proc_cell_vlservers_start(struct seq_file *m, loff_t *_pos)
516{
517 struct afs_cell *cell = m->private;
518 loff_t pos = *_pos;
519
520 _enter("cell=%p pos=%Ld", cell, *_pos);
521
522 /* lock the list against modification */
523 down_read(&cell->vl_sem);
524
525 /* allow for the header line */
526 if (!pos)
527 return (void *) 1;
528 pos--;
529
530 if (pos >= cell->vl_naddrs)
531 return NULL;
532
533 return &cell->vl_addrs[pos];
David Howellsec268152007-04-26 15:49:28 -0700534}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536/*
537 * move to next cell in cells list
538 */
539static void *afs_proc_cell_vlservers_next(struct seq_file *p, void *v,
540 loff_t *_pos)
541{
542 struct afs_cell *cell = p->private;
543 loff_t pos;
544
545 _enter("cell=%p{nad=%u} pos=%Ld", cell, cell->vl_naddrs, *_pos);
546
547 pos = *_pos;
548 (*_pos)++;
549 if (pos >= cell->vl_naddrs)
550 return NULL;
551
552 return &cell->vl_addrs[pos];
David Howellsec268152007-04-26 15:49:28 -0700553}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555/*
556 * clean up after reading from the cells list
557 */
558static void afs_proc_cell_vlservers_stop(struct seq_file *p, void *v)
559{
560 struct afs_cell *cell = p->private;
561
562 up_read(&cell->vl_sem);
David Howellsec268152007-04-26 15:49:28 -0700563}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565/*
566 * display a header line followed by a load of volume lines
567 */
568static int afs_proc_cell_vlservers_show(struct seq_file *m, void *v)
569{
570 struct in_addr *addr = v;
571
572 /* display header on line 1 */
573 if (v == (struct in_addr *) 1) {
574 seq_puts(m, "ADDRESS\n");
575 return 0;
576 }
577
578 /* display one cell per line on subsequent lines */
Harvey Harrisonbe859402008-10-31 00:56:28 -0700579 seq_printf(m, "%pI4\n", &addr->s_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 return 0;
David Howellsec268152007-04-26 15:49:28 -0700581}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583/*
584 * open "/proc/fs/afs/<cell>/servers" which provides a summary of active
585 * servers
586 */
587static int afs_proc_cell_servers_open(struct inode *inode, struct file *file)
588{
589 struct afs_cell *cell;
590 struct seq_file *m;
591 int ret;
592
Al Virod9dda782013-03-31 18:16:14 -0400593 cell = PDE_DATA(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 if (!cell)
595 return -ENOENT;
596
597 ret = seq_open(file, &afs_proc_cell_servers_ops);
598 if (ret < 0)
599 return ret;
600
601 m = file->private_data;
602 m->private = cell;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 return 0;
David Howellsec268152007-04-26 15:49:28 -0700604}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 * set up the iterator to start reading from the cells list and return the
608 * first item
609 */
610static void *afs_proc_cell_servers_start(struct seq_file *m, loff_t *_pos)
David Howells08e0e7c2007-04-26 15:55:03 -0700611 __acquires(m->private->servers_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 struct afs_cell *cell = m->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
615 _enter("cell=%p pos=%Ld", cell, *_pos);
616
617 /* lock the list against modification */
David Howells08e0e7c2007-04-26 15:55:03 -0700618 read_lock(&cell->servers_lock);
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700619 return seq_list_start_head(&cell->servers, *_pos);
David Howellsec268152007-04-26 15:49:28 -0700620}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622/*
623 * move to next cell in cells list
624 */
625static void *afs_proc_cell_servers_next(struct seq_file *p, void *v,
626 loff_t *_pos)
627{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 struct afs_cell *cell = p->private;
629
630 _enter("cell=%p pos=%Ld", cell, *_pos);
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700631 return seq_list_next(v, &cell->servers, _pos);
David Howellsec268152007-04-26 15:49:28 -0700632}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634/*
635 * clean up after reading from the cells list
636 */
637static void afs_proc_cell_servers_stop(struct seq_file *p, void *v)
David Howells08e0e7c2007-04-26 15:55:03 -0700638 __releases(p->private->servers_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639{
640 struct afs_cell *cell = p->private;
641
David Howells08e0e7c2007-04-26 15:55:03 -0700642 read_unlock(&cell->servers_lock);
David Howellsec268152007-04-26 15:49:28 -0700643}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645/*
646 * display a header line followed by a load of volume lines
647 */
648static int afs_proc_cell_servers_show(struct seq_file *m, void *v)
649{
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700650 struct afs_cell *cell = m->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 struct afs_server *server = list_entry(v, struct afs_server, link);
652 char ipaddr[20];
653
654 /* display header on line 1 */
Pavel Emelianova6a8bd62007-07-15 23:39:52 -0700655 if (v == &cell->servers) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 seq_puts(m, "USE ADDR STATE\n");
657 return 0;
658 }
659
660 /* display one cell per line on subsequent lines */
Harvey Harrisonbe859402008-10-31 00:56:28 -0700661 sprintf(ipaddr, "%pI4", &server->addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 seq_printf(m, "%3d %-15.15s %5d\n",
David Howellsec268152007-04-26 15:49:28 -0700663 atomic_read(&server->usage), ipaddr, server->fs_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
665 return 0;
David Howellsec268152007-04-26 15:49:28 -0700666}