From a75becab204e8af9e9f0b0939dad118b3e44b895 Mon Sep 17 00:00:00 2001 From: Alex Waterman Date: Mon, 20 Aug 2018 14:35:29 -0700 Subject: gpu: nvgpu: Fix MISRA 21.2 violations [2/3] MISRA 21.2 states that we may not use reserved identifiers; since all identifiers beginning with '_' are reserved by libc, the usage of '__' as a prefix is disallowed. This change removes the usage of the '__a' argument scattered throughout the nvgpu allocator code. JIRA NVGPU-1029 Change-Id: Ic39213ab800e92c6815ce5b9deb22520aa6d0630 Signed-off-by: Alex Waterman Reviewed-on: https://git-master.nvidia.com/r/1803352 Reviewed-by: mobile promotions Tested-by: mobile promotions --- drivers/gpu/nvgpu/common/mm/buddy_allocator.c | 152 +++++++++++++------------- drivers/gpu/nvgpu/include/nvgpu/allocator.h | 4 +- 2 files changed, 78 insertions(+), 78 deletions(-) (limited to 'drivers/gpu/nvgpu') diff --git a/drivers/gpu/nvgpu/common/mm/buddy_allocator.c b/drivers/gpu/nvgpu/common/mm/buddy_allocator.c index f8c97839..e684e637 100644 --- a/drivers/gpu/nvgpu/common/mm/buddy_allocator.c +++ b/drivers/gpu/nvgpu/common/mm/buddy_allocator.c @@ -255,18 +255,18 @@ cleanup: /* * Clean up and destroy the passed allocator. */ -static void nvgpu_buddy_allocator_destroy(struct nvgpu_allocator *__a) +static void nvgpu_buddy_allocator_destroy(struct nvgpu_allocator *na) { int i; struct nvgpu_rbtree_node *node = NULL; struct nvgpu_buddy *bud; struct nvgpu_fixed_alloc *falloc; - struct nvgpu_buddy_allocator *a = __a->priv; + struct nvgpu_buddy_allocator *a = na->priv; - alloc_lock(__a); + alloc_lock(na); #ifdef CONFIG_DEBUG_FS - nvgpu_fini_alloc_debug(__a); + nvgpu_fini_alloc_debug(na); #endif /* @@ -311,19 +311,19 @@ static void nvgpu_buddy_allocator_destroy(struct nvgpu_allocator *__a) } if (a->buddy_list_len[i] != 0) { - nvgpu_info(__a->g, + nvgpu_info(na->g, "Excess buddies!!! (%d: %llu)", i, a->buddy_list_len[i]); BUG(); } if (a->buddy_list_split[i] != 0) { - nvgpu_info(__a->g, + nvgpu_info(na->g, "Excess split nodes!!! (%d: %llu)", i, a->buddy_list_split[i]); BUG(); } if (a->buddy_list_alloced[i] != 0) { - nvgpu_info(__a->g, + nvgpu_info(na->g, "Excess alloced nodes!!! (%d: %llu)", i, a->buddy_list_alloced[i]); BUG(); @@ -331,9 +331,9 @@ static void nvgpu_buddy_allocator_destroy(struct nvgpu_allocator *__a) } nvgpu_kmem_cache_destroy(a->buddy_cache); - nvgpu_kfree(nvgpu_alloc_to_gpu(__a), a); + nvgpu_kfree(nvgpu_alloc_to_gpu(na), a); - alloc_unlock(__a); + alloc_unlock(na); } /* @@ -814,18 +814,18 @@ static void __balloc_do_free_fixed(struct nvgpu_buddy_allocator *a, /* * Allocate memory from the passed allocator. */ -static u64 nvgpu_buddy_balloc(struct nvgpu_allocator *__a, u64 len) +static u64 nvgpu_buddy_balloc(struct nvgpu_allocator *na, u64 len) { u64 order, addr; int pte_size; - struct nvgpu_buddy_allocator *a = __a->priv; + struct nvgpu_buddy_allocator *a = na->priv; - alloc_lock(__a); + alloc_lock(na); order = balloc_get_order(a, len); if (order > a->max_order) { - alloc_unlock(__a); + alloc_unlock(na); alloc_dbg(balloc_owner(a), "Alloc fail"); return 0; } @@ -853,22 +853,22 @@ static u64 nvgpu_buddy_balloc(struct nvgpu_allocator *__a, u64 len) a->alloc_made = 1; - alloc_unlock(__a); + alloc_unlock(na); return addr; } /* - * Requires @__a to be locked. + * Requires @na to be locked. */ -static u64 __nvgpu_balloc_fixed_buddy(struct nvgpu_allocator *__a, +static u64 __nvgpu_balloc_fixed_buddy(struct nvgpu_allocator *na, u64 base, u64 len, u32 page_size) { int pte_size = BALLOC_PTE_SIZE_ANY; u64 ret, real_bytes = 0; struct nvgpu_buddy *bud; struct nvgpu_fixed_alloc *falloc = NULL; - struct nvgpu_buddy_allocator *a = __a->priv; + struct nvgpu_buddy_allocator *a = na->priv; /* If base isn't aligned to an order 0 block, fail. */ if (base & (a->blk_size - 1)) { @@ -890,7 +890,7 @@ static u64 __nvgpu_balloc_fixed_buddy(struct nvgpu_allocator *__a, } } - falloc = nvgpu_kmalloc(nvgpu_alloc_to_gpu(__a), sizeof(*falloc)); + falloc = nvgpu_kmalloc(nvgpu_alloc_to_gpu(na), sizeof(*falloc)); if (!falloc) { goto fail; } @@ -929,9 +929,9 @@ static u64 __nvgpu_balloc_fixed_buddy(struct nvgpu_allocator *__a, return base; fail_unlock: - alloc_unlock(__a); + alloc_unlock(na); fail: - nvgpu_kfree(nvgpu_alloc_to_gpu(__a), falloc); + nvgpu_kfree(nvgpu_alloc_to_gpu(na), falloc); return 0; } @@ -943,16 +943,16 @@ fail: * * Please do not use this function unless _absolutely_ necessary. */ -static u64 nvgpu_balloc_fixed_buddy(struct nvgpu_allocator *__a, +static u64 nvgpu_balloc_fixed_buddy(struct nvgpu_allocator *na, u64 base, u64 len, u32 page_size) { u64 alloc; - struct nvgpu_buddy_allocator *a = __a->priv; + struct nvgpu_buddy_allocator *a = na->priv; - alloc_lock(__a); - alloc = __nvgpu_balloc_fixed_buddy(__a, base, len, page_size); + alloc_lock(na); + alloc = __nvgpu_balloc_fixed_buddy(na, base, len, page_size); a->alloc_made = 1; - alloc_unlock(__a); + alloc_unlock(na); return alloc; } @@ -960,17 +960,17 @@ static u64 nvgpu_balloc_fixed_buddy(struct nvgpu_allocator *__a, /* * Free the passed allocation. */ -static void nvgpu_buddy_bfree(struct nvgpu_allocator *__a, u64 addr) +static void nvgpu_buddy_bfree(struct nvgpu_allocator *na, u64 addr) { struct nvgpu_buddy *bud; struct nvgpu_fixed_alloc *falloc; - struct nvgpu_buddy_allocator *a = __a->priv; + struct nvgpu_buddy_allocator *a = na->priv; if (!addr) { return; } - alloc_lock(__a); + alloc_lock(na); /* * First see if this is a fixed alloc. If not fall back to a regular @@ -996,7 +996,7 @@ static void nvgpu_buddy_bfree(struct nvgpu_allocator *__a, u64 addr) balloc_coalesce(a, bud); done: - alloc_unlock(__a); + alloc_unlock(na); alloc_dbg(balloc_owner(a), "Free 0x%llx", addr); return; } @@ -1031,10 +1031,10 @@ static bool nvgpu_buddy_reserve_is_possible(struct nvgpu_buddy_allocator *a, * Carveouts can only be reserved before any regular allocations have been * made. */ -static int nvgpu_buddy_reserve_co(struct nvgpu_allocator *__a, +static int nvgpu_buddy_reserve_co(struct nvgpu_allocator *na, struct nvgpu_alloc_carveout *co) { - struct nvgpu_buddy_allocator *a = __a->priv; + struct nvgpu_buddy_allocator *a = na->priv; u64 addr; int err = 0; @@ -1043,7 +1043,7 @@ static int nvgpu_buddy_reserve_co(struct nvgpu_allocator *__a, return -EINVAL; } - alloc_lock(__a); + alloc_lock(na); if (!nvgpu_buddy_reserve_is_possible(a, co)) { err = -EBUSY; @@ -1051,10 +1051,10 @@ static int nvgpu_buddy_reserve_co(struct nvgpu_allocator *__a, } /* Should not be possible to fail... */ - addr = __nvgpu_balloc_fixed_buddy(__a, co->base, co->length, 0); + addr = __nvgpu_balloc_fixed_buddy(na, co->base, co->length, 0); if (!addr) { err = -ENOMEM; - nvgpu_warn(__a->g, + nvgpu_warn(na->g, "%s: Failed to reserve a valid carveout!", __func__); goto done; @@ -1063,22 +1063,22 @@ static int nvgpu_buddy_reserve_co(struct nvgpu_allocator *__a, nvgpu_list_add(&co->co_entry, &a->co_list); done: - alloc_unlock(__a); + alloc_unlock(na); return err; } /* * Carveouts can be release at any time. */ -static void nvgpu_buddy_release_co(struct nvgpu_allocator *__a, +static void nvgpu_buddy_release_co(struct nvgpu_allocator *na, struct nvgpu_alloc_carveout *co) { - alloc_lock(__a); + alloc_lock(na); nvgpu_list_del(&co->co_entry); - nvgpu_free(__a, co->base); + nvgpu_free(na, co->base); - alloc_unlock(__a); + alloc_unlock(na); } static u64 nvgpu_buddy_alloc_length(struct nvgpu_allocator *a) @@ -1130,41 +1130,41 @@ static u64 nvgpu_buddy_alloc_space(struct nvgpu_allocator *a) * stats are printed to the kernel log. This lets this code be used for * debugging purposes internal to the allocator. */ -static void nvgpu_buddy_print_stats(struct nvgpu_allocator *__a, +static void nvgpu_buddy_print_stats(struct nvgpu_allocator *na, struct seq_file *s, int lock) { int i = 0; struct nvgpu_rbtree_node *node = NULL; struct nvgpu_fixed_alloc *falloc; struct nvgpu_alloc_carveout *tmp; - struct nvgpu_buddy_allocator *a = __a->priv; + struct nvgpu_buddy_allocator *a = na->priv; - __alloc_pstat(s, __a, "base = %llu, limit = %llu, blk_size = %llu", + __alloc_pstat(s, na, "base = %llu, limit = %llu, blk_size = %llu", a->base, a->length, a->blk_size); - __alloc_pstat(s, __a, "Internal params:"); - __alloc_pstat(s, __a, " start = 0x%llx", a->start); - __alloc_pstat(s, __a, " end = 0x%llx", a->end); - __alloc_pstat(s, __a, " count = 0x%llx", a->count); - __alloc_pstat(s, __a, " blks = 0x%llx", a->blks); - __alloc_pstat(s, __a, " max_order = %llu", a->max_order); + __alloc_pstat(s, na, "Internal params:"); + __alloc_pstat(s, na, " start = 0x%llx", a->start); + __alloc_pstat(s, na, " end = 0x%llx", a->end); + __alloc_pstat(s, na, " count = 0x%llx", a->count); + __alloc_pstat(s, na, " blks = 0x%llx", a->blks); + __alloc_pstat(s, na, " max_order = %llu", a->max_order); if (lock) - alloc_lock(__a); + alloc_lock(na); if (!nvgpu_list_empty(&a->co_list)) { - __alloc_pstat(s, __a, ""); - __alloc_pstat(s, __a, "Carveouts:"); + __alloc_pstat(s, na, ""); + __alloc_pstat(s, na, "Carveouts:"); nvgpu_list_for_each_entry(tmp, &a->co_list, nvgpu_alloc_carveout, co_entry) - __alloc_pstat(s, __a, + __alloc_pstat(s, na, " CO %2d: %-20s 0x%010llx + 0x%llx", i++, tmp->name, tmp->base, tmp->length); } - __alloc_pstat(s, __a, ""); - __alloc_pstat(s, __a, "Buddy blocks:"); - __alloc_pstat(s, __a, " Order Free Alloced Split"); - __alloc_pstat(s, __a, " ----- ---- ------- -----"); + __alloc_pstat(s, na, ""); + __alloc_pstat(s, na, "Buddy blocks:"); + __alloc_pstat(s, na, " Order Free Alloced Split"); + __alloc_pstat(s, na, " ----- ---- ------- -----"); for (i = a->max_order; i >= 0; i--) { if (a->buddy_list_len[i] == 0 && @@ -1172,35 +1172,35 @@ static void nvgpu_buddy_print_stats(struct nvgpu_allocator *__a, a->buddy_list_split[i] == 0) continue; - __alloc_pstat(s, __a, " %3d %-7llu %-9llu %llu", i, + __alloc_pstat(s, na, " %3d %-7llu %-9llu %llu", i, a->buddy_list_len[i], a->buddy_list_alloced[i], a->buddy_list_split[i]); } - __alloc_pstat(s, __a, ""); + __alloc_pstat(s, na, ""); nvgpu_rbtree_enum_start(0, &node, a->fixed_allocs); i = 1; while (node) { falloc = nvgpu_fixed_alloc_from_rbtree_node(node); - __alloc_pstat(s, __a, "Fixed alloc (%d): [0x%llx -> 0x%llx]", + __alloc_pstat(s, na, "Fixed alloc (%d): [0x%llx -> 0x%llx]", i, falloc->start, falloc->end); nvgpu_rbtree_enum_next(&node, a->fixed_allocs); } - __alloc_pstat(s, __a, ""); - __alloc_pstat(s, __a, "Bytes allocated: %llu", + __alloc_pstat(s, na, ""); + __alloc_pstat(s, na, "Bytes allocated: %llu", a->bytes_alloced); - __alloc_pstat(s, __a, "Bytes allocated (real): %llu", + __alloc_pstat(s, na, "Bytes allocated (real): %llu", a->bytes_alloced_real); - __alloc_pstat(s, __a, "Bytes freed: %llu", + __alloc_pstat(s, na, "Bytes freed: %llu", a->bytes_freed); if (lock) - alloc_unlock(__a); + alloc_unlock(na); } #endif @@ -1245,7 +1245,7 @@ static const struct nvgpu_allocator_ops buddy_ops = { * will try and pick a reasonable max order. * @flags: Extra flags necessary. See GPU_BALLOC_*. */ -int __nvgpu_buddy_allocator_init(struct gk20a *g, struct nvgpu_allocator *__a, +int __nvgpu_buddy_allocator_init(struct gk20a *g, struct nvgpu_allocator *na, struct vm_gk20a *vm, const char *name, u64 base, u64 size, u64 blk_size, u64 max_order, u64 flags) @@ -1276,7 +1276,7 @@ int __nvgpu_buddy_allocator_init(struct gk20a *g, struct nvgpu_allocator *__a, return -ENOMEM; } - err = __nvgpu_alloc_common_init(__a, g, name, a, false, &buddy_ops); + err = __nvgpu_alloc_common_init(na, g, name, a, false, &buddy_ops); if (err) { goto fail; } @@ -1285,7 +1285,7 @@ int __nvgpu_buddy_allocator_init(struct gk20a *g, struct nvgpu_allocator *__a, a->length = size; a->blk_size = blk_size; a->blk_shift = __ffs(blk_size); - a->owner = __a; + a->owner = na; /* * If base is 0 then modfy base to be the size of one block so that we @@ -1337,19 +1337,19 @@ int __nvgpu_buddy_allocator_init(struct gk20a *g, struct nvgpu_allocator *__a, a->initialized = 1; #ifdef CONFIG_DEBUG_FS - nvgpu_init_alloc_debug(g, __a); + nvgpu_init_alloc_debug(g, na); #endif - alloc_dbg(__a, "New allocator: type buddy"); - alloc_dbg(__a, " base 0x%llx", a->base); - alloc_dbg(__a, " size 0x%llx", a->length); - alloc_dbg(__a, " blk_size 0x%llx", a->blk_size); + alloc_dbg(na, "New allocator: type buddy"); + alloc_dbg(na, " base 0x%llx", a->base); + alloc_dbg(na, " size 0x%llx", a->length); + alloc_dbg(na, " blk_size 0x%llx", a->blk_size); if (flags & GPU_ALLOC_GVA_SPACE) { alloc_dbg(balloc_owner(a), " pde_size 0x%llx", balloc_order_to_len(a, a->pte_blk_order)); } - alloc_dbg(__a, " max_order %llu", a->max_order); - alloc_dbg(__a, " flags 0x%llx", a->flags); + alloc_dbg(na, " max_order %llu", a->max_order); + alloc_dbg(na, " flags 0x%llx", a->flags); return 0; @@ -1361,10 +1361,10 @@ fail: return err; } -int nvgpu_buddy_allocator_init(struct gk20a *g, struct nvgpu_allocator *a, +int nvgpu_buddy_allocator_init(struct gk20a *g, struct nvgpu_allocator *na, const char *name, u64 base, u64 size, u64 blk_size, u64 flags) { - return __nvgpu_buddy_allocator_init(g, a, NULL, name, + return __nvgpu_buddy_allocator_init(g, na, NULL, name, base, size, blk_size, 0, 0); } diff --git a/drivers/gpu/nvgpu/include/nvgpu/allocator.h b/drivers/gpu/nvgpu/include/nvgpu/allocator.h index d7a47d23..839712db 100644 --- a/drivers/gpu/nvgpu/include/nvgpu/allocator.h +++ b/drivers/gpu/nvgpu/include/nvgpu/allocator.h @@ -205,11 +205,11 @@ static inline void alloc_unlock(struct nvgpu_allocator *a) /* * Buddy allocator specific initializers. */ -int __nvgpu_buddy_allocator_init(struct gk20a *g, struct nvgpu_allocator *a, +int __nvgpu_buddy_allocator_init(struct gk20a *g, struct nvgpu_allocator *na, struct vm_gk20a *vm, const char *name, u64 base, u64 size, u64 blk_size, u64 max_order, u64 flags); -int nvgpu_buddy_allocator_init(struct gk20a *g, struct nvgpu_allocator *a, +int nvgpu_buddy_allocator_init(struct gk20a *g, struct nvgpu_allocator *na, const char *name, u64 base, u64 size, u64 blk_size, u64 flags); -- cgit v1.2.2