dir.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512
  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 "sysfs.h"
  11. DECLARE_RWSEM(sysfs_rename_sem);
  12. static void sysfs_d_iput(struct dentry * dentry, struct inode * inode)
  13. {
  14. struct sysfs_dirent * sd = dentry->d_fsdata;
  15. if (sd) {
  16. BUG_ON(sd->s_dentry != dentry);
  17. sd->s_dentry = NULL;
  18. sysfs_put(sd);
  19. }
  20. iput(inode);
  21. }
  22. static struct dentry_operations sysfs_dentry_ops = {
  23. .d_iput = sysfs_d_iput,
  24. };
  25. /*
  26. * Allocates a new sysfs_dirent and links it to the parent sysfs_dirent
  27. */
  28. static struct sysfs_dirent * sysfs_new_dirent(struct sysfs_dirent * parent_sd,
  29. void * element)
  30. {
  31. struct sysfs_dirent * sd;
  32. sd = kmem_cache_alloc(sysfs_dir_cachep, GFP_KERNEL);
  33. if (!sd)
  34. return NULL;
  35. memset(sd, 0, sizeof(*sd));
  36. atomic_set(&sd->s_count, 1);
  37. INIT_LIST_HEAD(&sd->s_children);
  38. list_add(&sd->s_sibling, &parent_sd->s_children);
  39. sd->s_element = element;
  40. return sd;
  41. }
  42. /**
  43. *
  44. * Return -EEXIST if there is already a sysfs element with the same name for
  45. * the same parent.
  46. *
  47. * called with parent inode's i_mutex held
  48. */
  49. int sysfs_dirent_exist(struct sysfs_dirent *parent_sd,
  50. const unsigned char *new)
  51. {
  52. struct sysfs_dirent * sd;
  53. list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
  54. if (sd->s_element) {
  55. const unsigned char *existing = sysfs_get_name(sd);
  56. if (strcmp(existing, new))
  57. continue;
  58. else
  59. return -EEXIST;
  60. }
  61. }
  62. return 0;
  63. }
  64. int sysfs_make_dirent(struct sysfs_dirent * parent_sd, struct dentry * dentry,
  65. void * element, umode_t mode, int type)
  66. {
  67. struct sysfs_dirent * sd;
  68. sd = sysfs_new_dirent(parent_sd, element);
  69. if (!sd)
  70. return -ENOMEM;
  71. sd->s_mode = mode;
  72. sd->s_type = type;
  73. sd->s_dentry = dentry;
  74. if (dentry) {
  75. dentry->d_fsdata = sysfs_get(sd);
  76. dentry->d_op = &sysfs_dentry_ops;
  77. }
  78. return 0;
  79. }
  80. static int init_dir(struct inode * inode)
  81. {
  82. inode->i_op = &sysfs_dir_inode_operations;
  83. inode->i_fop = &sysfs_dir_operations;
  84. /* directory inodes start off with i_nlink == 2 (for "." entry) */
  85. inode->i_nlink++;
  86. return 0;
  87. }
  88. static int init_file(struct inode * inode)
  89. {
  90. inode->i_size = PAGE_SIZE;
  91. inode->i_fop = &sysfs_file_operations;
  92. return 0;
  93. }
  94. static int init_symlink(struct inode * inode)
  95. {
  96. inode->i_op = &sysfs_symlink_inode_operations;
  97. return 0;
  98. }
  99. static int create_dir(struct kobject * k, struct dentry * p,
  100. const char * n, struct dentry ** d)
  101. {
  102. int error;
  103. umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
  104. mutex_lock(&p->d_inode->i_mutex);
  105. *d = lookup_one_len(n, p, strlen(n));
  106. if (!IS_ERR(*d)) {
  107. if (sysfs_dirent_exist(p->d_fsdata, n))
  108. error = -EEXIST;
  109. else
  110. error = sysfs_make_dirent(p->d_fsdata, *d, k, mode,
  111. SYSFS_DIR);
  112. if (!error) {
  113. error = sysfs_create(*d, mode, init_dir);
  114. if (!error) {
  115. p->d_inode->i_nlink++;
  116. (*d)->d_op = &sysfs_dentry_ops;
  117. d_rehash(*d);
  118. }
  119. }
  120. if (error && (error != -EEXIST)) {
  121. struct sysfs_dirent *sd = (*d)->d_fsdata;
  122. if (sd) {
  123. list_del_init(&sd->s_sibling);
  124. sysfs_put(sd);
  125. }
  126. d_drop(*d);
  127. }
  128. dput(*d);
  129. } else
  130. error = PTR_ERR(*d);
  131. mutex_unlock(&p->d_inode->i_mutex);
  132. return error;
  133. }
  134. int sysfs_create_subdir(struct kobject * k, const char * n, struct dentry ** d)
  135. {
  136. return create_dir(k,k->dentry,n,d);
  137. }
  138. /**
  139. * sysfs_create_dir - create a directory for an object.
  140. * @parent: parent parent object.
  141. * @kobj: object we're creating directory for.
  142. */
  143. int sysfs_create_dir(struct kobject * kobj)
  144. {
  145. struct dentry * dentry = NULL;
  146. struct dentry * parent;
  147. int error = 0;
  148. BUG_ON(!kobj);
  149. if (kobj->parent)
  150. parent = kobj->parent->dentry;
  151. else if (sysfs_mount && sysfs_mount->mnt_sb)
  152. parent = sysfs_mount->mnt_sb->s_root;
  153. else
  154. return -EFAULT;
  155. error = create_dir(kobj,parent,kobject_name(kobj),&dentry);
  156. if (!error)
  157. kobj->dentry = dentry;
  158. return error;
  159. }
  160. /* attaches attribute's sysfs_dirent to the dentry corresponding to the
  161. * attribute file
  162. */
  163. static int sysfs_attach_attr(struct sysfs_dirent * sd, struct dentry * dentry)
  164. {
  165. struct attribute * attr = NULL;
  166. struct bin_attribute * bin_attr = NULL;
  167. int (* init) (struct inode *) = NULL;
  168. int error = 0;
  169. if (sd->s_type & SYSFS_KOBJ_BIN_ATTR) {
  170. bin_attr = sd->s_element;
  171. attr = &bin_attr->attr;
  172. } else {
  173. attr = sd->s_element;
  174. init = init_file;
  175. }
  176. dentry->d_fsdata = sysfs_get(sd);
  177. sd->s_dentry = dentry;
  178. error = sysfs_create(dentry, (attr->mode & S_IALLUGO) | S_IFREG, init);
  179. if (error) {
  180. sysfs_put(sd);
  181. return error;
  182. }
  183. if (bin_attr) {
  184. dentry->d_inode->i_size = bin_attr->size;
  185. dentry->d_inode->i_fop = &bin_fops;
  186. }
  187. dentry->d_op = &sysfs_dentry_ops;
  188. d_rehash(dentry);
  189. return 0;
  190. }
  191. static int sysfs_attach_link(struct sysfs_dirent * sd, struct dentry * dentry)
  192. {
  193. int err = 0;
  194. dentry->d_fsdata = sysfs_get(sd);
  195. sd->s_dentry = dentry;
  196. err = sysfs_create(dentry, S_IFLNK|S_IRWXUGO, init_symlink);
  197. if (!err) {
  198. dentry->d_op = &sysfs_dentry_ops;
  199. d_rehash(dentry);
  200. } else
  201. sysfs_put(sd);
  202. return err;
  203. }
  204. static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
  205. struct nameidata *nd)
  206. {
  207. struct sysfs_dirent * parent_sd = dentry->d_parent->d_fsdata;
  208. struct sysfs_dirent * sd;
  209. int err = 0;
  210. list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
  211. if (sd->s_type & SYSFS_NOT_PINNED) {
  212. const unsigned char * name = sysfs_get_name(sd);
  213. if (strcmp(name, dentry->d_name.name))
  214. continue;
  215. if (sd->s_type & SYSFS_KOBJ_LINK)
  216. err = sysfs_attach_link(sd, dentry);
  217. else
  218. err = sysfs_attach_attr(sd, dentry);
  219. break;
  220. }
  221. }
  222. return ERR_PTR(err);
  223. }
  224. struct inode_operations sysfs_dir_inode_operations = {
  225. .lookup = sysfs_lookup,
  226. .setattr = sysfs_setattr,
  227. };
  228. static void remove_dir(struct dentry * d)
  229. {
  230. struct dentry * parent = dget(d->d_parent);
  231. struct sysfs_dirent * sd;
  232. mutex_lock(&parent->d_inode->i_mutex);
  233. d_delete(d);
  234. sd = d->d_fsdata;
  235. list_del_init(&sd->s_sibling);
  236. sysfs_put(sd);
  237. if (d->d_inode)
  238. simple_rmdir(parent->d_inode,d);
  239. pr_debug(" o %s removing done (%d)\n",d->d_name.name,
  240. atomic_read(&d->d_count));
  241. mutex_unlock(&parent->d_inode->i_mutex);
  242. dput(parent);
  243. }
  244. void sysfs_remove_subdir(struct dentry * d)
  245. {
  246. remove_dir(d);
  247. }
  248. /**
  249. * sysfs_remove_dir - remove an object's directory.
  250. * @kobj: object.
  251. *
  252. * The only thing special about this is that we remove any files in
  253. * the directory before we remove the directory, and we've inlined
  254. * what used to be sysfs_rmdir() below, instead of calling separately.
  255. */
  256. void sysfs_remove_dir(struct kobject * kobj)
  257. {
  258. struct dentry * dentry = dget(kobj->dentry);
  259. struct sysfs_dirent * parent_sd;
  260. struct sysfs_dirent * sd, * tmp;
  261. if (!dentry)
  262. return;
  263. pr_debug("sysfs %s: removing dir\n",dentry->d_name.name);
  264. mutex_lock(&dentry->d_inode->i_mutex);
  265. parent_sd = dentry->d_fsdata;
  266. list_for_each_entry_safe(sd, tmp, &parent_sd->s_children, s_sibling) {
  267. if (!sd->s_element || !(sd->s_type & SYSFS_NOT_PINNED))
  268. continue;
  269. list_del_init(&sd->s_sibling);
  270. sysfs_drop_dentry(sd, dentry);
  271. sysfs_put(sd);
  272. }
  273. mutex_unlock(&dentry->d_inode->i_mutex);
  274. remove_dir(dentry);
  275. /**
  276. * Drop reference from dget() on entrance.
  277. */
  278. dput(dentry);
  279. kobj->dentry = NULL;
  280. }
  281. int sysfs_rename_dir(struct kobject * kobj, const char *new_name)
  282. {
  283. int error = 0;
  284. struct dentry * new_dentry, * parent;
  285. if (!strcmp(kobject_name(kobj), new_name))
  286. return -EINVAL;
  287. if (!kobj->parent)
  288. return -EINVAL;
  289. down_write(&sysfs_rename_sem);
  290. parent = kobj->parent->dentry;
  291. mutex_lock(&parent->d_inode->i_mutex);
  292. new_dentry = lookup_one_len(new_name, parent, strlen(new_name));
  293. if (!IS_ERR(new_dentry)) {
  294. if (!new_dentry->d_inode) {
  295. error = kobject_set_name(kobj, "%s", new_name);
  296. if (!error) {
  297. d_add(new_dentry, NULL);
  298. d_move(kobj->dentry, new_dentry);
  299. }
  300. else
  301. d_drop(new_dentry);
  302. } else
  303. error = -EEXIST;
  304. dput(new_dentry);
  305. }
  306. mutex_unlock(&parent->d_inode->i_mutex);
  307. up_write(&sysfs_rename_sem);
  308. return error;
  309. }
  310. static int sysfs_dir_open(struct inode *inode, struct file *file)
  311. {
  312. struct dentry * dentry = file->f_dentry;
  313. struct sysfs_dirent * parent_sd = dentry->d_fsdata;
  314. mutex_lock(&dentry->d_inode->i_mutex);
  315. file->private_data = sysfs_new_dirent(parent_sd, NULL);
  316. mutex_unlock(&dentry->d_inode->i_mutex);
  317. return file->private_data ? 0 : -ENOMEM;
  318. }
  319. static int sysfs_dir_close(struct inode *inode, struct file *file)
  320. {
  321. struct dentry * dentry = file->f_dentry;
  322. struct sysfs_dirent * cursor = file->private_data;
  323. mutex_lock(&dentry->d_inode->i_mutex);
  324. list_del_init(&cursor->s_sibling);
  325. mutex_unlock(&dentry->d_inode->i_mutex);
  326. release_sysfs_dirent(cursor);
  327. return 0;
  328. }
  329. /* Relationship between s_mode and the DT_xxx types */
  330. static inline unsigned char dt_type(struct sysfs_dirent *sd)
  331. {
  332. return (sd->s_mode >> 12) & 15;
  333. }
  334. static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
  335. {
  336. struct dentry *dentry = filp->f_dentry;
  337. struct sysfs_dirent * parent_sd = dentry->d_fsdata;
  338. struct sysfs_dirent *cursor = filp->private_data;
  339. struct list_head *p, *q = &cursor->s_sibling;
  340. ino_t ino;
  341. int i = filp->f_pos;
  342. switch (i) {
  343. case 0:
  344. ino = dentry->d_inode->i_ino;
  345. if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
  346. break;
  347. filp->f_pos++;
  348. i++;
  349. /* fallthrough */
  350. case 1:
  351. ino = parent_ino(dentry);
  352. if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
  353. break;
  354. filp->f_pos++;
  355. i++;
  356. /* fallthrough */
  357. default:
  358. if (filp->f_pos == 2) {
  359. list_del(q);
  360. list_add(q, &parent_sd->s_children);
  361. }
  362. for (p=q->next; p!= &parent_sd->s_children; p=p->next) {
  363. struct sysfs_dirent *next;
  364. const char * name;
  365. int len;
  366. next = list_entry(p, struct sysfs_dirent,
  367. s_sibling);
  368. if (!next->s_element)
  369. continue;
  370. name = sysfs_get_name(next);
  371. len = strlen(name);
  372. if (next->s_dentry)
  373. ino = next->s_dentry->d_inode->i_ino;
  374. else
  375. ino = iunique(sysfs_sb, 2);
  376. if (filldir(dirent, name, len, filp->f_pos, ino,
  377. dt_type(next)) < 0)
  378. return 0;
  379. list_del(q);
  380. list_add(q, p);
  381. p = q;
  382. filp->f_pos++;
  383. }
  384. }
  385. return 0;
  386. }
  387. static loff_t sysfs_dir_lseek(struct file * file, loff_t offset, int origin)
  388. {
  389. struct dentry * dentry = file->f_dentry;
  390. mutex_lock(&dentry->d_inode->i_mutex);
  391. switch (origin) {
  392. case 1:
  393. offset += file->f_pos;
  394. case 0:
  395. if (offset >= 0)
  396. break;
  397. default:
  398. mutex_unlock(&file->f_dentry->d_inode->i_mutex);
  399. return -EINVAL;
  400. }
  401. if (offset != file->f_pos) {
  402. file->f_pos = offset;
  403. if (file->f_pos >= 2) {
  404. struct sysfs_dirent *sd = dentry->d_fsdata;
  405. struct sysfs_dirent *cursor = file->private_data;
  406. struct list_head *p;
  407. loff_t n = file->f_pos - 2;
  408. list_del(&cursor->s_sibling);
  409. p = sd->s_children.next;
  410. while (n && p != &sd->s_children) {
  411. struct sysfs_dirent *next;
  412. next = list_entry(p, struct sysfs_dirent,
  413. s_sibling);
  414. if (next->s_element)
  415. n--;
  416. p = p->next;
  417. }
  418. list_add_tail(&cursor->s_sibling, p);
  419. }
  420. }
  421. mutex_unlock(&dentry->d_inode->i_mutex);
  422. return offset;
  423. }
  424. const struct file_operations sysfs_dir_operations = {
  425. .open = sysfs_dir_open,
  426. .release = sysfs_dir_close,
  427. .llseek = sysfs_dir_lseek,
  428. .read = generic_read_dir,
  429. .readdir = sysfs_readdir,
  430. };