arch/all-pc/boot/grub2-aros/grub-core/io/bufio.c

   1 /* bufio.c - buffered io access */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2008  Free Software Foundation, Inc.
   5  *
   6  *  GRUB is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  GRUB is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <grub/err.h>
  21 #include <grub/types.h>
  22 #include <grub/mm.h>
  23 #include <grub/misc.h>
  24 #include <grub/fs.h>
  25 #include <grub/bufio.h>
  26 #include <grub/dl.h>
  27
  28 GRUB_MOD_LICENSE ("GPLv3+");
  29
  30 #define GRUB_BUFIO_DEF_SIZE     8192
  31 #define GRUB_BUFIO_MAX_SIZE     1048576
  32
  33 struct grub_bufio
  34 {
  35   grub_file_t file;
  36   grub_size_t block_size;
  37   grub_size_t buffer_len;
  38   grub_off_t buffer_at;
  39   char buffer[0];
  40 };
  41 typedef struct grub_bufio *grub_bufio_t;
  42
  43 static struct grub_fs grub_bufio_fs;
  44
  45 grub_file_t
  46 grub_bufio_open (grub_file_t io, int size)
  47 {
  48   grub_file_t file;
  49   grub_bufio_t bufio = 0;
  50
  51   file = (grub_file_t) grub_zalloc (sizeof (*file));
  52   if (! file)
  53     return 0;
  54
  55   if (size == 0)
  56     size = GRUB_BUFIO_DEF_SIZE;
  57   else if (size > GRUB_BUFIO_MAX_SIZE)
  58     size = GRUB_BUFIO_MAX_SIZE;
  59
  60   if ((size < 0) || ((unsigned) size > io->size))
  61     size = ((io->size > GRUB_BUFIO_MAX_SIZE) ? GRUB_BUFIO_MAX_SIZE :
  62             io->size);
  63
  64   bufio = grub_zalloc (sizeof (struct grub_bufio) + size);
  65   if (! bufio)
  66     {
  67       grub_free (file);
  68       return 0;
  69     }
  70
  71   bufio->file = io;
  72   bufio->block_size = size;
  73
  74   file->device = io->device;
  75   file->size = io->size;
  76   file->data = bufio;
  77   file->fs = &grub_bufio_fs;
  78   file->not_easily_seekable = io->not_easily_seekable;
  79
  80   return file;
  81 }
  82
  83 grub_file_t
  84 grub_buffile_open (const char *name, int size)
  85 {
  86   grub_file_t io, file;
  87
  88   io = grub_file_open (name);
  89   if (! io)
  90     return 0;
  91
  92   file = grub_bufio_open (io, size);
  93   if (! file)
  94     {
  95       grub_file_close (io);
  96       return 0;
  97     }
  98
  99   return file;
 100 }
 101
 102 static grub_ssize_t
 103 grub_bufio_read (grub_file_t file, char *buf, grub_size_t len)
 104 {
 105   grub_size_t res = 0;
 106   grub_off_t next_buf;
 107   grub_bufio_t bufio = file->data;
 108   grub_ssize_t really_read;
 109
 110   if (file->size == GRUB_FILE_SIZE_UNKNOWN)
 111     file->size = bufio->file->size;
 112
 113   /* First part: use whatever we already have in the buffer.  */
 114   if ((file->offset >= bufio->buffer_at) &&
 115       (file->offset < bufio->buffer_at + bufio->buffer_len))
 116     {
 117       grub_size_t n;
 118       grub_uint64_t pos;
 119
 120       pos = file->offset - bufio->buffer_at;
 121       n = bufio->buffer_len - pos;
 122       if (n > len)
 123         n = len;
 124
 125       grub_memcpy (buf, &bufio->buffer[pos], n);
 126       len -= n;
 127       res += n;
 128
 129       buf += n;
 130     }
 131   if (len == 0)
 132     return res;
 133
 134   /* Need to read some more.  */
 135   next_buf = (file->offset + res + len - 1) & ~((grub_off_t) bufio->block_size - 1);
 136   /* Now read between file->offset + res and bufio->buffer_at.  */
 137   if (file->offset + res < next_buf)
 138     {
 139       grub_size_t read_now;
 140       read_now = next_buf - (file->offset + res);
 141       grub_file_seek (bufio->file, file->offset + res);
 142       really_read = grub_file_read (bufio->file, buf, read_now);
 143       if (really_read < 0)
 144         return -1;
 145       if (file->size == GRUB_FILE_SIZE_UNKNOWN)
 146         file->size = bufio->file->size;
 147       len -= really_read;
 148       buf += really_read;
 149       res += really_read;
 150
 151       /* Partial read. File ended unexpectedly. Save the last chunk in buffer.
 152        */
 153       if (really_read != (grub_ssize_t) read_now)
 154         {
 155           bufio->buffer_len = really_read;
 156           if (bufio->buffer_len > bufio->block_size)
 157             bufio->buffer_len = bufio->block_size;
 158           bufio->buffer_at = file->offset + res - bufio->buffer_len;
 159           grub_memcpy (&bufio->buffer[0], buf - bufio->buffer_len,
 160                        bufio->buffer_len);
 161           return res;
 162         }
 163     }
 164
 165   /* Read into buffer.  */
 166   grub_file_seek (bufio->file, next_buf);
 167   really_read = grub_file_read (bufio->file, bufio->buffer,
 168                                 bufio->block_size);
 169   if (really_read < 0)
 170     return -1;
 171   bufio->buffer_at = next_buf;
 172   bufio->buffer_len = really_read;
 173
 174   if (file->size == GRUB_FILE_SIZE_UNKNOWN)
 175     file->size = bufio->file->size;
 176
 177   if (len > bufio->buffer_len)
 178     len = bufio->buffer_len;
 179   grub_memcpy (buf, &bufio->buffer[file->offset + res - next_buf], len);
 180   res += len;
 181
 182   return res;
 183 }
 184
 185 static grub_err_t
 186 grub_bufio_close (grub_file_t file)
 187 {
 188   grub_bufio_t bufio = file->data;
 189
 190   grub_file_close (bufio->file);
 191   grub_free (bufio);
 192
 193   file->device = 0;
 194
 195   return grub_errno;
 196 }
 197
 198 static struct grub_fs grub_bufio_fs =
 199   {
 200     .name = "bufio",
 201     .dir = 0,
 202     .open = 0,
 203     .read = grub_bufio_read,
 204     .close = grub_bufio_close,
 205     .label = 0,
 206     .next = 0
 207   };