1/* 2 * Enclosure Services 3 * 4 * Copyright (C) 2008 James Bottomley <James.Bottomley@HansenPartnership.com> 5 * 6**----------------------------------------------------------------------------- 7** 8** This program is free software; you can redistribute it and/or 9** modify it under the terms of the GNU General Public License 10** version 2 as published by the Free Software Foundation. 11** 12** This program is distributed in the hope that it will be useful, 13** but WITHOUT ANY WARRANTY; without even the implied warranty of 14** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15** GNU General Public License for more details. 16** 17** You should have received a copy of the GNU General Public License 18** along with this program; if not, write to the Free Software 19** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20** 21**----------------------------------------------------------------------------- 22*/ 23#include <linux/device.h> 24#include <linux/enclosure.h> 25#include <linux/err.h> 26#include <linux/list.h> 27#include <linux/kernel.h> 28#include <linux/module.h> 29#include <linux/mutex.h> 30#include <linux/slab.h> 31 32static LIST_HEAD(container_list); 33static DEFINE_MUTEX(container_list_lock); 34static struct class enclosure_class; 35 36/** 37 * enclosure_find - find an enclosure given a parent device 38 * @dev: the parent to match against 39 * @start: Optional enclosure device to start from (NULL if none) 40 * 41 * Looks through the list of registered enclosures to find all those 42 * with @dev as a parent. Returns NULL if no enclosure is 43 * found. @start can be used as a starting point to obtain multiple 44 * enclosures per parent (should begin with NULL and then be set to 45 * each returned enclosure device). Obtains a reference to the 46 * enclosure class device which must be released with device_put(). 47 * If @start is not NULL, a reference must be taken on it which is 48 * released before returning (this allows a loop through all 49 * enclosures to exit with only the reference on the enclosure of 50 * interest held). Note that the @dev may correspond to the actual 51 * device housing the enclosure, in which case no iteration via @start 52 * is required. 53 */ 54struct enclosure_device *enclosure_find(struct device *dev, 55 struct enclosure_device *start) 56{ 57 struct enclosure_device *edev; 58 59 mutex_lock(&container_list_lock); 60 edev = list_prepare_entry(start, &container_list, node); 61 if (start) 62 put_device(&start->edev); 63 64 list_for_each_entry_continue(edev, &container_list, node) { 65 struct device *parent = edev->edev.parent; 66 /* parent might not be immediate, so iterate up to 67 * the root of the tree if necessary */ 68 while (parent) { 69 if (parent == dev) { 70 get_device(&edev->edev); 71 mutex_unlock(&container_list_lock); 72 return edev; 73 } 74 parent = parent->parent; 75 } 76 } 77 mutex_unlock(&container_list_lock); 78 79 return NULL; 80} 81EXPORT_SYMBOL_GPL(enclosure_find); 82 83/** 84 * enclosure_for_each_device - calls a function for each enclosure 85 * @fn: the function to call 86 * @data: the data to pass to each call 87 * 88 * Loops over all the enclosures calling the function. 89 * 90 * Note, this function uses a mutex which will be held across calls to 91 * @fn, so it must have non atomic context, and @fn may (although it 92 * should not) sleep or otherwise cause the mutex to be held for 93 * indefinite periods 94 */ 95int enclosure_for_each_device(int (*fn)(struct enclosure_device *, void *), 96 void *data) 97{ 98 int error = 0; 99 struct enclosure_device *edev; 100 101 mutex_lock(&container_list_lock); 102 list_for_each_entry(edev, &container_list, node) { 103 error = fn(edev, data); 104 if (error) 105 break; 106 } 107 mutex_unlock(&container_list_lock); 108 109 return error; 110} 111EXPORT_SYMBOL_GPL(enclosure_for_each_device); 112 113/** 114 * enclosure_register - register device as an enclosure 115 * 116 * @dev: device containing the enclosure 117 * @components: number of components in the enclosure 118 * 119 * This sets up the device for being an enclosure. Note that @dev does 120 * not have to be a dedicated enclosure device. It may be some other type 121 * of device that additionally responds to enclosure services 122 */ 123struct enclosure_device * 124enclosure_register(struct device *dev, const char *name, int components, 125 struct enclosure_component_callbacks *cb) 126{ 127 struct enclosure_device *edev = 128 kzalloc(sizeof(struct enclosure_device) + 129 sizeof(struct enclosure_component)*components, 130 GFP_KERNEL); 131 int err, i; 132 133 BUG_ON(!cb); 134 135 if (!edev) 136 return ERR_PTR(-ENOMEM); 137 138 edev->components = components; 139 140 edev->edev.class = &enclosure_class; 141 edev->edev.parent = get_device(dev); 142 edev->cb = cb; 143 dev_set_name(&edev->edev, "%s", name); 144 err = device_register(&edev->edev); 145 if (err) 146 goto err; 147 148 for (i = 0; i < components; i++) 149 edev->component[i].number = -1; 150 151 mutex_lock(&container_list_lock); 152 list_add_tail(&edev->node, &container_list); 153 mutex_unlock(&container_list_lock); 154 155 return edev; 156 157 err: 158 put_device(edev->edev.parent); 159 kfree(edev); 160 return ERR_PTR(err); 161} 162EXPORT_SYMBOL_GPL(enclosure_register); 163 164static struct enclosure_component_callbacks enclosure_null_callbacks; 165 166/** 167 * enclosure_unregister - remove an enclosure 168 * 169 * @edev: the registered enclosure to remove; 170 */ 171void enclosure_unregister(struct enclosure_device *edev) 172{ 173 int i; 174 175 mutex_lock(&container_list_lock); 176 list_del(&edev->node); 177 mutex_unlock(&container_list_lock); 178 179 for (i = 0; i < edev->components; i++) 180 if (edev->component[i].number != -1) 181 device_unregister(&edev->component[i].cdev); 182 183 /* prevent any callbacks into service user */ 184 edev->cb = &enclosure_null_callbacks; 185 device_unregister(&edev->edev); 186} 187EXPORT_SYMBOL_GPL(enclosure_unregister); 188 189#define ENCLOSURE_NAME_SIZE 64 190 191static void enclosure_link_name(struct enclosure_component *cdev, char *name) 192{ 193 strcpy(name, "enclosure_device:"); 194 strcat(name, dev_name(&cdev->cdev)); 195} 196 197static void enclosure_remove_links(struct enclosure_component *cdev) 198{ 199 char name[ENCLOSURE_NAME_SIZE]; 200 201 /* 202 * In odd circumstances, like multipath devices, something else may 203 * already have removed the links, so check for this condition first. 204 */ 205 if (!cdev->dev->kobj.sd) 206 return; 207 208 enclosure_link_name(cdev, name); 209 sysfs_remove_link(&cdev->dev->kobj, name); 210 sysfs_remove_link(&cdev->cdev.kobj, "device"); 211} 212 213static int enclosure_add_links(struct enclosure_component *cdev) 214{ 215 int error; 216 char name[ENCLOSURE_NAME_SIZE]; 217 218 error = sysfs_create_link(&cdev->cdev.kobj, &cdev->dev->kobj, "device"); 219 if (error) 220 return error; 221 222 enclosure_link_name(cdev, name); 223 error = sysfs_create_link(&cdev->dev->kobj, &cdev->cdev.kobj, name); 224 if (error) 225 sysfs_remove_link(&cdev->cdev.kobj, "device"); 226 227 return error; 228} 229 230static void enclosure_release(struct device *cdev) 231{ 232 struct enclosure_device *edev = to_enclosure_device(cdev); 233 234 put_device(cdev->parent); 235 kfree(edev); 236} 237 238static void enclosure_component_release(struct device *dev) 239{ 240 struct enclosure_component *cdev = to_enclosure_component(dev); 241 242 if (cdev->dev) { 243 enclosure_remove_links(cdev); 244 put_device(cdev->dev); 245 } 246 put_device(dev->parent); 247} 248 249static const struct attribute_group *enclosure_component_groups[]; 250 251/** 252 * enclosure_component_register - add a particular component to an enclosure 253 * @edev: the enclosure to add the component 254 * @num: the device number 255 * @type: the type of component being added 256 * @name: an optional name to appear in sysfs (leave NULL if none) 257 * 258 * Registers the component. The name is optional for enclosures that 259 * give their components a unique name. If not, leave the field NULL 260 * and a name will be assigned. 261 * 262 * Returns a pointer to the enclosure component or an error. 263 */ 264struct enclosure_component * 265enclosure_component_register(struct enclosure_device *edev, 266 unsigned int number, 267 enum enclosure_component_type type, 268 const char *name) 269{ 270 struct enclosure_component *ecomp; 271 struct device *cdev; 272 int err; 273 274 if (number >= edev->components) 275 return ERR_PTR(-EINVAL); 276 277 ecomp = &edev->component[number]; 278 279 if (ecomp->number != -1) 280 return ERR_PTR(-EINVAL); 281 282 ecomp->type = type; 283 ecomp->number = number; 284 cdev = &ecomp->cdev; 285 cdev->parent = get_device(&edev->edev); 286 if (name && name[0]) 287 dev_set_name(cdev, "%s", name); 288 else 289 dev_set_name(cdev, "%u", number); 290 291 cdev->release = enclosure_component_release; 292 cdev->groups = enclosure_component_groups; 293 294 err = device_register(cdev); 295 if (err) { 296 ecomp->number = -1; 297 put_device(cdev); 298 return ERR_PTR(err); 299 } 300 301 return ecomp; 302} 303EXPORT_SYMBOL_GPL(enclosure_component_register); 304 305/** 306 * enclosure_add_device - add a device as being part of an enclosure 307 * @edev: the enclosure device being added to. 308 * @num: the number of the component 309 * @dev: the device being added 310 * 311 * Declares a real device to reside in slot (or identifier) @num of an 312 * enclosure. This will cause the relevant sysfs links to appear. 313 * This function may also be used to change a device associated with 314 * an enclosure without having to call enclosure_remove_device() in 315 * between. 316 * 317 * Returns zero on success or an error. 318 */ 319int enclosure_add_device(struct enclosure_device *edev, int component, 320 struct device *dev) 321{ 322 struct enclosure_component *cdev; 323 324 if (!edev || component >= edev->components) 325 return -EINVAL; 326 327 cdev = &edev->component[component]; 328 329 if (cdev->dev == dev) 330 return -EEXIST; 331 332 if (cdev->dev) 333 enclosure_remove_links(cdev); 334 335 put_device(cdev->dev); 336 cdev->dev = get_device(dev); 337 return enclosure_add_links(cdev); 338} 339EXPORT_SYMBOL_GPL(enclosure_add_device); 340 341/** 342 * enclosure_remove_device - remove a device from an enclosure 343 * @edev: the enclosure device 344 * @num: the number of the component to remove 345 * 346 * Returns zero on success or an error. 347 * 348 */ 349int enclosure_remove_device(struct enclosure_device *edev, struct device *dev) 350{ 351 struct enclosure_component *cdev; 352 int i; 353 354 if (!edev || !dev) 355 return -EINVAL; 356 357 for (i = 0; i < edev->components; i++) { 358 cdev = &edev->component[i]; 359 if (cdev->dev == dev) { 360 enclosure_remove_links(cdev); 361 device_del(&cdev->cdev); 362 put_device(dev); 363 cdev->dev = NULL; 364 return device_add(&cdev->cdev); 365 } 366 } 367 return -ENODEV; 368} 369EXPORT_SYMBOL_GPL(enclosure_remove_device); 370 371/* 372 * sysfs pieces below 373 */ 374 375static ssize_t components_show(struct device *cdev, 376 struct device_attribute *attr, char *buf) 377{ 378 struct enclosure_device *edev = to_enclosure_device(cdev); 379 380 return snprintf(buf, 40, "%d\n", edev->components); 381} 382static DEVICE_ATTR_RO(components); 383 384static struct attribute *enclosure_class_attrs[] = { 385 &dev_attr_components.attr, 386 NULL, 387}; 388ATTRIBUTE_GROUPS(enclosure_class); 389 390static struct class enclosure_class = { 391 .name = "enclosure", 392 .owner = THIS_MODULE, 393 .dev_release = enclosure_release, 394 .dev_groups = enclosure_class_groups, 395}; 396 397static const char *const enclosure_status [] = { 398 [ENCLOSURE_STATUS_UNSUPPORTED] = "unsupported", 399 [ENCLOSURE_STATUS_OK] = "OK", 400 [ENCLOSURE_STATUS_CRITICAL] = "critical", 401 [ENCLOSURE_STATUS_NON_CRITICAL] = "non-critical", 402 [ENCLOSURE_STATUS_UNRECOVERABLE] = "unrecoverable", 403 [ENCLOSURE_STATUS_NOT_INSTALLED] = "not installed", 404 [ENCLOSURE_STATUS_UNKNOWN] = "unknown", 405 [ENCLOSURE_STATUS_UNAVAILABLE] = "unavailable", 406 [ENCLOSURE_STATUS_MAX] = NULL, 407}; 408 409static const char *const enclosure_type [] = { 410 [ENCLOSURE_COMPONENT_DEVICE] = "device", 411 [ENCLOSURE_COMPONENT_ARRAY_DEVICE] = "array device", 412}; 413 414static ssize_t get_component_fault(struct device *cdev, 415 struct device_attribute *attr, char *buf) 416{ 417 struct enclosure_device *edev = to_enclosure_device(cdev->parent); 418 struct enclosure_component *ecomp = to_enclosure_component(cdev); 419 420 if (edev->cb->get_fault) 421 edev->cb->get_fault(edev, ecomp); 422 return snprintf(buf, 40, "%d\n", ecomp->fault); 423} 424 425static ssize_t set_component_fault(struct device *cdev, 426 struct device_attribute *attr, 427 const char *buf, size_t count) 428{ 429 struct enclosure_device *edev = to_enclosure_device(cdev->parent); 430 struct enclosure_component *ecomp = to_enclosure_component(cdev); 431 int val = simple_strtoul(buf, NULL, 0); 432 433 if (edev->cb->set_fault) 434 edev->cb->set_fault(edev, ecomp, val); 435 return count; 436} 437 438static ssize_t get_component_status(struct device *cdev, 439 struct device_attribute *attr,char *buf) 440{ 441 struct enclosure_device *edev = to_enclosure_device(cdev->parent); 442 struct enclosure_component *ecomp = to_enclosure_component(cdev); 443 444 if (edev->cb->get_status) 445 edev->cb->get_status(edev, ecomp); 446 return snprintf(buf, 40, "%s\n", enclosure_status[ecomp->status]); 447} 448 449static ssize_t set_component_status(struct device *cdev, 450 struct device_attribute *attr, 451 const char *buf, size_t count) 452{ 453 struct enclosure_device *edev = to_enclosure_device(cdev->parent); 454 struct enclosure_component *ecomp = to_enclosure_component(cdev); 455 int i; 456 457 for (i = 0; enclosure_status[i]; i++) { 458 if (strncmp(buf, enclosure_status[i], 459 strlen(enclosure_status[i])) == 0 && 460 (buf[strlen(enclosure_status[i])] == '\n' || 461 buf[strlen(enclosure_status[i])] == '\0')) 462 break; 463 } 464 465 if (enclosure_status[i] && edev->cb->set_status) { 466 edev->cb->set_status(edev, ecomp, i); 467 return count; 468 } else 469 return -EINVAL; 470} 471 472static ssize_t get_component_active(struct device *cdev, 473 struct device_attribute *attr, char *buf) 474{ 475 struct enclosure_device *edev = to_enclosure_device(cdev->parent); 476 struct enclosure_component *ecomp = to_enclosure_component(cdev); 477 478 if (edev->cb->get_active) 479 edev->cb->get_active(edev, ecomp); 480 return snprintf(buf, 40, "%d\n", ecomp->active); 481} 482 483static ssize_t set_component_active(struct device *cdev, 484 struct device_attribute *attr, 485 const char *buf, size_t count) 486{ 487 struct enclosure_device *edev = to_enclosure_device(cdev->parent); 488 struct enclosure_component *ecomp = to_enclosure_component(cdev); 489 int val = simple_strtoul(buf, NULL, 0); 490 491 if (edev->cb->set_active) 492 edev->cb->set_active(edev, ecomp, val); 493 return count; 494} 495 496static ssize_t get_component_locate(struct device *cdev, 497 struct device_attribute *attr, char *buf) 498{ 499 struct enclosure_device *edev = to_enclosure_device(cdev->parent); 500 struct enclosure_component *ecomp = to_enclosure_component(cdev); 501 502 if (edev->cb->get_locate) 503 edev->cb->get_locate(edev, ecomp); 504 return snprintf(buf, 40, "%d\n", ecomp->locate); 505} 506 507static ssize_t set_component_locate(struct device *cdev, 508 struct device_attribute *attr, 509 const char *buf, size_t count) 510{ 511 struct enclosure_device *edev = to_enclosure_device(cdev->parent); 512 struct enclosure_component *ecomp = to_enclosure_component(cdev); 513 int val = simple_strtoul(buf, NULL, 0); 514 515 if (edev->cb->set_locate) 516 edev->cb->set_locate(edev, ecomp, val); 517 return count; 518} 519 520static ssize_t get_component_type(struct device *cdev, 521 struct device_attribute *attr, char *buf) 522{ 523 struct enclosure_component *ecomp = to_enclosure_component(cdev); 524 525 return snprintf(buf, 40, "%s\n", enclosure_type[ecomp->type]); 526} 527 528 529static DEVICE_ATTR(fault, S_IRUGO | S_IWUSR, get_component_fault, 530 set_component_fault); 531static DEVICE_ATTR(status, S_IRUGO | S_IWUSR, get_component_status, 532 set_component_status); 533static DEVICE_ATTR(active, S_IRUGO | S_IWUSR, get_component_active, 534 set_component_active); 535static DEVICE_ATTR(locate, S_IRUGO | S_IWUSR, get_component_locate, 536 set_component_locate); 537static DEVICE_ATTR(type, S_IRUGO, get_component_type, NULL); 538 539static struct attribute *enclosure_component_attrs[] = { 540 &dev_attr_fault.attr, 541 &dev_attr_status.attr, 542 &dev_attr_active.attr, 543 &dev_attr_locate.attr, 544 &dev_attr_type.attr, 545 NULL 546}; 547ATTRIBUTE_GROUPS(enclosure_component); 548 549static int __init enclosure_init(void) 550{ 551 int err; 552 553 err = class_register(&enclosure_class); 554 if (err) 555 return err; 556 557 return 0; 558} 559 560static void __exit enclosure_exit(void) 561{ 562 class_unregister(&enclosure_class); 563} 564 565module_init(enclosure_init); 566module_exit(enclosure_exit); 567 568MODULE_AUTHOR("James Bottomley"); 569MODULE_DESCRIPTION("Enclosure Services"); 570MODULE_LICENSE("GPL v2"); 571