super.c 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939
  1. /*
  2. * linux/fs/super.c
  3. *
  4. * Copyright (C) 1991, 1992 Linus Torvalds
  5. *
  6. * super.c contains code to handle: - mount structures
  7. * - super-block tables
  8. * - filesystem drivers list
  9. * - mount system call
  10. * - umount system call
  11. * - ustat system call
  12. *
  13. * GK 2/5/95 - Changed to support mounting the root fs via NFS
  14. *
  15. * Added kerneld support: Jacques Gelinas and Bjorn Ekwall
  16. * Added change_root: Werner Almesberger & Hans Lermen, Feb '96
  17. * Added options to /proc/mounts:
  18. * Torbjörn Lindh (torbjorn.lindh@gopta.se), April 14, 1996.
  19. * Added devfs support: Richard Gooch <rgooch@atnf.csiro.au>, 13-JAN-1998
  20. * Heavily rewritten for 'one fs - one tree' dcache architecture. AV, Mar 2000
  21. */
  22. #include <linux/module.h>
  23. #include <linux/slab.h>
  24. #include <linux/init.h>
  25. #include <linux/smp_lock.h>
  26. #include <linux/acct.h>
  27. #include <linux/blkdev.h>
  28. #include <linux/quotaops.h>
  29. #include <linux/namei.h>
  30. #include <linux/buffer_head.h> /* for fsync_super() */
  31. #include <linux/mount.h>
  32. #include <linux/security.h>
  33. #include <linux/syscalls.h>
  34. #include <linux/vfs.h>
  35. #include <linux/writeback.h> /* for the emergency remount stuff */
  36. #include <linux/idr.h>
  37. #include <linux/kobject.h>
  38. #include <linux/mutex.h>
  39. #include <asm/uaccess.h>
  40. void get_filesystem(struct file_system_type *fs);
  41. void put_filesystem(struct file_system_type *fs);
  42. struct file_system_type *get_fs_type(const char *name);
  43. LIST_HEAD(super_blocks);
  44. DEFINE_SPINLOCK(sb_lock);
  45. /**
  46. * alloc_super - create new superblock
  47. * @type: filesystem type superblock should belong to
  48. *
  49. * Allocates and initializes a new &struct super_block. alloc_super()
  50. * returns a pointer new superblock or %NULL if allocation had failed.
  51. */
  52. static struct super_block *alloc_super(struct file_system_type *type)
  53. {
  54. struct super_block *s = kzalloc(sizeof(struct super_block), GFP_USER);
  55. static struct super_operations default_op;
  56. if (s) {
  57. if (security_sb_alloc(s)) {
  58. kfree(s);
  59. s = NULL;
  60. goto out;
  61. }
  62. INIT_LIST_HEAD(&s->s_dirty);
  63. INIT_LIST_HEAD(&s->s_io);
  64. INIT_LIST_HEAD(&s->s_files);
  65. INIT_LIST_HEAD(&s->s_instances);
  66. INIT_HLIST_HEAD(&s->s_anon);
  67. INIT_LIST_HEAD(&s->s_inodes);
  68. init_rwsem(&s->s_umount);
  69. mutex_init(&s->s_lock);
  70. lockdep_set_class(&s->s_umount, &type->s_umount_key);
  71. /*
  72. * The locking rules for s_lock are up to the
  73. * filesystem. For example ext3fs has different
  74. * lock ordering than usbfs:
  75. */
  76. lockdep_set_class(&s->s_lock, &type->s_lock_key);
  77. down_write(&s->s_umount);
  78. s->s_count = S_BIAS;
  79. atomic_set(&s->s_active, 1);
  80. mutex_init(&s->s_vfs_rename_mutex);
  81. mutex_init(&s->s_dquot.dqio_mutex);
  82. mutex_init(&s->s_dquot.dqonoff_mutex);
  83. init_rwsem(&s->s_dquot.dqptr_sem);
  84. init_waitqueue_head(&s->s_wait_unfrozen);
  85. s->s_maxbytes = MAX_NON_LFS;
  86. s->dq_op = sb_dquot_ops;
  87. s->s_qcop = sb_quotactl_ops;
  88. s->s_op = &default_op;
  89. s->s_time_gran = 1000000000;
  90. }
  91. out:
  92. return s;
  93. }
  94. /**
  95. * destroy_super - frees a superblock
  96. * @s: superblock to free
  97. *
  98. * Frees a superblock.
  99. */
  100. static inline void destroy_super(struct super_block *s)
  101. {
  102. security_sb_free(s);
  103. kfree(s);
  104. }
  105. /* Superblock refcounting */
  106. /*
  107. * Drop a superblock's refcount. Returns non-zero if the superblock was
  108. * destroyed. The caller must hold sb_lock.
  109. */
  110. int __put_super(struct super_block *sb)
  111. {
  112. int ret = 0;
  113. if (!--sb->s_count) {
  114. destroy_super(sb);
  115. ret = 1;
  116. }
  117. return ret;
  118. }
  119. /*
  120. * Drop a superblock's refcount.
  121. * Returns non-zero if the superblock is about to be destroyed and
  122. * at least is already removed from super_blocks list, so if we are
  123. * making a loop through super blocks then we need to restart.
  124. * The caller must hold sb_lock.
  125. */
  126. int __put_super_and_need_restart(struct super_block *sb)
  127. {
  128. /* check for race with generic_shutdown_super() */
  129. if (list_empty(&sb->s_list)) {
  130. /* super block is removed, need to restart... */
  131. __put_super(sb);
  132. return 1;
  133. }
  134. /* can't be the last, since s_list is still in use */
  135. sb->s_count--;
  136. BUG_ON(sb->s_count == 0);
  137. return 0;
  138. }
  139. /**
  140. * put_super - drop a temporary reference to superblock
  141. * @sb: superblock in question
  142. *
  143. * Drops a temporary reference, frees superblock if there's no
  144. * references left.
  145. */
  146. static void put_super(struct super_block *sb)
  147. {
  148. spin_lock(&sb_lock);
  149. __put_super(sb);
  150. spin_unlock(&sb_lock);
  151. }
  152. /**
  153. * deactivate_super - drop an active reference to superblock
  154. * @s: superblock to deactivate
  155. *
  156. * Drops an active reference to superblock, acquiring a temprory one if
  157. * there is no active references left. In that case we lock superblock,
  158. * tell fs driver to shut it down and drop the temporary reference we
  159. * had just acquired.
  160. */
  161. void deactivate_super(struct super_block *s)
  162. {
  163. struct file_system_type *fs = s->s_type;
  164. if (atomic_dec_and_lock(&s->s_active, &sb_lock)) {
  165. s->s_count -= S_BIAS-1;
  166. spin_unlock(&sb_lock);
  167. DQUOT_OFF(s);
  168. down_write(&s->s_umount);
  169. fs->kill_sb(s);
  170. put_filesystem(fs);
  171. put_super(s);
  172. }
  173. }
  174. EXPORT_SYMBOL(deactivate_super);
  175. /**
  176. * grab_super - acquire an active reference
  177. * @s: reference we are trying to make active
  178. *
  179. * Tries to acquire an active reference. grab_super() is used when we
  180. * had just found a superblock in super_blocks or fs_type->fs_supers
  181. * and want to turn it into a full-blown active reference. grab_super()
  182. * is called with sb_lock held and drops it. Returns 1 in case of
  183. * success, 0 if we had failed (superblock contents was already dead or
  184. * dying when grab_super() had been called).
  185. */
  186. static int grab_super(struct super_block *s) __releases(sb_lock)
  187. {
  188. s->s_count++;
  189. spin_unlock(&sb_lock);
  190. down_write(&s->s_umount);
  191. if (s->s_root) {
  192. spin_lock(&sb_lock);
  193. if (s->s_count > S_BIAS) {
  194. atomic_inc(&s->s_active);
  195. s->s_count--;
  196. spin_unlock(&sb_lock);
  197. return 1;
  198. }
  199. spin_unlock(&sb_lock);
  200. }
  201. up_write(&s->s_umount);
  202. put_super(s);
  203. yield();
  204. return 0;
  205. }
  206. /*
  207. * Superblock locking. We really ought to get rid of these two.
  208. */
  209. void lock_super(struct super_block * sb)
  210. {
  211. get_fs_excl();
  212. mutex_lock(&sb->s_lock);
  213. }
  214. void unlock_super(struct super_block * sb)
  215. {
  216. put_fs_excl();
  217. mutex_unlock(&sb->s_lock);
  218. }
  219. EXPORT_SYMBOL(lock_super);
  220. EXPORT_SYMBOL(unlock_super);
  221. /*
  222. * Write out and wait upon all dirty data associated with this
  223. * superblock. Filesystem data as well as the underlying block
  224. * device. Takes the superblock lock. Requires a second blkdev
  225. * flush by the caller to complete the operation.
  226. */
  227. void __fsync_super(struct super_block *sb)
  228. {
  229. sync_inodes_sb(sb, 0);
  230. DQUOT_SYNC(sb);
  231. lock_super(sb);
  232. if (sb->s_dirt && sb->s_op->write_super)
  233. sb->s_op->write_super(sb);
  234. unlock_super(sb);
  235. if (sb->s_op->sync_fs)
  236. sb->s_op->sync_fs(sb, 1);
  237. sync_blockdev(sb->s_bdev);
  238. sync_inodes_sb(sb, 1);
  239. }
  240. /*
  241. * Write out and wait upon all dirty data associated with this
  242. * superblock. Filesystem data as well as the underlying block
  243. * device. Takes the superblock lock.
  244. */
  245. int fsync_super(struct super_block *sb)
  246. {
  247. __fsync_super(sb);
  248. return sync_blockdev(sb->s_bdev);
  249. }
  250. /**
  251. * generic_shutdown_super - common helper for ->kill_sb()
  252. * @sb: superblock to kill
  253. *
  254. * generic_shutdown_super() does all fs-independent work on superblock
  255. * shutdown. Typical ->kill_sb() should pick all fs-specific objects
  256. * that need destruction out of superblock, call generic_shutdown_super()
  257. * and release aforementioned objects. Note: dentries and inodes _are_
  258. * taken care of and do not need specific handling.
  259. *
  260. * Upon calling this function, the filesystem may no longer alter or
  261. * rearrange the set of dentries belonging to this super_block, nor may it
  262. * change the attachments of dentries to inodes.
  263. */
  264. void generic_shutdown_super(struct super_block *sb)
  265. {
  266. const struct super_operations *sop = sb->s_op;
  267. if (sb->s_root) {
  268. shrink_dcache_for_umount(sb);
  269. fsync_super(sb);
  270. lock_super(sb);
  271. sb->s_flags &= ~MS_ACTIVE;
  272. /* bad name - it should be evict_inodes() */
  273. invalidate_inodes(sb);
  274. lock_kernel();
  275. if (sop->write_super && sb->s_dirt)
  276. sop->write_super(sb);
  277. if (sop->put_super)
  278. sop->put_super(sb);
  279. /* Forget any remaining inodes */
  280. if (invalidate_inodes(sb)) {
  281. printk("VFS: Busy inodes after unmount of %s. "
  282. "Self-destruct in 5 seconds. Have a nice day...\n",
  283. sb->s_id);
  284. }
  285. unlock_kernel();
  286. unlock_super(sb);
  287. }
  288. spin_lock(&sb_lock);
  289. /* should be initialized for __put_super_and_need_restart() */
  290. list_del_init(&sb->s_list);
  291. list_del(&sb->s_instances);
  292. spin_unlock(&sb_lock);
  293. up_write(&sb->s_umount);
  294. }
  295. EXPORT_SYMBOL(generic_shutdown_super);
  296. /**
  297. * sget - find or create a superblock
  298. * @type: filesystem type superblock should belong to
  299. * @test: comparison callback
  300. * @set: setup callback
  301. * @data: argument to each of them
  302. */
  303. struct super_block *sget(struct file_system_type *type,
  304. int (*test)(struct super_block *,void *),
  305. int (*set)(struct super_block *,void *),
  306. void *data)
  307. {
  308. struct super_block *s = NULL;
  309. struct list_head *p;
  310. int err;
  311. retry:
  312. spin_lock(&sb_lock);
  313. if (test) list_for_each(p, &type->fs_supers) {
  314. struct super_block *old;
  315. old = list_entry(p, struct super_block, s_instances);
  316. if (!test(old, data))
  317. continue;
  318. if (!grab_super(old))
  319. goto retry;
  320. if (s)
  321. destroy_super(s);
  322. return old;
  323. }
  324. if (!s) {
  325. spin_unlock(&sb_lock);
  326. s = alloc_super(type);
  327. if (!s)
  328. return ERR_PTR(-ENOMEM);
  329. goto retry;
  330. }
  331. err = set(s, data);
  332. if (err) {
  333. spin_unlock(&sb_lock);
  334. destroy_super(s);
  335. return ERR_PTR(err);
  336. }
  337. s->s_type = type;
  338. strlcpy(s->s_id, type->name, sizeof(s->s_id));
  339. list_add_tail(&s->s_list, &super_blocks);
  340. list_add(&s->s_instances, &type->fs_supers);
  341. spin_unlock(&sb_lock);
  342. get_filesystem(type);
  343. return s;
  344. }
  345. EXPORT_SYMBOL(sget);
  346. void drop_super(struct super_block *sb)
  347. {
  348. up_read(&sb->s_umount);
  349. put_super(sb);
  350. }
  351. EXPORT_SYMBOL(drop_super);
  352. static inline void write_super(struct super_block *sb)
  353. {
  354. lock_super(sb);
  355. if (sb->s_root && sb->s_dirt)
  356. if (sb->s_op->write_super)
  357. sb->s_op->write_super(sb);
  358. unlock_super(sb);
  359. }
  360. /*
  361. * Note: check the dirty flag before waiting, so we don't
  362. * hold up the sync while mounting a device. (The newly
  363. * mounted device won't need syncing.)
  364. */
  365. void sync_supers(void)
  366. {
  367. struct super_block *sb;
  368. spin_lock(&sb_lock);
  369. restart:
  370. list_for_each_entry(sb, &super_blocks, s_list) {
  371. if (sb->s_dirt) {
  372. sb->s_count++;
  373. spin_unlock(&sb_lock);
  374. down_read(&sb->s_umount);
  375. write_super(sb);
  376. up_read(&sb->s_umount);
  377. spin_lock(&sb_lock);
  378. if (__put_super_and_need_restart(sb))
  379. goto restart;
  380. }
  381. }
  382. spin_unlock(&sb_lock);
  383. }
  384. /*
  385. * Call the ->sync_fs super_op against all filesytems which are r/w and
  386. * which implement it.
  387. *
  388. * This operation is careful to avoid the livelock which could easily happen
  389. * if two or more filesystems are being continuously dirtied. s_need_sync_fs
  390. * is used only here. We set it against all filesystems and then clear it as
  391. * we sync them. So redirtied filesystems are skipped.
  392. *
  393. * But if process A is currently running sync_filesytems and then process B
  394. * calls sync_filesystems as well, process B will set all the s_need_sync_fs
  395. * flags again, which will cause process A to resync everything. Fix that with
  396. * a local mutex.
  397. *
  398. * (Fabian) Avoid sync_fs with clean fs & wait mode 0
  399. */
  400. void sync_filesystems(int wait)
  401. {
  402. struct super_block *sb;
  403. static DEFINE_MUTEX(mutex);
  404. mutex_lock(&mutex); /* Could be down_interruptible */
  405. spin_lock(&sb_lock);
  406. list_for_each_entry(sb, &super_blocks, s_list) {
  407. if (!sb->s_op->sync_fs)
  408. continue;
  409. if (sb->s_flags & MS_RDONLY)
  410. continue;
  411. sb->s_need_sync_fs = 1;
  412. }
  413. restart:
  414. list_for_each_entry(sb, &super_blocks, s_list) {
  415. if (!sb->s_need_sync_fs)
  416. continue;
  417. sb->s_need_sync_fs = 0;
  418. if (sb->s_flags & MS_RDONLY)
  419. continue; /* hm. Was remounted r/o meanwhile */
  420. sb->s_count++;
  421. spin_unlock(&sb_lock);
  422. down_read(&sb->s_umount);
  423. if (sb->s_root && (wait || sb->s_dirt))
  424. sb->s_op->sync_fs(sb, wait);
  425. up_read(&sb->s_umount);
  426. /* restart only when sb is no longer on the list */
  427. spin_lock(&sb_lock);
  428. if (__put_super_and_need_restart(sb))
  429. goto restart;
  430. }
  431. spin_unlock(&sb_lock);
  432. mutex_unlock(&mutex);
  433. }
  434. /**
  435. * get_super - get the superblock of a device
  436. * @bdev: device to get the superblock for
  437. *
  438. * Scans the superblock list and finds the superblock of the file system
  439. * mounted on the device given. %NULL is returned if no match is found.
  440. */
  441. struct super_block * get_super(struct block_device *bdev)
  442. {
  443. struct super_block *sb;
  444. if (!bdev)
  445. return NULL;
  446. spin_lock(&sb_lock);
  447. rescan:
  448. list_for_each_entry(sb, &super_blocks, s_list) {
  449. if (sb->s_bdev == bdev) {
  450. sb->s_count++;
  451. spin_unlock(&sb_lock);
  452. down_read(&sb->s_umount);
  453. if (sb->s_root)
  454. return sb;
  455. up_read(&sb->s_umount);
  456. /* restart only when sb is no longer on the list */
  457. spin_lock(&sb_lock);
  458. if (__put_super_and_need_restart(sb))
  459. goto rescan;
  460. }
  461. }
  462. spin_unlock(&sb_lock);
  463. return NULL;
  464. }
  465. EXPORT_SYMBOL(get_super);
  466. struct super_block * user_get_super(dev_t dev)
  467. {
  468. struct super_block *sb;
  469. spin_lock(&sb_lock);
  470. rescan:
  471. list_for_each_entry(sb, &super_blocks, s_list) {
  472. if (sb->s_dev == dev) {
  473. sb->s_count++;
  474. spin_unlock(&sb_lock);
  475. down_read(&sb->s_umount);
  476. if (sb->s_root)
  477. return sb;
  478. up_read(&sb->s_umount);
  479. /* restart only when sb is no longer on the list */
  480. spin_lock(&sb_lock);
  481. if (__put_super_and_need_restart(sb))
  482. goto rescan;
  483. }
  484. }
  485. spin_unlock(&sb_lock);
  486. return NULL;
  487. }
  488. asmlinkage long sys_ustat(unsigned dev, struct ustat __user * ubuf)
  489. {
  490. struct super_block *s;
  491. struct ustat tmp;
  492. struct kstatfs sbuf;
  493. int err = -EINVAL;
  494. s = user_get_super(new_decode_dev(dev));
  495. if (s == NULL)
  496. goto out;
  497. err = vfs_statfs(s->s_root, &sbuf);
  498. drop_super(s);
  499. if (err)
  500. goto out;
  501. memset(&tmp,0,sizeof(struct ustat));
  502. tmp.f_tfree = sbuf.f_bfree;
  503. tmp.f_tinode = sbuf.f_ffree;
  504. err = copy_to_user(ubuf,&tmp,sizeof(struct ustat)) ? -EFAULT : 0;
  505. out:
  506. return err;
  507. }
  508. /**
  509. * mark_files_ro
  510. * @sb: superblock in question
  511. *
  512. * All files are marked read/only. We don't care about pending
  513. * delete files so this should be used in 'force' mode only
  514. */
  515. static void mark_files_ro(struct super_block *sb)
  516. {
  517. struct file *f;
  518. file_list_lock();
  519. list_for_each_entry(f, &sb->s_files, f_u.fu_list) {
  520. if (S_ISREG(f->f_path.dentry->d_inode->i_mode) && file_count(f))
  521. f->f_mode &= ~FMODE_WRITE;
  522. }
  523. file_list_unlock();
  524. }
  525. /**
  526. * do_remount_sb - asks filesystem to change mount options.
  527. * @sb: superblock in question
  528. * @flags: numeric part of options
  529. * @data: the rest of options
  530. * @force: whether or not to force the change
  531. *
  532. * Alters the mount options of a mounted file system.
  533. */
  534. int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
  535. {
  536. int retval;
  537. #ifdef CONFIG_BLOCK
  538. if (!(flags & MS_RDONLY) && bdev_read_only(sb->s_bdev))
  539. return -EACCES;
  540. #endif
  541. if (flags & MS_RDONLY)
  542. acct_auto_close(sb);
  543. shrink_dcache_sb(sb);
  544. fsync_super(sb);
  545. /* If we are remounting RDONLY and current sb is read/write,
  546. make sure there are no rw files opened */
  547. if ((flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY)) {
  548. if (force)
  549. mark_files_ro(sb);
  550. else if (!fs_may_remount_ro(sb))
  551. return -EBUSY;
  552. }
  553. if (sb->s_op->remount_fs) {
  554. lock_super(sb);
  555. retval = sb->s_op->remount_fs(sb, &flags, data);
  556. unlock_super(sb);
  557. if (retval)
  558. return retval;
  559. }
  560. sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);
  561. return 0;
  562. }
  563. static void do_emergency_remount(unsigned long foo)
  564. {
  565. struct super_block *sb;
  566. spin_lock(&sb_lock);
  567. list_for_each_entry(sb, &super_blocks, s_list) {
  568. sb->s_count++;
  569. spin_unlock(&sb_lock);
  570. down_read(&sb->s_umount);
  571. if (sb->s_root && sb->s_bdev && !(sb->s_flags & MS_RDONLY)) {
  572. /*
  573. * ->remount_fs needs lock_kernel().
  574. *
  575. * What lock protects sb->s_flags??
  576. */
  577. lock_kernel();
  578. do_remount_sb(sb, MS_RDONLY, NULL, 1);
  579. unlock_kernel();
  580. }
  581. drop_super(sb);
  582. spin_lock(&sb_lock);
  583. }
  584. spin_unlock(&sb_lock);
  585. printk("Emergency Remount complete\n");
  586. }
  587. void emergency_remount(void)
  588. {
  589. pdflush_operation(do_emergency_remount, 0);
  590. }
  591. /*
  592. * Unnamed block devices are dummy devices used by virtual
  593. * filesystems which don't use real block-devices. -- jrs
  594. */
  595. static struct idr unnamed_dev_idr;
  596. static DEFINE_SPINLOCK(unnamed_dev_lock);/* protects the above */
  597. int set_anon_super(struct super_block *s, void *data)
  598. {
  599. int dev;
  600. int error;
  601. retry:
  602. if (idr_pre_get(&unnamed_dev_idr, GFP_ATOMIC) == 0)
  603. return -ENOMEM;
  604. spin_lock(&unnamed_dev_lock);
  605. error = idr_get_new(&unnamed_dev_idr, NULL, &dev);
  606. spin_unlock(&unnamed_dev_lock);
  607. if (error == -EAGAIN)
  608. /* We raced and lost with another CPU. */
  609. goto retry;
  610. else if (error)
  611. return -EAGAIN;
  612. if ((dev & MAX_ID_MASK) == (1 << MINORBITS)) {
  613. spin_lock(&unnamed_dev_lock);
  614. idr_remove(&unnamed_dev_idr, dev);
  615. spin_unlock(&unnamed_dev_lock);
  616. return -EMFILE;
  617. }
  618. s->s_dev = MKDEV(0, dev & MINORMASK);
  619. return 0;
  620. }
  621. EXPORT_SYMBOL(set_anon_super);
  622. void kill_anon_super(struct super_block *sb)
  623. {
  624. int slot = MINOR(sb->s_dev);
  625. generic_shutdown_super(sb);
  626. spin_lock(&unnamed_dev_lock);
  627. idr_remove(&unnamed_dev_idr, slot);
  628. spin_unlock(&unnamed_dev_lock);
  629. }
  630. EXPORT_SYMBOL(kill_anon_super);
  631. void __init unnamed_dev_init(void)
  632. {
  633. idr_init(&unnamed_dev_idr);
  634. }
  635. void kill_litter_super(struct super_block *sb)
  636. {
  637. if (sb->s_root)
  638. d_genocide(sb->s_root);
  639. kill_anon_super(sb);
  640. }
  641. EXPORT_SYMBOL(kill_litter_super);
  642. #ifdef CONFIG_BLOCK
  643. static int set_bdev_super(struct super_block *s, void *data)
  644. {
  645. s->s_bdev = data;
  646. s->s_dev = s->s_bdev->bd_dev;
  647. return 0;
  648. }
  649. static int test_bdev_super(struct super_block *s, void *data)
  650. {
  651. return (void *)s->s_bdev == data;
  652. }
  653. static void bdev_uevent(struct block_device *bdev, enum kobject_action action)
  654. {
  655. if (bdev->bd_disk) {
  656. if (bdev->bd_part)
  657. kobject_uevent(&bdev->bd_part->kobj, action);
  658. else
  659. kobject_uevent(&bdev->bd_disk->kobj, action);
  660. }
  661. }
  662. int get_sb_bdev(struct file_system_type *fs_type,
  663. int flags, const char *dev_name, void *data,
  664. int (*fill_super)(struct super_block *, void *, int),
  665. struct vfsmount *mnt)
  666. {
  667. struct block_device *bdev;
  668. struct super_block *s;
  669. int error = 0;
  670. bdev = open_bdev_excl(dev_name, flags, fs_type);
  671. if (IS_ERR(bdev))
  672. return PTR_ERR(bdev);
  673. /*
  674. * once the super is inserted into the list by sget, s_umount
  675. * will protect the lockfs code from trying to start a snapshot
  676. * while we are mounting
  677. */
  678. down(&bdev->bd_mount_sem);
  679. s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
  680. up(&bdev->bd_mount_sem);
  681. if (IS_ERR(s))
  682. goto error_s;
  683. if (s->s_root) {
  684. if ((flags ^ s->s_flags) & MS_RDONLY) {
  685. up_write(&s->s_umount);
  686. deactivate_super(s);
  687. error = -EBUSY;
  688. goto error_bdev;
  689. }
  690. close_bdev_excl(bdev);
  691. } else {
  692. char b[BDEVNAME_SIZE];
  693. s->s_flags = flags;
  694. strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
  695. sb_set_blocksize(s, block_size(bdev));
  696. error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
  697. if (error) {
  698. up_write(&s->s_umount);
  699. deactivate_super(s);
  700. goto error;
  701. }
  702. s->s_flags |= MS_ACTIVE;
  703. bdev_uevent(bdev, KOBJ_MOUNT);
  704. }
  705. return simple_set_mnt(mnt, s);
  706. error_s:
  707. error = PTR_ERR(s);
  708. error_bdev:
  709. close_bdev_excl(bdev);
  710. error:
  711. return error;
  712. }
  713. EXPORT_SYMBOL(get_sb_bdev);
  714. void kill_block_super(struct super_block *sb)
  715. {
  716. struct block_device *bdev = sb->s_bdev;
  717. bdev_uevent(bdev, KOBJ_UMOUNT);
  718. generic_shutdown_super(sb);
  719. sync_blockdev(bdev);
  720. close_bdev_excl(bdev);
  721. }
  722. EXPORT_SYMBOL(kill_block_super);
  723. #endif
  724. int get_sb_nodev(struct file_system_type *fs_type,
  725. int flags, void *data,
  726. int (*fill_super)(struct super_block *, void *, int),
  727. struct vfsmount *mnt)
  728. {
  729. int error;
  730. struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
  731. if (IS_ERR(s))
  732. return PTR_ERR(s);
  733. s->s_flags = flags;
  734. error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
  735. if (error) {
  736. up_write(&s->s_umount);
  737. deactivate_super(s);
  738. return error;
  739. }
  740. s->s_flags |= MS_ACTIVE;
  741. return simple_set_mnt(mnt, s);
  742. }
  743. EXPORT_SYMBOL(get_sb_nodev);
  744. static int compare_single(struct super_block *s, void *p)
  745. {
  746. return 1;
  747. }
  748. int get_sb_single(struct file_system_type *fs_type,
  749. int flags, void *data,
  750. int (*fill_super)(struct super_block *, void *, int),
  751. struct vfsmount *mnt)
  752. {
  753. struct super_block *s;
  754. int error;
  755. s = sget(fs_type, compare_single, set_anon_super, NULL);
  756. if (IS_ERR(s))
  757. return PTR_ERR(s);
  758. if (!s->s_root) {
  759. s->s_flags = flags;
  760. error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
  761. if (error) {
  762. up_write(&s->s_umount);
  763. deactivate_super(s);
  764. return error;
  765. }
  766. s->s_flags |= MS_ACTIVE;
  767. }
  768. do_remount_sb(s, flags, data, 0);
  769. return simple_set_mnt(mnt, s);
  770. }
  771. EXPORT_SYMBOL(get_sb_single);
  772. struct vfsmount *
  773. vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
  774. {
  775. struct vfsmount *mnt;
  776. char *secdata = NULL;
  777. int error;
  778. if (!type)
  779. return ERR_PTR(-ENODEV);
  780. error = -ENOMEM;
  781. mnt = alloc_vfsmnt(name);
  782. if (!mnt)
  783. goto out;
  784. if (data) {
  785. secdata = alloc_secdata();
  786. if (!secdata)
  787. goto out_mnt;
  788. error = security_sb_copy_data(type, data, secdata);
  789. if (error)
  790. goto out_free_secdata;
  791. }
  792. error = type->get_sb(type, flags, name, data, mnt);
  793. if (error < 0)
  794. goto out_free_secdata;
  795. error = security_sb_kern_mount(mnt->mnt_sb, secdata);
  796. if (error)
  797. goto out_sb;
  798. mnt->mnt_mountpoint = mnt->mnt_root;
  799. mnt->mnt_parent = mnt;
  800. up_write(&mnt->mnt_sb->s_umount);
  801. free_secdata(secdata);
  802. return mnt;
  803. out_sb:
  804. dput(mnt->mnt_root);
  805. up_write(&mnt->mnt_sb->s_umount);
  806. deactivate_super(mnt->mnt_sb);
  807. out_free_secdata:
  808. free_secdata(secdata);
  809. out_mnt:
  810. free_vfsmnt(mnt);
  811. out:
  812. return ERR_PTR(error);
  813. }
  814. EXPORT_SYMBOL_GPL(vfs_kern_mount);
  815. struct vfsmount *
  816. do_kern_mount(const char *fstype, int flags, const char *name, void *data)
  817. {
  818. struct file_system_type *type = get_fs_type(fstype);
  819. struct vfsmount *mnt;
  820. if (!type)
  821. return ERR_PTR(-ENODEV);
  822. mnt = vfs_kern_mount(type, flags, name, data);
  823. put_filesystem(type);
  824. return mnt;
  825. }
  826. struct vfsmount *kern_mount(struct file_system_type *type)
  827. {
  828. return vfs_kern_mount(type, 0, type->name, NULL);
  829. }
  830. EXPORT_SYMBOL(kern_mount);