fs/afs/proc.c

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