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