resize/online.c

   1 /*
   2  * online.c --- Do on-line resizing of the ext3 filesystem
   3  *
   4  * Copyright (C) 2006 by Theodore Ts'o
   5  *
   6  * %Begin-Header%
   7  * This file may be redistributed under the terms of the GNU Public
   8  * License.
   9  * %End-Header%
  10  */
  11
  12 #include "config.h"
  13 #include "resize2fs.h"
  14 #ifdef HAVE_SYS_IOCTL_H
  15 #include <sys/ioctl.h>
  16 #endif
  17 #include <sys/stat.h>
  18 #include <fcntl.h>
  19
  20 extern char *program_name;
  21
  22 #define MAX_32_NUM ((((unsigned long long) 1) << 32) - 1)
  23
  24 #ifdef __linux__
  25 static int parse_version_number(const char *s)
  26 {
  27         int     major, minor, rev;
  28         char    *endptr;
  29         const char *cp = s;
  30
  31         if (!s)
  32                 return 0;
  33         major = strtol(cp, &endptr, 10);
  34         if (cp == endptr || *endptr != '.')
  35                 return 0;
  36         cp = endptr + 1;
  37         minor = strtol(cp, &endptr, 10);
  38         if (cp == endptr || *endptr != '.')
  39                 return 0;
  40         cp = endptr + 1;
  41         rev = strtol(cp, &endptr, 10);
  42         if (cp == endptr)
  43                 return 0;
  44         return ((((major * 256) + minor) * 256) + rev);
  45 }
  46
  47 #define VERSION_CODE(a,b,c) (((a) << 16) + ((b) << 8) + (c))
  48
  49 #endif
  50
  51 errcode_t online_resize_fs(ext2_filsys fs, const char *mtpt,
  52                            blk64_t *new_size, int flags EXT2FS_ATTR((unused)))
  53 {
  54 #ifdef __linux__
  55         struct ext2_new_group_input input;
  56         struct ext4_new_group_input input64;
  57         struct ext2_super_block *sb = fs->super;
  58         unsigned long           new_desc_blocks;
  59         ext2_filsys             new_fs;
  60         errcode_t               retval;
  61         double                  percent;
  62         dgrp_t                  i;
  63         blk_t                   size;
  64         int                     fd;
  65         int                     use_old_ioctl = 1;
  66         int                     no_meta_bg_resize = 0;
  67         int                     no_resize_ioctl = 0;
  68
  69         if (getenv("RESIZE2FS_KERNEL_VERSION")) {
  70                 char *version_to_emulate = getenv("RESIZE2FS_KERNEL_VERSION");
  71                 int kvers = parse_version_number(version_to_emulate);
  72
  73                 if (kvers < VERSION_CODE(3, 7, 0))
  74                         no_meta_bg_resize = 1;
  75                 if (kvers < VERSION_CODE(3, 3, 0))
  76                         no_resize_ioctl = 1;
  77         }
  78
  79         if (ext2fs_has_feature_sparse_super2(fs->super) &&
  80             (access("/sys/fs/ext4/features/sparse_super2", R_OK) != 0)) {
  81                 com_err(program_name, 0, _("kernel does not support online "
  82                                            "resize with sparse_super2"));
  83                 exit(1);
  84         }
  85
  86         printf(_("Filesystem at %s is mounted on %s; "
  87                  "on-line resizing required\n"), fs->device_name, mtpt);
  88
  89         if (*new_size < ext2fs_blocks_count(sb)) {
  90                 com_err(program_name, 0, _("On-line shrinking not supported"));
  91                 exit(1);
  92         }
  93
  94         /*
  95          * If the number of descriptor blocks is going to increase,
  96          * the on-line resizing inode must be present.
  97          */
  98         new_desc_blocks = ext2fs_div_ceil(
  99                 ext2fs_div64_ceil(*new_size -
 100                                   fs->super->s_first_data_block,
 101                                   EXT2_BLOCKS_PER_GROUP(fs->super)),
 102                 EXT2_DESC_PER_BLOCK(fs->super));
 103         printf("old_desc_blocks = %lu, new_desc_blocks = %lu\n",
 104                fs->desc_blocks, new_desc_blocks);
 105
 106         /*
 107          * Do error checking to make sure the resize will be successful.
 108          */
 109         if ((access("/sys/fs/ext4/features/meta_bg_resize", R_OK) != 0) ||
 110             no_meta_bg_resize) {
 111                 if (!ext2fs_has_feature_resize_inode(fs->super) &&
 112                     (new_desc_blocks != fs->desc_blocks)) {
 113                         com_err(program_name, 0,
 114                                 _("Filesystem does not support online resizing"));
 115                         exit(1);
 116                 }
 117
 118                 if (ext2fs_has_feature_resize_inode(fs->super) &&
 119                     new_desc_blocks > (fs->desc_blocks +
 120                                        fs->super->s_reserved_gdt_blocks)) {
 121                         com_err(program_name, 0,
 122                                 _("Not enough reserved gdt blocks for resizing"));
 123                         exit(1);
 124                 }
 125
 126                 if ((ext2fs_blocks_count(sb) > MAX_32_NUM) ||
 127                     (*new_size > MAX_32_NUM)) {
 128                         com_err(program_name, 0,
 129                                 _("Kernel does not support resizing a file system this large"));
 130                         exit(1);
 131                 }
 132         }
 133
 134         fd = open(mtpt, O_RDONLY);
 135         if (fd < 0) {
 136                 com_err(program_name, errno,
 137                         _("while trying to open mountpoint %s"), mtpt);
 138                 exit(1);
 139         }
 140
 141         if (no_resize_ioctl) {
 142                 printf(_("Old resize interface requested.\n"));
 143         } else if (ioctl(fd, EXT4_IOC_RESIZE_FS, new_size)) {
 144                 /*
 145                  * If kernel does not support EXT4_IOC_RESIZE_FS, use the
 146                  * old online resize. Note that the old approach does not
 147                  * handle >32 bit file systems
 148                  *
 149                  * Sigh, if we are running a 32-bit binary on a 64-bit
 150                  * kernel (which happens all the time on the MIPS
 151                  * architecture in Debian, but can happen on other CPU
 152                  * architectures as well) we will get EINVAL returned
 153                  * when an ioctl doesn't exist, at least up to Linux
 154                  * 3.1.  See compat_sys_ioctl() in fs/compat_ioctl.c
 155                  * in the kernel sources.  This is probably a kernel
 156                  * bug, but work around it here.
 157                  */
 158                 if ((errno != ENOTTY) && (errno != EINVAL)) {
 159                         if (errno == EPERM)
 160                                 com_err(program_name, 0,
 161                                 _("Permission denied to resize filesystem"));
 162                         else
 163                                 com_err(program_name, errno,
 164                                 _("While checking for on-line resizing "
 165                                   "support"));
 166                         exit(1);
 167                 }
 168         } else {
 169                 close(fd);
 170                 return 0;
 171         }
 172
 173         size = ext2fs_blocks_count(sb);
 174
 175         if (ioctl(fd, EXT2_IOC_GROUP_EXTEND, &size)) {
 176                 if (errno == EPERM)
 177                         com_err(program_name, 0,
 178                                 _("Permission denied to resize filesystem"));
 179                 else if (errno == ENOTTY)
 180                         com_err(program_name, 0,
 181                         _("Kernel does not support online resizing"));
 182                 else
 183                         com_err(program_name, errno,
 184                         _("While checking for on-line resizing support"));
 185                 exit(1);
 186         }
 187
 188         percent = (ext2fs_r_blocks_count(sb) * 100.0) /
 189                 ext2fs_blocks_count(sb);
 190
 191         retval = ext2fs_read_bitmaps(fs);
 192         if (retval) {
 193                 close(fd);
 194                 return retval;
 195         }
 196
 197         retval = ext2fs_dup_handle(fs, &new_fs);
 198         if (retval) {
 199                 close(fd);
 200                 return retval;
 201         }
 202
 203         /* The current method of adding one block group at a time to a
 204          * mounted filesystem means it is impossible to accommodate the
 205          * flex_bg allocation method of placing the metadata together
 206          * in a single block group.  For now we "fix" this issue by
 207          * using the traditional layout for new block groups, where
 208          * each block group is self-contained and contains its own
 209          * bitmap blocks and inode tables.  This means we don't get
 210          * the layout advantages of flex_bg in the new block groups,
 211          * but at least it allows on-line resizing to function.
 212          */
 213         ext2fs_clear_feature_flex_bg(new_fs->super);
 214         retval = adjust_fs_info(new_fs, fs, 0, *new_size);
 215         if (retval) {
 216                 close(fd);
 217                 return retval;
 218         }
 219
 220         printf(_("Performing an on-line resize of %s to %llu (%dk) blocks.\n"),
 221                fs->device_name, (unsigned long long) *new_size,
 222                fs->blocksize / 1024);
 223
 224         size = fs->group_desc_count * sb->s_blocks_per_group +
 225                 sb->s_first_data_block;
 226         if (size > *new_size)
 227                 size = *new_size;
 228
 229         if (ioctl(fd, EXT2_IOC_GROUP_EXTEND, &size)) {
 230                 com_err(program_name, errno,
 231                         _("While trying to extend the last group"));
 232                 exit(1);
 233         }
 234
 235         for (i = fs->group_desc_count;
 236              i < new_fs->group_desc_count; i++) {
 237                 input.group = i;
 238                 input.block_bitmap = ext2fs_block_bitmap_loc(new_fs, i);
 239                 input.inode_bitmap = ext2fs_inode_bitmap_loc(new_fs, i);
 240                 input.inode_table = ext2fs_inode_table_loc(new_fs, i);
 241                 input.blocks_count = ext2fs_group_blocks_count(new_fs, i);
 242                 input.reserved_blocks = (blk_t) (percent * input.blocks_count
 243                                                  / 100.0);
 244
 245 #if 0
 246                 printf("new block bitmap is at 0x%04x\n", input.block_bitmap);
 247                 printf("new inode bitmap is at 0x%04x\n", input.inode_bitmap);
 248                 printf("new inode table is at 0x%04x-0x%04x\n",
 249                        input.inode_table,
 250                        input.inode_table + new_fs->inode_blocks_per_group-1);
 251                 printf("new group has %u blocks\n", input.blocks_count);
 252                 printf("new group will reserve %d blocks\n",
 253                        input.reserved_blocks);
 254                 printf("new group has %d free blocks\n",
 255                        ext2fs_bg_free_blocks_count(new_fs, i),
 256                 printf("new group has %d free inodes (%d blocks)\n",
 257                        ext2fs_bg_free_inodes_count(new_fs, i),
 258                        new_fs->inode_blocks_per_group);
 259                 printf("Adding group #%d\n", input.group);
 260 #endif
 261
 262                 if (use_old_ioctl &&
 263                     ioctl(fd, EXT2_IOC_GROUP_ADD, &input) == 0)
 264                         continue;
 265                 else
 266                         use_old_ioctl = 0;
 267
 268                 input64.group = input.group;
 269                 input64.block_bitmap = input.block_bitmap;
 270                 input64.inode_bitmap = input.inode_bitmap;
 271                 input64.inode_table = input.inode_table;
 272                 input64.blocks_count = input.blocks_count;
 273                 input64.reserved_blocks = input.reserved_blocks;
 274                 input64.unused = input.unused;
 275
 276                 if (ioctl(fd, EXT4_IOC_GROUP_ADD, &input64) < 0) {
 277                         com_err(program_name, errno,
 278                                 _("While trying to add group #%d"),
 279                                 input.group);
 280                         exit(1);
 281                 }
 282         }
 283
 284         ext2fs_free(new_fs);
 285         close(fd);
 286
 287         return 0;
 288 #else
 289         printf(_("Filesystem at %s is mounted on %s, and on-line resizing is "
 290                  "not supported on this system.\n"), fs->device_name, mtpt);
 291         exit(1);
 292 #endif
 293 }