drop owner and parentid
[platform/upstream/btrfs-progs.git] / mkfs.c
1 #define _XOPEN_SOURCE 500
2 #ifndef __CHECKER__
3 #include <sys/ioctl.h>
4 #include <sys/mount.h>
5 #endif
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <sys/types.h>
9 #include <sys/stat.h>
10 #include <fcntl.h>
11 #include <unistd.h>
12 #include <uuid/uuid.h>
13 #include "kerncompat.h"
14 #include "radix-tree.h"
15 #include "ctree.h"
16 #include "disk-io.h"
17 #include "transaction.h"
18
19 #ifdef __CHECKER__
20 #define BLKGETSIZE64 0
21 static inline int ioctl(int fd, int define, u64 *size) { return 0; }
22 #endif
23
24 static int __make_root_dir(struct btrfs_trans_handle *trans,
25                            struct btrfs_root *root)
26 {
27         int ret;
28         char buf[8];
29         u64 objectid;
30         struct btrfs_key inode_map;
31         struct btrfs_inode_item inode_item;
32
33         buf[0] = '.';
34         buf[1] = '.';
35
36         ret = btrfs_find_free_objectid(trans, root, 1, &objectid);
37         if (ret)
38                 goto error;
39
40         inode_map.objectid = objectid;
41         inode_map.flags = 0;
42         btrfs_set_key_type(&inode_map, BTRFS_INODE_ITEM_KEY);
43         inode_map.offset = 0;
44
45         memset(&inode_item, 0, sizeof(inode_item));
46         btrfs_set_inode_generation(&inode_item, root->fs_info->generation);
47         btrfs_set_inode_size(&inode_item, 3);
48         btrfs_set_inode_nlink(&inode_item, 1);
49         btrfs_set_inode_nblocks(&inode_item, 1);
50         btrfs_set_inode_mode(&inode_item, S_IFDIR | 0555);
51
52         if (root->fs_info->tree_root == root)
53                 btrfs_set_super_root_dir(root->fs_info->disk_super, objectid);
54
55         ret = btrfs_insert_inode(trans, root, objectid, &inode_item);
56         if (ret)
57                 goto error;
58         ret = btrfs_insert_dir_item(trans, root, buf, 1, objectid,
59                                     &inode_map, 1);
60         if (ret)
61                 goto error;
62         ret = btrfs_insert_dir_item(trans, root, buf, 2, objectid,
63                                     &inode_map, 1);
64         if (ret)
65                 goto error;
66         btrfs_set_root_dirid(&root->root_item, objectid);
67         ret = 0;
68 error:
69         return ret;
70 }
71
72 static int make_root_dir(int fd) {
73         struct btrfs_root *root;
74         struct btrfs_super_block super;
75         struct btrfs_trans_handle *trans;
76         int ret;
77         struct btrfs_key location;
78
79         root = open_ctree_fd(fd, &super);
80
81         if (!root) {
82                 fprintf(stderr, "ctree init failed\n");
83                 return -1;
84         }
85         trans = btrfs_start_transaction(root, 1);
86         ret = __make_root_dir(trans, root->fs_info->tree_root);
87         if (ret)
88                 goto err;
89         ret = __make_root_dir(trans, root);
90         if (ret)
91                 goto err;
92         memcpy(&location, &root->fs_info->fs_root->root_key, sizeof(location));
93         location.offset = (u64)-1;
94         ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
95                         "default", strlen("default"),
96                         btrfs_super_root_dir(root->fs_info->disk_super),
97                         &location, 1);
98         if (ret)
99                 goto err;
100         btrfs_commit_transaction(trans, root, root->fs_info->disk_super);
101         ret = close_ctree(root, &super);
102 err:
103         return ret;
104 }
105
106 int mkfs(int fd, u64 num_blocks, u32 blocksize)
107 {
108         struct btrfs_super_block super;
109         struct btrfs_leaf *empty_leaf;
110         struct btrfs_root_item root_item;
111         struct btrfs_item item;
112         struct btrfs_extent_item extent_item;
113         struct btrfs_inode_item *inode_item;
114         char *block;
115         int ret;
116         u32 itemoff;
117         u32 start_block = BTRFS_SUPER_INFO_OFFSET / blocksize;
118         btrfs_set_super_generation(&super, 1);
119         btrfs_set_super_blocknr(&super, start_block);
120         btrfs_set_super_root(&super, start_block + 1);
121         strcpy((char *)(&super.magic), BTRFS_MAGIC);
122         btrfs_set_super_blocksize(&super, blocksize);
123         btrfs_set_super_total_blocks(&super, num_blocks);
124         btrfs_set_super_blocks_used(&super, start_block + 4);
125         uuid_generate(super.fsid);
126
127         block = malloc(blocksize);
128         memset(block, 0, blocksize);
129         BUG_ON(sizeof(super) > blocksize);
130         memcpy(block, &super, sizeof(super));
131         ret = pwrite(fd, block, blocksize, BTRFS_SUPER_INFO_OFFSET);
132         BUG_ON(ret != blocksize);
133
134         /* create the tree of root objects */
135         empty_leaf = malloc(blocksize);
136         memset(empty_leaf, 0, blocksize);
137         btrfs_set_header_blocknr(&empty_leaf->header, start_block + 1);
138         btrfs_set_header_nritems(&empty_leaf->header, 2);
139         btrfs_set_header_generation(&empty_leaf->header, 0);
140         memcpy(empty_leaf->header.fsid, super.fsid,
141                sizeof(empty_leaf->header.fsid));
142
143         /* create the items for the root tree */
144         inode_item = &root_item.inode;
145         memset(inode_item, 0, sizeof(*inode_item));
146         btrfs_set_inode_generation(inode_item, 1);
147         btrfs_set_inode_size(inode_item, 3);
148         btrfs_set_inode_nlink(inode_item, 1);
149         btrfs_set_inode_nblocks(inode_item, 1);
150         btrfs_set_inode_mode(inode_item, S_IFDIR | 0755);
151
152         btrfs_set_root_dirid(&root_item, 0);
153         btrfs_set_root_blocknr(&root_item, start_block + 2);
154         btrfs_set_root_refs(&root_item, 1);
155         itemoff = __BTRFS_LEAF_DATA_SIZE(blocksize) - sizeof(root_item);
156         btrfs_set_item_offset(&item, itemoff);
157         btrfs_set_item_size(&item, sizeof(root_item));
158         btrfs_set_disk_key_objectid(&item.key, BTRFS_EXTENT_TREE_OBJECTID);
159         btrfs_set_disk_key_offset(&item.key, 0);
160         btrfs_set_disk_key_flags(&item.key, 0);
161         btrfs_set_disk_key_type(&item.key, BTRFS_ROOT_ITEM_KEY);
162         memcpy(empty_leaf->items, &item, sizeof(item));
163         memcpy(btrfs_leaf_data(empty_leaf) + itemoff,
164                 &root_item, sizeof(root_item));
165
166         btrfs_set_root_blocknr(&root_item, start_block + 3);
167         itemoff = itemoff - sizeof(root_item);
168         btrfs_set_item_offset(&item, itemoff);
169         btrfs_set_disk_key_objectid(&item.key, BTRFS_FS_TREE_OBJECTID);
170         memcpy(empty_leaf->items + 1, &item, sizeof(item));
171         memcpy(btrfs_leaf_data(empty_leaf) + itemoff,
172                 &root_item, sizeof(root_item));
173         ret = pwrite(fd, empty_leaf, blocksize, (start_block + 1) * blocksize);
174
175         /* create the items for the extent tree */
176         btrfs_set_header_blocknr(&empty_leaf->header, start_block + 2);
177         btrfs_set_header_nritems(&empty_leaf->header, 4);
178
179         /* item1, reserve blocks 0-16 */
180         btrfs_set_disk_key_objectid(&item.key, 0);
181         btrfs_set_disk_key_offset(&item.key, start_block + 1);
182         btrfs_set_disk_key_flags(&item.key, 0);
183         btrfs_set_disk_key_type(&item.key, BTRFS_EXTENT_ITEM_KEY);
184         itemoff = __BTRFS_LEAF_DATA_SIZE(blocksize) -
185                         sizeof(struct btrfs_extent_item);
186         btrfs_set_item_offset(&item, itemoff);
187         btrfs_set_item_size(&item, sizeof(struct btrfs_extent_item));
188         btrfs_set_extent_refs(&extent_item, 1);
189         memcpy(empty_leaf->items, &item, sizeof(item));
190         memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
191                 &extent_item, btrfs_item_size(&item));
192
193         /* item2, give block 17 to the root */
194         btrfs_set_disk_key_objectid(&item.key, start_block + 1);
195         btrfs_set_disk_key_offset(&item.key, 1);
196         itemoff = itemoff - sizeof(struct btrfs_extent_item);
197         btrfs_set_item_offset(&item, itemoff);
198         memcpy(empty_leaf->items + 1, &item, sizeof(item));
199         memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
200                 &extent_item, btrfs_item_size(&item));
201
202         /* item3, give block 18 to the extent root */
203         btrfs_set_disk_key_objectid(&item.key, start_block + 2);
204         btrfs_set_disk_key_offset(&item.key, 1);
205         itemoff = itemoff - sizeof(struct btrfs_extent_item);
206         btrfs_set_item_offset(&item, itemoff);
207         memcpy(empty_leaf->items + 2, &item, sizeof(item));
208         memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
209                 &extent_item, btrfs_item_size(&item));
210
211         /* item5, give block 19 to the FS root */
212         btrfs_set_disk_key_objectid(&item.key, start_block + 3);
213         btrfs_set_disk_key_offset(&item.key, 1);
214         itemoff = itemoff - sizeof(struct btrfs_extent_item);
215         btrfs_set_item_offset(&item, itemoff);
216         memcpy(empty_leaf->items + 3, &item, sizeof(item));
217         memcpy(btrfs_leaf_data(empty_leaf) + btrfs_item_offset(&item),
218                 &extent_item, btrfs_item_size(&item));
219         ret = pwrite(fd, empty_leaf, blocksize, (start_block + 2) * blocksize);
220         if (ret != blocksize)
221                 return -1;
222
223         /* finally create the FS root */
224         btrfs_set_header_blocknr(&empty_leaf->header, start_block + 3);
225         btrfs_set_header_nritems(&empty_leaf->header, 0);
226         ret = pwrite(fd, empty_leaf, blocksize, (start_block + 3) * blocksize);
227         if (ret != blocksize)
228                 return -1;
229         return 0;
230 }
231
232 u64 device_size(int fd, struct stat *st)
233 {
234         u64 size;
235         if (S_ISREG(st->st_mode)) {
236                 return st->st_size;
237         }
238         if (!S_ISBLK(st->st_mode)) {
239                 return 0;
240         }
241         if (ioctl(fd, BLKGETSIZE64, &size) >= 0) {
242                 return size;
243         }
244         return 0; }
245
246 int main(int ac, char **av)
247 {
248         char *file;
249         u64 block_count = 0;
250         int fd;
251         struct stat st;
252         int ret;
253         int i;
254         char *buf = malloc(4096);
255
256         radix_tree_init();
257
258         if (ac >= 2) {
259                 file = av[1];
260                 if (ac == 3) {
261                         block_count = atoi(av[2]);
262                         if (!block_count) {
263                                 fprintf(stderr, "error finding block count\n");
264                                 exit(1);
265                         }
266                 }
267         } else {
268                 fprintf(stderr, "usage: mkfs.btrfs file [block count]\n");
269                 exit(1);
270         }
271         fd = open(file, O_RDWR);
272         if (fd < 0) {
273                 fprintf(stderr, "unable to open %s\n", file);
274                 exit(1);
275         }
276         ret = fstat(fd, &st);
277         if (ret < 0) {
278                 fprintf(stderr, "unable to stat %s\n", file);
279                 exit(1);
280         }
281         if (block_count == 0) {
282                 block_count = device_size(fd, &st);
283                 if (block_count == 0) {
284                         fprintf(stderr, "unable to find %s size\n", file);
285                         exit(1);
286                 }
287         }
288         block_count /= 4096;
289         if (block_count < 256) {
290                 fprintf(stderr, "device %s is too small\n", file);
291                 exit(1);
292         }
293         memset(buf, 0, 4096);
294         for(i = 0; i < 16; i++) {
295                 ret = write(fd, buf, 4096);
296                 if (ret != 4096) {
297                         fprintf(stderr, "unable to zero fill device\n");
298                         exit(1);
299                 }
300         }
301         ret = mkfs(fd, block_count, 4096);
302         if (ret) {
303                 fprintf(stderr, "error during mkfs %d\n", ret);
304                 exit(1);
305         }
306         ret = make_root_dir(fd);
307         if (ret) {
308                 fprintf(stderr, "failed to setup the root directory\n");
309                 exit(1);
310         }
311         printf("fs created on %s blocksize %d blocks %Lu\n",
312                file, 4096, block_count);
313         return 0;
314 }
315