1 // SPDX-License-Identifier: GPL-2.0 2 3 //! Generic disk abstraction. 4 //! 5 //! C header: [`include/linux/blkdev.h`](srctree/include/linux/blkdev.h) 6 //! C header: [`include/linux/blk_mq.h`](srctree/include/linux/blk_mq.h) 7 8 use crate::block::mq::{raw_writer::RawWriter, Operations, TagSet}; 9 use crate::error; 10 use crate::{bindings, error::from_err_ptr, error::Result, sync::Arc}; 11 use core::fmt::{self, Write}; 12 13 /// A builder for [`GenDisk`]. 14 /// 15 /// Use this struct to configure and add new [`GenDisk`] to the VFS. 16 pub struct GenDiskBuilder { 17 rotational: bool, 18 logical_block_size: u32, 19 physical_block_size: u32, 20 capacity_sectors: u64, 21 } 22 23 impl Default for GenDiskBuilder { 24 fn default() -> Self { 25 Self { 26 rotational: false, 27 logical_block_size: bindings::PAGE_SIZE as u32, 28 physical_block_size: bindings::PAGE_SIZE as u32, 29 capacity_sectors: 0, 30 } 31 } 32 } 33 34 impl GenDiskBuilder { 35 /// Create a new instance. 36 pub fn new() -> Self { 37 Self::default() 38 } 39 40 /// Set the rotational media attribute for the device to be built. 41 pub fn rotational(mut self, rotational: bool) -> Self { 42 self.rotational = rotational; 43 self 44 } 45 46 /// Validate block size by verifying that it is between 512 and `PAGE_SIZE`, 47 /// and that it is a power of two. 48 fn validate_block_size(size: u32) -> Result<()> { 49 if !(512..=bindings::PAGE_SIZE as u32).contains(&size) || !size.is_power_of_two() { 50 Err(error::code::EINVAL) 51 } else { 52 Ok(()) 53 } 54 } 55 56 /// Set the logical block size of the device to be built. 57 /// 58 /// This method will check that block size is a power of two and between 512 59 /// and 4096. If not, an error is returned and the block size is not set. 60 /// 61 /// This is the smallest unit the storage device can address. It is 62 /// typically 4096 bytes. 63 pub fn logical_block_size(mut self, block_size: u32) -> Result<Self> { 64 Self::validate_block_size(block_size)?; 65 self.logical_block_size = block_size; 66 Ok(self) 67 } 68 69 /// Set the physical block size of the device to be built. 70 /// 71 /// This method will check that block size is a power of two and between 512 72 /// and 4096. If not, an error is returned and the block size is not set. 73 /// 74 /// This is the smallest unit a physical storage device can write 75 /// atomically. It is usually the same as the logical block size but may be 76 /// bigger. One example is SATA drives with 4096 byte physical block size 77 /// that expose a 512 byte logical block size to the operating system. 78 pub fn physical_block_size(mut self, block_size: u32) -> Result<Self> { 79 Self::validate_block_size(block_size)?; 80 self.physical_block_size = block_size; 81 Ok(self) 82 } 83 84 /// Set the capacity of the device to be built, in sectors (512 bytes). 85 pub fn capacity_sectors(mut self, capacity: u64) -> Self { 86 self.capacity_sectors = capacity; 87 self 88 } 89 90 /// Build a new `GenDisk` and add it to the VFS. 91 pub fn build<T: Operations>( 92 self, 93 name: fmt::Arguments<'_>, 94 tagset: Arc<TagSet<T>>, 95 ) -> Result<GenDisk<T>> { 96 let lock_class_key = crate::sync::LockClassKey::new(); 97 98 // SAFETY: `tagset.raw_tag_set()` points to a valid and initialized tag set 99 let gendisk = from_err_ptr(unsafe { 100 bindings::__blk_mq_alloc_disk( 101 tagset.raw_tag_set(), 102 core::ptr::null_mut(), // TODO: We can pass queue limits right here 103 core::ptr::null_mut(), 104 lock_class_key.as_ptr(), 105 ) 106 })?; 107 108 const TABLE: bindings::block_device_operations = bindings::block_device_operations { 109 submit_bio: None, 110 open: None, 111 release: None, 112 ioctl: None, 113 compat_ioctl: None, 114 check_events: None, 115 unlock_native_capacity: None, 116 getgeo: None, 117 set_read_only: None, 118 swap_slot_free_notify: None, 119 report_zones: None, 120 devnode: None, 121 alternative_gpt_sector: None, 122 get_unique_id: None, 123 // TODO: Set to THIS_MODULE. Waiting for const_refs_to_static feature to 124 // be merged (unstable in rustc 1.78 which is staged for linux 6.10) 125 // https://github.com/rust-lang/rust/issues/119618 126 owner: core::ptr::null_mut(), 127 pr_ops: core::ptr::null_mut(), 128 free_disk: None, 129 poll_bio: None, 130 }; 131 132 // SAFETY: `gendisk` is a valid pointer as we initialized it above 133 unsafe { (*gendisk).fops = &TABLE }; 134 135 let mut raw_writer = RawWriter::from_array( 136 // SAFETY: `gendisk` points to a valid and initialized instance. We 137 // have exclusive access, since the disk is not added to the VFS 138 // yet. 139 unsafe { &mut (*gendisk).disk_name }, 140 )?; 141 raw_writer.write_fmt(name)?; 142 raw_writer.write_char('\0')?; 143 144 // SAFETY: `gendisk` points to a valid and initialized instance of 145 // `struct gendisk`. We have exclusive access, so we cannot race. 146 unsafe { 147 bindings::blk_queue_logical_block_size((*gendisk).queue, self.logical_block_size) 148 }; 149 150 // SAFETY: `gendisk` points to a valid and initialized instance of 151 // `struct gendisk`. We have exclusive access, so we cannot race. 152 unsafe { 153 bindings::blk_queue_physical_block_size((*gendisk).queue, self.physical_block_size) 154 }; 155 156 // SAFETY: `gendisk` points to a valid and initialized instance of 157 // `struct gendisk`. `set_capacity` takes a lock to synchronize this 158 // operation, so we will not race. 159 unsafe { bindings::set_capacity(gendisk, self.capacity_sectors) }; 160 161 if !self.rotational { 162 // SAFETY: `gendisk` points to a valid and initialized instance of 163 // `struct gendisk`. This operation uses a relaxed atomic bit flip 164 // operation, so there is no race on this field. 165 unsafe { bindings::blk_queue_flag_set(bindings::QUEUE_FLAG_NONROT, (*gendisk).queue) }; 166 } else { 167 // SAFETY: `gendisk` points to a valid and initialized instance of 168 // `struct gendisk`. This operation uses a relaxed atomic bit flip 169 // operation, so there is no race on this field. 170 unsafe { 171 bindings::blk_queue_flag_clear(bindings::QUEUE_FLAG_NONROT, (*gendisk).queue) 172 }; 173 } 174 175 crate::error::to_result( 176 // SAFETY: `gendisk` points to a valid and initialized instance of 177 // `struct gendisk`. 178 unsafe { 179 bindings::device_add_disk(core::ptr::null_mut(), gendisk, core::ptr::null_mut()) 180 }, 181 )?; 182 183 // INVARIANT: `gendisk` was initialized above. 184 // INVARIANT: `gendisk` was added to the VFS via `device_add_disk` above. 185 Ok(GenDisk { 186 _tagset: tagset, 187 gendisk, 188 }) 189 } 190 } 191 192 /// A generic block device. 193 /// 194 /// # Invariants 195 /// 196 /// - `gendisk` must always point to an initialized and valid `struct gendisk`. 197 /// - `gendisk` was added to the VFS through a call to 198 /// `bindings::device_add_disk`. 199 pub struct GenDisk<T: Operations> { 200 _tagset: Arc<TagSet<T>>, 201 gendisk: *mut bindings::gendisk, 202 } 203 204 // SAFETY: `GenDisk` is an owned pointer to a `struct gendisk` and an `Arc` to a 205 // `TagSet` It is safe to send this to other threads as long as T is Send. 206 unsafe impl<T: Operations + Send> Send for GenDisk<T> {} 207 208 impl<T: Operations> Drop for GenDisk<T> { 209 fn drop(&mut self) { 210 // SAFETY: By type invariant, `self.gendisk` points to a valid and 211 // initialized instance of `struct gendisk`, and it was previously added 212 // to the VFS. 213 unsafe { bindings::del_gendisk(self.gendisk) }; 214 } 215 } 216