lib/ext2fs/bitmaps.c

   1 /*
   2  * bitmaps.c --- routines to read, write, and manipulate the inode and
   3  * block bitmaps.
   4  *
   5  * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
   6  *
   7  * %Begin-Header%
   8  * This file may be redistributed under the terms of the GNU Public
   9  * License.
  10  * %End-Header%
  11  */
  12
  13 #include <stdio.h>
  14 #include <string.h>
  15 #if HAVE_UNISTD_H
  16 #include <unistd.h>
  17 #endif
  18 #include <stdlib.h>
  19 #include <fcntl.h>
  20 #include <time.h>
  21 #include <sys/stat.h>
  22 #include <sys/types.h>
  23 #if HAVE_ERRNO_H
  24 #include <errno.h>
  25 #endif
  26
  27 #include <linux/ext2_fs.h>
  28
  29 #include "ext2fs.h"
  30
  31 static errcode_t make_bitmap(__u32 start, __u32 end, __u32 real_end,
  32                              const char *descr, char *init_map,
  33                              ext2fs_generic_bitmap *ret)
  34 {
  35         ext2fs_generic_bitmap bitmap;
  36         size_t  size;
  37
  38         bitmap = malloc(sizeof(struct ext2fs_struct_generic_bitmap));
  39         if (!bitmap)
  40                 return ENOMEM;
  41
  42         bitmap->magic = EXT2_ET_MAGIC_GENERIC_BITMAP;
  43         bitmap->fs = NULL;
  44         bitmap->start = start;
  45         bitmap->end = end;
  46         bitmap->real_end = real_end;
  47         bitmap->base_error_code = EXT2_ET_BAD_GENERIC_MARK;
  48         if (descr) {
  49                 bitmap->description = malloc(strlen(descr)+1);
  50                 if (!bitmap->description) {
  51                         free(bitmap);
  52                         return ENOMEM;
  53                 }
  54                 strcpy(bitmap->description, descr);
  55         } else
  56                 bitmap->description = 0;
  57
  58         size = (size_t) (((bitmap->real_end - bitmap->start) / 8) + 1);
  59         bitmap->bitmap = malloc(size);
  60         if (!bitmap->bitmap) {
  61                 free(bitmap->description);
  62                 free(bitmap);
  63                 return ENOMEM;
  64         }
  65
  66         if (init_map)
  67                 memcpy(bitmap->bitmap, init_map, size);
  68         else
  69                 memset(bitmap->bitmap, 0, size);
  70         *ret = bitmap;
  71         return 0;
  72 }
  73
  74 errcode_t ext2fs_allocate_generic_bitmap(__u32 start,
  75                                          __u32 end,
  76                                          __u32 real_end,
  77                                          const char *descr,
  78                                          ext2fs_generic_bitmap *ret)
  79 {
  80         return make_bitmap(start, end, real_end, descr, 0, ret);
  81 }
  82
  83 errcode_t ext2fs_copy_bitmap(ext2fs_generic_bitmap src,
  84                              ext2fs_generic_bitmap *dest)
  85 {
  86         errcode_t               retval;
  87         ext2fs_generic_bitmap   new;
  88
  89         retval = make_bitmap(src->start, src->end, src->real_end,
  90                              src->description, src->bitmap, &new);
  91         if (retval)
  92                 return retval;
  93         new->magic = src->magic;
  94         new->fs = src->fs;
  95         new->base_error_code = src->base_error_code;
  96         *dest = new;
  97         return 0;
  98 }
  99
 100
 101 errcode_t ext2fs_allocate_inode_bitmap(ext2_filsys fs,
 102                                        const char *descr,
 103                                        ext2fs_inode_bitmap *ret)
 104 {
 105         ext2fs_inode_bitmap bitmap;
 106         errcode_t       retval;
 107         __u32           start, end, real_end;
 108
 109         EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 110
 111         fs->write_bitmaps = ext2fs_write_bitmaps;
 112
 113         start = 1;
 114         end = fs->super->s_inodes_count;
 115         real_end = (EXT2_INODES_PER_GROUP(fs->super) * fs->group_desc_count);
 116
 117         retval = ext2fs_allocate_generic_bitmap(start, end, real_end,
 118                                                 descr, &bitmap);
 119         if (retval)
 120                 return retval;
 121
 122         bitmap->magic = EXT2_ET_MAGIC_INODE_BITMAP;
 123         bitmap->fs = fs;
 124         bitmap->base_error_code = EXT2_ET_BAD_INODE_MARK;
 125
 126         *ret = bitmap;
 127         return 0;
 128 }
 129
 130 errcode_t ext2fs_allocate_block_bitmap(ext2_filsys fs,
 131                                        const char *descr,
 132                                        ext2fs_block_bitmap *ret)
 133 {
 134         ext2fs_block_bitmap bitmap;
 135         errcode_t       retval;
 136         __u32           start, end, real_end;
 137
 138         EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 139
 140         fs->write_bitmaps = ext2fs_write_bitmaps;
 141
 142         start = fs->super->s_first_data_block;
 143         end = fs->super->s_blocks_count-1;
 144         real_end = (EXT2_BLOCKS_PER_GROUP(fs->super)
 145                     * fs->group_desc_count)-1 + start;
 146
 147         retval = ext2fs_allocate_generic_bitmap(start, end, real_end,
 148                                                 descr, &bitmap);
 149         if (retval)
 150                 return retval;
 151
 152         bitmap->magic = EXT2_ET_MAGIC_BLOCK_BITMAP;
 153         bitmap->fs = fs;
 154         bitmap->base_error_code = EXT2_ET_BAD_BLOCK_MARK;
 155
 156         *ret = bitmap;
 157         return 0;
 158 }
 159
 160 errcode_t ext2fs_fudge_inode_bitmap_end(ext2fs_inode_bitmap bitmap,
 161                                         ino_t end, ino_t *oend)
 162 {
 163         EXT2_CHECK_MAGIC(bitmap, EXT2_ET_MAGIC_INODE_BITMAP);
 164
 165         if (end > bitmap->real_end)
 166                 return EXT2_ET_FUDGE_INODE_BITMAP_END;
 167         if (oend)
 168                 *oend = bitmap->end;
 169         bitmap->end = end;
 170         return 0;
 171 }
 172
 173 errcode_t ext2fs_fudge_block_bitmap_end(ext2fs_block_bitmap bitmap,
 174                                         blk_t end, blk_t *oend)
 175 {
 176         EXT2_CHECK_MAGIC(bitmap, EXT2_ET_MAGIC_BLOCK_BITMAP);
 177
 178         if (end > bitmap->real_end)
 179                 return EXT2_ET_FUDGE_BLOCK_BITMAP_END;
 180         if (oend)
 181                 *oend = bitmap->end;
 182         bitmap->end = end;
 183         return 0;
 184 }
 185
 186 void ext2fs_clear_inode_bitmap(ext2fs_inode_bitmap bitmap)
 187 {
 188         if (!bitmap || (bitmap->magic != EXT2_ET_MAGIC_INODE_BITMAP))
 189                 return;
 190
 191         memset(bitmap->bitmap, 0,
 192                (size_t) (((bitmap->real_end - bitmap->start) / 8) + 1));
 193 }
 194
 195 void ext2fs_clear_block_bitmap(ext2fs_block_bitmap bitmap)
 196 {
 197         if (!bitmap || (bitmap->magic != EXT2_ET_MAGIC_BLOCK_BITMAP))
 198                 return;
 199
 200         memset(bitmap->bitmap, 0,
 201                (size_t) (((bitmap->real_end - bitmap->start) / 8) + 1));
 202 }