#ifdef __KERNEL__
struct obd_request {
- struct obdo *oa;
- struct obd_conn *conn;
- __u32 plen1;
- char *pbuf1;
+ struct obdo *oa;
+ struct obd_conn *conn;
+ __u32 plen1;
+ char *pbuf1;
};
static inline int obd_check_conn(struct obd_conn *conn)
{
- struct obd_device *obd;
- if (!conn) {
- printk("obd_check_conn: NULL conn\n");
- return -ENOTCONN;
- }
- obd = conn->oc_dev;
- if (!obd) {
- printk("obd_check_conn: NULL obd\n");
- return -ENODEV;
- }
-
- if (!obd->obd_flags & OBD_ATTACHED ) {
- printk("obd_check_conn: obd %d not attached\n", obd->obd_minor);
- return -ENODEV;
- }
-
- if (!obd->obd_flags & OBD_SET_UP) {
- printk("obd_check_conn: obd %d not setup\n", obd->obd_minor);
- return -ENODEV;
- }
-
- if (!obd->obd_type) {
- printk("obd_check_conn: obd %d not typed\n", obd->obd_minor);
- return -ENODEV;
- }
-
- if (!obd->obd_type->typ_ops) {
- printk("obd_check_conn: obd %d no operations\n",
+ struct obd_device *obd;
+ if (!conn) {
+ printk("obd_check_conn: NULL conn\n");
+ return -ENOTCONN;
+ }
+ obd = conn->oc_dev;
+ if (!obd) {
+ printk("obd_check_conn: NULL obd\n");
+ return -ENODEV;
+ }
+
+ if (!obd->obd_flags & OBD_ATTACHED ) {
+ printk("obd_check_conn: obd %d not attached\n", obd->obd_minor);
+ return -ENODEV;
+ }
+
+ if (!obd->obd_flags & OBD_SET_UP) {
+ printk("obd_check_conn: obd %d not setup\n", obd->obd_minor);
+ return -ENODEV;
+ }
+
+ if (!obd->obd_type) {
+ printk("obd_check_conn: obd %d not typed\n", obd->obd_minor);
+ return -ENODEV;
+ }
+
+ if (!obd->obd_type->typ_ops) {
+ printk("obd_check_conn: obd %d no operations\n",
obd->obd_minor);
- return -EOPNOTSUPP;
- }
- return 0;
+ return -EOPNOTSUPP;
+ }
+ return 0;
}
#define OBT(dev) dev->obd_type
do { \
int rc = obd_check_conn(conn); \
if (rc) { \
- printk("obd: error in operation: " #op "\n"); \
- return rc; \
- } \
+ printk("obd: error in operation: " #op "\n"); \
+ return rc; \
+ } \
if (!OBP(conn->oc_dev,op)) { \
- printk("obd_" #op ": dev %d no operation\n", \
- conn->oc_dev->obd_minor); \
- return -EOPNOTSUPP; \
- } \
+ printk("obd_" #op ": dev %d no operation\n", \
+ conn->oc_dev->obd_minor); \
+ return -EOPNOTSUPP; \
+ } \
} while (0)
static inline int obd_get_info(struct obd_conn *conn, obd_count keylen,
void *key, obd_count *vallen, void **val)
{
- int rc;
+ int rc;
OBD_CHECK_SETUP(conn);
- OBD_CHECK_OP(conn,get_info);
-
- rc = OBP(conn->oc_dev, get_info)(conn, keylen, key, vallen, val);
- EXIT;
- return rc;
+ OBD_CHECK_OP(conn,get_info);
+
+ rc = OBP(conn->oc_dev, get_info)(conn, keylen, key, vallen, val);
+ EXIT;
+ return rc;
}
static inline int obd_set_info(struct obd_conn *conn, obd_count keylen,
void *key, obd_count vallen, void *val)
{
- int rc;
+ int rc;
OBD_CHECK_SETUP(conn);
- OBD_CHECK_OP(conn,set_info);
-
- rc = OBP(conn->oc_dev, set_info)(conn, keylen, key, vallen, val);
- EXIT;
- return rc;
+ OBD_CHECK_OP(conn,set_info);
+
+ rc = OBP(conn->oc_dev, set_info)(conn, keylen, key, vallen, val);
+ EXIT;
+ return rc;
}
static inline int obd_setup(struct obd_device *obd, int datalen, void *data)
{
- struct obd_conn conn;
- int rc;
- conn.oc_dev = obd;
-
- OBD_CHECK_OP((&conn),setup);
-
- rc = OBP(conn.oc_dev, setup)(obd, datalen, data);
- EXIT;
- return rc;
+ struct obd_conn conn;
+ int rc;
+ conn.oc_dev = obd;
+
+ OBD_CHECK_OP((&conn),setup);
+
+ rc = OBP(conn.oc_dev, setup)(obd, datalen, data);
+ EXIT;
+ return rc;
}
static inline int obd_cleanup(struct obd_device *obd)
{
- struct obd_conn conn;
- int rc;
- conn.oc_dev = obd;
+ struct obd_conn conn;
+ int rc;
+ conn.oc_dev = obd;
OBD_CHECK_SETUP(&conn);
- OBD_CHECK_OP((&conn),cleanup);
-
- rc = OBP(conn.oc_dev, cleanup)(obd);
- EXIT;
- return rc;
+ OBD_CHECK_OP((&conn),cleanup);
+
+ rc = OBP(conn.oc_dev, cleanup)(obd);
+ EXIT;
+ return rc;
}
static inline int obd_create(struct obd_conn *conn, struct obdo *obdo)
{
- int rc;
+ int rc;
OBD_CHECK_SETUP(conn);
- OBD_CHECK_OP(conn,create);
-
- rc = OBP(conn->oc_dev, create)(conn, obdo);
- EXIT;
- return rc;
+ OBD_CHECK_OP(conn,create);
+
+ rc = OBP(conn->oc_dev, create)(conn, obdo);
+ EXIT;
+ return rc;
}
static inline int obd_destroy(struct obd_conn *conn, struct obdo *obdo)
{
- int rc;
+ int rc;
OBD_CHECK_SETUP(conn);
- OBD_CHECK_OP(conn,destroy);
-
- rc = OBP(conn->oc_dev, destroy)(conn, obdo);
- EXIT;
- return rc;
+ OBD_CHECK_OP(conn,destroy);
+
+ rc = OBP(conn->oc_dev, destroy)(conn, obdo);
+ EXIT;
+ return rc;
}
static inline int obd_getattr(struct obd_conn *conn, struct obdo *obdo)
{
- int rc;
+ int rc;
OBD_CHECK_SETUP(conn);
- OBD_CHECK_OP(conn,getattr);
-
- rc = OBP(conn->oc_dev, getattr)(conn, obdo);
- EXIT;
- return rc;
+ OBD_CHECK_OP(conn,getattr);
+
+ rc = OBP(conn->oc_dev, getattr)(conn, obdo);
+ EXIT;
+ return rc;
}
static inline int obd_close(struct obd_conn *conn, struct obdo *obdo)
{
- int rc;
+ int rc;
OBD_CHECK_SETUP(conn);
- OBD_CHECK_OP(conn,close);
-
- rc = OBP(conn->oc_dev, close)(conn, obdo);
- EXIT;
- return rc;
+ OBD_CHECK_OP(conn,close);
+
+ rc = OBP(conn->oc_dev, close)(conn, obdo);
+ EXIT;
+ return rc;
}
static inline int obd_open(struct obd_conn *conn, struct obdo *obdo)
{
- int rc;
+ int rc;
OBD_CHECK_SETUP(conn);
- OBD_CHECK_OP(conn,open);
-
- rc = OBP(conn->oc_dev, open) (conn, obdo);
- EXIT;
- return rc;
+ OBD_CHECK_OP(conn,open);
+
+ rc = OBP(conn->oc_dev, open) (conn, obdo);
+ EXIT;
+ return rc;
}
static inline int obd_setattr(struct obd_conn *conn, struct obdo *obdo)
{
- int rc;
+ int rc;
OBD_CHECK_SETUP(conn);
- OBD_CHECK_OP(conn,setattr);
-
- rc = OBP(conn->oc_dev, setattr)(conn, obdo);
- EXIT;
- return rc;
+ OBD_CHECK_OP(conn,setattr);
+
+ rc = OBP(conn->oc_dev, setattr)(conn, obdo);
+ EXIT;
+ return rc;
}
static inline int obd_connect(struct obd_conn *conn)
{
- int rc;
+ int rc;
OBD_CHECK_SETUP(conn);
- OBD_CHECK_OP(conn,connect);
-
- rc = OBP(conn->oc_dev, connect)(conn);
- EXIT;
- return rc;
+ OBD_CHECK_OP(conn,connect);
+
+ rc = OBP(conn->oc_dev, connect)(conn);
+ EXIT;
+ return rc;
}
static inline int obd_disconnect(struct obd_conn *conn)
{
- int rc;
+ int rc;
OBD_CHECK_SETUP(conn);
- OBD_CHECK_OP(conn,disconnect);
-
- rc = OBP(conn->oc_dev, disconnect)(conn);
- EXIT;
- return rc;
+ OBD_CHECK_OP(conn,disconnect);
+
+ rc = OBP(conn->oc_dev, disconnect)(conn);
+ EXIT;
+ return rc;
}
static inline int obd_statfs(struct obd_conn *conn, struct statfs *buf)
{
- int rc;
+ int rc;
OBD_CHECK_SETUP(conn);
- OBD_CHECK_OP(conn,statfs);
-
- rc = OBP(conn->oc_dev, statfs)(conn, buf);
- EXIT;
- return rc;
+ OBD_CHECK_OP(conn,statfs);
+
+ rc = OBP(conn->oc_dev, statfs)(conn, buf);
+ EXIT;
+ return rc;
}
static inline int obd_punch(struct obd_conn *conn, struct obdo *tgt,
obd_size count, obd_off offset)
{
- int rc;
+ int rc;
OBD_CHECK_SETUP(conn);
- OBD_CHECK_OP(conn,punch);
-
- rc = OBP(conn->oc_dev, punch)(conn, tgt, count, offset);
- EXIT;
- return rc;
+ OBD_CHECK_OP(conn,punch);
+
+ rc = OBP(conn->oc_dev, punch)(conn, tgt, count, offset);
+ EXIT;
+ return rc;
}
static inline int obd_brw(int rw, struct obd_conn *conn, obd_count num_oa,
struct page **buf, obd_size *count, obd_off *offset,
obd_flag *flags)
{
- int rc;
+ int rc;
OBD_CHECK_SETUP(conn);
- OBD_CHECK_OP(conn,brw);
-
- rc = OBP(conn->oc_dev, brw)(rw, conn, num_oa, oa, oa_bufs, buf,
- count, offset, flags);
- EXIT;
- return rc;
+ OBD_CHECK_OP(conn,brw);
+
+ rc = OBP(conn->oc_dev, brw)(rw, conn, num_oa, oa, oa_bufs, buf,
+ count, offset, flags);
+ EXIT;
+ return rc;
}
static inline int obd_preprw(int cmd, struct obd_conn *conn,
int niocount, struct niobuf *nb,
struct niobuf *res)
{
- int rc;
+ int rc;
OBD_CHECK_SETUP(conn);
- OBD_CHECK_OP(conn, preprw);
-
- rc = OBP(conn->oc_dev, preprw)(cmd, conn, objcount, obj, niocount, nb,
+ OBD_CHECK_OP(conn, preprw);
+
+ rc = OBP(conn->oc_dev, preprw)(cmd, conn, objcount, obj, niocount, nb,
res);
- EXIT;
- return rc;
+ EXIT;
+ return rc;
}
static inline int obd_commitrw(int cmd, struct obd_conn *conn,
int objcount, struct obd_ioobj *obj,
int niocount, struct niobuf *res)
{
- int rc;
+ int rc;
OBD_CHECK_SETUP(conn);
- OBD_CHECK_OP(conn, commitrw);
-
- rc = OBP(conn->oc_dev, commitrw)(cmd, conn, objcount, obj, niocount,
+ OBD_CHECK_OP(conn, commitrw);
+
+ rc = OBP(conn->oc_dev, commitrw)(cmd, conn, objcount, obj, niocount,
res);
- EXIT;
- return rc;
+ EXIT;
+ return rc;
}
static inline int obd_iocontrol(int cmd, struct obd_conn *conn,
int len, void *karg, void *uarg)
{
- int rc;
+ int rc;
OBD_CHECK_SETUP(conn);
- OBD_CHECK_OP(conn, iocontrol);
-
- rc = OBP(conn->oc_dev, iocontrol)(cmd, conn, len, karg, uarg);
- EXIT;
- return rc;
+ OBD_CHECK_OP(conn, iocontrol);
+
+ rc = OBP(conn->oc_dev, iocontrol)(cmd, conn, len, karg, uarg);
+ EXIT;
+ return rc;
}
#endif
}
static __inline__ struct obdo *obdo_fromid(struct obd_conn *conn, obd_id id,
- obd_mode mode, obd_flag valid)
+ obd_mode mode, obd_flag valid)
{
struct obdo *oa;
int err;
}
oa->o_id = id;
- oa->o_mode = mode;
+ oa->o_mode = mode;
oa->o_valid = valid;
if ((err = OBP(conn->oc_dev, getattr)(conn, oa))) {
obdo_free(oa);
static inline void iattr_from_obdo(struct iattr *attr, struct obdo *oa)
{
unsigned int ia_valid = oa->o_valid;
-
- memset(attr, 0, sizeof(*attr));
+
+ memset(attr, 0, sizeof(*attr));
if (ia_valid & OBD_MD_FLATIME) {
attr->ia_atime = oa->o_atime;
attr->ia_valid |= ATTR_ATIME;
{
ENTRY;
- file->private_data = NULL;
+ file->private_data = NULL;
MOD_INC_USE_COUNT;
RETURN(0);
}
{
ENTRY;
- if (file->private_data)
- file->private_data = NULL;
+ if (file->private_data)
+ file->private_data = NULL;
MOD_DEC_USE_COUNT;
RETURN(0);
return type;
}
}
- return NULL;
+ return NULL;
}
static struct obd_type *obd_nm_to_type(char *nm)
struct obd_type *type = obd_search_type(nm);
#ifdef CONFIG_KMOD
- if ( !type ) {
- if ( !request_module(nm) ) {
- CDEBUG(D_INFO, "Loaded module '%s'\n", nm);
- type = obd_search_type(nm);
- } else {
- CDEBUG(D_INFO, "Can't load module '%s'\n", nm);
- }
- }
+ if ( !type ) {
+ if ( !request_module(nm) ) {
+ CDEBUG(D_INFO, "Loaded module '%s'\n", nm);
+ type = obd_search_type(nm);
+ } else {
+ CDEBUG(D_INFO, "Can't load module '%s'\n", nm);
+ }
+ }
#endif
return type;
}
{
/* NOTE this must be larger than any of the ioctl data structs */
char buf[1024];
- struct obd_ioctl_data *data;
- struct obd_device *obd = filp->private_data;
- struct obd_conn conn;
- int rw = OBD_BRW_READ;
+ struct obd_ioctl_data *data;
+ struct obd_device *obd = filp->private_data;
+ struct obd_conn conn;
+ int rw = OBD_BRW_READ;
int err = 0;
- ENTRY;
+ ENTRY;
- memset(buf, 0, sizeof(buf));
+ memset(buf, 0, sizeof(buf));
- if (!obd && cmd != OBD_IOC_DEVICE && cmd != TCGETS) {
- CERROR("OBD ioctl: No device\n");
- RETURN(-EINVAL);
- }
- if (obd_ioctl_getdata(buf, buf + 800, (void *)arg)) {
- CERROR("OBD ioctl: data error\n");
- RETURN(-EINVAL);
- }
- data = (struct obd_ioctl_data *)buf;
+ if (!obd && cmd != OBD_IOC_DEVICE && cmd != TCGETS) {
+ CERROR("OBD ioctl: No device\n");
+ RETURN(-EINVAL);
+ }
+ if (obd_ioctl_getdata(buf, buf + 800, (void *)arg)) {
+ CERROR("OBD ioctl: data error\n");
+ RETURN(-EINVAL);
+ }
+ data = (struct obd_ioctl_data *)buf;
switch (cmd) {
case TCGETS:
RETURN(-EINVAL);
- case OBD_IOC_DEVICE: {
- CDEBUG(D_IOCTL, "\n");
- if (data->ioc_dev >= MAX_OBD_DEVICES ||
- data->ioc_dev < 0) {
- CERROR("OBD ioctl: DEVICE insufficient devices\n");
- RETURN(-EINVAL);
- }
- CDEBUG(D_IOCTL, "device %d\n", data->ioc_dev);
-
- filp->private_data = &obd_dev[data->ioc_dev];
+ case OBD_IOC_DEVICE: {
+ CDEBUG(D_IOCTL, "\n");
+ if (data->ioc_dev >= MAX_OBD_DEVICES ||
+ data->ioc_dev < 0) {
+ CERROR("OBD ioctl: DEVICE insufficient devices\n");
+ RETURN(-EINVAL);
+ }
+ CDEBUG(D_IOCTL, "device %d\n", data->ioc_dev);
+
+ filp->private_data = &obd_dev[data->ioc_dev];
RETURN(0);
- }
+ }
case OBD_IOC_ATTACH: {
struct obd_type *type;
RETURN(-EBUSY);
}
- CDEBUG(D_IOCTL, "attach %s %s\n", MKSTR(data->ioc_inlbuf1),
- MKSTR(data->ioc_inlbuf2));
+ CDEBUG(D_IOCTL, "attach %s %s\n", MKSTR(data->ioc_inlbuf1),
+ MKSTR(data->ioc_inlbuf2));
/* find the type */
type = obd_nm_to_type(data->ioc_inlbuf1);
/* do the attach */
if (OBT(obd) && OBP(obd, attach))
- err = OBP(obd, attach)(obd, sizeof(*data), data);
+ err = OBP(obd, attach)(obd, sizeof(*data), data);
if (err) {
obd->obd_type = NULL;
obd->obd_flags |= OBD_ATTACHED;
type->typ_refcnt++;
CDEBUG(D_IOCTL, "OBD: dev %d attached type %s\n",
- obd->obd_minor, data->ioc_inlbuf1);
- obd->obd_proc_entry =
- proc_lustre_register_obd_device(obd);
+ obd->obd_minor, data->ioc_inlbuf1);
+ obd->obd_proc_entry =
+ proc_lustre_register_obd_device(obd);
MOD_INC_USE_COUNT;
}
RETURN(-EBUSY);
}
- if (obd->obd_proc_entry)
- proc_lustre_release_obd_device(obd);
+ if (obd->obd_proc_entry)
+ proc_lustre_release_obd_device(obd);
obd->obd_flags &= ~OBD_ATTACHED;
obd->obd_type->typ_refcnt--;
}
if ( OBT(obd) && OBP(obd, setup) )
- err = obd_setup(obd, sizeof(*data), data);
+ err = obd_setup(obd, sizeof(*data), data);
- if (!err) {
- obd->obd_type->typ_refcnt++;
- obd->obd_flags |= OBD_SET_UP;
- }
+ if (!err) {
+ obd->obd_type->typ_refcnt++;
+ obd->obd_flags |= OBD_SET_UP;
+ }
RETURN(err);
}
}
if ( OBT(obd) && OBP(obd, cleanup) )
- err = obd_cleanup(obd);
+ err = obd_cleanup(obd);
- if (!err) {
- obd->obd_flags &= ~OBD_SET_UP;
- obd->obd_type->typ_refcnt--;
- }
+ if (!err) {
+ obd->obd_flags &= ~OBD_SET_UP;
+ obd->obd_type->typ_refcnt--;
+ }
RETURN(err);
}
case OBD_IOC_CONNECT: {
- conn.oc_id = data->ioc_conn1;
- conn.oc_dev = obd;
+ conn.oc_id = data->ioc_conn1;
+ conn.oc_dev = obd;
err = obd_connect(&conn);
- CDEBUG(D_IOCTL, "assigned connection %d\n", conn.oc_id);
- data->ioc_conn1 = conn.oc_id;
+ CDEBUG(D_IOCTL, "assigned connection %d\n", conn.oc_id);
+ data->ioc_conn1 = conn.oc_id;
if (err)
RETURN(err);
}
case OBD_IOC_DISCONNECT: {
- conn.oc_id = data->ioc_conn1;
- conn.oc_dev = obd;
+ conn.oc_id = data->ioc_conn1;
+ conn.oc_dev = obd;
err = obd_disconnect(&conn);
RETURN(err);
- }
+ }
- case OBD_IOC_DEC_USE_COUNT: {
- MOD_DEC_USE_COUNT;
+ case OBD_IOC_DEC_USE_COUNT: {
+ MOD_DEC_USE_COUNT;
RETURN(0);
- }
+ }
case OBD_IOC_CREATE: {
conn.oc_id = data->ioc_conn1;
- conn.oc_dev = obd;
+ conn.oc_dev = obd;
err = obd_create(&conn, &data->ioc_obdo1);
if (err)
case OBD_IOC_GETATTR: {
conn.oc_id = data->ioc_conn1;
- conn.oc_dev = obd;
+ conn.oc_dev = obd;
err = obd_getattr(&conn, &data->ioc_obdo1);
if (err)
case OBD_IOC_SETATTR: {
conn.oc_id = data->ioc_conn1;
- conn.oc_dev = obd;
+ conn.oc_dev = obd;
err = obd_setattr(&conn, &data->ioc_obdo1);
if (err)
err = copy_to_user((int *)arg, data, sizeof(*data));
RETURN(err);
- }
+ }
case OBD_IOC_DESTROY: {
conn.oc_id = data->ioc_conn1;
- conn.oc_dev = obd;
+ conn.oc_dev = obd;
err = obd_destroy(&conn, &data->ioc_obdo1);
if (err)
err = copy_to_user((int *)arg, data, sizeof(*data));
RETURN(err);
- }
+ }
- case OBD_IOC_BRW_WRITE:
- rw = OBD_BRW_WRITE;
- case OBD_IOC_BRW_READ: {
- /* FIXME: use a better ioctl data struct than obd_ioctl_data.
+ case OBD_IOC_BRW_WRITE:
+ rw = OBD_BRW_WRITE;
+ case OBD_IOC_BRW_READ: {
+ /* FIXME: use a better ioctl data struct than obd_ioctl_data.
* We don't really support multiple-obdo I/Os here,
* for example offset and count are not per-obdo.
*/
}
default: {
conn.oc_id = data->ioc_conn1;
- conn.oc_dev = obd;
+ conn.oc_dev = obd;
err = obd_iocontrol(cmd, &conn, sizeof(*data), data, NULL);
if (err)
INIT_LIST_HEAD(&obd_types);
- if ( (err = misc_register(&obd_psdev)) ) {
+ if ( (err = misc_register(&obd_psdev)) ) {
CERROR("cannot register %d err %d\n", OBD_MINOR, err);
return -EIO;
}
obd_dev[i].obd_minor = i;
INIT_LIST_HEAD(&obd_dev[i].obd_gen_clients);
INIT_LIST_HEAD(&obd_dev[i].obd_req_list);
- init_waitqueue_head(&obd_dev[i].obd_req_waitq);
+ init_waitqueue_head(&obd_dev[i].obd_req_waitq);
}
err = obd_init_obdo_cache();
#define S_SHIFT 12
static char * obd_type_by_mode[S_IFMT >> S_SHIFT] = {
- [0] "",
- [S_IFREG >> S_SHIFT] "R",
- [S_IFDIR >> S_SHIFT] "D",
- [S_IFCHR >> S_SHIFT] "C",
- [S_IFBLK >> S_SHIFT] "B",
- [S_IFIFO >> S_SHIFT] "F",
- [S_IFSOCK >> S_SHIFT] "S",
- [S_IFLNK >> S_SHIFT] "L"
+ [0] "",
+ [S_IFREG >> S_SHIFT] "R",
+ [S_IFDIR >> S_SHIFT] "D",
+ [S_IFCHR >> S_SHIFT] "C",
+ [S_IFBLK >> S_SHIFT] "B",
+ [S_IFIFO >> S_SHIFT] "F",
+ [S_IFSOCK >> S_SHIFT] "S",
+ [S_IFLNK >> S_SHIFT] "L"
};
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);
+ 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]);
+ 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;
+ 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);
+ 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);
+ 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);
+ set_fs(saved->fs);
+ set_fs_pwd(current->fs, saved->pwdmnt, saved->pwd);
- dput(saved->pwd);
- mntput(saved->pwdmnt);
+ 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;
+ 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;
+ 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)
{
- struct obd_run_ctxt saved;
- struct file *file;
- struct inode *inode;
- loff_t off;
- long rc;
- char rootid[128];
- __u64 lastino = 2;
-
- push_ctxt(&saved, &obddev->u.filter.fo_ctxt);
- 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;
- }
- rc = simple_mkdir(file->f_dentry, "R", 0700); /* regular */
- rc = simple_mkdir(file->f_dentry, "D", 0700); /* directory */
- rc = simple_mkdir(file->f_dentry, "L", 0700); /* symbolic links */
- rc = simple_mkdir(file->f_dentry, "C", 0700); /* character devices */
- 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);
-
- 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;
- }
- filp_close(file, 0);
- 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;
- }
-
- /* steal operations */
- inode = file->f_dentry->d_inode;
- obddev->u.filter.fo_fop = file->f_op;
- obddev->u.filter.fo_iop = inode->i_op;
- 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)) {
- CERROR("OBD filter: error writing lastino\n");
- goto out;
- }
- } else {
- rc = file->f_op->read(file, (char *)&lastino, sizeof(lastino),
- &off);
- if (rc != sizeof(lastino)) {
- CERROR("OBD filter: error reading lastino\n");
- goto out;
- }
- }
- obddev->u.filter.fo_lastino = lastino;
+ struct obd_run_ctxt saved;
+ struct file *file;
+ struct inode *inode;
+ loff_t off;
+ long rc;
+ char rootid[128];
+ __u64 lastino = 2;
+
+ push_ctxt(&saved, &obddev->u.filter.fo_ctxt);
+ 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;
+ }
+ rc = simple_mkdir(file->f_dentry, "R", 0700); /* regular */
+ rc = simple_mkdir(file->f_dentry, "D", 0700); /* directory */
+ rc = simple_mkdir(file->f_dentry, "L", 0700); /* symbolic links */
+ rc = simple_mkdir(file->f_dentry, "C", 0700); /* character devices */
+ 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);
+
+ 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;
+ }
+ filp_close(file, 0);
+ 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;
+ }
+
+ /* steal operations */
+ inode = file->f_dentry->d_inode;
+ obddev->u.filter.fo_fop = file->f_op;
+ obddev->u.filter.fo_iop = inode->i_op;
+ 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)) {
+ CERROR("OBD filter: error writing lastino\n");
+ goto out;
+ }
+ } else {
+ rc = file->f_op->read(file, (char *)&lastino, sizeof(lastino),
+ &off);
+ if (rc != sizeof(lastino)) {
+ CERROR("OBD filter: error reading lastino\n");
+ goto out;
+ }
+ }
+ obddev->u.filter.fo_lastino = lastino;
out:
- pop_ctxt(&saved);
+ pop_ctxt(&saved);
}
static void filter_post(struct obd_device *obddev)
{
- struct obd_run_ctxt saved;
- long rc;
- struct file *file;
- loff_t off = 0;
-
- push_ctxt(&saved, &obddev->u.filter.fo_ctxt);
- file = filp_open("D/status", O_RDWR | O_CREAT, 0700);
- if ( !file || IS_ERR(file)) {
- CERROR("OBD filter: cannot create status file\n");
- goto out;
- }
- rc = file->f_op->write(file, (char *)&obddev->u.filter.fo_lastino,
- sizeof(obddev->u.filter.fo_lastino), &off);
- if (rc != sizeof(sizeof(obddev->u.filter.fo_lastino)) ) {
- CERROR("OBD filter: error writing lastino\n");
- }
-
- rc = filp_close(file, NULL);
- if (rc) {
- CERROR("OBD filter: cannot close status file\n");
- }
+ struct obd_run_ctxt saved;
+ long rc;
+ struct file *file;
+ loff_t off = 0;
+
+ push_ctxt(&saved, &obddev->u.filter.fo_ctxt);
+ file = filp_open("D/status", O_RDWR | O_CREAT, 0700);
+ if ( !file || IS_ERR(file)) {
+ CERROR("OBD filter: cannot create status file\n");
+ goto out;
+ }
+ rc = file->f_op->write(file, (char *)&obddev->u.filter.fo_lastino,
+ sizeof(obddev->u.filter.fo_lastino), &off);
+ if (rc != sizeof(obddev->u.filter.fo_lastino) ) {
+ CERROR("OBD filter: error writing lastino\n");
+ }
+
+ rc = filp_close(file, NULL);
+ if (rc) {
+ CERROR("OBD filter: cannot close status file\n");
+ }
out:
- pop_ctxt(&saved);
+ pop_ctxt(&saved);
}
/* release per client resources */
static int filter_disconnect(struct obd_conn *conn)
{
- /* XXX cleanup preallocated inodes */
- return gen_disconnect(conn);
+ /* XXX cleanup preallocated inodes */
+ return gen_disconnect(conn);
} /* ext2obd_disconnect */
/* mount the file system (secretly) */
static int filter_setup(struct obd_device *obddev, obd_count len,
- void *buf)
-
+ void *buf)
+
{
- struct obd_ioctl_data* data = buf;
- struct vfsmount *mnt;
- int err;
+ struct obd_ioctl_data* data = buf;
+ struct vfsmount *mnt;
+ int err;
ENTRY;
-
- mnt = do_kern_mount(data->ioc_inlbuf2, 0,
- data->ioc_inlbuf1, NULL);
- err = PTR_ERR(mnt);
- if (IS_ERR(mnt)) {
- EXIT;
- return err;
- }
-
- obddev->u.filter.fo_sb = mnt->mnt_root->d_inode->i_sb;
- if (!obddev->u.filter.fo_sb) {
- EXIT;
- return -ENODEV;
- }
-
- obddev->u.filter.fo_vfsmnt = mnt;
- obddev->u.filter.fo_fstype = strdup(data->ioc_inlbuf2);
-
- obddev->u.filter.fo_ctxt.pwdmnt = mnt;
- obddev->u.filter.fo_ctxt.pwd = mnt->mnt_root;
- obddev->u.filter.fo_ctxt.fs = KERNEL_DS;
-
- filter_prep(obddev);
- spin_lock_init(&obddev->u.filter.fo_lock);
+
+ mnt = do_kern_mount(data->ioc_inlbuf2, 0,
+ data->ioc_inlbuf1, NULL);
+ err = PTR_ERR(mnt);
+ if (IS_ERR(mnt)) {
+ EXIT;
+ return err;
+ }
+
+ obddev->u.filter.fo_sb = mnt->mnt_root->d_inode->i_sb;
+ if (!obddev->u.filter.fo_sb) {
+ EXIT;
+ return -ENODEV;
+ }
+
+ obddev->u.filter.fo_vfsmnt = mnt;
+ obddev->u.filter.fo_fstype = strdup(data->ioc_inlbuf2);
+
+ obddev->u.filter.fo_ctxt.pwdmnt = mnt;
+ obddev->u.filter.fo_ctxt.pwd = mnt->mnt_root;
+ obddev->u.filter.fo_ctxt.fs = KERNEL_DS;
+
+ filter_prep(obddev);
+ spin_lock_init(&obddev->u.filter.fo_lock);
MOD_INC_USE_COUNT;
EXIT;
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;
+ __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;
}
static int filter_cleanup(struct obd_device * obddev)
EXIT;
return 0;
}
- filter_post(obddev);
+ filter_post(obddev);
- unlock_kernel();
- mntput(obddev->u.filter.fo_vfsmnt);
+ unlock_kernel();
+ mntput(obddev->u.filter.fo_vfsmnt);
obddev->u.filter.fo_sb = 0;
- kfree(obddev->u.filter.fo_fstype);
+ kfree(obddev->u.filter.fo_fstype);
- lock_kernel();
+ lock_kernel();
MOD_DEC_USE_COUNT;
EXIT;
return 0;
}
-
static struct file *filter_obj_open(struct obd_device *obddev,
- struct obdo *oa)
+ struct obdo *oa)
{
- struct file *file;
- int error = 0;
- char id[24];
- struct obd_run_ctxt saved;
- struct super_block *sb;
+ struct file *file;
+ int error = 0;
+ char id[24];
+ struct obd_run_ctxt saved;
+ struct super_block *sb;
- sb = obddev->u.filter.fo_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_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);
+ 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 file;
}
static struct inode *filter_inode_from_obdo(struct obd_device *obddev,
- struct obdo *oa)
+ struct obdo *oa)
{
- struct file *file;
- struct inode *inode;
+ struct file *file;
+ struct inode *inode;
- file = filter_obj_open(obddev, oa);
- if ( !file ) {
- CERROR("filter_inode_from_obdo failed\n");
- return NULL;
- }
+ 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;
+ filp_close(file, 0);
+ return inode;
}
static inline void filter_from_inode(struct obdo *oa, struct inode *inode)
{
- int type = oa->o_mode & S_IFMT;
+ int type = oa->o_mode & S_IFMT;
ENTRY;
CDEBUG(D_INFO, "src inode %ld, dst obdo %ld valid 0x%08x\n",
inode->i_ino, (long)oa->o_id, oa->o_valid);
obdo_from_inode(oa, inode);
- oa->o_mode &= ~S_IFMT;
- oa->o_mode |= type;
+ oa->o_mode &= ~S_IFMT;
+ oa->o_mode |= type;
if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
- obd_rdev rdev = kdev_t_to_nr(inode->i_rdev);
+ obd_rdev rdev = kdev_t_to_nr(inode->i_rdev);
CDEBUG(D_INODE, "copying device %x from inode to obdo\n",
- rdev);
+ rdev);
*((obd_rdev *)oa->o_inline) = rdev;
oa->o_obdflags |= OBD_FL_INLINEDATA;
oa->o_valid |= OBD_MD_FLINLINE;
return -EINVAL;
}
- if ( !(inode = filter_inode_from_obdo(conn->oc_dev, oa)) ) {
- EXIT;
- return -ENOENT;
- }
+ if ( !(inode = filter_inode_from_obdo(conn->oc_dev, oa)) ) {
+ EXIT;
+ return -ENOENT;
+ }
- oa->o_valid &= ~OBD_MD_FLID;
+ oa->o_valid &= ~OBD_MD_FLID;
filter_from_inode(oa, inode);
-
+
iput(inode);
EXIT;
return 0;
static int filter_setattr(struct obd_conn *conn, struct obdo *oa)
{
- struct inode *inode;
- struct iattr iattr;
- int rc;
- struct dentry de;
+ struct inode *inode;
+ struct iattr iattr;
+ int rc;
+ struct dentry de;
if (!gen_client(conn)) {
CDEBUG(D_IOCTL, "invalid client %u\n", conn->oc_id);
return -EINVAL;
}
- inode = filter_inode_from_obdo(conn->oc_dev, oa);
- if ( !inode ) {
- EXIT;
- return -ENOENT;
- }
-
- iattr_from_obdo(&iattr, oa);
- iattr.ia_mode &= ~S_IFMT;
- iattr.ia_mode |= S_IFREG;
- de.d_inode = inode;
- if ( inode->i_op->setattr ) {
- rc = inode->i_op->setattr(&de, &iattr);
- } else {
- rc = inode_setattr(inode, &iattr);
- }
-
- iput(inode);
- EXIT;
- return rc;
+ inode = filter_inode_from_obdo(conn->oc_dev, oa);
+ if ( !inode ) {
+ EXIT;
+ return -ENOENT;
+ }
+
+ iattr_from_obdo(&iattr, oa);
+ iattr.ia_mode &= ~S_IFMT;
+ iattr.ia_mode |= S_IFREG;
+ de.d_inode = inode;
+ if ( inode->i_op->setattr ) {
+ rc = inode->i_op->setattr(&de, &iattr);
+ } else {
+ rc = inode_setattr(inode, &iattr);
+ }
+
+ iput(inode);
+ EXIT;
+ return rc;
}
static int filter_create (struct obd_conn* conn, struct obdo *oa)
{
- char name[64];
- struct obd_run_ctxt saved;
- struct file *file;
- int mode;
- struct obd_device *obddev = conn->oc_dev;
- struct iattr;
- ENTRY;
+ char name[64];
+ struct obd_run_ctxt saved;
+ struct file *file;
+ int mode;
+ struct obd_device *obddev = conn->oc_dev;
+ struct iattr;
+ ENTRY;
if (!gen_client(conn)) {
CDEBUG(D_IOCTL, "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) ) {
- CERROR("filter obd: no type!\n");
- return -ENOENT;
- }
-
- filter_id(name, oa->o_id, oa->o_mode);
- push_ctxt(&saved, &obddev->u.filter.fo_ctxt);
- mode = oa->o_mode;
- mode &= ~S_IFMT;
- mode |= S_IFREG;
- file = filp_open(name, O_RDONLY | O_CREAT, mode);
- pop_ctxt(&saved);
- if (IS_ERR(file)) {
- CERROR("Error mknod obj %s, err %ld\n", name, PTR_ERR(file));
- return -ENOENT;
- }
- filp_close(file, 0);
- CDEBUG(D_IOCTL, "\n");
-
+ CDEBUG(D_IOCTL, "\n");
+
+ oa->o_id = filter_next_id(conn->oc_dev);
+ if ( !(oa->o_mode && S_IFMT) ) {
+ CERROR("filter obd: no type!\n");
+ return -ENOENT;
+ }
+
+ filter_id(name, oa->o_id, oa->o_mode);
+ push_ctxt(&saved, &obddev->u.filter.fo_ctxt);
+ mode = oa->o_mode;
+ mode &= ~S_IFMT;
+ mode |= S_IFREG;
+ file = filp_open(name, O_RDONLY | O_CREAT, mode);
+ pop_ctxt(&saved);
+ if (IS_ERR(file)) {
+ CERROR("Error mknod obj %s, err %ld\n", name, PTR_ERR(file));
+ 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 |
OBD_MD_FLMTIME | OBD_MD_FLATIME | OBD_MD_FLCTIME |
struct obd_device * obddev;
struct obd_client * cli;
struct inode * inode;
- struct file *dir;
- int rc;
- struct obd_run_ctxt saved;
- char id[128];
+ struct file *dir;
+ 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);
}
obddev = conn->oc_dev;
- inode = filter_inode_from_obdo(obddev, oa);
+ inode = filter_inode_from_obdo(obddev, oa);
- if (!inode) {
- EXIT;
- return -ENOENT;
- }
+ if (!inode) {
+ EXIT;
+ return -ENOENT;
+ }
inode->i_nlink = 1;
- inode->i_mode = 010000;
- iput(inode);
+ 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)) {
- rc = PTR_ERR(dir);
- EXIT;
- goto out;
- }
+ 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)) {
+ rc = PTR_ERR(dir);
+ EXIT;
+ goto out;
+ }
- rc = simple_unlink(dir->f_dentry, id);
+ rc = simple_unlink(dir->f_dentry, id);
- filp_close(dir, 0);
+ filp_close(dir, 0);
out:
- pop_ctxt(&saved);
- EXIT;
+ pop_ctxt(&saved);
+ EXIT;
return rc;
}
static int filter_truncate(struct obd_conn *conn, struct obdo *oa, obd_size count,
obd_off offset)
{
- int error;
+ int error;
- error = filter_setattr(conn, oa);
+ error = filter_setattr(conn, oa);
oa->o_valid = OBD_MD_FLBLOCKS | OBD_MD_FLCTIME | OBD_MD_FLMTIME;
EXIT;
return -EINVAL;
}
- file = filter_obj_open(conn->oc_dev, oa);
- if (!file || IS_ERR(file)) {
- EXIT;
- return -PTR_ERR(file);
- }
+ file = filter_obj_open(conn->oc_dev, oa);
+ if (!file || IS_ERR(file)) {
+ EXIT;
+ return -PTR_ERR(file);
+ }
/* count doubles as retval */
retval = file->f_op->read(file, buf, *count, &offset);
- filp_close(file, 0);
+ filp_close(file, 0);
if ( retval >= 0 ) {
err = 0;
return -EINVAL;
}
- file = filter_obj_open(conn->oc_dev, oa);
- if (!file || IS_ERR(file)) {
- EXIT;
- return -PTR_ERR(file);
- }
+ file = filter_obj_open(conn->oc_dev, oa);
+ if (!file || IS_ERR(file)) {
+ EXIT;
+ return -PTR_ERR(file);
+ }
/* count doubles as retval */
retval = file->f_op->write(file, buf, *count, &offset);
- filp_close(file, 0);
+ filp_close(file, 0);
if ( retval >= 0 ) {
err = 0;
} /* ext2obd_write */
static int filter_pgcache_brw(int rw, struct obd_conn *conn,
- obd_count num_oa,
- struct obdo **oa,
- obd_count *oa_bufs,
- struct page **pages,
- obd_size *count,
- obd_off *offset,
- obd_flag *flags)
+ obd_count num_oa,
+ struct obdo **oa,
+ obd_count *oa_bufs,
+ struct page **pages,
+ obd_size *count,
+ obd_off *offset,
+ obd_flag *flags)
{
struct super_block *sb;
- mm_segment_t oldfs;
+ mm_segment_t oldfs;
int onum; /* index to oas */
int pnum; /* index to pages (bufs) */
unsigned long retval;
int error;
- struct file *file;
+ struct file *file;
ENTRY;
}
sb = conn->oc_dev->u.filter.fo_sb;
- oldfs = get_fs();
- set_fs(KERNEL_DS);
+ oldfs = get_fs();
+ set_fs(KERNEL_DS);
pnum = 0; /* pnum indexes buf 0..num_pages */
for (onum = 0; onum < num_oa; onum++) {
int pg;
- file = filter_obj_open(conn->oc_dev, oa[onum]);
- if (!file || IS_ERR(file)) {
- EXIT;
- error = -ENOENT;
- goto ERROR;
- }
+ file = filter_obj_open(conn->oc_dev, oa[onum]);
+ if (!file || IS_ERR(file)) {
+ EXIT;
+ error = -ENOENT;
+ goto ERROR;
+ }
- /* count doubles as retval */
+ /* count doubles as retval */
for (pg = 0; pg < oa_bufs[onum]; pg++) {
- CDEBUG(D_INODE, "OP %d obdo no/pno: (%d,%d) (%ld,%ld) off count (%Ld,%Ld)\n",
- rw, onum, pnum, file->f_dentry->d_inode->i_ino,
- (unsigned long)offset[pnum] >> PAGE_CACHE_SHIFT,
- offset[pnum], count[pnum]);
- if (rw == WRITE) {
- loff_t off;
- char *buffer;
- off = offset[pnum];
- buffer = kmap(pages[pnum]);
- retval = file->f_op->write(file, buffer, count[pnum], &off);
- kunmap(pages[pnum]);
- CDEBUG(D_INODE, "retval %ld\n", retval);
- } else {
- loff_t off = offset[pnum];
- char *buffer = kmap(pages[pnum]);
-
- if (off >= file->f_dentry->d_inode->i_size) {
- memset(buffer, 0, count[pnum]);
- retval = count[pnum];
- } else {
- retval = file->f_op->read(file, buffer, count[pnum], &off);
- }
- kunmap(pages[pnum]);
-
- if ( retval != count[pnum] ) {
- filp_close(file, 0);
- retval = -EIO;
- EXIT;
- goto ERROR;
- }
- CDEBUG(D_INODE, "retval %ld\n", retval);
- }
- pnum++;
- }
- /* sizes and blocks are set by generic_file_write */
- /* ctimes/mtimes will follow with a setattr call */
- filp_close(file, 0);
- }
-
- EXIT;
+ CDEBUG(D_INODE, "OP %d obdo no/pno: (%d,%d) (%ld,%ld) off count (%Ld,%Ld)\n",
+ rw, onum, pnum, file->f_dentry->d_inode->i_ino,
+ (unsigned long)offset[pnum] >> PAGE_CACHE_SHIFT,
+ offset[pnum], count[pnum]);
+ if (rw == WRITE) {
+ loff_t off;
+ char *buffer;
+ off = offset[pnum];
+ buffer = kmap(pages[pnum]);
+ retval = file->f_op->write(file, buffer, count[pnum], &off);
+ kunmap(pages[pnum]);
+ CDEBUG(D_INODE, "retval %ld\n", retval);
+ } else {
+ loff_t off = offset[pnum];
+ char *buffer = kmap(pages[pnum]);
+
+ if (off >= file->f_dentry->d_inode->i_size) {
+ memset(buffer, 0, count[pnum]);
+ retval = count[pnum];
+ } else {
+ retval = file->f_op->read(file, buffer, count[pnum], &off);
+ }
+ kunmap(pages[pnum]);
+
+ if ( retval != count[pnum] ) {
+ filp_close(file, 0);
+ retval = -EIO;
+ EXIT;
+ goto ERROR;
+ }
+ CDEBUG(D_INODE, "retval %ld\n", retval);
+ }
+ pnum++;
+ }
+ /* sizes and blocks are set by generic_file_write */
+ /* ctimes/mtimes will follow with a setattr call */
+ filp_close(file, 0);
+ }
+
+ EXIT;
ERROR:
- set_fs(oldfs);
- error = (retval >= 0) ? 0 : retval;
- return error;
+ set_fs(oldfs);
+ error = (retval >= 0) ? 0 : retval;
+ return error;
}
static int filter_statfs (struct obd_conn *conn, struct statfs * statfs)
{
- struct super_block *sb;
+ struct super_block *sb;
int err;
ENTRY;
{
struct obd_device *obddev;
struct obd_client * cli;
- ENTRY;
+ ENTRY;
if (!(cli = gen_client(conn))) {
CDEBUG(D_IOCTL, "invalid client %u\n", conn->oc_id);
memcmp(key, "blocksize", keylen) == 0 ) {
*vallen = sizeof(int);
*val = (void *)obddev->u.filter.fo_sb->s_blocksize;
- EXIT;
+ EXIT;
return 0;
}
memcmp(key, "blocksize_bits", keylen) == 0 ){
*vallen = sizeof(int);
*val = (void *)(int)obddev->u.filter.fo_sb->s_blocksize_bits;
- EXIT;
+ EXIT;
return 0;
}
memcmp(key, "root_ino", keylen) == 0 ){
*vallen = sizeof(int);
*val = (void *)(int) FILTER_ROOTINO;
- EXIT;
+ EXIT;
return 0;
}
o_statfs: filter_statfs,
o_getattr: filter_getattr,
o_create: filter_create,
- o_setattr: filter_setattr,
+ o_setattr: filter_setattr,
o_destroy: filter_destroy,
o_read: filter_read,
o_write: filter_write,
- o_brw: filter_pgcache_brw,
+ o_brw: filter_pgcache_brw,
o_punch: filter_truncate,
#if 0
o_preallocate: ext2obd_preallocate_inodes,
git://git.whamcloud.com / fs / lustre-release.git / commitdiff