From patchwork Fri Feb 7 13:26:16 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: FUJITA Tomonori X-Patchwork-Id: 13964974 Received: from mail-pl1-f181.google.com (mail-pl1-f181.google.com [209.85.214.181]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8E1FB1DFE25; Fri, 7 Feb 2025 13:31:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.181 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738935096; cv=none; b=p87BJ9R5kS5xzdRypqZiih+ZV5K/3vluNdQ1yHhfXQfxd851aD6tH7V6LjqTSjtqYDXJaWlxX6uV5gKq6azqBXQ9G/v2gs1vfKFZF/hyAgP1C8OU4PkWpw+0m6upSaDSI6ai+XN+3ANQ2+tnclNi6/V9K6KljpO13xLbJWx2mHg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738935096; c=relaxed/simple; bh=064mulaCi5LDzWlmhgPgjlBPoAcfLaq6k45Tym24phU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=LOr7TjPqUr+8xvfn5eJ4sTPkUgBipIQ8rCVItZZTNPOLKGt4X5mN+00X8mQtvC3nNpCfLcn1C7xUSCDrgiR2lfFy0qyWk8VNKaBeAqBk6abeLlDyNXmTOOaMND4YKRbv5MztLU77i1/ix4dioSYhtkD/cBUWlf9jJlgZXFV0xqI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=c3SNEpfM; arc=none smtp.client-ip=209.85.214.181 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="c3SNEpfM" Received: by mail-pl1-f181.google.com with SMTP id d9443c01a7336-21f0c4275a1so31588565ad.2; Fri, 07 Feb 2025 05:31:34 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1738935094; x=1739539894; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=O6Bli2BZjHS4ZZy20IyRSegYD0yjInLQaMwTFLH4pvs=; b=c3SNEpfMYVuhLci18kafLTvKwd9Z91mTcRox81FGs/CsFuLPLFqkHOIqUrSKJORbaI FmCqtvtI3iU4q/c3N4bxMmJ0nfg47rY9eUx76Gk7gBIPOmD+hsuH2l4zJXX3SYzSjDoP AvNtb0F6amR8j8S/P8HPlTINnXyQfgIlmhZEJaXXmgLKmTI+VDUbD/I92V+Vjn41+c0o +zUKmkZMuGtoNbf9KlxJ+ZJBijYaTsZqjkK07txABIhYGOnR2w0pyYwQopmRXGR8VSb5 Pu9xxsaMe983FWPs3rYCoi24NdZXOFq1IUZM61s6wmH0J9NiLrVrIXForw6zWEHL2BBZ vfVQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1738935094; x=1739539894; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=O6Bli2BZjHS4ZZy20IyRSegYD0yjInLQaMwTFLH4pvs=; b=QOosjI6rfpMt5uGePgNPN2xqw05ONdbAlRUizimqQ7Z7lg7zAjSLlR6GT5DW1oO+a4 MGK39tIulVzFekmrof8jiXWH7MylE7jj4uI4qnXPdTYoYvjLcqoctdm1qMTE8finEV/u DVnIV2l1l4V+J20tquVfl+VgUv94p5ZDLpDLKAkM55yEEpvui9HAz/C+FC9qvg1xkWen 2H531sT11thjyHespX4KqIHh0GyWN0sVjiva9tEx7eZlfD8ZQRfcSuhTjeFHaUrwdqBQ e+LYXKnzintrer6NYhUI2Qw2Q39Si73mh1tWjMjmb3s882kCNvm5Dv/ImOBh/ZCtlhmD tcaA== X-Forwarded-Encrypted: i=1; AJvYcCWPLiA+omB2lMhUgHmyBkSEGoWW7lGaffz86Es7WDHQ+FpEtpwJJlUMOhtF78abuMHBPuQJbRnE9IAsMcpm4f8=@vger.kernel.org, AJvYcCXAXv+gn6vINUFNMLgFQa2TnA4FksOcE3S5VSQaA44rpCqDbL5he5cNPigW9Hw2EEH2yPtuA2U=@vger.kernel.org X-Gm-Message-State: AOJu0YyKhzGPM2URAXkDOyFAMs5smEX8C61+o/imvpsu7EJgMZ7u5tsZ h4a61K22EHH9mwdf8mPFuLMnpWE17NK72GR4vmIY1E2SPIE8OTyaFsaTTSGf X-Gm-Gg: ASbGncvjBEv3INZgGiFUAtnEaVPMgSAq5+5YAO6LXfIQPnMYcIeorFh8UGPQjMhSN7I SqlKZMuXmnPVfznpvD5tjd1JPadHgl4GVTfnyK3LQ2jxDb6/nitjZh8eCFbr2AtXEoIVOnsrp6e QvIKF5UYK2eAm6CeLfqrc6kAu60aKrqsPAuXZyPogSOaMdgnHJtCo3nMLAYejJwnyprITi6es3+ hghmgD87RObFZzf2t0ThdqxIJBgLjfkwueiaKc3+1zXISYMYXDtuXAisKQ0q76qVX8dySa9bFIP UEaJPpJz8BBceFZPkA+XtDSDQcZfJPksIwTQV3Tnp9Lej+KYX6RUP1k6Rs8ZaG8In7k= X-Google-Smtp-Source: AGHT+IFCuW2ciwOj/rz2+cvmiWr/LcPaS/VEVQxIfl+6LHNYR4w30O828TCtVfp6OU2E1J5y/KknAA== X-Received: by 2002:a05:6a21:6e46:b0:1e1:b8bf:8e80 with SMTP id adf61e73a8af0-1ee03b70bb6mr7042645637.41.1738935093602; Fri, 07 Feb 2025 05:31:33 -0800 (PST) Received: from mew.. (p3882177-ipxg22501hodogaya.kanagawa.ocn.ne.jp. [180.15.148.177]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-ad51ea79a47sm2877843a12.76.2025.02.07.05.31.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 07 Feb 2025 05:31:33 -0800 (PST) From: FUJITA Tomonori To: linux-kernel@vger.kernel.org Cc: Alice Ryhl , Boqun Feng , rust-for-linux@vger.kernel.org, netdev@vger.kernel.org, andrew@lunn.ch, hkallweit1@gmail.com, tmgross@umich.edu, ojeda@kernel.org, alex.gaynor@gmail.com, gary@garyguo.net, bjorn3_gh@protonmail.com, benno.lossin@proton.me, a.hindborg@samsung.com, anna-maria@linutronix.de, frederic@kernel.org, tglx@linutronix.de, arnd@arndb.de, jstultz@google.com, sboyd@kernel.org, mingo@redhat.com, peterz@infradead.org, juri.lelli@redhat.com, vincent.guittot@linaro.org, dietmar.eggemann@arm.com, rostedt@goodmis.org, bsegall@google.com, mgorman@suse.de, vschneid@redhat.com, tgunders@redhat.com, me@kloenk.dev Subject: [PATCH v10 1/8] sched/core: Add __might_sleep_precision() Date: Fri, 7 Feb 2025 22:26:16 +0900 Message-ID: <20250207132623.168854-2-fujita.tomonori@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20250207132623.168854-1-fujita.tomonori@gmail.com> References: <20250207132623.168854-1-fujita.tomonori@gmail.com> Precedence: bulk X-Mailing-List: netdev@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Add __might_sleep_precision(), Rust friendly version of __might_sleep(), which takes a pointer to a string with the length instead of a null-terminated string. Rust's core::panic::Location::file(), which gives the file name of a caller, doesn't provide a null-terminated string. __might_sleep_precision() uses a precision specifier in the printk format, which specifies the length of a string; a string doesn't need to be a null-terminated. Modify __might_sleep() to call __might_sleep_precision() but the impact should be negligible. strlen() isn't called in a normal case; it's called only when printing the error (sleeping function called from invalid context). Note that Location::file() providing a null-terminated string for better C interoperability is under discussion [1]. Link: https://github.com/rust-lang/libs-team/issues/466 [1] Reviewed-by: Alice Ryhl Co-developed-by: Boqun Feng Signed-off-by: Boqun Feng Signed-off-by: FUJITA Tomonori --- include/linux/kernel.h | 2 ++ kernel/sched/core.c | 55 ++++++++++++++++++++++++++---------------- 2 files changed, 36 insertions(+), 21 deletions(-) diff --git a/include/linux/kernel.h b/include/linux/kernel.h index be2e8c0a187e..086ee1dc447e 100644 --- a/include/linux/kernel.h +++ b/include/linux/kernel.h @@ -87,6 +87,7 @@ extern int dynamic_might_resched(void); #ifdef CONFIG_DEBUG_ATOMIC_SLEEP extern void __might_resched(const char *file, int line, unsigned int offsets); extern void __might_sleep(const char *file, int line); +extern void __might_sleep_precision(const char *file, int len, int line); extern void __cant_sleep(const char *file, int line, int preempt_offset); extern void __cant_migrate(const char *file, int line); @@ -145,6 +146,7 @@ extern void __cant_migrate(const char *file, int line); static inline void __might_resched(const char *file, int line, unsigned int offsets) { } static inline void __might_sleep(const char *file, int line) { } +static inline void __might_sleep_precision(const char *file, int len, int line) { } # define might_sleep() do { might_resched(); } while (0) # define cant_sleep() do { } while (0) # define cant_migrate() do { } while (0) diff --git a/kernel/sched/core.c b/kernel/sched/core.c index 165c90ba64ea..d308f2a8692e 100644 --- a/kernel/sched/core.c +++ b/kernel/sched/core.c @@ -8678,24 +8678,6 @@ void __init sched_init(void) #ifdef CONFIG_DEBUG_ATOMIC_SLEEP -void __might_sleep(const char *file, int line) -{ - unsigned int state = get_current_state(); - /* - * Blocking primitives will set (and therefore destroy) current->state, - * since we will exit with TASK_RUNNING make sure we enter with it, - * otherwise we will destroy state. - */ - WARN_ONCE(state != TASK_RUNNING && current->task_state_change, - "do not call blocking ops when !TASK_RUNNING; " - "state=%x set at [<%p>] %pS\n", state, - (void *)current->task_state_change, - (void *)current->task_state_change); - - __might_resched(file, line, 0); -} -EXPORT_SYMBOL(__might_sleep); - static void print_preempt_disable_ip(int preempt_offset, unsigned long ip) { if (!IS_ENABLED(CONFIG_DEBUG_PREEMPT)) @@ -8717,7 +8699,8 @@ static inline bool resched_offsets_ok(unsigned int offsets) return nested == offsets; } -void __might_resched(const char *file, int line, unsigned int offsets) +static void __might_resched_precision(const char *file, int len, int line, + unsigned int offsets) { /* Ratelimiting timestamp: */ static unsigned long prev_jiffy; @@ -8740,8 +8723,10 @@ void __might_resched(const char *file, int line, unsigned int offsets) /* Save this before calling printk(), since that will clobber it: */ preempt_disable_ip = get_preempt_disable_ip(current); - pr_err("BUG: sleeping function called from invalid context at %s:%d\n", - file, line); + if (len < 0) + len = strlen(file); + pr_err("BUG: sleeping function called from invalid context at %.*s:%d\n", + len, file, line); pr_err("in_atomic(): %d, irqs_disabled(): %d, non_block: %d, pid: %d, name: %s\n", in_atomic(), irqs_disabled(), current->non_block_count, current->pid, current->comm); @@ -8766,8 +8751,36 @@ void __might_resched(const char *file, int line, unsigned int offsets) dump_stack(); add_taint(TAINT_WARN, LOCKDEP_STILL_OK); } + +void __might_resched(const char *file, int line, unsigned int offsets) +{ + __might_resched_precision(file, -1, line, offsets); +} EXPORT_SYMBOL(__might_resched); +void __might_sleep_precision(const char *file, int len, int line) +{ + unsigned int state = get_current_state(); + /* + * Blocking primitives will set (and therefore destroy) current->state, + * since we will exit with TASK_RUNNING make sure we enter with it, + * otherwise we will destroy state. + */ + WARN_ONCE(state != TASK_RUNNING && current->task_state_change, + "do not call blocking ops when !TASK_RUNNING; " + "state=%x set at [<%p>] %pS\n", state, + (void *)current->task_state_change, + (void *)current->task_state_change); + + __might_resched_precision(file, len, line, 0); +} + +void __might_sleep(const char *file, int line) +{ + __might_sleep_precision(file, -1, line); +} +EXPORT_SYMBOL(__might_sleep); + void __cant_sleep(const char *file, int line, int preempt_offset) { static unsigned long prev_jiffy; From patchwork Fri Feb 7 13:26:17 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: FUJITA Tomonori X-Patchwork-Id: 13964975 Received: from mail-pl1-f178.google.com (mail-pl1-f178.google.com [209.85.214.178]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2D21A1A5BB1; Fri, 7 Feb 2025 13:31:41 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.178 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738935104; cv=none; b=Q6zytJBbCT9fmG5aDnBtT1Dav0lufQxniKcWNLHRe1GIvMkjHiO8df0ema/YIrv6yfdyJhoe7AV/osPu6PRU76Ml/ItK4clwSQC0W218C1FxhraGHjAIxlb7xzBNLv/xO75ZPzrMrZhU+61+ie2vG/eEef1W8VaEmFvsfB5eZFs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738935104; c=relaxed/simple; bh=LoBGIidzr+b3R8h++Tx7qCa9b+hY5XCB/xrwCgA9bpo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=RjI8KkSdriSdVax9hNqBon6ThfBVBgIpTyHDu+XwFWskQ8vQyxv1uPEYhxoZ98bDB62bfL2HvlOPYM1xdvGGpcC5ItTjMC4sPEnQ6tS6O4eIsy1SqRGXgfEH+j8kU9a782DzpgjSKzz6qvqZ+I/6HFGKvYwtJoiiSsfgWNxdN0g= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=RLmts1JB; arc=none smtp.client-ip=209.85.214.178 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="RLmts1JB" Received: by mail-pl1-f178.google.com with SMTP id d9443c01a7336-21f20666e72so42872645ad.1; Fri, 07 Feb 2025 05:31:41 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1738935101; x=1739539901; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=Zg2LvfJwtwHDxNRHkkZCVAVibFr6XigkDjBCaMe28f8=; b=RLmts1JBKvxAJ2aSc5BjIR6rDJiIHlEJahpRLkEGXhzYFDX70BL0pPplANcTP3lloy cAFw9n9zxZ4fDgRBaYVlcWE0OIOrAC7HDSvzlOmJnktqH/37nwXEsoq7rmuLQLyRHjvG 2m1L88up7iNNKHA/U68vTDn5sA5gZChJ8m12jYkvQVTWATf4JYcWN3aW0jyO9UMwCZl6 8fKx5tIO03QoydwfCEbigG5pfnVOYwupvTaPWfR2K51IrIMWF4OT9xwtutVxcZTuL1+I yTvbUTVGFViakTijpFWkNFnPqoMlWTjvpZ9MgZgSWNmKjVFLYkinW6N7RerQ0gQN/aXo EUkg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1738935101; x=1739539901; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=Zg2LvfJwtwHDxNRHkkZCVAVibFr6XigkDjBCaMe28f8=; b=muoz1be4JA4Zs9hHS0hLnx3K98r4+9BcBx4SsqXQmgL545+L8FHpt0BbfIBdRMdQH6 D/B5OAU754CeWVhogFDLgZTg7RWcV4tAZJG9Wlv0H9pOFie70aT46CHAXA2JoqXK0ooJ cf34j8MiQo7h+JO2yYnSy2pwwUAqpHE443FyVUaN8SgQvfHDOKfGNRLjsPyYcFVv2KbF ug6oOg5qWE0zWf1USLYbTRedBEJ490idNrwKg8dXh9Rc2Rsan17f3Wa8NohU4w/DUnnD jOjrVFb80gdNZbWj+UAvyburIkK3fowfkzpiP8Zt1Jev02SaUzxzonUYqCYP39c0sNa3 36qQ== X-Forwarded-Encrypted: i=1; AJvYcCVhJs2tl1jLDhEHY2prihESvlNfguGJUJHEXeg6yFtleUyXhGfcb8WqlHZKZQk62+hpTfVfjQ2JAWIeo4oH0vQ=@vger.kernel.org, AJvYcCWTZUaquNLyntpadjpCqBpQAtQJ8+I9irH/g7lErxJlrxBA1XV82K/fTMpeW7kqc67DU1d42zQ=@vger.kernel.org X-Gm-Message-State: AOJu0YzGTzouV8y81daAViJLNmOb9NIiiT68xj+LXjZOkR8Yuly/IITV zXHEmC009jHkJ5vQ0VD2vf+Glz+rvKY7JLt+UUDbdzgug9rxC2T/UldNRB7B X-Gm-Gg: ASbGncueQnM6BbI6SkHxMk5MeHbcLbmNUxA8DPUG9X9Nk3BqIhqk7Q+jAjufDqfq6sd lseJ+SbsppfnRfCmaJ7Pjz7PUwt5/N7Ge+95WlJpg+EM+ILFTQXo2u7NU2rFp0Y9li70WyxV17G 571wGeVehCh0a41Fopmg4LNq7i0HyYt6sxkEdVf1GT+pIfJz2RdlywyIEKENrlh0iHyaExDzlGR 7m3fwfQqO5VFkYonZa1zlhGlnMcwfR81qOA0X0ahphF0gapx8vPj4apeeXzGOGz92V1pqkh8qeR D0PazhWmzuD7sZs+71UYPuFw3ulAzinx7Pgiije45Z+5x5Nbf7JvFS+YI885Auvs3AU= X-Google-Smtp-Source: AGHT+IHGMQicG3T0EcYkxJgmH1f/39a0QSgF398SGP0dohsSSfw8A3Nknz31U06ZwY/r0HEIDbTuQw== X-Received: by 2002:a05:6a00:1a93:b0:728:9d19:d2ea with SMTP id d2e1a72fcca58-7305d4adb54mr4525387b3a.13.1738935101122; Fri, 07 Feb 2025 05:31:41 -0800 (PST) Received: from mew.. (p3882177-ipxg22501hodogaya.kanagawa.ocn.ne.jp. [180.15.148.177]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-ad51ea79a47sm2877843a12.76.2025.02.07.05.31.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 07 Feb 2025 05:31:40 -0800 (PST) From: FUJITA Tomonori To: linux-kernel@vger.kernel.org Cc: Trevor Gross , Alice Ryhl , Gary Guo , Fiona Behrens , rust-for-linux@vger.kernel.org, netdev@vger.kernel.org, andrew@lunn.ch, hkallweit1@gmail.com, ojeda@kernel.org, alex.gaynor@gmail.com, bjorn3_gh@protonmail.com, benno.lossin@proton.me, a.hindborg@samsung.com, anna-maria@linutronix.de, frederic@kernel.org, tglx@linutronix.de, arnd@arndb.de, jstultz@google.com, sboyd@kernel.org, mingo@redhat.com, peterz@infradead.org, juri.lelli@redhat.com, vincent.guittot@linaro.org, dietmar.eggemann@arm.com, rostedt@goodmis.org, bsegall@google.com, mgorman@suse.de, vschneid@redhat.com, tgunders@redhat.com Subject: [PATCH v10 2/8] rust: time: Add PartialEq/Eq/PartialOrd/Ord trait to Ktime Date: Fri, 7 Feb 2025 22:26:17 +0900 Message-ID: <20250207132623.168854-3-fujita.tomonori@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20250207132623.168854-1-fujita.tomonori@gmail.com> References: <20250207132623.168854-1-fujita.tomonori@gmail.com> Precedence: bulk X-Mailing-List: netdev@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Add PartialEq/Eq/PartialOrd/Ord trait to Ktime so two Ktime instances can be compared to determine whether a timeout is met or not. Use the derive implements; we directly touch C's ktime_t rather than using the C's accessors because it is more efficient and we already do in the existing code (Ktime::sub). Reviewed-by: Trevor Gross Reviewed-by: Alice Ryhl Reviewed-by: Gary Guo Reviewed-by: Fiona Behrens Signed-off-by: FUJITA Tomonori --- rust/kernel/time.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rust/kernel/time.rs b/rust/kernel/time.rs index 379c0f5772e5..48b71e6641ce 100644 --- a/rust/kernel/time.rs +++ b/rust/kernel/time.rs @@ -27,7 +27,7 @@ pub fn msecs_to_jiffies(msecs: Msecs) -> Jiffies { /// A Rust wrapper around a `ktime_t`. #[repr(transparent)] -#[derive(Copy, Clone)] +#[derive(Copy, Clone, PartialEq, PartialOrd, Eq, Ord)] pub struct Ktime { inner: bindings::ktime_t, } From patchwork Fri Feb 7 13:26:18 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: FUJITA Tomonori X-Patchwork-Id: 13964976 Received: from mail-pl1-f174.google.com (mail-pl1-f174.google.com [209.85.214.174]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C16CF1A5BB1; Fri, 7 Feb 2025 13:31:49 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.174 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738935111; cv=none; b=c7yXQOuDMhvFCo8SL/gdYfvZqD+vGYdC34hkFegL4IsIqs18SHSZx66a7ZK6HeipMCjxTanpavGF1zLRrBYURHsjdeyt3cY2+e5F1uCSCSnUeLrlqx4sp37+C05OAvHckAUidmxBoFVb4NN7/jxqDy6U0BJ5Jb3cJ9cwPicMdBg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738935111; c=relaxed/simple; bh=v/wkh9kr1o8bPZhLstlnmZubIhj6xBoQq+qlOb9ycKA=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=HIlssRFYs4o9/D2EgIrgXmYkX1M+mDVhZG0QyLxtwzKn12AB+7iWhQ4TQtmfT393SvLzhZuz24sLvX+HnIV5tJcubIMu9+OEghkk6Er63suxYzmHinpMd8pmJwqvgEYivR/ptaG32HNKM61fCCHRmoOVgjSYaGNdENQQ+6pJM8Y= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=lgmOgSHQ; arc=none smtp.client-ip=209.85.214.174 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="lgmOgSHQ" Received: by mail-pl1-f174.google.com with SMTP id d9443c01a7336-2166f1e589cso52385495ad.3; Fri, 07 Feb 2025 05:31:49 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1738935109; x=1739539909; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=cj8NIj61MhF1K2//dHDrnbWqun0z8imxzp8+ulm+riQ=; b=lgmOgSHQNk58P+50d5OCwC/Nq75tUVORAzx+Q6D5+vcHT3PHBGHWHw8OVlDyaVvmY5 7zY1j9OzskNb1FZv7O9GGCIf9+MTZbTruzUVfMSW5kxYnp+h5DhZR43BvTncr0T3+t8s 6jawBCSLtNX20qKTP6sNgHVuCKPm1izPTQLhyIX0wBpUr0POvTDVa5nkkXQub7V6MFjP Ck9x0GtW9Ut+LEPRaK6jU++HT7ZT+YUAdxeeH3cxcqL06+w74/6I6Oe19PCNrPC4AfSg PaLrHW4Gqtaqvbzt9olBl95pAyG/YgK2l943dhC77GiV3LMlglMrnDPSC+Lhahr+bL7v bEhA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1738935109; x=1739539909; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=cj8NIj61MhF1K2//dHDrnbWqun0z8imxzp8+ulm+riQ=; b=xT+Cnxw4oRMBCdRXo6xuerQShBwOPm3PE4neXrG7LAQ0xncBZ/hoRYYH8/T1Lr3H1J 2dLi4DWZJWheixaKRmkY6PYrHRZDiGIbXp3wsTYWeAQ4NVipDQM2jHp9fEEmjo6wAeqq RvyrBpmbQiISWLrVpyupCDze5tf7XbSILnrFUcrK1cGZaOV4ZezyjHhTHVJO2a+tE+mO OpoO/yyqCkj94hBk3MlytrgjUhyxQJlhmGFNHsvJ/QmJ6OxiGYJUyoXGtadJz5pHtSBT Mm4/QTccWSjOq9QG7A/np0nX+ALXknmCYv+ymzaERcc2VFOUjA9vueQR/0hb0AwkZiY3 HIDA== X-Forwarded-Encrypted: i=1; AJvYcCUwbrJuotJESXn8qyRgeg5V+zBc3RoskLJxVV3aUc9CjLrJKIyYTW3mhcw+FJI0X64Z3tCx+WfFZgsRHkYABIQ=@vger.kernel.org, AJvYcCUxjmnf7c+nEFcQ0JG9sDbcDxgPOS4PIKoZ7+MWJaSlrlgpis3/hvWBstHTlpA0f/p3qHpmvvE=@vger.kernel.org X-Gm-Message-State: AOJu0YzERplZrrEUXWQXODc74iB4EizO4oPPLTQ05F1aeu4p5QbG5KvX y/ObUnvn2g/bp7y67qLS2Z0kOYLNyZ+VnzJd8l7R6/EheNe7x1M6yRDq3d/D X-Gm-Gg: ASbGncs/xeC/fulO+GAQ2tgumw77OUPgybRklcm3q2lVDnCa5jWi8FcGlO7LTpiiy7G CNkByKxwE+So+nxfXneVCMg4iFdHk4HbombFXWn0sxBOX0yWhqU35jstMkHfsv9QyoxJQ07V98Q MLTmct3cgbdUDvRepi7pGrXrDZsWJyvW06eeeBJLnnCiZWEWjqIDcXqNgyGWasuAJBLTMrnxhkB lDWbgUou03NZEJ5QJ7rFau0HKOQNOi7/gLUiQM4Fn22iZnbNeUqc1GFZX9Pqe3WLWGXjZOZoHVI BT85nUWwmPx7/u6RrHzeMoRzkMzjF2hO8ye84BtthhaoXDdQDXgvCQaiFErPzeTwwYI= X-Google-Smtp-Source: AGHT+IE8T9P7QTcwxMiIQY3V8PR1OxE5QCTkFUNALDy/74PLsQApqSBIkxe5Gmqm/V4cpV9KXJZQLQ== X-Received: by 2002:a05:6a20:c90a:b0:1ed:aca6:8dd4 with SMTP id adf61e73a8af0-1ee03a9ad11mr5727957637.19.1738935108702; Fri, 07 Feb 2025 05:31:48 -0800 (PST) Received: from mew.. (p3882177-ipxg22501hodogaya.kanagawa.ocn.ne.jp. [180.15.148.177]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-ad51ea79a47sm2877843a12.76.2025.02.07.05.31.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 07 Feb 2025 05:31:48 -0800 (PST) From: FUJITA Tomonori To: linux-kernel@vger.kernel.org Cc: Andrew Lunn , Alice Ryhl , Gary Guo , Fiona Behrens , rust-for-linux@vger.kernel.org, netdev@vger.kernel.org, hkallweit1@gmail.com, tmgross@umich.edu, ojeda@kernel.org, alex.gaynor@gmail.com, bjorn3_gh@protonmail.com, benno.lossin@proton.me, a.hindborg@samsung.com, anna-maria@linutronix.de, frederic@kernel.org, tglx@linutronix.de, arnd@arndb.de, jstultz@google.com, sboyd@kernel.org, mingo@redhat.com, peterz@infradead.org, juri.lelli@redhat.com, vincent.guittot@linaro.org, dietmar.eggemann@arm.com, rostedt@goodmis.org, bsegall@google.com, mgorman@suse.de, vschneid@redhat.com, tgunders@redhat.com Subject: [PATCH v10 3/8] rust: time: Introduce Delta type Date: Fri, 7 Feb 2025 22:26:18 +0900 Message-ID: <20250207132623.168854-4-fujita.tomonori@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20250207132623.168854-1-fujita.tomonori@gmail.com> References: <20250207132623.168854-1-fujita.tomonori@gmail.com> Precedence: bulk X-Mailing-List: netdev@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Introduce a type representing a span of time. Define our own type because `core::time::Duration` is large and could panic during creation. time::Ktime could be also used for time duration but timestamp and timedelta are different so better to use a new type. i64 is used instead of u64 to represent a span of time; some C drivers uses negative Deltas and i64 is more compatible with Ktime using i64 too (e.g., ktime_[us|ms]_delta() APIs return i64 so we create Delta object without type conversion. i64 is used instead of bindings::ktime_t because when the ktime_t type is used as timestamp, it represents values from 0 to KTIME_MAX, which is different from Delta. as_millis() method isn't used in this patchset. It's planned to be used in Binder driver. Reviewed-by: Andrew Lunn Reviewed-by: Alice Ryhl Reviewed-by: Gary Guo Reviewed-by: Fiona Behrens Signed-off-by: FUJITA Tomonori --- rust/kernel/time.rs | 88 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 88 insertions(+) diff --git a/rust/kernel/time.rs b/rust/kernel/time.rs index 48b71e6641ce..622cd01e24d7 100644 --- a/rust/kernel/time.rs +++ b/rust/kernel/time.rs @@ -8,9 +8,15 @@ //! C header: [`include/linux/jiffies.h`](srctree/include/linux/jiffies.h). //! C header: [`include/linux/ktime.h`](srctree/include/linux/ktime.h). +/// The number of nanoseconds per microsecond. +pub const NSEC_PER_USEC: i64 = bindings::NSEC_PER_USEC as i64; + /// The number of nanoseconds per millisecond. pub const NSEC_PER_MSEC: i64 = bindings::NSEC_PER_MSEC as i64; +/// The number of nanoseconds per second. +pub const NSEC_PER_SEC: i64 = bindings::NSEC_PER_SEC as i64; + /// The time unit of Linux kernel. One jiffy equals (1/HZ) second. pub type Jiffies = crate::ffi::c_ulong; @@ -81,3 +87,85 @@ fn sub(self, other: Ktime) -> Ktime { } } } + +/// A span of time. +/// +/// This struct represents a span of time, with its value stored as nanoseconds. +/// The value can represent any valid i64 value, including negative, zero, and +/// positive numbers. +#[derive(Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Debug)] +pub struct Delta { + nanos: i64, +} + +impl Delta { + /// A span of time equal to zero. + pub const ZERO: Self = Self { nanos: 0 }; + + /// Create a new [`Delta`] from a number of microseconds. + /// + /// The `micros` can range from -9_223_372_036_854_775 to 9_223_372_036_854_775. + /// If `micros` is outside this range, `i64::MIN` is used for negative values, + /// and `i64::MAX` is used for positive values due to saturation. + #[inline] + pub const fn from_micros(micros: i64) -> Self { + Self { + nanos: micros.saturating_mul(NSEC_PER_USEC), + } + } + + /// Create a new [`Delta`] from a number of milliseconds. + /// + /// The `millis` can range from -9_223_372_036_854 to 9_223_372_036_854. + /// If `millis` is outside this range, `i64::MIN` is used for negative values, + /// and `i64::MAX` is used for positive values due to saturation. + #[inline] + pub const fn from_millis(millis: i64) -> Self { + Self { + nanos: millis.saturating_mul(NSEC_PER_MSEC), + } + } + + /// Create a new [`Delta`] from a number of seconds. + /// + /// The `secs` can range from -9_223_372_036 to 9_223_372_036. + /// If `secs` is outside this range, `i64::MIN` is used for negative values, + /// and `i64::MAX` is used for positive values due to saturation. + #[inline] + pub const fn from_secs(secs: i64) -> Self { + Self { + nanos: secs.saturating_mul(NSEC_PER_SEC), + } + } + + /// Return `true` if the [`Delta`] spans no time. + #[inline] + pub fn is_zero(self) -> bool { + self.as_nanos() == 0 + } + + /// Return `true` if the [`Delta`] spans a negative amount of time. + #[inline] + pub fn is_negative(self) -> bool { + self.as_nanos() < 0 + } + + /// Return the number of nanoseconds in the [`Delta`]. + #[inline] + pub const fn as_nanos(self) -> i64 { + self.nanos + } + + /// Return the smallest number of microseconds greater than or equal + /// to the value in the [`Delta`]. + #[inline] + pub const fn as_micros_ceil(self) -> i64 { + self.as_nanos().saturating_add(NSEC_PER_USEC - 1) / NSEC_PER_USEC + } + + /// Return the number of milliseconds in the [`Delta`]. + #[inline] + pub const fn as_millis(self) -> i64 { + self.as_nanos() / NSEC_PER_MSEC + } +} From patchwork Fri Feb 7 13:26:19 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: FUJITA Tomonori X-Patchwork-Id: 13964977 Received: from mail-pl1-f171.google.com (mail-pl1-f171.google.com [209.85.214.171]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E37421F7575; Fri, 7 Feb 2025 13:31:58 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.171 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738935120; cv=none; b=aB6FscETk9H4wDGqxkjrj/5WcFd9p56/Chvhmko0te5W+YbJYNQr4y2GMYBns17fUDA/Ko0eWYU9ZrNDwozw8Ai8NcCdWo0pmb65wzZWS0YHhgh+D9Uy1DztyFVk4if839Uav+4mXSDzs/H4yqAKNJEMv7Z4gAL9Jv1Dm0oAVKw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738935120; c=relaxed/simple; bh=tkxX2CG2orzaTnWrp0cyRIUHv6uwgeKEZY/HfCxkTrk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=pcPqiSNM6g3Or4McKl+5qbyI+x7ytAlrZS7tLjlzPkR4z8XEseJhvMlyWa0N4FfxCbrlZmN9nfiofCc9p0y7OWo9BhJEjnW4u5S7LQV952pIqsagwQPRa91o6v8OhWDqoLyxAsj6okZ4mciEH+ac6RwzouxfqMz2V01toWl/2Ok= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=kPnEHZMw; arc=none smtp.client-ip=209.85.214.171 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="kPnEHZMw" Received: by mail-pl1-f171.google.com with SMTP id d9443c01a7336-21670dce0a7so48612775ad.1; Fri, 07 Feb 2025 05:31:58 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1738935118; x=1739539918; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=iFYCZZuPRIZuvCHcVAdtpHrS6egFrahgsjkjSvHAJYk=; b=kPnEHZMwBPBH4vTyIPxtAy6+tgZOMEz4HMbb43G7j2exdCLu732AUyeOj0hknx13G5 ovdENPHaN3yT0kt9ZY1x1DODcxouLldCTuA+AeidTE8P6sD9ZhVSDRlfOuG3wy4dXqep 6euabecOSfUVFdWGnplZTz1H18hEa4mPQkOTDL6wBuf/khD/ASJsa2d6narISM4phYBz 4VXzUUqm5e0onRQOVjfTXgYLG+tEatq7eI4NazpNIEgGkWtJnPyqEdVRrdoPz6JkW+O6 YHHIwQyiaKSrHKueKFmlVs5JGPxo6eFgq5WccjtDYM/bWh+ULSMq/OCfhTKyChig7ufH iEQA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1738935118; x=1739539918; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=iFYCZZuPRIZuvCHcVAdtpHrS6egFrahgsjkjSvHAJYk=; b=KJR3CXThCzQOf2KvFqY7rbvFcR4JMYTEIUdjQ/pumUud43C2PJyi1ngenog7FN5l9m KQ7LxMlvyI6D0toyfOqXo9JvJ1yKQHm9vn2eAj6Ht8exRo0NyuWYioJoHgJ0jFP4Up2J cnmSZeqYL8ZQ2WrX3+/IVqbilihV5Viw5VmoyRJKGmzv7ORUNigdKMUxMjJPckiazfh2 Wu9Dzx5vTy+zFj7JV5XfYrtCUj/tzKs0h7+D/CYYmTsgVWoY7YZmT2r2cIt5ySfsOuxb x6k/WlbypTV0HnSIFY2O/nPoLxx7pRM+Vk9lOvHvaI3i3GD0c+S7fghN2BzsBNY7T/gh H4Xg== X-Forwarded-Encrypted: i=1; AJvYcCUdylcK7q88ZUAh5c85mEALNNvObxpyG2jyEwp37r3iqc3UPzMShYUWGIr3pHV6Ur18WKWGiLbdKhOhsQ224Vg=@vger.kernel.org, AJvYcCV5IDmFvuodnNAU9NAECpMnzEVbMWwzzC5sqKWrL+UUcg2FXEGWm016mf0NmahPNJkScOEW1iY=@vger.kernel.org X-Gm-Message-State: AOJu0YxB7LkP3grC0ebWNQZsqW2f/dXVLB0BXd1TxPNUr65EsCvD50gY cTRQmjmx2Cb8U7UtKSb6rNuajsdnpgUvqmptk+jw3bU/QXEb3O5xYHKilKTF X-Gm-Gg: ASbGncutKX9vXWXV39UyKX+vsJrSy2VoN34OXZ0PJYgx2YhyFMP2dqcB5AmLAxYaWhP c8qx8AV6zONTgjnYRjdAxqI4dIDDihlNcndqxSLr4MbhtY9hmJ+9vEbXrfrJE3lUcfLP4yDmj1M tukPrX65nquc29qBi5v/4qE68YGmDEJkN7J4tg4ZWwZdmgQEYhoICyuhNUO2tMUx2/U8r0I02oa yXHsP1HhD+ijpFt/13pgxQS4Jeu/1YmgzIRKlaKi5d5y+5DMQL0Xu1nHtrUSK5VAjuy+zAc4iXW WsjFVTmZDC8tMryNwYXJGJUAXb94qOw9yByCC7Rz90kfZmRh84xixEzm2QWzU4wcNnQ= X-Google-Smtp-Source: AGHT+IEwez1doH7I2JYz3hgpJz1XgrqvXlZONG1xIqx3m/yRFH0PBiG4dWyQCDtYDJOmS9jCBfNL1Q== X-Received: by 2002:a05:6a21:9017:b0:1ed:a812:c3b with SMTP id adf61e73a8af0-1ee03a1db85mr7026491637.2.1738935116421; Fri, 07 Feb 2025 05:31:56 -0800 (PST) Received: from mew.. (p3882177-ipxg22501hodogaya.kanagawa.ocn.ne.jp. [180.15.148.177]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-ad51ea79a47sm2877843a12.76.2025.02.07.05.31.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 07 Feb 2025 05:31:56 -0800 (PST) From: FUJITA Tomonori To: linux-kernel@vger.kernel.org Cc: Boqun Feng , Gary Guo , Fiona Behrens , rust-for-linux@vger.kernel.org, netdev@vger.kernel.org, andrew@lunn.ch, hkallweit1@gmail.com, tmgross@umich.edu, ojeda@kernel.org, alex.gaynor@gmail.com, bjorn3_gh@protonmail.com, benno.lossin@proton.me, a.hindborg@samsung.com, aliceryhl@google.com, anna-maria@linutronix.de, frederic@kernel.org, tglx@linutronix.de, arnd@arndb.de, jstultz@google.com, sboyd@kernel.org, mingo@redhat.com, peterz@infradead.org, juri.lelli@redhat.com, vincent.guittot@linaro.org, dietmar.eggemann@arm.com, rostedt@goodmis.org, bsegall@google.com, mgorman@suse.de, vschneid@redhat.com, tgunders@redhat.com Subject: [PATCH v10 4/8] rust: time: Introduce Instant type Date: Fri, 7 Feb 2025 22:26:19 +0900 Message-ID: <20250207132623.168854-5-fujita.tomonori@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20250207132623.168854-1-fujita.tomonori@gmail.com> References: <20250207132623.168854-1-fujita.tomonori@gmail.com> Precedence: bulk X-Mailing-List: netdev@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Introduce a type representing a specific point in time. We could use the Ktime type but C's ktime_t is used for both timestamp and timedelta. To avoid confusion, introduce a new Instant type for timestamp. Rename Ktime to Instant and modify their methods for timestamp. Implement the subtraction operator for Instant: Delta = Instant A - Instant B Reviewed-by: Boqun Feng Reviewed-by: Gary Guo Reviewed-by: Fiona Behrens Signed-off-by: FUJITA Tomonori --- rust/kernel/time.rs | 77 +++++++++++++++++++++++---------------------- 1 file changed, 39 insertions(+), 38 deletions(-) diff --git a/rust/kernel/time.rs b/rust/kernel/time.rs index 622cd01e24d7..d64a05a4f4d1 100644 --- a/rust/kernel/time.rs +++ b/rust/kernel/time.rs @@ -5,6 +5,22 @@ //! This module contains the kernel APIs related to time and timers that //! have been ported or wrapped for usage by Rust code in the kernel. //! +//! There are two types in this module: +//! +//! - The [`Instant`] type represents a specific point in time. +//! - The [`Delta`] type represents a span of time. +//! +//! Note that the C side uses `ktime_t` type to represent both. However, timestamp +//! and timedelta are different. To avoid confusion, we use two different types. +//! +//! A [`Instant`] object can be created by calling the [`Instant::now()`] function. +//! It represents a point in time at which the object was created. +//! By calling the [`Instant::elapsed()`] method, a [`Delta`] object representing +//! the elapsed time can be created. The [`Delta`] object can also be created +//! by subtracting two [`Instant`] objects. +//! +//! A [`Delta`] type supports methods to retrieve the duration in various units. +//! //! C header: [`include/linux/jiffies.h`](srctree/include/linux/jiffies.h). //! C header: [`include/linux/ktime.h`](srctree/include/linux/ktime.h). @@ -31,59 +47,44 @@ pub fn msecs_to_jiffies(msecs: Msecs) -> Jiffies { unsafe { bindings::__msecs_to_jiffies(msecs) } } -/// A Rust wrapper around a `ktime_t`. +/// A specific point in time. +/// +/// # Invariants +/// +/// The `inner` value is in the range from 0 to `KTIME_MAX`. #[repr(transparent)] #[derive(Copy, Clone, PartialEq, PartialOrd, Eq, Ord)] -pub struct Ktime { +pub struct Instant { inner: bindings::ktime_t, } -impl Ktime { - /// Create a `Ktime` from a raw `ktime_t`. - #[inline] - pub fn from_raw(inner: bindings::ktime_t) -> Self { - Self { inner } - } - +impl Instant { /// Get the current time using `CLOCK_MONOTONIC`. #[inline] - pub fn ktime_get() -> Self { - // SAFETY: It is always safe to call `ktime_get` outside of NMI context. - Self::from_raw(unsafe { bindings::ktime_get() }) - } - - /// Divide the number of nanoseconds by a compile-time constant. - #[inline] - fn divns_constant(self) -> i64 { - self.to_ns() / DIV - } - - /// Returns the number of nanoseconds. - #[inline] - pub fn to_ns(self) -> i64 { - self.inner + pub fn now() -> Self { + // INVARIANT: The `ktime_get()` function returns a value in the range + // from 0 to `KTIME_MAX`. + Self { + // SAFETY: It is always safe to call `ktime_get()` outside of NMI context. + inner: unsafe { bindings::ktime_get() }, + } } - /// Returns the number of milliseconds. + /// Return the amount of time elapsed since the [`Instant`]. #[inline] - pub fn to_ms(self) -> i64 { - self.divns_constant::() + pub fn elapsed(&self) -> Delta { + Self::now() - *self } } -/// Returns the number of milliseconds between two ktimes. -#[inline] -pub fn ktime_ms_delta(later: Ktime, earlier: Ktime) -> i64 { - (later - earlier).to_ms() -} - -impl core::ops::Sub for Ktime { - type Output = Ktime; +impl core::ops::Sub for Instant { + type Output = Delta; + // By the type invariant, it never overflows. #[inline] - fn sub(self, other: Ktime) -> Ktime { - Self { - inner: self.inner - other.inner, + fn sub(self, other: Instant) -> Delta { + Delta { + nanos: self.inner - other.inner, } } } From patchwork Fri Feb 7 13:26:20 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: FUJITA Tomonori X-Patchwork-Id: 13964978 Received: from mail-pl1-f178.google.com (mail-pl1-f178.google.com [209.85.214.178]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 318341EEA5D; Fri, 7 Feb 2025 13:32:04 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.178 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738935126; cv=none; b=ARa4wBlz6ySNPmIYm4KI6SozsXetU9+6OQugdVBdEbBkkAzLGoq1c03IJxcRxFWFyzsdBQhDiD6sPiSZz4q4u99DjJmiVLZiuDoqIK85d7NJtjMnKj3geYGJV/Y1saXPspCO3JQMZhhvRoKx8B+QYmU85mpZT4o8AMlXKHZhxac= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738935126; c=relaxed/simple; bh=IjnSjBhWDp3CYU8cRoL5YbolvreL2c5kVU8dJdl02Ns=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=psbZpD06AwRkJ2TzqPjJ2cXJ1UZKUmLaldyCIeQ61UDA+dGdAgTLtwjCzU5dBl6rSMqSNT7XGUOLD4+sVVbCioYjcdJH5mTkGeZSvZBwT+gh72moacjHA+Pvf7VXrOoUe043kViFgvxppypwJWHvw6b0EXTsnNns4q0vbTN5lZ8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=kQjcA6c9; arc=none smtp.client-ip=209.85.214.178 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="kQjcA6c9" Received: by mail-pl1-f178.google.com with SMTP id d9443c01a7336-21f6022c2c3so2776305ad.0; Fri, 07 Feb 2025 05:32:04 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1738935124; x=1739539924; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=rznzjUgjcpczEk+LFFoCxRQeCpFrR9iS17ExxqZ9J80=; b=kQjcA6c9gn02RtLz8Z1w5EydkpQdZJSVjMtDtVn+UQuhNXiMq7uIyKTRMPcsr2ndeV lJcbqOee3OMPX2W8amRBAIGhS32Mhx1qxsFndqSggItQ7sGutCPryXcFiWctLnOwWo3n LjQeY71JFiQUfk+ZOwbTl6SdwxvUPwYnoiu9lYou/GWss7NLqfMTi377Ug+HZoAm8JtO b6Poue4BjKbBvAemm+W/BfLYwjlNkYkRi6WB3u9iLcqEkt+cPIuMNg4o/XvSoIxK+MBd 6mYOtV8Igqnh2Z0QiVhfmyBqxhoFli6OHpQbrlTm5KjQDmNviyj4zmHCBYbkgT2adLbW x5fw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1738935124; x=1739539924; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=rznzjUgjcpczEk+LFFoCxRQeCpFrR9iS17ExxqZ9J80=; b=P1ahY5UGdlKs+5Px09vQaudTMM0HW+58D9H2nPtZm7KIuLkvzCkZYzk9qq/yNsqWiU pF/eryPFYktw6i2IsSPyhIE0B20Kbdln8aZGCDA1ft0oED+tDEoBKHDpMPhyArzNH3wm 5tjho6aHz2NNLnDpneMoxsSs8f0kmF4HbbYfedAOuos4e1fCG+CgvjJh8j35njCp34g2 1rXIhpRvcnDYATpbof8p9mSVQXkHZyZiAfmQGyRG5w6WkLnFLBK3MwC5vhPvgWRelyOQ KiSwQ4i3iUbCD5FRtHwfB5e0KlXOSApCxn82lT/2xQ56yf0GaDFsWt2FJn/0TmbBb+/A 3zqg== X-Forwarded-Encrypted: i=1; AJvYcCU3wJHf12l4ZYk0KNqF4AXZhQOiDjCXMkdTu0m7xDo4x/F06zKaqCusvjwv//z+aRTMF8doW8I=@vger.kernel.org, AJvYcCWO9KA7iC3Egixkz1OSj4VMw03ColNo18z2EtWx9Yx8CAZ/GgFVoNVaqfZOIHYKAU4gpQTJqHNX4psEOW1ghJ8=@vger.kernel.org X-Gm-Message-State: AOJu0YxWM3vkDB5lqMKkYSdrM3qkK4jEEq1v2YarKHFqomX3ILBi1JsR QeQGKfsBE3U6fHRXEfl33O7nmzw2E6j2ZjYbNGWOTwtvQRyg0rRjz2wa3GPo X-Gm-Gg: ASbGncsiywPQzXwfXCvSnTixXdB0jOlUTCEV5bdAiQm/5iKyAhVi7SmDjxiBktl/0x4 U+gNHMLGwwH67kU3Gj8QL+4GCreoGgBiEOy8DjF+QmudEDMhVuPt37vzCKYuAmv/el1H8LdhqXu 6zb8SaW4tNanAye9aY3/wWyC1y2oxzB/S9RDfEmiu2JUfwfSGF6jSFFzyUzJsWI3A66reeisOCb dk7RPoPtAZOgnzJZcUIo/DGuGufR8pXjmLG0PqZilhoLEp1cbMG1/fQer5qVEanBnKjo96LPgdc Uap0/C4BgJ6hq3EAT+H2BcSzfH1hlp1/OfIkhbssxIp7Gw2IjCqYy22vsYinC4rWYRA= X-Google-Smtp-Source: AGHT+IGHAtCViaosKSA5Fy1JfmUfgIKoMml9Skas8g/+z7GuA1L7Uo6D7OiMI7NignqrpBB5wC+bGg== X-Received: by 2002:a17:902:cf05:b0:21f:58fd:d215 with SMTP id d9443c01a7336-21f58fdd3f8mr26923845ad.11.1738935124031; Fri, 07 Feb 2025 05:32:04 -0800 (PST) Received: from mew.. (p3882177-ipxg22501hodogaya.kanagawa.ocn.ne.jp. [180.15.148.177]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-ad51ea79a47sm2877843a12.76.2025.02.07.05.31.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 07 Feb 2025 05:32:03 -0800 (PST) From: FUJITA Tomonori To: linux-kernel@vger.kernel.org Cc: Gary Guo , Alice Ryhl , Fiona Behrens , rust-for-linux@vger.kernel.org, netdev@vger.kernel.org, andrew@lunn.ch, hkallweit1@gmail.com, tmgross@umich.edu, ojeda@kernel.org, alex.gaynor@gmail.com, bjorn3_gh@protonmail.com, benno.lossin@proton.me, a.hindborg@samsung.com, anna-maria@linutronix.de, frederic@kernel.org, tglx@linutronix.de, arnd@arndb.de, jstultz@google.com, sboyd@kernel.org, mingo@redhat.com, peterz@infradead.org, juri.lelli@redhat.com, vincent.guittot@linaro.org, dietmar.eggemann@arm.com, rostedt@goodmis.org, bsegall@google.com, mgorman@suse.de, vschneid@redhat.com, tgunders@redhat.com Subject: [PATCH v10 5/8] rust: time: Add wrapper for fsleep() function Date: Fri, 7 Feb 2025 22:26:20 +0900 Message-ID: <20250207132623.168854-6-fujita.tomonori@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20250207132623.168854-1-fujita.tomonori@gmail.com> References: <20250207132623.168854-1-fujita.tomonori@gmail.com> Precedence: bulk X-Mailing-List: netdev@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Add a wrapper for fsleep(), flexible sleep functions in include/linux/delay.h which typically deals with hardware delays. The kernel supports several sleep functions to handle various lengths of delay. This adds fsleep(), automatically chooses the best sleep method based on a duration. sleep functions including fsleep() belongs to TIMERS, not TIMEKEEPING. They are maintained separately. rust/kernel/time.rs is an abstraction for TIMEKEEPING. To make Rust abstractions match the C side, add rust/kernel/time/delay.rs for this wrapper. fsleep() can only be used in a nonatomic context. This requirement is not checked by these abstractions, but it is intended that klint [1] or a similar tool will be used to check it in the future. Link: https://rust-for-linux.com/klint [1] Reviewed-by: Gary Guo Reviewed-by: Alice Ryhl Reviewed-by: Fiona Behrens Signed-off-by: FUJITA Tomonori --- rust/helpers/helpers.c | 1 + rust/helpers/time.c | 8 +++++++ rust/kernel/time.rs | 2 ++ rust/kernel/time/delay.rs | 49 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 60 insertions(+) create mode 100644 rust/helpers/time.c create mode 100644 rust/kernel/time/delay.rs diff --git a/rust/helpers/helpers.c b/rust/helpers/helpers.c index 0640b7e115be..9565485a1a54 100644 --- a/rust/helpers/helpers.c +++ b/rust/helpers/helpers.c @@ -31,6 +31,7 @@ #include "slab.c" #include "spinlock.c" #include "task.c" +#include "time.c" #include "uaccess.c" #include "vmalloc.c" #include "wait.c" diff --git a/rust/helpers/time.c b/rust/helpers/time.c new file mode 100644 index 000000000000..7ae64ad8141d --- /dev/null +++ b/rust/helpers/time.c @@ -0,0 +1,8 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include + +void rust_helper_fsleep(unsigned long usecs) +{ + fsleep(usecs); +} diff --git a/rust/kernel/time.rs b/rust/kernel/time.rs index d64a05a4f4d1..eeb0f6a7e5d4 100644 --- a/rust/kernel/time.rs +++ b/rust/kernel/time.rs @@ -24,6 +24,8 @@ //! C header: [`include/linux/jiffies.h`](srctree/include/linux/jiffies.h). //! C header: [`include/linux/ktime.h`](srctree/include/linux/ktime.h). +pub mod delay; + /// The number of nanoseconds per microsecond. pub const NSEC_PER_USEC: i64 = bindings::NSEC_PER_USEC as i64; diff --git a/rust/kernel/time/delay.rs b/rust/kernel/time/delay.rs new file mode 100644 index 000000000000..02b8731433c7 --- /dev/null +++ b/rust/kernel/time/delay.rs @@ -0,0 +1,49 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Delay and sleep primitives. +//! +//! This module contains the kernel APIs related to delay and sleep that +//! have been ported or wrapped for usage by Rust code in the kernel. +//! +//! C header: [`include/linux/delay.h`](srctree/include/linux/delay.h). + +use super::Delta; +use crate::ffi::c_ulong; + +/// Sleeps for a given duration at least. +/// +/// Equivalent to the C side [`fsleep()`], flexible sleep function, +/// which automatically chooses the best sleep method based on a duration. +/// +/// `delta` must be within `[0, i32::MAX]` microseconds; +/// otherwise, it is erroneous behavior. That is, it is considered a bug +/// to call this function with an out-of-range value, in which case the function +/// will sleep for at least the maximum value in the range and may warn +/// in the future. +/// +/// The behavior above differs from the C side [`fsleep()`] for which out-of-range +/// values mean "infinite timeout" instead. +/// +/// This function can only be used in a nonatomic context. +/// +/// [`fsleep`]: https://docs.kernel.org/timers/delay_sleep_functions.html#c.fsleep +pub fn fsleep(delta: Delta) { + // The maximum value is set to `i32::MAX` microseconds to prevent integer + // overflow inside fsleep, which could lead to unintentional infinite sleep. + const MAX_DELTA: Delta = Delta::from_micros(i32::MAX as i64); + + let delta = if (Delta::ZERO..=MAX_DELTA).contains(&delta) { + delta + } else { + // TODO: Add WARN_ONCE() when it's supported. + MAX_DELTA + }; + + // SAFETY: It is always safe to call `fsleep()` with any duration. + unsafe { + // Convert the duration to microseconds and round up to preserve + // the guarantee; `fsleep()` sleeps for at least the provided duration, + // but that it may sleep for longer under some circumstances. + bindings::fsleep(delta.as_micros_ceil() as c_ulong) + } +} From patchwork Fri Feb 7 13:26:21 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: FUJITA Tomonori X-Patchwork-Id: 13964979 Received: from mail-pl1-f172.google.com (mail-pl1-f172.google.com [209.85.214.172]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9208A1F4186; Fri, 7 Feb 2025 13:32:12 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.172 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738935134; cv=none; b=LOLIlDSH99YpFTaEbkVQq4TH6j+LJHanYxITOSfdD2/ZrR25uVIiA70WB7uiF6GrAktK4yd+2+W8MMkCKudncE6qiF3OS2LscpeApK2Fgt1Z8/VGd9BeMyKF4OWnn14U7kCgDhSevNcOpH73n7CjWaDWtJgBpwlG/rnKd1P5Rok= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738935134; c=relaxed/simple; bh=W/xND7oeOqSyZuG0lyRIYpdb8PYTcr+3m5N/f6E0YAY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=OzTaM5Uq0nqYez1q1JsZnvCeRrRWsnqy4QoK4pgMsU6ZbQCII2lOShsZlXSCf2MfBIJ/7zWWj4EkefXZKV6VMW3AyLtZuyfWysvg6IOqT9k2DNYbXLt2YkzcwbsXY3noTFKCfFu5SFUOyjWKCQIap/FrB0XdvfbwSaiwnsI3N2o= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=VJHgrs9Y; arc=none smtp.client-ip=209.85.214.172 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="VJHgrs9Y" Received: by mail-pl1-f172.google.com with SMTP id d9443c01a7336-21f20666e72so42893735ad.1; Fri, 07 Feb 2025 05:32:12 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1738935131; x=1739539931; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=Fy5Hy6LkAGAxIDPrWVxfWAbE7bDJcs0zc4+QaIaJpio=; b=VJHgrs9YU5UPFIRjrqIgwohhG2ooJDBg0s+JLorFJIw22F7Wwl3Un2iq70dRxZl/3f 7l7KbNBruiFPCEWBcuwAtCO7GBjK60s7SSwNcJdRy+LIrhueS/a2Dd6NAUtj2aFrz9Ip uCjo2LxVvICZFhTifFs87Z+6JqL5Xkj4cxBcZvew1vvQMI6VruDJTtsH/B3PoVuO31n/ jJuSbWDDpWuaYpwXJBx7bnmSc312gPpyGICzDTQDBEDesOWdHFDigPAx0DbA4+lA1BRv PxWnLaYDes0IBPuxg15V/bJfJI1Wjhy3XFhbYnyc4UXclkDIoNj5TSj+vKWwMon84I2u 2o3g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1738935131; x=1739539931; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=Fy5Hy6LkAGAxIDPrWVxfWAbE7bDJcs0zc4+QaIaJpio=; b=TJT+ra0vDVgVz3gjCVmkhp5kDyQ6EYMdNRokrpLP1IzcD26D4oLRpkY5OOxlFdr+RK qQ051L/q+RhdctGNZ8l9gQS6SIyb2eptGYg2vBprxOAVJ4um4dGmU7qRhdGig6ROCyFU Tlr3s2xzlIMWF57ODL9rpRZUwqcyjOT8sl6Z5ahgqVDjwYBy4Npm6xkAF3PAiLvyqgaR rM7FtImxmokWQQurhAn2mGDzcbGlAc/AxDH24vLyuSDRQ7cGbN1MUGlwYe39rUFcsC3V Au4AqHELS4Jp+zEu0PGGVCfRI7zDQaZEkZnlvmrK8p/tkw/efDyuGZiFC8k1SACPDIpm qXdQ== X-Forwarded-Encrypted: i=1; AJvYcCWnbzS8CzVgO9ZNSiGNC1NvSRtPW9fRecYhXudGC7VY2WY4NX2zz6DbFXdBIdSJOV13Y/rbsxA=@vger.kernel.org X-Gm-Message-State: AOJu0YxHHEqRRY17SqfFvEhX+YWwvLRJoRQ+70DzIp6eEwFjx+7ys7AO 4JRtypg1FKa7HxiaF8+P351JmfU8GCuHXBkVeCqlWNqgNQago+XgAowQaZ+T X-Gm-Gg: ASbGncvUdWkflXc66fN1TA2FbFzpSOl3yaRRMD+iql0MapvbqhvXOLOmIB1zDR52Krk YbJbzNMeoERpfa61jyvpv+ZSWG86QyAuTKEqyLltXtgJHs4V85SRFET+wq0WTitjse3nD9Cxkpi Y6/lp8EuzGgcqypbZRaiwNGE2GYh5rbw0yXEWHW/qGyTDQftSSaMtU0KHjr6RkLAn3MHYuk1qMZ 4avaD1yZf4aZhAOQo6/jF7kAyNA8AoNdxHEBzH1aqueyn1nkqDX+TDFDFgfkk4pmyDK0+jq0o+V TeNaNgBsfZgZ0OE7+DLGstp7znasVBeq83L08RMiThwtB6PsqtgL6dcoP8GncPgzP38= X-Google-Smtp-Source: AGHT+IHdyLlWC3x6DmOvH0dr+XHTfI1t9rk5NvgYdws/iiUCWHn6IT5fkEAHlJ0PoEd2WSEJseQTGA== X-Received: by 2002:a05:6a20:438c:b0:1e4:80a9:b8fa with SMTP id adf61e73a8af0-1ee03a4149amr7173803637.13.1738935131624; Fri, 07 Feb 2025 05:32:11 -0800 (PST) Received: from mew.. (p3882177-ipxg22501hodogaya.kanagawa.ocn.ne.jp. [180.15.148.177]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-ad51ea79a47sm2877843a12.76.2025.02.07.05.32.04 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 07 Feb 2025 05:32:11 -0800 (PST) From: FUJITA Tomonori To: linux-kernel@vger.kernel.org Cc: rust-for-linux@vger.kernel.org, netdev@vger.kernel.org, andrew@lunn.ch, hkallweit1@gmail.com, tmgross@umich.edu, ojeda@kernel.org, alex.gaynor@gmail.com, gary@garyguo.net, bjorn3_gh@protonmail.com, benno.lossin@proton.me, a.hindborg@samsung.com, aliceryhl@google.com, anna-maria@linutronix.de, frederic@kernel.org, tglx@linutronix.de, arnd@arndb.de, jstultz@google.com, sboyd@kernel.org, mingo@redhat.com, peterz@infradead.org, juri.lelli@redhat.com, vincent.guittot@linaro.org, dietmar.eggemann@arm.com, rostedt@goodmis.org, bsegall@google.com, mgorman@suse.de, vschneid@redhat.com, tgunders@redhat.com, me@kloenk.dev Subject: [PATCH v10 6/8] MAINTAINERS: rust: Add TIMEKEEPING and TIMER abstractions Date: Fri, 7 Feb 2025 22:26:21 +0900 Message-ID: <20250207132623.168854-7-fujita.tomonori@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20250207132623.168854-1-fujita.tomonori@gmail.com> References: <20250207132623.168854-1-fujita.tomonori@gmail.com> Precedence: bulk X-Mailing-List: netdev@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Add Rust TIMEKEEPING and TIMER abstractions to the maintainers entry respectively. Signed-off-by: FUJITA Tomonori --- MAINTAINERS | 2 ++ 1 file changed, 2 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index c8d9e8187eb0..987a25550853 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -10353,6 +10353,7 @@ F: kernel/time/sleep_timeout.c F: kernel/time/timer.c F: kernel/time/timer_list.c F: kernel/time/timer_migration.* +F: rust/kernel/time/delay.rs F: tools/testing/selftests/timers/ HIGH-SPEED SCC DRIVER FOR AX.25 @@ -23852,6 +23853,7 @@ F: kernel/time/timeconv.c F: kernel/time/timecounter.c F: kernel/time/timekeeping* F: kernel/time/time_test.c +F: rust/kernel/time.rs F: tools/testing/selftests/timers/ TIPC NETWORK LAYER From patchwork Fri Feb 7 13:26:22 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: FUJITA Tomonori X-Patchwork-Id: 13964980 Received: from mail-pj1-f52.google.com (mail-pj1-f52.google.com [209.85.216.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5BFAD1F8AC5; Fri, 7 Feb 2025 13:32:20 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.52 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738935142; cv=none; b=ZdYAjZZUWg8nbKx+3gxTpgSo4CqPrMP6lGoxrgB36gzLCm9idfNSqrWyQ2IJmxU5zQuRvUeBs7glFRVs8ZHhPZ3Hn2sUeOG3vKqiDD2S1yzNfNDHd252AGQIPA4YHHIP5pu3PuIYAd4KY6f2lEjlkTnjP047tdrwu7e1nK2ol08= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738935142; c=relaxed/simple; bh=v0/zs/7L8bwSFmjJxmLHdRbKmb6DzaP8vuBcY/3qOd0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=cY6qCBIlUXlO3mBL1cI7F2rY5qVFHaHhhU4ouwbV0aK9RIAM3LKMn7/piP/CvnCFXGt/9S3dVll0KuXvMs8TstEc3IwhFN7+6r8DWRTcXioXw3B9ynbPgTRwuPgUq0T/lQGkGEERSqXJW7tWjkHDfRi2vGtJwgB3QSp1O0D/U3g= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=Uxe451xQ; arc=none smtp.client-ip=209.85.216.52 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="Uxe451xQ" Received: by mail-pj1-f52.google.com with SMTP id 98e67ed59e1d1-2fa286ea7e8so890167a91.2; Fri, 07 Feb 2025 05:32:20 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1738935139; x=1739539939; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=N/CQPGUILpT2aVlfr51p5lQWXt1hrLdHEOmb9TvWFrc=; b=Uxe451xQrhoeKn6KhxXzGbGhMNL3zjkPjtGMIA5tLjmGOQBZpioRtLwqL7vAbLaRlm sqt9gMEf3kCGnfoOF2U9LOkoax0lMyz7a+GahZRLpv0lXUXTwK4y5wlnVtJfXgIXvTk4 zp/kN1RIiqq/Xh44VYtdL1gSMY5ryLoGUVjT8xPvxqlQ6K+nD44jgJU3QL2+WM52Gb8n pH47t9umD6KxPvXJ7ZPa16/sVjhDpyxhmgME3g3BasrlT/Ep5Pz100wrMHa6X8L1mmph XTRtRAefyOpXIYJJBuNYnBgmbHViY9DRws86BbjmaSDWQB2m1BM7rTuHQprtcpXzFXT5 rBGg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1738935139; x=1739539939; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=N/CQPGUILpT2aVlfr51p5lQWXt1hrLdHEOmb9TvWFrc=; b=uMKkAhgHLjc2r4m9c0sYsKrrIJsT5ChI7L4/y64di/L4OrByQ7uDlgCbW9QKsjnbYd 9yKVLiUfzdz9EeN1u6IYOmyi3Bi3QgHj5UOX98CtKztDpRZFAfV4zxf7jq/gK73N11AR ECZeSruKDr+8tQbDy0YuMm8Ib8z8pL/neSEHUgbJqHWUR3VnrkGtfbigP9YJEwHHcRyU d59dEhad7zpjlqN7cv0ujY2+CUo5Rp82KE8xtiau1hmDdfLPcFtGIyczppkCjlR03GCC HBENljF1zoAubDqv3A7mx7mzHwX0yT2wKLF1F8veaKgxcoec979pXAWURflXs7Y0ZiKu yTMQ== X-Forwarded-Encrypted: i=1; AJvYcCXSlJC9GTsWkT1MzarDetkIt7soAIVeekZYC74vNEHOyj3MFvupPm2lUcoGq7DMGL3xIxKgcXE=@vger.kernel.org X-Gm-Message-State: AOJu0YxkdlGpRWo4i4p0FomAn8kgaLcq/l2mCyLwU/ZFj4Mg8p6D7DFm JhLad6Q4IsrSTzKG2EvGcn8ybcp5h+56WI3E6fUr3048GWaJ03zrF+X8aSo7 X-Gm-Gg: ASbGnctXvJwWLKlZXlvuDvppu5KQUKtYcQL4PCYHZM7gh8EKb54p4uqTqEEi2HZOCXv +09xzF2Q48ps/U+L9O8W5P+aext6lcMRW6hLGNk2M0b3xMMdB2PAVGLQ94Uh9knIXgDEFV6EgcA YnxKQIodpY6OZcQxzBSh0EvotdHGzrbxgI3WDcq2wC9o7P3VzZpcJOrrjxgqdzNIdZyhrCa38Do XUrGfFUhBti/kIDw1MAf1ahgRVJ8bPdtU6FbI0wBUolum049ILUK9DTJgL4KQqpNvAYStjcC4+a U3bgMdeeuRUJk+WsGdx3YFHvs9VWePy46TavOS+AQnV2og+/PUnvQcwNE/E5xr8MuZo= X-Google-Smtp-Source: AGHT+IHgviYp4+ArDLcILpmI3kJBYqbvyXTD6Y0du8v7EkUsIDf6r1GVgzuDg4DXX4ibVkBWm6q+5g== X-Received: by 2002:aa7:88cb:0:b0:72f:d7ce:500f with SMTP id d2e1a72fcca58-7305d525eb4mr5269278b3a.21.1738935139220; Fri, 07 Feb 2025 05:32:19 -0800 (PST) Received: from mew.. (p3882177-ipxg22501hodogaya.kanagawa.ocn.ne.jp. [180.15.148.177]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-ad51ea79a47sm2877843a12.76.2025.02.07.05.32.12 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 07 Feb 2025 05:32:18 -0800 (PST) From: FUJITA Tomonori To: linux-kernel@vger.kernel.org Cc: rust-for-linux@vger.kernel.org, netdev@vger.kernel.org, andrew@lunn.ch, hkallweit1@gmail.com, tmgross@umich.edu, ojeda@kernel.org, alex.gaynor@gmail.com, gary@garyguo.net, bjorn3_gh@protonmail.com, benno.lossin@proton.me, a.hindborg@samsung.com, aliceryhl@google.com, anna-maria@linutronix.de, frederic@kernel.org, tglx@linutronix.de, arnd@arndb.de, jstultz@google.com, sboyd@kernel.org, mingo@redhat.com, peterz@infradead.org, juri.lelli@redhat.com, vincent.guittot@linaro.org, dietmar.eggemann@arm.com, rostedt@goodmis.org, bsegall@google.com, mgorman@suse.de, vschneid@redhat.com, tgunders@redhat.com, me@kloenk.dev Subject: [PATCH v10 7/8] rust: Add read_poll_timeout functions Date: Fri, 7 Feb 2025 22:26:22 +0900 Message-ID: <20250207132623.168854-8-fujita.tomonori@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20250207132623.168854-1-fujita.tomonori@gmail.com> References: <20250207132623.168854-1-fujita.tomonori@gmail.com> Precedence: bulk X-Mailing-List: netdev@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Add read_poll_timeout functions which poll periodically until a condition is met or a timeout is reached. The C's read_poll_timeout (include/linux/iopoll.h) is a complicated macro and a simple wrapper for Rust doesn't work. So this implements the same functionality in Rust. The C version uses usleep_range() while the Rust version uses fsleep(), which uses the best sleep method so it works with spans that usleep_range() doesn't work nicely with. Unlike the C version, __might_sleep() is used instead of might_sleep() to show proper debug info; the file name and line number. might_resched() could be added to match what the C version does but this function works without it. The sleep_before_read argument isn't supported since there is no user for now. It's rarely used in the C version. read_poll_timeout() can only be used in a nonatomic context. This requirement is not checked by these abstractions, but it is intended that klint [1] or a similar tool will be used to check it in the future. Link: https://rust-for-linux.com/klint [1] Signed-off-by: FUJITA Tomonori --- rust/helpers/helpers.c | 1 + rust/helpers/kernel.c | 13 +++++++ rust/kernel/cpu.rs | 13 +++++++ rust/kernel/error.rs | 1 + rust/kernel/io.rs | 2 ++ rust/kernel/io/poll.rs | 78 ++++++++++++++++++++++++++++++++++++++++++ rust/kernel/lib.rs | 1 + 7 files changed, 109 insertions(+) create mode 100644 rust/helpers/kernel.c create mode 100644 rust/kernel/cpu.rs create mode 100644 rust/kernel/io/poll.rs diff --git a/rust/helpers/helpers.c b/rust/helpers/helpers.c index 9565485a1a54..16d256897ccb 100644 --- a/rust/helpers/helpers.c +++ b/rust/helpers/helpers.c @@ -14,6 +14,7 @@ #include "cred.c" #include "device.c" #include "err.c" +#include "kernel.c" #include "fs.c" #include "io.c" #include "jump_label.c" diff --git a/rust/helpers/kernel.c b/rust/helpers/kernel.c new file mode 100644 index 000000000000..9dff28f4618e --- /dev/null +++ b/rust/helpers/kernel.c @@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include + +void rust_helper_cpu_relax(void) +{ + cpu_relax(); +} + +void rust_helper___might_sleep_precision(const char *file, int len, int line) +{ + __might_sleep_precision(file, len, line); +} diff --git a/rust/kernel/cpu.rs b/rust/kernel/cpu.rs new file mode 100644 index 000000000000..eeeff4be84fa --- /dev/null +++ b/rust/kernel/cpu.rs @@ -0,0 +1,13 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Processor related primitives. +//! +//! C header: [`include/linux/processor.h`](srctree/include/linux/processor.h). + +/// Lower CPU power consumption or yield to a hyperthreaded twin processor. +/// +/// It also happens to serve as a compiler barrier. +pub fn cpu_relax() { + // SAFETY: FFI call. + unsafe { bindings::cpu_relax() } +} diff --git a/rust/kernel/error.rs b/rust/kernel/error.rs index f6ecf09cb65f..8858eb13b3df 100644 --- a/rust/kernel/error.rs +++ b/rust/kernel/error.rs @@ -64,6 +64,7 @@ macro_rules! declare_err { declare_err!(EPIPE, "Broken pipe."); declare_err!(EDOM, "Math argument out of domain of func."); declare_err!(ERANGE, "Math result not representable."); + declare_err!(ETIMEDOUT, "Connection timed out."); declare_err!(ERESTARTSYS, "Restart the system call."); declare_err!(ERESTARTNOINTR, "System call was interrupted by a signal and will be restarted."); declare_err!(ERESTARTNOHAND, "Restart if no handler."); diff --git a/rust/kernel/io.rs b/rust/kernel/io.rs index d4a73e52e3ee..be63742f517b 100644 --- a/rust/kernel/io.rs +++ b/rust/kernel/io.rs @@ -7,6 +7,8 @@ use crate::error::{code::EINVAL, Result}; use crate::{bindings, build_assert}; +pub mod poll; + /// Raw representation of an MMIO region. /// /// By itself, the existence of an instance of this structure does not provide any guarantees that diff --git a/rust/kernel/io/poll.rs b/rust/kernel/io/poll.rs new file mode 100644 index 000000000000..bed5b693402e --- /dev/null +++ b/rust/kernel/io/poll.rs @@ -0,0 +1,78 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! IO polling. +//! +//! C header: [`include/linux/iopoll.h`](srctree/include/linux/iopoll.h). + +use crate::{ + cpu::cpu_relax, + error::{code::*, Result}, + time::{delay::fsleep, Delta, Instant}, +}; + +use core::panic::Location; + +/// Polls periodically until a condition is met or a timeout is reached. +/// +/// ```rust +/// use kernel::io::poll::read_poll_timeout; +/// use kernel::time::Delta; +/// use kernel::sync::{SpinLock, new_spinlock}; +/// +/// let lock = KBox::pin_init(new_spinlock!(()), kernel::alloc::flags::GFP_KERNEL)?; +/// let g = lock.lock(); +/// read_poll_timeout(|| Ok(()), |()| true, Delta::from_micros(42), Some(Delta::from_micros(42))); +/// drop(g); +/// +/// # Ok::<(), Error>(()) +/// ``` +#[track_caller] +pub fn read_poll_timeout( + mut op: Op, + mut cond: Cond, + sleep_delta: Delta, + timeout_delta: Option, +) -> Result +where + Op: FnMut() -> Result, + Cond: FnMut(&T) -> bool, +{ + let start = Instant::now(); + let sleep = !sleep_delta.is_zero(); + + if sleep { + might_sleep(Location::caller()); + } + + loop { + let val = op()?; + if cond(&val) { + // Unlike the C version, we immediately return. + // We know the condition is met so we don't need to check again. + return Ok(val); + } + if let Some(timeout_delta) = timeout_delta { + if start.elapsed() > timeout_delta { + // Unlike the C version, we immediately return. + // We have just called `op()` so we don't need to call it again. + return Err(ETIMEDOUT); + } + } + if sleep { + fsleep(sleep_delta); + } + // fsleep() could be busy-wait loop so we always call cpu_relax(). + cpu_relax(); + } +} + +fn might_sleep(loc: &Location<'_>) { + // SAFETY: FFI call. + unsafe { + crate::bindings::__might_sleep_precision( + loc.file().as_ptr().cast(), + loc.file().len() as i32, + loc.line() as i32, + ) + } +} diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index 496ed32b0911..415c500212dd 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -40,6 +40,7 @@ pub mod block; #[doc(hidden)] pub mod build_assert; +pub mod cpu; pub mod cred; pub mod device; pub mod device_id; From patchwork Fri Feb 7 13:26:23 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: FUJITA Tomonori X-Patchwork-Id: 13964981 X-Patchwork-Delegate: kuba@kernel.org Received: from mail-pl1-f182.google.com (mail-pl1-f182.google.com [209.85.214.182]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id AA2011F4E56; Fri, 7 Feb 2025 13:32:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.182 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738935149; cv=none; b=sTwfZfeW9VoZ6s0Wz6GBWlAg1cfkEz59OHWOGD6Zcws1YXQsR7t3Em3VOXULCdkc0+8faF/acmILhi/F7/vK2sBqjUTeg2Z7y2CcSnTmbRk8943TjOOc9nBSjFpSBf437I9YNteuP+34vFGujMZq3gzCrdU/yYlQ7MvTE8fLcZw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738935149; c=relaxed/simple; bh=p/LLNspP63XeDluK8n1bB3ApPN0HiknOfwCoEOeBPsY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=hZp7v2G/8UGCb1rJQMI4LE5po7VvqCdDPwnYgGoHK/Q1ZeQiPoelaRD0Fh5KXAN6VswEGQqMinUbK/MlhPiVrkC0RraXPIpkrJtsaVWKcS6GVPqYuoC8UqKKMbIPlBNLJNYgMcSzLKWD3n2tOm+ZNgUISc6ibDMiNcsgvPkms48= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=j+5LtLQz; arc=none smtp.client-ip=209.85.214.182 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="j+5LtLQz" Received: by mail-pl1-f182.google.com with SMTP id d9443c01a7336-21f5660c2fdso9590525ad.2; Fri, 07 Feb 2025 05:32:27 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1738935147; x=1739539947; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=R57PZ40vsMBhmQU5DVB3HkIVq/yRk+LSm6ONd5T9PSk=; b=j+5LtLQz4hKl9OtugRZi89BG3nF+IzTUkizVR2EhR3vMCOMOTUu9sovFpSgTCZEKBu OMqY74VB9t13J3ad349EmLTqTkQbPmve3TL1OUuit1j/nJuuEurkIEy5y1QRoLIBy065 PS819Ny5ET663NbQbcxzbq3WIVUXyeOJDnKI2DZUOAxFJr0SjXxunY9gX2pFRrPwxKD3 xXYt2f9jdJMnbdZIqr8WHoJ1GpULB56GOG3YG8nsa8v+yu/Q0qhpLReiYCZdmUHZTqoC 0lG9bS4QfIorrgWs07KxwTL+yiSWDw4o4w//82VcyN/EOWswXUr2kVxMgtemESPQKCfE 84MA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1738935147; x=1739539947; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=R57PZ40vsMBhmQU5DVB3HkIVq/yRk+LSm6ONd5T9PSk=; b=hWiSmHI3r/IMbx3ML3DzwkgCO9Bv9V6vo6SR50vYv8hTzyELDDE+99j66+dx955n3d qubvMEAL55pcBGA2PdLO/KbJcPdjOf7TpFMMkXVUs1YJC+1BnWJ1SEbIuBAEHJ3L5vnK C6VcKh99ipFTpqpbD7r4RanmCFDBSJK25fVIXMZh6p5GiN7l/GdjhfVNOJklBosA/hJN T5UOVo5vL7SYYZAagYUlhswzy5VbWn+Oq9XcXz/FVoi7/y149xB06lcPojUb/sWFK3u1 1tOBmL98PpCzLIvOKKS/9hAySG68/ezbM08X3rXi9krC6xKARIqEqtwitKGhlkn+Ulny RpeA== X-Forwarded-Encrypted: i=1; AJvYcCVbisuUmNKbqOrXXepEnpOdTa4rUdIRkchMEjgGKwEMJhvEECZ6Y0VBADMyUMPMKh0WRx+NxWWnQpXGpgCc8Ao=@vger.kernel.org, AJvYcCWNZEVKb25KXh4Edt/tthZlTl4oTK/gD0eJbFQgbvHm94vno0w5G4ddgqixoikJz6TAai8U+mY=@vger.kernel.org X-Gm-Message-State: AOJu0YxNejoInx3c1o2mRWt9tlXzF99TONmywtwsBXQ0iiyHaxFQVO3l QWDkUYlNgnXCZto1ab1l+QKhtE9694x8Vtc+tmPgmDzfxHIbYKCdN+l/L66V X-Gm-Gg: ASbGncvm/tQQhDBmzHMtUsK9qEWMCEk6BVddoOPvVVizNDXxLojhlh8ToTT3pVm61Ir HnaVhXk5bEBHBjsYUP7PbGNHTifgCV6Q4zK5ee7k/e/jUS2Fk+8bA0nQc1d3nwMLS4G0F2qflkD xvWDddc9+j+UMFHkXrlPlwW34DNn6CTptr+jsRMMfwTbU7hGni7e4l19TMVrExSYOKK8GFKeGwX 9YUVoRt3tKBp+XJfEWphYHX1td+wEBeXdBqRB+9RvBdx02pTiKjaPL4WREkvk9uH5hGSb7F0Zfb yFmGVl1/CcmfVR/IiNr936+Jk8L2Mgfq1EENOBEvz/aXbbvonlRAQ03Bm6qsDlAE7+w= X-Google-Smtp-Source: AGHT+IHhtSG2duMocArmnuRm1/YUB2+aUWDxsujnMBlnADYjatNoIUDc8APNR9zWnp5zI5ykScedxA== X-Received: by 2002:a05:6a20:438c:b0:1ed:a72f:bed1 with SMTP id adf61e73a8af0-1ee03b5a90emr7910761637.32.1738935146765; Fri, 07 Feb 2025 05:32:26 -0800 (PST) Received: from mew.. (p3882177-ipxg22501hodogaya.kanagawa.ocn.ne.jp. [180.15.148.177]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-ad51ea79a47sm2877843a12.76.2025.02.07.05.32.19 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 07 Feb 2025 05:32:26 -0800 (PST) From: FUJITA Tomonori To: linux-kernel@vger.kernel.org Cc: Andrew Lunn , Alice Ryhl , Gary Guo , rust-for-linux@vger.kernel.org, netdev@vger.kernel.org, hkallweit1@gmail.com, tmgross@umich.edu, ojeda@kernel.org, alex.gaynor@gmail.com, bjorn3_gh@protonmail.com, benno.lossin@proton.me, a.hindborg@samsung.com, anna-maria@linutronix.de, frederic@kernel.org, tglx@linutronix.de, arnd@arndb.de, jstultz@google.com, sboyd@kernel.org, mingo@redhat.com, peterz@infradead.org, juri.lelli@redhat.com, vincent.guittot@linaro.org, dietmar.eggemann@arm.com, rostedt@goodmis.org, bsegall@google.com, mgorman@suse.de, vschneid@redhat.com, tgunders@redhat.com, me@kloenk.dev Subject: [PATCH v10 8/8] net: phy: qt2025: Wait until PHY becomes ready Date: Fri, 7 Feb 2025 22:26:23 +0900 Message-ID: <20250207132623.168854-9-fujita.tomonori@gmail.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20250207132623.168854-1-fujita.tomonori@gmail.com> References: <20250207132623.168854-1-fujita.tomonori@gmail.com> Precedence: bulk X-Mailing-List: netdev@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Patchwork-Delegate: kuba@kernel.org Wait until a PHY becomes ready in the probe callback by using read_poll_timeout function. Reviewed-by: Andrew Lunn Reviewed-by: Alice Ryhl Reviewed-by: Gary Guo Signed-off-by: FUJITA Tomonori --- drivers/net/phy/qt2025.rs | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/drivers/net/phy/qt2025.rs b/drivers/net/phy/qt2025.rs index 1ab065798175..cdf0540f0a98 100644 --- a/drivers/net/phy/qt2025.rs +++ b/drivers/net/phy/qt2025.rs @@ -12,6 +12,7 @@ use kernel::c_str; use kernel::error::code; use kernel::firmware::Firmware; +use kernel::io::poll::read_poll_timeout; use kernel::net::phy::{ self, reg::{Mmd, C45}, @@ -19,6 +20,7 @@ }; use kernel::prelude::*; use kernel::sizes::{SZ_16K, SZ_8K}; +use kernel::time::Delta; kernel::module_phy_driver! { drivers: [PhyQT2025], @@ -93,7 +95,13 @@ fn probe(dev: &mut phy::Device) -> Result<()> { // The micro-controller will start running from SRAM. dev.write(C45::new(Mmd::PCS, 0xe854), 0x0040)?; - // TODO: sleep here until the hw becomes ready. + read_poll_timeout( + || dev.read(C45::new(Mmd::PCS, 0xd7fd)), + |val| *val != 0x00 && *val != 0x10, + Delta::from_millis(50), + Some(Delta::from_secs(3)), + )?; + Ok(()) }