/* Called when the user switches from "appendonly no" to "appendonly yes"
* at runtime using the CONFIG command. */
int startAppendOnly(void) {
- server.aof_last_fsync = time(NULL);
+ server.aof_last_fsync = server.unixtime;
server.aof_fd = open(server.aof_filename,O_WRONLY|O_APPEND|O_CREAT,0644);
redisAssert(server.aof_state == REDIS_AOF_OFF);
if (server.aof_fd == -1) {
* C-level DB API
*----------------------------------------------------------------------------*/
-/* Important notes on lookup and disk store.
- *
- * When disk store is enabled on lookup we can have different cases.
- *
- * a) The key is in memory:
- * - If the key is not in IO_SAVEINPROG state we can access it.
- * As if it's just IO_SAVE this means we have the key in the IO queue
- * but can't be accessed by the IO thread (it requires to be
- * translated into an IO Job by the cache cron function.)
- * - If the key is in IO_SAVEINPROG we can't touch the key and have
- * to blocking wait completion of operations.
- * b) The key is not in memory:
- * - If it's marked as non existing on disk as well (negative cache)
- * we don't need to perform the disk access.
- * - if the key MAY EXIST, but is not in memory, and it is marked as IO_SAVE
- * then the key can only be a deleted one. As IO_SAVE keys are never
- * evicted (dirty state), so the only possibility is that key was deleted.
- * - if the key MAY EXIST we need to blocking load it.
- * We check that the key is not in IO_SAVEINPROG state before accessing
- * the disk object. If it is in this state, we wait.
- */
-
robj *lookupKey(redisDb *db, robj *key) {
dictEntry *de = dictFind(db->dict,key->ptr);
if (de) {
}
}
-/* Empty the whole database.
- * If diskstore is enabled this function will just flush the in-memory cache. */
long long emptyDb() {
int j;
long long removed = 0;
* that is, 0 if we think the key should be still valid, 1 if
* we think the key is expired at this time. */
if (server.masterhost != NULL) {
- return time(NULL) > when;
+ return mstime() > when;
}
/* Return when this key has not expired */
}
/* Resize the table to the minimal size that contains all the elements,
- * but with the invariant of a USER/BUCKETS ratio near to <= 1 */
+ * but with the invariant of a USED/BUCKETS ratio near to <= 1 */
int dictResize(dict *d)
{
int minimal;
c->bulklen = -1;
c->sentlen = 0;
c->flags = 0;
- c->ctime = c->lastinteraction = time(NULL);
+ c->ctime = c->lastinteraction = server.unixtime;
c->authenticated = 0;
c->replstate = REDIS_REPL_NONE;
c->reply = listCreate();
if (c->flags & REDIS_MASTER) {
server.master = NULL;
server.repl_state = REDIS_REPL_CONNECT;
- server.repl_down_since = time(NULL);
+ server.repl_down_since = server.unixtime;
/* Since we lost the connection with the master, we should also
* close the connection with all our slaves if we have any, so
* when we'll resync with the master the other slaves will sync again
return;
}
}
- if (totwritten > 0) c->lastinteraction = time(NULL);
+ if (totwritten > 0) c->lastinteraction = server.unixtime;
if (c->bufpos == 0 && listLength(c->reply) == 0) {
c->sentlen = 0;
aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
}
if (nread) {
sdsIncrLen(c->querybuf,nread);
- c->lastinteraction = time(NULL);
+ c->lastinteraction = server.unixtime;
} else {
server.current_client = NULL;
return;
sds getClientInfoString(redisClient *client) {
char ip[32], flags[16], events[3], *p;
int port;
- time_t now = time(NULL);
int emask;
anetPeerToString(client->fd,ip,&port);
return sdscatprintf(sdsempty(),
"addr=%s:%d fd=%d age=%ld idle=%ld flags=%s db=%d sub=%d psub=%d qbuf=%lu qbuf-free=%lu obl=%lu oll=%lu omem=%lu events=%s cmd=%s",
ip,port,client->fd,
- (long)(now - client->ctime),
- (long)(now - client->lastinteraction),
+ (long)(server.unixtime - client->ctime),
+ (long)(server.unixtime - client->lastinteraction),
flags,
client->db->id,
(int) dictSize(client->pubsub_channels),
/* Ok, this object can be encoded...
*
- * Can I use a shared object? Only if the object is inside a given
- * range and if the back end in use is in-memory. For disk store every
- * object in memory used as value should be independent.
+ * Can I use a shared object? Only if the object is inside a given range
*
* Note that we also avoid using shared integers when maxmemory is used
* because every object needs to have a private LRU field for the LRU
}
void updateLRUClock(void) {
- server.lruclock = (time(NULL)/REDIS_LRU_CLOCK_RESOLUTION) &
+ server.lruclock = (server.unixtime/REDIS_LRU_CLOCK_RESOLUTION) &
REDIS_LRU_CLOCK_MAX;
}
updateDictResizePolicy();
}
} else {
- time_t now = time(NULL);
-
/* If there is not a background saving/rewrite in progress check if
* we have to save/rewrite now */
for (j = 0; j < server.saveparamslen; j++) {
struct saveparam *sp = server.saveparams+j;
if (server.dirty >= sp->changes &&
- now-server.lastsave > sp->seconds) {
+ server.unixtime-server.lastsave > sp->seconds) {
redisLog(REDIS_NOTICE,"%d changes in %d seconds. Saving...",
sp->changes, sp->seconds);
rdbSaveBackground(server.rdb_filename);
* on memory corruption problems. */
sds genRedisInfoString(char *section) {
sds info = sdsempty();
- time_t uptime = time(NULL)-server.stat_starttime;
+ time_t uptime = server.unixtime-server.stat_starttime;
int j, numcommands;
struct rusage self_ru, c_ru;
unsigned long lol, bib;
perc = ((double)server.loading_loaded_bytes /
server.loading_total_bytes) * 100;
- elapsed = time(NULL)-server.loading_start_time;
+ elapsed = server.unixtime-server.loading_start_time;
if (elapsed == 0) {
eta = 1; /* A fake 1 second figure if we don't have
enough info */
(server.repl_state == REDIS_REPL_CONNECTED) ?
"up" : "down",
server.master ?
- ((int)(time(NULL)-server.master->lastinteraction)) : -1,
+ ((int)(server.unixtime-server.master->lastinteraction)) : -1,
server.repl_state == REDIS_REPL_TRANSFER
);
"master_sync_left_bytes:%ld\r\n"
"master_sync_last_io_seconds_ago:%d\r\n"
,(long)server.repl_transfer_left,
- (int)(time(NULL)-server.repl_transfer_lastio)
+ (int)(server.unixtime-server.repl_transfer_lastio)
);
}
if (server.repl_state != REDIS_REPL_CONNECTED) {
info = sdscatprintf(info,
"master_link_down_since_seconds:%ld\r\n",
- (long)time(NULL)-server.repl_down_since);
+ (long)server.unixtime-server.repl_down_since);
}
}
info = sdscatprintf(info,
extern dictType clusterNodesDictType;
extern dictType dbDictType;
extern double R_Zero, R_PosInf, R_NegInf, R_Nan;
-dictType hashDictType;
+extern dictType hashDictType;
/*-----------------------------------------------------------------------------
* Functions prototypes
/* At this stage just a newline works as a PING in order to take
* the connection live. So we refresh our last interaction
* timestamp. */
- server.repl_transfer_lastio = time(NULL);
+ server.repl_transfer_lastio = server.unixtime;
return;
} else if (buf[0] != '$') {
redisLog(REDIS_WARNING,"Bad protocol from MASTER, the first byte is not '$', are you sure the host and port are right?");
replicationAbortSyncTransfer();
return;
}
- server.repl_transfer_lastio = time(NULL);
+ server.repl_transfer_lastio = server.unixtime;
if (write(server.repl_transfer_fd,buf,nread) != nread) {
redisLog(REDIS_WARNING,"Write error or short write writing to the DB dump file needed for MASTER <-> SLAVE synchrnonization: %s", strerror(errno));
goto error;
/* Prepare a suitable temp file for bulk transfer */
while(maxtries--) {
snprintf(tmpfile,256,
- "temp-%d.%ld.rdb",(int)time(NULL),(long int)getpid());
+ "temp-%d.%ld.rdb",(int)server.unixtime,(long int)getpid());
dfd = open(tmpfile,O_CREAT|O_WRONLY|O_EXCL,0644);
if (dfd != -1) break;
sleep(1);
server.repl_state = REDIS_REPL_TRANSFER;
server.repl_transfer_left = -1;
server.repl_transfer_fd = dfd;
- server.repl_transfer_lastio = time(NULL);
+ server.repl_transfer_lastio = server.unixtime;
server.repl_transfer_tmpfile = zstrdup(tmpfile);
return;
return REDIS_ERR;
}
- server.repl_transfer_lastio = time(NULL);
+ server.repl_transfer_lastio = server.unixtime;
server.repl_transfer_s = fd;
server.repl_state = REDIS_REPL_CONNECTING;
return REDIS_OK;
return REDIS_ERR;
}
- if (tval > 0) tval += time(NULL);
+ if (tval > 0) tval += server.unixtime;
*timeout = tval;
return REDIS_OK;
set buf [read $fd]
close $fd
- if {![regexp -- {ERROR SUMMARY: 0 errors} $buf] ||
+ if {[regexp -- { at 0x} $buf] ||
(![regexp -- {definitely lost: 0 bytes} $buf] &&
![regexp -- {no leaks are possible} $buf])} {
send_data_packet $::test_server_fd err "Valgrind error: $buf\n"
projects / redis.git / commitdiff
