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