arch/tile: Miscellaneous cleanup changes.

This commit is primarily changes caused by reviewing "sparse"
and "checkpatch" output on our sources, so is somewhat noisy, since
things like "printk() -> pr_err()" (or whatever) throughout the
codebase tend to get tedious to read.  Rather than trying to tease
apart precisely which things changed due to which type of code
review, this commit includes various cleanups in the code:

- sparse: Add declarations in headers for globals.
- sparse: Fix __user annotations.
- sparse: Using gfp_t consistently instead of int.
- sparse: removing functions not actually used.
- checkpatch: Clean up printk() warnings by using pr_info(), etc.;
  also avoid partial-line printks except in bootup code.
  - checkpatch: Use exposed structs rather than typedefs.
  - checkpatch: Change some C99 comments to C89 comments.

In addition, a couple of minor other changes are rolled in
to this commit:

- Add support for a "raise" instruction to cause SIGFPE, etc., to be raised.
- Remove some compat code that is unnecessary when we fully eliminate
  some of the deprecated syscalls from the generic syscall ABI.
- Update the tile_defconfig to reflect current config contents.

Signed-off-by: Chris Metcalf <cmetcalf@tilera.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>

1 files changed, 51 insertions, 48 deletions

diff --git a/arch/tile/mm/init.c b/arch/tile/mm/init.c
index 125ac53b60fc..d89c9eacd162 100644
--- a/arch/tile/mm/init.c
+++ b/arch/tile/mm/init.c
@@ -67,7 +67,9 @@
 
 #define clear_pgd(pmdptr) (*(pmdptr) = hv_pte(0))
 
+#ifndef __tilegx__
 unsigned long VMALLOC_RESERVE = CONFIG_VMALLOC_RESERVE;
+#endif
 
 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
 
@@ -282,9 +284,9 @@ static pgprot_t __init init_pgprot(ulong address)
         /*
          * Everything else that isn't data or bss is heap, so mark it
          * with the initial heap home (hash-for-home, or this cpu).  This
-         * includes any addresses after the loaded image; any address before
-         * _einittext (since we already captured the case of text before
-         * _sinittext); and any init-data pages.
+         * includes any addresses after the loaded image and any address before
+         * _einitdata, since we already captured the case of text before
+         * _sinittext, and __pa(einittext) is approximately __pa(sinitdata).
          *
          * All the LOWMEM pages that we mark this way will get their
          * struct page homecache properly marked later, in set_page_homes().
@@ -292,9 +294,7 @@ static pgprot_t __init init_pgprot(ulong address)
          * homes, but with a zero free_time we don't have to actually
          * do a flush action the first time we use them, either.
          */
-        if (address >= (ulong) _end || address < (ulong) _sdata ||
-            (address >= (ulong) _sinitdata &&
-             address < (ulong) _einitdata))
+        if (address >= (ulong) _end || address < (ulong) _einitdata)
                 return construct_pgprot(PAGE_KERNEL, initial_heap_home());
 
 #if CHIP_HAS_CBOX_HOME_MAP()
@@ -304,35 +304,38 @@ static pgprot_t __init init_pgprot(ulong address)
 #endif
 
         /*
+         * Make the w1data homed like heap to start with, to avoid
+         * making it part of the page-striped data area when we're just
+         * going to convert it to read-only soon anyway.
+         */
+        if (address >= (ulong)__w1data_begin && address < (ulong)__w1data_end)
+                return construct_pgprot(PAGE_KERNEL, initial_heap_home());
+
+        /*
          * Otherwise we just hand out consecutive cpus.  To avoid
          * requiring this function to hold state, we just walk forward from
          * _sdata by PAGE_SIZE, skipping the readonly and init data, to reach
          * the requested address, while walking cpu home around kdata_mask.
          * This is typically no more than a dozen or so iterations.
          */
-        BUG_ON(_einitdata != __bss_start);
-        for (page = (ulong)_sdata, cpu = NR_CPUS; ; ) {
-                cpu = cpumask_next(cpu, &kdata_mask);
-                if (cpu == NR_CPUS)
-                        cpu = cpumask_first(&kdata_mask);
-                if (page >= address)
-                        break;
-                page += PAGE_SIZE;
-                if (page == (ulong)__start_rodata)
-                        page = (ulong)__end_rodata;
-                if (page == (ulong)&init_thread_union)
-                        page += THREAD_SIZE;
-                if (page == (ulong)_sinitdata)
-                        page = (ulong)_einitdata;
+        page = (((ulong)__w1data_end) + PAGE_SIZE - 1) & PAGE_MASK;
+        BUG_ON(address < page || address >= (ulong)_end);
+        cpu = cpumask_first(&kdata_mask);
+        for (; page < address; page += PAGE_SIZE) {
+                if (page >= (ulong)&init_thread_union &&
+                    page < (ulong)&init_thread_union + THREAD_SIZE)
+                        continue;
                 if (page == (ulong)empty_zero_page)
-                        page += PAGE_SIZE;
+                        continue;
 #ifndef __tilegx__
 #if !ATOMIC_LOCKS_FOUND_VIA_TABLE()
                 if (page == (ulong)atomic_locks)
-                        page += PAGE_SIZE;
+                        continue;
 #endif
 #endif
-
+                cpu = cpumask_next(cpu, &kdata_mask);
+                if (cpu == NR_CPUS)
+                        cpu = cpumask_first(&kdata_mask);
         }
         return construct_pgprot(PAGE_KERNEL, cpu);
 }
@@ -362,7 +365,7 @@ static int __init setup_ktext(char *str)
         /* If you have a leading "nocache", turn off ktext caching */
         if (strncmp(str, "nocache", 7) == 0) {
                 ktext_nocache = 1;
-                printk("ktext: disabling local caching of kernel text\n");
+                pr_info("ktext: disabling local caching of kernel text\n");
                 str += 7;
                 if (*str == ',')
                         ++str;
@@ -374,20 +377,20 @@ static int __init setup_ktext(char *str)
 
         /* Default setting on Tile64: use a huge page */
         if (strcmp(str, "huge") == 0)
-                printk("ktext: using one huge locally cached page\n");
+                pr_info("ktext: using one huge locally cached page\n");
 
         /* Pay TLB cost but get no cache benefit: cache small pages locally */
         else if (strcmp(str, "local") == 0) {
                 ktext_small = 1;
                 ktext_local = 1;
-                printk("ktext: using small pages with local caching\n");
+                pr_info("ktext: using small pages with local caching\n");
         }
 
         /* Neighborhood cache ktext pages on all cpus. */
         else if (strcmp(str, "all") == 0) {
                 ktext_small = 1;
                 ktext_all = 1;
-                printk("ktext: using maximal caching neighborhood\n");
+                pr_info("ktext: using maximal caching neighborhood\n");
         }
 
 
@@ -397,10 +400,10 @@ static int __init setup_ktext(char *str)
                 cpulist_scnprintf(buf, sizeof(buf), &ktext_mask);
                 if (cpumask_weight(&ktext_mask) > 1) {
                         ktext_small = 1;
-                        printk("ktext: using caching neighborhood %s "
+                        pr_info("ktext: using caching neighborhood %s "
                                "with small pages\n", buf);
                 } else {
-                        printk("ktext: caching on cpu %s with one huge page\n",
+                        pr_info("ktext: caching on cpu %s with one huge page\n",
                                buf);
                 }
         }
@@ -470,19 +473,19 @@ static void __init kernel_physical_mapping_init(pgd_t *pgd_base)
 
 #if CHIP_HAS_CBOX_HOME_MAP()
         if (ktext_arg_seen && ktext_hash) {
-                printk("warning: \"ktext\" boot argument ignored"
-                       " if \"kcache_hash\" sets up text hash-for-home\n");
+                pr_warning("warning: \"ktext\" boot argument ignored"
+                           " if \"kcache_hash\" sets up text hash-for-home\n");
                 ktext_small = 0;
         }
 
         if (kdata_arg_seen && kdata_hash) {
-                printk("warning: \"kdata\" boot argument ignored"
-                       " if \"kcache_hash\" sets up data hash-for-home\n");
+                pr_warning("warning: \"kdata\" boot argument ignored"
+                           " if \"kcache_hash\" sets up data hash-for-home\n");
         }
 
         if (kdata_huge && !hash_default) {
-                printk("warning: disabling \"kdata=huge\"; requires"
-                       " kcache_hash=all or =allbutstack\n");
+                pr_warning("warning: disabling \"kdata=huge\"; requires"
+                          " kcache_hash=all or =allbutstack\n");
                 kdata_huge = 0;
         }
 #endif
@@ -556,11 +559,11 @@ static void __init kernel_physical_mapping_init(pgd_t *pgd_base)
                 if (!cpumask_empty(&bad)) {
                         char buf[NR_CPUS * 5];
                         cpulist_scnprintf(buf, sizeof(buf), &bad);
-                        printk("ktext: not using unavailable cpus %s\n", buf);
+                        pr_info("ktext: not using unavailable cpus %s\n", buf);
                 }
                 if (cpumask_empty(&ktext_mask)) {
-                        printk("ktext: no valid cpus; caching on %d.\n",
-                               smp_processor_id());
+                        pr_warning("ktext: no valid cpus; caching on %d.\n",
+                                   smp_processor_id());
                         cpumask_copy(&ktext_mask,
                                      cpumask_of(smp_processor_id()));
                 }
@@ -737,17 +740,18 @@ static void __init set_non_bootmem_pages_init(void)
         for_each_zone(z) {
                 unsigned long start, end;
                 int nid = z->zone_pgdat->node_id;
+                int idx = zone_idx(z);
 
                 start = z->zone_start_pfn;
                 if (start == 0)
                         continue;  /* bootmem */
                 end = start + z->spanned_pages;
-                if (zone_idx(z) == ZONE_NORMAL) {
+                if (idx == ZONE_NORMAL) {
                         BUG_ON(start != node_start_pfn[nid]);
                         start = node_free_pfn[nid];
                 }
 #ifdef CONFIG_HIGHMEM
-                if (zone_idx(z) == ZONE_HIGHMEM)
+                if (idx == ZONE_HIGHMEM)
                         totalhigh_pages += z->spanned_pages;
 #endif
                 if (kdata_huge) {
@@ -841,9 +845,9 @@ void __init mem_init(void)
 #ifdef CONFIG_HIGHMEM
         /* check that fixmap and pkmap do not overlap */
         if (PKMAP_ADDR(LAST_PKMAP-1) >= FIXADDR_START) {
-                printk(KERN_ERR "fixmap and kmap areas overlap"
+                pr_err("fixmap and kmap areas overlap"
                        " - this will crash\n");
-                printk(KERN_ERR "pkstart: %lxh pkend: %lxh fixstart %lxh\n",
+                pr_err("pkstart: %lxh pkend: %lxh fixstart %lxh\n",
                        PKMAP_BASE, PKMAP_ADDR(LAST_PKMAP-1),
                        FIXADDR_START);
                 BUG();
@@ -863,7 +867,7 @@ void __init mem_init(void)
         initsize =  (unsigned long)&_einittext - (unsigned long)&_sinittext;
         initsize += (unsigned long)&_einitdata - (unsigned long)&_sinitdata;
 
-        printk(KERN_INFO "Memory: %luk/%luk available (%dk kernel code, %dk data, %dk init, %ldk highmem)\n",
+        pr_info("Memory: %luk/%luk available (%dk kernel code, %dk data, %dk init, %ldk highmem)\n",
                 (unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
                 num_physpages << (PAGE_SHIFT-10),
                 codesize >> 10,
@@ -968,7 +972,6 @@ static void mark_w1data_ro(void)
         BUG_ON((addr & (PAGE_SIZE-1)) != 0);
         for (; addr <= (unsigned long)__w1data_end - 1; addr += PAGE_SIZE) {
                 unsigned long pfn = kaddr_to_pfn((void *)addr);
-                struct page *page = pfn_to_page(pfn);
                 pte_t *ptep = virt_to_pte(NULL, addr);
                 BUG_ON(pte_huge(*ptep));   /* not relevant for kdata_huge */
                 set_pte_at(&init_mm, addr, ptep, pfn_pte(pfn, PAGE_KERNEL_RO));
@@ -986,7 +989,7 @@ static long __write_once initfree = 1;
 static int __init set_initfree(char *str)
 {
         strict_strtol(str, 0, &initfree);
-        printk("initfree: %s free init pages\n", initfree ? "will" : "won't");
+        pr_info("initfree: %s free init pages\n", initfree ? "will" : "won't");
         return 1;
 }
 __setup("initfree=", set_initfree);
@@ -996,8 +999,8 @@ static void free_init_pages(char *what, unsigned long begin, unsigned long end)
         unsigned long addr = (unsigned long) begin;
 
         if (kdata_huge && !initfree) {
-                printk("Warning: ignoring initfree=0:"
-                       " incompatible with kdata=huge\n");
+                pr_warning("Warning: ignoring initfree=0:"
+                           " incompatible with kdata=huge\n");
                 initfree = 1;
         }
         end = (end + PAGE_SIZE - 1) & PAGE_MASK;
@@ -1033,7 +1036,7 @@ static void free_init_pages(char *what, unsigned long begin, unsigned long end)
                 free_page(addr);
                 totalram_pages++;
         }
-        printk(KERN_INFO "Freeing %s: %ldk freed\n", what, (end - begin) >> 10);
+        pr_info("Freeing %s: %ldk freed\n", what, (end - begin) >> 10);
 }
 
 void free_initmem(void)