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 <bharrosh@panasas.com>
  14  *   Benny Halevy <bhalevy@panasas.com>
  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 <bharrosh@panasas.com>");
  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
 111 static ssize_t systemid_show(struct device *dev, struct device_attribute *attr,
 112                             char *buf)
 113 {
 114         struct osd_uld_device *ould = container_of(dev, struct osd_uld_device,
 115                                                    class_dev);
 116
 117         memcpy(buf, ould->odi.systemid, ould->odi.systemid_len);
 118         return ould->odi.systemid_len;
 119 }
 120
 121 static struct device_attribute osd_uld_attrs[] = {
 122         __ATTR(osdname, S_IRUGO, osdname_show, NULL),
 123         __ATTR(systemid, S_IRUGO, systemid_show, NULL),
 124         __ATTR_NULL,
 125 };
 126
 127 static struct class osd_uld_class = {
 128         .owner          = THIS_MODULE,
 129         .name           = "scsi_osd",
 130         .dev_attrs      = osd_uld_attrs,
 131 };
 132
 133 /*
 134  * Char Device operations
 135  */
 136
 137 static int osd_uld_open(struct inode *inode, struct file *file)
 138 {
 139         struct osd_uld_device *oud = container_of(inode->i_cdev,
 140                                         struct osd_uld_device, cdev);
 141
 142         get_device(&oud->class_dev);
 143         /* cache osd_uld_device on file handle */
 144         file->private_data = oud;
 145         OSD_DEBUG("osd_uld_open %p\n", oud);
 146         return 0;
 147 }
 148
 149 static int osd_uld_release(struct inode *inode, struct file *file)
 150 {
 151         struct osd_uld_device *oud = file->private_data;
 152
 153         OSD_DEBUG("osd_uld_release %p\n", file->private_data);
 154         file->private_data = NULL;
 155         put_device(&oud->class_dev);
 156         return 0;
 157 }
 158
 159 /* FIXME: Only one vector for now */
 160 unsigned g_test_ioctl;
 161 do_test_fn *g_do_test;
 162
 163 int osduld_register_test(unsigned ioctl, do_test_fn *do_test)
 164 {
 165         if (g_test_ioctl)
 166                 return -EINVAL;
 167
 168         g_test_ioctl = ioctl;
 169         g_do_test = do_test;
 170         return 0;
 171 }
 172 EXPORT_SYMBOL(osduld_register_test);
 173
 174 void osduld_unregister_test(unsigned ioctl)
 175 {
 176         if (ioctl == g_test_ioctl) {
 177                 g_test_ioctl = 0;
 178                 g_do_test = NULL;
 179         }
 180 }
 181 EXPORT_SYMBOL(osduld_unregister_test);
 182
 183 static do_test_fn *_find_ioctl(unsigned cmd)
 184 {
 185         if (g_test_ioctl == cmd)
 186                 return g_do_test;
 187         else
 188                 return NULL;
 189 }
 190
 191 static long osd_uld_ioctl(struct file *file, unsigned int cmd,
 192         unsigned long arg)
 193 {
 194         struct osd_uld_device *oud = file->private_data;
 195         int ret;
 196         do_test_fn *do_test;
 197
 198         do_test = _find_ioctl(cmd);
 199         if (do_test)
 200                 ret = do_test(&oud->od, cmd, arg);
 201         else {
 202                 OSD_ERR("Unknown ioctl %d: osd_uld_device=%p\n", cmd, oud);
 203                 ret = -ENOIOCTLCMD;
 204         }
 205         return ret;
 206 }
 207
 208 static const struct file_operations osd_fops = {
 209         .owner          = THIS_MODULE,
 210         .open           = osd_uld_open,
 211         .release        = osd_uld_release,
 212         .unlocked_ioctl = osd_uld_ioctl,
 213         .llseek         = noop_llseek,
 214 };
 215
 216 struct osd_dev *osduld_path_lookup(const char *name)
 217 {
 218         struct osd_uld_device *oud;
 219         struct osd_dev_handle *odh;
 220         struct file *file;
 221         int error;
 222
 223         if (!name || !*name) {
 224                 OSD_ERR("Mount with !path || !*path\n");
 225                 return ERR_PTR(-EINVAL);
 226         }
 227
 228         odh = kzalloc(sizeof(*odh), GFP_KERNEL);
 229         if (unlikely(!odh))
 230                 return ERR_PTR(-ENOMEM);
 231
 232         file = filp_open(name, O_RDWR, 0);
 233         if (IS_ERR(file)) {
 234                 error = PTR_ERR(file);
 235                 goto free_od;
 236         }
 237
 238         if (file->f_op != &osd_fops){
 239                 error = -EINVAL;
 240                 goto close_file;
 241         }
 242
 243         oud = file->private_data;
 244
 245         odh->od = oud->od;
 246         odh->file = file;
 247         odh->oud = oud;
 248
 249         return &odh->od;
 250
 251 close_file:
 252         fput(file);
 253 free_od:
 254         kfree(odh);
 255         return ERR_PTR(error);
 256 }
 257 EXPORT_SYMBOL(osduld_path_lookup);
 258
 259 static inline bool _the_same_or_null(const u8 *a1, unsigned a1_len,
 260                                      const u8 *a2, unsigned a2_len)
 261 {
 262         if (!a2_len) /* User string is Empty means don't care */
 263                 return true;
 264
 265         if (a1_len != a2_len)
 266                 return false;
 267
 268         return 0 == memcmp(a1, a2, a1_len);
 269 }
 270
 271 static int _match_odi(struct device *dev, const void *find_data)
 272 {
 273         struct osd_uld_device *oud = container_of(dev, struct osd_uld_device,
 274                                                   class_dev);
 275         const struct osd_dev_info *odi = find_data;
 276
 277         if (_the_same_or_null(oud->odi.systemid, oud->odi.systemid_len,
 278                               odi->systemid, odi->systemid_len) &&
 279             _the_same_or_null(oud->odi.osdname, oud->odi.osdname_len,
 280                               odi->osdname, odi->osdname_len)) {
 281                 OSD_DEBUG("found device sysid_len=%d osdname=%d\n",
 282                           odi->systemid_len, odi->osdname_len);
 283                 return 1;
 284         } else {
 285                 return 0;
 286         }
 287 }
 288
 289 /* osduld_info_lookup - Loop through all devices, return the requested osd_dev.
 290  *
 291  * if @odi->systemid_len and/or @odi->osdname_len are zero, they act as a don't
 292  * care. .e.g if they're both zero /dev/osd0 is returned.
 293  */
 294 struct osd_dev *osduld_info_lookup(const struct osd_dev_info *odi)
 295 {
 296         struct device *dev = class_find_device(&osd_uld_class, NULL, odi, _match_odi);
 297         if (likely(dev)) {
 298                 struct osd_dev_handle *odh = kzalloc(sizeof(*odh), GFP_KERNEL);
 299                 struct osd_uld_device *oud = container_of(dev,
 300                         struct osd_uld_device, class_dev);
 301
 302                 if (unlikely(!odh)) {
 303                         put_device(dev);
 304                         return ERR_PTR(-ENOMEM);
 305                 }
 306
 307                 odh->od = oud->od;
 308                 odh->oud = oud;
 309
 310                 return &odh->od;
 311         }
 312
 313         return ERR_PTR(-ENODEV);
 314 }
 315 EXPORT_SYMBOL(osduld_info_lookup);
 316
 317 void osduld_put_device(struct osd_dev *od)
 318 {
 319         if (od && !IS_ERR(od)) {
 320                 struct osd_dev_handle *odh =
 321                                 container_of(od, struct osd_dev_handle, od);
 322                 struct osd_uld_device *oud = odh->oud;
 323
 324                 BUG_ON(od->scsi_device != oud->od.scsi_device);
 325
 326                 /* If scsi has released the device (logout), and exofs has last
 327                  * reference on oud it will be freed by above osd_uld_release
 328                  * within fput below. But this will oops in cdev_release which
 329                  * is called after the fops->release. A get_/put_ pair makes
 330                  * sure we have a cdev for the duration of fput
 331                  */
 332                 if (odh->file) {
 333                         get_device(&oud->class_dev);
 334                         fput(odh->file);
 335                 }
 336                 put_device(&oud->class_dev);
 337                 kfree(odh);
 338         }
 339 }
 340 EXPORT_SYMBOL(osduld_put_device);
 341
 342 const struct osd_dev_info *osduld_device_info(struct osd_dev *od)
 343 {
 344         struct osd_dev_handle *odh =
 345                                 container_of(od, struct osd_dev_handle, od);
 346         return &odh->oud->odi;
 347 }
 348 EXPORT_SYMBOL(osduld_device_info);
 349
 350 bool osduld_device_same(struct osd_dev *od, const struct osd_dev_info *odi)
 351 {
 352         struct osd_dev_handle *odh =
 353                                 container_of(od, struct osd_dev_handle, od);
 354         struct osd_uld_device *oud = odh->oud;
 355
 356         return (oud->odi.systemid_len == odi->systemid_len) &&
 357                 _the_same_or_null(oud->odi.systemid, oud->odi.systemid_len,
 358                                  odi->systemid, odi->systemid_len) &&
 359                 (oud->odi.osdname_len == odi->osdname_len) &&
 360                 _the_same_or_null(oud->odi.osdname, oud->odi.osdname_len,
 361                                   odi->osdname, odi->osdname_len);
 362 }
 363 EXPORT_SYMBOL(osduld_device_same);
 364
 365 /*
 366  * Scsi Device operations
 367  */
 368
 369 static int __detect_osd(struct osd_uld_device *oud)
 370 {
 371         struct scsi_device *scsi_device = oud->od.scsi_device;
 372         char caps[OSD_CAP_LEN];
 373         int error;
 374
 375         /* sending a test_unit_ready as first command seems to be needed
 376          * by some targets
 377          */
 378         OSD_DEBUG("start scsi_test_unit_ready %p %p %p\n",
 379                         oud, scsi_device, scsi_device->request_queue);
 380         error = scsi_test_unit_ready(scsi_device, 10*HZ, 5, NULL);
 381         if (error)
 382                 OSD_ERR("warning: scsi_test_unit_ready failed\n");
 383
 384         osd_sec_init_nosec_doall_caps(caps, &osd_root_object, false, true);
 385         if (osd_auto_detect_ver(&oud->od, caps, &oud->odi))
 386                 return -ENODEV;
 387
 388         return 0;
 389 }
 390
 391 static void __remove(struct device *dev)
 392 {
 393         struct osd_uld_device *oud = container_of(dev, struct osd_uld_device,
 394                                                   class_dev);
 395         struct scsi_device *scsi_device = oud->od.scsi_device;
 396
 397         kfree(oud->odi.osdname);
 398
 399         if (oud->cdev.owner)
 400                 cdev_del(&oud->cdev);
 401
 402         osd_dev_fini(&oud->od);
 403         scsi_device_put(scsi_device);
 404
 405         OSD_INFO("osd_remove %s\n",
 406                  oud->disk ? oud->disk->disk_name : NULL);
 407
 408         if (oud->disk)
 409                 put_disk(oud->disk);
 410         ida_remove(&osd_minor_ida, oud->minor);
 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         do {
 427                 if (!ida_pre_get(&osd_minor_ida, GFP_KERNEL))
 428                         return -ENODEV;
 429
 430                 error = ida_get_new(&osd_minor_ida, &minor);
 431         } while (error == -EAGAIN);
 432
 433         if (error)
 434                 return error;
 435         if (minor >= SCSI_OSD_MAX_MINOR) {
 436                 error = -EBUSY;
 437                 goto err_retract_minor;
 438         }
 439
 440         error = -ENOMEM;
 441         oud = kzalloc(sizeof(*oud), GFP_KERNEL);
 442         if (NULL == oud)
 443                 goto err_retract_minor;
 444
 445         dev_set_drvdata(dev, oud);
 446         oud->minor = minor;
 447
 448         /* allocate a disk and set it up */
 449         /* FIXME: do we need this since sg has already done that */
 450         disk = alloc_disk(1);
 451         if (!disk) {
 452                 OSD_ERR("alloc_disk failed\n");
 453                 goto err_free_osd;
 454         }
 455         disk->major = SCSI_OSD_MAJOR;
 456         disk->first_minor = oud->minor;
 457         sprintf(disk->disk_name, "osd%d", oud->minor);
 458         oud->disk = disk;
 459
 460         /* hold one more reference to the scsi_device that will get released
 461          * in __release, in case a logout is happening while fs is mounted
 462          */
 463         scsi_device_get(scsi_device);
 464         osd_dev_init(&oud->od, scsi_device);
 465
 466         /* Detect the OSD Version */
 467         error = __detect_osd(oud);
 468         if (error) {
 469                 OSD_ERR("osd detection failed, non-compatible OSD device\n");
 470                 goto err_put_disk;
 471         }
 472
 473         /* init the char-device for communication with user-mode */
 474         cdev_init(&oud->cdev, &osd_fops);
 475         oud->cdev.owner = THIS_MODULE;
 476         error = cdev_add(&oud->cdev,
 477                          MKDEV(SCSI_OSD_MAJOR, oud->minor), 1);
 478         if (error) {
 479                 OSD_ERR("cdev_add failed\n");
 480                 goto err_put_disk;
 481         }
 482
 483         /* class device member */
 484         oud->class_dev.devt = oud->cdev.dev;
 485         oud->class_dev.class = &osd_uld_class;
 486         oud->class_dev.parent = dev;
 487         oud->class_dev.release = __remove;
 488         error = dev_set_name(&oud->class_dev, "%s", disk->disk_name);
 489         if (error) {
 490                 OSD_ERR("dev_set_name failed => %d\n", error);
 491                 goto err_put_cdev;
 492         }
 493
 494         error = device_register(&oud->class_dev);
 495         if (error) {
 496                 OSD_ERR("device_register failed => %d\n", error);
 497                 goto err_put_cdev;
 498         }
 499
 500         get_device(&oud->class_dev);
 501
 502         OSD_INFO("osd_probe %s\n", disk->disk_name);
 503         return 0;
 504
 505 err_put_cdev:
 506         cdev_del(&oud->cdev);
 507 err_put_disk:
 508         scsi_device_put(scsi_device);
 509         put_disk(disk);
 510 err_free_osd:
 511         dev_set_drvdata(dev, NULL);
 512         kfree(oud);
 513 err_retract_minor:
 514         ida_remove(&osd_minor_ida, minor);
 515         return error;
 516 }
 517
 518 static int osd_remove(struct device *dev)
 519 {
 520         struct scsi_device *scsi_device = to_scsi_device(dev);
 521         struct osd_uld_device *oud = dev_get_drvdata(dev);
 522
 523         if (!oud || (oud->od.scsi_device != scsi_device)) {
 524                 OSD_ERR("Half cooked osd-device %p,%p || %p!=%p",
 525                         dev, oud, oud ? oud->od.scsi_device : NULL,
 526                         scsi_device);
 527         }
 528
 529         device_unregister(&oud->class_dev);
 530
 531         put_device(&oud->class_dev);
 532         return 0;
 533 }
 534
 535 /*
 536  * Global driver and scsi registration
 537  */
 538
 539 static struct scsi_driver osd_driver = {
 540         .owner                  = THIS_MODULE,
 541         .gendrv = {
 542                 .name           = osd_name,
 543                 .probe          = osd_probe,
 544                 .remove         = osd_remove,
 545         }
 546 };
 547
 548 static int __init osd_uld_init(void)
 549 {
 550         int err;
 551
 552         err = class_register(&osd_uld_class);
 553         if (err) {
 554                 OSD_ERR("Unable to register sysfs class => %d\n", err);
 555                 return err;
 556         }
 557
 558         err = register_chrdev_region(MKDEV(SCSI_OSD_MAJOR, 0),
 559                                      SCSI_OSD_MAX_MINOR, osd_name);
 560         if (err) {
 561                 OSD_ERR("Unable to register major %d for osd ULD => %d\n",
 562                         SCSI_OSD_MAJOR, err);
 563                 goto err_out;
 564         }
 565
 566         err = scsi_register_driver(&osd_driver.gendrv);
 567         if (err) {
 568                 OSD_ERR("scsi_register_driver failed => %d\n", err);
 569                 goto err_out_chrdev;
 570         }
 571
 572         OSD_INFO("LOADED %s\n", osd_version_string);
 573         return 0;
 574
 575 err_out_chrdev:
 576         unregister_chrdev_region(MKDEV(SCSI_OSD_MAJOR, 0), SCSI_OSD_MAX_MINOR);
 577 err_out:
 578         class_unregister(&osd_uld_class);
 579         return err;
 580 }
 581
 582 static void __exit osd_uld_exit(void)
 583 {
 584         scsi_unregister_driver(&osd_driver.gendrv);
 585         unregister_chrdev_region(MKDEV(SCSI_OSD_MAJOR, 0), SCSI_OSD_MAX_MINOR);
 586         class_unregister(&osd_uld_class);
 587         OSD_INFO("UNLOADED %s\n", osd_version_string);
 588 }
 589
 590 module_init(osd_uld_init);
 591 module_exit(osd_uld_exit);