#include <linux/lustre_smfs.h>
#include "smfs_internal.h"
+#if 0
#define KML_BUF_REC_INIT(buffer, pbuf, len) \
do { \
pbuf = buffer + sizeof(int); \
pbuf = buffer + length; \
} while (0)
-static smfs_pack_rec_func smfs_get_rec_pack_type(struct super_block *sb)
+static int smfs_llog_process_rec_cb(struct llog_handle *handle,
+ struct llog_rec_hdr *rec, void *data)
{
- int idx = 0;
- struct smfs_super_info *smsi = S2SMI(sb);
-
- idx = GET_REC_PACK_TYPE_INDEX(smsi->smsi_flags);
- return smsi->smsi_pack_rec[idx];
-}
+ char *rec_buf ;
+ struct smfs_proc_args *args = (struct smfs_proc_args *)data;
+ struct lvfs_run_ctxt saved;
+ int rc = 0;
-static int smfs_post_kml_rec(struct inode *dir, void *de, void *data1,
- void *data2, int op);
+ if (!(le32_to_cpu(handle->lgh_hdr->llh_flags) & LLOG_F_IS_PLAIN)) {
+ CERROR("log is not plain\n");
+ RETURN(-EINVAL);
+ }
-static int smfs_rec_post_hook(struct inode *inode, void *dentry,
- void *data1, void *data2, int op, void *handle)
-{
- int rc = 0;
- ENTRY;
+ if (le32_to_cpu(rec->lrh_type) == LLOG_GEN_REC) {
+ struct llog_cookie cookie;
- if (smfs_do_rec(inode))
- rc = smfs_post_kml_rec(inode, dentry, data1, data2, op);
-
- RETURN(rc);
-}
+ cookie.lgc_lgl = handle->lgh_id;
+ cookie.lgc_index = le32_to_cpu(rec->lrh_index);
-#define KML_HOOK "kml_hook"
+ llog_cancel(handle->lgh_ctxt, 1, &cookie, 0, NULL);
+ RETURN(LLOG_PROC_BREAK);
+ }
-int smfs_rec_init(struct super_block *sb)
-{
- int rc = 0;
- struct smfs_super_info *smfs_info = S2SMI(sb);
- struct smfs_hook_ops *rec_hops = NULL;
+ if (le32_to_cpu(rec->lrh_type) != SMFS_UPDATE_REC)
+ RETURN(-EINVAL);
- SMFS_SET_REC(smfs_info);
+ rec_buf = (char*) (rec + 1);
- rc = ost_rec_pack_init(smfs_info);
- if (rc)
- return rc;
-
- rc = mds_rec_pack_init(smfs_info);
- if (rc)
- return rc;
+ if (!S2SMI(args->sr_sb)->smsi_ctxt)
+ GOTO(exit, rc = -ENODEV);
- rec_hops = smfs_alloc_hook_ops(KML_HOOK, NULL, smfs_rec_post_hook);
- if (!rec_hops) {
- RETURN(-ENOMEM);
+ push_ctxt(&saved, S2SMI(args->sr_sb)->smsi_ctxt, NULL);
+#if 0
+ /*FIXME later should first unpack the rec,
+ * then call lvfs_reint or lvfs_undo
+ * kml rec format has changed lvfs_reint lvfs_undo should
+ * be rewrite FIXME later*/
+ if (SMFS_DO_REINT_REC(args->sr_flags))
+ rc = lvfs_reint(args->sr_sb, rec_buf);
+ else
+ rc = lvfs_undo(args->sr_sb, rec_buf);
+#endif
+ if (!rc && !SMFS_DO_REC_ALL(args->sr_flags)) {
+ args->sr_count --;
+ if (args->sr_count == 0)
+ rc = LLOG_PROC_BREAK;
}
- rc = smfs_register_hook_ops(smfs_info, rec_hops);
- if (rc && rec_hops) {
- smfs_unregister_hook_ops(smfs_info, rec_hops->smh_name);
- smfs_free_hook_ops(rec_hops);
- }
+ pop_ctxt(&saved, S2SMI(args->sr_sb)->smsi_ctxt, NULL);
+exit:
RETURN(rc);
}
-int smfs_rec_cleanup(struct smfs_super_info *smfs_info)
+/* not used curently */
+static smfs_pack_rec_func smfs_get_rec_pack_type(struct super_block *sb)
{
- struct smfs_hook_ops *rec_hops;
- int rc = 0;
+ int idx = 0;
+ struct smfs_super_info *smsi = S2SMI(sb);
- rec_hops = smfs_unregister_hook_ops(smfs_info, KML_HOOK);
- smfs_free_hook_ops(rec_hops);
- SMFS_CLEAN_REC(smfs_info);
-
- RETURN(rc);
+ idx = GET_REC_PACK_TYPE_INDEX(smsi->smsi_flags);
+ return smsi->smsi_pack_rec[idx];
}
+#endif
-static inline void copy_inode_attr(struct iattr *iattr,
- struct inode *inode)
+static inline void
+copy_inode_attr(struct iattr *iattr, struct inode *inode)
{
iattr->ia_mode = inode->i_mode;
iattr->ia_uid = inode->i_uid;
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)
{
int args_len = 0;
int rc = 0;
+ ENTRY;
if (args_data)
args_len = strlen(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);
-
-int smfs_start_rec(struct super_block *sb, struct vfsmount *mnt)
-{
- struct dentry *dentry;
- struct lvfs_run_ctxt saved;
- int rc = 0;
- ENTRY;
-
- if (SMFS_INIT_REC(S2SMI(sb)) ||
- (!SMFS_DO_REC(S2SMI(sb)) && !SMFS_CACHE_HOOK(S2SMI(sb))))
- RETURN(rc);
-
- rc = smfs_llog_setup(sb, mnt);
- if (rc)
- RETURN(rc);
- push_ctxt(&saved, S2SMI(sb)->smsi_ctxt, NULL);
- dentry = simple_mkdir(current->fs->pwd, "DELETE", 0777, 1);
- if (IS_ERR(dentry)) {
- rc = PTR_ERR(dentry);
- CERROR("cannot create DELETE directory: rc = %d\n", rc);
- GOTO(err_exit, rc = -EINVAL);
- }
- S2SMI(sb)->smsi_delete_dir = dentry;
-
- if (!rc)
- SMFS_SET_INIT_REC(S2SMI(sb));
-exit:
- pop_ctxt(&saved, S2SMI(sb)->smsi_ctxt, NULL);
- RETURN(rc);
-err_exit:
- if (S2SMI(sb)->smsi_ctxt)
- OBD_FREE(S2SMI(sb)->smsi_ctxt, sizeof(struct lvfs_run_ctxt));
- goto exit;
-}
-EXPORT_SYMBOL(smfs_start_rec);
-
-int smfs_post_setup(struct super_block *sb, struct vfsmount *mnt)
-{
- struct lvfs_run_ctxt *current_ctxt = NULL;
- struct smfs_super_info *smb = S2SMI(sb);
-
- OBD_ALLOC(current_ctxt, sizeof(*current_ctxt));
- if (!current_ctxt)
- RETURN(-ENOMEM);
- OBD_SET_CTXT_MAGIC(current_ctxt);
-
- current_ctxt->pwdmnt = mnt;
- current_ctxt->pwd = mnt->mnt_root;
- current_ctxt->fs = get_ds();
- smb->smsi_ctxt = current_ctxt;
-
- RETURN(0);
-}
-EXPORT_SYMBOL(smfs_post_setup);
-
-int smfs_post_cleanup(struct super_block *sb)
-{
- struct smfs_super_info *smb = S2SMI(sb);
-
- ENTRY;
-
- if (smb->smsi_ctxt)
- OBD_FREE(S2SMI(sb)->smsi_ctxt, sizeof(struct lvfs_run_ctxt));
- RETURN(0);
-}
-EXPORT_SYMBOL(smfs_post_cleanup);
-
-int smfs_stop_rec(struct super_block *sb)
-{
- int rc = 0;
-
- if (!SMFS_INIT_REC(S2SMI(sb)) ||
- (!SMFS_DO_REC(S2SMI(sb)) && !SMFS_CACHE_HOOK(S2SMI(sb))))
- RETURN(rc);
-
- rc = smfs_llog_cleanup(sb);
-
- SMFS_CLEAN_INIT_REC(S2SMI(sb));
-
- if (S2SMI(sb)->smsi_delete_dir) {
- l_dput(S2SMI(sb)->smsi_delete_dir);
- S2SMI(sb)->smsi_delete_dir = NULL;
- }
- RETURN(rc);
-}
-EXPORT_SYMBOL(smfs_stop_rec);
+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;
+ //smfs_post_rec_write(dir, dentry, &from, &num);
+ return 0;
}
-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)
struct llog_handle *loghandle;
struct smfs_proc_args args;
int rc = 0;
+ ENTRY;
if (!SMFS_INIT_REC(S2SMI(sb))) {
CWARN("Did not start up rec server \n");
args.sr_count = count;
args.sr_data = dir;
args.sr_flags = flags ;
- ctxt = S2SMI(sb)->smsi_rec_log;
+ ctxt = S2SMI(sb)->smsi_kml_log;
loghandle = ctxt->loc_handle;
if (count == 0) {
RETURN(rc);
}
-/*smfs_path is gotten from intermezzo*/
-static char* smfs_path(struct dentry *dentry, struct dentry *root, char *buffer,
+/* smfs_path is gotten from intermezzo */
+static char *smfs_path(struct dentry *dentry, struct dentry *root, char *buffer,
int buflen)
{
char * end = buffer + buflen;
char *p_name = buffer + sizeof(int);
char *name = NULL;
int namelen = 0;
+ ENTRY;
+
if (dentry) {
name = smfs_path(dentry, root, p_name, buffer_len - sizeof(int));
namelen = cpu_to_le32(strlen(p_name));
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)
{
smfs_pack_rec_func pack_func;
- int rc;
pack_func = smfs_get_rec_pack_type(dir->i_sb);
- if (!pack_func) {
- return (0);
- }
- rc = pack_func(buffer, dentry, dir, data1, data2, op);
- return rc;
-}
-
-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;
-
- 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;
-
- 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;
-
- 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;
-
- 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);
+ if (!pack_func)
+ return 0;
+ return pack_func(buffer, dentry, dir, data1, data2, op);
}
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;
int rc = 0;
+ ENTRY;
if (SMFS_INODE_OVER_WRITE(inode))
RETURN(rc);
{
struct fsfilt_operations *fsfilt = S2SMI(inode->i_sb)->sm_fsfilt;
int rc = 0;
+ ENTRY;
rc = fsfilt->fs_remove_extents_ea(inode, OFF2BLKS(from, inode),
SIZE2BLKS(num, inode));
{
struct fsfilt_operations *fsfilt = S2SMI(inode->i_sb)->sm_fsfilt;
int rc = 0;
+ ENTRY;
rc = fsfilt->fs_remove_extents_ea(inode, 0, 0xffffffff);
RETURN(rc);
}
+
static int smfs_init_extents_ea(struct inode *inode)
{
struct fsfilt_operations *fsfilt = S2SMI(inode->i_sb)->sm_fsfilt;
int rc = 0;
+ ENTRY;
rc = fsfilt->fs_init_extents_ea(inode);
RETURN(rc);
}
+
static int smfs_set_dirty_flags(struct inode *inode, int flags)
{
struct fsfilt_operations *fsfilt = S2SMI(inode->i_sb)->sm_fsfilt;
void *handle;
int rc = 0;
+ ENTRY;
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;
- int rc = 0, length = 0, buf_len = 0;
+static int all_blocks_present_ea(struct inode *inode)
+{
+ int rc = 0;
+ ENTRY;
+ RETURN(rc);
+}
+#endif
- sinfo = S2SMI(inode->i_sb);
- if (!sinfo)
- RETURN(-EINVAL);
+/* 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;
+ char *buffer = NULL;
+ 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);
+}
+
+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 smfs_super_info *smb = S2SMI(inode->i_sb);
+ struct hook_symlink_msg *msg = arg;
+ int rc = 0, length = 0;
+ char *buffer = NULL;
+ 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);
- rc = smfs_pack_rec(pbuf, dentry, inode,
- data1, data2, REINT_SETATTR);
+ RETURN(rc);
+}
+
+static int kml_rename(struct inode *inode, void *arg, struct kml_priv *priv)
+{
+ struct hook_rename_msg *msg = arg;
+ int rc = 0, length = 0;
+ char *buffer = NULL;
+ ENTRY;
+
+ OBD_ALLOC(buffer, PAGE_SIZE);
+ if (!buffer)
+ GOTO(exit, rc = -ENOMEM);
+
+ 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);
+}
- rc = smfs_llog_add_rec(sinfo, (void*)buffer, length);
+static int kml_setattr(struct inode *inode, void *arg, struct kml_priv *priv)
+{
+ struct hook_attr_msg *msg = arg;
+ int rc = 0, length = 0;
+ char *buffer = NULL;
+ ENTRY;
+
+ OBD_ALLOC(buffer, PAGE_SIZE);
+ if (!buffer)
+ GOTO(exit, rc = -ENOMEM);
+
+ 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)
+
+static int kml_setxattr(struct inode *inode, void *arg, struct kml_priv *priv)
{
- int rc = 0;
+ struct hook_xattr_msg *msg = arg;
+ struct kml_buffer kbuf;
+ int rc = 0, length = 0;
+ char *buffer = NULL;
+ ENTRY;
+
+ OBD_ALLOC(buffer, PAGE_SIZE);
+ if (!buffer)
+ GOTO(exit, rc = -ENOMEM);
+
+ kbuf.buf = msg->buffer;
+ kbuf.buf_size = msg->buffer_size;
+
+ rc = priv->pack_fn(REINT_SETXATTR, buffer, NULL, inode,
+ msg->name, &kbuf);
+ if (rc <= 0)
+ GOTO(exit, rc);
- RETURN(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,
+ 0xffffffff);
+ if (attr->ia_size == 0)
+ smfs_set_dirty_flags(inode, SMFS_OVER_WRITE);
+ else
+ smfs_set_dirty_flags(inode, SMFS_DIRTY_WRITE);
+ }
+ }
+ */
+exit:
+ if (buffer)
+ OBD_FREE(buffer, PAGE_SIZE);
+ 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;
+ ENTRY;
if (!SMFS_INODE_OVER_WRITE(dentry->d_inode) &&
!SMFS_INODE_DIRTY_WRITE(dentry->d_inode)) {
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);
}
+*/
-typedef int (*post_kml_rec)(struct inode *dir, struct dentry *dentry,
- void *data1, void *data2);
+typedef int (*post_kml_op)(struct inode *inode, void *msg,
+ struct kml_priv *priv);
-static post_kml_rec smfs_kml_post[HOOK_MAX + 1] = {
- [HOOK_CREATE] smfs_post_rec_create,
+static post_kml_op smfs_kml_post[HOOK_MAX] = {
+ [HOOK_CREATE] kml_create,
[HOOK_LOOKUP] NULL,
- [HOOK_LINK] smfs_post_rec_link,
- [HOOK_UNLINK] smfs_post_rec_unlink,
- [HOOK_SYMLINK] smfs_post_rec_create,
- [HOOK_MKDIR] smfs_post_rec_create,
- [HOOK_RMDIR] smfs_post_rec_unlink,
- [HOOK_MKNOD] smfs_post_rec_create,
- [HOOK_RENAME] smfs_post_rec_rename,
- [HOOK_SETATTR] smfs_post_rec_setattr,
- [HOOK_WRITE] smfs_post_rec_write,
+ [HOOK_LINK] kml_link,
+ [HOOK_UNLINK] kml_unlink,
+ [HOOK_SYMLINK] kml_symlink,
+ [HOOK_MKDIR] kml_create,
+ [HOOK_RMDIR] kml_unlink,
+ [HOOK_MKNOD] kml_create,
+ [HOOK_RENAME] kml_rename,
+ [HOOK_SETATTR] kml_setattr,
+ [HOOK_WRITE] NULL,
[HOOK_READDIR] NULL,
+ [HOOK_F_SETXATTR] kml_setxattr,
};
-static int smfs_post_kml_rec(struct inode *dir, void *de, void *data1,
- void *data2, int op)
+
+static int smfs_kml_post_op(hook_op code, struct inode * inode,
+ void * msg, int ret, void * priv)
{
- if (smfs_kml_post[op]) {
- struct dentry *dentry = (struct dentry *)de;
+ int rc = 0;
+
+ ENTRY;
+
+ //check if inode has flag for KML
+ if (!SMFS_IS(I2SMI(inode)->smi_flags, SMFS_PLG_KML))
+ RETURN(0);
+
+ //KML don't handle failed ops
+ if (ret)
+ RETURN(0);
- return smfs_kml_post[op](dir, dentry, data1, data2);
+ if (smfs_kml_post[code]) {
+ CDEBUG(D_INODE,"KML: inode %lu, code: %u\n",
+ inode->i_ino, code);
+ rc = smfs_kml_post[code](inode, msg, priv);
}
+
+ RETURN(rc);
+}
+
+/* Helpers */
+static int smfs_trans_kml (struct super_block *sb, void *arg,
+ struct kml_priv * priv)
+{
+ int size = 1;
+ ENTRY;
+
+ /* FIXME-MIKE: pass fs opcode and see if kml can participate or not one
+ * record in log per operation size = 1 */
+
+ RETURN(size);
+}
+
+static int smfs_start_kml(struct super_block *sb, void *arg,
+ struct kml_priv *kml_p)
+{
+ struct smfs_super_info *smb = S2SMI(sb);
+ struct llog_ctxt **ctxt = &smb->smsi_kml_log;
+ struct obd_device *obd = arg;
+ int rc = 0;
+ 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, OBD_MDS_DEVICENAME)) {
+ kml_p->pack_fn = mds_rec_pack;
+ } else if (!strcmp(obd->obd_type->typ_name, OBD_FILTER_DEVICENAME)) {
+ kml_p->pack_fn = ost_rec_pack;
+ } else {
+ CWARN("unexpected device type: %s\n", obd->obd_type->typ_name);
+ }
+ }
+
+ LASSERT(kml_p->pack_fn != NULL);
+
+ /* this will do OBD_ALLOC() for ctxt */
+ rc = llog_catalog_setup(ctxt, KML_LOG_NAME, smb->smsi_exp,
+ smb->smsi_ctxt, smb->sm_fsfilt,
+ smb->smsi_logs_dir, smb->smsi_objects_dir);
+ if (rc) {
+ CERROR("failed to initialize kml log list catalog %d\n", rc);
+ RETURN(rc);
+ }
+
+ /* 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;
+ smb->smsi_kml_log->loc_llogs = &obd->obd_llogs;
+ obd->obd_llogs.llog_ctxt[LLOG_REINT_ORIG_CTXT] = smb->smsi_kml_log;
+ }
+
+ SMFS_SET(smb->plg_flags, SMFS_PLG_KML);
+ RETURN(0);
+}
+
+int smfs_stop_kml(struct super_block *sb, void *arg,
+ struct kml_priv * kml_p)
+{
+ struct smfs_super_info * smb = S2SMI(sb);
+ struct llog_ctxt *ctxt = smb->smsi_kml_log;
+ struct obd_device * obd = ctxt->loc_obd;
+ ENTRY;
+
+ if (!SMFS_IS(smb->plg_flags, SMFS_PLG_KML))
+ RETURN(0);
+
+ SMFS_CLEAR(smb->plg_flags, SMFS_PLG_KML);
+
+ llog_catalog_cleanup(ctxt);
+ obd->obd_llogs.llog_ctxt[LLOG_REINT_ORIG_CTXT] = NULL;
+ OBD_FREE(ctxt, sizeof(*ctxt));
+
+ RETURN(0);
+}
+
+typedef int (*kml_helper)(struct super_block * sb, void *msg, struct kml_priv *);
+static kml_helper smfs_kml_helpers[PLG_HELPER_MAX] = {
+ [PLG_START] smfs_start_kml,
+ [PLG_STOP] smfs_stop_kml,
+ [PLG_TRANS_SIZE] smfs_trans_kml,
+ [PLG_TEST_INODE] NULL,
+ [PLG_SET_INODE] NULL,
+};
+
+static int smfs_kml_help_op(int code, struct super_block * sb,
+ void * arg, void * priv)
+{
+ int rc = 0;
+
+ if (smfs_kml_helpers[code])
+ rc = smfs_kml_helpers[code](sb, arg, (struct kml_priv *) priv);
+ return rc;
+}
+
+static int smfs_exit_kml(struct super_block *sb, void * arg)
+{
+ struct smfs_plugin * plg = NULL;
+ struct kml_priv * priv = arg;
+ ENTRY;
+
+ plg = smfs_deregister_plugin(sb, SMFS_PLG_KML);
+ if (plg)
+ OBD_FREE(plg, sizeof(*plg));
+ else
+ CERROR("Cannot find KLM plugin while unregistering\n");
+
+ if (priv)
+ OBD_FREE(priv, sizeof(*priv));
+
+ EXIT;
return 0;
}
+
+int smfs_init_kml(struct super_block *sb)
+{
+ int rc = 0;
+ struct kml_priv * priv = NULL;
+ struct smfs_plugin * plg = NULL;
+ ENTRY;
+
+ OBD_ALLOC(plg, sizeof(*plg));
+ if (!plg) {
+ rc = -ENOMEM;
+ goto exit;
+ }
+
+ plg->plg_type = SMFS_PLG_KML;
+ plg->plg_pre_op = NULL;
+ plg->plg_post_op = smfs_kml_post_op;
+ plg->plg_helper = smfs_kml_help_op;
+ plg->plg_exit = smfs_exit_kml;
+
+ OBD_ALLOC(priv, sizeof(*priv));
+ if (!priv) {
+ rc = -ENOMEM;
+ goto exit;
+ }
+
+ plg->plg_private = priv;
+
+ rc = smfs_register_plugin(sb, plg);
+ if (!rc)
+ RETURN(0);
+exit:
+ if (priv)
+ OBD_FREE(priv, sizeof(*priv));
+
+ if (plg)
+ OBD_FREE(plg, sizeof(*plg));
+
+ RETURN(rc);
+}
+
+
git://git.whamcloud.com / fs / lustre-release.git / blobdiff