From 3828019030f981cc5b3411badc40704f5525fdb3 Mon Sep 17 00:00:00 2001 From: Mike Fleetwood Date: Wed, 12 Sep 2012 23:51:49 +0100 Subject: [PATCH] Read file system size for mounted ext2/3/4 from superblock (#683255) A user had a 190 MiB partition containing an old ext2 file system. When unmounted it was reported as filling the partition, but when mounted it was reported as having 6% unallocated space. The file system's inode tables were approximately twice the size of those created by default with the current mkfs.ext2 defaults. To create an equivalent file system in a 190 MiB partition: mkfs.ext2 -N 97344 /dev/sda15 It turns out that for ext2, ext3 and ext4 file systems what was described as intrinsic unallocated space during the development of Bug #499202 is actually file system overhead. When mounted the ext2/3/4 kernel code reports the size of the file system after subtracting the overhead. Overhead is made up of superblock backups, group descriptors, allocation bitmaps and largest of all inode tables. E2fsprogs tools don't subtract this overhead when reporting the file system size. References: * The Second Extended File System, Internal Layout, by Dave Poirier http://www.nongnu.org/ext2-doc/ext2.html * Linux ext2_statfs() function http://lxr.linux.no/#linux+v3.5.3/fs/ext2/super.c#L1311 Call the file system specific method for reading the usage of ext2, ext3 and ext4 file systems while mounted. Make it read the file system size from the on disk superblock to avoid subtraction of overhead and use the statvfs() system call to return an up to date free space figure. Bug #683255 - ext2: statvfs differs from dumpe2fs (x MB unallocated space within the partition) --- include/Utils.h | 3 +++ src/GParted_Core.cc | 19 ++++++++----------- src/Utils.cc | 22 ++++++++++++++++++++++ src/ext2.cc | 43 +++++++++++++++++++++++++++++++++---------- src/ext3.cc | 43 +++++++++++++++++++++++++++++++++---------- src/ext4.cc | 43 +++++++++++++++++++++++++++++++++---------- 6 files changed, 132 insertions(+), 41 deletions(-) diff --git a/include/Utils.h b/include/Utils.h index 116d7f4b..c0e00b65 100644 --- a/include/Utils.h +++ b/include/Utils.h @@ -188,6 +188,9 @@ public: const Glib::ustring& delimiters ) ; static int convert_to_int(const Glib::ustring & src); static Glib::ustring generate_uuid(void); + static int get_mounted_filesystem_usage( const Glib::ustring & mountpoint, + Byte_Value & fs_size, Byte_Value & fs_free, + Glib::ustring error_message ) ; private: static bool get_kernel_version( int & major_ver, int & minor_ver, int & patch_ver ) ; diff --git a/src/GParted_Core.cc b/src/GParted_Core.cc index d5f2b5bf..88f7be82 100644 --- a/src/GParted_Core.cc +++ b/src/GParted_Core.cc @@ -52,7 +52,6 @@ #include #include #include -#include #include #include #include @@ -1597,19 +1596,17 @@ void GParted_Core::set_used_sectors( std::vector & partitions ) void GParted_Core::mounted_set_used_sectors( Partition & partition ) { - struct statvfs sfs ; - if ( partition .get_mountpoints() .size() > 0 ) { - if ( statvfs( partition .get_mountpoint() .c_str(), &sfs ) == 0 ) - { - Sector fs_size = static_cast( sfs .f_blocks ) * sfs .f_frsize / partition .sector_size ; - Sector fs_free = static_cast( sfs .f_bfree ) * sfs .f_bsize / partition .sector_size ; - partition .set_sector_usage( fs_size, fs_free ) ; - } + Byte_Value fs_size ; + Byte_Value fs_free ; + Glib::ustring error_message ; + if ( Utils::get_mounted_filesystem_usage( partition .get_mountpoint(), + fs_size, fs_free, error_message ) == 0 ) + partition .set_sector_usage( fs_size / partition .sector_size, + fs_free / partition .sector_size ) ; else - partition .messages .push_back( "statvfs (" + partition .get_mountpoint() + "): " + - Glib::strerror( errno ) ) ; + partition .messages .push_back( error_message ) ; } } diff --git a/src/Utils.cc b/src/Utils.cc index 91196cd2..affbee4e 100644 --- a/src/Utils.cc +++ b/src/Utils.cc @@ -24,6 +24,8 @@ #include #include #include +#include +#include namespace GParted @@ -606,6 +608,26 @@ Glib::ustring Utils::generate_uuid(void) return uuid_str; } +//Wrapper around statvfs() system call to get mounted file system size +// and free space, both in bytes. +int Utils::get_mounted_filesystem_usage( const Glib::ustring & mountpoint, + Byte_Value & fs_size, Byte_Value & fs_free, + Glib::ustring error_message ) +{ + struct statvfs sfs ; + int ret ; + ret = statvfs( mountpoint .c_str(), &sfs ) ; + if ( ret == 0 ) + { + fs_size = static_cast( sfs .f_blocks ) * sfs .f_frsize ; + fs_free = static_cast( sfs .f_bfree ) * sfs .f_bsize ; + } + else + error_message = "statvfs (" + mountpoint + "): " + Glib::strerror( errno ) ; + + return ret ; +} + //private functions ... //Read kernel version, reporting success or failure diff --git a/src/ext2.cc b/src/ext2.cc index 722851ab..ad62208b 100644 --- a/src/ext2.cc +++ b/src/ext2.cc @@ -59,13 +59,18 @@ FS ext2::get_filesystem_support() fs .move = FS::GPARTED ; } - fs .online_read = FS::GPARTED ; + fs .online_read = FS::EXTERNAL ; return fs ; } void ext2::set_used_sectors( Partition & partition ) { + //Called when file system is unmounted *and* when mounted. Always read + // the file system size from the on disk superblock using dumpe2fs to + // avoid overhead subtraction. Read the free space from the kernel via + // the statvfs() system call when mounted and from the superblock when + // unmounted. if ( ! Utils::execute_command( "dumpe2fs -h " + partition .get_path(), output, error, true ) ) { index = output .find( "Block count:" ) ; @@ -73,22 +78,40 @@ void ext2::set_used_sectors( Partition & partition ) sscanf( output.substr( index ) .c_str(), "Block count: %Ld", &T ) != 1 ) T = -1 ; - index = output .find( "Free blocks:" ) ; - if ( index >= output .length() || - sscanf( output.substr( index ) .c_str(), "Free blocks: %Ld", &N ) != 1 ) - N = -1 ; - index = output .find( "Block size:" ) ; if ( index >= output.length() || sscanf( output.substr( index ) .c_str(), "Block size: %Ld", &S ) != 1 ) S = -1 ; - if ( T > -1 && N > -1 && S > -1 ) - { + if ( T > -1 && S > -1 ) T = Utils::round( T * ( S / double(partition .sector_size) ) ) ; - N = Utils::round( N * ( S / double(partition .sector_size) ) ) ; - partition .set_sector_usage( T, N ) ; + + if ( partition .busy ) + { + Byte_Value ignored ; + Byte_Value fs_free ; + if ( Utils::get_mounted_filesystem_usage( partition .get_mountpoint(), + ignored, fs_free, error ) == 0 ) + N = Utils::round( fs_free / double(partition .sector_size) ) ; + else + { + N = -1 ; + partition .messages .push_back( error ) ; + } } + else + { + index = output .find( "Free blocks:" ) ; + if ( index >= output .length() || + sscanf( output.substr( index ) .c_str(), "Free blocks: %Ld", &N ) != 1 ) + N = -1 ; + + if ( N > -1 && S > -1 ) + N = Utils::round( N * ( S / double(partition .sector_size) ) ) ; + } + + if ( T > -1 && N > -1 ) + partition .set_sector_usage( T, N ) ; } else { diff --git a/src/ext3.cc b/src/ext3.cc index 8698347a..a6d6d420 100644 --- a/src/ext3.cc +++ b/src/ext3.cc @@ -60,13 +60,18 @@ FS ext3::get_filesystem_support() fs .move = GParted::FS::GPARTED ; } - fs .online_read = FS::GPARTED ; + fs .online_read = FS::EXTERNAL ; return fs ; } void ext3::set_used_sectors( Partition & partition ) { + //Called when file system is unmounted *and* when mounted. Always read + // the file system size from the on disk superblock using dumpe2fs to + // avoid overhead subtraction. Read the free space from the kernel via + // the statvfs() system call when mounted and from the superblock when + // unmounted. if ( ! Utils::execute_command( "dumpe2fs -h " + partition .get_path(), output, error, true ) ) { index = output .find( "Block count: " ) ; @@ -74,22 +79,40 @@ void ext3::set_used_sectors( Partition & partition ) sscanf( output .substr( index ) .c_str(), "Block count: %Ld", &T ) != 1 ) T = -1 ; - index = output .find( "Free blocks:" ) ; - if ( index >= output .length() || - sscanf( output.substr( index ) .c_str(), "Free blocks: %Ld", &N ) != 1 ) - N = -1 ; - index = output .find( "Block size:" ) ; if ( index >= output.length() || sscanf( output.substr( index ) .c_str(), "Block size: %Ld", &S ) != 1 ) S = -1 ; - if ( T > -1 && N > -1 && S > -1 ) - { + if ( T > -1 && S > -1 ) T = Utils::round( T * ( S / double(partition .sector_size) ) ) ; - N = Utils::round( N * ( S / double(partition .sector_size) ) ) ; - partition .set_sector_usage( T, N ) ; + + if ( partition .busy ) + { + Byte_Value ignored ; + Byte_Value fs_free ; + if ( Utils::get_mounted_filesystem_usage( partition .get_mountpoint(), + ignored, fs_free, error ) == 0 ) + N = Utils::round( fs_free / double(partition .sector_size) ) ; + else + { + N = -1 ; + partition .messages .push_back( error ) ; + } } + else + { + index = output .find( "Free blocks:" ) ; + if ( index >= output .length() || + sscanf( output.substr( index ) .c_str(), "Free blocks: %Ld", &N ) != 1 ) + N = -1 ; + + if ( N > -1 && S > -1 ) + N = Utils::round( N * ( S / double(partition .sector_size) ) ) ; + } + + if ( T > -1 && N > -1 ) + partition .set_sector_usage( T, N ) ; } else { diff --git a/src/ext4.cc b/src/ext4.cc index 6a9d1a80..674903ab 100644 --- a/src/ext4.cc +++ b/src/ext4.cc @@ -63,13 +63,18 @@ FS ext4::get_filesystem_support() } } - fs .online_read = FS::GPARTED ; + fs .online_read = FS::EXTERNAL ; return fs ; } void ext4::set_used_sectors( Partition & partition ) { + //Called when file system is unmounted *and* when mounted. Always read + // the file system size from the on disk superblock using dumpe2fs to + // avoid overhead subtraction. Read the free space from the kernel via + // the statvfs() system call when mounted and from the superblock when + // unmounted. if ( ! Utils::execute_command( "dumpe2fs -h " + partition .get_path(), output, error, true ) ) { index = output .find( "Block count:" ) ; @@ -77,22 +82,40 @@ void ext4::set_used_sectors( Partition & partition ) sscanf( output.substr( index ) .c_str(), "Block count: %Ld", &T ) != 1 ) T = -1 ; - index = output .find( "Free blocks:" ) ; - if ( index >= output .length() || - sscanf( output.substr( index ) .c_str(), "Free blocks: %Ld", &N ) != 1 ) - N = -1 ; - index = output .find( "Block size:" ) ; if ( index >= output.length() || sscanf( output.substr( index ) .c_str(), "Block size: %Ld", &S ) != 1 ) S = -1 ; - if ( T > -1 && N > -1 && S > -1 ) - { + if ( T > -1 && S > -1 ) T = Utils::round( T * ( S / double(partition .sector_size) ) ) ; - N = Utils::round( N * ( S / double(partition .sector_size) ) ) ; - partition .set_sector_usage( T, N ) ; + + if ( partition .busy ) + { + Byte_Value ignored ; + Byte_Value fs_free ; + if ( Utils::get_mounted_filesystem_usage( partition .get_mountpoint(), + ignored, fs_free, error ) == 0 ) + N = Utils::round( fs_free / double(partition .sector_size) ) ; + else + { + N = -1 ; + partition .messages .push_back( error ) ; + } } + else + { + index = output .find( "Free blocks:" ) ; + if ( index >= output .length() || + sscanf( output.substr( index ) .c_str(), "Free blocks: %Ld", &N ) != 1 ) + N = -1 ; + + if ( N > -1 && S > -1 ) + N = Utils::round( N * ( S / double(partition .sector_size) ) ) ; + } + + if ( T > -1 && N > -1 ) + partition .set_sector_usage( T, N ) ; } else {