lustre/smfs/kml.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  lustre/smfs/kml.c
   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 EXPORT_SYMTAB
  25 # define EXPORT_SYMTAB
  26 #endif
  27
  28 #define DEBUG_SUBSYSTEM S_SM
  29
  30 #include <linux/kmod.h>
  31 #include <linux/init.h>
  32 #include <linux/fs.h>
  33 #include <linux/slab.h>
  34 #include <linux/obd_class.h>
  35 #include <linux/obd_support.h>
  36 #include <linux/lustre_lib.h>
  37 #include <linux/lustre_idl.h>
  38 #include <linux/lustre_fsfilt.h>
  39 #include <linux/lustre_smfs.h>
  40 #include "smfs_internal.h"
  41
  42 smfs_pack_rec_func smfs_get_rec_pack_type(struct super_block *sb)
  43 {
  44         struct smfs_super_info *smsi = S2SMI(sb);
  45
  46         int index = GET_REC_PACK_TYPE_INDEX(smsi->smsi_flags);
  47
  48         return smsi->smsi_pack_rec[index];
  49 }
  50 static int smfs_rec_post_hook(struct inode *inode, struct dentry *dentry,
  51                               void *data1, void *data2, int op, void *handle)
  52 {
  53         int rc = 0;
  54         ENTRY;
  55
  56         if (smfs_do_rec(inode))
  57                 rc = smfs_post_kml_rec(inode, dentry, data1, data2, op);
  58
  59         RETURN(rc);
  60 }
  61
  62 #define KML_HOOK "kml_hook"
  63 int smfs_rec_init(struct super_block *sb)
  64 {
  65         struct smfs_super_info *smfs_info = S2SMI(sb);
  66         struct smfs_hook_ops   *rec_hops = NULL;
  67         int rc = 0;
  68
  69         SMFS_SET_REC(smfs_info);
  70
  71         ost_rec_pack_init(sb);
  72         mds_rec_pack_init(sb);
  73
  74         rec_hops = smfs_alloc_hook_ops(KML_HOOK, NULL, smfs_rec_post_hook);
  75         if (!rec_hops) {
  76                 RETURN(-ENOMEM);
  77         }
  78
  79         rc = smfs_register_hook_ops(sb, rec_hops);
  80
  81         if (rc && rec_hops) {
  82                 smfs_unregister_hook_ops(sb, rec_hops->smh_name);
  83                 smfs_free_hook_ops(rec_hops);
  84         }
  85         RETURN(rc);
  86 }
  87
  88 int smfs_rec_cleanup(struct super_block *sb)
  89 {
  90         struct smfs_hook_ops *rec_hops;
  91         int rc = 0;
  92
  93         rec_hops = smfs_unregister_hook_ops(sb, KML_HOOK);
  94         smfs_free_hook_ops(rec_hops);
  95         SMFS_CLEAN_REC(S2SMI(sb));
  96
  97         RETURN(rc);
  98 }
  99
 100 static inline void copy_inode_attr(struct iattr *iattr, struct inode *inode)
 101 {
 102         iattr->ia_mode = inode->i_mode;
 103         iattr->ia_uid  = inode->i_uid;
 104         iattr->ia_gid  = inode->i_gid;
 105         iattr->ia_atime = inode->i_atime;
 106         iattr->ia_ctime = inode->i_ctime;
 107         iattr->ia_mtime = inode->i_mtime;
 108         iattr->ia_size = inode->i_size;
 109 }
 110
 111 static inline int unpack_rec_data(char **p_buffer, int *size,
 112                                   char *in_data, char *args_data)
 113 {
 114         int args_len = 0;
 115         int rc = 0;
 116
 117         if (args_data)
 118                 args_len = strlen(args_data);
 119
 120         *size = *((int*)(in_data));
 121         rc = *size + sizeof(int);
 122
 123         OBD_ALLOC(*p_buffer, *size + args_len + 1);
 124         if (!*p_buffer)
 125                 RETURN(-ENOMEM);
 126         /*First copy reint dir */
 127         if (args_data)
 128                 memcpy(*p_buffer, args_data, args_len);
 129
 130         /*then copy the node name */
 131         memcpy(*p_buffer + args_len,
 132                       (in_data + sizeof(int)), *size);
 133
 134         *size += args_len;
 135
 136         RETURN(rc);
 137 }
 138
 139 int smfs_rec_unpack(struct smfs_proc_args *args, char *record,
 140                     char **pbuf, int *opcode)
 141 {
 142         int offset = *(int *)(record);
 143         char *tmp = record + offset + sizeof(int);
 144         int rc = 0;
 145         *opcode = *(int *)tmp;
 146         *pbuf = tmp + sizeof(*opcode);
 147         RETURN(rc);
 148 }
 149 EXPORT_SYMBOL(smfs_rec_unpack);
 150
 151 int smfs_start_rec(struct super_block *sb, struct vfsmount *mnt)
 152 {
 153         struct dentry *dentry;
 154         struct lvfs_run_ctxt saved;
 155         int rc = 0;
 156         ENTRY;
 157
 158         if (SMFS_INIT_REC(S2SMI(sb)) ||
 159             (!SMFS_DO_REC(S2SMI(sb)) && !SMFS_CACHE_HOOK(S2SMI(sb))))
 160                 RETURN(rc);
 161
 162         rc = smfs_llog_setup(sb, mnt);
 163         if (rc)
 164                 RETURN(rc);
 165         push_ctxt(&saved, S2SMI(sb)->smsi_ctxt, NULL);
 166         dentry = simple_mkdir(current->fs->pwd, "DELETE", 0777, 1);
 167         if (IS_ERR(dentry)) {
 168                 rc = PTR_ERR(dentry);
 169                 CERROR("cannot create DELETE directory: rc = %d\n", rc);
 170                 GOTO(err_exit, rc = -EINVAL);
 171         }
 172         S2SMI(sb)->smsi_delete_dir = dentry;
 173
 174         if (!rc)
 175                 SMFS_SET_INIT_REC(S2SMI(sb));
 176 exit:
 177         pop_ctxt(&saved, S2SMI(sb)->smsi_ctxt, NULL);
 178         RETURN(rc);
 179 err_exit:
 180         if (S2SMI(sb)->smsi_ctxt)
 181                 OBD_FREE(S2SMI(sb)->smsi_ctxt, sizeof(struct lvfs_run_ctxt));
 182         goto exit;
 183 }
 184 EXPORT_SYMBOL(smfs_start_rec);
 185
 186 int smfs_post_setup(struct super_block *sb, struct vfsmount *mnt)
 187 {
 188         struct lvfs_run_ctxt *current_ctxt = NULL;
 189         struct smfs_super_info *smb = S2SMI(sb);
 190
 191         OBD_ALLOC(current_ctxt, sizeof(*current_ctxt));
 192         if (!current_ctxt)
 193                 RETURN(-ENOMEM);
 194         OBD_SET_CTXT_MAGIC(current_ctxt);
 195
 196         current_ctxt->pwdmnt = mnt;
 197         current_ctxt->pwd = mnt->mnt_root;
 198         current_ctxt->fs = get_ds();
 199         smb->smsi_ctxt = current_ctxt;
 200
 201         RETURN(0);
 202 }
 203 EXPORT_SYMBOL(smfs_post_setup);
 204
 205 int smfs_post_cleanup(struct super_block *sb)
 206 {
 207         struct smfs_super_info *smb = S2SMI(sb);
 208
 209         ENTRY;
 210
 211         if (smb->smsi_ctxt)
 212                 OBD_FREE(S2SMI(sb)->smsi_ctxt, sizeof(struct lvfs_run_ctxt));
 213         RETURN(0);
 214 }
 215 EXPORT_SYMBOL(smfs_post_cleanup);
 216
 217 int smfs_stop_rec(struct super_block *sb)
 218 {
 219         int rc = 0;
 220
 221         if (!SMFS_INIT_REC(S2SMI(sb)) ||
 222             (!SMFS_DO_REC(S2SMI(sb)) && !SMFS_CACHE_HOOK(S2SMI(sb))))
 223                 RETURN(rc);
 224
 225         rc = smfs_llog_cleanup(sb);
 226
 227         SMFS_CLEAN_INIT_REC(S2SMI(sb));
 228
 229         if (S2SMI(sb)->smsi_delete_dir) {
 230                 l_dput(S2SMI(sb)->smsi_delete_dir);
 231                 S2SMI(sb)->smsi_delete_dir = NULL;
 232         }
 233         RETURN(rc);
 234 }
 235 EXPORT_SYMBOL(smfs_stop_rec);
 236
 237 int smfs_write_extents(struct inode *dir, struct dentry *dentry,
 238                        unsigned long from, unsigned long num)
 239 {
 240         return smfs_post_rec_write(dir, dentry, &from, &num);
 241 }
 242 EXPORT_SYMBOL(smfs_write_extents);
 243
 244 int smfs_rec_setattr(struct inode *dir, struct dentry *dentry,
 245                      struct iattr *attr)
 246 {
 247         return smfs_post_rec_setattr(dir, dentry, attr, NULL);
 248 }
 249 EXPORT_SYMBOL(smfs_rec_setattr);
 250
 251 int smfs_rec_md(struct inode *inode, void * lmm, int lmm_size)
 252 {
 253         char *set_lmm = NULL;
 254         int  rc = 0;
 255         ENTRY;
 256
 257         if (lmm) {
 258                 OBD_ALLOC(set_lmm, lmm_size + sizeof(lmm_size));
 259                 if (!set_lmm)
 260                         RETURN(-ENOMEM);
 261                 memcpy(set_lmm, &lmm_size, sizeof(lmm_size));
 262                 memcpy(set_lmm + sizeof(lmm_size), lmm, lmm_size);
 263                 rc = smfs_post_rec_setattr(inode, NULL, NULL, set_lmm);
 264                 if (rc) {
 265                         CERROR("Error: Record md for inode %lu rc=%d\n",
 266                                 inode->i_ino, rc);
 267                 }
 268         }
 269         if (set_lmm)
 270                 OBD_FREE(set_lmm, lmm_size + sizeof(lmm_size));
 271         return rc;
 272 }
 273 EXPORT_SYMBOL(smfs_rec_md);
 274
 275 int smfs_rec_precreate(struct dentry *dentry, int *num, struct obdo *oa)
 276 {
 277        return smfs_post_rec_create(dentry->d_inode, dentry, num, oa);
 278 }
 279 EXPORT_SYMBOL(smfs_rec_precreate);
 280
 281 int smfs_process_rec(struct super_block *sb,
 282                      int count, char *dir, int flags)
 283 {
 284         struct llog_ctxt *ctxt;
 285         struct llog_handle *loghandle;
 286         struct smfs_proc_args args;
 287         int rc = 0;
 288
 289         if (!SMFS_INIT_REC(S2SMI(sb))) {
 290                 CWARN("Did not start up rec server \n");
 291                 RETURN(rc);
 292         }
 293
 294         memset(&args, 0, sizeof(struct smfs_proc_args));
 295         args.sr_sb = sb;
 296         args.sr_count = count;
 297         args.sr_data = dir;
 298         args.sr_flags = flags ;
 299         ctxt = S2SMI(sb)->smsi_rec_log;
 300         loghandle = ctxt->loc_handle;
 301
 302         if (count == 0) {
 303                 if (SMFS_DO_REINT_REC(flags)) {
 304                         struct llog_gen_rec *lgr;
 305
 306                         /*For reint rec, we need insert
 307                           *a gen rec to identify the end
 308                           *of the rec.*/
 309                         OBD_ALLOC(lgr, sizeof(*lgr));
 310                         if (!lgr)
 311                                 RETURN(-ENOMEM);
 312                         lgr->lgr_hdr.lrh_len = lgr->lgr_tail.lrt_len = sizeof(*lgr);
 313                         lgr->lgr_hdr.lrh_type = LLOG_GEN_REC;
 314                         lgr->lgr_gen = ctxt->loc_gen;
 315                         rc = llog_add(ctxt, &lgr->lgr_hdr, NULL, NULL, 1,
 316                                       NULL, NULL, NULL);
 317                         OBD_FREE(lgr, sizeof(*lgr));
 318                         if (rc != 1)
 319                                 RETURN(rc);
 320                 }
 321         } else {
 322                 SET_REC_COUNT_FLAGS(args.sr_flags, SMFS_REC_ALL);
 323         }
 324         if (loghandle) {
 325                 if (SMFS_DO_REINT_REC(flags))
 326                         rc = llog_cat_process(loghandle, ctxt->llog_proc_cb,
 327                                               (void *)&args);
 328                 else
 329                         rc = llog_cat_reverse_process(loghandle,
 330                                                       ctxt->llog_proc_cb,
 331                                                       (void *)&args);
 332                 if (rc == LLOG_PROC_BREAK)
 333                         rc = 0;
 334         }
 335         RETURN(rc);
 336 }