projects/linux·blob master · refs

291 lines · 7.4 KiB

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
98use 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
132const RUST_MISC_DEV_HELLO: u32 = _IO('|' as u32, 0x80);
133const RUST_MISC_DEV_GET_VALUE: u32 = _IOR::<i32>('|' as u32, 0x81);
134const RUST_MISC_DEV_SET_VALUE: u32 = _IOW::<i32>('|' as u32, 0x82);
135
136module! {
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]
145struct RustMiscDeviceModule {
146 #[pin]
147 _miscdev: MiscDeviceRegistration<RustMiscDevice>,
148}
149
150impl 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
164struct Inner {
165 value: i32,
166 buffer: KVVec<u8>,
167}
168
169#[pin_data(PinnedDrop)]
170struct RustMiscDevice {
171 #[pin]
172 inner: Mutex<Inner>,
173 dev: ARef<Device>,
174}
175
176#[vtable]
177impl 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]
248impl 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
254impl 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}