dir.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693
  1. /*
  2. * dir.c - Operations for sysfs directories.
  3. */
  4. #undef DEBUG
  5. #include <linux/fs.h>
  6. #include <linux/mount.h>
  7. #include <linux/module.h>
  8. #include <linux/kobject.h>
  9. #include <linux/namei.h>
  10. #include <asm/semaphore.h>
  11. #include "sysfs.h"
  12. DECLARE_RWSEM(sysfs_rename_sem);
  13. static void sysfs_d_iput(struct dentry * dentry, struct inode * inode)
  14. {
  15. struct sysfs_dirent * sd = dentry->d_fsdata;
  16. if (sd) {
  17. BUG_ON(sd->s_dentry != dentry);
  18. sd->s_dentry = NULL;
  19. sysfs_put(sd);
  20. }
  21. iput(inode);
  22. }
  23. static struct dentry_operations sysfs_dentry_ops = {
  24. .d_iput = sysfs_d_iput,
  25. };
  26. /*
  27. * Allocates a new sysfs_dirent and links it to the parent sysfs_dirent
  28. */
  29. static struct sysfs_dirent * __sysfs_new_dirent(void * element)
  30. {
  31. struct sysfs_dirent * sd;
  32. sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
  33. if (!sd)
  34. return NULL;
  35. atomic_set(&sd->s_count, 1);
  36. atomic_set(&sd->s_event, 1);
  37. INIT_LIST_HEAD(&sd->s_children);
  38. INIT_LIST_HEAD(&sd->s_sibling);
  39. sd->s_element = element;
  40. return sd;
  41. }
  42. static void __sysfs_list_dirent(struct sysfs_dirent *parent_sd,
  43. struct sysfs_dirent *sd)
  44. {
  45. if (sd)
  46. list_add(&sd->s_sibling, &parent_sd->s_children);
  47. }
  48. static struct sysfs_dirent * sysfs_new_dirent(struct sysfs_dirent *parent_sd,
  49. void * element)
  50. {
  51. struct sysfs_dirent *sd;
  52. sd = __sysfs_new_dirent(element);
  53. __sysfs_list_dirent(parent_sd, sd);
  54. return sd;
  55. }
  56. /*
  57. *
  58. * Return -EEXIST if there is already a sysfs element with the same name for
  59. * the same parent.
  60. *
  61. * called with parent inode's i_mutex held
  62. */
  63. int sysfs_dirent_exist(struct sysfs_dirent *parent_sd,
  64. const unsigned char *new)
  65. {
  66. struct sysfs_dirent * sd;
  67. list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
  68. if (sd->s_element) {
  69. const unsigned char *existing = sysfs_get_name(sd);
  70. if (strcmp(existing, new))
  71. continue;
  72. else
  73. return -EEXIST;
  74. }
  75. }
  76. return 0;
  77. }
  78. static struct sysfs_dirent *
  79. __sysfs_make_dirent(struct dentry *dentry, void *element, mode_t mode, int type)
  80. {
  81. struct sysfs_dirent * sd;
  82. sd = __sysfs_new_dirent(element);
  83. if (!sd)
  84. goto out;
  85. sd->s_mode = mode;
  86. sd->s_type = type;
  87. sd->s_dentry = dentry;
  88. if (dentry) {
  89. dentry->d_fsdata = sysfs_get(sd);
  90. dentry->d_op = &sysfs_dentry_ops;
  91. }
  92. out:
  93. return sd;
  94. }
  95. int sysfs_make_dirent(struct sysfs_dirent * parent_sd, struct dentry * dentry,
  96. void * element, umode_t mode, int type)
  97. {
  98. struct sysfs_dirent *sd;
  99. sd = __sysfs_make_dirent(dentry, element, mode, type);
  100. __sysfs_list_dirent(parent_sd, sd);
  101. return sd ? 0 : -ENOMEM;
  102. }
  103. static int init_dir(struct inode * inode)
  104. {
  105. inode->i_op = &sysfs_dir_inode_operations;
  106. inode->i_fop = &sysfs_dir_operations;
  107. /* directory inodes start off with i_nlink == 2 (for "." entry) */
  108. inc_nlink(inode);
  109. return 0;
  110. }
  111. static int init_file(struct inode * inode)
  112. {
  113. inode->i_size = PAGE_SIZE;
  114. inode->i_fop = &sysfs_file_operations;
  115. return 0;
  116. }
  117. static int init_symlink(struct inode * inode)
  118. {
  119. inode->i_op = &sysfs_symlink_inode_operations;
  120. return 0;
  121. }
  122. static int create_dir(struct kobject * k, struct dentry * p,
  123. const char * n, struct dentry ** d)
  124. {
  125. int error;
  126. umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
  127. mutex_lock(&p->d_inode->i_mutex);
  128. *d = lookup_one_len(n, p, strlen(n));
  129. if (!IS_ERR(*d)) {
  130. if (sysfs_dirent_exist(p->d_fsdata, n))
  131. error = -EEXIST;
  132. else
  133. error = sysfs_make_dirent(p->d_fsdata, *d, k, mode,
  134. SYSFS_DIR);
  135. if (!error) {
  136. error = sysfs_create(*d, mode, init_dir);
  137. if (!error) {
  138. inc_nlink(p->d_inode);
  139. (*d)->d_op = &sysfs_dentry_ops;
  140. d_rehash(*d);
  141. }
  142. }
  143. if (error && (error != -EEXIST)) {
  144. struct sysfs_dirent *sd = (*d)->d_fsdata;
  145. if (sd) {
  146. list_del_init(&sd->s_sibling);
  147. sysfs_put(sd);
  148. }
  149. d_drop(*d);
  150. }
  151. dput(*d);
  152. } else
  153. error = PTR_ERR(*d);
  154. mutex_unlock(&p->d_inode->i_mutex);
  155. return error;
  156. }
  157. int sysfs_create_subdir(struct kobject * k, const char * n, struct dentry ** d)
  158. {
  159. return create_dir(k,k->dentry,n,d);
  160. }
  161. /**
  162. * sysfs_create_dir - create a directory for an object.
  163. * @kobj: object we're creating directory for.
  164. * @shadow_parent: parent parent object.
  165. */
  166. int sysfs_create_dir(struct kobject * kobj, struct dentry *shadow_parent)
  167. {
  168. struct dentry * dentry = NULL;
  169. struct dentry * parent;
  170. int error = 0;
  171. BUG_ON(!kobj);
  172. if (shadow_parent)
  173. parent = shadow_parent;
  174. else if (kobj->parent)
  175. parent = kobj->parent->dentry;
  176. else if (sysfs_mount && sysfs_mount->mnt_sb)
  177. parent = sysfs_mount->mnt_sb->s_root;
  178. else
  179. return -EFAULT;
  180. error = create_dir(kobj,parent,kobject_name(kobj),&dentry);
  181. if (!error)
  182. kobj->dentry = dentry;
  183. return error;
  184. }
  185. /* attaches attribute's sysfs_dirent to the dentry corresponding to the
  186. * attribute file
  187. */
  188. static int sysfs_attach_attr(struct sysfs_dirent * sd, struct dentry * dentry)
  189. {
  190. struct attribute * attr = NULL;
  191. struct bin_attribute * bin_attr = NULL;
  192. int (* init) (struct inode *) = NULL;
  193. int error = 0;
  194. if (sd->s_type & SYSFS_KOBJ_BIN_ATTR) {
  195. bin_attr = sd->s_element;
  196. attr = &bin_attr->attr;
  197. } else {
  198. attr = sd->s_element;
  199. init = init_file;
  200. }
  201. dentry->d_fsdata = sysfs_get(sd);
  202. sd->s_dentry = dentry;
  203. error = sysfs_create(dentry, (attr->mode & S_IALLUGO) | S_IFREG, init);
  204. if (error) {
  205. sysfs_put(sd);
  206. return error;
  207. }
  208. if (bin_attr) {
  209. dentry->d_inode->i_size = bin_attr->size;
  210. dentry->d_inode->i_fop = &bin_fops;
  211. }
  212. dentry->d_op = &sysfs_dentry_ops;
  213. d_rehash(dentry);
  214. return 0;
  215. }
  216. static int sysfs_attach_link(struct sysfs_dirent * sd, struct dentry * dentry)
  217. {
  218. int err = 0;
  219. dentry->d_fsdata = sysfs_get(sd);
  220. sd->s_dentry = dentry;
  221. err = sysfs_create(dentry, S_IFLNK|S_IRWXUGO, init_symlink);
  222. if (!err) {
  223. dentry->d_op = &sysfs_dentry_ops;
  224. d_rehash(dentry);
  225. } else
  226. sysfs_put(sd);
  227. return err;
  228. }
  229. static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
  230. struct nameidata *nd)
  231. {
  232. struct sysfs_dirent * parent_sd = dentry->d_parent->d_fsdata;
  233. struct sysfs_dirent * sd;
  234. int err = 0;
  235. list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
  236. if (sd->s_type & SYSFS_NOT_PINNED) {
  237. const unsigned char * name = sysfs_get_name(sd);
  238. if (strcmp(name, dentry->d_name.name))
  239. continue;
  240. if (sd->s_type & SYSFS_KOBJ_LINK)
  241. err = sysfs_attach_link(sd, dentry);
  242. else
  243. err = sysfs_attach_attr(sd, dentry);
  244. break;
  245. }
  246. }
  247. return ERR_PTR(err);
  248. }
  249. const struct inode_operations sysfs_dir_inode_operations = {
  250. .lookup = sysfs_lookup,
  251. .setattr = sysfs_setattr,
  252. };
  253. static void remove_dir(struct dentry * d)
  254. {
  255. struct dentry * parent = dget(d->d_parent);
  256. struct sysfs_dirent * sd;
  257. mutex_lock(&parent->d_inode->i_mutex);
  258. d_delete(d);
  259. sd = d->d_fsdata;
  260. list_del_init(&sd->s_sibling);
  261. sysfs_put(sd);
  262. if (d->d_inode)
  263. simple_rmdir(parent->d_inode,d);
  264. pr_debug(" o %s removing done (%d)\n",d->d_name.name,
  265. atomic_read(&d->d_count));
  266. mutex_unlock(&parent->d_inode->i_mutex);
  267. dput(parent);
  268. }
  269. void sysfs_remove_subdir(struct dentry * d)
  270. {
  271. remove_dir(d);
  272. }
  273. static void __sysfs_remove_dir(struct dentry *dentry)
  274. {
  275. struct sysfs_dirent * parent_sd;
  276. struct sysfs_dirent * sd, * tmp;
  277. dget(dentry);
  278. if (!dentry)
  279. return;
  280. pr_debug("sysfs %s: removing dir\n",dentry->d_name.name);
  281. mutex_lock(&dentry->d_inode->i_mutex);
  282. parent_sd = dentry->d_fsdata;
  283. list_for_each_entry_safe(sd, tmp, &parent_sd->s_children, s_sibling) {
  284. if (!sd->s_element || !(sd->s_type & SYSFS_NOT_PINNED))
  285. continue;
  286. list_del_init(&sd->s_sibling);
  287. sysfs_drop_dentry(sd, dentry);
  288. sysfs_put(sd);
  289. }
  290. mutex_unlock(&dentry->d_inode->i_mutex);
  291. remove_dir(dentry);
  292. /**
  293. * Drop reference from dget() on entrance.
  294. */
  295. dput(dentry);
  296. }
  297. /**
  298. * sysfs_remove_dir - remove an object's directory.
  299. * @kobj: object.
  300. *
  301. * The only thing special about this is that we remove any files in
  302. * the directory before we remove the directory, and we've inlined
  303. * what used to be sysfs_rmdir() below, instead of calling separately.
  304. */
  305. void sysfs_remove_dir(struct kobject * kobj)
  306. {
  307. __sysfs_remove_dir(kobj->dentry);
  308. kobj->dentry = NULL;
  309. }
  310. int sysfs_rename_dir(struct kobject * kobj, struct dentry *new_parent,
  311. const char *new_name)
  312. {
  313. int error = 0;
  314. struct dentry * new_dentry;
  315. if (!new_parent)
  316. return -EFAULT;
  317. down_write(&sysfs_rename_sem);
  318. mutex_lock(&new_parent->d_inode->i_mutex);
  319. new_dentry = lookup_one_len(new_name, new_parent, strlen(new_name));
  320. if (!IS_ERR(new_dentry)) {
  321. /* By allowing two different directories with the
  322. * same d_parent we allow this routine to move
  323. * between different shadows of the same directory
  324. */
  325. if (kobj->dentry->d_parent->d_inode != new_parent->d_inode)
  326. return -EINVAL;
  327. else if (new_dentry->d_parent->d_inode != new_parent->d_inode)
  328. error = -EINVAL;
  329. else if (new_dentry == kobj->dentry)
  330. error = -EINVAL;
  331. else if (!new_dentry->d_inode) {
  332. error = kobject_set_name(kobj, "%s", new_name);
  333. if (!error) {
  334. struct sysfs_dirent *sd, *parent_sd;
  335. d_add(new_dentry, NULL);
  336. d_move(kobj->dentry, new_dentry);
  337. sd = kobj->dentry->d_fsdata;
  338. parent_sd = new_parent->d_fsdata;
  339. list_del_init(&sd->s_sibling);
  340. list_add(&sd->s_sibling, &parent_sd->s_children);
  341. }
  342. else
  343. d_drop(new_dentry);
  344. } else
  345. error = -EEXIST;
  346. dput(new_dentry);
  347. }
  348. mutex_unlock(&new_parent->d_inode->i_mutex);
  349. up_write(&sysfs_rename_sem);
  350. return error;
  351. }
  352. int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent)
  353. {
  354. struct dentry *old_parent_dentry, *new_parent_dentry, *new_dentry;
  355. struct sysfs_dirent *new_parent_sd, *sd;
  356. int error;
  357. old_parent_dentry = kobj->parent ?
  358. kobj->parent->dentry : sysfs_mount->mnt_sb->s_root;
  359. new_parent_dentry = new_parent ?
  360. new_parent->dentry : sysfs_mount->mnt_sb->s_root;
  361. if (old_parent_dentry->d_inode == new_parent_dentry->d_inode)
  362. return 0; /* nothing to move */
  363. again:
  364. mutex_lock(&old_parent_dentry->d_inode->i_mutex);
  365. if (!mutex_trylock(&new_parent_dentry->d_inode->i_mutex)) {
  366. mutex_unlock(&old_parent_dentry->d_inode->i_mutex);
  367. goto again;
  368. }
  369. new_parent_sd = new_parent_dentry->d_fsdata;
  370. sd = kobj->dentry->d_fsdata;
  371. new_dentry = lookup_one_len(kobj->name, new_parent_dentry,
  372. strlen(kobj->name));
  373. if (IS_ERR(new_dentry)) {
  374. error = PTR_ERR(new_dentry);
  375. goto out;
  376. } else
  377. error = 0;
  378. d_add(new_dentry, NULL);
  379. d_move(kobj->dentry, new_dentry);
  380. dput(new_dentry);
  381. /* Remove from old parent's list and insert into new parent's list. */
  382. list_del_init(&sd->s_sibling);
  383. list_add(&sd->s_sibling, &new_parent_sd->s_children);
  384. out:
  385. mutex_unlock(&new_parent_dentry->d_inode->i_mutex);
  386. mutex_unlock(&old_parent_dentry->d_inode->i_mutex);
  387. return error;
  388. }
  389. static int sysfs_dir_open(struct inode *inode, struct file *file)
  390. {
  391. struct dentry * dentry = file->f_path.dentry;
  392. struct sysfs_dirent * parent_sd = dentry->d_fsdata;
  393. mutex_lock(&dentry->d_inode->i_mutex);
  394. file->private_data = sysfs_new_dirent(parent_sd, NULL);
  395. mutex_unlock(&dentry->d_inode->i_mutex);
  396. return file->private_data ? 0 : -ENOMEM;
  397. }
  398. static int sysfs_dir_close(struct inode *inode, struct file *file)
  399. {
  400. struct dentry * dentry = file->f_path.dentry;
  401. struct sysfs_dirent * cursor = file->private_data;
  402. mutex_lock(&dentry->d_inode->i_mutex);
  403. list_del_init(&cursor->s_sibling);
  404. mutex_unlock(&dentry->d_inode->i_mutex);
  405. release_sysfs_dirent(cursor);
  406. return 0;
  407. }
  408. /* Relationship between s_mode and the DT_xxx types */
  409. static inline unsigned char dt_type(struct sysfs_dirent *sd)
  410. {
  411. return (sd->s_mode >> 12) & 15;
  412. }
  413. static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
  414. {
  415. struct dentry *dentry = filp->f_path.dentry;
  416. struct sysfs_dirent * parent_sd = dentry->d_fsdata;
  417. struct sysfs_dirent *cursor = filp->private_data;
  418. struct list_head *p, *q = &cursor->s_sibling;
  419. ino_t ino;
  420. int i = filp->f_pos;
  421. switch (i) {
  422. case 0:
  423. ino = dentry->d_inode->i_ino;
  424. if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
  425. break;
  426. filp->f_pos++;
  427. i++;
  428. /* fallthrough */
  429. case 1:
  430. ino = parent_ino(dentry);
  431. if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
  432. break;
  433. filp->f_pos++;
  434. i++;
  435. /* fallthrough */
  436. default:
  437. if (filp->f_pos == 2)
  438. list_move(q, &parent_sd->s_children);
  439. for (p=q->next; p!= &parent_sd->s_children; p=p->next) {
  440. struct sysfs_dirent *next;
  441. const char * name;
  442. int len;
  443. next = list_entry(p, struct sysfs_dirent,
  444. s_sibling);
  445. if (!next->s_element)
  446. continue;
  447. name = sysfs_get_name(next);
  448. len = strlen(name);
  449. if (next->s_dentry)
  450. ino = next->s_dentry->d_inode->i_ino;
  451. else
  452. ino = iunique(sysfs_sb, 2);
  453. if (filldir(dirent, name, len, filp->f_pos, ino,
  454. dt_type(next)) < 0)
  455. return 0;
  456. list_move(q, p);
  457. p = q;
  458. filp->f_pos++;
  459. }
  460. }
  461. return 0;
  462. }
  463. static loff_t sysfs_dir_lseek(struct file * file, loff_t offset, int origin)
  464. {
  465. struct dentry * dentry = file->f_path.dentry;
  466. mutex_lock(&dentry->d_inode->i_mutex);
  467. switch (origin) {
  468. case 1:
  469. offset += file->f_pos;
  470. case 0:
  471. if (offset >= 0)
  472. break;
  473. default:
  474. mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
  475. return -EINVAL;
  476. }
  477. if (offset != file->f_pos) {
  478. file->f_pos = offset;
  479. if (file->f_pos >= 2) {
  480. struct sysfs_dirent *sd = dentry->d_fsdata;
  481. struct sysfs_dirent *cursor = file->private_data;
  482. struct list_head *p;
  483. loff_t n = file->f_pos - 2;
  484. list_del(&cursor->s_sibling);
  485. p = sd->s_children.next;
  486. while (n && p != &sd->s_children) {
  487. struct sysfs_dirent *next;
  488. next = list_entry(p, struct sysfs_dirent,
  489. s_sibling);
  490. if (next->s_element)
  491. n--;
  492. p = p->next;
  493. }
  494. list_add_tail(&cursor->s_sibling, p);
  495. }
  496. }
  497. mutex_unlock(&dentry->d_inode->i_mutex);
  498. return offset;
  499. }
  500. /**
  501. * sysfs_make_shadowed_dir - Setup so a directory can be shadowed
  502. * @kobj: object we're creating shadow of.
  503. */
  504. int sysfs_make_shadowed_dir(struct kobject *kobj,
  505. void * (*follow_link)(struct dentry *, struct nameidata *))
  506. {
  507. struct inode *inode;
  508. struct inode_operations *i_op;
  509. inode = kobj->dentry->d_inode;
  510. if (inode->i_op != &sysfs_dir_inode_operations)
  511. return -EINVAL;
  512. i_op = kmalloc(sizeof(*i_op), GFP_KERNEL);
  513. if (!i_op)
  514. return -ENOMEM;
  515. memcpy(i_op, &sysfs_dir_inode_operations, sizeof(*i_op));
  516. i_op->follow_link = follow_link;
  517. /* Locking of inode->i_op?
  518. * Since setting i_op is a single word write and they
  519. * are atomic we should be ok here.
  520. */
  521. inode->i_op = i_op;
  522. return 0;
  523. }
  524. /**
  525. * sysfs_create_shadow_dir - create a shadow directory for an object.
  526. * @kobj: object we're creating directory for.
  527. *
  528. * sysfs_make_shadowed_dir must already have been called on this
  529. * directory.
  530. */
  531. struct dentry *sysfs_create_shadow_dir(struct kobject *kobj)
  532. {
  533. struct sysfs_dirent *sd;
  534. struct dentry *parent, *dir, *shadow;
  535. struct inode *inode;
  536. dir = kobj->dentry;
  537. inode = dir->d_inode;
  538. parent = dir->d_parent;
  539. shadow = ERR_PTR(-EINVAL);
  540. if (!sysfs_is_shadowed_inode(inode))
  541. goto out;
  542. shadow = d_alloc(parent, &dir->d_name);
  543. if (!shadow)
  544. goto nomem;
  545. sd = __sysfs_make_dirent(shadow, kobj, inode->i_mode, SYSFS_DIR);
  546. if (!sd)
  547. goto nomem;
  548. d_instantiate(shadow, igrab(inode));
  549. inc_nlink(inode);
  550. inc_nlink(parent->d_inode);
  551. shadow->d_op = &sysfs_dentry_ops;
  552. dget(shadow); /* Extra count - pin the dentry in core */
  553. out:
  554. return shadow;
  555. nomem:
  556. dput(shadow);
  557. shadow = ERR_PTR(-ENOMEM);
  558. goto out;
  559. }
  560. /**
  561. * sysfs_remove_shadow_dir - remove an object's directory.
  562. * @shadow: dentry of shadow directory
  563. *
  564. * The only thing special about this is that we remove any files in
  565. * the directory before we remove the directory, and we've inlined
  566. * what used to be sysfs_rmdir() below, instead of calling separately.
  567. */
  568. void sysfs_remove_shadow_dir(struct dentry *shadow)
  569. {
  570. __sysfs_remove_dir(shadow);
  571. }
  572. const struct file_operations sysfs_dir_operations = {
  573. .open = sysfs_dir_open,
  574. .release = sysfs_dir_close,
  575. .llseek = sysfs_dir_lseek,
  576. .read = generic_read_dir,
  577. .readdir = sysfs_readdir,
  578. };