Blame view
fs/xfs/xfs_trans_ail.c
22.8 KB
1da177e4c Linux-2.6.12-rc2 |
1 |
/* |
7b7187698 [XFS] Update lice... |
2 |
* Copyright (c) 2000-2002,2005 Silicon Graphics, Inc. |
c7e8f2682 [XFS] Move the AI... |
3 |
* Copyright (c) 2008 Dave Chinner |
7b7187698 [XFS] Update lice... |
4 |
* All Rights Reserved. |
1da177e4c Linux-2.6.12-rc2 |
5 |
* |
7b7187698 [XFS] Update lice... |
6 7 |
* 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 |
8 9 |
* published by the Free Software Foundation. * |
7b7187698 [XFS] Update lice... |
10 11 12 13 |
* 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 |
14 |
* |
7b7187698 [XFS] Update lice... |
15 16 17 |
* 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 |
18 |
*/ |
1da177e4c Linux-2.6.12-rc2 |
19 |
#include "xfs.h" |
a844f4510 [XFS] Remove xfs_... |
20 |
#include "xfs_fs.h" |
1da177e4c Linux-2.6.12-rc2 |
21 |
#include "xfs_types.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 25 |
#include "xfs_trans.h" #include "xfs_sb.h" |
da353b0d6 [XFS] Radix tree ... |
26 |
#include "xfs_ag.h" |
1da177e4c Linux-2.6.12-rc2 |
27 28 |
#include "xfs_mount.h" #include "xfs_trans_priv.h" |
9e4c109ac xfs: add AIL push... |
29 |
#include "xfs_trace.h" |
1da177e4c Linux-2.6.12-rc2 |
30 |
#include "xfs_error.h" |
1da177e4c Linux-2.6.12-rc2 |
31 |
#ifdef DEBUG |
cd4a3c503 xfs: clean up cod... |
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 |
/* * Check that the list is sorted as it should be. */ STATIC void xfs_ail_check( struct xfs_ail *ailp, xfs_log_item_t *lip) { xfs_log_item_t *prev_lip; if (list_empty(&ailp->xa_ail)) return; /* * Check the next and previous entries are valid. */ ASSERT((lip->li_flags & XFS_LI_IN_AIL) != 0); prev_lip = list_entry(lip->li_ail.prev, xfs_log_item_t, li_ail); if (&prev_lip->li_ail != &ailp->xa_ail) ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) <= 0); prev_lip = list_entry(lip->li_ail.next, xfs_log_item_t, li_ail); if (&prev_lip->li_ail != &ailp->xa_ail) ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) >= 0); #ifdef XFS_TRANS_DEBUG /* * Walk the list checking lsn ordering, and that every entry has the * XFS_LI_IN_AIL flag set. This is really expensive, so only do it * when specifically debugging the transaction subsystem. */ prev_lip = list_entry(&ailp->xa_ail, xfs_log_item_t, li_ail); list_for_each_entry(lip, &ailp->xa_ail, li_ail) { if (&prev_lip->li_ail != &ailp->xa_ail) ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) <= 0); ASSERT((lip->li_flags & XFS_LI_IN_AIL) != 0); prev_lip = lip; } #endif /* XFS_TRANS_DEBUG */ } #else /* !DEBUG */ |
de08dbc19 [XFS] Make xfs_ai... |
74 |
#define xfs_ail_check(a,l) |
1da177e4c Linux-2.6.12-rc2 |
75 |
#endif /* DEBUG */ |
cd4a3c503 xfs: clean up cod... |
76 77 78 79 80 81 82 83 84 85 86 87 88 |
/* * Return a pointer to the first item in the AIL. If the AIL is empty, then * return NULL. */ static xfs_log_item_t * xfs_ail_min( struct xfs_ail *ailp) { if (list_empty(&ailp->xa_ail)) return NULL; return list_first_entry(&ailp->xa_ail, xfs_log_item_t, li_ail); } |
fd074841c xfs: push the AIL... |
89 90 91 92 93 94 95 96 97 98 99 100 101 |
/* * Return a pointer to the last item in the AIL. If the AIL is empty, then * return NULL. */ static xfs_log_item_t * xfs_ail_max( struct xfs_ail *ailp) { if (list_empty(&ailp->xa_ail)) return NULL; return list_entry(ailp->xa_ail.prev, xfs_log_item_t, li_ail); } |
cd4a3c503 xfs: clean up cod... |
102 103 104 105 106 107 108 109 110 111 112 113 114 115 |
/* * Return a pointer to the item which follows the given item in the AIL. If * the given item is the last item in the list, then return NULL. */ static xfs_log_item_t * xfs_ail_next( struct xfs_ail *ailp, xfs_log_item_t *lip) { if (lip->li_ail.next == &ailp->xa_ail) return NULL; return list_first_entry(&lip->li_ail, xfs_log_item_t, li_ail); } |
1da177e4c Linux-2.6.12-rc2 |
116 117 |
/* |
cd4a3c503 xfs: clean up cod... |
118 119 120 |
* This is called by the log manager code to determine the LSN of the tail of * the log. This is exactly the LSN of the first item in the AIL. If the AIL * is empty, then this function returns 0. |
1da177e4c Linux-2.6.12-rc2 |
121 |
* |
cd4a3c503 xfs: clean up cod... |
122 123 |
* We need the AIL lock in order to get a coherent read of the lsn of the last * item in the AIL. |
1da177e4c Linux-2.6.12-rc2 |
124 125 |
*/ xfs_lsn_t |
fd074841c xfs: push the AIL... |
126 |
xfs_ail_min_lsn( |
5b00f14fb [XFS] move the AI... |
127 |
struct xfs_ail *ailp) |
1da177e4c Linux-2.6.12-rc2 |
128 |
{ |
cd4a3c503 xfs: clean up cod... |
129 |
xfs_lsn_t lsn = 0; |
1da177e4c Linux-2.6.12-rc2 |
130 |
xfs_log_item_t *lip; |
1da177e4c Linux-2.6.12-rc2 |
131 |
|
c7e8f2682 [XFS] Move the AI... |
132 |
spin_lock(&ailp->xa_lock); |
5b00f14fb [XFS] move the AI... |
133 |
lip = xfs_ail_min(ailp); |
cd4a3c503 xfs: clean up cod... |
134 |
if (lip) |
1da177e4c Linux-2.6.12-rc2 |
135 |
lsn = lip->li_lsn; |
c7e8f2682 [XFS] Move the AI... |
136 |
spin_unlock(&ailp->xa_lock); |
1da177e4c Linux-2.6.12-rc2 |
137 138 139 140 141 |
return lsn; } /* |
fd074841c xfs: push the AIL... |
142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 |
* Return the maximum lsn held in the AIL, or zero if the AIL is empty. */ static xfs_lsn_t xfs_ail_max_lsn( struct xfs_ail *ailp) { xfs_lsn_t lsn = 0; xfs_log_item_t *lip; spin_lock(&ailp->xa_lock); lip = xfs_ail_max(ailp); if (lip) lsn = lip->li_lsn; spin_unlock(&ailp->xa_lock); return lsn; } /* |
af3e40228 xfs: convert AIL ... |
161 162 163 164 165 |
* The cursor keeps track of where our current traversal is up to by tracking * the next item in the list for us. However, for this to be safe, removing an * object from the AIL needs to invalidate any cursor that points to it. hence * the traversal cursor needs to be linked to the struct xfs_ail so that * deletion can search all the active cursors for invalidation. |
27d8d5fe0 [XFS] Use a curso... |
166 |
*/ |
5b00f14fb [XFS] move the AI... |
167 |
STATIC void |
27d8d5fe0 [XFS] Use a curso... |
168 169 170 171 172 |
xfs_trans_ail_cursor_init( struct xfs_ail *ailp, struct xfs_ail_cursor *cur) { cur->item = NULL; |
af3e40228 xfs: convert AIL ... |
173 |
list_add_tail(&cur->list, &ailp->xa_cursors); |
27d8d5fe0 [XFS] Use a curso... |
174 175 176 |
} /* |
af3e40228 xfs: convert AIL ... |
177 178 |
* Get the next item in the traversal and advance the cursor. If the cursor * was invalidated (indicated by a lip of 1), restart the traversal. |
27d8d5fe0 [XFS] Use a curso... |
179 |
*/ |
5b00f14fb [XFS] move the AI... |
180 |
struct xfs_log_item * |
27d8d5fe0 [XFS] Use a curso... |
181 182 183 184 185 186 187 188 |
xfs_trans_ail_cursor_next( struct xfs_ail *ailp, struct xfs_ail_cursor *cur) { struct xfs_log_item *lip = cur->item; if ((__psint_t)lip & 1) lip = xfs_ail_min(ailp); |
16b590294 xfs: remove confu... |
189 190 |
if (lip) cur->item = xfs_ail_next(ailp, lip); |
27d8d5fe0 [XFS] Use a curso... |
191 192 193 194 |
return lip; } /* |
af3e40228 xfs: convert AIL ... |
195 196 |
* When the traversal is complete, we need to remove the cursor from the list * of traversing cursors. |
27d8d5fe0 [XFS] Use a curso... |
197 198 199 200 |
*/ void xfs_trans_ail_cursor_done( struct xfs_ail *ailp, |
af3e40228 xfs: convert AIL ... |
201 |
struct xfs_ail_cursor *cur) |
27d8d5fe0 [XFS] Use a curso... |
202 |
{ |
af3e40228 xfs: convert AIL ... |
203 204 |
cur->item = NULL; list_del_init(&cur->list); |
27d8d5fe0 [XFS] Use a curso... |
205 206 207 |
} /* |
af3e40228 xfs: convert AIL ... |
208 209 210 211 212 213 |
* Invalidate any cursor that is pointing to this item. This is called when an * item is removed from the AIL. Any cursor pointing to this object is now * invalid and the traversal needs to be terminated so it doesn't reference a * freed object. We set the low bit of the cursor item pointer so we can * distinguish between an invalidation and the end of the list when getting the * next item from the cursor. |
5b00f14fb [XFS] move the AI... |
214 215 216 217 218 219 220 |
*/ STATIC void xfs_trans_ail_cursor_clear( struct xfs_ail *ailp, struct xfs_log_item *lip) { struct xfs_ail_cursor *cur; |
af3e40228 xfs: convert AIL ... |
221 |
list_for_each_entry(cur, &ailp->xa_cursors, list) { |
5b00f14fb [XFS] move the AI... |
222 223 224 225 226 227 228 |
if (cur->item == lip) cur->item = (struct xfs_log_item *) ((__psint_t)cur->item | 1); } } /* |
16b590294 xfs: remove confu... |
229 230 231 232 |
* Find the first item in the AIL with the given @lsn by searching in ascending * LSN order and initialise the cursor to point to the next item for a * ascending traversal. Pass a @lsn of zero to initialise the cursor to the * first item in the AIL. Returns NULL if the list is empty. |
249a8c112 [XFS] Move AIL pu... |
233 |
*/ |
5b00f14fb [XFS] move the AI... |
234 235 |
xfs_log_item_t * xfs_trans_ail_cursor_first( |
27d8d5fe0 [XFS] Use a curso... |
236 237 238 |
struct xfs_ail *ailp, struct xfs_ail_cursor *cur, xfs_lsn_t lsn) |
249a8c112 [XFS] Move AIL pu... |
239 |
{ |
27d8d5fe0 [XFS] Use a curso... |
240 |
xfs_log_item_t *lip; |
249a8c112 [XFS] Move AIL pu... |
241 |
|
5b00f14fb [XFS] move the AI... |
242 |
xfs_trans_ail_cursor_init(ailp, cur); |
16b590294 xfs: remove confu... |
243 244 245 |
if (lsn == 0) { lip = xfs_ail_min(ailp); |
5b00f14fb [XFS] move the AI... |
246 |
goto out; |
16b590294 xfs: remove confu... |
247 |
} |
249a8c112 [XFS] Move AIL pu... |
248 |
|
27d8d5fe0 [XFS] Use a curso... |
249 |
list_for_each_entry(lip, &ailp->xa_ail, li_ail) { |
5b00f14fb [XFS] move the AI... |
250 |
if (XFS_LSN_CMP(lip->li_lsn, lsn) >= 0) |
7ee49acfe [XFS] correctly s... |
251 |
goto out; |
535f6b373 [XFS] Replace cus... |
252 |
} |
16b590294 xfs: remove confu... |
253 |
return NULL; |
5b00f14fb [XFS] move the AI... |
254 |
out: |
16b590294 xfs: remove confu... |
255 256 |
if (lip) cur->item = xfs_ail_next(ailp, lip); |
5b00f14fb [XFS] move the AI... |
257 |
return lip; |
249a8c112 [XFS] Move AIL pu... |
258 |
} |
1d8c95a36 xfs: use a cursor... |
259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 |
static struct xfs_log_item * __xfs_trans_ail_cursor_last( struct xfs_ail *ailp, xfs_lsn_t lsn) { xfs_log_item_t *lip; list_for_each_entry_reverse(lip, &ailp->xa_ail, li_ail) { if (XFS_LSN_CMP(lip->li_lsn, lsn) <= 0) return lip; } return NULL; } /* |
16b590294 xfs: remove confu... |
274 275 276 277 |
* Find the last item in the AIL with the given @lsn by searching in descending * LSN order and initialise the cursor to point to that item. If there is no * item with the value of @lsn, then it sets the cursor to the last item with an * LSN lower than @lsn. Returns NULL if the list is empty. |
1d8c95a36 xfs: use a cursor... |
278 279 280 281 282 283 284 285 286 287 288 289 290 |
*/ struct xfs_log_item * xfs_trans_ail_cursor_last( struct xfs_ail *ailp, struct xfs_ail_cursor *cur, xfs_lsn_t lsn) { xfs_trans_ail_cursor_init(ailp, cur); cur->item = __xfs_trans_ail_cursor_last(ailp, lsn); return cur->item; } /* |
16b590294 xfs: remove confu... |
291 |
* Splice the log item list into the AIL at the given LSN. We splice to the |
1d8c95a36 xfs: use a cursor... |
292 293 |
* tail of the given LSN to maintain insert order for push traversals. The * cursor is optional, allowing repeated updates to the same LSN to avoid |
e44f4112a xfs: set cursor i... |
294 |
* repeated traversals. This should not be called with an empty list. |
cd4a3c503 xfs: clean up cod... |
295 296 297 |
*/ static void xfs_ail_splice( |
1d8c95a36 xfs: use a cursor... |
298 299 300 301 |
struct xfs_ail *ailp, struct xfs_ail_cursor *cur, struct list_head *list, xfs_lsn_t lsn) |
cd4a3c503 xfs: clean up cod... |
302 |
{ |
e44f4112a xfs: set cursor i... |
303 304 305 |
struct xfs_log_item *lip; ASSERT(!list_empty(list)); |
cd4a3c503 xfs: clean up cod... |
306 |
|
1d8c95a36 xfs: use a cursor... |
307 |
/* |
e44f4112a xfs: set cursor i... |
308 309 310 |
* Use the cursor to determine the insertion point if one is * provided. If not, or if the one we got is not valid, * find the place in the AIL where the items belong. |
1d8c95a36 xfs: use a cursor... |
311 |
*/ |
e44f4112a xfs: set cursor i... |
312 313 |
lip = cur ? cur->item : NULL; if (!lip || (__psint_t) lip & 1) |
1d8c95a36 xfs: use a cursor... |
314 |
lip = __xfs_trans_ail_cursor_last(ailp, lsn); |
e44f4112a xfs: set cursor i... |
315 316 317 318 319 320 321 322 323 |
/* * If a cursor is provided, we know we're processing the AIL * in lsn order, and future items to be spliced in will * follow the last one being inserted now. Update the * cursor to point to that last item, now while we have a * reliable pointer to it. */ if (cur) cur->item = list_entry(list->prev, struct xfs_log_item, li_ail); |
cd4a3c503 xfs: clean up cod... |
324 |
|
1d8c95a36 xfs: use a cursor... |
325 |
/* |
e44f4112a xfs: set cursor i... |
326 327 328 329 |
* Finally perform the splice. Unless the AIL was empty, * lip points to the item in the AIL _after_ which the new * items should go. If lip is null the AIL was empty, so * the new items go at the head of the AIL. |
1d8c95a36 xfs: use a cursor... |
330 |
*/ |
e44f4112a xfs: set cursor i... |
331 332 333 334 |
if (lip) list_splice(list, &lip->li_ail); else list_splice(list, &ailp->xa_ail); |
cd4a3c503 xfs: clean up cod... |
335 336 337 338 339 340 341 342 343 344 345 346 347 348 |
} /* * Delete the given item from the AIL. Return a pointer to the item. */ static void xfs_ail_delete( struct xfs_ail *ailp, xfs_log_item_t *lip) { xfs_ail_check(ailp, lip); list_del(&lip->li_ail); xfs_trans_ail_cursor_clear(ailp, lip); } |
0030807c6 xfs: revert to us... |
349 350 351 |
static long xfsaild_push( struct xfs_ail *ailp) |
249a8c112 [XFS] Move AIL pu... |
352 |
{ |
9e7004e74 xfs: exit AIL pus... |
353 |
xfs_mount_t *mp = ailp->xa_mount; |
af3e40228 xfs: convert AIL ... |
354 |
struct xfs_ail_cursor cur; |
9e7004e74 xfs: exit AIL pus... |
355 356 |
xfs_log_item_t *lip; xfs_lsn_t lsn; |
fe0da7673 xfs: make AIL tar... |
357 |
xfs_lsn_t target; |
9e7004e74 xfs: exit AIL pus... |
358 |
long tout = 10; |
9e7004e74 xfs: exit AIL pus... |
359 360 361 |
int stuck = 0; int count = 0; int push_xfsbufd = 0; |
1da177e4c Linux-2.6.12-rc2 |
362 |
|
670ce93fe xfs: reduce the n... |
363 364 365 366 |
/* * If last time we ran we encountered pinned items, force the log first * and wait for it before pushing again. */ |
c7e8f2682 [XFS] Move the AI... |
367 |
spin_lock(&ailp->xa_lock); |
670ce93fe xfs: reduce the n... |
368 369 370 371 372 373 374 375 |
if (ailp->xa_last_pushed_lsn == 0 && ailp->xa_log_flush && !list_empty(&ailp->xa_ail)) { ailp->xa_log_flush = 0; spin_unlock(&ailp->xa_lock); XFS_STATS_INC(xs_push_ail_flush); xfs_log_force(mp, XFS_LOG_SYNC); spin_lock(&ailp->xa_lock); } |
fe0da7673 xfs: make AIL tar... |
376 |
target = ailp->xa_target; |
af3e40228 xfs: convert AIL ... |
377 |
lip = xfs_trans_ail_cursor_first(ailp, &cur, ailp->xa_last_pushed_lsn); |
249a8c112 [XFS] Move AIL pu... |
378 |
if (!lip || XFS_FORCED_SHUTDOWN(mp)) { |
1da177e4c Linux-2.6.12-rc2 |
379 |
/* |
249a8c112 [XFS] Move AIL pu... |
380 |
* AIL is empty or our push has reached the end. |
1da177e4c Linux-2.6.12-rc2 |
381 |
*/ |
af3e40228 xfs: convert AIL ... |
382 |
xfs_trans_ail_cursor_done(ailp, &cur); |
c7e8f2682 [XFS] Move the AI... |
383 |
spin_unlock(&ailp->xa_lock); |
9e7004e74 xfs: exit AIL pus... |
384 |
goto out_done; |
1da177e4c Linux-2.6.12-rc2 |
385 386 387 388 389 390 |
} XFS_STATS_INC(xs_push_ail); /* * While the item we are looking at is below the given threshold |
249a8c112 [XFS] Move AIL pu... |
391 |
* try to flush it out. We'd like not to stop until we've at least |
1da177e4c Linux-2.6.12-rc2 |
392 |
* tried to push on everything in the AIL with an LSN less than |
249a8c112 [XFS] Move AIL pu... |
393 394 395 396 397 398 |
* the given threshold. * * However, we will stop after a certain number of pushes and wait * for a reduced timeout to fire before pushing further. This * prevents use from spinning when we can't do anything or there is * lots of contention on the AIL lists. |
1da177e4c Linux-2.6.12-rc2 |
399 |
*/ |
249a8c112 [XFS] Move AIL pu... |
400 |
lsn = lip->li_lsn; |
50e86686d xfs: always push ... |
401 |
while ((XFS_LSN_CMP(lip->li_lsn, target) <= 0)) { |
249a8c112 [XFS] Move AIL pu... |
402 |
int lock_result; |
1da177e4c Linux-2.6.12-rc2 |
403 |
/* |
249a8c112 [XFS] Move AIL pu... |
404 405 406 407 |
* If we can lock the item without sleeping, unlock the AIL * lock and flush the item. Then re-grab the AIL lock so we * can look for the next item on the AIL. List changes are * handled by the AIL lookup functions internally |
1da177e4c Linux-2.6.12-rc2 |
408 |
* |
249a8c112 [XFS] Move AIL pu... |
409 410 411 412 |
* If we can't lock the item, either its holder will flush it * or it is already being flushed or it is being relogged. In * any of these case it is being taken care of and we can just * skip to the next item in the list. |
1da177e4c Linux-2.6.12-rc2 |
413 414 |
*/ lock_result = IOP_TRYLOCK(lip); |
c7e8f2682 [XFS] Move the AI... |
415 |
spin_unlock(&ailp->xa_lock); |
1da177e4c Linux-2.6.12-rc2 |
416 |
switch (lock_result) { |
249a8c112 [XFS] Move AIL pu... |
417 |
case XFS_ITEM_SUCCESS: |
1da177e4c Linux-2.6.12-rc2 |
418 |
XFS_STATS_INC(xs_push_ail_success); |
9e4c109ac xfs: add AIL push... |
419 |
trace_xfs_ail_push(lip); |
1da177e4c Linux-2.6.12-rc2 |
420 |
IOP_PUSH(lip); |
0bf6a5bd4 xfs: convert the ... |
421 |
ailp->xa_last_pushed_lsn = lsn; |
1da177e4c Linux-2.6.12-rc2 |
422 |
break; |
249a8c112 [XFS] Move AIL pu... |
423 |
case XFS_ITEM_PUSHBUF: |
1da177e4c Linux-2.6.12-rc2 |
424 |
XFS_STATS_INC(xs_push_ail_pushbuf); |
9e4c109ac xfs: add AIL push... |
425 |
trace_xfs_ail_pushbuf(lip); |
17b38471c xfs: force the lo... |
426 427 |
if (!IOP_PUSHBUF(lip)) { |
9e4c109ac xfs: add AIL push... |
428 |
trace_xfs_ail_pushbuf_pinned(lip); |
17b38471c xfs: force the lo... |
429 |
stuck++; |
2900b3399 xfs: put in misse... |
430 |
ailp->xa_log_flush++; |
17b38471c xfs: force the lo... |
431 432 433 |
} else { ailp->xa_last_pushed_lsn = lsn; } |
d808f617a xfs: Don't issue ... |
434 |
push_xfsbufd = 1; |
1da177e4c Linux-2.6.12-rc2 |
435 |
break; |
249a8c112 [XFS] Move AIL pu... |
436 |
case XFS_ITEM_PINNED: |
1da177e4c Linux-2.6.12-rc2 |
437 |
XFS_STATS_INC(xs_push_ail_pinned); |
9e4c109ac xfs: add AIL push... |
438 |
trace_xfs_ail_pinned(lip); |
249a8c112 [XFS] Move AIL pu... |
439 |
stuck++; |
670ce93fe xfs: reduce the n... |
440 |
ailp->xa_log_flush++; |
1da177e4c Linux-2.6.12-rc2 |
441 |
break; |
249a8c112 [XFS] Move AIL pu... |
442 |
case XFS_ITEM_LOCKED: |
1da177e4c Linux-2.6.12-rc2 |
443 |
XFS_STATS_INC(xs_push_ail_locked); |
9e4c109ac xfs: add AIL push... |
444 |
trace_xfs_ail_locked(lip); |
249a8c112 [XFS] Move AIL pu... |
445 |
stuck++; |
1da177e4c Linux-2.6.12-rc2 |
446 |
break; |
249a8c112 [XFS] Move AIL pu... |
447 |
default: |
1da177e4c Linux-2.6.12-rc2 |
448 449 450 |
ASSERT(0); break; } |
c7e8f2682 [XFS] Move the AI... |
451 |
spin_lock(&ailp->xa_lock); |
249a8c112 [XFS] Move AIL pu... |
452 453 |
/* should we bother continuing? */ if (XFS_FORCED_SHUTDOWN(mp)) |
1da177e4c Linux-2.6.12-rc2 |
454 |
break; |
249a8c112 [XFS] Move AIL pu... |
455 456 457 |
ASSERT(mp->m_log); count++; |
1da177e4c Linux-2.6.12-rc2 |
458 |
|
249a8c112 [XFS] Move AIL pu... |
459 460 461 462 463 464 465 466 467 468 469 470 471 472 |
/* * Are there too many items we can't do anything with? * If we we are skipping too many items because we can't flush * them or they are already being flushed, we back off and * given them time to complete whatever operation is being * done. i.e. remove pressure from the AIL while we can't make * progress so traversals don't slow down further inserts and * removals to/from the AIL. * * The value of 100 is an arbitrary magic number based on * observation. */ if (stuck > 100) break; |
af3e40228 xfs: convert AIL ... |
473 |
lip = xfs_trans_ail_cursor_next(ailp, &cur); |
249a8c112 [XFS] Move AIL pu... |
474 475 |
if (lip == NULL) break; |
249a8c112 [XFS] Move AIL pu... |
476 |
lsn = lip->li_lsn; |
1da177e4c Linux-2.6.12-rc2 |
477 |
} |
af3e40228 xfs: convert AIL ... |
478 |
xfs_trans_ail_cursor_done(ailp, &cur); |
c7e8f2682 [XFS] Move the AI... |
479 |
spin_unlock(&ailp->xa_lock); |
1da177e4c Linux-2.6.12-rc2 |
480 |
|
d808f617a xfs: Don't issue ... |
481 482 483 484 |
if (push_xfsbufd) { /* we've got delayed write buffers to flush */ wake_up_process(mp->m_ddev_targp->bt_task); } |
0bf6a5bd4 xfs: convert the ... |
485 |
/* assume we have more work to do in a short while */ |
9e7004e74 xfs: exit AIL pus... |
486 |
out_done: |
92d9cd105 [XFS] 977545 9775... |
487 488 |
if (!count) { /* We're past our target or empty, so idle */ |
0bf6a5bd4 xfs: convert the ... |
489 |
ailp->xa_last_pushed_lsn = 0; |
670ce93fe xfs: reduce the n... |
490 |
ailp->xa_log_flush = 0; |
0bf6a5bd4 xfs: convert the ... |
491 |
|
0bf6a5bd4 xfs: convert the ... |
492 |
tout = 50; |
92d9cd105 [XFS] 977545 9775... |
493 494 495 496 497 498 |
} else if (XFS_LSN_CMP(lsn, target) >= 0) { /* * We reached the target so wait a bit longer for I/O to * complete and remove pushed items from the AIL before we * start the next scan from the start of the AIL. */ |
453eac8a9 xfs: Don't wake t... |
499 |
tout = 50; |
0bf6a5bd4 xfs: convert the ... |
500 |
ailp->xa_last_pushed_lsn = 0; |
27d8d5fe0 [XFS] Use a curso... |
501 |
} else if ((stuck * 100) / count > 90) { |
249a8c112 [XFS] Move AIL pu... |
502 503 504 505 506 507 508 |
/* * Either there is a lot of contention on the AIL or we * are stuck due to operations in progress. "Stuck" in this * case is defined as >90% of the items we tried to push * were stuck. * * Backoff a bit more to allow some I/O to complete before |
670ce93fe xfs: reduce the n... |
509 510 511 512 |
* restarting from the start of the AIL. This prevents us * from spinning on the same items, and if they are pinned will * all the restart to issue a log force to unpin the stuck * items. |
249a8c112 [XFS] Move AIL pu... |
513 |
*/ |
453eac8a9 xfs: Don't wake t... |
514 |
tout = 20; |
670ce93fe xfs: reduce the n... |
515 |
ailp->xa_last_pushed_lsn = 0; |
1da177e4c Linux-2.6.12-rc2 |
516 |
} |
0bf6a5bd4 xfs: convert the ... |
517 |
|
0030807c6 xfs: revert to us... |
518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 |
return tout; } static int xfsaild( void *data) { struct xfs_ail *ailp = data; long tout = 0; /* milliseconds */ while (!kthread_should_stop()) { if (tout && tout <= 20) __set_current_state(TASK_KILLABLE); else __set_current_state(TASK_INTERRUPTIBLE); schedule_timeout(tout ? msecs_to_jiffies(tout) : MAX_SCHEDULE_TIMEOUT); try_to_freeze(); tout = xfsaild_push(ailp); } return 0; |
453eac8a9 xfs: Don't wake t... |
542 |
} |
1da177e4c Linux-2.6.12-rc2 |
543 |
|
0bf6a5bd4 xfs: convert the ... |
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 |
/* * This routine is called to move the tail of the AIL forward. It does this by * trying to flush items in the AIL whose lsns are below the given * threshold_lsn. * * The push is run asynchronously in a workqueue, which means the caller needs * to handle waiting on the async flush for space to become available. * We don't want to interrupt any push that is in progress, hence we only queue * work if we set the pushing bit approriately. * * We do this unlocked - we only need to know whether there is anything in the * AIL at the time we are called. We don't need to access the contents of * any of the objects, so the lock is not needed. */ void |
fd074841c xfs: push the AIL... |
559 |
xfs_ail_push( |
0bf6a5bd4 xfs: convert the ... |
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 |
struct xfs_ail *ailp, xfs_lsn_t threshold_lsn) { xfs_log_item_t *lip; lip = xfs_ail_min(ailp); if (!lip || XFS_FORCED_SHUTDOWN(ailp->xa_mount) || XFS_LSN_CMP(threshold_lsn, ailp->xa_target) <= 0) return; /* * Ensure that the new target is noticed in push code before it clears * the XFS_AIL_PUSHING_BIT. */ smp_wmb(); |
fe0da7673 xfs: make AIL tar... |
575 |
xfs_trans_ail_copy_lsn(ailp, &ailp->xa_target, &threshold_lsn); |
0030807c6 xfs: revert to us... |
576 577 578 |
smp_wmb(); wake_up_process(ailp->xa_task); |
0bf6a5bd4 xfs: convert the ... |
579 |
} |
1da177e4c Linux-2.6.12-rc2 |
580 581 |
/* |
fd074841c xfs: push the AIL... |
582 583 584 585 586 587 588 589 590 591 592 593 594 |
* Push out all items in the AIL immediately */ void xfs_ail_push_all( struct xfs_ail *ailp) { xfs_lsn_t threshold_lsn = xfs_ail_max_lsn(ailp); if (threshold_lsn) xfs_ail_push(ailp, threshold_lsn); } /* |
1da177e4c Linux-2.6.12-rc2 |
595 596 597 598 599 600 601 602 603 |
* This is to be called when an item is unlocked that may have * been in the AIL. It will wake up the first member of the AIL * wait list if this item's unlocking might allow it to progress. * If the item is in the AIL, then we need to get the AIL lock * while doing our checking so we don't race with someone going * to sleep waiting for this event in xfs_trans_push_ail(). */ void xfs_trans_unlocked_item( |
783a2f656 [XFS] Finish remo... |
604 |
struct xfs_ail *ailp, |
1da177e4c Linux-2.6.12-rc2 |
605 606 607 608 609 610 611 612 613 614 615 |
xfs_log_item_t *lip) { xfs_log_item_t *min_lip; /* * If we're forcibly shutting down, we may have * unlocked log items arbitrarily. The last thing * we want to do is to move the tail of the log * over some potentially valid data. */ if (!(lip->li_flags & XFS_LI_IN_AIL) || |
783a2f656 [XFS] Finish remo... |
616 |
XFS_FORCED_SHUTDOWN(ailp->xa_mount)) { |
1da177e4c Linux-2.6.12-rc2 |
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 |
return; } /* * This is the one case where we can call into xfs_ail_min() * without holding the AIL lock because we only care about the * case where we are at the tail of the AIL. If the object isn't * at the tail, it doesn't matter what result we get back. This * is slightly racy because since we were just unlocked, we could * go to sleep between the call to xfs_ail_min and the call to * xfs_log_move_tail, have someone else lock us, commit to us disk, * move us out of the tail of the AIL, and then we wake up. However, * the call to xfs_log_move_tail() doesn't do anything if there's * not enough free space to wake people up so we're safe calling it. */ |
783a2f656 [XFS] Finish remo... |
632 |
min_lip = xfs_ail_min(ailp); |
1da177e4c Linux-2.6.12-rc2 |
633 634 |
if (min_lip == lip) |
783a2f656 [XFS] Finish remo... |
635 |
xfs_log_move_tail(ailp->xa_mount, 1); |
1da177e4c Linux-2.6.12-rc2 |
636 |
} /* xfs_trans_unlocked_item */ |
1da177e4c Linux-2.6.12-rc2 |
637 |
/* |
0e57f6a36 xfs: bulk AIL ins... |
638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 |
* xfs_trans_ail_update - bulk AIL insertion operation. * * @xfs_trans_ail_update takes an array of log items that all need to be * positioned at the same LSN in the AIL. If an item is not in the AIL, it will * be added. Otherwise, it will be repositioned by removing it and re-adding * it to the AIL. If we move the first item in the AIL, update the log tail to * match the new minimum LSN in the AIL. * * This function takes the AIL lock once to execute the update operations on * all the items in the array, and as such should not be called with the AIL * lock held. As a result, once we have the AIL lock, we need to check each log * item LSN to confirm it needs to be moved forward in the AIL. * * To optimise the insert operation, we delete all the items from the AIL in * the first pass, moving them into a temporary list, then splice the temporary * list into the correct position in the AIL. This avoids needing to do an * insert operation on every item. * * This function must be called with the AIL lock held. The lock is dropped * before returning. */ void xfs_trans_ail_update_bulk( struct xfs_ail *ailp, |
1d8c95a36 xfs: use a cursor... |
662 |
struct xfs_ail_cursor *cur, |
0e57f6a36 xfs: bulk AIL ins... |
663 664 665 666 667 668 669 670 671 |
struct xfs_log_item **log_items, int nr_items, xfs_lsn_t lsn) __releases(ailp->xa_lock) { xfs_log_item_t *mlip; xfs_lsn_t tail_lsn; int mlip_changed = 0; int i; LIST_HEAD(tmp); |
e44f4112a xfs: set cursor i... |
672 |
ASSERT(nr_items > 0); /* Not required, but true. */ |
0e57f6a36 xfs: bulk AIL ins... |
673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 |
mlip = xfs_ail_min(ailp); for (i = 0; i < nr_items; i++) { struct xfs_log_item *lip = log_items[i]; if (lip->li_flags & XFS_LI_IN_AIL) { /* check if we really need to move the item */ if (XFS_LSN_CMP(lsn, lip->li_lsn) <= 0) continue; xfs_ail_delete(ailp, lip); if (mlip == lip) mlip_changed = 1; } else { lip->li_flags |= XFS_LI_IN_AIL; } lip->li_lsn = lsn; list_add(&lip->li_ail, &tmp); } |
e44f4112a xfs: set cursor i... |
691 692 |
if (!list_empty(&tmp)) xfs_ail_splice(ailp, cur, &tmp, lsn); |
0e57f6a36 xfs: bulk AIL ins... |
693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 |
if (!mlip_changed) { spin_unlock(&ailp->xa_lock); return; } /* * It is not safe to access mlip after the AIL lock is dropped, so we * must get a copy of li_lsn before we do so. This is especially * important on 32-bit platforms where accessing and updating 64-bit * values like li_lsn is not atomic. */ mlip = xfs_ail_min(ailp); tail_lsn = mlip->li_lsn; spin_unlock(&ailp->xa_lock); xfs_log_move_tail(ailp->xa_mount, tail_lsn); } /* |
301368325 xfs: remove all t... |
712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 |
* xfs_trans_ail_delete_bulk - remove multiple log items from the AIL * * @xfs_trans_ail_delete_bulk takes an array of log items that all need to * removed from the AIL. The caller is already holding the AIL lock, and done * all the checks necessary to ensure the items passed in via @log_items are * ready for deletion. This includes checking that the items are in the AIL. * * For each log item to be removed, unlink it from the AIL, clear the IN_AIL * flag from the item and reset the item's lsn to 0. If we remove the first * item in the AIL, update the log tail to match the new minimum LSN in the * AIL. * * This function will not drop the AIL lock until all items are removed from * the AIL to minimise the amount of lock traffic on the AIL. This does not * greatly increase the AIL hold time, but does significantly reduce the amount * of traffic on the lock, especially during IO completion. * * This function must be called with the AIL lock held. The lock is dropped * before returning. */ void xfs_trans_ail_delete_bulk( struct xfs_ail *ailp, struct xfs_log_item **log_items, int nr_items) __releases(ailp->xa_lock) { xfs_log_item_t *mlip; xfs_lsn_t tail_lsn; int mlip_changed = 0; int i; mlip = xfs_ail_min(ailp); for (i = 0; i < nr_items; i++) { struct xfs_log_item *lip = log_items[i]; if (!(lip->li_flags & XFS_LI_IN_AIL)) { struct xfs_mount *mp = ailp->xa_mount; spin_unlock(&ailp->xa_lock); if (!XFS_FORCED_SHUTDOWN(mp)) { |
6a19d9393 xfs: convert xfs_... |
752 |
xfs_alert_tag(mp, XFS_PTAG_AILDELETE, |
301368325 xfs: remove all t... |
753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 |
"%s: attempting to delete a log item that is not in the AIL", __func__); xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); } return; } xfs_ail_delete(ailp, lip); lip->li_flags &= ~XFS_LI_IN_AIL; lip->li_lsn = 0; if (mlip == lip) mlip_changed = 1; } if (!mlip_changed) { spin_unlock(&ailp->xa_lock); return; } /* * It is not safe to access mlip after the AIL lock is dropped, so we * must get a copy of li_lsn before we do so. This is especially * important on 32-bit platforms where accessing and updating 64-bit * values like li_lsn is not atomic. It is possible we've emptied the * AIL here, so if that is the case, pass an LSN of 0 to the tail move. */ mlip = xfs_ail_min(ailp); tail_lsn = mlip ? mlip->li_lsn : 0; spin_unlock(&ailp->xa_lock); xfs_log_move_tail(ailp->xa_mount, tail_lsn); } |
1da177e4c Linux-2.6.12-rc2 |
784 |
|
1da177e4c Linux-2.6.12-rc2 |
785 |
/* |
1da177e4c Linux-2.6.12-rc2 |
786 787 788 789 790 791 792 793 794 795 796 797 798 |
* The active item list (AIL) is a doubly linked list of log * items sorted by ascending lsn. The base of the list is * a forw/back pointer pair embedded in the xfs mount structure. * The base is initialized with both pointers pointing to the * base. This case always needs to be distinguished, because * the base has no lsn to look at. We almost always insert * at the end of the list, so on inserts we search from the * end of the list to find where the new item belongs. */ /* * Initialize the doubly linked list to point only to itself. */ |
249a8c112 [XFS] Move AIL pu... |
799 |
int |
1da177e4c Linux-2.6.12-rc2 |
800 801 802 |
xfs_trans_ail_init( xfs_mount_t *mp) { |
82fa90124 [XFS] Allocate th... |
803 804 805 806 807 808 809 810 |
struct xfs_ail *ailp; ailp = kmem_zalloc(sizeof(struct xfs_ail), KM_MAYFAIL); if (!ailp) return ENOMEM; ailp->xa_mount = mp; INIT_LIST_HEAD(&ailp->xa_ail); |
af3e40228 xfs: convert AIL ... |
811 |
INIT_LIST_HEAD(&ailp->xa_cursors); |
c7e8f2682 [XFS] Move the AI... |
812 |
spin_lock_init(&ailp->xa_lock); |
0030807c6 xfs: revert to us... |
813 814 815 816 817 |
ailp->xa_task = kthread_run(xfsaild, ailp, "xfsaild/%s", ailp->xa_mount->m_fsname); if (IS_ERR(ailp->xa_task)) goto out_free_ailp; |
27d8d5fe0 [XFS] Use a curso... |
818 819 |
mp->m_ail = ailp; return 0; |
0030807c6 xfs: revert to us... |
820 821 822 823 |
out_free_ailp: kmem_free(ailp); return ENOMEM; |
249a8c112 [XFS] Move AIL pu... |
824 825 826 827 828 829 |
} void xfs_trans_ail_destroy( xfs_mount_t *mp) { |
82fa90124 [XFS] Allocate th... |
830 |
struct xfs_ail *ailp = mp->m_ail; |
0030807c6 xfs: revert to us... |
831 |
kthread_stop(ailp->xa_task); |
82fa90124 [XFS] Allocate th... |
832 |
kmem_free(ailp); |
1da177e4c Linux-2.6.12-rc2 |
833 |
} |