struct fsfilt_operations *cache_fsfilt;
struct smfs_file_info *sfi;
struct inode *cache_inode;
- loff_t tmp_ppos;
loff_t *cache_ppos;
ssize_t rc = -EIO;
+ struct hook_msg msg = {
+ .dentry = file->f_dentry,
+ };
ENTRY;
if (sfi->magic != SMFS_FILE_MAGIC)
BUG();
- if (off != &(file->f_pos))
- cache_ppos = &tmp_ppos;
- else
- cache_ppos = &sfi->c_file->f_pos;
- *cache_ppos = *off;
+ pre_smfs_file(file, off, &cache_ppos);
+ SMFS_PRE_HOOK(file->f_dentry->d_inode, HOOK_READDIR, &msg);
- pre_smfs_inode(file->f_dentry->d_inode, cache_inode);
#if CONFIG_SNAPFS
/*readdir page*/
if (smfs_dotsnap_inode(file->f_dentry->d_inode)) {
cache_ppos);
#endif
- *off = *cache_ppos;
- post_smfs_inode(file->f_dentry->d_inode, cache_inode);
- duplicate_file(file, sfi->c_file);
-
+ SMFS_POST_HOOK(file->f_dentry->d_inode, HOOK_READDIR, &msg, rc);
+ post_smfs_file(file);
+
RETURN(rc);
}
struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
struct inode *cache_inode = NULL;
int rc = -EIO;
-
+ struct hook_rw_msg msg = {
+ .write = create,
+ };
+ hook_op hook = create ? HOOK_WRITE : HOOK_READ;
ENTRY;
+
if (!cache_fsfilt)
RETURN(-EINVAL);
if (!cache_fsfilt->fs_map_inode_pages)
RETURN(-ENOSYS);
+ SMFS_PRE_HOOK(inode, hook, &msg);
down(&cache_inode->i_sem);
rc = cache_fsfilt->fs_map_inode_pages(cache_inode, page, pages, blocks,
created, create, sem);
up(&cache_inode->i_sem);
+ SMFS_POST_HOOK(inode, hook, &msg, rc);
RETURN(rc);
}
struct fsfilt_operations *cache_fsfilt;
struct inode *cache_inode;
struct smfs_file_info *sfi;
- loff_t tmp_ppos;
loff_t *cache_ppos;
ssize_t rc;
RETURN(-EINVAL);
cache_inode = I2CI(file->f_dentry->d_inode);
-
if (!cache_inode)
RETURN(-EINVAL);
sfi = F2SMFI(file);
- if (sfi->magic != SMFS_FILE_MAGIC) BUG();
-
- if (offs != &(file->f_pos))
- cache_ppos = &tmp_ppos;
- else
- cache_ppos = &sfi->c_file->f_pos;
- *cache_ppos = *offs;
-
- pre_smfs_inode(file->f_dentry->d_inode, cache_inode);
+ LASSERT(sfi->magic == SMFS_FILE_MAGIC);
if (!cache_fsfilt->fs_read_record)
RETURN(-ENOSYS);
+ pre_smfs_file(file, offs, &cache_ppos);
rc = cache_fsfilt->fs_read_record(sfi->c_file, buf, size, cache_ppos);
-
- *offs = *cache_ppos;
- post_smfs_inode(file->f_dentry->d_inode, cache_inode);
- duplicate_file(file, sfi->c_file);
+ post_smfs_file(file);
RETURN(rc);
}
struct fsfilt_operations *cache_fsfilt;
struct inode *cache_inode;
struct smfs_file_info *sfi;
- loff_t tmp_ppos;
loff_t *cache_ppos;
ssize_t rc = -EIO;
RETURN(-EINVAL);
cache_inode = I2CI(file->f_dentry->d_inode);
-
if (!cache_inode)
RETURN(-EINVAL);
sfi = F2SMFI(file);
- if (sfi->magic != SMFS_FILE_MAGIC)
- BUG();
-
- if (offs != &(file->f_pos))
- cache_ppos = &tmp_ppos;
- else
- cache_ppos = &sfi->c_file->f_pos;
- *cache_ppos = *offs;
-
- pre_smfs_inode(file->f_dentry->d_inode, cache_inode);
+ LASSERT(sfi->magic == SMFS_FILE_MAGIC);
if (!cache_fsfilt->fs_write_record)
RETURN(-ENOSYS);
-
+
+ pre_smfs_file(file, offs, &cache_ppos);
rc = cache_fsfilt->fs_write_record(sfi->c_file, buf,
bufsize, cache_ppos, force_sync);
- *offs = *cache_ppos;
- post_smfs_inode(file->f_dentry->d_inode, cache_inode);
- duplicate_file(file, sfi->c_file);
+
+ post_smfs_file(file);
RETURN(rc);
}
static int fsfilt_smfs_post_setup(struct obd_device *obd, struct vfsmount *mnt,
- struct dentry *root_dentry)
+ struct dentry *root_dentry)//, void *data)
{
struct super_block *sb = NULL;
int rc = 0;
if (mnt) {
sb = mnt->mnt_sb;
- if (obd)
- S2SMI(sb)->smsi_exp = obd->obd_self_export;
+ LASSERT(obd);
+ S2SMI(sb)->smsi_exp = obd->obd_self_export;
- rc = smfs_post_setup(obd, mnt, root_dentry);
+ rc = smfs_post_setup(obd, mnt, root_dentry);//, data);
if (rc) {
CERROR("post_setup fails in obd %p rc=%d", obd, rc);
}
-
-
}
RETURN(rc);
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 0
if (SMFS_DO_COW(S2SMI(inode->i_sb)) && (flags & SM_DO_COW))
SMFS_SET_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);
}
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 = {
+ struct smfs_super_info *sbi = S2SMI(dentry->d_inode->i_sb);
+ struct hook_attr_msg msg = {
.dentry = dentry,
.attr = iattr
};
SMFS_PRE_HOOK(dentry->d_inode, HOOK_F_SETATTR, &msg);
+ if (SMFS_DO_HND_IBLOCKS(sbi)) {
+ /* size-on-mds changes i_blocks directly to reflect
+ * aggregated i_blocks from all OSTs -bzzz */
+ cache_inode->i_blocks = dentry->d_inode->i_blocks;
+ }
+
rc = cache_fsfilt->fs_setattr(cache_dentry, handle, iattr, do_trunc);
SMFS_POST_HOOK(dentry->d_inode, HOOK_F_SETATTR, &msg, rc);
static int fsfilt_smfs_set_xattr(struct inode *inode, void *handle, char *name,
void *buffer, int buffer_size)
{
- struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
- struct inode *cache_inode = NULL;
- int rc = -EIO;
-
+ struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
+ struct inode *cache_inode = NULL;
+ struct hook_xattr_msg msg = {
+ .name = name,
+ .buffer = buffer,
+ .buffer_size = buffer_size
+ };
+ int rc = -EIO;
+ int lov = 0;
+
ENTRY;
if (!cache_fsfilt)
- RETURN(rc);
+ RETURN(-EIO);
cache_inode = I2CI(inode);
if (!cache_inode)
RETURN(rc);
-
+
+ lov = (!strcmp(name, XATTR_LUSTRE_MDS_LOV_EA));
pre_smfs_inode(inode, cache_inode);
-
+ SMFS_PRE_HOOK(inode, HOOK_F_SETXATTR, &msg);
if (cache_fsfilt->fs_set_xattr)
rc = cache_fsfilt->fs_set_xattr(cache_inode, handle, name,
buffer, buffer_size);
+
+ SMFS_POST_HOOK(inode, HOOK_F_SETXATTR, &msg, rc);
post_smfs_inode(inode, cache_inode);
RETURN(rc);
RETURN(rc);
pre_smfs_inode(inode, cache_inode);
-
if (cache_fsfilt->fs_get_xattr)
rc = cache_fsfilt->fs_get_xattr(cache_inode, name,
buffer, buffer_size);
post_smfs_inode(inode, cache_inode);
-
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)
{
XATTR_LUSTRE_MDS_SID_EA,
lmm, lmm_size);
break;
- case EA_MID:
+ case EA_PID:
+ rc = fsfilt_smfs_set_xattr(inode, handle,
+ XATTR_LUSTRE_MDS_PID_EA,
+ lmm, lmm_size);
+ break;
+ case EA_KEY:
rc = fsfilt_smfs_set_xattr(inode, handle,
- XATTR_LUSTRE_MDS_MID_EA,
+ XATTR_LUSTRE_MDS_KEY_EA,
lmm, lmm_size);
break;
default:
XATTR_LUSTRE_MDS_SID_EA,
lmm, lmm_size);
break;
- case EA_MID:
+ case EA_PID:
+ rc = fsfilt_smfs_get_xattr(inode,
+ XATTR_LUSTRE_MDS_PID_EA,
+ lmm, lmm_size);
+ break;
+ case EA_KEY:
rc = fsfilt_smfs_get_xattr(inode,
- XATTR_LUSTRE_MDS_MID_EA,
+ XATTR_LUSTRE_MDS_KEY_EA,
lmm, lmm_size);
break;
default:
return rc;
}
+// should be rewrote when needed
static int fsfilt_smfs_get_ino_write_extents(struct super_block *sb, ino_t ino,
char **pbuf, int *size)
{
+ int rc = 0;
+#if 0
struct fs_extent *fs_extents;
struct ldlm_extent *extents = NULL;
struct inode *inode;
struct inode *cache_inode;
struct fsfilt_operations *cache_fsfilt = NULL;
struct lvfs_run_ctxt saved;
- int rc = 0, fs_ex_size, ex_num, flags;
+ int fs_ex_size, ex_num, flags;
char *buf = NULL, *ex_buf = NULL;
ENTRY;
if (rc && extents)
OBD_FREE(ex_buf, (*size) * (sizeof(struct ldlm_extent)));
pop_ctxt(&saved, S2SMI(sb)->smsi_ctxt, NULL);
+#endif
return rc;
}
rc = cache_fsfilt->fs_del_dir_entry(obd, cache_dentry);
- if (!rc)
+ if (!rc) {
d_drop(dentry);
-
- post_smfs_inode(dentry->d_inode, cache_inode);
- post_smfs_inode(dentry->d_parent->d_inode, cache_dir);
+ if (cache_inode) {
+ post_smfs_inode(dentry->d_inode, cache_inode);
+ if (S_ISDIR(dentry->d_inode->i_mode))
+ dentry->d_parent->d_inode->i_nlink--;
+ }
+ post_smfs_inode(dentry->d_parent->d_inode, cache_dir);
+ }
exit:
post_smfs_dentry(cache_dentry);
post_smfs_dentry(cache_parent);
}
+static int fsfilt_smfs_set_info (struct super_block *sb, struct inode * inode,
+ __u32 keylen, void *key,
+ __u32 valsize, void *val)
+{
+ int rc = 0;
+ struct plg_info_msg msg = {
+ .key = key,
+ .val = val,
+ };
+ ENTRY;
+
+ if (keylen >= 9 && memcmp(key, "file_read", 9) == 0) {
+ /*
+ * this key used to inform smfs on OST about incoming r/w
+ */
+ struct lustre_id * id = val;
+ struct hook_rw_msg msg = {
+ .write = 0,
+ .id = id,
+ };
+ if (inode)
+ SMFS_POST_HOOK(inode, HOOK_SI_READ, &msg, rc);
+ }
+ else if (keylen >= 10 && memcmp(key, "file_write", 10) == 0) {
+ /*
+ * this key used to inform smfs on OST about incoming r/w
+ */
+ struct lustre_id * id = val;
+ struct hook_rw_msg msg = {
+ .write = 1,
+ .id = id,
+ };
+ if (inode)
+ SMFS_POST_HOOK(inode, HOOK_SI_WRITE, &msg, rc);
+ }
+ else if (keylen >= 10 && memcmp(key, "audit_info", 10) == 0) {
+ /* this key used to pass audit data on MDS */
+ struct audit_info * info = val;
+
+ SMFS_POST_HOOK(inode, HOOK_SPECIAL, info, info->m.result);
+ }
+ else if (keylen >= 8 && memcmp(key, "auditlog", 8) == 0) {
+ /*
+ * this key used to inform smfs on OST about client audit data
+ */
+
+ audit_client_log(sb, val);
+ }
+ else if (keylen == 5 && memcmp(key, "audit", 5) == 0) {
+ smfs_set_audit(sb, inode, (__u64 *)val);
+ }
+ else if (keylen == 7 && memcmp(key, "id2name", 7) == 0) {
+ rc = SMFS_PLG_HELP(sb, PLG_SET_INFO, &msg);
+ }
+ else
+ rc = -ENOENT;
+
+ RETURN(rc);
+}
+
+static int fsfilt_smfs_get_info (struct super_block *sb, struct inode * inode,
+ __u32 keylen, void *key,
+ __u32 *valsize, void *val)
+{
+ int rc = -ENOENT;
+
+ ENTRY;
+
+ if (keylen == 5 && strcmp(key, "audit") == 0) {
+ __u64 * mask = val;
+ rc = smfs_get_audit(sb, inode, NULL, mask);
+ }
+
+ RETURN(rc);
+}
static struct fsfilt_operations fsfilt_smfs_ops = {
.fs_type = "smfs",
.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 = NULL, /*fsfilt_smfs_get_reint_log_ctxt,*/
+ .fs_set_info = fsfilt_smfs_set_info,
+ .fs_get_info = fsfilt_smfs_get_info,
.fs_set_snap_item = fsfilt_smfs_set_snap_item,
.fs_do_write_cow = fsfilt_smfs_do_write_cow,
- };
+};
struct fsfilt_operations *get_smfs_fs_ops(void)
{