# 2.11BSD#431 - /usr/src/sys/pdpstand/label.c

##### Functions

    dkcksum           X
    overlapchk        X
    readlabel         X
    writelabel        X

##### Macros

    RAWPART           X

       1: /*-
       2:  * Public domain, May 1995
       3:  *
       4:  *	@(#)label.c	1.2 (2.11BSD GTE) 1996/03/07
       5:  *
       6:  * Date: 1995/08/01
       7:  * Move the check for a partition number being out of bounds to the
       8:  * readlabel routine.  This is necessary in order to permit unlabeled disks
       9:  * (or disks whose label is corrupt) to be open'd.  This check can't be done
      10:  * in the open routine because a corrupt or missing label could have garbage
      11:  * for the number of partitions.
      12:  */
      13:
      14: #include "../h/param.h"
      15: #include "saio.h"
      16:
      17: /*
      18:  * Called from the general device label routine in conf.c.   A label with
      19:  * a fake geometry suitable for reading the label sector is created and
      20:  * the driver's strategy routine is called.  If the label is corrupted
      21:  * or absent an error is possibly printed.
      22:  *
      23:  * NOTES:  We reuse the iob structure's buffer (i_buf).
      24:  *	   All disks must have at least LABELSECTOR+1 sectors in a track.
      25:  *	   (this is not expected to be a problem since LABELSECTOR is 1).
      26: */
      27:
      28: readlabel(io, strat)
      29:     register struct iob *io;
      30:     int (*strat)();
      31:     {
      32:     register struct disklabel *lp = &io->i_label;
      33:     register struct partition *pi;
      34:
      35:     io->i_bn = LABELSECTOR;
      36:     io->i_ma = io->i_buf;
      37:     io->i_cc = 512;         /* XXX */
      38:     lp->d_nsectors = LABELSECTOR + 1;   /* # sectors per track */
      39:     lp->d_ntracks = 1;          /* # tracks per cylinder */
      40:     lp->d_secpercyl = LABELSECTOR + 1;  /* # sectors per cylinder */
      41:
      42:     pi = &lp->d_partitions[0];
      43:     lp->d_npartitions = 1;
      44:     pi->p_offset = 0;
      45:     pi->p_size = LABELSECTOR + 1;
      46:     pi->p_fsize = DEV_BSIZE;
      47:     pi->p_frag = 1;
      48:     pi->p_fstype = FS_V71K;
      49:
      50:     if  ((*strat)(io, READ) != 512)
      51:         {
      52:         printf("%s error reading labelsector\n", devname(io));
      53:         return(-1);
      54:         }
      55:     bcopy(io->i_buf, lp, sizeof (struct disklabel));
      56:     if  (Nolabelerr)
      57:         return(0);
      58:     if  (lp->d_magic != DISKMAGIC || lp->d_magic2 != DISKMAGIC ||
      59:          dkcksum(lp) != 0)
      60:         {
      61:         printf("%s disklabel missing/corrupt\n", devname(io));
      62:         if  (devlabel(io, DEFAULTLABEL) < 0)
      63:             return(-1);
      64:         printf("%s spans volume\n", devname(io));
      65:         }
      66:     if  (io->i_part >= lp->d_npartitions ||
      67:             lp->d_partitions[io->i_part].p_size == 0)
      68:         {
      69:         printf("%s bad partition # or size = 0\n", devname(io));
      70:         return(-1);
      71:         }
      72:     return(0);
      73:     }
      74:
      75: writelabel(io, strat)
      76:     register struct iob *io;
      77:     int (*strat)();
      78:     {
      79:     register struct disklabel *lp = &io->i_label;
      80:
      81:     if  ((io->i_flgs & F_WRITE) == 0)
      82:         return(-1);
      83:     io->i_bn = LABELSECTOR;
      84:     io->i_ma = (char *)&io->i_label;
      85:     io->i_cc = 512;         /* XXX */
      86: /*
      87:  * The geometry had better be set up and correct at this point - we can not
      88:  * fake the geometry because that would overwrite the contents of the label
      89:  * itself.
      90: */
      91:     lp->d_secsize = 512;            /* XXX */
      92:     lp->d_magic = DISKMAGIC;
      93:     lp->d_magic2 = DISKMAGIC;
      94:     lp->d_checksum = 0;
      95:     lp->d_checksum = dkcksum(lp);
      96:
      97:     if  ((*strat)(io, WRITE) != 512)
      98:         {
      99:         printf("%s error writing label\n", devname(io));
     100:         return(-1);
     101:         }
     102:     return(0);
     103:     }
     104:
     105: /*
     106:  * Compute checksum for disk label.
     107:  */
     108: dkcksum(lp)
     109:     register struct disklabel *lp;
     110:     {
     111:     register u_short *start, *end;
     112:     register u_short sum = 0;
     113:
     114:     start = (u_short *)lp;
     115:     end = (u_short *)&lp->d_partitions[lp->d_npartitions];
     116:     while (start < end)
     117:         sum ^= *start++;
     118:     return (sum);
     119:     }
     120:
     121: /*
     122:  * Check for partitions which overlap each other.  While it is legal
     123:  * to have partitions which overlap (as long as they are not used at the
     124:  * same time) it is often a mistake or oversite.
     125: */
     126:
     127: overlapchk(lp)
     128:     register struct disklabel *lp;
     129:     {
     130:     register struct partition *pp;
     131:     int i, part, openmask;
     132:     daddr_t start, end;
     133:
     134: #define RAWPART 2
     135: /*
     136:  * 'c' is normally (but not always) the partition which spans the whole
     137:  * drive, thus it is not normally an error for it to overlap all other
     138:  * partitions.
     139: */
     140:     openmask = ~0 & ~(1 << RAWPART);
     141:     for (part = 0; part < lp->d_npartitions; part++)
     142:         {
     143:         pp = &lp->d_partitions[part];
     144:         if  (part == RAWPART || pp->p_size == 0)
     145:             continue;
     146:         start = pp->p_offset;
     147:         end = start + pp->p_size;
     148:
     149:         for (pp = lp->d_partitions, i = 0;
     150:              i < lp->d_npartitions;
     151:              pp++, i++)
     152:             {
     153: /*
     154:  * We make sure to not report zero length partitions or that a
     155:  * partition overlaps itself.  We've already checked lower partitions
     156:  * so avoid giving something like "a overlaps b" and then "b overlaps a".
     157: */
     158:             if  (i <= part || pp->p_size == 0)
     159:                 continue;
     160:             if  (pp->p_offset + pp->p_size <= start ||
     161:                  pp->p_offset >= end)
     162:                 continue;
     163:             if  ((openmask & (1 << i)) == 0)
     164:                 continue;
     165:             printf("warning: partition '%c' overlaps '%c'\n",
     166:                 'a' + part, 'a' + i);
     167:             }
     168:         }
     169:     }

#### Defined functions

dkcksum defined in line 108; used 3 times

- in line 59, 95
- in /usr/src/sys/pdpstand/disklabel.c line 61

overlapchk defined in line 127; used 2 times

- in /usr/src/sys/pdpstand/disklabel.c line 98, 107

readlabel defined in line 28; used 1 times

- in /usr/src/sys/pdpstand/conf.c line 136

writelabel defined in line 75; used 1 times

- in /usr/src/sys/pdpstand/conf.c line 134

#### Defined macros

RAWPART defined in line 134; used 2 times

- in line 140-144(2)

Last modified: 1996-03-09 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1213 |