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_zalloc (grub_size_t size)
 262 {
 263   void *ret;
 264
 265   ret = xmalloc (size);
 266   memset (ret, 0, size);
 267   return ret;
 268 }
 269
 270 void
 271 grub_free (void *ptr)
 272 {
 273   free (ptr);
 274 }
 275
 276 void *
 277 grub_realloc (void *ptr, grub_size_t size)
 278 {
 279   return xrealloc (ptr, size);
 280 }
 281
 282 void *
 283 grub_memalign (grub_size_t align, grub_size_t size)
 284 {
 285   void *p;
 286
 287 #if defined(HAVE_POSIX_MEMALIGN)
 288   if (posix_memalign (&p, align, size) != 0)
 289     p = 0;
 290 #elif defined(HAVE_MEMALIGN)
 291   p = memalign (align, size);
 292 #else
 293   (void) align;
 294   (void) size;
 295   grub_util_error ("grub_memalign is not supported");
 296 #endif
 297
 298   if (! p)
 299     grub_util_error ("out of memory");
 300
 301   return p;
 302 }
 303
 304 /* Some functions that we don't use.  */
 305 void
 306 grub_mm_init_region (void *addr __attribute__ ((unused)),
 307                      grub_size_t size __attribute__ ((unused)))
 308 {
 309 }
 310
 311 void
 312 grub_register_exported_symbols (void)
 313 {
 314 }
 315
 316 void
 317 grub_exit (void)
 318 {
 319   exit (1);
 320 }
 321
 322 grub_uint32_t
 323 grub_get_rtc (void)
 324 {
 325   struct timeval tv;
 326
 327   gettimeofday (&tv, 0);
 328
 329   return (tv.tv_sec * GRUB_TICKS_PER_SECOND
 330           + (((tv.tv_sec % GRUB_TICKS_PER_SECOND) * 1000000 + tv.tv_usec)
 331              * GRUB_TICKS_PER_SECOND / 1000000));
 332 }
 333
 334 grub_uint64_t
 335 grub_get_time_ms (void)
 336 {
 337   struct timeval tv;
 338
 339   gettimeofday (&tv, 0);
 340
 341   return (tv.tv_sec * 1000 + tv.tv_usec / 1000);
 342 }
 343
 344 #ifdef __MINGW32__
 345
 346 void
 347 grub_millisleep (grub_uint32_t ms)
 348 {
 349   Sleep (ms);
 350 }
 351
 352 #else
 353
 354 void
 355 grub_millisleep (grub_uint32_t ms)
 356 {
 357   struct timespec ts;
 358
 359   ts.tv_sec = ms / 1000;
 360   ts.tv_nsec = (ms % 1000) * 1000000;
 361   nanosleep (&ts, NULL);
 362 }
 363
 364 #endif
 365
 366 void
 367 grub_arch_sync_caches (void *address __attribute__ ((unused)),
 368                        grub_size_t len __attribute__ ((unused)))
 369 {
 370 }
 371
 372 #ifndef  HAVE_ASPRINTF
 373
 374 int
 375 asprintf (char **buf, const char *fmt, ...)
 376 {
 377   int status;
 378   va_list ap;
 379
 380   /* Should be large enough.  */
 381   *buf = xmalloc (512);
 382
 383   va_start (ap, fmt);
 384   status = vsprintf (*buf, fmt, ap);
 385   va_end (ap);
 386
 387   return status;
 388 }
 389
 390 #endif
 391
 392 #ifdef __MINGW32__
 393
 394 void sync (void)
 395 {
 396 }
 397
 398 int fsync (int fno __attribute__ ((unused)))
 399 {
 400   return 0;
 401 }
 402
 403 void sleep (int s)
 404 {
 405   Sleep (s * 1000);
 406 }
 407
 408 grub_int64_t
 409 grub_util_get_disk_size (char *name)
 410 {
 411   HANDLE hd;
 412   grub_int64_t size = -1LL;
 413
 414   hd = CreateFile (name, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
 415                    0, OPEN_EXISTING, 0, 0);
 416
 417   if (hd == INVALID_HANDLE_VALUE)
 418     return size;
 419
 420   if (((name[0] == '/') || (name[0] == '\\')) &&
 421       ((name[1] == '/') || (name[1] == '\\')) &&
 422       (name[2] == '.') &&
 423       ((name[3] == '/') || (name[3] == '\\')) &&
 424       (! strncasecmp (name + 4, "PHYSICALDRIVE", 13)))
 425     {
 426       DWORD nr;
 427       DISK_GEOMETRY g;
 428
 429       if (! DeviceIoControl (hd, IOCTL_DISK_GET_DRIVE_GEOMETRY,
 430                              0, 0, &g, sizeof (g), &nr, 0))
 431         goto fail;
 432
 433       size = g.Cylinders.QuadPart;
 434       size *= g.TracksPerCylinder * g.SectorsPerTrack * g.BytesPerSector;
 435     }
 436   else
 437     {
 438       LARGE_INTEGER s;
 439
 440       s.LowPart = GetFileSize (hd, &s.HighPart);
 441       size = s.QuadPart;
 442     }
 443
 444 fail:
 445
 446   CloseHandle (hd);
 447
 448   return size;
 449 }
 450
 451 #endif /* __MINGW32__ */