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
))
218 /* Return the location of the first ',', if any, which is not
221 find_part_sep (const char *name
)
223 const char *p
= name
;
226 while ((c
= *p
++) != '\0')
228 if (c
== '\\' && *p
== ',')
237 grub_disk_open (const char *name
)
242 char *raw
= (char *) name
;
243 grub_uint64_t current_time
;
245 grub_dprintf ("disk", "Opening `%s'...\n", name
);
247 disk
= (grub_disk_t
) grub_malloc (sizeof (*disk
));
255 disk
->name
= grub_strdup (name
);
259 p
= find_part_sep (name
);
262 grub_size_t len
= p
- name
;
264 raw
= grub_malloc (len
+ 1);
268 grub_memcpy (raw
, name
, len
);
272 for (dev
= grub_disk_dev_list
; dev
; dev
= dev
->next
)
274 if ((dev
->open
) (raw
, disk
) == GRUB_ERR_NONE
)
276 else if (grub_errno
== GRUB_ERR_UNKNOWN_DEVICE
)
277 grub_errno
= GRUB_ERR_NONE
;
284 grub_error (GRUB_ERR_UNKNOWN_DEVICE
, "no such disk");
288 if (p
&& ! disk
->has_partitions
)
290 grub_error (GRUB_ERR_BAD_DEVICE
, "no partition on this disk");
298 disk
->partition
= grub_partition_probe (disk
, p
+ 1);
299 if (! disk
->partition
)
301 grub_error (GRUB_ERR_UNKNOWN_DEVICE
, "no such partition");
306 /* The cache will be invalidated about 2 seconds after a device was
308 current_time
= grub_get_time_ms ();
310 if (current_time
> (grub_last_time
311 + GRUB_CACHE_TIMEOUT
* 1000))
312 grub_disk_cache_invalidate_all ();
314 grub_last_time
= current_time
;
318 if (raw
&& raw
!= name
)
321 if (grub_errno
!= GRUB_ERR_NONE
)
324 grub_dprintf ("disk", "Opening `%s' failed.\n", name
);
327 grub_disk_close (disk
);
335 grub_disk_close (grub_disk_t disk
)
337 grub_dprintf ("disk", "Closing `%s'.\n", disk
->name
);
339 if (disk
->dev
&& disk
->dev
->close
)
340 (disk
->dev
->close
) (disk
);
342 /* Reset the timer. */
343 grub_last_time
= grub_get_time_ms ();
345 grub_free (disk
->partition
);
346 grub_free ((void *) disk
->name
);
350 /* This function performs three tasks:
351 - Make sectors disk relative from partition relative.
352 - Normalize offset to be less than the sector size.
353 - Verify that the range is inside the partition. */
355 grub_disk_adjust_range (grub_disk_t disk
, grub_disk_addr_t
*sector
,
356 grub_off_t
*offset
, grub_size_t size
)
358 *sector
+= *offset
>> GRUB_DISK_SECTOR_BITS
;
359 *offset
&= GRUB_DISK_SECTOR_SIZE
- 1;
363 grub_disk_addr_t start
;
366 start
= grub_partition_get_start (disk
->partition
);
367 len
= grub_partition_get_len (disk
->partition
);
370 || len
- *sector
< ((*offset
+ size
+ GRUB_DISK_SECTOR_SIZE
- 1)
371 >> GRUB_DISK_SECTOR_BITS
))
372 return grub_error (GRUB_ERR_OUT_OF_RANGE
, "out of partition");
377 if (disk
->total_sectors
<= *sector
378 || ((*offset
+ size
+ GRUB_DISK_SECTOR_SIZE
- 1)
379 >> GRUB_DISK_SECTOR_BITS
) > disk
->total_sectors
- *sector
)
380 return grub_error (GRUB_ERR_OUT_OF_RANGE
, "out of disk");
382 return GRUB_ERR_NONE
;
385 /* Read data from the disk. */
387 grub_disk_read (grub_disk_t disk
, grub_disk_addr_t sector
,
388 grub_off_t offset
, grub_size_t size
, void *buf
)
391 unsigned real_offset
;
393 grub_dprintf ("disk", "Reading `%s'...\n", disk
->name
);
395 /* First of all, check if the region is within the disk. */
396 if (grub_disk_adjust_range (disk
, §or
, &offset
, size
) != GRUB_ERR_NONE
)
399 grub_dprintf ("disk", "Read out of range: sector 0x%llx (%s).\n",
400 (unsigned long long) sector
, grub_errmsg
);
405 real_offset
= offset
;
407 /* Allocate a temporary buffer. */
408 tmp_buf
= grub_malloc (GRUB_DISK_SECTOR_SIZE
<< GRUB_DISK_CACHE_BITS
);
412 /* Until SIZE is zero... */
416 grub_disk_addr_t start_sector
;
420 /* For reading bulk data. */
421 start_sector
= sector
& ~(GRUB_DISK_CACHE_SIZE
- 1);
422 pos
= (sector
- start_sector
) << GRUB_DISK_SECTOR_BITS
;
423 len
= ((GRUB_DISK_SECTOR_SIZE
<< GRUB_DISK_CACHE_BITS
)
424 - pos
- real_offset
);
428 /* Fetch the cache. */
429 data
= grub_disk_cache_fetch (disk
->dev
->id
, disk
->id
, start_sector
);
433 grub_memcpy (buf
, data
+ pos
+ real_offset
, len
);
434 grub_disk_cache_unlock (disk
->dev
->id
, disk
->id
, start_sector
);
438 /* Otherwise read data from the disk actually. */
439 if ((disk
->dev
->read
) (disk
, start_sector
,
440 GRUB_DISK_CACHE_SIZE
, tmp_buf
)
443 /* Uggh... Failed. Instead, just read necessary data. */
447 grub_errno
= GRUB_ERR_NONE
;
449 num
= ((size
+ GRUB_DISK_SECTOR_SIZE
- 1)
450 >> GRUB_DISK_SECTOR_BITS
);
452 p
= grub_realloc (tmp_buf
, num
<< GRUB_DISK_SECTOR_BITS
);
458 if ((disk
->dev
->read
) (disk
, sector
, num
, tmp_buf
))
461 grub_dprintf ("disk", "%s read failed\n", disk
->name
);
466 grub_memcpy (buf
, tmp_buf
+ real_offset
, size
);
468 /* Call the read hook, if any. */
472 (disk
->read_hook
) (sector
, real_offset
,
473 ((size
> GRUB_DISK_SECTOR_SIZE
)
474 ? GRUB_DISK_SECTOR_SIZE
477 size
-= GRUB_DISK_SECTOR_SIZE
- real_offset
;
481 /* This must be the end. */
485 /* Copy it and store it in the disk cache. */
486 grub_memcpy (buf
, tmp_buf
+ pos
+ real_offset
, len
);
487 grub_disk_cache_store (disk
->dev
->id
, disk
->id
,
488 start_sector
, tmp_buf
);
491 /* Call the read hook, if any. */
494 grub_disk_addr_t s
= sector
;
499 (disk
->read_hook
) (s
, real_offset
,
500 ((l
> GRUB_DISK_SECTOR_SIZE
)
501 ? GRUB_DISK_SECTOR_SIZE
504 if (l
< GRUB_DISK_SECTOR_SIZE
- real_offset
)
508 l
-= GRUB_DISK_SECTOR_SIZE
- real_offset
;
513 sector
= start_sector
+ GRUB_DISK_CACHE_SIZE
;
514 buf
= (char *) buf
+ len
;
527 grub_disk_write (grub_disk_t disk
, grub_disk_addr_t sector
,
528 grub_off_t offset
, grub_size_t size
, const void *buf
)
530 unsigned real_offset
;
532 grub_dprintf ("disk", "Writing `%s'...\n", disk
->name
);
534 if (grub_disk_adjust_range (disk
, §or
, &offset
, size
) != GRUB_ERR_NONE
)
537 real_offset
= offset
;
541 if (real_offset
!= 0 || (size
< GRUB_DISK_SECTOR_SIZE
&& size
!= 0))
543 char tmp_buf
[GRUB_DISK_SECTOR_SIZE
];
546 if (grub_disk_read (disk
, sector
, 0, GRUB_DISK_SECTOR_SIZE
, tmp_buf
)
550 len
= GRUB_DISK_SECTOR_SIZE
- real_offset
;
554 grub_memcpy (tmp_buf
+ real_offset
, buf
, len
);
556 grub_disk_cache_invalidate (disk
->dev
->id
, disk
->id
, sector
);
558 if ((disk
->dev
->write
) (disk
, sector
, 1, tmp_buf
) != GRUB_ERR_NONE
)
562 buf
= (char *) buf
+ len
;
571 len
= size
& ~(GRUB_DISK_SECTOR_SIZE
- 1);
572 n
= size
>> GRUB_DISK_SECTOR_BITS
;
574 if ((disk
->dev
->write
) (disk
, sector
, n
, buf
) != GRUB_ERR_NONE
)
578 grub_disk_cache_invalidate (disk
->dev
->id
, disk
->id
, sector
++);
580 buf
= (char *) buf
+ len
;
591 grub_disk_get_size (grub_disk_t disk
)
594 return grub_partition_get_len (disk
->partition
);
596 return disk
->total_sectors
;