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 <asm/sections.h>
32
#include "internal.h"
L
Linus Torvalds 已提交
33

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

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

40 41
static struct proc_dir_entry *proc_root_kcore;

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

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

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

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

	write_lock(&kclist_lock);
71
	list_add_tail(&new->list, &kclist_head);
L
Linus Torvalds 已提交
72 73 74 75 76 77 78 79 80 81 82
	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;

83
	list_for_each_entry(m, &kclist_head, list) {
L
Linus Torvalds 已提交
84 85 86 87 88 89 90
		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) + 
91 92 93 94
			3 * ((sizeof(struct elf_note)) +
			     roundup(sizeof(CORE_STR), 4)) +
			roundup(sizeof(struct elf_prstatus), 4) +
			roundup(sizeof(struct elf_prpsinfo), 4) +
95
			roundup(arch_task_struct_size, 4);
L
Linus Torvalds 已提交
96 97 98 99
	*elf_buflen = PAGE_ALIGN(*elf_buflen);
	return size + *elf_buflen;
}

100 101 102 103 104 105 106 107 108 109
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);
	}
}
/*
110
 * Replace all KCORE_RAM/KCORE_VMEMMAP information with passed list.
111 112 113
 */
static void __kcore_update_ram(struct list_head *list)
{
114 115
	int nphdr;
	size_t size;
116 117 118 119 120 121
	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) {
122 123
			if (pos->type == KCORE_RAM
				|| pos->type == KCORE_VMEMMAP)
124 125 126 127 128 129
				list_move(&pos->list, &garbage);
		}
		list_splice_tail(list, &kclist_head);
	} else
		list_splice(list, &garbage);
	kcore_need_update = 0;
130
	proc_root_kcore->size = get_kcore_size(&nphdr, &size);
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
	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 */

162 163
#ifdef CONFIG_SPARSEMEM_VMEMMAP
/* calculate vmemmap's address from given system ram pfn and register it */
164 165
static int
get_sparsemem_vmemmap_info(struct kcore_list *ent, struct list_head *head)
166 167 168 169 170 171 172 173 174
{
	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;
175
	end = PAGE_ALIGN(end);
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196
	/* 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
197 198
static int
get_sparsemem_vmemmap_info(struct kcore_list *ent, struct list_head *head)
199 200 201 202 203 204
{
	return 1;
}

#endif

205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
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);
235 236 237 238 239 240

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

241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
	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;
256
	for_each_node_state(nid, N_MEMORY) {
257
		unsigned long node_end;
258
		node_end = node_end_pfn(nid);
259 260 261 262 263 264 265 266 267 268 269 270 271
		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 已提交
272 273 274 275 276 277 278 279 280 281

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

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

298
	en.n_namesz = strlen(men->name) + 1;
L
Linus Torvalds 已提交
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
	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;
345
	elf->e_flags	= ELF_CORE_EFLAGS;
L
Linus Torvalds 已提交
346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
	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 */
367
	list_for_each_entry(m, &kclist_head, list) {
L
Linus Torvalds 已提交
368 369 370 371 372 373 374 375
		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;
376 377 378 379
		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 已提交
380 381 382 383 384 385 386 387 388 389 390
		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 */
391
	notes[0].name = CORE_STR;
L
Linus Torvalds 已提交
392 393 394 395 396 397 398 399 400 401
	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 */
402
	notes[1].name	= CORE_STR;
L
Linus Torvalds 已提交
403 404 405 406 407 408 409 410 411 412
	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");
413
	strlcpy(prpsinfo.pr_psargs, saved_command_line, sizeof(prpsinfo.pr_psargs));
L
Linus Torvalds 已提交
414 415 416 417 418

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

	/* set up the task structure */
419
	notes[2].name	= CORE_STR;
L
Linus Torvalds 已提交
420
	notes[2].type	= NT_TASKSTRUCT;
421
	notes[2].datasz	= arch_task_struct_size;
L
Linus Torvalds 已提交
422 423 424 425 426 427 428 429 430 431 432 433 434 435
	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)
{
436
	char *buf = file->private_data;
L
Linus Torvalds 已提交
437 438 439 440 441 442 443
	ssize_t acc = 0;
	size_t size, tsz;
	size_t elf_buflen;
	int nphdr;
	unsigned long start;

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

L
Linus Torvalds 已提交
446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461
	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;
462
		elf_buf = kzalloc(elf_buflen, GFP_ATOMIC);
L
Linus Torvalds 已提交
463 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
		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);
497
		list_for_each_entry(m, &kclist_head, list) {
L
Linus Torvalds 已提交
498 499 500 501 502
			if (start >= m->addr && start < (m->addr+m->size))
				break;
		}
		read_unlock(&kclist_lock);

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

515 516 517 518 519 520
				/*
				 * 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 已提交
521
				/*
522
				 * We cannot distinguish between fault on source
L
Linus Torvalds 已提交
523 524 525 526 527 528
				 * 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,
529
								n))
L
Linus Torvalds 已提交
530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546
						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;
}
547

548 549 550 551 552

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

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

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

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

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

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

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

600 601
static struct kcore_list kcore_vmalloc;

602 603 604 605 606 607 608 609
#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 已提交
610
	kclist_add(&kcore_text, _text, _end - _text, KCORE_TEXT);
611 612 613 614 615 616 617
}
#else
static void __init proc_kcore_text_init(void)
{
}
#endif

618 619 620 621 622 623 624
#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)
{
625 626
	if (MODULES_VADDR != VMALLOC_START && MODULES_END != VMALLOC_END) {
		kclist_add(&kcore_modules, (void *)MODULES_VADDR,
627
			MODULES_END - MODULES_VADDR, KCORE_VMALLOC);
628
	}
629 630 631 632 633 634 635
}
#else
static void __init add_modules_range(void)
{
}
#endif

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

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