← Back to branch summary

~csurbhi/ubuntu/maverick/e2fsprogs/e2fsprogs.fix-505719

« back to all changes in this revision

Viewing changes to lib/ext2fs/closefs.c

  • Committer: Bazaar Package Importer
  • Author(s): Steve Langasek
  • Date: 2008-08-08 20:32:11 UTC
  • mfrom: (1.1.11 upstream)
  • Revision ID: james.westby@ubuntu.com-20080808203211-w72lpsd9q7o3bw6x
Tags: 1.41.0-3ubuntu1
https://launchpad.net/bugs/254152
https://launchpad.net/bugs/246461
* Merge from Debian unstable (LP: #254152, #246461), remaining changes:
  - Do not build-depend on dietlibc-dev, which is in universe.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/ext2fs/closefs.c
45
45
        return 0;
46
46
}
47
47
 
 
48
/*
 
49
 * This function returns the location of the superblock, block group
 
50
 * descriptors for a given block group.  It currently returns the
 
51
 * number of free blocks assuming that inode table and allocation
 
52
 * bitmaps will be in the group.  This is not necessarily the case
 
53
 * when the flex_bg feature is enabled, so callers should take care!
 
54
 * It was only really intended for use by mke2fs, and even there it's
 
55
 * not that useful.  In the future, when we redo this function for
 
56
 * 64-bit block numbers, we should probably return the number of
 
57
 * blocks used by the super block and group descriptors instead.
 
58
 *
 
59
 * See also the comment for ext2fs_reserve_super_and_bgd()
 
60
 */
48
61
int ext2fs_super_and_bgd_loc(ext2_filsys fs, 
49
62
                             dgrp_t group,
50
63
                             blk_t *ret_super_blk,
54
67
{
55
68
        blk_t   group_block, super_blk = 0, old_desc_blk = 0, new_desc_blk = 0;
56
69
        unsigned int meta_bg, meta_bg_size;
57
 
        int     numblocks, has_super;
58
 
        int     old_desc_blocks;
 
70
        blk_t   numblocks, old_desc_blocks;
 
71
        int     has_super;
59
72
 
60
 
        group_block = fs->super->s_first_data_block +
61
 
                (group * fs->super->s_blocks_per_group);
 
73
        group_block = ext2fs_group_first_block(fs, group);
62
74
 
63
75
        if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG)
64
76
                old_desc_blocks = fs->super->s_first_meta_bg;
81
93
                super_blk = group_block;
82
94
                numblocks--;
83
95
        }
84
 
        meta_bg_size = (fs->blocksize / sizeof (struct ext2_group_desc));
 
96
        meta_bg_size = EXT2_DESC_PER_BLOCK(fs->super);
85
97
        meta_bg = group / meta_bg_size;
86
98
 
87
99
        if (!(fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG) ||
191
203
        
192
204
        if (sgrp > ((1 << 16) - 1))
193
205
                sgrp = (1 << 16) - 1;
194
 
#ifdef EXT2FS_ENABLE_SWAPFS
195
 
        if (fs->flags & EXT2_FLAG_SWAP_BYTES)
196
 
                super_shadow->s_block_group_nr = ext2fs_swab16(sgrp);
197
 
        else
 
206
#ifdef WORDS_BIGENDIAN
 
207
        super_shadow->s_block_group_nr = ext2fs_swab16(sgrp);
 
208
#else
 
209
        fs->super->s_block_group_nr = sgrp;
198
210
#endif
199
 
                fs->super->s_block_group_nr = sgrp;
200
211
 
201
212
        return io_channel_write_blk(fs->io, group_block, -SUPERBLOCK_SIZE, 
202
213
                                    super_shadow);
205
216
 
206
217
errcode_t ext2fs_flush(ext2_filsys fs)
207
218
{
208
 
        dgrp_t          i,j;
 
219
        dgrp_t          i;
209
220
        errcode_t       retval;
210
221
        unsigned long   fs_state;
211
222
        __u32           feature_incompat;
212
223
        struct ext2_super_block *super_shadow = 0;
213
224
        struct ext2_group_desc *group_shadow = 0;
 
225
#ifdef WORDS_BIGENDIAN
214
226
        struct ext2_group_desc *s, *t;
 
227
        dgrp_t          j;
 
228
#endif
215
229
        char    *group_ptr;
216
230
        int     old_desc_blocks;
217
231
        
222
236
 
223
237
        fs->super->s_wtime = fs->now ? fs->now : time(NULL);
224
238
        fs->super->s_block_group_nr = 0;
225
 
#ifdef EXT2FS_ENABLE_SWAPFS
226
 
        if (fs->flags & EXT2_FLAG_SWAP_BYTES) {
227
 
                retval = EXT2_ET_NO_MEMORY;
228
 
                retval = ext2fs_get_mem(SUPERBLOCK_SIZE, &super_shadow);
229
 
                if (retval)
230
 
                        goto errout;
231
 
                retval = ext2fs_get_array(fs->blocksize, fs->desc_blocks,
232
 
                                        &group_shadow);
233
 
                if (retval)
234
 
                        goto errout;
235
 
                memset(group_shadow, 0, (size_t) fs->blocksize *
236
 
                       fs->desc_blocks);
237
 
 
238
 
                /* swap the group descriptors */
239
 
                for (j=0, s=fs->group_desc, t=group_shadow;
240
 
                     j < fs->group_desc_count; j++, t++, s++) {
241
 
                        *t = *s;
242
 
                        ext2fs_swap_group_desc(t);
243
 
                }
244
 
        } else {
245
 
                super_shadow = fs->super;
246
 
                group_shadow = fs->group_desc;
 
239
#ifdef WORDS_BIGENDIAN
 
240
        retval = EXT2_ET_NO_MEMORY;
 
241
        retval = ext2fs_get_mem(SUPERBLOCK_SIZE, &super_shadow);
 
242
        if (retval)
 
243
                goto errout;
 
244
        retval = ext2fs_get_array(fs->desc_blocks, fs->blocksize, 
 
245
                                  &group_shadow);
 
246
        if (retval)
 
247
                goto errout;
 
248
        memset(group_shadow, 0, (size_t) fs->blocksize *
 
249
               fs->desc_blocks);
 
250
        
 
251
        /* swap the group descriptors */
 
252
        for (j=0, s=fs->group_desc, t=group_shadow;
 
253
             j < fs->group_desc_count; j++, t++, s++) {
 
254
                *t = *s;
 
255
                ext2fs_swap_group_desc(t);
247
256
        }
248
257
#else
249
258
        super_shadow = fs->super;
257
266
         */
258
267
        fs->super->s_state &= ~EXT2_VALID_FS;
259
268
        fs->super->s_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER;
260
 
#ifdef EXT2FS_ENABLE_SWAPFS
261
 
        if (fs->flags & EXT2_FLAG_SWAP_BYTES) {
262
 
                *super_shadow = *fs->super;
263
 
                ext2fs_swap_super(super_shadow);
264
 
        }
 
269
#ifdef WORDS_BIGENDIAN
 
270
        *super_shadow = *fs->super;
 
271
        ext2fs_swap_super(super_shadow);
265
272
#endif
266
273
 
267
274
        /*
336
343
        fs->super->s_block_group_nr = 0;
337
344
        fs->super->s_state = fs_state;
338
345
        fs->super->s_feature_incompat = feature_incompat;
339
 
#ifdef EXT2FS_ENABLE_SWAPFS
340
 
        if (fs->flags & EXT2_FLAG_SWAP_BYTES) {
341
 
                *super_shadow = *fs->super;
342
 
                ext2fs_swap_super(super_shadow);
343
 
        }
 
346
#ifdef WORDS_BIGENDIAN
 
347
        *super_shadow = *fs->super;
 
348
        ext2fs_swap_super(super_shadow);
344
349
#endif
345
350
 
346
351
        retval = io_channel_flush(fs->io);
353
358
        retval = io_channel_flush(fs->io);
354
359
errout:
355
360
        fs->super->s_state = fs_state;
356
 
        if (fs->flags & EXT2_FLAG_SWAP_BYTES) {
357
 
                if (super_shadow)
358
 
                        ext2fs_free_mem(&super_shadow);
359
 
                if (group_shadow)
360
 
                        ext2fs_free_mem(&group_shadow);
361
 
        }
 
361
#ifdef WORDS_BIGENDIAN
 
362
        if (super_shadow)
 
363
                ext2fs_free_mem(&super_shadow);
 
364
        if (group_shadow)
 
365
                ext2fs_free_mem(&group_shadow);
 
366
#endif
362
367
        return retval;
363
368
}
364
369