*/
int ctdb_call_local(struct ctdb_db_context *ctdb_db, struct ctdb_call *call,
struct ctdb_ltdb_header *header, TALLOC_CTX *mem_ctx,
- TDB_DATA *data, uint32_t caller)
+ TDB_DATA *data)
{
struct ctdb_call_info *c;
struct ctdb_registered_call *fn;
}
/* we need to force the record to be written out if this was a remote access */
- if (header->laccessor != caller) {
- header->lacount = 0;
- }
- header->laccessor = caller;
- header->lacount++;
-
- /* we need to force the record to be written out if this was a remote access,
- so that the lacount is updated */
- if (c->new_data == NULL && header->laccessor != ctdb->pnn) {
+ if (c->new_data == NULL) {
c->new_data = &c->record_data;
}
*(state->call) = *call;
state->ctdb_db = ctdb_db;
- ret = ctdb_call_local(ctdb_db, state->call, header, state, data, ctdb->pnn);
+ ret = ctdb_call_local(ctdb_db, state->call, header, state, data);
return state;
}
/* initial dmaster is the lmaster */
header->dmaster = ctdb_lmaster(ctdb_db->ctdb, &key);
header->flags = CTDB_REC_FLAG_AUTOMATIC;
- header->laccessor = header->dmaster;
}
uint32_t lcp2_public_ip_assignment;
uint32_t allow_client_db_attach;
uint32_t fetch_lock_collapse;
- uint32_t max_lacount;
};
/*
int ctdb_call_local(struct ctdb_db_context *ctdb_db, struct ctdb_call *call,
struct ctdb_ltdb_header *header, TALLOC_CTX *mem_ctx,
- TDB_DATA *data, uint32_t caller);
+ TDB_DATA *data);
#define ctdb_reqid_find(ctdb, reqid, type) (type *)_ctdb_reqid_find(ctdb, reqid, #type, __location__)
struct ctdb_ltdb_header {
uint64_t rsn;
uint32_t dmaster;
- uint16_t laccessor;
- uint16_t lacount;
+ uint32_t reserved1;
#define CTDB_REC_FLAG_DEFAULT 0x00000000
#define CTDB_REC_FLAG_MIGRATED_WITH_DATA 0x00010000
#define CTDB_REC_FLAG_VACUUM_MIGRATED 0x00020000
return;
}
- ctdb_call_local(ctdb_db, state->call, &header, state, &data, ctdb->pnn);
+ ctdb_call_local(ctdb_db, state->call, &header, state, &data);
ret = ctdb_ltdb_unlock(ctdb_db, state->call->key);
if (ret != 0) {
CTDB_INCREMENT_STAT(ctdb, hop_count_bucket[bucket]);
- /* if this nodes has done enough consecutive calls on the same record
- then give them the record
- or if the node requested an immediate migration
- */
- if ( c->hdr.srcnode != ctdb->pnn &&
- ((header.laccessor == c->hdr.srcnode
- && header.lacount >= ctdb->tunable.max_lacount
- && ctdb->tunable.max_lacount != 0)
- || (c->flags & CTDB_IMMEDIATE_MIGRATION)) ) {
+ /* Try if possible to migrate the record off to the caller node.
+ * From the clients perspective a fetch of the data is just as
+ * expensive as a migration.
+ */
+ if (c->hdr.srcnode != ctdb->pnn) {
if (ctdb_db->transaction_active) {
DEBUG(DEBUG_INFO, (__location__ " refusing migration"
" of key %s while transaction is active\n",
}
}
- ctdb_call_local(ctdb_db, call, &header, hdr, &data, c->hdr.srcnode);
+ ctdb_call_local(ctdb_db, call, &header, hdr, &data);
ret = ctdb_ltdb_unlock(ctdb_db, call->key);
if (ret != 0) {
*(state->call) = *call;
state->ctdb_db = ctdb_db;
- ret = ctdb_call_local(ctdb_db, state->call, header, state, data, ctdb->pnn);
+ ret = ctdb_call_local(ctdb_db, state->call, header, state, data);
event_add_timed(ctdb->ev, state, timeval_zero(), call_local_trigger, state);
{ "StatHistoryInterval", 1, offsetof(struct ctdb_tunable, stat_history_interval) },
{ "DeferredAttachTO", 120, offsetof(struct ctdb_tunable, deferred_attach_timeout) },
{ "AllowClientDBAttach", 1, offsetof(struct ctdb_tunable, allow_client_db_attach) },
- { "FetchLockCollapse", 1, offsetof(struct ctdb_tunable, fetch_lock_collapse) },
- { "MaxLACount", 0, offsetof(struct ctdb_tunable, max_lacount) },
+ { "FetchLockCollapse", 1, offsetof(struct ctdb_tunable, fetch_lock_collapse) }
};
/*