hammer expand: Layer 2 formatting (step 1.5/2)
[dragonfly.git] / sys / vfs / hammer / hammer_expand.c
CommitLineData
e27700cf
MN
1/*
2 * Copyright (c) 2009 The DragonFly Project. All rights reserved.
3 *
4 * This code is derived from software contributed to The DragonFly Project
90ecab35
MN
5 * by Matthew Dillon <dillon@backplane.com> and
6 * Michael Neumann <mneumann@ntecs.de>
e27700cf
MN
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in
16 * the documentation and/or other materials provided with the
17 * distribution.
18 * 3. Neither the name of The DragonFly Project nor the names of its
19 * contributors may be used to endorse or promote products derived
20 * from this software without specific, prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
26 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
28 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
30 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
31 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
32 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 *
35 */
36
37#include "hammer.h"
90ecab35
MN
38#include <sys/fcntl.h>
39#include <sys/nlookup.h>
40#include <sys/buf.h>
41
42static int
2c794fb2
MN
43hammer_format_volume_header(struct hammer_mount *hmp, const char *dev_path,
44 const char *vol_name, int vol_no, int vol_count,
45 int64_t vol_size, int64_t boot_area_size, int64_t mem_area_size,
46 uint64_t *num_layer1_entries_p);
e27700cf
MN
47
48int
49hammer_ioc_expand(hammer_transaction_t trans, hammer_inode_t ip,
50 struct hammer_ioc_expand *expand)
51{
90ecab35
MN
52 struct hammer_mount *hmp = trans->hmp;
53 struct mount *mp = hmp->mp;
54 int error;
55
56 if (mp->mnt_flag & MNT_RDONLY) {
57 kprintf("Cannot expand read-only HAMMER filesystem\n");
58 return (EINVAL);
59 }
60
61 if (hmp->nvolumes + 1 >= HAMMER_MAX_VOLUMES) {
62 kprintf("Max number of HAMMER volumes exceeded\n");
63 return (EINVAL);
64 }
65
93d839df
MN
66 /*
67 * Find an unused volume number.
68 */
69 int free_vol_no = 0;
70 while (free_vol_no < HAMMER_MAX_VOLUMES &&
71 RB_LOOKUP(hammer_vol_rb_tree, &hmp->rb_vols_root, free_vol_no)) {
72 ++free_vol_no;
73 }
74 if (free_vol_no >= HAMMER_MAX_VOLUMES) {
75 kprintf("Max number of HAMMER volumes exceeded\n");
76 return (EINVAL);
77 }
78
2c794fb2 79 uint64_t num_layer1_entries = 0;
90ecab35
MN
80 error = hammer_format_volume_header(
81 hmp,
2c794fb2 82 expand->device_name,
90ecab35 83 hmp->rootvol->ondisk->vol_name,
93d839df 84 free_vol_no,
90ecab35
MN
85 hmp->nvolumes+1,
86 expand->vol_size,
87 expand->boot_area_size,
2c794fb2
MN
88 expand->mem_area_size,
89 &num_layer1_entries /* out param */);
90 if (error)
91 goto end;
90ecab35 92
2c794fb2
MN
93 error = hammer_install_volume(hmp, expand->device_name, NULL);
94 if (error)
95 goto end;
90ecab35 96
2c794fb2
MN
97 ++hmp->nvolumes;
98 hammer_sync_lock_sh(trans);
99 hammer_lock_ex(&hmp->blkmap_lock);
100
101 /*
102 * Set each volumes new value of the vol_count field.
103 */
104 for (int vol_no = 0; vol_no < HAMMER_MAX_VOLUMES; ++vol_no) {
105 hammer_volume_t volume;
106 volume = hammer_get_volume(hmp, vol_no, &error);
107 if (volume == NULL && error == ENOENT) {
108 /*
109 * Skip unused volume numbers
110 */
111 error = 0;
112 continue;
90ecab35 113 }
2c794fb2
MN
114 KKASSERT(error == 0);
115 hammer_modify_volume_field(trans, volume, vol_count);
116 volume->ondisk->vol_count = hmp->nvolumes;
117 hammer_modify_volume_done(volume);
118 hammer_rel_volume(volume, 0);
119 }
90ecab35 120
2c794fb2
MN
121 /*
122 * Assign Layer1 entries
123 */
124 for (uint64_t i_layer1 = 0; i_layer1 < num_layer1_entries; i_layer1++) {
125 /* XXX */
90ecab35
MN
126 }
127
2c794fb2
MN
128 hammer_unlock(&hmp->blkmap_lock);
129 hammer_sync_unlock(trans);
130
131end:
90ecab35
MN
132 if (error) {
133 kprintf("An error occured: %d\n", error);
134 }
90ecab35
MN
135 return (error);
136}
137
138static int
2c794fb2
MN
139hammer_format_volume_header(struct hammer_mount *hmp, const char *dev_path,
140 const char *vol_name, int vol_no, int vol_count,
141 int64_t vol_size, int64_t boot_area_size, int64_t mem_area_size,
142 uint64_t *num_layer1_entries_p)
90ecab35
MN
143{
144 struct vnode *devvp = NULL;
145 struct buf *bp = NULL;
146 struct nlookupdata nd;
147 struct hammer_volume_ondisk *ondisk;
148 int error;
149
150 /*
151 * Get the device vnode
152 */
2c794fb2 153 error = nlookup_init(&nd, dev_path, UIO_SYSSPACE, NLC_FOLLOW);
90ecab35
MN
154 if (error == 0)
155 error = nlookup(&nd);
156 if (error == 0)
157 error = cache_vref(&nd.nl_nch, nd.nl_cred, &devvp);
158 nlookup_done(&nd);
159
160 if (error == 0) {
161 if (vn_isdisk(devvp, &error)) {
162 error = vfs_mountedon(devvp);
163 }
164 }
165 if (error == 0 &&
166 count_udev(devvp->v_umajor, devvp->v_uminor) > 0) {
167 error = EBUSY;
168 }
169 if (error == 0) {
170 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
171 error = vinvalbuf(devvp, V_SAVE, 0, 0);
172 if (error == 0) {
173 error = VOP_OPEN(devvp, FREAD|FWRITE, FSCRED, NULL);
174 }
175 vn_unlock(devvp);
176 }
177 if (error) {
178 if (devvp)
179 vrele(devvp);
180 return (error);
181 }
182
183 /*
184 * Extract the volume number from the volume header and do various
185 * sanity checks.
186 */
187 KKASSERT(HAMMER_BUFSIZE >= sizeof(struct hammer_volume_ondisk));
188 error = bread(devvp, 0LL, HAMMER_BUFSIZE, &bp);
189 if (error || bp->b_bcount < sizeof(struct hammer_volume_ondisk))
190 goto late_failure;
191
192 ondisk = (struct hammer_volume_ondisk*) bp->b_data;
193
194 /*
195 * Note that we do NOT allow to use a device that contains
196 * a valid HAMMER signature. It has to be cleaned up with dd
197 * before.
198 */
199 if (ondisk->vol_signature == HAMMER_FSBUF_VOLUME) {
200 kprintf("hammer_expand: Formatting of valid HAMMER volume "
201 "%s denied. Erase with dd!\n", vol_name);
202 error = EFTYPE;
203 goto late_failure;
204 }
205
206 bzero(ondisk, sizeof(struct hammer_volume_ondisk));
207 ksnprintf(ondisk->vol_name, sizeof(ondisk->vol_name), "%s", vol_name);
208 ondisk->vol_fstype = hmp->rootvol->ondisk->vol_fstype;
209 ondisk->vol_signature = HAMMER_FSBUF_VOLUME;
210 ondisk->vol_fsid = hmp->fsid;
211 ondisk->vol_rootvol = hmp->rootvol->vol_no;
212 ondisk->vol_no = vol_no;
213 ondisk->vol_count = vol_count;
214 ondisk->vol_version = hmp->version;
215
216 /*
217 * Reserve space for (future) header junk, setup our poor-man's
218 * bigblock allocator.
219 */
220 int64_t vol_alloc = HAMMER_BUFSIZE * 16;
221
222 ondisk->vol_bot_beg = vol_alloc;
223 vol_alloc += boot_area_size;
224 ondisk->vol_mem_beg = vol_alloc;
225 vol_alloc += mem_area_size;
226
227 /*
228 * The remaining area is the zone 2 buffer allocation area. These
229 * buffers
230 */
231 ondisk->vol_buf_beg = vol_alloc;
232 ondisk->vol_buf_end = vol_size & ~(int64_t)HAMMER_BUFMASK;
233
234 if (ondisk->vol_buf_end < ondisk->vol_buf_beg) {
235 kprintf("volume %d %s is too small to hold the volume header",
236 ondisk->vol_no, ondisk->vol_name);
237 error = EFTYPE;
238 goto late_failure;
239 }
240
241 ondisk->vol_nblocks = (ondisk->vol_buf_end - ondisk->vol_buf_beg) /
242 HAMMER_BUFSIZE;
243 ondisk->vol_blocksize = HAMMER_BUFSIZE;
244
245 /*
246 * Write volume header to disk
247 */
248 error = bwrite(bp);
249 bp = NULL;
250
2c794fb2
MN
251 /*
252 * Initialize layer2 freemap
253 */
254
255 /*
256 * Determine the number of L1 entries we need to represent the
257 * space of the whole volume. Each L1 entry covers 4 TB of space
258 * (8MB * 2**19) and we need one L2 big block for each L1 entry.
259 * L1 entries are stored in the root volume.
260 */
261 hammer_off_t off_end = (ondisk->vol_buf_end - ondisk->vol_buf_beg)
262 & ~HAMMER_LARGEBLOCK_MASK64;
263 uint64_t num_layer1_entries = (off_end / HAMMER_BLOCKMAP_LAYER2) +
264 ((off_end & HAMMER_BLOCKMAP_LAYER2_MASK) == 0 ? 0 : 1);
265 *num_layer1_entries_p = num_layer1_entries;
266
267 kprintf("num_layer1_entries: %d\n", num_layer1_entries);
268
269 /*
270 * We allocate all L2 big blocks sequentially from the start of
271 * the volume.
272 */
273 KKASSERT(off_end / HAMMER_LARGEBLOCK_SIZE >= num_layer1_entries);
274
275 hammer_off_t layer2_end = num_layer1_entries * HAMMER_LARGEBLOCK_SIZE;
276 hammer_off_t off = 0;
277 while (off < layer2_end) {
278 error = bread(devvp, ondisk->vol_buf_beg + off,
279 HAMMER_BUFSIZE, &bp);
280 if (error || bp->b_bcount != HAMMER_BUFSIZE)
281 goto late_failure;
282 struct hammer_blockmap_layer2 *layer2 = (void*)bp->b_data;
283
284 for (int i = 0; i < HAMMER_BUFSIZE / sizeof(*layer2); ++i) {
285
286 /* the bigblock described by the layer2 entry */
287 hammer_off_t bigblock_off = HAMMER_LARGEBLOCK_SIZE *
288 (off / sizeof(*layer2));
289
290 bzero(layer2, sizeof(*layer2));
291
292 if ((off & HAMMER_LARGEBLOCK_SIZE) == bigblock_off) {
293 /*
294 * Bigblock is part of the layer2 freemap
295 */
296 layer2->zone = HAMMER_ZONE_FREEMAP_INDEX;
297 layer2->append_off = HAMMER_LARGEBLOCK_SIZE;
298 layer2->bytes_free = 0;
299 } else if (bigblock_off < off_end) {
300 layer2->zone = 0;
301 layer2->append_off = 0;
302 layer2->bytes_free = HAMMER_LARGEBLOCK_SIZE;
303 } else {
304 layer2->zone = HAMMER_ZONE_UNAVAIL_INDEX;
305 layer2->append_off = HAMMER_LARGEBLOCK_SIZE;
306 layer2->bytes_free = 0;
307 }
308 layer2->entry_crc = crc32(layer2, HAMMER_LAYER2_CRCSIZE);
309 off += sizeof(*layer2);
310 ++layer2;
311 }
312
313 error = bwrite(bp);
314 bp = NULL;
315 if (error)
316 goto late_failure;
317 }
318
90ecab35
MN
319late_failure:
320 if (bp)
321 brelse(bp);
322 VOP_CLOSE(devvp, FREAD|FWRITE);
323 if (devvp)
324 vrele(devvp);
325 return (error);
e27700cf 326}