1 #include "redis.h" 2 #include "lzf.h" /* LZF compression library */ 3 4 #include <math.h> 5 #include <sys/types.h> 6 #include <sys/time.h> 7 #include <sys/resource.h> 8 #include <sys/wait.h> 9 #include <arpa/inet.h> 10 #include <sys/stat.h> 11 12 static int rdbWriteRaw(rio *rdb, void *p, size_t len) { 13 if (rdb && rioWrite(rdb,p,len) == 0) 14 return -1; 15 return len; 16 } 17 18 int rdbSaveType(rio *rdb, unsigned char type) { 19 return rdbWriteRaw(rdb,&type,1); 20 } 21 22 int rdbLoadType(rio *rdb) { 23 unsigned char type; 24 if (rioRead(rdb,&type,1) == 0) return -1; 25 return type; 26 } 27 28 int rdbSaveTime(rio *rdb, time_t t) { 29 int32_t t32 = (int32_t) t; 30 return rdbWriteRaw(rdb,&t32,4); 31 } 32 33 time_t rdbLoadTime(rio *rdb) { 34 int32_t t32; 35 if (rioRead(rdb,&t32,4) == 0) return -1; 36 return (time_t)t32; 37 } 38 39 int rdbSaveMillisecondTime(rio *rdb, long long t) { 40 int64_t t64 = (int64_t) t; 41 return rdbWriteRaw(rdb,&t64,8); 42 } 43 44 long long rdbLoadMillisecondTime(rio *rdb) { 45 int64_t t64; 46 if (rioRead(rdb,&t64,8) == 0) return -1; 47 return (long long)t64; 48 } 49 50 /* Saves an encoded length. The first two bits in the first byte are used to 51 * hold the encoding type. See the REDIS_RDB_* definitions for more information 52 * on the types of encoding. */ 53 int rdbSaveLen(rio *rdb, uint32_t len) { 54 unsigned char buf[2]; 55 size_t nwritten; 56 57 if (len < (1<<6)) { 58 /* Save a 6 bit len */ 59 buf[0] = (len&0xFF)|(REDIS_RDB_6BITLEN<<6); 60 if (rdbWriteRaw(rdb,buf,1) == -1) return -1; 61 nwritten = 1; 62 } else if (len < (1<<14)) { 63 /* Save a 14 bit len */ 64 buf[0] = ((len>>8)&0xFF)|(REDIS_RDB_14BITLEN<<6); 65 buf[1] = len&0xFF; 66 if (rdbWriteRaw(rdb,buf,2) == -1) return -1; 67 nwritten = 2; 68 } else { 69 /* Save a 32 bit len */ 70 buf[0] = (REDIS_RDB_32BITLEN<<6); 71 if (rdbWriteRaw(rdb,buf,1) == -1) return -1; 72 len = htonl(len); 73 if (rdbWriteRaw(rdb,&len,4) == -4) return -1; 74 nwritten = 1+4; 75 } 76 return nwritten; 77 } 78 79 /* Load an encoded length. The "isencoded" argument is set to 1 if the length 80 * is not actually a length but an "encoding type". See the REDIS_RDB_ENC_* 81 * definitions in rdb.h for more information. */ 82 uint32_t rdbLoadLen(rio *rdb, int *isencoded) { 83 unsigned char buf[2]; 84 uint32_t len; 85 int type; 86 87 if (isencoded) *isencoded = 0; 88 if (rioRead(rdb,buf,1) == 0) return REDIS_RDB_LENERR; 89 type = (buf[0]&0xC0)>>6; 90 if (type == REDIS_RDB_ENCVAL) { 91 /* Read a 6 bit encoding type. */ 92 if (isencoded) *isencoded = 1; 93 return buf[0]&0x3F; 94 } else if (type == REDIS_RDB_6BITLEN) { 95 /* Read a 6 bit len. */ 96 return buf[0]&0x3F; 97 } else if (type == REDIS_RDB_14BITLEN) { 98 /* Read a 14 bit len. */ 99 if (rioRead(rdb,buf+1,1) == 0) return REDIS_RDB_LENERR; 100 return ((buf[0]&0x3F)<<8)|buf[1]; 101 } else { 102 /* Read a 32 bit len. */ 103 if (rioRead(rdb,&len,4) == 0) return REDIS_RDB_LENERR; 104 return ntohl(len); 105 } 106 } 107 108 /* Encodes the "value" argument as integer when it fits in the supported ranges 109 * for encoded types. If the function successfully encodes the integer, the 110 * representation is stored in the buffer pointer to by "enc" and the string 111 * length is returned. Otherwise 0 is returned. */ 112 int rdbEncodeInteger(long long value, unsigned char *enc) { 113 if (value >= -(1<<7) && value <= (1<<7)-1) { 114 enc[0] = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_INT8; 115 enc[1] = value&0xFF; 116 return 2; 117 } else if (value >= -(1<<15) && value <= (1<<15)-1) { 118 enc[0] = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_INT16; 119 enc[1] = value&0xFF; 120 enc[2] = (value>>8)&0xFF; 121 return 3; 122 } else if (value >= -((long long)1<<31) && value <= ((long long)1<<31)-1) { 123 enc[0] = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_INT32; 124 enc[1] = value&0xFF; 125 enc[2] = (value>>8)&0xFF; 126 enc[3] = (value>>16)&0xFF; 127 enc[4] = (value>>24)&0xFF; 128 return 5; 129 } else { 130 return 0; 131 } 132 } 133 134 /* Loads an integer-encoded object with the specified encoding type "enctype". 135 * If the "encode" argument is set the function may return an integer-encoded 136 * string object, otherwise it always returns a raw string object. */ 137 robj *rdbLoadIntegerObject(rio *rdb, int enctype, int encode) { 138 unsigned char enc[4]; 139 long long val; 140 141 if (enctype == REDIS_RDB_ENC_INT8) { 142 if (rioRead(rdb,enc,1) == 0) return NULL; 143 val = (signed char)enc[0]; 144 } else if (enctype == REDIS_RDB_ENC_INT16) { 145 uint16_t v; 146 if (rioRead(rdb,enc,2) == 0) return NULL; 147 v = enc[0]|(enc[1]<<8); 148 val = (int16_t)v; 149 } else if (enctype == REDIS_RDB_ENC_INT32) { 150 uint32_t v; 151 if (rioRead(rdb,enc,4) == 0) return NULL; 152 v = enc[0]|(enc[1]<<8)|(enc[2]<<16)|(enc[3]<<24); 153 val = (int32_t)v; 154 } else { 155 val = 0; /* anti-warning */ 156 redisPanic("Unknown RDB integer encoding type"); 157 } 158 if (encode) 159 return createStringObjectFromLongLong(val); 160 else 161 return createObject(REDIS_STRING,sdsfromlonglong(val)); 162 } 163 164 /* String objects in the form "2391" "-100" without any space and with a 165 * range of values that can fit in an 8, 16 or 32 bit signed value can be 166 * encoded as integers to save space */ 167 int rdbTryIntegerEncoding(char *s, size_t len, unsigned char *enc) { 168 long long value; 169 char *endptr, buf[32]; 170 171 /* Check if it's possible to encode this value as a number */ 172 value = strtoll(s, &endptr, 10); 173 if (endptr[0] != '\0') return 0; 174 ll2string(buf,32,value); 175 176 /* If the number converted back into a string is not identical 177 * then it's not possible to encode the string as integer */ 178 if (strlen(buf) != len || memcmp(buf,s,len)) return 0; 179 180 return rdbEncodeInteger(value,enc); 181 } 182 183 int rdbSaveLzfStringObject(rio *rdb, unsigned char *s, size_t len) { 184 size_t comprlen, outlen; 185 unsigned char byte; 186 int n, nwritten = 0; 187 void *out; 188 189 /* We require at least four bytes compression for this to be worth it */ 190 if (len <= 4) return 0; 191 outlen = len-4; 192 if ((out = zmalloc(outlen+1)) == NULL) return 0; 193 comprlen = lzf_compress(s, len, out, outlen); 194 if (comprlen == 0) { 195 zfree(out); 196 return 0; 197 } 198 /* Data compressed! Let's save it on disk */ 199 byte = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_LZF; 200 if ((n = rdbWriteRaw(rdb,&byte,1)) == -1) goto writeerr; 201 nwritten += n; 202 203 if ((n = rdbSaveLen(rdb,comprlen)) == -1) goto writeerr; 204 nwritten += n; 205 206 if ((n = rdbSaveLen(rdb,len)) == -1) goto writeerr; 207 nwritten += n; 208 209 if ((n = rdbWriteRaw(rdb,out,comprlen)) == -1) goto writeerr; 210 nwritten += n; 211 212 zfree(out); 213 return nwritten; 214 215 writeerr: 216 zfree(out); 217 return -1; 218 } 219 220 robj *rdbLoadLzfStringObject(rio *rdb) { 221 unsigned int len, clen; 222 unsigned char *c = NULL; 223 sds val = NULL; 224 225 if ((clen = rdbLoadLen(rdb,NULL)) == REDIS_RDB_LENERR) return NULL; 226 if ((len = rdbLoadLen(rdb,NULL)) == REDIS_RDB_LENERR) return NULL; 227 if ((c = zmalloc(clen)) == NULL) goto err; 228 if ((val = sdsnewlen(NULL,len)) == NULL) goto err; 229 if (rioRead(rdb,c,clen) == 0) goto err; 230 if (lzf_decompress(c,clen,val,len) == 0) goto err; 231 zfree(c); 232 return createObject(REDIS_STRING,val); 233 err: 234 zfree(c); 235 sdsfree(val); 236 return NULL; 237 } 238 239 /* Save a string objet as [len][data] on disk. If the object is a string 240 * representation of an integer value we try to save it in a special form */ 241 int rdbSaveRawString(rio *rdb, unsigned char *s, size_t len) { 242 int enclen; 243 int n, nwritten = 0; 244 245 /* Try integer encoding */ 246 if (len <= 11) { 247 unsigned char buf[5]; 248 if ((enclen = rdbTryIntegerEncoding((char*)s,len,buf)) > 0) { 249 if (rdbWriteRaw(rdb,buf,enclen) == -1) return -1; 250 return enclen; 251 } 252 } 253 254 /* Try LZF compression - under 20 bytes it's unable to compress even 255 * aaaaaaaaaaaaaaaaaa so skip it */ 256 if (server.rdb_compression && len > 20) { 257 n = rdbSaveLzfStringObject(rdb,s,len); 258 if (n == -1) return -1; 259 if (n > 0) return n; 260 /* Return value of 0 means data can't be compressed, save the old way */ 261 } 262 263 /* Store verbatim */ 264 if ((n = rdbSaveLen(rdb,len)) == -1) return -1; 265 nwritten += n; 266 if (len > 0) { 267 if (rdbWriteRaw(rdb,s,len) == -1) return -1; 268 nwritten += len; 269 } 270 return nwritten; 271 } 272 273 /* Save a long long value as either an encoded string or a string. */ 274 int rdbSaveLongLongAsStringObject(rio *rdb, long long value) { 275 unsigned char buf[32]; 276 int n, nwritten = 0; 277 int enclen = rdbEncodeInteger(value,buf); 278 if (enclen > 0) { 279 return rdbWriteRaw(rdb,buf,enclen); 280 } else { 281 /* Encode as string */ 282 enclen = ll2string((char*)buf,32,value); 283 redisAssert(enclen < 32); 284 if ((n = rdbSaveLen(rdb,enclen)) == -1) return -1; 285 nwritten += n; 286 if ((n = rdbWriteRaw(rdb,buf,enclen)) == -1) return -1; 287 nwritten += n; 288 } 289 return nwritten; 290 } 291 292 /* Like rdbSaveStringObjectRaw() but handle encoded objects */ 293 int rdbSaveStringObject(rio *rdb, robj *obj) { 294 /* Avoid to decode the object, then encode it again, if the 295 * object is alrady integer encoded. */ 296 if (obj->encoding == REDIS_ENCODING_INT) { 297 return rdbSaveLongLongAsStringObject(rdb,(long)obj->ptr); 298 } else { 299 redisAssertWithInfo(NULL,obj,obj->encoding == REDIS_ENCODING_RAW); 300 return rdbSaveRawString(rdb,obj->ptr,sdslen(obj->ptr)); 301 } 302 } 303 304 robj *rdbGenericLoadStringObject(rio *rdb, int encode) { 305 int isencoded; 306 uint32_t len; 307 sds val; 308 309 len = rdbLoadLen(rdb,&isencoded); 310 if (isencoded) { 311 switch(len) { 312 case REDIS_RDB_ENC_INT8: 313 case REDIS_RDB_ENC_INT16: 314 case REDIS_RDB_ENC_INT32: 315 return rdbLoadIntegerObject(rdb,len,encode); 316 case REDIS_RDB_ENC_LZF: 317 return rdbLoadLzfStringObject(rdb); 318 default: 319 redisPanic("Unknown RDB encoding type"); 320 } 321 } 322 323 if (len == REDIS_RDB_LENERR) return NULL; 324 val = sdsnewlen(NULL,len); 325 if (len && rioRead(rdb,val,len) == 0) { 326 sdsfree(val); 327 return NULL; 328 } 329 return createObject(REDIS_STRING,val); 330 } 331 332 robj *rdbLoadStringObject(rio *rdb) { 333 return rdbGenericLoadStringObject(rdb,0); 334 } 335 336 robj *rdbLoadEncodedStringObject(rio *rdb) { 337 return rdbGenericLoadStringObject(rdb,1); 338 } 339 340 /* Save a double value. Doubles are saved as strings prefixed by an unsigned 341 * 8 bit integer specifing the length of the representation. 342 * This 8 bit integer has special values in order to specify the following 343 * conditions: 344 * 253: not a number 345 * 254: + inf 346 * 255: - inf 347 */ 348 int rdbSaveDoubleValue(rio *rdb, double val) { 349 unsigned char buf[128]; 350 int len; 351 352 if (isnan(val)) { 353 buf[0] = 253; 354 len = 1; 355 } else if (!isfinite(val)) { 356 len = 1; 357 buf[0] = (val < 0) ? 255 : 254; 358 } else { 359 #if (DBL_MANT_DIG >= 52) && (LLONG_MAX == 0x7fffffffffffffffLL) 360 /* Check if the float is in a safe range to be casted into a 361 * long long. We are assuming that long long is 64 bit here. 362 * Also we are assuming that there are no implementations around where 363 * double has precision < 52 bit. 364 * 365 * Under this assumptions we test if a double is inside an interval 366 * where casting to long long is safe. Then using two castings we 367 * make sure the decimal part is zero. If all this is true we use 368 * integer printing function that is much faster. */ 369 double min = -4503599627370495; /* (2^52)-1 */ 370 double max = 4503599627370496; /* -(2^52) */ 371 if (val > min && val < max && val == ((double)((long long)val))) 372 ll2string((char*)buf+1,sizeof(buf),(long long)val); 373 else 374 #endif 375 snprintf((char*)buf+1,sizeof(buf)-1,"%.17g",val); 376 buf[0] = strlen((char*)buf+1); 377 len = buf[0]+1; 378 } 379 return rdbWriteRaw(rdb,buf,len); 380 } 381 382 /* For information about double serialization check rdbSaveDoubleValue() */ 383 int rdbLoadDoubleValue(rio *rdb, double *val) { 384 char buf[128]; 385 unsigned char len; 386 387 if (rioRead(rdb,&len,1) == 0) return -1; 388 switch(len) { 389 case 255: *val = R_NegInf; return 0; 390 case 254: *val = R_PosInf; return 0; 391 case 253: *val = R_Nan; return 0; 392 default: 393 if (rioRead(rdb,buf,len) == 0) return -1; 394 buf[len] = '\0'; 395 sscanf(buf, "%lg", val); 396 return 0; 397 } 398 } 399 400 /* Save the object type of object "o". */ 401 int rdbSaveObjectType(rio *rdb, robj *o) { 402 switch (o->type) { 403 case REDIS_STRING: 404 return rdbSaveType(rdb,REDIS_RDB_TYPE_STRING); 405 case REDIS_LIST: 406 if (o->encoding == REDIS_ENCODING_ZIPLIST) 407 return rdbSaveType(rdb,REDIS_RDB_TYPE_LIST_ZIPLIST); 408 else if (o->encoding == REDIS_ENCODING_LINKEDLIST) 409 return rdbSaveType(rdb,REDIS_RDB_TYPE_LIST); 410 else 411 redisPanic("Unknown list encoding"); 412 case REDIS_SET: 413 if (o->encoding == REDIS_ENCODING_INTSET) 414 return rdbSaveType(rdb,REDIS_RDB_TYPE_SET_INTSET); 415 else if (o->encoding == REDIS_ENCODING_HT) 416 return rdbSaveType(rdb,REDIS_RDB_TYPE_SET); 417 else 418 redisPanic("Unknown set encoding"); 419 case REDIS_ZSET: 420 if (o->encoding == REDIS_ENCODING_ZIPLIST) 421 return rdbSaveType(rdb,REDIS_RDB_TYPE_ZSET_ZIPLIST); 422 else if (o->encoding == REDIS_ENCODING_SKIPLIST) 423 return rdbSaveType(rdb,REDIS_RDB_TYPE_ZSET); 424 else 425 redisPanic("Unknown sorted set encoding"); 426 case REDIS_HASH: 427 if (o->encoding == REDIS_ENCODING_ZIPMAP) 428 return rdbSaveType(rdb,REDIS_RDB_TYPE_HASH_ZIPMAP); 429 else if (o->encoding == REDIS_ENCODING_HT) 430 return rdbSaveType(rdb,REDIS_RDB_TYPE_HASH); 431 else 432 redisPanic("Unknown hash encoding"); 433 default: 434 redisPanic("Unknown object type"); 435 } 436 return -1; /* avoid warning */ 437 } 438 439 /* Load object type. Return -1 when the byte doesn't contain an object type. */ 440 int rdbLoadObjectType(rio *rdb) { 441 int type; 442 if ((type = rdbLoadType(rdb)) == -1) return -1; 443 if (!rdbIsObjectType(type)) return -1; 444 return type; 445 } 446 447 /* Save a Redis object. Returns -1 on error, 0 on success. */ 448 int rdbSaveObject(rio *rdb, robj *o) { 449 int n, nwritten = 0; 450 451 if (o->type == REDIS_STRING) { 452 /* Save a string value */ 453 if ((n = rdbSaveStringObject(rdb,o)) == -1) return -1; 454 nwritten += n; 455 } else if (o->type == REDIS_LIST) { 456 /* Save a list value */ 457 if (o->encoding == REDIS_ENCODING_ZIPLIST) { 458 size_t l = ziplistBlobLen((unsigned char*)o->ptr); 459 460 if ((n = rdbSaveRawString(rdb,o->ptr,l)) == -1) return -1; 461 nwritten += n; 462 } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) { 463 list *list = o->ptr; 464 listIter li; 465 listNode *ln; 466 467 if ((n = rdbSaveLen(rdb,listLength(list))) == -1) return -1; 468 nwritten += n; 469 470 listRewind(list,&li); 471 while((ln = listNext(&li))) { 472 robj *eleobj = listNodeValue(ln); 473 if ((n = rdbSaveStringObject(rdb,eleobj)) == -1) return -1; 474 nwritten += n; 475 } 476 } else { 477 redisPanic("Unknown list encoding"); 478 } 479 } else if (o->type == REDIS_SET) { 480 /* Save a set value */ 481 if (o->encoding == REDIS_ENCODING_HT) { 482 dict *set = o->ptr; 483 dictIterator *di = dictGetIterator(set); 484 dictEntry *de; 485 486 if ((n = rdbSaveLen(rdb,dictSize(set))) == -1) return -1; 487 nwritten += n; 488 489 while((de = dictNext(di)) != NULL) { 490 robj *eleobj = dictGetKey(de); 491 if ((n = rdbSaveStringObject(rdb,eleobj)) == -1) return -1; 492 nwritten += n; 493 } 494 dictReleaseIterator(di); 495 } else if (o->encoding == REDIS_ENCODING_INTSET) { 496 size_t l = intsetBlobLen((intset*)o->ptr); 497 498 if ((n = rdbSaveRawString(rdb,o->ptr,l)) == -1) return -1; 499 nwritten += n; 500 } else { 501 redisPanic("Unknown set encoding"); 502 } 503 } else if (o->type == REDIS_ZSET) { 504 /* Save a sorted set value */ 505 if (o->encoding == REDIS_ENCODING_ZIPLIST) { 506 size_t l = ziplistBlobLen((unsigned char*)o->ptr); 507 508 if ((n = rdbSaveRawString(rdb,o->ptr,l)) == -1) return -1; 509 nwritten += n; 510 } else if (o->encoding == REDIS_ENCODING_SKIPLIST) { 511 zset *zs = o->ptr; 512 dictIterator *di = dictGetIterator(zs->dict); 513 dictEntry *de; 514 515 if ((n = rdbSaveLen(rdb,dictSize(zs->dict))) == -1) return -1; 516 nwritten += n; 517 518 while((de = dictNext(di)) != NULL) { 519 robj *eleobj = dictGetKey(de); 520 double *score = dictGetVal(de); 521 522 if ((n = rdbSaveStringObject(rdb,eleobj)) == -1) return -1; 523 nwritten += n; 524 if ((n = rdbSaveDoubleValue(rdb,*score)) == -1) return -1; 525 nwritten += n; 526 } 527 dictReleaseIterator(di); 528 } else { 529 redisPanic("Unknown sorted set encoding"); 530 } 531 } else if (o->type == REDIS_HASH) { 532 /* Save a hash value */ 533 if (o->encoding == REDIS_ENCODING_ZIPMAP) { 534 size_t l = zipmapBlobLen((unsigned char*)o->ptr); 535 536 if ((n = rdbSaveRawString(rdb,o->ptr,l)) == -1) return -1; 537 nwritten += n; 538 } else { 539 dictIterator *di = dictGetIterator(o->ptr); 540 dictEntry *de; 541 542 if ((n = rdbSaveLen(rdb,dictSize((dict*)o->ptr))) == -1) return -1; 543 nwritten += n; 544 545 while((de = dictNext(di)) != NULL) { 546 robj *key = dictGetKey(de); 547 robj *val = dictGetVal(de); 548 549 if ((n = rdbSaveStringObject(rdb,key)) == -1) return -1; 550 nwritten += n; 551 if ((n = rdbSaveStringObject(rdb,val)) == -1) return -1; 552 nwritten += n; 553 } 554 dictReleaseIterator(di); 555 } 556 } else { 557 redisPanic("Unknown object type"); 558 } 559 return nwritten; 560 } 561 562 /* Return the length the object will have on disk if saved with 563 * the rdbSaveObject() function. Currently we use a trick to get 564 * this length with very little changes to the code. In the future 565 * we could switch to a faster solution. */ 566 off_t rdbSavedObjectLen(robj *o) { 567 int len = rdbSaveObject(NULL,o); 568 redisAssertWithInfo(NULL,o,len != -1); 569 return len; 570 } 571 572 /* Save a key-value pair, with expire time, type, key, value. 573 * On error -1 is returned. 574 * On success if the key was actaully saved 1 is returned, otherwise 0 575 * is returned (the key was already expired). */ 576 int rdbSaveKeyValuePair(rio *rdb, robj *key, robj *val, 577 long long expiretime, long long now) 578 { 579 /* Save the expire time */ 580 if (expiretime != -1) { 581 /* If this key is already expired skip it */ 582 if (expiretime < now) return 0; 583 if (rdbSaveType(rdb,REDIS_RDB_OPCODE_EXPIRETIME_MS) == -1) return -1; 584 if (rdbSaveMillisecondTime(rdb,expiretime) == -1) return -1; 585 } 586 587 /* Save type, key, value */ 588 if (rdbSaveObjectType(rdb,val) == -1) return -1; 589 if (rdbSaveStringObject(rdb,key) == -1) return -1; 590 if (rdbSaveObject(rdb,val) == -1) return -1; 591 return 1; 592 } 593 594 /* Save the DB on disk. Return REDIS_ERR on error, REDIS_OK on success */ 595 int rdbSave(char *filename) { 596 dictIterator *di = NULL; 597 dictEntry *de; 598 char tmpfile[256]; 599 int j; 600 long long now = mstime(); 601 FILE *fp; 602 rio rdb; 603 604 snprintf(tmpfile,256,"temp-%d.rdb", (int) getpid()); 605 fp = fopen(tmpfile,"w"); 606 if (!fp) { 607 redisLog(REDIS_WARNING, "Failed opening .rdb for saving: %s", 608 strerror(errno)); 609 return REDIS_ERR; 610 } 611 612 rioInitWithFile(&rdb,fp); 613 if (rdbWriteRaw(&rdb,"REDIS0003",9) == -1) goto werr; 614 615 for (j = 0; j < server.dbnum; j++) { 616 redisDb *db = server.db+j; 617 dict *d = db->dict; 618 if (dictSize(d) == 0) continue; 619 di = dictGetSafeIterator(d); 620 if (!di) { 621 fclose(fp); 622 return REDIS_ERR; 623 } 624 625 /* Write the SELECT DB opcode */ 626 if (rdbSaveType(&rdb,REDIS_RDB_OPCODE_SELECTDB) == -1) goto werr; 627 if (rdbSaveLen(&rdb,j) == -1) goto werr; 628 629 /* Iterate this DB writing every entry */ 630 while((de = dictNext(di)) != NULL) { 631 sds keystr = dictGetKey(de); 632 robj key, *o = dictGetVal(de); 633 long long expire; 634 635 initStaticStringObject(key,keystr); 636 expire = getExpire(db,&key); 637 if (rdbSaveKeyValuePair(&rdb,&key,o,expire,now) == -1) goto werr; 638 } 639 dictReleaseIterator(di); 640 } 641 /* EOF opcode */ 642 if (rdbSaveType(&rdb,REDIS_RDB_OPCODE_EOF) == -1) goto werr; 643 644 /* Make sure data will not remain on the OS's output buffers */ 645 fflush(fp); 646 fsync(fileno(fp)); 647 fclose(fp); 648 649 /* Use RENAME to make sure the DB file is changed atomically only 650 * if the generate DB file is ok. */ 651 if (rename(tmpfile,filename) == -1) { 652 redisLog(REDIS_WARNING,"Error moving temp DB file on the final destination: %s", strerror(errno)); 653 unlink(tmpfile); 654 return REDIS_ERR; 655 } 656 redisLog(REDIS_NOTICE,"DB saved on disk"); 657 server.dirty = 0; 658 server.lastsave = time(NULL); 659 return REDIS_OK; 660 661 werr: 662 fclose(fp); 663 unlink(tmpfile); 664 redisLog(REDIS_WARNING,"Write error saving DB on disk: %s", strerror(errno)); 665 if (di) dictReleaseIterator(di); 666 return REDIS_ERR; 667 } 668 669 int rdbSaveBackground(char *filename) { 670 pid_t childpid; 671 long long start; 672 673 if (server.rdb_child_pid != -1) return REDIS_ERR; 674 675 server.dirty_before_bgsave = server.dirty; 676 677 start = ustime(); 678 if ((childpid = fork()) == 0) { 679 int retval; 680 681 /* Child */ 682 if (server.ipfd > 0) close(server.ipfd); 683 if (server.sofd > 0) close(server.sofd); 684 retval = rdbSave(filename); 685 _exit((retval == REDIS_OK) ? 0 : 1); 686 } else { 687 /* Parent */ 688 server.stat_fork_time = ustime()-start; 689 if (childpid == -1) { 690 redisLog(REDIS_WARNING,"Can't save in background: fork: %s", 691 strerror(errno)); 692 return REDIS_ERR; 693 } 694 redisLog(REDIS_NOTICE,"Background saving started by pid %d",childpid); 695 server.rdb_child_pid = childpid; 696 updateDictResizePolicy(); 697 return REDIS_OK; 698 } 699 return REDIS_OK; /* unreached */ 700 } 701 702 void rdbRemoveTempFile(pid_t childpid) { 703 char tmpfile[256]; 704 705 snprintf(tmpfile,256,"temp-%d.rdb", (int) childpid); 706 unlink(tmpfile); 707 } 708 709 /* Load a Redis object of the specified type from the specified file. 710 * On success a newly allocated object is returned, otherwise NULL. */ 711 robj *rdbLoadObject(int rdbtype, rio *rdb) { 712 robj *o, *ele, *dec; 713 size_t len; 714 unsigned int i; 715 716 redisLog(REDIS_DEBUG,"LOADING OBJECT %d (at %d)\n",rdbtype,rdb->tell(rdb)); 717 if (rdbtype == REDIS_RDB_TYPE_STRING) { 718 /* Read string value */ 719 if ((o = rdbLoadEncodedStringObject(rdb)) == NULL) return NULL; 720 o = tryObjectEncoding(o); 721 } else if (rdbtype == REDIS_RDB_TYPE_LIST) { 722 /* Read list value */ 723 if ((len = rdbLoadLen(rdb,NULL)) == REDIS_RDB_LENERR) return NULL; 724 725 /* Use a real list when there are too many entries */ 726 if (len > server.list_max_ziplist_entries) { 727 o = createListObject(); 728 } else { 729 o = createZiplistObject(); 730 } 731 732 /* Load every single element of the list */ 733 while(len--) { 734 if ((ele = rdbLoadEncodedStringObject(rdb)) == NULL) return NULL; 735 736 /* If we are using a ziplist and the value is too big, convert 737 * the object to a real list. */ 738 if (o->encoding == REDIS_ENCODING_ZIPLIST && 739 ele->encoding == REDIS_ENCODING_RAW && 740 sdslen(ele->ptr) > server.list_max_ziplist_value) 741 listTypeConvert(o,REDIS_ENCODING_LINKEDLIST); 742 743 if (o->encoding == REDIS_ENCODING_ZIPLIST) { 744 dec = getDecodedObject(ele); 745 o->ptr = ziplistPush(o->ptr,dec->ptr,sdslen(dec->ptr),REDIS_TAIL); 746 decrRefCount(dec); 747 decrRefCount(ele); 748 } else { 749 ele = tryObjectEncoding(ele); 750 listAddNodeTail(o->ptr,ele); 751 } 752 } 753 } else if (rdbtype == REDIS_RDB_TYPE_SET) { 754 /* Read list/set value */ 755 if ((len = rdbLoadLen(rdb,NULL)) == REDIS_RDB_LENERR) return NULL; 756 757 /* Use a regular set when there are too many entries. */ 758 if (len > server.set_max_intset_entries) { 759 o = createSetObject(); 760 /* It's faster to expand the dict to the right size asap in order 761 * to avoid rehashing */ 762 if (len > DICT_HT_INITIAL_SIZE) 763 dictExpand(o->ptr,len); 764 } else { 765 o = createIntsetObject(); 766 } 767 768 /* Load every single element of the list/set */ 769 for (i = 0; i < len; i++) { 770 long long llval; 771 if ((ele = rdbLoadEncodedStringObject(rdb)) == NULL) return NULL; 772 ele = tryObjectEncoding(ele); 773 774 if (o->encoding == REDIS_ENCODING_INTSET) { 775 /* Fetch integer value from element */ 776 if (isObjectRepresentableAsLongLong(ele,&llval) == REDIS_OK) { 777 o->ptr = intsetAdd(o->ptr,llval,NULL); 778 } else { 779 setTypeConvert(o,REDIS_ENCODING_HT); 780 dictExpand(o->ptr,len); 781 } 782 } 783 784 /* This will also be called when the set was just converted 785 * to regular hashtable encoded set */ 786 if (o->encoding == REDIS_ENCODING_HT) { 787 dictAdd((dict*)o->ptr,ele,NULL); 788 } else { 789 decrRefCount(ele); 790 } 791 } 792 } else if (rdbtype == REDIS_RDB_TYPE_ZSET) { 793 /* Read list/set value */ 794 size_t zsetlen; 795 size_t maxelelen = 0; 796 zset *zs; 797 798 if ((zsetlen = rdbLoadLen(rdb,NULL)) == REDIS_RDB_LENERR) return NULL; 799 o = createZsetObject(); 800 zs = o->ptr; 801 802 /* Load every single element of the list/set */ 803 while(zsetlen--) { 804 robj *ele; 805 double score; 806 zskiplistNode *znode; 807 808 if ((ele = rdbLoadEncodedStringObject(rdb)) == NULL) return NULL; 809 ele = tryObjectEncoding(ele); 810 if (rdbLoadDoubleValue(rdb,&score) == -1) return NULL; 811 812 /* Don't care about integer-encoded strings. */ 813 if (ele->encoding == REDIS_ENCODING_RAW && 814 sdslen(ele->ptr) > maxelelen) 815 maxelelen = sdslen(ele->ptr); 816 817 znode = zslInsert(zs->zsl,score,ele); 818 dictAdd(zs->dict,ele,&znode->score); 819 incrRefCount(ele); /* added to skiplist */ 820 } 821 822 /* Convert *after* loading, since sorted sets are not stored ordered. */ 823 if (zsetLength(o) <= server.zset_max_ziplist_entries && 824 maxelelen <= server.zset_max_ziplist_value) 825 zsetConvert(o,REDIS_ENCODING_ZIPLIST); 826 } else if (rdbtype == REDIS_RDB_TYPE_HASH) { 827 size_t hashlen; 828 829 if ((hashlen = rdbLoadLen(rdb,NULL)) == REDIS_RDB_LENERR) return NULL; 830 o = createHashObject(); 831 /* Too many entries? Use an hash table. */ 832 if (hashlen > server.hash_max_zipmap_entries) 833 convertToRealHash(o); 834 /* Load every key/value, then set it into the zipmap or hash 835 * table, as needed. */ 836 while(hashlen--) { 837 robj *key, *val; 838 839 if ((key = rdbLoadEncodedStringObject(rdb)) == NULL) return NULL; 840 if ((val = rdbLoadEncodedStringObject(rdb)) == NULL) return NULL; 841 /* If we are using a zipmap and there are too big values 842 * the object is converted to real hash table encoding. */ 843 if (o->encoding != REDIS_ENCODING_HT && 844 ((key->encoding == REDIS_ENCODING_RAW && 845 sdslen(key->ptr) > server.hash_max_zipmap_value) || 846 (val->encoding == REDIS_ENCODING_RAW && 847 sdslen(val->ptr) > server.hash_max_zipmap_value))) 848 { 849 convertToRealHash(o); 850 } 851 852 if (o->encoding == REDIS_ENCODING_ZIPMAP) { 853 unsigned char *zm = o->ptr; 854 robj *deckey, *decval; 855 856 /* We need raw string objects to add them to the zipmap */ 857 deckey = getDecodedObject(key); 858 decval = getDecodedObject(val); 859 zm = zipmapSet(zm,deckey->ptr,sdslen(deckey->ptr), 860 decval->ptr,sdslen(decval->ptr),NULL); 861 o->ptr = zm; 862 decrRefCount(deckey); 863 decrRefCount(decval); 864 decrRefCount(key); 865 decrRefCount(val); 866 } else { 867 key = tryObjectEncoding(key); 868 val = tryObjectEncoding(val); 869 dictAdd((dict*)o->ptr,key,val); 870 } 871 } 872 } else if (rdbtype == REDIS_RDB_TYPE_HASH_ZIPMAP || 873 rdbtype == REDIS_RDB_TYPE_LIST_ZIPLIST || 874 rdbtype == REDIS_RDB_TYPE_SET_INTSET || 875 rdbtype == REDIS_RDB_TYPE_ZSET_ZIPLIST) 876 { 877 robj *aux = rdbLoadStringObject(rdb); 878 879 if (aux == NULL) return NULL; 880 o = createObject(REDIS_STRING,NULL); /* string is just placeholder */ 881 o->ptr = zmalloc(sdslen(aux->ptr)); 882 memcpy(o->ptr,aux->ptr,sdslen(aux->ptr)); 883 decrRefCount(aux); 884 885 /* Fix the object encoding, and make sure to convert the encoded 886 * data type into the base type if accordingly to the current 887 * configuration there are too many elements in the encoded data 888 * type. Note that we only check the length and not max element 889 * size as this is an O(N) scan. Eventually everything will get 890 * converted. */ 891 switch(rdbtype) { 892 case REDIS_RDB_TYPE_HASH_ZIPMAP: 893 o->type = REDIS_HASH; 894 o->encoding = REDIS_ENCODING_ZIPMAP; 895 if (zipmapLen(o->ptr) > server.hash_max_zipmap_entries) 896 convertToRealHash(o); 897 break; 898 case REDIS_RDB_TYPE_LIST_ZIPLIST: 899 o->type = REDIS_LIST; 900 o->encoding = REDIS_ENCODING_ZIPLIST; 901 if (ziplistLen(o->ptr) > server.list_max_ziplist_entries) 902 listTypeConvert(o,REDIS_ENCODING_LINKEDLIST); 903 break; 904 case REDIS_RDB_TYPE_SET_INTSET: 905 o->type = REDIS_SET; 906 o->encoding = REDIS_ENCODING_INTSET; 907 if (intsetLen(o->ptr) > server.set_max_intset_entries) 908 setTypeConvert(o,REDIS_ENCODING_HT); 909 break; 910 case REDIS_RDB_TYPE_ZSET_ZIPLIST: 911 o->type = REDIS_ZSET; 912 o->encoding = REDIS_ENCODING_ZIPLIST; 913 if (zsetLength(o) > server.zset_max_ziplist_entries) 914 zsetConvert(o,REDIS_ENCODING_SKIPLIST); 915 break; 916 default: 917 redisPanic("Unknown encoding"); 918 break; 919 } 920 } else { 921 redisPanic("Unknown object type"); 922 } 923 return o; 924 } 925 926 /* Mark that we are loading in the global state and setup the fields 927 * needed to provide loading stats. */ 928 void startLoading(FILE *fp) { 929 struct stat sb; 930 931 /* Load the DB */ 932 server.loading = 1; 933 server.loading_start_time = time(NULL); 934 if (fstat(fileno(fp), &sb) == -1) { 935 server.loading_total_bytes = 1; /* just to avoid division by zero */ 936 } else { 937 server.loading_total_bytes = sb.st_size; 938 } 939 } 940 941 /* Refresh the loading progress info */ 942 void loadingProgress(off_t pos) { 943 server.loading_loaded_bytes = pos; 944 } 945 946 /* Loading finished */ 947 void stopLoading(void) { 948 server.loading = 0; 949 } 950 951 int rdbLoad(char *filename) { 952 uint32_t dbid; 953 int type, rdbver; 954 redisDb *db = server.db+0; 955 char buf[1024]; 956 long long expiretime, now = mstime(); 957 long loops = 0; 958 FILE *fp; 959 rio rdb; 960 961 fp = fopen(filename,"r"); 962 if (!fp) { 963 errno = ENOENT; 964 return REDIS_ERR; 965 } 966 rioInitWithFile(&rdb,fp); 967 if (rioRead(&rdb,buf,9) == 0) goto eoferr; 968 buf[9] = '\0'; 969 if (memcmp(buf,"REDIS",5) != 0) { 970 fclose(fp); 971 redisLog(REDIS_WARNING,"Wrong signature trying to load DB from file"); 972 errno = EINVAL; 973 return REDIS_ERR; 974 } 975 rdbver = atoi(buf+5); 976 if (rdbver < 1 || rdbver > 3) { 977 fclose(fp); 978 redisLog(REDIS_WARNING,"Can't handle RDB format version %d",rdbver); 979 errno = EINVAL; 980 return REDIS_ERR; 981 } 982 983 startLoading(fp); 984 while(1) { 985 robj *key, *val; 986 expiretime = -1; 987 988 /* Serve the clients from time to time */ 989 if (!(loops++ % 1000)) { 990 loadingProgress(rdb.tell(&rdb)); 991 aeProcessEvents(server.el, AE_FILE_EVENTS|AE_DONT_WAIT); 992 } 993 994 /* Read type. */ 995 if ((type = rdbLoadType(&rdb)) == -1) goto eoferr; 996 if (type == REDIS_RDB_OPCODE_EXPIRETIME) { 997 if ((expiretime = rdbLoadTime(&rdb)) == -1) goto eoferr; 998 /* We read the time so we need to read the object type again. */ 999 if ((type = rdbLoadType(&rdb)) == -1) goto eoferr; 1000 /* the EXPIRETIME opcode specifies time in seconds, so convert 1001 * into milliesconds. */ 1002 expiretime *= 1000; 1003 } else if (type == REDIS_RDB_OPCODE_EXPIRETIME_MS) { 1004 /* Milliseconds precision expire times introduced with RDB 1005 * version 3. */ 1006 if ((expiretime = rdbLoadMillisecondTime(&rdb)) == -1) goto eoferr; 1007 /* We read the time so we need to read the object type again. */ 1008 if ((type = rdbLoadType(&rdb)) == -1) goto eoferr; 1009 } 1010 1011 if (type == REDIS_RDB_OPCODE_EOF) 1012 break; 1013 1014 /* Handle SELECT DB opcode as a special case */ 1015 if (type == REDIS_RDB_OPCODE_SELECTDB) { 1016 if ((dbid = rdbLoadLen(&rdb,NULL)) == REDIS_RDB_LENERR) 1017 goto eoferr; 1018 if (dbid >= (unsigned)server.dbnum) { 1019 redisLog(REDIS_WARNING,"FATAL: Data file was created with a Redis server configured to handle more than %d databases. Exiting\n", server.dbnum); 1020 exit(1); 1021 } 1022 db = server.db+dbid; 1023 continue; 1024 } 1025 /* Read key */ 1026 if ((key = rdbLoadStringObject(&rdb)) == NULL) goto eoferr; 1027 /* Read value */ 1028 if ((val = rdbLoadObject(type,&rdb)) == NULL) goto eoferr; 1029 /* Check if the key already expired */ 1030 if (expiretime != -1 && expiretime < now) { 1031 decrRefCount(key); 1032 decrRefCount(val); 1033 continue; 1034 } 1035 /* Add the new object in the hash table */ 1036 dbAdd(db,key,val); 1037 1038 /* Set the expire time if needed */ 1039 if (expiretime != -1) setExpire(db,key,expiretime); 1040 1041 decrRefCount(key); 1042 } 1043 fclose(fp); 1044 stopLoading(); 1045 return REDIS_OK; 1046 1047 eoferr: /* unexpected end of file is handled here with a fatal exit */ 1048 redisLog(REDIS_WARNING,"Short read or OOM loading DB. Unrecoverable error, aborting now."); 1049 exit(1); 1050 return REDIS_ERR; /* Just to avoid warning */ 1051 } 1052 1053 /* A background saving child (BGSAVE) terminated its work. Handle this. */ 1054 void backgroundSaveDoneHandler(int exitcode, int bysignal) { 1055 if (!bysignal && exitcode == 0) { 1056 redisLog(REDIS_NOTICE, 1057 "Background saving terminated with success"); 1058 server.dirty = server.dirty - server.dirty_before_bgsave; 1059 server.lastsave = time(NULL); 1060 } else if (!bysignal && exitcode != 0) { 1061 redisLog(REDIS_WARNING, "Background saving error"); 1062 } else { 1063 redisLog(REDIS_WARNING, 1064 "Background saving terminated by signal %d", bysignal); 1065 rdbRemoveTempFile(server.rdb_child_pid); 1066 } 1067 server.rdb_child_pid = -1; 1068 /* Possibly there are slaves waiting for a BGSAVE in order to be served 1069 * (the first stage of SYNC is a bulk transfer of dump.rdb) */ 1070 updateSlavesWaitingBgsave(exitcode == 0 ? REDIS_OK : REDIS_ERR); 1071 } 1072 1073 void saveCommand(redisClient *c) { 1074 if (server.rdb_child_pid != -1) { 1075 addReplyError(c,"Background save already in progress"); 1076 return; 1077 } 1078 if (rdbSave(server.rdb_filename) == REDIS_OK) { 1079 addReply(c,shared.ok); 1080 } else { 1081 addReply(c,shared.err); 1082 } 1083 } 1084 1085 void bgsaveCommand(redisClient *c) { 1086 if (server.rdb_child_pid != -1) { 1087 addReplyError(c,"Background save already in progress"); 1088 } else if (server.aof_child_pid != -1) { 1089 addReplyError(c,"Can't BGSAVE while AOF log rewriting is in progress"); 1090 } else if (rdbSaveBackground(server.rdb_filename) == REDIS_OK) { 1091 addReplyStatus(c,"Background saving started"); 1092 } else { 1093 addReply(c,shared.err); 1094 } 1095 } 1096