delayed-inode.c 52 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (C) 2011 Fujitsu. All rights reserved.
  4. * Written by Miao Xie <miaox@cn.fujitsu.com>
  5. */
  6. #include <linux/slab.h>
  7. #include <linux/iversion.h>
  8. #include <linux/sched/mm.h>
  9. #include "misc.h"
  10. #include "delayed-inode.h"
  11. #include "disk-io.h"
  12. #include "transaction.h"
  13. #include "ctree.h"
  14. #include "qgroup.h"
  15. #include "locking.h"
  16. #define BTRFS_DELAYED_WRITEBACK 512
  17. #define BTRFS_DELAYED_BACKGROUND 128
  18. #define BTRFS_DELAYED_BATCH 16
  19. static struct kmem_cache *delayed_node_cache;
  20. int __init btrfs_delayed_inode_init(void)
  21. {
  22. delayed_node_cache = kmem_cache_create("btrfs_delayed_node",
  23. sizeof(struct btrfs_delayed_node),
  24. 0,
  25. SLAB_MEM_SPREAD,
  26. NULL);
  27. if (!delayed_node_cache)
  28. return -ENOMEM;
  29. return 0;
  30. }
  31. void __cold btrfs_delayed_inode_exit(void)
  32. {
  33. kmem_cache_destroy(delayed_node_cache);
  34. }
  35. static inline void btrfs_init_delayed_node(
  36. struct btrfs_delayed_node *delayed_node,
  37. struct btrfs_root *root, u64 inode_id)
  38. {
  39. delayed_node->root = root;
  40. delayed_node->inode_id = inode_id;
  41. refcount_set(&delayed_node->refs, 0);
  42. delayed_node->ins_root = RB_ROOT_CACHED;
  43. delayed_node->del_root = RB_ROOT_CACHED;
  44. mutex_init(&delayed_node->mutex);
  45. INIT_LIST_HEAD(&delayed_node->n_list);
  46. INIT_LIST_HEAD(&delayed_node->p_list);
  47. }
  48. static inline int btrfs_is_continuous_delayed_item(
  49. struct btrfs_delayed_item *item1,
  50. struct btrfs_delayed_item *item2)
  51. {
  52. if (item1->key.type == BTRFS_DIR_INDEX_KEY &&
  53. item1->key.objectid == item2->key.objectid &&
  54. item1->key.type == item2->key.type &&
  55. item1->key.offset + 1 == item2->key.offset)
  56. return 1;
  57. return 0;
  58. }
  59. static struct btrfs_delayed_node *btrfs_get_delayed_node(
  60. struct btrfs_inode *btrfs_inode)
  61. {
  62. struct btrfs_root *root = btrfs_inode->root;
  63. u64 ino = btrfs_ino(btrfs_inode);
  64. struct btrfs_delayed_node *node;
  65. node = READ_ONCE(btrfs_inode->delayed_node);
  66. if (node) {
  67. refcount_inc(&node->refs);
  68. return node;
  69. }
  70. spin_lock(&root->inode_lock);
  71. node = radix_tree_lookup(&root->delayed_nodes_tree, ino);
  72. if (node) {
  73. if (btrfs_inode->delayed_node) {
  74. refcount_inc(&node->refs); /* can be accessed */
  75. BUG_ON(btrfs_inode->delayed_node != node);
  76. spin_unlock(&root->inode_lock);
  77. return node;
  78. }
  79. /*
  80. * It's possible that we're racing into the middle of removing
  81. * this node from the radix tree. In this case, the refcount
  82. * was zero and it should never go back to one. Just return
  83. * NULL like it was never in the radix at all; our release
  84. * function is in the process of removing it.
  85. *
  86. * Some implementations of refcount_inc refuse to bump the
  87. * refcount once it has hit zero. If we don't do this dance
  88. * here, refcount_inc() may decide to just WARN_ONCE() instead
  89. * of actually bumping the refcount.
  90. *
  91. * If this node is properly in the radix, we want to bump the
  92. * refcount twice, once for the inode and once for this get
  93. * operation.
  94. */
  95. if (refcount_inc_not_zero(&node->refs)) {
  96. refcount_inc(&node->refs);
  97. btrfs_inode->delayed_node = node;
  98. } else {
  99. node = NULL;
  100. }
  101. spin_unlock(&root->inode_lock);
  102. return node;
  103. }
  104. spin_unlock(&root->inode_lock);
  105. return NULL;
  106. }
  107. /* Will return either the node or PTR_ERR(-ENOMEM) */
  108. static struct btrfs_delayed_node *btrfs_get_or_create_delayed_node(
  109. struct btrfs_inode *btrfs_inode)
  110. {
  111. struct btrfs_delayed_node *node;
  112. struct btrfs_root *root = btrfs_inode->root;
  113. u64 ino = btrfs_ino(btrfs_inode);
  114. int ret;
  115. again:
  116. node = btrfs_get_delayed_node(btrfs_inode);
  117. if (node)
  118. return node;
  119. node = kmem_cache_zalloc(delayed_node_cache, GFP_NOFS);
  120. if (!node)
  121. return ERR_PTR(-ENOMEM);
  122. btrfs_init_delayed_node(node, root, ino);
  123. /* cached in the btrfs inode and can be accessed */
  124. refcount_set(&node->refs, 2);
  125. ret = radix_tree_preload(GFP_NOFS);
  126. if (ret) {
  127. kmem_cache_free(delayed_node_cache, node);
  128. return ERR_PTR(ret);
  129. }
  130. spin_lock(&root->inode_lock);
  131. ret = radix_tree_insert(&root->delayed_nodes_tree, ino, node);
  132. if (ret == -EEXIST) {
  133. spin_unlock(&root->inode_lock);
  134. kmem_cache_free(delayed_node_cache, node);
  135. radix_tree_preload_end();
  136. goto again;
  137. }
  138. btrfs_inode->delayed_node = node;
  139. spin_unlock(&root->inode_lock);
  140. radix_tree_preload_end();
  141. return node;
  142. }
  143. /*
  144. * Call it when holding delayed_node->mutex
  145. *
  146. * If mod = 1, add this node into the prepared list.
  147. */
  148. static void btrfs_queue_delayed_node(struct btrfs_delayed_root *root,
  149. struct btrfs_delayed_node *node,
  150. int mod)
  151. {
  152. spin_lock(&root->lock);
  153. if (test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) {
  154. if (!list_empty(&node->p_list))
  155. list_move_tail(&node->p_list, &root->prepare_list);
  156. else if (mod)
  157. list_add_tail(&node->p_list, &root->prepare_list);
  158. } else {
  159. list_add_tail(&node->n_list, &root->node_list);
  160. list_add_tail(&node->p_list, &root->prepare_list);
  161. refcount_inc(&node->refs); /* inserted into list */
  162. root->nodes++;
  163. set_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags);
  164. }
  165. spin_unlock(&root->lock);
  166. }
  167. /* Call it when holding delayed_node->mutex */
  168. static void btrfs_dequeue_delayed_node(struct btrfs_delayed_root *root,
  169. struct btrfs_delayed_node *node)
  170. {
  171. spin_lock(&root->lock);
  172. if (test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) {
  173. root->nodes--;
  174. refcount_dec(&node->refs); /* not in the list */
  175. list_del_init(&node->n_list);
  176. if (!list_empty(&node->p_list))
  177. list_del_init(&node->p_list);
  178. clear_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags);
  179. }
  180. spin_unlock(&root->lock);
  181. }
  182. static struct btrfs_delayed_node *btrfs_first_delayed_node(
  183. struct btrfs_delayed_root *delayed_root)
  184. {
  185. struct list_head *p;
  186. struct btrfs_delayed_node *node = NULL;
  187. spin_lock(&delayed_root->lock);
  188. if (list_empty(&delayed_root->node_list))
  189. goto out;
  190. p = delayed_root->node_list.next;
  191. node = list_entry(p, struct btrfs_delayed_node, n_list);
  192. refcount_inc(&node->refs);
  193. out:
  194. spin_unlock(&delayed_root->lock);
  195. return node;
  196. }
  197. static struct btrfs_delayed_node *btrfs_next_delayed_node(
  198. struct btrfs_delayed_node *node)
  199. {
  200. struct btrfs_delayed_root *delayed_root;
  201. struct list_head *p;
  202. struct btrfs_delayed_node *next = NULL;
  203. delayed_root = node->root->fs_info->delayed_root;
  204. spin_lock(&delayed_root->lock);
  205. if (!test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) {
  206. /* not in the list */
  207. if (list_empty(&delayed_root->node_list))
  208. goto out;
  209. p = delayed_root->node_list.next;
  210. } else if (list_is_last(&node->n_list, &delayed_root->node_list))
  211. goto out;
  212. else
  213. p = node->n_list.next;
  214. next = list_entry(p, struct btrfs_delayed_node, n_list);
  215. refcount_inc(&next->refs);
  216. out:
  217. spin_unlock(&delayed_root->lock);
  218. return next;
  219. }
  220. static void __btrfs_release_delayed_node(
  221. struct btrfs_delayed_node *delayed_node,
  222. int mod)
  223. {
  224. struct btrfs_delayed_root *delayed_root;
  225. if (!delayed_node)
  226. return;
  227. delayed_root = delayed_node->root->fs_info->delayed_root;
  228. mutex_lock(&delayed_node->mutex);
  229. if (delayed_node->count)
  230. btrfs_queue_delayed_node(delayed_root, delayed_node, mod);
  231. else
  232. btrfs_dequeue_delayed_node(delayed_root, delayed_node);
  233. mutex_unlock(&delayed_node->mutex);
  234. if (refcount_dec_and_test(&delayed_node->refs)) {
  235. struct btrfs_root *root = delayed_node->root;
  236. spin_lock(&root->inode_lock);
  237. /*
  238. * Once our refcount goes to zero, nobody is allowed to bump it
  239. * back up. We can delete it now.
  240. */
  241. ASSERT(refcount_read(&delayed_node->refs) == 0);
  242. radix_tree_delete(&root->delayed_nodes_tree,
  243. delayed_node->inode_id);
  244. spin_unlock(&root->inode_lock);
  245. kmem_cache_free(delayed_node_cache, delayed_node);
  246. }
  247. }
  248. static inline void btrfs_release_delayed_node(struct btrfs_delayed_node *node)
  249. {
  250. __btrfs_release_delayed_node(node, 0);
  251. }
  252. static struct btrfs_delayed_node *btrfs_first_prepared_delayed_node(
  253. struct btrfs_delayed_root *delayed_root)
  254. {
  255. struct list_head *p;
  256. struct btrfs_delayed_node *node = NULL;
  257. spin_lock(&delayed_root->lock);
  258. if (list_empty(&delayed_root->prepare_list))
  259. goto out;
  260. p = delayed_root->prepare_list.next;
  261. list_del_init(p);
  262. node = list_entry(p, struct btrfs_delayed_node, p_list);
  263. refcount_inc(&node->refs);
  264. out:
  265. spin_unlock(&delayed_root->lock);
  266. return node;
  267. }
  268. static inline void btrfs_release_prepared_delayed_node(
  269. struct btrfs_delayed_node *node)
  270. {
  271. __btrfs_release_delayed_node(node, 1);
  272. }
  273. static struct btrfs_delayed_item *btrfs_alloc_delayed_item(u32 data_len)
  274. {
  275. struct btrfs_delayed_item *item;
  276. item = kmalloc(sizeof(*item) + data_len, GFP_NOFS);
  277. if (item) {
  278. item->data_len = data_len;
  279. item->ins_or_del = 0;
  280. item->bytes_reserved = 0;
  281. item->delayed_node = NULL;
  282. refcount_set(&item->refs, 1);
  283. }
  284. return item;
  285. }
  286. /*
  287. * __btrfs_lookup_delayed_item - look up the delayed item by key
  288. * @delayed_node: pointer to the delayed node
  289. * @key: the key to look up
  290. * @prev: used to store the prev item if the right item isn't found
  291. * @next: used to store the next item if the right item isn't found
  292. *
  293. * Note: if we don't find the right item, we will return the prev item and
  294. * the next item.
  295. */
  296. static struct btrfs_delayed_item *__btrfs_lookup_delayed_item(
  297. struct rb_root *root,
  298. struct btrfs_key *key,
  299. struct btrfs_delayed_item **prev,
  300. struct btrfs_delayed_item **next)
  301. {
  302. struct rb_node *node, *prev_node = NULL;
  303. struct btrfs_delayed_item *delayed_item = NULL;
  304. int ret = 0;
  305. node = root->rb_node;
  306. while (node) {
  307. delayed_item = rb_entry(node, struct btrfs_delayed_item,
  308. rb_node);
  309. prev_node = node;
  310. ret = btrfs_comp_cpu_keys(&delayed_item->key, key);
  311. if (ret < 0)
  312. node = node->rb_right;
  313. else if (ret > 0)
  314. node = node->rb_left;
  315. else
  316. return delayed_item;
  317. }
  318. if (prev) {
  319. if (!prev_node)
  320. *prev = NULL;
  321. else if (ret < 0)
  322. *prev = delayed_item;
  323. else if ((node = rb_prev(prev_node)) != NULL) {
  324. *prev = rb_entry(node, struct btrfs_delayed_item,
  325. rb_node);
  326. } else
  327. *prev = NULL;
  328. }
  329. if (next) {
  330. if (!prev_node)
  331. *next = NULL;
  332. else if (ret > 0)
  333. *next = delayed_item;
  334. else if ((node = rb_next(prev_node)) != NULL) {
  335. *next = rb_entry(node, struct btrfs_delayed_item,
  336. rb_node);
  337. } else
  338. *next = NULL;
  339. }
  340. return NULL;
  341. }
  342. static struct btrfs_delayed_item *__btrfs_lookup_delayed_insertion_item(
  343. struct btrfs_delayed_node *delayed_node,
  344. struct btrfs_key *key)
  345. {
  346. return __btrfs_lookup_delayed_item(&delayed_node->ins_root.rb_root, key,
  347. NULL, NULL);
  348. }
  349. static int __btrfs_add_delayed_item(struct btrfs_delayed_node *delayed_node,
  350. struct btrfs_delayed_item *ins,
  351. int action)
  352. {
  353. struct rb_node **p, *node;
  354. struct rb_node *parent_node = NULL;
  355. struct rb_root_cached *root;
  356. struct btrfs_delayed_item *item;
  357. int cmp;
  358. bool leftmost = true;
  359. if (action == BTRFS_DELAYED_INSERTION_ITEM)
  360. root = &delayed_node->ins_root;
  361. else if (action == BTRFS_DELAYED_DELETION_ITEM)
  362. root = &delayed_node->del_root;
  363. else
  364. BUG();
  365. p = &root->rb_root.rb_node;
  366. node = &ins->rb_node;
  367. while (*p) {
  368. parent_node = *p;
  369. item = rb_entry(parent_node, struct btrfs_delayed_item,
  370. rb_node);
  371. cmp = btrfs_comp_cpu_keys(&item->key, &ins->key);
  372. if (cmp < 0) {
  373. p = &(*p)->rb_right;
  374. leftmost = false;
  375. } else if (cmp > 0) {
  376. p = &(*p)->rb_left;
  377. } else {
  378. return -EEXIST;
  379. }
  380. }
  381. rb_link_node(node, parent_node, p);
  382. rb_insert_color_cached(node, root, leftmost);
  383. ins->delayed_node = delayed_node;
  384. ins->ins_or_del = action;
  385. if (ins->key.type == BTRFS_DIR_INDEX_KEY &&
  386. action == BTRFS_DELAYED_INSERTION_ITEM &&
  387. ins->key.offset >= delayed_node->index_cnt)
  388. delayed_node->index_cnt = ins->key.offset + 1;
  389. delayed_node->count++;
  390. atomic_inc(&delayed_node->root->fs_info->delayed_root->items);
  391. return 0;
  392. }
  393. static int __btrfs_add_delayed_insertion_item(struct btrfs_delayed_node *node,
  394. struct btrfs_delayed_item *item)
  395. {
  396. return __btrfs_add_delayed_item(node, item,
  397. BTRFS_DELAYED_INSERTION_ITEM);
  398. }
  399. static int __btrfs_add_delayed_deletion_item(struct btrfs_delayed_node *node,
  400. struct btrfs_delayed_item *item)
  401. {
  402. return __btrfs_add_delayed_item(node, item,
  403. BTRFS_DELAYED_DELETION_ITEM);
  404. }
  405. static void finish_one_item(struct btrfs_delayed_root *delayed_root)
  406. {
  407. int seq = atomic_inc_return(&delayed_root->items_seq);
  408. /* atomic_dec_return implies a barrier */
  409. if ((atomic_dec_return(&delayed_root->items) <
  410. BTRFS_DELAYED_BACKGROUND || seq % BTRFS_DELAYED_BATCH == 0))
  411. cond_wake_up_nomb(&delayed_root->wait);
  412. }
  413. static void __btrfs_remove_delayed_item(struct btrfs_delayed_item *delayed_item)
  414. {
  415. struct rb_root_cached *root;
  416. struct btrfs_delayed_root *delayed_root;
  417. /* Not associated with any delayed_node */
  418. if (!delayed_item->delayed_node)
  419. return;
  420. delayed_root = delayed_item->delayed_node->root->fs_info->delayed_root;
  421. BUG_ON(!delayed_root);
  422. BUG_ON(delayed_item->ins_or_del != BTRFS_DELAYED_DELETION_ITEM &&
  423. delayed_item->ins_or_del != BTRFS_DELAYED_INSERTION_ITEM);
  424. if (delayed_item->ins_or_del == BTRFS_DELAYED_INSERTION_ITEM)
  425. root = &delayed_item->delayed_node->ins_root;
  426. else
  427. root = &delayed_item->delayed_node->del_root;
  428. rb_erase_cached(&delayed_item->rb_node, root);
  429. delayed_item->delayed_node->count--;
  430. finish_one_item(delayed_root);
  431. }
  432. static void btrfs_release_delayed_item(struct btrfs_delayed_item *item)
  433. {
  434. if (item) {
  435. __btrfs_remove_delayed_item(item);
  436. if (refcount_dec_and_test(&item->refs))
  437. kfree(item);
  438. }
  439. }
  440. static struct btrfs_delayed_item *__btrfs_first_delayed_insertion_item(
  441. struct btrfs_delayed_node *delayed_node)
  442. {
  443. struct rb_node *p;
  444. struct btrfs_delayed_item *item = NULL;
  445. p = rb_first_cached(&delayed_node->ins_root);
  446. if (p)
  447. item = rb_entry(p, struct btrfs_delayed_item, rb_node);
  448. return item;
  449. }
  450. static struct btrfs_delayed_item *__btrfs_first_delayed_deletion_item(
  451. struct btrfs_delayed_node *delayed_node)
  452. {
  453. struct rb_node *p;
  454. struct btrfs_delayed_item *item = NULL;
  455. p = rb_first_cached(&delayed_node->del_root);
  456. if (p)
  457. item = rb_entry(p, struct btrfs_delayed_item, rb_node);
  458. return item;
  459. }
  460. static struct btrfs_delayed_item *__btrfs_next_delayed_item(
  461. struct btrfs_delayed_item *item)
  462. {
  463. struct rb_node *p;
  464. struct btrfs_delayed_item *next = NULL;
  465. p = rb_next(&item->rb_node);
  466. if (p)
  467. next = rb_entry(p, struct btrfs_delayed_item, rb_node);
  468. return next;
  469. }
  470. static int btrfs_delayed_item_reserve_metadata(struct btrfs_trans_handle *trans,
  471. struct btrfs_root *root,
  472. struct btrfs_delayed_item *item)
  473. {
  474. struct btrfs_block_rsv *src_rsv;
  475. struct btrfs_block_rsv *dst_rsv;
  476. struct btrfs_fs_info *fs_info = root->fs_info;
  477. u64 num_bytes;
  478. int ret;
  479. if (!trans->bytes_reserved)
  480. return 0;
  481. src_rsv = trans->block_rsv;
  482. dst_rsv = &fs_info->delayed_block_rsv;
  483. num_bytes = btrfs_calc_insert_metadata_size(fs_info, 1);
  484. /*
  485. * Here we migrate space rsv from transaction rsv, since have already
  486. * reserved space when starting a transaction. So no need to reserve
  487. * qgroup space here.
  488. */
  489. ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes, true);
  490. if (!ret) {
  491. trace_btrfs_space_reservation(fs_info, "delayed_item",
  492. item->key.objectid,
  493. num_bytes, 1);
  494. item->bytes_reserved = num_bytes;
  495. }
  496. return ret;
  497. }
  498. static void btrfs_delayed_item_release_metadata(struct btrfs_root *root,
  499. struct btrfs_delayed_item *item)
  500. {
  501. struct btrfs_block_rsv *rsv;
  502. struct btrfs_fs_info *fs_info = root->fs_info;
  503. if (!item->bytes_reserved)
  504. return;
  505. rsv = &fs_info->delayed_block_rsv;
  506. /*
  507. * Check btrfs_delayed_item_reserve_metadata() to see why we don't need
  508. * to release/reserve qgroup space.
  509. */
  510. trace_btrfs_space_reservation(fs_info, "delayed_item",
  511. item->key.objectid, item->bytes_reserved,
  512. 0);
  513. btrfs_block_rsv_release(fs_info, rsv, item->bytes_reserved, NULL);
  514. }
  515. static int btrfs_delayed_inode_reserve_metadata(
  516. struct btrfs_trans_handle *trans,
  517. struct btrfs_root *root,
  518. struct btrfs_inode *inode,
  519. struct btrfs_delayed_node *node)
  520. {
  521. struct btrfs_fs_info *fs_info = root->fs_info;
  522. struct btrfs_block_rsv *src_rsv;
  523. struct btrfs_block_rsv *dst_rsv;
  524. u64 num_bytes;
  525. int ret;
  526. src_rsv = trans->block_rsv;
  527. dst_rsv = &fs_info->delayed_block_rsv;
  528. num_bytes = btrfs_calc_metadata_size(fs_info, 1);
  529. /*
  530. * btrfs_dirty_inode will update the inode under btrfs_join_transaction
  531. * which doesn't reserve space for speed. This is a problem since we
  532. * still need to reserve space for this update, so try to reserve the
  533. * space.
  534. *
  535. * Now if src_rsv == delalloc_block_rsv we'll let it just steal since
  536. * we always reserve enough to update the inode item.
  537. */
  538. if (!src_rsv || (!trans->bytes_reserved &&
  539. src_rsv->type != BTRFS_BLOCK_RSV_DELALLOC)) {
  540. ret = btrfs_qgroup_reserve_meta(root, num_bytes,
  541. BTRFS_QGROUP_RSV_META_PREALLOC, true);
  542. if (ret < 0)
  543. return ret;
  544. ret = btrfs_block_rsv_add(root, dst_rsv, num_bytes,
  545. BTRFS_RESERVE_NO_FLUSH);
  546. /*
  547. * Since we're under a transaction reserve_metadata_bytes could
  548. * try to commit the transaction which will make it return
  549. * EAGAIN to make us stop the transaction we have, so return
  550. * ENOSPC instead so that btrfs_dirty_inode knows what to do.
  551. */
  552. if (ret == -EAGAIN) {
  553. ret = -ENOSPC;
  554. btrfs_qgroup_free_meta_prealloc(root, num_bytes);
  555. }
  556. if (!ret) {
  557. node->bytes_reserved = num_bytes;
  558. trace_btrfs_space_reservation(fs_info,
  559. "delayed_inode",
  560. btrfs_ino(inode),
  561. num_bytes, 1);
  562. } else {
  563. btrfs_qgroup_free_meta_prealloc(root, num_bytes);
  564. }
  565. return ret;
  566. }
  567. ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes, true);
  568. if (!ret) {
  569. trace_btrfs_space_reservation(fs_info, "delayed_inode",
  570. btrfs_ino(inode), num_bytes, 1);
  571. node->bytes_reserved = num_bytes;
  572. }
  573. return ret;
  574. }
  575. static void btrfs_delayed_inode_release_metadata(struct btrfs_fs_info *fs_info,
  576. struct btrfs_delayed_node *node,
  577. bool qgroup_free)
  578. {
  579. struct btrfs_block_rsv *rsv;
  580. if (!node->bytes_reserved)
  581. return;
  582. rsv = &fs_info->delayed_block_rsv;
  583. trace_btrfs_space_reservation(fs_info, "delayed_inode",
  584. node->inode_id, node->bytes_reserved, 0);
  585. btrfs_block_rsv_release(fs_info, rsv, node->bytes_reserved, NULL);
  586. if (qgroup_free)
  587. btrfs_qgroup_free_meta_prealloc(node->root,
  588. node->bytes_reserved);
  589. else
  590. btrfs_qgroup_convert_reserved_meta(node->root,
  591. node->bytes_reserved);
  592. node->bytes_reserved = 0;
  593. }
  594. /*
  595. * This helper will insert some continuous items into the same leaf according
  596. * to the free space of the leaf.
  597. */
  598. static int btrfs_batch_insert_items(struct btrfs_root *root,
  599. struct btrfs_path *path,
  600. struct btrfs_delayed_item *item)
  601. {
  602. struct btrfs_delayed_item *curr, *next;
  603. int free_space;
  604. int total_data_size = 0, total_size = 0;
  605. struct extent_buffer *leaf;
  606. char *data_ptr;
  607. struct btrfs_key *keys;
  608. u32 *data_size;
  609. struct list_head head;
  610. int slot;
  611. int nitems;
  612. int i;
  613. int ret = 0;
  614. BUG_ON(!path->nodes[0]);
  615. leaf = path->nodes[0];
  616. free_space = btrfs_leaf_free_space(leaf);
  617. INIT_LIST_HEAD(&head);
  618. next = item;
  619. nitems = 0;
  620. /*
  621. * count the number of the continuous items that we can insert in batch
  622. */
  623. while (total_size + next->data_len + sizeof(struct btrfs_item) <=
  624. free_space) {
  625. total_data_size += next->data_len;
  626. total_size += next->data_len + sizeof(struct btrfs_item);
  627. list_add_tail(&next->tree_list, &head);
  628. nitems++;
  629. curr = next;
  630. next = __btrfs_next_delayed_item(curr);
  631. if (!next)
  632. break;
  633. if (!btrfs_is_continuous_delayed_item(curr, next))
  634. break;
  635. }
  636. if (!nitems) {
  637. ret = 0;
  638. goto out;
  639. }
  640. /*
  641. * we need allocate some memory space, but it might cause the task
  642. * to sleep, so we set all locked nodes in the path to blocking locks
  643. * first.
  644. */
  645. btrfs_set_path_blocking(path);
  646. keys = kmalloc_array(nitems, sizeof(struct btrfs_key), GFP_NOFS);
  647. if (!keys) {
  648. ret = -ENOMEM;
  649. goto out;
  650. }
  651. data_size = kmalloc_array(nitems, sizeof(u32), GFP_NOFS);
  652. if (!data_size) {
  653. ret = -ENOMEM;
  654. goto error;
  655. }
  656. /* get keys of all the delayed items */
  657. i = 0;
  658. list_for_each_entry(next, &head, tree_list) {
  659. keys[i] = next->key;
  660. data_size[i] = next->data_len;
  661. i++;
  662. }
  663. /* insert the keys of the items */
  664. setup_items_for_insert(root, path, keys, data_size, nitems);
  665. /* insert the dir index items */
  666. slot = path->slots[0];
  667. list_for_each_entry_safe(curr, next, &head, tree_list) {
  668. data_ptr = btrfs_item_ptr(leaf, slot, char);
  669. write_extent_buffer(leaf, &curr->data,
  670. (unsigned long)data_ptr,
  671. curr->data_len);
  672. slot++;
  673. btrfs_delayed_item_release_metadata(root, curr);
  674. list_del(&curr->tree_list);
  675. btrfs_release_delayed_item(curr);
  676. }
  677. error:
  678. kfree(data_size);
  679. kfree(keys);
  680. out:
  681. return ret;
  682. }
  683. /*
  684. * This helper can just do simple insertion that needn't extend item for new
  685. * data, such as directory name index insertion, inode insertion.
  686. */
  687. static int btrfs_insert_delayed_item(struct btrfs_trans_handle *trans,
  688. struct btrfs_root *root,
  689. struct btrfs_path *path,
  690. struct btrfs_delayed_item *delayed_item)
  691. {
  692. struct extent_buffer *leaf;
  693. unsigned int nofs_flag;
  694. char *ptr;
  695. int ret;
  696. nofs_flag = memalloc_nofs_save();
  697. ret = btrfs_insert_empty_item(trans, root, path, &delayed_item->key,
  698. delayed_item->data_len);
  699. memalloc_nofs_restore(nofs_flag);
  700. if (ret < 0 && ret != -EEXIST)
  701. return ret;
  702. leaf = path->nodes[0];
  703. ptr = btrfs_item_ptr(leaf, path->slots[0], char);
  704. write_extent_buffer(leaf, delayed_item->data, (unsigned long)ptr,
  705. delayed_item->data_len);
  706. btrfs_mark_buffer_dirty(leaf);
  707. btrfs_delayed_item_release_metadata(root, delayed_item);
  708. return 0;
  709. }
  710. /*
  711. * we insert an item first, then if there are some continuous items, we try
  712. * to insert those items into the same leaf.
  713. */
  714. static int btrfs_insert_delayed_items(struct btrfs_trans_handle *trans,
  715. struct btrfs_path *path,
  716. struct btrfs_root *root,
  717. struct btrfs_delayed_node *node)
  718. {
  719. struct btrfs_delayed_item *curr, *prev;
  720. int ret = 0;
  721. do_again:
  722. mutex_lock(&node->mutex);
  723. curr = __btrfs_first_delayed_insertion_item(node);
  724. if (!curr)
  725. goto insert_end;
  726. ret = btrfs_insert_delayed_item(trans, root, path, curr);
  727. if (ret < 0) {
  728. btrfs_release_path(path);
  729. goto insert_end;
  730. }
  731. prev = curr;
  732. curr = __btrfs_next_delayed_item(prev);
  733. if (curr && btrfs_is_continuous_delayed_item(prev, curr)) {
  734. /* insert the continuous items into the same leaf */
  735. path->slots[0]++;
  736. btrfs_batch_insert_items(root, path, curr);
  737. }
  738. btrfs_release_delayed_item(prev);
  739. btrfs_mark_buffer_dirty(path->nodes[0]);
  740. btrfs_release_path(path);
  741. mutex_unlock(&node->mutex);
  742. goto do_again;
  743. insert_end:
  744. mutex_unlock(&node->mutex);
  745. return ret;
  746. }
  747. static int btrfs_batch_delete_items(struct btrfs_trans_handle *trans,
  748. struct btrfs_root *root,
  749. struct btrfs_path *path,
  750. struct btrfs_delayed_item *item)
  751. {
  752. struct btrfs_delayed_item *curr, *next;
  753. struct extent_buffer *leaf;
  754. struct btrfs_key key;
  755. struct list_head head;
  756. int nitems, i, last_item;
  757. int ret = 0;
  758. BUG_ON(!path->nodes[0]);
  759. leaf = path->nodes[0];
  760. i = path->slots[0];
  761. last_item = btrfs_header_nritems(leaf) - 1;
  762. if (i > last_item)
  763. return -ENOENT; /* FIXME: Is errno suitable? */
  764. next = item;
  765. INIT_LIST_HEAD(&head);
  766. btrfs_item_key_to_cpu(leaf, &key, i);
  767. nitems = 0;
  768. /*
  769. * count the number of the dir index items that we can delete in batch
  770. */
  771. while (btrfs_comp_cpu_keys(&next->key, &key) == 0) {
  772. list_add_tail(&next->tree_list, &head);
  773. nitems++;
  774. curr = next;
  775. next = __btrfs_next_delayed_item(curr);
  776. if (!next)
  777. break;
  778. if (!btrfs_is_continuous_delayed_item(curr, next))
  779. break;
  780. i++;
  781. if (i > last_item)
  782. break;
  783. btrfs_item_key_to_cpu(leaf, &key, i);
  784. }
  785. if (!nitems)
  786. return 0;
  787. ret = btrfs_del_items(trans, root, path, path->slots[0], nitems);
  788. if (ret)
  789. goto out;
  790. list_for_each_entry_safe(curr, next, &head, tree_list) {
  791. btrfs_delayed_item_release_metadata(root, curr);
  792. list_del(&curr->tree_list);
  793. btrfs_release_delayed_item(curr);
  794. }
  795. out:
  796. return ret;
  797. }
  798. static int btrfs_delete_delayed_items(struct btrfs_trans_handle *trans,
  799. struct btrfs_path *path,
  800. struct btrfs_root *root,
  801. struct btrfs_delayed_node *node)
  802. {
  803. struct btrfs_delayed_item *curr, *prev;
  804. unsigned int nofs_flag;
  805. int ret = 0;
  806. do_again:
  807. mutex_lock(&node->mutex);
  808. curr = __btrfs_first_delayed_deletion_item(node);
  809. if (!curr)
  810. goto delete_fail;
  811. nofs_flag = memalloc_nofs_save();
  812. ret = btrfs_search_slot(trans, root, &curr->key, path, -1, 1);
  813. memalloc_nofs_restore(nofs_flag);
  814. if (ret < 0)
  815. goto delete_fail;
  816. else if (ret > 0) {
  817. /*
  818. * can't find the item which the node points to, so this node
  819. * is invalid, just drop it.
  820. */
  821. prev = curr;
  822. curr = __btrfs_next_delayed_item(prev);
  823. btrfs_release_delayed_item(prev);
  824. ret = 0;
  825. btrfs_release_path(path);
  826. if (curr) {
  827. mutex_unlock(&node->mutex);
  828. goto do_again;
  829. } else
  830. goto delete_fail;
  831. }
  832. btrfs_batch_delete_items(trans, root, path, curr);
  833. btrfs_release_path(path);
  834. mutex_unlock(&node->mutex);
  835. goto do_again;
  836. delete_fail:
  837. btrfs_release_path(path);
  838. mutex_unlock(&node->mutex);
  839. return ret;
  840. }
  841. static void btrfs_release_delayed_inode(struct btrfs_delayed_node *delayed_node)
  842. {
  843. struct btrfs_delayed_root *delayed_root;
  844. if (delayed_node &&
  845. test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) {
  846. BUG_ON(!delayed_node->root);
  847. clear_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags);
  848. delayed_node->count--;
  849. delayed_root = delayed_node->root->fs_info->delayed_root;
  850. finish_one_item(delayed_root);
  851. }
  852. }
  853. static void btrfs_release_delayed_iref(struct btrfs_delayed_node *delayed_node)
  854. {
  855. struct btrfs_delayed_root *delayed_root;
  856. ASSERT(delayed_node->root);
  857. clear_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags);
  858. delayed_node->count--;
  859. delayed_root = delayed_node->root->fs_info->delayed_root;
  860. finish_one_item(delayed_root);
  861. }
  862. static int __btrfs_update_delayed_inode(struct btrfs_trans_handle *trans,
  863. struct btrfs_root *root,
  864. struct btrfs_path *path,
  865. struct btrfs_delayed_node *node)
  866. {
  867. struct btrfs_fs_info *fs_info = root->fs_info;
  868. struct btrfs_key key;
  869. struct btrfs_inode_item *inode_item;
  870. struct extent_buffer *leaf;
  871. unsigned int nofs_flag;
  872. int mod;
  873. int ret;
  874. key.objectid = node->inode_id;
  875. key.type = BTRFS_INODE_ITEM_KEY;
  876. key.offset = 0;
  877. if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &node->flags))
  878. mod = -1;
  879. else
  880. mod = 1;
  881. nofs_flag = memalloc_nofs_save();
  882. ret = btrfs_lookup_inode(trans, root, path, &key, mod);
  883. memalloc_nofs_restore(nofs_flag);
  884. if (ret > 0)
  885. ret = -ENOENT;
  886. if (ret < 0)
  887. goto out;
  888. leaf = path->nodes[0];
  889. inode_item = btrfs_item_ptr(leaf, path->slots[0],
  890. struct btrfs_inode_item);
  891. write_extent_buffer(leaf, &node->inode_item, (unsigned long)inode_item,
  892. sizeof(struct btrfs_inode_item));
  893. btrfs_mark_buffer_dirty(leaf);
  894. if (!test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &node->flags))
  895. goto no_iref;
  896. path->slots[0]++;
  897. if (path->slots[0] >= btrfs_header_nritems(leaf))
  898. goto search;
  899. again:
  900. btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
  901. if (key.objectid != node->inode_id)
  902. goto out;
  903. if (key.type != BTRFS_INODE_REF_KEY &&
  904. key.type != BTRFS_INODE_EXTREF_KEY)
  905. goto out;
  906. /*
  907. * Delayed iref deletion is for the inode who has only one link,
  908. * so there is only one iref. The case that several irefs are
  909. * in the same item doesn't exist.
  910. */
  911. btrfs_del_item(trans, root, path);
  912. out:
  913. btrfs_release_delayed_iref(node);
  914. no_iref:
  915. btrfs_release_path(path);
  916. err_out:
  917. btrfs_delayed_inode_release_metadata(fs_info, node, (ret < 0));
  918. btrfs_release_delayed_inode(node);
  919. /*
  920. * If we fail to update the delayed inode we need to abort the
  921. * transaction, because we could leave the inode with the improper
  922. * counts behind.
  923. */
  924. if (ret && ret != -ENOENT)
  925. btrfs_abort_transaction(trans, ret);
  926. return ret;
  927. search:
  928. btrfs_release_path(path);
  929. key.type = BTRFS_INODE_EXTREF_KEY;
  930. key.offset = -1;
  931. nofs_flag = memalloc_nofs_save();
  932. ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
  933. memalloc_nofs_restore(nofs_flag);
  934. if (ret < 0)
  935. goto err_out;
  936. ASSERT(ret);
  937. ret = 0;
  938. leaf = path->nodes[0];
  939. path->slots[0]--;
  940. goto again;
  941. }
  942. static inline int btrfs_update_delayed_inode(struct btrfs_trans_handle *trans,
  943. struct btrfs_root *root,
  944. struct btrfs_path *path,
  945. struct btrfs_delayed_node *node)
  946. {
  947. int ret;
  948. mutex_lock(&node->mutex);
  949. if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &node->flags)) {
  950. mutex_unlock(&node->mutex);
  951. return 0;
  952. }
  953. ret = __btrfs_update_delayed_inode(trans, root, path, node);
  954. mutex_unlock(&node->mutex);
  955. return ret;
  956. }
  957. static inline int
  958. __btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans,
  959. struct btrfs_path *path,
  960. struct btrfs_delayed_node *node)
  961. {
  962. int ret;
  963. ret = btrfs_insert_delayed_items(trans, path, node->root, node);
  964. if (ret)
  965. return ret;
  966. ret = btrfs_delete_delayed_items(trans, path, node->root, node);
  967. if (ret)
  968. return ret;
  969. ret = btrfs_update_delayed_inode(trans, node->root, path, node);
  970. return ret;
  971. }
  972. /*
  973. * Called when committing the transaction.
  974. * Returns 0 on success.
  975. * Returns < 0 on error and returns with an aborted transaction with any
  976. * outstanding delayed items cleaned up.
  977. */
  978. static int __btrfs_run_delayed_items(struct btrfs_trans_handle *trans, int nr)
  979. {
  980. struct btrfs_fs_info *fs_info = trans->fs_info;
  981. struct btrfs_delayed_root *delayed_root;
  982. struct btrfs_delayed_node *curr_node, *prev_node;
  983. struct btrfs_path *path;
  984. struct btrfs_block_rsv *block_rsv;
  985. int ret = 0;
  986. bool count = (nr > 0);
  987. if (TRANS_ABORTED(trans))
  988. return -EIO;
  989. path = btrfs_alloc_path();
  990. if (!path)
  991. return -ENOMEM;
  992. path->leave_spinning = 1;
  993. block_rsv = trans->block_rsv;
  994. trans->block_rsv = &fs_info->delayed_block_rsv;
  995. delayed_root = fs_info->delayed_root;
  996. curr_node = btrfs_first_delayed_node(delayed_root);
  997. while (curr_node && (!count || (count && nr--))) {
  998. ret = __btrfs_commit_inode_delayed_items(trans, path,
  999. curr_node);
  1000. if (ret) {
  1001. btrfs_release_delayed_node(curr_node);
  1002. curr_node = NULL;
  1003. btrfs_abort_transaction(trans, ret);
  1004. break;
  1005. }
  1006. prev_node = curr_node;
  1007. curr_node = btrfs_next_delayed_node(curr_node);
  1008. btrfs_release_delayed_node(prev_node);
  1009. }
  1010. if (curr_node)
  1011. btrfs_release_delayed_node(curr_node);
  1012. btrfs_free_path(path);
  1013. trans->block_rsv = block_rsv;
  1014. return ret;
  1015. }
  1016. int btrfs_run_delayed_items(struct btrfs_trans_handle *trans)
  1017. {
  1018. return __btrfs_run_delayed_items(trans, -1);
  1019. }
  1020. int btrfs_run_delayed_items_nr(struct btrfs_trans_handle *trans, int nr)
  1021. {
  1022. return __btrfs_run_delayed_items(trans, nr);
  1023. }
  1024. int btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans,
  1025. struct btrfs_inode *inode)
  1026. {
  1027. struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode);
  1028. struct btrfs_path *path;
  1029. struct btrfs_block_rsv *block_rsv;
  1030. int ret;
  1031. if (!delayed_node)
  1032. return 0;
  1033. mutex_lock(&delayed_node->mutex);
  1034. if (!delayed_node->count) {
  1035. mutex_unlock(&delayed_node->mutex);
  1036. btrfs_release_delayed_node(delayed_node);
  1037. return 0;
  1038. }
  1039. mutex_unlock(&delayed_node->mutex);
  1040. path = btrfs_alloc_path();
  1041. if (!path) {
  1042. btrfs_release_delayed_node(delayed_node);
  1043. return -ENOMEM;
  1044. }
  1045. path->leave_spinning = 1;
  1046. block_rsv = trans->block_rsv;
  1047. trans->block_rsv = &delayed_node->root->fs_info->delayed_block_rsv;
  1048. ret = __btrfs_commit_inode_delayed_items(trans, path, delayed_node);
  1049. btrfs_release_delayed_node(delayed_node);
  1050. btrfs_free_path(path);
  1051. trans->block_rsv = block_rsv;
  1052. return ret;
  1053. }
  1054. int btrfs_commit_inode_delayed_inode(struct btrfs_inode *inode)
  1055. {
  1056. struct btrfs_fs_info *fs_info = inode->root->fs_info;
  1057. struct btrfs_trans_handle *trans;
  1058. struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode);
  1059. struct btrfs_path *path;
  1060. struct btrfs_block_rsv *block_rsv;
  1061. int ret;
  1062. if (!delayed_node)
  1063. return 0;
  1064. mutex_lock(&delayed_node->mutex);
  1065. if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) {
  1066. mutex_unlock(&delayed_node->mutex);
  1067. btrfs_release_delayed_node(delayed_node);
  1068. return 0;
  1069. }
  1070. mutex_unlock(&delayed_node->mutex);
  1071. trans = btrfs_join_transaction(delayed_node->root);
  1072. if (IS_ERR(trans)) {
  1073. ret = PTR_ERR(trans);
  1074. goto out;
  1075. }
  1076. path = btrfs_alloc_path();
  1077. if (!path) {
  1078. ret = -ENOMEM;
  1079. goto trans_out;
  1080. }
  1081. path->leave_spinning = 1;
  1082. block_rsv = trans->block_rsv;
  1083. trans->block_rsv = &fs_info->delayed_block_rsv;
  1084. mutex_lock(&delayed_node->mutex);
  1085. if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags))
  1086. ret = __btrfs_update_delayed_inode(trans, delayed_node->root,
  1087. path, delayed_node);
  1088. else
  1089. ret = 0;
  1090. mutex_unlock(&delayed_node->mutex);
  1091. btrfs_free_path(path);
  1092. trans->block_rsv = block_rsv;
  1093. trans_out:
  1094. btrfs_end_transaction(trans);
  1095. btrfs_btree_balance_dirty(fs_info);
  1096. out:
  1097. btrfs_release_delayed_node(delayed_node);
  1098. return ret;
  1099. }
  1100. void btrfs_remove_delayed_node(struct btrfs_inode *inode)
  1101. {
  1102. struct btrfs_delayed_node *delayed_node;
  1103. delayed_node = READ_ONCE(inode->delayed_node);
  1104. if (!delayed_node)
  1105. return;
  1106. inode->delayed_node = NULL;
  1107. btrfs_release_delayed_node(delayed_node);
  1108. }
  1109. struct btrfs_async_delayed_work {
  1110. struct btrfs_delayed_root *delayed_root;
  1111. int nr;
  1112. struct btrfs_work work;
  1113. };
  1114. static void btrfs_async_run_delayed_root(struct btrfs_work *work)
  1115. {
  1116. struct btrfs_async_delayed_work *async_work;
  1117. struct btrfs_delayed_root *delayed_root;
  1118. struct btrfs_trans_handle *trans;
  1119. struct btrfs_path *path;
  1120. struct btrfs_delayed_node *delayed_node = NULL;
  1121. struct btrfs_root *root;
  1122. struct btrfs_block_rsv *block_rsv;
  1123. int total_done = 0;
  1124. async_work = container_of(work, struct btrfs_async_delayed_work, work);
  1125. delayed_root = async_work->delayed_root;
  1126. path = btrfs_alloc_path();
  1127. if (!path)
  1128. goto out;
  1129. do {
  1130. if (atomic_read(&delayed_root->items) <
  1131. BTRFS_DELAYED_BACKGROUND / 2)
  1132. break;
  1133. delayed_node = btrfs_first_prepared_delayed_node(delayed_root);
  1134. if (!delayed_node)
  1135. break;
  1136. path->leave_spinning = 1;
  1137. root = delayed_node->root;
  1138. trans = btrfs_join_transaction(root);
  1139. if (IS_ERR(trans)) {
  1140. btrfs_release_path(path);
  1141. btrfs_release_prepared_delayed_node(delayed_node);
  1142. total_done++;
  1143. continue;
  1144. }
  1145. block_rsv = trans->block_rsv;
  1146. trans->block_rsv = &root->fs_info->delayed_block_rsv;
  1147. __btrfs_commit_inode_delayed_items(trans, path, delayed_node);
  1148. trans->block_rsv = block_rsv;
  1149. btrfs_end_transaction(trans);
  1150. btrfs_btree_balance_dirty_nodelay(root->fs_info);
  1151. btrfs_release_path(path);
  1152. btrfs_release_prepared_delayed_node(delayed_node);
  1153. total_done++;
  1154. } while ((async_work->nr == 0 && total_done < BTRFS_DELAYED_WRITEBACK)
  1155. || total_done < async_work->nr);
  1156. btrfs_free_path(path);
  1157. out:
  1158. wake_up(&delayed_root->wait);
  1159. kfree(async_work);
  1160. }
  1161. static int btrfs_wq_run_delayed_node(struct btrfs_delayed_root *delayed_root,
  1162. struct btrfs_fs_info *fs_info, int nr)
  1163. {
  1164. struct btrfs_async_delayed_work *async_work;
  1165. async_work = kmalloc(sizeof(*async_work), GFP_NOFS);
  1166. if (!async_work)
  1167. return -ENOMEM;
  1168. async_work->delayed_root = delayed_root;
  1169. btrfs_init_work(&async_work->work, btrfs_async_run_delayed_root, NULL,
  1170. NULL);
  1171. async_work->nr = nr;
  1172. btrfs_queue_work(fs_info->delayed_workers, &async_work->work);
  1173. return 0;
  1174. }
  1175. void btrfs_assert_delayed_root_empty(struct btrfs_fs_info *fs_info)
  1176. {
  1177. WARN_ON(btrfs_first_delayed_node(fs_info->delayed_root));
  1178. }
  1179. static int could_end_wait(struct btrfs_delayed_root *delayed_root, int seq)
  1180. {
  1181. int val = atomic_read(&delayed_root->items_seq);
  1182. if (val < seq || val >= seq + BTRFS_DELAYED_BATCH)
  1183. return 1;
  1184. if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND)
  1185. return 1;
  1186. return 0;
  1187. }
  1188. void btrfs_balance_delayed_items(struct btrfs_fs_info *fs_info)
  1189. {
  1190. struct btrfs_delayed_root *delayed_root = fs_info->delayed_root;
  1191. if ((atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND) ||
  1192. btrfs_workqueue_normal_congested(fs_info->delayed_workers))
  1193. return;
  1194. if (atomic_read(&delayed_root->items) >= BTRFS_DELAYED_WRITEBACK) {
  1195. int seq;
  1196. int ret;
  1197. seq = atomic_read(&delayed_root->items_seq);
  1198. ret = btrfs_wq_run_delayed_node(delayed_root, fs_info, 0);
  1199. if (ret)
  1200. return;
  1201. wait_event_interruptible(delayed_root->wait,
  1202. could_end_wait(delayed_root, seq));
  1203. return;
  1204. }
  1205. btrfs_wq_run_delayed_node(delayed_root, fs_info, BTRFS_DELAYED_BATCH);
  1206. }
  1207. /* Will return 0 or -ENOMEM */
  1208. int btrfs_insert_delayed_dir_index(struct btrfs_trans_handle *trans,
  1209. const char *name, int name_len,
  1210. struct btrfs_inode *dir,
  1211. struct btrfs_disk_key *disk_key, u8 type,
  1212. u64 index)
  1213. {
  1214. struct btrfs_delayed_node *delayed_node;
  1215. struct btrfs_delayed_item *delayed_item;
  1216. struct btrfs_dir_item *dir_item;
  1217. int ret;
  1218. delayed_node = btrfs_get_or_create_delayed_node(dir);
  1219. if (IS_ERR(delayed_node))
  1220. return PTR_ERR(delayed_node);
  1221. delayed_item = btrfs_alloc_delayed_item(sizeof(*dir_item) + name_len);
  1222. if (!delayed_item) {
  1223. ret = -ENOMEM;
  1224. goto release_node;
  1225. }
  1226. delayed_item->key.objectid = btrfs_ino(dir);
  1227. delayed_item->key.type = BTRFS_DIR_INDEX_KEY;
  1228. delayed_item->key.offset = index;
  1229. dir_item = (struct btrfs_dir_item *)delayed_item->data;
  1230. dir_item->location = *disk_key;
  1231. btrfs_set_stack_dir_transid(dir_item, trans->transid);
  1232. btrfs_set_stack_dir_data_len(dir_item, 0);
  1233. btrfs_set_stack_dir_name_len(dir_item, name_len);
  1234. btrfs_set_stack_dir_type(dir_item, type);
  1235. memcpy((char *)(dir_item + 1), name, name_len);
  1236. ret = btrfs_delayed_item_reserve_metadata(trans, dir->root, delayed_item);
  1237. /*
  1238. * we have reserved enough space when we start a new transaction,
  1239. * so reserving metadata failure is impossible
  1240. */
  1241. BUG_ON(ret);
  1242. mutex_lock(&delayed_node->mutex);
  1243. ret = __btrfs_add_delayed_insertion_item(delayed_node, delayed_item);
  1244. if (unlikely(ret)) {
  1245. btrfs_err(trans->fs_info,
  1246. "err add delayed dir index item(name: %.*s) into the insertion tree of the delayed node(root id: %llu, inode id: %llu, errno: %d)",
  1247. name_len, name, delayed_node->root->root_key.objectid,
  1248. delayed_node->inode_id, ret);
  1249. BUG();
  1250. }
  1251. mutex_unlock(&delayed_node->mutex);
  1252. release_node:
  1253. btrfs_release_delayed_node(delayed_node);
  1254. return ret;
  1255. }
  1256. static int btrfs_delete_delayed_insertion_item(struct btrfs_fs_info *fs_info,
  1257. struct btrfs_delayed_node *node,
  1258. struct btrfs_key *key)
  1259. {
  1260. struct btrfs_delayed_item *item;
  1261. mutex_lock(&node->mutex);
  1262. item = __btrfs_lookup_delayed_insertion_item(node, key);
  1263. if (!item) {
  1264. mutex_unlock(&node->mutex);
  1265. return 1;
  1266. }
  1267. btrfs_delayed_item_release_metadata(node->root, item);
  1268. btrfs_release_delayed_item(item);
  1269. mutex_unlock(&node->mutex);
  1270. return 0;
  1271. }
  1272. int btrfs_delete_delayed_dir_index(struct btrfs_trans_handle *trans,
  1273. struct btrfs_inode *dir, u64 index)
  1274. {
  1275. struct btrfs_delayed_node *node;
  1276. struct btrfs_delayed_item *item;
  1277. struct btrfs_key item_key;
  1278. int ret;
  1279. node = btrfs_get_or_create_delayed_node(dir);
  1280. if (IS_ERR(node))
  1281. return PTR_ERR(node);
  1282. item_key.objectid = btrfs_ino(dir);
  1283. item_key.type = BTRFS_DIR_INDEX_KEY;
  1284. item_key.offset = index;
  1285. ret = btrfs_delete_delayed_insertion_item(trans->fs_info, node,
  1286. &item_key);
  1287. if (!ret)
  1288. goto end;
  1289. item = btrfs_alloc_delayed_item(0);
  1290. if (!item) {
  1291. ret = -ENOMEM;
  1292. goto end;
  1293. }
  1294. item->key = item_key;
  1295. ret = btrfs_delayed_item_reserve_metadata(trans, dir->root, item);
  1296. /*
  1297. * we have reserved enough space when we start a new transaction,
  1298. * so reserving metadata failure is impossible.
  1299. */
  1300. if (ret < 0) {
  1301. btrfs_err(trans->fs_info,
  1302. "metadata reservation failed for delayed dir item deltiona, should have been reserved");
  1303. btrfs_release_delayed_item(item);
  1304. goto end;
  1305. }
  1306. mutex_lock(&node->mutex);
  1307. ret = __btrfs_add_delayed_deletion_item(node, item);
  1308. if (unlikely(ret)) {
  1309. btrfs_err(trans->fs_info,
  1310. "err add delayed dir index item(index: %llu) into the deletion tree of the delayed node(root id: %llu, inode id: %llu, errno: %d)",
  1311. index, node->root->root_key.objectid,
  1312. node->inode_id, ret);
  1313. btrfs_delayed_item_release_metadata(dir->root, item);
  1314. btrfs_release_delayed_item(item);
  1315. }
  1316. mutex_unlock(&node->mutex);
  1317. end:
  1318. btrfs_release_delayed_node(node);
  1319. return ret;
  1320. }
  1321. int btrfs_inode_delayed_dir_index_count(struct btrfs_inode *inode)
  1322. {
  1323. struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode);
  1324. if (!delayed_node)
  1325. return -ENOENT;
  1326. /*
  1327. * Since we have held i_mutex of this directory, it is impossible that
  1328. * a new directory index is added into the delayed node and index_cnt
  1329. * is updated now. So we needn't lock the delayed node.
  1330. */
  1331. if (!delayed_node->index_cnt) {
  1332. btrfs_release_delayed_node(delayed_node);
  1333. return -EINVAL;
  1334. }
  1335. inode->index_cnt = delayed_node->index_cnt;
  1336. btrfs_release_delayed_node(delayed_node);
  1337. return 0;
  1338. }
  1339. bool btrfs_readdir_get_delayed_items(struct inode *inode,
  1340. struct list_head *ins_list,
  1341. struct list_head *del_list)
  1342. {
  1343. struct btrfs_delayed_node *delayed_node;
  1344. struct btrfs_delayed_item *item;
  1345. delayed_node = btrfs_get_delayed_node(BTRFS_I(inode));
  1346. if (!delayed_node)
  1347. return false;
  1348. /*
  1349. * We can only do one readdir with delayed items at a time because of
  1350. * item->readdir_list.
  1351. */
  1352. inode_unlock_shared(inode);
  1353. inode_lock(inode);
  1354. mutex_lock(&delayed_node->mutex);
  1355. item = __btrfs_first_delayed_insertion_item(delayed_node);
  1356. while (item) {
  1357. refcount_inc(&item->refs);
  1358. list_add_tail(&item->readdir_list, ins_list);
  1359. item = __btrfs_next_delayed_item(item);
  1360. }
  1361. item = __btrfs_first_delayed_deletion_item(delayed_node);
  1362. while (item) {
  1363. refcount_inc(&item->refs);
  1364. list_add_tail(&item->readdir_list, del_list);
  1365. item = __btrfs_next_delayed_item(item);
  1366. }
  1367. mutex_unlock(&delayed_node->mutex);
  1368. /*
  1369. * This delayed node is still cached in the btrfs inode, so refs
  1370. * must be > 1 now, and we needn't check it is going to be freed
  1371. * or not.
  1372. *
  1373. * Besides that, this function is used to read dir, we do not
  1374. * insert/delete delayed items in this period. So we also needn't
  1375. * requeue or dequeue this delayed node.
  1376. */
  1377. refcount_dec(&delayed_node->refs);
  1378. return true;
  1379. }
  1380. void btrfs_readdir_put_delayed_items(struct inode *inode,
  1381. struct list_head *ins_list,
  1382. struct list_head *del_list)
  1383. {
  1384. struct btrfs_delayed_item *curr, *next;
  1385. list_for_each_entry_safe(curr, next, ins_list, readdir_list) {
  1386. list_del(&curr->readdir_list);
  1387. if (refcount_dec_and_test(&curr->refs))
  1388. kfree(curr);
  1389. }
  1390. list_for_each_entry_safe(curr, next, del_list, readdir_list) {
  1391. list_del(&curr->readdir_list);
  1392. if (refcount_dec_and_test(&curr->refs))
  1393. kfree(curr);
  1394. }
  1395. /*
  1396. * The VFS is going to do up_read(), so we need to downgrade back to a
  1397. * read lock.
  1398. */
  1399. downgrade_write(&inode->i_rwsem);
  1400. }
  1401. int btrfs_should_delete_dir_index(struct list_head *del_list,
  1402. u64 index)
  1403. {
  1404. struct btrfs_delayed_item *curr;
  1405. int ret = 0;
  1406. list_for_each_entry(curr, del_list, readdir_list) {
  1407. if (curr->key.offset > index)
  1408. break;
  1409. if (curr->key.offset == index) {
  1410. ret = 1;
  1411. break;
  1412. }
  1413. }
  1414. return ret;
  1415. }
  1416. /*
  1417. * btrfs_readdir_delayed_dir_index - read dir info stored in the delayed tree
  1418. *
  1419. */
  1420. int btrfs_readdir_delayed_dir_index(struct dir_context *ctx,
  1421. struct list_head *ins_list)
  1422. {
  1423. struct btrfs_dir_item *di;
  1424. struct btrfs_delayed_item *curr, *next;
  1425. struct btrfs_key location;
  1426. char *name;
  1427. int name_len;
  1428. int over = 0;
  1429. unsigned char d_type;
  1430. if (list_empty(ins_list))
  1431. return 0;
  1432. /*
  1433. * Changing the data of the delayed item is impossible. So
  1434. * we needn't lock them. And we have held i_mutex of the
  1435. * directory, nobody can delete any directory indexes now.
  1436. */
  1437. list_for_each_entry_safe(curr, next, ins_list, readdir_list) {
  1438. list_del(&curr->readdir_list);
  1439. if (curr->key.offset < ctx->pos) {
  1440. if (refcount_dec_and_test(&curr->refs))
  1441. kfree(curr);
  1442. continue;
  1443. }
  1444. ctx->pos = curr->key.offset;
  1445. di = (struct btrfs_dir_item *)curr->data;
  1446. name = (char *)(di + 1);
  1447. name_len = btrfs_stack_dir_name_len(di);
  1448. d_type = fs_ftype_to_dtype(di->type);
  1449. btrfs_disk_key_to_cpu(&location, &di->location);
  1450. over = !dir_emit(ctx, name, name_len,
  1451. location.objectid, d_type);
  1452. if (refcount_dec_and_test(&curr->refs))
  1453. kfree(curr);
  1454. if (over)
  1455. return 1;
  1456. ctx->pos++;
  1457. }
  1458. return 0;
  1459. }
  1460. static void fill_stack_inode_item(struct btrfs_trans_handle *trans,
  1461. struct btrfs_inode_item *inode_item,
  1462. struct inode *inode)
  1463. {
  1464. btrfs_set_stack_inode_uid(inode_item, i_uid_read(inode));
  1465. btrfs_set_stack_inode_gid(inode_item, i_gid_read(inode));
  1466. btrfs_set_stack_inode_size(inode_item, BTRFS_I(inode)->disk_i_size);
  1467. btrfs_set_stack_inode_mode(inode_item, inode->i_mode);
  1468. btrfs_set_stack_inode_nlink(inode_item, inode->i_nlink);
  1469. btrfs_set_stack_inode_nbytes(inode_item, inode_get_bytes(inode));
  1470. btrfs_set_stack_inode_generation(inode_item,
  1471. BTRFS_I(inode)->generation);
  1472. btrfs_set_stack_inode_sequence(inode_item,
  1473. inode_peek_iversion(inode));
  1474. btrfs_set_stack_inode_transid(inode_item, trans->transid);
  1475. btrfs_set_stack_inode_rdev(inode_item, inode->i_rdev);
  1476. btrfs_set_stack_inode_flags(inode_item, BTRFS_I(inode)->flags);
  1477. btrfs_set_stack_inode_block_group(inode_item, 0);
  1478. btrfs_set_stack_timespec_sec(&inode_item->atime,
  1479. inode->i_atime.tv_sec);
  1480. btrfs_set_stack_timespec_nsec(&inode_item->atime,
  1481. inode->i_atime.tv_nsec);
  1482. btrfs_set_stack_timespec_sec(&inode_item->mtime,
  1483. inode->i_mtime.tv_sec);
  1484. btrfs_set_stack_timespec_nsec(&inode_item->mtime,
  1485. inode->i_mtime.tv_nsec);
  1486. btrfs_set_stack_timespec_sec(&inode_item->ctime,
  1487. inode->i_ctime.tv_sec);
  1488. btrfs_set_stack_timespec_nsec(&inode_item->ctime,
  1489. inode->i_ctime.tv_nsec);
  1490. btrfs_set_stack_timespec_sec(&inode_item->otime,
  1491. BTRFS_I(inode)->i_otime.tv_sec);
  1492. btrfs_set_stack_timespec_nsec(&inode_item->otime,
  1493. BTRFS_I(inode)->i_otime.tv_nsec);
  1494. }
  1495. int btrfs_fill_inode(struct inode *inode, u32 *rdev)
  1496. {
  1497. struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
  1498. struct btrfs_delayed_node *delayed_node;
  1499. struct btrfs_inode_item *inode_item;
  1500. delayed_node = btrfs_get_delayed_node(BTRFS_I(inode));
  1501. if (!delayed_node)
  1502. return -ENOENT;
  1503. mutex_lock(&delayed_node->mutex);
  1504. if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) {
  1505. mutex_unlock(&delayed_node->mutex);
  1506. btrfs_release_delayed_node(delayed_node);
  1507. return -ENOENT;
  1508. }
  1509. inode_item = &delayed_node->inode_item;
  1510. i_uid_write(inode, btrfs_stack_inode_uid(inode_item));
  1511. i_gid_write(inode, btrfs_stack_inode_gid(inode_item));
  1512. btrfs_i_size_write(BTRFS_I(inode), btrfs_stack_inode_size(inode_item));
  1513. btrfs_inode_set_file_extent_range(BTRFS_I(inode), 0,
  1514. round_up(i_size_read(inode), fs_info->sectorsize));
  1515. inode->i_mode = btrfs_stack_inode_mode(inode_item);
  1516. set_nlink(inode, btrfs_stack_inode_nlink(inode_item));
  1517. inode_set_bytes(inode, btrfs_stack_inode_nbytes(inode_item));
  1518. BTRFS_I(inode)->generation = btrfs_stack_inode_generation(inode_item);
  1519. BTRFS_I(inode)->last_trans = btrfs_stack_inode_transid(inode_item);
  1520. inode_set_iversion_queried(inode,
  1521. btrfs_stack_inode_sequence(inode_item));
  1522. inode->i_rdev = 0;
  1523. *rdev = btrfs_stack_inode_rdev(inode_item);
  1524. BTRFS_I(inode)->flags = btrfs_stack_inode_flags(inode_item);
  1525. inode->i_atime.tv_sec = btrfs_stack_timespec_sec(&inode_item->atime);
  1526. inode->i_atime.tv_nsec = btrfs_stack_timespec_nsec(&inode_item->atime);
  1527. inode->i_mtime.tv_sec = btrfs_stack_timespec_sec(&inode_item->mtime);
  1528. inode->i_mtime.tv_nsec = btrfs_stack_timespec_nsec(&inode_item->mtime);
  1529. inode->i_ctime.tv_sec = btrfs_stack_timespec_sec(&inode_item->ctime);
  1530. inode->i_ctime.tv_nsec = btrfs_stack_timespec_nsec(&inode_item->ctime);
  1531. BTRFS_I(inode)->i_otime.tv_sec =
  1532. btrfs_stack_timespec_sec(&inode_item->otime);
  1533. BTRFS_I(inode)->i_otime.tv_nsec =
  1534. btrfs_stack_timespec_nsec(&inode_item->otime);
  1535. inode->i_generation = BTRFS_I(inode)->generation;
  1536. BTRFS_I(inode)->index_cnt = (u64)-1;
  1537. mutex_unlock(&delayed_node->mutex);
  1538. btrfs_release_delayed_node(delayed_node);
  1539. return 0;
  1540. }
  1541. int btrfs_delayed_update_inode(struct btrfs_trans_handle *trans,
  1542. struct btrfs_root *root, struct inode *inode)
  1543. {
  1544. struct btrfs_delayed_node *delayed_node;
  1545. int ret = 0;
  1546. delayed_node = btrfs_get_or_create_delayed_node(BTRFS_I(inode));
  1547. if (IS_ERR(delayed_node))
  1548. return PTR_ERR(delayed_node);
  1549. mutex_lock(&delayed_node->mutex);
  1550. if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) {
  1551. fill_stack_inode_item(trans, &delayed_node->inode_item, inode);
  1552. goto release_node;
  1553. }
  1554. ret = btrfs_delayed_inode_reserve_metadata(trans, root, BTRFS_I(inode),
  1555. delayed_node);
  1556. if (ret)
  1557. goto release_node;
  1558. fill_stack_inode_item(trans, &delayed_node->inode_item, inode);
  1559. set_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags);
  1560. delayed_node->count++;
  1561. atomic_inc(&root->fs_info->delayed_root->items);
  1562. release_node:
  1563. mutex_unlock(&delayed_node->mutex);
  1564. btrfs_release_delayed_node(delayed_node);
  1565. return ret;
  1566. }
  1567. int btrfs_delayed_delete_inode_ref(struct btrfs_inode *inode)
  1568. {
  1569. struct btrfs_fs_info *fs_info = inode->root->fs_info;
  1570. struct btrfs_delayed_node *delayed_node;
  1571. /*
  1572. * we don't do delayed inode updates during log recovery because it
  1573. * leads to enospc problems. This means we also can't do
  1574. * delayed inode refs
  1575. */
  1576. if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))
  1577. return -EAGAIN;
  1578. delayed_node = btrfs_get_or_create_delayed_node(inode);
  1579. if (IS_ERR(delayed_node))
  1580. return PTR_ERR(delayed_node);
  1581. /*
  1582. * We don't reserve space for inode ref deletion is because:
  1583. * - We ONLY do async inode ref deletion for the inode who has only
  1584. * one link(i_nlink == 1), it means there is only one inode ref.
  1585. * And in most case, the inode ref and the inode item are in the
  1586. * same leaf, and we will deal with them at the same time.
  1587. * Since we are sure we will reserve the space for the inode item,
  1588. * it is unnecessary to reserve space for inode ref deletion.
  1589. * - If the inode ref and the inode item are not in the same leaf,
  1590. * We also needn't worry about enospc problem, because we reserve
  1591. * much more space for the inode update than it needs.
  1592. * - At the worst, we can steal some space from the global reservation.
  1593. * It is very rare.
  1594. */
  1595. mutex_lock(&delayed_node->mutex);
  1596. if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags))
  1597. goto release_node;
  1598. set_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags);
  1599. delayed_node->count++;
  1600. atomic_inc(&fs_info->delayed_root->items);
  1601. release_node:
  1602. mutex_unlock(&delayed_node->mutex);
  1603. btrfs_release_delayed_node(delayed_node);
  1604. return 0;
  1605. }
  1606. static void __btrfs_kill_delayed_node(struct btrfs_delayed_node *delayed_node)
  1607. {
  1608. struct btrfs_root *root = delayed_node->root;
  1609. struct btrfs_fs_info *fs_info = root->fs_info;
  1610. struct btrfs_delayed_item *curr_item, *prev_item;
  1611. mutex_lock(&delayed_node->mutex);
  1612. curr_item = __btrfs_first_delayed_insertion_item(delayed_node);
  1613. while (curr_item) {
  1614. btrfs_delayed_item_release_metadata(root, curr_item);
  1615. prev_item = curr_item;
  1616. curr_item = __btrfs_next_delayed_item(prev_item);
  1617. btrfs_release_delayed_item(prev_item);
  1618. }
  1619. curr_item = __btrfs_first_delayed_deletion_item(delayed_node);
  1620. while (curr_item) {
  1621. btrfs_delayed_item_release_metadata(root, curr_item);
  1622. prev_item = curr_item;
  1623. curr_item = __btrfs_next_delayed_item(prev_item);
  1624. btrfs_release_delayed_item(prev_item);
  1625. }
  1626. if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags))
  1627. btrfs_release_delayed_iref(delayed_node);
  1628. if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) {
  1629. btrfs_delayed_inode_release_metadata(fs_info, delayed_node, false);
  1630. btrfs_release_delayed_inode(delayed_node);
  1631. }
  1632. mutex_unlock(&delayed_node->mutex);
  1633. }
  1634. void btrfs_kill_delayed_inode_items(struct btrfs_inode *inode)
  1635. {
  1636. struct btrfs_delayed_node *delayed_node;
  1637. delayed_node = btrfs_get_delayed_node(inode);
  1638. if (!delayed_node)
  1639. return;
  1640. __btrfs_kill_delayed_node(delayed_node);
  1641. btrfs_release_delayed_node(delayed_node);
  1642. }
  1643. void btrfs_kill_all_delayed_nodes(struct btrfs_root *root)
  1644. {
  1645. u64 inode_id = 0;
  1646. struct btrfs_delayed_node *delayed_nodes[8];
  1647. int i, n;
  1648. while (1) {
  1649. spin_lock(&root->inode_lock);
  1650. n = radix_tree_gang_lookup(&root->delayed_nodes_tree,
  1651. (void **)delayed_nodes, inode_id,
  1652. ARRAY_SIZE(delayed_nodes));
  1653. if (!n) {
  1654. spin_unlock(&root->inode_lock);
  1655. break;
  1656. }
  1657. inode_id = delayed_nodes[n - 1]->inode_id + 1;
  1658. for (i = 0; i < n; i++) {
  1659. /*
  1660. * Don't increase refs in case the node is dead and
  1661. * about to be removed from the tree in the loop below
  1662. */
  1663. if (!refcount_inc_not_zero(&delayed_nodes[i]->refs))
  1664. delayed_nodes[i] = NULL;
  1665. }
  1666. spin_unlock(&root->inode_lock);
  1667. for (i = 0; i < n; i++) {
  1668. if (!delayed_nodes[i])
  1669. continue;
  1670. __btrfs_kill_delayed_node(delayed_nodes[i]);
  1671. btrfs_release_delayed_node(delayed_nodes[i]);
  1672. }
  1673. }
  1674. }
  1675. void btrfs_destroy_delayed_inodes(struct btrfs_fs_info *fs_info)
  1676. {
  1677. struct btrfs_delayed_node *curr_node, *prev_node;
  1678. curr_node = btrfs_first_delayed_node(fs_info->delayed_root);
  1679. while (curr_node) {
  1680. __btrfs_kill_delayed_node(curr_node);
  1681. prev_node = curr_node;
  1682. curr_node = btrfs_next_delayed_node(curr_node);
  1683. btrfs_release_delayed_node(prev_node);
  1684. }
  1685. }