mkfs.ubifs: fix description of favor_lzo
[mtd-utils.git] / ubifs-utils / mkfs.ubifs / mkfs.ubifs.c
1 /*
2  * Copyright (C) 2008 Nokia Corporation.
3  * Copyright (C) 2008 University of Szeged, Hungary
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 as published by
7  * the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12  * more details.
13  *
14  * You should have received a copy of the GNU General Public License along with
15  * this program; if not, write to the Free Software Foundation, Inc., 51
16  * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17  *
18  * Authors: Adrian Hunter
19  *          Artem Bityutskiy
20  *          Zoltan Sogor
21  */
22
23 #define _XOPEN_SOURCE 500 /* For realpath() */
24
25 #include "mkfs.ubifs.h"
26 #include <crc32.h>
27 #include "common.h"
28 #include <sys/types.h>
29 #ifndef WITHOUT_XATTR
30 #include <sys/xattr.h>
31 #endif
32
33 #ifdef WITH_SELINUX
34 #include <selinux/selinux.h>
35 #include <selinux/label.h>
36 #endif
37
38 #ifndef WITHOUT_ZSTD
39 #include <zstd.h>
40 #endif
41
42 #include "crypto.h"
43 #include "fscrypt.h"
44
45 /* Size (prime number) of hash table for link counting */
46 #define HASH_TABLE_SIZE 10099
47
48 /* The node buffer must allow for worst case compression */
49 #define NODE_BUFFER_SIZE (UBIFS_DATA_NODE_SZ + \
50                           UBIFS_BLOCK_SIZE * WORST_COMPR_FACTOR)
51
52 /* Default time granularity in nanoseconds */
53 #define DEFAULT_TIME_GRAN 1000000000
54
55
56 #ifdef WITH_SELINUX
57 #define XATTR_NAME_SELINUX "security.selinux"
58 static struct selabel_handle *sehnd;
59 static char *secontext;
60 #endif
61
62 /**
63  * struct idx_entry - index entry.
64  * @next: next index entry (NULL at end of list)
65  * @prev: previous index entry (NULL at beginning of list)
66  * @key: key
67  * @name: directory entry name used for sorting colliding keys by name
68  * @lnum: LEB number
69  * @offs: offset
70  * @len: length
71  *
72  * The index is recorded as a linked list which is sorted and used to create
73  * the bottom level of the on-flash index tree. The remaining levels of the
74  * index tree are each built from the level below.
75  */
76 struct idx_entry {
77         struct idx_entry *next;
78         struct idx_entry *prev;
79         union ubifs_key key;
80         char *name;
81         int name_len;
82         int lnum;
83         int offs;
84         int len;
85 };
86
87 /**
88  * struct inum_mapping - inode number mapping for link counting.
89  * @next: next inum_mapping (NULL at end of list)
90  * @prev: previous inum_mapping (NULL at beginning of list)
91  * @dev: source device on which the source inode number resides
92  * @inum: source inode number of the file
93  * @use_inum: target inode number of the file
94  * @use_nlink: number of links
95  * @path_name: a path name of the file
96  * @st: struct stat object containing inode attributes which have to be used
97  *      when the inode is being created (actually only UID, GID, access
98  *      mode, major and minor device numbers)
99  *
100  * If a file has more than one hard link, then the number of hard links that
101  * exist in the source directory hierarchy must be counted to exclude the
102  * possibility that the file is linked from outside the source directory
103  * hierarchy.
104  *
105  * The inum_mappings are stored in a hash_table of linked lists.
106  */
107 struct inum_mapping {
108         struct inum_mapping *next;
109         struct inum_mapping *prev;
110         dev_t dev;
111         ino_t inum;
112         ino_t use_inum;
113         unsigned int use_nlink;
114         char *path_name;
115         struct stat st;
116 };
117
118 /*
119  * Because we copy functions from the kernel, we use a subset of the UBIFS
120  * file-system description object struct ubifs_info.
121  */
122 struct ubifs_info info_;
123 static struct ubifs_info *c = &info_;
124 static libubi_t ubi;
125
126 /* Debug levels are: 0 (none), 1 (statistics), 2 (files) ,3 (more details) */
127 int debug_level;
128 int verbose;
129 int yes;
130
131 static char *root;
132 static int root_len;
133 static struct fscrypt_context *root_fctx;
134 static struct stat root_st;
135 static char *output;
136 static int out_fd;
137 static int out_ubi;
138 static int squash_owner;
139 static int do_create_inum_attr;
140 static char *context;
141 static int context_len;
142 static struct stat context_st;
143
144 /* The 'head' (position) which nodes are written */
145 static int head_lnum;
146 static int head_offs;
147 static int head_flags;
148
149 /* The index list */
150 static struct idx_entry *idx_list_first;
151 static struct idx_entry *idx_list_last;
152 static size_t idx_cnt;
153
154 /* Global buffers */
155 static void *leb_buf;
156 static void *node_buf;
157 static void *block_buf;
158
159 /* Hash table for inode link counting */
160 static struct inum_mapping **hash_table;
161
162 /* Inode creation sequence number */
163 static unsigned long long creat_sqnum;
164
165 static const char *optstring = "d:r:m:o:D:yh?vVe:c:g:f:Fp:k:x:X:j:R:l:j:UQqaK:b:P:C:";
166
167 static const struct option longopts[] = {
168         {"root",               1, NULL, 'r'},
169         {"min-io-size",        1, NULL, 'm'},
170         {"leb-size",           1, NULL, 'e'},
171         {"max-leb-cnt",        1, NULL, 'c'},
172         {"output",             1, NULL, 'o'},
173         {"devtable",           1, NULL, 'D'},
174         {"yes",                0, NULL, 'y'},
175         {"help",               0, NULL, 'h'},
176         {"verbose",            0, NULL, 'v'},
177         {"version",            0, NULL, 'V'},
178         {"debug-level",        1, NULL, 'g'},
179         {"jrn-size",           1, NULL, 'j'},
180         {"reserved",           1, NULL, 'R'},
181         {"compr",              1, NULL, 'x'},
182         {"favor-percent",      1, NULL, 'X'},
183         {"fanout",             1, NULL, 'f'},
184         {"space-fixup",        0, NULL, 'F'},
185         {"keyhash",            1, NULL, 'k'},
186         {"log-lebs",           1, NULL, 'l'},
187         {"orph-lebs",          1, NULL, 'p'},
188         {"squash-uids" ,       0, NULL, 'U'},
189         {"set-inode-attr",     0, NULL, 'a'},
190         {"selinux",            1, NULL, 's'},
191         {"key",                1, NULL, 'K'},
192         {"key-descriptor",     1, NULL, 'b'},
193         {"padding",            1, NULL, 'P'},
194         {"cipher",             1, NULL, 'C'},
195         {NULL, 0, NULL, 0}
196 };
197
198 static const char *helptext =
199 "Usage: mkfs.ubifs [OPTIONS] target\n"
200 "Make a UBIFS file system image from an existing directory tree\n\n"
201 "Examples:\n"
202 "Build file system from directory /opt/img, writting the result in the ubifs.img file\n"
203 "\tmkfs.ubifs -m 512 -e 128KiB -c 100 -r /opt/img ubifs.img\n"
204 "The same, but writting directly to an UBI volume\n"
205 "\tmkfs.ubifs -r /opt/img /dev/ubi0_0\n"
206 "Creating an empty UBIFS filesystem on an UBI volume\n"
207 "\tmkfs.ubifs /dev/ubi0_0\n\n"
208 "Options:\n"
209 "-r, -d, --root=DIR       build file system from directory DIR\n"
210 "-m, --min-io-size=SIZE   minimum I/O unit size\n"
211 "-e, --leb-size=SIZE      logical erase block size\n"
212 "-c, --max-leb-cnt=COUNT  maximum logical erase block count\n"
213 "-o, --output=FILE        output to FILE\n"
214 "-j, --jrn-size=SIZE      journal size\n"
215 "-R, --reserved=SIZE      how much space should be reserved for the super-user\n"
216 "-x, --compr=TYPE         compression type - \"lzo\", \"favor_lzo\", \"zlib\"\n"
217 "                         \"zstd\" or \"none\" (default: \"lzo\")\n"
218 "-X, --favor-percent      may only be used with favor LZO compression and defines\n"
219 "                         how many percent better zlib should compress to make\n"
220 "                         mkfs.ubifs use zlib instead of LZO (default 20%)\n"
221 "-f, --fanout=NUM         fanout NUM (default: 8)\n"
222 "-F, --space-fixup        file-system free space has to be fixed up on first mount\n"
223 "                         (requires kernel version 3.0 or greater)\n"
224 "-k, --keyhash=TYPE       key hash type - \"r5\" or \"test\" (default: \"r5\")\n"
225 "-p, --orph-lebs=COUNT    count of erase blocks for orphans (default: 1)\n"
226 "-D, --devtable=FILE      use device table FILE\n"
227 "-U, --squash-uids        squash owners making all files owned by root\n"
228 "-l, --log-lebs=COUNT     count of erase blocks for the log (used only for\n"
229 "                         debugging)\n"
230 "-y, --yes                assume the answer is \"yes\" for all questions\n"
231 "-v, --verbose            verbose operation\n"
232 "-V, --version            display version information\n"
233 "-g, --debug=LEVEL        display debug information (0 - none, 1 - statistics,\n"
234 "                         2 - files, 3 - more details)\n"
235 "-a, --set-inum-attr      create user.image-inode-number extended attribute on files\n"
236 "                         added to the image. The attribute will contain the inode\n"
237 "                         number the file has in the generated image.\n"
238 "-s, --selinux=FILE       Selinux context file\n"
239 "-K, --key=FILE           load an encryption key from a specified file.\n"
240 "-b, --key-descriptor=HEX specify the key descriptor as a hex string.\n"
241 "-P, --padding=NUM        specify padding policy for encrypting filenames\n"
242 "                         (default = 4).\n"
243 "-C, --cipher=NAME        Specify cipher to use for file level encryption\n"
244 "                         (default is \"AES-256-XTS\").\n"
245 "-h, --help               display this help text\n\n"
246 "Note, SIZE is specified in bytes, but it may also be specified in Kilobytes,\n"
247 "Megabytes, and Gigabytes if a KiB, MiB, or GiB suffix is used.\n\n"
248 "If you specify \"lzo\" or \"zlib\" compressors, mkfs.ubifs will use this compressor\n"
249 "for all data. The \"none\" disables any data compression. The \"favor_lzo\" is not\n"
250 "really a separate compressor. It is just a method of combining \"lzo\" and \"zlib\"\n"
251 "compressors. Namely, mkfs.ubifs tries to compress data with both \"lzo\" and \"zlib\"\n"
252 "compressors, then it compares which compressor is better. If \"zlib\" compresses 20\n"
253 "or more percent better than \"lzo\", mkfs.ubifs chooses \"zlib\", otherwise it chooses\n"
254 "\"lzo\". The \"--favor-percent\" may specify arbitrary threshold instead of the\n"
255 "default 20%.\n\n"
256 "The -F parameter is used to set the \"fix up free space\" flag in the superblock,\n"
257 "which forces UBIFS to \"fixup\" all the free space which it is going to use. This\n"
258 "option is useful to work-around the problem of double free space programming: if the\n"
259 "flasher program which flashes the UBI image is unable to skip NAND pages containing\n"
260 "only 0xFF bytes, the effect is that some NAND pages are written to twice - first time\n"
261 "when flashing the image and the second time when UBIFS is mounted and writes useful\n"
262 "data there. A proper UBI-aware flasher should skip such NAND pages, though. Note, this\n"
263 "flag may make the first mount very slow, because the \"free space fixup\" procedure\n"
264 "takes time. This feature is supported by the Linux kernel starting from version 3.0.\n";
265
266 /**
267  * make_path - make a path name from a directory and a name.
268  * @dir: directory path name
269  * @name: name
270  */
271 static char *make_path(const char *dir, const char *name)
272 {
273         char *s;
274
275         xasprintf(&s, "%s%s%s",
276                   dir, dir[strlen(dir) - 1] == '/' ? "" : "/", name);
277
278         return s;
279 }
280
281 /**
282  * is_contained - determine if a file is beneath a directory.
283  * @file: file path name
284  * @dir: directory path name
285  *
286  * This function returns %1 if @file is accessible from the @dir directory and
287  * %0 otherwise. In case of error, returns %-1.
288  */
289 static int is_contained(const char *file, const char *dir)
290 {
291         char *real_file = NULL;
292         char *real_dir = NULL;
293         char *file_base, *copy;
294         int ret = -1;
295
296         /* Make a copy of the file path because 'dirname()' can modify it */
297         copy = strdup(file);
298         if (!copy)
299                 return -1;
300         file_base = dirname(copy);
301
302         /* Turn the paths into the canonical form */
303         real_file = xmalloc(PATH_MAX);
304         real_dir = xmalloc(PATH_MAX);
305
306         if (!realpath(file_base, real_file)) {
307                 perror("Could not canonicalize file path");
308                 goto out_free;
309         }
310         if (!realpath(dir, real_dir)) {
311                 perror("Could not canonicalize directory");
312                 goto out_free;
313         }
314
315         ret = !!strstr(real_file, real_dir);
316
317 out_free:
318         free(copy);
319         free(real_file);
320         free(real_dir);
321         return ret;
322 }
323
324 /**
325  * calc_min_log_lebs - calculate the minimum number of log LEBs needed.
326  * @max_bud_bytes: journal size (buds only)
327  */
328 static int calc_min_log_lebs(unsigned long long max_bud_bytes)
329 {
330         int buds, log_lebs;
331         unsigned long long log_size;
332
333         buds = (max_bud_bytes + c->leb_size - 1) / c->leb_size;
334         log_size = ALIGN(UBIFS_REF_NODE_SZ, c->min_io_size);
335         log_size *= buds;
336         log_size += ALIGN(UBIFS_CS_NODE_SZ +
337                           UBIFS_REF_NODE_SZ * (c->jhead_cnt + 2),
338                           c->min_io_size);
339         log_lebs = (log_size + c->leb_size - 1) / c->leb_size;
340         log_lebs += 1;
341         return log_lebs;
342 }
343
344 /**
345  * add_space_overhead - add UBIFS overhead.
346  * @size: flash space which should be visible to the user
347  *
348  * UBIFS has overhead, and if we need to reserve @size bytes for the user data,
349  * we have to reserve more flash space, to compensate the overhead. This
350  * function calculates and returns the amount of physical flash space which
351  * should be reserved to provide @size bytes for the user.
352  */
353 static long long add_space_overhead(long long size)
354 {
355         int divisor, factor, f, max_idx_node_sz;
356
357         /*
358          * Do the opposite to what the 'ubifs_reported_space()' kernel UBIFS
359          * function does.
360          */
361         max_idx_node_sz =  ubifs_idx_node_sz(c, c->fanout);
362         f = c->fanout > 3 ? c->fanout >> 1 : 2;
363         divisor = UBIFS_BLOCK_SIZE;
364         factor = UBIFS_MAX_DATA_NODE_SZ;
365         factor += (max_idx_node_sz * 3) / (f - 1);
366         size *= factor;
367         return size / divisor;
368 }
369
370 static int validate_options(void)
371 {
372         int tmp;
373
374         if (!output)
375                 return err_msg("no output file or UBI volume specified");
376         if (root) {
377                 tmp = is_contained(output, root);
378                 if (tmp < 0)
379                         return err_msg("failed to perform output file root check");
380                 else if (tmp)
381                         return err_msg("output file cannot be in the UBIFS root "
382                                        "directory");
383         }
384         if (!is_power_of_2(c->min_io_size))
385                 return err_msg("min. I/O unit size should be power of 2");
386         if (c->leb_size < c->min_io_size)
387                 return err_msg("min. I/O unit cannot be larger than LEB size");
388         if (c->leb_size < UBIFS_MIN_LEB_SZ)
389                 return err_msg("too small LEB size %d, minimum is %d",
390                                c->leb_size, UBIFS_MIN_LEB_SZ);
391         if (c->leb_size % c->min_io_size)
392                 return err_msg("LEB should be multiple of min. I/O units");
393         if (c->leb_size % 8)
394                 return err_msg("LEB size has to be multiple of 8");
395         if (c->leb_size > UBIFS_MAX_LEB_SZ)
396                 return err_msg("too large LEB size %d, maximum is %d",
397                                 c->leb_size, UBIFS_MAX_LEB_SZ);
398         if (c->max_leb_cnt < UBIFS_MIN_LEB_CNT)
399                 return err_msg("too low max. count of LEBs, minimum is %d",
400                                UBIFS_MIN_LEB_CNT);
401         if (c->fanout < UBIFS_MIN_FANOUT)
402                 return err_msg("too low fanout, minimum is %d",
403                                UBIFS_MIN_FANOUT);
404         tmp = c->leb_size - UBIFS_IDX_NODE_SZ;
405         tmp /= UBIFS_BRANCH_SZ + UBIFS_MAX_KEY_LEN;
406         if (c->fanout > tmp)
407                 return err_msg("too high fanout, maximum is %d", tmp);
408         if (c->log_lebs < UBIFS_MIN_LOG_LEBS)
409                 return err_msg("too few log LEBs, minimum is %d",
410                                UBIFS_MIN_LOG_LEBS);
411         if (c->log_lebs >= c->max_leb_cnt - UBIFS_MIN_LEB_CNT)
412                 return err_msg("too many log LEBs, maximum is %d",
413                                c->max_leb_cnt - UBIFS_MIN_LEB_CNT);
414         if (c->orph_lebs < UBIFS_MIN_ORPH_LEBS)
415                 return err_msg("too few orphan LEBs, minimum is %d",
416                                UBIFS_MIN_ORPH_LEBS);
417         if (c->orph_lebs >= c->max_leb_cnt - UBIFS_MIN_LEB_CNT)
418                 return err_msg("too many orphan LEBs, maximum is %d",
419                                c->max_leb_cnt - UBIFS_MIN_LEB_CNT);
420         tmp = UBIFS_SB_LEBS + UBIFS_MST_LEBS + c->log_lebs + c->lpt_lebs;
421         tmp += c->orph_lebs + 4;
422         if (tmp > c->max_leb_cnt)
423                 return err_msg("too low max. count of LEBs, expected at "
424                                "least %d", tmp);
425         tmp = calc_min_log_lebs(c->max_bud_bytes);
426         if (c->log_lebs < calc_min_log_lebs(c->max_bud_bytes))
427                 return err_msg("too few log LEBs, expected at least %d", tmp);
428         if (c->rp_size >= ((long long)c->leb_size * c->max_leb_cnt) / 2)
429                 return err_msg("too much reserved space %lld", c->rp_size);
430         return 0;
431 }
432
433 /**
434  * get_multiplier - convert size specifier to an integer multiplier.
435  * @str: the size specifier string
436  *
437  * This function parses the @str size specifier, which may be one of
438  * 'KiB', 'MiB', or 'GiB' into an integer multiplier. Returns positive
439  * size multiplier in case of success and %-1 in case of failure.
440  */
441 static int get_multiplier(const char *str)
442 {
443         if (!str)
444                 return 1;
445
446         /* Remove spaces before the specifier */
447         while (*str == ' ' || *str == '\t')
448                 str += 1;
449
450         if (!strcmp(str, "KiB"))
451                 return 1024;
452         if (!strcmp(str, "MiB"))
453                 return 1024 * 1024;
454         if (!strcmp(str, "GiB"))
455                 return 1024 * 1024 * 1024;
456
457         return -1;
458 }
459
460 /**
461  * get_bytes - convert a string containing amount of bytes into an
462  *             integer.
463  * @str: string to convert
464  *
465  * This function parses @str which may have one of 'KiB', 'MiB', or 'GiB' size
466  * specifiers. Returns positive amount of bytes in case of success and %-1 in
467  * case of failure.
468  */
469 static long long get_bytes(const char *str)
470 {
471         char *endp;
472         long long bytes = strtoull(str, &endp, 0);
473
474         if (endp == str || bytes < 0)
475                 return err_msg("incorrect amount of bytes: \"%s\"", str);
476
477         if (*endp != '\0') {
478                 int mult = get_multiplier(endp);
479
480                 if (mult == -1)
481                         return err_msg("bad size specifier: \"%s\" - "
482                                        "should be 'KiB', 'MiB' or 'GiB'", endp);
483                 bytes *= mult;
484         }
485
486         return bytes;
487 }
488 /**
489  * open_ubi - open the UBI volume.
490  * @node: name of the UBI volume character device to fetch information about
491  *
492  * Returns %0 in case of success and %-1 in case of failure
493  */
494 static int open_ubi(const char *node)
495 {
496         struct stat st;
497
498         if (stat(node, &st) || !S_ISCHR(st.st_mode))
499                 return -1;
500
501         ubi = libubi_open();
502         if (!ubi)
503                 return -1;
504         if (ubi_get_vol_info(ubi, node, &c->vi))
505                 return -1;
506         if (ubi_get_dev_info1(ubi, c->vi.dev_num, &c->di))
507                 return -1;
508         return 0;
509 }
510
511 static void select_default_compr(void)
512 {
513         if (c->encrypted) {
514                 c->default_compr = UBIFS_COMPR_NONE;
515                 return;
516         }
517
518 #ifdef WITHOUT_LZO
519         c->default_compr = UBIFS_COMPR_ZLIB;
520 #else
521         c->default_compr = UBIFS_COMPR_LZO;
522 #endif
523 }
524
525 static int get_options(int argc, char**argv)
526 {
527         int opt, i, fscrypt_flags = FS_POLICY_FLAGS_PAD_4;
528         const char *key_file = NULL, *key_desc = NULL;
529         const char *tbl_file = NULL;
530         struct stat st;
531         char *endp;
532 #ifdef WITH_CRYPTO
533         const char *cipher_name;
534 #endif
535
536         c->fanout = 8;
537         c->orph_lebs = 1;
538         c->key_hash = key_r5_hash;
539         c->key_len = UBIFS_SK_LEN;
540         c->favor_percent = 20;
541         c->lsave_cnt = 256;
542         c->leb_size = -1;
543         c->min_io_size = -1;
544         c->max_leb_cnt = -1;
545         c->max_bud_bytes = -1;
546         c->log_lebs = -1;
547         c->double_hash = 0;
548         c->encrypted = 0;
549         c->default_compr = -1;
550
551         while (1) {
552                 opt = getopt_long(argc, argv, optstring, longopts, &i);
553                 if (opt == -1)
554                         break;
555                 switch (opt) {
556                 case 'r':
557                 case 'd':
558                         root_len = strlen(optarg);
559                         root = xmalloc(root_len + 2);
560
561                         /*
562                          * The further code expects '/' at the end of the root
563                          * UBIFS directory on the host.
564                          */
565                         memcpy(root, optarg, root_len);
566                         if (root[root_len - 1] != '/')
567                                 root[root_len++] = '/';
568                         root[root_len] = 0;
569
570                         /* Make sure the root directory exists */
571                         if (stat(root, &st))
572                                 return sys_err_msg("bad root directory '%s'",
573                                                    root);
574                         break;
575                 case 'm':
576                         c->min_io_size = get_bytes(optarg);
577                         if (c->min_io_size <= 0)
578                                 return err_msg("bad min. I/O size");
579                         break;
580                 case 'e':
581                         c->leb_size = get_bytes(optarg);
582                         if (c->leb_size <= 0)
583                                 return err_msg("bad LEB size");
584                         break;
585                 case 'c':
586                         c->max_leb_cnt = get_bytes(optarg);
587                         if (c->max_leb_cnt <= 0)
588                                 return err_msg("bad maximum LEB count");
589                         break;
590                 case 'o':
591                         output = xstrdup(optarg);
592                         break;
593                 case 'D':
594                         tbl_file = optarg;
595                         if (stat(tbl_file, &st) < 0)
596                                 return sys_err_msg("bad device table file '%s'",
597                                                    tbl_file);
598                         break;
599                 case 'y':
600                         yes = 1;
601                         break;
602                 case 'h':
603                         printf("%s", helptext);
604                         exit(EXIT_SUCCESS);
605                 case '?':
606                         printf("%s", helptext);
607 #ifdef WITH_CRYPTO
608                         printf("\n\nSupported ciphers:\n");
609                         list_ciphers(stdout);
610 #endif
611                         exit(-1);
612                 case 'v':
613                         verbose = 1;
614                         break;
615                 case 'V':
616                         common_print_version();
617                         exit(EXIT_SUCCESS);
618                 case 'g':
619                         debug_level = strtol(optarg, &endp, 0);
620                         if (*endp != '\0' || endp == optarg ||
621                             debug_level < 0 || debug_level > 3)
622                                 return err_msg("bad debugging level '%s'",
623                                                optarg);
624                         break;
625                 case 'f':
626                         c->fanout = strtol(optarg, &endp, 0);
627                         if (*endp != '\0' || endp == optarg || c->fanout <= 0)
628                                 return err_msg("bad fanout %s", optarg);
629                         break;
630                 case 'F':
631                         c->space_fixup = 1;
632                         break;
633                 case 'l':
634                         c->log_lebs = strtol(optarg, &endp, 0);
635                         if (*endp != '\0' || endp == optarg || c->log_lebs <= 0)
636                                 return err_msg("bad count of log LEBs '%s'",
637                                                optarg);
638                         break;
639                 case 'p':
640                         c->orph_lebs = strtol(optarg, &endp, 0);
641                         if (*endp != '\0' || endp == optarg ||
642                             c->orph_lebs <= 0)
643                                 return err_msg("bad orphan LEB count '%s'",
644                                                optarg);
645                         break;
646                 case 'k':
647                         if (strcmp(optarg, "r5") == 0) {
648                                 c->key_hash = key_r5_hash;
649                                 c->key_hash_type = UBIFS_KEY_HASH_R5;
650                         } else if (strcmp(optarg, "test") == 0) {
651                                 c->key_hash = key_test_hash;
652                                 c->key_hash_type = UBIFS_KEY_HASH_TEST;
653                         } else
654                                 return err_msg("bad key hash");
655                         break;
656                 case 'x':
657                         if (strcmp(optarg, "none") == 0)
658                                 c->default_compr = UBIFS_COMPR_NONE;
659                         else if (strcmp(optarg, "zlib") == 0)
660                                 c->default_compr = UBIFS_COMPR_ZLIB;
661 #ifndef WITHOUT_ZSTD
662                         else if (strcmp(optarg, "zstd") == 0)
663                                 c->default_compr = UBIFS_COMPR_ZSTD;
664 #endif
665 #ifndef WITHOUT_LZO
666                         else if (strcmp(optarg, "favor_lzo") == 0) {
667                                 c->default_compr = UBIFS_COMPR_LZO;
668                                 c->favor_lzo = 1;
669                         } else if (strcmp(optarg, "lzo") == 0) {
670                                 c->default_compr = UBIFS_COMPR_LZO;
671                         }
672 #endif
673                         else
674                                 return err_msg("bad compressor name");
675                         break;
676                 case 'X':
677 #ifdef WITHOUT_LZO
678                         return err_msg("built without LZO support");
679 #else
680                         c->favor_percent = strtol(optarg, &endp, 0);
681                         if (*endp != '\0' || endp == optarg ||
682                             c->favor_percent <= 0 || c->favor_percent >= 100)
683                                 return err_msg("bad favor LZO percent '%s'",
684                                                optarg);
685 #endif
686                         break;
687                 case 'j':
688                         c->max_bud_bytes = get_bytes(optarg);
689                         if (c->max_bud_bytes <= 0)
690                                 return err_msg("bad maximum amount of buds");
691                         break;
692                 case 'R':
693                         c->rp_size = get_bytes(optarg);
694                         if (c->rp_size < 0)
695                                 return err_msg("bad reserved bytes count");
696                         break;
697                 case 'U':
698                         squash_owner = 1;
699                         break;
700                 case 'a':
701                         do_create_inum_attr = 1;
702                         break;
703                 case 's':
704                         context_len = strlen(optarg);
705                         context = (char *) xmalloc(context_len + 1);
706                         if (!context)
707                                 return err_msg("xmalloc failed\n");
708                         memcpy(context, optarg, context_len);
709
710                         /* Make sure root directory exists */
711                         if (stat(context, &context_st))
712                                 return sys_err_msg("bad file context %s\n",
713                                                                    context);
714                         break;
715                 case 'K':
716                         if (key_file) {
717                                 return err_msg("key file specified more than once");
718                         }
719                         key_file = optarg;
720                         break;
721                 case 'b':
722                         if (key_desc) {
723                                 return err_msg("key descriptor specified more than once");
724                         }
725                         key_desc = optarg;
726                         break;
727                 case 'P': {
728                         int error = 0;
729                         unsigned long num;
730
731                         num = simple_strtoul(optarg, &error);
732                         if (error)
733                                 num = -1;
734
735                         fscrypt_flags &= ~FS_POLICY_FLAGS_PAD_MASK;
736
737                         switch (num) {
738                         case 4:
739                                 fscrypt_flags |= FS_POLICY_FLAGS_PAD_4;
740                                 break;
741                         case 8:
742                                 fscrypt_flags |= FS_POLICY_FLAGS_PAD_8;
743                                 break;
744                         case 16:
745                                 fscrypt_flags |= FS_POLICY_FLAGS_PAD_16;
746                                 break;
747                         case 32:
748                                 fscrypt_flags |= FS_POLICY_FLAGS_PAD_32;
749                                 break;
750                         default:
751                                 return errmsg("invalid padding policy '%s'",
752                                                 optarg);
753                         }
754                         break;
755                 }
756                 case 'C':
757 #ifdef WITH_CRYPTO
758                         cipher_name = optarg;
759 #else
760                         return err_msg("mkfs.ubifs was built without crypto support.");
761 #endif
762                         break;
763                 }
764         }
765
766         if (optind != argc && !output)
767                 output = xstrdup(argv[optind]);
768
769         if (!output)
770                 return err_msg("not output device or file specified");
771
772         out_ubi = !open_ubi(output);
773
774         if (out_ubi) {
775                 c->min_io_size = c->di.min_io_size;
776                 c->leb_size = c->vi.leb_size;
777                 if (c->max_leb_cnt == -1)
778                         c->max_leb_cnt = c->vi.rsvd_lebs;
779         }
780         if (key_file || key_desc) {
781 #ifdef WITH_CRYPTO
782                 if (!key_file)
783                         return err_msg("no key file specified");
784
785                 c->double_hash = 1;
786                 c->encrypted = 1;
787
788                 if (cipher_name == NULL)
789                         cipher_name = "AES-256-XTS";
790
791                 root_fctx = init_fscrypt_context(cipher_name, fscrypt_flags,
792                                                 key_file, key_desc);
793                 if (!root_fctx)
794                         return -1;
795 #else
796                 return err_msg("mkfs.ubifs was built without crypto support.");
797 #endif
798         }
799
800         if (c->default_compr == -1)
801                 select_default_compr();
802
803         if (c->min_io_size == -1)
804                 return err_msg("min. I/O unit was not specified "
805                                "(use -h for help)");
806
807         if (c->leb_size == -1)
808                 return err_msg("LEB size was not specified (use -h for help)");
809
810         if (c->max_leb_cnt == -1)
811                 return err_msg("Maximum count of LEBs was not specified "
812                                "(use -h for help)");
813
814         if (c->max_bud_bytes == -1) {
815                 int lebs;
816
817                 lebs = c->max_leb_cnt - UBIFS_SB_LEBS - UBIFS_MST_LEBS;
818                 lebs -= c->orph_lebs;
819                 if (c->log_lebs != -1)
820                         lebs -= c->log_lebs;
821                 else
822                         lebs -= UBIFS_MIN_LOG_LEBS;
823                 /*
824                  * We do not know lprops geometry so far, so assume minimum
825                  * count of lprops LEBs.
826                  */
827                 lebs -= UBIFS_MIN_LPT_LEBS;
828                 /* Make the journal about 12.5% of main area lebs */
829                 c->max_bud_bytes = (lebs / 8) * (long long)c->leb_size;
830                 /* Make the max journal size 8MiB */
831                 if (c->max_bud_bytes > 8 * 1024 * 1024)
832                         c->max_bud_bytes = 8 * 1024 * 1024;
833                 if (c->max_bud_bytes < 4 * c->leb_size)
834                         c->max_bud_bytes = 4 * c->leb_size;
835         }
836
837         if (c->log_lebs == -1) {
838                 c->log_lebs = calc_min_log_lebs(c->max_bud_bytes);
839                 c->log_lebs += 2;
840         }
841
842         if (c->min_io_size < 8)
843                 c->min_io_size = 8;
844         c->rp_size = add_space_overhead(c->rp_size);
845
846         if (verbose) {
847                 printf("mkfs.ubifs\n");
848                 printf("\troot:         %s\n", root);
849                 printf("\tmin_io_size:  %d\n", c->min_io_size);
850                 printf("\tleb_size:     %d\n", c->leb_size);
851                 printf("\tmax_leb_cnt:  %d\n", c->max_leb_cnt);
852                 printf("\toutput:       %s\n", output);
853                 printf("\tjrn_size:     %llu\n", c->max_bud_bytes);
854                 printf("\treserved:     %llu\n", c->rp_size);
855                 switch (c->default_compr) {
856                 case UBIFS_COMPR_LZO:
857                         printf("\tcompr:        lzo\n");
858                         break;
859                 case UBIFS_COMPR_ZLIB:
860                         printf("\tcompr:        zlib\n");
861                         break;
862                 case UBIFS_COMPR_NONE:
863                         printf("\tcompr:        none\n");
864                         break;
865                 }
866                 printf("\tkeyhash:      %s\n", (c->key_hash == key_r5_hash) ?
867                                                 "r5" : "test");
868                 printf("\tfanout:       %d\n", c->fanout);
869                 printf("\torph_lebs:    %d\n", c->orph_lebs);
870                 printf("\tspace_fixup:  %d\n", c->space_fixup);
871                 printf("\tselinux file: %s\n", context);
872         }
873
874         if (validate_options())
875                 return -1;
876
877         if (tbl_file && parse_devtable(tbl_file))
878                 return err_msg("cannot parse device table file '%s'", tbl_file);
879
880         return 0;
881 }
882
883 /**
884  * prepare_node - fill in the common header.
885  * @node: node
886  * @len: node length
887  */
888 static void prepare_node(void *node, int len)
889 {
890         uint32_t crc;
891         struct ubifs_ch *ch = node;
892
893         ch->magic = cpu_to_le32(UBIFS_NODE_MAGIC);
894         ch->len = cpu_to_le32(len);
895         ch->group_type = UBIFS_NO_NODE_GROUP;
896         ch->sqnum = cpu_to_le64(++c->max_sqnum);
897         ch->padding[0] = ch->padding[1] = 0;
898         crc = mtd_crc32(UBIFS_CRC32_INIT, node + 8, len - 8);
899         ch->crc = cpu_to_le32(crc);
900 }
901
902 /**
903  * write_leb - copy the image of a LEB to the output target.
904  * @lnum: LEB number
905  * @len: length of data in the buffer
906  * @buf: buffer (must be at least c->leb_size bytes)
907  */
908 int write_leb(int lnum, int len, void *buf)
909 {
910         off_t pos = (off_t)lnum * c->leb_size;
911
912         dbg_msg(3, "LEB %d len %d", lnum, len);
913         memset(buf + len, 0xff, c->leb_size - len);
914         if (out_ubi)
915                 if (ubi_leb_change_start(ubi, out_fd, lnum, c->leb_size))
916                         return sys_err_msg("ubi_leb_change_start failed");
917
918         if (lseek(out_fd, pos, SEEK_SET) != pos)
919                 return sys_err_msg("lseek failed seeking %lld", (long long)pos);
920
921         if (write(out_fd, buf, c->leb_size) != c->leb_size)
922                 return sys_err_msg("write failed writing %d bytes at pos %lld",
923                                    c->leb_size, (long long)pos);
924
925         return 0;
926 }
927
928 /**
929  * write_empty_leb - copy the image of an empty LEB to the output target.
930  * @lnum: LEB number
931  */
932 static int write_empty_leb(int lnum)
933 {
934         return write_leb(lnum, 0, leb_buf);
935 }
936
937 /**
938  * do_pad - pad a buffer to the minimum I/O size.
939  * @buf: buffer
940  * @len: buffer length
941  */
942 static int do_pad(void *buf, int len)
943 {
944         int pad_len, alen = ALIGN(len, 8), wlen = ALIGN(alen, c->min_io_size);
945         uint32_t crc;
946
947         memset(buf + len, 0xff, alen - len);
948         pad_len = wlen - alen;
949         dbg_msg(3, "len %d pad_len %d", len, pad_len);
950         buf += alen;
951         if (pad_len >= (int)UBIFS_PAD_NODE_SZ) {
952                 struct ubifs_ch *ch = buf;
953                 struct ubifs_pad_node *pad_node = buf;
954
955                 ch->magic      = cpu_to_le32(UBIFS_NODE_MAGIC);
956                 ch->node_type  = UBIFS_PAD_NODE;
957                 ch->group_type = UBIFS_NO_NODE_GROUP;
958                 ch->padding[0] = ch->padding[1] = 0;
959                 ch->sqnum      = cpu_to_le64(0);
960                 ch->len        = cpu_to_le32(UBIFS_PAD_NODE_SZ);
961
962                 pad_len -= UBIFS_PAD_NODE_SZ;
963                 pad_node->pad_len = cpu_to_le32(pad_len);
964
965                 crc = mtd_crc32(UBIFS_CRC32_INIT, buf + 8,
966                                   UBIFS_PAD_NODE_SZ - 8);
967                 ch->crc = cpu_to_le32(crc);
968
969                 memset(buf + UBIFS_PAD_NODE_SZ, 0, pad_len);
970         } else if (pad_len > 0)
971                 memset(buf, UBIFS_PADDING_BYTE, pad_len);
972
973         return wlen;
974 }
975
976 /**
977  * write_node - write a node to a LEB.
978  * @node: node
979  * @len: node length
980  * @lnum: LEB number
981  */
982 static int write_node(void *node, int len, int lnum)
983 {
984         prepare_node(node, len);
985
986         memcpy(leb_buf, node, len);
987
988         len = do_pad(leb_buf, len);
989
990         return write_leb(lnum, len, leb_buf);
991 }
992
993 /**
994  * calc_dark - calculate LEB dark space size.
995  * @c: the UBIFS file-system description object
996  * @spc: amount of free and dirty space in the LEB
997  *
998  * This function calculates amount of dark space in an LEB which has @spc bytes
999  * of free and dirty space. Returns the calculations result.
1000  *
1001  * Dark space is the space which is not always usable - it depends on which
1002  * nodes are written in which order. E.g., if an LEB has only 512 free bytes,
1003  * it is dark space, because it cannot fit a large data node. So UBIFS cannot
1004  * count on this LEB and treat these 512 bytes as usable because it is not true
1005  * if, for example, only big chunks of uncompressible data will be written to
1006  * the FS.
1007  */
1008 static int calc_dark(struct ubifs_info *c, int spc)
1009 {
1010         if (spc < c->dark_wm)
1011                 return spc;
1012
1013         /*
1014          * If we have slightly more space then the dark space watermark, we can
1015          * anyway safely assume it we'll be able to write a node of the
1016          * smallest size there.
1017          */
1018         if (spc - c->dark_wm < (int)MIN_WRITE_SZ)
1019                 return spc - MIN_WRITE_SZ;
1020
1021         return c->dark_wm;
1022 }
1023
1024 /**
1025  * set_lprops - set the LEB property values for a LEB.
1026  * @lnum: LEB number
1027  * @offs: end offset of data in the LEB
1028  * @flags: LEB property flags
1029  */
1030 static void set_lprops(int lnum, int offs, int flags)
1031 {
1032         int i = lnum - c->main_first, free, dirty;
1033         int a = max_t(int, c->min_io_size, 8);
1034
1035         free = c->leb_size - ALIGN(offs, a);
1036         dirty = c->leb_size - free - ALIGN(offs, 8);
1037         dbg_msg(3, "LEB %d free %d dirty %d flags %d", lnum, free, dirty,
1038                 flags);
1039         if (i < c->main_lebs) {
1040                 c->lpt[i].free = free;
1041                 c->lpt[i].dirty = dirty;
1042                 c->lpt[i].flags = flags;
1043         }
1044         c->lst.total_free += free;
1045         c->lst.total_dirty += dirty;
1046         if (flags & LPROPS_INDEX)
1047                 c->lst.idx_lebs += 1;
1048         else {
1049                 int spc;
1050
1051                 spc = free + dirty;
1052                 if (spc < c->dead_wm)
1053                         c->lst.total_dead += spc;
1054                 else
1055                         c->lst.total_dark += calc_dark(c, spc);
1056                 c->lst.total_used += c->leb_size - spc;
1057         }
1058 }
1059
1060 /**
1061  * add_to_index - add a node key and position to the index.
1062  * @key: node key
1063  * @lnum: node LEB number
1064  * @offs: node offset
1065  * @len: node length
1066  */
1067 static int add_to_index(union ubifs_key *key, char *name, int name_len,
1068                         int lnum, int offs, int len)
1069 {
1070         struct idx_entry *e;
1071
1072         dbg_msg(3, "LEB %d offs %d len %d", lnum, offs, len);
1073         e = xmalloc(sizeof(struct idx_entry));
1074         e->next = NULL;
1075         e->prev = idx_list_last;
1076         e->key = *key;
1077         e->name = name;
1078         e->name_len = name_len;
1079         e->lnum = lnum;
1080         e->offs = offs;
1081         e->len = len;
1082         if (!idx_list_first)
1083                 idx_list_first = e;
1084         if (idx_list_last)
1085                 idx_list_last->next = e;
1086         idx_list_last = e;
1087         idx_cnt += 1;
1088         return 0;
1089 }
1090
1091 /**
1092  * flush_nodes - write the current head and move the head to the next LEB.
1093  */
1094 static int flush_nodes(void)
1095 {
1096         int len, err;
1097
1098         if (!head_offs)
1099                 return 0;
1100         len = do_pad(leb_buf, head_offs);
1101         err = write_leb(head_lnum, len, leb_buf);
1102         if (err)
1103                 return err;
1104         set_lprops(head_lnum, head_offs, head_flags);
1105         head_lnum += 1;
1106         head_offs = 0;
1107         return 0;
1108 }
1109
1110 /**
1111  * reserve_space - reserve space for a node on the head.
1112  * @len: node length
1113  * @lnum: LEB number is returned here
1114  * @offs: offset is returned here
1115  */
1116 static int reserve_space(int len, int *lnum, int *offs)
1117 {
1118         int err;
1119
1120         if (len > c->leb_size - head_offs) {
1121                 err = flush_nodes();
1122                 if (err)
1123                         return err;
1124         }
1125         *lnum = head_lnum;
1126         *offs = head_offs;
1127         head_offs += ALIGN(len, 8);
1128         return 0;
1129 }
1130
1131 /**
1132  * add_node - write a node to the head.
1133  * @key: node key
1134  * @node: node
1135  * @len: node length
1136  */
1137 static int add_node(union ubifs_key *key, char *name, int name_len, void *node, int len)
1138 {
1139         int err, lnum, offs, type = key_type(key);
1140
1141         if (type == UBIFS_DENT_KEY || type == UBIFS_XENT_KEY) {
1142                 if (!name)
1143                         return err_msg("Directory entry or xattr "
1144                                         "without name!");
1145         } else {
1146                 if (name)
1147                         return err_msg("Name given for non dir/xattr node!");
1148         }
1149
1150         prepare_node(node, len);
1151
1152         err = reserve_space(len, &lnum, &offs);
1153         if (err)
1154                 return err;
1155
1156         memcpy(leb_buf + offs, node, len);
1157         memset(leb_buf + offs + len, 0xff, ALIGN(len, 8) - len);
1158
1159         add_to_index(key, name, name_len, lnum, offs, len);
1160
1161         return 0;
1162 }
1163
1164 static int add_xattr(struct ubifs_ino_node *host_ino, struct stat *st,
1165                      ino_t inum, char *name, const void *data,
1166                      unsigned int data_len)
1167 {
1168         struct ubifs_ino_node *ino;
1169         struct ubifs_dent_node *xent;
1170         struct qstr nm;
1171         union ubifs_key xkey, nkey;
1172         int len, ret;
1173
1174         nm.len = strlen(name);
1175         nm.name = xmalloc(nm.len + 1);
1176         memcpy(nm.name, name, nm.len + 1);
1177
1178         host_ino->xattr_cnt++;
1179         host_ino->xattr_size += CALC_DENT_SIZE(nm.len);
1180         host_ino->xattr_size += CALC_XATTR_BYTES(data_len);
1181         host_ino->xattr_names += nm.len;
1182
1183         xent = xzalloc(sizeof(*xent) + nm.len + 1);
1184         ino = xzalloc(sizeof(*ino) + data_len);
1185
1186         xent_key_init(c, &xkey, inum, &nm);
1187         xent->ch.node_type = UBIFS_XENT_NODE;
1188         key_write(&xkey, &xent->key);
1189
1190         len = UBIFS_XENT_NODE_SZ + nm.len + 1;
1191
1192         xent->ch.len = len;
1193         xent->padding1 = 0;
1194         xent->type = UBIFS_ITYPE_DIR;
1195         xent->nlen = cpu_to_le16(nm.len);
1196
1197         memcpy(xent->name, nm.name, nm.len + 1);
1198
1199         inum = ++c->highest_inum;
1200         creat_sqnum = ++c->max_sqnum;
1201
1202         xent->inum = cpu_to_le64(inum);
1203
1204         ret = add_node(&xkey, nm.name, nm.len, xent, len);
1205         if (ret)
1206                 goto out;
1207
1208         ino->creat_sqnum = cpu_to_le64(creat_sqnum);
1209         ino->nlink      = cpu_to_le32(1);
1210         /*
1211          * The time fields are updated assuming the default time granularity
1212          * of 1 second. To support finer granularities, utime() would be needed.
1213          */
1214         ino->atime_sec  = cpu_to_le64(st->st_atime);
1215         ino->ctime_sec  = cpu_to_le64(st->st_ctime);
1216         ino->mtime_sec  = cpu_to_le64(st->st_mtime);
1217         ino->atime_nsec = 0;
1218         ino->ctime_nsec = 0;
1219         ino->mtime_nsec = 0;
1220         ino->uid        = cpu_to_le32(st->st_uid);
1221         ino->gid        = cpu_to_le32(st->st_gid);
1222         ino->compr_type = cpu_to_le16(c->default_compr);
1223         ino->ch.node_type = UBIFS_INO_NODE;
1224
1225         ino_key_init(&nkey, inum);
1226         key_write(&nkey, &ino->key);
1227
1228         ino->size       = cpu_to_le64(data_len);
1229         ino->mode       = cpu_to_le32(S_IFREG);
1230         ino->data_len   = cpu_to_le32(data_len);
1231         ino->flags      = cpu_to_le32(UBIFS_XATTR_FL);
1232
1233         if (data_len)
1234                 memcpy(&ino->data, data, data_len);
1235
1236         ret = add_node(&nkey, NULL, 0, ino, UBIFS_INO_NODE_SZ + data_len);
1237
1238 out:
1239         free(xent);
1240         free(ino);
1241
1242         return ret;
1243 }
1244
1245 #ifdef WITHOUT_XATTR
1246 static inline int create_inum_attr(ino_t inum, const char *name)
1247 {
1248         (void)inum;
1249         (void)name;
1250
1251         return 0;
1252 }
1253
1254 static inline int inode_add_xattr(struct ubifs_ino_node *host_ino,
1255                                   const char *path_name,
1256                                   struct stat *st, ino_t inum)
1257 {
1258         (void)host_ino;
1259         (void)path_name;
1260         (void)st;
1261         (void)inum;
1262
1263         return 0;
1264 }
1265 #else
1266 static int create_inum_attr(ino_t inum, const char *name)
1267 {
1268         char *str;
1269         int ret;
1270
1271         if (!do_create_inum_attr)
1272                 return 0;
1273
1274         ret = asprintf(&str, "%llu", (unsigned long long)inum);
1275         if (ret < 0)
1276                 return ret;
1277
1278         ret = lsetxattr(name, "user.image-inode-number", str, ret, 0);
1279
1280         free(str);
1281
1282         return ret;
1283 }
1284
1285 static int inode_add_xattr(struct ubifs_ino_node *host_ino,
1286                            const char *path_name, struct stat *st, ino_t inum)
1287 {
1288         int ret;
1289         void *buf = NULL;
1290         ssize_t len;
1291         ssize_t pos = 0;
1292
1293         len = llistxattr(path_name, NULL, 0);
1294         if (len < 0) {
1295                 if (errno == ENOENT || errno == EOPNOTSUPP)
1296                         return 0;
1297
1298                 sys_err_msg("llistxattr failed on %s", path_name);
1299
1300                 return len;
1301         }
1302
1303         if (len == 0)
1304                 goto noxattr;
1305
1306         buf = xmalloc(len);
1307
1308         len = llistxattr(path_name, buf, len);
1309         if (len < 0) {
1310                 sys_err_msg("llistxattr failed on %s", path_name);
1311                 goto out_free;
1312         }
1313
1314         while (pos < len) {
1315                 char attrbuf[1024] = { };
1316                 char *name;
1317                 ssize_t attrsize;
1318
1319                 name = buf + pos;
1320                 pos += strlen(name) + 1;
1321
1322                 attrsize = lgetxattr(path_name, name, attrbuf, sizeof(attrbuf) - 1);
1323                 if (attrsize < 0) {
1324                         sys_err_msg("lgetxattr failed on %s", path_name);
1325                         goto out_free;
1326                 }
1327
1328                 if (!strcmp(name, "user.image-inode-number")) {
1329                         ino_t inum_from_xattr;
1330
1331                         inum_from_xattr = strtoull(attrbuf, NULL, 10);
1332                         if (inum != inum_from_xattr) {
1333                                 errno = EINVAL;
1334                                 sys_err_msg("calculated inum (%llu) doesn't match inum from xattr (%llu) size (%zd) on %s",
1335                                             (unsigned long long)inum,
1336                                             (unsigned long long)inum_from_xattr,
1337                                             attrsize,
1338                                             path_name);
1339                                 goto out_free;
1340                         }
1341
1342                         continue;
1343                 }
1344
1345                 ret = add_xattr(host_ino, st, inum, name, attrbuf, attrsize);
1346                 if (ret < 0)
1347                         goto out_free;
1348         }
1349
1350 noxattr:
1351         free(buf);
1352         return 0;
1353
1354 out_free:
1355         free(buf);
1356
1357         return -1;
1358 }
1359 #endif
1360
1361 #ifdef WITH_SELINUX
1362 static int inode_add_selinux_xattr(struct ubifs_ino_node *host_ino,
1363                            const char *path_name, struct stat *st, ino_t inum)
1364 {
1365         int ret;
1366         char *sepath = NULL;
1367         char *name;
1368         struct qstr nm;
1369         unsigned int con_size;
1370
1371         if (!context || !sehnd) {
1372                 secontext = NULL;
1373                 con_size = 0;
1374                 return 0;
1375         }
1376
1377         if (path_name[strlen(root)] == '/')
1378                 sepath = strdup(&path_name[strlen(root)]);
1379
1380         else if (asprintf(&sepath, "/%s", &path_name[strlen(root)]) < 0)
1381                 sepath = NULL;
1382
1383         if (!sepath)
1384                 return sys_err_msg("could not get sepath\n");
1385
1386         if (selabel_lookup(sehnd, &secontext, sepath, st->st_mode) < 0) {
1387                 /* Failed to lookup context, assume unlabeled */
1388                 secontext = strdup("system_u:object_r:unlabeled_t:s0");
1389                 dbg_msg(2, "missing context: %s\t%s\t%d\n", secontext, sepath,
1390                                 st->st_mode);
1391         }
1392
1393         dbg_msg(2, "appling selinux context on sepath=%s, secontext=%s\n",
1394                         sepath, secontext);
1395         free(sepath);
1396         con_size = strlen(secontext) + 1;
1397         name = strdup(XATTR_NAME_SELINUX);
1398
1399         nm.name = name;
1400         nm.len = strlen(name);
1401         host_ino->xattr_cnt++;
1402         host_ino->xattr_size += CALC_DENT_SIZE(nm.len);
1403         host_ino->xattr_size += CALC_XATTR_BYTES(con_size);
1404         host_ino->xattr_names += nm.len;
1405
1406         ret = add_xattr(st, inum, secontext, con_size, &nm);
1407         if (ret < 0)
1408                 dbg_msg(2, "add_xattr failed %d\n", ret);
1409         return ret;
1410 }
1411
1412 #else
1413 static inline int inode_add_selinux_xattr(struct ubifs_ino_node *host_ino,
1414                            const char *path_name, struct stat *st, ino_t inum)
1415 {
1416         (void)host_ino;
1417         (void)path_name;
1418         (void)st;
1419         (void)inum;
1420
1421         return 0;
1422 }
1423 #endif
1424
1425 #ifdef WITH_CRYPTO
1426 static int set_fscrypt_context(struct ubifs_ino_node *host_ino, ino_t inum,
1427                                struct stat *host_st,
1428                                struct fscrypt_context *fctx)
1429 {
1430         return add_xattr(host_ino, host_st, inum,
1431                          xstrdup(UBIFS_XATTR_NAME_ENCRYPTION_CONTEXT),
1432                          fctx, sizeof(*fctx));
1433 }
1434
1435 static int encrypt_symlink(void *dst, void *data, unsigned int data_len,
1436                            struct fscrypt_context *fctx)
1437 {
1438         struct fscrypt_symlink_data *sd;
1439         void *outbuf;
1440         unsigned int link_disk_len;
1441         unsigned int cryptlen;
1442         int ret;
1443
1444         link_disk_len = sizeof(struct fscrypt_symlink_data);
1445         link_disk_len += fscrypt_fname_encrypted_size(fctx, data_len);
1446
1447         ret = encrypt_path(&outbuf, data, data_len, UBIFS_MAX_INO_DATA, fctx);
1448         if (ret < 0)
1449                 return ret;
1450         cryptlen = ret;
1451
1452         sd = xzalloc(link_disk_len);
1453         memcpy(sd->encrypted_path, outbuf, cryptlen);
1454         sd->len = cpu_to_le16(cryptlen);
1455         memcpy(dst, sd, link_disk_len);
1456         ((char *)dst)[link_disk_len - 1] = '\0';
1457
1458         free(outbuf);
1459         free(sd);
1460         return link_disk_len;
1461 }
1462 #else
1463 static int set_fscrypt_context(struct ubifs_ino_node *host_ino, ino_t inum,
1464                                struct stat *host_st,
1465                                struct fscrypt_context *fctx)
1466 {
1467         (void)host_ino;
1468         (void)inum;
1469         (void)host_st;
1470         (void)fctx;
1471
1472         assert(0);
1473         return -1;
1474 }
1475 static int encrypt_symlink(void *dst, void *data, unsigned int data_len,
1476                            struct fscrypt_context *fctx)
1477 {
1478         (void)dst;
1479         (void)data;
1480         (void)data_len;
1481         (void)fctx;
1482
1483         assert(0);
1484         return -1;
1485 }
1486 #endif
1487
1488 /**
1489  * add_inode - write an inode.
1490  * @st: stat information of source inode
1491  * @inum: target inode number
1492  * @data: inode data (for special inodes e.g. symlink path etc)
1493  * @data_len: inode data length
1494  * @flags: source inode flags
1495  */
1496 static int add_inode(struct stat *st, ino_t inum, void *data,
1497                      unsigned int data_len, int flags, const char *xattr_path,
1498                      struct fscrypt_context *fctx)
1499 {
1500         struct ubifs_ino_node *ino = node_buf;
1501         union ubifs_key key;
1502         int len, use_flags = 0, ret;
1503
1504         if (c->default_compr != UBIFS_COMPR_NONE)
1505                 use_flags |= UBIFS_COMPR_FL;
1506         if (flags & FS_COMPR_FL)
1507                 use_flags |= UBIFS_COMPR_FL;
1508         if (flags & FS_SYNC_FL)
1509                 use_flags |= UBIFS_SYNC_FL;
1510         if (flags & FS_IMMUTABLE_FL)
1511                 use_flags |= UBIFS_IMMUTABLE_FL;
1512         if (flags & FS_APPEND_FL)
1513                 use_flags |= UBIFS_APPEND_FL;
1514         if (flags & FS_DIRSYNC_FL && S_ISDIR(st->st_mode))
1515                 use_flags |= UBIFS_DIRSYNC_FL;
1516         if (fctx)
1517                 use_flags |= UBIFS_CRYPT_FL;
1518         memset(ino, 0, UBIFS_INO_NODE_SZ);
1519
1520         ino_key_init(&key, inum);
1521         ino->ch.node_type = UBIFS_INO_NODE;
1522         key_write(&key, &ino->key);
1523         ino->creat_sqnum = cpu_to_le64(creat_sqnum);
1524         ino->size       = cpu_to_le64(st->st_size);
1525         ino->nlink      = cpu_to_le32(st->st_nlink);
1526         /*
1527          * The time fields are updated assuming the default time granularity
1528          * of 1 second. To support finer granularities, utime() would be needed.
1529          */
1530         ino->atime_sec  = cpu_to_le64(st->st_atime);
1531         ino->ctime_sec  = cpu_to_le64(st->st_ctime);
1532         ino->mtime_sec  = cpu_to_le64(st->st_mtime);
1533         ino->atime_nsec = 0;
1534         ino->ctime_nsec = 0;
1535         ino->mtime_nsec = 0;
1536         ino->uid        = cpu_to_le32(st->st_uid);
1537         ino->gid        = cpu_to_le32(st->st_gid);
1538         ino->mode       = cpu_to_le32(st->st_mode);
1539         ino->flags      = cpu_to_le32(use_flags);
1540         ino->compr_type = cpu_to_le16(c->default_compr);
1541         if (data_len) {
1542                 if (!fctx) {
1543                         memcpy(&ino->data, data, data_len);
1544                 } else {
1545                         /* TODO: what about device files? */
1546                         if (!S_ISLNK(st->st_mode))
1547                                 return err_msg("Expected symlink");
1548
1549                         ret = encrypt_symlink(&ino->data, data, data_len, fctx);
1550                         if (ret < 0)
1551                                 return ret;
1552                         data_len = ret;
1553                 }
1554         }
1555         ino->data_len   = cpu_to_le32(data_len);
1556         len = UBIFS_INO_NODE_SZ + data_len;
1557
1558         if (xattr_path) {
1559 #ifdef WITH_SELINUX
1560                 ret = inode_add_selinux_xattr(ino, xattr_path, st, inum);
1561 #else
1562                 ret = inode_add_xattr(ino, xattr_path, st, inum);
1563 #endif
1564                 if (ret < 0)
1565                         return ret;
1566         }
1567
1568         if (fctx) {
1569                 ret = set_fscrypt_context(ino, inum, st, fctx);
1570                 if (ret < 0)
1571                         return ret;
1572         }
1573
1574         return add_node(&key, NULL, 0, ino, len);
1575 }
1576
1577 /**
1578  * add_dir_inode - write an inode for a directory.
1579  * @dir: source directory
1580  * @inum: target inode number
1581  * @size: target directory size
1582  * @nlink: target directory link count
1583  * @st: struct stat object describing attributes (except size and nlink) of the
1584  *      target inode to create
1585  *
1586  * Note, this function may be called with %NULL @dir, when the directory which
1587  * is being created does not exist at the host file system, but is defined by
1588  * the device table.
1589  */
1590 static int add_dir_inode(const char *path_name, DIR *dir, ino_t inum, loff_t size,
1591                          unsigned int nlink, struct stat *st,
1592                          struct fscrypt_context *fctx)
1593 {
1594         int fd, flags = 0;
1595
1596         st->st_size = size;
1597         st->st_nlink = nlink;
1598
1599         if (dir) {
1600                 fd = dirfd(dir);
1601                 if (fd == -1)
1602                         return sys_err_msg("dirfd failed");
1603                 if (ioctl(fd, FS_IOC_GETFLAGS, &flags) == -1)
1604                         flags = 0;
1605         }
1606
1607         return add_inode(st, inum, NULL, 0, flags, path_name, fctx);
1608 }
1609
1610 /**
1611  * add_dev_inode - write an inode for a character or block device.
1612  * @st: stat information of source inode
1613  * @inum: target inode number
1614  * @flags: source inode flags
1615  */
1616 static int add_dev_inode(const char *path_name, struct stat *st, ino_t inum, int flags)
1617 {
1618         union ubifs_dev_desc dev;
1619
1620         dev.huge = cpu_to_le64(makedev(major(st->st_rdev), minor(st->st_rdev)));
1621         return add_inode(st, inum, &dev, 8, flags, path_name, NULL);
1622 }
1623
1624 /**
1625  * add_symlink_inode - write an inode for a symbolic link.
1626  * @path_name: path name of symbolic link inode itself (not the link target)
1627  * @st: stat information of source inode
1628  * @inum: target inode number
1629  * @flags: source inode flags
1630  */
1631 static int add_symlink_inode(const char *path_name, struct stat *st, ino_t inum,
1632                              int flags, struct fscrypt_context *fctx)
1633 {
1634         char buf[UBIFS_MAX_INO_DATA + 2];
1635         ssize_t len;
1636
1637         /* Take the symlink as is */
1638         len = readlink(path_name, buf, UBIFS_MAX_INO_DATA + 1);
1639         if (len <= 0)
1640                 return sys_err_msg("readlink failed for %s", path_name);
1641         if (len > UBIFS_MAX_INO_DATA)
1642                 return err_msg("symlink too long for %s", path_name);
1643
1644         return add_inode(st, inum, buf, len, flags, path_name, fctx);
1645 }
1646
1647 static void set_dent_cookie(struct ubifs_dent_node *dent)
1648 {
1649 #ifdef WITH_CRYPTO
1650         if (c->double_hash)
1651                 RAND_bytes((void *)&dent->cookie, sizeof(dent->cookie));
1652         else
1653 #endif
1654                 dent->cookie = 0;
1655 }
1656
1657 /**
1658  * add_dent_node - write a directory entry node.
1659  * @dir_inum: target inode number of directory
1660  * @name: directory entry name
1661  * @inum: target inode number of the directory entry
1662  * @type: type of the target inode
1663  */
1664 static int add_dent_node(ino_t dir_inum, const char *name, ino_t inum,
1665                          unsigned char type, struct fscrypt_context *fctx)
1666 {
1667         struct ubifs_dent_node *dent = node_buf;
1668         union ubifs_key key;
1669         struct qstr dname;
1670         char *kname;
1671         int kname_len;
1672         int len;
1673
1674         dbg_msg(3, "%s ino %lu type %u dir ino %lu", name, (unsigned long)inum,
1675                 (unsigned int)type, (unsigned long)dir_inum);
1676         memset(dent, 0, UBIFS_DENT_NODE_SZ);
1677
1678         dname.name = (void *)name;
1679         dname.len = strlen(name);
1680
1681         dent->ch.node_type = UBIFS_DENT_NODE;
1682
1683         dent->inum = cpu_to_le64(inum);
1684         dent->padding1 = 0;
1685         dent->type = type;
1686         set_dent_cookie(dent);
1687
1688         if (!fctx) {
1689                 kname_len = dname.len;
1690                 kname = strdup(name);
1691                 if (!kname)
1692                         return err_msg("cannot allocate memory");
1693         } else {
1694                 unsigned int max_namelen = UBIFS_MAX_NLEN;
1695                 int ret;
1696
1697                 if (type == UBIFS_ITYPE_LNK)
1698                         max_namelen = UBIFS_MAX_INO_DATA;
1699
1700                 ret = encrypt_path((void **)&kname, dname.name, dname.len,
1701                                    max_namelen, fctx);
1702                 if (ret < 0)
1703                         return ret;
1704
1705                 kname_len = ret;
1706         }
1707
1708         dent_key_init(c, &key, dir_inum, kname, kname_len);
1709         dent->nlen = cpu_to_le16(kname_len);
1710         memcpy(dent->name, kname, kname_len);
1711         dent->name[kname_len] = '\0';
1712         len = UBIFS_DENT_NODE_SZ + kname_len + 1;
1713
1714         key_write(&key, dent->key);
1715
1716         return add_node(&key, kname, kname_len, dent, len);
1717 }
1718
1719 /**
1720  * lookup_inum_mapping - add an inode mapping for link counting.
1721  * @dev: source device on which source inode number resides
1722  * @inum: source inode number
1723  */
1724 static struct inum_mapping *lookup_inum_mapping(dev_t dev, ino_t inum)
1725 {
1726         struct inum_mapping *im;
1727         unsigned int k;
1728
1729         k = inum % HASH_TABLE_SIZE;
1730         im = hash_table[k];
1731         while (im) {
1732                 if (im->dev == dev && im->inum == inum)
1733                         return im;
1734                 im = im->next;
1735         }
1736         im = xmalloc(sizeof(struct inum_mapping));
1737         im->next = hash_table[k];
1738         im->prev = NULL;
1739         im->dev = dev;
1740         im->inum = inum;
1741         im->use_inum = 0;
1742         im->use_nlink = 0;
1743         if (hash_table[k])
1744                 hash_table[k]->prev = im;
1745         hash_table[k] = im;
1746         return im;
1747 }
1748
1749 /**
1750  * all_zero - does a buffer contain only zero bytes.
1751  * @buf: buffer
1752  * @len: buffer length
1753  */
1754 static int all_zero(void *buf, int len)
1755 {
1756         unsigned char *p = buf;
1757
1758         while (len--)
1759                 if (*p++ != 0)
1760                         return 0;
1761         return 1;
1762 }
1763
1764 /**
1765  * add_file - write the data of a file and its inode to the output file.
1766  * @path_name: source path name
1767  * @st: source inode stat information
1768  * @inum: target inode number
1769  * @flags: source inode flags
1770  */
1771 static int add_file(const char *path_name, struct stat *st, ino_t inum,
1772                     int flags, struct fscrypt_context *fctx)
1773 {
1774         struct ubifs_data_node *dn = node_buf;
1775         void *buf = block_buf;
1776         loff_t file_size = 0;
1777         ssize_t ret, bytes_read;
1778         union ubifs_key key;
1779         int fd, dn_len, err, compr_type, use_compr;
1780         unsigned int block_no = 0;
1781         size_t out_len;
1782
1783         fd = open(path_name, O_RDONLY | O_LARGEFILE);
1784         if (fd == -1)
1785                 return sys_err_msg("failed to open file '%s'", path_name);
1786         do {
1787                 /* Read next block */
1788                 bytes_read = 0;
1789                 do {
1790                         ret = read(fd, buf + bytes_read,
1791                                    UBIFS_BLOCK_SIZE - bytes_read);
1792                         if (ret == -1) {
1793                                 sys_err_msg("failed to read file '%s'",
1794                                             path_name);
1795                                 close(fd);
1796                                 return 1;
1797                         }
1798                         bytes_read += ret;
1799                 } while (ret != 0 && bytes_read != UBIFS_BLOCK_SIZE);
1800                 if (bytes_read == 0)
1801                         break;
1802                 file_size += bytes_read;
1803                 /* Skip holes */
1804                 if (all_zero(buf, bytes_read)) {
1805                         block_no += 1;
1806                         continue;
1807                 }
1808                 /* Make data node */
1809                 memset(dn, 0, UBIFS_DATA_NODE_SZ);
1810                 data_key_init(&key, inum, block_no);
1811                 dn->ch.node_type = UBIFS_DATA_NODE;
1812                 key_write(&key, &dn->key);
1813                 out_len = NODE_BUFFER_SIZE - UBIFS_DATA_NODE_SZ;
1814                 if (c->default_compr == UBIFS_COMPR_NONE &&
1815                     !c->encrypted && (flags & FS_COMPR_FL))
1816 #ifdef WITHOUT_LZO
1817                         use_compr = UBIFS_COMPR_ZLIB;
1818 #else
1819                         use_compr = UBIFS_COMPR_LZO;
1820 #endif
1821                 else
1822                         use_compr = c->default_compr;
1823                 compr_type = compress_data(buf, bytes_read, &dn->data,
1824                                            &out_len, use_compr);
1825                 dn->compr_type = cpu_to_le16(compr_type);
1826                 dn->size = cpu_to_le32(bytes_read);
1827
1828                 if (!fctx) {
1829                         dn->compr_size = 0;
1830                 } else {
1831                         ret = encrypt_data_node(fctx, block_no, dn, out_len);
1832                         if (ret < 0)
1833                                 return ret;
1834                         out_len = ret;
1835                 }
1836
1837                 dn_len = UBIFS_DATA_NODE_SZ + out_len;
1838                 /* Add data node to file system */
1839                 err = add_node(&key, NULL, 0, dn, dn_len);
1840                 if (err) {
1841                         close(fd);
1842                         return err;
1843                 }
1844
1845                 block_no++;
1846         } while (ret != 0);
1847
1848         if (close(fd) == -1)
1849                 return sys_err_msg("failed to close file '%s'", path_name);
1850         if (file_size != st->st_size)
1851                 return err_msg("file size changed during writing file '%s'",
1852                                path_name);
1853
1854         return add_inode(st, inum, NULL, 0, flags, path_name, fctx);
1855 }
1856
1857 /**
1858  * add_non_dir - write a non-directory to the output file.
1859  * @path_name: source path name
1860  * @inum: target inode number is passed and returned here (due to link counting)
1861  * @nlink: number of links if known otherwise zero
1862  * @type: UBIFS inode type is returned here
1863  * @st: struct stat object containing inode attributes which should be use when
1864  *      creating the UBIFS inode
1865  */
1866 static int add_non_dir(const char *path_name, ino_t *inum, unsigned int nlink,
1867                        unsigned char *type, struct stat *st,
1868                        struct fscrypt_context *fctx)
1869 {
1870         int fd, flags = 0;
1871
1872         dbg_msg(2, "%s", path_name);
1873
1874         if (S_ISREG(st->st_mode)) {
1875                 fd = open(path_name, O_RDONLY);
1876                 if (fd == -1)
1877                         return sys_err_msg("failed to open file '%s'",
1878                                            path_name);
1879                 if (ioctl(fd, FS_IOC_GETFLAGS, &flags) == -1)
1880                         flags = 0;
1881                 if (close(fd) == -1)
1882                         return sys_err_msg("failed to close file '%s'",
1883                                            path_name);
1884                 *type = UBIFS_ITYPE_REG;
1885         } else if (S_ISCHR(st->st_mode))
1886                 *type = UBIFS_ITYPE_CHR;
1887         else if (S_ISBLK(st->st_mode))
1888                 *type = UBIFS_ITYPE_BLK;
1889         else if (S_ISLNK(st->st_mode))
1890                 *type = UBIFS_ITYPE_LNK;
1891         else if (S_ISSOCK(st->st_mode))
1892                 *type = UBIFS_ITYPE_SOCK;
1893         else if (S_ISFIFO(st->st_mode))
1894                 *type = UBIFS_ITYPE_FIFO;
1895         else
1896                 return err_msg("file '%s' has unknown inode type", path_name);
1897
1898         if (nlink)
1899                 st->st_nlink = nlink;
1900         else if (st->st_nlink > 1) {
1901                 /*
1902                  * If the number of links is greater than 1, then add this file
1903                  * later when we know the number of links that we actually have.
1904                  * For now, we just put the inode mapping in the hash table.
1905                  */
1906                 struct inum_mapping *im;
1907
1908                 im = lookup_inum_mapping(st->st_dev, st->st_ino);
1909                 if (!im)
1910                         return err_msg("out of memory");
1911                 if (im->use_nlink == 0) {
1912                         /* New entry */
1913                         im->use_inum = *inum;
1914                         im->use_nlink = 1;
1915                         im->path_name = xmalloc(strlen(path_name) + 1);
1916                         strcpy(im->path_name, path_name);
1917                 } else {
1918                         /* Existing entry */
1919                         *inum = im->use_inum;
1920                         im->use_nlink += 1;
1921                         /* Return unused inode number */
1922                         c->highest_inum -= 1;
1923                 }
1924
1925                 memcpy(&im->st, st, sizeof(struct stat));
1926                 return 0;
1927         } else
1928                 st->st_nlink = 1;
1929
1930         creat_sqnum = ++c->max_sqnum;
1931
1932         if (S_ISREG(st->st_mode))
1933                 return add_file(path_name, st, *inum, flags, fctx);
1934         if (S_ISCHR(st->st_mode))
1935                 return add_dev_inode(path_name, st, *inum, flags);
1936         if (S_ISBLK(st->st_mode))
1937                 return add_dev_inode(path_name, st, *inum, flags);
1938         if (S_ISLNK(st->st_mode))
1939                 return add_symlink_inode(path_name, st, *inum, flags, fctx);
1940         if (S_ISSOCK(st->st_mode))
1941                 return add_inode(st, *inum, NULL, 0, flags, NULL, NULL);
1942         if (S_ISFIFO(st->st_mode))
1943                 return add_inode(st, *inum, NULL, 0, flags, NULL, NULL);
1944
1945         return err_msg("file '%s' has unknown inode type", path_name);
1946 }
1947
1948 /**
1949  * add_directory - write a directory tree to the output file.
1950  * @dir_name: directory path name
1951  * @dir_inum: UBIFS inode number of directory
1952  * @st: directory inode statistics
1953  * @existing: zero if this function is called for a directory which
1954  *            does not exist on the host file-system and it is being
1955  *            created because it is defined in the device table file.
1956  */
1957 static int add_directory(const char *dir_name, ino_t dir_inum, struct stat *st,
1958                          int existing, struct fscrypt_context *fctx)
1959 {
1960         struct dirent *entry;
1961         DIR *dir = NULL;
1962         int err = 0;
1963         loff_t size = UBIFS_INO_NODE_SZ;
1964         char *name = NULL;
1965         unsigned int nlink = 2;
1966         struct path_htbl_element *ph_elt;
1967         struct name_htbl_element *nh_elt = NULL;
1968         struct hashtable_itr *itr;
1969         ino_t inum;
1970         unsigned char type;
1971         unsigned long long dir_creat_sqnum = ++c->max_sqnum;
1972
1973         dbg_msg(2, "%s", dir_name);
1974         if (existing) {
1975                 dir = opendir(dir_name);
1976                 if (dir == NULL)
1977                         return sys_err_msg("cannot open directory '%s'",
1978                                            dir_name);
1979         }
1980
1981         /*
1982          * Check whether this directory contains files which should be
1983          * added/changed because they were specified in the device table.
1984          * @ph_elt will be non-zero if yes.
1985          */
1986         ph_elt = devtbl_find_path(dir_name + root_len - 1);
1987
1988         /*
1989          * Before adding the directory itself, we have to iterate over all the
1990          * entries the device table adds to this directory and create them.
1991          */
1992         for (; existing;) {
1993                 struct stat dent_st;
1994                 struct fscrypt_context *new_fctx = NULL;
1995
1996                 errno = 0;
1997                 entry = readdir(dir);
1998                 if (!entry) {
1999                         if (errno == 0)
2000                                 break;
2001                         sys_err_msg("error reading directory '%s'", dir_name);
2002                         err = -1;
2003                         break;
2004                 }
2005
2006                 if (strcmp(".", entry->d_name) == 0)
2007                         continue;
2008                 if (strcmp("..", entry->d_name) == 0)
2009                         continue;
2010
2011                 if (ph_elt)
2012                         /*
2013                          * This directory was referred to at the device table
2014                          * file. Check if this directory entry is referred at
2015                          * too.
2016                          */
2017                         nh_elt = devtbl_find_name(ph_elt, entry->d_name);
2018
2019                 /*
2020                  * We are going to create the file corresponding to this
2021                  * directory entry (@entry->d_name). We use 'struct stat'
2022                  * object to pass information about file attributes (actually
2023                  * only about UID, GID, mode, major, and minor). Get attributes
2024                  * for this file from the UBIFS rootfs on the host.
2025                  */
2026                 free(name);
2027                 name = make_path(dir_name, entry->d_name);
2028                 if (lstat(name, &dent_st) == -1) {
2029                         sys_err_msg("lstat failed for file '%s'", name);
2030                         goto out_free;
2031                 }
2032
2033                 if (squash_owner)
2034                         /*
2035                          * Squash UID/GID. But the device table may override
2036                          * this.
2037                          */
2038                         dent_st.st_uid = dent_st.st_gid = 0;
2039
2040                 /*
2041                  * And if the device table describes the same file, override
2042                  * the attributes. However, this is not allowed for device node
2043                  * files.
2044                  */
2045                 if (nh_elt && override_attributes(&dent_st, ph_elt, nh_elt))
2046                         goto out_free;
2047
2048                 inum = ++c->highest_inum;
2049
2050                 if (fctx)
2051                         new_fctx = inherit_fscrypt_context(fctx);
2052
2053                 if (S_ISDIR(dent_st.st_mode)) {
2054                         err = add_directory(name, inum, &dent_st, 1, new_fctx);
2055                         if (err)
2056                                 goto out_free;
2057                         nlink += 1;
2058                         type = UBIFS_ITYPE_DIR;
2059                 } else {
2060                         err = add_non_dir(name, &inum, 0, &type,
2061                                           &dent_st, new_fctx);
2062                         if (err)
2063                                 goto out_free;
2064                 }
2065
2066                 err = create_inum_attr(inum, name);
2067                 if (err)
2068                         goto out_free;
2069
2070                 err = add_dent_node(dir_inum, entry->d_name, inum, type, fctx);
2071                 if (err)
2072                         goto out_free;
2073                 size += ALIGN(UBIFS_DENT_NODE_SZ + strlen(entry->d_name) + 1,
2074                               8);
2075
2076                 if (new_fctx)
2077                         free_fscrypt_context(new_fctx);
2078         }
2079
2080         /*
2081          * OK, we have created all files in this directory (recursively), let's
2082          * also create all files described in the device table. All t
2083          */
2084         nh_elt = first_name_htbl_element(ph_elt, &itr);
2085         while (nh_elt) {
2086                 struct stat fake_st;
2087                 struct fscrypt_context *new_fctx = NULL;
2088
2089                 /*
2090                  * We prohibit creating regular files using the device table,
2091                  * the device table may only re-define attributes of regular
2092                  * files.
2093                  */
2094                 if (S_ISREG(nh_elt->mode)) {
2095                         err_msg("Bad device table entry %s/%s - it is "
2096                                 "prohibited to create regular files "
2097                                 "via device table",
2098                                 strcmp(ph_elt->path, "/") ? ph_elt->path : "",
2099                                 nh_elt->name);
2100                         goto out_free;
2101                 }
2102
2103                 memcpy(&fake_st, &root_st, sizeof(struct stat));
2104                 fake_st.st_uid  = nh_elt->uid;
2105                 fake_st.st_gid  = nh_elt->gid;
2106                 fake_st.st_mode = nh_elt->mode;
2107                 fake_st.st_rdev = nh_elt->dev;
2108                 fake_st.st_nlink = 1;
2109
2110                 free(name);
2111                 name = make_path(dir_name, nh_elt->name);
2112                 inum = ++c->highest_inum;
2113
2114                 new_fctx = inherit_fscrypt_context(fctx);
2115
2116                 if (S_ISDIR(nh_elt->mode)) {
2117                         err = add_directory(name, inum, &fake_st, 0, new_fctx);
2118                         if (err)
2119                                 goto out_free;
2120                         nlink += 1;
2121                         type = UBIFS_ITYPE_DIR;
2122                 } else {
2123                         err = add_non_dir(name, &inum, 0, &type,
2124                                           &fake_st, new_fctx);
2125                         if (err)
2126                                 goto out_free;
2127                 }
2128
2129                 err = create_inum_attr(inum, name);
2130                 if (err)
2131                         goto out_free;
2132
2133                 err = add_dent_node(dir_inum, nh_elt->name, inum, type, fctx);
2134                 if (err)
2135                         goto out_free;
2136                 size += ALIGN(UBIFS_DENT_NODE_SZ + strlen(nh_elt->name) + 1, 8);
2137
2138                 nh_elt = next_name_htbl_element(ph_elt, &itr);
2139                 if (new_fctx)
2140                         free_fscrypt_context(new_fctx);
2141         }
2142
2143         creat_sqnum = dir_creat_sqnum;
2144
2145         err = add_dir_inode(dir ? dir_name : NULL, dir, dir_inum, size,
2146                             nlink, st, fctx);
2147         if (err)
2148                 goto out_free;
2149
2150         free(name);
2151         if (existing && closedir(dir) == -1)
2152                 return sys_err_msg("error closing directory '%s'", dir_name);
2153
2154         return 0;
2155
2156 out_free:
2157         free(name);
2158         if (existing)
2159                 closedir(dir);
2160         return -1;
2161 }
2162
2163 /**
2164  * add_multi_linked_files - write all the files for which we counted links.
2165  */
2166 static int add_multi_linked_files(void)
2167 {
2168         int i, err;
2169
2170         for (i = 0; i < HASH_TABLE_SIZE; i++) {
2171                 struct inum_mapping *im;
2172                 unsigned char type = 0;
2173
2174                 for (im = hash_table[i]; im; im = im->next) {
2175                         dbg_msg(2, "%s", im->path_name);
2176                         err = add_non_dir(im->path_name, &im->use_inum,
2177                                           im->use_nlink, &type, &im->st, NULL);
2178                         if (err)
2179                                 return err;
2180                 }
2181         }
2182         return 0;
2183 }
2184
2185 /**
2186  * write_data - write the files and directories.
2187  */
2188 static int write_data(void)
2189 {
2190         int err;
2191         mode_t mode = S_IFDIR | S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
2192         struct path_htbl_element *ph_elt;
2193         struct name_htbl_element *nh_elt;
2194
2195         if (root) {
2196                 err = stat(root, &root_st);
2197                 if (err)
2198                         return sys_err_msg("bad root file-system directory '%s'",
2199                                            root);
2200                 if (squash_owner)
2201                         root_st.st_uid = root_st.st_gid = 0;
2202         } else {
2203                 root_st.st_mtime = time(NULL);
2204                 root_st.st_atime = root_st.st_ctime = root_st.st_mtime;
2205                 root_st.st_mode = mode;
2206         }
2207
2208         /*
2209          * Check for root entry and update permissions if it exists. This will
2210          * also remove the entry from the device table list.
2211          */
2212         ph_elt = devtbl_find_path("/");
2213         if (ph_elt) {
2214                 nh_elt = devtbl_find_name(ph_elt, "");
2215                 if (nh_elt && override_attributes(&root_st, ph_elt, nh_elt))
2216                         return -1;
2217         }
2218
2219         head_flags = 0;
2220
2221         err = create_inum_attr(UBIFS_ROOT_INO, root);
2222         if (err)
2223                 return err;
2224
2225         err = add_directory(root, UBIFS_ROOT_INO, &root_st, !!root, root_fctx);
2226         if (err)
2227                 return err;
2228         err = add_multi_linked_files();
2229         if (err)
2230                 return err;
2231         return flush_nodes();
2232 }
2233
2234 static int namecmp(const struct idx_entry *e1, const struct idx_entry *e2)
2235 {
2236         size_t len1 = e1->name_len, len2 = e2->name_len;
2237         size_t clen = (len1 < len2) ? len1 : len2;
2238         int cmp;
2239
2240         cmp = memcmp(e1->name, e2->name, clen);
2241         if (cmp)
2242                 return cmp;
2243         return (len1 < len2) ? -1 : 1;
2244 }
2245
2246 static int cmp_idx(const void *a, const void *b)
2247 {
2248         const struct idx_entry *e1 = *(const struct idx_entry **)a;
2249         const struct idx_entry *e2 = *(const struct idx_entry **)b;
2250         int cmp;
2251
2252         cmp = keys_cmp(&e1->key, &e2->key);
2253         if (cmp)
2254                 return cmp;
2255         return namecmp(e1, e2);
2256 }
2257
2258 /**
2259  * add_idx_node - write an index node to the head.
2260  * @node: index node
2261  * @child_cnt: number of children of this index node
2262  */
2263 static int add_idx_node(void *node, int child_cnt)
2264 {
2265         int err, lnum, offs, len;
2266
2267         len = ubifs_idx_node_sz(c, child_cnt);
2268
2269         prepare_node(node, len);
2270
2271         err = reserve_space(len, &lnum, &offs);
2272         if (err)
2273                 return err;
2274
2275         memcpy(leb_buf + offs, node, len);
2276         memset(leb_buf + offs + len, 0xff, ALIGN(len, 8) - len);
2277
2278         c->old_idx_sz += ALIGN(len, 8);
2279
2280         dbg_msg(3, "at %d:%d len %d index size %llu", lnum, offs, len,
2281                 c->old_idx_sz);
2282
2283         /* The last index node written will be the root */
2284         c->zroot.lnum = lnum;
2285         c->zroot.offs = offs;
2286         c->zroot.len = len;
2287
2288         return 0;
2289 }
2290
2291 /**
2292  * write_index - write out the index.
2293  */
2294 static int write_index(void)
2295 {
2296         size_t sz, i, cnt, idx_sz, pstep, bcnt;
2297         struct idx_entry **idx_ptr, **p;
2298         struct ubifs_idx_node *idx;
2299         struct ubifs_branch *br;
2300         int child_cnt = 0, j, level, blnum, boffs, blen, blast_len, err;
2301
2302         dbg_msg(1, "leaf node count: %zd", idx_cnt);
2303
2304         /* Reset the head for the index */
2305         head_flags = LPROPS_INDEX;
2306         /* Allocate index node */
2307         idx_sz = ubifs_idx_node_sz(c, c->fanout);
2308         idx = xmalloc(idx_sz);
2309         /* Make an array of pointers to sort the index list */
2310         sz = idx_cnt * sizeof(struct idx_entry *);
2311         if (sz / sizeof(struct idx_entry *) != idx_cnt) {
2312                 free(idx);
2313                 return err_msg("index is too big (%zu entries)", idx_cnt);
2314         }
2315         idx_ptr = xmalloc(sz);
2316         idx_ptr[0] = idx_list_first;
2317         for (i = 1; i < idx_cnt; i++)
2318                 idx_ptr[i] = idx_ptr[i - 1]->next;
2319         qsort(idx_ptr, idx_cnt, sizeof(struct idx_entry *), cmp_idx);
2320         /* Write level 0 index nodes */
2321         cnt = idx_cnt / c->fanout;
2322         if (idx_cnt % c->fanout)
2323                 cnt += 1;
2324         p = idx_ptr;
2325         blnum = head_lnum;
2326         boffs = head_offs;
2327         for (i = 0; i < cnt; i++) {
2328                 /*
2329                  * Calculate the child count. All index nodes are created full
2330                  * except for the last index node on each row.
2331                  */
2332                 if (i == cnt - 1) {
2333                         child_cnt = idx_cnt % c->fanout;
2334                         if (child_cnt == 0)
2335                                 child_cnt = c->fanout;
2336                 } else
2337                         child_cnt = c->fanout;
2338                 memset(idx, 0, idx_sz);
2339                 idx->ch.node_type = UBIFS_IDX_NODE;
2340                 idx->child_cnt = cpu_to_le16(child_cnt);
2341                 idx->level = cpu_to_le16(0);
2342                 for (j = 0; j < child_cnt; j++, p++) {
2343                         br = ubifs_idx_branch(c, idx, j);
2344                         key_write_idx(&(*p)->key, &br->key);
2345                         br->lnum = cpu_to_le32((*p)->lnum);
2346                         br->offs = cpu_to_le32((*p)->offs);
2347                         br->len = cpu_to_le32((*p)->len);
2348                 }
2349                 add_idx_node(idx, child_cnt);
2350         }
2351         /* Write level 1 index nodes and above */
2352         level = 0;
2353         pstep = 1;
2354         while (cnt > 1) {
2355                 /*
2356                  * 'blast_len' is the length of the last index node in the level
2357                  * below.
2358                  */
2359                 blast_len = ubifs_idx_node_sz(c, child_cnt);
2360                 /* 'bcnt' is the number of index nodes in the level below */
2361                 bcnt = cnt;
2362                 /* 'cnt' is the number of index nodes in this level */
2363                 cnt = (cnt + c->fanout - 1) / c->fanout;
2364                 if (cnt == 0)
2365                         cnt = 1;
2366                 level += 1;
2367                 /*
2368                  * The key of an index node is the same as the key of its first
2369                  * child. Thus we can get the key by stepping along the bottom
2370                  * level 'p' with an increasing large step 'pstep'.
2371                  */
2372                 p = idx_ptr;
2373                 pstep *= c->fanout;
2374                 for (i = 0; i < cnt; i++) {
2375                         /*
2376                          * Calculate the child count. All index nodes are
2377                          * created full except for the last index node on each
2378                          * row.
2379                          */
2380                         if (i == cnt - 1) {
2381                                 child_cnt = bcnt % c->fanout;
2382                                 if (child_cnt == 0)
2383                                         child_cnt = c->fanout;
2384                         } else
2385                                 child_cnt = c->fanout;
2386                         memset(idx, 0, idx_sz);
2387                         idx->ch.node_type = UBIFS_IDX_NODE;
2388                         idx->child_cnt = cpu_to_le16(child_cnt);
2389                         idx->level = cpu_to_le16(level);
2390                         for (j = 0; j < child_cnt; j++) {
2391                                 size_t bn = i * c->fanout + j;
2392
2393                                 /*
2394                                  * The length of the index node in the level
2395                                  * below is 'idx_sz' except when it is the last
2396                                  * node on the row. i.e. all the others on the
2397                                  * row are full.
2398                                  */
2399                                 if (bn == bcnt - 1)
2400                                         blen = blast_len;
2401                                 else
2402                                         blen = idx_sz;
2403                                 /*
2404                                  * 'blnum' and 'boffs' hold the position of the
2405                                  * index node on the level below.
2406                                  */
2407                                 if (boffs + blen > c->leb_size) {
2408                                         blnum += 1;
2409                                         boffs = 0;
2410                                 }
2411                                 /*
2412                                  * Fill in the branch with the key and position
2413                                  * of the index node from the level below.
2414                                  */
2415                                 br = ubifs_idx_branch(c, idx, j);
2416                                 key_write_idx(&(*p)->key, &br->key);
2417                                 br->lnum = cpu_to_le32(blnum);
2418                                 br->offs = cpu_to_le32(boffs);
2419                                 br->len = cpu_to_le32(blen);
2420                                 /*
2421                                  * Step to the next index node on the level
2422                                  * below.
2423                                  */
2424                                 boffs += ALIGN(blen, 8);
2425                                 p += pstep;
2426                         }
2427                         add_idx_node(idx, child_cnt);
2428                 }
2429         }
2430
2431         /* Free stuff */
2432         for (i = 0; i < idx_cnt; i++) {
2433                 free(idx_ptr[i]->name);
2434                 free(idx_ptr[i]);
2435         }
2436         free(idx_ptr);
2437         free(idx);
2438
2439         dbg_msg(1, "zroot is at %d:%d len %d", c->zroot.lnum, c->zroot.offs,
2440                 c->zroot.len);
2441
2442         /* Set the index head */
2443         c->ihead_lnum = head_lnum;
2444         c->ihead_offs = ALIGN(head_offs, c->min_io_size);
2445         dbg_msg(1, "ihead is at %d:%d", c->ihead_lnum, c->ihead_offs);
2446
2447         /* Flush the last index LEB */
2448         err = flush_nodes();
2449         if (err)
2450                 return err;
2451
2452         return 0;
2453 }
2454
2455 /**
2456  * set_gc_lnum - set the LEB number reserved for the garbage collector.
2457  */
2458 static int set_gc_lnum(void)
2459 {
2460         int err;
2461
2462         c->gc_lnum = head_lnum++;
2463         err = write_empty_leb(c->gc_lnum);
2464         if (err)
2465                 return err;
2466         set_lprops(c->gc_lnum, 0, 0);
2467         c->lst.empty_lebs += 1;
2468         return 0;
2469 }
2470
2471 /**
2472  * finalize_leb_cnt - now that we know how many LEBs we used.
2473  */
2474 static int finalize_leb_cnt(void)
2475 {
2476         c->leb_cnt = head_lnum;
2477         if (c->leb_cnt > c->max_leb_cnt)
2478                 return err_msg("max_leb_cnt too low (%d needed)", c->leb_cnt);
2479         c->main_lebs = c->leb_cnt - c->main_first;
2480         if (verbose) {
2481                 printf("\tsuper lebs:   %d\n", UBIFS_SB_LEBS);
2482                 printf("\tmaster lebs:  %d\n", UBIFS_MST_LEBS);
2483                 printf("\tlog_lebs:     %d\n", c->log_lebs);
2484                 printf("\tlpt_lebs:     %d\n", c->lpt_lebs);
2485                 printf("\torph_lebs:    %d\n", c->orph_lebs);
2486                 printf("\tmain_lebs:    %d\n", c->main_lebs);
2487                 printf("\tgc lebs:      %d\n", 1);
2488                 printf("\tindex lebs:   %d\n", c->lst.idx_lebs);
2489                 printf("\tleb_cnt:      %d\n", c->leb_cnt);
2490         }
2491         dbg_msg(1, "total_free:  %llu", c->lst.total_free);
2492         dbg_msg(1, "total_dirty: %llu", c->lst.total_dirty);
2493         dbg_msg(1, "total_used:  %llu", c->lst.total_used);
2494         dbg_msg(1, "total_dead:  %llu", c->lst.total_dead);
2495         dbg_msg(1, "total_dark:  %llu", c->lst.total_dark);
2496         dbg_msg(1, "index size:  %llu", c->old_idx_sz);
2497         dbg_msg(1, "empty_lebs:  %d", c->lst.empty_lebs);
2498         return 0;
2499 }
2500
2501 static int ubifs_format_version(void)
2502 {
2503         if (c->double_hash || c->encrypted)
2504                 return 5;
2505
2506         /* Default */
2507         return 4;
2508 }
2509
2510 /**
2511  * write_super - write the super block.
2512  */
2513 static int write_super(void)
2514 {
2515         struct ubifs_sb_node sup;
2516
2517         memset(&sup, 0, UBIFS_SB_NODE_SZ);
2518
2519         sup.ch.node_type  = UBIFS_SB_NODE;
2520         sup.key_hash      = c->key_hash_type;
2521         sup.min_io_size   = cpu_to_le32(c->min_io_size);
2522         sup.leb_size      = cpu_to_le32(c->leb_size);
2523         sup.leb_cnt       = cpu_to_le32(c->leb_cnt);
2524         sup.max_leb_cnt   = cpu_to_le32(c->max_leb_cnt);
2525         sup.max_bud_bytes = cpu_to_le64(c->max_bud_bytes);
2526         sup.log_lebs      = cpu_to_le32(c->log_lebs);
2527         sup.lpt_lebs      = cpu_to_le32(c->lpt_lebs);
2528         sup.orph_lebs     = cpu_to_le32(c->orph_lebs);
2529         sup.jhead_cnt     = cpu_to_le32(c->jhead_cnt);
2530         sup.fanout        = cpu_to_le32(c->fanout);
2531         sup.lsave_cnt     = cpu_to_le32(c->lsave_cnt);
2532         sup.fmt_version   = cpu_to_le32(ubifs_format_version());
2533         sup.default_compr = cpu_to_le16(c->default_compr);
2534         sup.rp_size       = cpu_to_le64(c->rp_size);
2535         sup.time_gran     = cpu_to_le32(DEFAULT_TIME_GRAN);
2536         uuid_generate_random(sup.uuid);
2537         if (verbose) {
2538                 char s[40];
2539
2540                 uuid_unparse_upper(sup.uuid, s);
2541                 printf("\tUUID:         %s\n", s);
2542         }
2543         if (c->big_lpt)
2544                 sup.flags |= cpu_to_le32(UBIFS_FLG_BIGLPT);
2545         if (c->space_fixup)
2546                 sup.flags |= cpu_to_le32(UBIFS_FLG_SPACE_FIXUP);
2547         if (c->double_hash)
2548                 sup.flags |= cpu_to_le32(UBIFS_FLG_DOUBLE_HASH);
2549         if (c->encrypted)
2550                 sup.flags |= cpu_to_le32(UBIFS_FLG_ENCRYPTION);
2551
2552         return write_node(&sup, UBIFS_SB_NODE_SZ, UBIFS_SB_LNUM);
2553 }
2554
2555 /**
2556  * write_master - write the master node.
2557  */
2558 static int write_master(void)
2559 {
2560         struct ubifs_mst_node mst;
2561         int err;
2562
2563         memset(&mst, 0, UBIFS_MST_NODE_SZ);
2564
2565         mst.ch.node_type = UBIFS_MST_NODE;
2566         mst.log_lnum     = cpu_to_le32(UBIFS_LOG_LNUM);
2567         mst.highest_inum = cpu_to_le64(c->highest_inum);
2568         mst.cmt_no       = cpu_to_le64(0);
2569         mst.flags        = cpu_to_le32(UBIFS_MST_NO_ORPHS);
2570         mst.root_lnum    = cpu_to_le32(c->zroot.lnum);
2571         mst.root_offs    = cpu_to_le32(c->zroot.offs);
2572         mst.root_len     = cpu_to_le32(c->zroot.len);
2573         mst.gc_lnum      = cpu_to_le32(c->gc_lnum);
2574         mst.ihead_lnum   = cpu_to_le32(c->ihead_lnum);
2575         mst.ihead_offs   = cpu_to_le32(c->ihead_offs);
2576         mst.index_size   = cpu_to_le64(c->old_idx_sz);
2577         mst.lpt_lnum     = cpu_to_le32(c->lpt_lnum);
2578         mst.lpt_offs     = cpu_to_le32(c->lpt_offs);
2579         mst.nhead_lnum   = cpu_to_le32(c->nhead_lnum);
2580         mst.nhead_offs   = cpu_to_le32(c->nhead_offs);
2581         mst.ltab_lnum    = cpu_to_le32(c->ltab_lnum);
2582         mst.ltab_offs    = cpu_to_le32(c->ltab_offs);
2583         mst.lsave_lnum   = cpu_to_le32(c->lsave_lnum);
2584         mst.lsave_offs   = cpu_to_le32(c->lsave_offs);
2585         mst.lscan_lnum   = cpu_to_le32(c->lscan_lnum);
2586         mst.empty_lebs   = cpu_to_le32(c->lst.empty_lebs);
2587         mst.idx_lebs     = cpu_to_le32(c->lst.idx_lebs);
2588         mst.total_free   = cpu_to_le64(c->lst.total_free);
2589         mst.total_dirty  = cpu_to_le64(c->lst.total_dirty);
2590         mst.total_used   = cpu_to_le64(c->lst.total_used);
2591         mst.total_dead   = cpu_to_le64(c->lst.total_dead);
2592         mst.total_dark   = cpu_to_le64(c->lst.total_dark);
2593         mst.leb_cnt      = cpu_to_le32(c->leb_cnt);
2594
2595         err = write_node(&mst, UBIFS_MST_NODE_SZ, UBIFS_MST_LNUM);
2596         if (err)
2597                 return err;
2598
2599         err = write_node(&mst, UBIFS_MST_NODE_SZ, UBIFS_MST_LNUM + 1);
2600         if (err)
2601                 return err;
2602
2603         return 0;
2604 }
2605
2606 /**
2607  * write_log - write an empty log.
2608  */
2609 static int write_log(void)
2610 {
2611         struct ubifs_cs_node cs;
2612         int err, i, lnum;
2613
2614         lnum = UBIFS_LOG_LNUM;
2615
2616         cs.ch.node_type = UBIFS_CS_NODE;
2617         cs.cmt_no = cpu_to_le64(0);
2618
2619         err = write_node(&cs, UBIFS_CS_NODE_SZ, lnum);
2620         if (err)
2621                 return err;
2622
2623         lnum += 1;
2624
2625         for (i = 1; i < c->log_lebs; i++, lnum++) {
2626                 err = write_empty_leb(lnum);
2627                 if (err)
2628                         return err;
2629         }
2630
2631         return 0;
2632 }
2633
2634 /**
2635  * write_lpt - write the LEB properties tree.
2636  */
2637 static int write_lpt(void)
2638 {
2639         int err, lnum;
2640
2641         err = create_lpt(c);
2642         if (err)
2643                 return err;
2644
2645         lnum = c->nhead_lnum + 1;
2646         while (lnum <= c->lpt_last) {
2647                 err = write_empty_leb(lnum++);
2648                 if (err)
2649                         return err;
2650         }
2651
2652         return 0;
2653 }
2654
2655 /**
2656  * write_orphan_area - write an empty orphan area.
2657  */
2658 static int write_orphan_area(void)
2659 {
2660         int err, i, lnum;
2661
2662         lnum = UBIFS_LOG_LNUM + c->log_lebs + c->lpt_lebs;
2663         for (i = 0; i < c->orph_lebs; i++, lnum++) {
2664                 err = write_empty_leb(lnum);
2665                 if (err)
2666                         return err;
2667         }
2668         return 0;
2669 }
2670
2671 /**
2672  * check_volume_empty - check if the UBI volume is empty.
2673  *
2674  * This function checks if the UBI volume is empty by looking if its LEBs are
2675  * mapped or not.
2676  *
2677  * Returns %0 in case of success, %1 is the volume is not empty,
2678  * and a negative error code in case of failure.
2679  */
2680 static int check_volume_empty(void)
2681 {
2682         int lnum, err;
2683
2684         for (lnum = 0; lnum < c->vi.rsvd_lebs; lnum++) {
2685                 err = ubi_is_mapped(out_fd, lnum);
2686                 if (err < 0)
2687                         return err;
2688                 if (err == 1)
2689                         return 1;
2690         }
2691         return 0;
2692 }
2693
2694 /**
2695  * open_target - open the output target.
2696  *
2697  * Open the output target. The target can be an UBI volume
2698  * or a file.
2699  *
2700  * Returns %0 in case of success and %-1 in case of failure.
2701  */
2702 static int open_target(void)
2703 {
2704         if (out_ubi) {
2705                 out_fd = open(output, O_RDWR | O_EXCL);
2706
2707                 if (out_fd == -1)
2708                         return sys_err_msg("cannot open the UBI volume '%s'",
2709                                            output);
2710                 if (ubi_set_property(out_fd, UBI_VOL_PROP_DIRECT_WRITE, 1))
2711                         return sys_err_msg("ubi_set_property failed");
2712
2713                 if (!yes && check_volume_empty()) {
2714                         if (!prompt("UBI volume is not empty.  Format anyways?", false))
2715                                 return err_msg("UBI volume is not empty");
2716                 }
2717         } else {
2718                 out_fd = open(output, O_CREAT | O_RDWR | O_TRUNC,
2719                               S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
2720                 if (out_fd == -1)
2721                         return sys_err_msg("cannot create output file '%s'",
2722                                            output);
2723         }
2724         return 0;
2725 }
2726
2727
2728 /**
2729  * close_target - close the output target.
2730  *
2731  * Close the output target. If the target was an UBI
2732  * volume, also close libubi.
2733  *
2734  * Returns %0 in case of success and %-1 in case of failure.
2735  */
2736 static int close_target(void)
2737 {
2738         if (ubi)
2739                 libubi_close(ubi);
2740         if (out_fd >= 0 && close(out_fd) == -1)
2741                 return sys_err_msg("cannot close the target '%s'", output);
2742         if (output)
2743                 free(output);
2744         return 0;
2745 }
2746
2747 /**
2748  * init - initialize things.
2749  */
2750 static int init(void)
2751 {
2752         int err, i, main_lebs, big_lpt = 0, sz;
2753
2754         c->highest_inum = UBIFS_FIRST_INO;
2755
2756         c->jhead_cnt = 1;
2757
2758         main_lebs = c->max_leb_cnt - UBIFS_SB_LEBS - UBIFS_MST_LEBS;
2759         main_lebs -= c->log_lebs + c->orph_lebs;
2760
2761         err = calc_dflt_lpt_geom(c, &main_lebs, &big_lpt);
2762         if (err)
2763                 return err;
2764
2765         c->main_first = UBIFS_LOG_LNUM + c->log_lebs + c->lpt_lebs +
2766                         c->orph_lebs;
2767         head_lnum = c->main_first;
2768         head_offs = 0;
2769
2770         c->lpt_first = UBIFS_LOG_LNUM + c->log_lebs;
2771         c->lpt_last = c->lpt_first + c->lpt_lebs - 1;
2772
2773         c->lpt = xmalloc(c->main_lebs * sizeof(struct ubifs_lprops));
2774         c->ltab = xmalloc(c->lpt_lebs * sizeof(struct ubifs_lprops));
2775
2776         /* Initialize LPT's own lprops */
2777         for (i = 0; i < c->lpt_lebs; i++) {
2778                 c->ltab[i].free = c->leb_size;
2779                 c->ltab[i].dirty = 0;
2780         }
2781
2782         c->dead_wm = ALIGN(MIN_WRITE_SZ, c->min_io_size);
2783         c->dark_wm = ALIGN(UBIFS_MAX_NODE_SZ, c->min_io_size);
2784         dbg_msg(1, "dead_wm %d  dark_wm %d", c->dead_wm, c->dark_wm);
2785
2786         leb_buf = xmalloc(c->leb_size);
2787         node_buf = xmalloc(NODE_BUFFER_SIZE);
2788         block_buf = xmalloc(UBIFS_BLOCK_SIZE);
2789
2790         sz = sizeof(struct inum_mapping *) * HASH_TABLE_SIZE;
2791         hash_table = xzalloc(sz);
2792
2793         err = init_compression();
2794         if (err)
2795                 return err;
2796
2797 #ifdef WITH_SELINUX
2798         if (context) {
2799                 struct selinux_opt seopts[] = {
2800                         { SELABEL_OPT_PATH, context }
2801                 };
2802
2803                 sehnd = selabel_open(SELABEL_CTX_FILE, seopts, 1);
2804                 if (!sehnd)
2805                         return err_msg("could not open selinux context\n");
2806         }
2807 #endif
2808
2809         return 0;
2810 }
2811
2812 static void destroy_hash_table(void)
2813 {
2814         int i;
2815
2816         for (i = 0; i < HASH_TABLE_SIZE; i++) {
2817                 struct inum_mapping *im, *q;
2818
2819                 for (im = hash_table[i]; im; ) {
2820                         q = im;
2821                         im = im->next;
2822                         free(q->path_name);
2823                         free(q);
2824                 }
2825         }
2826 }
2827
2828 /**
2829  * deinit - deinitialize things.
2830  */
2831 static void deinit(void)
2832 {
2833
2834 #ifdef WITH_SELINUX
2835         if (sehnd)
2836                 selabel_close(sehnd);
2837 #endif
2838
2839         free(c->lpt);
2840         free(c->ltab);
2841         free(leb_buf);
2842         free(node_buf);
2843         free(block_buf);
2844         destroy_hash_table();
2845         free(hash_table);
2846         destroy_compression();
2847         free_devtable_info();
2848 }
2849
2850 /**
2851  * mkfs - make the file system.
2852  *
2853  * Each on-flash area has a corresponding function to create it. The order of
2854  * the functions reflects what information must be known to complete each stage.
2855  * As a consequence the output file is not written sequentially. No effort has
2856  * been made to make efficient use of memory or to allow for the possibility of
2857  * incremental updates to the output file.
2858  */
2859 static int mkfs(void)
2860 {
2861         int err = 0;
2862
2863         err = init();
2864         if (err)
2865                 goto out;
2866
2867         err = write_data();
2868         if (err)
2869                 goto out;
2870
2871         err = set_gc_lnum();
2872         if (err)
2873                 goto out;
2874
2875         err = write_index();
2876         if (err)
2877                 goto out;
2878
2879         err = finalize_leb_cnt();
2880         if (err)
2881                 goto out;
2882
2883         err = write_lpt();
2884         if (err)
2885                 goto out;
2886
2887         err = write_super();
2888         if (err)
2889                 goto out;
2890
2891         err = write_master();
2892         if (err)
2893                 goto out;
2894
2895         err = write_log();
2896         if (err)
2897                 goto out;
2898
2899         err = write_orphan_area();
2900
2901 out:
2902         deinit();
2903         return err;
2904 }
2905
2906 int main(int argc, char *argv[])
2907 {
2908         int err;
2909
2910         if (crypto_init())
2911                 return -1;
2912
2913         err = get_options(argc, argv);
2914         if (err)
2915                 return err;
2916
2917         err = open_target();
2918         if (err)
2919                 return err;
2920
2921         err = mkfs();
2922         if (err) {
2923                 close_target();
2924                 return err;
2925         }
2926
2927         err = close_target();
2928         if (err)
2929                 return err;
2930
2931         if (verbose)
2932                 printf("Success!\n");
2933
2934         crypto_cleanup();
2935         return 0;
2936 }