X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fobdclass%2Fclass_obd.c;h=24cadd0be9969e8384addd8e8d7a8ae56a659d09;hb=c227004555dd3485504b72e6d17ad3bb1bde744f;hp=95bdef8df69bab8a4fedeb26280d0d10a0ccb3d3;hpb=851d24d58eea7e9664546a8be8dd41959e4aa353;p=fs%2Flustre-release.git diff --git a/lustre/obdclass/class_obd.c b/lustre/obdclass/class_obd.c index 95bdef8..24cadd0 100644 --- a/lustre/obdclass/class_obd.c +++ b/lustre/obdclass/class_obd.c @@ -56,6 +56,7 @@ #include #include +static int obd_init_magic; int obd_print_entry = 1; int obd_debug_level = 4095; struct obd_device obd_dev[MAX_OBD_DEVICES]; @@ -73,7 +74,8 @@ static int obd_class_open(struct inode * inode, struct file * file) 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; @@ -93,12 +95,12 @@ static int obd_class_release(struct inode * inode, struct file * file) 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; @@ -110,10 +112,12 @@ static struct obd_type *obd_nm_to_type(char *nm) { struct list_head *tmp; struct obd_type *type; + CDEBUG(D_IOCTL, "SEARCH %s\n", nm); tmp = &obd_types; while ( (tmp = tmp->next) != &obd_types ) { type = list_entry(tmp, struct obd_type, typ_chain); + CDEBUG(D_IOCTL, "TYP %s\n", type->typ_name); if (strlen(type->typ_name) == strlen(nm) && strcmp(type->typ_name, nm) == 0 ) { return type; @@ -130,6 +134,8 @@ static int getdata(int len, void **data) if (!len) return 0; + CDEBUG(D_IOCTL, "getdata: len %d, add %p\n", len, *data); + OBD_ALLOC(tmp, void *, len); if ( !tmp ) return -ENOMEM; @@ -148,13 +154,14 @@ static int getdata(int len, void **data) static int obd_class_ioctl (struct inode * inode, struct file * filp, unsigned int cmd, unsigned long arg) { - int err, i_ino, dev; struct obd_device *obddev; - struct oic_rw_s rw_s; /* read, write */ + /* NOTE this must be larger than any of the ioctl data structs */ + char buff[1024]; + void *karg = buff; + struct obd_conn conn; + int err, dev; long int cli_id; /* connect, disconnect */ - struct oic_prealloc_s prealloc; /* preallocate */ - if (!inode) return -EINVAL; @@ -162,219 +169,243 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, if (dev > MAX_OBD_DEVICES) return -ENODEV; obddev = &obd_dev[dev]; + conn.oc_dev = obddev; switch (cmd) { + case TCGETS: + return -EINVAL; case OBD_IOC_ATTACH: { struct obd_type *type; - struct oic_attach input; + struct oic_generic *input = karg; + 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; + 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); + 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); + 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; } - CDEBUG(D_IOCTL, "Attach %d, type %s\n", - dev, obddev->obd_type->typ_name); - if (!obddev->obd_type->typ_ops || !OBP(obddev,attach)) { + INIT_LIST_HEAD(&obddev->obd_gen_clients); + obddev->obd_multi_count = 0; + + CDEBUG(D_IOCTL, "Attach %d, datalen %d, type %s\n", + dev, input->att_datalen, obddev->obd_type->typ_name); + /* maybe we are done */ + 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); - OBD_FREE(input.att_data, input.att_datalen); + 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_FORMAT: { - struct ioc_format { - int format_datalen; - void *format_data; - } input; - - /* have we attached a type to this device */ - if ( !obddev->obd_type ) { - CDEBUG(D_IOCTL, "OBD Device %d has no type.\n", dev); - return -EINVAL; - } - - /* get main structure */ - err = copy_from_user(&input, (void *) arg, sizeof(input)); - if (err) - return err; - - err = getdata(input.format_datalen, &input.format_data); - if (err) - return err; - if (!obddev->obd_type->typ_ops || - !obddev->obd_type->typ_ops->o_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); + case OBD_IOC_DETACH: { - OBD_FREE(input.format_data, input.format_datalen); - return err; - } - case OBD_IOC_PARTITION: { - struct ioc_part { - int part_datalen; - void *part_data; - } input; - - /* have we attached a type to this device */ - if ( !obddev->obd_type ) { - CDEBUG(D_IOCTL, "OBD Device %d has no type.\n", dev); - 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; } - /* get main structure */ - err = copy_from_user(&input, (void *) arg, sizeof(input)); - if (err) - return err; - - err = getdata(input.part_datalen, &input.part_data); - if (err) - return err; - - if (!obddev->obd_type->typ_ops || - !obddev->obd_type->typ_ops->o_partition ) - return -EOPNOTSUPP; - - /* do the partition */ - CDEBUG(D_IOCTL, "Partition %d, type %s\n", dev, + CDEBUG(D_IOCTL, "Detach %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); - - OBD_FREE(input.part_data, input.part_datalen); - return err; + 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_SETUP_OBDDEV: { + + case OBD_IOC_SETUP: { struct ioc_setup { int setup_datalen; void *setup_data; - } input; + } *setup; + setup = karg; + 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) + err = copy_from_user(setup, (void *) arg, sizeof(*setup)); + if (err) { + EXIT; return err; + } - err = getdata(input.setup_datalen, &input.setup_data); - if (err) + err = getdata(setup->setup_datalen, &setup->setup_data); + 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, setup->setup_datalen, + setup->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) + if (!obddev->obd_type) { + CDEBUG(D_IOCTL, "OBD Device %d has no type.\n", dev); + EXIT; return -ENODEV; + } + + 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_type->typ_refcnt ) - printk("OBD_CLEANUP: refcount wrap!\n"); + 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 = 0; + obddev->obd_flags &= ~OBD_SET_UP; obddev->obd_type->typ_refcnt--; - obddev->obd_type = NULL; - MOD_DEC_USE_COUNT; + CDEBUG(D_IOCTL, "Dev %d refcount now %d\n", dev, + obddev->obd_type->typ_refcnt); + EXIT; return 0; } case OBD_IOC_CONNECT: { - struct obd_conn_info conninfo; - 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 (obddev->obd_type->typ_ops->o_connect(obddev, &conninfo)) - return -EINVAL; + if ( !OBT(obddev) || !OBP(obddev, connect) ) + return -EOPNOTSUPP; + + err = OBP(obddev, connect)(&conn); + if ( err ) + return err; - return copy_to_user((int *)arg, &conninfo, - sizeof(struct obd_conn_info)); + return copy_to_user((int *)arg, &conn.oc_id, + sizeof(uint32_t)); } case OBD_IOC_DISCONNECT: /* frees data structures */ @@ -383,241 +414,214 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, return -ENODEV; get_user(cli_id, (int *) arg); + conn.oc_id = cli_id; - OBP(obddev, disconnect)(cli_id); + if ( !OBT(obddev) || !OBP(obddev, disconnect)) + return -EOPNOTSUPP; + + OBP(obddev, disconnect)(&conn); return 0; + /* XXX sync needs to be done */ case OBD_IOC_SYNC: { - /* sync doesn't need a connection ID, because it knows - * what device it was called on, and can thus get the - * superblock that it needs. */ - /* has this minor been registered? */ + struct oic_range_s *range = karg; + if (!obddev->obd_type) return -ENODEV; - if (!obddev->u.ext2.ext2_sb || !obddev->u.ext2.ext2_sb->s_dev) { - CDEBUG(D_IOCTL, "fatal: device not initialized.\n"); - err = -EINVAL; - } else { - if ((err = fsync_dev(obddev->u.ext2.ext2_sb->s_dev))) - CDEBUG(D_IOCTL, "sync: fsync_dev failure\n"); - else - CDEBUG(D_IOCTL, "sync: success\n"); + err = copy_from_user(range, (const void *)arg, sizeof(*range)); + if (err) { + EXIT; + return err; } return put_user(err, (int *) arg); } case OBD_IOC_CREATE: { - int err; - struct oic_create_s foo; + struct oic_attr_s *attr = karg; - if ( copy_from_user(&foo, (const void *)arg, sizeof(foo)) ) - return -EFAULT; + err = copy_from_user(attr, (const void *)arg, sizeof(*attr)); + if (err) { + EXIT; + return err; + } /* 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; - - - if (!obddev->u.ext2.ext2_sb) { - CDEBUG(D_IOCTL, "fatal: device not initialized.\n"); - return put_user(-EINVAL, (int *) arg); } + conn.oc_id = attr->conn_id; - i_ino = OBP(obddev, create)(foo.conn_id, foo.prealloc, &err); + if ( !OBT(obddev) || !OBP(obddev, create) ) + return -EOPNOTSUPP; + + err = OBP(obddev, create)(&conn, &attr->obdo); if (err) { - CDEBUG(D_IOCTL, "create: obd_inode_new failure\n"); - /* 0 is the only error value */ - return put_user(0, (int *) arg); + EXIT; + return err; } - return put_user(i_ino, (int *) arg); + err = copy_to_user((int *)arg, attr, sizeof(*attr)); + EXIT; + return err; } - case OBD_IOC_DESTROY: - { - struct destroy_s { - unsigned int conn_id; - unsigned int ino; - } destroy; + case OBD_IOC_DESTROY: { + struct oic_attr_s *attr = karg; + /* has this minor been registered? */ if (!obddev->obd_type) return -ENODEV; + err = copy_from_user(attr, (int *)arg, sizeof(*attr)); + if ( err ) { + EXIT; + return err; + } - 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; - return obddev->obd_type->typ_ops->o_destroy(destroy.conn_id, destroy.ino); + conn.oc_id = attr->conn_id; + err = OBP(obddev, destroy)(&conn, &attr->obdo); + EXIT; + return err; } - case OBD_IOC_SETATTR: - { - int err; - struct oic_attr_s foo; - struct inode holder; + + case OBD_IOC_SETATTR: { + struct oic_attr_s *attr = karg; /* has this minor been registered? */ if (!obddev->obd_type) return -ENODEV; - - err= copy_from_user(&foo, (int *)arg, sizeof(foo)); + err = copy_from_user(attr, (int *)arg, sizeof(*attr)); 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; - inode_setattr(&holder, &foo.iattr); - return obddev->obd_type->typ_ops->o_setattr(foo.conn_id, foo.ino, &holder); + conn.oc_id = attr->conn_id; + err = OBP(obddev, setattr)(&conn, &attr->obdo); + EXIT; + return err; } - case OBD_IOC_GETATTR: - { - int err; - struct tmp { - unsigned int conn_id; - unsigned long ino; - } foo; - struct iattr iattr; - struct inode holder; - copy_from_user(&foo, (int *)arg, sizeof(struct tmp)); - - if ( !obddev->obd_type || - !obddev->obd_type->typ_ops->o_getattr) - return -EINVAL; + case OBD_IOC_GETATTR: { + struct oic_attr_s *attr = karg; - if (obddev->obd_type->typ_ops->o_getattr(foo.conn_id, - foo.ino, &holder)) - return -EINVAL; + err = copy_from_user(attr, (int *)arg, sizeof(*attr)); + if (err) + return err; - inode_to_iattr(&holder, &iattr); - err = copy_to_user((int *)arg, &iattr, sizeof(iattr)); + conn.oc_id = attr->conn_id; + err = OBP(obddev, getattr)(&conn, &attr->obdo); + if ( err ) { + EXIT; + return err; + } + + err = copy_to_user((int *)arg, attr, sizeof(*attr)); + EXIT; return err; } - case OBD_IOC_READ2: - { + case OBD_IOC_READ: { int err; + struct oic_rw_s *rw_s = karg; /* read, write ioctl str */ - /* has this minor been registered? */ - if (!obddev->obd_type) - return -ENODEV; - - err = copy_from_user(&rw_s, (int *)arg, sizeof(struct oic_rw_s)); - if ( err ) + err = copy_from_user(rw_s, (int *)arg, sizeof(*rw_s)); + if ( err ) { + EXIT; return err; + } - if ( !obddev->obd_type->typ_ops || - !obddev->obd_type->typ_ops->o_read ) - return -EINVAL; + conn.oc_id = rw_s->conn_id; - rw_s.count = obddev->obd_type->typ_ops->o_read2(rw_s.conn_id, - rw_s.inode, - rw_s.buf, - rw_s.count, - rw_s.offset, - &err); - if ( err ) + if ( !OBT(obddev) || !OBP(obddev, read) ) { + err = -EOPNOTSUPP; + EXIT; return err; + } - err = copy_to_user((int*)arg, &rw_s.count, - sizeof(unsigned long)); + err = OBP(obddev, read)(&conn, &rw_s->obdo, rw_s->buf, + &rw_s->count, rw_s->offset); + if ( err ) { + EXIT; + return err; + } + + err = copy_to_user((int*)arg, &rw_s->count, sizeof(rw_s->count)); + EXIT; return err; } + case OBD_IOC_WRITE: { + struct oic_rw_s *rw_s = karg; /* read, write ioctl str */ - case OBD_IOC_READ: - { - int err; - /* has this minor been registered? */ - if (!obddev->obd_type) - return -ENODEV; + err = copy_from_user(rw_s, (int *)arg, sizeof(*rw_s)); + if ( err ) { + EXIT; + return err; + } + conn.oc_id = rw_s->conn_id; - err = copy_from_user(&rw_s, (int *)arg, sizeof(struct oic_rw_s)); - if ( err ) + if ( !OBT(obddev) || !OBP(obddev, write) ) { + err = -EOPNOTSUPP; return err; + } - if ( !obddev->obd_type->typ_ops || - !obddev->obd_type->typ_ops->o_read ) - return -EINVAL; - - rw_s.count = obddev->obd_type->typ_ops->o_read(rw_s.conn_id, - rw_s.inode, - rw_s.buf, - rw_s.count, - rw_s.offset, - &err); - if ( err ) + err = OBP(obddev, write)(&conn, &rw_s->obdo, rw_s->buf, + &rw_s->count, rw_s->offset); + if ( err ) { + EXIT; return err; + } - err = copy_to_user((int*)arg, &rw_s.count, - sizeof(unsigned long)); + err = copy_to_user((int*)arg, &rw_s->count, sizeof(rw_s->count)); + EXIT; return err; } + case OBD_IOC_PREALLOCATE: { + struct oic_prealloc_s *prealloc = karg; - case OBD_IOC_WRITE: - { - int err; /* has this minor been registered? */ if (!obddev->obd_type) return -ENODEV; + err = copy_from_user(prealloc, (int *)arg, sizeof(*prealloc)); + if (err) + return -EFAULT; - copy_from_user(&rw_s, (int *)arg, sizeof(struct oic_rw_s)); - CDEBUG(D_IOCTL, "\n"); - if ( !obddev->obd_type->typ_ops->o_write ) - return -EINVAL; - rw_s.count = - obddev->obd_type->typ_ops->o_write(rw_s.conn_id, - rw_s.inode, - rw_s.buf, - rw_s.count, - rw_s.offset, - &err); - - printk("Result rw_s.count %ld\n", rw_s.count); - return (int)rw_s.count; - copy_to_user((int *)arg, &rw_s.count, - sizeof(unsigned long)); - return err; - } - case OBD_IOC_PREALLOCATE: - /* has this minor been registered? */ - if (!obddev->obd_type) + if ( !(obddev->obd_flags & OBD_ATTACHED) || + !(obddev->obd_flags & OBD_SET_UP)) { + CDEBUG(D_IOCTL, "Device not attached or set up\n"); return -ENODEV; - - - copy_from_user(&prealloc, (int *)arg, - sizeof(struct oic_prealloc_s)); - - if (!obddev->u.ext2.ext2_sb || !obddev->u.ext2.ext2_sb->s_dev) { - CDEBUG(D_IOCTL, "fatal: device not initialized.\n"); - return -EINVAL; } - if (!obddev->obd_type || - !obddev->obd_type->typ_ops->o_preallocate) - return -EINVAL; + if ( !OBT(obddev) || !OBP(obddev, preallocate) ) + return -EOPNOTSUPP; - prealloc.alloc = - obddev->obd_type->typ_ops->o_preallocate(prealloc.cli_id, prealloc.alloc, - prealloc.inodes, &err); - if ( err ) + conn.oc_id = prealloc->cli_id; + err = OBP(obddev, preallocate)(&conn, &prealloc->alloc, + prealloc->ids); + if ( err ) { + EXIT; return err; - return copy_to_user((int *)arg, &prealloc, - sizeof(struct oic_prealloc_s)); - case OBD_IOC_STATFS: - { + } + + err =copy_to_user((int *)arg, prealloc, sizeof(*prealloc)); + EXIT; + return err; + } + 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) @@ -625,20 +629,136 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp, 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; - rc = obddev->obd_type->typ_ops->o_statfs(conn_id, &buf); - if ( rc ) - return rc; - rc = copy_to_user(tmp, &buf, sizeof(buf)); - return rc; + if ( !OBT(obddev) || !OBP(obddev, statfs) ) + return -EOPNOTSUPP; + + conn.oc_id = conn_id; + err = OBP(obddev, statfs)(&conn, &buf); + if ( err ) { + EXIT; + return err; + } + err = copy_to_user(tmp, &buf, sizeof(buf)); + EXIT; + return err; + + } + case OBD_IOC_COPY: { + struct ioc_mv_s *mvdata = karg; + + if ( (!(obddev->obd_flags & OBD_SET_UP)) || + (!(obddev->obd_flags & OBD_ATTACHED))) { + CDEBUG(D_IOCTL, "Device not attached or set up\n"); + return -ENODEV; + } + + /* get main structure */ + err = copy_from_user(mvdata, (void *) arg, sizeof(*mvdata)); + if (err) { + EXIT; + return err; + } + + if ( !OBT(obddev) || !OBP(obddev, copy) ) + return -EOPNOTSUPP; + + /* do the partition */ + CDEBUG(D_IOCTL, "Copy %d, type %s dst %Ld src %Ld\n", dev, + obddev->obd_type->typ_name, mvdata->dst.o_id, + mvdata->src.o_id); + + conn.oc_id = mvdata->src_conn_id; + + err = OBP(obddev, copy)(&conn, &mvdata->dst, + &conn, &mvdata->src, + mvdata->src.o_size, 0); + return err; + } + + case OBD_IOC_MIGR: { + struct ioc_mv_s *mvdata = karg; + + if ( (!(obddev->obd_flags & OBD_SET_UP)) || + (!(obddev->obd_flags & OBD_ATTACHED))) { + CDEBUG(D_IOCTL, "Device not attached or set up\n"); + return -ENODEV; + } + + err = copy_from_user(mvdata, (void *) arg, sizeof(*mvdata)); + if (err) { + EXIT; + return err; + } + + CDEBUG(D_IOCTL, "Migrate copying %d\n", sizeof(*mvdata)); + + if ( !OBT(obddev) || !OBP(obddev, migrate) ) + return -EOPNOTSUPP; + + /* do the partition */ + CDEBUG(D_IOCTL, "Migrate %d, type %s conn %d src %Ld dst %Ld\n", + dev, obddev->obd_type->typ_name, mvdata->src_conn_id, + mvdata->src.o_id, mvdata->dst.o_id); + + conn.oc_id = mvdata->src_conn_id; + err = OBP(obddev, migrate)(&conn, &mvdata->dst, &mvdata->src, + mvdata->dst.o_size, 0); + + return err; + } + + default: { + struct obd_type *type; + struct oic_generic input; + void *karg; + + /* get data structures */ + err = copy_from_user(&input, (void *)arg, sizeof(input)); + if ( err ) { + EXIT; + return err; + } + + err = getdata(input.att_typelen + 1, &input.att_type); + if ( err ) { + EXIT; + return err; + } + + /* find the type */ + 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 -EINVAL; + } + + if ( !type->typ_ops || !type->typ_ops->o_iocontrol ) { + EXIT; + 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 */ + karg = input.att_data; + err = getdata(input.att_datalen, karg); + if ( err ) { + EXIT; + return err; + } + + err = type->typ_ops->o_iocontrol(cmd, &conn, input.att_datalen, + karg, input.att_data); + OBD_FREE(karg, input.att_datalen); + + EXIT; + return err; } - default: - printk("invalid ioctl: cmd = %x, arg = %lx\n", cmd, arg); - return -ENOTTY; } } @@ -648,20 +768,30 @@ int obd_register_type(struct obd_ops *ops, char *nm) { struct obd_type *type; + + if (obd_init_magic != 0x11223344) { + EXIT; + return -EINVAL; + } + if ( obd_nm_to_type(nm) ) { CDEBUG(D_IOCTL, "Type %s already registered\n", nm); - return -1; + EXIT; + return -EEXIST; } - + OBD_ALLOC(type, struct obd_type * , sizeof(*type)); - if ( !type ) + if ( !type ) { + EXIT; return -ENOMEM; + } memset(type, 0, sizeof(*type)); INIT_LIST_HEAD(&type->typ_chain); - + MOD_INC_USE_COUNT; list_add(&type->typ_chain, obd_types.next); type->typ_ops = ops; type->typ_name = nm; + EXIT; return 0; } @@ -669,14 +799,24 @@ int obd_unregister_type(char *nm) { struct obd_type *type = obd_nm_to_type(nm); - if ( !type ) - return -1; + if ( !type ) { + MOD_DEC_USE_COUNT; + printk("Unknown obd type\n"); + EXIT; + return -EINVAL; + } - if ( type->typ_refcnt ) - return -1; + if ( type->typ_refcnt ) { + MOD_DEC_USE_COUNT; + printk("OBD: Type %s has refcount (%d)\n", nm, + type->typ_refcnt); + EXIT; + return -EBUSY; + } list_del(&type->typ_chain); OBD_FREE(type, sizeof(*type)); + MOD_DEC_USE_COUNT; return 0; } @@ -704,12 +844,13 @@ static struct file_operations obd_psdev_fops = { int init_obd(void) { + int err; int i; - printk(KERN_INFO "OBD class driver v0.002, braam@stelias.com\n"); - + printk(KERN_INFO "OBD class driver v0.01, braam@stelias.com\n"); + INIT_LIST_HEAD(&obd_types); - + if (register_chrdev(OBD_PSDEV_MAJOR,"obd_psdev", &obd_psdev_fops)) { printk(KERN_ERR "obd_psdev: unable to get major %d\n", @@ -719,11 +860,15 @@ int init_obd(void) for (i = 0; i < MAX_OBD_DEVICES; i++) { memset(&(obd_dev[i]), 0, sizeof(obd_dev[i])); + obd_dev[i].obd_minor = i; INIT_LIST_HEAD(&obd_dev[i].obd_gen_clients); } + err = obd_init_obdo_cache(); + if (err) + return err; obd_sysctl_init(); - + obd_init_magic = 0x11223344; return 0; } @@ -738,8 +883,10 @@ EXPORT_SYMBOL(gen_connect); EXPORT_SYMBOL(gen_client); EXPORT_SYMBOL(gen_cleanup); EXPORT_SYMBOL(gen_disconnect); +EXPORT_SYMBOL(gen_copy_data); +EXPORT_SYMBOL(obdo_cachep); -EXPORT_SYMBOL(gen_multi_attach); +/* EXPORT_SYMBOL(gen_multi_attach); */ EXPORT_SYMBOL(gen_multi_setup); EXPORT_SYMBOL(gen_multi_cleanup); @@ -759,10 +906,16 @@ void cleanup_module(void) for (i = 0; i < MAX_OBD_DEVICES; i++) { struct obd_device *obddev = &obd_dev[i]; if ( obddev->obd_type && - obddev->obd_type->typ_ops->o_cleanup_device ) - OBP(obddev, cleanup_device)(obddev); + (obddev->obd_flags & OBD_SET_UP) && + OBT(obddev) && OBP(obddev, detach) ) { + /* XXX should this call generic detach otherwise? */ + OBP(obddev, detach)(obddev); + } } obd_sysctl_clean(); + obd_cleanup_obdo_cache(); + obd_init_magic = 0; + EXIT; } #endif