9 files changed, 224 insertions, 296 deletions

diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 64155e310a9f..00eeff94b357 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -165,7 +165,7 @@ config DEBUG_INFO_REDUCED
 
 config DEBUG_INFO_SPLIT
         bool "Produce split debuginfo in .dwo files"
-        depends on DEBUG_INFO && !FRV
+        depends on DEBUG_INFO
         help
           Generate debug info into separate .dwo files. This significantly
           reduces the build directory size for builds with DEBUG_INFO,
@@ -354,10 +354,7 @@ config ARCH_WANT_FRAME_POINTERS
 
 config FRAME_POINTER
         bool "Compile the kernel with frame pointers"
-        depends on DEBUG_KERNEL && \
-                (CRIS || M68K || FRV || UML || \
-                 SUPERH || BLACKFIN || MN10300 || METAG) || \
-                ARCH_WANT_FRAME_POINTERS
+        depends on DEBUG_KERNEL && (M68K || UML || SUPERH) || ARCH_WANT_FRAME_POINTERS
         default y if (DEBUG_INFO && UML) || ARCH_WANT_FRAME_POINTERS
         help
           If you say Y here the resulting kernel image will be slightly
@@ -1034,69 +1031,20 @@ config DEBUG_PREEMPT
 
 menu "Lock Debugging (spinlocks, mutexes, etc...)"
 
-config DEBUG_RT_MUTEXES
-        bool "RT Mutex debugging, deadlock detection"
-        depends on DEBUG_KERNEL && RT_MUTEXES
-        help
-         This allows rt mutex semantics violations and rt mutex related
-         deadlocks (lockups) to be detected and reported automatically.
-
-config DEBUG_SPINLOCK
-        bool "Spinlock and rw-lock debugging: basic checks"
-        depends on DEBUG_KERNEL
-        select UNINLINE_SPIN_UNLOCK
-        help
-          Say Y here and build SMP to catch missing spinlock initialization
-          and certain other kinds of spinlock errors commonly made.  This is
-          best used in conjunction with the NMI watchdog so that spinlock
-          deadlocks are also debuggable.
-
-config DEBUG_MUTEXES
-        bool "Mutex debugging: basic checks"
-        depends on DEBUG_KERNEL
-        help
-         This feature allows mutex semantics violations to be detected and
-         reported.
-
-config DEBUG_WW_MUTEX_SLOWPATH
-        bool "Wait/wound mutex debugging: Slowpath testing"
-        depends on DEBUG_KERNEL && TRACE_IRQFLAGS_SUPPORT && STACKTRACE_SUPPORT && LOCKDEP_SUPPORT
-        select DEBUG_LOCK_ALLOC
-        select DEBUG_SPINLOCK
-        select DEBUG_MUTEXES
-        help
-         This feature enables slowpath testing for w/w mutex users by
-         injecting additional -EDEADLK wound/backoff cases. Together with
-         the full mutex checks enabled with (CONFIG_PROVE_LOCKING) this
-         will test all possible w/w mutex interface abuse with the
-         exception of simply not acquiring all the required locks.
-         Note that this feature can introduce significant overhead, so
-         it really should not be enabled in a production or distro kernel,
-         even a debug kernel.  If you are a driver writer, enable it.  If
-         you are a distro, do not.
-
-config DEBUG_LOCK_ALLOC
-        bool "Lock debugging: detect incorrect freeing of live locks"
-        depends on DEBUG_KERNEL && TRACE_IRQFLAGS_SUPPORT && STACKTRACE_SUPPORT && LOCKDEP_SUPPORT
-        select DEBUG_SPINLOCK
-        select DEBUG_MUTEXES
-        select DEBUG_RT_MUTEXES if RT_MUTEXES
-        select LOCKDEP
-        help
-         This feature will check whether any held lock (spinlock, rwlock,
-         mutex or rwsem) is incorrectly freed by the kernel, via any of the
-         memory-freeing routines (kfree(), kmem_cache_free(), free_pages(),
-         vfree(), etc.), whether a live lock is incorrectly reinitialized via
-         spin_lock_init()/mutex_init()/etc., or whether there is any lock
-         held during task exit.
+config LOCK_DEBUGGING_SUPPORT
+        bool
+        depends on TRACE_IRQFLAGS_SUPPORT && STACKTRACE_SUPPORT && LOCKDEP_SUPPORT
+        default y
 
 config PROVE_LOCKING
         bool "Lock debugging: prove locking correctness"
-        depends on DEBUG_KERNEL && TRACE_IRQFLAGS_SUPPORT && STACKTRACE_SUPPORT && LOCKDEP_SUPPORT
+        depends on DEBUG_KERNEL && LOCK_DEBUGGING_SUPPORT
         select LOCKDEP
         select DEBUG_SPINLOCK
         select DEBUG_MUTEXES
         select DEBUG_RT_MUTEXES if RT_MUTEXES
+        select DEBUG_RWSEMS if RWSEM_SPIN_ON_OWNER
+        select DEBUG_WW_MUTEX_SLOWPATH
         select DEBUG_LOCK_ALLOC
         select TRACE_IRQFLAGS
         default n
@@ -1134,20 +1082,9 @@ config PROVE_LOCKING
 
          For more details, see Documentation/locking/lockdep-design.txt.
 
-config LOCKDEP
-        bool
-        depends on DEBUG_KERNEL && TRACE_IRQFLAGS_SUPPORT && STACKTRACE_SUPPORT && LOCKDEP_SUPPORT
-        select STACKTRACE
-        select FRAME_POINTER if !MIPS && !PPC && !ARM_UNWIND && !S390 && !MICROBLAZE && !ARC && !SCORE && !X86
-        select KALLSYMS
-        select KALLSYMS_ALL
-
-config LOCKDEP_SMALL
-        bool
-
 config LOCK_STAT
         bool "Lock usage statistics"
-        depends on DEBUG_KERNEL && TRACE_IRQFLAGS_SUPPORT && STACKTRACE_SUPPORT && LOCKDEP_SUPPORT
+        depends on DEBUG_KERNEL && LOCK_DEBUGGING_SUPPORT
         select LOCKDEP
         select DEBUG_SPINLOCK
         select DEBUG_MUTEXES
@@ -1167,6 +1104,80 @@ config LOCK_STAT
          CONFIG_LOCK_STAT defines "contended" and "acquired" lock events.
          (CONFIG_LOCKDEP defines "acquire" and "release" events.)
 
+config DEBUG_RT_MUTEXES
+        bool "RT Mutex debugging, deadlock detection"
+        depends on DEBUG_KERNEL && RT_MUTEXES
+        help
+         This allows rt mutex semantics violations and rt mutex related
+         deadlocks (lockups) to be detected and reported automatically.
+
+config DEBUG_SPINLOCK
+        bool "Spinlock and rw-lock debugging: basic checks"
+        depends on DEBUG_KERNEL
+        select UNINLINE_SPIN_UNLOCK
+        help
+          Say Y here and build SMP to catch missing spinlock initialization
+          and certain other kinds of spinlock errors commonly made.  This is
+          best used in conjunction with the NMI watchdog so that spinlock
+          deadlocks are also debuggable.
+
+config DEBUG_MUTEXES
+        bool "Mutex debugging: basic checks"
+        depends on DEBUG_KERNEL
+        help
+         This feature allows mutex semantics violations to be detected and
+         reported.
+
+config DEBUG_WW_MUTEX_SLOWPATH
+        bool "Wait/wound mutex debugging: Slowpath testing"
+        depends on DEBUG_KERNEL && LOCK_DEBUGGING_SUPPORT
+        select DEBUG_LOCK_ALLOC
+        select DEBUG_SPINLOCK
+        select DEBUG_MUTEXES
+        help
+         This feature enables slowpath testing for w/w mutex users by
+         injecting additional -EDEADLK wound/backoff cases. Together with
+         the full mutex checks enabled with (CONFIG_PROVE_LOCKING) this
+         will test all possible w/w mutex interface abuse with the
+         exception of simply not acquiring all the required locks.
+         Note that this feature can introduce significant overhead, so
+         it really should not be enabled in a production or distro kernel,
+         even a debug kernel.  If you are a driver writer, enable it.  If
+         you are a distro, do not.
+
+config DEBUG_RWSEMS
+        bool "RW Semaphore debugging: basic checks"
+        depends on DEBUG_KERNEL && RWSEM_SPIN_ON_OWNER
+        help
+          This debugging feature allows mismatched rw semaphore locks and unlocks
+          to be detected and reported.
+
+config DEBUG_LOCK_ALLOC
+        bool "Lock debugging: detect incorrect freeing of live locks"
+        depends on DEBUG_KERNEL && LOCK_DEBUGGING_SUPPORT
+        select DEBUG_SPINLOCK
+        select DEBUG_MUTEXES
+        select DEBUG_RT_MUTEXES if RT_MUTEXES
+        select LOCKDEP
+        help
+         This feature will check whether any held lock (spinlock, rwlock,
+         mutex or rwsem) is incorrectly freed by the kernel, via any of the
+         memory-freeing routines (kfree(), kmem_cache_free(), free_pages(),
+         vfree(), etc.), whether a live lock is incorrectly reinitialized via
+         spin_lock_init()/mutex_init()/etc., or whether there is any lock
+         held during task exit.
+
+config LOCKDEP
+        bool
+        depends on DEBUG_KERNEL && LOCK_DEBUGGING_SUPPORT
+        select STACKTRACE
+        select FRAME_POINTER if !MIPS && !PPC && !ARM_UNWIND && !S390 && !MICROBLAZE && !ARC && !X86
+        select KALLSYMS
+        select KALLSYMS_ALL
+
+config LOCKDEP_SMALL
+        bool
+
 config DEBUG_LOCKDEP
         bool "Lock dependency engine debugging"
         depends on DEBUG_KERNEL && LOCKDEP
@@ -1571,7 +1582,7 @@ config FAULT_INJECTION_STACKTRACE_FILTER
         depends on FAULT_INJECTION_DEBUG_FS && STACKTRACE_SUPPORT
         depends on !X86_64
         select STACKTRACE
-        select FRAME_POINTER if !MIPS && !PPC && !S390 && !MICROBLAZE && !ARM_UNWIND && !ARC && !SCORE && !X86
+        select FRAME_POINTER if !MIPS && !PPC && !S390 && !MICROBLAZE && !ARM_UNWIND && !ARC && !X86
         help
           Provide stacktrace filter for fault-injection capabilities
 
@@ -1969,7 +1980,7 @@ config STRICT_DEVMEM
         bool "Filter access to /dev/mem"
         depends on MMU && DEVMEM
         depends on ARCH_HAS_DEVMEM_IS_ALLOWED
-        default y if TILE || PPC || X86 || ARM64
+        default y if PPC || X86 || ARM64
         ---help---
           If this option is disabled, you allow userspace (root) access to all
           of memory, including kernel and userspace memory. Accidental
diff --git a/lib/debugobjects.c b/lib/debugobjects.c
index 2f5349c6e81a..994be4805cec 100644
--- a/lib/debugobjects.c
+++ b/lib/debugobjects.c
@@ -42,14 +42,18 @@ static struct debug_obj		obj_static_pool[ODEBUG_POOL_SIZE] __initdata;
 static DEFINE_RAW_SPINLOCK(pool_lock);
 
 static HLIST_HEAD(obj_pool);
+static HLIST_HEAD(obj_to_free);
 
 static int                      obj_pool_min_free = ODEBUG_POOL_SIZE;
 static int                      obj_pool_free = ODEBUG_POOL_SIZE;
 static int                      obj_pool_used;
 static int                      obj_pool_max_used;
+/* The number of objs on the global free list */
+static int                      obj_nr_tofree;
 static struct kmem_cache        *obj_cache;
 
 static int                      debug_objects_maxchain __read_mostly;
+static int __maybe_unused       debug_objects_maxchecked __read_mostly;
 static int                      debug_objects_fixups __read_mostly;
 static int                      debug_objects_warnings __read_mostly;
 static int                      debug_objects_enabled __read_mostly
@@ -96,12 +100,32 @@ static const char *obj_states[ODEBUG_STATE_MAX] = {
 static void fill_pool(void)
 {
         gfp_t gfp = GFP_ATOMIC | __GFP_NORETRY | __GFP_NOWARN;
-        struct debug_obj *new;
+        struct debug_obj *new, *obj;
         unsigned long flags;
 
         if (likely(obj_pool_free >= debug_objects_pool_min_level))
                 return;
 
+        /*
+         * Reuse objs from the global free list; they will be reinitialized
+         * when allocating.
+         */
+        while (obj_nr_tofree && (obj_pool_free < obj_pool_min_free)) {
+                raw_spin_lock_irqsave(&pool_lock, flags);
+                /*
+                 * Recheck with the lock held as the worker thread might have
+                 * won the race and freed the global free list already.
+                 */
+                if (obj_nr_tofree) {
+                        obj = hlist_entry(obj_to_free.first, typeof(*obj), node);
+                        hlist_del(&obj->node);
+                        obj_nr_tofree--;
+                        hlist_add_head(&obj->node, &obj_pool);
+                        obj_pool_free++;
+                }
+                raw_spin_unlock_irqrestore(&pool_lock, flags);
+        }
+
         if (unlikely(!obj_cache))
                 return;
 
@@ -177,62 +201,76 @@ alloc_object(void *addr, struct debug_bucket *b, struct debug_obj_descr *descr)
  * workqueue function to free objects.
  *
  * To reduce contention on the global pool_lock, the actual freeing of
- * debug objects will be delayed if the pool_lock is busy. We also free
- * the objects in a batch of 4 for each lock/unlock cycle.
+ * debug objects will be delayed if the pool_lock is busy.
  */
-#define ODEBUG_FREE_BATCH       4
-
 static void free_obj_work(struct work_struct *work)
 {
-        struct debug_obj *objs[ODEBUG_FREE_BATCH];
+        struct hlist_node *tmp;
+        struct debug_obj *obj;
         unsigned long flags;
-        int i;
+        HLIST_HEAD(tofree);
 
         if (!raw_spin_trylock_irqsave(&pool_lock, flags))
                 return;
-        while (obj_pool_free >= debug_objects_pool_size + ODEBUG_FREE_BATCH) {
-                for (i = 0; i < ODEBUG_FREE_BATCH; i++) {
-                        objs[i] = hlist_entry(obj_pool.first,
-                                              typeof(*objs[0]), node);
-                        hlist_del(&objs[i]->node);
-                }
 
-                obj_pool_free -= ODEBUG_FREE_BATCH;
-                debug_objects_freed += ODEBUG_FREE_BATCH;
-                /*
-                 * We release pool_lock across kmem_cache_free() to
-                 * avoid contention on pool_lock.
-                 */
-                raw_spin_unlock_irqrestore(&pool_lock, flags);
-                for (i = 0; i < ODEBUG_FREE_BATCH; i++)
-                        kmem_cache_free(obj_cache, objs[i]);
-                if (!raw_spin_trylock_irqsave(&pool_lock, flags))
-                        return;
+        /*
+         * The objs on the pool list might be allocated before the work is
+         * run, so recheck if pool list it full or not, if not fill pool
+         * list from the global free list
+         */
+        while (obj_nr_tofree && obj_pool_free < debug_objects_pool_size) {
+                obj = hlist_entry(obj_to_free.first, typeof(*obj), node);
+                hlist_del(&obj->node);
+                hlist_add_head(&obj->node, &obj_pool);
+                obj_pool_free++;
+                obj_nr_tofree--;
+        }
+
+        /*
+         * Pool list is already full and there are still objs on the free
+         * list. Move remaining free objs to a temporary list to free the
+         * memory outside the pool_lock held region.
+         */
+        if (obj_nr_tofree) {
+                hlist_move_list(&obj_to_free, &tofree);
+                debug_objects_freed += obj_nr_tofree;
+                obj_nr_tofree = 0;
         }
         raw_spin_unlock_irqrestore(&pool_lock, flags);
+
+        hlist_for_each_entry_safe(obj, tmp, &tofree, node) {
+                hlist_del(&obj->node);
+                kmem_cache_free(obj_cache, obj);
+        }
 }
 
-/*
- * Put the object back into the pool and schedule work to free objects
- * if necessary.
- */
-static void free_object(struct debug_obj *obj)
+static bool __free_object(struct debug_obj *obj)
 {
         unsigned long flags;
-        int sched = 0;
+        bool work;
 
         raw_spin_lock_irqsave(&pool_lock, flags);
-        /*
-         * schedule work when the pool is filled and the cache is
-         * initialized:
-         */
-        if (obj_pool_free > debug_objects_pool_size && obj_cache)
-                sched = 1;
-        hlist_add_head(&obj->node, &obj_pool);
-        obj_pool_free++;
+        work = (obj_pool_free > debug_objects_pool_size) && obj_cache;
         obj_pool_used--;
+
+        if (work) {
+                obj_nr_tofree++;
+                hlist_add_head(&obj->node, &obj_to_free);
+        } else {
+                obj_pool_free++;
+                hlist_add_head(&obj->node, &obj_pool);
+        }
         raw_spin_unlock_irqrestore(&pool_lock, flags);
-        if (sched)
+        return work;
+}
+
+/*
+ * Put the object back into the pool and schedule work to free objects
+ * if necessary.
+ */
+static void free_object(struct debug_obj *obj)
+{
+        if (__free_object(obj))
                 schedule_work(&debug_obj_work);
 }
 
@@ -714,13 +752,13 @@ EXPORT_SYMBOL_GPL(debug_object_active_state);
 static void __debug_check_no_obj_freed(const void *address, unsigned long size)
 {
         unsigned long flags, oaddr, saddr, eaddr, paddr, chunks;
-        struct hlist_node *tmp;
-        HLIST_HEAD(freelist);
         struct debug_obj_descr *descr;
         enum debug_obj_state state;
         struct debug_bucket *db;
+        struct hlist_node *tmp;
         struct debug_obj *obj;
-        int cnt;
+        int cnt, objs_checked = 0;
+        bool work = false;
 
         saddr = (unsigned long) address;
         eaddr = saddr + size;
@@ -751,21 +789,24 @@ repeat:
                                 goto repeat;
                         default:
                                 hlist_del(&obj->node);
-                                hlist_add_head(&obj->node, &freelist);
+                                work |= __free_object(obj);
                                 break;
                         }
                 }
                 raw_spin_unlock_irqrestore(&db->lock, flags);
 
-                /* Now free them */
-                hlist_for_each_entry_safe(obj, tmp, &freelist, node) {
-                        hlist_del(&obj->node);
-                        free_object(obj);
-                }
-
                 if (cnt > debug_objects_maxchain)
                         debug_objects_maxchain = cnt;
+
+                objs_checked += cnt;
         }
+
+        if (objs_checked > debug_objects_maxchecked)
+                debug_objects_maxchecked = objs_checked;
+
+        /* Schedule work to actually kmem_cache_free() objects */
+        if (work)
+                schedule_work(&debug_obj_work);
 }
 
 void debug_check_no_obj_freed(const void *address, unsigned long size)
@@ -780,12 +821,14 @@ void debug_check_no_obj_freed(const void *address, unsigned long size)
 static int debug_stats_show(struct seq_file *m, void *v)
 {
         seq_printf(m, "max_chain     :%d\n", debug_objects_maxchain);
+        seq_printf(m, "max_checked   :%d\n", debug_objects_maxchecked);
         seq_printf(m, "warnings      :%d\n", debug_objects_warnings);
         seq_printf(m, "fixups        :%d\n", debug_objects_fixups);
         seq_printf(m, "pool_free     :%d\n", obj_pool_free);
         seq_printf(m, "pool_min_free :%d\n", obj_pool_min_free);
         seq_printf(m, "pool_used     :%d\n", obj_pool_used);
         seq_printf(m, "pool_max_used :%d\n", obj_pool_max_used);
+        seq_printf(m, "on_free_list  :%d\n", obj_nr_tofree);
         seq_printf(m, "objs_allocated:%d\n", debug_objects_allocated);
         seq_printf(m, "objs_freed    :%d\n", debug_objects_freed);
         return 0;
diff --git a/lib/dma-direct.c b/lib/dma-direct.c
index c9e8e21cb334..c0bba30fef0a 100644
--- a/lib/dma-direct.c
+++ b/lib/dma-direct.c
@@ -9,6 +9,7 @@
 #include <linux/scatterlist.h>
 #include <linux/dma-contiguous.h>
 #include <linux/pfn.h>
+#include <linux/set_memory.h>
 
 #define DIRECT_MAPPING_ERROR            0
 
@@ -20,6 +21,14 @@
 #define ARCH_ZONE_DMA_BITS 24
 #endif
 
+/*
+ * For AMD SEV all DMA must be to unencrypted addresses.
+ */
+static inline bool force_dma_unencrypted(void)
+{
+        return sev_active();
+}
+
 static bool
 check_addr(struct device *dev, dma_addr_t dma_addr, size_t size,
                 const char *caller)
@@ -37,7 +46,9 @@ check_addr(struct device *dev, dma_addr_t dma_addr, size_t size,
 
 static bool dma_coherent_ok(struct device *dev, phys_addr_t phys, size_t size)
 {
-        return phys_to_dma(dev, phys) + size - 1 <= dev->coherent_dma_mask;
+        dma_addr_t addr = force_dma_unencrypted() ?
+                __phys_to_dma(dev, phys) : phys_to_dma(dev, phys);
+        return addr + size - 1 <= dev->coherent_dma_mask;
 }
 
 void *dma_direct_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,
@@ -46,6 +57,10 @@ void *dma_direct_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,
         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
         int page_order = get_order(size);
         struct page *page = NULL;
+        void *ret;
+
+        /* we always manually zero the memory once we are done: */
+        gfp &= ~__GFP_ZERO;
 
         /* GFP_DMA32 and GFP_DMA are no ops without the corresponding zones: */
         if (dev->coherent_dma_mask <= DMA_BIT_MASK(ARCH_ZONE_DMA_BITS))
@@ -78,10 +93,15 @@ again:
 
         if (!page)
                 return NULL;
-
-        *dma_handle = phys_to_dma(dev, page_to_phys(page));
-        memset(page_address(page), 0, size);
-        return page_address(page);
+        ret = page_address(page);
+        if (force_dma_unencrypted()) {
+                set_memory_decrypted((unsigned long)ret, 1 << page_order);
+                *dma_handle = __phys_to_dma(dev, page_to_phys(page));
+        } else {
+                *dma_handle = phys_to_dma(dev, page_to_phys(page));
+        }
+        memset(ret, 0, size);
+        return ret;
 }
 
 /*
@@ -92,9 +112,12 @@ void dma_direct_free(struct device *dev, size_t size, void *cpu_addr,
                 dma_addr_t dma_addr, unsigned long attrs)
 {
         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
+        unsigned int page_order = get_order(size);
 
+        if (force_dma_unencrypted())
+                set_memory_encrypted((unsigned long)cpu_addr, 1 << page_order);
         if (!dma_release_from_contiguous(dev, virt_to_page(cpu_addr), count))
-                free_pages((unsigned long)cpu_addr, get_order(size));
+                free_pages((unsigned long)cpu_addr, page_order);
 }
 
 static dma_addr_t dma_direct_map_page(struct device *dev, struct page *page,
diff --git a/lib/raid6/Makefile b/lib/raid6/Makefile
index 4add700ddfe3..44d6b46df051 100644
--- a/lib/raid6/Makefile
+++ b/lib/raid6/Makefile
@@ -7,7 +7,6 @@ raid6_pq-y	+= algos.o recov.o tables.o int1.o int2.o int4.o \
 raid6_pq-$(CONFIG_X86) += recov_ssse3.o recov_avx2.o mmx.o sse1.o sse2.o avx2.o avx512.o recov_avx512.o
 raid6_pq-$(CONFIG_ALTIVEC) += altivec1.o altivec2.o altivec4.o altivec8.o
 raid6_pq-$(CONFIG_KERNEL_MODE_NEON) += neon.o neon1.o neon2.o neon4.o neon8.o recov_neon.o recov_neon_inner.o
-raid6_pq-$(CONFIG_TILEGX) += tilegx8.o
 raid6_pq-$(CONFIG_S390) += s390vx8.o recov_s390xc.o
 
 hostprogs-y     += mktables
@@ -115,11 +114,6 @@ $(obj)/neon8.c:   UNROLL := 8
 $(obj)/neon8.c:   $(src)/neon.uc $(src)/unroll.awk FORCE
         $(call if_changed,unroll)
 
-targets += tilegx8.c
-$(obj)/tilegx8.c:   UNROLL := 8
-$(obj)/tilegx8.c:   $(src)/tilegx.uc $(src)/unroll.awk FORCE
-        $(call if_changed,unroll)
-
 targets += s390vx8.c
 $(obj)/s390vx8.c:   UNROLL := 8
 $(obj)/s390vx8.c:   $(src)/s390vx.uc $(src)/unroll.awk FORCE
diff --git a/lib/raid6/algos.c b/lib/raid6/algos.c
index 476994723258..c65aa80d67ed 100644
--- a/lib/raid6/algos.c
+++ b/lib/raid6/algos.c
@@ -75,9 +75,6 @@ const struct raid6_calls * const raid6_algos[] = {
         &raid6_altivec4,
         &raid6_altivec8,
 #endif
-#if defined(CONFIG_TILEGX)
-        &raid6_tilegx8,
-#endif
 #if defined(CONFIG_S390)
         &raid6_s390vx8,
 #endif
diff --git a/lib/raid6/test/Makefile b/lib/raid6/test/Makefile
index be1010bdc435..fabc477b1417 100644
--- a/lib/raid6/test/Makefile
+++ b/lib/raid6/test/Makefile
@@ -51,9 +51,6 @@ else
                 OBJS += altivec1.o altivec2.o altivec4.o altivec8.o
         endif
 endif
-ifeq ($(ARCH),tilegx)
-OBJS += tilegx8.o
-endif
 
 .c.o:
         $(CC) $(CFLAGS) -c -o $@ $<
@@ -116,15 +113,11 @@ int16.c: int.uc ../unroll.awk
 int32.c: int.uc ../unroll.awk
         $(AWK) ../unroll.awk -vN=32 < int.uc > $@
 
-tilegx8.c: tilegx.uc ../unroll.awk
-        $(AWK) ../unroll.awk -vN=8 < tilegx.uc > $@
-
 tables.c: mktables
         ./mktables > tables.c
 
 clean:
         rm -f *.o *.a mktables mktables.c *.uc int*.c altivec*.c neon*.c tables.c raid6test
-        rm -f tilegx*.c
 
 spotless: clean
         rm -f *~
diff --git a/lib/raid6/tilegx.uc b/lib/raid6/tilegx.uc
deleted file mode 100644
index 2dd291a11264..000000000000
--- a/lib/raid6/tilegx.uc
+++ /dev/null
@@ -1,87 +0,0 @@
-/* -*- linux-c -*- ------------------------------------------------------- *
- *
- *   Copyright 2002 H. Peter Anvin - All Rights Reserved
- *   Copyright 2012 Tilera Corporation - All Rights Reserved
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
- *   Boston MA 02111-1307, USA; either version 2 of the License, or
- *   (at your option) any later version; incorporated herein by reference.
- *
- * ----------------------------------------------------------------------- */
-
-/*
- * tilegx$#.c
- *
- * $#-way unrolled TILE-Gx SIMD for RAID-6 math.
- *
- * This file is postprocessed using unroll.awk.
- *
- */
-
-#include <linux/raid/pq.h>
-
-/* Create 8 byte copies of constant byte */
-# define NBYTES(x) (__insn_v1addi(0, x))
-# define NSIZE  8
-
-/*
- * The SHLBYTE() operation shifts each byte left by 1, *not*
- * rolling over into the next byte
- */
-static inline __attribute_const__ u64 SHLBYTE(u64 v)
-{
-        /* Vector One Byte Shift Left Immediate. */
-        return __insn_v1shli(v, 1);
-}
-
-/*
- * The MASK() operation returns 0xFF in any byte for which the high
- * bit is 1, 0x00 for any byte for which the high bit is 0.
- */
-static inline __attribute_const__ u64 MASK(u64 v)
-{
-        /* Vector One Byte Shift Right Signed Immediate. */
-        return __insn_v1shrsi(v, 7);
-}
-
-
-void raid6_tilegx$#_gen_syndrome(int disks, size_t bytes, void **ptrs)
-{
-        u8 **dptr = (u8 **)ptrs;
-        u64 *p, *q;
-        int d, z, z0;
-
-        u64 wd$$, wq$$, wp$$, w1$$, w2$$;
-        u64 x1d = NBYTES(0x1d);
-        u64 * z0ptr;
-
-        z0 = disks - 3;                 /* Highest data disk */
-        p = (u64 *)dptr[z0+1];  /* XOR parity */
-        q = (u64 *)dptr[z0+2];  /* RS syndrome */
-
-        z0ptr = (u64 *)&dptr[z0][0];
-        for ( d = 0 ; d < bytes ; d += NSIZE*$# ) {
-                wq$$ = wp$$ = *z0ptr++;
-                for ( z = z0-1 ; z >= 0 ; z-- ) {
-                        wd$$ = *(u64 *)&dptr[z][d+$$*NSIZE];
-                        wp$$ = wp$$ ^ wd$$;
-                        w2$$ = MASK(wq$$);
-                        w1$$ = SHLBYTE(wq$$);
-                        w2$$ = w2$$ & x1d;
-                        w1$$ = w1$$ ^ w2$$;
-                        wq$$ = w1$$ ^ wd$$;
-                }
-                *p++ = wp$$;
-                *q++ = wq$$;
-        }
-}
-
-const struct raid6_calls raid6_tilegx$# = {
-        raid6_tilegx$#_gen_syndrome,
-        NULL,                   /* XOR not yet implemented */
-        NULL,
-        "tilegx$#",
-        0
-};
diff --git a/lib/swiotlb.c b/lib/swiotlb.c
index c43ec2271469..47aeb04c1997 100644
--- a/lib/swiotlb.c
+++ b/lib/swiotlb.c
@@ -31,6 +31,7 @@
 #include <linux/gfp.h>
 #include <linux/scatterlist.h>
 #include <linux/mem_encrypt.h>
+#include <linux/set_memory.h>
 
 #include <asm/io.h>
 #include <asm/dma.h>
@@ -156,22 +157,6 @@ unsigned long swiotlb_size_or_default(void)
         return size ? size : (IO_TLB_DEFAULT_SIZE);
 }
 
-void __weak swiotlb_set_mem_attributes(void *vaddr, unsigned long size) { }
-
-/* For swiotlb, clear memory encryption mask from dma addresses */
-static dma_addr_t swiotlb_phys_to_dma(struct device *hwdev,
-                                      phys_addr_t address)
-{
-        return __sme_clr(phys_to_dma(hwdev, address));
-}
-
-/* Note that this doesn't work with highmem page */
-static dma_addr_t swiotlb_virt_to_bus(struct device *hwdev,
-                                      volatile void *address)
-{
-        return phys_to_dma(hwdev, virt_to_phys(address));
-}
-
 static bool no_iotlb_memory;
 
 void swiotlb_print_info(void)
@@ -209,12 +194,12 @@ void __init swiotlb_update_mem_attributes(void)
 
         vaddr = phys_to_virt(io_tlb_start);
         bytes = PAGE_ALIGN(io_tlb_nslabs << IO_TLB_SHIFT);
-        swiotlb_set_mem_attributes(vaddr, bytes);
+        set_memory_decrypted((unsigned long)vaddr, bytes >> PAGE_SHIFT);
         memset(vaddr, 0, bytes);
 
         vaddr = phys_to_virt(io_tlb_overflow_buffer);
         bytes = PAGE_ALIGN(io_tlb_overflow);
-        swiotlb_set_mem_attributes(vaddr, bytes);
+        set_memory_decrypted((unsigned long)vaddr, bytes >> PAGE_SHIFT);
         memset(vaddr, 0, bytes);
 }
 
@@ -355,7 +340,7 @@ swiotlb_late_init_with_tbl(char *tlb, unsigned long nslabs)
         io_tlb_start = virt_to_phys(tlb);
         io_tlb_end = io_tlb_start + bytes;
 
-        swiotlb_set_mem_attributes(tlb, bytes);
+        set_memory_decrypted((unsigned long)tlb, bytes >> PAGE_SHIFT);
         memset(tlb, 0, bytes);
 
         /*
@@ -366,7 +351,8 @@ swiotlb_late_init_with_tbl(char *tlb, unsigned long nslabs)
         if (!v_overflow_buffer)
                 goto cleanup2;
 
-        swiotlb_set_mem_attributes(v_overflow_buffer, io_tlb_overflow);
+        set_memory_decrypted((unsigned long)v_overflow_buffer,
+                        io_tlb_overflow >> PAGE_SHIFT);
         memset(v_overflow_buffer, 0, io_tlb_overflow);
         io_tlb_overflow_buffer = virt_to_phys(v_overflow_buffer);
 
@@ -622,7 +608,7 @@ map_single(struct device *hwdev, phys_addr_t phys, size_t size,
                 return SWIOTLB_MAP_ERROR;
         }
 
-        start_dma_addr = swiotlb_phys_to_dma(hwdev, io_tlb_start);
+        start_dma_addr = __phys_to_dma(hwdev, io_tlb_start);
         return swiotlb_tbl_map_single(hwdev, start_dma_addr, phys, size,
                                       dir, attrs);
 }
@@ -706,6 +692,7 @@ void swiotlb_tbl_sync_single(struct device *hwdev, phys_addr_t tlb_addr,
         }
 }
 
+#ifdef CONFIG_DMA_DIRECT_OPS
 static inline bool dma_coherent_ok(struct device *dev, dma_addr_t addr,
                 size_t size)
 {
@@ -726,12 +713,12 @@ swiotlb_alloc_buffer(struct device *dev, size_t size, dma_addr_t *dma_handle,
                 goto out_warn;
 
         phys_addr = swiotlb_tbl_map_single(dev,
-                        swiotlb_phys_to_dma(dev, io_tlb_start),
+                        __phys_to_dma(dev, io_tlb_start),
                         0, size, DMA_FROM_DEVICE, 0);
         if (phys_addr == SWIOTLB_MAP_ERROR)
                 goto out_warn;
 
-        *dma_handle = swiotlb_phys_to_dma(dev, phys_addr);
+        *dma_handle = __phys_to_dma(dev, phys_addr);
         if (dma_coherent_ok(dev, *dma_handle, size))
                 goto out_unmap;
 
@@ -759,28 +746,6 @@ out_warn:
         return NULL;
 }
 
-void *
-swiotlb_alloc_coherent(struct device *hwdev, size_t size,
-                       dma_addr_t *dma_handle, gfp_t flags)
-{
-        int order = get_order(size);
-        unsigned long attrs = (flags & __GFP_NOWARN) ? DMA_ATTR_NO_WARN : 0;
-        void *ret;
-
-        ret = (void *)__get_free_pages(flags, order);
-        if (ret) {
-                *dma_handle = swiotlb_virt_to_bus(hwdev, ret);
-                if (dma_coherent_ok(hwdev, *dma_handle, size)) {
-                        memset(ret, 0, size);
-                        return ret;
-                }
-                free_pages((unsigned long)ret, order);
-        }
-
-        return swiotlb_alloc_buffer(hwdev, size, dma_handle, attrs);
-}
-EXPORT_SYMBOL(swiotlb_alloc_coherent);
-
 static bool swiotlb_free_buffer(struct device *dev, size_t size,
                 dma_addr_t dma_addr)
 {
@@ -799,15 +764,7 @@ static bool swiotlb_free_buffer(struct device *dev, size_t size,
                                  DMA_ATTR_SKIP_CPU_SYNC);
         return true;
 }
-
-void
-swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr,
-                      dma_addr_t dev_addr)
-{
-        if (!swiotlb_free_buffer(hwdev, size, dev_addr))
-                free_pages((unsigned long)vaddr, get_order(size));
-}
-EXPORT_SYMBOL(swiotlb_free_coherent);
+#endif
 
 static void
 swiotlb_full(struct device *dev, size_t size, enum dma_data_direction dir,
@@ -867,10 +824,10 @@ dma_addr_t swiotlb_map_page(struct device *dev, struct page *page,
         map = map_single(dev, phys, size, dir, attrs);
         if (map == SWIOTLB_MAP_ERROR) {
                 swiotlb_full(dev, size, dir, 1);
-                return swiotlb_phys_to_dma(dev, io_tlb_overflow_buffer);
+                return __phys_to_dma(dev, io_tlb_overflow_buffer);
         }
 
-        dev_addr = swiotlb_phys_to_dma(dev, map);
+        dev_addr = __phys_to_dma(dev, map);
 
         /* Ensure that the address returned is DMA'ble */
         if (dma_capable(dev, dev_addr, size))
@@ -879,7 +836,7 @@ dma_addr_t swiotlb_map_page(struct device *dev, struct page *page,
         attrs |= DMA_ATTR_SKIP_CPU_SYNC;
         swiotlb_tbl_unmap_single(dev, map, size, dir, attrs);
 
-        return swiotlb_phys_to_dma(dev, io_tlb_overflow_buffer);
+        return __phys_to_dma(dev, io_tlb_overflow_buffer);
 }
 
 /*
@@ -1009,7 +966,7 @@ swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, int nelems,
                                 sg_dma_len(sgl) = 0;
                                 return 0;
                         }
-                        sg->dma_address = swiotlb_phys_to_dma(hwdev, map);
+                        sg->dma_address = __phys_to_dma(hwdev, map);
                 } else
                         sg->dma_address = dev_addr;
                 sg_dma_len(sg) = sg->length;
@@ -1073,7 +1030,7 @@ swiotlb_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg,
 int
 swiotlb_dma_mapping_error(struct device *hwdev, dma_addr_t dma_addr)
 {
-        return (dma_addr == swiotlb_phys_to_dma(hwdev, io_tlb_overflow_buffer));
+        return (dma_addr == __phys_to_dma(hwdev, io_tlb_overflow_buffer));
 }
 
 /*
@@ -1085,7 +1042,7 @@ swiotlb_dma_mapping_error(struct device *hwdev, dma_addr_t dma_addr)
 int
 swiotlb_dma_supported(struct device *hwdev, u64 mask)
 {
-        return swiotlb_phys_to_dma(hwdev, io_tlb_end - 1) <= mask;
+        return __phys_to_dma(hwdev, io_tlb_end - 1) <= mask;
 }
 
 #ifdef CONFIG_DMA_DIRECT_OPS
diff --git a/lib/test_user_copy.c b/lib/test_user_copy.c
index 4621db801b23..e161f0498f42 100644
--- a/lib/test_user_copy.c
+++ b/lib/test_user_copy.c
@@ -31,11 +31,8 @@
  * their capability at compile-time, we just have to opt-out certain archs.
  */
 #if BITS_PER_LONG == 64 || (!(defined(CONFIG_ARM) && !defined(MMU)) && \
-                            !defined(CONFIG_BLACKFIN) &&        \
-                            !defined(CONFIG_M32R) &&            \
                             !defined(CONFIG_M68K) &&            \
                             !defined(CONFIG_MICROBLAZE) &&      \
-                            !defined(CONFIG_MN10300) &&         \
                             !defined(CONFIG_NIOS2) &&           \
                             !defined(CONFIG_PPC32) &&           \
                             !defined(CONFIG_SUPERH))