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