1 #define _XOPEN_SOURCE 500
12 #include <uuid/uuid.h>
13 #include "kerncompat.h"
14 #include "radix-tree.h"
17 #include "transaction.h"
20 #define BLKGETSIZE64 0
21 static inline int ioctl(int fd
, int define
, u64
*size
) { return 0; }
24 static int __make_root_dir(struct btrfs_trans_handle
*trans
,
25 struct btrfs_root
*root
)
30 struct btrfs_key inode_map
;
31 struct btrfs_inode_item inode_item
;
36 ret
= btrfs_find_free_objectid(trans
, root
, 1, &objectid
);
40 inode_map
.objectid
= objectid
;
42 btrfs_set_key_type(&inode_map
, BTRFS_INODE_ITEM_KEY
);
45 ret
= btrfs_insert_inode_map(trans
, root
, objectid
, &inode_map
);
49 memset(&inode_item
, 0, sizeof(inode_item
));
50 btrfs_set_inode_generation(&inode_item
, root
->fs_info
->generation
);
51 btrfs_set_inode_size(&inode_item
, 3);
52 btrfs_set_inode_nlink(&inode_item
, 1);
53 btrfs_set_inode_nblocks(&inode_item
, 1);
54 btrfs_set_inode_mode(&inode_item
, S_IFDIR
| 0555);
56 if (root
->fs_info
->tree_root
== root
)
57 btrfs_set_super_root_dir(root
->fs_info
->disk_super
, objectid
);
59 ret
= btrfs_insert_inode(trans
, root
, objectid
, &inode_item
);
62 ret
= btrfs_insert_dir_item(trans
, root
, buf
, 1, objectid
,
66 ret
= btrfs_insert_dir_item(trans
, root
, buf
, 2, objectid
,
70 btrfs_set_root_dirid(&root
->root_item
, objectid
);
76 static int make_root_dir(int fd
) {
77 struct btrfs_root
*root
;
78 struct btrfs_super_block super
;
79 struct btrfs_trans_handle
*trans
;
81 struct btrfs_key location
;
83 root
= open_ctree_fd(fd
, &super
);
86 fprintf(stderr
, "ctree init failed\n");
89 trans
= btrfs_start_transaction(root
, 1);
90 ret
= __make_root_dir(trans
, root
->fs_info
->tree_root
);
93 ret
= __make_root_dir(trans
, root
);
96 memcpy(&location
, &root
->fs_info
->fs_root
->root_key
, sizeof(location
));
97 location
.offset
= (u64
)-1;
98 ret
= btrfs_insert_dir_item(trans
, root
->fs_info
->tree_root
,
99 "default", strlen("default"),
100 btrfs_super_root_dir(root
->fs_info
->disk_super
),
104 btrfs_commit_transaction(trans
, root
, root
->fs_info
->disk_super
);
105 ret
= close_ctree(root
, &super
);
110 int mkfs(int fd
, u64 num_blocks
, u32 blocksize
)
112 struct btrfs_super_block super
;
113 struct btrfs_leaf
*empty_leaf
;
114 struct btrfs_root_item root_item
;
115 struct btrfs_item item
;
116 struct btrfs_extent_item extent_item
;
117 struct btrfs_inode_item
*inode_item
;
121 u32 start_block
= BTRFS_SUPER_INFO_OFFSET
/ blocksize
;
123 btrfs_set_super_blocknr(&super
, start_block
);
124 btrfs_set_super_root(&super
, start_block
+ 1);
125 strcpy((char *)(&super
.magic
), BTRFS_MAGIC
);
126 btrfs_set_super_blocksize(&super
, blocksize
);
127 btrfs_set_super_total_blocks(&super
, num_blocks
);
128 btrfs_set_super_blocks_used(&super
, start_block
+ 5);
129 uuid_generate(super
.fsid
);
131 block
= malloc(blocksize
);
132 memset(block
, 0, blocksize
);
133 BUG_ON(sizeof(super
) > blocksize
);
134 memcpy(block
, &super
, sizeof(super
));
135 ret
= pwrite(fd
, block
, blocksize
, BTRFS_SUPER_INFO_OFFSET
);
136 BUG_ON(ret
!= blocksize
);
138 /* create the tree of root objects */
139 empty_leaf
= malloc(blocksize
);
140 memset(empty_leaf
, 0, blocksize
);
141 btrfs_set_header_parentid(&empty_leaf
->header
,
142 BTRFS_ROOT_TREE_OBJECTID
);
143 btrfs_set_header_blocknr(&empty_leaf
->header
, start_block
+ 1);
144 btrfs_set_header_nritems(&empty_leaf
->header
, 3);
145 btrfs_set_header_generation(&empty_leaf
->header
, 0);
146 memcpy(empty_leaf
->header
.fsid
, super
.fsid
,
147 sizeof(empty_leaf
->header
.fsid
));
149 /* create the items for the root tree */
150 inode_item
= &root_item
.inode
;
151 memset(inode_item
, 0, sizeof(*inode_item
));
152 btrfs_set_inode_generation(inode_item
, 1);
153 btrfs_set_inode_size(inode_item
, 3);
154 btrfs_set_inode_nlink(inode_item
, 1);
155 btrfs_set_inode_nblocks(inode_item
, 1);
156 btrfs_set_inode_mode(inode_item
, S_IFDIR
| 0755);
158 btrfs_set_root_dirid(&root_item
, 0);
159 btrfs_set_root_blocknr(&root_item
, start_block
+ 2);
160 btrfs_set_root_refs(&root_item
, 1);
161 itemoff
= __BTRFS_LEAF_DATA_SIZE(blocksize
) - sizeof(root_item
);
162 btrfs_set_item_offset(&item
, itemoff
);
163 btrfs_set_item_size(&item
, sizeof(root_item
));
164 btrfs_set_disk_key_objectid(&item
.key
, BTRFS_EXTENT_TREE_OBJECTID
);
165 btrfs_set_disk_key_offset(&item
.key
, 0);
166 btrfs_set_disk_key_flags(&item
.key
, 0);
167 btrfs_set_disk_key_type(&item
.key
, BTRFS_ROOT_ITEM_KEY
);
168 memcpy(empty_leaf
->items
, &item
, sizeof(item
));
169 memcpy(btrfs_leaf_data(empty_leaf
) + itemoff
,
170 &root_item
, sizeof(root_item
));
172 btrfs_set_root_blocknr(&root_item
, start_block
+ 3);
173 itemoff
= itemoff
- sizeof(root_item
);
174 btrfs_set_item_offset(&item
, itemoff
);
175 btrfs_set_disk_key_objectid(&item
.key
, BTRFS_INODE_MAP_OBJECTID
);
176 memcpy(empty_leaf
->items
+ 1, &item
, sizeof(item
));
177 memcpy(btrfs_leaf_data(empty_leaf
) + itemoff
,
178 &root_item
, sizeof(root_item
));
180 btrfs_set_root_blocknr(&root_item
, start_block
+ 4);
181 itemoff
= itemoff
- sizeof(root_item
);
182 btrfs_set_item_offset(&item
, itemoff
);
183 btrfs_set_disk_key_objectid(&item
.key
, BTRFS_FS_TREE_OBJECTID
);
184 memcpy(empty_leaf
->items
+ 2, &item
, sizeof(item
));
185 memcpy(btrfs_leaf_data(empty_leaf
) + itemoff
,
186 &root_item
, sizeof(root_item
));
187 ret
= pwrite(fd
, empty_leaf
, blocksize
, (start_block
+ 1) * blocksize
);
189 /* create the items for the extent tree */
190 btrfs_set_header_parentid(&empty_leaf
->header
,
191 BTRFS_EXTENT_TREE_OBJECTID
);
192 btrfs_set_header_blocknr(&empty_leaf
->header
, start_block
+ 2);
193 btrfs_set_header_nritems(&empty_leaf
->header
, 5);
195 /* item1, reserve blocks 0-16 */
196 btrfs_set_disk_key_objectid(&item
.key
, 0);
197 btrfs_set_disk_key_offset(&item
.key
, start_block
+ 1);
198 btrfs_set_disk_key_flags(&item
.key
, 0);
199 btrfs_set_disk_key_type(&item
.key
, BTRFS_EXTENT_ITEM_KEY
);
200 itemoff
= __BTRFS_LEAF_DATA_SIZE(blocksize
) -
201 sizeof(struct btrfs_extent_item
);
202 btrfs_set_item_offset(&item
, itemoff
);
203 btrfs_set_item_size(&item
, sizeof(struct btrfs_extent_item
));
204 btrfs_set_extent_refs(&extent_item
, 1);
205 btrfs_set_extent_owner(&extent_item
, 0);
206 memcpy(empty_leaf
->items
, &item
, sizeof(item
));
207 memcpy(btrfs_leaf_data(empty_leaf
) + btrfs_item_offset(&item
),
208 &extent_item
, btrfs_item_size(&item
));
210 /* item2, give block 17 to the root */
211 btrfs_set_disk_key_objectid(&item
.key
, start_block
+ 1);
212 btrfs_set_disk_key_offset(&item
.key
, 1);
213 itemoff
= itemoff
- sizeof(struct btrfs_extent_item
);
214 btrfs_set_item_offset(&item
, itemoff
);
215 btrfs_set_extent_owner(&extent_item
, BTRFS_ROOT_TREE_OBJECTID
);
216 memcpy(empty_leaf
->items
+ 1, &item
, sizeof(item
));
217 memcpy(btrfs_leaf_data(empty_leaf
) + btrfs_item_offset(&item
),
218 &extent_item
, btrfs_item_size(&item
));
220 /* item3, give block 18 to the extent root */
221 btrfs_set_disk_key_objectid(&item
.key
, start_block
+ 2);
222 btrfs_set_disk_key_offset(&item
.key
, 1);
223 itemoff
= itemoff
- sizeof(struct btrfs_extent_item
);
224 btrfs_set_item_offset(&item
, itemoff
);
225 btrfs_set_extent_owner(&extent_item
, BTRFS_EXTENT_TREE_OBJECTID
);
226 memcpy(empty_leaf
->items
+ 2, &item
, sizeof(item
));
227 memcpy(btrfs_leaf_data(empty_leaf
) + btrfs_item_offset(&item
),
228 &extent_item
, btrfs_item_size(&item
));
230 /* item4, give block 19 to the inode map */
231 btrfs_set_disk_key_objectid(&item
.key
, start_block
+ 3);
232 btrfs_set_disk_key_offset(&item
.key
, 1);
233 itemoff
= itemoff
- sizeof(struct btrfs_extent_item
);
234 btrfs_set_item_offset(&item
, itemoff
);
235 btrfs_set_extent_owner(&extent_item
, BTRFS_INODE_MAP_OBJECTID
);
236 memcpy(empty_leaf
->items
+ 3, &item
, sizeof(item
));
237 memcpy(btrfs_leaf_data(empty_leaf
) + btrfs_item_offset(&item
),
238 &extent_item
, btrfs_item_size(&item
));
239 ret
= pwrite(fd
, empty_leaf
, blocksize
, (start_block
+ 2) * blocksize
);
240 if (ret
!= blocksize
)
243 /* item5, give block 20 to the FS root */
244 btrfs_set_disk_key_objectid(&item
.key
, start_block
+ 4);
245 btrfs_set_disk_key_offset(&item
.key
, 1);
246 itemoff
= itemoff
- sizeof(struct btrfs_extent_item
);
247 btrfs_set_item_offset(&item
, itemoff
);
248 btrfs_set_extent_owner(&extent_item
, BTRFS_FS_TREE_OBJECTID
);
249 memcpy(empty_leaf
->items
+ 4, &item
, sizeof(item
));
250 memcpy(btrfs_leaf_data(empty_leaf
) + btrfs_item_offset(&item
),
251 &extent_item
, btrfs_item_size(&item
));
252 ret
= pwrite(fd
, empty_leaf
, blocksize
, (start_block
+ 2) * blocksize
);
253 if (ret
!= blocksize
)
256 /* create the inode map */
257 btrfs_set_header_parentid(&empty_leaf
->header
,
258 BTRFS_INODE_MAP_OBJECTID
);
259 btrfs_set_header_blocknr(&empty_leaf
->header
, start_block
+ 3);
260 btrfs_set_header_nritems(&empty_leaf
->header
, 0);
261 ret
= pwrite(fd
, empty_leaf
, blocksize
, (start_block
+ 3) * blocksize
);
262 if (ret
!= blocksize
)
265 /* finally create the FS root */
266 btrfs_set_header_parentid(&empty_leaf
->header
, BTRFS_FS_TREE_OBJECTID
);
267 btrfs_set_header_blocknr(&empty_leaf
->header
, start_block
+ 4);
268 btrfs_set_header_nritems(&empty_leaf
->header
, 0);
269 ret
= pwrite(fd
, empty_leaf
, blocksize
, (start_block
+ 4) * blocksize
);
270 if (ret
!= blocksize
)
275 u64
device_size(int fd
, struct stat
*st
)
278 if (S_ISREG(st
->st_mode
)) {
281 if (!S_ISBLK(st
->st_mode
)) {
284 if (ioctl(fd
, BLKGETSIZE64
, &size
) >= 0) {
290 int main(int ac
, char **av
)
298 char *buf
= malloc(4096);
305 block_count
= atoi(av
[2]);
307 fprintf(stderr
, "error finding block count\n");
312 fprintf(stderr
, "usage: mkfs.btrfs file [block count]\n");
315 fd
= open(file
, O_RDWR
);
317 fprintf(stderr
, "unable to open %s\n", file
);
320 ret
= fstat(fd
, &st
);
322 fprintf(stderr
, "unable to stat %s\n", file
);
325 if (block_count
== 0) {
326 block_count
= device_size(fd
, &st
);
327 if (block_count
== 0) {
328 fprintf(stderr
, "unable to find %s size\n", file
);
333 if (block_count
< 256) {
334 fprintf(stderr
, "device %s is too small\n", file
);
337 memset(buf
, 0, 4096);
338 for(i
= 0; i
< 16; i
++) {
339 ret
= write(fd
, buf
, 4096);
341 fprintf(stderr
, "unable to zero fill device\n");
345 ret
= mkfs(fd
, block_count
, 4096);
347 fprintf(stderr
, "error during mkfs %d\n", ret
);
350 ret
= make_root_dir(fd
);
352 fprintf(stderr
, "failed to setup the root directory\n");
355 printf("fs created on %s blocksize %d blocks %Lu\n",
356 file
, 4096, block_count
);