Diff for /src/sys/kern/subr_diskslice.c between versions 1.7 and 1.8

version 1.7, 2003/11/10 06:12:13 version 1.8, 2004/06/02 17:18:43
Line 78  static void partition_info (char *sname, Line 78  static void partition_info (char *sname,
 static void slice_info (char *sname, struct diskslice *sp);  static void slice_info (char *sname, struct diskslice *sp);
 static void set_ds_label (struct diskslices *ssp, int slice,  static void set_ds_label (struct diskslices *ssp, int slice,
                               struct disklabel *lp);                                struct disklabel *lp);
static void set_ds_labeldevs (dev_t dev, struct diskslices *ssp);static void set_ds_wlabel (struct diskslices *ssp, int slice, int wlabel);
static void set_ds_wlabel (struct diskslices *ssp, int slice, 
                               int wlabel); 
   
 /*  /*
  * Duplicate a label for the whole disk, and initialize defaults in the   * Duplicate a label for the whole disk, and initialize defaults in the
Line 89  static void set_ds_wlabel (struct disksl Line 87  static void set_ds_wlabel (struct disksl
  * that are to be defaulted.   * that are to be defaulted.
  */   */
 static struct disklabel *  static struct disklabel *
clone_label(lp)clone_label(struct disklabel *lp)
        struct disklabel *lp; 
 {  {
         struct disklabel *lp1;          struct disklabel *lp1;
   
Line 135  clone_label(lp) Line 132  clone_label(lp)
  *      o Finish cleaning this up.   *      o Finish cleaning this up.
  */   */
 int  int
dscheck(bp, ssp)dscheck(struct buf *bp, struct diskslices *ssp)
        struct buf *bp; 
        struct diskslices *ssp; 
 {  {
         daddr_t blkno;          daddr_t blkno;
         u_long  endsecno;          u_long  endsecno;
         daddr_t labelsect;          daddr_t labelsect;
         struct disklabel *lp;          struct disklabel *lp;
         char *msg;          char *msg;
        long    nsec;        long nsec;
         struct partition *pp;          struct partition *pp;
         daddr_t secno;          daddr_t secno;
         daddr_t slicerel_secno;          daddr_t slicerel_secno;
Line 186  dscheck(bp, ssp) Line 181  dscheck(bp, ssp)
                 slicerel_secno = secno;                  slicerel_secno = secno;
         } else {          } else {
                 labelsect = lp->d_partitions[LABEL_PART].p_offset;                  labelsect = lp->d_partitions[LABEL_PART].p_offset;
if (labelsect != 0) Debugger("labelsect != 0 in dscheck()");                if (labelsect != 0)
                         Debugger("labelsect != 0 in dscheck()");
                 pp = &lp->d_partitions[dkpart(bp->b_dev)];                  pp = &lp->d_partitions[dkpart(bp->b_dev)];
                 endsecno = pp->p_size;                  endsecno = pp->p_size;
                 slicerel_secno = pp->p_offset + secno;                  slicerel_secno = pp->p_offset + secno;
Line 303  bad: Line 299  bad:
 }  }
   
 void  void
dsclose(dev, mode, ssp)dsclose(dev_t dev, int mode, struct diskslices *ssp)
        dev_t   dev; 
        int     mode; 
        struct diskslices *ssp; 
 {  {
        u_char  mask;        u_char mask;
         struct diskslice *sp;          struct diskslice *sp;
   
         sp = &ssp->dss_slices[dkslice(dev)];          sp = &ssp->dss_slices[dkslice(dev)];
Line 317  dsclose(dev, mode, ssp) Line 310  dsclose(dev, mode, ssp)
 }  }
   
 void  void
dsgone(sspp)dsgone(struct diskslices **sspp)
        struct diskslices **sspp; 
 {  {
        int        slice;        int slice;
         struct diskslice *sp;          struct diskslice *sp;
         struct diskslices *ssp;          struct diskslices *ssp;
   
Line 337  dsgone(sspp) Line 329  dsgone(sspp)
  * is subject to the same restriction as dsopen().   * is subject to the same restriction as dsopen().
  */   */
 int  int
dsioctl(dev, cmd, data, flags, sspp)dsioctl(dev_t dev, u_long cmd, caddr_t data, 
        dev_t   dev;        int flags, struct diskslices **sspp)
        u_long  cmd; 
        caddr_t data; 
        int     flags; 
        struct diskslices **sspp; 
 {  {
        int        error;        int error;
         struct disklabel *lp;          struct disklabel *lp;
        int        old_wlabel;        int old_wlabel;
        u_char  openmask;        u_char openmask;
        int     part;        int part;
        int     slice;        int slice;
         struct diskslice *sp;          struct diskslice *sp;
         struct diskslices *ssp;          struct diskslices *ssp;
         struct partition *pp;          struct partition *pp;
Line 459  dsioctl(dev, cmd, data, flags, sspp) Line 447  dsioctl(dev, cmd, data, flags, sspp)
                 }                  }
                 free_ds_label(ssp, slice);                  free_ds_label(ssp, slice);
                 set_ds_label(ssp, slice, lp);                  set_ds_label(ssp, slice, lp);
                 set_ds_labeldevs(dev, ssp);  
                 return (0);                  return (0);
   
         case DIOCSYNCSLICEINFO:          case DIOCSYNCSLICEINFO:
Line 547  dsioctl(dev, cmd, data, flags, sspp) Line 534  dsioctl(dev, cmd, data, flags, sspp)
 }  }
   
 static void  static void
dsiodone(bp)dsiodone(struct buf *bp)
        struct buf *bp; 
 {  {
         struct iodone_chain *ic;          struct iodone_chain *ic;
         char *msg;          char *msg;
Line 572  dsiodone(bp) Line 558  dsiodone(bp)
 }  }
   
 int  int
dsisopen(ssp)dsisopen(struct diskslices *ssp)
        struct diskslices *ssp; 
 {  {
        int        slice;        int slice;
   
         if (ssp == NULL)          if (ssp == NULL)
                 return (0);                  return (0);
        for (slice = 0; slice < ssp->dss_nslices; slice++)        for (slice = 0; slice < ssp->dss_nslices; slice++) {
                 if (ssp->dss_slices[slice].ds_openmask)                  if (ssp->dss_slices[slice].ds_openmask)
                         return (1);                          return (1);
           }
         return (0);          return (0);
 }  }
   
Line 592  dsisopen(ssp) Line 578  dsisopen(ssp)
  * slices beginning at BASE_SLICE.   * slices beginning at BASE_SLICE.
  */   */
 struct diskslices *  struct diskslices *
dsmakeslicestruct(nslices, lp)dsmakeslicestruct(int nslices, struct disklabel *lp)
        int nslices; 
        struct disklabel *lp; 
 {  {
         struct diskslice *sp;          struct diskslice *sp;
         struct diskslices *ssp;          struct diskslices *ssp;
Line 617  dsmakeslicestruct(nslices, lp) Line 601  dsmakeslicestruct(nslices, lp)
 }  }
   
 char *  char *
dsname(dev, unit, slice, part, partname)dsname(dev_t dev, int unit, int slice, int part, char *partname)
        dev_t   dev; 
        int     unit; 
        int     slice; 
        int     part; 
        char    *partname; 
 {  {
         static char name[32];          static char name[32];
         const char *dname;          const char *dname;
Line 635  dsname(dev, unit, slice, part, partname) Line 614  dsname(dev, unit, slice, part, partname)
         if (slice != WHOLE_DISK_SLICE || part != RAW_PART) {          if (slice != WHOLE_DISK_SLICE || part != RAW_PART) {
                 partname[0] = 'a' + part;                  partname[0] = 'a' + part;
                 partname[1] = '\0';                  partname[1] = '\0';
                if (slice != COMPATIBILITY_SLICE)                if (slice != COMPATIBILITY_SLICE) {
                         snprintf(name + strlen(name),                          snprintf(name + strlen(name),
                             sizeof(name) - strlen(name), "s%d", slice - 1);                              sizeof(name) - strlen(name), "s%d", slice - 1);
                   }
         }          }
         return (name);          return (name);
 }  }
Line 648  dsname(dev, unit, slice, part, partname) Line 628  dsname(dev, unit, slice, part, partname)
  * strategy routine must be special to allow activity.   * strategy routine must be special to allow activity.
  */   */
 int  int
dsopen(dev, mode, flags, sspp, lp)dsopen(dev_t dev, int mode, u_int flags, 
        dev_t   dev;        struct diskslices **sspp, struct disklabel *lp)
        int     mode; 
        u_int   flags; 
        struct diskslices **sspp; 
        struct disklabel *lp; 
 {  {
        dev_t   dev1;        dev_t dev1;
        int     error;        int error;
         struct disklabel *lp1;          struct disklabel *lp1;
        char    *msg;        char *msg;
        u_char  mask;        u_char mask;
        bool_t  need_init;        bool_t need_init;
        int     part;        int part;
        char    partname[2];        char partname[2];
        int     slice;        int slice;
        char    *sname;        char *sname;
         struct diskslice *sp;          struct diskslice *sp;
         struct diskslices *ssp;          struct diskslices *ssp;
        int        unit;        int unit;
   
         dev->si_bsize_phys = lp->d_secsize;          dev->si_bsize_phys = lp->d_secsize;
   
Line 795  dsopen(dev, mode, flags, sspp, lp) Line 771  dsopen(dev, mode, flags, sspp, lp)
                         continue;                          continue;
                 }                  }
                 set_ds_label(ssp, slice, lp1);                  set_ds_label(ssp, slice, lp1);
                 set_ds_labeldevs(dev1, ssp);  
                 set_ds_wlabel(ssp, slice, FALSE);                  set_ds_wlabel(ssp, slice, FALSE);
         }          }
   
Line 813  dsopen(dev, mode, flags, sspp, lp) Line 788  dsopen(dev, mode, flags, sspp, lp)
 }  }
   
 int  int
dssize(dev, sspp)dssize(dev_t dev, struct diskslices **sspp)
        dev_t   dev; 
        struct diskslices **sspp; 
 {  {
         struct disklabel *lp;          struct disklabel *lp;
        int        part;        int part;
        int     slice;        int slice;
         struct diskslices *ssp;          struct diskslices *ssp;
   
         slice = dkslice(dev);          slice = dkslice(dev);
Line 839  dssize(dev, sspp) Line 812  dssize(dev, sspp)
 }  }
   
 static void  static void
free_ds_label(ssp, slice)free_ds_label(struct diskslices *ssp, int slice)
        struct diskslices *ssp; 
        int        slice; 
 {  {
         struct disklabel *lp;          struct disklabel *lp;
         struct diskslice *sp;          struct diskslice *sp;
Line 855  free_ds_label(ssp, slice) Line 826  free_ds_label(ssp, slice)
 }  }
   
 static char *  static char *
fixlabel(sname, sp, lp, writeflag)fixlabel(char *sname, struct diskslice *sp, struct disklabel *lp, int writeflag)
        char    *sname; 
        struct diskslice *sp; 
        struct disklabel *lp; 
        int        writeflag; 
 {  {
        u_long  end;        u_long end;
        u_long  offset;        u_long offset;
        int     part;        int part;
         struct partition *pp;          struct partition *pp;
        u_long  start;        u_long start;
        bool_t  warned;        bool_t warned;
   
         /* These errors "can't happen" so don't bother reporting details. */          /* These errors "can't happen" so don't bother reporting details. */
         if (lp->d_magic != DISKMAGIC || lp->d_magic2 != DISKMAGIC)          if (lp->d_magic != DISKMAGIC || lp->d_magic2 != DISKMAGIC)
Line 941  fixlabel(sname, sp, lp, writeflag) Line 908  fixlabel(sname, sp, lp, writeflag)
 }  }
   
 static void  static void
partition_info(sname, part, pp)partition_info(char *sname, int part, struct partition *pp)
        char    *sname; 
        int     part; 
        struct partition *pp; 
 {  {
         printf("%s%c: start %lu, end %lu, size %lu\n", sname, 'a' + part,          printf("%s%c: start %lu, end %lu, size %lu\n", sname, 'a' + part,
                (u_long)pp->p_offset, (u_long)(pp->p_offset + pp->p_size - 1),                 (u_long)pp->p_offset, (u_long)(pp->p_offset + pp->p_size - 1),
Line 952  partition_info(sname, part, pp) Line 916  partition_info(sname, part, pp)
 }  }
   
 static void  static void
slice_info(sname, sp)slice_info(char *sname, struct diskslice *sp)
        char    *sname; 
        struct diskslice *sp; 
 {  {
         printf("%s: start %lu, end %lu, size %lu\n", sname,          printf("%s: start %lu, end %lu, size %lu\n", sname,
                sp->ds_offset, sp->ds_offset + sp->ds_size - 1, sp->ds_size);                 sp->ds_offset, sp->ds_offset + sp->ds_size - 1, sp->ds_size);
 }  }
   
 static void  static void
set_ds_label(ssp, slice, lp)set_ds_label(struct diskslices *ssp, int slice, struct disklabel *lp)
        struct diskslices *ssp; 
        int        slice; 
        struct disklabel *lp; 
 {  {
         ssp->dss_slices[slice].ds_label = lp;          ssp->dss_slices[slice].ds_label = lp;
         if (slice == COMPATIBILITY_SLICE)          if (slice == COMPATIBILITY_SLICE)
Line 973  set_ds_label(ssp, slice, lp) Line 932  set_ds_label(ssp, slice, lp)
                 ssp->dss_slices[COMPATIBILITY_SLICE].ds_label = lp;                  ssp->dss_slices[COMPATIBILITY_SLICE].ds_label = lp;
 }  }
   
 /* XXX remove this? */  
 static void  static void
set_ds_labeldevs(dev, ssp)set_ds_wlabel(struct diskslices *ssp, int slice, int wlabel)
        dev_t   dev; 
        struct diskslices *ssp; 
{ 
} 
 
static void 
set_ds_wlabel(ssp, slice, wlabel) 
        struct diskslices *ssp; 
        int     slice; 
        int     wlabel; 
 {  {
         ssp->dss_slices[slice].ds_wlabel = wlabel;          ssp->dss_slices[slice].ds_wlabel = wlabel;
         if (slice == COMPATIBILITY_SLICE)          if (slice == COMPATIBILITY_SLICE)

Removed from v.1.7  
changed lines
  Added in v.1.8