1 /* 2 * linux/drivers/char/mem.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 * 6 * Added devfs support. 7 * Jan-11-1998, C. Scott Ananian <cananian@alumni.princeton.edu> 8 * Shared /dev/zero mmaping support, Feb 2000, Kanoj Sarcar <kanoj@sgi.com> 9 */ 10 11 #include <linux/mm.h> 12 #include <linux/miscdevice.h> 13 #include <linux/slab.h> 14 #include <linux/vmalloc.h> 15 #include <linux/mman.h> 16 #include <linux/random.h> 17 #include <linux/init.h> 18 #include <linux/raw.h> 19 #include <linux/tty.h> 20 #include <linux/capability.h> 21 #include <linux/ptrace.h> 22 #include <linux/device.h> 23 #include <linux/highmem.h> 24 #include <linux/crash_dump.h> 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> 30 31 #include <asm/uaccess.h> 32 #include <asm/io.h> 33 34 #ifdef CONFIG_IA64 35 # include <linux/efi.h> 36 #endif 37 38 /* 39 * Architectures vary in how they handle caching for addresses 40 * outside of main memory. 41 * 42 */ 43 static inline int uncached_access(struct file *file, unsigned long addr) 44 { 45 #if defined(CONFIG_IA64) 46 /* 47 * On ia64, we ignore O_SYNC because we cannot tolerate memory attribute aliases. 48 */ 49 return !(efi_mem_attributes(addr) & EFI_MEMORY_WB); 50 #elif defined(CONFIG_MIPS) 51 { 52 extern int __uncached_access(struct file *file, 53 unsigned long addr); 54 55 return __uncached_access(file, addr); 56 } 57 #else 58 /* 59 * Accessing memory above the top the kernel knows about or through a file pointer 60 * that was marked O_SYNC will be done non-cached. 61 */ 62 if (file->f_flags & O_SYNC) 63 return 1; 64 return addr >= __pa(high_memory); 65 #endif 66 } 67 68 #ifndef ARCH_HAS_VALID_PHYS_ADDR_RANGE 69 static inline int valid_phys_addr_range(unsigned long addr, size_t count) 70 { 71 if (addr + count > __pa(high_memory)) 72 return 0; 73 74 return 1; 75 } 76 77 static inline int valid_mmap_phys_addr_range(unsigned long pfn, size_t size) 78 { 79 return 1; 80 } 81 #endif 82 83 #ifdef CONFIG_STRICT_DEVMEM 84 static inline int range_is_allowed(unsigned long pfn, unsigned long size) 85 { 86 u64 from = ((u64)pfn) << PAGE_SHIFT; 87 u64 to = from + size; 88 u64 cursor = from; 89 90 while (cursor < to) { 91 if (!devmem_is_allowed(pfn)) { 92 printk(KERN_INFO 93 "Program %s tried to access /dev/mem between %Lx->%Lx.\n", 94 current->comm, from, to); 95 return 0; 96 } 97 cursor += PAGE_SIZE; 98 pfn++; 99 } 100 return 1; 101 } 102 #else 103 static inline int range_is_allowed(unsigned long pfn, unsigned long size) 104 { 105 return 1; 106 } 107 #endif 108 109 void __attribute__((weak)) unxlate_dev_mem_ptr(unsigned long phys, void *addr) 110 { 111 } 112 113 /* 114 * This funcion reads the *physical* memory. The f_pos points directly to the 115 * memory location. 116 */ 117 static ssize_t read_mem(struct file * file, char __user * buf, 118 size_t count, loff_t *ppos) 119 { 120 unsigned long p = *ppos; 121 ssize_t read, sz; 122 char *ptr; 123 124 if (!valid_phys_addr_range(p, count)) 125 return -EFAULT; 126 read = 0; 127 #ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED 128 /* we don't have page 0 mapped on sparc and m68k.. */ 129 if (p < PAGE_SIZE) { 130 sz = PAGE_SIZE - p; 131 if (sz > count) 132 sz = count; 133 if (sz > 0) { 134 if (clear_user(buf, sz)) 135 return -EFAULT; 136 buf += sz; 137 p += sz; 138 count -= sz; 139 read += sz; 140 } 141 } 142 #endif 143 144 while (count > 0) { 145 /* 146 * Handle first page in case it's not aligned 147 */ 148 if (-p & (PAGE_SIZE - 1)) 149 sz = -p & (PAGE_SIZE - 1); 150 else 151 sz = PAGE_SIZE; 152 153 sz = min_t(unsigned long, sz, count); 154 155 if (!range_is_allowed(p >> PAGE_SHIFT, count)) 156 return -EPERM; 157 158 /* 159 * On ia64 if a page has been mapped somewhere as 160 * uncached, then it must also be accessed uncached 161 * by the kernel or data corruption may occur 162 */ 163 ptr = xlate_dev_mem_ptr(p); 164 if (!ptr) 165 return -EFAULT; 166 167 if (copy_to_user(buf, ptr, sz)) { 168 unxlate_dev_mem_ptr(p, ptr); 169 return -EFAULT; 170 } 171 172 unxlate_dev_mem_ptr(p, ptr); 173 174 buf += sz; 175 p += sz; 176 count -= sz; 177 read += sz; 178 } 179 180 *ppos += read; 181 return read; 182 } 183 184 static ssize_t write_mem(struct file * file, const char __user * buf, 185 size_t count, loff_t *ppos) 186 { 187 unsigned long p = *ppos; 188 ssize_t written, sz; 189 unsigned long copied; 190 void *ptr; 191 192 if (!valid_phys_addr_range(p, count)) 193 return -EFAULT; 194 195 written = 0; 196 197 #ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED 198 /* we don't have page 0 mapped on sparc and m68k.. */ 199 if (p < PAGE_SIZE) { 200 unsigned long sz = PAGE_SIZE - p; 201 if (sz > count) 202 sz = count; 203 /* Hmm. Do something? */ 204 buf += sz; 205 p += sz; 206 count -= sz; 207 written += sz; 208 } 209 #endif 210 211 while (count > 0) { 212 /* 213 * Handle first page in case it's not aligned 214 */ 215 if (-p & (PAGE_SIZE - 1)) 216 sz = -p & (PAGE_SIZE - 1); 217 else 218 sz = PAGE_SIZE; 219 220 sz = min_t(unsigned long, sz, count); 221 222 if (!range_is_allowed(p >> PAGE_SHIFT, sz)) 223 return -EPERM; 224 225 /* 226 * On ia64 if a page has been mapped somewhere as 227 * uncached, then it must also be accessed uncached 228 * by the kernel or data corruption may occur 229 */ 230 ptr = xlate_dev_mem_ptr(p); 231 if (!ptr) { 232 if (written) 233 break; 234 return -EFAULT; 235 } 236 237 copied = copy_from_user(ptr, buf, sz); 238 if (copied) { 239 written += sz - copied; 240 unxlate_dev_mem_ptr(p, ptr); 241 if (written) 242 break; 243 return -EFAULT; 244 } 245 246 unxlate_dev_mem_ptr(p, ptr); 247 248 buf += sz; 249 p += sz; 250 count -= sz; 251 written += sz; 252 } 253 254 *ppos += written; 255 return written; 256 } 257 258 int __attribute__((weak)) phys_mem_access_prot_allowed(struct file *file, 259 unsigned long pfn, unsigned long size, pgprot_t *vma_prot) 260 { 261 return 1; 262 } 263 264 #ifndef __HAVE_PHYS_MEM_ACCESS_PROT 265 static pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn, 266 unsigned long size, pgprot_t vma_prot) 267 { 268 #ifdef pgprot_noncached 269 unsigned long offset = pfn << PAGE_SHIFT; 270 271 if (uncached_access(file, offset)) 272 return pgprot_noncached(vma_prot); 273 #endif 274 return vma_prot; 275 } 276 #endif 277 278 #ifndef CONFIG_MMU 279 static unsigned long get_unmapped_area_mem(struct file *file, 280 unsigned long addr, 281 unsigned long len, 282 unsigned long pgoff, 283 unsigned long flags) 284 { 285 if (!valid_mmap_phys_addr_range(pgoff, len)) 286 return (unsigned long) -EINVAL; 287 return pgoff << PAGE_SHIFT; 288 } 289 290 /* can't do an in-place private mapping if there's no MMU */ 291 static inline int private_mapping_ok(struct vm_area_struct *vma) 292 { 293 return vma->vm_flags & VM_MAYSHARE; 294 } 295 #else 296 #define get_unmapped_area_mem NULL 297 298 static inline int private_mapping_ok(struct vm_area_struct *vma) 299 { 300 return 1; 301 } 302 #endif 303 304 static const struct vm_operations_struct mmap_mem_ops = { 305 #ifdef CONFIG_HAVE_IOREMAP_PROT 306 .access = generic_access_phys 307 #endif 308 }; 309 310 static int mmap_mem(struct file * file, struct vm_area_struct * vma) 311 { 312 size_t size = vma->vm_end - vma->vm_start; 313 314 if (!valid_mmap_phys_addr_range(vma->vm_pgoff, size)) 315 return -EINVAL; 316 317 if (!private_mapping_ok(vma)) 318 return -ENOSYS; 319 320 if (!range_is_allowed(vma->vm_pgoff, size)) 321 return -EPERM; 322 323 if (!phys_mem_access_prot_allowed(file, vma->vm_pgoff, size, 324 &vma->vm_page_prot)) 325 return -EINVAL; 326 327 vma->vm_page_prot = phys_mem_access_prot(file, vma->vm_pgoff, 328 size, 329 vma->vm_page_prot); 330 331 vma->vm_ops = &mmap_mem_ops; 332 333 /* Remap-pfn-range will mark the range VM_IO and VM_RESERVED */ 334 if (remap_pfn_range(vma, 335 vma->vm_start, 336 vma->vm_pgoff, 337 size, 338 vma->vm_page_prot)) { 339 return -EAGAIN; 340 } 341 return 0; 342 } 343 344 #ifdef CONFIG_DEVKMEM 345 static int mmap_kmem(struct file * file, struct vm_area_struct * vma) 346 { 347 unsigned long pfn; 348 349 /* Turn a kernel-virtual address into a physical page frame */ 350 pfn = __pa((u64)vma->vm_pgoff << PAGE_SHIFT) >> PAGE_SHIFT; 351 352 /* 353 * RED-PEN: on some architectures there is more mapped memory 354 * than available in mem_map which pfn_valid checks 355 * for. Perhaps should add a new macro here. 356 * 357 * RED-PEN: vmalloc is not supported right now. 358 */ 359 if (!pfn_valid(pfn)) 360 return -EIO; 361 362 vma->vm_pgoff = pfn; 363 return mmap_mem(file, vma); 364 } 365 #endif 366 367 #ifdef CONFIG_CRASH_DUMP 368 /* 369 * Read memory corresponding to the old kernel. 370 */ 371 static ssize_t read_oldmem(struct file *file, char __user *buf, 372 size_t count, loff_t *ppos) 373 { 374 unsigned long pfn, offset; 375 size_t read = 0, csize; 376 int rc = 0; 377 378 while (count) { 379 pfn = *ppos / PAGE_SIZE; 380 if (pfn > saved_max_pfn) 381 return read; 382 383 offset = (unsigned long)(*ppos % PAGE_SIZE); 384 if (count > PAGE_SIZE - offset) 385 csize = PAGE_SIZE - offset; 386 else 387 csize = count; 388 389 rc = copy_oldmem_page(pfn, buf, csize, offset, 1); 390 if (rc < 0) 391 return rc; 392 buf += csize; 393 *ppos += csize; 394 read += csize; 395 count -= csize; 396 } 397 return read; 398 } 399 #endif 400 401 #ifdef CONFIG_DEVKMEM 402 /* 403 * This function reads the *virtual* memory as seen by the kernel. 404 */ 405 static ssize_t read_kmem(struct file *file, char __user *buf, 406 size_t count, loff_t *ppos) 407 { 408 unsigned long p = *ppos; 409 ssize_t low_count, read, sz; 410 char * kbuf; /* k-addr because vread() takes vmlist_lock rwlock */ 411 412 read = 0; 413 if (p < (unsigned long) high_memory) { 414 low_count = count; 415 if (count > (unsigned long) high_memory - p) 416 low_count = (unsigned long) high_memory - p; 417 418 #ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED 419 /* we don't have page 0 mapped on sparc and m68k.. */ 420 if (p < PAGE_SIZE && low_count > 0) { 421 size_t tmp = PAGE_SIZE - p; 422 if (tmp > low_count) tmp = low_count; 423 if (clear_user(buf, tmp)) 424 return -EFAULT; 425 buf += tmp; 426 p += tmp; 427 read += tmp; 428 low_count -= tmp; 429 count -= tmp; 430 } 431 #endif 432 while (low_count > 0) { 433 /* 434 * Handle first page in case it's not aligned 435 */ 436 if (-p & (PAGE_SIZE - 1)) 437 sz = -p & (PAGE_SIZE - 1); 438 else 439 sz = PAGE_SIZE; 440 441 sz = min_t(unsigned long, sz, low_count); 442 443 /* 444 * On ia64 if a page has been mapped somewhere as 445 * uncached, then it must also be accessed uncached 446 * by the kernel or data corruption may occur 447 */ 448 kbuf = xlate_dev_kmem_ptr((char *)p); 449 450 if (copy_to_user(buf, kbuf, sz)) 451 return -EFAULT; 452 buf += sz; 453 p += sz; 454 read += sz; 455 low_count -= sz; 456 count -= sz; 457 } 458 } 459 460 if (count > 0) { 461 kbuf = (char *)__get_free_page(GFP_KERNEL); 462 if (!kbuf) 463 return -ENOMEM; 464 while (count > 0) { 465 int len = count; 466 467 if (len > PAGE_SIZE) 468 len = PAGE_SIZE; 469 len = vread(kbuf, (char *)p, len); 470 if (!len) 471 break; 472 if (copy_to_user(buf, kbuf, len)) { 473 free_page((unsigned long)kbuf); 474 return -EFAULT; 475 } 476 count -= len; 477 buf += len; 478 read += len; 479 p += len; 480 } 481 free_page((unsigned long)kbuf); 482 } 483 *ppos = p; 484 return read; 485 } 486 487 488 static inline ssize_t 489 do_write_kmem(void *p, unsigned long realp, const char __user * buf, 490 size_t count, loff_t *ppos) 491 { 492 ssize_t written, sz; 493 unsigned long copied; 494 495 written = 0; 496 #ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED 497 /* we don't have page 0 mapped on sparc and m68k.. */ 498 if (realp < PAGE_SIZE) { 499 unsigned long sz = PAGE_SIZE - realp; 500 if (sz > count) 501 sz = count; 502 /* Hmm. Do something? */ 503 buf += sz; 504 p += sz; 505 realp += sz; 506 count -= sz; 507 written += sz; 508 } 509 #endif 510 511 while (count > 0) { 512 char *ptr; 513 /* 514 * Handle first page in case it's not aligned 515 */ 516 if (-realp & (PAGE_SIZE - 1)) 517 sz = -realp & (PAGE_SIZE - 1); 518 else 519 sz = PAGE_SIZE; 520 521 sz = min_t(unsigned long, sz, count); 522 523 /* 524 * On ia64 if a page has been mapped somewhere as 525 * uncached, then it must also be accessed uncached 526 * by the kernel or data corruption may occur 527 */ 528 ptr = xlate_dev_kmem_ptr(p); 529 530 copied = copy_from_user(ptr, buf, sz); 531 if (copied) { 532 written += sz - copied; 533 if (written) 534 break; 535 return -EFAULT; 536 } 537 buf += sz; 538 p += sz; 539 realp += sz; 540 count -= sz; 541 written += sz; 542 } 543 544 *ppos += written; 545 return written; 546 } 547 548 549 /* 550 * This function writes to the *virtual* memory as seen by the kernel. 551 */ 552 static ssize_t write_kmem(struct file * file, const char __user * buf, 553 size_t count, loff_t *ppos) 554 { 555 unsigned long p = *ppos; 556 ssize_t wrote = 0; 557 ssize_t virtr = 0; 558 ssize_t written; 559 char * kbuf; /* k-addr because vwrite() takes vmlist_lock rwlock */ 560 561 if (p < (unsigned long) high_memory) { 562 563 wrote = count; 564 if (count > (unsigned long) high_memory - p) 565 wrote = (unsigned long) high_memory - p; 566 567 written = do_write_kmem((void*)p, p, buf, wrote, ppos); 568 if (written != wrote) 569 return written; 570 wrote = written; 571 p += wrote; 572 buf += wrote; 573 count -= wrote; 574 } 575 576 if (count > 0) { 577 kbuf = (char *)__get_free_page(GFP_KERNEL); 578 if (!kbuf) 579 return wrote ? wrote : -ENOMEM; 580 while (count > 0) { 581 int len = count; 582 583 if (len > PAGE_SIZE) 584 len = PAGE_SIZE; 585 if (len) { 586 written = copy_from_user(kbuf, buf, len); 587 if (written) { 588 if (wrote + virtr) 589 break; 590 free_page((unsigned long)kbuf); 591 return -EFAULT; 592 } 593 } 594 len = vwrite(kbuf, (char *)p, len); 595 count -= len; 596 buf += len; 597 virtr += len; 598 p += len; 599 } 600 free_page((unsigned long)kbuf); 601 } 602 603 *ppos = p; 604 return virtr + wrote; 605 } 606 #endif 607 608 #ifdef CONFIG_DEVPORT 609 static ssize_t read_port(struct file * file, char __user * buf, 610 size_t count, loff_t *ppos) 611 { 612 unsigned long i = *ppos; 613 char __user *tmp = buf; 614 615 if (!access_ok(VERIFY_WRITE, buf, count)) 616 return -EFAULT; 617 while (count-- > 0 && i < 65536) { 618 if (__put_user(inb(i),tmp) < 0) 619 return -EFAULT; 620 i++; 621 tmp++; 622 } 623 *ppos = i; 624 return tmp-buf; 625 } 626 627 static ssize_t write_port(struct file * file, const char __user * buf, 628 size_t count, loff_t *ppos) 629 { 630 unsigned long i = *ppos; 631 const char __user * tmp = buf; 632 633 if (!access_ok(VERIFY_READ,buf,count)) 634 return -EFAULT; 635 while (count-- > 0 && i < 65536) { 636 char c; 637 if (__get_user(c, tmp)) { 638 if (tmp > buf) 639 break; 640 return -EFAULT; 641 } 642 outb(c,i); 643 i++; 644 tmp++; 645 } 646 *ppos = i; 647 return tmp-buf; 648 } 649 #endif 650 651 static ssize_t read_null(struct file * file, char __user * buf, 652 size_t count, loff_t *ppos) 653 { 654 return 0; 655 } 656 657 static ssize_t write_null(struct file * file, const char __user * buf, 658 size_t count, loff_t *ppos) 659 { 660 return count; 661 } 662 663 static int pipe_to_null(struct pipe_inode_info *info, struct pipe_buffer *buf, 664 struct splice_desc *sd) 665 { 666 return sd->len; 667 } 668 669 static ssize_t splice_write_null(struct pipe_inode_info *pipe,struct file *out, 670 loff_t *ppos, size_t len, unsigned int flags) 671 { 672 return splice_from_pipe(pipe, out, ppos, len, flags, pipe_to_null); 673 } 674 675 static ssize_t read_zero(struct file * file, char __user * buf, 676 size_t count, loff_t *ppos) 677 { 678 size_t written; 679 680 if (!count) 681 return 0; 682 683 if (!access_ok(VERIFY_WRITE, buf, count)) 684 return -EFAULT; 685 686 written = 0; 687 while (count) { 688 unsigned long unwritten; 689 size_t chunk = count; 690 691 if (chunk > PAGE_SIZE) 692 chunk = PAGE_SIZE; /* Just for latency reasons */ 693 unwritten = __clear_user(buf, chunk); 694 written += chunk - unwritten; 695 if (unwritten) 696 break; 697 if (signal_pending(current)) 698 return written ? written : -ERESTARTSYS; 699 buf += chunk; 700 count -= chunk; 701 cond_resched(); 702 } 703 return written ? written : -EFAULT; 704 } 705 706 static int mmap_zero(struct file * file, struct vm_area_struct * vma) 707 { 708 #ifndef CONFIG_MMU 709 return -ENOSYS; 710 #endif 711 if (vma->vm_flags & VM_SHARED) 712 return shmem_zero_setup(vma); 713 return 0; 714 } 715 716 static ssize_t write_full(struct file * file, const char __user * buf, 717 size_t count, loff_t *ppos) 718 { 719 return -ENOSPC; 720 } 721 722 /* 723 * Special lseek() function for /dev/null and /dev/zero. Most notably, you 724 * can fopen() both devices with "a" now. This was previously impossible. 725 * -- SRB. 726 */ 727 728 static loff_t null_lseek(struct file * file, loff_t offset, int orig) 729 { 730 return file->f_pos = 0; 731 } 732 733 /* 734 * The memory devices use the full 32/64 bits of the offset, and so we cannot 735 * check against negative addresses: they are ok. The return value is weird, 736 * though, in that case (0). 737 * 738 * also note that seeking relative to the "end of file" isn't supported: 739 * it has no meaning, so it returns -EINVAL. 740 */ 741 static loff_t memory_lseek(struct file * file, loff_t offset, int orig) 742 { 743 loff_t ret; 744 745 mutex_lock(&file->f_path.dentry->d_inode->i_mutex); 746 switch (orig) { 747 case 0: 748 file->f_pos = offset; 749 ret = file->f_pos; 750 force_successful_syscall_return(); 751 break; 752 case 1: 753 file->f_pos += offset; 754 ret = file->f_pos; 755 force_successful_syscall_return(); 756 break; 757 default: 758 ret = -EINVAL; 759 } 760 mutex_unlock(&file->f_path.dentry->d_inode->i_mutex); 761 return ret; 762 } 763 764 static int open_port(struct inode * inode, struct file * filp) 765 { 766 return capable(CAP_SYS_RAWIO) ? 0 : -EPERM; 767 } 768 769 #define zero_lseek null_lseek 770 #define full_lseek null_lseek 771 #define write_zero write_null 772 #define read_full read_zero 773 #define open_mem open_port 774 #define open_kmem open_mem 775 #define open_oldmem open_mem 776 777 static const struct file_operations mem_fops = { 778 .llseek = memory_lseek, 779 .read = read_mem, 780 .write = write_mem, 781 .mmap = mmap_mem, 782 .open = open_mem, 783 .get_unmapped_area = get_unmapped_area_mem, 784 }; 785 786 #ifdef CONFIG_DEVKMEM 787 static const struct file_operations kmem_fops = { 788 .llseek = memory_lseek, 789 .read = read_kmem, 790 .write = write_kmem, 791 .mmap = mmap_kmem, 792 .open = open_kmem, 793 .get_unmapped_area = get_unmapped_area_mem, 794 }; 795 #endif 796 797 static const struct file_operations null_fops = { 798 .llseek = null_lseek, 799 .read = read_null, 800 .write = write_null, 801 .splice_write = splice_write_null, 802 }; 803 804 #ifdef CONFIG_DEVPORT 805 static const struct file_operations port_fops = { 806 .llseek = memory_lseek, 807 .read = read_port, 808 .write = write_port, 809 .open = open_port, 810 }; 811 #endif 812 813 static const struct file_operations zero_fops = { 814 .llseek = zero_lseek, 815 .read = read_zero, 816 .write = write_zero, 817 .mmap = mmap_zero, 818 }; 819 820 /* 821 * capabilities for /dev/zero 822 * - permits private mappings, "copies" are taken of the source of zeros 823 */ 824 static struct backing_dev_info zero_bdi = { 825 .name = "char/mem", 826 .capabilities = BDI_CAP_MAP_COPY, 827 }; 828 829 static const struct file_operations full_fops = { 830 .llseek = full_lseek, 831 .read = read_full, 832 .write = write_full, 833 }; 834 835 #ifdef CONFIG_CRASH_DUMP 836 static const struct file_operations oldmem_fops = { 837 .read = read_oldmem, 838 .open = open_oldmem, 839 }; 840 #endif 841 842 static ssize_t kmsg_write(struct file * file, const char __user * buf, 843 size_t count, loff_t *ppos) 844 { 845 char *tmp; 846 ssize_t ret; 847 848 tmp = kmalloc(count + 1, GFP_KERNEL); 849 if (tmp == NULL) 850 return -ENOMEM; 851 ret = -EFAULT; 852 if (!copy_from_user(tmp, buf, count)) { 853 tmp[count] = 0; 854 ret = printk("%s", tmp); 855 if (ret > count) 856 /* printk can add a prefix */ 857 ret = count; 858 } 859 kfree(tmp); 860 return ret; 861 } 862 863 static const struct file_operations kmsg_fops = { 864 .write = kmsg_write, 865 }; 866 867 static const struct memdev { 868 const char *name; 869 mode_t mode; 870 const struct file_operations *fops; 871 struct backing_dev_info *dev_info; 872 } devlist[] = { 873 [1] = { "mem", 0, &mem_fops, &directly_mappable_cdev_bdi }, 874 #ifdef CONFIG_DEVKMEM 875 [2] = { "kmem", 0, &kmem_fops, &directly_mappable_cdev_bdi }, 876 #endif 877 [3] = { "null", 0666, &null_fops, NULL }, 878 #ifdef CONFIG_DEVPORT 879 [4] = { "port", 0, &port_fops, NULL }, 880 #endif 881 [5] = { "zero", 0666, &zero_fops, &zero_bdi }, 882 [7] = { "full", 0666, &full_fops, NULL }, 883 [8] = { "random", 0666, &random_fops, NULL }, 884 [9] = { "urandom", 0666, &urandom_fops, NULL }, 885 [11] = { "kmsg", 0, &kmsg_fops, NULL }, 886 #ifdef CONFIG_CRASH_DUMP 887 [12] = { "oldmem", 0, &oldmem_fops, NULL }, 888 #endif 889 }; 890 891 static int memory_open(struct inode *inode, struct file *filp) 892 { 893 int minor; 894 const struct memdev *dev; 895 int ret = -ENXIO; 896 897 lock_kernel(); 898 899 minor = iminor(inode); 900 if (minor >= ARRAY_SIZE(devlist)) 901 goto out; 902 903 dev = &devlist[minor]; 904 if (!dev->fops) 905 goto out; 906 907 filp->f_op = dev->fops; 908 if (dev->dev_info) 909 filp->f_mapping->backing_dev_info = dev->dev_info; 910 911 if (dev->fops->open) 912 ret = dev->fops->open(inode, filp); 913 else 914 ret = 0; 915 out: 916 unlock_kernel(); 917 return ret; 918 } 919 920 static const struct file_operations memory_fops = { 921 .open = memory_open, 922 }; 923 924 static char *mem_devnode(struct device *dev, mode_t *mode) 925 { 926 if (mode && devlist[MINOR(dev->devt)].mode) 927 *mode = devlist[MINOR(dev->devt)].mode; 928 return NULL; 929 } 930 931 static struct class *mem_class; 932 933 static int __init chr_dev_init(void) 934 { 935 int minor; 936 int err; 937 938 err = bdi_init(&zero_bdi); 939 if (err) 940 return err; 941 942 if (register_chrdev(MEM_MAJOR,"mem",&memory_fops)) 943 printk("unable to get major %d for memory devs\n", MEM_MAJOR); 944 945 mem_class = class_create(THIS_MODULE, "mem"); 946 mem_class->devnode = mem_devnode; 947 for (minor = 1; minor < ARRAY_SIZE(devlist); minor++) { 948 if (!devlist[minor].name) 949 continue; 950 device_create(mem_class, NULL, MKDEV(MEM_MAJOR, minor), 951 NULL, devlist[minor].name); 952 } 953 954 return 0; 955 } 956 957 fs_initcall(chr_dev_init); 958