2 * GRUB -- GRand Unified Bootloader
3 * Copyright (C) 2002,2003,2004,2006,2007,2008 Free Software Foundation, Inc.
5 * GRUB is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, either version 3 of the License, or
8 * (at your option) any later version.
10 * GRUB is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with GRUB. If not, see <http://www.gnu.org/licenses/>.
19 #include <grub/disk.h>
22 #include <grub/types.h>
23 #include <grub/partition.h>
24 #include <grub/misc.h>
25 #include <grub/time.h>
26 #include <grub/file.h>
28 #define GRUB_CACHE_TIMEOUT 2
30 /* The last time the disk was used. */
31 static grub_uint64_t grub_last_time
= 0;
35 struct grub_disk_cache
38 unsigned long disk_id
;
39 grub_disk_addr_t sector
;
44 static struct grub_disk_cache grub_disk_cache_table
[GRUB_DISK_CACHE_NUM
];
46 void (*grub_disk_firmware_fini
) (void);
47 int grub_disk_firmware_is_tainted
;
49 grub_err_t (* grub_disk_ata_pass_through
) (grub_disk_t
,
50 struct grub_disk_ata_pass_through_parms
*);
54 static unsigned long grub_disk_cache_hits
;
55 static unsigned long grub_disk_cache_misses
;
58 grub_disk_cache_get_performance (unsigned long *hits
, unsigned long *misses
)
60 *hits
= grub_disk_cache_hits
;
61 *misses
= grub_disk_cache_misses
;
66 grub_disk_cache_get_index (unsigned long dev_id
, unsigned long disk_id
,
67 grub_disk_addr_t sector
)
69 return ((dev_id
* 524287UL + disk_id
* 2606459UL
70 + ((unsigned) (sector
>> GRUB_DISK_CACHE_BITS
)))
71 % GRUB_DISK_CACHE_NUM
);
75 grub_disk_cache_invalidate (unsigned long dev_id
, unsigned long disk_id
,
76 grub_disk_addr_t sector
)
79 struct grub_disk_cache
*cache
;
81 sector
&= ~(GRUB_DISK_CACHE_SIZE
- 1);
82 index
= grub_disk_cache_get_index (dev_id
, disk_id
, sector
);
83 cache
= grub_disk_cache_table
+ index
;
85 if (cache
->dev_id
== dev_id
&& cache
->disk_id
== disk_id
86 && cache
->sector
== sector
&& cache
->data
)
89 grub_free (cache
->data
);
96 grub_disk_cache_invalidate_all (void)
100 for (i
= 0; i
< GRUB_DISK_CACHE_NUM
; i
++)
102 struct grub_disk_cache
*cache
= grub_disk_cache_table
+ i
;
104 if (cache
->data
&& ! cache
->lock
)
106 grub_free (cache
->data
);
113 grub_disk_cache_fetch (unsigned long dev_id
, unsigned long disk_id
,
114 grub_disk_addr_t sector
)
116 struct grub_disk_cache
*cache
;
119 index
= grub_disk_cache_get_index (dev_id
, disk_id
, sector
);
120 cache
= grub_disk_cache_table
+ index
;
122 if (cache
->dev_id
== dev_id
&& cache
->disk_id
== disk_id
123 && cache
->sector
== sector
)
127 grub_disk_cache_hits
++;
133 grub_disk_cache_misses
++;
140 grub_disk_cache_unlock (unsigned long dev_id
, unsigned long disk_id
,
141 grub_disk_addr_t sector
)
143 struct grub_disk_cache
*cache
;
146 index
= grub_disk_cache_get_index (dev_id
, disk_id
, sector
);
147 cache
= grub_disk_cache_table
+ index
;
149 if (cache
->dev_id
== dev_id
&& cache
->disk_id
== disk_id
150 && cache
->sector
== sector
)
155 grub_disk_cache_store (unsigned long dev_id
, unsigned long disk_id
,
156 grub_disk_addr_t sector
, const char *data
)
159 struct grub_disk_cache
*cache
;
161 index
= grub_disk_cache_get_index (dev_id
, disk_id
, sector
);
162 cache
= grub_disk_cache_table
+ index
;
165 grub_free (cache
->data
);
169 cache
->data
= grub_malloc (GRUB_DISK_SECTOR_SIZE
<< GRUB_DISK_CACHE_BITS
);
173 grub_memcpy (cache
->data
, data
,
174 GRUB_DISK_SECTOR_SIZE
<< GRUB_DISK_CACHE_BITS
);
175 cache
->dev_id
= dev_id
;
176 cache
->disk_id
= disk_id
;
177 cache
->sector
= sector
;
179 return GRUB_ERR_NONE
;
184 static grub_disk_dev_t grub_disk_dev_list
;
187 grub_disk_dev_register (grub_disk_dev_t dev
)
189 dev
->next
= grub_disk_dev_list
;
190 grub_disk_dev_list
= dev
;
194 grub_disk_dev_unregister (grub_disk_dev_t dev
)
196 grub_disk_dev_t
*p
, q
;
198 for (p
= &grub_disk_dev_list
, q
= *p
; q
; p
= &(q
->next
), q
= q
->next
)
207 grub_disk_dev_iterate (int (*hook
) (const char *name
))
211 for (p
= grub_disk_dev_list
; p
; p
= p
->next
)
212 if (p
->iterate
&& (p
->iterate
) (hook
))
219 grub_disk_open (const char *name
)
224 char *raw
= (char *) name
;
225 grub_uint64_t current_time
;
227 grub_dprintf ("disk", "Opening `%s'...\n", name
);
229 disk
= (grub_disk_t
) grub_malloc (sizeof (*disk
));
237 disk
->name
= grub_strdup (name
);
241 p
= grub_strchr (name
, ',');
244 grub_size_t len
= p
- name
;
246 raw
= grub_malloc (len
+ 1);
250 grub_memcpy (raw
, name
, len
);
254 for (dev
= grub_disk_dev_list
; dev
; dev
= dev
->next
)
256 if ((dev
->open
) (raw
, disk
) == GRUB_ERR_NONE
)
258 else if (grub_errno
== GRUB_ERR_UNKNOWN_DEVICE
)
259 grub_errno
= GRUB_ERR_NONE
;
266 grub_error (GRUB_ERR_UNKNOWN_DEVICE
, "no such disk");
270 if (p
&& ! disk
->has_partitions
)
272 grub_error (GRUB_ERR_BAD_DEVICE
, "no partition on this disk");
280 disk
->partition
= grub_partition_probe (disk
, p
+ 1);
281 if (! disk
->partition
)
283 grub_error (GRUB_ERR_UNKNOWN_DEVICE
, "no such partition");
288 /* The cache will be invalidated about 2 seconds after a device was
290 current_time
= grub_get_time_ms ();
292 if (current_time
> (grub_last_time
293 + GRUB_CACHE_TIMEOUT
* 1000))
294 grub_disk_cache_invalidate_all ();
296 grub_last_time
= current_time
;
300 if (raw
&& raw
!= name
)
303 if (grub_errno
!= GRUB_ERR_NONE
)
306 grub_dprintf ("disk", "Opening `%s' failed.\n", name
);
309 grub_disk_close (disk
);
317 grub_disk_close (grub_disk_t disk
)
319 grub_dprintf ("disk", "Closing `%s'.\n", disk
->name
);
321 if (disk
->dev
&& disk
->dev
->close
)
322 (disk
->dev
->close
) (disk
);
324 /* Reset the timer. */
325 grub_last_time
= grub_get_time_ms ();
327 grub_free (disk
->partition
);
328 grub_free ((void *) disk
->name
);
332 /* This function performs three tasks:
333 - Make sectors disk relative from partition relative.
334 - Normalize offset to be less than the sector size.
335 - Verify that the range is inside the partition. */
337 grub_disk_adjust_range (grub_disk_t disk
, grub_disk_addr_t
*sector
,
338 grub_off_t
*offset
, grub_size_t size
)
340 *sector
+= *offset
>> GRUB_DISK_SECTOR_BITS
;
341 *offset
&= GRUB_DISK_SECTOR_SIZE
- 1;
345 grub_disk_addr_t start
;
348 start
= grub_partition_get_start (disk
->partition
);
349 len
= grub_partition_get_len (disk
->partition
);
352 || len
- *sector
< ((*offset
+ size
+ GRUB_DISK_SECTOR_SIZE
- 1)
353 >> GRUB_DISK_SECTOR_BITS
))
354 return grub_error (GRUB_ERR_OUT_OF_RANGE
, "out of partition");
359 if (disk
->total_sectors
<= *sector
360 || ((*offset
+ size
+ GRUB_DISK_SECTOR_SIZE
- 1)
361 >> GRUB_DISK_SECTOR_BITS
) > disk
->total_sectors
- *sector
)
362 return grub_error (GRUB_ERR_OUT_OF_RANGE
, "out of disk");
364 return GRUB_ERR_NONE
;
367 /* Read data from the disk. */
369 grub_disk_read (grub_disk_t disk
, grub_disk_addr_t sector
,
370 grub_off_t offset
, grub_size_t size
, char *buf
)
373 unsigned real_offset
;
375 grub_dprintf ("disk", "Reading `%s'...\n", disk
->name
);
377 /* First of all, check if the region is within the disk. */
378 if (grub_disk_adjust_range (disk
, §or
, &offset
, size
) != GRUB_ERR_NONE
)
381 grub_dprintf ("disk", "Read out of range: sector 0x%llx (%s).\n",
382 (unsigned long long) sector
, grub_errmsg
);
387 real_offset
= offset
;
389 /* Allocate a temporary buffer. */
390 tmp_buf
= grub_malloc (GRUB_DISK_SECTOR_SIZE
<< GRUB_DISK_CACHE_BITS
);
394 /* Until SIZE is zero... */
398 grub_disk_addr_t start_sector
;
402 /* For reading bulk data. */
403 start_sector
= sector
& ~(GRUB_DISK_CACHE_SIZE
- 1);
404 pos
= (sector
- start_sector
) << GRUB_DISK_SECTOR_BITS
;
405 len
= ((GRUB_DISK_SECTOR_SIZE
<< GRUB_DISK_CACHE_BITS
)
406 - pos
- real_offset
);
410 /* Fetch the cache. */
411 data
= grub_disk_cache_fetch (disk
->dev
->id
, disk
->id
, start_sector
);
415 grub_memcpy (buf
, data
+ pos
+ real_offset
, len
);
416 grub_disk_cache_unlock (disk
->dev
->id
, disk
->id
, start_sector
);
420 /* Otherwise read data from the disk actually. */
421 if ((disk
->dev
->read
) (disk
, start_sector
,
422 GRUB_DISK_CACHE_SIZE
, tmp_buf
)
425 /* Uggh... Failed. Instead, just read necessary data. */
429 grub_errno
= GRUB_ERR_NONE
;
431 num
= ((size
+ GRUB_DISK_SECTOR_SIZE
- 1)
432 >> GRUB_DISK_SECTOR_BITS
);
434 p
= grub_realloc (tmp_buf
, num
<< GRUB_DISK_SECTOR_BITS
);
440 if ((disk
->dev
->read
) (disk
, sector
, num
, tmp_buf
))
443 grub_dprintf ("disk", "%s read failed\n", disk
->name
);
448 grub_memcpy (buf
, tmp_buf
+ real_offset
, size
);
450 /* Call the read hook, if any. */
454 (disk
->read_hook
) (sector
, real_offset
,
455 ((size
> GRUB_DISK_SECTOR_SIZE
)
456 ? GRUB_DISK_SECTOR_SIZE
459 size
-= GRUB_DISK_SECTOR_SIZE
- real_offset
;
463 /* This must be the end. */
467 /* Copy it and store it in the disk cache. */
468 grub_memcpy (buf
, tmp_buf
+ pos
+ real_offset
, len
);
469 grub_disk_cache_store (disk
->dev
->id
, disk
->id
,
470 start_sector
, tmp_buf
);
473 /* Call the read hook, if any. */
476 grub_disk_addr_t s
= sector
;
481 (disk
->read_hook
) (s
, real_offset
,
482 ((l
> GRUB_DISK_SECTOR_SIZE
)
483 ? GRUB_DISK_SECTOR_SIZE
486 if (l
< GRUB_DISK_SECTOR_SIZE
- real_offset
)
490 l
-= GRUB_DISK_SECTOR_SIZE
- real_offset
;
495 sector
= start_sector
+ GRUB_DISK_CACHE_SIZE
;
509 grub_disk_write (grub_disk_t disk
, grub_disk_addr_t sector
,
510 grub_off_t offset
, grub_size_t size
, const char *buf
)
512 unsigned real_offset
;
514 grub_dprintf ("disk", "Writing `%s'...\n", disk
->name
);
516 if (grub_disk_adjust_range (disk
, §or
, &offset
, size
) != GRUB_ERR_NONE
)
519 real_offset
= offset
;
523 if (real_offset
!= 0 || (size
< GRUB_DISK_SECTOR_SIZE
&& size
!= 0))
525 char tmp_buf
[GRUB_DISK_SECTOR_SIZE
];
528 if (grub_disk_read (disk
, sector
, 0, GRUB_DISK_SECTOR_SIZE
, tmp_buf
)
532 len
= GRUB_DISK_SECTOR_SIZE
- real_offset
;
536 grub_memcpy (tmp_buf
+ real_offset
, buf
, len
);
538 grub_disk_cache_invalidate (disk
->dev
->id
, disk
->id
, sector
);
540 if ((disk
->dev
->write
) (disk
, sector
, 1, tmp_buf
) != GRUB_ERR_NONE
)
553 len
= size
& ~(GRUB_DISK_SECTOR_SIZE
- 1);
554 n
= size
>> GRUB_DISK_SECTOR_BITS
;
556 if ((disk
->dev
->write
) (disk
, sector
, n
, buf
) != GRUB_ERR_NONE
)
560 grub_disk_cache_invalidate (disk
->dev
->id
, disk
->id
, sector
++);
573 grub_disk_get_size (grub_disk_t disk
)
576 return grub_partition_get_len (disk
->partition
);
578 return disk
->total_sectors
;