sravan/system76-coreboot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

src/: Remove g_ prefixes and _g suffixes from variables

Browse Source 
These were often used to distinguish CAR_GLOBAL variables that weren't
directly usable. Since we're getting rid of this special case, also get
rid of the marker.

This change was created using coccinelle and the following script:
	@match@
	type T;
	identifier old =~ "^(g_.*|.*_g)$";
	@@
	old

	@script:python global_marker@
	old << match.old;
	new;
	@@
	new = old
	if old[0:2] == "g_":
	  new = new[2:]

	if new[-2:] == "_g":
	  new = new[:-2]

	coccinelle.new = new

	@@
	identifier match.old, global_marker.new;
	@@
	- old
	+ new

	@@
	type T;
	identifier match.old, global_marker.new;
	@@
	- T old;
	+ T new;

	@@
	type T;
	identifier match.old, global_marker.new;
	@@
	- T old
	+ T new
	 = ...;

There were some manual fixups: Some code still uses the global/local
variable naming scheme, so keep g_* there, and some variable names
weren't completely rewritten.

Change-Id: I4936ff9780a0d3ed9b8b539772bc48887f8d5eed
Signed-off-by: Patrick Georgi <pgeorgi@google.com>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/37358
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: Kyösti Mälkki <kyosti.malkki@gmail.com>
Reviewed-by: HAOUAS Elyes <ehaouas@noos.fr>
This commit is contained in:
Patrick Georgi
2019-11-29 11:47:47 +01:00
parent ae64f22e8d
commit c9b13594eb
17 changed files with 301 additions and 298 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
src/drivers/elog/elog.c
View File

@ -65,14 +65,14 @@ struct elog_state {
enum elog_init_state elog_initialized;
};
static struct elog_state g_elog_state;
static struct elog_state elog_state;
#define ELOG_SIZE (4 * KiB)
static uint8_t elog_mirror_buf[ELOG_SIZE];
static inline struct region_device *mirror_dev_get(void)
{
return &g_elog_state.mirror_dev.rdev;
return &elog_state.mirror_dev.rdev;
}
static size_t elog_events_start(void)
@ -83,7 +83,7 @@ static size_t elog_events_start(void)
static size_t elog_events_total_space(void)
{
return region_device_sz(&g_elog_state.nv_dev) - elog_events_start();
return region_device_sz(&elog_state.nv_dev) - elog_events_start();
}
static struct event_header *elog_get_event_buffer(size_t offset, size_t size)
@ -93,8 +93,9 @@ static struct event_header *elog_get_event_buffer(size_t offset, size_t size)
static struct event_header *elog_get_next_event_buffer(size_t size)
{
elog_debug("ELOG: new event at offset 0x%zx\n", g_elog_state.mirror_last_write);
return elog_get_event_buffer(g_elog_state.mirror_last_write, size);
elog_debug("ELOG: new event at offset 0x%zx\n",
elog_state.mirror_last_write);
return elog_get_event_buffer(elog_state.mirror_last_write, size);
}
static void elog_put_event_buffer(struct event_header *event)
@ -105,53 +106,53 @@ static void elog_put_event_buffer(struct event_header *event)
static size_t elog_mirror_reset_last_write(void)
{
/* Return previous write value. */
size_t prev = g_elog_state.mirror_last_write;
size_t prev = elog_state.mirror_last_write;
g_elog_state.mirror_last_write = 0;
elog_state.mirror_last_write = 0;
return prev;
}
static void elog_mirror_increment_last_write(size_t size)
{
g_elog_state.mirror_last_write += size;
elog_state.mirror_last_write += size;
}
static void elog_nv_reset_last_write(void)
{
g_elog_state.nv_last_write = 0;
elog_state.nv_last_write = 0;
}
static void elog_nv_increment_last_write(size_t size)
{
g_elog_state.nv_last_write += size;
elog_state.nv_last_write += size;
}
static void elog_nv_needs_possible_erase(void)
{
/* If last write is 0 it means it is already erased. */
if (g_elog_state.nv_last_write != 0)
g_elog_state.nv_last_write = NV_NEEDS_ERASE;
if (elog_state.nv_last_write != 0)
elog_state.nv_last_write = NV_NEEDS_ERASE;
}
static bool elog_should_shrink(void)
{
return g_elog_state.mirror_last_write >= g_elog_state.full_threshold;
return elog_state.mirror_last_write >= elog_state.full_threshold;
}
static bool elog_nv_needs_erase(void)
{
return g_elog_state.nv_last_write == NV_NEEDS_ERASE;
return elog_state.nv_last_write == NV_NEEDS_ERASE;
}
static bool elog_nv_needs_update(void)
{
return g_elog_state.nv_last_write != g_elog_state.mirror_last_write;
return elog_state.nv_last_write != elog_state.mirror_last_write;
}
static size_t elog_nv_region_to_update(size_t *offset)
{
*offset = g_elog_state.nv_last_write;
return g_elog_state.mirror_last_write - g_elog_state.nv_last_write;
*offset = elog_state.nv_last_write;
return elog_state.mirror_last_write - elog_state.nv_last_write;
}
/*
@ -335,7 +336,7 @@ static void elog_nv_write(size_t offset, size_t size)
return;
/* Write the data to flash */
if (rdev_writeat(&g_elog_state.nv_dev, address, offset, size) != size)
if (rdev_writeat(&elog_state.nv_dev, address, offset, size) != size)
printk(BIOS_ERR, "ELOG: NV Write failed at 0x%zx, size 0x%zx\n",
offset, size);
@ -348,11 +349,11 @@ static void elog_nv_write(size_t offset, size_t size)
*/
static void elog_nv_erase(void)
{
size_t size = region_device_sz(&g_elog_state.nv_dev);
size_t size = region_device_sz(&elog_state.nv_dev);
elog_debug("%s()\n", __func__);
/* Erase the sectors in this region */
if (rdev_eraseat(&g_elog_state.nv_dev, 0, size) != size)
if (rdev_eraseat(&elog_state.nv_dev, 0, size) != size)
printk(BIOS_ERR, "ELOG: erase failure.\n");
}
@ -411,11 +412,11 @@ static int elog_scan_flash(void)
void *mirror_buffer;
const struct region_device *rdev = mirror_dev_get();
size_t size = region_device_sz(&g_elog_state.nv_dev);
size_t size = region_device_sz(&elog_state.nv_dev);
/* Fill memory buffer by reading from SPI */
mirror_buffer = rdev_mmap_full(rdev);
if (rdev_readat(&g_elog_state.nv_dev, mirror_buffer, 0, size) != size) {
if (rdev_readat(&elog_state.nv_dev, mirror_buffer, 0, size) != size) {
rdev_munmap(rdev, mirror_buffer);
printk(BIOS_ERR, "ELOG: NV read failure.\n");
return -1;
@ -580,7 +581,7 @@ static int elog_prepare_empty(void)
static int elog_shrink(void)
{
if (elog_should_shrink())
return elog_shrink_by_size(g_elog_state.shrink_size);
return elog_shrink_by_size(elog_state.shrink_size);
return 0;
}
@ -593,12 +594,13 @@ static inline u8 *elog_flash_offset_to_address(void)
if (!CONFIG(BOOT_DEVICE_MEMORY_MAPPED))
return NULL;
if (!region_device_sz(&g_elog_state.nv_dev))
if (!region_device_sz(&elog_state.nv_dev))
return NULL;
/* Get a view into the read-only boot device. */
return rdev_mmap(boot_device_ro(), region_device_offset(&g_elog_state.nv_dev),
region_device_sz(&g_elog_state.nv_dev));
return rdev_mmap(boot_device_ro(),
region_device_offset(&elog_state.nv_dev),
region_device_sz(&elog_state.nv_dev));
}
/*
@ -611,7 +613,7 @@ int elog_smbios_write_type15(unsigned long *current, int handle)
int len = sizeof(struct smbios_type15);
uintptr_t log_address;
size_t elog_size = region_device_sz(&g_elog_state.nv_dev);
size_t elog_size = region_device_sz(&elog_state.nv_dev);
if (CONFIG(ELOG_CBMEM)) {
/* Save event log buffer into CBMEM for the OS to read */
@ -665,7 +667,7 @@ static int elog_find_flash(void)
{
size_t total_size;
size_t reserved_space = ELOG_MIN_AVAILABLE_ENTRIES * MAX_EVENT_SIZE;
struct region_device *rdev = &g_elog_state.nv_dev;
struct region_device *rdev = &elog_state.nv_dev;
elog_debug("%s()\n", __func__);
@ -688,10 +690,10 @@ static int elog_find_flash(void)
total_size = MIN(ELOG_SIZE, region_device_sz(rdev));
rdev_chain(rdev, rdev, 0, total_size);
g_elog_state.full_threshold = total_size - reserved_space;
g_elog_state.shrink_size = total_size * ELOG_SHRINK_PERCENTAGE / 100;
elog_state.full_threshold = total_size - reserved_space;
elog_state.shrink_size = total_size * ELOG_SHRINK_PERCENTAGE / 100;
if (reserved_space > g_elog_state.shrink_size) {
if (reserved_space > elog_state.shrink_size) {
printk(BIOS_ERR, "ELOG: SHRINK_PERCENTAGE too small\n");
return -1;
}
@ -734,7 +736,7 @@ static int elog_sync_to_nv(void)
if (elog_scan_flash() < 0) {
printk(BIOS_ERR, "ELOG: Sync back from NV storage failed.\n");
elog_debug_dump_buffer("ELOG: Buffer from NV:\n");
g_elog_state.elog_initialized = ELOG_BROKEN;
elog_state.elog_initialized = ELOG_BROKEN;
return -1;
}
@ -776,7 +778,7 @@ int elog_init(void)
{
void *mirror_buffer;
size_t elog_size;
switch (g_elog_state.elog_initialized) {
switch (elog_state.elog_initialized) {
case ELOG_UNINITIALIZED:
break;
case ELOG_INITIALIZED:
@ -784,7 +786,7 @@ int elog_init(void)
case ELOG_BROKEN:
return -1;
}
g_elog_state.elog_initialized = ELOG_BROKEN;
elog_state.elog_initialized = ELOG_BROKEN;
elog_debug("elog_init()\n");
@ -792,19 +794,20 @@ int elog_init(void)
if (elog_find_flash() < 0)
return -1;
elog_size = region_device_sz(&g_elog_state.nv_dev);
elog_size = region_device_sz(&elog_state.nv_dev);
mirror_buffer = elog_mirror_buf;
if (!mirror_buffer) {
printk(BIOS_ERR, "ELOG: Unable to allocate backing store\n");
return -1;
}
mem_region_device_rw_init(&g_elog_state.mirror_dev, mirror_buffer, elog_size);
mem_region_device_rw_init(&elog_state.mirror_dev, mirror_buffer,
elog_size);
/*
* Mark as initialized to allow elog_init() to be called and deemed
* successful in the prepare/shrink path which adds events.
*/
g_elog_state.elog_initialized = ELOG_INITIALIZED;
elog_state.elog_initialized = ELOG_INITIALIZED;
/* Load the log from flash and prepare the flash if necessary. */
if (elog_scan_flash() < 0 && elog_prepare_empty() < 0) {
@ -813,8 +816,8 @@ int elog_init(void)
}
printk(BIOS_INFO, "ELOG: area is %zu bytes, full threshold %d,"
" shrink size %d\n", region_device_sz(&g_elog_state.nv_dev),
g_elog_state.full_threshold, g_elog_state.shrink_size);
" shrink size %d\n", region_device_sz(&elog_state.nv_dev),
elog_state.full_threshold, elog_state.shrink_size);
if (ENV_PAYLOAD_LOADER)
elog_add_boot_count();