<feed xmlns='http://www.w3.org/2005/Atom'>
<title>linux/kernel, branch v3.8.11</title>
<subtitle>Linux kernel source tree</subtitle>
<id>https://git.amat.us/linux/atom/kernel?h=v3.8.11</id>
<link rel='self' href='https://git.amat.us/linux/atom/kernel?h=v3.8.11'/>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/'/>
<updated>2013-05-01T16:46:20Z</updated>
<entry>
<title>tracing: Fix selftest function recursion accounting</title>
<updated>2013-05-01T16:46:20Z</updated>
<author>
<name>Steven Rostedt</name>
<email>srostedt@redhat.com</email>
</author>
<published>2013-01-23T04:35:11Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=19ffe4c3896698b6d565d293a37bde5567d4e1aa'/>
<id>urn:sha1:19ffe4c3896698b6d565d293a37bde5567d4e1aa</id>
<content type='text'>
commit 05cbbf643b8eea1be21082c53cdb856d1dc6d765 upstream.

The test that checks function recursion does things differently
if the arch does not support all ftrace features. But that really
doesn't make a difference with how the test runs, and either way
the count variable should be 2 at the end.

Currently the test wrongly fails for archs that don't support all
the ftrace features.

Signed-off-by: Steven Rostedt &lt;rostedt@goodmis.org&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>Add file_ns_capable() helper function for open-time capability checking</title>
<updated>2013-04-26T19:18:20Z</updated>
<author>
<name>Linus Torvalds</name>
<email>torvalds@linux-foundation.org</email>
</author>
<published>2013-04-14T17:06:31Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=97129f70b9a32ddf8929daacd2abee36a7f0ddad'/>
<id>urn:sha1:97129f70b9a32ddf8929daacd2abee36a7f0ddad</id>
<content type='text'>
commit 935d8aabd4331f47a89c3e1daa5779d23cf244ee upstream.

Nothing is using it yet, but this will allow us to delay the open-time
checks to use time, without breaking the normal UNIX permission
semantics where permissions are determined by the opener (and the file
descriptor can then be passed to a different process, or the process can
drop capabilities).

Signed-off-by: Linus Torvalds &lt;torvalds@linux-foundation.org&gt;
Cc: Shea Levy &lt;shea@shealevy.com&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>userns: Changing any namespace id mappings should require privileges</title>
<updated>2013-04-25T19:51:23Z</updated>
<author>
<name>Andy Lutomirski</name>
<email>luto@amacapital.net</email>
</author>
<published>2013-04-14T18:44:04Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=37ed4a3f3bb107bfb307610b9ab2b87db03df3a6'/>
<id>urn:sha1:37ed4a3f3bb107bfb307610b9ab2b87db03df3a6</id>
<content type='text'>
commit 41c21e351e79004dbb4efa4bc14a53a7e0af38c5 upstream.

Changing uid/gid/projid mappings doesn't change your id within the
namespace; it reconfigures the namespace.  Unprivileged programs should
*not* be able to write these files.  (We're also checking the privileges
on the wrong task.)

Given the write-once nature of these files and the other security
checks, this is likely impossible to usefully exploit.

Signed-off-by: Andy Lutomirski &lt;luto@amacapital.net&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>userns: Check uid_map's opener's fsuid, not the current fsuid</title>
<updated>2013-04-25T19:51:23Z</updated>
<author>
<name>Andy Lutomirski</name>
<email>luto@amacapital.net</email>
</author>
<published>2013-04-14T23:28:19Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=be4c1b46075d42cbd82bc0d1e833dc4de052ae85'/>
<id>urn:sha1:be4c1b46075d42cbd82bc0d1e833dc4de052ae85</id>
<content type='text'>
commit e3211c120a85b792978bcb4be7b2886df18d27f0 upstream.

Signed-off-by: Andy Lutomirski &lt;luto@amacapital.net&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>userns: Don't let unprivileged users trick privileged users into setting the id_map</title>
<updated>2013-04-25T19:51:23Z</updated>
<author>
<name>Eric W. Biederman</name>
<email>ebiederm@xmission.com</email>
</author>
<published>2013-04-14T20:47:02Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=d2b12161ea5208d87dae24bcc5f3fed9da79262e'/>
<id>urn:sha1:d2b12161ea5208d87dae24bcc5f3fed9da79262e</id>
<content type='text'>
commit 6708075f104c3c9b04b23336bb0366ca30c3931b upstream.

When we require privilege for setting /proc/&lt;pid&gt;/uid_map or
/proc/&lt;pid&gt;/gid_map no longer allow an unprivileged user to
open the file and pass it to a privileged program to write
to the file.

Instead when privilege is required require both the opener and the
writer to have the necessary capabilities.

I have tested this code and verified that setting /proc/&lt;pid&gt;/uid_map
fails when an unprivileged user opens the file and a privielged user
attempts to set the mapping, that unprivileged users can still map
their own id, and that a privileged users can still setup an arbitrary
mapping.

Reported-by: Andy Lutomirski &lt;luto@amacapital.net&gt;
Signed-off-by: "Eric W. Biederman" &lt;ebiederm@xmission.com&gt;
Signed-off-by: Andy Lutomirski &lt;luto@amacapital.net&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>perf: Treat attr.config as u64 in perf_swevent_init()</title>
<updated>2013-04-25T19:51:23Z</updated>
<author>
<name>Tommi Rantala</name>
<email>tt.rantala@gmail.com</email>
</author>
<published>2013-04-13T19:49:14Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=ff91fd5bc105f29a34755a6dd6d547c877b7d027'/>
<id>urn:sha1:ff91fd5bc105f29a34755a6dd6d547c877b7d027</id>
<content type='text'>
commit 8176cced706b5e5d15887584150764894e94e02f upstream.

Trinity discovered that we fail to check all 64 bits of
attr.config passed by user space, resulting to out-of-bounds
access of the perf_swevent_enabled array in
sw_perf_event_destroy().

Introduced in commit b0a873ebb ("perf: Register PMU
implementations").

Signed-off-by: Tommi Rantala &lt;tt.rantala@gmail.com&gt;
Cc: Peter Zijlstra &lt;a.p.zijlstra@chello.nl&gt;
Cc: davej@redhat.com
Cc: Paul Mackerras &lt;paulus@samba.org&gt;
Cc: Arnaldo Carvalho de Melo &lt;acme@ghostprotocols.net&gt;
Link: http://lkml.kernel.org/r/1365882554-30259-1-git-send-email-tt.rantala@gmail.com
Signed-off-by: Ingo Molnar &lt;mingo@kernel.org&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>sched/debug: Fix sd-&gt;*_idx limit range avoiding overflow</title>
<updated>2013-04-25T19:51:12Z</updated>
<author>
<name>libin</name>
<email>huawei.libin@huawei.com</email>
</author>
<published>2013-04-08T06:39:12Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=dd135b0d8977ef119c7908c0153c3e94d8110e58'/>
<id>urn:sha1:dd135b0d8977ef119c7908c0153c3e94d8110e58</id>
<content type='text'>
commit fd9b86d37a600488dbd80fe60cca46b822bff1cd upstream.

Commit 201c373e8e ("sched/debug: Limit sd-&gt;*_idx range on
sysctl") was an incomplete bug fix.

This patch fixes sd-&gt;*_idx limit range to [0 ~ CPU_LOAD_IDX_MAX-1]
avoiding array overflow caused by setting sd-&gt;*_idx to CPU_LOAD_IDX_MAX
on sysctl.

Signed-off-by: Libin &lt;huawei.libin@huawei.com&gt;
Cc: &lt;jiang.liu@huawei.com&gt;
Cc: &lt;guohanjun@huawei.com&gt;
Cc: Peter Zijlstra &lt;peterz@infradead.org&gt;
Link: http://lkml.kernel.org/r/51626610.2040607@huawei.com
Signed-off-by: Ingo Molnar &lt;mingo@kernel.org&gt;
Signed-off-by: Jonghwan Choi &lt;jhbird.choi@samsung.com&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>sched: Convert BUG_ON()s in try_to_wake_up_local() to WARN_ON_ONCE()s</title>
<updated>2013-04-25T19:51:11Z</updated>
<author>
<name>Tejun Heo</name>
<email>tj@kernel.org</email>
</author>
<published>2013-03-18T19:22:34Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=4f795d18597696cc0da217c5177ddd8e2fbbb932'/>
<id>urn:sha1:4f795d18597696cc0da217c5177ddd8e2fbbb932</id>
<content type='text'>
commit 383efcd00053ec40023010ce5034bd702e7ab373 upstream.

try_to_wake_up_local() should only be invoked to wake up another
task in the same runqueue and BUG_ON()s are used to enforce the
rule. Missing try_to_wake_up_local() can stall workqueue
execution but such stalls are likely to be finite either by
another work item being queued or the one blocked getting
unblocked.  There's no reason to trigger BUG while holding rq
lock crashing the whole system.

Convert BUG_ON()s in try_to_wake_up_local() to WARN_ON_ONCE()s.

Signed-off-by: Tejun Heo &lt;tj@kernel.org&gt;
Acked-by: Steven Rostedt &lt;rostedt@goodmis.org&gt;
Cc: Peter Zijlstra &lt;peterz@infradead.org&gt;
Link: http://lkml.kernel.org/r/20130318192234.GD3042@htj.dyndns.org
Signed-off-by: Ingo Molnar &lt;mingo@kernel.org&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>kernel/signal.c: stop info leak via the tkill and the tgkill syscalls</title>
<updated>2013-04-25T19:51:10Z</updated>
<author>
<name>Emese Revfy</name>
<email>re.emese@gmail.com</email>
</author>
<published>2013-04-17T22:58:36Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=998f85133fd3067d715050826cf066efd59775f1'/>
<id>urn:sha1:998f85133fd3067d715050826cf066efd59775f1</id>
<content type='text'>
commit b9e146d8eb3b9ecae5086d373b50fa0c1f3e7f0f upstream.

This fixes a kernel memory contents leak via the tkill and tgkill syscalls
for compat processes.

This is visible in the siginfo_t-&gt;_sifields._rt.si_sigval.sival_ptr field
when handling signals delivered from tkill.

The place of the infoleak:

int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
{
        ...
        put_user_ex(ptr_to_compat(from-&gt;si_ptr), &amp;to-&gt;si_ptr);
        ...
}

Signed-off-by: Emese Revfy &lt;re.emese@gmail.com&gt;
Reviewed-by: PaX Team &lt;pageexec@freemail.hu&gt;
Signed-off-by: Kees Cook &lt;keescook@chromium.org&gt;
Cc: Al Viro &lt;viro@zeniv.linux.org.uk&gt;
Cc: Oleg Nesterov &lt;oleg@redhat.com&gt;
Cc: "Eric W. Biederman" &lt;ebiederm@xmission.com&gt;
Cc: Serge Hallyn &lt;serge.hallyn@canonical.com&gt;
Signed-off-by: Andrew Morton &lt;akpm@linux-foundation.org&gt;
Signed-off-by: Linus Torvalds &lt;torvalds@linux-foundation.org&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>hrtimer: Don't reinitialize a cpu_base lock on CPU_UP</title>
<updated>2013-04-25T19:51:09Z</updated>
<author>
<name>Michael Bohan</name>
<email>mbohan@codeaurora.org</email>
</author>
<published>2013-03-20T02:19:25Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=d7e0ec47be2ac4c26c4a2ed44e9541d790e7bb94'/>
<id>urn:sha1:d7e0ec47be2ac4c26c4a2ed44e9541d790e7bb94</id>
<content type='text'>
commit 84cc8fd2fe65866e49d70b38b3fdf7219dd92fe0 upstream.

The current code makes the assumption that a cpu_base lock won't be
held if the CPU corresponding to that cpu_base is offline, which isn't
always true.

If a hrtimer is not queued, then it will not be migrated by
migrate_hrtimers() when a CPU is offlined. Therefore, the hrtimer's
cpu_base may still point to a CPU which has subsequently gone offline
if the timer wasn't enqueued at the time the CPU went down.

Normally this wouldn't be a problem, but a cpu_base's lock is blindly
reinitialized each time a CPU is brought up. If a CPU is brought
online during the period that another thread is performing a hrtimer
operation on a stale hrtimer, then the lock will be reinitialized
under its feet, and a SPIN_BUG() like the following will be observed:

&lt;0&gt;[   28.082085] BUG: spinlock already unlocked on CPU#0, swapper/0/0
&lt;0&gt;[   28.087078]  lock: 0xc4780b40, value 0x0 .magic: dead4ead, .owner: &lt;none&gt;/-1, .owner_cpu: -1
&lt;4&gt;[   42.451150] [&lt;c0014398&gt;] (unwind_backtrace+0x0/0x120) from [&lt;c0269220&gt;] (do_raw_spin_unlock+0x44/0xdc)
&lt;4&gt;[   42.460430] [&lt;c0269220&gt;] (do_raw_spin_unlock+0x44/0xdc) from [&lt;c071b5bc&gt;] (_raw_spin_unlock+0x8/0x30)
&lt;4&gt;[   42.469632] [&lt;c071b5bc&gt;] (_raw_spin_unlock+0x8/0x30) from [&lt;c00a9ce0&gt;] (__hrtimer_start_range_ns+0x1e4/0x4f8)
&lt;4&gt;[   42.479521] [&lt;c00a9ce0&gt;] (__hrtimer_start_range_ns+0x1e4/0x4f8) from [&lt;c00aa014&gt;] (hrtimer_start+0x20/0x28)
&lt;4&gt;[   42.489247] [&lt;c00aa014&gt;] (hrtimer_start+0x20/0x28) from [&lt;c00e6190&gt;] (rcu_idle_enter_common+0x1ac/0x320)
&lt;4&gt;[   42.498709] [&lt;c00e6190&gt;] (rcu_idle_enter_common+0x1ac/0x320) from [&lt;c00e6440&gt;] (rcu_idle_enter+0xa0/0xb8)
&lt;4&gt;[   42.508259] [&lt;c00e6440&gt;] (rcu_idle_enter+0xa0/0xb8) from [&lt;c000f268&gt;] (cpu_idle+0x24/0xf0)
&lt;4&gt;[   42.516503] [&lt;c000f268&gt;] (cpu_idle+0x24/0xf0) from [&lt;c06ed3c0&gt;] (rest_init+0x88/0xa0)
&lt;4&gt;[   42.524319] [&lt;c06ed3c0&gt;] (rest_init+0x88/0xa0) from [&lt;c0c00978&gt;] (start_kernel+0x3d0/0x434)

As an example, this particular crash occurred when hrtimer_start() was
executed on CPU #0. The code locked the hrtimer's current cpu_base
corresponding to CPU #1. CPU #0 then tried to switch the hrtimer's
cpu_base to an optimal CPU which was online. In this case, it selected
the cpu_base corresponding to CPU #3.

Before it could proceed, CPU #1 came online and reinitialized the
spinlock corresponding to its cpu_base. Thus now CPU #0 held a lock
which was reinitialized. When CPU #0 finally ended up unlocking the
old cpu_base corresponding to CPU #1 so that it could switch to CPU
#3, we hit this SPIN_BUG() above while in switch_hrtimer_base().

CPU #0                            CPU #1
----                              ----
...                               &lt;offline&gt;
hrtimer_start()
lock_hrtimer_base(base #1)
...                               init_hrtimers_cpu()
switch_hrtimer_base()             ...
...                               raw_spin_lock_init(&amp;cpu_base-&gt;lock)
raw_spin_unlock(&amp;cpu_base-&gt;lock)  ...
&lt;spin_bug&gt;

Solve this by statically initializing the lock.

Signed-off-by: Michael Bohan &lt;mbohan@codeaurora.org&gt;
Link: http://lkml.kernel.org/r/1363745965-23475-1-git-send-email-mbohan@codeaurora.org
Signed-off-by: Thomas Gleixner &lt;tglx@linutronix.de&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
</feed>
