drivers/char/mem.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  linux/drivers/char/mem.c
   4  *
   5  *  Copyright (C) 1991, 1992  Linus Torvalds
   6  *
   7  *  Added devfs support.
   8  *    Jan-11-1998, C. Scott Ananian <cananian@alumni.princeton.edu>
   9  *  Shared /dev/zero mmapping support, Feb 2000, Kanoj Sarcar <kanoj@sgi.com>
  10  */
  11
  12 #include <linux/mm.h>
  13 #include <linux/miscdevice.h>
  14 #include <linux/slab.h>
  15 #include <linux/vmalloc.h>
  16 #include <linux/mman.h>
  17 #include <linux/random.h>
  18 #include <linux/init.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/backing-dev.h>
  25 #include <linux/shmem_fs.h>
  26 #include <linux/splice.h>
  27 #include <linux/pfn.h>
  28 #include <linux/export.h>
  29 #include <linux/io.h>
  30 #include <linux/uio.h>
  31 #include <linux/uaccess.h>
  32 #include <linux/security.h>
  33
  34 #define DEVMEM_MINOR    1
  35 #define DEVPORT_MINOR   4
  36
  37 static inline unsigned long size_inside_page(unsigned long start,
  38                                              unsigned long size)
  39 {
  40         unsigned long sz;
  41
  42         sz = PAGE_SIZE - (start & (PAGE_SIZE - 1));
  43
  44         return min(sz, size);
  45 }
  46
  47 #ifndef ARCH_HAS_VALID_PHYS_ADDR_RANGE
  48 static inline int valid_phys_addr_range(phys_addr_t addr, size_t count)
  49 {
  50         return addr + count <= __pa(high_memory);
  51 }
  52
  53 static inline int valid_mmap_phys_addr_range(unsigned long pfn, size_t size)
  54 {
  55         return 1;
  56 }
  57 #endif
  58
  59 #ifdef CONFIG_STRICT_DEVMEM
  60 static inline int page_is_allowed(unsigned long pfn)
  61 {
  62         return devmem_is_allowed(pfn);
  63 }
  64 static inline int range_is_allowed(unsigned long pfn, unsigned long size)
  65 {
  66         u64 from = ((u64)pfn) << PAGE_SHIFT;
  67         u64 to = from + size;
  68         u64 cursor = from;
  69
  70         while (cursor < to) {
  71                 if (!devmem_is_allowed(pfn))
  72                         return 0;
  73                 cursor += PAGE_SIZE;
  74                 pfn++;
  75         }
  76         return 1;
  77 }
  78 #else
  79 static inline int page_is_allowed(unsigned long pfn)
  80 {
  81         return 1;
  82 }
  83 static inline int range_is_allowed(unsigned long pfn, unsigned long size)
  84 {
  85         return 1;
  86 }
  87 #endif
  88
  89 static inline bool should_stop_iteration(void)
  90 {
  91         if (need_resched())
  92                 cond_resched();
  93         return signal_pending(current);
  94 }
  95
  96 /*
  97  * This funcion reads the *physical* memory. The f_pos points directly to the
  98  * memory location.
  99  */
 100 static ssize_t read_mem(struct file *file, char __user *buf,
 101                         size_t count, loff_t *ppos)
 102 {
 103         phys_addr_t p = *ppos;
 104         ssize_t read, sz;
 105         void *ptr;
 106         char *bounce;
 107         int err;
 108
 109         if (p != *ppos)
 110                 return 0;
 111
 112         if (!valid_phys_addr_range(p, count))
 113                 return -EFAULT;
 114         read = 0;
 115 #ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED
 116         /* we don't have page 0 mapped on sparc and m68k.. */
 117         if (p < PAGE_SIZE) {
 118                 sz = size_inside_page(p, count);
 119                 if (sz > 0) {
 120                         if (clear_user(buf, sz))
 121                                 return -EFAULT;
 122                         buf += sz;
 123                         p += sz;
 124                         count -= sz;
 125                         read += sz;
 126                 }
 127         }
 128 #endif
 129
 130         bounce = kmalloc(PAGE_SIZE, GFP_KERNEL);
 131         if (!bounce)
 132                 return -ENOMEM;
 133
 134         while (count > 0) {
 135                 unsigned long remaining;
 136                 int allowed, probe;
 137
 138                 sz = size_inside_page(p, count);
 139
 140                 err = -EPERM;
 141                 allowed = page_is_allowed(p >> PAGE_SHIFT);
 142                 if (!allowed)
 143                         goto failed;
 144
 145                 err = -EFAULT;
 146                 if (allowed == 2) {
 147                         /* Show zeros for restricted memory. */
 148                         remaining = clear_user(buf, sz);
 149                 } else {
 150                         /*
 151                          * On ia64 if a page has been mapped somewhere as
 152                          * uncached, then it must also be accessed uncached
 153                          * by the kernel or data corruption may occur.
 154                          */
 155                         ptr = xlate_dev_mem_ptr(p);
 156                         if (!ptr)
 157                                 goto failed;
 158
 159                         probe = copy_from_kernel_nofault(bounce, ptr, sz);
 160                         unxlate_dev_mem_ptr(p, ptr);
 161                         if (probe)
 162                                 goto failed;
 163
 164                         remaining = copy_to_user(buf, bounce, sz);
 165                 }
 166
 167                 if (remaining)
 168                         goto failed;
 169
 170                 buf += sz;
 171                 p += sz;
 172                 count -= sz;
 173                 read += sz;
 174                 if (should_stop_iteration())
 175                         break;
 176         }
 177         kfree(bounce);
 178
 179         *ppos += read;
 180         return read;
 181
 182 failed:
 183         kfree(bounce);
 184         return err;
 185 }
 186
 187 static ssize_t write_mem(struct file *file, const char __user *buf,
 188                          size_t count, loff_t *ppos)
 189 {
 190         phys_addr_t p = *ppos;
 191         ssize_t written, sz;
 192         unsigned long copied;
 193         void *ptr;
 194
 195         if (p != *ppos)
 196                 return -EFBIG;
 197
 198         if (!valid_phys_addr_range(p, count))
 199                 return -EFAULT;
 200
 201         written = 0;
 202
 203 #ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED
 204         /* we don't have page 0 mapped on sparc and m68k.. */
 205         if (p < PAGE_SIZE) {
 206                 sz = size_inside_page(p, count);
 207                 /* Hmm. Do something? */
 208                 buf += sz;
 209                 p += sz;
 210                 count -= sz;
 211                 written += sz;
 212         }
 213 #endif
 214
 215         while (count > 0) {
 216                 int allowed;
 217
 218                 sz = size_inside_page(p, count);
 219
 220                 allowed = page_is_allowed(p >> PAGE_SHIFT);
 221                 if (!allowed)
 222                         return -EPERM;
 223
 224                 /* Skip actual writing when a page is marked as restricted. */
 225                 if (allowed == 1) {
 226                         /*
 227                          * On ia64 if a page has been mapped somewhere as
 228                          * uncached, then it must also be accessed uncached
 229                          * by the kernel or data corruption may occur.
 230                          */
 231                         ptr = xlate_dev_mem_ptr(p);
 232                         if (!ptr) {
 233                                 if (written)
 234                                         break;
 235                                 return -EFAULT;
 236                         }
 237
 238                         copied = copy_from_user(ptr, buf, sz);
 239                         unxlate_dev_mem_ptr(p, ptr);
 240                         if (copied) {
 241                                 written += sz - copied;
 242                                 if (written)
 243                                         break;
 244                                 return -EFAULT;
 245                         }
 246                 }
 247
 248                 buf += sz;
 249                 p += sz;
 250                 count -= sz;
 251                 written += sz;
 252                 if (should_stop_iteration())
 253                         break;
 254         }
 255
 256         *ppos += written;
 257         return written;
 258 }
 259
 260 int __weak phys_mem_access_prot_allowed(struct file *file,
 261         unsigned long pfn, unsigned long size, pgprot_t *vma_prot)
 262 {
 263         return 1;
 264 }
 265
 266 #ifndef __HAVE_PHYS_MEM_ACCESS_PROT
 267
 268 /*
 269  * Architectures vary in how they handle caching for addresses
 270  * outside of main memory.
 271  *
 272  */
 273 #ifdef pgprot_noncached
 274 static int uncached_access(struct file *file, phys_addr_t addr)
 275 {
 276         /*
 277          * Accessing memory above the top the kernel knows about or through a
 278          * file pointer
 279          * that was marked O_DSYNC will be done non-cached.
 280          */
 281         if (file->f_flags & O_DSYNC)
 282                 return 1;
 283         return addr >= __pa(high_memory);
 284 }
 285 #endif
 286
 287 static pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
 288                                      unsigned long size, pgprot_t vma_prot)
 289 {
 290 #ifdef pgprot_noncached
 291         phys_addr_t offset = pfn << PAGE_SHIFT;
 292
 293         if (uncached_access(file, offset))
 294                 return pgprot_noncached(vma_prot);
 295 #endif
 296         return vma_prot;
 297 }
 298 #endif
 299
 300 #ifndef CONFIG_MMU
 301 static unsigned long get_unmapped_area_mem(struct file *file,
 302                                            unsigned long addr,
 303                                            unsigned long len,
 304                                            unsigned long pgoff,
 305                                            unsigned long flags)
 306 {
 307         if (!valid_mmap_phys_addr_range(pgoff, len))
 308                 return (unsigned long) -EINVAL;
 309         return pgoff << PAGE_SHIFT;
 310 }
 311
 312 /* permit direct mmap, for read, write or exec */
 313 static unsigned memory_mmap_capabilities(struct file *file)
 314 {
 315         return NOMMU_MAP_DIRECT |
 316                 NOMMU_MAP_READ | NOMMU_MAP_WRITE | NOMMU_MAP_EXEC;
 317 }
 318
 319 static unsigned zero_mmap_capabilities(struct file *file)
 320 {
 321         return NOMMU_MAP_COPY;
 322 }
 323
 324 /* can't do an in-place private mapping if there's no MMU */
 325 static inline int private_mapping_ok(struct vm_area_struct *vma)
 326 {
 327         return is_nommu_shared_mapping(vma->vm_flags);
 328 }
 329 #else
 330
 331 static inline int private_mapping_ok(struct vm_area_struct *vma)
 332 {
 333         return 1;
 334 }
 335 #endif
 336
 337 static const struct vm_operations_struct mmap_mem_ops = {
 338 #ifdef CONFIG_HAVE_IOREMAP_PROT
 339         .access = generic_access_phys
 340 #endif
 341 };
 342
 343 static int mmap_mem(struct file *file, struct vm_area_struct *vma)
 344 {
 345         size_t size = vma->vm_end - vma->vm_start;
 346         phys_addr_t offset = (phys_addr_t)vma->vm_pgoff << PAGE_SHIFT;
 347
 348         /* Does it even fit in phys_addr_t? */
 349         if (offset >> PAGE_SHIFT != vma->vm_pgoff)
 350                 return -EINVAL;
 351
 352         /* It's illegal to wrap around the end of the physical address space. */
 353         if (offset + (phys_addr_t)size - 1 < offset)
 354                 return -EINVAL;
 355
 356         if (!valid_mmap_phys_addr_range(vma->vm_pgoff, size))
 357                 return -EINVAL;
 358
 359         if (!private_mapping_ok(vma))
 360                 return -ENOSYS;
 361
 362         if (!range_is_allowed(vma->vm_pgoff, size))
 363                 return -EPERM;
 364
 365         if (!phys_mem_access_prot_allowed(file, vma->vm_pgoff, size,
 366                                                 &vma->vm_page_prot))
 367                 return -EINVAL;
 368
 369         vma->vm_page_prot = phys_mem_access_prot(file, vma->vm_pgoff,
 370                                                  size,
 371                                                  vma->vm_page_prot);
 372
 373         vma->vm_ops = &mmap_mem_ops;
 374
 375         /* Remap-pfn-range will mark the range VM_IO */
 376         if (remap_pfn_range(vma,
 377                             vma->vm_start,
 378                             vma->vm_pgoff,
 379                             size,
 380                             vma->vm_page_prot)) {
 381                 return -EAGAIN;
 382         }
 383         return 0;
 384 }
 385
 386 #ifdef CONFIG_DEVPORT
 387 static ssize_t read_port(struct file *file, char __user *buf,
 388                          size_t count, loff_t *ppos)
 389 {
 390         unsigned long i = *ppos;
 391         char __user *tmp = buf;
 392
 393         if (!access_ok(buf, count))
 394                 return -EFAULT;
 395         while (count-- > 0 && i < 65536) {
 396                 if (__put_user(inb(i), tmp) < 0)
 397                         return -EFAULT;
 398                 i++;
 399                 tmp++;
 400         }
 401         *ppos = i;
 402         return tmp-buf;
 403 }
 404
 405 static ssize_t write_port(struct file *file, const char __user *buf,
 406                           size_t count, loff_t *ppos)
 407 {
 408         unsigned long i = *ppos;
 409         const char __user *tmp = buf;
 410
 411         if (!access_ok(buf, count))
 412                 return -EFAULT;
 413         while (count-- > 0 && i < 65536) {
 414                 char c;
 415
 416                 if (__get_user(c, tmp)) {
 417                         if (tmp > buf)
 418                                 break;
 419                         return -EFAULT;
 420                 }
 421                 outb(c, i);
 422                 i++;
 423                 tmp++;
 424         }
 425         *ppos = i;
 426         return tmp-buf;
 427 }
 428 #endif
 429
 430 static ssize_t read_null(struct file *file, char __user *buf,
 431                          size_t count, loff_t *ppos)
 432 {
 433         return 0;
 434 }
 435
 436 static ssize_t write_null(struct file *file, const char __user *buf,
 437                           size_t count, loff_t *ppos)
 438 {
 439         return count;
 440 }
 441
 442 static ssize_t read_iter_null(struct kiocb *iocb, struct iov_iter *to)
 443 {
 444         return 0;
 445 }
 446
 447 static ssize_t write_iter_null(struct kiocb *iocb, struct iov_iter *from)
 448 {
 449         size_t count = iov_iter_count(from);
 450         iov_iter_advance(from, count);
 451         return count;
 452 }
 453
 454 static int pipe_to_null(struct pipe_inode_info *info, struct pipe_buffer *buf,
 455                         struct splice_desc *sd)
 456 {
 457         return sd->len;
 458 }
 459
 460 static ssize_t splice_write_null(struct pipe_inode_info *pipe, struct file *out,
 461                                  loff_t *ppos, size_t len, unsigned int flags)
 462 {
 463         return splice_from_pipe(pipe, out, ppos, len, flags, pipe_to_null);
 464 }
 465
 466 static int uring_cmd_null(struct io_uring_cmd *ioucmd, unsigned int issue_flags)
 467 {
 468         return 0;
 469 }
 470
 471 static ssize_t read_iter_zero(struct kiocb *iocb, struct iov_iter *iter)
 472 {
 473         size_t written = 0;
 474
 475         while (iov_iter_count(iter)) {
 476                 size_t chunk = iov_iter_count(iter), n;
 477
 478                 if (chunk > PAGE_SIZE)
 479                         chunk = PAGE_SIZE;      /* Just for latency reasons */
 480                 n = iov_iter_zero(chunk, iter);
 481                 if (!n && iov_iter_count(iter))
 482                         return written ? written : -EFAULT;
 483                 written += n;
 484                 if (signal_pending(current))
 485                         return written ? written : -ERESTARTSYS;
 486                 if (!need_resched())
 487                         continue;
 488                 if (iocb->ki_flags & IOCB_NOWAIT)
 489                         return written ? written : -EAGAIN;
 490                 cond_resched();
 491         }
 492         return written;
 493 }
 494
 495 static ssize_t read_zero(struct file *file, char __user *buf,
 496                          size_t count, loff_t *ppos)
 497 {
 498         size_t cleared = 0;
 499
 500         while (count) {
 501                 size_t chunk = min_t(size_t, count, PAGE_SIZE);
 502                 size_t left;
 503
 504                 left = clear_user(buf + cleared, chunk);
 505                 if (unlikely(left)) {
 506                         cleared += (chunk - left);
 507                         if (!cleared)
 508                                 return -EFAULT;
 509                         break;
 510                 }
 511                 cleared += chunk;
 512                 count -= chunk;
 513
 514                 if (signal_pending(current))
 515                         break;
 516                 cond_resched();
 517         }
 518
 519         return cleared;
 520 }
 521
 522 static int mmap_zero(struct file *file, struct vm_area_struct *vma)
 523 {
 524 #ifndef CONFIG_MMU
 525         return -ENOSYS;
 526 #endif
 527         if (vma->vm_flags & VM_SHARED)
 528                 return shmem_zero_setup(vma);
 529         vma_set_anonymous(vma);
 530         return 0;
 531 }
 532
 533 static unsigned long get_unmapped_area_zero(struct file *file,
 534                                 unsigned long addr, unsigned long len,
 535                                 unsigned long pgoff, unsigned long flags)
 536 {
 537 #ifdef CONFIG_MMU
 538         if (flags & MAP_SHARED) {
 539                 /*
 540                  * mmap_zero() will call shmem_zero_setup() to create a file,
 541                  * so use shmem's get_unmapped_area in case it can be huge;
 542                  * and pass NULL for file as in mmap.c's get_unmapped_area(),
 543                  * so as not to confuse shmem with our handle on "/dev/zero".
 544                  */
 545                 return shmem_get_unmapped_area(NULL, addr, len, pgoff, flags);
 546         }
 547
 548         /* Otherwise flags & MAP_PRIVATE: with no shmem object beneath it */
 549         return mm_get_unmapped_area(current->mm, file, addr, len, pgoff, flags);
 550 #else
 551         return -ENOSYS;
 552 #endif
 553 }
 554
 555 static ssize_t write_full(struct file *file, const char __user *buf,
 556                           size_t count, loff_t *ppos)
 557 {
 558         return -ENOSPC;
 559 }
 560
 561 /*
 562  * Special lseek() function for /dev/null and /dev/zero.  Most notably, you
 563  * can fopen() both devices with "a" now.  This was previously impossible.
 564  * -- SRB.
 565  */
 566 static loff_t null_lseek(struct file *file, loff_t offset, int orig)
 567 {
 568         return file->f_pos = 0;
 569 }
 570
 571 /*
 572  * The memory devices use the full 32/64 bits of the offset, and so we cannot
 573  * check against negative addresses: they are ok. The return value is weird,
 574  * though, in that case (0).
 575  *
 576  * also note that seeking relative to the "end of file" isn't supported:
 577  * it has no meaning, so it returns -EINVAL.
 578  */
 579 static loff_t memory_lseek(struct file *file, loff_t offset, int orig)
 580 {
 581         loff_t ret;
 582
 583         inode_lock(file_inode(file));
 584         switch (orig) {
 585         case SEEK_CUR:
 586                 offset += file->f_pos;
 587                 fallthrough;
 588         case SEEK_SET:
 589                 /* to avoid userland mistaking f_pos=-9 as -EBADF=-9 */
 590                 if ((unsigned long long)offset >= -MAX_ERRNO) {
 591                         ret = -EOVERFLOW;
 592                         break;
 593                 }
 594                 file->f_pos = offset;
 595                 ret = file->f_pos;
 596                 force_successful_syscall_return();
 597                 break;
 598         default:
 599                 ret = -EINVAL;
 600         }
 601         inode_unlock(file_inode(file));
 602         return ret;
 603 }
 604
 605 static int open_port(struct inode *inode, struct file *filp)
 606 {
 607         int rc;
 608
 609         if (!capable(CAP_SYS_RAWIO))
 610                 return -EPERM;
 611
 612         rc = security_locked_down(LOCKDOWN_DEV_MEM);
 613         if (rc)
 614                 return rc;
 615
 616         if (iminor(inode) != DEVMEM_MINOR)
 617                 return 0;
 618
 619         /*
 620          * Use a unified address space to have a single point to manage
 621          * revocations when drivers want to take over a /dev/mem mapped
 622          * range.
 623          */
 624         filp->f_mapping = iomem_get_mapping();
 625
 626         return 0;
 627 }
 628
 629 #define zero_lseek      null_lseek
 630 #define full_lseek      null_lseek
 631 #define write_zero      write_null
 632 #define write_iter_zero write_iter_null
 633 #define splice_write_zero       splice_write_null
 634 #define open_mem        open_port
 635
 636 static const struct file_operations __maybe_unused mem_fops = {
 637         .llseek         = memory_lseek,
 638         .read           = read_mem,
 639         .write          = write_mem,
 640         .mmap           = mmap_mem,
 641         .open           = open_mem,
 642 #ifndef CONFIG_MMU
 643         .get_unmapped_area = get_unmapped_area_mem,
 644         .mmap_capabilities = memory_mmap_capabilities,
 645 #endif
 646         .fop_flags      = FOP_UNSIGNED_OFFSET,
 647 };
 648
 649 static const struct file_operations null_fops = {
 650         .llseek         = null_lseek,
 651         .read           = read_null,
 652         .write          = write_null,
 653         .read_iter      = read_iter_null,
 654         .write_iter     = write_iter_null,
 655         .splice_write   = splice_write_null,
 656         .uring_cmd      = uring_cmd_null,
 657 };
 658
 659 #ifdef CONFIG_DEVPORT
 660 static const struct file_operations port_fops = {
 661         .llseek         = memory_lseek,
 662         .read           = read_port,
 663         .write          = write_port,
 664         .open           = open_port,
 665 };
 666 #endif
 667
 668 static const struct file_operations zero_fops = {
 669         .llseek         = zero_lseek,
 670         .write          = write_zero,
 671         .read_iter      = read_iter_zero,
 672         .read           = read_zero,
 673         .write_iter     = write_iter_zero,
 674         .splice_read    = copy_splice_read,
 675         .splice_write   = splice_write_zero,
 676         .mmap           = mmap_zero,
 677         .get_unmapped_area = get_unmapped_area_zero,
 678 #ifndef CONFIG_MMU
 679         .mmap_capabilities = zero_mmap_capabilities,
 680 #endif
 681 };
 682
 683 static const struct file_operations full_fops = {
 684         .llseek         = full_lseek,
 685         .read_iter      = read_iter_zero,
 686         .write          = write_full,
 687         .splice_read    = copy_splice_read,
 688 };
 689
 690 static const struct memdev {
 691         const char *name;
 692         const struct file_operations *fops;
 693         fmode_t fmode;
 694         umode_t mode;
 695 } devlist[] = {
 696 #ifdef CONFIG_DEVMEM
 697         [DEVMEM_MINOR] = { "mem", &mem_fops, 0, 0 },
 698 #endif
 699         [3] = { "null", &null_fops, FMODE_NOWAIT, 0666 },
 700 #ifdef CONFIG_DEVPORT
 701         [4] = { "port", &port_fops, 0, 0 },
 702 #endif
 703         [5] = { "zero", &zero_fops, FMODE_NOWAIT, 0666 },
 704         [7] = { "full", &full_fops, 0, 0666 },
 705         [8] = { "random", &random_fops, FMODE_NOWAIT, 0666 },
 706         [9] = { "urandom", &urandom_fops, FMODE_NOWAIT, 0666 },
 707 #ifdef CONFIG_PRINTK
 708         [11] = { "kmsg", &kmsg_fops, 0, 0644 },
 709 #endif
 710 };
 711
 712 static int memory_open(struct inode *inode, struct file *filp)
 713 {
 714         int minor;
 715         const struct memdev *dev;
 716
 717         minor = iminor(inode);
 718         if (minor >= ARRAY_SIZE(devlist))
 719                 return -ENXIO;
 720
 721         dev = &devlist[minor];
 722         if (!dev->fops)
 723                 return -ENXIO;
 724
 725         filp->f_op = dev->fops;
 726         filp->f_mode |= dev->fmode;
 727
 728         if (dev->fops->open)
 729                 return dev->fops->open(inode, filp);
 730
 731         return 0;
 732 }
 733
 734 static const struct file_operations memory_fops = {
 735         .open = memory_open,
 736         .llseek = noop_llseek,
 737 };
 738
 739 static char *mem_devnode(const struct device *dev, umode_t *mode)
 740 {
 741         if (mode && devlist[MINOR(dev->devt)].mode)
 742                 *mode = devlist[MINOR(dev->devt)].mode;
 743         return NULL;
 744 }
 745
 746 static const struct class mem_class = {
 747         .name           = "mem",
 748         .devnode        = mem_devnode,
 749 };
 750
 751 static int __init chr_dev_init(void)
 752 {
 753         int retval;
 754         int minor;
 755
 756         if (register_chrdev(MEM_MAJOR, "mem", &memory_fops))
 757                 printk("unable to get major %d for memory devs\n", MEM_MAJOR);
 758
 759         retval = class_register(&mem_class);
 760         if (retval)
 761                 return retval;
 762
 763         for (minor = 1; minor < ARRAY_SIZE(devlist); minor++) {
 764                 if (!devlist[minor].name)
 765                         continue;
 766
 767                 /*
 768                  * Create /dev/port?
 769                  */
 770                 if ((minor == DEVPORT_MINOR) && !arch_has_dev_port())
 771                         continue;
 772
 773                 device_create(&mem_class, NULL, MKDEV(MEM_MAJOR, minor),
 774                               NULL, devlist[minor].name);
 775         }
 776
 777         return tty_init();
 778 }
 779
 780 fs_initcall(chr_dev_init);