Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9f977fb7 authored by Octavian Purdila's avatar Octavian Purdila Committed by David S. Miller
Browse files

sysctl: add proc_do_large_bitmap 



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: default avatarOctavian Purdila <opurdila@ixiacom.com>
Signed-off-by: default avatarWANG Cong <amwang@redhat.com>
Cc: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 00b7c339

include/linux/sysctl.h

+2 −0
Original line number Diff line number Diff line
@@ -980,6 +980,8 @@ extern int proc_doulongvec_minmax(struct ctl_table *, int, 
				  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

kernel/sysctl.c

+161 −0
Original line number Diff line number Diff line
@@ -2049,6 +2049,16 @@ static size_t proc_skip_spaces(char **buf) 
	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,157 @@ static int proc_do_cad_pid(struct ctl_table *table, int write, 
	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) {

		if (write) {

			if (*ppos)

				bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len);

			else

				memcpy(bitmap, tmp_bitmap,

					BITS_TO_LONGS(bitmap_len) * sizeof(unsigned long));

		}

		kfree(tmp_bitmap);

		*lenp -= left;

		*ppos += *lenp;

		return 0;

	} else {

		kfree(tmp_bitmap);

		return err;

	}

}



#else /* CONFIG_PROC_FS */



int proc_dostring(struct ctl_table *table, int write,