util/misc.c

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 2002,2003,2005,2006,2007,2008  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 #include <config.h>
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <stdarg.h>
  24 #include <string.h>
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <sys/time.h>
  28 #include <unistd.h>
  29
  30 #include <grub/kernel.h>
  31 #include <grub/misc.h>
  32 #include <grub/cache.h>
  33 #include <grub/util/misc.h>
  34 #include <grub/mm.h>
  35 #include <grub/term.h>
  36 #include <grub/time.h>
  37 #include <grub/machine/time.h>
  38
  39 /* Include malloc.h, only if memalign is available. It is known that
  40    memalign is declared in malloc.h in all systems, if present.  */
  41 #ifdef HAVE_MEMALIGN
  42 # include <malloc.h>
  43 #endif
  44
  45 char *progname = 0;
  46 int verbosity = 0;
  47
  48 void
  49 grub_util_info (const char *fmt, ...)
  50 {
  51   if (verbosity > 0)
  52     {
  53       va_list ap;
  54
  55       fprintf (stderr, "%s: info: ", progname);
  56       va_start (ap, fmt);
  57       vfprintf (stderr, fmt, ap);
  58       va_end (ap);
  59       fputc ('\n', stderr);
  60       fflush (stderr);
  61     }
  62 }
  63
  64 void
  65 grub_util_error (const char *fmt, ...)
  66 {
  67   va_list ap;
  68
  69   fprintf (stderr, "%s: error: ", progname);
  70   va_start (ap, fmt);
  71   vfprintf (stderr, fmt, ap);
  72   va_end (ap);
  73   fputc ('\n', stderr);
  74   exit (1);
  75 }
  76
  77 int
  78 grub_err_printf (const char *fmt, ...)
  79 {
  80   va_list ap;
  81   int ret;
  82
  83   va_start (ap, fmt);
  84   ret = vfprintf (stderr, fmt, ap);
  85   va_end (ap);
  86
  87   return ret;
  88 }
  89
  90 void *
  91 xmalloc (size_t size)
  92 {
  93   void *p;
  94
  95   p = malloc (size);
  96   if (! p)
  97     grub_util_error ("out of memory");
  98
  99   return p;
 100 }
 101
 102 void *
 103 xrealloc (void *ptr, size_t size)
 104 {
 105   ptr = realloc (ptr, size);
 106   if (! ptr)
 107     grub_util_error ("out of memory");
 108
 109   return ptr;
 110 }
 111
 112 char *
 113 xstrdup (const char *str)
 114 {
 115   size_t len;
 116   char *dup;
 117
 118   len = strlen (str);
 119   dup = (char *) xmalloc (len + 1);
 120   memcpy (dup, str, len + 1);
 121
 122   return dup;
 123 }
 124
 125 char *
 126 grub_util_get_path (const char *dir, const char *file)
 127 {
 128   char *path;
 129
 130   path = (char *) xmalloc (strlen (dir) + 1 + strlen (file) + 1);
 131   sprintf (path, "%s/%s", dir, file);
 132   return path;
 133 }
 134
 135 size_t
 136 grub_util_get_fp_size (FILE *fp)
 137 {
 138   struct stat st;
 139
 140   if (fflush (fp) == EOF)
 141     grub_util_error ("fflush failed");
 142
 143   if (fstat (fileno (fp), &st) == -1)
 144     grub_util_error ("fstat failed");
 145
 146   return st.st_size;
 147 }
 148
 149 size_t
 150 grub_util_get_image_size (const char *path)
 151 {
 152   struct stat st;
 153
 154   grub_util_info ("getting the size of %s", path);
 155
 156   if (stat (path, &st) == -1)
 157     grub_util_error ("cannot stat %s", path);
 158
 159   return st.st_size;
 160 }
 161
 162 void
 163 grub_util_read_at (void *img, size_t size, off_t offset, FILE *fp)
 164 {
 165   if (fseeko (fp, offset, SEEK_SET) == -1)
 166     grub_util_error ("seek failed");
 167
 168   if (fread (img, 1, size, fp) != size)
 169     grub_util_error ("read failed");
 170 }
 171
 172 char *
 173 grub_util_read_image (const char *path)
 174 {
 175   char *img;
 176   FILE *fp;
 177   size_t size;
 178
 179   grub_util_info ("reading %s", path);
 180
 181   size = grub_util_get_image_size (path);
 182   img = (char *) xmalloc (size);
 183
 184   fp = fopen (path, "rb");
 185   if (! fp)
 186     grub_util_error ("cannot open %s", path);
 187
 188   grub_util_read_at (img, size, 0, fp);
 189
 190   fclose (fp);
 191
 192   return img;
 193 }
 194
 195 void
 196 grub_util_load_image (const char *path, char *buf)
 197 {
 198   FILE *fp;
 199   size_t size;
 200
 201   grub_util_info ("reading %s", path);
 202
 203   size = grub_util_get_image_size (path);
 204
 205   fp = fopen (path, "rb");
 206   if (! fp)
 207     grub_util_error ("cannot open %s", path);
 208
 209   if (fread (buf, 1, size, fp) != size)
 210     grub_util_error ("cannot read %s", path);
 211
 212   fclose (fp);
 213 }
 214
 215 void
 216 grub_util_write_image_at (const void *img, size_t size, off_t offset, FILE *out)
 217 {
 218   grub_util_info ("writing 0x%x bytes at offset 0x%x", size, offset);
 219   if (fseeko (out, offset, SEEK_SET) == -1)
 220     grub_util_error ("seek failed");
 221   if (fwrite (img, 1, size, out) != size)
 222     grub_util_error ("write failed");
 223 }
 224
 225 void
 226 grub_util_write_image (const char *img, size_t size, FILE *out)
 227 {
 228   grub_util_info ("writing 0x%x bytes", size);
 229   if (fwrite (img, 1, size, out) != size)
 230     grub_util_error ("write failed");
 231 }
 232
 233 void *
 234 grub_malloc (grub_size_t size)
 235 {
 236   return xmalloc (size);
 237 }
 238
 239 void
 240 grub_free (void *ptr)
 241 {
 242   free (ptr);
 243 }
 244
 245 void *
 246 grub_realloc (void *ptr, grub_size_t size)
 247 {
 248   return xrealloc (ptr, size);
 249 }
 250
 251 void *
 252 grub_memalign (grub_size_t align, grub_size_t size)
 253 {
 254   void *p;
 255
 256 #if defined(HAVE_POSIX_MEMALIGN)
 257   if (posix_memalign (&p, align, size) != 0)
 258     p = 0;
 259 #elif defined(HAVE_MEMALIGN)
 260   p = memalign (align, size);
 261 #else
 262   (void) align;
 263   (void) size;
 264   grub_util_error ("grub_memalign is not supported");
 265 #endif
 266
 267   if (! p)
 268     grub_util_error ("out of memory");
 269
 270   return p;
 271 }
 272
 273 /* Some functions that we don't use.  */
 274 void
 275 grub_mm_init_region (void *addr __attribute__ ((unused)),
 276                      grub_size_t size __attribute__ ((unused)))
 277 {
 278 }
 279
 280 void
 281 grub_register_exported_symbols (void)
 282 {
 283 }
 284
 285 void
 286 grub_exit (void)
 287 {
 288   exit (1);
 289 }
 290
 291 grub_uint32_t
 292 grub_get_rtc (void)
 293 {
 294   struct timeval tv;
 295
 296   gettimeofday (&tv, 0);
 297
 298   return (tv.tv_sec * GRUB_TICKS_PER_SECOND
 299           + (((tv.tv_sec % GRUB_TICKS_PER_SECOND) * 1000000 + tv.tv_usec)
 300              * GRUB_TICKS_PER_SECOND / 1000000));
 301 }
 302
 303 grub_uint64_t
 304 grub_get_time_ms (void)
 305 {
 306   struct timeval tv;
 307
 308   gettimeofday (&tv, 0);
 309
 310   return (tv.tv_sec * 1000 + tv.tv_usec / 1000);
 311 }
 312
 313 void
 314 grub_arch_sync_caches (void *address __attribute__ ((unused)),
 315                        grub_size_t len __attribute__ ((unused)))
 316 {
 317 }
 318
 319 #ifndef  HAVE_ASPRINTF
 320
 321 int
 322 asprintf (char **buf, const char *fmt, ...)
 323 {
 324   int status;
 325   va_list ap;
 326
 327   /* Should be large enough.  */
 328   *buf = xmalloc (512);
 329
 330   va_start (ap, fmt);
 331   status = vsprintf (*buf, fmt, ap);
 332   va_end (ap);
 333
 334   return status;
 335 }
 336
 337 #endif
 338
 339 #ifdef __MINGW32__
 340
 341 #include <windows.h>
 342 #include <winioctl.h>
 343
 344 void sync (void)
 345 {
 346 }
 347
 348 void sleep (int s)
 349 {
 350   Sleep (s * 1000);
 351 }
 352
 353 grub_int64_t
 354 grub_util_get_disk_size (char *name)
 355 {
 356   HANDLE hd;
 357   grub_int64_t size = -1LL;
 358
 359   hd = CreateFile (name, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
 360                    0, OPEN_EXISTING, 0, 0);
 361
 362   if (hd == INVALID_HANDLE_VALUE)
 363     return size;
 364
 365   if (((name[0] == '/') || (name[0] == '\\')) &&
 366       ((name[1] == '/') || (name[1] == '\\')) &&
 367       (name[2] == '.') &&
 368       ((name[3] == '/') || (name[3] == '\\')) &&
 369       (! strncasecmp (name + 4, "PHYSICALDRIVE", 13)))
 370     {
 371       DWORD nr;
 372       DISK_GEOMETRY g;
 373
 374       if (! DeviceIoControl (hd, IOCTL_DISK_GET_DRIVE_GEOMETRY,
 375                              0, 0, &g, sizeof (g), &nr, 0))
 376         goto fail;
 377
 378       size = g.Cylinders.QuadPart;
 379       size *= g.TracksPerCylinder * g.SectorsPerTrack * g.BytesPerSector;
 380     }
 381   else
 382     {
 383       LARGE_INTEGER s;
 384
 385       s.LowPart = GetFileSize (hd, &s.HighPart);
 386       size = s.QuadPart;
 387     }
 388
 389 fail:
 390
 391   CloseHandle (hd);
 392
 393   return size;
 394 }
 395
 396 #endif