-/*
+/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
+ * vim:expandtab:shiftwidth=8:tabstop=8:
+ *
* linux/fs/ext2_obd/ext2_obd.c
*
* Copyright (C) 2001 Cluster File Systems, Inc.
#define FILTER_ROOTINO 2
#define S_SHIFT 12
-
static char * obd_type_by_mode[S_IFMT >> S_SHIFT] = {
[0] "",
[S_IFREG >> S_SHIFT] "R",
[S_IFLNK >> S_SHIFT] "L"
};
+
+/* write the pathname into the string */
static void filter_id(char *buf, obd_id id, obd_mode mode)
{
sprintf(buf, "O/%s/%Ld", obd_type_by_mode[(mode & S_IFMT) >> S_SHIFT],
id);
}
-static struct file *filter_parent(obd_id id, obd_mode mode)
-{
- char path[64];
- struct file *file;
- sprintf(path, "O/%s", obd_type_by_mode[(mode & S_IFMT) >> S_SHIFT]);
-
- file = filp_open(path, O_RDONLY, 0);
- return file;
-}
-
-void push_ctxt(struct obd_run_ctxt *save, struct obd_run_ctxt *new)
-{
- save->fs = get_fs();
- save->pwd = dget(current->fs->pwd);
- save->pwdmnt = mntget(current->fs->pwdmnt);
-
- set_fs(new->fs);
- set_fs_pwd(current->fs, new->pwdmnt, new->pwd);
-}
-
-void pop_ctxt(struct obd_run_ctxt *saved)
-{
- set_fs(saved->fs);
- set_fs_pwd(current->fs, saved->pwdmnt, saved->pwd);
-
- dput(saved->pwd);
- mntput(saved->pwdmnt);
-}
-
-static int simple_mkdir(struct dentry *dir, char *name, int mode)
-{
- struct dentry *dchild;
- int err;
- ENTRY;
-
- dchild = lookup_one_len(name, dir, strlen(name));
- if (IS_ERR(dchild)) {
- EXIT;
- return PTR_ERR(dchild);
- }
-
- if (dchild->d_inode) {
- dput(dchild);
- EXIT;
- return -EEXIST;
- }
-
- err = vfs_mkdir(dir->d_inode, dchild, mode);
- dput(dchild);
-
- EXIT;
- return err;
-}
-
-static int simple_unlink(struct dentry *dir, char *name)
-{
- struct dentry *dchild;
- int err;
- ENTRY;
-
- dchild = lookup_one_len(name, dir, strlen(name));
- if (IS_ERR(dchild)) {
- EXIT;
- return PTR_ERR(dchild);
- }
-
- if (!dchild->d_inode) {
- dput(dchild);
- EXIT;
- return -ENOENT;
- }
-
- err = vfs_unlink(dir->d_inode, dchild);
- dput(dchild);
-
- EXIT;
- return err;
-}
-
-static void filter_prep(struct obd_device *obddev)
+/* setup the object store with correct subdirectories */
+static int filter_prep(struct obd_device *obddev)
{
struct obd_run_ctxt saved;
struct file *file;
struct inode *inode;
loff_t off;
- long rc;
+ int rc = 0;
char rootid[128];
__u64 lastino = 2;
rc = simple_mkdir(current->fs->pwd, "O", 0700);
rc = simple_mkdir(current->fs->pwd, "P", 0700);
rc = simple_mkdir(current->fs->pwd, "D", 0700);
- file = filp_open("O", O_RDONLY, 0);
- if (!file || IS_ERR(file)) {
- CERROR("cannot open O\n");
- goto out;
+ file = filp_open("O", O_RDONLY, 0);
+ if (IS_ERR(file)) {
+ CERROR("cannot open O\n");
+ GOTO(out, rc = PTR_ERR(file));
}
rc = simple_mkdir(file->f_dentry, "R", 0700); /* regular */
rc = simple_mkdir(file->f_dentry, "D", 0700); /* directory */
rc = simple_mkdir(file->f_dentry, "B", 0700); /* block devices */
rc = simple_mkdir(file->f_dentry, "F", 0700); /* fifo's */
rc = simple_mkdir(file->f_dentry, "S", 0700); /* sockets */
- filp_close(file, NULL);
+ filp_close(file, NULL);
filter_id(rootid, FILTER_ROOTINO, S_IFDIR);
file = filp_open(rootid, O_RDWR | O_CREAT, 00755);
if (IS_ERR(file)) {
CERROR("OBD filter: cannot make root directory");
- goto out;
+ GOTO(out, rc = PTR_ERR(file));
}
filp_close(file, 0);
+ /* FIXME: this is the same as the _file_ we just created? */
rc = simple_mkdir(current->fs->pwd, rootid, 0755);
file = filp_open("D/status", O_RDWR | O_CREAT, 0700);
if ( !file || IS_ERR(file) ) {
CERROR("OBD filter: cannot open/create status file\n");
- goto out;
+ GOTO(out, rc = PTR_ERR(file));
}
/* steal operations */
obddev->u.filter.fo_aops = inode->i_mapping->a_ops;
off = 0;
- if (inode->i_size == 0) {
- rc = file->f_op->write(file, (char *)&lastino,
- sizeof(lastino), &off);
- if (rc != sizeof(lastino)) {
+ if (inode->i_size == 0) {
+ ssize_t retval = file->f_op->write(file, (char *)&lastino,
+ sizeof(lastino), &off);
+ if (retval != sizeof(lastino)) {
CERROR("OBD filter: error writing lastino\n");
- goto out;
+ GOTO(out, rc = -EIO);
}
- } else {
- rc = file->f_op->read(file, (char *)&lastino, sizeof(lastino),
- &off);
- if (rc != sizeof(lastino)) {
+ } else {
+ ssize_t retval = file->f_op->read(file, (char *)&lastino,
+ sizeof(lastino), &off);
+ if (retval != sizeof(lastino)) {
CERROR("OBD filter: error reading lastino\n");
- goto out;
+ GOTO(out, rc = -EIO);
}
}
obddev->u.filter.fo_lastino = lastino;
+ filp_close(file, 0);
+ rc = 0;
out:
pop_ctxt(&saved);
+
+ return(rc);
}
+/* cleanup the filter: write last used object id to status file */
static void filter_post(struct obd_device *obddev)
{
struct obd_run_ctxt saved;
}
-/* release per client resources */
+static __u64 filter_next_id(struct obd_device *obddev)
+{
+ __u64 id;
+ spin_lock(&obddev->u.filter.fo_lock);
+ obddev->u.filter.fo_lastino++;
+ id = obddev->u.filter.fo_lastino;
+ spin_unlock(&obddev->u.filter.fo_lock);
+ return id;
+}
+
+/* how to get files, dentries, inodes from object id's */
+static struct file *filter_obj_open(struct obd_device *obddev,
+ __u64 id, __u32 type)
+{
+ struct obd_run_ctxt saved;
+ char name[24];
+ struct super_block *sb;
+ struct file *file;
+
+ sb = obddev->u.filter.fo_sb;
+ if (!sb || !sb->s_dev) {
+ CDEBUG(D_SUPER, "fatal: device not initialized.\n");
+ EXIT;
+ return NULL;
+ }
+
+ if ( !id ) {
+ CDEBUG(D_INODE, "fatal: invalid obdo %Lu\n", id);
+ EXIT;
+ return NULL;
+ }
+
+ if ( ! (type & S_IFMT) ) {
+ CERROR("OBD filter_obj_open, no type (%Ld), mode %o!\n",
+ id, type);
+ }
+
+ filter_id(name, id, type);
+ push_ctxt(&saved, &obddev->u.filter.fo_ctxt);
+ file = filp_open(name, O_RDONLY | O_LARGEFILE, 0);
+ pop_ctxt(&saved);
+
+ CDEBUG(D_INODE, "opening obdo %s\n", name);
+
+ return file;
+}
+
+static struct file *filter_parent(obd_id id, obd_mode mode)
+{
+ char path[64];
+ struct file *file;
+
+ sprintf(path, "O/%s", obd_type_by_mode[(mode & S_IFMT) >> S_SHIFT]);
+
+ file = filp_open(path, O_RDONLY, 0);
+ return file;
+}
+
+
+static struct inode *filter_inode_from_obj(struct obd_device *obddev,
+ __u64 id, __u32 type)
+{
+ struct file *file;
+ struct inode *inode;
+
+ file = filter_obj_open(obddev, id, type);
+ if ( !file ) {
+ CERROR("filter_inode_from_obdo failed\n");
+ return NULL;
+ }
+
+ inode = iget(file->f_dentry->d_inode->i_sb,
+ file->f_dentry->d_inode->i_ino);
+ filp_close(file, 0);
+ return inode;
+}
+
+/* obd methods */
+static int filter_connect(struct obd_conn *conn)
+{
+ int rc;
+
+ MOD_INC_USE_COUNT;
+ rc = gen_connect(conn);
+
+ if (rc)
+ MOD_DEC_USE_COUNT;
+
+ return rc;
+}
+
static int filter_disconnect(struct obd_conn *conn)
{
+ int rc;
+
+ rc = gen_disconnect(conn);
+ if (!rc)
+ MOD_DEC_USE_COUNT;
+
/* XXX cleanup preallocated inodes */
- return gen_disconnect(conn);
-} /* ext2obd_disconnect */
+ return rc;
+}
/* mount the file system (secretly) */
-static int filter_setup(struct obd_device *obddev, obd_count len,
- void *buf)
-
+static int filter_setup(struct obd_device *obddev, obd_count len, void *buf)
{
struct obd_ioctl_data* data = buf;
struct vfsmount *mnt;
- int err;
+ int err = 0;
ENTRY;
-
-
- mnt = do_kern_mount(data->ioc_inlbuf2, 0,
- data->ioc_inlbuf1, NULL);
+
+ MOD_INC_USE_COUNT;
+ mnt = do_kern_mount(data->ioc_inlbuf2, 0, data->ioc_inlbuf1, NULL);
err = PTR_ERR(mnt);
- if (IS_ERR(mnt)) {
- EXIT;
- return err;
- }
+ if (IS_ERR(mnt))
+ GOTO(err_dec, err);
+ /* XXX is this even possible if do_kern_mount succeeded? */
obddev->u.filter.fo_sb = mnt->mnt_root->d_inode->i_sb;
- if (!obddev->u.filter.fo_sb) {
- EXIT;
- return -ENODEV;
- }
+ if (!obddev->u.filter.fo_sb)
+ GOTO(err_put, err = -ENODEV);
obddev->u.filter.fo_vfsmnt = mnt;
obddev->u.filter.fo_fstype = strdup(data->ioc_inlbuf2);
obddev->u.filter.fo_ctxt.pwd = mnt->mnt_root;
obddev->u.filter.fo_ctxt.fs = KERNEL_DS;
- filter_prep(obddev);
+ err = filter_prep(obddev);
+ if (err)
+ GOTO(err_kfree, err);
spin_lock_init(&obddev->u.filter.fo_lock);
- MOD_INC_USE_COUNT;
- EXIT;
- return 0;
-}
+ RETURN(0);
-static __u64 filter_next_id(struct obd_device *obddev)
-{
- __u64 id;
- spin_lock(&obddev->u.filter.fo_lock);
- obddev->u.filter.fo_lastino++;
- id = obddev->u.filter.fo_lastino;
- spin_unlock(&obddev->u.filter.fo_lock);
- return id;
+err_kfree:
+ kfree(obddev->u.filter.fo_fstype);
+err_put:
+ unlock_kernel();
+ mntput(obddev->u.filter.fo_vfsmnt);
+ obddev->u.filter.fo_sb = 0;
+ lock_kernel();
+
+err_dec:
+ MOD_DEC_USE_COUNT;
+ return err;
}
+
static int filter_cleanup(struct obd_device * obddev)
{
struct super_block *sb;
ENTRY;
- if ( !(obddev->obd_flags & OBD_SET_UP) ) {
- EXIT;
- return 0;
- }
+ if ( !(obddev->obd_flags & OBD_SET_UP) )
+ RETURN(0);
if ( !list_empty(&obddev->obd_gen_clients) ) {
CERROR("still has clients!\n");
- EXIT;
- return -EBUSY;
+ RETURN(-EBUSY);
}
sb = obddev->u.filter.fo_sb;
- if (!obddev->u.filter.fo_sb){
- EXIT;
- return 0;
- }
+ if (!obddev->u.filter.fo_sb)
+ RETURN(0);
+
filter_post(obddev);
unlock_kernel();
lock_kernel();
MOD_DEC_USE_COUNT;
- EXIT;
- return 0;
-}
-
-static struct file *filter_obj_open(struct obd_device *obddev,
- struct obdo *oa)
-{
- struct file *file;
- int error = 0;
- char id[24];
- struct obd_run_ctxt saved;
- struct super_block *sb;
-
- sb = obddev->u.filter.fo_sb;
- if (!sb || !sb->s_dev) {
- CDEBUG(D_SUPER, "fatal: device not initialized.\n");
- EXIT;
- return NULL;
- }
-
- if ( !oa->o_id ) {
- CDEBUG(D_INODE, "fatal: invalid obdo %lu\n", (long)oa->o_id);
- EXIT;
- return NULL;
- }
-
- if ( ! (oa->o_mode & S_IFMT) ) {
- CERROR("OBD filter_obj_open, no type (%Ld), mode %o!\n",
- oa->o_id, oa->o_mode);
- }
- filter_id(id, oa->o_id, oa->o_mode);
- push_ctxt(&saved, &obddev->u.filter.fo_ctxt);
- file = filp_open(id , O_RDONLY | O_LARGEFILE, 0);
- pop_ctxt(&saved);
-
- if (IS_ERR(file)) {
- error = PTR_ERR(file);
- file = NULL;
- }
- CDEBUG(D_INODE, "opening obdo %s\n", id);
-
- return file;
+ RETURN(0);
}
-static struct inode *filter_inode_from_obdo(struct obd_device *obddev,
- struct obdo *oa)
-{
- struct file *file;
- struct inode *inode;
-
- file = filter_obj_open(obddev, oa);
- if ( !file ) {
- CERROR("filter_inode_from_obdo failed\n");
- return NULL;
- }
-
- inode = iget(file->f_dentry->d_inode->i_sb, file->f_dentry->d_inode->i_ino);
- filp_close(file, 0);
- return inode;
-}
static inline void filter_from_inode(struct obdo *oa, struct inode *inode)
{
}
#if 0
- else if (ext2obd_has_inline(inode)) {
+ else if (filter_has_inline(inode)) {
CDEBUG(D_INFO, "copying inline from inode to obdo\n");
memcpy(oa->o_inline, inode->u.ext2_i.i_data,
MIN(sizeof(inode->u.ext2_i.i_data),OBD_INLINESZ));
oa->o_valid |= OBD_MD_FLINLINE;
}
- if (ext2obd_has_obdmd(inode)) {
+ if (filter_has_obdmd(inode)) {
/* XXX this will change when we don't store the obdmd in data */
CDEBUG(D_INFO, "copying obdmd from inode to obdo\n");
memcpy(oa->o_obdmd, inode->u.ext2_i.i_data,
return -EINVAL;
}
- if ( !(inode = filter_inode_from_obdo(conn->oc_dev, oa)) ) {
+ if ( !(inode = filter_inode_from_obj(conn->oc_dev,
+ oa->o_id, oa->o_mode)) ) {
EXIT;
return -ENOENT;
}
return -EINVAL;
}
- inode = filter_inode_from_obdo(conn->oc_dev, oa);
+ inode = filter_inode_from_obj(conn->oc_dev, oa->o_id, oa->o_mode);
if ( !inode ) {
EXIT;
return -ENOENT;
return rc;
}
+static int filter_open(struct obd_conn *conn, struct obdo *oa)
+{
+ struct inode *inode;
+ /* ENTRY; */
+
+ if (!gen_client(conn))
+ RETURN(-EINVAL);
+
+ if ( !(inode = filter_inode_from_obj(conn->oc_dev,
+ oa->o_id, oa->o_mode)) )
+ RETURN(-ENOENT);
+
+ return 0;
+} /* filter_open */
+
+static int filter_close(struct obd_conn *conn, struct obdo *oa)
+{
+ struct inode *inode;
+ /* ENTRY; */
+
+ if (!gen_client(conn))
+ RETURN(-EINVAL);
+
+ if ( !(inode = filter_inode_from_obj(conn->oc_dev,
+ oa->o_id, oa->o_mode)) )
+ RETURN(-ENOENT);
+
+ iput(inode); /* for the close */
+ iput(inode); /* for this call */
+ return 0;
+} /* filter_close */
+
static int filter_create (struct obd_conn* conn, struct obdo *oa)
{
char name[64];
ENTRY;
if (!gen_client(conn)) {
- CDEBUG(D_IOCTL, "invalid client %u\n", conn->oc_id);
+ CERROR("invalid client %u\n", conn->oc_id);
return -EINVAL;
}
- CDEBUG(D_IOCTL, "\n");
oa->o_id = filter_next_id(conn->oc_dev);
if ( !(oa->o_mode && S_IFMT) ) {
return -ENOENT;
}
filp_close(file, 0);
- CDEBUG(D_IOCTL, "\n");
/* Set flags for fields we have set in ext2_new_inode */
oa->o_valid |= OBD_MD_FLID | OBD_MD_FLBLKSZ | OBD_MD_FLBLOCKS |
struct obd_client * cli;
struct inode * inode;
struct file *dir;
+ struct file *object;
int rc;
struct obd_run_ctxt saved;
- char id[128];
if (!(cli = gen_client(conn))) {
- CDEBUG(D_IOCTL, "invalid client %u\n", conn->oc_id);
+ CERROR("invalid client %u\n", conn->oc_id);
EXIT;
return -EINVAL;
}
obddev = conn->oc_dev;
- inode = filter_inode_from_obdo(obddev, oa);
-
- if (!inode) {
+ object = filter_obj_open(obddev, oa->o_id, oa->o_mode);
+ if (!object || IS_ERR(object)) {
EXIT;
return -ENOENT;
}
-
+
+ inode = object->f_dentry->d_inode;
inode->i_nlink = 1;
inode->i_mode = 010000;
- iput(inode);
- filter_id(id, oa->o_id, oa->o_mode);
push_ctxt(&saved, &obddev->u.filter.fo_ctxt);
dir = filter_parent(oa->o_id, oa->o_mode);
if (IS_ERR(dir)) {
EXIT;
goto out;
}
-
- rc = simple_unlink(dir->f_dentry, id);
+ dget(dir->f_dentry);
+ dget(object->f_dentry);
+ rc = vfs_unlink(dir->f_dentry->d_inode, object->f_dentry);
filp_close(dir, 0);
+ filp_close(object, 0);
out:
pop_ctxt(&saved);
EXIT;
return -EINVAL;
}
- file = filter_obj_open(conn->oc_dev, oa);
+ file = filter_obj_open(conn->oc_dev, oa->o_id, oa->o_mode);
if (!file || IS_ERR(file)) {
EXIT;
return -PTR_ERR(file);
}
return err;
-} /* ext2obd_read */
+}
/* buffer must lie in user memory here */
return -EINVAL;
}
- file = filter_obj_open(conn->oc_dev, oa);
+ file = filter_obj_open(conn->oc_dev, oa->o_id, oa->o_mode);
if (!file || IS_ERR(file)) {
EXIT;
return -PTR_ERR(file);
}
return err;
-} /* ext2obd_write */
+} /* filter_write */
static int filter_pgcache_brw(int rw, struct obd_conn *conn,
obd_count num_oa,
for (onum = 0; onum < num_oa; onum++) {
int pg;
- file = filter_obj_open(conn->oc_dev, oa[onum]);
+ file = filter_obj_open(conn->oc_dev, oa[onum]->o_id,
+ oa[onum]->o_mode);
if (!file || IS_ERR(file)) {
EXIT;
error = -ENOENT;
return error;
}
+
+struct inode *ioobj_to_inode(struct obd_conn *conn, struct obd_ioobj *o)
+{
+ struct inode *inode = NULL;
+ struct super_block *sb = conn->oc_dev->u.ext2.e2_sb;
+
+ if (!sb || !sb->s_dev) {
+ CDEBUG(D_SUPER, "fatal: device not initialized.\n");
+ EXIT;
+ return NULL;
+ }
+
+ if ( !o->ioo_id ) {
+ CDEBUG(D_INODE, "fatal: invalid obdo %lu\n", (long)o->ioo_id);
+ EXIT;
+ return NULL;
+ }
+
+ inode = filter_inode_from_obj(conn->oc_dev, o->ioo_id, S_IFREG);
+ if (!inode || inode->i_nlink == 0 || is_bad_inode(inode)) {
+ CERROR("from obdo - fatal: invalid inode %ld (%s).\n",
+ (long)o->ioo_id, inode ? inode->i_nlink ? "bad inode" :
+ "no links" : "NULL");
+ if (inode)
+ iput(inode);
+ EXIT;
+ return NULL;
+ }
+
+ return inode;
+}
+
+static int filter_preprw(int cmd, struct obd_conn *conn,
+ int objcount, struct obd_ioobj *obj,
+ int niocount, struct niobuf *nb,
+ struct niobuf *res)
+{
+ struct obd_ioobj *o = obj;
+ struct niobuf *b = nb;
+ struct niobuf *r = res;
+ int i;
+ ENTRY;
+
+ memset(res, 0, sizeof(*res) * niocount);
+
+ for (i = 0; i < objcount; i++, o++) {
+ int j;
+ for (j = 0; j < o->ioo_bufcnt; j++, b++, r++) {
+ struct inode *inode = ioobj_to_inode(conn, o);
+ struct page *page;
+
+ /* FIXME: we need to iput all inodes on error */
+ if (!inode)
+ RETURN(-EINVAL);
+
+ page = lustre_get_page(inode, b->offset >> PAGE_SHIFT);
+ if (IS_ERR(page))
+ RETURN(PTR_ERR(page));
+
+ if (cmd == OBD_BRW_WRITE) {
+ int rc = lustre_prepare_page(0, PAGE_SIZE,page);
+ if (rc)
+ CERROR("i %d j %d objcount %d bufcnt %d , rc %d, offset %Ld\n", i, j, objcount, o->ioo_bufcnt, rc, b->offset);
+ }
+
+ r->addr = (__u64)(unsigned long)page_address(page);
+ r->offset = b->offset;
+ r->page = page;
+ r->len = PAGE_SIZE;
+ }
+ }
+ return 0;
+}
+
+static int filter_commitrw(int cmd, struct obd_conn *conn,
+ int objcount, struct obd_ioobj *obj,
+ int niocount, struct niobuf *res)
+{
+ struct obd_ioobj *o = obj;
+ struct niobuf *r = res;
+ int i;
+ ENTRY;
+
+ for (i = 0; i < objcount; i++, obj++) {
+ int j;
+ for (j = 0 ; j < o->ioo_bufcnt ; j++, r++) {
+ struct page *page = r->page;
+
+ if (!r->page)
+ LBUG();
+
+ if (cmd == OBD_BRW_WRITE) {
+ int rc = lustre_commit_page(page, 0, PAGE_SIZE);
+
+ /* FIXME: still need to iput the other inodes */
+ if (rc)
+ RETURN(rc);
+ } else
+ lustre_put_page(page);
+
+ iput(page->mapping->host);
+ }
+ }
+ RETURN(0);
+}
+
static int filter_statfs (struct obd_conn *conn, struct statfs * statfs)
{
struct super_block *sb;
err = sb->s_op->statfs(sb, statfs);
EXIT;
return err;
-} /* ext2obd_statfs */
+} /* filter_statfs */
static int filter_get_info(struct obd_conn *conn, obd_count keylen,
o_get_info: filter_get_info,
o_setup: filter_setup,
o_cleanup: filter_cleanup,
- o_connect: gen_connect,
+ o_connect: filter_connect,
o_disconnect: filter_disconnect,
o_statfs: filter_statfs,
o_getattr: filter_getattr,
o_create: filter_create,
o_setattr: filter_setattr,
o_destroy: filter_destroy,
+ o_open: filter_open,
+ o_close: filter_close,
o_read: filter_read,
o_write: filter_write,
o_brw: filter_pgcache_brw,
o_punch: filter_truncate,
+ o_preprw: filter_preprw,
+ o_commitrw: filter_commitrw
#if 0
- o_preallocate: ext2obd_preallocate_inodes,
- o_migrate: ext2obd_migrate,
+ o_preallocate: filter_preallocate_inodes,
+ o_migrate: filter_migrate,
o_copy: gen_copy_data,
- o_iterate: ext2obd_iterate
+ o_iterate: filter_iterate
#endif
};
git://git.whamcloud.com / fs / lustre-release.git / blobdiff