FM / scripts

/usr/src/kernels/4.18.0-553.157.1.el8_10.x86_64/scripts/

/usr/src/kernels/4.18.0-553.157.1.el8_10.x86_64/scripts

Name	Size	Mode	Actions
basic/	-	0755	rm
clang-tools/	-	0755	rm
coccinelle/	-	0755	rm
dtc/	-	0755	rm
gcc-plugins/	-	0755	rm
gdb/	-	0755	rm
genksyms/	-	0755	rm
kconfig/	-	0755	rm
ksymoops/	-	0755	rm
mod/	-	0755	rm
package/	-	0755	rm
selinux/	-	0755	rm
adjust_autoksyms.sh	3010	0755	edit dl rm
asn1_compiler	28008	0755	edit dl rm
asn1_compiler.c	36391	0644	edit dl rm
bin2c	7024	0755	edit dl rm
bin2c.c	743	0644	edit dl rm
bloat-o-meter	3313	0755	edit dl rm
bootgraph.pl	6426	0755	edit dl rm
bpf_doc.py	25515	0755	edit dl rm
cc-can-link.sh	166	0755	edit dl rm
checkincludes.pl	1984	0755	edit dl rm
checkkconfigsymbols.py	15895	0755	edit dl rm
checkpatch.pl	197186	0755	edit dl rm
checkstack.pl	5303	0755	edit dl rm
checksyscalls.sh	7094	0755	edit dl rm
checkversion.pl	1938	0755	edit dl rm
check_00index.sh	1333	0755	edit dl rm
check_extable.sh	5049	0755	edit dl rm
clang-version.sh	635	0755	edit dl rm
cleanfile	3538	0755	edit dl rm
cleanpatch	5178	0755	edit dl rm
coccicheck	7407	0755	edit dl rm
config	4635	0755	edit dl rm
conmakehash	11616	0755	edit dl rm
conmakehash.c	6128	0644	edit dl rm
const_structs.checkpatch	964	0644	edit dl rm
decodecode	2525	0755	edit dl rm
decode_stacktrace.sh	3834	0755	edit dl rm
depmod.sh	1119	0755	edit dl rm
diffconfig	3821	0755	edit dl rm
documentation-file-ref-check	3548	0755	edit dl rm
export_report.pl	4654	0755	edit dl rm
extract-cert	11616	0755	edit dl rm
extract-cert.c	3541	0644	edit dl rm
extract-ikconfig	1734	0755	edit dl rm
extract-module-sig.pl	3742	0755	edit dl rm
extract-sys-certs.pl	3832	0755	edit dl rm
extract-vmlinux	1725	0755	edit dl rm
extract_xc3028.pl	45665	0755	edit dl rm
faddr2line	6303	0755	edit dl rm
file-size.sh	86	0755	edit dl rm
find-unused-docs.sh	1310	0755	edit dl rm
gcc-goto.sh	530	0755	edit dl rm
gcc-ld	711	0755	edit dl rm
gcc-plugin.sh	1090	0755	edit dl rm
gcc-version.sh	857	0755	edit dl rm
gcc-x86_32-has-stack-protector.sh	173	0755	edit dl rm
gcc-x86_64-has-stack-protector.sh	198	0755	edit dl rm
gen_initramfs_list.sh	8224	0755	edit dl rm
get_dvb_firmware	25824	0755	edit dl rm
get_maintainer.pl	67369	0755	edit dl rm
gfp-translate	1752	0755	edit dl rm
headerdep.pl	3582	0755	edit dl rm
headers.sh	512	0755	edit dl rm
headers_check.pl	3815	0755	edit dl rm
headers_install.sh	1397	0755	edit dl rm
insert-sys-cert.c	9084	0644	edit dl rm
kallsyms	19992	0755	edit dl rm
kallsyms.c	18580	0644	edit dl rm
Kbuild.include	15468	0644	edit dl rm
Kconfig.include	1173	0644	edit dl rm
kernel-doc	62560	0755	edit dl rm
ld-version.sh	269	0755	edit dl rm
leaking_addresses.pl	13160	0755	edit dl rm
Lindent	502	0755	edit dl rm
link-vmlinux.sh	9176	0755	edit dl rm
Makefile	1741	0644	edit dl rm
Makefile.asm-generic	1193	0644	edit dl rm
Makefile.build	19707	0644	edit dl rm
Makefile.clean	2883	0644	edit dl rm
Makefile.dtbinst	1116	0644	edit dl rm
Makefile.extrawarn	2770	0644	edit dl rm
Makefile.gcc-plugins	1861	0644	edit dl rm
Makefile.headersinst	4079	0644	edit dl rm
Makefile.host	6520	0644	edit dl rm
Makefile.kasan	1679	0644	edit dl rm
Makefile.kcov	319	0644	edit dl rm
Makefile.kcsan	118	0644	edit dl rm
Makefile.lib	15535	0644	edit dl rm
Makefile.modbuiltin	1717	0644	edit dl rm
Makefile.modinst	1149	0644	edit dl rm
Makefile.modpost	5430	0644	edit dl rm
Makefile.modsign	897	0644	edit dl rm
Makefile.ubsan	951	0644	edit dl rm
makelst	808	0755	edit dl rm
markup_oops.pl	8273	0755	edit dl rm
mkcompile_h	2628	0755	edit dl rm
mkmakefile	1218	0755	edit dl rm
mksysmap	1359	0755	edit dl rm
mkuboot.sh	414	0755	edit dl rm
module-common.lds	901	0644	edit dl rm
modules.order	0	0644	edit dl rm
namespace.pl	13358	0755	edit dl rm
objdiff	2917	0755	edit dl rm
parse-maintainers.pl	4646	0755	edit dl rm
patch-kernel	10185	0755	edit dl rm
pnmtologo	15720	0755	edit dl rm
pnmtologo.c	12197	0644	edit dl rm
profile2linkerlist.pl	410	0755	edit dl rm
prune-kernel	708	0755	edit dl rm
recordmcount	24008	0755	edit dl rm
recordmcount.c	17062	0644	edit dl rm
recordmcount.h	16772	0644	edit dl rm
recordmcount.pl	18709	0755	edit dl rm
setlocalversion	4013	0755	edit dl rm
show_delta	3076	0755	edit dl rm
sign-file	15768	0755	edit dl rm
sign-file.c	9994	0644	edit dl rm
sortextable	15712	0755	edit dl rm
sortextable.c	10411	0644	edit dl rm
sortextable.h	5614	0644	edit dl rm
spelling.txt	25611	0644	edit dl rm
sphinx-pre-install	14378	0755	edit dl rm
split-man.pl	600	0755	edit dl rm
stackdelta	1883	0755	edit dl rm
stackusage	794	0755	edit dl rm
subarch.include	641	0644	edit dl rm
tags.sh	9789	0755	edit dl rm
test_fortify.sh	2281	0644	edit dl rm
unifdef	36192	0755	edit dl rm
unifdef.c	35637	0644	edit dl rm
ver_linux	2747	0755	edit dl rm
xen-hypercalls.sh	386	0644	edit dl rm
xz_wrap.sh	562	0755	edit dl rm

Edit: /usr/src/kernels/4.18.0-553.157.1.el8_10.x86_64/scripts/sortextable.c (10411B)

/*
 * sortextable.c: Sort the kernel's exception table
 *
 * Copyright 2011 - 2012 Cavium, Inc.
 *
 * Based on code taken from recortmcount.c which is:
 *
 * Copyright 2009 John F. Reiser <jreiser@BitWagon.com>.  All rights reserved.
 * Licensed under the GNU General Public License, version 2 (GPLv2).
 *
 * Restructured to fit Linux format, as well as other updates:
 *  Copyright 2010 Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.
 */

/*
 * Strategy: alter the vmlinux file in-place.
 */

#include <sys/types.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <getopt.h>
#include <elf.h>
#include <fcntl.h>
#include <setjmp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <tools/be_byteshift.h>
#include <tools/le_byteshift.h>

#ifndef EM_ARCOMPACT
#define EM_ARCOMPACT	93
#endif

#ifndef EM_XTENSA
#define EM_XTENSA	94
#endif

#ifndef EM_AARCH64
#define EM_AARCH64	183
#endif

#ifndef EM_MICROBLAZE
#define EM_MICROBLAZE	189
#endif

#ifndef EM_ARCV2
#define EM_ARCV2	195
#endif

static int fd_map;	/* File descriptor for file being modified. */
static int mmap_failed; /* Boolean flag. */
static void *ehdr_curr; /* current ElfXX_Ehdr *  for resource cleanup */
static struct stat sb;	/* Remember .st_size, etc. */
static jmp_buf jmpenv;	/* setjmp/longjmp per-file error escape */

/* setjmp() return values */
enum {
	SJ_SETJMP = 0,  /* hardwired first return */
	SJ_FAIL,
	SJ_SUCCEED
};

/* Per-file resource cleanup when multiple files. */
static void
cleanup(void)
{
	if (!mmap_failed)
		munmap(ehdr_curr, sb.st_size);
	close(fd_map);
}

static void __attribute__((noreturn))
fail_file(void)
{
	cleanup();
	longjmp(jmpenv, SJ_FAIL);
}

/*
 * Get the whole file as a programming convenience in order to avoid
 * malloc+lseek+read+free of many pieces.  If successful, then mmap
 * avoids copying unused pieces; else just read the whole file.
 * Open for both read and write.
 */
static void *mmap_file(char const *fname)
{
	void *addr;

fd_map = open(fname, O_RDWR);
	if (fd_map < 0 || fstat(fd_map, &sb) < 0) {
		perror(fname);
		fail_file();
	}
	if (!S_ISREG(sb.st_mode)) {
		fprintf(stderr, "not a regular file: %s\n", fname);
		fail_file();
	}
	addr = mmap(0, sb.st_size, PROT_READ|PROT_WRITE, MAP_SHARED,
		    fd_map, 0);
	if (addr == MAP_FAILED) {
		mmap_failed = 1;
		fprintf(stderr, "Could not mmap file: %s\n", fname);
		fail_file();
	}
	return addr;
}

static uint64_t r8be(const uint64_t *x)
{
	return get_unaligned_be64(x);
}
static uint32_t rbe(const uint32_t *x)
{
	return get_unaligned_be32(x);
}
static uint16_t r2be(const uint16_t *x)
{
	return get_unaligned_be16(x);
}
static uint64_t r8le(const uint64_t *x)
{
	return get_unaligned_le64(x);
}
static uint32_t rle(const uint32_t *x)
{
	return get_unaligned_le32(x);
}
static uint16_t r2le(const uint16_t *x)
{
	return get_unaligned_le16(x);
}

static void w8be(uint64_t val, uint64_t *x)
{
	put_unaligned_be64(val, x);
}
static void wbe(uint32_t val, uint32_t *x)
{
	put_unaligned_be32(val, x);
}
static void w2be(uint16_t val, uint16_t *x)
{
	put_unaligned_be16(val, x);
}
static void w8le(uint64_t val, uint64_t *x)
{
	put_unaligned_le64(val, x);
}
static void wle(uint32_t val, uint32_t *x)
{
	put_unaligned_le32(val, x);
}
static void w2le(uint16_t val, uint16_t *x)
{
	put_unaligned_le16(val, x);
}

static uint64_t (*r8)(const uint64_t *);
static uint32_t (*r)(const uint32_t *);
static uint16_t (*r2)(const uint16_t *);
static void (*w8)(uint64_t, uint64_t *);
static void (*w)(uint32_t, uint32_t *);
static void (*w2)(uint16_t, uint16_t *);

typedef void (*table_sort_t)(char *, int);

/*
 * Move reserved section indices SHN_LORESERVE..SHN_HIRESERVE out of
 * the way to -256..-1, to avoid conflicting with real section
 * indices.
 */
#define SPECIAL(i) ((i) - (SHN_HIRESERVE + 1))

static inline int is_shndx_special(unsigned int i)
{
	return i != SHN_XINDEX && i >= SHN_LORESERVE && i <= SHN_HIRESERVE;
}

/* Accessor for sym->st_shndx, hides ugliness of "64k sections" */
static inline unsigned int get_secindex(unsigned int shndx,
					unsigned int sym_offs,
					const Elf32_Word *symtab_shndx_start)
{
	if (is_shndx_special(shndx))
		return SPECIAL(shndx);
	if (shndx != SHN_XINDEX)
		return shndx;
	return r(&symtab_shndx_start[sym_offs]);
}

/* 32 bit and 64 bit are very similar */
#include "sortextable.h"
#define SORTEXTABLE_64
#include "sortextable.h"

static int compare_relative_table(const void *a, const void *b)
{
	int32_t av = (int32_t)r(a);
	int32_t bv = (int32_t)r(b);

if (av < bv)
		return -1;
	if (av > bv)
		return 1;
	return 0;
}

static void arm64_sort_relative_table(char *extab_image, int image_size)
{
	int i = 0;

while (i < image_size) {
		uint32_t *loc = (uint32_t *)(extab_image + i);

w(r(loc) + i, loc);
		w(r(loc + 1) + i + 4, loc + 1);
		/* Don't touch the fixup type or data */

i += sizeof(uint32_t) * 3;
	}

qsort(extab_image, image_size / 12, 12, compare_relative_table);

i = 0;
	while (i < image_size) {
		uint32_t *loc = (uint32_t *)(extab_image + i);

w(r(loc) - i, loc);
		w(r(loc + 1) - (i + 4), loc + 1);
		/* Don't touch the fixup type or data */

i += sizeof(uint32_t) * 3;
	}
}

static void x86_sort_relative_table(char *extab_image, int image_size)
{
	int i;

i = 0;
	while (i < image_size) {
		uint32_t *loc = (uint32_t *)(extab_image + i);

w(r(loc) + i, loc);
		w(r(loc + 1) + i + 4, loc + 1);
		w(r(loc + 2) + i + 8, loc + 2);

i += sizeof(uint32_t) * 3;
	}

qsort(extab_image, image_size / 12, 12, compare_relative_table);

i = 0;
	while (i < image_size) {
		uint32_t *loc = (uint32_t *)(extab_image + i);

w(r(loc) - i, loc);
		w(r(loc + 1) - (i + 4), loc + 1);
		w(r(loc + 2) - (i + 8), loc + 2);

i += sizeof(uint32_t) * 3;
	}
}

static void s390_sort_relative_table(char *extab_image, int image_size)
{
	int i;

for (i = 0; i < image_size; i += 16) {
		char *loc = extab_image + i;
		uint64_t handler;

w(r((uint32_t *)loc) + i, (uint32_t *)loc);
		w(r((uint32_t *)(loc + 4)) + (i + 4), (uint32_t *)(loc + 4));
		/*
		 * 0 is a special self-relative handler value, which means that
		 * handler should be ignored. It is safe, because it means that
		 * handler field points to itself, which should never happen.
		 * When creating extable-relative values, keep it as 0, since
		 * this should never occur either: it would mean that handler
		 * field points to the first extable entry.
		 */
		handler = r8((uint64_t *)(loc + 8));
		if (handler)
			handler += i + 8;
		w8(handler, (uint64_t *)(loc + 8));
	}

qsort(extab_image, image_size / 16, 16, compare_relative_table);

for (i = 0; i < image_size; i += 16) {
		char *loc = extab_image + i;
		uint64_t handler;

w(r((uint32_t *)loc) - i, (uint32_t *)loc);
		w(r((uint32_t *)(loc + 4)) - (i + 4), (uint32_t *)(loc + 4));
		handler = r8((uint64_t *)(loc + 8));
		if (handler)
			handler -= i + 8;
		w8(handler, (uint64_t *)(loc + 8));
	}
}

static void sort_relative_table(char *extab_image, int image_size)
{
	int i;

/*
	 * Do the same thing the runtime sort does, first normalize to
	 * being relative to the start of the section.
	 */
	i = 0;
	while (i < image_size) {
		uint32_t *loc = (uint32_t *)(extab_image + i);
		w(r(loc) + i, loc);
		i += 4;
	}

qsort(extab_image, image_size / 8, 8, compare_relative_table);

/* Now denormalize. */
	i = 0;
	while (i < image_size) {
		uint32_t *loc = (uint32_t *)(extab_image + i);
		w(r(loc) - i, loc);
		i += 4;
	}
}

static void
do_file(char const *const fname)
{
	table_sort_t custom_sort;
	Elf32_Ehdr *ehdr = mmap_file(fname);

ehdr_curr = ehdr;
	switch (ehdr->e_ident[EI_DATA]) {
	default:
		fprintf(stderr, "unrecognized ELF data encoding %d: %s\n",
			ehdr->e_ident[EI_DATA], fname);
		fail_file();
		break;
	case ELFDATA2LSB:
		r = rle;
		r2 = r2le;
		r8 = r8le;
		w = wle;
		w2 = w2le;
		w8 = w8le;
		break;
	case ELFDATA2MSB:
		r = rbe;
		r2 = r2be;
		r8 = r8be;
		w = wbe;
		w2 = w2be;
		w8 = w8be;
		break;
	}  /* end switch */
	if (memcmp(ELFMAG, ehdr->e_ident, SELFMAG) != 0
	||  (r2(&ehdr->e_type) != ET_EXEC && r2(&ehdr->e_type) != ET_DYN)
	||  ehdr->e_ident[EI_VERSION] != EV_CURRENT) {
		fprintf(stderr, "unrecognized ET_EXEC/ET_DYN file %s\n", fname);
		fail_file();
	}

custom_sort = NULL;
	switch (r2(&ehdr->e_machine)) {
	default:
		fprintf(stderr, "unrecognized e_machine %d %s\n",
			r2(&ehdr->e_machine), fname);
		fail_file();
		break;
	case EM_386:
	case EM_X86_64:
		custom_sort = x86_sort_relative_table;
		break;

case EM_S390:
		custom_sort = s390_sort_relative_table;
		break;
	case EM_AARCH64:
		custom_sort = arm64_sort_relative_table;
		break;
	case EM_PARISC:
	case EM_PPC:
	case EM_PPC64:
		custom_sort = sort_relative_table;
		break;
	case EM_ARCOMPACT:
	case EM_ARCV2:
	case EM_ARM:
	case EM_MICROBLAZE:
	case EM_MIPS:
	case EM_XTENSA:
		break;
	}  /* end switch */

switch (ehdr->e_ident[EI_CLASS]) {
	default:
		fprintf(stderr, "unrecognized ELF class %d %s\n",
			ehdr->e_ident[EI_CLASS], fname);
		fail_file();
		break;
	case ELFCLASS32:
		if (r2(&ehdr->e_ehsize) != sizeof(Elf32_Ehdr)
		||  r2(&ehdr->e_shentsize) != sizeof(Elf32_Shdr)) {
			fprintf(stderr,
				"unrecognized ET_EXEC/ET_DYN file: %s\n", fname);
			fail_file();
		}
		do32(ehdr, fname, custom_sort);
		break;
	case ELFCLASS64: {
		Elf64_Ehdr *const ghdr = (Elf64_Ehdr *)ehdr;
		if (r2(&ghdr->e_ehsize) != sizeof(Elf64_Ehdr)
		||  r2(&ghdr->e_shentsize) != sizeof(Elf64_Shdr)) {
			fprintf(stderr,
				"unrecognized ET_EXEC/ET_DYN file: %s\n", fname);
			fail_file();
		}
		do64(ghdr, fname, custom_sort);
		break;
	}
	}  /* end switch */

cleanup();
}

int
main(int argc, char *argv[])
{
	int n_error = 0;  /* gcc-4.3.0 false positive complaint */
	int i;

if (argc < 2) {
		fprintf(stderr, "usage: sortextable vmlinux...\n");
		return 0;
	}

/* Process each file in turn, allowing deep failure. */
	for (i = 1; i < argc; i++) {
		char *file = argv[i];
		int const sjval = setjmp(jmpenv);

switch (sjval) {
		default:
			fprintf(stderr, "internal error: %s\n", file);
			exit(1);
			break;
		case SJ_SETJMP:    /* normal sequence */
			/* Avoid problems if early cleanup() */
			fd_map = -1;
			ehdr_curr = NULL;
			mmap_failed = 1;
			do_file(file);
			break;
		case SJ_FAIL:    /* error in do_file or below */
			++n_error;
			break;
		case SJ_SUCCEED:    /* premature success */
			/* do nothing */
			break;
		}  /* end switch */
	}
	return !!n_error;
}

cmd: