drivers/scsi/osd/osd_uld.c

   1 /*
   2  * osd_uld.c - OSD Upper Layer Driver
   3  *
   4  * A Linux driver module that registers as a SCSI ULD and probes
   5  * for OSD type SCSI devices.
   6  * It's main function is to export osd devices to in-kernel users like
   7  * osdfs and pNFS-objects-LD. It also provides one ioctl for running
   8  * in Kernel tests.
   9  *
  10  * Copyright (C) 2008 Panasas Inc.  All rights reserved.
  11  *
  12  * Authors:
  13  *   Boaz Harrosh <[email protected]>
  14  *   Benny Halevy <[email protected]>
  15  *
  16  * This program is free software; you can redistribute it and/or modify
  17  * it under the terms of the GNU General Public License version 2
  18  *
  19  * Redistribution and use in source and binary forms, with or without
  20  * modification, are permitted provided that the following conditions
  21  * are met:
  22  *
  23  *  1. Redistributions of source code must retain the above copyright
  24  *     notice, this list of conditions and the following disclaimer.
  25  *  2. Redistributions in binary form must reproduce the above copyright
  26  *     notice, this list of conditions and the following disclaimer in the
  27  *     documentation and/or other materials provided with the distribution.
  28  *  3. Neither the name of the Panasas company nor the names of its
  29  *     contributors may be used to endorse or promote products derived
  30  *     from this software without specific prior written permission.
  31  *
  32  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  33  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  34  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  35  * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  36  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  37  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  38  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  39  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  40  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  41  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  42  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  43  */
  44
  45 #include <linux/namei.h>
  46 #include <linux/cdev.h>
  47 #include <linux/fs.h>
  48 #include <linux/module.h>
  49 #include <linux/device.h>
  50 #include <linux/idr.h>
  51 #include <linux/major.h>
  52 #include <linux/file.h>
  53 #include <linux/slab.h>
  54
  55 #include <scsi/scsi.h>
  56 #include <scsi/scsi_driver.h>
  57 #include <scsi/scsi_device.h>
  58 #include <scsi/scsi_ioctl.h>
  59
  60 #include <scsi/osd_initiator.h>
  61 #include <scsi/osd_sec.h>
  62
  63 #include "osd_debug.h"
  64
  65 #ifndef TYPE_OSD
  66 #  define TYPE_OSD 0x11
  67 #endif
  68
  69 #ifndef SCSI_OSD_MAJOR
  70 #  define SCSI_OSD_MAJOR 260
  71 #endif
  72 #define SCSI_OSD_MAX_MINOR MINORMASK
  73
  74 static const char osd_name[] = "osd";
  75 static const char *osd_version_string = "open-osd 0.2.1";
  76
  77 MODULE_AUTHOR("Boaz Harrosh <[email protected]>");
  78 MODULE_DESCRIPTION("open-osd Upper-Layer-Driver osd.ko");
  79 MODULE_LICENSE("GPL");
  80 MODULE_ALIAS_CHARDEV_MAJOR(SCSI_OSD_MAJOR);
  81 MODULE_ALIAS_SCSI_DEVICE(TYPE_OSD);
  82
  83 struct osd_uld_device {
  84         int minor;
  85         struct device class_dev;
  86         struct cdev cdev;
  87         struct osd_dev od;
  88         struct osd_dev_info odi;
  89         struct gendisk *disk;
  90 };
  91
  92 struct osd_dev_handle {
  93         struct osd_dev od;
  94         struct file *file;
  95         struct osd_uld_device *oud;
  96 } ;
  97
  98 static DEFINE_IDA(osd_minor_ida);
  99
 100 /*
 101  * scsi sysfs attribute operations
 102  */
 103 static ssize_t osdname_show(struct device *dev, struct device_attribute *attr,
 104                             char *buf)
 105 {
 106         struct osd_uld_device *ould = container_of(dev, struct osd_uld_device,
 107                                                    class_dev);
 108         return sprintf(buf, "%s\n", ould->odi.osdname);
 109 }
 110 static DEVICE_ATTR_RO(osdname);
 111
 112 static ssize_t systemid_show(struct device *dev, struct device_attribute *attr,
 113                             char *buf)
 114 {
 115         struct osd_uld_device *ould = container_of(dev, struct osd_uld_device,
 116                                                    class_dev);
 117
 118         memcpy(buf, ould->odi.systemid, ould->odi.systemid_len);
 119         return ould->odi.systemid_len;
 120 }
 121 static DEVICE_ATTR_RO(systemid);
 122
 123 static struct attribute *osd_uld_attrs[] = {
 124         &dev_attr_osdname.attr,
 125         &dev_attr_systemid.attr,
 126         NULL,
 127 };
 128 ATTRIBUTE_GROUPS(osd_uld);
 129
 130 static struct class osd_uld_class = {
 131         .owner          = THIS_MODULE,
 132         .name           = "scsi_osd",
 133         .dev_groups     = osd_uld_groups,
 134 };
 135
 136 /*
 137  * Char Device operations
 138  */
 139
 140 static int osd_uld_open(struct inode *inode, struct file *file)
 141 {
 142         struct osd_uld_device *oud = container_of(inode->i_cdev,
 143                                         struct osd_uld_device, cdev);
 144
 145         get_device(&oud->class_dev);
 146         /* cache osd_uld_device on file handle */
 147         file->private_data = oud;
 148         OSD_DEBUG("osd_uld_open %p\n", oud);
 149         return 0;
 150 }
 151
 152 static int osd_uld_release(struct inode *inode, struct file *file)
 153 {
 154         struct osd_uld_device *oud = file->private_data;
 155
 156         OSD_DEBUG("osd_uld_release %p\n", file->private_data);
 157         file->private_data = NULL;
 158         put_device(&oud->class_dev);
 159         return 0;
 160 }
 161
 162 /* FIXME: Only one vector for now */
 163 unsigned g_test_ioctl;
 164 do_test_fn *g_do_test;
 165
 166 int osduld_register_test(unsigned ioctl, do_test_fn *do_test)
 167 {
 168         if (g_test_ioctl)
 169                 return -EINVAL;
 170
 171         g_test_ioctl = ioctl;
 172         g_do_test = do_test;
 173         return 0;
 174 }
 175 EXPORT_SYMBOL(osduld_register_test);
 176
 177 void osduld_unregister_test(unsigned ioctl)
 178 {
 179         if (ioctl == g_test_ioctl) {
 180                 g_test_ioctl = 0;
 181                 g_do_test = NULL;
 182         }
 183 }
 184 EXPORT_SYMBOL(osduld_unregister_test);
 185
 186 static do_test_fn *_find_ioctl(unsigned cmd)
 187 {
 188         if (g_test_ioctl == cmd)
 189                 return g_do_test;
 190         else
 191                 return NULL;
 192 }
 193
 194 static long osd_uld_ioctl(struct file *file, unsigned int cmd,
 195         unsigned long arg)
 196 {
 197         struct osd_uld_device *oud = file->private_data;
 198         int ret;
 199         do_test_fn *do_test;
 200
 201         do_test = _find_ioctl(cmd);
 202         if (do_test)
 203                 ret = do_test(&oud->od, cmd, arg);
 204         else {
 205                 OSD_ERR("Unknown ioctl %d: osd_uld_device=%p\n", cmd, oud);
 206                 ret = -ENOIOCTLCMD;
 207         }
 208         return ret;
 209 }
 210
 211 static const struct file_operations osd_fops = {
 212         .owner          = THIS_MODULE,
 213         .open           = osd_uld_open,
 214         .release        = osd_uld_release,
 215         .unlocked_ioctl = osd_uld_ioctl,
 216         .llseek         = noop_llseek,
 217 };
 218
 219 struct osd_dev *osduld_path_lookup(const char *name)
 220 {
 221         struct osd_uld_device *oud;
 222         struct osd_dev_handle *odh;
 223         struct file *file;
 224         int error;
 225
 226         if (!name || !*name) {
 227                 OSD_ERR("Mount with !path || !*path\n");
 228                 return ERR_PTR(-EINVAL);
 229         }
 230
 231         odh = kzalloc(sizeof(*odh), GFP_KERNEL);
 232         if (unlikely(!odh))
 233                 return ERR_PTR(-ENOMEM);
 234
 235         file = filp_open(name, O_RDWR, 0);
 236         if (IS_ERR(file)) {
 237                 error = PTR_ERR(file);
 238                 goto free_od;
 239         }
 240
 241         if (file->f_op != &osd_fops){
 242                 error = -EINVAL;
 243                 goto close_file;
 244         }
 245
 246         oud = file->private_data;
 247
 248         odh->od = oud->od;
 249         odh->file = file;
 250         odh->oud = oud;
 251
 252         return &odh->od;
 253
 254 close_file:
 255         fput(file);
 256 free_od:
 257         kfree(odh);
 258         return ERR_PTR(error);
 259 }
 260 EXPORT_SYMBOL(osduld_path_lookup);
 261
 262 static inline bool _the_same_or_null(const u8 *a1, unsigned a1_len,
 263                                      const u8 *a2, unsigned a2_len)
 264 {
 265         if (!a2_len) /* User string is Empty means don't care */
 266                 return true;
 267
 268         if (a1_len != a2_len)
 269                 return false;
 270
 271         return 0 == memcmp(a1, a2, a1_len);
 272 }
 273
 274 static int _match_odi(struct device *dev, const void *find_data)
 275 {
 276         struct osd_uld_device *oud = container_of(dev, struct osd_uld_device,
 277                                                   class_dev);
 278         const struct osd_dev_info *odi = find_data;
 279
 280         if (_the_same_or_null(oud->odi.systemid, oud->odi.systemid_len,
 281                               odi->systemid, odi->systemid_len) &&
 282             _the_same_or_null(oud->odi.osdname, oud->odi.osdname_len,
 283                               odi->osdname, odi->osdname_len)) {
 284                 OSD_DEBUG("found device sysid_len=%d osdname=%d\n",
 285                           odi->systemid_len, odi->osdname_len);
 286                 return 1;
 287         } else {
 288                 return 0;
 289         }
 290 }
 291
 292 /* osduld_info_lookup - Loop through all devices, return the requested osd_dev.
 293  *
 294  * if @odi->systemid_len and/or @odi->osdname_len are zero, they act as a don't
 295  * care. .e.g if they're both zero /dev/osd0 is returned.
 296  */
 297 struct osd_dev *osduld_info_lookup(const struct osd_dev_info *odi)
 298 {
 299         struct device *dev = class_find_device(&osd_uld_class, NULL, odi, _match_odi);
 300         if (likely(dev)) {
 301                 struct osd_dev_handle *odh = kzalloc(sizeof(*odh), GFP_KERNEL);
 302                 struct osd_uld_device *oud = container_of(dev,
 303                         struct osd_uld_device, class_dev);
 304
 305                 if (unlikely(!odh)) {
 306                         put_device(dev);
 307                         return ERR_PTR(-ENOMEM);
 308                 }
 309
 310                 odh->od = oud->od;
 311                 odh->oud = oud;
 312
 313                 return &odh->od;
 314         }
 315
 316         return ERR_PTR(-ENODEV);
 317 }
 318 EXPORT_SYMBOL(osduld_info_lookup);
 319
 320 void osduld_put_device(struct osd_dev *od)
 321 {
 322         if (od && !IS_ERR(od)) {
 323                 struct osd_dev_handle *odh =
 324                                 container_of(od, struct osd_dev_handle, od);
 325                 struct osd_uld_device *oud = odh->oud;
 326
 327                 BUG_ON(od->scsi_device != oud->od.scsi_device);
 328
 329                 /* If scsi has released the device (logout), and exofs has last
 330                  * reference on oud it will be freed by above osd_uld_release
 331                  * within fput below. But this will oops in cdev_release which
 332                  * is called after the fops->release. A get_/put_ pair makes
 333                  * sure we have a cdev for the duration of fput
 334                  */
 335                 if (odh->file) {
 336                         get_device(&oud->class_dev);
 337                         fput(odh->file);
 338                 }
 339                 put_device(&oud->class_dev);
 340                 kfree(odh);
 341         }
 342 }
 343 EXPORT_SYMBOL(osduld_put_device);
 344
 345 const struct osd_dev_info *osduld_device_info(struct osd_dev *od)
 346 {
 347         struct osd_dev_handle *odh =
 348                                 container_of(od, struct osd_dev_handle, od);
 349         return &odh->oud->odi;
 350 }
 351 EXPORT_SYMBOL(osduld_device_info);
 352
 353 bool osduld_device_same(struct osd_dev *od, const struct osd_dev_info *odi)
 354 {
 355         struct osd_dev_handle *odh =
 356                                 container_of(od, struct osd_dev_handle, od);
 357         struct osd_uld_device *oud = odh->oud;
 358
 359         return (oud->odi.systemid_len == odi->systemid_len) &&
 360                 _the_same_or_null(oud->odi.systemid, oud->odi.systemid_len,
 361                                  odi->systemid, odi->systemid_len) &&
 362                 (oud->odi.osdname_len == odi->osdname_len) &&
 363                 _the_same_or_null(oud->odi.osdname, oud->odi.osdname_len,
 364                                   odi->osdname, odi->osdname_len);
 365 }
 366 EXPORT_SYMBOL(osduld_device_same);
 367
 368 /*
 369  * Scsi Device operations
 370  */
 371
 372 static int __detect_osd(struct osd_uld_device *oud)
 373 {
 374         struct scsi_device *scsi_device = oud->od.scsi_device;
 375         struct scsi_sense_hdr sense_hdr;
 376         char caps[OSD_CAP_LEN];
 377         int error;
 378
 379         /* sending a test_unit_ready as first command seems to be needed
 380          * by some targets
 381          */
 382         OSD_DEBUG("start scsi_test_unit_ready %p %p %p\n",
 383                         oud, scsi_device, scsi_device->request_queue);
 384         error = scsi_test_unit_ready(scsi_device, 10*HZ, 5, &sense_hdr);
 385         if (error)
 386                 OSD_ERR("warning: scsi_test_unit_ready failed\n");
 387
 388         osd_sec_init_nosec_doall_caps(caps, &osd_root_object, false, true);
 389         if (osd_auto_detect_ver(&oud->od, caps, &oud->odi))
 390                 return -ENODEV;
 391
 392         return 0;
 393 }
 394
 395 static void __remove(struct device *dev)
 396 {
 397         struct osd_uld_device *oud = container_of(dev, struct osd_uld_device,
 398                                                   class_dev);
 399         struct scsi_device *scsi_device = oud->od.scsi_device;
 400
 401         kfree(oud->odi.osdname);
 402
 403         osd_dev_fini(&oud->od);
 404         scsi_device_put(scsi_device);
 405
 406         OSD_INFO("osd_remove %s\n",
 407                  oud->disk ? oud->disk->disk_name : NULL);
 408
 409         if (oud->disk)
 410                 put_disk(oud->disk);
 411
 412         kfree(oud);
 413 }
 414
 415 static int osd_probe(struct device *dev)
 416 {
 417         struct scsi_device *scsi_device = to_scsi_device(dev);
 418         struct gendisk *disk;
 419         struct osd_uld_device *oud;
 420         int minor;
 421         int error;
 422
 423         if (scsi_device->type != TYPE_OSD)
 424                 return -ENODEV;
 425
 426         minor = ida_alloc_max(&osd_minor_ida, SCSI_OSD_MAX_MINOR, GFP_KERNEL);
 427         if (minor == -ENOSPC)
 428                 return -EBUSY;
 429         if (minor < 0)
 430                 return -ENODEV;
 431
 432         error = -ENOMEM;
 433         oud = kzalloc(sizeof(*oud), GFP_KERNEL);
 434         if (NULL == oud)
 435                 goto err_retract_minor;
 436
 437         /* class device member */
 438         device_initialize(&oud->class_dev);
 439         dev_set_drvdata(dev, oud);
 440         oud->minor = minor;
 441         oud->class_dev.devt = MKDEV(SCSI_OSD_MAJOR, oud->minor);
 442         oud->class_dev.class = &osd_uld_class;
 443         oud->class_dev.parent = dev;
 444         oud->class_dev.release = __remove;
 445
 446         /* hold one more reference to the scsi_device that will get released
 447          * in __release, in case a logout is happening while fs is mounted
 448          */
 449         if (scsi_device_get(scsi_device))
 450                 goto err_retract_minor;
 451         osd_dev_init(&oud->od, scsi_device);
 452
 453         /* allocate a disk and set it up */
 454         /* FIXME: do we need this since sg has already done that */
 455         disk = alloc_disk(1);
 456         if (!disk) {
 457                 OSD_ERR("alloc_disk failed\n");
 458                 goto err_free_osd;
 459         }
 460         disk->major = SCSI_OSD_MAJOR;
 461         disk->first_minor = oud->minor;
 462         sprintf(disk->disk_name, "osd%d", oud->minor);
 463         oud->disk = disk;
 464
 465         /* Detect the OSD Version */
 466         error = __detect_osd(oud);
 467         if (error) {
 468                 OSD_ERR("osd detection failed, non-compatible OSD device\n");
 469                 goto err_free_osd;
 470         }
 471
 472         /* init the char-device for communication with user-mode */
 473         cdev_init(&oud->cdev, &osd_fops);
 474         oud->cdev.owner = THIS_MODULE;
 475
 476         error = dev_set_name(&oud->class_dev, "%s", disk->disk_name);
 477         if (error) {
 478                 OSD_ERR("dev_set_name failed => %d\n", error);
 479                 goto err_free_osd;
 480         }
 481
 482         error = cdev_device_add(&oud->cdev, &oud->class_dev);
 483         if (error) {
 484                 OSD_ERR("device_register failed => %d\n", error);
 485                 goto err_free_osd;
 486         }
 487
 488         OSD_INFO("osd_probe %s\n", disk->disk_name);
 489         return 0;
 490
 491 err_free_osd:
 492         put_device(&oud->class_dev);
 493 err_retract_minor:
 494         ida_free(&osd_minor_ida, minor);
 495         return error;
 496 }
 497
 498 static int osd_remove(struct device *dev)
 499 {
 500         struct scsi_device *scsi_device = to_scsi_device(dev);
 501         struct osd_uld_device *oud = dev_get_drvdata(dev);
 502
 503         if (oud->od.scsi_device != scsi_device) {
 504                 OSD_ERR("Half cooked osd-device %p, || %p!=%p",
 505                         dev, oud->od.scsi_device, scsi_device);
 506         }
 507
 508         cdev_device_del(&oud->cdev, &oud->class_dev);
 509         ida_free(&osd_minor_ida, oud->minor);
 510         put_device(&oud->class_dev);
 511
 512         return 0;
 513 }
 514
 515 /*
 516  * Global driver and scsi registration
 517  */
 518
 519 static struct scsi_driver osd_driver = {
 520         .gendrv = {
 521                 .name           = osd_name,
 522                 .owner          = THIS_MODULE,
 523                 .probe          = osd_probe,
 524                 .remove         = osd_remove,
 525         }
 526 };
 527
 528 static int __init osd_uld_init(void)
 529 {
 530         int err;
 531
 532         err = class_register(&osd_uld_class);
 533         if (err) {
 534                 OSD_ERR("Unable to register sysfs class => %d\n", err);
 535                 return err;
 536         }
 537
 538         err = register_chrdev_region(MKDEV(SCSI_OSD_MAJOR, 0),
 539                                      SCSI_OSD_MAX_MINOR, osd_name);
 540         if (err) {
 541                 OSD_ERR("Unable to register major %d for osd ULD => %d\n",
 542                         SCSI_OSD_MAJOR, err);
 543                 goto err_out;
 544         }
 545
 546         err = scsi_register_driver(&osd_driver.gendrv);
 547         if (err) {
 548                 OSD_ERR("scsi_register_driver failed => %d\n", err);
 549                 goto err_out_chrdev;
 550         }
 551
 552         OSD_INFO("LOADED %s\n", osd_version_string);
 553         return 0;
 554
 555 err_out_chrdev:
 556         unregister_chrdev_region(MKDEV(SCSI_OSD_MAJOR, 0), SCSI_OSD_MAX_MINOR);
 557 err_out:
 558         class_unregister(&osd_uld_class);
 559         return err;
 560 }
 561
 562 static void __exit osd_uld_exit(void)
 563 {
 564         scsi_unregister_driver(&osd_driver.gendrv);
 565         unregister_chrdev_region(MKDEV(SCSI_OSD_MAJOR, 0), SCSI_OSD_MAX_MINOR);
 566         class_unregister(&osd_uld_class);
 567         OSD_INFO("UNLOADED %s\n", osd_version_string);
 568 }
 569
 570 module_init(osd_uld_init);
 571 module_exit(osd_uld_exit);