Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
7b718769 NS |
2 | * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc. |
3 | * All Rights Reserved. | |
1da177e4 | 4 | * |
7b718769 NS |
5 | * This program is free software; you can redistribute it and/or |
6 | * modify it under the terms of the GNU General Public License as | |
1da177e4 LT |
7 | * published by the Free Software Foundation. |
8 | * | |
7b718769 NS |
9 | * This program is distributed in the hope that it would be useful, |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | * GNU General Public License for more details. | |
1da177e4 | 13 | * |
7b718769 NS |
14 | * You should have received a copy of the GNU General Public License |
15 | * along with this program; if not, write the Free Software Foundation, | |
16 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
1da177e4 | 17 | */ |
1da177e4 | 18 | #include "xfs.h" |
a844f451 | 19 | #include "xfs_fs.h" |
1da177e4 | 20 | #include "xfs_types.h" |
1da177e4 | 21 | #include "xfs_log.h" |
a844f451 | 22 | #include "xfs_inum.h" |
1da177e4 | 23 | #include "xfs_trans.h" |
a8272ce0 | 24 | #include "xfs_trans_priv.h" |
9da096fd | 25 | /* XXX: from here down needed until struct xfs_trans has its own ailp */ |
fc1829f3 DC |
26 | #include "xfs_bit.h" |
27 | #include "xfs_buf_item.h" | |
28 | #include "xfs_sb.h" | |
29 | #include "xfs_ag.h" | |
30 | #include "xfs_dir2.h" | |
31 | #include "xfs_dmapi.h" | |
32 | #include "xfs_mount.h" | |
1da177e4 LT |
33 | |
34 | STATIC int xfs_trans_unlock_chunk(xfs_log_item_chunk_t *, | |
35 | int, int, xfs_lsn_t); | |
36 | ||
37 | /* | |
38 | * This is called to add the given log item to the transaction's | |
39 | * list of log items. It must find a free log item descriptor | |
40 | * or allocate a new one and add the item to that descriptor. | |
41 | * The function returns a pointer to item descriptor used to point | |
42 | * to the new item. The log item will now point to its new descriptor | |
43 | * with its li_desc field. | |
44 | */ | |
45 | xfs_log_item_desc_t * | |
46 | xfs_trans_add_item(xfs_trans_t *tp, xfs_log_item_t *lip) | |
47 | { | |
48 | xfs_log_item_desc_t *lidp; | |
49 | xfs_log_item_chunk_t *licp; | |
50 | int i=0; | |
51 | ||
52 | /* | |
53 | * If there are no free descriptors, allocate a new chunk | |
54 | * of them and put it at the front of the chunk list. | |
55 | */ | |
56 | if (tp->t_items_free == 0) { | |
57 | licp = (xfs_log_item_chunk_t*) | |
58 | kmem_alloc(sizeof(xfs_log_item_chunk_t), KM_SLEEP); | |
59 | ASSERT(licp != NULL); | |
60 | /* | |
61 | * Initialize the chunk, and then | |
62 | * claim the first slot in the newly allocated chunk. | |
63 | */ | |
39dab9d7 ES |
64 | xfs_lic_init(licp); |
65 | xfs_lic_claim(licp, 0); | |
1da177e4 | 66 | licp->lic_unused = 1; |
39dab9d7 ES |
67 | xfs_lic_init_slot(licp, 0); |
68 | lidp = xfs_lic_slot(licp, 0); | |
1da177e4 LT |
69 | |
70 | /* | |
71 | * Link in the new chunk and update the free count. | |
72 | */ | |
73 | licp->lic_next = tp->t_items.lic_next; | |
74 | tp->t_items.lic_next = licp; | |
75 | tp->t_items_free = XFS_LIC_NUM_SLOTS - 1; | |
76 | ||
77 | /* | |
78 | * Initialize the descriptor and the generic portion | |
79 | * of the log item. | |
80 | * | |
81 | * Point the new slot at this item and return it. | |
82 | * Also point the log item at its currently active | |
83 | * descriptor and set the item's mount pointer. | |
84 | */ | |
85 | lidp->lid_item = lip; | |
86 | lidp->lid_flags = 0; | |
87 | lidp->lid_size = 0; | |
88 | lip->li_desc = lidp; | |
89 | lip->li_mountp = tp->t_mountp; | |
fc1829f3 | 90 | lip->li_ailp = tp->t_mountp->m_ail; |
014c2544 | 91 | return lidp; |
1da177e4 LT |
92 | } |
93 | ||
94 | /* | |
95 | * Find the free descriptor. It is somewhere in the chunklist | |
96 | * of descriptors. | |
97 | */ | |
98 | licp = &tp->t_items; | |
99 | while (licp != NULL) { | |
39dab9d7 | 100 | if (xfs_lic_vacancy(licp)) { |
1da177e4 LT |
101 | if (licp->lic_unused <= XFS_LIC_MAX_SLOT) { |
102 | i = licp->lic_unused; | |
39dab9d7 | 103 | ASSERT(xfs_lic_isfree(licp, i)); |
1da177e4 LT |
104 | break; |
105 | } | |
106 | for (i = 0; i <= XFS_LIC_MAX_SLOT; i++) { | |
39dab9d7 | 107 | if (xfs_lic_isfree(licp, i)) |
1da177e4 LT |
108 | break; |
109 | } | |
110 | ASSERT(i <= XFS_LIC_MAX_SLOT); | |
111 | break; | |
112 | } | |
113 | licp = licp->lic_next; | |
114 | } | |
115 | ASSERT(licp != NULL); | |
116 | /* | |
117 | * If we find a free descriptor, claim it, | |
118 | * initialize it, and return it. | |
119 | */ | |
39dab9d7 | 120 | xfs_lic_claim(licp, i); |
1da177e4 LT |
121 | if (licp->lic_unused <= i) { |
122 | licp->lic_unused = i + 1; | |
39dab9d7 | 123 | xfs_lic_init_slot(licp, i); |
1da177e4 | 124 | } |
39dab9d7 | 125 | lidp = xfs_lic_slot(licp, i); |
1da177e4 LT |
126 | tp->t_items_free--; |
127 | lidp->lid_item = lip; | |
128 | lidp->lid_flags = 0; | |
129 | lidp->lid_size = 0; | |
130 | lip->li_desc = lidp; | |
131 | lip->li_mountp = tp->t_mountp; | |
fc1829f3 | 132 | lip->li_ailp = tp->t_mountp->m_ail; |
014c2544 | 133 | return lidp; |
1da177e4 LT |
134 | } |
135 | ||
136 | /* | |
137 | * Free the given descriptor. | |
138 | * | |
139 | * This requires setting the bit in the chunk's free mask corresponding | |
140 | * to the given slot. | |
141 | */ | |
142 | void | |
143 | xfs_trans_free_item(xfs_trans_t *tp, xfs_log_item_desc_t *lidp) | |
144 | { | |
145 | uint slot; | |
146 | xfs_log_item_chunk_t *licp; | |
147 | xfs_log_item_chunk_t **licpp; | |
148 | ||
39dab9d7 ES |
149 | slot = xfs_lic_desc_to_slot(lidp); |
150 | licp = xfs_lic_desc_to_chunk(lidp); | |
151 | xfs_lic_relse(licp, slot); | |
1da177e4 LT |
152 | lidp->lid_item->li_desc = NULL; |
153 | tp->t_items_free++; | |
154 | ||
155 | /* | |
156 | * If there are no more used items in the chunk and this is not | |
157 | * the chunk embedded in the transaction structure, then free | |
158 | * the chunk. First pull it from the chunk list and then | |
159 | * free it back to the heap. We didn't bother with a doubly | |
160 | * linked list here because the lists should be very short | |
161 | * and this is not a performance path. It's better to save | |
162 | * the memory of the extra pointer. | |
163 | * | |
164 | * Also decrement the transaction structure's count of free items | |
165 | * by the number in a chunk since we are freeing an empty chunk. | |
166 | */ | |
39dab9d7 | 167 | if (xfs_lic_are_all_free(licp) && (licp != &(tp->t_items))) { |
1da177e4 LT |
168 | licpp = &(tp->t_items.lic_next); |
169 | while (*licpp != licp) { | |
170 | ASSERT(*licpp != NULL); | |
171 | licpp = &((*licpp)->lic_next); | |
172 | } | |
173 | *licpp = licp->lic_next; | |
f0e2d93c | 174 | kmem_free(licp); |
1da177e4 LT |
175 | tp->t_items_free -= XFS_LIC_NUM_SLOTS; |
176 | } | |
177 | } | |
178 | ||
179 | /* | |
180 | * This is called to find the descriptor corresponding to the given | |
181 | * log item. It returns a pointer to the descriptor. | |
182 | * The log item MUST have a corresponding descriptor in the given | |
183 | * transaction. This routine does not return NULL, it panics. | |
184 | * | |
185 | * The descriptor pointer is kept in the log item's li_desc field. | |
186 | * Just return it. | |
187 | */ | |
188 | /*ARGSUSED*/ | |
189 | xfs_log_item_desc_t * | |
190 | xfs_trans_find_item(xfs_trans_t *tp, xfs_log_item_t *lip) | |
191 | { | |
192 | ASSERT(lip->li_desc != NULL); | |
193 | ||
014c2544 | 194 | return lip->li_desc; |
1da177e4 LT |
195 | } |
196 | ||
197 | ||
198 | /* | |
199 | * Return a pointer to the first descriptor in the chunk list. | |
200 | * This does not return NULL if there are none, it panics. | |
201 | * | |
202 | * The first descriptor must be in either the first or second chunk. | |
203 | * This is because the only chunk allowed to be empty is the first. | |
204 | * All others are freed when they become empty. | |
205 | * | |
206 | * At some point this and xfs_trans_next_item() should be optimized | |
207 | * to quickly look at the mask to determine if there is anything to | |
208 | * look at. | |
209 | */ | |
210 | xfs_log_item_desc_t * | |
211 | xfs_trans_first_item(xfs_trans_t *tp) | |
212 | { | |
213 | xfs_log_item_chunk_t *licp; | |
214 | int i; | |
215 | ||
216 | licp = &tp->t_items; | |
217 | /* | |
218 | * If it's not in the first chunk, skip to the second. | |
219 | */ | |
39dab9d7 | 220 | if (xfs_lic_are_all_free(licp)) { |
1da177e4 LT |
221 | licp = licp->lic_next; |
222 | } | |
223 | ||
224 | /* | |
225 | * Return the first non-free descriptor in the chunk. | |
226 | */ | |
39dab9d7 | 227 | ASSERT(!xfs_lic_are_all_free(licp)); |
1da177e4 | 228 | for (i = 0; i < licp->lic_unused; i++) { |
39dab9d7 | 229 | if (xfs_lic_isfree(licp, i)) { |
1da177e4 LT |
230 | continue; |
231 | } | |
232 | ||
39dab9d7 | 233 | return xfs_lic_slot(licp, i); |
1da177e4 LT |
234 | } |
235 | cmn_err(CE_WARN, "xfs_trans_first_item() -- no first item"); | |
014c2544 | 236 | return NULL; |
1da177e4 LT |
237 | } |
238 | ||
239 | ||
240 | /* | |
241 | * Given a descriptor, return the next descriptor in the chunk list. | |
242 | * This returns NULL if there are no more used descriptors in the list. | |
243 | * | |
244 | * We do this by first locating the chunk in which the descriptor resides, | |
245 | * and then scanning forward in the chunk and the list for the next | |
246 | * used descriptor. | |
247 | */ | |
248 | /*ARGSUSED*/ | |
249 | xfs_log_item_desc_t * | |
250 | xfs_trans_next_item(xfs_trans_t *tp, xfs_log_item_desc_t *lidp) | |
251 | { | |
252 | xfs_log_item_chunk_t *licp; | |
253 | int i; | |
254 | ||
39dab9d7 | 255 | licp = xfs_lic_desc_to_chunk(lidp); |
1da177e4 LT |
256 | |
257 | /* | |
258 | * First search the rest of the chunk. The for loop keeps us | |
259 | * from referencing things beyond the end of the chunk. | |
260 | */ | |
39dab9d7 ES |
261 | for (i = (int)xfs_lic_desc_to_slot(lidp) + 1; i < licp->lic_unused; i++) { |
262 | if (xfs_lic_isfree(licp, i)) { | |
1da177e4 LT |
263 | continue; |
264 | } | |
265 | ||
39dab9d7 | 266 | return xfs_lic_slot(licp, i); |
1da177e4 LT |
267 | } |
268 | ||
269 | /* | |
270 | * Now search the next chunk. It must be there, because the | |
271 | * next chunk would have been freed if it were empty. | |
272 | * If there is no next chunk, return NULL. | |
273 | */ | |
274 | if (licp->lic_next == NULL) { | |
014c2544 | 275 | return NULL; |
1da177e4 LT |
276 | } |
277 | ||
278 | licp = licp->lic_next; | |
39dab9d7 | 279 | ASSERT(!xfs_lic_are_all_free(licp)); |
1da177e4 | 280 | for (i = 0; i < licp->lic_unused; i++) { |
39dab9d7 | 281 | if (xfs_lic_isfree(licp, i)) { |
1da177e4 LT |
282 | continue; |
283 | } | |
284 | ||
39dab9d7 | 285 | return xfs_lic_slot(licp, i); |
1da177e4 LT |
286 | } |
287 | ASSERT(0); | |
288 | /* NOTREACHED */ | |
289 | return NULL; /* keep gcc quite */ | |
290 | } | |
291 | ||
292 | /* | |
293 | * This is called to unlock all of the items of a transaction and to free | |
294 | * all the descriptors of that transaction. | |
295 | * | |
296 | * It walks the list of descriptors and unlocks each item. It frees | |
297 | * each chunk except that embedded in the transaction as it goes along. | |
298 | */ | |
299 | void | |
300 | xfs_trans_free_items( | |
301 | xfs_trans_t *tp, | |
302 | int flags) | |
303 | { | |
304 | xfs_log_item_chunk_t *licp; | |
305 | xfs_log_item_chunk_t *next_licp; | |
306 | int abort; | |
307 | ||
308 | abort = flags & XFS_TRANS_ABORT; | |
309 | licp = &tp->t_items; | |
310 | /* | |
311 | * Special case the embedded chunk so we don't free it below. | |
312 | */ | |
39dab9d7 | 313 | if (!xfs_lic_are_all_free(licp)) { |
1da177e4 | 314 | (void) xfs_trans_unlock_chunk(licp, 1, abort, NULLCOMMITLSN); |
39dab9d7 | 315 | xfs_lic_all_free(licp); |
1da177e4 LT |
316 | licp->lic_unused = 0; |
317 | } | |
318 | licp = licp->lic_next; | |
319 | ||
320 | /* | |
321 | * Unlock each item in each chunk and free the chunks. | |
322 | */ | |
323 | while (licp != NULL) { | |
39dab9d7 | 324 | ASSERT(!xfs_lic_are_all_free(licp)); |
1da177e4 LT |
325 | (void) xfs_trans_unlock_chunk(licp, 1, abort, NULLCOMMITLSN); |
326 | next_licp = licp->lic_next; | |
f0e2d93c | 327 | kmem_free(licp); |
1da177e4 LT |
328 | licp = next_licp; |
329 | } | |
330 | ||
331 | /* | |
332 | * Reset the transaction structure's free item count. | |
333 | */ | |
334 | tp->t_items_free = XFS_LIC_NUM_SLOTS; | |
335 | tp->t_items.lic_next = NULL; | |
336 | } | |
337 | ||
338 | ||
339 | ||
340 | /* | |
341 | * This is called to unlock the items associated with a transaction. | |
342 | * Items which were not logged should be freed. | |
343 | * Those which were logged must still be tracked so they can be unpinned | |
344 | * when the transaction commits. | |
345 | */ | |
346 | void | |
347 | xfs_trans_unlock_items(xfs_trans_t *tp, xfs_lsn_t commit_lsn) | |
348 | { | |
349 | xfs_log_item_chunk_t *licp; | |
350 | xfs_log_item_chunk_t *next_licp; | |
351 | xfs_log_item_chunk_t **licpp; | |
352 | int freed; | |
353 | ||
354 | freed = 0; | |
355 | licp = &tp->t_items; | |
356 | ||
357 | /* | |
358 | * Special case the embedded chunk so we don't free. | |
359 | */ | |
39dab9d7 | 360 | if (!xfs_lic_are_all_free(licp)) { |
1da177e4 LT |
361 | freed = xfs_trans_unlock_chunk(licp, 0, 0, commit_lsn); |
362 | } | |
363 | licpp = &(tp->t_items.lic_next); | |
364 | licp = licp->lic_next; | |
365 | ||
366 | /* | |
367 | * Unlock each item in each chunk, free non-dirty descriptors, | |
368 | * and free empty chunks. | |
369 | */ | |
370 | while (licp != NULL) { | |
39dab9d7 | 371 | ASSERT(!xfs_lic_are_all_free(licp)); |
1da177e4 LT |
372 | freed += xfs_trans_unlock_chunk(licp, 0, 0, commit_lsn); |
373 | next_licp = licp->lic_next; | |
39dab9d7 | 374 | if (xfs_lic_are_all_free(licp)) { |
1da177e4 | 375 | *licpp = next_licp; |
f0e2d93c | 376 | kmem_free(licp); |
1da177e4 LT |
377 | freed -= XFS_LIC_NUM_SLOTS; |
378 | } else { | |
379 | licpp = &(licp->lic_next); | |
380 | } | |
381 | ASSERT(*licpp == next_licp); | |
382 | licp = next_licp; | |
383 | } | |
384 | ||
385 | /* | |
386 | * Fix the free descriptor count in the transaction. | |
387 | */ | |
388 | tp->t_items_free += freed; | |
389 | } | |
390 | ||
391 | /* | |
392 | * Unlock each item pointed to by a descriptor in the given chunk. | |
393 | * Stamp the commit lsn into each item if necessary. | |
394 | * Free descriptors pointing to items which are not dirty if freeing_chunk | |
395 | * is zero. If freeing_chunk is non-zero, then we need to unlock all | |
396 | * items in the chunk. | |
397 | * | |
398 | * Return the number of descriptors freed. | |
399 | */ | |
400 | STATIC int | |
401 | xfs_trans_unlock_chunk( | |
402 | xfs_log_item_chunk_t *licp, | |
403 | int freeing_chunk, | |
404 | int abort, | |
405 | xfs_lsn_t commit_lsn) | |
406 | { | |
407 | xfs_log_item_desc_t *lidp; | |
408 | xfs_log_item_t *lip; | |
409 | int i; | |
410 | int freed; | |
411 | ||
412 | freed = 0; | |
413 | lidp = licp->lic_descs; | |
414 | for (i = 0; i < licp->lic_unused; i++, lidp++) { | |
39dab9d7 | 415 | if (xfs_lic_isfree(licp, i)) { |
1da177e4 LT |
416 | continue; |
417 | } | |
418 | lip = lidp->lid_item; | |
419 | lip->li_desc = NULL; | |
420 | ||
421 | if (commit_lsn != NULLCOMMITLSN) | |
422 | IOP_COMMITTING(lip, commit_lsn); | |
423 | if (abort) | |
424 | lip->li_flags |= XFS_LI_ABORTED; | |
425 | IOP_UNLOCK(lip); | |
426 | ||
427 | /* | |
428 | * Free the descriptor if the item is not dirty | |
429 | * within this transaction and the caller is not | |
430 | * going to just free the entire thing regardless. | |
431 | */ | |
432 | if (!(freeing_chunk) && | |
433 | (!(lidp->lid_flags & XFS_LID_DIRTY) || abort)) { | |
39dab9d7 | 434 | xfs_lic_relse(licp, i); |
1da177e4 LT |
435 | freed++; |
436 | } | |
437 | } | |
438 | ||
014c2544 | 439 | return freed; |
1da177e4 LT |
440 | } |
441 | ||
442 | ||
443 | /* | |
444 | * This is called to add the given busy item to the transaction's | |
445 | * list of busy items. It must find a free busy item descriptor | |
446 | * or allocate a new one and add the item to that descriptor. | |
447 | * The function returns a pointer to busy descriptor used to point | |
448 | * to the new busy entry. The log busy entry will now point to its new | |
449 | * descriptor with its ???? field. | |
450 | */ | |
451 | xfs_log_busy_slot_t * | |
452 | xfs_trans_add_busy(xfs_trans_t *tp, xfs_agnumber_t ag, xfs_extlen_t idx) | |
453 | { | |
454 | xfs_log_busy_chunk_t *lbcp; | |
455 | xfs_log_busy_slot_t *lbsp; | |
456 | int i=0; | |
457 | ||
458 | /* | |
459 | * If there are no free descriptors, allocate a new chunk | |
460 | * of them and put it at the front of the chunk list. | |
461 | */ | |
462 | if (tp->t_busy_free == 0) { | |
463 | lbcp = (xfs_log_busy_chunk_t*) | |
464 | kmem_alloc(sizeof(xfs_log_busy_chunk_t), KM_SLEEP); | |
465 | ASSERT(lbcp != NULL); | |
466 | /* | |
467 | * Initialize the chunk, and then | |
468 | * claim the first slot in the newly allocated chunk. | |
469 | */ | |
470 | XFS_LBC_INIT(lbcp); | |
471 | XFS_LBC_CLAIM(lbcp, 0); | |
472 | lbcp->lbc_unused = 1; | |
473 | lbsp = XFS_LBC_SLOT(lbcp, 0); | |
474 | ||
475 | /* | |
476 | * Link in the new chunk and update the free count. | |
477 | */ | |
478 | lbcp->lbc_next = tp->t_busy.lbc_next; | |
479 | tp->t_busy.lbc_next = lbcp; | |
480 | tp->t_busy_free = XFS_LIC_NUM_SLOTS - 1; | |
481 | ||
482 | /* | |
483 | * Initialize the descriptor and the generic portion | |
484 | * of the log item. | |
485 | * | |
486 | * Point the new slot at this item and return it. | |
487 | * Also point the log item at its currently active | |
488 | * descriptor and set the item's mount pointer. | |
489 | */ | |
490 | lbsp->lbc_ag = ag; | |
491 | lbsp->lbc_idx = idx; | |
014c2544 | 492 | return lbsp; |
1da177e4 LT |
493 | } |
494 | ||
495 | /* | |
496 | * Find the free descriptor. It is somewhere in the chunklist | |
497 | * of descriptors. | |
498 | */ | |
499 | lbcp = &tp->t_busy; | |
500 | while (lbcp != NULL) { | |
501 | if (XFS_LBC_VACANCY(lbcp)) { | |
502 | if (lbcp->lbc_unused <= XFS_LBC_MAX_SLOT) { | |
503 | i = lbcp->lbc_unused; | |
504 | break; | |
505 | } else { | |
506 | /* out-of-order vacancy */ | |
b6574520 | 507 | cmn_err(CE_DEBUG, "OOO vacancy lbcp 0x%p\n", lbcp); |
1da177e4 LT |
508 | ASSERT(0); |
509 | } | |
510 | } | |
511 | lbcp = lbcp->lbc_next; | |
512 | } | |
513 | ASSERT(lbcp != NULL); | |
514 | /* | |
515 | * If we find a free descriptor, claim it, | |
516 | * initialize it, and return it. | |
517 | */ | |
518 | XFS_LBC_CLAIM(lbcp, i); | |
519 | if (lbcp->lbc_unused <= i) { | |
520 | lbcp->lbc_unused = i + 1; | |
521 | } | |
522 | lbsp = XFS_LBC_SLOT(lbcp, i); | |
523 | tp->t_busy_free--; | |
524 | lbsp->lbc_ag = ag; | |
525 | lbsp->lbc_idx = idx; | |
014c2544 | 526 | return lbsp; |
1da177e4 LT |
527 | } |
528 | ||
529 | ||
530 | /* | |
531 | * xfs_trans_free_busy | |
532 | * Free all of the busy lists from a transaction | |
533 | */ | |
534 | void | |
535 | xfs_trans_free_busy(xfs_trans_t *tp) | |
536 | { | |
537 | xfs_log_busy_chunk_t *lbcp; | |
538 | xfs_log_busy_chunk_t *lbcq; | |
539 | ||
540 | lbcp = tp->t_busy.lbc_next; | |
541 | while (lbcp != NULL) { | |
542 | lbcq = lbcp->lbc_next; | |
f0e2d93c | 543 | kmem_free(lbcp); |
1da177e4 LT |
544 | lbcp = lbcq; |
545 | } | |
546 | ||
547 | XFS_LBC_INIT(&tp->t_busy); | |
548 | tp->t_busy.lbc_unused = 0; | |
549 | } |