From 1fbf48379f446689d10bffd91022b5778e6b12ef Mon Sep 17 00:00:00 2001 From: tappro Date: Mon, 23 May 2005 11:25:57 +0000 Subject: [PATCH] - KML fixes and updates due to SMFS plugin API. --- lustre/smfs/dir.c | 2 +- lustre/smfs/fsfilt.c | 291 +++++++++++++----------- lustre/smfs/kml.c | 536 ++++++++++++++++++-------------------------- lustre/smfs/mds_kml.c | 17 +- lustre/smfs/ost_kml.c | 5 +- lustre/smfs/smfs_api.h | 47 ++-- lustre/smfs/smfs_internal.h | 24 +- lustre/smfs/smfs_lib.c | 105 ++++++--- lustre/smfs/smfs_llog.c | 48 ++-- 9 files changed, 519 insertions(+), 556 deletions(-) diff --git a/lustre/smfs/dir.c b/lustre/smfs/dir.c index d5d4029..c51b4278 100644 --- a/lustre/smfs/dir.c +++ b/lustre/smfs/dir.c @@ -383,7 +383,7 @@ static int smfs_unlink(struct inode * dir, struct dentry *dentry) //int mode = 0; struct hook_unlink_msg msg = { .dentry = dentry, - .mode = 0 + .mode = dentry->d_inode->i_mode }; ENTRY; diff --git a/lustre/smfs/fsfilt.c b/lustre/smfs/fsfilt.c index 64bfcaf..7629e39 100644 --- a/lustre/smfs/fsfilt.c +++ b/lustre/smfs/fsfilt.c @@ -47,16 +47,22 @@ static void *fsfilt_smfs_start(struct inode *inode, int op, void *handle; struct inode *cache_inode = I2CI(inode); struct fsfilt_operations *cache_fsfilt = I2FOPS(inode); - + int extra = 0; + int opcode = op; + if (cache_fsfilt == NULL) return NULL; - //SMFS_TRANS_OP(inode, op); - if (!cache_fsfilt->fs_start) return ERR_PTR(-ENOSYS); + + //opcode can be changed here. + //For example, unlink is rename in nature for undo plugin + extra = SMFS_PLG_HELP(inode->i_sb, PLG_TRANS_SIZE, &opcode); + + handle = cache_fsfilt->fs_start(cache_inode, op, desc_private, + logs + extra); - handle = cache_fsfilt->fs_start(cache_inode, op, desc_private, logs); return handle; } @@ -161,41 +167,6 @@ static int fsfilt_smfs_commit_wait(struct inode *inode, void *h) RETURN(rc); } -static int fsfilt_smfs_setattr(struct dentry *dentry, void *handle, - struct iattr *iattr, int do_trunc) -{ - struct fsfilt_operations *cache_fsfilt = I2FOPS(dentry->d_inode); - struct dentry *cache_dentry = NULL; - struct inode *cache_inode = I2CI(dentry->d_inode); - struct hook_setattr_msg msg = { - .dentry = dentry, - .attr = iattr - }; - int rc = -EIO; - - if (!cache_fsfilt) - RETURN(rc); - - if (!cache_fsfilt->fs_setattr) - RETURN(-ENOSYS); - - cache_dentry = pre_smfs_dentry(NULL, cache_inode, dentry); - if (!cache_dentry) - RETURN(-ENOMEM); - - pre_smfs_inode(dentry->d_inode, cache_inode); - - SMFS_PRE_HOOK(dentry->d_inode, HOOK_F_SETATTR, &msg); - - rc = cache_fsfilt->fs_setattr(cache_dentry, handle, iattr, do_trunc); - - SMFS_POST_HOOK(dentry->d_inode, HOOK_F_SETATTR, &msg, rc); - post_smfs_inode(dentry->d_inode, cache_inode); - - post_smfs_dentry(cache_dentry); - RETURN(rc); -} - static int fsfilt_smfs_iocontrol(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { @@ -224,60 +195,6 @@ static int fsfilt_smfs_iocontrol(struct inode *inode, struct file *file, rc = cache_fsfilt->fs_iocontrol(cache_inode, cache_file, cmd, arg); -#if 0 - /* FIXME-UMKA: Should this be in duplicate_inode()? */ - if (rc == 0 && cmd == EXT3_IOC_SETFLAGS) - inode->i_flags = cache_inode->i_flags; -#endif - post_smfs_inode(inode, cache_inode); - - RETURN(rc); -} - -static int fsfilt_smfs_set_md(struct inode *inode, void *handle, - void *lmm, int lmm_size, enum ea_type type) -{ - struct fsfilt_operations *cache_fsfilt = I2FOPS(inode); - struct inode *cache_inode = I2CI(inode); - int rc = -EIO; - - if (!cache_fsfilt) - RETURN(-EINVAL); - - if (!cache_inode) - RETURN(-ENOENT); - /*TODO: HOOK is needed here */ - pre_smfs_inode(inode, cache_inode); - - down(&cache_inode->i_sem); - rc = cache_fsfilt->fs_set_md(cache_inode, handle, lmm, - lmm_size, type); - up(&cache_inode->i_sem); - - post_smfs_inode(inode, cache_inode); - - RETURN(rc); -} - -static int fsfilt_smfs_get_md(struct inode *inode, void *lmm, - int lmm_size, enum ea_type type) -{ - struct fsfilt_operations *cache_fsfilt = I2FOPS(inode); - struct inode *cache_inode = I2CI(inode); - int rc = -EIO; - - if (!cache_fsfilt) - RETURN(-EINVAL); - - if (!cache_inode) - RETURN(-ENOENT); - - pre_smfs_inode(inode, cache_inode); - - down(&cache_inode->i_sem); - rc = cache_fsfilt->fs_get_md(cache_inode, lmm, lmm_size, type); - up(&cache_inode->i_sem); - post_smfs_inode(inode, cache_inode); RETURN(rc); @@ -614,17 +531,13 @@ static int fsfilt_smfs_post_setup(struct obd_device *obd, struct vfsmount *mnt, if (obd) S2SMI(sb)->smsi_exp = obd->obd_self_export; - - rc = smfs_post_setup(sb, mnt); - if (!rc) { - if (obd) - obd->obd_llog_ctxt[LLOG_REINT_ORIG_CTXT] = - S2SMI(sb)->smsi_kml_log; - } - else { - CERROR("can not do post setup in obd %p rc=%d", - obd, rc); + + rc = smfs_post_setup(obd, mnt, root_dentry); + if (rc) { + CERROR("post_setup fails in obd %p rc=%d", obd, rc); } + + } RETURN(rc); @@ -650,13 +563,16 @@ static int fsfilt_smfs_set_fs_flags(struct inode *inode, int flags) int rc = 0; ENTRY; - if (flags & SM_DO_REC) - SMFS_SET(I2SMI(inode)->smi_flags, SMFS_PLG_KML); + if (flags & SM_ALL_PLG) /* enable all plugins */ + SMFS_SET(I2SMI(inode)->smi_flags, SMFS_PLG_ALL); + if (flags & SM_PRECREATE) /* disable logs for precreated objs */ + SMFS_CLEAR(I2SMI(inode)->smi_flags, SMFS_PLG_ALL); - //if (SMFS_DO_REC(S2SMI(inode->i_sb)) && (flags & SM_DO_REC)) - // SMFS_SET_INODE_REC(inode); + +#if 0 if (SMFS_DO_COW(S2SMI(inode->i_sb)) && (flags & SM_DO_COW)) SMFS_SET_INODE_COW(inode); +#endif RETURN(rc); } @@ -664,11 +580,17 @@ static int fsfilt_smfs_clear_fs_flags(struct inode *inode, int flags) { int rc = 0; ENTRY; - + /* if (SMFS_DO_REC(S2SMI(inode->i_sb)) && (flags & SM_DO_REC)) SMFS_CLEAN_INODE_REC(inode); if (SMFS_DO_COW(S2SMI(inode->i_sb)) && (flags & SM_DO_COW)) SMFS_CLEAN_INODE_COW(inode); + */ + if(flags & SM_ALL_PLG) /* disable all plugins */ + SMFS_CLEAR(I2SMI(inode)->smi_flags, SMFS_PLG_ALL); + if (flags & SM_PRECREATE) /* enable log again */ + SMFS_SET(I2SMI(inode)->smi_flags, SMFS_PLG_ALL); + RETURN(rc); } @@ -679,28 +601,23 @@ static int fsfilt_smfs_get_fs_flags(struct dentry *de) ENTRY; LASSERT(inode); - - if (SMFS_DO_REC(S2SMI(inode->i_sb)) && SMFS_DO_INODE_REC(inode)) - flags |= SM_DO_REC; - if (SMFS_DO_COW(S2SMI(inode->i_sb)) && SMFS_DO_INODE_COW(inode)) - flags |= SM_DO_COW; + + flags = I2SMI(inode)->smi_flags & S2SMI(inode->i_sb)->plg_flags; RETURN(flags); } + static int fsfilt_smfs_set_ost_flags(struct super_block *sb) { - int rc = 0; - SET_REC_PACK_TYPE_INDEX(S2SMI(sb)->smsi_flags, PACK_OST); - RETURN(rc); + return 0; } static int fsfilt_smfs_set_mds_flags(struct super_block *sb) { - int rc = 0; - SET_REC_PACK_TYPE_INDEX(S2SMI(sb)->smsi_flags, PACK_MDS); - RETURN(rc); + return 0; } +#if 0 static int fsfilt_smfs_get_reint_log_ctxt(struct super_block *sb, struct llog_ctxt **ctxt) { @@ -710,6 +627,7 @@ static int fsfilt_smfs_get_reint_log_ctxt(struct super_block *sb, *ctxt = smfs_info->smsi_kml_log; RETURN(rc); } +#endif static int fsfilt_smfs_setup(struct obd_device *obd, struct super_block *sb) { @@ -736,6 +654,41 @@ static int fsfilt_smfs_setup(struct obd_device *obd, struct super_block *sb) RETURN(rc); } +static int fsfilt_smfs_setattr(struct dentry *dentry, void *handle, + struct iattr *iattr, int do_trunc) +{ + struct fsfilt_operations *cache_fsfilt = I2FOPS(dentry->d_inode); + struct dentry *cache_dentry = NULL; + struct inode *cache_inode = I2CI(dentry->d_inode); + struct hook_setattr_msg msg = { + .dentry = dentry, + .attr = iattr + }; + int rc = -EIO; + + if (!cache_fsfilt) + RETURN(rc); + + if (!cache_fsfilt->fs_setattr) + RETURN(-ENOSYS); + + cache_dentry = pre_smfs_dentry(NULL, cache_inode, dentry); + if (!cache_dentry) + RETURN(-ENOMEM); + + pre_smfs_inode(dentry->d_inode, cache_inode); + + SMFS_PRE_HOOK(dentry->d_inode, HOOK_F_SETATTR, &msg); + + rc = cache_fsfilt->fs_setattr(cache_dentry, handle, iattr, do_trunc); + + SMFS_POST_HOOK(dentry->d_inode, HOOK_F_SETATTR, &msg, rc); + post_smfs_inode(dentry->d_inode, cache_inode); + + post_smfs_dentry(cache_dentry); + RETURN(rc); +} + static int fsfilt_smfs_set_xattr(struct inode *inode, void *handle, char *name, void *buffer, int buffer_size) { @@ -786,6 +739,77 @@ static int fsfilt_smfs_get_xattr(struct inode *inode, char *name, RETURN(rc); } +#define XATTR_LUSTRE_MDS_LOV_EA "lov" +#define XATTR_LUSTRE_MDS_MEA_EA "mea" +#define XATTR_LUSTRE_MDS_MID_EA "mid" +#define XATTR_LUSTRE_MDS_SID_EA "sid" + +static int fsfilt_smfs_set_md(struct inode *inode, void *handle, + void *lmm, int lmm_size, enum ea_type type) +{ + int rc; + + switch(type) { + case EA_LOV: + rc = fsfilt_smfs_set_xattr(inode, handle, + XATTR_LUSTRE_MDS_LOV_EA, + lmm, lmm_size); + break; + case EA_MEA: + rc = fsfilt_smfs_set_xattr(inode, handle, + XATTR_LUSTRE_MDS_MEA_EA, + lmm, lmm_size); + break; + case EA_SID: + rc = fsfilt_smfs_set_xattr(inode, handle, + XATTR_LUSTRE_MDS_SID_EA, + lmm, lmm_size); + break; + case EA_MID: + rc = fsfilt_smfs_set_xattr(inode, handle, + XATTR_LUSTRE_MDS_MID_EA, + lmm, lmm_size); + break; + default: + rc = -EINVAL; + } + + return rc; +} + +static int fsfilt_smfs_get_md(struct inode *inode, void *lmm, + int lmm_size, enum ea_type type) +{ + int rc; + + switch (type) { + case EA_LOV: + rc = fsfilt_smfs_get_xattr(inode, + XATTR_LUSTRE_MDS_LOV_EA, + lmm, lmm_size); + break; + case EA_MEA: + rc = fsfilt_smfs_get_xattr(inode, + XATTR_LUSTRE_MDS_MEA_EA, + lmm, lmm_size); + break; + case EA_SID: + rc = fsfilt_smfs_get_xattr(inode, + XATTR_LUSTRE_MDS_SID_EA, + lmm, lmm_size); + break; + case EA_MID: + rc = fsfilt_smfs_get_xattr(inode, + XATTR_LUSTRE_MDS_MID_EA, + lmm, lmm_size); + break; + default: + rc = -EINVAL; + } + + return rc; +} + static int fsfilt_smfs_insert_extents_ea(struct inode *inode, unsigned long from, unsigned long num) { @@ -866,21 +890,36 @@ static int fsfilt_smfs_write_extents(struct dentry *dentry, unsigned long from, unsigned long num) { int rc = 0; - ENTRY; - if (SMFS_DO_REC(S2SMI(dentry->d_inode->i_sb))) - rc = smfs_write_extents(dentry->d_inode, dentry, from, num); + struct inode * cache_inode = I2CI(dentry->d_inode); + struct hook_write_msg msg = { + .dentry = dentry, + .count = num, + .pos = from + }; - return rc; + ENTRY; + + /*TODO: fix this later + pre_smfs_inode(dentry->d_inode, cache_inode); + + SMFS_PRE_HOOK(dentry->d_inode, HOOK_WRITE, &msg); + + rc = smfs_write_extents(dentry->d_inode, dentry, from, num); + SMFS_POST_HOOK(dentry->d_inode, HOOK_WRITE, &msg, rc); + post_smfs_inode(dentry->d_inode, cache_inode); + */ + + RETURN(rc); } static int fsfilt_smfs_precreate_rec(struct dentry *dentry, int *count, struct obdo *oa) { int rc = 0; - + /* Why to log precreate?? MDS will do this in any case if (SMFS_DO_REC(S2SMI(dentry->d_inode->i_sb))) rc = smfs_rec_precreate(dentry, count, oa); - + */ return rc; } @@ -1146,7 +1185,7 @@ static struct fsfilt_operations fsfilt_smfs_ops = { .fs_set_ost_flags = fsfilt_smfs_set_ost_flags, .fs_set_mds_flags = fsfilt_smfs_set_mds_flags, .fs_precreate_rec = fsfilt_smfs_precreate_rec, - .fs_get_reint_log_ctxt = fsfilt_smfs_get_reint_log_ctxt, + .fs_get_reint_log_ctxt = NULL, /*fsfilt_smfs_get_reint_log_ctxt,*/ .fs_set_snap_item = fsfilt_smfs_set_snap_item, .fs_do_write_cow = fsfilt_smfs_do_write_cow, }; diff --git a/lustre/smfs/kml.c b/lustre/smfs/kml.c index 338b995..b314eaf 100644 --- a/lustre/smfs/kml.c +++ b/lustre/smfs/kml.c @@ -53,7 +53,6 @@ do { \ pbuf = buffer + length; \ } while (0) - static int smfs_llog_process_rec_cb(struct llog_handle *handle, struct llog_rec_hdr *rec, void *data) { @@ -127,6 +126,7 @@ copy_inode_attr(struct iattr *iattr, struct inode *inode) iattr->ia_size = inode->i_size; } +#if 0 static inline int unpack_rec_data(char **p_buffer, int *size, char *in_data, char *args_data) { @@ -156,65 +156,30 @@ static inline int unpack_rec_data(char **p_buffer, int *size, RETURN(rc); } +#endif int smfs_rec_unpack(struct smfs_proc_args *args, char *record, char **pbuf, int *opcode) { - int offset = *(int *)(record); - char *tmp = record + offset + sizeof(int); + //int offset = *(int *)(record); + //char *tmp = record + offset + sizeof(int); - *opcode = *(int *)tmp; - *pbuf = tmp + sizeof(*opcode); + *opcode = *(int *)record; + *pbuf = record + sizeof(*opcode); return 0; } -EXPORT_SYMBOL(smfs_rec_unpack); +EXPORT_SYMBOL(smfs_rec_unpack); /* cmobd/cm_reint.c */ int smfs_write_extents(struct inode *dir, struct dentry *dentry, unsigned long from, unsigned long num) { - return smfs_post_rec_write(dir, dentry, &from, &num); -} -EXPORT_SYMBOL(smfs_write_extents); - -int smfs_rec_setattr(struct inode *dir, struct dentry *dentry, - struct iattr *attr) -{ - return smfs_post_rec_setattr(dir, dentry, attr, NULL); -} -EXPORT_SYMBOL(smfs_rec_setattr); - -int smfs_rec_md(struct inode *inode, void *lmm, int lmm_size) -{ - char *set_lmm = NULL; - int rc = 0; - ENTRY; - - if (!SMFS_DO_REC(S2SMI(inode->i_sb))) - RETURN(0); - - if (lmm) { - OBD_ALLOC(set_lmm, lmm_size + sizeof(lmm_size)); - if (!set_lmm) - RETURN(-ENOMEM); - memcpy(set_lmm, &lmm_size, sizeof(lmm_size)); - memcpy(set_lmm + sizeof(lmm_size), lmm, lmm_size); - rc = smfs_post_rec_setattr(inode, NULL, NULL, set_lmm); - if (rc) { - CERROR("Error: Record md for inode %lu rc=%d\n", - inode->i_ino, rc); - } - } - if (set_lmm) - OBD_FREE(set_lmm, lmm_size + sizeof(lmm_size)); - RETURN(rc); + return 0;//smfs_post_rec_write(dir, dentry, &from, &num); } -EXPORT_SYMBOL(smfs_rec_md); - +#if 0 int smfs_rec_precreate(struct dentry *dentry, int *num, struct obdo *oa) { return smfs_post_rec_create(dentry->d_inode, dentry, num, oa); } -EXPORT_SYMBOL(smfs_rec_precreate); int smfs_process_rec(struct super_block *sb, int count, char *dir, int flags) @@ -272,7 +237,9 @@ int smfs_process_rec(struct super_block *sb, } RETURN(rc); } +#endif +#if 0 /*smfs_path is gotten from intermezzo*/ static char* smfs_path(struct dentry *dentry, struct dentry *root, char *buffer, int buflen) @@ -334,13 +301,6 @@ static int smfs_log_path(struct super_block *sb, RETURN(namelen); } -static inline int log_it(char *buffer, void *data, int length) -{ - memcpy(buffer, &length, sizeof(int)); - memcpy(buffer + sizeof(int), data, length); - return (sizeof(int) + length); -} - static int smfs_pack_rec (char *buffer, struct dentry *dentry, struct inode *dir, void *data1, void *data2, int op) @@ -353,173 +313,6 @@ static int smfs_pack_rec (char *buffer, struct dentry *dentry, return pack_func(buffer, dentry, dir, data1, data2, op); } -int smfs_post_rec_create(struct inode *dir, struct dentry *dentry, - void *data1, void *data2) -{ - struct smfs_super_info *sinfo; - char *buffer = NULL, *pbuf; - int rc = 0, length = 0, buf_len = 0; - ENTRY; - - sinfo = S2SMI(dentry->d_inode->i_sb); - if (!sinfo) - RETURN(-EINVAL); - - OBD_ALLOC(buffer, PAGE_SIZE); - if (!buffer) - GOTO(exit, rc = -ENOMEM); - - buf_len = PAGE_SIZE; - KML_BUF_REC_INIT(buffer, pbuf, buf_len); - rc = smfs_log_path(dir->i_sb, dentry, pbuf, buf_len); - if (rc < 0) - GOTO(exit, rc); - length = rc; - KML_BUF_REC_END(buffer, length, pbuf); - - rc = smfs_pack_rec(pbuf, dentry, dir, - data1, data2, REINT_CREATE); - if (rc <= 0) - GOTO(exit, rc); - else - length += rc; - rc = smfs_llog_add_rec(sinfo, (void*)buffer, length); -exit: - if (buffer) - OBD_FREE(buffer, PAGE_SIZE); - - RETURN(rc); -} - -static int smfs_post_rec_link(struct inode *dir, struct dentry *dentry, - void *data1, void *data2) -{ - struct dentry *new_dentry = (struct dentry *)data1; - int rc = 0, length = 0, buf_len = 0; - char *buffer = NULL, *pbuf = NULL; - struct smfs_super_info *sinfo; - ENTRY; - - sinfo = S2SMI(dir->i_sb); - if (!sinfo) - RETURN(-EINVAL); - OBD_ALLOC(buffer, PAGE_SIZE); - if (!buffer) - GOTO(exit, rc = -ENOMEM); - - buf_len = PAGE_SIZE; - KML_BUF_REC_INIT(buffer, pbuf, buf_len); - - rc = smfs_log_path(dir->i_sb, dentry, pbuf, buf_len); - if (rc < 0) - GOTO(exit, rc); - - length = rc; - KML_BUF_REC_END(buffer, length, pbuf); - - rc = smfs_pack_rec(pbuf, dentry, dir, dentry, - new_dentry, REINT_LINK); - if (rc <= 0) - GOTO(exit, rc); - - length += rc; - rc = smfs_llog_add_rec(sinfo, (void *)buffer, length); -exit: - if (buffer) - OBD_FREE(buffer, PAGE_SIZE); - - RETURN(rc); -} - -static int smfs_post_rec_unlink(struct inode *dir, struct dentry *dentry, - void *data1, void *data2) -{ - struct smfs_super_info *sinfo; - int mode = *((int*)data1); - char *buffer = NULL, *pbuf = NULL; - int length = 0, rc = 0, buf_len = 0; - ENTRY; - - sinfo = S2SMI(dentry->d_inode->i_sb); - if (!sinfo) - RETURN(-EINVAL); - - OBD_ALLOC(buffer, PAGE_SIZE); - if (!buffer) - GOTO(exit, rc = -ENOMEM); - - buf_len = PAGE_SIZE; - KML_BUF_REC_INIT(buffer, pbuf, buf_len); - rc = smfs_log_path(dir->i_sb, dentry, pbuf, buf_len); - if (rc < 0) - GOTO(exit, rc); - - length = rc; - KML_BUF_REC_END(buffer, length, pbuf); - rc = smfs_pack_rec(pbuf, dentry, dir, - &mode, NULL, REINT_UNLINK); - if (rc <= 0) - GOTO(exit, rc); - else - length += rc; - - rc = smfs_llog_add_rec(sinfo, (void*)buffer, length); -exit: - if (buffer) - OBD_FREE(buffer, PAGE_SIZE); - - RETURN(rc); -} - -static int smfs_post_rec_rename(struct inode *dir, struct dentry *dentry, - void *data1, void *data2) -{ - struct smfs_super_info *sinfo; - struct inode *new_dir = (struct inode *)data1; - struct dentry *new_dentry = (struct dentry *)data2; - char *buffer = NULL, *pbuf = NULL; - int rc = 0, length = 0, buf_len = 0; - ENTRY; - - sinfo = S2SMI(dir->i_sb); - if (!sinfo) - RETURN(-EINVAL); - - OBD_ALLOC(buffer, PAGE_SIZE); - if (!buffer) - GOTO(exit, rc = -ENOMEM); - - buf_len = PAGE_SIZE; - KML_BUF_REC_INIT(buffer, pbuf, buf_len); - rc = smfs_log_path(dir->i_sb, dentry, pbuf, buf_len); - if (rc < 0) - GOTO(exit, rc); - - pbuf += rc; - length += rc; - buf_len -= rc; - - /* record new_dentry path. */ - rc = smfs_log_path(dir->i_sb, new_dentry, pbuf, buf_len); - if (rc < 0) - GOTO(exit, rc); - - length += rc; - KML_BUF_REC_END(buffer, length, pbuf); - - rc = smfs_pack_rec(pbuf, dentry, dir, - new_dir, new_dentry, REINT_RENAME); - if (rc <= 0) - GOTO(exit, rc); - length += rc; - - rc = smfs_llog_add_rec(sinfo, (void*)buffer, length); -exit: - if (buffer) - OBD_FREE(buffer, PAGE_SIZE); - RETURN(rc); -} - static int smfs_insert_extents_ea(struct inode *inode, size_t from, loff_t num) { struct fsfilt_operations *fsfilt = S2SMI(inode->i_sb)->sm_fsfilt; @@ -575,7 +368,7 @@ static int smfs_set_dirty_flags(struct inode *inode, int flags) if (SMFS_INODE_OVER_WRITE(inode)) RETURN(rc); /*FIXME later, the blocks needed in journal here will be recalculated*/ - handle = smfs_trans_start(inode, FSFILT_OP_SETATTR, NULL); + handle = smfs_trans_start(inode, FSFILT_OP_SETATTR); if (IS_ERR(handle)) { CERROR("smfs_set_dirty_flag:no space for transaction\n"); RETURN(-ENOSPC); @@ -596,40 +389,193 @@ out: RETURN(rc); } -int smfs_post_rec_setattr(struct inode *inode, struct dentry *dentry, - void *data1, void *data2) -{ - struct smfs_super_info *sinfo; - struct iattr *attr = (struct iattr *)data1; - char *buffer = NULL, *pbuf; +static int all_blocks_present_ea(struct inode *inode) +{ + int rc = 0; + ENTRY; + RETURN(rc); +} +#endif + +/* new plugin API */ +#if 0 +static int kml_pack_path (char **buf, struct dentry * dentry) +{ + char *pbuf; + int length = 0, rc = 0; + + OBD_ALLOC(*buf, PAGE_SIZE); + if (*buf == NULL) + return -ENOMEM; + + length = PAGE_SIZE; + KML_BUF_REC_INIT(*buf, pbuf, length); + rc = smfs_log_path(dentry->d_sb, dentry, pbuf, length); + if (rc < 0) { + return rc; + } + + length = rc; + KML_BUF_REC_END(*buf, length, pbuf); + + return length; +} +#endif +static int kml_create(struct inode * inode, void *arg, struct kml_priv * priv) +{ + struct hook_msg * msg = arg; + //return smfs_post_rec_create(inode, msg->dentry, NULL, NULL); + struct smfs_super_info *smb = S2SMI(inode->i_sb); + char *buffer = NULL; + int rc = 0, length = 0; + ENTRY; + + OBD_ALLOC(buffer, PAGE_SIZE); + if (buffer == NULL) + return -ENOMEM; + + /* + rc = kml_pack_path(&buffer, msg->dentry); + if (rc < 0) + goto exit; + + length = rc; + pbuf = buffer + length; + */ + rc = priv->pack_fn(REINT_CREATE, buffer, msg->dentry, inode, + NULL, NULL); + if (rc <= 0) + GOTO(exit, rc); + + length += rc; + rc = smfs_llog_add_rec(smb, (void*)buffer, length); +exit: + if (buffer) + OBD_FREE(buffer, PAGE_SIZE); + + RETURN(rc); +} + +static int kml_link(struct inode * inode, void *arg, struct kml_priv * priv) +{ + struct hook_link_msg * msg = arg; int rc = 0, length = 0, buf_len = 0; + char *buffer = NULL, *pbuf = NULL; + struct smfs_super_info *smb; ENTRY; + + OBD_ALLOC(buffer, PAGE_SIZE); + if (!buffer) + GOTO(exit, rc = -ENOMEM); + + rc = priv->pack_fn(REINT_LINK, buffer, msg->dentry, inode, + msg->dentry, msg->new_dentry); + if (rc <= 0) + GOTO(exit, rc); + + length += rc; + rc = smfs_llog_add_rec(S2SMI(inode->i_sb), (void *)buffer, length); +exit: + if (buffer) + OBD_FREE(buffer, PAGE_SIZE); + + RETURN(rc); +} - sinfo = S2SMI(inode->i_sb); - if (!sinfo) - RETURN(-EINVAL); +static int kml_unlink(struct inode * inode, void *arg, struct kml_priv * priv) +{ + struct hook_unlink_msg * msg = arg; + char *buffer = NULL; + int length = 0, rc = 0; + ENTRY; + + OBD_ALLOC(buffer, PAGE_SIZE); + if (!buffer) + GOTO(exit, rc = -ENOMEM); + + rc = priv->pack_fn(REINT_UNLINK, buffer, msg->dentry, inode, + &msg->mode, NULL); + if (rc <= 0) + GOTO(exit, rc); + + length += rc; + rc = smfs_llog_add_rec(S2SMI(inode->i_sb), (void*)buffer, length); +exit: + if (buffer) + OBD_FREE(buffer, PAGE_SIZE); + + RETURN(rc); +} + +static int kml_symlink(struct inode * inode, void *arg, struct kml_priv * priv) +{ + struct hook_symlink_msg * msg = arg; + struct smfs_super_info *smb = S2SMI(inode->i_sb); + char *buffer = NULL, *pbuf; + int rc = 0, length = 0; + ENTRY; OBD_ALLOC(buffer, PAGE_SIZE); if (!buffer) GOTO(exit, rc = -ENOMEM); - buf_len = PAGE_SIZE; - KML_BUF_REC_INIT(buffer, pbuf, buf_len); - rc = smfs_log_path(inode->i_sb, dentry, pbuf, buf_len); - if (rc < 0) + rc = priv->pack_fn(REINT_CREATE, buffer, msg->dentry, inode, + msg->symname, &msg->tgt_len); + if (rc <= 0) GOTO(exit, rc); - length = rc; - KML_BUF_REC_END(buffer, length, pbuf); + length += rc; + rc = smfs_llog_add_rec(smb, (void*)buffer, length); +exit: + if (buffer) + OBD_FREE(buffer, PAGE_SIZE); + + RETURN(rc); +} + +static int kml_rename(struct inode * inode, void *arg, struct kml_priv * priv) +{ + struct hook_rename_msg * msg = arg; + char *buffer = NULL, *pbuf = NULL; + int rc = 0, length = 0, buf_len = 0; + ENTRY; + + OBD_ALLOC(buffer, PAGE_SIZE); + if (!buffer) + GOTO(exit, rc = -ENOMEM); - rc = smfs_pack_rec(pbuf, dentry, inode, - data1, data2, REINT_SETATTR); + rc = priv->pack_fn(REINT_RENAME, buffer, msg->dentry, inode, + msg->new_dir, msg->new_dentry); if (rc <= 0) GOTO(exit, rc); - else - length += rc; + length += rc; + + rc = smfs_llog_add_rec(S2SMI(inode->i_sb), (void*)buffer, length); +exit: + if (buffer) + OBD_FREE(buffer, PAGE_SIZE); + RETURN(rc); +} + +static int kml_setattr(struct inode * inode, void *arg, struct kml_priv * priv) +{ + struct hook_setattr_msg * msg = arg; + char *buffer = NULL, *pbuf; + int rc = 0, length = 0, buf_len = 0; + ENTRY; + + OBD_ALLOC(buffer, PAGE_SIZE); + if (!buffer) + GOTO(exit, rc = -ENOMEM); - rc = smfs_llog_add_rec(sinfo, (void*)buffer, length); + rc = priv->pack_fn(REINT_SETATTR, buffer, msg->dentry, inode, + msg->attr, NULL); + if (rc <= 0) + GOTO(exit, rc); + + length += rc; + rc = smfs_llog_add_rec(S2SMI(inode->i_sb), (void*)buffer, length); + /* if (!rc) { if (attr && attr->ia_valid & ATTR_SIZE) { smfs_remove_extents_ea(inode, attr->ia_size, @@ -640,22 +586,17 @@ int smfs_post_rec_setattr(struct inode *inode, struct dentry *dentry, smfs_set_dirty_flags(inode, SMFS_DIRTY_WRITE); } } + */ exit: if (buffer) OBD_FREE(buffer, PAGE_SIZE); RETURN(rc); } - -static int all_blocks_present_ea(struct inode *inode) -{ - int rc = 0; - ENTRY; - RETURN(rc); -} - -int smfs_post_rec_write(struct inode *dir, struct dentry *dentry, void *data1, - void *data2) +/* +static int kml_write(struct inode * inode, void *arg, struct kml_priv * priv) { + struct hook_write_msg * msg = arg; + //return smfs_post_rec_write(inode, msg->dentry, &msg->count, &msg->pos); struct smfs_super_info *sinfo; char *buffer = NULL, *pbuf; int rc = 0, length = 0, buf_len = 0; @@ -698,7 +639,7 @@ int smfs_post_rec_write(struct inode *dir, struct dentry *dentry, void *data1, if (dentry->d_inode->i_size == 0) { smfs_set_dirty_flags(dentry->d_inode, SMFS_OVER_WRITE); } else { - /*insert extent EA*/ + //insert extent EA loff_t off = *((loff_t*)data1); size_t count = *((size_t*)data2); @@ -717,57 +658,9 @@ exit: OBD_FREE(buffer, PAGE_SIZE); RETURN(rc); } +*/ -/* new plugin API */ -struct kml_priv { - struct dentry * kml_llog_dir; -}; - -static int kml_create(struct inode * inode, void *arg) -{ - struct hook_msg * msg = arg; - return smfs_post_rec_create(inode, msg->dentry, NULL, NULL); -} - -static int kml_link(struct inode * inode, void *arg) -{ - struct hook_link_msg * msg = arg; - return smfs_post_rec_link(inode, msg->dentry, msg->new_dentry, NULL); -} - -static int kml_unlink(struct inode * inode, void *arg) -{ - struct hook_unlink_msg * msg = arg; - return smfs_post_rec_unlink(inode, msg->dentry, &msg->mode, NULL); -} - -static int kml_symlink(struct inode * inode, void *arg) -{ - struct hook_symlink_msg * msg = arg; - return smfs_post_rec_create(inode, msg->dentry, &msg->tgt_len, - msg->symname); -} - -static int kml_rename(struct inode * inode, void *arg) -{ - struct hook_rename_msg * msg = arg; - return smfs_post_rec_rename(inode, msg->dentry, msg->new_dir, - msg->new_dentry); -} - -static int kml_setattr(struct inode * inode, void *arg) -{ - struct hook_setattr_msg * msg = arg; - return smfs_post_rec_setattr(inode, msg->dentry, msg->attr, NULL); -} - -static int kml_write(struct inode * inode, void *arg) -{ - struct hook_write_msg * msg = arg; - return smfs_post_rec_write(inode, msg->dentry, &msg->count, &msg->pos); -} - -typedef int (*post_kml_op)(struct inode * inode, void *msg); +typedef int (*post_kml_op)(struct inode * inode, void *msg, struct kml_priv * priv); static post_kml_op smfs_kml_post[HOOK_MAX] = { [HOOK_CREATE] kml_create, [HOOK_LOOKUP] NULL, @@ -779,7 +672,7 @@ static post_kml_op smfs_kml_post[HOOK_MAX] = { [HOOK_MKNOD] kml_create, [HOOK_RENAME] kml_rename, [HOOK_SETATTR] kml_setattr, - [HOOK_WRITE] kml_write, + [HOOK_WRITE] NULL, [HOOK_READDIR] NULL, }; @@ -789,13 +682,14 @@ static int smfs_kml_post_op(int code, struct inode * inode, int rc = 0; ENTRY; - CDEBUG(D_INODE,"KML: inode %lu, code: %u\n", inode->i_ino, code); + //KML don't handle failed ops if (ret) RETURN(0); if (smfs_kml_post[code]) { - rc = smfs_kml_post[code](inode, msg); + CDEBUG(D_INODE,"KML: inode %lu, code: %u\n", inode->i_ino, code); + rc = smfs_kml_post[code](inode, msg, priv); } RETURN(rc); @@ -807,7 +701,8 @@ static int smfs_exit_kml(struct super_block *sb, void * arg, struct kml_priv * p ENTRY; smfs_deregister_plugin(sb, SMFS_PLG_KML); - + OBD_FREE(priv, sizeof(*priv)); + EXIT; return 0; } @@ -817,25 +712,35 @@ static int smfs_trans_kml (struct super_block *sb, void *arg, { int size; - ENTRY; - - size = 20;//LDISKFS_INDEX_EXTRA_TRANS_BLOCKS+LDISKFS_DATA_TRANS_BLOCKS; + //TODO: pass fs opcode and see if kml can participate or not + //one record in log per operation + size = 1; - RETURN(size); + return size; } +extern int mds_rec_pack(int, char*, struct dentry*, struct inode*, void*, void*); + static int smfs_start_kml(struct super_block *sb, void *arg, struct kml_priv * kml_p) { int rc = 0; struct smfs_super_info * smb = S2SMI(sb); struct llog_ctxt **ctxt = &smb->smsi_kml_log; + struct obd_device *obd = arg; ENTRY; //is plugin already activated if (SMFS_IS(smb->plg_flags, SMFS_PLG_KML)) RETURN(0); + if (obd && obd->obd_type && obd->obd_type->typ_name) { + if (strcmp(obd->obd_type->typ_name, "mds")) + RETURN(0); + } + + kml_p->pack_fn = mds_rec_pack; + //this will do OBD_ALLOC() for ctxt rc = llog_catalog_setup(ctxt, KML_LOG_NAME, smb->smsi_exp, smb->smsi_ctxt, smb->sm_fsfilt, @@ -886,16 +791,16 @@ static int smfs_kml_help_op(int code, struct super_block * sb, void * arg, void * priv) { int rc = 0; - ENTRY; + if (smfs_kml_helpers[code]) rc = smfs_kml_helpers[code](sb, arg, (struct kml_priv *) priv); - RETURN(rc); + return rc; } int smfs_init_kml(struct super_block *sb) { int rc = 0; - struct smfs_super_info *smb = S2SMI(sb); + struct kml_priv * priv = NULL; struct smfs_plugin plg = { .plg_type = SMFS_PLG_KML, .plg_pre_op = NULL, @@ -906,6 +811,13 @@ int smfs_init_kml(struct super_block *sb) ENTRY; + OBD_ALLOC(priv, sizeof(*priv)); + if (!priv) { + RETURN(-ENOMEM); + } + + plg.plg_private = priv; + /* rc = ost_rec_pack_init(smb); if (rc) return rc; @@ -913,7 +825,7 @@ int smfs_init_kml(struct super_block *sb) rc = mds_rec_pack_init(smb); if (rc) return rc; - + */ rc = smfs_register_plugin(sb, &plg); RETURN(rc); diff --git a/lustre/smfs/mds_kml.c b/lustre/smfs/mds_kml.c index 2c46eed..6b57a4d 100644 --- a/lustre/smfs/mds_kml.c +++ b/lustre/smfs/mds_kml.c @@ -136,6 +136,8 @@ static int mds_rec_create_pack(char *buffer, struct dentry *dentry, int rc = 0, tgt_len = 0; void *tmp = NULL; + ENTRY; + OBD_ALLOC(op_data, sizeof(*op_data)); if (op_data == NULL) return -ENOMEM; @@ -252,8 +254,7 @@ static int mds_rec_rename_pack(char *buffer, struct dentry *dentry, return rc; } -typedef int (*mds_pack_rec_func)(char *buffer, struct dentry *dentry, - struct inode *dir, void *data1, void *data2); +typedef int (*mds_pack_rec_func)(char *, struct dentry*, struct inode *, void *, void*); static mds_pack_rec_func mds_kml_pack[REINT_MAX + 1] = { [REINT_LINK] mds_rec_link_pack, @@ -263,16 +264,10 @@ static mds_pack_rec_func mds_kml_pack[REINT_MAX + 1] = { [REINT_RENAME] mds_rec_rename_pack, }; -int mds_rec_pack(char *buffer, struct dentry *dentry, struct inode *dir, - void *data1, void *data2, int op) +int mds_rec_pack(int op, char *buffer, struct dentry *dentry, + struct inode *dir, void * arg, void * arg2) { - return mds_kml_pack[op](buffer, dentry, dir, data1, data2); + return mds_kml_pack[op](buffer, dentry, dir, arg, arg2); } -int mds_rec_pack_init(struct smfs_super_info *smsi) -{ - - smsi->smsi_pack_rec[PACK_MDS] = mds_rec_pack; - return 0; -} diff --git a/lustre/smfs/ost_kml.c b/lustre/smfs/ost_kml.c index c0dd244..f2f48b0 100644 --- a/lustre/smfs/ost_kml.c +++ b/lustre/smfs/ost_kml.c @@ -49,6 +49,7 @@ static int smfs_ost_get_id(obd_id *id, char *data, int size) *id = simple_strtoull(data, &endp, 10); else return -EINVAL; + CDEBUG(D_DENTRY,"name = %s\n", data); return 0; } @@ -66,14 +67,16 @@ static int smfs_ost_get_group(struct dentry *dentry, struct obdo *oa) if (dparent_group == NULL || dparent_group == dparent_subdir) return -EINVAL; + CDEBUG(D_DENTRY,"try to find group for dentry %p\n", dparent_group); for (i = 1; i < filter->fo_group_count; i++) { + CDEBUG(D_DENTRY, "group[%i] = %p\n", i, filter->fo_groups[i]); if (filter->fo_groups[i] == dparent_group) { oa->o_gr = i; oa->o_valid |= OBD_MD_FLGROUP; return 0; } } - return -EINVAL; + return -ENOENT; } static int ost_rec_create_pack(char *buffer, struct dentry *dentry, diff --git a/lustre/smfs/smfs_api.h b/lustre/smfs/smfs_api.h index d7911db..25fb44f 100644 --- a/lustre/smfs/smfs_api.h +++ b/lustre/smfs/smfs_api.h @@ -2,6 +2,7 @@ #define SMFS_PLG_KML 0x0001L #define SMFS_PLG_LRU 0x0004L #define SMFS_PLG_COW 0x0020L +#define SMFS_PLG_UNDO 0x0100L #define SMFS_PLG_DUMMY 0x1000L #define SMFS_PLG_ALL (~0L) @@ -24,6 +25,19 @@ struct smfs_plugin { void * plg_private; }; +#define KML_LOG_NAME "smfs_kml" + +struct kml_priv { + /* llog pack function */ + int (* pack_fn)(int, char *, struct dentry*, + struct inode *, void *, void *); +}; + +#define UNDO_LOG_NAME "smfs_undo" +struct undo_priv { + struct llog_ctxt *undo_ctxt; +}; + #define HOOK_CREATE 1 #define HOOK_LOOKUP 2 #define HOOK_LINK 3 @@ -37,10 +51,13 @@ struct smfs_plugin { #define HOOK_WRITE 11 #define HOOK_READDIR 12 #define HOOK_F_SETATTR 13 -#define HOOK_MAX 14 +#define HOOK_SETXATTR 14 +#define HOOK_F_SETXATTR 15 +#define HOOK_MAX 16 struct hook_msg { struct dentry * dentry; + }; struct hook_link_msg { @@ -86,34 +103,8 @@ void smfs_pre_hook (struct inode*, int, void*); void smfs_post_hook(struct inode*,int, void*, int); #define SMFS_PRE_HOOK(inode, op, msg) smfs_pre_hook (inode, op, msg) -/*\ -do { \ - struct smfs_super_info *smb = S2SMI(inode->i_sb); \ - struct list_head *hlist = &smb->smsi_plg_list; \ - struct smfs_plugin *plg; \ - \ - list_for_each_entry(plg, hlist, plg_list) { \ - if (plg->plg_pre_op) \ - plg->plg_pre_op(op, inode, msg, 0, \ - plg->plg_private); \ - } \ -} while(0) -*/ - #define SMFS_POST_HOOK(inode, op, msg, rc) smfs_post_hook(inode, op, msg, rc) -/*\ -do { \ - struct smfs_super_info *smb = S2SMI(inode->i_sb); \ - struct list_head *hlist = &smb->smsi_plg_list; \ - struct smfs_plugin *plg; \ - \ - list_for_each_entry(plg, hlist, plg_list) { \ - if (plg->plg_post_op) \ - plg->plg_post_op(op, inode, msg, rc, \ - plg->plg_private); \ - } \ -} while(0) -*/ + #define PLG_EXIT 0 #define PLG_TRANS_SIZE 1 #define PLG_TEST_INODE 2 diff --git a/lustre/smfs/smfs_internal.h b/lustre/smfs/smfs_internal.h index e2eedd1..2d3bfd3 100644 --- a/lustre/smfs/smfs_internal.h +++ b/lustre/smfs/smfs_internal.h @@ -59,11 +59,8 @@ struct smfs_control_device { #define SYMLINK_OPS_CHECK 0x20 #define DIR_OPS_CHECK 0x40 -#define KML_LOG_NAME "kml_rec" - #define MYPATHLEN(buffer, path) ((buffer) + PAGE_SIZE - (path)) - #define PACK_KML_REC_INIT(buffer, op_code) \ do{ \ int opcode = op_code; \ @@ -115,20 +112,10 @@ static inline struct journal_operations *journal_ops(struct smfs_super_info *smb return &smb->sm_ops->sm_journal_ops; } -struct smfs_hook_ops *smfs_alloc_hook_ops(char *name, - smfs_hook_func pre_hook, - smfs_hook_func post_hook); - -void smfs_free_hook_ops(struct smfs_hook_ops *hops); -int smfs_register_hook_ops(struct smfs_super_info *smb, - struct smfs_hook_ops *smh_ops); - -struct smfs_hook_ops *smfs_unregister_hook_ops(struct smfs_super_info *smb, - char *name); /*smfs_lib.c*/ void smfs_put_super(struct super_block *sb); int smfs_fill_super(struct super_block *sb, void *data, int silent); -int smfs_post_setup(struct super_block *, struct vfsmount *); +int smfs_post_setup(struct obd_device *, struct vfsmount *, struct dentry *); void smfs_post_cleanup(struct super_block *); /*sysctl.c*/ extern int sm_debug_level; @@ -170,7 +157,7 @@ struct smfs_iget_args { /*symlink.c*/ extern struct inode_operations smfs_sym_iops; extern struct file_operations smfs_sym_fops; -/*journal.c */ + void *smfs_trans_start(struct inode *inode, int op, void *desc_private); void smfs_trans_commit(struct inode *inode, void *handle, int force_sync); @@ -196,10 +183,9 @@ int mds_rec_pack_init(struct smfs_super_info *smb); int ost_rec_pack_init(struct smfs_super_info *smb); /*smfs_llog.c*/ -extern int smfs_llog_setup(struct super_block *sb, struct vfsmount *mnt); -extern int smfs_llog_cleanup(struct super_block *sb); -extern int smfs_llog_add_rec(struct smfs_super_info * sinfo, void *data, - int data_size); +extern int smfs_llog_setup(struct smfs_super_info *); +extern int smfs_llog_cleanup(struct smfs_super_info *); +extern int smfs_llog_add_rec(struct smfs_super_info *, void *, int); /*ioctl.c*/ extern int init_smfs_psdev(void); extern void smfs_cleanup_psdev(void); diff --git a/lustre/smfs/smfs_lib.c b/lustre/smfs/smfs_lib.c index 13e64ef..9723e74 100644 --- a/lustre/smfs/smfs_lib.c +++ b/lustre/smfs/smfs_lib.c @@ -118,6 +118,8 @@ static struct smfs_super_info *smfs_init_smb(struct super_block *sb) RETURN(NULL); S2FSI(sb) = smb; + INIT_LIST_HEAD(&smb->smsi_plg_list); + RETURN(smb); } @@ -162,10 +164,41 @@ void smfs_cleanup_fsfilt_ops(struct smfs_super_info *smb) fsfilt_put_ops(smb->sm_fsfilt); } -int smfs_post_setup(struct super_block *sb, struct vfsmount *mnt) +static void smfs_filter_flags(struct filter_obd * filt, struct inode * o_dir) +{ + struct dentry * dentry = NULL; + int i,j; + + CDEBUG(D_SUPER,"OST OBD post_setup\n"); + /* enable plugins for all in O */ + SMFS_SET(I2SMI(o_dir)->smi_flags, SMFS_PLG_ALL); + /* enable plugins for all already created d dirs */ + for (j = 1; j < filt->fo_group_count; j++) { + for (i = 0; i < filt->fo_subdir_count; i++) { + dentry = (filt->fo_subdirs + j)->dentry[i]; + SMFS_SET(I2SMI(dentry->d_inode)->smi_flags, + SMFS_PLG_ALL); + } + } +} + +static void smfs_mds_flags(struct mds_obd * mds, struct inode * root) +{ + struct inode * pend = mds->mds_pending_dir->d_inode; + + CDEBUG(D_SUPER,"MDS OBD post_setup\n"); + /* enable plugins for all in ROOT */ + SMFS_SET(I2SMI(root)->smi_flags, SMFS_PLG_ALL); + /* the same for PENDING */ + SMFS_SET(I2SMI(pend)->smi_flags, SMFS_PLG_ALL); +} + + +int smfs_post_setup(struct obd_device *obd, struct vfsmount *mnt, + struct dentry * root_dentry) { struct lvfs_run_ctxt saved, *current_ctxt = NULL; - struct smfs_super_info *smb = S2SMI(sb); + struct smfs_super_info *smb = S2SMI(mnt->mnt_sb); int rc = 0; ENTRY; @@ -183,13 +216,37 @@ int smfs_post_setup(struct super_block *sb, struct vfsmount *mnt) push_ctxt(&saved, smb->smsi_ctxt, NULL); - rc = smfs_llog_setup(sb, mnt); + rc = smfs_llog_setup(smb); if (!rc) { - rc = SMFS_PLG_HELP(sb, PLG_START, NULL); + rc = SMFS_PLG_HELP(mnt->mnt_sb, PLG_START, NULL); } pop_ctxt(&saved, smb->smsi_ctxt, NULL); + /* connect KML ctxt to obd */ + if (obd && smb->smsi_kml_log) { + smb->smsi_kml_log->loc_idx = LLOG_REINT_ORIG_CTXT; + smb->smsi_kml_log->loc_obd = obd; + obd->obd_llog_ctxt[LLOG_REINT_ORIG_CTXT] = smb->smsi_kml_log; + } + + /* enable plugins for directories on MDS or OST */ + if (obd && obd->obd_type && obd->obd_type->typ_name) { + if (!strcmp(obd->obd_type->typ_name, "obdfilter")) { + struct filter_obd *filt = &obd->u.filter; + + smfs_filter_flags(filt, root_dentry->d_inode); + } + else if (!strcmp(obd->obd_type->typ_name, "mds")) { + struct mds_obd * mds = &obd->u.mds; + + smfs_mds_flags(mds, root_dentry->d_inode); + } + else + CDEBUG(D_SUPER,"Unknown OBD (%s) post_setup\n", + obd->obd_type->typ_name); + } + if (rc) OBD_FREE(current_ctxt, sizeof(*current_ctxt)); @@ -202,7 +259,7 @@ void smfs_post_cleanup(struct super_block *sb) ENTRY; - smfs_llog_cleanup(sb); + smfs_llog_cleanup(smb); SMFS_PLG_HELP(sb, PLG_STOP, NULL); if (smb->smsi_ctxt) @@ -375,6 +432,9 @@ int smfs_fill_super(struct super_block *sb, void *data, int silent) goto out_err; } + /* all entries created until post_setup() should not be logged */ + SMFS_CLEAR((I2SMI(root_inode))->smi_flags, SMFS_PLG_ALL); + #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) CDEBUG(D_SUPER, "sb %lx, &sb->u.generic_sbp: %lx\n", (ulong)sb, (ulong)&sb->u.generic_sbp); @@ -402,14 +462,8 @@ void *smfs_trans_start(struct inode *inode, int op, void *desc_private) { struct fsfilt_operations *fsfilt = S2SMI(inode->i_sb)->sm_fsfilt; - CDEBUG(D_INFO, "trans start %p\n", fsfilt->fs_start); - - SMFS_TRANS_OP(inode, op); - - /* There are some problem here. fs_start in fsfilt is used by lustre - * the journal blocks of write rec are not counted in FIXME later */ if (fsfilt->fs_start) - return fsfilt->fs_start(inode, op, desc_private, 0); + return fsfilt->fs_start(inode, op, NULL, 0); return NULL; } @@ -417,12 +471,7 @@ void smfs_trans_commit(struct inode *inode, void *handle, int force_sync) { struct fsfilt_operations *fsfilt = S2SMI(inode->i_sb)->sm_fsfilt; - if (!handle) - return; - - CDEBUG(D_INFO, "trans commit %p\n", fsfilt->fs_commit); - - if (fsfilt->fs_commit) + if (handle && fsfilt->fs_commit) fsfilt->fs_commit(inode->i_sb, inode, handle, force_sync); } /* Plugin API */ @@ -494,7 +543,7 @@ void smfs_pre_hook (struct inode * inode, int op, void * msg) //check that plugin is active if(!SMFS_IS(smb->plg_flags, plg->plg_type)) continue; - //check that inode is not exclusion + //check that inode is allowed if (!SMFS_IS(smi->smi_flags, plg->plg_type)) continue; @@ -518,7 +567,7 @@ void smfs_post_hook (struct inode * inode, int op, void * msg, int ret) //check that plugin is active if(!SMFS_IS(smb->plg_flags, plg->plg_type)) continue; - //check that inode is not exclusion + //check that inode is allowed if (!SMFS_IS(smi->smi_flags, plg->plg_type)) continue; @@ -533,18 +582,24 @@ int smfs_helper (struct super_block * sb, int op, void * msg) { struct smfs_super_info *smb = S2SMI(sb); struct list_head *hlist = &smb->smsi_plg_list; - struct smfs_plugin *plg, *plg_tmp; + struct smfs_plugin *plg, *tmp; int rc = 0; - ENTRY; + //ENTRY; LASSERT(op < PLG_HELPER_MAX); //call hook operations - list_for_each_entry_safe(plg, plg_tmp, hlist, plg_list) { - if (plg->plg_helper) + list_for_each_entry_safe(plg, tmp, hlist, plg_list) { + //check that plugin is active + if(!SMFS_IS(smb->plg_flags, plg->plg_type) && (op != PLG_START)) + continue; + + if (plg->plg_helper) rc += plg->plg_helper(op, sb, msg, plg->plg_private); } - RETURN(rc); + //EXIT; + + return rc; } diff --git a/lustre/smfs/smfs_llog.c b/lustre/smfs/smfs_llog.c index 5891271..7415316 100644 --- a/lustre/smfs/smfs_llog.c +++ b/lustre/smfs/smfs_llog.c @@ -30,7 +30,7 @@ #include #include "smfs_internal.h" -int smfs_llog_setup(struct super_block *sb, struct vfsmount *mnt) +int smfs_llog_setup(struct smfs_super_info *smb) { struct dentry *dentry = NULL; int rc = 0; @@ -38,8 +38,6 @@ int smfs_llog_setup(struct super_block *sb, struct vfsmount *mnt) /* create OBJECTS and LOGS for writing logs */ ENTRY; - LASSERT(mnt); - //push_ctxt(&saved, S2SMI(sb)->smsi_ctxt, NULL); dentry = simple_mkdir(current->fs->pwd, "LOGS", 0777, 1); if (IS_ERR(dentry)) { @@ -49,9 +47,8 @@ int smfs_llog_setup(struct super_block *sb, struct vfsmount *mnt) goto exit; } - S2SMI(sb)->smsi_logs_dir = dentry; - //SMFS_SET(I2SMI(dentry->d_inode)->smi_flags, SMFS_PLG_ALL); - + smb->smsi_logs_dir = dentry; + dentry = simple_mkdir(current->fs->pwd, "OBJECTS", 0777, 1); if (IS_ERR(dentry)) { rc = PTR_ERR(dentry); @@ -60,29 +57,13 @@ int smfs_llog_setup(struct super_block *sb, struct vfsmount *mnt) goto exit; } - S2SMI(sb)->smsi_objects_dir = dentry; - //SMFS_SET(I2SMI(dentry->d_inode)->smi_flags, SMFS_PLG_ALL); - - /* write log will not write to KML, cleanup kml flags */ - //SMFS_CLEAN_INODE_REC(S2SMI(sb)->smsi_objects_dir->d_inode); - //SMFS_CLEAN_INODE_REC(S2SMI(sb)->smsi_logs_dir->d_inode); - - /* log create does not call cache hooks, cleanup hook flags */ - //SMFS_CLEAN_INODE_CACHE_HOOK(S2SMI(sb)->smsi_objects_dir->d_inode); - //SMFS_CLEAN_INODE_CACHE_HOOK(S2SMI(sb)->smsi_logs_dir->d_inode); - + smb->smsi_objects_dir = dentry; - /*if (SMFS_CACHE_HOOK(S2SMI(sb))) { - rc2 = cache_space_hook_setup(sb); - if (!rc && rc2) - rc = rc2; - }*/ exit: - //pop_ctxt(&saved, S2SMI(sb)->smsi_ctxt, NULL); RETURN(rc); } -int smfs_llog_cleanup(struct super_block *sb) +int smfs_llog_cleanup(struct smfs_super_info *smb) { ENTRY; @@ -97,26 +78,27 @@ int smfs_llog_cleanup(struct super_block *sb) rc = rc2; } */ - if (S2SMI(sb)->smsi_logs_dir) { - l_dput(S2SMI(sb)->smsi_logs_dir); - S2SMI(sb)->smsi_logs_dir = NULL; + if (smb->smsi_logs_dir) { + l_dput(smb->smsi_logs_dir); + smb->smsi_logs_dir = NULL; } - if (S2SMI(sb)->smsi_objects_dir) { - l_dput(S2SMI(sb)->smsi_objects_dir); - S2SMI(sb)->smsi_objects_dir = NULL; + if (smb->smsi_objects_dir) { + l_dput(smb->smsi_objects_dir); + smb->smsi_objects_dir = NULL; } RETURN(0); } -int smfs_llog_add_rec(struct smfs_super_info *sinfo, void *data, int data_size) +int smfs_llog_add_rec(struct smfs_super_info *smb, void *data, int data_size) { struct llog_rec_hdr rec; int rc = 0; - + + ENTRY; rec.lrh_len = size_round(data_size); rec.lrh_type = SMFS_UPDATE_REC; - rc = llog_add(sinfo->smsi_kml_log, &rec, data, NULL, 0, NULL, NULL, NULL); + rc = llog_catalog_add(smb->smsi_kml_log, &rec, data, NULL, 0, NULL, NULL, NULL); if (rc != 1) { CERROR("error adding kml rec: %d\n", rc); RETURN(-EINVAL); -- 1.8.3.1