void ElektronDataToSysexEncoder::finishChecksum() {
uint16_t len = retLen - 5;
inChecksum = false;
stop7Bit();
pack8((checksum >> 7) & 0x7F);
pack8(checksum & 0x7F);
pack8((len >> 7) & 0x7F);
pack8(len & 0x7F);
pack8(0xF7);
}
extern void jobacctinfo_pack(jobacctinfo_t *jobacct,
uint16_t rpc_version, uint16_t protocol_type,
Buf buffer)
{
bool no_pack;
no_pack = (!plugin_polling && (protocol_type != PROTOCOL_TYPE_DBD));
if (rpc_version >= SLURM_MIN_PROTOCOL_VERSION) {
if (!jobacct || no_pack) {
pack8((uint8_t) 0, buffer);
return;
}
pack8((uint8_t) 1, buffer);
pack32((uint32_t)jobacct->user_cpu_sec, buffer);
pack32((uint32_t)jobacct->user_cpu_usec, buffer);
pack32((uint32_t)jobacct->sys_cpu_sec, buffer);
pack32((uint32_t)jobacct->sys_cpu_usec, buffer);
pack64(jobacct->max_vsize, buffer);
pack64(jobacct->tot_vsize, buffer);
pack64(jobacct->max_rss, buffer);
pack64(jobacct->tot_rss, buffer);
pack64(jobacct->max_pages, buffer);
pack64(jobacct->tot_pages, buffer);
pack32((uint32_t)jobacct->min_cpu, buffer);
packdouble(jobacct->tot_cpu, buffer);
pack32((uint32_t)jobacct->act_cpufreq, buffer);
pack64((uint64_t)jobacct->energy.consumed_energy, buffer);
packdouble((double)jobacct->max_disk_read, buffer);
packdouble((double)jobacct->tot_disk_read, buffer);
packdouble((double)jobacct->max_disk_write, buffer);
packdouble((double)jobacct->tot_disk_write, buffer);
_pack_jobacct_id(&jobacct->max_vsize_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->max_rss_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->max_pages_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->min_cpu_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->max_disk_read_id, rpc_version,
buffer);
_pack_jobacct_id(&jobacct->max_disk_write_id, rpc_version,
buffer);
} else {
info("jobacctinfo_pack version %u not supported", rpc_version);
return;
}
}
int pmixp_server_health_chk(char *hostlist, const char *addr)
{
send_header_t hdr;
char nhdr[sizeof(send_header_t)];
size_t hsize;
Buf buf = pmixp_server_new_buf();
char *data = get_buf_data(buf);
int rc;
hdr.magic = PMIX_SERVER_MSG_MAGIC;
hdr.type = PMIXP_MSG_HEALTH_CHK;
hdr.msgsize = 1;
hdr.seq = 0;
/* Store global nodeid that is
* independent from exact collective */
hdr.nodeid = pmixp_info_nodeid_job();
hsize = _send_pack_hdr(&hdr, nhdr);
memcpy(data, nhdr, hsize);
grow_buf(buf, sizeof(char));
pack8('\n', buf);
rc = pmixp_stepd_send(hostlist, addr, data, get_buf_offset(buf), 4, 14, 1);
if (SLURM_SUCCESS != rc) {
PMIXP_ERROR("Was unable to wait for the parent %s to become alive on addr %s",
hostlist, addr);
}
return rc;
}
ref<set_member> CTimeSetMember::create(ref<object> obj, time_t t)
{
nat8 t1 = t ? t : time(NULL);
#ifdef PGSQL_ORM
pack8(t1);
#endif
return new(self_class, sizeof(time_t)) CTimeSetMember(self_class, obj, t1);
}
extern int select_p_select_jobinfo_pack(select_jobinfo_t *jobinfo, Buf buffer,
uint16_t protocol_version)
{
int rc = SLURM_ERROR;
if (protocol_version >= SLURM_MIN_PROTOCOL_VERSION) {
if (!jobinfo) {
pack8(0, buffer);
pack32(0, buffer);
pack64(0, buffer);
return SLURM_SUCCESS;
}
pack8(jobinfo->confirmed, buffer);
pack32(jobinfo->reservation_id, buffer);
pack64(jobinfo->confirm_cookie, buffer);
rc = other_select_jobinfo_pack(jobinfo->other_jobinfo, buffer,
protocol_version);
} else {
error("select_p_select_jobinfo_pack: protocol_version "
"%hu not supported", protocol_version);
}
return rc;
}
static void _base_hdr_pack_full(Buf packbuf, pmixp_base_hdr_t *hdr)
{
if (hdr->ext_flag) {
hdr->msgsize += PMIXP_BASE_HDR_EXT_SIZE(pmixp_dconn_ep_len());
}
pack32(hdr->magic, packbuf);
pack32(hdr->type, packbuf);
pack32(hdr->seq, packbuf);
pack32(hdr->nodeid, packbuf);
pack32(hdr->msgsize, packbuf);
pack8(hdr->ext_flag, packbuf);
if (hdr->ext_flag) {
packmem(pmixp_dconn_ep_data(), pmixp_dconn_ep_len(), packbuf);
xassert(get_buf_offset(packbuf) ==
(PMIXP_BASE_HDR_SIZE +
PMIXP_BASE_HDR_EXT_SIZE(pmixp_dconn_ep_len())));
}
}
void CTimeSetMember::UpdateKeyVal(time_t new_key)
{
if(getKeyLength() == 4)
{
#ifdef PGSQL_ORM
pack4((char*)key, (char*)&new_key);
#else
DWORD t = (DWORD)new_key;
memcpy(key, &t, sizeof(DWORD));
#endif
}
else
{
#ifdef PGSQL_ORM
pack8((char*)key, (char*)&new_key);
#else
memcpy(key, &new_key, sizeof(time_t));
#endif
}
}
static void _setup_header(Buf buf, dmdx_type_t t,
const char *nspace, int rank, int status)
{
char *str;
/* 1. pack message type */
unsigned char type = (char)t;
grow_buf(buf, sizeof(char));
pack8(type, buf);
/* 2. pack namespace _with_ '\0' (strlen(nspace) + 1)! */
packmem((char *)nspace, strlen(nspace) + 1, buf);
/* 3. pack rank */
grow_buf(buf, sizeof(int));
pack32((uint32_t)rank, buf);
/* 4. pack my rendezvous point - local namespace
* ! _with_ '\0' (strlen(nspace) + 1) ! */
str = pmixp_info_namespace();
packmem(str, strlen(str) + 1, buf);
/* 5. pack the status */
pack32((uint32_t)status, buf);
}
extern void pack_job_resources(job_resources_t *job_resrcs_ptr, Buf buffer,
uint16_t protocol_version)
{
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
if (protocol_version >= SLURM_2_5_PROTOCOL_VERSION) {
if (job_resrcs_ptr == NULL) {
uint32_t empty = NO_VAL;
pack32(empty, buffer);
return;
}
pack32(job_resrcs_ptr->nhosts, buffer);
pack32(job_resrcs_ptr->ncpus, buffer);
pack32(job_resrcs_ptr->node_req, buffer);
packstr(job_resrcs_ptr->nodes, buffer);
if (job_resrcs_ptr->cpu_array_reps)
pack32_array(job_resrcs_ptr->cpu_array_reps,
job_resrcs_ptr->cpu_array_cnt, buffer);
else
pack32_array(job_resrcs_ptr->cpu_array_reps, 0, buffer);
if (job_resrcs_ptr->cpu_array_value)
pack16_array(job_resrcs_ptr->cpu_array_value,
job_resrcs_ptr->cpu_array_cnt, buffer);
else
pack16_array(job_resrcs_ptr->cpu_array_value,
0, buffer);
if (job_resrcs_ptr->cpus)
pack16_array(job_resrcs_ptr->cpus,
job_resrcs_ptr->nhosts, buffer);
else
pack16_array(job_resrcs_ptr->cpus, 0, buffer);
if (job_resrcs_ptr->cpus_used)
pack16_array(job_resrcs_ptr->cpus_used,
job_resrcs_ptr->nhosts, buffer);
else
pack16_array(job_resrcs_ptr->cpus_used, 0, buffer);
if (job_resrcs_ptr->memory_allocated)
pack32_array(job_resrcs_ptr->memory_allocated,
job_resrcs_ptr->nhosts, buffer);
else
pack32_array(job_resrcs_ptr->memory_allocated,
0, buffer);
if (job_resrcs_ptr->memory_used)
pack32_array(job_resrcs_ptr->memory_used,
job_resrcs_ptr->nhosts, buffer);
else
pack32_array(job_resrcs_ptr->memory_used, 0, buffer);
if (!(cluster_flags & CLUSTER_FLAG_BG)) {
int i;
uint32_t core_cnt = 0, sock_recs = 0;
xassert(job_resrcs_ptr->cores_per_socket);
xassert(job_resrcs_ptr->sock_core_rep_count);
xassert(job_resrcs_ptr->sockets_per_node);
for (i=0; i<job_resrcs_ptr->nhosts; i++) {
core_cnt += job_resrcs_ptr->sockets_per_node[i]
* job_resrcs_ptr->cores_per_socket[i] *
job_resrcs_ptr->sock_core_rep_count[i];
sock_recs += job_resrcs_ptr->
sock_core_rep_count[i];
if (sock_recs >= job_resrcs_ptr->nhosts)
break;
}
i++;
pack16_array(job_resrcs_ptr->sockets_per_node,
(uint32_t) i, buffer);
pack16_array(job_resrcs_ptr->cores_per_socket,
(uint32_t) i, buffer);
pack32_array(job_resrcs_ptr->sock_core_rep_count,
(uint32_t) i, buffer);
xassert(job_resrcs_ptr->core_bitmap);
xassert(job_resrcs_ptr->core_bitmap_used);
pack_bit_str(job_resrcs_ptr->core_bitmap, buffer);
pack_bit_str(job_resrcs_ptr->core_bitmap_used, buffer);
}
} else if (protocol_version >= SLURM_2_3_PROTOCOL_VERSION) {
uint8_t tmp_8;
if (job_resrcs_ptr == NULL) {
uint32_t empty = NO_VAL;
pack32(empty, buffer);
return;
}
pack32(job_resrcs_ptr->nhosts, buffer);
pack32(job_resrcs_ptr->ncpus, buffer);
tmp_8 = job_resrcs_ptr->node_req; /* 32-bit in v2.5 */
pack8(tmp_8, buffer);
packstr(job_resrcs_ptr->nodes, buffer);
if (job_resrcs_ptr->cpu_array_reps)
pack32_array(job_resrcs_ptr->cpu_array_reps,
job_resrcs_ptr->cpu_array_cnt, buffer);
else
pack32_array(job_resrcs_ptr->cpu_array_reps, 0, buffer);
if (job_resrcs_ptr->cpu_array_value)
pack16_array(job_resrcs_ptr->cpu_array_value,
job_resrcs_ptr->cpu_array_cnt, buffer);
else
pack16_array(job_resrcs_ptr->cpu_array_value,
0, buffer);
if (job_resrcs_ptr->cpus)
pack16_array(job_resrcs_ptr->cpus,
job_resrcs_ptr->nhosts, buffer);
else
pack16_array(job_resrcs_ptr->cpus, 0, buffer);
if (job_resrcs_ptr->cpus_used)
pack16_array(job_resrcs_ptr->cpus_used,
job_resrcs_ptr->nhosts, buffer);
else
pack16_array(job_resrcs_ptr->cpus_used, 0, buffer);
if (job_resrcs_ptr->memory_allocated)
pack32_array(job_resrcs_ptr->memory_allocated,
job_resrcs_ptr->nhosts, buffer);
else
pack32_array(job_resrcs_ptr->memory_allocated,
0, buffer);
if (job_resrcs_ptr->memory_used)
pack32_array(job_resrcs_ptr->memory_used,
job_resrcs_ptr->nhosts, buffer);
else
pack32_array(job_resrcs_ptr->memory_used, 0, buffer);
if (!(cluster_flags & CLUSTER_FLAG_BG)) {
int i;
uint32_t core_cnt = 0, sock_recs = 0;
xassert(job_resrcs_ptr->cores_per_socket);
xassert(job_resrcs_ptr->sock_core_rep_count);
xassert(job_resrcs_ptr->sockets_per_node);
for (i=0; i<job_resrcs_ptr->nhosts; i++) {
core_cnt += job_resrcs_ptr->sockets_per_node[i]
* job_resrcs_ptr->cores_per_socket[i] *
job_resrcs_ptr->sock_core_rep_count[i];
sock_recs += job_resrcs_ptr->
sock_core_rep_count[i];
if (sock_recs >= job_resrcs_ptr->nhosts)
break;
}
i++;
pack16_array(job_resrcs_ptr->sockets_per_node,
(uint32_t) i, buffer);
pack16_array(job_resrcs_ptr->cores_per_socket,
(uint32_t) i, buffer);
pack32_array(job_resrcs_ptr->sock_core_rep_count,
(uint32_t) i, buffer);
xassert(job_resrcs_ptr->core_bitmap);
xassert(job_resrcs_ptr->core_bitmap_used);
pack_bit_str(job_resrcs_ptr->core_bitmap, buffer);
pack_bit_str(job_resrcs_ptr->core_bitmap_used, buffer);
}
} else {
error("pack_job_resources: protocol_version %hu not supported",
protocol_version);
}
}
static int cli_send_columns(int statement, int cmd)
{
statement_desc* s = statements.get(statement);
column_binding* cb;
if (s == NULL) {
return cli_bad_descriptor;
}
long msg_size = sizeof(cli_request);
if (cmd == cli_cmd_update) {
if (!s->prepared) {
return cli_not_fetched;
}
if (s->oid == 0) {
return cli_not_found;
}
if (!s->for_update) {
return cli_not_update_mode;
}
} else {
if (!s->prepared) {
cmd = cli_cmd_prepare_and_insert;
msg_size += 1 + s->stmt_len + s->n_columns + s->columns_len;
}
}
for (cb = s->columns; cb != NULL; cb = cb->next) {
if (cb->get_fnc != NULL) {
cb->arr_ptr = cb->get_fnc(cb->var_type, cb->var_ptr, &cb->arr_len);
int len = cb->arr_len;
if (cb->var_type >= cli_array_of_oid) {
len *= sizeof_type[cb->var_type - cli_array_of_oid];
}
msg_size += 4 + len;
} else {
if (cb->var_type == cli_asciiz) {
msg_size += 4 + strlen((char*)cb->var_ptr) + 1;
} else if (cb->var_type == cli_pasciiz) {
msg_size += 4 + strlen(*(char**)cb->var_ptr) + 1;
} else if (cb->var_type >= cli_array_of_oid) {
msg_size += 4 +
*cb->var_len * sizeof_type[cb->var_type-cli_array_of_oid];
} else {
msg_size += sizeof_type[cb->var_type];
}
}
}
dbSmallBuffer buf(msg_size);
char* p = buf;
cli_request* req = (cli_request*)p;
req->length = msg_size;
req->cmd = cmd;
req->stmt_id = statement;
req->pack();
p += sizeof(cli_request);
if (cmd == cli_cmd_prepare_and_insert) {
char* cmd = s->stmt;
while ((*p++ = *cmd++) != '\0');
*p++ = s->n_columns;
for (cb = s->columns; cb != NULL; cb = cb->next) {
char* src = cb->name;
*p++ = cb->var_type;
while ((*p++ = *src++) != '\0');
}
}
for (cb = s->columns; cb != NULL; cb = cb->next) {
int n;
char* src;
if (cb->get_fnc != NULL) {
src = (char*)cb->arr_ptr;
n = cb->arr_len;
} else {
src = (char*)cb->var_ptr;
if (cb->var_type >= cli_array_of_oid) {
n = *cb->var_len;
}
}
if (cb->var_type >= cli_array_of_oid) {
p = pack4(p, n);
switch (sizeof_type[cb->var_type-cli_array_of_oid]) {
case 2:
while (--n >= 0) {
p = pack2(p, src);
src += 2;
}
break;
case 4:
while (--n >= 0) {
p = pack4(p, src);
src += 4;
}
break;
case 8:
while (--n >= 0) {
p = pack8(p, src);
src += 8;
}
break;
default:
memcpy(p, src, n);
p += n;
}
} else if (cb->var_type == cli_asciiz) {
p = pack4(p, strlen(src)+1);
while ((*p++ = *src++) != 0);
} else if (cb->var_type == cli_pasciiz) {
src = *(char**)src;
p = pack4(p, strlen(src)+1);
while ((*p++ = *src++) != 0);
} else {
switch (sizeof_type[cb->var_type]) {
case 2:
p = pack2(p, src);
break;
case 4:
p = pack4(p, src);
break;
case 8:
p = pack8(p, src);
break;
default:
*p++ = *src;
}
}
}
assert(p - buf == msg_size);
if (!s->session->sock->write(buf, msg_size)) {
return cli_network_error;
}
return cli_ok;
}
int cli_fetch(int statement, int for_update)
{
parameter_binding* pb;
column_binding* cb;
statement_desc* stmt = statements.get(statement);
char *p, *s;
if (stmt == NULL) {
return cli_bad_descriptor;
}
stmt->for_update = for_update;
int msg_size = sizeof(cli_request) + 1;
for (pb = stmt->params; pb != NULL; pb = pb->next) {
if (pb->var_ptr == NULL) {
return cli_unbound_parameter;
}
if (pb->var_type == cli_asciiz) {
msg_size += strlen((char*)pb->var_ptr) + 1;
} else if (pb->var_type == cli_pasciiz) {
msg_size += strlen(*(char**)pb->var_ptr) + 1;
} else {
msg_size += sizeof_type[pb->var_type];
}
}
stmt->oid = 0;
if (!stmt->prepared) {
msg_size += 4 + stmt->stmt_len + stmt->n_params;
msg_size += stmt->columns_len + stmt->n_columns;
}
dbSmallBuffer buf(msg_size);
p = buf;
cli_request* req = (cli_request*)p;
req->length = msg_size;
req->cmd = stmt->prepared
? cli_cmd_execute : cli_cmd_prepare_and_execute;
req->stmt_id = statement;
req->pack();
p += sizeof(cli_request);
if (!stmt->prepared) {
*p++ = stmt->n_params;
*p++ = stmt->n_columns;
p = pack2(p, stmt->stmt_len + stmt->n_params);
pb = stmt->params;
char* end = p + stmt->stmt_len + stmt->n_params;
char* src = stmt->stmt;
while (p < end) {
while ((*p++ = *src++) != '\0');
if (pb != NULL) {
*p++ = pb->var_type == cli_pasciiz ? cli_asciiz : pb->var_type;
pb = pb->next;
}
}
for (cb = stmt->columns; cb != NULL; cb = cb->next) {
*p++ = cb->var_type;
s = cb->name;
while ((*p++ = *s++) != '\0');
}
}
*p++ = for_update;
for (pb = stmt->params; pb != NULL; pb = pb->next) {
switch (pb->var_type) {
case cli_asciiz:
s = (char*)pb->var_ptr;
while ((*p++ = *s++) != '\0');
continue;
case cli_pasciiz:
s = *(char**)pb->var_ptr;
while ((*p++ = *s++) != '\0');
continue;
default:
switch (sizeof_type[pb->var_type]) {
case 1:
*p++ = *(char*)pb->var_ptr;
continue;
case 2:
p = pack2(p, *(int2*)pb->var_ptr);
continue;
case 4:
p = pack4(p, *(int4*)pb->var_ptr);
continue;
case 8:
p = pack8(p, *(int8*)pb->var_ptr);
continue;
}
}
}
assert(msg_size == p - buf);
if (!stmt->session->sock->write(buf, msg_size)) {
return cli_network_error;
}
int4 response;
if (!stmt->session->sock->read(&response, sizeof response)) {
return cli_network_error;
}
unpack4(response);
if (response >= 0) {
stmt->prepared = true;
}
return response;
}
static int cli_send_columns_fdb(int statement, int cmd)
{
statement_desc* s = statements.get(statement);
column_binding* cb;
if (s == NULL) {
return cli_bad_descriptor;
}
long msg_size = sizeof(cli_request);
if (cmd == cli_cmd_update) {
if (!s->prepared) {
return cli_not_fetched;
}
if (s->oid == 0) {
return cli_not_found;
}
if (s->updated) {
return cli_already_updated;
}
if (!s->for_update) {
return cli_not_update_mode;
}
} else {
if (!s->prepared) {
cmd = cli_cmd_prepare_and_insert;
msg_size += 1 + s->stmt_len + s->n_columns + s->columns_len;
}
}
s->autoincrement = false;
for (cb = s->columns; cb != NULL; cb = cb->next) {
if (cb->get_fnc != NULL) {
cb->arr_ptr = cb->get_fnc(cb->var_type, cb->var_ptr, &cb->arr_len,
cb->name, statement, cb->user_data);
int len = cb->arr_len;
msg_size += 4;
if (cb->var_type == cli_array_of_string) {
char** p = (char**)cb->arr_ptr;
while (--len >= 0) {
msg_size += strlen(*p++) + 1;
}
} else if (cb->var_type == cli_array_of_wstring) {
wchar_t** p = (wchar_t**)cb->arr_ptr;
while (--len >= 0) {
msg_size += (wcslen(*p++) + 1)*sizeof(wchar_t);
}
} else if (cb->var_type == cli_wstring || cb->var_type == cli_pwstring) {
msg_size += len * sizeof(wchar_t);
} else if (cb->var_type >= cli_array_of_oid) {
msg_size += len * sizeof_type[cb->var_type - cli_array_of_oid];
} else {
msg_size += len;
}
} else {
switch (cb->var_type) {
case cli_autoincrement:
s->autoincrement = true;
break;
case cli_asciiz:
msg_size += 4 + (strlen((char*)cb->var_ptr) + 1);
break;
case cli_pasciiz:
msg_size += 4 + (strlen(*(char**)cb->var_ptr) + 1);
break;
case cli_wstring:
msg_size += 4 + (wcslen((wchar_t*)cb->var_ptr) + 1)*sizeof(wchar_t);
break;
case cli_pwstring:
msg_size += 4 + (wcslen(*(wchar_t**)cb->var_ptr) + 1)*sizeof(wchar_t);
break;
case cli_array_of_string:
{
char** p = (char**)cb->var_ptr;
int len;
msg_size += 4;
for (len = *cb->var_len; --len >= 0;) {
msg_size += (strlen(*p++) + 1);
}
break;
}
case cli_array_of_wstring:
{
wchar_t** p = (wchar_t**)cb->var_ptr;
int len;
msg_size += 4;
for (len = *cb->var_len; --len >= 0;) {
msg_size += (wcslen(*p++) + 1)*sizeof(wchar_t);
}
break;
}
default:
if (cb->var_type >= cli_array_of_oid && cb->var_type < cli_array_of_string) {
msg_size += 4 + *cb->var_len * sizeof_type[cb->var_type-cli_array_of_oid];
} else {
msg_size += sizeof_type[cb->var_type];
}
}
}
}
dbSmallBuffer buf(msg_size);
char* p = buf;
cli_request* req = (cli_request*)p;
req->length = msg_size;
req->cmd = cmd;
req->stmt_id = statement;
req->pack();
p += sizeof(cli_request);
if (cmd == cli_cmd_prepare_and_insert) {
char* cmd = s->stmt;
while ((*p++ = *cmd++) != '\0');
*p++ = s->n_columns;
for (cb = s->columns; cb != NULL; cb = cb->next) {
char* src = cb->name;
*p++ = cb->var_type;
while ((*p++ = *src++) != '\0');
}
}
for (cb = s->columns; cb != NULL; cb = cb->next) {
int n = 0;
char* src;
if (cb->get_fnc != NULL) {
src = (char*)cb->arr_ptr;
n = cb->arr_len;
} else {
src = (char*)cb->var_ptr;
if (cb->var_type >= cli_array_of_oid && (cb->var_type <= cli_array_of_string || cb->var_type == cli_array_of_wstring)) {
n = *cb->var_len;
}
}
if (cb->var_type >= cli_array_of_oid && (cb->var_type <= cli_array_of_string || cb->var_type == cli_array_of_wstring)) {
p = pack4(p, n);
if (cb->var_type == cli_array_of_string) {
while (--n >= 0) {
strcpy(p, *(char**)src);
p += strlen(p) + 1;
src += sizeof(char*);
}
} else if (cb->var_type == cli_array_of_wstring) {
while (--n >= 0) {
wcscpy((wchar_t*)p, *(wchar_t**)src);
p += (wcslen((wchar_t*)p) + 1)*sizeof(wchar_t);
src += sizeof(wchar_t*);
}
} else {
switch (sizeof_type[cb->var_type-cli_array_of_oid]) {
case 2:
while (--n >= 0) {
p = pack2(p, src);
src += 2;
}
break;
case 4:
while (--n >= 0) {
p = pack4(p, src);
src += 4;
}
break;
case 8:
while (--n >= 0) {
p = pack8(p, src);
src += 8;
}
break;
default:
memcpy(p, src, n);
p += n;
}
}
} else if (cb->var_type == cli_asciiz) {
p = pack4(p, strlen(src)+1);
while ((*p++ = *src++) != 0);
} else if (cb->var_type == cli_pasciiz) {
src = *(char**)src;
p = pack4(p, strlen(src)+1);
while ((*p++ = *src++) != 0);
} else if (cb->var_type == cli_wstring) {
wchar_t* body = (wchar_t*)src;
p = pack4(p, wcslen(body)+1);
wchar_t* dst = (wchar_t*)p;
while ((*dst++ = *body++) != 0);
p = (char*)dst;
} else if (cb->var_type == cli_pwstring) {
wchar_t* body = *(wchar_t**)src;
p = pack4(p, wcslen(body)+1);
wchar_t* dst = (wchar_t*)p;
while ((*dst++ = *body++) != 0);
p = (char*)dst;
} else if (cb->var_type == cli_rectangle) {
p = pack_rectangle(p, (cli_rectangle_t*)src);
} else if (cb->var_type != cli_autoincrement) {
switch (sizeof_type[cb->var_type]) {
case 2:
p = pack2(p, src);
break;
case 4:
p = pack4(p, src);
break;
case 8:
p = pack8(p, src);
break;
default:
*p++ = *src;
}
}
}
assert(p - buf.base() == msg_size);
if (!s->session->sock->write(buf, msg_size)) {
return cli_network_error;
}
return cli_ok;
}
extern void jobacctinfo_pack(jobacctinfo_t *jobacct,
uint16_t rpc_version, uint16_t protocol_type,
Buf buffer)
{
int i = 0;
bool no_pack;
no_pack = (!plugin_polling && (protocol_type != PROTOCOL_TYPE_DBD));
/* The function can take calls from both DBD and from regular
* SLURM functions. We choose to standardize on using the
* SLURM_PROTOCOL_VERSION here so if PROTOCOL_TYPE_DBD comes
* in we need to translate the DBD rpc_version to use the
* SLURM protocol_version.
*
* If this function ever changes make sure the
* slurmdbd_translate_rpc function has been updated with the
* new protocol version.
*/
if (protocol_type == PROTOCOL_TYPE_DBD)
rpc_version = slurmdbd_translate_rpc(rpc_version);
if (rpc_version >= SLURM_14_03_PROTOCOL_VERSION) {
if (no_pack) {
pack8((uint8_t) 0, buffer);
return;
}
pack8((uint8_t) 1, buffer);
if (!jobacct) {
for (i = 0; i < 6; i++)
pack64(0, buffer);
for (i = 0; i < 8; i++)
pack32((uint32_t) 0, buffer);
for (i = 0; i < 4; i++)
packdouble((double) 0, buffer);
for (i = 0; i < 6; i++)
_pack_jobacct_id(NULL, rpc_version, buffer);
return;
}
pack32((uint32_t)jobacct->user_cpu_sec, buffer);
pack32((uint32_t)jobacct->user_cpu_usec, buffer);
pack32((uint32_t)jobacct->sys_cpu_sec, buffer);
pack32((uint32_t)jobacct->sys_cpu_usec, buffer);
pack64(jobacct->max_vsize, buffer);
pack64(jobacct->tot_vsize, buffer);
pack64(jobacct->max_rss, buffer);
pack64(jobacct->tot_rss, buffer);
pack64(jobacct->max_pages, buffer);
pack64(jobacct->tot_pages, buffer);
pack32((uint32_t)jobacct->min_cpu, buffer);
pack32((uint32_t)jobacct->tot_cpu, buffer);
pack32((uint32_t)jobacct->act_cpufreq, buffer);
pack32((uint32_t)jobacct->energy.consumed_energy, buffer);
packdouble((double)jobacct->max_disk_read, buffer);
packdouble((double)jobacct->tot_disk_read, buffer);
packdouble((double)jobacct->max_disk_write, buffer);
packdouble((double)jobacct->tot_disk_write, buffer);
_pack_jobacct_id(&jobacct->max_vsize_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->max_rss_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->max_pages_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->min_cpu_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->max_disk_read_id, rpc_version,
buffer);
_pack_jobacct_id(&jobacct->max_disk_write_id, rpc_version,
buffer);
} else if (rpc_version >= SLURM_2_6_PROTOCOL_VERSION) {
if (no_pack)
return;
if (!jobacct) {
for (i = 0; i < 14; i++)
pack32((uint32_t) 0, buffer);
for (i = 0; i < 4; i++)
packdouble((double) 0, buffer);
for (i = 0; i < 6; i++)
_pack_jobacct_id(NULL, rpc_version, buffer);
return;
}
pack32((uint32_t)jobacct->user_cpu_sec, buffer);
pack32((uint32_t)jobacct->user_cpu_usec, buffer);
pack32((uint32_t)jobacct->sys_cpu_sec, buffer);
pack32((uint32_t)jobacct->sys_cpu_usec, buffer);
pack32((uint32_t)jobacct->max_vsize, buffer);
pack32((uint32_t)jobacct->tot_vsize, buffer);
pack32((uint32_t)jobacct->max_rss, buffer);
pack32((uint32_t)jobacct->tot_rss, buffer);
pack32((uint32_t)jobacct->max_pages, buffer);
pack32((uint32_t)jobacct->tot_pages, buffer);
pack32((uint32_t)jobacct->min_cpu, buffer);
pack32((uint32_t)jobacct->tot_cpu, buffer);
pack32((uint32_t)jobacct->act_cpufreq, buffer);
pack32((uint32_t)jobacct->energy.consumed_energy, buffer);
packdouble((double)jobacct->max_disk_read, buffer);
packdouble((double)jobacct->tot_disk_read, buffer);
packdouble((double)jobacct->max_disk_write, buffer);
packdouble((double)jobacct->tot_disk_write, buffer);
_pack_jobacct_id(&jobacct->max_vsize_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->max_rss_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->max_pages_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->min_cpu_id, rpc_version, buffer);
_pack_jobacct_id(&jobacct->max_disk_read_id, rpc_version,
buffer);
_pack_jobacct_id(&jobacct->max_disk_write_id, rpc_version,
buffer);
} else {
info("jobacctinfo_pack version %u not supported", rpc_version);
return;
}
}
