[thirdparty/e2fsprogs.git] / lib / ext2fs / dosio.c

/*
 * dosio.c -- Disk I/O module for the ext2fs/DOS library.
 *
 * Copyright (c) 1997 by Theodore Ts'o.
 *
 * Copyright (c) 1997 Mark Habersack
 * This file may be distributed under the terms of the GNU Public License.
 *
 */

#include <stdio.h>
#include <bios.h>
#include <string.h>
#include <ctype.h>
#include <io.h>
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif

#include <ext2fs/ext2_types.h>
#include "utils.h"
#include "dosio.h"
#include "et/com_err.h"
#include "ext2_err.h"
#include "ext2fs/io.h"

/*
 * Some helper macros
 */
#define LINUX_EXT2FS       0x83
#define LINUX_SWAP         0x82
#define WRITE_ERR(_msg_) write(2, _msg_, strlen(_msg_))
#define WRITE_ERR_S(_msg_) write(2, _msg_, sizeof(_msg_))

/*
 * Exported variables
 */
unsigned long        _dio_error;
unsigned long        _dio_hw_error;

/*
 * Array of all opened partitions
 */
static PARTITION        **partitions = NULL;
static unsigned short   npart = 0; /* Number of mapped partitions */
static PARTITION        *active = NULL;

/*
 * I/O Manager routine prototypes
 */
static errcode_t dos_open(const char *dev, int flags, io_channel *channel);
static errcode_t dos_close(io_channel channel);
static errcode_t dos_set_blksize(io_channel channel, int blksize);
static errcode_t dos_read_blk(io_channel channel, unsigned long block,
                                             int count, void *buf);
static errcode_t dos_write_blk(io_channel channel, unsigned long block,
                               int count, const void *buf);
static errcode_t dos_flush(io_channel channel);

static struct struct_io_manager struct_dos_manager = {
        EXT2_ET_MAGIC_IO_MANAGER,
        "DOS I/O Manager",
        dos_open,
        dos_close,
        dos_set_blksize,
        dos_read_blk,
        dos_write_blk,
        dos_flush
};
io_manager dos_io_manager = &struct_dos_manager;

/*
 * Macro taken from unix_io.c
 */
/*
 * For checking structure magic numbers...
 */

#define EXT2_CHECK_MAGIC(struct, code) \
          if ((struct)->magic != (code)) return (code)

/*
 * Calculates a CHS address of a sector from its LBA
 * offset for the given partition.
 */
static void lba2chs(unsigned long lba_addr, CHS *chs, PARTITION *part)
{
  unsigned long      abss;

  chs->offset = lba_addr & 0x000001FF;
  abss = (lba_addr >> 9) + part->start;
  chs->cyl    = abss / (part->sects * part->heads);
  chs->head   = (abss / part->sects) % part->heads;
  chs->sector = (abss % part->sects) + 1;
}

#ifdef __TURBOC__
#pragma argsused
#endif
/*
 * Scans the passed partition table looking for *pno partition
 * that has LINUX_EXT2FS type.
 *
 * TODO:
 * For partition numbers >5 Linux uses DOS extended partitions -
 * dive into them an return an appropriate entry. Also dive into
 * extended partitions when scanning for a first Linux/ext2fs.
 */
static PTABLE_ENTRY *scan_partition_table(PTABLE_ENTRY *pentry,
                                          unsigned short phys,
                                          unsigned char *pno)
{
  unsigned        i;

  if(*pno != 0xFF && *pno >= 5)
     return NULL; /* We don't support extended partitions for now */

  if(*pno != 0xFF)
  {
    if(pentry[*pno].type == LINUX_EXT2FS)
      return &pentry[*pno];
    else
    {
      if(!pentry[*pno].type)
        *pno = 0xFE;
      else if(pentry[*pno].type == LINUX_SWAP)
        *pno = 0xFD;
      return NULL;
    }
  }

  for(i = 0; i < 4; i++)
    if(pentry[i].type == LINUX_EXT2FS)
    {
      *pno = i;
      return &pentry[i];
    }

  return NULL;
}

/*
 * Allocate libext2fs structures associated with I/O manager
 */
static io_channel alloc_io_channel(PARTITION *part)
{
  io_channel     ioch;

  ioch = (io_channel)malloc(sizeof(struct struct_io_channel));
  if (!ioch)
	  return NULL;
  memset(ioch, 0, sizeof(struct struct_io_channel));
  ioch->magic = EXT2_ET_MAGIC_IO_CHANNEL;
  ioch->manager = dos_io_manager;
  ioch->name = (char *)malloc(strlen(part->dev)+1);
  if (!ioch->name) {
	  free(ioch);
	  return NULL;
  }
  strcpy(ioch->name, part->dev);
  ioch->private_data = part;
  ioch->block_size = 1024; /* The smallest ext2fs block size */
  ioch->read_error = 0;
  ioch->write_error = 0;

  return ioch;
}

#ifdef __TURBOC__
#pragma argsused
#endif
/*
 * Open the 'name' partition, initialize all information structures
 * we need to keep and create libext2fs I/O manager.
 */
static errcode_t dos_open(const char *dev, int flags, io_channel *channel)
{
  unsigned char  *tmp, sec[512];
  PARTITION      *part;
  PTABLE_ENTRY   *pent;
  PARTITION        **newparts;

  if(!dev)
  {
    _dio_error = ERR_BADDEV;
    return EXT2_ET_BAD_DEVICE_NAME;
  }

  /*
   * First check whether the dev name is OK
   */
  tmp = (unsigned char*)strrchr(dev, '/');
  if(!tmp)
  {
    _dio_error = ERR_BADDEV;
    return EXT2_ET_BAD_DEVICE_NAME;
  }
  *tmp = 0;
  if(strcmp(dev, "/dev"))
  {
    _dio_error = ERR_BADDEV;
    return EXT2_ET_BAD_DEVICE_NAME;
  }
  *tmp++ = '/';

  /*
   * Check whether the partition data is already in cache
   */

  part = (PARTITION*)malloc(sizeof(PARTITION));
  if (!part)
	  return ENOMEM;
  {
    int   i = 0;

    for(;i < npart; i++)
      if(!strcmp(partitions[i]->dev, dev))
      {
        /* Found it! Make it the active one */
        active = partitions[i];
        *channel = alloc_io_channel(active);
	if (!*channel)
		return ENOMEM;
        return 0;
      }
  }

  /*
   * Drive number & optionally partn number
   */
  switch(tmp[0])
  {
    case 'h':
    case 's':
      part->phys = 0x80;
      part->phys += toupper(tmp[2]) - 'A';
      /*
       * Do we have the partition number?
       */
      if(tmp[3])
        part->pno = isdigit((int)tmp[3]) ? tmp[3] - '0' - 1: 0;
      else
        part->pno = 0xFF;
      break;

    case 'f':
      if(tmp[2])
        part->phys = isdigit((int)tmp[2]) ? tmp[2] - '0' : 0;
      else
        part->phys = 0x00; /* We'll assume /dev/fd0 */
      break;

    default:
      _dio_error = ERR_BADDEV;
      return ENODEV;
  }

  if(part->phys < 0x80)
  {
     /* We don't support floppies for now */
     _dio_error = ERR_NOTSUPP;
     return EINVAL;
  }

  part->dev = strdup(dev);

  /*
   * Get drive's geometry
   */
  _dio_hw_error = biosdisk(DISK_GET_GEOMETRY,
                           part->phys,
                           0, /* head */
                           0, /* cylinder */
                           1, /* sector */
                           1, /* just one sector */
                           sec);

  if(!HW_OK())
  {
    _dio_error = ERR_HARDWARE;
    if (part)
	    free(part);
    return EFAULT;
  }

  /*
   * Calculate the geometry
   */
  part->cyls  = (unsigned short)(((sec[0] >> 6) << 8) + sec[1] + 1);
  part->heads = sec[3] + 1;
  part->sects = sec[0] & 0x3F;

  /*
   * Now that we know all we need, let's look for the partition
   */
  _dio_hw_error = biosdisk(DISK_READ, part->phys, 0, 0, 1, 1, sec);

  if(!HW_OK())
  {
    _dio_error = ERR_HARDWARE;
    if (part)
	    free(part);
    return EFAULT;
  }

  pent = (PTABLE_ENTRY*)&sec[0x1BE];
  pent = scan_partition_table(pent, part->phys, &part->pno);

  if(!pent)
  {
    _dio_error = part->pno == 0xFE ? ERR_EMPTYPART :
                 part->pno == 0xFD ? ERR_LINUXSWAP : ERR_NOTEXT2FS;
    if (part)
	    free(part);
    return ENODEV;
  }

  /*
   * Calculate the remaining figures
   */
  {
    unsigned long    fsec, fhead, fcyl;

    fsec = (unsigned long)(pent->start_sec & 0x3F);
    fhead = (unsigned long)pent->start_head;
    fcyl = ((pent->start_sec >> 6) << 8) + pent->start_cyl;
    part->start = fsec + fhead * part->sects + fcyl *
                  (part->heads * part->sects) - 1;
    part->len = pent->size;
  }

  /*
   * Add the partition to the table
   */
  newparts = (PARTITION**)realloc(partitions, sizeof(PARTITION) * npart);
  if (!newparts) {
	  free(part);
	  return ENOMEM;
  }
  partitions = newparts;
  partitions[npart++] = active = part;

  /*
   * Now alloc all libe2fs structures
   */
  *channel = alloc_io_channel(active);
  if (!*channel)
	  return ENOMEM;

  return 0;
}

static errcode_t dos_close(io_channel channel)
{
	if (channel->name)
		free(channel->name);
	if (channel)
		free(channel);

	return 0;
}

static errcode_t dos_set_blksize(io_channel channel, int blksize)
{
  channel->block_size = blksize;

  return 0;
}

static errcode_t dos_read_blk(io_channel channel, unsigned long block,
                                             int count, void *buf)
{
  PARTITION     *part;
  size_t        size;
  ext2_loff_t   loc;
  CHS           chs;

  EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
  part = (PARTITION*)channel->private_data;

  size = (size_t)((count < 0) ? -count : count * channel->block_size);
  loc = (ext2_loff_t) block * channel->block_size;

  lba2chs(loc, &chs, part);
  /*
   * Potential bug here:
   *   If DJGPP is used then reads of >18 sectors will fail!
   *   Have to rewrite biosdisk.
   */
  _dio_hw_error = biosdisk(DISK_READ,
                           part->phys,
                           chs.head,
                           chs.cyl,
                           chs.sector,
                           size < 512 ? 1 : size/512,
                           buf);

  if(!HW_OK())
  {
    _dio_error = ERR_HARDWARE;
    return EFAULT;
  }

  return 0;
}

static errcode_t dos_write_blk(io_channel channel, unsigned long block,
                               int count, const void *buf)
{
  PARTITION     *part;
  size_t        size;
  ext2_loff_t   loc;
  CHS           chs;

  EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
  part = (PARTITION*)channel->private_data;

  if(count == 1)
    size = (size_t)channel->block_size;
  else
  {
    if (count < 0)
      size = (size_t)-count;
    else
      size = (size_t)(count * channel->block_size);
  }

  loc = (ext2_loff_t)block * channel->block_size;
  lba2chs(loc, &chs, part);
  _dio_hw_error = biosdisk(DISK_WRITE,
                           part->phys,
                           chs.head,
                           chs.cyl,
                           chs.sector,
                           size < 512 ? 1 : size/512,
                           (void*)buf);

  if(!HW_OK())
  {
    _dio_error = ERR_HARDWARE;
    return EFAULT;
  }

  return 0;
}

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