Skip to contentSkip to conversation

net: reserve ports for applications using fixed port numbers

PATCH Superseded Amerigo Wang 4 participants 13 messages Apr 9, 2010 – Apr 12, 2010

Subsystems (9)

v7 of 10 Superseded Latest is v10 →

lore
Share & tools
lore
#0 lore raw

v7 cover net: reserve ports for applications using fixed port numbers

Changes from the previous version:
- Update to latest Linus' tree;
- Address Eric B.'s concern, copy the whole bitmap instead of set one by one.

------------->

This patch introduces /proc/sys/net/ipv4/ip_local_reserved_ports which allows users to reserve ports for third-party applications.

The reserved ports will not be used by automatic port assignments (e.g. when calling connect() or bind() with port number 0). Explicit port allocation behavior is unchanged.

There are still some miss behaviors with regard to proc parsing in odd invalid cases (for "40000\0-40001" all is acknowledged but only 40000 is accepted) but they are not easy to fix without changing the current "acknowledge how much we accepted" behavior.

Because of that and because the same issues are present in the existing proc_dointvec code as well I don't think its worth holding the actual feature (port reservation) after such petty error recovery issues.

#1 lore raw

PATCH v7 1/3 sysctl: refactor integer handling proc code

From: Octavian Purdila <[email protected]>

As we are about to add another integer handling proc function a little bit of cleanup is in order: add a few helper functions to improve code readability and decrease code duplication.

In the process a bug is also fixed: if the user specifies a number with more then 20 digits it will be interpreted as two integers (e.g. 10000...13 will be interpreted as 100.... and 13).

Behavior for EFAULT handling was changed as well. Previous to this patch, when an EFAULT error occurred in the middle of a write operation, although some of the elements were set, that was not acknowledged to the user (by shorting the write and returning the number of bytes accepted). EFAULT is now treated just like any other errors by acknowledging the amount of bytes accepted.

---

kernel/sysctl.c +210 -154
Index: linux-2.6/kernel/sysctl.c
===================================================================
@@ -2040,8 +2040,148 @@ int proc_dostring(struct ctl_table *tabl
 			       buffer, lenp, ppos);
 }
 
+static int proc_skip_wspace(char __user **buf, size_t *size)
+{
+	char c;
+
+	while (*size) {
+		if (get_user(c, *buf))
+			return -EFAULT;
+		if (!isspace(c))
+			break;
+		(*size)--;
+		(*buf)++;
+	}
+
+	return 0;
+}
+
+static bool isanyof(char c, const char *v, unsigned len)
+{
+	int i;
+
+	if (!len)
+		return false;
+
+	for (i = 0; i < len; i++)
+		if (c == v[i])
+			break;
+	if (i == len)
+		return false;
+
+	return true;
+}
+
+#define TMPBUFLEN 22
+/**
+ * proc_get_ulong - reads an ASCII formated integer from a user buffer
+ *
+ * @buf - user buffer
+ * @size - size of the user buffer
+ * @val - this is where the number will be stored
+ * @neg - set to %TRUE if number is negative
+ * @perm_tr - a vector which contains the allowed trailers
+ * @perm_tr_len - size of the perm_tr vector
+ * @tr - pointer to store the trailer character
+ *
+ * In case of success 0 is returned and buf and size are updated with
+ * the amount of bytes read. If tr is non NULL and a trailing
+ * character exist (size is non zero after returning from this
+ * function) tr is updated with the trailing character.
+ */
+static int proc_get_ulong(char __user **buf, size_t *size,
+			  unsigned long *val, bool *neg,
+			  const char *perm_tr, unsigned perm_tr_len, char *tr)
+{
+	int len;
+	char *p, tmp[TMPBUFLEN];
+
+	if (!*size)
+		return -EINVAL;
+
+	len = *size;
+	if (len > TMPBUFLEN-1)
+		len = TMPBUFLEN-1;
+
+	if (copy_from_user(tmp, *buf, len))
+		return -EFAULT;
+
+	tmp[len] = 0;
+	p = tmp;
+	if (*p == '-' && *size > 1) {
+		*neg = 1;
+		p++;
+	} else
+		*neg = 0;
+	if (!isdigit(*p))
+		return -EINVAL;
+
+	*val = simple_strtoul(p, &p, 0);
+
+	len = p - tmp;
+
+	/* We don't know if the next char is whitespace thus we may accept
+	 * invalid integers (e.g. 1234...a) or two integers instead of one
+	 * (e.g. 123...1). So lets not allow such large numbers. */
+	if (len == TMPBUFLEN - 1)
+		return -EINVAL;
+
+	if (len < *size && perm_tr_len && !isanyof(*p, perm_tr, perm_tr_len))
+		return -EINVAL;
+
+	if (tr && (len < *size))
+		*tr = *p;
+
+	*buf += len;
+	*size -= len;
+
+	return 0;
+}
+
+/**
+ * proc_put_ulong - coverts an integer to a decimal ASCII formated string
+ *
+ * @buf - the user buffer
+ * @size - the size of the user buffer
+ * @val - the integer to be converted
+ * @neg - sign of the number, %TRUE for negative
+ * @first - if %FALSE will insert a separator character before the number
+ * @separator - the separator character
+ *
+ * In case of success 0 is returned and buf and size are updated with
+ * the amount of bytes read.
+ */
+static int proc_put_ulong(char __user **buf, size_t *size, unsigned long val,
+			  bool neg, bool first, char separator)
+{
+	int len;
+	char tmp[TMPBUFLEN], *p = tmp;
+
+	if (!first)
+		*p++ = separator;
+	sprintf(p, "%s%lu", neg ? "-" : "", val);
+	len = strlen(tmp);
+	if (len > *size)
+		len = *size;
+	if (copy_to_user(*buf, tmp, len))
+		return -EFAULT;
+	*size -= len;
+	*buf += len;
+	return 0;
+}
+#undef TMPBUFLEN
+
+static int proc_put_char(char __user **buf, size_t *size, char c)
+{
+	if (*size) {
+		if (put_user(c, *buf))
+			return -EFAULT;
+		(*size)--, (*buf)++;
+	}
+	return 0;
+}
 
-static int do_proc_dointvec_conv(int *negp, unsigned long *lvalp,
+static int do_proc_dointvec_conv(bool *negp, unsigned long *lvalp,
 				 int *valp,
 				 int write, void *data)
 {
@@ -2050,7 +2190,7 @@ static int do_proc_dointvec_conv(int *ne
 	} else {
 		int val = *valp;
 		if (val < 0) {
-			*negp = -1;
+			*negp = 1;
 			*lvalp = (unsigned long)-val;
 		} else {
 			*negp = 0;
@@ -2060,20 +2200,18 @@ static int do_proc_dointvec_conv(int *ne
 	return 0;
 }
 
+static const char proc_wspace_sep[] = { ' ', '\t', '\n', 0 };
+
 static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
-		  int write, void __user *buffer,
+		  int write, void __user *_buffer,
 		  size_t *lenp, loff_t *ppos,
-		  int (*conv)(int *negp, unsigned long *lvalp, int *valp,
+		  int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
 			      int write, void *data),
 		  void *data)
 {
-#define TMPBUFLEN 21
-	int *i, vleft, first = 1, neg;
-	unsigned long lval;
-	size_t left, len;
-	
-	char buf[TMPBUFLEN], *p;
-	char __user *s = buffer;
+	int *i, vleft, first = 1, err = 0;
+	size_t left;
+	char __user *buffer = (char __user *) _buffer;
 	
 	if (!tbl_data || !table->maxlen || !*lenp ||
 	    (*ppos && !write)) {
@@ -2089,88 +2227,48 @@ static int __do_proc_dointvec(void *tbl_
 		conv = do_proc_dointvec_conv;
 
 	for (; left && vleft--; i++, first=0) {
-		if (write) {
-			while (left) {
-				char c;
-				if (get_user(c, s))
-					return -EFAULT;
-				if (!isspace(c))
-					break;
-				left--;
-				s++;
-			}
-			if (!left)
-				break;
-			neg = 0;
-			len = left;
-			if (len > sizeof(buf) - 1)
-				len = sizeof(buf) - 1;
-			if (copy_from_user(buf, s, len))
-				return -EFAULT;
-			buf[len] = 0;
-			p = buf;
-			if (*p == '-' && left > 1) {
-				neg = 1;
-				p++;
-			}
-			if (*p < '0' || *p > '9')
-				break;
-
-			lval = simple_strtoul(p, &p, 0);
+		unsigned long lval;
+		bool neg;
 
-			len = p-buf;
-			if ((len < left) && *p && !isspace(*p))
+		if (write) {
+			err = proc_skip_wspace(&buffer, &left);
+			if (err)
+				return err;
+			err = proc_get_ulong(&buffer, &left, &lval, &neg,
+					     proc_wspace_sep,
+					     sizeof(proc_wspace_sep), NULL);
+			if (err)
 				break;
-			s += len;
-			left -= len;
-
-			if (conv(&neg, &lval, i, 1, data))
+			if (conv(&neg, &lval, i, 1, data)) {
+				err = -EINVAL;
 				break;
+			}
 		} else {
-			p = buf;
-			if (!first)
-				*p++ = '\t';
-	
-			if (conv(&neg, &lval, i, 0, data))
+			if (conv(&neg, &lval, i, 0, data)) {
+				err = -EINVAL;
 				break;
-
-			sprintf(p, "%s%lu", neg ? "-" : "", lval);
-			len = strlen(buf);
-			if (len > left)
-				len = left;
-			if(copy_to_user(s, buf, len))
-				return -EFAULT;
-			left -= len;
-			s += len;
-		}
-	}
-
-	if (!write && !first && left) {
-		if(put_user('\n', s))
-			return -EFAULT;
-		left--, s++;
-	}
-	if (write) {
-		while (left) {
-			char c;
-			if (get_user(c, s++))
-				return -EFAULT;
-			if (!isspace(c))
+			}
+			err = proc_put_ulong(&buffer, &left, lval, neg, first,
+					     '\t');
+			if (err)
 				break;
-			left--;
 		}
 	}
+
+	if (!write && !first && left && !err)
+		err = proc_put_char(&buffer, &left, '\n');
+	if (write && !err)
+		err = proc_skip_wspace(&buffer, &left);
 	if (write && first)
-		return -EINVAL;
+		return err ? : -EINVAL;
 	*lenp -= left;
 	*ppos += *lenp;
 	return 0;
-#undef TMPBUFLEN
 }
 
 static int do_proc_dointvec(struct ctl_table *table, int write,
 		  void __user *buffer, size_t *lenp, loff_t *ppos,
-		  int (*conv)(int *negp, unsigned long *lvalp, int *valp,
+		  int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
 			      int write, void *data),
 		  void *data)
 {
@@ -2238,8 +2336,8 @@ struct do_proc_dointvec_minmax_conv_para
 	int *max;
 };
 
-static int do_proc_dointvec_minmax_conv(int *negp, unsigned long *lvalp, 
-					int *valp, 
+static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp,
+					int *valp,
 					int write, void *data)
 {
 	struct do_proc_dointvec_minmax_conv_param *param = data;
@@ -2252,7 +2350,7 @@ static int do_proc_dointvec_minmax_conv(
 	} else {
 		int val = *valp;
 		if (val < 0) {
-			*negp = -1;
+			*negp = 1;
 			*lvalp = (unsigned long)-val;
 		} else {
 			*negp = 0;
@@ -2290,17 +2388,15 @@ int proc_dointvec_minmax(struct ctl_tabl
 }
 
 static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int write,
-				     void __user *buffer,
+				     void __user *_buffer,
 				     size_t *lenp, loff_t *ppos,
 				     unsigned long convmul,
 				     unsigned long convdiv)
 {
-#define TMPBUFLEN 21
-	unsigned long *i, *min, *max, val;
-	int vleft, first=1, neg;
-	size_t len, left;
-	char buf[TMPBUFLEN], *p;
-	char __user *s = buffer;
+	unsigned long *i, *min, *max;
+	int vleft, first = 1, err = 0;
+	size_t left;
+	char __user *buffer = (char __user *) _buffer;
 	
 	if (!data || !table->maxlen || !*lenp ||
 	    (*ppos && !write)) {
@@ -2315,82 +2411,42 @@ static int __do_proc_doulongvec_minmax(v
 	left = *lenp;
 	
 	for (; left && vleft--; i++, min++, max++, first=0) {
+		unsigned long val;
+
 		if (write) {
-			while (left) {
-				char c;
-				if (get_user(c, s))
-					return -EFAULT;
-				if (!isspace(c))
-					break;
-				left--;
-				s++;
-			}
-			if (!left)
-				break;
-			neg = 0;
-			len = left;
-			if (len > TMPBUFLEN-1)
-				len = TMPBUFLEN-1;
-			if (copy_from_user(buf, s, len))
-				return -EFAULT;
-			buf[len] = 0;
-			p = buf;
-			if (*p == '-' && left > 1) {
-				neg = 1;
-				p++;
-			}
-			if (*p < '0' || *p > '9')
-				break;
-			val = simple_strtoul(p, &p, 0) * convmul / convdiv ;
-			len = p-buf;
-			if ((len < left) && *p && !isspace(*p))
+			bool neg;
+
+			err = proc_skip_wspace(&buffer, &left);
+			if (err)
+				return err;
+			err = proc_get_ulong(&buffer, &left, &val, &neg,
+					     proc_wspace_sep,
+					     sizeof(proc_wspace_sep), NULL);
+			if (err)
 				break;
 			if (neg)
-				val = -val;
-			s += len;
-			left -= len;
-
-			if(neg)
 				continue;
 			if ((min && val < *min) || (max && val > *max))
 				continue;
 			*i = val;
 		} else {
-			p = buf;
-			if (!first)
-				*p++ = '\t';
-			sprintf(p, "%lu", convdiv * (*i) / convmul);
-			len = strlen(buf);
-			if (len > left)
-				len = left;
-			if(copy_to_user(s, buf, len))
-				return -EFAULT;
-			left -= len;
-			s += len;
-		}
-	}
-
-	if (!write && !first && left) {
-		if(put_user('\n', s))
-			return -EFAULT;
-		left--, s++;
-	}
-	if (write) {
-		while (left) {
-			char c;
-			if (get_user(c, s++))
-				return -EFAULT;
-			if (!isspace(c))
+			val = convdiv * (*i) / convmul;
+			err = proc_put_ulong(&buffer, &left, val, 0, first,
+					     '\t');
+			if (err)
 				break;
-			left--;
 		}
 	}
+
+	if (!write && !first && left && !err)
+		err = proc_put_char(&buffer, &left, '\n');
+	if (write && !err)
+		err = proc_skip_wspace(&buffer, &left);
 	if (write && first)
-		return -EINVAL;
+		return err ? : -EINVAL;
 	*lenp -= left;
 	*ppos += *lenp;
 	return 0;
-#undef TMPBUFLEN
 }
 
 static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
@@ -2451,7 +2507,7 @@ int proc_doulongvec_ms_jiffies_minmax(st
 }
 
 
-static int do_proc_dointvec_jiffies_conv(int *negp, unsigned long *lvalp,
+static int do_proc_dointvec_jiffies_conv(bool *negp, unsigned long *lvalp,
 					 int *valp,
 					 int write, void *data)
 {
@@ -2463,7 +2519,7 @@ static int do_proc_dointvec_jiffies_conv
 		int val = *valp;
 		unsigned long lval;
 		if (val < 0) {
-			*negp = -1;
+			*negp = 1;
 			lval = (unsigned long)-val;
 		} else {
 			*negp = 0;
@@ -2474,7 +2530,7 @@ static int do_proc_dointvec_jiffies_conv
 	return 0;
 }
 
-static int do_proc_dointvec_userhz_jiffies_conv(int *negp, unsigned long *lvalp,
+static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp,
 						int *valp,
 						int write, void *data)
 {
@@ -2486,7 +2542,7 @@ static int do_proc_dointvec_userhz_jiffi
 		int val = *valp;
 		unsigned long lval;
 		if (val < 0) {
-			*negp = -1;
+			*negp = 1;
 			lval = (unsigned long)-val;
 		} else {
 			*negp = 0;
@@ -2497,7 +2553,7 @@ static int do_proc_dointvec_userhz_jiffi
 	return 0;
 }
 
-static int do_proc_dointvec_ms_jiffies_conv(int *negp, unsigned long *lvalp,
+static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp,
 					    int *valp,
 					    int write, void *data)
 {
@@ -2507,7 +2563,7 @@ static int do_proc_dointvec_ms_jiffies_c
 		int val = *valp;
 		unsigned long lval;
 		if (val < 0) {
-			*negp = -1;
+			*negp = 1;
 			lval = (unsigned long)-val;
 		} else {
 			*negp = 0;
#2 lore raw

Re: [Patch 1/3] sysctl: refactor integer handling proc code

Quoted 94 lines · Amerigo Wang

From: Octavian Purdila <[email protected]>

As we are about to add another integer handling proc function a little bit of cleanup is in order: add a few helper functions to improve code readability and decrease code duplication.

In the process a bug is also fixed: if the user specifies a number with more then 20 digits it will be interpreted as two integers (e.g. 10000...13 will be interpreted as 100.... and 13).

Behavior for EFAULT handling was changed as well. Previous to this patch, when an EFAULT error occurred in the middle of a write operation, although some of the elements were set, that was not acknowledged to the user (by shorting the write and returning the number of bytes accepted). EFAULT is now treated just like any other errors by acknowledging the amount of bytes accepted.

---

Index: linux-2.6/kernel/sysctl.c
===================================================================

kernel/sysctl.c +63 -0
@@ -2040,8 +2040,148 @@ int proc_dostring(struct ctl_table *tabl
                               buffer, lenp, ppos);
  }
 
+static int proc_skip_wspace(char __user **buf, size_t *size)
+{
+       char c;
+
+       while (*size) {
+               if (get_user(c, *buf))
+                       return -EFAULT;
+               if (!isspace(c))
+                       break;
+               (*size)--;
+               (*buf)++;
+       }
+
+       return 0;
+}
+
+static bool isanyof(char c, const char *v, unsigned len)
+{
+       int i;
+
+       if (!len)
+               return false;
+
+       for (i = 0; i < len; i++)
+               if (c == v[i])
+                       break;
+       if (i == len)
+               return false;
+
+       return true;
+}
+
+#define TMPBUFLEN 22
+/**
+ * proc_get_ulong - reads an ASCII formated integer from a user buffer
+ *
+ * @buf - user buffer
+ * @size - size of the user buffer
+ * @val - this is where the number will be stored
+ * @neg - set to %TRUE if number is negative
+ * @perm_tr - a vector which contains the allowed trailers
+ * @perm_tr_len - size of the perm_tr vector
+ * @tr - pointer to store the trailer character
+ *
+ * In case of success 0 is returned and buf and size are updated with
+ * the amount of bytes read. If tr is non NULL and a trailing
+ * character exist (size is non zero after returning from this
+ * function) tr is updated with the trailing character.
+ */
+static int proc_get_ulong(char __user **buf, size_t *size,
+                         unsigned long *val, bool *neg,
+                         const char *perm_tr, unsigned perm_tr_len, char *tr)
+{
+       int len;
+       char *p, tmp[TMPBUFLEN];
+
+       if (!*size)
+               return -EINVAL;
+
+       len = *size;
+       if (len > TMPBUFLEN-1)
+               len = TMPBUFLEN-1;
+

kernel/sysctl.c int proc_dostring(struct ctl_table *tabl · line 2115

Quoted 10 lines
kernel/sysctl.c +10 -0
+       if (copy_from_user(tmp, *buf, len))
+               return -EFAULT;
+
+       tmp[len] = 0;
+       p = tmp;
+       if (*p == '-' && *size > 1) {
+               *neg = 1;
+               p++;
+       } else
+               *neg = 0;

the function name implies that it is used to parse unsigned long, so negative value should not be supported.

kernel/sysctl.c int proc_dostring(struct ctl_table *tabl · line 2117

Quoted 2 lines
kernel/sysctl.c +2 -0
+       if (!isdigit(*p))
+               return -EINVAL;

It seems that ledding white space should be allowed, so this check isn't needed, and simple_strtoul can handle it.

kernel/sysctl.c int proc_dostring(struct ctl_table *tabl · line 2130

Quoted 13 lines
kernel/sysctl.c +13 -0
+
+       *val = simple_strtoul(p, &p, 0);
+
+       len = p - tmp;
+
+       /* We don't know if the next char is whitespace thus we may accept
+        * invalid integers (e.g. 1234...a) or two integers instead of one
+        * (e.g. 123...1). So lets not allow such large numbers. */
+       if (len == TMPBUFLEN - 1)
+               return -EINVAL;
+
+       if (len < *size && perm_tr_len && !isanyof(*p, perm_tr, perm_tr_len))
+               return -EINVAL;

is strspn() better?

Quoted 22 lines
kernel/sysctl.c +22 -0
+
+       if (tr && (len < *size))
+               *tr = *p;
+
+       *buf += len;
+       *size -= len;
+
+       return 0;
+}
+
+/**
+ * proc_put_ulong - coverts an integer to a decimal ASCII formated string
+ *
+ * @buf - the user buffer
+ * @size - the size of the user buffer
+ * @val - the integer to be converted
+ * @neg - sign of the number, %TRUE for negative
+ * @first - if %FALSE will insert a separator character before the number
+ * @separator - the separator character
+ *
+ * In case of success 0 is returned and buf and size are updated with
+ * the amount of bytes read.

kernel/sysctl.c int proc_dostring(struct ctl_table *tabl · line 2162

Quoted 10 lines
kernel/sysctl.c +10 -0
+ */
+static int proc_put_ulong(char __user **buf, size_t *size, unsigned long val,
+                         bool neg, bool first, char separator)
+{
+       int len;
+       char tmp[TMPBUFLEN], *p = tmp;
+
+       if (!first)
+               *p++ = separator;
+       sprintf(p, "%s%lu", neg ? "-" : "", val);

negative should not be supported too.

Quoted 371 lines
kernel/sysctl.c +29 -11
+       len = strlen(tmp);
+       if (len > *size)
+               len = *size;
+       if (copy_to_user(*buf, tmp, len))
+               return -EFAULT;
+       *size -= len;
+       *buf += len;
+       return 0;
+}
+#undef TMPBUFLEN
+
+static int proc_put_char(char __user **buf, size_t *size, char c)
+{
+       if (*size) {
+               if (put_user(c, *buf))
+                       return -EFAULT;
+               (*size)--, (*buf)++;
+       }
+       return 0;
+}
 
-static int do_proc_dointvec_conv(int *negp, unsigned long *lvalp,
+static int do_proc_dointvec_conv(bool *negp, unsigned long *lvalp,
                                 int *valp,
                                 int write, void *data)
  {
@@ -2050,7 +2190,7 @@ static int do_proc_dointvec_conv(int *ne
        } else {
                int val = *valp;
                if (val < 0) {
-                       *negp = -1;
+                       *negp = 1;
                        *lvalp = (unsigned long)-val;
                } else {
                        *negp = 0;
@@ -2060,20 +2200,18 @@ static int do_proc_dointvec_conv(int *ne
        return 0;
  }
 
+static const char proc_wspace_sep[] = { ' ', '\t', '\n', 0 };
+
  static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
-                 int write, void __user *buffer,
+                 int write, void __user *_buffer,
                  size_t *lenp, loff_t *ppos,
-                 int (*conv)(int *negp, unsigned long *lvalp, int *valp,
+                 int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
                              int write, void *data),
                  void *data)
  {
-#define TMPBUFLEN 21
-       int *i, vleft, first = 1, neg;
-       unsigned long lval;
-       size_t left, len;
-
-       char buf[TMPBUFLEN], *p;
-       char __user *s = buffer;
+       int *i, vleft, first = 1, err = 0;
+       size_t left;
+       char __user *buffer = (char __user *) _buffer;
 

       if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {

kernel/sysctl.c +34 -76
@@ -2089,88 +2227,48 @@ static int __do_proc_dointvec(void *tbl_
                conv = do_proc_dointvec_conv;
 
        for (; left && vleft--; i++, first=0) {
-               if (write) {
-                       while (left) {
-                               char c;
-                               if (get_user(c, s))
-                                       return -EFAULT;
-                               if (!isspace(c))
-                                       break;
-                               left--;
-                               s++;
-                       }
-                       if (!left)
-                               break;
-                       neg = 0;
-                       len = left;
-                       if (len > sizeof(buf) - 1)
-                               len = sizeof(buf) - 1;
-                       if (copy_from_user(buf, s, len))
-                               return -EFAULT;
-                       buf[len] = 0;
-                       p = buf;
-                       if (*p == '-' && left > 1) {
-                               neg = 1;
-                               p++;
-                       }
-                       if (*p < '0' || *p > '9')
-                               break;
-
-                       lval = simple_strtoul(p, &p, 0);
+               unsigned long lval;
+               bool neg;
 
-                       len = p-buf;
-                       if ((len < left) && *p && !isspace(*p))
+               if (write) {
+                       err = proc_skip_wspace(&buffer, &left);
+                       if (err)
+                               return err;
+                       err = proc_get_ulong(&buffer, &left, &lval, &neg,
+                                            proc_wspace_sep,
+                                            sizeof(proc_wspace_sep), NULL);
+                       if (err)
                                break;
-                       s += len;
-                       left -= len;
-
-                       if (conv(&neg, &lval, i, 1, data))
+                       if (conv(&neg, &lval, i, 1, data)) {
+                               err = -EINVAL;
                                break;
+                       }
                } else {
-                       p = buf;
-                       if (!first)
-                               *p++ = '\t';
-
-                       if (conv(&neg, &lval, i, 0, data))
+                       if (conv(&neg, &lval, i, 0, data)) {
+                               err = -EINVAL;
                                break;
-
-                       sprintf(p, "%s%lu", neg ? "-" : "", lval);
-                       len = strlen(buf);
-                       if (len > left)
-                               len = left;
-                       if(copy_to_user(s, buf, len))
-                               return -EFAULT;
-                       left -= len;
-                       s += len;
-               }
-       }
-
-       if (!write && !first && left) {
-               if(put_user('\n', s))
-                       return -EFAULT;
-               left--, s++;
-       }
-       if (write) {
-               while (left) {
-                       char c;
-                       if (get_user(c, s++))
-                               return -EFAULT;
-                       if (!isspace(c))
+                       }
+                       err = proc_put_ulong(&buffer, &left, lval, neg, first,
+                                            '\t');
+                       if (err)
                                break;
-                       left--;
                }
        }
+
+       if (!write && !first && left && !err)
+               err = proc_put_char(&buffer, &left, '\n');
+       if (write && !err)
+               err = proc_skip_wspace(&buffer, &left);
        if (write && first)
-               return -EINVAL;
+               return err ? : -EINVAL;
        *lenp -= left;
        *ppos += *lenp;
        return 0;
-#undef TMPBUFLEN
  }
 
  static int do_proc_dointvec(struct ctl_table *table, int write,
                  void __user *buffer, size_t *lenp, loff_t *ppos,
-                 int (*conv)(int *negp, unsigned long *lvalp, int *valp,
+                 int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
                              int write, void *data),
                  void *data)
  {
@@ -2238,8 +2336,8 @@ struct do_proc_dointvec_minmax_conv_para
        int *max;
  };
 
-static int do_proc_dointvec_minmax_conv(int *negp, unsigned long *lvalp,
-                                       int *valp,
+static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp,
+                                       int *valp,
                                        int write, void *data)
  {
        struct do_proc_dointvec_minmax_conv_param *param = data;
@@ -2252,7 +2350,7 @@ static int do_proc_dointvec_minmax_conv(
        } else {
                int val = *valp;
                if (val < 0) {
-                       *negp = -1;
+                       *negp = 1;
                        *lvalp = (unsigned long)-val;
                } else {
                        *negp = 0;
@@ -2290,17 +2388,15 @@ int proc_dointvec_minmax(struct ctl_tabl
  }
 
  static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int write,
-                                    void __user *buffer,
+                                    void __user *_buffer,
                                     size_t *lenp, loff_t *ppos,
                                     unsigned long convmul,
                                     unsigned long convdiv)
  {
-#define TMPBUFLEN 21
-       unsigned long *i, *min, *max, val;
-       int vleft, first=1, neg;
-       size_t len, left;
-       char buf[TMPBUFLEN], *p;
-       char __user *s = buffer;
+       unsigned long *i, *min, *max;
+       int vleft, first = 1, err = 0;
+       size_t left;
+       char __user *buffer = (char __user *) _buffer;
 

       if (!data || !table->maxlen || !*lenp ||
           (*ppos && !write)) {

kernel/sysctl.c +26 -66
@@ -2315,82 +2411,42 @@ static int __do_proc_doulongvec_minmax(v
        left = *lenp;
 
        for (; left && vleft--; i++, min++, max++, first=0) {
+               unsigned long val;
+
                if (write) {
-                       while (left) {
-                               char c;
-                               if (get_user(c, s))
-                                       return -EFAULT;
-                               if (!isspace(c))
-                                       break;
-                               left--;
-                               s++;
-                       }
-                       if (!left)
-                               break;
-                       neg = 0;
-                       len = left;
-                       if (len > TMPBUFLEN-1)
-                               len = TMPBUFLEN-1;
-                       if (copy_from_user(buf, s, len))
-                               return -EFAULT;
-                       buf[len] = 0;
-                       p = buf;
-                       if (*p == '-' && left > 1) {
-                               neg = 1;
-                               p++;
-                       }
-                       if (*p < '0' || *p > '9')
-                               break;
-                       val = simple_strtoul(p, &p, 0) * convmul / convdiv ;
-                       len = p-buf;
-                       if ((len < left) && *p && !isspace(*p))
+                       bool neg;
+
+                       err = proc_skip_wspace(&buffer, &left);
+                       if (err)
+                               return err;
+                       err = proc_get_ulong(&buffer, &left, &val, &neg,
+                                            proc_wspace_sep,
+                                            sizeof(proc_wspace_sep), NULL);
+                       if (err)
                                break;
                        if (neg)
-                               val = -val;
-                       s += len;
-                       left -= len;
-
-                       if(neg)
                                continue;
                        if ((min && val < *min) || (max && val > *max))
                                continue;
                        *i = val;
                } else {
-                       p = buf;
-                       if (!first)
-                               *p++ = '\t';
-                       sprintf(p, "%lu", convdiv * (*i) / convmul);
-                       len = strlen(buf);
-                       if (len > left)
-                               len = left;
-                       if(copy_to_user(s, buf, len))
-                               return -EFAULT;
-                       left -= len;
-                       s += len;
-               }
-       }
-
-       if (!write && !first && left) {
-               if(put_user('\n', s))
-                       return -EFAULT;
-               left--, s++;
-       }
-       if (write) {
-               while (left) {
-                       char c;
-                       if (get_user(c, s++))
-                               return -EFAULT;
-                       if (!isspace(c))
+                       val = convdiv * (*i) / convmul;
+                       err = proc_put_ulong(&buffer, &left, val, 0, first,
+                                            '\t');
+                       if (err)
                                break;
-                       left--;
                }
        }
+
+       if (!write && !first && left && !err)
+               err = proc_put_char(&buffer, &left, '\n');
+       if (write && !err)
+               err = proc_skip_wspace(&buffer, &left);
        if (write && first)
-               return -EINVAL;
+               return err ? : -EINVAL;
        *lenp -= left;
        *ppos += *lenp;
        return 0;
-#undef TMPBUFLEN
  }
 
  static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
@@ -2451,7 +2507,7 @@ int proc_doulongvec_ms_jiffies_minmax(st
  }
 
 
-static int do_proc_dointvec_jiffies_conv(int *negp, unsigned long *lvalp,
+static int do_proc_dointvec_jiffies_conv(bool *negp, unsigned long *lvalp,
                                         int *valp,
                                         int write, void *data)
  {
@@ -2463,7 +2519,7 @@ static int do_proc_dointvec_jiffies_conv
                int val = *valp;
                unsigned long lval;
                if (val < 0) {
-                       *negp = -1;
+                       *negp = 1;
                        lval = (unsigned long)-val;
                } else {
                        *negp = 0;
@@ -2474,7 +2530,7 @@ static int do_proc_dointvec_jiffies_conv
        return 0;
  }
 
-static int do_proc_dointvec_userhz_jiffies_conv(int *negp, unsigned long *lvalp,
+static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp,
                                                int *valp,
                                                int write, void *data)
  {
@@ -2486,7 +2542,7 @@ static int do_proc_dointvec_userhz_jiffi
                int val = *valp;
                unsigned long lval;
                if (val < 0) {
-                       *negp = -1;
+                       *negp = 1;
                        lval = (unsigned long)-val;
                } else {
                        *negp = 0;
@@ -2497,7 +2553,7 @@ static int do_proc_dointvec_userhz_jiffi
        return 0;
  }
 
-static int do_proc_dointvec_ms_jiffies_conv(int *negp, unsigned long *lvalp,
+static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp,
                                            int *valp,
                                            int write, void *data)
  {

kernel/sysctl.c static int do_proc_dointvec_ms_jiffies_c · line 2569

Quoted 8 lines
kernel/sysctl.c +1 -1
@@ -2507,7 +2563,7 @@ static int do_proc_dointvec_ms_jiffies_c
                int val = *valp;
                unsigned long lval;
                if (val < 0) {
-                       *negp = -1;
+                       *negp = 1;
                        lval = (unsigned long)-val;
                } else {
                        *negp = 0;

These functions have so much lines of code. I think you can make them less. Please refer to strsep().

Signature · 2 lines
Regards,
Changli Gao([email protected])
#3 lore raw

Re: [Patch 1/3] sysctl: refactor integer handling proc code

Hi and thanks for reviewing.

Quoted 25 lines · On Friday 09 April 2010 13:49:12 you wrote:
Quoted 25 lines

+ *
+ * In case of success 0 is returned and buf and size are updated with
+ * the amount of bytes read. If tr is non NULL and a trailing
+ * character exist (size is non zero after returning from this
+ * function) tr is updated with the trailing character.
+ */

kernel/sysctl.c +3 -0
+static int proc_get_ulong(char __user **buf, size_t *size,
+                         unsigned long *val, bool *neg,
+                         const char *perm_tr, unsigned perm_tr_len, char

*tr) +{

kernel/sysctl.c +15 -0
+       int len;
+       char *p, tmp[TMPBUFLEN];
+
+       if (!*size)
+               return -EINVAL;
+
+       len = *size;
+       if (len > TMPBUFLEN-1)
+               len = TMPBUFLEN-1;
+
+       if (copy_from_user(tmp, *buf, len))
+               return -EFAULT;
+
+       tmp[len] = 0;
+       p = tmp;
Quoted 9 lines

kernel/sysctl.c int proc_dostring(struct ctl_table *tabl · line 2115

Quoted 5 lines
kernel/sysctl.c +5 -0
+       if (*p == '-' && *size > 1) {
+               *neg = 1;
+               p++;
+       } else
+               *neg = 0;

the function name implies that it is used to parse unsigned long, so negative value should not be supported.

My intention was to signal that the argument is unsigned long and that the sign come separate in neg, but I am OK with changing the function name to proc_get_long() if you think that is better.

Quoted 6 lines

Review

Quoted 2 lines
(quoted diff) +2 -0
+       if (!isdigit(*p))
+               return -EINVAL;

It seems that ledding white space should be allowed, so this check isn't needed, and simple_strtoul can handle it.

Leading white space is skipped with proc_skip_space before calling this function. AFAICS simple_strtoul does not handle whitespaces.

Quoted 7 lines
Quoted 7 lines
kernel/sysctl.c +6 -0
+
+       *val = simple_strtoul(p, &p, 0);
+
+       len = p - tmp;
+
+       /* We don't know if the next char is whitespace thus we may

accept + * invalid integers (e.g. 1234...a) or two integers

Quoted 9 lines
Quoted 6 lines

instead of one + * (e.g. 123...1). So lets not allow such large
numbers. */ + if (len == TMPBUFLEN - 1)

kernel/sysctl.c +3 -0
+               return -EINVAL;
+
+       if (len < *size && perm_tr_len && !isanyof(*p, perm_tr,

perm_tr_len)) + return -EINVAL;

is strspn() better?

I don't think it will work out, \0 is an accepted trailer for many of the function which use this function.

Quoted 26 lines
Quoted 26 lines
kernel/sysctl.c +12 -0
+
+       if (tr && (len < *size))
+               *tr = *p;
+
+       *buf += len;
+       *size -= len;
+
+       return 0;
+}
+
+/**
+ * proc_put_ulong - coverts an integer to a decimal ASCII formated

string + *
+ * @buf - the user buffer
+ * @size - the size of the user buffer
+ * @val - the integer to be converted
+ * @neg - sign of the number, %TRUE for negative
+ * @first - if %FALSE will insert a separator character before the number + * @separator - the separator character
+ *
+ * In case of success 0 is returned and buf and size are updated with
+ * the amount of bytes read.
+ */
+static int proc_put_ulong(char __user **buf, size_t *size, unsigned long
val, + bool neg, bool first, char separator)
+{

Quoted 9 lines

kernel/sysctl.c int proc_dostring(struct ctl_table *tabl · line 2162

Quoted 6 lines
kernel/sysctl.c +6 -0
+       int len;
+       char tmp[TMPBUFLEN], *p = tmp;
+
+       if (!first)
+               *p++ = separator;
+       sprintf(p, "%s%lu", neg ? "-" : "", val);

negative should not be supported too.

We need negatives in proc_dointvec, again we can change the function name if it will clear things up.

<snip>

Quoted 9 lines

kernel/sysctl.c static int do_proc_dointvec_jiffies_conv · line 2525

Quoted 8 lines
               int val = *valp;
               unsigned long lval;
               if (val < 0) {
kernel/sysctl.c +1 -1
-                       *negp = -1;
+                       *negp = 1;
                       lval = (unsigned long)-val;
               } else {
                       *negp = 0;
Quoted 3 lines

These functions have so much lines of code. I think you can make them less. Please refer to strsep().

Hmm, the input its pretty permissive and maybe this is why it looks so fat, we need to account for quite a few cases.

Or maybe I spent too much time on this code already and I can't see the simple solution :)

Thanks,
tavi

author
#4 lore raw

Re: [Patch 1/3] sysctl: refactor integer handling proc code

Quoted 39 lines · Octavian Purdila

Hi and thanks for reviewing.

Quoted 24 lines · On Friday 09 April 2010 13:49:12 you wrote:
Quoted 24 lines

+ *
+ * In case of success 0 is returned and buf and size are updated with
+ * the amount of bytes read. If tr is non NULL and a trailing
+ * character exist (size is non zero after returning from this
+ * function) tr is updated with the trailing character.
+ */

kernel/sysctl.c +3 -0
+static int proc_get_ulong(char __user **buf, size_t *size,
+                         unsigned long *val, bool *neg,
+                         const char *perm_tr, unsigned perm_tr_len, char

*tr) +{

kernel/sysctl.c +14 -0
+       int len;
+       char *p, tmp[TMPBUFLEN];
+
+       if (!*size)
+               return -EINVAL;
+
+       len = *size;
+       if (len > TMPBUFLEN-1)
+               len = TMPBUFLEN-1;
+
+       if (copy_from_user(tmp, *buf, len))
+               return -EFAULT;
+
+       tmp[len] = 0;
Quoted 9 lines

kernel/sysctl.c int proc_dostring(struct ctl_table *tabl · line 2115

Quoted 6 lines
kernel/sysctl.c +6 -0
+       p = tmp;
+       if (*p == '-' && *size > 1) {
+               *neg = 1;
+               p++;
+       } else
+               *neg = 0;

the function name implies that it is used to parse unsigned long, so negative value should not be supported.

My intention was to signal that the argument is unsigned long and that the sign come separate in neg, but I am OK with changing the function name to proc_get_long() if you think that is better.

Quoted 7 lines
Quoted 5 lines

Review

Quoted 2 lines
(quoted diff) +2 -0
+       if (!isdigit(*p))
+               return -EINVAL;

It seems that ledding white space should be allowed, so this check isn't needed, and simple_strtoul can handle it.

Leading white space is skipped with proc_skip_space before calling this function. AFAICS simple_strtoul does not handle whitespaces.

Right, callers already skip spaces.

Quoted 17 lines
Quoted 16 lines
Quoted 13 lines
kernel/sysctl.c +6 -0
+
+       *val = simple_strtoul(p, &p, 0);
+
+       len = p - tmp;
+
+       /* We don't know if the next char is whitespace thus we may

accept + * invalid integers (e.g. 1234...a) or two integers
instead of one + * (e.g. 123...1). So lets not allow such large
numbers. */ + if (len == TMPBUFLEN - 1)

kernel/sysctl.c +3 -0
+               return -EINVAL;
+
+       if (len < *size && perm_tr_len && !isanyof(*p, perm_tr,
Quoted 1 line

perm_tr_len)) + return -EINVAL;

is strspn() better?

Quoted 2 lines

I don't think it will work out, \0 is an accepted trailer for many of the function which use this function.

Yes, that is why 'len' is the last parameter of isanyof().

Quoted 36 lines
Quoted 26 lines
Quoted 26 lines
kernel/sysctl.c +12 -0
+
+       if (tr && (len < *size))
+               *tr = *p;
+
+       *buf += len;
+       *size -= len;
+
+       return 0;
+}
+
+/**
+ * proc_put_ulong - coverts an integer to a decimal ASCII formated

string + *
+ * @buf - the user buffer
+ * @size - the size of the user buffer
+ * @val - the integer to be converted
+ * @neg - sign of the number, %TRUE for negative
+ * @first - if %FALSE will insert a separator character before the number + * @separator - the separator character
+ *
+ * In case of success 0 is returned and buf and size are updated with
+ * the amount of bytes read.
+ */
+static int proc_put_ulong(char __user **buf, size_t *size, unsigned long
val, + bool neg, bool first, char separator)

Quoted 9 lines

kernel/sysctl.c int proc_dostring(struct ctl_table *tabl · line 2162

Quoted 7 lines
kernel/sysctl.c +7 -0
+{
+       int len;
+       char tmp[TMPBUFLEN], *p = tmp;
+
+       if (!first)
+               *p++ = separator;
+       sprintf(p, "%s%lu", neg ? "-" : "", val);

negative should not be supported too.

Quoted 2 lines

We need negatives in proc_dointvec, again we can change the function name if it will clear things up.

Yeah, I will change them to proc_{get,put}_long().

Quoted 9 lines

<snip>

Quoted 8 lines
Quoted 8 lines
               int val = *valp;
               unsigned long lval;
               if (val < 0) {
kernel/sysctl.c +1 -1
-                       *negp = -1;
+                       *negp = 1;
                       lval = (unsigned long)-val;
               } else {
                       *negp = 0;
Quoted 6 lines
Quoted 3 lines

These functions have so much lines of code. I think you can make them less. Please refer to strsep().

Hmm, the input its pretty permissive and maybe this is why it looks so fat, we need to account for quite a few cases.

Because the original code is messy and already has much lines.

Thanks.

#5 lore raw

PATCH v7 2/3 sysctl: add proc_do_large_bitmap

In reply to Amerigo Wang

From: Octavian Purdila <[email protected]>

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.

---

include/linux/sysctl.h +2 -0
Index: 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
kernel/sysctl.c +146 -0

158 lines not on this page · raw message

#6 lore raw

Re: [Patch 2/3] sysctl: add proc_do_large_bitmap

Quoted 9 lines · Amerigo Wang

From: Octavian Purdila <[email protected]>

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.

We have bitmap_scnprintf() and bitmap_parse_user(), why invent a new suite?

Signature · 2 lines
Regards,
Changli Gao([email protected])
#7 lore raw

Re: [Patch 2/3] sysctl: add proc_do_large_bitmap

Quoted 12 lines · On Friday 09 April 2010 13:33:29 you wrote:
Quoted 8 lines · Amerigo Wang

From: Octavian Purdila <[email protected]>

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.

We have bitmap_scnprintf() and bitmap_parse_user(), why invent a new suite?

A decimal comma separated ranges seems the best option for this feature, and unfortunately both of the above functions only support hexadecimal and no ranges.

author
#8 lore raw

Re: [Patch 2/3] sysctl: add proc_do_large_bitmap

In reply to Changli Gao
Quoted 7 lines · Changli Gao
Quoted 6 lines · Amerigo Wang

From: Octavian Purdila <[email protected]>

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).

Quoted 7 lines
Quoted 3 lines

Writing into the file will first reset the bitmap then update it based on the given input.

We have bitmap_scnprintf() and bitmap_parse_user(), why invent a new suite?

Because they don't accept '-'.

#9 lore raw

PATCH v7 3/3 net: reserve ports for applications using fixed port numbers

In reply to Amerigo Wang

From: Octavian Purdila <[email protected]>

This patch introduces /proc/sys/net/ipv4/ip_local_reserved_ports which allows users to reserve ports for third-party applications.

The reserved ports will not be used by automatic port assignments (e.g. when calling connect() or bind() with port number 0). Explicit port allocation behavior is unchanged.

Cc Neil Horman <[email protected]>
Cc Eric Dumazet <[email protected]>
Cc Eric W. Biederman <[email protected]>

---

Documentation/networking/ip-sysctl.txt +31 -0
Index: linux-2.6/Documentation/networking/ip-sysctl.txt
===================================================================
@@ -588,6 +588,37 @@ ip_local_port_range - 2 INTEGERS
 	(i.e. by default) range 1024-4999 is enough to issue up to
 	2000 connections per second to systems supporting timestamps.
 
+ip_local_reserved_ports - list of comma separated ranges
+	Specify the ports which are reserved for known third-party
+	applications. These ports will not be used by automatic port
+	assignments (e.g. when calling connect() or bind() with port
+	number 0). Explicit port allocation behavior is unchanged.
+
+	The format used for both input and output is a comma separated
+	list of ranges (e.g. "1,2-4,10-10" for ports 1, 2, 3, 4 and
+	10). Writing to the file will clear all previously reserved
+	ports and update the current list with the one given in the
+	input.
+
+	Note that ip_local_port_range and ip_local_reserved_ports
+	settings are independent and both are considered by the kernel
+	when determining which ports are available for automatic port
+	assignments.
+
+	You can reserve ports which are not in the current
+	ip_local_port_range, e.g.:
+
+	$ cat /proc/sys/net/ipv4/ip_local_port_range
+	32000	61000
+	$ cat /proc/sys/net/ipv4/ip_local_reserved_ports
+	8080,9148
+
+	although this is redundant. However such a setting is useful
+	if later the port range is changed to a value that will
+	include the reserved ports.
+
+	Default: Empty
+
 ip_nonlocal_bind - BOOLEAN
 	If set, allows processes to bind() to non-local IP addresses,
 	which can be quite useful - but may break some applications.
drivers/infiniband/core/cma.c +6 -1
Index: linux-2.6/drivers/infiniband/core/cma.c
===================================================================
@@ -1980,6 +1980,8 @@ retry:
 	/* FIXME: add proper port randomization per like inet_csk_get_port */
 	do {
 		ret = idr_get_new_above(ps, bind_list, next_port, &port);
+		if (inet_is_reserved_local_port(port))
+			ret = -EAGAIN;
 	} while ((ret == -EAGAIN) && idr_pre_get(ps, GFP_KERNEL));
 
 	if (ret)
@@ -2996,10 +2998,13 @@ static int __init cma_init(void)
 {
 	int ret, low, high, remaining;
 
-	get_random_bytes(&next_port, sizeof next_port);
 	inet_get_local_port_range(&low, &high);
+again:
+	get_random_bytes(&next_port, sizeof next_port);
 	remaining = (high - low) + 1;
 	next_port = ((unsigned int) next_port % remaining) + low;
+	if (inet_is_reserved_local_port(next_port))
+		goto again;
 
 	cma_wq = create_singlethread_workqueue("rdma_cm");
 	if (!cma_wq)
include/net/ip.h +6 -0
Index: linux-2.6/include/net/ip.h
===================================================================
@@ -184,6 +184,12 @@ extern struct local_ports {
 } sysctl_local_ports;
 extern void inet_get_local_port_range(int *low, int *high);
 
+extern unsigned long *sysctl_local_reserved_ports;
+static inline int inet_is_reserved_local_port(int port)
+{
+	return test_bit(port, sysctl_local_reserved_ports);
+}
+
 extern int sysctl_ip_default_ttl;
 extern int sysctl_ip_nonlocal_bind;
 
net/ipv4/af_inet.c +7 -1
Index: linux-2.6/net/ipv4/af_inet.c
===================================================================
@@ -1552,9 +1552,13 @@ static int __init inet_init(void)
 
 	BUILD_BUG_ON(sizeof(struct inet_skb_parm) > sizeof(dummy_skb->cb));
 
+	sysctl_local_reserved_ports = kzalloc(65536 / 8, GFP_KERNEL);
+	if (!sysctl_local_reserved_ports)
+		goto out;
+
 	rc = proto_register(&tcp_prot, 1);
 	if (rc)
-		goto out;
+		goto out_free_reserved_ports;
 
 	rc = proto_register(&udp_prot, 1);
 	if (rc)
@@ -1653,6 +1657,8 @@ out_unregister_udp_proto:
 	proto_unregister(&udp_prot);
 out_unregister_tcp_proto:
 	proto_unregister(&tcp_prot);
+out_free_reserved_ports:
+	kfree(sysctl_local_reserved_ports);
 	goto out;
 }
 
net/ipv4/inet_connection_sock.c +6 -0
Index: linux-2.6/net/ipv4/inet_connection_sock.c
===================================================================
@@ -37,6 +37,9 @@ struct local_ports sysctl_local_ports __
 	.range = { 32768, 61000 },
 };
 
+unsigned long *sysctl_local_reserved_ports;
+EXPORT_SYMBOL(sysctl_local_reserved_ports);
+
 void inet_get_local_port_range(int *low, int *high)
 {
 	unsigned seq;
@@ -108,6 +111,8 @@ again:
 
 		smallest_size = -1;
 		do {
+			if (inet_is_reserved_local_port(rover))
+				goto next_nolock;
 			head = &hashinfo->bhash[inet_bhashfn(net, rover,
 					hashinfo->bhash_size)];
 			spin_lock(&head->lock);
@@ -130,6 +135,7 @@ again:
 			break;
 		next:
 			spin_unlock(&head->lock);
+		next_nolock:
 			if (++rover > high)
 				rover = low;
 		} while (--remaining > 0);
net/ipv4/inet_hashtables.c +2 -0
Index: linux-2.6/net/ipv4/inet_hashtables.c
===================================================================
@@ -456,6 +456,8 @@ int __inet_hash_connect(struct inet_time
 		local_bh_disable();
 		for (i = 1; i <= remaining; i++) {
 			port = low + (i + offset) % remaining;
+			if (inet_is_reserved_local_port(port))
+				continue;
 			head = &hinfo->bhash[inet_bhashfn(net, port,
 					hinfo->bhash_size)];
 			spin_lock(&head->lock);
net/ipv4/sysctl_net_ipv4.c +17 -0
Index: linux-2.6/net/ipv4/sysctl_net_ipv4.c
===================================================================
@@ -299,6 +299,13 @@ static struct ctl_table ipv4_table[] = {
 		.mode		= 0644,
 		.proc_handler	= ipv4_local_port_range,
 	},
+	{
+		.procname	= "ip_local_reserved_ports",
+		.data		= NULL, /* initialized in sysctl_ipv4_init */
+		.maxlen		= 65536,
+		.mode		= 0644,
+		.proc_handler	= proc_do_large_bitmap,
+	},
 #ifdef CONFIG_IP_MULTICAST
 	{
 		.procname	= "igmp_max_memberships",
@@ -736,6 +743,16 @@ static __net_initdata struct pernet_oper
 static __init int sysctl_ipv4_init(void)
 {
 	struct ctl_table_header *hdr;
+	struct ctl_table *i;
+
+	for (i = ipv4_table; i->procname; i++) {
+		if (strcmp(i->procname, "ip_local_reserved_ports") == 0) {
+			i->data = sysctl_local_reserved_ports;
+			break;
+		}
+	}
+	if (!i->procname)
+		return -EINVAL;
 
 	hdr = register_sysctl_paths(net_ipv4_ctl_path, ipv4_table);
 	if (hdr == NULL)
net/ipv4/udp.c +2 -1
Index: linux-2.6/net/ipv4/udp.c
===================================================================
@@ -233,7 +233,8 @@ int udp_lib_get_port(struct sock *sk, un
 			 */
 			do {
 				if (low <= snum && snum <= high &&
-				    !test_bit(snum >> udptable->log, bitmap))
+				    !test_bit(snum >> udptable->log, bitmap) &&
+				    !inet_is_reserved_local_port(snum))
 					goto found;
 				snum += rand;
 			} while (snum != first);
net/sctp/socket.c +2 -0
Index: linux-2.6/net/sctp/socket.c
===================================================================
@@ -5436,6 +5436,8 @@ static long sctp_get_port_local(struct s
 			rover++;
 			if ((rover < low) || (rover > high))
 				rover = low;
+			if (inet_is_reserved_local_port(rover))
+				continue;
 			index = sctp_phashfn(rover);
 			head = &sctp_port_hashtable[index];
 			sctp_spin_lock(&head->lock);
#10 lore raw

Hello.

drivers/infiniband/core/cma.c retry: · line 1984

Quoted 10 lines · Amerigo Wang

Index: linux-2.6/drivers/infiniband/core/cma.c
===================================================================

drivers/infiniband/core/cma.c +2 -0
@@ -1980,6 +1980,8 @@ retry:
 	/* FIXME: add proper port randomization per like inet_csk_get_port */
 	do {
 		ret = idr_get_new_above(ps, bind_list, next_port, &port);
+		if (inet_is_reserved_local_port(port))
+			ret = -EAGAIN;

You should not overwrite ret with -EAGAIN when idr_get_new_above() returned -ENOSPC. I don't know about idr, thus I don't know whether

		if (!ret && inet_is_reserved_local_port(port))
			ret = -EAGAIN;

is correct or not.

Quoted 6 lines
drivers/infiniband/core/cma.c +0 -0
 	} while ((ret == -EAGAIN) && idr_pre_get(ps, GFP_KERNEL));
 
 	if (ret)
@@ -2996,10 +2998,13 @@ static int __init cma_init(void)
 {
 	int ret, low, high, remaining;

drivers/infiniband/core/cma.c static int __init cma_init(void) · line 3008

Quoted 10 lines
drivers/infiniband/core/cma.c +4 -1
 
-	get_random_bytes(&next_port, sizeof next_port);
 	inet_get_local_port_range(&low, &high);
+again:
+	get_random_bytes(&next_port, sizeof next_port);
 	remaining = (high - low) + 1;
 	next_port = ((unsigned int) next_port % remaining) + low;
+	if (inet_is_reserved_local_port(next_port))
+		goto again;
 

You should not unconditionally "goto again;".
If all ports were reserved, it will loop forever (CPU stalls).

Quoted 9 lines
drivers/infiniband/core/cma.c +0 -0
 	cma_wq = create_singlethread_workqueue("rdma_cm");
 	if (!cma_wq)

Index: linux-2.6/net/sctp/socket.c
===================================================================

net/sctp/socket.c static long sctp_get_port_local(struct s · line 5440

Quoted 5 lines
net/sctp/socket.c +2 -0
@@ -5436,6 +5436,8 @@ static long sctp_get_port_local(struct s
 			rover++;
 			if ((rover < low) || (rover > high))
 				rover = low;
+			if (inet_is_reserved_local_port(rover))
+				continue;

This one needs to be

			if (inet_is_reserved_local_port(rover))
				goto next_nolock;

net/sctp/socket.c static long sctp_get_port_local(struct s · line 5443

Quoted 3 lines
net/sctp/socket.c +0 -0
 			index = sctp_phashfn(rover);
 			head = &sctp_port_hashtable[index];
 			sctp_spin_lock(&head->lock);

next:

			sctp_spin_unlock(&head->lock);
+next_nolock:
		} while (--remaining > 0);

otherwise, it will loop forever if all ports were reserved.

author
#11 lore raw
Quoted 17 lines · Tetsuo Handa

Hello.

drivers/infiniband/core/cma.c retry: · line 1984

Quoted 10 lines · Amerigo Wang

Index: linux-2.6/drivers/infiniband/core/cma.c
===================================================================

drivers/infiniband/core/cma.c +2 -0
@@ -1980,6 +1980,8 @@ retry:
 	/* FIXME: add proper port randomization per like inet_csk_get_port */
 	do {
 		ret = idr_get_new_above(ps, bind_list, next_port, &port);
+		if (inet_is_reserved_local_port(port))
+			ret = -EAGAIN;

You should not overwrite ret with -EAGAIN when idr_get_new_above() returned -ENOSPC. I don't know about idr, thus I don't know whether

Quoted 4 lines
		if (!ret && inet_is_reserved_local_port(port))
			ret = -EAGAIN;

is correct or not.

Hmm, good catch! I think it is correct.

Quoted 8 lines
Quoted 8 lines
drivers/infiniband/core/cma.c +0 -0
 	} while ((ret == -EAGAIN) && idr_pre_get(ps, GFP_KERNEL));
 
 	if (ret)
@@ -2996,10 +2998,13 @@ static int __init cma_init(void)
 {
 	int ret, low, high, remaining;
 
Quoted 13 lines

drivers/infiniband/core/cma.c static int __init cma_init(void) · line 3008

Quoted 9 lines
drivers/infiniband/core/cma.c +4 -1
-	get_random_bytes(&next_port, sizeof next_port);
 	inet_get_local_port_range(&low, &high);
+again:
+	get_random_bytes(&next_port, sizeof next_port);
 	remaining = (high - low) + 1;
 	next_port = ((unsigned int) next_port % remaining) + low;
+	if (inet_is_reserved_local_port(next_port))
+		goto again;
 

You should not unconditionally "goto again;".
If all ports were reserved, it will loop forever (CPU stalls).

Yeah, how about:

	int tries = 10;
	...
again:
	...
	if (inet_is_reserved_local_port(next_port)) {
		if (tries--)
			goto again;
		else
			return -EBUSY;
	}

?

Quoted 24 lines
Quoted 9 lines
drivers/infiniband/core/cma.c +0 -0
 	cma_wq = create_singlethread_workqueue("rdma_cm");
 	if (!cma_wq)

Index: linux-2.6/net/sctp/socket.c
===================================================================

net/sctp/socket.c static long sctp_get_port_local(struct s · line 5440

Quoted 5 lines
net/sctp/socket.c +2 -0
@@ -5436,6 +5436,8 @@ static long sctp_get_port_local(struct s
 			rover++;
 			if ((rover < low) || (rover > high))
 				rover = low;
+			if (inet_is_reserved_local_port(rover))
+				continue;

This one needs to be

			if (inet_is_reserved_local_port(rover))
				goto next_nolock;

net/sctp/socket.c static long sctp_get_port_local(struct s · line 5443

Quoted 3 lines
net/sctp/socket.c +0 -0
 			index = sctp_phashfn(rover);
 			head = &sctp_port_hashtable[index];
 			sctp_spin_lock(&head->lock);
Quoted 6 lines

next:

			sctp_spin_unlock(&head->lock);
+next_nolock:
		} while (--remaining > 0);

otherwise, it will loop forever if all ports were reserved.

Sorry, doesn't 'continue' jump to exactly where 'next_nolock' is?? Or I am missing something?

Thanks for your review!

#12 lore raw
Quoted 26 lines · Cong Wang
Quoted 25 lines · Tetsuo Handa

net/sctp/socket.c static long sctp_get_port_local(struct s · line 5440

Quoted 10 lines

Index: linux-2.6/net/sctp/socket.c
===================================================================

net/sctp/socket.c +2 -0
@@ -5436,6 +5436,8 @@ static long sctp_get_port_local(struct s
 			rover++;
 			if ((rover < low) || (rover > high))
 				rover = low;
+			if (inet_is_reserved_local_port(rover))
+				continue;

This one needs to be

			if (inet_is_reserved_local_port(rover))
				goto next_nolock;

net/sctp/socket.c static long sctp_get_port_local(struct s · line 5443

Quoted 3 lines
net/sctp/socket.c +0 -0
 			index = sctp_phashfn(rover);
 			head = &sctp_port_hashtable[index];
 			sctp_spin_lock(&head->lock);

next:

			sctp_spin_unlock(&head->lock);
+next_nolock:
		} while (--remaining > 0);
Quoted 4 lines
Quoted 1 line

otherwise, it will loop forever if all ports were reserved.

Sorry, doesn't 'continue' jump to exactly where 'next_nolock' is?? Or I am missing something?

My misreading, sorry.