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 <fcntl.h>
  19 #include <time.h>
  20 #if HAVE_SYS_STAT_H
  21 #include <sys/stat.h>
  22 #endif
  23 #if HAVE_SYS_TYPES_H
  24 #include <sys/types.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         errcode_t               retval;
  37         size_t                  size;
  38
  39         retval = ext2fs_get_mem(sizeof(struct ext2fs_struct_generic_bitmap),
  40                                 (void **) &bitmap);
  41         if (retval)
  42                 return retval;
  43
  44         bitmap->magic = EXT2_ET_MAGIC_GENERIC_BITMAP;
  45         bitmap->fs = NULL;
  46         bitmap->start = start;
  47         bitmap->end = end;
  48         bitmap->real_end = real_end;
  49         bitmap->base_error_code = EXT2_ET_BAD_GENERIC_MARK;
  50         if (descr) {
  51                 retval = ext2fs_get_mem(strlen(descr)+1,
  52                                         (void **) &bitmap->description);
  53                 if (retval) {
  54                         ext2fs_free_mem((void **) &bitmap);
  55                         return retval;
  56                 }
  57                 strcpy(bitmap->description, descr);
  58         } else
  59                 bitmap->description = 0;
  60
  61         size = (size_t) (((bitmap->real_end - bitmap->start) / 8) + 1);
  62         retval = ext2fs_get_mem(size, (void **) &bitmap->bitmap);
  63         if (retval) {
  64                 ext2fs_free_mem((void **) &bitmap->description);
  65                 ext2fs_free_mem((void **) &bitmap);
  66                 return retval;
  67         }
  68
  69         if (init_map)
  70                 memcpy(bitmap->bitmap, init_map, size);
  71         else
  72                 memset(bitmap->bitmap, 0, size);
  73         *ret = bitmap;
  74         return 0;
  75 }
  76
  77 errcode_t ext2fs_allocate_generic_bitmap(__u32 start,
  78                                          __u32 end,
  79                                          __u32 real_end,
  80                                          const char *descr,
  81                                          ext2fs_generic_bitmap *ret)
  82 {
  83         return make_bitmap(start, end, real_end, descr, 0, ret);
  84 }
  85
  86 errcode_t ext2fs_copy_bitmap(ext2fs_generic_bitmap src,
  87                              ext2fs_generic_bitmap *dest)
  88 {
  89         errcode_t               retval;
  90         ext2fs_generic_bitmap   new;
  91
  92         retval = make_bitmap(src->start, src->end, src->real_end,
  93                              src->description, src->bitmap, &new);
  94         if (retval)
  95                 return retval;
  96         new->magic = src->magic;
  97         new->fs = src->fs;
  98         new->base_error_code = src->base_error_code;
  99         *dest = new;
 100         return 0;
 101 }
 102
 103 void ext2fs_set_bitmap_padding(ext2fs_generic_bitmap map)
 104 {
 105         __u32   i, j;
 106
 107         for (i=map->end+1, j = i - map->start; i <= map->real_end; i++, j++)
 108                 ext2fs_set_bit(j, map->bitmap);
 109
 110         return;
 111 }
 112
 113 errcode_t ext2fs_allocate_inode_bitmap(ext2_filsys fs,
 114                                        const char *descr,
 115                                        ext2fs_inode_bitmap *ret)
 116 {
 117         ext2fs_inode_bitmap bitmap;
 118         errcode_t       retval;
 119         __u32           start, end, real_end;
 120
 121         EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 122
 123         fs->write_bitmaps = ext2fs_write_bitmaps;
 124
 125         start = 1;
 126         end = fs->super->s_inodes_count;
 127         real_end = (EXT2_INODES_PER_GROUP(fs->super) * fs->group_desc_count);
 128
 129         retval = ext2fs_allocate_generic_bitmap(start, end, real_end,
 130                                                 descr, &bitmap);
 131         if (retval)
 132                 return retval;
 133
 134         bitmap->magic = EXT2_ET_MAGIC_INODE_BITMAP;
 135         bitmap->fs = fs;
 136         bitmap->base_error_code = EXT2_ET_BAD_INODE_MARK;
 137
 138         *ret = bitmap;
 139         return 0;
 140 }
 141
 142 errcode_t ext2fs_allocate_block_bitmap(ext2_filsys fs,
 143                                        const char *descr,
 144                                        ext2fs_block_bitmap *ret)
 145 {
 146         ext2fs_block_bitmap bitmap;
 147         errcode_t       retval;
 148         __u32           start, end, real_end;
 149
 150         EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 151
 152         fs->write_bitmaps = ext2fs_write_bitmaps;
 153
 154         start = fs->super->s_first_data_block;
 155         end = fs->super->s_blocks_count-1;
 156         real_end = (EXT2_BLOCKS_PER_GROUP(fs->super)
 157                     * fs->group_desc_count)-1 + start;
 158
 159         retval = ext2fs_allocate_generic_bitmap(start, end, real_end,
 160                                                 descr, &bitmap);
 161         if (retval)
 162                 return retval;
 163
 164         bitmap->magic = EXT2_ET_MAGIC_BLOCK_BITMAP;
 165         bitmap->fs = fs;
 166         bitmap->base_error_code = EXT2_ET_BAD_BLOCK_MARK;
 167
 168         *ret = bitmap;
 169         return 0;
 170 }
 171
 172 errcode_t ext2fs_fudge_inode_bitmap_end(ext2fs_inode_bitmap bitmap,
 173                                         ino_t end, ino_t *oend)
 174 {
 175         EXT2_CHECK_MAGIC(bitmap, EXT2_ET_MAGIC_INODE_BITMAP);
 176
 177         if (end > bitmap->real_end)
 178                 return EXT2_ET_FUDGE_INODE_BITMAP_END;
 179         if (oend)
 180                 *oend = bitmap->end;
 181         bitmap->end = end;
 182         return 0;
 183 }
 184
 185 errcode_t ext2fs_fudge_block_bitmap_end(ext2fs_block_bitmap bitmap,
 186                                         blk_t end, blk_t *oend)
 187 {
 188         EXT2_CHECK_MAGIC(bitmap, EXT2_ET_MAGIC_BLOCK_BITMAP);
 189
 190         if (end > bitmap->real_end)
 191                 return EXT2_ET_FUDGE_BLOCK_BITMAP_END;
 192         if (oend)
 193                 *oend = bitmap->end;
 194         bitmap->end = end;
 195         return 0;
 196 }
 197
 198 void ext2fs_clear_inode_bitmap(ext2fs_inode_bitmap bitmap)
 199 {
 200         if (!bitmap || (bitmap->magic != EXT2_ET_MAGIC_INODE_BITMAP))
 201                 return;
 202
 203         memset(bitmap->bitmap, 0,
 204                (size_t) (((bitmap->real_end - bitmap->start) / 8) + 1));
 205 }
 206
 207 void ext2fs_clear_block_bitmap(ext2fs_block_bitmap bitmap)
 208 {
 209         if (!bitmap || (bitmap->magic != EXT2_ET_MAGIC_BLOCK_BITMAP))
 210                 return;
 211
 212         memset(bitmap->bitmap, 0,
 213                (size_t) (((bitmap->real_end - bitmap->start) / 8) + 1));
 214 }