[gparted] Remove unallocated space comment from HACKING file (!50)

[Curtis Gedak <gedakc src gnome org>]

commit 4b8d4be7890ec50843f378d71a5015dfd146a3a9
Author: Mike Fleetwood <mike fleetwood googlemail com>
Date:   Fri Nov 8 16:12:04 2019 +0000

    Remove unallocated space comment from HACKING file (!50)
    
    The HACKING file should be hints for making changes to the code base and
    associated processes.  A overview of how GParted handled unallocated
    space was not that.  Also now the size of a JFS is accurately calculated
    using JFS as an example of a file system with intrinsic unallocated
    space is no longer valid.  Therefore removed from the HACKING file.
    Instead add the original commit message as an extended comment to method
    calc_significant_unallocated_sectors().
    
    Closes !50 - Calculate JFS size accurately

 HACKING          | 53 -----------------------------------------------------
 src/Partition.cc | 32 +++++++++++++++++++++++++++++---
 2 files changed, 29 insertions(+), 56 deletions(-)
---
diff --git a/HACKING b/HACKING
index 738aa13c..d7ef5b89 100644
--- a/HACKING
+++ b/HACKING
@@ -29,56 +29,3 @@ old source code files include/*.h and src/*.cc.  Generally .cc files are
 included and .h files are not, but there are exceptions.  Some mistakes
 can be detected using:
     make distcheck
-
-
-
-partition usage and unallocated space
-=====================================
-
-After addressing bug #499202 GParted now also displays unallocated space
-as well as used and unused space for recognised file systems.  Many file
-systems which actually fill their partition report a small amount of
-intrinsic unallocated space when mounted, but not when unmounted.  To
-avoid confusing the user and unnecessarily alarming them don't show
-unallocated space below a threshold, 2 to 5% depending on partition
-size.  It is just included in the used figure instead.  (This is
-effectively how GParted behaved before bug #499202 was addressed).  When
-above the threshold unallocated space is shown graphically, the numeric
-figure is shown in the Information Dialog and a is warning displayed.
-See the code and commit messages for more details.
-
-Worked example of partition and file system usage for a newly created
-jfs file system in a 200 MiB partition reporting a small amount of
-unallocated space:
-
-# sfdisk -s /dev/sda9
-204800
-
-# echo dm | jfs_debugfs /dev/sda9 | egrep 'Block Size:|dn_mapsize:|dn_nfree:'
-Aggregate Block Size: 4096
-[1] dn_mapsize:                0x0000000c6cb   [9] dn_agheigth:        0
-[2] dn_nfree:          0x0000000c6a3   [10] dn_agwidth:        1
-
-Partition size = 204800  (1K blocks) = 409600 (512 byte sectors)
-FS size        = 0x0c6cb (4K blocks)
-               = 50891   (4K blocks) = 407128 (512 byte sectors)
-FS free        = 0x0c6a3 (4K blocks)
-               = 50851   (4K blocks) = 406808 (512 byte sectors)
-
-Calculation:
-size        = ptn_size           = 409600                 = 200.00 MiB
-used        = fs_size - fs_free  = 407128 - 406808 =  320 = 160.00 KiB
-unused      = fs_free            = 406808                 = 198.64 MiB
-unallocated = ptn_size - fs_size = 409600 - 407128 = 2472 =   1.21 MiB
-
-  (Threshold %age for 200 MiB partition is approximately 4.675%)
-threshold   = ptn_size * pct      = 19150                 =   9.35 MiB
-
-  (Unallocated is below threshold so is included in used figure)
-disp_used   = used + unallocated = 320 + 2472      = 2792 =   1.36 MiB
-disp_unused = unused             = 406808                 = 198.64 MiB
-
-Figures displayed in the Information dialog:
-Size:         200.00 MiB
-Used:           1.36 MiB  ( 1% )
-Unused:       198.64 KiB  ( 99% )
diff --git a/src/Partition.cc b/src/Partition.cc
index 94e08d6e..f9155f48 100644
--- a/src/Partition.cc
+++ b/src/Partition.cc
@@ -426,13 +426,39 @@ const Glib::ustring Partition::get_partition_type_string(PartitionType type)
 }
 
 
-//Return threshold of sectors which is considered above the intrinsic
-//  level for a file system which "fills" the partition.  Calculation
-//  is:
+// Return threshold of unallocated sectors below which the file system is considered to
+// fill the partition, but at and above which is displayed to the user to show the file
+// system doesn't fill the partition.  Calculation is:
 //      %age of partition size           , when
 //      5%                               ,           ptn size <= 100 MiB
 //      linear scaling from 5% down to 2%, 100 MiB < ptn size <= 1 GiB
 //      2%                               , 1 GiB   < ptn size
+//
+// Quoting the commit message:
+//     "Enhance calculation of significant unallocated space (#499202)
+//
+//     Many file systems report differing percentages of unallocated space over
+//     a range of sizes, as well differing figures using their own specific
+//     tools or using statvfs() system call when mounted.
+//
+//     File systems reporting intrinsic unallocated space using their specific
+//     tools are: jfs, lvm2 pv and ntfs.  LVM2 PV has the largest amount of
+//     unallocated space with its default Physical Extent size of 4 MiB.  For a
+//     100 MiB partition it has 4.0% unallocated space.
+//
+//     File systems reporting intrinsic unallocated space using the statvfs()
+//     system call when mounted are: ext2/3/4, fat16/32, hfs, jfs, nilfs2,
+//     ntfs, reiserfs, and xfs.  Xfs has the worst identified unallocated space
+//     of ~4.7% in a 100 MiB partition.  Ext2/3 exhibit unusual behaviour by
+//     reporting unallocated space of ~4.6% in a 100 MiB partition falling to a
+//     constant percentage of ~1.8% for sizes of 1 GiB and above.
+//
+//     Update the calculation for used to estimate the maximum size of
+//     intrinsic unallocated space.  Limit is now 5% for partitions smaller
+//     than 100 MiB, 2% for partitions larger than 1 GiB and linear scaling of
+//     the percentage between.  Will still get false unallocated space warnings
+//     for mounted xfs file systems and lvm2 pvs smaller than 100 MiB.
+//     "
 Sector Partition::calc_significant_unallocated_sectors() const
 {
        const double HIGHER_UNALLOCATED_FRACTION = 0.05 ;