<feed xmlns='http://www.w3.org/2005/Atom'>
<title>user/sven/linux.git/include, branch v3.12.41</title>
<subtitle>Linux Kernel
</subtitle>
<id>https://git.stealer.net/cgit.cgi/user/sven/linux.git/atom?h=v3.12.41</id>
<link rel='self' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/atom?h=v3.12.41'/>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/'/>
<updated>2015-04-27T17:59:54Z</updated>
<entry>
<title>nick kvfree() from apparmor</title>
<updated>2015-04-27T17:59:54Z</updated>
<author>
<name>Al Viro</name>
<email>viro@zeniv.linux.org.uk</email>
</author>
<published>2014-05-06T18:02:53Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=fb6a2a8ebe2741cd15d9f4c613c6b40cf0e40ea5'/>
<id>urn:sha1:fb6a2a8ebe2741cd15d9f4c613c6b40cf0e40ea5</id>
<content type='text'>
commit 39f1f78d53b9bcbca91967380c5f0f2305a5c55f upstream.

too many places open-code it

Signed-off-by: Al Viro &lt;viro@zeniv.linux.org.uk&gt;
Signed-off-by: Jiri Slaby &lt;jslaby@suse.cz&gt;
</content>
</entry>
<entry>
<title>Defer processing of REQ_PREEMPT requests for blocked devices</title>
<updated>2015-04-22T06:58:38Z</updated>
<author>
<name>Bart Van Assche</name>
<email>bart.vanassche@sandisk.com</email>
</author>
<published>2015-03-04T09:31:47Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=b71eafb8217c2006b45a4a056b0421870d16a6c4'/>
<id>urn:sha1:b71eafb8217c2006b45a4a056b0421870d16a6c4</id>
<content type='text'>
commit bba0bdd7ad4713d82338bcd9b72d57e9335a664b upstream.

SCSI transport drivers and SCSI LLDs block a SCSI device if the
transport layer is not operational. This means that in this state
no requests should be processed, even if the REQ_PREEMPT flag has
been set. This patch avoids that a rescan shortly after a cable
pull sporadically triggers the following kernel oops:

BUG: unable to handle kernel paging request at ffffc9001a6bc084
IP: [&lt;ffffffffa04e08f2&gt;] mlx4_ib_post_send+0xd2/0xb30 [mlx4_ib]
Process rescan-scsi-bus (pid: 9241, threadinfo ffff88053484a000, task ffff880534aae100)
Call Trace:
 [&lt;ffffffffa0718135&gt;] srp_post_send+0x65/0x70 [ib_srp]
 [&lt;ffffffffa071b9df&gt;] srp_queuecommand+0x1cf/0x3e0 [ib_srp]
 [&lt;ffffffffa0001ff1&gt;] scsi_dispatch_cmd+0x101/0x280 [scsi_mod]
 [&lt;ffffffffa0009ad1&gt;] scsi_request_fn+0x411/0x4d0 [scsi_mod]
 [&lt;ffffffff81223b37&gt;] __blk_run_queue+0x27/0x30
 [&lt;ffffffff8122a8d2&gt;] blk_execute_rq_nowait+0x82/0x110
 [&lt;ffffffff8122a9c2&gt;] blk_execute_rq+0x62/0xf0
 [&lt;ffffffffa000b0e8&gt;] scsi_execute+0xe8/0x190 [scsi_mod]
 [&lt;ffffffffa000b2f3&gt;] scsi_execute_req+0xa3/0x130 [scsi_mod]
 [&lt;ffffffffa000c1aa&gt;] scsi_probe_lun+0x17a/0x450 [scsi_mod]
 [&lt;ffffffffa000ce86&gt;] scsi_probe_and_add_lun+0x156/0x480 [scsi_mod]
 [&lt;ffffffffa000dc2f&gt;] __scsi_scan_target+0xdf/0x1f0 [scsi_mod]
 [&lt;ffffffffa000dfa3&gt;] scsi_scan_host_selected+0x183/0x1c0 [scsi_mod]
 [&lt;ffffffffa000edfb&gt;] scsi_scan+0xdb/0xe0 [scsi_mod]
 [&lt;ffffffffa000ee13&gt;] store_scan+0x13/0x20 [scsi_mod]
 [&lt;ffffffff811c8d9b&gt;] sysfs_write_file+0xcb/0x160
 [&lt;ffffffff811589de&gt;] vfs_write+0xce/0x140
 [&lt;ffffffff81158b53&gt;] sys_write+0x53/0xa0
 [&lt;ffffffff81464592&gt;] system_call_fastpath+0x16/0x1b
 [&lt;00007f611c9d9300&gt;] 0x7f611c9d92ff

Reported-by: Max Gurtuvoy &lt;maxg@mellanox.com&gt;
Signed-off-by: Bart Van Assche &lt;bart.vanassche@sandisk.com&gt;
Reviewed-by: Mike Christie &lt;michaelc@cs.wisc.edu&gt;
Signed-off-by: James Bottomley &lt;JBottomley@Odin.com&gt;
Signed-off-by: Jiri Slaby &lt;jslaby@suse.cz&gt;
</content>
</entry>
<entry>
<title>remove extra definitions of U32_MAX</title>
<updated>2015-04-22T06:58:25Z</updated>
<author>
<name>Alex Elder</name>
<email>alex.elder@linaro.org</email>
</author>
<published>2014-01-23T23:54:01Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=dc8adb882d40ca75c28e0e4b3ec7e9fd3386acd9'/>
<id>urn:sha1:dc8adb882d40ca75c28e0e4b3ec7e9fd3386acd9</id>
<content type='text'>
commit 04f9b74e4d96d349de12fdd4e6626af4a9f75e09 upstream.

Now that the definition is centralized in &lt;linux/kernel.h&gt;, the
definitions of U32_MAX (and related) elsewhere in the kernel can be
removed.

Signed-off-by: Alex Elder &lt;elder@linaro.org&gt;
Acked-by: Sage Weil &lt;sage@inktank.com&gt;
Acked-by: David S. Miller &lt;davem@davemloft.net&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: Jiri Slaby &lt;jslaby@suse.cz&gt;
</content>
</entry>
<entry>
<title>kernel.h: define u8, s8, u32, etc. limits</title>
<updated>2015-04-22T06:58:17Z</updated>
<author>
<name>Alex Elder</name>
<email>alex.elder@linaro.org</email>
</author>
<published>2014-01-23T23:54:00Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=70f9463cdf882d4f04bbf7f5e13c893a2efe07e0'/>
<id>urn:sha1:70f9463cdf882d4f04bbf7f5e13c893a2efe07e0</id>
<content type='text'>
commit 89a0714106aac7309c7dfa0f004b39e1e89d2942 upstream.

Create constants that define the maximum and minimum values
representable by the kernel types u8, s8, u16, s16, and so on.

Signed-off-by: Alex Elder &lt;elder@linaro.org&gt;
Cc: Sage Weil &lt;sage@inktank.com&gt;
Cc: David Miller &lt;davem@davemloft.net&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: Jiri Slaby &lt;jslaby@suse.cz&gt;
</content>
</entry>
<entry>
<title>conditionally define U32_MAX</title>
<updated>2015-04-22T06:58:14Z</updated>
<author>
<name>Alex Elder</name>
<email>alex.elder@linaro.org</email>
</author>
<published>2014-01-23T23:53:59Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=dd86ca3aae59e2f48512805e6df06a5070632730'/>
<id>urn:sha1:dd86ca3aae59e2f48512805e6df06a5070632730</id>
<content type='text'>
commit 77719536dc00f8fd8f5abe6dadbde5331c37f996 upstream.

The symbol U32_MAX is defined in several spots.  Change these
definitions to be conditional.  This is in preparation for the next
patch, which centralizes the definition in &lt;linux/kernel.h&gt;.

Signed-off-by: Alex Elder &lt;elder@linaro.org&gt;
Cc: Sage Weil &lt;sage@inktank.com&gt;
Cc: David Miller &lt;davem@davemloft.net&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: Jiri Slaby &lt;jslaby@suse.cz&gt;
</content>
</entry>
<entry>
<title>net: fix sparse warning in sk_dst_set()</title>
<updated>2015-04-09T12:13:51Z</updated>
<author>
<name>Eric Dumazet</name>
<email>edumazet@google.com</email>
</author>
<published>2014-07-02T09:39:38Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=1f2251ec984761b34036316a43a5eb2dc6e9df90'/>
<id>urn:sha1:1f2251ec984761b34036316a43a5eb2dc6e9df90</id>
<content type='text'>
commit 5925a0555bdaf0b396a84318cbc21ba085f6c0d3 upstream.

sk_dst_cache has __rcu annotation, so we need a cast to avoid
following sparse error :

include/net/sock.h:1774:19: warning: incorrect type in initializer (different address spaces)
include/net/sock.h:1774:19:    expected struct dst_entry [noderef] &lt;asn:4&gt;*__ret
include/net/sock.h:1774:19:    got struct dst_entry *dst

Signed-off-by: Eric Dumazet &lt;edumazet@google.com&gt;
Reported-by: kbuild test robot &lt;fengguang.wu@intel.com&gt;
Fixes: 7f502361531e ("ipv4: irq safe sk_dst_[re]set() and ipv4_sk_update_pmtu() fix")
Signed-off-by: David S. Miller &lt;davem@davemloft.net&gt;
Signed-off-by: Jiri Slaby &lt;jslaby@suse.cz&gt;
</content>
</entry>
<entry>
<title>NFS: Add attribute update barriers to nfs_setattr_update_inode()</title>
<updated>2015-04-09T12:13:22Z</updated>
<author>
<name>Trond Myklebust</name>
<email>trond.myklebust@primarydata.com</email>
</author>
<published>2015-02-26T21:09:04Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=db9e4643a103945a7ce6880f14b751845e0eb988'/>
<id>urn:sha1:db9e4643a103945a7ce6880f14b751845e0eb988</id>
<content type='text'>
commit f044636d972246d451e06226cc1675d5da389762 upstream.

Ensure that other operations which raced with our setattr RPC call
cannot revert the file attribute changes that were made on the server.
To do so, we artificially bump the attribute generation counter on
the inode so that all calls to nfs_fattr_init() that precede ours
will be dropped.

The motivation for the patch came from Chuck Lever's reports of readaheads
racing with truncate operations and causing the file size to be reverted.

Reported-by: Chuck Lever &lt;chuck.lever@oracle.com&gt;
Signed-off-by: Trond Myklebust &lt;trond.myklebust@primarydata.com&gt;
Tested-by: Chuck Lever &lt;chuck.lever@oracle.com&gt;
Acked-by: NeilBrown &lt;neilb@suse.de&gt;
Signed-off-by: Jiri Slaby &lt;jslaby@suse.cz&gt;
</content>
</entry>
<entry>
<title>workqueue: fix hang involving racing cancel[_delayed]_work_sync()'s for PREEMPT_NONE</title>
<updated>2015-04-09T11:14:05Z</updated>
<author>
<name>Tejun Heo</name>
<email>tj@kernel.org</email>
</author>
<published>2015-03-05T13:04:13Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=97b57f41a0054767b0834ac9b34dfb22a8ee38f4'/>
<id>urn:sha1:97b57f41a0054767b0834ac9b34dfb22a8ee38f4</id>
<content type='text'>
commit 8603e1b30027f943cc9c1eef2b291d42c3347af1 upstream.

cancel[_delayed]_work_sync() are implemented using
__cancel_work_timer() which grabs the PENDING bit using
try_to_grab_pending() and then flushes the work item with PENDING set
to prevent the on-going execution of the work item from requeueing
itself.

try_to_grab_pending() can always grab PENDING bit without blocking
except when someone else is doing the above flushing during
cancelation.  In that case, try_to_grab_pending() returns -ENOENT.  In
this case, __cancel_work_timer() currently invokes flush_work().  The
assumption is that the completion of the work item is what the other
canceling task would be waiting for too and thus waiting for the same
condition and retrying should allow forward progress without excessive
busy looping

Unfortunately, this doesn't work if preemption is disabled or the
latter task has real time priority.  Let's say task A just got woken
up from flush_work() by the completion of the target work item.  If,
before task A starts executing, task B gets scheduled and invokes
__cancel_work_timer() on the same work item, its try_to_grab_pending()
will return -ENOENT as the work item is still being canceled by task A
and flush_work() will also immediately return false as the work item
is no longer executing.  This puts task B in a busy loop possibly
preventing task A from executing and clearing the canceling state on
the work item leading to a hang.

task A			task B			worker

						executing work
__cancel_work_timer()
  try_to_grab_pending()
  set work CANCELING
  flush_work()
    block for work completion
						completion, wakes up A
			__cancel_work_timer()
			while (forever) {
			  try_to_grab_pending()
			    -ENOENT as work is being canceled
			  flush_work()
			    false as work is no longer executing
			}

This patch removes the possible hang by updating __cancel_work_timer()
to explicitly wait for clearing of CANCELING rather than invoking
flush_work() after try_to_grab_pending() fails with -ENOENT.

Link: http://lkml.kernel.org/g/20150206171156.GA8942@axis.com

v3: bit_waitqueue() can't be used for work items defined in vmalloc
    area.  Switched to custom wake function which matches the target
    work item and exclusive wait and wakeup.

v2: v1 used wake_up() on bit_waitqueue() which leads to NULL deref if
    the target bit waitqueue has wait_bit_queue's on it.  Use
    DEFINE_WAIT_BIT() and __wake_up_bit() instead.  Reported by Tomeu
    Vizoso.

Signed-off-by: Tejun Heo &lt;tj@kernel.org&gt;
Reported-by: Rabin Vincent &lt;rabin.vincent@axis.com&gt;
Cc: Tomeu Vizoso &lt;tomeu.vizoso@gmail.com&gt;
Tested-by: Jesper Nilsson &lt;jesper.nilsson@axis.com&gt;
Tested-by: Rabin Vincent &lt;rabin.vincent@axis.com&gt;
Signed-off-by: Jiri Slaby &lt;jslaby@suse.cz&gt;
</content>
</entry>
<entry>
<title>mm: thp: give transparent hugepage code a separate copy_page</title>
<updated>2015-04-09T11:13:54Z</updated>
<author>
<name>Dave Hansen</name>
<email>dave.hansen@linux.intel.com</email>
</author>
<published>2013-11-21T22:31:58Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=1ef840f5d8195897c80d40eb9f822ee6e91f9f4a'/>
<id>urn:sha1:1ef840f5d8195897c80d40eb9f822ee6e91f9f4a</id>
<content type='text'>
commit 30b0a105d9f7141e4cbf72ae5511832457d89788 upstream.

Right now, the migration code in migrate_page_copy() uses copy_huge_page()
for hugetlbfs and thp pages:

       if (PageHuge(page) || PageTransHuge(page))
                copy_huge_page(newpage, page);

So, yay for code reuse.  But:

  void copy_huge_page(struct page *dst, struct page *src)
  {
        struct hstate *h = page_hstate(src);

and a non-hugetlbfs page has no page_hstate().  This works 99% of the
time because page_hstate() determines the hstate from the page order
alone.  Since the page order of a THP page matches the default hugetlbfs
page order, it works.

But, if you change the default huge page size on the boot command-line
(say default_hugepagesz=1G), then we might not even *have* a 2MB hstate
so page_hstate() returns null and copy_huge_page() oopses pretty fast
since copy_huge_page() dereferences the hstate:

  void copy_huge_page(struct page *dst, struct page *src)
  {
        struct hstate *h = page_hstate(src);
        if (unlikely(pages_per_huge_page(h) &gt; MAX_ORDER_NR_PAGES)) {
  ...

Mel noticed that the migration code is really the only user of these
functions.  This moves all the copy code over to migrate.c and makes
copy_huge_page() work for THP by checking for it explicitly.

I believe the bug was introduced in commit b32967ff101a ("mm: numa: Add
THP migration for the NUMA working set scanning fault case")

[akpm@linux-foundation.org: fix coding-style and comment text, per Naoya Horiguchi]
Signed-off-by: Dave Hansen &lt;dave.hansen@linux.intel.com&gt;
Acked-by: Mel Gorman &lt;mgorman@suse.de&gt;
Reviewed-by: Naoya Horiguchi &lt;n-horiguchi@ah.jp.nec.com&gt;
Cc: Hillf Danton &lt;dhillf@gmail.com&gt;
Cc: Andrea Arcangeli &lt;aarcange@redhat.com&gt;
Tested-by: Dave Jiang &lt;dave.jiang@intel.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: Jiri Slaby &lt;jslaby@suse.cz&gt;
</content>
</entry>
<entry>
<title>mm, hugetlb: define page_hstate for !HUGETLB_PAGE</title>
<updated>2015-04-09T11:13:54Z</updated>
<author>
<name>Jiri Slaby</name>
<email>jslaby@suse.cz</email>
</author>
<published>2015-04-02T09:22:07Z</published>
<link rel='alternate' type='text/html' href='https://git.stealer.net/cgit.cgi/user/sven/linux.git/commit/?id=04240adfe44b8a38c21ca0972ef620254b931e25'/>
<id>urn:sha1:04240adfe44b8a38c21ca0972ef620254b931e25</id>
<content type='text'>
This is a single hunk introduced later in the upstream commit
cb900f41215447433cbc456d1c4294e858a84d7c (mm, hugetlb: convert
hugetlbfs to use split pmd lock). We need page_hstate even for
!HUGETLB_PAGE case for the next patch (mm: thp: give transparent
hugepage code a separate copy_page).

Signed-off-by: Jiri Slaby &lt;jslaby@suse.cz&gt;
</content>
</entry>
</feed>
