lkml.org 
[lkml]   [2005]   [Jul]   [14]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    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/
    \
     
     \ /
      Last update: 2005-07-14 23:02    [W:0.041 / U:33.984 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site