blob: 1f528fad3516827754270806a4c6afdee505c9d0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/drivers/char/mem.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 *
Andrew Mortond7d4d842010-03-10 15:21:52 -08006 * Added devfs support.
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * Jan-11-1998, C. Scott Ananian <cananian@alumni.princeton.edu>
André Goddard Rosaaf901ca2009-11-14 13:09:05 -02008 * Shared /dev/zero mmapping support, Feb 2000, Kanoj Sarcar <kanoj@sgi.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 */
10
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/ptrace.h>
22#include <linux/device.h>
Vivek Goyal50b1fdb2005-06-25 14:58:23 -070023#include <linux/highmem.h>
24#include <linux/crash_dump.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/backing-dev.h>
Vivek Goyal315c2152005-06-25 14:58:24 -070026#include <linux/bootmem.h>
Jens Axboed6b29d72007-06-04 09:59:47 +020027#include <linux/splice.h>
Linus Torvaldsb8a3ad52006-10-13 08:42:10 -070028#include <linux/pfn.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
30#include <asm/uaccess.h>
31#include <asm/io.h>
32
33#ifdef CONFIG_IA64
34# include <linux/efi.h>
35#endif
36
Wu Fengguangf2223182009-12-14 17:58:07 -080037static inline unsigned long size_inside_page(unsigned long start,
38 unsigned long size)
39{
40 unsigned long sz;
41
Wu Fengguang7fabadd2009-12-14 17:58:09 -080042 sz = PAGE_SIZE - (start & (PAGE_SIZE - 1));
Wu Fengguangf2223182009-12-14 17:58:07 -080043
Wu Fengguang7fabadd2009-12-14 17:58:09 -080044 return min(sz, size);
Wu Fengguangf2223182009-12-14 17:58:07 -080045}
46
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#ifndef ARCH_HAS_VALID_PHYS_ADDR_RANGE
Bjorn Helgaas136939a2006-03-26 01:37:05 -080048static inline int valid_phys_addr_range(unsigned long addr, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -070049{
Bjorn Helgaas136939a2006-03-26 01:37:05 -080050 if (addr + count > __pa(high_memory))
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 return 0;
52
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 return 1;
54}
Bjorn Helgaas80851ef2006-01-08 01:04:13 -080055
Lennert Buytenhek06c67be2006-07-10 04:45:27 -070056static inline int valid_mmap_phys_addr_range(unsigned long pfn, size_t size)
Bjorn Helgaas80851ef2006-01-08 01:04:13 -080057{
58 return 1;
59}
Linus Torvalds1da177e2005-04-16 15:20:36 -070060#endif
61
Ingo Molnard0926332008-07-18 00:26:59 +020062#ifdef CONFIG_STRICT_DEVMEM
Venki Pallipadie2beb3e2008-03-06 23:01:47 -080063static inline int range_is_allowed(unsigned long pfn, unsigned long size)
Arjan van de Venae531c22008-04-24 23:40:47 +020064{
Venki Pallipadie2beb3e2008-03-06 23:01:47 -080065 u64 from = ((u64)pfn) << PAGE_SHIFT;
66 u64 to = from + size;
67 u64 cursor = from;
Arjan van de Venae531c22008-04-24 23:40:47 +020068
Venki Pallipadie2beb3e2008-03-06 23:01:47 -080069 while (cursor < to) {
70 if (!devmem_is_allowed(pfn)) {
71 printk(KERN_INFO
72 "Program %s tried to access /dev/mem between %Lx->%Lx.\n",
Arjan van de Venae531c22008-04-24 23:40:47 +020073 current->comm, from, to);
74 return 0;
75 }
Venki Pallipadie2beb3e2008-03-06 23:01:47 -080076 cursor += PAGE_SIZE;
77 pfn++;
Arjan van de Venae531c22008-04-24 23:40:47 +020078 }
79 return 1;
80}
81#else
Venki Pallipadie2beb3e2008-03-06 23:01:47 -080082static inline int range_is_allowed(unsigned long pfn, unsigned long size)
Arjan van de Venae531c22008-04-24 23:40:47 +020083{
84 return 1;
85}
86#endif
87
Andrew Mortond7d4d842010-03-10 15:21:52 -080088void __weak unxlate_dev_mem_ptr(unsigned long phys, void *addr)
venkatesh.pallipadi@intel.come045fb22008-03-18 17:00:15 -070089{
90}
91
Linus Torvalds1da177e2005-04-16 15:20:36 -070092/*
Andrew Mortond7d4d842010-03-10 15:21:52 -080093 * This funcion reads the *physical* memory. The f_pos points directly to the
94 * memory location.
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 */
Andrew Mortond7d4d842010-03-10 15:21:52 -080096static ssize_t read_mem(struct file *file, char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 size_t count, loff_t *ppos)
98{
99 unsigned long p = *ppos;
100 ssize_t read, sz;
101 char *ptr;
102
Bjorn Helgaas136939a2006-03-26 01:37:05 -0800103 if (!valid_phys_addr_range(p, count))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 return -EFAULT;
105 read = 0;
106#ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED
107 /* we don't have page 0 mapped on sparc and m68k.. */
108 if (p < PAGE_SIZE) {
Wu Fengguang7fabadd2009-12-14 17:58:09 -0800109 sz = size_inside_page(p, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 if (sz > 0) {
111 if (clear_user(buf, sz))
112 return -EFAULT;
Andrew Mortond7d4d842010-03-10 15:21:52 -0800113 buf += sz;
114 p += sz;
115 count -= sz;
116 read += sz;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 }
118 }
119#endif
120
121 while (count > 0) {
Wu Fengguangfa29e972009-12-14 17:58:08 -0800122 unsigned long remaining;
123
Wu Fengguangf2223182009-12-14 17:58:07 -0800124 sz = size_inside_page(p, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125
venkatesh.pallipadi@intel.come045fb22008-03-18 17:00:15 -0700126 if (!range_is_allowed(p >> PAGE_SHIFT, count))
127 return -EPERM;
128
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 /*
Andrew Mortond7d4d842010-03-10 15:21:52 -0800130 * On ia64 if a page has been mapped somewhere as uncached, then
131 * it must also be accessed uncached by the kernel or data
132 * corruption may occur.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 */
134 ptr = xlate_dev_mem_ptr(p);
venkatesh.pallipadi@intel.come045fb22008-03-18 17:00:15 -0700135 if (!ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 return -EFAULT;
venkatesh.pallipadi@intel.come045fb22008-03-18 17:00:15 -0700137
Wu Fengguangfa29e972009-12-14 17:58:08 -0800138 remaining = copy_to_user(buf, ptr, sz);
venkatesh.pallipadi@intel.come045fb22008-03-18 17:00:15 -0700139 unxlate_dev_mem_ptr(p, ptr);
Wu Fengguangfa29e972009-12-14 17:58:08 -0800140 if (remaining)
141 return -EFAULT;
venkatesh.pallipadi@intel.come045fb22008-03-18 17:00:15 -0700142
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 buf += sz;
144 p += sz;
145 count -= sz;
146 read += sz;
147 }
148
149 *ppos += read;
150 return read;
151}
152
Andrew Mortond7d4d842010-03-10 15:21:52 -0800153static ssize_t write_mem(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 size_t count, loff_t *ppos)
155{
156 unsigned long p = *ppos;
157 ssize_t written, sz;
158 unsigned long copied;
159 void *ptr;
160
Bjorn Helgaas136939a2006-03-26 01:37:05 -0800161 if (!valid_phys_addr_range(p, count))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 return -EFAULT;
163
164 written = 0;
165
166#ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED
167 /* we don't have page 0 mapped on sparc and m68k.. */
168 if (p < PAGE_SIZE) {
Wu Fengguang7fabadd2009-12-14 17:58:09 -0800169 sz = size_inside_page(p, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 /* Hmm. Do something? */
171 buf += sz;
172 p += sz;
173 count -= sz;
174 written += sz;
175 }
176#endif
177
178 while (count > 0) {
Wu Fengguangf2223182009-12-14 17:58:07 -0800179 sz = size_inside_page(p, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180
venkatesh.pallipadi@intel.come045fb22008-03-18 17:00:15 -0700181 if (!range_is_allowed(p >> PAGE_SHIFT, sz))
182 return -EPERM;
183
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 /*
Andrew Mortond7d4d842010-03-10 15:21:52 -0800185 * On ia64 if a page has been mapped somewhere as uncached, then
186 * it must also be accessed uncached by the kernel or data
187 * corruption may occur.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 */
189 ptr = xlate_dev_mem_ptr(p);
venkatesh.pallipadi@intel.come045fb22008-03-18 17:00:15 -0700190 if (!ptr) {
Jan Beulichc654d602006-03-25 03:07:31 -0800191 if (written)
192 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 return -EFAULT;
194 }
venkatesh.pallipadi@intel.come045fb22008-03-18 17:00:15 -0700195
196 copied = copy_from_user(ptr, buf, sz);
Wu Fengguangfa29e972009-12-14 17:58:08 -0800197 unxlate_dev_mem_ptr(p, ptr);
venkatesh.pallipadi@intel.come045fb22008-03-18 17:00:15 -0700198 if (copied) {
199 written += sz - copied;
venkatesh.pallipadi@intel.come045fb22008-03-18 17:00:15 -0700200 if (written)
201 break;
202 return -EFAULT;
203 }
204
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 buf += sz;
206 p += sz;
207 count -= sz;
208 written += sz;
209 }
210
211 *ppos += written;
212 return written;
213}
214
Andrew Mortond7d4d842010-03-10 15:21:52 -0800215int __weak phys_mem_access_prot_allowed(struct file *file,
venkatesh.pallipadi@intel.comf0970c12008-03-18 17:00:20 -0700216 unsigned long pfn, unsigned long size, pgprot_t *vma_prot)
217{
218 return 1;
219}
220
Bjorn Helgaas44ac8412006-01-08 01:04:10 -0800221#ifndef __HAVE_PHYS_MEM_ACCESS_PROT
Andrew Mortond7d4d842010-03-10 15:21:52 -0800222
223/*
224 * Architectures vary in how they handle caching for addresses
225 * outside of main memory.
226 *
227 */
David Howellsea56f412010-04-06 14:35:08 -0700228#ifdef pgprot_noncached
Andrew Mortond7d4d842010-03-10 15:21:52 -0800229static int uncached_access(struct file *file, unsigned long addr)
230{
231#if defined(CONFIG_IA64)
232 /*
233 * On ia64, we ignore O_DSYNC because we cannot tolerate memory
234 * attribute aliases.
235 */
236 return !(efi_mem_attributes(addr) & EFI_MEMORY_WB);
237#elif defined(CONFIG_MIPS)
238 {
239 extern int __uncached_access(struct file *file,
240 unsigned long addr);
241
242 return __uncached_access(file, addr);
243 }
244#else
245 /*
246 * Accessing memory above the top the kernel knows about or through a
247 * file pointer
248 * that was marked O_DSYNC will be done non-cached.
249 */
250 if (file->f_flags & O_DSYNC)
251 return 1;
252 return addr >= __pa(high_memory);
253#endif
254}
David Howellsea56f412010-04-06 14:35:08 -0700255#endif
Andrew Mortond7d4d842010-03-10 15:21:52 -0800256
Bjorn Helgaas44ac8412006-01-08 01:04:10 -0800257static pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
258 unsigned long size, pgprot_t vma_prot)
259{
260#ifdef pgprot_noncached
261 unsigned long offset = pfn << PAGE_SHIFT;
262
263 if (uncached_access(file, offset))
264 return pgprot_noncached(vma_prot);
265#endif
266 return vma_prot;
267}
268#endif
269
David Howells5da61852006-09-27 01:50:16 -0700270#ifndef CONFIG_MMU
271static unsigned long get_unmapped_area_mem(struct file *file,
272 unsigned long addr,
273 unsigned long len,
274 unsigned long pgoff,
275 unsigned long flags)
276{
277 if (!valid_mmap_phys_addr_range(pgoff, len))
278 return (unsigned long) -EINVAL;
Benjamin Herrenschmidt8a932582007-04-16 22:53:16 -0700279 return pgoff << PAGE_SHIFT;
David Howells5da61852006-09-27 01:50:16 -0700280}
281
282/* can't do an in-place private mapping if there's no MMU */
283static inline int private_mapping_ok(struct vm_area_struct *vma)
284{
285 return vma->vm_flags & VM_MAYSHARE;
286}
287#else
288#define get_unmapped_area_mem NULL
289
290static inline int private_mapping_ok(struct vm_area_struct *vma)
291{
292 return 1;
293}
294#endif
295
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +0400296static const struct vm_operations_struct mmap_mem_ops = {
Rik van Riel7ae8ed52008-07-23 21:27:07 -0700297#ifdef CONFIG_HAVE_IOREMAP_PROT
298 .access = generic_access_phys
299#endif
venkatesh.pallipadi@intel.come7f260a2008-03-18 17:00:21 -0700300};
301
Andrew Mortond7d4d842010-03-10 15:21:52 -0800302static int mmap_mem(struct file *file, struct vm_area_struct *vma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303{
Bjorn Helgaas80851ef2006-01-08 01:04:13 -0800304 size_t size = vma->vm_end - vma->vm_start;
305
Lennert Buytenhek06c67be2006-07-10 04:45:27 -0700306 if (!valid_mmap_phys_addr_range(vma->vm_pgoff, size))
Bjorn Helgaas80851ef2006-01-08 01:04:13 -0800307 return -EINVAL;
308
David Howells5da61852006-09-27 01:50:16 -0700309 if (!private_mapping_ok(vma))
310 return -ENOSYS;
311
Venki Pallipadie2beb3e2008-03-06 23:01:47 -0800312 if (!range_is_allowed(vma->vm_pgoff, size))
313 return -EPERM;
314
venkatesh.pallipadi@intel.comf0970c12008-03-18 17:00:20 -0700315 if (!phys_mem_access_prot_allowed(file, vma->vm_pgoff, size,
316 &vma->vm_page_prot))
317 return -EINVAL;
318
Roland Dreier8b150472005-10-28 17:46:18 -0700319 vma->vm_page_prot = phys_mem_access_prot(file, vma->vm_pgoff,
Bjorn Helgaas80851ef2006-01-08 01:04:13 -0800320 size,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 vma->vm_page_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322
venkatesh.pallipadi@intel.come7f260a2008-03-18 17:00:21 -0700323 vma->vm_ops = &mmap_mem_ops;
324
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 /* Remap-pfn-range will mark the range VM_IO and VM_RESERVED */
326 if (remap_pfn_range(vma,
327 vma->vm_start,
328 vma->vm_pgoff,
Bjorn Helgaas80851ef2006-01-08 01:04:13 -0800329 size,
venkatesh.pallipadi@intel.come7f260a2008-03-18 17:00:21 -0700330 vma->vm_page_prot)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 return -EAGAIN;
venkatesh.pallipadi@intel.come7f260a2008-03-18 17:00:21 -0700332 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 return 0;
334}
335
Arjan van de Venb781ecb2008-04-29 00:58:34 -0700336#ifdef CONFIG_DEVKMEM
Andrew Mortond7d4d842010-03-10 15:21:52 -0800337static int mmap_kmem(struct file *file, struct vm_area_struct *vma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338{
Linus Torvalds4bb82552005-08-13 14:22:59 -0700339 unsigned long pfn;
340
Linus Torvalds6d3154c2007-01-22 08:53:24 -0800341 /* Turn a kernel-virtual address into a physical page frame */
342 pfn = __pa((u64)vma->vm_pgoff << PAGE_SHIFT) >> PAGE_SHIFT;
Linus Torvalds4bb82552005-08-13 14:22:59 -0700343
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 /*
Andrew Mortond7d4d842010-03-10 15:21:52 -0800345 * RED-PEN: on some architectures there is more mapped memory than
346 * available in mem_map which pfn_valid checks for. Perhaps should add a
347 * new macro here.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 *
349 * RED-PEN: vmalloc is not supported right now.
350 */
Linus Torvalds4bb82552005-08-13 14:22:59 -0700351 if (!pfn_valid(pfn))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 return -EIO;
Linus Torvalds4bb82552005-08-13 14:22:59 -0700353
354 vma->vm_pgoff = pfn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 return mmap_mem(file, vma);
356}
Arjan van de Venb781ecb2008-04-29 00:58:34 -0700357#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358
Vivek Goyal50b1fdb2005-06-25 14:58:23 -0700359#ifdef CONFIG_CRASH_DUMP
360/*
361 * Read memory corresponding to the old kernel.
Vivek Goyal50b1fdb2005-06-25 14:58:23 -0700362 */
Vivek Goyal315c2152005-06-25 14:58:24 -0700363static ssize_t read_oldmem(struct file *file, char __user *buf,
Vivek Goyal50b1fdb2005-06-25 14:58:23 -0700364 size_t count, loff_t *ppos)
365{
Vivek Goyal315c2152005-06-25 14:58:24 -0700366 unsigned long pfn, offset;
367 size_t read = 0, csize;
368 int rc = 0;
Vivek Goyal50b1fdb2005-06-25 14:58:23 -0700369
Maneesh Soni72414d32005-06-25 14:58:28 -0700370 while (count) {
Vivek Goyal50b1fdb2005-06-25 14:58:23 -0700371 pfn = *ppos / PAGE_SIZE;
Vivek Goyal315c2152005-06-25 14:58:24 -0700372 if (pfn > saved_max_pfn)
373 return read;
Vivek Goyal50b1fdb2005-06-25 14:58:23 -0700374
Vivek Goyal315c2152005-06-25 14:58:24 -0700375 offset = (unsigned long)(*ppos % PAGE_SIZE);
376 if (count > PAGE_SIZE - offset)
377 csize = PAGE_SIZE - offset;
378 else
379 csize = count;
Vivek Goyal50b1fdb2005-06-25 14:58:23 -0700380
Vivek Goyal315c2152005-06-25 14:58:24 -0700381 rc = copy_oldmem_page(pfn, buf, csize, offset, 1);
382 if (rc < 0)
383 return rc;
Vivek Goyal50b1fdb2005-06-25 14:58:23 -0700384 buf += csize;
385 *ppos += csize;
386 read += csize;
387 count -= csize;
388 }
Vivek Goyal50b1fdb2005-06-25 14:58:23 -0700389 return read;
390}
391#endif
392
Arjan van de Venb781ecb2008-04-29 00:58:34 -0700393#ifdef CONFIG_DEVKMEM
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394/*
395 * This function reads the *virtual* memory as seen by the kernel.
396 */
Andrew Mortond7d4d842010-03-10 15:21:52 -0800397static ssize_t read_kmem(struct file *file, char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 size_t count, loff_t *ppos)
399{
400 unsigned long p = *ppos;
401 ssize_t low_count, read, sz;
402 char * kbuf; /* k-addr because vread() takes vmlist_lock rwlock */
KAMEZAWA Hiroyuki325fda72010-02-02 13:44:05 -0800403 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404
405 read = 0;
406 if (p < (unsigned long) high_memory) {
407 low_count = count;
Andrew Mortond7d4d842010-03-10 15:21:52 -0800408 if (count > (unsigned long)high_memory - p)
409 low_count = (unsigned long)high_memory - p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
411#ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED
412 /* we don't have page 0 mapped on sparc and m68k.. */
413 if (p < PAGE_SIZE && low_count > 0) {
Wu Fengguang7fabadd2009-12-14 17:58:09 -0800414 sz = size_inside_page(p, low_count);
415 if (clear_user(buf, sz))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 return -EFAULT;
Wu Fengguang7fabadd2009-12-14 17:58:09 -0800417 buf += sz;
418 p += sz;
419 read += sz;
420 low_count -= sz;
421 count -= sz;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 }
423#endif
424 while (low_count > 0) {
Wu Fengguangf2223182009-12-14 17:58:07 -0800425 sz = size_inside_page(p, low_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
427 /*
428 * On ia64 if a page has been mapped somewhere as
429 * uncached, then it must also be accessed uncached
430 * by the kernel or data corruption may occur
431 */
432 kbuf = xlate_dev_kmem_ptr((char *)p);
433
434 if (copy_to_user(buf, kbuf, sz))
435 return -EFAULT;
436 buf += sz;
437 p += sz;
438 read += sz;
439 low_count -= sz;
440 count -= sz;
441 }
442 }
443
444 if (count > 0) {
445 kbuf = (char *)__get_free_page(GFP_KERNEL);
446 if (!kbuf)
447 return -ENOMEM;
448 while (count > 0) {
Wu Fengguang80ad89a2009-12-14 17:58:10 -0800449 sz = size_inside_page(p, count);
KAMEZAWA Hiroyuki325fda72010-02-02 13:44:05 -0800450 if (!is_vmalloc_or_module_addr((void *)p)) {
451 err = -ENXIO;
452 break;
453 }
Wu Fengguang80ad89a2009-12-14 17:58:10 -0800454 sz = vread(kbuf, (char *)p, sz);
455 if (!sz)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 break;
Wu Fengguang80ad89a2009-12-14 17:58:10 -0800457 if (copy_to_user(buf, kbuf, sz)) {
KAMEZAWA Hiroyuki325fda72010-02-02 13:44:05 -0800458 err = -EFAULT;
459 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 }
Wu Fengguang80ad89a2009-12-14 17:58:10 -0800461 count -= sz;
462 buf += sz;
463 read += sz;
464 p += sz;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 }
466 free_page((unsigned long)kbuf);
467 }
KAMEZAWA Hiroyuki325fda72010-02-02 13:44:05 -0800468 *ppos = p;
469 return read ? read : err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470}
471
472
Andrew Mortond7d4d842010-03-10 15:21:52 -0800473static ssize_t do_write_kmem(unsigned long p, const char __user *buf,
474 size_t count, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475{
476 ssize_t written, sz;
477 unsigned long copied;
478
479 written = 0;
480#ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED
481 /* we don't have page 0 mapped on sparc and m68k.. */
Wu Fengguangee323982009-12-14 17:58:10 -0800482 if (p < PAGE_SIZE) {
483 sz = size_inside_page(p, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 /* Hmm. Do something? */
485 buf += sz;
486 p += sz;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 count -= sz;
488 written += sz;
489 }
490#endif
491
492 while (count > 0) {
493 char *ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
Wu Fengguangee323982009-12-14 17:58:10 -0800495 sz = size_inside_page(p, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496
497 /*
Andrew Mortond7d4d842010-03-10 15:21:52 -0800498 * On ia64 if a page has been mapped somewhere as uncached, then
499 * it must also be accessed uncached by the kernel or data
500 * corruption may occur.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 */
Wu Fengguangee323982009-12-14 17:58:10 -0800502 ptr = xlate_dev_kmem_ptr((char *)p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
504 copied = copy_from_user(ptr, buf, sz);
505 if (copied) {
Jan Beulichc654d602006-03-25 03:07:31 -0800506 written += sz - copied;
507 if (written)
508 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 return -EFAULT;
510 }
511 buf += sz;
512 p += sz;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 count -= sz;
514 written += sz;
515 }
516
517 *ppos += written;
518 return written;
519}
520
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521/*
522 * This function writes to the *virtual* memory as seen by the kernel.
523 */
Andrew Mortond7d4d842010-03-10 15:21:52 -0800524static ssize_t write_kmem(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 size_t count, loff_t *ppos)
526{
527 unsigned long p = *ppos;
528 ssize_t wrote = 0;
529 ssize_t virtr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 char * kbuf; /* k-addr because vwrite() takes vmlist_lock rwlock */
KAMEZAWA Hiroyuki325fda72010-02-02 13:44:05 -0800531 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
533 if (p < (unsigned long) high_memory) {
Wu Fengguang80ad89a2009-12-14 17:58:10 -0800534 unsigned long to_write = min_t(unsigned long, count,
535 (unsigned long)high_memory - p);
Wu Fengguangee323982009-12-14 17:58:10 -0800536 wrote = do_write_kmem(p, buf, to_write, ppos);
Wu Fengguang80ad89a2009-12-14 17:58:10 -0800537 if (wrote != to_write)
538 return wrote;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 p += wrote;
540 buf += wrote;
541 count -= wrote;
542 }
543
544 if (count > 0) {
545 kbuf = (char *)__get_free_page(GFP_KERNEL);
546 if (!kbuf)
547 return wrote ? wrote : -ENOMEM;
548 while (count > 0) {
Wu Fengguang80ad89a2009-12-14 17:58:10 -0800549 unsigned long sz = size_inside_page(p, count);
550 unsigned long n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
KAMEZAWA Hiroyuki325fda72010-02-02 13:44:05 -0800552 if (!is_vmalloc_or_module_addr((void *)p)) {
553 err = -ENXIO;
554 break;
555 }
Wu Fengguang80ad89a2009-12-14 17:58:10 -0800556 n = copy_from_user(kbuf, buf, sz);
557 if (n) {
KAMEZAWA Hiroyuki325fda72010-02-02 13:44:05 -0800558 err = -EFAULT;
559 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 }
Wu Fengguangc85e9a92010-02-02 13:44:06 -0800561 vwrite(kbuf, (char *)p, sz);
Wu Fengguang80ad89a2009-12-14 17:58:10 -0800562 count -= sz;
563 buf += sz;
564 virtr += sz;
565 p += sz;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 }
567 free_page((unsigned long)kbuf);
568 }
569
KAMEZAWA Hiroyuki325fda72010-02-02 13:44:05 -0800570 *ppos = p;
571 return virtr + wrote ? : err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572}
Arjan van de Venb781ecb2008-04-29 00:58:34 -0700573#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574
Russell King4f911d62007-05-08 00:28:17 -0700575#ifdef CONFIG_DEVPORT
Andrew Mortond7d4d842010-03-10 15:21:52 -0800576static ssize_t read_port(struct file *file, char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 size_t count, loff_t *ppos)
578{
579 unsigned long i = *ppos;
580 char __user *tmp = buf;
581
582 if (!access_ok(VERIFY_WRITE, buf, count))
Andrew Mortond7d4d842010-03-10 15:21:52 -0800583 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 while (count-- > 0 && i < 65536) {
Andrew Mortond7d4d842010-03-10 15:21:52 -0800585 if (__put_user(inb(i), tmp) < 0)
586 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 i++;
588 tmp++;
589 }
590 *ppos = i;
591 return tmp-buf;
592}
593
Andrew Mortond7d4d842010-03-10 15:21:52 -0800594static ssize_t write_port(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 size_t count, loff_t *ppos)
596{
597 unsigned long i = *ppos;
598 const char __user * tmp = buf;
599
Andrew Mortond7d4d842010-03-10 15:21:52 -0800600 if (!access_ok(VERIFY_READ, buf, count))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 return -EFAULT;
602 while (count-- > 0 && i < 65536) {
603 char c;
Jan Beulichc654d602006-03-25 03:07:31 -0800604 if (__get_user(c, tmp)) {
605 if (tmp > buf)
606 break;
Andrew Mortond7d4d842010-03-10 15:21:52 -0800607 return -EFAULT;
Jan Beulichc654d602006-03-25 03:07:31 -0800608 }
Andrew Mortond7d4d842010-03-10 15:21:52 -0800609 outb(c, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 i++;
611 tmp++;
612 }
613 *ppos = i;
614 return tmp-buf;
615}
616#endif
617
Andrew Mortond7d4d842010-03-10 15:21:52 -0800618static ssize_t read_null(struct file *file, char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 size_t count, loff_t *ppos)
620{
621 return 0;
622}
623
Andrew Mortond7d4d842010-03-10 15:21:52 -0800624static ssize_t write_null(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 size_t count, loff_t *ppos)
626{
627 return count;
628}
629
Jens Axboe1ebd32f2006-04-26 14:40:08 +0200630static int pipe_to_null(struct pipe_inode_info *info, struct pipe_buffer *buf,
631 struct splice_desc *sd)
632{
633 return sd->len;
634}
635
Andrew Mortond7d4d842010-03-10 15:21:52 -0800636static ssize_t splice_write_null(struct pipe_inode_info *pipe, struct file *out,
Jens Axboe1ebd32f2006-04-26 14:40:08 +0200637 loff_t *ppos, size_t len, unsigned int flags)
638{
639 return splice_from_pipe(pipe, out, ppos, len, flags, pipe_to_null);
640}
641
Andrew Mortond7d4d842010-03-10 15:21:52 -0800642static ssize_t read_zero(struct file *file, char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 size_t count, loff_t *ppos)
644{
Nick Piggin557ed1f2007-10-16 01:24:40 -0700645 size_t written;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
647 if (!count)
648 return 0;
649
650 if (!access_ok(VERIFY_WRITE, buf, count))
651 return -EFAULT;
652
Nick Piggin557ed1f2007-10-16 01:24:40 -0700653 written = 0;
654 while (count) {
655 unsigned long unwritten;
656 size_t chunk = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
Nick Piggin557ed1f2007-10-16 01:24:40 -0700658 if (chunk > PAGE_SIZE)
659 chunk = PAGE_SIZE; /* Just for latency reasons */
Nikanth Karthikesanbb521c52009-09-23 15:57:09 -0700660 unwritten = __clear_user(buf, chunk);
Nick Piggin557ed1f2007-10-16 01:24:40 -0700661 written += chunk - unwritten;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 if (unwritten)
Nick Piggin557ed1f2007-10-16 01:24:40 -0700663 break;
Linus Torvalds2b838682009-06-09 20:40:25 -0700664 if (signal_pending(current))
665 return written ? written : -ERESTARTSYS;
Nick Piggin557ed1f2007-10-16 01:24:40 -0700666 buf += chunk;
667 count -= chunk;
668 cond_resched();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 return written ? written : -EFAULT;
671}
672
Andrew Mortond7d4d842010-03-10 15:21:52 -0800673static int mmap_zero(struct file *file, struct vm_area_struct *vma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674{
Nick Piggin557ed1f2007-10-16 01:24:40 -0700675#ifndef CONFIG_MMU
676 return -ENOSYS;
677#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 if (vma->vm_flags & VM_SHARED)
679 return shmem_zero_setup(vma);
Nick Piggin557ed1f2007-10-16 01:24:40 -0700680 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682
Andrew Mortond7d4d842010-03-10 15:21:52 -0800683static ssize_t write_full(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 size_t count, loff_t *ppos)
685{
686 return -ENOSPC;
687}
688
689/*
690 * Special lseek() function for /dev/null and /dev/zero. Most notably, you
691 * can fopen() both devices with "a" now. This was previously impossible.
692 * -- SRB.
693 */
Andrew Mortond7d4d842010-03-10 15:21:52 -0800694static loff_t null_lseek(struct file *file, loff_t offset, int orig)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695{
696 return file->f_pos = 0;
697}
698
699/*
700 * The memory devices use the full 32/64 bits of the offset, and so we cannot
701 * check against negative addresses: they are ok. The return value is weird,
702 * though, in that case (0).
703 *
704 * also note that seeking relative to the "end of file" isn't supported:
705 * it has no meaning, so it returns -EINVAL.
706 */
Andrew Mortond7d4d842010-03-10 15:21:52 -0800707static loff_t memory_lseek(struct file *file, loff_t offset, int orig)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708{
709 loff_t ret;
710
Josef Sipeka7113a92006-12-08 02:36:55 -0800711 mutex_lock(&file->f_path.dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 switch (orig) {
Andrew Mortond7d4d842010-03-10 15:21:52 -0800713 case SEEK_CUR:
714 offset += file->f_pos;
Andrew Mortond7d4d842010-03-10 15:21:52 -0800715 case SEEK_SET:
716 /* to avoid userland mistaking f_pos=-9 as -EBADF=-9 */
717 if ((unsigned long long)offset >= ~0xFFFULL) {
718 ret = -EOVERFLOW;
719 break;
720 }
721 file->f_pos = offset;
722 ret = file->f_pos;
723 force_successful_syscall_return();
724 break;
725 default:
726 ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 }
Josef Sipeka7113a92006-12-08 02:36:55 -0800728 mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 return ret;
730}
731
732static int open_port(struct inode * inode, struct file * filp)
733{
734 return capable(CAP_SYS_RAWIO) ? 0 : -EPERM;
735}
736
737#define zero_lseek null_lseek
738#define full_lseek null_lseek
739#define write_zero write_null
740#define read_full read_zero
741#define open_mem open_port
742#define open_kmem open_mem
Vivek Goyal50b1fdb2005-06-25 14:58:23 -0700743#define open_oldmem open_mem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
Arjan van de Ven62322d22006-07-03 00:24:21 -0700745static const struct file_operations mem_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 .llseek = memory_lseek,
747 .read = read_mem,
748 .write = write_mem,
749 .mmap = mmap_mem,
750 .open = open_mem,
David Howells5da61852006-09-27 01:50:16 -0700751 .get_unmapped_area = get_unmapped_area_mem,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752};
753
Arjan van de Venb781ecb2008-04-29 00:58:34 -0700754#ifdef CONFIG_DEVKMEM
Arjan van de Ven62322d22006-07-03 00:24:21 -0700755static const struct file_operations kmem_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 .llseek = memory_lseek,
757 .read = read_kmem,
758 .write = write_kmem,
759 .mmap = mmap_kmem,
760 .open = open_kmem,
David Howells5da61852006-09-27 01:50:16 -0700761 .get_unmapped_area = get_unmapped_area_mem,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762};
Arjan van de Venb781ecb2008-04-29 00:58:34 -0700763#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
Arjan van de Ven62322d22006-07-03 00:24:21 -0700765static const struct file_operations null_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 .llseek = null_lseek,
767 .read = read_null,
768 .write = write_null,
Jens Axboe1ebd32f2006-04-26 14:40:08 +0200769 .splice_write = splice_write_null,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770};
771
Russell King4f911d62007-05-08 00:28:17 -0700772#ifdef CONFIG_DEVPORT
Arjan van de Ven62322d22006-07-03 00:24:21 -0700773static const struct file_operations port_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 .llseek = memory_lseek,
775 .read = read_port,
776 .write = write_port,
777 .open = open_port,
778};
779#endif
780
Arjan van de Ven62322d22006-07-03 00:24:21 -0700781static const struct file_operations zero_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 .llseek = zero_lseek,
783 .read = read_zero,
784 .write = write_zero,
785 .mmap = mmap_zero,
786};
787
David Howells5da61852006-09-27 01:50:16 -0700788/*
789 * capabilities for /dev/zero
790 * - permits private mappings, "copies" are taken of the source of zeros
Jan Kara371d2172010-09-21 11:49:01 +0200791 * - no writeback happens
David Howells5da61852006-09-27 01:50:16 -0700792 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793static struct backing_dev_info zero_bdi = {
Jens Axboed9938312009-06-12 14:45:52 +0200794 .name = "char/mem",
Jan Kara371d2172010-09-21 11:49:01 +0200795 .capabilities = BDI_CAP_MAP_COPY | BDI_CAP_NO_ACCT_AND_WRITEBACK,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796};
797
Arjan van de Ven62322d22006-07-03 00:24:21 -0700798static const struct file_operations full_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 .llseek = full_lseek,
800 .read = read_full,
801 .write = write_full,
802};
803
Vivek Goyal50b1fdb2005-06-25 14:58:23 -0700804#ifdef CONFIG_CRASH_DUMP
Arjan van de Ven62322d22006-07-03 00:24:21 -0700805static const struct file_operations oldmem_fops = {
Vivek Goyal50b1fdb2005-06-25 14:58:23 -0700806 .read = read_oldmem,
807 .open = open_oldmem,
808};
809#endif
810
Andrew Mortond7d4d842010-03-10 15:21:52 -0800811static ssize_t kmsg_write(struct file *file, const char __user *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 size_t count, loff_t *ppos)
813{
814 char *tmp;
Guillaume Chazaraincd140a52006-01-08 01:02:43 -0800815 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816
817 tmp = kmalloc(count + 1, GFP_KERNEL);
818 if (tmp == NULL)
819 return -ENOMEM;
820 ret = -EFAULT;
821 if (!copy_from_user(tmp, buf, count)) {
822 tmp[count] = 0;
823 ret = printk("%s", tmp);
Guillaume Chazaraincd140a52006-01-08 01:02:43 -0800824 if (ret > count)
825 /* printk can add a prefix */
826 ret = count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 }
828 kfree(tmp);
829 return ret;
830}
831
Arjan van de Ven62322d22006-07-03 00:24:21 -0700832static const struct file_operations kmsg_fops = {
Andrew Mortond7d4d842010-03-10 15:21:52 -0800833 .write = kmsg_write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834};
835
Kay Sievers389e0cb2009-07-04 16:51:29 +0200836static const struct memdev {
837 const char *name;
Kay Sieverse454cea2009-09-18 23:01:12 +0200838 mode_t mode;
Kay Sievers389e0cb2009-07-04 16:51:29 +0200839 const struct file_operations *fops;
840 struct backing_dev_info *dev_info;
841} devlist[] = {
Kay Sieverse454cea2009-09-18 23:01:12 +0200842 [1] = { "mem", 0, &mem_fops, &directly_mappable_cdev_bdi },
Adriano dos Santos Fernandesd6f47be2009-06-17 16:27:48 -0700843#ifdef CONFIG_DEVKMEM
Kay Sieverse454cea2009-09-18 23:01:12 +0200844 [2] = { "kmem", 0, &kmem_fops, &directly_mappable_cdev_bdi },
Adriano dos Santos Fernandesd6f47be2009-06-17 16:27:48 -0700845#endif
Kay Sieverse454cea2009-09-18 23:01:12 +0200846 [3] = { "null", 0666, &null_fops, NULL },
Adriano dos Santos Fernandesd6f47be2009-06-17 16:27:48 -0700847#ifdef CONFIG_DEVPORT
Kay Sieverse454cea2009-09-18 23:01:12 +0200848 [4] = { "port", 0, &port_fops, NULL },
Adriano dos Santos Fernandesd6f47be2009-06-17 16:27:48 -0700849#endif
Kay Sieverse454cea2009-09-18 23:01:12 +0200850 [5] = { "zero", 0666, &zero_fops, &zero_bdi },
851 [7] = { "full", 0666, &full_fops, NULL },
852 [8] = { "random", 0666, &random_fops, NULL },
853 [9] = { "urandom", 0666, &urandom_fops, NULL },
854 [11] = { "kmsg", 0, &kmsg_fops, NULL },
Adriano dos Santos Fernandesd6f47be2009-06-17 16:27:48 -0700855#ifdef CONFIG_CRASH_DUMP
Kay Sieverse454cea2009-09-18 23:01:12 +0200856 [12] = { "oldmem", 0, &oldmem_fops, NULL },
Adriano dos Santos Fernandesd6f47be2009-06-17 16:27:48 -0700857#endif
858};
859
860static int memory_open(struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861{
Kay Sievers389e0cb2009-07-04 16:51:29 +0200862 int minor;
863 const struct memdev *dev;
Adriano dos Santos Fernandesd6f47be2009-06-17 16:27:48 -0700864
Kay Sievers389e0cb2009-07-04 16:51:29 +0200865 minor = iminor(inode);
866 if (minor >= ARRAY_SIZE(devlist))
Frederic Weisbecker205153a2009-10-09 20:31:02 +0200867 return -ENXIO;
Adriano dos Santos Fernandesd6f47be2009-06-17 16:27:48 -0700868
Kay Sievers389e0cb2009-07-04 16:51:29 +0200869 dev = &devlist[minor];
870 if (!dev->fops)
Frederic Weisbecker205153a2009-10-09 20:31:02 +0200871 return -ENXIO;
Adriano dos Santos Fernandesd6f47be2009-06-17 16:27:48 -0700872
Kay Sievers389e0cb2009-07-04 16:51:29 +0200873 filp->f_op = dev->fops;
874 if (dev->dev_info)
875 filp->f_mapping->backing_dev_info = dev->dev_info;
876
877 if (dev->fops->open)
Frederic Weisbecker205153a2009-10-09 20:31:02 +0200878 return dev->fops->open(inode, filp);
879
880 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881}
882
Arjan van de Ven62322d22006-07-03 00:24:21 -0700883static const struct file_operations memory_fops = {
Andrew Mortond7d4d842010-03-10 15:21:52 -0800884 .open = memory_open,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885};
886
Kay Sieverse454cea2009-09-18 23:01:12 +0200887static char *mem_devnode(struct device *dev, mode_t *mode)
888{
889 if (mode && devlist[MINOR(dev->devt)].mode)
890 *mode = devlist[MINOR(dev->devt)].mode;
891 return NULL;
892}
893
gregkh@suse.deca8eca62005-03-23 09:53:09 -0800894static struct class *mem_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895
896static int __init chr_dev_init(void)
897{
Kay Sievers389e0cb2009-07-04 16:51:29 +0200898 int minor;
Peter Zijlstrae0bf68d2007-10-16 23:25:46 -0700899 int err;
900
901 err = bdi_init(&zero_bdi);
902 if (err)
903 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904
Andrew Mortond7d4d842010-03-10 15:21:52 -0800905 if (register_chrdev(MEM_MAJOR, "mem", &memory_fops))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 printk("unable to get major %d for memory devs\n", MEM_MAJOR);
907
gregkh@suse.deca8eca62005-03-23 09:53:09 -0800908 mem_class = class_create(THIS_MODULE, "mem");
Anton Blanchard6e191f72010-04-06 14:34:55 -0700909 if (IS_ERR(mem_class))
910 return PTR_ERR(mem_class);
911
Kay Sieverse454cea2009-09-18 23:01:12 +0200912 mem_class->devnode = mem_devnode;
Kay Sievers389e0cb2009-07-04 16:51:29 +0200913 for (minor = 1; minor < ARRAY_SIZE(devlist); minor++) {
914 if (!devlist[minor].name)
915 continue;
916 device_create(mem_class, NULL, MKDEV(MEM_MAJOR, minor),
917 NULL, devlist[minor].name);
918 }
Greg Kroah-Hartmanebf644c2006-07-25 17:13:31 -0700919
David Howells31d1d482010-08-06 16:34:43 +0100920 return tty_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921}
922
923fs_initcall(chr_dev_init);