Doug / smarc-fsl-linux-kernel

1

/*

1

/*

2

* linux/fs/binfmt_elf.c

2

* linux/fs/binfmt_elf.c

3

*

3

*

4

* These are the functions used to load ELF format executables as used

4

* These are the functions used to load ELF format executables as used

5

* on SVr4 machines. Information on the format may be found in the book

5

* on SVr4 machines. Information on the format may be found in the book

6

* "UNIX SYSTEM V RELEASE 4 Programmers Guide: Ansi C and Programming Support

6

* "UNIX SYSTEM V RELEASE 4 Programmers Guide: Ansi C and Programming Support

7

* Tools".

7

* Tools".

8

*

8

*

9

10

*/

10

*/

11

12

#include <linux/module.h>

12

#include <linux/module.h>

13

#include <linux/kernel.h>

13

#include <linux/kernel.h>

14

#include <linux/fs.h>

14

#include <linux/fs.h>

15

#include <linux/stat.h>

15

#include <linux/stat.h>

16

#include <linux/time.h>

16

#include <linux/time.h>

17

#include <linux/mm.h>

17

#include <linux/mm.h>

18

#include <linux/mman.h>

18

#include <linux/mman.h>

19

#include <linux/a.out.h>

19

#include <linux/a.out.h>

20

#include <linux/errno.h>

20

#include <linux/errno.h>

21

#include <linux/signal.h>

21

#include <linux/signal.h>

22

#include <linux/binfmts.h>

22

#include <linux/binfmts.h>

23

#include <linux/string.h>

23

#include <linux/string.h>

24

#include <linux/file.h>

24

#include <linux/file.h>

25

#include <linux/fcntl.h>

25

#include <linux/fcntl.h>

26

#include <linux/ptrace.h>

26

#include <linux/ptrace.h>

27

#include <linux/slab.h>

27

#include <linux/slab.h>

28

#include <linux/shm.h>

28

#include <linux/shm.h>

29

#include <linux/personality.h>

29

#include <linux/personality.h>

30

#include <linux/elfcore.h>

30

#include <linux/elfcore.h>

31

#include <linux/init.h>

31

#include <linux/init.h>

32

#include <linux/highuid.h>

32

#include <linux/highuid.h>

33

#include <linux/smp.h>

33

#include <linux/smp.h>

34

#include <linux/smp_lock.h>

34

#include <linux/smp_lock.h>

35

#include <linux/compiler.h>

35

#include <linux/compiler.h>

36

#include <linux/highmem.h>

36

#include <linux/highmem.h>

37

#include <linux/pagemap.h>

37

#include <linux/pagemap.h>

38

#include <linux/security.h>

38

#include <linux/security.h>

39

#include <linux/syscalls.h>

39

#include <linux/syscalls.h>

40

#include <linux/random.h>

40

#include <linux/random.h>

41

42

#include <asm/uaccess.h>

42

#include <asm/uaccess.h>

43

#include <asm/param.h>

43

#include <asm/param.h>

44

#include <asm/page.h>

44

#include <asm/page.h>

45

46

#include <linux/elf.h>

46

#include <linux/elf.h>

47

48

static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs);

48

static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs);

49

static int load_elf_library(struct file*);

49

static int load_elf_library(struct file*);

50

static unsigned long elf_map (struct file *, unsigned long, struct elf_phdr *, int, int);

50

static unsigned long elf_map (struct file *, unsigned long, struct elf_phdr *, int, int);

51

extern int dump_fpu (struct pt_regs *, elf_fpregset_t *);

51

extern int dump_fpu (struct pt_regs *, elf_fpregset_t *);

52

53

#ifndef elf_addr_t

53

#ifndef elf_addr_t

54

#define elf_addr_t unsigned long

54

#define elf_addr_t unsigned long

55

#endif

55

#endif

56

57

/*

57

/*

58

* If we don't support core dumping, then supply a NULL so we

58

* If we don't support core dumping, then supply a NULL so we

59

* don't even try.

59

* don't even try.

60

*/

60

*/

61

#ifdef USE_ELF_CORE_DUMP

61

#ifdef USE_ELF_CORE_DUMP

62

static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file);

62

static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file);

63

#else

63

#else

64

#define elf_core_dump NULL

64

#define elf_core_dump NULL

65

#endif

65

#endif

66

67

#if ELF_EXEC_PAGESIZE > PAGE_SIZE

67

#if ELF_EXEC_PAGESIZE > PAGE_SIZE

68

# define ELF_MIN_ALIGN ELF_EXEC_PAGESIZE

68

# define ELF_MIN_ALIGN ELF_EXEC_PAGESIZE

69

#else

69

#else

70

# define ELF_MIN_ALIGN PAGE_SIZE

70

# define ELF_MIN_ALIGN PAGE_SIZE

71

#endif

71

#endif

72

73

#ifndef ELF_CORE_EFLAGS

73

#ifndef ELF_CORE_EFLAGS

74

#define ELF_CORE_EFLAGS 0

74

#define ELF_CORE_EFLAGS 0

75

#endif

75

#endif

76

77

#define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))

77

#define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))

78

#define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))

78

#define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))

79

#define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))

79

#define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))

80

81

static struct linux_binfmt elf_format = {

81

static struct linux_binfmt elf_format = {

82

.module = THIS_MODULE,

82

.module = THIS_MODULE,

83

.load_binary = load_elf_binary,

83

.load_binary = load_elf_binary,

84

.load_shlib = load_elf_library,

84

.load_shlib = load_elf_library,

85

.core_dump = elf_core_dump,

85

.core_dump = elf_core_dump,

86

.min_coredump = ELF_EXEC_PAGESIZE

86

.min_coredump = ELF_EXEC_PAGESIZE

87

};

87

};

88

89

#define BAD_ADDR(x) ((unsigned long)(x) > TASK_SIZE)

89

#define BAD_ADDR(x) ((unsigned long)(x) > TASK_SIZE)

90

91

static int set_brk(unsigned long start, unsigned long end)

91

static int set_brk(unsigned long start, unsigned long end)

92

{

92

{

93

start = ELF_PAGEALIGN(start);

93

start = ELF_PAGEALIGN(start);

94

end = ELF_PAGEALIGN(end);

94

end = ELF_PAGEALIGN(end);

95

if (end > start) {

95

if (end > start) {

96

unsigned long addr;

96

unsigned long addr;

97

down_write(&current->mm->mmap_sem);

97

down_write(&current->mm->mmap_sem);

98

addr = do_brk(start, end - start);

98

addr = do_brk(start, end - start);

99

up_write(&current->mm->mmap_sem);

99

up_write(&current->mm->mmap_sem);

100

if (BAD_ADDR(addr))

100

if (BAD_ADDR(addr))

101

return addr;

101

return addr;

102

}

102

}

103

current->mm->start_brk = current->mm->brk = end;

103

current->mm->start_brk = current->mm->brk = end;

104

return 0;

104

return 0;

105

}

105

}

106

107

108

/* We need to explicitly zero any fractional pages

108

/* We need to explicitly zero any fractional pages

109

after the data section (i.e. bss). This would

109

after the data section (i.e. bss). This would

110

contain the junk from the file that should not

110

contain the junk from the file that should not

111

be in memory */

111

be in memory */

112

113

114

static int padzero(unsigned long elf_bss)

114

static int padzero(unsigned long elf_bss)

115

{

115

{

116

unsigned long nbyte;

116

unsigned long nbyte;

117

118

nbyte = ELF_PAGEOFFSET(elf_bss);

118

nbyte = ELF_PAGEOFFSET(elf_bss);

119

if (nbyte) {

119

if (nbyte) {

120

nbyte = ELF_MIN_ALIGN - nbyte;

120

nbyte = ELF_MIN_ALIGN - nbyte;

121

if (clear_user((void __user *) elf_bss, nbyte))

121

if (clear_user((void __user *) elf_bss, nbyte))

122

return -EFAULT;

122

return -EFAULT;

123

}

123

}

124

return 0;

124

return 0;

125

}

125

}

126

127

/* Let's use some macros to make this stack manipulation a litle clearer */

127

/* Let's use some macros to make this stack manipulation a litle clearer */

128

#ifdef CONFIG_STACK_GROWSUP

128

#ifdef CONFIG_STACK_GROWSUP

129

#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) + (items))

129

#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) + (items))

130

#define STACK_ROUND(sp, items) \

130

#define STACK_ROUND(sp, items) \

131

((15 + (unsigned long) ((sp) + (items))) &~ 15UL)

131

((15 + (unsigned long) ((sp) + (items))) &~ 15UL)

132

#define STACK_ALLOC(sp, len) ({ elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; old_sp; })

132

#define STACK_ALLOC(sp, len) ({ elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; old_sp; })

133

#else

133

#else

134

#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) - (items))

134

#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) - (items))

135

#define STACK_ROUND(sp, items) \

135

#define STACK_ROUND(sp, items) \

136

(((unsigned long) (sp - items)) &~ 15UL)

136

(((unsigned long) (sp - items)) &~ 15UL)

137

#define STACK_ALLOC(sp, len) ({ sp -= len ; sp; })

137

#define STACK_ALLOC(sp, len) ({ sp -= len ; sp; })

138

#endif

138

#endif

139

140

static int

140

static int

141

create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,

141

create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,

142

int interp_aout, unsigned long load_addr,

142

int interp_aout, unsigned long load_addr,

143

unsigned long interp_load_addr)

143

unsigned long interp_load_addr)

144

{

144

{

145

unsigned long p = bprm->p;

145

unsigned long p = bprm->p;

146

int argc = bprm->argc;

146

int argc = bprm->argc;

147

int envc = bprm->envc;

147

int envc = bprm->envc;

148

elf_addr_t __user *argv;

148

elf_addr_t __user *argv;

149

elf_addr_t __user *envp;

149

elf_addr_t __user *envp;

150

elf_addr_t __user *sp;

150

elf_addr_t __user *sp;

151

elf_addr_t __user *u_platform;

151

elf_addr_t __user *u_platform;

152

const char *k_platform = ELF_PLATFORM;

152

const char *k_platform = ELF_PLATFORM;

153

int items;

153

int items;

154

elf_addr_t *elf_info;

154

elf_addr_t *elf_info;

155

int ei_index = 0;

155

int ei_index = 0;

156

struct task_struct *tsk = current;

156

struct task_struct *tsk = current;

157

158

/*

158

/*

159

* If this architecture has a platform capability string, copy it

159

* If this architecture has a platform capability string, copy it

160

* to userspace. In some cases (Sparc), this info is impossible

160

* to userspace. In some cases (Sparc), this info is impossible

161

* for userspace to get any other way, in others (i386) it is

161

* for userspace to get any other way, in others (i386) it is

162

* merely difficult.

162

* merely difficult.

163

*/

163

*/

164

165

u_platform = NULL;

165

u_platform = NULL;

166

if (k_platform) {

166

if (k_platform) {

167

size_t len = strlen(k_platform) + 1;

167

size_t len = strlen(k_platform) + 1;

168

169

/*

169

/*

170

* In some cases (e.g. Hyper-Threading), we want to avoid L1

170

* In some cases (e.g. Hyper-Threading), we want to avoid L1

171

* evictions by the processes running on the same package. One

171

* evictions by the processes running on the same package. One

172

* thing we can do is to shuffle the initial stack for them.

172

* thing we can do is to shuffle the initial stack for them.

173

*/

173

*/

174

175

p = arch_align_stack(p);

175

p = arch_align_stack(p);

176

177

u_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);

177

u_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);

178

if (__copy_to_user(u_platform, k_platform, len))

178

if (__copy_to_user(u_platform, k_platform, len))

179

return -EFAULT;

179

return -EFAULT;

180

}

180

}

181

182

/* Create the ELF interpreter info */

182

/* Create the ELF interpreter info */

183

elf_info = (elf_addr_t *) current->mm->saved_auxv;

183

elf_info = (elf_addr_t *) current->mm->saved_auxv;

184

#define NEW_AUX_ENT(id, val) \

184

#define NEW_AUX_ENT(id, val) \

185

do { elf_info[ei_index++] = id; elf_info[ei_index++] = val; } while (0)

185

do { elf_info[ei_index++] = id; elf_info[ei_index++] = val; } while (0)

186

187

#ifdef ARCH_DLINFO

187

#ifdef ARCH_DLINFO

188

/*

188

/*

189

* ARCH_DLINFO must come first so PPC can do its special alignment of

189

* ARCH_DLINFO must come first so PPC can do its special alignment of

190

* AUXV.

190

* AUXV.

191

*/

191

*/

192

ARCH_DLINFO;

192

ARCH_DLINFO;

193

#endif

193

#endif

194

NEW_AUX_ENT(AT_HWCAP, ELF_HWCAP);

194

NEW_AUX_ENT(AT_HWCAP, ELF_HWCAP);

195

NEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);

195

NEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);

196

NEW_AUX_ENT(AT_CLKTCK, CLOCKS_PER_SEC);

196

NEW_AUX_ENT(AT_CLKTCK, CLOCKS_PER_SEC);

197

NEW_AUX_ENT(AT_PHDR, load_addr + exec->e_phoff);

197

NEW_AUX_ENT(AT_PHDR, load_addr + exec->e_phoff);

198

NEW_AUX_ENT(AT_PHENT, sizeof (struct elf_phdr));

198

NEW_AUX_ENT(AT_PHENT, sizeof (struct elf_phdr));

199

NEW_AUX_ENT(AT_PHNUM, exec->e_phnum);

199

NEW_AUX_ENT(AT_PHNUM, exec->e_phnum);

200

NEW_AUX_ENT(AT_BASE, interp_load_addr);

200

NEW_AUX_ENT(AT_BASE, interp_load_addr);

201

NEW_AUX_ENT(AT_FLAGS, 0);

201

NEW_AUX_ENT(AT_FLAGS, 0);

202

NEW_AUX_ENT(AT_ENTRY, exec->e_entry);

202

NEW_AUX_ENT(AT_ENTRY, exec->e_entry);

203

NEW_AUX_ENT(AT_UID, (elf_addr_t) tsk->uid);

203

NEW_AUX_ENT(AT_UID, (elf_addr_t) tsk->uid);

204

NEW_AUX_ENT(AT_EUID, (elf_addr_t) tsk->euid);

204

NEW_AUX_ENT(AT_EUID, (elf_addr_t) tsk->euid);

205

NEW_AUX_ENT(AT_GID, (elf_addr_t) tsk->gid);

205

NEW_AUX_ENT(AT_GID, (elf_addr_t) tsk->gid);

206

NEW_AUX_ENT(AT_EGID, (elf_addr_t) tsk->egid);

206

NEW_AUX_ENT(AT_EGID, (elf_addr_t) tsk->egid);

207

NEW_AUX_ENT(AT_SECURE, (elf_addr_t) security_bprm_secureexec(bprm));

207

NEW_AUX_ENT(AT_SECURE, (elf_addr_t) security_bprm_secureexec(bprm));

208

if (k_platform) {

208

if (k_platform) {

209

NEW_AUX_ENT(AT_PLATFORM, (elf_addr_t)(unsigned long)u_platform);

209

NEW_AUX_ENT(AT_PLATFORM, (elf_addr_t)(unsigned long)u_platform);

210

}

210

}

211

if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {

211

if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {

212

NEW_AUX_ENT(AT_EXECFD, (elf_addr_t) bprm->interp_data);

212

NEW_AUX_ENT(AT_EXECFD, (elf_addr_t) bprm->interp_data);

213

}

213

}

214

#undef NEW_AUX_ENT

214

#undef NEW_AUX_ENT

215

/* AT_NULL is zero; clear the rest too */

215

/* AT_NULL is zero; clear the rest too */

216

memset(&elf_info[ei_index], 0,

216

memset(&elf_info[ei_index], 0,

217

sizeof current->mm->saved_auxv - ei_index * sizeof elf_info[0]);

217

sizeof current->mm->saved_auxv - ei_index * sizeof elf_info[0]);

218

219

/* And advance past the AT_NULL entry. */

219

/* And advance past the AT_NULL entry. */

220

ei_index += 2;

220

ei_index += 2;

221

222

sp = STACK_ADD(p, ei_index);

222

sp = STACK_ADD(p, ei_index);

223

224

items = (argc + 1) + (envc + 1);

224

items = (argc + 1) + (envc + 1);

225

if (interp_aout) {

225

if (interp_aout) {

226

items += 3; /* a.out interpreters require argv & envp too */

226

items += 3; /* a.out interpreters require argv & envp too */

227

} else {

227

} else {

228

items += 1; /* ELF interpreters only put argc on the stack */

228

items += 1; /* ELF interpreters only put argc on the stack */

229

}

229

}

230

bprm->p = STACK_ROUND(sp, items);

230

bprm->p = STACK_ROUND(sp, items);

231

232

/* Point sp at the lowest address on the stack */

232

/* Point sp at the lowest address on the stack */

233

#ifdef CONFIG_STACK_GROWSUP

233

#ifdef CONFIG_STACK_GROWSUP

234

sp = (elf_addr_t __user *)bprm->p - items - ei_index;

234

sp = (elf_addr_t __user *)bprm->p - items - ei_index;

235

bprm->exec = (unsigned long) sp; /* XXX: PARISC HACK */

235

bprm->exec = (unsigned long) sp; /* XXX: PARISC HACK */

236

#else

236

#else

237

sp = (elf_addr_t __user *)bprm->p;

237

sp = (elf_addr_t __user *)bprm->p;

238

#endif

238

#endif

239

240

/* Now, let's put argc (and argv, envp if appropriate) on the stack */

240

/* Now, let's put argc (and argv, envp if appropriate) on the stack */

241

if (__put_user(argc, sp++))

241

if (__put_user(argc, sp++))

242

return -EFAULT;

242

return -EFAULT;

243

if (interp_aout) {

243

if (interp_aout) {

244

argv = sp + 2;

244

argv = sp + 2;

245

envp = argv + argc + 1;

245

envp = argv + argc + 1;

246

__put_user((elf_addr_t)(unsigned long)argv, sp++);

246

__put_user((elf_addr_t)(unsigned long)argv, sp++);

247

__put_user((elf_addr_t)(unsigned long)envp, sp++);

247

__put_user((elf_addr_t)(unsigned long)envp, sp++);

248

} else {

248

} else {

249

argv = sp;

249

argv = sp;

250

envp = argv + argc + 1;

250

envp = argv + argc + 1;

251

}

251

}

252

253

/* Populate argv and envp */

253

/* Populate argv and envp */

254

p = current->mm->arg_end = current->mm->arg_start;

254

p = current->mm->arg_end = current->mm->arg_start;

255

while (argc-- > 0) {

255

while (argc-- > 0) {

256

size_t len;

256

size_t len;

257

__put_user((elf_addr_t)p, argv++);

257

__put_user((elf_addr_t)p, argv++);

258

len = strnlen_user((void __user *)p, PAGE_SIZE*MAX_ARG_PAGES);

258

len = strnlen_user((void __user *)p, PAGE_SIZE*MAX_ARG_PAGES);

259

if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)

259

if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)

260

return 0;

260

return 0;

261

p += len;

261

p += len;

262

}

262

}

263

if (__put_user(0, argv))

263

if (__put_user(0, argv))

264

return -EFAULT;

264

return -EFAULT;

265

current->mm->arg_end = current->mm->env_start = p;

265

current->mm->arg_end = current->mm->env_start = p;

266

while (envc-- > 0) {

266

while (envc-- > 0) {

267

size_t len;

267

size_t len;

268

__put_user((elf_addr_t)p, envp++);

268

__put_user((elf_addr_t)p, envp++);

269

len = strnlen_user((void __user *)p, PAGE_SIZE*MAX_ARG_PAGES);

269

len = strnlen_user((void __user *)p, PAGE_SIZE*MAX_ARG_PAGES);

270

if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)

270

if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)

271

return 0;

271

return 0;

272

p += len;

272

p += len;

273

}

273

}

274

if (__put_user(0, envp))

274

if (__put_user(0, envp))

275

return -EFAULT;

275

return -EFAULT;

276

current->mm->env_end = p;

276

current->mm->env_end = p;

277

278

/* Put the elf_info on the stack in the right place. */

278

/* Put the elf_info on the stack in the right place. */

279

sp = (elf_addr_t __user *)envp + 1;

279

sp = (elf_addr_t __user *)envp + 1;

280

if (copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t)))

280

if (copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t)))

281

return -EFAULT;

281

return -EFAULT;

282

return 0;

282

return 0;

283

}

283

}

284

285

#ifndef elf_map

285

#ifndef elf_map

286

287

static unsigned long elf_map(struct file *filep, unsigned long addr,

287

static unsigned long elf_map(struct file *filep, unsigned long addr,

288

struct elf_phdr *eppnt, int prot, int type)

288

struct elf_phdr *eppnt, int prot, int type)

289

{

289

{

290

unsigned long map_addr;

290

unsigned long map_addr;

291

292

down_write(&current->mm->mmap_sem);

292

down_write(&current->mm->mmap_sem);

293

map_addr = do_mmap(filep, ELF_PAGESTART(addr),

293

map_addr = do_mmap(filep, ELF_PAGESTART(addr),

294

eppnt->p_filesz + ELF_PAGEOFFSET(eppnt->p_vaddr), prot, type,

294

eppnt->p_filesz + ELF_PAGEOFFSET(eppnt->p_vaddr), prot, type,

295

eppnt->p_offset - ELF_PAGEOFFSET(eppnt->p_vaddr));

295

eppnt->p_offset - ELF_PAGEOFFSET(eppnt->p_vaddr));

296

up_write(&current->mm->mmap_sem);

296

up_write(&current->mm->mmap_sem);

297

return(map_addr);

297

return(map_addr);

298

}

298

}

299

300

#endif /* !elf_map */

300

#endif /* !elf_map */

301

302

/* This is much more generalized than the library routine read function,

302

/* This is much more generalized than the library routine read function,

303

so we keep this separate. Technically the library read function

303

so we keep this separate. Technically the library read function

304

is only provided so that we can read a.out libraries that have

304

is only provided so that we can read a.out libraries that have

305

an ELF header */

305

an ELF header */

306

307

static unsigned long load_elf_interp(struct elfhdr * interp_elf_ex,

307

static unsigned long load_elf_interp(struct elfhdr * interp_elf_ex,

308

struct file * interpreter,

308

struct file * interpreter,

309

unsigned long *interp_load_addr)

309

unsigned long *interp_load_addr)

310

{

310

{

311

struct elf_phdr *elf_phdata;

311

struct elf_phdr *elf_phdata;

312

struct elf_phdr *eppnt;

312

struct elf_phdr *eppnt;

313

unsigned long load_addr = 0;

313

unsigned long load_addr = 0;

314

int load_addr_set = 0;

314

int load_addr_set = 0;

315

unsigned long last_bss = 0, elf_bss = 0;

315

unsigned long last_bss = 0, elf_bss = 0;

316

unsigned long error = ~0UL;

316

unsigned long error = ~0UL;

317

int retval, i, size;

317

int retval, i, size;

318

319

/* First of all, some simple consistency checks */

319

/* First of all, some simple consistency checks */

320

if (interp_elf_ex->e_type != ET_EXEC &&

320

if (interp_elf_ex->e_type != ET_EXEC &&

321

interp_elf_ex->e_type != ET_DYN)

321

interp_elf_ex->e_type != ET_DYN)

322

goto out;

322

goto out;

323

if (!elf_check_arch(interp_elf_ex))

323

if (!elf_check_arch(interp_elf_ex))

324

goto out;

324

goto out;

325

if (!interpreter->f_op || !interpreter->f_op->mmap)

325

if (!interpreter->f_op || !interpreter->f_op->mmap)

326

goto out;

326

goto out;

327

328

/*

328

/*

329

* If the size of this structure has changed, then punt, since

329

* If the size of this structure has changed, then punt, since

330

* we will be doing the wrong thing.

330

* we will be doing the wrong thing.

331

*/

331

*/

332

if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr))

332

if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr))

333

goto out;

333

goto out;

334

if (interp_elf_ex->e_phnum < 1 ||

334

if (interp_elf_ex->e_phnum < 1 ||

335

interp_elf_ex->e_phnum > 65536U / sizeof(struct elf_phdr))

335

interp_elf_ex->e_phnum > 65536U / sizeof(struct elf_phdr))

336

goto out;

336

goto out;

337

338

/* Now read in all of the header information */

338

/* Now read in all of the header information */

339

340

size = sizeof(struct elf_phdr) * interp_elf_ex->e_phnum;

340

size = sizeof(struct elf_phdr) * interp_elf_ex->e_phnum;

341

if (size > ELF_MIN_ALIGN)

341

if (size > ELF_MIN_ALIGN)

342

goto out;

342

goto out;

343

elf_phdata = (struct elf_phdr *) kmalloc(size, GFP_KERNEL);

343

elf_phdata = (struct elf_phdr *) kmalloc(size, GFP_KERNEL);

344

if (!elf_phdata)

344

if (!elf_phdata)

345

goto out;

345

goto out;

346

347

retval = kernel_read(interpreter,interp_elf_ex->e_phoff,(char *)elf_phdata,size);

347

retval = kernel_read(interpreter,interp_elf_ex->e_phoff,(char *)elf_phdata,size);

348

error = -EIO;

348

error = -EIO;

349

if (retval != size) {

349

if (retval != size) {

350

if (retval < 0)

350

if (retval < 0)

351

error = retval;

351

error = retval;

352

goto out_close;

352

goto out_close;

353

}

353

}

354

355

eppnt = elf_phdata;

355

eppnt = elf_phdata;

356

for (i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) {

356

for (i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) {

357

if (eppnt->p_type == PT_LOAD) {

357

if (eppnt->p_type == PT_LOAD) {

358

int elf_type = MAP_PRIVATE | MAP_DENYWRITE;

358

int elf_type = MAP_PRIVATE | MAP_DENYWRITE;

359

int elf_prot = 0;

359

int elf_prot = 0;

360

unsigned long vaddr = 0;

360

unsigned long vaddr = 0;

361

unsigned long k, map_addr;

361

unsigned long k, map_addr;

362

363

if (eppnt->p_flags & PF_R) elf_prot = PROT_READ;

363

if (eppnt->p_flags & PF_R) elf_prot = PROT_READ;

364

if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;

364

if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;

365

if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;

365

if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;

366

vaddr = eppnt->p_vaddr;

366

vaddr = eppnt->p_vaddr;

367

if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)

367

if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)

368

elf_type |= MAP_FIXED;

368

elf_type |= MAP_FIXED;

369

370

map_addr = elf_map(interpreter, load_addr + vaddr, eppnt, elf_prot, elf_type);

370

map_addr = elf_map(interpreter, load_addr + vaddr, eppnt, elf_prot, elf_type);

371

error = map_addr;

371

error = map_addr;

372

if (BAD_ADDR(map_addr))

372

if (BAD_ADDR(map_addr))

373

goto out_close;

373

goto out_close;

374

375

if (!load_addr_set && interp_elf_ex->e_type == ET_DYN) {

375

if (!load_addr_set && interp_elf_ex->e_type == ET_DYN) {

376

load_addr = map_addr - ELF_PAGESTART(vaddr);

376

load_addr = map_addr - ELF_PAGESTART(vaddr);

377

load_addr_set = 1;

377

load_addr_set = 1;

378

}

378

}

379

380

/*

380

/*

381

* Check to see if the section's size will overflow the

381

* Check to see if the section's size will overflow the

382

* allowed task size. Note that p_filesz must always be

382

* allowed task size. Note that p_filesz must always be

383

* <= p_memsize so it is only necessary to check p_memsz.

383

* <= p_memsize so it is only necessary to check p_memsz.

384

*/

384

*/

385

k = load_addr + eppnt->p_vaddr;

385

k = load_addr + eppnt->p_vaddr;

386

if (k > TASK_SIZE || eppnt->p_filesz > eppnt->p_memsz ||

386

if (k > TASK_SIZE || eppnt->p_filesz > eppnt->p_memsz ||

387

eppnt->p_memsz > TASK_SIZE || TASK_SIZE - eppnt->p_memsz < k) {

387

eppnt->p_memsz > TASK_SIZE || TASK_SIZE - eppnt->p_memsz < k) {

388

error = -ENOMEM;

388

error = -ENOMEM;

389

goto out_close;

389

goto out_close;

390

}

390

}

391

392

/*

392

/*

393

* Find the end of the file mapping for this phdr, and keep

393

* Find the end of the file mapping for this phdr, and keep

394

* track of the largest address we see for this.

394

* track of the largest address we see for this.

395

*/

395

*/

396

k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;

396

k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;

397

if (k > elf_bss)

397

if (k > elf_bss)

398

elf_bss = k;

398

elf_bss = k;

399

400

/*

400

/*

401

* Do the same thing for the memory mapping - between

401

* Do the same thing for the memory mapping - between

402

* elf_bss and last_bss is the bss section.

402

* elf_bss and last_bss is the bss section.

403

*/

403

*/

404

k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;

404

k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;

405

if (k > last_bss)

405

if (k > last_bss)

406

last_bss = k;

406

last_bss = k;

407

}

407

}

408

}

408

}

409

410

/*

410

/*

411

* Now fill out the bss section. First pad the last page up

411

* Now fill out the bss section. First pad the last page up

412

* to the page boundary, and then perform a mmap to make sure

412

* to the page boundary, and then perform a mmap to make sure

413

* that there are zero-mapped pages up to and including the

413

* that there are zero-mapped pages up to and including the

414

* last bss page.

414

* last bss page.

415

*/

415

*/

416

if (padzero(elf_bss)) {

416

if (padzero(elf_bss)) {

417

error = -EFAULT;

417

error = -EFAULT;

418

goto out_close;

418

goto out_close;

419

}

419

}

420

421

elf_bss = ELF_PAGESTART(elf_bss + ELF_MIN_ALIGN - 1); /* What we have mapped so far */

421

elf_bss = ELF_PAGESTART(elf_bss + ELF_MIN_ALIGN - 1); /* What we have mapped so far */

422

423

/* Map the last of the bss segment */

423

/* Map the last of the bss segment */

424

if (last_bss > elf_bss) {

424

if (last_bss > elf_bss) {

425

down_write(&current->mm->mmap_sem);

425

down_write(&current->mm->mmap_sem);

426

error = do_brk(elf_bss, last_bss - elf_bss);

426

error = do_brk(elf_bss, last_bss - elf_bss);

427

up_write(&current->mm->mmap_sem);

427

up_write(&current->mm->mmap_sem);

428

if (BAD_ADDR(error))

428

if (BAD_ADDR(error))

429

goto out_close;

429

goto out_close;

430

}

430

}

431

432

*interp_load_addr = load_addr;

432

*interp_load_addr = load_addr;

433

error = ((unsigned long) interp_elf_ex->e_entry) + load_addr;

433

error = ((unsigned long) interp_elf_ex->e_entry) + load_addr;

434

435

out_close:

435

out_close:

436

kfree(elf_phdata);

436

kfree(elf_phdata);

437

out:

437

out:

438

return error;

438

return error;

439

}

439

}

440

441

static unsigned long load_aout_interp(struct exec * interp_ex,

441

static unsigned long load_aout_interp(struct exec * interp_ex,

442

struct file * interpreter)

442

struct file * interpreter)

443

{

443

{

444

unsigned long text_data, elf_entry = ~0UL;

444

unsigned long text_data, elf_entry = ~0UL;

445

char __user * addr;

445

char __user * addr;

446

loff_t offset;

446

loff_t offset;

447

448

current->mm->end_code = interp_ex->a_text;

448

current->mm->end_code = interp_ex->a_text;

449

text_data = interp_ex->a_text + interp_ex->a_data;

449

text_data = interp_ex->a_text + interp_ex->a_data;

450

current->mm->end_data = text_data;

450

current->mm->end_data = text_data;

451

current->mm->brk = interp_ex->a_bss + text_data;

451

current->mm->brk = interp_ex->a_bss + text_data;

452

453

switch (N_MAGIC(*interp_ex)) {

453

switch (N_MAGIC(*interp_ex)) {

454

case OMAGIC:

454

case OMAGIC:

455

offset = 32;

455

offset = 32;

456

addr = (char __user *)0;

456

addr = (char __user *)0;

457

break;

457

break;

458

case ZMAGIC:

458

case ZMAGIC:

459

case QMAGIC:

459

case QMAGIC:

460

offset = N_TXTOFF(*interp_ex);

460

offset = N_TXTOFF(*interp_ex);

461

addr = (char __user *) N_TXTADDR(*interp_ex);

461

addr = (char __user *) N_TXTADDR(*interp_ex);

462

break;

462

break;

463

default:

463

default:

464

goto out;

464

goto out;

465

}

465

}

466

467

down_write(&current->mm->mmap_sem);

467

down_write(&current->mm->mmap_sem);

468

do_brk(0, text_data);

468

do_brk(0, text_data);

469

up_write(&current->mm->mmap_sem);

469

up_write(&current->mm->mmap_sem);

470

if (!interpreter->f_op || !interpreter->f_op->read)

470

if (!interpreter->f_op || !interpreter->f_op->read)

471

goto out;

471

goto out;

472

if (interpreter->f_op->read(interpreter, addr, text_data, &offset) < 0)

472

if (interpreter->f_op->read(interpreter, addr, text_data, &offset) < 0)

473

goto out;

473

goto out;

474

flush_icache_range((unsigned long)addr,

474

flush_icache_range((unsigned long)addr,

475

(unsigned long)addr + text_data);

475

(unsigned long)addr + text_data);

476

477

478

down_write(&current->mm->mmap_sem);

478

down_write(&current->mm->mmap_sem);

479

do_brk(ELF_PAGESTART(text_data + ELF_MIN_ALIGN - 1),

479

do_brk(ELF_PAGESTART(text_data + ELF_MIN_ALIGN - 1),

480

interp_ex->a_bss);

480

interp_ex->a_bss);

481

up_write(&current->mm->mmap_sem);

481

up_write(&current->mm->mmap_sem);

482

elf_entry = interp_ex->a_entry;

482

elf_entry = interp_ex->a_entry;

483

484

out:

484

out:

485

return elf_entry;

485

return elf_entry;

486

}

486

}

487

488

/*

488

/*

489

* These are the functions used to load ELF style executables and shared

489

* These are the functions used to load ELF style executables and shared

490

* libraries. There is no binary dependent code anywhere else.

490

* libraries. There is no binary dependent code anywhere else.

491

*/

491

*/

492

493

#define INTERPRETER_NONE 0

493

#define INTERPRETER_NONE 0

494

#define INTERPRETER_AOUT 1

494

#define INTERPRETER_AOUT 1

495

#define INTERPRETER_ELF 2

495

#define INTERPRETER_ELF 2

496

497

498

static unsigned long randomize_stack_top(unsigned long stack_top)

498

static unsigned long randomize_stack_top(unsigned long stack_top)

499

{

499

{

500

unsigned int random_variable = 0;

500

unsigned int random_variable = 0;

501

502

if (current->flags & PF_RANDOMIZE)

502

if (current->flags & PF_RANDOMIZE)

503

random_variable = get_random_int() % (8*1024*1024);

503

random_variable = get_random_int() % (8*1024*1024);

504

#ifdef CONFIG_STACK_GROWSUP

504

#ifdef CONFIG_STACK_GROWSUP

505

return PAGE_ALIGN(stack_top + random_variable);

505

return PAGE_ALIGN(stack_top + random_variable);

506

#else

506

#else

507

return PAGE_ALIGN(stack_top - random_variable);

507

return PAGE_ALIGN(stack_top - random_variable);

508

#endif

508

#endif

509

}

509

}

510

511

static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)

511

static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)

512

{

512

{

513

struct file *interpreter = NULL; /* to shut gcc up */

513

struct file *interpreter = NULL; /* to shut gcc up */

514

unsigned long load_addr = 0, load_bias = 0;

514

unsigned long load_addr = 0, load_bias = 0;

515

int load_addr_set = 0;

515

int load_addr_set = 0;

516

char * elf_interpreter = NULL;

516

char * elf_interpreter = NULL;

517

unsigned int interpreter_type = INTERPRETER_NONE;

517

unsigned int interpreter_type = INTERPRETER_NONE;

518

unsigned char ibcs2_interpreter = 0;

518

unsigned char ibcs2_interpreter = 0;

519

unsigned long error;

519

unsigned long error;

520

struct elf_phdr * elf_ppnt, *elf_phdata;

520

struct elf_phdr * elf_ppnt, *elf_phdata;

521

unsigned long elf_bss, elf_brk;

521

unsigned long elf_bss, elf_brk;

522

int elf_exec_fileno;

522

int elf_exec_fileno;

523

int retval, i;

523

int retval, i;

524

unsigned int size;

524

unsigned int size;

525

unsigned long elf_entry, interp_load_addr = 0;

525

unsigned long elf_entry, interp_load_addr = 0;

526

unsigned long start_code, end_code, start_data, end_data;

526

unsigned long start_code, end_code, start_data, end_data;

527

unsigned long reloc_func_desc = 0;

527

unsigned long reloc_func_desc = 0;

528

char passed_fileno[6];

528

char passed_fileno[6];

529

struct files_struct *files;

529

struct files_struct *files;

530

int have_pt_gnu_stack, executable_stack = EXSTACK_DEFAULT;

530

int have_pt_gnu_stack, executable_stack = EXSTACK_DEFAULT;

531

unsigned long def_flags = 0;

531

unsigned long def_flags = 0;

532

struct {

532

struct {

533

struct elfhdr elf_ex;

533

struct elfhdr elf_ex;

534

struct elfhdr interp_elf_ex;

534

struct elfhdr interp_elf_ex;

535

struct exec interp_ex;

535

struct exec interp_ex;

536

} *loc;

536

} *loc;

537

538

loc = kmalloc(sizeof(*loc), GFP_KERNEL);

538

loc = kmalloc(sizeof(*loc), GFP_KERNEL);

539

if (!loc) {

539

if (!loc) {

540

retval = -ENOMEM;

540

retval = -ENOMEM;

541

goto out_ret;

541

goto out_ret;

542

}

542

}

543

544

/* Get the exec-header */

544

/* Get the exec-header */

545

loc->elf_ex = *((struct elfhdr *) bprm->buf);

545

loc->elf_ex = *((struct elfhdr *) bprm->buf);

546

547

retval = -ENOEXEC;

547

retval = -ENOEXEC;

548

/* First of all, some simple consistency checks */

548

/* First of all, some simple consistency checks */

549

if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)

549

if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)

550

goto out;

550

goto out;

551

552

if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)

552

if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)

553

goto out;

553

goto out;

554

if (!elf_check_arch(&loc->elf_ex))

554

if (!elf_check_arch(&loc->elf_ex))

555

goto out;

555

goto out;

556

if (!bprm->file->f_op||!bprm->file->f_op->mmap)

556

if (!bprm->file->f_op||!bprm->file->f_op->mmap)

557

goto out;

557

goto out;

558

559

/* Now read in all of the header information */

559

/* Now read in all of the header information */

560

561

if (loc->elf_ex.e_phentsize != sizeof(struct elf_phdr))

561

if (loc->elf_ex.e_phentsize != sizeof(struct elf_phdr))

562

goto out;

562

goto out;

563

if (loc->elf_ex.e_phnum < 1 ||

563

if (loc->elf_ex.e_phnum < 1 ||

564

loc->elf_ex.e_phnum > 65536U / sizeof(struct elf_phdr))

564

loc->elf_ex.e_phnum > 65536U / sizeof(struct elf_phdr))

565

goto out;

565

goto out;

566

size = loc->elf_ex.e_phnum * sizeof(struct elf_phdr);

566

size = loc->elf_ex.e_phnum * sizeof(struct elf_phdr);

567

retval = -ENOMEM;

567

retval = -ENOMEM;

568

elf_phdata = (struct elf_phdr *) kmalloc(size, GFP_KERNEL);

568

elf_phdata = (struct elf_phdr *) kmalloc(size, GFP_KERNEL);

569

if (!elf_phdata)

569

if (!elf_phdata)

570

goto out;

570

goto out;

571

572

retval = kernel_read(bprm->file, loc->elf_ex.e_phoff, (char *) elf_phdata, size);

572

retval = kernel_read(bprm->file, loc->elf_ex.e_phoff, (char *) elf_phdata, size);

573

if (retval != size) {

573

if (retval != size) {

574

if (retval >= 0)

574

if (retval >= 0)

575

retval = -EIO;

575

retval = -EIO;

576

goto out_free_ph;

576

goto out_free_ph;

577

}

577

}

578

579

files = current->files; /* Refcounted so ok */

579

files = current->files; /* Refcounted so ok */

580

retval = unshare_files();

580

retval = unshare_files();

581

if (retval < 0)

581

if (retval < 0)

582

goto out_free_ph;

582

goto out_free_ph;

583

if (files == current->files) {

583

if (files == current->files) {

584

put_files_struct(files);

584

put_files_struct(files);

585

files = NULL;

585

files = NULL;

586

}

586

}

587

588

/* exec will make our files private anyway, but for the a.out

588

/* exec will make our files private anyway, but for the a.out

589

loader stuff we need to do it earlier */

589

loader stuff we need to do it earlier */

590

591

retval = get_unused_fd();

591

retval = get_unused_fd();

592

if (retval < 0)

592

if (retval < 0)

593

goto out_free_fh;

593

goto out_free_fh;

594

get_file(bprm->file);

594

get_file(bprm->file);

595

fd_install(elf_exec_fileno = retval, bprm->file);

595

fd_install(elf_exec_fileno = retval, bprm->file);

596

597

elf_ppnt = elf_phdata;

597

elf_ppnt = elf_phdata;

598

elf_bss = 0;

598

elf_bss = 0;

599

elf_brk = 0;

599

elf_brk = 0;

600

601

start_code = ~0UL;

601

start_code = ~0UL;

602

end_code = 0;

602

end_code = 0;

603

start_data = 0;

603

start_data = 0;

604

end_data = 0;

604

end_data = 0;

605

606

for (i = 0; i < loc->elf_ex.e_phnum; i++) {

606

for (i = 0; i < loc->elf_ex.e_phnum; i++) {

607

if (elf_ppnt->p_type == PT_INTERP) {

607

if (elf_ppnt->p_type == PT_INTERP) {

608

/* This is the program interpreter used for

608

/* This is the program interpreter used for

609

* shared libraries - for now assume that this

609

* shared libraries - for now assume that this

610

* is an a.out format binary

610

* is an a.out format binary

611

*/

611

*/

612

613

retval = -ENOEXEC;

613

retval = -ENOEXEC;

614

if (elf_ppnt->p_filesz > PATH_MAX ||

614

if (elf_ppnt->p_filesz > PATH_MAX ||

615

elf_ppnt->p_filesz < 2)

615

elf_ppnt->p_filesz < 2)

616

goto out_free_file;

616

goto out_free_file;

617

618

retval = -ENOMEM;

618

retval = -ENOMEM;

619

elf_interpreter = (char *) kmalloc(elf_ppnt->p_filesz,

619

elf_interpreter = (char *) kmalloc(elf_ppnt->p_filesz,

620

GFP_KERNEL);

620

GFP_KERNEL);

621

if (!elf_interpreter)

621

if (!elf_interpreter)

622

goto out_free_file;

622

goto out_free_file;

623

624

retval = kernel_read(bprm->file, elf_ppnt->p_offset,

624

retval = kernel_read(bprm->file, elf_ppnt->p_offset,

625

elf_interpreter,

625

elf_interpreter,

626

elf_ppnt->p_filesz);

626

elf_ppnt->p_filesz);

627

if (retval != elf_ppnt->p_filesz) {

627

if (retval != elf_ppnt->p_filesz) {

628

if (retval >= 0)

628

if (retval >= 0)

629

retval = -EIO;

629

retval = -EIO;

630

goto out_free_interp;

630

goto out_free_interp;

631

}

631

}

632

/* make sure path is NULL terminated */

632

/* make sure path is NULL terminated */

633

retval = -ENOEXEC;

633

retval = -ENOEXEC;

634

if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')

634

if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')

635

goto out_free_interp;

635

goto out_free_interp;

636

637

/* If the program interpreter is one of these two,

637

/* If the program interpreter is one of these two,

638

* then assume an iBCS2 image. Otherwise assume

638

* then assume an iBCS2 image. Otherwise assume

639

* a native linux image.

639

* a native linux image.

640

*/

640

*/

641

if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||

641

if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||

642

strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0)

642

strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0)

643

ibcs2_interpreter = 1;

643

ibcs2_interpreter = 1;

644

645

/*

645

/*

646

* The early SET_PERSONALITY here is so that the lookup

646

* The early SET_PERSONALITY here is so that the lookup

647

* for the interpreter happens in the namespace of the

647

* for the interpreter happens in the namespace of the

648

* to-be-execed image. SET_PERSONALITY can select an

648

* to-be-execed image. SET_PERSONALITY can select an

649

* alternate root.

649

* alternate root.

650

*

650

*

651

* However, SET_PERSONALITY is NOT allowed to switch

651

* However, SET_PERSONALITY is NOT allowed to switch

652

* this task into the new images's memory mapping

652

* this task into the new images's memory mapping

653

* policy - that is, TASK_SIZE must still evaluate to

653

* policy - that is, TASK_SIZE must still evaluate to

654

* that which is appropriate to the execing application.

654

* that which is appropriate to the execing application.

655

* This is because exit_mmap() needs to have TASK_SIZE

655

* This is because exit_mmap() needs to have TASK_SIZE

656

* evaluate to the size of the old image.

656

* evaluate to the size of the old image.

657

*

657

*

658

* So if (say) a 64-bit application is execing a 32-bit

658

* So if (say) a 64-bit application is execing a 32-bit

659

* application it is the architecture's responsibility

659

* application it is the architecture's responsibility

660

* to defer changing the value of TASK_SIZE until the

660

* to defer changing the value of TASK_SIZE until the

661

* switch really is going to happen - do this in

661

* switch really is going to happen - do this in

662

* flush_thread(). - akpm

662

* flush_thread(). - akpm

663

*/

663

*/

664

SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);

664

SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);

665

666

interpreter = open_exec(elf_interpreter);

666

interpreter = open_exec(elf_interpreter);

667

retval = PTR_ERR(interpreter);

667

retval = PTR_ERR(interpreter);

668

if (IS_ERR(interpreter))

668

if (IS_ERR(interpreter))

669

goto out_free_interp;

669

goto out_free_interp;

670

retval = kernel_read(interpreter, 0, bprm->buf, BINPRM_BUF_SIZE);

670

retval = kernel_read(interpreter, 0, bprm->buf, BINPRM_BUF_SIZE);

671

if (retval != BINPRM_BUF_SIZE) {

671

if (retval != BINPRM_BUF_SIZE) {

672

if (retval >= 0)

672

if (retval >= 0)

673

retval = -EIO;

673

retval = -EIO;

674

goto out_free_dentry;

674

goto out_free_dentry;

675

}

675

}

676

677

/* Get the exec headers */

677

/* Get the exec headers */

678

loc->interp_ex = *((struct exec *) bprm->buf);

678

loc->interp_ex = *((struct exec *) bprm->buf);

679

loc->interp_elf_ex = *((struct elfhdr *) bprm->buf);

679

loc->interp_elf_ex = *((struct elfhdr *) bprm->buf);

680

break;

680

break;

681

}

681

}

682

elf_ppnt++;

682

elf_ppnt++;

683

}

683

}

684

685

elf_ppnt = elf_phdata;

685

elf_ppnt = elf_phdata;

686

for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)

686

for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)

687

if (elf_ppnt->p_type == PT_GNU_STACK) {

687

if (elf_ppnt->p_type == PT_GNU_STACK) {

688

if (elf_ppnt->p_flags & PF_X)

688

if (elf_ppnt->p_flags & PF_X)

689

executable_stack = EXSTACK_ENABLE_X;

689

executable_stack = EXSTACK_ENABLE_X;

690

else

690

else

691

executable_stack = EXSTACK_DISABLE_X;

691

executable_stack = EXSTACK_DISABLE_X;

692

break;

692

break;

693

}

693

}

694

have_pt_gnu_stack = (i < loc->elf_ex.e_phnum);

694

have_pt_gnu_stack = (i < loc->elf_ex.e_phnum);

695

696

/* Some simple consistency checks for the interpreter */

696

/* Some simple consistency checks for the interpreter */

697

if (elf_interpreter) {

697

if (elf_interpreter) {

698

interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;

698

interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;

699

700

/* Now figure out which format our binary is */

700

/* Now figure out which format our binary is */

701

if ((N_MAGIC(loc->interp_ex) != OMAGIC) &&

701

if ((N_MAGIC(loc->interp_ex) != OMAGIC) &&

702

(N_MAGIC(loc->interp_ex) != ZMAGIC) &&

702

(N_MAGIC(loc->interp_ex) != ZMAGIC) &&

703

(N_MAGIC(loc->interp_ex) != QMAGIC))

703

(N_MAGIC(loc->interp_ex) != QMAGIC))

704

interpreter_type = INTERPRETER_ELF;

704

interpreter_type = INTERPRETER_ELF;

705

706

if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)

706

if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)

707

interpreter_type &= ~INTERPRETER_ELF;

707

interpreter_type &= ~INTERPRETER_ELF;

708

709

retval = -ELIBBAD;

709

retval = -ELIBBAD;

710

if (!interpreter_type)

710

if (!interpreter_type)

711

goto out_free_dentry;

711

goto out_free_dentry;

712

713

/* Make sure only one type was selected */

713

/* Make sure only one type was selected */

714

if ((interpreter_type & INTERPRETER_ELF) &&

714

if ((interpreter_type & INTERPRETER_ELF) &&

715

interpreter_type != INTERPRETER_ELF) {

715

interpreter_type != INTERPRETER_ELF) {

716

// FIXME - ratelimit this before re-enabling

716

// FIXME - ratelimit this before re-enabling

717

// printk(KERN_WARNING "ELF: Ambiguous type, using ELF\n");

717

// printk(KERN_WARNING "ELF: Ambiguous type, using ELF\n");

718

interpreter_type = INTERPRETER_ELF;

718

interpreter_type = INTERPRETER_ELF;

719

}

719

}

720

/* Verify the interpreter has a valid arch */

720

/* Verify the interpreter has a valid arch */

721

if ((interpreter_type == INTERPRETER_ELF) &&

721

if ((interpreter_type == INTERPRETER_ELF) &&

722

!elf_check_arch(&loc->interp_elf_ex))

722

!elf_check_arch(&loc->interp_elf_ex))

723

goto out_free_dentry;

723

goto out_free_dentry;

724

} else {

724

} else {

725

/* Executables without an interpreter also need a personality */

725

/* Executables without an interpreter also need a personality */

726

SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);

726

SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);

727

}

727

}

728

729

/* OK, we are done with that, now set up the arg stuff,

729

/* OK, we are done with that, now set up the arg stuff,

730

and then start this sucker up */

730

and then start this sucker up */

731

732

if ((!bprm->sh_bang) && (interpreter_type == INTERPRETER_AOUT)) {

732

if ((!bprm->sh_bang) && (interpreter_type == INTERPRETER_AOUT)) {

733

char *passed_p = passed_fileno;

733

char *passed_p = passed_fileno;

734

sprintf(passed_fileno, "%d", elf_exec_fileno);

734

sprintf(passed_fileno, "%d", elf_exec_fileno);

735

736

if (elf_interpreter) {

736

if (elf_interpreter) {

737

retval = copy_strings_kernel(1, &passed_p, bprm);

737

retval = copy_strings_kernel(1, &passed_p, bprm);

738

if (retval)

738

if (retval)

739

goto out_free_dentry;

739

goto out_free_dentry;

740

bprm->argc++;

740

bprm->argc++;

741

}

741

}

742

}

742

}

743

744

/* Flush all traces of the currently running executable */

744

/* Flush all traces of the currently running executable */

745

retval = flush_old_exec(bprm);

745

retval = flush_old_exec(bprm);

746

if (retval)

746

if (retval)

747

goto out_free_dentry;

747

goto out_free_dentry;

748

749

/* Discard our unneeded old files struct */

749

/* Discard our unneeded old files struct */

750

if (files) {

750

if (files) {

751

steal_locks(files);

751

steal_locks(files);

752

put_files_struct(files);

752

put_files_struct(files);

753

files = NULL;

753

files = NULL;

754

}

754

}

755

756

/* OK, This is the point of no return */

756

/* OK, This is the point of no return */

757

current->mm->start_data = 0;

757

current->mm->start_data = 0;

758

current->mm->end_data = 0;

758

current->mm->end_data = 0;

759

current->mm->end_code = 0;

759

current->mm->end_code = 0;

760

current->mm->mmap = NULL;

760

current->mm->mmap = NULL;

761

current->flags &= ~PF_FORKNOEXEC;

761

current->flags &= ~PF_FORKNOEXEC;

762

current->mm->def_flags = def_flags;

762

current->mm->def_flags = def_flags;

763

764

/* Do this immediately, since STACK_TOP as used in setup_arg_pages

764

/* Do this immediately, since STACK_TOP as used in setup_arg_pages

765

may depend on the personality. */

765

may depend on the personality. */

766

SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);

766

SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);

767

if (elf_read_implies_exec(loc->elf_ex, executable_stack))

767

if (elf_read_implies_exec(loc->elf_ex, executable_stack))

768

current->personality |= READ_IMPLIES_EXEC;

768

current->personality |= READ_IMPLIES_EXEC;

769

770

if ( !(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)

770

if ( !(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)

771

current->flags |= PF_RANDOMIZE;

771

current->flags |= PF_RANDOMIZE;

772

arch_pick_mmap_layout(current->mm);

772

arch_pick_mmap_layout(current->mm);

773

774

/* Do this so that we can load the interpreter, if need be. We will

774

/* Do this so that we can load the interpreter, if need be. We will

775

change some of these later */

775

change some of these later */

776

set_mm_counter(current->mm, rss, 0);

776

set_mm_counter(current->mm, rss, 0);

777

current->mm->free_area_cache = current->mm->mmap_base;

777

current->mm->free_area_cache = current->mm->mmap_base;

778

retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),

778

retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),

779

executable_stack);

779

executable_stack);

780

if (retval < 0) {

780

if (retval < 0) {

781

send_sig(SIGKILL, current, 0);

781

send_sig(SIGKILL, current, 0);

782

goto out_free_dentry;

782

goto out_free_dentry;

783

}

783

}

784

785

current->mm->start_stack = bprm->p;

785

current->mm->start_stack = bprm->p;

786

787

/* Now we do a little grungy work by mmaping the ELF image into

787

/* Now we do a little grungy work by mmaping the ELF image into

788

the correct location in memory. At this point, we assume that

788

the correct location in memory. At this point, we assume that

789

the image should be loaded at fixed address, not at a variable

789

the image should be loaded at fixed address, not at a variable

790

address. */

790

address. */

791

792

for(i = 0, elf_ppnt = elf_phdata; i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {

792

for(i = 0, elf_ppnt = elf_phdata; i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {

793

int elf_prot = 0, elf_flags;

793

int elf_prot = 0, elf_flags;

794

unsigned long k, vaddr;

794

unsigned long k, vaddr;

795

796

if (elf_ppnt->p_type != PT_LOAD)

796

if (elf_ppnt->p_type != PT_LOAD)

797

continue;

797

continue;

798

799

if (unlikely (elf_brk > elf_bss)) {

799

if (unlikely (elf_brk > elf_bss)) {

800

unsigned long nbyte;

800

unsigned long nbyte;

801

802

/* There was a PT_LOAD segment with p_memsz > p_filesz

802

/* There was a PT_LOAD segment with p_memsz > p_filesz

803

before this one. Map anonymous pages, if needed,

803

before this one. Map anonymous pages, if needed,

804

and clear the area. */

804

and clear the area. */

805

retval = set_brk (elf_bss + load_bias,

805

retval = set_brk (elf_bss + load_bias,

806

elf_brk + load_bias);

806

elf_brk + load_bias);

807

if (retval) {

807

if (retval) {

808

send_sig(SIGKILL, current, 0);

808

send_sig(SIGKILL, current, 0);

809

goto out_free_dentry;

809

goto out_free_dentry;

810

}

810

}

811

nbyte = ELF_PAGEOFFSET(elf_bss);

811

nbyte = ELF_PAGEOFFSET(elf_bss);

812

if (nbyte) {

812

if (nbyte) {

813

nbyte = ELF_MIN_ALIGN - nbyte;

813

nbyte = ELF_MIN_ALIGN - nbyte;

814

if (nbyte > elf_brk - elf_bss)

814

if (nbyte > elf_brk - elf_bss)

815

nbyte = elf_brk - elf_bss;

815

nbyte = elf_brk - elf_bss;

816

if (clear_user((void __user *)elf_bss +

816

if (clear_user((void __user *)elf_bss +

817

load_bias, nbyte)) {

817

load_bias, nbyte)) {

818

/*

818

/*

819

* This bss-zeroing can fail if the ELF

819

* This bss-zeroing can fail if the ELF

820

* file specifies odd protections. So

820

* file specifies odd protections. So

821

* we don't check the return value

821

* we don't check the return value

822

*/

822

*/

823

}

823

}

824

}

824

}

825

}

825

}

826

827

if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;

827

if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;

828

if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;

828

if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;

829

if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;

829

if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;

830

831

elf_flags = MAP_PRIVATE|MAP_DENYWRITE|MAP_EXECUTABLE;

831

elf_flags = MAP_PRIVATE|MAP_DENYWRITE|MAP_EXECUTABLE;

832

833

vaddr = elf_ppnt->p_vaddr;

833

vaddr = elf_ppnt->p_vaddr;

834

if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {

834

if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {

835

elf_flags |= MAP_FIXED;

835

elf_flags |= MAP_FIXED;

836

} else if (loc->elf_ex.e_type == ET_DYN) {

836

} else if (loc->elf_ex.e_type == ET_DYN) {

837

/* Try and get dynamic programs out of the way of the default mmap

837

/* Try and get dynamic programs out of the way of the default mmap

838

base, as well as whatever program they might try to exec. This

838

base, as well as whatever program they might try to exec. This

839

is because the brk will follow the loader, and is not movable. */

839

is because the brk will follow the loader, and is not movable. */

840

load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);

840

load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);

841

}

841

}

842

843

error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt, elf_prot, elf_flags);

843

error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt, elf_prot, elf_flags);

844

if (BAD_ADDR(error)) {

844

if (BAD_ADDR(error)) {

845

send_sig(SIGKILL, current, 0);

845

send_sig(SIGKILL, current, 0);

846

goto out_free_dentry;

846

goto out_free_dentry;

847

}

847

}

848

849

if (!load_addr_set) {

849

if (!load_addr_set) {

850

load_addr_set = 1;

850

load_addr_set = 1;

851

load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);

851

load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);

852

if (loc->elf_ex.e_type == ET_DYN) {

852

if (loc->elf_ex.e_type == ET_DYN) {

853

load_bias += error -

853

load_bias += error -

854

ELF_PAGESTART(load_bias + vaddr);

854

ELF_PAGESTART(load_bias + vaddr);

855

load_addr += load_bias;

855

load_addr += load_bias;

856

reloc_func_desc = load_bias;

856

reloc_func_desc = load_bias;

857

}

857

}

858

}

858

}

859

k = elf_ppnt->p_vaddr;

859

k = elf_ppnt->p_vaddr;

860

if (k < start_code) start_code = k;

860

if (k < start_code) start_code = k;

861

if (start_data < k) start_data = k;

861

if (start_data < k) start_data = k;

862

863

/*

863

/*

864

* Check to see if the section's size will overflow the

864

* Check to see if the section's size will overflow the

865

* allowed task size. Note that p_filesz must always be

865

* allowed task size. Note that p_filesz must always be

866

* <= p_memsz so it is only necessary to check p_memsz.

866

* <= p_memsz so it is only necessary to check p_memsz.

867

*/

867

*/

868

if (k > TASK_SIZE || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||

868

if (k > TASK_SIZE || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||

869

elf_ppnt->p_memsz > TASK_SIZE ||

869

elf_ppnt->p_memsz > TASK_SIZE ||

870

TASK_SIZE - elf_ppnt->p_memsz < k) {

870

TASK_SIZE - elf_ppnt->p_memsz < k) {

871

/* set_brk can never work. Avoid overflows. */

871

/* set_brk can never work. Avoid overflows. */

872

send_sig(SIGKILL, current, 0);

872

send_sig(SIGKILL, current, 0);

873

goto out_free_dentry;

873

goto out_free_dentry;

874

}

874

}

875

876

k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;

876

k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;

877

878

if (k > elf_bss)

878

if (k > elf_bss)

879

elf_bss = k;

879

elf_bss = k;

880

if ((elf_ppnt->p_flags & PF_X) && end_code < k)

880

if ((elf_ppnt->p_flags & PF_X) && end_code < k)

881

end_code = k;

881

end_code = k;

882

if (end_data < k)

882

if (end_data < k)

883

end_data = k;

883

end_data = k;

884

k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;

884

k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;

885

if (k > elf_brk)

885

if (k > elf_brk)

886

elf_brk = k;

886

elf_brk = k;

887

}

887

}

888

889

loc->elf_ex.e_entry += load_bias;

889

loc->elf_ex.e_entry += load_bias;

890

elf_bss += load_bias;

890

elf_bss += load_bias;

891

elf_brk += load_bias;

891

elf_brk += load_bias;

892

start_code += load_bias;

892

start_code += load_bias;

893

end_code += load_bias;

893

end_code += load_bias;

894

start_data += load_bias;

894

start_data += load_bias;

895

end_data += load_bias;

895

end_data += load_bias;

896

897

/* Calling set_brk effectively mmaps the pages that we need

897

/* Calling set_brk effectively mmaps the pages that we need

898

* for the bss and break sections. We must do this before

898

* for the bss and break sections. We must do this before

899

* mapping in the interpreter, to make sure it doesn't wind

899

* mapping in the interpreter, to make sure it doesn't wind

900

* up getting placed where the bss needs to go.

900

* up getting placed where the bss needs to go.

901

*/

901

*/

902

retval = set_brk(elf_bss, elf_brk);

902

retval = set_brk(elf_bss, elf_brk);

903

if (retval) {

903

if (retval) {

904

send_sig(SIGKILL, current, 0);

904

send_sig(SIGKILL, current, 0);

905

goto out_free_dentry;

905

goto out_free_dentry;

906

}

906

}

907

if (padzero(elf_bss)) {

907

if (padzero(elf_bss)) {

908

send_sig(SIGSEGV, current, 0);

908

send_sig(SIGSEGV, current, 0);

909

retval = -EFAULT; /* Nobody gets to see this, but.. */

909

retval = -EFAULT; /* Nobody gets to see this, but.. */

910

goto out_free_dentry;

910

goto out_free_dentry;

911

}

911

}

912

913

if (elf_interpreter) {

913

if (elf_interpreter) {

914

if (interpreter_type == INTERPRETER_AOUT)

914

if (interpreter_type == INTERPRETER_AOUT)

915

elf_entry = load_aout_interp(&loc->interp_ex,

915

elf_entry = load_aout_interp(&loc->interp_ex,

916

interpreter);

916

interpreter);

917

else

917

else

918

elf_entry = load_elf_interp(&loc->interp_elf_ex,

918

elf_entry = load_elf_interp(&loc->interp_elf_ex,

919

interpreter,

919

interpreter,

920

&interp_load_addr);

920

&interp_load_addr);

921

if (BAD_ADDR(elf_entry)) {

921

if (BAD_ADDR(elf_entry)) {

922

printk(KERN_ERR "Unable to load interpreter %.128s\n",

922

printk(KERN_ERR "Unable to load interpreter %.128s\n",

923

elf_interpreter);

923

elf_interpreter);

924

force_sig(SIGSEGV, current);

924

force_sig(SIGSEGV, current);

925

retval = -ENOEXEC; /* Nobody gets to see this, but.. */

925

retval = -ENOEXEC; /* Nobody gets to see this, but.. */

926

goto out_free_dentry;

926

goto out_free_dentry;

927

}

927

}

928

reloc_func_desc = interp_load_addr;

928

reloc_func_desc = interp_load_addr;

929

930

allow_write_access(interpreter);

930

allow_write_access(interpreter);

931

fput(interpreter);

931

fput(interpreter);

932

kfree(elf_interpreter);

932

kfree(elf_interpreter);

933

} else {

933

} else {

934

elf_entry = loc->elf_ex.e_entry;

934

elf_entry = loc->elf_ex.e_entry;

935

}

935

}

936

937

kfree(elf_phdata);

937

kfree(elf_phdata);

938

939

if (interpreter_type != INTERPRETER_AOUT)

939

if (interpreter_type != INTERPRETER_AOUT)

940

sys_close(elf_exec_fileno);

940

sys_close(elf_exec_fileno);

941

942

set_binfmt(&elf_format);

942

set_binfmt(&elf_format);

943

944

#ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES

944

#ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES

945

retval = arch_setup_additional_pages(bprm, executable_stack);

945

retval = arch_setup_additional_pages(bprm, executable_stack);

946

if (retval < 0) {

946

if (retval < 0) {

947

send_sig(SIGKILL, current, 0);

947

send_sig(SIGKILL, current, 0);

948

goto out;

948

goto out;

949

}

949

}

950

#endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */

950

#endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */

951

952

compute_creds(bprm);

952

compute_creds(bprm);

953

current->flags &= ~PF_FORKNOEXEC;

953

current->flags &= ~PF_FORKNOEXEC;

954

create_elf_tables(bprm, &loc->elf_ex, (interpreter_type == INTERPRETER_AOUT),

954

create_elf_tables(bprm, &loc->elf_ex, (interpreter_type == INTERPRETER_AOUT),

955

load_addr, interp_load_addr);

955

load_addr, interp_load_addr);

956

/* N.B. passed_fileno might not be initialized? */

956

/* N.B. passed_fileno might not be initialized? */

957

if (interpreter_type == INTERPRETER_AOUT)

957

if (interpreter_type == INTERPRETER_AOUT)

958

current->mm->arg_start += strlen(passed_fileno) + 1;

958

current->mm->arg_start += strlen(passed_fileno) + 1;

959

current->mm->end_code = end_code;

959

current->mm->end_code = end_code;

960

current->mm->start_code = start_code;

960

current->mm->start_code = start_code;

961

current->mm->start_data = start_data;

961

current->mm->start_data = start_data;

962

current->mm->end_data = end_data;

962

current->mm->end_data = end_data;

963

current->mm->start_stack = bprm->p;

963

current->mm->start_stack = bprm->p;

964

965

if (current->personality & MMAP_PAGE_ZERO) {

965

if (current->personality & MMAP_PAGE_ZERO) {

966

/* Why this, you ask??? Well SVr4 maps page 0 as read-only,

966

/* Why this, you ask??? Well SVr4 maps page 0 as read-only,

967

and some applications "depend" upon this behavior.

967

and some applications "depend" upon this behavior.

968

Since we do not have the power to recompile these, we

968

Since we do not have the power to recompile these, we

969

emulate the SVr4 behavior. Sigh. */

969

emulate the SVr4 behavior. Sigh. */

970

down_write(&current->mm->mmap_sem);

970

down_write(&current->mm->mmap_sem);

971

error = do_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,

971

error = do_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,

972

MAP_FIXED | MAP_PRIVATE, 0);

972

MAP_FIXED | MAP_PRIVATE, 0);

973

up_write(&current->mm->mmap_sem);

973

up_write(&current->mm->mmap_sem);

974

}

974

}

975

976

#ifdef ELF_PLAT_INIT

976

#ifdef ELF_PLAT_INIT

977

/*

977

/*

978

* The ABI may specify that certain registers be set up in special

978

* The ABI may specify that certain registers be set up in special

979

* ways (on i386 %edx is the address of a DT_FINI function, for

979

* ways (on i386 %edx is the address of a DT_FINI function, for

980

* example. In addition, it may also specify (eg, PowerPC64 ELF)

980

* example. In addition, it may also specify (eg, PowerPC64 ELF)

981

* that the e_entry field is the address of the function descriptor

981

* that the e_entry field is the address of the function descriptor

982

* for the startup routine, rather than the address of the startup

982

* for the startup routine, rather than the address of the startup

983

* routine itself. This macro performs whatever initialization to

983

* routine itself. This macro performs whatever initialization to

984

* the regs structure is required as well as any relocations to the

984

* the regs structure is required as well as any relocations to the

985

* function descriptor entries when executing dynamically links apps.

985

* function descriptor entries when executing dynamically links apps.

986

*/

986

*/

987

ELF_PLAT_INIT(regs, reloc_func_desc);

987

ELF_PLAT_INIT(regs, reloc_func_desc);

988

#endif

988

#endif

989

990

start_thread(regs, elf_entry, bprm->p);

990

start_thread(regs, elf_entry, bprm->p);

991

if (unlikely(current->ptrace & PT_PTRACED)) {

991

if (unlikely(current->ptrace & PT_PTRACED)) {

992

if (current->ptrace & PT_TRACE_EXEC)

992

if (current->ptrace & PT_TRACE_EXEC)

993

ptrace_notify ((PTRACE_EVENT_EXEC << 8) | SIGTRAP);

993

ptrace_notify ((PTRACE_EVENT_EXEC << 8) | SIGTRAP);

994

else

994

else

995

send_sig(SIGTRAP, current, 0);

995

send_sig(SIGTRAP, current, 0);

996

}

996

}

997

retval = 0;

997

retval = 0;

998

out:

998

out:

999

kfree(loc);

999

kfree(loc);

1000

out_ret:

1000

out_ret:

1001

return retval;

1001

return retval;

1002

1003

/* error cleanup */

1003

/* error cleanup */

1004

out_free_dentry:

1004

out_free_dentry:

1005

allow_write_access(interpreter);

1005

allow_write_access(interpreter);

1006

if (interpreter)

1006

if (interpreter)

1007

fput(interpreter);

1007

fput(interpreter);

1008

out_free_interp:

1008

out_free_interp:

1009

if (elf_interpreter)

1009

if (elf_interpreter)

1010

kfree(elf_interpreter);

1010

kfree(elf_interpreter);

1011

out_free_file:

1011

out_free_file:

1012

sys_close(elf_exec_fileno);

1012

sys_close(elf_exec_fileno);

1013

out_free_fh:

1013

out_free_fh:

1014

if (files) {

1014

if (files) {

1015

put_files_struct(current->files);

1015

put_files_struct(current->files);

1016

current->files = files;

1016

current->files = files;

1017

}

1017

}

1018

out_free_ph:

1018

out_free_ph:

1019

kfree(elf_phdata);

1019

kfree(elf_phdata);

1020

goto out;

1020

goto out;

1021

}

1021

}

1022

1023

/* This is really simpleminded and specialized - we are loading an

1023

/* This is really simpleminded and specialized - we are loading an

1024

a.out library that is given an ELF header. */

1024

a.out library that is given an ELF header. */

1025

1026

static int load_elf_library(struct file *file)

1026

static int load_elf_library(struct file *file)

1027

{

1027

{

1028

struct elf_phdr *elf_phdata;

1028

struct elf_phdr *elf_phdata;

1029

struct elf_phdr *eppnt;

1029

struct elf_phdr *eppnt;

1030

unsigned long elf_bss, bss, len;

1030

unsigned long elf_bss, bss, len;

1031

int retval, error, i, j;

1031

int retval, error, i, j;

1032

struct elfhdr elf_ex;

1032

struct elfhdr elf_ex;

1033

1034

error = -ENOEXEC;

1034

error = -ENOEXEC;

1035

retval = kernel_read(file, 0, (char *) &elf_ex, sizeof(elf_ex));

1035

retval = kernel_read(file, 0, (char *) &elf_ex, sizeof(elf_ex));

1036

if (retval != sizeof(elf_ex))

1036

if (retval != sizeof(elf_ex))

1037

goto out;

1037

goto out;

1038

1039

if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)

1039

if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)

1040

goto out;

1040

goto out;

1041

1042

/* First of all, some simple consistency checks */

1042

/* First of all, some simple consistency checks */

1043

if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||

1043

if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||

1044

!elf_check_arch(&elf_ex) || !file->f_op || !file->f_op->mmap)

1044

!elf_check_arch(&elf_ex) || !file->f_op || !file->f_op->mmap)

1045

goto out;

1045

goto out;

1046

1047

/* Now read in all of the header information */

1047

/* Now read in all of the header information */

1048

1049

j = sizeof(struct elf_phdr) * elf_ex.e_phnum;

1049

j = sizeof(struct elf_phdr) * elf_ex.e_phnum;

1050

/* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */

1050

/* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */

1051

1052

error = -ENOMEM;

1052

error = -ENOMEM;

1053

elf_phdata = kmalloc(j, GFP_KERNEL);

1053

elf_phdata = kmalloc(j, GFP_KERNEL);

1054

if (!elf_phdata)

1054

if (!elf_phdata)

1055

goto out;

1055

goto out;

1056

1057

eppnt = elf_phdata;

1057

eppnt = elf_phdata;

1058

error = -ENOEXEC;

1058

error = -ENOEXEC;

1059

retval = kernel_read(file, elf_ex.e_phoff, (char *)eppnt, j);

1059

retval = kernel_read(file, elf_ex.e_phoff, (char *)eppnt, j);

1060

if (retval != j)

1060

if (retval != j)

1061

goto out_free_ph;

1061

goto out_free_ph;

1062

1063

for (j = 0, i = 0; i<elf_ex.e_phnum; i++)

1063

for (j = 0, i = 0; i<elf_ex.e_phnum; i++)

1064

if ((eppnt + i)->p_type == PT_LOAD)

1064

if ((eppnt + i)->p_type == PT_LOAD)

1065

j++;

1065

j++;

1066

if (j != 1)

1066

if (j != 1)

1067

goto out_free_ph;

1067

goto out_free_ph;

1068

1069

while (eppnt->p_type != PT_LOAD)

1069

while (eppnt->p_type != PT_LOAD)

1070

eppnt++;

1070

eppnt++;

1071

1072

/* Now use mmap to map the library into memory. */

1072

/* Now use mmap to map the library into memory. */

1073

down_write(&current->mm->mmap_sem);

1073

down_write(&current->mm->mmap_sem);

1074

error = do_mmap(file,

1074

error = do_mmap(file,

1075

ELF_PAGESTART(eppnt->p_vaddr),

1075

ELF_PAGESTART(eppnt->p_vaddr),

1076

(eppnt->p_filesz +

1076

(eppnt->p_filesz +

1077

ELF_PAGEOFFSET(eppnt->p_vaddr)),

1077

ELF_PAGEOFFSET(eppnt->p_vaddr)),

1078

PROT_READ | PROT_WRITE | PROT_EXEC,

1078

PROT_READ | PROT_WRITE | PROT_EXEC,

1079

MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,

1079

MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,

1080

(eppnt->p_offset -

1080

(eppnt->p_offset -

1081

ELF_PAGEOFFSET(eppnt->p_vaddr)));

1081

ELF_PAGEOFFSET(eppnt->p_vaddr)));

1082

up_write(&current->mm->mmap_sem);

1082

up_write(&current->mm->mmap_sem);

1083

if (error != ELF_PAGESTART(eppnt->p_vaddr))

1083

if (error != ELF_PAGESTART(eppnt->p_vaddr))

1084

goto out_free_ph;

1084

goto out_free_ph;

1085

1086

elf_bss = eppnt->p_vaddr + eppnt->p_filesz;

1086

elf_bss = eppnt->p_vaddr + eppnt->p_filesz;

1087

if (padzero(elf_bss)) {

1087

if (padzero(elf_bss)) {

1088

error = -EFAULT;

1088

error = -EFAULT;

1089

goto out_free_ph;

1089

goto out_free_ph;

1090

}

1090

}

1091

1092

len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr + ELF_MIN_ALIGN - 1);

1092

len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr + ELF_MIN_ALIGN - 1);

1093

bss = eppnt->p_memsz + eppnt->p_vaddr;

1093

bss = eppnt->p_memsz + eppnt->p_vaddr;

1094

if (bss > len) {

1094

if (bss > len) {

1095

down_write(&current->mm->mmap_sem);

1095

down_write(&current->mm->mmap_sem);

1096

do_brk(len, bss - len);

1096

do_brk(len, bss - len);

1097

up_write(&current->mm->mmap_sem);

1097

up_write(&current->mm->mmap_sem);

1098

}

1098

}

1099

error = 0;

1099

error = 0;

1100

1101

out_free_ph:

1101

out_free_ph:

1102

kfree(elf_phdata);

1102

kfree(elf_phdata);

1103

out:

1103

out:

1104

return error;

1104

return error;

1105

}

1105

}

1106

1107

/*

1107

/*

1108

* Note that some platforms still use traditional core dumps and not

1108

* Note that some platforms still use traditional core dumps and not

1109

* the ELF core dump. Each platform can select it as appropriate.

1109

* the ELF core dump. Each platform can select it as appropriate.

1110

*/

1110

*/

1111

#ifdef USE_ELF_CORE_DUMP

1111

#ifdef USE_ELF_CORE_DUMP

1112

1113

/*

1113

/*

1114

* ELF core dumper

1114

* ELF core dumper

1115

*

1115

*

1116

* Modelled on fs/exec.c:aout_core_dump()

1116

* Modelled on fs/exec.c:aout_core_dump()

1117

* Jeremy Fitzhardinge <jeremy@sw.oz.au>

1117

* Jeremy Fitzhardinge <jeremy@sw.oz.au>

1118

*/

1118

*/

1119

/*

1119

/*

1120

* These are the only things you should do on a core-file: use only these

1120

* These are the only things you should do on a core-file: use only these

1121

* functions to write out all the necessary info.

1121

* functions to write out all the necessary info.

1122

*/

1122

*/

1123

static int dump_write(struct file *file, const void *addr, int nr)

1123

static int dump_write(struct file *file, const void *addr, int nr)

1124

{

1124

{

1125

return file->f_op->write(file, addr, nr, &file->f_pos) == nr;

1125

return file->f_op->write(file, addr, nr, &file->f_pos) == nr;

1126

}

1126

}

1127

1128

static int dump_seek(struct file *file, off_t off)

1128

static int dump_seek(struct file *file, loff_t off)

1129

{

1129

{

1130

if (file->f_op->llseek) {

1130

if (file->f_op->llseek) {

1131

if (file->f_op->llseek(file, off, 0) != off)

1131

if (file->f_op->llseek(file, off, 0) != off)

1132

return 0;

1132

return 0;

1133

} else

1133

} else

1134

file->f_pos = off;

1134

file->f_pos = off;

1135

return 1;

1135

return 1;

1136

}

1136

}

1137

1138

/*

1138

/*

1139

* Decide whether a segment is worth dumping; default is yes to be

1139

* Decide whether a segment is worth dumping; default is yes to be

1140

* sure (missing info is worse than too much; etc).

1140

* sure (missing info is worse than too much; etc).

1141

* Personally I'd include everything, and use the coredump limit...

1141

* Personally I'd include everything, and use the coredump limit...

1142

*

1142

*

1143

* I think we should skip something. But I am not sure how. H.J.

1143

* I think we should skip something. But I am not sure how. H.J.

1144

*/

1144

*/

1145

static int maydump(struct vm_area_struct *vma)

1145

static int maydump(struct vm_area_struct *vma)

1146

{

1146

{

1147

/* Do not dump I/O mapped devices or special mappings */

1147

/* Do not dump I/O mapped devices or special mappings */

1148

if (vma->vm_flags & (VM_IO | VM_RESERVED))

1148

if (vma->vm_flags & (VM_IO | VM_RESERVED))

1149

return 0;

1149

return 0;

1150

1151

/* Dump shared memory only if mapped from an anonymous file. */

1151

/* Dump shared memory only if mapped from an anonymous file. */

1152

if (vma->vm_flags & VM_SHARED)

1152

if (vma->vm_flags & VM_SHARED)

1153

return vma->vm_file->f_dentry->d_inode->i_nlink == 0;

1153

return vma->vm_file->f_dentry->d_inode->i_nlink == 0;

1154

1155

/* If it hasn't been written to, don't write it out */

1155

/* If it hasn't been written to, don't write it out */

1156

if (!vma->anon_vma)

1156

if (!vma->anon_vma)

1157

return 0;

1157

return 0;

1158

1159

return 1;

1159

return 1;

1160

}

1160

}

1161

1162

#define roundup(x, y) ((((x)+((y)-1))/(y))*(y))

1162

#define roundup(x, y) ((((x)+((y)-1))/(y))*(y))

1163

1164

/* An ELF note in memory */

1164

/* An ELF note in memory */

1165

struct memelfnote

1165

struct memelfnote

1166

{

1166

{

1167

const char *name;

1167

const char *name;

1168

int type;

1168

int type;

1169

unsigned int datasz;

1169

unsigned int datasz;

1170

void *data;

1170

void *data;

1171

};

1171

};

1172

1173

static int notesize(struct memelfnote *en)

1173

static int notesize(struct memelfnote *en)

1174

{

1174

{

1175

int sz;

1175

int sz;

1176

1177

sz = sizeof(struct elf_note);

1177

sz = sizeof(struct elf_note);

1178

sz += roundup(strlen(en->name) + 1, 4);

1178

sz += roundup(strlen(en->name) + 1, 4);

1179

sz += roundup(en->datasz, 4);

1179

sz += roundup(en->datasz, 4);

1180

1181

return sz;

1181

return sz;

1182

}

1182

}

1183

1184

#define DUMP_WRITE(addr, nr) \

1184

#define DUMP_WRITE(addr, nr) \

1185

do { if (!dump_write(file, (addr), (nr))) return 0; } while(0)

1185

do { if (!dump_write(file, (addr), (nr))) return 0; } while(0)

1186

#define DUMP_SEEK(off) \

1186

#define DUMP_SEEK(off) \

1187

do { if (!dump_seek(file, (off))) return 0; } while(0)

1187

do { if (!dump_seek(file, (off))) return 0; } while(0)

1188

1189

static int writenote(struct memelfnote *men, struct file *file)

1189

static int writenote(struct memelfnote *men, struct file *file)

1190

{

1190

{

1191

struct elf_note en;

1191

struct elf_note en;

1192

1193

en.n_namesz = strlen(men->name) + 1;

1193

en.n_namesz = strlen(men->name) + 1;

1194

en.n_descsz = men->datasz;

1194

en.n_descsz = men->datasz;

1195

en.n_type = men->type;

1195

en.n_type = men->type;

1196

1197

DUMP_WRITE(&en, sizeof(en));

1197

DUMP_WRITE(&en, sizeof(en));

1198

DUMP_WRITE(men->name, en.n_namesz);

1198

DUMP_WRITE(men->name, en.n_namesz);

1199

/* XXX - cast from long long to long to avoid need for libgcc.a */

1199

/* XXX - cast from long long to long to avoid need for libgcc.a */

1200

DUMP_SEEK(roundup((unsigned long)file->f_pos, 4)); /* XXX */

1200

DUMP_SEEK(roundup((unsigned long)file->f_pos, 4)); /* XXX */

1201

DUMP_WRITE(men->data, men->datasz);

1201

DUMP_WRITE(men->data, men->datasz);

1202

DUMP_SEEK(roundup((unsigned long)file->f_pos, 4)); /* XXX */

1202

DUMP_SEEK(roundup((unsigned long)file->f_pos, 4)); /* XXX */

1203

1204

return 1;

1204

return 1;

1205

}

1205

}

1206

#undef DUMP_WRITE

1206

#undef DUMP_WRITE

1207

#undef DUMP_SEEK

1207

#undef DUMP_SEEK

1208

1209

#define DUMP_WRITE(addr, nr) \

1209

#define DUMP_WRITE(addr, nr) \

1210

if ((size += (nr)) > limit || !dump_write(file, (addr), (nr))) \

1210

if ((size += (nr)) > limit || !dump_write(file, (addr), (nr))) \

1211

goto end_coredump;

1211

goto end_coredump;

1212

#define DUMP_SEEK(off) \

1212

#define DUMP_SEEK(off) \

1213

if (!dump_seek(file, (off))) \

1213

if (!dump_seek(file, (off))) \

1214

goto end_coredump;

1214

goto end_coredump;

1215

1216

static inline void fill_elf_header(struct elfhdr *elf, int segs)

1216

static inline void fill_elf_header(struct elfhdr *elf, int segs)

1217

{

1217

{

1218

memcpy(elf->e_ident, ELFMAG, SELFMAG);

1218

memcpy(elf->e_ident, ELFMAG, SELFMAG);

1219

elf->e_ident[EI_CLASS] = ELF_CLASS;

1219

elf->e_ident[EI_CLASS] = ELF_CLASS;

1220

elf->e_ident[EI_DATA] = ELF_DATA;

1220

elf->e_ident[EI_DATA] = ELF_DATA;

1221

elf->e_ident[EI_VERSION] = EV_CURRENT;

1221

elf->e_ident[EI_VERSION] = EV_CURRENT;

1222

elf->e_ident[EI_OSABI] = ELF_OSABI;

1222

elf->e_ident[EI_OSABI] = ELF_OSABI;

1223

memset(elf->e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD);

1223

memset(elf->e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD);

1224

1225

elf->e_type = ET_CORE;

1225

elf->e_type = ET_CORE;

1226

elf->e_machine = ELF_ARCH;

1226

elf->e_machine = ELF_ARCH;

1227

elf->e_version = EV_CURRENT;

1227

elf->e_version = EV_CURRENT;

1228

elf->e_entry = 0;

1228

elf->e_entry = 0;

1229

elf->e_phoff = sizeof(struct elfhdr);

1229

elf->e_phoff = sizeof(struct elfhdr);

1230

elf->e_shoff = 0;

1230

elf->e_shoff = 0;

1231

elf->e_flags = ELF_CORE_EFLAGS;

1231

elf->e_flags = ELF_CORE_EFLAGS;

1232

elf->e_ehsize = sizeof(struct elfhdr);

1232

elf->e_ehsize = sizeof(struct elfhdr);

1233

elf->e_phentsize = sizeof(struct elf_phdr);

1233

elf->e_phentsize = sizeof(struct elf_phdr);

1234

elf->e_phnum = segs;

1234

elf->e_phnum = segs;

1235

elf->e_shentsize = 0;

1235

elf->e_shentsize = 0;

1236

elf->e_shnum = 0;

1236

elf->e_shnum = 0;

1237

elf->e_shstrndx = 0;

1237

elf->e_shstrndx = 0;

1238

return;

1238

return;

1239

}

1239

}

1240

1241

static inline void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, off_t offset)

1241

static inline void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, off_t offset)

1242

{

1242

{

1243

phdr->p_type = PT_NOTE;

1243

phdr->p_type = PT_NOTE;

1244

phdr->p_offset = offset;

1244

phdr->p_offset = offset;

1245

phdr->p_vaddr = 0;

1245

phdr->p_vaddr = 0;

1246

phdr->p_paddr = 0;

1246

phdr->p_paddr = 0;

1247

phdr->p_filesz = sz;

1247

phdr->p_filesz = sz;

1248

phdr->p_memsz = 0;

1248

phdr->p_memsz = 0;

1249

phdr->p_flags = 0;

1249

phdr->p_flags = 0;

1250

phdr->p_align = 0;

1250

phdr->p_align = 0;

1251

return;

1251

return;

1252

}

1252

}

1253

1254

static void fill_note(struct memelfnote *note, const char *name, int type,

1254

static void fill_note(struct memelfnote *note, const char *name, int type,

1255

unsigned int sz, void *data)

1255

unsigned int sz, void *data)

1256

{

1256

{

1257

note->name = name;

1257

note->name = name;

1258

note->type = type;

1258

note->type = type;

1259

note->datasz = sz;

1259

note->datasz = sz;

1260

note->data = data;

1260

note->data = data;

1261

return;

1261

return;

1262

}

1262

}

1263

1264

/*

1264

/*

1265

* fill up all the fields in prstatus from the given task struct, except registers

1265

* fill up all the fields in prstatus from the given task struct, except registers

1266

* which need to be filled up separately.

1266

* which need to be filled up separately.

1267

*/

1267

*/

1268

static void fill_prstatus(struct elf_prstatus *prstatus,

1268

static void fill_prstatus(struct elf_prstatus *prstatus,

1269

struct task_struct *p, long signr)

1269

struct task_struct *p, long signr)

1270

{

1270

{

1271

prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;

1271

prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;

1272

prstatus->pr_sigpend = p->pending.signal.sig[0];

1272

prstatus->pr_sigpend = p->pending.signal.sig[0];

1273

prstatus->pr_sighold = p->blocked.sig[0];

1273

prstatus->pr_sighold = p->blocked.sig[0];

1274

prstatus->pr_pid = p->pid;

1274

prstatus->pr_pid = p->pid;

1275

prstatus->pr_ppid = p->parent->pid;

1275

prstatus->pr_ppid = p->parent->pid;

1276

prstatus->pr_pgrp = process_group(p);

1276

prstatus->pr_pgrp = process_group(p);

1277

prstatus->pr_sid = p->signal->session;

1277

prstatus->pr_sid = p->signal->session;

1278

if (thread_group_leader(p)) {

1278

if (thread_group_leader(p)) {

1279

/*

1279

/*

1280

* This is the record for the group leader. Add in the

1280

* This is the record for the group leader. Add in the

1281

* cumulative times of previous dead threads. This total

1281

* cumulative times of previous dead threads. This total

1282

* won't include the time of each live thread whose state

1282

* won't include the time of each live thread whose state

1283

* is included in the core dump. The final total reported

1283

* is included in the core dump. The final total reported

1284

* to our parent process when it calls wait4 will include

1284

* to our parent process when it calls wait4 will include

1285

* those sums as well as the little bit more time it takes

1285

* those sums as well as the little bit more time it takes

1286

* this and each other thread to finish dying after the

1286

* this and each other thread to finish dying after the

1287

* core dump synchronization phase.

1287

* core dump synchronization phase.

1288

*/

1288

*/

1289

cputime_to_timeval(cputime_add(p->utime, p->signal->utime),

1289

cputime_to_timeval(cputime_add(p->utime, p->signal->utime),

1290

&prstatus->pr_utime);

1290

&prstatus->pr_utime);

1291

cputime_to_timeval(cputime_add(p->stime, p->signal->stime),

1291

cputime_to_timeval(cputime_add(p->stime, p->signal->stime),

1292

&prstatus->pr_stime);

1292

&prstatus->pr_stime);

1293

} else {

1293

} else {

1294

cputime_to_timeval(p->utime, &prstatus->pr_utime);

1294

cputime_to_timeval(p->utime, &prstatus->pr_utime);

1295

cputime_to_timeval(p->stime, &prstatus->pr_stime);

1295

cputime_to_timeval(p->stime, &prstatus->pr_stime);

1296

}

1296

}

1297

cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);

1297

cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);

1298

cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);

1298

cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);

1299

}

1299

}

1300

1301

static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,

1301

static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,

1302

struct mm_struct *mm)

1302

struct mm_struct *mm)

1303

{

1303

{

1304

unsigned int i, len;

1304

unsigned int i, len;

1305

1306

/* first copy the parameters from user space */

1306

/* first copy the parameters from user space */

1307

memset(psinfo, 0, sizeof(struct elf_prpsinfo));

1307

memset(psinfo, 0, sizeof(struct elf_prpsinfo));

1308

1309

len = mm->arg_end - mm->arg_start;

1309

len = mm->arg_end - mm->arg_start;

1310

if (len >= ELF_PRARGSZ)

1310

if (len >= ELF_PRARGSZ)

1311

len = ELF_PRARGSZ-1;

1311

len = ELF_PRARGSZ-1;

1312

if (copy_from_user(&psinfo->pr_psargs,

1312

if (copy_from_user(&psinfo->pr_psargs,

1313

(const char __user *)mm->arg_start, len))

1313

(const char __user *)mm->arg_start, len))

1314

return -EFAULT;

1314

return -EFAULT;

1315

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

1315

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

1316

if (psinfo->pr_psargs[i] == 0)

1316

if (psinfo->pr_psargs[i] == 0)

1317

psinfo->pr_psargs[i] = ' ';

1317

psinfo->pr_psargs[i] = ' ';

1318

psinfo->pr_psargs[len] = 0;

1318

psinfo->pr_psargs[len] = 0;

1319

1320

psinfo->pr_pid = p->pid;

1320

psinfo->pr_pid = p->pid;

1321

psinfo->pr_ppid = p->parent->pid;

1321

psinfo->pr_ppid = p->parent->pid;

1322

psinfo->pr_pgrp = process_group(p);

1322

psinfo->pr_pgrp = process_group(p);

1323

psinfo->pr_sid = p->signal->session;

1323

psinfo->pr_sid = p->signal->session;

1324

1325

i = p->state ? ffz(~p->state) + 1 : 0;

1325

i = p->state ? ffz(~p->state) + 1 : 0;

1326

psinfo->pr_state = i;

1326

psinfo->pr_state = i;

1327

psinfo->pr_sname = (i < 0 || i > 5) ? '.' : "RSDTZW"[i];

1327

psinfo->pr_sname = (i < 0 || i > 5) ? '.' : "RSDTZW"[i];

1328

psinfo->pr_zomb = psinfo->pr_sname == 'Z';

1328

psinfo->pr_zomb = psinfo->pr_sname == 'Z';

1329

psinfo->pr_nice = task_nice(p);

1329

psinfo->pr_nice = task_nice(p);

1330

psinfo->pr_flag = p->flags;

1330

psinfo->pr_flag = p->flags;

1331

SET_UID(psinfo->pr_uid, p->uid);

1331

SET_UID(psinfo->pr_uid, p->uid);

1332

SET_GID(psinfo->pr_gid, p->gid);

1332

SET_GID(psinfo->pr_gid, p->gid);

1333

strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));

1333

strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));

1334

1335

return 0;

1335

return 0;

1336

}

1336

}

1337

1338

/* Here is the structure in which status of each thread is captured. */

1338

/* Here is the structure in which status of each thread is captured. */

1339

struct elf_thread_status

1339

struct elf_thread_status

1340

{

1340

{

1341

struct list_head list;

1341

struct list_head list;

1342

struct elf_prstatus prstatus; /* NT_PRSTATUS */

1342

struct elf_prstatus prstatus; /* NT_PRSTATUS */

1343

elf_fpregset_t fpu; /* NT_PRFPREG */

1343

elf_fpregset_t fpu; /* NT_PRFPREG */

1344

struct task_struct *thread;

1344

struct task_struct *thread;

1345

#ifdef ELF_CORE_COPY_XFPREGS

1345

#ifdef ELF_CORE_COPY_XFPREGS

1346

elf_fpxregset_t xfpu; /* NT_PRXFPREG */

1346

elf_fpxregset_t xfpu; /* NT_PRXFPREG */

1347

#endif

1347

#endif

1348

struct memelfnote notes[3];

1348

struct memelfnote notes[3];

1349

int num_notes;

1349

int num_notes;

1350

};

1350

};

1351

1352

/*

1352

/*

1353

* In order to add the specific thread information for the elf file format,

1353

* In order to add the specific thread information for the elf file format,

1354

* we need to keep a linked list of every threads pr_status and then

1354

* we need to keep a linked list of every threads pr_status and then

1355

* create a single section for them in the final core file.

1355

* create a single section for them in the final core file.

1356

*/

1356

*/

1357

static int elf_dump_thread_status(long signr, struct elf_thread_status *t)

1357

static int elf_dump_thread_status(long signr, struct elf_thread_status *t)

1358

{

1358

{

1359

int sz = 0;

1359

int sz = 0;

1360

struct task_struct *p = t->thread;

1360

struct task_struct *p = t->thread;

1361

t->num_notes = 0;

1361

t->num_notes = 0;

1362

1363

fill_prstatus(&t->prstatus, p, signr);

1363

fill_prstatus(&t->prstatus, p, signr);

1364

elf_core_copy_task_regs(p, &t->prstatus.pr_reg);

1364

elf_core_copy_task_regs(p, &t->prstatus.pr_reg);

1365

1366

fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus), &(t->prstatus));

1366

fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus), &(t->prstatus));

1367

t->num_notes++;

1367

t->num_notes++;

1368

sz += notesize(&t->notes[0]);

1368

sz += notesize(&t->notes[0]);

1369

1370

if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL, &t->fpu))) {

1370

if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL, &t->fpu))) {

1371

fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu), &(t->fpu));

1371

fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu), &(t->fpu));

1372

t->num_notes++;

1372

t->num_notes++;

1373

sz += notesize(&t->notes[1]);

1373

sz += notesize(&t->notes[1]);

1374

}

1374

}

1375

1376

#ifdef ELF_CORE_COPY_XFPREGS

1376

#ifdef ELF_CORE_COPY_XFPREGS

1377

if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {

1377

if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {

1378

fill_note(&t->notes[2], "LINUX", NT_PRXFPREG, sizeof(t->xfpu), &t->xfpu);

1378

fill_note(&t->notes[2], "LINUX", NT_PRXFPREG, sizeof(t->xfpu), &t->xfpu);

1379

t->num_notes++;

1379

t->num_notes++;

1380

sz += notesize(&t->notes[2]);

1380

sz += notesize(&t->notes[2]);

1381

}

1381

}

1382

#endif

1382

#endif

1383

return sz;

1383

return sz;

1384

}

1384

}

1385

1386

/*

1386

/*

1387

* Actual dumper

1387

* Actual dumper

1388

*

1388

*

1389

* This is a two-pass process; first we find the offsets of the bits,

1389

* This is a two-pass process; first we find the offsets of the bits,

1390

* and then they are actually written out. If we run out of core limit

1390

* and then they are actually written out. If we run out of core limit

1391

* we just truncate.

1391

* we just truncate.

1392

*/

1392

*/

1393

static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)

1393

static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)

1394

{

1394

{

1395

#define NUM_NOTES 6

1395

#define NUM_NOTES 6

1396

int has_dumped = 0;

1396

int has_dumped = 0;

1397

mm_segment_t fs;

1397

mm_segment_t fs;

1398

int segs;

1398

int segs;

1399

size_t size = 0;

1399

size_t size = 0;

1400

int i;

1400

int i;

1401

struct vm_area_struct *vma;

1401

struct vm_area_struct *vma;

1402

struct elfhdr *elf = NULL;

1402

struct elfhdr *elf = NULL;

1403

off_t offset = 0, dataoff;

1403

off_t offset = 0, dataoff;

1404

unsigned long limit = current->signal->rlim[RLIMIT_CORE].rlim_cur;

1404

unsigned long limit = current->signal->rlim[RLIMIT_CORE].rlim_cur;

1405

int numnote;

1405

int numnote;

1406

struct memelfnote *notes = NULL;

1406

struct memelfnote *notes = NULL;

1407

struct elf_prstatus *prstatus = NULL; /* NT_PRSTATUS */

1407

struct elf_prstatus *prstatus = NULL; /* NT_PRSTATUS */

1408

struct elf_prpsinfo *psinfo = NULL; /* NT_PRPSINFO */

1408

struct elf_prpsinfo *psinfo = NULL; /* NT_PRPSINFO */

1409

struct task_struct *g, *p;

1409

struct task_struct *g, *p;

1410

LIST_HEAD(thread_list);

1410

LIST_HEAD(thread_list);

1411

struct list_head *t;

1411

struct list_head *t;

1412

elf_fpregset_t *fpu = NULL;

1412

elf_fpregset_t *fpu = NULL;

1413

#ifdef ELF_CORE_COPY_XFPREGS

1413

#ifdef ELF_CORE_COPY_XFPREGS

1414

elf_fpxregset_t *xfpu = NULL;

1414

elf_fpxregset_t *xfpu = NULL;

1415

#endif

1415

#endif

1416

int thread_status_size = 0;

1416

int thread_status_size = 0;

1417

elf_addr_t *auxv;

1417

elf_addr_t *auxv;

1418

1419

/*

1419

/*

1420

* We no longer stop all VM operations.

1420

* We no longer stop all VM operations.

1421

*

1421

*

1422

* This is because those proceses that could possibly change map_count or

1422

* This is because those proceses that could possibly change map_count or

1423

* the mmap / vma pages are now blocked in do_exit on current finishing

1423

* the mmap / vma pages are now blocked in do_exit on current finishing

1424

* this core dump.

1424

* this core dump.

1425

*

1425

*

1426

* Only ptrace can touch these memory addresses, but it doesn't change

1426

* Only ptrace can touch these memory addresses, but it doesn't change

1427

* the map_count or the pages allocated. So no possibility of crashing

1427

* the map_count or the pages allocated. So no possibility of crashing

1428

* exists while dumping the mm->vm_next areas to the core file.

1428

* exists while dumping the mm->vm_next areas to the core file.

1429

*/

1429

*/

1430

1431

/* alloc memory for large data structures: too large to be on stack */

1431

/* alloc memory for large data structures: too large to be on stack */

1432

elf = kmalloc(sizeof(*elf), GFP_KERNEL);

1432

elf = kmalloc(sizeof(*elf), GFP_KERNEL);

1433

if (!elf)

1433

if (!elf)

1434

goto cleanup;

1434

goto cleanup;

1435

prstatus = kmalloc(sizeof(*prstatus), GFP_KERNEL);

1435

prstatus = kmalloc(sizeof(*prstatus), GFP_KERNEL);

1436

if (!prstatus)

1436

if (!prstatus)

1437

goto cleanup;

1437

goto cleanup;

1438

psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);

1438

psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);

1439

if (!psinfo)

1439

if (!psinfo)

1440

goto cleanup;

1440

goto cleanup;

1441

notes = kmalloc(NUM_NOTES * sizeof(struct memelfnote), GFP_KERNEL);

1441

notes = kmalloc(NUM_NOTES * sizeof(struct memelfnote), GFP_KERNEL);

1442

if (!notes)

1442

if (!notes)

1443

goto cleanup;

1443

goto cleanup;

1444

fpu = kmalloc(sizeof(*fpu), GFP_KERNEL);

1444

fpu = kmalloc(sizeof(*fpu), GFP_KERNEL);

1445

if (!fpu)

1445

if (!fpu)

1446

goto cleanup;

1446

goto cleanup;

1447

#ifdef ELF_CORE_COPY_XFPREGS

1447

#ifdef ELF_CORE_COPY_XFPREGS

1448

xfpu = kmalloc(sizeof(*xfpu), GFP_KERNEL);

1448

xfpu = kmalloc(sizeof(*xfpu), GFP_KERNEL);

1449

if (!xfpu)

1449

if (!xfpu)

1450

goto cleanup;

1450

goto cleanup;

1451

#endif

1451

#endif

1452

1453

if (signr) {

1453

if (signr) {

1454

struct elf_thread_status *tmp;

1454

struct elf_thread_status *tmp;

1455

read_lock(&tasklist_lock);

1455

read_lock(&tasklist_lock);

1456

do_each_thread(g,p)

1456

do_each_thread(g,p)

1457

if (current->mm == p->mm && current != p) {

1457

if (current->mm == p->mm && current != p) {

1458

tmp = kmalloc(sizeof(*tmp), GFP_ATOMIC);

1458

tmp = kmalloc(sizeof(*tmp), GFP_ATOMIC);

1459

if (!tmp) {

1459

if (!tmp) {

1460

read_unlock(&tasklist_lock);

1460

read_unlock(&tasklist_lock);

1461

goto cleanup;

1461

goto cleanup;

1462

}

1462

}

1463

memset(tmp, 0, sizeof(*tmp));

1463

memset(tmp, 0, sizeof(*tmp));

1464

INIT_LIST_HEAD(&tmp->list);

1464

INIT_LIST_HEAD(&tmp->list);

1465

tmp->thread = p;

1465

tmp->thread = p;

1466

list_add(&tmp->list, &thread_list);

1466

list_add(&tmp->list, &thread_list);

1467

}

1467

}

1468

while_each_thread(g,p);

1468

while_each_thread(g,p);

1469

read_unlock(&tasklist_lock);

1469

read_unlock(&tasklist_lock);

1470

list_for_each(t, &thread_list) {

1470

list_for_each(t, &thread_list) {

1471

struct elf_thread_status *tmp;

1471

struct elf_thread_status *tmp;

1472

int sz;

1472

int sz;

1473

1474

tmp = list_entry(t, struct elf_thread_status, list);

1474

tmp = list_entry(t, struct elf_thread_status, list);

1475

sz = elf_dump_thread_status(signr, tmp);

1475

sz = elf_dump_thread_status(signr, tmp);

1476

thread_status_size += sz;

1476

thread_status_size += sz;

1477

}

1477

}

1478

}

1478

}

1479

/* now collect the dump for the current */

1479

/* now collect the dump for the current */

1480

memset(prstatus, 0, sizeof(*prstatus));

1480

memset(prstatus, 0, sizeof(*prstatus));

1481

fill_prstatus(prstatus, current, signr);

1481

fill_prstatus(prstatus, current, signr);

1482

elf_core_copy_regs(&prstatus->pr_reg, regs);

1482

elf_core_copy_regs(&prstatus->pr_reg, regs);

1483

1484

segs = current->mm->map_count;

1484

segs = current->mm->map_count;

1485

#ifdef ELF_CORE_EXTRA_PHDRS

1485

#ifdef ELF_CORE_EXTRA_PHDRS

1486

segs += ELF_CORE_EXTRA_PHDRS;

1486

segs += ELF_CORE_EXTRA_PHDRS;

1487

#endif

1487

#endif

1488

1489

/* Set up header */

1489

/* Set up header */

1490

fill_elf_header(elf, segs+1); /* including notes section */

1490

fill_elf_header(elf, segs+1); /* including notes section */

1491

1492

has_dumped = 1;

1492

has_dumped = 1;

1493

current->flags |= PF_DUMPCORE;

1493

current->flags |= PF_DUMPCORE;

1494

1495

/*

1495

/*

1496

* Set up the notes in similar form to SVR4 core dumps made

1496

* Set up the notes in similar form to SVR4 core dumps made

1497

* with info from their /proc.

1497

* with info from their /proc.

1498

*/

1498

*/

1499

1500

fill_note(notes +0, "CORE", NT_PRSTATUS, sizeof(*prstatus), prstatus);

1500

fill_note(notes +0, "CORE", NT_PRSTATUS, sizeof(*prstatus), prstatus);

1501

1502

fill_psinfo(psinfo, current->group_leader, current->mm);

1502

fill_psinfo(psinfo, current->group_leader, current->mm);

1503

fill_note(notes +1, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);

1503

fill_note(notes +1, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);

1504

1505

fill_note(notes +2, "CORE", NT_TASKSTRUCT, sizeof(*current), current);

1505

fill_note(notes +2, "CORE", NT_TASKSTRUCT, sizeof(*current), current);

1506

1507

numnote = 3;

1507

numnote = 3;

1508

1509

auxv = (elf_addr_t *) current->mm->saved_auxv;

1509

auxv = (elf_addr_t *) current->mm->saved_auxv;

1510

1511

i = 0;

1511

i = 0;

1512

do

1512

do

1513

i += 2;

1513

i += 2;

1514

while (auxv[i - 2] != AT_NULL);

1514

while (auxv[i - 2] != AT_NULL);

1515

fill_note(&notes[numnote++], "CORE", NT_AUXV,

1515

fill_note(&notes[numnote++], "CORE", NT_AUXV,

1516

i * sizeof (elf_addr_t), auxv);

1516

i * sizeof (elf_addr_t), auxv);

1517

1518

/* Try to dump the FPU. */

1518

/* Try to dump the FPU. */

1519

if ((prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs, fpu)))

1519

if ((prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs, fpu)))

1520

fill_note(notes + numnote++,

1520

fill_note(notes + numnote++,

1521

"CORE", NT_PRFPREG, sizeof(*fpu), fpu);

1521

"CORE", NT_PRFPREG, sizeof(*fpu), fpu);

1522

#ifdef ELF_CORE_COPY_XFPREGS

1522

#ifdef ELF_CORE_COPY_XFPREGS

1523

if (elf_core_copy_task_xfpregs(current, xfpu))

1523

if (elf_core_copy_task_xfpregs(current, xfpu))

1524

fill_note(notes + numnote++,

1524

fill_note(notes + numnote++,

1525

"LINUX", NT_PRXFPREG, sizeof(*xfpu), xfpu);

1525

"LINUX", NT_PRXFPREG, sizeof(*xfpu), xfpu);

1526

#endif

1526

#endif

1527

1528

fs = get_fs();

1528

fs = get_fs();

1529

set_fs(KERNEL_DS);

1529

set_fs(KERNEL_DS);

1530

1531

DUMP_WRITE(elf, sizeof(*elf));

1531

DUMP_WRITE(elf, sizeof(*elf));

1532

offset += sizeof(*elf); /* Elf header */

1532

offset += sizeof(*elf); /* Elf header */

1533

offset += (segs+1) * sizeof(struct elf_phdr); /* Program headers */

1533

offset += (segs+1) * sizeof(struct elf_phdr); /* Program headers */

1534

1535

/* Write notes phdr entry */

1535

/* Write notes phdr entry */

1536

{

1536

{

1537

struct elf_phdr phdr;

1537

struct elf_phdr phdr;

1538

int sz = 0;

1538

int sz = 0;

1539

1540

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

1540

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

1541

sz += notesize(notes + i);

1541

sz += notesize(notes + i);

1542

1543

sz += thread_status_size;

1543

sz += thread_status_size;

1544

1545

fill_elf_note_phdr(&phdr, sz, offset);

1545

fill_elf_note_phdr(&phdr, sz, offset);

1546

offset += sz;

1546

offset += sz;

1547

DUMP_WRITE(&phdr, sizeof(phdr));

1547

DUMP_WRITE(&phdr, sizeof(phdr));

1548

}

1548

}

1549

1550

/* Page-align dumped data */

1550

/* Page-align dumped data */

1551

dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);

1551

dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);

1552

1553

/* Write program headers for segments dump */

1553

/* Write program headers for segments dump */

1554

for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {

1554

for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {

1555

struct elf_phdr phdr;

1555

struct elf_phdr phdr;

1556

size_t sz;

1556

size_t sz;

1557

1558

sz = vma->vm_end - vma->vm_start;

1558

sz = vma->vm_end - vma->vm_start;

1559

1560

phdr.p_type = PT_LOAD;

1560

phdr.p_type = PT_LOAD;

1561

phdr.p_offset = offset;

1561

phdr.p_offset = offset;

1562

phdr.p_vaddr = vma->vm_start;

1562

phdr.p_vaddr = vma->vm_start;

1563

phdr.p_paddr = 0;

1563

phdr.p_paddr = 0;

1564

phdr.p_filesz = maydump(vma) ? sz : 0;

1564

phdr.p_filesz = maydump(vma) ? sz : 0;

1565

phdr.p_memsz = sz;

1565

phdr.p_memsz = sz;

1566

offset += phdr.p_filesz;

1566

offset += phdr.p_filesz;

1567

phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;

1567

phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;

1568

if (vma->vm_flags & VM_WRITE) phdr.p_flags |= PF_W;

1568

if (vma->vm_flags & VM_WRITE) phdr.p_flags |= PF_W;

1569

if (vma->vm_flags & VM_EXEC) phdr.p_flags |= PF_X;

1569

if (vma->vm_flags & VM_EXEC) phdr.p_flags |= PF_X;

1570

phdr.p_align = ELF_EXEC_PAGESIZE;

1570

phdr.p_align = ELF_EXEC_PAGESIZE;

1571

1572

DUMP_WRITE(&phdr, sizeof(phdr));

1572

DUMP_WRITE(&phdr, sizeof(phdr));

1573

}

1573

}

1574

1575

#ifdef ELF_CORE_WRITE_EXTRA_PHDRS

1575

#ifdef ELF_CORE_WRITE_EXTRA_PHDRS

1576

ELF_CORE_WRITE_EXTRA_PHDRS;

1576

ELF_CORE_WRITE_EXTRA_PHDRS;

1577

#endif

1577

#endif

1578

1579

/* write out the notes section */

1579

/* write out the notes section */

1580

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

1580

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

1581

if (!writenote(notes + i, file))

1581

if (!writenote(notes + i, file))

1582

goto end_coredump;

1582

goto end_coredump;

1583

1584

/* write out the thread status notes section */

1584

/* write out the thread status notes section */

1585

list_for_each(t, &thread_list) {

1585

list_for_each(t, &thread_list) {

1586

struct elf_thread_status *tmp = list_entry(t, struct elf_thread_status, list);

1586

struct elf_thread_status *tmp = list_entry(t, struct elf_thread_status, list);

1587

for (i = 0; i < tmp->num_notes; i++)

1587

for (i = 0; i < tmp->num_notes; i++)

1588

if (!writenote(&tmp->notes[i], file))

1588

if (!writenote(&tmp->notes[i], file))

1589

goto end_coredump;

1589

goto end_coredump;

1590

}

1590

}

1591

1592

DUMP_SEEK(dataoff);

1592

DUMP_SEEK(dataoff);

1593

1594

for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {

1594

for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {

1595

unsigned long addr;

1595

unsigned long addr;

1596

1597

if (!maydump(vma))

1597

if (!maydump(vma))

1598

continue;

1598

continue;

1599

1600

for (addr = vma->vm_start;

1600

for (addr = vma->vm_start;

1601

addr < vma->vm_end;

1601

addr < vma->vm_end;

1602

addr += PAGE_SIZE) {

1602

addr += PAGE_SIZE) {

1603

struct page* page;

1603

struct page* page;

1604

struct vm_area_struct *vma;

1604

struct vm_area_struct *vma;

1605

1606

if (get_user_pages(current, current->mm, addr, 1, 0, 1,

1606

if (get_user_pages(current, current->mm, addr, 1, 0, 1,

1607

&page, &vma) <= 0) {

1607

&page, &vma) <= 0) {

1608

DUMP_SEEK (file->f_pos + PAGE_SIZE);

1608

DUMP_SEEK (file->f_pos + PAGE_SIZE);

1609

} else {

1609

} else {

1610

if (page == ZERO_PAGE(addr)) {

1610

if (page == ZERO_PAGE(addr)) {

1611

DUMP_SEEK (file->f_pos + PAGE_SIZE);

1611

DUMP_SEEK (file->f_pos + PAGE_SIZE);

1612

} else {

1612

} else {

1613

void *kaddr;

1613

void *kaddr;

1614

flush_cache_page(vma, addr, page_to_pfn(page));

1614

flush_cache_page(vma, addr, page_to_pfn(page));

1615

kaddr = kmap(page);

1615

kaddr = kmap(page);

1616

if ((size += PAGE_SIZE) > limit ||

1616

if ((size += PAGE_SIZE) > limit ||

1617

!dump_write(file, kaddr,

1617

!dump_write(file, kaddr,

1618

PAGE_SIZE)) {

1618

PAGE_SIZE)) {

1619

kunmap(page);

1619

kunmap(page);

1620

page_cache_release(page);

1620

page_cache_release(page);

1621

goto end_coredump;

1621

goto end_coredump;

1622

}

1622

}

1623

kunmap(page);

1623

kunmap(page);

1624

}

1624

}

1625

page_cache_release(page);

1625

page_cache_release(page);

1626

}

1626

}

1627

}

1627

}

1628

}

1628

}

1629

1630

#ifdef ELF_CORE_WRITE_EXTRA_DATA

1630

#ifdef ELF_CORE_WRITE_EXTRA_DATA

1631

ELF_CORE_WRITE_EXTRA_DATA;

1631

ELF_CORE_WRITE_EXTRA_DATA;

1632

#endif

1632

#endif

1633

1634

if ((off_t) file->f_pos != offset) {

1634

if ((off_t) file->f_pos != offset) {

1635

/* Sanity check */

1635

/* Sanity check */

1636

printk("elf_core_dump: file->f_pos (%ld) != offset (%ld)\n",

1636

printk("elf_core_dump: file->f_pos (%ld) != offset (%ld)\n",

1637

(off_t) file->f_pos, offset);

1637

(off_t) file->f_pos, offset);

1638

}

1638

}

1639

1640

end_coredump:

1640

end_coredump:

1641

set_fs(fs);

1641

set_fs(fs);

1642

1643

cleanup:

1643

cleanup:

1644

while(!list_empty(&thread_list)) {

1644

while(!list_empty(&thread_list)) {

1645

struct list_head *tmp = thread_list.next;

1645

struct list_head *tmp = thread_list.next;

1646

list_del(tmp);

1646

list_del(tmp);

1647

kfree(list_entry(tmp, struct elf_thread_status, list));

1647

kfree(list_entry(tmp, struct elf_thread_status, list));

1648

}

1648

}

1649

1650

kfree(elf);

1650

kfree(elf);

1651

kfree(prstatus);

1651

kfree(prstatus);

1652

kfree(psinfo);

1652

kfree(psinfo);

1653

kfree(notes);

1653

kfree(notes);

1654

kfree(fpu);

1654

kfree(fpu);

1655

#ifdef ELF_CORE_COPY_XFPREGS

1655

#ifdef ELF_CORE_COPY_XFPREGS

1656

kfree(xfpu);

1656

kfree(xfpu);

1657

#endif

1657

#endif

1658

return has_dumped;

1658

return has_dumped;

1659

#undef NUM_NOTES

1659

#undef NUM_NOTES

1660

}

1660

}

1661

1662

#endif /* USE_ELF_CORE_DUMP */

1662

#endif /* USE_ELF_CORE_DUMP */

1663

1664

static int __init init_elf_binfmt(void)

1664

static int __init init_elf_binfmt(void)

1665

{

1665

{

1666

return register_binfmt(&elf_format);

1666

return register_binfmt(&elf_format);

1667

}

1667

}

1668

1669

static void __exit exit_elf_binfmt(void)

1669

static void __exit exit_elf_binfmt(void)

1670

{

1670

{

1671

/* Remove the COFF and ELF loaders. */

1671

/* Remove the COFF and ELF loaders. */

1672

unregister_binfmt(&elf_format);

1672

unregister_binfmt(&elf_format);

1673

}

1673

}

1674

1675

core_initcall(init_elf_binfmt);

1675

core_initcall(init_elf_binfmt);

1676

module_exit(exit_elf_binfmt);

1676

module_exit(exit_elf_binfmt);

1677

MODULE_LICENSE("GPL");

1677

MODULE_LICENSE("GPL");

1678

GITLAB

[PATCH] Fix large core dumps with a 32-bit off_t