As detailed in doc/design.lyx section 2.16 "Record Headers Are Not
Expandible", we make sure that if there is padding at the end of a record,
the first byte of padding is a zero.
-static enum TDB_ERROR check_header(struct tdb_context *tdb, tdb_off_t *recovery)
+static enum TDB_ERROR check_header(struct tdb_context *tdb, tdb_off_t *recovery,
+ uint64_t *features)
{
uint64_t hash_test;
struct tdb_header hdr;
{
uint64_t hash_test;
struct tdb_header hdr;
+ /* Features which are used must be a subset of features offered. */
+ if (hdr.features_used & ~hdr.features_offered) {
+ return tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "check: features used (0x%llx) which"
+ " are not offered (0x%llx)",
+ (long long)hdr.features_used,
+ (long long)hdr.features_offered);
+ }
+
+ *features = hdr.features_offered;
*recovery = hdr.recovery;
if (*recovery) {
if (*recovery < sizeof(hdr) || *recovery > tdb->map_size) {
*recovery = hdr.recovery;
if (*recovery) {
if (*recovery < sizeof(hdr) || *recovery > tdb->map_size) {
static enum TDB_ERROR check_linear(struct tdb_context *tdb,
tdb_off_t **used, size_t *num_used,
tdb_off_t **fr, size_t *num_free,
static enum TDB_ERROR check_linear(struct tdb_context *tdb,
tdb_off_t **used, size_t *num_used,
tdb_off_t **fr, size_t *num_free,
+ uint64_t features, tdb_off_t recovery)
{
tdb_off_t off;
tdb_len_t len;
{
tdb_off_t off;
tdb_len_t len;
(long long)len,
(long long)off);
}
(long long)len,
(long long)off);
}
+
+ /* Check that records have correct 0 at end (but may
+ * not in future). */
+ if (extra && !features) {
+ const char *p;
+ char c;
+ p = tdb_access_read(tdb, off + sizeof(rec.u)
+ + klen + dlen, 1, false);
+ if (TDB_PTR_IS_ERR(p))
+ return TDB_PTR_ERR(p);
+ c = *p;
+ tdb_access_release(tdb, p);
+
+ if (c != '\0') {
+ return tdb_logerr(tdb, TDB_ERR_CORRUPT,
+ TDB_LOG_ERROR,
+ "tdb_check:"
+ " non-zero extra"
+ " at %llu",
+ (long long)off);
+ }
+ }
} else {
return tdb_logerr(tdb, TDB_ERR_CORRUPT,
TDB_LOG_ERROR,
} else {
return tdb_logerr(tdb, TDB_ERR_CORRUPT,
TDB_LOG_ERROR,
{
tdb_off_t *fr = NULL, *used = NULL, ft, recovery;
size_t num_free = 0, num_used = 0, num_found = 0, num_ftables = 0;
{
tdb_off_t *fr = NULL, *used = NULL, ft, recovery;
size_t num_free = 0, num_used = 0, num_found = 0, num_ftables = 0;
enum TDB_ERROR ecode;
ecode = tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false);
enum TDB_ERROR ecode;
ecode = tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false);
- ecode = check_header(tdb, &recovery);
+ ecode = check_header(tdb, &recovery, &features);
if (ecode != TDB_SUCCESS)
goto out;
/* First we do a linear scan, checking all records. */
if (ecode != TDB_SUCCESS)
goto out;
/* First we do a linear scan, checking all records. */
- ecode = check_linear(tdb, &used, &num_used, &fr, &num_free, recovery);
+ ecode = check_linear(tdb, &used, &num_used, &fr, &num_free, features,
+ recovery);
if (ecode != TDB_SUCCESS)
goto out;
if (ecode != TDB_SUCCESS)
goto out;
\end_layout
\begin_layout Standard
\end_layout
\begin_layout Standard
+
+\change_deleted 0 1300360766
+\change_inserted 0 1300360767
+Complete.
+\change_unchanged
+
\end_layout
\begin_layout Subsection
\end_layout
\begin_layout Subsection
+ /* For futureproofing, we put a 0 in any unused space. */
+ if (rec_extra_padding(&rec)) {
+ ecode = tdb->methods->twrite(tdb, best_off + sizeof(rec)
+ + keylen + datalen, "", 1);
+ if (ecode != TDB_SUCCESS) {
+ goto unlock_err;
+ }
+ }
+
/* Bucket of leftover will be <= current bucket, so nested
* locking is allowed. */
if (leftover) {
/* Bucket of leftover will be <= current bucket, so nested
* locking is allowed. */
if (leftover) {
+static enum TDB_ERROR update_data(struct tdb_context *tdb,
+ tdb_off_t off,
+ struct tdb_data dbuf,
+ tdb_len_t extra)
+{
+ enum TDB_ERROR ecode;
+
+ ecode = tdb->methods->twrite(tdb, off, dbuf.dptr, dbuf.dsize);
+ if (ecode == TDB_SUCCESS && extra) {
+ /* Put a zero in; future versions may append other data. */
+ ecode = tdb->methods->twrite(tdb, off + dbuf.dsize, "", 1);
+ }
+ return ecode;
+}
+
enum TDB_ERROR tdb_store(struct tdb_context *tdb,
struct tdb_data key, struct tdb_data dbuf, int flag)
{
enum TDB_ERROR tdb_store(struct tdb_context *tdb,
struct tdb_data key, struct tdb_data dbuf, int flag)
{
if (ecode != TDB_SUCCESS) {
goto out;
}
if (ecode != TDB_SUCCESS) {
goto out;
}
- ecode = tdb->methods->twrite(tdb,
- off + sizeof(rec)
- + key.dsize,
- dbuf.dptr,
- dbuf.dsize);
+ ecode = update_data(tdb,
+ off + sizeof(rec)
+ + key.dsize, dbuf,
+ old_room - dbuf.dsize);
if (ecode != TDB_SUCCESS) {
goto out;
}
if (ecode != TDB_SUCCESS) {
goto out;
}
}
off += sizeof(rec) + key.dsize + old_dlen;
}
off += sizeof(rec) + key.dsize + old_dlen;
- ecode = tdb->methods->twrite(tdb, off, dbuf.dptr,
- dbuf.dsize);
+ ecode = update_data(tdb, off, dbuf,
+ rec_extra_padding(&rec));
/* We do all the work in add_to_freetable */
}
/* We do all the work in add_to_freetable */
}
+static void add_zero_pad(struct tdb_used_record *u, size_t len, size_t extra)
+{
+ if (extra)
+ ((char *)(u + 1))[len] = '\0';
+}
+
static void set_data_record(void *mem, struct tdb_context *tdb,
struct tle_used *used)
{
static void set_data_record(void *mem, struct tdb_context *tdb,
struct tle_used *used)
{
memcpy(u + 1, used->key.dptr, used->key.dsize);
memcpy((char *)(u + 1) + used->key.dsize,
used->data.dptr, used->data.dsize);
memcpy(u + 1, used->key.dptr, used->key.dsize);
memcpy((char *)(u + 1) + used->key.dsize,
used->data.dptr, used->data.dsize);
+ add_zero_pad(u, used->key.dsize + used->data.dsize, used->extra);
}
static void set_hashtable(void *mem, struct tdb_context *tdb,
}
static void set_hashtable(void *mem, struct tdb_context *tdb,
set_header(tdb, u, TDB_HTABLE_MAGIC, 0, len, len + htable->extra, 0);
memset(u + 1, 0, len);
set_header(tdb, u, TDB_HTABLE_MAGIC, 0, len, len + htable->extra, 0);
memset(u + 1, 0, len);
+ add_zero_pad(u, len, htable->extra);
}
static void set_freetable(void *mem, struct tdb_context *tdb,
}
static void set_freetable(void *mem, struct tdb_context *tdb,