Add filesystem sector offsets to the disk layout structure.

davidgiven · davidgiven · commit 06a3af2a1dfe · 2025-10-01T00:34:09.000+02:00
diff --git a/lib/algorithms/readerwriter.cc b/lib/algorithms/readerwriter.cc
@@ -238,8 +238,9 @@ static std::set<std::shared_ptr<const Sector>> collectSectors(
 
     for (const auto& sector : track_sectors)
     {
-        key_t sectorid = {
-            sector->logicalCylinder, sector->logicalHead, sector->logicalSector};
+        key_t sectorid = {sector->logicalCylinder,
+            sector->logicalHead,
+            sector->logicalSector};
         sectors.insert({sectorid, sector});
     }
 
@@ -300,8 +301,10 @@ BadSectorsState combineRecordAndSectors(TrackFlux& trackFlux,
 
     for (unsigned sectorId : trackLayout->naturalSectorOrder)
     {
-        auto sector = std::make_shared<Sector>(trackLayout, LogicalLocation{
-            trackLayout->logicalCylinder, trackLayout->logicalHead, sectorId});
+        auto sector = std::make_shared<Sector>(trackLayout,
+            LogicalLocation{trackLayout->logicalCylinder,
+                trackLayout->logicalHead,
+                sectorId});
 
         sector->status = Sector::MISSING;
         track_sectors.insert(sector);
@@ -406,7 +409,8 @@ void writeTracks(FluxSink& fluxSink,
             for (int offset = 0; offset < trackInfo->groupSize;
                 offset += Layout::getHeadWidth())
             {
-                unsigned physicalCylinder = trackInfo->physicalCylinder + offset;
+                unsigned physicalCylinder =
+                    trackInfo->physicalCylinder + offset;
 
                 log(BeginWriteOperationLogMessage{
                     physicalCylinder, trackInfo->physicalHead});
diff --git a/lib/data/layout.cc b/lib/data/layout.cc
@@ -129,47 +129,46 @@ Layout::LayoutBounds Layout::getBounds(
     return r;
 }
 
-std::vector<std::pair<int, int>> Layout::getTrackOrdering(
+std::vector<std::pair<unsigned, unsigned>> getTrackOrdering(
+    const ConfigProto& config,
     LayoutProto::Order ordering,
-    unsigned guessedCylinders,
-    unsigned guessedHeads)
+    unsigned tracks,
+    unsigned sides)
 {
-    auto layout = globalConfig()->layout();
-    int tracks = layout.has_tracks() ? layout.tracks() : guessedCylinders;
-    int sides = layout.has_sides() ? layout.sides() : guessedHeads;
+    auto layout = config.layout();
 
-    std::vector<std::pair<int, int>> trackList;
+    std::vector<std::pair<unsigned, unsigned>> trackList;
     switch (ordering)
     {
         case LayoutProto::CHS:
         {
-            for (int track = 0; track < tracks; track++)
+            for (unsigned track = 0; track < tracks; track++)
             {
-                for (int side = 0; side < sides; side++)
+                for (unsigned side = 0; side < sides; side++)
                     trackList.push_back(std::make_pair(track, side));
             }
             break;
         }
 
         case LayoutProto::HCS:
         {
-            for (int side = 0; side < sides; side++)
+            for (unsigned side = 0; side < sides; side++)
             {
-                for (int track = 0; track < tracks; track++)
+                for (unsigned track = 0; track < tracks; track++)
                     trackList.push_back(std::make_pair(track, side));
             }
             break;
         }
 
         case LayoutProto::HCS_RH1:
         {
-            for (int side = 0; side < sides; side++)
+            for (unsigned side = 0; side < sides; side++)
             {
                 if (side == 0)
-                    for (int track = 0; track < tracks; track++)
+                    for (unsigned track = 0; track < tracks; track++)
                         trackList.push_back(std::make_pair(track, side));
                 if (side == 1)
-                    for (int track = tracks; track >= 0; track--)
+                    for (unsigned track = tracks; track >= 0; track--)
                         trackList.push_back(std::make_pair(track - 1, side));
             }
             break;
@@ -182,6 +181,18 @@ std::vector<std::pair<int, int>> Layout::getTrackOrdering(
     return trackList;
 }
 
+std::vector<std::pair<unsigned, unsigned>> Layout::getTrackOrdering(
+    LayoutProto::Order ordering,
+    unsigned guessedCylinders,
+    unsigned guessedHeads)
+{
+    auto& layout = globalConfig()->layout();
+    return ::getTrackOrdering(globalConfig(),
+        ordering,
+        layout.has_tracks() ? layout.tracks() : guessedCylinders,
+        layout.has_sides() ? layout.sides() : guessedHeads);
+}
+
 std::vector<unsigned> Layout::expandSectorList(
     const SectorListProto& sectorsProto)
 {
@@ -388,6 +399,7 @@ DiskLayout::DiskLayout(const ConfigProto& config)
 
             auto layoutdata =
                 getLayoutData(logicalCylinder, logicalHead, globalConfig());
+            ltl->sectorSize = layoutdata.sector_size();
             ltl->diskSectorOrder =
                 Layout::expandSectorList(layoutdata.physical());
             ltl->naturalSectorOrder = ltl->diskSectorOrder;
@@ -436,6 +448,24 @@ DiskLayout::DiskLayout(const ConfigProto& config)
             ptl->logicalTrackLayout = findOrDefault(
                 layoutByLogicalLocation, {logicalCylinder, logicalHead});
         }
+
+    unsigned sectorOffset = 0;
+    for (auto [logicalCylinder, logicalHead] : getTrackOrdering(config,
+             config.layout().filesystem_track_order(),
+             numLogicalCylinders,
+             numLogicalHeads))
+    {
+        const auto& ltl =
+            layoutByLogicalLocation[{logicalCylinder, logicalHead}];
+        for (unsigned lid : ltl->filesystemSectorOrder)
+        {
+            LogicalLocation logicalLocation = {
+                logicalCylinder, logicalHead, lid};
+            logicalLocationsBySectorOffset[sectorOffset] = logicalLocation;
+            sectorOffsetByLogicalLocation[logicalLocation] = sectorOffset;
+            sectorOffset += ltl->sectorSize;
+        }
+    }
 }
 
 static Layout::LayoutBounds getBounds(std::ranges::view auto keys)
diff --git a/lib/data/layout.h b/lib/data/layout.h
@@ -47,9 +47,9 @@ class Layout
     };
     static LayoutBounds getBounds(const std::vector<CylinderHead>& locations);
 
-    /* Returns a series of <track, side> pairs representing the filesystem
-     * ordering of the disk, in logical numbers. */
-    static std::vector<std::pair<int, int>> getTrackOrdering(
+    /* Returns a series of logical <track, side> pairs representing the
+     * filesystem ordering of the disk, in logical numbers. */
+    static std::vector<std::pair<unsigned, unsigned>> getTrackOrdering(
         LayoutProto::Order ordering,
         unsigned guessedCylinders = 0,
         unsigned guessedHeads = 0);
@@ -157,6 +157,8 @@ class DiskLayout
         layoutByLogicalLocation;
     std::vector<CylinderHeadSector> physicalLocationsInFilesystemOrder;
     std::vector<LogicalLocation> logicalLocationsInFilesystemOrder;
+    std::map<unsigned, LogicalLocation> logicalLocationsBySectorOffset;
+    std::map<LogicalLocation, unsigned> sectorOffsetByLogicalLocation;
 
 public:
     unsigned remapCylinderPhysicalToLogical(unsigned physicalCylinder) const
diff --git a/lib/data/locations.h b/lib/data/locations.h
@@ -32,6 +32,12 @@ struct LogicalLocation
     }
 };
 
+inline std::ostream& operator<<(std::ostream& stream, LogicalLocation location)
+{
+    stream << (std::string)location;
+    return stream;
+}
+
 extern std::vector<CylinderHead> parseCylinderHeadsString(const std::string& s);
 extern std::string convertCylinderHeadsToString(
     const std::vector<CylinderHead>& chs);
diff --git a/tests/layout.cc b/tests/layout.cc
@@ -4,12 +4,24 @@
 #include "lib/config/config.pb.h"
 #include "lib/config/proto.h"
 #include "lib/data/layout.h"
+#include "lib/data/locations.h"
 #include "snowhouse/snowhouse.h"
 #include <google/protobuf/text_format.h>
 #include <regex>
 
 using namespace snowhouse;
 
+template <typename F, typename S>
+struct snowhouse::Stringizer<std::pair<F, S>>
+{
+    static std::string ToString(const std::pair<F, S>& a)
+    {
+        std::stringstream stream;
+        stream << '(' << a.first << ", " << a.second << ')';
+        return stream.str();
+    }
+};
+
 static std::string cleanup(const std::string& s)
 {
     auto outs = std::regex_replace(s, std::regex("[ \t\n]+"), " ");
@@ -254,11 +266,87 @@ static void test_bounds()
         Equals(Layout::LayoutBounds{0, 3, 0, 1}));
 }
 
+template <typename K, typename V>
+static std::vector<std::pair<K, V>> toVector(const std::map<K, V>& map)
+{
+    return std::vector<std::pair<K, V>>(map.begin(), map.end());
+}
+
+static void test_sectoroffsets()
+{
+    globalConfig().clear();
+    globalConfig().readBaseConfig(R"M(
+		drive {
+			drive_type: DRIVETYPE_80TRACK
+		}
+
+		layout {
+			format_type: FORMATTYPE_80TRACK
+			tracks: 2
+			sides: 2
+			layoutdata {
+				sector_size: 256
+                physical {
+					start_sector: 0
+					count: 4
+                }
+				filesystem {
+					start_sector: 0
+					count: 4
+					skew: 2
+				}
+			}
+		}
+	)M");
+
+    auto diskLayout = createDiskLayout();
+    AssertThat(diskLayout->groupSize, Equals(1));
+    AssertThat(diskLayout->logicalLocationsBySectorOffset,
+        EqualsContainer(decltype(diskLayout->logicalLocationsBySectorOffset){
+            {0,    {0, 0, 0}},
+            {256,  {0, 0, 2}},
+            {512,  {0, 0, 1}},
+            {768,  {0, 0, 3}},
+            {1024, {0, 1, 0}},
+            {1280, {0, 1, 2}},
+            {1536, {0, 1, 1}},
+            {1792, {0, 1, 3}},
+            {2048, {1, 0, 0}},
+            {2304, {1, 0, 2}},
+            {2560, {1, 0, 1}},
+            {2816, {1, 0, 3}},
+            {3072, {1, 1, 0}},
+            {3328, {1, 1, 2}},
+            {3584, {1, 1, 1}},
+            {3840, {1, 1, 3}}
+    }));
+    AssertThat(diskLayout->sectorOffsetByLogicalLocation,
+        EqualsContainer(decltype(diskLayout->sectorOffsetByLogicalLocation){
+            {{0, 0, 0}, 0   },
+            {{0, 0, 1}, 512 },
+            {{0, 0, 2}, 256 },
+            {{0, 0, 3}, 768 },
+            {{0, 1, 0}, 1024},
+            {{0, 1, 1}, 1536},
+            {{0, 1, 2}, 1280},
+            {{0, 1, 3}, 1792},
+            {{1, 0, 0}, 2048},
+            {{1, 0, 1}, 2560},
+            {{1, 0, 2}, 2304},
+            {{1, 0, 3}, 2816},
+            {{1, 1, 0}, 3072},
+            {{1, 1, 1}, 3584},
+            {{1, 1, 2}, 3328},
+            {{1, 1, 3}, 3840}
+    }));
+}
+
 int main(int argc, const char* argv[])
 {
     test_physical_sectors();
     test_logical_sectors();
     test_both_sectors();
     test_skew();
     test_bounds();
+    test_sectoroffsets();
 }
