diff --git a/system/ulib/blkctl/blkctl.cpp b/system/ulib/blkctl/blkctl.cpp
index 41b5267..c62c8c2 100644
--- a/system/ulib/blkctl/blkctl.cpp
+++ b/system/ulib/blkctl/blkctl.cpp
@@ -16,6 +16,7 @@
 #include <zircon/errors.h>
 #include <zircon/types.h>
 
+#include "fvm.h"
 #include "generic.h"
 #include "ramdisk.h"
 
@@ -40,6 +41,7 @@
 // Then simply #include the appropriate header and add a DEVICE_TYPE to the list below.
 constexpr CmdType kTypes[] = {
     ADD_CMD_TYPE(ramdisk),
+    ADD_CMD_TYPE(fvm),
     // The generic commands should be last, so that various routines use them if no type matches
     ADD_CMD_TYPE(generic),
 };
diff --git a/system/ulib/blkctl/fvm.cpp b/system/ulib/blkctl/fvm.cpp
new file mode 100644
index 0000000..ef58ebd
--- /dev/null
+++ b/system/ulib/blkctl/fvm.cpp
@@ -0,0 +1,345 @@
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <fcntl.h>
+#include <inttypes.h>
+#include <stddef.h>
+#include <stdio.h>
+
+#include <blkctl/blkctl.h>
+#include <blkctl/command.h>
+#include <fs-management/fvm.h>
+#include <fs-management/ramdisk.h>
+#include <fvm/fvm.h>
+#include <lib/zx/time.h>
+#include <zircon/device/block.h>
+#include <zircon/device/device.h>
+#include <zircon/errors.h>
+#include <zircon/status.h>
+#include <zircon/types.h>
+
+#include "fvm.h"
+#include "generic.h"
+
+namespace blkctl {
+namespace fvm {
+namespace {
+
+bool SupportsFvmQuery(int fd) {
+    if (fd < 0) {
+        return false;
+    }
+    fvm_info_t info;
+    memset(&info, 0, sizeof(info));
+    return ioctl_block_fvm_query(fd, &info) != ZX_ERR_NOT_SUPPORTED;
+}
+
+bool SupportsFvmVSliceQuery(int fd) {
+    if (fd < 0) {
+        return false;
+    }
+    query_request_t request;
+    query_response_t response;
+    memset(&request, 0, sizeof(request));
+    memset(&response, 0, sizeof(response));
+    return ioctl_block_fvm_vslice_query(fd, &request, &response) != ZX_ERR_NOT_SUPPORTED;
+}
+
+zx_status_t CheckFvm(int fd) {
+    if (!SupportsFvmQuery(fd) && !SupportsFvmVSliceQuery(fd)) {
+        fprintf(stderr, "device does not appear to be an FVM volume or partition\n");
+        return ZX_ERR_INVALID_ARGS;
+    }
+    return ZX_OK;
+}
+
+zx_status_t CheckFvmVolume(int fd) {
+    if (!SupportsFvmQuery(fd)) {
+        fprintf(stderr, "device does not appear to be an FVM volume\n");
+        return ZX_ERR_INVALID_ARGS;
+    }
+    return ZX_OK;
+}
+
+zx_status_t CheckFvmPartition(int fd) {
+    if (!SupportsFvmVSliceQuery(fd)) {
+        fprintf(stderr, "device does not appear to be an FVM partition\n");
+        return ZX_ERR_INVALID_ARGS;
+    }
+    return ZX_OK;
+}
+
+} // namespace
+
+zx_status_t Init::Run() {
+    zx_status_t rc;
+    ssize_t res;
+    BlkCtl* cmdline = this->cmdline();
+
+    const char* dev;
+    int fd;
+    size_t slice_size;
+    if ((rc = cmdline->GetStrArg("device", &dev)) != ZX_OK ||
+        (rc = cmdline->GetNumArg("slice_size", &slice_size)) != ZX_OK ||
+        (rc = cmdline->ArgsDone()) != ZX_OK || (rc = OpenReadable(dev, &fd)) != ZX_OK) {
+        return rc;
+    }
+    char path[PATH_MAX];
+    if ((res = ioctl_device_get_topo_path(fd, path, sizeof(path))) < 0) {
+        rc = static_cast<zx_status_t>(res);
+        fprintf(stderr, "failed to get topological path: %s\n", zx_status_get_string(rc));
+        return rc;
+    }
+    if ((rc = cmdline->Confirm()) != ZX_OK || (rc = ReopenWritable(&fd)) != ZX_OK) {
+        return rc;
+    }
+    if ((rc = fvm_init(fd, slice_size)) != ZX_OK) {
+        fprintf(stderr, "fvm_init failed: %s\n", zx_status_get_string(rc));
+        return rc;
+    }
+    if ((res = ioctl_device_bind(fd, kDriver, strlen(kDriver))) < 0) {
+        rc = static_cast<zx_status_t>(res);
+        fprintf(stderr, "could not bind fvm driver: %s\n", zx_status_get_string(rc));
+        return rc;
+    }
+    char name[PATH_MAX];
+    snprintf(name, sizeof(name), "%s/fvm", path);
+    if (wait_for_device(name, zx::sec(3).get()) != 0) {
+        fprintf(stderr, "timed out waiting for fvm driver to bind\n");
+        return ZX_ERR_TIMED_OUT;
+    }
+    printf("%s created\n", name);
+    return ZX_OK;
+}
+
+zx_status_t Dump::Run() {
+    zx_status_t rc;
+    ssize_t res;
+    BlkCtl* cmdline = this->cmdline();
+
+    const char* dev;
+    int fd;
+    fvm_info_t info;
+    if ((rc = cmdline->GetStrArg("device", &dev)) != ZX_OK || (rc = cmdline->ArgsDone()) != ZX_OK ||
+        (rc = OpenReadable(dev, &fd)) != ZX_OK || (rc = CheckFvm(fd)) != ZX_OK) {
+        return rc;
+    }
+    if ((res = ioctl_block_fvm_query(fd, &info)) < 0) {
+        rc = static_cast<zx_status_t>(res);
+        fprintf(stderr, "ioctl_block_fvm_query failed: %s\n", zx_status_get_string(rc));
+        return rc;
+    }
+    generic::Dump baseCmd(cmdline);
+    if ((rc = cmdline->UngetArgs(1)) != ZX_OK || (rc = baseCmd.Run()) != ZX_OK) {
+        return rc;
+    }
+    printf("%16s: %zu\n", "FVM slice size", info.slice_size);
+    printf("%16s: %zu\n", "FVM slice count", info.vslice_count);
+    return ZX_OK;
+}
+
+zx_status_t Add::Run() {
+    zx_status_t rc;
+    ssize_t res;
+    BlkCtl* cmdline = this->cmdline();
+
+    const char* dev;
+    int fd;
+    alloc_req_t request;
+    memset(&request, 0, sizeof(request));
+    const char* name;
+    if ((rc = cmdline->GetStrArg("device", &dev)) != ZX_OK ||
+        (rc = cmdline->GetStrArg("name", &name)) != ZX_OK ||
+        (rc = cmdline->GetNumArg("slices", &request.slice_count)) != ZX_OK) {
+        return rc;
+    }
+    const char* guid;
+
+    rc = cmdline->GetStrArg("guid", &guid, true /* optional */);
+
+    if (rc == ZX_ERR_NOT_FOUND) {
+        GenerateGuid(request.type, sizeof(request.type));
+    } else if (rc != ZX_OK || (rc = ParseGuid(guid, request.type, sizeof(request.type))) != ZX_OK) {
+        return rc;
+    }
+    if ((rc = cmdline->ArgsDone()) != ZX_OK ||
+        (rc = OpenReadable(dev, &fd)) != ZX_OK || (rc = CheckFvmVolume(fd)) != ZX_OK ||
+        (rc = cmdline->Confirm()) != ZX_OK || (rc = ReopenWritable(&fd)) != ZX_OK) {
+        return rc;
+    }
+
+    GenerateGuid(request.guid, sizeof(request.guid));
+    if ((res = ioctl_block_fvm_alloc_partition(fd, &request)) < 0) {
+        rc = static_cast<zx_status_t>(res);
+        fprintf(stderr, "ioctl_block_fvm_alloc_partition failed: %s\n", zx_status_get_string(rc));
+        return rc;
+    }
+    printf("added partition '%s' as ", name);
+    PrintGuid(request.guid, sizeof(request.guid));
+    printf("\n");
+    return ZX_OK;
+}
+
+zx_status_t Query::Run() {
+    zx_status_t rc;
+    ssize_t res;
+    BlkCtl* cmdline = this->cmdline();
+
+    const char* dev;
+    int fd;
+    if ((rc = cmdline->GetStrArg("device", &dev)) != ZX_OK || (rc = cmdline->ArgsDone()) != ZX_OK ||
+        (rc = OpenReadable(dev, &fd)) != ZX_OK || (rc = CheckFvmPartition(fd)) != ZX_OK) {
+        return rc;
+    }
+    fvm_info_t info;
+    if ((res = ioctl_block_fvm_query(fd, &info)) < 0) {
+        rc = static_cast<zx_status_t>(res);
+        fprintf(stderr, "ioctl_block_fvm_query failed: %s\n", zx_status_get_string(rc));
+        return rc;
+    }
+    query_request_t request;
+    query_response_t response;
+    request.count = 1;
+    printf("Allocated ranges:\n");
+    size_t end = 0;
+    for (size_t off = 0; off < info.vslice_count; off = end) {
+        request.vslice_start[0] = off;
+        if ((res = ioctl_block_fvm_vslice_query(fd, &request, &response)) < 0) {
+            rc = static_cast<zx_status_t>(res);
+            fprintf(stderr, "ioctl_block_fvm_vslice_query failed: %s\n", zx_status_get_string(rc));
+            return rc;
+        }
+        ZX_DEBUG_ASSERT(response.count == 1);
+        ZX_DEBUG_ASSERT(response.vslice_range[0].count != 0);
+        end = off + response.vslice_range[0].count;
+        if (response.vslice_range[0].allocated) {
+            printf("  <0x%016" PRIx64 ", 0x%016" PRIx64 ">:   slices %zu through %zu\n",
+                   static_cast<uint64_t>(off * info.slice_size),
+                   static_cast<uint64_t>((end * info.slice_size) - 1), off, end);
+        }
+    }
+    return ZX_OK;
+}
+
+zx_status_t Extend::Run() {
+    zx_status_t rc;
+    ssize_t res;
+    BlkCtl* cmdline = this->cmdline();
+
+    const char* dev;
+    int fd;
+    extend_request_t request;
+    if ((rc = cmdline->GetStrArg("device", &dev)) != ZX_OK ||
+        (rc = cmdline->GetNumArg("start", &request.offset)) != ZX_OK ||
+        (rc = cmdline->GetNumArg("length", &request.length)) != ZX_OK ||
+        (rc = cmdline->ArgsDone()) != ZX_OK || (rc = OpenReadable(dev, &fd)) != ZX_OK ||
+        (rc = CheckFvmPartition(fd)) != ZX_OK) {
+        return rc;
+    }
+    if ((rc = cmdline->Confirm()) != ZX_OK || (rc = ReopenWritable(&fd)) != ZX_OK) {
+        return rc;
+    }
+    if ((res = ioctl_block_fvm_extend(fd, &request)) < 0) {
+        fprintf(stderr, "ioctl_block_fvm_extend failed: %s\n", zx_status_get_string(rc));
+        rc = static_cast<zx_status_t>(res);
+        return rc;
+    }
+    printf("partition extended\n");
+    return ZX_OK;
+}
+
+zx_status_t Shrink::Run() {
+    zx_status_t rc;
+    ssize_t res;
+    BlkCtl* cmdline = this->cmdline();
+
+    const char* dev;
+    int fd;
+    extend_request_t request;
+    if ((rc = cmdline->GetStrArg("device", &dev)) != ZX_OK ||
+        (rc = cmdline->GetNumArg("start", &request.offset)) != ZX_OK ||
+        (rc = cmdline->GetNumArg("length", &request.length)) != ZX_OK ||
+        (rc = cmdline->ArgsDone()) != ZX_OK || (rc = OpenReadable(dev, &fd)) != ZX_OK ||
+        (rc = CheckFvmPartition(fd)) != ZX_OK) {
+        return rc;
+    }
+    if ((rc = cmdline->Confirm()) != ZX_OK || (rc = ReopenWritable(&fd)) != ZX_OK) {
+        return rc;
+    }
+    if ((res = ioctl_block_fvm_shrink(fd, &request)) < 0) {
+        rc = static_cast<zx_status_t>(res);
+        fprintf(stderr, "ioctl_block_fvm_shrink failed: %s\n", zx_status_get_string(rc));
+        return rc;
+    }
+    printf("partition shrunk\n");
+    return ZX_OK;
+}
+
+zx_status_t Remove::Run() {
+    zx_status_t rc;
+    ssize_t res;
+    BlkCtl* cmdline = this->cmdline();
+
+    const char* dev;
+    int fd;
+    if ((rc = cmdline->GetStrArg("device", &dev)) != ZX_OK || (rc = cmdline->ArgsDone()) != ZX_OK ||
+        (rc = OpenReadable(dev, &fd)) != ZX_OK || (rc = CheckFvmPartition(fd)) != ZX_OK) {
+        return rc;
+    }
+    if ((rc = cmdline->Confirm()) != ZX_OK || (rc = ReopenWritable(&fd)) != ZX_OK) {
+        return rc;
+    }
+    if ((res = ioctl_block_fvm_destroy_partition(fd)) < 0) {
+        rc = static_cast<zx_status_t>(res);
+        fprintf(stderr, "ioctl_block_fvm_destroy_partition failed: %s\n", zx_status_get_string(rc));
+        return rc;
+    }
+    printf("partition removed\n");
+    return ZX_OK;
+}
+
+zx_status_t Destroy::Run() {
+    zx_status_t rc;
+    ssize_t res;
+    BlkCtl* cmdline = this->cmdline();
+
+    const char* dev;
+    int fd;
+    if ((rc = cmdline->GetStrArg("device", &dev)) != ZX_OK || (rc = cmdline->ArgsDone()) != ZX_OK ||
+        (rc = OpenReadable(dev, &fd)) != ZX_OK) {
+        return rc;
+    }
+    char path[PATH_MAX];
+    constexpr const char* suffix = "/fvm";
+    ZX_DEBUG_ASSERT(strlen(suffix) < sizeof(path));
+    size_t path_max = sizeof(path) - (strlen(suffix) + 1);
+    if ((res = ioctl_device_get_topo_path(fd, path, path_max)) < 0) {
+        rc = static_cast<zx_status_t>(res);
+        fprintf(stderr, "failed to get topological path: %s\n", zx_status_get_string(rc));
+        return rc;
+    }
+    strcat(path, suffix); // Safe to due to size limit above
+    fbl::unique_fd fvm_fd(open(path, O_RDONLY));
+    if ((rc = CheckFvmVolume(fvm_fd.get())) != ZX_OK) {
+        return rc;
+    }
+    fvm_fd.reset();
+    if ((rc = cmdline->Confirm()) != ZX_OK || (rc = ReopenWritable(&fd)) != ZX_OK) {
+        return rc;
+    }
+    if ((rc = fvm_destroy(devname())) != ZX_OK) {
+        fprintf(stderr, "fvm_destroy failed\n");
+        return rc;
+    }
+    if ((res = ioctl_block_rr_part(fd)) < 0) {
+        rc = static_cast<zx_status_t>(res);
+        fprintf(stderr, "failed to unbind FVM driver: %s\n", zx_status_get_string(rc));
+        return rc;
+    }
+    printf("FVM volume metadata destroyed\n");
+    return ZX_OK;
+}
+
+} // namespace fvm
+} // namespace blkctl
diff --git a/system/ulib/blkctl/fvm.h b/system/ulib/blkctl/fvm.h
new file mode 100644
index 0000000..2fc4aa6
--- /dev/null
+++ b/system/ulib/blkctl/fvm.h
@@ -0,0 +1,38 @@
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <blkctl/command.h>
+
+namespace blkctl {
+namespace fvm {
+
+DEFINE_COMMAND(Init);
+DEFINE_COMMAND(Dump);
+DEFINE_COMMAND(Add);
+DEFINE_COMMAND(Query);
+DEFINE_COMMAND(Extend);
+DEFINE_COMMAND(Shrink);
+DEFINE_COMMAND(Remove);
+DEFINE_COMMAND(Destroy);
+
+constexpr const char* kType = "fvm";
+
+constexpr Cmd kCommands[] = {
+    {"init", "<device> <slice_size>", "Format a block device to be an empty FVM volume.", Instantiate<Init>},
+    {"dump", "<device>", "Dump block device and FVM volume information.", Instantiate<Dump>},
+    {"add", "<device> <name> <slices> [type-guid]", "Allocates a new partition in the FVM volume.", Instantiate<Add>},
+    {"query", "<device>", "List ranges of allocated slices.", Instantiate<Query>},
+    {"extend", "<device> <start> <length>", "Allocates slices for the partition.", Instantiate<Extend>},
+    {"shrink", "<device> <start> <length>", "Free slices from the partition.", Instantiate<Shrink>},
+    {"remove", "<device>", "Removes partition from the FVM volume.", Instantiate<Remove>},
+    {"destroy", "<device>", "Overwrites and unbinds an FVM volume.", Instantiate<Destroy>},
+};
+constexpr size_t kNumCommands = sizeof(kCommands) / sizeof(kCommands[0]);
+
+constexpr const char *kDriver = "/boot/driver/fvm.so";
+
+} // namespace fvm
+} // namespace blkctl
diff --git a/system/ulib/blkctl/rules.mk b/system/ulib/blkctl/rules.mk
index 2a61007..ab9d488 100644
--- a/system/ulib/blkctl/rules.mk
+++ b/system/ulib/blkctl/rules.mk
@@ -15,6 +15,7 @@
     $(LOCAL_DIR)/command.cpp \
     $(LOCAL_DIR)/generic.cpp \
     $(LOCAL_DIR)/ramdisk.cpp \
+    $(LOCAL_DIR)/fvm.cpp \
 
 MODULE_LIBS := \
     system/ulib/c \
diff --git a/system/utest/blkctl/fvm.cpp b/system/utest/blkctl/fvm.cpp
new file mode 100644
index 0000000..7efc820
--- /dev/null
+++ b/system/utest/blkctl/fvm.cpp
@@ -0,0 +1,262 @@
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <limits.h>
+#include <stddef.h>
+
+#include <fbl/unique_ptr.h>
+#include <unittest/unittest.h>
+#include <zircon/types.h>
+
+#include "utils.h"
+
+namespace blkctl {
+namespace testing {
+namespace {
+
+bool TestBadCommand(void) {
+    BEGIN_TEST;
+
+    // Missing command
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm"));
+
+    // Gibberish
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm booplesnoot"));
+
+    END_TEST;
+}
+
+bool TestInitDestroy(void) {
+    BEGIN_TEST;
+    ScopedRamdisk ramdisk;
+    ScopedRamdisk nonfvm;
+    ASSERT_TRUE(ramdisk.Init());
+    ASSERT_TRUE(nonfvm.Init());
+
+    // Missing/bad device
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm init"));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm init booplesnoot"));
+
+    // Missing/bad slice size
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm init %s", ramdisk.path()));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm init %s foo", ramdisk.path()));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm init %s -1", ramdisk.path()));
+
+    // Too many args
+    EXPECT_TRUE(
+        ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm init %s %zu foo", ramdisk.path(), kSliceSize));
+
+    // Valid
+    EXPECT_TRUE(ParseAndRun(ZX_OK, "blkctl fvm init --force %s %zu", ramdisk.path(), kSliceSize));
+
+    // Missing/bad device
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm destroy"));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm destroy booplesnoot"));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm destroy %s", nonfvm.path()));
+
+    // Too many args
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm destroy %s foo", ramdisk.path()));
+
+    // Valid
+    EXPECT_TRUE(ParseAndRun(ZX_OK, "blkctl fvm destroy --force %s", ramdisk.path()));
+
+    END_TEST;
+}
+
+bool TestDump(void) {
+    BEGIN_TEST;
+    ScopedFvmPartition partition;
+    ASSERT_TRUE(partition.Init());
+    const ScopedFvmVolume& volume = partition.volume();
+    const ScopedRamdisk& ramdisk = volume.ramdisk();
+
+    // Missing/bad device
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm dump"));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm dump booplesnoot"));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm add %s", ramdisk.path()));
+
+    // Too many args
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm dump %s foo", volume.path()));
+
+    // Valid for volume
+    EXPECT_TRUE(ParseAndRun(ZX_OK, "blkctl fvm dump %s", volume.path()));
+
+    // Valid for partition
+    EXPECT_TRUE(ParseAndRun(ZX_OK, "blkctl fvm dump %s", partition.path()));
+
+    END_TEST;
+}
+
+bool TestAdd(void) {
+    BEGIN_TEST;
+    ScopedFvmVolume volume;
+    ASSERT_TRUE(volume.Init());
+    const ScopedRamdisk& ramdisk = volume.ramdisk();
+
+    // Missing device
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm add"));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm add booplesnoot"));
+
+    // Missing/bad name and/or slices
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm add %s", volume.path()));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm add %s foo", volume.path()));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm add %s foo bar", volume.path()));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm add %s foo -1", volume.path()));
+
+    // GUID is optional
+    EXPECT_TRUE(ParseAndRun(ZX_OK, "blkctl fvm add --force %s foo %zu", volume.path(),
+                            volume.slices() / 2));
+
+    // Bad GUID
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS,
+                            "blkctl fvm add %s bar %zu 00000000-0000-0000-0000000000000000",
+                            volume.path(), volume.slices()));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS,
+                            "blkctl fvm add %s bar %zu thisisno-thex-adec-imal-anditmustbe!",
+                            volume.path(), volume.slices()));
+
+    // Too many args
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS,
+                            "blkctl fvm add %s bar %zu deadbeef-dead-beef-dead-beefdeadbeef bar",
+                            volume.path(), volume.slices()));
+
+    // Bad device
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm add %s bar %zu", ramdisk.path(),
+                            volume.slices() / 2));
+
+    // Valid
+    EXPECT_TRUE(
+        ParseAndRun(ZX_OK, "blkctl fvm add --force %s bar %zu deadbeef-dead-beef-dead-beefdeadbeef",
+                    volume.path(), volume.slices() / 2));
+
+    END_TEST;
+}
+
+bool TestQuery(void) {
+    BEGIN_TEST;
+    ScopedFvmPartition partition;
+    ASSERT_TRUE(partition.Init());
+    const ScopedFvmVolume& volume = partition.volume();
+
+    // Missing/bad device
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm query"));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm query booplesnoot"));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm query %s", volume.path()));
+
+    // Too many args
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm query %s foo", partition.path()));
+
+    // Valid
+    EXPECT_TRUE(ParseAndRun(ZX_OK, "blkctl fvm query %s", partition.path()));
+
+    END_TEST;
+}
+
+bool TestExtend(void) {
+    BEGIN_TEST;
+    ScopedFvmPartition partition;
+    ASSERT_TRUE(partition.Init());
+    const ScopedFvmVolume& volume = partition.volume();
+
+    // Missing device
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm extend"));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm extend booplesnoot"));
+
+    // Missing/bad start and/or length
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm extend %s", partition.path()));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm extend %s %zu", partition.path(),
+                            partition.slices()));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm extend %s foo 1", partition.path()));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm extend %s -1 1", partition.path()));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm extend %s %zu foo", partition.path(),
+                            partition.slices()));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm extend %s %zu -1", partition.path(),
+                            partition.slices()));
+
+    // Too many args
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm extend %s %zu 1 foo", partition.path(),
+                            partition.slices()));
+
+    // Bad device
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm extend %s %zu 1", volume.path(),
+                            partition.slices()));
+
+    // Valid
+    EXPECT_TRUE(ParseAndRun(ZX_OK, "blkctl fvm extend --force %s %zu 1", partition.path(),
+                            partition.slices()));
+
+    END_TEST;
+}
+
+bool TestShrink(void) {
+    BEGIN_TEST;
+    ScopedFvmPartition partition;
+    ASSERT_TRUE(partition.Init());
+    const ScopedFvmVolume& volume = partition.volume();
+
+    // Missing device
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm shrink"));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm shrink booplesnoot"));
+
+    // Missing/bad start and/or length
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm shrink %s", partition.path()));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm shrink %s %zu", partition.path(),
+                            partition.slices() - 1));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm shrink %s foo 1", partition.path()));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm shrink %s -1 1", partition.path()));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm shrink %s %zu foo", partition.path(),
+                            partition.slices() - 1));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm shrink %s %zu -1", partition.path(),
+                            partition.slices() - 1));
+
+    // Too many args
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm shrink %s %zu 1 foo", partition.path(),
+                            partition.slices() - 1));
+
+    // Bad device
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm shrink %s %zu 1", volume.path(),
+                            partition.slices() - 1));
+
+    // Valid
+    EXPECT_TRUE(ParseAndRun(ZX_OK, "blkctl fvm shrink --force %s %zu 1", partition.path(),
+                            partition.slices() - 1));
+
+    END_TEST;
+}
+
+bool TestRemove(void) {
+    BEGIN_TEST;
+    ScopedFvmPartition partition;
+    ASSERT_TRUE(partition.Init());
+    const ScopedFvmVolume& volume = partition.volume();
+
+    // Missing device
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm remove"));
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm remove booplesnoot"));
+
+    // Too many args
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm remove %s foo", partition.path()));
+
+    // Bad device
+    EXPECT_TRUE(ParseAndRun(ZX_ERR_INVALID_ARGS, "blkctl fvm remove %s", volume.path()));
+
+    // Valid
+    EXPECT_TRUE(ParseAndRun(ZX_OK, "blkctl fvm remove --force %s", partition.path()));
+
+    END_TEST;
+}
+
+BEGIN_TEST_CASE(FvmCommandTest)
+RUN_TEST(TestInitDestroy)
+RUN_TEST(TestDump)
+RUN_TEST(TestAdd)
+RUN_TEST(TestQuery)
+RUN_TEST(TestExtend)
+RUN_TEST(TestShrink)
+RUN_TEST(TestRemove)
+END_TEST_CASE(FvmCommandTest)
+
+} // namespace
+} // namespace testing
+} // namespace blkctl
diff --git a/system/utest/blkctl/rules.mk b/system/utest/blkctl/rules.mk
index fcaed07..bd148f2 100644
--- a/system/utest/blkctl/rules.mk
+++ b/system/utest/blkctl/rules.mk
@@ -19,6 +19,7 @@
 MODULE_SRCS += \
     $(LOCAL_DIR)/command.cpp \
     $(LOCAL_DIR)/ramdisk.cpp \
+    $(LOCAL_DIR)/fvm.cpp \
 
 MODULE_LIBS := \
     system/ulib/blkctl \