fs/coda/sysctl.c

   1 /*
   2  * Sysctl operations for Coda filesystem
   3  * Original version: (C) 1996 P. Braam and M. Callahan
   4  * Rewritten for Linux 2.1. (C) 1997 Carnegie Mellon University
   5  *
   6  * Carnegie Mellon encourages users to contribute improvements to
   7  * the Coda project. Contact Peter Braam (coda@cs.cmu.edu).
   8  *
   9  * CODA operation statistics
  10  * (c) March, 1998 Zhanyong Wan <zhanyong.wan@yale.edu>
  11  *
  12  */
  13
  14 #include <linux/time.h>
  15 #include <linux/mm.h>
  16 #include <linux/sysctl.h>
  17 #include <linux/proc_fs.h>
  18 #include <linux/slab.h>
  19 #include <linux/stat.h>
  20 #include <linux/ctype.h>
  21 #include <linux/bitops.h>
  22 #include <asm/uaccess.h>
  23 #include <linux/utsname.h>
  24 #include <linux/module.h>
  25
  26 #include <linux/coda.h>
  27 #include <linux/coda_linux.h>
  28 #include <linux/coda_fs_i.h>
  29 #include <linux/coda_psdev.h>
  30 #include <linux/coda_cache.h>
  31 #include <linux/coda_proc.h>
  32
  33 static struct ctl_table_header *fs_table_header;
  34
  35 #define FS_CODA         1       /* Coda file system */
  36
  37 #define CODA_TIMEOUT    3       /* timeout on upcalls to become intrble */
  38 #define CODA_HARD       5       /* mount type "hard" or "soft" */
  39 #define CODA_VFS         6       /* vfs statistics */
  40 #define CODA_CACHE_INV   9       /* cache invalidation statistics */
  41 #define CODA_FAKE_STATFS 10      /* don't query venus for actual cache usage */
  42
  43 struct coda_vfs_stats           coda_vfs_stat;
  44 static struct coda_cache_inv_stats      coda_cache_inv_stat;
  45
  46 static void reset_coda_vfs_stats( void )
  47 {
  48         memset( &coda_vfs_stat, 0, sizeof( coda_vfs_stat ) );
  49 }
  50
  51 static void reset_coda_cache_inv_stats( void )
  52 {
  53         memset( &coda_cache_inv_stat, 0, sizeof( coda_cache_inv_stat ) );
  54 }
  55
  56 static int do_reset_coda_vfs_stats( ctl_table * table, int write,
  57                                     struct file * filp, void __user * buffer,
  58                                     size_t * lenp, loff_t * ppos )
  59 {
  60         if ( write ) {
  61                 reset_coda_vfs_stats();
  62
  63                 *ppos += *lenp;
  64         } else {
  65                 *lenp = 0;
  66         }
  67
  68         return 0;
  69 }
  70
  71 static int do_reset_coda_cache_inv_stats( ctl_table * table, int write,
  72                                           struct file * filp,
  73                                           void __user * buffer,
  74                                           size_t * lenp, loff_t * ppos )
  75 {
  76         if ( write ) {
  77                 reset_coda_cache_inv_stats();
  78
  79                 *ppos += *lenp;
  80         } else {
  81                 *lenp = 0;
  82         }
  83
  84         return 0;
  85 }
  86
  87 static int coda_vfs_stats_get_info( char * buffer, char ** start,
  88                                     off_t offset, int length)
  89 {
  90         int len=0;
  91         off_t begin;
  92         struct coda_vfs_stats * ps = & coda_vfs_stat;
  93
  94   /* this works as long as we are below 1024 characters! */
  95         len += sprintf( buffer,
  96                         "Coda VFS statistics\n"
  97                         "===================\n\n"
  98                         "File Operations:\n"
  99                         "\topen\t\t%9d\n"
 100                         "\tflush\t\t%9d\n"
 101                         "\trelease\t\t%9d\n"
 102                         "\tfsync\t\t%9d\n\n"
 103                         "Dir Operations:\n"
 104                         "\treaddir\t\t%9d\n\n"
 105                         "Inode Operations\n"
 106                         "\tcreate\t\t%9d\n"
 107                         "\tlookup\t\t%9d\n"
 108                         "\tlink\t\t%9d\n"
 109                         "\tunlink\t\t%9d\n"
 110                         "\tsymlink\t\t%9d\n"
 111                         "\tmkdir\t\t%9d\n"
 112                         "\trmdir\t\t%9d\n"
 113                         "\trename\t\t%9d\n"
 114                         "\tpermission\t%9d\n",
 115
 116                         /* file operations */
 117                         ps->open,
 118                         ps->flush,
 119                         ps->release,
 120                         ps->fsync,
 121
 122                         /* dir operations */
 123                         ps->readdir,
 124
 125                         /* inode operations */
 126                         ps->create,
 127                         ps->lookup,
 128                         ps->link,
 129                         ps->unlink,
 130                         ps->symlink,
 131                         ps->mkdir,
 132                         ps->rmdir,
 133                         ps->rename,
 134                         ps->permission);
 135
 136         begin = offset;
 137         *start = buffer + begin;
 138         len -= begin;
 139
 140         if ( len > length )
 141                 len = length;
 142         if ( len < 0 )
 143                 len = 0;
 144
 145         return len;
 146 }
 147
 148 static int coda_cache_inv_stats_get_info( char * buffer, char ** start,
 149                                           off_t offset, int length)
 150 {
 151         int len=0;
 152         off_t begin;
 153         struct coda_cache_inv_stats * ps = & coda_cache_inv_stat;
 154
 155         /* this works as long as we are below 1024 characters! */
 156         len += sprintf( buffer,
 157                         "Coda cache invalidation statistics\n"
 158                         "==================================\n\n"
 159                         "flush\t\t%9d\n"
 160                         "purge user\t%9d\n"
 161                         "zap_dir\t\t%9d\n"
 162                         "zap_file\t%9d\n"
 163                         "zap_vnode\t%9d\n"
 164                         "purge_fid\t%9d\n"
 165                         "replace\t\t%9d\n",
 166                         ps->flush,
 167                         ps->purge_user,
 168                         ps->zap_dir,
 169                         ps->zap_file,
 170                         ps->zap_vnode,
 171                         ps->purge_fid,
 172                         ps->replace );
 173
 174         begin = offset;
 175         *start = buffer + begin;
 176         len -= begin;
 177
 178         if ( len > length )
 179                 len = length;
 180         if ( len < 0 )
 181                 len = 0;
 182
 183         return len;
 184 }
 185
 186 static ctl_table coda_table[] = {
 187         {CODA_TIMEOUT, "timeout", &coda_timeout, sizeof(int), 0644, NULL, &proc_dointvec},
 188         {CODA_HARD, "hard", &coda_hard, sizeof(int), 0644, NULL, &proc_dointvec},
 189         {CODA_VFS, "vfs_stats", NULL, 0, 0644, NULL, &do_reset_coda_vfs_stats},
 190         {CODA_CACHE_INV, "cache_inv_stats", NULL, 0, 0644, NULL, &do_reset_coda_cache_inv_stats},
 191         {CODA_FAKE_STATFS, "fake_statfs", &coda_fake_statfs, sizeof(int), 0600, NULL, &proc_dointvec},
 192         { 0 }
 193 };
 194
 195 static ctl_table fs_table[] = {
 196        {FS_CODA, "coda",    NULL, 0, 0555, coda_table},
 197        {0}
 198 };
 199
 200
 201 #ifdef CONFIG_PROC_FS
 202
 203 /*
 204  target directory structure:
 205    /proc/fs  (see linux/fs/proc/root.c)
 206    /proc/fs/coda
 207    /proc/fs/coda/{vfs_stats,
 208
 209 */
 210
 211 static struct proc_dir_entry* proc_fs_coda;
 212
 213 #endif
 214
 215 #define coda_proc_create(name,get_info) \
 216         create_proc_info_entry(name, 0, proc_fs_coda, get_info)
 217
 218 void coda_sysctl_init(void)
 219 {
 220         reset_coda_vfs_stats();
 221         reset_coda_cache_inv_stats();
 222
 223 #ifdef CONFIG_PROC_FS
 224         proc_fs_coda = proc_mkdir("coda", proc_root_fs);
 225         if (proc_fs_coda) {
 226                 proc_fs_coda->owner = THIS_MODULE;
 227                 coda_proc_create("vfs_stats", coda_vfs_stats_get_info);
 228                 coda_proc_create("cache_inv_stats", coda_cache_inv_stats_get_info);
 229         }
 230 #endif
 231
 232 #ifdef CONFIG_SYSCTL
 233         if ( !fs_table_header )
 234                 fs_table_header = register_sysctl_table(fs_table, 0);
 235 #endif
 236 }
 237
 238 void coda_sysctl_clean(void)
 239 {
 240
 241 #ifdef CONFIG_SYSCTL
 242         if ( fs_table_header ) {
 243                 unregister_sysctl_table(fs_table_header);
 244                 fs_table_header = NULL;
 245         }
 246 #endif
 247
 248 #ifdef CONFIG_PROC_FS
 249         remove_proc_entry("cache_inv_stats", proc_fs_coda);
 250         remove_proc_entry("vfs_stats", proc_fs_coda);
 251         remove_proc_entry("coda", proc_root_fs);
 252 #endif
 253 }