// -----------------------------------------------------------------------
int mx_line_conf_log(struct mx_line *line, uint16_t *data)
{
unsigned proto_num = (data[0] & 0b1111111100000000) >> 8;
// formetter number is not really used anywhere in emulation,
// but let's at least log its number
unsigned tape_fmter = (data[0] & 0b0000000010000000) >> 7;
// get protocol
const struct mx_proto *proto = mx_proto_get(proto_num);
LOGID(L_MX, 3, line, " Logical line protocol %i: %s%s",
proto_num,
proto ? proto->name : "[unknown]",
line->type == MX_PHY_MTAPE ? (tape_fmter ? ", formatter 1" : ", formatter 0" ) : ""
);
// make sure physical line is active (configured)
if (!line->used) {
return MX_SC_E_PHY_UNUSED;
}
// make sure that no logical line uses this physical line
if (line->proto) {
return MX_SC_E_PHY_USED;
}
// check if protocol exists and its emulation is usable
if (!proto || !proto->enabled) {
return MX_SC_E_PROTO_MISSING;
}
// check if line direction matches required protocol direction
if ((proto->dir & line->dir) != proto->dir) {
return MX_SC_E_DIR_MISMATCH;
}
// check if line type is OK for the protocol
int *type = proto->phy_types;
while (*type != line->type) {
if (*type == -1) {
return MX_SC_E_PROTO_MISMATCH;
}
type++;
}
// set protocol configuration
line->proto = proto;
return line->proto->conf(line, data+1);
}
// -----------------------------------------------------------------------
int mx_line_conf_phy(struct mx_line *line, uint16_t data)
{
unsigned dir = (data & 0b1110000000000000) >> 13;
unsigned used = (data & 0b0001000000000000) >> 12;
unsigned type = (data & 0b0000111100000000) >> 8;
LOGID(L_MX, 3, line, " %s (%i), %s (%i), %s",
mx_line_type_name(type),
type,
mx_line_dir_name(dir),
dir, used ? "used" : "unused"
);
// check type for correctness
if (type >= MX_PHY_MAX) {
return MX_SC_E_DEVTYPE;
// check direction: USART
} else if ((type == MX_PHY_USART_SYNC) || (type == MX_PHY_USART_ASYNC)) {
if ((dir != MX_DIR_OUTPUT) && (dir != MX_DIR_INPUT) && (dir != MX_DIR_HALF_DUPLEX) && (dir != MX_DIR_FULL_DUPLEX)) {
if (used) {
return MX_SC_E_DIR;
} else if (dir != MX_DIR_NONE) {
return MX_SC_E_DIR;
}
}
// check direction: 8255
} else if (type == MX_PHY_8255) {
if ((dir != MX_DIR_OUTPUT) && (dir != MX_DIR_INPUT)) {
return MX_SC_E_DIR;
}
// check direction: winchester, floppy, tape
} else {
if (dir != MX_DIR_NONE) {
return MX_SC_E_DIR;
}
}
line->dir = dir;
line->used = used;
line->type = type;
return MX_SC_E_OK;
}
static void
write_to_file(file_provider *provider, lcbvb_CONFIG *cfg)
{
FILE *fp;
if (provider->filename == NULL || provider->ro_mode) {
return;
}
fp = fopen(provider->filename, "w");
if (fp) {
char *json = lcbvb_save_json(cfg);
lcb_log(LOGARGS(provider, INFO), LOGFMT "Writing configuration to file", LOGID(provider));
fprintf(fp, "%s%s", json, CONFIG_CACHE_MAGIC);
fclose(fp);
free(json);
} else {
int save_errno = errno;
lcb_log(LOGARGS(provider, ERROR), LOGFMT "Couldn't open file for writing: %s", LOGID(provider), strerror(save_errno));
}
}
static int load_cache(file_provider *provider)
{
lcb_string str;
char line[1024];
lcb_ssize_t nr;
int fail;
FILE *fp = NULL;
lcbvb_CONFIG *config = NULL;
char *end;
struct stat st;
int status = -1;
lcb_string_init(&str);
if (provider->filename == NULL) {
return -1;
}
fp = fopen(provider->filename, "r");
if (fp == NULL) {
int save_errno = errno;
lcb_log(LOGARGS(provider, ERROR), LOGFMT "Couldn't open for reading: %s", LOGID(provider), strerror(save_errno));
return -1;
}
if (fstat(fileno(fp), &st)) {
provider->last_errno = errno;
goto GT_DONE;
}
if (provider->last_mtime == st.st_mtime) {
lcb_log(LOGARGS(provider, WARN), LOGFMT "Modification time too old", LOGID(provider));
goto GT_DONE;
}
config = lcbvb_create();
if (config == NULL) {
goto GT_DONE;
}
lcb_string_init(&str);
while ((nr = fread(line, 1, sizeof(line), fp)) > 0) {
if (lcb_string_append(&str, line, nr)) {
goto GT_DONE;
}
}
if (ferror(fp)) {
goto GT_DONE;
}
fclose(fp);
fp = NULL;
if (!str.nused) {
status = -1;
goto GT_DONE;
}
end = strstr(str.base, CONFIG_CACHE_MAGIC);
if (end == NULL) {
lcb_log(LOGARGS(provider, ERROR), LOGFMT "Couldn't find magic", LOGID(provider));
if (!provider->ro_mode) {
remove(provider->filename);
}
status = -1;
goto GT_DONE;
}
fail = lcbvb_load_json(config, str.base);
if (fail) {
status = -1;
lcb_log(LOGARGS(provider, ERROR), LOGFMT "Couldn't parse configuration", LOGID(provider));
lcb_log_badconfig(LOGARGS(provider, ERROR), config, str.base);
if (!provider->ro_mode) {
remove(provider->filename);
}
goto GT_DONE;
}
if (lcbvb_get_distmode(config) != LCBVB_DIST_VBUCKET) {
status = -1;
lcb_log(LOGARGS(provider, ERROR), LOGFMT "Not applying cached memcached config", LOGID(provider));
goto GT_DONE;
}
if (strcmp(config->bname, PROVIDER_SETTING(&provider->base, bucket)) != 0) {
status = -1;
lcb_log(LOGARGS(provider, ERROR), LOGFMT "Bucket name in file is different from the one requested", LOGID(provider));
}
if (provider->config) {
lcb_clconfig_decref(provider->config);
}
provider->config = lcb_clconfig_create(config, LCB_CLCONFIG_FILE);
provider->config->cmpclock = gethrtime();
provider->config->origin = provider->base.type;
provider->last_mtime = st.st_mtime;
status = 0;
config = NULL;
GT_DONE:
if (fp != NULL) {
fclose(fp);
}
if (config != NULL) {
lcbvb_destroy(config);
}
lcb_string_release(&str);
return status;
}
int lcb_clconfig_file_set_filename(clconfig_provider *p, const char *f, int ro)
{
file_provider *provider = (file_provider *)p;
lcb_assert(provider->base.type == LCB_CLCONFIG_FILE);
provider->base.enabled = 1;
if (provider->filename) {
free(provider->filename);
}
provider->filename = mkcachefile(f, p->parent->settings->bucket);
if (ro) {
FILE *fp_tmp;
provider->ro_mode = 1;
fp_tmp = fopen(provider->filename, "r");
if (!fp_tmp) {
lcb_log(LOGARGS(provider, ERROR), LOGFMT "Couldn't open for reading: %s", LOGID(provider), strerror(errno));
return -1;
} else {
fclose(fp_tmp);
}
}
return 0;
}
/* This function is called within a loop to process a single packet.
*
* If a full packet is available, it will process the packet and return
* PKT_READ_COMPLETE, resulting in the `on_read()` function calling this
* function in a loop.
*
* When a complete packet is not available, PKT_READ_PARTIAL will be returned
* and the `on_read()` loop will exit, scheduling any required pending I/O.
*/
static int
try_read(lcbio_CTX *ctx, mc_SERVER *server, rdb_IOROPE *ior)
{
packet_info info_s, *info = &info_s;
mc_PACKET *request;
mc_PIPELINE *pl = &server->pipeline;
unsigned pktsize = 24, is_last = 1;
#define RETURN_NEED_MORE(n) \
if (mcserver_has_pending(server)) { \
lcbio_ctx_rwant(ctx, n); \
} \
return PKT_READ_PARTIAL; \
#define DO_ASSIGN_PAYLOAD() \
rdb_consumed(ior, sizeof(info->res.bytes)); \
if (PACKET_NBODY(info)) { \
info->payload = rdb_get_consolidated(ior, PACKET_NBODY(info)); \
} {
#define DO_SWALLOW_PAYLOAD() \
} if (PACKET_NBODY(info)) { \
rdb_consumed(ior, PACKET_NBODY(info)); \
}
if (rdb_get_nused(ior) < pktsize) {
RETURN_NEED_MORE(pktsize)
}
/* copy bytes into the info structure */
rdb_copyread(ior, info->res.bytes, sizeof info->res.bytes);
pktsize += PACKET_NBODY(info);
if (rdb_get_nused(ior) < pktsize) {
RETURN_NEED_MORE(pktsize);
}
/* Find the packet */
if (PACKET_OPCODE(info) == PROTOCOL_BINARY_CMD_STAT && PACKET_NKEY(info) != 0) {
is_last = 0;
request = mcreq_pipeline_find(pl, PACKET_OPAQUE(info));
} else {
is_last = 1;
request = mcreq_pipeline_remove(pl, PACKET_OPAQUE(info));
}
if (!request) {
lcb_log(LOGARGS(server, WARN), LOGFMT "Found stale packet (OP=0x%x, RC=0x%x, SEQ=%u)", LOGID(server), PACKET_OPCODE(info), PACKET_STATUS(info), PACKET_OPAQUE(info));
rdb_consumed(ior, pktsize);
return PKT_READ_COMPLETE;
}
if (PACKET_STATUS(info) == PROTOCOL_BINARY_RESPONSE_NOT_MY_VBUCKET) {
/* consume the header */
DO_ASSIGN_PAYLOAD()
if (!handle_nmv(server, info, request)) {
mcreq_dispatch_response(pl, request, info, LCB_NOT_MY_VBUCKET);
}
DO_SWALLOW_PAYLOAD()
return PKT_READ_COMPLETE;
}
/**
* Invoked when get a NOT_MY_VBUCKET response. If the response contains a JSON
* payload then we refresh the configuration with it.
*
* This function returns 1 if the operation was successfully rescheduled;
* otherwise it returns 0. If it returns 0 then we give the error back to the
* user.
*/
static int
handle_nmv(mc_SERVER *oldsrv, packet_info *resinfo, mc_PACKET *oldpkt)
{
mc_PACKET *newpkt;
protocol_binary_request_header hdr;
lcb_error_t err = LCB_ERROR;
lcb_t instance = oldsrv->instance;
lcb_U16 vbid;
int tmpix;
clconfig_provider *cccp = lcb_confmon_get_provider(instance->confmon,
LCB_CLCONFIG_CCCP);
mcreq_read_hdr(oldpkt, &hdr);
vbid = ntohs(hdr.request.vbucket);
lcb_log(LOGARGS(oldsrv, WARN), LOGFMT "NOT_MY_VBUCKET. Packet=%p (S=%u). VBID=%u", LOGID(oldsrv), (void*)oldpkt, oldpkt->opaque, vbid);
/* Notify of new map */
tmpix = lcb_vbguess_remap(LCBT_VBCONFIG(instance),
instance->vbguess, vbid, oldsrv->pipeline.index);
if (tmpix > -1 && tmpix != oldsrv->pipeline.index) {
lcb_log(LOGARGS(oldsrv, TRACE), LOGFMT "Heuristically set IX=%d as master for VBID=%u", LOGID(oldsrv), tmpix, vbid);
}
if (PACKET_NBODY(resinfo) && cccp->enabled) {
lcb_string s;
lcb_string_init(&s);
lcb_string_append(&s, PACKET_VALUE(resinfo), PACKET_NVALUE(resinfo));
err = lcb_cccp_update(cccp, mcserver_get_host(oldsrv), &s);
lcb_string_release(&s);
}
if (err != LCB_SUCCESS) {
lcb_bootstrap_common(instance, LCB_BS_REFRESH_ALWAYS);
}
if (!lcb_should_retry(oldsrv->settings, oldpkt, LCB_NOT_MY_VBUCKET)) {
return 0;
}
/** Reschedule the packet again .. */
newpkt = mcreq_renew_packet(oldpkt);
newpkt->flags &= ~MCREQ_STATE_FLAGS;
lcb_retryq_add(instance->retryq, (mc_EXPACKET*)newpkt, LCB_NOT_MY_VBUCKET);
return 1;
}
/**
* Invoked when get a NOT_MY_VBUCKET response. If the response contains a JSON
* payload then we refresh the configuration with it.
*
* This function returns 1 if the operation was successfully rescheduled;
* otherwise it returns 0. If it returns 0 then we give the error back to the
* user.
*/
static int
handle_nmv(mc_SERVER *oldsrv, packet_info *resinfo, mc_PACKET *oldpkt)
{
mc_PACKET *newpkt;
protocol_binary_request_header hdr;
lcb_error_t err = LCB_ERROR;
lcb_t instance = oldsrv->instance;
lcb_U16 vbid;
clconfig_provider *cccp = lcb_confmon_get_provider(instance->confmon,
LCB_CLCONFIG_CCCP);
mcreq_read_hdr(oldpkt, &hdr);
vbid = ntohs(hdr.request.vbucket);
lcb_log(LOGARGS(oldsrv, WARN), LOGFMT "NOT_MY_VBUCKET. Packet=%p (S=%u). VBID=%u", LOGID(oldsrv), (void*)oldpkt, oldpkt->opaque, vbid);
/* Notify of new map */
lcb_vbguess_remap(instance, vbid, oldsrv->pipeline.index);
if (PACKET_NBODY(resinfo) && cccp->enabled) {
lcb_string s;
lcb_string_init(&s);
lcb_string_append(&s, PACKET_VALUE(resinfo), PACKET_NVALUE(resinfo));
err = lcb_cccp_update(cccp, mcserver_get_host(oldsrv), &s);
lcb_string_release(&s);
}
if (err != LCB_SUCCESS) {
int bs_options;
if (instance->cur_configinfo->origin == LCB_CLCONFIG_CCCP) {
/**
* XXX: Not enough to see if cccp was enabled, since cccp might
* be requested by a user, but would still not actually be active
* for clusters < 2.5 If our current config is from CCCP
* then we can be fairly certain that CCCP is indeed working.
*
* For this reason, we don't use if (cccp->enabled) {...}
*/
bs_options = LCB_BS_REFRESH_THROTTLE;
} else {
bs_options = LCB_BS_REFRESH_ALWAYS;
}
lcb_bootstrap_common(instance, bs_options);
}
if (!lcb_should_retry(oldsrv->settings, oldpkt, LCB_NOT_MY_VBUCKET)) {
return 0;
}
/** Reschedule the packet again .. */
newpkt = mcreq_renew_packet(oldpkt);
newpkt->flags &= ~MCREQ_STATE_FLAGS;
lcb_retryq_nmvadd(instance->retryq, (mc_EXPACKET*)newpkt);
return 1;
}