make_ext4fs: add command-line -u option for UUID

As the ability to easily determine or specify the UUID of the
file-system eases working with some bootloaders, this patch adds
printing of the UUID upon file system creation with the other
information and allows for the UUID to be specified as a command-line
parameter.

Whether specified or automatically generated, the UUID is now printed
with the Label and other creation information.

The parsing of command-line supplied UUIDs is relatively forgiving,
allowing dash-separated values or not.

The default UUID generation remains unchanged as the hash of the
file-system label.

Signed-off-by: Eric Herman <[email protected]>

Author: ericherman

ext4_sb.c

@@ -15,6 +15,7 @@
  */
 
 #include <errno.h>
+#include <string.h>
 
 #include "ext4_sb.h"
 
@@ -38,6 +39,7 @@ int ext4_parse_sb(struct ext4_super_block *sb, struct fs_info *info)
 	info->feat_incompat = sb->s_feature_incompat;
 	info->bg_desc_reserve_blocks = sb->s_reserved_gdt_blocks;
 	info->label = sb->s_volume_name;
+	memcpy(info->uuid, sb->s_uuid, 16);
 
 	len_blocks = ((uint64_t)sb->s_blocks_count_hi << 32) +
                 sb->s_blocks_count_lo;

ext4_sb.h

@@ -42,6 +42,7 @@ struct fs_info {
 	uint32_t reserve_pcnt;
 	const char *label;
 	uint8_t no_journal;
+	uint8_t uuid[16];
 };
 
 int ext4_parse_sb(struct ext4_super_block *sb, struct fs_info *info);

ext4_utils.c

@@ -15,13 +15,14 @@
  */
 
 #include "ext4_utils.h"
-#include "uuid.h"
 #include "allocate.h"
 #include "indirect.h"
 #include "extent.h"
 
 #include <sparse/sparse.h>
 
+#include <assert.h>
+#include <ctype.h>
 #include <fcntl.h>
 #include <inttypes.h>
 #include <sys/stat.h>
@@ -42,6 +43,7 @@ int force = 0;
 struct fs_info info;
 struct fs_aux_info aux_info;
 struct sparse_file *ext4_sparse_file;
+int uuid_user_specified = 0;
 
 jmp_buf setjmp_env;
 
@@ -221,7 +223,7 @@ void ext4_fill_in_sb()
 	sb->s_feature_compat = info.feat_compat;
 	sb->s_feature_incompat = info.feat_incompat;
 	sb->s_feature_ro_compat = info.feat_ro_compat;
-	generate_uuid("extandroid/make_ext4fs", info.label, sb->s_uuid);
+	memcpy(sb->s_uuid, info.uuid, 16);
 	memset(sb->s_volume_name, 0, sizeof(sb->s_volume_name));
 	strncpy(sb->s_volume_name, info.label, sizeof(sb->s_volume_name));
 	memset(sb->s_last_mounted, 0, sizeof(sb->s_last_mounted));
@@ -490,10 +492,86 @@ u64 parse_num(const char *arg)
 	return num;
 }
 
+static char nibble_to_hex_char(uint8_t nibble)
+{
+	const char *hexchars = "0123456789abcdef";
+
+	assert(nibble < 16);
+
+	return hexchars[nibble];
+}
+
+static uint8_t hex_char_to_nibble(char c)
+{
+	assert(isxdigit(c));
+
+	if (c >= '0' && c <= '9') {
+		return c - '0';
+	}
+
+	if (c >= 'a' && c <= 'f') {
+		return 10 + c - 'a';
+	}
+
+	assert(c >= 'A' && c <= 'F');
+	return 10 + c - 'A';
+}
+
+uint8_t *parse_uuid(uint8_t bytes[16], const char *str, size_t len)
+{
+	size_t i, pos;
+	uint8_t hi_nibble, lo_nibble;
+
+	assert(str);
+
+	for (i = 0, pos = 0; i < 16; ++i) {
+		while (pos < len && (ispunct(str[pos]) || isspace(str[pos]))) {
+			++pos;
+		}
+
+		if (pos >= len || !isxdigit(str[pos])) {
+			return NULL;
+		}
+		hi_nibble = hex_char_to_nibble(str[pos++]);
+
+		if (pos >= len || !isxdigit(str[pos])) {
+			return NULL;
+		}
+		lo_nibble = hex_char_to_nibble(str[pos++]);
+
+		bytes[i] = ((hi_nibble << 4) | lo_nibble);
+	}
+	return bytes;
+}
+
+/* 00000000-0000-0000-0000-000000000000 */
+char *uuid_bin_to_str(char *buf, size_t buf_size, const uint8_t bytes[16])
+{
+	const size_t uuid_str_size = ((16 * 2) + 4) + 1;
+	size_t i, pos;
+	uint8_t hi_nibble, lo_nibble;
+
+	assert(buf);
+	assert(buf_size >= uuid_str_size);
+
+	memset(buf, 0x00, buf_size);
+	for (i = 0, pos = 0; i < 16; ++i) {
+		hi_nibble = ((bytes[i] & 0xF0) >> 4);
+		lo_nibble = (bytes[i] & 0x0F);
+		buf[pos++] = nibble_to_hex_char(hi_nibble);
+		buf[pos++] = nibble_to_hex_char(lo_nibble);
+		if (i == 3 || i == 5 || i == 7 || i == 9) {
+			buf[pos++] = '-';
+		}
+	}
+	return buf;
+}
+
 int read_ext(int fd, int verbose)
 {
 	off_t ret;
 	struct ext4_super_block sb;
+	char buf[40];
 
 	read_sb(fd, &sb);
 
@@ -521,6 +599,7 @@ int read_ext(int fd, int verbose)
 		printf("    Inodes per group: %d\n", info.inodes_per_group);
 		printf("    Inode size: %d\n", info.inode_size);
 		printf("    Label: %s\n", info.label);
+		printf("    UUID: %s\n", uuid_bin_to_str(buf, sizeof(buf), info.uuid));
 		printf("    Blocks: %"PRIu64"\n", aux_info.len_blocks);
 		printf("    Block groups: %d\n", aux_info.groups);
 		printf("    Reserved block group size: %d\n", info.bg_desc_reserve_blocks);

ext4_utils.h

@@ -113,6 +113,7 @@ struct fs_aux_info {
 extern struct fs_info info;
 extern struct fs_aux_info aux_info;
 extern struct sparse_file *ext4_sparse_file;
+extern int uuid_user_specified;
 
 extern jmp_buf setjmp_env;
 
@@ -145,6 +146,8 @@ u64 get_file_size(int fd);
 u64 parse_num(const char *arg);
 void ext4_parse_sb_info(struct ext4_super_block *sb);
 u16 ext4_crc16(u16 crc_in, const void *buf, int size);
+uint8_t *parse_uuid(uint8_t bytes[16], const char *str, size_t len);
+char *uuid_bin_to_str(char *buf, size_t buf_size, const uint8_t bytes[16]);
 
 typedef int (*fs_config_func_t)(const char *path, int dir, unsigned *uid, unsigned *gid,
 		unsigned *mode, uint64_t *capabilities);

make_ext4fs.c

@@ -384,6 +384,7 @@ int make_ext4fs_internal(int fd, const char *_directory,
 	u32 root_inode_num;
 	u16 root_mode;
 	char *directory = NULL;
+	char buf[40];
 
 	if (setjmp(setjmp_env))
 		return EXIT_FAILURE; /* Handle a call to longjmp() */
@@ -443,6 +444,10 @@ int make_ext4fs_internal(int fd, const char *_directory,
 
 	info.bg_desc_reserve_blocks = compute_bg_desc_reserve_blocks();
 
+	if (!uuid_user_specified) {
+		generate_uuid("extandroid/make_ext4fs", info.label, info.uuid);
+	}
+
 	printf("Creating filesystem with parameters:\n");
 	printf("    Size: %"PRIu64"\n", info.len);
 	printf("    Block size: %d\n", info.block_size);
@@ -451,6 +456,7 @@ int make_ext4fs_internal(int fd, const char *_directory,
 	printf("    Inode size: %d\n", info.inode_size);
 	printf("    Journal blocks: %d\n", info.journal_blocks);
 	printf("    Label: %s\n", info.label);
+	printf("    UUID: %s\n", uuid_bin_to_str(buf, sizeof(buf), info.uuid));
 
 	ext4_create_fs_aux_info();
 

make_ext4fs_main.c

@@ -29,13 +29,14 @@
 #include "canned_fs_config.h"
 
 extern struct fs_info info;
+extern int uuid_user_specified;
 
 
 static void usage(char *path)
 {
 	fprintf(stderr, "%s [ -l <len> ] [ -j <journal size> ] [ -b <block_size> ]\n", basename(path));
 	fprintf(stderr, "    [ -g <blocks per group> ] [ -i <inodes> ] [ -I <inode size> ]\n");
-	fprintf(stderr, "    [ -m <reserved blocks percent> ] [ -L <label> ] [ -f ]\n");
+	fprintf(stderr, "    [ -m <reserved blocks percent> ] [ -L <label> ] [ -u <uuid>] [ -f ]\n");
 	fprintf(stderr, "    [ -S file_contexts ] [ -C fs_config ] [ -T timestamp ]\n");
 	fprintf(stderr, "    [ -z | -s ] [ -w ] [ -c ] [ -J ] [ -v ] [ -B <block_list_file> ]\n");
 	fprintf(stderr, "    <filename> [<directory>]\n");
@@ -58,7 +59,7 @@ int main(int argc, char **argv)
 	time_t fixed_time = -1;
 	FILE* block_list_file = NULL;
 
-	while ((opt = getopt(argc, argv, "l:j:b:g:i:I:L:T:C:B:m:fwzJsctv")) != -1) {
+	while ((opt = getopt(argc, argv, "l:j:b:g:i:I:L:u:T:C:B:m:fwzJsctv")) != -1) {
 		switch (opt) {
 		case 'l':
 			info.len = parse_num(optarg);
@@ -81,6 +82,14 @@ int main(int argc, char **argv)
 		case 'L':
 			info.label = optarg;
 			break;
+		case 'u':
+			if (!parse_uuid(info.uuid, optarg, strlen(optarg))) {
+				fprintf(stderr, "failed to parse UUID: '%s'\n",
+					optarg);
+				exit(EXIT_FAILURE);
+			}
+			uuid_user_specified = 1;
+			break;
 		case 'f':
 			force = 1;
 			break;