void print_pss(){
for(int i = 0; i < SIZE; i++)
{
if(contains(i))
{
print_ps(i);
}
}
}
// ----------------------------------------------------------------------
void
SimulationTaskLocalizationEvaluation::
run( SimulationController& sc )
throw( std::runtime_error )
{
require_world( sc );
HeaderInfo header;
Results results;
header.collect_information( sc, *this );
results.collect_information( sc, *this );
print( header, results );
print_ps( sc, header );
write_out( sc, header, results );
}
static void
disp_envc_status()
{
int err;
char *system = "SYSTEM";
picl_nodehdl_t system_node, root;
log_printf(dgettext(TEXT_DOMAIN,
"\n"
"========================= Environmental Status "
"=========================\n\n"));
err = picl_initialize();
if (err != PICL_SUCCESS) {
exit_code = PD_INTERNAL_FAILURE;
goto err_out;
}
err = picl_get_root(&root);
if (err != PICL_SUCCESS) {
exit_code = PD_INTERNAL_FAILURE;
goto err_out;
}
err = find_child_device(root, system, &system_node);
if (err != PICL_SUCCESS) {
exit_code = PD_INTERNAL_FAILURE;
goto err_out;
}
err = print_temps(system_node);
err |= print_keyswitch(system_node);
err |= print_FSP_LEDS(system_node);
err |= print_disk(system_node);
err |= print_fans(system_node);
err |= print_ps(system_node);
if (err != PICL_SUCCESS)
goto err_out;
return;
err_out:
log_printf(dgettext(TEXT_DOMAIN,
"\nEnvironmental reporting error: %s\n"),
picl_strerror(err));
}
int print_es(const char *format, int *i, va_list list)
{
int nb;
int ret;
ret = 0;
(*i)++;
if (format[(*i)] == '0')
{
nb = ft_atoi(nbr(format, i));
ret += print_e(format, i, list, nb);
}
else if (format[(*i)] == '+')
ret += print_ps(format, i, list);
else
{
nb = ft_atoi(nbr(format, i));
ret += print(format, i, list, nb);
}
return(ret);
}
int ft_printf(const char *format, ...)
{
int i;
va_list list;
int size;
int nb;
nb = 0;
size = 0;
i = 0;
va_start(list, format);
while (format[i])
{
size += search_char(format, &i);
if(format[i] == '\0')
return (size);
i++;
if (format[i] == '0')
size += print_0(format, &i, list);
else if (format[i] == ' ')
size += print_es(format, &i, list);
else if (format[i] == '+')
size += print_ps(format, &i, list);
else if (format[i] == '-')
size += print_ng(format, &i, list);
else
{
if(format[i] == '\0')
return (size);
nb = ft_atoi(nbr(format, &i));
size += print(format, &i, list, nb);
}
i++;
}
va_end(list);
return (size);
}
int
main(int argc, char **argv)
{
kstat_ctl_t *kc;
kstat_t *ksp;
kstat_named_t *knp;
struct vcpu *vc;
struct core *core;
struct pchip *chip;
struct link **ins;
char *s;
int nspec;
int optc;
int opt_s = 0;
int opt_p = 0;
int opt_v = 0;
int ex = 0;
cmdname = basename(argv[0]);
(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
(void) textdomain(TEXT_DOMAIN);
/* collect the kstats */
if ((kc = kstat_open()) == NULL)
die(_("kstat_open() failed"));
if ((ksp = kstat_lookup(kc, "cpu_info", -1, NULL)) == NULL)
die(_("kstat_lookup() failed"));
for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
if (strcmp(ksp->ks_module, "cpu_info") != 0)
continue;
if (kstat_read(kc, ksp, NULL) == NULL)
die(_("kstat_read() failed"));
vc = find_link(&vcpus, ksp->ks_instance, &ins);
if (vc == NULL) {
vc = zalloc(sizeof (struct vcpu));
vc->v_link.l_id = ksp->ks_instance;
vc->v_link_core.l_id = ksp->ks_instance;
vc->v_link_pchip.l_id = ksp->ks_instance;
vc->v_link.l_ptr = vc;
vc->v_link_core.l_ptr = vc;
vc->v_link_pchip.l_ptr = vc;
ins_link(ins, &vc->v_link);
}
if ((knp = kstat_data_lookup(ksp, "state")) != NULL) {
vc->v_state = mystrdup(knp->value.c);
} else {
vc->v_state = "unknown";
}
if ((knp = kstat_data_lookup(ksp, "cpu_type")) != NULL) {
vc->v_cpu_type = mystrdup(knp->value.c);
}
if ((knp = kstat_data_lookup(ksp, "fpu_type")) != NULL) {
vc->v_fpu_type = mystrdup(knp->value.c);
}
if ((knp = kstat_data_lookup(ksp, "state_begin")) != NULL) {
vc->v_state_begin = knp->value.l;
}
if ((knp = kstat_data_lookup(ksp, "clock_MHz")) != NULL) {
vc->v_clock_mhz = knp->value.l;
}
if ((knp = kstat_data_lookup(ksp, "brand")) == NULL) {
vc->v_brand = _("(unknown)");
} else {
vc->v_brand = mystrdup(knp->value.str.addr.ptr);
}
if ((knp = kstat_data_lookup(ksp, "socket_type")) == NULL) {
vc->v_socket = "Unknown";
} else {
vc->v_socket = mystrdup(knp->value.str.addr.ptr);
}
if ((knp = kstat_data_lookup(ksp, "implementation")) == NULL) {
vc->v_impl = _("(unknown)");
} else {
vc->v_impl = mystrdup(knp->value.str.addr.ptr);
}
/*
* Legacy code removed the chipid and cpuid fields... we
* do the same for compatibility. Note that the original
* pattern is a bit strange, and we have to emulate this because
* on SPARC we *do* emit these. The original pattern we are
* emulating is: $impl =~ s/(cpuid|chipid)\s*\w+\s+//;
*/
if ((s = strstr(vc->v_impl, "chipid")) != NULL) {
char *x = s + strlen("chipid");
while (isspace(*x))
x++;
if ((!isalnum(*x)) && (*x != '_'))
goto nochipid;
while (isalnum(*x) || (*x == '_'))
x++;
if (!isspace(*x))
goto nochipid;
while (isspace(*x))
x++;
(void) strcpy(s, x);
}
nochipid:
if ((s = strstr(vc->v_impl, "cpuid")) != NULL) {
char *x = s + strlen("cpuid");
while (isspace(*x))
x++;
if ((!isalnum(*x)) && (*x != '_'))
goto nocpuid;
while (isalnum(*x) || (*x == '_'))
x++;
if (!isspace(*x))
goto nocpuid;
while (isspace(*x))
x++;
(void) strcpy(s, x);
}
nocpuid:
if ((knp = kstat_data_lookup(ksp, "chip_id")) != NULL)
vc->v_pchip_id = knp->value.l;
chip = find_link(&pchips, vc->v_pchip_id, &ins);
if (chip == NULL) {
chip = zalloc(sizeof (struct pchip));
chip->p_link.l_id = vc->v_pchip_id;
chip->p_link.l_ptr = chip;
ins_link(ins, &chip->p_link);
}
vc->v_pchip = chip;
if ((knp = kstat_data_lookup(ksp, "core_id")) != NULL)
vc->v_core_id = knp->value.l;
core = find_link(&cores, vc->v_core_id, &ins);
if (core == NULL) {
core = zalloc(sizeof (struct core));
core->c_link.l_id = vc->v_core_id;
core->c_link.l_ptr = core;
core->c_link_pchip.l_id = vc->v_core_id;
core->c_link_pchip.l_ptr = core;
core->c_pchip = chip;
ins_link(ins, &core->c_link);
chip->p_ncore++;
(void) find_link(&chip->p_cores, core->c_link.l_id,
&ins);
ins_link(ins, &core->c_link_pchip);
}
vc->v_core = core;
/* now put other linkages in place */
(void) find_link(&chip->p_vcpus, vc->v_link.l_id, &ins);
ins_link(ins, &vc->v_link_pchip);
chip->p_nvcpu++;
(void) find_link(&core->c_vcpus, vc->v_link.l_id, &ins);
ins_link(ins, &vc->v_link_core);
core->c_nvcpu++;
}
(void) kstat_close(kc);
nspec = 0;
while ((optc = getopt(argc, argv, "pvs")) != EOF) {
switch (optc) {
case 's':
opt_s = 1;
break;
case 'p':
opt_p = 1;
break;
case 'v':
opt_v = 1;
break;
default:
usage(NULL);
}
}
while (optind < argc) {
long id;
char *eptr;
struct link *l;
id = strtol(argv[optind], &eptr, 10);
l = find_link(&vcpus, id, NULL);
if ((*eptr != '\0') || (l == NULL)) {
(void) fprintf(stderr,
_("%s: processor %s: Invalid argument\n"),
cmdname, argv[optind]);
ex = 2;
} else {
((struct vcpu *)l->l_ptr)->v_doit = 1;
((struct vcpu *)l->l_ptr)->v_pchip->p_doit = 1;
((struct vcpu *)l->l_ptr)->v_core->c_doit = 1;
}
nspec++;
optind++;
}
if (opt_s && opt_v) {
usage(_("options -s and -v are mutually exclusive"));
}
if (opt_s && nspec != 1) {
usage(_("must specify exactly one processor if -s used"));
}
if (opt_v && opt_p) {
print_vp(nspec);
} else if (opt_s && opt_p) {
print_ps();
} else if (opt_p) {
print_p(nspec);
} else if (opt_v) {
print_v(nspec);
} else if (opt_s) {
print_s();
} else {
print_normal(nspec);
}
return (ex);
}
static int res_cm_id_parse_cb(const struct nlmsghdr *nlh, void *data)
{
struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
struct nlattr *nla_table, *nla_entry;
struct rd *rd = data;
const char *name;
int idx;
mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] ||
!tb[RDMA_NLDEV_ATTR_DEV_NAME] ||
!tb[RDMA_NLDEV_ATTR_RES_CM_ID])
return MNL_CB_ERROR;
name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
nla_table = tb[RDMA_NLDEV_ATTR_RES_CM_ID];
mnl_attr_for_each_nested(nla_entry, nla_table) {
struct nlattr *nla_line[RDMA_NLDEV_ATTR_MAX] = {};
char src_addr_str[INET6_ADDRSTRLEN];
char dst_addr_str[INET6_ADDRSTRLEN];
uint16_t src_port, dst_port;
uint32_t port = 0, pid = 0;
uint8_t type = 0, state;
uint32_t lqpn = 0, ps;
char *comm = NULL;
int err;
err = mnl_attr_parse_nested(nla_entry, rd_attr_cb, nla_line);
if (err != MNL_CB_OK)
return -EINVAL;
if (!nla_line[RDMA_NLDEV_ATTR_RES_STATE] ||
!nla_line[RDMA_NLDEV_ATTR_RES_PS] ||
(!nla_line[RDMA_NLDEV_ATTR_RES_PID] &&
!nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME])) {
return MNL_CB_ERROR;
}
if (nla_line[RDMA_NLDEV_ATTR_PORT_INDEX])
port = mnl_attr_get_u32(
nla_line[RDMA_NLDEV_ATTR_PORT_INDEX]);
if (port && port != rd->port_idx)
continue;
if (nla_line[RDMA_NLDEV_ATTR_RES_LQPN]) {
lqpn = mnl_attr_get_u32(
nla_line[RDMA_NLDEV_ATTR_RES_LQPN]);
if (rd_check_is_filtered(rd, "lqpn", lqpn))
continue;
}
if (nla_line[RDMA_NLDEV_ATTR_RES_TYPE]) {
type = mnl_attr_get_u8(
nla_line[RDMA_NLDEV_ATTR_RES_TYPE]);
if (rd_check_is_string_filtered(rd, "qp-type",
qp_types_to_str(type)))
continue;
}
ps = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_PS]);
if (rd_check_is_string_filtered(rd, "ps", cm_id_ps_to_str(ps)))
continue;
state = mnl_attr_get_u8(nla_line[RDMA_NLDEV_ATTR_RES_STATE]);
if (rd_check_is_string_filtered(rd, "state",
cm_id_state_to_str(state)))
continue;
if (nla_line[RDMA_NLDEV_ATTR_RES_SRC_ADDR]) {
if (ss_ntop(nla_line[RDMA_NLDEV_ATTR_RES_SRC_ADDR],
src_addr_str, &src_port))
continue;
if (rd_check_is_string_filtered(rd, "src-addr",
src_addr_str))
continue;
if (rd_check_is_filtered(rd, "src-port", src_port))
continue;
}
if (nla_line[RDMA_NLDEV_ATTR_RES_DST_ADDR]) {
if (ss_ntop(nla_line[RDMA_NLDEV_ATTR_RES_DST_ADDR],
dst_addr_str, &dst_port))
continue;
if (rd_check_is_string_filtered(rd, "dst-addr",
dst_addr_str))
continue;
if (rd_check_is_filtered(rd, "dst-port", dst_port))
continue;
}
if (nla_line[RDMA_NLDEV_ATTR_RES_PID]) {
pid = mnl_attr_get_u32(
nla_line[RDMA_NLDEV_ATTR_RES_PID]);
comm = get_task_name(pid);
}
if (rd_check_is_filtered(rd, "pid", pid)) {
free(comm);
continue;
}
if (nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME]) {
/* discard const from mnl_attr_get_str */
comm = (char *)mnl_attr_get_str(
nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME]);
}
if (rd->json_output)
jsonw_start_array(rd->jw);
print_link(rd, idx, name, port, nla_line);
if (nla_line[RDMA_NLDEV_ATTR_RES_LQPN])
print_lqpn(rd, lqpn);
if (nla_line[RDMA_NLDEV_ATTR_RES_TYPE])
print_qp_type(rd, type);
print_cm_id_state(rd, state);
print_ps(rd, ps);
print_pid(rd, pid);
print_comm(rd, comm, nla_line);
if (nla_line[RDMA_NLDEV_ATTR_RES_SRC_ADDR])
print_ipaddr(rd, "src-addr", src_addr_str, src_port);
if (nla_line[RDMA_NLDEV_ATTR_RES_DST_ADDR])
print_ipaddr(rd, "dst-addr", dst_addr_str, dst_port);
if (nla_line[RDMA_NLDEV_ATTR_RES_PID])
free(comm);
print_driver_table(rd, nla_line[RDMA_NLDEV_ATTR_DRIVER]);
newline(rd);
}
return MNL_CB_OK;
}
int main() {
int count;
char *rest, *command_str, *param_str, *param2_str;
//Inicializar terminal...
devreq(KEYBOARD);
devreq(SCREEN);
devreq(TERMINAL);
while(TRUE) {
write(TERMINAL, PROMPT, strlen(PROMPT));
count = read_line(line_buffer, BUFF_LEN);
if (count == -1) {
while (read_line(line_buffer, BUFF_LEN) != 1);
write_line("Line too long");
} else {
line_buffer[count -1] = NULL;
rest = skip_spaces(line_buffer);
if (!*rest) {
command_use_error();
continue;
}
command_str = get_word(&rest);
rest = skip_spaces(rest);
param_str = get_word(&rest);
rest = skip_spaces(rest);
if (strcmp(HELP, command_str) == 0) {
print_shell_use();
} else if (strcmp(ECHO, command_str) == 0) {
write_line(param_str);
} else if (strcmp(PS, command_str) == 0) {
//Imprimir informacion de programas en ejecucion
print_ps(param_str);
} else if (strcmp(LS, command_str) == 0) {
//Imprimir lista de programas disponibles
print_ls(param_str);
} else if (strcmp(RUN, command_str) == 0) {
//Ejecutar un programa en foreground
do_run(param_str);
} else if (strcmp(RUN_BG, command_str) == 0) {
//Ejecutar un programa en background
do_runbg(param_str);
} else if (strcmp(NICE, command_str) == 0) {
param2_str = get_word(&rest);
//Cambiar prioridad de un proceso
do_nice(param_str, param2_str);
} else if (strcmp(KILL, command_str) == 0) {
//Ejecutar un programa en background
do_kill(param_str);
} else
command_use_error();
}
}
return 0;
}