int dnet_update_ts_metadata_raw(struct dnet_meta_container *mc, uint64_t flags_set, uint64_t flags_clear)
{
struct dnet_meta m;
void *data = mc->data;
uint32_t size = mc->size;
struct dnet_meta_update *mu;
while (size) {
if (size < sizeof(struct dnet_meta)) {
return -1;
}
m = *(struct dnet_meta *)data;
dnet_convert_meta(&m);
if (m.size + sizeof(struct dnet_meta) > size) {
return -1;
}
if (m.type == DNET_META_UPDATE) {
mu = (struct dnet_meta_update *)(data + sizeof(struct dnet_meta));
dnet_convert_meta_update(mu);
dnet_current_time(&mu->tm);
mu->flags |= flags_set;
mu->flags &= ~flags_clear;
dnet_convert_meta_update(mu);
}
data += m.size + sizeof(struct dnet_meta);
size -= m.size + sizeof(struct dnet_meta);
}
return -ENOENT;
}
struct dnet_meta_update *dnet_get_meta_update(struct dnet_node *n, struct dnet_meta_container *mc,
struct dnet_meta_update *meta_update)
{
struct dnet_meta m;
void *data = mc->data;
uint32_t size = mc->size;
struct dnet_meta_update *mu;
int num;
while (size) {
if (size < sizeof(struct dnet_meta)) {
dnet_log(n, DNET_LOG_ERROR, "Metadata size %u is too small, min %zu, searching for type 0x%x.\n",
size, sizeof(struct dnet_meta), DNET_META_UPDATE);
return NULL;
}
m = *(struct dnet_meta *)data;
dnet_convert_meta(&m);
if (m.size + sizeof(struct dnet_meta) > size) {
dnet_log(n, DNET_LOG_ERROR, "Metadata entry broken: entry size %u, type: 0x%x, struct size: %zu, "
"total size left: %u, searching for type: 0x%x.\n",
m.size, m.type, sizeof(struct dnet_meta), size, DNET_META_UPDATE);
return NULL;
}
if (m.type == DNET_META_UPDATE) {
mu = (struct dnet_meta_update *)(data + sizeof(struct dnet_meta));
num = m.size / sizeof(struct dnet_meta_update);
if (num >= 0) {
if (meta_update) {
memcpy(meta_update, &mu[0], sizeof(struct dnet_meta_update));
dnet_convert_meta_update(meta_update);
}
return &mu[0];
}
}
data += m.size + sizeof(struct dnet_meta);
size -= m.size + sizeof(struct dnet_meta);
}
return NULL;
}
void dnet_create_meta_update(struct dnet_meta *m, struct timespec *ts, uint64_t flags_set, uint64_t flags_clear)
{
struct dnet_meta_update *mu = (struct dnet_meta_update *)m->data;
m->size = sizeof(struct dnet_meta_update);
m->type = DNET_META_UPDATE;
if (!ts) {
dnet_current_time(&mu->tm);
} else {
mu->tm.tsec = ts->tv_sec;
mu->tm.tnsec = ts->tv_nsec;
}
mu->flags = 0;
mu->flags |= flags_set;
mu->flags &= ~flags_clear;
dnet_convert_meta_update(mu);
dnet_convert_meta(m);
}
static int dnet_bulk_add_id(struct dnet_node *n, struct dnet_bulk_array *bulk_array, struct dnet_id *id,
struct dnet_meta_container *mc, struct dnet_check_params *params)
{
int err = 0;
struct dnet_bulk_state tmp;
struct dnet_bulk_state *state = NULL;
struct dnet_net_state *st = dnet_state_get_first(n, id);
struct dnet_bulk_id *bulk_id;
struct dnet_meta_update mu;
dnet_log(n, DNET_LOG_DEBUG, "BULK: adding ID %s to array\n", dnet_dump_id(id));
if (!st)
return -1;
memcpy(&tmp.addr, &st->addr, sizeof(struct dnet_addr));
dnet_state_put(st);
dnet_log(n, DNET_LOG_DEBUG, "BULK: Searching state in states array\n");
state = bsearch(&tmp, bulk_array->states, bulk_array->num, sizeof(struct dnet_bulk_state), dnet_compare_bulk_state);
if (!state)
return -1;
if (!dnet_get_meta_update(n, mc, &mu))
return -ENOENT;
dnet_log(n, DNET_LOG_DEBUG, "BULK: addr = %s state->num = %d\n", dnet_server_convert_dnet_addr(&state->addr), state->num);
//pthread_mutex_lock(&state->state_lock);
if (state->num >= DNET_BULK_IDS_SIZE || state->num < 0)
goto err_out_unlock;
bulk_id = &state->ids[state->num];
memset(bulk_id, 0, sizeof(struct dnet_bulk_id));
memcpy(&bulk_id->id, &id->id, DNET_ID_SIZE);
dnet_log(n, DNET_LOG_DEBUG, "BULK: ID: %s, last_update->tsec=%llu, last_update->tnsec=%llu, flags=%02llx\n",
dnet_dump_id_str(bulk_id->id.id), (unsigned long long)mu.tm.tsec, (unsigned long long)mu.tm.tnsec,
(unsigned long long)mu.flags);
dnet_convert_meta_update(&mu);
memcpy(&bulk_id->last_update, &mu, sizeof(struct dnet_meta_update));
state->num++;
dnet_log(n, DNET_LOG_DEBUG, "BULK: addr = %s state->num = %d\n", dnet_server_convert_dnet_addr(&state->addr), state->num);
if (state->num == DNET_BULK_IDS_SIZE) {
err = dnet_request_bulk_check(n, state, params);
state->num = 0;
if (err)
goto err_out_unlock;
}
//pthread_mutex_unlock(&state->state_lock);
return 0;
err_out_unlock:
//pthread_mutex_unlock(&state->state_lock);
return -2;
}
static int dnet_bulk_check_complete_single(struct dnet_net_state *state, struct dnet_bulk_id *ids,
int remote_group, struct dnet_bulk_check_priv *p)
{
struct dnet_session *s = dnet_session_create(state->n);
struct dnet_meta_container mc;
struct dnet_meta_container temp_mc;
struct dnet_meta_update *mu;
struct dnet_meta *mg;
struct dnet_id id;
char *tmpdata = NULL;
int *groups, group_num = 1;
int err = -EINVAL, error = 0;
int i = 0;
int my_group, lastest_group = -1;
struct dnet_meta_update lastest_mu, my_mu;
struct timeval current_ts;
int removed_in_all = 1, updated = 0;
int lastest = 0;
uint64_t cflags = 0;
uint64_t ioflags = 0;
my_group = state->n->id.group_id;
dnet_log(state->n, DNET_LOG_DEBUG, "BULK: checking ID %s\n", dnet_dump_id_str(ids->id.id));
err = -ENOENT;
error = 0;
dnet_setup_id(&mc.id, my_group, ids->id.id);
err = state->n->cb->meta_read(state->n->cb->command_private, &ids->id, &mc.data);
if (err <= 0) {
if (err == 0)
err = -ENOENT;
goto err_out_continue;
}
mc.size = err;
/* Set current group meta_update as lastest_mu */
if (!dnet_get_meta_update(state->n, &mc, &my_mu)) {
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: meta_update structure doesn't exist for group %d\n",
dnet_dump_id_str(ids->id.id), my_group);
err = -ENOENT;
goto err_out_kcfree;
}
dnet_convert_meta_update(&my_mu);
memcpy(&lastest_mu, &my_mu, sizeof(struct dnet_meta_update));
lastest_group = my_group;
/* Get group list */
if (p->group_num) {
/* groups came from dnet_check utility */
groups = p->groups;
group_num = p->group_num;
} else {
mg = dnet_meta_search(state->n, &mc, DNET_META_GROUPS);
if (!mg) {
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: DNET_META_GROUPS structure doesn't exist\n", dnet_dump_id_str(ids->id.id));
err = -ENOENT;
goto err_out_kcfree;
}
dnet_convert_meta(mg);
if (mg->size % sizeof(int)) {
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: DNET_META_GROUPS structure is corrupted\n", dnet_dump_id_str(ids->id.id));
err = -1;
goto err_out_kcfree;
}
group_num = mg->size / sizeof(int);
groups = (int *)mg->data;
dnet_convert_meta(mg);
}
/* Read temporary meta */
temp_mc.data = malloc(sizeof(struct dnet_meta_update) * group_num);
if (!temp_mc.data) {
err = -ENOMEM;
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: could not allocate memory for temp UPDATE_META\n", dnet_dump_id_str(ids->id.id));
goto err_out_kcfree;
}
memset(temp_mc.data, 0, sizeof(struct dnet_meta_update) * group_num);
temp_mc.size = sizeof(struct dnet_meta_update) * group_num;
err = dnet_db_read_raw(p->db->b, &ids->id, (void **)&tmpdata);
if (err <= 0) {
if (err < 0 && err != -2)
goto err_out_free;
/* No data in temp meta was stored. Placing local meta_update at the beginning */
mu = temp_mc.data;
mu[0].group_id = my_group;
mu[0].tm = my_mu.tm;
mu[0].flags = my_mu.flags;
} else {
if (err > (int)(sizeof(struct dnet_meta_update) * group_num)) {
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: too many data stored in temp meta\n", dnet_dump_id_str(ids->id.id));
err = -ENOMEM;
goto err_out_free;
}
memcpy(temp_mc.data, tmpdata, err);
}
/* Update temp meta with received group */
mu = temp_mc.data;
updated = 0;
lastest = 0;
for (i = 0; i < group_num; ++i) {
if (mu[i].group_id == remote_group) {
mu[i].tm = ids->last_update.tm;
mu[i].flags = ids->last_update.flags;
updated = 1;
}
if (mu[i].group_id == 0)
break;
if (!(mu[i].flags & DNET_IO_FLAGS_REMOVED))
removed_in_all = 0;
if (((mu[i].tm.tsec > mu[lastest].tm.tsec)
|| ((mu[i].tm.tsec == mu[lastest].tm.tsec) && (mu[i].tm.tnsec > mu[lastest].tm.tnsec)))
&& i != lastest) {
lastest = i;
lastest_group = groups[i];
}
}
if (!updated && i == group_num) {
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: no space left to save group in temp meta!\n", dnet_dump_id_str(ids->id.id));
err = -ENOMEM;
goto err_out_free;
}
if (!updated) {
mu[i].group_id = remote_group;
mu[i].tm = ids->last_update.tm;
mu[i].flags = ids->last_update.flags;
if (((mu[i].tm.tsec > mu[lastest].tm.tsec)
|| ((mu[i].tm.tsec == mu[lastest].tm.tsec) && (mu[i].tm.tnsec > mu[lastest].tm.tnsec)))
&& i != lastest) {
lastest = i;
lastest_group = groups[i];
}
++i;
}
/* Not all groups processed yet */
if (i < group_num) {
err = 0;
err = dnet_db_write_raw(p->db->b, &ids->id, temp_mc.data, temp_mc.size);
if (err) {
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: unable to save temp meta, err: %d\n", dnet_dump_id_str(ids->id.id), err);
}
goto err_out_free;
}
/* Check if removal_delay second has gone since object was marked as REMOVED */
if (removed_in_all) {
gettimeofday(¤t_ts, NULL);
if (((uint64_t)current_ts.tv_sec < mu[lastest].tm.tsec)
|| ((uint64_t)current_ts.tv_sec - mu[lastest].tm.tsec) < (uint64_t)(state->n->removal_delay * 3600 * 24))
removed_in_all = 0;
}
/* TODO: receive newer files from remote groups
*
* Yep, we should read it locally and send it to other groups too
*/
if ((lastest_group != my_group) && !(mu[lastest].flags & DNET_IO_FLAGS_REMOVED)) {
dnet_log(state->n, DNET_LOG_DEBUG, "BULK: %s: File on remote group %d is newer, skipping this file\n",
dnet_dump_id_str(ids->id.id), lastest_group);
err = 0;
goto err_out_free;
}
for (i = 0; i < group_num; ++i) {
err = 0;
if (mu[i].group_id == my_group)
continue;
dnet_session_set_groups(s, (int *)&mu[i].group_id, 1);
dnet_setup_id(&id, mu[i].group_id, ids->id.id);
id.type = -1;
if (mu[lastest].flags & DNET_IO_FLAGS_REMOVED) {
if (removed_in_all) {
dnet_log(state->n, DNET_LOG_DEBUG, "BULK: dnet_remove_object_now %s in group %d, err=%d\n",
dnet_dump_id(&id), mu[i].group_id, err);
err = dnet_remove_object_now(s, &id, cflags, ioflags);
} else {
if (!(mu[i].flags & DNET_IO_FLAGS_REMOVED)) {
err = dnet_remove_object(s, &id, NULL, NULL, cflags, ioflags);
dnet_log(state->n, DNET_LOG_DEBUG, "BULK: dnet_remove_object %s in group %d err=%d\n",
dnet_dump_id(&id), mu[i].group_id, err);
}
}
if (err < 0)
goto err_out_cont2;
} else {
if ((mu[i].tm.tsec < mu[lastest].tm.tsec) || ((mu[i].tm.tsec == mu[lastest].tm.tsec) &&
((mu[i].tm.tnsec < mu[lastest].tm.tnsec)))) {
err = state->n->cb->send(state, state->n->cb->command_private, &id);
if (err)
goto err_out_cont2;
err = dnet_meta_update_check_status_raw(state->n, &mc);
if (err)
goto err_out_cont2;
memcpy(&mc.id, &id, sizeof(struct dnet_id));
err = dnet_write_metadata(s, &mc, 1, cflags);
dnet_log(state->n, DNET_LOG_DEBUG, "BULK: dnet_write_metadata %s in group %d, err=%d\n",
dnet_dump_id(&id), my_group, err);
if (err < 0)
goto err_out_cont2;
}
}
err_out_cont2:
if (err < 0)
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: Error during sending transaction to group %d, err=%d\n",
dnet_dump_id_str(ids->id.id), groups[i], err);
if (!error && err < 0)
error = err;
}
if (mu[lastest].flags & DNET_IO_FLAGS_REMOVED) {
if (removed_in_all) {
err = dnet_merge_remove_local(state->n, &mc.id, 0);
} else if (!(my_mu.flags & DNET_IO_FLAGS_REMOVED)) {
err = dnet_merge_remove_local(state->n, &mc.id, 1);
}
}
if (!(mu[lastest].flags & DNET_IO_FLAGS_REMOVED) && !error) {
err = dnet_meta_update_check_status(state->n, &mc);
if (err) {
dnet_log(state->n, DNET_LOG_ERROR, "BULK: %s: couldn't update meta CHECK_STATUS\n", dnet_dump_id_str(ids->id.id));
}
}
if (group_num > 2) {
err = dnet_db_remove_raw(p->db->b, &ids->id, 1);
if (!err) {
dnet_log_raw(state->n, DNET_LOG_ERROR, "BULK: %s: DB: failed to remove temp_meta object, err: %d.\n",
dnet_dump_id(&mc.id), err);
}
}
if (error > 0)
error = 0;
err_out_free:
free(temp_mc.data);
err_out_kcfree:
free(mc.data);
if (tmpdata)
free(tmpdata);
err_out_continue:
if (error < 0) {
dnet_log(state->n, DNET_LOG_ERROR, "Failed to check ID %s to %s, err=%d\n", dnet_dump_id_str(ids->id.id),
dnet_state_dump_addr(state), error);
}
if (i == group_num) {
dnet_counter_inc(state->n, DNET_CNTR_NODE_CHECK_COPY, error);
}
return error;
}
int dnet_cmd_bulk_check(struct dnet_net_state *orig, struct dnet_cmd *cmd, void *data)
{
struct dnet_bulk_id *ids = (struct dnet_bulk_id *)data;
struct dnet_meta_container mc;
struct dnet_meta_update mu;
struct dnet_id raw;
int i;
int err = 0;
int num;
if (!(cmd->size % sizeof(struct dnet_bulk_id))) {
num = cmd->size / sizeof(struct dnet_bulk_id);
dnet_log(orig->n, DNET_LOG_DEBUG, "BULK: received %d entries\n", num);
for (i = 0; i < num; ++i) {
/* Send empty reply every DNET_BULK_CHECK_PING records to prevent timeout */
if (i % DNET_BULK_CHECK_PING == 0 && i > 0) {
dnet_send_reply(orig, cmd, NULL, 0, 1);
}
dnet_log(orig->n, DNET_LOG_DEBUG, "BULK: processing ID %s\n", dnet_dump_id_str(ids[i].id.id));
mc.data = NULL;
dnet_setup_id(&mc.id, 0, ids[i].id.id);
err = orig->n->cb->meta_read(orig->n->cb->command_private, &ids[i].id, &mc.data);
if (mc.data) {
mc.size = err;
dnet_log(orig->n, DNET_LOG_DEBUG, "BULK: %d bytes of metadata found, searching for META_UPDATE group_id=%d\n",
mc.size, orig->n->st->idc->group->group_id);
if (dnet_get_meta_update(orig->n, &mc, &mu))
{
dnet_convert_meta_update(&ids[i].last_update);
dnet_log(orig->n, DNET_LOG_DEBUG, "BULK: mu.tsec=%lu, mu.tnsec=%lu, mu.flags=%02lx\n",
(unsigned long)mu.tm.tsec, (unsigned long)mu.tm.tnsec, (unsigned long)mu.flags);
dnet_log(orig->n, DNET_LOG_DEBUG,
"BULK: last_update.tsec=%lu, last_update.tnsec=%lu, last_update.flags=%02lx\n",
(unsigned long)ids[i].last_update.tm.tsec, (unsigned long)ids[i].last_update.tm.tnsec,
(unsigned long)ids[i].last_update.flags);
if ((mu.flags & DNET_IO_FLAGS_REMOVED) || (mu.tm.tsec < ids[i].last_update.tm.tsec) ||
((mu.tm.tnsec < ids[i].last_update.tm.tnsec) && (mu.tm.tsec == ids[i].last_update.tm.tsec))) {
err = 0;
} else {
/* File is not needed to be updated */
dnet_setup_id(&raw, orig->n->id.group_id, ids[i].id.id);
err = dnet_stat_local(orig, &raw);
if (err) {
/* File was not found in the storage */
mu.tm.tsec = 1;
mu.flags = 0;
} else {
err = dnet_meta_update_check_status(orig->n, &mc);
if (err) {
dnet_log(orig->n, DNET_LOG_ERROR,
"BULK: %s: couldn't update meta CHECK_STATUS err: %d\n",
dnet_dump_id_str(ids[i].id.id), err);
}
}
}
memcpy(&ids[i].last_update, &mu, sizeof(struct dnet_meta_update));
dnet_convert_meta_update(&ids[i].last_update);
}
free(mc.data);
} else {
/* Meta is not present - set timestamp to very old one */
dnet_convert_meta_update(&ids[i].last_update);
ids[i].last_update.tm.tsec = 1;
ids[i].last_update.flags = 0;
dnet_convert_meta_update(&ids[i].last_update);
}
}
} else {
dnet_log(orig->n, DNET_LOG_ERROR, "BULK: received corrupted data, size = %llu, sizeof(dnet_bulk_id) = %zu\n",
(unsigned long long)cmd->size, sizeof(struct dnet_bulk_id));
err = -1;
goto err_out_exit;
}
return dnet_send_reply(orig, cmd, data, sizeof(struct dnet_bulk_id) * num, 0);
err_out_exit:
return err;
}
