Changeset 75815 in vbox for trunk/src/VBox/ImageMounter/vboxraw/vboxraw.cpp

Timestamp:

Nov 29, 2018 2:03:50 PM (6 years ago)

Author:

vboxsync

Message:

Improved cmd line options, and vm/media listing. Added partition mounting at FUSE level, Added support for MBR/EBR and GPT partition tables (ability to parse them and display summary information), and added self-sizing table class to neatly display partition data. (See #3641 for more information).

File:

• trunk/src/VBox/ImageMounter/vboxraw/vboxraw.cpp (modified) (45 diffs)

trunk/src/VBox/ImageMounter/vboxraw/vboxraw.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2009-2017 Oracle Corporation
+ * Copyright (C) 2009-2018 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -20 +20 @@
 *   Header Files                                                                                                                 *
 *********************************************************************************************************************************/
+
+/*** PKK TEMPORARY FOR DEBUGGING DON'T PUT INTO PRODUCTION CODE */
+#include <stdio.h>
+/*** END OF ADMONITION */
+
+
 #define LOG_GROUP LOG_GROUP_DEFAULT /** @todo log group */
 
@@ -27 +33 @@
 #endif
 #define MAX_READERS (INT32_MAX / 32)
-
 #include <fuse.h>
 #ifdef UNIX_DERIVATIVE
@@ -35 +40 @@
 #include <libgen.h>
 #include <unistd.h>
+#include <math.h>
+//#include <stdarg.h>
+#include <cstdarg>
 #include <sys/stat.h>
 #endif
@@ -70 +78 @@
 #include <iprt/types.h>
 #include <iprt/path.h>
-
+#include <iprt/utf16.h>
+
+#include "vboxraw.h"
+#include "SelfSizingTable.h"
+
+/*
+ * PKK: REMOVE AFTER DEBUGGING
+ */
 #pragma GCC diagnostic ignored "-Wunused-variable"
 #pragma GCC diagnostic ignored "-Wunused-parameter"
@@ -88 +103 @@
 } g_u;
 
-
-#define VD_SECTOR_SIZE                   0x200 /* 0t512 */
-#define VD_SECTOR_MASK                   (VD_SECTOR_SIZE - 1)
-#define VD_SECTOR_OUT_OF_BOUNDS_MASK     (~UINT64_C(VD_SECTOR_MASK))
-
-#define PADMAX                           50
-#define MAX_ID_LEN                       256
-#define CSTR(arg)                        Utf8Str(arg).c_str()
-
-static struct fuse_operations   g_vboxrawOps;
-PVDISK                g_pVDisk;
-int32_t               g_cReaders;
-int32_t               g_cWriters;
-RTFOFF                g_cbPrimary;
-char                 *g_pszBaseImageName;
-char                 *g_pszBaseImagePath;
-PVDINTERFACE          g_pVdIfs;             /** @todo Remove when VD I/O becomes threadsafe */
-VDINTERFACETHREADSYNC g_VDIfThreadSync;     /** @todo Remove when VD I/O becomes threadsafe */
-RTCRITSECT            g_vdioLock;           /** @todo Remove when VD I/O becomes threadsafe */
-
-char *nsIDToString(nsID *guid);
-void printErrorInfo();
-/** XPCOM stuff */
+const uint64_t KB = 1024;
+const uint64_t MB = KB * KB;
+const uint64_t GB = MB * KB;
+const uint64_t TB = GB * KB;
+const uint64_t PB = TB * KB;
+
+
+
+enum { PARTITION_TABLE_MBR = 1, PARTITION_TABLE_GPT = 2 };
+
+#define GPT_PTABLE_SIZE             32 * BLOCKSIZE   /** Max size we to read for GPT partition table */
+#define MBR_PARTITIONS_MAX          4                /** Fixed number of partitions in Master Boot Record */
+#define BASENAME_MAX                256              /** Maximum name for the basename of a path (for RTStrNLen()*/
+#define VBOXRAW_PARTITION_MAX       256              /** How much storage to allocate to store partition info */
+#define PARTITION_NAME_MAX          72               /** Maximum partition name size (accomodates GPT partition name) */
+#define BLOCKSIZE                   512              /** Commonly used disk block size */
+#define DOS_BOOT_RECORD_SIGNATURE   0xaa55           /** MBR and EBR (partition table) signature [EOT boundary] */
+#define NULL_BOOT_RECORD_SIGNATURE  0x0000           /** MBR or EBR null signature value */
+#define MAX_UUID_LEN                256              /** Max length of a UUID */
+#define LBA(n)                      (n * BLOCKSIZE)
+#define VD_SECTOR_SIZE              512              /** Virtual disk sector/blocksize */
+#define VD_SECTOR_MASK              (VD_SECTOR_SIZE - 1)    /** Masks off a blocks worth of data */
+#define VD_SECTOR_OUT_OF_BOUNDS_MASK  (~UINT64_C(VD_SECTOR_MASK))         /** Masks the overflow of a blocks worth of data */
+
+#define IS_BIG_ENDIAN (*(uint16_t *)"\0\xff" < 0x100)
+
+#define PARTTYPE_IS_NULL(parType) ((uint8_t)parType == 0x00)
+#define PARTTYPE_IS_GPT(parType)  ((uint8_t)parType == 0xee)
+#define PARTTYPE_IS_EXT(parType)  ((    (uint8_t)parType) == 0x05  /* Extended           */ \
+                                    || ((uint8_t)parType) == 0x0f  /* W95 Extended (LBA) */ \
+                                    || ((uint8_t)parType) == 0x85) /* Linux Extended     */
+
+#define SAFENULL(strPtr)   (strPtr ? strPtr : "")
+
+#define CSTR(arg)     Utf8Str(arg).c_str()          /* Converts XPCOM string type to C string type */
+
+
+static struct fuse_operations g_vboxrawOps;         /** FUSE structure that defines allowed ops for this FS */
+
+/* Global variables */
+
+static PVDISK                g_pVDisk;              /** Handle for Virtual Disk in contet */
+static char                 *g_pvDiskUuid;          /** UUID of image (if known, otherwise NULL) */
+static off_t                 g_vDiskOffset;         /** Biases r/w from start of VD */
+static off_t                 g_vDiskSize;           /** Limits r/w length for VD */
+static int32_t               g_cReaders;            /** Number of readers for VD */
+static int32_t               g_cWriters;            /** Number of writers for VD */
+static RTFOFF                g_cbEntireVDisk;       /** Size of VD */
+static char                 *g_pszBaseImageName;    /** Base filename for current VD image */
+static char                 *g_pszBaseImagePath;    /** Full path to current VD image */
+static PVDINTERFACE          g_pVdIfs;              /** @todo Remove when VD I/O becomes threadsafe */
+static VDINTERFACETHREADSYNC g_VDIfThreadSync;      /** @todo Remove when VD I/O becomes threadsafe */
+static RTCRITSECT            g_vdioLock;            /** @todo Remove when VD I/O becomes threadsafe */
+static uint16_t              g_lastPartNbr;         /** Last partition number found in MBR + EBR chain */
+static bool                  g_fGPT;                /** True if GPT type partition table was found */
+
+/* Table entry containing partition info parsed out of GPT or MBR and EBR chain of specified VD */
+
+typedef struct
+{
+    int            idxPartition;            /** partition number */
+    char           *pszName;
+    off_t          offPartition;        /** partition offset from start of disk, in bytes */
+    uint64_t       cbPartition;           /** partition size in bytes */
+    uint8_t        fBootable;               /** partition bootable */
+    union
+    {
+        uint8_t    legacy;                  /** partition type MBR/EBR */
+        uint128_t  gptGuidTypeSpecifier;    /** partition type GPT */
+    } partitionType;                        /** uint8_t for MBR/EBR (legacy) and GUID for GPT */
+
+    union
+    {
+        MBRPARTITIONENTRY mbrEntry;          /** MBR (also EBR partition entry) */
+        GPTPARTITIONENTRY gptEntry;          /** GPT partition entry */
+    } partitionEntry;
+} PARTITIONINFO;
+
+PARTITIONINFO g_aParsedPartitionInfo[VBOXRAW_PARTITION_MAX + 1]; /* Note: Element 0 reserved for EntireDisk partitionEntry */
 
 static struct vboxrawOpts {
-     char    *pszVm;
-     char    *pszImage;
-     char    *pszImageUuid;
-     uint32_t cHddImageDiffMax;
-     uint32_t fList;
-     uint32_t fAllowRoot;
-     uint32_t fRW;
-     uint32_t fVerbose;
+     char         *pszVm;                   /** optional VM UUID */
+     char         *pszImage;                /** Virtual Disk image UUID or path */
+     int32_t       idxPartition;            /** Number of partition to constrain FUSE based FS to (optional) 0 - whole disk*/
+     int32_t       offset;                  /** Offset to base virtual disk reads and writes from (altnerative to partition) */
+     int32_t       size;                    /** Size of accessible disk region, starting at offset, default = offset 0 */
+     uint32_t      cHddImageDiffMax;        /** Max number of differencing images (snapshots) to apply to image */
+     uint32_t      fListMedia;              /** Flag to list virtual disks of all known VMs */
+     uint32_t      fListMediaBrief;         /** Flag to list virtual disks of all known VMs */
+     uint32_t      fListParts;              /** Flag to summarily list partitions associated with pszImage */
+     uint32_t      fAllowRoot;              /** Flag to allow root to access this FUSE FS */
+     uint32_t      fRW;                     /** Flag to allow changes to FUSE-mounted Virtual Disk image */
+     uint32_t      fBriefUsage;             /** Flag to display only FS-specific program usage options */
+     uint32_t      fVerbose;                /** Make some noise */
 } g_vboxrawOpts;
 
@@ -126 +202 @@
 
 static struct fuse_opt vboxrawOptDefs[] = {
-    OPTION("--list",          fList,            1),
-    OPTION("--root",          fAllowRoot,       1),
-    OPTION("--vm=%s",         pszVm,            0),
-    OPTION("--maxdiff=%d",    cHddImageDiffMax, 1),
-    OPTION("--diff=%d",       cHddImageDiffMax, 1),
-    OPTION("--image=%s",      pszImage,         0),
-    OPTION("--rw",            fRW,              1),
-    OPTION("--verbose",       fVerbose,         1),
-    FUSE_OPT_KEY("-h",        USAGE_FLAG),
+    OPTION("-l",              fListMediaBrief,   1),
+    OPTION("-L",              fListMedia,        1),
+    OPTION("-t",              fListParts,        1),
+    OPTION("--root",          fAllowRoot,        1),
+    OPTION("--vm=%s",         pszVm,             0),
+    OPTION("--maxdiff=%d",    cHddImageDiffMax,  1),
+    OPTION("--diff=%d",       cHddImageDiffMax,  1),
+    OPTION("--partition=%d",  idxPartition,      1),
+    OPTION("-p %d",           idxPartition,      1),
+    OPTION("--offset=%d",     offset,            1),
+    OPTION("-o %d",           offset,            1),
+    OPTION("--size=%d",       size,              1),
+    OPTION("-s %d",           size,              1),
+    OPTION("--image=%s",      pszImage,          0),
+    OPTION("-i %s",           pszImage,          0),
+    OPTION("--rw",            fRW,               1),
+    OPTION("--verbose",       fVerbose,          1),
+    OPTION("-v",              fVerbose,          1),
+    OPTION("-h",              fBriefUsage,       1),
     FUSE_OPT_KEY("--help",    USAGE_FLAG),
     FUSE_OPT_END
 };
 
-static int vboxrawOptHandler(void *data, const char *arg, int optKey, struct fuse_args *outargs)
+static void
+briefUsage()
+{
+    RTPrintf("usage: vboxraw [options] <mountpoint>\n\n"
+        "vboxraw options:\n\n"
+        "    [ -l ]                                     List virtual disk media (brief version)\n"
+        "    [ -L ]                                     List virtual disk media (long version)\n"
+        "    [ -t ]                                     List partition table (requires -i or --image option)\n"
+        "\n"
+        "    [ { -i | --image= } <UUID | name | path> ] Virtual Box disk image to use\n"
+        "\n"
+        "    [ { -p | --partition= } <partition #> ]    Mount specified partition number via FUSE\n"
+        "\n"
+        "    [ { -o | --offset= } <byte #> ]            Disk I/O will be based on offset from disk start\n"
+        "                                               (Can't use with -p or --partition options)\n"
+        "\n"
+        "    [ -s | --size=<bytes>]                     Sets size of mounted disk from disk start or from\n"
+        "                                               offset, if specified. (Can't use with\n"
+        "                                               -p or --partition options)\n"
+        "\n"
+        "    [ --diff=<diff #> ]                        Apply diffs (snapshot differencing disk images)\n"
+        "                                               to specified base disk image up to and including\n"
+        "                                               specified diff number.\n"
+        "                                               (0 = Apply no diffs, default = Apply all diffs)\n"
+        "\n"
+        "    [ --rw]                                    Make image writeable (default = readonly)\n"
+        "    [ --root]                                  Same as -o allow_root\n"
+        "\n"
+        "    [ --vm < Path | UUID >]                    VM UUID (limit media list to specific VM)\n"
+        "\n"
+        "    [ --verbose]                               Log extra information\n"
+        "    -o opt[,opt...]                            FUSE mount options\n"
+        "    -h                                         Display short usage info showing only the above\n"
+        "    --help                                     Display long usage info (including FUSE opts)\n\n"
+    );
+    RTPrintf("\n");
+    RTPrintf("When successful, the --image option creates a one-directory-deep filesystem \n");
+    RTPrintf("rooted at the specified mountpoint.  The contents of the directory will be \n");
+    RTPrintf("a symbolic link with the base name of the image file pointing to the path of\n");
+    RTPrintf("the virtual disk image, and a regular file named 'vhdd', which represents\n");
+    RTPrintf("the byte stream of the disk image as interpreted by VirtualBox.\n");
+    RTPrintf("It is the vhdd file that the user or a utility will subsequently mount on\n");
+    RTPrintf("the host OS to gain access to the virtual disk contents.\n\n");
+    RTPrintf("If any of the partition, size or offset related options are used the\n");
+    RTPrintf("The constraining start offset (in bytes) and size (in bytes) will be\n");
+    RTPrintf("appended in brackets to the symbolic link basename to indicate\n");
+    RTPrintf("what part of the image is exposed by the FUSE filesystem implementation.\n\n");
+}
+
+static int
+vboxrawOptHandler(void *data, const char *arg, int optKey, struct fuse_args *outargs)
 {
     (void) data;
     (void) arg;
-
-    char *progname = basename(outargs->argv[0]);
     switch(optKey)
     {
         case USAGE_FLAG:
-            RTPrintf("usage: %s [options] <mountpoint>\n\n"
-                "%s options:\n"
-                "    [--list]                              List media\n"
-                "    [--root]                              Same as -o allow_root\n"
-                "    [--rw]                                writeable (default = readonly)\n"
-                "    [--vm <name | UUID >]                 vm UUID (limit media list to specific VM)\n\n"
-                "    [--diff=<diff #> ]                    Apply diffs to base image up "
-                                                          "to and including specified diff #\n"
-                "                                          (0 = no diffs, default: all diffs)\n\n"
-                "    [--image=<UUID, name or path>]        Image UUID or path\n"
-                "    [--verbose]                           Log extra information\n"
-                "    -o opt[,opt...]                       mount options\n"
-                "    -h --help                             print usage\n\n",
-                    progname, progname);
-            RTPrintf("\n");
-            RTPrintf("When successful, the --image option creates a one-directory-deep filesystem \n");
-            RTPrintf("rooted at the specified mountpoint.  The contents of the directory will be \n");
-            RTPrintf("a symbolic link with the base name of the image file pointing to the path of\n");
-            RTPrintf("the virtual disk image, and a regular file named 'vhdd', which represents\n");
-            RTPrintf("the byte stream of the disk image as interpreted by VirtualBox.\n");
-            RTPrintf("It is the vhdd file that the user or a utility will subsequently mount on\n");
-            RTPrintf("the host OS to gain access to the virtual disk contents.\n\n");
+            briefUsage();
             fuse_opt_add_arg(outargs, "-ho");
             fuse_main(outargs->argc, outargs->argv, &g_vboxrawOps, NULL);
-            exit(1);
+            break;
     }
     return 1;
@@ -207 +320 @@
         rc = -EINVAL;
 #   ifdef O_DIRECTORY
-        if (pInfo->flags & O_DIRECTORY)
-            rc = -ENOTDIR;
+    if (pInfo->flags & O_DIRECTORY)
+        rc = -ENOTDIR;
 #   endif
 #endif
@@ -263 +376 @@
     return RTCritSectLeave(vdioLock);
 }
-
 /** @todo (end of to do section) */
 
@@ -290 +402 @@
     return 0;
 }
-
 
 /**
  * VD read Sanitizer taking care of unaligned accesses.
  *
- * @return  VBox status code.
+ * @return  VBox bootIndicator code.
  * @param   pDisk    VD disk container.
  * @param   off      Offset to start reading from.
@@ -305 +416 @@
     int rc;
 
-    uint64_t const cbMisalignHead = off & VD_SECTOR_MASK;
-    uint64_t const cbMisalignTail  = (off + cbRead) & VD_SECTOR_MASK;
-
-    if (cbMisalignHead + cbMisalignTail == 0) /* perfectly aligned request; just read it and done */
+    uint64_t const cbMisalignmentOfStart = off & VD_SECTOR_MASK;
+    uint64_t const cbMisalignmentOfEnd  = (off + cbRead) & VD_SECTOR_MASK;
+
+    if (cbMisalignmentOfStart + cbMisalignmentOfEnd == 0) /* perfectly aligned request; just read it and done */
         rc = VDRead(pDisk, off, pvBuf, cbRead);
     else
@@ -318 +429 @@
          * bytes (requested by user), only up to sector boundary, into user's buffer
          */
-        if (cbMisalignHead)
-        {
-            rc = VDRead(pDisk, off - cbMisalignHead, abBuf, VD_SECTOR_SIZE);
+        if (cbMisalignmentOfStart)
+        {
+            rc = VDRead(pDisk, off - cbMisalignmentOfStart, abBuf, VD_SECTOR_SIZE);
             if (RT_SUCCESS(rc))
             {
-                size_t const cbPart = RT_MIN(VD_SECTOR_SIZE - cbMisalignHead, cbRead);
-                memcpy(pbBuf, &abBuf[cbMisalignHead], cbPart);
-                pbBuf  += cbPart;
-                off    += cbPart; /* Beginning of next sector or EOD */
-                cbRead -= cbPart; /* # left to read */
+                size_t const cbPartial = RT_MIN(VD_SECTOR_SIZE - cbMisalignmentOfStart, cbRead);
+                memcpy(pbBuf, &abBuf[cbMisalignmentOfStart], cbPartial);
+                pbBuf  += cbPartial;
+                off    += cbPartial; /* Beginning of next sector or EOD */
+                cbRead -= cbPartial; /* # left to read */
             }
         }
@@ -338 +449 @@
             Assert(!(off % VD_SECTOR_SIZE));
 
-            size_t cbPart = cbRead - cbMisalignTail;
-            Assert(!(cbPart % VD_SECTOR_SIZE));
-            rc = VDRead(pDisk, off, pbBuf, cbPart);
+            size_t cbPartial = cbRead - cbMisalignmentOfEnd;
+            Assert(!(cbPartial % VD_SECTOR_SIZE));
+            rc = VDRead(pDisk, off, pbBuf, cbPartial);
             if (RT_SUCCESS(rc))
             {
-                pbBuf  += cbPart;
-                off    += cbPart;
-                cbRead -= cbPart;
+                pbBuf  += cbPartial;
+                off    += cbPartial;
+                cbRead -= cbPartial;
             }
         }
@@ -352 +463 @@
         if (RT_SUCCESS(rc) && cbRead)
         {
-            Assert(cbRead == cbMisalignTail);
+            Assert(cbRead == cbMisalignmentOfEnd);
             Assert(cbRead < VD_SECTOR_SIZE);
             Assert(!(off % VD_SECTOR_SIZE));
@@ -374 +485 @@
  * VD write Sanitizer taking care of unaligned accesses.
  *
- * @return  VBox status code.
+ * @return  VBox bootIndicator code.
  * @param   pDisk    VD disk container.
  * @param   off      Offset to start writing to.
@@ -386 +497 @@
     int rc;
     int cbRemaining = cbWrite;
+
     /*
      * Take direct route if the request is sector aligned.
      */
-    uint64_t const cbMisalignHead = off & 511;
-    size_t   const cbMisalignTail  = (off + cbWrite) & 511;
-    if (!cbMisalignHead && !cbMisalignTail)
+    uint64_t const cbMisalignmentOfStart = off & VD_SECTOR_MASK;
+    size_t   const cbMisalignmentOfEnd  = (off + cbWrite) & VD_SECTOR_MASK;
+    if (!cbMisalignmentOfStart && !cbMisalignmentOfEnd)
     {
           rc = VDWrite(pDisk, off, pbSrc, cbWrite);
@@ -413 +525 @@
          * Unaligned buffered read+write of head.  Aligns the offset.
          */
-        if (cbMisalignHead)
-        {
-            rc = VDRead(pDisk, off - cbMisalignHead, abBuf, VD_SECTOR_SIZE);
+        if (cbMisalignmentOfStart)
+        {
+            rc = VDRead(pDisk, off - cbMisalignmentOfStart, abBuf, VD_SECTOR_SIZE);
             if (RT_SUCCESS(rc))
             {
-                size_t const cbPart = RT_MIN(VD_SECTOR_SIZE - cbMisalignHead, cbWrite);
-                memcpy(&abBuf[cbMisalignHead], pbSrc, cbPart);
-                rc = VDWrite(pDisk, off - cbMisalignHead, abBuf, VD_SECTOR_SIZE);
+                size_t const cbPartial = RT_MIN(VD_SECTOR_SIZE - cbMisalignmentOfStart, cbWrite);
+                memcpy(&abBuf[cbMisalignmentOfStart], pbSrc, cbPartial);
+                rc = VDWrite(pDisk, off - cbMisalignmentOfStart, abBuf, VD_SECTOR_SIZE);
                 if (RT_SUCCESS(rc))
                 {
-                    pbSrc   += cbPart;
-                    off     += cbPart;
-                    cbRemaining -= cbPart;
+                    pbSrc   += cbPartial;
+                    off     += cbPartial;
+                    cbRemaining -= cbPartial;
                 }
             }
@@ -438 +550 @@
         {
             Assert(!(off % VD_SECTOR_SIZE));
-            size_t cbPart = cbWrite - cbMisalignTail;
-            Assert(!(cbPart % VD_SECTOR_SIZE));
-            rc = VDWrite(pDisk, off, pbSrc, cbPart);
+            size_t cbPartial = cbWrite - cbMisalignmentOfEnd;
+            Assert(!(cbPartial % VD_SECTOR_SIZE));
+            rc = VDWrite(pDisk, off, pbSrc, cbPartial);
             if (RT_SUCCESS(rc))
             {
-                pbSrc   += cbPart;
-                off     += cbPart;
-                cbRemaining -= cbPart;
+                pbSrc   += cbPartial;
+                off     += cbPartial;
+                cbRemaining -= cbPartial;
             }
         }
@@ -454 +566 @@
         if (   RT_SUCCESS(rc) && cbWrite > 0)
         {
-            Assert(cbWrite == cbMisalignTail);
+            Assert(cbWrite == cbMisalignmentOfEnd);
             Assert(cbWrite < VD_SECTOR_SIZE);
             Assert(!(off % VD_SECTOR_SIZE));
@@ -488 +600 @@
     AssertReturn((unsigned)cbBuf == cbBuf, -EINVAL);
 
+    AssertReturn(offset + g_vDiskOffset >= 0, -EINVAL);
+    int64_t adjOff = offset + g_vDiskOffset;
+
     int rc = 0;
-    if ((off_t)(offset + cbBuf) < offset)
+    if ((off_t)(adjOff + cbBuf) < adjOff)
         rc = -EINVAL;
-    else if (offset >= g_cbPrimary)
+    else if (adjOff >= g_vDiskSize)
         return 0;
     else if (!cbBuf)
@@ -497 +612 @@
 
     if (rc >= 0)
-        rc = vdReadSanitizer(g_pVDisk, offset, pbBuf, cbBuf);
+        rc = vdReadSanitizer(g_pVDisk, adjOff, pbBuf, cbBuf);
     if (rc < 0)
         LogFlowFunc(("%s\n", strerror(rc)));
@@ -515 +630 @@
     AssertReturn((int)cbBuf >= 0, -EINVAL);
     AssertReturn((unsigned)cbBuf == cbBuf, -EINVAL);
+    AssertReturn(offset + g_vDiskOffset >= 0, -EINVAL);
+    int64_t adjOff = offset + g_vDiskOffset;
 
     int rc = 0;
@@ -521 +638 @@
                      "              (write operation ignored w/o error!)\n"));
         return cbBuf;
-    } else if ((off_t)(offset + cbBuf) < offset)
+    } else if ((off_t)(adjOff + cbBuf) < adjOff)
         rc = -EINVAL;
-    else if (offset >= g_cbPrimary)
+    else if (offset >= g_vDiskSize)
         return 0;
     else if (!cbBuf)
@@ -529 +646 @@
 
     if (rc >= 0)
-        rc = vdWriteSanitizer(g_pVDisk, offset, pbBuf, cbBuf);
+        rc = vdWriteSanitizer(g_pVDisk, adjOff, pbBuf, cbBuf);
     if (rc < 0)
         LogFlowFunc(("%s\n", strerror(rc)));
@@ -556 +673 @@
         if (rc < 0)
             return rc;
-
-        stbuf->st_size = VDGetSize(g_pVDisk, 0);
+        /*
+         * st_size represents the size of the FUSE FS-mounted portion of the disk.
+         * By default it is the whole disk, but can be a partition or specified
+         * (or overridden) directly by the { -s | --size } option on the command line.
+         */
+        stbuf->st_size = g_vDiskSize;
         stbuf->st_nlink = 1;
     }
-    else if (RTStrCmp(pszPath + 1, g_pszBaseImageName) == 0)
-    {
+    else if (RTStrNCmp(pszPath + 1, g_pszBaseImageName, strlen(g_pszBaseImageName)) == 0)
+    {
+        /* When the disk is partitioned, the symbolic link named from `basename` of
+         * resolved path to VBox disk image, has appended to it formatted text
+         * representing the offset range of the partition.
+         *
+         *  $ vboxraw -i /stroll/along/the/path/simple_fixed_disk.vdi -p 1 /mnt/tmpdir
+         *  $ ls /mnt/tmpdir
+         *  simple_fixed_disk.vdi[20480:2013244928]    vhdd
+         */
         rc = stat(g_pszBaseImagePath, stbuf);
         if (rc < 0)
@@ -590 +719 @@
 
     /*
-     * The usual suspects (mandatory)
+     *  mandatory '.', '..', ...
      */
     pfnFiller(pvBuf, ".", NULL, 0);
@@ -596 +725 @@
 
     /*
-     * Create one entry w/basename of original image that getattr() will
-     * depict as a symbolic link pointing back to the original file,
-     * as a convenience, so anyone who lists the FUSE file system can
-     * easily find the associated vdisk.
+     * Create FUSE FS dir entry that is depicted here (and exposed via stat()) as
+     * a symbolic link back to the resolved path to the VBox virtual disk image,
+     * whose symlink name is basename that path. This is a convenience so anyone
+     * listing the dir can figure out easily what the vhdd FUSE node entry
+     * represents.
      */
-    pfnFiller(pvBuf, g_pszBaseImageName, NULL, 0);
-
+
+    if (g_vDiskOffset == 0 && (g_vDiskSize == 0 || g_vDiskSize == g_cbEntireVDisk))
+        pfnFiller(pvBuf, g_pszBaseImageName, NULL, 0);
+    else
+    {
+        char tmp[BASENAME_MAX];
+        RTStrPrintf(tmp, sizeof (tmp), "%s[%d:%d]", g_pszBaseImageName, g_vDiskOffset, g_vDiskSize);
+        pfnFiller(pvBuf, tmp, NULL, 0);
+    }
     /*
      * Create entry named "vhdd", which getattr() will describe as a
@@ -622 +759 @@
 
 static void
-listMedia(IMachine *pMachine)
+listMedia(IMachine *pMachine, char *vmName, char *vmUuid)
 {
     int rc = 0;
@@ -628 +765 @@
 
     CHECK_ERROR(pMachine, COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(pMediumAttachments)));
+    int firstIteration = 1;
     for (size_t i = 0; i < pMediumAttachments.size(); i++)
     {
+
         ComPtr<IMedium> pMedium;
         DeviceType_T deviceType;
@@ -661 +800 @@
             if (pEarliestAncestor.isNull())
                 return;
-            RTPrintf("\n");
             do
             {
@@ -671 +809 @@
                 if (ancestorNumber == 0)
                 {
-                    RTPrintf("   -----------------------\n");
-                    RTPrintf("   HDD base:   \"%s\"\n",   CSTR(pMediumName));
-                    RTPrintf("   UUID:       %s\n",       CSTR(pMediumUuid));
-                    RTPrintf("   Location:   %s\n\n",     CSTR(pMediumPath));
+                    if (!g_vboxrawOpts.fListMediaBrief)
+                    {
+                        RTPrintf("   -----------------------\n");
+                        RTPrintf("   HDD base:   \"%s\"\n",   CSTR(pMediumName));
+                        RTPrintf("   UUID:       %s\n",       CSTR(pMediumUuid));
+                        RTPrintf("   Location:   %s\n\n",     CSTR(pMediumPath));
+                    }
+                    else
+                    {
+                        if (firstIteration)
+                            RTPrintf("\nVM:    %s " ANSI_BOLD "%-20s" ANSI_RESET "\n",
+                                vmUuid, vmName);
+                        RTPrintf("  img: %s " ANSI_BOLD "  %s" ANSI_RESET "\n",
+                            CSTR(pMediumUuid), CSTR(pMediumName));
+                    }
                 }
                 else
                 {
-                    RTPrintf("     Diff %d:\n", ancestorNumber);
-                    RTPrintf("          UUID:       %s\n",    CSTR(pMediumUuid));
-                    RTPrintf("          Location:   %s\n\n",  CSTR(pMediumPath));
+                    if (!g_vboxrawOpts.fListMediaBrief)
+                    {
+                        RTPrintf("     Diff %d:\n", ancestorNumber);
+                        RTPrintf("          UUID:       %s\n",    CSTR(pMediumUuid));
+                        RTPrintf("          Location:   %s\n",  CSTR(pMediumPath));
+                    }
                 }
                 CHECK_ERROR_BREAK(pChild, COMGETTER(Children)(ComSafeArrayAsOutParam(aMediumChildren)));
                 pChild = (aMediumChildren.size()) ? aMediumChildren[0] : NULL;
                 ++ancestorNumber;
+                firstIteration = 0;
             } while(pChild);
         }
@@ -720 +873 @@
 
                 if (   g_vboxrawOpts.pszVm == NULL
-                    || RTStrNCmp(CSTR(pMachineUuid), g_vboxrawOpts.pszVm, MAX_ID_LEN) == 0
-                    || RTStrNCmp((const char *)pMachineName.raw(), g_vboxrawOpts.pszVm, MAX_ID_LEN) == 0)
+                    || RTStrNCmp(CSTR(pMachineUuid), g_vboxrawOpts.pszVm, MAX_UUID_LEN) == 0
+                    || RTStrNCmp((const char *)pMachineName.raw(), g_vboxrawOpts.pszVm, MAX_UUID_LEN) == 0)
                 {
-                    RTPrintf("------------------------------------------------------\n");
-                    RTPrintf("VM Name:   \"%s\"\n", CSTR(pMachineName));
-                    RTPrintf("UUID:      %s\n",     CSTR(pMachineUuid));
-                    if (*pDescription.raw() != '\0')
-                        RTPrintf("Description:  %s\n",      CSTR(pDescription));
-                    RTPrintf("Location:  %s\n",      CSTR(pMachineLocation));
-
-                    listMedia(pMachine);
-
-                    RTPrintf("\n");
+                    if (!g_vboxrawOpts.fListMediaBrief)
+                    {
+                        RTPrintf("------------------------------------------------------\n");
+                        RTPrintf("VM Name:   \"%s\"\n", CSTR(pMachineName));
+                        RTPrintf("UUID:      %s\n",     CSTR(pMachineUuid));
+                        if (*pDescription.raw() != '\0')
+                            RTPrintf("Description:  %s\n",      CSTR(pDescription));
+                        RTPrintf("Location:  %s\n",      CSTR(pMachineLocation));
+                    }
+                    listMedia(pMachine, RTStrDup(CSTR(pMachineName)), RTStrDup(CSTR(pMachineUuid)));
+                }
+                else
+                {
+                    listMedia(pMachine, RTStrDup(CSTR(pMachineName)), RTStrDup(CSTR(pMachineUuid)));
                 }
             }
@@ -766 +923 @@
 }
 
+uint8_t
+parsePartitionTable(void)
+{
+    MBR_t mbr;
+    EBR_t ebr;
+    PTH_t parTblHdr;
+
+    ASSERT(sizeof (mbr) == 512);
+    ASSERT(sizeof (ebr) == 512);
+    /*
+     * First entry describes entire disk as a single entity
+     */
+    g_aParsedPartitionInfo[0].idxPartition = 0;
+    g_aParsedPartitionInfo[0].offPartition = 0;
+    g_aParsedPartitionInfo[0].cbPartition = VDGetSize(g_pVDisk, 0);
+    g_aParsedPartitionInfo[0].pszName = RTStrDup("EntireDisk");
+
+    /*
+     * Currently only DOS partitioned disks are supported. Ensure this one conforms
+     */
+    int rc = vdReadSanitizer(g_pVDisk, 0, &mbr, sizeof (mbr));
+    if (RT_FAILURE(rc))
+        return RTMsgErrorExitFailure("Error reading MBR block from disk\n");
+
+    if (mbr.signature == NULL_BOOT_RECORD_SIGNATURE)
+        return RTMsgErrorExitFailure("Unprt disk (null MBR signature)\n");
+
+    if (mbr.signature != DOS_BOOT_RECORD_SIGNATURE)
+        return RTMsgErrorExitFailure("Invalid MBR found on image with signature 0x%04hX\n",
+            mbr.signature);
+    /*
+     * Parse the four physical partition entires in the MBR (any one, and only one, can be an EBR)
+     */
+    int ebridxPartitionInMbr = 0;
+    for (int idxPartition = 1;
+             idxPartition <= MBR_PARTITIONS_MAX;
+             idxPartition++)
+    {
+        MBRPARTITIONENTRY *pMbrPartitionEntry =
+            &g_aParsedPartitionInfo[idxPartition].partitionEntry.mbrEntry;;
+        memcpy (pMbrPartitionEntry, &mbr.partitionEntry[idxPartition - 1], sizeof (MBRPARTITIONENTRY));
+
+        if (PARTTYPE_IS_NULL(pMbrPartitionEntry->type))
+            continue;
+
+        if (PARTTYPE_IS_EXT(pMbrPartitionEntry->type))
+        {
+            if (ebridxPartitionInMbr)
+                 return RTMsgErrorExitFailure("Multiple EBRs found found in MBR\n");
+            ebridxPartitionInMbr = idxPartition;
+        }
+
+        PARTITIONINFO *ppi = &g_aParsedPartitionInfo[idxPartition];
+
+        ppi->idxPartition = idxPartition;
+        ppi->offPartition = (off_t) pMbrPartitionEntry->partitionLba * BLOCKSIZE;
+        ppi->cbPartition = (off_t) pMbrPartitionEntry->partitionBlkCnt * BLOCKSIZE;
+        ppi->fBootable = pMbrPartitionEntry->bootIndicator == 0x80;
+        (ppi->partitionType).legacy = pMbrPartitionEntry->type;
+
+        g_lastPartNbr = idxPartition;
+
+        if (PARTTYPE_IS_GPT(pMbrPartitionEntry->type))
+        {
+            g_fGPT = true;
+            break;
+        }
+    }
+
+    if (g_fGPT)
+    {
+        g_lastPartNbr = 2;  /* from the 'protective MBR' */
+
+        rc = vdReadSanitizer(g_pVDisk, LBA(1), &parTblHdr, sizeof (parTblHdr));
+        if (RT_FAILURE(rc))
+            return RTMsgErrorExitFailure("Error reading Partition Table Header (LBA 1) from disk\n");
+
+        uint8_t *pTblBuf = (uint8_t *)RTMemAlloc(GPT_PTABLE_SIZE);
+
+        RTPrintf( "Virtual disk image:\n\n");
+        RTPrintf("   Path: %s\n", g_pszBaseImagePath);
+        if (g_pvDiskUuid)
+            RTPrintf("   UUID: %s\n\n", g_pvDiskUuid);
+
+        if (g_vboxrawOpts.fVerbose)
+        {
+            RTPrintf("   GPT Partition Table Header:\n\n");
+            if (RTStrCmp((const char *)&parTblHdr.signature, "EFI PART") == 0)
+                RTPrintf(
+                     "      Signature               \"EFI PART\" (0x%llx)\n", parTblHdr.signature);
+            else
+                RTPrintf(
+                     "      Signature:              0x%llx\n",  parTblHdr.signature);
+            RTPrintf("      Revision:               %-8.8x\n",  parTblHdr.revision);
+            RTPrintf("      Current LBA:            %lld\n",    parTblHdr.headerLba);
+            RTPrintf("      Backup LBA:             %lld\n",    parTblHdr.backupLba);
+            RTPrintf("      Partition entries LBA:  %lld\n",    parTblHdr.partitionEntriesLba);
+            RTPrintf("      # of partitions:        %d\n",      parTblHdr.cPartitionEntries);
+            RTPrintf("      size of entry:          %d\n\n",    parTblHdr.cbPartitionEntry);
+        }
+
+        if (!pTblBuf)
+            return RTMsgErrorExitFailure("Out of memory\n");
+
+        rc = vdReadSanitizer(g_pVDisk, LBA(2), pTblBuf, GPT_PTABLE_SIZE);
+        if (RT_FAILURE(rc))
+            return RTMsgErrorExitFailure("Error reading Partition Table blocks from disk\n");
+
+        uint32_t cEntries = parTblHdr.cPartitionEntries;
+        uint32_t cbEntry  = parTblHdr.cbPartitionEntry;
+        if (cEntries * cbEntry > GPT_PTABLE_SIZE)
+        {
+            RTPrintf("Partition entries exceed GPT table read from disk (pruning!)\n");
+            while (cEntries * cbEntry > GPT_PTABLE_SIZE && cEntries > 0)
+                --cEntries;
+        }
+        uint8_t *pEntryRaw = pTblBuf;
+        for (uint32_t i = 0; i < cEntries; i++)
+        {
+            GPTPARTITIONENTRY *pEntry = (GPTPARTITIONENTRY *)pEntryRaw;
+            PARTITIONINFO *ppi = &g_aParsedPartitionInfo[g_lastPartNbr];
+            memcpy(&(ppi->partitionEntry).gptEntry, pEntry, sizeof(GPTPARTITIONENTRY));
+            uint64_t firstLba = pEntry->firstLba;
+            uint64_t lastLba  = pEntry->lastLba;
+            if (!firstLba)
+                break;
+            ppi->offPartition = firstLba * BLOCKSIZE;
+            ppi->cbPartition = (lastLba - firstLba) * BLOCKSIZE;
+            ppi->fBootable = pEntry->attrFlags & (1 << GPT_LEGACY_BIOS_BOOTABLE);
+            ppi->partitionType.gptGuidTypeSpecifier = pEntry->partitionTypeGuid;
+            size_t cwName = sizeof (pEntry->partitionName) / 2;
+            char *pszTmp = NULL, **pPszTmp = &pszTmp;
+            RTUtf16LittleToUtf8Ex((PRTUTF16)pEntry->partitionName, RTSTR_MAX, &ppi->pszName, cwName, NULL);
+            ppi->idxPartition = g_lastPartNbr++;
+            pEntryRaw += cbEntry;
+        }
+        return PARTITION_TABLE_GPT;
+    }
+
+    /*
+     * Starting with EBR located in MBR, walk EBR chain to parse the logical partition entries
+     */
+    if (ebridxPartitionInMbr)
+    {
+        uint32_t firstEbrLba
+            = g_aParsedPartitionInfo[ebridxPartitionInMbr].partitionEntry.mbrEntry.partitionLba;
+        off_t    firstEbrOffset   = (off_t)firstEbrLba * BLOCKSIZE;
+        off_t    chainedEbrOffset = 0;
+
+        if (!firstEbrLba)
+            return RTMsgErrorExitFailure("Inconsistency for logical partition start. Aborting\n");
+
+        for (int idxPartition = 5;
+                 idxPartition <= VBOXRAW_PARTITION_MAX;
+                 idxPartition++)
+        {
+
+            off_t currentEbrOffset = firstEbrOffset + chainedEbrOffset;
+            vdReadSanitizer(g_pVDisk, currentEbrOffset, &ebr, sizeof (ebr));
+
+            if (ebr.signature != DOS_BOOT_RECORD_SIGNATURE)
+                return RTMsgErrorExitFailure("Invalid EBR found on image with signature 0x%04hX\n",
+                    ebr.signature);
+
+            MBRPARTITIONENTRY *pEbrPartitionEntry =
+                &g_aParsedPartitionInfo[idxPartition].partitionEntry.mbrEntry; /* EBR entry struct same as MBR */
+            memcpy(pEbrPartitionEntry, &ebr.partitionEntry, sizeof (MBRPARTITIONENTRY));
+
+            if (pEbrPartitionEntry->type == NULL_BOOT_RECORD_SIGNATURE)
+                return RTMsgErrorExitFailure("Logical partition with type 0 encountered");
+
+            if (!pEbrPartitionEntry->partitionLba)
+                return RTMsgErrorExitFailure("Logical partition invalid partition start offset (LBA) encountered");
+
+            PARTITIONINFO *ppi = &g_aParsedPartitionInfo[idxPartition];
+            ppi->idxPartition         = idxPartition;
+            ppi->offPartition    = currentEbrOffset + (off_t)pEbrPartitionEntry->partitionLba * BLOCKSIZE;
+            ppi->cbPartition        = (off_t)pEbrPartitionEntry->partitionBlkCnt * BLOCKSIZE;
+            ppi->fBootable            = pEbrPartitionEntry->bootIndicator == 0x80;
+            ppi->partitionType.legacy = pEbrPartitionEntry->type;
+
+            g_lastPartNbr = idxPartition;
+
+            if (ebr.chainingPartitionEntry.type == 0) /* end of chain */
+                break;
+
+            if (!PARTTYPE_IS_EXT(ebr.chainingPartitionEntry.type))
+                return RTMsgErrorExitFailure("Logical partition chain broken");
+
+            chainedEbrOffset = ebr.chainingPartitionEntry.partitionLba * BLOCKSIZE;
+        }
+    }
+    return PARTITION_TABLE_MBR;
+}
+
+const char *getClassicPartitionDesc(uint8_t type)
+{
+    for (uint32_t i = 0; i < sizeof (g_partitionDescTable) / sizeof (struct PartitionDesc); i++)
+    {
+        if (g_partitionDescTable[i].type == type)
+            return g_partitionDescTable[i].desc;
+    }
+    return "????";
+}
+
+void
+displayGptPartitionTable(void)
+{
+
+    void *colBoot = NULL;
+
+    SELFSIZINGTABLE tbl(2);
+
+    /* Note: Omitting partition name column because type/UUID seems suffcient */
+    void *colPartNbr   = tbl.addCol("#",                 "%3d",       1);
+
+    /* If none of the partitions supports legacy BIOS boot, don't show column */
+    for (int idxPartition = 2; idxPartition <= g_lastPartNbr; idxPartition++)
+        if (g_aParsedPartitionInfo[idxPartition].fBootable) {
+            colBoot    = tbl.addCol("Boot",         "%c   ",     1);
+            break;
+        }
+
+    void *colStart     = tbl.addCol("Start",             "%lld",      1);
+    void *colSectors   = tbl.addCol("Sectors",           "%lld",     -1, 2);
+    void *colSize      = tbl.addCol("Size",              "%d.%d%c",   1);
+    void *colOffset    = tbl.addCol("Offset",            "%lld",      1);
+    /* Need to see how other OSes with GPT schemes use this field. Seems like type covers it
+    void *colName      = tbl.addCol("Name",              "%s",       -1); */
+    void *colType      = tbl.addCol("Type",              "%s",       -1, 2);
+
+    for (int idxPartition = 2; idxPartition <= g_lastPartNbr; idxPartition++)
+    {
+        PARTITIONINFO *ppi = &g_aParsedPartitionInfo[idxPartition];
+        if (ppi->idxPartition)
+        {
+            uint8_t exp = log2((double)ppi->cbPartition);
+            char scaledMagnitude = ((char []){ ' ', 'K', 'M', 'G', 'T', 'P' })[exp / 10];
+
+             /* This workaround is because IPRT RT*Printf* funcs don't handle floating point format specifiers */
+            double cbPartitionScaled = (double)ppi->cbPartition / pow(2, (double)(((uint8_t)(exp / 10)) * 10));
+            uint8_t cbPartitionIntPart = cbPartitionScaled;
+            uint8_t cbPartitionFracPart = (cbPartitionScaled - (double)cbPartitionIntPart) * 10;
+
+            char abGuid[GUID_STRING_LENGTH * 2];
+            RTStrPrintf(abGuid, sizeof(abGuid), "%RTuuid",  &ppi->partitionType.gptGuidTypeSpecifier);
+
+            char *pszPartitionTypeDesc = NULL;
+            for (uint32_t i = 0; i < sizeof(g_gptPartitionTypes) / sizeof(GPTPARTITIONTYPE); i++)
+                if (RTStrNICmp(abGuid, g_gptPartitionTypes[i].gptPartitionUuid, GUID_STRING_LENGTH) == 0)
+                {
+                    pszPartitionTypeDesc =  (char *)g_gptPartitionTypes[i].gptPartitionTypeDesc;
+                    break;
+                }
+
+            if (!pszPartitionTypeDesc)
+                RTPrintf("Couldn't find GPT partitiontype for GUID: %s\n", abGuid);
+
+            void *row = tbl.addRow();
+            tbl.setCell(row, colPartNbr,    idxPartition - 1);
+            if (colBoot)
+                tbl.setCell(row, colBoot,   ppi->fBootable ? '*' : ' ');
+            tbl.setCell(row, colStart,      ppi->offPartition / BLOCKSIZE);
+            tbl.setCell(row, colSectors,    ppi->cbPartition / BLOCKSIZE);
+            tbl.setCell(row, colSize,       cbPartitionIntPart, cbPartitionFracPart, scaledMagnitude);
+            tbl.setCell(row, colOffset,     ppi->offPartition);
+/*          tbl.setCell(row, colName,       ppi->pszName);    ... see comment for column definition */
+            tbl.setCell(row, colType,       SAFENULL(pszPartitionTypeDesc));
+        }
+    }
+    tbl.displayTable();
+    RTPrintf ("\n");
+}
+
+void
+displayLegacyPartitionTable(void)
+{
+    /*
+     * Partition table is most readable and concise when headers and columns
+     * are adapted to the actual data, to avoid insufficient or excessive whitespace.
+     */
+    RTPrintf( "Virtual disk image:\n\n");
+    RTPrintf("   Path: %s\n", g_pszBaseImagePath);
+    if (g_pvDiskUuid)
+        RTPrintf("   UUID: %s\n\n", g_pvDiskUuid);
+
+    SELFSIZINGTABLE tbl(2);
+
+    void *colPartition = tbl.addCol("Partition",    "%s%d",     -1);
+    void *colBoot      = tbl.addCol("Boot",         "%c   ",     1);
+    void *colStart     = tbl.addCol("Start",        "%lld",      1);
+    void *colSectors   = tbl.addCol("Sectors",      "%lld",     -1, 2);
+    void *colSize      = tbl.addCol("Size",         "%d.%d%c",   1);
+    void *colOffset    = tbl.addCol("Offset",       "%lld",      1);
+    void *colId        = tbl.addCol("Id",           "%2x",       1);
+    void *colType      = tbl.addCol("Type",         "%s",       -1, 2);
+
+    for (int idxPartition = 1; idxPartition <= g_lastPartNbr; idxPartition++)
+    {
+        PARTITIONINFO *p = &g_aParsedPartitionInfo[idxPartition];
+        if (p->idxPartition)
+        {
+            uint8_t exp = log2((double)p->cbPartition);
+            char scaledMagnitude = ((char []){ ' ', 'K', 'M', 'G', 'T', 'P' })[exp / 10];
+
+             /* This workaround is because IPRT RT*Printf* funcs don't handle floating point format specifiers */
+            double  cbPartitionScaled = (double)p->cbPartition / pow(2, (double)(((uint8_t)(exp / 10)) * 10));
+            uint8_t cbPartitionIntPart = cbPartitionScaled;
+            uint8_t cbPartitionFracPart = (cbPartitionScaled - (double)cbPartitionIntPart) * 10;
+
+            void *row = tbl.addRow();
+
+            tbl.setCell(row, colPartition,  g_pszBaseImageName, idxPartition);
+            tbl.setCell(row, colBoot,       p->fBootable ? '*' : ' ');
+            tbl.setCell(row, colStart,      p->offPartition / BLOCKSIZE);
+            tbl.setCell(row, colSectors,    p->cbPartition / BLOCKSIZE);
+            tbl.setCell(row, colSize,       cbPartitionIntPart, cbPartitionFracPart, scaledMagnitude);
+            tbl.setCell(row, colOffset,     p->offPartition);
+            tbl.setCell(row, colId,         p->partitionType.legacy);
+            tbl.setCell(row, colType,       getClassicPartitionDesc((p->partitionType).legacy));
+        }
+    }
+    tbl.displayTable();
+    RTPrintf ("\n");
+}
+
 int
 main(int argc, char **argv)
@@ -772 +1255 @@
     int rc = RTR3InitExe(argc, &argv, 0);
     if (RT_FAILURE(rc))
-        return RTMsgErrorExitFailure("vboxraw: ERROR: RTR3InitExe failed, rc=%Rrc\n", rc);
+        return RTMsgErrorExitFailure("RTR3InitExe failed, rc=%Rrc\n", rc);
 
     rc = VDInit();
     if (RT_FAILURE(rc))
-        return RTMsgErrorExitFailure("vboxraw: ERROR: VDInit failed, rc=%Rrc\n", rc);
+        return RTMsgErrorExitFailure("VDInit failed, rc=%Rrc\n", rc);
 
     memset(&g_vboxrawOps, 0, sizeof(g_vboxrawOps));
@@ -786 +1269 @@
     g_vboxrawOps.readdir     = vboxrawOp_readdir;
     g_vboxrawOps.readlink    = vboxrawOp_readlink;
+
     struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
-
     memset(&g_vboxrawOpts, 0, sizeof(g_vboxrawOpts));
 
     rc = fuse_opt_parse(&args, &g_vboxrawOpts, vboxrawOptDefs, vboxrawOptHandler);
+
     if (g_vboxrawOpts.fAllowRoot)
         fuse_opt_add_arg(&args, "-oallow_root");
 
     if (rc == -1)
-        return RTMsgErrorExitFailure("vboxraw: ERROR: Couldn't parse fuse options, rc=%Rrc\n", rc);
+        return RTMsgErrorExitFailure("Couldn't parse fuse options, rc=%Rrc\n", rc);
+    if (g_vboxrawOpts.fBriefUsage)
+    {
+        briefUsage();
+        return 0;
+    }
 
     /*
@@ -826 +1315 @@
         hrc = pVirtualBoxClient->COMGETTER(VirtualBox)(pVirtualBox.asOutParam());
     if (FAILED(hrc))
-         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to get IVirtualBox object! (hrc=%Rhrc)", hrc);
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to get IVirtualBox object! (hrc=%Rhrc)", hrc);
 
     if (g_vboxrawOpts.fVerbose)
         RTPrintf("vboxraw: VirtualBox XPCOM object created\n");
 
-    if (g_vboxrawOpts.fList)
-    {
-         listVMs(pVirtualBox);
-         return 0;
-    }
+    if (g_vboxrawOpts.fListMedia || g_vboxrawOpts.fListMediaBrief)
+    {
+        listVMs(pVirtualBox);
+        return 0;
+    }
+
 
     if (g_vboxrawOpts.pszImage == NULL)
     {
-            RTMsgErrorExitFailure("vboxraw: ERROR: "
-                "Must provide at at least --list or --image option\n");
-            return 0;
+        RTMsgErrorExitFailure("To list partitions, must also specify --i or --image option\n");
+        return 0;
     }
     ComPtr<IMedium> pBaseImageMedium = NULL;
     char    *pszFormat;
     VDTYPE  enmType;
-
     searchForBaseImage(pVirtualBox, g_vboxrawOpts.pszImage, &pBaseImageMedium);
     if (pBaseImageMedium == NULL)
@@ -860 +1348 @@
         g_pszBaseImagePath = RTStrDup(g_vboxrawOpts.pszImage);
         if (g_pszBaseImagePath == NULL)
-            return RTMsgErrorExitFailure("vboxraw: out of memory\n");
+            return RTMsgErrorExitFailure("out of memory\n");
 
         if (access(g_pszBaseImagePath, F_OK) < 0)
-            return RTMsgErrorExitFailure("vboxraw: ERROR: "
-                    "Virtual disk image not found: \"%s\"\n", g_pszBaseImagePath);
+            return RTMsgErrorExitFailure("Virtual disk image not found: \"%s\"\n", g_pszBaseImagePath);
 
         if (access(g_pszBaseImagePath, R_OK) < 0)
-             return RTMsgErrorExitFailure("vboxraw: ERROR: "
+             return RTMsgErrorExitFailure(
                     "Virtual disk image not readable: \"%s\"\n", g_pszBaseImagePath);
 
-        if ( g_vboxrawOpts.fRW && access(g_vboxrawOpts.pszImage, W_OK) < 0)
-             return RTMsgErrorExitFailure("vboxraw: ERROR: "
+        if (g_vboxrawOpts.fRW && access(g_vboxrawOpts.pszImage, W_OK) < 0)
+             return RTMsgErrorExitFailure(
                     "Virtual disk image not writeable: \"%s\"\n", g_pszBaseImagePath);
         rc = RTPathSplit(g_pszBaseImagePath, &g_u.split, sizeof(g_u), 0);
 
         if (RT_FAILURE(rc))
-             return RTMsgErrorExitFailure("vboxraw: "
+             return RTMsgErrorExitFailure(
                     "RTPathSplit failed on '%s': %Rrc",  g_pszBaseImagePath);
 
         if (!(g_u.split.fProps & RTPATH_PROP_FILENAME))
-             return RTMsgErrorExitFailure("vboxraw: "
+             return RTMsgErrorExitFailure(
                     "RTPATH_PROP_FILENAME not set for: '%s'",  g_pszBaseImagePath);
 
@@ -896 +1383 @@
                 g_pszBaseImagePath, &pszFormat, &enmType);
             if (RT_FAILURE(rc))
-                return RTMsgErrorExitFailure("vboxraw: ERROR: VDGetFormat(%s,) "
+                return RTMsgErrorExitFailure("VDGetFormat(%s,) "
                     "failed, rc=%Rrc\n", g_pszBaseImagePath, rc);
 
@@ -907 +1394 @@
                 {
                     VDClose(g_pVDisk, false /* fDeletes */);
-                    return RTMsgErrorExitFailure("vboxraw: ERROR: VDCreate(,%s,%s,,,) failed,"
+                    return RTMsgErrorExitFailure("VDCreate(,%s,%s,,,) failed,"
                         " rc=%Rrc\n", pszFormat, g_pszBaseImagePath, rc);
                 }
             }
             else
-                return RTMsgErrorExitFailure("vboxraw: ERROR: VDCreate failed, rc=%Rrc\n", rc);
-        }
+                return RTMsgErrorExitFailure("VDCreate failed, rc=%Rrc\n", rc);
+        }
+    } else {
+        Bstr pMediumUuid;
+        CHECK_ERROR(pBaseImageMedium, COMGETTER(Id)(pMediumUuid.asOutParam()));
+        g_pvDiskUuid = RTStrDup((char *)CSTR(pMediumUuid));
     }
 
     if (g_pVDisk == NULL)
     {
+
         com::SafeIfaceArray<IMedium> aMediumChildren;
         ComPtr<IMedium> pChild = pBaseImageMedium;
@@ -937 +1429 @@
                 g_pszBaseImagePath = RTStrDup(CSTR(pMediumPath));
                 if (g_pszBaseImageName == NULL)
-                    return RTMsgErrorExitFailure("vboxraw: out of memory\n");
+                    return RTMsgErrorExitFailure("out of memory\n");
 
                 if (g_pszBaseImagePath == NULL)
-                    return RTMsgErrorExitFailure("vboxraw: out of memory\n");
+                    return RTMsgErrorExitFailure("out of memory\n");
                 /*
                  * Create HDD container to open base image and differencing images into
@@ -947 +1439 @@
                         g_pszBaseImagePath, &pszFormat, &enmType);
                 if (RT_FAILURE(rc))
-                    return RTMsgErrorExitFailure("vboxraw: VDGetFormat(,,%s,,) "
+                    return RTMsgErrorExitFailure("VDGetFormat(,,%s,,) "
                         "failed (during HDD container creation), rc=%Rrc\n", g_pszBaseImagePath, rc);
                 if (g_vboxrawOpts.fVerbose)
-                    RTPrintf("vboxraw: Creating container for base image of format %s\n", pszFormat);
+                    RTPrintf("Creating container for base image of format %s\n", pszFormat);
                 /** @todo Remove I/O CB's and crit sect. when VDRead()/VDWrite() are made threadsafe */
                 rc = RTCritSectInit(&g_vdioLock);
@@ -963 +1455 @@
                 }
                 else
-                    return RTMsgErrorExitFailure("vboxraw: ERROR: Failed to create critsects "
+                    return RTMsgErrorExitFailure("ERROR: Failed to create critsects "
                                                  "for virtual disk I/O, rc=%Rrc\n", rc);
 
@@ -969 +1461 @@
                 rc = VDCreate(g_pVdIfs, enmType, &g_pVDisk);
                 if (NS_FAILED(rc))
-                    return RTMsgErrorExitFailure("vboxraw: ERROR: Couldn't create virtual disk container\n");
+                    return RTMsgErrorExitFailure("ERROR: Couldn't create virtual disk container\n");
             }
             /** @todo (end of to do section) */
@@ -990 +1482 @@
             {
                 VDClose(g_pVDisk, false /* fDeletes */);
-                return RTMsgErrorExitFailure("vboxraw: VDOpen(,,%s,,) failed, rc=%Rrc\n",
+                return RTMsgErrorExitFailure("VDOpen(,,%s,,) failed, rc=%Rrc\n",
                    g_pszBaseImagePath, rc);
             }
@@ -1010 +1502 @@
     g_cReaders    = VDIsReadOnly(g_pVDisk) ? INT32_MAX / 2 : 0;
     g_cWriters   = 0;
-    g_cbPrimary  = VDGetSize(g_pVDisk, 0 /* base */);
+    g_cbEntireVDisk  = VDGetSize(g_pVDisk, 0 /* base */);
+
+    if (g_vboxrawOpts.fListParts)
+    {
+        if (g_pVDisk == NULL)
+            return RTMsgErrorExitFailure("No valid --image to list partitions from\n");
+
+        RTPrintf("\n");
+
+        rc = parsePartitionTable();
+        switch(rc)
+        {
+            case PARTITION_TABLE_MBR:
+                displayLegacyPartitionTable();
+                break;
+            case PARTITION_TABLE_GPT:
+                displayGptPartitionTable();
+                break;
+            default:
+                return rc;
+        }
+        return 0;
+    }
+    if (g_vboxrawOpts.idxPartition >= 0)
+    {
+        if (g_vboxrawOpts.offset)
+            return RTMsgErrorExitFailure("--offset and --partition are mutually exclusive options\n");
+
+        if (g_vboxrawOpts.size)
+            return RTMsgErrorExitFailure("--size and --partition are mutually exclusive options\n");
+
+        /*
+         * --partition option specified. That will set the global offset and limit
+         * honored by the disk read and write sanitizers to constrain operations
+         * to within the specified partion based on an initial parsing of the MBR
+         */
+        rc = parsePartitionTable();
+        if (rc < 0)
+            return RTMsgErrorExitFailure("Error parsing disk MBR/Partition table\n");
+        int partNbr = g_vboxrawOpts.idxPartition;
+
+        if (partNbr < 0 || partNbr > g_lastPartNbr)
+            return RTMsgErrorExitFailure("Non-valid partition number specified\n");
+
+        if (partNbr == 0)
+        {
+            g_vDiskOffset = 0;
+            g_vDiskSize = VDGetSize(g_pVDisk, 0);
+            if (g_vboxrawOpts.fVerbose)
+                RTPrintf("Partition 0 specified - Whole disk will be accessible\n");
+        } else {
+            for (int i = 0; i < g_lastPartNbr; i++)
+            {
+                /* If GPT, display vboxraw's representation of partition table starts at partition 2
+                 * but the table is displayed calling it partition 1, because the protective MBR
+                 * record is relatively pointless to display or reference in this context */
+
+                if (g_aParsedPartitionInfo[i].idxPartition == partNbr + g_fGPT ? 1 : 0)
+                {
+                     g_vDiskOffset = g_aParsedPartitionInfo[i].offPartition;
+                     g_vDiskSize = g_vDiskOffset + g_aParsedPartitionInfo[i].cbPartition;
+                     if (g_vboxrawOpts.fVerbose)
+                        RTPrintf("Partition %d specified. Only sectors %llu to %llu of disk will be accessible\n",
+                            g_vboxrawOpts.idxPartition, g_vDiskOffset / BLOCKSIZE, g_vDiskSize / BLOCKSIZE);
+                }
+            }
+        }
+    } else {
+        if (g_vboxrawOpts.offset) {
+            if (g_vboxrawOpts.offset < 0 || g_vboxrawOpts.offset + g_vboxrawOpts.size > g_cbEntireVDisk)
+                return RTMsgErrorExitFailure("User specified offset out of range of virtual disk\n");
+
+            if (g_vboxrawOpts.fVerbose)
+                RTPrintf("Setting r/w bias (offset) to user requested value for sector %llu\n", g_vDiskOffset / BLOCKSIZE);
+
+            g_vDiskOffset = g_vboxrawOpts.offset;
+        }
+        if (g_vboxrawOpts.size) {
+            if (g_vboxrawOpts.size < 0 || g_vboxrawOpts.offset + g_vboxrawOpts.size > g_cbEntireVDisk)
+                return RTMsgErrorExitFailure("User specified size out of range of virtual disk\n");
+
+            if (g_vboxrawOpts.fVerbose)
+                RTPrintf("Setting r/w size limit to user requested value %llu\n", g_vDiskSize / BLOCKSIZE);
+
+            g_vDiskSize = g_vboxrawOpts.size;
+        }
+    }
+    if (g_vDiskSize == 0)
+        g_vDiskSize = g_cbEntireVDisk - g_vDiskOffset;
 
     /*