xfs_trans.c 35 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364
  1. /*
  2. * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
  3. * All Rights Reserved.
  4. *
  5. * This program is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU General Public License as
  7. * published by the Free Software Foundation.
  8. *
  9. * This program is distributed in the hope that it would be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write the Free Software Foundation,
  16. * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17. */
  18. #include "xfs.h"
  19. #include "xfs_fs.h"
  20. #include "xfs_types.h"
  21. #include "xfs_bit.h"
  22. #include "xfs_log.h"
  23. #include "xfs_inum.h"
  24. #include "xfs_trans.h"
  25. #include "xfs_sb.h"
  26. #include "xfs_ag.h"
  27. #include "xfs_dir2.h"
  28. #include "xfs_dmapi.h"
  29. #include "xfs_mount.h"
  30. #include "xfs_error.h"
  31. #include "xfs_da_btree.h"
  32. #include "xfs_bmap_btree.h"
  33. #include "xfs_alloc_btree.h"
  34. #include "xfs_ialloc_btree.h"
  35. #include "xfs_dir2_sf.h"
  36. #include "xfs_attr_sf.h"
  37. #include "xfs_dinode.h"
  38. #include "xfs_inode.h"
  39. #include "xfs_btree.h"
  40. #include "xfs_ialloc.h"
  41. #include "xfs_alloc.h"
  42. #include "xfs_bmap.h"
  43. #include "xfs_quota.h"
  44. #include "xfs_trans_priv.h"
  45. #include "xfs_trans_space.h"
  46. STATIC void xfs_trans_apply_sb_deltas(xfs_trans_t *);
  47. STATIC uint xfs_trans_count_vecs(xfs_trans_t *);
  48. STATIC void xfs_trans_fill_vecs(xfs_trans_t *, xfs_log_iovec_t *);
  49. STATIC void xfs_trans_uncommit(xfs_trans_t *, uint);
  50. STATIC void xfs_trans_committed(xfs_trans_t *, int);
  51. STATIC void xfs_trans_chunk_committed(xfs_log_item_chunk_t *, xfs_lsn_t, int);
  52. STATIC void xfs_trans_free(xfs_trans_t *);
  53. kmem_zone_t *xfs_trans_zone;
  54. /*
  55. * Reservation functions here avoid a huge stack in xfs_trans_init
  56. * due to register overflow from temporaries in the calculations.
  57. */
  58. STATIC uint
  59. xfs_calc_write_reservation(xfs_mount_t *mp)
  60. {
  61. return XFS_CALC_WRITE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
  62. }
  63. STATIC uint
  64. xfs_calc_itruncate_reservation(xfs_mount_t *mp)
  65. {
  66. return XFS_CALC_ITRUNCATE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
  67. }
  68. STATIC uint
  69. xfs_calc_rename_reservation(xfs_mount_t *mp)
  70. {
  71. return XFS_CALC_RENAME_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
  72. }
  73. STATIC uint
  74. xfs_calc_link_reservation(xfs_mount_t *mp)
  75. {
  76. return XFS_CALC_LINK_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
  77. }
  78. STATIC uint
  79. xfs_calc_remove_reservation(xfs_mount_t *mp)
  80. {
  81. return XFS_CALC_REMOVE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
  82. }
  83. STATIC uint
  84. xfs_calc_symlink_reservation(xfs_mount_t *mp)
  85. {
  86. return XFS_CALC_SYMLINK_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
  87. }
  88. STATIC uint
  89. xfs_calc_create_reservation(xfs_mount_t *mp)
  90. {
  91. return XFS_CALC_CREATE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
  92. }
  93. STATIC uint
  94. xfs_calc_mkdir_reservation(xfs_mount_t *mp)
  95. {
  96. return XFS_CALC_MKDIR_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
  97. }
  98. STATIC uint
  99. xfs_calc_ifree_reservation(xfs_mount_t *mp)
  100. {
  101. return XFS_CALC_IFREE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
  102. }
  103. STATIC uint
  104. xfs_calc_ichange_reservation(xfs_mount_t *mp)
  105. {
  106. return XFS_CALC_ICHANGE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
  107. }
  108. STATIC uint
  109. xfs_calc_growdata_reservation(xfs_mount_t *mp)
  110. {
  111. return XFS_CALC_GROWDATA_LOG_RES(mp);
  112. }
  113. STATIC uint
  114. xfs_calc_growrtalloc_reservation(xfs_mount_t *mp)
  115. {
  116. return XFS_CALC_GROWRTALLOC_LOG_RES(mp);
  117. }
  118. STATIC uint
  119. xfs_calc_growrtzero_reservation(xfs_mount_t *mp)
  120. {
  121. return XFS_CALC_GROWRTZERO_LOG_RES(mp);
  122. }
  123. STATIC uint
  124. xfs_calc_growrtfree_reservation(xfs_mount_t *mp)
  125. {
  126. return XFS_CALC_GROWRTFREE_LOG_RES(mp);
  127. }
  128. STATIC uint
  129. xfs_calc_swrite_reservation(xfs_mount_t *mp)
  130. {
  131. return XFS_CALC_SWRITE_LOG_RES(mp);
  132. }
  133. STATIC uint
  134. xfs_calc_writeid_reservation(xfs_mount_t *mp)
  135. {
  136. return XFS_CALC_WRITEID_LOG_RES(mp);
  137. }
  138. STATIC uint
  139. xfs_calc_addafork_reservation(xfs_mount_t *mp)
  140. {
  141. return XFS_CALC_ADDAFORK_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
  142. }
  143. STATIC uint
  144. xfs_calc_attrinval_reservation(xfs_mount_t *mp)
  145. {
  146. return XFS_CALC_ATTRINVAL_LOG_RES(mp);
  147. }
  148. STATIC uint
  149. xfs_calc_attrset_reservation(xfs_mount_t *mp)
  150. {
  151. return XFS_CALC_ATTRSET_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
  152. }
  153. STATIC uint
  154. xfs_calc_attrrm_reservation(xfs_mount_t *mp)
  155. {
  156. return XFS_CALC_ATTRRM_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp);
  157. }
  158. STATIC uint
  159. xfs_calc_clear_agi_bucket_reservation(xfs_mount_t *mp)
  160. {
  161. return XFS_CALC_CLEAR_AGI_BUCKET_LOG_RES(mp);
  162. }
  163. /*
  164. * Initialize the precomputed transaction reservation values
  165. * in the mount structure.
  166. */
  167. void
  168. xfs_trans_init(
  169. xfs_mount_t *mp)
  170. {
  171. xfs_trans_reservations_t *resp;
  172. resp = &(mp->m_reservations);
  173. resp->tr_write = xfs_calc_write_reservation(mp);
  174. resp->tr_itruncate = xfs_calc_itruncate_reservation(mp);
  175. resp->tr_rename = xfs_calc_rename_reservation(mp);
  176. resp->tr_link = xfs_calc_link_reservation(mp);
  177. resp->tr_remove = xfs_calc_remove_reservation(mp);
  178. resp->tr_symlink = xfs_calc_symlink_reservation(mp);
  179. resp->tr_create = xfs_calc_create_reservation(mp);
  180. resp->tr_mkdir = xfs_calc_mkdir_reservation(mp);
  181. resp->tr_ifree = xfs_calc_ifree_reservation(mp);
  182. resp->tr_ichange = xfs_calc_ichange_reservation(mp);
  183. resp->tr_growdata = xfs_calc_growdata_reservation(mp);
  184. resp->tr_swrite = xfs_calc_swrite_reservation(mp);
  185. resp->tr_writeid = xfs_calc_writeid_reservation(mp);
  186. resp->tr_addafork = xfs_calc_addafork_reservation(mp);
  187. resp->tr_attrinval = xfs_calc_attrinval_reservation(mp);
  188. resp->tr_attrset = xfs_calc_attrset_reservation(mp);
  189. resp->tr_attrrm = xfs_calc_attrrm_reservation(mp);
  190. resp->tr_clearagi = xfs_calc_clear_agi_bucket_reservation(mp);
  191. resp->tr_growrtalloc = xfs_calc_growrtalloc_reservation(mp);
  192. resp->tr_growrtzero = xfs_calc_growrtzero_reservation(mp);
  193. resp->tr_growrtfree = xfs_calc_growrtfree_reservation(mp);
  194. }
  195. /*
  196. * This routine is called to allocate a transaction structure.
  197. * The type parameter indicates the type of the transaction. These
  198. * are enumerated in xfs_trans.h.
  199. *
  200. * Dynamically allocate the transaction structure from the transaction
  201. * zone, initialize it, and return it to the caller.
  202. */
  203. xfs_trans_t *
  204. xfs_trans_alloc(
  205. xfs_mount_t *mp,
  206. uint type)
  207. {
  208. vfs_wait_for_freeze(XFS_MTOVFS(mp), SB_FREEZE_TRANS);
  209. return _xfs_trans_alloc(mp, type);
  210. }
  211. xfs_trans_t *
  212. _xfs_trans_alloc(
  213. xfs_mount_t *mp,
  214. uint type)
  215. {
  216. xfs_trans_t *tp;
  217. atomic_inc(&mp->m_active_trans);
  218. tp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);
  219. tp->t_magic = XFS_TRANS_MAGIC;
  220. tp->t_type = type;
  221. tp->t_mountp = mp;
  222. tp->t_items_free = XFS_LIC_NUM_SLOTS;
  223. tp->t_busy_free = XFS_LBC_NUM_SLOTS;
  224. XFS_LIC_INIT(&(tp->t_items));
  225. XFS_LBC_INIT(&(tp->t_busy));
  226. return tp;
  227. }
  228. /*
  229. * This is called to create a new transaction which will share the
  230. * permanent log reservation of the given transaction. The remaining
  231. * unused block and rt extent reservations are also inherited. This
  232. * implies that the original transaction is no longer allowed to allocate
  233. * blocks. Locks and log items, however, are no inherited. They must
  234. * be added to the new transaction explicitly.
  235. */
  236. xfs_trans_t *
  237. xfs_trans_dup(
  238. xfs_trans_t *tp)
  239. {
  240. xfs_trans_t *ntp;
  241. ntp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);
  242. /*
  243. * Initialize the new transaction structure.
  244. */
  245. ntp->t_magic = XFS_TRANS_MAGIC;
  246. ntp->t_type = tp->t_type;
  247. ntp->t_mountp = tp->t_mountp;
  248. ntp->t_items_free = XFS_LIC_NUM_SLOTS;
  249. ntp->t_busy_free = XFS_LBC_NUM_SLOTS;
  250. XFS_LIC_INIT(&(ntp->t_items));
  251. XFS_LBC_INIT(&(ntp->t_busy));
  252. ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
  253. ASSERT(tp->t_ticket != NULL);
  254. ntp->t_flags = XFS_TRANS_PERM_LOG_RES | (tp->t_flags & XFS_TRANS_RESERVE);
  255. ntp->t_ticket = tp->t_ticket;
  256. ntp->t_blk_res = tp->t_blk_res - tp->t_blk_res_used;
  257. tp->t_blk_res = tp->t_blk_res_used;
  258. ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used;
  259. tp->t_rtx_res = tp->t_rtx_res_used;
  260. ntp->t_pflags = tp->t_pflags;
  261. XFS_TRANS_DUP_DQINFO(tp->t_mountp, tp, ntp);
  262. atomic_inc(&tp->t_mountp->m_active_trans);
  263. return ntp;
  264. }
  265. /*
  266. * This is called to reserve free disk blocks and log space for the
  267. * given transaction. This must be done before allocating any resources
  268. * within the transaction.
  269. *
  270. * This will return ENOSPC if there are not enough blocks available.
  271. * It will sleep waiting for available log space.
  272. * The only valid value for the flags parameter is XFS_RES_LOG_PERM, which
  273. * is used by long running transactions. If any one of the reservations
  274. * fails then they will all be backed out.
  275. *
  276. * This does not do quota reservations. That typically is done by the
  277. * caller afterwards.
  278. */
  279. int
  280. xfs_trans_reserve(
  281. xfs_trans_t *tp,
  282. uint blocks,
  283. uint logspace,
  284. uint rtextents,
  285. uint flags,
  286. uint logcount)
  287. {
  288. int log_flags;
  289. int error = 0;
  290. int rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
  291. /* Mark this thread as being in a transaction */
  292. current_set_flags_nested(&tp->t_pflags, PF_FSTRANS);
  293. /*
  294. * Attempt to reserve the needed disk blocks by decrementing
  295. * the number needed from the number available. This will
  296. * fail if the count would go below zero.
  297. */
  298. if (blocks > 0) {
  299. error = xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FDBLOCKS,
  300. -((int64_t)blocks), rsvd);
  301. if (error != 0) {
  302. current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
  303. return (XFS_ERROR(ENOSPC));
  304. }
  305. tp->t_blk_res += blocks;
  306. }
  307. /*
  308. * Reserve the log space needed for this transaction.
  309. */
  310. if (logspace > 0) {
  311. ASSERT((tp->t_log_res == 0) || (tp->t_log_res == logspace));
  312. ASSERT((tp->t_log_count == 0) ||
  313. (tp->t_log_count == logcount));
  314. if (flags & XFS_TRANS_PERM_LOG_RES) {
  315. log_flags = XFS_LOG_PERM_RESERV;
  316. tp->t_flags |= XFS_TRANS_PERM_LOG_RES;
  317. } else {
  318. ASSERT(tp->t_ticket == NULL);
  319. ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
  320. log_flags = 0;
  321. }
  322. error = xfs_log_reserve(tp->t_mountp, logspace, logcount,
  323. &tp->t_ticket,
  324. XFS_TRANSACTION, log_flags, tp->t_type);
  325. if (error) {
  326. goto undo_blocks;
  327. }
  328. tp->t_log_res = logspace;
  329. tp->t_log_count = logcount;
  330. }
  331. /*
  332. * Attempt to reserve the needed realtime extents by decrementing
  333. * the number needed from the number available. This will
  334. * fail if the count would go below zero.
  335. */
  336. if (rtextents > 0) {
  337. error = xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FREXTENTS,
  338. -((int64_t)rtextents), rsvd);
  339. if (error) {
  340. error = XFS_ERROR(ENOSPC);
  341. goto undo_log;
  342. }
  343. tp->t_rtx_res += rtextents;
  344. }
  345. return 0;
  346. /*
  347. * Error cases jump to one of these labels to undo any
  348. * reservations which have already been performed.
  349. */
  350. undo_log:
  351. if (logspace > 0) {
  352. if (flags & XFS_TRANS_PERM_LOG_RES) {
  353. log_flags = XFS_LOG_REL_PERM_RESERV;
  354. } else {
  355. log_flags = 0;
  356. }
  357. xfs_log_done(tp->t_mountp, tp->t_ticket, NULL, log_flags);
  358. tp->t_ticket = NULL;
  359. tp->t_log_res = 0;
  360. tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES;
  361. }
  362. undo_blocks:
  363. if (blocks > 0) {
  364. (void) xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FDBLOCKS,
  365. (int64_t)blocks, rsvd);
  366. tp->t_blk_res = 0;
  367. }
  368. current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
  369. return error;
  370. }
  371. /*
  372. * Record the indicated change to the given field for application
  373. * to the file system's superblock when the transaction commits.
  374. * For now, just store the change in the transaction structure.
  375. *
  376. * Mark the transaction structure to indicate that the superblock
  377. * needs to be updated before committing.
  378. */
  379. void
  380. xfs_trans_mod_sb(
  381. xfs_trans_t *tp,
  382. uint field,
  383. int64_t delta)
  384. {
  385. switch (field) {
  386. case XFS_TRANS_SB_ICOUNT:
  387. tp->t_icount_delta += delta;
  388. break;
  389. case XFS_TRANS_SB_IFREE:
  390. tp->t_ifree_delta += delta;
  391. break;
  392. case XFS_TRANS_SB_FDBLOCKS:
  393. /*
  394. * Track the number of blocks allocated in the
  395. * transaction. Make sure it does not exceed the
  396. * number reserved.
  397. */
  398. if (delta < 0) {
  399. tp->t_blk_res_used += (uint)-delta;
  400. ASSERT(tp->t_blk_res_used <= tp->t_blk_res);
  401. }
  402. tp->t_fdblocks_delta += delta;
  403. break;
  404. case XFS_TRANS_SB_RES_FDBLOCKS:
  405. /*
  406. * The allocation has already been applied to the
  407. * in-core superblock's counter. This should only
  408. * be applied to the on-disk superblock.
  409. */
  410. ASSERT(delta < 0);
  411. tp->t_res_fdblocks_delta += delta;
  412. break;
  413. case XFS_TRANS_SB_FREXTENTS:
  414. /*
  415. * Track the number of blocks allocated in the
  416. * transaction. Make sure it does not exceed the
  417. * number reserved.
  418. */
  419. if (delta < 0) {
  420. tp->t_rtx_res_used += (uint)-delta;
  421. ASSERT(tp->t_rtx_res_used <= tp->t_rtx_res);
  422. }
  423. tp->t_frextents_delta += delta;
  424. break;
  425. case XFS_TRANS_SB_RES_FREXTENTS:
  426. /*
  427. * The allocation has already been applied to the
  428. * in-core superblock's counter. This should only
  429. * be applied to the on-disk superblock.
  430. */
  431. ASSERT(delta < 0);
  432. tp->t_res_frextents_delta += delta;
  433. break;
  434. case XFS_TRANS_SB_DBLOCKS:
  435. ASSERT(delta > 0);
  436. tp->t_dblocks_delta += delta;
  437. break;
  438. case XFS_TRANS_SB_AGCOUNT:
  439. ASSERT(delta > 0);
  440. tp->t_agcount_delta += delta;
  441. break;
  442. case XFS_TRANS_SB_IMAXPCT:
  443. tp->t_imaxpct_delta += delta;
  444. break;
  445. case XFS_TRANS_SB_REXTSIZE:
  446. tp->t_rextsize_delta += delta;
  447. break;
  448. case XFS_TRANS_SB_RBMBLOCKS:
  449. tp->t_rbmblocks_delta += delta;
  450. break;
  451. case XFS_TRANS_SB_RBLOCKS:
  452. tp->t_rblocks_delta += delta;
  453. break;
  454. case XFS_TRANS_SB_REXTENTS:
  455. tp->t_rextents_delta += delta;
  456. break;
  457. case XFS_TRANS_SB_REXTSLOG:
  458. tp->t_rextslog_delta += delta;
  459. break;
  460. default:
  461. ASSERT(0);
  462. return;
  463. }
  464. tp->t_flags |= (XFS_TRANS_SB_DIRTY | XFS_TRANS_DIRTY);
  465. }
  466. /*
  467. * xfs_trans_apply_sb_deltas() is called from the commit code
  468. * to bring the superblock buffer into the current transaction
  469. * and modify it as requested by earlier calls to xfs_trans_mod_sb().
  470. *
  471. * For now we just look at each field allowed to change and change
  472. * it if necessary.
  473. */
  474. STATIC void
  475. xfs_trans_apply_sb_deltas(
  476. xfs_trans_t *tp)
  477. {
  478. xfs_sb_t *sbp;
  479. xfs_buf_t *bp;
  480. int whole = 0;
  481. bp = xfs_trans_getsb(tp, tp->t_mountp, 0);
  482. sbp = XFS_BUF_TO_SBP(bp);
  483. /*
  484. * Check that superblock mods match the mods made to AGF counters.
  485. */
  486. ASSERT((tp->t_fdblocks_delta + tp->t_res_fdblocks_delta) ==
  487. (tp->t_ag_freeblks_delta + tp->t_ag_flist_delta +
  488. tp->t_ag_btree_delta));
  489. if (tp->t_icount_delta != 0) {
  490. INT_MOD(sbp->sb_icount, ARCH_CONVERT, tp->t_icount_delta);
  491. }
  492. if (tp->t_ifree_delta != 0) {
  493. INT_MOD(sbp->sb_ifree, ARCH_CONVERT, tp->t_ifree_delta);
  494. }
  495. if (tp->t_fdblocks_delta != 0) {
  496. INT_MOD(sbp->sb_fdblocks, ARCH_CONVERT, tp->t_fdblocks_delta);
  497. }
  498. if (tp->t_res_fdblocks_delta != 0) {
  499. INT_MOD(sbp->sb_fdblocks, ARCH_CONVERT, tp->t_res_fdblocks_delta);
  500. }
  501. if (tp->t_frextents_delta != 0) {
  502. INT_MOD(sbp->sb_frextents, ARCH_CONVERT, tp->t_frextents_delta);
  503. }
  504. if (tp->t_res_frextents_delta != 0) {
  505. INT_MOD(sbp->sb_frextents, ARCH_CONVERT, tp->t_res_frextents_delta);
  506. }
  507. if (tp->t_dblocks_delta != 0) {
  508. INT_MOD(sbp->sb_dblocks, ARCH_CONVERT, tp->t_dblocks_delta);
  509. whole = 1;
  510. }
  511. if (tp->t_agcount_delta != 0) {
  512. INT_MOD(sbp->sb_agcount, ARCH_CONVERT, tp->t_agcount_delta);
  513. whole = 1;
  514. }
  515. if (tp->t_imaxpct_delta != 0) {
  516. INT_MOD(sbp->sb_imax_pct, ARCH_CONVERT, tp->t_imaxpct_delta);
  517. whole = 1;
  518. }
  519. if (tp->t_rextsize_delta != 0) {
  520. INT_MOD(sbp->sb_rextsize, ARCH_CONVERT, tp->t_rextsize_delta);
  521. whole = 1;
  522. }
  523. if (tp->t_rbmblocks_delta != 0) {
  524. INT_MOD(sbp->sb_rbmblocks, ARCH_CONVERT, tp->t_rbmblocks_delta);
  525. whole = 1;
  526. }
  527. if (tp->t_rblocks_delta != 0) {
  528. INT_MOD(sbp->sb_rblocks, ARCH_CONVERT, tp->t_rblocks_delta);
  529. whole = 1;
  530. }
  531. if (tp->t_rextents_delta != 0) {
  532. INT_MOD(sbp->sb_rextents, ARCH_CONVERT, tp->t_rextents_delta);
  533. whole = 1;
  534. }
  535. if (tp->t_rextslog_delta != 0) {
  536. INT_MOD(sbp->sb_rextslog, ARCH_CONVERT, tp->t_rextslog_delta);
  537. whole = 1;
  538. }
  539. if (whole)
  540. /*
  541. * Log the whole thing, the fields are noncontiguous.
  542. */
  543. xfs_trans_log_buf(tp, bp, 0, sizeof(xfs_sb_t) - 1);
  544. else
  545. /*
  546. * Since all the modifiable fields are contiguous, we
  547. * can get away with this.
  548. */
  549. xfs_trans_log_buf(tp, bp, offsetof(xfs_sb_t, sb_icount),
  550. offsetof(xfs_sb_t, sb_frextents) +
  551. sizeof(sbp->sb_frextents) - 1);
  552. XFS_MTOVFS(tp->t_mountp)->vfs_super->s_dirt = 1;
  553. }
  554. /*
  555. * xfs_trans_unreserve_and_mod_sb() is called to release unused
  556. * reservations and apply superblock counter changes to the in-core
  557. * superblock.
  558. *
  559. * This is done efficiently with a single call to xfs_mod_incore_sb_batch().
  560. */
  561. STATIC void
  562. xfs_trans_unreserve_and_mod_sb(
  563. xfs_trans_t *tp)
  564. {
  565. xfs_mod_sb_t msb[14]; /* If you add cases, add entries */
  566. xfs_mod_sb_t *msbp;
  567. /* REFERENCED */
  568. int error;
  569. int rsvd;
  570. msbp = msb;
  571. rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
  572. /*
  573. * Release any reserved blocks. Any that were allocated
  574. * will be taken back again by fdblocks_delta below.
  575. */
  576. if (tp->t_blk_res > 0) {
  577. msbp->msb_field = XFS_SBS_FDBLOCKS;
  578. msbp->msb_delta = tp->t_blk_res;
  579. msbp++;
  580. }
  581. /*
  582. * Release any reserved real time extents . Any that were
  583. * allocated will be taken back again by frextents_delta below.
  584. */
  585. if (tp->t_rtx_res > 0) {
  586. msbp->msb_field = XFS_SBS_FREXTENTS;
  587. msbp->msb_delta = tp->t_rtx_res;
  588. msbp++;
  589. }
  590. /*
  591. * Apply any superblock modifications to the in-core version.
  592. * The t_res_fdblocks_delta and t_res_frextents_delta fields are
  593. * explicitly NOT applied to the in-core superblock.
  594. * The idea is that that has already been done.
  595. */
  596. if (tp->t_flags & XFS_TRANS_SB_DIRTY) {
  597. if (tp->t_icount_delta != 0) {
  598. msbp->msb_field = XFS_SBS_ICOUNT;
  599. msbp->msb_delta = tp->t_icount_delta;
  600. msbp++;
  601. }
  602. if (tp->t_ifree_delta != 0) {
  603. msbp->msb_field = XFS_SBS_IFREE;
  604. msbp->msb_delta = tp->t_ifree_delta;
  605. msbp++;
  606. }
  607. if (tp->t_fdblocks_delta != 0) {
  608. msbp->msb_field = XFS_SBS_FDBLOCKS;
  609. msbp->msb_delta = tp->t_fdblocks_delta;
  610. msbp++;
  611. }
  612. if (tp->t_frextents_delta != 0) {
  613. msbp->msb_field = XFS_SBS_FREXTENTS;
  614. msbp->msb_delta = tp->t_frextents_delta;
  615. msbp++;
  616. }
  617. if (tp->t_dblocks_delta != 0) {
  618. msbp->msb_field = XFS_SBS_DBLOCKS;
  619. msbp->msb_delta = tp->t_dblocks_delta;
  620. msbp++;
  621. }
  622. if (tp->t_agcount_delta != 0) {
  623. msbp->msb_field = XFS_SBS_AGCOUNT;
  624. msbp->msb_delta = tp->t_agcount_delta;
  625. msbp++;
  626. }
  627. if (tp->t_imaxpct_delta != 0) {
  628. msbp->msb_field = XFS_SBS_IMAX_PCT;
  629. msbp->msb_delta = tp->t_imaxpct_delta;
  630. msbp++;
  631. }
  632. if (tp->t_rextsize_delta != 0) {
  633. msbp->msb_field = XFS_SBS_REXTSIZE;
  634. msbp->msb_delta = tp->t_rextsize_delta;
  635. msbp++;
  636. }
  637. if (tp->t_rbmblocks_delta != 0) {
  638. msbp->msb_field = XFS_SBS_RBMBLOCKS;
  639. msbp->msb_delta = tp->t_rbmblocks_delta;
  640. msbp++;
  641. }
  642. if (tp->t_rblocks_delta != 0) {
  643. msbp->msb_field = XFS_SBS_RBLOCKS;
  644. msbp->msb_delta = tp->t_rblocks_delta;
  645. msbp++;
  646. }
  647. if (tp->t_rextents_delta != 0) {
  648. msbp->msb_field = XFS_SBS_REXTENTS;
  649. msbp->msb_delta = tp->t_rextents_delta;
  650. msbp++;
  651. }
  652. if (tp->t_rextslog_delta != 0) {
  653. msbp->msb_field = XFS_SBS_REXTSLOG;
  654. msbp->msb_delta = tp->t_rextslog_delta;
  655. msbp++;
  656. }
  657. }
  658. /*
  659. * If we need to change anything, do it.
  660. */
  661. if (msbp > msb) {
  662. error = xfs_mod_incore_sb_batch(tp->t_mountp, msb,
  663. (uint)(msbp - msb), rsvd);
  664. ASSERT(error == 0);
  665. }
  666. }
  667. /*
  668. * xfs_trans_commit
  669. *
  670. * Commit the given transaction to the log a/synchronously.
  671. *
  672. * XFS disk error handling mechanism is not based on a typical
  673. * transaction abort mechanism. Logically after the filesystem
  674. * gets marked 'SHUTDOWN', we can't let any new transactions
  675. * be durable - ie. committed to disk - because some metadata might
  676. * be inconsistent. In such cases, this returns an error, and the
  677. * caller may assume that all locked objects joined to the transaction
  678. * have already been unlocked as if the commit had succeeded.
  679. * Do not reference the transaction structure after this call.
  680. */
  681. /*ARGSUSED*/
  682. int
  683. _xfs_trans_commit(
  684. xfs_trans_t *tp,
  685. uint flags,
  686. xfs_lsn_t *commit_lsn_p,
  687. int *log_flushed)
  688. {
  689. xfs_log_iovec_t *log_vector;
  690. int nvec;
  691. xfs_mount_t *mp;
  692. xfs_lsn_t commit_lsn;
  693. /* REFERENCED */
  694. int error;
  695. int log_flags;
  696. int sync;
  697. #define XFS_TRANS_LOGVEC_COUNT 16
  698. xfs_log_iovec_t log_vector_fast[XFS_TRANS_LOGVEC_COUNT];
  699. void *commit_iclog;
  700. int shutdown;
  701. commit_lsn = -1;
  702. /*
  703. * Determine whether this commit is releasing a permanent
  704. * log reservation or not.
  705. */
  706. if (flags & XFS_TRANS_RELEASE_LOG_RES) {
  707. ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
  708. log_flags = XFS_LOG_REL_PERM_RESERV;
  709. } else {
  710. log_flags = 0;
  711. }
  712. mp = tp->t_mountp;
  713. /*
  714. * If there is nothing to be logged by the transaction,
  715. * then unlock all of the items associated with the
  716. * transaction and free the transaction structure.
  717. * Also make sure to return any reserved blocks to
  718. * the free pool.
  719. */
  720. shut_us_down:
  721. shutdown = XFS_FORCED_SHUTDOWN(mp) ? EIO : 0;
  722. if (!(tp->t_flags & XFS_TRANS_DIRTY) || shutdown) {
  723. xfs_trans_unreserve_and_mod_sb(tp);
  724. /*
  725. * It is indeed possible for the transaction to be
  726. * not dirty but the dqinfo portion to be. All that
  727. * means is that we have some (non-persistent) quota
  728. * reservations that need to be unreserved.
  729. */
  730. XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(mp, tp);
  731. if (tp->t_ticket) {
  732. commit_lsn = xfs_log_done(mp, tp->t_ticket,
  733. NULL, log_flags);
  734. if (commit_lsn == -1 && !shutdown)
  735. shutdown = XFS_ERROR(EIO);
  736. }
  737. current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
  738. xfs_trans_free_items(tp, shutdown? XFS_TRANS_ABORT : 0);
  739. xfs_trans_free_busy(tp);
  740. xfs_trans_free(tp);
  741. XFS_STATS_INC(xs_trans_empty);
  742. if (commit_lsn_p)
  743. *commit_lsn_p = commit_lsn;
  744. return (shutdown);
  745. }
  746. ASSERT(tp->t_ticket != NULL);
  747. /*
  748. * If we need to update the superblock, then do it now.
  749. */
  750. if (tp->t_flags & XFS_TRANS_SB_DIRTY) {
  751. xfs_trans_apply_sb_deltas(tp);
  752. }
  753. XFS_TRANS_APPLY_DQUOT_DELTAS(mp, tp);
  754. /*
  755. * Ask each log item how many log_vector entries it will
  756. * need so we can figure out how many to allocate.
  757. * Try to avoid the kmem_alloc() call in the common case
  758. * by using a vector from the stack when it fits.
  759. */
  760. nvec = xfs_trans_count_vecs(tp);
  761. if (nvec == 0) {
  762. xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
  763. goto shut_us_down;
  764. } else if (nvec <= XFS_TRANS_LOGVEC_COUNT) {
  765. log_vector = log_vector_fast;
  766. } else {
  767. log_vector = (xfs_log_iovec_t *)kmem_alloc(nvec *
  768. sizeof(xfs_log_iovec_t),
  769. KM_SLEEP);
  770. }
  771. /*
  772. * Fill in the log_vector and pin the logged items, and
  773. * then write the transaction to the log.
  774. */
  775. xfs_trans_fill_vecs(tp, log_vector);
  776. error = xfs_log_write(mp, log_vector, nvec, tp->t_ticket, &(tp->t_lsn));
  777. /*
  778. * The transaction is committed incore here, and can go out to disk
  779. * at any time after this call. However, all the items associated
  780. * with the transaction are still locked and pinned in memory.
  781. */
  782. commit_lsn = xfs_log_done(mp, tp->t_ticket, &commit_iclog, log_flags);
  783. tp->t_commit_lsn = commit_lsn;
  784. if (nvec > XFS_TRANS_LOGVEC_COUNT) {
  785. kmem_free(log_vector, nvec * sizeof(xfs_log_iovec_t));
  786. }
  787. if (commit_lsn_p)
  788. *commit_lsn_p = commit_lsn;
  789. /*
  790. * If we got a log write error. Unpin the logitems that we
  791. * had pinned, clean up, free trans structure, and return error.
  792. */
  793. if (error || commit_lsn == -1) {
  794. current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
  795. xfs_trans_uncommit(tp, flags|XFS_TRANS_ABORT);
  796. return XFS_ERROR(EIO);
  797. }
  798. /*
  799. * Once the transaction has committed, unused
  800. * reservations need to be released and changes to
  801. * the superblock need to be reflected in the in-core
  802. * version. Do that now.
  803. */
  804. xfs_trans_unreserve_and_mod_sb(tp);
  805. sync = tp->t_flags & XFS_TRANS_SYNC;
  806. /*
  807. * Tell the LM to call the transaction completion routine
  808. * when the log write with LSN commit_lsn completes (e.g.
  809. * when the transaction commit really hits the on-disk log).
  810. * After this call we cannot reference tp, because the call
  811. * can happen at any time and the call will free the transaction
  812. * structure pointed to by tp. The only case where we call
  813. * the completion routine (xfs_trans_committed) directly is
  814. * if the log is turned off on a debug kernel or we're
  815. * running in simulation mode (the log is explicitly turned
  816. * off).
  817. */
  818. tp->t_logcb.cb_func = (void(*)(void*, int))xfs_trans_committed;
  819. tp->t_logcb.cb_arg = tp;
  820. /*
  821. * We need to pass the iclog buffer which was used for the
  822. * transaction commit record into this function, and attach
  823. * the callback to it. The callback must be attached before
  824. * the items are unlocked to avoid racing with other threads
  825. * waiting for an item to unlock.
  826. */
  827. shutdown = xfs_log_notify(mp, commit_iclog, &(tp->t_logcb));
  828. /*
  829. * Mark this thread as no longer being in a transaction
  830. */
  831. current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
  832. /*
  833. * Once all the items of the transaction have been copied
  834. * to the in core log and the callback is attached, the
  835. * items can be unlocked.
  836. *
  837. * This will free descriptors pointing to items which were
  838. * not logged since there is nothing more to do with them.
  839. * For items which were logged, we will keep pointers to them
  840. * so they can be unpinned after the transaction commits to disk.
  841. * This will also stamp each modified meta-data item with
  842. * the commit lsn of this transaction for dependency tracking
  843. * purposes.
  844. */
  845. xfs_trans_unlock_items(tp, commit_lsn);
  846. /*
  847. * If we detected a log error earlier, finish committing
  848. * the transaction now (unpin log items, etc).
  849. *
  850. * Order is critical here, to avoid using the transaction
  851. * pointer after its been freed (by xfs_trans_committed
  852. * either here now, or as a callback). We cannot do this
  853. * step inside xfs_log_notify as was done earlier because
  854. * of this issue.
  855. */
  856. if (shutdown)
  857. xfs_trans_committed(tp, XFS_LI_ABORTED);
  858. /*
  859. * Now that the xfs_trans_committed callback has been attached,
  860. * and the items are released we can finally allow the iclog to
  861. * go to disk.
  862. */
  863. error = xfs_log_release_iclog(mp, commit_iclog);
  864. /*
  865. * If the transaction needs to be synchronous, then force the
  866. * log out now and wait for it.
  867. */
  868. if (sync) {
  869. if (!error) {
  870. error = _xfs_log_force(mp, commit_lsn,
  871. XFS_LOG_FORCE | XFS_LOG_SYNC,
  872. log_flushed);
  873. }
  874. XFS_STATS_INC(xs_trans_sync);
  875. } else {
  876. XFS_STATS_INC(xs_trans_async);
  877. }
  878. return (error);
  879. }
  880. /*
  881. * Total up the number of log iovecs needed to commit this
  882. * transaction. The transaction itself needs one for the
  883. * transaction header. Ask each dirty item in turn how many
  884. * it needs to get the total.
  885. */
  886. STATIC uint
  887. xfs_trans_count_vecs(
  888. xfs_trans_t *tp)
  889. {
  890. int nvecs;
  891. xfs_log_item_desc_t *lidp;
  892. nvecs = 1;
  893. lidp = xfs_trans_first_item(tp);
  894. ASSERT(lidp != NULL);
  895. /* In the non-debug case we need to start bailing out if we
  896. * didn't find a log_item here, return zero and let trans_commit
  897. * deal with it.
  898. */
  899. if (lidp == NULL)
  900. return 0;
  901. while (lidp != NULL) {
  902. /*
  903. * Skip items which aren't dirty in this transaction.
  904. */
  905. if (!(lidp->lid_flags & XFS_LID_DIRTY)) {
  906. lidp = xfs_trans_next_item(tp, lidp);
  907. continue;
  908. }
  909. lidp->lid_size = IOP_SIZE(lidp->lid_item);
  910. nvecs += lidp->lid_size;
  911. lidp = xfs_trans_next_item(tp, lidp);
  912. }
  913. return nvecs;
  914. }
  915. /*
  916. * Called from the trans_commit code when we notice that
  917. * the filesystem is in the middle of a forced shutdown.
  918. */
  919. STATIC void
  920. xfs_trans_uncommit(
  921. xfs_trans_t *tp,
  922. uint flags)
  923. {
  924. xfs_log_item_desc_t *lidp;
  925. for (lidp = xfs_trans_first_item(tp);
  926. lidp != NULL;
  927. lidp = xfs_trans_next_item(tp, lidp)) {
  928. /*
  929. * Unpin all but those that aren't dirty.
  930. */
  931. if (lidp->lid_flags & XFS_LID_DIRTY)
  932. IOP_UNPIN_REMOVE(lidp->lid_item, tp);
  933. }
  934. xfs_trans_unreserve_and_mod_sb(tp);
  935. XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(tp->t_mountp, tp);
  936. xfs_trans_free_items(tp, flags);
  937. xfs_trans_free_busy(tp);
  938. xfs_trans_free(tp);
  939. }
  940. /*
  941. * Fill in the vector with pointers to data to be logged
  942. * by this transaction. The transaction header takes
  943. * the first vector, and then each dirty item takes the
  944. * number of vectors it indicated it needed in xfs_trans_count_vecs().
  945. *
  946. * As each item fills in the entries it needs, also pin the item
  947. * so that it cannot be flushed out until the log write completes.
  948. */
  949. STATIC void
  950. xfs_trans_fill_vecs(
  951. xfs_trans_t *tp,
  952. xfs_log_iovec_t *log_vector)
  953. {
  954. xfs_log_item_desc_t *lidp;
  955. xfs_log_iovec_t *vecp;
  956. uint nitems;
  957. /*
  958. * Skip over the entry for the transaction header, we'll
  959. * fill that in at the end.
  960. */
  961. vecp = log_vector + 1; /* pointer arithmetic */
  962. nitems = 0;
  963. lidp = xfs_trans_first_item(tp);
  964. ASSERT(lidp != NULL);
  965. while (lidp != NULL) {
  966. /*
  967. * Skip items which aren't dirty in this transaction.
  968. */
  969. if (!(lidp->lid_flags & XFS_LID_DIRTY)) {
  970. lidp = xfs_trans_next_item(tp, lidp);
  971. continue;
  972. }
  973. /*
  974. * The item may be marked dirty but not log anything.
  975. * This can be used to get called when a transaction
  976. * is committed.
  977. */
  978. if (lidp->lid_size) {
  979. nitems++;
  980. }
  981. IOP_FORMAT(lidp->lid_item, vecp);
  982. vecp += lidp->lid_size; /* pointer arithmetic */
  983. IOP_PIN(lidp->lid_item);
  984. lidp = xfs_trans_next_item(tp, lidp);
  985. }
  986. /*
  987. * Now that we've counted the number of items in this
  988. * transaction, fill in the transaction header.
  989. */
  990. tp->t_header.th_magic = XFS_TRANS_HEADER_MAGIC;
  991. tp->t_header.th_type = tp->t_type;
  992. tp->t_header.th_num_items = nitems;
  993. log_vector->i_addr = (xfs_caddr_t)&tp->t_header;
  994. log_vector->i_len = sizeof(xfs_trans_header_t);
  995. XLOG_VEC_SET_TYPE(log_vector, XLOG_REG_TYPE_TRANSHDR);
  996. }
  997. /*
  998. * Unlock all of the transaction's items and free the transaction.
  999. * The transaction must not have modified any of its items, because
  1000. * there is no way to restore them to their previous state.
  1001. *
  1002. * If the transaction has made a log reservation, make sure to release
  1003. * it as well.
  1004. */
  1005. void
  1006. xfs_trans_cancel(
  1007. xfs_trans_t *tp,
  1008. int flags)
  1009. {
  1010. int log_flags;
  1011. #ifdef DEBUG
  1012. xfs_log_item_chunk_t *licp;
  1013. xfs_log_item_desc_t *lidp;
  1014. xfs_log_item_t *lip;
  1015. int i;
  1016. #endif
  1017. xfs_mount_t *mp = tp->t_mountp;
  1018. /*
  1019. * See if the caller is being too lazy to figure out if
  1020. * the transaction really needs an abort.
  1021. */
  1022. if ((flags & XFS_TRANS_ABORT) && !(tp->t_flags & XFS_TRANS_DIRTY))
  1023. flags &= ~XFS_TRANS_ABORT;
  1024. /*
  1025. * See if the caller is relying on us to shut down the
  1026. * filesystem. This happens in paths where we detect
  1027. * corruption and decide to give up.
  1028. */
  1029. if ((tp->t_flags & XFS_TRANS_DIRTY) && !XFS_FORCED_SHUTDOWN(mp)) {
  1030. XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp);
  1031. xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
  1032. }
  1033. #ifdef DEBUG
  1034. if (!(flags & XFS_TRANS_ABORT)) {
  1035. licp = &(tp->t_items);
  1036. while (licp != NULL) {
  1037. lidp = licp->lic_descs;
  1038. for (i = 0; i < licp->lic_unused; i++, lidp++) {
  1039. if (XFS_LIC_ISFREE(licp, i)) {
  1040. continue;
  1041. }
  1042. lip = lidp->lid_item;
  1043. if (!XFS_FORCED_SHUTDOWN(mp))
  1044. ASSERT(!(lip->li_type == XFS_LI_EFD));
  1045. }
  1046. licp = licp->lic_next;
  1047. }
  1048. }
  1049. #endif
  1050. xfs_trans_unreserve_and_mod_sb(tp);
  1051. XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(mp, tp);
  1052. if (tp->t_ticket) {
  1053. if (flags & XFS_TRANS_RELEASE_LOG_RES) {
  1054. ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
  1055. log_flags = XFS_LOG_REL_PERM_RESERV;
  1056. } else {
  1057. log_flags = 0;
  1058. }
  1059. xfs_log_done(mp, tp->t_ticket, NULL, log_flags);
  1060. }
  1061. /* mark this thread as no longer being in a transaction */
  1062. current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
  1063. xfs_trans_free_items(tp, flags);
  1064. xfs_trans_free_busy(tp);
  1065. xfs_trans_free(tp);
  1066. }
  1067. /*
  1068. * Free the transaction structure. If there is more clean up
  1069. * to do when the structure is freed, add it here.
  1070. */
  1071. STATIC void
  1072. xfs_trans_free(
  1073. xfs_trans_t *tp)
  1074. {
  1075. atomic_dec(&tp->t_mountp->m_active_trans);
  1076. XFS_TRANS_FREE_DQINFO(tp->t_mountp, tp);
  1077. kmem_zone_free(xfs_trans_zone, tp);
  1078. }
  1079. /*
  1080. * THIS SHOULD BE REWRITTEN TO USE xfs_trans_next_item().
  1081. *
  1082. * This is typically called by the LM when a transaction has been fully
  1083. * committed to disk. It needs to unpin the items which have
  1084. * been logged by the transaction and update their positions
  1085. * in the AIL if necessary.
  1086. * This also gets called when the transactions didn't get written out
  1087. * because of an I/O error. Abortflag & XFS_LI_ABORTED is set then.
  1088. *
  1089. * Call xfs_trans_chunk_committed() to process the items in
  1090. * each chunk.
  1091. */
  1092. STATIC void
  1093. xfs_trans_committed(
  1094. xfs_trans_t *tp,
  1095. int abortflag)
  1096. {
  1097. xfs_log_item_chunk_t *licp;
  1098. xfs_log_item_chunk_t *next_licp;
  1099. xfs_log_busy_chunk_t *lbcp;
  1100. xfs_log_busy_slot_t *lbsp;
  1101. int i;
  1102. /*
  1103. * Call the transaction's completion callback if there
  1104. * is one.
  1105. */
  1106. if (tp->t_callback != NULL) {
  1107. tp->t_callback(tp, tp->t_callarg);
  1108. }
  1109. /*
  1110. * Special case the chunk embedded in the transaction.
  1111. */
  1112. licp = &(tp->t_items);
  1113. if (!(XFS_LIC_ARE_ALL_FREE(licp))) {
  1114. xfs_trans_chunk_committed(licp, tp->t_lsn, abortflag);
  1115. }
  1116. /*
  1117. * Process the items in each chunk in turn.
  1118. */
  1119. licp = licp->lic_next;
  1120. while (licp != NULL) {
  1121. ASSERT(!XFS_LIC_ARE_ALL_FREE(licp));
  1122. xfs_trans_chunk_committed(licp, tp->t_lsn, abortflag);
  1123. next_licp = licp->lic_next;
  1124. kmem_free(licp, sizeof(xfs_log_item_chunk_t));
  1125. licp = next_licp;
  1126. }
  1127. /*
  1128. * Clear all the per-AG busy list items listed in this transaction
  1129. */
  1130. lbcp = &tp->t_busy;
  1131. while (lbcp != NULL) {
  1132. for (i = 0, lbsp = lbcp->lbc_busy; i < lbcp->lbc_unused; i++, lbsp++) {
  1133. if (!XFS_LBC_ISFREE(lbcp, i)) {
  1134. xfs_alloc_clear_busy(tp, lbsp->lbc_ag,
  1135. lbsp->lbc_idx);
  1136. }
  1137. }
  1138. lbcp = lbcp->lbc_next;
  1139. }
  1140. xfs_trans_free_busy(tp);
  1141. /*
  1142. * That's it for the transaction structure. Free it.
  1143. */
  1144. xfs_trans_free(tp);
  1145. }
  1146. /*
  1147. * This is called to perform the commit processing for each
  1148. * item described by the given chunk.
  1149. *
  1150. * The commit processing consists of unlocking items which were
  1151. * held locked with the SYNC_UNLOCK attribute, calling the committed
  1152. * routine of each logged item, updating the item's position in the AIL
  1153. * if necessary, and unpinning each item. If the committed routine
  1154. * returns -1, then do nothing further with the item because it
  1155. * may have been freed.
  1156. *
  1157. * Since items are unlocked when they are copied to the incore
  1158. * log, it is possible for two transactions to be completing
  1159. * and manipulating the same item simultaneously. The AIL lock
  1160. * will protect the lsn field of each item. The value of this
  1161. * field can never go backwards.
  1162. *
  1163. * We unpin the items after repositioning them in the AIL, because
  1164. * otherwise they could be immediately flushed and we'd have to race
  1165. * with the flusher trying to pull the item from the AIL as we add it.
  1166. */
  1167. STATIC void
  1168. xfs_trans_chunk_committed(
  1169. xfs_log_item_chunk_t *licp,
  1170. xfs_lsn_t lsn,
  1171. int aborted)
  1172. {
  1173. xfs_log_item_desc_t *lidp;
  1174. xfs_log_item_t *lip;
  1175. xfs_lsn_t item_lsn;
  1176. struct xfs_mount *mp;
  1177. int i;
  1178. SPLDECL(s);
  1179. lidp = licp->lic_descs;
  1180. for (i = 0; i < licp->lic_unused; i++, lidp++) {
  1181. if (XFS_LIC_ISFREE(licp, i)) {
  1182. continue;
  1183. }
  1184. lip = lidp->lid_item;
  1185. if (aborted)
  1186. lip->li_flags |= XFS_LI_ABORTED;
  1187. /*
  1188. * Send in the ABORTED flag to the COMMITTED routine
  1189. * so that it knows whether the transaction was aborted
  1190. * or not.
  1191. */
  1192. item_lsn = IOP_COMMITTED(lip, lsn);
  1193. /*
  1194. * If the committed routine returns -1, make
  1195. * no more references to the item.
  1196. */
  1197. if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0) {
  1198. continue;
  1199. }
  1200. /*
  1201. * If the returned lsn is greater than what it
  1202. * contained before, update the location of the
  1203. * item in the AIL. If it is not, then do nothing.
  1204. * Items can never move backwards in the AIL.
  1205. *
  1206. * While the new lsn should usually be greater, it
  1207. * is possible that a later transaction completing
  1208. * simultaneously with an earlier one using the
  1209. * same item could complete first with a higher lsn.
  1210. * This would cause the earlier transaction to fail
  1211. * the test below.
  1212. */
  1213. mp = lip->li_mountp;
  1214. AIL_LOCK(mp,s);
  1215. if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0) {
  1216. /*
  1217. * This will set the item's lsn to item_lsn
  1218. * and update the position of the item in
  1219. * the AIL.
  1220. *
  1221. * xfs_trans_update_ail() drops the AIL lock.
  1222. */
  1223. xfs_trans_update_ail(mp, lip, item_lsn, s);
  1224. } else {
  1225. AIL_UNLOCK(mp, s);
  1226. }
  1227. /*
  1228. * Now that we've repositioned the item in the AIL,
  1229. * unpin it so it can be flushed. Pass information
  1230. * about buffer stale state down from the log item
  1231. * flags, if anyone else stales the buffer we do not
  1232. * want to pay any attention to it.
  1233. */
  1234. IOP_UNPIN(lip, lidp->lid_flags & XFS_LID_BUF_STALE);
  1235. }
  1236. }