mem.c 20.9 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 *  linux/drivers/char/mem.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  Added devfs support. 
 *    Jan-11-1998, C. Scott Ananian <cananian@alumni.princeton.edu>
 *  Shared /dev/zero mmaping support, Feb 2000, Kanoj Sarcar <kanoj@sgi.com>
 */

#include <linux/mm.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/mman.h>
#include <linux/random.h>
#include <linux/init.h>
#include <linux/raw.h>
#include <linux/tty.h>
#include <linux/capability.h>
#include <linux/ptrace.h>
#include <linux/device.h>
23 24
#include <linux/highmem.h>
#include <linux/crash_dump.h>
L
Linus Torvalds 已提交
25
#include <linux/backing-dev.h>
26
#include <linux/bootmem.h>
27
#include <linux/splice.h>
28
#include <linux/pfn.h>
29
#include <linux/smp_lock.h>
L
Linus Torvalds 已提交
30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

#include <asm/uaccess.h>
#include <asm/io.h>

#ifdef CONFIG_IA64
# include <linux/efi.h>
#endif

/*
 * Architectures vary in how they handle caching for addresses
 * outside of main memory.
 *
 */
static inline int uncached_access(struct file *file, unsigned long addr)
{
45
#if defined(CONFIG_IA64)
L
Linus Torvalds 已提交
46 47 48 49
	/*
	 * On ia64, we ignore O_SYNC because we cannot tolerate memory attribute aliases.
	 */
	return !(efi_mem_attributes(addr) & EFI_MEMORY_WB);
50 51 52 53 54 55 56
#elif defined(CONFIG_MIPS)
	{
		extern int __uncached_access(struct file *file,
					     unsigned long addr);

		return __uncached_access(file, addr);
	}
L
Linus Torvalds 已提交
57 58 59 60 61 62 63 64 65 66 67 68
#else
	/*
	 * Accessing memory above the top the kernel knows about or through a file pointer
	 * that was marked O_SYNC will be done non-cached.
	 */
	if (file->f_flags & O_SYNC)
		return 1;
	return addr >= __pa(high_memory);
#endif
}

#ifndef ARCH_HAS_VALID_PHYS_ADDR_RANGE
69
static inline int valid_phys_addr_range(unsigned long addr, size_t count)
L
Linus Torvalds 已提交
70
{
71
	if (addr + count > __pa(high_memory))
L
Linus Torvalds 已提交
72 73 74 75
		return 0;

	return 1;
}
76

77
static inline int valid_mmap_phys_addr_range(unsigned long pfn, size_t size)
78 79 80
{
	return 1;
}
L
Linus Torvalds 已提交
81 82
#endif

83
#ifdef CONFIG_STRICT_DEVMEM
84
static inline int range_is_allowed(unsigned long pfn, unsigned long size)
85
{
86 87 88 89 90 91 92 93
	u64 from = ((u64)pfn) << PAGE_SHIFT;
	u64 to = from + size;
	u64 cursor = from;

	while (cursor < to) {
		if (!devmem_is_allowed(pfn)) {
			printk(KERN_INFO
		"Program %s tried to access /dev/mem between %Lx->%Lx.\n",
94 95 96
				current->comm, from, to);
			return 0;
		}
97 98
		cursor += PAGE_SIZE;
		pfn++;
99 100 101 102
	}
	return 1;
}
#else
103
static inline int range_is_allowed(unsigned long pfn, unsigned long size)
104 105 106 107 108
{
	return 1;
}
#endif

109 110 111 112
void __attribute__((weak)) unxlate_dev_mem_ptr(unsigned long phys, void *addr)
{
}

L
Linus Torvalds 已提交
113 114 115 116 117 118 119 120 121 122 123
/*
 * This funcion reads the *physical* memory. The f_pos points directly to the 
 * memory location. 
 */
static ssize_t read_mem(struct file * file, char __user * buf,
			size_t count, loff_t *ppos)
{
	unsigned long p = *ppos;
	ssize_t read, sz;
	char *ptr;

124
	if (!valid_phys_addr_range(p, count))
L
Linus Torvalds 已提交
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
		return -EFAULT;
	read = 0;
#ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED
	/* we don't have page 0 mapped on sparc and m68k.. */
	if (p < PAGE_SIZE) {
		sz = PAGE_SIZE - p;
		if (sz > count) 
			sz = count; 
		if (sz > 0) {
			if (clear_user(buf, sz))
				return -EFAULT;
			buf += sz; 
			p += sz; 
			count -= sz; 
			read += sz; 
		}
	}
#endif

	while (count > 0) {
		/*
		 * Handle first page in case it's not aligned
		 */
		if (-p & (PAGE_SIZE - 1))
			sz = -p & (PAGE_SIZE - 1);
		else
			sz = PAGE_SIZE;

		sz = min_t(unsigned long, sz, count);

155 156 157
		if (!range_is_allowed(p >> PAGE_SHIFT, count))
			return -EPERM;

L
Linus Torvalds 已提交
158 159 160 161 162 163
		/*
		 * On ia64 if a page has been mapped somewhere as
		 * uncached, then it must also be accessed uncached
		 * by the kernel or data corruption may occur
		 */
		ptr = xlate_dev_mem_ptr(p);
164 165
		if (!ptr)
			return -EFAULT;
L
Linus Torvalds 已提交
166

167 168
		if (copy_to_user(buf, ptr, sz)) {
			unxlate_dev_mem_ptr(p, ptr);
L
Linus Torvalds 已提交
169
			return -EFAULT;
170 171 172 173
		}

		unxlate_dev_mem_ptr(p, ptr);

L
Linus Torvalds 已提交
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
		buf += sz;
		p += sz;
		count -= sz;
		read += sz;
	}

	*ppos += read;
	return read;
}

static ssize_t write_mem(struct file * file, const char __user * buf, 
			 size_t count, loff_t *ppos)
{
	unsigned long p = *ppos;
	ssize_t written, sz;
	unsigned long copied;
	void *ptr;

192
	if (!valid_phys_addr_range(p, count))
L
Linus Torvalds 已提交
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
		return -EFAULT;

	written = 0;

#ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED
	/* we don't have page 0 mapped on sparc and m68k.. */
	if (p < PAGE_SIZE) {
		unsigned long sz = PAGE_SIZE - p;
		if (sz > count)
			sz = count;
		/* Hmm. Do something? */
		buf += sz;
		p += sz;
		count -= sz;
		written += sz;
	}
#endif

	while (count > 0) {
		/*
		 * Handle first page in case it's not aligned
		 */
		if (-p & (PAGE_SIZE - 1))
			sz = -p & (PAGE_SIZE - 1);
		else
			sz = PAGE_SIZE;

		sz = min_t(unsigned long, sz, count);

222 223 224
		if (!range_is_allowed(p >> PAGE_SHIFT, sz))
			return -EPERM;

L
Linus Torvalds 已提交
225 226 227 228 229 230
		/*
		 * On ia64 if a page has been mapped somewhere as
		 * uncached, then it must also be accessed uncached
		 * by the kernel or data corruption may occur
		 */
		ptr = xlate_dev_mem_ptr(p);
231 232 233 234 235
		if (!ptr) {
			if (written)
				break;
			return -EFAULT;
		}
L
Linus Torvalds 已提交
236 237 238

		copied = copy_from_user(ptr, buf, sz);
		if (copied) {
239
			written += sz - copied;
240
			unxlate_dev_mem_ptr(p, ptr);
241 242
			if (written)
				break;
L
Linus Torvalds 已提交
243 244
			return -EFAULT;
		}
245 246 247

		unxlate_dev_mem_ptr(p, ptr);

L
Linus Torvalds 已提交
248 249 250 251 252 253 254 255 256 257
		buf += sz;
		p += sz;
		count -= sz;
		written += sz;
	}

	*ppos += written;
	return written;
}

258 259 260 261 262 263
int __attribute__((weak)) phys_mem_access_prot_allowed(struct file *file,
	unsigned long pfn, unsigned long size, pgprot_t *vma_prot)
{
	return 1;
}

264 265 266 267 268 269 270 271 272 273 274 275 276 277
#ifndef __HAVE_PHYS_MEM_ACCESS_PROT
static pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
				     unsigned long size, pgprot_t vma_prot)
{
#ifdef pgprot_noncached
	unsigned long offset = pfn << PAGE_SHIFT;

	if (uncached_access(file, offset))
		return pgprot_noncached(vma_prot);
#endif
	return vma_prot;
}
#endif

278 279 280 281 282 283 284 285 286
#ifndef CONFIG_MMU
static unsigned long get_unmapped_area_mem(struct file *file,
					   unsigned long addr,
					   unsigned long len,
					   unsigned long pgoff,
					   unsigned long flags)
{
	if (!valid_mmap_phys_addr_range(pgoff, len))
		return (unsigned long) -EINVAL;
287
	return pgoff << PAGE_SHIFT;
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
}

/* can't do an in-place private mapping if there's no MMU */
static inline int private_mapping_ok(struct vm_area_struct *vma)
{
	return vma->vm_flags & VM_MAYSHARE;
}
#else
#define get_unmapped_area_mem	NULL

static inline int private_mapping_ok(struct vm_area_struct *vma)
{
	return 1;
}
#endif

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
void __attribute__((weak))
map_devmem(unsigned long pfn, unsigned long len, pgprot_t prot)
{
	/* nothing. architectures can override. */
}

void __attribute__((weak))
unmap_devmem(unsigned long pfn, unsigned long len, pgprot_t prot)
{
	/* nothing. architectures can override. */
}

static void mmap_mem_open(struct vm_area_struct *vma)
{
	map_devmem(vma->vm_pgoff,  vma->vm_end - vma->vm_start,
			vma->vm_page_prot);
}

static void mmap_mem_close(struct vm_area_struct *vma)
{
	unmap_devmem(vma->vm_pgoff,  vma->vm_end - vma->vm_start,
			vma->vm_page_prot);
}

static struct vm_operations_struct mmap_mem_ops = {
	.open  = mmap_mem_open,
	.close = mmap_mem_close
};

L
Linus Torvalds 已提交
333 334
static int mmap_mem(struct file * file, struct vm_area_struct * vma)
{
335 336
	size_t size = vma->vm_end - vma->vm_start;

337
	if (!valid_mmap_phys_addr_range(vma->vm_pgoff, size))
338 339
		return -EINVAL;

340 341 342
	if (!private_mapping_ok(vma))
		return -ENOSYS;

343 344 345
	if (!range_is_allowed(vma->vm_pgoff, size))
		return -EPERM;

346 347 348 349
	if (!phys_mem_access_prot_allowed(file, vma->vm_pgoff, size,
						&vma->vm_page_prot))
		return -EINVAL;

350
	vma->vm_page_prot = phys_mem_access_prot(file, vma->vm_pgoff,
351
						 size,
L
Linus Torvalds 已提交
352 353
						 vma->vm_page_prot);

354 355
	vma->vm_ops = &mmap_mem_ops;

L
Linus Torvalds 已提交
356 357 358 359
	/* Remap-pfn-range will mark the range VM_IO and VM_RESERVED */
	if (remap_pfn_range(vma,
			    vma->vm_start,
			    vma->vm_pgoff,
360
			    size,
361 362
			    vma->vm_page_prot)) {
		unmap_devmem(vma->vm_pgoff, size, vma->vm_page_prot);
L
Linus Torvalds 已提交
363
		return -EAGAIN;
364
	}
L
Linus Torvalds 已提交
365 366 367
	return 0;
}

368
#ifdef CONFIG_DEVKMEM
L
Linus Torvalds 已提交
369 370
static int mmap_kmem(struct file * file, struct vm_area_struct * vma)
{
L
Linus Torvalds 已提交
371 372
	unsigned long pfn;

373 374
	/* Turn a kernel-virtual address into a physical page frame */
	pfn = __pa((u64)vma->vm_pgoff << PAGE_SHIFT) >> PAGE_SHIFT;
L
Linus Torvalds 已提交
375

L
Linus Torvalds 已提交
376 377 378 379 380 381 382
	/*
	 * RED-PEN: on some architectures there is more mapped memory
	 * than available in mem_map which pfn_valid checks
	 * for. Perhaps should add a new macro here.
	 *
	 * RED-PEN: vmalloc is not supported right now.
	 */
L
Linus Torvalds 已提交
383
	if (!pfn_valid(pfn))
L
Linus Torvalds 已提交
384
		return -EIO;
L
Linus Torvalds 已提交
385 386

	vma->vm_pgoff = pfn;
L
Linus Torvalds 已提交
387 388
	return mmap_mem(file, vma);
}
389
#endif
L
Linus Torvalds 已提交
390

391 392 393 394
#ifdef CONFIG_CRASH_DUMP
/*
 * Read memory corresponding to the old kernel.
 */
395
static ssize_t read_oldmem(struct file *file, char __user *buf,
396 397
				size_t count, loff_t *ppos)
{
398 399 400
	unsigned long pfn, offset;
	size_t read = 0, csize;
	int rc = 0;
401

M
Maneesh Soni 已提交
402
	while (count) {
403
		pfn = *ppos / PAGE_SIZE;
404 405
		if (pfn > saved_max_pfn)
			return read;
406

407 408 409 410 411
		offset = (unsigned long)(*ppos % PAGE_SIZE);
		if (count > PAGE_SIZE - offset)
			csize = PAGE_SIZE - offset;
		else
			csize = count;
412

413 414 415
		rc = copy_oldmem_page(pfn, buf, csize, offset, 1);
		if (rc < 0)
			return rc;
416 417 418 419 420 421 422 423 424
		buf += csize;
		*ppos += csize;
		read += csize;
		count -= csize;
	}
	return read;
}
#endif

L
Linus Torvalds 已提交
425 426 427
extern long vread(char *buf, char *addr, unsigned long count);
extern long vwrite(char *buf, char *addr, unsigned long count);

428
#ifdef CONFIG_DEVKMEM
L
Linus Torvalds 已提交
429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 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 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
/*
 * This function reads the *virtual* memory as seen by the kernel.
 */
static ssize_t read_kmem(struct file *file, char __user *buf, 
			 size_t count, loff_t *ppos)
{
	unsigned long p = *ppos;
	ssize_t low_count, read, sz;
	char * kbuf; /* k-addr because vread() takes vmlist_lock rwlock */

	read = 0;
	if (p < (unsigned long) high_memory) {
		low_count = count;
		if (count > (unsigned long) high_memory - p)
			low_count = (unsigned long) high_memory - p;

#ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED
		/* we don't have page 0 mapped on sparc and m68k.. */
		if (p < PAGE_SIZE && low_count > 0) {
			size_t tmp = PAGE_SIZE - p;
			if (tmp > low_count) tmp = low_count;
			if (clear_user(buf, tmp))
				return -EFAULT;
			buf += tmp;
			p += tmp;
			read += tmp;
			low_count -= tmp;
			count -= tmp;
		}
#endif
		while (low_count > 0) {
			/*
			 * Handle first page in case it's not aligned
			 */
			if (-p & (PAGE_SIZE - 1))
				sz = -p & (PAGE_SIZE - 1);
			else
				sz = PAGE_SIZE;

			sz = min_t(unsigned long, sz, low_count);

			/*
			 * On ia64 if a page has been mapped somewhere as
			 * uncached, then it must also be accessed uncached
			 * by the kernel or data corruption may occur
			 */
			kbuf = xlate_dev_kmem_ptr((char *)p);

			if (copy_to_user(buf, kbuf, sz))
				return -EFAULT;
			buf += sz;
			p += sz;
			read += sz;
			low_count -= sz;
			count -= sz;
		}
	}

	if (count > 0) {
		kbuf = (char *)__get_free_page(GFP_KERNEL);
		if (!kbuf)
			return -ENOMEM;
		while (count > 0) {
			int len = count;

			if (len > PAGE_SIZE)
				len = PAGE_SIZE;
			len = vread(kbuf, (char *)p, len);
			if (!len)
				break;
			if (copy_to_user(buf, kbuf, len)) {
				free_page((unsigned long)kbuf);
				return -EFAULT;
			}
			count -= len;
			buf += len;
			read += len;
			p += len;
		}
		free_page((unsigned long)kbuf);
	}
 	*ppos = p;
 	return read;
}


static inline ssize_t
do_write_kmem(void *p, unsigned long realp, const char __user * buf,
	      size_t count, loff_t *ppos)
{
	ssize_t written, sz;
	unsigned long copied;

	written = 0;
#ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED
	/* we don't have page 0 mapped on sparc and m68k.. */
	if (realp < PAGE_SIZE) {
		unsigned long sz = PAGE_SIZE - realp;
		if (sz > count)
			sz = count;
		/* Hmm. Do something? */
		buf += sz;
		p += sz;
		realp += sz;
		count -= sz;
		written += sz;
	}
#endif

	while (count > 0) {
		char *ptr;
		/*
		 * Handle first page in case it's not aligned
		 */
		if (-realp & (PAGE_SIZE - 1))
			sz = -realp & (PAGE_SIZE - 1);
		else
			sz = PAGE_SIZE;

		sz = min_t(unsigned long, sz, count);

		/*
		 * On ia64 if a page has been mapped somewhere as
		 * uncached, then it must also be accessed uncached
		 * by the kernel or data corruption may occur
		 */
		ptr = xlate_dev_kmem_ptr(p);

		copied = copy_from_user(ptr, buf, sz);
		if (copied) {
559 560 561
			written += sz - copied;
			if (written)
				break;
L
Linus Torvalds 已提交
562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614
			return -EFAULT;
		}
		buf += sz;
		p += sz;
		realp += sz;
		count -= sz;
		written += sz;
	}

	*ppos += written;
	return written;
}


/*
 * This function writes to the *virtual* memory as seen by the kernel.
 */
static ssize_t write_kmem(struct file * file, const char __user * buf, 
			  size_t count, loff_t *ppos)
{
	unsigned long p = *ppos;
	ssize_t wrote = 0;
	ssize_t virtr = 0;
	ssize_t written;
	char * kbuf; /* k-addr because vwrite() takes vmlist_lock rwlock */

	if (p < (unsigned long) high_memory) {

		wrote = count;
		if (count > (unsigned long) high_memory - p)
			wrote = (unsigned long) high_memory - p;

		written = do_write_kmem((void*)p, p, buf, wrote, ppos);
		if (written != wrote)
			return written;
		wrote = written;
		p += wrote;
		buf += wrote;
		count -= wrote;
	}

	if (count > 0) {
		kbuf = (char *)__get_free_page(GFP_KERNEL);
		if (!kbuf)
			return wrote ? wrote : -ENOMEM;
		while (count > 0) {
			int len = count;

			if (len > PAGE_SIZE)
				len = PAGE_SIZE;
			if (len) {
				written = copy_from_user(kbuf, buf, len);
				if (written) {
615 616
					if (wrote + virtr)
						break;
L
Linus Torvalds 已提交
617
					free_page((unsigned long)kbuf);
618
					return -EFAULT;
L
Linus Torvalds 已提交
619 620 621 622 623 624 625 626 627 628 629 630 631 632
				}
			}
			len = vwrite(kbuf, (char *)p, len);
			count -= len;
			buf += len;
			virtr += len;
			p += len;
		}
		free_page((unsigned long)kbuf);
	}

 	*ppos = p;
 	return virtr + wrote;
}
633
#endif
L
Linus Torvalds 已提交
634

635
#ifdef CONFIG_DEVPORT
L
Linus Torvalds 已提交
636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663
static ssize_t read_port(struct file * file, char __user * buf,
			 size_t count, loff_t *ppos)
{
	unsigned long i = *ppos;
	char __user *tmp = buf;

	if (!access_ok(VERIFY_WRITE, buf, count))
		return -EFAULT; 
	while (count-- > 0 && i < 65536) {
		if (__put_user(inb(i),tmp) < 0) 
			return -EFAULT;  
		i++;
		tmp++;
	}
	*ppos = i;
	return tmp-buf;
}

static ssize_t write_port(struct file * file, const char __user * buf,
			  size_t count, loff_t *ppos)
{
	unsigned long i = *ppos;
	const char __user * tmp = buf;

	if (!access_ok(VERIFY_READ,buf,count))
		return -EFAULT;
	while (count-- > 0 && i < 65536) {
		char c;
664 665 666
		if (__get_user(c, tmp)) {
			if (tmp > buf)
				break;
L
Linus Torvalds 已提交
667
			return -EFAULT; 
668
		}
L
Linus Torvalds 已提交
669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
		outb(c,i);
		i++;
		tmp++;
	}
	*ppos = i;
	return tmp-buf;
}
#endif

static ssize_t read_null(struct file * file, char __user * buf,
			 size_t count, loff_t *ppos)
{
	return 0;
}

static ssize_t write_null(struct file * file, const char __user * buf,
			  size_t count, loff_t *ppos)
{
	return count;
}

690 691 692 693 694 695 696 697 698 699 700 701
static int pipe_to_null(struct pipe_inode_info *info, struct pipe_buffer *buf,
			struct splice_desc *sd)
{
	return sd->len;
}

static ssize_t splice_write_null(struct pipe_inode_info *pipe,struct file *out,
				 loff_t *ppos, size_t len, unsigned int flags)
{
	return splice_from_pipe(pipe, out, ppos, len, flags, pipe_to_null);
}

L
Linus Torvalds 已提交
702 703 704
static ssize_t read_zero(struct file * file, char __user * buf, 
			 size_t count, loff_t *ppos)
{
N
Nick Piggin 已提交
705
	size_t written;
L
Linus Torvalds 已提交
706 707 708 709 710 711 712

	if (!count)
		return 0;

	if (!access_ok(VERIFY_WRITE, buf, count))
		return -EFAULT;

N
Nick Piggin 已提交
713 714 715 716
	written = 0;
	while (count) {
		unsigned long unwritten;
		size_t chunk = count;
L
Linus Torvalds 已提交
717

N
Nick Piggin 已提交
718 719 720 721
		if (chunk > PAGE_SIZE)
			chunk = PAGE_SIZE;	/* Just for latency reasons */
		unwritten = clear_user(buf, chunk);
		written += chunk - unwritten;
L
Linus Torvalds 已提交
722
		if (unwritten)
N
Nick Piggin 已提交
723
			break;
L
Linus Torvalds 已提交
724
		buf += chunk;
N
Nick Piggin 已提交
725
		count -= chunk;
L
Linus Torvalds 已提交
726 727
		cond_resched();
	}
N
Nick Piggin 已提交
728
	return written ? written : -EFAULT;
L
Linus Torvalds 已提交
729 730 731 732
}

static int mmap_zero(struct file * file, struct vm_area_struct * vma)
{
N
Nick Piggin 已提交
733
#ifndef CONFIG_MMU
L
Linus Torvalds 已提交
734
	return -ENOSYS;
N
Nick Piggin 已提交
735 736 737 738
#endif
	if (vma->vm_flags & VM_SHARED)
		return shmem_zero_setup(vma);
	return 0;
L
Linus Torvalds 已提交
739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769
}

static ssize_t write_full(struct file * file, const char __user * buf,
			  size_t count, loff_t *ppos)
{
	return -ENOSPC;
}

/*
 * Special lseek() function for /dev/null and /dev/zero.  Most notably, you
 * can fopen() both devices with "a" now.  This was previously impossible.
 * -- SRB.
 */

static loff_t null_lseek(struct file * file, loff_t offset, int orig)
{
	return file->f_pos = 0;
}

/*
 * The memory devices use the full 32/64 bits of the offset, and so we cannot
 * check against negative addresses: they are ok. The return value is weird,
 * though, in that case (0).
 *
 * also note that seeking relative to the "end of file" isn't supported:
 * it has no meaning, so it returns -EINVAL.
 */
static loff_t memory_lseek(struct file * file, loff_t offset, int orig)
{
	loff_t ret;

770
	mutex_lock(&file->f_path.dentry->d_inode->i_mutex);
L
Linus Torvalds 已提交
771 772 773 774 775 776 777 778 779 780 781 782 783 784
	switch (orig) {
		case 0:
			file->f_pos = offset;
			ret = file->f_pos;
			force_successful_syscall_return();
			break;
		case 1:
			file->f_pos += offset;
			ret = file->f_pos;
			force_successful_syscall_return();
			break;
		default:
			ret = -EINVAL;
	}
785
	mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
L
Linus Torvalds 已提交
786 787 788 789 790 791 792 793 794 795 796 797 798 799
	return ret;
}

static int open_port(struct inode * inode, struct file * filp)
{
	return capable(CAP_SYS_RAWIO) ? 0 : -EPERM;
}

#define zero_lseek	null_lseek
#define full_lseek      null_lseek
#define write_zero	write_null
#define read_full       read_zero
#define open_mem	open_port
#define open_kmem	open_mem
800
#define open_oldmem	open_mem
L
Linus Torvalds 已提交
801

802
static const struct file_operations mem_fops = {
L
Linus Torvalds 已提交
803 804 805 806 807
	.llseek		= memory_lseek,
	.read		= read_mem,
	.write		= write_mem,
	.mmap		= mmap_mem,
	.open		= open_mem,
808
	.get_unmapped_area = get_unmapped_area_mem,
L
Linus Torvalds 已提交
809 810
};

811
#ifdef CONFIG_DEVKMEM
812
static const struct file_operations kmem_fops = {
L
Linus Torvalds 已提交
813 814 815 816 817
	.llseek		= memory_lseek,
	.read		= read_kmem,
	.write		= write_kmem,
	.mmap		= mmap_kmem,
	.open		= open_kmem,
818
	.get_unmapped_area = get_unmapped_area_mem,
L
Linus Torvalds 已提交
819
};
820
#endif
L
Linus Torvalds 已提交
821

822
static const struct file_operations null_fops = {
L
Linus Torvalds 已提交
823 824 825
	.llseek		= null_lseek,
	.read		= read_null,
	.write		= write_null,
826
	.splice_write	= splice_write_null,
L
Linus Torvalds 已提交
827 828
};

829
#ifdef CONFIG_DEVPORT
830
static const struct file_operations port_fops = {
L
Linus Torvalds 已提交
831 832 833 834 835 836 837
	.llseek		= memory_lseek,
	.read		= read_port,
	.write		= write_port,
	.open		= open_port,
};
#endif

838
static const struct file_operations zero_fops = {
L
Linus Torvalds 已提交
839 840 841 842 843 844
	.llseek		= zero_lseek,
	.read		= read_zero,
	.write		= write_zero,
	.mmap		= mmap_zero,
};

845 846 847 848
/*
 * capabilities for /dev/zero
 * - permits private mappings, "copies" are taken of the source of zeros
 */
L
Linus Torvalds 已提交
849 850 851 852
static struct backing_dev_info zero_bdi = {
	.capabilities	= BDI_CAP_MAP_COPY,
};

853
static const struct file_operations full_fops = {
L
Linus Torvalds 已提交
854 855 856 857 858
	.llseek		= full_lseek,
	.read		= read_full,
	.write		= write_full,
};

859
#ifdef CONFIG_CRASH_DUMP
860
static const struct file_operations oldmem_fops = {
861 862 863 864 865
	.read	= read_oldmem,
	.open	= open_oldmem,
};
#endif

L
Linus Torvalds 已提交
866 867 868 869
static ssize_t kmsg_write(struct file * file, const char __user * buf,
			  size_t count, loff_t *ppos)
{
	char *tmp;
870
	ssize_t ret;
L
Linus Torvalds 已提交
871 872 873 874 875 876 877 878

	tmp = kmalloc(count + 1, GFP_KERNEL);
	if (tmp == NULL)
		return -ENOMEM;
	ret = -EFAULT;
	if (!copy_from_user(tmp, buf, count)) {
		tmp[count] = 0;
		ret = printk("%s", tmp);
879 880 881
		if (ret > count)
			/* printk can add a prefix */
			ret = count;
L
Linus Torvalds 已提交
882 883 884 885 886
	}
	kfree(tmp);
	return ret;
}

887
static const struct file_operations kmsg_fops = {
L
Linus Torvalds 已提交
888 889 890 891 892
	.write =	kmsg_write,
};

static int memory_open(struct inode * inode, struct file * filp)
{
893 894 895
	int ret = 0;

	lock_kernel();
L
Linus Torvalds 已提交
896 897 898
	switch (iminor(inode)) {
		case 1:
			filp->f_op = &mem_fops;
899 900
			filp->f_mapping->backing_dev_info =
				&directly_mappable_cdev_bdi;
L
Linus Torvalds 已提交
901
			break;
902
#ifdef CONFIG_DEVKMEM
L
Linus Torvalds 已提交
903 904
		case 2:
			filp->f_op = &kmem_fops;
905 906
			filp->f_mapping->backing_dev_info =
				&directly_mappable_cdev_bdi;
L
Linus Torvalds 已提交
907
			break;
908
#endif
L
Linus Torvalds 已提交
909 910 911
		case 3:
			filp->f_op = &null_fops;
			break;
912
#ifdef CONFIG_DEVPORT
L
Linus Torvalds 已提交
913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932
		case 4:
			filp->f_op = &port_fops;
			break;
#endif
		case 5:
			filp->f_mapping->backing_dev_info = &zero_bdi;
			filp->f_op = &zero_fops;
			break;
		case 7:
			filp->f_op = &full_fops;
			break;
		case 8:
			filp->f_op = &random_fops;
			break;
		case 9:
			filp->f_op = &urandom_fops;
			break;
		case 11:
			filp->f_op = &kmsg_fops;
			break;
933 934 935 936 937
#ifdef CONFIG_CRASH_DUMP
		case 12:
			filp->f_op = &oldmem_fops;
			break;
#endif
L
Linus Torvalds 已提交
938
		default:
939
			unlock_kernel();
L
Linus Torvalds 已提交
940 941 942
			return -ENXIO;
	}
	if (filp->f_op && filp->f_op->open)
943 944 945
		ret = filp->f_op->open(inode,filp);
	unlock_kernel();
	return ret;
L
Linus Torvalds 已提交
946 947
}

948
static const struct file_operations memory_fops = {
L
Linus Torvalds 已提交
949 950 951 952 953 954 955
	.open		= memory_open,	/* just a selector for the real open */
};

static const struct {
	unsigned int		minor;
	char			*name;
	umode_t			mode;
956
	const struct file_operations	*fops;
L
Linus Torvalds 已提交
957 958
} devlist[] = { /* list of minor devices */
	{1, "mem",     S_IRUSR | S_IWUSR | S_IRGRP, &mem_fops},
959
#ifdef CONFIG_DEVKMEM
L
Linus Torvalds 已提交
960
	{2, "kmem",    S_IRUSR | S_IWUSR | S_IRGRP, &kmem_fops},
961
#endif
L
Linus Torvalds 已提交
962
	{3, "null",    S_IRUGO | S_IWUGO,           &null_fops},
963
#ifdef CONFIG_DEVPORT
L
Linus Torvalds 已提交
964 965 966 967 968 969 970
	{4, "port",    S_IRUSR | S_IWUSR | S_IRGRP, &port_fops},
#endif
	{5, "zero",    S_IRUGO | S_IWUGO,           &zero_fops},
	{7, "full",    S_IRUGO | S_IWUGO,           &full_fops},
	{8, "random",  S_IRUGO | S_IWUSR,           &random_fops},
	{9, "urandom", S_IRUGO | S_IWUSR,           &urandom_fops},
	{11,"kmsg",    S_IRUGO | S_IWUSR,           &kmsg_fops},
971 972 973
#ifdef CONFIG_CRASH_DUMP
	{12,"oldmem",    S_IRUSR | S_IWUSR | S_IRGRP, &oldmem_fops},
#endif
L
Linus Torvalds 已提交
974 975
};

976
static struct class *mem_class;
L
Linus Torvalds 已提交
977 978 979 980

static int __init chr_dev_init(void)
{
	int i;
P
Peter Zijlstra 已提交
981 982 983 984 985
	int err;

	err = bdi_init(&zero_bdi);
	if (err)
		return err;
L
Linus Torvalds 已提交
986 987 988 989

	if (register_chrdev(MEM_MAJOR,"mem",&memory_fops))
		printk("unable to get major %d for memory devs\n", MEM_MAJOR);

990
	mem_class = class_create(THIS_MODULE, "mem");
991
	for (i = 0; i < ARRAY_SIZE(devlist); i++)
992 993 994
		device_create_drvdata(mem_class, NULL,
				      MKDEV(MEM_MAJOR, devlist[i].minor),
				      NULL, devlist[i].name);
995

L
Linus Torvalds 已提交
996 997 998 999
	return 0;
}

fs_initcall(chr_dev_init);