lib/ext2fs/dosio.c

   1 /*
   2  * dosio.c -- Disk I/O module for the ext2fs/DOS library.
   3  *
   4  * Copyright (c) 1997 by Theodore Ts'o.
   5  *
   6  * Copyright (c) 1997 Mark Habersack
   7  *
   8  * %Begin-Header%
   9  * This file may be redistributed under the terms of the GNU Library
  10  * General Public License, version 2.
  11  * %End-Header%
  12  */
  13
  14 #include "config.h"
  15 #include <stdio.h>
  16 #include <bios.h>
  17 #include <string.h>
  18 #include <ctype.h>
  19 #include <io.h>
  20 #ifdef HAVE_ERRNO_H
  21 #include <errno.h>
  22 #endif
  23
  24 #include <ext2fs/ext2_types.h>
  25 #include "utils.h"
  26 #include "dosio.h"
  27 #include "et/com_err.h"
  28 #include "ext2_err.h"
  29 #include "ext2fs/io.h"
  30
  31 /*
  32  * Some helper macros
  33  */
  34 #define LINUX_EXT2FS       0x83
  35 #define LINUX_SWAP         0x82
  36 #define WRITE_ERR(_msg_) write(2, _msg_, strlen(_msg_))
  37 #define WRITE_ERR_S(_msg_) write(2, _msg_, sizeof(_msg_))
  38
  39 /*
  40  * Exported variables
  41  */
  42 unsigned long        _dio_error;
  43 unsigned long        _dio_hw_error;
  44
  45 /*
  46  * Array of all opened partitions
  47  */
  48 static PARTITION        **partitions = NULL;
  49 static unsigned short   npart = 0; /* Number of mapped partitions */
  50 static PARTITION        *active = NULL;
  51
  52 /*
  53  * I/O Manager routine prototypes
  54  */
  55 static errcode_t dos_open(const char *dev, int flags, io_channel *channel);
  56 static errcode_t dos_close(io_channel channel);
  57 static errcode_t dos_set_blksize(io_channel channel, int blksize);
  58 static errcode_t dos_read_blk(io_channel channel, unsigned long block,
  59                                              int count, void *buf);
  60 static errcode_t dos_write_blk(io_channel channel, unsigned long block,
  61                                int count, const void *buf);
  62 static errcode_t dos_flush(io_channel channel);
  63
  64 static struct struct_io_manager struct_dos_manager = {
  65         EXT2_ET_MAGIC_IO_MANAGER,
  66         "DOS I/O Manager",
  67         dos_open,
  68         dos_close,
  69         dos_set_blksize,
  70         dos_read_blk,
  71         dos_write_blk,
  72         dos_flush
  73 };
  74 io_manager dos_io_manager = &struct_dos_manager;
  75
  76 /*
  77  * Macro taken from unix_io.c
  78  */
  79 /*
  80  * For checking structure magic numbers...
  81  */
  82
  83 #define EXT2_CHECK_MAGIC(struct, code) \
  84           if ((struct)->magic != (code)) return (code)
  85
  86 /*
  87  * Calculates a CHS address of a sector from its LBA
  88  * offset for the given partition.
  89  */
  90 static void lba2chs(unsigned long lba_addr, CHS *chs, PARTITION *part)
  91 {
  92   unsigned long      abss;
  93
  94   chs->offset = lba_addr & 0x000001FF;
  95   abss = (lba_addr >> 9) + part->start;
  96   chs->cyl    = abss / (part->sects * part->heads);
  97   chs->head   = (abss / part->sects) % part->heads;
  98   chs->sector = (abss % part->sects) + 1;
  99 }
 100
 101 #ifdef __TURBOC__
 102 #pragma argsused
 103 #endif
 104 /*
 105  * Scans the passed partition table looking for *pno partition
 106  * that has LINUX_EXT2FS type.
 107  *
 108  * TODO:
 109  * For partition numbers >5 Linux uses DOS extended partitions -
 110  * dive into them an return an appropriate entry. Also dive into
 111  * extended partitions when scanning for a first Linux/ext2fs.
 112  */
 113 static PTABLE_ENTRY *scan_partition_table(PTABLE_ENTRY *pentry,
 114                                           unsigned short phys,
 115                                           unsigned char *pno)
 116 {
 117   unsigned        i;
 118
 119   if(*pno != 0xFF && *pno >= 5)
 120      return NULL; /* We don't support extended partitions for now */
 121
 122   if(*pno != 0xFF)
 123   {
 124     if(pentry[*pno].type == LINUX_EXT2FS)
 125       return &pentry[*pno];
 126     else
 127     {
 128       if(!pentry[*pno].type)
 129         *pno = 0xFE;
 130       else if(pentry[*pno].type == LINUX_SWAP)
 131         *pno = 0xFD;
 132       return NULL;
 133     }
 134   }
 135
 136   for(i = 0; i < 4; i++)
 137     if(pentry[i].type == LINUX_EXT2FS)
 138     {
 139       *pno = i;
 140       return &pentry[i];
 141     }
 142
 143   return NULL;
 144 }
 145
 146 /*
 147  * Allocate libext2fs structures associated with I/O manager
 148  */
 149 static io_channel alloc_io_channel(PARTITION *part)
 150 {
 151   io_channel     ioch;
 152
 153   ioch = (io_channel)malloc(sizeof(struct struct_io_channel));
 154   if (!ioch)
 155           return NULL;
 156   memset(ioch, 0, sizeof(struct struct_io_channel));
 157   ioch->magic = EXT2_ET_MAGIC_IO_CHANNEL;
 158   ioch->manager = dos_io_manager;
 159   ioch->name = (char *)malloc(strlen(part->dev)+1);
 160   if (!ioch->name) {
 161           free(ioch);
 162           return NULL;
 163   }
 164   strcpy(ioch->name, part->dev);
 165   ioch->private_data = part;
 166   ioch->block_size = 1024; /* The smallest ext2fs block size */
 167   ioch->read_error = 0;
 168   ioch->write_error = 0;
 169
 170   return ioch;
 171 }
 172
 173 #ifdef __TURBOC__
 174 #pragma argsused
 175 #endif
 176 /*
 177  * Open the 'name' partition, initialize all information structures
 178  * we need to keep and create libext2fs I/O manager.
 179  */
 180 static errcode_t dos_open(const char *dev, int flags, io_channel *channel)
 181 {
 182   unsigned char  *tmp, sec[512];
 183   PARTITION      *part;
 184   PTABLE_ENTRY   *pent;
 185   PARTITION        **newparts;
 186
 187   if(!dev)
 188   {
 189     _dio_error = ERR_BADDEV;
 190     return EXT2_ET_BAD_DEVICE_NAME;
 191   }
 192
 193   /*
 194    * First check whether the dev name is OK
 195    */
 196   tmp = (unsigned char*)strrchr(dev, '/');
 197   if(!tmp)
 198   {
 199     _dio_error = ERR_BADDEV;
 200     return EXT2_ET_BAD_DEVICE_NAME;
 201   }
 202   *tmp = 0;
 203   if(strcmp(dev, "/dev"))
 204   {
 205     _dio_error = ERR_BADDEV;
 206     return EXT2_ET_BAD_DEVICE_NAME;
 207   }
 208   *tmp++ = '/';
 209
 210   /*
 211    * Check whether the partition data is already in cache
 212    */
 213
 214   part = (PARTITION*)malloc(sizeof(PARTITION));
 215   if (!part)
 216           return ENOMEM;
 217   {
 218     int   i = 0;
 219
 220     for(;i < npart; i++)
 221       if(!strcmp(partitions[i]->dev, dev))
 222       {
 223         /* Found it! Make it the active one */
 224         active = partitions[i];
 225         *channel = alloc_io_channel(active);
 226         if (!*channel)
 227                 return ENOMEM;
 228         return 0;
 229       }
 230   }
 231
 232   /*
 233    * Drive number & optionally partn number
 234    */
 235   switch(tmp[0])
 236   {
 237     case 'h':
 238     case 's':
 239       part->phys = 0x80;
 240       part->phys += toupper(tmp[2]) - 'A';
 241       /*
 242        * Do we have the partition number?
 243        */
 244       if(tmp[3])
 245         part->pno = isdigit((int)tmp[3]) ? tmp[3] - '0' - 1: 0;
 246       else
 247         part->pno = 0xFF;
 248       break;
 249
 250     case 'f':
 251       if(tmp[2])
 252         part->phys = isdigit((int)tmp[2]) ? tmp[2] - '0' : 0;
 253       else
 254         part->phys = 0x00; /* We'll assume /dev/fd0 */
 255       break;
 256
 257     default:
 258       _dio_error = ERR_BADDEV;
 259       return ENODEV;
 260   }
 261
 262   if(part->phys < 0x80)
 263   {
 264      /* We don't support floppies for now */
 265      _dio_error = ERR_NOTSUPP;
 266      return EINVAL;
 267   }
 268
 269   part->dev = strdup(dev);
 270
 271   /*
 272    * Get drive's geometry
 273    */
 274   _dio_hw_error = biosdisk(DISK_GET_GEOMETRY,
 275                            part->phys,
 276                            0, /* head */
 277                            0, /* cylinder */
 278                            1, /* sector */
 279                            1, /* just one sector */
 280                            sec);
 281
 282   if(!HW_OK())
 283   {
 284     _dio_error = ERR_HARDWARE;
 285     free(part->dev);
 286     free(part);
 287     return EFAULT;
 288   }
 289
 290   /*
 291    * Calculate the geometry
 292    */
 293   part->cyls  = (unsigned short)(((sec[0] >> 6) << 8) + sec[1] + 1);
 294   part->heads = sec[3] + 1;
 295   part->sects = sec[0] & 0x3F;
 296
 297   /*
 298    * Now that we know all we need, let's look for the partition
 299    */
 300   _dio_hw_error = biosdisk(DISK_READ, part->phys, 0, 0, 1, 1, sec);
 301
 302   if(!HW_OK())
 303   {
 304     _dio_error = ERR_HARDWARE;
 305     free(part->dev);
 306     free(part);
 307     return EFAULT;
 308   }
 309
 310   pent = (PTABLE_ENTRY*)&sec[0x1BE];
 311   pent = scan_partition_table(pent, part->phys, &part->pno);
 312
 313   if(!pent)
 314   {
 315     _dio_error = part->pno == 0xFE ? ERR_EMPTYPART :
 316                  part->pno == 0xFD ? ERR_LINUXSWAP : ERR_NOTEXT2FS;
 317     free(part->dev);
 318     free(part);
 319     return ENODEV;
 320   }
 321
 322   /*
 323    * Calculate the remaining figures
 324    */
 325   {
 326     unsigned long    fsec, fhead, fcyl;
 327
 328     fsec = (unsigned long)(pent->start_sec & 0x3F);
 329     fhead = (unsigned long)pent->start_head;
 330     fcyl = ((pent->start_sec >> 6) << 8) + pent->start_cyl;
 331     part->start = fsec + fhead * part->sects + fcyl *
 332                   (part->heads * part->sects) - 1;
 333     part->len = pent->size;
 334   }
 335
 336   /*
 337    * Add the partition to the table
 338    */
 339   newparts = (PARTITION**)realloc(partitions, sizeof(PARTITION) * npart);
 340   if (!newparts) {
 341           free(part);
 342           return ENOMEM;
 343   }
 344   partitions = newparts;
 345   partitions[npart++] = active = part;
 346
 347   /*
 348    * Now alloc all libe2fs structures
 349    */
 350   *channel = alloc_io_channel(active);
 351   if (!*channel)
 352           return ENOMEM;
 353
 354   return 0;
 355 }
 356
 357 static errcode_t dos_close(io_channel channel)
 358 {
 359         free(channel->name);
 360         free(channel);
 361
 362         return 0;
 363 }
 364
 365 static errcode_t dos_set_blksize(io_channel channel, int blksize)
 366 {
 367   channel->block_size = blksize;
 368
 369   return 0;
 370 }
 371
 372 static errcode_t dos_read_blk(io_channel channel, unsigned long block,
 373                                              int count, void *buf)
 374 {
 375   PARTITION     *part;
 376   size_t        size;
 377   ext2_loff_t   loc;
 378   CHS           chs;
 379
 380   EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
 381   part = (PARTITION*)channel->private_data;
 382
 383   size = (size_t)((count < 0) ? -count : count * channel->block_size);
 384   loc = (ext2_loff_t) block * channel->block_size;
 385
 386   lba2chs(loc, &chs, part);
 387   /*
 388    * Potential bug here:
 389    *   If DJGPP is used then reads of >18 sectors will fail!
 390    *   Have to rewrite biosdisk.
 391    */
 392   _dio_hw_error = biosdisk(DISK_READ,
 393                            part->phys,
 394                            chs.head,
 395                            chs.cyl,
 396                            chs.sector,
 397                            size < 512 ? 1 : size/512,
 398                            buf);
 399
 400   if(!HW_OK())
 401   {
 402     _dio_error = ERR_HARDWARE;
 403     return EFAULT;
 404   }
 405
 406   return 0;
 407 }
 408
 409 static errcode_t dos_write_blk(io_channel channel, unsigned long block,
 410                                int count, const void *buf)
 411 {
 412   PARTITION     *part;
 413   size_t        size;
 414   ext2_loff_t   loc;
 415   CHS           chs;
 416
 417   EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
 418   part = (PARTITION*)channel->private_data;
 419
 420   if(count == 1)
 421     size = (size_t)channel->block_size;
 422   else
 423   {
 424     if (count < 0)
 425       size = (size_t)-count;
 426     else
 427       size = (size_t)(count * channel->block_size);
 428   }
 429
 430   loc = (ext2_loff_t)block * channel->block_size;
 431   lba2chs(loc, &chs, part);
 432   _dio_hw_error = biosdisk(DISK_WRITE,
 433                            part->phys,
 434                            chs.head,
 435                            chs.cyl,
 436                            chs.sector,
 437                            size < 512 ? 1 : size/512,
 438                            (void*)buf);
 439
 440   if(!HW_OK())
 441   {
 442     _dio_error = ERR_HARDWARE;
 443     return EFAULT;
 444   }
 445
 446   return 0;
 447 }
 448
 449 #ifdef __TURBOC__
 450 #pragma argsused
 451 #endif
 452 static errcode_t dos_flush(io_channel channel)
 453 {
 454   /*
 455    * No buffers, no flush...
 456    */
 457   return 0;
 458 }