lustre/obdclass/lprocfs_status.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  Copyright (C) 2002 Cluster File Systems, Inc.
   5  *
   6  *   This file is part of Lustre, http://www.lustre.org.
   7  *
   8  *   Lustre is free software; you can redistribute it and/or
   9  *   modify it under the terms of version 2 of the GNU General Public
  10  *   License as published by the Free Software Foundation.
  11  *
  12  *   Lustre is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with Lustre; if not, write to the Free Software
  19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  *   Author: Hariharan Thantry thantry@users.sourceforge.net
  22  */
  23 #define EXPORT_SYMTAB
  24 #include <linux/config.h>
  25 #include <linux/module.h>
  26 #include <linux/version.h>
  27 #include <linux/proc_fs.h>
  28 #include <linux/slab.h>
  29 #include <linux/types.h>
  30
  31 #define DEBUG_SUBSYSTEM S_CLASS
  32 #include <linux/lustre_lite.h>
  33 #include <linux/lprocfs_status.h>
  34
  35 #ifdef LPROC_SNMP
  36
  37 #define DEFAULT_MODE 0444
  38 /*
  39  * Tokenizer array. Change this array to include special
  40  * characters for string tokenizing
  41  */
  42 const char tok[] = {'/', '\0'};
  43
  44 /*
  45  * Externs
  46  */
  47 extern struct proc_dir_entry proc_root; /* Defined in proc/root.c */
  48
  49 /*
  50  * Globals
  51  */
  52 struct proc_dir_entry *proc_lustre_root;
  53 struct proc_dir_entry *proc_lustre_dev_root;
  54 struct proc_dir_entry *proc_lustre_fs_root;
  55
  56 struct proc_dir_entry* lprocfs_mkdir(const char* dname,
  57                                      struct proc_dir_entry *parent)
  58 {
  59         struct proc_dir_entry *child_dir_entry;
  60         child_dir_entry = proc_mkdir(dname, parent);
  61         if (!child_dir_entry)
  62                 CERROR("lustre: failed to create /proc entry %s\n", dname);
  63         return child_dir_entry;
  64 }
  65
  66 struct proc_dir_entry* lprocfs_srch(struct proc_dir_entry* head,
  67                                     const char* name)
  68 {
  69         struct proc_dir_entry* temp;
  70         if (!head)
  71                 return NULL;
  72         temp = head->subdir;
  73         while (temp != NULL) {
  74                 if (!strcmp(temp->name, name))
  75                         return temp;
  76                 temp = temp->next;
  77         }
  78         return NULL;
  79 }
  80
  81 void lprocfs_remove_all(struct proc_dir_entry* root)
  82 {
  83         struct proc_dir_entry *temp = root;
  84         struct proc_dir_entry *rm_entry;
  85         struct proc_dir_entry *parent = root->parent;
  86
  87         while (1) {
  88                 while (temp->subdir)
  89                         temp = temp->subdir;
  90
  91                 rm_entry = temp;
  92                 temp = temp->parent;
  93                 remove_proc_entry(rm_entry->name, rm_entry->parent);
  94                 if (temp == parent) break;
  95         }
  96 }
  97
  98 #define MAX_STRING_SIZE 100
  99 struct proc_dir_entry* lprocfs_new_dir(struct proc_dir_entry* root,
 100                                        const char* string, const char* tok)
 101 {
 102         struct proc_dir_entry* new_root;
 103         struct proc_dir_entry* temp_entry;
 104         char temp_string[MAX_STRING_SIZE];
 105         char* my_str;
 106         char* mover_str;
 107
 108         strncpy(temp_string, string, MAX_STRING_SIZE-1);
 109         temp_string[MAX_STRING_SIZE] = '\0';
 110
 111         new_root = root;
 112         mover_str = temp_string;
 113         while ((my_str = strsep(&mover_str, tok))) {
 114                 if(!*my_str)
 115                         continue;
 116                 CDEBUG(D_OTHER, "SEARCH= %s\t, ROOT=%s\n", my_str,
 117                        new_root->name);
 118                 temp_entry = lprocfs_srch(new_root, my_str);
 119                 if (temp_entry == NULL) {
 120                         CDEBUG(D_OTHER, "Adding: %s\n", my_str);
 121                         temp_entry = lprocfs_mkdir(my_str, new_root);
 122                         if (temp_entry == NULL) {
 123                                 CDEBUG(D_OTHER,
 124                                        "! Did not create new dir %s !!\n",
 125                                        my_str);
 126                                 return temp_entry;
 127                         }
 128                 }
 129                 new_root = temp_entry;
 130         }
 131         return new_root;
 132 }
 133
 134 int lprocfs_new_vars(struct proc_dir_entry* root,
 135                      struct lprocfs_vars* list,
 136                      const char* tok, void* data)
 137 {
 138         struct proc_dir_entry *temp_root;
 139         struct proc_dir_entry *new_leaf;
 140         struct proc_dir_entry *new_parent;
 141         char temp_string[MAX_STRING_SIZE];
 142
 143         if (list == NULL)
 144                 return 0;
 145
 146         while (list->name) {
 147                 temp_root = lprocfs_new_dir(root, list->name, tok);
 148                 if (temp_root == NULL) {
 149                         CDEBUG(D_OTHER, "!LProcFS: Mods: No root!");
 150                         return -EINVAL;
 151                 }
 152
 153                 /* Convert the last element into a leaf-node */
 154                 strncpy(temp_string, temp_root->name, MAX_STRING_SIZE-1);
 155                 temp_string[MAX_STRING_SIZE] = '\0';
 156                 new_parent = temp_root->parent;
 157                 remove_proc_entry(temp_root->name, new_parent);
 158                 new_leaf = create_proc_entry(temp_string, DEFAULT_MODE,
 159                                              new_parent);
 160                 new_leaf->read_proc = list->read_fptr;
 161                 new_leaf->write_proc = list->write_fptr;
 162                 if (data)
 163                         new_leaf->data=data;
 164                 else
 165                         new_leaf->data=list->data;
 166                 list++;
 167         }
 168         return 0;
 169
 170 }
 171 #undef MAX_STRING_SIZE
 172 /*
 173  *  API implementations
 174  */
 175 int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *var,
 176                      void *data)
 177 {
 178         return lprocfs_new_vars(root, var, tok, data);
 179 }
 180
 181 int lprocfs_reg_obd(struct obd_device *device, struct lprocfs_vars *list,
 182                     void *data)
 183 {
 184         struct proc_dir_entry* this_dev_root;
 185         int retval;
 186
 187         if(lprocfs_srch(device->obd_type->typ_procroot, device->obd_name)){
 188                 CDEBUG(D_OTHER, "Device with name [%s] exists!",
 189                                 device->obd_name);
 190                 return 0;
 191         }
 192
 193         /* Obtain this device root */
 194         this_dev_root = lprocfs_mkdir(device->obd_name,
 195                                       device->obd_type->typ_procroot);
 196
 197         device->obd_proc_entry = this_dev_root;
 198         retval = lprocfs_add_vars(this_dev_root, list, data);
 199
 200         return retval;
 201 }
 202
 203 int lprocfs_dereg_obd(struct obd_device* device)
 204 {
 205         CDEBUG(D_OTHER, "LPROCFS removing device = %s\n", device->obd_name);
 206
 207         if (device == NULL) {
 208                 CDEBUG(D_OTHER, "! LProcfs:  Null pointer !\n");
 209                 return 0;
 210         }
 211         if (device->obd_proc_entry == NULL) {
 212                 CDEBUG(D_OTHER, "! Proc entry non-existent !");
 213                 return 0;
 214         }
 215         lprocfs_remove_all(device->obd_proc_entry);
 216         device->obd_proc_entry = NULL;
 217         if (device->counters)
 218                 OBD_FREE(device->counters, device->cntr_mem_size);
 219
 220         return 0;
 221 }
 222
 223 struct proc_dir_entry* lprocfs_reg_mnt(char* mnt_name)
 224 {
 225         if(lprocfs_srch(proc_lustre_fs_root, mnt_name)){
 226                 CDEBUG(D_OTHER, "Mount with same name exists!");
 227                 return 0;
 228         }
 229         return lprocfs_mkdir(mnt_name, proc_lustre_fs_root);
 230 }
 231
 232 int lprocfs_dereg_mnt(struct proc_dir_entry* root)
 233 {
 234         if(root == NULL){
 235                 CDEBUG(D_OTHER, "Non-existent root!");
 236                 return 0;
 237         }
 238         lprocfs_remove_all(root);
 239         return 0;
 240 }
 241
 242 int lprocfs_reg_class(struct obd_type* type, struct lprocfs_vars* list,
 243                       void* data)
 244 {
 245
 246         struct proc_dir_entry* root;
 247         int retval;
 248         root = lprocfs_mkdir(type->typ_name, proc_lustre_dev_root);
 249         lprocfs_add_vars(root, list, data);
 250         type->typ_procroot = root;
 251         retval = lprocfs_add_vars(root, list, data);
 252         return retval;
 253 }
 254
 255 int lprocfs_dereg_class(struct obd_type* class)
 256 {
 257         if(class == NULL){
 258                 CDEBUG(D_OTHER, "Non-existent class",
 259                        class->typ_name);
 260                 return 0;
 261         }
 262         lprocfs_remove_all(class->typ_procroot);
 263         class->typ_procroot = NULL;
 264         CDEBUG(D_OTHER, "LPROCFS removed = %s\n", class->typ_name);
 265         return 0;
 266
 267 }
 268 int lprocfs_reg_main()
 269 {
 270         proc_lustre_root = lprocfs_mkdir("lustre", &proc_root);
 271         if (proc_lustre_root == NULL) {
 272                 CERROR(" !! Cannot create /proc/lustre !! \n");
 273                 return -EINVAL;
 274         }
 275
 276         proc_lustre_dev_root = lprocfs_mkdir("devices", proc_lustre_root);
 277         if (proc_lustre_dev_root == NULL) {
 278                 CERROR(" !! Cannot create /proc/lustre/devices !! \n");
 279                 return -EINVAL;
 280         }
 281         proc_lustre_fs_root = lprocfs_mkdir("mnt_pnt", proc_lustre_root);
 282
 283         if (proc_lustre_fs_root == NULL) {
 284                 CERROR(" !! Cannot create /proc/lustre/mnt_pnt !! \n");
 285                 return -EINVAL;
 286         }
 287
 288         return 0;
 289 }
 290
 291 int lprocfs_dereg_main()
 292 {
 293         lprocfs_remove_all(proc_lustre_root);
 294         proc_lustre_root = NULL;
 295         proc_lustre_dev_root = NULL;
 296         proc_lustre_fs_root = NULL;
 297         return 0;
 298 }
 299
 300
 301 /*
 302  * Needs to go...
 303  */
 304 int lprocfs_ll_rd(char *page, char **start, off_t off,
 305                   int count, int *eof, void *data)
 306 {
 307         __u64 *temp = (__u64 *)data;
 308         int len;
 309         len = snprintf(page, count, LPU64"\n", *temp);
 310         return len;
 311 }
 312
 313 #endif /* LPROC_SNMP */
 314
 315 EXPORT_SYMBOL(lprocfs_reg_obd);
 316 EXPORT_SYMBOL(lprocfs_dereg_obd);
 317 EXPORT_SYMBOL(lprocfs_reg_main);
 318 EXPORT_SYMBOL(lprocfs_dereg_main);
 319 EXPORT_SYMBOL(lprocfs_reg_mnt);
 320 EXPORT_SYMBOL(lprocfs_dereg_mnt);
 321 EXPORT_SYMBOL(lprocfs_add_vars);
 322 EXPORT_SYMBOL(lprocfs_reg_class);
 323 EXPORT_SYMBOL(lprocfs_dereg_class);
 324 EXPORT_SYMBOL(lprocfs_ll_rd);
 325
 326