2 #include "lzf.h" /* LZF compression library */
7 #include <sys/resource.h>
12 /* Convenience wrapper around fwrite, that returns the number of bytes written
13 * to the file instead of the number of objects (see fwrite(3)) and -1 in the
14 * case of an error. It also supports a NULL *fp to skip writing altogether
15 * instead of writing to /dev/null. */
16 static int rdbWriteRaw(FILE *fp
, void *p
, size_t len
) {
17 if (fp
!= NULL
&& fwrite(p
,len
,1,fp
) == 0) return -1;
21 int rdbSaveType(FILE *fp
, unsigned char type
) {
22 return rdbWriteRaw(fp
,&type
,1);
25 int rdbSaveTime(FILE *fp
, time_t t
) {
26 int32_t t32
= (int32_t) t
;
27 return rdbWriteRaw(fp
,&t32
,4);
30 /* check rdbLoadLen() comments for more info */
31 int rdbSaveLen(FILE *fp
, uint32_t len
) {
36 /* Save a 6 bit len */
37 buf
[0] = (len
&0xFF)|(REDIS_RDB_6BITLEN
<<6);
38 if (rdbWriteRaw(fp
,buf
,1) == -1) return -1;
40 } else if (len
< (1<<14)) {
41 /* Save a 14 bit len */
42 buf
[0] = ((len
>>8)&0xFF)|(REDIS_RDB_14BITLEN
<<6);
44 if (rdbWriteRaw(fp
,buf
,2) == -1) return -1;
47 /* Save a 32 bit len */
48 buf
[0] = (REDIS_RDB_32BITLEN
<<6);
49 if (rdbWriteRaw(fp
,buf
,1) == -1) return -1;
51 if (rdbWriteRaw(fp
,&len
,4) == -1) return -1;
57 /* Encode 'value' as an integer if possible (if integer will fit the
58 * supported range). If the function sucessful encoded the integer
59 * then the (up to 5 bytes) encoded representation is written in the
60 * string pointed by 'enc' and the length is returned. Otherwise
62 int rdbEncodeInteger(long long value
, unsigned char *enc
) {
63 /* Finally check if it fits in our ranges */
64 if (value
>= -(1<<7) && value
<= (1<<7)-1) {
65 enc
[0] = (REDIS_RDB_ENCVAL
<<6)|REDIS_RDB_ENC_INT8
;
68 } else if (value
>= -(1<<15) && value
<= (1<<15)-1) {
69 enc
[0] = (REDIS_RDB_ENCVAL
<<6)|REDIS_RDB_ENC_INT16
;
71 enc
[2] = (value
>>8)&0xFF;
73 } else if (value
>= -((long long)1<<31) && value
<= ((long long)1<<31)-1) {
74 enc
[0] = (REDIS_RDB_ENCVAL
<<6)|REDIS_RDB_ENC_INT32
;
76 enc
[2] = (value
>>8)&0xFF;
77 enc
[3] = (value
>>16)&0xFF;
78 enc
[4] = (value
>>24)&0xFF;
85 /* String objects in the form "2391" "-100" without any space and with a
86 * range of values that can fit in an 8, 16 or 32 bit signed value can be
87 * encoded as integers to save space */
88 int rdbTryIntegerEncoding(char *s
, size_t len
, unsigned char *enc
) {
90 char *endptr
, buf
[32];
92 /* Check if it's possible to encode this value as a number */
93 value
= strtoll(s
, &endptr
, 10);
94 if (endptr
[0] != '\0') return 0;
95 ll2string(buf
,32,value
);
97 /* If the number converted back into a string is not identical
98 * then it's not possible to encode the string as integer */
99 if (strlen(buf
) != len
|| memcmp(buf
,s
,len
)) return 0;
101 return rdbEncodeInteger(value
,enc
);
104 int rdbSaveLzfStringObject(FILE *fp
, unsigned char *s
, size_t len
) {
105 size_t comprlen
, outlen
;
110 /* We require at least four bytes compression for this to be worth it */
111 if (len
<= 4) return 0;
113 if ((out
= zmalloc(outlen
+1)) == NULL
) return 0;
114 comprlen
= lzf_compress(s
, len
, out
, outlen
);
119 /* Data compressed! Let's save it on disk */
120 byte
= (REDIS_RDB_ENCVAL
<<6)|REDIS_RDB_ENC_LZF
;
121 if ((n
= rdbWriteRaw(fp
,&byte
,1)) == -1) goto writeerr
;
124 if ((n
= rdbSaveLen(fp
,comprlen
)) == -1) goto writeerr
;
127 if ((n
= rdbSaveLen(fp
,len
)) == -1) goto writeerr
;
130 if ((n
= rdbWriteRaw(fp
,out
,comprlen
)) == -1) goto writeerr
;
141 /* Save a string objet as [len][data] on disk. If the object is a string
142 * representation of an integer value we try to safe it in a special form */
143 int rdbSaveRawString(FILE *fp
, unsigned char *s
, size_t len
) {
147 /* Try integer encoding */
149 unsigned char buf
[5];
150 if ((enclen
= rdbTryIntegerEncoding((char*)s
,len
,buf
)) > 0) {
151 if (rdbWriteRaw(fp
,buf
,enclen
) == -1) return -1;
156 /* Try LZF compression - under 20 bytes it's unable to compress even
157 * aaaaaaaaaaaaaaaaaa so skip it */
158 if (server
.rdbcompression
&& len
> 20) {
159 n
= rdbSaveLzfStringObject(fp
,s
,len
);
160 if (n
== -1) return -1;
162 /* Return value of 0 means data can't be compressed, save the old way */
166 if ((n
= rdbSaveLen(fp
,len
)) == -1) return -1;
169 if (rdbWriteRaw(fp
,s
,len
) == -1) return -1;
175 /* Save a long long value as either an encoded string or a string. */
176 int rdbSaveLongLongAsStringObject(FILE *fp
, long long value
) {
177 unsigned char buf
[32];
179 int enclen
= rdbEncodeInteger(value
,buf
);
181 return rdbWriteRaw(fp
,buf
,enclen
);
183 /* Encode as string */
184 enclen
= ll2string((char*)buf
,32,value
);
185 redisAssert(enclen
< 32);
186 if ((n
= rdbSaveLen(fp
,enclen
)) == -1) return -1;
188 if ((n
= rdbWriteRaw(fp
,buf
,enclen
)) == -1) return -1;
194 /* Like rdbSaveStringObjectRaw() but handle encoded objects */
195 int rdbSaveStringObject(FILE *fp
, robj
*obj
) {
196 /* Avoid to decode the object, then encode it again, if the
197 * object is alrady integer encoded. */
198 if (obj
->encoding
== REDIS_ENCODING_INT
) {
199 return rdbSaveLongLongAsStringObject(fp
,(long)obj
->ptr
);
201 redisAssert(obj
->encoding
== REDIS_ENCODING_RAW
);
202 return rdbSaveRawString(fp
,obj
->ptr
,sdslen(obj
->ptr
));
206 /* Save a double value. Doubles are saved as strings prefixed by an unsigned
207 * 8 bit integer specifing the length of the representation.
208 * This 8 bit integer has special values in order to specify the following
214 int rdbSaveDoubleValue(FILE *fp
, double val
) {
215 unsigned char buf
[128];
221 } else if (!isfinite(val
)) {
223 buf
[0] = (val
< 0) ? 255 : 254;
225 #if (DBL_MANT_DIG >= 52) && (LLONG_MAX == 0x7fffffffffffffffLL)
226 /* Check if the float is in a safe range to be casted into a
227 * long long. We are assuming that long long is 64 bit here.
228 * Also we are assuming that there are no implementations around where
229 * double has precision < 52 bit.
231 * Under this assumptions we test if a double is inside an interval
232 * where casting to long long is safe. Then using two castings we
233 * make sure the decimal part is zero. If all this is true we use
234 * integer printing function that is much faster. */
235 double min
= -4503599627370495; /* (2^52)-1 */
236 double max
= 4503599627370496; /* -(2^52) */
237 if (val
> min
&& val
< max
&& val
== ((double)((long long)val
)))
238 ll2string((char*)buf
+1,sizeof(buf
),(long long)val
);
241 snprintf((char*)buf
+1,sizeof(buf
)-1,"%.17g",val
);
242 buf
[0] = strlen((char*)buf
+1);
245 return rdbWriteRaw(fp
,buf
,len
);
248 /* Save a Redis object. */
249 int rdbSaveObject(FILE *fp
, robj
*o
) {
252 if (o
->type
== REDIS_STRING
) {
253 /* Save a string value */
254 if ((n
= rdbSaveStringObject(fp
,o
)) == -1) return -1;
256 } else if (o
->type
== REDIS_LIST
) {
257 /* Save a list value */
258 if (o
->encoding
== REDIS_ENCODING_ZIPLIST
) {
264 if ((n
= rdbSaveLen(fp
,ziplistLen(o
->ptr
))) == -1) return -1;
267 p
= ziplistIndex(o
->ptr
,0);
268 while(ziplistGet(p
,&vstr
,&vlen
,&vlong
)) {
270 if ((n
= rdbSaveRawString(fp
,vstr
,vlen
)) == -1)
274 if ((n
= rdbSaveLongLongAsStringObject(fp
,vlong
)) == -1)
278 p
= ziplistNext(o
->ptr
,p
);
280 } else if (o
->encoding
== REDIS_ENCODING_LINKEDLIST
) {
285 if ((n
= rdbSaveLen(fp
,listLength(list
))) == -1) return -1;
288 listRewind(list
,&li
);
289 while((ln
= listNext(&li
))) {
290 robj
*eleobj
= listNodeValue(ln
);
291 if ((n
= rdbSaveStringObject(fp
,eleobj
)) == -1) return -1;
295 redisPanic("Unknown list encoding");
297 } else if (o
->type
== REDIS_SET
) {
298 /* Save a set value */
299 if (o
->encoding
== REDIS_ENCODING_HT
) {
301 dictIterator
*di
= dictGetIterator(set
);
304 if ((n
= rdbSaveLen(fp
,dictSize(set
))) == -1) return -1;
307 while((de
= dictNext(di
)) != NULL
) {
308 robj
*eleobj
= dictGetEntryKey(de
);
309 if ((n
= rdbSaveStringObject(fp
,eleobj
)) == -1) return -1;
312 dictReleaseIterator(di
);
313 } else if (o
->encoding
== REDIS_ENCODING_INTSET
) {
318 if ((n
= rdbSaveLen(fp
,intsetLen(is
))) == -1) return -1;
321 while(intsetGet(is
,i
++,&llval
)) {
322 if ((n
= rdbSaveLongLongAsStringObject(fp
,llval
)) == -1) return -1;
326 redisPanic("Unknown set encoding");
328 } else if (o
->type
== REDIS_ZSET
) {
329 /* Save a set value */
331 dictIterator
*di
= dictGetIterator(zs
->dict
);
334 if ((n
= rdbSaveLen(fp
,dictSize(zs
->dict
))) == -1) return -1;
337 while((de
= dictNext(di
)) != NULL
) {
338 robj
*eleobj
= dictGetEntryKey(de
);
339 double *score
= dictGetEntryVal(de
);
341 if ((n
= rdbSaveStringObject(fp
,eleobj
)) == -1) return -1;
343 if ((n
= rdbSaveDoubleValue(fp
,*score
)) == -1) return -1;
346 dictReleaseIterator(di
);
347 } else if (o
->type
== REDIS_HASH
) {
348 /* Save a hash value */
349 if (o
->encoding
== REDIS_ENCODING_ZIPMAP
) {
350 unsigned char *p
= zipmapRewind(o
->ptr
);
351 unsigned int count
= zipmapLen(o
->ptr
);
352 unsigned char *key
, *val
;
353 unsigned int klen
, vlen
;
355 if ((n
= rdbSaveLen(fp
,count
)) == -1) return -1;
358 while((p
= zipmapNext(p
,&key
,&klen
,&val
,&vlen
)) != NULL
) {
359 if ((n
= rdbSaveRawString(fp
,key
,klen
)) == -1) return -1;
361 if ((n
= rdbSaveRawString(fp
,val
,vlen
)) == -1) return -1;
365 dictIterator
*di
= dictGetIterator(o
->ptr
);
368 if ((n
= rdbSaveLen(fp
,dictSize((dict
*)o
->ptr
))) == -1) return -1;
371 while((de
= dictNext(di
)) != NULL
) {
372 robj
*key
= dictGetEntryKey(de
);
373 robj
*val
= dictGetEntryVal(de
);
375 if ((n
= rdbSaveStringObject(fp
,key
)) == -1) return -1;
377 if ((n
= rdbSaveStringObject(fp
,val
)) == -1) return -1;
380 dictReleaseIterator(di
);
383 redisPanic("Unknown object type");
388 /* Return the length the object will have on disk if saved with
389 * the rdbSaveObject() function. Currently we use a trick to get
390 * this length with very little changes to the code. In the future
391 * we could switch to a faster solution. */
392 off_t
rdbSavedObjectLen(robj
*o
) {
393 int len
= rdbSaveObject(NULL
,o
);
394 redisAssert(len
!= -1);
398 /* Save a key-value pair, with expire time, type, key, value.
399 * On error -1 is returned.
400 * On success if the key was actaully saved 1 is returned, otherwise 0
401 * is returned (the key was already expired). */
402 int rdbSaveKeyValuePair(FILE *fp
, redisDb
*db
, robj
*key
, robj
*val
,
407 expiretime
= getExpire(db
,key
);
409 /* Save the expire time */
410 if (expiretime
!= -1) {
411 /* If this key is already expired skip it */
412 if (expiretime
< now
) return 0;
413 if (rdbSaveType(fp
,REDIS_EXPIRETIME
) == -1) return -1;
414 if (rdbSaveTime(fp
,expiretime
) == -1) return -1;
416 /* Save type, key, value */
417 if (rdbSaveType(fp
,val
->type
) == -1) return -1;
418 if (rdbSaveStringObject(fp
,key
) == -1) return -1;
419 if (rdbSaveObject(fp
,val
) == -1) return -1;
423 /* Save the DB on disk. Return REDIS_ERR on error, REDIS_OK on success */
424 int rdbSave(char *filename
) {
425 dictIterator
*di
= NULL
;
430 time_t now
= time(NULL
);
432 if (server
.ds_enabled
) {
433 cacheForcePointInTime();
434 return dsRdbSave(filename
);
437 snprintf(tmpfile
,256,"temp-%d.rdb", (int) getpid());
438 fp
= fopen(tmpfile
,"w");
440 redisLog(REDIS_WARNING
, "Failed opening .rdb for saving: %s",
444 if (fwrite("REDIS0001",9,1,fp
) == 0) goto werr
;
445 for (j
= 0; j
< server
.dbnum
; j
++) {
446 redisDb
*db
= server
.db
+j
;
448 if (dictSize(d
) == 0) continue;
449 di
= dictGetIterator(d
);
455 /* Write the SELECT DB opcode */
456 if (rdbSaveType(fp
,REDIS_SELECTDB
) == -1) goto werr
;
457 if (rdbSaveLen(fp
,j
) == -1) goto werr
;
459 /* Iterate this DB writing every entry */
460 while((de
= dictNext(di
)) != NULL
) {
461 sds keystr
= dictGetEntryKey(de
);
462 robj key
, *o
= dictGetEntryVal(de
);
464 initStaticStringObject(key
,keystr
);
465 if (rdbSaveKeyValuePair(fp
,db
,&key
,o
,now
) == -1) goto werr
;
467 dictReleaseIterator(di
);
470 if (rdbSaveType(fp
,REDIS_EOF
) == -1) goto werr
;
472 /* Make sure data will not remain on the OS's output buffers */
477 /* Use RENAME to make sure the DB file is changed atomically only
478 * if the generate DB file is ok. */
479 if (rename(tmpfile
,filename
) == -1) {
480 redisLog(REDIS_WARNING
,"Error moving temp DB file on the final destination: %s", strerror(errno
));
484 redisLog(REDIS_NOTICE
,"DB saved on disk");
486 server
.lastsave
= time(NULL
);
492 redisLog(REDIS_WARNING
,"Write error saving DB on disk: %s", strerror(errno
));
493 if (di
) dictReleaseIterator(di
);
497 int rdbSaveBackground(char *filename
) {
500 if (server
.bgsavechildpid
!= -1 ||
501 server
.bgsavethread
!= (pthread_t
) -1) return REDIS_ERR
;
503 server
.dirty_before_bgsave
= server
.dirty
;
505 if (server
.ds_enabled
) {
506 cacheForcePointInTime();
507 return dsRdbSave(filename
);
510 if ((childpid
= fork()) == 0) {
514 if (server
.ipfd
> 0) close(server
.ipfd
);
515 if (server
.sofd
> 0) close(server
.sofd
);
516 retval
= rdbSave(filename
);
517 _exit((retval
== REDIS_OK
) ? 0 : 1);
520 if (childpid
== -1) {
521 redisLog(REDIS_WARNING
,"Can't save in background: fork: %s",
525 redisLog(REDIS_NOTICE
,"Background saving started by pid %d",childpid
);
526 server
.bgsavechildpid
= childpid
;
527 updateDictResizePolicy();
530 return REDIS_OK
; /* unreached */
533 void rdbRemoveTempFile(pid_t childpid
) {
536 snprintf(tmpfile
,256,"temp-%d.rdb", (int) childpid
);
540 int rdbLoadType(FILE *fp
) {
542 if (fread(&type
,1,1,fp
) == 0) return -1;
546 time_t rdbLoadTime(FILE *fp
) {
548 if (fread(&t32
,4,1,fp
) == 0) return -1;
552 /* Load an encoded length from the DB, see the REDIS_RDB_* defines on the top
553 * of this file for a description of how this are stored on disk.
555 * isencoded is set to 1 if the readed length is not actually a length but
556 * an "encoding type", check the above comments for more info */
557 uint32_t rdbLoadLen(FILE *fp
, int *isencoded
) {
558 unsigned char buf
[2];
562 if (isencoded
) *isencoded
= 0;
563 if (fread(buf
,1,1,fp
) == 0) return REDIS_RDB_LENERR
;
564 type
= (buf
[0]&0xC0)>>6;
565 if (type
== REDIS_RDB_6BITLEN
) {
566 /* Read a 6 bit len */
568 } else if (type
== REDIS_RDB_ENCVAL
) {
569 /* Read a 6 bit len encoding type */
570 if (isencoded
) *isencoded
= 1;
572 } else if (type
== REDIS_RDB_14BITLEN
) {
573 /* Read a 14 bit len */
574 if (fread(buf
+1,1,1,fp
) == 0) return REDIS_RDB_LENERR
;
575 return ((buf
[0]&0x3F)<<8)|buf
[1];
577 /* Read a 32 bit len */
578 if (fread(&len
,4,1,fp
) == 0) return REDIS_RDB_LENERR
;
583 /* Load an integer-encoded object from file 'fp', with the specified
584 * encoding type 'enctype'. If encode is true the function may return
585 * an integer-encoded object as reply, otherwise the returned object
586 * will always be encoded as a raw string. */
587 robj
*rdbLoadIntegerObject(FILE *fp
, int enctype
, int encode
) {
588 unsigned char enc
[4];
591 if (enctype
== REDIS_RDB_ENC_INT8
) {
592 if (fread(enc
,1,1,fp
) == 0) return NULL
;
593 val
= (signed char)enc
[0];
594 } else if (enctype
== REDIS_RDB_ENC_INT16
) {
596 if (fread(enc
,2,1,fp
) == 0) return NULL
;
597 v
= enc
[0]|(enc
[1]<<8);
599 } else if (enctype
== REDIS_RDB_ENC_INT32
) {
601 if (fread(enc
,4,1,fp
) == 0) return NULL
;
602 v
= enc
[0]|(enc
[1]<<8)|(enc
[2]<<16)|(enc
[3]<<24);
605 val
= 0; /* anti-warning */
606 redisPanic("Unknown RDB integer encoding type");
609 return createStringObjectFromLongLong(val
);
611 return createObject(REDIS_STRING
,sdsfromlonglong(val
));
614 robj
*rdbLoadLzfStringObject(FILE*fp
) {
615 unsigned int len
, clen
;
616 unsigned char *c
= NULL
;
619 if ((clen
= rdbLoadLen(fp
,NULL
)) == REDIS_RDB_LENERR
) return NULL
;
620 if ((len
= rdbLoadLen(fp
,NULL
)) == REDIS_RDB_LENERR
) return NULL
;
621 if ((c
= zmalloc(clen
)) == NULL
) goto err
;
622 if ((val
= sdsnewlen(NULL
,len
)) == NULL
) goto err
;
623 if (fread(c
,clen
,1,fp
) == 0) goto err
;
624 if (lzf_decompress(c
,clen
,val
,len
) == 0) goto err
;
626 return createObject(REDIS_STRING
,val
);
633 robj
*rdbGenericLoadStringObject(FILE*fp
, int encode
) {
638 len
= rdbLoadLen(fp
,&isencoded
);
641 case REDIS_RDB_ENC_INT8
:
642 case REDIS_RDB_ENC_INT16
:
643 case REDIS_RDB_ENC_INT32
:
644 return rdbLoadIntegerObject(fp
,len
,encode
);
645 case REDIS_RDB_ENC_LZF
:
646 return rdbLoadLzfStringObject(fp
);
648 redisPanic("Unknown RDB encoding type");
652 if (len
== REDIS_RDB_LENERR
) return NULL
;
653 val
= sdsnewlen(NULL
,len
);
654 if (len
&& fread(val
,len
,1,fp
) == 0) {
658 return createObject(REDIS_STRING
,val
);
661 robj
*rdbLoadStringObject(FILE *fp
) {
662 return rdbGenericLoadStringObject(fp
,0);
665 robj
*rdbLoadEncodedStringObject(FILE *fp
) {
666 return rdbGenericLoadStringObject(fp
,1);
669 /* For information about double serialization check rdbSaveDoubleValue() */
670 int rdbLoadDoubleValue(FILE *fp
, double *val
) {
674 if (fread(&len
,1,1,fp
) == 0) return -1;
676 case 255: *val
= R_NegInf
; return 0;
677 case 254: *val
= R_PosInf
; return 0;
678 case 253: *val
= R_Nan
; return 0;
680 if (fread(buf
,len
,1,fp
) == 0) return -1;
682 sscanf(buf
, "%lg", val
);
687 /* Load a Redis object of the specified type from the specified file.
688 * On success a newly allocated object is returned, otherwise NULL. */
689 robj
*rdbLoadObject(int type
, FILE *fp
) {
694 redisLog(REDIS_DEBUG
,"LOADING OBJECT %d (at %d)\n",type
,ftell(fp
));
695 if (type
== REDIS_STRING
) {
696 /* Read string value */
697 if ((o
= rdbLoadEncodedStringObject(fp
)) == NULL
) return NULL
;
698 o
= tryObjectEncoding(o
);
699 } else if (type
== REDIS_LIST
) {
700 /* Read list value */
701 if ((len
= rdbLoadLen(fp
,NULL
)) == REDIS_RDB_LENERR
) return NULL
;
703 /* Use a real list when there are too many entries */
704 if (len
> server
.list_max_ziplist_entries
) {
705 o
= createListObject();
707 o
= createZiplistObject();
710 /* Load every single element of the list */
712 if ((ele
= rdbLoadEncodedStringObject(fp
)) == NULL
) return NULL
;
714 /* If we are using a ziplist and the value is too big, convert
715 * the object to a real list. */
716 if (o
->encoding
== REDIS_ENCODING_ZIPLIST
&&
717 ele
->encoding
== REDIS_ENCODING_RAW
&&
718 sdslen(ele
->ptr
) > server
.list_max_ziplist_value
)
719 listTypeConvert(o
,REDIS_ENCODING_LINKEDLIST
);
721 if (o
->encoding
== REDIS_ENCODING_ZIPLIST
) {
722 dec
= getDecodedObject(ele
);
723 o
->ptr
= ziplistPush(o
->ptr
,dec
->ptr
,sdslen(dec
->ptr
),REDIS_TAIL
);
727 ele
= tryObjectEncoding(ele
);
728 listAddNodeTail(o
->ptr
,ele
);
731 } else if (type
== REDIS_SET
) {
732 /* Read list/set value */
733 if ((len
= rdbLoadLen(fp
,NULL
)) == REDIS_RDB_LENERR
) return NULL
;
735 /* Use a regular set when there are too many entries. */
736 if (len
> server
.set_max_intset_entries
) {
737 o
= createSetObject();
738 /* It's faster to expand the dict to the right size asap in order
739 * to avoid rehashing */
740 if (len
> DICT_HT_INITIAL_SIZE
)
741 dictExpand(o
->ptr
,len
);
743 o
= createIntsetObject();
746 /* Load every single element of the list/set */
747 for (i
= 0; i
< len
; i
++) {
749 if ((ele
= rdbLoadEncodedStringObject(fp
)) == NULL
) return NULL
;
750 ele
= tryObjectEncoding(ele
);
752 if (o
->encoding
== REDIS_ENCODING_INTSET
) {
753 /* Fetch integer value from element */
754 if (isObjectRepresentableAsLongLong(ele
,&llval
) == REDIS_OK
) {
755 o
->ptr
= intsetAdd(o
->ptr
,llval
,NULL
);
757 setTypeConvert(o
,REDIS_ENCODING_HT
);
758 dictExpand(o
->ptr
,len
);
762 /* This will also be called when the set was just converted
763 * to regular hashtable encoded set */
764 if (o
->encoding
== REDIS_ENCODING_HT
) {
765 dictAdd((dict
*)o
->ptr
,ele
,NULL
);
770 } else if (type
== REDIS_ZSET
) {
771 /* Read list/set value */
775 if ((zsetlen
= rdbLoadLen(fp
,NULL
)) == REDIS_RDB_LENERR
) return NULL
;
776 o
= createZsetObject();
778 /* Load every single element of the list/set */
782 zskiplistNode
*znode
;
784 if ((ele
= rdbLoadEncodedStringObject(fp
)) == NULL
) return NULL
;
785 ele
= tryObjectEncoding(ele
);
786 if (rdbLoadDoubleValue(fp
,&score
) == -1) return NULL
;
787 znode
= zslInsert(zs
->zsl
,score
,ele
);
788 dictAdd(zs
->dict
,ele
,&znode
->score
);
789 incrRefCount(ele
); /* added to skiplist */
791 } else if (type
== REDIS_HASH
) {
794 if ((hashlen
= rdbLoadLen(fp
,NULL
)) == REDIS_RDB_LENERR
) return NULL
;
795 o
= createHashObject();
796 /* Too many entries? Use an hash table. */
797 if (hashlen
> server
.hash_max_zipmap_entries
)
798 convertToRealHash(o
);
799 /* Load every key/value, then set it into the zipmap or hash
800 * table, as needed. */
804 if ((key
= rdbLoadEncodedStringObject(fp
)) == NULL
) return NULL
;
805 if ((val
= rdbLoadEncodedStringObject(fp
)) == NULL
) return NULL
;
806 /* If we are using a zipmap and there are too big values
807 * the object is converted to real hash table encoding. */
808 if (o
->encoding
!= REDIS_ENCODING_HT
&&
809 ((key
->encoding
== REDIS_ENCODING_RAW
&&
810 sdslen(key
->ptr
) > server
.hash_max_zipmap_value
) ||
811 (val
->encoding
== REDIS_ENCODING_RAW
&&
812 sdslen(val
->ptr
) > server
.hash_max_zipmap_value
)))
814 convertToRealHash(o
);
817 if (o
->encoding
== REDIS_ENCODING_ZIPMAP
) {
818 unsigned char *zm
= o
->ptr
;
819 robj
*deckey
, *decval
;
821 /* We need raw string objects to add them to the zipmap */
822 deckey
= getDecodedObject(key
);
823 decval
= getDecodedObject(val
);
824 zm
= zipmapSet(zm
,deckey
->ptr
,sdslen(deckey
->ptr
),
825 decval
->ptr
,sdslen(decval
->ptr
),NULL
);
827 decrRefCount(deckey
);
828 decrRefCount(decval
);
832 key
= tryObjectEncoding(key
);
833 val
= tryObjectEncoding(val
);
834 dictAdd((dict
*)o
->ptr
,key
,val
);
838 redisPanic("Unknown object type");
843 /* Mark that we are loading in the global state and setup the fields
844 * needed to provide loading stats. */
845 void startLoading(FILE *fp
) {
850 server
.loading_start_time
= time(NULL
);
851 if (fstat(fileno(fp
), &sb
) == -1) {
852 server
.loading_total_bytes
= 1; /* just to avoid division by zero */
854 server
.loading_total_bytes
= sb
.st_size
;
858 /* Refresh the loading progress info */
859 void loadingProgress(off_t pos
) {
860 server
.loading_loaded_bytes
= pos
;
863 /* Loading finished */
864 void stopLoading(void) {
868 int rdbLoad(char *filename
) {
871 int type
, retval
, rdbver
;
872 redisDb
*db
= server
.db
+0;
874 time_t expiretime
, now
= time(NULL
);
877 fp
= fopen(filename
,"r");
878 if (!fp
) return REDIS_ERR
;
879 if (fread(buf
,9,1,fp
) == 0) goto eoferr
;
881 if (memcmp(buf
,"REDIS",5) != 0) {
883 redisLog(REDIS_WARNING
,"Wrong signature trying to load DB from file");
886 rdbver
= atoi(buf
+5);
889 redisLog(REDIS_WARNING
,"Can't handle RDB format version %d",rdbver
);
898 /* Serve the clients from time to time */
899 if (!(loops
++ % 1000)) {
900 loadingProgress(ftello(fp
));
901 aeProcessEvents(server
.el
, AE_FILE_EVENTS
|AE_DONT_WAIT
);
905 if ((type
= rdbLoadType(fp
)) == -1) goto eoferr
;
906 if (type
== REDIS_EXPIRETIME
) {
907 if ((expiretime
= rdbLoadTime(fp
)) == -1) goto eoferr
;
908 /* We read the time so we need to read the object type again */
909 if ((type
= rdbLoadType(fp
)) == -1) goto eoferr
;
911 if (type
== REDIS_EOF
) break;
912 /* Handle SELECT DB opcode as a special case */
913 if (type
== REDIS_SELECTDB
) {
914 if ((dbid
= rdbLoadLen(fp
,NULL
)) == REDIS_RDB_LENERR
)
916 if (dbid
>= (unsigned)server
.dbnum
) {
917 redisLog(REDIS_WARNING
,"FATAL: Data file was created with a Redis server configured to handle more than %d databases. Exiting\n", server
.dbnum
);
924 if ((key
= rdbLoadStringObject(fp
)) == NULL
) goto eoferr
;
926 if ((val
= rdbLoadObject(type
,fp
)) == NULL
) goto eoferr
;
927 /* Check if the key already expired */
928 if (expiretime
!= -1 && expiretime
< now
) {
933 /* Add the new object in the hash table */
934 retval
= dbAdd(db
,key
,val
);
935 if (retval
== REDIS_ERR
) {
936 redisLog(REDIS_WARNING
,"Loading DB, duplicated key (%s) found! Unrecoverable error, exiting now.", key
->ptr
);
939 /* Set the expire time if needed */
940 if (expiretime
!= -1) setExpire(db
,key
,expiretime
);
948 eoferr
: /* unexpected end of file is handled here with a fatal exit */
949 redisLog(REDIS_WARNING
,"Short read or OOM loading DB. Unrecoverable error, aborting now.");
951 return REDIS_ERR
; /* Just to avoid warning */
954 /* A background saving child (BGSAVE) terminated its work. Handle this. */
955 void backgroundSaveDoneHandler(int exitcode
, int bysignal
) {
956 if (!bysignal
&& exitcode
== 0) {
957 redisLog(REDIS_NOTICE
,
958 "Background saving terminated with success");
959 server
.dirty
= server
.dirty
- server
.dirty_before_bgsave
;
960 server
.lastsave
= time(NULL
);
961 } else if (!bysignal
&& exitcode
!= 0) {
962 redisLog(REDIS_WARNING
, "Background saving error");
964 redisLog(REDIS_WARNING
,
965 "Background saving terminated by signal %d", bysignal
);
966 rdbRemoveTempFile(server
.bgsavechildpid
);
968 server
.bgsavechildpid
= -1;
969 server
.bgsavethread
= (pthread_t
) -1;
970 server
.bgsavethread_state
= REDIS_BGSAVE_THREAD_UNACTIVE
;
971 /* Possibly there are slaves waiting for a BGSAVE in order to be served
972 * (the first stage of SYNC is a bulk transfer of dump.rdb) */
973 updateSlavesWaitingBgsave(exitcode
== 0 ? REDIS_OK
: REDIS_ERR
);
976 void saveCommand(redisClient
*c
) {
977 if (server
.bgsavechildpid
!= -1 || server
.bgsavethread
!= (pthread_t
)-1) {
978 addReplyError(c
,"Background save already in progress");
981 if (rdbSave(server
.dbfilename
) == REDIS_OK
) {
982 addReply(c
,shared
.ok
);
984 addReply(c
,shared
.err
);
988 void bgsaveCommand(redisClient
*c
) {
989 if (server
.bgsavechildpid
!= -1 || server
.bgsavethread
!= (pthread_t
)-1) {
990 addReplyError(c
,"Background save already in progress");
993 if (rdbSaveBackground(server
.dbfilename
) == REDIS_OK
) {
994 addReplyStatus(c
,"Background saving started");
996 addReply(c
,shared
.err
);