From 3edd755804234a413039907b2f5b29aee0de119c Mon Sep 17 00:00:00 2001 From: Greg Kroah-Hartman Date: Sat, 17 Oct 2015 17:34:10 -0700 Subject: [PATCH] 3.14-stable patches added patches: arm64-readahead-fault-retry-breaks-mmap-file-read-random-detection.patch clk-ti-fix-dual-registration-of-uart4_ick.patch dm-cache-fix-null-pointer-when-switching-from-cleaner-policy.patch fib_rules-fix-dump_rules-not-to-exit-early.patch genirq-fix-race-in-register_irq_proc.patch jbd2-avoid-infinite-loop-when-destroying-aborted-journal.patch m68k-define-asmlinkage_protect.patch staging-speakup-fix-speakup-r-regression.patch --- ...eaks-mmap-file-read-random-detection.patch | 48 +++++ ...i-fix-dual-registration-of-uart4_ick.patch | 51 +++++ ...r-when-switching-from-cleaner-policy.patch | 37 ++++ ...les-fix-dump_rules-not-to-exit-early.patch | 38 ++++ ...genirq-fix-race-in-register_irq_proc.patch | 76 ++++++++ ...loop-when-destroying-aborted-journal.patch | 174 ++++++++++++++++++ .../m68k-define-asmlinkage_protect.patch | 70 +++++++ queue-3.14/series | 8 + ...ing-speakup-fix-speakup-r-regression.patch | 37 ++++ 9 files changed, 539 insertions(+) create mode 100644 queue-3.14/arm64-readahead-fault-retry-breaks-mmap-file-read-random-detection.patch create mode 100644 queue-3.14/clk-ti-fix-dual-registration-of-uart4_ick.patch create mode 100644 queue-3.14/dm-cache-fix-null-pointer-when-switching-from-cleaner-policy.patch create mode 100644 queue-3.14/fib_rules-fix-dump_rules-not-to-exit-early.patch create mode 100644 queue-3.14/genirq-fix-race-in-register_irq_proc.patch create mode 100644 queue-3.14/jbd2-avoid-infinite-loop-when-destroying-aborted-journal.patch create mode 100644 queue-3.14/m68k-define-asmlinkage_protect.patch create mode 100644 queue-3.14/staging-speakup-fix-speakup-r-regression.patch diff --git a/queue-3.14/arm64-readahead-fault-retry-breaks-mmap-file-read-random-detection.patch b/queue-3.14/arm64-readahead-fault-retry-breaks-mmap-file-read-random-detection.patch new file mode 100644 index 00000000000..9b9c8cb2758 --- /dev/null +++ b/queue-3.14/arm64-readahead-fault-retry-breaks-mmap-file-read-random-detection.patch @@ -0,0 +1,48 @@ +From 569ba74a7ba69f46ce2950bf085b37fea2408385 Mon Sep 17 00:00:00 2001 +From: Mark Salyzyn +Date: Mon, 21 Sep 2015 21:39:50 +0100 +Subject: arm64: readahead: fault retry breaks mmap file read random detection + +From: Mark Salyzyn + +commit 569ba74a7ba69f46ce2950bf085b37fea2408385 upstream. + +This is the arm64 portion of commit 45cac65b0fcd ("readahead: fault +retry breaks mmap file read random detection"), which was absent from +the initial port and has since gone unnoticed. The original commit says: + +> .fault now can retry. The retry can break state machine of .fault. In +> filemap_fault, if page is miss, ra->mmap_miss is increased. In the second +> try, since the page is in page cache now, ra->mmap_miss is decreased. And +> these are done in one fault, so we can't detect random mmap file access. +> +> Add a new flag to indicate .fault is tried once. In the second try, skip +> ra->mmap_miss decreasing. The filemap_fault state machine is ok with it. + +With this change, Mark reports that: + +> Random read improves by 250%, sequential read improves by 40%, and +> random write by 400% to an eMMC device with dm crypto wrapped around it. + +Cc: Shaohua Li +Cc: Rik van Riel +Cc: Wu Fengguang +Signed-off-by: Mark Salyzyn +Signed-off-by: Riley Andrews +Signed-off-by: Will Deacon +Signed-off-by: Greg Kroah-Hartman + +--- + arch/arm64/mm/fault.c | 1 + + 1 file changed, 1 insertion(+) + +--- a/arch/arm64/mm/fault.c ++++ b/arch/arm64/mm/fault.c +@@ -278,6 +278,7 @@ retry: + * starvation. + */ + mm_flags &= ~FAULT_FLAG_ALLOW_RETRY; ++ mm_flags |= FAULT_FLAG_TRIED; + goto retry; + } + } diff --git a/queue-3.14/clk-ti-fix-dual-registration-of-uart4_ick.patch b/queue-3.14/clk-ti-fix-dual-registration-of-uart4_ick.patch new file mode 100644 index 00000000000..49d39b79ab3 --- /dev/null +++ b/queue-3.14/clk-ti-fix-dual-registration-of-uart4_ick.patch @@ -0,0 +1,51 @@ +From 19e79687de22f23bcfb5e79cce3daba20af228d1 Mon Sep 17 00:00:00 2001 +From: Ben Dooks +Date: Tue, 29 Sep 2015 15:01:08 +0100 +Subject: clk: ti: fix dual-registration of uart4_ick + +From: Ben Dooks + +commit 19e79687de22f23bcfb5e79cce3daba20af228d1 upstream. + +On the OMAP AM3517 platform the uart4_ick gets registered +twice, causing any power management to /dev/ttyO3 to fail +when trying to wake the device up. + +This solves the following oops: + +[] Unhandled fault: external abort on non-linefetch (0x1028) at 0xfa09e008 +[] PC is at serial_omap_pm+0x48/0x15c +[] LR is at _raw_spin_unlock_irqrestore+0x30/0x5c + +Fixes: aafd900cab87 ("CLK: TI: add omap3 clock init file") +Cc: mturquette@baylibre.com +Cc: sboyd@codeaurora.org +Cc: linux-clk@vger.kernel.org +Cc: linux-omap@vger.kernel.org +Cc: linux-kernel@lists.codethink.co.uk +Signed-off-by: Ben Dooks +Signed-off-by: Tero Kristo +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/clk/ti/clk-3xxx.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/drivers/clk/ti/clk-3xxx.c ++++ b/drivers/clk/ti/clk-3xxx.c +@@ -174,7 +174,6 @@ static struct ti_dt_clk omap3xxx_clks[] + DT_CLK(NULL, "gpio2_ick", "gpio2_ick"), + DT_CLK(NULL, "wdt3_ick", "wdt3_ick"), + DT_CLK(NULL, "uart3_ick", "uart3_ick"), +- DT_CLK(NULL, "uart4_ick", "uart4_ick"), + DT_CLK(NULL, "gpt9_ick", "gpt9_ick"), + DT_CLK(NULL, "gpt8_ick", "gpt8_ick"), + DT_CLK(NULL, "gpt7_ick", "gpt7_ick"), +@@ -317,6 +316,7 @@ static struct ti_dt_clk am35xx_clks[] = + static struct ti_dt_clk omap36xx_clks[] = { + DT_CLK(NULL, "omap_192m_alwon_fck", "omap_192m_alwon_fck"), + DT_CLK(NULL, "uart4_fck", "uart4_fck"), ++ DT_CLK(NULL, "uart4_ick", "uart4_ick"), + { .node_name = NULL }, + }; + diff --git a/queue-3.14/dm-cache-fix-null-pointer-when-switching-from-cleaner-policy.patch b/queue-3.14/dm-cache-fix-null-pointer-when-switching-from-cleaner-policy.patch new file mode 100644 index 00000000000..3eded01b418 --- /dev/null +++ b/queue-3.14/dm-cache-fix-null-pointer-when-switching-from-cleaner-policy.patch @@ -0,0 +1,37 @@ +From 2bffa1503c5c06192eb1459180fac4416575a966 Mon Sep 17 00:00:00 2001 +From: Joe Thornber +Date: Fri, 9 Oct 2015 14:03:38 +0100 +Subject: dm cache: fix NULL pointer when switching from cleaner policy + +From: Joe Thornber + +commit 2bffa1503c5c06192eb1459180fac4416575a966 upstream. + +The cleaner policy doesn't make use of the per cache block hint space in +the metadata (unlike the other policies). When switching from the +cleaner policy to mq or smq a NULL pointer crash (in dm_tm_new_block) +was observed. The crash was caused by bugs in dm-cache-metadata.c +when trying to skip creation of the hint btree. + +The minimal fix is to change hint size for the cleaner policy to 4 bytes +(only hint size supported). + +Signed-off-by: Joe Thornber +Signed-off-by: Mike Snitzer +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/md/dm-cache-policy-cleaner.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/drivers/md/dm-cache-policy-cleaner.c ++++ b/drivers/md/dm-cache-policy-cleaner.c +@@ -434,7 +434,7 @@ static struct dm_cache_policy *wb_create + static struct dm_cache_policy_type wb_policy_type = { + .name = "cleaner", + .version = {1, 0, 0}, +- .hint_size = 0, ++ .hint_size = 4, + .owner = THIS_MODULE, + .create = wb_create + }; diff --git a/queue-3.14/fib_rules-fix-dump_rules-not-to-exit-early.patch b/queue-3.14/fib_rules-fix-dump_rules-not-to-exit-early.patch new file mode 100644 index 00000000000..51f36b0a8e1 --- /dev/null +++ b/queue-3.14/fib_rules-fix-dump_rules-not-to-exit-early.patch @@ -0,0 +1,38 @@ +From roland@kernel.org Sat Oct 17 17:11:23 2015 +From: Roland Dreier +Date: Mon, 5 Oct 2015 10:29:28 -0700 +Subject: fib_rules: Fix dump_rules() not to exit early +To: netdev@vger.kernel.org, stable@vger.kernel.org +Cc: Roland Dreier +Message-ID: <1444066168-5566-1-git-send-email-roland@kernel.org> + + +From: Roland Dreier + +Backports of 41fc014332d9 ("fib_rules: fix fib rule dumps across +multiple skbs") introduced a regression in "ip rule show" - it ends up +dumping the first rule over and over and never exiting, because 3.19 +and earlier are missing commit 053c095a82cf ("netlink: make +nlmsg_end() and genlmsg_end() void"), so fib_nl_fill_rule() ends up +returning skb->len (i.e. > 0) in the success case. + +Fix this by checking the return code for < 0 instead of != 0. + +Signed-off-by: Roland Dreier +Signed-off-by: Greg Kroah-Hartman + +--- + net/core/fib_rules.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/net/core/fib_rules.c ++++ b/net/core/fib_rules.c +@@ -631,7 +631,7 @@ static int dump_rules(struct sk_buff *sk + err = fib_nl_fill_rule(skb, rule, NETLINK_CB(cb->skb).portid, + cb->nlh->nlmsg_seq, RTM_NEWRULE, + NLM_F_MULTI, ops); +- if (err) ++ if (err < 0) + break; + skip: + idx++; diff --git a/queue-3.14/genirq-fix-race-in-register_irq_proc.patch b/queue-3.14/genirq-fix-race-in-register_irq_proc.patch new file mode 100644 index 00000000000..09255620cf8 --- /dev/null +++ b/queue-3.14/genirq-fix-race-in-register_irq_proc.patch @@ -0,0 +1,76 @@ +From 95c2b17534654829db428f11bcf4297c059a2a7e Mon Sep 17 00:00:00 2001 +From: Ben Hutchings +Date: Sat, 26 Sep 2015 12:23:56 +0100 +Subject: genirq: Fix race in register_irq_proc() + +From: Ben Hutchings + +commit 95c2b17534654829db428f11bcf4297c059a2a7e upstream. + +Per-IRQ directories in procfs are created only when a handler is first +added to the irqdesc, not when the irqdesc is created. In the case of +a shared IRQ, multiple tasks can race to create a directory. This +race condition seems to have been present forever, but is easier to +hit with async probing. + +Signed-off-by: Ben Hutchings +Link: http://lkml.kernel.org/r/1443266636.2004.2.camel@decadent.org.uk +Signed-off-by: Thomas Gleixner +Signed-off-by: Greg Kroah-Hartman + +--- + kernel/irq/proc.c | 19 +++++++++++++++++-- + 1 file changed, 17 insertions(+), 2 deletions(-) + +--- a/kernel/irq/proc.c ++++ b/kernel/irq/proc.c +@@ -12,6 +12,7 @@ + #include + #include + #include ++#include + + #include "internals.h" + +@@ -326,18 +327,29 @@ void register_handler_proc(unsigned int + + void register_irq_proc(unsigned int irq, struct irq_desc *desc) + { ++ static DEFINE_MUTEX(register_lock); + char name [MAX_NAMELEN]; + +- if (!root_irq_dir || (desc->irq_data.chip == &no_irq_chip) || desc->dir) ++ if (!root_irq_dir || (desc->irq_data.chip == &no_irq_chip)) + return; + ++ /* ++ * irq directories are registered only when a handler is ++ * added, not when the descriptor is created, so multiple ++ * tasks might try to register at the same time. ++ */ ++ mutex_lock(®ister_lock); ++ ++ if (desc->dir) ++ goto out_unlock; ++ + memset(name, 0, MAX_NAMELEN); + sprintf(name, "%d", irq); + + /* create /proc/irq/1234 */ + desc->dir = proc_mkdir(name, root_irq_dir); + if (!desc->dir) +- return; ++ goto out_unlock; + + #ifdef CONFIG_SMP + /* create /proc/irq//smp_affinity */ +@@ -358,6 +370,9 @@ void register_irq_proc(unsigned int irq, + + proc_create_data("spurious", 0444, desc->dir, + &irq_spurious_proc_fops, (void *)(long)irq); ++ ++out_unlock: ++ mutex_unlock(®ister_lock); + } + + void unregister_irq_proc(unsigned int irq, struct irq_desc *desc) diff --git a/queue-3.14/jbd2-avoid-infinite-loop-when-destroying-aborted-journal.patch b/queue-3.14/jbd2-avoid-infinite-loop-when-destroying-aborted-journal.patch new file mode 100644 index 00000000000..2ff685e486f --- /dev/null +++ b/queue-3.14/jbd2-avoid-infinite-loop-when-destroying-aborted-journal.patch @@ -0,0 +1,174 @@ +From 841df7df196237ea63233f0f9eaa41db53afd70f Mon Sep 17 00:00:00 2001 +From: Jan Kara +Date: Tue, 28 Jul 2015 14:57:14 -0400 +Subject: jbd2: avoid infinite loop when destroying aborted journal + +From: Jan Kara + +commit 841df7df196237ea63233f0f9eaa41db53afd70f upstream. + +Commit 6f6a6fda2945 "jbd2: fix ocfs2 corrupt when updating journal +superblock fails" changed jbd2_cleanup_journal_tail() to return EIO +when the journal is aborted. That makes logic in +jbd2_log_do_checkpoint() bail out which is fine, except that +jbd2_journal_destroy() expects jbd2_log_do_checkpoint() to always make +a progress in cleaning the journal. Without it jbd2_journal_destroy() +just loops in an infinite loop. + +Fix jbd2_journal_destroy() to cleanup journal checkpoint lists of +jbd2_log_do_checkpoint() fails with error. + +Reported-by: Eryu Guan +Tested-by: Eryu Guan +Fixes: 6f6a6fda294506dfe0e3e0a253bb2d2923f28f0a +Signed-off-by: Jan Kara +Signed-off-by: Theodore Ts'o +Signed-off-by: Greg Kroah-Hartman + +--- + fs/jbd2/checkpoint.c | 39 +++++++++++++++++++++++++++++++++------ + fs/jbd2/commit.c | 2 +- + fs/jbd2/journal.c | 11 ++++++++++- + include/linux/jbd2.h | 3 ++- + 4 files changed, 46 insertions(+), 9 deletions(-) + +--- a/fs/jbd2/checkpoint.c ++++ b/fs/jbd2/checkpoint.c +@@ -475,14 +475,15 @@ int jbd2_cleanup_journal_tail(journal_t + * journal_clean_one_cp_list + * + * Find all the written-back checkpoint buffers in the given list and +- * release them. ++ * release them. If 'destroy' is set, clean all buffers unconditionally. + * + * Called with the journal locked. + * Called with j_list_lock held. + * Returns number of buffers reaped (for debug) + */ + +-static int journal_clean_one_cp_list(struct journal_head *jh, int *released) ++static int journal_clean_one_cp_list(struct journal_head *jh, bool destroy, ++ int *released) + { + struct journal_head *last_jh; + struct journal_head *next_jh = jh; +@@ -496,7 +497,10 @@ static int journal_clean_one_cp_list(str + do { + jh = next_jh; + next_jh = jh->b_cpnext; +- ret = __try_to_free_cp_buf(jh); ++ if (!destroy) ++ ret = __try_to_free_cp_buf(jh); ++ else ++ ret = __jbd2_journal_remove_checkpoint(jh) + 1; + if (ret) { + freed++; + if (ret == 2) { +@@ -521,13 +525,14 @@ static int journal_clean_one_cp_list(str + * journal_clean_checkpoint_list + * + * Find all the written-back checkpoint buffers in the journal and release them. ++ * If 'destroy' is set, release all buffers unconditionally. + * + * Called with the journal locked. + * Called with j_list_lock held. + * Returns number of buffers reaped (for debug) + */ + +-int __jbd2_journal_clean_checkpoint_list(journal_t *journal) ++int __jbd2_journal_clean_checkpoint_list(journal_t *journal, bool destroy) + { + transaction_t *transaction, *last_transaction, *next_transaction; + int ret = 0; +@@ -543,7 +548,7 @@ int __jbd2_journal_clean_checkpoint_list + transaction = next_transaction; + next_transaction = transaction->t_cpnext; + ret += journal_clean_one_cp_list(transaction-> +- t_checkpoint_list, &released); ++ t_checkpoint_list, destroy, &released); + /* + * This function only frees up some memory if possible so we + * dont have an obligation to finish processing. Bail out if +@@ -559,7 +564,7 @@ int __jbd2_journal_clean_checkpoint_list + * we can possibly see not yet submitted buffers on io_list + */ + ret += journal_clean_one_cp_list(transaction-> +- t_checkpoint_io_list, &released); ++ t_checkpoint_io_list, destroy, &released); + if (need_resched()) + goto out; + } while (transaction != last_transaction); +@@ -568,6 +573,28 @@ out: + } + + /* ++ * Remove buffers from all checkpoint lists as journal is aborted and we just ++ * need to free memory ++ */ ++void jbd2_journal_destroy_checkpoint(journal_t *journal) ++{ ++ /* ++ * We loop because __jbd2_journal_clean_checkpoint_list() may abort ++ * early due to a need of rescheduling. ++ */ ++ while (1) { ++ spin_lock(&journal->j_list_lock); ++ if (!journal->j_checkpoint_transactions) { ++ spin_unlock(&journal->j_list_lock); ++ break; ++ } ++ __jbd2_journal_clean_checkpoint_list(journal, true); ++ spin_unlock(&journal->j_list_lock); ++ cond_resched(); ++ } ++} ++ ++/* + * journal_remove_checkpoint: called after a buffer has been committed + * to disk (either by being write-back flushed to disk, or being + * committed to the log). +--- a/fs/jbd2/commit.c ++++ b/fs/jbd2/commit.c +@@ -510,7 +510,7 @@ void jbd2_journal_commit_transaction(jou + * frees some memory + */ + spin_lock(&journal->j_list_lock); +- __jbd2_journal_clean_checkpoint_list(journal); ++ __jbd2_journal_clean_checkpoint_list(journal, false); + spin_unlock(&journal->j_list_lock); + + jbd_debug(3, "JBD2: commit phase 1\n"); +--- a/fs/jbd2/journal.c ++++ b/fs/jbd2/journal.c +@@ -1708,8 +1708,17 @@ int jbd2_journal_destroy(journal_t *jour + while (journal->j_checkpoint_transactions != NULL) { + spin_unlock(&journal->j_list_lock); + mutex_lock(&journal->j_checkpoint_mutex); +- jbd2_log_do_checkpoint(journal); ++ err = jbd2_log_do_checkpoint(journal); + mutex_unlock(&journal->j_checkpoint_mutex); ++ /* ++ * If checkpointing failed, just free the buffers to avoid ++ * looping forever ++ */ ++ if (err) { ++ jbd2_journal_destroy_checkpoint(journal); ++ spin_lock(&journal->j_list_lock); ++ break; ++ } + spin_lock(&journal->j_list_lock); + } + +--- a/include/linux/jbd2.h ++++ b/include/linux/jbd2.h +@@ -1042,8 +1042,9 @@ void jbd2_update_log_tail(journal_t *jou + extern void jbd2_journal_commit_transaction(journal_t *); + + /* Checkpoint list management */ +-int __jbd2_journal_clean_checkpoint_list(journal_t *journal); ++int __jbd2_journal_clean_checkpoint_list(journal_t *journal, bool destroy); + int __jbd2_journal_remove_checkpoint(struct journal_head *); ++void jbd2_journal_destroy_checkpoint(journal_t *journal); + void __jbd2_journal_insert_checkpoint(struct journal_head *, transaction_t *); + + diff --git a/queue-3.14/m68k-define-asmlinkage_protect.patch b/queue-3.14/m68k-define-asmlinkage_protect.patch new file mode 100644 index 00000000000..e284c30de41 --- /dev/null +++ b/queue-3.14/m68k-define-asmlinkage_protect.patch @@ -0,0 +1,70 @@ +From 8474ba74193d302e8340dddd1e16c85cc4b98caf Mon Sep 17 00:00:00 2001 +From: Andreas Schwab +Date: Wed, 23 Sep 2015 23:12:09 +0200 +Subject: m68k: Define asmlinkage_protect + +From: Andreas Schwab + +commit 8474ba74193d302e8340dddd1e16c85cc4b98caf upstream. + +Make sure the compiler does not modify arguments of syscall functions. +This can happen if the compiler generates a tailcall to another +function. For example, without asmlinkage_protect sys_openat is compiled +into this function: + +sys_openat: + clr.l %d0 + move.w 18(%sp),%d0 + move.l %d0,16(%sp) + jbra do_sys_open + +Note how the fourth argument is modified in place, modifying the register +%d4 that gets restored from this stack slot when the function returns to +user-space. The caller may expect the register to be unmodified across +system calls. + +Signed-off-by: Andreas Schwab +Signed-off-by: Geert Uytterhoeven +Signed-off-by: Greg Kroah-Hartman + +--- + arch/m68k/include/asm/linkage.h | 30 ++++++++++++++++++++++++++++++ + 1 file changed, 30 insertions(+) + +--- a/arch/m68k/include/asm/linkage.h ++++ b/arch/m68k/include/asm/linkage.h +@@ -4,4 +4,34 @@ + #define __ALIGN .align 4 + #define __ALIGN_STR ".align 4" + ++/* ++ * Make sure the compiler doesn't do anything stupid with the ++ * arguments on the stack - they are owned by the *caller*, not ++ * the callee. This just fools gcc into not spilling into them, ++ * and keeps it from doing tailcall recursion and/or using the ++ * stack slots for temporaries, since they are live and "used" ++ * all the way to the end of the function. ++ */ ++#define asmlinkage_protect(n, ret, args...) \ ++ __asmlinkage_protect##n(ret, ##args) ++#define __asmlinkage_protect_n(ret, args...) \ ++ __asm__ __volatile__ ("" : "=r" (ret) : "0" (ret), ##args) ++#define __asmlinkage_protect0(ret) \ ++ __asmlinkage_protect_n(ret) ++#define __asmlinkage_protect1(ret, arg1) \ ++ __asmlinkage_protect_n(ret, "m" (arg1)) ++#define __asmlinkage_protect2(ret, arg1, arg2) \ ++ __asmlinkage_protect_n(ret, "m" (arg1), "m" (arg2)) ++#define __asmlinkage_protect3(ret, arg1, arg2, arg3) \ ++ __asmlinkage_protect_n(ret, "m" (arg1), "m" (arg2), "m" (arg3)) ++#define __asmlinkage_protect4(ret, arg1, arg2, arg3, arg4) \ ++ __asmlinkage_protect_n(ret, "m" (arg1), "m" (arg2), "m" (arg3), \ ++ "m" (arg4)) ++#define __asmlinkage_protect5(ret, arg1, arg2, arg3, arg4, arg5) \ ++ __asmlinkage_protect_n(ret, "m" (arg1), "m" (arg2), "m" (arg3), \ ++ "m" (arg4), "m" (arg5)) ++#define __asmlinkage_protect6(ret, arg1, arg2, arg3, arg4, arg5, arg6) \ ++ __asmlinkage_protect_n(ret, "m" (arg1), "m" (arg2), "m" (arg3), \ ++ "m" (arg4), "m" (arg5), "m" (arg6)) ++ + #endif diff --git a/queue-3.14/series b/queue-3.14/series index 5286a987771..9a23795044c 100644 --- a/queue-3.14/series +++ b/queue-3.14/series @@ -67,3 +67,11 @@ ubi-validate-data_size.patch ubi-return-enospc-if-no-enough-space-available.patch dcache-handle-escaped-paths-in-prepend_path.patch vfs-test-for-and-handle-paths-that-are-unreachable-from-their-mnt_root.patch +arm64-readahead-fault-retry-breaks-mmap-file-read-random-detection.patch +m68k-define-asmlinkage_protect.patch +fib_rules-fix-dump_rules-not-to-exit-early.patch +genirq-fix-race-in-register_irq_proc.patch +jbd2-avoid-infinite-loop-when-destroying-aborted-journal.patch +clk-ti-fix-dual-registration-of-uart4_ick.patch +dm-cache-fix-null-pointer-when-switching-from-cleaner-policy.patch +staging-speakup-fix-speakup-r-regression.patch diff --git a/queue-3.14/staging-speakup-fix-speakup-r-regression.patch b/queue-3.14/staging-speakup-fix-speakup-r-regression.patch new file mode 100644 index 00000000000..52590cb859b --- /dev/null +++ b/queue-3.14/staging-speakup-fix-speakup-r-regression.patch @@ -0,0 +1,37 @@ +From b1d562acc78f0af46de0dfe447410bc40bdb7ece Mon Sep 17 00:00:00 2001 +From: "covici@ccs.covici.com" +Date: Wed, 20 May 2015 05:44:11 -0400 +Subject: staging: speakup: fix speakup-r regression + +From: "covici@ccs.covici.com" + +commit b1d562acc78f0af46de0dfe447410bc40bdb7ece upstream. + +Here is a patch to make speakup-r work again. + +It broke in 3.6 due to commit 4369c64c79a22b98d3b7eff9d089196cd878a10a +"Input: Send events one packet at a time) + +The problem was that the fakekey.c routine to fake a down arrow no +longer functioned properly and putting the input_sync fixed it. + +Fixes: 4369c64c79a22b98d3b7eff9d089196cd878a10a +Acked-by: Samuel Thibault +Signed-off-by: John Covici +Signed-off-by: Greg Kroah-Hartman +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/staging/speakup/fakekey.c | 1 + + 1 file changed, 1 insertion(+) + +--- a/drivers/staging/speakup/fakekey.c ++++ b/drivers/staging/speakup/fakekey.c +@@ -81,6 +81,7 @@ void speakup_fake_down_arrow(void) + __this_cpu_write(reporting_keystroke, true); + input_report_key(virt_keyboard, KEY_DOWN, PRESSED); + input_report_key(virt_keyboard, KEY_DOWN, RELEASED); ++ input_sync(virt_keyboard); + __this_cpu_write(reporting_keystroke, false); + + /* reenable preemption */ -- 2.47.3