reftable/blocksource.c

   1 /*
   2 Copyright 2020 Google LLC
   3
   4 Use of this source code is governed by a BSD-style
   5 license that can be found in the LICENSE file or at
   6 https://developers.google.com/open-source/licenses/bsd
   7 */
   8
   9 #include "system.h"
  10
  11 #include "basics.h"
  12 #include "blocksource.h"
  13 #include "reftable-blocksource.h"
  14 #include "reftable-error.h"
  15
  16 static void strbuf_return_block(void *b, struct reftable_block *dest)
  17 {
  18         if (dest->len)
  19                 memset(dest->data, 0xff, dest->len);
  20         reftable_free(dest->data);
  21 }
  22
  23 static void strbuf_close(void *b)
  24 {
  25 }
  26
  27 static int strbuf_read_block(void *v, struct reftable_block *dest, uint64_t off,
  28                              uint32_t size)
  29 {
  30         struct strbuf *b = v;
  31         assert(off + size <= b->len);
  32         dest->data = reftable_calloc(size);
  33         memcpy(dest->data, b->buf + off, size);
  34         dest->len = size;
  35         return size;
  36 }
  37
  38 static uint64_t strbuf_size(void *b)
  39 {
  40         return ((struct strbuf *)b)->len;
  41 }
  42
  43 static struct reftable_block_source_vtable strbuf_vtable = {
  44         .size = &strbuf_size,
  45         .read_block = &strbuf_read_block,
  46         .return_block = &strbuf_return_block,
  47         .close = &strbuf_close,
  48 };
  49
  50 void block_source_from_strbuf(struct reftable_block_source *bs,
  51                               struct strbuf *buf)
  52 {
  53         assert(!bs->ops);
  54         bs->ops = &strbuf_vtable;
  55         bs->arg = buf;
  56 }
  57
  58 static void malloc_return_block(void *b, struct reftable_block *dest)
  59 {
  60         if (dest->len)
  61                 memset(dest->data, 0xff, dest->len);
  62         reftable_free(dest->data);
  63 }
  64
  65 static struct reftable_block_source_vtable malloc_vtable = {
  66         .return_block = &malloc_return_block,
  67 };
  68
  69 static struct reftable_block_source malloc_block_source_instance = {
  70         .ops = &malloc_vtable,
  71 };
  72
  73 struct reftable_block_source malloc_block_source(void)
  74 {
  75         return malloc_block_source_instance;
  76 }
  77
  78 struct file_block_source {
  79         uint64_t size;
  80         unsigned char *data;
  81 };
  82
  83 static uint64_t file_size(void *b)
  84 {
  85         return ((struct file_block_source *)b)->size;
  86 }
  87
  88 static void file_return_block(void *b, struct reftable_block *dest)
  89 {
  90 }
  91
  92 static void file_close(void *v)
  93 {
  94         struct file_block_source *b = v;
  95         munmap(b->data, b->size);
  96         reftable_free(b);
  97 }
  98
  99 static int file_read_block(void *v, struct reftable_block *dest, uint64_t off,
 100                            uint32_t size)
 101 {
 102         struct file_block_source *b = v;
 103         assert(off + size <= b->size);
 104         dest->data = b->data + off;
 105         dest->len = size;
 106         return size;
 107 }
 108
 109 static struct reftable_block_source_vtable file_vtable = {
 110         .size = &file_size,
 111         .read_block = &file_read_block,
 112         .return_block = &file_return_block,
 113         .close = &file_close,
 114 };
 115
 116 int reftable_block_source_from_file(struct reftable_block_source *bs,
 117                                     const char *name)
 118 {
 119         struct file_block_source *p;
 120         struct stat st;
 121         int fd;
 122
 123         fd = open(name, O_RDONLY);
 124         if (fd < 0) {
 125                 if (errno == ENOENT)
 126                         return REFTABLE_NOT_EXIST_ERROR;
 127                 return -1;
 128         }
 129
 130         if (fstat(fd, &st) < 0) {
 131                 close(fd);
 132                 return REFTABLE_IO_ERROR;
 133         }
 134
 135         p = reftable_calloc(sizeof(*p));
 136         p->size = st.st_size;
 137         p->data = xmmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
 138         close(fd);
 139
 140         assert(!bs->ops);
 141         bs->ops = &file_vtable;
 142         bs->arg = p;
 143         return 0;
 144 }