xref: /linux/drivers/char/mem.c (revision 8f72c31f45a575d156cfe964099b4cfcc02e03eb)
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 
size_inside_page(unsigned long start,unsigned long size)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
valid_phys_addr_range(phys_addr_t addr,size_t count)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 
valid_mmap_phys_addr_range(unsigned long pfn,size_t size)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
page_is_allowed(unsigned long pfn)60 static inline int page_is_allowed(unsigned long pfn)
61 {
62 	return devmem_is_allowed(pfn);
63 }
range_is_allowed(unsigned long pfn,unsigned long size)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
page_is_allowed(unsigned long pfn)79 static inline int page_is_allowed(unsigned long pfn)
80 {
81 	return 1;
82 }
range_is_allowed(unsigned long pfn,unsigned long size)83 static inline int range_is_allowed(unsigned long pfn, unsigned long size)
84 {
85 	return 1;
86 }
87 #endif
88 
should_stop_iteration(void)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  */
read_mem(struct file * file,char __user * buf,size_t count,loff_t * ppos)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 
write_mem(struct file * file,const char __user * buf,size_t count,loff_t * ppos)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 
phys_mem_access_prot_allowed(struct file * file,unsigned long pfn,unsigned long size,pgprot_t * vma_prot)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
uncached_access(struct file * file,phys_addr_t addr)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 
phys_mem_access_prot(struct file * file,unsigned long pfn,unsigned long size,pgprot_t vma_prot)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
get_unmapped_area_mem(struct file * file,unsigned long addr,unsigned long len,unsigned long pgoff,unsigned long flags)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 */
memory_mmap_capabilities(struct file * file)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 
zero_mmap_capabilities(struct file * file)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 */
private_mapping_ok(struct vm_area_struct * vma)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 
private_mapping_ok(struct vm_area_struct * vma)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 
mmap_mem(struct file * file,struct vm_area_struct * vma)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
read_port(struct file * file,char __user * buf,size_t count,loff_t * ppos)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 
write_port(struct file * file,const char __user * buf,size_t count,loff_t * ppos)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 
read_null(struct file * file,char __user * buf,size_t count,loff_t * ppos)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 
write_null(struct file * file,const char __user * buf,size_t count,loff_t * ppos)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 
read_iter_null(struct kiocb * iocb,struct iov_iter * to)442 static ssize_t read_iter_null(struct kiocb *iocb, struct iov_iter *to)
443 {
444 	return 0;
445 }
446 
write_iter_null(struct kiocb * iocb,struct iov_iter * from)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 
pipe_to_null(struct pipe_inode_info * info,struct pipe_buffer * buf,struct splice_desc * sd)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 
splice_write_null(struct pipe_inode_info * pipe,struct file * out,loff_t * ppos,size_t len,unsigned int flags)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 
uring_cmd_null(struct io_uring_cmd * ioucmd,unsigned int issue_flags)466 static int uring_cmd_null(struct io_uring_cmd *ioucmd, unsigned int issue_flags)
467 {
468 	return 0;
469 }
470 
read_iter_zero(struct kiocb * iocb,struct iov_iter * iter)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 
read_zero(struct file * file,char __user * buf,size_t count,loff_t * ppos)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 
mmap_zero(struct file * file,struct vm_area_struct * vma)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 
get_unmapped_area_zero(struct file * file,unsigned long addr,unsigned long len,unsigned long pgoff,unsigned long flags)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 
write_full(struct file * file,const char __user * buf,size_t count,loff_t * ppos)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  */
null_lseek(struct file * file,loff_t offset,int orig)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  */
memory_lseek(struct file * file,loff_t offset,int orig)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 
open_port(struct inode * inode,struct file * filp)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 
memory_open(struct inode * inode,struct file * filp)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 
mem_devnode(const struct device * dev,umode_t * mode)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 
chr_dev_init(void)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);
781