?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
btrfs-progs: fix uninit variable in btrfs_scan_kernel
[btrfs-progs-unstable/devel.git] / mkfs.c
blob2dc90c24443ea8e87c980cdd5e0772a434787038
1 /*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
17 */
18
19 #define _XOPEN_SOURCE 500
20 #define _GNU_SOURCE
21
22 #include "kerncompat.h"
23
24 #include <sys/ioctl.h>
25 #include <sys/mount.h>
26 #include "ioctl.h"
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <sys/types.h>
30 #include <sys/stat.h>
31 #include <sys/dir.h>
32 #include <fcntl.h>
33 #include <unistd.h>
34 #include <getopt.h>
35 #include <uuid/uuid.h>
36 #include <ctype.h>
37 #include <sys/xattr.h>
38 #include <blkid/blkid.h>
39 #include <ftw.h>
40 #include "ctree.h"
41 #include "disk-io.h"
42 #include "volumes.h"
43 #include "transaction.h"
44 #include "utils.h"
45 #include "version.h"
46
47 static u64 index_cnt = 2;
48
49 #define DEFAULT_MKFS_FEATURES (BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
50
51 #define DEFAULT_MKFS_LEAF_SIZE 16384
52
53 struct directory_name_entry {
54 char *dir_name;
55 char *path;
56 ino_t inum;
57 struct list_head list;
58 };
59
60 static int make_root_dir(struct btrfs_root *root, int mixed)
61 {
62 struct btrfs_trans_handle *trans;
63 struct btrfs_key location;
64 u64 bytes_used;
65 u64 chunk_start = 0;
66 u64 chunk_size = 0;
67 int ret;
68
69 trans = btrfs_start_transaction(root, 1);
70 bytes_used = btrfs_super_bytes_used(root->fs_info->super_copy);
71
72 root->fs_info->system_allocs = 1;
73 ret = btrfs_make_block_group(trans, root, bytes_used,
74 BTRFS_BLOCK_GROUP_SYSTEM,
75 BTRFS_FIRST_CHUNK_TREE_OBJECTID,
76 0, BTRFS_MKFS_SYSTEM_GROUP_SIZE);
77 BUG_ON(ret);
78
79 if (mixed) {
80 ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root,
81 &chunk_start, &chunk_size,
82 BTRFS_BLOCK_GROUP_METADATA |
83 BTRFS_BLOCK_GROUP_DATA);
84 if (ret == -ENOSPC) {
85 fprintf(stderr,
86 "no space to alloc data/metadata chunk\n");
87 goto err;
88 }
89 BUG_ON(ret);
90 ret = btrfs_make_block_group(trans, root, 0,
91 BTRFS_BLOCK_GROUP_METADATA |
92 BTRFS_BLOCK_GROUP_DATA,
93 BTRFS_FIRST_CHUNK_TREE_OBJECTID,
94 chunk_start, chunk_size);
95 BUG_ON(ret);
96 printf("Created a data/metadata chunk of size %llu\n", chunk_size);
97 } else {
98 ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root,
99 &chunk_start, &chunk_size,
100 BTRFS_BLOCK_GROUP_METADATA);
101 if (ret == -ENOSPC) {
102 fprintf(stderr, "no space to alloc metadata chunk\n");
103 goto err;
104 }
105 BUG_ON(ret);
106 ret = btrfs_make_block_group(trans, root, 0,
107 BTRFS_BLOCK_GROUP_METADATA,
108 BTRFS_FIRST_CHUNK_TREE_OBJECTID,
109 chunk_start, chunk_size);
110 BUG_ON(ret);
111 }
112
113 root->fs_info->system_allocs = 0;
114 btrfs_commit_transaction(trans, root);
115 trans = btrfs_start_transaction(root, 1);
116 BUG_ON(!trans);
117
118 if (!mixed) {
119 ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root,
120 &chunk_start, &chunk_size,
121 BTRFS_BLOCK_GROUP_DATA);
122 if (ret == -ENOSPC) {
123 fprintf(stderr, "no space to alloc data chunk\n");
124 goto err;
125 }
126 BUG_ON(ret);
127 ret = btrfs_make_block_group(trans, root, 0,
128 BTRFS_BLOCK_GROUP_DATA,
129 BTRFS_FIRST_CHUNK_TREE_OBJECTID,
130 chunk_start, chunk_size);
131 BUG_ON(ret);
132 }
133
134 ret = btrfs_make_root_dir(trans, root->fs_info->tree_root,
135 BTRFS_ROOT_TREE_DIR_OBJECTID);
136 if (ret)
137 goto err;
138 ret = btrfs_make_root_dir(trans, root, BTRFS_FIRST_FREE_OBJECTID);
139 if (ret)
140 goto err;
141 memcpy(&location, &root->fs_info->fs_root->root_key, sizeof(location));
142 location.offset = (u64)-1;
143 ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
144 "default", 7,
145 btrfs_super_root_dir(root->fs_info->super_copy),
146 &location, BTRFS_FT_DIR, 0);
147 if (ret)
148 goto err;
149
150 ret = btrfs_insert_inode_ref(trans, root->fs_info->tree_root,
151 "default", 7, location.objectid,
152 BTRFS_ROOT_TREE_DIR_OBJECTID, 0);
153 if (ret)
154 goto err;
155
156 btrfs_commit_transaction(trans, root);
157 err:
158 return ret;
159 }
160
161 static void __recow_root(struct btrfs_trans_handle *trans,
162 struct btrfs_root *root)
163 {
164 int ret;
165 struct extent_buffer *tmp;
166
167 if (trans->transid != btrfs_root_generation(&root->root_item)) {
168 extent_buffer_get(root->node);
169 ret = __btrfs_cow_block(trans, root, root->node,
170 NULL, 0, &tmp, 0, 0);
171 BUG_ON(ret);
172 free_extent_buffer(tmp);
173 }
174 }
175
176 static void recow_roots(struct btrfs_trans_handle *trans,
177 struct btrfs_root *root)
178 {
179 struct btrfs_fs_info *info = root->fs_info;
180
181 __recow_root(trans, info->fs_root);
182 __recow_root(trans, info->tree_root);
183 __recow_root(trans, info->extent_root);
184 __recow_root(trans, info->chunk_root);
185 __recow_root(trans, info->dev_root);
186 __recow_root(trans, info->csum_root);
187 }
188
189 static int create_one_raid_group(struct btrfs_trans_handle *trans,
190 struct btrfs_root *root, u64 type)
191 {
192 u64 chunk_start;
193 u64 chunk_size;
194 int ret;
195
196 ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root,
197 &chunk_start, &chunk_size, type);
198 if (ret == -ENOSPC) {
199 fprintf(stderr, "not enough free space\n");
200 exit(1);
201 }
202 BUG_ON(ret);
203 ret = btrfs_make_block_group(trans, root->fs_info->extent_root, 0,
204 type, BTRFS_FIRST_CHUNK_TREE_OBJECTID,
205 chunk_start, chunk_size);
206 BUG_ON(ret);
207 return ret;
208 }
209
210 static int create_raid_groups(struct btrfs_trans_handle *trans,
211 struct btrfs_root *root, u64 data_profile,
212 int data_profile_opt, u64 metadata_profile,
213 int metadata_profile_opt, int mixed, int ssd)
214 {
215 u64 num_devices = btrfs_super_num_devices(root->fs_info->super_copy);
216 int ret;
217
218 if (metadata_profile) {
219 u64 meta_flags = BTRFS_BLOCK_GROUP_METADATA;
220
221 ret = create_one_raid_group(trans, root,
222 BTRFS_BLOCK_GROUP_SYSTEM |
223 metadata_profile);
224 BUG_ON(ret);
225
226 if (mixed)
227 meta_flags |= BTRFS_BLOCK_GROUP_DATA;
228
229 ret = create_one_raid_group(trans, root, meta_flags |
230 metadata_profile);
231 BUG_ON(ret);
232
233 }
234 if (!mixed && num_devices > 1 && data_profile) {
235 ret = create_one_raid_group(trans, root,
236 BTRFS_BLOCK_GROUP_DATA |
237 data_profile);
238 BUG_ON(ret);
239 }
240 recow_roots(trans, root);
241
242 return 0;
243 }
244
245 static int create_data_reloc_tree(struct btrfs_trans_handle *trans,
246 struct btrfs_root *root)
247 {
248 struct btrfs_key location;
249 struct btrfs_root_item root_item;
250 struct extent_buffer *tmp;
251 u64 objectid = BTRFS_DATA_RELOC_TREE_OBJECTID;
252 int ret;
253
254 ret = btrfs_copy_root(trans, root, root->node, &tmp, objectid);
255 BUG_ON(ret);
256
257 memcpy(&root_item, &root->root_item, sizeof(root_item));
258 btrfs_set_root_bytenr(&root_item, tmp->start);
259 btrfs_set_root_level(&root_item, btrfs_header_level(tmp));
260 btrfs_set_root_generation(&root_item, trans->transid);
261 free_extent_buffer(tmp);
262
263 location.objectid = objectid;
264 location.type = BTRFS_ROOT_ITEM_KEY;
265 location.offset = 0;
266 ret = btrfs_insert_root(trans, root->fs_info->tree_root,
267 &location, &root_item);
268 BUG_ON(ret);
269 return 0;
270 }
271
272
273 static void print_usage(void) __attribute__((noreturn));
274 static void print_usage(void)
275 {
276 fprintf(stderr, "usage: mkfs.btrfs [options] dev [ dev ... ]\n");
277 fprintf(stderr, "options:\n");
278 fprintf(stderr, "\t -A --alloc-start the offset to start the FS\n");
279 fprintf(stderr, "\t -b --byte-count total number of bytes in the FS\n");
280 fprintf(stderr, "\t -d --data data profile, raid0, raid1, raid5, raid6, raid10, dup or single\n");
281 fprintf(stderr, "\t -f --force force overwrite of existing filesystem\n");
282 fprintf(stderr, "\t -l --leafsize size of btree leaves\n");
283 fprintf(stderr, "\t -L --label set a label\n");
284 fprintf(stderr, "\t -m --metadata metadata profile, values like data profile\n");
285 fprintf(stderr, "\t -M --mixed mix metadata and data together\n");
286 fprintf(stderr, "\t -n --nodesize size of btree nodes\n");
287 fprintf(stderr, "\t -s --sectorsize min block allocation (may not mountable by current kernel)\n");
288 fprintf(stderr, "\t -r --rootdir the source directory\n");
289 fprintf(stderr, "\t -K --nodiscard do not perform whole device TRIM\n");
290 fprintf(stderr, "\t -O --features comma separated list of filesystem features\n");
291 fprintf(stderr, "\t -V --version print the mkfs.btrfs version and exit\n");
292 fprintf(stderr, "%s\n", BTRFS_BUILD_VERSION);
293 exit(1);
294 }
295
296 static void print_version(void) __attribute__((noreturn));
297 static void print_version(void)
298 {
299 fprintf(stderr, "mkfs.btrfs, part of %s\n", BTRFS_BUILD_VERSION);
300 exit(0);
301 }
302
303 static u64 parse_profile(char *s)
304 {
305 if (strcmp(s, "raid0") == 0) {
306 return BTRFS_BLOCK_GROUP_RAID0;
307 } else if (strcmp(s, "raid1") == 0) {
308 return BTRFS_BLOCK_GROUP_RAID1;
309 } else if (strcmp(s, "raid5") == 0) {
310 return BTRFS_BLOCK_GROUP_RAID5;
311 } else if (strcmp(s, "raid6") == 0) {
312 return BTRFS_BLOCK_GROUP_RAID6;
313 } else if (strcmp(s, "raid10") == 0) {
314 return BTRFS_BLOCK_GROUP_RAID10;
315 } else if (strcmp(s, "dup") == 0) {
316 return BTRFS_BLOCK_GROUP_DUP;
317 } else if (strcmp(s, "single") == 0) {
318 return 0;
319 } else {
320 fprintf(stderr, "Unknown profile %s\n", s);
321 print_usage();
322 }
323 /* not reached */
324 return 0;
325 }
326
327 static char *parse_label(char *input)
328 {
329 int len = strlen(input);
330
331 if (len >= BTRFS_LABEL_SIZE) {
332 fprintf(stderr, "Label %s is too long (max %d)\n", input,
333 BTRFS_LABEL_SIZE - 1);
334 exit(1);
335 }
336 return strdup(input);
337 }
338
339 static struct option long_options[] = {
340 { "alloc-start", 1, NULL, 'A'},
341 { "byte-count", 1, NULL, 'b' },
342 { "force", 0, NULL, 'f' },
343 { "leafsize", 1, NULL, 'l' },
344 { "label", 1, NULL, 'L'},
345 { "metadata", 1, NULL, 'm' },
346 { "mixed", 0, NULL, 'M' },
347 { "nodesize", 1, NULL, 'n' },
348 { "sectorsize", 1, NULL, 's' },
349 { "data", 1, NULL, 'd' },
350 { "version", 0, NULL, 'V' },
351 { "rootdir", 1, NULL, 'r' },
352 { "nodiscard", 0, NULL, 'K' },
353 { "features", 0, NULL, 'O' },
354 { NULL, 0, NULL, 0}
355 };
356
357 static int add_directory_items(struct btrfs_trans_handle *trans,
358 struct btrfs_root *root, u64 objectid,
359 ino_t parent_inum, const char *name,
360 struct stat *st, int *dir_index_cnt)
361 {
362 int ret;
363 int name_len;
364 struct btrfs_key location;
365 u8 filetype = 0;
366
367 name_len = strlen(name);
368
369 location.objectid = objectid;
370 location.offset = 0;
371 btrfs_set_key_type(&location, BTRFS_INODE_ITEM_KEY);
372
373 if (S_ISDIR(st->st_mode))
374 filetype = BTRFS_FT_DIR;
375 if (S_ISREG(st->st_mode))
376 filetype = BTRFS_FT_REG_FILE;
377 if (S_ISLNK(st->st_mode))
378 filetype = BTRFS_FT_SYMLINK;
379
380 ret = btrfs_insert_dir_item(trans, root, name, name_len,
381 parent_inum, &location,
382 filetype, index_cnt);
383
384 *dir_index_cnt = index_cnt;
385 index_cnt++;
386
387 return ret;
388 }
389
390 static int fill_inode_item(struct btrfs_trans_handle *trans,
391 struct btrfs_root *root,
392 struct btrfs_inode_item *dst, struct stat *src)
393 {
394 u64 blocks = 0;
395 u64 sectorsize = root->sectorsize;
396
397 /*
398 * btrfs_inode_item has some reserved fields
399 * and represents on-disk inode entry, so
400 * zero everything to prevent information leak
401 */
402 memset(dst, 0, sizeof (*dst));
403
404 btrfs_set_stack_inode_generation(dst, trans->transid);
405 btrfs_set_stack_inode_size(dst, src->st_size);
406 btrfs_set_stack_inode_nbytes(dst, 0);
407 btrfs_set_stack_inode_block_group(dst, 0);
408 btrfs_set_stack_inode_nlink(dst, src->st_nlink);
409 btrfs_set_stack_inode_uid(dst, src->st_uid);
410 btrfs_set_stack_inode_gid(dst, src->st_gid);
411 btrfs_set_stack_inode_mode(dst, src->st_mode);
412 btrfs_set_stack_inode_rdev(dst, 0);
413 btrfs_set_stack_inode_flags(dst, 0);
414 btrfs_set_stack_timespec_sec(&dst->atime, src->st_atime);
415 btrfs_set_stack_timespec_nsec(&dst->atime, 0);
416 btrfs_set_stack_timespec_sec(&dst->ctime, src->st_ctime);
417 btrfs_set_stack_timespec_nsec(&dst->ctime, 0);
418 btrfs_set_stack_timespec_sec(&dst->mtime, src->st_mtime);
419 btrfs_set_stack_timespec_nsec(&dst->mtime, 0);
420 btrfs_set_stack_timespec_sec(&dst->otime, 0);
421 btrfs_set_stack_timespec_nsec(&dst->otime, 0);
422
423 if (S_ISDIR(src->st_mode)) {
424 btrfs_set_stack_inode_size(dst, 0);
425 btrfs_set_stack_inode_nlink(dst, 1);
426 }
427 if (S_ISREG(src->st_mode)) {
428 btrfs_set_stack_inode_size(dst, (u64)src->st_size);
429 if (src->st_size <= BTRFS_MAX_INLINE_DATA_SIZE(root))
430 btrfs_set_stack_inode_nbytes(dst, src->st_size);
431 else {
432 blocks = src->st_size / sectorsize;
433 if (src->st_size % sectorsize)
434 blocks += 1;
435 blocks *= sectorsize;
436 btrfs_set_stack_inode_nbytes(dst, blocks);
437 }
438 }
439 if (S_ISLNK(src->st_mode))
440 btrfs_set_stack_inode_nbytes(dst, src->st_size + 1);
441
442 return 0;
443 }
444
445 static int directory_select(const struct direct *entry)
446 {
447 if ((strncmp(entry->d_name, ".", entry->d_reclen) == 0) ||
448 (strncmp(entry->d_name, "..", entry->d_reclen) == 0))
449 return 0;
450 else
451 return 1;
452 }
453
454 static void free_namelist(struct direct **files, int count)
455 {
456 int i;
457
458 if (count < 0)
459 return;
460
461 for (i = 0; i < count; ++i)
462 free(files[i]);
463 free(files);
464 }
465
466 static u64 calculate_dir_inode_size(char *dirname)
467 {
468 int count, i;
469 struct direct **files, *cur_file;
470 u64 dir_inode_size = 0;
471
472 count = scandir(dirname, &files, directory_select, NULL);
473
474 for (i = 0; i < count; i++) {
475 cur_file = files[i];
476 dir_inode_size += strlen(cur_file->d_name);
477 }
478
479 free_namelist(files, count);
480
481 dir_inode_size *= 2;
482 return dir_inode_size;
483 }
484
485 static int add_inode_items(struct btrfs_trans_handle *trans,
486 struct btrfs_root *root,
487 struct stat *st, char *name,
488 u64 self_objectid, ino_t parent_inum,
489 int dir_index_cnt, struct btrfs_inode_item *inode_ret)
490 {
491 int ret;
492 struct btrfs_key inode_key;
493 struct btrfs_inode_item btrfs_inode;
494 u64 objectid;
495 u64 inode_size = 0;
496 int name_len;
497
498 name_len = strlen(name);
499 fill_inode_item(trans, root, &btrfs_inode, st);
500 objectid = self_objectid;
501
502 if (S_ISDIR(st->st_mode)) {
503 inode_size = calculate_dir_inode_size(name);
504 btrfs_set_stack_inode_size(&btrfs_inode, inode_size);
505 }
506
507 inode_key.objectid = objectid;
508 inode_key.offset = 0;
509 btrfs_set_key_type(&inode_key, BTRFS_INODE_ITEM_KEY);
510
511 ret = btrfs_insert_inode(trans, root, objectid, &btrfs_inode);
512 if (ret)
513 goto fail;
514
515 ret = btrfs_insert_inode_ref(trans, root, name, name_len,
516 objectid, parent_inum, dir_index_cnt);
517 if (ret)
518 goto fail;
519
520 *inode_ret = btrfs_inode;
521 fail:
522 return ret;
523 }
524
525 static int add_xattr_item(struct btrfs_trans_handle *trans,
526 struct btrfs_root *root, u64 objectid,
527 const char *file_name)
528 {
529 int ret;
530 int cur_name_len;
531 char xattr_list[XATTR_LIST_MAX];
532 char *cur_name;
533 char cur_value[XATTR_SIZE_MAX];
534 char delimiter = '\0';
535 char *next_location = xattr_list;
536
537 ret = llistxattr(file_name, xattr_list, XATTR_LIST_MAX);
538 if (ret < 0) {
539 if(errno == ENOTSUP)
540 return 0;
541 fprintf(stderr, "get a list of xattr failed for %s\n",
542 file_name);
543 return ret;
544 }
545 if (ret == 0)
546 return ret;
547
548 cur_name = strtok(xattr_list, &delimiter);
549 while (cur_name != NULL) {
550 cur_name_len = strlen(cur_name);
551 next_location += cur_name_len + 1;
552
553 ret = getxattr(file_name, cur_name, cur_value, XATTR_SIZE_MAX);
554 if (ret < 0) {
555 if(errno == ENOTSUP)
556 return 0;
557 fprintf(stderr, "get a xattr value failed for %s attr %s\n",
558 file_name, cur_name);
559 return ret;
560 }
561
562 ret = btrfs_insert_xattr_item(trans, root, cur_name,
563 cur_name_len, cur_value,
564 ret, objectid);
565 if (ret) {
566 fprintf(stderr, "insert a xattr item failed for %s\n",
567 file_name);
568 }
569
570 cur_name = strtok(next_location, &delimiter);
571 }
572
573 return ret;
574 }
575
576 static int add_symbolic_link(struct btrfs_trans_handle *trans,
577 struct btrfs_root *root,
578 u64 objectid, const char *path_name)
579 {
580 int ret;
581 u64 sectorsize = root->sectorsize;
582 char *buf = malloc(sectorsize);
583
584 ret = readlink(path_name, buf, sectorsize);
585 if (ret <= 0) {
586 fprintf(stderr, "readlink failed for %s\n", path_name);
587 goto fail;
588 }
589 if (ret >= sectorsize) {
590 fprintf(stderr, "symlink too long for %s", path_name);
591 ret = -1;
592 goto fail;
593 }
594
595 buf[ret] = '\0'; /* readlink does not do it for us */
596 ret = btrfs_insert_inline_extent(trans, root, objectid, 0,
597 buf, ret + 1);
598 fail:
599 free(buf);
600 return ret;
601 }
602
603 static int add_file_items(struct btrfs_trans_handle *trans,
604 struct btrfs_root *root,
605 struct btrfs_inode_item *btrfs_inode, u64 objectid,
606 ino_t parent_inum, struct stat *st,
607 const char *path_name, int out_fd)
608 {
609 int ret = -1;
610 ssize_t ret_read;
611 u64 bytes_read = 0;
612 struct btrfs_key key;
613 int blocks;
614 u32 sectorsize = root->sectorsize;
615 u64 first_block = 0;
616 u64 file_pos = 0;
617 u64 cur_bytes;
618 u64 total_bytes;
619 struct extent_buffer *eb = NULL;
620 int fd;
621
622 fd = open(path_name, O_RDONLY);
623 if (fd == -1) {
624 fprintf(stderr, "%s open failed\n", path_name);
625 return ret;
626 }
627
628 blocks = st->st_size / sectorsize;
629 if (st->st_size % sectorsize)
630 blocks += 1;
631
632 if (st->st_size <= BTRFS_MAX_INLINE_DATA_SIZE(root)) {
633 char *buffer = malloc(st->st_size);
634 ret_read = pread64(fd, buffer, st->st_size, bytes_read);
635 if (ret_read == -1) {
636 fprintf(stderr, "%s read failed\n", path_name);
637 free(buffer);
638 goto end;
639 }
640
641 ret = btrfs_insert_inline_extent(trans, root, objectid, 0,
642 buffer, st->st_size);
643 free(buffer);
644 goto end;
645 }
646
647 /* round up our st_size to the FS blocksize */
648 total_bytes = (u64)blocks * sectorsize;
649
650 /*
651 * do our IO in extent buffers so it can work
652 * against any raid type
653 */
654 eb = malloc(sizeof(*eb) + sectorsize);
655 if (!eb) {
656 ret = -ENOMEM;
657 goto end;
658 }
659 memset(eb, 0, sizeof(*eb) + sectorsize);
660
661 again:
662
663 /*
664 * keep our extent size at 1MB max, this makes it easier to work inside
665 * the tiny block groups created during mkfs
666 */
667 cur_bytes = min(total_bytes, 1024ULL * 1024);
668 ret = btrfs_reserve_extent(trans, root, cur_bytes, 0, 0, (u64)-1,
669 &key, 1);
670 if (ret)
671 goto end;
672
673 first_block = key.objectid;
674 bytes_read = 0;
675
676 while (bytes_read < cur_bytes) {
677
678 memset(eb->data, 0, sectorsize);
679
680 ret_read = pread64(fd, eb->data, sectorsize, file_pos + bytes_read);
681 if (ret_read == -1) {
682 fprintf(stderr, "%s read failed\n", path_name);
683 goto end;
684 }
685
686 eb->start = first_block + bytes_read;
687 eb->len = sectorsize;
688
689 /*
690 * we're doing the csum before we record the extent, but
691 * that's ok
692 */
693 ret = btrfs_csum_file_block(trans, root->fs_info->csum_root,
694 first_block + bytes_read + sectorsize,
695 first_block + bytes_read,
696 eb->data, sectorsize);
697 if (ret)
698 goto end;
699
700 ret = write_and_map_eb(trans, root, eb);
701 if (ret) {
702 fprintf(stderr, "output file write failed\n");
703 goto end;
704 }
705
706 bytes_read += sectorsize;
707 }
708
709 if (bytes_read) {
710 ret = btrfs_record_file_extent(trans, root, objectid, btrfs_inode,
711 file_pos, first_block, cur_bytes);
712 if (ret)
713 goto end;
714
715 }
716
717 file_pos += cur_bytes;
718 total_bytes -= cur_bytes;
719
720 if (total_bytes)
721 goto again;
722
723 end:
724 free(eb);
725 close(fd);
726 return ret;
727 }
728
729 static char *make_path(char *dir, char *name)
730 {
731 char *path;
732
733 path = malloc(strlen(dir) + strlen(name) + 2);
734 if (!path)
735 return NULL;
736 strcpy(path, dir);
737 if (dir[strlen(dir) - 1] != '/')
738 strcat(path, "/");
739 strcat(path, name);
740 return path;
741 }
742
743 static int traverse_directory(struct btrfs_trans_handle *trans,
744 struct btrfs_root *root, char *dir_name,
745 struct directory_name_entry *dir_head, int out_fd)
746 {
747 int ret = 0;
748
749 struct btrfs_inode_item cur_inode;
750 struct btrfs_inode_item *inode_item;
751 int count, i, dir_index_cnt;
752 struct direct **files;
753 struct stat st;
754 struct directory_name_entry *dir_entry, *parent_dir_entry;
755 struct direct *cur_file;
756 ino_t parent_inum, cur_inum;
757 ino_t highest_inum = 0;
758 char *parent_dir_name;
759 struct btrfs_path path;
760 struct extent_buffer *leaf;
761 struct btrfs_key root_dir_key;
762 u64 root_dir_inode_size = 0;
763
764 /* Add list for source directory */
765 dir_entry = malloc(sizeof(struct directory_name_entry));
766 dir_entry->dir_name = dir_name;
767 dir_entry->path = strdup(dir_name);
768
769 parent_inum = highest_inum + BTRFS_FIRST_FREE_OBJECTID;
770 dir_entry->inum = parent_inum;
771 list_add_tail(&dir_entry->list, &dir_head->list);
772
773 btrfs_init_path(&path);
774
775 root_dir_key.objectid = btrfs_root_dirid(&root->root_item);
776 root_dir_key.offset = 0;
777 btrfs_set_key_type(&root_dir_key, BTRFS_INODE_ITEM_KEY);
778 ret = btrfs_lookup_inode(trans, root, &path, &root_dir_key, 1);
779 if (ret) {
780 fprintf(stderr, "root dir lookup error\n");
781 return -1;
782 }
783
784 leaf = path.nodes[0];
785 inode_item = btrfs_item_ptr(leaf, path.slots[0],
786 struct btrfs_inode_item);
787
788 root_dir_inode_size = calculate_dir_inode_size(dir_name);
789 btrfs_set_inode_size(leaf, inode_item, root_dir_inode_size);
790 btrfs_mark_buffer_dirty(leaf);
791
792 btrfs_release_path(&path);
793
794 do {
795 parent_dir_entry = list_entry(dir_head->list.next,
796 struct directory_name_entry,
797 list);
798 list_del(&parent_dir_entry->list);
799
800 parent_inum = parent_dir_entry->inum;
801 parent_dir_name = parent_dir_entry->dir_name;
802 if (chdir(parent_dir_entry->path)) {
803 fprintf(stderr, "chdir error for %s\n",
804 parent_dir_name);
805 goto fail_no_files;
806 }
807
808 count = scandir(parent_dir_entry->path, &files,
809 directory_select, NULL);
810 if (count == -1)
811 {
812 fprintf(stderr, "scandir for %s failed: %s\n",
813 parent_dir_name, strerror (errno));
814 goto fail;
815 }
816
817 for (i = 0; i < count; i++) {
818 cur_file = files[i];
819
820 if (lstat(cur_file->d_name, &st) == -1) {
821 fprintf(stderr, "lstat failed for file %s\n",
822 cur_file->d_name);
823 goto fail;
824 }
825
826 cur_inum = ++highest_inum + BTRFS_FIRST_FREE_OBJECTID;
827 ret = add_directory_items(trans, root,
828 cur_inum, parent_inum,
829 cur_file->d_name,
830 &st, &dir_index_cnt);
831 if (ret) {
832 fprintf(stderr, "add_directory_items failed\n");
833 goto fail;
834 }
835
836 ret = add_inode_items(trans, root, &st,
837 cur_file->d_name, cur_inum,
838 parent_inum, dir_index_cnt,
839 &cur_inode);
840 if (ret) {
841 fprintf(stderr, "add_inode_items failed\n");
842 goto fail;
843 }
844
845 ret = add_xattr_item(trans, root,
846 cur_inum, cur_file->d_name);
847 if (ret) {
848 fprintf(stderr, "add_xattr_item failed\n");
849 if(ret != -ENOTSUP)
850 goto fail;
851 }
852
853 if (S_ISDIR(st.st_mode)) {
854 dir_entry = malloc(sizeof(struct directory_name_entry));
855 dir_entry->dir_name = cur_file->d_name;
856 dir_entry->path = make_path(parent_dir_entry->path,
857 cur_file->d_name);
858 dir_entry->inum = cur_inum;
859 list_add_tail(&dir_entry->list, &dir_head->list);
860 } else if (S_ISREG(st.st_mode)) {
861 ret = add_file_items(trans, root, &cur_inode,
862 cur_inum, parent_inum, &st,
863 cur_file->d_name, out_fd);
864 if (ret) {
865 fprintf(stderr, "add_file_items failed\n");
866 goto fail;
867 }
868 } else if (S_ISLNK(st.st_mode)) {
869 ret = add_symbolic_link(trans, root,
870 cur_inum, cur_file->d_name);
871 if (ret) {
872 fprintf(stderr, "add_symbolic_link failed\n");
873 goto fail;
874 }
875 }
876 }
877
878 free_namelist(files, count);
879 free(parent_dir_entry->path);
880 free(parent_dir_entry);
881
882 index_cnt = 2;
883
884 } while (!list_empty(&dir_head->list));
885
886 return 0;
887 fail:
888 free_namelist(files, count);
889 fail_no_files:
890 free(parent_dir_entry->path);
891 free(parent_dir_entry);
892 return -1;
893 }
894
895 static int open_target(char *output_name)
896 {
897 int output_fd;
898 output_fd = open(output_name, O_CREAT | O_RDWR | O_TRUNC,
899 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
900
901 return output_fd;
902 }
903
904 static int create_chunks(struct btrfs_trans_handle *trans,
905 struct btrfs_root *root, u64 num_of_meta_chunks,
906 u64 size_of_data)
907 {
908 u64 chunk_start;
909 u64 chunk_size;
910 u64 meta_type = BTRFS_BLOCK_GROUP_METADATA;
911 u64 data_type = BTRFS_BLOCK_GROUP_DATA;
912 u64 minimum_data_chunk_size = 8 * 1024 * 1024;
913 u64 i;
914 int ret;
915
916 for (i = 0; i < num_of_meta_chunks; i++) {
917 ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root,
918 &chunk_start, &chunk_size, meta_type);
919 BUG_ON(ret);
920 ret = btrfs_make_block_group(trans, root->fs_info->extent_root, 0,
921 meta_type, BTRFS_FIRST_CHUNK_TREE_OBJECTID,
922 chunk_start, chunk_size);
923 BUG_ON(ret);
924 set_extent_dirty(&root->fs_info->free_space_cache,
925 chunk_start, chunk_start + chunk_size - 1, 0);
926 }
927
928 if (size_of_data < minimum_data_chunk_size)
929 size_of_data = minimum_data_chunk_size;
930
931 ret = btrfs_alloc_data_chunk(trans, root->fs_info->extent_root,
932 &chunk_start, size_of_data, data_type);
933 BUG_ON(ret);
934 ret = btrfs_make_block_group(trans, root->fs_info->extent_root, 0,
935 data_type, BTRFS_FIRST_CHUNK_TREE_OBJECTID,
936 chunk_start, size_of_data);
937 BUG_ON(ret);
938 set_extent_dirty(&root->fs_info->free_space_cache,
939 chunk_start, chunk_start + size_of_data - 1, 0);
940 return ret;
941 }
942
943 static int make_image(char *source_dir, struct btrfs_root *root, int out_fd)
944 {
945 int ret;
946 struct btrfs_trans_handle *trans;
947
948 struct stat root_st;
949
950 struct directory_name_entry dir_head;
951
952 struct directory_name_entry *dir_entry = NULL;
953
954 ret = lstat(source_dir, &root_st);
955 if (ret) {
956 fprintf(stderr, "unable to lstat the %s\n", source_dir);
957 goto fail;
958 }
959
960 INIT_LIST_HEAD(&dir_head.list);
961
962 trans = btrfs_start_transaction(root, 1);
963 ret = traverse_directory(trans, root, source_dir, &dir_head, out_fd);
964 if (ret) {
965 fprintf(stderr, "unable to traverse_directory\n");
966 goto fail;
967 }
968 btrfs_commit_transaction(trans, root);
969
970 printf("Making image is completed.\n");
971 return 0;
972 fail:
973 while (!list_empty(&dir_head.list)) {
974 dir_entry = list_entry(dir_head.list.next,
975 struct directory_name_entry, list);
976 list_del(&dir_entry->list);
977 free(dir_entry);
978 }
979 fprintf(stderr, "Making image is aborted.\n");
980 return -1;
981 }
982
983 /*
984 * This ignores symlinks with unreadable targets and subdirs that can't
985 * be read. It's a best-effort to give a rough estimate of the size of
986 * a subdir. It doesn't guarantee that prepopulating btrfs from this
987 * tree won't still run out of space.
988 *
989 * The rounding up to 4096 is questionable. Previous code used du -B 4096.
990 */
991 static u64 global_total_size;
992 static int ftw_add_entry_size(const char *fpath, const struct stat *st,
993 int type)
994 {
995 if (type == FTW_F || type == FTW_D)
996 global_total_size += round_up(st->st_size, 4096);
997
998 return 0;
999 }
1000
1001 static u64 size_sourcedir(char *dir_name, u64 sectorsize,
1002 u64 *num_of_meta_chunks_ret, u64 *size_of_data_ret)
1003 {
1004 u64 dir_size = 0;
1005 u64 total_size = 0;
1006 int ret;
1007 u64 default_chunk_size = 8 * 1024 * 1024; /* 8MB */
1008 u64 allocated_meta_size = 8 * 1024 * 1024; /* 8MB */
1009 u64 allocated_total_size = 20 * 1024 * 1024; /* 20MB */
1010 u64 num_of_meta_chunks = 0;
1011 u64 num_of_data_chunks = 0;
1012 u64 num_of_allocated_meta_chunks =
1013 allocated_meta_size / default_chunk_size;
1014
1015 global_total_size = 0;
1016 ret = ftw(dir_name, ftw_add_entry_size, 10);
1017 dir_size = global_total_size;
1018 if (ret < 0) {
1019 fprintf(stderr, "ftw subdir walk of '%s' failed: %s\n",
1020 dir_name, strerror(errno));
1021 exit(1);
1022 }
1023
1024 num_of_data_chunks = (dir_size + default_chunk_size - 1) /
1025 default_chunk_size;
1026
1027 num_of_meta_chunks = (dir_size / 2) / default_chunk_size;
1028 if (((dir_size / 2) % default_chunk_size) != 0)
1029 num_of_meta_chunks++;
1030 if (num_of_meta_chunks <= num_of_allocated_meta_chunks)
1031 num_of_meta_chunks = 0;
1032 else
1033 num_of_meta_chunks -= num_of_allocated_meta_chunks;
1034
1035 total_size = allocated_total_size +
1036 (num_of_data_chunks * default_chunk_size) +
1037 (num_of_meta_chunks * default_chunk_size);
1038
1039 *num_of_meta_chunks_ret = num_of_meta_chunks;
1040 *size_of_data_ret = num_of_data_chunks * default_chunk_size;
1041 return total_size;
1042 }
1043
1044 static int zero_output_file(int out_fd, u64 size, u32 sectorsize)
1045 {
1046 int len = sectorsize;
1047 int loop_num = size / sectorsize;
1048 u64 location = 0;
1049 char *buf = malloc(len);
1050 int ret = 0, i;
1051 ssize_t written;
1052
1053 if (!buf)
1054 return -ENOMEM;
1055 memset(buf, 0, len);
1056 for (i = 0; i < loop_num; i++) {
1057 written = pwrite64(out_fd, buf, len, location);
1058 if (written != len)
1059 ret = -EIO;
1060 location += sectorsize;
1061 }
1062 free(buf);
1063 return ret;
1064 }
1065
1066 static int check_leaf_or_node_size(u32 size, u32 sectorsize)
1067 {
1068 if (size < sectorsize) {
1069 fprintf(stderr,
1070 "Illegal leafsize (or nodesize) %u (smaller than %u)\n",
1071 size, sectorsize);
1072 return -1;
1073 } else if (size > BTRFS_MAX_METADATA_BLOCKSIZE) {
1074 fprintf(stderr,
1075 "Illegal leafsize (or nodesize) %u (larger than %u)\n",
1076 size, BTRFS_MAX_METADATA_BLOCKSIZE);
1077 return -1;
1078 } else if (size & (sectorsize - 1)) {
1079 fprintf(stderr,
1080 "Illegal leafsize (or nodesize) %u (not align to %u)\n",
1081 size, sectorsize);
1082 return -1;
1083 }
1084 return 0;
1085 }
1086
1087 static int is_ssd(const char *file)
1088 {
1089 blkid_probe probe;
1090 char wholedisk[32];
1091 char sysfs_path[PATH_MAX];
1092 dev_t devno;
1093 int fd;
1094 char rotational;
1095 int ret;
1096
1097 probe = blkid_new_probe_from_filename(file);
1098 if (!probe)
1099 return 0;
1100
1101 /* Device number of this disk (possibly a partition) */
1102 devno = blkid_probe_get_devno(probe);
1103 if (!devno) {
1104 blkid_free_probe(probe);
1105 return 0;
1106 }
1107
1108 /* Get whole disk name (not full path) for this devno */
1109 ret = blkid_devno_to_wholedisk(devno,
1110 wholedisk, sizeof(wholedisk), NULL);
1111 if (ret) {
1112 blkid_free_probe(probe);
1113 return 0;
1114 }
1115
1116 snprintf(sysfs_path, PATH_MAX, "/sys/block/%s/queue/rotational",
1117 wholedisk);
1118
1119 blkid_free_probe(probe);
1120
1121 fd = open(sysfs_path, O_RDONLY);
1122 if (fd < 0) {
1123 return 0;
1124 }
1125
1126 if (read(fd, &rotational, sizeof(char)) < sizeof(char)) {
1127 close(fd);
1128 return 0;
1129 }
1130 close(fd);
1131
1132 return !atoi((const char *)&rotational);
1133 }
1134
1135 #define BTRFS_FEATURE_LIST_ALL (1ULL << 63)
1136
1137 static const struct btrfs_fs_feature {
1138 const char *name;
1139 u64 flag;
1140 const char *desc;
1141 } mkfs_features[] = {
1142 { "mixed-bg", BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS,
1143 "mixed data and metadata block groups" },
1144 { "extref", BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF,
1145 "increased hardlink limit per file to 65536" },
1146 { "raid56", BTRFS_FEATURE_INCOMPAT_RAID56,
1147 "raid56 extended format" },
1148 { "skinny-metadata", BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA,
1149 "reduced-size metadata extent refs" },
1150 { "no-holes", BTRFS_FEATURE_INCOMPAT_NO_HOLES,
1151 "no explicit hole extents for files" },
1152 /* Keep this one last */
1153 { "list-all", BTRFS_FEATURE_LIST_ALL, NULL }
1154 };
1155
1156 static void list_all_fs_features(void)
1157 {
1158 int i;
1159
1160 fprintf(stderr, "Filesystem features available at mkfs time:\n");
1161 for (i = 0; i < ARRAY_SIZE(mkfs_features) - 1; i++) {
1162 char *is_default = "";
1163
1164 if (mkfs_features[i].flag & DEFAULT_MKFS_FEATURES)
1165 is_default = ", default";
1166 fprintf(stderr, "%-20s- %s (0x%llx%s)\n",
1167 mkfs_features[i].name,
1168 mkfs_features[i].desc,
1169 mkfs_features[i].flag,
1170 is_default);
1171 }
1172 }
1173
1174 static int parse_one_fs_feature(const char *name, u64 *flags)
1175 {
1176 int i;
1177 int found = 0;
1178
1179 for (i = 0; i < ARRAY_SIZE(mkfs_features); i++) {
1180 if (name[0] == '^' &&
1181 !strcmp(mkfs_features[i].name, name + 1)) {
1182 *flags &= ~ mkfs_features[i].flag;
1183 found = 1;
1184 } else if (!strcmp(mkfs_features[i].name, name)) {
1185 *flags |= mkfs_features[i].flag;
1186 found = 1;
1187 }
1188 }
1189
1190 return !found;
1191 }
1192
1193 static void process_fs_features(u64 flags)
1194 {
1195 int i;
1196
1197 for (i = 0; i < ARRAY_SIZE(mkfs_features); i++) {
1198 if (flags & mkfs_features[i].flag) {
1199 printf("Turning ON incompat feature '%s': %s\n",
1200 mkfs_features[i].name,
1201 mkfs_features[i].desc);
1202 }
1203 }
1204 }
1205
1206
1207 /*
1208 * Return NULL if all features were parsed fine, otherwise return the name of
1209 * the first unparsed.
1210 */
1211 static char* parse_fs_features(char *namelist, u64 *flags)
1212 {
1213 char *this_char;
1214 char *save_ptr = NULL; /* Satisfy static checkers */
1215
1216 for (this_char = strtok_r(namelist, ",", &save_ptr);
1217 this_char != NULL;
1218 this_char = strtok_r(NULL, ",", &save_ptr)) {
1219 if (parse_one_fs_feature(this_char, flags))
1220 return this_char;
1221 }
1222
1223 return NULL;
1224 }
1225
1226 int main(int ac, char **av)
1227 {
1228 char *file;
1229 struct btrfs_root *root;
1230 struct btrfs_trans_handle *trans;
1231 char *label = NULL;
1232 char *first_file;
1233 u64 block_count = 0;
1234 u64 dev_block_count = 0;
1235 u64 blocks[7];
1236 u64 alloc_start = 0;
1237 u64 metadata_profile = 0;
1238 u64 data_profile = 0;
1239 u32 leafsize = max_t(u32, sysconf(_SC_PAGESIZE), DEFAULT_MKFS_LEAF_SIZE);
1240 u32 sectorsize = 4096;
1241 u32 nodesize = leafsize;
1242 u32 stripesize = 4096;
1243 int zero_end = 1;
1244 int option_index = 0;
1245 int fd;
1246 int ret;
1247 int i;
1248 int mixed = 0;
1249 int leaf_forced = 0;
1250 int data_profile_opt = 0;
1251 int metadata_profile_opt = 0;
1252 int discard = 1;
1253 int ssd = 0;
1254 int force_overwrite = 0;
1255
1256 char *source_dir = NULL;
1257 int source_dir_set = 0;
1258 u64 num_of_meta_chunks = 0;
1259 u64 size_of_data = 0;
1260 u64 source_dir_size = 0;
1261 int dev_cnt = 0;
1262 int saved_optind;
1263 char estr[100];
1264 u64 features = DEFAULT_MKFS_FEATURES;
1265
1266 while(1) {
1267 int c;
1268 c = getopt_long(ac, av, "A:b:fl:n:s:m:d:L:O:r:VMK",
1269 long_options, &option_index);
1270 if (c < 0)
1271 break;
1272 switch(c) {
1273 case 'A':
1274 alloc_start = parse_size(optarg);
1275 break;
1276 case 'f':
1277 force_overwrite = 1;
1278 break;
1279 case 'd':
1280 data_profile = parse_profile(optarg);
1281 data_profile_opt = 1;
1282 break;
1283 case 'l':
1284 case 'n':
1285 nodesize = parse_size(optarg);
1286 leafsize = parse_size(optarg);
1287 leaf_forced = 1;
1288 break;
1289 case 'L':
1290 label = parse_label(optarg);
1291 break;
1292 case 'm':
1293 metadata_profile = parse_profile(optarg);
1294 metadata_profile_opt = 1;
1295 break;
1296 case 'M':
1297 mixed = 1;
1298 break;
1299 case 'O': {
1300 char *orig = strdup(optarg);
1301 char *tmp = orig;
1302
1303 tmp = parse_fs_features(tmp, &features);
1304 if (tmp) {
1305 fprintf(stderr,
1306 "Unrecognized filesystem feature '%s'\n",
1307 tmp);
1308 free(orig);
1309 exit(1);
1310 }
1311 free(orig);
1312 if (features & BTRFS_FEATURE_LIST_ALL) {
1313 list_all_fs_features();
1314 exit(0);
1315 }
1316 break;
1317 }
1318 case 's':
1319 sectorsize = parse_size(optarg);
1320 break;
1321 case 'b':
1322 block_count = parse_size(optarg);
1323 if (block_count <= 1024*1024*1024) {
1324 printf("SMALL VOLUME: forcing mixed "
1325 "metadata/data groups\n");
1326 mixed = 1;
1327 }
1328 zero_end = 0;
1329 break;
1330 case 'V':
1331 print_version();
1332 break;
1333 case 'r':
1334 source_dir = optarg;
1335 source_dir_set = 1;
1336 break;
1337 case 'K':
1338 discard = 0;
1339 break;
1340 default:
1341 print_usage();
1342 }
1343 }
1344 sectorsize = max(sectorsize, (u32)sysconf(_SC_PAGESIZE));
1345 if (check_leaf_or_node_size(leafsize, sectorsize))
1346 exit(1);
1347 if (check_leaf_or_node_size(nodesize, sectorsize))
1348 exit(1);
1349 saved_optind = optind;
1350 dev_cnt = ac - optind;
1351 if (dev_cnt == 0)
1352 print_usage();
1353
1354 if (source_dir_set && dev_cnt > 1) {
1355 fprintf(stderr,
1356 "The -r option is limited to a single device\n");
1357 exit(1);
1358 }
1359 while (dev_cnt-- > 0) {
1360 file = av[optind++];
1361 if (is_block_device(file))
1362 if (test_dev_for_mkfs(file, force_overwrite, estr)) {
1363 fprintf(stderr, "Error: %s", estr);
1364 exit(1);
1365 }
1366 }
1367
1368 optind = saved_optind;
1369 dev_cnt = ac - optind;
1370
1371 file = av[optind++];
1372 ssd = is_ssd(file);
1373
1374 if (is_vol_small(file)) {
1375 printf("SMALL VOLUME: forcing mixed metadata/data groups\n");
1376 mixed = 1;
1377 }
1378
1379 /*
1380 * Set default profiles according to number of added devices.
1381 * For mixed groups defaults are single/single.
1382 */
1383 if (!mixed) {
1384 if (!metadata_profile_opt) {
1385 if (dev_cnt == 1 && ssd)
1386 printf("Detected a SSD, turning off metadata "
1387 "duplication. Mkfs with -m dup if you want to "
1388 "force metadata duplication.\n");
1389
1390 metadata_profile = (dev_cnt > 1) ?
1391 BTRFS_BLOCK_GROUP_RAID1 : (ssd) ?
1392 0: BTRFS_BLOCK_GROUP_DUP;
1393 }
1394 if (!data_profile_opt) {
1395 data_profile = (dev_cnt > 1) ?
1396 BTRFS_BLOCK_GROUP_RAID0 : 0; /* raid0 or single */
1397 }
1398 } else {
1399 u32 best_leafsize = max_t(u32, sysconf(_SC_PAGESIZE), sectorsize);
1400
1401 if (metadata_profile_opt || data_profile_opt) {
1402 if (metadata_profile != data_profile) {
1403 fprintf(stderr,
1404 "ERROR: With mixed block groups data and metadata profiles must be the same\n");
1405 exit(1);
1406 }
1407 }
1408
1409 if (!leaf_forced) {
1410 leafsize = best_leafsize;
1411 nodesize = best_leafsize;
1412 if (check_leaf_or_node_size(leafsize, sectorsize))
1413 exit(1);
1414 }
1415 if (leafsize != sectorsize) {
1416 fprintf(stderr, "Error: mixed metadata/data block groups "
1417 "require metadata blocksizes equal to the sectorsize\n");
1418 exit(1);
1419 }
1420 }
1421
1422 ret = test_num_disk_vs_raid(metadata_profile, data_profile,
1423 dev_cnt, mixed, estr);
1424 if (ret) {
1425 fprintf(stderr, "Error: %s\n", estr);
1426 exit(1);
1427 }
1428
1429 /* if we are here that means all devs are good to btrfsify */
1430 printf("\nWARNING! - %s IS EXPERIMENTAL\n", BTRFS_BUILD_VERSION);
1431 printf("WARNING! - see http://btrfs.wiki.kernel.org before using\n\n");
1432
1433 dev_cnt--;
1434
1435 if (!source_dir_set) {
1436 /*
1437 * open without O_EXCL so that the problem should not
1438 * occur by the following processing.
1439 * (btrfs_register_one_device() fails if O_EXCL is on)
1440 */
1441 fd = open(file, O_RDWR);
1442 if (fd < 0) {
1443 fprintf(stderr, "unable to open %s: %s\n", file,
1444 strerror(errno));
1445 exit(1);
1446 }
1447 first_file = file;
1448 ret = btrfs_prepare_device(fd, file, zero_end, &dev_block_count,
1449 block_count, &mixed, discard);
1450 if (ret) {
1451 close(fd);
1452 exit(1);
1453 }
1454 if (block_count && block_count > dev_block_count) {
1455 fprintf(stderr, "%s is smaller than requested size\n", file);
1456 exit(1);
1457 }
1458 } else {
1459 fd = open_target(file);
1460 if (fd < 0) {
1461 fprintf(stderr, "unable to open the %s\n", file);
1462 exit(1);
1463 }
1464
1465 first_file = file;
1466 source_dir_size = size_sourcedir(source_dir, sectorsize,
1467 &num_of_meta_chunks, &size_of_data);
1468 if(block_count < source_dir_size)
1469 block_count = source_dir_size;
1470 ret = zero_output_file(fd, block_count, sectorsize);
1471 if (ret) {
1472 fprintf(stderr, "unable to zero the output file\n");
1473 exit(1);
1474 }
1475 /* our "device" is the new image file */
1476 dev_block_count = block_count;
1477 }
1478
1479 /* To create the first block group and chunk 0 in make_btrfs */
1480 if (dev_block_count < BTRFS_MKFS_SYSTEM_GROUP_SIZE) {
1481 fprintf(stderr, "device is too small to make filesystem\n");
1482 exit(1);
1483 }
1484
1485 blocks[0] = BTRFS_SUPER_INFO_OFFSET;
1486 for (i = 1; i < 7; i++) {
1487 blocks[i] = BTRFS_SUPER_INFO_OFFSET + 1024 * 1024 +
1488 leafsize * i;
1489 }
1490
1491 /*
1492 * FS features that can be set by other means than -O
1493 * just set the bit here
1494 */
1495 if (mixed)
1496 features |= BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS;
1497
1498 if ((data_profile | metadata_profile) &
1499 (BTRFS_BLOCK_GROUP_RAID5 | BTRFS_BLOCK_GROUP_RAID6)) {
1500 features |= BTRFS_FEATURE_INCOMPAT_RAID56;
1501 }
1502
1503 process_fs_features(features);
1504
1505 ret = make_btrfs(fd, file, label, blocks, dev_block_count,
1506 nodesize, leafsize,
1507 sectorsize, stripesize, features);
1508 if (ret) {
1509 fprintf(stderr, "error during mkfs: %s\n", strerror(-ret));
1510 exit(1);
1511 }
1512
1513 root = open_ctree(file, 0, OPEN_CTREE_WRITES);
1514 if (!root) {
1515 fprintf(stderr, "Open ctree failed\n");
1516 close(fd);
1517 exit(1);
1518 }
1519 root->fs_info->alloc_start = alloc_start;
1520
1521 ret = make_root_dir(root, mixed);
1522 if (ret) {
1523 fprintf(stderr, "failed to setup the root directory\n");
1524 exit(1);
1525 }
1526
1527 trans = btrfs_start_transaction(root, 1);
1528
1529 if (dev_cnt == 0)
1530 goto raid_groups;
1531
1532 btrfs_register_one_device(file);
1533
1534 zero_end = 1;
1535 while (dev_cnt-- > 0) {
1536 int old_mixed = mixed;
1537
1538 file = av[optind++];
1539
1540 /*
1541 * open without O_EXCL so that the problem should not
1542 * occur by the following processing.
1543 * (btrfs_register_one_device() fails if O_EXCL is on)
1544 */
1545 fd = open(file, O_RDWR);
1546 if (fd < 0) {
1547 fprintf(stderr, "unable to open %s: %s\n", file,
1548 strerror(errno));
1549 exit(1);
1550 }
1551 ret = btrfs_device_already_in_root(root, fd,
1552 BTRFS_SUPER_INFO_OFFSET);
1553 if (ret) {
1554 fprintf(stderr, "skipping duplicate device %s in FS\n",
1555 file);
1556 close(fd);
1557 continue;
1558 }
1559 ret = btrfs_prepare_device(fd, file, zero_end, &dev_block_count,
1560 block_count, &mixed, discard);
1561 if (ret) {
1562 close(fd);
1563 exit(1);
1564 }
1565 mixed = old_mixed;
1566
1567 ret = btrfs_add_to_fsid(trans, root, fd, file, dev_block_count,
1568 sectorsize, sectorsize, sectorsize);
1569 BUG_ON(ret);
1570 btrfs_register_one_device(file);
1571 }
1572
1573 raid_groups:
1574 if (!source_dir_set) {
1575 ret = create_raid_groups(trans, root, data_profile,
1576 data_profile_opt, metadata_profile,
1577 metadata_profile_opt, mixed, ssd);
1578 BUG_ON(ret);
1579 }
1580
1581 ret = create_data_reloc_tree(trans, root);
1582 BUG_ON(ret);
1583
1584 printf("fs created label %s on %s\n\tnodesize %u leafsize %u "
1585 "sectorsize %u size %s\n",
1586 label, first_file, nodesize, leafsize, sectorsize,
1587 pretty_size(btrfs_super_total_bytes(root->fs_info->super_copy)));
1588
1589 printf("%s\n", BTRFS_BUILD_VERSION);
1590 btrfs_commit_transaction(trans, root);
1591
1592 if (source_dir_set) {
1593 trans = btrfs_start_transaction(root, 1);
1594 ret = create_chunks(trans, root,
1595 num_of_meta_chunks, size_of_data);
1596 BUG_ON(ret);
1597 btrfs_commit_transaction(trans, root);
1598
1599 ret = make_image(source_dir, root, fd);
1600 BUG_ON(ret);
1601 }
1602
1603 ret = close_ctree(root);
1604 BUG_ON(ret);
1605 free(label);
1606 return 0;
1607 }
(deprecated) Btrfs progs developments and patch integration