kcore.c 15.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 *	fs/proc/kcore.c kernel ELF core dumper
 *
 *	Modelled on fs/exec.c:aout_core_dump()
 *	Jeremy Fitzhardinge <jeremy@sw.oz.au>
 *	ELF version written by David Howells <David.Howells@nexor.co.uk>
 *	Modified and incorporated into 2.3.x by Tigran Aivazian <tigran@veritas.com>
 *	Support to dump vmalloc'd areas (ELF only), Tigran Aivazian <tigran@veritas.com>
 *	Safe accesses to vmalloc/direct-mapped discontiguous areas, Kanoj Sarcar <kanoj@sgi.com>
 */

#include <linux/mm.h>
#include <linux/proc_fs.h>
14
#include <linux/kcore.h>
L
Linus Torvalds 已提交
15
#include <linux/user.h>
16
#include <linux/capability.h>
L
Linus Torvalds 已提交
17 18
#include <linux/elf.h>
#include <linux/elfcore.h>
19
#include <linux/notifier.h>
L
Linus Torvalds 已提交
20 21
#include <linux/vmalloc.h>
#include <linux/highmem.h>
A
Andrew Morton 已提交
22
#include <linux/printk.h>
23
#include <linux/bootmem.h>
L
Linus Torvalds 已提交
24
#include <linux/init.h>
25
#include <linux/slab.h>
26
#include <linux/uaccess.h>
L
Linus Torvalds 已提交
27
#include <asm/io.h>
28
#include <linux/list.h>
29 30
#include <linux/ioport.h>
#include <linux/memory.h>
31
#include <linux/sched/task.h>
32
#include <asm/sections.h>
33
#include "internal.h"
L
Linus Torvalds 已提交
34

35
#define CORE_STR "CORE"
L
Linus Torvalds 已提交
36

37 38 39 40
#ifndef ELF_CORE_EFLAGS
#define ELF_CORE_EFLAGS	0
#endif

41 42
static struct proc_dir_entry *proc_root_kcore;

L
Linus Torvalds 已提交
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

#ifndef kc_vaddr_to_offset
#define	kc_vaddr_to_offset(v) ((v) - PAGE_OFFSET)
#endif
#ifndef	kc_offset_to_vaddr
#define	kc_offset_to_vaddr(o) ((o) + PAGE_OFFSET)
#endif

/* An ELF note in memory */
struct memelfnote
{
	const char *name;
	int type;
	unsigned int datasz;
	void *data;
};

60
static LIST_HEAD(kclist_head);
L
Linus Torvalds 已提交
61
static DEFINE_RWLOCK(kclist_lock);
62
static int kcore_need_update = 1;
L
Linus Torvalds 已提交
63 64

void
K
KAMEZAWA Hiroyuki 已提交
65
kclist_add(struct kcore_list *new, void *addr, size_t size, int type)
L
Linus Torvalds 已提交
66 67 68
{
	new->addr = (unsigned long)addr;
	new->size = size;
K
KAMEZAWA Hiroyuki 已提交
69
	new->type = type;
L
Linus Torvalds 已提交
70 71

	write_lock(&kclist_lock);
72
	list_add_tail(&new->list, &kclist_head);
L
Linus Torvalds 已提交
73 74 75 76 77 78 79 80 81 82 83
	write_unlock(&kclist_lock);
}

static size_t get_kcore_size(int *nphdr, size_t *elf_buflen)
{
	size_t try, size;
	struct kcore_list *m;

	*nphdr = 1; /* PT_NOTE */
	size = 0;

84
	list_for_each_entry(m, &kclist_head, list) {
L
Linus Torvalds 已提交
85 86 87 88 89 90 91
		try = kc_vaddr_to_offset((size_t)m->addr + m->size);
		if (try > size)
			size = try;
		*nphdr = *nphdr + 1;
	}
	*elf_buflen =	sizeof(struct elfhdr) + 
			(*nphdr + 2)*sizeof(struct elf_phdr) + 
92 93 94 95
			3 * ((sizeof(struct elf_note)) +
			     roundup(sizeof(CORE_STR), 4)) +
			roundup(sizeof(struct elf_prstatus), 4) +
			roundup(sizeof(struct elf_prpsinfo), 4) +
96
			roundup(arch_task_struct_size, 4);
L
Linus Torvalds 已提交
97 98 99 100
	*elf_buflen = PAGE_ALIGN(*elf_buflen);
	return size + *elf_buflen;
}

101 102 103 104 105 106 107 108 109 110
static void free_kclist_ents(struct list_head *head)
{
	struct kcore_list *tmp, *pos;

	list_for_each_entry_safe(pos, tmp, head, list) {
		list_del(&pos->list);
		kfree(pos);
	}
}
/*
111
 * Replace all KCORE_RAM/KCORE_VMEMMAP information with passed list.
112 113 114
 */
static void __kcore_update_ram(struct list_head *list)
{
115 116
	int nphdr;
	size_t size;
117 118 119 120 121 122
	struct kcore_list *tmp, *pos;
	LIST_HEAD(garbage);

	write_lock(&kclist_lock);
	if (kcore_need_update) {
		list_for_each_entry_safe(pos, tmp, &kclist_head, list) {
123 124
			if (pos->type == KCORE_RAM
				|| pos->type == KCORE_VMEMMAP)
125 126 127 128 129 130
				list_move(&pos->list, &garbage);
		}
		list_splice_tail(list, &kclist_head);
	} else
		list_splice(list, &garbage);
	kcore_need_update = 0;
131
	proc_root_kcore->size = get_kcore_size(&nphdr, &size);
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
	write_unlock(&kclist_lock);

	free_kclist_ents(&garbage);
}


#ifdef CONFIG_HIGHMEM
/*
 * If no highmem, we can assume [0...max_low_pfn) continuous range of memory
 * because memory hole is not as big as !HIGHMEM case.
 * (HIGHMEM is special because part of memory is _invisible_ from the kernel.)
 */
static int kcore_update_ram(void)
{
	LIST_HEAD(head);
	struct kcore_list *ent;
	int ret = 0;

	ent = kmalloc(sizeof(*ent), GFP_KERNEL);
	if (!ent)
		return -ENOMEM;
	ent->addr = (unsigned long)__va(0);
	ent->size = max_low_pfn << PAGE_SHIFT;
	ent->type = KCORE_RAM;
	list_add(&ent->list, &head);
	__kcore_update_ram(&head);
	return ret;
}

#else /* !CONFIG_HIGHMEM */

163 164
#ifdef CONFIG_SPARSEMEM_VMEMMAP
/* calculate vmemmap's address from given system ram pfn and register it */
165 166
static int
get_sparsemem_vmemmap_info(struct kcore_list *ent, struct list_head *head)
167 168 169 170 171 172 173 174 175
{
	unsigned long pfn = __pa(ent->addr) >> PAGE_SHIFT;
	unsigned long nr_pages = ent->size >> PAGE_SHIFT;
	unsigned long start, end;
	struct kcore_list *vmm, *tmp;


	start = ((unsigned long)pfn_to_page(pfn)) & PAGE_MASK;
	end = ((unsigned long)pfn_to_page(pfn + nr_pages)) - 1;
176
	end = PAGE_ALIGN(end);
177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
	/* overlap check (because we have to align page */
	list_for_each_entry(tmp, head, list) {
		if (tmp->type != KCORE_VMEMMAP)
			continue;
		if (start < tmp->addr + tmp->size)
			if (end > tmp->addr)
				end = tmp->addr;
	}
	if (start < end) {
		vmm = kmalloc(sizeof(*vmm), GFP_KERNEL);
		if (!vmm)
			return 0;
		vmm->addr = start;
		vmm->size = end - start;
		vmm->type = KCORE_VMEMMAP;
		list_add_tail(&vmm->list, head);
	}
	return 1;

}
#else
198 199
static int
get_sparsemem_vmemmap_info(struct kcore_list *ent, struct list_head *head)
200 201 202 203 204 205
{
	return 1;
}

#endif

206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235
static int
kclist_add_private(unsigned long pfn, unsigned long nr_pages, void *arg)
{
	struct list_head *head = (struct list_head *)arg;
	struct kcore_list *ent;

	ent = kmalloc(sizeof(*ent), GFP_KERNEL);
	if (!ent)
		return -ENOMEM;
	ent->addr = (unsigned long)__va((pfn << PAGE_SHIFT));
	ent->size = nr_pages << PAGE_SHIFT;

	/* Sanity check: Can happen in 32bit arch...maybe */
	if (ent->addr < (unsigned long) __va(0))
		goto free_out;

	/* cut not-mapped area. ....from ppc-32 code. */
	if (ULONG_MAX - ent->addr < ent->size)
		ent->size = ULONG_MAX - ent->addr;

	/* cut when vmalloc() area is higher than direct-map area */
	if (VMALLOC_START > (unsigned long)__va(0)) {
		if (ent->addr > VMALLOC_START)
			goto free_out;
		if (VMALLOC_START - ent->addr < ent->size)
			ent->size = VMALLOC_START - ent->addr;
	}

	ent->type = KCORE_RAM;
	list_add_tail(&ent->list, head);
236 237 238 239 240 241

	if (!get_sparsemem_vmemmap_info(ent, head)) {
		list_del(&ent->list);
		goto free_out;
	}

242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
	return 0;
free_out:
	kfree(ent);
	return 1;
}

static int kcore_update_ram(void)
{
	int nid, ret;
	unsigned long end_pfn;
	LIST_HEAD(head);

	/* Not inialized....update now */
	/* find out "max pfn" */
	end_pfn = 0;
257
	for_each_node_state(nid, N_MEMORY) {
258
		unsigned long node_end;
259
		node_end = node_end_pfn(nid);
260 261 262 263 264 265 266 267 268 269 270 271 272
		if (end_pfn < node_end)
			end_pfn = node_end;
	}
	/* scan 0 to max_pfn */
	ret = walk_system_ram_range(0, end_pfn, &head, kclist_add_private);
	if (ret) {
		free_kclist_ents(&head);
		return -ENOMEM;
	}
	__kcore_update_ram(&head);
	return ret;
}
#endif /* CONFIG_HIGHMEM */
L
Linus Torvalds 已提交
273 274 275 276 277 278 279 280 281 282

/*****************************************************************************/
/*
 * determine size of ELF note
 */
static int notesize(struct memelfnote *en)
{
	int sz;

	sz = sizeof(struct elf_note);
283
	sz += roundup((strlen(en->name) + 1), 4);
L
Linus Torvalds 已提交
284 285 286 287 288 289 290 291 292 293 294 295 296 297 298
	sz += roundup(en->datasz, 4);

	return sz;
} /* end notesize() */

/*****************************************************************************/
/*
 * store a note in the header buffer
 */
static char *storenote(struct memelfnote *men, char *bufp)
{
	struct elf_note en;

#define DUMP_WRITE(addr,nr) do { memcpy(bufp,addr,nr); bufp += nr; } while(0)

299
	en.n_namesz = strlen(men->name) + 1;
L
Linus Torvalds 已提交
300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
	en.n_descsz = men->datasz;
	en.n_type = men->type;

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

	/* XXX - cast from long long to long to avoid need for libgcc.a */
	bufp = (char*) roundup((unsigned long)bufp,4);
	DUMP_WRITE(men->data, men->datasz);
	bufp = (char*) roundup((unsigned long)bufp,4);

#undef DUMP_WRITE

	return bufp;
} /* end storenote() */

/*
 * store an ELF coredump header in the supplied buffer
 * nphdr is the number of elf_phdr to insert
 */
static void elf_kcore_store_hdr(char *bufp, int nphdr, int dataoff)
{
	struct elf_prstatus prstatus;	/* NT_PRSTATUS */
	struct elf_prpsinfo prpsinfo;	/* NT_PRPSINFO */
	struct elf_phdr *nhdr, *phdr;
	struct elfhdr *elf;
	struct memelfnote notes[3];
	off_t offset = 0;
	struct kcore_list *m;

	/* setup ELF header */
	elf = (struct elfhdr *) bufp;
	bufp += sizeof(struct elfhdr);
	offset += sizeof(struct elfhdr);
	memcpy(elf->e_ident, ELFMAG, SELFMAG);
	elf->e_ident[EI_CLASS]	= ELF_CLASS;
	elf->e_ident[EI_DATA]	= ELF_DATA;
	elf->e_ident[EI_VERSION]= EV_CURRENT;
	elf->e_ident[EI_OSABI] = ELF_OSABI;
	memset(elf->e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD);
	elf->e_type	= ET_CORE;
	elf->e_machine	= ELF_ARCH;
	elf->e_version	= EV_CURRENT;
	elf->e_entry	= 0;
	elf->e_phoff	= sizeof(struct elfhdr);
	elf->e_shoff	= 0;
346
	elf->e_flags	= ELF_CORE_EFLAGS;
L
Linus Torvalds 已提交
347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
	elf->e_ehsize	= sizeof(struct elfhdr);
	elf->e_phentsize= sizeof(struct elf_phdr);
	elf->e_phnum	= nphdr;
	elf->e_shentsize= 0;
	elf->e_shnum	= 0;
	elf->e_shstrndx	= 0;

	/* setup ELF PT_NOTE program header */
	nhdr = (struct elf_phdr *) bufp;
	bufp += sizeof(struct elf_phdr);
	offset += sizeof(struct elf_phdr);
	nhdr->p_type	= PT_NOTE;
	nhdr->p_offset	= 0;
	nhdr->p_vaddr	= 0;
	nhdr->p_paddr	= 0;
	nhdr->p_filesz	= 0;
	nhdr->p_memsz	= 0;
	nhdr->p_flags	= 0;
	nhdr->p_align	= 0;

	/* setup ELF PT_LOAD program header for every area */
368
	list_for_each_entry(m, &kclist_head, list) {
L
Linus Torvalds 已提交
369 370 371 372 373 374 375 376
		phdr = (struct elf_phdr *) bufp;
		bufp += sizeof(struct elf_phdr);
		offset += sizeof(struct elf_phdr);

		phdr->p_type	= PT_LOAD;
		phdr->p_flags	= PF_R|PF_W|PF_X;
		phdr->p_offset	= kc_vaddr_to_offset(m->addr) + dataoff;
		phdr->p_vaddr	= (size_t)m->addr;
377 378 379 380
		if (m->type == KCORE_RAM || m->type == KCORE_TEXT)
			phdr->p_paddr	= __pa(m->addr);
		else
			phdr->p_paddr	= (elf_addr_t)-1;
L
Linus Torvalds 已提交
381 382 383 384 385 386 387 388 389 390 391
		phdr->p_filesz	= phdr->p_memsz	= m->size;
		phdr->p_align	= PAGE_SIZE;
	}

	/*
	 * Set up the notes in similar form to SVR4 core dumps made
	 * with info from their /proc.
	 */
	nhdr->p_offset	= offset;

	/* set up the process status */
392
	notes[0].name = CORE_STR;
L
Linus Torvalds 已提交
393 394 395 396 397 398 399 400 401 402
	notes[0].type = NT_PRSTATUS;
	notes[0].datasz = sizeof(struct elf_prstatus);
	notes[0].data = &prstatus;

	memset(&prstatus, 0, sizeof(struct elf_prstatus));

	nhdr->p_filesz	= notesize(&notes[0]);
	bufp = storenote(&notes[0], bufp);

	/* set up the process info */
403
	notes[1].name	= CORE_STR;
L
Linus Torvalds 已提交
404 405 406 407 408 409 410 411 412 413
	notes[1].type	= NT_PRPSINFO;
	notes[1].datasz	= sizeof(struct elf_prpsinfo);
	notes[1].data	= &prpsinfo;

	memset(&prpsinfo, 0, sizeof(struct elf_prpsinfo));
	prpsinfo.pr_state	= 0;
	prpsinfo.pr_sname	= 'R';
	prpsinfo.pr_zomb	= 0;

	strcpy(prpsinfo.pr_fname, "vmlinux");
414
	strlcpy(prpsinfo.pr_psargs, saved_command_line, sizeof(prpsinfo.pr_psargs));
L
Linus Torvalds 已提交
415 416 417 418 419

	nhdr->p_filesz	+= notesize(&notes[1]);
	bufp = storenote(&notes[1], bufp);

	/* set up the task structure */
420
	notes[2].name	= CORE_STR;
L
Linus Torvalds 已提交
421
	notes[2].type	= NT_TASKSTRUCT;
422
	notes[2].datasz	= arch_task_struct_size;
L
Linus Torvalds 已提交
423 424 425 426 427 428 429 430 431 432 433 434 435 436
	notes[2].data	= current;

	nhdr->p_filesz	+= notesize(&notes[2]);
	bufp = storenote(&notes[2], bufp);

} /* end elf_kcore_store_hdr() */

/*****************************************************************************/
/*
 * read from the ELF header and then kernel memory
 */
static ssize_t
read_kcore(struct file *file, char __user *buffer, size_t buflen, loff_t *fpos)
{
437
	char *buf = file->private_data;
L
Linus Torvalds 已提交
438 439 440 441 442 443 444
	ssize_t acc = 0;
	size_t size, tsz;
	size_t elf_buflen;
	int nphdr;
	unsigned long start;

	read_lock(&kclist_lock);
445 446
	size = get_kcore_size(&nphdr, &elf_buflen);

L
Linus Torvalds 已提交
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
	if (buflen == 0 || *fpos >= size) {
		read_unlock(&kclist_lock);
		return 0;
	}

	/* trim buflen to not go beyond EOF */
	if (buflen > size - *fpos)
		buflen = size - *fpos;

	/* construct an ELF core header if we'll need some of it */
	if (*fpos < elf_buflen) {
		char * elf_buf;

		tsz = elf_buflen - *fpos;
		if (buflen < tsz)
			tsz = buflen;
463
		elf_buf = kzalloc(elf_buflen, GFP_ATOMIC);
L
Linus Torvalds 已提交
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497
		if (!elf_buf) {
			read_unlock(&kclist_lock);
			return -ENOMEM;
		}
		elf_kcore_store_hdr(elf_buf, nphdr, elf_buflen);
		read_unlock(&kclist_lock);
		if (copy_to_user(buffer, elf_buf + *fpos, tsz)) {
			kfree(elf_buf);
			return -EFAULT;
		}
		kfree(elf_buf);
		buflen -= tsz;
		*fpos += tsz;
		buffer += tsz;
		acc += tsz;

		/* leave now if filled buffer already */
		if (buflen == 0)
			return acc;
	} else
		read_unlock(&kclist_lock);

	/*
	 * Check to see if our file offset matches with any of
	 * the addresses in the elf_phdr on our list.
	 */
	start = kc_offset_to_vaddr(*fpos - elf_buflen);
	if ((tsz = (PAGE_SIZE - (start & ~PAGE_MASK))) > buflen)
		tsz = buflen;
		
	while (buflen) {
		struct kcore_list *m;

		read_lock(&kclist_lock);
498
		list_for_each_entry(m, &kclist_head, list) {
L
Linus Torvalds 已提交
499 500 501 502 503
			if (start >= m->addr && start < (m->addr+m->size))
				break;
		}
		read_unlock(&kclist_lock);

D
Dan Carpenter 已提交
504
		if (&m->list == &kclist_head) {
L
Linus Torvalds 已提交
505 506
			if (clear_user(buffer, tsz))
				return -EFAULT;
507
		} else if (m->type == KCORE_VMALLOC) {
508
			vread(buf, (char *)start, tsz);
509
			/* we have to zero-fill user buffer even if no read */
510
			if (copy_to_user(buffer, buf, tsz))
L
Linus Torvalds 已提交
511 512 513 514 515
				return -EFAULT;
		} else {
			if (kern_addr_valid(start)) {
				unsigned long n;

516 517 518 519 520 521
				/*
				 * Using bounce buffer to bypass the
				 * hardened user copy kernel text checks.
				 */
				memcpy(buf, (char *) start, tsz);
				n = copy_to_user(buffer, buf, tsz);
L
Linus Torvalds 已提交
522
				/*
523
				 * We cannot distinguish between fault on source
L
Linus Torvalds 已提交
524 525 526 527 528 529
				 * and fault on destination. When this happens
				 * we clear too and hope it will trigger the
				 * EFAULT again.
				 */
				if (n) { 
					if (clear_user(buffer + tsz - n,
530
								n))
L
Linus Torvalds 已提交
531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547
						return -EFAULT;
				}
			} else {
				if (clear_user(buffer, tsz))
					return -EFAULT;
			}
		}
		buflen -= tsz;
		*fpos += tsz;
		buffer += tsz;
		acc += tsz;
		start += tsz;
		tsz = (buflen > PAGE_SIZE ? PAGE_SIZE : buflen);
	}

	return acc;
}
548

549 550 551 552 553

static int open_kcore(struct inode *inode, struct file *filp)
{
	if (!capable(CAP_SYS_RAWIO))
		return -EPERM;
554 555 556 557 558

	filp->private_data = kmalloc(PAGE_SIZE, GFP_KERNEL);
	if (!filp->private_data)
		return -ENOMEM;

559 560
	if (kcore_need_update)
		kcore_update_ram();
561
	if (i_size_read(inode) != proc_root_kcore->size) {
A
Al Viro 已提交
562
		inode_lock(inode);
563
		i_size_write(inode, proc_root_kcore->size);
A
Al Viro 已提交
564
		inode_unlock(inode);
565
	}
566 567 568
	return 0;
}

569 570 571 572 573
static int release_kcore(struct inode *inode, struct file *file)
{
	kfree(file->private_data);
	return 0;
}
574 575 576 577

static const struct file_operations proc_kcore_operations = {
	.read		= read_kcore,
	.open		= open_kcore,
578
	.release	= release_kcore,
D
Dave Anderson 已提交
579
	.llseek		= default_llseek,
580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
};

/* just remember that we have to update kcore */
static int __meminit kcore_callback(struct notifier_block *self,
				    unsigned long action, void *arg)
{
	switch (action) {
	case MEM_ONLINE:
	case MEM_OFFLINE:
		write_lock(&kclist_lock);
		kcore_need_update = 1;
		write_unlock(&kclist_lock);
	}
	return NOTIFY_OK;
}

596 597 598 599
static struct notifier_block kcore_callback_nb __meminitdata = {
	.notifier_call = kcore_callback,
	.priority = 0,
};
600

601 602
static struct kcore_list kcore_vmalloc;

603 604 605 606 607 608 609 610
#ifdef CONFIG_ARCH_PROC_KCORE_TEXT
static struct kcore_list kcore_text;
/*
 * If defined, special segment is used for mapping kernel text instead of
 * direct-map area. We need to create special TEXT section.
 */
static void __init proc_kcore_text_init(void)
{
W
Wu Fengguang 已提交
611
	kclist_add(&kcore_text, _text, _end - _text, KCORE_TEXT);
612 613 614 615 616 617 618
}
#else
static void __init proc_kcore_text_init(void)
{
}
#endif

619 620 621 622 623 624 625
#if defined(CONFIG_MODULES) && defined(MODULES_VADDR)
/*
 * MODULES_VADDR has no intersection with VMALLOC_ADDR.
 */
struct kcore_list kcore_modules;
static void __init add_modules_range(void)
{
626 627
	if (MODULES_VADDR != VMALLOC_START && MODULES_END != VMALLOC_END) {
		kclist_add(&kcore_modules, (void *)MODULES_VADDR,
628
			MODULES_END - MODULES_VADDR, KCORE_VMALLOC);
629
	}
630 631 632 633 634 635 636
}
#else
static void __init add_modules_range(void)
{
}
#endif

637 638
static int __init proc_kcore_init(void)
{
639 640
	proc_root_kcore = proc_create("kcore", S_IRUSR, NULL,
				      &proc_kcore_operations);
K
KAMEZAWA Hiroyuki 已提交
641
	if (!proc_root_kcore) {
A
Andrew Morton 已提交
642
		pr_err("couldn't create /proc/kcore\n");
K
KAMEZAWA Hiroyuki 已提交
643 644
		return 0; /* Always returns 0. */
	}
645
	/* Store text area if it's special */
646
	proc_kcore_text_init();
647
	/* Store vmalloc area */
648 649
	kclist_add(&kcore_vmalloc, (void *)VMALLOC_START,
		VMALLOC_END - VMALLOC_START, KCORE_VMALLOC);
650
	add_modules_range();
651 652
	/* Store direct-map area from physical memory map */
	kcore_update_ram();
653
	register_hotmemory_notifier(&kcore_callback_nb);
654

655 656
	return 0;
}
657
fs_initcall(proc_kcore_init);