src/aof.c

   1 #include "redis.h"
   2
   3 #include <signal.h>
   4 #include <fcntl.h>
   5 #include <sys/stat.h>
   6
   7 /* Called when the user switches from "appendonly yes" to "appendonly no"
   8  * at runtime using the CONFIG command. */
   9 void stopAppendOnly(void) {
  10     flushAppendOnlyFile();
  11     aof_fsync(server.appendfd);
  12     close(server.appendfd);
  13
  14     server.appendfd = -1;
  15     server.appendseldb = -1;
  16     server.appendonly = 0;
  17     /* rewrite operation in progress? kill it, wait child exit */
  18     if (server.bgsavechildpid != -1) {
  19         int statloc;
  20
  21         if (kill(server.bgsavechildpid,SIGKILL) != -1)
  22             wait3(&statloc,0,NULL);
  23         /* reset the buffer accumulating changes while the child saves */
  24         sdsfree(server.bgrewritebuf);
  25         server.bgrewritebuf = sdsempty();
  26         server.bgsavechildpid = -1;
  27     }
  28 }
  29
  30 /* Called when the user switches from "appendonly no" to "appendonly yes"
  31  * at runtime using the CONFIG command. */
  32 int startAppendOnly(void) {
  33     server.appendonly = 1;
  34     server.lastfsync = time(NULL);
  35     server.appendfd = open(server.appendfilename,O_WRONLY|O_APPEND|O_CREAT,0644);
  36     if (server.appendfd == -1) {
  37         redisLog(REDIS_WARNING,"Used tried to switch on AOF via CONFIG, but I can't open the AOF file: %s",strerror(errno));
  38         return REDIS_ERR;
  39     }
  40     if (rewriteAppendOnlyFileBackground() == REDIS_ERR) {
  41         server.appendonly = 0;
  42         close(server.appendfd);
  43         redisLog(REDIS_WARNING,"Used tried to switch on AOF via CONFIG, I can't trigger a background AOF rewrite operation. Check the above logs for more info about the error.",strerror(errno));
  44         return REDIS_ERR;
  45     }
  46     return REDIS_OK;
  47 }
  48
  49 /* Write the append only file buffer on disk.
  50  *
  51  * Since we are required to write the AOF before replying to the client,
  52  * and the only way the client socket can get a write is entering when the
  53  * the event loop, we accumulate all the AOF writes in a memory
  54  * buffer and write it on disk using this function just before entering
  55  * the event loop again. */
  56 void flushAppendOnlyFile(void) {
  57     time_t now;
  58     ssize_t nwritten;
  59
  60     if (sdslen(server.aofbuf) == 0) return;
  61
  62     /* We want to perform a single write. This should be guaranteed atomic
  63      * at least if the filesystem we are writing is a real physical one.
  64      * While this will save us against the server being killed I don't think
  65      * there is much to do about the whole server stopping for power problems
  66      * or alike */
  67      nwritten = write(server.appendfd,server.aofbuf,sdslen(server.aofbuf));
  68      if (nwritten != (signed)sdslen(server.aofbuf)) {
  69         /* Ooops, we are in troubles. The best thing to do for now is
  70          * aborting instead of giving the illusion that everything is
  71          * working as expected. */
  72          if (nwritten == -1) {
  73             redisLog(REDIS_WARNING,"Exiting on error writing to the append-only file: %s",strerror(errno));
  74          } else {
  75             redisLog(REDIS_WARNING,"Exiting on short write while writing to the append-only file: %s",strerror(errno));
  76          }
  77          exit(1);
  78     }
  79     sdsfree(server.aofbuf);
  80     server.aofbuf = sdsempty();
  81
  82     /* Don't Fsync if no-appendfsync-on-rewrite is set to yes and we have
  83      * childs performing heavy I/O on disk. */
  84     if (server.no_appendfsync_on_rewrite &&
  85         (server.bgrewritechildpid != -1 || server.bgsavechildpid != -1))
  86             return;
  87     /* Fsync if needed */
  88     now = time(NULL);
  89     if (server.appendfsync == APPENDFSYNC_ALWAYS ||
  90         (server.appendfsync == APPENDFSYNC_EVERYSEC &&
  91          now-server.lastfsync > 1))
  92     {
  93         /* aof_fsync is defined as fdatasync() for Linux in order to avoid
  94          * flushing metadata. */
  95         aof_fsync(server.appendfd); /* Let's try to get this data on the disk */
  96         server.lastfsync = now;
  97     }
  98 }
  99
 100 sds catAppendOnlyGenericCommand(sds buf, int argc, robj **argv) {
 101     int j;
 102     buf = sdscatprintf(buf,"*%d\r\n",argc);
 103     for (j = 0; j < argc; j++) {
 104         robj *o = getDecodedObject(argv[j]);
 105         buf = sdscatprintf(buf,"$%lu\r\n",(unsigned long)sdslen(o->ptr));
 106         buf = sdscatlen(buf,o->ptr,sdslen(o->ptr));
 107         buf = sdscatlen(buf,"\r\n",2);
 108         decrRefCount(o);
 109     }
 110     return buf;
 111 }
 112
 113 sds catAppendOnlyExpireAtCommand(sds buf, robj *key, robj *seconds) {
 114     int argc = 3;
 115     long when;
 116     robj *argv[3];
 117
 118     /* Make sure we can use strtol */
 119     seconds = getDecodedObject(seconds);
 120     when = time(NULL)+strtol(seconds->ptr,NULL,10);
 121     decrRefCount(seconds);
 122
 123     argv[0] = createStringObject("EXPIREAT",8);
 124     argv[1] = key;
 125     argv[2] = createObject(REDIS_STRING,
 126         sdscatprintf(sdsempty(),"%ld",when));
 127     buf = catAppendOnlyGenericCommand(buf, argc, argv);
 128     decrRefCount(argv[0]);
 129     decrRefCount(argv[2]);
 130     return buf;
 131 }
 132
 133 void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv, int argc) {
 134     sds buf = sdsempty();
 135     robj *tmpargv[3];
 136
 137     /* The DB this command was targetting is not the same as the last command
 138      * we appendend. To issue a SELECT command is needed. */
 139     if (dictid != server.appendseldb) {
 140         char seldb[64];
 141
 142         snprintf(seldb,sizeof(seldb),"%d",dictid);
 143         buf = sdscatprintf(buf,"*2\r\n$6\r\nSELECT\r\n$%lu\r\n%s\r\n",
 144             (unsigned long)strlen(seldb),seldb);
 145         server.appendseldb = dictid;
 146     }
 147
 148     if (cmd->proc == expireCommand) {
 149         /* Translate EXPIRE into EXPIREAT */
 150         buf = catAppendOnlyExpireAtCommand(buf,argv[1],argv[2]);
 151     } else if (cmd->proc == setexCommand) {
 152         /* Translate SETEX to SET and EXPIREAT */
 153         tmpargv[0] = createStringObject("SET",3);
 154         tmpargv[1] = argv[1];
 155         tmpargv[2] = argv[3];
 156         buf = catAppendOnlyGenericCommand(buf,3,tmpargv);
 157         decrRefCount(tmpargv[0]);
 158         buf = catAppendOnlyExpireAtCommand(buf,argv[1],argv[2]);
 159     } else {
 160         buf = catAppendOnlyGenericCommand(buf,argc,argv);
 161     }
 162
 163     /* Append to the AOF buffer. This will be flushed on disk just before
 164      * of re-entering the event loop, so before the client will get a
 165      * positive reply about the operation performed. */
 166     server.aofbuf = sdscatlen(server.aofbuf,buf,sdslen(buf));
 167
 168     /* If a background append only file rewriting is in progress we want to
 169      * accumulate the differences between the child DB and the current one
 170      * in a buffer, so that when the child process will do its work we
 171      * can append the differences to the new append only file. */
 172     if (server.bgrewritechildpid != -1)
 173         server.bgrewritebuf = sdscatlen(server.bgrewritebuf,buf,sdslen(buf));
 174
 175     sdsfree(buf);
 176 }
 177
 178 /* In Redis commands are always executed in the context of a client, so in
 179  * order to load the append only file we need to create a fake client. */
 180 struct redisClient *createFakeClient(void) {
 181     struct redisClient *c = zmalloc(sizeof(*c));
 182
 183     selectDb(c,0);
 184     c->fd = -1;
 185     c->querybuf = sdsempty();
 186     c->argc = 0;
 187     c->argv = NULL;
 188     c->flags = 0;
 189     /* We set the fake client as a slave waiting for the synchronization
 190      * so that Redis will not try to send replies to this client. */
 191     c->replstate = REDIS_REPL_WAIT_BGSAVE_START;
 192     c->reply = listCreate();
 193     listSetFreeMethod(c->reply,decrRefCount);
 194     listSetDupMethod(c->reply,dupClientReplyValue);
 195     initClientMultiState(c);
 196     return c;
 197 }
 198
 199 void freeFakeClient(struct redisClient *c) {
 200     sdsfree(c->querybuf);
 201     listRelease(c->reply);
 202     freeClientMultiState(c);
 203     zfree(c);
 204 }
 205
 206 /* Replay the append log file. On error REDIS_OK is returned. On non fatal
 207  * error (the append only file is zero-length) REDIS_ERR is returned. On
 208  * fatal error an error message is logged and the program exists. */
 209 int loadAppendOnlyFile(char *filename) {
 210     struct redisClient *fakeClient;
 211     FILE *fp = fopen(filename,"r");
 212     struct redis_stat sb;
 213     int appendonly = server.appendonly;
 214
 215     if (redis_fstat(fileno(fp),&sb) != -1 && sb.st_size == 0)
 216         return REDIS_ERR;
 217
 218     if (fp == NULL) {
 219         redisLog(REDIS_WARNING,"Fatal error: can't open the append log file for reading: %s",strerror(errno));
 220         exit(1);
 221     }
 222
 223     /* Temporarily disable AOF, to prevent EXEC from feeding a MULTI
 224      * to the same file we're about to read. */
 225     server.appendonly = 0;
 226
 227     fakeClient = createFakeClient();
 228     while(1) {
 229         int argc, j;
 230         unsigned long len;
 231         robj **argv;
 232         char buf[128];
 233         sds argsds;
 234         struct redisCommand *cmd;
 235         int force_swapout;
 236
 237         if (fgets(buf,sizeof(buf),fp) == NULL) {
 238             if (feof(fp))
 239                 break;
 240             else
 241                 goto readerr;
 242         }
 243         if (buf[0] != '*') goto fmterr;
 244         argc = atoi(buf+1);
 245         argv = zmalloc(sizeof(robj*)*argc);
 246         for (j = 0; j < argc; j++) {
 247             if (fgets(buf,sizeof(buf),fp) == NULL) goto readerr;
 248             if (buf[0] != '$') goto fmterr;
 249             len = strtol(buf+1,NULL,10);
 250             argsds = sdsnewlen(NULL,len);
 251             if (len && fread(argsds,len,1,fp) == 0) goto fmterr;
 252             argv[j] = createObject(REDIS_STRING,argsds);
 253             if (fread(buf,2,1,fp) == 0) goto fmterr; /* discard CRLF */
 254         }
 255
 256         /* Command lookup */
 257         cmd = lookupCommand(argv[0]->ptr);
 258         if (!cmd) {
 259             redisLog(REDIS_WARNING,"Unknown command '%s' reading the append only file", argv[0]->ptr);
 260             exit(1);
 261         }
 262         /* Try object encoding */
 263         if (cmd->flags & REDIS_CMD_BULK)
 264             argv[argc-1] = tryObjectEncoding(argv[argc-1]);
 265         /* Run the command in the context of a fake client */
 266         fakeClient->argc = argc;
 267         fakeClient->argv = argv;
 268         cmd->proc(fakeClient);
 269         /* Discard the reply objects list from the fake client */
 270         while(listLength(fakeClient->reply))
 271             listDelNode(fakeClient->reply,listFirst(fakeClient->reply));
 272         /* Clean up, ready for the next command */
 273         for (j = 0; j < argc; j++) decrRefCount(argv[j]);
 274         zfree(argv);
 275         /* Handle swapping while loading big datasets when VM is on */
 276         force_swapout = 0;
 277         if ((zmalloc_used_memory() - server.vm_max_memory) > 1024*1024*32)
 278             force_swapout = 1;
 279
 280         if (server.vm_enabled && force_swapout) {
 281             while (zmalloc_used_memory() > server.vm_max_memory) {
 282                 if (vmSwapOneObjectBlocking() == REDIS_ERR) break;
 283             }
 284         }
 285     }
 286
 287     /* This point can only be reached when EOF is reached without errors.
 288      * If the client is in the middle of a MULTI/EXEC, log error and quit. */
 289     if (fakeClient->flags & REDIS_MULTI) goto readerr;
 290
 291     fclose(fp);
 292     freeFakeClient(fakeClient);
 293     server.appendonly = appendonly;
 294     return REDIS_OK;
 295
 296 readerr:
 297     if (feof(fp)) {
 298         redisLog(REDIS_WARNING,"Unexpected end of file reading the append only file");
 299     } else {
 300         redisLog(REDIS_WARNING,"Unrecoverable error reading the append only file: %s", strerror(errno));
 301     }
 302     exit(1);
 303 fmterr:
 304     redisLog(REDIS_WARNING,"Bad file format reading the append only file");
 305     exit(1);
 306 }
 307
 308 /* Write binary-safe string into a file in the bulkformat
 309  * $<count>\r\n<payload>\r\n */
 310 int fwriteBulkString(FILE *fp, char *s, unsigned long len) {
 311     char cbuf[128];
 312     int clen;
 313     cbuf[0] = '$';
 314     clen = 1+ll2string(cbuf+1,sizeof(cbuf)-1,len);
 315     cbuf[clen++] = '\r';
 316     cbuf[clen++] = '\n';
 317     if (fwrite(cbuf,clen,1,fp) == 0) return 0;
 318     if (len > 0 && fwrite(s,len,1,fp) == 0) return 0;
 319     if (fwrite("\r\n",2,1,fp) == 0) return 0;
 320     return 1;
 321 }
 322
 323 /* Write a double value in bulk format $<count>\r\n<payload>\r\n */
 324 int fwriteBulkDouble(FILE *fp, double d) {
 325     char buf[128], dbuf[128];
 326
 327     snprintf(dbuf,sizeof(dbuf),"%.17g\r\n",d);
 328     snprintf(buf,sizeof(buf),"$%lu\r\n",(unsigned long)strlen(dbuf)-2);
 329     if (fwrite(buf,strlen(buf),1,fp) == 0) return 0;
 330     if (fwrite(dbuf,strlen(dbuf),1,fp) == 0) return 0;
 331     return 1;
 332 }
 333
 334 /* Write a long value in bulk format $<count>\r\n<payload>\r\n */
 335 int fwriteBulkLongLong(FILE *fp, long long l) {
 336     char bbuf[128], lbuf[128];
 337     unsigned int blen, llen;
 338     llen = ll2string(lbuf,32,l);
 339     blen = snprintf(bbuf,sizeof(bbuf),"$%u\r\n%s\r\n",llen,lbuf);
 340     if (fwrite(bbuf,blen,1,fp) == 0) return 0;
 341     return 1;
 342 }
 343
 344 /* Delegate writing an object to writing a bulk string or bulk long long. */
 345 int fwriteBulkObject(FILE *fp, robj *obj) {
 346     /* Avoid using getDecodedObject to help copy-on-write (we are often
 347      * in a child process when this function is called). */
 348     if (obj->encoding == REDIS_ENCODING_INT) {
 349         return fwriteBulkLongLong(fp,(long)obj->ptr);
 350     } else if (obj->encoding == REDIS_ENCODING_RAW) {
 351         return fwriteBulkString(fp,obj->ptr,sdslen(obj->ptr));
 352     } else {
 353         redisPanic("Unknown string encoding");
 354     }
 355 }
 356
 357 /* Write a sequence of commands able to fully rebuild the dataset into
 358  * "filename". Used both by REWRITEAOF and BGREWRITEAOF. */
 359 int rewriteAppendOnlyFile(char *filename) {
 360     dictIterator *di = NULL;
 361     dictEntry *de;
 362     FILE *fp;
 363     char tmpfile[256];
 364     int j;
 365     time_t now = time(NULL);
 366
 367     /* Note that we have to use a different temp name here compared to the
 368      * one used by rewriteAppendOnlyFileBackground() function. */
 369     snprintf(tmpfile,256,"temp-rewriteaof-%d.aof", (int) getpid());
 370     fp = fopen(tmpfile,"w");
 371     if (!fp) {
 372         redisLog(REDIS_WARNING, "Failed rewriting the append only file: %s", strerror(errno));
 373         return REDIS_ERR;
 374     }
 375     for (j = 0; j < server.dbnum; j++) {
 376         char selectcmd[] = "*2\r\n$6\r\nSELECT\r\n";
 377         redisDb *db = server.db+j;
 378         dict *d = db->dict;
 379         if (dictSize(d) == 0) continue;
 380         di = dictGetIterator(d);
 381         if (!di) {
 382             fclose(fp);
 383             return REDIS_ERR;
 384         }
 385
 386         /* SELECT the new DB */
 387         if (fwrite(selectcmd,sizeof(selectcmd)-1,1,fp) == 0) goto werr;
 388         if (fwriteBulkLongLong(fp,j) == 0) goto werr;
 389
 390         /* Iterate this DB writing every entry */
 391         while((de = dictNext(di)) != NULL) {
 392             sds keystr = dictGetEntryKey(de);
 393             robj key, *o;
 394             time_t expiretime;
 395             int swapped;
 396
 397             keystr = dictGetEntryKey(de);
 398             o = dictGetEntryVal(de);
 399             initStaticStringObject(key,keystr);
 400             /* If the value for this key is swapped, load a preview in memory.
 401              * We use a "swapped" flag to remember if we need to free the
 402              * value object instead to just increment the ref count anyway
 403              * in order to avoid copy-on-write of pages if we are forked() */
 404             if (!server.vm_enabled || o->storage == REDIS_VM_MEMORY ||
 405                 o->storage == REDIS_VM_SWAPPING) {
 406                 swapped = 0;
 407             } else {
 408                 o = vmPreviewObject(o);
 409                 swapped = 1;
 410             }
 411             expiretime = getExpire(db,&key);
 412
 413             /* Save the key and associated value */
 414             if (o->type == REDIS_STRING) {
 415                 /* Emit a SET command */
 416                 char cmd[]="*3\r\n$3\r\nSET\r\n";
 417                 if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr;
 418                 /* Key and value */
 419                 if (fwriteBulkObject(fp,&key) == 0) goto werr;
 420                 if (fwriteBulkObject(fp,o) == 0) goto werr;
 421             } else if (o->type == REDIS_LIST) {
 422                 /* Emit the RPUSHes needed to rebuild the list */
 423                 char cmd[]="*3\r\n$5\r\nRPUSH\r\n";
 424                 if (o->encoding == REDIS_ENCODING_ZIPLIST) {
 425                     unsigned char *zl = o->ptr;
 426                     unsigned char *p = ziplistIndex(zl,0);
 427                     unsigned char *vstr;
 428                     unsigned int vlen;
 429                     long long vlong;
 430
 431                     while(ziplistGet(p,&vstr,&vlen,&vlong)) {
 432                         if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr;
 433                         if (fwriteBulkObject(fp,&key) == 0) goto werr;
 434                         if (vstr) {
 435                             if (fwriteBulkString(fp,(char*)vstr,vlen) == 0)
 436                                 goto werr;
 437                         } else {
 438                             if (fwriteBulkLongLong(fp,vlong) == 0)
 439                                 goto werr;
 440                         }
 441                         p = ziplistNext(zl,p);
 442                     }
 443                 } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) {
 444                     list *list = o->ptr;
 445                     listNode *ln;
 446                     listIter li;
 447
 448                     listRewind(list,&li);
 449                     while((ln = listNext(&li))) {
 450                         robj *eleobj = listNodeValue(ln);
 451
 452                         if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr;
 453                         if (fwriteBulkObject(fp,&key) == 0) goto werr;
 454                         if (fwriteBulkObject(fp,eleobj) == 0) goto werr;
 455                     }
 456                 } else {
 457                     redisPanic("Unknown list encoding");
 458                 }
 459             } else if (o->type == REDIS_SET) {
 460                 /* Emit the SADDs needed to rebuild the set */
 461                 dict *set = o->ptr;
 462                 dictIterator *di = dictGetIterator(set);
 463                 dictEntry *de;
 464
 465                 while((de = dictNext(di)) != NULL) {
 466                     char cmd[]="*3\r\n$4\r\nSADD\r\n";
 467                     robj *eleobj = dictGetEntryKey(de);
 468
 469                     if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr;
 470                     if (fwriteBulkObject(fp,&key) == 0) goto werr;
 471                     if (fwriteBulkObject(fp,eleobj) == 0) goto werr;
 472                 }
 473                 dictReleaseIterator(di);
 474             } else if (o->type == REDIS_ZSET) {
 475                 /* Emit the ZADDs needed to rebuild the sorted set */
 476                 zset *zs = o->ptr;
 477                 dictIterator *di = dictGetIterator(zs->dict);
 478                 dictEntry *de;
 479
 480                 while((de = dictNext(di)) != NULL) {
 481                     char cmd[]="*4\r\n$4\r\nZADD\r\n";
 482                     robj *eleobj = dictGetEntryKey(de);
 483                     double *score = dictGetEntryVal(de);
 484
 485                     if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr;
 486                     if (fwriteBulkObject(fp,&key) == 0) goto werr;
 487                     if (fwriteBulkDouble(fp,*score) == 0) goto werr;
 488                     if (fwriteBulkObject(fp,eleobj) == 0) goto werr;
 489                 }
 490                 dictReleaseIterator(di);
 491             } else if (o->type == REDIS_HASH) {
 492                 char cmd[]="*4\r\n$4\r\nHSET\r\n";
 493
 494                 /* Emit the HSETs needed to rebuild the hash */
 495                 if (o->encoding == REDIS_ENCODING_ZIPMAP) {
 496                     unsigned char *p = zipmapRewind(o->ptr);
 497                     unsigned char *field, *val;
 498                     unsigned int flen, vlen;
 499
 500                     while((p = zipmapNext(p,&field,&flen,&val,&vlen)) != NULL) {
 501                         if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr;
 502                         if (fwriteBulkObject(fp,&key) == 0) goto werr;
 503                         if (fwriteBulkString(fp,(char*)field,flen) == 0)
 504                             goto werr;
 505                         if (fwriteBulkString(fp,(char*)val,vlen) == 0)
 506                             goto werr;
 507                     }
 508                 } else {
 509                     dictIterator *di = dictGetIterator(o->ptr);
 510                     dictEntry *de;
 511
 512                     while((de = dictNext(di)) != NULL) {
 513                         robj *field = dictGetEntryKey(de);
 514                         robj *val = dictGetEntryVal(de);
 515
 516                         if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr;
 517                         if (fwriteBulkObject(fp,&key) == 0) goto werr;
 518                         if (fwriteBulkObject(fp,field) == 0) goto werr;
 519                         if (fwriteBulkObject(fp,val) == 0) goto werr;
 520                     }
 521                     dictReleaseIterator(di);
 522                 }
 523             } else {
 524                 redisPanic("Unknown object type");
 525             }
 526             /* Save the expire time */
 527             if (expiretime != -1) {
 528                 char cmd[]="*3\r\n$8\r\nEXPIREAT\r\n";
 529                 /* If this key is already expired skip it */
 530                 if (expiretime < now) continue;
 531                 if (fwrite(cmd,sizeof(cmd)-1,1,fp) == 0) goto werr;
 532                 if (fwriteBulkObject(fp,&key) == 0) goto werr;
 533                 if (fwriteBulkLongLong(fp,expiretime) == 0) goto werr;
 534             }
 535             if (swapped) decrRefCount(o);
 536         }
 537         dictReleaseIterator(di);
 538     }
 539
 540     /* Make sure data will not remain on the OS's output buffers */
 541     fflush(fp);
 542     aof_fsync(fileno(fp));
 543     fclose(fp);
 544
 545     /* Use RENAME to make sure the DB file is changed atomically only
 546      * if the generate DB file is ok. */
 547     if (rename(tmpfile,filename) == -1) {
 548         redisLog(REDIS_WARNING,"Error moving temp append only file on the final destination: %s", strerror(errno));
 549         unlink(tmpfile);
 550         return REDIS_ERR;
 551     }
 552     redisLog(REDIS_NOTICE,"SYNC append only file rewrite performed");
 553     return REDIS_OK;
 554
 555 werr:
 556     fclose(fp);
 557     unlink(tmpfile);
 558     redisLog(REDIS_WARNING,"Write error writing append only file on disk: %s", strerror(errno));
 559     if (di) dictReleaseIterator(di);
 560     return REDIS_ERR;
 561 }
 562
 563 /* This is how rewriting of the append only file in background works:
 564  *
 565  * 1) The user calls BGREWRITEAOF
 566  * 2) Redis calls this function, that forks():
 567  *    2a) the child rewrite the append only file in a temp file.
 568  *    2b) the parent accumulates differences in server.bgrewritebuf.
 569  * 3) When the child finished '2a' exists.
 570  * 4) The parent will trap the exit code, if it's OK, will append the
 571  *    data accumulated into server.bgrewritebuf into the temp file, and
 572  *    finally will rename(2) the temp file in the actual file name.
 573  *    The the new file is reopened as the new append only file. Profit!
 574  */
 575 int rewriteAppendOnlyFileBackground(void) {
 576     pid_t childpid;
 577
 578     if (server.bgrewritechildpid != -1) return REDIS_ERR;
 579     if (server.vm_enabled) waitEmptyIOJobsQueue();
 580     if ((childpid = fork()) == 0) {
 581         /* Child */
 582         char tmpfile[256];
 583
 584         if (server.vm_enabled) vmReopenSwapFile();
 585         close(server.fd);
 586         snprintf(tmpfile,256,"temp-rewriteaof-bg-%d.aof", (int) getpid());
 587         if (rewriteAppendOnlyFile(tmpfile) == REDIS_OK) {
 588             _exit(0);
 589         } else {
 590             _exit(1);
 591         }
 592     } else {
 593         /* Parent */
 594         if (childpid == -1) {
 595             redisLog(REDIS_WARNING,
 596                 "Can't rewrite append only file in background: fork: %s",
 597                 strerror(errno));
 598             return REDIS_ERR;
 599         }
 600         redisLog(REDIS_NOTICE,
 601             "Background append only file rewriting started by pid %d",childpid);
 602         server.bgrewritechildpid = childpid;
 603         updateDictResizePolicy();
 604         /* We set appendseldb to -1 in order to force the next call to the
 605          * feedAppendOnlyFile() to issue a SELECT command, so the differences
 606          * accumulated by the parent into server.bgrewritebuf will start
 607          * with a SELECT statement and it will be safe to merge. */
 608         server.appendseldb = -1;
 609         return REDIS_OK;
 610     }
 611     return REDIS_OK; /* unreached */
 612 }
 613
 614 void bgrewriteaofCommand(redisClient *c) {
 615     if (server.bgrewritechildpid != -1) {
 616         addReplySds(c,sdsnew("-ERR background append only file rewriting already in progress\r\n"));
 617         return;
 618     }
 619     if (rewriteAppendOnlyFileBackground() == REDIS_OK) {
 620         char *status = "+Background append only file rewriting started\r\n";
 621         addReplySds(c,sdsnew(status));
 622     } else {
 623         addReply(c,shared.err);
 624     }
 625 }
 626
 627 void aofRemoveTempFile(pid_t childpid) {
 628     char tmpfile[256];
 629
 630     snprintf(tmpfile,256,"temp-rewriteaof-bg-%d.aof", (int) childpid);
 631     unlink(tmpfile);
 632 }
 633
 634 /* A background append only file rewriting (BGREWRITEAOF) terminated its work.
 635  * Handle this. */
 636 void backgroundRewriteDoneHandler(int statloc) {
 637     int exitcode = WEXITSTATUS(statloc);
 638     int bysignal = WIFSIGNALED(statloc);
 639
 640     if (!bysignal && exitcode == 0) {
 641         int fd;
 642         char tmpfile[256];
 643
 644         redisLog(REDIS_NOTICE,
 645             "Background append only file rewriting terminated with success");
 646         /* Now it's time to flush the differences accumulated by the parent */
 647         snprintf(tmpfile,256,"temp-rewriteaof-bg-%d.aof", (int) server.bgrewritechildpid);
 648         fd = open(tmpfile,O_WRONLY|O_APPEND);
 649         if (fd == -1) {
 650             redisLog(REDIS_WARNING, "Not able to open the temp append only file produced by the child: %s", strerror(errno));
 651             goto cleanup;
 652         }
 653         /* Flush our data... */
 654         if (write(fd,server.bgrewritebuf,sdslen(server.bgrewritebuf)) !=
 655                 (signed) sdslen(server.bgrewritebuf)) {
 656             redisLog(REDIS_WARNING, "Error or short write trying to flush the parent diff of the append log file in the child temp file: %s", strerror(errno));
 657             close(fd);
 658             goto cleanup;
 659         }
 660         redisLog(REDIS_NOTICE,"Parent diff flushed into the new append log file with success (%lu bytes)",sdslen(server.bgrewritebuf));
 661         /* Now our work is to rename the temp file into the stable file. And
 662          * switch the file descriptor used by the server for append only. */
 663         if (rename(tmpfile,server.appendfilename) == -1) {
 664             redisLog(REDIS_WARNING,"Can't rename the temp append only file into the stable one: %s", strerror(errno));
 665             close(fd);
 666             goto cleanup;
 667         }
 668         /* Mission completed... almost */
 669         redisLog(REDIS_NOTICE,"Append only file successfully rewritten.");
 670         if (server.appendfd != -1) {
 671             /* If append only is actually enabled... */
 672             close(server.appendfd);
 673             server.appendfd = fd;
 674             if (server.appendfsync != APPENDFSYNC_NO) aof_fsync(fd);
 675             server.appendseldb = -1; /* Make sure it will issue SELECT */
 676             redisLog(REDIS_NOTICE,"The new append only file was selected for future appends.");
 677         } else {
 678             /* If append only is disabled we just generate a dump in this
 679              * format. Why not? */
 680             close(fd);
 681         }
 682     } else if (!bysignal && exitcode != 0) {
 683         redisLog(REDIS_WARNING, "Background append only file rewriting error");
 684     } else {
 685         redisLog(REDIS_WARNING,
 686             "Background append only file rewriting terminated by signal %d",
 687             WTERMSIG(statloc));
 688     }
 689 cleanup:
 690     sdsfree(server.bgrewritebuf);
 691     server.bgrewritebuf = sdsempty();
 692     aofRemoveTempFile(server.bgrewritechildpid);
 693     server.bgrewritechildpid = -1;
 694 }