palacios/include/interfaces/vmm_keyed_stream.h

   1 /*
   2  * This file is part of the Palacios Virtual Machine Monitor developed
   3  * by the V3VEE Project with funding from the United States National
   4  * Science Foundation and the Department of Energy.
   5  *
   6  * The V3VEE Project is a joint project between Northwestern University
   7  * and the University of New Mexico.  You can find out more at
   8  * http://www.v3vee.org
   9  *
  10  * Copyright (c) 2011, Peter Dinda <pdinda@northwestern.edu>
  11  * Copyright (c) 2011, The V3VEE Project <http://www.v3vee.org>
  12  * All rights reserved.
  13  *
  14  * Author: Peter Dinda <pdinda@northwestern.edu>
  15  *
  16  * This is free software.  You are permitted to use,
  17  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
  18  */
  19
  20
  21 #ifndef __VMM_KEYED_STREAM_H__
  22 #define __VMM_KEYED_STREAM_H__
  23
  24 #include <palacios/vmm.h>
  25
  26
  27 /*
  28   A keyed stream essentially supports this:
  29
  30   URL => {collection of key->stream pairs}
  31
  32   If you open a key for reading, you get the read pointer set to its beginning.
  33   You can then make repeated reads to advance the read pointer.  You cannot seek.
  34
  35   Writing works similarly.
  36
  37   You cannot both read and write.
  38
  39 */
  40
  41 /* A keyed stream and its components are opaque to palacios */
  42 typedef void * v3_keyed_stream_t;
  43 typedef void * v3_keyed_stream_key_t;
  44
  45 typedef enum {V3_KS_RD_ONLY,V3_KS_WR_ONLY,V3_KS_WR_ONLY_CREATE} v3_keyed_stream_open_t;
  46
  47 #ifdef __V3VEE__
  48
  49
  50 v3_keyed_stream_t     v3_keyed_stream_open(char *url, v3_keyed_stream_open_t open_type);
  51 void                  v3_keyed_stream_close(v3_keyed_stream_t stream);
  52 void                  v3_keyed_stream_preallocate_hint_key(v3_keyed_stream_t stream, char *key, uint64_t size);
  53 v3_keyed_stream_key_t v3_keyed_stream_open_key(v3_keyed_stream_t stream, char *key);
  54 void                  v3_keyed_stream_close_key(v3_keyed_stream_t stream,  char *key);
  55 sint64_t              v3_keyed_stream_write_key(v3_keyed_stream_t stream,
  56                                                 v3_keyed_stream_key_t key,
  57                                                 void *buf,
  58                                                 sint64_t len);
  59 sint64_t              v3_keyed_stream_read_key(v3_keyed_stream_t stream,
  60                                                v3_keyed_stream_key_t key,
  61                                                void *buf,
  62                                                sint64_t len);
  63
  64
  65
  66 #define STD_SAVE_RAW(stream,ks,x)                       \
  67     do { \
  68         if (sizeof((x)) != v3_keyed_stream_write_key((stream), (ks), &(x), sizeof((x)))) { \
  69             v3_keyed_stream_close_key((stream),(ks)); \
  70             return -1;                                \
  71         } \
  72     } while (0)
  73
  74 #define STD_LOAD_RAW(stream,ks,x)                       \
  75     do {                                                                \
  76         if (sizeof((x)) != v3_keyed_stream_read_key((stream), (ks), &(x), sizeof((x)))) { \
  77             v3_keyed_stream_close_key((stream),(ks)); \
  78             return -1;                                 \
  79         } \
  80     } while (0)
  81 #endif
  82
  83 #define KSTREAM_MAGIC_COOKIE 0xabcd0123
  84
  85 #define STD_SAVE_TAGGED(stream,ks,tag,size,x)                           \
  86 do {                                                                    \
  87 uint32_t temp;                                                          \
  88 temp=KSTREAM_MAGIC_COOKIE;                                              \
  89 if (sizeof(temp) != v3_keyed_stream_write_key((stream),(ks),&temp,sizeof(temp))) { \
  90     v3_keyed_stream_close_key((stream),(ks));                           \
  91     return -1;                                                          \
  92  }                                                                      \
  93 temp=strlen(tag);                                                       \
  94 if (sizeof(temp) != v3_keyed_stream_write_key((stream),(ks),&temp,sizeof(temp))) { \
  95     v3_keyed_stream_close_key((stream),(ks));                           \
  96     return -1;                                                          \
  97  }                                                                      \
  98 if (temp != v3_keyed_stream_write_key((stream),(ks),tag,temp)) {        \
  99     v3_keyed_stream_close_key((stream),(ks));                           \
 100     return -1;                                                          \
 101  }                                                                      \
 102 temp=(size);                                                            \
 103 if (sizeof(temp) != v3_keyed_stream_write_key((stream),(ks),&temp,sizeof(temp))) { \
 104     v3_keyed_stream_close_key((stream),(ks));                           \
 105     return -1;                                                          \
 106  }                                                                      \
 107 if ((size) != v3_keyed_stream_write_key((stream),(ks),&(x),(size))) {   \
 108     v3_keyed_stream_close_key((stream),(ks));                           \
 109     return -1;                                                          \
 110  }                                                                      \
 111 } while (0)
 112
 113 #define STD_LOAD_TAGGED(stream,ks,tag,size,x)                           \
 114 do {                                                                    \
 115 uint32_t temp;                                                          \
 116 if (sizeof(temp) != v3_keyed_stream_read_key((stream),(ks),&temp,sizeof(temp))) { \
 117     v3_keyed_stream_close_key((stream),(ks));                           \
 118     return -1;                                                          \
 119  }                                                                      \
 120 if (temp!=KSTREAM_MAGIC_COOKIE) {                                       \
 121     v3_keyed_stream_close_key((stream),(ks));                           \
 122     return -1;                                                          \
 123 }                                                                       \
 124 if (sizeof(temp) != v3_keyed_stream_read_key((stream),(ks),&temp,sizeof(temp))) { \
 125     v3_keyed_stream_close_key((stream),(ks));                           \
 126     return -1;                                                          \
 127  }                                                                      \
 128 if (strlen((tag))!=temp) {                                              \
 129     v3_keyed_stream_close_key((stream),(ks));                           \
 130     return -1;                                                          \
 131 }                                                                       \
 132 { char buf[temp+1];                                                     \
 133     if (temp != v3_keyed_stream_read_key((stream),(ks),buf,temp)) {     \
 134         v3_keyed_stream_close_key((stream),(ks));                       \
 135         return -1;                                                      \
 136     }                                                                   \
 137     buf[temp]=0;                                                        \
 138     if (strncasecmp(buf,tag,temp)) {                                    \
 139         v3_keyed_stream_close_key((stream),(ks));                       \
 140         return -1;                                                      \
 141     }                                                                   \
 142 }                                                                       \
 143 if (sizeof(temp) != v3_keyed_stream_read_key((stream),(ks),&temp,sizeof(temp))) { \
 144     v3_keyed_stream_close_key((stream),(ks));                           \
 145     return -1;                                                          \
 146  }                                                                      \
 147 if (temp!=(size)) {                                                     \
 148     v3_keyed_stream_close_key((stream),(ks));                           \
 149     return -1;                                                          \
 150 }                                                                       \
 151 if ((size) != v3_keyed_stream_read_key((stream),(ks),&(x),(size))) {    \
 152     v3_keyed_stream_close_key((stream),(ks));                           \
 153     return -1;                                                          \
 154  }                                                                      \
 155 } while (0)
 156
 157 #ifdef V3_CONFIG_KEYED_STREAMS_WITH_TAGS
 158 #define STD_SAVE(stream,ks,x) STD_SAVE_TAGGED(stream,ks,#x,sizeof(x),x)
 159 #define STD_LOAD(stream,ks,x) STD_LOAD_TAGGED(stream,ks,#x,sizeof(x),x)
 160 #else
 161 #define STD_SAVE(stream,ks,x) STD_SAVE_RAW(stream,ks,x)
 162 #define STD_LOAD(stream,ks,x) STD_LOAD_RAW(stream,ks,x)
 163 #endif
 164
 165
 166
 167 struct v3_keyed_stream_hooks {
 168     // url is meaningful only to the host implementation
 169     v3_keyed_stream_t (*open)(char *url,
 170                               v3_keyed_stream_open_t open_type);
 171
 172     void (*close)(v3_keyed_stream_t stream);
 173
 174     void (*preallocate_hint_key)(v3_keyed_stream_t stream,
 175                                  char *key,
 176                                  uint64_t size);
 177
 178     v3_keyed_stream_key_t (*open_key)(v3_keyed_stream_t stream,
 179                                       char *key);
 180
 181     void (*close_key)(v3_keyed_stream_t stream,
 182                       v3_keyed_stream_key_t key);
 183
 184
 185     sint64_t (*write_key)(v3_keyed_stream_t stream,
 186                           v3_keyed_stream_key_t key,
 187                           void *buf,
 188                           sint64_t len);
 189
 190     sint64_t (*read_key)(v3_keyed_stream_t stream,
 191                          v3_keyed_stream_key_t key,
 192                          void *buf,
 193                          sint64_t len);
 194
 195 };
 196
 197
 198 extern void V3_Init_Keyed_Streams(struct v3_keyed_stream_hooks *hooks);
 199
 200 #endif