git.m6w6.name Git - awesomized/libmemcached/blob - storage_innodb.c

   1 /* -*- Mode: C; tab-width: 2; c-basic-offset: 2; indent-tabs-mode: nil -*- */
   2 #include <stdlib.h>
   3 #include <inttypes.h>
   4 #include <time.h>
   5 #include <stdbool.h>
   6 #include <string.h>
   7 #include <unistd.h>
   8 #include <assert.h>
   9 #include <embedded_innodb-1.0/innodb.h>
  10
  11 #include "storage.h"
  12
  13 const char *tablename= "memcached/items";
  14
  15 #define key_col_idx 0
  16 #define data_col_idx 1
  17 #define flags_col_idx 2
  18 #define cas_col_idx 3
  19 #define exp_col_idx 4
  20
  21 static uint64_t cas;
  22
  23 /**
  24  * To avoid cluttering down all the code with error checking I use the
  25  * following macro. It will execute the statement and verify that the
  26  * result of the operation is DB_SUCCESS. If any other error code is
  27  * returned it will print an "assert-like" output and jump to the
  28  * label error_exit. There I release resources before returning out of
  29  * the function.
  30  *
  31  * @param a the expression to execute
  32  *
  33  */
  34 #define checked(expression)                                    \
  35 do {                                                           \
  36   ib_err_t checked_err= expression;                            \
  37   if (checked_err != DB_SUCCESS)                               \
  38   {                                                            \
  39     fprintf(stderr, "ERROR: %s at %u: Failed: <%s>\n\t%s\n",   \
  40             __FILE__, __LINE__, #expression,                   \
  41             ib_strerror(checked_err));                         \
  42     goto error_exit;                                           \
  43   }                                                            \
  44 } while (0);
  45
  46 /**
  47  * Create the database schema.
  48  * @return true if the database schema was created without any problems
  49  *         false otherwise.
  50  */
  51 static bool create_schema(void)
  52 {
  53   ib_tbl_sch_t schema= NULL;
  54   ib_idx_sch_t dbindex= NULL;
  55
  56   if (ib_database_create("memcached") != IB_TRUE)
  57   {
  58     fprintf(stderr, "Failed to create database\n");
  59     return false;
  60   }
  61
  62   ib_trx_t transaction= ib_trx_begin(IB_TRX_SERIALIZABLE);
  63   ib_id_t table_id;
  64
  65   checked(ib_table_schema_create(tablename, &schema, IB_TBL_COMPACT, 0));
  66   checked(ib_table_schema_add_col(schema, "key", IB_BLOB,
  67                                   IB_COL_NOT_NULL, 0, 32767));
  68   checked(ib_table_schema_add_col(schema, "data", IB_BLOB,
  69                                   IB_COL_NONE, 0, 1024*1024));
  70   checked(ib_table_schema_add_col(schema, "flags", IB_INT,
  71                                   IB_COL_UNSIGNED, 0, 4));
  72   checked(ib_table_schema_add_col(schema, "cas", IB_INT,
  73                                   IB_COL_UNSIGNED, 0, 8));
  74   checked(ib_table_schema_add_col(schema, "exp", IB_INT,
  75                                   IB_COL_UNSIGNED, 0, 4));
  76   checked(ib_table_schema_add_index(schema, "PRIMARY_KEY", &dbindex));
  77   checked(ib_index_schema_add_col(dbindex, "key", 0));
  78   checked(ib_index_schema_set_clustered(dbindex));
  79   checked(ib_schema_lock_exclusive(transaction));
  80   checked(ib_table_create(transaction, schema, &table_id));
  81   checked(ib_trx_commit(transaction));
  82   ib_table_schema_delete(schema);
  83
  84   return true;
  85
  86  error_exit:
  87   /* @todo release resources! */
  88   {
  89     ib_err_t error= ib_trx_rollback(transaction);
  90     if (error != DB_SUCCESS)
  91       fprintf(stderr, "Failed to roll back the transaction:\n\t%s\n",
  92               ib_strerror(error));
  93   }
  94   return false;
  95 }
  96
  97 /**
  98  * Store an item into the database. Update the CAS id on the item before
  99  * storing it in the database.
 100  *
 101  * @param trx the transaction to use
 102  * @param item the item to store
 103  * @return true if we can go ahead and commit the transaction, false otherwise
 104  */
 105 static bool do_put_item(ib_trx_t trx, struct item* item)
 106 {
 107   update_cas(item);
 108
 109   ib_crsr_t cursor= NULL;
 110   ib_tpl_t tuple= NULL;
 111   bool retval= false;
 112
 113   checked(ib_cursor_open_table(tablename, trx, &cursor));
 114   checked(ib_cursor_lock(cursor, IB_LOCK_X));
 115   tuple= ib_clust_read_tuple_create(cursor);
 116
 117   checked(ib_col_set_value(tuple, key_col_idx, item->key, item->nkey));
 118   checked(ib_col_set_value(tuple, data_col_idx, item->data, item->size));
 119   checked(ib_tuple_write_u32(tuple, flags_col_idx, item->flags));
 120   checked(ib_tuple_write_u64(tuple, cas_col_idx, item->cas));
 121   checked(ib_tuple_write_u32(tuple, exp_col_idx, (ib_u32_t)item->exp));
 122   checked(ib_cursor_insert_row(cursor, tuple));
 123
 124   retval= true;
 125   /* Release resources: */
 126   /* FALLTHROUGH */
 127
 128  error_exit:
 129   if (tuple != NULL)
 130     ib_tuple_delete(tuple);
 131
 132   ib_err_t currsor_error;
 133   if (cursor != NULL)
 134     currsor_error= ib_cursor_close(cursor);
 135
 136   return retval;
 137 }
 138
 139 /**
 140  * Try to locate an item in the database. Return a cursor and the tuple to
 141  * the item if I found it in the database.
 142  *
 143  * @param trx the transaction to use
 144  * @param key the key of the item to look up
 145  * @param nkey the size of the key
 146  * @param cursor where to store the cursor (OUT)
 147  * @param tuple where to store the tuple (OUT)
 148  * @return true if I found the object, false otherwise
 149  */
 150 static bool do_locate_item(ib_trx_t trx,
 151                            const void* key,
 152                            size_t nkey,
 153                            ib_crsr_t *cursor)
 154 {
 155   int res;
 156   ib_tpl_t tuple= NULL;
 157
 158   *cursor= NULL;
 159
 160   checked(ib_cursor_open_table(tablename, trx, cursor));
 161   tuple= ib_clust_search_tuple_create(*cursor);
 162   if (tuple == NULL)
 163   {
 164     fprintf(stderr, "Failed to allocate tuple object\n");
 165     goto error_exit;
 166   }
 167
 168   checked(ib_col_set_value(tuple, key_col_idx, key, nkey));
 169   ib_err_t err= ib_cursor_moveto(*cursor, tuple, IB_CUR_GE, &res);
 170
 171   if (err == DB_SUCCESS && res == 0)
 172   {
 173     ib_tuple_delete(tuple);
 174     return true;
 175   }
 176   else if (err != DB_SUCCESS &&
 177            err != DB_RECORD_NOT_FOUND &&
 178            err != DB_END_OF_INDEX)
 179   {
 180     fprintf(stderr, "ERROR: ib_cursor_moveto(): %s\n", ib_strerror(err));
 181   }
 182   /* FALLTHROUGH */
 183  error_exit:
 184   if (tuple != NULL)
 185     ib_tuple_delete(tuple);
 186
 187   ib_err_t cursor_error;
 188   if (*cursor != NULL)
 189     cursor_error= ib_cursor_close(*cursor);
 190
 191   *cursor= NULL;
 192
 193   return false;
 194 }
 195
 196 /**
 197  * Try to get an item from the database
 198  *
 199  * @param trx the transaction to use
 200  * @param key the key to get
 201  * @param nkey the lenght of the key
 202  * @return a pointer to the item if I found it in the database
 203  */
 204 static struct item* do_get_item(ib_trx_t trx, const void* key, size_t nkey)
 205 {
 206   ib_crsr_t cursor= NULL;
 207   ib_tpl_t tuple= NULL;
 208   struct item* retval= NULL;
 209
 210   if (do_locate_item(trx, key, nkey, &cursor))
 211   {
 212     tuple= ib_clust_read_tuple_create(cursor);
 213     if (tuple == NULL)
 214     {
 215       fprintf(stderr, "Failed to create read tuple\n");
 216       goto error_exit;
 217     }
 218     checked(ib_cursor_read_row(cursor, tuple));
 219     ib_col_meta_t meta;
 220     ib_ulint_t datalen= ib_col_get_meta(tuple, data_col_idx, &meta);
 221     ib_ulint_t flaglen= ib_col_get_meta(tuple, flags_col_idx, &meta);
 222     ib_ulint_t caslen= ib_col_get_meta(tuple, cas_col_idx, &meta);
 223     ib_ulint_t explen= ib_col_get_meta(tuple, exp_col_idx, &meta);
 224     const void *dataptr= ib_col_get_value(tuple, data_col_idx);
 225
 226     retval= create_item(key, nkey, dataptr, datalen, 0, 0);
 227     if (retval == NULL)
 228     {
 229       fprintf(stderr, "Failed to allocate memory\n");
 230       goto error_exit;
 231     }
 232
 233     if (flaglen != 0)
 234     {
 235       ib_u32_t val;
 236       checked(ib_tuple_read_u32(tuple, flags_col_idx, &val));
 237       retval->flags= (uint32_t)val;
 238     }
 239     if (caslen != 0)
 240     {
 241       ib_u64_t val;
 242       checked(ib_tuple_read_u64(tuple, cas_col_idx, &val));
 243       retval->cas= (uint64_t)val;
 244     }
 245     if (explen != 0)
 246     {
 247       ib_u32_t val;
 248       checked(ib_tuple_read_u32(tuple, exp_col_idx, &val));
 249       retval->exp= (time_t)val;
 250     }
 251   }
 252
 253   /* Release resources */
 254   /* FALLTHROUGH */
 255
 256  error_exit:
 257   if (tuple != NULL)
 258     ib_tuple_delete(tuple);
 259
 260   ib_err_t cursor_error;
 261   if (cursor != NULL)
 262     cursor_error= ib_cursor_close(cursor);
 263
 264   return retval;
 265 }
 266
 267 /**
 268  * Delete an item from the cache
 269  * @param trx the transaction to use
 270  * @param key the key of the item to delete
 271  * @param nkey the length of the key
 272  * @return true if we should go ahead and commit the transaction
 273  *         or false if we should roll back (if the key didn't exists)
 274  */
 275 static bool do_delete_item(ib_trx_t trx, const void* key, size_t nkey) {
 276   ib_crsr_t cursor= NULL;
 277   bool retval= false;
 278
 279   if (do_locate_item(trx, key, nkey, &cursor))
 280   {
 281     checked(ib_cursor_lock(cursor, IB_LOCK_X));
 282     checked(ib_cursor_delete_row(cursor));
 283     retval= true;
 284   }
 285   /* Release resources */
 286   /* FALLTHROUGH */
 287
 288  error_exit:
 289   if (cursor != NULL)
 290   {
 291     ib_err_t cursor_error;
 292     cursor_error= ib_cursor_close(cursor);
 293   }
 294
 295   return retval;
 296 }
 297
 298
 299 /****************************************************************************
 300  * External interface
 301  ***************************************************************************/
 302
 303 /**
 304  * Initialize the database storage
 305  * @return true if the database was initialized successfully, false otherwise
 306  */
 307 bool initialize_storage(void)
 308 {
 309   ib_err_t error;
 310   ib_id_t tid;
 311
 312   checked(ib_init());
 313   checked(ib_cfg_set_text("data_home_dir", "/tmp/memcached_light"));
 314   checked(ib_cfg_set_text("log_group_home_dir", "/tmp/memcached_light"));
 315   checked(ib_cfg_set_bool_on("file_per_table"));
 316   checked(ib_startup("barracuda"));
 317
 318   /* check to see if the table exists or if we should create the schema */
 319   error= ib_table_get_id(tablename, &tid);
 320   if (error == DB_TABLE_NOT_FOUND)
 321   {
 322     if (!create_schema())
 323     {
 324       return false;
 325     }
 326   }
 327   else if (error != DB_SUCCESS)
 328   {
 329     fprintf(stderr, "Failed to get table id: %s\n", ib_strerror(error));
 330     return false;
 331   }
 332
 333   return true;
 334
 335  error_exit:
 336
 337   return false;
 338 }
 339
 340 /**
 341  * Shut down this storage engine
 342  */
 343 void shutdown_storage(void)
 344 {
 345   checked(ib_shutdown(IB_SHUTDOWN_NORMAL));
 346  error_exit:
 347   ;
 348 }
 349
 350 /**
 351  * Store an item in the databse
 352  *
 353  * @param item the item to store
 354  */
 355 void put_item(struct item* item)
 356 {
 357   ib_trx_t transaction= ib_trx_begin(IB_TRX_SERIALIZABLE);
 358   if (do_put_item(transaction, item))
 359   {
 360     ib_err_t error= ib_trx_commit(transaction);
 361     if (error != DB_SUCCESS)
 362     {
 363       fprintf(stderr, "Failed to store key:\n\t%s\n",
 364               ib_strerror(error));
 365     }
 366   }
 367   else
 368   {
 369     ib_err_t error= ib_trx_rollback(transaction);
 370     if (error != DB_SUCCESS)
 371       fprintf(stderr, "Failed to roll back the transaction:\n\t%s\n",
 372               ib_strerror(error));
 373   }
 374 }
 375
 376 /**
 377  * Get an item from the engine
 378  * @param key the key to grab
 379  * @param nkey number of bytes in the key
 380  * @return pointer to the item if found
 381  */
 382 struct item* get_item(const void* key, size_t nkey)
 383 {
 384   ib_trx_t transaction= ib_trx_begin(IB_TRX_SERIALIZABLE);
 385   struct item* ret= do_get_item(transaction, key, nkey);
 386   ib_err_t error= ib_trx_rollback(transaction);
 387
 388   if (error != DB_SUCCESS)
 389     fprintf(stderr, "Failed to roll back the transaction:\n\t%s\n",
 390             ib_strerror(error));
 391
 392   return ret;
 393 }
 394
 395 /**
 396  * Create an item structure and initialize it with the content
 397  *
 398  * @param key the key for the item
 399  * @param nkey the number of bytes in the key
 400  * @param data pointer to the value for the item (may be NULL)
 401  * @param size the size of the data
 402  * @param flags the flags to store with the data
 403  * @param exp the expiry time for the item
 404  * @return pointer to an initialized item object or NULL if allocation failed
 405  */
 406 struct item* create_item(const void* key, size_t nkey, const void* data,
 407                          size_t size, uint32_t flags, time_t exp)
 408 {
 409   struct item* ret= calloc(1, sizeof(*ret));
 410   if (ret != NULL)
 411   {
 412     ret->key= malloc(nkey);
 413     if (size > 0)
 414     {
 415       ret->data= malloc(size);
 416     }
 417
 418     if (ret->key == NULL || (size > 0 && ret->data == NULL))
 419     {
 420       free(ret->key);
 421       free(ret->data);
 422       free(ret);
 423       return NULL;
 424     }
 425
 426     memcpy(ret->key, key, nkey);
 427     if (data != NULL)
 428     {
 429       memcpy(ret->data, data, size);
 430     }
 431
 432     ret->nkey= nkey;
 433     ret->size= size;
 434     ret->flags= flags;
 435     ret->exp= exp;
 436   }
 437
 438   return ret;
 439 }
 440
 441 /**
 442  * Delete an item from the cache
 443  * @param key the key of the item to delete
 444  * @param nkey the length of the key
 445  * @return true if the item was deleted from the cache
 446  */
 447 bool delete_item(const void* key, size_t nkey) {
 448   ib_trx_t transaction= ib_trx_begin(IB_TRX_REPEATABLE_READ);
 449
 450   bool ret= do_delete_item(transaction, key, nkey);
 451
 452   if (ret)
 453   {
 454     /* object found. commit transaction */
 455     ib_err_t error= ib_trx_commit(transaction);
 456     if (error != DB_SUCCESS)
 457     {
 458       fprintf(stderr, "Failed to delete key:\n\t%s\n",
 459               ib_strerror(error));
 460       ret= false;
 461     }
 462   }
 463   else
 464   {
 465     ib_err_t error= ib_trx_rollback(transaction);
 466     if (error != DB_SUCCESS)
 467       fprintf(stderr, "Failed to roll back the transaction:\n\t%s\n",
 468               ib_strerror(error));
 469   }
 470
 471   return ret;
 472 }
 473
 474 /**
 475  * Flush the entire cache
 476  * @param when when the cache should be flushed (0 == immediately)
 477  */
 478 void flush(uint32_t when __attribute__((unused)))
 479 {
 480   /* @TODO implement support for when != 0 */
 481   ib_trx_t transaction= ib_trx_begin(IB_TRX_REPEATABLE_READ);
 482   ib_crsr_t cursor= NULL;
 483         ib_err_t err= DB_SUCCESS;
 484
 485   checked(ib_cursor_open_table(tablename, transaction, &cursor));
 486   checked(ib_cursor_first(cursor));
 487   checked(ib_cursor_lock(cursor, IB_LOCK_X));
 488
 489   do
 490   {
 491     checked(ib_cursor_delete_row(cursor));
 492   } while ((err= ib_cursor_next(cursor)) == DB_SUCCESS);
 493
 494   if (err != DB_END_OF_INDEX)
 495   {
 496     fprintf(stderr, "Failed to flush the cache: %s\n", ib_strerror(err));
 497     goto error_exit;
 498   }
 499   ib_err_t cursor_error;
 500   cursor_error= ib_cursor_close(cursor);
 501   cursor= NULL;
 502   checked(ib_trx_commit(transaction));
 503   return;
 504
 505  error_exit:
 506   if (cursor != NULL)
 507   {
 508     cursor_error= ib_cursor_close(cursor);
 509   }
 510
 511   ib_err_t error= ib_trx_rollback(transaction);
 512   if (error != DB_SUCCESS)
 513     fprintf(stderr, "Failed to roll back the transaction:\n\t%s\n",
 514             ib_strerror(error));
 515 }
 516
 517 /**
 518  * Update the cas ID in the item structure
 519  * @param item the item to update
 520  */
 521 void update_cas(struct item* item)
 522 {
 523   item->cas= ++cas;
 524 }
 525
 526 /**
 527  * Release all the resources allocated by the item
 528  * @param item the item to release
 529  */
 530 void release_item(struct item* item)
 531 {
 532   free(item->key);
 533   free(item->data);
 534   free(item);
 535 }