[PATCH 0/5] staging: Updates from the Android tree (for 3.10)

[PATCH 0/5] staging: Updates from the Android tree (for 3.10)

[John Stultz]

Hey Greg,
	I was looking over the current Android tree and noticed there
were a few updates that should be pushed into staging so upstream stays
in sync with what Android is using. I've already checked with the folks
at Google (cc'ed) and they had no objections to sending these to you.

Let me know if you have any objections or comments.

thanks
-john

Cc: Android Kernel Team <kernel-team@android.com>
Cc: Arve Hjønnevåg <arve@android.com>
Cc: Nick Kralevich <nnk@google.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Charndeep Grewal <csgrewa@tycho.ncsc.mil>

Arve Hjønnevåg (3):
  staging: android: lowmemorykiller: Add config option to support
    oom_adj values
  staging: android: lowmemorykiller: Don't count reserved free memory
  staging: android: lowmemorykiller: Change default debug_level to 1

Charndeep Grewal (1):
  staging: android: logger: enforce GID and CAP check on log flush

Nick Kralevich (1):
  staging: android: logger: Allow a UID to read it's own log entries

 drivers/staging/android/Kconfig           |    9 ++
 drivers/staging/android/logger.c          |  196 +++++++++++++++++++++++++----
 drivers/staging/android/logger.h          |   40 +++++-
 drivers/staging/android/lowmemorykiller.c |   90 ++++++++++++-
 4 files changed, 304 insertions(+), 31 deletions(-)

-- 
1.7.10.4

[PATCH 1/5] staging: android: lowmemorykiller: Add config option to support oom_adj values

[John Stultz]

From: Arve Hjønnevåg <arve@android.com>

The conversion to use oom_score_adj instead of the deprecated oom_adj
values breaks existing user-space code. Add a config option to convert
oom_adj values written to oom_score_adj values if they appear to be
valid oom_adj values.

Cc: Android Kernel Team <kernel-team@android.com>
Cc: Arve Hjønnevåg <arve@android.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Signed-off-by: Arve Hjønnevåg <arve@android.com>
Signed-off-by: John Stultz <john.stultz@linaro.org>
---
 drivers/staging/android/Kconfig           |    9 +++
 drivers/staging/android/lowmemorykiller.c |   85 +++++++++++++++++++++++++++++
 2 files changed, 94 insertions(+)

diff --git a/drivers/staging/android/Kconfig b/drivers/staging/android/Kconfig
index 465a28c..5663c61 100644
--- a/drivers/staging/android/Kconfig
+++ b/drivers/staging/android/Kconfig
@@ -63,6 +63,15 @@ config ANDROID_LOW_MEMORY_KILLER
 	---help---
 	  Registers processes to be killed when memory is low
 
+config ANDROID_LOW_MEMORY_KILLER_AUTODETECT_OOM_ADJ_VALUES
+	bool "Android Low Memory Killer: detect oom_adj values"
+	depends on ANDROID_LOW_MEMORY_KILLER
+	default y
+	---help---
+	  Detect oom_adj values written to
+	  /sys/module/lowmemorykiller/parameters/adj and convert them
+	  to oom_score_adj values.
+
 config ANDROID_INTF_ALARM_DEV
 	bool "Android alarm driver"
 	depends on RTC_CLASS
diff --git a/drivers/staging/android/lowmemorykiller.c b/drivers/staging/android/lowmemorykiller.c
index 3b91b0f..7e00bdb 100644
--- a/drivers/staging/android/lowmemorykiller.c
+++ b/drivers/staging/android/lowmemorykiller.c
@@ -175,9 +175,94 @@ static void __exit lowmem_exit(void)
 	unregister_shrinker(&lowmem_shrinker);
 }
 
+#ifdef CONFIG_ANDROID_LOW_MEMORY_KILLER_AUTODETECT_OOM_ADJ_VALUES
+static short lowmem_oom_adj_to_oom_score_adj(short oom_adj)
+{
+	if (oom_adj == OOM_ADJUST_MAX)
+		return OOM_SCORE_ADJ_MAX;
+	else
+		return (oom_adj * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE;
+}
+
+static void lowmem_autodetect_oom_adj_values(void)
+{
+	int i;
+	short oom_adj;
+	short oom_score_adj;
+	int array_size = ARRAY_SIZE(lowmem_adj);
+
+	if (lowmem_adj_size < array_size)
+		array_size = lowmem_adj_size;
+
+	if (array_size <= 0)
+		return;
+
+	oom_adj = lowmem_adj[array_size - 1];
+	if (oom_adj > OOM_ADJUST_MAX)
+		return;
+
+	oom_score_adj = lowmem_oom_adj_to_oom_score_adj(oom_adj);
+	if (oom_score_adj <= OOM_ADJUST_MAX)
+		return;
+
+	lowmem_print(1, "lowmem_shrink: convert oom_adj to oom_score_adj:\n");
+	for (i = 0; i < array_size; i++) {
+		oom_adj = lowmem_adj[i];
+		oom_score_adj = lowmem_oom_adj_to_oom_score_adj(oom_adj);
+		lowmem_adj[i] = oom_score_adj;
+		lowmem_print(1, "oom_adj %d => oom_score_adj %d\n",
+			     oom_adj, oom_score_adj);
+	}
+}
+
+static int lowmem_adj_array_set(const char *val, const struct kernel_param *kp)
+{
+	int ret;
+
+	ret = param_array_ops.set(val, kp);
+
+	/* HACK: Autodetect oom_adj values in lowmem_adj array */
+	lowmem_autodetect_oom_adj_values();
+
+	return ret;
+}
+
+static int lowmem_adj_array_get(char *buffer, const struct kernel_param *kp)
+{
+	return param_array_ops.get(buffer, kp);
+}
+
+static void lowmem_adj_array_free(void *arg)
+{
+	param_array_ops.free(arg);
+}
+
+static struct kernel_param_ops lowmem_adj_array_ops = {
+	.set = lowmem_adj_array_set,
+	.get = lowmem_adj_array_get,
+	.free = lowmem_adj_array_free,
+};
+
+static const struct kparam_array __param_arr_adj = {
+	.max = ARRAY_SIZE(lowmem_adj),
+	.num = &lowmem_adj_size,
+	.ops = &param_ops_short,
+	.elemsize = sizeof(lowmem_adj[0]),
+	.elem = lowmem_adj,
+};
+#endif
+
 module_param_named(cost, lowmem_shrinker.seeks, int, S_IRUGO | S_IWUSR);
+#ifdef CONFIG_ANDROID_LOW_MEMORY_KILLER_AUTODETECT_OOM_ADJ_VALUES
+__module_param_call(MODULE_PARAM_PREFIX, adj,
+		    &lowmem_adj_array_ops,
+		    .arr = &__param_arr_adj,
+		    S_IRUGO | S_IWUSR, -1);
+__MODULE_PARM_TYPE(adj, "array of short");
+#else
 module_param_array_named(adj, lowmem_adj, short, &lowmem_adj_size,
 			 S_IRUGO | S_IWUSR);
+#endif
 module_param_array_named(minfree, lowmem_minfree, uint, &lowmem_minfree_size,
 			 S_IRUGO | S_IWUSR);
 module_param_named(debug_level, lowmem_debug_level, uint, S_IRUGO | S_IWUSR);
-- 
1.7.10.4

[PATCH 2/5] staging: android: lowmemorykiller: Don't count reserved free memory

[John Stultz]

From: Arve Hjønnevåg <arve@android.com>

The amount of reserved memory varies between devices. Subtract it
here to reduce the amount of devices specific tuning needed for the
minfree values.

Cc: Android Kernel Team <kernel-team@android.com>
Cc: Arve Hjønnevåg <arve@android.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Signed-off-by: Arve Hjønnevåg <arve@android.com>
Signed-off-by: John Stultz <john.stultz@linaro.org>
---
 drivers/staging/android/lowmemorykiller.c |    3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/staging/android/lowmemorykiller.c b/drivers/staging/android/lowmemorykiller.c
index 7e00bdb..2f28763 100644
--- a/drivers/staging/android/lowmemorykiller.c
+++ b/drivers/staging/android/lowmemorykiller.c
@@ -35,6 +35,7 @@
 #include <linux/mm.h>
 #include <linux/oom.h>
 #include <linux/sched.h>
+#include <linux/swap.h>
 #include <linux/rcupdate.h>
 #include <linux/profile.h>
 #include <linux/notifier.h>
@@ -74,7 +75,7 @@ static int lowmem_shrink(struct shrinker *s, struct shrink_control *sc)
 	int selected_tasksize = 0;
 	short selected_oom_score_adj;
 	int array_size = ARRAY_SIZE(lowmem_adj);
-	int other_free = global_page_state(NR_FREE_PAGES);
+	int other_free = global_page_state(NR_FREE_PAGES) - totalreserve_pages;
 	int other_file = global_page_state(NR_FILE_PAGES) -
 						global_page_state(NR_SHMEM);
 
-- 
1.7.10.4

[PATCH 3/5] staging: android: lowmemorykiller: Change default debug_level to 1

[John Stultz]

From: Arve Hjønnevåg <arve@android.com>

The select...to kill messages are not very useful when not debugging
the lowmemorykiller itself. After the change to check TIF_MEMDIE
instead of using a task notifer this message can also get very
noisy.

Cc: Android Kernel Team <kernel-team@android.com>
Cc: Arve Hjønnevåg <arve@android.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Signed-off-by: Arve Hjønnevåg <arve@android.com>
Signed-off-by: John Stultz <john.stultz@linaro.org>
---
 drivers/staging/android/lowmemorykiller.c |    2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drivers/staging/android/lowmemorykiller.c b/drivers/staging/android/lowmemorykiller.c
index 2f28763..e0435a9 100644
--- a/drivers/staging/android/lowmemorykiller.c
+++ b/drivers/staging/android/lowmemorykiller.c
@@ -40,7 +40,7 @@
 #include <linux/profile.h>
 #include <linux/notifier.h>
 
-static uint32_t lowmem_debug_level = 2;
+static uint32_t lowmem_debug_level = 1;
 static short lowmem_adj[6] = {
 	0,
 	1,
-- 
1.7.10.4

[PATCH 4/5] staging: android: logger: Allow a UID to read it's own log entries

[John Stultz]

From: Nick Kralevich <nnk@google.com>

Modify the kernel logger to record the UID associated with
the log entries. Always allow the same UID which generated a
log message to read the log message.

Allow anyone in the logs group, or anyone with CAP_SYSLOG, to
read all log entries.

In addition, allow the client to upgrade log formats, so they
can get additional information from the kernel.

Cc: Android Kernel Team <kernel-team@android.com>
Cc: Nick Kralevich <nnk@google.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Signed-off-by: Nick Kralevich <nnk@google.com>
Signed-off-by: John Stultz <john.stultz@linaro.org>
---
 drivers/staging/android/logger.c |  191 +++++++++++++++++++++++++++++++++-----
 drivers/staging/android/logger.h |   40 +++++++-
 2 files changed, 202 insertions(+), 29 deletions(-)

diff --git a/drivers/staging/android/logger.c b/drivers/staging/android/logger.c
index dbc63cb..cfa6061 100644
--- a/drivers/staging/android/logger.c
+++ b/drivers/staging/android/logger.c
@@ -68,6 +68,8 @@ static LIST_HEAD(log_list);
  * @log:	The associated log
  * @list:	The associated entry in @logger_log's list
  * @r_off:	The current read head offset.
+ * @r_all:	Reader can read all entries
+ * @r_ver:	Reader ABI version
  *
  * This object lives from open to release, so we don't need additional
  * reference counting. The structure is protected by log->mutex.
@@ -76,6 +78,8 @@ struct logger_reader {
 	struct logger_log	*log;
 	struct list_head	list;
 	size_t			r_off;
+	bool			r_all;
+	int			r_ver;
 };
 
 /* logger_offset - returns index 'n' into the log via (optimized) modulus */
@@ -109,8 +113,29 @@ static inline struct logger_log *file_get_log(struct file *file)
 }
 
 /*
- * get_entry_len - Grabs the length of the payload of the next entry starting
- * from 'off'.
+ * get_entry_header - returns a pointer to the logger_entry header within
+ * 'log' starting at offset 'off'. A temporary logger_entry 'scratch' must
+ * be provided. Typically the return value will be a pointer within
+ * 'logger->buf'.  However, a pointer to 'scratch' may be returned if
+ * the log entry spans the end and beginning of the circular buffer.
+ */
+static struct logger_entry *get_entry_header(struct logger_log *log,
+		size_t off, struct logger_entry *scratch)
+{
+	size_t len = min(sizeof(struct logger_entry), log->size - off);
+	if (len != sizeof(struct logger_entry)) {
+		memcpy(((void *) scratch), log->buffer + off, len);
+		memcpy(((void *) scratch) + len, log->buffer,
+			sizeof(struct logger_entry) - len);
+		return scratch;
+	}
+
+	return (struct logger_entry *) (log->buffer + off);
+}
+
+/*
+ * get_entry_msg_len - Grabs the length of the message of the entry
+ * starting from from 'off'.
  *
  * An entry length is 2 bytes (16 bits) in host endian order.
  * In the log, the length does not include the size of the log entry structure.
@@ -118,20 +143,45 @@ static inline struct logger_log *file_get_log(struct file *file)
  *
  * Caller needs to hold log->mutex.
  */
-static __u32 get_entry_len(struct logger_log *log, size_t off)
+static __u32 get_entry_msg_len(struct logger_log *log, size_t off)
 {
-	__u16 val;
+	struct logger_entry scratch;
+	struct logger_entry *entry;
 
-	/* copy 2 bytes from buffer, in memcpy order, */
-	/* handling possible wrap at end of buffer */
+	entry = get_entry_header(log, off, &scratch);
+	return entry->len;
+}
 
-	((__u8 *)&val)[0] = log->buffer[off];
-	if (likely(off+1 < log->size))
-		((__u8 *)&val)[1] = log->buffer[off+1];
+static size_t get_user_hdr_len(int ver)
+{
+	if (ver < 2)
+		return sizeof(struct user_logger_entry_compat);
 	else
-		((__u8 *)&val)[1] = log->buffer[0];
+		return sizeof(struct logger_entry);
+}
+
+static ssize_t copy_header_to_user(int ver, struct logger_entry *entry,
+					 char __user *buf)
+{
+	void *hdr;
+	size_t hdr_len;
+	struct user_logger_entry_compat v1;
+
+	if (ver < 2) {
+		v1.len      = entry->len;
+		v1.__pad    = 0;
+		v1.pid      = entry->pid;
+		v1.tid      = entry->tid;
+		v1.sec      = entry->sec;
+		v1.nsec     = entry->nsec;
+		hdr         = &v1;
+		hdr_len     = sizeof(struct user_logger_entry_compat);
+	} else {
+		hdr         = entry;
+		hdr_len     = sizeof(struct logger_entry);
+	}
 
-	return sizeof(struct logger_entry) + val;
+	return copy_to_user(buf, hdr, hdr_len);
 }
 
 /*
@@ -145,15 +195,31 @@ static ssize_t do_read_log_to_user(struct logger_log *log,
 				   char __user *buf,
 				   size_t count)
 {
+	struct logger_entry scratch;
+	struct logger_entry *entry;
 	size_t len;
+	size_t msg_start;
 
 	/*
-	 * We read from the log in two disjoint operations. First, we read from
-	 * the current read head offset up to 'count' bytes or to the end of
+	 * First, copy the header to userspace, using the version of
+	 * the header requested
+	 */
+	entry = get_entry_header(log, reader->r_off, &scratch);
+	if (copy_header_to_user(reader->r_ver, entry, buf))
+		return -EFAULT;
+
+	count -= get_user_hdr_len(reader->r_ver);
+	buf += get_user_hdr_len(reader->r_ver);
+	msg_start = logger_offset(log,
+		reader->r_off + sizeof(struct logger_entry));
+
+	/*
+	 * We read from the msg in two disjoint operations. First, we read from
+	 * the current msg head offset up to 'count' bytes or to the end of
 	 * the log, whichever comes first.
 	 */
-	len = min(count, log->size - reader->r_off);
-	if (copy_to_user(buf, log->buffer + reader->r_off, len))
+	len = min(count, log->size - msg_start);
+	if (copy_to_user(buf, log->buffer + msg_start, len))
 		return -EFAULT;
 
 	/*
@@ -164,9 +230,34 @@ static ssize_t do_read_log_to_user(struct logger_log *log,
 		if (copy_to_user(buf + len, log->buffer, count - len))
 			return -EFAULT;
 
-	reader->r_off = logger_offset(log, reader->r_off + count);
+	reader->r_off = logger_offset(log, reader->r_off +
+		sizeof(struct logger_entry) + count);
 
-	return count;
+	return count + get_user_hdr_len(reader->r_ver);
+}
+
+/*
+ * get_next_entry_by_uid - Starting at 'off', returns an offset into
+ * 'log->buffer' which contains the first entry readable by 'euid'
+ */
+static size_t get_next_entry_by_uid(struct logger_log *log,
+		size_t off, uid_t euid)
+{
+	while (off != log->w_off) {
+		struct logger_entry *entry;
+		struct logger_entry scratch;
+		size_t next_len;
+
+		entry = get_entry_header(log, off, &scratch);
+
+		if (entry->euid == euid)
+			return off;
+
+		next_len = sizeof(struct logger_entry) + entry->len;
+		off = logger_offset(log, off + next_len);
+	}
+
+	return off;
 }
 
 /*
@@ -178,7 +269,7 @@ static ssize_t do_read_log_to_user(struct logger_log *log,
  *	- If there are no log entries to read, blocks until log is written to
  *	- Atomically reads exactly one log entry
  *
- * Optimal read size is LOGGER_ENTRY_MAX_LEN. Will set errno to EINVAL if read
+ * Will set errno to EINVAL if read
  * buffer is insufficient to hold next entry.
  */
 static ssize_t logger_read(struct file *file, char __user *buf,
@@ -219,6 +310,10 @@ start:
 
 	mutex_lock(&log->mutex);
 
+	if (!reader->r_all)
+		reader->r_off = get_next_entry_by_uid(log,
+			reader->r_off, current_euid());
+
 	/* is there still something to read or did we race? */
 	if (unlikely(log->w_off == reader->r_off)) {
 		mutex_unlock(&log->mutex);
@@ -226,7 +321,8 @@ start:
 	}
 
 	/* get the size of the next entry */
-	ret = get_entry_len(log, reader->r_off);
+	ret = get_user_hdr_len(reader->r_ver) +
+		get_entry_msg_len(log, reader->r_off);
 	if (count < ret) {
 		ret = -EINVAL;
 		goto out;
@@ -252,7 +348,8 @@ static size_t get_next_entry(struct logger_log *log, size_t off, size_t len)
 	size_t count = 0;
 
 	do {
-		size_t nr = get_entry_len(log, off);
+		size_t nr = sizeof(struct logger_entry) +
+			get_entry_msg_len(log, off);
 		off = logger_offset(log, off + nr);
 		count += nr;
 	} while (count < len);
@@ -382,7 +479,9 @@ static ssize_t logger_aio_write(struct kiocb *iocb, const struct iovec *iov,
 	header.tid = current->pid;
 	header.sec = now.tv_sec;
 	header.nsec = now.tv_nsec;
+	header.euid = current_euid();
 	header.len = min_t(size_t, iocb->ki_left, LOGGER_ENTRY_MAX_PAYLOAD);
+	header.hdr_size = sizeof(struct logger_entry);
 
 	/* null writes succeed, return zero */
 	if (unlikely(!header.len))
@@ -463,6 +562,10 @@ static int logger_open(struct inode *inode, struct file *file)
 			return -ENOMEM;
 
 		reader->log = log;
+		reader->r_ver = 1;
+		reader->r_all = in_egroup_p(inode->i_gid) ||
+			capable(CAP_SYSLOG);
+
 		INIT_LIST_HEAD(&reader->list);
 
 		mutex_lock(&log->mutex);
@@ -522,6 +625,10 @@ static unsigned int logger_poll(struct file *file, poll_table *wait)
 	poll_wait(file, &log->wq, wait);
 
 	mutex_lock(&log->mutex);
+	if (!reader->r_all)
+		reader->r_off = get_next_entry_by_uid(log,
+			reader->r_off, current_euid());
+
 	if (log->w_off != reader->r_off)
 		ret |= POLLIN | POLLRDNORM;
 	mutex_unlock(&log->mutex);
@@ -529,11 +636,25 @@ static unsigned int logger_poll(struct file *file, poll_table *wait)
 	return ret;
 }
 
+static long logger_set_version(struct logger_reader *reader, void __user *arg)
+{
+	int version;
+	if (copy_from_user(&version, arg, sizeof(int)))
+		return -EFAULT;
+
+	if ((version < 1) || (version > 2))
+		return -EINVAL;
+
+	reader->r_ver = version;
+	return 0;
+}
+
 static long logger_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
 	struct logger_log *log = file_get_log(file);
 	struct logger_reader *reader;
-	long ret = -ENOTTY;
+	long ret = -EINVAL;
+	void __user *argp = (void __user *) arg;
 
 	mutex_lock(&log->mutex);
 
@@ -558,8 +679,14 @@ static long logger_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 			break;
 		}
 		reader = file->private_data;
+
+		if (!reader->r_all)
+			reader->r_off = get_next_entry_by_uid(log,
+				reader->r_off, current_euid());
+
 		if (log->w_off != reader->r_off)
-			ret = get_entry_len(log, reader->r_off);
+			ret = get_user_hdr_len(reader->r_ver) +
+				get_entry_msg_len(log, reader->r_off);
 		else
 			ret = 0;
 		break;
@@ -573,6 +700,22 @@ static long logger_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 		log->head = log->w_off;
 		ret = 0;
 		break;
+	case LOGGER_GET_VERSION:
+		if (!(file->f_mode & FMODE_READ)) {
+			ret = -EBADF;
+			break;
+		}
+		reader = file->private_data;
+		ret = reader->r_ver;
+		break;
+	case LOGGER_SET_VERSION:
+		if (!(file->f_mode & FMODE_READ)) {
+			ret = -EBADF;
+			break;
+		}
+		reader = file->private_data;
+		ret = logger_set_version(reader, argp);
+		break;
 	}
 
 	mutex_unlock(&log->mutex);
@@ -592,8 +735,8 @@ static const struct file_operations logger_fops = {
 };
 
 /*
- * Log size must be a power of two, greater than LOGGER_ENTRY_MAX_LEN,
- * and less than LONG_MAX minus LOGGER_ENTRY_MAX_LEN.
+ * Log size must must be a power of two, and greater than
+ * (LOGGER_ENTRY_MAX_PAYLOAD + sizeof(struct logger_entry)).
  */
 static int __init create_log(char *log_name, int size)
 {
diff --git a/drivers/staging/android/logger.h b/drivers/staging/android/logger.h
index 9b929a8..cc6bbd9 100644
--- a/drivers/staging/android/logger.h
+++ b/drivers/staging/android/logger.h
@@ -21,7 +21,7 @@
 #include <linux/ioctl.h>
 
 /**
- * struct logger_entry - defines a single entry that is given to a logger
+ * struct user_logger_entry_compat - defines a single entry that is given to a logger
  * @len:	The length of the payload
  * @__pad:	Two bytes of padding that appear to be required
  * @pid:	The generating process' process ID
@@ -29,8 +29,12 @@
  * @sec:	The number of seconds that have elapsed since the Epoch
  * @nsec:	The number of nanoseconds that have elapsed since @sec
  * @msg:	The message that is to be logged
+ *
+ * The userspace structure for version 1 of the logger_entry ABI.
+ * This structure is returned to userspace unless the caller requests
+ * an upgrade to a newer ABI version.
  */
-struct logger_entry {
+struct user_logger_entry_compat {
 	__u16		len;
 	__u16		__pad;
 	__s32		pid;
@@ -40,14 +44,38 @@ struct logger_entry {
 	char		msg[0];
 };
 
+/**
+ * struct logger_entry - defines a single entry that is given to a logger
+ * @len:	The length of the payload
+ * @hdr_size:	sizeof(struct logger_entry_v2)
+ * @pid:	The generating process' process ID
+ * @tid:	The generating process' thread ID
+ * @sec:	The number of seconds that have elapsed since the Epoch
+ * @nsec:	The number of nanoseconds that have elapsed since @sec
+ * @euid:	Effective UID of logger
+ * @msg:	The message that is to be logged
+ *
+ * The structure for version 2 of the logger_entry ABI.
+ * This structure is returned to userspace if ioctl(LOGGER_SET_VERSION)
+ * is called with version >= 2
+ */
+struct logger_entry {
+	__u16		len;
+	__u16		hdr_size;
+	__s32		pid;
+	__s32		tid;
+	__s32		sec;
+	__s32		nsec;
+	uid_t		euid;
+	char		msg[0];
+};
+
 #define LOGGER_LOG_RADIO	"log_radio"	/* radio-related messages */
 #define LOGGER_LOG_EVENTS	"log_events"	/* system/hardware events */
 #define LOGGER_LOG_SYSTEM	"log_system"	/* system/framework messages */
 #define LOGGER_LOG_MAIN		"log_main"	/* everything else */
 
-#define LOGGER_ENTRY_MAX_LEN		(4*1024)
-#define LOGGER_ENTRY_MAX_PAYLOAD	\
-	(LOGGER_ENTRY_MAX_LEN - sizeof(struct logger_entry))
+#define LOGGER_ENTRY_MAX_PAYLOAD	4076
 
 #define __LOGGERIO	0xAE
 
@@ -55,5 +83,7 @@ struct logger_entry {
 #define LOGGER_GET_LOG_LEN		_IO(__LOGGERIO, 2) /* used log len */
 #define LOGGER_GET_NEXT_ENTRY_LEN	_IO(__LOGGERIO, 3) /* next entry len */
 #define LOGGER_FLUSH_LOG		_IO(__LOGGERIO, 4) /* flush log */
+#define LOGGER_GET_VERSION		_IO(__LOGGERIO, 5) /* abi version */
+#define LOGGER_SET_VERSION		_IO(__LOGGERIO, 6) /* abi version */
 
 #endif /* _LINUX_LOGGER_H */
-- 
1.7.10.4

[PATCH 5/5] staging: android: logger: enforce GID and CAP check on log flush

[John Stultz]

From: Charndeep Grewal <csgrewa@tycho.ncsc.mil>

Restrict log flushing to those in the logs group, or
anyone with CAP_SYSLOG.

Cc: Android Kernel Team <kernel-team@android.com>
Cc: Charndeep Grewal <csgrewa@tycho.ncsc.mil>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Signed-off-by: Charndeep Grewal <csgrewa@tycho.ncsc.mil>
Signed-off-by: John Stultz <john.stultz@linaro.org>
---
 drivers/staging/android/logger.c |    5 +++++
 1 file changed, 5 insertions(+)

diff --git a/drivers/staging/android/logger.c b/drivers/staging/android/logger.c
index cfa6061..b14a557 100644
--- a/drivers/staging/android/logger.c
+++ b/drivers/staging/android/logger.c
@@ -695,6 +695,11 @@ static long logger_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 			ret = -EBADF;
 			break;
 		}
+		if (!(in_egroup_p(file->f_dentry->d_inode->i_gid) ||
+				capable(CAP_SYSLOG))) {
+			ret = -EPERM;
+			break;
+		}
 		list_for_each_entry(reader, &log->readers, list)
 			reader->r_off = log->w_off;
 		log->head = log->w_off;
-- 
1.7.10.4

Re: [PATCH 1/5] staging: android: lowmemorykiller: Add config option to support oom_adj values

[David Rientjes]

[-- Attachment #1: Type: TEXT/PLAIN, Size: 500 bytes --]

On Tue, 26 Feb 2013, John Stultz wrote:

> From: Arve Hjønnevåg <arve@android.com>
> 
> The conversion to use oom_score_adj instead of the deprecated oom_adj
> values breaks existing user-space code. Add a config option to convert
> oom_adj values written to oom_score_adj values if they appear to be
> valid oom_adj values.
> 

Umm, writes to /proc/pid/oom_adj already are converted to the 
/proc/pid/oom_score_adj scale linearly.  Heavy NACK to this patch since 
oom_adj is completely deprecated.

Re: [PATCH 2/5] staging: android: lowmemorykiller: Don't count reserved free memory

[David Rientjes]

[-- Attachment #1: Type: TEXT/PLAIN, Size: 549 bytes --]

On Tue, 26 Feb 2013, John Stultz wrote:

> From: Arve Hjønnevåg <arve@android.com>
> 
> The amount of reserved memory varies between devices. Subtract it
> here to reduce the amount of devices specific tuning needed for the
> minfree values.
> 
> Cc: Android Kernel Team <kernel-team@android.com>
> Cc: Arve Hjønnevåg <arve@android.com>
> Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
> Signed-off-by: Arve Hjønnevåg <arve@android.com>
> Signed-off-by: John Stultz <john.stultz@linaro.org>

Acked-by: David Rientjes <rientjes@google.com>

Re: [PATCH 1/5] staging: android: lowmemorykiller: Add config option to support oom_adj values

[Arve Hjønnevåg]

On Wed, Feb 27, 2013 at 2:18 PM, David Rientjes <rientjes@google.com> wrote:
> On Tue, 26 Feb 2013, John Stultz wrote:
>
>> From: Arve Hjønnevåg <arve@android.com>
>>
>> The conversion to use oom_score_adj instead of the deprecated oom_adj
>> values breaks existing user-space code. Add a config option to convert
>> oom_adj values written to oom_score_adj values if they appear to be
>> valid oom_adj values.
>>
>
> Umm, writes to /proc/pid/oom_adj already are converted to the
> /proc/pid/oom_score_adj scale linearly.  Heavy NACK to this patch since
> oom_adj is completely deprecated.

I know it is deprecated, but your change, staging: android,
lowmemorykiller: convert to use oom_score_adj, broke existing
user-space code that still write to /proc/pid/oom_adj. This option
lets you build a kernel that supports our user-space code until that
user-space has been converted to use /proc/pid/oom_score_adj.

-- 
Arve Hjønnevåg

Re: [PATCH 1/5] staging: android: lowmemorykiller: Add config option to support oom_adj values

[David Rientjes]

[-- Attachment #1: Type: TEXT/PLAIN, Size: 904 bytes --]

On Wed, 27 Feb 2013, Arve Hjønnevåg wrote:

> > Umm, writes to /proc/pid/oom_adj already are converted to the
> > /proc/pid/oom_score_adj scale linearly.  Heavy NACK to this patch since
> > oom_adj is completely deprecated.
> 
> I know it is deprecated, but your change, staging: android,
> lowmemorykiller: convert to use oom_score_adj, broke existing
> user-space code that still write to /proc/pid/oom_adj. This option
> lets you build a kernel that supports our user-space code until that
> user-space has been converted to use /proc/pid/oom_score_adj.
> 

As stated, writes to /proc/pid/oom_adj already are converted to a linear 
scale and stored in /proc/pid/oom_score_adj.  This is done with

	oom_adj == 15	->	oom_score_adj = 1000
	oom_adj != 15	->	oom_score_adj = (oom_adj * -1000) / -17

since the maximum oom_score_adj is 1000 and the minimum oom_adj is -17.

How does this not work as needed?

Re: [PATCH 1/5] staging: android: lowmemorykiller: Add config option to support oom_adj values

[Arve Hjønnevåg]

On Wed, Feb 27, 2013 at 3:12 PM, David Rientjes <rientjes@google.com> wrote:
> On Wed, 27 Feb 2013, Arve Hjønnevåg wrote:
>
>> > Umm, writes to /proc/pid/oom_adj already are converted to the
>> > /proc/pid/oom_score_adj scale linearly.  Heavy NACK to this patch since
>> > oom_adj is completely deprecated.
>>
>> I know it is deprecated, but your change, staging: android,
>> lowmemorykiller: convert to use oom_score_adj, broke existing
>> user-space code that still write to /proc/pid/oom_adj. This option
>> lets you build a kernel that supports our user-space code until that
>> user-space has been converted to use /proc/pid/oom_score_adj.
>>
>
> As stated, writes to /proc/pid/oom_adj already are converted to a linear
> scale and stored in /proc/pid/oom_score_adj.  This is done with
>
>         oom_adj == 15   ->      oom_score_adj = 1000
>         oom_adj != 15   ->      oom_score_adj = (oom_adj * -1000) / -17
>
> since the maximum oom_score_adj is 1000 and the minimum oom_adj is -17.
>
> How does this not work as needed?

Because, without this patch, the values written to
/sys/module/lowmemorykiller/parameters/adj do not get adjusted and
therefore do not match the correct processes.

-- 
Arve Hjønnevåg

Re: [PATCH 1/5] staging: android: lowmemorykiller: Add config option to support oom_adj values

[David Rientjes]

[-- Attachment #1: Type: TEXT/PLAIN, Size: 411 bytes --]

On Wed, 27 Feb 2013, Arve Hjønnevåg wrote:

> Because, without this patch, the values written to
> /sys/module/lowmemorykiller/parameters/adj do not get adjusted and
> therefore do not match the correct processes.
> 

Explain how this can possibly be consistent if your system includes two 
processes, one writing oom_adj values and one writing oom_score_adj 
values, and the kernel has this new option enabled?

Re: [PATCH 1/5] staging: android: lowmemorykiller: Add config option to support oom_adj values

[Arve Hjønnevåg]

On Wed, Feb 27, 2013 at 4:14 PM, David Rientjes <rientjes@google.com> wrote:
> On Wed, 27 Feb 2013, Arve Hjønnevåg wrote:
>
>> Because, without this patch, the values written to
>> /sys/module/lowmemorykiller/parameters/adj do not get adjusted and
>> therefore do not match the correct processes.
>>
>
> Explain how this can possibly be consistent if your system includes two
> processes, one writing oom_adj values and one writing oom_score_adj
> values, and the kernel has this new option enabled?

These values are all written by the same process. If you want to
improve this, the lowmemorykiller will need a separate score_adj
parameter so that it knows for sure which type of value it receives.
You changed the meaning of /sys/module/lowmemorykiller/parameters/adj.
This patch restores the old behavior as long as the values you write
are within the range oom_adj, while still supporting the new behavior
you added in the likely case that one of the values are out of range
for oom_adj.

-- 
Arve Hjønnevåg

Re: [PATCH 1/5] staging: android: lowmemorykiller: Add config option to support oom_adj values

[David Rientjes]

[-- Attachment #1: Type: TEXT/PLAIN, Size: 1018 bytes --]

On Wed, 27 Feb 2013, Arve Hjønnevåg wrote:

> > Explain how this can possibly be consistent if your system includes two
> > processes, one writing oom_adj values and one writing oom_score_adj
> > values, and the kernel has this new option enabled?
> 
> These values are all written by the same process. If you want to
> improve this, the lowmemorykiller will need a separate score_adj
> parameter so that it knows for sure which type of value it receives.
> You changed the meaning of /sys/module/lowmemorykiller/parameters/adj.
> This patch restores the old behavior as long as the values you write
> are within the range oom_adj, while still supporting the new behavior
> you added in the likely case that one of the values are out of range
> for oom_adj.
> 

Then remove the config option entirely and add a new score_adj file that 
gets mapped from writes to adj.  No reason to tie the kernel config to a 
particular userspace implementation (even though it's been like this for 
over a year).  Nack to this patch.

Re: [PATCH 0/5] staging: Updates from the Android tree (for 3.10)

[Greg Kroah-Hartman]

On Tue, Feb 26, 2013 at 10:07:33PM -0800, John Stultz wrote:
> Hey Greg,
> 	I was looking over the current Android tree and noticed there
> were a few updates that should be pushed into staging so upstream stays
> in sync with what Android is using. I've already checked with the folks
> at Google (cc'ed) and they had no objections to sending these to you.
> 
> Let me know if you have any objections or comments.

I took the last 4 of these, skipping the first one due to the objections
that it raised.

thanks,

greg k-h

Re: [PATCH 0/5] staging: Updates from the Android tree (for 3.10)

[John Stultz]

On 03/05/2013 04:39 PM, Greg Kroah-Hartman wrote:
> On Tue, Feb 26, 2013 at 10:07:33PM -0800, John Stultz wrote:
>> Hey Greg,
>> 	I was looking over the current Android tree and noticed there
>> were a few updates that should be pushed into staging so upstream stays
>> in sync with what Android is using. I've already checked with the folks
>> at Google (cc'ed) and they had no objections to sending these to you.
>>
>> Let me know if you have any objections or comments.
> I took the last 4 of these, skipping the first one due to the objections
> that it raised.
Sweet! I was just about to resend the set, dropping the contentious one 
for now.

Thanks for picking them up!
-john