elf core dump: notes user_regset

	fill_note(note, "CORE", NT_AUXV, i * sizeof(elf_addr_t), auxv);

}

#ifdef CORE_DUMP_USE_REGSET

#include <linux/regset.h>

struct elf_thread_core_info {

	struct elf_thread_core_info *next;

	struct task_struct *task;

	struct elf_prstatus prstatus;

	struct memelfnote notes[0];

};

struct elf_note_info {

	struct elf_thread_core_info *thread;

	struct memelfnote psinfo;

	struct memelfnote auxv;

	size_t size;

	int thread_notes;

};

static int fill_thread_core_info(struct elf_thread_core_info *t,

				 const struct user_regset_view *view,

				 long signr, size_t *total)

{

	unsigned int i;

	/*

	 * NT_PRSTATUS is the one special case, because the regset data

	 * goes into the pr_reg field inside the note contents, rather

	 * than being the whole note contents.  We fill the reset in here.

	 * We assume that regset 0 is NT_PRSTATUS.

	 */

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

	(void) view->regsets[0].get(t->task, &view->regsets[0],

				    0, sizeof(t->prstatus.pr_reg),

				    &t->prstatus.pr_reg, NULL);

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

		  sizeof(t->prstatus), &t->prstatus);

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

	/*

	 * Each other regset might generate a note too.  For each regset

	 * that has no core_note_type or is inactive, we leave t->notes[i]

	 * all zero and we'll know to skip writing it later.

	 */

	for (i = 1; i < view->n; ++i) {

		const struct user_regset *regset = &view->regsets[i];

		if (regset->core_note_type &&

		    (!regset->active || regset->active(t->task, regset))) {

			int ret;

			size_t size = regset->n * regset->size;

			void *data = kmalloc(size, GFP_KERNEL);

			if (unlikely(!data))

				return 0;

			ret = regset->get(t->task, regset,

					  0, size, data, NULL);

			if (unlikely(ret))

				kfree(data);

			else {

				if (regset->core_note_type != NT_PRFPREG)

					fill_note(&t->notes[i], "LINUX",

						  regset->core_note_type,

						  size, data);

				else {

					t->prstatus.pr_fpvalid = 1;

					fill_note(&t->notes[i], "CORE",

						  NT_PRFPREG, size, data);

				}

				*total += notesize(&t->notes[i]);

			}

		}

	}

	return 1;

}

static int fill_note_info(struct elfhdr *elf, int phdrs,

			  struct elf_note_info *info,

			  long signr, struct pt_regs *regs)

{

	struct task_struct *dump_task = current;

	const struct user_regset_view *view = task_user_regset_view(dump_task);

	struct elf_thread_core_info *t;

	struct elf_prpsinfo *psinfo;

	struct task_struct *g, *p;

	unsigned int i;

	info->size = 0;

	info->thread = NULL;

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

	fill_note(&info->psinfo, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);

	if (psinfo == NULL)

		return 0;

	/*

	 * Figure out how many notes we're going to need for each thread.

	 */

	info->thread_notes = 0;

	for (i = 0; i < view->n; ++i)

		if (view->regsets[i].core_note_type != 0)

			++info->thread_notes;

	/*

	 * Sanity check.  We rely on regset 0 being in NT_PRSTATUS,

	 * since it is our one special case.

	 */

	if (unlikely(info->thread_notes == 0) ||

	    unlikely(view->regsets[0].core_note_type != NT_PRSTATUS)) {

		WARN_ON(1);

		return 0;

	}

	/*

	 * Initialize the ELF file header.

	 */

	fill_elf_header(elf, phdrs,

			view->e_machine, view->e_flags, view->ei_osabi);

	/*

	 * Allocate a structure for each thread.

	 */

	rcu_read_lock();

	do_each_thread(g, p)

		if (p->mm == dump_task->mm) {

			t = kzalloc(offsetof(struct elf_thread_core_info,

					     notes[info->thread_notes]),

				    GFP_ATOMIC);

			if (unlikely(!t)) {

				rcu_read_unlock();

				return 0;

			}

			t->task = p;

			if (p == dump_task || !info->thread) {

				t->next = info->thread;

				info->thread = t;

			} else {

				/*

				 * Make sure to keep the original task at

				 * the head of the list.

				 */

				t->next = info->thread->next;

				info->thread->next = t;

			}

		}

	while_each_thread(g, p);

	rcu_read_unlock();

	/*

	 * Now fill in each thread's information.

	 */

	for (t = info->thread; t != NULL; t = t->next)

		if (!fill_thread_core_info(t, view, signr, &info->size))

			return 0;

	/*

	 * Fill in the two process-wide notes.

	 */

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

	info->size += notesize(&info->psinfo);

	fill_auxv_note(&info->auxv, current->mm);

	info->size += notesize(&info->auxv);

	return 1;

}

static size_t get_note_info_size(struct elf_note_info *info)

{

	return info->size;

}

/*

 * Write all the notes for each thread.  When writing the first thread, the

 * process-wide notes are interleaved after the first thread-specific note.

 */

static int write_note_info(struct elf_note_info *info,

			   struct file *file, loff_t *foffset)

{

	bool first = 1;

	struct elf_thread_core_info *t = info->thread;

	do {

		int i;

		if (!writenote(&t->notes[0], file, foffset))

			return 0;

		if (first && !writenote(&info->psinfo, file, foffset))

			return 0;

		if (first && !writenote(&info->auxv, file, foffset))

			return 0;

		for (i = 1; i < info->thread_notes; ++i)

			if (t->notes[i].data &&

			    !writenote(&t->notes[i], file, foffset))

				return 0;

		first = 0;

		t = t->next;

	} while (t);

	return 1;

}

static void free_note_info(struct elf_note_info *info)

{

	struct elf_thread_core_info *threads = info->thread;

	while (threads) {

		unsigned int i;

		struct elf_thread_core_info *t = threads;

		threads = t->next;

		WARN_ON(t->notes[0].data && t->notes[0].data != &t->prstatus);

		for (i = 1; i < info->thread_notes; ++i)

			kfree(t->notes[i].data);

		kfree(t);

	}

	kfree(info->psinfo.data);

}

#else

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

struct elf_thread_status

{

#endif

}

#endif

static struct vm_area_struct *first_vma(struct task_struct *tsk,

					struct vm_area_struct *gate_vma)

{