super.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688
  1. #include <linux/module.h>
  2. #include <linux/buffer_head.h>
  3. #include <linux/fs.h>
  4. #include <linux/pagemap.h>
  5. #include <linux/highmem.h>
  6. #include <linux/time.h>
  7. #include <linux/init.h>
  8. #include <linux/string.h>
  9. #include <linux/smp_lock.h>
  10. #include <linux/backing-dev.h>
  11. #include "ctree.h"
  12. #include "disk-io.h"
  13. #include "transaction.h"
  14. #define BTRFS_SUPER_MAGIC 0x9123682E
  15. static struct inode_operations btrfs_dir_inode_operations;
  16. static struct super_operations btrfs_super_ops;
  17. static struct file_operations btrfs_dir_file_operations;
  18. #if 0
  19. /* some random number */
  20. static struct super_operations ramfs_ops;
  21. static struct backing_dev_info ramfs_backing_dev_info = {
  22. .ra_pages = 0, /* No readahead */
  23. .capabilities = BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_WRITEBACK |
  24. BDI_CAP_MAP_DIRECT | BDI_CAP_MAP_COPY |
  25. BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP,
  26. };
  27. struct inode *ramfs_get_inode(struct super_block *sb, int mode, dev_t dev)
  28. {
  29. struct inode * inode = new_inode(sb);
  30. if (inode) {
  31. inode->i_mode = mode;
  32. inode->i_uid = current->fsuid;
  33. inode->i_gid = current->fsgid;
  34. inode->i_blocks = 0;
  35. inode->i_mapping->a_ops = &ramfs_aops;
  36. inode->i_mapping->backing_dev_info = &ramfs_backing_dev_info;
  37. inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
  38. switch (mode & S_IFMT) {
  39. default:
  40. init_special_inode(inode, mode, dev);
  41. break;
  42. case S_IFREG:
  43. inode->i_op = &ramfs_file_inode_operations;
  44. inode->i_fop = &ramfs_file_operations;
  45. break;
  46. case S_IFDIR:
  47. inode->i_op = &ramfs_dir_inode_operations;
  48. inode->i_fop = &simple_dir_operations;
  49. /* directory inodes start off with i_nlink == 2 (for "." entry) */
  50. inc_nlink(inode);
  51. break;
  52. case S_IFLNK:
  53. inode->i_op = &page_symlink_inode_operations;
  54. break;
  55. }
  56. }
  57. return inode;
  58. }
  59. /*
  60. * File creation. Allocate an inode, and we're done..
  61. */
  62. /* SMP-safe */
  63. static int
  64. ramfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
  65. {
  66. struct inode * inode = ramfs_get_inode(dir->i_sb, mode, dev);
  67. int error = -ENOSPC;
  68. if (inode) {
  69. if (dir->i_mode & S_ISGID) {
  70. inode->i_gid = dir->i_gid;
  71. if (S_ISDIR(mode))
  72. inode->i_mode |= S_ISGID;
  73. }
  74. d_instantiate(dentry, inode);
  75. dget(dentry); /* Extra count - pin the dentry in core */
  76. error = 0;
  77. dir->i_mtime = dir->i_ctime = CURRENT_TIME;
  78. }
  79. return error;
  80. }
  81. static int ramfs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
  82. {
  83. int retval = ramfs_mknod(dir, dentry, mode | S_IFDIR, 0);
  84. if (!retval)
  85. inc_nlink(dir);
  86. return retval;
  87. }
  88. static int ramfs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
  89. {
  90. return ramfs_mknod(dir, dentry, mode | S_IFREG, 0);
  91. }
  92. static int ramfs_symlink(struct inode * dir, struct dentry *dentry, const char * symname)
  93. {
  94. struct inode *inode;
  95. int error = -ENOSPC;
  96. inode = ramfs_get_inode(dir->i_sb, S_IFLNK|S_IRWXUGO, 0);
  97. if (inode) {
  98. int l = strlen(symname)+1;
  99. error = page_symlink(inode, symname, l);
  100. if (!error) {
  101. if (dir->i_mode & S_ISGID)
  102. inode->i_gid = dir->i_gid;
  103. d_instantiate(dentry, inode);
  104. dget(dentry);
  105. dir->i_mtime = dir->i_ctime = CURRENT_TIME;
  106. } else
  107. iput(inode);
  108. }
  109. return error;
  110. }
  111. static struct inode_operations ramfs_dir_inode_operations = {
  112. .create = ramfs_create,
  113. .lookup = simple_lookup,
  114. .link = simple_link,
  115. .unlink = simple_unlink,
  116. .symlink = ramfs_symlink,
  117. .mkdir = ramfs_mkdir,
  118. .rmdir = simple_rmdir,
  119. .mknod = ramfs_mknod,
  120. .rename = simple_rename,
  121. };
  122. #endif
  123. static void btrfs_read_locked_inode(struct inode *inode)
  124. {
  125. struct btrfs_path path;
  126. struct btrfs_inode_item *inode_item;
  127. struct btrfs_root *root = btrfs_sb(inode->i_sb);
  128. int ret;
  129. btrfs_init_path(&path);
  130. ret = btrfs_lookup_inode(NULL, root, &path, inode->i_ino, 0);
  131. if (ret) {
  132. make_bad_inode(inode);
  133. btrfs_release_path(root, &path);
  134. return;
  135. }
  136. inode_item = btrfs_item_ptr(btrfs_buffer_leaf(path.nodes[0]),
  137. path.slots[0],
  138. struct btrfs_inode_item);
  139. inode->i_mode = btrfs_inode_mode(inode_item);
  140. inode->i_nlink = btrfs_inode_nlink(inode_item);
  141. inode->i_uid = btrfs_inode_uid(inode_item);
  142. inode->i_gid = btrfs_inode_gid(inode_item);
  143. inode->i_size = btrfs_inode_size(inode_item);
  144. inode->i_atime.tv_sec = btrfs_timespec_sec(&inode_item->atime);
  145. inode->i_atime.tv_nsec = btrfs_timespec_nsec(&inode_item->atime);
  146. inode->i_mtime.tv_sec = btrfs_timespec_sec(&inode_item->mtime);
  147. inode->i_mtime.tv_nsec = btrfs_timespec_nsec(&inode_item->mtime);
  148. inode->i_ctime.tv_sec = btrfs_timespec_sec(&inode_item->ctime);
  149. inode->i_ctime.tv_nsec = btrfs_timespec_nsec(&inode_item->ctime);
  150. inode->i_blocks = btrfs_inode_nblocks(inode_item);
  151. inode->i_generation = btrfs_inode_generation(inode_item);
  152. btrfs_release_path(root, &path);
  153. switch (inode->i_mode & S_IFMT) {
  154. #if 0
  155. default:
  156. init_special_inode(inode, inode->i_mode,
  157. btrfs_inode_rdev(inode_item));
  158. break;
  159. #endif
  160. case S_IFREG:
  161. break;
  162. case S_IFDIR:
  163. inode->i_op = &btrfs_dir_inode_operations;
  164. inode->i_fop = &btrfs_dir_file_operations;
  165. break;
  166. case S_IFLNK:
  167. // inode->i_op = &page_symlink_inode_operations;
  168. break;
  169. }
  170. return;
  171. }
  172. static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
  173. {
  174. struct btrfs_path path;
  175. struct btrfs_root *root;
  176. struct btrfs_trans_handle *trans;
  177. const char *name = dentry->d_name.name;
  178. int name_len = dentry->d_name.len;
  179. int ret;
  180. u64 objectid;
  181. struct btrfs_dir_item *di;
  182. btrfs_init_path(&path);
  183. root = btrfs_sb(dir->i_sb);
  184. mutex_lock(&root->fs_info->fs_mutex);
  185. trans = btrfs_start_transaction(root, 1);
  186. ret = btrfs_lookup_dir_item(trans, root, &path, dir->i_ino,
  187. name, name_len, -1);
  188. if (ret < 0)
  189. goto err;
  190. if (ret > 0) {
  191. ret = -ENOENT;
  192. goto err;
  193. }
  194. di = btrfs_item_ptr(btrfs_buffer_leaf(path.nodes[0]), path.slots[0],
  195. struct btrfs_dir_item);
  196. objectid = btrfs_dir_objectid(di);
  197. ret = btrfs_del_item(trans, root, &path);
  198. BUG_ON(ret);
  199. dentry->d_inode->i_ctime = dir->i_ctime;
  200. err:
  201. btrfs_release_path(root, &path);
  202. btrfs_end_transaction(trans, root);
  203. mutex_unlock(&root->fs_info->fs_mutex);
  204. if (ret == 0)
  205. inode_dec_link_count(dentry->d_inode);
  206. return ret;
  207. }
  208. static int btrfs_free_inode(struct btrfs_trans_handle *trans,
  209. struct btrfs_root *root,
  210. struct inode *inode)
  211. {
  212. u64 objectid = inode->i_ino;
  213. struct btrfs_path path;
  214. struct btrfs_inode_map_item *map;
  215. struct btrfs_key stat_data_key;
  216. int ret;
  217. clear_inode(inode);
  218. btrfs_init_path(&path);
  219. ret = btrfs_lookup_inode_map(trans, root, &path, objectid, -1);
  220. if (ret) {
  221. if (ret > 0)
  222. ret = -ENOENT;
  223. btrfs_release_path(root, &path);
  224. goto error;
  225. }
  226. map = btrfs_item_ptr(btrfs_buffer_leaf(path.nodes[0]), path.slots[0],
  227. struct btrfs_inode_map_item);
  228. btrfs_disk_key_to_cpu(&stat_data_key, &map->key);
  229. ret = btrfs_del_item(trans, root->fs_info->inode_root, &path);
  230. BUG_ON(ret);
  231. btrfs_release_path(root, &path);
  232. btrfs_init_path(&path);
  233. ret = btrfs_lookup_inode(trans, root, &path, objectid, -1);
  234. BUG_ON(ret);
  235. ret = btrfs_del_item(trans, root, &path);
  236. BUG_ON(ret);
  237. btrfs_release_path(root, &path);
  238. error:
  239. return ret;
  240. }
  241. static void btrfs_delete_inode(struct inode *inode)
  242. {
  243. struct btrfs_trans_handle *trans;
  244. struct btrfs_root *root = btrfs_sb(inode->i_sb);
  245. truncate_inode_pages(&inode->i_data, 0);
  246. if (is_bad_inode(inode)) {
  247. goto no_delete;
  248. }
  249. inode->i_size = 0;
  250. if (inode->i_blocks)
  251. WARN_ON(1);
  252. mutex_lock(&root->fs_info->fs_mutex);
  253. trans = btrfs_start_transaction(root, 1);
  254. btrfs_free_inode(trans, root, inode);
  255. btrfs_end_transaction(trans, root);
  256. mutex_unlock(&root->fs_info->fs_mutex);
  257. return;
  258. no_delete:
  259. clear_inode(inode);
  260. }
  261. static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
  262. ino_t *ino)
  263. {
  264. const char *name = dentry->d_name.name;
  265. int namelen = dentry->d_name.len;
  266. struct btrfs_dir_item *di;
  267. struct btrfs_path path;
  268. struct btrfs_root *root = btrfs_sb(dir->i_sb);
  269. int ret;
  270. btrfs_init_path(&path);
  271. ret = btrfs_lookup_dir_item(NULL, root, &path, dir->i_ino, name,
  272. namelen, 0);
  273. if (ret || !btrfs_match_dir_item_name(root, &path, name, namelen)) {
  274. *ino = 0;
  275. goto out;
  276. }
  277. di = btrfs_item_ptr(btrfs_buffer_leaf(path.nodes[0]), path.slots[0],
  278. struct btrfs_dir_item);
  279. *ino = btrfs_dir_objectid(di);
  280. out:
  281. btrfs_release_path(root, &path);
  282. return ret;
  283. }
  284. static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
  285. struct nameidata *nd)
  286. {
  287. struct inode * inode;
  288. ino_t ino;
  289. int ret;
  290. if (dentry->d_name.len > BTRFS_NAME_LEN)
  291. return ERR_PTR(-ENAMETOOLONG);
  292. ret = btrfs_inode_by_name(dir, dentry, &ino);
  293. if (ret < 0)
  294. return ERR_PTR(ret);
  295. inode = NULL;
  296. if (ino) {
  297. inode = iget(dir->i_sb, ino);
  298. if (!inode)
  299. return ERR_PTR(-EACCES);
  300. }
  301. return d_splice_alias(inode, dentry);
  302. }
  303. static void reada_leaves(struct btrfs_root *root, struct btrfs_path *path)
  304. {
  305. struct buffer_head *bh;
  306. struct btrfs_node *node;
  307. int i;
  308. int nritems;
  309. u64 objectid;
  310. u64 item_objectid;
  311. u64 blocknr;
  312. int slot;
  313. if (!path->nodes[1])
  314. return;
  315. node = btrfs_buffer_node(path->nodes[1]);
  316. slot = path->slots[1];
  317. objectid = btrfs_disk_key_objectid(&node->ptrs[slot].key);
  318. nritems = btrfs_header_nritems(&node->header);
  319. for (i = slot; i < nritems; i++) {
  320. item_objectid = btrfs_disk_key_objectid(&node->ptrs[i].key);
  321. if (item_objectid != objectid)
  322. break;
  323. blocknr = btrfs_node_blockptr(node, i);
  324. bh = sb_getblk(root->fs_info->sb, blocknr);
  325. ll_rw_block(READ, 1, &bh);
  326. brelse(bh);
  327. }
  328. }
  329. static int btrfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
  330. {
  331. struct inode *inode = filp->f_path.dentry->d_inode;
  332. struct btrfs_root *root = btrfs_sb(inode->i_sb);
  333. struct btrfs_item *item;
  334. struct btrfs_dir_item *di;
  335. struct btrfs_key key;
  336. struct btrfs_path path;
  337. int ret;
  338. u32 nritems;
  339. struct btrfs_leaf *leaf;
  340. int slot;
  341. int advance;
  342. unsigned char d_type = DT_UNKNOWN;
  343. int over = 0;
  344. key.objectid = inode->i_ino;
  345. key.flags = 0;
  346. btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
  347. key.offset = filp->f_pos;
  348. btrfs_init_path(&path);
  349. ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
  350. if (ret < 0) {
  351. goto err;
  352. }
  353. advance = 0;
  354. reada_leaves(root, &path);
  355. while(1) {
  356. leaf = btrfs_buffer_leaf(path.nodes[0]);
  357. nritems = btrfs_header_nritems(&leaf->header);
  358. slot = path.slots[0];
  359. if (advance) {
  360. if (slot == nritems -1) {
  361. ret = btrfs_next_leaf(root, &path);
  362. if (ret)
  363. break;
  364. leaf = btrfs_buffer_leaf(path.nodes[0]);
  365. nritems = btrfs_header_nritems(&leaf->header);
  366. slot = path.slots[0];
  367. if (path.nodes[1] && path.slots[1] == 0)
  368. reada_leaves(root, &path);
  369. } else {
  370. slot++;
  371. path.slots[0]++;
  372. }
  373. }
  374. advance = 1;
  375. item = leaf->items + slot;
  376. if (btrfs_disk_key_objectid(&item->key) != key.objectid)
  377. break;
  378. if (btrfs_disk_key_type(&item->key) != BTRFS_DIR_ITEM_KEY)
  379. continue;
  380. if (btrfs_disk_key_offset(&item->key) < filp->f_pos)
  381. continue;
  382. di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
  383. over = filldir(dirent, (const char *)(di + 1),
  384. btrfs_dir_name_len(di),
  385. btrfs_disk_key_offset(&item->key),
  386. btrfs_dir_objectid(di), d_type);
  387. if (over) {
  388. filp->f_pos = btrfs_disk_key_offset(&item->key);
  389. break;
  390. }
  391. filp->f_pos = btrfs_disk_key_offset(&item->key) + 1;
  392. }
  393. ret = 0;
  394. err:
  395. btrfs_release_path(root, &path);
  396. return ret;
  397. }
  398. static void btrfs_put_super (struct super_block * sb)
  399. {
  400. struct btrfs_root *root = btrfs_sb(sb);
  401. int ret;
  402. ret = close_ctree(root);
  403. if (ret) {
  404. printk("close ctree returns %d\n", ret);
  405. }
  406. sb->s_fs_info = NULL;
  407. }
  408. static int btrfs_fill_super(struct super_block * sb, void * data, int silent)
  409. {
  410. struct inode * inode;
  411. struct dentry * root_dentry;
  412. struct btrfs_super_block *disk_super;
  413. struct buffer_head *bh;
  414. struct btrfs_root *root;
  415. sb->s_maxbytes = MAX_LFS_FILESIZE;
  416. sb->s_blocksize = PAGE_CACHE_SIZE;
  417. sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
  418. sb->s_magic = BTRFS_SUPER_MAGIC;
  419. sb->s_op = &btrfs_super_ops;
  420. sb->s_time_gran = 1;
  421. bh = sb_bread(sb, BTRFS_SUPER_INFO_OFFSET / sb->s_blocksize);
  422. if (!bh) {
  423. printk("btrfs: unable to read on disk super\n");
  424. return -EIO;
  425. }
  426. disk_super = (struct btrfs_super_block *)bh->b_data;
  427. root = open_ctree(sb, bh, disk_super);
  428. sb->s_fs_info = root;
  429. if (!root) {
  430. printk("btrfs: open_ctree failed\n");
  431. return -EIO;
  432. }
  433. printk("read in super total blocks %Lu root %Lu\n",
  434. btrfs_super_total_blocks(disk_super),
  435. btrfs_super_root_dir(disk_super));
  436. inode = iget_locked(sb, btrfs_super_root_dir(disk_super));
  437. if (!inode)
  438. return -ENOMEM;
  439. if (inode->i_state & I_NEW) {
  440. btrfs_read_locked_inode(inode);
  441. unlock_new_inode(inode);
  442. }
  443. root_dentry = d_alloc_root(inode);
  444. if (!root_dentry) {
  445. iput(inode);
  446. return -ENOMEM;
  447. }
  448. sb->s_root = root_dentry;
  449. return 0;
  450. }
  451. static void fill_inode_item(struct btrfs_inode_item *item,
  452. struct inode *inode)
  453. {
  454. btrfs_set_inode_uid(item, inode->i_uid);
  455. btrfs_set_inode_gid(item, inode->i_gid);
  456. btrfs_set_inode_size(item, inode->i_size);
  457. btrfs_set_inode_mode(item, inode->i_mode);
  458. btrfs_set_inode_nlink(item, inode->i_nlink);
  459. btrfs_set_timespec_sec(&item->atime, inode->i_atime.tv_sec);
  460. btrfs_set_timespec_nsec(&item->atime, inode->i_atime.tv_nsec);
  461. btrfs_set_timespec_sec(&item->mtime, inode->i_mtime.tv_sec);
  462. btrfs_set_timespec_nsec(&item->mtime, inode->i_mtime.tv_nsec);
  463. btrfs_set_timespec_sec(&item->ctime, inode->i_ctime.tv_sec);
  464. btrfs_set_timespec_nsec(&item->ctime, inode->i_ctime.tv_nsec);
  465. btrfs_set_inode_nblocks(item, inode->i_blocks);
  466. btrfs_set_inode_generation(item, inode->i_generation);
  467. }
  468. static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
  469. struct inode *dir, int mode)
  470. {
  471. struct inode *inode;
  472. struct btrfs_inode_item inode_item;
  473. struct btrfs_root *root = btrfs_sb(dir->i_sb);
  474. struct btrfs_key key;
  475. int ret;
  476. u64 objectid;
  477. inode = new_inode(dir->i_sb);
  478. if (!inode)
  479. return ERR_PTR(-ENOMEM);
  480. ret = btrfs_find_free_objectid(trans, root, dir->i_ino, &objectid);
  481. BUG_ON(ret);
  482. inode->i_uid = current->fsuid;
  483. inode->i_gid = current->fsgid;
  484. inode->i_mode = mode;
  485. inode->i_ino = objectid;
  486. inode->i_blocks = 0;
  487. inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
  488. fill_inode_item(&inode_item, inode);
  489. key.objectid = objectid;
  490. key.flags = 0;
  491. key.offset = 0;
  492. btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
  493. ret = btrfs_insert_inode_map(trans, root, objectid, &key);
  494. BUG_ON(ret);
  495. ret = btrfs_insert_inode(trans, root, objectid, &inode_item);
  496. BUG_ON(ret);
  497. insert_inode_hash(inode);
  498. // FIXME mark_inode_dirty(inode)
  499. return inode;
  500. }
  501. static int btrfs_add_link(struct btrfs_trans_handle *trans,
  502. struct dentry *dentry, struct inode *inode)
  503. {
  504. int ret;
  505. ret = btrfs_insert_dir_item(trans, btrfs_sb(inode->i_sb),
  506. dentry->d_name.name, dentry->d_name.len,
  507. dentry->d_parent->d_inode->i_ino,
  508. inode->i_ino, 0);
  509. return ret;
  510. }
  511. static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
  512. struct dentry *dentry, struct inode *inode)
  513. {
  514. int err = btrfs_add_link(trans, dentry, inode);
  515. if (!err) {
  516. d_instantiate(dentry, inode);
  517. return 0;
  518. }
  519. return err;
  520. }
  521. static int btrfs_create(struct inode *dir, struct dentry *dentry,
  522. int mode, struct nameidata *nd)
  523. {
  524. struct btrfs_trans_handle *trans;
  525. struct btrfs_root *root = btrfs_sb(dir->i_sb);
  526. struct inode *inode;
  527. int err;
  528. int drop_inode = 0;
  529. mutex_lock(&root->fs_info->fs_mutex);
  530. trans = btrfs_start_transaction(root, 1);
  531. inode = btrfs_new_inode(trans, dir, mode);
  532. err = PTR_ERR(inode);
  533. if (IS_ERR(inode))
  534. goto out_unlock;
  535. // FIXME mark the inode dirty
  536. err = btrfs_add_nondir(trans, dentry, inode);
  537. if (err)
  538. drop_inode = 1;
  539. dir->i_sb->s_dirt = 1;
  540. btrfs_end_transaction(trans, root);
  541. out_unlock:
  542. mutex_unlock(&root->fs_info->fs_mutex);
  543. if (drop_inode) {
  544. inode_dec_link_count(inode);
  545. iput(inode);
  546. }
  547. return err;
  548. }
  549. static int btrfs_sync_fs(struct super_block *sb, int wait)
  550. {
  551. struct btrfs_trans_handle *trans;
  552. struct btrfs_root *root;
  553. int ret;
  554. sb->s_dirt = 0;
  555. if (!wait) {
  556. filemap_flush(sb->s_bdev->bd_inode->i_mapping);
  557. return 0;
  558. }
  559. filemap_write_and_wait(sb->s_bdev->bd_inode->i_mapping);
  560. root = btrfs_sb(sb);
  561. mutex_lock(&root->fs_info->fs_mutex);
  562. trans = btrfs_start_transaction(root, 1);
  563. ret = btrfs_commit_transaction(trans, root);
  564. sb->s_dirt = 0;
  565. BUG_ON(ret);
  566. printk("btrfs sync_fs\n");
  567. mutex_unlock(&root->fs_info->fs_mutex);
  568. return 0;
  569. }
  570. static void btrfs_write_super(struct super_block *sb)
  571. {
  572. btrfs_sync_fs(sb, 1);
  573. }
  574. static int btrfs_get_sb(struct file_system_type *fs_type,
  575. int flags, const char *dev_name, void *data, struct vfsmount *mnt)
  576. {
  577. return get_sb_bdev(fs_type, flags, dev_name, data,
  578. btrfs_fill_super, mnt);
  579. }
  580. static struct file_system_type btrfs_fs_type = {
  581. .owner = THIS_MODULE,
  582. .name = "btrfs",
  583. .get_sb = btrfs_get_sb,
  584. .kill_sb = kill_block_super,
  585. .fs_flags = FS_REQUIRES_DEV,
  586. };
  587. static struct super_operations btrfs_super_ops = {
  588. .statfs = simple_statfs,
  589. .delete_inode = btrfs_delete_inode,
  590. .put_super = btrfs_put_super,
  591. .read_inode = btrfs_read_locked_inode,
  592. .write_super = btrfs_write_super,
  593. .sync_fs = btrfs_sync_fs,
  594. };
  595. static struct inode_operations btrfs_dir_inode_operations = {
  596. .lookup = btrfs_lookup,
  597. .create = btrfs_create,
  598. .unlink = btrfs_unlink,
  599. };
  600. static struct file_operations btrfs_dir_file_operations = {
  601. .llseek = generic_file_llseek,
  602. .read = generic_read_dir,
  603. .readdir = btrfs_readdir,
  604. };
  605. static int __init init_btrfs_fs(void)
  606. {
  607. printk("btrfs loaded!\n");
  608. return register_filesystem(&btrfs_fs_type);
  609. }
  610. static void __exit exit_btrfs_fs(void)
  611. {
  612. unregister_filesystem(&btrfs_fs_type);
  613. printk("btrfs unloaded\n");
  614. }
  615. module_init(init_btrfs_fs)
  616. module_exit(exit_btrfs_fs)
  617. MODULE_LICENSE("GPL");