1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
6 * Node local data allocation
8 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
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.
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.
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.
27 #include <linux/types.h>
28 #include <linux/slab.h>
29 #include <linux/highmem.h>
30 #include <linux/bitops.h>
31 #include <linux/debugfs.h>
33 #define MLOG_MASK_PREFIX ML_DISK_ALLOC
34 #include <cluster/masklog.h>
42 #include "localalloc.h"
47 #include "buffer_head_io.h"
49 #define OCFS2_LOCAL_ALLOC(dinode) (&((dinode)->id2.i_lab))
51 static u32
ocfs2_local_alloc_count_bits(struct ocfs2_dinode
*alloc
);
53 static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super
*osb
,
54 struct ocfs2_dinode
*alloc
,
57 static void ocfs2_clear_local_alloc(struct ocfs2_dinode
*alloc
);
59 static int ocfs2_sync_local_to_main(struct ocfs2_super
*osb
,
61 struct ocfs2_dinode
*alloc
,
62 struct inode
*main_bm_inode
,
63 struct buffer_head
*main_bm_bh
);
65 static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super
*osb
,
66 struct ocfs2_alloc_context
**ac
,
67 struct inode
**bitmap_inode
,
68 struct buffer_head
**bitmap_bh
);
70 static int ocfs2_local_alloc_new_window(struct ocfs2_super
*osb
,
72 struct ocfs2_alloc_context
*ac
);
74 static int ocfs2_local_alloc_slide_window(struct ocfs2_super
*osb
,
75 struct inode
*local_alloc_inode
);
77 #ifdef CONFIG_OCFS2_FS_STATS
79 DEFINE_MUTEX(la_debug_mutex
);
81 static int ocfs2_la_debug_open(struct inode
*inode
, struct file
*file
)
83 file
->private_data
= inode
->i_private
;
87 #define LA_DEBUG_BUF_SZ PAGE_CACHE_SIZE
88 #define LA_DEBUG_VER 1
89 static ssize_t
ocfs2_la_debug_read(struct file
*file
, char __user
*userbuf
,
90 size_t count
, loff_t
*ppos
)
92 struct ocfs2_super
*osb
= file
->private_data
;
94 char *buf
= osb
->local_alloc_debug_buf
;
96 mutex_lock(&la_debug_mutex
);
97 memset(buf
, 0, LA_DEBUG_BUF_SZ
);
99 written
= snprintf(buf
, LA_DEBUG_BUF_SZ
,
100 "0x%x\t0x%llx\t%u\t%u\t0x%x\n",
102 (unsigned long long)osb
->la_last_gd
,
103 osb
->local_alloc_default_bits
,
104 osb
->local_alloc_bits
, osb
->local_alloc_state
);
106 ret
= simple_read_from_buffer(userbuf
, count
, ppos
, buf
, written
);
108 mutex_unlock(&la_debug_mutex
);
112 static const struct file_operations ocfs2_la_debug_fops
= {
113 .open
= ocfs2_la_debug_open
,
114 .read
= ocfs2_la_debug_read
,
117 static void ocfs2_init_la_debug(struct ocfs2_super
*osb
)
119 osb
->local_alloc_debug_buf
= kmalloc(LA_DEBUG_BUF_SZ
, GFP_NOFS
);
120 if (!osb
->local_alloc_debug_buf
)
123 osb
->local_alloc_debug
= debugfs_create_file("local_alloc_stats",
127 &ocfs2_la_debug_fops
);
128 if (!osb
->local_alloc_debug
) {
129 kfree(osb
->local_alloc_debug_buf
);
130 osb
->local_alloc_debug_buf
= NULL
;
134 static void ocfs2_shutdown_la_debug(struct ocfs2_super
*osb
)
136 if (osb
->local_alloc_debug
)
137 debugfs_remove(osb
->local_alloc_debug
);
139 if (osb
->local_alloc_debug_buf
)
140 kfree(osb
->local_alloc_debug_buf
);
142 osb
->local_alloc_debug_buf
= NULL
;
143 osb
->local_alloc_debug
= NULL
;
145 #else /* CONFIG_OCFS2_FS_STATS */
146 static void ocfs2_init_la_debug(struct ocfs2_super
*osb
)
150 static void ocfs2_shutdown_la_debug(struct ocfs2_super
*osb
)
156 static inline int ocfs2_la_state_enabled(struct ocfs2_super
*osb
)
158 return (osb
->local_alloc_state
== OCFS2_LA_THROTTLED
||
159 osb
->local_alloc_state
== OCFS2_LA_ENABLED
);
162 void ocfs2_local_alloc_seen_free_bits(struct ocfs2_super
*osb
,
163 unsigned int num_clusters
)
165 spin_lock(&osb
->osb_lock
);
166 if (osb
->local_alloc_state
== OCFS2_LA_DISABLED
||
167 osb
->local_alloc_state
== OCFS2_LA_THROTTLED
)
168 if (num_clusters
>= osb
->local_alloc_default_bits
) {
169 cancel_delayed_work(&osb
->la_enable_wq
);
170 osb
->local_alloc_state
= OCFS2_LA_ENABLED
;
172 spin_unlock(&osb
->osb_lock
);
175 void ocfs2_la_enable_worker(struct work_struct
*work
)
177 struct ocfs2_super
*osb
=
178 container_of(work
, struct ocfs2_super
,
180 spin_lock(&osb
->osb_lock
);
181 osb
->local_alloc_state
= OCFS2_LA_ENABLED
;
182 spin_unlock(&osb
->osb_lock
);
186 * Tell us whether a given allocation should use the local alloc
187 * file. Otherwise, it has to go to the main bitmap.
189 * This function does semi-dirty reads of local alloc size and state!
190 * This is ok however, as the values are re-checked once under mutex.
192 int ocfs2_alloc_should_use_local(struct ocfs2_super
*osb
, u64 bits
)
197 spin_lock(&osb
->osb_lock
);
198 la_bits
= osb
->local_alloc_bits
;
200 if (!ocfs2_la_state_enabled(osb
))
203 /* la_bits should be at least twice the size (in clusters) of
204 * a new block group. We want to be sure block group
205 * allocations go through the local alloc, so allow an
206 * allocation to take up to half the bitmap. */
207 if (bits
> (la_bits
/ 2))
212 mlog(0, "state=%d, bits=%llu, la_bits=%d, ret=%d\n",
213 osb
->local_alloc_state
, (unsigned long long)bits
, la_bits
, ret
);
214 spin_unlock(&osb
->osb_lock
);
218 int ocfs2_load_local_alloc(struct ocfs2_super
*osb
)
221 struct ocfs2_dinode
*alloc
= NULL
;
222 struct buffer_head
*alloc_bh
= NULL
;
224 struct inode
*inode
= NULL
;
225 struct ocfs2_local_alloc
*la
;
229 ocfs2_init_la_debug(osb
);
231 if (osb
->local_alloc_bits
== 0)
234 if (osb
->local_alloc_bits
>= osb
->bitmap_cpg
) {
235 mlog(ML_NOTICE
, "Requested local alloc window %d is larger "
236 "than max possible %u. Using defaults.\n",
237 osb
->local_alloc_bits
, (osb
->bitmap_cpg
- 1));
238 osb
->local_alloc_bits
=
239 ocfs2_megabytes_to_clusters(osb
->sb
,
240 OCFS2_DEFAULT_LOCAL_ALLOC_SIZE
);
243 /* read the alloc off disk */
244 inode
= ocfs2_get_system_file_inode(osb
, LOCAL_ALLOC_SYSTEM_INODE
,
252 status
= ocfs2_read_block(osb
, OCFS2_I(inode
)->ip_blkno
,
253 &alloc_bh
, 0, inode
);
259 alloc
= (struct ocfs2_dinode
*) alloc_bh
->b_data
;
260 la
= OCFS2_LOCAL_ALLOC(alloc
);
262 if (!(le32_to_cpu(alloc
->i_flags
) &
263 (OCFS2_LOCAL_ALLOC_FL
|OCFS2_BITMAP_FL
))) {
264 mlog(ML_ERROR
, "Invalid local alloc inode, %llu\n",
265 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
270 if ((la
->la_size
== 0) ||
271 (le16_to_cpu(la
->la_size
) > ocfs2_local_alloc_size(inode
->i_sb
))) {
272 mlog(ML_ERROR
, "Local alloc size is invalid (la_size = %u)\n",
273 le16_to_cpu(la
->la_size
));
278 /* do a little verification. */
279 num_used
= ocfs2_local_alloc_count_bits(alloc
);
281 /* hopefully the local alloc has always been recovered before
284 || alloc
->id1
.bitmap1
.i_used
285 || alloc
->id1
.bitmap1
.i_total
287 mlog(ML_ERROR
, "Local alloc hasn't been recovered!\n"
288 "found = %u, set = %u, taken = %u, off = %u\n",
289 num_used
, le32_to_cpu(alloc
->id1
.bitmap1
.i_used
),
290 le32_to_cpu(alloc
->id1
.bitmap1
.i_total
),
291 OCFS2_LOCAL_ALLOC(alloc
)->la_bm_off
);
293 osb
->local_alloc_bh
= alloc_bh
;
294 osb
->local_alloc_state
= OCFS2_LA_ENABLED
;
304 ocfs2_shutdown_la_debug(osb
);
306 mlog(0, "Local alloc window bits = %d\n", osb
->local_alloc_bits
);
313 * return any unused bits to the bitmap and write out a clean
316 * local_alloc_bh is optional. If not passed, we will simply use the
317 * one off osb. If you do pass it however, be warned that it *will* be
318 * returned brelse'd and NULL'd out.*/
319 void ocfs2_shutdown_local_alloc(struct ocfs2_super
*osb
)
323 struct inode
*local_alloc_inode
= NULL
;
324 struct buffer_head
*bh
= NULL
;
325 struct buffer_head
*main_bm_bh
= NULL
;
326 struct inode
*main_bm_inode
= NULL
;
327 struct ocfs2_dinode
*alloc_copy
= NULL
;
328 struct ocfs2_dinode
*alloc
= NULL
;
332 cancel_delayed_work(&osb
->la_enable_wq
);
333 flush_workqueue(ocfs2_wq
);
335 ocfs2_shutdown_la_debug(osb
);
337 if (osb
->local_alloc_state
== OCFS2_LA_UNUSED
)
341 ocfs2_get_system_file_inode(osb
,
342 LOCAL_ALLOC_SYSTEM_INODE
,
344 if (!local_alloc_inode
) {
350 osb
->local_alloc_state
= OCFS2_LA_DISABLED
;
352 main_bm_inode
= ocfs2_get_system_file_inode(osb
,
353 GLOBAL_BITMAP_SYSTEM_INODE
,
355 if (!main_bm_inode
) {
361 mutex_lock(&main_bm_inode
->i_mutex
);
363 status
= ocfs2_inode_lock(main_bm_inode
, &main_bm_bh
, 1);
369 /* WINDOW_MOVE_CREDITS is a bit heavy... */
370 handle
= ocfs2_start_trans(osb
, OCFS2_WINDOW_MOVE_CREDITS
);
371 if (IS_ERR(handle
)) {
372 mlog_errno(PTR_ERR(handle
));
377 bh
= osb
->local_alloc_bh
;
378 alloc
= (struct ocfs2_dinode
*) bh
->b_data
;
380 alloc_copy
= kmalloc(bh
->b_size
, GFP_NOFS
);
385 memcpy(alloc_copy
, alloc
, bh
->b_size
);
387 status
= ocfs2_journal_access(handle
, local_alloc_inode
, bh
,
388 OCFS2_JOURNAL_ACCESS_WRITE
);
394 ocfs2_clear_local_alloc(alloc
);
396 status
= ocfs2_journal_dirty(handle
, bh
);
403 osb
->local_alloc_bh
= NULL
;
404 osb
->local_alloc_state
= OCFS2_LA_UNUSED
;
406 status
= ocfs2_sync_local_to_main(osb
, handle
, alloc_copy
,
407 main_bm_inode
, main_bm_bh
);
412 ocfs2_commit_trans(osb
, handle
);
418 ocfs2_inode_unlock(main_bm_inode
, 1);
421 mutex_unlock(&main_bm_inode
->i_mutex
);
425 if (local_alloc_inode
)
426 iput(local_alloc_inode
);
435 * We want to free the bitmap bits outside of any recovery context as
436 * we'll need a cluster lock to do so, but we must clear the local
437 * alloc before giving up the recovered nodes journal. To solve this,
438 * we kmalloc a copy of the local alloc before it's change for the
439 * caller to process with ocfs2_complete_local_alloc_recovery
441 int ocfs2_begin_local_alloc_recovery(struct ocfs2_super
*osb
,
443 struct ocfs2_dinode
**alloc_copy
)
446 struct buffer_head
*alloc_bh
= NULL
;
447 struct inode
*inode
= NULL
;
448 struct ocfs2_dinode
*alloc
;
450 mlog_entry("(slot_num = %d)\n", slot_num
);
454 inode
= ocfs2_get_system_file_inode(osb
,
455 LOCAL_ALLOC_SYSTEM_INODE
,
463 mutex_lock(&inode
->i_mutex
);
465 status
= ocfs2_read_block(osb
, OCFS2_I(inode
)->ip_blkno
,
466 &alloc_bh
, 0, inode
);
472 *alloc_copy
= kmalloc(alloc_bh
->b_size
, GFP_KERNEL
);
473 if (!(*alloc_copy
)) {
477 memcpy((*alloc_copy
), alloc_bh
->b_data
, alloc_bh
->b_size
);
479 alloc
= (struct ocfs2_dinode
*) alloc_bh
->b_data
;
480 ocfs2_clear_local_alloc(alloc
);
482 status
= ocfs2_write_block(osb
, alloc_bh
, inode
);
487 if ((status
< 0) && (*alloc_copy
)) {
496 mutex_unlock(&inode
->i_mutex
);
505 * Step 2: By now, we've completed the journal recovery, we've stamped
506 * a clean local alloc on disk and dropped the node out of the
507 * recovery map. Dlm locks will no longer stall, so lets clear out the
510 int ocfs2_complete_local_alloc_recovery(struct ocfs2_super
*osb
,
511 struct ocfs2_dinode
*alloc
)
515 struct buffer_head
*main_bm_bh
= NULL
;
516 struct inode
*main_bm_inode
;
520 main_bm_inode
= ocfs2_get_system_file_inode(osb
,
521 GLOBAL_BITMAP_SYSTEM_INODE
,
523 if (!main_bm_inode
) {
529 mutex_lock(&main_bm_inode
->i_mutex
);
531 status
= ocfs2_inode_lock(main_bm_inode
, &main_bm_bh
, 1);
537 handle
= ocfs2_start_trans(osb
, OCFS2_WINDOW_MOVE_CREDITS
);
538 if (IS_ERR(handle
)) {
539 status
= PTR_ERR(handle
);
545 /* we want the bitmap change to be recorded on disk asap */
548 status
= ocfs2_sync_local_to_main(osb
, handle
, alloc
,
549 main_bm_inode
, main_bm_bh
);
553 ocfs2_commit_trans(osb
, handle
);
556 ocfs2_inode_unlock(main_bm_inode
, 1);
559 mutex_unlock(&main_bm_inode
->i_mutex
);
568 ocfs2_init_inode_steal_slot(osb
);
574 * make sure we've got at least bits_wanted contiguous bits in the
575 * local alloc. You lose them when you drop i_mutex.
577 * We will add ourselves to the transaction passed in, but may start
578 * our own in order to shift windows.
580 int ocfs2_reserve_local_alloc_bits(struct ocfs2_super
*osb
,
582 struct ocfs2_alloc_context
*ac
)
585 struct ocfs2_dinode
*alloc
;
586 struct inode
*local_alloc_inode
;
587 unsigned int free_bits
;
594 ocfs2_get_system_file_inode(osb
,
595 LOCAL_ALLOC_SYSTEM_INODE
,
597 if (!local_alloc_inode
) {
603 mutex_lock(&local_alloc_inode
->i_mutex
);
606 * We must double check state and allocator bits because
607 * another process may have changed them while holding i_mutex.
609 spin_lock(&osb
->osb_lock
);
610 if (!ocfs2_la_state_enabled(osb
) ||
611 (bits_wanted
> osb
->local_alloc_bits
)) {
612 spin_unlock(&osb
->osb_lock
);
616 spin_unlock(&osb
->osb_lock
);
618 alloc
= (struct ocfs2_dinode
*) osb
->local_alloc_bh
->b_data
;
620 #ifdef CONFIG_OCFS2_DEBUG_FS
621 if (le32_to_cpu(alloc
->id1
.bitmap1
.i_used
) !=
622 ocfs2_local_alloc_count_bits(alloc
)) {
623 ocfs2_error(osb
->sb
, "local alloc inode %llu says it has "
624 "%u free bits, but a count shows %u",
625 (unsigned long long)le64_to_cpu(alloc
->i_blkno
),
626 le32_to_cpu(alloc
->id1
.bitmap1
.i_used
),
627 ocfs2_local_alloc_count_bits(alloc
));
633 free_bits
= le32_to_cpu(alloc
->id1
.bitmap1
.i_total
) -
634 le32_to_cpu(alloc
->id1
.bitmap1
.i_used
);
635 if (bits_wanted
> free_bits
) {
636 /* uhoh, window change time. */
638 ocfs2_local_alloc_slide_window(osb
, local_alloc_inode
);
640 if (status
!= -ENOSPC
)
646 * Under certain conditions, the window slide code
647 * might have reduced the number of bits available or
648 * disabled the the local alloc entirely. Re-check
649 * here and return -ENOSPC if necessary.
652 if (!ocfs2_la_state_enabled(osb
))
655 free_bits
= le32_to_cpu(alloc
->id1
.bitmap1
.i_total
) -
656 le32_to_cpu(alloc
->id1
.bitmap1
.i_used
);
657 if (bits_wanted
> free_bits
)
661 ac
->ac_inode
= local_alloc_inode
;
662 /* We should never use localalloc from another slot */
663 ac
->ac_alloc_slot
= osb
->slot_num
;
664 ac
->ac_which
= OCFS2_AC_USE_LOCAL
;
665 get_bh(osb
->local_alloc_bh
);
666 ac
->ac_bh
= osb
->local_alloc_bh
;
669 if (status
< 0 && local_alloc_inode
) {
670 mutex_unlock(&local_alloc_inode
->i_mutex
);
671 iput(local_alloc_inode
);
674 mlog(0, "bits=%d, slot=%d, ret=%d\n", bits_wanted
, osb
->slot_num
,
681 int ocfs2_claim_local_alloc_bits(struct ocfs2_super
*osb
,
683 struct ocfs2_alloc_context
*ac
,
689 struct inode
*local_alloc_inode
;
691 struct ocfs2_dinode
*alloc
;
692 struct ocfs2_local_alloc
*la
;
695 BUG_ON(ac
->ac_which
!= OCFS2_AC_USE_LOCAL
);
697 local_alloc_inode
= ac
->ac_inode
;
698 alloc
= (struct ocfs2_dinode
*) osb
->local_alloc_bh
->b_data
;
699 la
= OCFS2_LOCAL_ALLOC(alloc
);
701 start
= ocfs2_local_alloc_find_clear_bits(osb
, alloc
, bits_wanted
);
703 /* TODO: Shouldn't we just BUG here? */
709 bitmap
= la
->la_bitmap
;
710 *bit_off
= le32_to_cpu(la
->la_bm_off
) + start
;
711 /* local alloc is always contiguous by nature -- we never
712 * delete bits from it! */
713 *num_bits
= bits_wanted
;
715 status
= ocfs2_journal_access(handle
, local_alloc_inode
,
717 OCFS2_JOURNAL_ACCESS_WRITE
);
724 ocfs2_set_bit(start
++, bitmap
);
726 le32_add_cpu(&alloc
->id1
.bitmap1
.i_used
, *num_bits
);
728 status
= ocfs2_journal_dirty(handle
, osb
->local_alloc_bh
);
740 static u32
ocfs2_local_alloc_count_bits(struct ocfs2_dinode
*alloc
)
745 struct ocfs2_local_alloc
*la
= OCFS2_LOCAL_ALLOC(alloc
);
749 buffer
= la
->la_bitmap
;
750 for (i
= 0; i
< le16_to_cpu(la
->la_size
); i
++)
751 count
+= hweight8(buffer
[i
]);
757 static int ocfs2_local_alloc_find_clear_bits(struct ocfs2_super
*osb
,
758 struct ocfs2_dinode
*alloc
,
761 int numfound
, bitoff
, left
, startoff
, lastzero
;
764 mlog_entry("(numbits wanted = %u)\n", numbits
);
766 if (!alloc
->id1
.bitmap1
.i_total
) {
767 mlog(0, "No bits in my window!\n");
772 bitmap
= OCFS2_LOCAL_ALLOC(alloc
)->la_bitmap
;
774 numfound
= bitoff
= startoff
= 0;
776 left
= le32_to_cpu(alloc
->id1
.bitmap1
.i_total
);
777 while ((bitoff
= ocfs2_find_next_zero_bit(bitmap
, left
, startoff
)) != -1) {
778 if (bitoff
== left
) {
779 /* mlog(0, "bitoff (%d) == left", bitoff); */
782 /* mlog(0, "Found a zero: bitoff = %d, startoff = %d, "
783 "numfound = %d\n", bitoff, startoff, numfound);*/
785 /* Ok, we found a zero bit... is it contig. or do we
787 if (bitoff
== startoff
) {
788 /* we found a zero */
792 /* got a zero after some ones */
796 /* we got everything we needed */
797 if (numfound
== numbits
) {
798 /* mlog(0, "Found it all!\n"); */
803 mlog(0, "Exiting loop, bitoff = %d, numfound = %d\n", bitoff
,
806 if (numfound
== numbits
)
807 bitoff
= startoff
- numfound
;
816 static void ocfs2_clear_local_alloc(struct ocfs2_dinode
*alloc
)
818 struct ocfs2_local_alloc
*la
= OCFS2_LOCAL_ALLOC(alloc
);
822 alloc
->id1
.bitmap1
.i_total
= 0;
823 alloc
->id1
.bitmap1
.i_used
= 0;
825 for(i
= 0; i
< le16_to_cpu(la
->la_size
); i
++)
826 la
->la_bitmap
[i
] = 0;
832 /* turn this on and uncomment below to aid debugging window shifts. */
833 static void ocfs2_verify_zero_bits(unsigned long *bitmap
,
837 unsigned int tmp
= count
;
839 if (ocfs2_test_bit(start
+ tmp
, bitmap
)) {
840 printk("ocfs2_verify_zero_bits: start = %u, count = "
841 "%u\n", start
, count
);
842 printk("ocfs2_verify_zero_bits: bit %u is set!",
851 * sync the local alloc to main bitmap.
853 * assumes you've already locked the main bitmap -- the bitmap inode
854 * passed is used for caching.
856 static int ocfs2_sync_local_to_main(struct ocfs2_super
*osb
,
858 struct ocfs2_dinode
*alloc
,
859 struct inode
*main_bm_inode
,
860 struct buffer_head
*main_bm_bh
)
863 int bit_off
, left
, count
, start
;
867 struct ocfs2_local_alloc
*la
= OCFS2_LOCAL_ALLOC(alloc
);
869 mlog_entry("total = %u, used = %u\n",
870 le32_to_cpu(alloc
->id1
.bitmap1
.i_total
),
871 le32_to_cpu(alloc
->id1
.bitmap1
.i_used
));
873 if (!alloc
->id1
.bitmap1
.i_total
) {
874 mlog(0, "nothing to sync!\n");
878 if (le32_to_cpu(alloc
->id1
.bitmap1
.i_used
) ==
879 le32_to_cpu(alloc
->id1
.bitmap1
.i_total
)) {
880 mlog(0, "all bits were taken!\n");
884 la_start_blk
= ocfs2_clusters_to_blocks(osb
->sb
,
885 le32_to_cpu(la
->la_bm_off
));
886 bitmap
= la
->la_bitmap
;
887 start
= count
= bit_off
= 0;
888 left
= le32_to_cpu(alloc
->id1
.bitmap1
.i_total
);
890 while ((bit_off
= ocfs2_find_next_zero_bit(bitmap
, left
, start
))
892 if ((bit_off
< left
) && (bit_off
== start
)) {
898 blkno
= la_start_blk
+
899 ocfs2_clusters_to_blocks(osb
->sb
,
902 mlog(0, "freeing %u bits starting at local alloc bit "
903 "%u (la_start_blk = %llu, blkno = %llu)\n",
904 count
, start
- count
,
905 (unsigned long long)la_start_blk
,
906 (unsigned long long)blkno
);
908 status
= ocfs2_free_clusters(handle
, main_bm_inode
,
909 main_bm_bh
, blkno
, count
);
926 enum ocfs2_la_event
{
927 OCFS2_LA_EVENT_SLIDE
, /* Normal window slide. */
928 OCFS2_LA_EVENT_FRAGMENTED
, /* The global bitmap has
929 * enough bits theoretically
930 * free, but a contiguous
931 * allocation could not be
933 OCFS2_LA_EVENT_ENOSPC
, /* Global bitmap doesn't have
934 * enough bits free to satisfy
937 #define OCFS2_LA_ENABLE_INTERVAL (30 * HZ)
939 * Given an event, calculate the size of our next local alloc window.
941 * This should always be called under i_mutex of the local alloc inode
942 * so that local alloc disabling doesn't race with processes trying to
945 * Returns the state which the local alloc was left in. This value can
946 * be ignored by some paths.
948 static int ocfs2_recalc_la_window(struct ocfs2_super
*osb
,
949 enum ocfs2_la_event event
)
954 spin_lock(&osb
->osb_lock
);
955 if (osb
->local_alloc_state
== OCFS2_LA_DISABLED
) {
956 WARN_ON_ONCE(osb
->local_alloc_state
== OCFS2_LA_DISABLED
);
961 * ENOSPC and fragmentation are treated similarly for now.
963 if (event
== OCFS2_LA_EVENT_ENOSPC
||
964 event
== OCFS2_LA_EVENT_FRAGMENTED
) {
966 * We ran out of contiguous space in the primary
967 * bitmap. Drastically reduce the number of bits used
968 * by local alloc until we have to disable it.
970 bits
= osb
->local_alloc_bits
>> 1;
971 if (bits
> ocfs2_megabytes_to_clusters(osb
->sb
, 1)) {
973 * By setting state to THROTTLED, we'll keep
974 * the number of local alloc bits used down
975 * until an event occurs which would give us
976 * reason to assume the bitmap situation might
979 osb
->local_alloc_state
= OCFS2_LA_THROTTLED
;
980 osb
->local_alloc_bits
= bits
;
982 osb
->local_alloc_state
= OCFS2_LA_DISABLED
;
984 queue_delayed_work(ocfs2_wq
, &osb
->la_enable_wq
,
985 OCFS2_LA_ENABLE_INTERVAL
);
990 * Don't increase the size of the local alloc window until we
991 * know we might be able to fulfill the request. Otherwise, we
992 * risk bouncing around the global bitmap during periods of
995 if (osb
->local_alloc_state
!= OCFS2_LA_THROTTLED
)
996 osb
->local_alloc_bits
= osb
->local_alloc_default_bits
;
999 state
= osb
->local_alloc_state
;
1000 spin_unlock(&osb
->osb_lock
);
1005 static int ocfs2_local_alloc_reserve_for_window(struct ocfs2_super
*osb
,
1006 struct ocfs2_alloc_context
**ac
,
1007 struct inode
**bitmap_inode
,
1008 struct buffer_head
**bitmap_bh
)
1012 *ac
= kzalloc(sizeof(struct ocfs2_alloc_context
), GFP_KERNEL
);
1020 (*ac
)->ac_bits_wanted
= osb
->local_alloc_bits
;
1022 status
= ocfs2_reserve_cluster_bitmap_bits(osb
, *ac
);
1023 if (status
== -ENOSPC
) {
1024 if (ocfs2_recalc_la_window(osb
, OCFS2_LA_EVENT_ENOSPC
) ==
1028 ocfs2_free_ac_resource(*ac
);
1029 memset(*ac
, 0, sizeof(struct ocfs2_alloc_context
));
1037 *bitmap_inode
= (*ac
)->ac_inode
;
1038 igrab(*bitmap_inode
);
1039 *bitmap_bh
= (*ac
)->ac_bh
;
1043 if ((status
< 0) && *ac
) {
1044 ocfs2_free_alloc_context(*ac
);
1053 * pass it the bitmap lock in lock_bh if you have it.
1055 static int ocfs2_local_alloc_new_window(struct ocfs2_super
*osb
,
1057 struct ocfs2_alloc_context
*ac
)
1060 u32 cluster_off
, cluster_count
;
1061 struct ocfs2_dinode
*alloc
= NULL
;
1062 struct ocfs2_local_alloc
*la
;
1066 alloc
= (struct ocfs2_dinode
*) osb
->local_alloc_bh
->b_data
;
1067 la
= OCFS2_LOCAL_ALLOC(alloc
);
1069 if (alloc
->id1
.bitmap1
.i_total
)
1070 mlog(0, "asking me to alloc a new window over a non-empty "
1073 mlog(0, "Allocating %u clusters for a new window.\n",
1074 osb
->local_alloc_bits
);
1076 /* Instruct the allocation code to try the most recently used
1077 * cluster group. We'll re-record the group used this pass
1079 ac
->ac_last_group
= osb
->la_last_gd
;
1081 /* we used the generic suballoc reserve function, but we set
1082 * everything up nicely, so there's no reason why we can't use
1083 * the more specific cluster api to claim bits. */
1084 status
= ocfs2_claim_clusters(osb
, handle
, ac
, osb
->local_alloc_bits
,
1085 &cluster_off
, &cluster_count
);
1086 if (status
== -ENOSPC
) {
1089 * Note: We could also try syncing the journal here to
1090 * allow use of any free bits which the current
1091 * transaction can't give us access to. --Mark
1093 if (ocfs2_recalc_la_window(osb
, OCFS2_LA_EVENT_FRAGMENTED
) ==
1097 status
= ocfs2_claim_clusters(osb
, handle
, ac
,
1098 osb
->local_alloc_bits
,
1101 if (status
== -ENOSPC
)
1104 * We only shrunk the *minimum* number of in our
1105 * request - it's entirely possible that the allocator
1106 * might give us more than we asked for.
1109 spin_lock(&osb
->osb_lock
);
1110 osb
->local_alloc_bits
= cluster_count
;
1111 spin_unlock(&osb
->osb_lock
);
1115 if (status
!= -ENOSPC
)
1120 osb
->la_last_gd
= ac
->ac_last_group
;
1122 la
->la_bm_off
= cpu_to_le32(cluster_off
);
1123 alloc
->id1
.bitmap1
.i_total
= cpu_to_le32(cluster_count
);
1124 /* just in case... In the future when we find space ourselves,
1125 * we don't have to get all contiguous -- but we'll have to
1126 * set all previously used bits in bitmap and update
1127 * la_bits_set before setting the bits in the main bitmap. */
1128 alloc
->id1
.bitmap1
.i_used
= 0;
1129 memset(OCFS2_LOCAL_ALLOC(alloc
)->la_bitmap
, 0,
1130 le16_to_cpu(la
->la_size
));
1132 mlog(0, "New window allocated:\n");
1133 mlog(0, "window la_bm_off = %u\n",
1134 OCFS2_LOCAL_ALLOC(alloc
)->la_bm_off
);
1135 mlog(0, "window bits = %u\n", le32_to_cpu(alloc
->id1
.bitmap1
.i_total
));
1142 /* Note that we do *NOT* lock the local alloc inode here as
1143 * it's been locked already for us. */
1144 static int ocfs2_local_alloc_slide_window(struct ocfs2_super
*osb
,
1145 struct inode
*local_alloc_inode
)
1148 struct buffer_head
*main_bm_bh
= NULL
;
1149 struct inode
*main_bm_inode
= NULL
;
1150 handle_t
*handle
= NULL
;
1151 struct ocfs2_dinode
*alloc
;
1152 struct ocfs2_dinode
*alloc_copy
= NULL
;
1153 struct ocfs2_alloc_context
*ac
= NULL
;
1157 ocfs2_recalc_la_window(osb
, OCFS2_LA_EVENT_SLIDE
);
1159 /* This will lock the main bitmap for us. */
1160 status
= ocfs2_local_alloc_reserve_for_window(osb
,
1165 if (status
!= -ENOSPC
)
1170 handle
= ocfs2_start_trans(osb
, OCFS2_WINDOW_MOVE_CREDITS
);
1171 if (IS_ERR(handle
)) {
1172 status
= PTR_ERR(handle
);
1178 alloc
= (struct ocfs2_dinode
*) osb
->local_alloc_bh
->b_data
;
1180 /* We want to clear the local alloc before doing anything
1181 * else, so that if we error later during this operation,
1182 * local alloc shutdown won't try to double free main bitmap
1183 * bits. Make a copy so the sync function knows which bits to
1185 alloc_copy
= kmalloc(osb
->local_alloc_bh
->b_size
, GFP_NOFS
);
1191 memcpy(alloc_copy
, alloc
, osb
->local_alloc_bh
->b_size
);
1193 status
= ocfs2_journal_access(handle
, local_alloc_inode
,
1194 osb
->local_alloc_bh
,
1195 OCFS2_JOURNAL_ACCESS_WRITE
);
1201 ocfs2_clear_local_alloc(alloc
);
1203 status
= ocfs2_journal_dirty(handle
, osb
->local_alloc_bh
);
1209 status
= ocfs2_sync_local_to_main(osb
, handle
, alloc_copy
,
1210 main_bm_inode
, main_bm_bh
);
1216 status
= ocfs2_local_alloc_new_window(osb
, handle
, ac
);
1218 if (status
!= -ENOSPC
)
1223 atomic_inc(&osb
->alloc_stats
.moves
);
1228 ocfs2_commit_trans(osb
, handle
);
1234 iput(main_bm_inode
);
1240 ocfs2_free_alloc_context(ac
);