[BACK]Return to ccd.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / dev

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/dev/ccd.c between version 1.50 and 1.50.2.1

version 1.50, 1998/07/09 20:56:12 version 1.50.2.1, 1998/08/08 03:06:46
Line 132  struct ccdbuf {
Line 132  struct ccdbuf {
         int             cb_unit;        /* target unit */          int             cb_unit;        /* target unit */
         int             cb_comp;        /* target component */          int             cb_comp;        /* target component */
         int             cb_flags;       /* misc. flags */          int             cb_flags;       /* misc. flags */
         LIST_ENTRY(ccdbuf) cb_list;     /* entry on freelist */  
 };  };
   
 /* cb_flags */  /* cb_flags */
 #define CBF_MIRROR      0x01            /* we're for a mirror component */  #define CBF_MIRROR      0x01            /* we're for a mirror component */
   
 /*  /* XXX Safe to wait? */
  * Number of freelist buffers per component.  Overridable in kernel  #define CCD_GETBUF(cs)          pool_get(&(cs)->sc_cbufpool, PR_WAITOK)
  * config file and patchable.  #define CCD_PUTBUF(cs, cbp)     pool_put(&(cs)->sc_cbufpool, cbp)
  */  
 #ifndef CCDNBUF  
 #define CCDNBUF         8  
 #endif  
 int     ccdnbuf = CCDNBUF;  
   
 /*  
  * XXX Is it OK to wait here?  
  * XXX maybe set up a timeout when we hit some lowater?  
  * XXX    --thorpej  
  */  
 #define CCDGETBUF(cs, cbp)      do {                                    \  
                 (cs)->sc_ngetbuf++;                                     \  
                 if (((cbp) = (cs)->sc_freelist.lh_first) != NULL) {     \  
                         LIST_REMOVE((cbp), cb_list);                    \  
                         (cs)->sc_freecount--;                           \  
                 } else {                                                \  
                         (cs)->sc_nmisses++;                             \  
                         MALLOC((cbp), struct ccdbuf *,                  \  
                             sizeof(struct ccdbuf), M_DEVBUF, M_WAITOK); \  
                 }                                                       \  
         } while (0)  
   
 #define CCDPUTBUF(cs, cbp)      do {                                    \  
                 if ((cs)->sc_freecount == (cs)->sc_hiwat) {             \  
                         FREE((cbp), M_DEVBUF);                          \  
                 } else {                                                \  
                         LIST_INSERT_HEAD(&(cs)->sc_freelist, (cbp), cb_list); \  
                         (cs)->sc_freecount++;                           \  
                 }                                                       \  
         } while (0)  
   
 #define CCDLABELDEV(dev)        \  #define CCDLABELDEV(dev)        \
         (MAKEDISKDEV(major((dev)), ccdunit((dev)), RAW_PART))          (MAKEDISKDEV(major((dev)), ccdunit((dev)), RAW_PART))
Line 254  ccdinit(ccd, cpaths, p)
Line 222  ccdinit(ccd, cpaths, p)
         struct partinfo dpart;          struct partinfo dpart;
         struct ccdgeom *ccg = &cs->sc_geom;          struct ccdgeom *ccg = &cs->sc_geom;
         char tmppath[MAXPATHLEN];          char tmppath[MAXPATHLEN];
         struct ccdbuf *cbp;  
         int error;          int error;
   
 #ifdef DEBUG  #ifdef DEBUG
Line 433  ccdinit(ccd, cpaths, p)
Line 400  ccdinit(ccd, cpaths, p)
         ccg->ccg_nsectors = 1024 * (1024 / ccg->ccg_secsize);          ccg->ccg_nsectors = 1024 * (1024 / ccg->ccg_secsize);
         ccg->ccg_ncylinders = cs->sc_size / ccg->ccg_nsectors;          ccg->ccg_ncylinders = cs->sc_size / ccg->ccg_nsectors;
   
         /*  
          * Allocate the component buffer header freelist.  We allocate  
          * ccdnbuf buffers per component.  
          */  
         LIST_INIT(&cs->sc_freelist);  
         cs->sc_hiwat = cs->sc_nccdisks * ccdnbuf;  
         cs->sc_freecount = cs->sc_hiwat;  
         for (ix = 0; ix < cs->sc_hiwat; ix++) {  
                 MALLOC(cbp, struct ccdbuf *, sizeof(struct ccdbuf),  
                     M_DEVBUF, M_WAITOK);  
                 LIST_INSERT_HEAD(&cs->sc_freelist, cbp, cb_list);  
         }  
   
         /* Reset statistics. */  
         cs->sc_nmisses = 0;  
         cs->sc_ngetbuf = 0;  
   
         cs->sc_flags |= CCDF_INITED;          cs->sc_flags |= CCDF_INITED;
         cs->sc_cflags = ccd->ccd_flags; /* So we can find out later... */          cs->sc_cflags = ccd->ccd_flags; /* So we can find out later... */
         cs->sc_unit = ccd->ccd_unit;          cs->sc_unit = ccd->ccd_unit;
Line 849  ccdbuffer(cs, bp, bn, addr, bcount, cbpp
Line 799  ccdbuffer(cs, bp, bn, addr, bcount, cbpp
         /*          /*
          * Fill in the component buf structure.           * Fill in the component buf structure.
          */           */
         CCDGETBUF(cs, cbp);          cbp = CCD_GETBUF(cs);
         cbp->cb_flags = 0;          cbp->cb_flags = 0;
         cbp->cb_buf.b_flags = bp->b_flags | B_CALL;          cbp->cb_buf.b_flags = bp->b_flags | B_CALL;
         cbp->cb_buf.b_iodone = ccdiodone;          cbp->cb_buf.b_iodone = ccdiodone;
Line 887  ccdbuffer(cs, bp, bn, addr, bcount, cbpp
Line 837  ccdbuffer(cs, bp, bn, addr, bcount, cbpp
          */           */
         if ((cs->sc_cflags & CCDF_MIRROR) &&          if ((cs->sc_cflags & CCDF_MIRROR) &&
             ((cbp->cb_buf.b_flags & B_READ) == 0)) {              ((cbp->cb_buf.b_flags & B_READ) == 0)) {
                 CCDGETBUF(cs, cbp);                  cbp = CCD_GETBUF(cs);
                 *cbp = *cbpp[0];                  *cbp = *cbpp[0];
                 cbp->cb_flags = CBF_MIRROR;                  cbp->cb_flags = CBF_MIRROR;
                 cbp->cb_buf.b_dev = ci2->ci_dev;        /* XXX */                  cbp->cb_buf.b_dev = ci2->ci_dev;        /* XXX */
Line 964  ccdiodone(vbp)
Line 914  ccdiodone(vbp)
         }          }
         count = cbp->cb_buf.b_bcount;          count = cbp->cb_buf.b_bcount;
         cbflags = cbp->cb_flags;          cbflags = cbp->cb_flags;
         CCDPUTBUF(cs, cbp);          CCD_PUTBUF(cs, cbp);
   
         /*          /*
          * If all done, "interrupt".           * If all done, "interrupt".
Line 1054  ccdioctl(dev, cmd, data, flag, p)
Line 1004  ccdioctl(dev, cmd, data, flag, p)
         struct ccd_softc *cs;          struct ccd_softc *cs;
         struct ccd_ioctl *ccio = (struct ccd_ioctl *)data;          struct ccd_ioctl *ccio = (struct ccd_ioctl *)data;
         struct ccddevice ccd;          struct ccddevice ccd;
         struct ccdbuf *cbp;  
         char **cpp;          char **cpp;
         struct vnode **vpp;          struct vnode **vpp;
   
Line 1175  ccdioctl(dev, cmd, data, flag, p)
Line 1124  ccdioctl(dev, cmd, data, flag, p)
                 cs->sc_dkdev.dk_name = cs->sc_xname;                  cs->sc_dkdev.dk_name = cs->sc_xname;
                 disk_attach(&cs->sc_dkdev);                  disk_attach(&cs->sc_dkdev);
   
                   /* Initialize the component buffer pool. */
                   pool_init(&cs->sc_cbufpool, sizeof(struct ccdbuf), 0,
                       0, 0, "ccdpl", 0, NULL, NULL, M_DEVBUF);
   
                 /* Try and read the disklabel. */                  /* Try and read the disklabel. */
                 ccdgetdisklabel(dev);                  ccdgetdisklabel(dev);
   
Line 1221  ccdioctl(dev, cmd, data, flag, p)
Line 1174  ccdioctl(dev, cmd, data, flag, p)
                         free(cs->sc_cinfo[i].ci_path, M_DEVBUF);                          free(cs->sc_cinfo[i].ci_path, M_DEVBUF);
                 }                  }
   
                 /* Free component buffer freelist. */  
                 while ((cbp = cs->sc_freelist.lh_first) != NULL) {  
                         LIST_REMOVE(cbp, cb_list);  
                         FREE(cbp, M_DEVBUF);  
                 }  
   
                 /* Free interleave index. */                  /* Free interleave index. */
                 for (i = 0; cs->sc_itable[i].ii_ndisk; ++i)                  for (i = 0; cs->sc_itable[i].ii_ndisk; ++i)
                         free(cs->sc_itable[i].ii_index, M_DEVBUF);                          free(cs->sc_itable[i].ii_index, M_DEVBUF);
Line 1243  ccdioctl(dev, cmd, data, flag, p)
Line 1190  ccdioctl(dev, cmd, data, flag, p)
                 free(ccddevs[unit].ccd_vpp, M_DEVBUF);                  free(ccddevs[unit].ccd_vpp, M_DEVBUF);
                 bcopy(&ccd, &ccddevs[unit], sizeof(ccd));                  bcopy(&ccd, &ccddevs[unit], sizeof(ccd));
   
                   /* Free the component buffer pool. */
                   pool_destroy(&cs->sc_cbufpool);
   
                 /* Detatch the disk. */                  /* Detatch the disk. */
                 disk_detach(&cs->sc_dkdev);                  disk_detach(&cs->sc_dkdev);
   

Legend:
Removed from v.1.50  
changed lines
  Added in v.1.50.2.1

CVSweb <webmaster@jp.NetBSD.org>