1 /* 2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README 3 */ 4 5 /* 6 * Written by Alexander Zarochentcev. 7 * 8 * The kernel part of the (on-line) reiserfs resizer. 9 */ 10 11 #include <linux/kernel.h> 12 #include <linux/mm.h> 13 #include <linux/vmalloc.h> 14 #include <linux/string.h> 15 #include <linux/errno.h> 16 #include "reiserfs.h" 17 #include <linux/buffer_head.h> 18 19 int reiserfs_resize(struct super_block *s, unsigned long block_count_new) 20 { 21 int err = 0; 22 struct reiserfs_super_block *sb; 23 struct reiserfs_bitmap_info *bitmap; 24 struct reiserfs_bitmap_info *info; 25 struct reiserfs_bitmap_info *old_bitmap = SB_AP_BITMAP(s); 26 struct buffer_head *bh; 27 struct reiserfs_transaction_handle th; 28 unsigned int bmap_nr_new, bmap_nr; 29 unsigned int block_r_new, block_r; 30 31 struct reiserfs_list_bitmap *jb; 32 struct reiserfs_list_bitmap jbitmap[JOURNAL_NUM_BITMAPS]; 33 34 unsigned long int block_count, free_blocks; 35 int i; 36 int copy_size; 37 int depth; 38 39 sb = SB_DISK_SUPER_BLOCK(s); 40 41 if (SB_BLOCK_COUNT(s) >= block_count_new) { 42 printk("can\'t shrink filesystem on-line\n"); 43 return -EINVAL; 44 } 45 46 /* check the device size */ 47 depth = reiserfs_write_unlock_nested(s); 48 bh = sb_bread(s, block_count_new - 1); 49 reiserfs_write_lock_nested(s, depth); 50 if (!bh) { 51 printk("reiserfs_resize: can\'t read last block\n"); 52 return -EINVAL; 53 } 54 bforget(bh); 55 56 /* 57 * old disk layout detection; those partitions can be mounted, but 58 * cannot be resized 59 */ 60 if (SB_BUFFER_WITH_SB(s)->b_blocknr * SB_BUFFER_WITH_SB(s)->b_size 61 != REISERFS_DISK_OFFSET_IN_BYTES) { 62 printk 63 ("reiserfs_resize: unable to resize a reiserfs without distributed bitmap (fs version < 3.5.12)\n"); 64 return -ENOTSUPP; 65 } 66 67 /* count used bits in last bitmap block */ 68 block_r = SB_BLOCK_COUNT(s) - 69 (reiserfs_bmap_count(s) - 1) * s->s_blocksize * 8; 70 71 /* count bitmap blocks in new fs */ 72 bmap_nr_new = block_count_new / (s->s_blocksize * 8); 73 block_r_new = block_count_new - bmap_nr_new * s->s_blocksize * 8; 74 if (block_r_new) 75 bmap_nr_new++; 76 else 77 block_r_new = s->s_blocksize * 8; 78 79 /* save old values */ 80 block_count = SB_BLOCK_COUNT(s); 81 bmap_nr = reiserfs_bmap_count(s); 82 83 /* resizing of reiserfs bitmaps (journal and real), if needed */ 84 if (bmap_nr_new > bmap_nr) { 85 /* reallocate journal bitmaps */ 86 if (reiserfs_allocate_list_bitmaps(s, jbitmap, bmap_nr_new) < 0) { 87 printk 88 ("reiserfs_resize: unable to allocate memory for journal bitmaps\n"); 89 return -ENOMEM; 90 } 91 /* 92 * the new journal bitmaps are zero filled, now we copy i 93 * the bitmap node pointers from the old journal bitmap 94 * structs, and then transfer the new data structures 95 * into the journal struct. 96 * 97 * using the copy_size var below allows this code to work for 98 * both shrinking and expanding the FS. 99 */ 100 copy_size = bmap_nr_new < bmap_nr ? bmap_nr_new : bmap_nr; 101 copy_size = 102 copy_size * sizeof(struct reiserfs_list_bitmap_node *); 103 for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) { 104 struct reiserfs_bitmap_node **node_tmp; 105 jb = SB_JOURNAL(s)->j_list_bitmap + i; 106 memcpy(jbitmap[i].bitmaps, jb->bitmaps, copy_size); 107 108 /* 109 * just in case vfree schedules on us, copy the new 110 * pointer into the journal struct before freeing the 111 * old one 112 */ 113 node_tmp = jb->bitmaps; 114 jb->bitmaps = jbitmap[i].bitmaps; 115 vfree(node_tmp); 116 } 117 118 /* 119 * allocate additional bitmap blocks, reallocate 120 * array of bitmap block pointers 121 */ 122 bitmap = 123 vzalloc(array_size(bmap_nr_new, 124 sizeof(struct reiserfs_bitmap_info))); 125 if (!bitmap) { 126 /* 127 * Journal bitmaps are still supersized, but the 128 * memory isn't leaked, so I guess it's ok 129 */ 130 printk("reiserfs_resize: unable to allocate memory.\n"); 131 return -ENOMEM; 132 } 133 for (i = 0; i < bmap_nr; i++) 134 bitmap[i] = old_bitmap[i]; 135 136 /* 137 * This doesn't go through the journal, but it doesn't have to. 138 * The changes are still atomic: We're synced up when the 139 * journal transaction begins, and the new bitmaps don't 140 * matter if the transaction fails. 141 */ 142 for (i = bmap_nr; i < bmap_nr_new; i++) { 143 int depth; 144 /* 145 * don't use read_bitmap_block since it will cache 146 * the uninitialized bitmap 147 */ 148 depth = reiserfs_write_unlock_nested(s); 149 bh = sb_bread(s, i * s->s_blocksize * 8); 150 reiserfs_write_lock_nested(s, depth); 151 if (!bh) { 152 vfree(bitmap); 153 return -EIO; 154 } 155 memset(bh->b_data, 0, sb_blocksize(sb)); 156 reiserfs_set_le_bit(0, bh->b_data); 157 reiserfs_cache_bitmap_metadata(s, bh, bitmap + i); 158 159 set_buffer_uptodate(bh); 160 mark_buffer_dirty(bh); 161 depth = reiserfs_write_unlock_nested(s); 162 sync_dirty_buffer(bh); 163 reiserfs_write_lock_nested(s, depth); 164 /* update bitmap_info stuff */ 165 bitmap[i].free_count = sb_blocksize(sb) * 8 - 1; 166 brelse(bh); 167 } 168 /* free old bitmap blocks array */ 169 SB_AP_BITMAP(s) = bitmap; 170 vfree(old_bitmap); 171 } 172 173 /* 174 * begin transaction, if there was an error, it's fine. Yes, we have 175 * incorrect bitmaps now, but none of it is ever going to touch the 176 * disk anyway. 177 */ 178 err = journal_begin(&th, s, 10); 179 if (err) 180 return err; 181 182 /* Extend old last bitmap block - new blocks have been made available */ 183 info = SB_AP_BITMAP(s) + bmap_nr - 1; 184 bh = reiserfs_read_bitmap_block(s, bmap_nr - 1); 185 if (!bh) { 186 int jerr = journal_end(&th); 187 if (jerr) 188 return jerr; 189 return -EIO; 190 } 191 192 reiserfs_prepare_for_journal(s, bh, 1); 193 for (i = block_r; i < s->s_blocksize * 8; i++) 194 reiserfs_clear_le_bit(i, bh->b_data); 195 info->free_count += s->s_blocksize * 8 - block_r; 196 197 journal_mark_dirty(&th, bh); 198 brelse(bh); 199 200 /* Correct new last bitmap block - It may not be full */ 201 info = SB_AP_BITMAP(s) + bmap_nr_new - 1; 202 bh = reiserfs_read_bitmap_block(s, bmap_nr_new - 1); 203 if (!bh) { 204 int jerr = journal_end(&th); 205 if (jerr) 206 return jerr; 207 return -EIO; 208 } 209 210 reiserfs_prepare_for_journal(s, bh, 1); 211 for (i = block_r_new; i < s->s_blocksize * 8; i++) 212 reiserfs_set_le_bit(i, bh->b_data); 213 journal_mark_dirty(&th, bh); 214 brelse(bh); 215 216 info->free_count -= s->s_blocksize * 8 - block_r_new; 217 /* update super */ 218 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1); 219 free_blocks = SB_FREE_BLOCKS(s); 220 PUT_SB_FREE_BLOCKS(s, 221 free_blocks + (block_count_new - block_count - 222 (bmap_nr_new - bmap_nr))); 223 PUT_SB_BLOCK_COUNT(s, block_count_new); 224 PUT_SB_BMAP_NR(s, bmap_would_wrap(bmap_nr_new) ? : bmap_nr_new); 225 226 journal_mark_dirty(&th, SB_BUFFER_WITH_SB(s)); 227 228 SB_JOURNAL(s)->j_must_wait = 1; 229 return journal_end(&th); 230 } 231