[PATCH] numa.c: use spaces instead of tabs

[PATCH] numa.c: use spaces instead of tabs

[Elena Ufimtseva]

Signed-off-by: Elena Ufimtseva <ufimtseva@gmail.com>
---
 xen/arch/x86/numa.c |  484 +++++++++++++++++++++++++--------------------------
 1 file changed, 242 insertions(+), 242 deletions(-)

diff --git a/xen/arch/x86/numa.c b/xen/arch/x86/numa.c
index b141877..555276e 100644
--- a/xen/arch/x86/numa.c
+++ b/xen/arch/x86/numa.c
@@ -36,13 +36,13 @@ unsigned long memnodemapsize;
 u8 *memnodemap;
 
 unsigned char cpu_to_node[NR_CPUS] __read_mostly = {
-	[0 ... NR_CPUS-1] = NUMA_NO_NODE
+    [0 ... NR_CPUS-1] = NUMA_NO_NODE
 };
 /*
  * Keep BIOS's CPU2node information, should not be used for memory allocaion
  */
 unsigned char apicid_to_node[MAX_LOCAL_APIC] __cpuinitdata = {
- 	[0 ... MAX_LOCAL_APIC-1] = NUMA_NO_NODE
+    [0 ... MAX_LOCAL_APIC-1] = NUMA_NO_NODE
 };
 cpumask_t node_to_cpumask[MAX_NUMNODES] __read_mostly;
 
@@ -54,7 +54,7 @@ int acpi_numa __devinitdata;
 
 int srat_disabled(void)
 {
-	return numa_off || acpi_numa < 0;
+    return numa_off || acpi_numa < 0;
 }
 
 /*
@@ -67,53 +67,53 @@ int srat_disabled(void)
 static int __init populate_memnodemap(const struct node *nodes,
                                       int numnodes, int shift, int *nodeids)
 {
-	unsigned long spdx, epdx;
-	int i, res = -1;
-
-	memset(memnodemap, NUMA_NO_NODE, memnodemapsize * sizeof(*memnodemap));
-	for (i = 0; i < numnodes; i++) {
-		spdx = paddr_to_pdx(nodes[i].start);
-		epdx = paddr_to_pdx(nodes[i].end - 1) + 1;
-		if (spdx >= epdx)
-			continue;
-		if ((epdx >> shift) >= memnodemapsize)
-			return 0;
-		do {
-			if (memnodemap[spdx >> shift] != NUMA_NO_NODE)
-				return -1;
-
-			if (!nodeids)
-				memnodemap[spdx >> shift] = i;
-			else
-				memnodemap[spdx >> shift] = nodeids[i];
-
-			spdx += (1UL << shift);
-		} while (spdx < epdx);
-		res = 1;
-	}
-	return res;
+    unsigned long spdx, epdx;
+    int i, res = -1;
+
+    memset(memnodemap, NUMA_NO_NODE, memnodemapsize * sizeof(*memnodemap));
+    for (i = 0; i < numnodes; i++) {
+        spdx = paddr_to_pdx(nodes[i].start);
+        epdx = paddr_to_pdx(nodes[i].end - 1) + 1;
+        if (spdx >= epdx)
+            continue;
+        if ((epdx >> shift) >= memnodemapsize)
+            return 0;
+        do {
+            if (memnodemap[spdx >> shift] != NUMA_NO_NODE)
+                return -1;
+
+            if (!nodeids)
+                memnodemap[spdx >> shift] = i;
+            else
+                memnodemap[spdx >> shift] = nodeids[i];
+
+            spdx += (1UL << shift);
+        } while (spdx < epdx);
+        res = 1;
+    }
+    return res;
 }
 
 static int __init allocate_cachealigned_memnodemap(void)
 {
-	unsigned long size = PFN_UP(memnodemapsize * sizeof(*memnodemap));
-	unsigned long mfn = alloc_boot_pages(size, 1);
-
-	if (!mfn) {
-		printk(KERN_ERR
-		       "NUMA: Unable to allocate Memory to Node hash map\n");
-		memnodemapsize = 0;
-		return -1;
-	}
-
-	memnodemap = mfn_to_virt(mfn);
-	mfn <<= PAGE_SHIFT;
-	size <<= PAGE_SHIFT;
-	printk(KERN_DEBUG "NUMA: Allocated memnodemap from %lx - %lx\n",
-	       mfn, mfn + size);
-	memnodemapsize = size / sizeof(*memnodemap);
-
-	return 0;
+    unsigned long size = PFN_UP(memnodemapsize * sizeof(*memnodemap));
+    unsigned long mfn = alloc_boot_pages(size, 1);
+
+    if (!mfn) {
+        printk(KERN_ERR
+               "NUMA: Unable to allocate Memory to Node hash map\n");
+        memnodemapsize = 0;
+        return -1;
+    }
+
+    memnodemap = mfn_to_virt(mfn);
+    mfn <<= PAGE_SHIFT;
+    size <<= PAGE_SHIFT;
+    printk(KERN_DEBUG "NUMA: Allocated memnodemap from %lx - %lx\n",
+           mfn, mfn + size);
+    memnodemapsize = size / sizeof(*memnodemap);
+
+    return 0;
 }
 
 /*
@@ -121,83 +121,83 @@ static int __init allocate_cachealigned_memnodemap(void)
  * maximum possible shift.
  */
 static int __init extract_lsb_from_nodes(const struct node *nodes,
-					 int numnodes)
+                     int numnodes)
 {
-	int i, nodes_used = 0;
-	unsigned long spdx, epdx;
-	unsigned long bitfield = 0, memtop = 0;
-
-	for (i = 0; i < numnodes; i++) {
-		spdx = paddr_to_pdx(nodes[i].start);
-		epdx = paddr_to_pdx(nodes[i].end - 1) + 1;
-		if (spdx >= epdx)
-			continue;
-		bitfield |= spdx;
-		nodes_used++;
-		if (epdx > memtop)
-			memtop = epdx;
-	}
-	if (nodes_used <= 1)
-		i = BITS_PER_LONG - 1;
-	else
-		i = find_first_bit(&bitfield, sizeof(unsigned long)*8);
-	memnodemapsize = (memtop >> i) + 1;
-	return i;
+    int i, nodes_used = 0;
+    unsigned long spdx, epdx;
+    unsigned long bitfield = 0, memtop = 0;
+
+    for (i = 0; i < numnodes; i++) {
+        spdx = paddr_to_pdx(nodes[i].start);
+        epdx = paddr_to_pdx(nodes[i].end - 1) + 1;
+        if (spdx >= epdx)
+            continue;
+        bitfield |= spdx;
+        nodes_used++;
+        if (epdx > memtop)
+            memtop = epdx;
+    }
+    if (nodes_used <= 1)
+        i = BITS_PER_LONG - 1;
+    else
+        i = find_first_bit(&bitfield, sizeof(unsigned long)*8);
+    memnodemapsize = (memtop >> i) + 1;
+    return i;
 }
 
 int __init compute_hash_shift(struct node *nodes, int numnodes,
-			      int *nodeids)
+                  int *nodeids)
 {
-	int shift;
-
-	shift = extract_lsb_from_nodes(nodes, numnodes);
-	if (memnodemapsize <= ARRAY_SIZE(_memnodemap))
-		memnodemap = _memnodemap;
-	else if (allocate_cachealigned_memnodemap())
-		return -1;
-	printk(KERN_DEBUG "NUMA: Using %d for the hash shift.\n",
-		shift);
-
-	if (populate_memnodemap(nodes, numnodes, shift, nodeids) != 1) {
-		printk(KERN_INFO "Your memory is not aligned you need to "
-		       "rebuild your kernel with a bigger NODEMAPSIZE "
-		       "shift=%d\n", shift);
-		return -1;
-	}
-	return shift;
+    int shift;
+
+    shift = extract_lsb_from_nodes(nodes, numnodes);
+    if (memnodemapsize <= ARRAY_SIZE(_memnodemap))
+        memnodemap = _memnodemap;
+    else if (allocate_cachealigned_memnodemap())
+        return -1;
+    printk(KERN_DEBUG "NUMA: Using %d for the hash shift.\n",
+        shift);
+
+    if (populate_memnodemap(nodes, numnodes, shift, nodeids) != 1) {
+        printk(KERN_INFO "Your memory is not aligned you need to "
+               "rebuild your kernel with a bigger NODEMAPSIZE "
+               "shift=%d\n", shift);
+        return -1;
+    }
+    return shift;
 }
 /* initialize NODE_DATA given nodeid and start/end */
 void __init setup_node_bootmem(int nodeid, u64 start, u64 end)
 { 
-	unsigned long start_pfn, end_pfn;
+    unsigned long start_pfn, end_pfn;
 
-	start_pfn = start >> PAGE_SHIFT;
-	end_pfn = end >> PAGE_SHIFT;
+    start_pfn = start >> PAGE_SHIFT;
+    end_pfn = end >> PAGE_SHIFT;
 
-	NODE_DATA(nodeid)->node_id = nodeid;
-	NODE_DATA(nodeid)->node_start_pfn = start_pfn;
-	NODE_DATA(nodeid)->node_spanned_pages = end_pfn - start_pfn;
+    NODE_DATA(nodeid)->node_id = nodeid;
+    NODE_DATA(nodeid)->node_start_pfn = start_pfn;
+    NODE_DATA(nodeid)->node_spanned_pages = end_pfn - start_pfn;
 
-	node_set_online(nodeid);
+    node_set_online(nodeid);
 } 
 
 void __init numa_init_array(void)
 {
-	int rr, i;
-	/* There are unfortunately some poorly designed mainboards around
-	   that only connect memory to a single CPU. This breaks the 1:1 cpu->node
-	   mapping. To avoid this fill in the mapping for all possible
-	   CPUs, as the number of CPUs is not known yet. 
-	   We round robin the existing nodes. */
-	rr = first_node(node_online_map);
-	for (i = 0; i < nr_cpu_ids; i++) {
-		if (cpu_to_node[i] != NUMA_NO_NODE)
-			continue;
- 		numa_set_node(i, rr);
-		rr = next_node(rr, node_online_map);
-		if (rr == MAX_NUMNODES)
-			rr = first_node(node_online_map);
-	}
+    int rr, i;
+    /* There are unfortunately some poorly designed mainboards around
+       that only connect memory to a single CPU. This breaks the 1:1 cpu->node
+       mapping. To avoid this fill in the mapping for all possible
+       CPUs, as the number of CPUs is not known yet.
+       We round robin the existing nodes. */
+    rr = first_node(node_online_map);
+    for (i = 0; i < nr_cpu_ids; i++) {
+        if (cpu_to_node[i] != NUMA_NO_NODE)
+            continue;
+        numa_set_node(i, rr);
+        rr = next_node(rr, node_online_map);
+        if (rr == MAX_NUMNODES)
+            rr = first_node(node_online_map);
+    }
 
 }
 
@@ -207,109 +207,109 @@ static int numa_fake __initdata = 0;
 /* Numa emulation */
 static int __init numa_emulation(u64 start_pfn, u64 end_pfn)
 {
- 	int i;
- 	struct node nodes[MAX_NUMNODES];
- 	u64 sz = ((end_pfn - start_pfn)<<PAGE_SHIFT) / numa_fake;
-
- 	/* Kludge needed for the hash function */
- 	if (hweight64(sz) > 1) {
- 		u64 x = 1;
- 		while ((x << 1) < sz)
- 			x <<= 1;
- 		if (x < sz/2)
- 			printk(KERN_ERR "Numa emulation unbalanced. Complain to maintainer\n");
- 		sz = x;
- 	}
-
- 	memset(&nodes,0,sizeof(nodes));
- 	for (i = 0; i < numa_fake; i++) {
- 		nodes[i].start = (start_pfn<<PAGE_SHIFT) + i*sz;
- 		if (i == numa_fake-1)
- 			sz = (end_pfn<<PAGE_SHIFT) - nodes[i].start;
- 		nodes[i].end = nodes[i].start + sz;
- 		printk(KERN_INFO "Faking node %d at %"PRIx64"-%"PRIx64" (%"PRIu64"MB)\n",
-		       i,
-		       nodes[i].start, nodes[i].end,
-		       (nodes[i].end - nodes[i].start) >> 20);
-		node_set_online(i);
- 	}
- 	memnode_shift = compute_hash_shift(nodes, numa_fake, NULL);
- 	if (memnode_shift < 0) {
- 		memnode_shift = 0;
- 		printk(KERN_ERR "No NUMA hash function found. Emulation disabled.\n");
- 		return -1;
- 	}
- 	for_each_online_node(i)
- 		setup_node_bootmem(i, nodes[i].start, nodes[i].end);
- 	numa_init_array();
- 	return 0;
+    int i;
+    struct node nodes[MAX_NUMNODES];
+    u64 sz = ((end_pfn - start_pfn)<<PAGE_SHIFT) / numa_fake;
+
+    /* Kludge needed for the hash function */
+    if (hweight64(sz) > 1) {
+        u64 x = 1;
+        while ((x << 1) < sz)
+            x <<= 1;
+        if (x < sz/2)
+            printk(KERN_ERR "Numa emulation unbalanced. Complain to maintainer\n");
+        sz = x;
+    }
+
+    memset(&nodes,0,sizeof(nodes));
+    for (i = 0; i < numa_fake; i++) {
+        nodes[i].start = (start_pfn<<PAGE_SHIFT) + i*sz;
+        if (i == numa_fake-1)
+            sz = (end_pfn<<PAGE_SHIFT) - nodes[i].start;
+        nodes[i].end = nodes[i].start + sz;
+        printk(KERN_INFO "Faking node %d at %"PRIx64"-%"PRIx64" (%"PRIu64"MB)\n",
+               i,
+               nodes[i].start, nodes[i].end,
+               (nodes[i].end - nodes[i].start) >> 20);
+        node_set_online(i);
+    }
+    memnode_shift = compute_hash_shift(nodes, numa_fake, NULL);
+    if (memnode_shift < 0) {
+        memnode_shift = 0;
+        printk(KERN_ERR "No NUMA hash function found. Emulation disabled.\n");
+        return -1;
+    }
+    for_each_online_node(i)
+        setup_node_bootmem(i, nodes[i].start, nodes[i].end);
+    numa_init_array();
+    return 0;
 }
 #endif
 
 void __init numa_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
 { 
-	int i;
+    int i;
 
 #ifdef CONFIG_NUMA_EMU
-	if (numa_fake && !numa_emulation(start_pfn, end_pfn))
-		return;
+    if (numa_fake && !numa_emulation(start_pfn, end_pfn))
+        return;
 #endif
 
 #ifdef CONFIG_ACPI_NUMA
-	if (!numa_off && !acpi_scan_nodes((u64)start_pfn << PAGE_SHIFT,
-					  (u64)end_pfn << PAGE_SHIFT))
-		return;
+    if (!numa_off && !acpi_scan_nodes((u64)start_pfn << PAGE_SHIFT,
+                      (u64)end_pfn << PAGE_SHIFT))
+        return;
 #endif
 
-	printk(KERN_INFO "%s\n",
-	       numa_off ? "NUMA turned off" : "No NUMA configuration found");
-
-	printk(KERN_INFO "Faking a node at %016"PRIx64"-%016"PRIx64"\n",
-	       (u64)start_pfn << PAGE_SHIFT,
-	       (u64)end_pfn << PAGE_SHIFT);
-	/* setup dummy node covering all memory */ 
-	memnode_shift = BITS_PER_LONG - 1;
-	memnodemap = _memnodemap;
-	nodes_clear(node_online_map);
-	node_set_online(0);
-	for (i = 0; i < nr_cpu_ids; i++)
-		numa_set_node(i, 0);
-	cpumask_copy(&node_to_cpumask[0], cpumask_of(0));
-	setup_node_bootmem(0, (u64)start_pfn << PAGE_SHIFT, (u64)end_pfn << PAGE_SHIFT);
+    printk(KERN_INFO "%s\n",
+           numa_off ? "NUMA turned off" : "No NUMA configuration found");
+
+    printk(KERN_INFO "Faking a node at %016"PRIx64"-%016"PRIx64"\n",
+           (u64)start_pfn << PAGE_SHIFT,
+           (u64)end_pfn << PAGE_SHIFT);
+    /* setup dummy node covering all memory */
+    memnode_shift = BITS_PER_LONG - 1;
+    memnodemap = _memnodemap;
+    nodes_clear(node_online_map);
+    node_set_online(0);
+    for (i = 0; i < nr_cpu_ids; i++)
+        numa_set_node(i, 0);
+    cpumask_copy(&node_to_cpumask[0], cpumask_of(0));
+    setup_node_bootmem(0, (u64)start_pfn << PAGE_SHIFT, (u64)end_pfn << PAGE_SHIFT);
 }
 
 __cpuinit void numa_add_cpu(int cpu)
 {
-	cpumask_set_cpu(cpu, &node_to_cpumask[cpu_to_node(cpu)]);
+    cpumask_set_cpu(cpu, &node_to_cpumask[cpu_to_node(cpu)]);
 } 
 
 void __cpuinit numa_set_node(int cpu, int node)
 {
-	cpu_to_node[cpu] = node;
+    cpu_to_node[cpu] = node;
 }
 
 /* [numa=off] */
 static __init int numa_setup(char *opt) 
 { 
-	if (!strncmp(opt,"off",3))
-		numa_off = 1;
-	if (!strncmp(opt,"on",2))
-		numa_off = 0;
+    if (!strncmp(opt,"off",3))
+        numa_off = 1;
+    if (!strncmp(opt,"on",2))
+        numa_off = 0;
 #ifdef CONFIG_NUMA_EMU
-	if(!strncmp(opt, "fake=", 5)) {
-		numa_off = 0;
-		numa_fake = simple_strtoul(opt+5,NULL,0); ;
-		if (numa_fake >= MAX_NUMNODES)
-			numa_fake = MAX_NUMNODES;
-	}
+    if(!strncmp(opt, "fake=", 5)) {
+        numa_off = 0;
+        numa_fake = simple_strtoul(opt+5,NULL,0); ;
+        if (numa_fake >= MAX_NUMNODES)
+            numa_fake = MAX_NUMNODES;
+    }
 #endif
 #ifdef CONFIG_ACPI_NUMA
-	if (!strncmp(opt,"noacpi",6)) {
-		numa_off = 0;
-		acpi_numa = -1;
-	}
+    if (!strncmp(opt,"noacpi",6)) {
+        numa_off = 0;
+        acpi_numa = -1;
+    }
 #endif
-	return 1;
+    return 1;
 } 
 
 /*
@@ -326,16 +326,16 @@ static __init int numa_setup(char *opt)
  */
 void __init init_cpu_to_node(void)
 {
-	int i, node;
- 	for (i = 0; i < nr_cpu_ids; i++) {
-		u32 apicid = x86_cpu_to_apicid[i];
-		if (apicid == BAD_APICID)
-			continue;
-		node = apicid_to_node[apicid];
-		if ( node == NUMA_NO_NODE || !node_online(node) )
-			node = 0;
-		numa_set_node(i, node);
-	}
+    int i, node;
+    for (i = 0; i < nr_cpu_ids; i++) {
+        u32 apicid = x86_cpu_to_apicid[i];
+        if (apicid == BAD_APICID)
+            continue;
+        node = apicid_to_node[apicid];
+        if ( node == NUMA_NO_NODE || !node_online(node) )
+            node = 0;
+        numa_set_node(i, node);
+    }
 }
 
 EXPORT_SYMBOL(cpu_to_node);
@@ -346,64 +346,64 @@ EXPORT_SYMBOL(node_data);
 
 static void dump_numa(unsigned char key)
 {
-	s_time_t now = NOW();
-	int i;
-	struct domain *d;
-	struct page_info *page;
-	unsigned int page_num_node[MAX_NUMNODES];
-
-	printk("'%c' pressed -> dumping numa info (now-0x%X:%08X)\n", key,
-		  (u32)(now>>32), (u32)now);
-
-	for_each_online_node(i) {
-		paddr_t pa = (paddr_t)(NODE_DATA(i)->node_start_pfn + 1)<< PAGE_SHIFT;
-		printk("idx%d -> NODE%d start->%lu size->%lu free->%lu\n",
-			  i, NODE_DATA(i)->node_id,
-			  NODE_DATA(i)->node_start_pfn,
-			  NODE_DATA(i)->node_spanned_pages,
-			  avail_node_heap_pages(i));
-		/* sanity check phys_to_nid() */
-		printk("phys_to_nid(%"PRIpaddr") -> %d should be %d\n", pa, phys_to_nid(pa),
-			  NODE_DATA(i)->node_id);
-	}
-	for_each_online_cpu(i)
-		printk("CPU%d -> NODE%d\n", i, cpu_to_node[i]);
-
-	rcu_read_lock(&domlist_read_lock);
-
-	printk("Memory location of each domain:\n");
-	for_each_domain(d)
-	{
-		printk("Domain %u (total: %u):\n", d->domain_id, d->tot_pages);
-
-		for_each_online_node(i)
-			page_num_node[i] = 0;
-
-		spin_lock(&d->page_alloc_lock);
-		page_list_for_each(page, &d->page_list)
-		{
-			i = phys_to_nid((paddr_t)page_to_mfn(page) << PAGE_SHIFT);
-			page_num_node[i]++;
-		}
-		spin_unlock(&d->page_alloc_lock);
-
-		for_each_online_node(i)
-			printk("    Node %u: %u\n", i, page_num_node[i]);
-	}
-
-	rcu_read_unlock(&domlist_read_lock);
+    s_time_t now = NOW();
+    int i;
+    struct domain *d;
+    struct page_info *page;
+    unsigned int page_num_node[MAX_NUMNODES];
+
+    printk("'%c' pressed -> dumping numa info (now-0x%X:%08X)\n", key,
+          (u32)(now>>32), (u32)now);
+
+    for_each_online_node(i) {
+        paddr_t pa = (paddr_t)(NODE_DATA(i)->node_start_pfn + 1)<< PAGE_SHIFT;
+        printk("idx%d -> NODE%d start->%lu size->%lu free->%lu\n",
+              i, NODE_DATA(i)->node_id,
+              NODE_DATA(i)->node_start_pfn,
+              NODE_DATA(i)->node_spanned_pages,
+              avail_node_heap_pages(i));
+        /* sanity check phys_to_nid() */
+        printk("phys_to_nid(%"PRIpaddr") -> %d should be %d\n", pa, phys_to_nid(pa),
+              NODE_DATA(i)->node_id);
+    }
+    for_each_online_cpu(i)
+        printk("CPU%d -> NODE%d\n", i, cpu_to_node[i]);
+
+    rcu_read_lock(&domlist_read_lock);
+
+    printk("Memory location of each domain:\n");
+    for_each_domain(d)
+    {
+        printk("Domain %u (total: %u):\n", d->domain_id, d->tot_pages);
+
+        for_each_online_node(i)
+            page_num_node[i] = 0;
+
+        spin_lock(&d->page_alloc_lock);
+        page_list_for_each(page, &d->page_list)
+        {
+            i = phys_to_nid((paddr_t)page_to_mfn(page) << PAGE_SHIFT);
+            page_num_node[i]++;
+        }
+        spin_unlock(&d->page_alloc_lock);
+
+        for_each_online_node(i)
+            printk("    Node %u: %u\n", i, page_num_node[i]);
+    }
+
+    rcu_read_unlock(&domlist_read_lock);
 }
 
 static struct keyhandler dump_numa_keyhandler = {
-	.diagnostic = 1,
-	.u.fn = dump_numa,
-	.desc = "dump numa info"
+    .diagnostic = 1,
+    .u.fn = dump_numa,
+    .desc = "dump numa info"
 };
 
 static __init int register_numa_trigger(void)
 {
-	register_keyhandler('u', &dump_numa_keyhandler);
-	return 0;
+    register_keyhandler('u', &dump_numa_keyhandler);
+    return 0;
 }
 __initcall(register_numa_trigger);
 
-- 
1.7.10.4

Re: [PATCH] numa.c: use spaces instead of tabs

[Dario Faggioli]

[-- Attachment #1.1: Type: text/plain, Size: 2444 bytes --]

On mer, 2014-09-03 at 00:18 -0400, Elena Ufimtseva wrote:
> Signed-off-by: Elena Ufimtseva <ufimtseva@gmail.com>
> ---
>
I think the patch does what the subject says, i.e., converting tabs to
spaces, and does it right (I've only one question, see below).

However, does it make sense, while at it, to turn the file into a Xen's
code stile compliant one? Because, if yes, there are other things than
tabs-->spaces that needs fixing, I believe.

> --- a/xen/arch/x86/numa.c
> +++ b/xen/arch/x86/numa.c

> @@ -67,53 +67,53 @@ int srat_disabled(void)
>  static int __init populate_memnodemap(const struct node *nodes,
>                                        int numnodes, int shift, int *nodeids)
>  {
> -	unsigned long spdx, epdx;
> -	int i, res = -1;
> -
> -	memset(memnodemap, NUMA_NO_NODE, memnodemapsize * sizeof(*memnodemap));
> -	for (i = 0; i < numnodes; i++) {
> -		spdx = paddr_to_pdx(nodes[i].start);
> -		epdx = paddr_to_pdx(nodes[i].end - 1) + 1;
> -		if (spdx >= epdx)
> -			continue;
> -		if ((epdx >> shift) >= memnodemapsize)
> -			return 0;
> -		do {
> -			if (memnodemap[spdx >> shift] != NUMA_NO_NODE)
> -				return -1;
> -
> -			if (!nodeids)
> -				memnodemap[spdx >> shift] = i;
> -			else
> -				memnodemap[spdx >> shift] = nodeids[i];
> -
> -			spdx += (1UL << shift);
> -		} while (spdx < epdx);
> -		res = 1;
> -	}
> -	return res;
> +    unsigned long spdx, epdx;
> +    int i, res = -1;
> +
> +    memset(memnodemap, NUMA_NO_NODE, memnodemapsize * sizeof(*memnodemap));
> +    for (i = 0; i < numnodes; i++) {
>
For example here. In Xen's style, this would become something like:

    for ( i = 0; i < numnodes; i++ )
    {

And the same throughout all the for-s and if-s in the file.

>  /*
> @@ -121,83 +121,83 @@ static int __init allocate_cachealigned_memnodemap(void)
>   * maximum possible shift.
>   */
>  static int __init extract_lsb_from_nodes(const struct node *nodes,
> -					 int numnodes)
> +                     int numnodes)
>
Perhaps I am the one missing something here, but shouldn't this still be
aligned to the '(' above (through spaces, of course)?

Regards,
Dario

-- 
<<This happens because I choose it to happen!>> (Raistlin Majere)
-----------------------------------------------------------------
Dario Faggioli, Ph.D, http://about.me/dario.faggioli
Senior Software Engineer, Citrix Systems R&D Ltd., Cambridge (UK)


[-- Attachment #1.2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 181 bytes --]

[-- Attachment #2: Type: text/plain, Size: 126 bytes --]

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
http://lists.xen.org/xen-devel

Re: [PATCH] numa.c: use spaces instead of tabs

[Jan Beulich]

>>> On 03.09.14 at 11:52, <dario.faggioli@citrix.com> wrote:
> On mer, 2014-09-03 at 00:18 -0400, Elena Ufimtseva wrote:
>> Signed-off-by: Elena Ufimtseva <ufimtseva@gmail.com>
>> ---
>>
> I think the patch does what the subject says, i.e., converting tabs to
> spaces, and does it right (I've only one question, see below).
> 
> However, does it make sense, while at it, to turn the file into a Xen's
> code stile compliant one? Because, if yes, there are other things than
> tabs-->spaces that needs fixing, I believe.

Yes, indeed - we don't use a style like what results from this patch.

>> @@ -121,83 +121,83 @@ static int __init 
> allocate_cachealigned_memnodemap(void)
>>   * maximum possible shift.
>>   */
>>  static int __init extract_lsb_from_nodes(const struct node *nodes,
>> -					 int numnodes)
>> +                     int numnodes)
>>
> Perhaps I am the one missing something here, but shouldn't this still be
> aligned to the '(' above (through spaces, of course)?

Indeed it should.

Jan

Re: [PATCH] numa.c: use spaces instead of tabs

[Elena Ufimtseva]

On Wed, Sep 3, 2014 at 6:01 AM, Jan Beulich <JBeulich@suse.com> wrote:
>>>> On 03.09.14 at 11:52, <dario.faggioli@citrix.com> wrote:
>> On mer, 2014-09-03 at 00:18 -0400, Elena Ufimtseva wrote:
>>> Signed-off-by: Elena Ufimtseva <ufimtseva@gmail.com>
>>> ---
>>>
>> I think the patch does what the subject says, i.e., converting tabs to
>> spaces, and does it right (I've only one question, see below).
>>
>> However, does it make sense, while at it, to turn the file into a Xen's
>> code stile compliant one? Because, if yes, there are other things than
>> tabs-->spaces that needs fixing, I believe.
>
> Yes, indeed - we don't use a style like what results from this patch.
>
>>> @@ -121,83 +121,83 @@ static int __init
>> allocate_cachealigned_memnodemap(void)
>>>   * maximum possible shift.
>>>   */
>>>  static int __init extract_lsb_from_nodes(const struct node *nodes,
>>> -                                     int numnodes)
>>> +                     int numnodes)
>>>
>> Perhaps I am the one missing something here, but shouldn't this still be
>> aligned to the '(' above (through spaces, of course)?
>
> Indeed it should.
>
> Jan
>


Dario, Jan

True to that there are few other things that should be fixed in
regards to the style.

But about the tabs/spaces what patch attempt to change, as it says.

Jan, you say that such style is not used.. But numa.c uses tabs as
:set list shows and its not Xen style either.
Coding style says - 4 spaces for one level of indent. numa.c uses tabs
and sometimes space between tabs.

I am looking at the rest of the files in xen/arch/x86/ and see that
they have all same tab= 4 spaces for indentation.
for example see xen/arch/x86/domain.c.
I used this for vim to re-tab the file: set noai ts=4 sw=8 expandtab

Linux has 8 spaces for tabs.. So I am lost here.

-- 
Elena

Re: [PATCH] numa.c: use spaces instead of tabs

[Ian Campbell]

On Wed, 2014-09-03 at 07:59 -0400, Elena Ufimtseva wrote:
> On Wed, Sep 3, 2014 at 6:01 AM, Jan Beulich <JBeulich@suse.com> wrote:
> >>>> On 03.09.14 at 11:52, <dario.faggioli@citrix.com> wrote:
> >> On mer, 2014-09-03 at 00:18 -0400, Elena Ufimtseva wrote:
> >>> Signed-off-by: Elena Ufimtseva <ufimtseva@gmail.com>
> >>> ---
> >>>
> >> I think the patch does what the subject says, i.e., converting tabs to
> >> spaces, and does it right (I've only one question, see below).
> >>
> >> However, does it make sense, while at it, to turn the file into a Xen's
> >> code stile compliant one? Because, if yes, there are other things than
> >> tabs-->spaces that needs fixing, I believe.
> >
> > Yes, indeed - we don't use a style like what results from this patch.
> >
> >>> @@ -121,83 +121,83 @@ static int __init
> >> allocate_cachealigned_memnodemap(void)
> >>>   * maximum possible shift.
> >>>   */
> >>>  static int __init extract_lsb_from_nodes(const struct node *nodes,
> >>> -                                     int numnodes)
> >>> +                     int numnodes)
> >>>
> >> Perhaps I am the one missing something here, but shouldn't this still be
> >> aligned to the '(' above (through spaces, of course)?
> >
> > Indeed it should.
> >
> > Jan
> >
> 
> 
> Dario, Jan
> 
> True to that there are few other things that should be fixed in
> regards to the style.
> 
> But about the tabs/spaces what patch attempt to change, as it says.
> 
> Jan, you say that such style is not used.. But numa.c uses tabs as
> :set list shows and its not Xen style either.
> Coding style says - 4 spaces for one level of indent. numa.c uses tabs
> and sometimes space between tabs.
> 
> I am looking at the rest of the files in xen/arch/x86/ and see that
> they have all same tab= 4 spaces for indentation.
> for example see xen/arch/x86/domain.c.
> I used this for vim to re-tab the file: set noai ts=4 sw=8 expandtab

I think what Jan meant was that simply changing tabs->spaces did not
result in any valid coding style, since Xen style differs from the
result in other ways too (e.g. spacing inside the spaces surrounding
expressions). 

> Linux has 8 spaces for tabs.. So I am lost here.

Was numa.c imported from Linux? In such cases we often (try to) stick
with Linux style.

Ian.

Re: [PATCH] numa.c: use spaces instead of tabs

[Elena Ufimtseva]

On Wed, Sep 3, 2014 at 8:18 AM, Ian Campbell <Ian.Campbell@citrix.com> wrote:
> On Wed, 2014-09-03 at 07:59 -0400, Elena Ufimtseva wrote:
>> On Wed, Sep 3, 2014 at 6:01 AM, Jan Beulich <JBeulich@suse.com> wrote:
>> >>>> On 03.09.14 at 11:52, <dario.faggioli@citrix.com> wrote:
>> >> On mer, 2014-09-03 at 00:18 -0400, Elena Ufimtseva wrote:
>> >>> Signed-off-by: Elena Ufimtseva <ufimtseva@gmail.com>
>> >>> ---
>> >>>
>> >> I think the patch does what the subject says, i.e., converting tabs to
>> >> spaces, and does it right (I've only one question, see below).
>> >>
>> >> However, does it make sense, while at it, to turn the file into a Xen's
>> >> code stile compliant one? Because, if yes, there are other things than
>> >> tabs-->spaces that needs fixing, I believe.
>> >
>> > Yes, indeed - we don't use a style like what results from this patch.
>> >
>> >>> @@ -121,83 +121,83 @@ static int __init
>> >> allocate_cachealigned_memnodemap(void)
>> >>>   * maximum possible shift.
>> >>>   */
>> >>>  static int __init extract_lsb_from_nodes(const struct node *nodes,
>> >>> -                                     int numnodes)
>> >>> +                     int numnodes)
>> >>>
>> >> Perhaps I am the one missing something here, but shouldn't this still be
>> >> aligned to the '(' above (through spaces, of course)?
>> >
>> > Indeed it should.
>> >
>> > Jan
>> >
>>
>>
>> Dario, Jan
>>
>> True to that there are few other things that should be fixed in
>> regards to the style.
>>
>> But about the tabs/spaces what patch attempt to change, as it says.
>>
>> Jan, you say that such style is not used.. But numa.c uses tabs as
>> :set list shows and its not Xen style either.
>> Coding style says - 4 spaces for one level of indent. numa.c uses tabs
>> and sometimes space between tabs.
>>
>> I am looking at the rest of the files in xen/arch/x86/ and see that
>> they have all same tab= 4 spaces for indentation.
>> for example see xen/arch/x86/domain.c.
>> I used this for vim to re-tab the file: set noai ts=4 sw=8 expandtab
>
> I think what Jan meant was that simply changing tabs->spaces did not
> result in any valid coding style, since Xen style differs from the
> result in other ways too (e.g. spacing inside the spaces surrounding
> expressions).
>
>> Linux has 8 spaces for tabs.. So I am lost here.
>
> Was numa.c imported from Linux? In such cases we often (try to) stick
> with Linux style.

Ian, thanks for comment.

Well, tabs in that file are used for indents. And it is for linux or Xen style.
As to the rest of the code, I can change the style. The patch was just
replacing tabs :)

>
> Ian.
>
>



-- 
Elena

Re: [PATCH] numa.c: use spaces instead of tabs

[Jan Beulich]

>>> On 03.09.14 at 13:59, <ufimtseva@gmail.com> wrote:
> Jan, you say that such style is not used.. But numa.c uses tabs as
> :set list shows and its not Xen style either.
> Coding style says - 4 spaces for one level of indent. numa.c uses tabs
> and sometimes space between tabs.
> 
> I am looking at the rest of the files in xen/arch/x86/ and see that
> they have all same tab= 4 spaces for indentation.
> for example see xen/arch/x86/domain.c.
> I used this for vim to re-tab the file: set noai ts=4 sw=8 expandtab
> 
> Linux has 8 spaces for tabs.. So I am lost here.

In a few files, original Linux style got retained, and we're accepting
that. See for example xen/arch/x86/cpu/. As a result, keeping the
file here as is would be fine (as indicated before); the only alternative
would be to fully switch it to Xen style.

Jan

Re: [PATCH] numa.c: use spaces instead of tabs

[Elena Ufimtseva]

On Wed, Sep 3, 2014 at 8:29 AM, Jan Beulich <JBeulich@suse.com> wrote:
>>>> On 03.09.14 at 13:59, <ufimtseva@gmail.com> wrote:
>> Jan, you say that such style is not used.. But numa.c uses tabs as
>> :set list shows and its not Xen style either.
>> Coding style says - 4 spaces for one level of indent. numa.c uses tabs
>> and sometimes space between tabs.
>>
>> I am looking at the rest of the files in xen/arch/x86/ and see that
>> they have all same tab= 4 spaces for indentation.
>> for example see xen/arch/x86/domain.c.
>> I used this for vim to re-tab the file: set noai ts=4 sw=8 expandtab
>>
>> Linux has 8 spaces for tabs.. So I am lost here.
>
> In a few files, original Linux style got retained, and we're accepting
> that. See for example xen/arch/x86/cpu/. As a result, keeping the
> file here as is would be fine (as indicated before); the only alternative
> would be to fully switch it to Xen style.
>
> Jan
>

Jan

I understand that, but that style is mixed. Not linux, not Xen :)
And tabs also do not make it look like linux.
But I got your point I think. Or leave it as it is (with tabs), or
change it to Xen style.

-- 
Elena

Re: [PATCH] numa.c: use spaces instead of tabs

[Jan Beulich]

>>> On 03.09.14 at 14:34, <ufimtseva@gmail.com> wrote:
> I understand that, but that style is mixed. Not linux, not Xen :)

Yeah, mistakes like that creep in. But we're trying to avoid them
(perhaps harder now than a few years ago).

Jan

Re: [PATCH] numa.c: use spaces instead of tabs

[Don Slutz]

[-- Attachment #1: Type: text/plain, Size: 2699 bytes --]

On 09/03/14 08:40, Jan Beulich wrote:
>>>> On 03.09.14 at 14:34, <ufimtseva@gmail.com> wrote:
>> I understand that, but that style is mixed. Not linux, not Xen :)
> Yeah, mistakes like that creep in. But we're trying to avoid them
> (perhaps harder now than a few years ago).
>
> Jan

I have attempted to get Xen coding style (not libxl coding style) into
a more automated process.

Using astyle (Artistic Style Version 2.04), the attached astyle options 
file does a
lot of the work.

    dcs-xen-54:~/xen>astyle --options=/home/don/xen.astylerc 
xen/arch/x86/hvm/vmware/vmport_rpc.c
    Formatted  xen/arch/x86/hvm/vmware/vmport_rpc.c
    dcs-xen-54:~/xen>emacs -nw /home/don/xen_reformat.el 
xen/arch/x86/hvm/vmware/vmport_rpc.c

However it does not support the:

    Space characters are used to spread out logical statements, ...

And so I use the emacs extension xen-reformat-region (also attached)
to post process the file, and adjust to the Xen style.  This only works
if the emacs local variables comment (See CODING_STYLE) is there.

Using this on xen/arch/x86/numa.c (and asking git to ignore white space
changes) gives me:

dcs-xen-54:~/xen>git diff -w
diff --git a/xen/arch/x86/numa.c b/xen/arch/x86/numa.c
index 628a40a..35ce32c 100644
--- a/xen/arch/x86/numa.c
+++ b/xen/arch/x86/numa.c
@@ -35,13 +35,15 @@ static typeof(*memnodemap) _memnodemap[64];
  unsigned long memnodemapsize;
  u8 *memnodemap;

-unsigned char cpu_to_node[NR_CPUS] __read_mostly = {
+unsigned char cpu_to_node[NR_CPUS] __read_mostly =
+{
      [0 ... NR_CPUS - 1] = NUMA_NO_NODE
  };
  /*
   * Keep BIOS's CPU2node information, should not be used for memory 
allocaion
   */
-unsigned char apicid_to_node[MAX_LOCAL_APIC] __cpuinitdata = {
+unsigned char apicid_to_node[MAX_LOCAL_APIC] __cpuinitdata =
+{
      [0 ... MAX_LOCAL_APIC - 1] = NUMA_NO_NODE
  };
  cpumask_t node_to_cpumask[MAX_NUMNODES] __read_mostly;
@@ -413,7 +415,8 @@ static void dump_numa(unsigned char key)
      rcu_read_unlock(&domlist_read_lock);
  }

-static struct keyhandler dump_numa_keyhandler = {
+static struct keyhandler dump_numa_keyhandler =
+{
      .diagnostic = 1,
      .u.fn = dump_numa,
      .desc = "dump numa info"
@@ -426,3 +429,11 @@ static __init int register_numa_trigger(void)
  }
  __initcall(register_numa_trigger);

+/*
+ * Local variables:
+ * mode: C
+ * c-file-style: "BSD"
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */

The attached zz.txt file the full git diff output.  If there are coding 
styles left
I would like to know about them.


    -Don Slutz

>
> _______________________________________________
> Xen-devel mailing list
> Xen-devel@lists.xen.org
> http://lists.xen.org/xen-devel


[-- Attachment #2: xen.astylerc --]
[-- Type: text/plain, Size: 838 bytes --]

#
# Default is mostly allman / ansi / bsd / break
#
style=bsd
#
# Converts tabs into single spaces.
#
convert-tabs
#
# indent using spaces by 4
#
indent=spaces=4
#
# Do preprocessor statements also.
#
indent-preproc-define
#
# Insert space padding around operators only.
#
pad-oper
#
# Insert space padding after paren headers only.
#
pad-header
#
# Remove extra space padding around parenthesis on the inside and outside.
#
unpad-paren
#
# Remove brackets from 1 line conditional statements.
#
remove-brackets
#
# Attach a pointer or reference operator to variable name
#
align-pointer=name
#
# Do not change the reference alignment.
#
align-reference=none
#
# The option max-code-length will break a line
#
max-code-length=80
#
# Set the minimal indent that is added when a header is built of multiple lines.
#
min-conditional-indent=0

[-- Attachment #3: xen_reformat.el --]
[-- Type: text/x-emacs-lisp, Size: 2368 bytes --]

(defun xen-reformat-region ()
  "Adjust region based on xen/CODING_STYLE."
  (interactive "")
  (save-excursion
    (let ((start (point))
	  (end (mark))
	  (case-fold-search nil)
	 )
      (if (not end)
	  (setq end (point-max))
      )
      (if (< end start)
	  (progn
	    (setq start (mark))
	    (setq end (point))
	  )
      )
      (goto-char start)
      (while (word-search-forward "if" end t)
	(if (looking-at "(") (insert-char ?  1) )
	(if (looking-at " ") (just-one-space) )
	(if (looking-at "(")
	    (progn
	      (forward-char)
	      (insert-char ?  1)
	      (just-one-space)
	      (backward-char 2)
	      (forward-sexp)
	      (backward-char 1)
	      (insert-char ?  1)
	      (just-one-space)
	    )
	)
      )
      (goto-char start)
      (while (word-search-forward "while" end t)
	(if (looking-at "(") (insert-char ?  1) )
	(if (looking-at " ") (just-one-space) )
	(if (looking-at "(")
	    (progn
	      (forward-char)
	      (insert-char ?  1)
	      (just-one-space)
	      (backward-char 2)
	      (forward-sexp)
	      (backward-char 1)
	      (insert-char ?  1)
	      (just-one-space)
	    )
	)
      )
      (goto-char start)
      (while (word-search-forward "for" end t)
	(if (looking-at "(") (insert-char ?  1) )
	(if (looking-at " ") (just-one-space) )
	(if (looking-at "(")
	    (progn
	      (forward-char)
	      (insert-char ?  1)
	      (just-one-space)
	      (backward-char 2)
	      (forward-sexp)
	      (backward-char 1)
	      (insert-char ?  1)
	      (just-one-space)
	    )
	)
      )
      (goto-char start)
      (while (word-search-forward "switch" end t)
	(if (looking-at "(") (insert-char ?  1) )
	(if (looking-at " ") (just-one-space) )
	(if (looking-at "(")
	    (progn
	      (forward-char)
	      (insert-char ?  1)
	      (just-one-space)
	      (backward-char 2)
	      (forward-sexp)
	      (backward-char 1)
	      (insert-char ?  1)
	      (just-one-space)
	    )
	)
      )
      (goto-char start)
      (while (word-search-forward "do" end t)
	(if (eolp) (delete-char 1) )
	(if (looking-at "(") (insert-char ?  1) )
	(if (looking-at " ") (just-one-space) )
	(if (looking-at "{")
	    (progn
	      (forward-sexp)
	      (if (eolp)
		  (delete-char 1)
	      )
	      (insert-char ?  1)
	      (just-one-space)
	    )
	)
      )
      (indent-region start end)
      (untabify start end)
    )
  )
)

[-- Attachment #4: zz.txt --]
[-- Type: text/plain, Size: 7434 bytes --]

diff --git a/xen/arch/x86/numa.c b/xen/arch/x86/numa.c
index 628a40a..35ce32c 100644
--- a/xen/arch/x86/numa.c
+++ b/xen/arch/x86/numa.c
@@ -1,8 +1,8 @@
-/* 
+/*
  * Generic VM initialization for x86-64 NUMA setups.
  * Copyright 2002,2003 Andi Kleen, SuSE Labs.
  * Adapted for Xen: Ryan Harper <ryanh@us.ibm.com>
- */ 
+ */
 
 #include <xen/mm.h>
 #include <xen/string.h>
@@ -35,14 +35,16 @@ static typeof(*memnodemap) _memnodemap[64];
 unsigned long memnodemapsize;
 u8 *memnodemap;
 
-unsigned char cpu_to_node[NR_CPUS] __read_mostly = {
-    [0 ... NR_CPUS-1] = NUMA_NO_NODE
+unsigned char cpu_to_node[NR_CPUS] __read_mostly =
+{
+    [0 ... NR_CPUS - 1] = NUMA_NO_NODE
 };
 /*
  * Keep BIOS's CPU2node information, should not be used for memory allocaion
  */
-unsigned char apicid_to_node[MAX_LOCAL_APIC] __cpuinitdata = {
-    [0 ... MAX_LOCAL_APIC-1] = NUMA_NO_NODE
+unsigned char apicid_to_node[MAX_LOCAL_APIC] __cpuinitdata =
+{
+    [0 ... MAX_LOCAL_APIC - 1] = NUMA_NO_NODE
 };
 cpumask_t node_to_cpumask[MAX_NUMNODES] __read_mostly;
 
@@ -144,7 +146,7 @@ static int __init extract_lsb_from_nodes(const struct node *nodes,
     if ( nodes_used <= 1 )
         i = BITS_PER_LONG - 1;
     else
-        i = find_first_bit(&bitfield, sizeof(unsigned long)*8);
+        i = find_first_bit(&bitfield, sizeof(unsigned long) * 8);
     memnodemapsize = (memtop >> i) + 1;
     return i;
 }
@@ -173,7 +175,7 @@ int __init compute_hash_shift(struct node *nodes, int numnodes,
 }
 /* initialize NODE_DATA given nodeid and start/end */
 void __init setup_node_bootmem(int nodeid, u64 start, u64 end)
-{ 
+{
     unsigned long start_pfn, end_pfn;
 
     start_pfn = start >> PAGE_SHIFT;
@@ -184,7 +186,7 @@ void __init setup_node_bootmem(int nodeid, u64 start, u64 end)
     NODE_DATA(nodeid)->node_spanned_pages = end_pfn - start_pfn;
 
     node_set_online(nodeid);
-} 
+}
 
 void __init numa_init_array(void)
 {
@@ -215,7 +217,7 @@ static int __init numa_emulation(u64 start_pfn, u64 end_pfn)
 {
     int i;
     struct node nodes[MAX_NUMNODES];
-    u64 sz = ((end_pfn - start_pfn)<<PAGE_SHIFT) / numa_fake;
+    u64 sz = ((end_pfn - start_pfn) << PAGE_SHIFT) / numa_fake;
 
     /* Kludge needed for the hash function */
     if ( hweight64(sz) > 1 )
@@ -223,17 +225,17 @@ static int __init numa_emulation(u64 start_pfn, u64 end_pfn)
         u64 x = 1;
         while ( (x << 1) < sz )
             x <<= 1;
-        if ( x < sz/2 )
+        if ( x < sz / 2 )
             printk(KERN_ERR "Numa emulation unbalanced. Complain to maintainer\n");
         sz = x;
     }
 
-    memset(&nodes,0,sizeof(nodes));
+    memset(&nodes, 0, sizeof(nodes));
     for ( i = 0; i < numa_fake; i++ )
     {
-        nodes[i].start = (start_pfn<<PAGE_SHIFT) + i*sz;
+        nodes[i].start = (start_pfn << PAGE_SHIFT) + i * sz;
         if ( i == numa_fake - 1 )
-            sz = (end_pfn<<PAGE_SHIFT) - nodes[i].start;
+            sz = (end_pfn << PAGE_SHIFT) - nodes[i].start;
         nodes[i].end = nodes[i].start + sz;
         printk(KERN_INFO "Faking node %d at %"PRIx64"-%"PRIx64" (%"PRIu64"MB)\n",
                i,
@@ -248,7 +250,7 @@ static int __init numa_emulation(u64 start_pfn, u64 end_pfn)
         printk(KERN_ERR "No NUMA hash function found. Emulation disabled.\n");
         return -1;
     }
-    for_each_online_node ( i )
+    for_each_online_node(i)
         setup_node_bootmem(i, nodes[i].start, nodes[i].end);
     numa_init_array();
 
@@ -257,7 +259,7 @@ static int __init numa_emulation(u64 start_pfn, u64 end_pfn)
 #endif
 
 void __init numa_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
-{ 
+{
     int i;
 
 #ifdef CONFIG_NUMA_EMU
@@ -267,7 +269,7 @@ void __init numa_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
 
 #ifdef CONFIG_ACPI_NUMA
     if ( !numa_off && !acpi_scan_nodes((u64)start_pfn << PAGE_SHIFT,
-         (u64)end_pfn << PAGE_SHIFT) )
+                                       (u64)end_pfn << PAGE_SHIFT) )
         return;
 #endif
 
@@ -286,13 +288,13 @@ void __init numa_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
         numa_set_node(i, 0);
     cpumask_copy(&node_to_cpumask[0], cpumask_of(0));
     setup_node_bootmem(0, (u64)start_pfn << PAGE_SHIFT,
-                    (u64)end_pfn << PAGE_SHIFT);
+                       (u64)end_pfn << PAGE_SHIFT);
 }
 
 __cpuinit void numa_add_cpu(int cpu)
 {
     cpumask_set_cpu(cpu, &node_to_cpumask[cpu_to_node(cpu)]);
-} 
+}
 
 void __cpuinit numa_set_node(int cpu, int node)
 {
@@ -300,23 +302,23 @@ void __cpuinit numa_set_node(int cpu, int node)
 }
 
 /* [numa=off] */
-static __init int numa_setup(char *opt) 
-{ 
-    if ( !strncmp(opt,"off",3) )
+static __init int numa_setup(char *opt)
+{
+    if ( !strncmp(opt, "off", 3) )
         numa_off = 1;
-    if ( !strncmp(opt,"on",2) )
+    if ( !strncmp(opt, "on", 2) )
         numa_off = 0;
 #ifdef CONFIG_NUMA_EMU
     if ( !strncmp(opt, "fake=", 5) )
     {
         numa_off = 0;
-        numa_fake = simple_strtoul(opt+5,NULL,0);
+        numa_fake = simple_strtoul(opt + 5, NULL, 0);
         if ( numa_fake >= MAX_NUMNODES )
             numa_fake = MAX_NUMNODES;
     }
 #endif
 #ifdef CONFIG_ACPI_NUMA
-    if ( !strncmp(opt,"noacpi",6) )
+    if ( !strncmp(opt, "noacpi", 6) )
     {
         numa_off = 0;
         acpi_numa = -1;
@@ -324,7 +326,7 @@ static __init int numa_setup(char *opt)
 #endif
 
     return 1;
-} 
+}
 
 /*
  * Setup early cpu_to_node.
@@ -369,11 +371,11 @@ static void dump_numa(unsigned char key)
     unsigned int page_num_node[MAX_NUMNODES];
 
     printk("'%c' pressed -> dumping numa info (now-0x%X:%08X)\n", key,
-           (u32)(now>>32), (u32)now);
+           (u32)(now >> 32), (u32)now);
 
-    for_each_online_node ( i )
+    for_each_online_node(i)
     {
-        paddr_t pa = (paddr_t)(NODE_DATA(i)->node_start_pfn + 1)<< PAGE_SHIFT;
+        paddr_t pa = (paddr_t)(NODE_DATA(i)->node_start_pfn + 1) << PAGE_SHIFT;
         printk("idx%d -> NODE%d start->%lu size->%lu free->%lu\n",
                i, NODE_DATA(i)->node_id,
                NODE_DATA(i)->node_start_pfn,
@@ -385,17 +387,17 @@ static void dump_numa(unsigned char key)
                NODE_DATA(i)->node_id);
     }
 
-    for_each_online_cpu ( i )
+    for_each_online_cpu(i)
         printk("CPU%d -> NODE%d\n", i, cpu_to_node[i]);
 
     rcu_read_lock(&domlist_read_lock);
 
     printk("Memory location of each domain:\n");
-    for_each_domain ( d )
+    for_each_domain(d)
     {
         printk("Domain %u (total: %u):\n", d->domain_id, d->tot_pages);
 
-        for_each_online_node ( i )
+        for_each_online_node(i)
             page_num_node[i] = 0;
 
         spin_lock(&d->page_alloc_lock);
@@ -406,14 +408,15 @@ static void dump_numa(unsigned char key)
         }
         spin_unlock(&d->page_alloc_lock);
 
-        for_each_online_node ( i )
+        for_each_online_node(i)
             printk("    Node %u: %u\n", i, page_num_node[i]);
     }
 
     rcu_read_unlock(&domlist_read_lock);
 }
 
-static struct keyhandler dump_numa_keyhandler = {
+static struct keyhandler dump_numa_keyhandler =
+{
     .diagnostic = 1,
     .u.fn = dump_numa,
     .desc = "dump numa info"
@@ -426,3 +429,11 @@ static __init int register_numa_trigger(void)
 }
 __initcall(register_numa_trigger);
 
+/*
+ * Local variables:
+ * mode: C
+ * c-file-style: "BSD"
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */

[-- Attachment #5: Type: text/plain, Size: 126 bytes --]

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
http://lists.xen.org/xen-devel

Re: [PATCH] numa.c: use spaces instead of tabs

[Jan Beulich]

>>> On 06.09.14 at 19:28, <dslutz@verizon.com> wrote:
> Using this on xen/arch/x86/numa.c (and asking git to ignore white space
> changes) gives me:
> 
> dcs-xen-54:~/xen>git diff -w
> diff --git a/xen/arch/x86/numa.c b/xen/arch/x86/numa.c
> index 628a40a..35ce32c 100644
> --- a/xen/arch/x86/numa.c
> +++ b/xen/arch/x86/numa.c
> @@ -35,13 +35,15 @@ static typeof(*memnodemap) _memnodemap[64];
>   unsigned long memnodemapsize;
>   u8 *memnodemap;
> 
> -unsigned char cpu_to_node[NR_CPUS] __read_mostly = {
> +unsigned char cpu_to_node[NR_CPUS] __read_mostly =
> +{
>       [0 ... NR_CPUS - 1] = NUMA_NO_NODE
>   };
>   /*
>    * Keep BIOS's CPU2node information, should not be used for memory allocaion
>    */
> -unsigned char apicid_to_node[MAX_LOCAL_APIC] __cpuinitdata = {
> +unsigned char apicid_to_node[MAX_LOCAL_APIC] __cpuinitdata =
> +{
>       [0 ... MAX_LOCAL_APIC - 1] = NUMA_NO_NODE
>   };
>   cpumask_t node_to_cpumask[MAX_NUMNODES] __read_mostly;
> @@ -413,7 +415,8 @@ static void dump_numa(unsigned char key)
>       rcu_read_unlock(&domlist_read_lock);
>   }
> 
> -static struct keyhandler dump_numa_keyhandler = {
> +static struct keyhandler dump_numa_keyhandler =
> +{
>       .diagnostic = 1,
>       .u.fn = dump_numa,
>       .desc = "dump numa info"

Except that I think on initializers we don't strictly require the { to
be on a separate line, albeit I admit that one can conclude either
way from ./CODING_STYLE.

Jan