1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
6 * metadata alloc and free
7 * Inspired by ext3 block groups.
9 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public
13 * License as published by the Free Software Foundation; either
14 * version 2 of the License, or (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
21 * You should have received a copy of the GNU General Public
22 * License along with this program; if not, write to the
23 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 * Boston, MA 021110-1307, USA.
28 #include <linux/types.h>
29 #include <linux/slab.h>
30 #include <linux/highmem.h>
32 #define MLOG_MASK_PREFIX ML_DISK_ALLOC
33 #include <cluster/masklog.h>
38 #include "blockcheck.h"
42 #include "localalloc.h"
48 #include "buffer_head_io.h"
50 #define NOT_ALLOC_NEW_GROUP 0
51 #define ALLOC_NEW_GROUP 0x1
52 #define ALLOC_GROUPS_FROM_GLOBAL 0x2
54 #define OCFS2_MAX_TO_STEAL 1024
56 static inline void ocfs2_debug_bg(struct ocfs2_group_desc
*bg
);
57 static inline void ocfs2_debug_suballoc_inode(struct ocfs2_dinode
*fe
);
58 static inline u16
ocfs2_find_victim_chain(struct ocfs2_chain_list
*cl
);
59 static int ocfs2_block_group_fill(handle_t
*handle
,
60 struct inode
*alloc_inode
,
61 struct buffer_head
*bg_bh
,
64 struct ocfs2_chain_list
*cl
);
65 static int ocfs2_block_group_alloc(struct ocfs2_super
*osb
,
66 struct inode
*alloc_inode
,
67 struct buffer_head
*bh
,
69 u64
*last_alloc_group
,
72 static int ocfs2_cluster_group_search(struct inode
*inode
,
73 struct buffer_head
*group_bh
,
74 u32 bits_wanted
, u32 min_bits
,
76 u16
*bit_off
, u16
*bits_found
);
77 static int ocfs2_block_group_search(struct inode
*inode
,
78 struct buffer_head
*group_bh
,
79 u32 bits_wanted
, u32 min_bits
,
81 u16
*bit_off
, u16
*bits_found
);
82 static int ocfs2_claim_suballoc_bits(struct ocfs2_super
*osb
,
83 struct ocfs2_alloc_context
*ac
,
88 unsigned int *num_bits
,
90 static int ocfs2_test_bg_bit_allocatable(struct buffer_head
*bg_bh
,
92 static inline int ocfs2_block_group_set_bits(handle_t
*handle
,
93 struct inode
*alloc_inode
,
94 struct ocfs2_group_desc
*bg
,
95 struct buffer_head
*group_bh
,
97 unsigned int num_bits
);
98 static inline int ocfs2_block_group_clear_bits(handle_t
*handle
,
99 struct inode
*alloc_inode
,
100 struct ocfs2_group_desc
*bg
,
101 struct buffer_head
*group_bh
,
102 unsigned int bit_off
,
103 unsigned int num_bits
);
105 static int ocfs2_relink_block_group(handle_t
*handle
,
106 struct inode
*alloc_inode
,
107 struct buffer_head
*fe_bh
,
108 struct buffer_head
*bg_bh
,
109 struct buffer_head
*prev_bg_bh
,
111 static inline int ocfs2_block_group_reasonably_empty(struct ocfs2_group_desc
*bg
,
113 static inline u32
ocfs2_desc_bitmap_to_cluster_off(struct inode
*inode
,
116 static inline void ocfs2_block_to_cluster_group(struct inode
*inode
,
120 static int ocfs2_reserve_clusters_with_limit(struct ocfs2_super
*osb
,
121 u32 bits_wanted
, u64 max_block
,
123 struct ocfs2_alloc_context
**ac
);
125 void ocfs2_free_ac_resource(struct ocfs2_alloc_context
*ac
)
127 struct inode
*inode
= ac
->ac_inode
;
130 if (ac
->ac_which
!= OCFS2_AC_USE_LOCAL
)
131 ocfs2_inode_unlock(inode
, 1);
133 mutex_unlock(&inode
->i_mutex
);
142 void ocfs2_free_alloc_context(struct ocfs2_alloc_context
*ac
)
144 ocfs2_free_ac_resource(ac
);
148 static u32
ocfs2_bits_per_group(struct ocfs2_chain_list
*cl
)
150 return (u32
)le16_to_cpu(cl
->cl_cpg
) * (u32
)le16_to_cpu(cl
->cl_bpc
);
153 #define do_error(fmt, ...) \
156 mlog(ML_ERROR, fmt "\n", ##__VA_ARGS__); \
158 ocfs2_error(sb, fmt, ##__VA_ARGS__); \
161 static int ocfs2_validate_gd_self(struct super_block
*sb
,
162 struct buffer_head
*bh
,
165 struct ocfs2_group_desc
*gd
= (struct ocfs2_group_desc
*)bh
->b_data
;
167 if (!OCFS2_IS_VALID_GROUP_DESC(gd
)) {
168 do_error("Group descriptor #%llu has bad signature %.*s",
169 (unsigned long long)bh
->b_blocknr
, 7,
174 if (le64_to_cpu(gd
->bg_blkno
) != bh
->b_blocknr
) {
175 do_error("Group descriptor #%llu has an invalid bg_blkno "
177 (unsigned long long)bh
->b_blocknr
,
178 (unsigned long long)le64_to_cpu(gd
->bg_blkno
));
182 if (le32_to_cpu(gd
->bg_generation
) != OCFS2_SB(sb
)->fs_generation
) {
183 do_error("Group descriptor #%llu has an invalid "
184 "fs_generation of #%u",
185 (unsigned long long)bh
->b_blocknr
,
186 le32_to_cpu(gd
->bg_generation
));
190 if (le16_to_cpu(gd
->bg_free_bits_count
) > le16_to_cpu(gd
->bg_bits
)) {
191 do_error("Group descriptor #%llu has bit count %u but "
192 "claims that %u are free",
193 (unsigned long long)bh
->b_blocknr
,
194 le16_to_cpu(gd
->bg_bits
),
195 le16_to_cpu(gd
->bg_free_bits_count
));
199 if (le16_to_cpu(gd
->bg_bits
) > (8 * le16_to_cpu(gd
->bg_size
))) {
200 do_error("Group descriptor #%llu has bit count %u but "
201 "max bitmap bits of %u",
202 (unsigned long long)bh
->b_blocknr
,
203 le16_to_cpu(gd
->bg_bits
),
204 8 * le16_to_cpu(gd
->bg_size
));
211 static int ocfs2_validate_gd_parent(struct super_block
*sb
,
212 struct ocfs2_dinode
*di
,
213 struct buffer_head
*bh
,
216 unsigned int max_bits
;
217 struct ocfs2_group_desc
*gd
= (struct ocfs2_group_desc
*)bh
->b_data
;
219 if (di
->i_blkno
!= gd
->bg_parent_dinode
) {
220 do_error("Group descriptor #%llu has bad parent "
221 "pointer (%llu, expected %llu)",
222 (unsigned long long)bh
->b_blocknr
,
223 (unsigned long long)le64_to_cpu(gd
->bg_parent_dinode
),
224 (unsigned long long)le64_to_cpu(di
->i_blkno
));
228 max_bits
= le16_to_cpu(di
->id2
.i_chain
.cl_cpg
) * le16_to_cpu(di
->id2
.i_chain
.cl_bpc
);
229 if (le16_to_cpu(gd
->bg_bits
) > max_bits
) {
230 do_error("Group descriptor #%llu has bit count of %u",
231 (unsigned long long)bh
->b_blocknr
,
232 le16_to_cpu(gd
->bg_bits
));
236 /* In resize, we may meet the case bg_chain == cl_next_free_rec. */
237 if ((le16_to_cpu(gd
->bg_chain
) >
238 le16_to_cpu(di
->id2
.i_chain
.cl_next_free_rec
)) ||
239 ((le16_to_cpu(gd
->bg_chain
) ==
240 le16_to_cpu(di
->id2
.i_chain
.cl_next_free_rec
)) && !resize
)) {
241 do_error("Group descriptor #%llu has bad chain %u",
242 (unsigned long long)bh
->b_blocknr
,
243 le16_to_cpu(gd
->bg_chain
));
253 * This version only prints errors. It does not fail the filesystem, and
254 * exists only for resize.
256 int ocfs2_check_group_descriptor(struct super_block
*sb
,
257 struct ocfs2_dinode
*di
,
258 struct buffer_head
*bh
)
261 struct ocfs2_group_desc
*gd
= (struct ocfs2_group_desc
*)bh
->b_data
;
263 BUG_ON(!buffer_uptodate(bh
));
266 * If the ecc fails, we return the error but otherwise
267 * leave the filesystem running. We know any error is
268 * local to this block.
270 rc
= ocfs2_validate_meta_ecc(sb
, bh
->b_data
, &gd
->bg_check
);
273 "Checksum failed for group descriptor %llu\n",
274 (unsigned long long)bh
->b_blocknr
);
276 rc
= ocfs2_validate_gd_self(sb
, bh
, 1);
278 rc
= ocfs2_validate_gd_parent(sb
, di
, bh
, 1);
283 static int ocfs2_validate_group_descriptor(struct super_block
*sb
,
284 struct buffer_head
*bh
)
287 struct ocfs2_group_desc
*gd
= (struct ocfs2_group_desc
*)bh
->b_data
;
289 mlog(0, "Validating group descriptor %llu\n",
290 (unsigned long long)bh
->b_blocknr
);
292 BUG_ON(!buffer_uptodate(bh
));
295 * If the ecc fails, we return the error but otherwise
296 * leave the filesystem running. We know any error is
297 * local to this block.
299 rc
= ocfs2_validate_meta_ecc(sb
, bh
->b_data
, &gd
->bg_check
);
304 * Errors after here are fatal.
307 return ocfs2_validate_gd_self(sb
, bh
, 0);
310 int ocfs2_read_group_descriptor(struct inode
*inode
, struct ocfs2_dinode
*di
,
311 u64 gd_blkno
, struct buffer_head
**bh
)
314 struct buffer_head
*tmp
= *bh
;
316 rc
= ocfs2_read_block(INODE_CACHE(inode
), gd_blkno
, &tmp
,
317 ocfs2_validate_group_descriptor
);
321 rc
= ocfs2_validate_gd_parent(inode
->i_sb
, di
, tmp
, 0);
327 /* If ocfs2_read_block() got us a new bh, pass it up. */
335 static int ocfs2_block_group_fill(handle_t
*handle
,
336 struct inode
*alloc_inode
,
337 struct buffer_head
*bg_bh
,
340 struct ocfs2_chain_list
*cl
)
343 struct ocfs2_group_desc
*bg
= (struct ocfs2_group_desc
*) bg_bh
->b_data
;
344 struct super_block
* sb
= alloc_inode
->i_sb
;
348 if (((unsigned long long) bg_bh
->b_blocknr
) != group_blkno
) {
349 ocfs2_error(alloc_inode
->i_sb
, "group block (%llu) != "
351 (unsigned long long)group_blkno
,
352 (unsigned long long) bg_bh
->b_blocknr
);
357 status
= ocfs2_journal_access_gd(handle
,
358 INODE_CACHE(alloc_inode
),
360 OCFS2_JOURNAL_ACCESS_CREATE
);
366 memset(bg
, 0, sb
->s_blocksize
);
367 strcpy(bg
->bg_signature
, OCFS2_GROUP_DESC_SIGNATURE
);
368 bg
->bg_generation
= cpu_to_le32(OCFS2_SB(sb
)->fs_generation
);
369 bg
->bg_size
= cpu_to_le16(ocfs2_group_bitmap_size(sb
));
370 bg
->bg_bits
= cpu_to_le16(ocfs2_bits_per_group(cl
));
371 bg
->bg_chain
= cpu_to_le16(my_chain
);
372 bg
->bg_next_group
= cl
->cl_recs
[my_chain
].c_blkno
;
373 bg
->bg_parent_dinode
= cpu_to_le64(OCFS2_I(alloc_inode
)->ip_blkno
);
374 bg
->bg_blkno
= cpu_to_le64(group_blkno
);
375 /* set the 1st bit in the bitmap to account for the descriptor block */
376 ocfs2_set_bit(0, (unsigned long *)bg
->bg_bitmap
);
377 bg
->bg_free_bits_count
= cpu_to_le16(le16_to_cpu(bg
->bg_bits
) - 1);
379 status
= ocfs2_journal_dirty(handle
, bg_bh
);
383 /* There is no need to zero out or otherwise initialize the
384 * other blocks in a group - All valid FS metadata in a block
385 * group stores the superblock fs_generation value at
386 * allocation time. */
393 static inline u16
ocfs2_find_smallest_chain(struct ocfs2_chain_list
*cl
)
398 while (curr
< le16_to_cpu(cl
->cl_count
)) {
399 if (le32_to_cpu(cl
->cl_recs
[best
].c_total
) >
400 le32_to_cpu(cl
->cl_recs
[curr
].c_total
))
408 * We expect the block group allocator to already be locked.
410 static int ocfs2_block_group_alloc(struct ocfs2_super
*osb
,
411 struct inode
*alloc_inode
,
412 struct buffer_head
*bh
,
414 u64
*last_alloc_group
,
418 struct ocfs2_dinode
*fe
= (struct ocfs2_dinode
*) bh
->b_data
;
419 struct ocfs2_chain_list
*cl
;
420 struct ocfs2_alloc_context
*ac
= NULL
;
421 handle_t
*handle
= NULL
;
422 u32 bit_off
, num_bits
;
425 struct buffer_head
*bg_bh
= NULL
;
426 struct ocfs2_group_desc
*bg
;
428 BUG_ON(ocfs2_is_cluster_bitmap(alloc_inode
));
432 cl
= &fe
->id2
.i_chain
;
433 status
= ocfs2_reserve_clusters_with_limit(osb
,
434 le16_to_cpu(cl
->cl_cpg
),
435 max_block
, flags
, &ac
);
437 if (status
!= -ENOSPC
)
442 credits
= ocfs2_calc_group_alloc_credits(osb
->sb
,
443 le16_to_cpu(cl
->cl_cpg
));
444 handle
= ocfs2_start_trans(osb
, credits
);
445 if (IS_ERR(handle
)) {
446 status
= PTR_ERR(handle
);
452 if (last_alloc_group
&& *last_alloc_group
!= 0) {
453 mlog(0, "use old allocation group %llu for block group alloc\n",
454 (unsigned long long)*last_alloc_group
);
455 ac
->ac_last_group
= *last_alloc_group
;
457 status
= ocfs2_claim_clusters(osb
,
460 le16_to_cpu(cl
->cl_cpg
),
464 if (status
!= -ENOSPC
)
469 alloc_rec
= ocfs2_find_smallest_chain(cl
);
471 /* setup the group */
472 bg_blkno
= ocfs2_clusters_to_blocks(osb
->sb
, bit_off
);
473 mlog(0, "new descriptor, record %u, at block %llu\n",
474 alloc_rec
, (unsigned long long)bg_blkno
);
476 bg_bh
= sb_getblk(osb
->sb
, bg_blkno
);
482 ocfs2_set_new_buffer_uptodate(INODE_CACHE(alloc_inode
), bg_bh
);
484 status
= ocfs2_block_group_fill(handle
,
495 bg
= (struct ocfs2_group_desc
*) bg_bh
->b_data
;
497 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(alloc_inode
),
498 bh
, OCFS2_JOURNAL_ACCESS_WRITE
);
504 le32_add_cpu(&cl
->cl_recs
[alloc_rec
].c_free
,
505 le16_to_cpu(bg
->bg_free_bits_count
));
506 le32_add_cpu(&cl
->cl_recs
[alloc_rec
].c_total
, le16_to_cpu(bg
->bg_bits
));
507 cl
->cl_recs
[alloc_rec
].c_blkno
= cpu_to_le64(bg_blkno
);
508 if (le16_to_cpu(cl
->cl_next_free_rec
) < le16_to_cpu(cl
->cl_count
))
509 le16_add_cpu(&cl
->cl_next_free_rec
, 1);
511 le32_add_cpu(&fe
->id1
.bitmap1
.i_used
, le16_to_cpu(bg
->bg_bits
) -
512 le16_to_cpu(bg
->bg_free_bits_count
));
513 le32_add_cpu(&fe
->id1
.bitmap1
.i_total
, le16_to_cpu(bg
->bg_bits
));
514 le32_add_cpu(&fe
->i_clusters
, le16_to_cpu(cl
->cl_cpg
));
516 status
= ocfs2_journal_dirty(handle
, bh
);
522 spin_lock(&OCFS2_I(alloc_inode
)->ip_lock
);
523 OCFS2_I(alloc_inode
)->ip_clusters
= le32_to_cpu(fe
->i_clusters
);
524 fe
->i_size
= cpu_to_le64(ocfs2_clusters_to_bytes(alloc_inode
->i_sb
,
525 le32_to_cpu(fe
->i_clusters
)));
526 spin_unlock(&OCFS2_I(alloc_inode
)->ip_lock
);
527 i_size_write(alloc_inode
, le64_to_cpu(fe
->i_size
));
528 alloc_inode
->i_blocks
= ocfs2_inode_sector_count(alloc_inode
);
532 /* save the new last alloc group so that the caller can cache it. */
533 if (last_alloc_group
)
534 *last_alloc_group
= ac
->ac_last_group
;
538 ocfs2_commit_trans(osb
, handle
);
541 ocfs2_free_alloc_context(ac
);
549 static int ocfs2_reserve_suballoc_bits(struct ocfs2_super
*osb
,
550 struct ocfs2_alloc_context
*ac
,
553 u64
*last_alloc_group
,
557 u32 bits_wanted
= ac
->ac_bits_wanted
;
558 struct inode
*alloc_inode
;
559 struct buffer_head
*bh
= NULL
;
560 struct ocfs2_dinode
*fe
;
565 alloc_inode
= ocfs2_get_system_file_inode(osb
, type
, slot
);
571 mutex_lock(&alloc_inode
->i_mutex
);
573 status
= ocfs2_inode_lock(alloc_inode
, &bh
, 1);
575 mutex_unlock(&alloc_inode
->i_mutex
);
582 ac
->ac_inode
= alloc_inode
;
583 ac
->ac_alloc_slot
= slot
;
585 fe
= (struct ocfs2_dinode
*) bh
->b_data
;
587 /* The bh was validated by the inode read inside
588 * ocfs2_inode_lock(). Any corruption is a code bug. */
589 BUG_ON(!OCFS2_IS_VALID_DINODE(fe
));
591 if (!(fe
->i_flags
& cpu_to_le32(OCFS2_CHAIN_FL
))) {
592 ocfs2_error(alloc_inode
->i_sb
, "Invalid chain allocator %llu",
593 (unsigned long long)le64_to_cpu(fe
->i_blkno
));
598 free_bits
= le32_to_cpu(fe
->id1
.bitmap1
.i_total
) -
599 le32_to_cpu(fe
->id1
.bitmap1
.i_used
);
601 if (bits_wanted
> free_bits
) {
602 /* cluster bitmap never grows */
603 if (ocfs2_is_cluster_bitmap(alloc_inode
)) {
604 mlog(0, "Disk Full: wanted=%u, free_bits=%u\n",
605 bits_wanted
, free_bits
);
610 if (!(flags
& ALLOC_NEW_GROUP
)) {
611 mlog(0, "Alloc File %u Full: wanted=%u, free_bits=%u, "
612 "and we don't alloc a new group for it.\n",
613 slot
, bits_wanted
, free_bits
);
618 status
= ocfs2_block_group_alloc(osb
, alloc_inode
, bh
,
620 last_alloc_group
, flags
);
622 if (status
!= -ENOSPC
)
626 atomic_inc(&osb
->alloc_stats
.bg_extends
);
628 /* You should never ask for this much metadata */
630 (le32_to_cpu(fe
->id1
.bitmap1
.i_total
)
631 - le32_to_cpu(fe
->id1
.bitmap1
.i_used
)));
643 static void ocfs2_init_inode_steal_slot(struct ocfs2_super
*osb
)
645 spin_lock(&osb
->osb_lock
);
646 osb
->s_inode_steal_slot
= OCFS2_INVALID_SLOT
;
647 spin_unlock(&osb
->osb_lock
);
648 atomic_set(&osb
->s_num_inodes_stolen
, 0);
651 static void ocfs2_init_meta_steal_slot(struct ocfs2_super
*osb
)
653 spin_lock(&osb
->osb_lock
);
654 osb
->s_meta_steal_slot
= OCFS2_INVALID_SLOT
;
655 spin_unlock(&osb
->osb_lock
);
656 atomic_set(&osb
->s_num_meta_stolen
, 0);
659 void ocfs2_init_steal_slots(struct ocfs2_super
*osb
)
661 ocfs2_init_inode_steal_slot(osb
);
662 ocfs2_init_meta_steal_slot(osb
);
665 static void __ocfs2_set_steal_slot(struct ocfs2_super
*osb
, int slot
, int type
)
667 spin_lock(&osb
->osb_lock
);
668 if (type
== INODE_ALLOC_SYSTEM_INODE
)
669 osb
->s_inode_steal_slot
= slot
;
670 else if (type
== EXTENT_ALLOC_SYSTEM_INODE
)
671 osb
->s_meta_steal_slot
= slot
;
672 spin_unlock(&osb
->osb_lock
);
675 static int __ocfs2_get_steal_slot(struct ocfs2_super
*osb
, int type
)
677 int slot
= OCFS2_INVALID_SLOT
;
679 spin_lock(&osb
->osb_lock
);
680 if (type
== INODE_ALLOC_SYSTEM_INODE
)
681 slot
= osb
->s_inode_steal_slot
;
682 else if (type
== EXTENT_ALLOC_SYSTEM_INODE
)
683 slot
= osb
->s_meta_steal_slot
;
684 spin_unlock(&osb
->osb_lock
);
689 static int ocfs2_get_inode_steal_slot(struct ocfs2_super
*osb
)
691 return __ocfs2_get_steal_slot(osb
, INODE_ALLOC_SYSTEM_INODE
);
694 static int ocfs2_get_meta_steal_slot(struct ocfs2_super
*osb
)
696 return __ocfs2_get_steal_slot(osb
, EXTENT_ALLOC_SYSTEM_INODE
);
699 static int ocfs2_steal_resource(struct ocfs2_super
*osb
,
700 struct ocfs2_alloc_context
*ac
,
703 int i
, status
= -ENOSPC
;
704 int slot
= __ocfs2_get_steal_slot(osb
, type
);
706 /* Start to steal resource from the first slot after ours. */
707 if (slot
== OCFS2_INVALID_SLOT
)
708 slot
= osb
->slot_num
+ 1;
710 for (i
= 0; i
< osb
->max_slots
; i
++, slot
++) {
711 if (slot
== osb
->max_slots
)
714 if (slot
== osb
->slot_num
)
717 status
= ocfs2_reserve_suballoc_bits(osb
, ac
,
720 NOT_ALLOC_NEW_GROUP
);
722 __ocfs2_set_steal_slot(osb
, slot
, type
);
726 ocfs2_free_ac_resource(ac
);
732 static int ocfs2_steal_inode(struct ocfs2_super
*osb
,
733 struct ocfs2_alloc_context
*ac
)
735 return ocfs2_steal_resource(osb
, ac
, INODE_ALLOC_SYSTEM_INODE
);
738 static int ocfs2_steal_meta(struct ocfs2_super
*osb
,
739 struct ocfs2_alloc_context
*ac
)
741 return ocfs2_steal_resource(osb
, ac
, EXTENT_ALLOC_SYSTEM_INODE
);
744 int ocfs2_reserve_new_metadata_blocks(struct ocfs2_super
*osb
,
746 struct ocfs2_alloc_context
**ac
)
749 int slot
= ocfs2_get_meta_steal_slot(osb
);
751 *ac
= kzalloc(sizeof(struct ocfs2_alloc_context
), GFP_KERNEL
);
758 (*ac
)->ac_bits_wanted
= blocks
;
759 (*ac
)->ac_which
= OCFS2_AC_USE_META
;
760 (*ac
)->ac_group_search
= ocfs2_block_group_search
;
762 if (slot
!= OCFS2_INVALID_SLOT
&&
763 atomic_read(&osb
->s_num_meta_stolen
) < OCFS2_MAX_TO_STEAL
)
766 atomic_set(&osb
->s_num_meta_stolen
, 0);
767 status
= ocfs2_reserve_suballoc_bits(osb
, (*ac
),
768 EXTENT_ALLOC_SYSTEM_INODE
,
769 (u32
)osb
->slot_num
, NULL
,
775 if (slot
!= OCFS2_INVALID_SLOT
)
776 ocfs2_init_meta_steal_slot(osb
);
778 } else if (status
< 0 && status
!= -ENOSPC
) {
783 ocfs2_free_ac_resource(*ac
);
786 status
= ocfs2_steal_meta(osb
, *ac
);
787 atomic_inc(&osb
->s_num_meta_stolen
);
789 if (status
!= -ENOSPC
)
796 if ((status
< 0) && *ac
) {
797 ocfs2_free_alloc_context(*ac
);
805 int ocfs2_reserve_new_metadata(struct ocfs2_super
*osb
,
806 struct ocfs2_extent_list
*root_el
,
807 struct ocfs2_alloc_context
**ac
)
809 return ocfs2_reserve_new_metadata_blocks(osb
,
810 ocfs2_extend_meta_needed(root_el
),
814 int ocfs2_reserve_new_inode(struct ocfs2_super
*osb
,
815 struct ocfs2_alloc_context
**ac
)
818 int slot
= ocfs2_get_inode_steal_slot(osb
);
821 *ac
= kzalloc(sizeof(struct ocfs2_alloc_context
), GFP_KERNEL
);
828 (*ac
)->ac_bits_wanted
= 1;
829 (*ac
)->ac_which
= OCFS2_AC_USE_INODE
;
831 (*ac
)->ac_group_search
= ocfs2_block_group_search
;
834 * stat(2) can't handle i_ino > 32bits, so we tell the
835 * lower levels not to allocate us a block group past that
836 * limit. The 'inode64' mount option avoids this behavior.
838 if (!(osb
->s_mount_opt
& OCFS2_MOUNT_INODE64
))
839 (*ac
)->ac_max_block
= (u32
)~0U;
842 * slot is set when we successfully steal inode from other nodes.
843 * It is reset in 3 places:
844 * 1. when we flush the truncate log
845 * 2. when we complete local alloc recovery.
846 * 3. when we successfully allocate from our own slot.
847 * After it is set, we will go on stealing inodes until we find the
848 * need to check our slots to see whether there is some space for us.
850 if (slot
!= OCFS2_INVALID_SLOT
&&
851 atomic_read(&osb
->s_num_inodes_stolen
) < OCFS2_MAX_TO_STEAL
)
854 atomic_set(&osb
->s_num_inodes_stolen
, 0);
855 alloc_group
= osb
->osb_inode_alloc_group
;
856 status
= ocfs2_reserve_suballoc_bits(osb
, *ac
,
857 INODE_ALLOC_SYSTEM_INODE
,
861 ALLOC_GROUPS_FROM_GLOBAL
);
865 spin_lock(&osb
->osb_lock
);
866 osb
->osb_inode_alloc_group
= alloc_group
;
867 spin_unlock(&osb
->osb_lock
);
868 mlog(0, "after reservation, new allocation group is "
869 "%llu\n", (unsigned long long)alloc_group
);
872 * Some inodes must be freed by us, so try to allocate
873 * from our own next time.
875 if (slot
!= OCFS2_INVALID_SLOT
)
876 ocfs2_init_inode_steal_slot(osb
);
878 } else if (status
< 0 && status
!= -ENOSPC
) {
883 ocfs2_free_ac_resource(*ac
);
886 status
= ocfs2_steal_inode(osb
, *ac
);
887 atomic_inc(&osb
->s_num_inodes_stolen
);
889 if (status
!= -ENOSPC
)
896 if ((status
< 0) && *ac
) {
897 ocfs2_free_alloc_context(*ac
);
905 /* local alloc code has to do the same thing, so rather than do this
907 int ocfs2_reserve_cluster_bitmap_bits(struct ocfs2_super
*osb
,
908 struct ocfs2_alloc_context
*ac
)
912 ac
->ac_which
= OCFS2_AC_USE_MAIN
;
913 ac
->ac_group_search
= ocfs2_cluster_group_search
;
915 status
= ocfs2_reserve_suballoc_bits(osb
, ac
,
916 GLOBAL_BITMAP_SYSTEM_INODE
,
917 OCFS2_INVALID_SLOT
, NULL
,
919 if (status
< 0 && status
!= -ENOSPC
) {
928 /* Callers don't need to care which bitmap (local alloc or main) to
929 * use so we figure it out for them, but unfortunately this clutters
931 static int ocfs2_reserve_clusters_with_limit(struct ocfs2_super
*osb
,
932 u32 bits_wanted
, u64 max_block
,
934 struct ocfs2_alloc_context
**ac
)
940 *ac
= kzalloc(sizeof(struct ocfs2_alloc_context
), GFP_KERNEL
);
947 (*ac
)->ac_bits_wanted
= bits_wanted
;
948 (*ac
)->ac_max_block
= max_block
;
951 if (!(flags
& ALLOC_GROUPS_FROM_GLOBAL
) &&
952 ocfs2_alloc_should_use_local(osb
, bits_wanted
)) {
953 status
= ocfs2_reserve_local_alloc_bits(osb
,
956 if (status
== -EFBIG
) {
957 /* The local alloc window is outside ac_max_block.
958 * use the main bitmap. */
960 } else if ((status
< 0) && (status
!= -ENOSPC
)) {
966 if (status
== -ENOSPC
) {
967 status
= ocfs2_reserve_cluster_bitmap_bits(osb
, *ac
);
969 if (status
!= -ENOSPC
)
977 if ((status
< 0) && *ac
) {
978 ocfs2_free_alloc_context(*ac
);
986 int ocfs2_reserve_clusters(struct ocfs2_super
*osb
,
988 struct ocfs2_alloc_context
**ac
)
990 return ocfs2_reserve_clusters_with_limit(osb
, bits_wanted
, 0,
991 ALLOC_NEW_GROUP
, ac
);
995 * More or less lifted from ext3. I'll leave their description below:
997 * "For ext3 allocations, we must not reuse any blocks which are
998 * allocated in the bitmap buffer's "last committed data" copy. This
999 * prevents deletes from freeing up the page for reuse until we have
1000 * committed the delete transaction.
1002 * If we didn't do this, then deleting something and reallocating it as
1003 * data would allow the old block to be overwritten before the
1004 * transaction committed (because we force data to disk before commit).
1005 * This would lead to corruption if we crashed between overwriting the
1006 * data and committing the delete.
1008 * @@@ We may want to make this allocation behaviour conditional on
1009 * data-writes at some point, and disable it for metadata allocations or
1010 * sync-data inodes."
1012 * Note: OCFS2 already does this differently for metadata vs data
1013 * allocations, as those bitmaps are separate and undo access is never
1014 * called on a metadata group descriptor.
1016 static int ocfs2_test_bg_bit_allocatable(struct buffer_head
*bg_bh
,
1019 struct ocfs2_group_desc
*bg
= (struct ocfs2_group_desc
*) bg_bh
->b_data
;
1022 if (ocfs2_test_bit(nr
, (unsigned long *)bg
->bg_bitmap
))
1025 if (!buffer_jbd(bg_bh
))
1028 jbd_lock_bh_state(bg_bh
);
1029 bg
= (struct ocfs2_group_desc
*) bh2jh(bg_bh
)->b_committed_data
;
1031 ret
= !ocfs2_test_bit(nr
, (unsigned long *)bg
->bg_bitmap
);
1034 jbd_unlock_bh_state(bg_bh
);
1039 static int ocfs2_block_group_find_clear_bits(struct ocfs2_super
*osb
,
1040 struct buffer_head
*bg_bh
,
1041 unsigned int bits_wanted
,
1042 unsigned int total_bits
,
1047 u16 best_offset
, best_size
;
1048 int offset
, start
, found
, status
= 0;
1049 struct ocfs2_group_desc
*bg
= (struct ocfs2_group_desc
*) bg_bh
->b_data
;
1051 /* Callers got this descriptor from
1052 * ocfs2_read_group_descriptor(). Any corruption is a code bug. */
1053 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg
));
1055 found
= start
= best_offset
= best_size
= 0;
1056 bitmap
= bg
->bg_bitmap
;
1058 while((offset
= ocfs2_find_next_zero_bit(bitmap
, total_bits
, start
)) != -1) {
1059 if (offset
== total_bits
)
1062 if (!ocfs2_test_bg_bit_allocatable(bg_bh
, offset
)) {
1063 /* We found a zero, but we can't use it as it
1064 * hasn't been put to disk yet! */
1067 } else if (offset
== start
) {
1068 /* we found a zero */
1070 /* move start to the next bit to test */
1073 /* got a zero after some ones */
1077 if (found
> best_size
) {
1079 best_offset
= start
- found
;
1081 /* we got everything we needed */
1082 if (found
== bits_wanted
) {
1083 /* mlog(0, "Found it all!\n"); */
1088 /* XXX: I think the first clause is equivalent to the second
1090 if (found
== bits_wanted
) {
1091 *bit_off
= start
- found
;
1092 *bits_found
= found
;
1093 } else if (best_size
) {
1094 *bit_off
= best_offset
;
1095 *bits_found
= best_size
;
1098 /* No error log here -- see the comment above
1099 * ocfs2_test_bg_bit_allocatable */
1105 static inline int ocfs2_block_group_set_bits(handle_t
*handle
,
1106 struct inode
*alloc_inode
,
1107 struct ocfs2_group_desc
*bg
,
1108 struct buffer_head
*group_bh
,
1109 unsigned int bit_off
,
1110 unsigned int num_bits
)
1113 void *bitmap
= bg
->bg_bitmap
;
1114 int journal_type
= OCFS2_JOURNAL_ACCESS_WRITE
;
1118 /* All callers get the descriptor via
1119 * ocfs2_read_group_descriptor(). Any corruption is a code bug. */
1120 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg
));
1121 BUG_ON(le16_to_cpu(bg
->bg_free_bits_count
) < num_bits
);
1123 mlog(0, "block_group_set_bits: off = %u, num = %u\n", bit_off
,
1126 if (ocfs2_is_cluster_bitmap(alloc_inode
))
1127 journal_type
= OCFS2_JOURNAL_ACCESS_UNDO
;
1129 status
= ocfs2_journal_access_gd(handle
,
1130 INODE_CACHE(alloc_inode
),
1138 le16_add_cpu(&bg
->bg_free_bits_count
, -num_bits
);
1141 ocfs2_set_bit(bit_off
++, bitmap
);
1143 status
= ocfs2_journal_dirty(handle
,
1155 /* find the one with the most empty bits */
1156 static inline u16
ocfs2_find_victim_chain(struct ocfs2_chain_list
*cl
)
1160 BUG_ON(!cl
->cl_next_free_rec
);
1163 while (curr
< le16_to_cpu(cl
->cl_next_free_rec
)) {
1164 if (le32_to_cpu(cl
->cl_recs
[curr
].c_free
) >
1165 le32_to_cpu(cl
->cl_recs
[best
].c_free
))
1170 BUG_ON(best
>= le16_to_cpu(cl
->cl_next_free_rec
));
1174 static int ocfs2_relink_block_group(handle_t
*handle
,
1175 struct inode
*alloc_inode
,
1176 struct buffer_head
*fe_bh
,
1177 struct buffer_head
*bg_bh
,
1178 struct buffer_head
*prev_bg_bh
,
1182 /* there is a really tiny chance the journal calls could fail,
1183 * but we wouldn't want inconsistent blocks in *any* case. */
1184 u64 fe_ptr
, bg_ptr
, prev_bg_ptr
;
1185 struct ocfs2_dinode
*fe
= (struct ocfs2_dinode
*) fe_bh
->b_data
;
1186 struct ocfs2_group_desc
*bg
= (struct ocfs2_group_desc
*) bg_bh
->b_data
;
1187 struct ocfs2_group_desc
*prev_bg
= (struct ocfs2_group_desc
*) prev_bg_bh
->b_data
;
1189 /* The caller got these descriptors from
1190 * ocfs2_read_group_descriptor(). Any corruption is a code bug. */
1191 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg
));
1192 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(prev_bg
));
1194 mlog(0, "Suballoc %llu, chain %u, move group %llu to top, prev = %llu\n",
1195 (unsigned long long)le64_to_cpu(fe
->i_blkno
), chain
,
1196 (unsigned long long)le64_to_cpu(bg
->bg_blkno
),
1197 (unsigned long long)le64_to_cpu(prev_bg
->bg_blkno
));
1199 fe_ptr
= le64_to_cpu(fe
->id2
.i_chain
.cl_recs
[chain
].c_blkno
);
1200 bg_ptr
= le64_to_cpu(bg
->bg_next_group
);
1201 prev_bg_ptr
= le64_to_cpu(prev_bg
->bg_next_group
);
1203 status
= ocfs2_journal_access_gd(handle
, INODE_CACHE(alloc_inode
),
1205 OCFS2_JOURNAL_ACCESS_WRITE
);
1211 prev_bg
->bg_next_group
= bg
->bg_next_group
;
1213 status
= ocfs2_journal_dirty(handle
, prev_bg_bh
);
1219 status
= ocfs2_journal_access_gd(handle
, INODE_CACHE(alloc_inode
),
1220 bg_bh
, OCFS2_JOURNAL_ACCESS_WRITE
);
1226 bg
->bg_next_group
= fe
->id2
.i_chain
.cl_recs
[chain
].c_blkno
;
1228 status
= ocfs2_journal_dirty(handle
, bg_bh
);
1234 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(alloc_inode
),
1235 fe_bh
, OCFS2_JOURNAL_ACCESS_WRITE
);
1241 fe
->id2
.i_chain
.cl_recs
[chain
].c_blkno
= bg
->bg_blkno
;
1243 status
= ocfs2_journal_dirty(handle
, fe_bh
);
1252 fe
->id2
.i_chain
.cl_recs
[chain
].c_blkno
= cpu_to_le64(fe_ptr
);
1253 bg
->bg_next_group
= cpu_to_le64(bg_ptr
);
1254 prev_bg
->bg_next_group
= cpu_to_le64(prev_bg_ptr
);
1261 static inline int ocfs2_block_group_reasonably_empty(struct ocfs2_group_desc
*bg
,
1264 return le16_to_cpu(bg
->bg_free_bits_count
) > wanted
;
1267 /* return 0 on success, -ENOSPC to keep searching and any other < 0
1268 * value on error. */
1269 static int ocfs2_cluster_group_search(struct inode
*inode
,
1270 struct buffer_head
*group_bh
,
1271 u32 bits_wanted
, u32 min_bits
,
1273 u16
*bit_off
, u16
*bits_found
)
1275 int search
= -ENOSPC
;
1278 struct ocfs2_group_desc
*gd
= (struct ocfs2_group_desc
*) group_bh
->b_data
;
1279 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
1280 u16 tmp_off
, tmp_found
;
1281 unsigned int max_bits
, gd_cluster_off
;
1283 BUG_ON(!ocfs2_is_cluster_bitmap(inode
));
1285 if (gd
->bg_free_bits_count
) {
1286 max_bits
= le16_to_cpu(gd
->bg_bits
);
1288 /* Tail groups in cluster bitmaps which aren't cpg
1289 * aligned are prone to partial extention by a failed
1290 * fs resize. If the file system resize never got to
1291 * update the dinode cluster count, then we don't want
1292 * to trust any clusters past it, regardless of what
1293 * the group descriptor says. */
1294 gd_cluster_off
= ocfs2_blocks_to_clusters(inode
->i_sb
,
1295 le64_to_cpu(gd
->bg_blkno
));
1296 if ((gd_cluster_off
+ max_bits
) >
1297 OCFS2_I(inode
)->ip_clusters
) {
1298 max_bits
= OCFS2_I(inode
)->ip_clusters
- gd_cluster_off
;
1299 mlog(0, "Desc %llu, bg_bits %u, clusters %u, use %u\n",
1300 (unsigned long long)le64_to_cpu(gd
->bg_blkno
),
1301 le16_to_cpu(gd
->bg_bits
),
1302 OCFS2_I(inode
)->ip_clusters
, max_bits
);
1305 ret
= ocfs2_block_group_find_clear_bits(OCFS2_SB(inode
->i_sb
),
1306 group_bh
, bits_wanted
,
1308 &tmp_off
, &tmp_found
);
1313 blkoff
= ocfs2_clusters_to_blocks(inode
->i_sb
,
1315 tmp_off
+ tmp_found
);
1316 mlog(0, "Checking %llu against %llu\n",
1317 (unsigned long long)blkoff
,
1318 (unsigned long long)max_block
);
1319 if (blkoff
> max_block
)
1323 /* ocfs2_block_group_find_clear_bits() might
1324 * return success, but we still want to return
1325 * -ENOSPC unless it found the minimum number
1327 if (min_bits
<= tmp_found
) {
1329 *bits_found
= tmp_found
;
1330 search
= 0; /* success */
1331 } else if (tmp_found
) {
1333 * Don't show bits which we'll be returning
1334 * for allocation to the local alloc bitmap.
1336 ocfs2_local_alloc_seen_free_bits(osb
, tmp_found
);
1343 static int ocfs2_block_group_search(struct inode
*inode
,
1344 struct buffer_head
*group_bh
,
1345 u32 bits_wanted
, u32 min_bits
,
1347 u16
*bit_off
, u16
*bits_found
)
1351 struct ocfs2_group_desc
*bg
= (struct ocfs2_group_desc
*) group_bh
->b_data
;
1353 BUG_ON(min_bits
!= 1);
1354 BUG_ON(ocfs2_is_cluster_bitmap(inode
));
1356 if (bg
->bg_free_bits_count
) {
1357 ret
= ocfs2_block_group_find_clear_bits(OCFS2_SB(inode
->i_sb
),
1358 group_bh
, bits_wanted
,
1359 le16_to_cpu(bg
->bg_bits
),
1360 bit_off
, bits_found
);
1361 if (!ret
&& max_block
) {
1362 blkoff
= le64_to_cpu(bg
->bg_blkno
) + *bit_off
+
1364 mlog(0, "Checking %llu against %llu\n",
1365 (unsigned long long)blkoff
,
1366 (unsigned long long)max_block
);
1367 if (blkoff
> max_block
)
1375 static int ocfs2_alloc_dinode_update_counts(struct inode
*inode
,
1377 struct buffer_head
*di_bh
,
1383 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*) di_bh
->b_data
;
1384 struct ocfs2_chain_list
*cl
= (struct ocfs2_chain_list
*) &di
->id2
.i_chain
;
1386 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), di_bh
,
1387 OCFS2_JOURNAL_ACCESS_WRITE
);
1393 tmp_used
= le32_to_cpu(di
->id1
.bitmap1
.i_used
);
1394 di
->id1
.bitmap1
.i_used
= cpu_to_le32(num_bits
+ tmp_used
);
1395 le32_add_cpu(&cl
->cl_recs
[chain
].c_free
, -num_bits
);
1397 ret
= ocfs2_journal_dirty(handle
, di_bh
);
1405 static int ocfs2_search_one_group(struct ocfs2_alloc_context
*ac
,
1410 unsigned int *num_bits
,
1416 struct buffer_head
*group_bh
= NULL
;
1417 struct ocfs2_group_desc
*gd
;
1418 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)ac
->ac_bh
->b_data
;
1419 struct inode
*alloc_inode
= ac
->ac_inode
;
1421 ret
= ocfs2_read_group_descriptor(alloc_inode
, di
, gd_blkno
,
1428 gd
= (struct ocfs2_group_desc
*) group_bh
->b_data
;
1429 ret
= ac
->ac_group_search(alloc_inode
, group_bh
, bits_wanted
, min_bits
,
1430 ac
->ac_max_block
, bit_off
, &found
);
1439 ret
= ocfs2_alloc_dinode_update_counts(alloc_inode
, handle
, ac
->ac_bh
,
1441 le16_to_cpu(gd
->bg_chain
));
1447 ret
= ocfs2_block_group_set_bits(handle
, alloc_inode
, gd
, group_bh
,
1448 *bit_off
, *num_bits
);
1452 *bits_left
= le16_to_cpu(gd
->bg_free_bits_count
);
1460 static int ocfs2_search_chain(struct ocfs2_alloc_context
*ac
,
1465 unsigned int *num_bits
,
1470 u16 chain
, tmp_bits
;
1473 struct inode
*alloc_inode
= ac
->ac_inode
;
1474 struct buffer_head
*group_bh
= NULL
;
1475 struct buffer_head
*prev_group_bh
= NULL
;
1476 struct ocfs2_dinode
*fe
= (struct ocfs2_dinode
*) ac
->ac_bh
->b_data
;
1477 struct ocfs2_chain_list
*cl
= (struct ocfs2_chain_list
*) &fe
->id2
.i_chain
;
1478 struct ocfs2_group_desc
*bg
;
1480 chain
= ac
->ac_chain
;
1481 mlog(0, "trying to alloc %u bits from chain %u, inode %llu\n",
1483 (unsigned long long)OCFS2_I(alloc_inode
)->ip_blkno
);
1485 status
= ocfs2_read_group_descriptor(alloc_inode
, fe
,
1486 le64_to_cpu(cl
->cl_recs
[chain
].c_blkno
),
1492 bg
= (struct ocfs2_group_desc
*) group_bh
->b_data
;
1495 /* for now, the chain search is a bit simplistic. We just use
1496 * the 1st group with any empty bits. */
1497 while ((status
= ac
->ac_group_search(alloc_inode
, group_bh
,
1498 bits_wanted
, min_bits
,
1499 ac
->ac_max_block
, bit_off
,
1500 &tmp_bits
)) == -ENOSPC
) {
1501 if (!bg
->bg_next_group
)
1504 brelse(prev_group_bh
);
1505 prev_group_bh
= NULL
;
1507 next_group
= le64_to_cpu(bg
->bg_next_group
);
1508 prev_group_bh
= group_bh
;
1510 status
= ocfs2_read_group_descriptor(alloc_inode
, fe
,
1511 next_group
, &group_bh
);
1516 bg
= (struct ocfs2_group_desc
*) group_bh
->b_data
;
1519 if (status
!= -ENOSPC
)
1524 mlog(0, "alloc succeeds: we give %u bits from block group %llu\n",
1525 tmp_bits
, (unsigned long long)le64_to_cpu(bg
->bg_blkno
));
1527 *num_bits
= tmp_bits
;
1529 BUG_ON(*num_bits
== 0);
1532 * Keep track of previous block descriptor read. When
1533 * we find a target, if we have read more than X
1534 * number of descriptors, and the target is reasonably
1535 * empty, relink him to top of his chain.
1537 * We've read 0 extra blocks and only send one more to
1538 * the transaction, yet the next guy to search has a
1541 * Do this *after* figuring out how many bits we're taking out
1542 * of our target group.
1544 if (ac
->ac_allow_chain_relink
&&
1546 (ocfs2_block_group_reasonably_empty(bg
, *num_bits
))) {
1547 status
= ocfs2_relink_block_group(handle
, alloc_inode
,
1548 ac
->ac_bh
, group_bh
,
1549 prev_group_bh
, chain
);
1556 /* Ok, claim our bits now: set the info on dinode, chainlist
1557 * and then the group */
1558 status
= ocfs2_journal_access_di(handle
,
1559 INODE_CACHE(alloc_inode
),
1561 OCFS2_JOURNAL_ACCESS_WRITE
);
1567 tmp_used
= le32_to_cpu(fe
->id1
.bitmap1
.i_used
);
1568 fe
->id1
.bitmap1
.i_used
= cpu_to_le32(*num_bits
+ tmp_used
);
1569 le32_add_cpu(&cl
->cl_recs
[chain
].c_free
, -(*num_bits
));
1571 status
= ocfs2_journal_dirty(handle
,
1578 status
= ocfs2_block_group_set_bits(handle
,
1589 mlog(0, "Allocated %u bits from suballocator %llu\n", *num_bits
,
1590 (unsigned long long)le64_to_cpu(fe
->i_blkno
));
1592 *bg_blkno
= le64_to_cpu(bg
->bg_blkno
);
1593 *bits_left
= le16_to_cpu(bg
->bg_free_bits_count
);
1596 brelse(prev_group_bh
);
1602 /* will give out up to bits_wanted contiguous bits. */
1603 static int ocfs2_claim_suballoc_bits(struct ocfs2_super
*osb
,
1604 struct ocfs2_alloc_context
*ac
,
1609 unsigned int *num_bits
,
1615 u64 hint_blkno
= ac
->ac_last_group
;
1616 struct ocfs2_chain_list
*cl
;
1617 struct ocfs2_dinode
*fe
;
1621 BUG_ON(ac
->ac_bits_given
>= ac
->ac_bits_wanted
);
1622 BUG_ON(bits_wanted
> (ac
->ac_bits_wanted
- ac
->ac_bits_given
));
1625 fe
= (struct ocfs2_dinode
*) ac
->ac_bh
->b_data
;
1627 /* The bh was validated by the inode read during
1628 * ocfs2_reserve_suballoc_bits(). Any corruption is a code bug. */
1629 BUG_ON(!OCFS2_IS_VALID_DINODE(fe
));
1631 if (le32_to_cpu(fe
->id1
.bitmap1
.i_used
) >=
1632 le32_to_cpu(fe
->id1
.bitmap1
.i_total
)) {
1633 ocfs2_error(osb
->sb
, "Chain allocator dinode %llu has %u used "
1634 "bits but only %u total.",
1635 (unsigned long long)le64_to_cpu(fe
->i_blkno
),
1636 le32_to_cpu(fe
->id1
.bitmap1
.i_used
),
1637 le32_to_cpu(fe
->id1
.bitmap1
.i_total
));
1643 /* Attempt to short-circuit the usual search mechanism
1644 * by jumping straight to the most recently used
1645 * allocation group. This helps us mantain some
1646 * contiguousness across allocations. */
1647 status
= ocfs2_search_one_group(ac
, handle
, bits_wanted
,
1648 min_bits
, bit_off
, num_bits
,
1649 hint_blkno
, &bits_left
);
1651 /* Be careful to update *bg_blkno here as the
1652 * caller is expecting it to be filled in, and
1653 * ocfs2_search_one_group() won't do that for
1655 *bg_blkno
= hint_blkno
;
1658 if (status
< 0 && status
!= -ENOSPC
) {
1664 cl
= (struct ocfs2_chain_list
*) &fe
->id2
.i_chain
;
1666 victim
= ocfs2_find_victim_chain(cl
);
1667 ac
->ac_chain
= victim
;
1668 ac
->ac_allow_chain_relink
= 1;
1670 status
= ocfs2_search_chain(ac
, handle
, bits_wanted
, min_bits
, bit_off
,
1671 num_bits
, bg_blkno
, &bits_left
);
1674 if (status
< 0 && status
!= -ENOSPC
) {
1679 mlog(0, "Search of victim chain %u came up with nothing, "
1680 "trying all chains now.\n", victim
);
1682 /* If we didn't pick a good victim, then just default to
1683 * searching each chain in order. Don't allow chain relinking
1684 * because we only calculate enough journal credits for one
1685 * relink per alloc. */
1686 ac
->ac_allow_chain_relink
= 0;
1687 for (i
= 0; i
< le16_to_cpu(cl
->cl_next_free_rec
); i
++) {
1690 if (!cl
->cl_recs
[i
].c_free
)
1694 status
= ocfs2_search_chain(ac
, handle
, bits_wanted
, min_bits
,
1695 bit_off
, num_bits
, bg_blkno
,
1699 if (status
< 0 && status
!= -ENOSPC
) {
1706 if (status
!= -ENOSPC
) {
1707 /* If the next search of this group is not likely to
1708 * yield a suitable extent, then we reset the last
1709 * group hint so as to not waste a disk read */
1710 if (bits_left
< min_bits
)
1711 ac
->ac_last_group
= 0;
1713 ac
->ac_last_group
= *bg_blkno
;
1721 int ocfs2_claim_metadata(struct ocfs2_super
*osb
,
1723 struct ocfs2_alloc_context
*ac
,
1725 u16
*suballoc_bit_start
,
1726 unsigned int *num_bits
,
1733 BUG_ON(ac
->ac_bits_wanted
< (ac
->ac_bits_given
+ bits_wanted
));
1734 BUG_ON(ac
->ac_which
!= OCFS2_AC_USE_META
);
1736 status
= ocfs2_claim_suballoc_bits(osb
,
1748 atomic_inc(&osb
->alloc_stats
.bg_allocs
);
1750 *blkno_start
= bg_blkno
+ (u64
) *suballoc_bit_start
;
1751 ac
->ac_bits_given
+= (*num_bits
);
1758 static void ocfs2_init_inode_ac_group(struct inode
*dir
,
1759 struct buffer_head
*parent_fe_bh
,
1760 struct ocfs2_alloc_context
*ac
)
1762 struct ocfs2_dinode
*fe
= (struct ocfs2_dinode
*)parent_fe_bh
->b_data
;
1764 * Try to allocate inodes from some specific group.
1766 * If the parent dir has recorded the last group used in allocation,
1767 * cool, use it. Otherwise if we try to allocate new inode from the
1768 * same slot the parent dir belongs to, use the same chunk.
1770 * We are very careful here to avoid the mistake of setting
1771 * ac_last_group to a group descriptor from a different (unlocked) slot.
1773 if (OCFS2_I(dir
)->ip_last_used_group
&&
1774 OCFS2_I(dir
)->ip_last_used_slot
== ac
->ac_alloc_slot
)
1775 ac
->ac_last_group
= OCFS2_I(dir
)->ip_last_used_group
;
1776 else if (le16_to_cpu(fe
->i_suballoc_slot
) == ac
->ac_alloc_slot
)
1777 ac
->ac_last_group
= ocfs2_which_suballoc_group(
1778 le64_to_cpu(fe
->i_blkno
),
1779 le16_to_cpu(fe
->i_suballoc_bit
));
1782 static inline void ocfs2_save_inode_ac_group(struct inode
*dir
,
1783 struct ocfs2_alloc_context
*ac
)
1785 OCFS2_I(dir
)->ip_last_used_group
= ac
->ac_last_group
;
1786 OCFS2_I(dir
)->ip_last_used_slot
= ac
->ac_alloc_slot
;
1789 int ocfs2_claim_new_inode(struct ocfs2_super
*osb
,
1792 struct buffer_head
*parent_fe_bh
,
1793 struct ocfs2_alloc_context
*ac
,
1798 unsigned int num_bits
;
1804 BUG_ON(ac
->ac_bits_given
!= 0);
1805 BUG_ON(ac
->ac_bits_wanted
!= 1);
1806 BUG_ON(ac
->ac_which
!= OCFS2_AC_USE_INODE
);
1808 ocfs2_init_inode_ac_group(dir
, parent_fe_bh
, ac
);
1810 status
= ocfs2_claim_suballoc_bits(osb
,
1822 atomic_inc(&osb
->alloc_stats
.bg_allocs
);
1824 BUG_ON(num_bits
!= 1);
1826 *fe_blkno
= bg_blkno
+ (u64
) (*suballoc_bit
);
1827 ac
->ac_bits_given
++;
1828 ocfs2_save_inode_ac_group(dir
, ac
);
1835 /* translate a group desc. blkno and it's bitmap offset into
1836 * disk cluster offset. */
1837 static inline u32
ocfs2_desc_bitmap_to_cluster_off(struct inode
*inode
,
1841 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
1844 BUG_ON(!ocfs2_is_cluster_bitmap(inode
));
1846 if (bg_blkno
!= osb
->first_cluster_group_blkno
)
1847 cluster
= ocfs2_blocks_to_clusters(inode
->i_sb
, bg_blkno
);
1848 cluster
+= (u32
) bg_bit_off
;
1852 /* given a cluster offset, calculate which block group it belongs to
1853 * and return that block offset. */
1854 u64
ocfs2_which_cluster_group(struct inode
*inode
, u32 cluster
)
1856 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
1859 BUG_ON(!ocfs2_is_cluster_bitmap(inode
));
1861 group_no
= cluster
/ osb
->bitmap_cpg
;
1863 return osb
->first_cluster_group_blkno
;
1864 return ocfs2_clusters_to_blocks(inode
->i_sb
,
1865 group_no
* osb
->bitmap_cpg
);
1868 /* given the block number of a cluster start, calculate which cluster
1869 * group and descriptor bitmap offset that corresponds to. */
1870 static inline void ocfs2_block_to_cluster_group(struct inode
*inode
,
1875 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
1876 u32 data_cluster
= ocfs2_blocks_to_clusters(osb
->sb
, data_blkno
);
1878 BUG_ON(!ocfs2_is_cluster_bitmap(inode
));
1880 *bg_blkno
= ocfs2_which_cluster_group(inode
,
1883 if (*bg_blkno
== osb
->first_cluster_group_blkno
)
1884 *bg_bit_off
= (u16
) data_cluster
;
1886 *bg_bit_off
= (u16
) ocfs2_blocks_to_clusters(osb
->sb
,
1887 data_blkno
- *bg_blkno
);
1891 * min_bits - minimum contiguous chunk from this total allocation we
1892 * can handle. set to what we asked for originally for a full
1893 * contig. allocation, set to '1' to indicate we can deal with extents
1896 int __ocfs2_claim_clusters(struct ocfs2_super
*osb
,
1898 struct ocfs2_alloc_context
*ac
,
1905 unsigned int bits_wanted
= max_clusters
;
1911 BUG_ON(ac
->ac_bits_given
>= ac
->ac_bits_wanted
);
1913 BUG_ON(ac
->ac_which
!= OCFS2_AC_USE_LOCAL
1914 && ac
->ac_which
!= OCFS2_AC_USE_MAIN
);
1916 if (ac
->ac_which
== OCFS2_AC_USE_LOCAL
) {
1917 status
= ocfs2_claim_local_alloc_bits(osb
,
1924 atomic_inc(&osb
->alloc_stats
.local_data
);
1926 if (min_clusters
> (osb
->bitmap_cpg
- 1)) {
1927 /* The only paths asking for contiguousness
1928 * should know about this already. */
1929 mlog(ML_ERROR
, "minimum allocation requested %u exceeds "
1930 "group bitmap size %u!\n", min_clusters
,
1935 /* clamp the current request down to a realistic size. */
1936 if (bits_wanted
> (osb
->bitmap_cpg
- 1))
1937 bits_wanted
= osb
->bitmap_cpg
- 1;
1939 status
= ocfs2_claim_suballoc_bits(osb
,
1949 ocfs2_desc_bitmap_to_cluster_off(ac
->ac_inode
,
1952 atomic_inc(&osb
->alloc_stats
.bitmap_data
);
1956 if (status
!= -ENOSPC
)
1961 ac
->ac_bits_given
+= *num_clusters
;
1968 int ocfs2_claim_clusters(struct ocfs2_super
*osb
,
1970 struct ocfs2_alloc_context
*ac
,
1975 unsigned int bits_wanted
= ac
->ac_bits_wanted
- ac
->ac_bits_given
;
1977 return __ocfs2_claim_clusters(osb
, handle
, ac
, min_clusters
,
1978 bits_wanted
, cluster_start
, num_clusters
);
1981 static inline int ocfs2_block_group_clear_bits(handle_t
*handle
,
1982 struct inode
*alloc_inode
,
1983 struct ocfs2_group_desc
*bg
,
1984 struct buffer_head
*group_bh
,
1985 unsigned int bit_off
,
1986 unsigned int num_bits
)
1990 int journal_type
= OCFS2_JOURNAL_ACCESS_WRITE
;
1991 struct ocfs2_group_desc
*undo_bg
= NULL
;
1992 int cluster_bitmap
= 0;
1996 /* The caller got this descriptor from
1997 * ocfs2_read_group_descriptor(). Any corruption is a code bug. */
1998 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg
));
2000 mlog(0, "off = %u, num = %u\n", bit_off
, num_bits
);
2002 if (ocfs2_is_cluster_bitmap(alloc_inode
))
2003 journal_type
= OCFS2_JOURNAL_ACCESS_UNDO
;
2005 status
= ocfs2_journal_access_gd(handle
, INODE_CACHE(alloc_inode
),
2006 group_bh
, journal_type
);
2012 if (ocfs2_is_cluster_bitmap(alloc_inode
))
2015 if (cluster_bitmap
) {
2016 jbd_lock_bh_state(group_bh
);
2017 undo_bg
= (struct ocfs2_group_desc
*)
2018 bh2jh(group_bh
)->b_committed_data
;
2024 ocfs2_clear_bit((bit_off
+ tmp
),
2025 (unsigned long *) bg
->bg_bitmap
);
2027 ocfs2_set_bit(bit_off
+ tmp
,
2028 (unsigned long *) undo_bg
->bg_bitmap
);
2030 le16_add_cpu(&bg
->bg_free_bits_count
, num_bits
);
2033 jbd_unlock_bh_state(group_bh
);
2035 status
= ocfs2_journal_dirty(handle
, group_bh
);
2043 * expects the suballoc inode to already be locked.
2045 int ocfs2_free_suballoc_bits(handle_t
*handle
,
2046 struct inode
*alloc_inode
,
2047 struct buffer_head
*alloc_bh
,
2048 unsigned int start_bit
,
2054 struct ocfs2_dinode
*fe
= (struct ocfs2_dinode
*) alloc_bh
->b_data
;
2055 struct ocfs2_chain_list
*cl
= &fe
->id2
.i_chain
;
2056 struct buffer_head
*group_bh
= NULL
;
2057 struct ocfs2_group_desc
*group
;
2061 /* The alloc_bh comes from ocfs2_free_dinode() or
2062 * ocfs2_free_clusters(). The callers have all locked the
2063 * allocator and gotten alloc_bh from the lock call. This
2064 * validates the dinode buffer. Any corruption that has happended
2066 BUG_ON(!OCFS2_IS_VALID_DINODE(fe
));
2067 BUG_ON((count
+ start_bit
) > ocfs2_bits_per_group(cl
));
2069 mlog(0, "%llu: freeing %u bits from group %llu, starting at %u\n",
2070 (unsigned long long)OCFS2_I(alloc_inode
)->ip_blkno
, count
,
2071 (unsigned long long)bg_blkno
, start_bit
);
2073 status
= ocfs2_read_group_descriptor(alloc_inode
, fe
, bg_blkno
,
2079 group
= (struct ocfs2_group_desc
*) group_bh
->b_data
;
2081 BUG_ON((count
+ start_bit
) > le16_to_cpu(group
->bg_bits
));
2083 status
= ocfs2_block_group_clear_bits(handle
, alloc_inode
,
2091 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(alloc_inode
),
2092 alloc_bh
, OCFS2_JOURNAL_ACCESS_WRITE
);
2098 le32_add_cpu(&cl
->cl_recs
[le16_to_cpu(group
->bg_chain
)].c_free
,
2100 tmp_used
= le32_to_cpu(fe
->id1
.bitmap1
.i_used
);
2101 fe
->id1
.bitmap1
.i_used
= cpu_to_le32(tmp_used
- count
);
2103 status
= ocfs2_journal_dirty(handle
, alloc_bh
);
2116 int ocfs2_free_dinode(handle_t
*handle
,
2117 struct inode
*inode_alloc_inode
,
2118 struct buffer_head
*inode_alloc_bh
,
2119 struct ocfs2_dinode
*di
)
2121 u64 blk
= le64_to_cpu(di
->i_blkno
);
2122 u16 bit
= le16_to_cpu(di
->i_suballoc_bit
);
2123 u64 bg_blkno
= ocfs2_which_suballoc_group(blk
, bit
);
2125 return ocfs2_free_suballoc_bits(handle
, inode_alloc_inode
,
2126 inode_alloc_bh
, bit
, bg_blkno
, 1);
2129 int ocfs2_free_clusters(handle_t
*handle
,
2130 struct inode
*bitmap_inode
,
2131 struct buffer_head
*bitmap_bh
,
2133 unsigned int num_clusters
)
2138 struct ocfs2_dinode
*fe
;
2140 /* You can't ever have a contiguous set of clusters
2141 * bigger than a block group bitmap so we never have to worry
2142 * about looping on them. */
2146 /* This is expensive. We can safely remove once this stuff has
2147 * gotten tested really well. */
2148 BUG_ON(start_blk
!= ocfs2_clusters_to_blocks(bitmap_inode
->i_sb
, ocfs2_blocks_to_clusters(bitmap_inode
->i_sb
, start_blk
)));
2150 fe
= (struct ocfs2_dinode
*) bitmap_bh
->b_data
;
2152 ocfs2_block_to_cluster_group(bitmap_inode
, start_blk
, &bg_blkno
,
2155 mlog(0, "want to free %u clusters starting at block %llu\n",
2156 num_clusters
, (unsigned long long)start_blk
);
2157 mlog(0, "bg_blkno = %llu, bg_start_bit = %u\n",
2158 (unsigned long long)bg_blkno
, bg_start_bit
);
2160 status
= ocfs2_free_suballoc_bits(handle
, bitmap_inode
, bitmap_bh
,
2161 bg_start_bit
, bg_blkno
,
2168 ocfs2_local_alloc_seen_free_bits(OCFS2_SB(bitmap_inode
->i_sb
),
2176 static inline void ocfs2_debug_bg(struct ocfs2_group_desc
*bg
)
2178 printk("Block Group:\n");
2179 printk("bg_signature: %s\n", bg
->bg_signature
);
2180 printk("bg_size: %u\n", bg
->bg_size
);
2181 printk("bg_bits: %u\n", bg
->bg_bits
);
2182 printk("bg_free_bits_count: %u\n", bg
->bg_free_bits_count
);
2183 printk("bg_chain: %u\n", bg
->bg_chain
);
2184 printk("bg_generation: %u\n", le32_to_cpu(bg
->bg_generation
));
2185 printk("bg_next_group: %llu\n",
2186 (unsigned long long)bg
->bg_next_group
);
2187 printk("bg_parent_dinode: %llu\n",
2188 (unsigned long long)bg
->bg_parent_dinode
);
2189 printk("bg_blkno: %llu\n",
2190 (unsigned long long)bg
->bg_blkno
);
2193 static inline void ocfs2_debug_suballoc_inode(struct ocfs2_dinode
*fe
)
2197 printk("Suballoc Inode %llu:\n", (unsigned long long)fe
->i_blkno
);
2198 printk("i_signature: %s\n", fe
->i_signature
);
2199 printk("i_size: %llu\n",
2200 (unsigned long long)fe
->i_size
);
2201 printk("i_clusters: %u\n", fe
->i_clusters
);
2202 printk("i_generation: %u\n",
2203 le32_to_cpu(fe
->i_generation
));
2204 printk("id1.bitmap1.i_used: %u\n",
2205 le32_to_cpu(fe
->id1
.bitmap1
.i_used
));
2206 printk("id1.bitmap1.i_total: %u\n",
2207 le32_to_cpu(fe
->id1
.bitmap1
.i_total
));
2208 printk("id2.i_chain.cl_cpg: %u\n", fe
->id2
.i_chain
.cl_cpg
);
2209 printk("id2.i_chain.cl_bpc: %u\n", fe
->id2
.i_chain
.cl_bpc
);
2210 printk("id2.i_chain.cl_count: %u\n", fe
->id2
.i_chain
.cl_count
);
2211 printk("id2.i_chain.cl_next_free_rec: %u\n",
2212 fe
->id2
.i_chain
.cl_next_free_rec
);
2213 for(i
= 0; i
< fe
->id2
.i_chain
.cl_next_free_rec
; i
++) {
2214 printk("fe->id2.i_chain.cl_recs[%d].c_free: %u\n", i
,
2215 fe
->id2
.i_chain
.cl_recs
[i
].c_free
);
2216 printk("fe->id2.i_chain.cl_recs[%d].c_total: %u\n", i
,
2217 fe
->id2
.i_chain
.cl_recs
[i
].c_total
);
2218 printk("fe->id2.i_chain.cl_recs[%d].c_blkno: %llu\n", i
,
2219 (unsigned long long)fe
->id2
.i_chain
.cl_recs
[i
].c_blkno
);
2224 * For a given allocation, determine which allocators will need to be
2225 * accessed, and lock them, reserving the appropriate number of bits.
2227 * Sparse file systems call this from ocfs2_write_begin_nolock()
2228 * and ocfs2_allocate_unwritten_extents().
2230 * File systems which don't support holes call this from
2231 * ocfs2_extend_allocation().
2233 int ocfs2_lock_allocators(struct inode
*inode
,
2234 struct ocfs2_extent_tree
*et
,
2235 u32 clusters_to_add
, u32 extents_to_split
,
2236 struct ocfs2_alloc_context
**data_ac
,
2237 struct ocfs2_alloc_context
**meta_ac
)
2239 int ret
= 0, num_free_extents
;
2240 unsigned int max_recs_needed
= clusters_to_add
+ 2 * extents_to_split
;
2241 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
2247 BUG_ON(clusters_to_add
!= 0 && data_ac
== NULL
);
2249 num_free_extents
= ocfs2_num_free_extents(osb
, et
);
2250 if (num_free_extents
< 0) {
2251 ret
= num_free_extents
;
2257 * Sparse allocation file systems need to be more conservative
2258 * with reserving room for expansion - the actual allocation
2259 * happens while we've got a journal handle open so re-taking
2260 * a cluster lock (because we ran out of room for another
2261 * extent) will violate ordering rules.
2263 * Most of the time we'll only be seeing this 1 cluster at a time
2266 * Always lock for any unwritten extents - we might want to
2267 * add blocks during a split.
2269 if (!num_free_extents
||
2270 (ocfs2_sparse_alloc(osb
) && num_free_extents
< max_recs_needed
)) {
2271 ret
= ocfs2_reserve_new_metadata(osb
, et
->et_root_el
, meta_ac
);
2279 if (clusters_to_add
== 0)
2282 ret
= ocfs2_reserve_clusters(osb
, clusters_to_add
, data_ac
);
2292 ocfs2_free_alloc_context(*meta_ac
);
2297 * We cannot have an error and a non null *data_ac.
2305 * Read the inode specified by blkno to get suballoc_slot and
2308 static int ocfs2_get_suballoc_slot_bit(struct ocfs2_super
*osb
, u64 blkno
,
2309 u16
*suballoc_slot
, u16
*suballoc_bit
)
2312 struct buffer_head
*inode_bh
= NULL
;
2313 struct ocfs2_dinode
*inode_fe
;
2315 mlog_entry("blkno: %llu\n", (unsigned long long)blkno
);
2317 /* dirty read disk */
2318 status
= ocfs2_read_blocks_sync(osb
, blkno
, 1, &inode_bh
);
2320 mlog(ML_ERROR
, "read block %llu failed %d\n",
2321 (unsigned long long)blkno
, status
);
2325 inode_fe
= (struct ocfs2_dinode
*) inode_bh
->b_data
;
2326 if (!OCFS2_IS_VALID_DINODE(inode_fe
)) {
2327 mlog(ML_ERROR
, "invalid inode %llu requested\n",
2328 (unsigned long long)blkno
);
2333 if (le16_to_cpu(inode_fe
->i_suballoc_slot
) != (u16
)OCFS2_INVALID_SLOT
&&
2334 (u32
)le16_to_cpu(inode_fe
->i_suballoc_slot
) > osb
->max_slots
- 1) {
2335 mlog(ML_ERROR
, "inode %llu has invalid suballoc slot %u\n",
2336 (unsigned long long)blkno
,
2337 (u32
)le16_to_cpu(inode_fe
->i_suballoc_slot
));
2343 *suballoc_slot
= le16_to_cpu(inode_fe
->i_suballoc_slot
);
2345 *suballoc_bit
= le16_to_cpu(inode_fe
->i_suballoc_bit
);
2355 * test whether bit is SET in allocator bitmap or not. on success, 0
2356 * is returned and *res is 1 for SET; 0 otherwise. when fails, errno
2357 * is returned and *res is meaningless. Call this after you have
2358 * cluster locked against suballoc, or you may get a result based on
2359 * non-up2date contents
2361 static int ocfs2_test_suballoc_bit(struct ocfs2_super
*osb
,
2362 struct inode
*suballoc
,
2363 struct buffer_head
*alloc_bh
, u64 blkno
,
2366 struct ocfs2_dinode
*alloc_fe
;
2367 struct ocfs2_group_desc
*group
;
2368 struct buffer_head
*group_bh
= NULL
;
2372 mlog_entry("blkno: %llu bit: %u\n", (unsigned long long)blkno
,
2375 alloc_fe
= (struct ocfs2_dinode
*)alloc_bh
->b_data
;
2376 if ((bit
+ 1) > ocfs2_bits_per_group(&alloc_fe
->id2
.i_chain
)) {
2377 mlog(ML_ERROR
, "suballoc bit %u out of range of %u\n",
2379 ocfs2_bits_per_group(&alloc_fe
->id2
.i_chain
));
2384 bg_blkno
= ocfs2_which_suballoc_group(blkno
, bit
);
2385 status
= ocfs2_read_group_descriptor(suballoc
, alloc_fe
, bg_blkno
,
2388 mlog(ML_ERROR
, "read group %llu failed %d\n",
2389 (unsigned long long)bg_blkno
, status
);
2393 group
= (struct ocfs2_group_desc
*) group_bh
->b_data
;
2394 *res
= ocfs2_test_bit(bit
, (unsigned long *)group
->bg_bitmap
);
2404 * Test if the bit representing this inode (blkno) is set in the
2407 * On success, 0 is returned and *res is 1 for SET; 0 otherwise.
2409 * In the event of failure, a negative value is returned and *res is
2412 * Callers must make sure to hold nfs_sync_lock to prevent
2413 * ocfs2_delete_inode() on another node from accessing the same
2414 * suballocator concurrently.
2416 int ocfs2_test_inode_bit(struct ocfs2_super
*osb
, u64 blkno
, int *res
)
2419 u16 suballoc_bit
= 0, suballoc_slot
= 0;
2420 struct inode
*inode_alloc_inode
;
2421 struct buffer_head
*alloc_bh
= NULL
;
2423 mlog_entry("blkno: %llu", (unsigned long long)blkno
);
2425 status
= ocfs2_get_suballoc_slot_bit(osb
, blkno
, &suballoc_slot
,
2428 mlog(ML_ERROR
, "get alloc slot and bit failed %d\n", status
);
2433 ocfs2_get_system_file_inode(osb
, INODE_ALLOC_SYSTEM_INODE
,
2435 if (!inode_alloc_inode
) {
2436 /* the error code could be inaccurate, but we are not able to
2437 * get the correct one. */
2439 mlog(ML_ERROR
, "unable to get alloc inode in slot %u\n",
2440 (u32
)suballoc_slot
);
2444 mutex_lock(&inode_alloc_inode
->i_mutex
);
2445 status
= ocfs2_inode_lock(inode_alloc_inode
, &alloc_bh
, 0);
2447 mutex_unlock(&inode_alloc_inode
->i_mutex
);
2448 mlog(ML_ERROR
, "lock on alloc inode on slot %u failed %d\n",
2449 (u32
)suballoc_slot
, status
);
2453 status
= ocfs2_test_suballoc_bit(osb
, inode_alloc_inode
, alloc_bh
,
2454 blkno
, suballoc_bit
, res
);
2456 mlog(ML_ERROR
, "test suballoc bit failed %d\n", status
);
2458 ocfs2_inode_unlock(inode_alloc_inode
, 0);
2459 mutex_unlock(&inode_alloc_inode
->i_mutex
);
2461 iput(inode_alloc_inode
);