| #include <u.h> |
| #include <libc.h> |
| #include <bio.h> |
| #include <ctype.h> |
| #include <disk.h> |
| |
| static Disk* |
| mkwidth(Disk *disk) |
| { |
| char buf[40]; |
| |
| sprint(buf, "%lld", disk->size); |
| disk->width = strlen(buf); |
| return disk; |
| } |
| |
| /* |
| * Discover the disk geometry by various sleazeful means. |
| * |
| * First, if there is a partition table in sector 0, |
| * see if all the partitions have the same end head |
| * and sector; if so, we'll assume that that's the |
| * right count. |
| * |
| * If that fails, we'll try looking at the geometry that the ATA |
| * driver supplied, if any, and translate that as a |
| * BIOS might. |
| * |
| * If that too fails, which should only happen on a SCSI |
| * disk with no currently defined partitions, we'll try |
| * various common (h, s) pairs used by BIOSes when faking |
| * the geometries. |
| */ |
| typedef struct Table Table; |
| typedef struct Tentry Tentry; |
| struct Tentry { |
| uchar active; /* active flag */ |
| uchar starth; /* starting head */ |
| uchar starts; /* starting sector */ |
| uchar startc; /* starting cylinder */ |
| uchar type; /* partition type */ |
| uchar endh; /* ending head */ |
| uchar ends; /* ending sector */ |
| uchar endc; /* ending cylinder */ |
| uchar xlba[4]; /* starting LBA from beginning of disc */ |
| uchar xsize[4]; /* size in sectors */ |
| }; |
| enum { |
| Toffset = 446, /* offset of partition table in sector */ |
| Magic0 = 0x55, |
| Magic1 = 0xAA, |
| NTentry = 4 |
| }; |
| struct Table { |
| Tentry entry[NTentry]; |
| uchar magic[2]; |
| }; |
| static int |
| partitiongeometry(Disk *disk) |
| { |
| char *rawname; |
| int i, h, rawfd, s; |
| uchar buf[512]; |
| Table *t; |
| |
| t = (Table*)(buf + Toffset); |
| |
| /* |
| * look for an MBR first in the /dev/sdXX/data partition, otherwise |
| * attempt to fall back on the current partition. |
| */ |
| rawname = malloc(strlen(disk->prefix) + 5); /* prefix + "data" + nul */ |
| if(rawname == nil) |
| return -1; |
| |
| strcpy(rawname, disk->prefix); |
| strcat(rawname, "data"); |
| rawfd = open(rawname, OREAD); |
| free(rawname); |
| if(rawfd >= 0 |
| && seek(rawfd, 0, 0) >= 0 |
| && readn(rawfd, buf, 512) == 512 |
| && t->magic[0] == Magic0 |
| && t->magic[1] == Magic1) { |
| close(rawfd); |
| } else { |
| if(rawfd >= 0) |
| close(rawfd); |
| if(seek(disk->fd, 0, 0) < 0 |
| || readn(disk->fd, buf, 512) != 512 |
| || t->magic[0] != Magic0 |
| || t->magic[1] != Magic1) { |
| return -1; |
| } |
| } |
| |
| h = s = -1; |
| for(i=0; i<NTentry; i++) { |
| if(t->entry[i].type == 0) |
| continue; |
| |
| t->entry[i].ends &= 63; |
| if(h == -1) { |
| h = t->entry[i].endh; |
| s = t->entry[i].ends; |
| } else { |
| /* |
| * Only accept the partition info if every |
| * partition is consistent. |
| */ |
| if(h != t->entry[i].endh || s != t->entry[i].ends) |
| return -1; |
| } |
| } |
| |
| if(h == -1) |
| return -1; |
| |
| disk->h = h+1; /* heads count from 0 */ |
| disk->s = s; /* sectors count from 1 */ |
| disk->c = disk->secs / (disk->h*disk->s); |
| disk->chssrc = Gpart; |
| return 0; |
| } |
| |
| /* |
| * If there is ATA geometry, use it, perhaps massaged. |
| */ |
| static int |
| drivergeometry(Disk *disk) |
| { |
| int m; |
| |
| if(disk->c == 0 || disk->h == 0 || disk->s == 0) |
| return -1; |
| |
| disk->chssrc = Gdisk; |
| if(disk->c < 1024) |
| return 0; |
| |
| switch(disk->h) { |
| case 15: |
| disk->h = 255; |
| disk->c /= 17; |
| return 0; |
| } |
| |
| for(m = 2; m*disk->h < 256; m *= 2) { |
| if(disk->c/m < 1024) { |
| disk->c /= m; |
| disk->h *= m; |
| return 0; |
| } |
| } |
| |
| /* set to 255, 63 and be done with it */ |
| disk->h = 255; |
| disk->s = 63; |
| disk->c = disk->secs / (disk->h * disk->s); |
| return 0; |
| } |
| |
| /* |
| * There's no ATA geometry and no partitions. |
| * Our guess is as good as anyone's. |
| */ |
| static struct { |
| int h; |
| int s; |
| } guess[] = { |
| 64, 32, |
| 64, 63, |
| 128, 63, |
| 255, 63, |
| }; |
| static int |
| guessgeometry(Disk *disk) |
| { |
| int i; |
| long c; |
| |
| disk->chssrc = Gguess; |
| c = 1024; |
| for(i=0; i<nelem(guess); i++) |
| if(c*guess[i].h*guess[i].s >= disk->secs) { |
| disk->h = guess[i].h; |
| disk->s = guess[i].s; |
| disk->c = disk->secs / (disk->h * disk->s); |
| return 0; |
| } |
| |
| /* use maximum values */ |
| disk->h = 255; |
| disk->s = 63; |
| disk->c = disk->secs / (disk->h * disk->s); |
| return 0; |
| } |
| |
| static void |
| findgeometry(Disk *disk) |
| { |
| if(partitiongeometry(disk) < 0 |
| && drivergeometry(disk) < 0 |
| && guessgeometry(disk) < 0) { /* can't happen */ |
| print("we're completely confused about your disk; sorry\n"); |
| assert(0); |
| } |
| } |
| |
| static Disk* |
| openfile(Disk *disk) |
| { |
| Dir *d; |
| |
| if((d = dirfstat(disk->fd)) == nil){ |
| free(disk); |
| return nil; |
| } |
| |
| disk->secsize = 512; |
| disk->size = d->length; |
| disk->secs = disk->size / disk->secsize; |
| disk->offset = 0; |
| free(d); |
| |
| findgeometry(disk); |
| return mkwidth(disk); |
| } |
| |
| static Disk* |
| opensd(Disk *disk) |
| { |
| Biobuf b; |
| char *p, *f[10]; |
| int nf; |
| |
| Binit(&b, disk->ctlfd, OREAD); |
| while(p = Brdline(&b, '\n')) { |
| p[Blinelen(&b)-1] = '\0'; |
| nf = tokenize(p, f, nelem(f)); |
| if(nf >= 3 && strcmp(f[0], "geometry") == 0) { |
| disk->secsize = strtoll(f[2], 0, 0); |
| if(nf >= 6) { |
| disk->c = strtol(f[3], 0, 0); |
| disk->h = strtol(f[4], 0, 0); |
| disk->s = strtol(f[5], 0, 0); |
| } |
| } |
| if(nf >= 4 && strcmp(f[0], "part") == 0 && strcmp(f[1], disk->part) == 0) { |
| disk->offset = strtoll(f[2], 0, 0); |
| disk->secs = strtoll(f[3], 0, 0) - disk->offset; |
| } |
| } |
| |
| |
| disk->size = disk->secs * disk->secsize; |
| if(disk->size <= 0) { |
| strcpy(disk->part, ""); |
| disk->type = Tfile; |
| return openfile(disk); |
| } |
| |
| findgeometry(disk); |
| return mkwidth(disk); |
| } |
| |
| Disk* |
| opendisk(char *disk, int rdonly, int noctl) |
| { |
| char *p, *q; |
| Disk *d; |
| |
| d = malloc(sizeof(*d)); |
| if(d == nil) |
| return nil; |
| |
| d->fd = d->wfd = d->ctlfd = -1; |
| d->rdonly = rdonly; |
| |
| d->fd = open(disk, OREAD); |
| if(d->fd < 0) { |
| werrstr("cannot open disk file"); |
| free(d); |
| return nil; |
| } |
| |
| if(rdonly == 0) { |
| d->wfd = open(disk, OWRITE); |
| if(d->wfd < 0) |
| d->rdonly = 1; |
| } |
| |
| if(noctl) |
| return openfile(d); |
| |
| p = malloc(strlen(disk) + 4); /* 4: slop for "ctl\0" */ |
| if(p == nil) { |
| close(d->wfd); |
| close(d->fd); |
| free(d); |
| return nil; |
| } |
| strcpy(p, disk); |
| |
| /* check for floppy(3) disk */ |
| if(strlen(p) >= 7) { |
| q = p+strlen(p)-7; |
| if(q[0] == 'f' && q[1] == 'd' && isdigit((uchar)q[2]) && strcmp(q+3, "disk") == 0) { |
| strcpy(q+3, "ctl"); |
| if((d->ctlfd = open(p, ORDWR)) >= 0) { |
| *q = '\0'; |
| d->prefix = p; |
| d->type = Tfloppy; |
| return openfile(d); |
| } |
| } |
| } |
| |
| /* attempt to find sd(3) disk or partition */ |
| if(q = strrchr(p, '/')) |
| q++; |
| else |
| q = p; |
| |
| strcpy(q, "ctl"); |
| if((d->ctlfd = open(p, ORDWR)) >= 0) { |
| *q = '\0'; |
| d->prefix = p; |
| d->type = Tsd; |
| d->part = strdup(disk+(q-p)); |
| if(d->part == nil){ |
| close(d->ctlfd); |
| close(d->wfd); |
| close(d->fd); |
| free(p); |
| free(d); |
| return nil; |
| } |
| return opensd(d); |
| } |
| |
| *q = '\0'; |
| d->prefix = p; |
| /* assume we just have a normal file */ |
| d->type = Tfile; |
| return openfile(d); |
| } |
| |