Whamcloud - gitweb
- minor fixes in smfs to support raw lookups
[fs/lustre-release.git] / lustre / smfs / smfs_internal.h
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  *  lustre/smfs/smfs_internal.h
5  *  Lustre filesystem abstraction routines
6  *
7  *  Copyright (C) 2004 Cluster File Systems, Inc.
8  *
9  *   This file is part of Lustre, http://www.lustre.org.
10  *
11  *   Lustre is free software; you can redistribute it and/or
12  *   modify it under the terms of version 2 of the GNU General Public
13  *   License as published by the Free Software Foundation.
14  *
15  *   Lustre is distributed in the hope that it will be useful,
16  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
17  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  *   GNU General Public License for more details.
19  *
20  *   You should have received a copy of the GNU General Public License
21  *   along with Lustre; if not, write to the Free Software
22  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23  */
24 #ifndef __LINUX_SMFS_H
25 #define __LINUX_SMFS_H
26
27 #include "smfs_api.h"
28 #define SMFSDEV_NAME "/dev/smfsconf"
29 #define SMFS_PSDEV_MINOR 250
30 #define SMFS_PSDEV_MAJOR 10
31
32 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10))
33 #define FC3_KERNEL
34 #endif
35
36 struct option {
37         char *opt;
38         char *value;
39         struct list_head list;
40 };
41
42 struct smfs_control_device {
43         struct list_head smfs_dev_list;
44 };
45
46 #define SMFS_TYPE                "smfs"
47 #define IOC_SMFS_START           _IOWR('s', 41, long)
48 #define IOC_SMFS_STOP            _IOWR('s', 42, long)
49 #define IOC_SMFS_REINT           _IOWR('s', 43, long)
50 #define IOC_SMFS_UNDO            _IOWR('s', 44, long)
51
52 #ifdef __KERNEL__
53
54 #define SB_OPS_CHECK             0x1
55 #define INODE_OPS_CHECK          0x2
56 #define FILE_OPS_CHECK           0x4
57 #define DENTRY_OPS_CHECK         0x8
58 #define DEV_OPS_CHECK            0x10
59 #define SYMLINK_OPS_CHECK        0x20
60 #define DIR_OPS_CHECK            0x40
61
62 #define MYPATHLEN(buffer, path) ((buffer) + PAGE_SIZE - (path))
63
64 #define PACK_KML_REC_INIT(buffer, op_code)          \
65 do{                                                 \
66         int opcode = op_code;                       \
67         memcpy(buffer, &opcode, sizeof(opcode));    \
68         buffer += sizeof(opcode);                   \
69 } while (0)
70
71
72 extern int init_smfs_proc_sys(void);
73 /*cache.c*/
74 extern void sm_set_inode_ops(struct inode *cache_inode, struct inode *inode);
75 extern void sm_set_sb_ops(struct super_block *cache_sb, struct super_block *sb);
76 extern void init_smfs_cache(void);
77 extern void cleanup_smfs_cache(void);
78 extern void sm_set_journal_ops(struct super_block *sb, char *cache_type);
79 extern int smfs_init_sm_ops(struct smfs_super_info *smb);
80 extern void smfs_cleanup_sm_ops(struct smfs_super_info *smb);
81
82 static inline struct inode_operations *cache_diops(struct smfs_super_info *smb)
83 {
84         return &smb->sm_ops->sm_dir_iops;
85 }
86 static inline struct inode_operations *cache_fiops(struct smfs_super_info *smb)
87 {
88         return &smb->sm_ops->sm_file_iops;
89 }
90 static inline struct inode_operations *cache_siops(struct smfs_super_info *smb)
91 {
92         return &smb->sm_ops->sm_sym_iops;
93 }
94 static inline struct file_operations *cache_dfops(struct smfs_super_info *smb)
95 {
96         return &smb->sm_ops->sm_dir_fops;
97 }
98 static inline struct file_operations *cache_ffops(struct smfs_super_info *smb)
99 {
100         return &smb->sm_ops->sm_file_fops;
101 }
102 static inline struct file_operations *cache_sfops(struct smfs_super_info *smb)
103 {
104         return &smb->sm_ops->sm_sym_fops;
105 }
106 static inline struct dentry_operations *cache_dops(struct smfs_super_info *smb)
107 {
108         return &smb->sm_ops->sm_dentry_ops;
109 }
110 static inline struct journal_operations *journal_ops(struct smfs_super_info *smb)
111 {
112         return &smb->sm_ops->sm_journal_ops;
113 }
114
115 /*smfs_lib.c*/
116 void smfs_put_super(struct super_block *sb);
117 int smfs_fill_super(struct super_block *sb, void *data, int silent);
118 int smfs_post_setup(struct obd_device *, struct vfsmount *, struct dentry *);
119 void smfs_post_cleanup(struct super_block *);
120 /*sysctl.c*/
121 extern int sm_debug_level;
122 extern int sm_inodes;
123 extern long sm_kmemory;
124 extern int sm_stack;
125 /*dir.c*/
126 extern struct inode_operations smfs_dir_iops;
127 extern struct file_operations smfs_dir_fops;
128 extern struct inode_operations smfs_iopen_iops;
129 extern struct file_operations smfs_iopen_fops;
130
131 /*file.c*/
132 extern struct inode_operations smfs_file_iops;
133 extern struct file_operations  smfs_file_fops;
134 extern int smfs_ioctl(struct inode * inode, struct file * filp,
135                       unsigned int cmd, unsigned long arg);
136 extern int smfs_fsync(struct file * file, struct dentry *dentry, int datasync);
137 extern int smfs_setattr(struct dentry *dentry, struct iattr *attr);
138 extern int smfs_setxattr(struct dentry *dentry, const char *name,
139                          const void *value, size_t size, int flags);
140 extern int smfs_getxattr(struct dentry *dentry, const char *name, void *buffer,
141                          size_t size);
142 extern ssize_t smfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
143 extern int smfs_removexattr(struct dentry *dentry, const char *name);
144 extern int smfs_open(struct inode * inode, struct file * filp);
145 extern int smfs_release(struct inode * inode, struct file * filp);
146 /*inode.c*/
147 struct inode *smfs_get_inode(struct super_block *sb, ino_t hash, 
148                              struct inode *dir, int index);
149
150 extern struct super_operations smfs_super_ops;
151
152 struct smfs_iget_args {
153         struct inode *s_inode;
154         int           s_index;
155         int           s_ino;
156 };
157 /*symlink.c*/
158 extern struct inode_operations smfs_sym_iops;
159 extern struct file_operations smfs_sym_fops;
160
161 void *smfs_trans_start(struct inode *inode, int op, void *desc_private);
162 void smfs_trans_commit(struct inode *inode, void *handle, int force_sync);
163
164 extern int smfs_post_rec_write(struct inode *dir, struct dentry *dentry,
165                                void   *data1, void *data2);
166 extern int smfs_post_rec_setattr(struct inode *dir, struct dentry *dentry,
167                                  void   *data1, void *data2);
168 extern int smfs_post_rec_create(struct inode *dir, struct dentry *dentry,
169                                 void   *data1, void   *data2);
170 /*kml.c*/
171 int smfs_do_rec(struct inode *inode);
172 int smfs_rec_cleanup(struct smfs_super_info *sb);
173 int smfs_rec_init(struct super_block *sb);
174
175 extern int smfs_rec_unpack(struct smfs_proc_args *args, char *record,
176                            char **pbuf, int *opcode);
177 extern int smfs_process_rec(struct super_block *sb, int count,
178                             char *dir, int flags);
179
180 /*mds_kml.c*/
181 int mds_rec_pack_init(struct smfs_super_info *smb);
182 /*ost_kml.c*/
183 int ost_rec_pack_init(struct smfs_super_info *smb);
184
185 /*smfs_llog.c*/
186 extern int smfs_llog_setup(struct smfs_super_info *);
187 extern int smfs_llog_cleanup(struct smfs_super_info *);
188 extern int smfs_llog_add_rec(struct smfs_super_info *, void *, int);
189 /*ioctl.c*/
190 extern int init_smfs_psdev(void);
191 extern void smfs_cleanup_psdev(void);
192 /*smfs_cow.c */
193
194 /* cache_space.c */
195 extern int do_cache_manage;
196 struct cache_purge_queue {
197         wait_queue_head_t       cpq_waitq;
198         struct super_block     *cpq_sb;
199         struct llog_handle     *cpq_loghandle;
200         __u32                   cpq_flags;
201         struct completion       cpq_comp;
202 };
203 /* opcodes */
204 #define CACHE_SPACE_INSERT 0x1
205 #define CACHE_SPACE_DELETE 0x2
206 #define CACHE_SPACE_COMMIT 0x4
207
208 #define CACHE_LRU_LOG "CACHE_LRU_LIST"
209
210 extern int smfs_cache_hook(struct inode *inode);
211 extern void cache_space_pre(struct inode *inode, int op);
212 extern int cache_space_post(int op, void *handle, struct inode *old_dir,
213                             struct dentry *old_dentry, struct inode *new_dir,
214                             struct dentry *new_dentry);
215
216 int cache_space_hook_setup(struct super_block *);
217 int cache_space_hook_cleanup(void);
218 int cache_space_hook_init(struct super_block *sb);
219 int cache_space_hook_exit(struct smfs_super_info *smfs_info);
220
221 #define XATTR_SMFS_HOARD_MARK           "hoard"
222 #define XATTR_SMFS_CACHE_LOGCOOKIE      "cache"
223 #define XATTR_SMFS_ACTIVE_ENTRY         "entry"
224
225
226 static inline int set_hoard_priority(struct inode *inode, void *handle,
227                                      __u32 *hoard)
228 {
229         struct fsfilt_operations *fsops = I2CSB(inode)->sm_fsfilt;
230         int rc;
231
232         rc = fsops->fs_set_xattr(inode, handle, XATTR_SMFS_HOARD_MARK,
233                                  hoard, sizeof(__u32));
234         RETURN(rc);
235 }
236
237 static inline int get_hoard_priority(struct inode *inode, __u32 *hoard)
238 {
239         struct fsfilt_operations *fsops = I2CSB(inode)->sm_fsfilt;
240         int rc;
241
242         rc = fsops->fs_get_xattr(inode, XATTR_SMFS_HOARD_MARK,
243                                  hoard, sizeof(__u32));
244         RETURN(rc);
245 }
246
247 static inline int set_active_entry(struct inode *dir, __u64 *active_entry,
248                                    void *handle)
249 {
250         struct fsfilt_operations *fsops = I2CSB(dir)->sm_fsfilt;
251         int rc;
252         *active_entry = cpu_to_le64(*active_entry);
253         rc = fsops->fs_set_xattr(dir, handle, XATTR_SMFS_ACTIVE_ENTRY,
254                                  active_entry, sizeof(__u64));
255         RETURN(rc);
256 }
257 static inline int get_active_entry(struct inode *dir, __u64 *active_entry)
258 {
259         struct fsfilt_operations *fsops = I2CSB(dir)->sm_fsfilt;
260         int rc = fsops->fs_get_xattr(dir, XATTR_SMFS_ACTIVE_ENTRY,
261                                      active_entry, sizeof(__u64));
262         *active_entry = le64_to_cpu(*active_entry);
263         if (rc >= 0)
264                 rc = 0;
265         RETURN(rc);
266 }
267
268 #if CONFIG_SNAPFS
269 int smfs_cow_init(struct super_block *sb);
270 int smfs_cow_cleanup(struct smfs_super_info *smb);
271 int smfs_snap_test_inode(struct inode *inode, void *args);
272 #else
273 #define SMFS_PRE_COW(dir, dentry, new_dir, new_dentry, op, name, rc, label)                 
274 #endif 
275 #endif /*__KERNEL*/
276 #endif /* __LINUX_SMFS_H */