kallsyms_seqs_of_names[] records the symbol index sorted by address, the
maximum value in kallsyms_seqs_of_names[] is the number of symbols. And
2^24 = 16777216, which means that three bytes are enough to store the
index. This can help us save (1 * kallsyms_num_syms) bytes of memory.
Signed-off-by: Zhen Lei <[email protected]>
---
kernel/kallsyms.c | 18 ++++++++++++++----
kernel/kallsyms_internal.h | 2 +-
scripts/kallsyms.c | 5 ++++-
3 files changed, 19 insertions(+), 6 deletions(-)
diff --git a/kernel/kallsyms.c b/kernel/kallsyms.c
index ba351dfa109b6ac..48f36fd7e10b95e 100644
--- a/kernel/kallsyms.c
+++ b/kernel/kallsyms.c
@@ -201,6 +201,16 @@ static int compare_symbol_name(const char *name, char *namebuf)
return ret;
}
+static unsigned int get_symbol_seq(int index)
+{
+ unsigned int i, seq = 0;
+
+ for (i = 0; i < 3; i++)
+ seq = (seq << 8) | kallsyms_seqs_of_names[3 * index + i];
+
+ return seq;
+}
+
static int kallsyms_lookup_names(const char *name,
unsigned int *start,
unsigned int *end)
@@ -215,7 +225,7 @@ static int kallsyms_lookup_names(const char *name,
while (low <= high) {
mid = low + (high - low) / 2;
- seq = kallsyms_seqs_of_names[mid];
+ seq = get_symbol_seq(mid);
off = get_symbol_offset(seq);
kallsyms_expand_symbol(off, namebuf, ARRAY_SIZE(namebuf));
ret = compare_symbol_name(name, namebuf);
@@ -232,7 +242,7 @@ static int kallsyms_lookup_names(const char *name,
low = mid;
while (low) {
- seq = kallsyms_seqs_of_names[low - 1];
+ seq = get_symbol_seq(low - 1);
off = get_symbol_offset(seq);
kallsyms_expand_symbol(off, namebuf, ARRAY_SIZE(namebuf));
if (compare_symbol_name(name, namebuf))
@@ -244,7 +254,7 @@ static int kallsyms_lookup_names(const char *name,
if (end) {
high = mid;
while (high < kallsyms_num_syms - 1) {
- seq = kallsyms_seqs_of_names[high + 1];
+ seq = get_symbol_seq(high + 1);
off = get_symbol_offset(seq);
kallsyms_expand_symbol(off, namebuf, ARRAY_SIZE(namebuf));
if (compare_symbol_name(name, namebuf))
@@ -269,7 +279,7 @@ unsigned long kallsyms_lookup_name(const char *name)
ret = kallsyms_lookup_names(name, &i, NULL);
if (!ret)
- return kallsyms_sym_address(kallsyms_seqs_of_names[i]);
+ return kallsyms_sym_address(get_symbol_seq(i));
return module_kallsyms_lookup_name(name);
}
diff --git a/kernel/kallsyms_internal.h b/kernel/kallsyms_internal.h
index a04b7a5cb1e3eaf..27fabdcc40f5793 100644
--- a/kernel/kallsyms_internal.h
+++ b/kernel/kallsyms_internal.h
@@ -26,6 +26,6 @@ extern const char kallsyms_token_table[] __weak;
extern const u16 kallsyms_token_index[] __weak;
extern const unsigned int kallsyms_markers[] __weak;
-extern const unsigned int kallsyms_seqs_of_names[] __weak;
+extern const u8 kallsyms_seqs_of_names[] __weak;
#endif // LINUX_KALLSYMS_INTERNAL_H_
diff --git a/scripts/kallsyms.c b/scripts/kallsyms.c
index 07ecf7e5c49f616..04e04fbd9625caf 100644
--- a/scripts/kallsyms.c
+++ b/scripts/kallsyms.c
@@ -600,7 +600,10 @@ static void write_src(void)
sort_symbols_by_name();
output_label("kallsyms_seqs_of_names");
for (i = 0; i < table_cnt; i++)
- printf("\t.long\t%u\n", table[i]->seq);
+ printf("\t.byte 0x%02x, 0x%02x, 0x%02x\n",
+ (unsigned char)(table[i]->seq >> 16),
+ (unsigned char)(table[i]->seq >> 8),
+ (unsigned char)(table[i]->seq >> 0));
printf("\n");
output_label("kallsyms_token_table");
--
2.25.1
From: Zhen Lei
> Sent: 02 November 2022 08:49
>
> kallsyms_seqs_of_names[] records the symbol index sorted by address, the
> maximum value in kallsyms_seqs_of_names[] is the number of symbols. And
> 2^24 = 16777216, which means that three bytes are enough to store the
> index. This can help us save (1 * kallsyms_num_syms) bytes of memory.
You can get the compiler to do the 'heavy lifting' for you.
struct uint24 {
unsigned int val24:24;
} __attribute__((packed));
struct uint24 table[1024];
works fine.
David
-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK
Registration No: 1397386 (Wales)
On 2022/11/2 20:00, David Laight wrote:
> From: Zhen Lei
>> Sent: 02 November 2022 08:49
>>
>> kallsyms_seqs_of_names[] records the symbol index sorted by address, the
>> maximum value in kallsyms_seqs_of_names[] is the number of symbols. And
>> 2^24 = 16777216, which means that three bytes are enough to store the
>> index. This can help us save (1 * kallsyms_num_syms) bytes of memory.
>
> You can get the compiler to do the 'heavy lifting' for you.
>
> struct uint24 {
> unsigned int val24:24;
> } __attribute__((packed));
This method depends on byte order. If the byte order of the tool is
different from that of the kernel, it's a problem. For example,
cross-compile PowerPC kernel on x86.
>
> struct uint24 table[1024];
>
> works fine.
>
> David
>
> -
> Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK
> Registration No: 1397386 (Wales)
>
>
> .
>
--
Regards,
Zhen Lei