kobject.c 14 KB

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