Replace all usage of ziplist with listpack for t_hash (#8887)
Part one of implementing #8702 (taking hashes first before other types) ## Description of the feature 1. Change ziplist encoded hash objects to listpack encoding. 2. Convert existing ziplists on RDB loading time. an O(n) operation. ## Rdb format changes 1. Add RDB_TYPE_HASH_LISTPACK rdb type. 2. Bump RDB_VERSION to 10 ## Interface changes 1. New `hash-max-listpack-entries` config is an alias for `hash-max-ziplist-entries` (same with `hash-max-listpack-value`) 2. OBJECT ENCODING will return `listpack` instead of `ziplist` ## Listpack improvements: 1. Support direct insert, replace integer element (rather than convert back and forth from string) 3. Add more listpack capabilities to match the ziplist ones (like `lpFind`, `lpRandomPairs` and such) 4. Optimize element length fetching, avoid multiple calculations 5. Use inline to avoid function call overhead. ## Tests 1. Add a new test to the RDB load time conversion 2. Adding the listpack unit tests. (based on the one in ziplist.c) 3. Add a few "corrupt payload: fuzzer findings" tests, and slightly modify existing ones. Co-authored-by: Oran Agra <oran@redislabs.com>
This commit is contained in:
sundb
GitHub
parent
cbda492909
commit
02fd76b97c
@ -1704,8 +1704,8 @@ notify-keyspace-events ""
|
||||
# Hashes are encoded using a memory efficient data structure when they have a
|
||||
# small number of entries, and the biggest entry does not exceed a given
|
||||
# threshold. These thresholds can be configured using the following directives.
|
||||
hash-max-ziplist-entries 512
|
||||
hash-max-ziplist-value 64
|
||||
hash-max-listpack-entries 512
|
||||
hash-max-listpack-value 64
|
||||
|
||||
# Lists are also encoded in a special way to save a lot of space.
|
||||
# The number of entries allowed per internal list node can be specified
|
||||
|
||||
@ -1105,12 +1105,12 @@ int rewriteSortedSetObject(rio *r, robj *key, robj *o) {
|
||||
*
|
||||
* The function returns 0 on error, non-zero on success. */
|
||||
static int rioWriteHashIteratorCursor(rio *r, hashTypeIterator *hi, int what) {
|
||||
if (hi->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
if (hi->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
unsigned char *vstr = NULL;
|
||||
unsigned int vlen = UINT_MAX;
|
||||
long long vll = LLONG_MAX;
|
||||
|
||||
hashTypeCurrentFromZiplist(hi, what, &vstr, &vlen, &vll);
|
||||
hashTypeCurrentFromListpack(hi, what, &vstr, &vlen, &vll);
|
||||
if (vstr)
|
||||
return rioWriteBulkString(r, (char*)vstr, vlen);
|
||||
else
|
||||
|
||||
@ -2636,11 +2636,11 @@ standardConfig configs[] = {
|
||||
createULongLongConfig("maxmemory", NULL, MODIFIABLE_CONFIG, 0, ULLONG_MAX, server.maxmemory, 0, MEMORY_CONFIG, NULL, updateMaxmemory),
|
||||
|
||||
/* Size_t configs */
|
||||
createSizeTConfig("hash-max-ziplist-entries", NULL, MODIFIABLE_CONFIG, 0, LONG_MAX, server.hash_max_ziplist_entries, 512, INTEGER_CONFIG, NULL, NULL),
|
||||
createSizeTConfig("hash-max-listpack-entries", "hash-max-ziplist-entries", MODIFIABLE_CONFIG, 0, LONG_MAX, server.hash_max_listpack_entries, 512, INTEGER_CONFIG, NULL, NULL),
|
||||
createSizeTConfig("set-max-intset-entries", NULL, MODIFIABLE_CONFIG, 0, LONG_MAX, server.set_max_intset_entries, 512, INTEGER_CONFIG, NULL, NULL),
|
||||
createSizeTConfig("zset-max-ziplist-entries", NULL, MODIFIABLE_CONFIG, 0, LONG_MAX, server.zset_max_ziplist_entries, 128, INTEGER_CONFIG, NULL, NULL),
|
||||
createSizeTConfig("active-defrag-ignore-bytes", NULL, MODIFIABLE_CONFIG, 1, LLONG_MAX, server.active_defrag_ignore_bytes, 100<<20, MEMORY_CONFIG, NULL, NULL), /* Default: don't defrag if frag overhead is below 100mb */
|
||||
createSizeTConfig("hash-max-ziplist-value", NULL, MODIFIABLE_CONFIG, 0, LONG_MAX, server.hash_max_ziplist_value, 64, MEMORY_CONFIG, NULL, NULL),
|
||||
createSizeTConfig("hash-max-listpack-value", "hash-max-ziplist-value", MODIFIABLE_CONFIG, 0, LONG_MAX, server.hash_max_listpack_value, 64, MEMORY_CONFIG, NULL, NULL),
|
||||
createSizeTConfig("stream-node-max-bytes", NULL, MODIFIABLE_CONFIG, 0, LONG_MAX, server.stream_node_max_bytes, 4096, MEMORY_CONFIG, NULL, NULL),
|
||||
createSizeTConfig("zset-max-ziplist-value", NULL, MODIFIABLE_CONFIG, 0, LONG_MAX, server.zset_max_ziplist_value, 64, MEMORY_CONFIG, NULL, NULL),
|
||||
createSizeTConfig("hll-sparse-max-bytes", NULL, MODIFIABLE_CONFIG, 0, LONG_MAX, server.hll_sparse_max_bytes, 3000, MEMORY_CONFIG, NULL, NULL),
|
||||
|
||||
14
src/db.c
14
src/db.c
@ -935,7 +935,7 @@ void scanGenericCommand(client *c, robj *o, unsigned long cursor) {
|
||||
while(intsetGet(o->ptr,pos++,&ll))
|
||||
listAddNodeTail(keys,createStringObjectFromLongLong(ll));
|
||||
cursor = 0;
|
||||
} else if (o->type == OBJ_HASH || o->type == OBJ_ZSET) {
|
||||
} else if (o->type == OBJ_ZSET) {
|
||||
unsigned char *p = ziplistIndex(o->ptr,0);
|
||||
unsigned char *vstr;
|
||||
unsigned int vlen;
|
||||
@ -949,6 +949,18 @@ void scanGenericCommand(client *c, robj *o, unsigned long cursor) {
|
||||
p = ziplistNext(o->ptr,p);
|
||||
}
|
||||
cursor = 0;
|
||||
} else if (o->type == OBJ_HASH) {
|
||||
unsigned char *p = lpFirst(o->ptr);
|
||||
unsigned char *vstr;
|
||||
int64_t vlen;
|
||||
unsigned char intbuf[LP_INTBUF_SIZE];
|
||||
|
||||
while(p) {
|
||||
vstr = lpGet(p,&vlen,intbuf);
|
||||
listAddNodeTail(keys, createStringObject((char*)vstr,vlen));
|
||||
p = lpNext(o->ptr,p);
|
||||
}
|
||||
cursor = 0;
|
||||
} else {
|
||||
serverPanic("Not handled encoding in SCAN.");
|
||||
}
|
||||
|
||||
@ -864,7 +864,7 @@ long defragKey(redisDb *db, dictEntry *de) {
|
||||
serverPanic("Unknown sorted set encoding");
|
||||
}
|
||||
} else if (ob->type == OBJ_HASH) {
|
||||
if (ob->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
if (ob->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
if ((newzl = activeDefragAlloc(ob->ptr)))
|
||||
defragged++, ob->ptr = newzl;
|
||||
} else if (ob->encoding == OBJ_ENCODING_HT) {
|
||||
|
||||
1182
src/listpack.c
1182
src/listpack.c
File diff suppressed because it is too large
Load Diff
@ -45,22 +45,47 @@
|
||||
#define LP_AFTER 1
|
||||
#define LP_REPLACE 2
|
||||
|
||||
/* Each entry in the listpack is either a string or an integer. */
|
||||
typedef struct {
|
||||
/* When string is used, it is provided with the length (slen). */
|
||||
unsigned char *sval;
|
||||
uint32_t slen;
|
||||
/* When integer is used, 'sval' is NULL, and lval holds the value. */
|
||||
long long lval;
|
||||
} listpackEntry;
|
||||
|
||||
unsigned char *lpNew(size_t capacity);
|
||||
void lpFree(unsigned char *lp);
|
||||
unsigned char* lpShrinkToFit(unsigned char *lp);
|
||||
unsigned char *lpInsert(unsigned char *lp, unsigned char *ele, uint32_t size, unsigned char *p, int where, unsigned char **newp);
|
||||
unsigned char *lpAppend(unsigned char *lp, unsigned char *ele, uint32_t size);
|
||||
unsigned char *lpPrepend(unsigned char *lp, unsigned char *s, uint32_t slen);
|
||||
unsigned char *lpPrependInteger(unsigned char *lp, long long lval);
|
||||
unsigned char *lpAppend(unsigned char *lp, unsigned char *s, uint32_t slen);
|
||||
unsigned char *lpAppendInteger(unsigned char *lp, long long lval);
|
||||
unsigned char *lpReplace(unsigned char *lp, unsigned char **p, unsigned char *s, uint32_t slen);
|
||||
unsigned char *lpReplaceInteger(unsigned char *lp, unsigned char **p, long long lval);
|
||||
unsigned char *lpDelete(unsigned char *lp, unsigned char *p, unsigned char **newp);
|
||||
uint32_t lpLength(unsigned char *lp);
|
||||
unsigned long lpLength(unsigned char *lp);
|
||||
unsigned char *lpGet(unsigned char *p, int64_t *count, unsigned char *intbuf);
|
||||
unsigned char *lpGetValue(unsigned char *p, unsigned int *slen, long long *lval);
|
||||
unsigned char *lpFind(unsigned char *lp, unsigned char *p, unsigned char *s, uint32_t slen, unsigned int skip);
|
||||
unsigned char *lpFirst(unsigned char *lp);
|
||||
unsigned char *lpLast(unsigned char *lp);
|
||||
unsigned char *lpNext(unsigned char *lp, unsigned char *p);
|
||||
unsigned char *lpPrev(unsigned char *lp, unsigned char *p);
|
||||
uint32_t lpBytes(unsigned char *lp);
|
||||
size_t lpBytes(unsigned char *lp);
|
||||
unsigned char *lpSeek(unsigned char *lp, long index);
|
||||
int lpValidateIntegrity(unsigned char *lp, size_t size, int deep);
|
||||
typedef int (*listpackValidateEntryCB)(unsigned char *p, void *userdata);
|
||||
int lpValidateIntegrity(unsigned char *lp, size_t size, int deep,
|
||||
listpackValidateEntryCB entry_cb, void *cb_userdata);
|
||||
unsigned char *lpValidateFirst(unsigned char *lp);
|
||||
int lpValidateNext(unsigned char *lp, unsigned char **pp, size_t lpbytes);
|
||||
unsigned int lpCompare(unsigned char *p, unsigned char *s, uint32_t slen);
|
||||
void lpRandomPair(unsigned char *lp, unsigned long total_count, listpackEntry *key, listpackEntry *val);
|
||||
void lpRandomPairs(unsigned char *lp, unsigned int count, listpackEntry *keys, listpackEntry *vals);
|
||||
unsigned int lpRandomPairsUnique(unsigned char *lp, unsigned int count, listpackEntry *keys, listpackEntry *vals);
|
||||
|
||||
#ifdef REDIS_TEST
|
||||
int listpackTest(int argc, char *argv[], int accurate);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
21
src/module.c
21
src/module.c
@ -7990,7 +7990,7 @@ int RM_ScanKey(RedisModuleKey *key, RedisModuleScanCursor *cursor, RedisModuleSc
|
||||
cursor->cursor = 1;
|
||||
cursor->done = 1;
|
||||
ret = 0;
|
||||
} else if (o->type == OBJ_HASH || o->type == OBJ_ZSET) {
|
||||
} else if (o->type == OBJ_ZSET) {
|
||||
unsigned char *p = ziplistIndex(o->ptr,0);
|
||||
unsigned char *vstr;
|
||||
unsigned int vlen;
|
||||
@ -8013,6 +8013,25 @@ int RM_ScanKey(RedisModuleKey *key, RedisModuleScanCursor *cursor, RedisModuleSc
|
||||
cursor->cursor = 1;
|
||||
cursor->done = 1;
|
||||
ret = 0;
|
||||
} else if (o->type == OBJ_HASH) {
|
||||
unsigned char *p = lpFirst(o->ptr);
|
||||
unsigned char *vstr;
|
||||
int64_t vlen;
|
||||
unsigned char intbuf[LP_INTBUF_SIZE];
|
||||
while(p) {
|
||||
vstr = lpGet(p,&vlen,intbuf);
|
||||
robj *field = createStringObject((char*)vstr,vlen);
|
||||
p = lpNext(o->ptr,p);
|
||||
vstr = lpGet(p,&vlen,intbuf);
|
||||
robj *value = createStringObject((char*)vstr,vlen);
|
||||
fn(key, field, value, privdata);
|
||||
p = lpNext(o->ptr,p);
|
||||
decrRefCount(field);
|
||||
decrRefCount(value);
|
||||
}
|
||||
cursor->cursor = 1;
|
||||
cursor->done = 1;
|
||||
ret = 0;
|
||||
}
|
||||
errno = 0;
|
||||
return ret;
|
||||
|
||||
11
src/object.c
11
src/object.c
@ -255,9 +255,9 @@ robj *createIntsetObject(void) {
|
||||
}
|
||||
|
||||
robj *createHashObject(void) {
|
||||
unsigned char *zl = ziplistNew();
|
||||
unsigned char *zl = lpNew(0);
|
||||
robj *o = createObject(OBJ_HASH, zl);
|
||||
o->encoding = OBJ_ENCODING_ZIPLIST;
|
||||
o->encoding = OBJ_ENCODING_LISTPACK;
|
||||
return o;
|
||||
}
|
||||
|
||||
@ -342,8 +342,8 @@ void freeHashObject(robj *o) {
|
||||
case OBJ_ENCODING_HT:
|
||||
dictRelease((dict*) o->ptr);
|
||||
break;
|
||||
case OBJ_ENCODING_ZIPLIST:
|
||||
zfree(o->ptr);
|
||||
case OBJ_ENCODING_LISTPACK:
|
||||
lpFree(o->ptr);
|
||||
break;
|
||||
default:
|
||||
serverPanic("Unknown hash encoding type");
|
||||
@ -929,6 +929,7 @@ char *strEncoding(int encoding) {
|
||||
case OBJ_ENCODING_HT: return "hashtable";
|
||||
case OBJ_ENCODING_QUICKLIST: return "quicklist";
|
||||
case OBJ_ENCODING_ZIPLIST: return "ziplist";
|
||||
case OBJ_ENCODING_LISTPACK: return "listpack";
|
||||
case OBJ_ENCODING_INTSET: return "intset";
|
||||
case OBJ_ENCODING_SKIPLIST: return "skiplist";
|
||||
case OBJ_ENCODING_EMBSTR: return "embstr";
|
||||
@ -1038,7 +1039,7 @@ size_t objectComputeSize(robj *key, robj *o, size_t sample_size, int dbid) {
|
||||
serverPanic("Unknown sorted set encoding");
|
||||
}
|
||||
} else if (o->type == OBJ_HASH) {
|
||||
if (o->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
if (o->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
asize = sizeof(*o)+zmalloc_size(o->ptr);
|
||||
} else if (o->encoding == OBJ_ENCODING_HT) {
|
||||
d = o->ptr;
|
||||
|
||||
76
src/rdb.c
76
src/rdb.c
@ -676,8 +676,8 @@ int rdbSaveObjectType(rio *rdb, robj *o) {
|
||||
else
|
||||
serverPanic("Unknown sorted set encoding");
|
||||
case OBJ_HASH:
|
||||
if (o->encoding == OBJ_ENCODING_ZIPLIST)
|
||||
return rdbSaveType(rdb,RDB_TYPE_HASH_ZIPLIST);
|
||||
if (o->encoding == OBJ_ENCODING_LISTPACK)
|
||||
return rdbSaveType(rdb,RDB_TYPE_HASH_LISTPACK);
|
||||
else if (o->encoding == OBJ_ENCODING_HT)
|
||||
return rdbSaveType(rdb,RDB_TYPE_HASH);
|
||||
else
|
||||
@ -897,12 +897,11 @@ ssize_t rdbSaveObject(rio *rdb, robj *o, robj *key, int dbid) {
|
||||
}
|
||||
} else if (o->type == OBJ_HASH) {
|
||||
/* Save a hash value */
|
||||
if (o->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
size_t l = ziplistBlobLen((unsigned char*)o->ptr);
|
||||
if (o->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
size_t l = lpBytes((unsigned char*)o->ptr);
|
||||
|
||||
if ((n = rdbSaveRawString(rdb,o->ptr,l)) == -1) return -1;
|
||||
nwritten += n;
|
||||
|
||||
} else if (o->encoding == OBJ_ENCODING_HT) {
|
||||
dictIterator *di = dictGetIterator(o->ptr);
|
||||
dictEntry *de;
|
||||
@ -1703,7 +1702,7 @@ robj *rdbLoadObject(int rdbtype, rio *rdb, sds key, int dbid, int *error) {
|
||||
o = createHashObject();
|
||||
|
||||
/* Too many entries? Use a hash table right from the start. */
|
||||
if (len > server.hash_max_ziplist_entries)
|
||||
if (len > server.hash_max_listpack_entries)
|
||||
hashTypeConvert(o, OBJ_ENCODING_HT);
|
||||
else if (deep_integrity_validation) {
|
||||
/* In this mode, we need to guarantee that the server won't crash
|
||||
@ -1715,7 +1714,7 @@ robj *rdbLoadObject(int rdbtype, rio *rdb, sds key, int dbid, int *error) {
|
||||
|
||||
|
||||
/* Load every field and value into the ziplist */
|
||||
while (o->encoding == OBJ_ENCODING_ZIPLIST && len > 0) {
|
||||
while (o->encoding == OBJ_ENCODING_LISTPACK && len > 0) {
|
||||
len--;
|
||||
/* Load raw strings */
|
||||
if ((field = rdbGenericLoadStringObject(rdb,RDB_LOAD_SDS,NULL)) == NULL) {
|
||||
@ -1743,15 +1742,13 @@ robj *rdbLoadObject(int rdbtype, rio *rdb, sds key, int dbid, int *error) {
|
||||
}
|
||||
}
|
||||
|
||||
/* Add pair to ziplist */
|
||||
o->ptr = ziplistPush(o->ptr, (unsigned char*)field,
|
||||
sdslen(field), ZIPLIST_TAIL);
|
||||
o->ptr = ziplistPush(o->ptr, (unsigned char*)value,
|
||||
sdslen(value), ZIPLIST_TAIL);
|
||||
/* Add pair to listpack */
|
||||
o->ptr = lpAppend(o->ptr, (unsigned char*)field, sdslen(field));
|
||||
o->ptr = lpAppend(o->ptr, (unsigned char*)value, sdslen(value));
|
||||
|
||||
/* Convert to hash table if size threshold is exceeded */
|
||||
if (sdslen(field) > server.hash_max_ziplist_value ||
|
||||
sdslen(value) > server.hash_max_ziplist_value)
|
||||
if (sdslen(field) > server.hash_max_listpack_value ||
|
||||
sdslen(value) > server.hash_max_listpack_value)
|
||||
{
|
||||
sdsfree(field);
|
||||
sdsfree(value);
|
||||
@ -1845,7 +1842,8 @@ robj *rdbLoadObject(int rdbtype, rio *rdb, sds key, int dbid, int *error) {
|
||||
rdbtype == RDB_TYPE_LIST_ZIPLIST ||
|
||||
rdbtype == RDB_TYPE_SET_INTSET ||
|
||||
rdbtype == RDB_TYPE_ZSET_ZIPLIST ||
|
||||
rdbtype == RDB_TYPE_HASH_ZIPLIST)
|
||||
rdbtype == RDB_TYPE_HASH_ZIPLIST ||
|
||||
rdbtype == RDB_TYPE_HASH_LISTPACK)
|
||||
{
|
||||
size_t encoded_len;
|
||||
unsigned char *encoded =
|
||||
@ -1874,7 +1872,7 @@ robj *rdbLoadObject(int rdbtype, rio *rdb, sds key, int dbid, int *error) {
|
||||
/* Convert to ziplist encoded hash. This must be deprecated
|
||||
* when loading dumps created by Redis 2.4 gets deprecated. */
|
||||
{
|
||||
unsigned char *zl = ziplistNew();
|
||||
unsigned char *zl = lpNew(0);
|
||||
unsigned char *zi = zipmapRewind(o->ptr);
|
||||
unsigned char *fstr, *vstr;
|
||||
unsigned int flen, vlen;
|
||||
@ -1884,8 +1882,8 @@ robj *rdbLoadObject(int rdbtype, rio *rdb, sds key, int dbid, int *error) {
|
||||
while ((zi = zipmapNext(zi, &fstr, &flen, &vstr, &vlen)) != NULL) {
|
||||
if (flen > maxlen) maxlen = flen;
|
||||
if (vlen > maxlen) maxlen = vlen;
|
||||
zl = ziplistPush(zl, fstr, flen, ZIPLIST_TAIL);
|
||||
zl = ziplistPush(zl, vstr, vlen, ZIPLIST_TAIL);
|
||||
zl = lpAppend(zl, fstr, flen);
|
||||
zl = lpAppend(zl, vstr, vlen);
|
||||
|
||||
/* search for duplicate records */
|
||||
sds field = sdstrynewlen(fstr, flen);
|
||||
@ -1904,10 +1902,10 @@ robj *rdbLoadObject(int rdbtype, rio *rdb, sds key, int dbid, int *error) {
|
||||
zfree(o->ptr);
|
||||
o->ptr = zl;
|
||||
o->type = OBJ_HASH;
|
||||
o->encoding = OBJ_ENCODING_ZIPLIST;
|
||||
o->encoding = OBJ_ENCODING_LISTPACK;
|
||||
|
||||
if (hashTypeLength(o) > server.hash_max_ziplist_entries ||
|
||||
maxlen > server.hash_max_ziplist_value)
|
||||
if (hashTypeLength(o) > server.hash_max_listpack_entries ||
|
||||
maxlen > server.hash_max_listpack_value)
|
||||
{
|
||||
hashTypeConvert(o, OBJ_ENCODING_HT);
|
||||
}
|
||||
@ -1970,16 +1968,44 @@ robj *rdbLoadObject(int rdbtype, rio *rdb, sds key, int dbid, int *error) {
|
||||
zsetConvert(o,OBJ_ENCODING_SKIPLIST);
|
||||
break;
|
||||
case RDB_TYPE_HASH_ZIPLIST:
|
||||
{
|
||||
unsigned char *lp = lpNew(encoded_len);
|
||||
if (!hashZiplistConvertAndValidateIntegrity(encoded, encoded_len, &lp)) {
|
||||
rdbReportCorruptRDB("Hash ziplist integrity check failed.");
|
||||
zfree(lp);
|
||||
zfree(encoded);
|
||||
o->ptr = NULL;
|
||||
decrRefCount(o);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
zfree(o->ptr);
|
||||
o->ptr = lp;
|
||||
o->type = OBJ_HASH;
|
||||
o->encoding = OBJ_ENCODING_LISTPACK;
|
||||
if (hashTypeLength(o) == 0) {
|
||||
zfree(o->ptr);
|
||||
o->ptr = NULL;
|
||||
decrRefCount(o);
|
||||
goto emptykey;
|
||||
}
|
||||
|
||||
if (hashTypeLength(o) > server.hash_max_listpack_entries) {
|
||||
hashTypeConvert(o, OBJ_ENCODING_HT);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case RDB_TYPE_HASH_LISTPACK:
|
||||
if (deep_integrity_validation) server.stat_dump_payload_sanitizations++;
|
||||
if (!hashZiplistValidateIntegrity(encoded, encoded_len, deep_integrity_validation)) {
|
||||
rdbReportCorruptRDB("Hash ziplist integrity check failed.");
|
||||
if (!hashListpackValidateIntegrity(encoded, encoded_len, deep_integrity_validation)) {
|
||||
rdbReportCorruptRDB("Hash listpack integrity check failed.");
|
||||
zfree(encoded);
|
||||
o->ptr = NULL;
|
||||
decrRefCount(o);
|
||||
return NULL;
|
||||
}
|
||||
o->type = OBJ_HASH;
|
||||
o->encoding = OBJ_ENCODING_ZIPLIST;
|
||||
o->encoding = OBJ_ENCODING_LISTPACK;
|
||||
if (hashTypeLength(o) == 0) {
|
||||
zfree(encoded);
|
||||
o->ptr = NULL;
|
||||
@ -1987,7 +2013,7 @@ robj *rdbLoadObject(int rdbtype, rio *rdb, sds key, int dbid, int *error) {
|
||||
goto emptykey;
|
||||
}
|
||||
|
||||
if (hashTypeLength(o) > server.hash_max_ziplist_entries)
|
||||
if (hashTypeLength(o) > server.hash_max_listpack_entries)
|
||||
hashTypeConvert(o, OBJ_ENCODING_HT);
|
||||
break;
|
||||
default:
|
||||
|
||||
@ -38,7 +38,7 @@
|
||||
|
||||
/* The current RDB version. When the format changes in a way that is no longer
|
||||
* backward compatible this number gets incremented. */
|
||||
#define RDB_VERSION 9
|
||||
#define RDB_VERSION 10
|
||||
|
||||
/* Defines related to the dump file format. To store 32 bits lengths for short
|
||||
* keys requires a lot of space, so we check the most significant 2 bits of
|
||||
@ -91,10 +91,11 @@
|
||||
#define RDB_TYPE_HASH_ZIPLIST 13
|
||||
#define RDB_TYPE_LIST_QUICKLIST 14
|
||||
#define RDB_TYPE_STREAM_LISTPACKS 15
|
||||
#define RDB_TYPE_HASH_LISTPACK 16
|
||||
/* NOTE: WHEN ADDING NEW RDB TYPE, UPDATE rdbIsObjectType() BELOW */
|
||||
|
||||
/* Test if a type is an object type. */
|
||||
#define rdbIsObjectType(t) ((t >= 0 && t <= 7) || (t >= 9 && t <= 15))
|
||||
#define rdbIsObjectType(t) ((t >= 0 && t <= 7) || (t >= 9 && t <= 16))
|
||||
|
||||
/* Special RDB opcodes (saved/loaded with rdbSaveType/rdbLoadType). */
|
||||
#define RDB_OPCODE_MODULE_AUX 247 /* Module auxiliary data. */
|
||||
|
||||
@ -90,7 +90,8 @@ char *rdb_type_string[] = {
|
||||
"zset-ziplist",
|
||||
"hash-ziplist",
|
||||
"quicklist",
|
||||
"stream"
|
||||
"stream",
|
||||
"hash-listpack"
|
||||
};
|
||||
|
||||
/* Show a few stats collected into 'rdbstate' */
|
||||
|
||||
@ -6241,7 +6241,8 @@ struct redisTest {
|
||||
{"crc64", crc64Test},
|
||||
{"zmalloc", zmalloc_test},
|
||||
{"sds", sdsTest},
|
||||
{"dict", dictTest}
|
||||
{"dict", dictTest},
|
||||
{"listpack", listpackTest}
|
||||
};
|
||||
redisTestProc *getTestProcByName(const char *name) {
|
||||
int numtests = sizeof(redisTests)/sizeof(struct redisTest);
|
||||
|
||||
16
src/server.h
16
src/server.h
@ -707,6 +707,7 @@ typedef struct RedisModuleDigest {
|
||||
#define OBJ_ENCODING_EMBSTR 8 /* Embedded sds string encoding */
|
||||
#define OBJ_ENCODING_QUICKLIST 9 /* Encoded as linked list of ziplists */
|
||||
#define OBJ_ENCODING_STREAM 10 /* Encoded as a radix tree of listpacks */
|
||||
#define OBJ_ENCODING_LISTPACK 11 /* Encoded as a listpack */
|
||||
|
||||
#define LRU_BITS 24
|
||||
#define LRU_CLOCK_MAX ((1<<LRU_BITS)-1) /* Max value of obj->lru */
|
||||
@ -1569,8 +1570,8 @@ struct redisServer {
|
||||
int sort_bypattern;
|
||||
int sort_store;
|
||||
/* Zip structure config, see redis.conf for more information */
|
||||
size_t hash_max_ziplist_entries;
|
||||
size_t hash_max_ziplist_value;
|
||||
size_t hash_max_listpack_entries;
|
||||
size_t hash_max_listpack_value;
|
||||
size_t set_max_intset_entries;
|
||||
size_t zset_max_ziplist_entries;
|
||||
size_t zset_max_ziplist_value;
|
||||
@ -2341,10 +2342,10 @@ unsigned long hashTypeLength(const robj *o);
|
||||
hashTypeIterator *hashTypeInitIterator(robj *subject);
|
||||
void hashTypeReleaseIterator(hashTypeIterator *hi);
|
||||
int hashTypeNext(hashTypeIterator *hi);
|
||||
void hashTypeCurrentFromZiplist(hashTypeIterator *hi, int what,
|
||||
unsigned char **vstr,
|
||||
unsigned int *vlen,
|
||||
long long *vll);
|
||||
void hashTypeCurrentFromListpack(hashTypeIterator *hi, int what,
|
||||
unsigned char **vstr,
|
||||
unsigned int *vlen,
|
||||
long long *vll);
|
||||
sds hashTypeCurrentFromHashTable(hashTypeIterator *hi, int what);
|
||||
void hashTypeCurrentObject(hashTypeIterator *hi, int what, unsigned char **vstr, unsigned int *vlen, long long *vll);
|
||||
sds hashTypeCurrentObjectNewSds(hashTypeIterator *hi, int what);
|
||||
@ -2352,7 +2353,8 @@ robj *hashTypeLookupWriteOrCreate(client *c, robj *key);
|
||||
robj *hashTypeGetValueObject(robj *o, sds field);
|
||||
int hashTypeSet(robj *o, sds field, sds value, int flags);
|
||||
robj *hashTypeDup(robj *o);
|
||||
int hashZiplistValidateIntegrity(unsigned char *zl, size_t size, int deep);
|
||||
int hashZiplistConvertAndValidateIntegrity(unsigned char *zl, size_t size, unsigned char **lp);
|
||||
int hashListpackValidateIntegrity(unsigned char *lp, size_t size, int deep);
|
||||
|
||||
/* Pub / Sub */
|
||||
int pubsubUnsubscribeAllChannels(client *c, int notify);
|
||||
|
||||
288
src/t_hash.c
288
src/t_hash.c
@ -35,16 +35,16 @@
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
/* Check the length of a number of objects to see if we need to convert a
|
||||
* ziplist to a real hash. Note that we only check string encoded objects
|
||||
* listpack to a real hash. Note that we only check string encoded objects
|
||||
* as their string length can be queried in constant time. */
|
||||
void hashTypeTryConversion(robj *o, robj **argv, int start, int end) {
|
||||
int i;
|
||||
|
||||
if (o->encoding != OBJ_ENCODING_ZIPLIST) return;
|
||||
if (o->encoding != OBJ_ENCODING_LISTPACK) return;
|
||||
|
||||
for (i = start; i <= end; i++) {
|
||||
if (sdsEncodedObject(argv[i]) &&
|
||||
sdslen(argv[i]->ptr) > server.hash_max_ziplist_value)
|
||||
sdslen(argv[i]->ptr) > server.hash_max_listpack_value)
|
||||
{
|
||||
hashTypeConvert(o, OBJ_ENCODING_HT);
|
||||
break;
|
||||
@ -52,32 +52,30 @@ void hashTypeTryConversion(robj *o, robj **argv, int start, int end) {
|
||||
}
|
||||
}
|
||||
|
||||
/* Get the value from a ziplist encoded hash, identified by field.
|
||||
/* Get the value from a listpack encoded hash, identified by field.
|
||||
* Returns -1 when the field cannot be found. */
|
||||
int hashTypeGetFromZiplist(robj *o, sds field,
|
||||
unsigned char **vstr,
|
||||
unsigned int *vlen,
|
||||
long long *vll)
|
||||
int hashTypeGetFromListpack(robj *o, sds field,
|
||||
unsigned char **vstr,
|
||||
unsigned int *vlen,
|
||||
long long *vll)
|
||||
{
|
||||
unsigned char *zl, *fptr = NULL, *vptr = NULL;
|
||||
int ret;
|
||||
|
||||
serverAssert(o->encoding == OBJ_ENCODING_ZIPLIST);
|
||||
serverAssert(o->encoding == OBJ_ENCODING_LISTPACK);
|
||||
|
||||
zl = o->ptr;
|
||||
fptr = ziplistIndex(zl, ZIPLIST_HEAD);
|
||||
fptr = lpFirst(zl);
|
||||
if (fptr != NULL) {
|
||||
fptr = ziplistFind(zl, fptr, (unsigned char*)field, sdslen(field), 1);
|
||||
fptr = lpFind(zl, fptr, (unsigned char*)field, sdslen(field), 1);
|
||||
if (fptr != NULL) {
|
||||
/* Grab pointer to the value (fptr points to the field) */
|
||||
vptr = ziplistNext(zl, fptr);
|
||||
vptr = lpNext(zl, fptr);
|
||||
serverAssert(vptr != NULL);
|
||||
}
|
||||
}
|
||||
|
||||
if (vptr != NULL) {
|
||||
ret = ziplistGet(vptr, vstr, vlen, vll);
|
||||
serverAssert(ret);
|
||||
*vstr = lpGetValue(vptr, vlen, vll);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -107,9 +105,9 @@ sds hashTypeGetFromHashTable(robj *o, sds field) {
|
||||
* can always check the function return by checking the return value
|
||||
* for C_OK and checking if vll (or vstr) is NULL. */
|
||||
int hashTypeGetValue(robj *o, sds field, unsigned char **vstr, unsigned int *vlen, long long *vll) {
|
||||
if (o->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
if (o->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
*vstr = NULL;
|
||||
if (hashTypeGetFromZiplist(o, field, vstr, vlen, vll) == 0)
|
||||
if (hashTypeGetFromListpack(o, field, vstr, vlen, vll) == 0)
|
||||
return C_OK;
|
||||
} else if (o->encoding == OBJ_ENCODING_HT) {
|
||||
sds value;
|
||||
@ -143,12 +141,12 @@ robj *hashTypeGetValueObject(robj *o, sds field) {
|
||||
* exist. */
|
||||
size_t hashTypeGetValueLength(robj *o, sds field) {
|
||||
size_t len = 0;
|
||||
if (o->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
if (o->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
unsigned char *vstr = NULL;
|
||||
unsigned int vlen = UINT_MAX;
|
||||
long long vll = LLONG_MAX;
|
||||
|
||||
if (hashTypeGetFromZiplist(o, field, &vstr, &vlen, &vll) == 0)
|
||||
if (hashTypeGetFromListpack(o, field, &vstr, &vlen, &vll) == 0)
|
||||
len = vstr ? vlen : sdigits10(vll);
|
||||
} else if (o->encoding == OBJ_ENCODING_HT) {
|
||||
sds aux;
|
||||
@ -164,12 +162,12 @@ size_t hashTypeGetValueLength(robj *o, sds field) {
|
||||
/* Test if the specified field exists in the given hash. Returns 1 if the field
|
||||
* exists, and 0 when it doesn't. */
|
||||
int hashTypeExists(robj *o, sds field) {
|
||||
if (o->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
if (o->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
unsigned char *vstr = NULL;
|
||||
unsigned int vlen = UINT_MAX;
|
||||
long long vll = LLONG_MAX;
|
||||
|
||||
if (hashTypeGetFromZiplist(o, field, &vstr, &vlen, &vll) == 0) return 1;
|
||||
if (hashTypeGetFromListpack(o, field, &vstr, &vlen, &vll) == 0) return 1;
|
||||
} else if (o->encoding == OBJ_ENCODING_HT) {
|
||||
if (hashTypeGetFromHashTable(o, field) != NULL) return 1;
|
||||
} else {
|
||||
@ -202,36 +200,33 @@ int hashTypeExists(robj *o, sds field) {
|
||||
int hashTypeSet(robj *o, sds field, sds value, int flags) {
|
||||
int update = 0;
|
||||
|
||||
if (o->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
if (o->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
unsigned char *zl, *fptr, *vptr;
|
||||
|
||||
zl = o->ptr;
|
||||
fptr = ziplistIndex(zl, ZIPLIST_HEAD);
|
||||
fptr = lpFirst(zl);
|
||||
if (fptr != NULL) {
|
||||
fptr = ziplistFind(zl, fptr, (unsigned char*)field, sdslen(field), 1);
|
||||
fptr = lpFind(zl, fptr, (unsigned char*)field, sdslen(field), 1);
|
||||
if (fptr != NULL) {
|
||||
/* Grab pointer to the value (fptr points to the field) */
|
||||
vptr = ziplistNext(zl, fptr);
|
||||
vptr = lpNext(zl, fptr);
|
||||
serverAssert(vptr != NULL);
|
||||
update = 1;
|
||||
|
||||
/* Replace value */
|
||||
zl = ziplistReplace(zl, vptr, (unsigned char*)value,
|
||||
sdslen(value));
|
||||
zl = lpReplace(zl, &vptr, (unsigned char*)value, sdslen(value));
|
||||
}
|
||||
}
|
||||
|
||||
if (!update) {
|
||||
/* Push new field/value pair onto the tail of the ziplist */
|
||||
zl = ziplistPush(zl, (unsigned char*)field, sdslen(field),
|
||||
ZIPLIST_TAIL);
|
||||
zl = ziplistPush(zl, (unsigned char*)value, sdslen(value),
|
||||
ZIPLIST_TAIL);
|
||||
/* Push new field/value pair onto the tail of the listpack */
|
||||
zl = lpAppend(zl, (unsigned char*)field, sdslen(field));
|
||||
zl = lpAppend(zl, (unsigned char*)value, sdslen(value));
|
||||
}
|
||||
o->ptr = zl;
|
||||
|
||||
/* Check if the ziplist needs to be converted to a hash table */
|
||||
if (hashTypeLength(o) > server.hash_max_ziplist_entries)
|
||||
/* Check if the listpack needs to be converted to a hash table */
|
||||
if (hashTypeLength(o) > server.hash_max_listpack_entries)
|
||||
hashTypeConvert(o, OBJ_ENCODING_HT);
|
||||
} else if (o->encoding == OBJ_ENCODING_HT) {
|
||||
dictEntry *de = dictFind(o->ptr,field);
|
||||
@ -276,16 +271,16 @@ int hashTypeSet(robj *o, sds field, sds value, int flags) {
|
||||
int hashTypeDelete(robj *o, sds field) {
|
||||
int deleted = 0;
|
||||
|
||||
if (o->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
if (o->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
unsigned char *zl, *fptr;
|
||||
|
||||
zl = o->ptr;
|
||||
fptr = ziplistIndex(zl, ZIPLIST_HEAD);
|
||||
fptr = lpFirst(zl);
|
||||
if (fptr != NULL) {
|
||||
fptr = ziplistFind(zl, fptr, (unsigned char*)field, sdslen(field), 1);
|
||||
fptr = lpFind(zl, fptr, (unsigned char*)field, sdslen(field), 1);
|
||||
if (fptr != NULL) {
|
||||
zl = ziplistDelete(zl,&fptr); /* Delete the key. */
|
||||
zl = ziplistDelete(zl,&fptr); /* Delete the value. */
|
||||
zl = lpDelete(zl,fptr,&fptr); /* Delete the key. */
|
||||
zl = lpDelete(zl,fptr,&fptr); /* Delete the value. */
|
||||
o->ptr = zl;
|
||||
deleted = 1;
|
||||
}
|
||||
@ -308,8 +303,8 @@ int hashTypeDelete(robj *o, sds field) {
|
||||
unsigned long hashTypeLength(const robj *o) {
|
||||
unsigned long length = ULONG_MAX;
|
||||
|
||||
if (o->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
length = ziplistLen(o->ptr) / 2;
|
||||
if (o->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
length = lpLength(o->ptr) / 2;
|
||||
} else if (o->encoding == OBJ_ENCODING_HT) {
|
||||
length = dictSize((const dict*)o->ptr);
|
||||
} else {
|
||||
@ -323,7 +318,7 @@ hashTypeIterator *hashTypeInitIterator(robj *subject) {
|
||||
hi->subject = subject;
|
||||
hi->encoding = subject->encoding;
|
||||
|
||||
if (hi->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
if (hi->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
hi->fptr = NULL;
|
||||
hi->vptr = NULL;
|
||||
} else if (hi->encoding == OBJ_ENCODING_HT) {
|
||||
@ -343,7 +338,7 @@ void hashTypeReleaseIterator(hashTypeIterator *hi) {
|
||||
/* Move to the next entry in the hash. Return C_OK when the next entry
|
||||
* could be found and C_ERR when the iterator reaches the end. */
|
||||
int hashTypeNext(hashTypeIterator *hi) {
|
||||
if (hi->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
if (hi->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
unsigned char *zl;
|
||||
unsigned char *fptr, *vptr;
|
||||
|
||||
@ -354,16 +349,16 @@ int hashTypeNext(hashTypeIterator *hi) {
|
||||
if (fptr == NULL) {
|
||||
/* Initialize cursor */
|
||||
serverAssert(vptr == NULL);
|
||||
fptr = ziplistIndex(zl, 0);
|
||||
fptr = lpFirst(zl);
|
||||
} else {
|
||||
/* Advance cursor */
|
||||
serverAssert(vptr != NULL);
|
||||
fptr = ziplistNext(zl, vptr);
|
||||
fptr = lpNext(zl, vptr);
|
||||
}
|
||||
if (fptr == NULL) return C_ERR;
|
||||
|
||||
/* Grab pointer to the value (fptr points to the field) */
|
||||
vptr = ziplistNext(zl, fptr);
|
||||
vptr = lpNext(zl, fptr);
|
||||
serverAssert(vptr != NULL);
|
||||
|
||||
/* fptr, vptr now point to the first or next pair */
|
||||
@ -378,22 +373,18 @@ int hashTypeNext(hashTypeIterator *hi) {
|
||||
}
|
||||
|
||||
/* Get the field or value at iterator cursor, for an iterator on a hash value
|
||||
* encoded as a ziplist. Prototype is similar to `hashTypeGetFromZiplist`. */
|
||||
void hashTypeCurrentFromZiplist(hashTypeIterator *hi, int what,
|
||||
unsigned char **vstr,
|
||||
unsigned int *vlen,
|
||||
long long *vll)
|
||||
* encoded as a listpack. Prototype is similar to `hashTypeGetFromListpack`. */
|
||||
void hashTypeCurrentFromListpack(hashTypeIterator *hi, int what,
|
||||
unsigned char **vstr,
|
||||
unsigned int *vlen,
|
||||
long long *vll)
|
||||
{
|
||||
int ret;
|
||||
|
||||
serverAssert(hi->encoding == OBJ_ENCODING_ZIPLIST);
|
||||
serverAssert(hi->encoding == OBJ_ENCODING_LISTPACK);
|
||||
|
||||
if (what & OBJ_HASH_KEY) {
|
||||
ret = ziplistGet(hi->fptr, vstr, vlen, vll);
|
||||
serverAssert(ret);
|
||||
*vstr = lpGetValue(hi->fptr, vlen, vll);
|
||||
} else {
|
||||
ret = ziplistGet(hi->vptr, vstr, vlen, vll);
|
||||
serverAssert(ret);
|
||||
*vstr = lpGetValue(hi->vptr, vlen, vll);
|
||||
}
|
||||
}
|
||||
|
||||
@ -421,9 +412,9 @@ sds hashTypeCurrentFromHashTable(hashTypeIterator *hi, int what) {
|
||||
* can always check the function return by checking the return value
|
||||
* type checking if vstr == NULL. */
|
||||
void hashTypeCurrentObject(hashTypeIterator *hi, int what, unsigned char **vstr, unsigned int *vlen, long long *vll) {
|
||||
if (hi->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
if (hi->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
*vstr = NULL;
|
||||
hashTypeCurrentFromZiplist(hi, what, vstr, vlen, vll);
|
||||
hashTypeCurrentFromListpack(hi, what, vstr, vlen, vll);
|
||||
} else if (hi->encoding == OBJ_ENCODING_HT) {
|
||||
sds ele = hashTypeCurrentFromHashTable(hi, what);
|
||||
*vstr = (unsigned char*) ele;
|
||||
@ -456,10 +447,11 @@ robj *hashTypeLookupWriteOrCreate(client *c, robj *key) {
|
||||
return o;
|
||||
}
|
||||
|
||||
void hashTypeConvertZiplist(robj *o, int enc) {
|
||||
serverAssert(o->encoding == OBJ_ENCODING_ZIPLIST);
|
||||
|
||||
if (enc == OBJ_ENCODING_ZIPLIST) {
|
||||
void hashTypeConvertListpack(robj *o, int enc) {
|
||||
serverAssert(o->encoding == OBJ_ENCODING_LISTPACK);
|
||||
|
||||
if (enc == OBJ_ENCODING_LISTPACK) {
|
||||
/* Nothing to do... */
|
||||
|
||||
} else if (enc == OBJ_ENCODING_HT) {
|
||||
@ -480,9 +472,9 @@ void hashTypeConvertZiplist(robj *o, int enc) {
|
||||
value = hashTypeCurrentObjectNewSds(hi,OBJ_HASH_VALUE);
|
||||
ret = dictAdd(dict, key, value);
|
||||
if (ret != DICT_OK) {
|
||||
serverLogHexDump(LL_WARNING,"ziplist with dup elements dump",
|
||||
o->ptr,ziplistBlobLen(o->ptr));
|
||||
serverPanic("Ziplist corruption detected");
|
||||
serverLogHexDump(LL_WARNING,"listpack with dup elements dump",
|
||||
o->ptr,lpBytes(o->ptr));
|
||||
serverPanic("Listpack corruption detected");
|
||||
}
|
||||
}
|
||||
hashTypeReleaseIterator(hi);
|
||||
@ -495,8 +487,8 @@ void hashTypeConvertZiplist(robj *o, int enc) {
|
||||
}
|
||||
|
||||
void hashTypeConvert(robj *o, int enc) {
|
||||
if (o->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
hashTypeConvertZiplist(o, enc);
|
||||
if (o->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
hashTypeConvertListpack(o, enc);
|
||||
} else if (o->encoding == OBJ_ENCODING_HT) {
|
||||
serverPanic("Not implemented");
|
||||
} else {
|
||||
@ -515,13 +507,13 @@ robj *hashTypeDup(robj *o) {
|
||||
|
||||
serverAssert(o->type == OBJ_HASH);
|
||||
|
||||
if(o->encoding == OBJ_ENCODING_ZIPLIST){
|
||||
if(o->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
unsigned char *zl = o->ptr;
|
||||
size_t sz = ziplistBlobLen(zl);
|
||||
size_t sz = lpBytes(zl);
|
||||
unsigned char *new_zl = zmalloc(sz);
|
||||
memcpy(new_zl, zl, sz);
|
||||
hobj = createObject(OBJ_HASH, new_zl);
|
||||
hobj->encoding = OBJ_ENCODING_ZIPLIST;
|
||||
hobj->encoding = OBJ_ENCODING_LISTPACK;
|
||||
} else if(o->encoding == OBJ_ENCODING_HT){
|
||||
dict *d = dictCreate(&hashDictType);
|
||||
dictExpand(d, dictSize((const dict*)o->ptr));
|
||||
@ -549,8 +541,45 @@ robj *hashTypeDup(robj *o) {
|
||||
return hobj;
|
||||
}
|
||||
|
||||
/* callback for to check the ziplist doesn't have duplicate records */
|
||||
static int _hashZiplistEntryValidation(unsigned char *p, void *userdata) {
|
||||
/* callback for hashZiplistConvertAndValidateIntegrity.
|
||||
* Check that the ziplist doesn't have duplicate hash field names.
|
||||
* The ziplist element pointed by 'p' will be converted and stored into listpack. */
|
||||
static int _hashZiplistEntryConvertAndValidation(unsigned char *p, void *userdata) {
|
||||
unsigned char *str;
|
||||
unsigned int slen;
|
||||
long long vll;
|
||||
|
||||
struct {
|
||||
long count;
|
||||
dict *fields;
|
||||
unsigned char **lp;
|
||||
} *data = userdata;
|
||||
|
||||
if (!ziplistGet(p, &str, &slen, &vll))
|
||||
return 0;
|
||||
|
||||
/* Even records are field names, add to dict and check that's not a dup */
|
||||
if (((data->count) & 1) == 0) {
|
||||
sds field = str? sdsnewlen(str, slen): sdsfromlonglong(vll);
|
||||
if (dictAdd(data->fields, field, NULL) != DICT_OK) {
|
||||
/* Duplicate, return an error */
|
||||
sdsfree(field);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (str) {
|
||||
*(data->lp) = lpAppend(*(data->lp), (unsigned char*)str, slen);
|
||||
} else {
|
||||
*(data->lp) = lpAppendInteger(*(data->lp), vll);
|
||||
}
|
||||
|
||||
(data->count)++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* callback for to check the listpack doesn't have duplicate records */
|
||||
static int _hashListpackEntryValidation(unsigned char *p, void *userdata) {
|
||||
struct {
|
||||
long count;
|
||||
dict *fields;
|
||||
@ -559,11 +588,11 @@ static int _hashZiplistEntryValidation(unsigned char *p, void *userdata) {
|
||||
/* Even records are field names, add to dict and check that's not a dup */
|
||||
if (((data->count) & 1) == 0) {
|
||||
unsigned char *str;
|
||||
unsigned int slen;
|
||||
long long vll;
|
||||
if (!ziplistGet(p, &str, &slen, &vll))
|
||||
return 0;
|
||||
sds field = str? sdsnewlen(str, slen): sdsfromlonglong(vll);
|
||||
int64_t slen;
|
||||
unsigned char buf[LP_INTBUF_SIZE];
|
||||
|
||||
str = lpGet(p, &slen, buf);
|
||||
sds field = sdsnewlen(str, slen);
|
||||
if (dictAdd(data->fields, field, NULL) != DICT_OK) {
|
||||
/* Duplicate, return an error */
|
||||
sdsfree(field);
|
||||
@ -575,20 +604,19 @@ static int _hashZiplistEntryValidation(unsigned char *p, void *userdata) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Validate the integrity of the data structure.
|
||||
* when `deep` is 0, only the integrity of the header is validated.
|
||||
* when `deep` is 1, we scan all the entries one by one. */
|
||||
int hashZiplistValidateIntegrity(unsigned char *zl, size_t size, int deep) {
|
||||
if (!deep)
|
||||
return ziplistValidateIntegrity(zl, size, 0, NULL, NULL);
|
||||
|
||||
/* Validate the integrity of the data structure while converting it to
|
||||
* listpack and storing it at 'lp'.
|
||||
* The function is safe to call on non-validated ziplists, it returns 0
|
||||
* when encounter an integrity validation issue. */
|
||||
int hashZiplistConvertAndValidateIntegrity(unsigned char *zl, size_t size, unsigned char **lp) {
|
||||
/* Keep track of the field names to locate duplicate ones */
|
||||
struct {
|
||||
long count;
|
||||
dict *fields;
|
||||
} data = {0, dictCreate(&hashDictType)};
|
||||
unsigned char **lp;
|
||||
} data = {0, dictCreate(&hashDictType), lp};
|
||||
|
||||
int ret = ziplistValidateIntegrity(zl, size, 1, _hashZiplistEntryValidation, &data);
|
||||
int ret = ziplistValidateIntegrity(zl, size, 1, _hashZiplistEntryConvertAndValidation, &data);
|
||||
|
||||
/* make sure we have an even number of records. */
|
||||
if (data.count & 1)
|
||||
@ -598,13 +626,36 @@ int hashZiplistValidateIntegrity(unsigned char *zl, size_t size, int deep) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Create a new sds string from the ziplist entry. */
|
||||
sds hashSdsFromZiplistEntry(ziplistEntry *e) {
|
||||
/* Validate the integrity of the listpack structure.
|
||||
* when `deep` is 0, only the integrity of the header is validated.
|
||||
* when `deep` is 1, we scan all the entries one by one. */
|
||||
int hashListpackValidateIntegrity(unsigned char *lp, size_t size, int deep) {
|
||||
if (!deep)
|
||||
return lpValidateIntegrity(lp, size, 0, NULL, NULL);
|
||||
|
||||
/* Keep track of the field names to locate duplicate ones */
|
||||
struct {
|
||||
long count;
|
||||
dict *fields;
|
||||
} data = {0, dictCreate(&hashDictType)};
|
||||
|
||||
int ret = lpValidateIntegrity(lp, size, 1, _hashListpackEntryValidation, &data);
|
||||
|
||||
/* make sure we have an even number of records. */
|
||||
if (data.count & 1)
|
||||
ret = 0;
|
||||
|
||||
dictRelease(data.fields);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Create a new sds string from the listpack entry. */
|
||||
sds hashSdsFromListpackEntry(listpackEntry *e) {
|
||||
return e->sval ? sdsnewlen(e->sval, e->slen) : sdsfromlonglong(e->lval);
|
||||
}
|
||||
|
||||
/* Reply with bulk string from the ziplist entry. */
|
||||
void hashReplyFromZiplistEntry(client *c, ziplistEntry *e) {
|
||||
/* Reply with bulk string from the listpack entry. */
|
||||
void hashReplyFromListpackEntry(client *c, listpackEntry *e) {
|
||||
if (e->sval)
|
||||
addReplyBulkCBuffer(c, e->sval, e->slen);
|
||||
else
|
||||
@ -615,7 +666,7 @@ void hashReplyFromZiplistEntry(client *c, ziplistEntry *e) {
|
||||
* 'key' and 'val' will be set to hold the element.
|
||||
* The memory in them is not to be freed or modified by the caller.
|
||||
* 'val' can be NULL in which case it's not extracted. */
|
||||
void hashTypeRandomElement(robj *hashobj, unsigned long hashsize, ziplistEntry *key, ziplistEntry *val) {
|
||||
void hashTypeRandomElement(robj *hashobj, unsigned long hashsize, listpackEntry *key, listpackEntry *val) {
|
||||
if (hashobj->encoding == OBJ_ENCODING_HT) {
|
||||
dictEntry *de = dictGetFairRandomKey(hashobj->ptr);
|
||||
sds s = dictGetKey(de);
|
||||
@ -626,8 +677,8 @@ void hashTypeRandomElement(robj *hashobj, unsigned long hashsize, ziplistEntry *
|
||||
val->sval = (unsigned char*)s;
|
||||
val->slen = sdslen(s);
|
||||
}
|
||||
} else if (hashobj->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
ziplistRandomPair(hashobj->ptr, hashsize, key, val);
|
||||
} else if (hashobj->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
lpRandomPair(hashobj->ptr, hashsize, key, val);
|
||||
} else {
|
||||
serverPanic("Unknown hash encoding");
|
||||
}
|
||||
@ -774,12 +825,12 @@ static void addHashFieldToReply(client *c, robj *o, sds field) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (o->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
if (o->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
unsigned char *vstr = NULL;
|
||||
unsigned int vlen = UINT_MAX;
|
||||
long long vll = LLONG_MAX;
|
||||
|
||||
ret = hashTypeGetFromZiplist(o, field, &vstr, &vlen, &vll);
|
||||
ret = hashTypeGetFromListpack(o, field, &vstr, &vlen, &vll);
|
||||
if (ret < 0) {
|
||||
addReplyNull(c);
|
||||
} else {
|
||||
@ -871,12 +922,12 @@ void hstrlenCommand(client *c) {
|
||||
}
|
||||
|
||||
static void addHashIteratorCursorToReply(client *c, hashTypeIterator *hi, int what) {
|
||||
if (hi->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
if (hi->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
unsigned char *vstr = NULL;
|
||||
unsigned int vlen = UINT_MAX;
|
||||
long long vll = LLONG_MAX;
|
||||
|
||||
hashTypeCurrentFromZiplist(hi, what, &vstr, &vlen, &vll);
|
||||
hashTypeCurrentFromListpack(hi, what, &vstr, &vlen, &vll);
|
||||
if (vstr)
|
||||
addReplyBulkCBuffer(c, vstr, vlen);
|
||||
else
|
||||
@ -957,7 +1008,7 @@ void hscanCommand(client *c) {
|
||||
scanGenericCommand(c,o,cursor);
|
||||
}
|
||||
|
||||
static void harndfieldReplyWithZiplist(client *c, unsigned int count, ziplistEntry *keys, ziplistEntry *vals) {
|
||||
static void harndfieldReplyWithListpack(client *c, unsigned int count, listpackEntry *keys, listpackEntry *vals) {
|
||||
for (unsigned long i = 0; i < count; i++) {
|
||||
if (vals && c->resp > 2)
|
||||
addReplyArrayLen(c,2);
|
||||
@ -1028,18 +1079,19 @@ void hrandfieldWithCountCommand(client *c, long l, int withvalues) {
|
||||
if (withvalues)
|
||||
addReplyBulkCBuffer(c, value, sdslen(value));
|
||||
}
|
||||
} else if (hash->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
ziplistEntry *keys, *vals = NULL;
|
||||
} else if (hash->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
listpackEntry *keys, *vals = NULL;
|
||||
unsigned long limit, sample_count;
|
||||
|
||||
limit = count > HRANDFIELD_RANDOM_SAMPLE_LIMIT ? HRANDFIELD_RANDOM_SAMPLE_LIMIT : count;
|
||||
keys = zmalloc(sizeof(ziplistEntry)*limit);
|
||||
keys = zmalloc(sizeof(listpackEntry)*limit);
|
||||
if (withvalues)
|
||||
vals = zmalloc(sizeof(ziplistEntry)*limit);
|
||||
vals = zmalloc(sizeof(listpackEntry)*limit);
|
||||
while (count) {
|
||||
sample_count = count > limit ? limit : count;
|
||||
count -= sample_count;
|
||||
ziplistRandomPairs(hash->ptr, sample_count, keys, vals);
|
||||
harndfieldReplyWithZiplist(c, sample_count, keys, vals);
|
||||
lpRandomPairs(hash->ptr, sample_count, keys, vals);
|
||||
harndfieldReplyWithListpack(c, sample_count, keys, vals);
|
||||
}
|
||||
zfree(keys);
|
||||
zfree(vals);
|
||||
@ -1133,15 +1185,15 @@ void hrandfieldWithCountCommand(client *c, long l, int withvalues) {
|
||||
* to the temporary hash, trying to eventually get enough unique elements
|
||||
* to reach the specified count. */
|
||||
else {
|
||||
if (hash->encoding == OBJ_ENCODING_ZIPLIST) {
|
||||
if (hash->encoding == OBJ_ENCODING_LISTPACK) {
|
||||
/* it is inefficient to repeatedly pick one random element from a
|
||||
* ziplist. so we use this instead: */
|
||||
ziplistEntry *keys, *vals = NULL;
|
||||
keys = zmalloc(sizeof(ziplistEntry)*count);
|
||||
* listpack. so we use this instead: */
|
||||
listpackEntry *keys, *vals = NULL;
|
||||
keys = zmalloc(sizeof(listpackEntry)*count);
|
||||
if (withvalues)
|
||||
vals = zmalloc(sizeof(ziplistEntry)*count);
|
||||
serverAssert(ziplistRandomPairsUnique(hash->ptr, count, keys, vals) == count);
|
||||
harndfieldReplyWithZiplist(c, count, keys, vals);
|
||||
vals = zmalloc(sizeof(listpackEntry)*count);
|
||||
serverAssert(lpRandomPairsUnique(hash->ptr, count, keys, vals) == count);
|
||||
harndfieldReplyWithListpack(c, count, keys, vals);
|
||||
zfree(keys);
|
||||
zfree(vals);
|
||||
return;
|
||||
@ -1149,7 +1201,7 @@ void hrandfieldWithCountCommand(client *c, long l, int withvalues) {
|
||||
|
||||
/* Hashtable encoding (generic implementation) */
|
||||
unsigned long added = 0;
|
||||
ziplistEntry key, value;
|
||||
listpackEntry key, value;
|
||||
dict *d = dictCreate(&hashDictType);
|
||||
dictExpand(d, count);
|
||||
while(added < count) {
|
||||
@ -1158,7 +1210,7 @@ void hrandfieldWithCountCommand(client *c, long l, int withvalues) {
|
||||
/* Try to add the object to the dictionary. If it already exists
|
||||
* free it, otherwise increment the number of objects we have
|
||||
* in the result dictionary. */
|
||||
sds skey = hashSdsFromZiplistEntry(&key);
|
||||
sds skey = hashSdsFromListpackEntry(&key);
|
||||
if (dictAdd(d,skey,NULL) != DICT_OK) {
|
||||
sdsfree(skey);
|
||||
continue;
|
||||
@ -1168,9 +1220,9 @@ void hrandfieldWithCountCommand(client *c, long l, int withvalues) {
|
||||
/* We can reply right away, so that we don't need to store the value in the dict. */
|
||||
if (withvalues && c->resp > 2)
|
||||
addReplyArrayLen(c,2);
|
||||
hashReplyFromZiplistEntry(c, &key);
|
||||
hashReplyFromListpackEntry(c, &key);
|
||||
if (withvalues)
|
||||
hashReplyFromZiplistEntry(c, &value);
|
||||
hashReplyFromListpackEntry(c, &value);
|
||||
}
|
||||
|
||||
/* Release memory */
|
||||
@ -1183,7 +1235,7 @@ void hrandfieldCommand(client *c) {
|
||||
long l;
|
||||
int withvalues = 0;
|
||||
robj *hash;
|
||||
ziplistEntry ele;
|
||||
listpackEntry ele;
|
||||
|
||||
if (c->argc >= 3) {
|
||||
if (getLongFromObjectOrReply(c,c->argv[2],&l,NULL) != C_OK) return;
|
||||
@ -1203,5 +1255,5 @@ void hrandfieldCommand(client *c) {
|
||||
}
|
||||
|
||||
hashTypeRandomElement(hash,hashTypeLength(hash),&ele,NULL);
|
||||
hashReplyFromZiplistEntry(c, &ele);
|
||||
hashReplyFromListpackEntry(c, &ele);
|
||||
}
|
||||
|
||||
@ -241,24 +241,6 @@ robj *streamDup(robj *o) {
|
||||
return sobj;
|
||||
}
|
||||
|
||||
/* This is just a wrapper for lpAppend() to directly use a 64 bit integer
|
||||
* instead of a string. */
|
||||
unsigned char *lpAppendInteger(unsigned char *lp, int64_t value) {
|
||||
char buf[LONG_STR_SIZE];
|
||||
int slen = ll2string(buf,sizeof(buf),value);
|
||||
return lpAppend(lp,(unsigned char*)buf,slen);
|
||||
}
|
||||
|
||||
/* This is just a wrapper for lpReplace() to directly use a 64 bit integer
|
||||
* instead of a string to replace the current element. The function returns
|
||||
* the new listpack as return value, and also updates the current cursor
|
||||
* by updating '*pos'. */
|
||||
unsigned char *lpReplaceInteger(unsigned char *lp, unsigned char **pos, int64_t value) {
|
||||
char buf[LONG_STR_SIZE];
|
||||
int slen = ll2string(buf,sizeof(buf),value);
|
||||
return lpInsert(lp, (unsigned char*)buf, slen, *pos, LP_REPLACE, pos);
|
||||
}
|
||||
|
||||
/* This is a wrapper function for lpGet() to directly get an integer value
|
||||
* from the listpack (that may store numbers as a string), converting
|
||||
* the string if needed.
|
||||
@ -3577,7 +3559,7 @@ int streamValidateListpackIntegrity(unsigned char *lp, size_t size, int deep) {
|
||||
|
||||
/* Since we don't want to run validation of all records twice, we'll
|
||||
* run the listpack validation of just the header and do the rest here. */
|
||||
if (!lpValidateIntegrity(lp, size, 0))
|
||||
if (!lpValidateIntegrity(lp, size, 0, NULL, NULL))
|
||||
return 0;
|
||||
|
||||
/* In non-deep mode we just validated the listpack header (encoded size) */
|
||||
|
||||
BIN
tests/assets/hash-ziplist.rdb
Normal file
BIN
tests/assets/hash-ziplist.rdb
Normal file
Binary file not shown.
28
tests/integration/convert-ziplist-hash-on-load.tcl
Normal file
28
tests/integration/convert-ziplist-hash-on-load.tcl
Normal file
@ -0,0 +1,28 @@
|
||||
tags {"external:skip"} {
|
||||
|
||||
# Copy RDB with ziplist encoded hash to server path
|
||||
set server_path [tmpdir "server.convert-ziplist-hash-on-load"]
|
||||
|
||||
exec cp -f tests/assets/hash-ziplist.rdb $server_path
|
||||
start_server [list overrides [list "dir" $server_path "dbfilename" "hash-ziplist.rdb"]] {
|
||||
test "RDB load ziplist hash: converts to listpack when RDB loading" {
|
||||
r select 0
|
||||
|
||||
assert_encoding listpack hash
|
||||
assert_equal 2 [r hlen hash]
|
||||
assert_match {v1 v2} [r hmget hash f1 f2]
|
||||
}
|
||||
}
|
||||
|
||||
exec cp -f tests/assets/hash-ziplist.rdb $server_path
|
||||
start_server [list overrides [list "dir" $server_path "dbfilename" "hash-ziplist.rdb" "hash-max-ziplist-entries" 1]] {
|
||||
test "RDB load ziplist hash: converts to hash table when hash-max-ziplist-entries is exceeded" {
|
||||
r select 0
|
||||
|
||||
assert_encoding hashtable hash
|
||||
assert_equal 2 [r hlen hash]
|
||||
assert_match {v1 v2} [r hmget hash f1 f2]
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@ -5,10 +5,10 @@ set server_path [tmpdir "server.convert-zipmap-hash-on-load"]
|
||||
|
||||
exec cp -f tests/assets/hash-zipmap.rdb $server_path
|
||||
start_server [list overrides [list "dir" $server_path "dbfilename" "hash-zipmap.rdb"]] {
|
||||
test "RDB load zipmap hash: converts to ziplist" {
|
||||
test "RDB load zipmap hash: converts to listpack" {
|
||||
r select 0
|
||||
|
||||
assert_match "*ziplist*" [r debug object hash]
|
||||
assert_match "*listpack*" [r debug object hash]
|
||||
assert_equal 2 [r hlen hash]
|
||||
assert_match {v1 v2} [r hmget hash f1 f2]
|
||||
}
|
||||
|
||||
@ -43,32 +43,31 @@ test {corrupt payload: #7445 - without sanitize - 2} {
|
||||
|
||||
test {corrupt payload: hash with valid zip list header, invalid entry len} {
|
||||
start_server [list overrides [list loglevel verbose use-exit-on-panic yes crash-memcheck-enabled no] ] {
|
||||
r config set sanitize-dump-payload no
|
||||
r restore key 0 "\x0D\x1B\x1B\x00\x00\x00\x16\x00\x00\x00\x04\x00\x00\x02\x61\x00\x04\x02\x62\x00\x04\x14\x63\x00\x04\x02\x64\x00\xFF\x09\x00\xD9\x10\x54\x92\x15\xF5\x5F\x52"
|
||||
r config set hash-max-ziplist-entries 1
|
||||
catch {r hset key b b}
|
||||
verify_log_message 0 "*zipEntrySafe*" 0
|
||||
catch {
|
||||
r restore key 0 "\x0D\x1B\x1B\x00\x00\x00\x16\x00\x00\x00\x04\x00\x00\x02\x61\x00\x04\x02\x62\x00\x04\x14\x63\x00\x04\x02\x64\x00\xFF\x09\x00\xD9\x10\x54\x92\x15\xF5\x5F\x52"
|
||||
} err
|
||||
assert_match "*Bad data format*" $err
|
||||
verify_log_message 0 "*integrity check failed*" 0
|
||||
}
|
||||
}
|
||||
|
||||
test {corrupt payload: invalid zlbytes header} {
|
||||
start_server [list overrides [list loglevel verbose use-exit-on-panic yes crash-memcheck-enabled no] ] {
|
||||
r config set sanitize-dump-payload no
|
||||
catch {
|
||||
r restore key 0 "\x0D\x1B\x25\x00\x00\x00\x16\x00\x00\x00\x04\x00\x00\x02\x61\x00\x04\x02\x62\x00\x04\x02\x63\x00\x04\x02\x64\x00\xFF\x09\x00\xB7\xF7\x6E\x9F\x43\x43\x14\xC6"
|
||||
} err
|
||||
assert_match "*Bad data format*" $err
|
||||
verify_log_message 0 "*integrity check failed*" 0
|
||||
}
|
||||
}
|
||||
|
||||
test {corrupt payload: valid zipped hash header, dup records} {
|
||||
start_server [list overrides [list loglevel verbose use-exit-on-panic yes crash-memcheck-enabled no] ] {
|
||||
r config set sanitize-dump-payload no
|
||||
r restore key 0 "\x0D\x1B\x1B\x00\x00\x00\x16\x00\x00\x00\x04\x00\x00\x02\x61\x00\x04\x02\x62\x00\x04\x02\x61\x00\x04\x02\x64\x00\xFF\x09\x00\xA1\x98\x36\x78\xCC\x8E\x93\x2E"
|
||||
r config set hash-max-ziplist-entries 1
|
||||
# cause an assertion when converting to hash table
|
||||
catch {r hset key b b}
|
||||
verify_log_message 0 "*ziplist with dup elements dump*" 0
|
||||
catch {
|
||||
r restore key 0 "\x0D\x1B\x1B\x00\x00\x00\x16\x00\x00\x00\x04\x00\x00\x02\x61\x00\x04\x02\x62\x00\x04\x02\x61\x00\x04\x02\x64\x00\xFF\x09\x00\xA1\x98\x36\x78\xCC\x8E\x93\x2E"
|
||||
} err
|
||||
assert_match "*Bad data format*" $err
|
||||
verify_log_message 0 "*integrity check failed*" 0
|
||||
}
|
||||
}
|
||||
|
||||
@ -235,6 +234,16 @@ test {corrupt payload: hash ziplist with duplicate records} {
|
||||
}
|
||||
}
|
||||
|
||||
test {corrupt payload: hash listpack with duplicate records} {
|
||||
# when we do perform full sanitization, we expect duplicate records to fail the restore
|
||||
start_server [list overrides [list loglevel verbose use-exit-on-panic yes crash-memcheck-enabled no] ] {
|
||||
r config set sanitize-dump-payload yes
|
||||
r debug set-skip-checksum-validation 1
|
||||
catch { r RESTORE _hash 0 "\x10\x17\x17\x00\x00\x00\x04\x00\x82a\x00\x03\x82b\x00\x03\x82a\x00\x03\x82d\x00\x03\xff\n\x00\xc0\xcf\xa6\x87\xe5\xa7\xc5\xbe" } err
|
||||
assert_match "*Bad data format*" $err
|
||||
}
|
||||
}
|
||||
|
||||
test {corrupt payload: hash ziplist uneven record count} {
|
||||
# when we do perform full sanitization, we expect duplicate records to fail the restore
|
||||
start_server [list overrides [list loglevel verbose use-exit-on-panic yes crash-memcheck-enabled no] ] {
|
||||
@ -304,16 +313,14 @@ test {corrupt payload: fuzzer findings - NPD in quicklistIndex} {
|
||||
}
|
||||
}
|
||||
|
||||
test {corrupt payload: fuzzer findings - invalid read in ziplistFind} {
|
||||
test {corrupt payload: fuzzer findings - encoded entry header reach outside the allocation} {
|
||||
start_server [list overrides [list loglevel verbose use-exit-on-panic yes crash-memcheck-enabled no] ] {
|
||||
r config set sanitize-dump-payload no
|
||||
r debug set-skip-checksum-validation 1
|
||||
catch {
|
||||
r RESTORE key 0 "\x0D\x19\x19\x00\x00\x00\x16\x00\x00\x00\x06\x00\x00\xF1\x02\xF1\x02\xF2\x02\x02\x5F\x31\x04\x99\x02\xF3\xFF\x09\x00\xC5\xB8\x10\xC0\x8A\xF9\x16\xDF"
|
||||
r HEXISTS key -688319650333
|
||||
}
|
||||
assert_equal [count_log_message 0 "crashed by signal"] 0
|
||||
assert_equal [count_log_message 0 "ASSERTION FAILED"] 1
|
||||
} err
|
||||
assert_match "*Bad data format*" $err
|
||||
verify_log_message 0 "*integrity check failed*" 0
|
||||
}
|
||||
}
|
||||
|
||||
@ -342,12 +349,12 @@ test {corrupt payload: fuzzer findings - hash crash} {
|
||||
|
||||
test {corrupt payload: fuzzer findings - uneven entry count in hash} {
|
||||
start_server [list overrides [list loglevel verbose use-exit-on-panic yes crash-memcheck-enabled no] ] {
|
||||
r config set sanitize-dump-payload no
|
||||
r debug set-skip-checksum-validation 1
|
||||
r RESTORE _hashbig 0 "\x0D\x3D\x3D\x00\x00\x00\x38\x00\x00\x00\x14\x00\x00\xF2\x02\x02\x5F\x31\x04\x1C\x02\xF7\x02\xF1\x02\xF1\x02\xF5\x02\xF5\x02\xF4\x02\x02\x5F\x33\x04\xF6\x02\x02\x5F\x35\x04\xF8\x02\x02\x5F\x37\x04\xF9\x02\xF9\x02\xF3\x02\xF3\x02\xFA\x02\x02\x5F\x39\xFF\x09\x00\x73\xB7\x68\xC8\x97\x24\x8E\x88"
|
||||
catch { r HSCAN _hashbig -250 }
|
||||
assert_equal [count_log_message 0 "crashed by signal"] 0
|
||||
assert_equal [count_log_message 0 "ASSERTION FAILED"] 1
|
||||
catch {
|
||||
r RESTORE _hashbig 0 "\x0D\x3D\x3D\x00\x00\x00\x38\x00\x00\x00\x14\x00\x00\xF2\x02\x02\x5F\x31\x04\x1C\x02\xF7\x02\xF1\x02\xF1\x02\xF5\x02\xF5\x02\xF4\x02\x02\x5F\x33\x04\xF6\x02\x02\x5F\x35\x04\xF8\x02\x02\x5F\x37\x04\xF9\x02\xF9\x02\xF3\x02\xF3\x02\xFA\x02\x02\x5F\x39\xFF\x09\x00\x73\xB7\x68\xC8\x97\x24\x8E\x88"
|
||||
} err
|
||||
assert_match "*Bad data format*" $err
|
||||
verify_log_message 0 "*integrity check failed*" 0
|
||||
}
|
||||
}
|
||||
|
||||
@ -474,15 +481,14 @@ test {corrupt payload: fuzzer findings - infinite loop} {
|
||||
}
|
||||
}
|
||||
|
||||
test {corrupt payload: fuzzer findings - hash convert asserts on RESTORE with shallow sanitization} {
|
||||
# if we don't perform full sanitization, and the next command can assert on converting
|
||||
# a ziplist to hash records, then we're ok with that happning in RESTORE too
|
||||
test {corrupt payload: fuzzer findings - hash ziplist too long entry len} {
|
||||
start_server [list overrides [list loglevel verbose use-exit-on-panic yes crash-memcheck-enabled no] ] {
|
||||
r config set sanitize-dump-payload no
|
||||
r debug set-skip-checksum-validation 1
|
||||
catch { r RESTORE _hash 0 "\x0D\x3D\x3D\x00\x00\x00\x3A\x00\x00\x00\x14\x13\x00\xF5\x02\xF5\x02\xF2\x02\x53\x5F\x31\x04\xF3\x02\xF3\x02\xF7\x02\xF7\x02\xF8\x02\x02\x5F\x37\x04\xF1\x02\xF1\x02\xF6\x02\x02\x5F\x35\x04\xF4\x02\x02\x5F\x33\x04\xFA\x02\x02\x5F\x39\x04\xF9\x02\xF9\xFF\x09\x00\xB5\x48\xDE\x62\x31\xD0\xE5\x63" }
|
||||
assert_equal [count_log_message 0 "crashed by signal"] 0
|
||||
assert_equal [count_log_message 0 "ASSERTION FAILED"] 1
|
||||
catch {
|
||||
r RESTORE _hash 0 "\x0D\x3D\x3D\x00\x00\x00\x3A\x00\x00\x00\x14\x13\x00\xF5\x02\xF5\x02\xF2\x02\x53\x5F\x31\x04\xF3\x02\xF3\x02\xF7\x02\xF7\x02\xF8\x02\x02\x5F\x37\x04\xF1\x02\xF1\x02\xF6\x02\x02\x5F\x35\x04\xF4\x02\x02\x5F\x33\x04\xFA\x02\x02\x5F\x39\x04\xF9\x02\xF9\xFF\x09\x00\xB5\x48\xDE\x62\x31\xD0\xE5\x63"
|
||||
} err
|
||||
assert_match "*Bad data format*" $err
|
||||
verify_log_message 0 "*integrity check failed*" 0
|
||||
}
|
||||
}
|
||||
|
||||
@ -688,5 +694,15 @@ test {corrupt payload: fuzzer findings - hash with len of 0} {
|
||||
}
|
||||
}
|
||||
|
||||
test {corrupt payload: fuzzer findings - hash listpack first element too long entry len} {
|
||||
start_server [list overrides [list loglevel verbose use-exit-on-panic yes crash-memcheck-enabled no] ] {
|
||||
r debug set-skip-checksum-validation 1
|
||||
r config set sanitize-dump-payload yes
|
||||
catch { r restore _hash 0 "\x10\x15\x15\x00\x00\x00\x06\x00\xF0\x01\x00\x01\x01\x01\x82\x5F\x31\x03\x02\x01\x02\x01\xFF\x0A\x00\x94\x21\x0A\xFA\x06\x52\x9F\x44" replace } err
|
||||
assert_match "*Bad data format*" $err
|
||||
verify_log_message 0 "*integrity check failed*" 0
|
||||
}
|
||||
}
|
||||
|
||||
} ;# tags
|
||||
|
||||
|
||||
@ -48,6 +48,7 @@ set ::all_tests {
|
||||
integration/corrupt-dump
|
||||
integration/corrupt-dump-fuzzer
|
||||
integration/convert-zipmap-hash-on-load
|
||||
integration/convert-ziplist-hash-on-load
|
||||
integration/logging
|
||||
integration/psync2
|
||||
integration/psync2-reg
|
||||
|
||||
@ -127,10 +127,10 @@ start_server {tags {"aofrw external:skip"} overrides {aof-use-rdb-preamble no}}
|
||||
}
|
||||
|
||||
foreach d {string int} {
|
||||
foreach e {ziplist hashtable} {
|
||||
foreach e {listpack hashtable} {
|
||||
test "AOF rewrite of hash with $e encoding, $d data" {
|
||||
r flushall
|
||||
if {$e eq {ziplist}} {set len 10} else {set len 1000}
|
||||
if {$e eq {listpack}} {set len 10} else {set len 1000}
|
||||
for {set j 0} {$j < $len} {incr j} {
|
||||
if {$d eq {string}} {
|
||||
set data [randstring 0 16 alpha]
|
||||
|
||||
@ -313,10 +313,10 @@ start_server {tags {"keyspace"}} {
|
||||
r config set zset-max-ziplist-entries $original_max
|
||||
}
|
||||
|
||||
test {COPY basic usage for ziplist hash} {
|
||||
test {COPY basic usage for listpack hash} {
|
||||
r del hash1{t} newhash1{t}
|
||||
r hset hash1{t} tmp 17179869184
|
||||
assert_encoding ziplist hash1{t}
|
||||
assert_encoding listpack hash1{t}
|
||||
r copy hash1{t} newhash1{t}
|
||||
set digest [debug_digest_value hash1{t}]
|
||||
assert_equal $digest [debug_digest_value newhash1{t}]
|
||||
|
||||
@ -132,11 +132,11 @@ start_server {tags {"scan network"}} {
|
||||
}
|
||||
}
|
||||
|
||||
foreach enc {ziplist hashtable} {
|
||||
foreach enc {listpack hashtable} {
|
||||
test "HSCAN with encoding $enc" {
|
||||
# Create the Hash
|
||||
r del hash
|
||||
if {$enc eq {ziplist}} {
|
||||
if {$enc eq {listpack}} {
|
||||
set count 30
|
||||
} else {
|
||||
set count 1000
|
||||
|
||||
@ -14,8 +14,8 @@ start_server {tags {"hash"}} {
|
||||
list [r hlen smallhash]
|
||||
} {8}
|
||||
|
||||
test {Is the small hash encoded with a ziplist?} {
|
||||
assert_encoding ziplist smallhash
|
||||
test {Is the small hash encoded with a listpack?} {
|
||||
assert_encoding listpack smallhash
|
||||
}
|
||||
|
||||
proc create_hash {key entries} {
|
||||
@ -34,12 +34,15 @@ start_server {tags {"hash"}} {
|
||||
return $res
|
||||
}
|
||||
|
||||
foreach {type contents} "ziplist {{a 1} {b 2} {c 3}} hashtable {{a 1} {b 2} {[randstring 70 90 alpha] 3}}" {
|
||||
foreach {type contents} "listpack {{a 1} {b 2} {c 3}} hashtable {{a 1} {b 2} {[randstring 70 90 alpha] 3}}" {
|
||||
set original_max_value [lindex [r config get hash-max-ziplist-value] 1]
|
||||
r config set hash-max-ziplist-value 10
|
||||
create_hash myhash $contents
|
||||
assert_encoding $type myhash
|
||||
|
||||
# coverage for objectComputeSize
|
||||
assert_morethan [r memory usage myhash] 0
|
||||
|
||||
test "HRANDFIELD - $type" {
|
||||
unset -nocomplain myhash
|
||||
array set myhash {}
|
||||
@ -87,7 +90,7 @@ start_server {tags {"hash"}} {
|
||||
|
||||
foreach {type contents} "
|
||||
hashtable {{a 1} {b 2} {c 3} {d 4} {e 5} {6 f} {7 g} {8 h} {9 i} {[randstring 70 90 alpha] 10}}
|
||||
ziplist {{a 1} {b 2} {c 3} {d 4} {e 5} {6 f} {7 g} {8 h} {9 i} {10 j}} " {
|
||||
listpack {{a 1} {b 2} {c 3} {d 4} {e 5} {6 f} {7 g} {8 h} {9 i} {10 j}} " {
|
||||
test "HRANDFIELD with <count> - $type" {
|
||||
set original_max_value [lindex [r config get hash-max-ziplist-value] 1]
|
||||
r config set hash-max-ziplist-value 10
|
||||
|
||||
Loading…
Reference in New Issue
Block a user