* what is disk management?
	- what is a "disk configuration"?  A: a layering of consumers
	and producers
	- initial set up
	- addition of new hardware / reconfiguration
	- online reconfiguration:
		* communication with OS (kernel) - different for Mach/Hurd?
		* shallow vs deep reconfiguration

* consumers and producers
	- producers are consumers (except for physical / netblock devices,
	perhaps)
	- LVM, partitions tables, raid, encryption, bbr: producers (and
	therefore consumers)
	- loopback, network block-devices, physical devices: physical
	devices
	- file systems, swap space, raw databases: consumers
	- partitions, logical volumes, etc.: are devices that are produced
	by producers
	- all devices can be consumed
	- contrast to EVMS

* issues around consumers & producers
	- OS communication: each file system is different, different LVM
	implementations are different, and LVM is different from partitions.
	However, most partition table formats have the same semantics,
	AFAIK the OS is concerned.  Therefore, needs to be an OS-specific
	OO mechanism for communication with kernel, that reflects the
	polymorphism inside the OS (?)
	- role of userspace:
		* kernel does everything, including parsing partition
		table, LVM, etc. and possibly writing out.  (Viro appears
		to want this, although he wants it implemented via
		userfs)
			- how do constraints and planning work?
		* userspace tells the kernel, a la blkpg, possibly in
		an initrd / initfs
	- should userland management access the highest level volumes
	made available by the kernel, or access on lower levels, or
	optional?  (eg: when resizing a file system, should parted do IO
	through /dev/hda or /dev/hda1?)  high-level requires kernel support.

* file systems:
	- probing / clobbering / labelling - same as consumers
	- mkfs, dealing with options => gobject?
	- resize:
		* incremental resizers
		* reconstructive resizers, resize-the-start, LVM,
		block-size, etc.
	- fsck, resize: long operations => avoid restarts => libparted
	exception system.  Want heirarchical error codes (?)  (C++/Java have!)

* constraints:
	- "can I do this?" vs "what can I do?", and compromises in the middle
	- alignment constraints
	- location constraints
	- multiway constraints (shrink this partition vs shrink this file
	system)
	- dealing with complicated constraints:
		* in what ways can I do this?  (eg:
		get_move_to_device_constraint())
		* more expressive constraints
		* EVMS vs Parted

* undo, planning:
	- checkpoints
	- reverse operations
	- partition surprise
	- automatic partitioning, complicated searches
	- convertfs?

* other issues:
	- maintaining clusters?

* building the utopia:
	- have a core that knows about consumers, producers, constraints
	and exceptions
	- have a libpartition for partition tables, liblvm for LVM, libfs, etc.
	- since fs code is big, split resizing, fsck and mkfs into
	separate modules?
	- we want to be able to scale down, for fitting on an initrd (?)
	and scale up to doing high-level disk manipulation.  compatible
	with gobject/glib?  Should we create a subset of glib?