<feed xmlns='http://www.w3.org/2005/Atom'>
<title>linux/net, branch v3.0.86</title>
<subtitle>Linux kernel source tree</subtitle>
<id>https://git.amat.us/linux/atom/net?h=v3.0.86</id>
<link rel='self' href='https://git.amat.us/linux/atom/net?h=v3.0.86'/>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/'/>
<updated>2013-07-13T17:34:43Z</updated>
<entry>
<title>libceph: Fix NULL pointer dereference in auth client code</title>
<updated>2013-07-13T17:34:43Z</updated>
<author>
<name>Tyler Hicks</name>
<email>tyhicks@canonical.com</email>
</author>
<published>2013-06-20T20:13:59Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=314d3e7c43ea9125ef257dad74f494c0c82b7fe3'/>
<id>urn:sha1:314d3e7c43ea9125ef257dad74f494c0c82b7fe3</id>
<content type='text'>
commit 2cb33cac622afde897aa02d3dcd9fbba8bae839e upstream.

A malicious monitor can craft an auth reply message that could cause a
NULL function pointer dereference in the client's kernel.

To prevent this, the auth_none protocol handler needs an empty
ceph_auth_client_ops-&gt;build_request() function.

CVE-2013-1059

Signed-off-by: Tyler Hicks &lt;tyhicks@canonical.com&gt;
Reported-by: Chanam Park &lt;chanam.park@hkpco.kr&gt;
Reviewed-by: Seth Arnold &lt;seth.arnold@canonical.com&gt;
Reviewed-by: Sage Weil &lt;sage@inktank.com&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>Bluetooth: Fix crash in l2cap_build_cmd() with small MTU</title>
<updated>2013-07-03T18:03:23Z</updated>
<author>
<name>Anderson Lizardo</name>
<email>anderson.lizardo@openbossa.org</email>
</author>
<published>2013-06-02T20:30:40Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=3ddc55287a4505a5634643fec8e02f887498ffc8'/>
<id>urn:sha1:3ddc55287a4505a5634643fec8e02f887498ffc8</id>
<content type='text'>
commit 300b962e5244a1ea010df7e88595faa0085b461d upstream.

If a too small MTU value is set with ioctl(HCISETACLMTU) or by a bogus
controller, memory corruption happens due to a memcpy() call with
negative length.

Fix this crash on either incoming or outgoing connections with a MTU
smaller than L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE:

[   46.885433] BUG: unable to handle kernel paging request at f56ad000
[   46.888037] IP: [&lt;c03d94cd&gt;] memcpy+0x1d/0x40
[   46.888037] *pdpt = 0000000000ac3001 *pde = 00000000373f8067 *pte = 80000000356ad060
[   46.888037] Oops: 0002 [#1] SMP DEBUG_PAGEALLOC
[   46.888037] Modules linked in: hci_vhci bluetooth virtio_balloon i2c_piix4 uhci_hcd usbcore usb_common
[   46.888037] CPU: 0 PID: 1044 Comm: kworker/u3:0 Not tainted 3.10.0-rc1+ #12
[   46.888037] Hardware name: Bochs Bochs, BIOS Bochs 01/01/2007
[   46.888037] Workqueue: hci0 hci_rx_work [bluetooth]
[   46.888037] task: f59b15b0 ti: f55c4000 task.ti: f55c4000
[   46.888037] EIP: 0060:[&lt;c03d94cd&gt;] EFLAGS: 00010212 CPU: 0
[   46.888037] EIP is at memcpy+0x1d/0x40
[   46.888037] EAX: f56ac1c0 EBX: fffffff8 ECX: 3ffffc6e EDX: f55c5cf2
[   46.888037] ESI: f55c6b32 EDI: f56ad000 EBP: f55c5c68 ESP: f55c5c5c
[   46.888037]  DS: 007b ES: 007b FS: 00d8 GS: 00e0 SS: 0068
[   46.888037] CR0: 8005003b CR2: f56ad000 CR3: 3557d000 CR4: 000006f0
[   46.888037] DR0: 00000000 DR1: 00000000 DR2: 00000000 DR3: 00000000
[   46.888037] DR6: ffff0ff0 DR7: 00000400
[   46.888037] Stack:
[   46.888037]  fffffff8 00000010 00000003 f55c5cac f8c6a54c ffffffff f8c69eb2 00000000
[   46.888037]  f4783cdc f57f0070 f759c590 1001c580 00000003 0200000a 00000000 f5a88560
[   46.888037]  f5ba2600 f5a88560 00000041 00000000 f55c5d90 f8c6f4c7 00000008 f55c5cf2
[   46.888037] Call Trace:
[   46.888037]  [&lt;f8c6a54c&gt;] l2cap_send_cmd+0x1cc/0x230 [bluetooth]
[   46.888037]  [&lt;f8c69eb2&gt;] ? l2cap_global_chan_by_psm+0x152/0x1a0 [bluetooth]
[   46.888037]  [&lt;f8c6f4c7&gt;] l2cap_connect+0x3f7/0x540 [bluetooth]
[   46.888037]  [&lt;c019b37b&gt;] ? trace_hardirqs_off+0xb/0x10
[   46.888037]  [&lt;c01a0ff8&gt;] ? mark_held_locks+0x68/0x110
[   46.888037]  [&lt;c064ad20&gt;] ? mutex_lock_nested+0x280/0x360
[   46.888037]  [&lt;c064b9d9&gt;] ? __mutex_unlock_slowpath+0xa9/0x150
[   46.888037]  [&lt;c01a118c&gt;] ? trace_hardirqs_on_caller+0xec/0x1b0
[   46.888037]  [&lt;c064ad08&gt;] ? mutex_lock_nested+0x268/0x360
[   46.888037]  [&lt;c01a125b&gt;] ? trace_hardirqs_on+0xb/0x10
[   46.888037]  [&lt;f8c72f8d&gt;] l2cap_recv_frame+0xb2d/0x1d30 [bluetooth]
[   46.888037]  [&lt;c01a0ff8&gt;] ? mark_held_locks+0x68/0x110
[   46.888037]  [&lt;c064b9d9&gt;] ? __mutex_unlock_slowpath+0xa9/0x150
[   46.888037]  [&lt;c01a118c&gt;] ? trace_hardirqs_on_caller+0xec/0x1b0
[   46.888037]  [&lt;f8c754f1&gt;] l2cap_recv_acldata+0x2a1/0x320 [bluetooth]
[   46.888037]  [&lt;f8c491d8&gt;] hci_rx_work+0x518/0x810 [bluetooth]
[   46.888037]  [&lt;f8c48df2&gt;] ? hci_rx_work+0x132/0x810 [bluetooth]
[   46.888037]  [&lt;c0158979&gt;] process_one_work+0x1a9/0x600
[   46.888037]  [&lt;c01588fb&gt;] ? process_one_work+0x12b/0x600
[   46.888037]  [&lt;c015922e&gt;] ? worker_thread+0x19e/0x320
[   46.888037]  [&lt;c015922e&gt;] ? worker_thread+0x19e/0x320
[   46.888037]  [&lt;c0159187&gt;] worker_thread+0xf7/0x320
[   46.888037]  [&lt;c0159090&gt;] ? rescuer_thread+0x290/0x290
[   46.888037]  [&lt;c01602f8&gt;] kthread+0xa8/0xb0
[   46.888037]  [&lt;c0656777&gt;] ret_from_kernel_thread+0x1b/0x28
[   46.888037]  [&lt;c0160250&gt;] ? flush_kthread_worker+0x120/0x120
[   46.888037] Code: c3 90 8d 74 26 00 e8 63 fc ff ff eb e8 90 55 89 e5 83 ec 0c 89 5d f4 89 75 f8 89 7d fc 3e 8d 74 26 00 89 cb 89 c7 c1 e9 02 89 d6 &lt;f3&gt; a5 89 d9 83 e1 03 74 02 f3 a4 8b 5d f4 8b 75 f8 8b 7d fc 89
[   46.888037] EIP: [&lt;c03d94cd&gt;] memcpy+0x1d/0x40 SS:ESP 0068:f55c5c5c
[   46.888037] CR2: 00000000f56ad000
[   46.888037] ---[ end trace 0217c1f4d78714a9 ]---

Signed-off-by: Anderson Lizardo &lt;anderson.lizardo@openbossa.org&gt;
Signed-off-by: Gustavo Padovan &lt;gustavo.padovan@collabora.co.uk&gt;
Signed-off-by: John W. Linville &lt;linville@tuxdriver.com&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>l2tp: Fix sendmsg() return value</title>
<updated>2013-06-27T17:34:33Z</updated>
<author>
<name>Guillaume Nault</name>
<email>g.nault@alphalink.fr</email>
</author>
<published>2013-06-12T14:07:36Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=60ab7833a93b180b420a18e24e88e3a9528a7038'/>
<id>urn:sha1:60ab7833a93b180b420a18e24e88e3a9528a7038</id>
<content type='text'>
[ Upstream commit a6f79d0f26704214b5b702bbac525cb72997f984 ]

PPPoL2TP sockets should comply with the standard send*() return values
(i.e. return number of bytes sent instead of 0 upon success).

Signed-off-by: Guillaume Nault &lt;g.nault@alphalink.fr&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>l2tp: Fix PPP header erasure and memory leak</title>
<updated>2013-06-27T17:34:33Z</updated>
<author>
<name>Guillaume Nault</name>
<email>g.nault@alphalink.fr</email>
</author>
<published>2013-06-12T14:07:23Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=6e092615d27d7036832c18f1c14b691c6c1cbb1d'/>
<id>urn:sha1:6e092615d27d7036832c18f1c14b691c6c1cbb1d</id>
<content type='text'>
[ Upstream commit 55b92b7a11690bc377b5d373872a6b650ae88e64 ]

Copy user data after PPP framing header. This prevents erasure of the
added PPP header and avoids leaking two bytes of uninitialised memory
at the end of skb's data buffer.

Signed-off-by: Guillaume Nault &lt;g.nault@alphalink.fr&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>packet: packet_getname_spkt: make sure string is always 0-terminated</title>
<updated>2013-06-27T17:34:33Z</updated>
<author>
<name>Daniel Borkmann</name>
<email>dborkman@redhat.com</email>
</author>
<published>2013-06-12T14:02:27Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=b4d45a2af9c9ca5c14e00375366125e7c31d5293'/>
<id>urn:sha1:b4d45a2af9c9ca5c14e00375366125e7c31d5293</id>
<content type='text'>
[ Upstream commit 2dc85bf323515e59e15dfa858d1472bb25cad0fe ]

uaddr-&gt;sa_data is exactly of size 14, which is hard-coded here and
passed as a size argument to strncpy(). A device name can be of size
IFNAMSIZ (== 16), meaning we might leave the destination string
unterminated. Thus, use strlcpy() and also sizeof() while we're
at it. We need to memset the data area beforehand, since strlcpy
does not padd the remaining buffer with zeroes for user space, so
that we do not possibly leak anything.

Signed-off-by: Daniel Borkmann &lt;dborkman@redhat.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: sctp: fix NULL pointer dereference in socket destruction</title>
<updated>2013-06-27T17:34:33Z</updated>
<author>
<name>Daniel Borkmann</name>
<email>dborkman@redhat.com</email>
</author>
<published>2013-06-06T13:53:47Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=bba0c7f5421c40314ef48be4a7540efa76166dcd'/>
<id>urn:sha1:bba0c7f5421c40314ef48be4a7540efa76166dcd</id>
<content type='text'>
[ Upstream commit 1abd165ed757db1afdefaac0a4bc8a70f97d258c ]

While stress testing sctp sockets, I hit the following panic:

BUG: unable to handle kernel NULL pointer dereference at 0000000000000020
IP: [&lt;ffffffffa0490c4e&gt;] sctp_endpoint_free+0xe/0x40 [sctp]
PGD 7cead067 PUD 7ce76067 PMD 0
Oops: 0000 [#1] SMP
Modules linked in: sctp(F) libcrc32c(F) [...]
CPU: 7 PID: 2950 Comm: acc Tainted: GF            3.10.0-rc2+ #1
Hardware name: Dell Inc. PowerEdge T410/0H19HD, BIOS 1.6.3 02/01/2011
task: ffff88007ce0e0c0 ti: ffff88007b568000 task.ti: ffff88007b568000
RIP: 0010:[&lt;ffffffffa0490c4e&gt;]  [&lt;ffffffffa0490c4e&gt;] sctp_endpoint_free+0xe/0x40 [sctp]
RSP: 0018:ffff88007b569e08  EFLAGS: 00010292
RAX: 0000000000000000 RBX: ffff88007db78a00 RCX: dead000000200200
RDX: ffffffffa049fdb0 RSI: ffff8800379baf38 RDI: 0000000000000000
RBP: ffff88007b569e18 R08: ffff88007c230da0 R09: 0000000000000001
R10: 0000000000000000 R11: 0000000000000000 R12: 0000000000000000
R13: ffff880077990d00 R14: 0000000000000084 R15: ffff88007db78a00
FS:  00007fc18ab61700(0000) GS:ffff88007fc60000(0000) knlGS:0000000000000000
CS:  0010 DS: 0000 ES: 0000 CR0: 000000008005003b
CR2: 0000000000000020 CR3: 000000007cf9d000 CR4: 00000000000007e0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 0000000000000400
Stack:
 ffff88007b569e38 ffff88007db78a00 ffff88007b569e38 ffffffffa049fded
 ffffffff81abf0c0 ffff88007db78a00 ffff88007b569e58 ffffffff8145b60e
 0000000000000000 0000000000000000 ffff88007b569eb8 ffffffff814df36e
Call Trace:
 [&lt;ffffffffa049fded&gt;] sctp_destroy_sock+0x3d/0x80 [sctp]
 [&lt;ffffffff8145b60e&gt;] sk_common_release+0x1e/0xf0
 [&lt;ffffffff814df36e&gt;] inet_create+0x2ae/0x350
 [&lt;ffffffff81455a6f&gt;] __sock_create+0x11f/0x240
 [&lt;ffffffff81455bf0&gt;] sock_create+0x30/0x40
 [&lt;ffffffff8145696c&gt;] SyS_socket+0x4c/0xc0
 [&lt;ffffffff815403be&gt;] ? do_page_fault+0xe/0x10
 [&lt;ffffffff8153cb32&gt;] ? page_fault+0x22/0x30
 [&lt;ffffffff81544e02&gt;] system_call_fastpath+0x16/0x1b
Code: 0c c9 c3 66 2e 0f 1f 84 00 00 00 00 00 e8 fb fe ff ff c9 c3 66 0f
      1f 84 00 00 00 00 00 55 48 89 e5 53 48 83 ec 08 66 66 66 66 90 &lt;48&gt;
      8b 47 20 48 89 fb c6 47 1c 01 c6 40 12 07 e8 9e 68 01 00 48
RIP  [&lt;ffffffffa0490c4e&gt;] sctp_endpoint_free+0xe/0x40 [sctp]
 RSP &lt;ffff88007b569e08&gt;
CR2: 0000000000000020
---[ end trace e0d71ec1108c1dd9 ]---

I did not hit this with the lksctp-tools functional tests, but with a
small, multi-threaded test program, that heavily allocates, binds,
listens and waits in accept on sctp sockets, and then randomly kills
some of them (no need for an actual client in this case to hit this).
Then, again, allocating, binding, etc, and then killing child processes.

This panic then only occurs when ``echo 1 &gt; /proc/sys/net/sctp/auth_enable''
is set. The cause for that is actually very simple: in sctp_endpoint_init()
we enter the path of sctp_auth_init_hmacs(). There, we try to allocate
our crypto transforms through crypto_alloc_hash(). In our scenario,
it then can happen that crypto_alloc_hash() fails with -EINTR from
crypto_larval_wait(), thus we bail out and release the socket via
sk_common_release(), sctp_destroy_sock() and hit the NULL pointer
dereference as soon as we try to access members in the endpoint during
sctp_endpoint_free(), since endpoint at that time is still NULL. Now,
if we have that case, we do not need to do any cleanup work and just
leave the destruction handler.

Signed-off-by: Daniel Borkmann &lt;dborkman@redhat.com&gt;
Acked-by: Neil Horman &lt;nhorman@tuxdriver.com&gt;
Acked-by: Vlad Yasevich &lt;vyasevich@gmail.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>ipv6: assign rt6_info to inet6_ifaddr in init_loopback</title>
<updated>2013-06-27T17:34:33Z</updated>
<author>
<name>Gao feng</name>
<email>gaofeng@cn.fujitsu.com</email>
</author>
<published>2013-06-02T22:16:21Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=0e7d0e50a7502671ff7deed63595ed2d20ac1e8c'/>
<id>urn:sha1:0e7d0e50a7502671ff7deed63595ed2d20ac1e8c</id>
<content type='text'>
[ Upstream commit 534c877928a16ae5f9776436a497109639bf67dc ]

Commit 25fb6ca4ed9cad72f14f61629b68dc03c0d9713f
"net IPv6 : Fix broken IPv6 routing table after loopback down-up"
forgot to assign rt6_info to the inet6_ifaddr.
When disable the net device, the rt6_info which allocated
in init_loopback will not be destroied in __ipv6_ifa_notify.

This will trigger the waring message below
[23527.916091] unregister_netdevice: waiting for tap0 to become free. Usage count = 1

Reported-by: Arkadiusz Miskiewicz &lt;a.miskiewicz@gmail.com&gt;
Signed-off-by: Gao feng &lt;gaofeng@cn.fujitsu.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-27T17:34: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=e1b796f9408a33d18709e9fdbf18ce91dfede962'/>
<id>urn:sha1:e1b796f9408a33d18709e9fdbf18ce91dfede962</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;
}

Cc: David S. Miller &lt;davem@davemloft.net&gt;
Signed-off-by: Andy Lutomirski &lt;luto@amacapital.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>ip_tunnel: fix kernel panic with icmp_dest_unreach</title>
<updated>2013-06-27T17:34:32Z</updated>
<author>
<name>Eric Dumazet</name>
<email>edumazet@google.com</email>
</author>
<published>2013-05-24T05:49:58Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=34e4c0aed353934a72809784999900fc7b5653ef'/>
<id>urn:sha1:34e4c0aed353934a72809784999900fc7b5653ef</id>
<content type='text'>
[ Upstream commit a622260254ee481747cceaaa8609985b29a31565 ]

Daniel Petre reported crashes in icmp_dst_unreach() with following call
graph:

Daniel found a similar problem mentioned in
 http://lkml.indiana.edu/hypermail/linux/kernel/1007.0/00961.html

And indeed this is the root cause : skb-&gt;cb[] contains data fooling IP
stack.

We must clear IPCB in ip_tunnel_xmit() sooner in case dst_link_failure()
is called. Or else skb-&gt;cb[] might contain garbage from GSO segmentation
layer.

A similar fix was tested on linux-3.9, but gre code was refactored in
linux-3.10. I'll send patches for stable kernels as well.

Many thanks to Daniel for providing reports, patches and testing !

Reported-by: Daniel Petre &lt;daniel.petre@rcs-rds.ro&gt;
Signed-off-by: Eric Dumazet &lt;edumazet@google.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>tcp: xps: fix reordering issues</title>
<updated>2013-06-27T17:34:32Z</updated>
<author>
<name>Eric Dumazet</name>
<email>edumazet@google.com</email>
</author>
<published>2013-05-23T07:44:20Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=04e093d128963bfe46f50dbcff4c70147464fd0a'/>
<id>urn:sha1:04e093d128963bfe46f50dbcff4c70147464fd0a</id>
<content type='text'>
[ Upstream commit 547669d483e5783d722772af1483fa474da7caf9 ]

commit 3853b5841c01a ("xps: Improvements in TX queue selection")
introduced ooo_okay flag, but the condition to set it is slightly wrong.

In our traces, we have seen ACK packets being received out of order,
and RST packets sent in response.

We should test if we have any packets still in host queue.

Signed-off-by: Eric Dumazet &lt;edumazet@google.com&gt;
Cc: Tom Herbert &lt;therbert@google.com&gt;
Cc: Yuchung Cheng &lt;ycheng@google.com&gt;
Cc: Neal Cardwell &lt;ncardwell@google.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>
</feed>
