lkml.org 
[lkml]   [2010]   [Apr]   [30]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    From
    Date
    SubjectRe: [Patch 2/3] sysctl: add proc_do_large_bitmap
    On Fri, Apr 30, 2010 at 4:25 PM, Amerigo Wang <amwang@redhat.com> wrote:
    > From: Octavian Purdila <opurdila@ixiacom.com>
    >
    > The new function can be used to read/write large bitmaps via /proc. A
    > comma separated range format is used for compact output and input
    > (e.g. 1,3-4,10-10).
    >
    > Writing into the file will first reset the bitmap then update it
    > based on the given input.
    >
    > Signed-off-by: Octavian Purdila <opurdila@ixiacom.com>
    > Signed-off-by: WANG Cong <amwang@redhat.com>
    > Cc: Eric W. Biederman <ebiederm@xmission.com>
    > ---
    >
    > Index: linux-2.6/include/linux/sysctl.h
    > ===================================================================
    > --- linux-2.6.orig/include/linux/sysctl.h
    > +++ linux-2.6/include/linux/sysctl.h
    > @@ -980,6 +980,8 @@ extern int proc_doulongvec_minmax(struct
    >                                  void __user *, size_t *, loff_t *);
    >  extern int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int,
    >                                      void __user *, size_t *, loff_t *);
    > +extern int proc_do_large_bitmap(struct ctl_table *, int,
    > +                               void __user *, size_t *, loff_t *);
    >
    >  /*
    >  * Register a set of sysctl names by calling register_sysctl_table
    > Index: linux-2.6/kernel/sysctl.c
    > ===================================================================
    > --- linux-2.6.orig/kernel/sysctl.c
    > +++ linux-2.6/kernel/sysctl.c
    > @@ -2049,6 +2049,16 @@ static size_t proc_skip_spaces(char **bu
    >        return ret;
    >  }
    >
    > +static void proc_skip_char(char **buf, size_t *size, const char v)
    > +{
    > +       while (*size) {
    > +               if (**buf != v)
    > +                       break;
    > +               (*size)--;
    > +               (*buf)++;
    > +       }
    > +}
    > +
    >  #define TMPBUFLEN 22
    >  /**
    >  * proc_get_long - reads an ASCII formated integer from a user buffer
    > @@ -2675,6 +2685,153 @@ static int proc_do_cad_pid(struct ctl_ta
    >        return 0;
    >  }
    >
    > +/**
    > + * proc_do_large_bitmap - read/write from/to a large bitmap
    > + * @table: the sysctl table
    > + * @write: %TRUE if this is a write to the sysctl file
    > + * @buffer: the user buffer
    > + * @lenp: the size of the user buffer
    > + * @ppos: file position
    > + *
    > + * The bitmap is stored at table->data and the bitmap length (in bits)
    > + * in table->maxlen.
    > + *
    > + * We use a range comma separated format (e.g. 1,3-4,10-10) so that
    > + * large bitmaps may be represented in a compact manner. Writing into
    > + * the file will clear the bitmap then update it with the given input.
    > + *
    > + * Returns 0 on success.
    > + */
    > +int proc_do_large_bitmap(struct ctl_table *table, int write,
    > +                        void __user *buffer, size_t *lenp, loff_t *ppos)
    > +{
    > +       int err = 0;
    > +       bool first = 1;
    > +       size_t left = *lenp;
    > +       unsigned long bitmap_len = table->maxlen;
    > +       unsigned long *bitmap = (unsigned long *) table->data;
    > +       unsigned long *tmp_bitmap = NULL;
    > +       char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c;
    > +
    > +       if (!bitmap_len || !left || (*ppos && !write)) {
    > +               *lenp = 0;
    > +               return 0;
    > +       }
    > +
    > +       if (write) {
    > +               unsigned long page = 0;
    > +               char *kbuf;
    > +
    > +               if (left > PAGE_SIZE - 1)
    > +                       left = PAGE_SIZE - 1;
    > +
    > +               page = __get_free_page(GFP_TEMPORARY);
    > +               kbuf = (char *) page;
    > +               if (!kbuf)
    > +                       return -ENOMEM;
    > +               if (copy_from_user(kbuf, buffer, left)) {
    > +                       free_page(page);
    > +                       return -EFAULT;
    > +                }
    > +               kbuf[left] = 0;
    > +
    > +               tmp_bitmap = kzalloc(BITS_TO_LONGS(bitmap_len) * sizeof(unsigned long),
    > +                                    GFP_KERNEL);
    > +               if (!tmp_bitmap) {
    > +                       free_page(page);
    > +                       return -ENOMEM;
    > +               }
    > +               proc_skip_char(&kbuf, &left, '\n');
    > +               while (!err && left) {
    > +                       unsigned long val_a, val_b;
    > +                       bool neg;
    > +
    > +                       err = proc_get_long(&kbuf, &left, &val_a, &neg, tr_a,
    > +                                            sizeof(tr_a), &c);
    > +                       if (err)
    > +                               break;
    > +                       if (val_a >= bitmap_len || neg) {
    > +                               err = -EINVAL;
    > +                               break;
    > +                       }
    > +
    > +                       val_b = val_a;
    > +                       if (left) {
    > +                               kbuf++;
    > +                               left--;
    > +                       }
    > +
    > +                       if (c == '-') {
    > +                               err = proc_get_long(&kbuf, &left, &val_b,
    > +                                                    &neg, tr_b, sizeof(tr_b),
    > +                                                    &c);
    > +                               if (err)
    > +                                       break;
    > +                               if (val_b >= bitmap_len || neg ||
    > +                                   val_a > val_b) {
    > +                                       err = -EINVAL;
    > +                                       break;
    > +                               }
    > +                               if (left) {
    > +                                       kbuf++;
    > +                                       left--;
    > +                               }
    > +                       }
    > +
    > +                       while (val_a <= val_b)
    > +                               set_bit(val_a++, tmp_bitmap);
    > +
    > +                       first = 0;
    > +                       proc_skip_char(&kbuf, &left, '\n');
    > +               }
    > +               free_page(page);
    > +       } else {
    > +               unsigned long bit_a, bit_b = 0;
    > +
    > +               while (left) {
    > +                       bit_a = find_next_bit(bitmap, bitmap_len, bit_b);
    > +                       if (bit_a >= bitmap_len)
    > +                               break;
    > +                       bit_b = find_next_zero_bit(bitmap, bitmap_len,
    > +                                                  bit_a + 1) - 1;
    > +
    > +                       if (!first) {
    > +                               err = proc_put_char(&buffer, &left, ',');
    > +                               if (err)
    > +                                       break;
    > +                       }
    > +                       err = proc_put_long(&buffer, &left, bit_a, false);
    > +                       if (err)
    > +                               break;
    > +                       if (bit_a != bit_b) {
    > +                               err = proc_put_char(&buffer, &left, '-');
    > +                               if (err)
    > +                                       break;
    > +                               err = proc_put_long(&buffer, &left, bit_b, false);
    > +                               if (err)
    > +                                       break;
    > +                       }
    > +
    > +                       first = 0; bit_b++;
    > +               }
    > +               if (!err)
    > +                       err = proc_put_char(&buffer, &left, '\n');
    > +       }
    > +
    > +       if (!err) {
    add the following lines to let "echo 1-10 >>
    /proc/..." work as normal.
    if (write && *ppos)
    bimap_or(bitmap, bitmap, tmp_bitmap,....)
    else

    > +               if (write)
    > +                       memcpy(bitmap, tmp_bitmap,
    > +                              BITS_TO_LONGS(bitmap_len) * sizeof(unsigned long));
    > +               kfree(tmp_bitmap);
    > +               *lenp -= left;
    > +               *ppos += *lenp;
    > +               return 0;





    --
    Regards,
    Changli Gao(xiaosuo@gmail.com)
    \
     
     \ /
      Last update: 2010-05-01 00:45    [W:0.039 / U:61.412 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site