FreeBSD/Linux Kernel Cross Reference
sys/drivers/rescue/rescue.c

     /* This file contains the rescue device driver (/dev/rescue)
      *
      *  Changes:
      *      Oct 21, 1992    created  (Jorrit N. Herder)
      */
     
     #include "../drivers.h"
     #include "../libdriver/driver.h"
     #include "../../kernel/const.h"
    #include "../../kernel/config.h"
    #include "../../kernel/type.h"
    
    #define VERBOSE            0            /* enable/ disable messages */
    #define NR_DEVS            1            /* number of rescue devices */
    #define RESCUE_KBYTES    128            /* default size in kilobytes */
    
    PRIVATE struct device m_geom[NR_DEVS];  /* base and size of each device */
    PRIVATE int m_seg[NR_DEVS];             /* segment index of each device */
    PRIVATE int m_device;                   /* current device */
    
    extern int errno;                       /* error number for PM calls */
    
    FORWARD _PROTOTYPE( void m_init, (int argc, char **argv) );
    FORWARD _PROTOTYPE( char *m_name, (void)                                );
    FORWARD _PROTOTYPE( struct device *m_prepare, (int device)              );
    FORWARD _PROTOTYPE( int m_transfer, (int proc_nr, int opcode, off_t position,
                                            iovec_t *iov, unsigned nr_req)  );
    FORWARD _PROTOTYPE( int m_do_open, (struct driver *dp, message *m_ptr)  );
    FORWARD _PROTOTYPE( void m_geometry, (struct partition *entry)          );
    
    /* Entry points to this driver. */
    PRIVATE struct driver m_dtab = {
      m_name,       /* current device's name */
      m_do_open,    /* open or mount */
      do_nop,       /* nothing on a close */
      do_diocntl,   /* standard I/O controls */
      m_prepare,    /* prepare for I/O on a given minor device */
      m_transfer,   /* do the I/O */
      nop_cleanup,  /* no need to clean up */
      m_geometry,   /* memory device "geometry" */
      nop_signal,   /* system signals */
      nop_alarm,
      nop_cancel,
      nop_select,
      NULL,
      NULL
    };
    
    
    /*===========================================================================*
     *                                 main                                      *
     *===========================================================================*/
    PUBLIC int main(int argc, char **argv)
    {
    /* Main program. Initialize the rescue driver and start the main loop. */
      m_init(argc, argv);                   
      driver_task(&m_dtab);         
      return(OK);                           
    }
    
    /*===========================================================================*
     *                               m_name                                      *
     *===========================================================================*/
    PRIVATE char *m_name()
    {
    /* Return a name for the current device. */
      static char name[] = "rescue";
      return name;  
    }
    
    /*===========================================================================*
     *                              m_prepare                                    *
     *===========================================================================*/
    PRIVATE struct device *m_prepare(device)
    int device;
    {
    /* Prepare for I/O on a device: check if the minor device number is ok. */
      if (device < 0 || device >= NR_DEVS) return(NIL_DEV);
      m_device = device;
    
      return(&m_geom[device]);
    }
    
    /*===========================================================================*
     *                              m_transfer                                   *
     *===========================================================================*/
    PRIVATE int m_transfer(proc_nr, opcode, position, iov, nr_req)
    int proc_nr;                    /* process doing the request */
    int opcode;                     /* DEV_GATHER or DEV_SCATTER */
    off_t position;                 /* offset on device to read or write */
    iovec_t *iov;                   /* pointer to read or write request vector */
    unsigned nr_req;                /* length of request vector */
    {
    /* Read or write one the driver's minor devices. */
      int seg;
      unsigned count, left, chunk;
      vir_bytes user_vir;
      struct device *dv;
      unsigned long dv_size;
     int s;
   
     /* Get and check minor device number. */
     if ((unsigned) m_device > NR_DEVS - 1) return(ENXIO);
     dv = &m_geom[m_device];
     dv_size = cv64ul(dv->dv_size);
   
     while (nr_req > 0) {
   
           /* How much to transfer and where to / from. */
           count = iov->iov_size;
           user_vir = iov->iov_addr;
   
           /* Virtual copying. For rescue device. */
           if (position >= dv_size) return(OK);    /* check for EOF */
           if (position + count > dv_size) count = dv_size - position;
           seg = m_seg[m_device];
   
           if (opcode == DEV_GATHER) {                     /* copy actual data */
               sys_vircopy(SELF,seg,position, proc_nr,D,user_vir, count);
           } else {
               sys_vircopy(proc_nr,D,user_vir, SELF,seg,position, count);
           }
   
           /* Book the number of bytes transferred. */
           position += count;
           iov->iov_addr += count;
           if ((iov->iov_size -= count) == 0) { iov++; nr_req--; }
   
     }
     return(OK);
   }
   
   /*===========================================================================*
    *                              m_do_open                                    *
    *===========================================================================*/
   PRIVATE int m_do_open(dp, m_ptr)
   struct driver *dp;
   message *m_ptr;
   {
   /* Check device number on open. */
     if (m_prepare(m_ptr->DEVICE) == NIL_DEV) return(ENXIO);
     return(OK);
   }
   
   /*===========================================================================*
    *                              m_init                                       *
    *===========================================================================*/
   PRIVATE void m_init(argc,argv)
   int argc;
   char **argv;
   {
     /* Initialize this task. All minor devices are initialized one by one. */
     phys_bytes rescue_size;
     phys_bytes rescue_base;
     message m;
     int i, s;
   
     /* Initialize all rescue devices in a loop. */
     for (i=0; i< NR_DEVS; i++) {
   
         /* Determine size and base of rescue disks. See if rescue disk details 
          * exist in the data store. If no memory for the rescue disk was claimed 
          * yet, do it below. 
          */
         m.DS_KEY = (RESCUE_MAJOR << 8) + i;
         if (OK == (s = _taskcall(DS_PROC_NR, DS_RETRIEVE, &m))) {
             rescue_size = m.DS_VAL_L1;
             rescue_base = m.DS_VAL_L2;
         }
         else {                                    /* no details known */
             if (argc>i+1) rescue_size = atoi(argv[i+1]) * 1024;
             else          rescue_size = RESCUE_KBYTES * 1024;
   
             if (allocmem(rescue_size, &rescue_base) < 0) {
                 report("RESCUE", "warning, allocmem failed", errno);
                 rescue_size = 0;
             }
         }
   
         /* Now that we have the base and size of the rescue disk, set up all
          * data structures if the rescue has a positive (nonzero) size. 
          */
         if (rescue_size > 0) {
   
             /* Create a new remote segment to make virtual copies. */ 
             if (OK != (s=sys_segctl(&m_seg[i], (u16_t *) &s, 
                     (vir_bytes *) &s, rescue_base, rescue_size))) {
                 panic("RESCUE","Couldn't install remote segment.",s);
             }
   
             /* Set the device geometry for the outside world. */
             m_geom[i].dv_base = cvul64(rescue_base);
             m_geom[i].dv_size = cvul64(rescue_size);
   
             /* Store the values in the data store for future retrieval. */
             m.DS_KEY = (RESCUE_MAJOR << 8) + i;
             m.DS_VAL_L1 = rescue_size;
             m.DS_VAL_L2 = rescue_base;
             if (OK != (s = _taskcall(DS_PROC_NR, DS_PUBLISH, &m))) {
                 panic("RESCUE","Couldn't store rescue disk details at DS.",s);
             }
   
   #if VERBOSE
             printf("RESCUE disk %d (size %u/base %u) initialized\n",
                 i, rescue_size, rescue_base);
   #endif
         }
     }
   }
   
   /*===========================================================================*
    *                              m_geometry                                   *
    *===========================================================================*/
   PRIVATE void m_geometry(entry)
   struct partition *entry;
   {
     /* Memory devices don't have a geometry, but the outside world insists. */
     entry->cylinders = div64u(m_geom[m_device].dv_size, SECTOR_SIZE) / (64 * 32);
     entry->heads = 64;
     entry->sectors = 32;
   }
   

Cache object: b1eaad0c870dfd911998d2b2e25dce5e