/*
    libparted - a library for manipulating disk partitions
    Copyright (C) 1999-2001, 2005, 2007, 2009-2014, 2019-2023 Free Software
    Foundation, Inc.

    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 3 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
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <config.h>

#include <parted/parted.h>
#include <parted/debug.h>

#include <errno.h>
#include <hurd.h>
#include <hurd/fs.h>
#include <hurd/store.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#if ENABLE_NLS
#  include <libintl.h>
#  define _(String) dgettext (PACKAGE, String)
#else
#  define _(String) (String)
#endif /* ENABLE_NLS */

#include "../architecture.h"

#define GNU_SPECIFIC(dev)	((GNUSpecific*) (dev)->arch_specific)

typedef	struct _GNUSpecific	GNUSpecific;

struct _GNUSpecific {
	struct store*	store;
	int consume;
};

/* Initialize a PedDevice using SOURCE.  The SOURCE will NOT be destroyed;
   the caller created it, it is the caller's responsilbility to free it
   after it calls ped_device_destory.  SOURCE is not registered in Parted's
   list of devices.  */
PedDevice* ped_device_new_from_store (struct store *source);

static int
_device_get_sector_size (PedDevice* dev)
{
	GNUSpecific*	arch_specific = GNU_SPECIFIC (dev);
	size_t		store_block_size = arch_specific->store->block_size;

	return PED_SECTOR_SIZE_DEFAULT;
}

static PedSector
_device_get_length (PedDevice* dev)
{
	GNUSpecific*	arch_specific = GNU_SPECIFIC (dev);
	size_t		store_blocks = arch_specific->store->blocks;
	size_t		store_block_size = arch_specific->store->block_size;

	return ((long long) store_blocks * store_block_size) / PED_SECTOR_SIZE_DEFAULT;
}

static int
_device_probe_geometry (PedDevice* dev)
{
	PedSector cyl_size;

	dev->length = _device_get_length (dev);
	if (!dev->length)
		return 0;

	dev->sector_size = _device_get_sector_size (dev);
	if (!dev->sector_size)
		return 0;

	/* XXX: We have no way to get this!  */
	dev->bios_geom.sectors = 63;
	dev->bios_geom.heads = 255;
	cyl_size = dev->bios_geom.sectors * dev->bios_geom.heads;
	dev->bios_geom.cylinders = dev->length / cyl_size
					* (dev->sector_size / PED_SECTOR_SIZE_DEFAULT);
	dev->hw_geom = dev->bios_geom;

	return 1;
}

static int
init_file (PedDevice* dev)
{
	PedExceptionOption	ex_status;

retry_open:
	if (!ped_device_open (dev)) {
		ex_status = ped_exception_throw (
				PED_EXCEPTION_WARNING,
				PED_EXCEPTION_RETRY_CANCEL,
				_("Unable to open %s."),
				dev->path);
		switch (ex_status) {
			case PED_EXCEPTION_RETRY:
				goto retry_open;

			case PED_EXCEPTION_UNHANDLED:
				ped_exception_catch ();
			case PED_EXCEPTION_CANCEL:
				goto error;
		}

		return 0;
	}

retry_probe:
	if (!_device_probe_geometry (dev)) {
		ex_status = ped_exception_throw (
				PED_EXCEPTION_WARNING,
				PED_EXCEPTION_RETRY_CANCEL,
				_("Unable to probe store."));
		switch (ex_status) {
			case PED_EXCEPTION_RETRY:
				goto retry_probe;

			case PED_EXCEPTION_UNHANDLED:
				ped_exception_catch ();
			case PED_EXCEPTION_CANCEL:
				goto error_close_dev;
		}

		return 0;
	}

	dev->model = "";

	ped_device_close (dev);
	return 1;

error_close_dev:
	ped_device_close (dev);
error:
	return 0;
}

static void
_flush_cache (PedDevice* dev)
{
	GNUSpecific*	arch_specific = GNU_SPECIFIC (dev);

	if (dev->read_only)
		return;

	/* Wait for a complete sync to finish.  */
	file_sync (arch_specific->store->source, 1, 0);
}

/* Initialize by allocating memory and filling in a few defaults, a
   PedDevice structure.  */
static PedDevice*
_init_device (const char *path)
{
	PedDevice *dev;
	GNUSpecific*	arch_specific;

	dev = (PedDevice*) ped_malloc (sizeof (PedDevice));
	if (!dev)
		goto error;

	dev->path = strdup (path);
	if (!dev->path)
		goto error_free_dev;

	dev->arch_specific
		= (GNUSpecific*) ped_malloc (sizeof (GNUSpecific));
	if (!dev->arch_specific)
		goto error_free_path;

	dev->type = PED_DEVICE_UNKNOWN;	/* It's deprecated anyway */
	dev->open_count = 0;
	dev->read_only = 0;
	dev->external_mode = 0;
	dev->dirty = 0;
	dev->boot_dirty = 0;

	return dev;

error_free_arch_specific:
	free (dev->arch_specific);
error_free_path:
	free (dev->path);
error_free_dev:
	free (dev);
error:
	return NULL;
}

/* Ask the kernel and translators to reload the partition table.
   XXX: Will probably be replaced by some RPC to partfs when it's finished.  In
   the meantime, gnumach's glue layer will pass BLKRRPART to the Linux drivers.
   */
#define BLKRRPART 0x125F
static int
_reread_part_table (PedDevice* dev)
{
	struct store *store = GNU_SPECIFIC (dev)->store;
	int retry_count = 9;
	int len = strlen (dev->path);
	char path[len + 3 + 1];
	int i;
	int done = 1;

	sync ();

	if(strcmp (store->class->name, "device") == 0) {
		while (device_set_status (store->port, BLKRRPART, NULL, 0)) {
			retry_count--;
			sync ();
			if (retry_count == 3)
				sleep (1); /* Pause to allow system to settle */

			if (!retry_count) {
				ped_exception_throw (
					PED_EXCEPTION_WARNING,
					PED_EXCEPTION_IGNORE,
				_("WARNING: the kernel failed to re-read the "
				  "partition table on %s (%s).  As a result, "
				  "it may not reflect all of your changes "
				  "until after reboot."),
					dev->path, strerror (errno));
				return 0;
			}
		}
	}

	i = 1;
	while (1) {
		file_t node;
		error_t err;

		/* Throw away all active parted-based translators */
		snprintf (path, sizeof (path), "%ss%u", dev->path, i);
		node = file_name_lookup (path, O_NOTRANS, 0666);
		if (node == MACH_PORT_NULL) {
			if (errno == ENOENT)
				/* Finished looping over them */
				break;

			ped_exception_throw (
				PED_EXCEPTION_WARNING,
				PED_EXCEPTION_IGNORE,
				_("Warning: unable to open %s (%s). As a "
				  "result, it may not reflect all of your "
				  "changes until after reboot."),
					path, strerror (errno));
			done = 0;
		}

		err = file_set_translator (node, 0, FS_TRANS_SET,
			0, 0, 0, MACH_PORT_NULL, MACH_MSG_TYPE_COPY_SEND);
		if (err) {
			ped_exception_throw (
				PED_EXCEPTION_WARNING,
				PED_EXCEPTION_IGNORE,
				_("Warning: failed to make translator go away "
				  "on %s (%s). As a result, it may not reflect "
				  "all of your changes until after reboot."),
					dev->path, strerror (errno));
			done = 0;
		}
		i++;
	}

	return done;
}

/* Free the memory associated with a PedDevice structure.  */
static void
_done_device (PedDevice *dev)
{
        free (dev->arch_specific);
	free (dev->path);
	free (dev);
}

/* Release all resources that libparted owns in DEV.  */
static void
gnu_destroy (PedDevice* dev)
{
	GNUSpecific*	arch_specific = GNU_SPECIFIC (dev);

	if (arch_specific->consume)
	        store_free (arch_specific->store);

	_done_device (dev);
}

static PedDevice*
gnu_new (const char* path)
{
	PedDevice*	dev;
	GNUSpecific*	arch_specific;
	error_t         ro_err, rw_err;
	int             ispath;

	PED_ASSERT (path != NULL);

	dev = _init_device (path);
	if (!dev)
	        return NULL;

	arch_specific = GNU_SPECIFIC (dev);
	arch_specific->consume = 1;

 retry_open:
	/* Try read-write. */
	if (strchr (dev->path, '/') != NULL) {
	        /* We set this to prevent having to use strchr more then once. */
	        ispath = 1;

	        rw_err = store_open (dev->path, 0, NULL, &arch_specific->store);
	} else {
	        rw_err = store_typed_open (dev->path, 0, NULL, &arch_specific->store);
	}

	/* Try readonly. */
	if (rw_err) {
	  if (ispath) {
	        ro_err = store_open (dev->path, STORE_READONLY, NULL,
				 &arch_specific->store);
	  } else {
	        ro_err = store_typed_open (dev->path, STORE_READONLY, NULL,
				       &arch_specific->store);
	  }

	if (ro_err) {
	        if (ped_exception_throw (
			        PED_EXCEPTION_ERROR,
				PED_EXCEPTION_RETRY_CANCEL,
				_("Error opening %s: %s"),
				dev->path, strerror (ro_err))
					!= PED_EXCEPTION_RETRY) {
				return NULL;
			} else
				goto retry_open;
		} else {
			ped_exception_throw (
				PED_EXCEPTION_WARNING,
				PED_EXCEPTION_OK,
				_("Unable to open %s read-write (%s).  %s has "
				  "been opened read-only."),
				dev->path, strerror (rw_err), dev->path);
			dev->read_only = 1;
		}
	} else {
		dev->read_only = 0;
	}

	_flush_cache (dev);

	if (!init_file (dev)) {
		gnu_destroy(dev);
		return NULL;
	}

	return dev;
}

PedDevice*
ped_device_new_from_store (struct store *source)
{
        PedDevice*      dev;
	GNUSpecific*    arch_specific;

	PED_ASSERT (source != NULL);

	dev = _init_device (source->name ?: "(unknown)");
	if (!dev)
	        return NULL;

	arch_specific = GNU_SPECIFIC (dev);
	arch_specific->store = source;
	arch_specific->consume = 0;

	dev->read_only = source->flags & (STORE_READONLY|STORE_HARD_READONLY);

	if (!init_file (dev)) {
	        _done_device (dev);
		return NULL;
	}

	return dev;
}

static int
gnu_is_busy (PedDevice* dev)
{
	return 0;
}

static int
gnu_open (PedDevice* dev)
{
        return 1;
}

static int
gnu_refresh_open (PedDevice* dev)
{
	return 1;
}

static int
gnu_close (PedDevice* dev)
{
	GNUSpecific*	arch_specific = GNU_SPECIFIC (dev);

	_flush_cache (dev);

	if (dev->dirty && dev->type != PED_DEVICE_FILE) {
		if (_reread_part_table (dev))
			dev->dirty = 0;
	}

	return 1;
}

static int
gnu_refresh_close (PedDevice* dev)
{
	_flush_cache (dev);
	return 1;
}

static int
gnu_read (const PedDevice* dev, void* user_buffer, PedSector device_start,
          PedSector count)
{
	GNUSpecific*		arch_specific = GNU_SPECIFIC (dev);
	error_t			err;
	PedExceptionOption	ex_status;
	size_t			start;
	size_t			store_start_block;
	/* In bytes.  This can be larger than COUNT when store pages are
	   larger than PED_SECTOR_SIZE_DEFAULT.  */
	size_t			store_read_length;
	char			local_buffer[PED_SECTOR_SIZE_DEFAULT];
	void *			store_read_buffer;
	size_t			have_read;
	size_t			read_offset;
	size_t			device_read_length = count * PED_SECTOR_SIZE_DEFAULT;

	start = device_start * PED_SECTOR_SIZE_DEFAULT;
	if (PED_SECTOR_SIZE_DEFAULT != arch_specific->store->block_size) {
		store_start_block = start / arch_specific->store->block_size;
		store_read_length = (device_read_length
				     + arch_specific->store->block_size - 1)
				    / arch_specific->store->block_size;
	} else {
		store_start_block = device_start;
		store_read_length = device_read_length;
	}

	read_offset = start
		      - store_start_block * arch_specific->store->block_size;

	if (store_read_length % arch_specific->store->block_size != 0)
		store_read_length = store_read_length
				    + arch_specific->store->block_size
				    - store_read_length % arch_specific->store->block_size;

retry:
	have_read = 0;
	while (1) {
		size_t	did_read;
		size_t	offset;

		store_read_buffer = local_buffer;
		did_read = sizeof (local_buffer);

		err = store_read (arch_specific->store, store_start_block,
				  store_read_length - have_read,
			  	  &store_read_buffer, &did_read);
		if (err) {
			ex_status = ped_exception_throw (
				PED_EXCEPTION_ERROR,
				PED_EXCEPTION_RETRY_IGNORE_CANCEL,
				_("%s during read on %s"),
				strerror (err),
				dev->path);

			switch (ex_status) {
				case PED_EXCEPTION_IGNORE:
					return 1;

				case PED_EXCEPTION_RETRY:
					goto retry;

				case PED_EXCEPTION_UNHANDLED:
					ped_exception_catch ();
				case PED_EXCEPTION_CANCEL:
					return 0;
			}
		}

		memcpy (user_buffer + have_read - read_offset,
			store_read_buffer
			+ (have_read >= read_offset
				? 0 : read_offset - have_read),
			have_read + did_read > device_read_length + read_offset
				? device_read_length + read_offset - have_read
				: did_read);

		if (store_read_buffer != local_buffer)
			vm_deallocate (mach_task_self (),
				       (long) store_read_buffer, did_read);

		have_read += did_read;
		store_start_block += did_read
		       			/ arch_specific->store->block_size;

		if (have_read >= device_read_length)
			break;
	}

	return 1;
}

static int
gnu_write (PedDevice* dev, const void* buffer, PedSector start, PedSector count)
{
	GNUSpecific*		arch_specific = GNU_SPECIFIC (dev);
	error_t			err;
	PedExceptionOption	ex_status;
	void *			temp;
	char			local_buffer[PED_SECTOR_SIZE_DEFAULT];
	size_t			did_read;
	size_t			did_write;

	/* Map a disk sector to a store sector.  */
	#define PED_TO_STORE(store, sector) (((sector) * PED_SECTOR_SIZE_DEFAULT) \
				      	/ (store)->block_size)

	if (dev->read_only) {
		if (ped_exception_throw (
			PED_EXCEPTION_ERROR,
			PED_EXCEPTION_IGNORE_CANCEL,
			_("Can't write to %s, because it is opened read-only."),
			dev->path)
				!= PED_EXCEPTION_IGNORE)
			return 0;
		else
			return 1;
	}

#ifdef READ_ONLY
	printf ("ped_device_write (\"%s\", %p, %d, %d)\n",
		dev->path, buffer, (int) start, (int) count);
#else
	dev->dirty = 1;

	/* If the first ``device'' block (PedSector) is not aligned on a
	   store block, then we need to fetch the old block, copy in the
	   overlaping area and finally, write the modified data out to the
	   store.  */
	if ((PED_SECTOR_SIZE_DEFAULT * start) % arch_specific->store->block_size
	    != 0) {
		size_t 		write_offset;
		size_t 		flushing;

doggy_first_block_read:
		/* We do not bother looping as we are only reading a
		   single block.  */
		temp = local_buffer;
		did_read = sizeof (local_buffer);
		err = store_read (arch_specific->store,
				  PED_TO_STORE (arch_specific->store, start),
				  arch_specific->store->block_size, &temp,
				  &did_read);
		if (! err && did_read != arch_specific->store->block_size)
			err = EIO;

		if (err) {
			ex_status = ped_exception_throw (
				PED_EXCEPTION_ERROR,
				PED_EXCEPTION_RETRY_IGNORE_CANCEL,
				_("%s during read on %s"),
				strerror (err), dev->path);

			switch (ex_status) {
				case PED_EXCEPTION_IGNORE:
					break;

				case PED_EXCEPTION_RETRY:
					goto doggy_first_block_read;

				case PED_EXCEPTION_UNHANDLED:
					ped_exception_catch ();
				case PED_EXCEPTION_CANCEL:
					return 0;
			}
		}

		write_offset = (start * PED_SECTOR_SIZE_DEFAULT)
			       % arch_specific->store->block_size;
		flushing = arch_specific->store->block_size - write_offset;
		if (flushing > count * PED_SECTOR_SIZE_DEFAULT)
			flushing = count * PED_SECTOR_SIZE_DEFAULT;

		memcpy (temp + write_offset, buffer, flushing);

doggy_first_block_write:
		err = store_write (arch_specific->store,
		    		   PED_TO_STORE (arch_specific->store, start),
				   temp, arch_specific->store->block_size,
				   &did_write);
		if (! err && did_write != arch_specific->store->block_size)
			err = EIO;

		if (err) {
			ex_status = ped_exception_throw (
				PED_EXCEPTION_ERROR,
				PED_EXCEPTION_RETRY_IGNORE_CANCEL,
				_("%s during write on %s"),
				strerror (err), dev->path);

			switch (ex_status) {
				case PED_EXCEPTION_IGNORE:
					break;

				case PED_EXCEPTION_RETRY:
					goto doggy_first_block_write;

				case PED_EXCEPTION_UNHANDLED:
					ped_exception_catch ();
				case PED_EXCEPTION_CANCEL:
					if (temp != local_buffer)
						vm_deallocate (
							mach_task_self (),
							(long) temp,
							did_read);
					return 0;
			}
		}

		start += flushing / PED_SECTOR_SIZE_DEFAULT;
		count -= flushing / PED_SECTOR_SIZE_DEFAULT;
		buffer += write_offset;

		if (temp != local_buffer)
			vm_deallocate (mach_task_self (), (long) temp,
				       did_read);

		if (count == 0)
			return 1;
	}

	while (count > 0
	   && count >= arch_specific->store->block_size / PED_SECTOR_SIZE_DEFAULT) {
		err = store_write (arch_specific->store,
				   PED_TO_STORE (arch_specific->store, start),
				   buffer, count * PED_SECTOR_SIZE_DEFAULT,
				   &did_write);

		if (err) {
			ex_status = ped_exception_throw (
				PED_EXCEPTION_ERROR,
				PED_EXCEPTION_RETRY_IGNORE_CANCEL,
				_("%s during write on %s"),
				strerror (err), dev->path);

			switch (ex_status) {
				case PED_EXCEPTION_IGNORE:
					break;

				case PED_EXCEPTION_RETRY:
					continue;

				case PED_EXCEPTION_UNHANDLED:
					ped_exception_catch ();
				case PED_EXCEPTION_CANCEL:
					return 0;
			}
		}

		start += did_write / PED_SECTOR_SIZE_DEFAULT;
		count -= did_write / PED_SECTOR_SIZE_DEFAULT;
		buffer += did_write;
	}

	if (count == 0)
		return 1;

	/* We are now left with (strictly) less then a store block to write
	   to disk.  Thus, we read the block, overlay the buffer and flush.  */
	PED_ASSERT (count * PED_SECTOR_SIZE_DEFAULT
		    < arch_specific->store->block_size);

doggy_last_block_read:
	/* We do not bother looping as we are only reading a
	   single block.  */
	temp = local_buffer;
	did_read = sizeof (local_buffer);
	err = store_read (arch_specific->store,
			  PED_TO_STORE (arch_specific->store, start),
			  arch_specific->store->block_size, &temp,
			  &did_read);
	if (! err && did_read != arch_specific->store->block_size)
		err = EIO;

	if (err) {
		ex_status = ped_exception_throw (
			PED_EXCEPTION_ERROR,
			PED_EXCEPTION_RETRY_IGNORE_CANCEL,
			_("%s during read on %s"),
			strerror (err), dev->path);

		switch (ex_status) {
			case PED_EXCEPTION_IGNORE:
				break;

			case PED_EXCEPTION_RETRY:
				goto doggy_last_block_read;

			case PED_EXCEPTION_UNHANDLED:
				ped_exception_catch ();
			case PED_EXCEPTION_CANCEL:
				return 0;
		}
	}

	memcpy (temp, buffer, count * PED_SECTOR_SIZE_DEFAULT);

doggy_last_block_write:
	err = store_write (arch_specific->store,
	    		   PED_TO_STORE (arch_specific->store, start),
			   temp, arch_specific->store->block_size,
			   &did_write);
	if (! err && did_write != arch_specific->store->block_size)
		err = EIO;

	if (err) {
		ex_status = ped_exception_throw (
			PED_EXCEPTION_ERROR,
			PED_EXCEPTION_RETRY_IGNORE_CANCEL,
			_("%s during write on %s"),
			strerror (err), dev->path);

		switch (ex_status) {
			case PED_EXCEPTION_IGNORE:
				break;

			case PED_EXCEPTION_RETRY:
				goto doggy_last_block_write;

			case PED_EXCEPTION_UNHANDLED:
				ped_exception_catch ();
			case PED_EXCEPTION_CANCEL:
				if (temp != local_buffer)
					vm_deallocate (mach_task_self (),
					       	       (long) temp,
					       	       did_read);
				return 0;
		}
	}

#endif /* !READ_ONLY */
	return 1;
}

/* TODO: returns the number of sectors that are ok.
 */
static PedSector
gnu_check (PedDevice* dev, void* buffer, PedSector start, PedSector count)
{
	int			status;
	int			done = 0;

	PED_ASSERT (dev != NULL);
	PED_ASSERT (!dev->external_mode);
	PED_ASSERT (buffer != NULL);

	return count;
}

static int
gnu_sync (PedDevice* dev)
{
	GNUSpecific*		arch_specific;
	error_t			err;
	PedExceptionOption	ex_status;
	static char *last_failure = NULL;

	PED_ASSERT (dev != NULL);
	PED_ASSERT (!dev->external_mode);

	arch_specific = GNU_SPECIFIC (dev);

	if (dev->read_only || ! dev->dirty)
		return 1;

	while (1) {
		err = file_sync (arch_specific->store->source, 1, 0);
		if (! err || err == EOPNOTSUPP || err == EPERM
		    || (last_failure && strcmp (last_failure, dev->path) == 0))
		  break;

		ex_status = ped_exception_throw (
			PED_EXCEPTION_ERROR,
			PED_EXCEPTION_RETRY_IGNORE_CANCEL,
			_("%s trying to sync %s to disk"),
			strerror (errno), dev->path);

		switch (ex_status) {
			case PED_EXCEPTION_IGNORE:
				free (last_failure);
				last_failure = strdup (dev->path);
				return 1;

			case PED_EXCEPTION_RETRY:
				break;

			case PED_EXCEPTION_UNHANDLED:
				ped_exception_catch ();
			case PED_EXCEPTION_CANCEL:
				return 0;
		}
	}

	return 1;
}

static int
probe_standard_devices ()
{
	_ped_device_probe ("/dev/sd0");
	_ped_device_probe ("/dev/sd1");
	_ped_device_probe ("/dev/sd2");
	_ped_device_probe ("/dev/sd3");
	_ped_device_probe ("/dev/sd4");
	_ped_device_probe ("/dev/sd5");

	_ped_device_probe ("/dev/hd0");
	_ped_device_probe ("/dev/hd1");
	_ped_device_probe ("/dev/hd2");
	_ped_device_probe ("/dev/hd3");
	_ped_device_probe ("/dev/hd4");
	_ped_device_probe ("/dev/hd5");
	_ped_device_probe ("/dev/hd6");
	_ped_device_probe ("/dev/hd7");

	_ped_device_probe ("/dev/wd0");
	_ped_device_probe ("/dev/wd1");
	_ped_device_probe ("/dev/wd2");
	_ped_device_probe ("/dev/wd3");
	_ped_device_probe ("/dev/wd4");
	_ped_device_probe ("/dev/wd5");
	_ped_device_probe ("/dev/wd6");
	_ped_device_probe ("/dev/wd7");

	return 1;
}

static void
gnu_probe_all ()
{
	probe_standard_devices ();
}

static char*
gnu_partition_get_path (const PedPartition* part)
{
	const char*	dev_path = part->disk->dev->path;
	int		result_len = strlen (dev_path) + 16;
	char*		result;

	result = (char*) ped_malloc (result_len);
	if (!result)
		return NULL;
	snprintf (result, result_len, "%ss%d", dev_path, part->num);
	return result;
}

static int
gnu_partition_is_busy (const PedPartition* part)
{
	return 0;
}

static int
gnu_disk_commit (PedDisk* disk)
{
	return _reread_part_table (disk->dev);
}

static PedDeviceArchOps gnu_dev_ops = {
	_new:		gnu_new,
	destroy:	gnu_destroy,
	is_busy:	gnu_is_busy,
	open:		gnu_open,
	refresh_open:	gnu_refresh_open,
	close:		gnu_close,
	refresh_close:	gnu_refresh_close,
	read:		gnu_read,
	write:		gnu_write,
	check:		gnu_check,
	sync:		gnu_sync,
	sync_fast:	gnu_sync,
	probe_all:	gnu_probe_all
};

static PedDiskArchOps gnu_disk_ops = {
	partition_get_path:	gnu_partition_get_path,
	partition_is_busy:	gnu_partition_is_busy,
	disk_commit:		gnu_disk_commit
};

PedArchitecture ped_gnu_arch = {
	dev_ops:	&gnu_dev_ops,
	disk_ops:	&gnu_disk_ops
};