if (dev >= MAX_OBD_DEVICES)
return -ENODEV;
obd_dev[dev].obd_refcnt++;
- CDEBUG(D_PSDEV, "Refcount now %d\n", obd_dev[dev].obd_refcnt++);
+ CDEBUG(D_PSDEV, "Dev %d refcount now %d\n", dev,
+ obd_dev[dev].obd_refcnt);
MOD_INC_USE_COUNT;
EXIT;
return -ENODEV;
fsync_dev(inode->i_rdev);
if (obd_dev[dev].obd_refcnt <= 0)
- printk(KERN_ALERT "presto_psdev_release: refcount(%d) <= 0\n",
+ printk(KERN_ALERT "obd_class_release: refcount(%d) <= 0\n",
obd_dev[dev].obd_refcnt);
obd_dev[dev].obd_refcnt--;
- CDEBUG(D_PSDEV, "Refcount now %d\n", obd_dev[dev].obd_refcnt++);
-
+ CDEBUG(D_PSDEV, "Dev %d refcount now %d\n", dev,
+ obd_dev[dev].obd_refcnt);
MOD_DEC_USE_COUNT;
EXIT;
conn.oc_dev = obddev;
switch (cmd) {
+ case TCGETS:
+ return -EINVAL;
case OBD_IOC_ATTACH: {
struct obd_type *type;
struct oic_generic input;
+ ENTRY;
/* have we attached a type to this device */
if ( obddev->obd_type || (obddev->obd_flags & OBD_ATTACHED) ){
- CDEBUG(D_IOCTL, "OBD Device %d already attached to type %s.\n", dev, obddev->obd_type->typ_name);
- return -EINVAL;
+ CDEBUG(D_IOCTL,
+ "OBD Device %d already attached to type %s.\n",
+ dev, obddev->obd_type->typ_name);
+ EXIT;
+ return -EBUSY;
}
/* get data structures */
- err = copy_from_user(&input, (void *) arg, sizeof(input));
- if (err)
+ err = copy_from_user(&input, (void *)arg, sizeof(input));
+ if ( err ) {
+ EXIT;
return err;
+ }
- if ( (err = getdata(input.att_typelen + 1, &input.att_type)) )
+ err = getdata(input.att_typelen + 1, &input.att_type);
+ if ( err ) {
+ EXIT;
return err;
+ }
/* find the type */
- err = -EINVAL;
type = obd_nm_to_type(input.att_type);
OBD_FREE(input.att_type, input.att_typelen + 1);
if ( !type ) {
printk("Unknown obd type dev %d\n", dev);
- return err;
+ EXIT;
+ return -EINVAL;
}
obddev->obd_type = type;
/* get the attach data */
- if ( (err = getdata(input.att_datalen, &input.att_data)) ) {
+ err = getdata(input.att_datalen, &input.att_data);
+ if ( err ) {
+ EXIT;
return err;
}
INIT_LIST_HEAD(&obddev->obd_gen_clients);
obddev->obd_multi_count = 0;
- CDEBUG(D_IOCTL, "Attach %d, datalen %d, type %s\n",
+ CDEBUG(D_IOCTL, "Attach %d, datalen %d, type %s\n",
dev, input.att_datalen, obddev->obd_type->typ_name);
- if (!obddev->obd_type->typ_ops || !OBP(obddev,attach)) {
+ if ( !OBT(obddev) || !OBP(obddev, attach) ) {
obddev->obd_flags |= OBD_ATTACHED;
type->typ_refcnt++;
+ CDEBUG(D_IOCTL, "Dev %d refcount now %d\n", dev,
+ type->typ_refcnt);
MOD_INC_USE_COUNT;
+ EXIT;
return 0;
}
/* do the attach */
- err = OBP(obddev,attach)(obddev,
- input.att_datalen, input.att_data);
+ err = OBP(obddev, attach)(obddev, input.att_datalen,
+ input.att_data);
OBD_FREE(input.att_data, input.att_datalen);
if ( err ) {
obddev->obd_flags &= ~OBD_ATTACHED;
obddev->obd_type = NULL;
+ EXIT;
} else {
obddev->obd_flags |= OBD_ATTACHED;
type->typ_refcnt++;
+ CDEBUG(D_IOCTL, "Dev %d refcount now %d\n", dev,
+ type->typ_refcnt);
MOD_INC_USE_COUNT;
+ EXIT;
}
return err;
}
case OBD_IOC_DETACH: {
- if (obddev->obd_flags & OBD_SET_UP)
- return -EINVAL;
- if (! (obddev->obd_flags & OBD_ATTACHED) )
- return -EINVAL;
- if ( !list_empty(&obddev->obd_gen_clients) )
- return -EINVAL;
+ ENTRY;
+ if (obddev->obd_flags & OBD_SET_UP) {
+ EXIT;
+ return -EBUSY;
+ }
+ if (! (obddev->obd_flags & OBD_ATTACHED) ) {
+ CDEBUG(D_IOCTL, "Device not attached\n");
+ EXIT;
+ return -ENODEV;
+ }
+ if ( !list_empty(&obddev->obd_gen_clients) ) {
+ CDEBUG(D_IOCTL, "Device has connected clients\n");
+ EXIT;
+ return -EBUSY;
+ }
+ CDEBUG(D_IOCTL, "Detach %d, type %s\n", dev,
+ obddev->obd_type->typ_name);
obddev->obd_flags &= ~OBD_ATTACHED;
obddev->obd_type->typ_refcnt--;
+ CDEBUG(D_IOCTL, "Dev %d refcount now %d\n", dev,
+ obddev->obd_type->typ_refcnt);
obddev->obd_type = NULL;
MOD_DEC_USE_COUNT;
+ EXIT;
return 0;
}
-
case OBD_IOC_FORMAT: {
struct ioc_format {
int format_datalen;
if (err)
return err;
- if (!obddev->obd_type->typ_ops ||
- !obddev->obd_type->typ_ops->o_format )
+ if ( !OBT(obddev) || !OBP(obddev, format) )
return -EOPNOTSUPP;
/* do the format */
CDEBUG(D_IOCTL, "Format %d, type %s\n", dev,
obddev->obd_type->typ_name);
- err = obddev->obd_type->typ_ops->o_format
- (obddev, input.format_datalen, input.format_data);
+ err = OBP(obddev, format)(obddev, input.format_datalen,
+ input.format_data);
OBD_FREE(input.format_data, input.format_datalen);
return err;
if (err)
return err;
- if (!obddev->obd_type->typ_ops ||
- !obddev->obd_type->typ_ops->o_partition )
+ if ( !OBT(obddev) || !OBP(obddev, partition) )
return -EOPNOTSUPP;
/* do the partition */
CDEBUG(D_IOCTL, "Partition %d, type %s\n", dev,
obddev->obd_type->typ_name);
- err = obddev->obd_type->typ_ops->o_partition
- (obddev, input.part_datalen, input.part_data);
+ err = OBP(obddev, partition)(obddev, input.part_datalen,
+ input.part_data);
OBD_FREE(input.part_data, input.part_datalen);
return err;
if ( (!(obddev->obd_flags & OBD_SET_UP)) ||
(!(obddev->obd_flags & OBD_ATTACHED))) {
CDEBUG(D_IOCTL, "Device not attached or set up\n");
- return -EINVAL;
+ return -ENODEV;
}
/* get main structure */
if (err)
return err;
-
err = copy_from_user(&mvdata, input.part_data, sizeof(mvdata));
if (err)
return err;
- if (!obddev->obd_type->typ_ops ||
- !obddev->obd_type->typ_ops->o_copy )
+ if ( !OBT(obddev) || !OBP(obddev, copy) )
return -EOPNOTSUPP;
/* do the partition */
tgtoa = obd_oa_fromid(&conn, mvdata.tgt);
if ( ! tgtoa ) {
obd_free_oa(srcoa);
- return -ENOMEM;
+ return -ENOENT;
}
- err = obddev->obd_type->typ_ops->o_copy(&conn,srcoa, tgtoa);
+ err = OBP(obddev, copy)(&conn, srcoa, tgtoa);
obd_free_oa(srcoa);
obd_free_oa(tgtoa);
if ( (!(obddev->obd_flags & OBD_SET_UP)) ||
(!(obddev->obd_flags & OBD_ATTACHED))) {
CDEBUG(D_IOCTL, "Device not attached or set up\n");
- return -EINVAL;
+ return -ENODEV;
}
/* get main structure */
if (err)
return err;
- if (!obddev->obd_type->typ_ops ||
- !obddev->obd_type->typ_ops->o_copy )
+ if ( !OBT(obddev) || !OBP(obddev, migrate) )
return -EOPNOTSUPP;
/* do the partition */
- CDEBUG(D_IOCTL, "Migrate %d, type %s conn %d src %ld tgt %ld\n", dev,
- obddev->obd_type->typ_name, mvdata.conn_id, mvdata.src, mvdata.tgt);
+ CDEBUG(D_IOCTL, "Migrate %d, type %s conn %d src %ld tgt %ld\n",
+ dev, obddev->obd_type->typ_name, mvdata.conn_id,
+ mvdata.src, mvdata.tgt);
if ( ! (srcoa = obd_empty_oa()) )
conn.oc_id = mvdata.conn_id;
- err = obddev->obd_type->typ_ops->o_migrate(&conn, tgtoa, srcoa);
+ err = OBP(obddev, migrate)(&conn, tgtoa, srcoa);
obd_free_oa(srcoa);
obd_free_oa(tgtoa);
void *setup_data;
} input;
+ ENTRY;
/* have we attached a type to this device */
if (!(obddev->obd_flags & OBD_ATTACHED)) {
- CDEBUG(D_IOCTL, "OBD Device %d has no type.\n", dev);
- return -EINVAL;
+ CDEBUG(D_IOCTL, "Device not attached\n");
+ EXIT;
+ return -ENODEV;
}
/* has this been done already? */
if ( obddev->obd_flags & OBD_SET_UP ) {
CDEBUG(D_IOCTL, "Device %d already setup (type %s)\n",
dev, obddev->obd_type->typ_name);
- return -EINVAL;
+ EXIT;
+ return -EBUSY;
}
/* get main structure */
err = copy_from_user(&input, (void *) arg, sizeof(input));
- if (err)
+ if (err) {
+ EXIT;
return err;
+ }
err = getdata(input.setup_datalen, &input.setup_data);
- if (err)
+ if (err) {
+ EXIT;
return err;
-
+ }
/* do the setup */
CDEBUG(D_IOCTL, "Setup %d, type %s\n", dev,
obddev->obd_type->typ_name);
- if ( !obddev->obd_type->typ_ops ||
- !obddev->obd_type->typ_ops->o_setup ) {
+ if ( !OBT(obddev) || !OBP(obddev, setup) ) {
+ obddev->obd_type->typ_refcnt++;
+ CDEBUG(D_IOCTL, "Dev %d refcount now %d\n",
+ dev, obddev->obd_type->typ_refcnt);
obddev->obd_flags |= OBD_SET_UP;
+ EXIT;
return 0;
}
- err = obddev->obd_type->typ_ops->o_setup
- (obddev, input.setup_datalen, input.setup_data);
+ err = OBP(obddev, setup)(obddev, input.setup_datalen,
+ input.setup_data);
- if ( err )
+ if ( err ) {
obddev->obd_flags &= ~OBD_SET_UP;
- else {
+ EXIT;
+ } else {
obddev->obd_type->typ_refcnt++;
+ CDEBUG(D_IOCTL, "Dev %d refcount now %d\n",
+ dev, obddev->obd_type->typ_refcnt);
obddev->obd_flags |= OBD_SET_UP;
+ EXIT;
}
return err;
}
case OBD_IOC_CLEANUP: {
- int rc;
-
+ ENTRY;
/* has this minor been registered? */
- if (!obddev->obd_type)
- return -ENODEV;
+ if (!obddev->obd_type) {
+ CDEBUG(D_IOCTL, "OBD Device %d has no type.\n", dev);
+ EXIT;
+ return -EINVAL;
+ }
- if ( !obddev->obd_type->typ_refcnt )
- printk("OBD_CLEANUP: refcount wrap!\n");
+ if ( !obddev->obd_type->typ_refcnt ) {
+ printk("OBD_CLEANUP: Dev %d has refcount (%d)!\n",
+ dev, obddev->obd_type->typ_refcnt);
+ EXIT;
+ return -EBUSY;
+ }
- if ( !obddev->obd_flags & OBD_SET_UP )
- return -EINVAL;
+ if ( (!(obddev->obd_flags & OBD_SET_UP)) ||
+ (!(obddev->obd_flags & OBD_ATTACHED))) {
+ CDEBUG(D_IOCTL, "Device not attached or set up\n");
+ EXIT;
+ return -ENODEV;
+ }
- if ( !obddev->obd_type->typ_ops->o_cleanup )
+ if ( !OBT(obddev) || !OBP(obddev, cleanup) )
goto cleanup_out;
/* cleanup has no argument */
- rc = OBP(obddev, cleanup)(obddev);
- if ( rc )
- return rc;
+ err = OBP(obddev, cleanup)(obddev);
+ if ( err ) {
+ EXIT;
+ return err;
+ }
cleanup_out:
obddev->obd_flags &= ~OBD_SET_UP;
obddev->obd_type->typ_refcnt--;
+ CDEBUG(D_IOCTL, "Dev %d refcount now %d\n", dev,
+ obddev->obd_type->typ_refcnt);
+ EXIT;
return 0;
}
case OBD_IOC_CONNECT:
{
-
if ( (!(obddev->obd_flags & OBD_SET_UP)) ||
(!(obddev->obd_flags & OBD_ATTACHED))) {
CDEBUG(D_IOCTL, "Device not attached or set up\n");
- return -EINVAL;
+ return -ENODEV;
}
+ if ( !OBT(obddev) || !OBP(obddev, connect) )
+ return -EOPNOTSUPP;
- if (obddev->obd_type->typ_ops->o_connect(&conn))
+ if (OBP(obddev, connect)(&conn))
return -EINVAL;
return copy_to_user((int *)arg, &conn.oc_id,
/* frees data structures */
/* has this minor been registered? */
if (!obddev->obd_type)
- return -ENODEV;
+ return -EINVAL;
get_user(cli_id, (int *) arg);
conn.oc_id = cli_id;
+ if ( !OBT(obddev) || !OBP(obddev, disconnect))
+ return -EOPNOTSUPP;
+
OBP(obddev, disconnect)(&conn);
return 0;
* superblock that it needs. */
/* has this minor been registered? */
if (!obddev->obd_type)
- return -ENODEV;
+ return -EINVAL;
if (!obddev->u.ext2.ext2_sb || !obddev->u.ext2.ext2_sb->s_dev) {
CDEBUG(D_IOCTL, "fatal: device not initialized.\n");
- err = -EINVAL;
+ err = -ENODEV;
} else {
- if ((err = fsync_dev(obddev->u.ext2.ext2_sb->s_dev)))
+ err = fsync_dev(obddev->u.ext2.ext2_sb->s_dev);
+ if ( err )
CDEBUG(D_IOCTL, "sync: fsync_dev failure\n");
else
CDEBUG(D_IOCTL, "sync: success\n");
return put_user(err, (int *) arg);
}
case OBD_IOC_CREATE: {
- int err;
struct oic_create_s foo;
if ( copy_from_user(&foo, (const void *)arg, sizeof(foo)) )
/* has this minor been registered? */
if ( !(obddev->obd_flags & OBD_ATTACHED) ||
- !(obddev->obd_flags & OBD_SET_UP))
+ !(obddev->obd_flags & OBD_SET_UP)) {
+ CDEBUG(D_IOCTL, "Device not attached or set up\n");
return -ENODEV;
+ }
conn.oc_id = foo.conn_id;
+ if ( !OBT(obddev) || !OBP(obddev, create) )
+ return -EOPNOTSUPP;
+
i_ino = OBP(obddev, create)(&conn, foo.prealloc, &err);
if (err) {
CDEBUG(D_IOCTL, "create: obd_inode_new failure\n");
return put_user(i_ino, (int *) arg);
}
- case OBD_IOC_DESTROY:
- {
+ case OBD_IOC_DESTROY: {
struct destroy_s {
unsigned int conn_id;
unsigned int ino;
} destroy;
obdattr *oa;
- int rc;
if ( ! (oa = obd_empty_oa()) )
return -ENOMEM;
/* has this minor been registered? */
if (!obddev->obd_type)
- return -ENODEV;
-
+ return -EINVAL;
copy_from_user(&destroy, (int *)arg, sizeof(struct destroy_s));
- if ( !obddev->obd_type ||
- !obddev->obd_type->typ_ops->o_destroy)
- return -EINVAL;
+ if ( !OBT(obddev) || !OBP(obddev, destroy) )
+ return -EOPNOTSUPP;
oa->i_ino = destroy.ino;
conn.oc_id = destroy.conn_id;
- rc = obddev->obd_type->typ_ops->o_destroy(&conn, oa);
+ err = OBP(obddev, destroy)(&conn, oa);
OBD_FREE(oa, sizeof(*oa));
- return rc;
+ return err;
}
- case OBD_IOC_SETATTR:
- {
+ case OBD_IOC_SETATTR: {
struct oic_attr_s foo;
obdattr *oa;
- int rc;
if ( ! (oa = obd_empty_oa()) )
return -ENOMEM;
/* has this minor been registered? */
if (!obddev->obd_type)
- return -ENODEV;
+ return -EINVAL;
- rc = copy_from_user(&foo, (int *)arg, sizeof(foo));
- if (rc)
- return rc;
+ err = copy_from_user(&foo, (int *)arg, sizeof(foo));
+ if (err)
+ return err;
- if ( !obddev->obd_type ||
- !obddev->obd_type->typ_ops->o_setattr)
- return -EINVAL;
+ if ( !OBT(obddev) || !OBP(obddev, setattr) )
+ return -EOPNOTSUPP;
oa->i_ino = foo.ino;
inode_setattr(oa, &foo.iattr);
conn.oc_id = foo.conn_id;
- rc = obddev->obd_type->typ_ops->o_setattr(&conn, oa);
+ err = OBP(obddev, setattr)(&conn, oa);
OBD_FREE(oa, sizeof(*oa));
- return rc;
+ return err;
}
- case OBD_IOC_GETATTR:
- {
- int rc;
+ case OBD_IOC_GETATTR: {
struct oic_getattr {
unsigned int conn_id;
unsigned long ino;
struct iattr iattr;
obdattr *oa;
- rc = copy_from_user(&foo, (int *)arg, sizeof(foo));
- if (rc)
- return rc;
+ err = copy_from_user(&foo, (int *)arg, sizeof(foo));
+ if (err)
+ return err;
conn.oc_id = foo.conn_id;
oa = obd_oa_fromid(&conn, foo.ino);
return -ENOENT;
inode_to_iattr(oa, &iattr);
- rc = copy_to_user((int *)arg, &iattr, sizeof(iattr));
- return rc;
+ err = copy_to_user((int *)arg, &iattr, sizeof(iattr));
+ return err;
}
- case OBD_IOC_READ:
- {
+ case OBD_IOC_READ: {
obdattr *oa = NULL;
- int rc;
+ int err;
struct oic_rw_s rw_s; /* read, write ioctl str */
- rc = copy_from_user(&rw_s, (int *)arg, sizeof(rw_s));
- if ( rc )
+ err = copy_from_user(&rw_s, (int *)arg, sizeof(rw_s));
+ if ( err )
goto READ_OUT;
-
conn.oc_id = rw_s.conn_id;
if ( ! (oa = obd_oa_fromid(&conn, rw_s.id)) )
return -ENOENT;
- rc = -EINVAL;
- if ( !obddev->obd_type->typ_ops ||
- !obddev->obd_type->typ_ops->o_read )
+ if ( !OBT(obddev) || !OBP(obddev, read) ) {
+ err = -EOPNOTSUPP;
goto READ_OUT;
+ }
- rc = obddev->obd_type->typ_ops->o_read
- (&conn, oa, rw_s.buf, &rw_s.count, rw_s.offset);
- if ( rc )
+ err = OBP(obddev, read)(&conn, oa, rw_s.buf, &rw_s.count,
+ rw_s.offset);
+ if ( err )
goto READ_OUT;
- rc = copy_to_user((int*)arg, &rw_s.count, sizeof(rw_s.count));
+ err = copy_to_user((int*)arg, &rw_s.count, sizeof(rw_s.count));
READ_OUT:
if ( oa )
OBD_FREE(oa, sizeof(*oa));
- return rc;
+ return err;
}
case OBD_IOC_WRITE: {
obdattr *oa = NULL;
- int rc;
struct oic_rw_s rw_s; /* read, write ioctl str */
- rc = copy_from_user(&rw_s, (int *)arg, sizeof(rw_s));
- if ( rc )
+ err = copy_from_user(&rw_s, (int *)arg, sizeof(rw_s));
+ if ( err )
goto WRITE_OUT;
conn.oc_id = rw_s.conn_id;
if ( !oa )
return -ENOENT;
- rc = -EINVAL;
- if ( !obddev->obd_type->typ_ops ||
- !obddev->obd_type->typ_ops->o_write )
+ if ( !OBT(obddev) || !OBP(obddev, write) ) {
+ err = -EOPNOTSUPP;
goto WRITE_OUT;
+ }
- rc = obddev->obd_type->typ_ops->o_write
- (&conn, oa, rw_s.buf, &rw_s.count, rw_s.offset);
- if ( rc )
+ err = OBP(obddev, write)(&conn, oa, rw_s.buf, &rw_s.count,
+ rw_s.offset);
+ if ( err )
goto WRITE_OUT;
- rc = copy_to_user((int*)arg, &rw_s.count, sizeof(rw_s.count));
+ err = copy_to_user((int*)arg, &rw_s.count, sizeof(rw_s.count));
WRITE_OUT:
OBD_FREE(oa, sizeof(*oa));
- return rc;
+ return err;
}
case OBD_IOC_PREALLOCATE: {
struct oic_prealloc_s prealloc;
- int rc;
/* has this minor been registered? */
if (!obddev->obd_type)
- return -ENODEV;
-
+ return -EINVAL;
- rc = copy_from_user(&prealloc, (int *)arg, sizeof(prealloc));
- if (rc)
- return -ENOMEM;
+ err = copy_from_user(&prealloc, (int *)arg, sizeof(prealloc));
+ if (err)
+ return -EFAULT;
if ( !(obddev->obd_flags & OBD_ATTACHED) ||
!(obddev->obd_flags & OBD_SET_UP)) {
- CDEBUG(D_IOCTL, "fatal: device not initialized.\n");
- return -EINVAL;
+ CDEBUG(D_IOCTL, "Device not attached or set up\n");
+ return -ENODEV;
}
- if (!obddev->obd_type ||
- !obddev->obd_type->typ_ops->o_preallocate)
+ if ( !OBT(obddev) || !OBP(obddev, preallocate) )
return -EOPNOTSUPP;
+
conn.oc_id = prealloc.cli_id;
- rc = obddev->obd_type->typ_ops->o_preallocate
- (&conn, &prealloc.alloc, prealloc.inodes);
- if ( rc )
- return rc;
+ err = OBP(obddev, preallocate)(&conn, &prealloc.alloc,
+ prealloc.inodes);
+ if ( err )
+ return err;
return copy_to_user((int *)arg, &prealloc, sizeof(prealloc));
}
- case OBD_IOC_STATFS:
- {
+ case OBD_IOC_STATFS: {
struct statfs *tmp;
unsigned int conn_id;
struct statfs buf;
- int rc;
/* has this minor been registered? */
if (!obddev->obd_type)
- return -ENODEV;
+ return -EINVAL;
tmp = (void *)arg + sizeof(unsigned int);
get_user(conn_id, (int *) arg);
- if ( !obddev->obd_type ||
- !obddev->obd_type->typ_ops->o_statfs)
- return -EINVAL;
+
+ if ( !OBT(obddev) || !OBP(obddev, statfs) )
+ return -EOPNOTSUPP;
conn.oc_id = conn_id;
- rc = obddev->obd_type->typ_ops->o_statfs(&conn, &buf);
- if ( rc )
- return rc;
- rc = copy_to_user(tmp, &buf, sizeof(buf));
- return rc;
+ err = OBP(obddev, statfs)(&conn, &buf);
+ if ( err )
+ return err;
+ err = copy_to_user(tmp, &buf, sizeof(buf));
+ return err;
}
default: {
void *karg;
/* get data structures */
- err = copy_from_user(&input, (void *) arg, sizeof(input));
- if (err) {
+ err = copy_from_user(&input, (void *)arg, sizeof(input));
+ if ( err ) {
EXIT;
return err;
}
- if ( (err = getdata(input.att_typelen + 1, &input.att_type))){
+ err = getdata(input.att_typelen + 1, &input.att_type);
+ if ( err ) {
EXIT;
return err;
}
/* find the type */
- err = -EINVAL;
type = obd_nm_to_type(input.att_type);
OBD_FREE(input.att_type, input.att_typelen + 1);
if ( !type ) {
printk("Unknown obd type dev %d\n", dev);
EXIT;
- return err;
+ return -EINVAL;
}
- if ( !type->typ_ops->o_iocontrol ) {
+ if ( !type->typ_ops || !type->typ_ops->o_iocontrol ) {
EXIT;
- return -EINVAL;
+ return -EOPNOTSUPP;
}
-
+ conn.oc_id = input.att_connid;
CDEBUG(D_IOCTL, "Calling ioctl %x for type %s, len %d\n",
cmd, type->typ_name, input.att_datalen);
/* get the generic data */
- if ( (err = getdata(input.att_datalen, &karg)) ) {
+ karg = input.att_data;
+ err = getdata(input.att_datalen, &karg);
+ if ( err ) {
EXIT;
return err;
}
- err = type->typ_ops->o_iocontrol(cmd, input.att_datalen,
+ err = type->typ_ops->o_iocontrol(cmd, &conn, input.att_datalen,
karg, input.att_data);
OBD_FREE(karg, input.att_datalen);
if ( obd_nm_to_type(nm) ) {
CDEBUG(D_IOCTL, "Type %s already registered\n", nm);
EXIT;
- return -1;
+ return -EEXIST;
}
OBD_ALLOC(type, struct obd_type * , sizeof(*type));
if ( !type ) {
MOD_DEC_USE_COUNT;
- printk("OBD: NO TYPE\n");
+ printk("Unknown obd type\n");
EXIT;
- return -1;
+ return -EINVAL;
}
if ( type->typ_refcnt ) {
MOD_DEC_USE_COUNT;
- printk("OBD: refcount wrap\n");
+ printk("OBD: Type %s has refcount (%d)\n", nm,
+ type->typ_refcnt);
EXIT;
- return -1;
+ return -EBUSY;
}
list_del(&type->typ_chain);
struct obd_device *obddev = &obd_dev[i];
if ( obddev->obd_type &&
(obddev->obd_flags & OBD_SET_UP) &&
- obddev->obd_type->typ_ops->o_detach ) {
+ OBT(obddev) && OBP(obddev, detach) ) {
+ /* XXX should this call generic detach otherwise? */
OBP(obddev, detach)(obddev);
}
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff