<feed xmlns='http://www.w3.org/2005/Atom'>
<title>linux/include, branch v3.4.58</title>
<subtitle>Linux kernel source tree</subtitle>
<id>https://git.amat.us/linux/atom/include?h=v3.4.58</id>
<link rel='self' href='https://git.amat.us/linux/atom/include?h=v3.4.58'/>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/'/>
<updated>2013-08-15T05:57:08Z</updated>
<entry>
<title>tracing: Fix fields of struct trace_iterator that are zeroed by mistake</title>
<updated>2013-08-15T05:57:08Z</updated>
<author>
<name>Andrew Vagin</name>
<email>avagin@openvz.org</email>
</author>
<published>2013-08-02T17:16:43Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=99593eb7ca1dd9bfaa431d96e009eda23f001ace'/>
<id>urn:sha1:99593eb7ca1dd9bfaa431d96e009eda23f001ace</id>
<content type='text'>
commit ed5467da0e369e65b247b99eb6403cb79172bcda upstream.

tracing_read_pipe zeros all fields bellow "seq". The declaration contains
a comment about that, but it doesn't help.

The first field is "snapshot", it's true when current open file is
snapshot. Looks obvious, that it should not be zeroed.

The second field is "started". It was converted from cpumask_t to
cpumask_var_t (v2.6.28-4983-g4462344), in other words it was
converted from cpumask to pointer on cpumask.

Currently the reference on "started" memory is lost after the first read
from tracing_read_pipe and a proper object will never be freed.

The "started" is never dereferenced for trace_pipe, because trace_pipe
can't have the TRACE_FILE_ANNOTATE options.

Link: http://lkml.kernel.org/r/1375463803-3085183-1-git-send-email-avagin@openvz.org

Signed-off-by: Andrew Vagin &lt;avagin@openvz.org&gt;
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>virtio: support unlocked queue poll</title>
<updated>2013-08-04T08:26:03Z</updated>
<author>
<name>Michael S. Tsirkin</name>
<email>mst@redhat.com</email>
</author>
<published>2013-07-09T10:19:18Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=2010fa31f8f5c5fa8385459dff03cb844cf79dd1'/>
<id>urn:sha1:2010fa31f8f5c5fa8385459dff03cb844cf79dd1</id>
<content type='text'>
commit cc229884d3f77ec3b1240e467e0236c3e0647c0c upstream.

This adds a way to check ring empty state after enable_cb outside any
locks. Will be used by virtio_net.

Note: there's room for more optimization: caller is likely to have a
memory barrier already, which means we might be able to get rid of a
barrier here.  Deferring this optimization until we do some
benchmarking.

Signed-off-by: Michael S. Tsirkin &lt;mst@redhat.com&gt;
Signed-off-by: David S. Miller &lt;davem@davemloft.net&gt;
[wg: Backported to 3.2]
Signed-off-by: Wolfram Gloger &lt;wmglo@dent.med.uni-muenchen.de&gt;
[bwh: Backported to 3.4: adjust context]
Signed-off-by: Ben Hutchings &lt;ben@decadent.org.uk&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>firewire: fix libdc1394/FlyCap2 iso event regression</title>
<updated>2013-08-04T08:26:02Z</updated>
<author>
<name>Clemens Ladisch</name>
<email>clemens@ladisch.de</email>
</author>
<published>2013-07-22T19:32:09Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=a90a3adeda28c4b701b11770817cf86d92db3228'/>
<id>urn:sha1:a90a3adeda28c4b701b11770817cf86d92db3228</id>
<content type='text'>
commit 0699a73af3811b66b1ab5650575acee5eea841ab upstream.

Commit 18d627113b83 (firewire: prevent dropping of completed iso packet
header data) was intended to be an obvious bug fix, but libdc1394 and
FlyCap2 depend on the old behaviour by ignoring all returned information
and thus not noticing that not all packets have been received yet.  The
result was that the video frame buffers would be saved before they
contained the correct data.

Reintroduce the old behaviour for old clients.

Tested-by: Stepan Salenikovich &lt;stepan.salenikovich@gmail.com&gt;
Tested-by: Josep Bosch &lt;jep250@gmail.com&gt;
Cc: &lt;stable@vger.kernel.org&gt; # 3.4+
Signed-off-by: Clemens Ladisch &lt;clemens@ladisch.de&gt;
Signed-off-by: Stefan Richter &lt;stefanr@s5r6.in-berlin.de&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>ipv6: call udp_push_pending_frames when uncorking a socket with AF_INET pending data</title>
<updated>2013-07-28T23:26:02Z</updated>
<author>
<name>Hannes Frederic Sowa</name>
<email>hannes@stressinduktion.org</email>
</author>
<published>2013-07-01T18:21:30Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=eeddd9177a67b743868e09742d58f574b2b9a497'/>
<id>urn:sha1:eeddd9177a67b743868e09742d58f574b2b9a497</id>
<content type='text'>
[ Upstream commit 8822b64a0fa64a5dd1dfcf837c5b0be83f8c05d1 ]

We accidentally call down to ip6_push_pending_frames when uncorking
pending AF_INET data on a ipv6 socket. This results in the following
splat (from Dave Jones):

skbuff: skb_under_panic: text:ffffffff816765f6 len:48 put:40 head:ffff88013deb6df0 data:ffff88013deb6dec tail:0x2c end:0xc0 dev:&lt;NULL&gt;
------------[ cut here ]------------
kernel BUG at net/core/skbuff.c:126!
invalid opcode: 0000 [#1] PREEMPT SMP DEBUG_PAGEALLOC
Modules linked in: dccp_ipv4 dccp 8021q garp bridge stp dlci mpoa snd_seq_dummy sctp fuse hidp tun bnep nfnetlink scsi_transport_iscsi rfcomm can_raw can_bcm af_802154 appletalk caif_socket can caif ipt_ULOG x25 rose af_key pppoe pppox ipx phonet irda llc2 ppp_generic slhc p8023 psnap p8022 llc crc_ccitt atm bluetooth
+netrom ax25 nfc rfkill rds af_rxrpc coretemp hwmon kvm_intel kvm crc32c_intel snd_hda_codec_realtek ghash_clmulni_intel microcode pcspkr snd_hda_codec_hdmi snd_hda_intel snd_hda_codec snd_hwdep usb_debug snd_seq snd_seq_device snd_pcm e1000e snd_page_alloc snd_timer ptp snd pps_core soundcore xfs libcrc32c
CPU: 2 PID: 8095 Comm: trinity-child2 Not tainted 3.10.0-rc7+ #37
task: ffff8801f52c2520 ti: ffff8801e6430000 task.ti: ffff8801e6430000
RIP: 0010:[&lt;ffffffff816e759c&gt;]  [&lt;ffffffff816e759c&gt;] skb_panic+0x63/0x65
RSP: 0018:ffff8801e6431de8  EFLAGS: 00010282
RAX: 0000000000000086 RBX: ffff8802353d3cc0 RCX: 0000000000000006
RDX: 0000000000003b90 RSI: ffff8801f52c2ca0 RDI: ffff8801f52c2520
RBP: ffff8801e6431e08 R08: 0000000000000000 R09: 0000000000000000
R10: 0000000000000001 R11: 0000000000000001 R12: ffff88022ea0c800
R13: ffff88022ea0cdf8 R14: ffff8802353ecb40 R15: ffffffff81cc7800
FS:  00007f5720a10740(0000) GS:ffff880244c00000(0000) knlGS:0000000000000000
CS:  0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 0000000005862000 CR3: 000000022843c000 CR4: 00000000001407e0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000600
Stack:
 ffff88013deb6dec 000000000000002c 00000000000000c0 ffffffff81a3f6e4
 ffff8801e6431e18 ffffffff8159a9aa ffff8801e6431e90 ffffffff816765f6
 ffffffff810b756b 0000000700000002 ffff8801e6431e40 0000fea9292aa8c0
Call Trace:
 [&lt;ffffffff8159a9aa&gt;] skb_push+0x3a/0x40
 [&lt;ffffffff816765f6&gt;] ip6_push_pending_frames+0x1f6/0x4d0
 [&lt;ffffffff810b756b&gt;] ? mark_held_locks+0xbb/0x140
 [&lt;ffffffff81694919&gt;] udp_v6_push_pending_frames+0x2b9/0x3d0
 [&lt;ffffffff81694660&gt;] ? udplite_getfrag+0x20/0x20
 [&lt;ffffffff8162092a&gt;] udp_lib_setsockopt+0x1aa/0x1f0
 [&lt;ffffffff811cc5e7&gt;] ? fget_light+0x387/0x4f0
 [&lt;ffffffff816958a4&gt;] udpv6_setsockopt+0x34/0x40
 [&lt;ffffffff815949f4&gt;] sock_common_setsockopt+0x14/0x20
 [&lt;ffffffff81593c31&gt;] SyS_setsockopt+0x71/0xd0
 [&lt;ffffffff816f5d54&gt;] tracesys+0xdd/0xe2
Code: 00 00 48 89 44 24 10 8b 87 d8 00 00 00 48 89 44 24 08 48 8b 87 e8 00 00 00 48 c7 c7 c0 04 aa 81 48 89 04 24 31 c0 e8 e1 7e ff ff &lt;0f&gt; 0b 55 48 89 e5 0f 0b 55 48 89 e5 0f 0b 55 48 89 e5 0f 0b 55
RIP  [&lt;ffffffff816e759c&gt;] skb_panic+0x63/0x65
 RSP &lt;ffff8801e6431de8&gt;

This patch adds a check if the pending data is of address family AF_INET
and directly calls udp_push_ending_frames from udp_v6_push_pending_frames
if that is the case.

This bug was found by Dave Jones with trinity.

(Also move the initialization of fl6 below the AF_INET check, even if
not strictly necessary.)

Signed-off-by: Hannes Frederic Sowa &lt;hannes@stressinduktion.org&gt;
Cc: Dave Jones &lt;davej@redhat.com&gt;
Cc: YOSHIFUJI Hideaki &lt;yoshfuji@linux-ipv6.org&gt;
Signed-off-by: David S. Miller &lt;davem@davemloft.net&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>ipv6,mcast: always hold idev-&gt;lock before mca_lock</title>
<updated>2013-07-28T23:26:02Z</updated>
<author>
<name>Amerigo Wang</name>
<email>amwang@redhat.com</email>
</author>
<published>2013-06-29T13:30:49Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=3ef208a71f18b128e318294af3f7ee8081fe0ac1'/>
<id>urn:sha1:3ef208a71f18b128e318294af3f7ee8081fe0ac1</id>
<content type='text'>
[ Upstream commit 8965779d2c0e6ab246c82a405236b1fb2adae6b2, with
  some bits from commit b7b1bfce0bb68bd8f6e62a28295922785cc63781
  ("ipv6: split duplicate address detection and router solicitation timer")
  to get the __ipv6_get_lladdr() used by this patch. ]

dingtianhong reported the following deadlock detected by lockdep:

 ======================================================
 [ INFO: possible circular locking dependency detected ]
 3.4.24.05-0.1-default #1 Not tainted
 -------------------------------------------------------
 ksoftirqd/0/3 is trying to acquire lock:
  (&amp;ndev-&gt;lock){+.+...}, at: [&lt;ffffffff8147f804&gt;] ipv6_get_lladdr+0x74/0x120

 but task is already holding lock:
  (&amp;mc-&gt;mca_lock){+.+...}, at: [&lt;ffffffff8149d130&gt;] mld_send_report+0x40/0x150

 which lock already depends on the new lock.

 the existing dependency chain (in reverse order) is:

 -&gt; #1 (&amp;mc-&gt;mca_lock){+.+...}:
        [&lt;ffffffff810a8027&gt;] validate_chain+0x637/0x730
        [&lt;ffffffff810a8417&gt;] __lock_acquire+0x2f7/0x500
        [&lt;ffffffff810a8734&gt;] lock_acquire+0x114/0x150
        [&lt;ffffffff814f691a&gt;] rt_spin_lock+0x4a/0x60
        [&lt;ffffffff8149e4bb&gt;] igmp6_group_added+0x3b/0x120
        [&lt;ffffffff8149e5d8&gt;] ipv6_mc_up+0x38/0x60
        [&lt;ffffffff81480a4d&gt;] ipv6_find_idev+0x3d/0x80
        [&lt;ffffffff81483175&gt;] addrconf_notify+0x3d5/0x4b0
        [&lt;ffffffff814fae3f&gt;] notifier_call_chain+0x3f/0x80
        [&lt;ffffffff81073471&gt;] raw_notifier_call_chain+0x11/0x20
        [&lt;ffffffff813d8722&gt;] call_netdevice_notifiers+0x32/0x60
        [&lt;ffffffff813d92d4&gt;] __dev_notify_flags+0x34/0x80
        [&lt;ffffffff813d9360&gt;] dev_change_flags+0x40/0x70
        [&lt;ffffffff813ea627&gt;] do_setlink+0x237/0x8a0
        [&lt;ffffffff813ebb6c&gt;] rtnl_newlink+0x3ec/0x600
        [&lt;ffffffff813eb4d0&gt;] rtnetlink_rcv_msg+0x160/0x310
        [&lt;ffffffff814040b9&gt;] netlink_rcv_skb+0x89/0xb0
        [&lt;ffffffff813eb357&gt;] rtnetlink_rcv+0x27/0x40
        [&lt;ffffffff81403e20&gt;] netlink_unicast+0x140/0x180
        [&lt;ffffffff81404a9e&gt;] netlink_sendmsg+0x33e/0x380
        [&lt;ffffffff813c4252&gt;] sock_sendmsg+0x112/0x130
        [&lt;ffffffff813c537e&gt;] __sys_sendmsg+0x44e/0x460
        [&lt;ffffffff813c5544&gt;] sys_sendmsg+0x44/0x70
        [&lt;ffffffff814feab9&gt;] system_call_fastpath+0x16/0x1b

 -&gt; #0 (&amp;ndev-&gt;lock){+.+...}:
        [&lt;ffffffff810a798e&gt;] check_prev_add+0x3de/0x440
        [&lt;ffffffff810a8027&gt;] validate_chain+0x637/0x730
        [&lt;ffffffff810a8417&gt;] __lock_acquire+0x2f7/0x500
        [&lt;ffffffff810a8734&gt;] lock_acquire+0x114/0x150
        [&lt;ffffffff814f6c82&gt;] rt_read_lock+0x42/0x60
        [&lt;ffffffff8147f804&gt;] ipv6_get_lladdr+0x74/0x120
        [&lt;ffffffff8149b036&gt;] mld_newpack+0xb6/0x160
        [&lt;ffffffff8149b18b&gt;] add_grhead+0xab/0xc0
        [&lt;ffffffff8149d03b&gt;] add_grec+0x3ab/0x460
        [&lt;ffffffff8149d14a&gt;] mld_send_report+0x5a/0x150
        [&lt;ffffffff8149f99e&gt;] igmp6_timer_handler+0x4e/0xb0
        [&lt;ffffffff8105705a&gt;] call_timer_fn+0xca/0x1d0
        [&lt;ffffffff81057b9f&gt;] run_timer_softirq+0x1df/0x2e0
        [&lt;ffffffff8104e8c7&gt;] handle_pending_softirqs+0xf7/0x1f0
        [&lt;ffffffff8104ea3b&gt;] __do_softirq_common+0x7b/0xf0
        [&lt;ffffffff8104f07f&gt;] __thread_do_softirq+0x1af/0x210
        [&lt;ffffffff8104f1c1&gt;] run_ksoftirqd+0xe1/0x1f0
        [&lt;ffffffff8106c7de&gt;] kthread+0xae/0xc0
        [&lt;ffffffff814fff74&gt;] kernel_thread_helper+0x4/0x10

actually we can just hold idev-&gt;lock before taking pmc-&gt;mca_lock,
and avoid taking idev-&gt;lock again when iterating idev-&gt;addr_list,
since the upper callers of mld_newpack() already take
read_lock_bh(&amp;idev-&gt;lock).

Reported-by: dingtianhong &lt;dingtianhong@huawei.com&gt;
Cc: dingtianhong &lt;dingtianhong@huawei.com&gt;
Cc: Hideaki YOSHIFUJI &lt;yoshfuji@linux-ipv6.org&gt;
Cc: David S. Miller &lt;davem@davemloft.net&gt;
Cc: Hannes Frederic Sowa &lt;hannes@stressinduktion.org&gt;
Tested-by: Ding Tianhong &lt;dingtianhong@huawei.com&gt;
Tested-by: Chen Weilong &lt;chenweilong@huawei.com&gt;
Signed-off-by: Cong Wang &lt;amwang@redhat.com&gt;
Acked-by: Hannes Frederic Sowa &lt;hannes@stressinduktion.org&gt;
Signed-off-by: David S. Miller &lt;davem@davemloft.net&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>net: Swap ver and type in pppoe_hdr</title>
<updated>2013-07-28T23:25:59Z</updated>
<author>
<name>Changli Gao</name>
<email>xiaosuo@gmail.com</email>
</author>
<published>2013-06-28T16:15:51Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=d11ff32e52d86dfc6d3f100653ad88b83b6ead0e'/>
<id>urn:sha1:d11ff32e52d86dfc6d3f100653ad88b83b6ead0e</id>
<content type='text'>
[ Upstream commit b1a5a34bd0b8767ea689e68f8ea513e9710b671e ]

Ver and type in pppoe_hdr should be swapped as defined by RFC2516
section-4.

Signed-off-by: David S. Miller &lt;davem@davemloft.net&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>perf: Fix perf mmap bugs</title>
<updated>2013-07-03T17:59:06Z</updated>
<author>
<name>Peter Zijlstra</name>
<email>peterz@infradead.org</email>
</author>
<published>2013-05-28T08:55:48Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=535fad87e86d33ea41d4b8580fadf62f5865ae6b'/>
<id>urn:sha1:535fad87e86d33ea41d4b8580fadf62f5865ae6b</id>
<content type='text'>
commit 26cb63ad11e04047a64309362674bcbbd6a6f246 upstream.

Vince reported a problem found by his perf specific trinity
fuzzer.

Al noticed 2 problems with perf's mmap():

 - it has issues against fork() since we use vma-&gt;vm_mm for accounting.
 - it has an rb refcount leak on double mmap().

We fix the issues against fork() by using VM_DONTCOPY; I don't
think there's code out there that uses this; we didn't hear
about weird accounting problems/crashes. If we do need this to
work, the previously proposed VM_PINNED could make this work.

Aside from the rb reference leak spotted by Al, Vince's example
prog was indeed doing a double mmap() through the use of
perf_event_set_output().

This exposes another problem, since we now have 2 events with
one buffer, the accounting gets screwy because we account per
event. Fix this by making the buffer responsible for its own
accounting.

[Backporting for 3.4-stable.
VM_RESERVED flag was replaced with pair 'VM_DONTEXPAND | VM_DONTDUMP' in
314e51b9 since 3.7.0-rc1, and 314e51b9 comes from a big patchset, we didn't
backport the patchset, so I restored 'VM_DNOTEXPAND | VM_DONTDUMP' as before:
-       vma-&gt;vm_flags |= VM_DONTCOPY | VM_DONTEXPAND | VM_DONTDUMP;
+       vma-&gt;vm_flags |= VM_DONTCOPY | VM_RESERVED;
 -- zliu]

Reported-by: Vince Weaver &lt;vincent.weaver@maine.edu&gt;
Signed-off-by: Peter Zijlstra &lt;peterz@infradead.org&gt;
Cc: Al Viro &lt;viro@zeniv.linux.org.uk&gt;
Cc: Paul Mackerras &lt;paulus@samba.org&gt;
Cc: Arnaldo Carvalho de Melo &lt;acme@ghostprotocols.net&gt;
Link: http://lkml.kernel.org/r/20130528085548.GA12193@twins.programming.kicks-ass.net
Signed-off-by: Ingo Molnar &lt;mingo@kernel.org&gt;
Signed-off-by: Zhouping Liu &lt;zliu@redhat.com&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>net: force a reload of first item in hlist_nulls_for_each_entry_rcu</title>
<updated>2013-06-27T18:27:32Z</updated>
<author>
<name>Eric Dumazet</name>
<email>eric.dumazet@gmail.com</email>
</author>
<published>2013-05-29T09:06:27Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=689ec1227270c5b3f009b82fb32d902717a0a03e'/>
<id>urn:sha1:689ec1227270c5b3f009b82fb32d902717a0a03e</id>
<content type='text'>
[ Upstream commit c87a124a5d5e8cf8e21c4363c3372bcaf53ea190 ]

Roman Gushchin discovered that udp4_lib_lookup2() was not reloading
first item in the rcu protected list, in case the loop was restarted.

This produced soft lockups as in https://lkml.org/lkml/2013/4/16/37

rcu_dereference(X)/ACCESS_ONCE(X) seem to not work as intended if X is
ptr-&gt;field :

In some cases, gcc caches the value or ptr-&gt;field in a register.

Use a barrier() to disallow such caching, as documented in
Documentation/atomic_ops.txt line 114

Thanks a lot to Roman for providing analysis and numerous patches.

Diagnosed-by: Roman Gushchin &lt;klamm@yandex-team.ru&gt;
Signed-off-by: Eric Dumazet &lt;edumazet@google.com&gt;
Reported-by: Boris Zhmurov &lt;zhmurov@yandex-team.ru&gt;
Signed-off-by: Roman Gushchin &lt;klamm@yandex-team.ru&gt;
Acked-by: Paul E. McKenney &lt;paulmck@linux.vnet.ibm.com&gt;
Signed-off-by: David S. Miller &lt;davem@davemloft.net&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>net: Block MSG_CMSG_COMPAT in send(m)msg and recv(m)msg</title>
<updated>2013-06-27T18:27:32Z</updated>
<author>
<name>Andy Lutomirski</name>
<email>luto@amacapital.net</email>
</author>
<published>2013-05-22T21:07:44Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=c0cc94f2f65a682827cca2a79a4d045a20f8897f'/>
<id>urn:sha1:c0cc94f2f65a682827cca2a79a4d045a20f8897f</id>
<content type='text'>
[ Upstream commits 1be374a0518a288147c6a7398792583200a67261 and
  a7526eb5d06b0084ef12d7b168d008fcf516caab ]

MSG_CMSG_COMPAT is (AFAIK) not intended to be part of the API --
it's a hack that steals a bit to indicate to other networking code
that a compat entry was used.  So don't allow it from a non-compat
syscall.

This prevents an oops when running this code:

int main()
{
	int s;
	struct sockaddr_in addr;
	struct msghdr *hdr;

	char *highpage = mmap((void*)(TASK_SIZE_MAX - 4096), 4096,
	                      PROT_READ | PROT_WRITE,
	                      MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
	if (highpage == MAP_FAILED)
		err(1, "mmap");

	s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if (s == -1)
		err(1, "socket");

        addr.sin_family = AF_INET;
        addr.sin_port = htons(1);
        addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
	if (connect(s, (struct sockaddr*)&amp;addr, sizeof(addr)) != 0)
		err(1, "connect");

	void *evil = highpage + 4096 - COMPAT_MSGHDR_SIZE;
	printf("Evil address is %p\n", evil);

	if (syscall(__NR_sendmmsg, s, evil, 1, MSG_CMSG_COMPAT) &lt; 0)
		err(1, "sendmmsg");

	return 0;
}

Signed-off-by: Andy Lutomirski &lt;luto@amacapital.net&gt;
Cc: David S. Miller &lt;davem@davemloft.net&gt;
Signed-off-by: David S. Miller &lt;davem@davemloft.net&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;
</content>
</entry>
<entry>
<title>libceph: wrap auth methods in a mutex</title>
<updated>2013-06-20T18:58:47Z</updated>
<author>
<name>Sage Weil</name>
<email>sage@inktank.com</email>
</author>
<published>2013-03-25T17:26:30Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=7f259658b1f320b35040a14d7ace371b5cc15fbb'/>
<id>urn:sha1:7f259658b1f320b35040a14d7ace371b5cc15fbb</id>
<content type='text'>
commit e9966076cdd952e19f2dd4854cd719be0d7cbebc upstream.

The auth code is called from a variety of contexts, include the mon_client
(protected by the monc's mutex) and the messenger callbacks (currently
protected by nothing).  Avoid chaos by protecting all auth state with a
mutex.  Nothing is blocking, so this should be simple and lightweight.

Signed-off-by: Sage Weil &lt;sage@inktank.com&gt;
Reviewed-by: Alex Elder &lt;elder@inktank.com&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

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