[PATCH] binfmt_elf: CodingStyle cleanup and remove some pointless casts

#include <linux/security.h>

#include <linux/syscalls.h>

#include <linux/random.h>

#include <linux/elf.h>

#include <asm/uaccess.h>

#include <asm/param.h>

#include <asm/page.h>

#include <linux/elf.h>

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

static int load_elf_library(struct file *);

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

	return 0;

}

/* We need to explicitly zero any fractional pages

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

   contain the junk from the file that should not

   be in memory */

   be in memory

 */

static int padzero(unsigned long elf_bss)

{

	unsigned long nbyte;

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

#define STACK_ROUND(sp, items) \

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

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

#define STACK_ALLOC(sp, len) ({ \

	elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; \

	old_sp; })

#else

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

#define STACK_ROUND(sp, items) \

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

	 * merely difficult.

	 */

	u_platform = NULL;

	if (k_platform) {

		size_t len = strlen(k_platform) + 1;

	/* Create the ELF interpreter info */

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

#define NEW_AUX_ENT(id, val) \

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

	do { \

		elf_info[ei_index++] = id; elf_info[ei_index++] = val; \

	} while (0)

#ifdef ARCH_DLINFO

	/* 

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

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

	if (k_platform) {

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

		NEW_AUX_ENT(AT_PLATFORM,

			(elf_addr_t)(unsigned long)u_platform);

	}

	if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {

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

   an ELF header */

static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,

				     struct file * interpreter,

				     unsigned long *interp_load_addr)

		struct file *interpreter, unsigned long *interp_load_addr)

{

	struct elf_phdr *elf_phdata;

	struct elf_phdr *eppnt;

		goto out;

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

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

	if (size > ELF_MIN_ALIGN)

		goto out;

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

	elf_phdata = kmalloc(size, GFP_KERNEL);

	if (!elf_phdata)

		goto out;

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

	retval = kernel_read(interpreter, interp_elf_ex->e_phoff,

			     (char *)elf_phdata,size);

	error = -EIO;

	if (retval != size) {

		if (retval < 0)

			unsigned long vaddr = 0;

			unsigned long k, map_addr;

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

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

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

			if (eppnt->p_flags & PF_R)

		    		elf_prot = PROT_READ;

			if (eppnt->p_flags & PF_W)

				elf_prot |= PROT_WRITE;

			if (eppnt->p_flags & PF_X)

				elf_prot |= PROT_EXEC;

			vaddr = eppnt->p_vaddr;

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

				elf_type |= MAP_FIXED;

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

			map_addr = elf_map(interpreter, load_addr + vaddr,

					   eppnt, elf_prot, elf_type);

			error = map_addr;

			if (BAD_ADDR(map_addr))

				goto out_close;

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

			if (!load_addr_set &&

			    interp_elf_ex->e_type == ET_DYN) {

				load_addr = map_addr - ELF_PAGESTART(vaddr);

				load_addr_set = 1;

			}

			/*

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

			 * allowed task size. Note that p_filesz must always be

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

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

			 */

			k = load_addr + eppnt->p_vaddr;

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

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

			if (k > TASK_SIZE ||

			    eppnt->p_filesz > eppnt->p_memsz ||

			    eppnt->p_memsz > TASK_SIZE ||

			    TASK_SIZE - eppnt->p_memsz < k) {

				error = -ENOMEM;

				goto out_close;

			}

			/*

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

	     * track of the largest address we see for this.

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

			 * keep track of the largest address we see for this.

			 */

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

			if (k > elf_bss)

		goto out_close;

	}

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

	/* What we have mapped so far */

	elf_bss = ELF_PAGESTART(elf_bss + ELF_MIN_ALIGN - 1);

	/* Map the last of the bss segment */

	if (last_bss > elf_bss) {

	flush_icache_range((unsigned long)addr,

	                   (unsigned long)addr + text_data);

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

	do_brk(ELF_PAGESTART(text_data + ELF_MIN_ALIGN - 1),

		interp_ex->a_bss);

		goto out;

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

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

		goto out;

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

		goto out;

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

	retval = -ENOMEM;

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

	elf_phdata = kmalloc(size, GFP_KERNEL);

	if (!elf_phdata)

		goto out;

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

	retval = kernel_read(bprm->file, loc->elf_ex.e_phoff,

			     (char *)elf_phdata, size);

	if (retval != size) {

		if (retval >= 0)

			retval = -EIO;

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

	   loader stuff we need to do it earlier */

	retval = get_unused_fd();

	if (retval < 0)

		goto out_free_fh;

			 * shared libraries - for now assume that this

			 * is an a.out format binary

			 */

			retval = -ENOEXEC;

			if (elf_ppnt->p_filesz > PATH_MAX || 

			    elf_ppnt->p_filesz < 2)

			retval = PTR_ERR(interpreter);

			if (IS_ERR(interpreter))

				goto out_free_interp;

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

			retval = kernel_read(interpreter, 0, bprm->buf,

					     BINPRM_BUF_SIZE);

			if (retval != BINPRM_BUF_SIZE) {

				if (retval >= 0)

					retval = -EIO;

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

	   and then start this sucker up */

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

		char *passed_p = passed_fileno;

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

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

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

	   address. */

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

	for(i = 0, elf_ppnt = elf_phdata;

	    i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {

		int elf_prot = 0, elf_flags;

		unsigned long k, vaddr;

			}

		}

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

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

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

		if (elf_ppnt->p_flags & PF_R)

			elf_prot |= PROT_READ;

		if (elf_ppnt->p_flags & PF_W)

			elf_prot |= PROT_WRITE;

		if (elf_ppnt->p_flags & PF_X)

			elf_prot |= PROT_EXEC;

		elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;

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

			elf_flags |= MAP_FIXED;

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

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

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

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

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

			 * default mmap base, as well as whatever program they

			 * might try to exec.  This is because the brk will

			 * follow the loader, and is not movable.  */

			load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);

		}

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

		error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,

				elf_prot, elf_flags);

		if (BAD_ADDR(error)) {

			send_sig(SIGKILL, current, 0);

			goto out_free_dentry;

			}

		}

		k = elf_ppnt->p_vaddr;

		if (k < start_code) start_code = k;

		if (start_data < k) start_data = k;

		if (k < start_code)

			start_code = k;

		if (start_data < k)

			start_data = k;

		/*

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

	compute_creds(bprm);

	current->flags &= ~PF_FORKNOEXEC;

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

	create_elf_tables(bprm, &loc->elf_ex,

			  (interpreter_type == INTERPRETER_AOUT),

			  load_addr, interp_load_addr);

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

	if (interpreter_type == INTERPRETER_AOUT)

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

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

static int load_elf_library(struct file *file)

{

	struct elf_phdr *elf_phdata;

		goto out_free_ph;

	}

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

	len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr +

			    ELF_MIN_ALIGN - 1);

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

	if (bss > len) {

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

}

/*

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

 * which need to be filled up separately.

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

 * registers which need to be filled up separately.

 */

static void fill_prstatus(struct elf_prstatus *prstatus,

		struct task_struct *p, long signr)

/*

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

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

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

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

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

 */

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

{

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

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

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

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

		  &(t->prstatus));

	t->num_notes++;

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

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

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

	if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL,

								&t->fpu))) {

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

			  &(t->fpu));

		t->num_notes++;

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

	}

#ifdef ELF_CORE_COPY_XFPREGS

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

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

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

			  &t->xfpu);

		t->num_notes++;

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

	}

	/*

	 * We no longer stop all VM operations.

	 * 

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

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

	 * this core dump.

	 * This is because those proceses that could possibly change map_count

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

	 * finishing this core dump.

	 *

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

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

	 */

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

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

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

		  i * sizeof(elf_addr_t), auxv);

  	/* Try to dump the FPU. */

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

	if ((prstatus->pr_fpvalid =

	     elf_core_copy_task_fpregs(current, regs, fpu)))

		fill_note(notes + numnote++,

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

#ifdef ELF_CORE_COPY_XFPREGS

		phdr.p_memsz = sz;

		offset += phdr.p_filesz;

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

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

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

		if (vma->vm_flags & VM_WRITE)

			phdr.p_flags |= PF_W;

		if (vma->vm_flags & VM_EXEC)

			phdr.p_flags |= PF_X;

		phdr.p_align = ELF_EXEC_PAGESIZE;

		DUMP_WRITE(&phdr, sizeof(phdr));

	/* write out the thread status notes section */

	list_for_each(t, &thread_list) {

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

		struct elf_thread_status *tmp =

				list_entry(t, struct elf_thread_status, list);

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

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

				goto end_coredump;

					DUMP_SEEK(file->f_pos + PAGE_SIZE);

				} else {

					void *kaddr;

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

					flush_cache_page(vma, addr,

							 page_to_pfn(page));

					kaddr = kmap(page);

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

					    !dump_write(file, kaddr,

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

		/* Sanity check */

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

		printk(KERN_WARNING

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

		       (off_t)file->f_pos, offset);

	}