2 * Copyright (c) 2004 Apple Computer, Inc. All rights reserved.
4 * @APPLE_LICENSE_HEADER_START@
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. Please obtain a copy of the License at
10 * http://www.opensource.apple.com/apsl/ and read it before using this
13 * The Original Code and all software distributed under the License are
14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
18 * Please see the License for the specific language governing rights and
19 * limitations under the License.
21 * @APPLE_LICENSE_HEADER_END@
24 * Copyright (c) 1988 University of Utah.
25 * Copyright (c) 1990, 1993
26 * The Regents of the University of California. All rights reserved.
28 * This code is derived from software contributed to Berkeley by
29 * the Systems Programming Group of the University of Utah Computer
32 * Redistribution and use in source and binary forms, with or without
33 * modification, are permitted provided that the following conditions
35 * 1. Redistributions of source code must retain the above copyright
36 * notice, this list of conditions and the following disclaimer.
37 * 2. Redistributions in binary form must reproduce the above copyright
38 * notice, this list of conditions and the following disclaimer in the
39 * documentation and/or other materials provided with the distribution.
40 * 3. All advertising materials mentioning features or use of this software
41 * must display the following acknowledgement:
42 * This product includes software developed by the University of
43 * California, Berkeley and its contributors.
44 * 4. Neither the name of the University nor the names of its contributors
45 * may be used to endorse or promote products derived from this software
46 * without specific prior written permission.
48 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
60 * from: Utah Hdr: vn.c 1.13 94/04/02
62 * from: @(#)vn.c 8.6 (Berkeley) 4/1/94
63 * $FreeBSD: src/sys/dev/vn/vn.c,v 1.105.2.4 2001/11/18 07:11:00 dillon Exp $
69 * Block interface to a ramdisk.
73 #include <sys/param.h>
74 #include <sys/kernel.h>
75 #include <sys/mount.h>
76 #include <sys/namei.h>
79 #include <sys/malloc.h>
80 #include <sys/mount.h>
81 #include <sys/fcntl.h>
86 #include <sys/uio_internal.h>
87 #include <libkern/libkern.h>
90 #include <vm/vm_pager.h>
91 #include <mach/memory_object_types.h>
93 #include <miscfs/devfs/devfs.h>
96 void mdevinit(int the_cnt
);
98 static open_close_fcn_t mdevopen
;
99 static open_close_fcn_t mdevclose
;
100 static psize_fcn_t mdevsize
;
101 static strategy_fcn_t mdevstrategy
;
102 static int mdevbioctl(dev_t dev
, u_long cmd
, caddr_t data
, int flag
, struct proc
*p
);
103 static int mdevcioctl(dev_t dev
, u_long cmd
, caddr_t data
, int flag
, struct proc
*p
);
104 static int mdevrw(dev_t dev
, struct uio
*uio
, int ioflag
);
105 static char * nonspace(char *pos
, char *end
);
106 static char * getspace(char *pos
, char *end
);
107 static char * cvtnum(char *pos
, char *end
, unsigned int *num
);
109 extern void bcopy_phys(addr64_t from
, addr64_t to
, vm_size_t bytes
);
110 extern void mapping_set_mod(ppnum_t pn
);
111 extern ppnum_t
pmap_find_phys(pmap_t pmap
, addr64_t va
);
116 * D_DISK we want to look like a disk
117 * D_CANFREE We support B_FREEBUF
120 static struct bdevsw mdevbdevsw
= {
122 /* close */ mdevclose
,
123 /* strategy */ mdevstrategy
,
124 /* ioctl */ mdevbioctl
,
126 /* psize */ mdevsize
,
130 static struct cdevsw mdevcdevsw
= {
132 /* close */ mdevclose
,
135 /* ioctl */ mdevcioctl
,
137 /* reset */ eno_reset
,
139 /* select */ eno_select
,
141 /* strategy */ eno_strat
,
148 vm_offset_t mdBase
; /* file size in bytes */
149 uint32_t mdSize
; /* file size in bytes */
150 int mdFlags
; /* flags */
151 int mdSecsize
; /* sector size */
152 int mdBDev
; /* Block device number */
153 int mdCDev
; /* Character device number */
159 #define mdInited 0x01 /* This device defined */
160 #define mdRO 0x02 /* This device is read-only */
161 #define mdPhys 0x04 /* This device is in physical memory */
166 static int mdevioctl(dev_t dev
, u_long cmd
, caddr_t data
, int flag
, struct proc
*p
, int is_char
);
167 dev_t
mdevadd(int devid
, ppnum_t base
, unsigned int size
, int phys
);
168 dev_t
mdevlookup(int devid
);
170 static int mdevclose(__unused dev_t dev
, __unused
int flags
,
171 __unused
int devtype
, __unused
struct proc
*p
) {
176 static int mdevopen(dev_t dev
, int flags
, __unused
int devtype
, __unused
struct proc
*p
) {
180 devid
= minor(dev
); /* Get minor device number */
182 if (devid
> 16) return (ENXIO
); /* Not valid */
184 if ((flags
& FWRITE
) && (mdev
[devid
].mdFlags
& mdRO
)) return (EACCES
); /* Currently mounted RO */
189 static int mdevrw(dev_t dev
, struct uio
*uio
, __unused
int ioflag
) {
193 enum uio_seg saveflag
;
195 devid
= minor(dev
); /* Get minor device number */
197 if (devid
> 16) return (ENXIO
); /* Not valid */
198 if (!(mdev
[devid
].mdFlags
& mdInited
)) return (ENXIO
); /* Have we actually been defined yet? */
200 mdata
= ((addr64_t
)mdev
[devid
].mdBase
<< 12) + uio
->uio_offset
; /* Point to the area in "file" */
202 saveflag
= uio
->uio_segflg
; /* Remember what the request is */
204 if (IS_VALID_UIO_SEGFLG(uio
->uio_segflg
) == 0) {
205 panic("mdevrw - invalid uio_segflg\n");
207 #endif /* LP64_DEBUG */
208 /* Make sure we are moving from physical ram if physical device */
209 if (mdev
[devid
].mdFlags
& mdPhys
) {
210 if (uio
->uio_segflg
== UIO_USERSPACE64
)
211 uio
->uio_segflg
= UIO_PHYS_USERSPACE64
;
212 else if (uio
->uio_segflg
== UIO_USERSPACE32
)
213 uio
->uio_segflg
= UIO_PHYS_USERSPACE32
;
215 uio
->uio_segflg
= UIO_PHYS_USERSPACE
;
217 status
= uiomove64(mdata
, uio_resid(uio
), uio
); /* Move the data */
218 uio
->uio_segflg
= saveflag
; /* Restore the flag */
223 static void mdevstrategy(struct buf
*bp
) {
224 unsigned int left
, lop
, csize
;
225 vm_offset_t vaddr
, blkoff
;
227 addr64_t paddr
, fvaddr
;
230 devid
= minor(buf_device(bp
)); /* Get minor device number */
232 if ((mdev
[devid
].mdFlags
& mdInited
) == 0) { /* Have we actually been defined yet? */
233 buf_seterror(bp
, ENXIO
);
238 buf_setresid(bp
, buf_count(bp
)); /* Set byte count */
240 blkoff
= buf_blkno(bp
) * mdev
[devid
].mdSecsize
; /* Get offset into file */
243 * Note that reading past end is an error, but reading at end is an EOF. For these
244 * we just return with resid == count.
247 if (blkoff
>= (mdev
[devid
].mdSize
<< 12)) { /* Are they trying to read/write at/after end? */
248 if(blkoff
!= (mdev
[devid
].mdSize
<< 12)) { /* Are we trying to read after EOF? */
249 buf_seterror(bp
, EINVAL
); /* Yeah, this is an error */
251 buf_biodone(bp
); /* Return */
255 if ((blkoff
+ buf_count(bp
)) > (mdev
[devid
].mdSize
<< 12)) { /* Will this read go past end? */
256 buf_setcount(bp
, ((mdev
[devid
].mdSize
<< 12) - blkoff
)); /* Yes, trim to max */
259 * make sure the buffer's data area is
262 if (buf_map(bp
, (caddr_t
*)&vaddr
))
263 panic("ramstrategy: buf_map failed\n");
265 fvaddr
= (mdev
[devid
].mdBase
<< 12) + blkoff
; /* Point to offset into ram disk */
267 if (buf_flags(bp
) & B_READ
) { /* Is this a read? */
268 if(!(mdev
[devid
].mdFlags
& mdPhys
)) { /* Physical mapped disk? */
269 bcopy((void *)((uintptr_t)fvaddr
),
270 (void *)vaddr
, (size_t)buf_count(bp
)); /* This is virtual, just get the data */
273 left
= buf_count(bp
); /* Init the amount left to copy */
274 while(left
) { /* Go until it is all copied */
276 lop
= min((4096 - (vaddr
& 4095)), (4096 - (fvaddr
& 4095))); /* Get smallest amount left on sink and source */
277 csize
= min(lop
, left
); /* Don't move more than we need to */
279 pp
= pmap_find_phys(kernel_pmap
, (addr64_t
)((unsigned int)vaddr
)); /* Get the sink physical address */
280 if(!pp
) { /* Not found, what gives? */
281 panic("mdevstrategy: sink address %016llX not mapped\n", (addr64_t
)((unsigned int)vaddr
));
283 paddr
= (addr64_t
)(((addr64_t
)pp
<< 12) | (addr64_t
)(vaddr
& 4095)); /* Get actual address */
284 bcopy_phys(fvaddr
, paddr
, csize
); /* Copy this on in */
285 mapping_set_mod(paddr
>> 12); /* Make sure we know that it is modified */
287 left
= left
- csize
; /* Calculate what is left */
288 vaddr
= vaddr
+ csize
; /* Move to next sink address */
289 fvaddr
= fvaddr
+ csize
; /* Bump to next physical address */
293 else { /* This is a write */
294 if(!(mdev
[devid
].mdFlags
& mdPhys
)) { /* Physical mapped disk? */
295 bcopy((void *)vaddr
, (void *)((uintptr_t)fvaddr
),
296 (size_t)buf_count(bp
)); /* This is virtual, just put the data */
299 left
= buf_count(bp
); /* Init the amount left to copy */
300 while(left
) { /* Go until it is all copied */
302 lop
= min((4096 - (vaddr
& 4095)), (4096 - (fvaddr
& 4095))); /* Get smallest amount left on sink and source */
303 csize
= min(lop
, left
); /* Don't move more than we need to */
305 pp
= pmap_find_phys(kernel_pmap
, (addr64_t
)((unsigned int)vaddr
)); /* Get the source physical address */
306 if(!pp
) { /* Not found, what gives? */
307 panic("mdevstrategy: source address %016llX not mapped\n", (addr64_t
)((unsigned int)vaddr
));
309 paddr
= (addr64_t
)(((addr64_t
)pp
<< 12) | (addr64_t
)(vaddr
& 4095)); /* Get actual address */
311 bcopy_phys(paddr
, fvaddr
, csize
); /* Move this on out */
313 left
= left
- csize
; /* Calculate what is left */
314 vaddr
= vaddr
+ csize
; /* Move to next sink address */
315 fvaddr
= fvaddr
+ csize
; /* Bump to next physical address */
320 * buf_unmap takes care of all the cases
321 * it will unmap the buffer from kernel
322 * virtual space if that was the state
327 buf_setresid(bp
, 0); /* Nothing more to do */
328 buf_biodone(bp
); /* Say we've finished */
331 static int mdevbioctl(dev_t dev
, u_long cmd
, caddr_t data
, int flag
, struct proc
*p
) {
332 return (mdevioctl(dev
, cmd
, data
, flag
, p
, 0));
335 static int mdevcioctl(dev_t dev
, u_long cmd
, caddr_t data
, int flag
, struct proc
*p
) {
336 return (mdevioctl(dev
, cmd
, data
, flag
, p
, 1));
339 static int mdevioctl(dev_t dev
, u_long cmd
, caddr_t data
, __unused
int flag
,
340 struct proc
*p
, int is_char
) {
346 devid
= minor(dev
); /* Get minor device number */
348 if (devid
> 16) return (ENXIO
); /* Not valid */
350 error
= proc_suser(p
); /* Are we superman? */
351 if (error
) return (error
); /* Nope... */
354 o
= (u_int64_t
*)data
;
358 case DKIOCGETMAXBLOCKCOUNTREAD
:
362 case DKIOCGETMAXBLOCKCOUNTWRITE
:
366 case DKIOCGETMAXSEGMENTCOUNTREAD
:
370 case DKIOCGETMAXSEGMENTCOUNTWRITE
:
374 case DKIOCGETBLOCKSIZE
:
375 *f
= mdev
[devid
].mdSecsize
;
378 case DKIOCSETBLOCKSIZE
:
379 if (is_char
) return (ENODEV
); /* We can only do this for a block */
381 if (*f
< DEV_BSIZE
) return (EINVAL
); /* Too short? */
383 mdev
[devid
].mdSecsize
= *f
; /* set the new block size */
386 case DKIOCISWRITABLE
:
390 case DKIOCGETBLOCKCOUNT32
:
391 if(!(mdev
[devid
].mdFlags
& mdInited
)) return (ENXIO
);
392 *f
= ((mdev
[devid
].mdSize
<< 12) + mdev
[devid
].mdSecsize
- 1) / mdev
[devid
].mdSecsize
;
395 case DKIOCGETBLOCKCOUNT
:
396 if(!(mdev
[devid
].mdFlags
& mdInited
)) return (ENXIO
);
397 *o
= ((mdev
[devid
].mdSize
<< 12) + mdev
[devid
].mdSecsize
- 1) / mdev
[devid
].mdSecsize
;
408 static int mdevsize(dev_t dev
) {
412 devid
= minor(dev
); /* Get minor device number */
413 if (devid
> 16) return (ENXIO
); /* Not valid */
415 if ((mdev
[devid
].mdFlags
& mdInited
) == 0) return(-1); /* Not inited yet */
417 return(mdev
[devid
].mdSecsize
);
420 #include <pexpert/pexpert.h>
422 void mdevinit(__unused
int the_cnt
) {
431 ba
= PE_boot_args(); /* Get the boot arguments */
432 lp
= ba
+ 256; /* Point to the end */
434 while(1) { /* Step through, looking for our keywords */
435 phys
= 0; /* Assume virtual memory device */
436 ba
= nonspace(ba
, lp
); /* Find non-space */
437 if(ba
>= lp
) return; /* We are done if no more... */
438 if(((ba
[0] != 'v') && (ba
[0] != 'p'))
439 || (ba
[1] != 'm') || (ba
[2] != 'd') || (ba
[4] != '=')
440 || (ba
[3] < '0') || (ba
[3] > 'f')
441 || ((ba
[3] > '9') && (ba
[3] < 'a'))) { /* Is this of form "vmdx=" or "pmdx=" where x is hex digit? */
443 ba
= getspace(ba
, lp
); /* Find next white space or end */
444 continue; /* Start looking for the next one */
447 if(ba
[0] == 'p') phys
= 1; /* Set physical memory disk */
449 devid
= ba
[3] & 0xF; /* Assume digit */
450 if(ba
[3] > '9') devid
+= 9; /* Adjust for hex digits */
452 ba
= &ba
[5]; /* Step past keyword */
453 ba
= cvtnum(ba
, lp
, &base
); /* Convert base of memory disk */
454 if(ba
>= lp
) return; /* Malformed one at the end, leave */
455 if(ba
[0] != '.') continue; /* If not length separater, try next... */
456 if(base
& 0xFFF) continue; /* Only allow page aligned stuff */
458 ba
++; /* Step past '.' */
459 ba
= cvtnum(ba
, lp
, &size
); /* Try to convert it */
460 if(!size
|| (size
& 0xFFF)) continue; /* Allow only non-zer page size multiples */
461 if(ba
< lp
) { /* If we are not at end, check end character */
462 if((ba
[0] != ' ') && (ba
[0] != 0)) continue; /* End must be null or space */
465 dev
= mdevadd(devid
, base
>> 12, size
>> 12, phys
); /* Go add the device */
472 char *nonspace(char *pos
, char *end
) { /* Find next non-space in string */
474 if(pos
>= end
) return end
; /* Don't go past end */
475 if(pos
[0] == 0) return end
; /* If at null, make end */
477 while(1) { /* Keep going */
478 if(pos
[0] != ' ') return pos
; /* Leave if we found one */
480 if(pos
>= end
) return end
; /* Quit if we run off end */
484 char *getspace(char *pos
, char *end
) { /* Find next non-space in string */
486 while(1) { /* Keep going */
487 if(pos
>= end
) return end
; /* Don't go past end */
488 if(pos
[0] == 0) return end
; /* Leave if we hit null */
489 if(pos
[0] == ' ') return pos
; /* Leave if we found one */
494 char *cvtnum(char *pos
, char *end
, unsigned int *num
) { /* Convert to a number */
498 *num
= 0; /* Set answer to 0 to start */
501 if(pos
>= end
) return end
; /* Don't go past end */
502 if(pos
[0] == 0) return end
; /* If at null, make end */
504 if(pos
[0] == '0' && ((pos
[1] == 'x') || (pos
[1] == 'x'))) { /* A hex constant? */
506 pos
+= 2; /* Point to the number */
509 while(1) { /* Convert it */
511 if(pos
>= end
) return end
; /* Don't go past end */
512 if(pos
[0] == 0) return end
; /* If at null, make end */
513 if(pos
[0] < '0') return pos
; /* Leave if non-digit */
514 dig
= pos
[0] & 0xF; /* Extract digit */
515 if(pos
[0] > '9') { /* Is it bigger than 9? */
516 if(rad
== 10) return pos
; /* Leave if not base 10 */
517 if(!(((pos
[0] >= 'A') && (pos
[0] <= 'F'))
518 || ((pos
[0] >= 'a') && (pos
[0] <= 'f')))) return pos
; /* Leave if bogus char */
519 dig
= dig
+ 9; /* Adjust for character */
521 *num
= (*num
* rad
) + dig
; /* Accumulate the number */
526 dev_t
mdevadd(int devid
, ppnum_t base
, unsigned int size
, int phys
) {
533 for(i
= 0; i
< 16; i
++) { /* Search all known memory devices */
534 if(!(mdev
[i
].mdFlags
& mdInited
)) { /* Is this a free one? */
535 if(devid
< 0)devid
= i
; /* Remember first free one */
536 continue; /* Skip check */
538 if(!(((base
+ size
-1 ) < mdev
[i
].mdBase
) || ((mdev
[i
].mdBase
+ mdev
[i
].mdSize
- 1) < base
))) { /* Is there any overlap? */
539 panic("mdevadd: attempt to add overlapping memory device at %08X-%08X\n", mdev
[i
].mdBase
, mdev
[i
].mdBase
+ mdev
[i
].mdSize
- 1);
542 if(devid
< 0) { /* Do we have free slots? */
543 panic("mdevadd: attempt to add more than 16 memory devices\n");
547 if(devid
>= 16) { /* Giving us something bogus? */
548 panic("mdevadd: attempt to explicitly add a bogus memory device: &08X\n", devid
);
550 if(mdev
[devid
].mdFlags
&mdInited
) { /* Already there? */
551 panic("mdevadd: attempt to explicitly add a previously defined memory device: &08X\n", devid
);
555 if(mdevBMajor
< 0) { /* Have we gotten a major number yet? */
556 mdevBMajor
= bdevsw_add(-1, &mdevbdevsw
); /* Add to the table and figure out a major number */
557 if (mdevBMajor
< 0) {
558 printf("mdevadd: error - bdevsw_add() returned %d\n", mdevBMajor
);
563 if(mdevCMajor
< 0) { /* Have we gotten a major number yet? */
564 mdevCMajor
= cdevsw_add_with_bdev(-1, &mdevcdevsw
, mdevBMajor
); /* Add to the table and figure out a major number */
565 if (mdevCMajor
< 0) {
566 printf("ramdevice_init: error - cdevsw_add() returned %d\n", mdevCMajor
);
571 mdev
[devid
].mdBDev
= makedev(mdevBMajor
, devid
); /* Get the device number */
572 mdev
[devid
].mdbdevb
= devfs_make_node(mdev
[devid
].mdBDev
, DEVFS_BLOCK
, /* Make the node */
573 UID_ROOT
, GID_OPERATOR
,
574 0600, "md%d", devid
);
575 if (mdev
[devid
].mdbdevb
== NULL
) { /* Did we make one? */
576 printf("mdevadd: devfs_make_node for block failed!\n");
577 return -1; /* Nope... */
580 mdev
[devid
].mdCDev
= makedev(mdevCMajor
, devid
); /* Get the device number */
581 mdev
[devid
].mdcdevb
= devfs_make_node(mdev
[devid
].mdCDev
, DEVFS_CHAR
, /* Make the node */
582 UID_ROOT
, GID_OPERATOR
,
583 0600, "rmd%d", devid
);
584 if (mdev
[devid
].mdcdevb
== NULL
) { /* Did we make one? */
585 printf("mdevadd: devfs_make_node for character failed!\n");
586 return -1; /* Nope... */
589 mdev
[devid
].mdBase
= base
; /* Set the base address of ram disk */
590 mdev
[devid
].mdSize
= size
; /* Set the length of the ram disk */
591 mdev
[devid
].mdSecsize
= DEV_BSIZE
; /* Set starting block size */
592 if(phys
) mdev
[devid
].mdFlags
|= mdPhys
; /* Show that we are in physical memory */
593 mdev
[devid
].mdFlags
|= mdInited
; /* Show we are all set up */
594 printf("Added memory device md%x/rmd%x (%08X/%08X) at %08X for %08X\n",
595 devid
, devid
, mdev
[devid
].mdBDev
, mdev
[devid
].mdCDev
, base
<< 12, size
<< 12);
596 return mdev
[devid
].mdBDev
;
600 dev_t
mdevlookup(int devid
) {
602 if((devid
< 0) || (devid
> 15)) return -1; /* Filter any bogus requests */
603 if(!(mdev
[devid
].mdFlags
& mdInited
)) return -1; /* This one hasn't been defined */
604 return mdev
[devid
].mdBDev
; /* Return the device number */