int main(int argc, char *argv[]) { unsigned int i, count; bool found[3]; struct ntdb_context *ntdb0, *ntdb1, *ntdb; int flags[] = { NTDB_DEFAULT, NTDB_NOMMAP, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; plan_tests(sizeof(flags) / sizeof(flags[0]) * 8); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { ntdb0 = ntdb_open("run-ntdb_foreach0.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); ntdb1 = ntdb_open("run-ntdb_foreach1.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); ntdb = ntdb_open("run-ntdb_foreach2.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); memset(found, 0, sizeof(found)); ntdb_foreach(set_found, found); ok1(found[0] && found[1] && found[2]); /* Test premature iteration termination */ count = 1; ntdb_foreach(drop_count, &count); ok1(count == 0); ntdb_close(ntdb1); memset(found, 0, sizeof(found)); ntdb_foreach(set_found, found); ok1(found[0] && !found[1] && found[2]); ntdb_close(ntdb); memset(found, 0, sizeof(found)); ntdb_foreach(set_found, found); ok1(found[0] && !found[1] && !found[2]); ntdb1 = ntdb_open("run-ntdb_foreach1.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR, 0600, &tap_log_attr); memset(found, 0, sizeof(found)); ntdb_foreach(set_found, found); ok1(found[0] && found[1] && !found[2]); ntdb_close(ntdb0); memset(found, 0, sizeof(found)); ntdb_foreach(set_found, found); ok1(!found[0] && found[1] && !found[2]); ntdb_close(ntdb1); memset(found, 0, sizeof(found)); ntdb_foreach(set_found, found); ok1(!found[0] && !found[1] && !found[2]); ok1(tap_log_messages == 0); } return exit_status(); }
int main(int argc, char *argv[]) { unsigned int i, j; struct ntdb_context *ntdb; int flags[] = { NTDB_DEFAULT, NTDB_NOMMAP, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; NTDB_DATA key = { (unsigned char *)&j, sizeof(j) }; NTDB_DATA data = { (unsigned char *)&j, sizeof(j) }; plan_tests(sizeof(flags) / sizeof(flags[0]) * 8 + 1); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { uint64_t features; ntdb = ntdb_open("run-features.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); ok1(ntdb); if (!ntdb) continue; /* Put some stuff in there. */ for (j = 0; j < 100; j++) { if (ntdb_store(ntdb, key, data, NTDB_REPLACE) != 0) fail("Storing in ntdb"); } /* Mess with features fields in hdr. */ features = (~NTDB_FEATURE_MASK ^ 1); ok1(ntdb_write_convert(ntdb, offsetof(struct ntdb_header, features_used), &features, sizeof(features)) == 0); ok1(ntdb_write_convert(ntdb, offsetof(struct ntdb_header, features_offered), &features, sizeof(features)) == 0); ntdb_close(ntdb); ntdb = ntdb_open("run-features.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR, 0, &tap_log_attr); ok1(ntdb); if (!ntdb) continue; /* Should not have changed features offered. */ ok1(ntdb_read_convert(ntdb, offsetof(struct ntdb_header, features_offered), &features, sizeof(features)) == 0); ok1(features == (~NTDB_FEATURE_MASK ^ 1)); /* Should have cleared unknown bits in features_used. */ ok1(ntdb_read_convert(ntdb, offsetof(struct ntdb_header, features_used), &features, sizeof(features)) == 0); ok1(features == (1 & NTDB_FEATURE_MASK)); ntdb_close(ntdb); } ok1(tap_log_messages == 0); return exit_status(); }
int main(int argc, char *argv[]) { unsigned int i; struct ntdb_context *ntdb; struct agent *agent; union ntdb_attribute cif; NTDB_DATA key = ntdb_mkdata(KEY_STR, strlen(KEY_STR)); int flags[] = { NTDB_DEFAULT, NTDB_NOMMAP, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; cif.openhook.base.attr = NTDB_ATTRIBUTE_OPENHOOK; cif.openhook.base.next = &tap_log_attr; cif.openhook.fn = clear_if_first; cif.openhook.data = clear_if_first; agent = prepare_external_agent(); plan_tests(sizeof(flags) / sizeof(flags[0]) * 13); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { /* Create it */ ntdb = ntdb_open("run-83-openhook.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, NULL); ok1(ntdb); ok1(ntdb_store(ntdb, key, key, NTDB_REPLACE) == 0); ntdb_close(ntdb); /* Now, open with CIF, should clear it. */ ntdb = ntdb_open("run-83-openhook.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR, 0, &cif); ok1(ntdb); ok1(!ntdb_exists(ntdb, key)); ok1(ntdb_store(ntdb, key, key, NTDB_REPLACE) == 0); /* Agent should not clear it, since it's still open. */ ok1(external_agent_operation(agent, OPEN_WITH_HOOK, "run-83-openhook.ntdb") == SUCCESS); ok1(external_agent_operation(agent, FETCH, KEY_STR "=" KEY_STR) == SUCCESS); ok1(external_agent_operation(agent, CLOSE, "") == SUCCESS); /* Still exists for us too. */ ok1(ntdb_exists(ntdb, key)); /* Close it, now agent should clear it. */ ntdb_close(ntdb); ok1(external_agent_operation(agent, OPEN_WITH_HOOK, "run-83-openhook.ntdb") == SUCCESS); ok1(external_agent_operation(agent, FETCH, KEY_STR "=" KEY_STR) == FAILED); ok1(external_agent_operation(agent, CLOSE, "") == SUCCESS); ok1(tap_log_messages == 0); } free_external_agent(agent); return exit_status(); }
int main(int argc, char *argv[]) { unsigned int i, messages = 0; struct ntdb_context *ntdb; int flags[] = { NTDB_DEFAULT, NTDB_NOMMAP, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; failtest_init(argc, argv); failtest_hook = block_repeat_failures; failtest_exit_check = exit_check_log; plan_tests(sizeof(flags) / sizeof(flags[0]) * 4); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { ntdb = ntdb_open("run-35-convert.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); if (!ok1(ntdb)) failtest_exit(exit_status()); ntdb_close(ntdb); /* We can fail in log message formatting or open. That's OK */ if (failtest_has_failed()) { failtest_exit(exit_status()); } /* If we say NTDB_CONVERT, it must be converted */ ntdb = ntdb_open("run-35-convert.ntdb", flags[i]|NTDB_CONVERT|MAYBE_NOSYNC, O_RDWR, 0600, &tap_log_attr); if (flags[i] & NTDB_CONVERT) { if (!ntdb) failtest_exit(exit_status()); ok1(ntdb_get_flags(ntdb) & NTDB_CONVERT); ntdb_close(ntdb); } else { if (!ok1(!ntdb && errno == EIO)) failtest_exit(exit_status()); ok1(tap_log_messages == ++messages); if (!ok1(log_last && strstr(log_last, "NTDB_CONVERT"))) failtest_exit(exit_status()); } /* If don't say NTDB_CONVERT, it *may* be converted */ ntdb = ntdb_open("run-35-convert.ntdb", (flags[i] & ~NTDB_CONVERT)|MAYBE_NOSYNC, O_RDWR, 0600, &tap_log_attr); if (!ntdb) failtest_exit(exit_status()); ok1(ntdb_get_flags(ntdb) == (flags[i]|MAYBE_NOSYNC)); ntdb_close(ntdb); } failtest_exit(exit_status()); }
static int dump_ntdb(const char *fname, const char *keyname) { struct ntdb_context *ntdb; NTDB_DATA key, value; ntdb = ntdb_open(fname, 0, O_RDONLY, 0, NULL); if (!ntdb) { printf("Failed to open %s\n", fname); return 1; } if (!keyname) { ntdb_traverse(ntdb, traverse_fn, NULL); } else { key = ntdb_mkdata(keyname, strlen(keyname)); if (ntdb_fetch(ntdb, key, &value) != 0) { return 1; } else { print_data(value); free(value.dptr); } } return 0; }
int main(int argc, char *argv[]) { unsigned int i; struct ntdb_context *ntdb; int flags[] = { NTDB_INTERNAL, NTDB_DEFAULT, NTDB_NOMMAP, NTDB_INTERNAL|NTDB_CONVERT, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; NTDB_DATA key = ntdb_mkdata("key", 3); NTDB_DATA data = ntdb_mkdata("data", 4); plan_tests(sizeof(flags) / sizeof(flags[0]) * 7 + 1); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { ntdb = ntdb_open("run-simple-delete.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); ok1(ntdb); if (ntdb) { /* Delete should fail. */ ok1(ntdb_delete(ntdb, key) == NTDB_ERR_NOEXIST); ok1(ntdb_check(ntdb, NULL, NULL) == 0); /* Insert should succeed. */ ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == 0); ok1(ntdb_check(ntdb, NULL, NULL) == 0); /* Delete should now work. */ ok1(ntdb_delete(ntdb, key) == 0); ok1(ntdb_check(ntdb, NULL, NULL) == 0); ntdb_close(ntdb); } } ok1(tap_log_messages == 0); return exit_status(); }
int main(int argc, char *argv[]) { unsigned int i; struct ntdb_context *ntdb; int flags[] = { NTDB_INTERNAL, NTDB_DEFAULT, NTDB_NOMMAP, NTDB_INTERNAL|NTDB_CONVERT, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; failtest_init(argc, argv); failtest_hook = block_repeat_failures; failtest_exit_check = exit_check_log; plan_tests(sizeof(flags) / sizeof(flags[0]) * 3); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { ntdb = ntdb_open("run-new_database.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); if (!ok1(ntdb)) failtest_exit(exit_status()); failtest_suppress = true; ok1(ntdb_check(ntdb, NULL, NULL) == 0); failtest_suppress = false; ntdb_close(ntdb); if (!ok1(tap_log_messages == 0)) break; } failtest_exit(exit_status()); /* * We will never reach this but the compiler complains if we do not * return in this function. */ return EFAULT; }
int main(int argc, char *argv[]) { unsigned int i; bool found[NUM_TESTS]; struct ntdb_context *ntdb; int flags[] = { NTDB_DEFAULT, NTDB_NOMMAP, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; plan_tests(sizeof(flags) / sizeof(flags[0]) * 6 + 1); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { ntdb = ntdb_open("run-93-repack.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); ok1(ntdb); if (!ntdb) break; ok1(store_all(ntdb)); ok1(ntdb_repack(ntdb) == NTDB_SUCCESS); memset(found, 0, sizeof(found)); ok1(ntdb_check(ntdb, NULL, NULL) == NTDB_SUCCESS); ok1(ntdb_traverse(ntdb, mark_entry, found) == NUM_TESTS); ok1(is_all_set(found, NUM_TESTS)); ntdb_close(ntdb); } ok1(tap_log_messages == 0); return exit_status(); }
int main(int argc, char *argv[]) { unsigned int i; struct agent *agent; struct ntdb_context *ntdb; NTDB_DATA d = ntdb_mkdata("hello", 5); const char filename[] = "run-remap-in-read_traverse.ntdb"; plan_tests(4); agent = prepare_external_agent(); ntdb = ntdb_open(filename, MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); ok1(external_agent_operation(agent, OPEN, filename) == SUCCESS); i = add_records_to_grow(agent, ntdb->file->fd, ntdb->file->map_size); /* Do a traverse. */ ok1(ntdb_traverse(ntdb, NULL, NULL) == i); /* Now store something! */ ok1(ntdb_store(ntdb, d, d, NTDB_INSERT) == 0); ok1(tap_log_messages == 0); ntdb_close(ntdb); free_external_agent(agent); return exit_status(); }
int main(int argc, char *argv[]) { unsigned int i; uint64_t val; struct ntdb_context *ntdb; int flags[] = { NTDB_INTERNAL, NTDB_DEFAULT, NTDB_NOMMAP, NTDB_INTERNAL|NTDB_CONVERT, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; plan_tests(sizeof(flags) / sizeof(flags[0]) * 11 + 1); failtest_init(argc, argv); failtest_hook = block_repeat_failures; failtest_exit_check = exit_check_log; for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { failtest_suppress = true; ntdb = ntdb_open("run-expand.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); if (!ok1(ntdb)) break; val = ntdb->file->map_size; /* Need some hash lock for expand. */ ok1(ntdb_lock_hash(ntdb, 0, F_WRLCK) == 0); failtest_suppress = false; if (!ok1(ntdb_expand(ntdb, 1) == 0)) { failtest_suppress = true; ntdb_close(ntdb); break; } failtest_suppress = true; ok1(ntdb->file->map_size >= val + 1 * NTDB_EXTENSION_FACTOR); ok1(ntdb_unlock_hash(ntdb, 0, F_WRLCK) == 0); ok1(ntdb_check(ntdb, NULL, NULL) == 0); val = ntdb->file->map_size; ok1(ntdb_lock_hash(ntdb, 0, F_WRLCK) == 0); failtest_suppress = false; if (!ok1(ntdb_expand(ntdb, 1024) == 0)) { failtest_suppress = true; ntdb_close(ntdb); break; } failtest_suppress = true; ok1(ntdb_unlock_hash(ntdb, 0, F_WRLCK) == 0); ok1(ntdb->file->map_size >= val + 1024 * NTDB_EXTENSION_FACTOR); ok1(ntdb_check(ntdb, NULL, NULL) == 0); ntdb_close(ntdb); } ok1(tap_log_messages == 0); failtest_exit(exit_status()); }
int main(int argc, char *argv[]) { unsigned int i; struct ntdb_context *ntdb; int flags[] = { NTDB_DEFAULT, NTDB_NOMMAP, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; plan_tests(sizeof(flags) / sizeof(flags[0]) * 11); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { union ntdb_attribute *attr; NTDB_DATA key = ntdb_mkdata("key", 3), data; ntdb = ntdb_open("run-91-get-stats.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); ok1(ntdb); /* Force an expansion */ data.dsize = 65536; data.dptr = calloc(data.dsize, 1); ok1(ntdb_store(ntdb, key, data, NTDB_REPLACE) == 0); free(data.dptr); /* Use malloc so valgrind will catch overruns. */ attr = malloc(sizeof *attr); attr->stats.base.attr = NTDB_ATTRIBUTE_STATS; attr->stats.size = sizeof(*attr); ok1(ntdb_get_attribute(ntdb, attr) == 0); ok1(attr->stats.size == sizeof(*attr)); ok1(attr->stats.allocs > 0); ok1(attr->stats.expands > 0); ok1(attr->stats.locks > 0); free(attr); /* Try short one. */ attr = malloc(offsetof(struct ntdb_attribute_stats, allocs) + sizeof(attr->stats.allocs)); attr->stats.base.attr = NTDB_ATTRIBUTE_STATS; attr->stats.size = offsetof(struct ntdb_attribute_stats, allocs) + sizeof(attr->stats.allocs); ok1(ntdb_get_attribute(ntdb, attr) == 0); ok1(attr->stats.size == sizeof(*attr)); ok1(attr->stats.allocs > 0); free(attr); ok1(tap_log_messages == 0); ntdb_close(ntdb); } return exit_status(); }
static void open_ntdb(const char *tdbname) { union ntdb_attribute log_attr; log_attr.base.attr = NTDB_ATTRIBUTE_LOG; log_attr.base.next = NULL; log_attr.log.fn = ntdb_log; if (ntdb) ntdb_close(ntdb); ntdb = ntdb_open(tdbname, disable_mmap?NTDB_NOMMAP:0, O_RDWR, 0600, &log_attr); if (!ntdb) { printf("Could not open %s: %s\n", tdbname, strerror(errno)); } }
int main(int argc, char *argv[]) { unsigned int i, j; struct ntdb_context *ntdb; int flags[] = { NTDB_INTERNAL, NTDB_DEFAULT, NTDB_NOMMAP, NTDB_INTERNAL|NTDB_CONVERT, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; NTDB_DATA key = { (unsigned char *)&j, sizeof(j) }; NTDB_DATA data = { (unsigned char *)&j, sizeof(j) }; char *summary; plan_tests(sizeof(flags) / sizeof(flags[0]) * (1 + 2 * 5) + 1); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { ntdb = ntdb_open("run-summary.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); ok1(ntdb); if (!ntdb) continue; /* Put some stuff in there. */ for (j = 0; j < 500; j++) { /* Make sure padding varies to we get some graphs! */ data.dsize = j % (sizeof(j) + 1); if (ntdb_store(ntdb, key, data, NTDB_REPLACE) != 0) fail("Storing in ntdb"); } for (j = 0; j <= NTDB_SUMMARY_HISTOGRAMS; j += NTDB_SUMMARY_HISTOGRAMS) { ok1(ntdb_summary(ntdb, j, &summary) == NTDB_SUCCESS); ok1(strstr(summary, "Number of records: 500\n")); ok1(strstr(summary, "Smallest/average/largest keys: 4/4/4\n")); ok1(strstr(summary, "Smallest/average/largest data: 0/2/4\n")); if (j == NTDB_SUMMARY_HISTOGRAMS) { ok1(strstr(summary, "|") && strstr(summary, "*")); } else { ok1(!strstr(summary, "|") && !strstr(summary, "*")); } free(summary); } ntdb_close(ntdb); } ok1(tap_log_messages == 0); return exit_status(); }
int main(int argc, char *argv[]) { unsigned int i, j; union ntdb_attribute alloc_attr; struct ntdb_context *ntdb; int flags[] = { NTDB_INTERNAL, NTDB_DEFAULT, NTDB_NOMMAP, NTDB_INTERNAL|NTDB_CONVERT, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; NTDB_DATA key = { (unsigned char *)&j, sizeof(j) }; NTDB_DATA data = { (unsigned char *)&j, sizeof(j) }; alloc_attr.base.next = &tap_log_attr; alloc_attr.base.attr = NTDB_ATTRIBUTE_ALLOCATOR; alloc_attr.alloc.alloc = test_alloc; alloc_attr.alloc.expand = test_expand; alloc_attr.alloc.free = test_free; alloc_attr.alloc.priv_data = &owner_weird_count; plan_tests(sizeof(flags) / sizeof(flags[0]) * (1 + 700 * 3 + 4) + 1); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { curr_ntdb = NULL; curr_file = NULL; ntdb = ntdb_open("run-12-store.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &alloc_attr); ok1(ntdb); if (!ntdb) continue; for (j = 0; j < 700; j++) { NTDB_DATA d = { NULL, 0 }; /* Bogus GCC warning */ ok1(ntdb_store(ntdb, key, data, NTDB_REPLACE) == 0); ok1(ntdb_fetch(ntdb, key, &d) == NTDB_SUCCESS); ok1(ntdb_deq(d, data)); test_free(d.dptr, &owner_weird_count); } ntdb_close(ntdb); ok1(owner_null_count == 2+i*2); ok1(owner_weird_count == 0); ok1(alloc_count == free_count); ok1(expand_count != 0); } ok1(tap_log_messages == 0); return exit_status(); }
int main(int argc, char *argv[]) { unsigned int i; int flags[] = { NTDB_DEFAULT, NTDB_NOMMAP, NTDB_CONVERT }; NTDB_DATA key = ntdb_mkdata("hello", 5), data = ntdb_mkdata("world", 5); plan_tests(sizeof(flags) / sizeof(flags[0]) * 2 + 1); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { ntdb = ntdb_open("api-95-read-only-during-parse.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == NTDB_SUCCESS); ok1(ntdb_parse_record(ntdb, key, parse, &data) == NTDB_SUCCESS); ntdb_close(ntdb); } ok1(tap_log_messages == 0); return exit_status(); }
_PUBLIC_ enum NTDB_ERROR ntdb_repack(struct ntdb_context *ntdb) { struct ntdb_context *tmp_db; struct traverse_state state; state.error = ntdb_transaction_start(ntdb); if (state.error != NTDB_SUCCESS) { return state.error; } tmp_db = ntdb_open("tmpdb", NTDB_INTERNAL, O_RDWR|O_CREAT, 0, NULL); if (tmp_db == NULL) { state.error = ntdb_logerr(ntdb, NTDB_ERR_OOM, NTDB_LOG_ERROR, __location__ " Failed to create tmp_db"); ntdb_transaction_cancel(ntdb); return state.error; } state.dest_db = tmp_db; if (ntdb_traverse(ntdb, repack_traverse, &state) < 0) { goto fail; } state.error = ntdb_wipe_all(ntdb); if (state.error != NTDB_SUCCESS) { goto fail; } state.dest_db = ntdb; if (ntdb_traverse(tmp_db, repack_traverse, &state) < 0) { goto fail; } ntdb_close(tmp_db); return ntdb_transaction_commit(ntdb); fail: ntdb_transaction_cancel(ntdb); ntdb_close(tmp_db); return state.error; }
static void move_rec(char *keyname, size_t keylen, char* tdbname) { NTDB_DATA key, dbuf; struct ntdb_context *dst_ntdb; enum NTDB_ERROR ecode; if ((keyname == NULL) || (keylen == 0)) { terror(NTDB_SUCCESS, "need key"); return; } if ( !tdbname ) { terror(NTDB_SUCCESS, "need destination ntdb name"); return; } key.dptr = (unsigned char *)keyname; key.dsize = keylen; ecode = ntdb_fetch(ntdb, key, &dbuf); if (ecode) { terror(ecode, "fetch failed"); return; } print_rec(ntdb, key, dbuf, NULL); dst_ntdb = ntdb_open(tdbname, 0, O_RDWR, 0600, NULL); if ( !dst_ntdb ) { terror(NTDB_SUCCESS, "unable to open destination ntdb"); return; } ecode = ntdb_store( dst_ntdb, key, dbuf, NTDB_REPLACE); if (ecode) terror(ecode, "failed to move record"); else printf("record moved\n"); ntdb_close( dst_ntdb ); }
int main(int argc, char *argv[]) { unsigned int i; struct ntdb_context *ntdb; int flags[] = { NTDB_INTERNAL, NTDB_DEFAULT, NTDB_NOMMAP, NTDB_INTERNAL|NTDB_CONVERT, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; NTDB_DATA key = ntdb_mkdata("key", 3); NTDB_DATA data; data.dptr = malloc(MAX_SIZE); memset(data.dptr, 0x24, MAX_SIZE); plan_tests(sizeof(flags) / sizeof(flags[0]) * (3 + (1 + (MAX_SIZE/SIZE_STEP)) * 2) + 1); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { ntdb = ntdb_open("run-record-expand.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); ok1(ntdb); if (!ntdb) continue; data.dsize = 0; ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == 0); ok1(ntdb_check(ntdb, NULL, NULL) == 0); for (data.dsize = 0; data.dsize < MAX_SIZE; data.dsize += SIZE_STEP) { memset(data.dptr, data.dsize, data.dsize); ok1(ntdb_store(ntdb, key, data, NTDB_MODIFY) == 0); ok1(ntdb_check(ntdb, NULL, NULL) == 0); } ntdb_close(ntdb); } ok1(tap_log_messages == 0); free(data.dptr); return exit_status(); }
int main(int argc, char *argv[]) { const int flags[] = { NTDB_DEFAULT, NTDB_NOMMAP, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; int i; struct ntdb_context *ntdb; NTDB_DATA key, data; plan_tests(sizeof(flags)/sizeof(flags[0]) * 5); agent = prepare_external_agent(); if (!agent) err(1, "preparing agent"); unlock_callback = after_unlock; for (i = 0; i < sizeof(flags)/sizeof(flags[0]); i++) { diag("Test with %s and %s\n", (flags[i] & NTDB_CONVERT) ? "CONVERT" : "DEFAULT", (flags[i] & NTDB_NOMMAP) ? "no mmap" : "mmap"); unlink(TEST_DBNAME); ntdb = ntdb_open(TEST_DBNAME, flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); ok1(ntdb); opened = true; ok1(ntdb_transaction_start(ntdb) == 0); key = ntdb_mkdata("hi", strlen("hi")); data = ntdb_mkdata("world", strlen("world")); ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == 0); ok1(ntdb_transaction_commit(ntdb) == 0); ok(!errors, "We had %u open errors", errors); opened = false; ntdb_close(ntdb); } return exit_status(); }
int main(int argc, char *argv[]) { unsigned int i; struct ntdb_context *ntdb; int flags[] = { NTDB_INTERNAL, NTDB_INTERNAL|NTDB_CONVERT, NTDB_CONVERT }; NTDB_DATA key = ntdb_mkdata("key", 3); NTDB_DATA data = ntdb_mkdata("data", 4); failtest_init(argc, argv); failtest_hook = block_repeat_failures; failtest_exit_check = exit_check_log; failtest_suppress = true; plan_tests(sizeof(flags) / sizeof(flags[0]) * 3 + 1); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { ntdb = ntdb_open("run-12-check.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); ok1(ntdb); ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == 0); /* This is what we really want to test: ntdb_check(). */ failtest_suppress = false; if (!ok1(ntdb_check(ntdb, NULL, NULL) == 0)) goto fail; failtest_suppress = true; ntdb_close(ntdb); } ok1(tap_log_messages == 0); failtest_exit(exit_status()); fail: failtest_suppress = true; ntdb_close(ntdb); failtest_exit(exit_status()); }
int main(int argc, char *argv[]) { unsigned int i; struct ntdb_context *ntdb; int flags[] = { NTDB_INTERNAL, NTDB_DEFAULT, NTDB_NOMMAP, NTDB_INTERNAL|NTDB_CONVERT, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; plan_tests(sizeof(flags) / sizeof(flags[0]) * 3); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { ntdb = ntdb_open("api-80-ntdb_fd.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); if (!ok1(ntdb)) continue; if (flags[i] & NTDB_INTERNAL) ok1(ntdb_fd(ntdb) == -1); else ok1(ntdb_fd(ntdb) > 2); ntdb_close(ntdb); ok1(tap_log_messages == 0); } return exit_status(); }
int main(int argc, char *argv[]) { unsigned int i, seq; struct ntdb_context *ntdb; NTDB_DATA d = { NULL, 0 }; /* Bogus GCC warning */ NTDB_DATA key = ntdb_mkdata("key", 3); NTDB_DATA data = ntdb_mkdata("data", 4); int flags[] = { NTDB_INTERNAL, NTDB_DEFAULT, NTDB_NOMMAP, NTDB_INTERNAL|NTDB_CONVERT, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; plan_tests(sizeof(flags) / sizeof(flags[0]) * 15 + 4 * 13); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { ntdb = ntdb_open("api-81-seqnum.ntdb", flags[i]|NTDB_SEQNUM|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); if (!ok1(ntdb)) continue; seq = 0; ok1(ntdb_get_seqnum(ntdb) == seq); ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == 0); ok1(ntdb_get_seqnum(ntdb) == ++seq); /* Fetch doesn't change seqnum */ if (ok1(ntdb_fetch(ntdb, key, &d) == NTDB_SUCCESS)) free(d.dptr); ok1(ntdb_get_seqnum(ntdb) == seq); ok1(ntdb_append(ntdb, key, data) == NTDB_SUCCESS); ok1(ntdb_get_seqnum(ntdb) == ++seq); ok1(ntdb_delete(ntdb, key) == NTDB_SUCCESS); ok1(ntdb_get_seqnum(ntdb) == ++seq); /* Empty append works */ ok1(ntdb_append(ntdb, key, data) == NTDB_SUCCESS); ok1(ntdb_get_seqnum(ntdb) == ++seq); ok1(ntdb_wipe_all(ntdb) == NTDB_SUCCESS); ok1(ntdb_get_seqnum(ntdb) == ++seq); if (!(flags[i] & NTDB_INTERNAL)) { ok1(ntdb_transaction_start(ntdb) == NTDB_SUCCESS); ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == 0); ok1(ntdb_get_seqnum(ntdb) == ++seq); ok1(ntdb_append(ntdb, key, data) == NTDB_SUCCESS); ok1(ntdb_get_seqnum(ntdb) == ++seq); ok1(ntdb_delete(ntdb, key) == NTDB_SUCCESS); ok1(ntdb_get_seqnum(ntdb) == ++seq); ok1(ntdb_transaction_commit(ntdb) == NTDB_SUCCESS); ok1(ntdb_get_seqnum(ntdb) == seq); ok1(ntdb_transaction_start(ntdb) == NTDB_SUCCESS); ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == 0); ok1(ntdb_get_seqnum(ntdb) == seq + 1); ntdb_transaction_cancel(ntdb); ok1(ntdb_get_seqnum(ntdb) == seq); } ntdb_close(ntdb); ok1(tap_log_messages == 0); } return exit_status(); }
int main(int argc, char *argv[]) { unsigned int i; struct ntdb_context *ntdb; int flags[] = { NTDB_DEFAULT, NTDB_NOMMAP, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; NTDB_DATA key = ntdb_mkdata("key", 3); NTDB_DATA data = ntdb_mkdata("data", 4), d; union ntdb_attribute seed_attr; unsigned int msgs = 0; failtest_init(argc, argv); failtest_hook = block_repeat_failures; failtest_exit_check = exit_check_log; seed_attr.base.attr = NTDB_ATTRIBUTE_SEED; seed_attr.base.next = &tap_log_attr; seed_attr.seed.seed = 0; failtest_suppress = true; plan_tests(sizeof(flags) / sizeof(flags[0]) * 11); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { ntdb = ntdb_open("run-05-readonly-open.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &seed_attr); ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == 0); ntdb_close(ntdb); failtest_suppress = false; ntdb = ntdb_open("run-05-readonly-open.ntdb", flags[i]|MAYBE_NOSYNC, O_RDONLY, 0600, &tap_log_attr); if (!ok1(ntdb)) break; ok1(tap_log_messages == msgs); /* Fetch should succeed, stores should fail. */ if (!ok1(ntdb_fetch(ntdb, key, &d) == 0)) goto fail; ok1(ntdb_deq(d, data)); free(d.dptr); if (!ok1(ntdb_store(ntdb, key, data, NTDB_MODIFY) == NTDB_ERR_RDONLY)) goto fail; ok1(tap_log_messages == ++msgs); if (!ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == NTDB_ERR_RDONLY)) goto fail; ok1(tap_log_messages == ++msgs); failtest_suppress = true; ok1(ntdb_check(ntdb, NULL, NULL) == 0); ntdb_close(ntdb); ok1(tap_log_messages == msgs); /* SIGH: failtest bug, it doesn't save the ntdb file because * we have it read-only. If we go around again, it gets * changed underneath us and things get screwy. */ if (failtest_has_failed()) break; } failtest_exit(exit_status()); fail: failtest_suppress = true; ntdb_close(ntdb); failtest_exit(exit_status()); }
int main(int argc, char *argv[]) { unsigned int i; struct ntdb_context *ntdb; int flags[] = { NTDB_DEFAULT, NTDB_NOMMAP, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; NTDB_DATA key = ntdb_mkdata("key", 3); NTDB_DATA data = ntdb_mkdata("data", 4); plan_tests(sizeof(flags) / sizeof(flags[0]) * 14); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { int status; tap_log_messages = 0; ntdb = ntdb_open("run-fork-test.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); if (!ok1(ntdb)) continue; /* Put a record in here. */ ok1(ntdb_store(ntdb, key, data, NTDB_REPLACE) == NTDB_SUCCESS); ok1(ntdb_chainlock(ntdb, key) == NTDB_SUCCESS); if (fork() == 0) { /* We expect this to fail. */ if (ntdb_store(ntdb, key, data, NTDB_REPLACE) != NTDB_ERR_LOCK) return 1; if (ntdb_fetch(ntdb, key, &data) != NTDB_ERR_LOCK) return 1; if (tap_log_messages != 2) return 2; /* Child can do this without any complaints. */ ntdb_chainunlock(ntdb, key); if (tap_log_messages != 2) return 3; ntdb_close(ntdb); if (tap_log_messages != 2) return 4; return 0; } wait(&status); ok1(WIFEXITED(status) && WEXITSTATUS(status) == 0); ntdb_chainunlock(ntdb, key); ok1(ntdb_lockall(ntdb) == NTDB_SUCCESS); if (fork() == 0) { /* We expect this to fail. */ if (ntdb_store(ntdb, key, data, NTDB_REPLACE) != NTDB_ERR_LOCK) return 1; if (ntdb_fetch(ntdb, key, &data) != NTDB_ERR_LOCK) return 1; if (tap_log_messages != 2) return 2; /* Child can do this without any complaints. */ ntdb_unlockall(ntdb); if (tap_log_messages != 2) return 3; ntdb_close(ntdb); if (tap_log_messages != 2) return 4; return 0; } wait(&status); ok1(WIFEXITED(status) && WEXITSTATUS(status) == 0); ntdb_unlockall(ntdb); ok1(ntdb_lockall_read(ntdb) == NTDB_SUCCESS); if (fork() == 0) { /* We expect this to fail. */ /* This would always fail anyway... */ if (ntdb_store(ntdb, key, data, NTDB_REPLACE) != NTDB_ERR_LOCK) return 1; if (ntdb_fetch(ntdb, key, &data) != NTDB_ERR_LOCK) return 1; if (tap_log_messages != 2) return 2; /* Child can do this without any complaints. */ ntdb_unlockall_read(ntdb); if (tap_log_messages != 2) return 3; ntdb_close(ntdb); if (tap_log_messages != 2) return 4; return 0; } wait(&status); ok1(WIFEXITED(status) && WEXITSTATUS(status) == 0); ntdb_unlockall_read(ntdb); ok1(ntdb_transaction_start(ntdb) == NTDB_SUCCESS); /* If transactions is empty, noop "commit" succeeds. */ ok1(ntdb_delete(ntdb, key) == NTDB_SUCCESS); if (fork() == 0) { int last_log_messages; /* We expect this to fail. */ if (ntdb_store(ntdb, key, data, NTDB_REPLACE) != NTDB_ERR_LOCK) return 1; if (ntdb_fetch(ntdb, key, &data) != NTDB_ERR_LOCK) return 1; if (tap_log_messages != 2) return 2; if (ntdb_transaction_prepare_commit(ntdb) != NTDB_ERR_LOCK) return 3; if (tap_log_messages == 2) return 4; last_log_messages = tap_log_messages; /* Child can do this without any complaints. */ ntdb_transaction_cancel(ntdb); if (tap_log_messages != last_log_messages) return 4; ntdb_close(ntdb); if (tap_log_messages != last_log_messages) return 4; return 0; } wait(&status); ok1(WIFEXITED(status) && WEXITSTATUS(status) == 0); ntdb_transaction_cancel(ntdb); ok1(ntdb_parse_record(ntdb, key, fork_in_parse, ntdb) == NTDB_SUCCESS); ntdb_close(ntdb); if (am_child) { /* Child can return from parse without complaints. */ if (tap_log_messages != 2) exit(3); exit(0); } ok1(tap_log_messages == 0); } return exit_status(); }
int main(int argc, char *argv[]) { unsigned int i; struct ntdb_context *ntdb; NTDB_DATA key = ntdb_mkdata("key", 3); NTDB_DATA data = ntdb_mkdata("data", 4); int flags[] = { NTDB_DEFAULT, NTDB_NOMMAP, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; plan_tests(sizeof(flags) / sizeof(flags[0]) * 48); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { /* RW -> R0 */ ntdb = ntdb_open("run-92-get-set-readonly.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); ok1(ntdb); ok1(!(ntdb_get_flags(ntdb) & NTDB_RDONLY)); ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == NTDB_SUCCESS); ntdb_add_flag(ntdb, NTDB_RDONLY); ok1(ntdb_get_flags(ntdb) & NTDB_RDONLY); /* Can't store, append, delete. */ ok1(ntdb_store(ntdb, key, data, NTDB_MODIFY) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 1); ok1(ntdb_append(ntdb, key, data) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 2); ok1(ntdb_delete(ntdb, key) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 3); /* Can't start a transaction, or any write lock. */ ok1(ntdb_transaction_start(ntdb) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 4); ok1(ntdb_chainlock(ntdb, key) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 5); ok1(ntdb_lockall(ntdb) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 6); ok1(ntdb_wipe_all(ntdb) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 7); /* Back to RW. */ ntdb_remove_flag(ntdb, NTDB_RDONLY); ok1(!(ntdb_get_flags(ntdb) & NTDB_RDONLY)); ok1(ntdb_store(ntdb, key, data, NTDB_MODIFY) == NTDB_SUCCESS); ok1(ntdb_append(ntdb, key, data) == NTDB_SUCCESS); ok1(ntdb_delete(ntdb, key) == NTDB_SUCCESS); ok1(ntdb_transaction_start(ntdb) == NTDB_SUCCESS); ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == NTDB_SUCCESS); ok1(ntdb_transaction_commit(ntdb) == NTDB_SUCCESS); ok1(ntdb_chainlock(ntdb, key) == NTDB_SUCCESS); ntdb_chainunlock(ntdb, key); ok1(ntdb_lockall(ntdb) == NTDB_SUCCESS); ntdb_unlockall(ntdb); ok1(ntdb_wipe_all(ntdb) == NTDB_SUCCESS); ok1(tap_log_messages == 7); ntdb_close(ntdb); /* R0 -> RW */ ntdb = ntdb_open("run-92-get-set-readonly.ntdb", flags[i]|MAYBE_NOSYNC, O_RDONLY, 0600, &tap_log_attr); ok1(ntdb); ok1(ntdb_get_flags(ntdb) & NTDB_RDONLY); /* Can't store, append, delete. */ ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 8); ok1(ntdb_append(ntdb, key, data) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 9); ok1(ntdb_delete(ntdb, key) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 10); /* Can't start a transaction, or any write lock. */ ok1(ntdb_transaction_start(ntdb) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 11); ok1(ntdb_chainlock(ntdb, key) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 12); ok1(ntdb_lockall(ntdb) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 13); ok1(ntdb_wipe_all(ntdb) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 14); /* Can't remove NTDB_RDONLY since we opened with O_RDONLY */ ntdb_remove_flag(ntdb, NTDB_RDONLY); ok1(tap_log_messages == 15); ok1(ntdb_get_flags(ntdb) & NTDB_RDONLY); ntdb_close(ntdb); ok1(tap_log_messages == 15); tap_log_messages = 0; } return exit_status(); }
int main(int argc, char *argv[]) { unsigned int i; struct ntdb_context *ntdb; unsigned char *buffer; int flags[] = { NTDB_DEFAULT, NTDB_NOMMAP, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; NTDB_DATA key = ntdb_mkdata("key", 3); NTDB_DATA data; buffer = malloc(1000); for (i = 0; i < 1000; i++) buffer[i] = i; plan_tests(sizeof(flags) / sizeof(flags[0]) * 20 + 1); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { ntdb = ntdb_open("run-55-transaction.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); ok1(ntdb); if (!ntdb) continue; ok1(ntdb_transaction_start(ntdb) == 0); data.dptr = buffer; data.dsize = 1000; ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == 0); ok1(ntdb_fetch(ntdb, key, &data) == NTDB_SUCCESS); ok1(data.dsize == 1000); ok1(memcmp(data.dptr, buffer, data.dsize) == 0); free(data.dptr); /* Cancelling a transaction means no store */ ntdb_transaction_cancel(ntdb); ok1(ntdb->file->allrecord_lock.count == 0 && ntdb->file->num_lockrecs == 0); ok1(ntdb_check(ntdb, NULL, NULL) == 0); ok1(ntdb_fetch(ntdb, key, &data) == NTDB_ERR_NOEXIST); /* Commit the transaction. */ ok1(ntdb_transaction_start(ntdb) == 0); data.dptr = buffer; data.dsize = 1000; ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == 0); ok1(ntdb_fetch(ntdb, key, &data) == NTDB_SUCCESS); ok1(data.dsize == 1000); ok1(memcmp(data.dptr, buffer, data.dsize) == 0); free(data.dptr); ok1(ntdb_transaction_commit(ntdb) == 0); ok1(ntdb->file->allrecord_lock.count == 0 && ntdb->file->num_lockrecs == 0); ok1(ntdb_check(ntdb, NULL, NULL) == 0); ok1(ntdb_fetch(ntdb, key, &data) == NTDB_SUCCESS); ok1(data.dsize == 1000); ok1(memcmp(data.dptr, buffer, data.dsize) == 0); free(data.dptr); ntdb_close(ntdb); } ok1(tap_log_messages == 0); free(buffer); return exit_status(); }
static enum agent_return do_operation(enum operation op, const char *name) { NTDB_DATA k, d; enum agent_return ret; NTDB_DATA data; enum NTDB_ERROR ecode; union ntdb_attribute cif; const char *eq; if (op != OPEN && op != OPEN_WITH_HOOK && !ntdb) { diag("external: No ntdb open!"); return OTHER_FAILURE; } diag("external: %s", operation_name(op)); eq = strchr(name, '='); if (eq) { k = ntdb_mkdata(name, eq - name); d = ntdb_mkdata(eq + 1, strlen(eq+1)); } else { k = ntdb_mkdata(name, strlen(name)); d.dsize = 0; d.dptr = NULL; } locking_would_block = 0; switch (op) { case OPEN: if (ntdb) { diag("Already have ntdb %s open", ntdb_name(ntdb)); return OTHER_FAILURE; } ntdb = ntdb_open(name, MAYBE_NOSYNC, O_RDWR, 0, &tap_log_attr); if (!ntdb) { if (!locking_would_block) diag("Opening ntdb gave %s", strerror(errno)); forget_locking(); ret = OTHER_FAILURE; } else ret = SUCCESS; break; case OPEN_WITH_HOOK: if (ntdb) { diag("Already have ntdb %s open", ntdb_name(ntdb)); return OTHER_FAILURE; } cif.openhook.base.attr = NTDB_ATTRIBUTE_OPENHOOK; cif.openhook.base.next = &tap_log_attr; cif.openhook.fn = clear_if_first; ntdb = ntdb_open(name, MAYBE_NOSYNC, O_RDWR, 0, &cif); if (!ntdb) { if (!locking_would_block) diag("Opening ntdb gave %s", strerror(errno)); forget_locking(); ret = OTHER_FAILURE; } else ret = SUCCESS; break; case FETCH: ecode = ntdb_fetch(ntdb, k, &data); if (ecode == NTDB_ERR_NOEXIST) { ret = FAILED; } else if (ecode < 0) { ret = OTHER_FAILURE; } else if (!ntdb_deq(data, d)) { ret = OTHER_FAILURE; external_agent_free(data.dptr); } else { ret = SUCCESS; external_agent_free(data.dptr); } break; case STORE: ret = ntdb_store(ntdb, k, d, 0) == 0 ? SUCCESS : OTHER_FAILURE; break; case TRANSACTION_START: ret = ntdb_transaction_start(ntdb) == 0 ? SUCCESS : OTHER_FAILURE; break; case TRANSACTION_COMMIT: ret = ntdb_transaction_commit(ntdb)==0 ? SUCCESS : OTHER_FAILURE; break; case NEEDS_RECOVERY: ret = external_agent_needs_rec(ntdb); break; case CHECK: ret = ntdb_check(ntdb, NULL, NULL) == 0 ? SUCCESS : OTHER_FAILURE; break; case CLOSE: ret = ntdb_close(ntdb) == 0 ? SUCCESS : OTHER_FAILURE; ntdb = NULL; break; case SEND_SIGNAL: /* We do this async */ ret = SUCCESS; break; default: ret = OTHER_FAILURE; } if (locking_would_block) ret = WOULD_HAVE_BLOCKED; return ret; }
static void dump_and_clear_stats(struct ntdb_context **ntdb, int flags, union ntdb_attribute *attr) { union ntdb_attribute stats; enum NTDB_ERROR ecode; stats.base.attr = NTDB_ATTRIBUTE_STATS; stats.stats.size = sizeof(stats.stats); ecode = ntdb_get_attribute(*ntdb, &stats); if (ecode != NTDB_SUCCESS) errx(1, "Getting stats: %s", ntdb_errorstr(ecode)); printf("allocs = %llu\n", (unsigned long long)stats.stats.allocs); printf(" alloc_subhash = %llu\n", (unsigned long long)stats.stats.alloc_subhash); printf(" alloc_chain = %llu\n", (unsigned long long)stats.stats.alloc_chain); printf(" alloc_bucket_exact = %llu\n", (unsigned long long)stats.stats.alloc_bucket_exact); printf(" alloc_bucket_max = %llu\n", (unsigned long long)stats.stats.alloc_bucket_max); printf(" alloc_leftover = %llu\n", (unsigned long long)stats.stats.alloc_leftover); printf(" alloc_coalesce_tried = %llu\n", (unsigned long long)stats.stats.alloc_coalesce_tried); printf(" alloc_coalesce_iterate_clash = %llu\n", (unsigned long long)stats.stats.alloc_coalesce_iterate_clash); printf(" alloc_coalesce_lockfail = %llu\n", (unsigned long long)stats.stats.alloc_coalesce_lockfail); printf(" alloc_coalesce_race = %llu\n", (unsigned long long)stats.stats.alloc_coalesce_race); printf(" alloc_coalesce_succeeded = %llu\n", (unsigned long long)stats.stats.alloc_coalesce_succeeded); printf(" alloc_coalesce_num_merged = %llu\n", (unsigned long long)stats.stats.alloc_coalesce_num_merged); printf("compares = %llu\n", (unsigned long long)stats.stats.compares); printf(" compare_wrong_offsetbits = %llu\n", (unsigned long long)stats.stats.compare_wrong_offsetbits); printf(" compare_wrong_keylen = %llu\n", (unsigned long long)stats.stats.compare_wrong_keylen); printf(" compare_wrong_rechash = %llu\n", (unsigned long long)stats.stats.compare_wrong_rechash); printf(" compare_wrong_keycmp = %llu\n", (unsigned long long)stats.stats.compare_wrong_keycmp); printf("transactions = %llu\n", (unsigned long long)stats.stats.transactions); printf(" transaction_cancel = %llu\n", (unsigned long long)stats.stats.transaction_cancel); printf(" transaction_nest = %llu\n", (unsigned long long)stats.stats.transaction_nest); printf(" transaction_expand_file = %llu\n", (unsigned long long)stats.stats.transaction_expand_file); printf(" transaction_read_direct = %llu\n", (unsigned long long)stats.stats.transaction_read_direct); printf(" transaction_read_direct_fail = %llu\n", (unsigned long long)stats.stats.transaction_read_direct_fail); printf(" transaction_write_direct = %llu\n", (unsigned long long)stats.stats.transaction_write_direct); printf(" transaction_write_direct_fail = %llu\n", (unsigned long long)stats.stats.transaction_write_direct_fail); printf("expands = %llu\n", (unsigned long long)stats.stats.expands); printf("frees = %llu\n", (unsigned long long)stats.stats.frees); printf("locks = %llu\n", (unsigned long long)stats.stats.locks); printf(" lock_lowlevel = %llu\n", (unsigned long long)stats.stats.lock_lowlevel); printf(" lock_nonblock = %llu\n", (unsigned long long)stats.stats.lock_nonblock); printf(" lock_nonblock_fail = %llu\n", (unsigned long long)stats.stats.lock_nonblock_fail); /* Now clear. */ ntdb_close(*ntdb); *ntdb = ntdb_open("/tmp/speed.ntdb", flags, O_RDWR, 0, attr); }
int main(int argc, char *argv[]) { unsigned int i, j, num = 1000, stage = 0, stopat = -1; int flags = NTDB_DEFAULT; bool transaction = false, summary = false; NTDB_DATA key, data; struct ntdb_context *ntdb; struct timeval start, stop; union ntdb_attribute seed, log; bool do_stats = false; enum NTDB_ERROR ecode; /* Try to keep benchmarks even. */ seed.base.attr = NTDB_ATTRIBUTE_SEED; seed.base.next = NULL; seed.seed.seed = 0; log.base.attr = NTDB_ATTRIBUTE_LOG; log.base.next = &seed; log.log.fn = ntdb_log; if (argv[1] && strcmp(argv[1], "--internal") == 0) { flags = NTDB_INTERNAL; argc--; argv++; } if (argv[1] && strcmp(argv[1], "--transaction") == 0) { transaction = true; argc--; argv++; } if (argv[1] && strcmp(argv[1], "--no-sync") == 0) { flags |= NTDB_NOSYNC; argc--; argv++; } if (argv[1] && strcmp(argv[1], "--summary") == 0) { summary = true; argc--; argv++; } if (argv[1] && strcmp(argv[1], "--stats") == 0) { do_stats = true; argc--; argv++; } ntdb = ntdb_open("/tmp/speed.ntdb", flags, O_RDWR|O_CREAT|O_TRUNC, 0600, &log); if (!ntdb) err(1, "Opening /tmp/speed.ntdb"); key.dptr = (void *)&i; key.dsize = sizeof(i); data = key; if (argv[1]) { num = atoi(argv[1]); argv++; argc--; } if (argv[1]) { stopat = atoi(argv[1]); argv++; argc--; } /* Add 1000 records. */ printf("Adding %u records: ", num); fflush(stdout); if (transaction && (ecode = ntdb_transaction_start(ntdb))) errx(1, "starting transaction: %s", ntdb_errorstr(ecode)); gettimeofday(&start, NULL); for (i = 0; i < num; i++) if ((ecode = ntdb_store(ntdb, key, data, NTDB_INSERT)) != 0) errx(1, "Inserting key %u in ntdb: %s", i, ntdb_errorstr(ecode)); gettimeofday(&stop, NULL); if (transaction && (ecode = ntdb_transaction_commit(ntdb))) errx(1, "committing transaction: %s", ntdb_errorstr(ecode)); printf(" %zu ns (%zu bytes)\n", normalize(&start, &stop, num), file_size()); if (ntdb_check(ntdb, NULL, NULL)) errx(1, "ntdb_check failed!"); if (summary) { char *sumstr = NULL; ntdb_summary(ntdb, NTDB_SUMMARY_HISTOGRAMS, &sumstr); printf("%s\n", sumstr); free(sumstr); } if (do_stats) dump_and_clear_stats(&ntdb, flags, &log); if (++stage == stopat) exit(0); /* Finding 1000 records. */ printf("Finding %u records: ", num); fflush(stdout); if (transaction && (ecode = ntdb_transaction_start(ntdb))) errx(1, "starting transaction: %s", ntdb_errorstr(ecode)); gettimeofday(&start, NULL); for (i = 0; i < num; i++) { NTDB_DATA dbuf; if ((ecode = ntdb_fetch(ntdb, key, &dbuf)) != NTDB_SUCCESS || *(int *)dbuf.dptr != i) { errx(1, "Fetching key %u in ntdb gave %u", i, ecode ? ecode : *(int *)dbuf.dptr); } } gettimeofday(&stop, NULL); if (transaction && (ecode = ntdb_transaction_commit(ntdb))) errx(1, "committing transaction: %s", ntdb_errorstr(ecode)); printf(" %zu ns (%zu bytes)\n", normalize(&start, &stop, num), file_size()); if (ntdb_check(ntdb, NULL, NULL)) errx(1, "ntdb_check failed!"); if (summary) { char *sumstr = NULL; ntdb_summary(ntdb, NTDB_SUMMARY_HISTOGRAMS, &sumstr); printf("%s\n", sumstr); free(sumstr); } if (do_stats) dump_and_clear_stats(&ntdb, flags, &log); if (++stage == stopat) exit(0); /* Missing 1000 records. */ printf("Missing %u records: ", num); fflush(stdout); if (transaction && (ecode = ntdb_transaction_start(ntdb))) errx(1, "starting transaction: %s", ntdb_errorstr(ecode)); gettimeofday(&start, NULL); for (i = num; i < num*2; i++) { NTDB_DATA dbuf; ecode = ntdb_fetch(ntdb, key, &dbuf); if (ecode != NTDB_ERR_NOEXIST) errx(1, "Fetching key %u in ntdb gave %s", i, ntdb_errorstr(ecode)); } gettimeofday(&stop, NULL); if (transaction && (ecode = ntdb_transaction_commit(ntdb))) errx(1, "committing transaction: %s", ntdb_errorstr(ecode)); printf(" %zu ns (%zu bytes)\n", normalize(&start, &stop, num), file_size()); if (ntdb_check(ntdb, NULL, NULL)) errx(1, "ntdb_check failed!"); if (summary) { char *sumstr = NULL; ntdb_summary(ntdb, NTDB_SUMMARY_HISTOGRAMS, &sumstr); printf("%s\n", sumstr); free(sumstr); } if (do_stats) dump_and_clear_stats(&ntdb, flags, &log); if (++stage == stopat) exit(0); /* Traverse 1000 records. */ printf("Traversing %u records: ", num); fflush(stdout); if (transaction && (ecode = ntdb_transaction_start(ntdb))) errx(1, "starting transaction: %s", ntdb_errorstr(ecode)); i = 0; gettimeofday(&start, NULL); if (ntdb_traverse(ntdb, count_record, &i) != num) errx(1, "Traverse returned wrong number of records"); if (i != (num - 1) * (num / 2)) errx(1, "Traverse tallied to %u", i); gettimeofday(&stop, NULL); if (transaction && (ecode = ntdb_transaction_commit(ntdb))) errx(1, "committing transaction: %s", ntdb_errorstr(ecode)); printf(" %zu ns (%zu bytes)\n", normalize(&start, &stop, num), file_size()); if (ntdb_check(ntdb, NULL, NULL)) errx(1, "ntdb_check failed!"); if (summary) { char *sumstr = NULL; ntdb_summary(ntdb, NTDB_SUMMARY_HISTOGRAMS, &sumstr); printf("%s\n", sumstr); free(sumstr); } if (do_stats) dump_and_clear_stats(&ntdb, flags, &log); if (++stage == stopat) exit(0); /* Delete 1000 records (not in order). */ printf("Deleting %u records: ", num); fflush(stdout); if (transaction && (ecode = ntdb_transaction_start(ntdb))) errx(1, "starting transaction: %s", ntdb_errorstr(ecode)); gettimeofday(&start, NULL); for (j = 0; j < num; j++) { i = (j + 100003) % num; if ((ecode = ntdb_delete(ntdb, key)) != NTDB_SUCCESS) errx(1, "Deleting key %u in ntdb: %s", i, ntdb_errorstr(ecode)); } gettimeofday(&stop, NULL); if (transaction && (ecode = ntdb_transaction_commit(ntdb))) errx(1, "committing transaction: %s", ntdb_errorstr(ecode)); printf(" %zu ns (%zu bytes)\n", normalize(&start, &stop, num), file_size()); if (ntdb_check(ntdb, NULL, NULL)) errx(1, "ntdb_check failed!"); if (summary) { char *sumstr = NULL; ntdb_summary(ntdb, NTDB_SUMMARY_HISTOGRAMS, &sumstr); printf("%s\n", sumstr); free(sumstr); } if (do_stats) dump_and_clear_stats(&ntdb, flags, &log); if (++stage == stopat) exit(0); /* Re-add 1000 records (not in order). */ printf("Re-adding %u records: ", num); fflush(stdout); if (transaction && (ecode = ntdb_transaction_start(ntdb))) errx(1, "starting transaction: %s", ntdb_errorstr(ecode)); gettimeofday(&start, NULL); for (j = 0; j < num; j++) { i = (j + 100003) % num; if ((ecode = ntdb_store(ntdb, key, data, NTDB_INSERT)) != 0) errx(1, "Inserting key %u in ntdb: %s", i, ntdb_errorstr(ecode)); } gettimeofday(&stop, NULL); if (transaction && (ecode = ntdb_transaction_commit(ntdb))) errx(1, "committing transaction: %s", ntdb_errorstr(ecode)); printf(" %zu ns (%zu bytes)\n", normalize(&start, &stop, num), file_size()); if (ntdb_check(ntdb, NULL, NULL)) errx(1, "ntdb_check failed!"); if (summary) { char *sumstr = NULL; ntdb_summary(ntdb, NTDB_SUMMARY_HISTOGRAMS, &sumstr); printf("%s\n", sumstr); free(sumstr); } if (do_stats) dump_and_clear_stats(&ntdb, flags, &log); if (++stage == stopat) exit(0); /* Append 1000 records. */ if (transaction && (ecode = ntdb_transaction_start(ntdb))) errx(1, "starting transaction: %s", ntdb_errorstr(ecode)); printf("Appending %u records: ", num); fflush(stdout); gettimeofday(&start, NULL); for (i = 0; i < num; i++) if ((ecode = ntdb_append(ntdb, key, data)) != NTDB_SUCCESS) errx(1, "Appending key %u in ntdb: %s", i, ntdb_errorstr(ecode)); gettimeofday(&stop, NULL); if (transaction && (ecode = ntdb_transaction_commit(ntdb))) errx(1, "committing transaction: %s", ntdb_errorstr(ecode)); printf(" %zu ns (%zu bytes)\n", normalize(&start, &stop, num), file_size()); if (ntdb_check(ntdb, NULL, NULL)) errx(1, "ntdb_check failed!"); if (summary) { char *sumstr = NULL; ntdb_summary(ntdb, NTDB_SUMMARY_HISTOGRAMS, &sumstr); printf("%s\n", sumstr); free(sumstr); } if (++stage == stopat) exit(0); /* Churn 1000 records: not in order! */ if (transaction && (ecode = ntdb_transaction_start(ntdb))) errx(1, "starting transaction: %s", ntdb_errorstr(ecode)); printf("Churning %u records: ", num); fflush(stdout); gettimeofday(&start, NULL); for (j = 0; j < num; j++) { i = (j + 1000019) % num; if ((ecode = ntdb_delete(ntdb, key)) != NTDB_SUCCESS) errx(1, "Deleting key %u in ntdb: %s", i, ntdb_errorstr(ecode)); i += num; if ((ecode = ntdb_store(ntdb, key, data, NTDB_INSERT)) != 0) errx(1, "Inserting key %u in ntdb: %s", i, ntdb_errorstr(ecode)); } gettimeofday(&stop, NULL); if (transaction && (ecode = ntdb_transaction_commit(ntdb))) errx(1, "committing transaction: %s", ntdb_errorstr(ecode)); printf(" %zu ns (%zu bytes)\n", normalize(&start, &stop, num), file_size()); if (ntdb_check(ntdb, NULL, NULL)) errx(1, "ntdb_check failed!"); if (summary) { char *sumstr = NULL; ntdb_summary(ntdb, NTDB_SUMMARY_HISTOGRAMS, &sumstr); printf("%s\n", sumstr); free(sumstr); } if (do_stats) dump_and_clear_stats(&ntdb, flags, &log); if (++stage == stopat) exit(0); return 0; }
int main(int argc, char *argv[]) { unsigned int i; struct ntdb_context *ntdb; int flags[] = { NTDB_INTERNAL, NTDB_DEFAULT, NTDB_NOMMAP, NTDB_INTERNAL|NTDB_CONVERT, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; plan_tests(87); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { ntdb = ntdb_open("run-add-remove-flags.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); ok1(ntdb); if (!ntdb) continue; ok1(ntdb_get_flags(ntdb) == ntdb->flags); tap_log_messages = 0; ntdb_add_flag(ntdb, NTDB_NOLOCK); if (flags[i] & NTDB_INTERNAL) ok1(tap_log_messages == 1); else { ok1(tap_log_messages == 0); ok1(ntdb_get_flags(ntdb) & NTDB_NOLOCK); } tap_log_messages = 0; ntdb_add_flag(ntdb, NTDB_NOMMAP); if (flags[i] & NTDB_INTERNAL) ok1(tap_log_messages == 1); else { ok1(tap_log_messages == 0); ok1(ntdb_get_flags(ntdb) & NTDB_NOMMAP); ok1(ntdb->file->map_ptr == NULL); } tap_log_messages = 0; ntdb_add_flag(ntdb, NTDB_NOSYNC); if (flags[i] & NTDB_INTERNAL) ok1(tap_log_messages == 1); else { ok1(tap_log_messages == 0); ok1(ntdb_get_flags(ntdb) & NTDB_NOSYNC); } ok1(ntdb_get_flags(ntdb) == ntdb->flags); tap_log_messages = 0; ntdb_remove_flag(ntdb, NTDB_NOLOCK); if (flags[i] & NTDB_INTERNAL) ok1(tap_log_messages == 1); else { ok1(tap_log_messages == 0); ok1(!(ntdb_get_flags(ntdb) & NTDB_NOLOCK)); } tap_log_messages = 0; ntdb_remove_flag(ntdb, NTDB_NOMMAP); if (flags[i] & NTDB_INTERNAL) ok1(tap_log_messages == 1); else { ok1(tap_log_messages == 0); ok1(!(ntdb_get_flags(ntdb) & NTDB_NOMMAP)); ok1(ntdb->file->map_ptr != NULL); } tap_log_messages = 0; ntdb_remove_flag(ntdb, NTDB_NOSYNC); if (flags[i] & NTDB_INTERNAL) ok1(tap_log_messages == 1); else { ok1(tap_log_messages == 0); ok1(!(ntdb_get_flags(ntdb) & NTDB_NOSYNC)); } ntdb_close(ntdb); } ok1(tap_log_messages == 0); return exit_status(); }