1 /* 2 * kobject.c - library routines for handling generic kernel objects 3 * 4 * Copyright (c) 2002-2003 Patrick Mochel <mochel@osdl.org> 5 * 6 * This file is released under the GPLv2. 7 * 8 * 9 * Please see the file Documentation/kobject.txt for critical information 10 * about using the kobject interface. 11 */ 12 13 #include <linux/kobject.h> 14 #include <linux/string.h> 15 #include <linux/module.h> 16 #include <linux/stat.h> 17 #include <linux/slab.h> 18 19 /** 20 * populate_dir - populate directory with attributes. 21 * @kobj: object we're working on. 22 * 23 * Most subsystems have a set of default attributes that 24 * are associated with an object that registers with them. 25 * This is a helper called during object registration that 26 * loops through the default attributes of the subsystem 27 * and creates attributes files for them in sysfs. 28 * 29 */ 30 31 static int populate_dir(struct kobject * kobj) 32 { 33 struct kobj_type * t = get_ktype(kobj); 34 struct attribute * attr; 35 int error = 0; 36 int i; 37 38 if (t && t->default_attrs) { 39 for (i = 0; (attr = t->default_attrs[i]) != NULL; i++) { 40 if ((error = sysfs_create_file(kobj,attr))) 41 break; 42 } 43 } 44 return error; 45 } 46 47 static int create_dir(struct kobject * kobj) 48 { 49 int error = 0; 50 if (kobject_name(kobj)) { 51 error = sysfs_create_dir(kobj); 52 if (!error) { 53 if ((error = populate_dir(kobj))) 54 sysfs_remove_dir(kobj); 55 } 56 } 57 return error; 58 } 59 60 static inline struct kobject * to_kobj(struct list_head * entry) 61 { 62 return container_of(entry,struct kobject,entry); 63 } 64 65 static int get_kobj_path_length(struct kobject *kobj) 66 { 67 int length = 1; 68 struct kobject * parent = kobj; 69 70 /* walk up the ancestors until we hit the one pointing to the 71 * root. 72 * Add 1 to strlen for leading '/' of each level. 73 */ 74 do { 75 length += strlen(kobject_name(parent)) + 1; 76 parent = parent->parent; 77 } while (parent); 78 return length; 79 } 80 81 static void fill_kobj_path(struct kobject *kobj, char *path, int length) 82 { 83 struct kobject * parent; 84 85 --length; 86 for (parent = kobj; parent; parent = parent->parent) { 87 int cur = strlen(kobject_name(parent)); 88 /* back up enough to print this name with '/' */ 89 length -= cur; 90 strncpy (path + length, kobject_name(parent), cur); 91 *(path + --length) = '/'; 92 } 93 94 pr_debug("%s: path = '%s'\n",__FUNCTION__,path); 95 } 96 97 /** 98 * kobject_get_path - generate and return the path associated with a given kobj 99 * and kset pair. The result must be freed by the caller with kfree(). 100 * 101 * @kobj: kobject in question, with which to build the path 102 * @gfp_mask: the allocation type used to allocate the path 103 */ 104 char *kobject_get_path(struct kobject *kobj, gfp_t gfp_mask) 105 { 106 char *path; 107 int len; 108 109 len = get_kobj_path_length(kobj); 110 path = kmalloc(len, gfp_mask); 111 if (!path) 112 return NULL; 113 memset(path, 0x00, len); 114 fill_kobj_path(kobj, path, len); 115 116 return path; 117 } 118 119 /** 120 * kobject_init - initialize object. 121 * @kobj: object in question. 122 */ 123 void kobject_init(struct kobject * kobj) 124 { 125 kref_init(&kobj->kref); 126 INIT_LIST_HEAD(&kobj->entry); 127 kobj->kset = kset_get(kobj->kset); 128 } 129 130 131 /** 132 * unlink - remove kobject from kset list. 133 * @kobj: kobject. 134 * 135 * Remove the kobject from the kset list and decrement 136 * its parent's refcount. 137 * This is separated out, so we can use it in both 138 * kobject_del() and kobject_add() on error. 139 */ 140 141 static void unlink(struct kobject * kobj) 142 { 143 if (kobj->kset) { 144 spin_lock(&kobj->kset->list_lock); 145 list_del_init(&kobj->entry); 146 spin_unlock(&kobj->kset->list_lock); 147 } 148 kobject_put(kobj); 149 } 150 151 /** 152 * kobject_add - add an object to the hierarchy. 153 * @kobj: object. 154 */ 155 156 int kobject_add(struct kobject * kobj) 157 { 158 int error = 0; 159 struct kobject * parent; 160 161 if (!(kobj = kobject_get(kobj))) 162 return -ENOENT; 163 if (!kobj->k_name) 164 kobj->k_name = kobj->name; 165 parent = kobject_get(kobj->parent); 166 167 pr_debug("kobject %s: registering. parent: %s, set: %s\n", 168 kobject_name(kobj), parent ? kobject_name(parent) : "<NULL>", 169 kobj->kset ? kobj->kset->kobj.name : "<NULL>" ); 170 171 if (kobj->kset) { 172 spin_lock(&kobj->kset->list_lock); 173 174 if (!parent) 175 parent = kobject_get(&kobj->kset->kobj); 176 177 list_add_tail(&kobj->entry,&kobj->kset->list); 178 spin_unlock(&kobj->kset->list_lock); 179 } 180 kobj->parent = parent; 181 182 error = create_dir(kobj); 183 if (error) { 184 /* unlink does the kobject_put() for us */ 185 unlink(kobj); 186 if (parent) 187 kobject_put(parent); 188 } 189 190 return error; 191 } 192 193 194 /** 195 * kobject_register - initialize and add an object. 196 * @kobj: object in question. 197 */ 198 199 int kobject_register(struct kobject * kobj) 200 { 201 int error = 0; 202 if (kobj) { 203 kobject_init(kobj); 204 error = kobject_add(kobj); 205 if (error) { 206 printk("kobject_register failed for %s (%d)\n", 207 kobject_name(kobj),error); 208 dump_stack(); 209 } else 210 kobject_hotplug(kobj, KOBJ_ADD); 211 } else 212 error = -EINVAL; 213 return error; 214 } 215 216 217 /** 218 * kobject_set_name - Set the name of an object 219 * @kobj: object. 220 * @fmt: format string used to build the name 221 * 222 * If strlen(name) >= KOBJ_NAME_LEN, then use a dynamically allocated 223 * string that @kobj->k_name points to. Otherwise, use the static 224 * @kobj->name array. 225 */ 226 int kobject_set_name(struct kobject * kobj, const char * fmt, ...) 227 { 228 int error = 0; 229 int limit = KOBJ_NAME_LEN; 230 int need; 231 va_list args; 232 char * name; 233 234 /* 235 * First, try the static array 236 */ 237 va_start(args,fmt); 238 need = vsnprintf(kobj->name,limit,fmt,args); 239 va_end(args); 240 if (need < limit) 241 name = kobj->name; 242 else { 243 /* 244 * Need more space? Allocate it and try again 245 */ 246 limit = need + 1; 247 name = kmalloc(limit,GFP_KERNEL); 248 if (!name) { 249 error = -ENOMEM; 250 goto Done; 251 } 252 va_start(args,fmt); 253 need = vsnprintf(name,limit,fmt,args); 254 va_end(args); 255 256 /* Still? Give up. */ 257 if (need >= limit) { 258 kfree(name); 259 error = -EFAULT; 260 goto Done; 261 } 262 } 263 264 /* Free the old name, if necessary. */ 265 if (kobj->k_name && kobj->k_name != kobj->name) 266 kfree(kobj->k_name); 267 268 /* Now, set the new name */ 269 kobj->k_name = name; 270 Done: 271 return error; 272 } 273 274 EXPORT_SYMBOL(kobject_set_name); 275 276 277 /** 278 * kobject_rename - change the name of an object 279 * @kobj: object in question. 280 * @new_name: object's new name 281 */ 282 283 int kobject_rename(struct kobject * kobj, const char *new_name) 284 { 285 int error = 0; 286 287 kobj = kobject_get(kobj); 288 if (!kobj) 289 return -EINVAL; 290 error = sysfs_rename_dir(kobj, new_name); 291 kobject_put(kobj); 292 293 return error; 294 } 295 296 /** 297 * kobject_del - unlink kobject from hierarchy. 298 * @kobj: object. 299 */ 300 301 void kobject_del(struct kobject * kobj) 302 { 303 sysfs_remove_dir(kobj); 304 unlink(kobj); 305 } 306 307 /** 308 * kobject_unregister - remove object from hierarchy and decrement refcount. 309 * @kobj: object going away. 310 */ 311 312 void kobject_unregister(struct kobject * kobj) 313 { 314 pr_debug("kobject %s: unregistering\n",kobject_name(kobj)); 315 kobject_hotplug(kobj, KOBJ_REMOVE); 316 kobject_del(kobj); 317 kobject_put(kobj); 318 } 319 320 /** 321 * kobject_get - increment refcount for object. 322 * @kobj: object. 323 */ 324 325 struct kobject * kobject_get(struct kobject * kobj) 326 { 327 if (kobj) 328 kref_get(&kobj->kref); 329 return kobj; 330 } 331 332 /** 333 * kobject_cleanup - free kobject resources. 334 * @kobj: object. 335 */ 336 337 void kobject_cleanup(struct kobject * kobj) 338 { 339 struct kobj_type * t = get_ktype(kobj); 340 struct kset * s = kobj->kset; 341 struct kobject * parent = kobj->parent; 342 343 pr_debug("kobject %s: cleaning up\n",kobject_name(kobj)); 344 if (kobj->k_name != kobj->name) 345 kfree(kobj->k_name); 346 kobj->k_name = NULL; 347 if (t && t->release) 348 t->release(kobj); 349 if (s) 350 kset_put(s); 351 if (parent) 352 kobject_put(parent); 353 } 354 355 static void kobject_release(struct kref *kref) 356 { 357 kobject_cleanup(container_of(kref, struct kobject, kref)); 358 } 359 360 /** 361 * kobject_put - decrement refcount for object. 362 * @kobj: object. 363 * 364 * Decrement the refcount, and if 0, call kobject_cleanup(). 365 */ 366 void kobject_put(struct kobject * kobj) 367 { 368 if (kobj) 369 kref_put(&kobj->kref, kobject_release); 370 } 371 372 373 /** 374 * kset_init - initialize a kset for use 375 * @k: kset 376 */ 377 378 void kset_init(struct kset * k) 379 { 380 kobject_init(&k->kobj); 381 INIT_LIST_HEAD(&k->list); 382 spin_lock_init(&k->list_lock); 383 } 384 385 386 /** 387 * kset_add - add a kset object to the hierarchy. 388 * @k: kset. 389 * 390 * Simply, this adds the kset's embedded kobject to the 391 * hierarchy. 392 * We also try to make sure that the kset's embedded kobject 393 * has a parent before it is added. We only care if the embedded 394 * kobject is not part of a kset itself, since kobject_add() 395 * assigns a parent in that case. 396 * If that is the case, and the kset has a controlling subsystem, 397 * then we set the kset's parent to be said subsystem. 398 */ 399 400 int kset_add(struct kset * k) 401 { 402 if (!k->kobj.parent && !k->kobj.kset && k->subsys) 403 k->kobj.parent = &k->subsys->kset.kobj; 404 405 return kobject_add(&k->kobj); 406 } 407 408 409 /** 410 * kset_register - initialize and add a kset. 411 * @k: kset. 412 */ 413 414 int kset_register(struct kset * k) 415 { 416 kset_init(k); 417 return kset_add(k); 418 } 419 420 421 /** 422 * kset_unregister - remove a kset. 423 * @k: kset. 424 */ 425 426 void kset_unregister(struct kset * k) 427 { 428 kobject_unregister(&k->kobj); 429 } 430 431 432 /** 433 * kset_find_obj - search for object in kset. 434 * @kset: kset we're looking in. 435 * @name: object's name. 436 * 437 * Lock kset via @kset->subsys, and iterate over @kset->list, 438 * looking for a matching kobject. If matching object is found 439 * take a reference and return the object. 440 */ 441 442 struct kobject * kset_find_obj(struct kset * kset, const char * name) 443 { 444 struct list_head * entry; 445 struct kobject * ret = NULL; 446 447 spin_lock(&kset->list_lock); 448 list_for_each(entry,&kset->list) { 449 struct kobject * k = to_kobj(entry); 450 if (kobject_name(k) && !strcmp(kobject_name(k),name)) { 451 ret = kobject_get(k); 452 break; 453 } 454 } 455 spin_unlock(&kset->list_lock); 456 return ret; 457 } 458 459 460 void subsystem_init(struct subsystem * s) 461 { 462 init_rwsem(&s->rwsem); 463 kset_init(&s->kset); 464 } 465 466 /** 467 * subsystem_register - register a subsystem. 468 * @s: the subsystem we're registering. 469 * 470 * Once we register the subsystem, we want to make sure that 471 * the kset points back to this subsystem for correct usage of 472 * the rwsem. 473 */ 474 475 int subsystem_register(struct subsystem * s) 476 { 477 int error; 478 479 subsystem_init(s); 480 pr_debug("subsystem %s: registering\n",s->kset.kobj.name); 481 482 if (!(error = kset_add(&s->kset))) { 483 if (!s->kset.subsys) 484 s->kset.subsys = s; 485 } 486 return error; 487 } 488 489 void subsystem_unregister(struct subsystem * s) 490 { 491 pr_debug("subsystem %s: unregistering\n",s->kset.kobj.name); 492 kset_unregister(&s->kset); 493 } 494 495 496 /** 497 * subsystem_create_file - export sysfs attribute file. 498 * @s: subsystem. 499 * @a: subsystem attribute descriptor. 500 */ 501 502 int subsys_create_file(struct subsystem * s, struct subsys_attribute * a) 503 { 504 int error = 0; 505 if (subsys_get(s)) { 506 error = sysfs_create_file(&s->kset.kobj,&a->attr); 507 subsys_put(s); 508 } 509 return error; 510 } 511 512 513 /** 514 * subsystem_remove_file - remove sysfs attribute file. 515 * @s: subsystem. 516 * @a: attribute desciptor. 517 */ 518 519 void subsys_remove_file(struct subsystem * s, struct subsys_attribute * a) 520 { 521 if (subsys_get(s)) { 522 sysfs_remove_file(&s->kset.kobj,&a->attr); 523 subsys_put(s); 524 } 525 } 526 527 EXPORT_SYMBOL(kobject_init); 528 EXPORT_SYMBOL(kobject_register); 529 EXPORT_SYMBOL(kobject_unregister); 530 EXPORT_SYMBOL(kobject_get); 531 EXPORT_SYMBOL(kobject_put); 532 EXPORT_SYMBOL(kobject_add); 533 EXPORT_SYMBOL(kobject_del); 534 535 EXPORT_SYMBOL(kset_register); 536 EXPORT_SYMBOL(kset_unregister); 537 EXPORT_SYMBOL(kset_find_obj); 538 539 EXPORT_SYMBOL(subsystem_init); 540 EXPORT_SYMBOL(subsystem_register); 541 EXPORT_SYMBOL(subsystem_unregister); 542 EXPORT_SYMBOL(subsys_create_file); 543 EXPORT_SYMBOL(subsys_remove_file); 544