eb3fc57f9eef681d73e39e07e3546cb45c350929
[linux-2.6.git] / fs / xfs / xfs_trans_item.c
1 /*
2  * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18 #include "xfs.h"
19 #include "xfs_fs.h"
20 #include "xfs_types.h"
21 #include "xfs_log.h"
22 #include "xfs_inum.h"
23 #include "xfs_trans.h"
24 #include "xfs_trans_priv.h"
25 /* XXX: from here down needed until struct xfs_trans has its own ailp */
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"
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                  */
64                 xfs_lic_init(licp);
65                 xfs_lic_claim(licp, 0);
66                 licp->lic_unused = 1;
67                 xfs_lic_init_slot(licp, 0);
68                 lidp = xfs_lic_slot(licp, 0);
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;
90                 lip->li_ailp = tp->t_mountp->m_ail;
91                 return lidp;
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) {
100                 if (xfs_lic_vacancy(licp)) {
101                         if (licp->lic_unused <= XFS_LIC_MAX_SLOT) {
102                                 i = licp->lic_unused;
103                                 ASSERT(xfs_lic_isfree(licp, i));
104                                 break;
105                         }
106                         for (i = 0; i <= XFS_LIC_MAX_SLOT; i++) {
107                                 if (xfs_lic_isfree(licp, i))
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          */
120         xfs_lic_claim(licp, i);
121         if (licp->lic_unused <= i) {
122                 licp->lic_unused = i + 1;
123                 xfs_lic_init_slot(licp, i);
124         }
125         lidp = xfs_lic_slot(licp, i);
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;
132         lip->li_ailp = tp->t_mountp->m_ail;
133         return lidp;
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
149         slot = xfs_lic_desc_to_slot(lidp);
150         licp = xfs_lic_desc_to_chunk(lidp);
151         xfs_lic_relse(licp, slot);
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          */
167         if (xfs_lic_are_all_free(licp) && (licp != &(tp->t_items))) {
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;
174                 kmem_free(licp);
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
194         return lip->li_desc;
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          */
220         if (xfs_lic_are_all_free(licp)) {
221                 licp = licp->lic_next;
222         }
223
224         /*
225          * Return the first non-free descriptor in the chunk.
226          */
227         ASSERT(!xfs_lic_are_all_free(licp));
228         for (i = 0; i < licp->lic_unused; i++) {
229                 if (xfs_lic_isfree(licp, i)) {
230                         continue;
231                 }
232
233                 return xfs_lic_slot(licp, i);
234         }
235         cmn_err(CE_WARN, "xfs_trans_first_item() -- no first item");
236         return NULL;
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
255         licp = xfs_lic_desc_to_chunk(lidp);
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          */
261         for (i = (int)xfs_lic_desc_to_slot(lidp) + 1; i < licp->lic_unused; i++) {
262                 if (xfs_lic_isfree(licp, i)) {
263                         continue;
264                 }
265
266                 return xfs_lic_slot(licp, i);
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) {
275                 return NULL;
276         }
277
278         licp = licp->lic_next;
279         ASSERT(!xfs_lic_are_all_free(licp));
280         for (i = 0; i < licp->lic_unused; i++) {
281                 if (xfs_lic_isfree(licp, i)) {
282                         continue;
283                 }
284
285                 return xfs_lic_slot(licp, i);
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          */
313         if (!xfs_lic_are_all_free(licp)) {
314                 (void) xfs_trans_unlock_chunk(licp, 1, abort, NULLCOMMITLSN);
315                 xfs_lic_all_free(licp);
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) {
324                 ASSERT(!xfs_lic_are_all_free(licp));
325                 (void) xfs_trans_unlock_chunk(licp, 1, abort, NULLCOMMITLSN);
326                 next_licp = licp->lic_next;
327                 kmem_free(licp);
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          */
360         if (!xfs_lic_are_all_free(licp)) {
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) {
371                 ASSERT(!xfs_lic_are_all_free(licp));
372                 freed += xfs_trans_unlock_chunk(licp, 0, 0, commit_lsn);
373                 next_licp = licp->lic_next;
374                 if (xfs_lic_are_all_free(licp)) {
375                         *licpp = next_licp;
376                         kmem_free(licp);
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++) {
415                 if (xfs_lic_isfree(licp, i)) {
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)) {
434                         xfs_lic_relse(licp, i);
435                         freed++;
436                 }
437         }
438
439         return freed;
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;
492                 return lbsp;
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 */
507                                 cmn_err(CE_DEBUG, "OOO vacancy lbcp 0x%p\n", lbcp);
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;
526         return lbsp;
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;
543                 kmem_free(lbcp);
544                 lbcp = lbcq;
545         }
546
547         XFS_LBC_INIT(&tp->t_busy);
548         tp->t_busy.lbc_unused = 0;
549 }