util/misc.c

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