SmartisanOS_Kernel_Source/scripts/kallsyms.c at master · coolsnake/SmartisanOS_Kernel_Source · GitHub

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

/* Generate assembler source containing symbol information

* This software may be used and distributed according to the terms

* of the GNU General Public License, incorporated herein by reference.

* Usage: nm -n vmlinux | scripts/kallsyms [--all-symbols] > symbols.S

* Table compression uses all the unused char codes on the symbols and

* maps these to the most used substrings (tokens). For instance, it might

* map char code 0xF7 to represent "write_" and then in every symbol where

* "write_" appears it can be replaced by 0xF7, saving 5 bytes.

* The used codes themselves are also placed in the table so that the

* decompresion can work without "special cases".

* Applied to kernel symbols, this usually produces a compression ratio

* of about 50%.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#ifndef ARRAY_SIZE

#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0]))

#endif

#define KSYM_NAME_LEN 128

struct sym_entry {

unsigned long long addr;

unsigned int len;

unsigned int start_pos;

unsigned char *sym;

};

struct text_range {

const char *stext, *etext;

unsigned long long start, end;

};

static unsigned long long _text;

static struct text_range text_ranges[] = {

{ "_stext", "_etext" },

{ "_sinittext", "_einittext" },

{ "_stext_l1", "_etext_l1" }, /* Blackfin on-chip L1 inst SRAM */

{ "_stext_l2", "_etext_l2" }, /* Blackfin on-chip L2 SRAM */

};

#define text_range_text (&text_ranges[0])

#define text_range_inittext (&text_ranges[1])

static struct sym_entry *table;

static unsigned int table_size, table_cnt;

static int all_symbols = 0;

static char symbol_prefix_char = '\0';

static unsigned long long kernel_start_addr = 0;

int token_profit[0x10000];

/* the table that holds the result of the compression */

unsigned char best_table[256][2];

unsigned char best_table_len[256];

static void usage(void)

{

fprintf(stderr, "Usage: kallsyms [--all-symbols] "

"[--symbol-prefix=<prefix char>] "

"[--page-offset=<CONFIG_PAGE_OFFSET>] "

"< in.map > out.S\n");

exit(1);

}

* This ignores the intensely annoying "mapping symbols" found

* in ARM ELF files: $a, $t and $d.

static inline int is_arm_mapping_symbol(const char *str)

{

return str[0] == '$' && strchr("atd", str[1])

&& (str[2] == '\0' || str[2] == '.');

}

static int read_symbol_tr(const char *sym, unsigned long long addr)

{

size_t i;

struct text_range *tr;

for (i = 0; i < ARRAY_SIZE(text_ranges); ++i) {

tr = &text_ranges[i];

if (strcmp(sym, tr->stext) == 0) {

tr->start = addr;

return 0;

} else if (strcmp(sym, tr->etext) == 0) {

tr->end = addr;

return 0;

}

return 1;

}

static int read_symbol(FILE *in, struct sym_entry *s)

{

char str[500];

char *sym, stype;

int rc;

rc = fscanf(in, "%llx %c %499s\n", &s->addr, &stype, str);

if (rc != 3) {

if (rc != EOF && fgets(str, 500, in) == NULL)

fprintf(stderr, "Read error or end of file.\n");

return -1;

}

sym = str;

/* skip prefix char */

if (symbol_prefix_char && str[0] == symbol_prefix_char)

sym++;

/* Ignore most absolute/undefined (?) symbols. */

if (strcmp(sym, "_text") == 0)

_text = s->addr;

else if (read_symbol_tr(sym, s->addr) == 0)

/* nothing to do */;

else if (toupper(stype) == 'A')

{

/* Keep these useful absolute symbols */

if (strcmp(sym, "__kernel_syscall_via_break") &&

strcmp(sym, "__kernel_syscall_via_epc") &&

strcmp(sym, "__kernel_sigtramp") &&

strcmp(sym, "__gp"))

return -1;

}

else if (toupper(stype) == 'U' ||

is_arm_mapping_symbol(sym))

return -1;

/* exclude also MIPS ELF local symbols ($L123 instead of .L123) */

else if (str[0] == '$')

return -1;

/* exclude debugging symbols */

else if (stype == 'N')

return -1;

/* include the type field in the symbol name, so that it gets

* compressed together */

s->len = strlen(str) + 1;

s->sym = malloc(s->len + 1);

if (!s->sym) {

fprintf(stderr, "kallsyms failure: "

"unable to allocate required amount of memory\n");

exit(EXIT_FAILURE);

}

strcpy((char *)s->sym + 1, str);

s->sym[0] = stype;

return 0;

}

static int symbol_valid_tr(struct sym_entry *s)

{

size_t i;

struct text_range *tr;

for (i = 0; i < ARRAY_SIZE(text_ranges); ++i) {

tr = &text_ranges[i];

if (s->addr >= tr->start && s->addr <= tr->end)

return 1;

}

return 0;

}

static int symbol_valid(struct sym_entry *s)

{

/* Symbols which vary between passes. Passes 1 and 2 must have

* identical symbol lists. The kallsyms_* symbols below are only added

* after pass 1, they would be included in pass 2 when --all-symbols is

* specified so exclude them to get a stable symbol list.

static char *special_symbols[] = {

"kallsyms_addresses",

"kallsyms_num_syms",

"kallsyms_names",

"kallsyms_markers",

"kallsyms_token_table",

"kallsyms_token_index",

/* Exclude linker generated symbols which vary between passes */

"_SDA_BASE_", /* ppc */

"_SDA2_BASE_", /* ppc */

NULL };

int i;

int offset = 1;

if (s->addr < kernel_start_addr)

return 0;

/* skip prefix char */

if (symbol_prefix_char && *(s->sym + 1) == symbol_prefix_char)

offset++;

/* if --all-symbols is not specified, then symbols outside the text

* and inittext sections are discarded */

if (!all_symbols) {

if (symbol_valid_tr(s) == 0)

return 0;

/* Corner case. Discard any symbols with the same value as

* _etext _einittext; they can move between pass 1 and 2 when

* the kallsyms data are added. If these symbols move then

* they may get dropped in pass 2, which breaks the kallsyms

* rules.

if ((s->addr == text_range_text->end &&

strcmp((char *)s->sym + offset, text_range_text->etext)) ||

(s->addr == text_range_inittext->end &&

strcmp((char *)s->sym + offset, text_range_inittext->etext)))

return 0;

}

/* Exclude symbols which vary between passes. */

if (strstr((char *)s->sym + offset, "_compiled."))

return 0;

for (i = 0; special_symbols[i]; i++)

if( strcmp((char *)s->sym + offset, special_symbols[i]) == 0 )

return 0;

return 1;

}

static void read_map(FILE *in)

{

while (!feof(in)) {

if (table_cnt >= table_size) {

table_size += 10000;

table = realloc(table, sizeof(*table) * table_size);

if (!table) {

fprintf(stderr, "out of memory\n");

exit (1);

}

if (read_symbol(in, &table[table_cnt]) == 0) {

table[table_cnt].start_pos = table_cnt;

table_cnt++;

}

static void output_label(char *label)

{

if (symbol_prefix_char)

printf(".globl %c%s\n", symbol_prefix_char, label);

else

printf(".globl %s\n", label);

printf("\tALGN\n");

if (symbol_prefix_char)

printf("%c%s:\n", symbol_prefix_char, label);

else

printf("%s:\n", label);

}

/* uncompress a compressed symbol. When this function is called, the best table

* might still be compressed itself, so the function needs to be recursive */

static int expand_symbol(unsigned char *data, int len, char *result)

{

int c, rlen, total=0;

while (len) {

c = *data;

/* if the table holds a single char that is the same as the one

* we are looking for, then end the search */

if (best_table[c][0]==c && best_table_len[c]==1) {

*result++ = c;

total++;

} else {

/* if not, recurse and expand */

rlen = expand_symbol(best_table[c], best_table_len[c], result);

total += rlen;

result += rlen;

}

data++;

len--;

}

*result=0;

return total;

}

static void write_src(void)

{

unsigned int i, k, off;

unsigned int best_idx[256];

unsigned int *markers;

char buf[KSYM_NAME_LEN];

printf("#include <asm/types.h>\n");

printf("#if BITS_PER_LONG == 64\n");

printf("#define PTR .quad\n");

printf("#define ALGN .align 8\n");

printf("#else\n");

printf("#define PTR .long\n");

printf("#define ALGN .align 4\n");

printf("#endif\n");

printf("\t.section .rodata, \"a\"\n");

/* Provide proper symbols relocatability by their '_text'

* relativeness. The symbol names cannot be used to construct

* normal symbol references as the list of symbols contains

* symbols that are declared static and are private to their

* .o files. This prevents .tmp_kallsyms.o or any other

* object from referencing them.

output_label("kallsyms_addresses");

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

if (toupper(table[i].sym[0]) != 'A') {

if (_text <= table[i].addr)

printf("\tPTR\t_text + %#llx\n",

table[i].addr - _text);

else

printf("\tPTR\t_text - %#llx\n",

_text - table[i].addr);

} else {

printf("\tPTR\t%#llx\n", table[i].addr);

}

printf("\n");

output_label("kallsyms_num_syms");

printf("\tPTR\t%d\n", table_cnt);

printf("\n");

/* table of offset markers, that give the offset in the compressed stream

* every 256 symbols */

markers = malloc(sizeof(unsigned int) * ((table_cnt + 255) / 256));

if (!markers) {

fprintf(stderr, "kallsyms failure: "

"unable to allocate required memory\n");

exit(EXIT_FAILURE);

}

output_label("kallsyms_names");

off = 0;

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

if ((i & 0xFF) == 0)

markers[i >> 8] = off;

printf("\t.byte 0x%02x", table[i].len);

for (k = 0; k < table[i].len; k++)

printf(", 0x%02x", table[i].sym[k]);

printf("\n");

off += table[i].len + 1;

}

printf("\n");

output_label("kallsyms_markers");

for (i = 0; i < ((table_cnt + 255) >> 8); i++)

printf("\tPTR\t%d\n", markers[i]);

printf("\n");

free(markers);

output_label("kallsyms_token_table");

off = 0;

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

best_idx[i] = off;

expand_symbol(best_table[i], best_table_len[i], buf);

printf("\t.asciz\t\"%s\"\n", buf);

off += strlen(buf) + 1;

}

printf("\n");

output_label("kallsyms_token_index");

for (i = 0; i < 256; i++)

printf("\t.short\t%d\n", best_idx[i]);

printf("\n");

}

/* table lookup compression functions */

/* count all the possible tokens in a symbol */

static void learn_symbol(unsigned char *symbol, int len)

{

int i;

for (i = 0; i < len - 1; i++)

token_profit[ symbol[i] + (symbol[i + 1] << 8) ]++;

}

/* decrease the count for all the possible tokens in a symbol */

static void forget_symbol(unsigned char *symbol, int len)

{

int i;

for (i = 0; i < len - 1; i++)

token_profit[ symbol[i] + (symbol[i + 1] << 8) ]--;

}

/* remove all the invalid symbols from the table and do the initial token count */

static void build_initial_tok_table(void)

{

unsigned int i, pos;

pos = 0;

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

if ( symbol_valid(&table[i]) ) {

if (pos != i)

table[pos] = table[i];

learn_symbol(table[pos].sym, table[pos].len);

pos++;

}

table_cnt = pos;

}

static void *find_token(unsigned char *str, int len, unsigned char *token)

{

int i;

for (i = 0; i < len - 1; i++) {

if (str[i] == token[0] && str[i+1] == token[1])

return &str[i];

}

return NULL;

}

/* replace a given token in all the valid symbols. Use the sampled symbols

* to update the counts */

static void compress_symbols(unsigned char *str, int idx)

{

unsigned int i, len, size;

unsigned char *p1, *p2;

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

len = table[i].len;

p1 = table[i].sym;

/* find the token on the symbol */

p2 = find_token(p1, len, str);

if (!p2) continue;

/* decrease the counts for this symbol's tokens */

forget_symbol(table[i].sym, len);

size = len;

do {

*p2 = idx;

p2++;

size -= (p2 - p1);

memmove(p2, p2 + 1, size);

p1 = p2;

len--;

if (size < 2) break;

/* find the token on the symbol */

p2 = find_token(p1, size, str);

} while (p2);

table[i].len = len;

/* increase the counts for this symbol's new tokens */

learn_symbol(table[i].sym, len);

}

/* search the token with the maximum profit */

static int find_best_token(void)

{

int i, best, bestprofit;

bestprofit=-10000;

best = 0;

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

if (token_profit[i] > bestprofit) {

best = i;

bestprofit = token_profit[i];

}

return best;

}

/* this is the core of the algorithm: calculate the "best" table */

static void optimize_result(void)

{

int i, best;

/* using the '\0' symbol last allows compress_symbols to use standard

* fast string functions */

for (i = 255; i >= 0; i--) {

/* if this table slot is empty (it is not used by an actual

* original char code */

if (!best_table_len[i]) {

/* find the token with the breates profit value */

best = find_best_token();

if (token_profit[best] == 0)

break;

/* place it in the "best" table */

best_table_len[i] = 2;

best_table[i][0] = best & 0xFF;

best_table[i][1] = (best >> 8) & 0xFF;

/* replace this token in all the valid symbols */

compress_symbols(best_table[i], i);

}

/* start by placing the symbols that are actually used on the table */

static void insert_real_symbols_in_table(void)

{

unsigned int i, j, c;

memset(best_table, 0, sizeof(best_table));

memset(best_table_len, 0, sizeof(best_table_len));

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

for (j = 0; j < table[i].len; j++) {

c = table[i].sym[j];

best_table[c][0]=c;

best_table_len[c]=1;

}

static void optimize_token_table(void)

{

build_initial_tok_table();

insert_real_symbols_in_table();

/* When valid symbol is not registered, exit to error */

if (!table_cnt) {

fprintf(stderr, "No valid symbol.\n");

exit(1);

}

optimize_result();

}

/* guess for "linker script provide" symbol */

static int may_be_linker_script_provide_symbol(const struct sym_entry *se)

{

const char *symbol = (char *)se->sym + 1;

int len = se->len - 1;

if (len < 8)

return 0;

if (symbol[0] != '_' || symbol[1] != '_')

return 0;

/* __start_XXXXX */

if (!memcmp(symbol + 2, "start_", 6))

return 1;

/* __stop_XXXXX */

if (!memcmp(symbol + 2, "stop_", 5))

return 1;

/* __end_XXXXX */

if (!memcmp(symbol + 2, "end_", 4))

return 1;

/* __XXXXX_start */

if (!memcmp(symbol + len - 6, "_start", 6))

return 1;

/* __XXXXX_end */

if (!memcmp(symbol + len - 4, "_end", 4))

return 1;

return 0;

}

static int prefix_underscores_count(const char *str)

{

const char *tail = str;

while (*tail == '_')

tail++;

return tail - str;

}

static int compare_symbols(const void *a, const void *b)

{

const struct sym_entry *sa;

const struct sym_entry *sb;

int wa, wb;

sa = a;

sb = b;

/* sort by address first */

if (sa->addr > sb->addr)

return 1;

if (sa->addr < sb->addr)

return -1;

/* sort by "weakness" type */

wa = (sa->sym[0] == 'w') || (sa->sym[0] == 'W');

wb = (sb->sym[0] == 'w') || (sb->sym[0] == 'W');

if (wa != wb)

return wa - wb;

/* sort by "linker script provide" type */

wa = may_be_linker_script_provide_symbol(sa);

wb = may_be_linker_script_provide_symbol(sb);

if (wa != wb)

return wa - wb;

/* sort by the number of prefix underscores */

wa = prefix_underscores_count((const char *)sa->sym + 1);

wb = prefix_underscores_count((const char *)sb->sym + 1);

if (wa != wb)

return wa - wb;

/* sort by initial order, so that other symbols are left undisturbed */

return sa->start_pos - sb->start_pos;

}

static void sort_symbols(void)

{

qsort(table, table_cnt, sizeof(struct sym_entry), compare_symbols);

}

int main(int argc, char **argv)

{

if (argc >= 2) {

int i;

for (i = 1; i < argc; i++) {

if(strcmp(argv[i], "--all-symbols") == 0)

all_symbols = 1;

else if (strncmp(argv[i], "--symbol-prefix=", 16) == 0) {

char *p = &argv[i][16];

/* skip quote */

if ((*p == '"' && *(p+2) == '"') || (*p == '\'' && *(p+2) == '\''))

p++;

symbol_prefix_char = *p;

} else if (strncmp(argv[i], "--page-offset=", 14) == 0) {

const char *p = &argv[i][14];

kernel_start_addr = strtoull(p, NULL, 16);

} else

usage();

}

} else if (argc != 1)

usage();

read_map(stdin);

sort_symbols();

optimize_token_table();

write_src();

return 0;

}

SmartisanOS_Kernel_Source/scripts/kallsyms.c at master · coolsnake/SmartisanOS_Kernel_Source · GitHub

Repository navigation

Expand file tree

Breadcrumbs

kallsyms.c

Latest commit

History

Breadcrumbs

kallsyms.c

File metadata and controls