staging: Updates from the Android tree (for 3.10)
cover staging: Updates from the Android tree (for 3.10)
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
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(-)
Signature · 1 line
1.7.10.4
PATCH 1/5 staging: android: lowmemorykiller: Add config option to support oom_adj values
From: Arve Hjønnevåg <[email protected]>
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.
--- drivers/staging/android/Kconfig | 9 +++ drivers/staging/android/lowmemorykiller.c | 85 +++++++++++++++++++++++++++++ 2 files changed, 94 insertions(+)
drivers/staging/android/Kconfig +9 -0
@@ -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
drivers/staging/android/lowmemorykiller.c +85 -0
94 lines not on this page · raw message
Signature · 1 line
1.7.10.4
Re: [PATCH 1/5] staging: android: lowmemorykiller: Add config option to support oom_adj values
Quoted 7 lines · John Stultz
From: Arve Hjønnevåg <[email protected]>
The conversion to use
oom_score_adjinstead of the deprecatedoom_adjvalues breaks existing user-space code. Add a config option to convertoom_adjvalues written tooom_score_adjvalues if they appear to be validoom_adjvalues.
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 1/5] staging: android: lowmemorykiller: Add config option to support oom_adj values
Quoted 10 lines · David Rientjes
Quoted 7 lines · John Stultz
From: Arve Hjønnevåg <[email protected]>
The conversion to use
oom_score_adjinstead of the deprecatedoom_adjvalues breaks existing user-space code. Add a config option to convertoom_adjvalues written tooom_score_adjvalues if they appear to be validoom_adjvalues.
Quoted 3 lines
Umm, writes to
/proc/pid/oom_adjalready are converted to the/proc/pid/oom_score_adjscale linearly. Heavy NACK to this patch sinceoom_adjis 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.
Signature · 1 line
Arve Hjønnevåg
Re: [PATCH 1/5] staging: android: lowmemorykiller: Add config option to support oom_adj values
Quoted 10 lines · Arve Hjønnevåg
Quoted 3 lines
Umm, writes to
/proc/pid/oom_adjalready are converted to the/proc/pid/oom_score_adjscale linearly. Heavy NACK to this patch sinceoom_adjis completely deprecated.I know it is deprecated, but your change, staging: android,
lowmemorykiller: convert to useoom_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
Quoted 16 lines · David Rientjes
Quoted 10 lines · Arve Hjønnevåg
Quoted 3 lines
Umm, writes to
/proc/pid/oom_adjalready are converted to the/proc/pid/oom_score_adjscale linearly. Heavy NACK to this patch sinceoom_adjis completely deprecated.I know it is deprecated, but your change, staging: android,
lowmemorykiller: convert to useoom_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_adjalready are converted to a linear scale and stored in/proc/pid/oom_score_adj. This is done with
Quoted 6 lines
oom_adj == 15 -> oom_score_adj = 1000 oom_adj != 15 -> oom_score_adj = (oom_adj * -1000) / -17since the maximum
oom_score_adjis 1000 and the minimumoom_adjis -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.
Signature · 1 line
Arve Hjønnevåg
Re: [PATCH 1/5] staging: android: lowmemorykiller: Add config option to support oom_adj values
Quoted 4 lines · Arve Hjønnevåg
Because, without this patch, the values written to
/sys/module/lowmemorykiller/parameters/adjdo 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
Quoted 10 lines · David Rientjes
Quoted 4 lines · Arve Hjønnevåg
Because, without this patch, the values written to
/sys/module/lowmemorykiller/parameters/adjdo 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_adjvalues and one writingoom_score_adjvalues, 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.
Signature · 1 line
Arve Hjønnevåg
Re: [PATCH 1/5] staging: android: lowmemorykiller: Add config option to support oom_adj values
Quoted 4 lines · Arve Hjønnevåg
Quoted 3 lines
Explain how this can possibly be consistent if your system includes two processes, one writing
oom_adjvalues and one writingoom_score_adjvalues, and the kernel has this new option enabled?
Quoted 9 lines
These values are all written by the same process. If you want to improve this, the lowmemorykiller will need a separate
score_adjparameter 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 rangeoom_adj, while still supporting the new behavior you added in the likely case that one of the values are out of range foroom_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.
PATCH 2/5 staging: android: lowmemorykiller: Don't count reserved free memory
In reply to John StultzFrom: Arve Hjønnevåg <[email protected]>
The amount of reserved memory varies between devices. Subtract it here to reduce the amount of devices specific tuning needed for the minfree values.
--- drivers/staging/android/lowmemorykiller.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/staging/android/lowmemorykiller.c +2 -1
@@ -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 );
Signature · 1 line
1.7.10.4
Re: [PATCH 2/5] staging: android: lowmemorykiller: Don't count reserved free memory
Quoted 11 lines · John Stultz
From: Arve Hjønnevåg <[email protected]>
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 <[email protected]>Cc Arve Hjønnevåg <[email protected]>Cc Greg Kroah-Hartman <[email protected]>Signed-off-by Arve Hjønnevåg <[email protected]>Signed-off-by John Stultz <[email protected]>
PATCH 3/5 staging: android: lowmemorykiller: Change default debug_level to 1
In reply to John StultzFrom: Arve Hjønnevåg <[email protected]>
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.
--- drivers/staging/android/lowmemorykiller.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/staging/android/lowmemorykiller.c +1 -1
@@ -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 ,
Signature · 1 line
1.7.10.4
PATCH 4/5 staging: android: logger: Allow a UID to read it's own log entries
In reply to John StultzFrom: Nick Kralevich <[email protected]>
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.
--- drivers/staging/android/logger.c | 191 +++++++++++++++++++++++++++++++++----- drivers/staging/android/logger.h | 40 +++++++- 2 files changed, 202 insertions(+), 29 deletions(-)
drivers/staging/android/logger.c +167 -24
@@ -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) {
drivers/staging/android/logger.h +35 -5
@@ -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 */
Signature · 1 line
1.7.10.4
PATCH 5/5 staging: android: logger: enforce GID and CAP check on log flush
In reply to John StultzFrom: Charndeep Grewal <[email protected]>
Restrict log flushing to those in the logs group, or anyone with CAP_SYSLOG.
--- drivers/staging/android/logger.c | 5 +++++ 1 file changed, 5 insertions(+)
drivers/staging/android/logger.c +5 -0
@@ -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;
Signature · 1 line
1.7.10.4
Greg Kroah-Hartman
maintainerQuoted 7 lines · 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.
I took the last 4 of these, skipping the first one due to the objections that it raised.
thanks,
greg k-h
Quoted 10 lines · Greg Kroah-Hartman
Quoted 7 lines · 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.
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