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