Пример #1
0
int dbfile_read_all_hashes(struct hash_tree *tree)
{
	int ret;
	sqlite3 *db;
	sqlite3_stmt *stmt = NULL;
	char *filename;
	uint64_t ino, subvolid, size;
	struct filerec *file;

	db = dbfile_get_handle();
	if (!db)
		return ENOENT;

	ret = dbfile_check_version(db);
	if (ret)
		return ret;

	ret = sqlite3_prepare_v2(db,
				 "SELECT ino, subvol, filename, size from files;", -1,
				 &stmt, NULL);
	if (ret) {
		perror_sqlite(ret, "preparing statement");
		return ret;
	}

	while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
		ino = sqlite3_column_int64(stmt, 0);
		subvolid = sqlite3_column_int64(stmt, 1);
		filename = (char *)sqlite3_column_text(stmt, 2);
		size = sqlite3_column_int64(stmt, 3);

		file = filerec_new(filename, ino, subvolid, size);
		if (!file) {
			ret = ENOMEM;
			goto out_finalize;
		}

		ret = dbfile_walk_file_hashes(db, file, load_into_hash_tree_cb,
					      tree);
		if (ret)
			goto out_finalize;
	}
	if (ret != SQLITE_DONE) {
		perror_sqlite(ret, "retrieving hashes from table");
		ret = EIO;
		goto out_finalize;
	}

	ret = 0;
out_finalize:
	sqlite3_finalize(stmt);

	return ret;
}
Пример #2
0
int dbfile_sync_config(unsigned int block_size)
{
	sqlite3 *db;
	int ret;

	db = dbfile_get_handle();
	if (!db)
		return ENOENT;

	ret = __dbfile_sync_config(db, block_size);

	return ret;
}
Пример #3
0
int dbfile_load_hashes_bloom(struct hash_tree *hash_tree,
			     struct rb_root *d_tree)
{
	int ret;
	struct rb_node *d_hash_node = rb_first(d_tree);
	struct d_tree *d_hash;
	sqlite3 *db;
	sqlite3_stmt *stmt = NULL;
	uint64_t subvol, ino, loff;
	int flags;
	struct filerec *file;

	db = dbfile_get_handle();
	if (!db)
		return ENOENT;

	ret = sqlite3_prepare_v2(db,
	 "SELECT ino, subvol, loff, flags FROM hashes WHERE digest = ?1;",
				 -1, &stmt, NULL);
	if (ret) {
		perror_sqlite(ret, "preparing statement");
		return ret;
	}

	for (d_hash_node = rb_first(d_tree); d_hash_node;
	     d_hash_node = rb_next(d_hash_node)) {
		d_hash = rb_entry(d_hash_node, struct d_tree, t_node);

		/*
		 * XXX: Using SQLITE_STATIC here because it's probably
		 * faster. If we ever free items from d_tree, we need
		 * to change that.
		 */
		ret = sqlite3_bind_blob(stmt, 1, d_hash->digest,
					digest_len, SQLITE_STATIC);
		if (ret) {
			perror_sqlite(ret, "looking up hash (bind)");
			goto out;
		}

		while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
			ino = sqlite3_column_int64(stmt, 0);
			subvol = sqlite3_column_int64(stmt, 1);
			loff = sqlite3_column_int64(stmt, 2);
			flags = sqlite3_column_int(stmt, 3);

			file = filerec_find(ino, subvol);
			if (!file) {
				ret = ENOENT;
				fprintf(stderr,
					"Filerec (%"PRIu64",%"PRIu64" is in db"
					" but not in hash!\n", ino, subvol);
				goto out;
			}

			ret = insert_hashed_block(hash_tree, d_hash->digest,
						  file, loff, flags);
			if (ret)
				return ENOMEM;
		}
		if (ret != SQLITE_DONE) {
			perror_sqlite(ret, "looking up hash");
			goto out;
		}
		sqlite3_reset(stmt);
	}

	ret = 0;
out:
	if (stmt)
		sqlite3_finalize(stmt);

	return ret;
}
Пример #4
0
int dbfile_populate_hashes(struct rb_root *d_tree)
{
	int ret;
	sqlite3 *db;
	sqlite3_stmt *stmt = NULL;
	char *filename;
	uint64_t ino, subvolid;
	uint64_t num_hashes;
	struct filerec *file;
	struct bloom_cb_priv priv;

	db = dbfile_get_handle();
	if (!db)
		return ENOENT;

	ret = dbfile_count_rows(db, &num_hashes, NULL);
	if (ret)
		return ret;

	priv.d_tree = d_tree;
	ret = bloom_init(&priv.bloom, num_hashes, 0.01);
	if (ret)
		return ret;

	ret = sqlite3_prepare_v2(db,
				 "SELECT ino, subvol, filename from files;", -1,
				 &stmt, NULL);
	if (ret) {
		perror_sqlite(ret, "preparing statement");
		goto out_bloom;
	}

	while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
		ino = sqlite3_column_int64(stmt, 0);
		subvolid = sqlite3_column_int64(stmt, 1);
		filename = (char *)sqlite3_column_text(stmt, 2);

		file = filerec_new(filename, ino, subvolid);
		if (!file) {
			ret = ENOMEM;
			goto out_finalize;
		}

		ret = dbfile_walk_file_hashes(db, file, load_into_bloom_cb,
					      &priv);
		if (ret)
			goto out_finalize;
	}
	if (ret != SQLITE_DONE) {
		perror_sqlite(ret, "retrieving file info from table");
		goto out_finalize;
	}

	ret = 0;
out_finalize:
	sqlite3_finalize(stmt);
out_bloom:
	bloom_free(&priv.bloom);

	return ret;
}