workbench/libs/partition/partitionmbr.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5 */
   6
   7 #include <proto/exec.h>
   8 #include <proto/partition.h>
   9
  10 #include <exec/memory.h>
  11 #include <exec/types.h>
  12 #include <libraries/partition.h>
  13
  14 #include "partition_support.h"
  15 #include "partitionmbr.h"
  16 #include "platform.h"
  17
  18 #ifndef DEBUG
  19 #define DEBUG 1
  20 #endif
  21 #include "debug.h"
  22
  23 struct MBRData {
  24     struct PCPartitionTable *entry;
  25     UBYTE position;
  26 };
  27
  28 static LONG PartitionMBRCheckPartitionTable
  29     (
  30         struct Library *PartitionBase,
  31         struct PartitionHandle *root
  32     )
  33 {
  34 struct MBR mbr;
  35
  36     if (readBlock(PartitionBase, root, 0, &mbr) == 0)
  37     {
  38         if (
  39                 (AROS_LE2WORD(mbr.magic) == 0xAA55) &&
  40                 (((mbr.pcpt[0].status & 0x0F)==0) || (mbr.pcpt[0].status & 0x80)) &&
  41                 (((mbr.pcpt[1].status & 0x0F)==0) || (mbr.pcpt[1].status & 0x80)) &&
  42                 (((mbr.pcpt[2].status & 0x0F)==0) || (mbr.pcpt[2].status & 0x80)) &&
  43                 (((mbr.pcpt[3].status & 0x0F)==0) || (mbr.pcpt[3].status & 0x80))
  44             )
  45         {
  46             if (root->root)
  47             {
  48                     return 0;
  49             }
  50             return 1;
  51         }
  52     }
  53     return 0;
  54 }
  55
  56 static struct PartitionHandle *PartitionMBRNewHandle
  57     (
  58         struct Library *PartitionBase,
  59         struct PartitionHandle *root,
  60         UBYTE position,
  61         struct PCPartitionTable *entry
  62     )
  63 {
  64 struct PartitionHandle *ph;
  65 ULONG cylsecs;
  66
  67     if (entry->first_sector != 0)
  68     {
  69         ph = AllocMem(sizeof(struct PartitionHandle), MEMF_PUBLIC | MEMF_CLEAR);
  70         if (ph)
  71         {
  72         struct MBRData *data;
  73
  74             data = AllocMem(sizeof(struct MBRData), MEMF_PUBLIC);
  75             if (data)
  76             {
  77                 cylsecs = root->de.de_BlocksPerTrack*root->de.de_Surfaces;
  78                 data->entry = entry;
  79                 data->position = position;
  80                 ph->root = root;
  81                 ph->bd = root->bd;
  82                 ph->data = data;
  83
  84                 /* initialize DosEnvec */
  85
  86                 /* Check if partition starts and ends on a cylinder boundary */
  87                 CopyMem(&root->de, &ph->de, sizeof(struct DosEnvec));
  88                 if (
  89                         (AROS_LE2LONG(data->entry->first_sector) % cylsecs != 0) ||
  90                         (AROS_LE2LONG(data->entry->count_sector) % cylsecs != 0)
  91                     )
  92                 {
  93                     /* Treat each track as a cylinder if possible */
  94                     ph->de.de_Surfaces = 1;
  95                     cylsecs = ph->de.de_BlocksPerTrack*ph->de.de_Surfaces;
  96                     if (
  97                         (AROS_LE2LONG(data->entry->first_sector) % cylsecs != 0) ||
  98                         (AROS_LE2LONG(data->entry->count_sector) % cylsecs != 0)
  99                     )
 100                     {
 101                         /* We can't. We could find the highest common factor of
 102                            first_sector and count_sector here, but currently we
 103                            simply use one block per cylinder */
 104                         ph->de.de_BlocksPerTrack = 1;
 105                         cylsecs = ph->de.de_BlocksPerTrack*ph->de.de_Surfaces;
 106                     }
 107                 }
 108                 ph->de.de_LowCyl = AROS_LE2LONG(data->entry->first_sector) / cylsecs;
 109                 ph->de.de_HighCyl =
 110                     ph->de.de_LowCyl+
 111                     (AROS_LE2LONG(data->entry->count_sector)/cylsecs)-1;
 112                 ph->de.de_TableSize = 10; // only until de_HighCyl
 113                 ph->ln.ln_Pri = MBR_MAX_PARTITIONS-1-position;
 114
 115                 /* initialize DriveGeometry */
 116                 ph->dg.dg_DeviceType = DG_DIRECT_ACCESS;
 117                 ph->dg.dg_SectorSize = ph->de.de_SizeBlock<<2;
 118                 ph->dg.dg_Heads = ph->de.de_Surfaces;
 119                 ph->dg.dg_TrackSectors = ph->de.de_BlocksPerTrack;
 120                 ph->dg.dg_Cylinders = ph->de.de_HighCyl - ph->de.de_LowCyl + 1;
 121                 ph->dg.dg_BufMemType = ph->de.de_BufMemType;
 122                 return ph;
 123             }
 124             FreeMem(ph, sizeof(struct PartitionHandle));
 125         }
 126     }
 127     return NULL;
 128 }
 129
 130 static LONG PartitionMBROpenPartitionTable
 131     (
 132         struct Library *PartitionBase,
 133         struct PartitionHandle *root
 134     )
 135 {
 136 struct PartitionHandle *ph;
 137 struct MBR *mbr;
 138 UBYTE i;
 139
 140     mbr = AllocMem(root->de.de_SizeBlock<<2, MEMF_PUBLIC);
 141     if (mbr)
 142     {
 143         if (readBlock(PartitionBase, root, 0, mbr) == 0)
 144         {
 145             NEWLIST(&root->table->list);
 146             root->table->data = mbr;
 147             for (i=0;i<4;i++)
 148             {
 149                 ph = PartitionMBRNewHandle(PartitionBase, root, i, &mbr->pcpt[i]);
 150                 if (ph != NULL)
 151                     Enqueue(&root->table->list, &ph->ln);
 152             }
 153             return 0;
 154         }
 155         FreeMem(mbr, root->de.de_SizeBlock<<2);
 156     }
 157     return 1;
 158 }
 159
 160 static void PartitionMBRFreeHandle
 161     (
 162         struct Library *PartitionBase,
 163         struct PartitionHandle *ph
 164     )
 165 {
 166     ClosePartitionTable(ph);
 167     FreeMem(ph->data, sizeof(struct MBRData));
 168     FreeMem(ph, sizeof(struct PartitionHandle));
 169 }
 170
 171 static void PartitionMBRClosePartitionTable
 172     (
 173         struct Library *PartitionBase,
 174         struct PartitionHandle *root
 175     )
 176 {
 177 struct PartitionHandle *ph;
 178
 179     while ((ph = (struct PartitionHandle *)RemTail(&root->table->list)))
 180         PartitionMBRFreeHandle(PartitionBase, ph);
 181     FreeMem(root->table->data, root->de.de_SizeBlock<<2);
 182 }
 183
 184 static LONG PartitionMBRWritePartitionTable
 185     (
 186         struct Library *PartitionBase,
 187         struct PartitionHandle *root
 188     )
 189 {
 190 #warning "FIXME: readBlock(0) and synchronize data"
 191
 192     /* root->data = mbr is up to date */
 193     if (writeBlock(PartitionBase, root, 0, root->table->data))
 194         return 1;
 195     return 0;
 196 }
 197
 198 static LONG PartitionMBRCreatePartitionTable
 199     (
 200         struct Library *PartitionBase,
 201         struct PartitionHandle *ph
 202     )
 203 {
 204 struct MBR *mbr;
 205
 206     mbr = AllocMem(ph->de.de_SizeBlock<<2, MEMF_PUBLIC);
 207     if (mbr)
 208     {
 209         if (readBlock(PartitionBase, ph, 0, mbr) == 0)
 210         {
 211             ph->table->data = mbr;
 212             fillMem((BYTE *)mbr->pcpt, sizeof(mbr->pcpt), 0);
 213             mbr->magic = AROS_WORD2LE(0xAA55);
 214             NEWLIST(&ph->table->list);
 215             return 0;
 216         }
 217         FreeMem(mbr, ph->de.de_SizeBlock<<2);
 218     }
 219     return 1;
 220 }
 221
 222 void PartitionMBRSetGeometry
 223     (
 224         struct PartitionHandle *root,
 225         struct PCPartitionTable *entry,
 226         ULONG sector,
 227         ULONG count,
 228         ULONG relative_sector
 229     )
 230 {
 231 ULONG track;
 232 ULONG cyl;
 233
 234     /* Store LBA start block and block count */
 235
 236     entry->first_sector = AROS_LONG2LE(sector - relative_sector);
 237     entry->count_sector = AROS_LONG2LE(count);
 238
 239     /* Store CHS-address of start block. The upper two bits of the cylinder
 240        number are stored in the upper two bits of the sector field */
 241
 242     track = sector/root->de.de_BlocksPerTrack;
 243     cyl = track/root->de.de_Surfaces;
 244     if (cyl<1024)
 245     {
 246         entry->start_head = track % root->de.de_Surfaces;
 247         entry->start_sector =
 248             ((sector % root->de.de_BlocksPerTrack) + 1)
 249             | ((cyl & 0x300) >> 2);
 250         entry->start_cylinder = (cyl & 0xFF);
 251     }
 252     else
 253     {
 254         entry->start_head = 0xFE;
 255         entry->start_sector = 0xFF;
 256         entry->start_cylinder = 0xFF;
 257     }
 258
 259     /* Store CHS-address of last block */
 260
 261     sector += count - 1;
 262     track = sector/root->de.de_BlocksPerTrack;
 263     cyl = track/root->de.de_Surfaces;
 264     if (cyl<1024)
 265     {
 266         entry->end_head = track % root->de.de_Surfaces;
 267         entry->end_sector = ((sector % root->de.de_BlocksPerTrack) + 1)
 268             | ((cyl & 0x300)>>2);
 269         entry->end_cylinder = (cyl & 0xFF);
 270     }
 271     else
 272     {
 273         entry->end_head = 0xFE;
 274         entry->end_sector = 0xFF;
 275         entry->end_cylinder = 0xFF;
 276     }
 277 }
 278
 279 static void PartitionMBRSetDosEnvec
 280     (
 281         struct PartitionHandle *root,
 282         struct PCPartitionTable *entry,
 283         struct DosEnvec *de
 284     )
 285 {
 286 ULONG sector, count;
 287
 288     sector = de->de_LowCyl * de->de_Surfaces * de->de_BlocksPerTrack;
 289     count = (de->de_HighCyl - de->de_LowCyl + 1) *
 290             de->de_Surfaces *
 291             de->de_BlocksPerTrack;
 292     PartitionMBRSetGeometry(root, entry, sector, count, 0);
 293 }
 294
 295 static struct PartitionHandle *PartitionMBRAddPartition
 296     (
 297         struct Library *PartitionBase,
 298         struct PartitionHandle *root,
 299         struct TagItem *taglist
 300     )
 301 {
 302 struct TagItem *tag;
 303
 304     tag = findTagItem(PT_DOSENVEC, taglist);
 305     if (tag)
 306     {
 307     struct PCPartitionTable *entry;
 308     struct PartitionHandle *ph;
 309     struct DosEnvec *de;
 310     WORD pos = -1, i;
 311
 312         de =  (struct DosEnvec *)tag->ti_Data;
 313         tag = findTagItem(PT_POSITION, taglist);
 314         if (tag != NULL)
 315             pos = tag->ti_Data;
 316         else
 317         {
 318             // Find an unused slot
 319             for (i = 0; i < MBR_MAX_PARTITIONS && pos == -1; i++)
 320             {
 321                 entry = &((struct MBR *)root->table->data)->pcpt[i];
 322                 if (entry->type == 0)
 323                     pos = i;
 324             }
 325         }
 326
 327         if (pos != -1)
 328         {
 329             entry = &((struct MBR *)root->table->data)->pcpt[pos];
 330             tag = findTagItem(PT_ACTIVE, taglist);
 331             if (tag)
 332                 entry->status = tag->ti_Data ? 0x80 : 0;
 333             else
 334                 entry->status = 0;
 335             tag = findTagItem(PT_TYPE, taglist);
 336             if (tag)
 337             {
 338             struct PartitionType *ptype = (struct PartitionType *)tag->ti_Data;
 339
 340                 entry->type = ptype->id[0];
 341             }
 342             else
 343                 entry->type = 0;
 344             PartitionMBRSetDosEnvec(root, entry, de);
 345             ph = PartitionMBRNewHandle(PartitionBase, root, pos, entry);
 346             if (ph != NULL)
 347                 Enqueue(&root->table->list, &ph->ln);
 348             else
 349                 fillMem((BYTE *)entry, sizeof(struct PCPartitionTable), 0);
 350             return ph;
 351         }
 352     }
 353     return NULL;
 354 }
 355
 356 static void PartitionMBRDeletePartition
 357     (
 358         struct Library *PartitionBase,
 359         struct PartitionHandle *ph
 360     )
 361 {
 362 struct MBRData *data;
 363
 364     data = (struct MBRData *)ph->data;
 365     fillMem((BYTE *)data->entry, sizeof(struct PCPartitionTable), 0);
 366     Remove(&ph->ln);
 367     PartitionMBRFreeHandle(PartitionBase, ph);
 368 }
 369
 370 static LONG PartitionMBRGetPartitionTableAttrs
 371     (
 372         struct Library *PartitionBase,
 373         struct PartitionHandle *root,
 374         struct TagItem *taglist
 375     )
 376 {
 377
 378     while (taglist[0].ti_Tag != TAG_DONE)
 379     {
 380
 381         switch (taglist[0].ti_Tag)
 382         {
 383         case PTT_TYPE:
 384             *((LONG *)taglist[0].ti_Data) = root->table->type;
 385             break;
 386         case PTT_RESERVED:
 387             *((LONG *)taglist[0].ti_Data) =
 388                 root->de.de_BlocksPerTrack; /* One track */
 389             break;
 390         case PTT_MAX_PARTITIONS:
 391             *((LONG *)taglist[0].ti_Data) = MBR_MAX_PARTITIONS;
 392         }
 393         taglist++;
 394     }
 395     return 0;
 396 }
 397
 398 static LONG PartitionMBRSetPartitionTableAttrs
 399     (
 400         struct Library *PartitionBase,
 401         struct PartitionHandle *root,
 402         struct TagItem *taglist
 403     )
 404 {
 405
 406     while (taglist[0].ti_Tag != TAG_DONE)
 407     {
 408
 409         switch (taglist[0].ti_Tag)
 410         {
 411         }
 412         taglist++;
 413     }
 414     return 0;
 415 }
 416
 417 static LONG PartitionMBRGetPartitionAttrs
 418     (
 419         struct Library *PartitionBase,
 420         struct PartitionHandle *ph,
 421         struct TagItem *taglist
 422     )
 423 {
 424
 425     while (taglist[0].ti_Tag != TAG_DONE)
 426     {
 427     struct MBRData *data = (struct MBRData *)ph->data;
 428
 429         switch (taglist[0].ti_Tag)
 430         {
 431         case PT_GEOMETRY:
 432             {
 433                 struct DriveGeometry *dg = (struct DriveGeometry *)taglist[0].ti_Data;
 434                 CopyMem(&ph->dg, dg, sizeof(struct DriveGeometry));
 435             }
 436             break;
 437         case PT_DOSENVEC:
 438             CopyMem(&ph->de, (struct DosEnvec *)taglist[0].ti_Data, sizeof(struct DosEnvec));
 439             break;
 440         case PT_TYPE:
 441             {
 442             struct PartitionType *ptype=(struct PartitionType *)taglist[0].ti_Data;
 443
 444                 ptype->id[0] = (LONG)data->entry->type;
 445                 ptype->id_len = 1;
 446             }
 447             break;
 448         case PT_POSITION:
 449             *((LONG *)taglist[0].ti_Data) = (LONG)data->position;
 450             break;
 451         case PT_ACTIVE:
 452             *((LONG *)taglist[0].ti_Data) = data->entry->status & 0x80 ? 1 : 0;
 453             break;
 454         }
 455         taglist++;
 456     }
 457     return 0;
 458 }
 459
 460 static LONG PartitionMBRSetPartitionAttrs
 461     (
 462         struct Library *PartitionBase,
 463         struct PartitionHandle *ph,
 464         struct TagItem *taglist
 465     )
 466 {
 467
 468     while (taglist[0].ti_Tag != TAG_DONE)
 469     {
 470     struct MBRData *data = (struct MBRData *)ph->data;
 471
 472         switch (taglist[0].ti_Tag)
 473         {
 474         case PT_DOSENVEC:
 475             {
 476             struct DosEnvec *de;
 477                 de = (struct DosEnvec *)taglist[0].ti_Data;
 478                 CopyMem(de, &ph->de, sizeof(struct DosEnvec));
 479                 PartitionMBRSetDosEnvec(ph->root, data->entry, de);
 480             }
 481             break;
 482         case PT_TYPE:
 483             {
 484             struct PartitionType *ptype=(struct PartitionType *)taglist[0].ti_Data;
 485
 486                 data->entry->type = ptype->id[0];
 487             }
 488             break;
 489         case PT_POSITION:
 490             if (taglist[0].ti_Data != data->position)
 491             {
 492             struct PartitionHandle *node;
 493             struct PCPartitionTable *entry;
 494
 495                 node = (struct PartitionHandle *)ph->root->table->list.lh_Head;
 496                 while (node->ln.ln_Succ)
 497                 {
 498                     if (taglist[0].ti_Data == ((struct MBRData *)node->data)->position)
 499                         goto posbreak;
 500                     node = (struct PartitionHandle *)node->ln.ln_Succ;
 501                 }
 502                 data->position = taglist[0].ti_Data;
 503                 entry = &((struct MBR *)ph->root->table->data)->pcpt[data->position];
 504                 CopyMem(data->entry, entry, sizeof(struct PCPartitionTable));
 505                 fillMem((BYTE *)data->entry, sizeof(struct PCPartitionTable), 0);
 506                 data->entry = entry;
 507                 ph->ln.ln_Pri = MBR_MAX_PARTITIONS-1-data->position;
 508                 Remove(&ph->ln);
 509                 Enqueue(&ph->root->table->list, &ph->ln);
 510 posbreak:
 511             ;
 512             }
 513             break;
 514         case PT_ACTIVE:
 515             if (taglist[0].ti_Data)
 516                 data->entry->status |= 0x80;
 517             else
 518                 data->entry->status &= ~0x80;
 519             break;
 520         }
 521         taglist++;
 522     }
 523     return 0;
 524 }
 525
 526 static struct PartitionAttribute PartitionMBRPartitionTableAttrs[]=
 527 {
 528     {PTTA_TYPE,           PLAM_READ},
 529     {PTTA_RESERVED,       PLAM_READ},
 530     {PTTA_MAX_PARTITIONS, PLAM_READ},
 531     {PTTA_DONE,           0}
 532 };
 533
 534 static struct PartitionAttribute *PartitionMBRQueryPartitionTableAttrs(struct Library *PartitionBase)
 535 {
 536     return PartitionMBRPartitionTableAttrs;
 537 }
 538
 539 static struct PartitionAttribute PartitionMBRPartitionAttrs[]=
 540 {
 541     {PTA_GEOMETRY, PLAM_READ},
 542     {PTA_TYPE,     PLAM_READ | PLAM_WRITE},
 543     {PTA_POSITION, PLAM_READ | PLAM_WRITE},
 544     {PTA_ACTIVE,   PLAM_READ | PLAM_WRITE},
 545     {PTA_DONE,     0}
 546 };
 547
 548 struct PartitionAttribute *PartitionMBRQueryPartitionAttrs(struct Library *PartitionBase)
 549 {
 550     return PartitionMBRPartitionAttrs;
 551 }
 552
 553 static ULONG PartitionMBRDestroyPartitionTable
 554     (
 555         struct Library *PartitionBase,
 556         struct PartitionHandle *root
 557     )
 558 {
 559 struct MBR *mbr;
 560
 561     mbr = root->table->data;
 562     fillMem((BYTE *)mbr->pcpt, sizeof(mbr->pcpt), 0);
 563     if (writeBlock(PartitionBase, root, 0, root->table->data))
 564         return 1;
 565     return 0;
 566 }
 567
 568 struct PTFunctionTable PartitionMBR =
 569 {
 570     PHPTT_MBR,
 571     "PC-MBR",
 572     PartitionMBRCheckPartitionTable,
 573     PartitionMBROpenPartitionTable,
 574     PartitionMBRClosePartitionTable,
 575     PartitionMBRWritePartitionTable,
 576     PartitionMBRCreatePartitionTable,
 577     PartitionMBRAddPartition,
 578     PartitionMBRDeletePartition,
 579     PartitionMBRGetPartitionTableAttrs,
 580     PartitionMBRSetPartitionTableAttrs,
 581     PartitionMBRGetPartitionAttrs,
 582     PartitionMBRSetPartitionAttrs,
 583     PartitionMBRQueryPartitionTableAttrs,
 584     PartitionMBRQueryPartitionAttrs,
 585     PartitionMBRDestroyPartitionTable
 586 };
 587