arch/all-pc/boot/grub2-aros/include/grub/disk.h

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 2002,2003,2004,2005,2006,2007,2008,2009  Free Software Foundation, Inc.
   4  *
   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.
   9  *
  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.
  14  *
  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/>.
  17  */
  18
  19 #ifndef GRUB_DISK_HEADER
  20 #define GRUB_DISK_HEADER        1
  21
  22 #include <config.h>
  23
  24 #include <grub/symbol.h>
  25 #include <grub/err.h>
  26 #include <grub/types.h>
  27 #include <grub/device.h>
  28 /* For NULL.  */
  29 #include <grub/mm.h>
  30
  31 /* These are used to set a device id. When you add a new disk device,
  32    you must define a new id for it here.  */
  33 enum grub_disk_dev_id
  34   {
  35     GRUB_DISK_DEVICE_BIOSDISK_ID,
  36     GRUB_DISK_DEVICE_OFDISK_ID,
  37     GRUB_DISK_DEVICE_LOOPBACK_ID,
  38     GRUB_DISK_DEVICE_EFIDISK_ID,
  39     GRUB_DISK_DEVICE_DISKFILTER_ID,
  40     GRUB_DISK_DEVICE_HOST_ID,
  41     GRUB_DISK_DEVICE_ATA_ID,
  42     GRUB_DISK_DEVICE_MEMDISK_ID,
  43     GRUB_DISK_DEVICE_NAND_ID,
  44     GRUB_DISK_DEVICE_SCSI_ID,
  45     GRUB_DISK_DEVICE_CRYPTODISK_ID,
  46     GRUB_DISK_DEVICE_ARCDISK_ID,
  47     GRUB_DISK_DEVICE_HOSTDISK_ID,
  48     GRUB_DISK_DEVICE_PROCFS_ID,
  49     GRUB_DISK_DEVICE_CBFSDISK_ID,
  50     GRUB_DISK_DEVICE_UBOOTDISK_ID,
  51     GRUB_DISK_DEVICE_XEN,
  52   };
  53
  54 struct grub_disk;
  55 #ifdef GRUB_UTIL
  56 struct grub_disk_memberlist;
  57 #endif
  58
  59 typedef enum
  60   {
  61     GRUB_DISK_PULL_NONE,
  62     GRUB_DISK_PULL_REMOVABLE,
  63     GRUB_DISK_PULL_RESCAN,
  64     GRUB_DISK_PULL_MAX
  65   } grub_disk_pull_t;
  66
  67 typedef int (*grub_disk_dev_iterate_hook_t) (const char *name, void *data);
  68
  69 /* Disk device.  */
  70 struct grub_disk_dev
  71 {
  72   /* The device name.  */
  73   const char *name;
  74
  75   /* The device id used by the cache manager.  */
  76   enum grub_disk_dev_id id;
  77
  78   /* Call HOOK with each device name, until HOOK returns non-zero.  */
  79   int (*iterate) (grub_disk_dev_iterate_hook_t hook, void *hook_data,
  80                   grub_disk_pull_t pull);
  81
  82   /* Open the device named NAME, and set up DISK.  */
  83   grub_err_t (*open) (const char *name, struct grub_disk *disk);
  84
  85   /* Close the disk DISK.  */
  86   void (*close) (struct grub_disk *disk);
  87
  88   /* Read SIZE sectors from the sector SECTOR of the disk DISK into BUF.  */
  89   grub_err_t (*read) (struct grub_disk *disk, grub_disk_addr_t sector,
  90                       grub_size_t size, char *buf);
  91
  92   /* Write SIZE sectors from BUF into the sector SECTOR of the disk DISK.  */
  93   grub_err_t (*write) (struct grub_disk *disk, grub_disk_addr_t sector,
  94                        grub_size_t size, const char *buf);
  95
  96 #ifdef GRUB_UTIL
  97   struct grub_disk_memberlist *(*memberlist) (struct grub_disk *disk);
  98   const char * (*raidname) (struct grub_disk *disk);
  99 #endif
 100
 101   /* The next disk device.  */
 102   struct grub_disk_dev *next;
 103 };
 104 typedef struct grub_disk_dev *grub_disk_dev_t;
 105
 106 extern grub_disk_dev_t EXPORT_VAR (grub_disk_dev_list);
 107
 108 struct grub_partition;
 109
 110 typedef void (*grub_disk_read_hook_t) (grub_disk_addr_t sector,
 111                                        unsigned offset, unsigned length,
 112                                        void *data);
 113
 114 /* Disk.  */
 115 struct grub_disk
 116 {
 117   /* The disk name.  */
 118   const char *name;
 119
 120   /* The underlying disk device.  */
 121   grub_disk_dev_t dev;
 122
 123   /* The total number of sectors.  */
 124   grub_uint64_t total_sectors;
 125
 126   /* Logarithm of sector size.  */
 127   unsigned int log_sector_size;
 128
 129   /* Maximum number of sectors read divided by GRUB_DISK_CACHE_SIZE.  */
 130   unsigned int max_agglomerate;
 131
 132   /* The id used by the disk cache manager.  */
 133   unsigned long id;
 134
 135   /* The partition information. This is machine-specific.  */
 136   struct grub_partition *partition;
 137
 138   /* Called when a sector was read. OFFSET is between 0 and
 139      the sector size minus 1, and LENGTH is between 0 and the sector size.  */
 140   grub_disk_read_hook_t read_hook;
 141
 142   /* Caller-specific data passed to the read hook.  */
 143   void *read_hook_data;
 144
 145   /* Device-specific data.  */
 146   void *data;
 147 };
 148 typedef struct grub_disk *grub_disk_t;
 149
 150 #ifdef GRUB_UTIL
 151 struct grub_disk_memberlist
 152 {
 153   grub_disk_t disk;
 154   struct grub_disk_memberlist *next;
 155 };
 156 typedef struct grub_disk_memberlist *grub_disk_memberlist_t;
 157 #endif
 158
 159 /* The sector size.  */
 160 #define GRUB_DISK_SECTOR_SIZE   0x200
 161 #define GRUB_DISK_SECTOR_BITS   9
 162
 163 /* The maximum number of disk caches.  */
 164 #define GRUB_DISK_CACHE_NUM     1021
 165
 166 /* The size of a disk cache in 512B units. Must be at least as big as the
 167    largest supported sector size, currently 16K.  */
 168 #define GRUB_DISK_CACHE_BITS    6
 169 #define GRUB_DISK_CACHE_SIZE    (1 << GRUB_DISK_CACHE_BITS)
 170
 171 #define GRUB_DISK_MAX_MAX_AGGLOMERATE ((1 << (30 - GRUB_DISK_CACHE_BITS - GRUB_DISK_SECTOR_BITS)) - 1)
 172
 173 /* Return value of grub_disk_get_size() in case disk size is unknown. */
 174 #define GRUB_DISK_SIZE_UNKNOWN   0xffffffffffffffffULL
 175
 176 /* This is called from the memory manager.  */
 177 void grub_disk_cache_invalidate_all (void);
 178
 179 void EXPORT_FUNC(grub_disk_dev_register) (grub_disk_dev_t dev);
 180 void EXPORT_FUNC(grub_disk_dev_unregister) (grub_disk_dev_t dev);
 181 static inline int
 182 grub_disk_dev_iterate (grub_disk_dev_iterate_hook_t hook, void *hook_data)
 183 {
 184   grub_disk_dev_t p;
 185   grub_disk_pull_t pull;
 186
 187   for (pull = 0; pull < GRUB_DISK_PULL_MAX; pull++)
 188     for (p = grub_disk_dev_list; p; p = p->next)
 189       if (p->iterate && (p->iterate) (hook, hook_data, pull))
 190         return 1;
 191
 192   return 0;
 193 }
 194
 195 grub_disk_t EXPORT_FUNC(grub_disk_open) (const char *name);
 196 void EXPORT_FUNC(grub_disk_close) (grub_disk_t disk);
 197 grub_err_t EXPORT_FUNC(grub_disk_read) (grub_disk_t disk,
 198                                         grub_disk_addr_t sector,
 199                                         grub_off_t offset,
 200                                         grub_size_t size,
 201                                         void *buf);
 202 grub_err_t grub_disk_write (grub_disk_t disk,
 203                             grub_disk_addr_t sector,
 204                             grub_off_t offset,
 205                             grub_size_t size,
 206                             const void *buf);
 207 extern grub_err_t (*EXPORT_VAR(grub_disk_write_weak)) (grub_disk_t disk,
 208                                                        grub_disk_addr_t sector,
 209                                                        grub_off_t offset,
 210                                                        grub_size_t size,
 211                                                        const void *buf);
 212
 213
 214 grub_uint64_t EXPORT_FUNC(grub_disk_get_size) (grub_disk_t disk);
 215
 216 #if DISK_CACHE_STATS
 217 void
 218 EXPORT_FUNC(grub_disk_cache_get_performance) (unsigned long *hits, unsigned long *misses);
 219 #endif
 220
 221 extern void (* EXPORT_VAR(grub_disk_firmware_fini)) (void);
 222 extern int EXPORT_VAR(grub_disk_firmware_is_tainted);
 223
 224 static inline void
 225 grub_stop_disk_firmware (void)
 226 {
 227   /* To prevent two drivers operating on the same disks.  */
 228   grub_disk_firmware_is_tainted = 1;
 229   if (grub_disk_firmware_fini)
 230     {
 231       grub_disk_firmware_fini ();
 232       grub_disk_firmware_fini = NULL;
 233     }
 234 }
 235
 236 /* Disk cache.  */
 237 struct grub_disk_cache
 238 {
 239   enum grub_disk_dev_id dev_id;
 240   unsigned long disk_id;
 241   grub_disk_addr_t sector;
 242   char *data;
 243   int lock;
 244 };
 245
 246 extern struct grub_disk_cache EXPORT_VAR(grub_disk_cache_table)[GRUB_DISK_CACHE_NUM];
 247
 248 #if defined (GRUB_UTIL)
 249 void grub_lvm_init (void);
 250 void grub_ldm_init (void);
 251 void grub_mdraid09_init (void);
 252 void grub_mdraid1x_init (void);
 253 void grub_diskfilter_init (void);
 254 void grub_lvm_fini (void);
 255 void grub_ldm_fini (void);
 256 void grub_mdraid09_fini (void);
 257 void grub_mdraid1x_fini (void);
 258 void grub_diskfilter_fini (void);
 259 #endif
 260
 261 #endif /* ! GRUB_DISK_HEADER */