1 // SPDX-License-Identifier: GPL-2.0 2 3 // Copyright (C) 2024 Google LLC. 4 5 //! Rust misc device sample. 6 //! 7 //! Below is an example userspace C program that exercises this sample's functionality. 8 //! 9 //! ```c 10 //! #include <stdio.h> 11 //! #include <stdlib.h> 12 //! #include <errno.h> 13 //! #include <fcntl.h> 14 //! #include <unistd.h> 15 //! #include <sys/ioctl.h> 16 //! 17 //! #define RUST_MISC_DEV_FAIL _IO('|', 0) 18 //! #define RUST_MISC_DEV_HELLO _IO('|', 0x80) 19 //! #define RUST_MISC_DEV_GET_VALUE _IOR('|', 0x81, int) 20 //! #define RUST_MISC_DEV_SET_VALUE _IOW('|', 0x82, int) 21 //! 22 //! int main() { 23 //! int value, new_value; 24 //! int fd, ret; 25 //! 26 //! // Open the device file 27 //! printf("Opening /dev/rust-misc-device for reading and writing\n"); 28 //! fd = open("/dev/rust-misc-device", O_RDWR); 29 //! if (fd < 0) { 30 //! perror("open"); 31 //! return errno; 32 //! } 33 //! 34 //! // Make call into driver to say "hello" 35 //! printf("Calling Hello\n"); 36 //! ret = ioctl(fd, RUST_MISC_DEV_HELLO, NULL); 37 //! if (ret < 0) { 38 //! perror("ioctl: Failed to call into Hello"); 39 //! close(fd); 40 //! return errno; 41 //! } 42 //! 43 //! // Get initial value 44 //! printf("Fetching initial value\n"); 45 //! ret = ioctl(fd, RUST_MISC_DEV_GET_VALUE, &value); 46 //! if (ret < 0) { 47 //! perror("ioctl: Failed to fetch the initial value"); 48 //! close(fd); 49 //! return errno; 50 //! } 51 //! 52 //! value++; 53 //! 54 //! // Set value to something different 55 //! printf("Submitting new value (%d)\n", value); 56 //! ret = ioctl(fd, RUST_MISC_DEV_SET_VALUE, &value); 57 //! if (ret < 0) { 58 //! perror("ioctl: Failed to submit new value"); 59 //! close(fd); 60 //! return errno; 61 //! } 62 //! 63 //! // Ensure new value was applied 64 //! printf("Fetching new value\n"); 65 //! ret = ioctl(fd, RUST_MISC_DEV_GET_VALUE, &new_value); 66 //! if (ret < 0) { 67 //! perror("ioctl: Failed to fetch the new value"); 68 //! close(fd); 69 //! return errno; 70 //! } 71 //! 72 //! if (value != new_value) { 73 //! printf("Failed: Committed and retrieved values are different (%d - %d)\n", value, new_value); 74 //! close(fd); 75 //! return -1; 76 //! } 77 //! 78 //! // Call the unsuccessful ioctl 79 //! printf("Attempting to call in to an non-existent IOCTL\n"); 80 //! ret = ioctl(fd, RUST_MISC_DEV_FAIL, NULL); 81 //! if (ret < 0) { 82 //! perror("ioctl: Succeeded to fail - this was expected"); 83 //! } else { 84 //! printf("ioctl: Failed to fail\n"); 85 //! close(fd); 86 //! return -1; 87 //! } 88 //! 89 //! // Close the device file 90 //! printf("Closing /dev/rust-misc-device\n"); 91 //! close(fd); 92 //! 93 //! printf("Success\n"); 94 //! return 0; 95 //! } 96 //! ``` 97 98 use kernel::{ 99 device::Device, 100 fs::{ 101 File, 102 Kiocb, // 103 }, 104 ioctl::{ 105 _IO, 106 _IOC_SIZE, 107 _IOR, 108 _IOW, // 109 }, 110 iov::{ 111 IovIterDest, 112 IovIterSource, // 113 }, 114 miscdevice::{ 115 MiscDevice, 116 MiscDeviceOptions, 117 MiscDeviceRegistration, // 118 }, 119 new_mutex, 120 prelude::*, 121 sync::{ 122 aref::ARef, 123 Mutex, // 124 }, 125 uaccess::{ 126 UserSlice, 127 UserSliceReader, 128 UserSliceWriter, // 129 }, 130 }; 131 132 const RUST_MISC_DEV_HELLO: u32 = _IO('|' as u32, 0x80); 133 const RUST_MISC_DEV_GET_VALUE: u32 = _IOR::<i32>('|' as u32, 0x81); 134 const RUST_MISC_DEV_SET_VALUE: u32 = _IOW::<i32>('|' as u32, 0x82); 135 136 module! { 137 type: RustMiscDeviceModule, 138 name: "rust_misc_device", 139 authors: ["Lee Jones"], 140 description: "Rust misc device sample", 141 license: "GPL", 142 } 143 144 #[pin_data] 145 struct RustMiscDeviceModule { 146 #[pin] 147 _miscdev: MiscDeviceRegistration<RustMiscDevice>, 148 } 149 150 impl kernel::InPlaceModule for RustMiscDeviceModule { 151 fn init(_module: &'static ThisModule) -> impl PinInit<Self, Error> { 152 pr_info!("Initialising Rust Misc Device Sample\n"); 153 154 let options = MiscDeviceOptions { 155 name: c"rust-misc-device", 156 }; 157 158 try_pin_init!(Self { 159 _miscdev <- MiscDeviceRegistration::register(options), 160 }) 161 } 162 } 163 164 struct Inner { 165 value: i32, 166 buffer: KVVec<u8>, 167 } 168 169 #[pin_data(PinnedDrop)] 170 struct RustMiscDevice { 171 #[pin] 172 inner: Mutex<Inner>, 173 dev: ARef<Device>, 174 } 175 176 #[vtable] 177 impl MiscDevice for RustMiscDevice { 178 type Ptr = Pin<KBox<Self>>; 179 180 fn open(_file: &File, misc: &MiscDeviceRegistration<Self>) -> Result<Pin<KBox<Self>>> { 181 let dev = ARef::from(misc.device()); 182 183 dev_info!(dev, "Opening Rust Misc Device Sample\n"); 184 185 KBox::try_pin_init( 186 try_pin_init! { 187 RustMiscDevice { 188 inner <- new_mutex!(Inner { 189 value: 0_i32, 190 buffer: KVVec::new(), 191 }), 192 dev: dev, 193 } 194 }, 195 GFP_KERNEL, 196 ) 197 } 198 199 fn read_iter(mut kiocb: Kiocb<'_, Self::Ptr>, iov: &mut IovIterDest<'_>) -> Result<usize> { 200 let me = kiocb.file(); 201 dev_info!(me.dev, "Reading from Rust Misc Device Sample\n"); 202 203 let inner = me.inner.lock(); 204 // Read the buffer contents, taking the file position into account. 205 let read = iov.simple_read_from_buffer(kiocb.ki_pos_mut(), &inner.buffer)?; 206 207 Ok(read) 208 } 209 210 fn write_iter(mut kiocb: Kiocb<'_, Self::Ptr>, iov: &mut IovIterSource<'_>) -> Result<usize> { 211 let me = kiocb.file(); 212 dev_info!(me.dev, "Writing to Rust Misc Device Sample\n"); 213 214 let mut inner = me.inner.lock(); 215 216 // Replace buffer contents. 217 inner.buffer.clear(); 218 let len = iov.copy_from_iter_vec(&mut inner.buffer, GFP_KERNEL)?; 219 220 // Set position to zero so that future `read` calls will see the new contents. 221 *kiocb.ki_pos_mut() = 0; 222 223 Ok(len) 224 } 225 226 fn ioctl(me: Pin<&RustMiscDevice>, _file: &File, cmd: u32, arg: usize) -> Result<isize> { 227 dev_info!(me.dev, "IOCTLing Rust Misc Device Sample\n"); 228 229 // Treat the ioctl argument as a user pointer. 230 let arg = UserPtr::from_addr(arg); 231 let size = _IOC_SIZE(cmd); 232 233 match cmd { 234 RUST_MISC_DEV_GET_VALUE => me.get_value(UserSlice::new(arg, size).writer())?, 235 RUST_MISC_DEV_SET_VALUE => me.set_value(UserSlice::new(arg, size).reader())?, 236 RUST_MISC_DEV_HELLO => me.hello()?, 237 _ => { 238 dev_err!(me.dev, "-> IOCTL not recognised: {}\n", cmd); 239 return Err(ENOTTY); 240 } 241 }; 242 243 Ok(0) 244 } 245 } 246 247 #[pinned_drop] 248 impl PinnedDrop for RustMiscDevice { 249 fn drop(self: Pin<&mut Self>) { 250 dev_info!(self.dev, "Exiting the Rust Misc Device Sample\n"); 251 } 252 } 253 254 impl RustMiscDevice { 255 fn set_value(&self, mut reader: UserSliceReader) -> Result<isize> { 256 let new_value = reader.read::<i32>()?; 257 let mut guard = self.inner.lock(); 258 259 dev_info!( 260 self.dev, 261 "-> Copying data from userspace (value: {})\n", 262 new_value 263 ); 264 265 guard.value = new_value; 266 Ok(0) 267 } 268 269 fn get_value(&self, mut writer: UserSliceWriter) -> Result<isize> { 270 let guard = self.inner.lock(); 271 let value = guard.value; 272 273 // Free-up the lock and use our locally cached instance from here 274 drop(guard); 275 276 dev_info!( 277 self.dev, 278 "-> Copying data to userspace (value: {})\n", 279 &value 280 ); 281 282 writer.write::<i32>(&value)?; 283 Ok(0) 284 } 285 286 fn hello(&self) -> Result<isize> { 287 dev_info!(self.dev, "-> Hello from the Rust Misc Device\n"); 288 289 Ok(0) 290 } 291 } 292