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