Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20;
Feedback-ID: i56684263:Fastmail
Message-ID: <283f3831-a51c-1798-6871-cd19584bc03e@ryhl.io>
Date:   Fri, 31 Mar 2023 09:32:46 +0200
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101
 Thunderbird/102.9.0
Subject: Re: [PATCH 10/13] rust: introduce `Task::current`
Content-Language: en-US
To:     Gary Guo <gary@garyguo.net>,
        Wedson Almeida Filho <wedsonaf@gmail.com>
Cc:     rust-for-linux@vger.kernel.org, Miguel Ojeda <ojeda@kernel.org>,
        Alex Gaynor <alex.gaynor@gmail.com>,
        Boqun Feng <boqun.feng@gmail.com>,
        =?UTF-8?Q?Bj=c3=b6rn_Roy_Baron?= <bjorn3_gh@protonmail.com>,
        linux-kernel@vger.kernel.org,
        Wedson Almeida Filho <walmeida@microsoft.com>,
        Ingo Molnar <mingo@redhat.com>,
        Peter Zijlstra <peterz@infradead.org>
References: <20230330043954.562237-1-wedsonaf@gmail.com>
 <20230330043954.562237-10-wedsonaf@gmail.com>
 <20230331034701.0657d5f2.gary@garyguo.net>
From:   Alice Ryhl <alice@ryhl.io>
In-Reply-To: <20230331034701.0657d5f2.gary@garyguo.net>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Precedence: bulk

On 3/31/23 04:47, Gary Guo wrote:
> On Thu, 30 Mar 2023 01:39:51 -0300
> Wedson Almeida Filho <wedsonaf@gmail.com> wrote:
> 
>> From: Wedson Almeida Filho <walmeida@microsoft.com>
>>
>> This allows Rust code to get a reference to the current task without
>> having to increment the refcount, but still guaranteeing memory safety.
>>
>> Cc: Ingo Molnar <mingo@redhat.com>
>> Cc: Peter Zijlstra <peterz@infradead.org>
>> Signed-off-by: Wedson Almeida Filho <walmeida@microsoft.com>
>> ---
>>   rust/helpers.c      |  6 ++++
>>   rust/kernel/task.rs | 83 ++++++++++++++++++++++++++++++++++++++++++++-
>>   2 files changed, 88 insertions(+), 1 deletion(-)
>>
>> diff --git a/rust/helpers.c b/rust/helpers.c
>> index 58a194042c86..96441744030e 100644
>> --- a/rust/helpers.c
>> +++ b/rust/helpers.c
>> @@ -100,6 +100,12 @@ bool rust_helper_refcount_dec_and_test(refcount_t *r)
>>   }
>>   EXPORT_SYMBOL_GPL(rust_helper_refcount_dec_and_test);
>>   
>> +struct task_struct *rust_helper_get_current(void)
>> +{
>> +	return current;
>> +}
>> +EXPORT_SYMBOL_GPL(rust_helper_get_current);
>> +
>>   void rust_helper_get_task_struct(struct task_struct *t)
>>   {
>>   	get_task_struct(t);
>> diff --git a/rust/kernel/task.rs b/rust/kernel/task.rs
>> index 8d7a8222990f..8b2b56ba9c6d 100644
>> --- a/rust/kernel/task.rs
>> +++ b/rust/kernel/task.rs
>> @@ -5,7 +5,7 @@
>>   //! C header: [`include/linux/sched.h`](../../../../include/linux/sched.h).
>>   
>>   use crate::bindings;
>> -use core::{cell::UnsafeCell, ptr};
>> +use core::{cell::UnsafeCell, marker::PhantomData, ops::Deref, ptr};
>>   
>>   /// Wraps the kernel's `struct task_struct`.
>>   ///
>> @@ -13,6 +13,46 @@ use core::{cell::UnsafeCell, ptr};
>>   ///
>>   /// Instances of this type are always ref-counted, that is, a call to `get_task_struct` ensures
>>   /// that the allocation remains valid at least until the matching call to `put_task_struct`.
>> +///
>> +/// # Examples
>> +///
>> +/// The following is an example of getting the PID of the current thread with zero additional cost
>> +/// when compared to the C version:
>> +///
>> +/// ```
>> +/// use kernel::task::Task;
>> +///
>> +/// let pid = Task::current().pid();
>> +/// ```
>> +///
>> +/// Getting the PID of the current process, also zero additional cost:
>> +///
>> +/// ```
>> +/// use kernel::task::Task;
>> +///
>> +/// let pid = Task::current().group_leader().pid();
>> +/// ```
>> +///
>> +/// Getting the current task and storing it in some struct. The reference count is automatically
>> +/// incremented when creating `State` and decremented when it is dropped:
>> +///
>> +/// ```
>> +/// use kernel::{task::Task, ARef};
>> +///
>> +/// struct State {
>> +///     creator: ARef<Task>,
>> +///     index: u32,
>> +/// }
>> +///
>> +/// impl State {
>> +///     fn new() -> Self {
>> +///         Self {
>> +///             creator: Task::current().into(),
>> +///             index: 0,
>> +///         }
>> +///     }
>> +/// }
>> +/// ```
>>   #[repr(transparent)]
>>   pub struct Task(pub(crate) UnsafeCell<bindings::task_struct>);
>>   
>> @@ -25,6 +65,20 @@ unsafe impl Sync for Task {}
>>   type Pid = bindings::pid_t;
>>   
>>   impl Task {
>> +    /// Returns a task reference for the currently executing task/thread.
>> +    pub fn current<'a>() -> TaskRef<'a> {
>> +        // SAFETY: Just an FFI call with no additional safety requirements.
>> +        let ptr = unsafe { bindings::get_current() };
>> +
>> +        TaskRef {
>> +            // SAFETY: If the current thread is still running, the current task is valid. Given
>> +            // that `TaskRef` is not `Send`, we know it cannot be transferred to another thread
>> +            // (where it could potentially outlive the caller).
>> +            task: unsafe { &*ptr.cast() },
>> +            _not_send: PhantomData,
>> +        }
>> +    }
>> +
> 
> I don't think this API is sound, as you can do `&*Task::current()` and
> get a `&'static Task`, which is very problematic.
> 
> A sound API would be
> 
> 	pub fn with_current<R>(f: imp FnOnce(&Task) -> R) -> R { ... }
> 
> (which also is how thread local works in Rust)
> 
> You would have to write `Task::with_current(|cur| cur.pid())` though,
> which unfortunately is a bit less ergonomic.
> 
> Best,
> Gary

This is true, unfortunately. It would be possible to write a macro with 
a more similar API to the current implementation.