//int mode = 0;
struct hook_unlink_msg msg = {
.dentry = dentry,
- .mode = 0
+ .mode = dentry->d_inode->i_mode
};
ENTRY;
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;
}
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)
{
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);
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);
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);
}
{
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);
}
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)
{
*ctxt = smfs_info->smsi_kml_log;
RETURN(rc);
}
+#endif
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)
{
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)
{
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;
}
.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,
};
pbuf = buffer + length; \
} while (0)
-
static int smfs_llog_process_rec_cb(struct llog_handle *handle,
struct llog_rec_hdr *rec, void *data)
{
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)
{
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)
}
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)
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)
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;
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);
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,
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;
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);
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,
[HOOK_MKNOD] kml_create,
[HOOK_RENAME] kml_rename,
[HOOK_SETATTR] kml_setattr,
- [HOOK_WRITE] kml_write,
+ [HOOK_WRITE] NULL,
[HOOK_READDIR] NULL,
};
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);
ENTRY;
smfs_deregister_plugin(sb, SMFS_PLG_KML);
-
+ OBD_FREE(priv, sizeof(*priv));
+
EXIT;
return 0;
}
{
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,
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,
ENTRY;
+ OBD_ALLOC(priv, sizeof(*priv));
+ if (!priv) {
+ RETURN(-ENOMEM);
+ }
+
+ plg.plg_private = priv;
+ /*
rc = ost_rec_pack_init(smb);
if (rc)
return rc;
rc = mds_rec_pack_init(smb);
if (rc)
return rc;
-
+ */
rc = smfs_register_plugin(sb, &plg);
RETURN(rc);
int rc = 0, tgt_len = 0;
void *tmp = NULL;
+ ENTRY;
+
OBD_ALLOC(op_data, sizeof(*op_data));
if (op_data == NULL)
return -ENOMEM;
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,
[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;
-}
*id = simple_strtoull(data, &endp, 10);
else
return -EINVAL;
+ CDEBUG(D_DENTRY,"name = %s\n", data);
return 0;
}
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,
#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)
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
#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 {
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
#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; \
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;
/*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);
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);
RETURN(NULL);
S2FSI(sb) = smb;
+ INIT_LIST_HEAD(&smb->smsi_plg_list);
+
RETURN(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<n> 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;
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));
ENTRY;
- smfs_llog_cleanup(sb);
+ smfs_llog_cleanup(smb);
SMFS_PLG_HELP(sb, PLG_STOP, NULL);
if (smb->smsi_ctxt)
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);
{
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;
}
{
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 */
//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;
//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;
{
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;
}
#include <linux/lvfs.h>
#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;
/* 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)) {
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);
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;
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);
git://git.whamcloud.com / fs / lustre-release.git / commitdiff