1
2
3
4
5
6
7
8
9
10
11#include <linux/fs.h>
12#include <linux/types.h>
13#include <linux/slab.h>
14#include <linux/highmem.h>
15
16#include <cluster/masklog.h>
17
18#include "ocfs2.h"
19
20#include "alloc.h"
21#include "blockcheck.h"
22#include "dlmglue.h"
23#include "inode.h"
24#include "journal.h"
25#include "localalloc.h"
26#include "suballoc.h"
27#include "super.h"
28#include "sysfile.h"
29#include "uptodate.h"
30#include "ocfs2_trace.h"
31
32#include "buffer_head_io.h"
33
34#define NOT_ALLOC_NEW_GROUP 0
35#define ALLOC_NEW_GROUP 0x1
36#define ALLOC_GROUPS_FROM_GLOBAL 0x2
37
38#define OCFS2_MAX_TO_STEAL 1024
39
40struct ocfs2_suballoc_result {
41 u64 sr_bg_blkno;
42
43
44 u64 sr_bg_stable_blkno;
45
46
47
48
49
50 u64 sr_blkno;
51 unsigned int sr_bit_offset;
52 unsigned int sr_bits;
53};
54
55static u64 ocfs2_group_from_res(struct ocfs2_suballoc_result *res)
56{
57 if (res->sr_blkno == 0)
58 return 0;
59
60 if (res->sr_bg_blkno)
61 return res->sr_bg_blkno;
62
63 return ocfs2_which_suballoc_group(res->sr_blkno, res->sr_bit_offset);
64}
65
66static inline u16 ocfs2_find_victim_chain(struct ocfs2_chain_list *cl);
67static int ocfs2_block_group_fill(handle_t *handle,
68 struct inode *alloc_inode,
69 struct buffer_head *bg_bh,
70 u64 group_blkno,
71 unsigned int group_clusters,
72 u16 my_chain,
73 struct ocfs2_chain_list *cl);
74static int ocfs2_block_group_alloc(struct ocfs2_super *osb,
75 struct inode *alloc_inode,
76 struct buffer_head *bh,
77 u64 max_block,
78 u64 *last_alloc_group,
79 int flags);
80
81static int ocfs2_cluster_group_search(struct inode *inode,
82 struct buffer_head *group_bh,
83 u32 bits_wanted, u32 min_bits,
84 u64 max_block,
85 struct ocfs2_suballoc_result *res);
86static int ocfs2_block_group_search(struct inode *inode,
87 struct buffer_head *group_bh,
88 u32 bits_wanted, u32 min_bits,
89 u64 max_block,
90 struct ocfs2_suballoc_result *res);
91static int ocfs2_claim_suballoc_bits(struct ocfs2_alloc_context *ac,
92 handle_t *handle,
93 u32 bits_wanted,
94 u32 min_bits,
95 struct ocfs2_suballoc_result *res);
96static int ocfs2_test_bg_bit_allocatable(struct buffer_head *bg_bh,
97 int nr);
98static int ocfs2_relink_block_group(handle_t *handle,
99 struct inode *alloc_inode,
100 struct buffer_head *fe_bh,
101 struct buffer_head *bg_bh,
102 struct buffer_head *prev_bg_bh,
103 u16 chain);
104static inline int ocfs2_block_group_reasonably_empty(struct ocfs2_group_desc *bg,
105 u32 wanted);
106static inline u32 ocfs2_desc_bitmap_to_cluster_off(struct inode *inode,
107 u64 bg_blkno,
108 u16 bg_bit_off);
109static inline void ocfs2_block_to_cluster_group(struct inode *inode,
110 u64 data_blkno,
111 u64 *bg_blkno,
112 u16 *bg_bit_off);
113static int ocfs2_reserve_clusters_with_limit(struct ocfs2_super *osb,
114 u32 bits_wanted, u64 max_block,
115 int flags,
116 struct ocfs2_alloc_context **ac);
117
118void ocfs2_free_ac_resource(struct ocfs2_alloc_context *ac)
119{
120 struct inode *inode = ac->ac_inode;
121
122 if (inode) {
123 if (ac->ac_which != OCFS2_AC_USE_LOCAL)
124 ocfs2_inode_unlock(inode, 1);
125
126 inode_unlock(inode);
127
128 iput(inode);
129 ac->ac_inode = NULL;
130 }
131 brelse(ac->ac_bh);
132 ac->ac_bh = NULL;
133 ac->ac_resv = NULL;
134 kfree(ac->ac_find_loc_priv);
135 ac->ac_find_loc_priv = NULL;
136}
137
138void ocfs2_free_alloc_context(struct ocfs2_alloc_context *ac)
139{
140 ocfs2_free_ac_resource(ac);
141 kfree(ac);
142}
143
144static u32 ocfs2_bits_per_group(struct ocfs2_chain_list *cl)
145{
146 return (u32)le16_to_cpu(cl->cl_cpg) * (u32)le16_to_cpu(cl->cl_bpc);
147}
148
149#define do_error(fmt, ...) \
150do { \
151 if (resize) \
152 mlog(ML_ERROR, fmt, ##__VA_ARGS__); \
153 else \
154 return ocfs2_error(sb, fmt, ##__VA_ARGS__); \
155} while (0)
156
157static int ocfs2_validate_gd_self(struct super_block *sb,
158 struct buffer_head *bh,
159 int resize)
160{
161 struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *)bh->b_data;
162
163 if (!OCFS2_IS_VALID_GROUP_DESC(gd)) {
164 do_error("Group descriptor #%llu has bad signature %.*s\n",
165 (unsigned long long)bh->b_blocknr, 7,
166 gd->bg_signature);
167 }
168
169 if (le64_to_cpu(gd->bg_blkno) != bh->b_blocknr) {
170 do_error("Group descriptor #%llu has an invalid bg_blkno of %llu\n",
171 (unsigned long long)bh->b_blocknr,
172 (unsigned long long)le64_to_cpu(gd->bg_blkno));
173 }
174
175 if (le32_to_cpu(gd->bg_generation) != OCFS2_SB(sb)->fs_generation) {
176 do_error("Group descriptor #%llu has an invalid fs_generation of #%u\n",
177 (unsigned long long)bh->b_blocknr,
178 le32_to_cpu(gd->bg_generation));
179 }
180
181 if (le16_to_cpu(gd->bg_free_bits_count) > le16_to_cpu(gd->bg_bits)) {
182 do_error("Group descriptor #%llu has bit count %u but claims that %u are free\n",
183 (unsigned long long)bh->b_blocknr,
184 le16_to_cpu(gd->bg_bits),
185 le16_to_cpu(gd->bg_free_bits_count));
186 }
187
188 if (le16_to_cpu(gd->bg_bits) > (8 * le16_to_cpu(gd->bg_size))) {
189 do_error("Group descriptor #%llu has bit count %u but max bitmap bits of %u\n",
190 (unsigned long long)bh->b_blocknr,
191 le16_to_cpu(gd->bg_bits),
192 8 * le16_to_cpu(gd->bg_size));
193 }
194
195 return 0;
196}
197
198static int ocfs2_validate_gd_parent(struct super_block *sb,
199 struct ocfs2_dinode *di,
200 struct buffer_head *bh,
201 int resize)
202{
203 unsigned int max_bits;
204 struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *)bh->b_data;
205
206 if (di->i_blkno != gd->bg_parent_dinode) {
207 do_error("Group descriptor #%llu has bad parent pointer (%llu, expected %llu)\n",
208 (unsigned long long)bh->b_blocknr,
209 (unsigned long long)le64_to_cpu(gd->bg_parent_dinode),
210 (unsigned long long)le64_to_cpu(di->i_blkno));
211 }
212
213 max_bits = le16_to_cpu(di->id2.i_chain.cl_cpg) * le16_to_cpu(di->id2.i_chain.cl_bpc);
214 if (le16_to_cpu(gd->bg_bits) > max_bits) {
215 do_error("Group descriptor #%llu has bit count of %u\n",
216 (unsigned long long)bh->b_blocknr,
217 le16_to_cpu(gd->bg_bits));
218 }
219
220
221 if ((le16_to_cpu(gd->bg_chain) >
222 le16_to_cpu(di->id2.i_chain.cl_next_free_rec)) ||
223 ((le16_to_cpu(gd->bg_chain) ==
224 le16_to_cpu(di->id2.i_chain.cl_next_free_rec)) && !resize)) {
225 do_error("Group descriptor #%llu has bad chain %u\n",
226 (unsigned long long)bh->b_blocknr,
227 le16_to_cpu(gd->bg_chain));
228 }
229
230 return 0;
231}
232
233#undef do_error
234
235
236
237
238
239int ocfs2_check_group_descriptor(struct super_block *sb,
240 struct ocfs2_dinode *di,
241 struct buffer_head *bh)
242{
243 int rc;
244 struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *)bh->b_data;
245
246 BUG_ON(!buffer_uptodate(bh));
247
248
249
250
251
252
253 rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &gd->bg_check);
254 if (rc) {
255 mlog(ML_ERROR,
256 "Checksum failed for group descriptor %llu\n",
257 (unsigned long long)bh->b_blocknr);
258 } else
259 rc = ocfs2_validate_gd_self(sb, bh, 1);
260 if (!rc)
261 rc = ocfs2_validate_gd_parent(sb, di, bh, 1);
262
263 return rc;
264}
265
266static int ocfs2_validate_group_descriptor(struct super_block *sb,
267 struct buffer_head *bh)
268{
269 int rc;
270 struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *)bh->b_data;
271
272 trace_ocfs2_validate_group_descriptor(
273 (unsigned long long)bh->b_blocknr);
274
275 BUG_ON(!buffer_uptodate(bh));
276
277
278
279
280
281
282 rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &gd->bg_check);
283 if (rc)
284 return rc;
285
286
287
288
289
290 return ocfs2_validate_gd_self(sb, bh, 0);
291}
292
293int ocfs2_read_group_descriptor(struct inode *inode, struct ocfs2_dinode *di,
294 u64 gd_blkno, struct buffer_head **bh)
295{
296 int rc;
297 struct buffer_head *tmp = *bh;
298
299 rc = ocfs2_read_block(INODE_CACHE(inode), gd_blkno, &tmp,
300 ocfs2_validate_group_descriptor);
301 if (rc)
302 goto out;
303
304 rc = ocfs2_validate_gd_parent(inode->i_sb, di, tmp, 0);
305 if (rc) {
306 brelse(tmp);
307 goto out;
308 }
309
310
311 if (!*bh)
312 *bh = tmp;
313
314out:
315 return rc;
316}
317
318static void ocfs2_bg_discontig_add_extent(struct ocfs2_super *osb,
319 struct ocfs2_group_desc *bg,
320 struct ocfs2_chain_list *cl,
321 u64 p_blkno, unsigned int clusters)
322{
323 struct ocfs2_extent_list *el = &bg->bg_list;
324 struct ocfs2_extent_rec *rec;
325
326 BUG_ON(!ocfs2_supports_discontig_bg(osb));
327 if (!el->l_next_free_rec)
328 el->l_count = cpu_to_le16(ocfs2_extent_recs_per_gd(osb->sb));
329 rec = &el->l_recs[le16_to_cpu(el->l_next_free_rec)];
330 rec->e_blkno = cpu_to_le64(p_blkno);
331 rec->e_cpos = cpu_to_le32(le16_to_cpu(bg->bg_bits) /
332 le16_to_cpu(cl->cl_bpc));
333 rec->e_leaf_clusters = cpu_to_le16(clusters);
334 le16_add_cpu(&bg->bg_bits, clusters * le16_to_cpu(cl->cl_bpc));
335 le16_add_cpu(&bg->bg_free_bits_count,
336 clusters * le16_to_cpu(cl->cl_bpc));
337 le16_add_cpu(&el->l_next_free_rec, 1);
338}
339
340static int ocfs2_block_group_fill(handle_t *handle,
341 struct inode *alloc_inode,
342 struct buffer_head *bg_bh,
343 u64 group_blkno,
344 unsigned int group_clusters,
345 u16 my_chain,
346 struct ocfs2_chain_list *cl)
347{
348 int status = 0;
349 struct ocfs2_super *osb = OCFS2_SB(alloc_inode->i_sb);
350 struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) bg_bh->b_data;
351 struct super_block * sb = alloc_inode->i_sb;
352
353 if (((unsigned long long) bg_bh->b_blocknr) != group_blkno) {
354 status = ocfs2_error(alloc_inode->i_sb,
355 "group block (%llu) != b_blocknr (%llu)\n",
356 (unsigned long long)group_blkno,
357 (unsigned long long) bg_bh->b_blocknr);
358 goto bail;
359 }
360
361 status = ocfs2_journal_access_gd(handle,
362 INODE_CACHE(alloc_inode),
363 bg_bh,
364 OCFS2_JOURNAL_ACCESS_CREATE);
365 if (status < 0) {
366 mlog_errno(status);
367 goto bail;
368 }
369
370 memset(bg, 0, sb->s_blocksize);
371 strcpy(bg->bg_signature, OCFS2_GROUP_DESC_SIGNATURE);
372 bg->bg_generation = cpu_to_le32(osb->fs_generation);
373 bg->bg_size = cpu_to_le16(ocfs2_group_bitmap_size(sb, 1,
374 osb->s_feature_incompat));
375 bg->bg_chain = cpu_to_le16(my_chain);
376 bg->bg_next_group = cl->cl_recs[my_chain].c_blkno;
377 bg->bg_parent_dinode = cpu_to_le64(OCFS2_I(alloc_inode)->ip_blkno);
378 bg->bg_blkno = cpu_to_le64(group_blkno);
379 if (group_clusters == le16_to_cpu(cl->cl_cpg))
380 bg->bg_bits = cpu_to_le16(ocfs2_bits_per_group(cl));
381 else
382 ocfs2_bg_discontig_add_extent(osb, bg, cl, group_blkno,
383 group_clusters);
384
385
386 ocfs2_set_bit(0, (unsigned long *)bg->bg_bitmap);
387 bg->bg_free_bits_count = cpu_to_le16(le16_to_cpu(bg->bg_bits) - 1);
388
389 ocfs2_journal_dirty(handle, bg_bh);
390
391
392
393
394
395
396bail:
397 if (status)
398 mlog_errno(status);
399 return status;
400}
401
402static inline u16 ocfs2_find_smallest_chain(struct ocfs2_chain_list *cl)
403{
404 u16 curr, best;
405
406 best = curr = 0;
407 while (curr < le16_to_cpu(cl->cl_count)) {
408 if (le32_to_cpu(cl->cl_recs[best].c_total) >
409 le32_to_cpu(cl->cl_recs[curr].c_total))
410 best = curr;
411 curr++;
412 }
413 return best;
414}
415
416static struct buffer_head *
417ocfs2_block_group_alloc_contig(struct ocfs2_super *osb, handle_t *handle,
418 struct inode *alloc_inode,
419 struct ocfs2_alloc_context *ac,
420 struct ocfs2_chain_list *cl)
421{
422 int status;
423 u32 bit_off, num_bits;
424 u64 bg_blkno;
425 struct buffer_head *bg_bh;
426 unsigned int alloc_rec = ocfs2_find_smallest_chain(cl);
427
428 status = ocfs2_claim_clusters(handle, ac,
429 le16_to_cpu(cl->cl_cpg), &bit_off,
430 &num_bits);
431 if (status < 0) {
432 if (status != -ENOSPC)
433 mlog_errno(status);
434 goto bail;
435 }
436
437
438 bg_blkno = ocfs2_clusters_to_blocks(osb->sb, bit_off);
439 trace_ocfs2_block_group_alloc_contig(
440 (unsigned long long)bg_blkno, alloc_rec);
441
442 bg_bh = sb_getblk(osb->sb, bg_blkno);
443 if (!bg_bh) {
444 status = -ENOMEM;
445 mlog_errno(status);
446 goto bail;
447 }
448 ocfs2_set_new_buffer_uptodate(INODE_CACHE(alloc_inode), bg_bh);
449
450 status = ocfs2_block_group_fill(handle, alloc_inode, bg_bh,
451 bg_blkno, num_bits, alloc_rec, cl);
452 if (status < 0) {
453 brelse(bg_bh);
454 mlog_errno(status);
455 }
456
457bail:
458 return status ? ERR_PTR(status) : bg_bh;
459}
460
461static int ocfs2_block_group_claim_bits(struct ocfs2_super *osb,
462 handle_t *handle,
463 struct ocfs2_alloc_context *ac,
464 unsigned int min_bits,
465 u32 *bit_off, u32 *num_bits)
466{
467 int status = 0;
468
469 while (min_bits) {
470 status = ocfs2_claim_clusters(handle, ac, min_bits,
471 bit_off, num_bits);
472 if (status != -ENOSPC)
473 break;
474
475 min_bits >>= 1;
476 }
477
478 return status;
479}
480
481static int ocfs2_block_group_grow_discontig(handle_t *handle,
482 struct inode *alloc_inode,
483 struct buffer_head *bg_bh,
484 struct ocfs2_alloc_context *ac,
485 struct ocfs2_chain_list *cl,
486 unsigned int min_bits)
487{
488 int status;
489 struct ocfs2_super *osb = OCFS2_SB(alloc_inode->i_sb);
490 struct ocfs2_group_desc *bg =
491 (struct ocfs2_group_desc *)bg_bh->b_data;
492 unsigned int needed = le16_to_cpu(cl->cl_cpg) -
493 le16_to_cpu(bg->bg_bits) / le16_to_cpu(cl->cl_bpc);
494 u32 p_cpos, clusters;
495 u64 p_blkno;
496 struct ocfs2_extent_list *el = &bg->bg_list;
497
498 status = ocfs2_journal_access_gd(handle,
499 INODE_CACHE(alloc_inode),
500 bg_bh,
501 OCFS2_JOURNAL_ACCESS_CREATE);
502 if (status < 0) {
503 mlog_errno(status);
504 goto bail;
505 }
506
507 while ((needed > 0) && (le16_to_cpu(el->l_next_free_rec) <
508 le16_to_cpu(el->l_count))) {
509 if (min_bits > needed)
510 min_bits = needed;
511 status = ocfs2_block_group_claim_bits(osb, handle, ac,
512 min_bits, &p_cpos,
513 &clusters);
514 if (status < 0) {
515 if (status != -ENOSPC)
516 mlog_errno(status);
517 goto bail;
518 }
519 p_blkno = ocfs2_clusters_to_blocks(osb->sb, p_cpos);
520 ocfs2_bg_discontig_add_extent(osb, bg, cl, p_blkno,
521 clusters);
522
523 min_bits = clusters;
524 needed = le16_to_cpu(cl->cl_cpg) -
525 le16_to_cpu(bg->bg_bits) / le16_to_cpu(cl->cl_bpc);
526 }
527
528 if (needed > 0) {
529
530
531
532
533 status = -ENOSPC;
534 goto bail;
535 }
536
537 ocfs2_journal_dirty(handle, bg_bh);
538
539bail:
540 return status;
541}
542
543static void ocfs2_bg_alloc_cleanup(handle_t *handle,
544 struct ocfs2_alloc_context *cluster_ac,
545 struct inode *alloc_inode,
546 struct buffer_head *bg_bh)
547{
548 int i, ret;
549 struct ocfs2_group_desc *bg;
550 struct ocfs2_extent_list *el;
551 struct ocfs2_extent_rec *rec;
552
553 if (!bg_bh)
554 return;
555
556 bg = (struct ocfs2_group_desc *)bg_bh->b_data;
557 el = &bg->bg_list;
558 for (i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
559 rec = &el->l_recs[i];
560 ret = ocfs2_free_clusters(handle, cluster_ac->ac_inode,
561 cluster_ac->ac_bh,
562 le64_to_cpu(rec->e_blkno),
563 le16_to_cpu(rec->e_leaf_clusters));
564 if (ret)
565 mlog_errno(ret);
566
567 }
568
569 ocfs2_remove_from_cache(INODE_CACHE(alloc_inode), bg_bh);
570 brelse(bg_bh);
571}
572
573static struct buffer_head *
574ocfs2_block_group_alloc_discontig(handle_t *handle,
575 struct inode *alloc_inode,
576 struct ocfs2_alloc_context *ac,
577 struct ocfs2_chain_list *cl)
578{
579 int status;
580 u32 bit_off, num_bits;
581 u64 bg_blkno;
582 unsigned int min_bits = le16_to_cpu(cl->cl_cpg) >> 1;
583 struct buffer_head *bg_bh = NULL;
584 unsigned int alloc_rec = ocfs2_find_smallest_chain(cl);
585 struct ocfs2_super *osb = OCFS2_SB(alloc_inode->i_sb);
586
587 if (!ocfs2_supports_discontig_bg(osb)) {
588 status = -ENOSPC;
589 goto bail;
590 }
591
592 status = ocfs2_extend_trans(handle,
593 ocfs2_calc_bg_discontig_credits(osb->sb));
594 if (status) {
595 mlog_errno(status);
596 goto bail;
597 }
598
599
600
601
602
603
604
605 ac->ac_disable_chain_relink = 1;
606
607
608 status = ocfs2_block_group_claim_bits(osb, handle, ac, min_bits,
609 &bit_off, &num_bits);
610 if (status < 0) {
611 if (status != -ENOSPC)
612 mlog_errno(status);
613 goto bail;
614 }
615 min_bits = num_bits;
616
617
618 bg_blkno = ocfs2_clusters_to_blocks(osb->sb, bit_off);
619 trace_ocfs2_block_group_alloc_discontig(
620 (unsigned long long)bg_blkno, alloc_rec);
621
622 bg_bh = sb_getblk(osb->sb, bg_blkno);
623 if (!bg_bh) {
624 status = -ENOMEM;
625 mlog_errno(status);
626 goto bail;
627 }
628 ocfs2_set_new_buffer_uptodate(INODE_CACHE(alloc_inode), bg_bh);
629
630 status = ocfs2_block_group_fill(handle, alloc_inode, bg_bh,
631 bg_blkno, num_bits, alloc_rec, cl);
632 if (status < 0) {
633 mlog_errno(status);
634 goto bail;
635 }
636
637 status = ocfs2_block_group_grow_discontig(handle, alloc_inode,
638 bg_bh, ac, cl, min_bits);
639 if (status)
640 mlog_errno(status);
641
642bail:
643 if (status)
644 ocfs2_bg_alloc_cleanup(handle, ac, alloc_inode, bg_bh);
645 return status ? ERR_PTR(status) : bg_bh;
646}
647
648
649
650
651static int ocfs2_block_group_alloc(struct ocfs2_super *osb,
652 struct inode *alloc_inode,
653 struct buffer_head *bh,
654 u64 max_block,
655 u64 *last_alloc_group,
656 int flags)
657{
658 int status, credits;
659 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) bh->b_data;
660 struct ocfs2_chain_list *cl;
661 struct ocfs2_alloc_context *ac = NULL;
662 handle_t *handle = NULL;
663 u16 alloc_rec;
664 struct buffer_head *bg_bh = NULL;
665 struct ocfs2_group_desc *bg;
666
667 BUG_ON(ocfs2_is_cluster_bitmap(alloc_inode));
668
669 cl = &fe->id2.i_chain;
670 status = ocfs2_reserve_clusters_with_limit(osb,
671 le16_to_cpu(cl->cl_cpg),
672 max_block, flags, &ac);
673 if (status < 0) {
674 if (status != -ENOSPC)
675 mlog_errno(status);
676 goto bail;
677 }
678
679 credits = ocfs2_calc_group_alloc_credits(osb->sb,
680 le16_to_cpu(cl->cl_cpg));
681 handle = ocfs2_start_trans(osb, credits);
682 if (IS_ERR(handle)) {
683 status = PTR_ERR(handle);
684 handle = NULL;
685 mlog_errno(status);
686 goto bail;
687 }
688
689 if (last_alloc_group && *last_alloc_group != 0) {
690 trace_ocfs2_block_group_alloc(
691 (unsigned long long)*last_alloc_group);
692 ac->ac_last_group = *last_alloc_group;
693 }
694
695 bg_bh = ocfs2_block_group_alloc_contig(osb, handle, alloc_inode,
696 ac, cl);
697 if (PTR_ERR(bg_bh) == -ENOSPC)
698 bg_bh = ocfs2_block_group_alloc_discontig(handle,
699 alloc_inode,
700 ac, cl);
701 if (IS_ERR(bg_bh)) {
702 status = PTR_ERR(bg_bh);
703 bg_bh = NULL;
704 if (status != -ENOSPC)
705 mlog_errno(status);
706 goto bail;
707 }
708 bg = (struct ocfs2_group_desc *) bg_bh->b_data;
709
710 status = ocfs2_journal_access_di(handle, INODE_CACHE(alloc_inode),
711 bh, OCFS2_JOURNAL_ACCESS_WRITE);
712 if (status < 0) {
713 mlog_errno(status);
714 goto bail;
715 }
716
717 alloc_rec = le16_to_cpu(bg->bg_chain);
718 le32_add_cpu(&cl->cl_recs[alloc_rec].c_free,
719 le16_to_cpu(bg->bg_free_bits_count));
720 le32_add_cpu(&cl->cl_recs[alloc_rec].c_total,
721 le16_to_cpu(bg->bg_bits));
722 cl->cl_recs[alloc_rec].c_blkno = bg->bg_blkno;
723 if (le16_to_cpu(cl->cl_next_free_rec) < le16_to_cpu(cl->cl_count))
724 le16_add_cpu(&cl->cl_next_free_rec, 1);
725
726 le32_add_cpu(&fe->id1.bitmap1.i_used, le16_to_cpu(bg->bg_bits) -
727 le16_to_cpu(bg->bg_free_bits_count));
728 le32_add_cpu(&fe->id1.bitmap1.i_total, le16_to_cpu(bg->bg_bits));
729 le32_add_cpu(&fe->i_clusters, le16_to_cpu(cl->cl_cpg));
730
731 ocfs2_journal_dirty(handle, bh);
732
733 spin_lock(&OCFS2_I(alloc_inode)->ip_lock);
734 OCFS2_I(alloc_inode)->ip_clusters = le32_to_cpu(fe->i_clusters);
735 fe->i_size = cpu_to_le64(ocfs2_clusters_to_bytes(alloc_inode->i_sb,
736 le32_to_cpu(fe->i_clusters)));
737 spin_unlock(&OCFS2_I(alloc_inode)->ip_lock);
738 i_size_write(alloc_inode, le64_to_cpu(fe->i_size));
739 alloc_inode->i_blocks = ocfs2_inode_sector_count(alloc_inode);
740 ocfs2_update_inode_fsync_trans(handle, alloc_inode, 0);
741
742 status = 0;
743
744
745 if (last_alloc_group)
746 *last_alloc_group = ac->ac_last_group;
747
748bail:
749 if (handle)
750 ocfs2_commit_trans(osb, handle);
751
752 if (ac)
753 ocfs2_free_alloc_context(ac);
754
755 brelse(bg_bh);
756
757 if (status)
758 mlog_errno(status);
759 return status;
760}
761
762static int ocfs2_reserve_suballoc_bits(struct ocfs2_super *osb,
763 struct ocfs2_alloc_context *ac,
764 int type,
765 u32 slot,
766 u64 *last_alloc_group,
767 int flags)
768{
769 int status;
770 u32 bits_wanted = ac->ac_bits_wanted;
771 struct inode *alloc_inode;
772 struct buffer_head *bh = NULL;
773 struct ocfs2_dinode *fe;
774 u32 free_bits;
775
776 alloc_inode = ocfs2_get_system_file_inode(osb, type, slot);
777 if (!alloc_inode) {
778 mlog_errno(-EINVAL);
779 return -EINVAL;
780 }
781
782 inode_lock(alloc_inode);
783
784 status = ocfs2_inode_lock(alloc_inode, &bh, 1);
785 if (status < 0) {
786 inode_unlock(alloc_inode);
787 iput(alloc_inode);
788
789 mlog_errno(status);
790 return status;
791 }
792
793 ac->ac_inode = alloc_inode;
794 ac->ac_alloc_slot = slot;
795
796 fe = (struct ocfs2_dinode *) bh->b_data;
797
798
799
800 BUG_ON(!OCFS2_IS_VALID_DINODE(fe));
801
802 if (!(fe->i_flags & cpu_to_le32(OCFS2_CHAIN_FL))) {
803 status = ocfs2_error(alloc_inode->i_sb,
804 "Invalid chain allocator %llu\n",
805 (unsigned long long)le64_to_cpu(fe->i_blkno));
806 goto bail;
807 }
808
809 free_bits = le32_to_cpu(fe->id1.bitmap1.i_total) -
810 le32_to_cpu(fe->id1.bitmap1.i_used);
811
812 if (bits_wanted > free_bits) {
813
814 if (ocfs2_is_cluster_bitmap(alloc_inode)) {
815 trace_ocfs2_reserve_suballoc_bits_nospc(bits_wanted,
816 free_bits);
817 status = -ENOSPC;
818 goto bail;
819 }
820
821 if (!(flags & ALLOC_NEW_GROUP)) {
822 trace_ocfs2_reserve_suballoc_bits_no_new_group(
823 slot, bits_wanted, free_bits);
824 status = -ENOSPC;
825 goto bail;
826 }
827
828 status = ocfs2_block_group_alloc(osb, alloc_inode, bh,
829 ac->ac_max_block,
830 last_alloc_group, flags);
831 if (status < 0) {
832 if (status != -ENOSPC)
833 mlog_errno(status);
834 goto bail;
835 }
836 atomic_inc(&osb->alloc_stats.bg_extends);
837
838
839 BUG_ON(bits_wanted >
840 (le32_to_cpu(fe->id1.bitmap1.i_total)
841 - le32_to_cpu(fe->id1.bitmap1.i_used)));
842 }
843
844 get_bh(bh);
845 ac->ac_bh = bh;
846bail:
847 brelse(bh);
848
849 if (status)
850 mlog_errno(status);
851 return status;
852}
853
854static void ocfs2_init_inode_steal_slot(struct ocfs2_super *osb)
855{
856 spin_lock(&osb->osb_lock);
857 osb->s_inode_steal_slot = OCFS2_INVALID_SLOT;
858 spin_unlock(&osb->osb_lock);
859 atomic_set(&osb->s_num_inodes_stolen, 0);
860}
861
862static void ocfs2_init_meta_steal_slot(struct ocfs2_super *osb)
863{
864 spin_lock(&osb->osb_lock);
865 osb->s_meta_steal_slot = OCFS2_INVALID_SLOT;
866 spin_unlock(&osb->osb_lock);
867 atomic_set(&osb->s_num_meta_stolen, 0);
868}
869
870void ocfs2_init_steal_slots(struct ocfs2_super *osb)
871{
872 ocfs2_init_inode_steal_slot(osb);
873 ocfs2_init_meta_steal_slot(osb);
874}
875
876static void __ocfs2_set_steal_slot(struct ocfs2_super *osb, int slot, int type)
877{
878 spin_lock(&osb->osb_lock);
879 if (type == INODE_ALLOC_SYSTEM_INODE)
880 osb->s_inode_steal_slot = (u16)slot;
881 else if (type == EXTENT_ALLOC_SYSTEM_INODE)
882 osb->s_meta_steal_slot = (u16)slot;
883 spin_unlock(&osb->osb_lock);
884}
885
886static int __ocfs2_get_steal_slot(struct ocfs2_super *osb, int type)
887{
888 int slot = OCFS2_INVALID_SLOT;
889
890 spin_lock(&osb->osb_lock);
891 if (type == INODE_ALLOC_SYSTEM_INODE)
892 slot = osb->s_inode_steal_slot;
893 else if (type == EXTENT_ALLOC_SYSTEM_INODE)
894 slot = osb->s_meta_steal_slot;
895 spin_unlock(&osb->osb_lock);
896
897 return slot;
898}
899
900static int ocfs2_get_inode_steal_slot(struct ocfs2_super *osb)
901{
902 return __ocfs2_get_steal_slot(osb, INODE_ALLOC_SYSTEM_INODE);
903}
904
905static int ocfs2_get_meta_steal_slot(struct ocfs2_super *osb)
906{
907 return __ocfs2_get_steal_slot(osb, EXTENT_ALLOC_SYSTEM_INODE);
908}
909
910static int ocfs2_steal_resource(struct ocfs2_super *osb,
911 struct ocfs2_alloc_context *ac,
912 int type)
913{
914 int i, status = -ENOSPC;
915 int slot = __ocfs2_get_steal_slot(osb, type);
916
917
918 if (slot == OCFS2_INVALID_SLOT)
919 slot = osb->slot_num + 1;
920
921 for (i = 0; i < osb->max_slots; i++, slot++) {
922 if (slot == osb->max_slots)
923 slot = 0;
924
925 if (slot == osb->slot_num)
926 continue;
927
928 status = ocfs2_reserve_suballoc_bits(osb, ac,
929 type,
930 (u32)slot, NULL,
931 NOT_ALLOC_NEW_GROUP);
932 if (status >= 0) {
933 __ocfs2_set_steal_slot(osb, slot, type);
934 break;
935 }
936
937 ocfs2_free_ac_resource(ac);
938 }
939
940 return status;
941}
942
943static int ocfs2_steal_inode(struct ocfs2_super *osb,
944 struct ocfs2_alloc_context *ac)
945{
946 return ocfs2_steal_resource(osb, ac, INODE_ALLOC_SYSTEM_INODE);
947}
948
949static int ocfs2_steal_meta(struct ocfs2_super *osb,
950 struct ocfs2_alloc_context *ac)
951{
952 return ocfs2_steal_resource(osb, ac, EXTENT_ALLOC_SYSTEM_INODE);
953}
954
955int ocfs2_reserve_new_metadata_blocks(struct ocfs2_super *osb,
956 int blocks,
957 struct ocfs2_alloc_context **ac)
958{
959 int status;
960 int slot = ocfs2_get_meta_steal_slot(osb);
961
962 *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
963 if (!(*ac)) {
964 status = -ENOMEM;
965 mlog_errno(status);
966 goto bail;
967 }
968
969 (*ac)->ac_bits_wanted = blocks;
970 (*ac)->ac_which = OCFS2_AC_USE_META;
971 (*ac)->ac_group_search = ocfs2_block_group_search;
972
973 if (slot != OCFS2_INVALID_SLOT &&
974 atomic_read(&osb->s_num_meta_stolen) < OCFS2_MAX_TO_STEAL)
975 goto extent_steal;
976
977 atomic_set(&osb->s_num_meta_stolen, 0);
978 status = ocfs2_reserve_suballoc_bits(osb, (*ac),
979 EXTENT_ALLOC_SYSTEM_INODE,
980 (u32)osb->slot_num, NULL,
981 ALLOC_GROUPS_FROM_GLOBAL|ALLOC_NEW_GROUP);
982
983
984 if (status >= 0) {
985 status = 0;
986 if (slot != OCFS2_INVALID_SLOT)
987 ocfs2_init_meta_steal_slot(osb);
988 goto bail;
989 } else if (status < 0 && status != -ENOSPC) {
990 mlog_errno(status);
991 goto bail;
992 }
993
994 ocfs2_free_ac_resource(*ac);
995
996extent_steal:
997 status = ocfs2_steal_meta(osb, *ac);
998 atomic_inc(&osb->s_num_meta_stolen);
999 if (status < 0) {
1000 if (status != -ENOSPC)
1001 mlog_errno(status);
1002 goto bail;
1003 }
1004
1005 status = 0;
1006bail:
1007 if ((status < 0) && *ac) {
1008 ocfs2_free_alloc_context(*ac);
1009 *ac = NULL;
1010 }
1011
1012 if (status)
1013 mlog_errno(status);
1014 return status;
1015}
1016
1017int ocfs2_reserve_new_metadata(struct ocfs2_super *osb,
1018 struct ocfs2_extent_list *root_el,
1019 struct ocfs2_alloc_context **ac)
1020{
1021 return ocfs2_reserve_new_metadata_blocks(osb,
1022 ocfs2_extend_meta_needed(root_el),
1023 ac);
1024}
1025
1026int ocfs2_reserve_new_inode(struct ocfs2_super *osb,
1027 struct ocfs2_alloc_context **ac)
1028{
1029 int status;
1030 int slot = ocfs2_get_inode_steal_slot(osb);
1031 u64 alloc_group;
1032
1033 *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
1034 if (!(*ac)) {
1035 status = -ENOMEM;
1036 mlog_errno(status);
1037 goto bail;
1038 }
1039
1040 (*ac)->ac_bits_wanted = 1;
1041 (*ac)->ac_which = OCFS2_AC_USE_INODE;
1042
1043 (*ac)->ac_group_search = ocfs2_block_group_search;
1044
1045
1046
1047
1048
1049
1050 if (!(osb->s_mount_opt & OCFS2_MOUNT_INODE64))
1051 (*ac)->ac_max_block = (u32)~0U;
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062 if (slot != OCFS2_INVALID_SLOT &&
1063 atomic_read(&osb->s_num_inodes_stolen) < OCFS2_MAX_TO_STEAL)
1064 goto inode_steal;
1065
1066 atomic_set(&osb->s_num_inodes_stolen, 0);
1067 alloc_group = osb->osb_inode_alloc_group;
1068 status = ocfs2_reserve_suballoc_bits(osb, *ac,
1069 INODE_ALLOC_SYSTEM_INODE,
1070 (u32)osb->slot_num,
1071 &alloc_group,
1072 ALLOC_NEW_GROUP |
1073 ALLOC_GROUPS_FROM_GLOBAL);
1074 if (status >= 0) {
1075 status = 0;
1076
1077 spin_lock(&osb->osb_lock);
1078 osb->osb_inode_alloc_group = alloc_group;
1079 spin_unlock(&osb->osb_lock);
1080 trace_ocfs2_reserve_new_inode_new_group(
1081 (unsigned long long)alloc_group);
1082
1083
1084
1085
1086
1087 if (slot != OCFS2_INVALID_SLOT)
1088 ocfs2_init_inode_steal_slot(osb);
1089 goto bail;
1090 } else if (status < 0 && status != -ENOSPC) {
1091 mlog_errno(status);
1092 goto bail;
1093 }
1094
1095 ocfs2_free_ac_resource(*ac);
1096
1097inode_steal:
1098 status = ocfs2_steal_inode(osb, *ac);
1099 atomic_inc(&osb->s_num_inodes_stolen);
1100 if (status < 0) {
1101 if (status != -ENOSPC)
1102 mlog_errno(status);
1103 goto bail;
1104 }
1105
1106 status = 0;
1107bail:
1108 if ((status < 0) && *ac) {
1109 ocfs2_free_alloc_context(*ac);
1110 *ac = NULL;
1111 }
1112
1113 if (status)
1114 mlog_errno(status);
1115 return status;
1116}
1117
1118
1119
1120int ocfs2_reserve_cluster_bitmap_bits(struct ocfs2_super *osb,
1121 struct ocfs2_alloc_context *ac)
1122{
1123 int status;
1124
1125 ac->ac_which = OCFS2_AC_USE_MAIN;
1126 ac->ac_group_search = ocfs2_cluster_group_search;
1127
1128 status = ocfs2_reserve_suballoc_bits(osb, ac,
1129 GLOBAL_BITMAP_SYSTEM_INODE,
1130 OCFS2_INVALID_SLOT, NULL,
1131 ALLOC_NEW_GROUP);
1132 if (status < 0 && status != -ENOSPC)
1133 mlog_errno(status);
1134
1135 return status;
1136}
1137
1138
1139
1140
1141static int ocfs2_reserve_clusters_with_limit(struct ocfs2_super *osb,
1142 u32 bits_wanted, u64 max_block,
1143 int flags,
1144 struct ocfs2_alloc_context **ac)
1145{
1146 int status, ret = 0;
1147 int retried = 0;
1148
1149 *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
1150 if (!(*ac)) {
1151 status = -ENOMEM;
1152 mlog_errno(status);
1153 goto bail;
1154 }
1155
1156 (*ac)->ac_bits_wanted = bits_wanted;
1157 (*ac)->ac_max_block = max_block;
1158
1159 status = -ENOSPC;
1160 if (!(flags & ALLOC_GROUPS_FROM_GLOBAL) &&
1161 ocfs2_alloc_should_use_local(osb, bits_wanted)) {
1162 status = ocfs2_reserve_local_alloc_bits(osb,
1163 bits_wanted,
1164 *ac);
1165 if ((status < 0) && (status != -ENOSPC)) {
1166 mlog_errno(status);
1167 goto bail;
1168 }
1169 }
1170
1171 if (status == -ENOSPC) {
1172retry:
1173 status = ocfs2_reserve_cluster_bitmap_bits(osb, *ac);
1174
1175 if (status == -ENOSPC && !retried) {
1176 retried = 1;
1177 ocfs2_inode_unlock((*ac)->ac_inode, 1);
1178 inode_unlock((*ac)->ac_inode);
1179
1180 ret = ocfs2_try_to_free_truncate_log(osb, bits_wanted);
1181 if (ret == 1) {
1182 iput((*ac)->ac_inode);
1183 (*ac)->ac_inode = NULL;
1184 goto retry;
1185 }
1186
1187 if (ret < 0)
1188 mlog_errno(ret);
1189
1190 inode_lock((*ac)->ac_inode);
1191 ret = ocfs2_inode_lock((*ac)->ac_inode, NULL, 1);
1192 if (ret < 0) {
1193 mlog_errno(ret);
1194 inode_unlock((*ac)->ac_inode);
1195 iput((*ac)->ac_inode);
1196 (*ac)->ac_inode = NULL;
1197 goto bail;
1198 }
1199 }
1200 if (status < 0) {
1201 if (status != -ENOSPC)
1202 mlog_errno(status);
1203 goto bail;
1204 }
1205 }
1206
1207 status = 0;
1208bail:
1209 if ((status < 0) && *ac) {
1210 ocfs2_free_alloc_context(*ac);
1211 *ac = NULL;
1212 }
1213
1214 if (status)
1215 mlog_errno(status);
1216 return status;
1217}
1218
1219int ocfs2_reserve_clusters(struct ocfs2_super *osb,
1220 u32 bits_wanted,
1221 struct ocfs2_alloc_context **ac)
1222{
1223 return ocfs2_reserve_clusters_with_limit(osb, bits_wanted, 0,
1224 ALLOC_NEW_GROUP, ac);
1225}
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249static int ocfs2_test_bg_bit_allocatable(struct buffer_head *bg_bh,
1250 int nr)
1251{
1252 struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) bg_bh->b_data;
1253 struct journal_head *jh;
1254 int ret = 1;
1255
1256 if (ocfs2_test_bit(nr, (unsigned long *)bg->bg_bitmap))
1257 return 0;
1258
1259 if (!buffer_jbd(bg_bh))
1260 return 1;
1261
1262 jbd_lock_bh_journal_head(bg_bh);
1263 if (buffer_jbd(bg_bh)) {
1264 jh = bh2jh(bg_bh);
1265 spin_lock(&jh->b_state_lock);
1266 bg = (struct ocfs2_group_desc *) jh->b_committed_data;
1267 if (bg)
1268 ret = !ocfs2_test_bit(nr, (unsigned long *)bg->bg_bitmap);
1269 else
1270 ret = 1;
1271 spin_unlock(&jh->b_state_lock);
1272 }
1273 jbd_unlock_bh_journal_head(bg_bh);
1274
1275 return ret;
1276}
1277
1278static int ocfs2_block_group_find_clear_bits(struct ocfs2_super *osb,
1279 struct buffer_head *bg_bh,
1280 unsigned int bits_wanted,
1281 unsigned int total_bits,
1282 struct ocfs2_suballoc_result *res)
1283{
1284 void *bitmap;
1285 u16 best_offset, best_size;
1286 int offset, start, found, status = 0;
1287 struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) bg_bh->b_data;
1288
1289
1290
1291 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg));
1292
1293 found = start = best_offset = best_size = 0;
1294 bitmap = bg->bg_bitmap;
1295
1296 while((offset = ocfs2_find_next_zero_bit(bitmap, total_bits, start)) != -1) {
1297 if (offset == total_bits)
1298 break;
1299
1300 if (!ocfs2_test_bg_bit_allocatable(bg_bh, offset)) {
1301
1302
1303 found = 0;
1304 start = offset + 1;
1305 } else if (offset == start) {
1306
1307 found++;
1308
1309 start++;
1310 } else {
1311
1312 found = 1;
1313 start = offset + 1;
1314 }
1315 if (found > best_size) {
1316 best_size = found;
1317 best_offset = start - found;
1318 }
1319
1320 if (found == bits_wanted) {
1321
1322 break;
1323 }
1324 }
1325
1326 if (best_size) {
1327 res->sr_bit_offset = best_offset;
1328 res->sr_bits = best_size;
1329 } else {
1330 status = -ENOSPC;
1331
1332
1333 }
1334
1335 return status;
1336}
1337
1338int ocfs2_block_group_set_bits(handle_t *handle,
1339 struct inode *alloc_inode,
1340 struct ocfs2_group_desc *bg,
1341 struct buffer_head *group_bh,
1342 unsigned int bit_off,
1343 unsigned int num_bits)
1344{
1345 int status;
1346 void *bitmap = bg->bg_bitmap;
1347 int journal_type = OCFS2_JOURNAL_ACCESS_WRITE;
1348
1349
1350
1351 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg));
1352 BUG_ON(le16_to_cpu(bg->bg_free_bits_count) < num_bits);
1353
1354 trace_ocfs2_block_group_set_bits(bit_off, num_bits);
1355
1356 if (ocfs2_is_cluster_bitmap(alloc_inode))
1357 journal_type = OCFS2_JOURNAL_ACCESS_UNDO;
1358
1359 status = ocfs2_journal_access_gd(handle,
1360 INODE_CACHE(alloc_inode),
1361 group_bh,
1362 journal_type);
1363 if (status < 0) {
1364 mlog_errno(status);
1365 goto bail;
1366 }
1367
1368 le16_add_cpu(&bg->bg_free_bits_count, -num_bits);
1369 if (le16_to_cpu(bg->bg_free_bits_count) > le16_to_cpu(bg->bg_bits)) {
1370 return ocfs2_error(alloc_inode->i_sb, "Group descriptor # %llu has bit count %u but claims %u are freed. num_bits %d\n",
1371 (unsigned long long)le64_to_cpu(bg->bg_blkno),
1372 le16_to_cpu(bg->bg_bits),
1373 le16_to_cpu(bg->bg_free_bits_count),
1374 num_bits);
1375 }
1376 while(num_bits--)
1377 ocfs2_set_bit(bit_off++, bitmap);
1378
1379 ocfs2_journal_dirty(handle, group_bh);
1380
1381bail:
1382 return status;
1383}
1384
1385
1386static inline u16 ocfs2_find_victim_chain(struct ocfs2_chain_list *cl)
1387{
1388 u16 curr, best;
1389
1390 BUG_ON(!cl->cl_next_free_rec);
1391
1392 best = curr = 0;
1393 while (curr < le16_to_cpu(cl->cl_next_free_rec)) {
1394 if (le32_to_cpu(cl->cl_recs[curr].c_free) >
1395 le32_to_cpu(cl->cl_recs[best].c_free))
1396 best = curr;
1397 curr++;
1398 }
1399
1400 BUG_ON(best >= le16_to_cpu(cl->cl_next_free_rec));
1401 return best;
1402}
1403
1404static int ocfs2_relink_block_group(handle_t *handle,
1405 struct inode *alloc_inode,
1406 struct buffer_head *fe_bh,
1407 struct buffer_head *bg_bh,
1408 struct buffer_head *prev_bg_bh,
1409 u16 chain)
1410{
1411 int status;
1412
1413
1414 u64 bg_ptr, prev_bg_ptr;
1415 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) fe_bh->b_data;
1416 struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) bg_bh->b_data;
1417 struct ocfs2_group_desc *prev_bg = (struct ocfs2_group_desc *) prev_bg_bh->b_data;
1418
1419
1420
1421 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg));
1422 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(prev_bg));
1423
1424 trace_ocfs2_relink_block_group(
1425 (unsigned long long)le64_to_cpu(fe->i_blkno), chain,
1426 (unsigned long long)le64_to_cpu(bg->bg_blkno),
1427 (unsigned long long)le64_to_cpu(prev_bg->bg_blkno));
1428
1429 bg_ptr = le64_to_cpu(bg->bg_next_group);
1430 prev_bg_ptr = le64_to_cpu(prev_bg->bg_next_group);
1431
1432 status = ocfs2_journal_access_gd(handle, INODE_CACHE(alloc_inode),
1433 prev_bg_bh,
1434 OCFS2_JOURNAL_ACCESS_WRITE);
1435 if (status < 0)
1436 goto out;
1437
1438 prev_bg->bg_next_group = bg->bg_next_group;
1439 ocfs2_journal_dirty(handle, prev_bg_bh);
1440
1441 status = ocfs2_journal_access_gd(handle, INODE_CACHE(alloc_inode),
1442 bg_bh, OCFS2_JOURNAL_ACCESS_WRITE);
1443 if (status < 0)
1444 goto out_rollback_prev_bg;
1445
1446 bg->bg_next_group = fe->id2.i_chain.cl_recs[chain].c_blkno;
1447 ocfs2_journal_dirty(handle, bg_bh);
1448
1449 status = ocfs2_journal_access_di(handle, INODE_CACHE(alloc_inode),
1450 fe_bh, OCFS2_JOURNAL_ACCESS_WRITE);
1451 if (status < 0)
1452 goto out_rollback_bg;
1453
1454 fe->id2.i_chain.cl_recs[chain].c_blkno = bg->bg_blkno;
1455 ocfs2_journal_dirty(handle, fe_bh);
1456
1457out:
1458 if (status < 0)
1459 mlog_errno(status);
1460 return status;
1461
1462out_rollback_bg:
1463 bg->bg_next_group = cpu_to_le64(bg_ptr);
1464out_rollback_prev_bg:
1465 prev_bg->bg_next_group = cpu_to_le64(prev_bg_ptr);
1466 goto out;
1467}
1468
1469static inline int ocfs2_block_group_reasonably_empty(struct ocfs2_group_desc *bg,
1470 u32 wanted)
1471{
1472 return le16_to_cpu(bg->bg_free_bits_count) > wanted;
1473}
1474
1475
1476
1477static int ocfs2_cluster_group_search(struct inode *inode,
1478 struct buffer_head *group_bh,
1479 u32 bits_wanted, u32 min_bits,
1480 u64 max_block,
1481 struct ocfs2_suballoc_result *res)
1482{
1483 int search = -ENOSPC;
1484 int ret;
1485 u64 blkoff;
1486 struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *) group_bh->b_data;
1487 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1488 unsigned int max_bits, gd_cluster_off;
1489
1490 BUG_ON(!ocfs2_is_cluster_bitmap(inode));
1491
1492 if (gd->bg_free_bits_count) {
1493 max_bits = le16_to_cpu(gd->bg_bits);
1494
1495
1496
1497
1498
1499
1500
1501 gd_cluster_off = ocfs2_blocks_to_clusters(inode->i_sb,
1502 le64_to_cpu(gd->bg_blkno));
1503 if ((gd_cluster_off + max_bits) >
1504 OCFS2_I(inode)->ip_clusters) {
1505 max_bits = OCFS2_I(inode)->ip_clusters - gd_cluster_off;
1506 trace_ocfs2_cluster_group_search_wrong_max_bits(
1507 (unsigned long long)le64_to_cpu(gd->bg_blkno),
1508 le16_to_cpu(gd->bg_bits),
1509 OCFS2_I(inode)->ip_clusters, max_bits);
1510 }
1511
1512 ret = ocfs2_block_group_find_clear_bits(osb,
1513 group_bh, bits_wanted,
1514 max_bits, res);
1515 if (ret)
1516 return ret;
1517
1518 if (max_block) {
1519 blkoff = ocfs2_clusters_to_blocks(inode->i_sb,
1520 gd_cluster_off +
1521 res->sr_bit_offset +
1522 res->sr_bits);
1523 trace_ocfs2_cluster_group_search_max_block(
1524 (unsigned long long)blkoff,
1525 (unsigned long long)max_block);
1526 if (blkoff > max_block)
1527 return -ENOSPC;
1528 }
1529
1530
1531
1532
1533
1534 if (min_bits <= res->sr_bits)
1535 search = 0;
1536 else if (res->sr_bits) {
1537
1538
1539
1540
1541 ocfs2_local_alloc_seen_free_bits(osb, res->sr_bits);
1542 }
1543 }
1544
1545 return search;
1546}
1547
1548static int ocfs2_block_group_search(struct inode *inode,
1549 struct buffer_head *group_bh,
1550 u32 bits_wanted, u32 min_bits,
1551 u64 max_block,
1552 struct ocfs2_suballoc_result *res)
1553{
1554 int ret = -ENOSPC;
1555 u64 blkoff;
1556 struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) group_bh->b_data;
1557
1558 BUG_ON(min_bits != 1);
1559 BUG_ON(ocfs2_is_cluster_bitmap(inode));
1560
1561 if (bg->bg_free_bits_count) {
1562 ret = ocfs2_block_group_find_clear_bits(OCFS2_SB(inode->i_sb),
1563 group_bh, bits_wanted,
1564 le16_to_cpu(bg->bg_bits),
1565 res);
1566 if (!ret && max_block) {
1567 blkoff = le64_to_cpu(bg->bg_blkno) +
1568 res->sr_bit_offset + res->sr_bits;
1569 trace_ocfs2_block_group_search_max_block(
1570 (unsigned long long)blkoff,
1571 (unsigned long long)max_block);
1572 if (blkoff > max_block)
1573 ret = -ENOSPC;
1574 }
1575 }
1576
1577 return ret;
1578}
1579
1580int ocfs2_alloc_dinode_update_counts(struct inode *inode,
1581 handle_t *handle,
1582 struct buffer_head *di_bh,
1583 u32 num_bits,
1584 u16 chain)
1585{
1586 int ret;
1587 u32 tmp_used;
1588 struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data;
1589 struct ocfs2_chain_list *cl = (struct ocfs2_chain_list *) &di->id2.i_chain;
1590
1591 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
1592 OCFS2_JOURNAL_ACCESS_WRITE);
1593 if (ret < 0) {
1594 mlog_errno(ret);
1595 goto out;
1596 }
1597
1598 tmp_used = le32_to_cpu(di->id1.bitmap1.i_used);
1599 di->id1.bitmap1.i_used = cpu_to_le32(num_bits + tmp_used);
1600 le32_add_cpu(&cl->cl_recs[chain].c_free, -num_bits);
1601 ocfs2_journal_dirty(handle, di_bh);
1602
1603out:
1604 return ret;
1605}
1606
1607void ocfs2_rollback_alloc_dinode_counts(struct inode *inode,
1608 struct buffer_head *di_bh,
1609 u32 num_bits,
1610 u16 chain)
1611{
1612 u32 tmp_used;
1613 struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data;
1614 struct ocfs2_chain_list *cl;
1615
1616 cl = (struct ocfs2_chain_list *)&di->id2.i_chain;
1617 tmp_used = le32_to_cpu(di->id1.bitmap1.i_used);
1618 di->id1.bitmap1.i_used = cpu_to_le32(tmp_used - num_bits);
1619 le32_add_cpu(&cl->cl_recs[chain].c_free, num_bits);
1620}
1621
1622static int ocfs2_bg_discontig_fix_by_rec(struct ocfs2_suballoc_result *res,
1623 struct ocfs2_extent_rec *rec,
1624 struct ocfs2_chain_list *cl)
1625{
1626 unsigned int bpc = le16_to_cpu(cl->cl_bpc);
1627 unsigned int bitoff = le32_to_cpu(rec->e_cpos) * bpc;
1628 unsigned int bitcount = le16_to_cpu(rec->e_leaf_clusters) * bpc;
1629
1630 if (res->sr_bit_offset < bitoff)
1631 return 0;
1632 if (res->sr_bit_offset >= (bitoff + bitcount))
1633 return 0;
1634 res->sr_blkno = le64_to_cpu(rec->e_blkno) +
1635 (res->sr_bit_offset - bitoff);
1636 if ((res->sr_bit_offset + res->sr_bits) > (bitoff + bitcount))
1637 res->sr_bits = (bitoff + bitcount) - res->sr_bit_offset;
1638 return 1;
1639}
1640
1641static void ocfs2_bg_discontig_fix_result(struct ocfs2_alloc_context *ac,
1642 struct ocfs2_group_desc *bg,
1643 struct ocfs2_suballoc_result *res)
1644{
1645 int i;
1646 u64 bg_blkno = res->sr_bg_blkno;
1647 struct ocfs2_extent_rec *rec;
1648 struct ocfs2_dinode *di = (struct ocfs2_dinode *)ac->ac_bh->b_data;
1649 struct ocfs2_chain_list *cl = &di->id2.i_chain;
1650
1651 if (ocfs2_is_cluster_bitmap(ac->ac_inode)) {
1652 res->sr_blkno = 0;
1653 return;
1654 }
1655
1656 res->sr_blkno = res->sr_bg_blkno + res->sr_bit_offset;
1657 res->sr_bg_blkno = 0;
1658 if (!ocfs2_supports_discontig_bg(OCFS2_SB(ac->ac_inode->i_sb)) ||
1659 !bg->bg_list.l_next_free_rec)
1660 return;
1661
1662 for (i = 0; i < le16_to_cpu(bg->bg_list.l_next_free_rec); i++) {
1663 rec = &bg->bg_list.l_recs[i];
1664 if (ocfs2_bg_discontig_fix_by_rec(res, rec, cl)) {
1665 res->sr_bg_blkno = bg_blkno;
1666 break;
1667 }
1668 }
1669}
1670
1671static int ocfs2_search_one_group(struct ocfs2_alloc_context *ac,
1672 handle_t *handle,
1673 u32 bits_wanted,
1674 u32 min_bits,
1675 struct ocfs2_suballoc_result *res,
1676 u16 *bits_left)
1677{
1678 int ret;
1679 struct buffer_head *group_bh = NULL;
1680 struct ocfs2_group_desc *gd;
1681 struct ocfs2_dinode *di = (struct ocfs2_dinode *)ac->ac_bh->b_data;
1682 struct inode *alloc_inode = ac->ac_inode;
1683
1684 ret = ocfs2_read_group_descriptor(alloc_inode, di,
1685 res->sr_bg_blkno, &group_bh);
1686 if (ret < 0) {
1687 mlog_errno(ret);
1688 return ret;
1689 }
1690
1691 gd = (struct ocfs2_group_desc *) group_bh->b_data;
1692 ret = ac->ac_group_search(alloc_inode, group_bh, bits_wanted, min_bits,
1693 ac->ac_max_block, res);
1694 if (ret < 0) {
1695 if (ret != -ENOSPC)
1696 mlog_errno(ret);
1697 goto out;
1698 }
1699
1700 if (!ret)
1701 ocfs2_bg_discontig_fix_result(ac, gd, res);
1702
1703
1704
1705
1706
1707 res->sr_bg_stable_blkno = group_bh->b_blocknr;
1708
1709 if (ac->ac_find_loc_only)
1710 goto out_loc_only;
1711
1712 ret = ocfs2_alloc_dinode_update_counts(alloc_inode, handle, ac->ac_bh,
1713 res->sr_bits,
1714 le16_to_cpu(gd->bg_chain));
1715 if (ret < 0) {
1716 mlog_errno(ret);
1717 goto out;
1718 }
1719
1720 ret = ocfs2_block_group_set_bits(handle, alloc_inode, gd, group_bh,
1721 res->sr_bit_offset, res->sr_bits);
1722 if (ret < 0) {
1723 ocfs2_rollback_alloc_dinode_counts(alloc_inode, ac->ac_bh,
1724 res->sr_bits,
1725 le16_to_cpu(gd->bg_chain));
1726 mlog_errno(ret);
1727 }
1728
1729out_loc_only:
1730 *bits_left = le16_to_cpu(gd->bg_free_bits_count);
1731
1732out:
1733 brelse(group_bh);
1734
1735 return ret;
1736}
1737
1738static int ocfs2_search_chain(struct ocfs2_alloc_context *ac,
1739 handle_t *handle,
1740 u32 bits_wanted,
1741 u32 min_bits,
1742 struct ocfs2_suballoc_result *res,
1743 u16 *bits_left)
1744{
1745 int status;
1746 u16 chain;
1747 u64 next_group;
1748 struct inode *alloc_inode = ac->ac_inode;
1749 struct buffer_head *group_bh = NULL;
1750 struct buffer_head *prev_group_bh = NULL;
1751 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) ac->ac_bh->b_data;
1752 struct ocfs2_chain_list *cl = (struct ocfs2_chain_list *) &fe->id2.i_chain;
1753 struct ocfs2_group_desc *bg;
1754
1755 chain = ac->ac_chain;
1756 trace_ocfs2_search_chain_begin(
1757 (unsigned long long)OCFS2_I(alloc_inode)->ip_blkno,
1758 bits_wanted, chain);
1759
1760 status = ocfs2_read_group_descriptor(alloc_inode, fe,
1761 le64_to_cpu(cl->cl_recs[chain].c_blkno),
1762 &group_bh);
1763 if (status < 0) {
1764 mlog_errno(status);
1765 goto bail;
1766 }
1767 bg = (struct ocfs2_group_desc *) group_bh->b_data;
1768
1769 status = -ENOSPC;
1770
1771
1772 while ((status = ac->ac_group_search(alloc_inode, group_bh,
1773 bits_wanted, min_bits,
1774 ac->ac_max_block,
1775 res)) == -ENOSPC) {
1776 if (!bg->bg_next_group)
1777 break;
1778
1779 brelse(prev_group_bh);
1780 prev_group_bh = NULL;
1781
1782 next_group = le64_to_cpu(bg->bg_next_group);
1783 prev_group_bh = group_bh;
1784 group_bh = NULL;
1785 status = ocfs2_read_group_descriptor(alloc_inode, fe,
1786 next_group, &group_bh);
1787 if (status < 0) {
1788 mlog_errno(status);
1789 goto bail;
1790 }
1791 bg = (struct ocfs2_group_desc *) group_bh->b_data;
1792 }
1793 if (status < 0) {
1794 if (status != -ENOSPC)
1795 mlog_errno(status);
1796 goto bail;
1797 }
1798
1799 trace_ocfs2_search_chain_succ(
1800 (unsigned long long)le64_to_cpu(bg->bg_blkno), res->sr_bits);
1801
1802 res->sr_bg_blkno = le64_to_cpu(bg->bg_blkno);
1803
1804 BUG_ON(res->sr_bits == 0);
1805 if (!status)
1806 ocfs2_bg_discontig_fix_result(ac, bg, res);
1807
1808
1809
1810
1811
1812 res->sr_bg_stable_blkno = group_bh->b_blocknr;
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827 if (!ac->ac_disable_chain_relink &&
1828 (prev_group_bh) &&
1829 (ocfs2_block_group_reasonably_empty(bg, res->sr_bits))) {
1830 status = ocfs2_relink_block_group(handle, alloc_inode,
1831 ac->ac_bh, group_bh,
1832 prev_group_bh, chain);
1833 if (status < 0) {
1834 mlog_errno(status);
1835 goto bail;
1836 }
1837 }
1838
1839 if (ac->ac_find_loc_only)
1840 goto out_loc_only;
1841
1842 status = ocfs2_alloc_dinode_update_counts(alloc_inode, handle,
1843 ac->ac_bh, res->sr_bits,
1844 chain);
1845 if (status) {
1846 mlog_errno(status);
1847 goto bail;
1848 }
1849
1850 status = ocfs2_block_group_set_bits(handle,
1851 alloc_inode,
1852 bg,
1853 group_bh,
1854 res->sr_bit_offset,
1855 res->sr_bits);
1856 if (status < 0) {
1857 ocfs2_rollback_alloc_dinode_counts(alloc_inode,
1858 ac->ac_bh, res->sr_bits, chain);
1859 mlog_errno(status);
1860 goto bail;
1861 }
1862
1863 trace_ocfs2_search_chain_end(
1864 (unsigned long long)le64_to_cpu(fe->i_blkno),
1865 res->sr_bits);
1866
1867out_loc_only:
1868 *bits_left = le16_to_cpu(bg->bg_free_bits_count);
1869bail:
1870 brelse(group_bh);
1871 brelse(prev_group_bh);
1872
1873 if (status)
1874 mlog_errno(status);
1875 return status;
1876}
1877
1878
1879static int ocfs2_claim_suballoc_bits(struct ocfs2_alloc_context *ac,
1880 handle_t *handle,
1881 u32 bits_wanted,
1882 u32 min_bits,
1883 struct ocfs2_suballoc_result *res)
1884{
1885 int status;
1886 u16 victim, i;
1887 u16 bits_left = 0;
1888 u64 hint = ac->ac_last_group;
1889 struct ocfs2_chain_list *cl;
1890 struct ocfs2_dinode *fe;
1891
1892 BUG_ON(ac->ac_bits_given >= ac->ac_bits_wanted);
1893 BUG_ON(bits_wanted > (ac->ac_bits_wanted - ac->ac_bits_given));
1894 BUG_ON(!ac->ac_bh);
1895
1896 fe = (struct ocfs2_dinode *) ac->ac_bh->b_data;
1897
1898
1899
1900 BUG_ON(!OCFS2_IS_VALID_DINODE(fe));
1901
1902 if (le32_to_cpu(fe->id1.bitmap1.i_used) >=
1903 le32_to_cpu(fe->id1.bitmap1.i_total)) {
1904 status = ocfs2_error(ac->ac_inode->i_sb,
1905 "Chain allocator dinode %llu has %u used bits but only %u total\n",
1906 (unsigned long long)le64_to_cpu(fe->i_blkno),
1907 le32_to_cpu(fe->id1.bitmap1.i_used),
1908 le32_to_cpu(fe->id1.bitmap1.i_total));
1909 goto bail;
1910 }
1911
1912 res->sr_bg_blkno = hint;
1913 if (res->sr_bg_blkno) {
1914
1915
1916
1917
1918 status = ocfs2_search_one_group(ac, handle, bits_wanted,
1919 min_bits, res, &bits_left);
1920 if (!status)
1921 goto set_hint;
1922 if (status < 0 && status != -ENOSPC) {
1923 mlog_errno(status);
1924 goto bail;
1925 }
1926 }
1927
1928 cl = (struct ocfs2_chain_list *) &fe->id2.i_chain;
1929
1930 victim = ocfs2_find_victim_chain(cl);
1931 ac->ac_chain = victim;
1932
1933 status = ocfs2_search_chain(ac, handle, bits_wanted, min_bits,
1934 res, &bits_left);
1935 if (!status) {
1936 if (ocfs2_is_cluster_bitmap(ac->ac_inode))
1937 hint = res->sr_bg_blkno;
1938 else
1939 hint = ocfs2_group_from_res(res);
1940 goto set_hint;
1941 }
1942 if (status < 0 && status != -ENOSPC) {
1943 mlog_errno(status);
1944 goto bail;
1945 }
1946
1947 trace_ocfs2_claim_suballoc_bits(victim);
1948
1949
1950
1951
1952
1953 ac->ac_disable_chain_relink = 1;
1954 for (i = 0; i < le16_to_cpu(cl->cl_next_free_rec); i ++) {
1955 if (i == victim)
1956 continue;
1957 if (!cl->cl_recs[i].c_free)
1958 continue;
1959
1960 ac->ac_chain = i;
1961 status = ocfs2_search_chain(ac, handle, bits_wanted, min_bits,
1962 res, &bits_left);
1963 if (!status) {
1964 hint = ocfs2_group_from_res(res);
1965 break;
1966 }
1967 if (status < 0 && status != -ENOSPC) {
1968 mlog_errno(status);
1969 goto bail;
1970 }
1971 }
1972
1973set_hint:
1974 if (status != -ENOSPC) {
1975
1976
1977
1978 if (bits_left < min_bits)
1979 ac->ac_last_group = 0;
1980 else
1981 ac->ac_last_group = hint;
1982 }
1983
1984bail:
1985 if (status)
1986 mlog_errno(status);
1987 return status;
1988}
1989
1990int ocfs2_claim_metadata(handle_t *handle,
1991 struct ocfs2_alloc_context *ac,
1992 u32 bits_wanted,
1993 u64 *suballoc_loc,
1994 u16 *suballoc_bit_start,
1995 unsigned int *num_bits,
1996 u64 *blkno_start)
1997{
1998 int status;
1999 struct ocfs2_suballoc_result res = { .sr_blkno = 0, };
2000
2001 BUG_ON(!ac);
2002 BUG_ON(ac->ac_bits_wanted < (ac->ac_bits_given + bits_wanted));
2003 BUG_ON(ac->ac_which != OCFS2_AC_USE_META);
2004
2005 status = ocfs2_claim_suballoc_bits(ac,
2006 handle,
2007 bits_wanted,
2008 1,
2009 &res);
2010 if (status < 0) {
2011 mlog_errno(status);
2012 goto bail;
2013 }
2014 atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs);
2015
2016 *suballoc_loc = res.sr_bg_blkno;
2017 *suballoc_bit_start = res.sr_bit_offset;
2018 *blkno_start = res.sr_blkno;
2019 ac->ac_bits_given += res.sr_bits;
2020 *num_bits = res.sr_bits;
2021 status = 0;
2022bail:
2023 if (status)
2024 mlog_errno(status);
2025 return status;
2026}
2027
2028static void ocfs2_init_inode_ac_group(struct inode *dir,
2029 struct buffer_head *parent_di_bh,
2030 struct ocfs2_alloc_context *ac)
2031{
2032 struct ocfs2_dinode *di = (struct ocfs2_dinode *)parent_di_bh->b_data;
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043 if (OCFS2_I(dir)->ip_last_used_group &&
2044 OCFS2_I(dir)->ip_last_used_slot == ac->ac_alloc_slot)
2045 ac->ac_last_group = OCFS2_I(dir)->ip_last_used_group;
2046 else if (le16_to_cpu(di->i_suballoc_slot) == ac->ac_alloc_slot) {
2047 if (di->i_suballoc_loc)
2048 ac->ac_last_group = le64_to_cpu(di->i_suballoc_loc);
2049 else
2050 ac->ac_last_group = ocfs2_which_suballoc_group(
2051 le64_to_cpu(di->i_blkno),
2052 le16_to_cpu(di->i_suballoc_bit));
2053 }
2054}
2055
2056static inline void ocfs2_save_inode_ac_group(struct inode *dir,
2057 struct ocfs2_alloc_context *ac)
2058{
2059 OCFS2_I(dir)->ip_last_used_group = ac->ac_last_group;
2060 OCFS2_I(dir)->ip_last_used_slot = ac->ac_alloc_slot;
2061}
2062
2063int ocfs2_find_new_inode_loc(struct inode *dir,
2064 struct buffer_head *parent_fe_bh,
2065 struct ocfs2_alloc_context *ac,
2066 u64 *fe_blkno)
2067{
2068 int ret;
2069 handle_t *handle = NULL;
2070 struct ocfs2_suballoc_result *res;
2071
2072 BUG_ON(!ac);
2073 BUG_ON(ac->ac_bits_given != 0);
2074 BUG_ON(ac->ac_bits_wanted != 1);
2075 BUG_ON(ac->ac_which != OCFS2_AC_USE_INODE);
2076
2077 res = kzalloc(sizeof(*res), GFP_NOFS);
2078 if (res == NULL) {
2079 ret = -ENOMEM;
2080 mlog_errno(ret);
2081 goto out;
2082 }
2083
2084 ocfs2_init_inode_ac_group(dir, parent_fe_bh, ac);
2085
2086
2087
2088
2089
2090 handle = ocfs2_start_trans(OCFS2_SB(dir->i_sb), OCFS2_SUBALLOC_ALLOC);
2091 if (IS_ERR(handle)) {
2092 ret = PTR_ERR(handle);
2093 handle = NULL;
2094 mlog_errno(ret);
2095 goto out;
2096 }
2097
2098
2099
2100
2101
2102
2103 ac->ac_find_loc_only = 1;
2104
2105 ret = ocfs2_claim_suballoc_bits(ac, handle, 1, 1, res);
2106 if (ret < 0) {
2107 mlog_errno(ret);
2108 goto out;
2109 }
2110
2111 ac->ac_find_loc_priv = res;
2112 *fe_blkno = res->sr_blkno;
2113 ocfs2_update_inode_fsync_trans(handle, dir, 0);
2114out:
2115 if (handle)
2116 ocfs2_commit_trans(OCFS2_SB(dir->i_sb), handle);
2117
2118 if (ret)
2119 kfree(res);
2120
2121 return ret;
2122}
2123
2124int ocfs2_claim_new_inode_at_loc(handle_t *handle,
2125 struct inode *dir,
2126 struct ocfs2_alloc_context *ac,
2127 u64 *suballoc_loc,
2128 u16 *suballoc_bit,
2129 u64 di_blkno)
2130{
2131 int ret;
2132 u16 chain;
2133 struct ocfs2_suballoc_result *res = ac->ac_find_loc_priv;
2134 struct buffer_head *bg_bh = NULL;
2135 struct ocfs2_group_desc *bg;
2136 struct ocfs2_dinode *di = (struct ocfs2_dinode *) ac->ac_bh->b_data;
2137
2138
2139
2140
2141
2142
2143
2144 BUG_ON(res->sr_blkno != di_blkno);
2145
2146 ret = ocfs2_read_group_descriptor(ac->ac_inode, di,
2147 res->sr_bg_stable_blkno, &bg_bh);
2148 if (ret) {
2149 mlog_errno(ret);
2150 goto out;
2151 }
2152
2153 bg = (struct ocfs2_group_desc *) bg_bh->b_data;
2154 chain = le16_to_cpu(bg->bg_chain);
2155
2156 ret = ocfs2_alloc_dinode_update_counts(ac->ac_inode, handle,
2157 ac->ac_bh, res->sr_bits,
2158 chain);
2159 if (ret) {
2160 mlog_errno(ret);
2161 goto out;
2162 }
2163
2164 ret = ocfs2_block_group_set_bits(handle,
2165 ac->ac_inode,
2166 bg,
2167 bg_bh,
2168 res->sr_bit_offset,
2169 res->sr_bits);
2170 if (ret < 0) {
2171 ocfs2_rollback_alloc_dinode_counts(ac->ac_inode,
2172 ac->ac_bh, res->sr_bits, chain);
2173 mlog_errno(ret);
2174 goto out;
2175 }
2176
2177 trace_ocfs2_claim_new_inode_at_loc((unsigned long long)di_blkno,
2178 res->sr_bits);
2179
2180 atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs);
2181
2182 BUG_ON(res->sr_bits != 1);
2183
2184 *suballoc_loc = res->sr_bg_blkno;
2185 *suballoc_bit = res->sr_bit_offset;
2186 ac->ac_bits_given++;
2187 ocfs2_save_inode_ac_group(dir, ac);
2188
2189out:
2190 brelse(bg_bh);
2191
2192 return ret;
2193}
2194
2195int ocfs2_claim_new_inode(handle_t *handle,
2196 struct inode *dir,
2197 struct buffer_head *parent_fe_bh,
2198 struct ocfs2_alloc_context *ac,
2199 u64 *suballoc_loc,
2200 u16 *suballoc_bit,
2201 u64 *fe_blkno)
2202{
2203 int status;
2204 struct ocfs2_suballoc_result res;
2205
2206 BUG_ON(!ac);
2207 BUG_ON(ac->ac_bits_given != 0);
2208 BUG_ON(ac->ac_bits_wanted != 1);
2209 BUG_ON(ac->ac_which != OCFS2_AC_USE_INODE);
2210
2211 ocfs2_init_inode_ac_group(dir, parent_fe_bh, ac);
2212
2213 status = ocfs2_claim_suballoc_bits(ac,
2214 handle,
2215 1,
2216 1,
2217 &res);
2218 if (status < 0) {
2219 mlog_errno(status);
2220 goto bail;
2221 }
2222 atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs);
2223
2224 BUG_ON(res.sr_bits != 1);
2225
2226 *suballoc_loc = res.sr_bg_blkno;
2227 *suballoc_bit = res.sr_bit_offset;
2228 *fe_blkno = res.sr_blkno;
2229 ac->ac_bits_given++;
2230 ocfs2_save_inode_ac_group(dir, ac);
2231 status = 0;
2232bail:
2233 if (status)
2234 mlog_errno(status);
2235 return status;
2236}
2237
2238
2239
2240static inline u32 ocfs2_desc_bitmap_to_cluster_off(struct inode *inode,
2241 u64 bg_blkno,
2242 u16 bg_bit_off)
2243{
2244 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2245 u32 cluster = 0;
2246
2247 BUG_ON(!ocfs2_is_cluster_bitmap(inode));
2248
2249 if (bg_blkno != osb->first_cluster_group_blkno)
2250 cluster = ocfs2_blocks_to_clusters(inode->i_sb, bg_blkno);
2251 cluster += (u32) bg_bit_off;
2252 return cluster;
2253}
2254
2255
2256
2257u64 ocfs2_which_cluster_group(struct inode *inode, u32 cluster)
2258{
2259 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2260 u32 group_no;
2261
2262 BUG_ON(!ocfs2_is_cluster_bitmap(inode));
2263
2264 group_no = cluster / osb->bitmap_cpg;
2265 if (!group_no)
2266 return osb->first_cluster_group_blkno;
2267 return ocfs2_clusters_to_blocks(inode->i_sb,
2268 group_no * osb->bitmap_cpg);
2269}
2270
2271
2272
2273static inline void ocfs2_block_to_cluster_group(struct inode *inode,
2274 u64 data_blkno,
2275 u64 *bg_blkno,
2276 u16 *bg_bit_off)
2277{
2278 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2279 u32 data_cluster = ocfs2_blocks_to_clusters(osb->sb, data_blkno);
2280
2281 BUG_ON(!ocfs2_is_cluster_bitmap(inode));
2282
2283 *bg_blkno = ocfs2_which_cluster_group(inode,
2284 data_cluster);
2285
2286 if (*bg_blkno == osb->first_cluster_group_blkno)
2287 *bg_bit_off = (u16) data_cluster;
2288 else
2289 *bg_bit_off = (u16) ocfs2_blocks_to_clusters(osb->sb,
2290 data_blkno - *bg_blkno);
2291}
2292
2293
2294
2295
2296
2297
2298
2299int __ocfs2_claim_clusters(handle_t *handle,
2300 struct ocfs2_alloc_context *ac,
2301 u32 min_clusters,
2302 u32 max_clusters,
2303 u32 *cluster_start,
2304 u32 *num_clusters)
2305{
2306 int status;
2307 unsigned int bits_wanted = max_clusters;
2308 struct ocfs2_suballoc_result res = { .sr_blkno = 0, };
2309 struct ocfs2_super *osb = OCFS2_SB(ac->ac_inode->i_sb);
2310
2311 BUG_ON(ac->ac_bits_given >= ac->ac_bits_wanted);
2312
2313 BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL
2314 && ac->ac_which != OCFS2_AC_USE_MAIN);
2315
2316 if (ac->ac_which == OCFS2_AC_USE_LOCAL) {
2317 WARN_ON(min_clusters > 1);
2318
2319 status = ocfs2_claim_local_alloc_bits(osb,
2320 handle,
2321 ac,
2322 bits_wanted,
2323 cluster_start,
2324 num_clusters);
2325 if (!status)
2326 atomic_inc(&osb->alloc_stats.local_data);
2327 } else {
2328 if (min_clusters > (osb->bitmap_cpg - 1)) {
2329
2330
2331 mlog(ML_ERROR, "minimum allocation requested %u exceeds "
2332 "group bitmap size %u!\n", min_clusters,
2333 osb->bitmap_cpg);
2334 status = -ENOSPC;
2335 goto bail;
2336 }
2337
2338 if (bits_wanted > (osb->bitmap_cpg - 1))
2339 bits_wanted = osb->bitmap_cpg - 1;
2340
2341 status = ocfs2_claim_suballoc_bits(ac,
2342 handle,
2343 bits_wanted,
2344 min_clusters,
2345 &res);
2346 if (!status) {
2347 BUG_ON(res.sr_blkno);
2348 *cluster_start =
2349 ocfs2_desc_bitmap_to_cluster_off(ac->ac_inode,
2350 res.sr_bg_blkno,
2351 res.sr_bit_offset);
2352 atomic_inc(&osb->alloc_stats.bitmap_data);
2353 *num_clusters = res.sr_bits;
2354 }
2355 }
2356 if (status < 0) {
2357 if (status != -ENOSPC)
2358 mlog_errno(status);
2359 goto bail;
2360 }
2361
2362 ac->ac_bits_given += *num_clusters;
2363
2364bail:
2365 if (status)
2366 mlog_errno(status);
2367 return status;
2368}
2369
2370int ocfs2_claim_clusters(handle_t *handle,
2371 struct ocfs2_alloc_context *ac,
2372 u32 min_clusters,
2373 u32 *cluster_start,
2374 u32 *num_clusters)
2375{
2376 unsigned int bits_wanted = ac->ac_bits_wanted - ac->ac_bits_given;
2377
2378 return __ocfs2_claim_clusters(handle, ac, min_clusters,
2379 bits_wanted, cluster_start, num_clusters);
2380}
2381
2382static int ocfs2_block_group_clear_bits(handle_t *handle,
2383 struct inode *alloc_inode,
2384 struct ocfs2_group_desc *bg,
2385 struct buffer_head *group_bh,
2386 unsigned int bit_off,
2387 unsigned int num_bits,
2388 void (*undo_fn)(unsigned int bit,
2389 unsigned long *bmap))
2390{
2391 int status;
2392 unsigned int tmp;
2393 struct ocfs2_group_desc *undo_bg = NULL;
2394 struct journal_head *jh;
2395
2396
2397
2398 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg));
2399
2400 trace_ocfs2_block_group_clear_bits(bit_off, num_bits);
2401
2402 BUG_ON(undo_fn && !ocfs2_is_cluster_bitmap(alloc_inode));
2403 status = ocfs2_journal_access_gd(handle, INODE_CACHE(alloc_inode),
2404 group_bh,
2405 undo_fn ?
2406 OCFS2_JOURNAL_ACCESS_UNDO :
2407 OCFS2_JOURNAL_ACCESS_WRITE);
2408 if (status < 0) {
2409 mlog_errno(status);
2410 goto bail;
2411 }
2412
2413 jh = bh2jh(group_bh);
2414 if (undo_fn) {
2415 spin_lock(&jh->b_state_lock);
2416 undo_bg = (struct ocfs2_group_desc *) jh->b_committed_data;
2417 BUG_ON(!undo_bg);
2418 }
2419
2420 tmp = num_bits;
2421 while(tmp--) {
2422 ocfs2_clear_bit((bit_off + tmp),
2423 (unsigned long *) bg->bg_bitmap);
2424 if (undo_fn)
2425 undo_fn(bit_off + tmp,
2426 (unsigned long *) undo_bg->bg_bitmap);
2427 }
2428 le16_add_cpu(&bg->bg_free_bits_count, num_bits);
2429 if (le16_to_cpu(bg->bg_free_bits_count) > le16_to_cpu(bg->bg_bits)) {
2430 if (undo_fn)
2431 spin_unlock(&jh->b_state_lock);
2432 return ocfs2_error(alloc_inode->i_sb, "Group descriptor # %llu has bit count %u but claims %u are freed. num_bits %d\n",
2433 (unsigned long long)le64_to_cpu(bg->bg_blkno),
2434 le16_to_cpu(bg->bg_bits),
2435 le16_to_cpu(bg->bg_free_bits_count),
2436 num_bits);
2437 }
2438
2439 if (undo_fn)
2440 spin_unlock(&jh->b_state_lock);
2441
2442 ocfs2_journal_dirty(handle, group_bh);
2443bail:
2444 return status;
2445}
2446
2447
2448
2449
2450static int _ocfs2_free_suballoc_bits(handle_t *handle,
2451 struct inode *alloc_inode,
2452 struct buffer_head *alloc_bh,
2453 unsigned int start_bit,
2454 u64 bg_blkno,
2455 unsigned int count,
2456 void (*undo_fn)(unsigned int bit,
2457 unsigned long *bitmap))
2458{
2459 int status = 0;
2460 u32 tmp_used;
2461 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) alloc_bh->b_data;
2462 struct ocfs2_chain_list *cl = &fe->id2.i_chain;
2463 struct buffer_head *group_bh = NULL;
2464 struct ocfs2_group_desc *group;
2465
2466
2467
2468
2469
2470
2471 BUG_ON(!OCFS2_IS_VALID_DINODE(fe));
2472 BUG_ON((count + start_bit) > ocfs2_bits_per_group(cl));
2473
2474 trace_ocfs2_free_suballoc_bits(
2475 (unsigned long long)OCFS2_I(alloc_inode)->ip_blkno,
2476 (unsigned long long)bg_blkno,
2477 start_bit, count);
2478
2479 status = ocfs2_read_group_descriptor(alloc_inode, fe, bg_blkno,
2480 &group_bh);
2481 if (status < 0) {
2482 mlog_errno(status);
2483 goto bail;
2484 }
2485 group = (struct ocfs2_group_desc *) group_bh->b_data;
2486
2487 BUG_ON((count + start_bit) > le16_to_cpu(group->bg_bits));
2488
2489 status = ocfs2_block_group_clear_bits(handle, alloc_inode,
2490 group, group_bh,
2491 start_bit, count, undo_fn);
2492 if (status < 0) {
2493 mlog_errno(status);
2494 goto bail;
2495 }
2496
2497 status = ocfs2_journal_access_di(handle, INODE_CACHE(alloc_inode),
2498 alloc_bh, OCFS2_JOURNAL_ACCESS_WRITE);
2499 if (status < 0) {
2500 mlog_errno(status);
2501 ocfs2_block_group_set_bits(handle, alloc_inode, group, group_bh,
2502 start_bit, count);
2503 goto bail;
2504 }
2505
2506 le32_add_cpu(&cl->cl_recs[le16_to_cpu(group->bg_chain)].c_free,
2507 count);
2508 tmp_used = le32_to_cpu(fe->id1.bitmap1.i_used);
2509 fe->id1.bitmap1.i_used = cpu_to_le32(tmp_used - count);
2510 ocfs2_journal_dirty(handle, alloc_bh);
2511
2512bail:
2513 brelse(group_bh);
2514 return status;
2515}
2516
2517int ocfs2_free_suballoc_bits(handle_t *handle,
2518 struct inode *alloc_inode,
2519 struct buffer_head *alloc_bh,
2520 unsigned int start_bit,
2521 u64 bg_blkno,
2522 unsigned int count)
2523{
2524 return _ocfs2_free_suballoc_bits(handle, alloc_inode, alloc_bh,
2525 start_bit, bg_blkno, count, NULL);
2526}
2527
2528int ocfs2_free_dinode(handle_t *handle,
2529 struct inode *inode_alloc_inode,
2530 struct buffer_head *inode_alloc_bh,
2531 struct ocfs2_dinode *di)
2532{
2533 u64 blk = le64_to_cpu(di->i_blkno);
2534 u16 bit = le16_to_cpu(di->i_suballoc_bit);
2535 u64 bg_blkno = ocfs2_which_suballoc_group(blk, bit);
2536
2537 if (di->i_suballoc_loc)
2538 bg_blkno = le64_to_cpu(di->i_suballoc_loc);
2539 return ocfs2_free_suballoc_bits(handle, inode_alloc_inode,
2540 inode_alloc_bh, bit, bg_blkno, 1);
2541}
2542
2543static int _ocfs2_free_clusters(handle_t *handle,
2544 struct inode *bitmap_inode,
2545 struct buffer_head *bitmap_bh,
2546 u64 start_blk,
2547 unsigned int num_clusters,
2548 void (*undo_fn)(unsigned int bit,
2549 unsigned long *bitmap))
2550{
2551 int status;
2552 u16 bg_start_bit;
2553 u64 bg_blkno;
2554
2555
2556
2557
2558
2559
2560 BUG_ON(start_blk != ocfs2_clusters_to_blocks(bitmap_inode->i_sb,
2561 ocfs2_blocks_to_clusters(bitmap_inode->i_sb,
2562 start_blk)));
2563
2564
2565 ocfs2_block_to_cluster_group(bitmap_inode, start_blk, &bg_blkno,
2566 &bg_start_bit);
2567
2568 trace_ocfs2_free_clusters((unsigned long long)bg_blkno,
2569 (unsigned long long)start_blk,
2570 bg_start_bit, num_clusters);
2571
2572 status = _ocfs2_free_suballoc_bits(handle, bitmap_inode, bitmap_bh,
2573 bg_start_bit, bg_blkno,
2574 num_clusters, undo_fn);
2575 if (status < 0) {
2576 mlog_errno(status);
2577 goto out;
2578 }
2579
2580 ocfs2_local_alloc_seen_free_bits(OCFS2_SB(bitmap_inode->i_sb),
2581 num_clusters);
2582
2583out:
2584 return status;
2585}
2586
2587int ocfs2_free_clusters(handle_t *handle,
2588 struct inode *bitmap_inode,
2589 struct buffer_head *bitmap_bh,
2590 u64 start_blk,
2591 unsigned int num_clusters)
2592{
2593 return _ocfs2_free_clusters(handle, bitmap_inode, bitmap_bh,
2594 start_blk, num_clusters,
2595 _ocfs2_set_bit);
2596}
2597
2598
2599
2600
2601
2602int ocfs2_release_clusters(handle_t *handle,
2603 struct inode *bitmap_inode,
2604 struct buffer_head *bitmap_bh,
2605 u64 start_blk,
2606 unsigned int num_clusters)
2607{
2608 return _ocfs2_free_clusters(handle, bitmap_inode, bitmap_bh,
2609 start_blk, num_clusters,
2610 _ocfs2_clear_bit);
2611}
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623int ocfs2_lock_allocators(struct inode *inode,
2624 struct ocfs2_extent_tree *et,
2625 u32 clusters_to_add, u32 extents_to_split,
2626 struct ocfs2_alloc_context **data_ac,
2627 struct ocfs2_alloc_context **meta_ac)
2628{
2629 int ret = 0, num_free_extents;
2630 unsigned int max_recs_needed = clusters_to_add + 2 * extents_to_split;
2631 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2632
2633 *meta_ac = NULL;
2634 if (data_ac)
2635 *data_ac = NULL;
2636
2637 BUG_ON(clusters_to_add != 0 && data_ac == NULL);
2638
2639 num_free_extents = ocfs2_num_free_extents(et);
2640 if (num_free_extents < 0) {
2641 ret = num_free_extents;
2642 mlog_errno(ret);
2643 goto out;
2644 }
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659 if (!num_free_extents ||
2660 (ocfs2_sparse_alloc(osb) && num_free_extents < max_recs_needed)) {
2661 ret = ocfs2_reserve_new_metadata(osb, et->et_root_el, meta_ac);
2662 if (ret < 0) {
2663 if (ret != -ENOSPC)
2664 mlog_errno(ret);
2665 goto out;
2666 }
2667 }
2668
2669 if (clusters_to_add == 0)
2670 goto out;
2671
2672 ret = ocfs2_reserve_clusters(osb, clusters_to_add, data_ac);
2673 if (ret < 0) {
2674 if (ret != -ENOSPC)
2675 mlog_errno(ret);
2676 goto out;
2677 }
2678
2679out:
2680 if (ret) {
2681 if (*meta_ac) {
2682 ocfs2_free_alloc_context(*meta_ac);
2683 *meta_ac = NULL;
2684 }
2685
2686
2687
2688
2689 }
2690
2691 return ret;
2692}
2693
2694
2695
2696
2697
2698static int ocfs2_get_suballoc_slot_bit(struct ocfs2_super *osb, u64 blkno,
2699 u16 *suballoc_slot, u64 *group_blkno,
2700 u16 *suballoc_bit)
2701{
2702 int status;
2703 struct buffer_head *inode_bh = NULL;
2704 struct ocfs2_dinode *inode_fe;
2705
2706 trace_ocfs2_get_suballoc_slot_bit((unsigned long long)blkno);
2707
2708
2709 status = ocfs2_read_blocks_sync(osb, blkno, 1, &inode_bh);
2710 if (status < 0) {
2711 mlog(ML_ERROR, "read block %llu failed %d\n",
2712 (unsigned long long)blkno, status);
2713 goto bail;
2714 }
2715
2716 inode_fe = (struct ocfs2_dinode *) inode_bh->b_data;
2717 if (!OCFS2_IS_VALID_DINODE(inode_fe)) {
2718 mlog(ML_ERROR, "invalid inode %llu requested\n",
2719 (unsigned long long)blkno);
2720 status = -EINVAL;
2721 goto bail;
2722 }
2723
2724 if (le16_to_cpu(inode_fe->i_suballoc_slot) != (u16)OCFS2_INVALID_SLOT &&
2725 (u32)le16_to_cpu(inode_fe->i_suballoc_slot) > osb->max_slots - 1) {
2726 mlog(ML_ERROR, "inode %llu has invalid suballoc slot %u\n",
2727 (unsigned long long)blkno,
2728 (u32)le16_to_cpu(inode_fe->i_suballoc_slot));
2729 status = -EINVAL;
2730 goto bail;
2731 }
2732
2733 if (suballoc_slot)
2734 *suballoc_slot = le16_to_cpu(inode_fe->i_suballoc_slot);
2735 if (suballoc_bit)
2736 *suballoc_bit = le16_to_cpu(inode_fe->i_suballoc_bit);
2737 if (group_blkno)
2738 *group_blkno = le64_to_cpu(inode_fe->i_suballoc_loc);
2739
2740bail:
2741 brelse(inode_bh);
2742
2743 if (status)
2744 mlog_errno(status);
2745 return status;
2746}
2747
2748
2749
2750
2751
2752
2753
2754
2755static int ocfs2_test_suballoc_bit(struct ocfs2_super *osb,
2756 struct inode *suballoc,
2757 struct buffer_head *alloc_bh,
2758 u64 group_blkno, u64 blkno,
2759 u16 bit, int *res)
2760{
2761 struct ocfs2_dinode *alloc_di;
2762 struct ocfs2_group_desc *group;
2763 struct buffer_head *group_bh = NULL;
2764 u64 bg_blkno;
2765 int status;
2766
2767 trace_ocfs2_test_suballoc_bit((unsigned long long)blkno,
2768 (unsigned int)bit);
2769
2770 alloc_di = (struct ocfs2_dinode *)alloc_bh->b_data;
2771 if ((bit + 1) > ocfs2_bits_per_group(&alloc_di->id2.i_chain)) {
2772 mlog(ML_ERROR, "suballoc bit %u out of range of %u\n",
2773 (unsigned int)bit,
2774 ocfs2_bits_per_group(&alloc_di->id2.i_chain));
2775 status = -EINVAL;
2776 goto bail;
2777 }
2778
2779 bg_blkno = group_blkno ? group_blkno :
2780 ocfs2_which_suballoc_group(blkno, bit);
2781 status = ocfs2_read_group_descriptor(suballoc, alloc_di, bg_blkno,
2782 &group_bh);
2783 if (status < 0) {
2784 mlog(ML_ERROR, "read group %llu failed %d\n",
2785 (unsigned long long)bg_blkno, status);
2786 goto bail;
2787 }
2788
2789 group = (struct ocfs2_group_desc *) group_bh->b_data;
2790 *res = ocfs2_test_bit(bit, (unsigned long *)group->bg_bitmap);
2791
2792bail:
2793 brelse(group_bh);
2794
2795 if (status)
2796 mlog_errno(status);
2797 return status;
2798}
2799
2800
2801
2802
2803
2804
2805
2806
2807
2808
2809
2810
2811
2812
2813int ocfs2_test_inode_bit(struct ocfs2_super *osb, u64 blkno, int *res)
2814{
2815 int status;
2816 u64 group_blkno = 0;
2817 u16 suballoc_bit = 0, suballoc_slot = 0;
2818 struct inode *inode_alloc_inode;
2819 struct buffer_head *alloc_bh = NULL;
2820
2821 trace_ocfs2_test_inode_bit((unsigned long long)blkno);
2822
2823 status = ocfs2_get_suballoc_slot_bit(osb, blkno, &suballoc_slot,
2824 &group_blkno, &suballoc_bit);
2825 if (status < 0) {
2826 mlog(ML_ERROR, "get alloc slot and bit failed %d\n", status);
2827 goto bail;
2828 }
2829
2830 if (suballoc_slot == (u16)OCFS2_INVALID_SLOT)
2831 inode_alloc_inode = ocfs2_get_system_file_inode(osb,
2832 GLOBAL_INODE_ALLOC_SYSTEM_INODE, suballoc_slot);
2833 else
2834 inode_alloc_inode = ocfs2_get_system_file_inode(osb,
2835 INODE_ALLOC_SYSTEM_INODE, suballoc_slot);
2836 if (!inode_alloc_inode) {
2837
2838
2839 status = -EINVAL;
2840 mlog(ML_ERROR, "unable to get alloc inode in slot %u\n",
2841 (u32)suballoc_slot);
2842 goto bail;
2843 }
2844
2845 inode_lock(inode_alloc_inode);
2846 status = ocfs2_inode_lock(inode_alloc_inode, &alloc_bh, 0);
2847 if (status < 0) {
2848 inode_unlock(inode_alloc_inode);
2849 iput(inode_alloc_inode);
2850 mlog(ML_ERROR, "lock on alloc inode on slot %u failed %d\n",
2851 (u32)suballoc_slot, status);
2852 goto bail;
2853 }
2854
2855 status = ocfs2_test_suballoc_bit(osb, inode_alloc_inode, alloc_bh,
2856 group_blkno, blkno, suballoc_bit, res);
2857 if (status < 0)
2858 mlog(ML_ERROR, "test suballoc bit failed %d\n", status);
2859
2860 ocfs2_inode_unlock(inode_alloc_inode, 0);
2861 inode_unlock(inode_alloc_inode);
2862
2863 iput(inode_alloc_inode);
2864 brelse(alloc_bh);
2865bail:
2866 if (status)
2867 mlog_errno(status);
2868 return status;
2869}
2870