sdk/fidl/fuchsia.hardware.block.volume/volume.fidl - fuchsia - Git at Google

 // Copyright 2019 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 library fuchsia.hardware.block.volume;
 using fuchsia.io;
 using zx;
 using fuchsia.hardware.block.partition as partition;

 /// VolumeManagerInfo describes the properties of the volume manager and not each individual volume.
 @for_deprecated_c_bindings
 type VolumeManagerInfo = struct {
     /// Size of a single slice, in bytes.
     slice_size uint64;

     /// Number of slices the volume manager is able use right now. This counts the
     /// allocated_slice_count plus the number of available slices.
     slice_count uint64;

     /// Number of slices currently assigned to partitions.
     assigned_slice_count uint64;

     /// The maximum capacity which the Volume Manager could grow to utilize if the partition
     /// containing the Volume Manager itself expands (i.e., the Volume Manager is initialized on a
     /// GPT partition that has extended beyond the originally allocated capacity). This value is
     /// the number of entries reserved in the volume manager header and is not related to the size
     /// of the physical device (which may be larger or smaller).
     maximum_slice_count uint64;

     /// Largest value that can be used for a virtual slice number.
     max_virtual_slice uint64;
 };

 @for_deprecated_c_bindings
 type VolumeInfo = struct {
     /// Number of slices allocated to the volume.
     partition_slice_count uint64;

     /// Limit on the maximum slices assigned to this partition, if there is one. If the size of the
     /// partition is not limited, this value will be 0. Partitions can grow into free slices
     /// available in the volume manager as long as their slices are less than or equal to this
     /// value.
     ///
     /// The partition may be larger than this limit if a smaller limit was applied after the
     /// partition had already grown to the current size.
     ///
     /// See `VolumeManager.GetPartitionLimit()`
     slice_limit uint64;
 };

 /// Indicates that the partition should be created as inactive, implying that it
 /// will be destroyed on reboot (unless activated by a call to "Activate").
 const ALLOCATE_PARTITION_FLAG_INACTIVE uint32 = 0x00000001;

 /// VolumeManager controls a collection of Volumes.
 protocol VolumeManager {
     /// Allocates a virtual partition with the requested features.
     ///
     /// `slice_count` is the number of slices initially allocated to the partition, at
     /// offset zero. The number of slices allocated to a new partition must be at least one.
     /// `type` and `value` indicate type and instance GUIDs for the partition, respectively.
     /// `name` indicates the name of the new partition.
     AllocatePartition(struct {
         slice_count uint64;
         type partition.GUID;
         instance partition.GUID;
         name string:partition.NAME_LENGTH;
         flags uint32;
     }) -> (struct {
         status zx.status;
     });

     /// Gets the VolumeManagerInfo describing this instance of the `VolumeManager`.
     GetInfo() -> (struct {
         status zx.status;
         info box<VolumeManagerInfo>;
     });

     /// Atomically marks a vpartition (by instance GUID) as inactive, while finding
     /// another partition (by instance GUID) and marking it as active.
     ///
     /// If the "old" partition does not exist, the GUID is ignored.
     /// If the "old" partition is the same as the "new" partition, the "old"
     /// GUID is ignored.
     /// If the "new" partition does not exist, `ZX_ERR_NOT_FOUND` is returned.
     ///
     /// This function does not destroy the "old" partition, it just marks it as
     /// inactive -- to reclaim that space, the "old" partition must be explicitly
     /// destroyed.  This destruction can also occur automatically when the FVM driver
     /// is rebound (i.e., on reboot).
     ///
     /// This function may be useful for A/B updates within the FVM,
     /// since it will allow activating updated partitions.
     Activate(struct {
         old_guid partition.GUID;
         new_guid partition.GUID;
     }) -> (struct {
         status zx.status;
     });

     /// Retrieves the allocation limit for the partition. A return value of 0 indicates that there
     /// is no limit and the partition can be extended as long as there is available space on the
     /// device.
     ///
     /// The partition may be larger than this limit if a smaller limit was applied after the
     /// partition had already grown to the current size.
     ///
     /// Currently the partition limit is not persisted across reboots but this may change in the
     /// future.
     GetPartitionLimit(struct {
         guid partition.GUID;
     }) -> (struct {
         status zx.status;
         slice_count uint64;
     });

     /// Sets the allocation limit for the partition. Partitions can not be extended beyond their
     /// allocation limit. The partition limit will never shrink partitions so if this value is
     /// less than the current partition size, it will keep the current size but prevent further
     /// growth.
     ///
     /// The allocation limits are on the VolumeManager API rather than on the partition because
     /// they represent a higher capability level. These limits are designed to put guards on
     /// users of the block device (and hence the Volume API).
     ///
     /// Currently the partition limit is not persisted across reboots but this may change in the
     /// future.
     SetPartitionLimit(struct {
         guid partition.GUID;
         slice_count uint64;
     }) -> (struct {
         status zx.status;
     });

     /// Renames the specified partition. Any existing devices that include the name of the partition
     /// in their topological path might *not* reflect the name change until the next time that the
     /// device is instantiated.
     SetPartitionName(struct {
         guid partition.GUID;
         name string:<partition.NAME_LENGTH>;
     }) -> (struct {}) error zx.status;
 };

 /// An arbitrary cap on the number of slices which may be requested when querying
 /// for allocation information from a volume.
 const MAX_SLICE_REQUESTS uint32 = 16;

 /// VsliceRange describes a range of virtual slices: start, length, and allocated status.
 ///
 /// These ranges are returned in an ordered container, which implicitly describes the
 /// starting offset, starting from the "index zero" slice.
 @for_deprecated_c_bindings
 type VsliceRange = struct {
     /// True if the virtual slices are allocated, false otherwise.
     allocated bool;

     /// The number of contiguous virtual slices.
     count uint64;
 };

 /// Volume is a partition which may access virtually-mapped blocks within a device.
 @for_deprecated_c_bindings
 protocol Volume {
     compose partition.Partition;

     /// Returns the number of contiguous allocated (or unallocated) vslices
     /// starting from each vslice.
     ///
     // TODO(smklein): Replace array with vector; doing so would be non-simple.
     QuerySlices(struct {
         start_slices vector<uint64>:MAX_SLICE_REQUESTS;
     }) -> (struct {
         status zx.status;
         response array<VsliceRange, MAX_SLICE_REQUESTS>;
         response_count uint64;
     });

     /// Returns the information about this volume and the volume manager it is embedded in.
     GetVolumeInfo() -> (struct {
         status zx.status;
         manager box<VolumeManagerInfo>;
         volume box<VolumeInfo>;
     });

     /// Extends the mapping of this partition.
     ///
     /// The ability to extend the partition is dependent on having sufficient free space on the
     /// underlying device, having sufficient free slots for tracking the bytes in the volume
     /// manager header, and the partition limit (see VolumeManager.SetPartitionLimit).
     Extend(struct {
         start_slice uint64;
         slice_count uint64;
     }) -> (struct {
         status zx.status;
     });

     /// Shrinks a virtual partition. Returns `ZX_OK` if ANY slices are
     /// freed, even if part of the requested range contains unallocated slices.
     Shrink(struct {
         start_slice uint64;
         slice_count uint64;
     }) -> (struct {
         status zx.status;
     });

     /// Destroys the current partition, removing it from the VolumeManager, and
     /// freeing all underlying storage. The connection to the volume is also closed.
     Destroy() -> (struct {
         status zx.status;
     });
 };

 /// This protocol is intended for servers that handles both hardware.block.Volume
 /// and io.Node.
 ///
 /// In the C++ implementation, such a server is able to test for the requests
 /// from each protocol. However, Rust bindings make it difficult to do
 /// so and requires that we create a new protocol that is composed of the two.
 protocol VolumeAndNode {
     compose Volume;
     compose fuchsia.io.Node;
 };
	// Copyright 2019 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.
	library fuchsia.hardware.block.volume;
	using fuchsia.io;
	using zx;
	using fuchsia.hardware.block.partition as partition;

	/// VolumeManagerInfo describes the properties of the volume manager and not each individual volume.
	@for_deprecated_c_bindings
	type VolumeManagerInfo = struct {
	/// Size of a single slice, in bytes.
	slice_size uint64;

	/// Number of slices the volume manager is able use right now. This counts the
	/// allocated_slice_count plus the number of available slices.
	slice_count uint64;

	/// Number of slices currently assigned to partitions.
	assigned_slice_count uint64;

	/// The maximum capacity which the Volume Manager could grow to utilize if the partition
	/// containing the Volume Manager itself expands (i.e., the Volume Manager is initialized on a
	/// GPT partition that has extended beyond the originally allocated capacity). This value is
	/// the number of entries reserved in the volume manager header and is not related to the size
	/// of the physical device (which may be larger or smaller).
	maximum_slice_count uint64;

	/// Largest value that can be used for a virtual slice number.
	max_virtual_slice uint64;
	};

	@for_deprecated_c_bindings
	type VolumeInfo = struct {
	/// Number of slices allocated to the volume.
	partition_slice_count uint64;

	/// Limit on the maximum slices assigned to this partition, if there is one. If the size of the
	/// partition is not limited, this value will be 0. Partitions can grow into free slices
	/// available in the volume manager as long as their slices are less than or equal to this
	/// value.
	///
	/// The partition may be larger than this limit if a smaller limit was applied after the
	/// partition had already grown to the current size.
	///
	/// See `VolumeManager.GetPartitionLimit()`
	slice_limit uint64;
	};

	/// Indicates that the partition should be created as inactive, implying that it
	/// will be destroyed on reboot (unless activated by a call to "Activate").
	const ALLOCATE_PARTITION_FLAG_INACTIVE uint32 = 0x00000001;

	/// VolumeManager controls a collection of Volumes.
	protocol VolumeManager {
	/// Allocates a virtual partition with the requested features.
	///
	/// `slice_count` is the number of slices initially allocated to the partition, at
	/// offset zero. The number of slices allocated to a new partition must be at least one.
	/// `type` and `value` indicate type and instance GUIDs for the partition, respectively.
	/// `name` indicates the name of the new partition.
	AllocatePartition(struct {
	slice_count uint64;
	type partition.GUID;
	instance partition.GUID;
	name string:partition.NAME_LENGTH;
	flags uint32;
	}) -> (struct {
	status zx.status;
	});

	/// Gets the VolumeManagerInfo describing this instance of the `VolumeManager`.
	GetInfo() -> (struct {
	status zx.status;
	info box<VolumeManagerInfo>;
	});

	/// Atomically marks a vpartition (by instance GUID) as inactive, while finding
	/// another partition (by instance GUID) and marking it as active.
	///
	/// If the "old" partition does not exist, the GUID is ignored.
	/// If the "old" partition is the same as the "new" partition, the "old"
	/// GUID is ignored.
	/// If the "new" partition does not exist, `ZX_ERR_NOT_FOUND` is returned.
	///
	/// This function does not destroy the "old" partition, it just marks it as
	/// inactive -- to reclaim that space, the "old" partition must be explicitly
	/// destroyed. This destruction can also occur automatically when the FVM driver
	/// is rebound (i.e., on reboot).
	///
	/// This function may be useful for A/B updates within the FVM,
	/// since it will allow activating updated partitions.
	Activate(struct {
	old_guid partition.GUID;
	new_guid partition.GUID;
	}) -> (struct {
	status zx.status;
	});

	/// Retrieves the allocation limit for the partition. A return value of 0 indicates that there
	/// is no limit and the partition can be extended as long as there is available space on the
	/// device.
	///
	/// The partition may be larger than this limit if a smaller limit was applied after the
	/// partition had already grown to the current size.
	///
	/// Currently the partition limit is not persisted across reboots but this may change in the
	/// future.
	GetPartitionLimit(struct {
	guid partition.GUID;
	}) -> (struct {
	status zx.status;
	slice_count uint64;
	});

	/// Sets the allocation limit for the partition. Partitions can not be extended beyond their
	/// allocation limit. The partition limit will never shrink partitions so if this value is
	/// less than the current partition size, it will keep the current size but prevent further
	/// growth.
	///
	/// The allocation limits are on the VolumeManager API rather than on the partition because
	/// they represent a higher capability level. These limits are designed to put guards on
	/// users of the block device (and hence the Volume API).
	///
	/// Currently the partition limit is not persisted across reboots but this may change in the
	/// future.
	SetPartitionLimit(struct {
	guid partition.GUID;
	slice_count uint64;
	}) -> (struct {
	status zx.status;
	});

	/// Renames the specified partition. Any existing devices that include the name of the partition
	/// in their topological path might not reflect the name change until the next time that the
	/// device is instantiated.
	SetPartitionName(struct {
	guid partition.GUID;
	name string:<partition.NAME_LENGTH>;
	}) -> (struct {}) error zx.status;
	};

	/// An arbitrary cap on the number of slices which may be requested when querying
	/// for allocation information from a volume.
	const MAX_SLICE_REQUESTS uint32 = 16;

	/// VsliceRange describes a range of virtual slices: start, length, and allocated status.
	///
	/// These ranges are returned in an ordered container, which implicitly describes the
	/// starting offset, starting from the "index zero" slice.
	@for_deprecated_c_bindings
	type VsliceRange = struct {
	/// True if the virtual slices are allocated, false otherwise.
	allocated bool;

	/// The number of contiguous virtual slices.
	count uint64;
	};

	/// Volume is a partition which may access virtually-mapped blocks within a device.
	@for_deprecated_c_bindings
	protocol Volume {
	compose partition.Partition;

	/// Returns the number of contiguous allocated (or unallocated) vslices
	/// starting from each vslice.
	///
	// TODO(smklein): Replace array with vector; doing so would be non-simple.
	QuerySlices(struct {
	start_slices vector<uint64>:MAX_SLICE_REQUESTS;
	}) -> (struct {
	status zx.status;
	response array<VsliceRange, MAX_SLICE_REQUESTS>;
	response_count uint64;
	});

	/// Returns the information about this volume and the volume manager it is embedded in.
	GetVolumeInfo() -> (struct {
	status zx.status;
	manager box<VolumeManagerInfo>;
	volume box<VolumeInfo>;
	});

	/// Extends the mapping of this partition.
	///
	/// The ability to extend the partition is dependent on having sufficient free space on the
	/// underlying device, having sufficient free slots for tracking the bytes in the volume
	/// manager header, and the partition limit (see VolumeManager.SetPartitionLimit).
	Extend(struct {
	start_slice uint64;
	slice_count uint64;
	}) -> (struct {
	status zx.status;
	});

	/// Shrinks a virtual partition. Returns `ZX_OK` if ANY slices are
	/// freed, even if part of the requested range contains unallocated slices.
	Shrink(struct {
	start_slice uint64;
	slice_count uint64;
	}) -> (struct {
	status zx.status;
	});

	/// Destroys the current partition, removing it from the VolumeManager, and
	/// freeing all underlying storage. The connection to the volume is also closed.
	Destroy() -> (struct {
	status zx.status;
	});
	};

	/// This protocol is intended for servers that handles both hardware.block.Volume
	/// and io.Node.
	///
	/// In the C++ implementation, such a server is able to test for the requests
	/// from each protocol. However, Rust bindings make it difficult to do
	/// so and requires that we create a new protocol that is composed of the two.
	protocol VolumeAndNode {
	compose Volume;
	compose fuchsia.io.Node;
	};