libcfs/include/libcfs/params_tree.h

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * GPL HEADER START
   5  *
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License version 2 for more details (a copy is included
  16  * in the LICENSE file that accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * version 2 along with this program; If not, see
  20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  21  *
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *
  26  * GPL HEADER END
  27  */
  28 /*
  29  * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
  30  * Use is subject to license terms.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  *
  36  * API and structure definitions for params_tree.
  37  *
  38  * Author: LiuYing <emoly.liu@oracle.com>
  39  */
  40 #ifndef __PARAMS_TREE_H__
  41 #define __PARAMS_TREE_H__
  42
  43 #ifndef EXPORT_SYMTAB
  44 # define EXPORT_SYMTAB
  45 #endif
  46
  47 #include <libcfs/libcfs.h>
  48
  49 #undef LPROCFS
  50 #if (defined(__KERNEL__) && defined(CONFIG_PROC_FS))
  51 # define LPROCFS
  52 #endif
  53
  54 #ifdef LPROCFS
  55 typedef struct file                             cfs_param_file_t;
  56 typedef struct inode                            cfs_inode_t;
  57 typedef struct proc_inode                       cfs_proc_inode_t;
  58 typedef struct seq_file                         cfs_seq_file_t;
  59 typedef struct seq_operations                   cfs_seq_ops_t;
  60 typedef struct file_operations                  cfs_param_file_ops_t;
  61 typedef cfs_module_t                           *cfs_param_module_t;
  62 typedef struct proc_dir_entry                   cfs_param_dentry_t;
  63 typedef struct poll_table_struct                cfs_poll_table_t;
  64 #define CFS_PARAM_MODULE                        THIS_MODULE
  65 #define CFS_PDE(value)                          PDE(value)
  66 #define cfs_file_private(file)                  (file->private_data)
  67 #define cfs_dentry_data(dentry)                 (dentry->data)
  68 #define cfs_proc_inode_pde(proc_inode)          (proc_inode->pde)
  69 #define cfs_proc_inode(proc_inode)              (proc_inode->vfs_inode)
  70 #define cfs_seq_read_common                     seq_read
  71 #define cfs_seq_lseek_common                    seq_lseek
  72 #define cfs_seq_private(seq)                    (seq->private)
  73 #define cfs_seq_printf(seq, format, ...)        seq_printf(seq, format,  \
  74                                                            ## __VA_ARGS__)
  75 #define cfs_seq_release(inode, file)            seq_release(inode, file)
  76 #define cfs_seq_puts(seq, s)                    seq_puts(seq, s)
  77 #define cfs_seq_putc(seq, s)                    seq_putc(seq, s)
  78 #define cfs_seq_read(file, buf, count, ppos, rc) (rc = seq_read(file, buf, \
  79                                                             count, ppos))
  80 #define cfs_seq_open(file, ops, rc)             (rc = seq_open(file, ops))
  81
  82 /* in lprocfs_stat.c, to protect the private data for proc entries */
  83 extern cfs_rw_semaphore_t       _lprocfs_lock;
  84 #define LPROCFS_ENTRY()                 \
  85 do {                                    \
  86         cfs_down_read(&_lprocfs_lock);  \
  87 } while(0)
  88 #define LPROCFS_EXIT()                  \
  89 do {                                    \
  90         cfs_up_read(&_lprocfs_lock);    \
  91 } while(0)
  92
  93 #ifdef HAVE_PROCFS_DELETED
  94 static inline
  95 int LPROCFS_ENTRY_AND_CHECK(struct proc_dir_entry *dp)
  96 {
  97         LPROCFS_ENTRY();
  98         if ((dp)->deleted) {
  99                 LPROCFS_EXIT();
 100                 return -ENODEV;
 101         }
 102         return 0;
 103 }
 104 #else /* !HAVE_PROCFS_DELETED*/
 105 static inline
 106 int LPROCFS_ENTRY_AND_CHECK(struct proc_dir_entry *dp)
 107 {
 108         LPROCFS_ENTRY();
 109         return 0;
 110 }
 111 #endif /* HAVE_PROCFS_DELETED */
 112
 113 #define LPROCFS_WRITE_ENTRY()           \
 114 do {                                    \
 115         cfs_down_write(&_lprocfs_lock); \
 116 } while(0)
 117 #define LPROCFS_WRITE_EXIT()            \
 118 do {                                    \
 119         cfs_up_write(&_lprocfs_lock);   \
 120 } while(0)
 121
 122 #else /* !LPROCFS */
 123
 124 typedef struct cfs_params_file {
 125         void           *param_private;
 126         loff_t          param_pos;
 127         unsigned int    param_flags;
 128 } cfs_param_file_t;
 129
 130 typedef struct cfs_param_inode {
 131         void    *param_private;
 132 } cfs_inode_t;
 133
 134 typedef struct cfs_param_dentry {
 135         void *param_data;
 136 } cfs_param_dentry_t;
 137
 138 typedef struct cfs_proc_inode {
 139         cfs_param_dentry_t *param_pde;
 140         cfs_inode_t         param_inode;
 141 } cfs_proc_inode_t;
 142
 143 struct cfs_seq_operations;
 144 typedef struct cfs_seq_file {
 145         char                      *buf;
 146         size_t                     size;
 147         size_t                     from;
 148         size_t                     count;
 149         loff_t                     index;
 150         loff_t                     version;
 151         cfs_mutex_t                lock;
 152         struct cfs_seq_operations *op;
 153         void                      *private;
 154 } cfs_seq_file_t;
 155
 156 typedef struct cfs_seq_operations {
 157         void *(*start) (cfs_seq_file_t *m, loff_t *pos);
 158         void  (*stop) (cfs_seq_file_t *m, void *v);
 159         void *(*next) (cfs_seq_file_t *m, void *v, loff_t *pos);
 160         int   (*show) (cfs_seq_file_t *m, void *v);
 161 } cfs_seq_ops_t;
 162
 163 typedef void *cfs_param_module_t;
 164 typedef void *cfs_poll_table_t;
 165
 166 typedef struct cfs_param_file_ops {
 167         cfs_param_module_t owner;
 168         int (*open) (cfs_inode_t *, cfs_file_t *);
 169         loff_t (*llseek)(cfs_file_t *, loff_t, int);
 170         int (*release) (cfs_inode_t *, cfs_param_file_t *);
 171         unsigned int (*poll) (cfs_file_t *, cfs_poll_table_t *);
 172         ssize_t (*write) (cfs_file_t *, const char *, size_t, loff_t *);
 173         ssize_t (*read)(cfs_file_t *, char *, size_t, loff_t *);
 174 } cfs_param_file_ops_t;
 175 typedef cfs_param_file_ops_t *cfs_lproc_filep_t;
 176
 177 static inline cfs_proc_inode_t *FAKE_PROC_I(const cfs_inode_t *inode)
 178 {
 179         return container_of(inode, cfs_proc_inode_t, param_inode);
 180 }
 181
 182 static inline cfs_param_dentry_t *FAKE_PDE(cfs_inode_t *inode)
 183 {
 184         return FAKE_PROC_I(inode)->param_pde;
 185 }
 186
 187 #define CFS_PARAM_MODULE                        NULL
 188 #define CFS_PDE(value)                          FAKE_PDE(value)
 189 #define cfs_file_private(file)                  (file->param_private)
 190 #define cfs_dentry_data(dentry)                 (dentry->param_data)
 191 #define cfs_proc_inode(proc_inode)              (proc_inode->param_inode)
 192 #define cfs_proc_inode_pde(proc_inode)          (proc_inode->param_pde)
 193 #define cfs_seq_read_common                     NULL
 194 #define cfs_seq_lseek_common                    NULL
 195 #define cfs_seq_private(seq)                    (seq->private)
 196 #define cfs_seq_read(file, buf, count, ppos, rc) do {} while(0)
 197 #define cfs_seq_open(file, ops, rc)                     \
 198 do {                                                    \
 199          cfs_seq_file_t *p = cfs_file_private(file);    \
 200          if (!p) {                                      \
 201                 LIBCFS_ALLOC(p, sizeof(*p));            \
 202                 if (!p) {                               \
 203                         rc = -ENOMEM;                   \
 204                         break;                          \
 205                 }                                       \
 206                 cfs_file_private(file) = p;             \
 207         }                                               \
 208         memset(p, 0, sizeof(*p));                       \
 209         p->op = ops;                                    \
 210         rc = 0;                                         \
 211 } while(0)
 212
 213 #define LPROCFS_ENTRY()             do {} while(0)
 214 #define LPROCFS_EXIT()              do {} while(0)
 215 static inline
 216 int LPROCFS_ENTRY_AND_CHECK(cfs_param_dentry_t *dp)
 217 {
 218         LPROCFS_ENTRY();
 219         return 0;
 220 }
 221 #define LPROCFS_WRITE_ENTRY()       do {} while(0)
 222 #define LPROCFS_WRITE_EXIT()        do {} while(0)
 223
 224 #endif /* LPROCFS */
 225
 226 /* XXX: params_tree APIs */
 227
 228 #endif  /* __PARAMS_TREE_H__ */