diff --git a/delta_performer_unittest.cc b/delta_performer_unittest.cc
index bc47b0b..5737422 100644
--- a/delta_performer_unittest.cc
+++ b/delta_performer_unittest.cc
@@ -532,7 +532,8 @@
         payload_config.source.kernel.path = state->old_kernel;
       payload_config.source.image_info = old_image_info;
       EXPECT_TRUE(payload_config.source.LoadImageSize());
-
+      EXPECT_TRUE(payload_config.source.rootfs.OpenFilesystem());
+      EXPECT_TRUE(payload_config.source.kernel.OpenFilesystem());
     } else {
       if (payload_config.chunk_size == -1)
         payload_config.chunk_size = kDefaultChunkSize;
@@ -541,6 +542,8 @@
     payload_config.target.kernel.path = state->new_kernel;
     payload_config.target.image_info = new_image_info;
     EXPECT_TRUE(payload_config.target.LoadImageSize());
+    EXPECT_TRUE(payload_config.target.rootfs.OpenFilesystem());
+    EXPECT_TRUE(payload_config.target.kernel.OpenFilesystem());
 
     EXPECT_TRUE(payload_config.Validate());
     EXPECT_TRUE(
@@ -1404,9 +1407,10 @@
   // Test that the minor version in update_engine.conf that is installed to
   // the image matches the supported delta minor version in the update engine.
   uint32_t minor_version;
-  base::FilePath conf_path("update_engine.conf");
-  EXPECT_TRUE(utils::GetMinorVersion(conf_path, &minor_version));
-  ASSERT_EQ(DeltaPerformer::kSupportedMinorPayloadVersion, minor_version);
+  chromeos::KeyValueStore store;
+  EXPECT_TRUE(store.Load(base::FilePath("update_engine.conf")));
+  EXPECT_TRUE(utils::GetMinorVersion(store, &minor_version));
+  EXPECT_EQ(DeltaPerformer::kSupportedMinorPayloadVersion, minor_version);
 }
 
 }  // namespace chromeos_update_engine
diff --git a/payload_generator/ab_generator.cc b/payload_generator/ab_generator.cc
index 7a9c748..67163eb 100644
--- a/payload_generator/ab_generator.cc
+++ b/payload_generator/ab_generator.cc
@@ -13,7 +13,6 @@
 #include "update_engine/payload_generator/annotated_operation.h"
 #include "update_engine/payload_generator/delta_diff_generator.h"
 #include "update_engine/payload_generator/delta_diff_utils.h"
-#include "update_engine/payload_generator/ext2_filesystem.h"
 #include "update_engine/utils.h"
 
 using std::string;
@@ -45,21 +44,15 @@
     off_t* data_file_size,
     vector<AnnotatedOperation>* rootfs_ops,
     vector<AnnotatedOperation>* kernel_ops) {
-  unique_ptr<Ext2Filesystem> old_fs = Ext2Filesystem::CreateFromFile(
-      config.source.rootfs.path);
-  unique_ptr<Ext2Filesystem> new_fs = Ext2Filesystem::CreateFromFile(
-      config.target.rootfs.path);
 
   off_t chunk_blocks = (config.chunk_size == -1 ? -1 :
                         config.chunk_size / config.block_size);
 
   rootfs_ops->clear();
-  TEST_AND_RETURN_FALSE(diff_utils::DeltaReadFilesystem(
+  TEST_AND_RETURN_FALSE(diff_utils::DeltaReadPartition(
       rootfs_ops,
-      config.source.rootfs.path,
-      config.target.rootfs.path,
-      old_fs.get(),
-      new_fs.get(),
+      config.source.rootfs,
+      config.target.rootfs,
       chunk_blocks,
       data_file_fd,
       data_file_size,
@@ -68,15 +61,14 @@
   LOG(INFO) << "done reading normal files";
 
   // Read kernel partition
-  TEST_AND_RETURN_FALSE(diff_utils::DeltaCompressKernelPartition(
-      config.source.kernel.path,
-      config.target.kernel.path,
-      config.source.kernel.size,
-      config.target.kernel.size,
-      config.block_size,
+  TEST_AND_RETURN_FALSE(diff_utils::DeltaReadPartition(
       kernel_ops,
+      config.source.kernel,
+      config.target.kernel,
+      chunk_blocks,
       data_file_fd,
       data_file_size,
+      false,  // skip_block_0
       true));  // src_ops_allowed
   LOG(INFO) << "done reading kernel";
 
diff --git a/payload_generator/delta_diff_generator.cc b/payload_generator/delta_diff_generator.cc
index bedfbbb..dbb63a8 100644
--- a/payload_generator/delta_diff_generator.cc
+++ b/payload_generator/delta_diff_generator.cc
@@ -58,6 +58,9 @@
   LOG(INFO) << "Block count: "
             << config.target.rootfs.size / config.block_size;
 
+  LOG_IF(INFO, config.source.kernel.path.empty())
+      << "Will generate full kernel update.";
+
   const string kTempFileTemplate("CrAU_temp_data.XXXXXX");
   string temp_file_path;
   off_t data_file_size = 0;
@@ -99,11 +102,10 @@
     }
   } else {
     // Full update.
-    LOG(INFO) << "Using generator FullUpdateGenerator::Run";
+    LOG(INFO) << "Using generator FullUpdateGenerator()";
     strategy.reset(new FullUpdateGenerator());
   }
 
-
   int data_file_fd;
   TEST_AND_RETURN_FALSE(
       utils::MakeTempFile(kTempFileTemplate, &temp_file_path, &data_file_fd));
diff --git a/payload_generator/delta_diff_generator.h b/payload_generator/delta_diff_generator.h
index 8ba1dc0..405f451 100644
--- a/payload_generator/delta_diff_generator.h
+++ b/payload_generator/delta_diff_generator.h
@@ -9,13 +9,6 @@
 
 #include "update_engine/payload_generator/payload_generation_config.h"
 
-// There is one function in DeltaDiffGenerator of importance to users
-// of the class: GenerateDeltaUpdateFile(). Before calling it,
-// the old and new images must be mounted. Call GenerateDeltaUpdateFile()
-// with both the mount-points of the images in addition to the paths of
-// the images (both old and new). A delta from old to new will be
-// generated and stored in output_path.
-
 namespace chromeos_update_engine {
 
 extern const size_t kBlockSize;
diff --git a/payload_generator/delta_diff_utils.cc b/payload_generator/delta_diff_utils.cc
index d53c5e0..6c15919 100644
--- a/payload_generator/delta_diff_utils.cc
+++ b/payload_generator/delta_diff_utils.cc
@@ -16,7 +16,6 @@
 #include "update_engine/payload_generator/delta_diff_generator.h"
 #include "update_engine/payload_generator/extent_ranges.h"
 #include "update_engine/payload_generator/extent_utils.h"
-#include "update_engine/payload_generator/raw_filesystem.h"
 #include "update_engine/subprocess.h"
 #include "update_engine/utils.h"
 
@@ -139,12 +138,10 @@
 
 namespace diff_utils {
 
-bool DeltaReadFilesystem(
+bool DeltaReadPartition(
     vector<AnnotatedOperation>* aops,
-    const string& old_part,
-    const string& new_part,
-    FilesystemInterface* old_fs,
-    FilesystemInterface* new_fs,
+    const PartitionConfig& old_part,
+    const PartitionConfig& new_part,
     off_t chunk_blocks,
     int data_fd,
     off_t* data_file_size,
@@ -164,15 +161,16 @@
   }
 
   map<string, vector<Extent>> old_files_map;
-  if (old_fs) {
+  if (old_part.fs_interface) {
     vector<FilesystemInterface::File> old_files;
-    old_fs->GetFiles(&old_files);
+    old_part.fs_interface->GetFiles(&old_files);
     for (const FilesystemInterface::File& file : old_files)
       old_files_map[file.name] = file.extents;
   }
 
+  TEST_AND_RETURN_FALSE(new_part.fs_interface);
   vector<FilesystemInterface::File> new_files;
-  new_fs->GetFiles(&new_files);
+  new_part.fs_interface->GetFiles(&new_files);
 
   // The processing is very straightforward here, we generate operations for
   // every file (and pseudo-file such as the metadata) in the new filesystem
@@ -210,8 +208,8 @@
 
     TEST_AND_RETURN_FALSE(DeltaReadFile(
         aops,
-        old_part,
-        new_part,
+        old_part.path,
+        new_part.path,
         old_file_extents,
         new_file_extents,
         new_file.name,  // operation name
@@ -222,14 +220,15 @@
   }
   // Process all the blocks not included in any file. We provided all the unused
   // blocks in the old partition as available data.
-  vector<Extent> new_unvisited = { ExtentForRange(0, new_fs->GetBlockCount()) };
+  vector<Extent> new_unvisited = {
+      ExtentForRange(0, new_part.size / kBlockSize)};
   new_unvisited = FilterExtentRanges(new_unvisited, new_visited_blocks);
   if (new_unvisited.empty())
     return true;
 
   vector<Extent> old_unvisited;
-  if (old_fs) {
-    old_unvisited.push_back(ExtentForRange(0, old_fs->GetBlockCount()));
+  if (old_part.fs_interface) {
+    old_unvisited.push_back(ExtentForRange(0, old_part.size / kBlockSize));
     old_unvisited = FilterExtentRanges(old_unvisited, old_visited_blocks);
   }
 
@@ -237,8 +236,8 @@
             << " unwritten blocks";
   TEST_AND_RETURN_FALSE(DeltaReadFile(
       aops,
-      old_part,
-      new_part,
+      old_part.path,
+      new_part.path,
       old_unvisited,
       new_unvisited,
       "<non-file-data>",  // operation name
@@ -460,44 +459,6 @@
   return true;
 }
 
-bool DeltaCompressKernelPartition(
-    const string& old_kernel_part,
-    const string& new_kernel_part,
-    uint64_t old_kernel_size,
-    uint64_t new_kernel_size,
-    uint64_t block_size,
-    vector<AnnotatedOperation>* aops,
-    int blobs_fd,
-    off_t* blobs_length,
-    bool src_ops_allowed) {
-  LOG(INFO) << "Delta compressing kernel partition...";
-  LOG_IF(INFO, old_kernel_part.empty()) << "Generating full kernel update...";
-
-  unique_ptr<RawFilesystem> old_kernel_fs;
-  if (!old_kernel_part.empty())
-    old_kernel_fs = RawFilesystem::Create("<kernel-delta-operation>",
-                                          block_size,
-                                          old_kernel_size / block_size);
-  unique_ptr<RawFilesystem> new_kernel_fs = RawFilesystem::Create(
-      "<kernel-delta-operation>",
-      block_size,
-      new_kernel_size / block_size);
-
-  TEST_AND_RETURN_FALSE(DeltaReadFilesystem(aops,
-                                            old_kernel_part,
-                                            new_kernel_part,
-                                            old_kernel_fs.get(),
-                                            new_kernel_fs.get(),
-                                            -1,  // chunk_blocks
-                                            blobs_fd,
-                                            blobs_length,
-                                            false,  // skip_block_0
-                                            src_ops_allowed));
-
-  LOG(INFO) << "Done delta compressing kernel partition.";
-  return true;
-}
-
 // Runs the bsdiff tool on two files and returns the resulting delta in
 // 'out'. Returns true on success.
 bool BsdiffFiles(const string& old_file,
diff --git a/payload_generator/delta_diff_utils.h b/payload_generator/delta_diff_utils.h
index aa18f16..0be8666 100644
--- a/payload_generator/delta_diff_utils.h
+++ b/payload_generator/delta_diff_utils.h
@@ -11,7 +11,6 @@
 #include <chromeos/secure_blob.h>
 
 #include "update_engine/payload_generator/annotated_operation.h"
-#include "update_engine/payload_generator/filesystem_interface.h"
 #include "update_engine/payload_generator/payload_generation_config.h"
 #include "update_engine/update_metadata.pb.h"
 
@@ -19,22 +18,20 @@
 
 namespace diff_utils {
 
-// Create operations in |aops| to produce all the files reported by |new_fs|,
-// including all the blocks not reported by any file.
-// It uses the files reported by |old_fs| and the data in |old_part| to
-// determine the best way to compress the new files (REPLACE, REPLACE_BZ,
-// COPY, BSDIFF) and writes any necessary data to the end of data_fd updating
-// data_file_size accordingly.
-bool DeltaReadFilesystem(std::vector<AnnotatedOperation>* aops,
-                         const std::string& old_part,
-                         const std::string& new_part,
-                         FilesystemInterface* old_fs,
-                         FilesystemInterface* new_fs,
-                         off_t chunk_blocks,
-                         int data_fd,
-                         off_t* data_file_size,
-                         bool skip_block_0,
-                         bool src_ops_allowed);
+// Create operations in |aops| to produce all the blocks in the |new_part|
+// partition using the filesystem opened in that PartitionConfig.
+// It uses the files reported by the filesystem in |old_part| and the data
+// blocks in that partition (if available) to determine the best way to compress
+// the new files (REPLACE, REPLACE_BZ, COPY, BSDIFF) and writes any necessary
+// data to the end of |data_fd| updating |data_file_size| accordingly.
+bool DeltaReadPartition(std::vector<AnnotatedOperation>* aops,
+                        const PartitionConfig& old_part,
+                        const PartitionConfig& new_part,
+                        off_t chunk_blocks,
+                        int data_fd,
+                        off_t* data_file_size,
+                        bool skip_block_0,
+                        bool src_ops_allowed);
 
 // For a given file |name| append operations to |aops| to produce it in the
 // |new_part|. The file will be split in chunks of |chunk_blocks| blocks each
@@ -73,25 +70,6 @@
                        DeltaArchiveManifest_InstallOperation* out_op,
                        bool src_ops_allowed);
 
-// Delta compresses a kernel partition |new_kernel_part| with knowledge of the
-// old kernel partition |old_kernel_part|. If |old_kernel_part| is an empty
-// string, generates a full update of the partition. The size of the old and
-// new kernel is passed in |old_kernel_size| and |new_kernel_size|. The
-// operations used to generate the new kernel are stored in the |aops|
-// vector, and the blob associated to those operations is written at the end
-// of the |blobs_fd| file, adding to the value pointed by |blobs_length| the
-// bytes written to |blobs_fd|.
-bool DeltaCompressKernelPartition(
-    const std::string& old_kernel_part,
-    const std::string& new_kernel_part,
-    uint64_t old_kernel_size,
-    uint64_t new_kernel_size,
-    uint64_t block_size,
-    std::vector<AnnotatedOperation>* aops,
-    int blobs_fd,
-    off_t* blobs_length,
-    bool src_ops_allowed);
-
 // Runs the bsdiff tool on two files and returns the resulting delta in
 // |out|. Returns true on success.
 bool BsdiffFiles(const std::string& old_file,
diff --git a/payload_generator/full_update_generator.cc b/payload_generator/full_update_generator.cc
index bc75393..c28f7e8 100644
--- a/payload_generator/full_update_generator.cc
+++ b/payload_generator/full_update_generator.cc
@@ -135,17 +135,19 @@
   size_t max_threads = std::max(sysconf(_SC_NPROCESSORS_ONLN), 4L);
   LOG(INFO) << "Max threads: " << max_threads;
 
-  PartitionConfig partitions[] = { config.target.rootfs, config.target.kernel };
+  const PartitionConfig* partitions[] = {
+      &config.target.rootfs,
+      &config.target.kernel};
 
   for (int part_id = 0; part_id < 2; ++part_id) {
-    const PartitionConfig& partition = partitions[part_id];
-    LOG(INFO) << "compressing " << partition.path;
-    int in_fd = open(partition.path.c_str(), O_RDONLY, 0);
+    const PartitionConfig* partition = partitions[part_id];
+    LOG(INFO) << "compressing " << partition->path;
+    int in_fd = open(partition->path.c_str(), O_RDONLY, 0);
     TEST_AND_RETURN_FALSE(in_fd >= 0);
     ScopedFdCloser in_fd_closer(&in_fd);
     deque<shared_ptr<ChunkProcessor>> threads;
     int last_progress_update = INT_MIN;
-    size_t bytes_left = partition.size, counter = 0, offset = 0;
+    size_t bytes_left = partition->size, counter = 0, offset = 0;
     while (bytes_left > 0 || !threads.empty()) {
       // Check and start new chunk processors if possible.
       while (threads.size() < max_threads && bytes_left > 0) {
@@ -195,7 +197,7 @@
 
       int progress = static_cast<int>(
           (processor->offset() + processor->buffer_in().size()) * 100.0 /
-          partition.size);
+          partition->size);
       if (last_progress_update < progress &&
           (last_progress_update + 10 <= progress || progress == 100)) {
         LOG(INFO) << progress << "% complete (output size: "
diff --git a/payload_generator/generate_delta_main.cc b/payload_generator/generate_delta_main.cc
index 662c1f4..170a612 100644
--- a/payload_generator/generate_delta_main.cc
+++ b/payload_generator/generate_delta_main.cc
@@ -218,7 +218,8 @@
 
 int Main(int argc, char** argv) {
   DEFINE_string(old_dir, "",
-                "Directory where the old rootfs is loop mounted read-only");
+                "[DEPRECATED] Directory where the old rootfs is loop mounted "
+                "read-only. Not required anymore.");
   DEFINE_string(new_dir, "",
                 "[DEPRECATED] Directory where the new rootfs is loop mounted "
                 "read-only. Not required anymore.");
@@ -255,8 +256,9 @@
   DEFINE_uint64(rootfs_partition_size,
                chromeos_update_engine::kRootFSPartitionSize,
                "RootFS partition size for the image once installed");
-  DEFINE_int32(minor_version, DeltaPerformer::kFullPayloadMinorVersion,
-               "The minor version of the payload being generated");
+  DEFINE_int32(minor_version, -1,
+               "The minor version of the payload being generated "
+               "(-1 means autodetect).");
 
   DEFINE_string(old_channel, "",
                 "The channel for the old image. 'dev-channel', 'npo-channel', "
@@ -311,6 +313,9 @@
   logging::InitLogging(log_settings);
 
   // Check flags.
+  if (!FLAGS_old_dir.empty()) {
+    LOG(INFO) << "--old_dir flag is deprecated and ignored.";
+  }
   if (!FLAGS_new_dir.empty()) {
     LOG(INFO) << "--new_dir flag is deprecated and ignored.";
   }
@@ -389,21 +394,6 @@
                  &payload_config.source.image_info);
 
   payload_config.rootfs_partition_size = FLAGS_rootfs_partition_size;
-  payload_config.minor_version = FLAGS_minor_version;
-  // Look for the minor version in the old image if it was not given as an
-  // argument.
-  if (payload_config.is_delta &&
-      !base::CommandLine::ForCurrentProcess()->HasSwitch("minor_version")) {
-    uint32_t minor_version;
-    base::FilePath image_path(FLAGS_old_dir);
-    base::FilePath conf_loc("etc/update_engine.conf");
-    base::FilePath conf_path = image_path.Append(conf_loc);
-    if (utils::GetMinorVersion(conf_path, &minor_version)) {
-      payload_config.minor_version = minor_version;
-    } else {
-      payload_config.minor_version = kInPlaceMinorPayloadVersion;
-    }
-  }
 
   // Load the rootfs size from verity's kernel command line if rootfs
   // verification is enabled.
@@ -411,6 +401,36 @@
   payload_config.target.LoadVerityRootfsSize();
 
   if (payload_config.is_delta) {
+    // Avoid opening the filesystem interface for full payloads.
+    CHECK(payload_config.target.rootfs.OpenFilesystem());
+    CHECK(payload_config.target.kernel.OpenFilesystem());
+    CHECK(payload_config.source.rootfs.OpenFilesystem());
+    CHECK(payload_config.source.kernel.OpenFilesystem());
+  }
+
+  if (FLAGS_minor_version == -1) {
+    // Autodetect minor_version by looking at the update_engine.conf in the old
+    // image.
+    if (payload_config.is_delta) {
+      CHECK(payload_config.source.rootfs.fs_interface);
+      chromeos::KeyValueStore store;
+      uint32_t minor_version;
+      if (payload_config.source.rootfs.fs_interface->LoadSettings(&store) &&
+          utils::GetMinorVersion(store, &minor_version)) {
+        payload_config.minor_version = minor_version;
+      } else {
+        payload_config.minor_version = kInPlaceMinorPayloadVersion;
+      }
+    } else {
+      payload_config.minor_version = DeltaPerformer::kFullPayloadMinorVersion;
+    }
+    LOG(INFO) << "Auto-detected minor_version=" << payload_config.minor_version;
+  } else {
+    payload_config.minor_version = FLAGS_minor_version;
+    LOG(INFO) << "Using provided minor_version=" << FLAGS_minor_version;
+  }
+
+  if (payload_config.is_delta) {
     LOG(INFO) << "Generating delta update";
   } else {
     LOG(INFO) << "Generating full update";
diff --git a/payload_generator/inplace_generator.cc b/payload_generator/inplace_generator.cc
index 2ada2f3..2e0dbaf 100644
--- a/payload_generator/inplace_generator.cc
+++ b/payload_generator/inplace_generator.cc
@@ -15,7 +15,6 @@
 #include "update_engine/payload_generator/cycle_breaker.h"
 #include "update_engine/payload_generator/delta_diff_generator.h"
 #include "update_engine/payload_generator/delta_diff_utils.h"
-#include "update_engine/payload_generator/ext2_filesystem.h"
 #include "update_engine/payload_generator/extent_ranges.h"
 #include "update_engine/payload_generator/graph_types.h"
 #include "update_engine/payload_generator/graph_utils.h"
@@ -712,27 +711,20 @@
     off_t* data_file_size,
     vector<AnnotatedOperation>* rootfs_ops,
     vector<AnnotatedOperation>* kernel_ops) {
-  unique_ptr<Ext2Filesystem> old_fs = Ext2Filesystem::CreateFromFile(
-      config.source.rootfs.path);
-  unique_ptr<Ext2Filesystem> new_fs = Ext2Filesystem::CreateFromFile(
-      config.target.rootfs.path);
-
   off_t chunk_blocks = (config.chunk_size == -1 ? -1 :
                         config.chunk_size / config.block_size);
 
   // Temporary list of operations used to construct the dependency graph.
   vector<AnnotatedOperation> aops;
   TEST_AND_RETURN_FALSE(
-      diff_utils::DeltaReadFilesystem(&aops,
-                                      config.source.rootfs.path,
-                                      config.target.rootfs.path,
-                                      old_fs.get(),
-                                      new_fs.get(),
-                                      chunk_blocks,
-                                      data_file_fd,
-                                      data_file_size,
-                                      true,  // skip_block_0
-                                      false));  // src_ops_allowed
+      diff_utils::DeltaReadPartition(&aops,
+                                     config.source.rootfs,
+                                     config.target.rootfs,
+                                     chunk_blocks,
+                                     data_file_fd,
+                                     data_file_size,
+                                     true,  // skip_block_0
+                                     false));  // src_ops_allowed
   // Convert the rootfs operations to the graph.
   Graph graph;
   CheckGraph(graph);
@@ -756,16 +748,18 @@
   }
 
   // Read kernel partition
-  TEST_AND_RETURN_FALSE(diff_utils::DeltaCompressKernelPartition(
-      config.source.kernel.path,
-      config.target.kernel.path,
-      config.source.kernel.size,
-      config.target.kernel.size,
-      config.block_size,
-      kernel_ops,
-      data_file_fd,
-      data_file_size,
-      false));  // src_ops_allowed
+  LOG(INFO) << "Delta compressing kernel partition...";
+  // It is safe to not skip the block 0 since we will not be using the cycle
+  // breaking algorithm on this list of operations as we expect no cycles here.
+  TEST_AND_RETURN_FALSE(
+      diff_utils::DeltaReadPartition(kernel_ops,
+                                     config.source.kernel,
+                                     config.target.kernel,
+                                     chunk_blocks,
+                                     data_file_fd,
+                                     data_file_size,
+                                     false,  // skip_block_0
+                                     false));  // src_ops_allowed
   LOG(INFO) << "done reading kernel";
   CheckGraph(graph);
 
diff --git a/payload_generator/payload_generation_config.cc b/payload_generator/payload_generation_config.cc
index 3af9b4f..d58c9a1 100644
--- a/payload_generator/payload_generation_config.cc
+++ b/payload_generator/payload_generation_config.cc
@@ -8,6 +8,8 @@
 
 #include "update_engine/delta_performer.h"
 #include "update_engine/payload_generator/delta_diff_generator.h"
+#include "update_engine/payload_generator/ext2_filesystem.h"
+#include "update_engine/payload_generator/raw_filesystem.h"
 #include "update_engine/payload_generator/verity_utils.h"
 #include "update_engine/utils.h"
 
@@ -23,6 +25,34 @@
   return true;
 }
 
+bool PartitionConfig::OpenFilesystem() {
+  if (path.empty())
+    return true;
+  fs_interface.reset();
+  if (name == PartitionName::kRootfs) {
+    fs_interface = Ext2Filesystem::CreateFromFile(path);
+  }
+
+  if (!fs_interface) {
+    // Fall back to a RAW filesystem.
+    TEST_AND_RETURN_FALSE(size % kBlockSize == 0);
+    std::string str_name = "other";
+    switch (name) {
+      case PartitionName::kKernel:
+        str_name = "kernel";
+        break;
+      case PartitionName::kRootfs:
+        str_name = "rootfs";
+        break;
+    }
+    fs_interface = RawFilesystem::Create(
+      "<" + str_name + "-partition>",
+      kBlockSize,
+      size / kBlockSize);
+  }
+  return true;
+}
+
 bool ImageConfig::ValidateIsEmpty() const {
   TEST_AND_RETURN_FALSE(ImageInfoIsEmpty());
 
diff --git a/payload_generator/payload_generation_config.h b/payload_generator/payload_generation_config.h
index 0f002e1..f18055f 100644
--- a/payload_generator/payload_generation_config.h
+++ b/payload_generator/payload_generation_config.h
@@ -7,9 +7,11 @@
 
 #include <cstddef>
 
+#include <memory>
 #include <string>
 #include <vector>
 
+#include "update_engine/payload_generator/filesystem_interface.h"
 #include "update_engine/update_metadata.pb.h"
 
 namespace chromeos_update_engine {
@@ -27,6 +29,10 @@
   // fields are set correctly to a valid image file.
   bool ValidateExists() const;
 
+  // Open then filesystem stored in this partition and stores it in
+  // |fs_interface|. Returns whether opening the filesystem worked.
+  bool OpenFilesystem();
+
   // The path to the partition file. This can be a regular file or a block
   // device such as a loop device.
   std::string path;
@@ -39,6 +45,10 @@
   // target image.
   uint64_t size = 0;
 
+  // The FilesystemInterface implementation used to access this partition's
+  // files.
+  std::unique_ptr<FilesystemInterface> fs_interface;
+
   PartitionName name;
 };
 
diff --git a/utils.cc b/utils.cc
index f36cbec..97ce712 100644
--- a/utils.cc
+++ b/utils.cc
@@ -38,7 +38,6 @@
 #include <base/strings/string_util.h>
 #include <base/strings/stringprintf.h>
 #include <chromeos/data_encoding.h>
-#include <chromeos/key_value_store.h>
 #include <chromeos/message_loops/message_loop.h>
 
 #include "update_engine/clock_interface.h"
@@ -1628,11 +1627,10 @@
   return ret;
 }
 
-bool GetMinorVersion(base::FilePath path, uint32_t* minor_version) {
-  chromeos::KeyValueStore store;
+bool GetMinorVersion(const chromeos::KeyValueStore& store,
+                     uint32_t* minor_version) {
   string result;
-  if (base::PathExists(path) && store.Load(path) &&
-      store.GetString("PAYLOAD_MINOR_VERSION", &result)) {
+  if (store.GetString("PAYLOAD_MINOR_VERSION", &result)) {
     if (!base::StringToUint(result, minor_version)) {
       LOG(ERROR) << "StringToUint failed when parsing delta minor version.";
       return false;
diff --git a/utils.h b/utils.h
index 6a9e065..b661b43 100644
--- a/utils.h
+++ b/utils.h
@@ -19,6 +19,7 @@
 #include <base/posix/eintr_wrapper.h>
 #include <base/time/time.h>
 #include <chromeos/secure_blob.h>
+#include <chromeos/key_value_store.h>
 #include "metrics/metrics_library.h"
 
 #include "update_engine/action.h"
@@ -424,13 +425,10 @@
                              int64_t* storage,
                              base::TimeDelta* out_duration);
 
-// This function looks for a configuration file at |path|. If it finds that
-// file, it will try get the PAYLOAD_MINOR_VERSION value from it and set
-// |minor_version| to that value.
-//
-// The function will return |true| if it succeeds at finding the file and
-// value and setting it, and |false| otherwise.
-bool GetMinorVersion(base::FilePath path, uint32_t* minor_version);
+// Look for the minor version value in the passed |store| and set
+// |minor_version| to that value. Return whether the value was found and valid.
+bool GetMinorVersion(const chromeos::KeyValueStore& store,
+                     uint32_t* minor_version);
 
 // This function reads the specified data in |extents| into |out_data|. The
 // extents are read from the file at |path|. |out_data_size| is the size of
diff --git a/utils_unittest.cc b/utils_unittest.cc
index 0d82f61..4787e84 100644
--- a/utils_unittest.cc
+++ b/utils_unittest.cc
@@ -732,18 +732,17 @@
 TEST(UtilsTest, GetMinorVersion) {
   // Test GetMinorVersion by verifying that it parses the conf file and returns
   // the correct value.
-  string contents = "PAYLOAD_MINOR_VERSION=1\n";
   uint32_t minor_version;
 
-  base::ScopedTempDir temp_dir;
-  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+  chromeos::KeyValueStore store;
+  EXPECT_FALSE(utils::GetMinorVersion(store, &minor_version));
 
-  base::FilePath temp_file("update_engine.conf");
-  base::FilePath filepath = temp_dir.path().Append(temp_file);
+  EXPECT_TRUE(store.LoadFromString("PAYLOAD_MINOR_VERSION=one-two-three\n"));
+  EXPECT_FALSE(utils::GetMinorVersion(store, &minor_version));
 
-  ASSERT_TRUE(test_utils::WriteFileString(filepath.value(), contents.c_str()));
-  ASSERT_TRUE(utils::GetMinorVersion(filepath, &minor_version));
-  ASSERT_EQ(minor_version, 1);
+  EXPECT_TRUE(store.LoadFromString("PAYLOAD_MINOR_VERSION=123\n"));
+  EXPECT_TRUE(utils::GetMinorVersion(store, &minor_version));
+  EXPECT_EQ(minor_version, 123);
 }
 
 static bool BoolMacroTestHelper() {