ref: Rename shadowing variables

The Wshadow flag warns whenever a local variable or type declaration
shadows another variable (e.g., global variables)

Signed-off-by: Miguel Silva <[email protected]>

Author: miguelafsilva5

src/arch/armv8/armv8-a/iommu.c

@@ -69,16 +69,16 @@ inline bool iommu_arch_vm_add_device(struct vm* vm, streamid_t id)
     return iommu_vm_arch_add(vm, 0, id);
 }
 
-bool iommu_arch_vm_init(struct vm* vm, const struct vm_config* config)
+bool iommu_arch_vm_init(struct vm* vm, const struct vm_config* vm_config)
 {
     vm->io.prot.mmu.global_mask =
-        config->platform.arch.smmu.global_mask | platform.arch.smmu.global_mask;
+        vm_config->platform.arch.smmu.global_mask | platform.arch.smmu.global_mask;
     vm->io.prot.mmu.ctx_id = -1;
 
     /* This section relates only to arm's iommu so we parse it here. */
-    for (size_t i = 0; i < config->platform.arch.smmu.group_num; i++) {
+    for (size_t i = 0; i < vm_config->platform.arch.smmu.group_num; i++) {
         /* Register each group. */
-        const struct smmu_group* group = &config->platform.arch.smmu.groups[i];
+        const struct smmu_group* group = &vm_config->platform.arch.smmu.groups[i];
         if (!iommu_vm_arch_add(vm, group->mask, group->id)) {
             return false;
         }

src/arch/armv8/vm.c

@@ -9,10 +9,10 @@
 #include <string.h>
 #include <config.h>
 
-void vm_arch_init(struct vm* vm, const struct vm_config* config)
+void vm_arch_init(struct vm* vm, const struct vm_config* vm_config)
 {
     if (vm->master == cpu()->id) {
-        vgic_init(vm, &config->platform.arch.gic);
+        vgic_init(vm, &vm_config->platform.arch.gic);
     }
     cpu_sync_and_clear_msgs(&vm->sync);
 }

src/arch/riscv/iommu.c

@@ -484,10 +484,10 @@ inline bool iommu_arch_vm_add_device(struct vm* vm, deviceid_t dev_id)
  *
  * @returns true on success, false on error.
  */
-bool iommu_arch_vm_init(struct vm* vm, const struct vm_config* config)
+bool iommu_arch_vm_init(struct vm* vm, const struct vm_config* vm_config)
 {
     UNUSED_ARG(vm);
-    UNUSED_ARG(config);
+    UNUSED_ARG(vm_config);
 
     // For now there is no data to initialize
     return true;

src/arch/riscv/vm.c

@@ -11,7 +11,7 @@
 #include <string.h>
 #include <config.h>
 
-void vm_arch_init(struct vm* vm, const struct vm_config* config)
+void vm_arch_init(struct vm* vm, const struct vm_config* vm_config)
 {
     paddr_t root_pt_pa;
     mem_translate(&cpu()->as, (vaddr_t)vm->as.pt.root, &root_pt_pa);
@@ -21,7 +21,7 @@ void vm_arch_init(struct vm* vm, const struct vm_config* config)
 
     csrs_hgatp_write(hgatp);
 
-    virqc_init(vm, &config->platform.arch.irqc);
+    virqc_init(vm, &vm_config->platform.arch.irqc);
 }
 
 void vcpu_arch_init(struct vcpu* vcpu, struct vm* vm)

src/core/mmu/mem.c

@@ -145,7 +145,7 @@ bool pp_alloc_clr(struct page_pool* pool, size_t n, colormap_t colors, struct pp
              */
             ppages->num_pages = n;
             ppages->base = pool->base + (first_index * PAGE_SIZE);
-            for (size_t i = 0; i < n; i++) {
+            for (size_t j = 0; j < n; j++) {
                 first_index = pp_next_clr(pool->base, first_index, colors);
                 bitmap_set(pool->bitmap, first_index++);
             }
@@ -388,7 +388,7 @@ vaddr_t mem_alloc_vpage(struct addr_space* as, enum AS_SEC section, vaddr_t at,
     if (vpage != INVALID_VA && !failed) {
         count = 0;
         addr = vpage;
-        size_t lvl = 0;
+        lvl = 0;
         while (count < n) {
             for (lvl = 0; lvl < as->pt.dscr->lvls; lvl++) {
                 pte = pt_get_pte(&as->pt, lvl, addr);

src/core/mmu/vm.c

@@ -8,7 +8,7 @@
 #include <config.h>
 #include <mem.h>
 
-void vm_mem_prot_init(struct vm* vm, const struct vm_config* config)
+void vm_mem_prot_init(struct vm* vm, const struct vm_config* vm_config)
 {
-    as_init(&vm->as, AS_VM, vm->id, NULL, config->colors);
+    as_init(&vm->as, AS_VM, vm->id, NULL, vm_config->colors);
 }

src/core/vm.c

@@ -9,16 +9,16 @@
 #include <cache.h>
 #include <config.h>
 
-static void vm_master_init(struct vm* vm, const struct vm_config* config, vmid_t vm_id)
+static void vm_master_init(struct vm* vm, const struct vm_config* vm_config, vmid_t vm_id)
 {
     vm->master = cpu()->id;
-    vm->config = config;
-    vm->cpu_num = config->platform.cpu_num;
+    vm->config = vm_config;
+    vm->cpu_num = vm_config->platform.cpu_num;
     vm->id = vm_id;
 
     cpu_sync_init(&vm->sync, vm->cpu_num);
 
-    vm_mem_prot_init(vm, config);
+    vm_mem_prot_init(vm, vm_config);
 }
 
 static void vm_cpu_init(struct vm* vm)
@@ -39,7 +39,7 @@ static vcpuid_t vm_calc_vcpu_id(struct vm* vm)
     return vcpu_id;
 }
 
-static void vm_vcpu_init(struct vm* vm, const struct vm_config* config)
+static void vm_vcpu_init(struct vm* vm, const struct vm_config* vm_config)
 {
     vcpuid_t vcpu_id = vm_calc_vcpu_id(vm);
     struct vcpu* vcpu = vm_get_vcpu(vm, vcpu_id);
@@ -50,7 +50,7 @@ static void vm_vcpu_init(struct vm* vm, const struct vm_config* config)
     cpu()->vcpu = vcpu;
 
     vcpu_arch_init(vcpu, vm);
-    vcpu_arch_reset(vcpu, config->entry);
+    vcpu_arch_reset(vcpu, vm_config->entry);
 }
 
 static void vm_map_mem_region(struct vm* vm, struct vm_mem_region* reg)
@@ -73,11 +73,11 @@ static void vm_map_mem_region(struct vm* vm, struct vm_mem_region* reg)
     }
 }
 
-static void vm_map_img_rgn_inplace(struct vm* vm, const struct vm_config* config,
+static void vm_map_img_rgn_inplace(struct vm* vm, const struct vm_config* vm_config,
     struct vm_mem_region* reg)
 {
-    vaddr_t img_base = config->image.base_addr;
-    size_t img_size = config->image.size;
+    vaddr_t img_base = vm_config->image.base_addr;
+    size_t img_size = vm_config->image.size;
     /* mem region pages before the img */
     size_t n_before = NUM_PAGES(img_base - reg->base);
     /* pages after the img */
@@ -86,7 +86,7 @@ static void vm_map_img_rgn_inplace(struct vm* vm, const struct vm_config* config
     size_t n_img = NUM_PAGES(img_size);
 
     /* map img in place */
-    struct ppages pa_img = mem_ppages_get(config->image.load_addr, n_img);
+    struct ppages pa_img = mem_ppages_get(vm_config->image.load_addr, n_img);
 
     mem_alloc_map(&vm->as, SEC_VM_ANY, NULL, (vaddr_t)reg->base, n_before, PTE_VM_FLAGS);
     if (all_clrs(vm->as.colors)) {
@@ -135,36 +135,37 @@ static void vm_install_image(struct vm* vm, struct vm_mem_region* reg)
     mem_unmap(&cpu()->as, dst_va, img_num_pages, false);
 }
 
-static void vm_map_img_rgn(struct vm* vm, const struct vm_config* config, struct vm_mem_region* reg)
+static void vm_map_img_rgn(struct vm* vm, const struct vm_config* vm_config,
+    struct vm_mem_region* reg)
 {
-    if (!reg->place_phys && config->image.inplace) {
-        vm_map_img_rgn_inplace(vm, config, reg);
+    if (!reg->place_phys && vm_config->image.inplace) {
+        vm_map_img_rgn_inplace(vm, vm_config, reg);
     } else {
         vm_map_mem_region(vm, reg);
         vm_install_image(vm, reg);
     }
 }
 
-static void vm_init_mem_regions(struct vm* vm, const struct vm_config* config)
+static void vm_init_mem_regions(struct vm* vm, const struct vm_config* vm_config)
 {
-    for (size_t i = 0; i < config->platform.region_num; i++) {
-        struct vm_mem_region* reg = &config->platform.regions[i];
+    for (size_t i = 0; i < vm_config->platform.region_num; i++) {
+        struct vm_mem_region* reg = &vm_config->platform.regions[i];
         bool img_is_in_rgn =
-            range_in_range(config->image.base_addr, config->image.size, reg->base, reg->size);
+            range_in_range(vm_config->image.base_addr, vm_config->image.size, reg->base, reg->size);
         if (img_is_in_rgn) {
-            vm_map_img_rgn(vm, config, reg);
+            vm_map_img_rgn(vm, vm_config, reg);
         } else {
             vm_map_mem_region(vm, reg);
         }
     }
 }
 
-static void vm_init_ipc(struct vm* vm, const struct vm_config* config)
+static void vm_init_ipc(struct vm* vm, const struct vm_config* vm_config)
 {
-    vm->ipc_num = config->platform.ipc_num;
-    vm->ipcs = config->platform.ipcs;
-    for (size_t i = 0; i < config->platform.ipc_num; i++) {
-        struct ipc* ipc = &config->platform.ipcs[i];
+    vm->ipc_num = vm_config->platform.ipc_num;
+    vm->ipcs = vm_config->platform.ipcs;
+    for (size_t i = 0; i < vm_config->platform.ipc_num; i++) {
+        struct ipc* ipc = &vm_config->platform.ipcs[i];
         struct shmem* shmem = ipc_get_shmem(ipc->shmem_id);
         if (shmem == NULL) {
             WARNING("Invalid shmem id in configuration. Ignored.");
@@ -192,10 +193,10 @@ static void vm_init_ipc(struct vm* vm, const struct vm_config* config)
     }
 }
 
-static void vm_init_dev(struct vm* vm, const struct vm_config* config)
+static void vm_init_dev(struct vm* vm, const struct vm_config* vm_config)
 {
-    for (size_t i = 0; i < config->platform.dev_num; i++) {
-        struct vm_dev_region* dev = &config->platform.devs[i];
+    for (size_t i = 0; i < vm_config->platform.dev_num; i++) {
+        struct vm_dev_region* dev = &vm_config->platform.devs[i];
 
         size_t n = ALIGN(dev->size, PAGE_SIZE) / PAGE_SIZE;
 
@@ -210,9 +211,9 @@ static void vm_init_dev(struct vm* vm, const struct vm_config* config)
         }
     }
 
-    if (io_vm_init(vm, config)) {
-        for (size_t i = 0; i < config->platform.dev_num; i++) {
-            struct vm_dev_region* dev = &config->platform.devs[i];
+    if (io_vm_init(vm, vm_config)) {
+        for (size_t i = 0; i < vm_config->platform.dev_num; i++) {
+            struct vm_dev_region* dev = &vm_config->platform.devs[i];
             if (dev->id) {
                 if (!io_vm_add_device(vm, dev->id)) {
                     ERROR("Failed to add device to iommu");
@@ -229,7 +230,7 @@ static struct vm* vm_allocation_init(struct vm_allocation* vm_alloc)
     return vm;
 }
 
-struct vm* vm_init(struct vm_allocation* vm_alloc, const struct vm_config* config, bool master,
+struct vm* vm_init(struct vm_allocation* vm_alloc, const struct vm_config* vm_config, bool master,
     vmid_t vm_id)
 {
     struct vm* vm = vm_allocation_init(vm_alloc);
@@ -238,7 +239,7 @@ struct vm* vm_init(struct vm_allocation* vm_alloc, const struct vm_config* confi
      * Before anything else, initialize vm structure.
      */
     if (master) {
-        vm_master_init(vm, config, vm_id);
+        vm_master_init(vm, vm_config, vm_id);
     }
 
     /*
@@ -251,23 +252,23 @@ struct vm* vm_init(struct vm_allocation* vm_alloc, const struct vm_config* confi
     /*
      *  Initialize each virtual core.
      */
-    vm_vcpu_init(vm, config);
+    vm_vcpu_init(vm, vm_config);
 
     cpu_sync_barrier(&vm->sync);
 
     /**
      * Perform architecture dependent initializations. This includes, for example, setting the page
      * table pointer and other virtualization extensions specifics.
      */
-    vm_arch_init(vm, config);
+    vm_arch_init(vm, vm_config);
 
     /**
      * Create the VM's address space according to configuration and where its image was loaded.
      */
     if (master) {
-        vm_init_mem_regions(vm, config);
-        vm_init_dev(vm, config);
-        vm_init_ipc(vm, config);
+        vm_init_mem_regions(vm, vm_config);
+        vm_init_dev(vm, vm_config);
+        vm_init_ipc(vm, vm_config);
     }
 
     cpu_sync_and_clear_msgs(&vm->sync);

src/core/vmm.c

@@ -75,7 +75,7 @@ static bool vmm_assign_vcpu(bool* master, vmid_t* vm_id)
     return assigned;
 }
 
-static bool vmm_alloc_vm(struct vm_allocation* vm_alloc, struct vm_config* config)
+static bool vmm_alloc_vm(struct vm_allocation* vm_alloc, struct vm_config* vm_config)
 {
     /**
      * We know that we will allocate a block aligned to the PAGE_SIZE, which is guaranteed to
@@ -86,7 +86,7 @@ static bool vmm_alloc_vm(struct vm_allocation* vm_alloc, struct vm_config* confi
 
     size_t total_size = sizeof(struct vm);
     size_t vcpus_offset = ALIGN(total_size, _Alignof(struct vcpu));
-    total_size = vcpus_offset + (config->platform.cpu_num * sizeof(struct vcpu));
+    total_size = vcpus_offset + (vm_config->platform.cpu_num * sizeof(struct vcpu));
     total_size = ALIGN(total_size, PAGE_SIZE);
 
     void* allocation = mem_alloc_page(NUM_PAGES(total_size), SEC_HYP_VM, false);