Blame view
fs/xfs/xfs_log.c
103 KB
1da177e4c Linux-2.6.12-rc2 |
1 |
/* |
7b7187698 [XFS] Update lice... |
2 3 |
* Copyright (c) 2000-2005 Silicon Graphics, Inc. * All Rights Reserved. |
1da177e4c Linux-2.6.12-rc2 |
4 |
* |
7b7187698 [XFS] Update lice... |
5 6 |
* This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as |
1da177e4c Linux-2.6.12-rc2 |
7 8 |
* published by the Free Software Foundation. * |
7b7187698 [XFS] Update lice... |
9 10 11 12 |
* This program is distributed in the hope that it would be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. |
1da177e4c Linux-2.6.12-rc2 |
13 |
* |
7b7187698 [XFS] Update lice... |
14 15 16 |
* You should have received a copy of the GNU General Public License * along with this program; if not, write the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
1da177e4c Linux-2.6.12-rc2 |
17 |
*/ |
1da177e4c Linux-2.6.12-rc2 |
18 |
#include "xfs.h" |
a844f4510 [XFS] Remove xfs_... |
19 |
#include "xfs_fs.h" |
1da177e4c Linux-2.6.12-rc2 |
20 |
#include "xfs_types.h" |
a844f4510 [XFS] Remove xfs_... |
21 |
#include "xfs_bit.h" |
1da177e4c Linux-2.6.12-rc2 |
22 |
#include "xfs_log.h" |
a844f4510 [XFS] Remove xfs_... |
23 |
#include "xfs_inum.h" |
1da177e4c Linux-2.6.12-rc2 |
24 |
#include "xfs_trans.h" |
a844f4510 [XFS] Remove xfs_... |
25 26 |
#include "xfs_sb.h" #include "xfs_ag.h" |
1da177e4c Linux-2.6.12-rc2 |
27 28 29 30 |
#include "xfs_mount.h" #include "xfs_error.h" #include "xfs_log_priv.h" #include "xfs_buf_item.h" |
a844f4510 [XFS] Remove xfs_... |
31 |
#include "xfs_bmap_btree.h" |
1da177e4c Linux-2.6.12-rc2 |
32 |
#include "xfs_alloc_btree.h" |
a844f4510 [XFS] Remove xfs_... |
33 |
#include "xfs_ialloc_btree.h" |
1da177e4c Linux-2.6.12-rc2 |
34 |
#include "xfs_log_recover.h" |
1da177e4c Linux-2.6.12-rc2 |
35 |
#include "xfs_trans_priv.h" |
a844f4510 [XFS] Remove xfs_... |
36 37 38 |
#include "xfs_dinode.h" #include "xfs_inode.h" #include "xfs_rw.h" |
0b1b213fc xfs: event tracin... |
39 |
#include "xfs_trace.h" |
1da177e4c Linux-2.6.12-rc2 |
40 |
|
eb01c9cd8 [XFS] Remove the ... |
41 |
kmem_zone_t *xfs_log_ticket_zone; |
1da177e4c Linux-2.6.12-rc2 |
42 |
|
1da177e4c Linux-2.6.12-rc2 |
43 |
/* Local miscellaneous function prototypes */ |
55b66332d xfs: introduce ne... |
44 |
STATIC int xlog_commit_record(struct log *log, struct xlog_ticket *ticket, |
1da177e4c Linux-2.6.12-rc2 |
45 46 47 48 49 |
xlog_in_core_t **, xfs_lsn_t *); STATIC xlog_t * xlog_alloc_log(xfs_mount_t *mp, xfs_buftarg_t *log_target, xfs_daddr_t blk_offset, int num_bblks); |
c8a09ff8c xfs: convert log ... |
50 |
STATIC int xlog_space_left(struct log *log, atomic64_t *head); |
1da177e4c Linux-2.6.12-rc2 |
51 |
STATIC int xlog_sync(xlog_t *log, xlog_in_core_t *iclog); |
c41564b5a [XFS] We really s... |
52 |
STATIC void xlog_dealloc_log(xlog_t *log); |
1da177e4c Linux-2.6.12-rc2 |
53 54 55 56 57 58 59 60 61 62 |
/* local state machine functions */ STATIC void xlog_state_done_syncing(xlog_in_core_t *iclog, int); STATIC void xlog_state_do_callback(xlog_t *log,int aborted, xlog_in_core_t *iclog); STATIC int xlog_state_get_iclog_space(xlog_t *log, int len, xlog_in_core_t **iclog, xlog_ticket_t *ticket, int *continued_write, int *logoffsetp); |
1da177e4c Linux-2.6.12-rc2 |
63 64 65 66 67 |
STATIC int xlog_state_release_iclog(xlog_t *log, xlog_in_core_t *iclog); STATIC void xlog_state_switch_iclogs(xlog_t *log, xlog_in_core_t *iclog, int eventual_size); |
1da177e4c Linux-2.6.12-rc2 |
68 69 70 71 72 |
STATIC void xlog_state_want_sync(xlog_t *log, xlog_in_core_t *iclog); /* local functions to manipulate grant head */ STATIC int xlog_grant_log_space(xlog_t *log, xlog_ticket_t *xtic); |
2ced19cba xfs: make AIL tai... |
73 |
STATIC void xlog_grant_push_ail(struct log *log, |
1da177e4c Linux-2.6.12-rc2 |
74 75 76 77 78 79 80 |
int need_bytes); STATIC void xlog_regrant_reserve_log_space(xlog_t *log, xlog_ticket_t *ticket); STATIC int xlog_regrant_write_log_space(xlog_t *log, xlog_ticket_t *ticket); STATIC void xlog_ungrant_log_space(xlog_t *log, xlog_ticket_t *ticket); |
cfcbbbd08 [XFS] Remove old,... |
81 |
#if defined(DEBUG) |
e6b1f2737 xfs: clean up xlo... |
82 |
STATIC void xlog_verify_dest_ptr(xlog_t *log, char *ptr); |
3f336c6fa xfs: fact out com... |
83 |
STATIC void xlog_verify_grant_tail(struct log *log); |
1da177e4c Linux-2.6.12-rc2 |
84 85 86 87 88 89 |
STATIC void xlog_verify_iclog(xlog_t *log, xlog_in_core_t *iclog, int count, boolean_t syncing); STATIC void xlog_verify_tail_lsn(xlog_t *log, xlog_in_core_t *iclog, xfs_lsn_t tail_lsn); #else #define xlog_verify_dest_ptr(a,b) |
3f336c6fa xfs: fact out com... |
90 |
#define xlog_verify_grant_tail(a) |
1da177e4c Linux-2.6.12-rc2 |
91 92 93 |
#define xlog_verify_iclog(a,b,c,d) #define xlog_verify_tail_lsn(a,b,c) #endif |
ba0f32d46 [XFS] mark variou... |
94 |
STATIC int xlog_iclogs_empty(xlog_t *log); |
1da177e4c Linux-2.6.12-rc2 |
95 |
|
dd954c69d [XFS] turn xlog h... |
96 |
static void |
663e496a7 xfs: rework log g... |
97 98 |
xlog_grant_sub_space( struct log *log, |
c8a09ff8c xfs: convert log ... |
99 |
atomic64_t *head, |
663e496a7 xfs: rework log g... |
100 |
int bytes) |
dd954c69d [XFS] turn xlog h... |
101 |
{ |
d0eb2f38b xfs: convert gran... |
102 103 |
int64_t head_val = atomic64_read(head); int64_t new, old; |
a69ed03c2 xfs: combine gran... |
104 |
|
d0eb2f38b xfs: convert gran... |
105 106 |
do { int cycle, space; |
a69ed03c2 xfs: combine gran... |
107 |
|
d0eb2f38b xfs: convert gran... |
108 |
xlog_crack_grant_head_val(head_val, &cycle, &space); |
a69ed03c2 xfs: combine gran... |
109 |
|
d0eb2f38b xfs: convert gran... |
110 111 112 113 114 115 116 117 118 119 |
space -= bytes; if (space < 0) { space += log->l_logsize; cycle--; } old = head_val; new = xlog_assign_grant_head_val(cycle, space); head_val = atomic64_cmpxchg(head, old, new); } while (head_val != old); |
dd954c69d [XFS] turn xlog h... |
120 121 122 |
} static void |
663e496a7 xfs: rework log g... |
123 124 |
xlog_grant_add_space( struct log *log, |
c8a09ff8c xfs: convert log ... |
125 |
atomic64_t *head, |
663e496a7 xfs: rework log g... |
126 |
int bytes) |
dd954c69d [XFS] turn xlog h... |
127 |
{ |
d0eb2f38b xfs: convert gran... |
128 129 |
int64_t head_val = atomic64_read(head); int64_t new, old; |
a69ed03c2 xfs: combine gran... |
130 |
|
d0eb2f38b xfs: convert gran... |
131 132 133 |
do { int tmp; int cycle, space; |
a69ed03c2 xfs: combine gran... |
134 |
|
d0eb2f38b xfs: convert gran... |
135 |
xlog_crack_grant_head_val(head_val, &cycle, &space); |
a69ed03c2 xfs: combine gran... |
136 |
|
d0eb2f38b xfs: convert gran... |
137 138 139 140 141 142 143 144 145 146 147 148 |
tmp = log->l_logsize - space; if (tmp > bytes) space += bytes; else { space = bytes - tmp; cycle++; } old = head_val; new = xlog_assign_grant_head_val(cycle, space); head_val = atomic64_cmpxchg(head, old, new); } while (head_val != old); |
dd954c69d [XFS] turn xlog h... |
149 |
} |
a69ed03c2 xfs: combine gran... |
150 |
|
9f9c19ec1 xfs: fix the logs... |
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 |
STATIC bool xlog_reserveq_wake( struct log *log, int *free_bytes) { struct xlog_ticket *tic; int need_bytes; list_for_each_entry(tic, &log->l_reserveq, t_queue) { if (tic->t_flags & XLOG_TIC_PERM_RESERV) need_bytes = tic->t_unit_res * tic->t_cnt; else need_bytes = tic->t_unit_res; if (*free_bytes < need_bytes) return false; *free_bytes -= need_bytes; trace_xfs_log_grant_wake_up(log, tic); wake_up(&tic->t_wait); } return true; } STATIC bool xlog_writeq_wake( struct log *log, int *free_bytes) { struct xlog_ticket *tic; int need_bytes; list_for_each_entry(tic, &log->l_writeq, t_queue) { ASSERT(tic->t_flags & XLOG_TIC_PERM_RESERV); need_bytes = tic->t_unit_res; if (*free_bytes < need_bytes) return false; *free_bytes -= need_bytes; trace_xfs_log_regrant_write_wake_up(log, tic); wake_up(&tic->t_wait); } return true; } STATIC int xlog_reserveq_wait( struct log *log, struct xlog_ticket *tic, int need_bytes) { list_add_tail(&tic->t_queue, &log->l_reserveq); do { if (XLOG_FORCED_SHUTDOWN(log)) goto shutdown; xlog_grant_push_ail(log, need_bytes); XFS_STATS_INC(xs_sleep_logspace); trace_xfs_log_grant_sleep(log, tic); xlog_wait(&tic->t_wait, &log->l_grant_reserve_lock); trace_xfs_log_grant_wake(log, tic); spin_lock(&log->l_grant_reserve_lock); if (XLOG_FORCED_SHUTDOWN(log)) goto shutdown; } while (xlog_space_left(log, &log->l_grant_reserve_head) < need_bytes); list_del_init(&tic->t_queue); return 0; shutdown: list_del_init(&tic->t_queue); return XFS_ERROR(EIO); } STATIC int xlog_writeq_wait( struct log *log, struct xlog_ticket *tic, int need_bytes) { list_add_tail(&tic->t_queue, &log->l_writeq); do { if (XLOG_FORCED_SHUTDOWN(log)) goto shutdown; xlog_grant_push_ail(log, need_bytes); XFS_STATS_INC(xs_sleep_logspace); trace_xfs_log_regrant_write_sleep(log, tic); xlog_wait(&tic->t_wait, &log->l_grant_write_lock); trace_xfs_log_regrant_write_wake(log, tic); spin_lock(&log->l_grant_write_lock); if (XLOG_FORCED_SHUTDOWN(log)) goto shutdown; } while (xlog_space_left(log, &log->l_grant_write_head) < need_bytes); list_del_init(&tic->t_queue); return 0; shutdown: list_del_init(&tic->t_queue); return XFS_ERROR(EIO); } |
0adba5363 [XFS] replace som... |
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 |
static void xlog_tic_reset_res(xlog_ticket_t *tic) { tic->t_res_num = 0; tic->t_res_arr_sum = 0; tic->t_res_num_ophdrs = 0; } static void xlog_tic_add_region(xlog_ticket_t *tic, uint len, uint type) { if (tic->t_res_num == XLOG_TIC_LEN_MAX) { /* add to overflow and start again */ tic->t_res_o_flow += tic->t_res_arr_sum; tic->t_res_num = 0; tic->t_res_arr_sum = 0; } tic->t_res_arr[tic->t_res_num].r_len = len; tic->t_res_arr[tic->t_res_num].r_type = type; tic->t_res_arr_sum += len; tic->t_res_num++; } |
dd954c69d [XFS] turn xlog h... |
284 |
|
1da177e4c Linux-2.6.12-rc2 |
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 |
/* * NOTES: * * 1. currblock field gets updated at startup and after in-core logs * marked as with WANT_SYNC. */ /* * This routine is called when a user of a log manager ticket is done with * the reservation. If the ticket was ever used, then a commit record for * the associated transaction is written out as a log operation header with * no data. The flag XLOG_TIC_INITED is set when the first write occurs with * a given ticket. If the ticket was one with a permanent reservation, then * a few operations are done differently. Permanent reservation tickets by * default don't release the reservation. They just commit the current * transaction with the belief that the reservation is still needed. A flag * must be passed in before permanent reservations are actually released. * When these type of tickets are not released, they need to be set into * the inited state again. By doing this, a start record will be written * out when the next write occurs. */ xfs_lsn_t |
35a8a72f0 xfs: stop passing... |
307 308 309 310 311 |
xfs_log_done( struct xfs_mount *mp, struct xlog_ticket *ticket, struct xlog_in_core **iclog, uint flags) |
1da177e4c Linux-2.6.12-rc2 |
312 |
{ |
35a8a72f0 xfs: stop passing... |
313 314 |
struct log *log = mp->m_log; xfs_lsn_t lsn = 0; |
1da177e4c Linux-2.6.12-rc2 |
315 |
|
1da177e4c Linux-2.6.12-rc2 |
316 317 318 319 320 321 |
if (XLOG_FORCED_SHUTDOWN(log) || /* * If nothing was ever written, don't write out commit record. * If we get an error, just continue and give back the log ticket. */ (((ticket->t_flags & XLOG_TIC_INITED) == 0) && |
55b66332d xfs: introduce ne... |
322 |
(xlog_commit_record(log, ticket, iclog, &lsn)))) { |
1da177e4c Linux-2.6.12-rc2 |
323 324 325 326 327 328 329 330 331 |
lsn = (xfs_lsn_t) -1; if (ticket->t_flags & XLOG_TIC_PERM_RESERV) { flags |= XFS_LOG_REL_PERM_RESERV; } } if ((ticket->t_flags & XLOG_TIC_PERM_RESERV) == 0 || (flags & XFS_LOG_REL_PERM_RESERV)) { |
0b1b213fc xfs: event tracin... |
332 |
trace_xfs_log_done_nonperm(log, ticket); |
1da177e4c Linux-2.6.12-rc2 |
333 |
/* |
c41564b5a [XFS] We really s... |
334 |
* Release ticket if not permanent reservation or a specific |
1da177e4c Linux-2.6.12-rc2 |
335 336 337 |
* request has been made to release a permanent reservation. */ xlog_ungrant_log_space(log, ticket); |
cc09c0dc5 [XFS] Fix double ... |
338 |
xfs_log_ticket_put(ticket); |
1da177e4c Linux-2.6.12-rc2 |
339 |
} else { |
0b1b213fc xfs: event tracin... |
340 |
trace_xfs_log_done_perm(log, ticket); |
1da177e4c Linux-2.6.12-rc2 |
341 |
xlog_regrant_reserve_log_space(log, ticket); |
c6a7b0f8a [XFS] Fix use aft... |
342 343 344 345 |
/* If this ticket was a permanent reservation and we aren't * trying to release it, reset the inited flags; so next time * we write, a start record will be written out. */ |
1da177e4c Linux-2.6.12-rc2 |
346 |
ticket->t_flags |= XLOG_TIC_INITED; |
c6a7b0f8a [XFS] Fix use aft... |
347 |
} |
1da177e4c Linux-2.6.12-rc2 |
348 349 |
return lsn; |
35a8a72f0 xfs: stop passing... |
350 |
} |
1da177e4c Linux-2.6.12-rc2 |
351 |
|
1da177e4c Linux-2.6.12-rc2 |
352 353 354 355 356 357 358 |
/* * Attaches a new iclog I/O completion callback routine during * transaction commit. If the log is in error state, a non-zero * return code is handed back and the caller is responsible for * executing the callback at an appropriate time. */ int |
35a8a72f0 xfs: stop passing... |
359 360 361 362 |
xfs_log_notify( struct xfs_mount *mp, struct xlog_in_core *iclog, xfs_log_callback_t *cb) |
1da177e4c Linux-2.6.12-rc2 |
363 |
{ |
b22cd72c9 [XFS] Unwrap LOG_... |
364 |
int abortflg; |
1da177e4c Linux-2.6.12-rc2 |
365 |
|
114d23aae [XFS] Per iclog c... |
366 |
spin_lock(&iclog->ic_callback_lock); |
1da177e4c Linux-2.6.12-rc2 |
367 368 369 370 371 372 373 374 |
abortflg = (iclog->ic_state & XLOG_STATE_IOERROR); if (!abortflg) { ASSERT_ALWAYS((iclog->ic_state == XLOG_STATE_ACTIVE) || (iclog->ic_state == XLOG_STATE_WANT_SYNC)); cb->cb_next = NULL; *(iclog->ic_callback_tail) = cb; iclog->ic_callback_tail = &(cb->cb_next); } |
114d23aae [XFS] Per iclog c... |
375 |
spin_unlock(&iclog->ic_callback_lock); |
1da177e4c Linux-2.6.12-rc2 |
376 |
return abortflg; |
35a8a72f0 xfs: stop passing... |
377 |
} |
1da177e4c Linux-2.6.12-rc2 |
378 379 |
int |
35a8a72f0 xfs: stop passing... |
380 381 382 |
xfs_log_release_iclog( struct xfs_mount *mp, struct xlog_in_core *iclog) |
1da177e4c Linux-2.6.12-rc2 |
383 |
{ |
35a8a72f0 xfs: stop passing... |
384 |
if (xlog_state_release_iclog(mp->m_log, iclog)) { |
7d04a335b [XFS] Shutdown th... |
385 |
xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR); |
014c2544e return statement ... |
386 |
return EIO; |
1da177e4c Linux-2.6.12-rc2 |
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 |
} return 0; } /* * 1. Reserve an amount of on-disk log space and return a ticket corresponding * to the reservation. * 2. Potentially, push buffers at tail of log to disk. * * Each reservation is going to reserve extra space for a log record header. * When writes happen to the on-disk log, we don't subtract the length of the * log record header from any reservation. By wasting space in each * reservation, we prevent over allocation problems. */ int |
35a8a72f0 xfs: stop passing... |
403 404 405 406 407 408 409 410 |
xfs_log_reserve( struct xfs_mount *mp, int unit_bytes, int cnt, struct xlog_ticket **ticket, __uint8_t client, uint flags, uint t_type) |
1da177e4c Linux-2.6.12-rc2 |
411 |
{ |
35a8a72f0 xfs: stop passing... |
412 413 414 |
struct log *log = mp->m_log; struct xlog_ticket *internal_ticket; int retval = 0; |
1da177e4c Linux-2.6.12-rc2 |
415 |
|
1da177e4c Linux-2.6.12-rc2 |
416 |
ASSERT(client == XFS_TRANSACTION || client == XFS_LOG); |
1da177e4c Linux-2.6.12-rc2 |
417 418 419 420 421 |
if (XLOG_FORCED_SHUTDOWN(log)) return XFS_ERROR(EIO); XFS_STATS_INC(xs_try_logspace); |
0b1b213fc xfs: event tracin... |
422 |
|
1da177e4c Linux-2.6.12-rc2 |
423 424 |
if (*ticket != NULL) { ASSERT(flags & XFS_LOG_PERM_RESERV); |
35a8a72f0 xfs: stop passing... |
425 |
internal_ticket = *ticket; |
0b1b213fc xfs: event tracin... |
426 |
|
524ee36fa xfs: Don't reuse ... |
427 428 429 430 431 432 433 434 |
/* * this is a new transaction on the ticket, so we need to * change the transaction ID so that the next transaction has a * different TID in the log. Just add one to the existing tid * so that we can see chains of rolling transactions in the log * easily. */ internal_ticket->t_tid++; |
0b1b213fc xfs: event tracin... |
435 |
trace_xfs_log_reserve(log, internal_ticket); |
2ced19cba xfs: make AIL tai... |
436 |
xlog_grant_push_ail(log, internal_ticket->t_unit_res); |
1da177e4c Linux-2.6.12-rc2 |
437 438 439 |
retval = xlog_regrant_write_log_space(log, internal_ticket); } else { /* may sleep if need to allocate more tickets */ |
cc09c0dc5 [XFS] Fix double ... |
440 |
internal_ticket = xlog_ticket_alloc(log, unit_bytes, cnt, |
3383ca578 xfs: allow log ti... |
441 442 |
client, flags, KM_SLEEP|KM_MAYFAIL); |
eb01c9cd8 [XFS] Remove the ... |
443 444 |
if (!internal_ticket) return XFS_ERROR(ENOMEM); |
7e9c63961 [XFS] 929956 add ... |
445 |
internal_ticket->t_trans_type = t_type; |
1da177e4c Linux-2.6.12-rc2 |
446 |
*ticket = internal_ticket; |
0b1b213fc xfs: event tracin... |
447 448 |
trace_xfs_log_reserve(log, internal_ticket); |
2ced19cba xfs: make AIL tai... |
449 |
xlog_grant_push_ail(log, |
1da177e4c Linux-2.6.12-rc2 |
450 451 452 453 |
(internal_ticket->t_unit_res * internal_ticket->t_cnt)); retval = xlog_grant_log_space(log, internal_ticket); } |
9f9c19ec1 xfs: fix the logs... |
454 455 456 457 458 459 460 461 462 463 |
if (unlikely(retval)) { /* * If we are failing, make sure the ticket doesn't have any * current reservations. We don't want to add this back * when the ticket/ transaction gets cancelled. */ internal_ticket->t_curr_res = 0; /* ungrant will give back unit_res * t_cnt. */ internal_ticket->t_cnt = 0; } |
1da177e4c Linux-2.6.12-rc2 |
464 |
return retval; |
9f9c19ec1 xfs: fix the logs... |
465 |
} |
1da177e4c Linux-2.6.12-rc2 |
466 467 468 469 470 471 472 473 474 475 476 477 478 |
/* * Mount a log filesystem * * mp - ubiquitous xfs mount point structure * log_target - buftarg of on-disk log device * blk_offset - Start block # where block size is 512 bytes (BBSIZE) * num_bblocks - Number of BBSIZE blocks in on-disk log * * Return error or zero. */ int |
249a8c112 [XFS] Move AIL pu... |
479 480 481 482 483 |
xfs_log_mount( xfs_mount_t *mp, xfs_buftarg_t *log_target, xfs_daddr_t blk_offset, int num_bblks) |
1da177e4c Linux-2.6.12-rc2 |
484 |
{ |
249a8c112 [XFS] Move AIL pu... |
485 |
int error; |
1da177e4c Linux-2.6.12-rc2 |
486 |
if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) |
a0fa2b679 xfs: Convert xlog... |
487 |
xfs_notice(mp, "Mounting Filesystem"); |
1da177e4c Linux-2.6.12-rc2 |
488 |
else { |
a0fa2b679 xfs: Convert xlog... |
489 490 |
xfs_notice(mp, "Mounting filesystem in no-recovery mode. Filesystem will be inconsistent."); |
bd186aa90 [XFS] kill the vf... |
491 |
ASSERT(mp->m_flags & XFS_MOUNT_RDONLY); |
1da177e4c Linux-2.6.12-rc2 |
492 493 494 |
} mp->m_log = xlog_alloc_log(mp, log_target, blk_offset, num_bblks); |
a6cb767e2 xfs: validate log... |
495 496 |
if (IS_ERR(mp->m_log)) { error = -PTR_ERR(mp->m_log); |
644c3567d [XFS] handle memo... |
497 498 |
goto out; } |
1da177e4c Linux-2.6.12-rc2 |
499 |
|
1da177e4c Linux-2.6.12-rc2 |
500 |
/* |
249a8c112 [XFS] Move AIL pu... |
501 502 |
* Initialize the AIL now we have a log. */ |
249a8c112 [XFS] Move AIL pu... |
503 504 |
error = xfs_trans_ail_init(mp); if (error) { |
a0fa2b679 xfs: Convert xlog... |
505 |
xfs_warn(mp, "AIL initialisation failed: error %d", error); |
264307520 xfs: fix error ha... |
506 |
goto out_free_log; |
249a8c112 [XFS] Move AIL pu... |
507 |
} |
a9c21c1b9 [XFS] Given the l... |
508 |
mp->m_log->l_ailp = mp->m_ail; |
249a8c112 [XFS] Move AIL pu... |
509 510 |
/* |
1da177e4c Linux-2.6.12-rc2 |
511 512 513 514 |
* skip log recovery on a norecovery mount. pretend it all * just worked. */ if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) { |
249a8c112 [XFS] Move AIL pu... |
515 |
int readonly = (mp->m_flags & XFS_MOUNT_RDONLY); |
1da177e4c Linux-2.6.12-rc2 |
516 517 |
if (readonly) |
bd186aa90 [XFS] kill the vf... |
518 |
mp->m_flags &= ~XFS_MOUNT_RDONLY; |
1da177e4c Linux-2.6.12-rc2 |
519 |
|
65be60541 [XFS] remove unus... |
520 |
error = xlog_recover(mp->m_log); |
1da177e4c Linux-2.6.12-rc2 |
521 522 |
if (readonly) |
bd186aa90 [XFS] kill the vf... |
523 |
mp->m_flags |= XFS_MOUNT_RDONLY; |
1da177e4c Linux-2.6.12-rc2 |
524 |
if (error) { |
a0fa2b679 xfs: Convert xlog... |
525 526 |
xfs_warn(mp, "log mount/recovery failed: error %d", error); |
264307520 xfs: fix error ha... |
527 |
goto out_destroy_ail; |
1da177e4c Linux-2.6.12-rc2 |
528 529 530 531 532 |
} } /* Normal transactions can now occur */ mp->m_log->l_flags &= ~XLOG_ACTIVE_RECOVERY; |
71e330b59 xfs: Introduce de... |
533 534 535 536 537 538 |
/* * Now the log has been fully initialised and we know were our * space grant counters are, we can initialise the permanent ticket * needed for delayed logging to work. */ xlog_cil_init_post_recovery(mp->m_log); |
1da177e4c Linux-2.6.12-rc2 |
539 |
return 0; |
264307520 xfs: fix error ha... |
540 541 542 543 544 |
out_destroy_ail: xfs_trans_ail_destroy(mp); out_free_log: xlog_dealloc_log(mp->m_log); |
644c3567d [XFS] handle memo... |
545 |
out: |
249a8c112 [XFS] Move AIL pu... |
546 |
return error; |
264307520 xfs: fix error ha... |
547 |
} |
1da177e4c Linux-2.6.12-rc2 |
548 549 550 551 552 553 554 555 556 557 |
/* * Finish the recovery of the file system. This is separate from * the xfs_log_mount() call, because it depends on the code in * xfs_mountfs() to read in the root and real-time bitmap inodes * between calling xfs_log_mount() and here. * * mp - ubiquitous xfs mount point structure */ int |
4249023a5 [XFS] cleanup xfs... |
558 |
xfs_log_mount_finish(xfs_mount_t *mp) |
1da177e4c Linux-2.6.12-rc2 |
559 560 561 562 |
{ int error; if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) |
4249023a5 [XFS] cleanup xfs... |
563 |
error = xlog_recover_finish(mp->m_log); |
1da177e4c Linux-2.6.12-rc2 |
564 565 |
else { error = 0; |
bd186aa90 [XFS] kill the vf... |
566 |
ASSERT(mp->m_flags & XFS_MOUNT_RDONLY); |
1da177e4c Linux-2.6.12-rc2 |
567 568 569 570 571 572 |
} return error; } /* |
1da177e4c Linux-2.6.12-rc2 |
573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 |
* Final log writes as part of unmount. * * Mark the filesystem clean as unmount happens. Note that during relocation * this routine needs to be executed as part of source-bag while the * deallocation must not be done until source-end. */ /* * Unmount record used to have a string "Unmount filesystem--" in the * data section where the "Un" was really a magic number (XLOG_UNMOUNT_TYPE). * We just write the magic number now since that particular field isn't * currently architecture converted and "nUmount" is a bit foo. * As far as I know, there weren't any dependencies on the old behaviour. */ int xfs_log_unmount_write(xfs_mount_t *mp) { xlog_t *log = mp->m_log; xlog_in_core_t *iclog; #ifdef DEBUG xlog_in_core_t *first_iclog; #endif |
35a8a72f0 xfs: stop passing... |
596 |
xlog_ticket_t *tic = NULL; |
1da177e4c Linux-2.6.12-rc2 |
597 598 |
xfs_lsn_t lsn; int error; |
1da177e4c Linux-2.6.12-rc2 |
599 |
|
1da177e4c Linux-2.6.12-rc2 |
600 601 602 603 |
/* * Don't write out unmount record on read-only mounts. * Or, if we are doing a forced umount (typically because of IO errors). */ |
bd186aa90 [XFS] kill the vf... |
604 |
if (mp->m_flags & XFS_MOUNT_RDONLY) |
1da177e4c Linux-2.6.12-rc2 |
605 |
return 0; |
a14a348bf xfs: cleanup up x... |
606 |
error = _xfs_log_force(mp, XFS_LOG_SYNC, NULL); |
b911ca047 [XFS] Sanitise xf... |
607 |
ASSERT(error || !(XLOG_FORCED_SHUTDOWN(log))); |
1da177e4c Linux-2.6.12-rc2 |
608 609 610 611 612 613 614 615 616 617 618 619 |
#ifdef DEBUG first_iclog = iclog = log->l_iclog; do { if (!(iclog->ic_state & XLOG_STATE_IOERROR)) { ASSERT(iclog->ic_state & XLOG_STATE_ACTIVE); ASSERT(iclog->ic_offset == 0); } iclog = iclog->ic_next; } while (iclog != first_iclog); #endif if (! (XLOG_FORCED_SHUTDOWN(log))) { |
955e47ad2 [XFS] Fixes the l... |
620 621 |
error = xfs_log_reserve(mp, 600, 1, &tic, XFS_LOG, 0, XLOG_UNMOUNT_REC_TYPE); |
1da177e4c Linux-2.6.12-rc2 |
622 |
if (!error) { |
55b66332d xfs: introduce ne... |
623 624 625 626 627 628 629 630 631 |
/* the data section must be 32 bit size aligned */ struct { __uint16_t magic; __uint16_t pad1; __uint32_t pad2; /* may as well make it 64 bits */ } magic = { .magic = XLOG_UNMOUNT_TYPE, }; struct xfs_log_iovec reg = { |
4e0d5f926 xfs: fix the xfs_... |
632 |
.i_addr = &magic, |
55b66332d xfs: introduce ne... |
633 634 635 636 637 638 639 |
.i_len = sizeof(magic), .i_type = XLOG_REG_TYPE_UNMOUNT, }; struct xfs_log_vec vec = { .lv_niovecs = 1, .lv_iovecp = ®, }; |
1da177e4c Linux-2.6.12-rc2 |
640 |
/* remove inited flag */ |
55b66332d xfs: introduce ne... |
641 642 |
tic->t_flags = 0; error = xlog_write(log, &vec, tic, &lsn, |
1da177e4c Linux-2.6.12-rc2 |
643 644 645 646 647 648 649 |
NULL, XLOG_UNMOUNT_TRANS); /* * At this point, we're umounting anyway, * so there's no point in transitioning log state * to IOERROR. Just continue... */ } |
a0fa2b679 xfs: Convert xlog... |
650 651 |
if (error) xfs_alert(mp, "%s: unmount record failed", __func__); |
1da177e4c Linux-2.6.12-rc2 |
652 |
|
b22cd72c9 [XFS] Unwrap LOG_... |
653 |
spin_lock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
654 |
iclog = log->l_iclog; |
155cc6b78 [XFS] Use atomics... |
655 |
atomic_inc(&iclog->ic_refcnt); |
1da177e4c Linux-2.6.12-rc2 |
656 |
xlog_state_want_sync(log, iclog); |
39e2defe7 reduce l_iclogloc... |
657 |
spin_unlock(&log->l_icloglock); |
1bb7d6b5a [XFS] Catch log u... |
658 |
error = xlog_state_release_iclog(log, iclog); |
1da177e4c Linux-2.6.12-rc2 |
659 |
|
b22cd72c9 [XFS] Unwrap LOG_... |
660 |
spin_lock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
661 662 663 |
if (!(iclog->ic_state == XLOG_STATE_ACTIVE || iclog->ic_state == XLOG_STATE_DIRTY)) { if (!XLOG_FORCED_SHUTDOWN(log)) { |
eb40a8750 xfs: use wait que... |
664 665 |
xlog_wait(&iclog->ic_force_wait, &log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
666 |
} else { |
b22cd72c9 [XFS] Unwrap LOG_... |
667 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
668 669 |
} } else { |
b22cd72c9 [XFS] Unwrap LOG_... |
670 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
671 |
} |
955e47ad2 [XFS] Fixes the l... |
672 |
if (tic) { |
0b1b213fc xfs: event tracin... |
673 |
trace_xfs_log_umount_write(log, tic); |
955e47ad2 [XFS] Fixes the l... |
674 |
xlog_ungrant_log_space(log, tic); |
cc09c0dc5 [XFS] Fix double ... |
675 |
xfs_log_ticket_put(tic); |
955e47ad2 [XFS] Fixes the l... |
676 |
} |
1da177e4c Linux-2.6.12-rc2 |
677 678 679 680 681 682 683 |
} else { /* * We're already in forced_shutdown mode, couldn't * even attempt to write out the unmount transaction. * * Go through the motions of sync'ing and releasing * the iclog, even though no I/O will actually happen, |
c41564b5a [XFS] We really s... |
684 |
* we need to wait for other log I/Os that may already |
1da177e4c Linux-2.6.12-rc2 |
685 686 687 688 689 690 |
* be in progress. Do this as a separate section of * code so we'll know if we ever get stuck here that * we're in this odd situation of trying to unmount * a file system that went into forced_shutdown as * the result of an unmount.. */ |
b22cd72c9 [XFS] Unwrap LOG_... |
691 |
spin_lock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
692 |
iclog = log->l_iclog; |
155cc6b78 [XFS] Use atomics... |
693 |
atomic_inc(&iclog->ic_refcnt); |
1da177e4c Linux-2.6.12-rc2 |
694 695 |
xlog_state_want_sync(log, iclog); |
39e2defe7 reduce l_iclogloc... |
696 |
spin_unlock(&log->l_icloglock); |
1bb7d6b5a [XFS] Catch log u... |
697 |
error = xlog_state_release_iclog(log, iclog); |
1da177e4c Linux-2.6.12-rc2 |
698 |
|
b22cd72c9 [XFS] Unwrap LOG_... |
699 |
spin_lock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
700 701 702 703 |
if ( ! ( iclog->ic_state == XLOG_STATE_ACTIVE || iclog->ic_state == XLOG_STATE_DIRTY || iclog->ic_state == XLOG_STATE_IOERROR) ) { |
eb40a8750 xfs: use wait que... |
704 705 |
xlog_wait(&iclog->ic_force_wait, &log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
706 |
} else { |
b22cd72c9 [XFS] Unwrap LOG_... |
707 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
708 709 |
} } |
1bb7d6b5a [XFS] Catch log u... |
710 |
return error; |
1da177e4c Linux-2.6.12-rc2 |
711 712 713 714 |
} /* xfs_log_unmount_write */ /* * Deallocate log structures for unmount/relocation. |
249a8c112 [XFS] Move AIL pu... |
715 716 717 |
* * We need to stop the aild from running before we destroy * and deallocate the log as the aild references the log. |
1da177e4c Linux-2.6.12-rc2 |
718 719 |
*/ void |
21b699c89 xfs: cleanup log ... |
720 |
xfs_log_unmount(xfs_mount_t *mp) |
1da177e4c Linux-2.6.12-rc2 |
721 |
{ |
249a8c112 [XFS] Move AIL pu... |
722 |
xfs_trans_ail_destroy(mp); |
c41564b5a [XFS] We really s... |
723 |
xlog_dealloc_log(mp->m_log); |
1da177e4c Linux-2.6.12-rc2 |
724 |
} |
43f5efc5b xfs: factor log i... |
725 726 727 728 729 |
void xfs_log_item_init( struct xfs_mount *mp, struct xfs_log_item *item, int type, |
272e42b21 xfs: constify xfs... |
730 |
const struct xfs_item_ops *ops) |
43f5efc5b xfs: factor log i... |
731 732 733 734 735 |
{ item->li_mountp = mp; item->li_ailp = mp->m_ail; item->li_type = type; item->li_ops = ops; |
71e330b59 xfs: Introduce de... |
736 737 738 739 |
item->li_lv = NULL; INIT_LIST_HEAD(&item->li_ail); INIT_LIST_HEAD(&item->li_cil); |
43f5efc5b xfs: factor log i... |
740 |
} |
1da177e4c Linux-2.6.12-rc2 |
741 742 743 744 745 746 |
void xfs_log_move_tail(xfs_mount_t *mp, xfs_lsn_t tail_lsn) { xlog_ticket_t *tic; xlog_t *log = mp->m_log; |
a69ed03c2 xfs: combine gran... |
747 |
int need_bytes, free_bytes; |
1da177e4c Linux-2.6.12-rc2 |
748 |
|
1da177e4c Linux-2.6.12-rc2 |
749 750 |
if (XLOG_FORCED_SHUTDOWN(log)) return; |
1da177e4c Linux-2.6.12-rc2 |
751 |
|
84f3c683c xfs: convert l_la... |
752 753 |
if (tail_lsn == 0) tail_lsn = atomic64_read(&log->l_last_sync_lsn); |
1da177e4c Linux-2.6.12-rc2 |
754 |
|
1c3cb9ec0 xfs: convert l_ta... |
755 756 757 |
/* tail_lsn == 1 implies that we weren't passed a valid value. */ if (tail_lsn != 1) atomic64_set(&log->l_tail_lsn, tail_lsn); |
1da177e4c Linux-2.6.12-rc2 |
758 |
|
3f16b9850 xfs: introduce ne... |
759 |
if (!list_empty_careful(&log->l_writeq)) { |
1da177e4c Linux-2.6.12-rc2 |
760 761 762 763 |
#ifdef DEBUG if (log->l_flags & XLOG_ACTIVE_RECOVERY) panic("Recovery problem"); #endif |
3f16b9850 xfs: introduce ne... |
764 |
spin_lock(&log->l_grant_write_lock); |
a69ed03c2 xfs: combine gran... |
765 |
free_bytes = xlog_space_left(log, &log->l_grant_write_head); |
105479419 xfs: convert log ... |
766 |
list_for_each_entry(tic, &log->l_writeq, t_queue) { |
1da177e4c Linux-2.6.12-rc2 |
767 768 769 770 771 772 |
ASSERT(tic->t_flags & XLOG_TIC_PERM_RESERV); if (free_bytes < tic->t_unit_res && tail_lsn != 1) break; tail_lsn = 0; free_bytes -= tic->t_unit_res; |
3f16b9850 xfs: introduce ne... |
773 |
trace_xfs_log_regrant_write_wake_up(log, tic); |
eb40a8750 xfs: use wait que... |
774 |
wake_up(&tic->t_wait); |
105479419 xfs: convert log ... |
775 |
} |
3f16b9850 xfs: introduce ne... |
776 |
spin_unlock(&log->l_grant_write_lock); |
1da177e4c Linux-2.6.12-rc2 |
777 |
} |
105479419 xfs: convert log ... |
778 |
|
3f16b9850 xfs: introduce ne... |
779 |
if (!list_empty_careful(&log->l_reserveq)) { |
1da177e4c Linux-2.6.12-rc2 |
780 781 782 783 |
#ifdef DEBUG if (log->l_flags & XLOG_ACTIVE_RECOVERY) panic("Recovery problem"); #endif |
3f16b9850 xfs: introduce ne... |
784 |
spin_lock(&log->l_grant_reserve_lock); |
a69ed03c2 xfs: combine gran... |
785 |
free_bytes = xlog_space_left(log, &log->l_grant_reserve_head); |
105479419 xfs: convert log ... |
786 |
list_for_each_entry(tic, &log->l_reserveq, t_queue) { |
1da177e4c Linux-2.6.12-rc2 |
787 788 789 790 791 792 793 794 |
if (tic->t_flags & XLOG_TIC_PERM_RESERV) need_bytes = tic->t_unit_res*tic->t_cnt; else need_bytes = tic->t_unit_res; if (free_bytes < need_bytes && tail_lsn != 1) break; tail_lsn = 0; free_bytes -= need_bytes; |
3f16b9850 xfs: introduce ne... |
795 |
trace_xfs_log_grant_wake_up(log, tic); |
eb40a8750 xfs: use wait que... |
796 |
wake_up(&tic->t_wait); |
105479419 xfs: convert log ... |
797 |
} |
3f16b9850 xfs: introduce ne... |
798 |
spin_unlock(&log->l_grant_reserve_lock); |
1da177e4c Linux-2.6.12-rc2 |
799 |
} |
3f16b9850 xfs: introduce ne... |
800 |
} |
1da177e4c Linux-2.6.12-rc2 |
801 802 803 |
/* * Determine if we have a transaction that has gone to disk |
b6f8dd49d xfs: ensure that ... |
804 805 806 807 808 809 810 811 812 813 |
* that needs to be covered. To begin the transition to the idle state * firstly the log needs to be idle (no AIL and nothing in the iclogs). * If we are then in a state where covering is needed, the caller is informed * that dummy transactions are required to move the log into the idle state. * * Because this is called as part of the sync process, we should also indicate * that dummy transactions should be issued in anything but the covered or * idle states. This ensures that the log tail is accurately reflected in * the log at the end of the sync, hence if a crash occurrs avoids replay * of transactions where the metadata is already on disk. |
1da177e4c Linux-2.6.12-rc2 |
814 815 816 817 |
*/ int xfs_log_need_covered(xfs_mount_t *mp) { |
27d8d5fe0 [XFS] Use a curso... |
818 |
int needed = 0; |
1da177e4c Linux-2.6.12-rc2 |
819 |
xlog_t *log = mp->m_log; |
1da177e4c Linux-2.6.12-rc2 |
820 |
|
92821e2ba [XFS] Lazy Superb... |
821 |
if (!xfs_fs_writable(mp)) |
1da177e4c Linux-2.6.12-rc2 |
822 |
return 0; |
b22cd72c9 [XFS] Unwrap LOG_... |
823 |
spin_lock(&log->l_icloglock); |
b6f8dd49d xfs: ensure that ... |
824 825 826 827 828 829 830 |
switch (log->l_covered_state) { case XLOG_STATE_COVER_DONE: case XLOG_STATE_COVER_DONE2: case XLOG_STATE_COVER_IDLE: break; case XLOG_STATE_COVER_NEED: case XLOG_STATE_COVER_NEED2: |
fd074841c xfs: push the AIL... |
831 |
if (!xfs_ail_min_lsn(log->l_ailp) && |
b6f8dd49d xfs: ensure that ... |
832 833 834 835 836 |
xlog_iclogs_empty(log)) { if (log->l_covered_state == XLOG_STATE_COVER_NEED) log->l_covered_state = XLOG_STATE_COVER_DONE; else log->l_covered_state = XLOG_STATE_COVER_DONE2; |
1da177e4c Linux-2.6.12-rc2 |
837 |
} |
b6f8dd49d xfs: ensure that ... |
838 839 |
/* FALLTHRU */ default: |
1da177e4c Linux-2.6.12-rc2 |
840 |
needed = 1; |
b6f8dd49d xfs: ensure that ... |
841 |
break; |
1da177e4c Linux-2.6.12-rc2 |
842 |
} |
b22cd72c9 [XFS] Unwrap LOG_... |
843 |
spin_unlock(&log->l_icloglock); |
014c2544e return statement ... |
844 |
return needed; |
1da177e4c Linux-2.6.12-rc2 |
845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 |
} /****************************************************************************** * * local routines * ****************************************************************************** */ /* xfs_trans_tail_ail returns 0 when there is nothing in the list. * The log manager must keep track of the last LR which was committed * to disk. The lsn of this LR will become the new tail_lsn whenever * xfs_trans_tail_ail returns 0. If we don't do this, we run into * the situation where stuff could be written into the log but nothing * was ever in the AIL when asked. Eventually, we panic since the * tail hits the head. * * We may be holding the log iclog lock upon entering this routine. */ xfs_lsn_t |
1c3cb9ec0 xfs: convert l_ta... |
865 866 |
xlog_assign_tail_lsn( struct xfs_mount *mp) |
1da177e4c Linux-2.6.12-rc2 |
867 |
{ |
1c3cb9ec0 xfs: convert l_ta... |
868 869 |
xfs_lsn_t tail_lsn; struct log *log = mp->m_log; |
1da177e4c Linux-2.6.12-rc2 |
870 |
|
fd074841c xfs: push the AIL... |
871 |
tail_lsn = xfs_ail_min_lsn(mp->m_ail); |
84f3c683c xfs: convert l_la... |
872 873 |
if (!tail_lsn) tail_lsn = atomic64_read(&log->l_last_sync_lsn); |
1da177e4c Linux-2.6.12-rc2 |
874 |
|
1c3cb9ec0 xfs: convert l_ta... |
875 |
atomic64_set(&log->l_tail_lsn, tail_lsn); |
1da177e4c Linux-2.6.12-rc2 |
876 |
return tail_lsn; |
1c3cb9ec0 xfs: convert l_ta... |
877 |
} |
1da177e4c Linux-2.6.12-rc2 |
878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 |
/* * Return the space in the log between the tail and the head. The head * is passed in the cycle/bytes formal parms. In the special case where * the reserve head has wrapped passed the tail, this calculation is no * longer valid. In this case, just return 0 which means there is no space * in the log. This works for all places where this function is called * with the reserve head. Of course, if the write head were to ever * wrap the tail, we should blow up. Rather than catch this case here, * we depend on other ASSERTions in other parts of the code. XXXmiken * * This code also handles the case where the reservation head is behind * the tail. The details of this case are described below, but the end * result is that we return the size of the log as the amount of space left. */ |
a8272ce0c [XFS] Fix up spar... |
893 |
STATIC int |
a69ed03c2 xfs: combine gran... |
894 895 |
xlog_space_left( struct log *log, |
c8a09ff8c xfs: convert log ... |
896 |
atomic64_t *head) |
1da177e4c Linux-2.6.12-rc2 |
897 |
{ |
a69ed03c2 xfs: combine gran... |
898 899 900 901 902 |
int free_bytes; int tail_bytes; int tail_cycle; int head_cycle; int head_bytes; |
1da177e4c Linux-2.6.12-rc2 |
903 |
|
a69ed03c2 xfs: combine gran... |
904 |
xlog_crack_grant_head(head, &head_cycle, &head_bytes); |
1c3cb9ec0 xfs: convert l_ta... |
905 906 |
xlog_crack_atomic_lsn(&log->l_tail_lsn, &tail_cycle, &tail_bytes); tail_bytes = BBTOB(tail_bytes); |
a69ed03c2 xfs: combine gran... |
907 908 909 |
if (tail_cycle == head_cycle && head_bytes >= tail_bytes) free_bytes = log->l_logsize - (head_bytes - tail_bytes); else if (tail_cycle + 1 < head_cycle) |
1da177e4c Linux-2.6.12-rc2 |
910 |
return 0; |
a69ed03c2 xfs: combine gran... |
911 912 913 |
else if (tail_cycle < head_cycle) { ASSERT(tail_cycle == (head_cycle - 1)); free_bytes = tail_bytes - head_bytes; |
1da177e4c Linux-2.6.12-rc2 |
914 915 916 917 918 919 |
} else { /* * The reservation head is behind the tail. * In this case we just want to return the size of the * log as the amount of space left. */ |
a0fa2b679 xfs: Convert xlog... |
920 |
xfs_alert(log->l_mp, |
1da177e4c Linux-2.6.12-rc2 |
921 922 923 924 925 |
"xlog_space_left: head behind tail " " tail_cycle = %d, tail_bytes = %d " " GH cycle = %d, GH bytes = %d", |
a69ed03c2 xfs: combine gran... |
926 |
tail_cycle, tail_bytes, head_cycle, head_bytes); |
1da177e4c Linux-2.6.12-rc2 |
927 928 929 930 |
ASSERT(0); free_bytes = log->l_logsize; } return free_bytes; |
a69ed03c2 xfs: combine gran... |
931 |
} |
1da177e4c Linux-2.6.12-rc2 |
932 933 934 935 936 937 938 939 940 941 942 |
/* * Log function which is called when an io completes. * * The log manager needs its own routine, in order to control what * happens with the buffer after the write completes. */ void xlog_iodone(xfs_buf_t *bp) { |
adadbeefb xfs: remove wrapp... |
943 944 945 |
xlog_in_core_t *iclog = bp->b_fspriv; xlog_t *l = iclog->ic_log; int aborted = 0; |
1da177e4c Linux-2.6.12-rc2 |
946 947 948 949 |
/* * Race to shutdown the filesystem if we see an error. */ |
5a52c2a58 xfs: Remove the m... |
950 |
if (XFS_TEST_ERROR((xfs_buf_geterror(bp)), l->l_mp, |
1da177e4c Linux-2.6.12-rc2 |
951 |
XFS_ERRTAG_IODONE_IOERR, XFS_RANDOM_IODONE_IOERR)) { |
901796afc xfs: clean up xfs... |
952 |
xfs_buf_ioerror_alert(bp, __func__); |
c867cb616 xfs: remove XFS_B... |
953 |
xfs_buf_stale(bp); |
7d04a335b [XFS] Shutdown th... |
954 |
xfs_force_shutdown(l->l_mp, SHUTDOWN_LOG_IO_ERROR); |
1da177e4c Linux-2.6.12-rc2 |
955 956 957 958 959 960 961 962 963 |
/* * This flag will be propagated to the trans-committed * callback routines to let them know that the log-commit * didn't succeed. */ aborted = XFS_LI_ABORTED; } else if (iclog->ic_state & XLOG_STATE_IOERROR) { aborted = XFS_LI_ABORTED; } |
3db296f34 [XFS] Fix use-aft... |
964 965 966 |
/* log I/O is always issued ASYNC */ ASSERT(XFS_BUF_ISASYNC(bp)); |
1da177e4c Linux-2.6.12-rc2 |
967 |
xlog_state_done_syncing(iclog, aborted); |
3db296f34 [XFS] Fix use-aft... |
968 969 970 971 972 |
/* * do not reference the buffer (bp) here as we could race * with it being freed after writing the unmount record to the * log. */ |
1da177e4c Linux-2.6.12-rc2 |
973 974 975 |
} /* xlog_iodone */ /* |
1da177e4c Linux-2.6.12-rc2 |
976 977 |
* Return size of each in-core log record buffer. * |
9da096fd1 xfs: fix various ... |
978 |
* All machines get 8 x 32kB buffers by default, unless tuned otherwise. |
1da177e4c Linux-2.6.12-rc2 |
979 980 981 982 983 984 985 986 987 988 989 |
* * If the filesystem blocksize is too large, we may need to choose a * larger size since the directory code currently logs entire blocks. */ STATIC void xlog_get_iclog_buffer_size(xfs_mount_t *mp, xlog_t *log) { int size; int xhdrs; |
1cb512587 [XFS] choose sing... |
990 991 992 |
if (mp->m_logbufs <= 0) log->l_iclog_bufs = XLOG_MAX_ICLOGS; else |
cfcbbbd08 [XFS] Remove old,... |
993 |
log->l_iclog_bufs = mp->m_logbufs; |
1da177e4c Linux-2.6.12-rc2 |
994 995 996 997 |
/* * Buffer size passed in from mount system call. */ |
cfcbbbd08 [XFS] Remove old,... |
998 |
if (mp->m_logbsize > 0) { |
1da177e4c Linux-2.6.12-rc2 |
999 1000 1001 1002 1003 1004 |
size = log->l_iclog_size = mp->m_logbsize; log->l_iclog_size_log = 0; while (size != 1) { log->l_iclog_size_log++; size >>= 1; } |
621187099 [XFS] remove shou... |
1005 |
if (xfs_sb_version_haslogv2(&mp->m_sb)) { |
9da096fd1 xfs: fix various ... |
1006 1007 |
/* # headers = size / 32k * one header holds cycles from 32k of data |
1da177e4c Linux-2.6.12-rc2 |
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 |
*/ xhdrs = mp->m_logbsize / XLOG_HEADER_CYCLE_SIZE; if (mp->m_logbsize % XLOG_HEADER_CYCLE_SIZE) xhdrs++; log->l_iclog_hsize = xhdrs << BBSHIFT; log->l_iclog_heads = xhdrs; } else { ASSERT(mp->m_logbsize <= XLOG_BIG_RECORD_BSIZE); log->l_iclog_hsize = BBSIZE; log->l_iclog_heads = 1; } |
cfcbbbd08 [XFS] Remove old,... |
1020 |
goto done; |
1da177e4c Linux-2.6.12-rc2 |
1021 |
} |
9da096fd1 xfs: fix various ... |
1022 |
/* All machines use 32kB buffers by default. */ |
1cb512587 [XFS] choose sing... |
1023 1024 |
log->l_iclog_size = XLOG_BIG_RECORD_BSIZE; log->l_iclog_size_log = XLOG_BIG_RECORD_BSHIFT; |
1da177e4c Linux-2.6.12-rc2 |
1025 1026 1027 1028 |
/* the default log size is 16k or 32k which is one header sector */ log->l_iclog_hsize = BBSIZE; log->l_iclog_heads = 1; |
7153f8ba2 xfs: remove iclog... |
1029 1030 |
done: /* are we being asked to make the sizes selected above visible? */ |
cfcbbbd08 [XFS] Remove old,... |
1031 1032 1033 1034 |
if (mp->m_logbufs == 0) mp->m_logbufs = log->l_iclog_bufs; if (mp->m_logbsize == 0) mp->m_logbsize = log->l_iclog_size; |
1da177e4c Linux-2.6.12-rc2 |
1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 |
} /* xlog_get_iclog_buffer_size */ /* * This routine initializes some of the log structure for a given mount point. * Its primary purpose is to fill in enough, so recovery can occur. However, * some other stuff may be filled in too. */ STATIC xlog_t * xlog_alloc_log(xfs_mount_t *mp, xfs_buftarg_t *log_target, xfs_daddr_t blk_offset, int num_bblks) { xlog_t *log; xlog_rec_header_t *head; xlog_in_core_t **iclogp; xlog_in_core_t *iclog, *prev_iclog=NULL; xfs_buf_t *bp; int i; |
a6cb767e2 xfs: validate log... |
1055 |
int error = ENOMEM; |
69ce58f08 xfs: record log s... |
1056 |
uint log2_size = 0; |
1da177e4c Linux-2.6.12-rc2 |
1057 |
|
644c3567d [XFS] handle memo... |
1058 |
log = kmem_zalloc(sizeof(xlog_t), KM_MAYFAIL); |
a6cb767e2 xfs: validate log... |
1059 |
if (!log) { |
a0fa2b679 xfs: Convert xlog... |
1060 |
xfs_warn(mp, "Log allocation failed: No memory!"); |
a6cb767e2 xfs: validate log... |
1061 1062 |
goto out; } |
1da177e4c Linux-2.6.12-rc2 |
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 |
log->l_mp = mp; log->l_targ = log_target; log->l_logsize = BBTOB(num_bblks); log->l_logBBstart = blk_offset; log->l_logBBsize = num_bblks; log->l_covered_state = XLOG_STATE_COVER_IDLE; log->l_flags |= XLOG_ACTIVE_RECOVERY; log->l_prev_block = -1; |
1da177e4c Linux-2.6.12-rc2 |
1073 |
/* log->l_tail_lsn = 0x100000000LL; cycle = 1; current block = 0 */ |
1c3cb9ec0 xfs: convert l_ta... |
1074 1075 |
xlog_assign_atomic_lsn(&log->l_tail_lsn, 1, 0); xlog_assign_atomic_lsn(&log->l_last_sync_lsn, 1, 0); |
1da177e4c Linux-2.6.12-rc2 |
1076 |
log->l_curr_cycle = 1; /* 0 is bad since this is initial value */ |
a69ed03c2 xfs: combine gran... |
1077 1078 |
xlog_assign_grant_head(&log->l_grant_reserve_head, 1, 0); xlog_assign_grant_head(&log->l_grant_write_head, 1, 0); |
105479419 xfs: convert log ... |
1079 1080 |
INIT_LIST_HEAD(&log->l_reserveq); INIT_LIST_HEAD(&log->l_writeq); |
3f16b9850 xfs: introduce ne... |
1081 1082 |
spin_lock_init(&log->l_grant_reserve_lock); spin_lock_init(&log->l_grant_write_lock); |
1da177e4c Linux-2.6.12-rc2 |
1083 |
|
a6cb767e2 xfs: validate log... |
1084 |
error = EFSCORRUPTED; |
621187099 [XFS] remove shou... |
1085 |
if (xfs_sb_version_hassector(&mp->m_sb)) { |
69ce58f08 xfs: record log s... |
1086 1087 |
log2_size = mp->m_sb.sb_logsectlog; if (log2_size < BBSHIFT) { |
a0fa2b679 xfs: Convert xlog... |
1088 1089 |
xfs_warn(mp, "Log sector size too small (0x%x < 0x%x)", log2_size, BBSHIFT); |
a6cb767e2 xfs: validate log... |
1090 1091 |
goto out_free_log; } |
69ce58f08 xfs: record log s... |
1092 1093 |
log2_size -= BBSHIFT; if (log2_size > mp->m_sectbb_log) { |
a0fa2b679 xfs: Convert xlog... |
1094 1095 |
xfs_warn(mp, "Log sector size too large (0x%x > 0x%x)", log2_size, mp->m_sectbb_log); |
a6cb767e2 xfs: validate log... |
1096 1097 |
goto out_free_log; } |
69ce58f08 xfs: record log s... |
1098 1099 1100 1101 |
/* for larger sector sizes, must have v2 or external log */ if (log2_size && log->l_logBBstart > 0 && !xfs_sb_version_haslogv2(&mp->m_sb)) { |
a0fa2b679 xfs: Convert xlog... |
1102 1103 1104 |
xfs_warn(mp, "log sector size (0x%x) invalid for configuration.", log2_size); |
a6cb767e2 xfs: validate log... |
1105 1106 |
goto out_free_log; } |
1da177e4c Linux-2.6.12-rc2 |
1107 |
} |
69ce58f08 xfs: record log s... |
1108 |
log->l_sectBBsize = 1 << log2_size; |
1da177e4c Linux-2.6.12-rc2 |
1109 1110 |
xlog_get_iclog_buffer_size(mp, log); |
a6cb767e2 xfs: validate log... |
1111 |
error = ENOMEM; |
4347b9d7a xfs: clean up buf... |
1112 |
bp = xfs_buf_alloc(mp->m_logdev_targp, 0, log->l_iclog_size, 0); |
644c3567d [XFS] handle memo... |
1113 1114 |
if (!bp) goto out_free_log; |
cb669ca57 xfs: remove wrapp... |
1115 |
bp->b_iodone = xlog_iodone; |
0c842ad46 xfs: clean up buf... |
1116 |
ASSERT(xfs_buf_islocked(bp)); |
1da177e4c Linux-2.6.12-rc2 |
1117 |
log->l_xbuf = bp; |
007c61c68 [XFS] Remove spin.h |
1118 |
spin_lock_init(&log->l_icloglock); |
eb40a8750 xfs: use wait que... |
1119 |
init_waitqueue_head(&log->l_flush_wait); |
1da177e4c Linux-2.6.12-rc2 |
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 |
/* log record size must be multiple of BBSIZE; see xlog_rec_header_t */ ASSERT((XFS_BUF_SIZE(bp) & BBMASK) == 0); iclogp = &log->l_iclog; /* * The amount of memory to allocate for the iclog structure is * rather funky due to the way the structure is defined. It is * done this way so that we can use different sizes for machines * with different amounts of memory. See the definition of * xlog_in_core_t in xfs_log_priv.h for details. */ |
1da177e4c Linux-2.6.12-rc2 |
1132 1133 |
ASSERT(log->l_iclog_size >= 4096); for (i=0; i < log->l_iclog_bufs; i++) { |
644c3567d [XFS] handle memo... |
1134 1135 1136 |
*iclogp = kmem_zalloc(sizeof(xlog_in_core_t), KM_MAYFAIL); if (!*iclogp) goto out_free_iclog; |
1da177e4c Linux-2.6.12-rc2 |
1137 |
iclog = *iclogp; |
1da177e4c Linux-2.6.12-rc2 |
1138 1139 |
iclog->ic_prev = prev_iclog; prev_iclog = iclog; |
1fa40b01a [XFS] Only use re... |
1140 |
|
686865f76 xfs: rename xfs_b... |
1141 1142 |
bp = xfs_buf_get_uncached(mp->m_logdev_targp, log->l_iclog_size, 0); |
644c3567d [XFS] handle memo... |
1143 1144 |
if (!bp) goto out_free_iclog; |
c8da0faf6 xfs: return the b... |
1145 |
|
cb669ca57 xfs: remove wrapp... |
1146 |
bp->b_iodone = xlog_iodone; |
1fa40b01a [XFS] Only use re... |
1147 |
iclog->ic_bp = bp; |
b28708d6a [XFS] sanitize xl... |
1148 |
iclog->ic_data = bp->b_addr; |
4679b2d36 [XFS] Reorganise ... |
1149 |
#ifdef DEBUG |
1da177e4c Linux-2.6.12-rc2 |
1150 |
log->l_iclog_bak[i] = (xfs_caddr_t)&(iclog->ic_header); |
4679b2d36 [XFS] Reorganise ... |
1151 |
#endif |
1da177e4c Linux-2.6.12-rc2 |
1152 1153 |
head = &iclog->ic_header; memset(head, 0, sizeof(xlog_rec_header_t)); |
b53e675dc [XFS] xlog_rec_he... |
1154 1155 |
head->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM); head->h_version = cpu_to_be32( |
621187099 [XFS] remove shou... |
1156 |
xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1); |
b53e675dc [XFS] xlog_rec_he... |
1157 |
head->h_size = cpu_to_be32(log->l_iclog_size); |
1da177e4c Linux-2.6.12-rc2 |
1158 |
/* new fields */ |
b53e675dc [XFS] xlog_rec_he... |
1159 |
head->h_fmt = cpu_to_be32(XLOG_FMT); |
1da177e4c Linux-2.6.12-rc2 |
1160 |
memcpy(&head->h_fs_uuid, &mp->m_sb.sb_uuid, sizeof(uuid_t)); |
1da177e4c Linux-2.6.12-rc2 |
1161 1162 1163 |
iclog->ic_size = XFS_BUF_SIZE(bp) - log->l_iclog_hsize; iclog->ic_state = XLOG_STATE_ACTIVE; iclog->ic_log = log; |
114d23aae [XFS] Per iclog c... |
1164 1165 |
atomic_set(&iclog->ic_refcnt, 0); spin_lock_init(&iclog->ic_callback_lock); |
1da177e4c Linux-2.6.12-rc2 |
1166 |
iclog->ic_callback_tail = &(iclog->ic_callback); |
b28708d6a [XFS] sanitize xl... |
1167 |
iclog->ic_datap = (char *)iclog->ic_data + log->l_iclog_hsize; |
1da177e4c Linux-2.6.12-rc2 |
1168 |
|
0c842ad46 xfs: clean up buf... |
1169 |
ASSERT(xfs_buf_islocked(iclog->ic_bp)); |
eb40a8750 xfs: use wait que... |
1170 1171 |
init_waitqueue_head(&iclog->ic_force_wait); init_waitqueue_head(&iclog->ic_write_wait); |
1da177e4c Linux-2.6.12-rc2 |
1172 1173 1174 1175 1176 |
iclogp = &iclog->ic_next; } *iclogp = log->l_iclog; /* complete ring */ log->l_iclog->ic_prev = prev_iclog; /* re-write 1st prev ptr */ |
71e330b59 xfs: Introduce de... |
1177 1178 1179 |
error = xlog_cil_init(log); if (error) goto out_free_iclog; |
1da177e4c Linux-2.6.12-rc2 |
1180 |
return log; |
644c3567d [XFS] handle memo... |
1181 1182 1183 1184 |
out_free_iclog: for (iclog = log->l_iclog; iclog; iclog = prev_iclog) { prev_iclog = iclog->ic_next; |
eb40a8750 xfs: use wait que... |
1185 |
if (iclog->ic_bp) |
644c3567d [XFS] handle memo... |
1186 |
xfs_buf_free(iclog->ic_bp); |
644c3567d [XFS] handle memo... |
1187 1188 1189 |
kmem_free(iclog); } spinlock_destroy(&log->l_icloglock); |
644c3567d [XFS] handle memo... |
1190 1191 1192 |
xfs_buf_free(log->l_xbuf); out_free_log: kmem_free(log); |
a6cb767e2 xfs: validate log... |
1193 1194 |
out: return ERR_PTR(-error); |
1da177e4c Linux-2.6.12-rc2 |
1195 1196 1197 1198 1199 1200 1201 1202 |
} /* xlog_alloc_log */ /* * Write out the commit record of a transaction associated with the given * ticket. Return the lsn of the commit record. */ STATIC int |
55b66332d xfs: introduce ne... |
1203 1204 1205 1206 1207 |
xlog_commit_record( struct log *log, struct xlog_ticket *ticket, struct xlog_in_core **iclog, xfs_lsn_t *commitlsnp) |
1da177e4c Linux-2.6.12-rc2 |
1208 |
{ |
55b66332d xfs: introduce ne... |
1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 |
struct xfs_mount *mp = log->l_mp; int error; struct xfs_log_iovec reg = { .i_addr = NULL, .i_len = 0, .i_type = XLOG_REG_TYPE_COMMIT, }; struct xfs_log_vec vec = { .lv_niovecs = 1, .lv_iovecp = ®, }; |
1da177e4c Linux-2.6.12-rc2 |
1220 1221 |
ASSERT_ALWAYS(iclog); |
55b66332d xfs: introduce ne... |
1222 1223 1224 |
error = xlog_write(log, &vec, ticket, commitlsnp, iclog, XLOG_COMMIT_TRANS); if (error) |
7d04a335b [XFS] Shutdown th... |
1225 |
xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR); |
014c2544e return statement ... |
1226 |
return error; |
55b66332d xfs: introduce ne... |
1227 |
} |
1da177e4c Linux-2.6.12-rc2 |
1228 1229 1230 1231 1232 1233 1234 1235 |
/* * Push on the buffer cache code if we ever use more than 75% of the on-disk * log space. This code pushes on the lsn which would supposedly free up * the 25% which we want to leave free. We may need to adopt a policy which * pushes on an lsn which is further along in the log once we reach the high * water mark. In this manner, we would be creating a low water mark. */ |
a8272ce0c [XFS] Fix up spar... |
1236 |
STATIC void |
2ced19cba xfs: make AIL tai... |
1237 1238 1239 |
xlog_grant_push_ail( struct log *log, int need_bytes) |
1da177e4c Linux-2.6.12-rc2 |
1240 |
{ |
2ced19cba xfs: make AIL tai... |
1241 |
xfs_lsn_t threshold_lsn = 0; |
84f3c683c xfs: convert l_la... |
1242 |
xfs_lsn_t last_sync_lsn; |
2ced19cba xfs: make AIL tai... |
1243 1244 1245 1246 1247 1248 1249 |
int free_blocks; int free_bytes; int threshold_block; int threshold_cycle; int free_threshold; ASSERT(BTOBB(need_bytes) < log->l_logBBsize); |
2ced19cba xfs: make AIL tai... |
1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 |
free_bytes = xlog_space_left(log, &log->l_grant_reserve_head); free_blocks = BTOBBT(free_bytes); /* * Set the threshold for the minimum number of free blocks in the * log to the maximum of what the caller needs, one quarter of the * log, and 256 blocks. */ free_threshold = BTOBB(need_bytes); free_threshold = MAX(free_threshold, (log->l_logBBsize >> 2)); free_threshold = MAX(free_threshold, 256); if (free_blocks >= free_threshold) return; |
1c3cb9ec0 xfs: convert l_ta... |
1263 1264 1265 |
xlog_crack_atomic_lsn(&log->l_tail_lsn, &threshold_cycle, &threshold_block); threshold_block += free_threshold; |
1da177e4c Linux-2.6.12-rc2 |
1266 |
if (threshold_block >= log->l_logBBsize) { |
2ced19cba xfs: make AIL tai... |
1267 1268 |
threshold_block -= log->l_logBBsize; threshold_cycle += 1; |
1da177e4c Linux-2.6.12-rc2 |
1269 |
} |
2ced19cba xfs: make AIL tai... |
1270 1271 1272 1273 |
threshold_lsn = xlog_assign_lsn(threshold_cycle, threshold_block); /* * Don't pass in an lsn greater than the lsn of the last |
84f3c683c xfs: convert l_la... |
1274 1275 |
* log record known to be on disk. Use a snapshot of the last sync lsn * so that it doesn't change between the compare and the set. |
1da177e4c Linux-2.6.12-rc2 |
1276 |
*/ |
84f3c683c xfs: convert l_la... |
1277 1278 1279 |
last_sync_lsn = atomic64_read(&log->l_last_sync_lsn); if (XFS_LSN_CMP(threshold_lsn, last_sync_lsn) > 0) threshold_lsn = last_sync_lsn; |
2ced19cba xfs: make AIL tai... |
1280 1281 1282 1283 1284 1285 1286 |
/* * Get the transaction layer to kick the dirty buffers out to * disk asynchronously. No point in trying to do this if * the filesystem is shutting down. */ if (!XLOG_FORCED_SHUTDOWN(log)) |
fd074841c xfs: push the AIL... |
1287 |
xfs_ail_push(log->l_ailp, threshold_lsn); |
2ced19cba xfs: make AIL tai... |
1288 |
} |
1da177e4c Linux-2.6.12-rc2 |
1289 |
|
873ff5501 xfs: clean up log... |
1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 |
/* * The bdstrat callback function for log bufs. This gives us a central * place to trap bufs in case we get hit by a log I/O error and need to * shutdown. Actually, in practice, even when we didn't get a log error, * we transition the iclogs to IOERROR state *after* flushing all existing * iclogs to disk. This is because we don't want anymore new transactions to be * started or completed afterwards. */ STATIC int xlog_bdstrat( struct xfs_buf *bp) { |
adadbeefb xfs: remove wrapp... |
1302 |
struct xlog_in_core *iclog = bp->b_fspriv; |
873ff5501 xfs: clean up log... |
1303 |
|
873ff5501 xfs: clean up log... |
1304 |
if (iclog->ic_state & XLOG_STATE_IOERROR) { |
5a52c2a58 xfs: Remove the m... |
1305 |
xfs_buf_ioerror(bp, EIO); |
c867cb616 xfs: remove XFS_B... |
1306 |
xfs_buf_stale(bp); |
1a1a3e97b xfs: remove xfs_b... |
1307 |
xfs_buf_ioend(bp, 0); |
873ff5501 xfs: clean up log... |
1308 1309 1310 1311 1312 1313 1314 |
/* * It would seem logical to return EIO here, but we rely on * the log state machine to propagate I/O errors instead of * doing it here. */ return 0; } |
873ff5501 xfs: clean up log... |
1315 1316 1317 |
xfs_buf_iorequest(bp); return 0; } |
1da177e4c Linux-2.6.12-rc2 |
1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 |
/* * Flush out the in-core log (iclog) to the on-disk log in an asynchronous * fashion. Previously, we should have moved the current iclog * ptr in the log to point to the next available iclog. This allows further * write to continue while this code syncs out an iclog ready to go. * Before an in-core log can be written out, the data section must be scanned * to save away the 1st word of each BBSIZE block into the header. We replace * it with the current cycle count. Each BBSIZE block is tagged with the * cycle count because there in an implicit assumption that drives will * guarantee that entire 512 byte blocks get written at once. In other words, * we can't have part of a 512 byte block written and part not written. By * tagging each block, we will know which blocks are valid when recovering * after an unclean shutdown. * * This routine is single threaded on the iclog. No other thread can be in * this routine with the same iclog. Changing contents of iclog can there- * fore be done without grabbing the state machine lock. Updating the global * log will require grabbing the lock though. * * The entire log manager uses a logical block numbering scheme. Only * log_sync (and then only bwrite()) know about the fact that the log may * not start with block zero on a given device. The log block start offset * is added immediately before calling bwrite(). */ |
a8272ce0c [XFS] Fix up spar... |
1343 |
STATIC int |
1da177e4c Linux-2.6.12-rc2 |
1344 1345 1346 1347 1348 |
xlog_sync(xlog_t *log, xlog_in_core_t *iclog) { xfs_caddr_t dptr; /* pointer to byte sized element */ xfs_buf_t *bp; |
b53e675dc [XFS] xlog_rec_he... |
1349 |
int i; |
1da177e4c Linux-2.6.12-rc2 |
1350 1351 1352 1353 1354 |
uint count; /* byte count of bwrite */ uint count_init; /* initial count before roundup */ int roundoff; /* roundoff to BB or stripe */ int split = 0; /* split write into two regions */ int error; |
621187099 [XFS] remove shou... |
1355 |
int v2 = xfs_sb_version_haslogv2(&log->l_mp->m_sb); |
1da177e4c Linux-2.6.12-rc2 |
1356 1357 |
XFS_STATS_INC(xs_log_writes); |
155cc6b78 [XFS] Use atomics... |
1358 |
ASSERT(atomic_read(&iclog->ic_refcnt) == 0); |
1da177e4c Linux-2.6.12-rc2 |
1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 |
/* Add for LR header */ count_init = log->l_iclog_hsize + iclog->ic_offset; /* Round out the log write size */ if (v2 && log->l_mp->m_sb.sb_logsunit > 1) { /* we have a v2 stripe unit to use */ count = XLOG_LSUNITTOB(log, XLOG_BTOLSUNIT(log, count_init)); } else { count = BBTOB(BTOBB(count_init)); } roundoff = count - count_init; ASSERT(roundoff >= 0); ASSERT((v2 && log->l_mp->m_sb.sb_logsunit > 1 && roundoff < log->l_mp->m_sb.sb_logsunit) || (log->l_mp->m_sb.sb_logsunit <= 1 && roundoff < BBTOB(1))); /* move grant heads by roundoff in sync */ |
a69ed03c2 xfs: combine gran... |
1379 1380 |
xlog_grant_add_space(log, &log->l_grant_reserve_head, roundoff); xlog_grant_add_space(log, &log->l_grant_write_head, roundoff); |
1da177e4c Linux-2.6.12-rc2 |
1381 1382 1383 1384 1385 1386 |
/* put cycle number in every block */ xlog_pack_data(log, iclog, roundoff); /* real byte length */ if (v2) { |
b53e675dc [XFS] xlog_rec_he... |
1387 1388 |
iclog->ic_header.h_len = cpu_to_be32(iclog->ic_offset + roundoff); |
1da177e4c Linux-2.6.12-rc2 |
1389 |
} else { |
b53e675dc [XFS] xlog_rec_he... |
1390 1391 |
iclog->ic_header.h_len = cpu_to_be32(iclog->ic_offset); |
1da177e4c Linux-2.6.12-rc2 |
1392 |
} |
f5faad799 [XFS] Fix remount... |
1393 |
bp = iclog->ic_bp; |
b53e675dc [XFS] xlog_rec_he... |
1394 |
XFS_BUF_SET_ADDR(bp, BLOCK_LSN(be64_to_cpu(iclog->ic_header.h_lsn))); |
1da177e4c Linux-2.6.12-rc2 |
1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 |
XFS_STATS_ADD(xs_log_blocks, BTOBB(count)); /* Do we need to split this write into 2 parts? */ if (XFS_BUF_ADDR(bp) + BTOBB(count) > log->l_logBBsize) { split = count - (BBTOB(log->l_logBBsize - XFS_BUF_ADDR(bp))); count = BBTOB(log->l_logBBsize - XFS_BUF_ADDR(bp)); iclog->ic_bwritecnt = 2; /* split into 2 writes */ } else { iclog->ic_bwritecnt = 1; } |
511105b3d [XFS] Fix vmalloc... |
1406 |
XFS_BUF_SET_COUNT(bp, count); |
adadbeefb xfs: remove wrapp... |
1407 |
bp->b_fspriv = iclog; |
f5faad799 [XFS] Fix remount... |
1408 |
XFS_BUF_ZEROFLAGS(bp); |
1da177e4c Linux-2.6.12-rc2 |
1409 |
XFS_BUF_ASYNC(bp); |
1d5ae5dfe xfs: cleanup I/O-... |
1410 |
bp->b_flags |= XBF_SYNCIO; |
651701d71 xfs: remove incor... |
1411 |
|
a27a263ba xfs: make log dev... |
1412 |
if (log->l_mp->m_flags & XFS_MOUNT_BARRIER) { |
e163cbde9 xfs: avoid a few ... |
1413 |
bp->b_flags |= XBF_FUA; |
a27a263ba xfs: make log dev... |
1414 |
/* |
e163cbde9 xfs: avoid a few ... |
1415 1416 1417 1418 1419 1420 1421 |
* Flush the data device before flushing the log to make * sure all meta data written back from the AIL actually made * it to disk before stamping the new log tail LSN into the * log buffer. For an external log we need to issue the * flush explicitly, and unfortunately synchronously here; * for an internal log we can simply use the block layer * state machine for preflushes. |
a27a263ba xfs: make log dev... |
1422 1423 1424 |
*/ if (log->l_mp->m_logdev_targp != log->l_mp->m_ddev_targp) xfs_blkdev_issue_flush(log->l_mp->m_ddev_targp); |
e163cbde9 xfs: avoid a few ... |
1425 1426 |
else bp->b_flags |= XBF_FLUSH; |
a27a263ba xfs: make log dev... |
1427 |
} |
1da177e4c Linux-2.6.12-rc2 |
1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 |
ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1); ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize); xlog_verify_iclog(log, iclog, count, B_TRUE); /* account for log which doesn't start at block #0 */ XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart); /* * Don't call xfs_bwrite here. We do log-syncs even when the filesystem * is shutting down. */ XFS_BUF_WRITE(bp); |
901796afc xfs: clean up xfs... |
1441 1442 1443 |
error = xlog_bdstrat(bp); if (error) { xfs_buf_ioerror_alert(bp, "xlog_sync"); |
014c2544e return statement ... |
1444 |
return error; |
1da177e4c Linux-2.6.12-rc2 |
1445 1446 |
} if (split) { |
f5faad799 [XFS] Fix remount... |
1447 |
bp = iclog->ic_log->l_xbuf; |
1da177e4c Linux-2.6.12-rc2 |
1448 |
XFS_BUF_SET_ADDR(bp, 0); /* logical 0 */ |
02fe03d90 xfs: Remove the m... |
1449 1450 |
xfs_buf_associate_memory(bp, (char *)&iclog->ic_header + count, split); |
adadbeefb xfs: remove wrapp... |
1451 |
bp->b_fspriv = iclog; |
f5faad799 [XFS] Fix remount... |
1452 |
XFS_BUF_ZEROFLAGS(bp); |
1da177e4c Linux-2.6.12-rc2 |
1453 |
XFS_BUF_ASYNC(bp); |
1d5ae5dfe xfs: cleanup I/O-... |
1454 |
bp->b_flags |= XBF_SYNCIO; |
f538d4da8 [XFS] write barri... |
1455 |
if (log->l_mp->m_flags & XFS_MOUNT_BARRIER) |
e163cbde9 xfs: avoid a few ... |
1456 |
bp->b_flags |= XBF_FUA; |
629260444 xfs: Remove the m... |
1457 |
dptr = bp->b_addr; |
1da177e4c Linux-2.6.12-rc2 |
1458 1459 1460 1461 1462 1463 |
/* * Bump the cycle numbers at the start of each block * since this part of the buffer is at the start of * a new cycle. Watch out for the header magic number * case, though. */ |
b53e675dc [XFS] xlog_rec_he... |
1464 |
for (i = 0; i < split; i += BBSIZE) { |
413d57c99 xfs: convert beX_... |
1465 |
be32_add_cpu((__be32 *)dptr, 1); |
b53e675dc [XFS] xlog_rec_he... |
1466 |
if (be32_to_cpu(*(__be32 *)dptr) == XLOG_HEADER_MAGIC_NUM) |
413d57c99 xfs: convert beX_... |
1467 |
be32_add_cpu((__be32 *)dptr, 1); |
1da177e4c Linux-2.6.12-rc2 |
1468 1469 1470 1471 1472 |
dptr += BBSIZE; } ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1); ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize); |
c41564b5a [XFS] We really s... |
1473 |
/* account for internal log which doesn't start at block #0 */ |
1da177e4c Linux-2.6.12-rc2 |
1474 1475 |
XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart); XFS_BUF_WRITE(bp); |
901796afc xfs: clean up xfs... |
1476 1477 1478 |
error = xlog_bdstrat(bp); if (error) { xfs_buf_ioerror_alert(bp, "xlog_sync (split)"); |
014c2544e return statement ... |
1479 |
return error; |
1da177e4c Linux-2.6.12-rc2 |
1480 1481 |
} } |
014c2544e return statement ... |
1482 |
return 0; |
1da177e4c Linux-2.6.12-rc2 |
1483 1484 1485 1486 |
} /* xlog_sync */ /* |
c41564b5a [XFS] We really s... |
1487 |
* Deallocate a log structure |
1da177e4c Linux-2.6.12-rc2 |
1488 |
*/ |
a8272ce0c [XFS] Fix up spar... |
1489 |
STATIC void |
c41564b5a [XFS] We really s... |
1490 |
xlog_dealloc_log(xlog_t *log) |
1da177e4c Linux-2.6.12-rc2 |
1491 1492 |
{ xlog_in_core_t *iclog, *next_iclog; |
1da177e4c Linux-2.6.12-rc2 |
1493 |
int i; |
71e330b59 xfs: Introduce de... |
1494 |
xlog_cil_destroy(log); |
44396476a xfs: reset buffer... |
1495 1496 1497 1498 1499 1500 |
/* * always need to ensure that the extra buffer does not point to memory * owned by another log buffer before we free it. */ xfs_buf_set_empty(log->l_xbuf, log->l_iclog_size); xfs_buf_free(log->l_xbuf); |
1da177e4c Linux-2.6.12-rc2 |
1501 1502 |
iclog = log->l_iclog; for (i=0; i<log->l_iclog_bufs; i++) { |
1da177e4c Linux-2.6.12-rc2 |
1503 |
xfs_buf_free(iclog->ic_bp); |
1da177e4c Linux-2.6.12-rc2 |
1504 |
next_iclog = iclog->ic_next; |
f0e2d93c2 [XFS] Remove unus... |
1505 |
kmem_free(iclog); |
1da177e4c Linux-2.6.12-rc2 |
1506 1507 |
iclog = next_iclog; } |
1da177e4c Linux-2.6.12-rc2 |
1508 |
spinlock_destroy(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
1509 |
|
1da177e4c Linux-2.6.12-rc2 |
1510 |
log->l_mp->m_log = NULL; |
f0e2d93c2 [XFS] Remove unus... |
1511 |
kmem_free(log); |
c41564b5a [XFS] We really s... |
1512 |
} /* xlog_dealloc_log */ |
1da177e4c Linux-2.6.12-rc2 |
1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 |
/* * Update counters atomically now that memcpy is done. */ /* ARGSUSED */ static inline void xlog_state_finish_copy(xlog_t *log, xlog_in_core_t *iclog, int record_cnt, int copy_bytes) { |
b22cd72c9 [XFS] Unwrap LOG_... |
1524 |
spin_lock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
1525 |
|
413d57c99 xfs: convert beX_... |
1526 |
be32_add_cpu(&iclog->ic_header.h_num_logops, record_cnt); |
1da177e4c Linux-2.6.12-rc2 |
1527 |
iclog->ic_offset += copy_bytes; |
b22cd72c9 [XFS] Unwrap LOG_... |
1528 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
1529 1530 1531 1532 1533 1534 |
} /* xlog_state_finish_copy */ /* |
7e9c63961 [XFS] 929956 add ... |
1535 1536 1537 |
* print out info relating to regions written which consume * the reservation */ |
71e330b59 xfs: Introduce de... |
1538 1539 1540 1541 |
void xlog_print_tic_res( struct xfs_mount *mp, struct xlog_ticket *ticket) |
7e9c63961 [XFS] 929956 add ... |
1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 |
{ uint i; uint ophdr_spc = ticket->t_res_num_ophdrs * (uint)sizeof(xlog_op_header_t); /* match with XLOG_REG_TYPE_* in xfs_log.h */ static char *res_type_str[XLOG_REG_TYPE_MAX] = { "bformat", "bchunk", "efi_format", "efd_format", "iformat", "icore", "iext", "ibroot", "ilocal", "iattr_ext", "iattr_broot", "iattr_local", "qformat", "dquot", "quotaoff", "LR header", "unmount", "commit", "trans header" }; static char *trans_type_str[XFS_TRANS_TYPE_MAX] = { "SETATTR_NOT_SIZE", "SETATTR_SIZE", "INACTIVE", "CREATE", "CREATE_TRUNC", "TRUNCATE_FILE", "REMOVE", "LINK", "RENAME", "MKDIR", "RMDIR", "SYMLINK", "SET_DMATTRS", "GROWFS", "STRAT_WRITE", "DIOSTRAT", "WRITE_SYNC", "WRITEID", "ADDAFORK", "ATTRINVAL", "ATRUNCATE", "ATTR_SET", "ATTR_RM", "ATTR_FLAG", "CLEAR_AGI_BUCKET", "QM_SBCHANGE", "DUMMY1", "DUMMY2", "QM_QUOTAOFF", "QM_DQALLOC", "QM_SETQLIM", "QM_DQCLUSTER", "QM_QINOCREATE", "QM_QUOTAOFF_END", "SB_UNIT", "FSYNC_TS", "GROWFSRT_ALLOC", "GROWFSRT_ZERO", "GROWFSRT_FREE", "SWAPEXT" }; |
a0fa2b679 xfs: Convert xlog... |
1610 |
xfs_warn(mp, |
93b8a5854 xfs: remove the d... |
1611 1612 |
"xlog_write: reservation summary: " |
a0fa2b679 xfs: Convert xlog... |
1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 |
" trans type = %s (%u) " " unit res = %d bytes " " current res = %d bytes " " total reg = %u bytes (o/flow = %u bytes) " " ophdrs = %u (ophdr space = %u bytes) " " ophdr + reg = %u bytes " " num regions = %u ", ((ticket->t_trans_type <= 0 || ticket->t_trans_type > XFS_TRANS_TYPE_MAX) ? "bad-trans-type" : trans_type_str[ticket->t_trans_type-1]), ticket->t_trans_type, ticket->t_unit_res, ticket->t_curr_res, ticket->t_res_arr_sum, ticket->t_res_o_flow, ticket->t_res_num_ophdrs, ophdr_spc, ticket->t_res_arr_sum + ticket->t_res_o_flow + ophdr_spc, ticket->t_res_num); |
7e9c63961 [XFS] 929956 add ... |
1638 1639 |
for (i = 0; i < ticket->t_res_num; i++) { |
a0fa2b679 xfs: Convert xlog... |
1640 1641 1642 |
uint r_type = ticket->t_res_arr[i].r_type; xfs_warn(mp, "region[%u]: %s - %u bytes ", i, |
7e9c63961 [XFS] 929956 add ... |
1643 1644 1645 1646 |
((r_type <= 0 || r_type > XLOG_REG_TYPE_MAX) ? "bad-rtype" : res_type_str[r_type-1]), ticket->t_res_arr[i].r_len); } |
169a7b078 xfs: clean up log... |
1647 |
|
a0fa2b679 xfs: Convert xlog... |
1648 |
xfs_alert_tag(mp, XFS_PTAG_LOGRES, |
93b8a5854 xfs: remove the d... |
1649 |
"xlog_write: reservation ran out. Need to up reservation"); |
169a7b078 xfs: clean up log... |
1650 |
xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); |
7e9c63961 [XFS] 929956 add ... |
1651 |
} |
7e9c63961 [XFS] 929956 add ... |
1652 1653 |
/* |
b5203cd0a xfs: factor xlog_... |
1654 1655 1656 1657 1658 1659 |
* Calculate the potential space needed by the log vector. Each region gets * its own xlog_op_header_t and may need to be double word aligned. */ static int xlog_write_calc_vec_length( struct xlog_ticket *ticket, |
55b66332d xfs: introduce ne... |
1660 |
struct xfs_log_vec *log_vector) |
b5203cd0a xfs: factor xlog_... |
1661 |
{ |
55b66332d xfs: introduce ne... |
1662 |
struct xfs_log_vec *lv; |
b5203cd0a xfs: factor xlog_... |
1663 1664 1665 1666 1667 1668 1669 |
int headers = 0; int len = 0; int i; /* acct for start rec of xact */ if (ticket->t_flags & XLOG_TIC_INITED) headers++; |
55b66332d xfs: introduce ne... |
1670 1671 1672 1673 1674 |
for (lv = log_vector; lv; lv = lv->lv_next) { headers += lv->lv_niovecs; for (i = 0; i < lv->lv_niovecs; i++) { struct xfs_log_iovec *vecp = &lv->lv_iovecp[i]; |
b5203cd0a xfs: factor xlog_... |
1675 |
|
55b66332d xfs: introduce ne... |
1676 1677 1678 |
len += vecp->i_len; xlog_tic_add_region(ticket, vecp->i_len, vecp->i_type); } |
b5203cd0a xfs: factor xlog_... |
1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 |
} ticket->t_res_num_ophdrs += headers; len += headers * sizeof(struct xlog_op_header); return len; } /* * If first write for transaction, insert start record We can't be trying to * commit if we are inited. We can't have any "partial_copy" if we are inited. */ static int xlog_write_start_rec( |
e6b1f2737 xfs: clean up xlo... |
1693 |
struct xlog_op_header *ophdr, |
b5203cd0a xfs: factor xlog_... |
1694 1695 |
struct xlog_ticket *ticket) { |
b5203cd0a xfs: factor xlog_... |
1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 |
if (!(ticket->t_flags & XLOG_TIC_INITED)) return 0; ophdr->oh_tid = cpu_to_be32(ticket->t_tid); ophdr->oh_clientid = ticket->t_clientid; ophdr->oh_len = 0; ophdr->oh_flags = XLOG_START_TRANS; ophdr->oh_res2 = 0; ticket->t_flags &= ~XLOG_TIC_INITED; return sizeof(struct xlog_op_header); } static xlog_op_header_t * xlog_write_setup_ophdr( struct log *log, |
e6b1f2737 xfs: clean up xlo... |
1713 |
struct xlog_op_header *ophdr, |
b5203cd0a xfs: factor xlog_... |
1714 1715 1716 |
struct xlog_ticket *ticket, uint flags) { |
b5203cd0a xfs: factor xlog_... |
1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 |
ophdr->oh_tid = cpu_to_be32(ticket->t_tid); ophdr->oh_clientid = ticket->t_clientid; ophdr->oh_res2 = 0; /* are we copying a commit or unmount record? */ ophdr->oh_flags = flags; /* * We've seen logs corrupted with bad transaction client ids. This * makes sure that XFS doesn't generate them on. Turn this into an EIO * and shut down the filesystem. */ switch (ophdr->oh_clientid) { case XFS_TRANSACTION: case XFS_VOLUME: case XFS_LOG: break; default: |
a0fa2b679 xfs: Convert xlog... |
1735 |
xfs_warn(log->l_mp, |
b5203cd0a xfs: factor xlog_... |
1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 |
"Bad XFS transaction clientid 0x%x in ticket 0x%p", ophdr->oh_clientid, ticket); return NULL; } return ophdr; } /* * Set up the parameters of the region copy into the log. This has * to handle region write split across multiple log buffers - this * state is kept external to this function so that this code can * can be written in an obvious, self documenting manner. */ static int xlog_write_setup_copy( struct xlog_ticket *ticket, struct xlog_op_header *ophdr, int space_available, int space_required, int *copy_off, int *copy_len, int *last_was_partial_copy, int *bytes_consumed) { int still_to_copy; still_to_copy = space_required - *bytes_consumed; *copy_off = *bytes_consumed; if (still_to_copy <= space_available) { /* write of region completes here */ *copy_len = still_to_copy; ophdr->oh_len = cpu_to_be32(*copy_len); if (*last_was_partial_copy) ophdr->oh_flags |= (XLOG_END_TRANS|XLOG_WAS_CONT_TRANS); *last_was_partial_copy = 0; *bytes_consumed = 0; return 0; } /* partial write of region, needs extra log op header reservation */ *copy_len = space_available; ophdr->oh_len = cpu_to_be32(*copy_len); ophdr->oh_flags |= XLOG_CONTINUE_TRANS; if (*last_was_partial_copy) ophdr->oh_flags |= XLOG_WAS_CONT_TRANS; *bytes_consumed += *copy_len; (*last_was_partial_copy)++; /* account for new log op header */ ticket->t_curr_res -= sizeof(struct xlog_op_header); ticket->t_res_num_ophdrs++; return sizeof(struct xlog_op_header); } static int xlog_write_copy_finish( struct log *log, struct xlog_in_core *iclog, uint flags, int *record_cnt, int *data_cnt, int *partial_copy, int *partial_copy_len, int log_offset, struct xlog_in_core **commit_iclog) { if (*partial_copy) { /* * This iclog has already been marked WANT_SYNC by * xlog_state_get_iclog_space. */ xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt); *record_cnt = 0; *data_cnt = 0; return xlog_state_release_iclog(log, iclog); } *partial_copy = 0; *partial_copy_len = 0; if (iclog->ic_size - log_offset <= sizeof(xlog_op_header_t)) { /* no more space in this iclog - push it. */ xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt); *record_cnt = 0; *data_cnt = 0; spin_lock(&log->l_icloglock); xlog_state_want_sync(log, iclog); spin_unlock(&log->l_icloglock); if (!commit_iclog) return xlog_state_release_iclog(log, iclog); ASSERT(flags & XLOG_COMMIT_TRANS); *commit_iclog = iclog; } return 0; } /* |
1da177e4c Linux-2.6.12-rc2 |
1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 |
* Write some region out to in-core log * * This will be called when writing externally provided regions or when * writing out a commit record for a given transaction. * * General algorithm: * 1. Find total length of this write. This may include adding to the * lengths passed in. * 2. Check whether we violate the tickets reservation. * 3. While writing to this iclog * A. Reserve as much space in this iclog as can get * B. If this is first write, save away start lsn * C. While writing this region: * 1. If first write of transaction, write start record * 2. Write log operation header (header per region) * 3. Find out if we can fit entire region into this iclog * 4. Potentially, verify destination memcpy ptr * 5. Memcpy (partial) region * 6. If partial copy, release iclog; otherwise, continue * copying more regions into current iclog * 4. Mark want sync bit (in simulation mode) * 5. Release iclog for potential flush to on-disk log. * * ERRORS: * 1. Panic if reservation is overrun. This should never happen since * reservation amounts are generated internal to the filesystem. * NOTES: * 1. Tickets are single threaded data structures. * 2. The XLOG_END_TRANS & XLOG_CONTINUE_TRANS flags are passed down to the * syncing routine. When a single log_write region needs to span * multiple in-core logs, the XLOG_CONTINUE_TRANS bit should be set * on all log operation writes which don't contain the end of the * region. The XLOG_END_TRANS bit is used for the in-core log * operation which contains the end of the continued log_write region. * 3. When xlog_state_get_iclog_space() grabs the rest of the current iclog, * we don't really know exactly how much space will be used. As a result, * we don't update ic_offset until the end when we know exactly how many * bytes have been written out. */ |
71e330b59 xfs: Introduce de... |
1878 |
int |
35a8a72f0 xfs: stop passing... |
1879 |
xlog_write( |
55b66332d xfs: introduce ne... |
1880 1881 |
struct log *log, struct xfs_log_vec *log_vector, |
35a8a72f0 xfs: stop passing... |
1882 1883 1884 1885 |
struct xlog_ticket *ticket, xfs_lsn_t *start_lsn, struct xlog_in_core **commit_iclog, uint flags) |
1da177e4c Linux-2.6.12-rc2 |
1886 |
{ |
99428ad0f xfs: reindent xlo... |
1887 |
struct xlog_in_core *iclog = NULL; |
55b66332d xfs: introduce ne... |
1888 1889 |
struct xfs_log_iovec *vecp; struct xfs_log_vec *lv; |
99428ad0f xfs: reindent xlo... |
1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 |
int len; int index; int partial_copy = 0; int partial_copy_len = 0; int contwr = 0; int record_cnt = 0; int data_cnt = 0; int error; *start_lsn = 0; |
55b66332d xfs: introduce ne... |
1900 |
len = xlog_write_calc_vec_length(ticket, log_vector); |
71e330b59 xfs: Introduce de... |
1901 |
|
93b8a5854 xfs: remove the d... |
1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 |
/* * Region headers and bytes are already accounted for. * We only need to take into account start records and * split regions in this function. */ if (ticket->t_flags & XLOG_TIC_INITED) ticket->t_curr_res -= sizeof(xlog_op_header_t); /* * Commit record headers need to be accounted for. These * come in as separate writes so are easy to detect. */ if (flags & (XLOG_COMMIT_TRANS | XLOG_UNMOUNT_TRANS)) ticket->t_curr_res -= sizeof(xlog_op_header_t); |
71e330b59 xfs: Introduce de... |
1916 1917 |
if (ticket->t_curr_res < 0) |
55b66332d xfs: introduce ne... |
1918 |
xlog_print_tic_res(log->l_mp, ticket); |
1da177e4c Linux-2.6.12-rc2 |
1919 |
|
55b66332d xfs: introduce ne... |
1920 1921 1922 1923 |
index = 0; lv = log_vector; vecp = lv->lv_iovecp; while (lv && index < lv->lv_niovecs) { |
e6b1f2737 xfs: clean up xlo... |
1924 |
void *ptr; |
99428ad0f xfs: reindent xlo... |
1925 |
int log_offset; |
1da177e4c Linux-2.6.12-rc2 |
1926 |
|
99428ad0f xfs: reindent xlo... |
1927 1928 1929 1930 |
error = xlog_state_get_iclog_space(log, len, &iclog, ticket, &contwr, &log_offset); if (error) return error; |
1da177e4c Linux-2.6.12-rc2 |
1931 |
|
99428ad0f xfs: reindent xlo... |
1932 |
ASSERT(log_offset <= iclog->ic_size - 1); |
e6b1f2737 xfs: clean up xlo... |
1933 |
ptr = iclog->ic_datap + log_offset; |
1da177e4c Linux-2.6.12-rc2 |
1934 |
|
99428ad0f xfs: reindent xlo... |
1935 1936 1937 |
/* start_lsn is the first lsn written to. That's all we need. */ if (!*start_lsn) *start_lsn = be64_to_cpu(iclog->ic_header.h_lsn); |
b5203cd0a xfs: factor xlog_... |
1938 |
|
99428ad0f xfs: reindent xlo... |
1939 1940 1941 1942 |
/* * This loop writes out as many regions as can fit in the amount * of space which was allocated by xlog_state_get_iclog_space(). */ |
55b66332d xfs: introduce ne... |
1943 1944 |
while (lv && index < lv->lv_niovecs) { struct xfs_log_iovec *reg = &vecp[index]; |
99428ad0f xfs: reindent xlo... |
1945 1946 1947 1948 |
struct xlog_op_header *ophdr; int start_rec_copy; int copy_len; int copy_off; |
55b66332d xfs: introduce ne... |
1949 |
ASSERT(reg->i_len % sizeof(__int32_t) == 0); |
e6b1f2737 xfs: clean up xlo... |
1950 |
ASSERT((unsigned long)ptr % sizeof(__int32_t) == 0); |
99428ad0f xfs: reindent xlo... |
1951 1952 1953 1954 |
start_rec_copy = xlog_write_start_rec(ptr, ticket); if (start_rec_copy) { record_cnt++; |
e6b1f2737 xfs: clean up xlo... |
1955 |
xlog_write_adv_cnt(&ptr, &len, &log_offset, |
99428ad0f xfs: reindent xlo... |
1956 1957 |
start_rec_copy); } |
b5203cd0a xfs: factor xlog_... |
1958 |
|
99428ad0f xfs: reindent xlo... |
1959 1960 1961 |
ophdr = xlog_write_setup_ophdr(log, ptr, ticket, flags); if (!ophdr) return XFS_ERROR(EIO); |
e6b1f2737 xfs: clean up xlo... |
1962 |
xlog_write_adv_cnt(&ptr, &len, &log_offset, |
99428ad0f xfs: reindent xlo... |
1963 1964 1965 1966 |
sizeof(struct xlog_op_header)); len += xlog_write_setup_copy(ticket, ophdr, iclog->ic_size-log_offset, |
55b66332d xfs: introduce ne... |
1967 |
reg->i_len, |
99428ad0f xfs: reindent xlo... |
1968 1969 1970 1971 1972 1973 1974 |
©_off, ©_len, &partial_copy, &partial_copy_len); xlog_verify_dest_ptr(log, ptr); /* copy region */ ASSERT(copy_len >= 0); |
e6b1f2737 xfs: clean up xlo... |
1975 1976 |
memcpy(ptr, reg->i_addr + copy_off, copy_len); xlog_write_adv_cnt(&ptr, &len, &log_offset, copy_len); |
99428ad0f xfs: reindent xlo... |
1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 |
copy_len += start_rec_copy + sizeof(xlog_op_header_t); record_cnt++; data_cnt += contwr ? copy_len : 0; error = xlog_write_copy_finish(log, iclog, flags, &record_cnt, &data_cnt, &partial_copy, &partial_copy_len, log_offset, commit_iclog); if (error) return error; /* * if we had a partial copy, we need to get more iclog * space but we don't want to increment the region * index because there is still more is this region to * write. * * If we completed writing this region, and we flushed * the iclog (indicated by resetting of the record * count), then we also need to get more log space. If * this was the last record, though, we are done and * can just return. */ if (partial_copy) break; |
55b66332d xfs: introduce ne... |
2005 2006 2007 2008 2009 2010 |
if (++index == lv->lv_niovecs) { lv = lv->lv_next; index = 0; if (lv) vecp = lv->lv_iovecp; } |
99428ad0f xfs: reindent xlo... |
2011 |
if (record_cnt == 0) { |
55b66332d xfs: introduce ne... |
2012 |
if (!lv) |
99428ad0f xfs: reindent xlo... |
2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 |
return 0; break; } } } ASSERT(len == 0); xlog_state_finish_copy(log, iclog, record_cnt, data_cnt); if (!commit_iclog) return xlog_state_release_iclog(log, iclog); |
1da177e4c Linux-2.6.12-rc2 |
2024 |
|
1da177e4c Linux-2.6.12-rc2 |
2025 2026 2027 |
ASSERT(flags & XLOG_COMMIT_TRANS); *commit_iclog = iclog; return 0; |
99428ad0f xfs: reindent xlo... |
2028 |
} |
1da177e4c Linux-2.6.12-rc2 |
2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 |
/***************************************************************************** * * State Machine functions * ***************************************************************************** */ /* Clean iclogs starting from the head. This ordering must be * maintained, so an iclog doesn't become ACTIVE beyond one that * is SYNCING. This is also required to maintain the notion that we use |
12017faf3 [XFS] clean up st... |
2041 |
* a ordered wait queue to hold off would be writers to the log when every |
1da177e4c Linux-2.6.12-rc2 |
2042 2043 2044 2045 |
* iclog is trying to sync to disk. * * State Change: DIRTY -> ACTIVE */ |
ba0f32d46 [XFS] mark variou... |
2046 |
STATIC void |
1da177e4c Linux-2.6.12-rc2 |
2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 |
xlog_state_clean_log(xlog_t *log) { xlog_in_core_t *iclog; int changed = 0; iclog = log->l_iclog; do { if (iclog->ic_state == XLOG_STATE_DIRTY) { iclog->ic_state = XLOG_STATE_ACTIVE; iclog->ic_offset = 0; |
114d23aae [XFS] Per iclog c... |
2057 |
ASSERT(iclog->ic_callback == NULL); |
1da177e4c Linux-2.6.12-rc2 |
2058 2059 2060 2061 2062 2063 2064 2065 2066 |
/* * If the number of ops in this iclog indicate it just * contains the dummy transaction, we can * change state into IDLE (the second time around). * Otherwise we should change the state into * NEED a dummy. * We don't need to cover the dummy. */ if (!changed && |
b53e675dc [XFS] xlog_rec_he... |
2067 2068 |
(be32_to_cpu(iclog->ic_header.h_num_logops) == XLOG_COVER_OPS)) { |
1da177e4c Linux-2.6.12-rc2 |
2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 |
changed = 1; } else { /* * We have two dirty iclogs so start over * This could also be num of ops indicates * this is not the dummy going out. */ changed = 2; } iclog->ic_header.h_num_logops = 0; memset(iclog->ic_header.h_cycle_data, 0, sizeof(iclog->ic_header.h_cycle_data)); iclog->ic_header.h_lsn = 0; } else if (iclog->ic_state == XLOG_STATE_ACTIVE) /* do nothing */; else break; /* stop cleaning */ iclog = iclog->ic_next; } while (iclog != log->l_iclog); /* log is locked when we are called */ /* * Change state for the dummy log recording. * We usually go to NEED. But we go to NEED2 if the changed indicates * we are done writing the dummy record. * If we are done with the second dummy recored (DONE2), then * we go to IDLE. */ if (changed) { switch (log->l_covered_state) { case XLOG_STATE_COVER_IDLE: case XLOG_STATE_COVER_NEED: case XLOG_STATE_COVER_NEED2: log->l_covered_state = XLOG_STATE_COVER_NEED; break; case XLOG_STATE_COVER_DONE: if (changed == 1) log->l_covered_state = XLOG_STATE_COVER_NEED2; else log->l_covered_state = XLOG_STATE_COVER_NEED; break; case XLOG_STATE_COVER_DONE2: if (changed == 1) log->l_covered_state = XLOG_STATE_COVER_IDLE; else log->l_covered_state = XLOG_STATE_COVER_NEED; break; default: ASSERT(0); } } } /* xlog_state_clean_log */ STATIC xfs_lsn_t xlog_get_lowest_lsn( xlog_t *log) { xlog_in_core_t *lsn_log; xfs_lsn_t lowest_lsn, lsn; lsn_log = log->l_iclog; lowest_lsn = 0; do { if (!(lsn_log->ic_state & (XLOG_STATE_ACTIVE|XLOG_STATE_DIRTY))) { |
b53e675dc [XFS] xlog_rec_he... |
2136 |
lsn = be64_to_cpu(lsn_log->ic_header.h_lsn); |
1da177e4c Linux-2.6.12-rc2 |
2137 2138 2139 2140 2141 2142 2143 |
if ((lsn && !lowest_lsn) || (XFS_LSN_CMP(lsn, lowest_lsn) < 0)) { lowest_lsn = lsn; } } lsn_log = lsn_log->ic_next; } while (lsn_log != log->l_iclog); |
014c2544e return statement ... |
2144 |
return lowest_lsn; |
1da177e4c Linux-2.6.12-rc2 |
2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 |
} STATIC void xlog_state_do_callback( xlog_t *log, int aborted, xlog_in_core_t *ciclog) { xlog_in_core_t *iclog; xlog_in_core_t *first_iclog; /* used to know when we've * processed all iclogs once */ xfs_log_callback_t *cb, *cb_next; int flushcnt = 0; xfs_lsn_t lowest_lsn; int ioerrors; /* counter: iclogs with errors */ int loopdidcallbacks; /* flag: inner loop did callbacks*/ int funcdidcallbacks; /* flag: function did callbacks */ int repeats; /* for issuing console warnings if * looping too many times */ |
d748c6236 [XFS] Convert l_f... |
2165 |
int wake = 0; |
1da177e4c Linux-2.6.12-rc2 |
2166 |
|
b22cd72c9 [XFS] Unwrap LOG_... |
2167 |
spin_lock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 |
first_iclog = iclog = log->l_iclog; ioerrors = 0; funcdidcallbacks = 0; repeats = 0; do { /* * Scan all iclogs starting with the one pointed to by the * log. Reset this starting point each time the log is * unlocked (during callbacks). * * Keep looping through iclogs until one full pass is made * without running any callbacks. */ first_iclog = log->l_iclog; iclog = log->l_iclog; loopdidcallbacks = 0; repeats++; do { /* skip all iclogs in the ACTIVE & DIRTY states */ if (iclog->ic_state & (XLOG_STATE_ACTIVE|XLOG_STATE_DIRTY)) { iclog = iclog->ic_next; continue; } /* * Between marking a filesystem SHUTDOWN and stopping * the log, we do flush all iclogs to disk (if there * wasn't a log I/O error). So, we do want things to * go smoothly in case of just a SHUTDOWN w/o a * LOG_IO_ERROR. */ if (!(iclog->ic_state & XLOG_STATE_IOERROR)) { /* * Can only perform callbacks in order. Since * this iclog is not in the DONE_SYNC/ * DO_CALLBACK state, we skip the rest and * just try to clean up. If we set our iclog * to DO_CALLBACK, we will not process it when * we retry since a previous iclog is in the * CALLBACK and the state cannot change since |
b22cd72c9 [XFS] Unwrap LOG_... |
2212 |
* we are holding the l_icloglock. |
1da177e4c Linux-2.6.12-rc2 |
2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 |
*/ if (!(iclog->ic_state & (XLOG_STATE_DONE_SYNC | XLOG_STATE_DO_CALLBACK))) { if (ciclog && (ciclog->ic_state == XLOG_STATE_DONE_SYNC)) { ciclog->ic_state = XLOG_STATE_DO_CALLBACK; } break; } /* * We now have an iclog that is in either the * DO_CALLBACK or DONE_SYNC states. The other * states (WANT_SYNC, SYNCING, or CALLBACK were * caught by the above if and are going to * clean (i.e. we aren't doing their callbacks) * see the above if. */ /* * We will do one more check here to see if we * have chased our tail around. */ lowest_lsn = xlog_get_lowest_lsn(log); |
b53e675dc [XFS] xlog_rec_he... |
2238 2239 |
if (lowest_lsn && XFS_LSN_CMP(lowest_lsn, |
84f3c683c xfs: convert l_la... |
2240 |
be64_to_cpu(iclog->ic_header.h_lsn)) < 0) { |
1da177e4c Linux-2.6.12-rc2 |
2241 2242 2243 2244 2245 2246 |
iclog = iclog->ic_next; continue; /* Leave this iclog for * another thread */ } iclog->ic_state = XLOG_STATE_CALLBACK; |
1da177e4c Linux-2.6.12-rc2 |
2247 |
|
84f3c683c xfs: convert l_la... |
2248 2249 2250 2251 |
/* * update the last_sync_lsn before we drop the * icloglock to ensure we are the only one that * can update it. |
1da177e4c Linux-2.6.12-rc2 |
2252 |
*/ |
84f3c683c xfs: convert l_la... |
2253 2254 2255 2256 |
ASSERT(XFS_LSN_CMP(atomic64_read(&log->l_last_sync_lsn), be64_to_cpu(iclog->ic_header.h_lsn)) <= 0); atomic64_set(&log->l_last_sync_lsn, be64_to_cpu(iclog->ic_header.h_lsn)); |
1da177e4c Linux-2.6.12-rc2 |
2257 |
|
84f3c683c xfs: convert l_la... |
2258 |
} else |
1da177e4c Linux-2.6.12-rc2 |
2259 |
ioerrors++; |
84f3c683c xfs: convert l_la... |
2260 2261 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2262 |
|
114d23aae [XFS] Per iclog c... |
2263 2264 2265 2266 2267 2268 2269 2270 2271 |
/* * Keep processing entries in the callback list until * we come around and it is empty. We need to * atomically see that the list is empty and change the * state to DIRTY so that we don't miss any more * callbacks being added. */ spin_lock(&iclog->ic_callback_lock); cb = iclog->ic_callback; |
4b80916b2 [XFS] Fix sparse ... |
2272 |
while (cb) { |
1da177e4c Linux-2.6.12-rc2 |
2273 2274 |
iclog->ic_callback_tail = &(iclog->ic_callback); iclog->ic_callback = NULL; |
114d23aae [XFS] Per iclog c... |
2275 |
spin_unlock(&iclog->ic_callback_lock); |
1da177e4c Linux-2.6.12-rc2 |
2276 2277 |
/* perform callbacks in the order given */ |
4b80916b2 [XFS] Fix sparse ... |
2278 |
for (; cb; cb = cb_next) { |
1da177e4c Linux-2.6.12-rc2 |
2279 2280 2281 |
cb_next = cb->cb_next; cb->cb_func(cb->cb_arg, aborted); } |
114d23aae [XFS] Per iclog c... |
2282 |
spin_lock(&iclog->ic_callback_lock); |
1da177e4c Linux-2.6.12-rc2 |
2283 2284 2285 2286 2287 |
cb = iclog->ic_callback; } loopdidcallbacks++; funcdidcallbacks++; |
114d23aae [XFS] Per iclog c... |
2288 |
spin_lock(&log->l_icloglock); |
4b80916b2 [XFS] Fix sparse ... |
2289 |
ASSERT(iclog->ic_callback == NULL); |
114d23aae [XFS] Per iclog c... |
2290 |
spin_unlock(&iclog->ic_callback_lock); |
1da177e4c Linux-2.6.12-rc2 |
2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 |
if (!(iclog->ic_state & XLOG_STATE_IOERROR)) iclog->ic_state = XLOG_STATE_DIRTY; /* * Transition from DIRTY to ACTIVE if applicable. * NOP if STATE_IOERROR. */ xlog_state_clean_log(log); /* wake up threads waiting in xfs_log_force() */ |
eb40a8750 xfs: use wait que... |
2301 |
wake_up_all(&iclog->ic_force_wait); |
1da177e4c Linux-2.6.12-rc2 |
2302 2303 2304 |
iclog = iclog->ic_next; } while (first_iclog != iclog); |
a3c6685ea [XFS] Ensure xlog... |
2305 2306 2307 2308 |
if (repeats > 5000) { flushcnt += repeats; repeats = 0; |
a0fa2b679 xfs: Convert xlog... |
2309 |
xfs_warn(log->l_mp, |
a3c6685ea [XFS] Ensure xlog... |
2310 |
"%s: possible infinite loop (%d iterations)", |
34a622b2e [XFS] replace rem... |
2311 |
__func__, flushcnt); |
1da177e4c Linux-2.6.12-rc2 |
2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 |
} } while (!ioerrors && loopdidcallbacks); /* * make one last gasp attempt to see if iclogs are being left in * limbo.. */ #ifdef DEBUG if (funcdidcallbacks) { first_iclog = iclog = log->l_iclog; do { ASSERT(iclog->ic_state != XLOG_STATE_DO_CALLBACK); /* * Terminate the loop if iclogs are found in states * which will cause other threads to clean up iclogs. * * SYNCING - i/o completion will go through logs * DONE_SYNC - interrupt thread should be waiting for |
b22cd72c9 [XFS] Unwrap LOG_... |
2330 |
* l_icloglock |
1da177e4c Linux-2.6.12-rc2 |
2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 |
* IOERROR - give up hope all ye who enter here */ if (iclog->ic_state == XLOG_STATE_WANT_SYNC || iclog->ic_state == XLOG_STATE_SYNCING || iclog->ic_state == XLOG_STATE_DONE_SYNC || iclog->ic_state == XLOG_STATE_IOERROR ) break; iclog = iclog->ic_next; } while (first_iclog != iclog); } #endif |
d748c6236 [XFS] Convert l_f... |
2342 2343 |
if (log->l_iclog->ic_state & (XLOG_STATE_ACTIVE|XLOG_STATE_IOERROR)) wake = 1; |
b22cd72c9 [XFS] Unwrap LOG_... |
2344 |
spin_unlock(&log->l_icloglock); |
d748c6236 [XFS] Convert l_f... |
2345 2346 |
if (wake) |
eb40a8750 xfs: use wait que... |
2347 |
wake_up_all(&log->l_flush_wait); |
d748c6236 [XFS] Convert l_f... |
2348 |
} |
1da177e4c Linux-2.6.12-rc2 |
2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 |
/* * Finish transitioning this iclog to the dirty state. * * Make sure that we completely execute this routine only when this is * the last call to the iclog. There is a good chance that iclog flushes, * when we reach the end of the physical log, get turned into 2 separate * calls to bwrite. Hence, one iclog flush could generate two calls to this * routine. By using the reference count bwritecnt, we guarantee that only * the second completion goes through. * * Callbacks could take time, so they are done outside the scope of the |
12017faf3 [XFS] clean up st... |
2362 |
* global state machine log lock. |
1da177e4c Linux-2.6.12-rc2 |
2363 |
*/ |
a8272ce0c [XFS] Fix up spar... |
2364 |
STATIC void |
1da177e4c Linux-2.6.12-rc2 |
2365 2366 2367 2368 2369 |
xlog_state_done_syncing( xlog_in_core_t *iclog, int aborted) { xlog_t *log = iclog->ic_log; |
1da177e4c Linux-2.6.12-rc2 |
2370 |
|
b22cd72c9 [XFS] Unwrap LOG_... |
2371 |
spin_lock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2372 2373 2374 |
ASSERT(iclog->ic_state == XLOG_STATE_SYNCING || iclog->ic_state == XLOG_STATE_IOERROR); |
155cc6b78 [XFS] Use atomics... |
2375 |
ASSERT(atomic_read(&iclog->ic_refcnt) == 0); |
1da177e4c Linux-2.6.12-rc2 |
2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 |
ASSERT(iclog->ic_bwritecnt == 1 || iclog->ic_bwritecnt == 2); /* * If we got an error, either on the first buffer, or in the case of * split log writes, on the second, we mark ALL iclogs STATE_IOERROR, * and none should ever be attempted to be written to disk * again. */ if (iclog->ic_state != XLOG_STATE_IOERROR) { if (--iclog->ic_bwritecnt == 1) { |
b22cd72c9 [XFS] Unwrap LOG_... |
2387 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 |
return; } iclog->ic_state = XLOG_STATE_DONE_SYNC; } /* * Someone could be sleeping prior to writing out the next * iclog buffer, we wake them all, one will get to do the * I/O, the others get to wait for the result. */ |
eb40a8750 xfs: use wait que... |
2398 |
wake_up_all(&iclog->ic_write_wait); |
b22cd72c9 [XFS] Unwrap LOG_... |
2399 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2400 2401 2402 2403 2404 2405 |
xlog_state_do_callback(log, aborted, iclog); /* also cleans log */ } /* xlog_state_done_syncing */ /* * If the head of the in-core log ring is not (ACTIVE or DIRTY), then we must |
12017faf3 [XFS] clean up st... |
2406 2407 2408 |
* sleep. We wait on the flush queue on the head iclog as that should be * the first iclog to complete flushing. Hence if all iclogs are syncing, * we will wait here and all new writes will sleep until a sync completes. |
1da177e4c Linux-2.6.12-rc2 |
2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 |
* * The in-core logs are used in a circular fashion. They are not used * out-of-order even when an iclog past the head is free. * * return: * * log_offset where xlog_write() can start writing into the in-core * log's data space. * * in-core log pointer to which xlog_write() should write. * * boolean indicating this is a continued write to an in-core log. * If this is the last write, then the in-core log's offset field * needs to be incremented, depending on the amount of data which * is copied. */ |
a8272ce0c [XFS] Fix up spar... |
2422 |
STATIC int |
1da177e4c Linux-2.6.12-rc2 |
2423 2424 2425 2426 2427 2428 2429 |
xlog_state_get_iclog_space(xlog_t *log, int len, xlog_in_core_t **iclogp, xlog_ticket_t *ticket, int *continued_write, int *logoffsetp) { |
1da177e4c Linux-2.6.12-rc2 |
2430 2431 2432 2433 2434 2435 |
int log_offset; xlog_rec_header_t *head; xlog_in_core_t *iclog; int error; restart: |
b22cd72c9 [XFS] Unwrap LOG_... |
2436 |
spin_lock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2437 |
if (XLOG_FORCED_SHUTDOWN(log)) { |
b22cd72c9 [XFS] Unwrap LOG_... |
2438 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2439 2440 2441 2442 |
return XFS_ERROR(EIO); } iclog = log->l_iclog; |
d748c6236 [XFS] Convert l_f... |
2443 |
if (iclog->ic_state != XLOG_STATE_ACTIVE) { |
1da177e4c Linux-2.6.12-rc2 |
2444 |
XFS_STATS_INC(xs_log_noiclogs); |
d748c6236 [XFS] Convert l_f... |
2445 2446 |
/* Wait for log writes to have flushed */ |
eb40a8750 xfs: use wait que... |
2447 |
xlog_wait(&log->l_flush_wait, &log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2448 2449 |
goto restart; } |
d748c6236 [XFS] Convert l_f... |
2450 |
|
1da177e4c Linux-2.6.12-rc2 |
2451 |
head = &iclog->ic_header; |
155cc6b78 [XFS] Use atomics... |
2452 |
atomic_inc(&iclog->ic_refcnt); /* prevents sync */ |
1da177e4c Linux-2.6.12-rc2 |
2453 2454 2455 2456 2457 2458 2459 2460 2461 |
log_offset = iclog->ic_offset; /* On the 1st write to an iclog, figure out lsn. This works * if iclogs marked XLOG_STATE_WANT_SYNC always write out what they are * committing to. If the offset is set, that's how many blocks * must be written. */ if (log_offset == 0) { ticket->t_curr_res -= log->l_iclog_hsize; |
0adba5363 [XFS] replace som... |
2462 |
xlog_tic_add_region(ticket, |
7e9c63961 [XFS] 929956 add ... |
2463 2464 |
log->l_iclog_hsize, XLOG_REG_TYPE_LRHEADER); |
b53e675dc [XFS] xlog_rec_he... |
2465 2466 |
head->h_cycle = cpu_to_be32(log->l_curr_cycle); head->h_lsn = cpu_to_be64( |
03bea6fe6 [XFS] clean up so... |
2467 |
xlog_assign_lsn(log->l_curr_cycle, log->l_curr_block)); |
1da177e4c Linux-2.6.12-rc2 |
2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 |
ASSERT(log->l_curr_block >= 0); } /* If there is enough room to write everything, then do it. Otherwise, * claim the rest of the region and make sure the XLOG_STATE_WANT_SYNC * bit is on, so this will get flushed out. Don't update ic_offset * until you know exactly how many bytes get copied. Therefore, wait * until later to update ic_offset. * * xlog_write() algorithm assumes that at least 2 xlog_op_header_t's * can fit into remaining data section. */ if (iclog->ic_size - iclog->ic_offset < 2*sizeof(xlog_op_header_t)) { xlog_state_switch_iclogs(log, iclog, iclog->ic_size); |
49641f1ac Fix reference cou... |
2482 2483 2484 2485 2486 2487 2488 2489 2490 |
/* * If I'm the only one writing to this iclog, sync it to disk. * We need to do an atomic compare and decrement here to avoid * racing with concurrent atomic_dec_and_lock() calls in * xlog_state_release_iclog() when there is more than one * reference to the iclog. */ if (!atomic_add_unless(&iclog->ic_refcnt, -1, 1)) { /* we are the only one */ |
b22cd72c9 [XFS] Unwrap LOG_... |
2491 |
spin_unlock(&log->l_icloglock); |
49641f1ac Fix reference cou... |
2492 2493 |
error = xlog_state_release_iclog(log, iclog); if (error) |
014c2544e return statement ... |
2494 |
return error; |
1da177e4c Linux-2.6.12-rc2 |
2495 |
} else { |
b22cd72c9 [XFS] Unwrap LOG_... |
2496 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 |
} goto restart; } /* Do we have enough room to write the full amount in the remainder * of this iclog? Or must we continue a write on the next iclog and * mark this iclog as completely taken? In the case where we switch * iclogs (to mark it taken), this particular iclog will release/sync * to disk in xlog_write(). */ if (len <= iclog->ic_size - iclog->ic_offset) { *continued_write = 0; iclog->ic_offset += len; } else { *continued_write = 1; xlog_state_switch_iclogs(log, iclog, iclog->ic_size); } *iclogp = iclog; ASSERT(iclog->ic_offset <= iclog->ic_size); |
b22cd72c9 [XFS] Unwrap LOG_... |
2517 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2518 2519 2520 2521 2522 2523 2524 2525 |
*logoffsetp = log_offset; return 0; } /* xlog_state_get_iclog_space */ /* * Atomically get the log space required for a log ticket. * |
9f9c19ec1 xfs: fix the logs... |
2526 2527 |
* Once a ticket gets put onto the reserveq, it will only return after the * needed reservation is satisfied. |
3f16b9850 xfs: introduce ne... |
2528 2529 2530 2531 2532 2533 2534 |
* * This function is structured so that it has a lock free fast path. This is * necessary because every new transaction reservation will come through this * path. Hence any lock will be globally hot if we take it unconditionally on * every pass. * * As tickets are only ever moved on and off the reserveq under the |
9f9c19ec1 xfs: fix the logs... |
2535 2536 2537 2538 |
* l_grant_reserve_lock, we only need to take that lock if we are going to add * the ticket to the queue and sleep. We can avoid taking the lock if the ticket * was never added to the reserveq because the t_queue list head will be empty * and we hold the only reference to it so it can safely be checked unlocked. |
1da177e4c Linux-2.6.12-rc2 |
2539 2540 |
*/ STATIC int |
9f9c19ec1 xfs: fix the logs... |
2541 2542 2543 |
xlog_grant_log_space( struct log *log, struct xlog_ticket *tic) |
1da177e4c Linux-2.6.12-rc2 |
2544 |
{ |
9f9c19ec1 xfs: fix the logs... |
2545 2546 |
int free_bytes, need_bytes; int error = 0; |
1da177e4c Linux-2.6.12-rc2 |
2547 |
|
9f9c19ec1 xfs: fix the logs... |
2548 |
ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY)); |
1da177e4c Linux-2.6.12-rc2 |
2549 |
|
0b1b213fc xfs: event tracin... |
2550 |
trace_xfs_log_grant_enter(log, tic); |
1da177e4c Linux-2.6.12-rc2 |
2551 |
|
9f9c19ec1 xfs: fix the logs... |
2552 2553 2554 2555 2556 2557 |
/* * If there are other waiters on the queue then give them a chance at * logspace before us. Wake up the first waiters, if we do not wake * up all the waiters then go to sleep waiting for more free space, * otherwise try to get some space for this transaction. */ |
3f16b9850 xfs: introduce ne... |
2558 2559 2560 |
need_bytes = tic->t_unit_res; if (tic->t_flags & XFS_LOG_PERM_RESERV) need_bytes *= tic->t_ocnt; |
a69ed03c2 xfs: combine gran... |
2561 |
free_bytes = xlog_space_left(log, &log->l_grant_reserve_head); |
9f9c19ec1 xfs: fix the logs... |
2562 |
if (!list_empty_careful(&log->l_reserveq)) { |
3f16b9850 xfs: introduce ne... |
2563 |
spin_lock(&log->l_grant_reserve_lock); |
9f9c19ec1 xfs: fix the logs... |
2564 2565 2566 2567 2568 |
if (!xlog_reserveq_wake(log, &free_bytes) || free_bytes < need_bytes) error = xlog_reserveq_wait(log, tic, need_bytes); spin_unlock(&log->l_grant_reserve_lock); } else if (free_bytes < need_bytes) { |
3f16b9850 xfs: introduce ne... |
2569 |
spin_lock(&log->l_grant_reserve_lock); |
9f9c19ec1 xfs: fix the logs... |
2570 |
error = xlog_reserveq_wait(log, tic, need_bytes); |
3f16b9850 xfs: introduce ne... |
2571 2572 |
spin_unlock(&log->l_grant_reserve_lock); } |
9f9c19ec1 xfs: fix the logs... |
2573 2574 |
if (error) return error; |
1da177e4c Linux-2.6.12-rc2 |
2575 |
|
a69ed03c2 xfs: combine gran... |
2576 2577 |
xlog_grant_add_space(log, &log->l_grant_reserve_head, need_bytes); xlog_grant_add_space(log, &log->l_grant_write_head, need_bytes); |
0b1b213fc xfs: event tracin... |
2578 |
trace_xfs_log_grant_exit(log, tic); |
3f336c6fa xfs: fact out com... |
2579 |
xlog_verify_grant_tail(log); |
1da177e4c Linux-2.6.12-rc2 |
2580 |
return 0; |
9f9c19ec1 xfs: fix the logs... |
2581 |
} |
1da177e4c Linux-2.6.12-rc2 |
2582 2583 2584 2585 |
/* * Replenish the byte reservation required by moving the grant write head. * |
3f16b9850 xfs: introduce ne... |
2586 2587 |
* Similar to xlog_grant_log_space, the function is structured to have a lock * free fast path. |
1da177e4c Linux-2.6.12-rc2 |
2588 2589 |
*/ STATIC int |
9f9c19ec1 xfs: fix the logs... |
2590 2591 2592 |
xlog_regrant_write_log_space( struct log *log, struct xlog_ticket *tic) |
1da177e4c Linux-2.6.12-rc2 |
2593 |
{ |
9f9c19ec1 xfs: fix the logs... |
2594 2595 |
int free_bytes, need_bytes; int error = 0; |
1da177e4c Linux-2.6.12-rc2 |
2596 2597 |
tic->t_curr_res = tic->t_unit_res; |
0adba5363 [XFS] replace som... |
2598 |
xlog_tic_reset_res(tic); |
1da177e4c Linux-2.6.12-rc2 |
2599 2600 |
if (tic->t_cnt > 0) |
014c2544e return statement ... |
2601 |
return 0; |
1da177e4c Linux-2.6.12-rc2 |
2602 |
|
9f9c19ec1 xfs: fix the logs... |
2603 |
ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY)); |
1da177e4c Linux-2.6.12-rc2 |
2604 |
|
0b1b213fc xfs: event tracin... |
2605 |
trace_xfs_log_regrant_write_enter(log, tic); |
1da177e4c Linux-2.6.12-rc2 |
2606 |
|
9f9c19ec1 xfs: fix the logs... |
2607 2608 2609 2610 2611 |
/* * If there are other waiters on the queue then give them a chance at * logspace before us. Wake up the first waiters, if we do not wake * up all the waiters then go to sleep waiting for more free space, * otherwise try to get some space for this transaction. |
1da177e4c Linux-2.6.12-rc2 |
2612 |
*/ |
9d7fef74b xfs: inform the x... |
2613 |
need_bytes = tic->t_unit_res; |
a69ed03c2 xfs: combine gran... |
2614 |
free_bytes = xlog_space_left(log, &log->l_grant_write_head); |
9f9c19ec1 xfs: fix the logs... |
2615 |
if (!list_empty_careful(&log->l_writeq)) { |
3f16b9850 xfs: introduce ne... |
2616 |
spin_lock(&log->l_grant_write_lock); |
9f9c19ec1 xfs: fix the logs... |
2617 2618 2619 2620 2621 |
if (!xlog_writeq_wake(log, &free_bytes) || free_bytes < need_bytes) error = xlog_writeq_wait(log, tic, need_bytes); spin_unlock(&log->l_grant_write_lock); } else if (free_bytes < need_bytes) { |
3f16b9850 xfs: introduce ne... |
2622 |
spin_lock(&log->l_grant_write_lock); |
9f9c19ec1 xfs: fix the logs... |
2623 |
error = xlog_writeq_wait(log, tic, need_bytes); |
3f16b9850 xfs: introduce ne... |
2624 2625 |
spin_unlock(&log->l_grant_write_lock); } |
1da177e4c Linux-2.6.12-rc2 |
2626 |
|
9f9c19ec1 xfs: fix the logs... |
2627 2628 |
if (error) return error; |
a69ed03c2 xfs: combine gran... |
2629 |
xlog_grant_add_space(log, &log->l_grant_write_head, need_bytes); |
0b1b213fc xfs: event tracin... |
2630 |
trace_xfs_log_regrant_write_exit(log, tic); |
3f336c6fa xfs: fact out com... |
2631 |
xlog_verify_grant_tail(log); |
014c2544e return statement ... |
2632 |
return 0; |
9f9c19ec1 xfs: fix the logs... |
2633 |
} |
1da177e4c Linux-2.6.12-rc2 |
2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 |
/* The first cnt-1 times through here we don't need to * move the grant write head because the permanent * reservation has reserved cnt times the unit amount. * Release part of current permanent unit reservation and * reset current reservation to be one units worth. Also * move grant reservation head forward. */ STATIC void xlog_regrant_reserve_log_space(xlog_t *log, xlog_ticket_t *ticket) { |
0b1b213fc xfs: event tracin... |
2646 |
trace_xfs_log_regrant_reserve_enter(log, ticket); |
1da177e4c Linux-2.6.12-rc2 |
2647 2648 |
if (ticket->t_cnt > 0) ticket->t_cnt--; |
a69ed03c2 xfs: combine gran... |
2649 2650 2651 2652 |
xlog_grant_sub_space(log, &log->l_grant_reserve_head, ticket->t_curr_res); xlog_grant_sub_space(log, &log->l_grant_write_head, ticket->t_curr_res); |
1da177e4c Linux-2.6.12-rc2 |
2653 |
ticket->t_curr_res = ticket->t_unit_res; |
0adba5363 [XFS] replace som... |
2654 |
xlog_tic_reset_res(ticket); |
0b1b213fc xfs: event tracin... |
2655 2656 |
trace_xfs_log_regrant_reserve_sub(log, ticket); |
1da177e4c Linux-2.6.12-rc2 |
2657 |
/* just return if we still have some of the pre-reserved space */ |
d0eb2f38b xfs: convert gran... |
2658 |
if (ticket->t_cnt > 0) |
1da177e4c Linux-2.6.12-rc2 |
2659 |
return; |
1da177e4c Linux-2.6.12-rc2 |
2660 |
|
a69ed03c2 xfs: combine gran... |
2661 2662 |
xlog_grant_add_space(log, &log->l_grant_reserve_head, ticket->t_unit_res); |
0b1b213fc xfs: event tracin... |
2663 2664 |
trace_xfs_log_regrant_reserve_exit(log, ticket); |
1da177e4c Linux-2.6.12-rc2 |
2665 |
ticket->t_curr_res = ticket->t_unit_res; |
0adba5363 [XFS] replace som... |
2666 |
xlog_tic_reset_res(ticket); |
1da177e4c Linux-2.6.12-rc2 |
2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 |
} /* xlog_regrant_reserve_log_space */ /* * Give back the space left from a reservation. * * All the information we need to make a correct determination of space left * is present. For non-permanent reservations, things are quite easy. The * count should have been decremented to zero. We only need to deal with the * space remaining in the current reservation part of the ticket. If the * ticket contains a permanent reservation, there may be left over space which * needs to be released. A count of N means that N-1 refills of the current * reservation can be done before we need to ask for more space. The first * one goes to fill up the first current reservation. Once we run out of * space, the count will stay at zero and the only space remaining will be * in the current reservation field. */ STATIC void xlog_ungrant_log_space(xlog_t *log, xlog_ticket_t *ticket) { |
663e496a7 xfs: rework log g... |
2688 |
int bytes; |
1da177e4c Linux-2.6.12-rc2 |
2689 2690 |
if (ticket->t_cnt > 0) ticket->t_cnt--; |
0b1b213fc xfs: event tracin... |
2691 |
trace_xfs_log_ungrant_enter(log, ticket); |
0b1b213fc xfs: event tracin... |
2692 |
trace_xfs_log_ungrant_sub(log, ticket); |
1da177e4c Linux-2.6.12-rc2 |
2693 |
|
663e496a7 xfs: rework log g... |
2694 2695 |
/* * If this is a permanent reservation ticket, we may be able to free |
1da177e4c Linux-2.6.12-rc2 |
2696 2697 |
* up more space based on the remaining count. */ |
663e496a7 xfs: rework log g... |
2698 |
bytes = ticket->t_curr_res; |
1da177e4c Linux-2.6.12-rc2 |
2699 2700 |
if (ticket->t_cnt > 0) { ASSERT(ticket->t_flags & XLOG_TIC_PERM_RESERV); |
663e496a7 xfs: rework log g... |
2701 |
bytes += ticket->t_unit_res*ticket->t_cnt; |
1da177e4c Linux-2.6.12-rc2 |
2702 |
} |
a69ed03c2 xfs: combine gran... |
2703 2704 |
xlog_grant_sub_space(log, &log->l_grant_reserve_head, bytes); xlog_grant_sub_space(log, &log->l_grant_write_head, bytes); |
663e496a7 xfs: rework log g... |
2705 |
|
0b1b213fc xfs: event tracin... |
2706 |
trace_xfs_log_ungrant_exit(log, ticket); |
1da177e4c Linux-2.6.12-rc2 |
2707 2708 2709 2710 2711 |
xfs_log_move_tail(log->l_mp, 1); } /* xlog_ungrant_log_space */ /* |
1da177e4c Linux-2.6.12-rc2 |
2712 2713 2714 2715 2716 2717 2718 2719 |
* Flush iclog to disk if this is the last reference to the given iclog and * the WANT_SYNC bit is set. * * When this function is entered, the iclog is not necessarily in the * WANT_SYNC state. It may be sitting around waiting to get filled. * * */ |
a8272ce0c [XFS] Fix up spar... |
2720 |
STATIC int |
b589334c7 [XFS] Prevent AIL... |
2721 2722 2723 |
xlog_state_release_iclog( xlog_t *log, xlog_in_core_t *iclog) |
1da177e4c Linux-2.6.12-rc2 |
2724 |
{ |
1da177e4c Linux-2.6.12-rc2 |
2725 |
int sync = 0; /* do we sync? */ |
155cc6b78 [XFS] Use atomics... |
2726 2727 2728 2729 2730 2731 |
if (iclog->ic_state & XLOG_STATE_IOERROR) return XFS_ERROR(EIO); ASSERT(atomic_read(&iclog->ic_refcnt) > 0); if (!atomic_dec_and_lock(&iclog->ic_refcnt, &log->l_icloglock)) return 0; |
1da177e4c Linux-2.6.12-rc2 |
2732 |
if (iclog->ic_state & XLOG_STATE_IOERROR) { |
b22cd72c9 [XFS] Unwrap LOG_... |
2733 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2734 2735 |
return XFS_ERROR(EIO); } |
1da177e4c Linux-2.6.12-rc2 |
2736 2737 |
ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE || iclog->ic_state == XLOG_STATE_WANT_SYNC); |
155cc6b78 [XFS] Use atomics... |
2738 |
if (iclog->ic_state == XLOG_STATE_WANT_SYNC) { |
b589334c7 [XFS] Prevent AIL... |
2739 |
/* update tail before writing to iclog */ |
1c3cb9ec0 xfs: convert l_ta... |
2740 |
xfs_lsn_t tail_lsn = xlog_assign_tail_lsn(log->l_mp); |
1da177e4c Linux-2.6.12-rc2 |
2741 2742 |
sync++; iclog->ic_state = XLOG_STATE_SYNCING; |
1c3cb9ec0 xfs: convert l_ta... |
2743 2744 |
iclog->ic_header.h_tail_lsn = cpu_to_be64(tail_lsn); xlog_verify_tail_lsn(log, iclog, tail_lsn); |
1da177e4c Linux-2.6.12-rc2 |
2745 2746 |
/* cycle incremented when incrementing curr_block */ } |
b22cd72c9 [XFS] Unwrap LOG_... |
2747 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2748 2749 2750 |
/* * We let the log lock go, so it's possible that we hit a log I/O |
c41564b5a [XFS] We really s... |
2751 |
* error or some other SHUTDOWN condition that marks the iclog |
1da177e4c Linux-2.6.12-rc2 |
2752 2753 2754 2755 |
* as XLOG_STATE_IOERROR before the bwrite. However, we know that * this iclog has consistent data, so we ignore IOERROR * flags after this point. */ |
b589334c7 [XFS] Prevent AIL... |
2756 |
if (sync) |
1da177e4c Linux-2.6.12-rc2 |
2757 |
return xlog_sync(log, iclog); |
014c2544e return statement ... |
2758 |
return 0; |
1da177e4c Linux-2.6.12-rc2 |
2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 |
} /* xlog_state_release_iclog */ /* * This routine will mark the current iclog in the ring as WANT_SYNC * and move the current iclog pointer to the next iclog in the ring. * When this routine is called from xlog_state_get_iclog_space(), the * exact size of the iclog has not yet been determined. All we know is * that every data block. We have run out of space in this log record. */ STATIC void xlog_state_switch_iclogs(xlog_t *log, xlog_in_core_t *iclog, int eventual_size) { ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE); if (!eventual_size) eventual_size = iclog->ic_offset; iclog->ic_state = XLOG_STATE_WANT_SYNC; |
b53e675dc [XFS] xlog_rec_he... |
2778 |
iclog->ic_header.h_prev_block = cpu_to_be32(log->l_prev_block); |
1da177e4c Linux-2.6.12-rc2 |
2779 2780 2781 2782 2783 2784 2785 |
log->l_prev_block = log->l_curr_block; log->l_prev_cycle = log->l_curr_cycle; /* roll log?: ic_offset changed later */ log->l_curr_block += BTOBB(eventual_size)+BTOBB(log->l_iclog_hsize); /* Round up to next log-sunit */ |
621187099 [XFS] remove shou... |
2786 |
if (xfs_sb_version_haslogv2(&log->l_mp->m_sb) && |
1da177e4c Linux-2.6.12-rc2 |
2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 |
log->l_mp->m_sb.sb_logsunit > 1) { __uint32_t sunit_bb = BTOBB(log->l_mp->m_sb.sb_logsunit); log->l_curr_block = roundup(log->l_curr_block, sunit_bb); } if (log->l_curr_block >= log->l_logBBsize) { log->l_curr_cycle++; if (log->l_curr_cycle == XLOG_HEADER_MAGIC_NUM) log->l_curr_cycle++; log->l_curr_block -= log->l_logBBsize; ASSERT(log->l_curr_block >= 0); } ASSERT(iclog == log->l_iclog); log->l_iclog = iclog->ic_next; } /* xlog_state_switch_iclogs */ |
1da177e4c Linux-2.6.12-rc2 |
2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 |
/* * Write out all data in the in-core log as of this exact moment in time. * * Data may be written to the in-core log during this call. However, * we don't guarantee this data will be written out. A change from past * implementation means this routine will *not* write out zero length LRs. * * Basically, we try and perform an intelligent scan of the in-core logs. * If we determine there is no flushable data, we just return. There is no * flushable data if: * * 1. the current iclog is active and has no data; the previous iclog * is in the active or dirty state. * 2. the current iclog is drity, and the previous iclog is in the * active or dirty state. * |
12017faf3 [XFS] clean up st... |
2818 |
* We may sleep if: |
1da177e4c Linux-2.6.12-rc2 |
2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 |
* * 1. the current iclog is not in the active nor dirty state. * 2. the current iclog dirty, and the previous iclog is not in the * active nor dirty state. * 3. the current iclog is active, and there is another thread writing * to this particular iclog. * 4. a) the current iclog is active and has no other writers * b) when we return from flushing out this iclog, it is still * not in the active nor dirty state. */ |
a14a348bf xfs: cleanup up x... |
2829 2830 2831 2832 2833 |
int _xfs_log_force( struct xfs_mount *mp, uint flags, int *log_flushed) |
1da177e4c Linux-2.6.12-rc2 |
2834 |
{ |
a14a348bf xfs: cleanup up x... |
2835 2836 2837 2838 2839 |
struct log *log = mp->m_log; struct xlog_in_core *iclog; xfs_lsn_t lsn; XFS_STATS_INC(xs_log_force); |
1da177e4c Linux-2.6.12-rc2 |
2840 |
|
93b8a5854 xfs: remove the d... |
2841 |
xlog_cil_force(log); |
71e330b59 xfs: Introduce de... |
2842 |
|
b22cd72c9 [XFS] Unwrap LOG_... |
2843 |
spin_lock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2844 2845 2846 |
iclog = log->l_iclog; if (iclog->ic_state & XLOG_STATE_IOERROR) { |
b22cd72c9 [XFS] Unwrap LOG_... |
2847 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 |
return XFS_ERROR(EIO); } /* If the head iclog is not active nor dirty, we just attach * ourselves to the head and go to sleep. */ if (iclog->ic_state == XLOG_STATE_ACTIVE || iclog->ic_state == XLOG_STATE_DIRTY) { /* * If the head is dirty or (active and empty), then * we need to look at the previous iclog. If the previous * iclog is active or dirty we are done. There is nothing * to sync out. Otherwise, we attach ourselves to the * previous iclog and go to sleep. */ if (iclog->ic_state == XLOG_STATE_DIRTY || |
155cc6b78 [XFS] Use atomics... |
2864 2865 |
(atomic_read(&iclog->ic_refcnt) == 0 && iclog->ic_offset == 0)) { |
1da177e4c Linux-2.6.12-rc2 |
2866 2867 2868 2869 2870 2871 2872 |
iclog = iclog->ic_prev; if (iclog->ic_state == XLOG_STATE_ACTIVE || iclog->ic_state == XLOG_STATE_DIRTY) goto no_sleep; else goto maybe_sleep; } else { |
155cc6b78 [XFS] Use atomics... |
2873 |
if (atomic_read(&iclog->ic_refcnt) == 0) { |
1da177e4c Linux-2.6.12-rc2 |
2874 2875 2876 2877 2878 2879 |
/* We are the only one with access to this * iclog. Flush it out now. There should * be a roundoff of zero to show that someone * has already taken care of the roundoff from * the previous sync. */ |
155cc6b78 [XFS] Use atomics... |
2880 |
atomic_inc(&iclog->ic_refcnt); |
b53e675dc [XFS] xlog_rec_he... |
2881 |
lsn = be64_to_cpu(iclog->ic_header.h_lsn); |
1da177e4c Linux-2.6.12-rc2 |
2882 |
xlog_state_switch_iclogs(log, iclog, 0); |
b22cd72c9 [XFS] Unwrap LOG_... |
2883 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2884 2885 2886 |
if (xlog_state_release_iclog(log, iclog)) return XFS_ERROR(EIO); |
a14a348bf xfs: cleanup up x... |
2887 2888 2889 |
if (log_flushed) *log_flushed = 1; |
b22cd72c9 [XFS] Unwrap LOG_... |
2890 |
spin_lock(&log->l_icloglock); |
b53e675dc [XFS] xlog_rec_he... |
2891 |
if (be64_to_cpu(iclog->ic_header.h_lsn) == lsn && |
1da177e4c Linux-2.6.12-rc2 |
2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 |
iclog->ic_state != XLOG_STATE_DIRTY) goto maybe_sleep; else goto no_sleep; } else { /* Someone else is writing to this iclog. * Use its call to flush out the data. However, * the other thread may not force out this LR, * so we mark it WANT_SYNC. */ xlog_state_switch_iclogs(log, iclog, 0); goto maybe_sleep; } } } /* By the time we come around again, the iclog could've been filled * which would give it another lsn. If we have a new lsn, just * return because the relevant data has been flushed. */ maybe_sleep: if (flags & XFS_LOG_SYNC) { /* * We must check if we're shutting down here, before |
b22cd72c9 [XFS] Unwrap LOG_... |
2916 |
* we wait, while we're holding the l_icloglock. |
1da177e4c Linux-2.6.12-rc2 |
2917 2918 2919 2920 |
* Then we check again after waking up, in case our * sleep was disturbed by a bad news. */ if (iclog->ic_state & XLOG_STATE_IOERROR) { |
b22cd72c9 [XFS] Unwrap LOG_... |
2921 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2922 2923 2924 |
return XFS_ERROR(EIO); } XFS_STATS_INC(xs_log_force_sleep); |
eb40a8750 xfs: use wait que... |
2925 |
xlog_wait(&iclog->ic_force_wait, &log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2926 2927 2928 2929 2930 2931 2932 |
/* * No need to grab the log lock here since we're * only deciding whether or not to return EIO * and the memory read should be atomic. */ if (iclog->ic_state & XLOG_STATE_IOERROR) return XFS_ERROR(EIO); |
a14a348bf xfs: cleanup up x... |
2933 2934 |
if (log_flushed) *log_flushed = 1; |
1da177e4c Linux-2.6.12-rc2 |
2935 2936 2937 |
} else { no_sleep: |
b22cd72c9 [XFS] Unwrap LOG_... |
2938 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
2939 2940 |
} return 0; |
a14a348bf xfs: cleanup up x... |
2941 |
} |
1da177e4c Linux-2.6.12-rc2 |
2942 |
|
a14a348bf xfs: cleanup up x... |
2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 |
/* * Wrapper for _xfs_log_force(), to be used when caller doesn't care * about errors or whether the log was flushed or not. This is the normal * interface to use when trying to unpin items or move the log forward. */ void xfs_log_force( xfs_mount_t *mp, uint flags) { int error; error = _xfs_log_force(mp, flags, NULL); |
a0fa2b679 xfs: Convert xlog... |
2956 2957 |
if (error) xfs_warn(mp, "%s: error %d returned.", __func__, error); |
a14a348bf xfs: cleanup up x... |
2958 |
} |
1da177e4c Linux-2.6.12-rc2 |
2959 2960 |
/* |
a14a348bf xfs: cleanup up x... |
2961 |
* Force the in-core log to disk for a specific LSN. |
1da177e4c Linux-2.6.12-rc2 |
2962 2963 2964 2965 2966 2967 2968 |
* * Find in-core log with lsn. * If it is in the DIRTY state, just return. * If it is in the ACTIVE state, move the in-core log into the WANT_SYNC * state and go to sleep or return. * If it is in any other state, go to sleep or return. * |
a14a348bf xfs: cleanup up x... |
2969 2970 2971 2972 2973 |
* Synchronous forces are implemented with a signal variable. All callers * to force a given lsn to disk will wait on a the sv attached to the * specific in-core log. When given in-core log finally completes its * write to disk, that thread will wake up all threads waiting on the * sv. |
1da177e4c Linux-2.6.12-rc2 |
2974 |
*/ |
a14a348bf xfs: cleanup up x... |
2975 2976 2977 2978 2979 2980 |
int _xfs_log_force_lsn( struct xfs_mount *mp, xfs_lsn_t lsn, uint flags, int *log_flushed) |
1da177e4c Linux-2.6.12-rc2 |
2981 |
{ |
a14a348bf xfs: cleanup up x... |
2982 2983 2984 |
struct log *log = mp->m_log; struct xlog_in_core *iclog; int already_slept = 0; |
1da177e4c Linux-2.6.12-rc2 |
2985 |
|
a14a348bf xfs: cleanup up x... |
2986 |
ASSERT(lsn != 0); |
1da177e4c Linux-2.6.12-rc2 |
2987 |
|
a14a348bf xfs: cleanup up x... |
2988 |
XFS_STATS_INC(xs_log_force); |
1da177e4c Linux-2.6.12-rc2 |
2989 |
|
93b8a5854 xfs: remove the d... |
2990 2991 2992 |
lsn = xlog_cil_force_lsn(log, lsn); if (lsn == NULLCOMMITLSN) return 0; |
71e330b59 xfs: Introduce de... |
2993 |
|
a14a348bf xfs: cleanup up x... |
2994 2995 2996 2997 |
try_again: spin_lock(&log->l_icloglock); iclog = log->l_iclog; if (iclog->ic_state & XLOG_STATE_IOERROR) { |
b22cd72c9 [XFS] Unwrap LOG_... |
2998 |
spin_unlock(&log->l_icloglock); |
a14a348bf xfs: cleanup up x... |
2999 |
return XFS_ERROR(EIO); |
1da177e4c Linux-2.6.12-rc2 |
3000 |
} |
a14a348bf xfs: cleanup up x... |
3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 |
do { if (be64_to_cpu(iclog->ic_header.h_lsn) != lsn) { iclog = iclog->ic_next; continue; } if (iclog->ic_state == XLOG_STATE_DIRTY) { spin_unlock(&log->l_icloglock); return 0; } if (iclog->ic_state == XLOG_STATE_ACTIVE) { /* * We sleep here if we haven't already slept (e.g. * this is the first time we've looked at the correct * iclog buf) and the buffer before us is going to * be sync'ed. The reason for this is that if we * are doing sync transactions here, by waiting for * the previous I/O to complete, we can allow a few * more transactions into this iclog before we close * it down. * * Otherwise, we mark the buffer WANT_SYNC, and bump * up the refcnt so we can release the log (which * drops the ref count). The state switch keeps new * transaction commits from using this buffer. When * the current commits finish writing into the buffer, * the refcount will drop to zero and the buffer will * go out then. */ if (!already_slept && (iclog->ic_prev->ic_state & (XLOG_STATE_WANT_SYNC | XLOG_STATE_SYNCING))) { ASSERT(!(iclog->ic_state & XLOG_STATE_IOERROR)); XFS_STATS_INC(xs_log_force_sleep); |
eb40a8750 xfs: use wait que... |
3037 3038 |
xlog_wait(&iclog->ic_prev->ic_write_wait, &log->l_icloglock); |
a14a348bf xfs: cleanup up x... |
3039 3040 3041 3042 3043 |
if (log_flushed) *log_flushed = 1; already_slept = 1; goto try_again; } |
155cc6b78 [XFS] Use atomics... |
3044 |
atomic_inc(&iclog->ic_refcnt); |
1da177e4c Linux-2.6.12-rc2 |
3045 |
xlog_state_switch_iclogs(log, iclog, 0); |
b22cd72c9 [XFS] Unwrap LOG_... |
3046 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
3047 3048 |
if (xlog_state_release_iclog(log, iclog)) return XFS_ERROR(EIO); |
a14a348bf xfs: cleanup up x... |
3049 3050 |
if (log_flushed) *log_flushed = 1; |
b22cd72c9 [XFS] Unwrap LOG_... |
3051 |
spin_lock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
3052 |
} |
1da177e4c Linux-2.6.12-rc2 |
3053 |
|
a14a348bf xfs: cleanup up x... |
3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 |
if ((flags & XFS_LOG_SYNC) && /* sleep */ !(iclog->ic_state & (XLOG_STATE_ACTIVE | XLOG_STATE_DIRTY))) { /* * Don't wait on completion if we know that we've * gotten a log write error. */ if (iclog->ic_state & XLOG_STATE_IOERROR) { spin_unlock(&log->l_icloglock); return XFS_ERROR(EIO); } XFS_STATS_INC(xs_log_force_sleep); |
eb40a8750 xfs: use wait que... |
3066 |
xlog_wait(&iclog->ic_force_wait, &log->l_icloglock); |
a14a348bf xfs: cleanup up x... |
3067 3068 3069 3070 3071 3072 3073 |
/* * No need to grab the log lock here since we're * only deciding whether or not to return EIO * and the memory read should be atomic. */ if (iclog->ic_state & XLOG_STATE_IOERROR) return XFS_ERROR(EIO); |
1da177e4c Linux-2.6.12-rc2 |
3074 |
|
a14a348bf xfs: cleanup up x... |
3075 3076 3077 |
if (log_flushed) *log_flushed = 1; } else { /* just return */ |
b22cd72c9 [XFS] Unwrap LOG_... |
3078 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
3079 |
} |
1da177e4c Linux-2.6.12-rc2 |
3080 |
|
a14a348bf xfs: cleanup up x... |
3081 3082 |
return 0; } while (iclog != log->l_iclog); |
1da177e4c Linux-2.6.12-rc2 |
3083 |
|
a14a348bf xfs: cleanup up x... |
3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 |
spin_unlock(&log->l_icloglock); return 0; } /* * Wrapper for _xfs_log_force_lsn(), to be used when caller doesn't care * about errors or whether the log was flushed or not. This is the normal * interface to use when trying to unpin items or move the log forward. */ void xfs_log_force_lsn( xfs_mount_t *mp, xfs_lsn_t lsn, uint flags) { int error; |
1da177e4c Linux-2.6.12-rc2 |
3100 |
|
a14a348bf xfs: cleanup up x... |
3101 |
error = _xfs_log_force_lsn(mp, lsn, flags, NULL); |
a0fa2b679 xfs: Convert xlog... |
3102 3103 |
if (error) xfs_warn(mp, "%s: error %d returned.", __func__, error); |
a14a348bf xfs: cleanup up x... |
3104 |
} |
1da177e4c Linux-2.6.12-rc2 |
3105 3106 3107 3108 3109 |
/* * Called when we want to mark the current iclog as being ready to sync to * disk. */ |
a8272ce0c [XFS] Fix up spar... |
3110 |
STATIC void |
1da177e4c Linux-2.6.12-rc2 |
3111 3112 |
xlog_state_want_sync(xlog_t *log, xlog_in_core_t *iclog) { |
a8914f3a6 xfs: fix spin_is_... |
3113 |
assert_spin_locked(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
3114 3115 3116 3117 3118 3119 3120 |
if (iclog->ic_state == XLOG_STATE_ACTIVE) { xlog_state_switch_iclogs(log, iclog, 0); } else { ASSERT(iclog->ic_state & (XLOG_STATE_WANT_SYNC|XLOG_STATE_IOERROR)); } |
39e2defe7 reduce l_iclogloc... |
3121 |
} |
1da177e4c Linux-2.6.12-rc2 |
3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 |
/***************************************************************************** * * TICKET functions * ***************************************************************************** */ /* |
9da096fd1 xfs: fix various ... |
3132 |
* Free a used ticket when its refcount falls to zero. |
1da177e4c Linux-2.6.12-rc2 |
3133 |
*/ |
cc09c0dc5 [XFS] Fix double ... |
3134 3135 3136 |
void xfs_log_ticket_put( xlog_ticket_t *ticket) |
1da177e4c Linux-2.6.12-rc2 |
3137 |
{ |
cc09c0dc5 [XFS] Fix double ... |
3138 |
ASSERT(atomic_read(&ticket->t_ref) > 0); |
eb40a8750 xfs: use wait que... |
3139 |
if (atomic_dec_and_test(&ticket->t_ref)) |
cc09c0dc5 [XFS] Fix double ... |
3140 |
kmem_zone_free(xfs_log_ticket_zone, ticket); |
cc09c0dc5 [XFS] Fix double ... |
3141 |
} |
1da177e4c Linux-2.6.12-rc2 |
3142 |
|
cc09c0dc5 [XFS] Fix double ... |
3143 3144 3145 3146 3147 3148 3149 3150 |
xlog_ticket_t * xfs_log_ticket_get( xlog_ticket_t *ticket) { ASSERT(atomic_read(&ticket->t_ref) > 0); atomic_inc(&ticket->t_ref); return ticket; } |
1da177e4c Linux-2.6.12-rc2 |
3151 3152 |
/* |
eb01c9cd8 [XFS] Remove the ... |
3153 |
* Allocate and initialise a new log ticket. |
1da177e4c Linux-2.6.12-rc2 |
3154 |
*/ |
71e330b59 xfs: Introduce de... |
3155 |
xlog_ticket_t * |
9b9fc2b76 xfs: log ticket r... |
3156 3157 3158 3159 3160 |
xlog_ticket_alloc( struct log *log, int unit_bytes, int cnt, char client, |
3383ca578 xfs: allow log ti... |
3161 3162 |
uint xflags, int alloc_flags) |
1da177e4c Linux-2.6.12-rc2 |
3163 |
{ |
9b9fc2b76 xfs: log ticket r... |
3164 |
struct xlog_ticket *tic; |
1da177e4c Linux-2.6.12-rc2 |
3165 |
uint num_headers; |
9b9fc2b76 xfs: log ticket r... |
3166 |
int iclog_space; |
1da177e4c Linux-2.6.12-rc2 |
3167 |
|
3383ca578 xfs: allow log ti... |
3168 |
tic = kmem_zone_zalloc(xfs_log_ticket_zone, alloc_flags); |
eb01c9cd8 [XFS] Remove the ... |
3169 3170 |
if (!tic) return NULL; |
1da177e4c Linux-2.6.12-rc2 |
3171 3172 3173 3174 3175 3176 3177 3178 |
/* * Permanent reservations have up to 'cnt'-1 active log operations * in the log. A unit in this case is the amount of space for one * of these log operations. Normal reservations have a cnt of 1 * and their unit amount is the total amount of space required. * * The following lines of code account for non-transaction data |
32fb9b57a [XFS] Fix up the ... |
3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 |
* which occupy space in the on-disk log. * * Normal form of a transaction is: * <oph><trans-hdr><start-oph><reg1-oph><reg1><reg2-oph>...<commit-oph> * and then there are LR hdrs, split-recs and roundoff at end of syncs. * * We need to account for all the leadup data and trailer data * around the transaction data. * And then we need to account for the worst case in terms of using * more space. * The worst case will happen if: * - the placement of the transaction happens to be such that the * roundoff is at its maximum * - the transaction data is synced before the commit record is synced * i.e. <transaction-data><roundoff> | <commit-rec><roundoff> * Therefore the commit record is in its own Log Record. * This can happen as the commit record is called with its * own region to xlog_write(). * This then means that in the worst case, roundoff can happen for * the commit-rec as well. * The commit-rec is smaller than padding in this scenario and so it is * not added separately. |
1da177e4c Linux-2.6.12-rc2 |
3201 |
*/ |
32fb9b57a [XFS] Fix up the ... |
3202 3203 3204 |
/* for trans header */ unit_bytes += sizeof(xlog_op_header_t); unit_bytes += sizeof(xfs_trans_header_t); |
1da177e4c Linux-2.6.12-rc2 |
3205 |
/* for start-rec */ |
32fb9b57a [XFS] Fix up the ... |
3206 |
unit_bytes += sizeof(xlog_op_header_t); |
9b9fc2b76 xfs: log ticket r... |
3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 |
/* * for LR headers - the space for data in an iclog is the size minus * the space used for the headers. If we use the iclog size, then we * undercalculate the number of headers required. * * Furthermore - the addition of op headers for split-recs might * increase the space required enough to require more log and op * headers, so take that into account too. * * IMPORTANT: This reservation makes the assumption that if this * transaction is the first in an iclog and hence has the LR headers * accounted to it, then the remaining space in the iclog is * exclusively for this transaction. i.e. if the transaction is larger * than the iclog, it will be the only thing in that iclog. * Fundamentally, this means we must pass the entire log vector to * xlog_write to guarantee this. */ iclog_space = log->l_iclog_size - log->l_iclog_hsize; num_headers = howmany(unit_bytes, iclog_space); /* for split-recs - ophdrs added when data split over LRs */ unit_bytes += sizeof(xlog_op_header_t) * num_headers; /* add extra header reservations if we overrun */ while (!num_headers || howmany(unit_bytes, iclog_space) > num_headers) { unit_bytes += sizeof(xlog_op_header_t); num_headers++; } |
32fb9b57a [XFS] Fix up the ... |
3236 |
unit_bytes += log->l_iclog_hsize * num_headers; |
1da177e4c Linux-2.6.12-rc2 |
3237 |
|
32fb9b57a [XFS] Fix up the ... |
3238 3239 |
/* for commit-rec LR header - note: padding will subsume the ophdr */ unit_bytes += log->l_iclog_hsize; |
32fb9b57a [XFS] Fix up the ... |
3240 |
/* for roundoff padding for transaction data and one for commit record */ |
621187099 [XFS] remove shou... |
3241 |
if (xfs_sb_version_haslogv2(&log->l_mp->m_sb) && |
32fb9b57a [XFS] Fix up the ... |
3242 |
log->l_mp->m_sb.sb_logsunit > 1) { |
1da177e4c Linux-2.6.12-rc2 |
3243 |
/* log su roundoff */ |
32fb9b57a [XFS] Fix up the ... |
3244 |
unit_bytes += 2*log->l_mp->m_sb.sb_logsunit; |
1da177e4c Linux-2.6.12-rc2 |
3245 3246 |
} else { /* BB roundoff */ |
32fb9b57a [XFS] Fix up the ... |
3247 |
unit_bytes += 2*BBSIZE; |
1da177e4c Linux-2.6.12-rc2 |
3248 |
} |
cc09c0dc5 [XFS] Fix double ... |
3249 |
atomic_set(&tic->t_ref, 1); |
105479419 xfs: convert log ... |
3250 |
INIT_LIST_HEAD(&tic->t_queue); |
1da177e4c Linux-2.6.12-rc2 |
3251 3252 3253 3254 |
tic->t_unit_res = unit_bytes; tic->t_curr_res = unit_bytes; tic->t_cnt = cnt; tic->t_ocnt = cnt; |
f98371075 xfs: make the log... |
3255 |
tic->t_tid = random32(); |
1da177e4c Linux-2.6.12-rc2 |
3256 3257 |
tic->t_clientid = client; tic->t_flags = XLOG_TIC_INITED; |
7e9c63961 [XFS] 929956 add ... |
3258 |
tic->t_trans_type = 0; |
1da177e4c Linux-2.6.12-rc2 |
3259 3260 |
if (xflags & XFS_LOG_PERM_RESERV) tic->t_flags |= XLOG_TIC_PERM_RESERV; |
eb40a8750 xfs: use wait que... |
3261 |
init_waitqueue_head(&tic->t_wait); |
1da177e4c Linux-2.6.12-rc2 |
3262 |
|
0adba5363 [XFS] replace som... |
3263 |
xlog_tic_reset_res(tic); |
7e9c63961 [XFS] 929956 add ... |
3264 |
|
1da177e4c Linux-2.6.12-rc2 |
3265 |
return tic; |
cc09c0dc5 [XFS] Fix double ... |
3266 |
} |
1da177e4c Linux-2.6.12-rc2 |
3267 3268 3269 3270 3271 3272 3273 3274 |
/****************************************************************************** * * Log debug routines * ****************************************************************************** */ |
cfcbbbd08 [XFS] Remove old,... |
3275 |
#if defined(DEBUG) |
1da177e4c Linux-2.6.12-rc2 |
3276 3277 3278 3279 3280 3281 |
/* * Make sure that the destination ptr is within the valid data region of * one of the iclogs. This uses backup pointers stored in a different * part of the log in case we trash the log structure. */ void |
e6b1f2737 xfs: clean up xlo... |
3282 3283 3284 |
xlog_verify_dest_ptr( struct log *log, char *ptr) |
1da177e4c Linux-2.6.12-rc2 |
3285 3286 3287 |
{ int i; int good_ptr = 0; |
e6b1f2737 xfs: clean up xlo... |
3288 3289 3290 |
for (i = 0; i < log->l_iclog_bufs; i++) { if (ptr >= log->l_iclog_bak[i] && ptr <= log->l_iclog_bak[i] + log->l_iclog_size) |
1da177e4c Linux-2.6.12-rc2 |
3291 3292 |
good_ptr++; } |
e6b1f2737 xfs: clean up xlo... |
3293 3294 |
if (!good_ptr) |
a0fa2b679 xfs: Convert xlog... |
3295 |
xfs_emerg(log->l_mp, "%s: invalid ptr", __func__); |
e6b1f2737 xfs: clean up xlo... |
3296 |
} |
1da177e4c Linux-2.6.12-rc2 |
3297 |
|
da8a1a4a4 xfs: convert log ... |
3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 |
/* * Check to make sure the grant write head didn't just over lap the tail. If * the cycles are the same, we can't be overlapping. Otherwise, make sure that * the cycles differ by exactly one and check the byte count. * * This check is run unlocked, so can give false positives. Rather than assert * on failures, use a warn-once flag and a panic tag to allow the admin to * determine if they want to panic the machine when such an error occurs. For * debug kernels this will have the same effect as using an assert but, unlinke * an assert, it can be turned off at runtime. */ |
1da177e4c Linux-2.6.12-rc2 |
3309 |
STATIC void |
3f336c6fa xfs: fact out com... |
3310 3311 3312 |
xlog_verify_grant_tail( struct log *log) { |
1c3cb9ec0 xfs: convert l_ta... |
3313 |
int tail_cycle, tail_blocks; |
a69ed03c2 xfs: combine gran... |
3314 |
int cycle, space; |
3f336c6fa xfs: fact out com... |
3315 |
|
a69ed03c2 xfs: combine gran... |
3316 |
xlog_crack_grant_head(&log->l_grant_write_head, &cycle, &space); |
1c3cb9ec0 xfs: convert l_ta... |
3317 3318 |
xlog_crack_atomic_lsn(&log->l_tail_lsn, &tail_cycle, &tail_blocks); if (tail_cycle != cycle) { |
da8a1a4a4 xfs: convert log ... |
3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 |
if (cycle - 1 != tail_cycle && !(log->l_flags & XLOG_TAIL_WARN)) { xfs_alert_tag(log->l_mp, XFS_PTAG_LOGRES, "%s: cycle - 1 != tail_cycle", __func__); log->l_flags |= XLOG_TAIL_WARN; } if (space > BBTOB(tail_blocks) && !(log->l_flags & XLOG_TAIL_WARN)) { xfs_alert_tag(log->l_mp, XFS_PTAG_LOGRES, "%s: space > BBTOB(tail_blocks)", __func__); log->l_flags |= XLOG_TAIL_WARN; } |
3f336c6fa xfs: fact out com... |
3332 3333 |
} } |
1da177e4c Linux-2.6.12-rc2 |
3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 |
/* check if it will fit */ STATIC void xlog_verify_tail_lsn(xlog_t *log, xlog_in_core_t *iclog, xfs_lsn_t tail_lsn) { int blocks; if (CYCLE_LSN(tail_lsn) == log->l_prev_cycle) { blocks = log->l_logBBsize - (log->l_prev_block - BLOCK_LSN(tail_lsn)); if (blocks < BTOBB(iclog->ic_offset)+BTOBB(log->l_iclog_hsize)) |
a0fa2b679 xfs: Convert xlog... |
3346 |
xfs_emerg(log->l_mp, "%s: ran out of log space", __func__); |
1da177e4c Linux-2.6.12-rc2 |
3347 3348 3349 3350 |
} else { ASSERT(CYCLE_LSN(tail_lsn)+1 == log->l_prev_cycle); if (BLOCK_LSN(tail_lsn) == log->l_prev_block) |
a0fa2b679 xfs: Convert xlog... |
3351 |
xfs_emerg(log->l_mp, "%s: tail wrapped", __func__); |
1da177e4c Linux-2.6.12-rc2 |
3352 3353 3354 |
blocks = BLOCK_LSN(tail_lsn) - log->l_prev_block; if (blocks < BTOBB(iclog->ic_offset) + 1) |
a0fa2b679 xfs: Convert xlog... |
3355 |
xfs_emerg(log->l_mp, "%s: ran out of log space", __func__); |
1da177e4c Linux-2.6.12-rc2 |
3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 |
} } /* xlog_verify_tail_lsn */ /* * Perform a number of checks on the iclog before writing to disk. * * 1. Make sure the iclogs are still circular * 2. Make sure we have a good magic number * 3. Make sure we don't have magic numbers in the data * 4. Check fields of each log operation header for: * A. Valid client identifier * B. tid ptr value falls in valid ptr space (user space code) * C. Length in log record header is correct according to the * individual operation headers within record. * 5. When a bwrite will occur within 5 blocks of the front of the physical * log, check the preceding blocks of the physical log to make sure all * the cycle numbers agree with the current cycle number. */ STATIC void xlog_verify_iclog(xlog_t *log, xlog_in_core_t *iclog, int count, boolean_t syncing) { xlog_op_header_t *ophead; xlog_in_core_t *icptr; xlog_in_core_2_t *xhdr; xfs_caddr_t ptr; xfs_caddr_t base_ptr; __psint_t field_offset; __uint8_t clientid; int len, i, j, k, op_len; int idx; |
1da177e4c Linux-2.6.12-rc2 |
3389 3390 |
/* check validity of iclog pointers */ |
b22cd72c9 [XFS] Unwrap LOG_... |
3391 |
spin_lock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
3392 3393 |
icptr = log->l_iclog; for (i=0; i < log->l_iclog_bufs; i++) { |
4b80916b2 [XFS] Fix sparse ... |
3394 |
if (icptr == NULL) |
a0fa2b679 xfs: Convert xlog... |
3395 |
xfs_emerg(log->l_mp, "%s: invalid ptr", __func__); |
1da177e4c Linux-2.6.12-rc2 |
3396 3397 3398 |
icptr = icptr->ic_next; } if (icptr != log->l_iclog) |
a0fa2b679 xfs: Convert xlog... |
3399 |
xfs_emerg(log->l_mp, "%s: corrupt iclog ring", __func__); |
b22cd72c9 [XFS] Unwrap LOG_... |
3400 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
3401 3402 |
/* check log magic numbers */ |
69ef921b5 xfs: byteswap con... |
3403 |
if (iclog->ic_header.h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) |
a0fa2b679 xfs: Convert xlog... |
3404 |
xfs_emerg(log->l_mp, "%s: invalid magic num", __func__); |
1da177e4c Linux-2.6.12-rc2 |
3405 |
|
b53e675dc [XFS] xlog_rec_he... |
3406 3407 |
ptr = (xfs_caddr_t) &iclog->ic_header; for (ptr += BBSIZE; ptr < ((xfs_caddr_t)&iclog->ic_header) + count; |
1da177e4c Linux-2.6.12-rc2 |
3408 |
ptr += BBSIZE) { |
69ef921b5 xfs: byteswap con... |
3409 |
if (*(__be32 *)ptr == cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) |
a0fa2b679 xfs: Convert xlog... |
3410 3411 |
xfs_emerg(log->l_mp, "%s: unexpected magic num", __func__); |
1da177e4c Linux-2.6.12-rc2 |
3412 3413 3414 |
} /* check fields */ |
b53e675dc [XFS] xlog_rec_he... |
3415 |
len = be32_to_cpu(iclog->ic_header.h_num_logops); |
1da177e4c Linux-2.6.12-rc2 |
3416 3417 3418 |
ptr = iclog->ic_datap; base_ptr = ptr; ophead = (xlog_op_header_t *)ptr; |
b28708d6a [XFS] sanitize xl... |
3419 |
xhdr = iclog->ic_data; |
1da177e4c Linux-2.6.12-rc2 |
3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 |
for (i = 0; i < len; i++) { ophead = (xlog_op_header_t *)ptr; /* clientid is only 1 byte */ field_offset = (__psint_t) ((xfs_caddr_t)&(ophead->oh_clientid) - base_ptr); if (syncing == B_FALSE || (field_offset & 0x1ff)) { clientid = ophead->oh_clientid; } else { idx = BTOBBT((xfs_caddr_t)&(ophead->oh_clientid) - iclog->ic_datap); if (idx >= (XLOG_HEADER_CYCLE_SIZE / BBSIZE)) { j = idx / (XLOG_HEADER_CYCLE_SIZE / BBSIZE); k = idx % (XLOG_HEADER_CYCLE_SIZE / BBSIZE); |
03bea6fe6 [XFS] clean up so... |
3433 3434 |
clientid = xlog_get_client_id( xhdr[j].hic_xheader.xh_cycle_data[k]); |
1da177e4c Linux-2.6.12-rc2 |
3435 |
} else { |
03bea6fe6 [XFS] clean up so... |
3436 3437 |
clientid = xlog_get_client_id( iclog->ic_header.h_cycle_data[idx]); |
1da177e4c Linux-2.6.12-rc2 |
3438 3439 3440 |
} } if (clientid != XFS_TRANSACTION && clientid != XFS_LOG) |
a0fa2b679 xfs: Convert xlog... |
3441 3442 3443 3444 |
xfs_warn(log->l_mp, "%s: invalid clientid %d op 0x%p offset 0x%lx", __func__, clientid, ophead, (unsigned long)field_offset); |
1da177e4c Linux-2.6.12-rc2 |
3445 3446 3447 3448 3449 |
/* check length */ field_offset = (__psint_t) ((xfs_caddr_t)&(ophead->oh_len) - base_ptr); if (syncing == B_FALSE || (field_offset & 0x1ff)) { |
67fcb7bfb [XFS] clean up so... |
3450 |
op_len = be32_to_cpu(ophead->oh_len); |
1da177e4c Linux-2.6.12-rc2 |
3451 3452 3453 3454 3455 3456 |
} else { idx = BTOBBT((__psint_t)&ophead->oh_len - (__psint_t)iclog->ic_datap); if (idx >= (XLOG_HEADER_CYCLE_SIZE / BBSIZE)) { j = idx / (XLOG_HEADER_CYCLE_SIZE / BBSIZE); k = idx % (XLOG_HEADER_CYCLE_SIZE / BBSIZE); |
b53e675dc [XFS] xlog_rec_he... |
3457 |
op_len = be32_to_cpu(xhdr[j].hic_xheader.xh_cycle_data[k]); |
1da177e4c Linux-2.6.12-rc2 |
3458 |
} else { |
b53e675dc [XFS] xlog_rec_he... |
3459 |
op_len = be32_to_cpu(iclog->ic_header.h_cycle_data[idx]); |
1da177e4c Linux-2.6.12-rc2 |
3460 3461 3462 3463 3464 |
} } ptr += sizeof(xlog_op_header_t) + op_len; } } /* xlog_verify_iclog */ |
cfcbbbd08 [XFS] Remove old,... |
3465 |
#endif |
1da177e4c Linux-2.6.12-rc2 |
3466 3467 |
/* |
b22cd72c9 [XFS] Unwrap LOG_... |
3468 |
* Mark all iclogs IOERROR. l_icloglock is held by the caller. |
1da177e4c Linux-2.6.12-rc2 |
3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 |
*/ STATIC int xlog_state_ioerror( xlog_t *log) { xlog_in_core_t *iclog, *ic; iclog = log->l_iclog; if (! (iclog->ic_state & XLOG_STATE_IOERROR)) { /* * Mark all the incore logs IOERROR. * From now on, no log flushes will result. */ ic = iclog; do { ic->ic_state = XLOG_STATE_IOERROR; ic = ic->ic_next; } while (ic != iclog); |
014c2544e return statement ... |
3487 |
return 0; |
1da177e4c Linux-2.6.12-rc2 |
3488 3489 3490 3491 |
} /* * Return non-zero, if state transition has already happened. */ |
014c2544e return statement ... |
3492 |
return 1; |
1da177e4c Linux-2.6.12-rc2 |
3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 |
} /* * This is called from xfs_force_shutdown, when we're forcibly * shutting down the filesystem, typically because of an IO error. * Our main objectives here are to make sure that: * a. the filesystem gets marked 'SHUTDOWN' for all interested * parties to find out, 'atomically'. * b. those who're sleeping on log reservations, pinned objects and * other resources get woken up, and be told the bad news. * c. nothing new gets queued up after (a) and (b) are done. * d. if !logerror, flush the iclogs to disk, then seal them off * for business. |
9da1ab181 xfs: forced unmou... |
3506 3507 3508 3509 3510 |
* * Note: for delayed logging the !logerror case needs to flush the regions * held in memory out to the iclogs before flushing them to disk. This needs * to be done before the log is marked as shutdown, otherwise the flush to the * iclogs will fail. |
1da177e4c Linux-2.6.12-rc2 |
3511 3512 3513 3514 3515 3516 3517 3518 3519 |
*/ int xfs_log_force_umount( struct xfs_mount *mp, int logerror) { xlog_ticket_t *tic; xlog_t *log; int retval; |
1da177e4c Linux-2.6.12-rc2 |
3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 |
log = mp->m_log; /* * If this happens during log recovery, don't worry about * locking; the log isn't open for business yet. */ if (!log || log->l_flags & XLOG_ACTIVE_RECOVERY) { mp->m_flags |= XFS_MOUNT_FS_SHUTDOWN; |
bac8dca9f [XFS] fix NULL po... |
3530 3531 |
if (mp->m_sb_bp) XFS_BUF_DONE(mp->m_sb_bp); |
014c2544e return statement ... |
3532 |
return 0; |
1da177e4c Linux-2.6.12-rc2 |
3533 3534 3535 3536 3537 3538 3539 3540 |
} /* * Somebody could've already done the hard work for us. * No need to get locks for this. */ if (logerror && log->l_iclog->ic_state & XLOG_STATE_IOERROR) { ASSERT(XLOG_FORCED_SHUTDOWN(log)); |
014c2544e return statement ... |
3541 |
return 1; |
1da177e4c Linux-2.6.12-rc2 |
3542 3543 |
} retval = 0; |
9da1ab181 xfs: forced unmou... |
3544 3545 3546 3547 3548 3549 3550 |
/* * Flush the in memory commit item list before marking the log as * being shut down. We need to do it in this order to ensure all the * completed transactions are flushed to disk with the xfs_log_force() * call below. */ |
93b8a5854 xfs: remove the d... |
3551 |
if (!logerror) |
a44f13edf xfs: Reduce log f... |
3552 |
xlog_cil_force(log); |
9da1ab181 xfs: forced unmou... |
3553 |
|
1da177e4c Linux-2.6.12-rc2 |
3554 |
/* |
3f16b9850 xfs: introduce ne... |
3555 3556 |
* mark the filesystem and the as in a shutdown state and wake * everybody up to tell them the bad news. |
1da177e4c Linux-2.6.12-rc2 |
3557 |
*/ |
b22cd72c9 [XFS] Unwrap LOG_... |
3558 |
spin_lock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
3559 |
mp->m_flags |= XFS_MOUNT_FS_SHUTDOWN; |
bac8dca9f [XFS] fix NULL po... |
3560 3561 |
if (mp->m_sb_bp) XFS_BUF_DONE(mp->m_sb_bp); |
1da177e4c Linux-2.6.12-rc2 |
3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 |
/* * This flag is sort of redundant because of the mount flag, but * it's good to maintain the separation between the log and the rest * of XFS. */ log->l_flags |= XLOG_IO_ERROR; /* * If we hit a log error, we want to mark all the iclogs IOERROR * while we're still holding the loglock. */ if (logerror) retval = xlog_state_ioerror(log); |
b22cd72c9 [XFS] Unwrap LOG_... |
3575 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
3576 3577 |
/* |
105479419 xfs: convert log ... |
3578 3579 3580 3581 |
* We don't want anybody waiting for log reservations after this. That * means we have to wake up everybody queued up on reserveq as well as * writeq. In addition, we make sure in xlog_{re}grant_log_space that * we don't enqueue anything once the SHUTDOWN flag is set, and this |
3f16b9850 xfs: introduce ne... |
3582 |
* action is protected by the grant locks. |
1da177e4c Linux-2.6.12-rc2 |
3583 |
*/ |
3f16b9850 xfs: introduce ne... |
3584 |
spin_lock(&log->l_grant_reserve_lock); |
105479419 xfs: convert log ... |
3585 |
list_for_each_entry(tic, &log->l_reserveq, t_queue) |
eb40a8750 xfs: use wait que... |
3586 |
wake_up(&tic->t_wait); |
3f16b9850 xfs: introduce ne... |
3587 |
spin_unlock(&log->l_grant_reserve_lock); |
1da177e4c Linux-2.6.12-rc2 |
3588 |
|
3f16b9850 xfs: introduce ne... |
3589 |
spin_lock(&log->l_grant_write_lock); |
105479419 xfs: convert log ... |
3590 |
list_for_each_entry(tic, &log->l_writeq, t_queue) |
eb40a8750 xfs: use wait que... |
3591 |
wake_up(&tic->t_wait); |
3f16b9850 xfs: introduce ne... |
3592 |
spin_unlock(&log->l_grant_write_lock); |
1da177e4c Linux-2.6.12-rc2 |
3593 |
|
a14a348bf xfs: cleanup up x... |
3594 |
if (!(log->l_iclog->ic_state & XLOG_STATE_IOERROR)) { |
1da177e4c Linux-2.6.12-rc2 |
3595 3596 3597 3598 3599 |
ASSERT(!logerror); /* * Force the incore logs to disk before shutting the * log down completely. */ |
a14a348bf xfs: cleanup up x... |
3600 |
_xfs_log_force(mp, XFS_LOG_SYNC, NULL); |
b22cd72c9 [XFS] Unwrap LOG_... |
3601 |
spin_lock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
3602 |
retval = xlog_state_ioerror(log); |
b22cd72c9 [XFS] Unwrap LOG_... |
3603 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 |
} /* * Wake up everybody waiting on xfs_log_force. * Callback all log item committed functions as if the * log writes were completed. */ xlog_state_do_callback(log, XFS_LI_ABORTED, NULL); #ifdef XFSERRORDEBUG { xlog_in_core_t *iclog; |
b22cd72c9 [XFS] Unwrap LOG_... |
3615 |
spin_lock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
3616 3617 3618 3619 3620 |
iclog = log->l_iclog; do { ASSERT(iclog->ic_callback == 0); iclog = iclog->ic_next; } while (iclog != log->l_iclog); |
b22cd72c9 [XFS] Unwrap LOG_... |
3621 |
spin_unlock(&log->l_icloglock); |
1da177e4c Linux-2.6.12-rc2 |
3622 3623 3624 |
} #endif /* return non-zero if log IOERROR transition had already happened */ |
014c2544e return statement ... |
3625 |
return retval; |
1da177e4c Linux-2.6.12-rc2 |
3626 |
} |
ba0f32d46 [XFS] mark variou... |
3627 |
STATIC int |
1da177e4c Linux-2.6.12-rc2 |
3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 |
xlog_iclogs_empty(xlog_t *log) { xlog_in_core_t *iclog; iclog = log->l_iclog; do { /* endianness does not matter here, zero is zero in * any language. */ if (iclog->ic_header.h_num_logops) |
014c2544e return statement ... |
3638 |
return 0; |
1da177e4c Linux-2.6.12-rc2 |
3639 3640 |
iclog = iclog->ic_next; } while (iclog != log->l_iclog); |
014c2544e return statement ... |
3641 |
return 1; |
1da177e4c Linux-2.6.12-rc2 |
3642 |
} |