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