linux/scripts/sortextable.c at master · fabgithub/linux · GitHub

Repository navigation

History

329 lines (297 loc) · 6.83 KB

Raw

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

* sortextable.c: Sort the kernel's exception table

* Based on code taken from recortmcount.c which is:

* Licensed under the GNU General Public License, version 2 (GPLv2).

* Restructured to fit Linux format, as well as other updates:

* 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_AARCH64

#define EM_AARCH64 183

#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);

}

static void __attribute__((noreturn))

succeed_file(void)

{

cleanup();

longjmp(jmpenv, SJ_SUCCEED);

}

* 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);

/* 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 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

|| ehdr->e_ident[EI_VERSION] != EV_CURRENT) {

fprintf(stderr, "unrecognized ET_EXEC 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:

case EM_S390:

custom_sort = sort_relative_table;

break;

case EM_ARM:

case EM_AARCH64:

case EM_MIPS:

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 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 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;

}

linux/scripts/sortextable.c at master · fabgithub/linux · GitHub

Repository navigation

Expand file tree

Breadcrumbs

sortextable.c

Latest commit

History

Breadcrumbs

sortextable.c

File metadata and controls