[RESEND][RFC v3 PATCH] RTTIME watchdog timer proc interface - Kernel

This is a discussion on [RESEND][RFC v3 PATCH] RTTIME watchdog timer proc interface - Kernel ; From: Hiroshi Shimamoto Introduce new proc interface for RTTIME watchdog. It makes administrator able to set RTTIME watchdog to exisiting real-time applications without impact. It's useful we don't want to change software stack, but want to use RTTIME watchdog for ...

+ Reply to Thread
Results 1 to 3 of 3

Thread: [RESEND][RFC v3 PATCH] RTTIME watchdog timer proc interface

  1. [RESEND][RFC v3 PATCH] RTTIME watchdog timer proc interface

    From: Hiroshi Shimamoto

    Introduce new proc interface for RTTIME watchdog.
    It makes administrator able to set RTTIME watchdog to exisiting real-time
    applications without impact. It's useful we don't want to change software
    stack, but want to use RTTIME watchdog for that software.

    New proc files:
    /proc//rttime
    /proc//task//rttime
    these files have same content.

    $ cat /proc//rttime
    10000000 20000000
    It shows current RLIMIT_RTTIME values, and the unit is nsec.
    If the value is RLIM_INFINITY, it prints "unlimited".

    $ echo "10000000" > /proc//rttime
    It sets RTTIME current value to 10000000.

    $ echo "10000000 20000000" > /proc//rttime
    It sets RTTIME current value to 10000000 and max value to 20000000.

    $ echo "0 0" > /proc//rttime
    It sets RTTIME values to unlimited.

    Signed-off-by: Hiroshi Shimamoto
    ---
    Update for 2.6.25-rc8

    fs/proc/base.c | 103 ++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++
    1 files changed, 103 insertions(+), 0 deletions(-)

    diff --git a/fs/proc/base.c b/fs/proc/base.c
    index 81d7d14..07cbbae 100644
    --- a/fs/proc/base.c
    +++ b/fs/proc/base.c
    @@ -376,6 +376,107 @@ static const struct file_operations proc_lstats_operations = {

    #endif

    +static int rttime_show_proc(struct seq_file *m, void *v)
    +{
    + struct inode *inode = m->private;
    + struct task_struct *task = get_proc_task(inode);
    + struct rlimit *rt;
    +
    + if (!task)
    + return -ESRCH;
    +
    + rt = &task->signal->rlim[RLIMIT_RTTIME];
    +
    + if (rt->rlim_cur == RLIM_INFINITY)
    + seq_printf(m, "unlimited ");
    + else
    + seq_printf(m, "%lu ", rt->rlim_cur);
    +
    + if (rt->rlim_max == RLIM_INFINITY)
    + seq_printf(m, "unlimited\n");
    + else
    + seq_printf(m, "%lu\n", rt->rlim_max);
    +
    + put_task_struct(task);
    +
    + return 0;
    +}
    +
    +static int rttime_open(struct inode *inode, struct file *file)
    +{
    + return single_open(file, rttime_show_proc, inode);
    +}
    +
    +static ssize_t rttime_do_write(struct task_struct *task,
    + const char __user *buf,
    + size_t count)
    +{
    + char buffer[PROC_NUMBUF], *end;
    + struct rlimit new_rlim, *old_rlim;
    + size_t bufsz;
    + int ret;
    +
    + old_rlim = task->signal->rlim + RLIMIT_RTTIME;
    + new_rlim = *old_rlim;
    + memset(buffer, 0, sizeof(buffer));
    + bufsz = min(count, sizeof(buffer) - 1);
    + if (copy_from_user(buffer, buf, bufsz))
    + return -EFAULT;
    + new_rlim.rlim_cur = simple_strtoul(buffer, &end, 0);
    + if (end - buffer == 0)
    + return -EINVAL;
    + /* 0 means unlimited */
    + if (new_rlim.rlim_cur == 0)
    + new_rlim.rlim_cur = RLIM_INFINITY;
    + if (*end == ' ') {
    + ++end;
    + buf += end - buffer;
    + memset(buffer, 0, sizeof(buffer));
    + bufsz = min(count - (end - buffer), sizeof(buffer) - 1);
    + if (copy_from_user(buffer, buf, bufsz))
    + return -EFAULT;
    + ret = strict_strtoul(buffer, 0, &new_rlim.rlim_max);
    + if (ret)
    + return ret;
    + /* 0 means unlimited */
    + if (new_rlim.rlim_max == 0)
    + new_rlim.rlim_max = RLIM_INFINITY;
    + }
    + if (new_rlim.rlim_cur > new_rlim.rlim_max)
    + return -EINVAL;
    + if ((new_rlim.rlim_max > old_rlim->rlim_max) &&
    + !__capable(task, CAP_SYS_RESOURCE))
    + return -EPERM;
    + task_lock(task->group_leader);
    + *old_rlim = new_rlim;
    + task_unlock(task->group_leader);
    +
    + return count;
    +}
    +
    +static ssize_t rttime_write(struct file *file,
    + const char __user *buf,
    + size_t count,
    + loff_t *ppos)
    +{
    + struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
    + int ret;
    +
    + if (!task)
    + return -ESRCH;
    + ret = rttime_do_write(task, buf, count);
    + put_task_struct(task);
    + return ret;
    +}
    +
    +static const struct file_operations proc_rttime_operations = {
    + .open = rttime_open,
    + .read = seq_read,
    + .write = rttime_write,
    + .llseek = seq_lseek,
    + .release = single_release,
    +};
    +
    /* The badness from the OOM killer */
    unsigned long badness(struct task_struct *p, unsigned long uptime);
    static int proc_oom_score(struct task_struct *task, char *buffer)
    @@ -2312,6 +2413,7 @@ static const struct pid_entry tgid_base_stuff[] = {
    LNK("exe", exe),
    REG("mounts", S_IRUGO, mounts),
    REG("mountstats", S_IRUSR, mountstats),
    + REG("rttime", S_IRUSR|S_IWUSR, rttime),
    #ifdef CONFIG_PROC_PAGE_MONITOR
    REG("clear_refs", S_IWUSR, clear_refs),
    REG("smaps", S_IRUGO, smaps),
    @@ -2643,6 +2745,7 @@ static const struct pid_entry tid_base_stuff[] = {
    LNK("root", root),
    LNK("exe", exe),
    REG("mounts", S_IRUGO, mounts),
    + REG("rttime", S_IRUSR|S_IWUSR, rttime),
    #ifdef CONFIG_PROC_PAGE_MONITOR
    REG("clear_refs", S_IWUSR, clear_refs),
    REG("smaps", S_IRUGO, smaps),
    --
    1.5.4.1

    --
    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/

  2. Re: [RESEND][RFC v3 PATCH] RTTIME watchdog timer proc interface

    On Thu, 03 Apr 2008 15:43:25 -0700
    Hiroshi Shimamoto wrote:

    > From: Hiroshi Shimamoto
    >
    > Introduce new proc interface for RTTIME watchdog.
    > It makes administrator able to set RTTIME watchdog to exisiting real-time
    > applications without impact. It's useful we don't want to change software
    > stack, but want to use RTTIME watchdog for that software.


    Well you don't really need to change the software stack. It's a matter of
    setting RLIMIT_RTTIME in the parent process before starting the stack up.
    This is not much more work than poking at /proc//rttime afterwards.

    Although setting RLIMIT_RTTIME via fork() is much less useful than being
    able to alter it at runtime.

    > fs/proc/base.c | 103 ++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++


    And that's rather a lot of new code just for RLIMIT_RTTIME. And
    RLIMIT_RTTIME is not the only rlimit which has this problem - generally the
    rlimit interface is a rather nasty one.


    I think we should look at creating a general way of modifying and reading a
    running process's rlimits. If we want to do that, a syscall would be the
    appropriate interface.

    --
    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/

  3. Re: [RESEND][RFC v3 PATCH] RTTIME watchdog timer proc interface

    Andrew Morton wrote:
    > On Thu, 03 Apr 2008 15:43:25 -0700
    > Hiroshi Shimamoto wrote:
    >
    >> From: Hiroshi Shimamoto
    >>
    >> Introduce new proc interface for RTTIME watchdog.
    >> It makes administrator able to set RTTIME watchdog to exisiting real-time
    >> applications without impact. It's useful we don't want to change software
    >> stack, but want to use RTTIME watchdog for that software.

    >
    > Well you don't really need to change the software stack. It's a matter of
    > setting RLIMIT_RTTIME in the parent process before starting the stack up.


    I think it means all processes have the same RTTIME, I cannot change some
    of them, correct?

    > This is not much more work than poking at /proc//rttime afterwards.
    >
    > Although setting RLIMIT_RTTIME via fork() is much less useful than being
    > able to alter it at runtime.
    >
    >> fs/proc/base.c | 103 ++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++

    >
    > And that's rather a lot of new code just for RLIMIT_RTTIME. And
    > RLIMIT_RTTIME is not the only rlimit which has this problem - generally the
    > rlimit interface is a rather nasty one.
    >
    >
    > I think we should look at creating a general way of modifying and reading a
    > running process's rlimits. If we want to do that, a syscall would be the
    > appropriate interface.
    >

    I agreed, using /proc is easy but wrong way.
    I'll look for other approach for this.


    thanks,
    Hiroshi Shimamoto
    --
    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/

+ Reply to Thread