Messages in this thread Patch in this message | | | Date | Thu, 14 Jul 2005 13:41:32 -0700 | From | Nishanth Aravamudan <> | Subject | [RFC][PATCH 3/4] new human-time schedule_timeout() functions |
| |
From: Nishanth Aravamudan <nacc@us.ibm.com>
Description: Add new human-time schedule_timeout() style functions, along with the appropriate constants/prototypes.
Signed-off-by: Nishanth Aravamudan <nacc@us.ibm.com>
---
include/linux/sched.h | 7 ++ include/linux/time.h | 4 + kernel/timer.c | 147 ++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 158 insertions(+)
diff -urpN 2.6.13-rc3-base/include/linux/sched.h 2.6.13-rc3-dev/include/linux/sched.h --- 2.6.13-rc3-base/include/linux/sched.h 2005-07-13 15:52:14.000000000 -0700 +++ 2.6.13-rc3-dev/include/linux/sched.h 2005-07-14 12:45:15.000000000 -0700 @@ -182,7 +182,14 @@ extern void scheduler_tick(void); extern int in_sched_functions(unsigned long addr); #define MAX_SCHEDULE_TIMEOUT LONG_MAX +#define MAX_SCHEDULE_TIMEOUT_NSECS ((u64)(-1)) +#define MAX_SCHEDULE_TIMEOUT_USECS ULONG_MAX +#define MAX_SCHEDULE_TIMEOUT_MSECS UINT_MAX + extern signed long FASTCALL(schedule_timeout(signed long timeout)); +extern u64 FASTCALL(schedule_timeout_nsecs(u64 timeout_nsecs)); +extern unsigned long FASTCALL(schedule_timeout_usecs(unsigned long timeout_usecs)); +extern unsigned int FASTCALL(schedule_timeout_msecs(unsigned int timeout_msecs)); asmlinkage void schedule(void); struct namespace; diff -urpN 2.6.13-rc3-base/include/linux/time.h 2.6.13-rc3-dev/include/linux/time.h --- 2.6.13-rc3-base/include/linux/time.h 2005-07-14 12:45:07.000000000 -0700 +++ 2.6.13-rc3-dev/include/linux/time.h 2005-07-14 12:45:15.000000000 -0700 @@ -36,6 +36,10 @@ struct timezone { #define NSEC_PER_SEC (1000000000L) #endif +#ifndef NSEC_PER_MSEC +#define NSEC_PER_MSEC (1000000L) +#endif + #ifndef NSEC_PER_USEC #define NSEC_PER_USEC (1000L) #endif diff -urpN 2.6.13-rc3-base/kernel/timer.c 2.6.13-rc3-dev/kernel/timer.c --- 2.6.13-rc3-base/kernel/timer.c 2005-07-14 12:45:07.000000000 -0700 +++ 2.6.13-rc3-dev/kernel/timer.c 2005-07-14 12:45:15.000000000 -0700 @@ -1271,6 +1271,10 @@ static void process_timeout(unsigned lon * value will be %MAX_SCHEDULE_TIMEOUT. * * In all cases the return value is guaranteed to be non-negative. + * + * The callers of schedule_timeout() should be aware that the interface + * is now deprecated. schedule_timeout_{msecs,usecs,nsecs}() are now the + * interfaces for relative timeout requests. */ fastcall signed long __sched schedule_timeout(signed long timeout) { @@ -1326,6 +1330,149 @@ fastcall signed long __sched schedule_ti EXPORT_SYMBOL(schedule_timeout); +/** + * schedule_timeout_nsecs - sleep until timeout + * @timeout_nsecs: timeout value in nanoseconds + * + * Make the current task sleep until @timeout_nsecs nsecs have + * elapsed. The routine will return immediately unless + * the current task state has been set (see set_current_state()). + * + * You can set the task state as follows - + * + * %TASK_UNINTERRUPTIBLE - at least @timeout_nsecs nsecs are guaranteed + * to pass before the routine returns. The routine will return 0 + * + * %TASK_INTERRUPTIBLE - the routine may return early if a signal is + * delivered to the current task. In this case the remaining time + * in nsecs will be returned, or 0 if the timer expired in time + * + * The current task state is guaranteed to be TASK_RUNNING when this + * routine returns. + * + * Specifying a @timeout value of %MAX_SCHEDULE_TIMEOUT_NSECS will + * schedule the CPU away without a bound on the timeout. In this case + * the return value will be %MAX_SCHEDULE_TIMEOUT_NSECS. + */ +fastcall u64 __sched schedule_timeout_nsecs(u64 timeout_nsecs) +{ + struct timer_list timer; + u64 expires; + + if (timeout_nsecs == MAX_SCHEDULE_TIMEOUT_NSECS) { + schedule(); + goto out; + } + + expires = do_monotonic_clock() + timeout_nsecs; + + init_timer(&timer); + timer.data = (unsigned long) current; + timer.function = process_timeout; + + set_timer_nsecs(&timer, expires); + schedule(); + del_singleshot_timer_sync(&timer); + + timeout_nsecs = do_monotonic_clock(); + if (expires < timeout_nsecs) + timeout_nsecs = (u64)0UL; + else + timeout_nsecs = expires - timeout_nsecs; +out: + return timeout_nsecs; +} + +EXPORT_SYMBOL_GPL(schedule_timeout_nsecs); + +/** + * schedule_timeout_usecs - sleep until timeout + * @timeout_usecs: timeout value in nanoseconds + * + * Make the current task sleep until @timeout_usecs usecs have + * elapsed. The routine will return immediately unless + * the current task state has been set (see set_current_state()). + * + * You can set the task state as follows - + * + * %TASK_UNINTERRUPTIBLE - at least @timeout_usecs usecs are guaranteed + * to pass before the routine returns. The routine will return 0 + * + * %TASK_INTERRUPTIBLE - the routine may return early if a signal is + * delivered to the current task. In this case the remaining time + * in usecs will be returned, or 0 if the timer expired in time + * + * The current task state is guaranteed to be TASK_RUNNING when this + * routine returns. + * + * Specifying a @timeout value of %MAX_SCHEDULE_TIMEOUT_USECS will + * schedule the CPU away without a bound on the timeout. In this case + * the return value will be %MAX_SCHEDULE_TIMEOUT_USECS. + */ +fastcall inline unsigned long __sched schedule_timeout_usecs(unsigned long timeout_usecs) +{ + u64 timeout_nsecs; + + if (timeout_usecs == MAX_SCHEDULE_TIMEOUT_USECS) + timeout_nsecs = MAX_SCHEDULE_TIMEOUT_NSECS; + else + timeout_nsecs = timeout_usecs * (u64)NSEC_PER_USEC; + /* + * Make sure to round up by subtracting one before division and + * adding one after + */ + timeout_nsecs = schedule_timeout_nsecs(timeout_nsecs) - 1; + do_div(timeout_nsecs, NSEC_PER_USEC); + timeout_usecs = (unsigned long)timeout_nsecs + 1UL; + return timeout_usecs; +} + +EXPORT_SYMBOL_GPL(schedule_timeout_usecs); + +/** + * schedule_timeout_msecs - sleep until timeout + * @timeout_msecs: timeout value in nanoseconds + * + * Make the current task sleep until @timeout_msecs msecs have + * elapsed. The routine will return immediately unless + * the current task state has been set (see set_current_state()). + * + * You can set the task state as follows - + * + * %TASK_UNINTERRUPTIBLE - at least @timeout_msecs msecs are guaranteed + * to pass before the routine returns. The routine will return 0 + * + * %TASK_INTERRUPTIBLE - the routine may return early if a signal is + * delivered to the current task. In this case the remaining time + * in msecs will be returned, or 0 if the timer expired in time + * + * The current task state is guaranteed to be TASK_RUNNING when this + * routine returns. + * + * Specifying a @timeout value of %MAX_SCHEDULE_TIMEOUT_MSECS will + * schedule the CPU away without a bound on the timeout. In this case + * the return value will be %MAX_SCHEDULE_TIMEOUT_MSECS. + */ +fastcall inline unsigned int __sched schedule_timeout_msecs(unsigned int timeout_msecs) +{ + u64 timeout_nsecs; + + if (timeout_msecs == MAX_SCHEDULE_TIMEOUT_MSECS) + timeout_nsecs = MAX_SCHEDULE_TIMEOUT_NSECS; + else + timeout_nsecs = timeout_msecs * (u64)NSEC_PER_MSEC; + /* + * Make sure to round up by subtracting one before division and + * adding one after + */ + timeout_nsecs = schedule_timeout_nsecs(timeout_nsecs) - 1; + do_div(timeout_nsecs, NSEC_PER_MSEC); + timeout_msecs = (unsigned int)timeout_nsecs + 1; + return timeout_msecs; +} + +EXPORT_SYMBOL_GPL(schedule_timeout_msecs); + /* Thread ID - the internal kernel "pid" */ asmlinkage long sys_gettid(void) { - To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
| |