ia64/linux-2.6.18-xen.hg

view fs/ocfs2/localalloc.c @ 524:7f8b544237bf

netfront: Allow netfront in domain 0.

This is useful if your physical network device is in a utility domain.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Tue Apr 15 15:18:58 2008 +0100 (2008-04-15)
parents 831230e53067
children
line source
1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
3 *
4 * localalloc.c
5 *
6 * Node local data allocation
7 *
8 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public
12 * License as published by the Free Software Foundation; either
13 * version 2 of the License, or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public
21 * License along with this program; if not, write to the
22 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23 * Boston, MA 021110-1307, USA.
24 */
26 #include <linux/fs.h>
27 #include <linux/types.h>
28 #include <linux/slab.h>
29 #include <linux/highmem.h>
30 #include <linux/bitops.h>
32 #define MLOG_MASK_PREFIX ML_DISK_ALLOC
33 #include <cluster/masklog.h>
35 #include "ocfs2.h"
37 #include "alloc.h"
38 #include "dlmglue.h"
39 #include "inode.h"
40 #include "journal.h"
41 #include "localalloc.h"
42 #include "suballoc.h"
43 #include "super.h"
44 #include "sysfile.h"
46 #include "buffer_head_io.h"
48 #define OCFS2_LOCAL_ALLOC(dinode) (&((dinode)->id2.i_lab))
50 static inline int ocfs2_local_alloc_window_bits(struct ocfs2_super *osb);
52 static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc);
54 static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb,
55 struct ocfs2_dinode *alloc,
56 u32 numbits);
58 static void ocfs2_clear_local_alloc(struct ocfs2_dinode *alloc);
60 static int ocfs2_sync_local_to_main(struct ocfs2_super *osb,
61 struct ocfs2_journal_handle *handle,
62 struct ocfs2_dinode *alloc,
63 struct inode *main_bm_inode,
64 struct buffer_head *main_bm_bh);
66 static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb,
67 struct ocfs2_journal_handle *handle,
68 struct ocfs2_alloc_context **ac,
69 struct inode **bitmap_inode,
70 struct buffer_head **bitmap_bh);
72 static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb,
73 struct ocfs2_journal_handle *handle,
74 struct ocfs2_alloc_context *ac);
76 static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,
77 struct inode *local_alloc_inode);
79 /*
80 * Determine how large our local alloc window should be, in bits.
81 *
82 * These values (and the behavior in ocfs2_alloc_should_use_local) have
83 * been chosen so that most allocations, including new block groups go
84 * through local alloc.
85 */
86 static inline int ocfs2_local_alloc_window_bits(struct ocfs2_super *osb)
87 {
88 BUG_ON(osb->s_clustersize_bits < 12);
90 return 2048 >> (osb->s_clustersize_bits - 12);
91 }
93 /*
94 * Tell us whether a given allocation should use the local alloc
95 * file. Otherwise, it has to go to the main bitmap.
96 */
97 int ocfs2_alloc_should_use_local(struct ocfs2_super *osb, u64 bits)
98 {
99 int la_bits = ocfs2_local_alloc_window_bits(osb);
101 if (osb->local_alloc_state != OCFS2_LA_ENABLED)
102 return 0;
104 /* la_bits should be at least twice the size (in clusters) of
105 * a new block group. We want to be sure block group
106 * allocations go through the local alloc, so allow an
107 * allocation to take up to half the bitmap. */
108 if (bits > (la_bits / 2))
109 return 0;
111 return 1;
112 }
114 int ocfs2_load_local_alloc(struct ocfs2_super *osb)
115 {
116 int status = 0;
117 struct ocfs2_dinode *alloc = NULL;
118 struct buffer_head *alloc_bh = NULL;
119 u32 num_used;
120 struct inode *inode = NULL;
121 struct ocfs2_local_alloc *la;
123 mlog_entry_void();
125 /* read the alloc off disk */
126 inode = ocfs2_get_system_file_inode(osb, LOCAL_ALLOC_SYSTEM_INODE,
127 osb->slot_num);
128 if (!inode) {
129 status = -EINVAL;
130 mlog_errno(status);
131 goto bail;
132 }
134 status = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno,
135 &alloc_bh, 0, inode);
136 if (status < 0) {
137 mlog_errno(status);
138 goto bail;
139 }
141 alloc = (struct ocfs2_dinode *) alloc_bh->b_data;
142 la = OCFS2_LOCAL_ALLOC(alloc);
144 if (!(le32_to_cpu(alloc->i_flags) &
145 (OCFS2_LOCAL_ALLOC_FL|OCFS2_BITMAP_FL))) {
146 mlog(ML_ERROR, "Invalid local alloc inode, %llu\n",
147 (unsigned long long)OCFS2_I(inode)->ip_blkno);
148 status = -EINVAL;
149 goto bail;
150 }
152 if ((la->la_size == 0) ||
153 (le16_to_cpu(la->la_size) > ocfs2_local_alloc_size(inode->i_sb))) {
154 mlog(ML_ERROR, "Local alloc size is invalid (la_size = %u)\n",
155 le16_to_cpu(la->la_size));
156 status = -EINVAL;
157 goto bail;
158 }
160 /* do a little verification. */
161 num_used = ocfs2_local_alloc_count_bits(alloc);
163 /* hopefully the local alloc has always been recovered before
164 * we load it. */
165 if (num_used
166 || alloc->id1.bitmap1.i_used
167 || alloc->id1.bitmap1.i_total
168 || la->la_bm_off)
169 mlog(ML_ERROR, "Local alloc hasn't been recovered!\n"
170 "found = %u, set = %u, taken = %u, off = %u\n",
171 num_used, le32_to_cpu(alloc->id1.bitmap1.i_used),
172 le32_to_cpu(alloc->id1.bitmap1.i_total),
173 OCFS2_LOCAL_ALLOC(alloc)->la_bm_off);
175 osb->local_alloc_bh = alloc_bh;
176 osb->local_alloc_state = OCFS2_LA_ENABLED;
178 bail:
179 if (status < 0)
180 if (alloc_bh)
181 brelse(alloc_bh);
182 if (inode)
183 iput(inode);
185 mlog_exit(status);
186 return status;
187 }
189 /*
190 * return any unused bits to the bitmap and write out a clean
191 * local_alloc.
192 *
193 * local_alloc_bh is optional. If not passed, we will simply use the
194 * one off osb. If you do pass it however, be warned that it *will* be
195 * returned brelse'd and NULL'd out.*/
196 void ocfs2_shutdown_local_alloc(struct ocfs2_super *osb)
197 {
198 int status;
199 struct ocfs2_journal_handle *handle = NULL;
200 struct inode *local_alloc_inode = NULL;
201 struct buffer_head *bh = NULL;
202 struct buffer_head *main_bm_bh = NULL;
203 struct inode *main_bm_inode = NULL;
204 struct ocfs2_dinode *alloc_copy = NULL;
205 struct ocfs2_dinode *alloc = NULL;
207 mlog_entry_void();
209 if (osb->local_alloc_state == OCFS2_LA_UNUSED)
210 goto bail;
212 local_alloc_inode =
213 ocfs2_get_system_file_inode(osb,
214 LOCAL_ALLOC_SYSTEM_INODE,
215 osb->slot_num);
216 if (!local_alloc_inode) {
217 status = -ENOENT;
218 mlog_errno(status);
219 goto bail;
220 }
222 osb->local_alloc_state = OCFS2_LA_DISABLED;
224 handle = ocfs2_alloc_handle(osb);
225 if (!handle) {
226 status = -ENOMEM;
227 mlog_errno(status);
228 goto bail;
229 }
231 main_bm_inode = ocfs2_get_system_file_inode(osb,
232 GLOBAL_BITMAP_SYSTEM_INODE,
233 OCFS2_INVALID_SLOT);
234 if (!main_bm_inode) {
235 status = -EINVAL;
236 mlog_errno(status);
237 goto bail;
238 }
240 ocfs2_handle_add_inode(handle, main_bm_inode);
241 status = ocfs2_meta_lock(main_bm_inode, handle, &main_bm_bh, 1);
242 if (status < 0) {
243 mlog_errno(status);
244 goto bail;
245 }
247 /* WINDOW_MOVE_CREDITS is a bit heavy... */
248 handle = ocfs2_start_trans(osb, handle, OCFS2_WINDOW_MOVE_CREDITS);
249 if (IS_ERR(handle)) {
250 mlog_errno(PTR_ERR(handle));
251 handle = NULL;
252 goto bail;
253 }
255 bh = osb->local_alloc_bh;
256 alloc = (struct ocfs2_dinode *) bh->b_data;
258 alloc_copy = kmalloc(bh->b_size, GFP_KERNEL);
259 if (!alloc_copy) {
260 status = -ENOMEM;
261 goto bail;
262 }
263 memcpy(alloc_copy, alloc, bh->b_size);
265 status = ocfs2_journal_access(handle, local_alloc_inode, bh,
266 OCFS2_JOURNAL_ACCESS_WRITE);
267 if (status < 0) {
268 mlog_errno(status);
269 goto bail;
270 }
272 ocfs2_clear_local_alloc(alloc);
274 status = ocfs2_journal_dirty(handle, bh);
275 if (status < 0) {
276 mlog_errno(status);
277 goto bail;
278 }
280 brelse(bh);
281 osb->local_alloc_bh = NULL;
282 osb->local_alloc_state = OCFS2_LA_UNUSED;
284 status = ocfs2_sync_local_to_main(osb, handle, alloc_copy,
285 main_bm_inode, main_bm_bh);
286 if (status < 0)
287 mlog_errno(status);
289 bail:
290 if (handle)
291 ocfs2_commit_trans(handle);
293 if (main_bm_bh)
294 brelse(main_bm_bh);
296 if (main_bm_inode)
297 iput(main_bm_inode);
299 if (local_alloc_inode)
300 iput(local_alloc_inode);
302 if (alloc_copy)
303 kfree(alloc_copy);
305 mlog_exit_void();
306 }
308 /*
309 * We want to free the bitmap bits outside of any recovery context as
310 * we'll need a cluster lock to do so, but we must clear the local
311 * alloc before giving up the recovered nodes journal. To solve this,
312 * we kmalloc a copy of the local alloc before it's change for the
313 * caller to process with ocfs2_complete_local_alloc_recovery
314 */
315 int ocfs2_begin_local_alloc_recovery(struct ocfs2_super *osb,
316 int slot_num,
317 struct ocfs2_dinode **alloc_copy)
318 {
319 int status = 0;
320 struct buffer_head *alloc_bh = NULL;
321 struct inode *inode = NULL;
322 struct ocfs2_dinode *alloc;
324 mlog_entry("(slot_num = %d)\n", slot_num);
326 *alloc_copy = NULL;
328 inode = ocfs2_get_system_file_inode(osb,
329 LOCAL_ALLOC_SYSTEM_INODE,
330 slot_num);
331 if (!inode) {
332 status = -EINVAL;
333 mlog_errno(status);
334 goto bail;
335 }
337 mutex_lock(&inode->i_mutex);
339 status = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno,
340 &alloc_bh, 0, inode);
341 if (status < 0) {
342 mlog_errno(status);
343 goto bail;
344 }
346 *alloc_copy = kmalloc(alloc_bh->b_size, GFP_KERNEL);
347 if (!(*alloc_copy)) {
348 status = -ENOMEM;
349 goto bail;
350 }
351 memcpy((*alloc_copy), alloc_bh->b_data, alloc_bh->b_size);
353 alloc = (struct ocfs2_dinode *) alloc_bh->b_data;
354 ocfs2_clear_local_alloc(alloc);
356 status = ocfs2_write_block(osb, alloc_bh, inode);
357 if (status < 0)
358 mlog_errno(status);
360 bail:
361 if ((status < 0) && (*alloc_copy)) {
362 kfree(*alloc_copy);
363 *alloc_copy = NULL;
364 }
366 if (alloc_bh)
367 brelse(alloc_bh);
369 if (inode) {
370 mutex_unlock(&inode->i_mutex);
371 iput(inode);
372 }
374 mlog_exit(status);
375 return status;
376 }
378 /*
379 * Step 2: By now, we've completed the journal recovery, we've stamped
380 * a clean local alloc on disk and dropped the node out of the
381 * recovery map. Dlm locks will no longer stall, so lets clear out the
382 * main bitmap.
383 */
384 int ocfs2_complete_local_alloc_recovery(struct ocfs2_super *osb,
385 struct ocfs2_dinode *alloc)
386 {
387 int status;
388 struct ocfs2_journal_handle *handle = NULL;
389 struct buffer_head *main_bm_bh = NULL;
390 struct inode *main_bm_inode = NULL;
392 mlog_entry_void();
394 handle = ocfs2_alloc_handle(osb);
395 if (!handle) {
396 status = -ENOMEM;
397 mlog_errno(status);
398 goto bail;
399 }
401 main_bm_inode = ocfs2_get_system_file_inode(osb,
402 GLOBAL_BITMAP_SYSTEM_INODE,
403 OCFS2_INVALID_SLOT);
404 if (!main_bm_inode) {
405 status = -EINVAL;
406 mlog_errno(status);
407 goto bail;
408 }
410 ocfs2_handle_add_inode(handle, main_bm_inode);
411 status = ocfs2_meta_lock(main_bm_inode, handle, &main_bm_bh, 1);
412 if (status < 0) {
413 mlog_errno(status);
414 goto bail;
415 }
417 handle = ocfs2_start_trans(osb, handle, OCFS2_WINDOW_MOVE_CREDITS);
418 if (IS_ERR(handle)) {
419 status = PTR_ERR(handle);
420 handle = NULL;
421 mlog_errno(status);
422 goto bail;
423 }
425 /* we want the bitmap change to be recorded on disk asap */
426 ocfs2_handle_set_sync(handle, 1);
428 status = ocfs2_sync_local_to_main(osb, handle, alloc,
429 main_bm_inode, main_bm_bh);
430 if (status < 0)
431 mlog_errno(status);
433 bail:
434 if (handle)
435 ocfs2_commit_trans(handle);
437 if (main_bm_bh)
438 brelse(main_bm_bh);
440 if (main_bm_inode)
441 iput(main_bm_inode);
443 mlog_exit(status);
444 return status;
445 }
447 /*
448 * make sure we've got at least bitswanted contiguous bits in the
449 * local alloc. You lose them when you drop i_mutex.
450 *
451 * We will add ourselves to the transaction passed in, but may start
452 * our own in order to shift windows.
453 */
454 int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb,
455 struct ocfs2_journal_handle *passed_handle,
456 u32 bits_wanted,
457 struct ocfs2_alloc_context *ac)
458 {
459 int status;
460 struct ocfs2_dinode *alloc;
461 struct inode *local_alloc_inode;
462 unsigned int free_bits;
464 mlog_entry_void();
466 BUG_ON(!passed_handle);
467 BUG_ON(!ac);
468 BUG_ON(passed_handle->flags & OCFS2_HANDLE_STARTED);
470 local_alloc_inode =
471 ocfs2_get_system_file_inode(osb,
472 LOCAL_ALLOC_SYSTEM_INODE,
473 osb->slot_num);
474 if (!local_alloc_inode) {
475 status = -ENOENT;
476 mlog_errno(status);
477 goto bail;
478 }
479 ocfs2_handle_add_inode(passed_handle, local_alloc_inode);
481 if (osb->local_alloc_state != OCFS2_LA_ENABLED) {
482 status = -ENOSPC;
483 goto bail;
484 }
486 if (bits_wanted > ocfs2_local_alloc_window_bits(osb)) {
487 mlog(0, "Asking for more than my max window size!\n");
488 status = -ENOSPC;
489 goto bail;
490 }
492 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
494 if (le32_to_cpu(alloc->id1.bitmap1.i_used) !=
495 ocfs2_local_alloc_count_bits(alloc)) {
496 ocfs2_error(osb->sb, "local alloc inode %llu says it has "
497 "%u free bits, but a count shows %u",
498 (unsigned long long)le64_to_cpu(alloc->i_blkno),
499 le32_to_cpu(alloc->id1.bitmap1.i_used),
500 ocfs2_local_alloc_count_bits(alloc));
501 status = -EIO;
502 goto bail;
503 }
505 free_bits = le32_to_cpu(alloc->id1.bitmap1.i_total) -
506 le32_to_cpu(alloc->id1.bitmap1.i_used);
507 if (bits_wanted > free_bits) {
508 /* uhoh, window change time. */
509 status =
510 ocfs2_local_alloc_slide_window(osb, local_alloc_inode);
511 if (status < 0) {
512 if (status != -ENOSPC)
513 mlog_errno(status);
514 goto bail;
515 }
516 }
518 ac->ac_inode = igrab(local_alloc_inode);
519 get_bh(osb->local_alloc_bh);
520 ac->ac_bh = osb->local_alloc_bh;
521 ac->ac_which = OCFS2_AC_USE_LOCAL;
522 status = 0;
523 bail:
524 if (local_alloc_inode)
525 iput(local_alloc_inode);
527 mlog_exit(status);
528 return status;
529 }
531 int ocfs2_claim_local_alloc_bits(struct ocfs2_super *osb,
532 struct ocfs2_journal_handle *handle,
533 struct ocfs2_alloc_context *ac,
534 u32 min_bits,
535 u32 *bit_off,
536 u32 *num_bits)
537 {
538 int status, start;
539 struct inode *local_alloc_inode;
540 u32 bits_wanted;
541 void *bitmap;
542 struct ocfs2_dinode *alloc;
543 struct ocfs2_local_alloc *la;
545 mlog_entry_void();
546 BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL);
548 bits_wanted = ac->ac_bits_wanted - ac->ac_bits_given;
549 local_alloc_inode = ac->ac_inode;
550 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
551 la = OCFS2_LOCAL_ALLOC(alloc);
553 start = ocfs2_local_alloc_find_clear_bits(osb, alloc, bits_wanted);
554 if (start == -1) {
555 /* TODO: Shouldn't we just BUG here? */
556 status = -ENOSPC;
557 mlog_errno(status);
558 goto bail;
559 }
561 bitmap = la->la_bitmap;
562 *bit_off = le32_to_cpu(la->la_bm_off) + start;
563 /* local alloc is always contiguous by nature -- we never
564 * delete bits from it! */
565 *num_bits = bits_wanted;
567 status = ocfs2_journal_access(handle, local_alloc_inode,
568 osb->local_alloc_bh,
569 OCFS2_JOURNAL_ACCESS_WRITE);
570 if (status < 0) {
571 mlog_errno(status);
572 goto bail;
573 }
575 while(bits_wanted--)
576 ocfs2_set_bit(start++, bitmap);
578 alloc->id1.bitmap1.i_used = cpu_to_le32(*num_bits +
579 le32_to_cpu(alloc->id1.bitmap1.i_used));
581 status = ocfs2_journal_dirty(handle, osb->local_alloc_bh);
582 if (status < 0) {
583 mlog_errno(status);
584 goto bail;
585 }
587 status = 0;
588 bail:
589 mlog_exit(status);
590 return status;
591 }
593 static u32 ocfs2_local_alloc_count_bits(struct ocfs2_dinode *alloc)
594 {
595 int i;
596 u8 *buffer;
597 u32 count = 0;
598 struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc);
600 mlog_entry_void();
602 buffer = la->la_bitmap;
603 for (i = 0; i < le16_to_cpu(la->la_size); i++)
604 count += hweight8(buffer[i]);
606 mlog_exit(count);
607 return count;
608 }
610 static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super *osb,
611 struct ocfs2_dinode *alloc,
612 u32 numbits)
613 {
614 int numfound, bitoff, left, startoff, lastzero;
615 void *bitmap = NULL;
617 mlog_entry("(numbits wanted = %u)\n", numbits);
619 if (!alloc->id1.bitmap1.i_total) {
620 mlog(0, "No bits in my window!\n");
621 bitoff = -1;
622 goto bail;
623 }
625 bitmap = OCFS2_LOCAL_ALLOC(alloc)->la_bitmap;
627 numfound = bitoff = startoff = 0;
628 lastzero = -1;
629 left = le32_to_cpu(alloc->id1.bitmap1.i_total);
630 while ((bitoff = ocfs2_find_next_zero_bit(bitmap, left, startoff)) != -1) {
631 if (bitoff == left) {
632 /* mlog(0, "bitoff (%d) == left", bitoff); */
633 break;
634 }
635 /* mlog(0, "Found a zero: bitoff = %d, startoff = %d, "
636 "numfound = %d\n", bitoff, startoff, numfound);*/
638 /* Ok, we found a zero bit... is it contig. or do we
639 * start over?*/
640 if (bitoff == startoff) {
641 /* we found a zero */
642 numfound++;
643 startoff++;
644 } else {
645 /* got a zero after some ones */
646 numfound = 1;
647 startoff = bitoff+1;
648 }
649 /* we got everything we needed */
650 if (numfound == numbits) {
651 /* mlog(0, "Found it all!\n"); */
652 break;
653 }
654 }
656 mlog(0, "Exiting loop, bitoff = %d, numfound = %d\n", bitoff,
657 numfound);
659 if (numfound == numbits)
660 bitoff = startoff - numfound;
661 else
662 bitoff = -1;
664 bail:
665 mlog_exit(bitoff);
666 return bitoff;
667 }
669 static void ocfs2_clear_local_alloc(struct ocfs2_dinode *alloc)
670 {
671 struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc);
672 int i;
673 mlog_entry_void();
675 alloc->id1.bitmap1.i_total = 0;
676 alloc->id1.bitmap1.i_used = 0;
677 la->la_bm_off = 0;
678 for(i = 0; i < le16_to_cpu(la->la_size); i++)
679 la->la_bitmap[i] = 0;
681 mlog_exit_void();
682 }
684 #if 0
685 /* turn this on and uncomment below to aid debugging window shifts. */
686 static void ocfs2_verify_zero_bits(unsigned long *bitmap,
687 unsigned int start,
688 unsigned int count)
689 {
690 unsigned int tmp = count;
691 while(tmp--) {
692 if (ocfs2_test_bit(start + tmp, bitmap)) {
693 printk("ocfs2_verify_zero_bits: start = %u, count = "
694 "%u\n", start, count);
695 printk("ocfs2_verify_zero_bits: bit %u is set!",
696 start + tmp);
697 BUG();
698 }
699 }
700 }
701 #endif
703 /*
704 * sync the local alloc to main bitmap.
705 *
706 * assumes you've already locked the main bitmap -- the bitmap inode
707 * passed is used for caching.
708 */
709 static int ocfs2_sync_local_to_main(struct ocfs2_super *osb,
710 struct ocfs2_journal_handle *handle,
711 struct ocfs2_dinode *alloc,
712 struct inode *main_bm_inode,
713 struct buffer_head *main_bm_bh)
714 {
715 int status = 0;
716 int bit_off, left, count, start;
717 u64 la_start_blk;
718 u64 blkno;
719 void *bitmap;
720 struct ocfs2_local_alloc *la = OCFS2_LOCAL_ALLOC(alloc);
722 mlog_entry("total = %u, COUNT = %u, used = %u\n",
723 le32_to_cpu(alloc->id1.bitmap1.i_total),
724 ocfs2_local_alloc_count_bits(alloc),
725 le32_to_cpu(alloc->id1.bitmap1.i_used));
727 if (!alloc->id1.bitmap1.i_total) {
728 mlog(0, "nothing to sync!\n");
729 goto bail;
730 }
732 if (le32_to_cpu(alloc->id1.bitmap1.i_used) ==
733 le32_to_cpu(alloc->id1.bitmap1.i_total)) {
734 mlog(0, "all bits were taken!\n");
735 goto bail;
736 }
738 la_start_blk = ocfs2_clusters_to_blocks(osb->sb,
739 le32_to_cpu(la->la_bm_off));
740 bitmap = la->la_bitmap;
741 start = count = bit_off = 0;
742 left = le32_to_cpu(alloc->id1.bitmap1.i_total);
744 while ((bit_off = ocfs2_find_next_zero_bit(bitmap, left, start))
745 != -1) {
746 if ((bit_off < left) && (bit_off == start)) {
747 count++;
748 start++;
749 continue;
750 }
751 if (count) {
752 blkno = la_start_blk +
753 ocfs2_clusters_to_blocks(osb->sb,
754 start - count);
756 mlog(0, "freeing %u bits starting at local alloc bit "
757 "%u (la_start_blk = %llu, blkno = %llu)\n",
758 count, start - count,
759 (unsigned long long)la_start_blk,
760 (unsigned long long)blkno);
762 status = ocfs2_free_clusters(handle, main_bm_inode,
763 main_bm_bh, blkno, count);
764 if (status < 0) {
765 mlog_errno(status);
766 goto bail;
767 }
768 }
769 if (bit_off >= left)
770 break;
771 count = 1;
772 start = bit_off + 1;
773 }
775 bail:
776 mlog_exit(status);
777 return status;
778 }
780 static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super *osb,
781 struct ocfs2_journal_handle *handle,
782 struct ocfs2_alloc_context **ac,
783 struct inode **bitmap_inode,
784 struct buffer_head **bitmap_bh)
785 {
786 int status;
788 *ac = kcalloc(1, sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
789 if (!(*ac)) {
790 status = -ENOMEM;
791 mlog_errno(status);
792 goto bail;
793 }
795 (*ac)->ac_handle = handle;
796 (*ac)->ac_bits_wanted = ocfs2_local_alloc_window_bits(osb);
798 status = ocfs2_reserve_cluster_bitmap_bits(osb, *ac);
799 if (status < 0) {
800 if (status != -ENOSPC)
801 mlog_errno(status);
802 goto bail;
803 }
805 *bitmap_inode = (*ac)->ac_inode;
806 igrab(*bitmap_inode);
807 *bitmap_bh = (*ac)->ac_bh;
808 get_bh(*bitmap_bh);
809 status = 0;
810 bail:
811 if ((status < 0) && *ac) {
812 ocfs2_free_alloc_context(*ac);
813 *ac = NULL;
814 }
816 mlog_exit(status);
817 return status;
818 }
820 /*
821 * pass it the bitmap lock in lock_bh if you have it.
822 */
823 static int ocfs2_local_alloc_new_window(struct ocfs2_super *osb,
824 struct ocfs2_journal_handle *handle,
825 struct ocfs2_alloc_context *ac)
826 {
827 int status = 0;
828 u32 cluster_off, cluster_count;
829 struct ocfs2_dinode *alloc = NULL;
830 struct ocfs2_local_alloc *la;
832 mlog_entry_void();
834 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
835 la = OCFS2_LOCAL_ALLOC(alloc);
837 if (alloc->id1.bitmap1.i_total)
838 mlog(0, "asking me to alloc a new window over a non-empty "
839 "one\n");
841 mlog(0, "Allocating %u clusters for a new window.\n",
842 ocfs2_local_alloc_window_bits(osb));
844 /* Instruct the allocation code to try the most recently used
845 * cluster group. We'll re-record the group used this pass
846 * below. */
847 ac->ac_last_group = osb->la_last_gd;
849 /* we used the generic suballoc reserve function, but we set
850 * everything up nicely, so there's no reason why we can't use
851 * the more specific cluster api to claim bits. */
852 status = ocfs2_claim_clusters(osb, handle, ac,
853 ocfs2_local_alloc_window_bits(osb),
854 &cluster_off, &cluster_count);
855 if (status < 0) {
856 if (status != -ENOSPC)
857 mlog_errno(status);
858 goto bail;
859 }
861 osb->la_last_gd = ac->ac_last_group;
863 la->la_bm_off = cpu_to_le32(cluster_off);
864 alloc->id1.bitmap1.i_total = cpu_to_le32(cluster_count);
865 /* just in case... In the future when we find space ourselves,
866 * we don't have to get all contiguous -- but we'll have to
867 * set all previously used bits in bitmap and update
868 * la_bits_set before setting the bits in the main bitmap. */
869 alloc->id1.bitmap1.i_used = 0;
870 memset(OCFS2_LOCAL_ALLOC(alloc)->la_bitmap, 0,
871 le16_to_cpu(la->la_size));
873 mlog(0, "New window allocated:\n");
874 mlog(0, "window la_bm_off = %u\n",
875 OCFS2_LOCAL_ALLOC(alloc)->la_bm_off);
876 mlog(0, "window bits = %u\n", le32_to_cpu(alloc->id1.bitmap1.i_total));
878 bail:
879 mlog_exit(status);
880 return status;
881 }
883 /* Note that we do *NOT* lock the local alloc inode here as
884 * it's been locked already for us. */
885 static int ocfs2_local_alloc_slide_window(struct ocfs2_super *osb,
886 struct inode *local_alloc_inode)
887 {
888 int status = 0;
889 struct buffer_head *main_bm_bh = NULL;
890 struct inode *main_bm_inode = NULL;
891 struct ocfs2_journal_handle *handle = NULL;
892 struct ocfs2_dinode *alloc;
893 struct ocfs2_dinode *alloc_copy = NULL;
894 struct ocfs2_alloc_context *ac = NULL;
896 mlog_entry_void();
898 handle = ocfs2_alloc_handle(osb);
899 if (!handle) {
900 status = -ENOMEM;
901 mlog_errno(status);
902 goto bail;
903 }
905 /* This will lock the main bitmap for us. */
906 status = ocfs2_local_alloc_reserve_for_window(osb,
907 handle,
908 &ac,
909 &main_bm_inode,
910 &main_bm_bh);
911 if (status < 0) {
912 if (status != -ENOSPC)
913 mlog_errno(status);
914 goto bail;
915 }
917 handle = ocfs2_start_trans(osb, handle, OCFS2_WINDOW_MOVE_CREDITS);
918 if (IS_ERR(handle)) {
919 status = PTR_ERR(handle);
920 handle = NULL;
921 mlog_errno(status);
922 goto bail;
923 }
925 alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
927 /* We want to clear the local alloc before doing anything
928 * else, so that if we error later during this operation,
929 * local alloc shutdown won't try to double free main bitmap
930 * bits. Make a copy so the sync function knows which bits to
931 * free. */
932 alloc_copy = kmalloc(osb->local_alloc_bh->b_size, GFP_KERNEL);
933 if (!alloc_copy) {
934 status = -ENOMEM;
935 mlog_errno(status);
936 goto bail;
937 }
938 memcpy(alloc_copy, alloc, osb->local_alloc_bh->b_size);
940 status = ocfs2_journal_access(handle, local_alloc_inode,
941 osb->local_alloc_bh,
942 OCFS2_JOURNAL_ACCESS_WRITE);
943 if (status < 0) {
944 mlog_errno(status);
945 goto bail;
946 }
948 ocfs2_clear_local_alloc(alloc);
950 status = ocfs2_journal_dirty(handle, osb->local_alloc_bh);
951 if (status < 0) {
952 mlog_errno(status);
953 goto bail;
954 }
956 status = ocfs2_sync_local_to_main(osb, handle, alloc_copy,
957 main_bm_inode, main_bm_bh);
958 if (status < 0) {
959 mlog_errno(status);
960 goto bail;
961 }
963 status = ocfs2_local_alloc_new_window(osb, handle, ac);
964 if (status < 0) {
965 if (status != -ENOSPC)
966 mlog_errno(status);
967 goto bail;
968 }
970 atomic_inc(&osb->alloc_stats.moves);
972 status = 0;
973 bail:
974 if (handle)
975 ocfs2_commit_trans(handle);
977 if (main_bm_bh)
978 brelse(main_bm_bh);
980 if (main_bm_inode)
981 iput(main_bm_inode);
983 if (alloc_copy)
984 kfree(alloc_copy);
986 if (ac)
987 ocfs2_free_alloc_context(ac);
989 mlog_exit(status);
990 return status;
991 }