/* * pack_all_front_end - dump all front_end node information for all nodes * in machine independent form (for network transmission) * OUT buffer_ptr - pointer to the stored data * OUT buffer_size - set to size of the buffer in bytes * IN protocol_version - slurm protocol version of client * NOTE: the caller must xfree the buffer at *buffer_ptr * NOTE: READ lock_slurmctld config before entry */ extern void pack_all_front_end(char **buffer_ptr, int *buffer_size, uid_t uid, uint16_t protocol_version) { time_t now = time(NULL); uint32_t nodes_packed = 0; Buf buffer; #ifdef HAVE_FRONT_END uint32_t tmp_offset; front_end_record_t *front_end_ptr; int i; buffer_ptr[0] = NULL; *buffer_size = 0; buffer = init_buf(BUF_SIZE * 2); nodes_packed = 0; if (protocol_version >= SLURM_2_5_PROTOCOL_VERSION) { /* write header: count and time */ pack32(nodes_packed, buffer); pack_time(now, buffer); /* write records */ for (i = 0, front_end_ptr = front_end_nodes; i < front_end_node_cnt; i++, front_end_ptr++) { xassert(front_end_ptr->magic == FRONT_END_MAGIC); _pack_front_end(front_end_ptr, buffer, protocol_version); nodes_packed++; } } else { error("pack_all_front_end: Unsupported slurm version %u", protocol_version); } tmp_offset = get_buf_offset (buffer); set_buf_offset(buffer, 0); pack32(nodes_packed, buffer); set_buf_offset(buffer, tmp_offset); *buffer_size = get_buf_offset(buffer); buffer_ptr[0] = xfer_buf_data(buffer); #else buffer_ptr[0] = NULL; *buffer_size = 0; buffer = init_buf(64); pack32(nodes_packed, buffer); pack_time(now, buffer); *buffer_size = get_buf_offset(buffer); buffer_ptr[0] = xfer_buf_data(buffer); #endif }
extern int slurm_persist_conn_process_msg(slurm_persist_conn_t *persist_conn, persist_msg_t *persist_msg, char *msg_char, uint32_t msg_size, Buf *out_buffer, bool first) { int rc; Buf recv_buffer = NULL; char *comment = NULL; /* puts msg_char into buffer struct */ recv_buffer = create_buf(msg_char, msg_size); memset(persist_msg, 0, sizeof(persist_msg_t)); rc = slurm_persist_msg_unpack(persist_conn, persist_msg, recv_buffer); xfer_buf_data(recv_buffer); /* delete in_buffer struct * without xfree of msg_char * (done later in this * function). */ if (rc != SLURM_SUCCESS) { comment = xstrdup_printf("Failed to unpack %s message", slurmdbd_msg_type_2_str( persist_msg->msg_type, true)); error("CONN:%u %s", persist_conn->fd, comment); *out_buffer = slurm_persist_make_rc_msg( persist_conn, rc, comment, persist_msg->msg_type); xfree(comment); } /* 2 versions after 17.02 code refering to DBD_INIT can be removed as it will no longer be suppported. */ else if (first && (persist_msg->msg_type != REQUEST_PERSIST_INIT) && (persist_msg->msg_type != DBD_INIT)) { comment = "Initial RPC not REQUEST_PERSIST_INIT"; error("CONN:%u %s type (%d)", persist_conn->fd, comment, persist_msg->msg_type); rc = EINVAL; *out_buffer = slurm_persist_make_rc_msg( persist_conn, rc, comment, REQUEST_PERSIST_INIT); } else if (!first && ((persist_msg->msg_type == REQUEST_PERSIST_INIT) || (persist_msg->msg_type == DBD_INIT))) { comment = "REQUEST_PERSIST_INIT sent after connection established"; error("CONN:%u %s", persist_conn->fd, comment); rc = EINVAL; *out_buffer = slurm_persist_make_rc_msg( persist_conn, rc, comment, REQUEST_PERSIST_INIT); } return rc; }
/* * pack_all_part - dump all partition information for all partitions in * machine independent form (for network transmission) * OUT buffer_ptr - the pointer is set to the allocated buffer. * OUT buffer_size - set to size of the buffer in bytes * IN show_flags - partition filtering options * IN uid - uid of user making request (for partition filtering) * global: part_list - global list of partition records * NOTE: the buffer at *buffer_ptr must be xfreed by the caller * NOTE: change slurm_load_part() in api/part_info.c if data format changes */ extern void pack_all_part(char **buffer_ptr, int *buffer_size, uint16_t show_flags, uid_t uid, uint16_t protocol_version) { ListIterator part_iterator; struct part_record *part_ptr; uint32_t parts_packed; int tmp_offset; Buf buffer; time_t now = time(NULL); buffer_ptr[0] = NULL; *buffer_size = 0; buffer = init_buf(BUF_SIZE); /* write header: version and time */ parts_packed = 0; pack32(parts_packed, buffer); pack_time(now, buffer); /* write individual partition records */ part_iterator = list_iterator_create(part_list); while ((part_ptr = (struct part_record *) list_next(part_iterator))) { xassert (part_ptr->magic == PART_MAGIC); if (((show_flags & SHOW_ALL) == 0) && (uid != 0) && ((part_ptr->flags & PART_FLAG_HIDDEN) || (validate_group (part_ptr, uid) == 0))) continue; pack_part(part_ptr, buffer, protocol_version); parts_packed++; } list_iterator_destroy(part_iterator); /* put the real record count in the message body header */ tmp_offset = get_buf_offset(buffer); set_buf_offset(buffer, 0); pack32(parts_packed, buffer); set_buf_offset(buffer, tmp_offset); *buffer_size = get_buf_offset(buffer); buffer_ptr[0] = xfer_buf_data(buffer); }
/* Pack all scheduling statistics */ extern void pack_all_stat(int resp, char **buffer_ptr, int *buffer_size, uint16_t protocol_version) { Buf buffer; int parts_packed; int agent_queue_size; time_t now = time(NULL); buffer_ptr[0] = NULL; *buffer_size = 0; buffer = init_buf(BUF_SIZE); if (protocol_version >= SLURM_2_5_PROTOCOL_VERSION) { parts_packed = resp; pack32(parts_packed, buffer); if (resp) { pack_time(now, buffer); debug3("pack_all_stat: time = %u", (uint32_t) last_proc_req_start); pack_time(last_proc_req_start, buffer); debug3("pack_all_stat: server_thread_count = %u", slurmctld_config.server_thread_count); pack32(slurmctld_config.server_thread_count, buffer); agent_queue_size = retry_list_size(); pack32(agent_queue_size, buffer); pack32(slurmctld_diag_stats.jobs_submitted, buffer); pack32(slurmctld_diag_stats.jobs_started, buffer); pack32(slurmctld_diag_stats.jobs_completed, buffer); pack32(slurmctld_diag_stats.jobs_canceled, buffer); pack32(slurmctld_diag_stats.jobs_failed, buffer); pack32(slurmctld_diag_stats.schedule_cycle_max, buffer); pack32(slurmctld_diag_stats.schedule_cycle_last, buffer); pack32(slurmctld_diag_stats.schedule_cycle_sum, buffer); pack32(slurmctld_diag_stats.schedule_cycle_counter, buffer); pack32(slurmctld_diag_stats.schedule_cycle_depth, buffer); pack32(slurmctld_diag_stats.schedule_queue_len, buffer); pack32(slurmctld_diag_stats.backfilled_jobs, buffer); pack32(slurmctld_diag_stats.last_backfilled_jobs, buffer); pack32(slurmctld_diag_stats.bf_cycle_counter, buffer); pack32(slurmctld_diag_stats.bf_cycle_sum, buffer); pack32(slurmctld_diag_stats.bf_cycle_last, buffer); pack32(slurmctld_diag_stats.bf_last_depth, buffer); pack32(slurmctld_diag_stats.bf_last_depth_try, buffer); pack32(slurmctld_diag_stats.bf_queue_len, buffer); pack32(slurmctld_diag_stats.bf_cycle_max, buffer); pack_time(slurmctld_diag_stats.bf_when_last_cycle, buffer); pack32(slurmctld_diag_stats.bf_depth_sum, buffer); pack32(slurmctld_diag_stats.bf_depth_try_sum, buffer); pack32(slurmctld_diag_stats.bf_queue_len_sum, buffer); pack32(slurmctld_diag_stats.bf_active, buffer); } } *buffer_size = get_buf_offset(buffer); buffer_ptr[0] = xfer_buf_data(buffer); }
int main (int argc, char *argv[]) { Buf buffer; uint16_t test16 = 1234, out16; uint32_t test32 = 5678, out32, byte_cnt; char testbytes[] = "TEST BYTES", *outbytes; char teststring[] = "TEST STRING", *outstring = NULL; char *nullstr = NULL; char *data; int data_size; long double test_double = 1340664754944.2132312, test_double2; uint64_t test64; buffer = init_buf (0); pack16(test16, buffer); pack32(test32, buffer); pack64((uint64_t)test_double, buffer); packstr(testbytes, buffer); packstr(teststring, buffer); packstr(nullstr, buffer); packstr("literal", buffer); packstr("", buffer); data_size = get_buf_offset(buffer); printf("wrote %d bytes\n", data_size); /* Pull data off old buffer, destroy it, and create a new one */ data = xfer_buf_data(buffer); buffer = create_buf(data, data_size); unpack16(&out16, buffer); TEST(out16 != test16, "un/pack16"); unpack32(&out32, buffer); TEST(out32 != test32, "un/pack32"); unpack64(&test64, buffer); test_double2 = (long double)test64; TEST((uint64_t)test_double2 != (uint64_t)test_double, "un/pack double as a uint64"); /* info("Original\t %Lf", test_double); */ /* info("uint64\t %ld", test64); */ /* info("converted LD\t %Lf", test_double2); */ unpackstr_ptr(&outbytes, &byte_cnt, buffer); TEST( ( strcmp(testbytes, outbytes) != 0 ) , "un/packstr_ptr"); unpackstr_xmalloc(&outstring, &byte_cnt, buffer); TEST(strcmp(teststring, outstring) != 0, "un/packstr_xmalloc"); xfree(outstring); unpackstr_xmalloc(&nullstr, &byte_cnt, buffer); TEST(nullstr != NULL, "un/packstr of null string."); unpackstr_xmalloc(&outstring, &byte_cnt, buffer); TEST(strcmp("literal", outstring) != 0, "un/packstr of string literal"); xfree(outstring); unpackstr_xmalloc(&outstring, &byte_cnt, buffer); TEST(strcmp("", outstring) != 0, "un/packstr of string \"\" "); xfree(outstring); free_buf(buffer); totals(); return failed; }