Mirrors
/
gparted
mirror of https://gitlab.gnome.org/GNOME/gparted.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gparted/include/GParted_Core.h

251 lines
12 KiB
C
Raw Normal View History

Cleanup file copyright entries Restore copyright entries by original author to those of his last known repository commit titled "released gparted-0.3.4 on LarryT's request." on Feb 25, 2007. Add my own copyright entries for files in which I changed source code. Files in which I only made spelling changes do not have my copyright entry added.
2009-11-05 11:08:32 -07:00
/* Copyright (C) 2004 Bart
Enable new fs resize library available with parted-3.1 (#668281) The parted-3.1 release brings back FAT16/FAT32 and HFS/HFS+ file system resize capabilities in a new libparted fs resize library. The following operations are again available when GParted is linked with parted-3.1: FAT16 - grow and shrink FAT32 - grow and shrink HFS - shrink HFS+ - shrink Note that there is a difference in how move actions are handled for FAT16/FAT32 file systems based on parted version. When GParted is linked with parted >= 3.0: FAT16 - move performed internally by GParted FAT32 - move performed internally by GParted When GParted is linked with parted < 3.0: FAT16 - move performed by libparted FAT32 - move performed by libparted Thanks goes to Jim Meyering for restoring these file system resizing capabilities in Parted 3.1 with a new libparted fs resize library. Closes Bug #668281 - minimal file-system resize API? (FAT and HFS* only)
2012-03-03 11:47:39 -07:00
* Copyright (C) 2008, 2009, 2010, 2011, 2012 Curtis Gedak
P) It still needs a lot of love, but the foundations are laid =) * Rewrote a large part of gparteds internal code. Filesystemssupport is now much more separated from the rest of gparted and adding support for other filesystems should be a piece of cake now (hope that's true :P) It still needs a lot of love, but the foundations are laid =)
2004-11-17 06:00:25 -07:00
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
Replace obsolete FSF postal address in copyright notices (#721565) This is part of parent bug: Bug #721455 - Obsolete info in license text on multiple modules and GNOME Goal: https://wiki.gnome.org/Initiatives/GnomeGoals/Proposals * verify all source files to make sure they have a license and a copyright, and that both are up-to-date Bug #721565 - License text contains obsolete FSF postal address
2014-01-23 03:59:48 -07:00
* GNU General Public License for more details.
P) It still needs a lot of love, but the foundations are laid =) * Rewrote a large part of gparteds internal code. Filesystemssupport is now much more separated from the rest of gparted and adding support for other filesystems should be a piece of cake now (hope that's true :P) It still needs a lot of love, but the foundations are laid =)
2004-11-17 06:00:25 -07:00
*
* You should have received a copy of the GNU General Public License
Replace obsolete FSF postal address in copyright notices (#721565) This is part of parent bug: Bug #721455 - Obsolete info in license text on multiple modules and GNOME Goal: https://wiki.gnome.org/Initiatives/GnomeGoals/Proposals * verify all source files to make sure they have a license and a copyright, and that both are up-to-date Bug #721565 - License text contains obsolete FSF postal address
2014-01-23 03:59:48 -07:00
* along with this program; if not, see <http://www.gnu.org/licenses/>.
P) It still needs a lot of love, but the foundations are laid =) * Rewrote a large part of gparteds internal code. Filesystemssupport is now much more separated from the rest of gparted and adding support for other filesystems should be a piece of cake now (hope that's true :P) It still needs a lot of love, but the foundations are laid =)
2004-11-17 06:00:25 -07:00
*/
Make include guards unique (#539297) Include guards need to be unique within GParted code and all included library header files. http://en.wikipedia.org/wiki/Include_guard#Difficulties Use this model for all include guards: #ifndef GPARTED_FILE_NAME_H #define GPARTED_FILE_NAME_H ... #endif /* GPARTED_FILE_NAME_H */ Closes Bug #539297 - Make include guards unique
2013-05-27 05:20:16 -06:00
#ifndef GPARTED_GPARTED_CORE_H
#define GPARTED_GPARTED_CORE_H
P) It still needs a lot of love, but the foundations are laid =) * Rewrote a large part of gparteds internal code. Filesystemssupport is now much more separated from the rest of gparted and adding support for other filesystems should be a piece of cake now (hope that's true :P) It still needs a lot of love, but the foundations are laid =)
2004-11-17 06:00:25 -07:00
Remove "../include/" from GParted header #includes It made the code look a little messy, is easily resolved in the build system and made the dependencies more complicated than needed. Each GParted header was tracked via multiple different names (different numbers of "../include/" prefixes). For example just looking at how DialogFeatures.o depends on Utils.h: $ cd src $ make DialogFeatures.o $ egrep ' [^ ]*Utils.h' .deps/DialogFeatures.Po ../include/DialogFeatures.h ../include/../include/Utils.h \ ../include/../include/../include/../include/../include/../include/Utils.h \ ../include/../include/../include/Utils.h \ After removing "../include/" from the GParted header #includes, just need to add "-I../include" to the compile command via the AM_CPPFLAGS in src/Makefile.am. Now the dependencies on GParted header files are tracked under a single name (with a single "../include/" prefix). Now DialogFeatures.o only depends on a single name to Utils.h: $ make DialogFeatures.o $ egrep ' [^ ]*Utils.h' .deps/DialogFeatures.Po ../include/DialogFeatures.h ../include/Utils.h ../include/i18n.h \
2016-10-18 16:45:28 -06:00
#include "BlockSpecial.h"
Add missing Device.h include into GParted_Core and Win_GParted The files GParted_Core.h, GParted_Core.cc and Win_GParted.cc all use the Device type but don't include Device.h for it's definition. Include it.
2019-05-10 10:34:14 -06:00
#include "Device.h"
Remove "../include/" from GParted header #includes It made the code look a little messy, is easily resolved in the build system and made the dependencies more complicated than needed. Each GParted header was tracked via multiple different names (different numbers of "../include/" prefixes). For example just looking at how DialogFeatures.o depends on Utils.h: $ cd src $ make DialogFeatures.o $ egrep ' [^ ]*Utils.h' .deps/DialogFeatures.Po ../include/DialogFeatures.h ../include/../include/Utils.h \ ../include/../include/../include/../include/../include/../include/Utils.h \ ../include/../include/../include/Utils.h \ After removing "../include/" from the GParted header #includes, just need to add "-I../include" to the compile command via the AM_CPPFLAGS in src/Makefile.am. Now the dependencies on GParted header files are tracked under a single name (with a single "../include/" prefix). Now DialogFeatures.o only depends on a single name to Utils.h: $ make DialogFeatures.o $ egrep ' [^ ]*Utils.h' .deps/DialogFeatures.Po ../include/DialogFeatures.h ../include/Utils.h ../include/i18n.h \
2016-10-18 16:45:28 -06:00
#include "FileSystem.h"
#include "Operation.h"
#include "Partition.h"
#include "PartitionLUKS.h"
#include "PartitionVector.h"
Split FILESYSTEMS and FILESYSTEM_MAP into separate module (!49) GParted_Core::FILESYSTEMS and ::FILESYSTEM_MAP and the methods that query and manipulate them are self-contained. Therefore move them into a separate SupportedFileSystems module. Also having a single class maintaining all FileSystem interface objects will make testing all the file system types much easier as there will be no need to duplicate this functionality in the test. Closes !49 - Add file system interface tests
2019-07-16 06:01:07 -06:00
#include "SupportedFileSystems.h"
Extract common code into GParted_Core::get_filesystem_limits() (#787204) There are multiple repetitions of the same code getting a FileSystem object, checking for NULL and then calling the file system specific get_filesystem_limits(). Extract that into a common function. GParted_Core::get_filesystem_limits() can't use the file system from the passed Partition object because that is the current file system which will be different from the intended file system for new and format operations. So would look up the wrong derived FileSystem specific object and call the wrong get_filesystem_limits(). Hence still needing fstype as a separate parameter to pass the intended file system. Bug 787204 - Minimum and maximum size of the UDF partition/disk
2018-01-15 14:25:55 -07:00
#include "Utils.h"
P) It still needs a lot of love, but the foundations are laid =) * Rewrote a large part of gparteds internal code. Filesystemssupport is now much more separated from the rest of gparted and adding support for other filesystems should be a piece of cake now (hope that's true :P) It still needs a lot of love, but the foundations are laid =)
2004-11-17 06:00:25 -07:00
p * added detailed progressfeedback. It still needs some polishing, but is already far better then the old situation. And what's more, it's finally threadsafe :p
2006-01-19 12:15:15 -07:00
#include <parted/parted.h>
P) It still needs a lot of love, but the foundations are laid =) * Rewrote a large part of gparteds internal code. Filesystemssupport is now much more separated from the rest of gparted and adding support for other filesystems should be a piece of cake now (hope that's true :P) It still needs a lot of love, but the foundations are laid =)
2004-11-17 06:00:25 -07:00
#include <vector>
#include <fstream>
port-to-gtk3: Rework Glibmm header includes (#7) Now that we are compiling against Gtkmm3 there are missing declarations of Glibmm identifiers due to changes in Gtkmm internal header structure. All we have to do is bring back the declarations by including the appropriate headers where needed. Add necessary Glibmm header includes. Closes #7 - Port to Gtk3
2018-12-04 09:46:27 -07:00
#include <glibmm/thread.h>
Display more version and configuration info to stdout when starting (!34) So that we might get more information from users when helping them. Starting GParted from the command line now looks like this: # ./gpartedbin GParted 0.33.0-git configuration --enable-online-resize libparted 3.2 Closes !34 - Display more version and configuration information
2019-03-30 05:41:54 -06:00
#include <glibmm/ustring.h>
port-to-gtk3: Rework Glibmm header includes (#7) Now that we are compiling against Gtkmm3 there are missing declarations of Glibmm identifiers due to changes in Gtkmm internal header structure. All we have to do is bring back the declarations by including the appropriate headers where needed. Add necessary Glibmm header includes. Closes #7 - Port to Gtk3
2018-12-04 09:46:27 -07:00
P) It still needs a lot of love, but the foundations are laid =) * Rewrote a large part of gparteds internal code. Filesystemssupport is now much more separated from the rest of gparted and adding support for other filesystems should be a piece of cake now (hope that's true :P) It still needs a lot of love, but the foundations are laid =)
2004-11-17 06:00:25 -07:00
namespace GParted
{
class GParted_Core
{
Add initial unit test of erase_filesystem_signatures() (#220) Initially just testing erasing of Intel Software RAID signatures. Chosen because it was expected to work, but turned out not to be true in all cases. The code needs to initialise GParted_Core::mainthread, construct Gtk::Main() and execute xvfb-run because of this call chain: GParted_Core::erase_filesystem_signatures() GParted_Core::settle_device() Utils::execute_command ("udevadm settle ...") status.foreground = (Glib::Thread::self() == GParted_Core::mainthread) Gtk::Main::run() This was also needed when testing file system interface classes as discussed in commits [1][2]. The test fails like this: $ ./test_EraseFileSystemSignatures ... [ RUN ] EraseFileSystemSignaturesTest.IntelSoftwareRAIDAligned [ OK ] EraseFileSystemSignaturesTest.IntelSoftwareRAIDAligned (155 ms) [ RUN ] EraseFileSystemSignaturesTest.IntelSoftwareRAIDUnaligned test_EraseFileSystemSignatures.cc:286: Failure Failed image_contains_all_zeros(): First non-zero bytes: 0x00001A00 "Intel Raid ISM C" 49 6E 74 65 6C 20 52 61 69 64 20 49 53 4D 20 43 test_EraseFileSystemSignatures.cc:320: Failure Value of: image_contains_all_zeros() Actual: false Expected: true [ FAILED ] EraseFileSystemSignaturesTest.IntelSoftwareRAIDUnaligned (92 ms) Manually write the same test image: $ python << 'EOF' signature = b'Intel Raid ISM Cfg Sig. ' import os fd = os.open('/tmp/test.img', os.O_CREAT|os.O_WRONLY) os.ftruncate(fd, 16*1024*1024 - 512) os.lseek(fd, -(2*512), os.SEEK_END) os.write(fd, signature) os.close(fd) EOF Run gpartedbin /tmp/test.img and Format to > Cleared. GParted continues to display the the image file as containing an ataraid signature. $ blkid /tmp/test.img /tmp/test.img: TYPE="isw_raid_member" $ hexdump -C /tmp/test.img 00000000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| * 00fffa00 49 6e 74 65 6c 20 52 61 69 64 20 49 53 4d 20 43 |Intel Raid ISM C| 00fffa10 66 67 20 53 69 67 2e 20 00 00 00 00 00 00 00 00 |fg Sig. ........| 00fffa20 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| * 00fffe00 This signature is not being cleared when the device/partition/image size is 512 bytes smaller than a whole MiB because the last 3.5 KiB is left unwritten. This is because the last block of zeros written is 8 KiB aligned to 4 KiB at the end of the device. [1] a97c23c57c693b77724970d2f99702d7be18b4bc Add initial create ext2 only FileSystem interface class test (!49) [2] 8db9a83b39b82785dcbcc776ac259aa7986c0955 Run test program under xvfb-run to satisfy need for an X11 display (!49) Closes #220 - Format to Cleared not clearing "pdc" ataraid signature
2023-02-04 08:36:37 -07:00
friend class EraseFileSystemSignaturesTest; // To allow unit testing to call private
// method.
P) It still needs a lot of love, but the foundations are laid =) * Rewrote a large part of gparteds internal code. Filesystemssupport is now much more separated from the rest of gparted and adding support for other filesystems should be a piece of cake now (hope that's true :P) It still needs a lot of love, but the foundations are laid =)
2004-11-17 06:00:25 -07:00
public:
Display pop up dialog on libparted exceptions We used to just log libparted exceptions without handling them. This patch changes the exception handler to display a modal dialog box and return the chosen action to libparted.
2012-01-04 17:30:28 -07:00
static Glib::Thread *mainthread;
catch libparted exceptions and display them in the operationdetails if an * include/GParted_Core.h, src/GParted_Core.cc: catch libparted exceptions and display them in the operationdetails if an operation has failed. * src/Dialog_Progress.cc: small cosmetic change to the errordialog.
2006-02-25 09:30:43 -07:00
GParted_Core() ;
fixed another minor memleak (yeah i'm playing with valgrind ;) ) * include/GParted_Core.h, src/GParted_Core.cc: fixed another minor memleak (yeah i'm playing with valgrind ;) )
2006-03-28 12:01:20 -07:00
~GParted_Core() ;
restructured the core a bit, over time it had become very messy. * restructured the core a bit, over time it had become very messy.
2006-06-17 14:52:25 -06:00
Display more version and configuration info to stdout when starting (!34) So that we might get more information from users when helping them. Starting GParted from the command line now looks like this: # ./gpartedbin GParted 0.33.0-git configuration --enable-online-resize libparted 3.2 Closes !34 - Display more version and configuration information
2019-03-30 05:41:54 -06:00
static Glib::ustring get_version_and_config_string();
Remember result of searching the PATH for the hdparm command (#751251) Previously on every refresh for every device, GParted was searching the PATH to discover if the hdparm command existed. Stracing GParted showed that calling Glib::find_program_in_path("hdparm") made the following OS calls: access("/usr/lib64/qt-3.3/bin/hdparm", X_OK) = -1 ENOENT (No such file or directory) access("/usr/local/sbin/hdparm", X_OK) = -1 ENOENT (No such file or directory) access("/usr/local/bin/hdparm", X_OK) = -1 ENOENT (No such file or directory) access("/sbin/hdparm", X_OK) = 0 getuid() = 0 stat("/sbin/hdparm", {st_mode=S_IFREG|0755, st_size=137, ...}) = 0 stat("/sbin/hdparm", {st_mode=S_IFREG|0755, st_size=137, ...}) = 0 The Linux VFS is very fast but repeatedly doing this is wasteful. Remember the result of searching the PATH for the hdparm command at startup and refresh this when the [Rescan For Supported Actions] button is pressed in the File System Support dialog. This is the same as GParted already does for file system specific commands and their capabilities. Bug 751251 - Show serial number in device information
2015-06-30 05:14:20 -06:00
static void find_supported_core();
catch libparted exceptions and display them in the operationdetails if an * include/GParted_Core.h, src/GParted_Core.cc: catch libparted exceptions and display them in the operationdetails if an operation has failed. * src/Dialog_Progress.cc: small cosmetic change to the errordialog.
2006-02-25 09:30:43 -07:00
void find_supported_filesystems() ;
added support for commandline arguments (#329414) * include/GParted_Core.h, include/Win_GParted.h, src/GParted_Core.cc, src/Win_GParted.cc, src/main.cc: added support for commandline arguments (#329414)
2006-02-02 06:50:37 -07:00
void set_user_devices( const std::vector<Glib::ustring> & user_devices ) ;
some more cleanups, should be finished now :) * include/GParted_Core.h, src/GParted_Core.cc, src/Win_GParted.cc: some more cleanups, should be finished now :)
2006-06-18 02:50:17 -06:00
void set_devices( std::vector<Device> & devices ) ;
Reduce threading (#685740) Win_Gparted and Dialog_Progress were creating threads to perform most functions in the background. Most of the time, the only reason the threads blocked was to execute an external command. The external command execution has been changed to spawn the command asynchronously and wait for completion with a nested main loop. While waiting for completion, the pipe output is captured via events. In the future, this will allow for it to be parsed in real time to obtain progress information. Those tasks in GParted_Core that still block now spawn a background thread and wait for it to complete with a nested main loop to avoid hanging the gui. Part of Bug #685740 - Refactor to use asynchronous command execution
2013-02-21 17:57:33 -07:00
void set_devices_thread( std::vector<Device> * pdevices );
Remove unused error reporting from snap_to_*() (#48) None of the snap_to_*() methods report any errors so remove the unused error parameter and return value. Closes #48 - Error when moving locked LUKS-encrypted partition
2019-05-09 01:03:16 -06:00
Separate partition alignment from validation (#48) PATCHSET OVERVIEW A user had 2 adjacent partitions which were aligned to multiples of 33553920 bytes (32 MiB - 512 bytes), not MiB or cylinders. As far as GParted is concerned this is not aligned. The second partition contained closed LUKS encrypted data. Recreate this setup with: # truncate -s 200G /tmp/disk.img # losetup -f --show /tmp/disk.img /dev/loop0 # sfdisk -u S /dev/loop0 << EOF 65535 2162655 83 2228190 78904140 83 EOF # partprobe /dev/loop0 # echo -n badpassword | cryptsetup luksFormat /dev/loop0p2 - When trying to move the second LUKS encrypted partition to the right by any amount, with the default MiB alignment, GParted displays this error dialog and fails to even queue the operation: Could not add this operation to the list A partition with used sectors (78907392) greater than its length (78905344) is not valid [ OK ] Overview of the steps involved: 1. The Resize/Move dialog composed a new partition to start a whole multiple of MiB after the end of the previous non-aligned partition. The new partition also had it's size increased to a whole multiple of MiB, to 78907392 sectors (38529 MiB) which was 1.59 MiB larger than before. Neither the start or end of the new partition are aligned at this point. 2. Win_GParted::activate_resize() applied the change back to the closed LUKS partition object, additionally making the used sectors equal to the partition size. (To match the fact that when opened the LUKS mapping it will automatically fill the new larger partition size). 3. GParted_Core::snap_to_mebibyte() then aligned the partition start and end to whole MiB boundaries, reducing the partition size in the process to 78905344 (38528 MiB). 4. GParted_Core::snap_to_alignment() reported the error saying that it couldn't add the operation to the list because it was invalid to have the file system used sectors larger than the partition size. Fix this by having the snap to alignment adjustments applied before the dialogs update any associated file system usage. Specifically the Resize/Move, Paste (into new) and Create New dialogs as these are the only ones which either create or modify partition boundaries. Validation done by snap_to_alignment() will continue to occur at the current point when the operation is added to the list. THIS COMMIT snap_to_alignment() is doing two different jobs, it is (1) optionally adjusting the new partition boundaries for MiB or Cylinder alignment; and (2) checking that the partition boundaries and file system usage are valid. Split those into two different functions (1) snap_to_alignment() and (2) valid_partition(). For now valid_partition() still calls snap_to_alignment() so there is no functional change with this commit. Closes #48 - Error when moving locked LUKS-encrypted partition
2019-05-08 09:29:13 -06:00
bool valid_partition(const Device& device, Partition& partition, Glib::ustring& error);
lots of cleanups in operationhandling. This resulted in cleaner/less code * lots of cleanups in operationhandling. This resulted in cleaner/less code and the fixing of some longstanding issues.
2006-03-24 12:08:41 -07:00
bool apply_operation_to_disk( Operation * operation );
Erase file system signatures before creating a partition table (#743181) When writing "loop" partition table over the top of some whole disk device file system types GParted continued to show those whole disk device file systems rather than the virtual unknown partition from the "loop" partition table. This affected btrfs, jfs, reiser4 and reiserfs. It occurred because of several factors: 1) Libparted only zeroed the first and last 9.5 KiB (assuming 512 byte sectors) of the device before writing a new partition table. See ped_disk_clobber(). 2) These file systems have their super blocks and therefore signatures after the first 9.5 KiB. 3) Whole disk device file system detection is performed using blkid before checking for a libparted "loop" partition table. See GParted_Core::set_devices_thread(). Ref: libparted 3.2: disk.c:ped_disk_clobber() http://git.savannah.gnu.org/cgit/parted.git/tree/libparted/disk.c?id=v3.2#n302 Fix by always erasing any possible file system signatures on the device before creating a new "loop" partition table. NOTE: This is typically taking up to 0.5 seconds in my testing on a 5400 RPM hard drive, during which time the GParted UI is hung and the create partition table dialog shows the apply button pressed but no other progress indication. Bug 743181 - Add unpartitioned drive read-write support
2015-02-14 13:49:45 -07:00
bool set_disklabel( const Device & device, const Glib::ustring & disklabel );
Fix failure to recognise whole disk file systems in certain cases (#743181) When the following conditions were met GParted would fail to recognise a newly created whole disk device file system, and instead show an unknown file system filling the disk: 1) Disk was previously partitioned and contained at least one partition. 2) Using libparted version 2.0 to 3.0 inclusive. Initial status: # blkid | fgrep sdc # fgrep sdc /proc/partitions 8 32 976762584 sdc 8 33 104857600 sdc1 # parted /dev/sdc GNU Parted 2.4 Using /dev/sdc Welcome to GNU Parted! Type 'help' to view a list of commands. (parted) print Model: ATA ST1000LM024 HN-M (scsi) Disk /dev/sdc: 1000GB Sector size (logical/physical): 512B/4096B Partition Table: msdos Number Start End Size Type File system Flags 1 1049kB 107GB 107GB primary When creating the loop partition table libparted would not inform the kernel to delete the old partitions. /proc/partitions still contained the details of the old partitions. (parted) mktable loop Warning: The existing disk label on /dev/sdc will be destroyed and all data on this disk will be lost. Do you want to continue? Yes/No? Yes (parted) print Model: ATA ST1000LM024 HN-M (scsi) Disk /dev/sdc: 1000GB Sector size (logical/physical): 512B/4096B Partition Table: loop Number Start End Size File system Flags (parted) quit # fgrep sdc /proc/partitions 8 32 976762584 sdc 8 33 104857600 sdc1 Creation of the whole disk device file system goes unnoticed by blkid because the kernel and therefore blkid's cache have stale partition information. # mkfs.xfs -f /dev/sdc # blkid | fgrep sdc NOTE: On a Linux Software RAID array, as opposed to a hard disk, blkid does notice creation of the whole disk device file system. However the kernel still has old partition details. This was fixed in libparted 3.1 by commit: http://git.savannah.gnu.org/cgit/parted.git/commit/?id=f5c909c0cd50ed52a48dae6d35907dc08b137e88 libparted: remove has_partitions check to allow loopback partitions Fix by deleting old partitions before creating the loop table when compiled with a broken version of libparted. The GParted UI provides no feedback while a new partition table is created, and with some versions of GTK the UI become unresponsive too, so it is important to be as fast as possible. Evaluated three different methods, deleting 15 and 22 MSDOS partitions on a physical 5400 RPM hard drive using libparted 2.4: M1) Delete and commit one partition at a time. Takes up to 24 seconds to delete 15 partitions. With 22 partitions libparted always reports finding some of the partitions busy and unable to inform the kernel about the modifications. Too slow and doesn't work. M2) Delete all partitions in one go and commit once. Takes up to 1.4 seconds to delete either 15 or 22 partitions. Never removes partitions 17 and higher from the kernel. Doesn't work. M3) Write GPT table (letting libparted delete any old partitions). Takes up to 0.8 seconds to delete either 15 or 22 partitions. Fast and works. Use method 3 - write a GPT table thus using libparted code to inform the kernel of the old partition deletions. Bug 743181 - Add unpartitioned drive read-write support
2015-02-21 09:43:42 -07:00
bool new_disklabel( const Glib::ustring & device_path, const Glib::ustring & disklabel,
bool recreate_dmraid_devs = true );
restructured the core a bit, over time it had become very messy. * restructured the core a bit, over time it had become very messy.
2006-06-17 14:52:25 -06:00
bool toggle_flag( const Partition & partition, const Glib::ustring & flag, bool state ) ;
added movesupport, atm in experimental state and needs lots of cleaning. * include/GParted_Core.h, src/GParted_Core.cc, src/ext2.cc: added movesupport, atm in experimental state and needs lots of cleaning. only enabled for ext2, but should work for all filesystems. * src/DialogFeatures.cc: added alternating rowcolours (see #342682)
2006-05-31 14:03:49 -06:00
const std::vector<FS> & get_filesystems() const ;
Split FILESYSTEMS and FILESYSTEM_MAP into separate module (!49) GParted_Core::FILESYSTEMS and ::FILESYSTEM_MAP and the methods that query and manipulate them are self-contained. Therefore move them into a separate SupportedFileSystems module. Also having a single class maintaining all FileSystem interface objects will make testing all the file system types much easier as there will be no need to duplicate this functionality in the test. Closes !49 - Add file system interface tests
2019-07-16 06:01:07 -06:00
const FS& get_fs(FSType fstype) const;
Display partition table types in order (#711098) In the Create Partition Table dialog display the entries in the combobox in order. Previously the default of MSDOS or GPT was moved to the first item in the combobox. Now the partition table types remain in order with just either MSDOS or GPT being selected as as the default as required. The partition table types are displayed in the order supplied by libparted, which is alphabetic except with "loop" last. Bug #711098 - Default partition table can not handle > 2 TiB disks
2014-01-03 13:56:57 -07:00
static std::vector<Glib::ustring> get_disklabeltypes() ;
added movesupport, atm in experimental state and needs lots of cleaning. * include/GParted_Core.h, src/GParted_Core.cc, src/ext2.cc: added movesupport, atm in experimental state and needs lots of cleaning. only enabled for ext2, but should work for all filesystems. * src/DialogFeatures.cc: added alternating rowcolours (see #342682)
2006-05-31 14:03:49 -06:00
std::map<Glib::ustring, bool> get_available_flags( const Partition & partition ) ;
Added set and get thread status message methods. Added thread status message updates in set_devices(). svn path=/trunk/; revision=943
2008-10-30 12:50:38 -06:00
Glib::ustring get_thread_status_message() ;
Refactor get_filesystem_object() The function was using std::map::count() [1] to test if the file system entry existed in the map before looking up the value using std::map::operator[] to avoid having operator[] inserting elements which don't exist [2]. Rewrite using std::map::find() [3] so that map is only searched once, and so that it is more obvious what is happening without having to know the subtleties of std::map::count() and ::operator[]. [1] std::map::count() http://www.cplusplus.com/reference/map/map/count/ "Searches the container for elements with a key equivalent to k and returns the number of matches. Because all elements in a map container are unique, the function can only return 1 (if the element is found) or zero (otherwise). " [2] std::map::operator[] http://www.cplusplus.com/reference/map/map/operator[]/ "If k does not match the key of any element in the container, the function inserts a new element with that key and returns a reference to its mapped value. Notice that this always increases the container size by one, even if no mapped value is assigned to the element (the element is constructed using its default constructor). " [3] std::map::find http://www.cplusplus.com/reference/map/map/find/ "Searches the container for an element with a key equivalent to k and returns an iterator to it if found, otherwise it returns an iterator to map::end. "
2018-09-10 11:58:44 -06:00
static FileSystem * get_filesystem_object( FSType fstype );
Rename enum FILESYSTEM to FSType There are too many different types of things named "filesystem" in the GParted code with the potential to cause confusion. Namely: std::vector<FS> FILESYSTEMS Vector of file system capabilities. class FileSystem Base class interfacing to file system specific executables for querying and modification. enum FILESYSTEM Symbolic constants representing each file system type. Many recent written or re-written functions already used a variable named fstype. Rename enum FILESYSTEM to enum FSType to clearly distinguish it from the other things with very similar names. Only changing the name of the enumeration, not the name of variables of that type too because that is a lot more lines of code and those can be changed when the relevant code is re-written.
2018-01-02 10:44:01 -07:00
static bool supported_filesystem( FSType fstype );
static FS_Limits get_filesystem_limits( FSType fstype, const Partition & partition );
Disallow resizing of LVM2 PVs which are members of exported VGs (#670171) When an inactive LVM2 Volume Group is exported it makes it unknown to the local system, ready for moving the member Physical Volumes to another system, where the VG can be imported and used. In this state a PV can't be resized. # lvm pvresize /dev/sda10 Volume group Test-VG1 is exported Unable to read volume group "Test-VG1". 0 physical volume(s) resized / 1 physical volume(s) not resized # echo $? 5 Fix this by preventing resizing of such a PV. This has been coded in a generic way using new function filesystem_resize_disallowed() to determine whether a file system is allowed to be resized or not. For a file system which can be resized, but is currently not allowed to be resized, the behaviour is as follows: 1) Pasting into unallocated space is limited to creating a new partition which is the same size as the copied partition. 2) Resizing the partition is disallowed, only moving the partition is allowed. 3) Pasting into an existing partition will only copy the file system. If the destination partition is larger a warning will report that growing the file system is not currently allowed. 4) Checking a partition will also report a warning that growing the file system is not currently allowed. This is exactly the same behaviour as for a file system which does not implement resizing, except for a different warning message. Bug #670171 - Add LVM PV read-write support
2012-08-25 13:49:10 -06:00
static bool filesystem_resize_disallowed( const Partition & partition ) ;
Consolidate down to a single insert_unallocated() implementation (#759726) GParted_Core and Operation classes both have an insert_unallocated() method which do the same thing with very nearly identical code. Both methods insert unallocated partitions into the vector of partitions within the specified range of sectors to fill in any gaps larger than 1 MiB. The only difference was how the two methods got the device path; the GParted_Core class method got it via a parameter and the Operation class method got it by calling get_path() on its device member variable. The GParted_Core insert_unallocated() method gets called during device scanning and the Operation one gets called when constructing the visual for a pending operation. Consolidate down to a single insert_unallocated() implementation by making the Operation class method call the GParted_Core class method. Make the GParted_Core class method static and public so that it can be called using the class name from outside the class. Bug 759726 - Implement Partition object polymorphism
2015-12-07 00:24:38 -07:00
static void insert_unallocated( const Glib::ustring & device_path,
PartitionVector & partitions,
Sector start,
Sector end,
Byte_Value sector_size,
bool inside_extended );
added movesupport, atm in experimental state and needs lots of cleaning. * include/GParted_Core.h, src/GParted_Core.cc, src/ext2.cc: added movesupport, atm in experimental state and needs lots of cleaning. only enabled for ext2, but should work for all filesystems. * src/DialogFeatures.cc: added alternating rowcolours (see #342682)
2006-05-31 14:03:49 -06:00
private:
restructured the core a bit, over time it had become very messy. * restructured the core a bit, over time it had become very messy.
2006-06-17 14:52:25 -06:00
//detectionstuff..
Added set and get thread status message methods. Added thread status message updates in set_devices(). svn path=/trunk/; revision=943
2008-10-30 12:50:38 -06:00
void set_thread_status_message( Glib::ustring msg ) ;
Correctly const and assert detect_filesystem() parameters (#152) As discussed in the previous commit "Don't crash probing libparted unrecognised encrypted file system (#152)", detect_filesystem() accepted a NULL lp_device pointer and dereferenced it leading to the crash. Document the requirement for lp_device parameter to be non-NULL via an assert and also correctly const the parameters. This forces needing to const the lp_partition parameter to get_partition_path() too. Also assert it's non-NULL requirement. Closes #152 - GParted crashed when trying to probe an encrypted partition containing content that libparted doesn't recognise
2021-04-10 07:19:32 -06:00
static Glib::ustring get_partition_path(const PedPartition *lp_partition);
Create new method GParted_Core::set_device_from_disk() (#771244) Move code from GParted_Core::set_devices_thread() performing top level population of each Device object during the scan of the drives into new set_device_from_disk() method. Bug 771244 - gparted does not recognize the iso9660 file system in cloned Ubuntu USB boot drives
2016-12-22 00:57:02 -07:00
void set_device_from_disk( Device & device, const Glib::ustring & device_path );
Display device serial numbers (#751251) Run "hdparm -I /dev/DISK" to get the hard drive serial number of every device which has one and display it in the Device Information. The displayed value can either be the actual serial number, "none" or blank. "none" means the device doesn't have a hard drive serial number, such as for Linux software RAID arrays, BIOS fake RAID arrays or USB flash drives. Blank means something went wrong getting the serial number. Either it couldn't be found in the hdparm output or the hdparm command wasn't installed. Example real hard drive: # hdparm -I /dev/sda ... ATA device, with non-removable media Model Number: SAMSUNG HM500JI Serial Number: S1WFJDSZ123732 ... Example Linux software RAID array: # hdparm -I /dev/md127 /dev/md127: HDIO_DRIVE_CMD(identify) failed: Inappropriate ioctl for device On my desktop with 4 internal hard drives 2 Linux software RAID arrays on those hard drives, 2 USB flash drives and 1 USB hard drive attached, running hdparm 9 times added 0.07 seconds to the device refresh time. Bug 751251 - Show serial number in device information
2015-06-22 07:08:02 -06:00
void set_device_serial_number( Device & device );
Remove lp_device and lp_disk from GParted_Core (#683149) They were used like global variables. Now they are moved to the functions that actually use them to make clearer how the data flow is. Bug #683149 - Cleanup(?): Remove lp_device and lp_disk from GParted_Core
2012-10-30 03:30:49 -06:00
void set_device_partitions( Device & device, PedDevice* lp_device, PedDisk* lp_disk ) ;
Rename enum FILESYSTEM to FSType There are too many different types of things named "filesystem" in the GParted code with the potential to cause confusion. Namely: std::vector<FS> FILESYSTEMS Vector of file system capabilities. class FileSystem Base class interfacing to file system specific executables for querying and modification. enum FILESYSTEM Symbolic constants representing each file system type. Many recent written or re-written functions already used a variable named fstype. Rename enum FILESYSTEM to enum FSType to clearly distinguish it from the other things with very similar names. Only changing the name of the enumeration, not the name of variables of that type too because that is a lot more lines of code and those can be changed when the relevant code is re-written.
2018-01-02 10:44:01 -07:00
void set_device_one_partition( Device & device, PedDevice * lp_device, FSType fstype,
Display whole disk file systems via partition table "none" (#741430) For file systems which libparted recognises, when found on the whole disk device, it reports with partition table "loop" and a partition covering the whole disk. GParted duly displays this to the user. For file systems which libparted doesn't recognise it reports "unrecognised disk label". As of the latest libparted 3.2, these file system aren't recognised and can't currently be shown when on the whole disk device: BitLocker, Crypt LUKS, exFAT, F2FS, LVM2 Physical Volume, Linux Software RAID, ReFS, Reiser 4 So only when libparted doesn't recognise a file system on the whole disk device and GParted does, either via blkid or it's internal code, display this with partition table "none". Bug 741430 - GParted cannot recognise LVM signature on unpartitioned drive
2014-12-27 07:10:54 -07:00
std::vector<Glib::ustring> & messages );
Populate encrypted Partition member inside PartitionLUKS (#760080) When there exists an open dm-crypt mapping, populate the encrypted Partition object representing the encrypted file system. Bug 760080 - Implement read-only LUKS support
2015-12-23 05:26:17 -07:00
void set_luks_partition( PartitionLUKS & partition );
Create helper function set_partition_label_and_uuid() (#741430) Move code which queries the file system label and UUID of a partition into a separate helper function. Bug 741430 - GParted cannot recognise LVM signature on unpartitioned drive
2014-12-27 06:46:38 -07:00
void set_partition_label_and_uuid( Partition & partition );
Extract some code into detect_filesystem_in_encryption_mapping() (#148) To avoid making set_luks_partition() more complicated extract the file system detection portion into a new function. Closes 148 - Encrypted file systems are no longer recognised
2021-03-29 14:39:57 -06:00
static FSType detect_filesystem_in_encryption_mapping(const Glib::ustring& path,
std::vector<Glib::ustring>& messages);
Just pass sector size to detect_filesystem_internal() (!46)(#16) After the previous commit the lp_device structure pointer parameter is only used to provide sector_size. Just pass that instead. Closes !46 - Whole device FAT32 file system reports device busy warning from mlabel Closes #16 - "invalid argument for seek()" error on very small (<=40KiB) drives
2019-07-11 12:33:45 -06:00
static FSType detect_filesystem_internal(const Glib::ustring& path, Byte_Value sector_size);
Correctly const and assert detect_filesystem() parameters (#152) As discussed in the previous commit "Don't crash probing libparted unrecognised encrypted file system (#152)", detect_filesystem() accepted a NULL lp_device pointer and dereferenced it leading to the crash. Document the requirement for lp_device parameter to be non-NULL via an assert and also correctly const the parameters. This forces needing to const the lp_partition parameter to get_partition_path() too. Also assert it's non-NULL requirement. Closes #152 - GParted crashed when trying to probe an encrypted partition containing content that libparted doesn't recognise
2021-04-10 07:19:32 -06:00
static FSType detect_filesystem(const PedDevice *lp_device, const PedPartition *lp_partition,
std::vector<Glib::ustring> &messages);
Renamed set_label and get_label methods to write_label and read_label respectively. svn path=/trunk/; revision=957
2008-11-08 16:55:17 -07:00
void read_label( Partition & partition ) ;
Add support for setting UUID (#667278) Add the ability to set a new random UUID on file systems that provide the appropriate tools to perform this action. Update the help manual to include this new functionality. Also add reference links to "setting a partition label" and "changing a partition UUID" in the "copying and pasting a partition" section. This patch does not include setting the UUID on an NTFS file system. Bug #667278 - Add support for setting UUID Bug #608308 - fix documentation - Copying and Pasting a Partition
2012-01-22 13:49:52 -07:00
void read_uuid( Partition & partition ) ;
Refactor set_mountpoints() to be called per partition (#760080) Previously GParted_Core::set_mountpoints() was called with a vector of partitions and processed them all. Now make set_mountpoints() process a single partition and push the calls to it down one level from set_devices_thread() into set_device_partitions() and set_device_one_partition(). This is in preparation for having an encrypted file system represented as a Partition object inside a PartitionLUKS object and needing to call set_mountpoints() for the inner single Partition object. Bug 760080 - Implement read-only LUKS support
2015-11-27 01:30:56 -07:00
void set_mountpoints( Partition & partition );
bool set_mountpoints_helper( Partition & partition, const Glib::ustring & path );
Also pass device_path into GParted_Core::is_busy() (#183) Will use this extra parameter when determining if a device or partition containing bcache is busy or not. Closes #183 - Basic support for bcache
2022-01-07 01:53:52 -07:00
bool is_busy(const Glib::ustring& device_path, FSType fstype, const Glib::ustring& partition_path);
Refactor set_used_sectors() to be called per partition (#760080) This is the equivalent change as made to set_mountpoints() in an earlier commit. Change GParted_Core::set_used_sectors() from being called with a vector of partitions and processing them all to being called per partition. This is in preparation for calling set_used_sectors() on a single Partition object inside a PartitionLUKS object. Bug 760080 - Implement read-only LUKS support
2015-11-27 06:55:20 -07:00
void set_used_sectors( Partition & partition, PedDisk* lp_disk );
Fix false usage figures for busy SWRAID members (#27) Create an active Linux Software RAID member which is larger than /dev virtual file system and GParted will report the usage figure of the /dev virtual file system for the SWRAID member. # df -h /dev Filesystem Size Used Avail Use% Mounted on devtmpfs 732M 0 732M 0% /dev # sgdisk -n 1:1M:+1G /dev/sdb # mdadm --create --verbose /dev/md1 --level=linear --raid-devices=1 --force /dev/sdb1 mdadm: Defaulting to version 1.2 metadata mdadm: array /dev/md1 started. GParted reports the usage of /dev/sdb1 as: Partition Mount Point Size Used Unused Unallocated /dev/sdb1 /dev/md1 1.00GiB 0.00B 731.04MiB 292.96MiB However GParted should have reported the usage as "---" for unknown because it isn't coded to query the size of the SWRAID member within a partition. The fault has been bisected to this commit: Extend un/mounting and usage reporting to unsupported file systems (!13) 95903efb1f284f3d6819f38e894dc6c3464b2183 What happens for busy Linux Software RAID array members: * GParted_Core::is_busy() has custom code to identify busy members. * GParted_Core::set_mountpoints() has custom code to add the array device name as the "mount point" of the member. * GParted_Core::set_used_sectors() falls into the else not a supported file system (because SWRAID doesn't have a derived FileSystem implementation class). * GParted_Core::mounted_set_used_sectors() is called to get the file system usage of mounted, but unsupported file systems, such as UFS and any others. * Utils::get_mounted_filesystem_usage() is called which queries the kernel using statvfs() and gets the file system usage of the /dev virtual file system because the array device name will always start /dev. Fix by ensuring that GParted only asks the kernel for the usage of paths which it knows are mount points of mounted file systems. (As read from /proc/mounts and cached in the Mount_Info module). Also rename the method, by inserting "_fs", to mounted_fs_set_used_sectors() to remind us that it is for mounted *file systems* only. Closes #27 - GParted may report incorrect usage for SWRAID partitions instead of unknown S
2018-11-18 05:41:56 -07:00
void mounted_fs_set_used_sectors(Partition& partition);
Enable new fs resize library available with parted-3.1 (#668281) The parted-3.1 release brings back FAT16/FAT32 and HFS/HFS+ file system resize capabilities in a new libparted fs resize library. The following operations are again available when GParted is linked with parted-3.1: FAT16 - grow and shrink FAT32 - grow and shrink HFS - shrink HFS+ - shrink Note that there is a difference in how move actions are handled for FAT16/FAT32 file systems based on parted version. When GParted is linked with parted >= 3.0: FAT16 - move performed internally by GParted FAT32 - move performed internally by GParted When GParted is linked with parted < 3.0: FAT16 - move performed by libparted FAT32 - move performed by libparted Thanks goes to Jim Meyering for restoring these file system resizing capabilities in Parted 3.1 with a new libparted fs resize library. Closes Bug #668281 - minimal file-system resize API? (FAT and HFS* only)
2012-03-03 11:47:39 -07:00
#ifdef HAVE_LIBPARTED_FS_RESIZE
Remove lp_device and lp_disk from GParted_Core (#683149) They were used like global variables. Now they are moved to the functions that actually use them to make clearer how the data flow is. Bug #683149 - Cleanup(?): Remove lp_device and lp_disk from GParted_Core
2012-10-30 03:30:49 -06:00
void LP_set_used_sectors( Partition & partition, PedDisk* lp_disk ) ;
Enable compile and link with libparted 3.0 (#651559) The release of (lib)parted 3.0 includes a change to the Application Programing Interface - API. Most importantly, libparted 3.0 removes many file system specific function calls, and hence the capabilities provided by these functions. In order for GParted to compile and link with libparted 3.0, this libparted functionality is lost. Specifically, the functionality that is lost when GParted is compiled and linked with libparted 3.0 is as follows: - Loss of ability to grow and shrink FAT16 and FAT32 file systems - Loss of ability to shrink HFS and HFS+ file systems - Loss of ability to determine used and unused sectors in HFS and HFS+ file systems - Loss of ability to erase file system signatures on partition create and format It is hoped that other free software projects will include some or all of the above lost functionality, which can then be added back to GParted. This commit includes a change in how FAT16 and FAT32 file systems are moved. Specifically the move is now performed internally by GParted when linked with libparted 3.0. The move functionality is provided by libparted for prior libparted versions (e.g. less than 3.0). This is the final enhancement in a series of commits that enable GParted to compile with libparted version 3.0. Closes Bug #651559 - Doesn't compile against parted 3.0
2011-06-09 09:59:41 -06:00
#endif
Remove lp_partition from GParted_Core (#683149) Bug #683149 - Cleanup(?): Remove lp_device and lp_disk from GParted_Core
2012-10-30 03:43:46 -06:00
void set_flags( Partition & partition, PedPartition* lp_partition ) ;
Added set and get thread status message methods. Added thread status message updates in set_devices(). svn path=/trunk/; revision=943
2008-10-30 12:50:38 -06:00
restructured the core a bit, over time it had become very messy. * restructured the core a bit, over time it had become very messy.
2006-06-17 14:52:25 -06:00
//operationstuff...
Remove unused device parameter from a few GParted_Core methods resize_move() and move() stopped using the device parameter in this commit from 2006-07-23: d663c3c277f60da2ac1785c039f25f7920a315e9 removed cylindersize buffering during resize from the filesystems. It is create() stopped using the device parameter in this commit from 2006-03-19: ad9f2126e7fc92c16fffe839847dfe1c520146c8 fixed issues with copying (see also #335004) cleanups + added FIXME added For reference most other operation methods had the device parameter removed in this earlier commit from 2005-12-07: 642f0a145bc4b45a774dbf39e9cad4eb66afe56a from now on each partition has a reference to it's device. make use of new
2015-01-18 08:46:10 -07:00
bool create( Partition & new_partition, OperationDetail & operationdetail );
changed progressfeedbackhandling a bit. Because this affected * changed progressfeedbackhandling a bit. Because this affected OperationDetail i had to make changes in almost every file.
2006-08-20 03:33:54 -06:00
bool create_partition( Partition & new_partition, OperationDetail & operationdetail, Sector min_size = 0 ) ;
bool create_filesystem( const Partition & partition, OperationDetail & operationdetail ) ;
restructured the core a bit, over time it had become very messy. * restructured the core a bit, over time it had become very messy.
2006-06-17 14:52:25 -06:00
changed progressfeedbackhandling a bit. Because this affected * changed progressfeedbackhandling a bit. Because this affected OperationDetail i had to make changes in almost every file.
2006-08-20 03:33:54 -06:00
bool format( const Partition & partition, OperationDetail & operationdetail ) ;
restructured the core a bit, over time it had become very messy. * restructured the core a bit, over time it had become very messy.
2006-06-17 14:52:25 -06:00
Rename a few GParted_Core apply related methods (#775932) Make the methods called below apply_operation_to_disk() follow a standard naming convention: * Contains "_partition" Uses libparted to query or change the partition in the disk label (partition table). E.g.: calibrate_partition() create_partition() delete_partition() name_partition() resize_move_partition() set_partition_type() * Contains "_filesystem" Manipulates the file system within the partition, mostly using the FileSystem and derived class methods. E.g.: create_filesystem() remove_filesystem() label_filesystem() copy_filesystem() erase_filesystem_signatures() check_repair_filesystem() resize_filesystem() maximize_filesystem() * Other Compound method calling multiple partition and file system related apply methods. E.g.: create() format() copy() resize_move() resize() move() Rename: Delete() -> delete_partition() change_uuid() -> change_filesystem_uuid() Bug 775932 - Refactor mostly applying of operations
2016-11-19 04:49:44 -07:00
bool delete_partition( const Partition & partition, OperationDetail & operationdetail );
Add file system specific remove() methods (#670171) This commit only adds a remove() method to every file system and an optional call to it in the relevant operations. All remove() methods are no operations and not enabled. The remove() method provides explicit controlled removal of a file system before the partition is deleted or overwritten by being formatted or pasted into. When implemented, it appears as an extra step in the relevant operation. The file system specific remove() method is explicitly allowed to fail and stop the operations currently being applied. This is different to the existing erase_filesystem_signatures() which wipes any previous file system signatures immediately before a new file system is written to ensure there is no possibility of the partition containing two or more different file system signatures. It never fails or reports anything to the user. NOTE: Most file systems should NOT implement a remove() method as it will prevent recovery from accidental partition deletion. Bug #670171 - Add LVM PV read-write support
2012-07-25 14:05:33 -06:00
bool remove_filesystem( const Partition & partition, OperationDetail & operationdetail ) ;
Rename methods in GParted_Core and Win_GParted classes (#741424) class GParted_Core: label_partition() -> label_filesystem() class Win_GParted: allow_label_partition() -> allow_label_filesystem() activate_label_partition() -> activate_label_filesystem() Bug 741424 - Add support for GPT partition names
2014-12-18 15:18:33 -07:00
bool label_filesystem( const Partition & partition, OperationDetail & operationdetail );
Add support for GPT partition names (#741424) Embedded devices (Android) use GPT partition names to identify partitions, instead of file system labels. Add support for viewing and changing them. As partition names are used to provide unique identification they are never copied when copying the contents of one partition to another. Note that GNU/Linux uses file system labels, UUIDs or device names for identification during the boot process and afterwards so while partition names can be used, they are optional and purely for user information. Bug 741424 - Add support for GPT partition names
2014-12-12 00:00:02 -07:00
bool name_partition( const Partition & partition, OperationDetail & operationdetail );
Rename a few GParted_Core apply related methods (#775932) Make the methods called below apply_operation_to_disk() follow a standard naming convention: * Contains "_partition" Uses libparted to query or change the partition in the disk label (partition table). E.g.: calibrate_partition() create_partition() delete_partition() name_partition() resize_move_partition() set_partition_type() * Contains "_filesystem" Manipulates the file system within the partition, mostly using the FileSystem and derived class methods. E.g.: create_filesystem() remove_filesystem() label_filesystem() copy_filesystem() erase_filesystem_signatures() check_repair_filesystem() resize_filesystem() maximize_filesystem() * Other Compound method calling multiple partition and file system related apply methods. E.g.: create() format() copy() resize_move() resize() move() Rename: Delete() -> delete_partition() change_uuid() -> change_filesystem_uuid() Bug 775932 - Refactor mostly applying of operations
2016-11-19 04:49:44 -07:00
bool change_filesystem_uuid( const Partition & partition, OperationDetail & operation_detail );
Add support for setting UUID (#667278) Add the ability to set a new random UUID on file systems that provide the appropriate tools to perform this action. Update the help manual to include this new functionality. Also add reference links to "setting a partition label" and "changing a partition UUID" in the "copying and pasting a partition" section. This patch does not include setting the UUID on an NTFS file system. Bug #667278 - Add support for setting UUID Bug #608308 - fix documentation - Copying and Pasting a Partition
2012-01-22 13:49:52 -07:00
Remove unused device parameter from a few GParted_Core methods resize_move() and move() stopped using the device parameter in this commit from 2006-07-23: d663c3c277f60da2ac1785c039f25f7920a315e9 removed cylindersize buffering during resize from the filesystems. It is create() stopped using the device parameter in this commit from 2006-03-19: ad9f2126e7fc92c16fffe839847dfe1c520146c8 fixed issues with copying (see also #335004) cleanups + added FIXME added For reference most other operation methods had the device parameter removed in this earlier commit from 2005-12-07: 642f0a145bc4b45a774dbf39e9cad4eb66afe56a from now on each partition has a reference to it's device. make use of new
2015-01-18 08:46:10 -07:00
bool resize_move( const Partition & partition_old,
Partition & partition_new,
OperationDetail & operationdetail );
bool move( const Partition & partition_old,
const Partition & partition_new,
OperationDetail & operationdetail );
did more work on moving * include/GParted_Core.h, src/GParted_Core.cc: did more work on moving
2006-06-18 13:27:52 -06:00
bool move_filesystem( const Partition & partition_old,
added FIXME: decoupled libparted partition and filesystemresizing. This * src/Win_GParted.cc: added FIXME: * include/GParted_Core.h, src/GParted_Core.cc, src/fat32.cc: decoupled libparted partition and filesystemresizing. This resulted in a much more consistent core. This also affected several other aspects of resizing/moving in a positive way.
2006-07-23 03:58:45 -06:00
const Partition & partition_new,
changed progressfeedbackhandling a bit. Because this affected * changed progressfeedbackhandling a bit. Because this affected OperationDetail i had to make changes in almost every file.
2006-08-20 03:33:54 -06:00
OperationDetail & operationdetail ) ;
Enable new fs resize library available with parted-3.1 (#668281) The parted-3.1 release brings back FAT16/FAT32 and HFS/HFS+ file system resize capabilities in a new libparted fs resize library. The following operations are again available when GParted is linked with parted-3.1: FAT16 - grow and shrink FAT32 - grow and shrink HFS - shrink HFS+ - shrink Note that there is a difference in how move actions are handled for FAT16/FAT32 file systems based on parted version. When GParted is linked with parted >= 3.0: FAT16 - move performed internally by GParted FAT32 - move performed internally by GParted When GParted is linked with parted < 3.0: FAT16 - move performed by libparted FAT32 - move performed by libparted Thanks goes to Jim Meyering for restoring these file system resizing capabilities in Parted 3.1 with a new libparted fs resize library. Closes Bug #668281 - minimal file-system resize API? (FAT and HFS* only)
2012-03-03 11:47:39 -07:00
#ifdef HAVE_LIBPARTED_FS_RESIZE
added FIXME: decoupled libparted partition and filesystemresizing. This * src/Win_GParted.cc: added FIXME: * include/GParted_Core.h, src/GParted_Core.cc, src/fat32.cc: decoupled libparted partition and filesystemresizing. This resulted in a much more consistent core. This also affected several other aspects of resizing/moving in a positive way.
2006-07-23 03:58:45 -06:00
bool resize_move_filesystem_using_libparted( const Partition & partition_old,
const Partition & partition_new,
changed progressfeedbackhandling a bit. Because this affected * changed progressfeedbackhandling a bit. Because this affected OperationDetail i had to make changes in almost every file.
2006-08-20 03:33:54 -06:00
OperationDetail & operationdetail ) ;
Add libparted ped_file_system_resize thread to avoid blocking GUI (#737022) Since GParted commit 52a2a9b "Reduce threading (#685740)", released in GParted 0.15.0, application of operations occurs in the main thread running the UI, therefore long running libparted actions such as resizing a FAT16 or FAT32 file system hang the UI for as long as it take to complete the operation. https://git.gnome.org/browse/gparted/commit/?id=52a2a9b00a32996921ace055e71d0e09fb33c5fe Though this problem exists for all libparted actions, it is particularly noticeable when performing a large resize of fat16/fat32/hfs/hfs+ file systems. To address this significant cause of an unresponsive GUI, this enhancement adds threading to the libparted ped_file_system_resize function call. Bug 737022 - UI hangs while running libparted operations such as FAT16/FAT32 resizing
2015-07-14 13:40:56 -06:00
void thread_lp_ped_file_system_resize( PedFileSystem * fs,
PedGeometry * lp_geom,
bool * return_value );
Enable compile and link with libparted 3.0 (#651559) The release of (lib)parted 3.0 includes a change to the Application Programing Interface - API. Most importantly, libparted 3.0 removes many file system specific function calls, and hence the capabilities provided by these functions. In order for GParted to compile and link with libparted 3.0, this libparted functionality is lost. Specifically, the functionality that is lost when GParted is compiled and linked with libparted 3.0 is as follows: - Loss of ability to grow and shrink FAT16 and FAT32 file systems - Loss of ability to shrink HFS and HFS+ file systems - Loss of ability to determine used and unused sectors in HFS and HFS+ file systems - Loss of ability to erase file system signatures on partition create and format It is hoped that other free software projects will include some or all of the above lost functionality, which can then be added back to GParted. This commit includes a change in how FAT16 and FAT32 file systems are moved. Specifically the move is now performed internally by GParted when linked with libparted 3.0. The move functionality is provided by libparted for prior libparted versions (e.g. less than 3.0). This is the final enhancement in a series of commits that enable GParted to compile with libparted version 3.0. Closes Bug #651559 - Doesn't compile against parted 3.0
2011-06-09 09:59:41 -06:00
#endif
removed cylindersize buffering during resize from the filesystems. It is * include/FileSystem.h, include/GParted_Core.h, src/FileSystem.cc, src/GParted_Core.cc, src/ext2.cc, src/ext3.cc, src/ntfs.cc, src/reiserfs.cc: removed cylindersize buffering during resize from the filesystems. It is not needed anymore now we calculate the new position before calling this. Also added some extra progressfeedback in the core
2006-07-23 12:43:15 -06:00
bool resize( const Partition & partition_old,
more work on moving/resizing sequence * include/GParted_Core.h, src/GParted_Core.cc: more work on moving/resizing sequence
2006-07-23 10:51:38 -06:00
const Partition & partition_new,
changed progressfeedbackhandling a bit. Because this affected * changed progressfeedbackhandling a bit. Because this affected OperationDetail i had to make changes in almost every file.
2006-08-20 03:33:54 -06:00
OperationDetail & operationdetail ) ;
Implement resize/move operation of encrypted file systems (#774818) Moving of closed LUKS is simply enabled by luks .move capability being set and requires no further coding. Resizing of encrypted file systems requires both the LUKS mapping and encrypted file system within to be resized in the right order for both shrinking and growing. To keep the code simple split resizing of plain and encrypted into separate functions. Bug 774818 - Implement LUKS read-write actions NOT requiring a passphrase
2016-12-05 04:37:18 -07:00
bool resize_encryption( const Partition & partition_old,
const Partition & partition_new,
OperationDetail & operationdetail );
bool resize_plain( const Partition & partition_old,
const Partition & partition_new,
OperationDetail & operationdetail );
renamed resize_partition to resize_move_partition to better reflect its * include/GParted_Core.h, src/GParted_Core.cc: renamed resize_partition to resize_move_partition to better reflect its functionality.
2006-06-18 13:38:29 -06:00
bool resize_move_partition( const Partition & partition_old,
Implement rollback of failed partition resize/move steps (#791875) Even after implementing a fix for bug 790418 "Unable to inform the kernel of the change message may lead to corrupted partition table" GParted/libparted can still encounter errors informing the kernel of the new partition layout. This has been seen with GParted on CentOS 7 with libparted 3.1. In such a case the partition has been successfully written to the disk but just informing the kernel failed. This is a problem because when a partition is being moved in advance of a file system move step, failure to inform the kernel leaves the partition boundaries not matching the on disk limits of the file system. For a move to the left this leaves the partition reported as unknown, apparently losing the user's data. For example start with a 512 MiB partition containing an XFS file system. This is recognised by blkid and parted, hence also by GParted. # blkid /dev/sdb1 /dev/sdb1: UUID=... TYPE="xfs" PARTUUID="37965980-01" # parted /dev/sdb unit s print Model: ATA VBOX HARDDISK (scsi) Disk /dev/sdb: 16777216s Sector size (logical/physical): 512B/512B Partition Table: msdos Disk Flags: Number Start End Size Type File system Flags 1 1048576s 2097151s 1048576s primary xfs Now move the partition 100 MiB to the left and have it fail to inform the kernel after the first partition change step. Operation details: Move /dev/sdb1 to the left (ERROR) * calibrate /dev/sdb1 (SUCCESS) * check file system on /dev/sdb1 for errors and (if poss...(SUCCESS) * grow partition from 512.00 MiB to 612.00 MiB (ERROR) old start: 1048576 old end: 2097151 old size: 1048576 (512.00 MiB) requested start: 843776 requested end: 2097151 requested size: 1253376 (612.00 MiB) * libparted messages (ERROR) Error informing the kernel about modifications to partition /dev/sdb1 -- Device or resource busy. This means Linux won't know about any changes you made to /dev/sdb1 until you reboot -- so you shouldn't mount it or use it in any way before rebooting. Failed to add partition 1 (resource temporarily unavailable) Now because the start of the partition is 100 MiB before the start of the file system, the file system is no longer recognised, and apparently the user's data has been lost. # blkid /dev/sdb1 /dev/sdb1: PARTUUID="37965980-01" # parted /dev/sdb unit s print ... Number Start End Size Type File system Flags 1 843776s 2097151s 1253376s primary It doesn't matter why updating the partition failed, even if it was because of an error writing to the disk. Rollback of the change to the partition should be attempted. The worst case scenario is that rollback of the change fails, which is the equivalent to how the code worked before this patch set. However in other cases where the partition boundaries are being updated after a file system move or shrink step then the partition should be updated to match the new location of the file system itself. And no rollback is wanted. If the failure was only informing the kernel then in fact the partition has actually been updated on disk after all. So each partition resize/move step needs examining on a case by case basis to decide if rolling back the change to the partition is wanted or not. This patch only adds partition change rollback into resize_move_partition(). Rollback remains disabled until all cases are examined in the following patch. Bug 791875 - Rollback specific failed partition change steps
2017-12-08 09:46:31 -07:00
const Partition & partition_new,
OperationDetail & operationdetail,
Enable failed partition change rollback for selected steps (#791875) The general rule is that: 1) For a partition change step BEFORE a file system change step, rollback on failure; 2) For a partition change step AFTER a file system change step, don't rollback on failure. Examining every case where resize_move_partition() is called and whether rollback on failure is wanted or not: * In resize_move() Resize / move extended partition. No associated file system change. NO ROLLBACK Just to keep possibly applied operation. * #1 in move() Making all encompassing partition before moving file system. ROLLBACK To restore partition boundaries back to those of the file system. * #2 in move() Recreating original partition boundaries after file system move failed or was cancelled and has been rolled back. NO ROLLBACK To keep updated partition boundaries to match restored file system data. * #3 in move() Replacing all encompassing partition with final partition after successful file system move. NO ROLLBACK Keep new partition boundaries to match moved file system. * #1 in resize_encryption() Making the partition larger before growing closed LUKS encrypted data. ROLLBACK Restore partition boundaries back to those of the closed LUKS encrypted data. * #2 in resize_encryption() Shrinking the partition after open LUKS mapping has been shrunk, but before swap is re-created (smaller). NO ROLLBACK Difficult case because the partition shrink is in the middle of a LUKS shrink and a swap shrink (re-create). If swap was actually shrunk like other types of file system, rather than re-created, then the operation sequence would be (1) shrink swap, (2) shrink LUKS encryption, (3) shrink partition. In this hypothetical case and the actual case no rollback is preferred to try to keep the new partition boundaries match the shrunk open LUKS encryption mapping. * #3 in resize_encryption() Grow the partition before growing open LUKS mapping and re-creating swap larger. ROLLBACK Restore partition boundaries back to those of the smaller open LUKS encryption mapping. * #4 in resize_encryption() Shrink the partition after shrinking the file system and open LUKS encryption mapping. NO ROLLBACK Keep new smaller partition boundaries to match shrunk encrypted file system. * #5 in resize_encryption() Grow the partition before growing the open LUKS encryption mapping and file system. ROLLBACK Restore partition boundaries back to those of the not yet grown encrypted file system. * #1 in resize_plain() Resize partition before re-creating swap a different size. ROLLBACK Restore partition boundaries back to those of the not yet resized (re-created) swap space. * #2 in resize_plain() Shrink partition after shrinking the file system. NO ROLLBACK Keep new smaller partition boundaries to match shrunk file system. * #3 in resize_plain() Grow partition before growing the file system. ROLLBACK Restore partition boundaries back to those of the not yet grown file system. Removes the default value from the rollback_on_fail parameter so rollback or not has to be explicitly specified for every call of resize_move_partition(). Bug 791875 - Rollback specific failed partition change steps
2017-12-18 09:39:37 -07:00
bool rollback_on_fail );
Extract code into resize_move_partition_implement() (#791875) Extract the code which actually implements the partition change into a sub-function ready for adding rollback of the change on failure. Bug 791875 - Rollback specific failed partition change steps
2017-12-08 09:32:30 -07:00
bool resize_move_partition_implement( const Partition & partition_old,
const Partition & partition_new,
Sector & new_start,
Sector & new_end );
Implement resize/move operation of encrypted file systems (#774818) Moving of closed LUKS is simply enabled by luks .move capability being set and requires no further coding. Resizing of encrypted file systems requires both the LUKS mapping and encrypted file system within to be resized in the right order for both shrinking and growing. To keep the code simple split resizing of plain and encrypted into separate functions. Bug 774818 - Implement LUKS read-write actions NOT requiring a passphrase
2016-12-05 04:37:18 -07:00
bool shrink_encryption( const Partition & partition_old,
const Partition & partition_new,
OperationDetail & operationdetail );
bool maximize_encryption( const Partition & partition,
OperationDetail & operationdetail );
Refactor resizing file system apply methods (#775932) resize_filesystem() was meeting two different needs: 1) when called with fill_partition = false it generated operation details; 2) when called from maximize_filesystem() with fill_partition = true it skipped generating any operation details; then ran the switch statement to select the resize implementation. So extract the common switch statement into new method resize_filesystem_implement(). Then observe that the only time resize_filesystem() was called to grow the file system was when re-creating linux-swap. Therefore change that call to use maximize_filesystem() and rename to shrink_filesystem() and modify the operation detail messages to match. Bug 775932 - Refactor mostly applying of operations
2016-10-26 14:24:28 -06:00
bool shrink_filesystem( const Partition & partition_old,
const Partition & partition_new,
OperationDetail & operationdetail );
changed progressfeedbackhandling a bit. Because this affected * changed progressfeedbackhandling a bit. Because this affected OperationDetail i had to make changes in almost every file.
2006-08-20 03:33:54 -06:00
bool maximize_filesystem( const Partition & partition, OperationDetail & operationdetail ) ;
Refactor linux-swap recreation (#775932) Linux-swap is recreated as part of copy, resize and move operations and the code was special cased to implement that by calling the linux-swap specific resize method. However the displayed text always said "growing file system" and then proceeded to recreate linux swap. Example operation: Copy /dev/sdb1 to /dev/sdb2 ... + copy file system from /dev/sdb1 to /dev/sdb2 Partition copy action skipped because linux-swap file system does not contain data + grow file system to fill the partition + create new linux-swap file system + mkswap -L"" -U "77d939ef-54d6-427a-a2bf-a053da7eed4c" /dev/sdb2 Setting up swapspace version 1, size = 262140 KiB LABEL=, UUID=77d939ef-54d6-427a-a2bf-a053da7eed4c Fix by writing recreate_linux_swap_filesystem() method with better messaging and use everywhere maximise_filesystem() was previously used to recreate linux-swap. Also as this is a create step, erase the partition first to prevent the possibility of any other file system signatures being found afterwards. Now the operation steps are more reflective of what is actually being performed. Copy /dev/sdb1 to /dev/sdb2 ... + copy file system from /dev/sdb1 to /dev/sdb2 Partition copy action skipped because linux-swap file system does not contain data + clear old file system signatures in /dev/sdb2 + create new linux-swap file system + mkswap -L"" -U "77d939ef-54d6-427a-a2bf-a053da7eed4c" /dev/sdb2 Setting up swapspace version 1, size = 262140 KiB LABEL=, UUID=77d939ef-54d6-427a-a2bf-a053da7eed4c Bug 775932 - Refactor mostly applying of operations
2016-11-19 16:48:22 -07:00
bool recreate_linux_swap_filesystem( const Partition & partition,
OperationDetail & operationdetail );
Refactor resizing file system apply methods (#775932) resize_filesystem() was meeting two different needs: 1) when called with fill_partition = false it generated operation details; 2) when called from maximize_filesystem() with fill_partition = true it skipped generating any operation details; then ran the switch statement to select the resize implementation. So extract the common switch statement into new method resize_filesystem_implement(). Then observe that the only time resize_filesystem() was called to grow the file system was when re-creating linux-swap. Therefore change that call to use maximize_filesystem() and rename to shrink_filesystem() and modify the operation detail messages to match. Bug 775932 - Refactor mostly applying of operations
2016-10-26 14:24:28 -06:00
bool resize_filesystem_implement( const Partition & partition_old,
const Partition & partition_new,
OperationDetail & operationdetail );
restructured the core a bit, over time it had become very messy. * restructured the core a bit, over time it had become very messy.
2006-06-17 14:52:25 -06:00
bool copy( const Partition & partition_src,
Refactor GParted_Core::copy() (#775932) Split out the switch statement selecting the copy implementation and associated copy file system operation detail message into a separate copy_filesystem() method, matching how a number of other operations are coded. This is why the previous copy_filesystem() methods needed renaming. Re-write the remaining copy() into if-operation-fails-return-false style to simplify it. Re-write final complicated conditional check repair and maximise file system into separate positive if conditions for swap and larger partition to make it understandable. The min_size parameter to copy() was queried from the partition_src parameter also passed to copy(). Drop the parameter and query inside copy() instead. Bug 775932 - Refactor mostly applying of operations
2016-11-04 09:07:29 -06:00
Partition & partition_dst,
OperationDetail & operationdetail );
bool copy_filesystem( const Partition & partition_src,
Partition & partition_dst,
OperationDetail & operationdetail );
Rename copy_filesystem() methods (#775932) Rename GParted_Core methods: copy_filesystem(4 params) -> copy_filesystem_internal() copy_filesystem(5 params) -> copy_filesystem_internal() copy_filesystem(10 params) -> copy_blocks() See the following commit for the desire to do this. Bug 775932 - Refactor mostly applying of operations
2016-11-04 07:45:50 -06:00
bool copy_filesystem_internal( const Partition & partition_src,
const Partition & partition_dst,
OperationDetail & operationdetail,
bool cancel_safe );
bool copy_filesystem_internal( const Partition & partition_src,
const Partition & partition_dst,
OperationDetail & operationdetail,
Byte_Value & total_done,
bool cancel_safe );
bool copy_blocks( const Glib::ustring & src_device,
const Glib::ustring & dst_device,
Sector src_start,
Sector dst_start,
Byte_Value src_sector_size,
Byte_Value dst_sector_size,
Byte_Value src_length,
OperationDetail & operationdetail,
Byte_Value & total_done,
bool cancel_safe );
Rename function and reword text for rollback of failed file system move To better reflect specifically that it is a failed (internally implemented) file system move which is being rolled back.
2017-11-30 01:34:30 -07:00
void rollback_move_filesystem( const Partition & partition_src,
const Partition & partition_dst,
OperationDetail & operationdetail,
Byte_Value total_done );
restructured the core a bit, over time it had become very messy. * restructured the core a bit, over time it had become very messy.
2006-06-17 14:52:25 -06:00
changed progressfeedbackhandling a bit. Because this affected * changed progressfeedbackhandling a bit. Because this affected OperationDetail i had to make changes in almost every file.
2006-08-20 03:33:54 -06:00
bool check_repair_filesystem( const Partition & partition, OperationDetail & operationdetail ) ;
Implement maximize encryption volume as part of check repair operation (#774818) Now that resizing of encrypted file systems is implemented add growing of the open LUKS mapping as part of the check repair operation. Resizing an encrypted file system requires the LUKS mapping to be open to access the file system within; therefore it also requires libparted and kernel support for online partition resizing. This limits resizing to the latest distributions with libparted >= 3.2 and kernel >= 3.6. However growing an open LUKS mapping as part of a check repair operation doesn't require resizing the partition. Therefore route via offline grow of LUKS to avoid those extra, unnecessary requirement. This does mean that offline LUKS grow artificially requires cryptsetup, but that is not really significant as even opening LUKS requires cryptsetup. So now checking an encrypted file system on even the oldest distributions does: 1) runs FSCK on the encrypted file system; 2) grows the encryption volume to fill the partition; 3) grows the file system to fill the encryption mapping. Bug 774818 - Implement LUKS read-write actions NOT requiring a passphrase
2016-12-05 05:21:19 -07:00
bool check_repair_maximize( const Partition & partition,
OperationDetail & operationdetail );
restructured the core a bit, over time it had become very messy. * restructured the core a bit, over time it had become very messy.
2006-06-17 14:52:25 -06:00
changed progressfeedbackhandling a bit. Because this affected * changed progressfeedbackhandling a bit. Because this affected OperationDetail i had to make changes in almost every file.
2006-08-20 03:33:54 -06:00
bool set_partition_type( const Partition & partition, OperationDetail & operationdetail ) ;
restructured the core a bit, over time it had become very messy. * restructured the core a bit, over time it had become very messy.
2006-06-17 14:52:25 -06:00
more fixes related to moving.. * include/GParted_Core.h, src/GParted_Core.cc: more fixes related to moving..
2006-09-03 08:24:05 -06:00
bool calibrate_partition( Partition & partition, OperationDetail & operationdetail ) ;
added FIXME: decoupled libparted partition and filesystemresizing. This * src/Win_GParted.cc: added FIXME: * include/GParted_Core.h, src/GParted_Core.cc, src/fat32.cc: decoupled libparted partition and filesystemresizing. This resulted in a much more consistent core. This also affected several other aspects of resizing/moving in a positive way.
2006-07-23 03:58:45 -06:00
bool calculate_exact_geom( const Partition & partition_old,
Partition & partition_new,
^) restructured resize_move() to be more robust. This will hopefully * happy 24th birthday Johannes! :^) * include/GParted_Core.h, src/GParted_Core.cc: restructured resize_move() to be more robust. This will hopefully tackle a couple of issues which came up during the public testing.
2006-08-27 02:41:25 -06:00
OperationDetail & operationdetail ) ;
Extract common code into update_dmraid_entry() (#791875) Extract common code which updates a DMRaid device mapper entry into a sub-function. This will also be needed when adding rollback of a partition change on failure. Bug 791875 - Rollback specific failed partition change steps
2017-12-28 05:08:25 -07:00
bool update_dmraid_entry( const Partition & partition_new, OperationDetail & operationdetail );
Use wipefs to clear old signatures before creating new file systems (#688882) Previously the function erase_filesystem_signatures() was used to clear file system signatures when a new partition was created and when an existing partition was formatted with a file system. However this was only available with libparted <= 2.4 and then only for the file systems which libparted supports. Having multiple different file system signatures on a partition leads to misidentification of file system. For example creating a nilfs2 over the top of a fat32 file system is detected as a fat32, not nilfs2. This shows that old file system signatures must be cleared before a new file system is created. Fix by always using "wipefs -a /dev/PARTITION" command to clear all old file system signatures rather than libparted API calls. Failure from wipefs is only considered a warning so doesn't fail the file system creation. (This doesn't yet fully meet the "MUST be cleared" requirement above. Will be fully met later in this patchset). Output from the wipefs command is displayed as a new sub-step which looks like this: v Format /dev/sda7 as xfs 00:00:05 > calibrate /dev/sda14 00:00:01 v clear old file system signatures in /dev/sda7 00:00:01 [NEW] > wipefs -a /dev/sda7 [NEW] > set partition type on /dev/sda7 00:00:02 v create new xfs file system 00:00:01 > mkfs.xfs -f -L "" /dev/sda7 Also signatures are only cleared immediately before a new file system is written and not when an unformatted partition is created. This allows recovery from accidental partition deletion by re-creating the deleted partition as unformatted. Bug #688882 - Improve clearing of file system signatures
2012-12-01 05:49:29 -07:00
bool erase_filesystem_signatures( const Partition & partition, OperationDetail & operationdetail ) ;
update ntfsbootsector after first sector has changed. This is necessary to * include/GParted_Core.h, src/GParted_Core.cc: update ntfsbootsector after first sector has changed. This is necessary to let windows boot correctly afterwards. * src/ntfs.cc: added FIXME
2006-09-04 13:18:44 -06:00
bool update_bootsector( const Partition & partition, OperationDetail & operationdetail ) ;
restructured the core a bit, over time it had become very messy. * restructured the core a bit, over time it had become very messy.
2006-06-17 14:52:25 -06:00
//general..
Identify libparted messages as either success or error (#790842) All libparted messages were reported as informational, even for a step which failed. Instead identify libparted messages as either informational or errors depending on whether this step was successful or not respectively. Bug 790842 - Report libparted messages into operation details at the point at which they occur
2017-11-26 06:23:31 -07:00
void capture_libparted_messages( OperationDetail & operationdetail, bool success );
Capture libparted messages via callback at top-level only (#790842) Replace the explicit adding of libparted exception messages with a callback to do it instead, and fire the callback just once per operation by only changing the very top-level OperationDetail to use the new set_success_and_capture_errors(). Therefore this still produces exactly the same operation details with libparted messages at the end of each operation. Bug 790842 - Report libparted messages into operation details at the point at which they occur
2017-11-25 06:56:56 -07:00
Only explicitly flush devices when using libparted < 3.2 (#259) During device probing GParted always explicitly calls ped_device_sync() to flush the caches for coherency between the whole disk device and the partition devices [1]. As the GParted_Core::flush_device() comment explains, since v3.1.61-gfb99ba5 [2], libparted flushes the devices every time a device is opened [3], so also explicitly doing this in GParted is unnecessary. Therefore stop explicitly flushing the devices in GParted, except when using libparted 3.1 and older which doesn't do it itself. The ped_device_open() and ped_device_close() needed for the ped_device_sync() is also a trigger of device changes and udev rule execution performing LVM Volume Group activation, because libparted opens the device read-write [4]. This is another reason to remove it when possible. However even when eliminated it does not solve the issue of LVM VG activation because other triggers remain. Do want this change first though so that the sequence of libparted calls isn't changed immediately after documenting them and fixing the issue and so that there is no doubt that this change doesn't fix the issue. Removing this extra device flush saves a little bit of time, depending on the speed of the drive and number of partitions. Sample savings on my desktop: Drive type and partitions Saving (seconds) ----------------------------- ---------------- fast SSD with 3 partitions 0.05 slow SSD with 12 partitions 0.27 HDD with 1 partition 0.05 VHDD in VM with 1 partition 0.14 VHDD in VM with 10 partitions 0.58 Also the settle_device() call in flush_device() needs to be kept to wait for device changes and udev rule execution whether it is GParted explicitly flushing the device or just libparted automatically doing it for cache coherency in ped_device_get(). This is because: 1. Libparted <= 3.2 opens the whole disk device read-write for ped_device_get() [5]. (This was changed with parted v3.2.26-g44d5ae0 [6] to open the whole disk device read-only). 2. Libparted up to and including the latest 3.6 release still opens all partition devices read-write for ped_device_get() [7]. 3. A whole disk device FAT32 file system looks enough like a partition table that both the Linux kernel and libparted think it is partitioned: # mkfs.fat -F32 /dev/sdb mkfs.fat 4.2 (2021-01-31) # grep sdb /proc/partitions 8 16 8388608 sdb 8 17 8388607 sdb1 # parted /dev/sdb print Model: ATA VBOX HARDDISK (scsi) Disk /dev/sdb: 8590MB Sector size (logical/physical): 512B/512B Partition Table: loop Disk Flags: Number Start End Size File system Flags 1 0s 16777215s 16777216s fat32 So the ped_device_get() call on a whole disk device FAT32 file system still triggers device change and udev rule execution which needs to be waited for, as this is exactly the case fixed previously by commit: 1382e0b828f630a705cecd97c346dfc6267909bf Wait for udev change on /dev/DISK when querying whole device FS (!46) [1] 3bea067596e3e2d6513cda2a66df1b3e4fa432fb Flush devices when scanning to prevent reading stale signatures (#723842) [2] Revert "linux-commit: do not unnecessarily open partition device nodes" http://git.savannah.gnu.org/cgit/parted.git/commit/?id=fb99ba5ebd0dc34204fc9f1014131d5d494805bc [3] parted libparted/arch/linux.c:_device_open() https://git.savannah.gnu.org/cgit/parted.git/tree/libparted/arch/linux.c?h=v3.6#n1752 1709 static int 1710 linux_open (PedDevice* dev) 1711 { 1712 return _device_open (dev, RW_MODE); 1713 } 1714 1715 static int 1716 _device_open (PedDevice* dev, int flags) ... 1752 _flush_cache (dev); [4] parted libparted/device.c:ped_device_open() v3.6 https://git.savannah.gnu.org/cgit/parted.git/tree/libparted/device.c?h=v3.6#n226 parted libparted/arch/linux.c v3.6 https://git.savannah.gnu.org/cgit/parted.git/tree/libparted/arch/linux.c?h=v3.6 ped_device_open(...) ped_architecture->dev_ops->open(...) = linux_open(...) _device_open(..., RW_MODE) open(..., O_RDWR) [5] parted libparted/device.c:ped_device_get() v3.2 https://git.savannah.gnu.org/cgit/parted.git/tree/libparted/device.c?h=v3.2#n149 parted libparted/arch/linux.c v3.2 https://git.savannah.gnu.org/cgit/parted.git/tree/libparted/arch/linux.c?h=v3.2 ped_device_get(...) ped_architecture->dev_ops->_new(...) = linux_new() init_ide(...) init_scsi(...) init_generic(...) ped_device_open(...) ped_architecture->dev_ops->open(...) = linux_open(...) open(..., O_RDWR) [6] libparted: Use read only when probing devices on linux (#1245144) http://git.savannah.gnu.org/cgit/parted.git/commit/?id=44d5ae0115c4ecfe3158748309e9912c5aede92d [7] parted libparted/arch/linux.v v3.6 http://git.savannah.gnu.org/cgit/parted.git/tree/libparted/arch/linux.c?h=v3.6#n1660 1660 static void 1661 _flush_cache (PedDevice* dev) ... 1673 for (i = 1; i < lpn; i++) { ... 1680 if (!_partition_is_mounted_by_path(name)) { 1681 fd = open (name, WR_MODE, 0); Closes #259 - Trying to deactivate LVM PV fails
2024-08-25 13:19:09 -06:00
#ifdef ENABLE_EXPLICIT_FLUSH_WORKAROUND
Make GParted_Core methods flush_device(), get_device(), etc static GParted_Core methods: flush_device() get_device() get_disk() get_device_and_disk() destroy_device_and_disk() commit() commit_to_os() settle_device() This group of methods only call libparted API functions and run external executables. None of them access any GParted_Core member variables. Make them all static member functions.
2015-04-25 06:37:59 -06:00
static bool flush_device( PedDevice * lp_device );
Only explicitly flush devices when using libparted < 3.2 (#259) During device probing GParted always explicitly calls ped_device_sync() to flush the caches for coherency between the whole disk device and the partition devices [1]. As the GParted_Core::flush_device() comment explains, since v3.1.61-gfb99ba5 [2], libparted flushes the devices every time a device is opened [3], so also explicitly doing this in GParted is unnecessary. Therefore stop explicitly flushing the devices in GParted, except when using libparted 3.1 and older which doesn't do it itself. The ped_device_open() and ped_device_close() needed for the ped_device_sync() is also a trigger of device changes and udev rule execution performing LVM Volume Group activation, because libparted opens the device read-write [4]. This is another reason to remove it when possible. However even when eliminated it does not solve the issue of LVM VG activation because other triggers remain. Do want this change first though so that the sequence of libparted calls isn't changed immediately after documenting them and fixing the issue and so that there is no doubt that this change doesn't fix the issue. Removing this extra device flush saves a little bit of time, depending on the speed of the drive and number of partitions. Sample savings on my desktop: Drive type and partitions Saving (seconds) ----------------------------- ---------------- fast SSD with 3 partitions 0.05 slow SSD with 12 partitions 0.27 HDD with 1 partition 0.05 VHDD in VM with 1 partition 0.14 VHDD in VM with 10 partitions 0.58 Also the settle_device() call in flush_device() needs to be kept to wait for device changes and udev rule execution whether it is GParted explicitly flushing the device or just libparted automatically doing it for cache coherency in ped_device_get(). This is because: 1. Libparted <= 3.2 opens the whole disk device read-write for ped_device_get() [5]. (This was changed with parted v3.2.26-g44d5ae0 [6] to open the whole disk device read-only). 2. Libparted up to and including the latest 3.6 release still opens all partition devices read-write for ped_device_get() [7]. 3. A whole disk device FAT32 file system looks enough like a partition table that both the Linux kernel and libparted think it is partitioned: # mkfs.fat -F32 /dev/sdb mkfs.fat 4.2 (2021-01-31) # grep sdb /proc/partitions 8 16 8388608 sdb 8 17 8388607 sdb1 # parted /dev/sdb print Model: ATA VBOX HARDDISK (scsi) Disk /dev/sdb: 8590MB Sector size (logical/physical): 512B/512B Partition Table: loop Disk Flags: Number Start End Size File system Flags 1 0s 16777215s 16777216s fat32 So the ped_device_get() call on a whole disk device FAT32 file system still triggers device change and udev rule execution which needs to be waited for, as this is exactly the case fixed previously by commit: 1382e0b828f630a705cecd97c346dfc6267909bf Wait for udev change on /dev/DISK when querying whole device FS (!46) [1] 3bea067596e3e2d6513cda2a66df1b3e4fa432fb Flush devices when scanning to prevent reading stale signatures (#723842) [2] Revert "linux-commit: do not unnecessarily open partition device nodes" http://git.savannah.gnu.org/cgit/parted.git/commit/?id=fb99ba5ebd0dc34204fc9f1014131d5d494805bc [3] parted libparted/arch/linux.c:_device_open() https://git.savannah.gnu.org/cgit/parted.git/tree/libparted/arch/linux.c?h=v3.6#n1752 1709 static int 1710 linux_open (PedDevice* dev) 1711 { 1712 return _device_open (dev, RW_MODE); 1713 } 1714 1715 static int 1716 _device_open (PedDevice* dev, int flags) ... 1752 _flush_cache (dev); [4] parted libparted/device.c:ped_device_open() v3.6 https://git.savannah.gnu.org/cgit/parted.git/tree/libparted/device.c?h=v3.6#n226 parted libparted/arch/linux.c v3.6 https://git.savannah.gnu.org/cgit/parted.git/tree/libparted/arch/linux.c?h=v3.6 ped_device_open(...) ped_architecture->dev_ops->open(...) = linux_open(...) _device_open(..., RW_MODE) open(..., O_RDWR) [5] parted libparted/device.c:ped_device_get() v3.2 https://git.savannah.gnu.org/cgit/parted.git/tree/libparted/device.c?h=v3.2#n149 parted libparted/arch/linux.c v3.2 https://git.savannah.gnu.org/cgit/parted.git/tree/libparted/arch/linux.c?h=v3.2 ped_device_get(...) ped_architecture->dev_ops->_new(...) = linux_new() init_ide(...) init_scsi(...) init_generic(...) ped_device_open(...) ped_architecture->dev_ops->open(...) = linux_open(...) open(..., O_RDWR) [6] libparted: Use read only when probing devices on linux (#1245144) http://git.savannah.gnu.org/cgit/parted.git/commit/?id=44d5ae0115c4ecfe3158748309e9912c5aede92d [7] parted libparted/arch/linux.v v3.6 http://git.savannah.gnu.org/cgit/parted.git/tree/libparted/arch/linux.c?h=v3.6#n1660 1660 static void 1661 _flush_cache (PedDevice* dev) ... 1673 for (i = 1; i < lpn; i++) { ... 1680 if (!_partition_is_mounted_by_path(name)) { 1681 fd = open (name, WR_MODE, 0); Closes #259 - Trying to deactivate LVM PV fails
2024-08-25 13:19:09 -06:00
#endif
Make GParted_Core methods flush_device(), get_device(), etc static GParted_Core methods: flush_device() get_device() get_disk() get_device_and_disk() destroy_device_and_disk() commit() commit_to_os() settle_device() This group of methods only call libparted API functions and run external executables. None of them access any GParted_Core member variables. Make them all static member functions.
2015-04-25 06:37:59 -06:00
static bool get_device( const Glib::ustring & device_path, PedDevice *& lp_device, bool flush = false );
Remove coding landmine in get_disk() (#152) get_disk() is the wrapper around libparted's ped_disk_new() which reads a disk label from the specified device and if successful creates the in memory PedDisk object to represent it. In the case that libparted doesn't recognise a disk label or a file system, having get_disk() go and destroy the passed in PedDevice object via parameter lp_device is very unexpected behaviour hence describing it as a coding landmine. BACKGROUND 1. Early on GParted only worked with devices with valid disk labels. FileSystem.h:open_device_and_disk() required both ped_device_get() and ped_disk_new() to succeed or neither to succeed. 2. Commit [1] added support for devices which didn't yet have a disk label. open_device_and_disk() had default parameter strict=true added. While scanning strict=false was passed which allowed open_device_and_disk() to return success if only ped_device_get() succeeded and ped_disk_new() failed when the disk was empty. All other times open_device_and_disk() was called with default strict=true, still requiring both or neither to succeed. 3. Commit [2] added support for whole disk file systems. The now named get_device_and_disk() had it's functionality split between get_device() and get_disk(). This result in the code landmine being left behind: get_disk() destroying the passed device object if default parameter strict=true and no disk label or file system was detected. ANALYSIS 1. Since support for whole disk file systems [2] all current calls to get_device_and_disk() let the strict parameter default to true and are only called on known partitions within disk labels when applying a change to that partition. Therefore they don't care about the behaviour of get_disk(), just that get_device_and_disk() maintains that both ped_device_get() and ped_disk_new() succeed or neither succeed. 2. Two direct calls to get_disk() where the strict parameter defaults to true, from calibrate_partition() and erase_filesystem_signatures(), only do so on known partitions within disk labels as part of applying a change to that partition. Therefore ped_disk_new() will succeed and so PedDevice isn't deleted when not wanted. 3. The two remaining direct calls to get_disk() where the strict parameter is explicitly set to false, from set_device_from_disk() and detect_filesystem_in_encryption_mapping(), are when scanning. As the pass strict=false they don't allow the PedDevice deletion to occur if no recognised disk label is found. FIX Remove the strict parameter from get_disk() and get_device_and_disk() as it's no longer needed. Remove the code landmine by removing the side affect of destroying the PedDevice object if a disk label isn't found. Make sure get_device_and_disk() maintains the all or nothing behaviour. Also don't pass lp_device by reference to a pointer to get_disk() so the code can't change where lp_device points. [1] 038c5c5d99ad842f1a57f12222c884be29f4df4f P (special thanks to mantiena-baltix for bringing this issue to my [2] 51ac4d56489653854cd22787238a14bfa66a6ad4 Split get_device_and_disk() into two (#743181) Closes #152 - GParted crashed when trying to probe an encrypted partition containing content that libparted doesn't recognise
2021-04-10 09:39:22 -06:00
static bool get_disk(PedDevice *lp_device, PedDisk*& lp_disk);
static bool get_device_and_disk(const Glib::ustring& device_path,
PedDevice*& lp_device, PedDisk*& lp_disk, bool flush = false);
Make GParted_Core methods flush_device(), get_device(), etc static GParted_Core methods: flush_device() get_device() get_disk() get_device_and_disk() destroy_device_and_disk() commit() commit_to_os() settle_device() This group of methods only call libparted API functions and run external executables. None of them access any GParted_Core member variables. Make them all static member functions.
2015-04-25 06:37:59 -06:00
static void destroy_device_and_disk( PedDevice*& lp_device, PedDisk*& lp_disk );
static bool commit( PedDisk* lp_disk );
static bool commit_to_os( PedDisk* lp_disk, std::time_t timeout );
static void settle_device( std::time_t timeout );
Pass unmodified parameter to useable_device() as const (!46) GParted_Core::useable_device() doesn't change the pointed to PedDevice structure. Pass it as const so the compiler enforces this. Closes !46 - Whole device FAT32 file system reports device busy warning from mlabel
2019-07-10 04:00:32 -06:00
static bool useable_device(const PedDevice* lp_device);
Extract common code into new method get_lp_partition()
2017-09-26 01:06:29 -06:00
static PedPartition* get_lp_partition( const PedDisk* lp_disk, const Partition & partition );
hmmz, lots of shimmery internals.. Instead of using a boolean to indicate * hmmz, lots of shimmery internals.. Instead of using a boolean to indicate support for certain features i now use and enum (NONE, LIBPARTED, EXTENDED). This allowed me to clean up some stuff that annoyed me ;) Still.. the core could use a bit more love...
2005-11-26 17:57:11 -07:00
catch libparted exceptions and display them in the operationdetails if an * include/GParted_Core.h, src/GParted_Core.cc: catch libparted exceptions and display them in the operationdetails if an operation has failed. * src/Dialog_Progress.cc: small cosmetic change to the errordialog.
2006-02-25 09:30:43 -07:00
static PedExceptionOption ped_exception_handler( PedException * e ) ;
support partitions with multiple mountpoints (see also #330327) * include/GParted_Core.h, include/Partition.h, src/Dialog_Partition_Info.cc, src/GParted_Core.cc, src/Partition.cc, src/TreeView_Detail.cc, src/Win_GParted.cc: support partitions with multiple mountpoints (see also #330327)
2006-02-15 15:32:54 -07:00
std::vector<PedPartitionFlag> flags;
added support for commandline arguments (#329414) * include/GParted_Core.h, include/Win_GParted.h, src/GParted_Core.cc, src/Win_GParted.cc, src/main.cc: added support for commandline arguments (#329414)
2006-02-02 06:50:37 -07:00
std::vector<Glib::ustring> device_paths ;
bool probe_devices ;
Added set and get thread status message methods. Added thread status message updates in set_devices(). svn path=/trunk/; revision=943
2008-10-30 12:50:38 -06:00
Glib::ustring thread_status_message; //Used to pass data to show_pulsebar method
Split FILESYSTEMS and FILESYSTEM_MAP into separate module (!49) GParted_Core::FILESYSTEMS and ::FILESYSTEM_MAP and the methods that query and manipulate them are self-contained. Therefore move them into a separate SupportedFileSystems module. Also having a single class maintaining all FileSystem interface objects will make testing all the file system types much easier as there will be no need to duplicate this functionality in the test. Closes !49 - Add file system interface tests
2019-07-16 06:01:07 -06:00
static SupportedFileSystems* supported_filesystems;
P) It still needs a lot of love, but the foundations are laid =) * Rewrote a large part of gparteds internal code. Filesystemssupport is now much more separated from the rest of gparted and adding support for other filesystems should be a piece of cake now (hope that's true :P) It still needs a lot of love, but the foundations are laid =)
2004-11-17 06:00:25 -07:00
};
} //GParted
Make include guards unique (#539297) Include guards need to be unique within GParted code and all included library header files. http://en.wikipedia.org/wiki/Include_guard#Difficulties Use this model for all include guards: #ifndef GPARTED_FILE_NAME_H #define GPARTED_FILE_NAME_H ... #endif /* GPARTED_FILE_NAME_H */ Closes Bug #539297 - Make include guards unique
2013-05-27 05:20:16 -06:00
#endif /* GPARTED_GPARTED_CORE_H */