xfs_log_cil.c 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910
  1. /*
  2. * Copyright (c) 2010 Red Hat, Inc. All Rights Reserved.
  3. *
  4. * This program is free software; you can redistribute it and/or
  5. * modify it under the terms of the GNU General Public License as
  6. * published by the Free Software Foundation.
  7. *
  8. * This program is distributed in the hope that it would be useful,
  9. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11. * GNU General Public License for more details.
  12. *
  13. * You should have received a copy of the GNU General Public License
  14. * along with this program; if not, write the Free Software Foundation,
  15. * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  16. */
  17. #include "xfs.h"
  18. #include "xfs_fs.h"
  19. #include "xfs_types.h"
  20. #include "xfs_log.h"
  21. #include "xfs_trans.h"
  22. #include "xfs_trans_priv.h"
  23. #include "xfs_log_priv.h"
  24. #include "xfs_sb.h"
  25. #include "xfs_ag.h"
  26. #include "xfs_mount.h"
  27. #include "xfs_error.h"
  28. #include "xfs_alloc.h"
  29. #include "xfs_extent_busy.h"
  30. #include "xfs_discard.h"
  31. /*
  32. * Allocate a new ticket. Failing to get a new ticket makes it really hard to
  33. * recover, so we don't allow failure here. Also, we allocate in a context that
  34. * we don't want to be issuing transactions from, so we need to tell the
  35. * allocation code this as well.
  36. *
  37. * We don't reserve any space for the ticket - we are going to steal whatever
  38. * space we require from transactions as they commit. To ensure we reserve all
  39. * the space required, we need to set the current reservation of the ticket to
  40. * zero so that we know to steal the initial transaction overhead from the
  41. * first transaction commit.
  42. */
  43. static struct xlog_ticket *
  44. xlog_cil_ticket_alloc(
  45. struct xlog *log)
  46. {
  47. struct xlog_ticket *tic;
  48. tic = xlog_ticket_alloc(log, 0, 1, XFS_TRANSACTION, 0,
  49. KM_SLEEP|KM_NOFS);
  50. tic->t_trans_type = XFS_TRANS_CHECKPOINT;
  51. /*
  52. * set the current reservation to zero so we know to steal the basic
  53. * transaction overhead reservation from the first transaction commit.
  54. */
  55. tic->t_curr_res = 0;
  56. return tic;
  57. }
  58. /*
  59. * After the first stage of log recovery is done, we know where the head and
  60. * tail of the log are. We need this log initialisation done before we can
  61. * initialise the first CIL checkpoint context.
  62. *
  63. * Here we allocate a log ticket to track space usage during a CIL push. This
  64. * ticket is passed to xlog_write() directly so that we don't slowly leak log
  65. * space by failing to account for space used by log headers and additional
  66. * region headers for split regions.
  67. */
  68. void
  69. xlog_cil_init_post_recovery(
  70. struct xlog *log)
  71. {
  72. log->l_cilp->xc_ctx->ticket = xlog_cil_ticket_alloc(log);
  73. log->l_cilp->xc_ctx->sequence = 1;
  74. log->l_cilp->xc_ctx->commit_lsn = xlog_assign_lsn(log->l_curr_cycle,
  75. log->l_curr_block);
  76. }
  77. /*
  78. * Format log item into a flat buffers
  79. *
  80. * For delayed logging, we need to hold a formatted buffer containing all the
  81. * changes on the log item. This enables us to relog the item in memory and
  82. * write it out asynchronously without needing to relock the object that was
  83. * modified at the time it gets written into the iclog.
  84. *
  85. * This function builds a vector for the changes in each log item in the
  86. * transaction. It then works out the length of the buffer needed for each log
  87. * item, allocates them and formats the vector for the item into the buffer.
  88. * The buffer is then attached to the log item are then inserted into the
  89. * Committed Item List for tracking until the next checkpoint is written out.
  90. *
  91. * We don't set up region headers during this process; we simply copy the
  92. * regions into the flat buffer. We can do this because we still have to do a
  93. * formatting step to write the regions into the iclog buffer. Writing the
  94. * ophdrs during the iclog write means that we can support splitting large
  95. * regions across iclog boundares without needing a change in the format of the
  96. * item/region encapsulation.
  97. *
  98. * Hence what we need to do now is change the rewrite the vector array to point
  99. * to the copied region inside the buffer we just allocated. This allows us to
  100. * format the regions into the iclog as though they are being formatted
  101. * directly out of the objects themselves.
  102. */
  103. static struct xfs_log_vec *
  104. xlog_cil_prepare_log_vecs(
  105. struct xfs_trans *tp)
  106. {
  107. struct xfs_log_item_desc *lidp;
  108. struct xfs_log_vec *lv = NULL;
  109. struct xfs_log_vec *ret_lv = NULL;
  110. /* Bail out if we didn't find a log item. */
  111. if (list_empty(&tp->t_items)) {
  112. ASSERT(0);
  113. return NULL;
  114. }
  115. list_for_each_entry(lidp, &tp->t_items, lid_trans) {
  116. struct xfs_log_item *lip = lidp->lid_item;
  117. struct xfs_log_vec *new_lv;
  118. void *ptr;
  119. int index;
  120. int len = 0;
  121. uint niovecs = 0;
  122. uint nbytes = 0;
  123. bool ordered = false;
  124. /* Skip items which aren't dirty in this transaction. */
  125. if (!(lidp->lid_flags & XFS_LID_DIRTY))
  126. continue;
  127. /* get number of vecs and size of data to be stored */
  128. lip->li_ops->iop_size(lip, &niovecs, &nbytes);
  129. /* Skip items that do not have any vectors for writing */
  130. if (!niovecs)
  131. continue;
  132. /*
  133. * Ordered items need to be tracked but we do not wish to write
  134. * them. We need a logvec to track the object, but we do not
  135. * need an iovec or buffer to be allocated for copying data.
  136. */
  137. if (niovecs == XFS_LOG_VEC_ORDERED) {
  138. ordered = true;
  139. niovecs = 0;
  140. }
  141. new_lv = kmem_zalloc(sizeof(*new_lv) +
  142. niovecs * sizeof(struct xfs_log_iovec),
  143. KM_SLEEP|KM_NOFS);
  144. new_lv->lv_item = lip;
  145. new_lv->lv_niovecs = niovecs;
  146. if (ordered) {
  147. /* track as an ordered logvec */
  148. new_lv->lv_buf_len = XFS_LOG_VEC_ORDERED;
  149. goto next;
  150. }
  151. /* The allocated iovec region lies beyond the log vector. */
  152. new_lv->lv_iovecp = (struct xfs_log_iovec *)&new_lv[1];
  153. /* build the vector array and calculate it's length */
  154. IOP_FORMAT(new_lv->lv_item, new_lv->lv_iovecp);
  155. for (index = 0; index < new_lv->lv_niovecs; index++)
  156. len += new_lv->lv_iovecp[index].i_len;
  157. new_lv->lv_buf_len = len;
  158. new_lv->lv_buf = kmem_alloc(new_lv->lv_buf_len,
  159. KM_SLEEP|KM_NOFS);
  160. ptr = new_lv->lv_buf;
  161. for (index = 0; index < new_lv->lv_niovecs; index++) {
  162. struct xfs_log_iovec *vec = &new_lv->lv_iovecp[index];
  163. memcpy(ptr, vec->i_addr, vec->i_len);
  164. vec->i_addr = ptr;
  165. ptr += vec->i_len;
  166. }
  167. ASSERT(ptr == new_lv->lv_buf + new_lv->lv_buf_len);
  168. next:
  169. if (!ret_lv)
  170. ret_lv = new_lv;
  171. else
  172. lv->lv_next = new_lv;
  173. lv = new_lv;
  174. }
  175. return ret_lv;
  176. }
  177. /*
  178. * Prepare the log item for insertion into the CIL. Calculate the difference in
  179. * log space and vectors it will consume, and if it is a new item pin it as
  180. * well.
  181. */
  182. STATIC void
  183. xfs_cil_prepare_item(
  184. struct xlog *log,
  185. struct xfs_log_vec *lv,
  186. int *len,
  187. int *diff_iovecs)
  188. {
  189. struct xfs_log_vec *old = lv->lv_item->li_lv;
  190. if (old) {
  191. /* existing lv on log item, space used is a delta */
  192. ASSERT((old->lv_buf && old->lv_buf_len && old->lv_niovecs) ||
  193. old->lv_buf_len == XFS_LOG_VEC_ORDERED);
  194. /*
  195. * If the new item is ordered, keep the old one that is already
  196. * tracking dirty or ordered regions
  197. */
  198. if (lv->lv_buf_len == XFS_LOG_VEC_ORDERED) {
  199. ASSERT(!lv->lv_buf);
  200. kmem_free(lv);
  201. return;
  202. }
  203. *len += lv->lv_buf_len - old->lv_buf_len;
  204. *diff_iovecs += lv->lv_niovecs - old->lv_niovecs;
  205. kmem_free(old->lv_buf);
  206. kmem_free(old);
  207. } else {
  208. /* new lv, must pin the log item */
  209. ASSERT(!lv->lv_item->li_lv);
  210. if (lv->lv_buf_len != XFS_LOG_VEC_ORDERED) {
  211. *len += lv->lv_buf_len;
  212. *diff_iovecs += lv->lv_niovecs;
  213. }
  214. IOP_PIN(lv->lv_item);
  215. }
  216. /* attach new log vector to log item */
  217. lv->lv_item->li_lv = lv;
  218. /*
  219. * If this is the first time the item is being committed to the
  220. * CIL, store the sequence number on the log item so we can
  221. * tell in future commits whether this is the first checkpoint
  222. * the item is being committed into.
  223. */
  224. if (!lv->lv_item->li_seq)
  225. lv->lv_item->li_seq = log->l_cilp->xc_ctx->sequence;
  226. }
  227. /*
  228. * Insert the log items into the CIL and calculate the difference in space
  229. * consumed by the item. Add the space to the checkpoint ticket and calculate
  230. * if the change requires additional log metadata. If it does, take that space
  231. * as well. Remove the amount of space we added to the checkpoint ticket from
  232. * the current transaction ticket so that the accounting works out correctly.
  233. */
  234. static void
  235. xlog_cil_insert_items(
  236. struct xlog *log,
  237. struct xfs_log_vec *log_vector,
  238. struct xlog_ticket *ticket)
  239. {
  240. struct xfs_cil *cil = log->l_cilp;
  241. struct xfs_cil_ctx *ctx = cil->xc_ctx;
  242. struct xfs_log_vec *lv;
  243. int len = 0;
  244. int diff_iovecs = 0;
  245. int iclog_space;
  246. ASSERT(log_vector);
  247. /*
  248. * Do all the accounting aggregation and switching of log vectors
  249. * around in a separate loop to the insertion of items into the CIL.
  250. * Then we can do a separate loop to update the CIL within a single
  251. * lock/unlock pair. This reduces the number of round trips on the CIL
  252. * lock from O(nr_logvectors) to O(1) and greatly reduces the overall
  253. * hold time for the transaction commit.
  254. *
  255. * If this is the first time the item is being placed into the CIL in
  256. * this context, pin it so it can't be written to disk until the CIL is
  257. * flushed to the iclog and the iclog written to disk.
  258. *
  259. * We can do this safely because the context can't checkpoint until we
  260. * are done so it doesn't matter exactly how we update the CIL.
  261. */
  262. spin_lock(&cil->xc_cil_lock);
  263. for (lv = log_vector; lv; ) {
  264. struct xfs_log_vec *next = lv->lv_next;
  265. ASSERT(lv->lv_item->li_lv || list_empty(&lv->lv_item->li_cil));
  266. lv->lv_next = NULL;
  267. /*
  268. * xfs_cil_prepare_item() may free the lv, so move the item on
  269. * the CIL first.
  270. */
  271. list_move_tail(&lv->lv_item->li_cil, &cil->xc_cil);
  272. xfs_cil_prepare_item(log, lv, &len, &diff_iovecs);
  273. lv = next;
  274. }
  275. /* account for space used by new iovec headers */
  276. len += diff_iovecs * sizeof(xlog_op_header_t);
  277. ctx->nvecs += diff_iovecs;
  278. /*
  279. * Now transfer enough transaction reservation to the context ticket
  280. * for the checkpoint. The context ticket is special - the unit
  281. * reservation has to grow as well as the current reservation as we
  282. * steal from tickets so we can correctly determine the space used
  283. * during the transaction commit.
  284. */
  285. if (ctx->ticket->t_curr_res == 0) {
  286. /* first commit in checkpoint, steal the header reservation */
  287. ASSERT(ticket->t_curr_res >= ctx->ticket->t_unit_res + len);
  288. ctx->ticket->t_curr_res = ctx->ticket->t_unit_res;
  289. ticket->t_curr_res -= ctx->ticket->t_unit_res;
  290. }
  291. /* do we need space for more log record headers? */
  292. iclog_space = log->l_iclog_size - log->l_iclog_hsize;
  293. if (len > 0 && (ctx->space_used / iclog_space !=
  294. (ctx->space_used + len) / iclog_space)) {
  295. int hdrs;
  296. hdrs = (len + iclog_space - 1) / iclog_space;
  297. /* need to take into account split region headers, too */
  298. hdrs *= log->l_iclog_hsize + sizeof(struct xlog_op_header);
  299. ctx->ticket->t_unit_res += hdrs;
  300. ctx->ticket->t_curr_res += hdrs;
  301. ticket->t_curr_res -= hdrs;
  302. ASSERT(ticket->t_curr_res >= len);
  303. }
  304. ticket->t_curr_res -= len;
  305. ctx->space_used += len;
  306. spin_unlock(&cil->xc_cil_lock);
  307. }
  308. static void
  309. xlog_cil_free_logvec(
  310. struct xfs_log_vec *log_vector)
  311. {
  312. struct xfs_log_vec *lv;
  313. for (lv = log_vector; lv; ) {
  314. struct xfs_log_vec *next = lv->lv_next;
  315. kmem_free(lv->lv_buf);
  316. kmem_free(lv);
  317. lv = next;
  318. }
  319. }
  320. /*
  321. * Mark all items committed and clear busy extents. We free the log vector
  322. * chains in a separate pass so that we unpin the log items as quickly as
  323. * possible.
  324. */
  325. static void
  326. xlog_cil_committed(
  327. void *args,
  328. int abort)
  329. {
  330. struct xfs_cil_ctx *ctx = args;
  331. struct xfs_mount *mp = ctx->cil->xc_log->l_mp;
  332. xfs_trans_committed_bulk(ctx->cil->xc_log->l_ailp, ctx->lv_chain,
  333. ctx->start_lsn, abort);
  334. xfs_extent_busy_sort(&ctx->busy_extents);
  335. xfs_extent_busy_clear(mp, &ctx->busy_extents,
  336. (mp->m_flags & XFS_MOUNT_DISCARD) && !abort);
  337. spin_lock(&ctx->cil->xc_cil_lock);
  338. list_del(&ctx->committing);
  339. spin_unlock(&ctx->cil->xc_cil_lock);
  340. xlog_cil_free_logvec(ctx->lv_chain);
  341. if (!list_empty(&ctx->busy_extents)) {
  342. ASSERT(mp->m_flags & XFS_MOUNT_DISCARD);
  343. xfs_discard_extents(mp, &ctx->busy_extents);
  344. xfs_extent_busy_clear(mp, &ctx->busy_extents, false);
  345. }
  346. kmem_free(ctx);
  347. }
  348. /*
  349. * Push the Committed Item List to the log. If @push_seq flag is zero, then it
  350. * is a background flush and so we can chose to ignore it. Otherwise, if the
  351. * current sequence is the same as @push_seq we need to do a flush. If
  352. * @push_seq is less than the current sequence, then it has already been
  353. * flushed and we don't need to do anything - the caller will wait for it to
  354. * complete if necessary.
  355. *
  356. * @push_seq is a value rather than a flag because that allows us to do an
  357. * unlocked check of the sequence number for a match. Hence we can allows log
  358. * forces to run racily and not issue pushes for the same sequence twice. If we
  359. * get a race between multiple pushes for the same sequence they will block on
  360. * the first one and then abort, hence avoiding needless pushes.
  361. */
  362. STATIC int
  363. xlog_cil_push(
  364. struct xlog *log)
  365. {
  366. struct xfs_cil *cil = log->l_cilp;
  367. struct xfs_log_vec *lv;
  368. struct xfs_cil_ctx *ctx;
  369. struct xfs_cil_ctx *new_ctx;
  370. struct xlog_in_core *commit_iclog;
  371. struct xlog_ticket *tic;
  372. int num_iovecs;
  373. int error = 0;
  374. struct xfs_trans_header thdr;
  375. struct xfs_log_iovec lhdr;
  376. struct xfs_log_vec lvhdr = { NULL };
  377. xfs_lsn_t commit_lsn;
  378. xfs_lsn_t push_seq;
  379. if (!cil)
  380. return 0;
  381. new_ctx = kmem_zalloc(sizeof(*new_ctx), KM_SLEEP|KM_NOFS);
  382. new_ctx->ticket = xlog_cil_ticket_alloc(log);
  383. down_write(&cil->xc_ctx_lock);
  384. ctx = cil->xc_ctx;
  385. spin_lock(&cil->xc_cil_lock);
  386. push_seq = cil->xc_push_seq;
  387. ASSERT(push_seq <= ctx->sequence);
  388. /*
  389. * Check if we've anything to push. If there is nothing, then we don't
  390. * move on to a new sequence number and so we have to be able to push
  391. * this sequence again later.
  392. */
  393. if (list_empty(&cil->xc_cil)) {
  394. cil->xc_push_seq = 0;
  395. spin_unlock(&cil->xc_cil_lock);
  396. goto out_skip;
  397. }
  398. spin_unlock(&cil->xc_cil_lock);
  399. /* check for a previously pushed seqeunce */
  400. if (push_seq < cil->xc_ctx->sequence)
  401. goto out_skip;
  402. /*
  403. * pull all the log vectors off the items in the CIL, and
  404. * remove the items from the CIL. We don't need the CIL lock
  405. * here because it's only needed on the transaction commit
  406. * side which is currently locked out by the flush lock.
  407. */
  408. lv = NULL;
  409. num_iovecs = 0;
  410. while (!list_empty(&cil->xc_cil)) {
  411. struct xfs_log_item *item;
  412. item = list_first_entry(&cil->xc_cil,
  413. struct xfs_log_item, li_cil);
  414. list_del_init(&item->li_cil);
  415. if (!ctx->lv_chain)
  416. ctx->lv_chain = item->li_lv;
  417. else
  418. lv->lv_next = item->li_lv;
  419. lv = item->li_lv;
  420. item->li_lv = NULL;
  421. num_iovecs += lv->lv_niovecs;
  422. }
  423. /*
  424. * initialise the new context and attach it to the CIL. Then attach
  425. * the current context to the CIL committing lsit so it can be found
  426. * during log forces to extract the commit lsn of the sequence that
  427. * needs to be forced.
  428. */
  429. INIT_LIST_HEAD(&new_ctx->committing);
  430. INIT_LIST_HEAD(&new_ctx->busy_extents);
  431. new_ctx->sequence = ctx->sequence + 1;
  432. new_ctx->cil = cil;
  433. cil->xc_ctx = new_ctx;
  434. /*
  435. * mirror the new sequence into the cil structure so that we can do
  436. * unlocked checks against the current sequence in log forces without
  437. * risking deferencing a freed context pointer.
  438. */
  439. cil->xc_current_sequence = new_ctx->sequence;
  440. /*
  441. * The switch is now done, so we can drop the context lock and move out
  442. * of a shared context. We can't just go straight to the commit record,
  443. * though - we need to synchronise with previous and future commits so
  444. * that the commit records are correctly ordered in the log to ensure
  445. * that we process items during log IO completion in the correct order.
  446. *
  447. * For example, if we get an EFI in one checkpoint and the EFD in the
  448. * next (e.g. due to log forces), we do not want the checkpoint with
  449. * the EFD to be committed before the checkpoint with the EFI. Hence
  450. * we must strictly order the commit records of the checkpoints so
  451. * that: a) the checkpoint callbacks are attached to the iclogs in the
  452. * correct order; and b) the checkpoints are replayed in correct order
  453. * in log recovery.
  454. *
  455. * Hence we need to add this context to the committing context list so
  456. * that higher sequences will wait for us to write out a commit record
  457. * before they do.
  458. */
  459. spin_lock(&cil->xc_cil_lock);
  460. list_add(&ctx->committing, &cil->xc_committing);
  461. spin_unlock(&cil->xc_cil_lock);
  462. up_write(&cil->xc_ctx_lock);
  463. /*
  464. * Build a checkpoint transaction header and write it to the log to
  465. * begin the transaction. We need to account for the space used by the
  466. * transaction header here as it is not accounted for in xlog_write().
  467. *
  468. * The LSN we need to pass to the log items on transaction commit is
  469. * the LSN reported by the first log vector write. If we use the commit
  470. * record lsn then we can move the tail beyond the grant write head.
  471. */
  472. tic = ctx->ticket;
  473. thdr.th_magic = XFS_TRANS_HEADER_MAGIC;
  474. thdr.th_type = XFS_TRANS_CHECKPOINT;
  475. thdr.th_tid = tic->t_tid;
  476. thdr.th_num_items = num_iovecs;
  477. lhdr.i_addr = &thdr;
  478. lhdr.i_len = sizeof(xfs_trans_header_t);
  479. lhdr.i_type = XLOG_REG_TYPE_TRANSHDR;
  480. tic->t_curr_res -= lhdr.i_len + sizeof(xlog_op_header_t);
  481. lvhdr.lv_niovecs = 1;
  482. lvhdr.lv_iovecp = &lhdr;
  483. lvhdr.lv_next = ctx->lv_chain;
  484. error = xlog_write(log, &lvhdr, tic, &ctx->start_lsn, NULL, 0);
  485. if (error)
  486. goto out_abort_free_ticket;
  487. /*
  488. * now that we've written the checkpoint into the log, strictly
  489. * order the commit records so replay will get them in the right order.
  490. */
  491. restart:
  492. spin_lock(&cil->xc_cil_lock);
  493. list_for_each_entry(new_ctx, &cil->xc_committing, committing) {
  494. /*
  495. * Higher sequences will wait for this one so skip them.
  496. * Don't wait for own own sequence, either.
  497. */
  498. if (new_ctx->sequence >= ctx->sequence)
  499. continue;
  500. if (!new_ctx->commit_lsn) {
  501. /*
  502. * It is still being pushed! Wait for the push to
  503. * complete, then start again from the beginning.
  504. */
  505. xlog_wait(&cil->xc_commit_wait, &cil->xc_cil_lock);
  506. goto restart;
  507. }
  508. }
  509. spin_unlock(&cil->xc_cil_lock);
  510. /* xfs_log_done always frees the ticket on error. */
  511. commit_lsn = xfs_log_done(log->l_mp, tic, &commit_iclog, 0);
  512. if (commit_lsn == -1)
  513. goto out_abort;
  514. /* attach all the transactions w/ busy extents to iclog */
  515. ctx->log_cb.cb_func = xlog_cil_committed;
  516. ctx->log_cb.cb_arg = ctx;
  517. error = xfs_log_notify(log->l_mp, commit_iclog, &ctx->log_cb);
  518. if (error)
  519. goto out_abort;
  520. /*
  521. * now the checkpoint commit is complete and we've attached the
  522. * callbacks to the iclog we can assign the commit LSN to the context
  523. * and wake up anyone who is waiting for the commit to complete.
  524. */
  525. spin_lock(&cil->xc_cil_lock);
  526. ctx->commit_lsn = commit_lsn;
  527. wake_up_all(&cil->xc_commit_wait);
  528. spin_unlock(&cil->xc_cil_lock);
  529. /* release the hounds! */
  530. return xfs_log_release_iclog(log->l_mp, commit_iclog);
  531. out_skip:
  532. up_write(&cil->xc_ctx_lock);
  533. xfs_log_ticket_put(new_ctx->ticket);
  534. kmem_free(new_ctx);
  535. return 0;
  536. out_abort_free_ticket:
  537. xfs_log_ticket_put(tic);
  538. out_abort:
  539. xlog_cil_committed(ctx, XFS_LI_ABORTED);
  540. return XFS_ERROR(EIO);
  541. }
  542. static void
  543. xlog_cil_push_work(
  544. struct work_struct *work)
  545. {
  546. struct xfs_cil *cil = container_of(work, struct xfs_cil,
  547. xc_push_work);
  548. xlog_cil_push(cil->xc_log);
  549. }
  550. /*
  551. * We need to push CIL every so often so we don't cache more than we can fit in
  552. * the log. The limit really is that a checkpoint can't be more than half the
  553. * log (the current checkpoint is not allowed to overwrite the previous
  554. * checkpoint), but commit latency and memory usage limit this to a smaller
  555. * size.
  556. */
  557. static void
  558. xlog_cil_push_background(
  559. struct xlog *log)
  560. {
  561. struct xfs_cil *cil = log->l_cilp;
  562. /*
  563. * The cil won't be empty because we are called while holding the
  564. * context lock so whatever we added to the CIL will still be there
  565. */
  566. ASSERT(!list_empty(&cil->xc_cil));
  567. /*
  568. * don't do a background push if we haven't used up all the
  569. * space available yet.
  570. */
  571. if (cil->xc_ctx->space_used < XLOG_CIL_SPACE_LIMIT(log))
  572. return;
  573. spin_lock(&cil->xc_cil_lock);
  574. if (cil->xc_push_seq < cil->xc_current_sequence) {
  575. cil->xc_push_seq = cil->xc_current_sequence;
  576. queue_work(log->l_mp->m_cil_workqueue, &cil->xc_push_work);
  577. }
  578. spin_unlock(&cil->xc_cil_lock);
  579. }
  580. static void
  581. xlog_cil_push_foreground(
  582. struct xlog *log,
  583. xfs_lsn_t push_seq)
  584. {
  585. struct xfs_cil *cil = log->l_cilp;
  586. if (!cil)
  587. return;
  588. ASSERT(push_seq && push_seq <= cil->xc_current_sequence);
  589. /* start on any pending background push to minimise wait time on it */
  590. flush_work(&cil->xc_push_work);
  591. /*
  592. * If the CIL is empty or we've already pushed the sequence then
  593. * there's no work we need to do.
  594. */
  595. spin_lock(&cil->xc_cil_lock);
  596. if (list_empty(&cil->xc_cil) || push_seq <= cil->xc_push_seq) {
  597. spin_unlock(&cil->xc_cil_lock);
  598. return;
  599. }
  600. cil->xc_push_seq = push_seq;
  601. spin_unlock(&cil->xc_cil_lock);
  602. /* do the push now */
  603. xlog_cil_push(log);
  604. }
  605. /*
  606. * Commit a transaction with the given vector to the Committed Item List.
  607. *
  608. * To do this, we need to format the item, pin it in memory if required and
  609. * account for the space used by the transaction. Once we have done that we
  610. * need to release the unused reservation for the transaction, attach the
  611. * transaction to the checkpoint context so we carry the busy extents through
  612. * to checkpoint completion, and then unlock all the items in the transaction.
  613. *
  614. * Called with the context lock already held in read mode to lock out
  615. * background commit, returns without it held once background commits are
  616. * allowed again.
  617. */
  618. int
  619. xfs_log_commit_cil(
  620. struct xfs_mount *mp,
  621. struct xfs_trans *tp,
  622. xfs_lsn_t *commit_lsn,
  623. int flags)
  624. {
  625. struct xlog *log = mp->m_log;
  626. int log_flags = 0;
  627. struct xfs_log_vec *log_vector;
  628. if (flags & XFS_TRANS_RELEASE_LOG_RES)
  629. log_flags = XFS_LOG_REL_PERM_RESERV;
  630. /*
  631. * Do all the hard work of formatting items (including memory
  632. * allocation) outside the CIL context lock. This prevents stalling CIL
  633. * pushes when we are low on memory and a transaction commit spends a
  634. * lot of time in memory reclaim.
  635. */
  636. log_vector = xlog_cil_prepare_log_vecs(tp);
  637. if (!log_vector)
  638. return ENOMEM;
  639. /* lock out background commit */
  640. down_read(&log->l_cilp->xc_ctx_lock);
  641. if (commit_lsn)
  642. *commit_lsn = log->l_cilp->xc_ctx->sequence;
  643. /* xlog_cil_insert_items() destroys log_vector list */
  644. xlog_cil_insert_items(log, log_vector, tp->t_ticket);
  645. /* check we didn't blow the reservation */
  646. if (tp->t_ticket->t_curr_res < 0)
  647. xlog_print_tic_res(log->l_mp, tp->t_ticket);
  648. /* attach the transaction to the CIL if it has any busy extents */
  649. if (!list_empty(&tp->t_busy)) {
  650. spin_lock(&log->l_cilp->xc_cil_lock);
  651. list_splice_init(&tp->t_busy,
  652. &log->l_cilp->xc_ctx->busy_extents);
  653. spin_unlock(&log->l_cilp->xc_cil_lock);
  654. }
  655. tp->t_commit_lsn = *commit_lsn;
  656. xfs_log_done(mp, tp->t_ticket, NULL, log_flags);
  657. xfs_trans_unreserve_and_mod_sb(tp);
  658. /*
  659. * Once all the items of the transaction have been copied to the CIL,
  660. * the items can be unlocked and freed.
  661. *
  662. * This needs to be done before we drop the CIL context lock because we
  663. * have to update state in the log items and unlock them before they go
  664. * to disk. If we don't, then the CIL checkpoint can race with us and
  665. * we can run checkpoint completion before we've updated and unlocked
  666. * the log items. This affects (at least) processing of stale buffers,
  667. * inodes and EFIs.
  668. */
  669. xfs_trans_free_items(tp, *commit_lsn, 0);
  670. xlog_cil_push_background(log);
  671. up_read(&log->l_cilp->xc_ctx_lock);
  672. return 0;
  673. }
  674. /*
  675. * Conditionally push the CIL based on the sequence passed in.
  676. *
  677. * We only need to push if we haven't already pushed the sequence
  678. * number given. Hence the only time we will trigger a push here is
  679. * if the push sequence is the same as the current context.
  680. *
  681. * We return the current commit lsn to allow the callers to determine if a
  682. * iclog flush is necessary following this call.
  683. */
  684. xfs_lsn_t
  685. xlog_cil_force_lsn(
  686. struct xlog *log,
  687. xfs_lsn_t sequence)
  688. {
  689. struct xfs_cil *cil = log->l_cilp;
  690. struct xfs_cil_ctx *ctx;
  691. xfs_lsn_t commit_lsn = NULLCOMMITLSN;
  692. ASSERT(sequence <= cil->xc_current_sequence);
  693. /*
  694. * check to see if we need to force out the current context.
  695. * xlog_cil_push() handles racing pushes for the same sequence,
  696. * so no need to deal with it here.
  697. */
  698. xlog_cil_push_foreground(log, sequence);
  699. /*
  700. * See if we can find a previous sequence still committing.
  701. * We need to wait for all previous sequence commits to complete
  702. * before allowing the force of push_seq to go ahead. Hence block
  703. * on commits for those as well.
  704. */
  705. restart:
  706. spin_lock(&cil->xc_cil_lock);
  707. list_for_each_entry(ctx, &cil->xc_committing, committing) {
  708. if (ctx->sequence > sequence)
  709. continue;
  710. if (!ctx->commit_lsn) {
  711. /*
  712. * It is still being pushed! Wait for the push to
  713. * complete, then start again from the beginning.
  714. */
  715. xlog_wait(&cil->xc_commit_wait, &cil->xc_cil_lock);
  716. goto restart;
  717. }
  718. if (ctx->sequence != sequence)
  719. continue;
  720. /* found it! */
  721. commit_lsn = ctx->commit_lsn;
  722. }
  723. spin_unlock(&cil->xc_cil_lock);
  724. return commit_lsn;
  725. }
  726. /*
  727. * Check if the current log item was first committed in this sequence.
  728. * We can't rely on just the log item being in the CIL, we have to check
  729. * the recorded commit sequence number.
  730. *
  731. * Note: for this to be used in a non-racy manner, it has to be called with
  732. * CIL flushing locked out. As a result, it should only be used during the
  733. * transaction commit process when deciding what to format into the item.
  734. */
  735. bool
  736. xfs_log_item_in_current_chkpt(
  737. struct xfs_log_item *lip)
  738. {
  739. struct xfs_cil_ctx *ctx;
  740. if (list_empty(&lip->li_cil))
  741. return false;
  742. ctx = lip->li_mountp->m_log->l_cilp->xc_ctx;
  743. /*
  744. * li_seq is written on the first commit of a log item to record the
  745. * first checkpoint it is written to. Hence if it is different to the
  746. * current sequence, we're in a new checkpoint.
  747. */
  748. if (XFS_LSN_CMP(lip->li_seq, ctx->sequence) != 0)
  749. return false;
  750. return true;
  751. }
  752. /*
  753. * Perform initial CIL structure initialisation.
  754. */
  755. int
  756. xlog_cil_init(
  757. struct xlog *log)
  758. {
  759. struct xfs_cil *cil;
  760. struct xfs_cil_ctx *ctx;
  761. cil = kmem_zalloc(sizeof(*cil), KM_SLEEP|KM_MAYFAIL);
  762. if (!cil)
  763. return ENOMEM;
  764. ctx = kmem_zalloc(sizeof(*ctx), KM_SLEEP|KM_MAYFAIL);
  765. if (!ctx) {
  766. kmem_free(cil);
  767. return ENOMEM;
  768. }
  769. INIT_WORK(&cil->xc_push_work, xlog_cil_push_work);
  770. INIT_LIST_HEAD(&cil->xc_cil);
  771. INIT_LIST_HEAD(&cil->xc_committing);
  772. spin_lock_init(&cil->xc_cil_lock);
  773. init_rwsem(&cil->xc_ctx_lock);
  774. init_waitqueue_head(&cil->xc_commit_wait);
  775. INIT_LIST_HEAD(&ctx->committing);
  776. INIT_LIST_HEAD(&ctx->busy_extents);
  777. ctx->sequence = 1;
  778. ctx->cil = cil;
  779. cil->xc_ctx = ctx;
  780. cil->xc_current_sequence = ctx->sequence;
  781. cil->xc_log = log;
  782. log->l_cilp = cil;
  783. return 0;
  784. }
  785. void
  786. xlog_cil_destroy(
  787. struct xlog *log)
  788. {
  789. if (log->l_cilp->xc_ctx) {
  790. if (log->l_cilp->xc_ctx->ticket)
  791. xfs_log_ticket_put(log->l_cilp->xc_ctx->ticket);
  792. kmem_free(log->l_cilp->xc_ctx);
  793. }
  794. ASSERT(list_empty(&log->l_cilp->xc_cil));
  795. kmem_free(log->l_cilp);
  796. }