drivers/memory/memory.c

   1 /* This file contains the device dependent part of the drivers for the
   2  * following special files:
   3  *     /dev/ram         - RAM disk
   4  *     /dev/mem         - absolute memory
   5  *     /dev/kmem        - kernel virtual memory
   6  *     /dev/null        - null device (data sink)
   7  *     /dev/boot        - boot device loaded from boot image
   8  *     /dev/zero        - null byte stream generator
   9  *     /dev/imgrd       - boot image RAM disk
  10  *
  11  *  Changes:
  12  *      Apr 29, 2005    added null byte generator  (Jorrit N. Herder)
  13  *      Apr 09, 2005    added support for boot device  (Jorrit N. Herder)
  14  *      Jul 26, 2004    moved RAM driver to user-space  (Jorrit N. Herder)
  15  *      Apr 20, 1992    device dependent/independent split  (Kees J. Bot)
  16  */
  17
  18 #include <assert.h>
  19 #include <minix/drivers.h>
  20 #include <minix/chardriver.h>
  21 #include <minix/blockdriver.h>
  22 #include <sys/ioc_memory.h>
  23 #include <minix/ds.h>
  24 #include <minix/vm.h>
  25 #include <machine/param.h>
  26 #include <sys/mman.h>
  27 #include "kernel/const.h"
  28 #include "kernel/config.h"
  29 #include "kernel/type.h"
  30
  31 #include <machine/vm.h>
  32
  33 #include "local.h"
  34
  35 /* ramdisks (/dev/ram*) */
  36 #define RAMDISKS     6
  37
  38 #define RAM_DEV_LAST (RAM_DEV_FIRST+RAMDISKS-1)
  39
  40 #define NR_DEVS            (7+RAMDISKS) /* number of minor devices */
  41
  42 static struct device m_geom[NR_DEVS];  /* base and size of each device */
  43 static vir_bytes m_vaddrs[NR_DEVS];
  44
  45 static int openct[NR_DEVS];
  46
  47 static ssize_t m_char_read(devminor_t minor, u64_t position, endpoint_t endpt,
  48         cp_grant_id_t grant, size_t size, int flags, cdev_id_t id);
  49 static ssize_t m_char_write(devminor_t minor, u64_t position, endpoint_t endpt,
  50         cp_grant_id_t grant, size_t size, int flags, cdev_id_t id);
  51 static int m_char_open(devminor_t minor, int access, endpoint_t user_endpt);
  52 static int m_char_close(devminor_t minor);
  53
  54 static struct device *m_block_part(devminor_t minor);
  55 static ssize_t m_block_transfer(devminor_t minor, int do_write, u64_t position,
  56         endpoint_t endpt, iovec_t *iov, unsigned int nr_req, int flags);
  57 static int m_block_open(devminor_t minor, int access);
  58 static int m_block_close(devminor_t minor);
  59 static int m_block_ioctl(devminor_t minor, unsigned long request, endpoint_t
  60         endpt, cp_grant_id_t grant, endpoint_t user_endpt);
  61
  62 /* Entry points to the CHARACTER part of this driver. */
  63 static struct chardriver m_cdtab = {
  64   .cdr_open     = m_char_open,          /* open device */
  65   .cdr_close    = m_char_close,         /* close device */
  66   .cdr_read     = m_char_read,          /* read from device */
  67   .cdr_write    = m_char_write          /* write to device */
  68 };
  69
  70 /* Entry points to the BLOCK part of this driver. */
  71 static struct blockdriver m_bdtab = {
  72   .bdr_type     = BLOCKDRIVER_TYPE_DISK,/* handle partition requests */
  73   .bdr_open     = m_block_open,         /* open device */
  74   .bdr_close    = m_block_close,        /* nothing on a close */
  75   .bdr_transfer = m_block_transfer,     /* do the I/O */
  76   .bdr_ioctl    = m_block_ioctl,        /* ram disk I/O control */
  77   .bdr_part     = m_block_part          /* return partition information */
  78 };
  79
  80 /* SEF functions and variables. */
  81 static void sef_local_startup(void);
  82 static int sef_cb_init_fresh(int type, sef_init_info_t *info);
  83
  84 /*===========================================================================*
  85  *                                 main                                      *
  86  *===========================================================================*/
  87 int main(void)
  88 {
  89   message msg;
  90   int r, ipc_status;
  91
  92   /* SEF local startup. */
  93   sef_local_startup();
  94
  95   /* The receive loop. */
  96   for (;;) {
  97         if ((r = driver_receive(ANY, &msg, &ipc_status)) != OK)
  98                 panic("memory: driver_receive failed (%d)", r);
  99
 100         if (IS_BDEV_RQ(msg.m_type))
 101                 blockdriver_process(&m_bdtab, &msg, ipc_status);
 102         else
 103                 chardriver_process(&m_cdtab, &msg, ipc_status);
 104   }
 105
 106   return(OK);
 107 }
 108
 109 /*===========================================================================*
 110  *                             sef_local_startup                             *
 111  *===========================================================================*/
 112 static void sef_local_startup()
 113 {
 114   /* Register init callbacks. */
 115   sef_setcb_init_fresh(sef_cb_init_fresh);
 116   sef_setcb_init_lu(sef_cb_init_fresh);
 117   sef_setcb_init_restart(sef_cb_init_fresh);
 118
 119   /* Register live update callbacks. */
 120   sef_setcb_lu_prepare(sef_cb_lu_prepare_always_ready);
 121   sef_setcb_lu_state_isvalid(sef_cb_lu_state_isvalid_standard);
 122
 123   /* Let SEF perform startup. */
 124   sef_startup();
 125 }
 126
 127 /*===========================================================================*
 128  *                          sef_cb_init_fresh                                *
 129  *===========================================================================*/
 130 static int sef_cb_init_fresh(int UNUSED(type), sef_init_info_t *UNUSED(info))
 131 {
 132 /* Initialize the memory driver. */
 133   int i;
 134 #if 0
 135   struct kinfo kinfo;           /* kernel information */
 136   int s;
 137
 138   if (OK != (s=sys_getkinfo(&kinfo))) {
 139       panic("Couldn't get kernel information: %d", s);
 140   }
 141
 142   /* Map in kernel memory for /dev/kmem. */
 143   m_geom[KMEM_DEV].dv_base = kinfo.kmem_base;
 144   m_geom[KMEM_DEV].dv_size = kinfo.kmem_size;
 145   if((m_vaddrs[KMEM_DEV] = vm_map_phys(SELF, (void *) kinfo.kmem_base,
 146         kinfo.kmem_size)) == MAP_FAILED) {
 147         printf("MEM: Couldn't map in /dev/kmem.");
 148   }
 149 #endif
 150
 151   /* Ramdisk image built into the memory driver */
 152   m_geom[IMGRD_DEV].dv_base= 0;
 153   m_geom[IMGRD_DEV].dv_size= imgrd_size;
 154   m_vaddrs[IMGRD_DEV] = (vir_bytes) imgrd;
 155
 156   for(i = 0; i < NR_DEVS; i++)
 157         openct[i] = 0;
 158
 159   /* Set up memory range for /dev/mem. */
 160   m_geom[MEM_DEV].dv_base = 0;
 161   m_geom[MEM_DEV].dv_size = 0xffffffffULL;
 162
 163   m_vaddrs[MEM_DEV] = (vir_bytes) MAP_FAILED; /* we are not mapping this in. */
 164
 165   return(OK);
 166 }
 167
 168 /*===========================================================================*
 169  *                              m_is_block                                   *
 170  *===========================================================================*/
 171 static int m_is_block(devminor_t minor)
 172 {
 173 /* Return TRUE iff the given minor device number is for a block device. */
 174
 175   switch (minor) {
 176   case MEM_DEV:
 177   case KMEM_DEV:
 178   case NULL_DEV:
 179   case ZERO_DEV:
 180         return FALSE;
 181
 182   default:
 183         return TRUE;
 184   }
 185 }
 186
 187 /*===========================================================================*
 188  *                              m_transfer_kmem                              *
 189  *===========================================================================*/
 190 static ssize_t m_transfer_kmem(devminor_t minor, int do_write, u64_t position,
 191         endpoint_t endpt, cp_grant_id_t grant, size_t size)
 192 {
 193 /* Transfer from or to the KMEM device. */
 194   u64_t dv_size, dev_vaddr;
 195   int r;
 196
 197   dv_size = m_geom[minor].dv_size;
 198   dev_vaddr = m_vaddrs[minor];
 199
 200   if (!dev_vaddr || dev_vaddr == (vir_bytes) MAP_FAILED) {
 201         printf("MEM: dev %d not initialized\n", minor);
 202         return EIO;
 203   }
 204
 205   if (position >= dv_size) return 0;    /* check for EOF */
 206   if (position + size > dv_size) size = dv_size - position;
 207
 208   if (!do_write)                        /* copy actual data */
 209         r = sys_safecopyto(endpt, grant, 0, dev_vaddr + position, size);
 210   else
 211         r = sys_safecopyfrom(endpt, grant, 0, dev_vaddr + position, size);
 212
 213   return (r != OK) ? r : size;
 214 }
 215
 216 /*===========================================================================*
 217  *                              m_transfer_mem                               *
 218  *===========================================================================*/
 219 static ssize_t m_transfer_mem(devminor_t minor, int do_write, u64_t position,
 220         endpoint_t endpt, cp_grant_id_t grant, size_t size)
 221 {
 222 /* Transfer from or to the MEM device. */
 223   static int any_mapped = 0;
 224   static phys_bytes pagestart_mapped;
 225   static char *vaddr;
 226   phys_bytes mem_phys, pagestart;
 227   size_t off, page_off, subcount;
 228   u64_t dv_size;
 229   int r;
 230
 231   dv_size = m_geom[minor].dv_size;
 232   if (position >= dv_size) return 0;    /* check for EOF */
 233   if (position + size > dv_size) size = dv_size - position;
 234
 235   /* Physical copying. Only used to access entire memory.
 236    * Transfer one 'page window' at a time.
 237    */
 238   off = 0;
 239   while (off < size) {
 240         mem_phys = (phys_bytes) position;
 241
 242         page_off = (size_t) (mem_phys % PAGE_SIZE);
 243         pagestart = mem_phys - page_off;
 244
 245         /* All memory to the map call has to be page-aligned.
 246          * Don't have to map same page over and over.
 247          */
 248         if (!any_mapped || pagestart_mapped != pagestart) {
 249                 if (any_mapped) {
 250                         if (vm_unmap_phys(SELF, vaddr, PAGE_SIZE) != OK)
 251                                 panic("vm_unmap_phys failed");
 252                         any_mapped = 0;
 253                 }
 254
 255                 vaddr = vm_map_phys(SELF, (void *) pagestart, PAGE_SIZE);
 256                 if (vaddr == MAP_FAILED) {
 257                         printf("memory: vm_map_phys failed\n");
 258                         return ENOMEM;
 259                 }
 260                 any_mapped = 1;
 261                 pagestart_mapped = pagestart;
 262         }
 263
 264         /* how much to be done within this page. */
 265         subcount = PAGE_SIZE - page_off;
 266         if (subcount > size)
 267                 subcount = size;
 268
 269         if (!do_write)  /* copy data */
 270                 r = sys_safecopyto(endpt, grant, off,
 271                         (vir_bytes) vaddr + page_off, subcount);
 272         else
 273                 r = sys_safecopyfrom(endpt, grant, off,
 274                         (vir_bytes) vaddr + page_off, subcount);
 275         if (r != OK)
 276                 return r;
 277
 278         position += subcount;
 279         off += subcount;
 280   }
 281
 282   return off;
 283 }
 284
 285 /*===========================================================================*
 286  *                              m_char_read                                  *
 287  *===========================================================================*/
 288 static ssize_t m_char_read(devminor_t minor, u64_t position, endpoint_t endpt,
 289         cp_grant_id_t grant, size_t size, int UNUSED(flags),
 290         cdev_id_t UNUSED(id))
 291 {
 292 /* Read from one of the driver's character devices. */
 293   ssize_t r;
 294
 295   /* Check if the minor device number is ok. */
 296   if (minor < 0 || minor >= NR_DEVS || m_is_block(minor)) return ENXIO;
 297
 298   switch (minor) {
 299   case NULL_DEV:
 300         r = 0;  /* always at EOF */
 301         break;
 302
 303   case ZERO_DEV:
 304         /* Fill the target area with zeroes. In fact, let the kernel do it! */
 305         if ((r = sys_safememset(endpt, grant, 0, '\0', size)) == OK)
 306                 r = size;
 307         break;
 308
 309   case KMEM_DEV:
 310         r = m_transfer_kmem(minor, FALSE, position, endpt, grant, size);
 311         break;
 312
 313   case MEM_DEV:
 314         r = m_transfer_mem(minor, FALSE, position, endpt, grant, size);
 315         break;
 316
 317   default:
 318         panic("unknown character device %d", minor);
 319   }
 320
 321   return r;
 322 }
 323
 324 /*===========================================================================*
 325  *                              m_char_write                                 *
 326  *===========================================================================*/
 327 static ssize_t m_char_write(devminor_t minor, u64_t position, endpoint_t endpt,
 328         cp_grant_id_t grant, size_t size, int UNUSED(flags),
 329         cdev_id_t UNUSED(id))
 330 {
 331 /* Write to one of the driver's character devices. */
 332   ssize_t r;
 333
 334   /* Check if the minor device number is ok. */
 335   if (minor < 0 || minor >= NR_DEVS || m_is_block(minor)) return ENXIO;
 336
 337   switch (minor) {
 338   case NULL_DEV:
 339   case ZERO_DEV:
 340         r = size;       /* just eat everything */
 341         break;
 342
 343   case KMEM_DEV:
 344         r = m_transfer_kmem(minor, TRUE, position, endpt, grant, size);
 345         break;
 346
 347   case MEM_DEV:
 348         r = m_transfer_mem(minor, TRUE, position, endpt, grant, size);
 349         break;
 350
 351   default:
 352         panic("unknown character device %d", minor);
 353   }
 354
 355   return r;
 356 }
 357
 358 /*===========================================================================*
 359  *                              m_char_open                                  *
 360  *===========================================================================*/
 361 static int m_char_open(devminor_t minor, int access, endpoint_t user_endpt)
 362 {
 363 /* Open a memory character device. */
 364
 365   /* Check if the minor device number is ok. */
 366   if (minor < 0 || minor >= NR_DEVS || m_is_block(minor)) return ENXIO;
 367
 368 #if defined(__i386__)
 369   if (minor == MEM_DEV)
 370   {
 371         int r = sys_enable_iop(user_endpt);
 372         if (r != OK)
 373         {
 374                 printf("m_char_open: sys_enable_iop failed for %d: %d\n",
 375                         user_endpt, r);
 376                 return r;
 377         }
 378   }
 379 #endif
 380
 381   openct[minor]++;
 382
 383   return(OK);
 384 }
 385
 386 /*===========================================================================*
 387  *                              m_char_close                                 *
 388  *===========================================================================*/
 389 static int m_char_close(devminor_t minor)
 390 {
 391 /* Close a memory character device. */
 392
 393   if (minor < 0 || minor >= NR_DEVS || m_is_block(minor)) return ENXIO;
 394
 395   if(openct[minor] < 1) {
 396         printf("MEMORY: closing unopened device %d\n", minor);
 397         return(EINVAL);
 398   }
 399   openct[minor]--;
 400
 401   return(OK);
 402 }
 403
 404 /*===========================================================================*
 405  *                              m_block_part                                 *
 406  *===========================================================================*/
 407 static struct device *m_block_part(devminor_t minor)
 408 {
 409 /* Prepare for I/O on a device: check if the minor device number is ok. */
 410   if (minor < 0 || minor >= NR_DEVS || !m_is_block(minor)) return(NULL);
 411
 412   return(&m_geom[minor]);
 413 }
 414
 415 /*===========================================================================*
 416  *                              m_block_transfer                             *
 417  *===========================================================================*/
 418 static int m_block_transfer(
 419   devminor_t minor,             /* minor device number */
 420   int do_write,                 /* read or write? */
 421   u64_t position,               /* offset on device to read or write */
 422   endpoint_t endpt,             /* process doing the request */
 423   iovec_t *iov,                 /* pointer to read or write request vector */
 424   unsigned int nr_req,          /* length of request vector */
 425   int UNUSED(flags)             /* transfer flags */
 426 )
 427 {
 428 /* Read or write one the driver's block devices. */
 429   unsigned count;
 430   vir_bytes vir_offset = 0;
 431   struct device *dv;
 432   u64_t dv_size;
 433   int r;
 434   vir_bytes dev_vaddr;
 435   cp_grant_id_t grant;
 436   ssize_t total = 0;
 437
 438   /* Get minor device information. */
 439   if ((dv = m_block_part(minor)) == NULL) return(ENXIO);
 440   dv_size = dv->dv_size;
 441   dev_vaddr = m_vaddrs[minor];
 442
 443   if (ex64hi(position) != 0)
 444         return OK;      /* Beyond EOF */
 445
 446   while (nr_req > 0) {
 447
 448         /* How much to transfer and where to / from. */
 449         count = iov->iov_size;
 450         grant = (cp_grant_id_t) iov->iov_addr;
 451
 452         /* Virtual copying. For RAM disks and internal FS. */
 453         if(!dev_vaddr || dev_vaddr == (vir_bytes) MAP_FAILED) {
 454                 printf("MEM: dev %d not initialized\n", minor);
 455                 return EIO;
 456         }
 457         if (position >= dv_size) return(total); /* check for EOF */
 458         if (position + count > dv_size) count = dv_size - position;
 459         if (!do_write) {        /* copy actual data */
 460                 r=sys_safecopyto(endpt, grant, vir_offset,
 461                   dev_vaddr + position, count);
 462         } else {
 463                 r=sys_safecopyfrom(endpt, grant, vir_offset,
 464                   dev_vaddr + position, count);
 465         }
 466         if(r != OK) {
 467                 panic("I/O copy failed: %d", r);
 468         }
 469
 470         /* Book the number of bytes transferred. */
 471         position += count;
 472         vir_offset += count;
 473         total += count;
 474         if ((iov->iov_size -= count) == 0) { iov++; nr_req--; vir_offset = 0; }
 475
 476   }
 477   return(total);
 478 }
 479
 480 /*===========================================================================*
 481  *                              m_block_open                                 *
 482  *===========================================================================*/
 483 static int m_block_open(devminor_t minor, int UNUSED(access))
 484 {
 485 /* Open a memory block device. */
 486   if (m_block_part(minor) == NULL) return(ENXIO);
 487
 488   openct[minor]++;
 489
 490   return(OK);
 491 }
 492
 493 /*===========================================================================*
 494  *                              m_block_close                                *
 495  *===========================================================================*/
 496 static int m_block_close(devminor_t minor)
 497 {
 498 /* Close a memory block device. */
 499   if (m_block_part(minor) == NULL) return(ENXIO);
 500
 501   if(openct[minor] < 1) {
 502         printf("MEMORY: closing unopened device %d\n", minor);
 503         return(EINVAL);
 504   }
 505   openct[minor]--;
 506
 507   return(OK);
 508 }
 509
 510 /*===========================================================================*
 511  *                              m_block_ioctl                                *
 512  *===========================================================================*/
 513 static int m_block_ioctl(devminor_t minor, unsigned long request,
 514         endpoint_t endpt, cp_grant_id_t grant, endpoint_t UNUSED(user_endpt))
 515 {
 516 /* I/O controls for the block devices of the memory driver. Currently there is
 517  * one I/O control specific to the memory driver:
 518  * - MIOCRAMSIZE: to set the size of the RAM disk.
 519  */
 520   struct device *dv;
 521   u32_t ramdev_size;
 522   int s;
 523   void *mem;
 524   int is_imgrd = 0;
 525
 526   if (request != MIOCRAMSIZE)
 527         return EINVAL;
 528
 529   if(minor == IMGRD_DEV)
 530         is_imgrd = 1;
 531
 532   /* Someone wants to create a new RAM disk with the given size.
 533    * A ramdisk can be created only once, and only on RAM disk device.
 534    */
 535   if ((dv = m_block_part(minor)) == NULL) return ENXIO;
 536   if((minor < RAM_DEV_FIRST || minor > RAM_DEV_LAST) &&
 537         minor != RAM_DEV_OLD && !is_imgrd) {
 538         printf("MEM: MIOCRAMSIZE: %d not a ramdisk\n", minor);
 539         return EINVAL;
 540   }
 541
 542   /* Get request structure */
 543   s= sys_safecopyfrom(endpt, grant, 0, (vir_bytes)&ramdev_size,
 544         sizeof(ramdev_size));
 545   if (s != OK)
 546         return s;
 547   if(is_imgrd)
 548         ramdev_size = 0;
 549   if(m_vaddrs[minor] && dv->dv_size == (u64_t) ramdev_size) {
 550         return(OK);
 551   }
 552   /* openct is 1 for the ioctl(). */
 553   if(openct[minor] != 1) {
 554         printf("MEM: MIOCRAMSIZE: %d in use (count %d)\n",
 555                 minor, openct[minor]);
 556         return(EBUSY);
 557   }
 558   if(m_vaddrs[minor]) {
 559         u32_t a, o;
 560         u64_t size;
 561         int r;
 562         if(ex64hi(dv->dv_size)) {
 563                 panic("huge old ramdisk");
 564         }
 565         size = dv->dv_size;
 566         a = m_vaddrs[minor];
 567         if((o = a % PAGE_SIZE)) {
 568                 vir_bytes l = PAGE_SIZE - o;
 569                 a += l;
 570                 size -= l;
 571         }
 572         size = rounddown(size, PAGE_SIZE);
 573         r = munmap((void *) a, size);
 574         if(r != OK) {
 575                 printf("memory: WARNING: munmap failed: %d\n", r);
 576         }
 577         m_vaddrs[minor] = (vir_bytes) NULL;
 578         dv->dv_size = 0;
 579   }
 580
 581 #if DEBUG
 582   printf("MEM:%d: allocating ramdisk of size 0x%x\n", minor, ramdev_size);
 583 #endif
 584
 585   mem = NULL;
 586
 587   /* Try to allocate a piece of memory for the RAM disk. */
 588   if(ramdev_size > 0 &&
 589         (mem = mmap(NULL, ramdev_size, PROT_READ|PROT_WRITE,
 590                 MAP_PREALLOC|MAP_ANON, -1, 0)) == MAP_FAILED) {
 591         printf("MEM: failed to get memory for ramdisk\n");
 592         return(ENOMEM);
 593   }
 594
 595   m_vaddrs[minor] = (vir_bytes) mem;
 596
 597   dv->dv_size = ramdev_size;
 598
 599   return(OK);
 600 }