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 <linux/lustre_fsfilt.h>
  28 #define SMFSDEV_NAME "/dev/smfsconf"
  29 #define SMFS_PSDEV_MINOR 250
  30 #define SMFS_PSDEV_MAJOR 10
  31
  32 struct option {
  33         char *opt;
  34         char *value;
  35         struct list_head list;
  36 };
  37
  38 struct smfs_control_device {
  39         struct list_head smfs_dev_list;
  40 };
  41
  42 #define SMFS_TYPE                "smfs"
  43 #define IOC_SMFS_START           _IOWR('s', 41, long)
  44 #define IOC_SMFS_STOP            _IOWR('s', 42, long)
  45 #define IOC_SMFS_REINT           _IOWR('s', 43, long)
  46 #define IOC_SMFS_UNDO            _IOWR('s', 44, long)
  47
  48 #ifdef __KERNEL__
  49
  50 #define SB_OPS_CHECK             0x1
  51 #define INODE_OPS_CHECK          0x2
  52 #define FILE_OPS_CHECK           0x4
  53 #define DENTRY_OPS_CHECK         0x8
  54 #define DEV_OPS_CHECK            0x10
  55 #define SYMLINK_OPS_CHECK        0x20
  56 #define DIR_OPS_CHECK            0x40
  57
  58 #define KML_LOG_NAME "kml_rec"
  59
  60 #define MYPATHLEN(buffer, path) ((buffer) + PAGE_SIZE - (path))
  61
  62
  63 #define PACK_KML_REC_INIT(buffer, op_code)          \
  64 do{                                                 \
  65         int opcode = op_code;                       \
  66         memcpy(buffer, &opcode, sizeof(opcode));    \
  67         buffer += sizeof(opcode);                   \
  68 } while (0)
  69
  70
  71 extern int init_smfs_proc_sys(void);
  72 /*options.c*/
  73 extern int get_opt(struct option **option, char **pos);
  74 extern void cleanup_option(void);
  75 extern int init_option(char *data);
  76 /*cache.c*/
  77 extern void sm_set_inode_ops(struct inode *cache_inode, struct inode *inode);
  78 extern void sm_set_sb_ops(struct super_block *cache_sb, struct super_block *sb);
  79 extern void init_smfs_cache(void);
  80 extern void cleanup_smfs_cache(void);
  81 extern void sm_set_journal_ops(struct super_block *sb, char *cache_type);
  82 extern int smfs_init_sm_ops(struct smfs_super_info *smb);
  83 extern void smfs_cleanup_sm_ops(struct smfs_super_info *smb);
  84 static inline struct super_operations *cache_sops(struct smfs_super_info *smb)
  85 {
  86         return &smb->sm_ops->sm_sb_ops;
  87 }
  88 static inline struct inode_operations *cache_diops(struct smfs_super_info *smb)
  89 {
  90         return &smb->sm_ops->sm_dir_iops;
  91 }
  92 static inline struct inode_operations *cache_fiops(struct smfs_super_info *smb)
  93 {
  94         return &smb->sm_ops->sm_file_iops;
  95 }
  96 static inline struct inode_operations *cache_siops(struct smfs_super_info *smb)
  97 {
  98         return &smb->sm_ops->sm_sym_iops;
  99 }
 100 static inline struct file_operations *cache_dfops(struct smfs_super_info *smb)
 101 {
 102         return &smb->sm_ops->sm_dir_fops;
 103 }
 104 static inline struct file_operations *cache_ffops(struct smfs_super_info *smb)
 105 {
 106         return &smb->sm_ops->sm_file_fops;
 107 }
 108 static inline struct file_operations *cache_sfops(struct smfs_super_info *smb)
 109 {
 110         return &smb->sm_ops->sm_sym_fops;
 111 }
 112 static inline struct dentry_operations *cache_dops(struct smfs_super_info *smb)
 113 {
 114         return &smb->sm_ops->sm_dentry_ops;
 115 }
 116 static inline struct journal_operations *journal_ops(struct smfs_super_info *smb)
 117 {
 118         return &smb->sm_ops->sm_journal_ops;
 119 }
 120
 121 struct smfs_hook_ops *smfs_alloc_hook_ops(char *name,
 122                                           smfs_hook_func pre_hook,
 123                                           smfs_hook_func post_hook);
 124
 125 void smfs_free_hook_ops(struct smfs_hook_ops *hops);
 126 int smfs_register_hook_ops(struct smfs_super_info *smb,
 127                            struct smfs_hook_ops *smh_ops);
 128
 129 struct smfs_hook_ops *smfs_unregister_hook_ops(struct smfs_super_info *smb,
 130                                                char *name);
 131 /*smfs_lib.c*/
 132 void smfs_put_super(struct super_block *sb);
 133 int smfs_fill_super(struct super_block *sb, void *data, int silent);
 134
 135 void smfs_cleanup_hooks(struct smfs_super_info *smb);
 136 /*sysctl.c*/
 137 extern int sm_debug_level;
 138 extern int sm_inodes;
 139 extern long sm_kmemory;
 140 extern int sm_stack;
 141 /*dir.c*/
 142 extern struct inode_operations smfs_dir_iops;
 143 extern struct file_operations smfs_dir_fops;
 144 /*file.c*/
 145 extern struct inode_operations smfs_file_iops;
 146 extern struct file_operations  smfs_file_fops;
 147 extern int smfs_ioctl(struct inode * inode, struct file * filp,
 148                       unsigned int cmd, unsigned long arg);
 149 extern int smfs_fsync(struct file * file, struct dentry *dentry, int datasync);
 150 extern int smfs_setattr(struct dentry *dentry, struct iattr *attr);
 151 extern int smfs_setxattr(struct dentry *dentry, const char *name,
 152                          const void *value, size_t size, int flags);
 153 extern int smfs_getxattr(struct dentry *dentry, const char *name, void *buffer,
 154                          size_t size);
 155 extern ssize_t smfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
 156 extern int smfs_removexattr(struct dentry *dentry, const char *name);
 157 extern int smfs_open(struct inode * inode, struct file * filp);
 158 extern int smfs_release(struct inode * inode, struct file * filp);
 159 /*inode.c*/
 160 struct inode *smfs_get_inode(struct super_block *sb, ino_t hash,
 161                              struct inode *dir, int index);
 162
 163 extern struct super_operations smfs_super_ops;
 164
 165 struct smfs_iget_args {
 166         struct inode *s_inode;
 167         int           s_index;
 168         int           s_ino;
 169 };
 170 /*symlink.c*/
 171 extern struct inode_operations smfs_sym_iops;
 172 extern struct file_operations smfs_sym_fops;
 173 /*journal.c */
 174 void *smfs_trans_start(struct inode *inode, int op, void *desc_private);
 175 void smfs_trans_commit(struct inode *inode, void *handle, int force_sync);
 176
 177 extern int smfs_post_rec_write(struct inode *dir, struct dentry *dentry,
 178                                void   *data1, void *data2);
 179 extern int smfs_post_rec_setattr(struct inode *dir, struct dentry *dentry,
 180                                  void   *data1, void *data2);
 181 extern int smfs_post_rec_create(struct inode *dir, struct dentry *dentry,
 182                                 void   *data1, void   *data2);
 183 /*kml.c*/
 184 int smfs_do_rec(struct inode *inode);
 185 int smfs_rec_cleanup(struct smfs_super_info *sb);
 186 int smfs_rec_init(struct super_block *sb);
 187
 188 extern int smfs_rec_unpack(struct smfs_proc_args *args, char *record,
 189                            char **pbuf, int *opcode);
 190 extern int smfs_process_rec(struct super_block *sb, int count,
 191                             char *dir, int flags);
 192
 193 /*mds_kml.c*/
 194 int mds_rec_pack_init(struct smfs_super_info *smb);
 195 /*ost_kml.c*/
 196 int ost_rec_pack_init(struct smfs_super_info *smb);
 197
 198 /*smfs_llog.c*/
 199 extern int smfs_llog_setup(struct super_block *sb, struct vfsmount *mnt);
 200 extern int smfs_llog_cleanup(struct super_block *sb);
 201 extern int smfs_llog_add_rec(struct smfs_super_info * sinfo, void *data,
 202                              int data_size);
 203 /*ioctl.c*/
 204 extern int init_smfs_psdev(void);
 205 extern void smfs_cleanup_psdev(void);
 206 /*smfs_cow.c */
 207
 208 /* cache_space.c */
 209 extern int do_cache_manage;
 210 struct cache_purge_queue {
 211         wait_queue_head_t       cpq_waitq;
 212         struct super_block     *cpq_sb;
 213         struct llog_handle     *cpq_loghandle;
 214         __u32                   cpq_flags;
 215         struct completion       cpq_comp;
 216 };
 217 /* opcodes */
 218 #define CACHE_SPACE_INSERT 0x1
 219 #define CACHE_SPACE_DELETE 0x2
 220 #define CACHE_SPACE_COMMIT 0x4
 221
 222 #define CACHE_LRU_LOG "CACHE_LRU_LIST"
 223
 224 extern int smfs_cache_hook(struct inode *inode);
 225 extern void cache_space_pre(struct inode *inode, int op);
 226 extern int cache_space_post(int op, void *handle, struct inode *old_dir,
 227                             struct dentry *old_dentry, struct inode *new_dir,
 228                             struct dentry *new_dentry);
 229
 230 int cache_space_hook_setup(struct super_block *);
 231 int cache_space_hook_cleanup(void);
 232 int cache_space_hook_init(struct super_block *sb);
 233 int cache_space_hook_exit(struct smfs_super_info *smfs_info);
 234
 235 #define XATTR_SMFS_HOARD_MARK           "hoard"
 236 #define XATTR_SMFS_CACHE_LOGCOOKIE      "cache"
 237 #define XATTR_SMFS_ACTIVE_ENTRY         "entry"
 238
 239
 240 static inline int set_hoard_priority(struct inode *inode, void *handle,
 241                                      __u32 *hoard)
 242 {
 243         struct fsfilt_operations *fsops = I2CSB(inode)->sm_fsfilt;
 244         int rc;
 245
 246         rc = fsops->fs_set_xattr(inode, handle, XATTR_SMFS_HOARD_MARK,
 247                                  hoard, sizeof(__u32));
 248         RETURN(rc);
 249 }
 250
 251 static inline int get_hoard_priority(struct inode *inode, __u32 *hoard)
 252 {
 253         struct fsfilt_operations *fsops = I2CSB(inode)->sm_fsfilt;
 254         int rc;
 255
 256         rc = fsops->fs_get_xattr(inode, XATTR_SMFS_HOARD_MARK,
 257                                  hoard, sizeof(__u32));
 258         RETURN(rc);
 259 }
 260
 261 static inline int set_active_entry(struct inode *dir, __u64 *active_entry,
 262                                    void *handle)
 263 {
 264         struct fsfilt_operations *fsops = I2CSB(dir)->sm_fsfilt;
 265         int rc;
 266         *active_entry = cpu_to_le64(*active_entry);
 267         rc = fsops->fs_set_xattr(dir, handle, XATTR_SMFS_ACTIVE_ENTRY,
 268                                  active_entry, sizeof(__u64));
 269         RETURN(rc);
 270 }
 271 static inline int get_active_entry(struct inode *dir, __u64 *active_entry)
 272 {
 273         struct fsfilt_operations *fsops = I2CSB(dir)->sm_fsfilt;
 274         int rc = fsops->fs_get_xattr(dir, XATTR_SMFS_ACTIVE_ENTRY,
 275                                      active_entry, sizeof(__u64));
 276         *active_entry = le64_to_cpu(*active_entry);
 277         if (rc >= 0)
 278                 rc = 0;
 279         RETURN(rc);
 280 }
 281 #define HOOK_CREATE       1
 282 #define HOOK_LOOKUP       2
 283 #define HOOK_LINK         3
 284 #define HOOK_UNLINK       4
 285 #define HOOK_SYMLINK      5
 286 #define HOOK_MKDIR        6
 287 #define HOOK_RMDIR        7
 288 #define HOOK_MKNOD        8
 289 #define HOOK_RENAME       9
 290 #define HOOK_SETATTR      10
 291 #define HOOK_WRITE        11
 292 #define HOOK_READDIR      12
 293 #define HOOK_MAX          12
 294
 295 #define PRE_HOOK 0
 296 #define POST_HOOK 1
 297 #define SMFS_HOOK(inode, dentry, data1, data2, op, handle, flag, rc, label)    \
 298 do {                                                                           \
 299         LASSERT(inode->i_sb);                                                  \
 300         if (!rc) {                                                             \
 301                 struct smfs_super_info *smb = S2SMI(inode->i_sb);              \
 302                 struct list_head *hlist = &smb->smsi_hook_list;                \
 303                 struct list_head *p;                                           \
 304                                                                                \
 305                 list_for_each(p, hlist) {                                      \
 306                         struct smfs_hook_ops *hops;                            \
 307                                                                                \
 308                         hops = list_entry(p, typeof(*hops), smh_list);         \
 309                         if (flag == PRE_HOOK && hops->smh_pre_op)              \
 310                                 rc = hops->smh_pre_op(inode, dentry, data1,    \
 311                                                       data2, op, handle);      \
 312                         else if (flag == POST_HOOK && hops->smh_post_op)       \
 313                                 rc = hops->smh_post_op(inode, dentry, data1,   \
 314                                                        data2, op, handle);     \
 315                         if (rc)                                                \
 316                                 break;                                         \
 317                 }                                                              \
 318         }                                                                      \
 319         if (rc)                                                                \
 320                 GOTO(label, rc);                                               \
 321 } while(0)                                                                     \
 322
 323 #define SMFS_GET_INODE(sb, cache_inode, dir, inode, rc, label)          \
 324 do {                                                                    \
 325         LASSERT(cache_inode);                                           \
 326         inode = smfs_get_inode(sb, cache_inode->i_ino, dir, 0);         \
 327         iput(cache_inode);                                              \
 328         if (!inode)                                                     \
 329                 GOTO(label, rc = -ENOENT);                              \
 330 } while(0)
 331
 332
 333 #if CONFIG_SNAPFS
 334 int smfs_cow_init(struct super_block *sb);
 335 int smfs_cow_cleanup(struct smfs_super_info *smb);
 336 int smfs_snap_test_inode(struct inode *inode, void *args);
 337 #else
 338 #define SMFS_PRE_COW(dir, dentry, new_dir, new_dentry, op, name, rc, label)
 339 #endif
 340 #endif /*__KERNEL*/
 341 #endif /* __LINUX_SMFS_H */