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(sb: s, block: 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(sb: 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(sb: 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 = min(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(addr: 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(sb: s, block: i * s->s_blocksize * 8); |
150 | reiserfs_write_lock_nested(s, depth); |
151 | if (!bh) { |
152 | vfree(addr: bitmap); |
153 | return -EIO; |
154 | } |
155 | memset(bh->b_data, 0, sb_blocksize(sb)); |
156 | reiserfs_set_le_bit(nr: 0, addr: bh->b_data); |
157 | reiserfs_cache_bitmap_metadata(sb: s, bh, info: 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(addr: 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, sb: 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(sb: s, bitmap: 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, wait: 1); |
193 | for (i = block_r; i < s->s_blocksize * 8; i++) |
194 | reiserfs_clear_le_bit(nr: i, addr: 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(sb: s, bitmap: 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, wait: 1); |
211 | for (i = block_r_new; i < s->s_blocksize * 8; i++) |
212 | reiserfs_set_le_bit(nr: i, addr: 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), wait: 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 | |