xref: /titanic_51/usr/src/grub/grub-0.97/lib/device.c (revision 791a814c934fcd4deb13b26c1f116ff283272a0d)
1 /* device.c - Some helper functions for OS devices and BIOS drives */
2 /*
3  *  GRUB  --  GRand Unified Bootloader
4  *  Copyright (C) 1999,2000,2001,2002,2003,2004,2005  Free Software Foundation, Inc.
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 2 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, write to the Free Software
18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */
20 
21 /* Try to use glibc's transparant LFS support. */
22 #define _LARGEFILE_SOURCE       1
23 /* lseek becomes synonymous with lseek64.  */
24 #define _FILE_OFFSET_BITS       64
25 
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <ctype.h>
30 #include <assert.h>
31 #include <unistd.h>
32 #include <sys/types.h>
33 #include <sys/stat.h>
34 #include <fcntl.h>
35 #include <errno.h>
36 #include <limits.h>
37 #include <stdarg.h>
38 
39 #ifdef __linux__
40 # if !defined(__GLIBC__) || \
41         ((__GLIBC__ < 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ < 1)))
42 /* Maybe libc doesn't have large file support.  */
43 #  include <linux/unistd.h>     /* _llseek */
44 # endif /* (GLIBC < 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR < 1)) */
45 # include <sys/ioctl.h>		/* ioctl */
46 # ifndef HDIO_GETGEO
47 #  define HDIO_GETGEO	0x0301	/* get device geometry */
48 /* If HDIO_GETGEO is not defined, it is unlikely that hd_geometry is
49    defined.  */
50 struct hd_geometry
51 {
52   unsigned char heads;
53   unsigned char sectors;
54   unsigned short cylinders;
55   unsigned long start;
56 };
57 # endif /* ! HDIO_GETGEO */
58 # ifndef FLOPPY_MAJOR
59 #  define FLOPPY_MAJOR	2	/* the major number for floppy */
60 # endif /* ! FLOPPY_MAJOR */
61 # ifndef MAJOR
62 #  define MAJOR(dev)	\
63   ({ \
64      unsigned long long __dev = (dev); \
65      (unsigned) ((__dev >> 8) & 0xfff) \
66                  | ((unsigned int) (__dev >> 32) & ~0xfff); \
67   })
68 # endif /* ! MAJOR */
69 # ifndef CDROM_GET_CAPABILITY
70 #  define CDROM_GET_CAPABILITY	0x5331	/* get capabilities */
71 # endif /* ! CDROM_GET_CAPABILITY */
72 # ifndef BLKGETSIZE
73 #  define BLKGETSIZE	_IO(0x12,96)	/* return device size */
74 # endif /* ! BLKGETSIZE */
75 #endif /* __linux__ */
76 
77 /* Use __FreeBSD_kernel__ instead of __FreeBSD__ for compatibility with
78    kFreeBSD-based non-FreeBSD systems (e.g. GNU/kFreeBSD) */
79 #if defined(__FreeBSD__) && ! defined(__FreeBSD_kernel__)
80 # define __FreeBSD_kernel__
81 #endif
82 #ifdef __FreeBSD_kernel__
83   /* Obtain version of kFreeBSD headers */
84 # include <osreldate.h>
85 # ifndef __FreeBSD_kernel_version
86 #  define __FreeBSD_kernel_version __FreeBSD_version
87 # endif
88 
89   /* Runtime detection of kernel */
90 # include <sys/utsname.h>
91 int
92 get_kfreebsd_version ()
93 {
94   struct utsname uts;
95   int major; int minor, v[2];
96 
97   uname (&uts);
98   sscanf (uts.release, "%d.%d", &major, &minor);
99 
100   if (major >= 9)
101     major = 9;
102   if (major >= 5)
103     {
104       v[0] = minor/10; v[1] = minor%10;
105     }
106   else
107     {
108       v[0] = minor%10; v[1] = minor/10;
109     }
110   return major*100000+v[0]*10000+v[1]*1000;
111 }
112 #endif /* __FreeBSD_kernel__ */
113 
114 #if defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__)
115 # include <sys/ioctl.h>		/* ioctl */
116 # include <sys/disklabel.h>
117 # include <sys/cdio.h>		/* CDIOCCLRDEBUG */
118 # if defined(__FreeBSD_kernel__)
119 #  include <sys/param.h>
120 #  if __FreeBSD_kernel_version >= 500040
121 #   include <sys/disk.h>
122 #  endif
123 # endif /* __FreeBSD_kernel__ */
124 #endif /* __FreeBSD_kernel__ || __NetBSD__ || __OpenBSD__ */
125 
126 #if defined(__sun)
127 # include <sys/dkio.h>
128 #endif /* __sun */
129 
130 #ifdef HAVE_OPENDISK
131 # include <util.h>
132 #endif /* HAVE_OPENDISK */
133 
134 #define WITHOUT_LIBC_STUBS	1
135 #include <shared.h>
136 #include <device.h>
137 
138 /* Get the geometry of a drive DRIVE.  */
139 void
140 get_drive_geometry (struct geometry *geom, char **map, int drive)
141 {
142   int fd;
143 
144   if (geom->flags == -1)
145     {
146       fd = open (map[drive], O_RDONLY);
147       assert (fd >= 0);
148     }
149   else
150     fd = geom->flags;
151 
152   /* XXX This is the default size.  */
153   geom->sector_size = SECTOR_SIZE;
154 
155 #if defined(__linux__)
156   /* Linux */
157   {
158     struct hd_geometry hdg;
159     unsigned long nr;
160 
161     if (ioctl (fd, HDIO_GETGEO, &hdg))
162       goto fail;
163 
164     if (ioctl (fd, BLKGETSIZE, &nr))
165       goto fail;
166 
167     /* Got the geometry, so save it. */
168     geom->cylinders = hdg.cylinders;
169     geom->heads = hdg.heads;
170     geom->sectors = hdg.sectors;
171     geom->total_sectors = nr;
172 
173     goto success;
174   }
175 
176 #elif defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__)
177 # if defined(__FreeBSD_kernel__) && __FreeBSD_kernel_version >= 500040
178   /* kFreeBSD version 5 or later */
179   if (get_kfreebsd_version () >= 500040)
180   {
181     unsigned int sector_size;
182     off_t media_size;
183     unsigned int tmp;
184 
185     if(ioctl (fd, DIOCGSECTORSIZE, &sector_size) != 0)
186       sector_size = 512;
187 
188     if (ioctl (fd, DIOCGMEDIASIZE, &media_size) != 0)
189       goto fail;
190 
191     geom->total_sectors = media_size / sector_size;
192 
193     if (ioctl (fd, DIOCGFWSECTORS, &tmp) == 0)
194       geom->sectors = tmp;
195     else
196       geom->sectors = 63;
197     if (ioctl (fd, DIOCGFWHEADS, &tmp) == 0)
198       geom->heads = tmp;
199     else if (geom->total_sectors <= 63 * 1 * 1024)
200       geom->heads = 1;
201     else if (geom->total_sectors <= 63 * 16 * 1024)
202       geom->heads = 16;
203     else
204       geom->heads = 255;
205 
206     geom->cylinders = (geom->total_sectors
207 			   / geom->heads
208 			   / geom->sectors);
209 
210     goto success;
211   }
212   else
213 #endif /* defined(__FreeBSD_kernel__) && __FreeBSD_kernel_version >= 500040 */
214 
215   /* kFreeBSD < 5, NetBSD or OpenBSD */
216   {
217     struct disklabel hdg;
218     if (ioctl (fd, DIOCGDINFO, &hdg))
219       goto fail;
220 
221     geom->cylinders = hdg.d_ncylinders;
222     geom->heads = hdg.d_ntracks;
223     geom->sectors = hdg.d_nsectors;
224     geom->total_sectors = hdg.d_secperunit;
225 
226     goto success;
227   }
228 
229 #elif defined(__sun)
230   /* Solaris */
231   {
232     struct dk_geom dkg;
233 
234     if (ioctl(fd, DKIOCG_PHYGEOM, &dkg))
235       goto fail;
236     geom->cylinders = dkg.dkg_ncyl;
237     geom->heads = dkg.dkg_nhead;
238     geom->sectors = dkg.dkg_nsect;
239     geom->total_sectors = (unsigned long long)dkg.dkg_ncyl * dkg.dkg_nhead
240 	* dkg.dkg_nsect;
241 
242     goto success;
243   }
244 
245 #else
246   /* Notably, defined(__GNU__) */
247 # warning "Automatic detection of geometries will be performed only \
248 partially. This is not fatal."
249 #endif
250 
251  fail:
252   {
253     struct stat st;
254 
255     /* FIXME: It would be nice to somehow compute fake C/H/S settings,
256        given a proper st_blocks size. */
257     if (drive & 0x80)
258       {
259 	geom->cylinders = DEFAULT_HD_CYLINDERS;
260 	geom->heads = DEFAULT_HD_HEADS;
261 	geom->sectors = DEFAULT_HD_SECTORS;
262       }
263     else
264       {
265 	geom->cylinders = DEFAULT_FD_CYLINDERS;
266 	geom->heads = DEFAULT_FD_HEADS;
267 	geom->sectors = DEFAULT_FD_SECTORS;
268       }
269 
270     /* Set the total sectors properly, if we can. */
271     if (! fstat (fd, &st) && st.st_blocks)
272       geom->total_sectors = st.st_blocks >> SECTOR_BITS;
273     else
274       geom->total_sectors = (unsigned long long)geom->cylinders *
275 	geom->heads * geom->sectors;
276   }
277 
278  success:
279   if (geom->flags == -1)
280     close (fd);
281 }
282 
283 #ifdef __linux__
284 /* Check if we have devfs support.  */
285 static int
286 have_devfs (void)
287 {
288   static int dev_devfsd_exists = -1;
289 
290   if (dev_devfsd_exists < 0)
291     {
292       struct stat st;
293 
294       dev_devfsd_exists = stat ("/dev/.devfsd", &st) == 0;
295     }
296 
297   return dev_devfsd_exists;
298 }
299 #endif /* __linux__ */
300 
301 /* These three functions are quite different among OSes.  */
302 static void
303 get_floppy_disk_name (char *name, int unit)
304 {
305 #if defined(__linux__)
306   /* GNU/Linux */
307   if (have_devfs ())
308     sprintf (name, "/dev/floppy/%d", unit);
309   else
310     sprintf (name, "/dev/fd%d", unit);
311 #elif defined(__GNU__)
312   /* GNU/Hurd */
313   sprintf (name, "/dev/fd%d", unit);
314 #elif defined(__FreeBSD_kernel__)
315   /* kFreeBSD */
316   if (get_kfreebsd_version () >= 400000)
317     sprintf (name, "/dev/fd%d", unit);
318   else
319     sprintf (name, "/dev/rfd%d", unit);
320 #elif defined(__NetBSD__)
321   /* NetBSD */
322   /* opendisk() doesn't work for floppies.  */
323   sprintf (name, "/dev/rfd%da", unit);
324 #elif defined(__OpenBSD__)
325   /* OpenBSD */
326   sprintf (name, "/dev/rfd%dc", unit);
327 #elif defined(__QNXNTO__)
328   /* QNX RTP */
329   sprintf (name, "/dev/fd%d", unit);
330 #elif defined(__sun)
331   /* Solaris */
332   sprintf (name, "/dev/rdiskette%d", unit);
333 #else
334 # warning "BIOS floppy drives cannot be guessed in your operating system."
335   /* Set NAME to a bogus string.  */
336   *name = 0;
337 #endif
338 }
339 
340 static void
341 get_ide_disk_name (char *name, int unit)
342 {
343 #if defined(__linux__)
344   /* GNU/Linux */
345   sprintf (name, "/dev/hd%c", unit + 'a');
346 #elif defined(__GNU__)
347   /* GNU/Hurd */
348   sprintf (name, "/dev/hd%d", unit);
349 #elif defined(__FreeBSD_kernel__)
350   /* kFreeBSD */
351   if (get_kfreebsd_version () >= 400000)
352     sprintf (name, "/dev/ad%d", unit);
353   else
354     sprintf (name, "/dev/rwd%d", unit);
355 #elif defined(__NetBSD__) && defined(HAVE_OPENDISK)
356   /* NetBSD */
357   char shortname[16];
358   int fd;
359 
360   sprintf (shortname, "wd%d", unit);
361   fd = opendisk (shortname, O_RDONLY, name,
362 		 16,	/* length of NAME */
363 		 0	/* char device */
364 		 );
365   close (fd);
366 #elif defined(__OpenBSD__)
367   /* OpenBSD */
368   sprintf (name, "/dev/rwd%dc", unit);
369 #elif defined(__QNXNTO__)
370   /* QNX RTP */
371   /* Actually, QNX RTP doesn't distinguish IDE from SCSI, so this could
372      contain SCSI disks.  */
373   sprintf (name, "/dev/hd%d", unit);
374 #elif defined(__sun)
375   *name = 0;		/* FIXME */
376 #else
377 # warning "BIOS IDE drives cannot be guessed in your operating system."
378   /* Set NAME to a bogus string.  */
379   *name = 0;
380 #endif
381 }
382 
383 static void
384 get_scsi_disk_name (char *name, int unit)
385 {
386 #if defined(__linux__)
387   /* GNU/Linux */
388   sprintf (name, "/dev/sd%c", unit + 'a');
389 #elif defined(__GNU__)
390   /* GNU/Hurd */
391   sprintf (name, "/dev/sd%d", unit);
392 #elif defined(__FreeBSD_kernel__)
393   /* kFreeBSD */
394   if (get_kfreebsd_version () >= 400000)
395     sprintf (name, "/dev/da%d", unit);
396   else
397     sprintf (name, "/dev/rda%d", unit);
398 #elif defined(__NetBSD__) && defined(HAVE_OPENDISK)
399   /* NetBSD */
400   char shortname[16];
401   int fd;
402 
403   sprintf (shortname, "sd%d", unit);
404   fd = opendisk (shortname, O_RDONLY, name,
405 		 16,	/* length of NAME */
406 		 0	/* char device */
407 		 );
408   close (fd);
409 #elif defined(__OpenBSD__)
410   /* OpenBSD */
411   sprintf (name, "/dev/rsd%dc", unit);
412 #elif defined(__QNXNTO__)
413   /* QNX RTP */
414   /* QNX RTP doesn't distinguish SCSI from IDE, so it is better to
415      disable the detection of SCSI disks here.  */
416   *name = 0;
417 #elif defined(__sun)
418   *name = 0;		/* FIXME */
419 #else
420 # warning "BIOS SCSI drives cannot be guessed in your operating system."
421   /* Set NAME to a bogus string.  */
422   *name = 0;
423 #endif
424 }
425 
426 #ifdef __linux__
427 static void
428 get_dac960_disk_name (char *name, int controller, int drive)
429 {
430   sprintf (name, "/dev/rd/c%dd%d", controller, drive);
431 }
432 
433 static void
434 get_ataraid_disk_name (char *name, int unit)
435 {
436   sprintf (name, "/dev/ataraid/d%c", unit + '0');
437 }
438 #endif
439 
440 /* Check if DEVICE can be read. If an error occurs, return zero,
441    otherwise return non-zero.  */
442 int
443 check_device (const char *device)
444 {
445   char buf[512];
446   FILE *fp;
447 
448   /* If DEVICE is empty, just return 1.  */
449   if (*device == 0)
450     return 1;
451 
452   fp = fopen (device, "r");
453   if (! fp)
454     {
455       switch (errno)
456 	{
457 #ifdef ENOMEDIUM
458 	case ENOMEDIUM:
459 # if 0
460 	  /* At the moment, this finds only CDROMs, which can't be
461 	     read anyway, so leave it out. Code should be
462 	     reactivated if `removable disks' and CDROMs are
463 	     supported.  */
464 	  /* Accept it, it may be inserted.  */
465 	  return 1;
466 # endif
467 	  break;
468 #endif /* ENOMEDIUM */
469 	default:
470 	  /* Break case and leave.  */
471 	  break;
472 	}
473       /* Error opening the device.  */
474       return 0;
475     }
476 
477   /* Make sure CD-ROMs don't get assigned a BIOS disk number
478      before SCSI disks!  */
479 #ifdef __linux__
480 # ifdef CDROM_GET_CAPABILITY
481   if (ioctl (fileno (fp), CDROM_GET_CAPABILITY, 0) >= 0)
482     return 0;
483 # else /* ! CDROM_GET_CAPABILITY */
484   /* Check if DEVICE is a CD-ROM drive by the HDIO_GETGEO ioctl.  */
485   {
486     struct hd_geometry hdg;
487     struct stat st;
488 
489     if (fstat (fileno (fp), &st))
490       return 0;
491 
492     /* If it is a block device and isn't a floppy, check if HDIO_GETGEO
493        succeeds.  */
494     if (S_ISBLK (st.st_mode)
495 	&& MAJOR (st.st_rdev) != FLOPPY_MAJOR
496 	&& ioctl (fileno (fp), HDIO_GETGEO, &hdg))
497       return 0;
498   }
499 # endif /* ! CDROM_GET_CAPABILITY */
500 #endif /* __linux__ */
501 
502 #if defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__)
503 # ifdef CDIOCCLRDEBUG
504   if (ioctl (fileno (fp), CDIOCCLRDEBUG, 0) >= 0)
505     return 0;
506 # endif /* CDIOCCLRDEBUG */
507 #endif /* __FreeBSD_kernel__ || __NetBSD__ || __OpenBSD__ */
508 
509   /* Attempt to read the first sector.  */
510   if (fread (buf, 1, 512, fp) != 512)
511     {
512       fclose (fp);
513       return 0;
514     }
515 
516   fclose (fp);
517   return 1;
518 }
519 
520 /* Read mapping information from FP, and write it to MAP.  */
521 static int
522 read_device_map (FILE *fp, char **map, const char *map_file)
523 {
524   auto void show_error (int no, const char *msg);
525   auto void show_warning (int no, const char *msg, ...);
526 
527   auto void show_error (int no, const char *msg)
528     {
529       fprintf (stderr, "%s:%d: error: %s\n", map_file, no, msg);
530     }
531 
532   auto void show_warning (int no, const char *msg, ...)
533     {
534       va_list ap;
535 
536       va_start (ap, msg);
537       fprintf (stderr, "%s:%d: warning: ", map_file, no);
538       vfprintf (stderr, msg, ap);
539       va_end (ap);
540     }
541 
542   /* If there is the device map file, use the data in it instead of
543      probing devices.  */
544   char buf[1024];		/* XXX */
545   int line_number = 0;
546 
547   while (fgets (buf, sizeof (buf), fp))
548     {
549       char *ptr, *eptr;
550       int drive;
551       int is_floppy = 0;
552 
553       /* Increase the number of lines.  */
554       line_number++;
555 
556       /* If the first character is '#', skip it.  */
557       if (buf[0] == '#')
558 	continue;
559 
560       ptr = buf;
561       /* Skip leading spaces.  */
562       while (*ptr && isspace (*ptr))
563 	ptr++;
564 
565       /* Skip empty lines.  */
566       if (! *ptr)
567 	continue;
568 
569       if (*ptr != '(')
570 	{
571 	  show_error (line_number, "No open parenthesis found");
572 	  return 0;
573 	}
574 
575       ptr++;
576       if ((*ptr != 'f' && *ptr != 'h') || *(ptr + 1) != 'd')
577 	{
578 	  show_error (line_number, "Bad drive name");
579 	  return 0;
580 	}
581 
582       if (*ptr == 'f')
583 	is_floppy = 1;
584 
585       ptr += 2;
586       drive = strtoul (ptr, &ptr, 10);
587       if (drive < 0)
588 	{
589 	  show_error (line_number, "Bad device number");
590 	  return 0;
591 	}
592       else if (drive > 127)
593 	{
594 	  show_warning (line_number,
595 			"Ignoring %cd%d due to a BIOS limitation",
596 			is_floppy ? 'f' : 'h', drive);
597 	  continue;
598 	}
599 
600       if (! is_floppy)
601 	drive += 0x80;
602 
603       if (*ptr != ')')
604 	{
605 	  show_error (line_number, "No close parenthesis found");
606 	  return 0;
607 	}
608 
609       ptr++;
610       /* Skip spaces.  */
611       while (*ptr && isspace (*ptr))
612 	ptr++;
613 
614       if (! *ptr)
615 	{
616 	  show_error (line_number, "No filename found");
617 	  return 0;
618 	}
619 
620       /* Terminate the filename.  */
621       eptr = ptr;
622       while (*eptr && ! isspace (*eptr))
623 	eptr++;
624       *eptr = 0;
625 
626       /* Multiple entries for a given drive is not allowed.  */
627       if (map[drive])
628 	{
629 	  show_error (line_number, "Duplicated entry found");
630 	  return 0;
631 	}
632 
633       map[drive] = strdup (ptr);
634       assert (map[drive]);
635     }
636 
637   return 1;
638 }
639 
640 /* Initialize the device map MAP. *MAP will be allocated from the heap
641    space. If MAP_FILE is not NULL, then read mappings from the file
642    MAP_FILE if it exists, otherwise, write guessed mappings to the file.
643    FLOPPY_DISKS is the number of floppy disk drives which will be probed.
644    If it is zero, don't probe any floppy at all. If it is one, probe one
645    floppy. If it is two, probe two floppies. And so on.  */
646 int
647 init_device_map (char ***map, const char *map_file, int floppy_disks)
648 {
649   int i;
650   int num_hd = 0;
651   FILE *fp = 0;
652 
653   assert (map);
654   assert (*map == 0);
655   *map = malloc (NUM_DISKS * sizeof (char *));
656   assert (*map);
657 
658   /* Probe devices for creating the device map.  */
659 
660   /* Initialize DEVICE_MAP.  */
661   for (i = 0; i < NUM_DISKS; i++)
662     (*map)[i] = 0;
663 
664   if (map_file)
665     {
666       /* Open the device map file.  */
667       fp = fopen (map_file, "r");
668       if (fp)
669 	{
670 	  int ret;
671 
672 	  ret = read_device_map (fp, *map, map_file);
673 	  fclose (fp);
674 	  return ret;
675 	}
676     }
677 
678   /* Print something so that the user does not think GRUB has been
679      crashed.  */
680   fprintf (stderr,
681 	   "Probing devices to guess BIOS drives. "
682 	   "This may take a long time.\n");
683 
684   if (map_file)
685     /* Try to open the device map file to write the probed data.  */
686     fp = fopen (map_file, "w");
687 
688   /* Floppies.  */
689   for (i = 0; i < floppy_disks; i++)
690     {
691       char name[16];
692 
693       get_floppy_disk_name (name, i);
694       /* In floppies, write the map, whether check_device succeeds
695 	 or not, because the user just does not insert floppies.  */
696       if (fp)
697 	fprintf (fp, "(fd%d)\t%s\n", i, name);
698 
699       if (check_device (name))
700 	{
701 	  (*map)[i] = strdup (name);
702 	  assert ((*map)[i]);
703 	}
704     }
705 
706 #ifdef __linux__
707   if (have_devfs ())
708     {
709       while (1)
710 	{
711 	  char discn[32];
712 	  char name[PATH_MAX];
713 	  struct stat st;
714 
715 	  /* Linux creates symlinks "/dev/discs/discN" for convenience.
716 	     The way to number disks is the same as GRUB's.  */
717 	  sprintf (discn, "/dev/discs/disc%d", num_hd);
718 	  if (stat (discn, &st) < 0)
719 	    break;
720 
721 	  if (realpath (discn, name))
722 	    {
723 	      strcat (name, "/disc");
724 	      (*map)[num_hd + 0x80] = strdup (name);
725 	      assert ((*map)[num_hd + 0x80]);
726 
727 	      /* If the device map file is opened, write the map.  */
728 	      if (fp)
729 		fprintf (fp, "(hd%d)\t%s\n", num_hd, name);
730 	    }
731 
732 	  num_hd++;
733 	}
734 
735       /* OK, close the device map file if opened.  */
736       if (fp)
737 	fclose (fp);
738 
739       return 1;
740     }
741 #endif /* __linux__ */
742 
743   /* IDE disks.  */
744   for (i = 0; i < 8; i++)
745     {
746       char name[16];
747 
748       get_ide_disk_name (name, i);
749       if (check_device (name))
750 	{
751 	  (*map)[num_hd + 0x80] = strdup (name);
752 	  assert ((*map)[num_hd + 0x80]);
753 
754 	  /* If the device map file is opened, write the map.  */
755 	  if (fp)
756 	    fprintf (fp, "(hd%d)\t%s\n", num_hd, name);
757 
758 	  num_hd++;
759 	}
760     }
761 
762 #ifdef __linux__
763   /* ATARAID disks.  */
764   for (i = 0; i < 8; i++)
765     {
766       char name[20];
767 
768       get_ataraid_disk_name (name, i);
769       if (check_device (name))
770         {
771           (*map)[num_hd + 0x80] = strdup (name);
772           assert ((*map)[num_hd + 0x80]);
773 
774           /* If the device map file is opened, write the map.  */
775           if (fp)
776             fprintf (fp, "(hd%d)\t%s\n", num_hd, name);
777 
778           num_hd++;
779         }
780     }
781 #endif /* __linux__ */
782 
783   /* The rest is SCSI disks.  */
784   for (i = 0; i < 16; i++)
785     {
786       char name[16];
787 
788       get_scsi_disk_name (name, i);
789       if (check_device (name))
790 	{
791 	  (*map)[num_hd + 0x80] = strdup (name);
792 	  assert ((*map)[num_hd + 0x80]);
793 
794 	  /* If the device map file is opened, write the map.  */
795 	  if (fp)
796 	    fprintf (fp, "(hd%d)\t%s\n", num_hd, name);
797 
798 	  num_hd++;
799 	}
800     }
801 
802 #ifdef __linux__
803   /* This is for DAC960 - we have
804      /dev/rd/c<controller>d<logical drive>p<partition>.
805 
806      DAC960 driver currently supports up to 8 controllers, 32 logical
807      drives, and 7 partitions.  */
808   {
809     int controller, drive;
810 
811     for (controller = 0; controller < 8; controller++)
812       {
813 	for (drive = 0; drive < 15; drive++)
814 	  {
815 	    char name[24];
816 
817 	    get_dac960_disk_name (name, controller, drive);
818 	    if (check_device (name))
819 	      {
820 		(*map)[num_hd + 0x80] = strdup (name);
821 		assert ((*map)[num_hd + 0x80]);
822 
823 		/* If the device map file is opened, write the map.  */
824 		if (fp)
825 		  fprintf (fp, "(hd%d)\t%s\n", num_hd, name);
826 
827 		num_hd++;
828 	      }
829 	  }
830       }
831   }
832 #endif /* __linux__ */
833 
834   /* OK, close the device map file if opened.  */
835   if (fp)
836     fclose (fp);
837 
838   return 1;
839 }
840 
841 /* Restore the memory consumed for MAP.  */
842 void
843 restore_device_map (char **map)
844 {
845   int i;
846 
847   for (i = 0; i < NUM_DISKS; i++)
848     if (map[i])
849       free (map[i]);
850 
851   free (map);
852 }
853 
854 #ifdef __linux__
855 /* Linux-only functions, because Linux has a bug that the disk cache for
856    a whole disk is not consistent with the one for a partition of the
857    disk.  */
858 int
859 is_disk_device (char **map, int drive)
860 {
861   struct stat st;
862 
863   assert (map[drive] != 0);
864   assert (stat (map[drive], &st) == 0);
865   /* For now, disk devices under Linux are all block devices.  */
866   return S_ISBLK (st.st_mode);
867 }
868 
869 int
870 write_to_partition (char **map, int drive, int partition,
871 		    int sector, int size, const char *buf)
872 {
873   char dev[PATH_MAX];	/* XXX */
874   int fd;
875 
876   if ((partition & 0x00FF00) != 0x00FF00)
877     {
878       /* If the partition is a BSD partition, it is difficult to
879 	 obtain the representation in Linux. So don't support that.  */
880       errnum = ERR_DEV_VALUES;
881       return 1;
882     }
883 
884   assert (map[drive] != 0);
885 
886   strcpy (dev, map[drive]);
887   if (have_devfs ())
888     {
889       if (strcmp (dev + strlen(dev) - 5, "/disc") == 0)
890 	strcpy (dev + strlen(dev) - 5, "/part");
891     }
892   sprintf (dev + strlen(dev), "%d", ((partition >> 16) & 0xFF) + 1);
893 
894   /* Open the partition.  */
895   fd = open (dev, O_RDWR);
896   if (fd < 0)
897     {
898       errnum = ERR_NO_PART;
899       return 0;
900     }
901 
902 #if defined(__linux__) && (!defined(__GLIBC__) || \
903         ((__GLIBC__ < 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ < 1))))
904   /* Maybe libc doesn't have large file support.  */
905   {
906     loff_t offset, result;
907     static int _llseek (uint filedes, ulong hi, ulong lo,
908                         loff_t *res, uint wh);
909     _syscall5 (int, _llseek, uint, filedes, ulong, hi, ulong, lo,
910                loff_t *, res, uint, wh);
911 
912     offset = (loff_t) sector * (loff_t) SECTOR_SIZE;
913     if (_llseek (fd, offset >> 32, offset & 0xffffffff, &result, SEEK_SET))
914       {
915 	errnum = ERR_DEV_VALUES;
916 	return 0;
917       }
918   }
919 #else
920   {
921     off_t offset = (off_t) sector * (off_t) SECTOR_SIZE;
922 
923     if (lseek (fd, offset, SEEK_SET) != offset)
924       {
925 	errnum = ERR_DEV_VALUES;
926 	return 0;
927       }
928   }
929 #endif
930 
931   if (write (fd, buf, size * SECTOR_SIZE) != (size * SECTOR_SIZE))
932     {
933       close (fd);
934       errnum = ERR_WRITE;
935       return 0;
936     }
937 
938   sync ();	/* Paranoia.  */
939   close (fd);
940 
941   return 1;
942 }
943 #endif /* __linux__ */
944