Root/fs/ocfs2/suballoc.c

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

Archive Download this file



interactive