[VDO-5752] [VDOSTORY-292] Add formatting logic

src/c++/uds/userLinux/build/Makefile

@@ -25,6 +25,7 @@ LIBRARIES =	libuds.a				\
 
 UDS_OBJECTS =	$(notdir $(UDS_COMMON_SOURCES:%.c=%.o))	\
 		bitops.o		\
+		blk-lib.o		\
 		directoryReader.o	\
 		directoryUtils.o	\
 		dm-bufio.o		\

src/c++/uds/userLinux/uds/blk-lib.c

@@ -0,0 +1,50 @@
+/*
+ * %COPYRIGHT%
+ *
+ * %LICENSE%
+ *
+ * $Id$
+ */
+
+#include <linux/blkdev.h>
+#include <linux/err.h>
+
+#include "fileUtils.h"
+#include "logger.h"
+#include "memory-alloc.h"
+#include "errors.h"
+
+int blkdev_issue_zeroout(struct block_device *bdev,
+                         sector_t sector,
+                         sector_t nr_sects,
+                         gfp_t gfp_mask __always_unused ,
+                         unsigned flags __always_unused)
+{
+  int result;
+  off_t offset, length, file_size;
+  void *buffer;
+
+  offset = sector * SECTOR_SIZE;
+  length = nr_sects * SECTOR_SIZE;
+  file_size = bdev->size;
+
+  if ((offset + length) > file_size) {
+    return UDS_OUT_OF_RANGE;
+  }
+
+  result = vdo_allocate(length, u8, __func__, &buffer);
+  if (result != VDO_SUCCESS)
+    return result;
+
+  memset(buffer, 0, length);
+
+  result = write_buffer_at_offset(bdev->fd, offset, buffer, length);
+  if (result != UDS_SUCCESS) {
+    vdo_free(vdo_forget(buffer));
+    return result;
+  }
+
+  result = logging_fsync(bdev->fd, "zero out");
+  vdo_free(vdo_forget(buffer));
+  return result;
+}

src/c++/uds/userLinux/uds/linux/blkdev.h

@@ -1,5 +1,5 @@
 /*
- * Unit test requirements from linux/blkdev.h and other kernel headers.
+ * User mode version of linux/blkdev.h and other kernel headers.
  */
 
 #ifndef LINUX_BLKDEV_H
@@ -92,4 +92,18 @@ static inline loff_t bdev_nr_bytes(struct block_device *bdev)
 	return bdev->size;
 }
 
+/**
+ * blkdev_issue_zeroout - zero-fill a block range
+ * @bdev:	blockdev to write
+ * @sector:	start sector
+ * @nr_sects:	number of sectors to write
+ * @gfp_mask:	memory allocation flags (for bio_alloc)
+ * @flags:	controls detailed behavior
+ *
+ * Description:
+ *  Zero-fill a block range. This is the usermode version of the kernel function.
+ */
+int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
+			 sector_t nr_sects, gfp_t gfp_mask, unsigned flags);
+
 #endif // LINUX_BLKDEV_H

src/c++/uds/userLinux/uds/linux/types.h

@@ -51,4 +51,6 @@ typedef unsigned int fmode_t;
 typedef int pid_t;
 typedef u64 sector_t;
 
+typedef unsigned int gfp_t;
+
 #endif /* UDS_LINUX_TYPES_H */

src/c++/uds/userLinux/uds/linux/uuid.h

@@ -0,0 +1,15 @@
+/*
+ * User mode version of linux/uuid.h.
+ */
+
+#ifndef LINUX_UUID_H
+#define LINUX_UUID_H
+
+#include <uuid/uuid.h>
+
+static inline void uuid_gen(uuid_t *uuid)
+{
+	uuid_generate(*uuid);
+}
+
+#endif // LINUX_UUID_H

src/c++/vdo/base/admin-state.c

@@ -23,6 +23,16 @@ static const struct admin_state_code VDO_CODE_OPERATING = {
 	.operating = true,
 };
 const struct admin_state_code *VDO_ADMIN_STATE_OPERATING = &VDO_CODE_OPERATING;
+static const struct admin_state_code VDO_CODE_KERNEL_FORMATTING = {
+	.name = "VDO_ADMIN_STATE_KERNEL_FORMATTING",
+	.operating = true,
+	.loading = true
+};
+const struct admin_state_code *VDO_ADMIN_STATE_KERNEL_FORMATTING = &VDO_CODE_KERNEL_FORMATTING;
+static const struct admin_state_code VDO_CODE_KERNEL_FORMATTED = {
+	.name = "VDO_ADMIN_STATE_KERNEL_FORMATTED",
+};
+const struct admin_state_code *VDO_ADMIN_STATE_KERNEL_FORMATTED = &VDO_CODE_KERNEL_FORMATTED;
 static const struct admin_state_code VDO_CODE_FORMATTING = {
 	.name = "VDO_ADMIN_STATE_FORMATTING",
 	.operating = true,
@@ -174,8 +184,12 @@ static const struct admin_state_code *get_next_state(const struct admin_state *s
 	if (operation == VDO_ADMIN_STATE_STOPPING)
 		return (code == VDO_ADMIN_STATE_NORMAL_OPERATION ? VDO_ADMIN_STATE_STOPPED : NULL);
 
+	if (operation == VDO_ADMIN_STATE_KERNEL_FORMATTING)
+		return (code == VDO_ADMIN_STATE_INITIALIZED ? VDO_ADMIN_STATE_KERNEL_FORMATTED : NULL);
+
 	if (operation == VDO_ADMIN_STATE_PRE_LOADING)
-		return (code == VDO_ADMIN_STATE_INITIALIZED ? VDO_ADMIN_STATE_PRE_LOADED : NULL);
+		return (((code == VDO_ADMIN_STATE_INITIALIZED) ||
+			 (code == VDO_ADMIN_STATE_KERNEL_FORMATTED)) ? VDO_ADMIN_STATE_PRE_LOADED : NULL);
 
 	if (operation == VDO_ADMIN_STATE_SUSPENDED_OPERATION) {
 		return (((code == VDO_ADMIN_STATE_SUSPENDED) ||

src/c++/vdo/base/admin-state.h

@@ -27,6 +27,8 @@ struct admin_state_code {
 
 extern const struct admin_state_code *VDO_ADMIN_STATE_NORMAL_OPERATION;
 extern const struct admin_state_code *VDO_ADMIN_STATE_OPERATING;
+extern const struct admin_state_code *VDO_ADMIN_STATE_KERNEL_FORMATTING;
+extern const struct admin_state_code *VDO_ADMIN_STATE_KERNEL_FORMATTED;
 extern const struct admin_state_code *VDO_ADMIN_STATE_FORMATTING;
 extern const struct admin_state_code *VDO_ADMIN_STATE_PRE_LOADING;
 extern const struct admin_state_code *VDO_ADMIN_STATE_PRE_LOADED;

src/c++/vdo/base/dm-vdo-target.c

@@ -65,6 +65,10 @@
 
 #endif /* VDO_UPSTREAM */
 enum admin_phases {
+	FORMAT_PHASE_START,
+	FORMAT_PHASE_WRITE_SUPER,
+	FORMAT_PHASE_WRITE_GEOMETRY,
+	FORMAT_PHASE_END,
 	GROW_LOGICAL_PHASE_START,
 	GROW_LOGICAL_PHASE_GROW_BLOCK_MAP,
 	GROW_LOGICAL_PHASE_END,
@@ -117,6 +121,10 @@ enum admin_phases {
 };
 
 static const char * const ADMIN_PHASE_NAMES[] = {
+	"FORMAT_PHASE_START",
+	"FORMAT_PHASE_WRITE_SUPER",
+	"FORMAT_PHASE_WRITE_GEOMETRY",
+	"FORMAT_PHASE_END",
 	"GROW_LOGICAL_PHASE_START",
 	"GROW_LOGICAL_PHASE_GROW_BLOCK_MAP",
 	"GROW_LOGICAL_PHASE_END",
@@ -1702,6 +1710,48 @@ static int __must_check decode_vdo(struct vdo *vdo)
 	return vdo_make_hash_zones(vdo, &vdo->hash_zones);
 }
 
+/**
+ * format_callback() - Callback to initiate a format, registered in vdo_initialize().
+ * @completion: The admin completion.
+ */
+static void format_callback(struct vdo_completion *completion)
+{
+	struct vdo *vdo = completion->vdo;
+	int result;
+
+	assert_admin_phase_thread(vdo, __func__);
+
+	switch (advance_phase(vdo)) {
+	case FORMAT_PHASE_START:
+		result = vdo_start_operation(&vdo->admin.state, VDO_ADMIN_STATE_KERNEL_FORMATTING);
+		if (result != VDO_SUCCESS) {
+			vdo_continue_completion(completion, result);
+			return;
+		}
+
+		vdo_continue_completion(completion, vdo_clear_layout(vdo));
+		return;
+
+	case FORMAT_PHASE_WRITE_SUPER:
+		vdo_save_super_block(vdo, completion);
+		return;
+
+	case FORMAT_PHASE_WRITE_GEOMETRY:
+		vdo_save_geometry_block(vdo, completion);
+		return;
+
+	case FORMAT_PHASE_END:
+		/* Clean up the states layout to prevent corruption during pre-load decode */
+		vdo_uninitialize_layout(&vdo->states.layout);
+		break;
+
+	default:
+		vdo_set_completion_result(completion, UDS_BAD_STATE);
+	}
+
+	finish_operation_callback(completion);
+}
+
 /**
  * pre_load_callback() - Callback to initiate a pre-load, registered in vdo_initialize().
  * @completion: The admin completion.
@@ -1805,6 +1855,20 @@ static int vdo_initialize(struct dm_target *ti, unsigned int instance,
 		return result;
 	}
 
+	if (vdo_get_state(vdo) == VDO_NEW) {
+		result = perform_admin_operation(vdo, FORMAT_PHASE_START, format_callback,
+						 finish_operation_callback, "format");
+		if (result != VDO_SUCCESS) {
+			ti->error = ((result == VDO_INVALID_ADMIN_STATE) ?
+				     "Format is only valid immediately after initialization" :
+				     "Cannot format device");
+			vdo_log_error("Could not format VDO device. (VDO error %d, message %s)",
+				      result, ti->error);
+			vdo_destroy(vdo);
+			return result;
+		}
+	}
+
 	result = perform_admin_operation(vdo, PRE_LOAD_PHASE_START, pre_load_callback,
 					 finish_operation_callback, "pre-load");
 	if (result != VDO_SUCCESS) {

src/c++/vdo/base/status-codes.c

@@ -134,6 +134,8 @@ int vdo_status_to_errno(int error)
 
 	/* VDO or UDS error */
 	switch (error) {
+	case VDO_BAD_CONFIGURATION:
+		return -EINVAL;
 	case VDO_NO_SPACE:
 		return -ENOSPC;
 	case VDO_READ_ONLY: