Merge branch 'akpm' (patches from Andrew)

threads: the global ones, that are spawned during kernel boot in a limited

number of instances (e.g. one USB hub_event() worker thread is spawned per

USB HCD); and the local ones, that are spawned when a user interacts with

some kernel interface (e.g. vhost workers).

some kernel interface (e.g. vhost workers); as well as from soft

interrupts.

To enable collecting coverage from a global background thread, a unique

global handle must be assigned and passed to the corresponding

kcov_remote_start() call. Then a userspace process can pass a list of such

handles to the KCOV_REMOTE_ENABLE ioctl in the handles array field of the

kcov_remote_arg struct. This will attach the used kcov device to the code

sections, that are referenced by those handles.

To enable collecting coverage from a global background thread or from a

softirq, a unique global handle must be assigned and passed to the

corresponding kcov_remote_start() call. Then a userspace process can pass

a list of such handles to the KCOV_REMOTE_ENABLE ioctl in the handles

array field of the kcov_remote_arg struct. This will attach the used kcov

device to the code sections, that are referenced by those handles.

Since there might be many local background threads spawned from different

userspace processes, we can't use a single global handle per annotation.

currently reserved and must be zero. In the future the number of bytes

used for the subsystem or handle ids might be increased.

When a particular userspace proccess collects coverage by via a common

When a particular userspace proccess collects coverage via a common

handle, kcov will collect coverage for each code section that is annotated

to use the common handle obtained as kcov_handle from the current

task_struct. However non common handles allow to collect coverage

#

# Feature name:          debug-vm-pgtable

#         Kconfig:       ARCH_HAS_DEBUG_VM_PGTABLE

#         description:   arch supports pgtable tests for semantics compliance

#

    -----------------------

    |         arch |status|

    -----------------------

    |       alpha: | TODO |

    |         arc: |  ok  |

    |         arm: | TODO |

    |       arm64: |  ok  |

    |         c6x: | TODO |

    |        csky: | TODO |

    |       h8300: | TODO |

    |     hexagon: | TODO |

    |        ia64: | TODO |

    |        m68k: | TODO |

    |  microblaze: | TODO |

    |        mips: | TODO |

    |       nds32: | TODO |

    |       nios2: | TODO |

    |    openrisc: | TODO |

    |      parisc: | TODO |

    |     powerpc: |  ok  |

    |       riscv: | TODO |

    |        s390: |  ok  |

    |          sh: | TODO |

    |       sparc: | TODO |

    |          um: | TODO |

    |   unicore32: | TODO |

    |         x86: |  ok  |

    |      xtensa: | TODO |

    -----------------------

config ARC

	def_bool y

	select ARC_TIMERS

	select ARCH_HAS_DEBUG_VM_PGTABLE

	select ARCH_HAS_DMA_PREP_COHERENT

	select ARCH_HAS_PTE_SPECIAL

	select ARCH_HAS_SETUP_DMA_OPS

#define PKMAP_ADDR(nr)		(PKMAP_BASE + ((nr) << PAGE_SHIFT))

#define PKMAP_NR(virt)		(((virt) - PKMAP_BASE) >> PAGE_SHIFT)

#define kmap_prot		PAGE_KERNEL

#include <asm/cacheflush.h>

extern void *kmap(struct page *page);

extern void *kmap_high(struct page *page);

extern void *kmap_atomic(struct page *page);

extern void __kunmap_atomic(void *kvaddr);

extern void kunmap_high(struct page *page);

extern void kmap_init(void);

static inline void flush_cache_kmaps(void)

	flush_cache_all();

}

static inline void kunmap(struct page *page)

{

	BUG_ON(in_interrupt());

	if (!PageHighMem(page))

		return;

	kunmap_high(page);

}

#endif

#endif

extern pte_t * pkmap_page_table;

static pte_t * fixmap_page_table;

void *kmap(struct page *page)

{

	BUG_ON(in_interrupt());

	if (!PageHighMem(page))

		return page_address(page);

	return kmap_high(page);

}

EXPORT_SYMBOL(kmap);

void *kmap_atomic(struct page *page)

void *kmap_atomic_high_prot(struct page *page, pgprot_t prot)

{

	int idx, cpu_idx;

	unsigned long vaddr;

	preempt_disable();

	pagefault_disable();

	if (!PageHighMem(page))

		return page_address(page);

	cpu_idx = kmap_atomic_idx_push();

	idx = cpu_idx + KM_TYPE_NR * smp_processor_id();

	vaddr = FIXMAP_ADDR(idx);

	set_pte_at(&init_mm, vaddr, fixmap_page_table + idx,

		   mk_pte(page, kmap_prot));

		   mk_pte(page, prot));

	return (void *)vaddr;

}

EXPORT_SYMBOL(kmap_atomic);

EXPORT_SYMBOL(kmap_atomic_high_prot);

void __kunmap_atomic(void *kv)

void kunmap_atomic_high(void *kv)

{

	unsigned long kvaddr = (unsigned long)kv;

		kmap_atomic_idx_pop();

	}

	pagefault_enable();

	preempt_enable();

}

EXPORT_SYMBOL(__kunmap_atomic);

EXPORT_SYMBOL(kunmap_atomic_high);

static noinline pte_t * __init alloc_kmap_pgtable(unsigned long kvaddr)

{