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