1 /* 2 * res_gdt.c --- reserve blocks for growing the group descriptor table 3 * during online resizing. 4 * 5 * Copyright (C) 2002 Andreas Dilger 6 * 7 * %Begin-Header% 8 * This file may be redistributed under the terms of the GNU Library 9 * General Public License, version 2. 10 * %End-Header% 11 */ 12 13 #include "config.h" 14 #include <stdio.h> 15 #include <string.h> 16 #include <time.h> 17 #include "ext2_fs.h" 18 #include "ext2fs.h" 19 20 /* 21 * Iterate through the groups which hold BACKUP superblock/GDT copies in an 22 * ext3 filesystem. The counters should be initialized to 1, 5, and 7 before 23 * calling this for the first time. In a sparse filesystem it will be the 24 * sequence of powers of 3, 5, and 7: 1, 3, 5, 7, 9, 25, 27, 49, 81, ... 25 * For a non-sparse filesystem it will be every group: 1, 2, 3, 4, ... 26 */ 27 static unsigned int list_backups(ext2_filsys fs, unsigned int *three, 28 unsigned int *five, unsigned int *seven) 29 { 30 unsigned int *min = three; 31 int mult = 3; 32 unsigned int ret; 33 34 if (ext2fs_has_feature_sparse_super2(fs->super)) { 35 if (*min == 1) { 36 *min += 1; 37 if (fs->super->s_backup_bgs[0]) 38 return fs->super->s_backup_bgs[0]; 39 } 40 if (*min == 2) { 41 *min += 1; 42 if (fs->super->s_backup_bgs[1]) 43 return fs->super->s_backup_bgs[1]; 44 } 45 return fs->group_desc_count; 46 } 47 if (!ext2fs_has_feature_sparse_super(fs->super)) { 48 ret = *min; 49 *min += 1; 50 return ret; 51 } 52 53 if (*five < *min) { 54 min = five; 55 mult = 5; 56 } 57 if (*seven < *min) { 58 min = seven; 59 mult = 7; 60 } 61 62 ret = *min; 63 *min *= mult; 64 65 return ret; 66 } 67 68 /* 69 * This code assumes that the reserved blocks have already been marked in-use 70 * during ext2fs_initialize(), so that they are not allocated for other 71 * uses before we can add them to the resize inode (which has to come 72 * after the creation of the inode table). 73 */ 74 errcode_t ext2fs_create_resize_inode(ext2_filsys fs) 75 { 76 errcode_t retval, retval2; 77 struct ext2_super_block *sb; 78 struct ext2_inode inode; 79 __u32 *dindir_buf, *gdt_buf; 80 unsigned long long apb, inode_size; 81 /* FIXME-64 - can't deal with extents */ 82 blk_t dindir_blk, rsv_off, gdt_off, gdt_blk; 83 int dindir_dirty = 0, inode_dirty = 0, sb_blk = 0; 84 85 EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); 86 87 sb = fs->super; 88 89 retval = ext2fs_get_array(2, fs->blocksize, &dindir_buf); 90 if (retval) 91 return retval; 92 gdt_buf = (__u32 *)((char *)dindir_buf + fs->blocksize); 93 94 retval = ext2fs_read_inode(fs, EXT2_RESIZE_INO, &inode); 95 if (retval) 96 goto out_free; 97 98 /* 99 * File systems with a blocksize of 1024 and bigalloc have 100 * sb->s_first_data_block of 0; yet the superblock is still at 101 * block #1. We compensate for it here. 102 */ 103 sb_blk = sb->s_first_data_block; 104 if (fs->blocksize == 1024 && sb_blk == 0) 105 sb_blk = 1; 106 107 /* Maximum possible file size (we donly use the dindirect blocks) */ 108 apb = EXT2_ADDR_PER_BLOCK(sb); 109 if ((dindir_blk = inode.i_block[EXT2_DIND_BLOCK])) { 110 #ifdef RES_GDT_DEBUG 111 printf("reading GDT dindir %u\n", dindir_blk); 112 #endif 113 retval = ext2fs_read_ind_block(fs, dindir_blk, dindir_buf); 114 if (retval) 115 goto out_inode; 116 } else { 117 blk_t goal = sb_blk + fs->desc_blocks + 118 sb->s_reserved_gdt_blocks + 2 + 119 fs->inode_blocks_per_group; 120 121 retval = ext2fs_alloc_block(fs, goal, 0, &dindir_blk); 122 if (retval) 123 goto out_free; 124 inode.i_mode = LINUX_S_IFREG | 0600; 125 inode.i_links_count = 1; 126 inode.i_block[EXT2_DIND_BLOCK] = dindir_blk; 127 ext2fs_iblk_set(fs, &inode, 1); 128 memset(dindir_buf, 0, fs->blocksize); 129 #ifdef RES_GDT_DEBUG 130 printf("allocated GDT dindir %u\n", dindir_blk); 131 #endif 132 dindir_dirty = inode_dirty = 1; 133 inode_size = apb*apb + apb + EXT2_NDIR_BLOCKS; 134 inode_size *= fs->blocksize; 135 retval = ext2fs_inode_size_set(fs, &inode, inode_size); 136 if (retval) 137 goto out_free; 138 inode.i_ctime = fs->now ? fs->now : time(0); 139 } 140 141 for (rsv_off = 0, gdt_off = fs->desc_blocks, 142 gdt_blk = sb_blk + 1 + fs->desc_blocks; 143 rsv_off < sb->s_reserved_gdt_blocks; 144 rsv_off++, gdt_off++, gdt_blk++) { 145 unsigned int three = 1, five = 5, seven = 7; 146 unsigned int grp, last = 0; 147 int gdt_dirty = 0; 148 149 gdt_off %= apb; 150 if (!dindir_buf[gdt_off]) { 151 /* FIXME XXX XXX 152 blk_t new_blk; 153 154 retval = ext2fs_new_block(fs, gdt_blk, 0, &new_blk); 155 if (retval) 156 goto out_free; 157 if (new_blk != gdt_blk) { 158 // XXX free block 159 retval = -1; // XXX 160 } 161 */ 162 gdt_dirty = dindir_dirty = inode_dirty = 1; 163 memset(gdt_buf, 0, fs->blocksize); 164 dindir_buf[gdt_off] = gdt_blk; 165 ext2fs_iblk_add_blocks(fs, &inode, 1); 166 #ifdef RES_GDT_DEBUG 167 printf("added primary GDT block %u at %u[%u]\n", 168 gdt_blk, dindir_blk, gdt_off); 169 #endif 170 } else if (dindir_buf[gdt_off] == gdt_blk) { 171 #ifdef RES_GDT_DEBUG 172 printf("reading primary GDT block %u\n", gdt_blk); 173 #endif 174 retval = ext2fs_read_ind_block(fs, gdt_blk, gdt_buf); 175 if (retval) 176 goto out_dindir; 177 } else { 178 #ifdef RES_GDT_DEBUG 179 printf("bad primary GDT %u != %u at %u[%u]\n", 180 dindir_buf[gdt_off], gdt_blk,dindir_blk,gdt_off); 181 #endif 182 retval = EXT2_ET_RESIZE_INODE_CORRUPT; 183 goto out_dindir; 184 } 185 186 while ((grp = list_backups(fs, &three, &five, &seven)) < 187 fs->group_desc_count) { 188 blk_t expect = gdt_blk + grp * sb->s_blocks_per_group; 189 190 if (!gdt_buf[last]) { 191 #ifdef RES_GDT_DEBUG 192 printf("added backup GDT %u grp %u@%u[%u]\n", 193 expect, grp, gdt_blk, last); 194 #endif 195 gdt_buf[last] = expect; 196 ext2fs_iblk_add_blocks(fs, &inode, 1); 197 gdt_dirty = inode_dirty = 1; 198 } else if (gdt_buf[last] != expect) { 199 #ifdef RES_GDT_DEBUG 200 printf("bad backup GDT %u != %u at %u[%u]\n", 201 gdt_buf[last], expect, gdt_blk, last); 202 #endif 203 retval = EXT2_ET_RESIZE_INODE_CORRUPT; 204 goto out_dindir; 205 } 206 last++; 207 } 208 if (gdt_dirty) { 209 #ifdef RES_GDT_DEBUG 210 printf("writing primary GDT block %u\n", gdt_blk); 211 #endif 212 retval = ext2fs_write_ind_block(fs, gdt_blk, gdt_buf); 213 if (retval) 214 goto out_dindir; 215 } 216 } 217 218 out_dindir: 219 if (dindir_dirty) { 220 retval2 = ext2fs_write_ind_block(fs, dindir_blk, dindir_buf); 221 if (!retval) 222 retval = retval2; 223 } 224 out_inode: 225 #ifdef RES_GDT_DEBUG 226 printf("inode.i_blocks = %u, i_size = %u\n", inode.i_blocks, 227 inode.i_size); 228 #endif 229 if (inode_dirty) { 230 inode.i_atime = inode.i_mtime = fs->now ? fs->now : time(0); 231 retval2 = ext2fs_write_new_inode(fs, EXT2_RESIZE_INO, &inode); 232 if (!retval) 233 retval = retval2; 234 } 235 out_free: 236 ext2fs_free_mem(&dindir_buf); 237 return retval; 238 } 239 240
