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/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() */