void runCommand(char ** args) {
pid_t pid;
bool bg;
pid = fork();
bg = is_background(args);
if (pid < 0) {
/* error */
printf("Error in forking. We should check this out.");
} else if (pid == 0) {
/* Child */
if (execvp(args[0], args) < 0) {
printf("Could not find program or it failed in some way\n");
exit(1);
}
if (bg) {
/* should the child do something special when its in bg mode? */
free(args);
}
} else {
/* parent */
if (!bg) {
int status;
print_pid(pid);
while (wait(&status) != pid); /* wait for completion HITTAD DEN RAD ONLINE */
print_pid(pid);
free(args);
}
}
}
void
batch_print(int tprocs, int tnodes)
{
int i, vnodes;
char buf[80];
switch (displaymode) {
case DISPLAY_LOAD:
memcpy(sortnode, nodedata, sizeof(nodedata_t) * tnodes);
for (i=0, vnodes=0; i < tnodes; i++)
if (nodedata[i].node != NULL)
vnodes++;
qsort(sortnode, vnodes, sizeof(nodedata_t), compare_node);
printf("%*s %6s %6s %6s %6s %6s %6s %6s %6s %6s %6s\n",
maxnodelen, "HOSTNAME", "PROCS", "LOAD1", "LOAD5",
"LOAD15", "ACTIVE", "INACT", "FILE", "FREE",
"SWPFRE", "SWUSED");
for (i=0; i < vnodes; i++) {
print_nodedata(buf, i);
printf("%s\n", buf);
}
break;
case DISPLAY_PROC:
default:
printf("%*s %6s %8s %6s %6s %6s %s\n", maxnodelen, "HOSTNAME",
"PID", "USERNAME", "SIZE", "RES", "CPU", "COMMAND");
printf("tprocs==%d showprocs==%d\n", tprocs, showprocs);
for (i=0; i < tprocs && i < showprocs; i++) {
print_pid(buf, i);
printf("%s\n", buf);
}
break;
}
}
int run_test(ssize_t f, char c) {
int exit = 0;
switch(c) {
case 'q':
case 'Q':
exit = 1;
break;
case 'i':
case 'I':
printf ("Vendor id = 0x%x, Device id = 0x%x\n",
get_vendor_id(f), get_device_id(f));
print_pid();
break;
case 'h':
case 'H':
print_help();
break;
case '1':
test_auto_discovery_read(f);
break;
case '2':
test_global_mem_write (f);
break;
case '3':
test_dma_writes(f);
break;
default:
printf("Invalid selection (%c).\n", c);
exit = 1;
break;
}
return exit;
}
void runCommand(char ** args) {
pid_t pid;
bool bg;
pid = fork();
bg = is_background(args);
pipe(pipes[0]);
if (pid < 0) {
/* error */
printf("Error in forking. We should check this out.");
} else if (pid == 0) {
/* Child */
if (execvp(args[0], args) < 0) {
printf("Could not find program or it failed in some way\n");
exit(1);
}
if (bg) {
/* should the child do something special when its in bg mode? */
free(args);
}
char string[] = "hej";
close(pipes[0][READ]);
write(pipes[0][WRITE], string, strlen(string)+1);
close(pipes[0][WRITE]);
} else {
/* parent */
if (!bg) {
int status;
print_pid(pid);
while (wait(&status) != pid); /* wait for completion HITTAD DEN RAD ONLINE */
print_pid(pid);
free(args);
}
char msg[100];
close(pipes[0][WRITE]);
read(pipes[0][READ], msg, sizeof(msg));
close(pipes[0][READ]);
printf("pipe message: %s\n", msg);
}
}
int main()
{
struct sigaction *act;
if (!(act = act_init(act)))
my_error(4, 6);
signal_init(act);
print_pid(getpid());
call_next_client(getpid());
}
void print_pids( uint8_t *p_data )
{
int i_pid;
print_pids_header();
for ( i_pid = 0; i_pid < MAX_PIDS; i_pid++ ) {
ts_pid_info_t *p_info = (ts_pid_info_t *)(p_data + i_pid * sizeof(ts_pid_info_t));
print_pid( i_pid, p_info );
}
print_pids_footer();
}
/*
Handles child 2
*/
void handle_child2()
{
sleep(1);
print_pid("C2");
sleep(3);
adjust_whale("C2", 5);
sleep(3);
print_cwd("C2");
_exit(0);
}
static int pid_test(IC_Env *env)
{
erlang_pid pid = {"", 7, 0, 0}, pido, pidr;
strcpy(pid.node, this_node), /* this currently running node */
fprintf(stdout, "\n======== m_i_pid test ======\n\n");
pidr = m_i_pid_test(NULL, &pid, &pido, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(cmp_pid(&pid, &pido) && cmp_pid(&pid, &pidr));
if (!cmp_pid(&pid, &pido)) {
fprintf(stdout, " out parameter error, sent:\n");
print_pid(&pid);
fprintf(stdout, "got:\n");
print_pid(&pido);
}
if (!cmp_pid(&pid, &pidr)) {
fprintf(stdout, " result error, sent:\n");
print_pid(&pid);
fprintf(stdout, "got:\n");
print_pid(&pidr);
}
return -1;
}
/*
Handle child 1
*/
void handle_child1()
{
print_pid("C1");
sleep(3);
adjust_whale("C1", 6);
sleep(3);
printf("C1:\t");
if(fflush(stdout) < 0)
{
perror("Failed to fflush");
_exit(1);
}
chdir("/");
execlp("ls", "ls", "-la", (char *) NULL);
// should never reach this. if we do, exec fails
_exit(1);
}
int main(void)
{
/* print PIDs */
print_pid("P0");
/* User/Hostname */
print_userhost();
/* Time */
print_time();
/* CWD */
print_cwd("P0");
/* Create ENV Var */
putenv(env_var); // to change env variable, change actual character pointer
handle_processes();
return 0;
}
int main() {
ssize_t f = open ("/dev/de4", O_RDWR);
if (f == -1) {
printf ("Couldn't open the device. Did you load the driver?\n");
return 0;
} else {
printf ("Opened the device: file handle #%zu!\n", f);
}
printf ("Vendor id = 0x%x, Device id = 0x%x\n",
get_vendor_id(f), get_device_id(f));
print_pid();
test_global_mem_write(f);
int i;
/* Change upper limit to a larger number (e.g. 1000) for stress testing */
for (i = 0; i < 1; i++) {
printf ("-- %d --\n", i);
test_auto_discovery_read (f);
test_small_writes (f);
test_global_mem(f);
// test_large_read_write (f);
// test_reprogram(f);
test_dma_writes(f);
// test_cvp(f);
}
test_global_mem_write(f);
printf ("Done testing!\n");
close (f);
return 0;
}
void
curses_print(int tprocs, int tnodes)
{
int i, vnodes;
char buf[80];
if (debug)
return;
move(2, 0);
clrtobot();
refresh();
switch (displaymode) {
case DISPLAY_LOAD:
memcpy(sortnode, nodedata, sizeof(nodedata_t) * tnodes);
for (i=0, vnodes=0; i < tnodes; i++)
if (nodedata[i].node != NULL)
vnodes++;
qsort(sortnode, vnodes, sizeof(nodedata_t), compare_node);
for (i=0; i < vnodes && i < (LINES-2); i++) {
print_nodedata(buf, i);
move(i+2, 0);
addstr(buf);
}
break;
case DISPLAY_PROC:
default:
for (i=0; i < tprocs && i < (LINES-2); i++) {
print_pid(buf, i);
move(i+2, 0);
addstr(buf);
}
break;
}
move(0, 0);
refresh();
}
int main( int i_argc, char **ppsz_argv )
{
char *client_socket_tmpl = "dvblastctl.clientsock.XXXXXX";
char *psz_srv_socket = NULL;
int i;
char *p_cmd, *p_arg1 = NULL, *p_arg2 = NULL;
ssize_t i_size;
struct sockaddr_un sun_client, sun_server;
uint8_t p_buffer[COMM_BUFFER_SIZE];
uint8_t *p_data = p_buffer + COMM_HEADER_SIZE;
uint16_t i_pid = 0;
struct dvblastctl_option opt = { 0, 0, 0 };
for ( ; ; )
{
int c;
static const struct option long_options[] =
{
{"remote-socket", required_argument, NULL, 'r'},
{"print", required_argument, NULL, 'x'},
{"help", no_argument, NULL, 'h'},
{0, 0, 0, 0}
};
if ( (c = getopt_long(i_argc, ppsz_argv, "r:x:h", long_options, NULL)) == -1 )
break;
switch ( c )
{
case 'r':
psz_srv_socket = optarg;
break;
case 'x':
if ( !strcmp(optarg, "text") )
i_print_type = PRINT_TEXT;
else if ( !strcmp(optarg, "xml") )
i_print_type = PRINT_XML;
else
msg_Warn( NULL, "unrecognized print type %s", optarg );
/* Make stdout line-buffered */
setvbuf(stdout, NULL, _IOLBF, 0);
break;
case 'h':
default:
usage();
}
}
/* Validate commands */
#define usage_error(msg, ...) \
do { \
msg_Err( NULL, msg, ##__VA_ARGS__ ); \
usage(); \
} while(0)
p_cmd = ppsz_argv[optind];
p_arg1 = ppsz_argv[optind + 1];
p_arg2 = ppsz_argv[optind + 2];
if ( !psz_srv_socket )
usage_error( "Remote socket is not set.\n" );
if ( !p_cmd )
usage_error( "Command is not set.\n" );
i = 0;
do {
if ( streq(ppsz_argv[optind], options[i].opt) )
{
opt = options[i];
break;
}
} while ( options[++i].opt );
if ( !opt.opt )
usage_error( "Unknown command: %s\n", p_cmd );
if ( opt.nparams == 1 && !p_arg1 )
usage_error( "%s option needs parameter.\n", opt.opt );
if ( opt.nparams == 2 && (!p_arg1 || !p_arg2) )
usage_error( "%s option needs two parameters.\n", opt.opt );
#undef usage_error
/* Create client socket name */
char *tmpdir = getenv("TMPDIR");
snprintf( psz_client_socket, PATH_MAX - 1, "%s/%s",
tmpdir ? tmpdir : "/tmp", client_socket_tmpl );
psz_client_socket[PATH_MAX - 1] = '\0';
int tmp_fd = mkstemp(psz_client_socket);
if ( tmp_fd > -1 ) {
close(tmp_fd);
unlink(psz_client_socket);
} else {
return_error( "Cannot build UNIX socket %s (%s)", psz_client_socket, strerror(errno) );
}
if ( (i_fd = socket( AF_UNIX, SOCK_DGRAM, 0 )) < 0 )
return_error( "Cannot create UNIX socket (%s)", strerror(errno) );
i = COMM_MAX_MSG_CHUNK;
setsockopt( i_fd, SOL_SOCKET, SO_RCVBUF, &i, sizeof(i) );
memset( &sun_client, 0, sizeof(sun_client) );
sun_client.sun_family = AF_UNIX;
strncpy( sun_client.sun_path, psz_client_socket,
sizeof(sun_client.sun_path) );
sun_client.sun_path[sizeof(sun_client.sun_path) - 1] = '\0';
if ( bind( i_fd, (struct sockaddr *)&sun_client,
SUN_LEN(&sun_client) ) < 0 )
return_error( "Cannot bind (%s)", strerror(errno) );
memset( &sun_server, 0, sizeof(sun_server) );
sun_server.sun_family = AF_UNIX;
strncpy( sun_server.sun_path, psz_srv_socket, sizeof(sun_server.sun_path) );
sun_server.sun_path[sizeof(sun_server.sun_path) - 1] = '\0';
p_buffer[0] = COMM_HEADER_MAGIC;
p_buffer[1] = opt.cmd;
memset( p_buffer + 2, 0, COMM_HEADER_SIZE - 2 );
i_size = COMM_HEADER_SIZE;
/* Handle commands that send parameters */
switch ( opt.cmd )
{
case CMD_INVALID:
case CMD_RELOAD:
case CMD_SHUTDOWN:
case CMD_FRONTEND_STATUS:
case CMD_MMI_STATUS:
case CMD_GET_PAT:
case CMD_GET_CAT:
case CMD_GET_NIT:
case CMD_GET_SDT:
case CMD_GET_PIDS:
/* These commands need no special handling because they have no parameters */
break;
case CMD_GET_PMT:
{
uint16_t i_sid = atoi(p_arg1);
i_size = COMM_HEADER_SIZE + 2;
p_data[0] = (uint8_t)((i_sid >> 8) & 0xff);
p_data[1] = (uint8_t)(i_sid & 0xff);
break;
}
case CMD_GET_PID:
{
i_pid = (uint16_t)atoi(p_arg1);
i_size = COMM_HEADER_SIZE + 2;
p_data[0] = (uint8_t)((i_pid >> 8) & 0xff);
p_data[1] = (uint8_t)(i_pid & 0xff);
break;
}
case CMD_MMI_SEND_TEXT:
{
struct cmd_mmi_send *p_cmd = (struct cmd_mmi_send *)p_data;
p_cmd->i_slot = atoi(p_arg1);
en50221_mmi_object_t object;
object.i_object_type = EN50221_MMI_ANSW;
if ( !p_arg2 || p_arg2[0] == '\0' )
{
object.u.answ.b_ok = 0;
object.u.answ.psz_answ = "";
}
else
{
object.u.answ.b_ok = 1;
object.u.answ.psz_answ = p_arg2;
}
i_size = COMM_BUFFER_SIZE - COMM_HEADER_SIZE
- ((void *)&p_cmd->object - (void *)p_cmd);
if ( en50221_SerializeMMIObject( (uint8_t *)&p_cmd->object,
&i_size, &object ) == -1 )
return_error( "Comm buffer is too small" );
i_size += COMM_HEADER_SIZE
+ ((void *)&p_cmd->object - (void *)p_cmd);
break;
}
case CMD_MMI_SEND_CHOICE:
{
struct cmd_mmi_send *p_cmd = (struct cmd_mmi_send *)p_data;
p_cmd->i_slot = atoi(p_arg1);
i_size = COMM_HEADER_SIZE + sizeof(struct cmd_mmi_send);
p_cmd->object.i_object_type = EN50221_MMI_MENU_ANSW;
p_cmd->object.u.menu_answ.i_choice = atoi(p_arg2);
break;
}
case CMD_MMI_SLOT_STATUS:
case CMD_MMI_OPEN:
case CMD_MMI_CLOSE:
case CMD_MMI_RECV:
{
p_data[0] = atoi(p_arg1);
i_size = COMM_HEADER_SIZE + 1;
break;
}
default:
/* This should not happen */
return_error( "Unhandled option (%d)", opt.cmd );
}
/* Send command and receive answer */
if ( sendto( i_fd, p_buffer, i_size, 0, (struct sockaddr *)&sun_server,
SUN_LEN(&sun_server) ) < 0 )
return_error( "Cannot send comm socket (%s)", strerror(errno) );
uint32_t i_packet_size = 0, i_received = 0;
do {
i_size = recv( i_fd, p_buffer + i_received, COMM_MAX_MSG_CHUNK, 0 );
if ( i_size == -1 )
break;
if ( !i_packet_size ) {
uint32_t *p_packet_size = (uint32_t *)&p_buffer[4];
i_packet_size = *p_packet_size;
if ( i_packet_size > COMM_BUFFER_SIZE ) {
i_size = -1;
break;
}
}
i_received += i_size;
} while ( i_received < i_packet_size );
clean_client_socket();
if ( i_size < COMM_HEADER_SIZE )
return_error( "Cannot recv from comm socket, size:%zd (%s)", i_size, strerror(errno) );
/* Process answer */
if ( p_buffer[0] != COMM_HEADER_MAGIC )
return_error( "Wrong protocol version 0x%x", p_buffer[0] );
now = mdate();
ctl_cmd_answer_t c_answer = p_buffer[1];
switch ( c_answer )
{
case RET_OK:
break;
case RET_MMI_WAIT:
exit(252);
break;
case RET_ERR:
return_error( "Request failed" );
break;
case RET_HUH:
return_error( "Internal error" );
break;
case RET_NODATA:
return_error( "No data" );
break;
case RET_PAT:
case RET_CAT:
case RET_NIT:
case RET_SDT:
{
uint8_t *p_flat_data = p_buffer + COMM_HEADER_SIZE;
unsigned int i_flat_data_size = i_size - COMM_HEADER_SIZE;
uint8_t **pp_sections = psi_unpack_sections( p_flat_data, i_flat_data_size );
switch( c_answer )
{
case RET_PAT: pat_table_print( pp_sections, psi_print, NULL, i_print_type ); break;
case RET_CAT: cat_table_print( pp_sections, psi_print, NULL, i_print_type ); break;
case RET_NIT: nit_table_print( pp_sections, psi_print, NULL, psi_iconv, NULL, i_print_type ); break;
case RET_SDT: sdt_table_print( pp_sections, psi_print, NULL, psi_iconv, NULL, i_print_type ); break;
default: break; /* Can't happen */
}
psi_table_free( pp_sections );
free( pp_sections );
break;
}
case RET_PMT:
{
pmt_print( p_data, psi_print, NULL, psi_iconv, NULL, i_print_type );
break;
}
case RET_PID:
{
print_pids_header();
print_pid( i_pid, (ts_pid_info_t *)p_data );
print_pids_footer();
break;
}
case RET_PIDS:
{
print_pids( p_data );
break;
}
case RET_FRONTEND_STATUS:
{
int ret = 1;
struct ret_frontend_status *p_ret =
(struct ret_frontend_status *)&p_buffer[COMM_HEADER_SIZE];
if ( i_size != COMM_HEADER_SIZE + sizeof(struct ret_frontend_status) )
return_error( "Bad frontend status" );
if ( i_print_type == PRINT_XML )
printf("<FRONTEND>\n");
#define PRINT_TYPE( x ) \
do { \
if ( i_print_type == PRINT_XML ) \
printf( " <TYPE type=\"%s\"/>\n", STRINGIFY(x) ); \
else \
printf( "type: %s\n", STRINGIFY(x) ); \
} while(0)
switch ( p_ret->info.type )
{
case FE_QPSK: PRINT_TYPE(QPSK); break;
case FE_QAM : PRINT_TYPE(QAM); break;
case FE_OFDM: PRINT_TYPE(OFDM); break;
case FE_ATSC: PRINT_TYPE(ATSC); break;
default : PRINT_TYPE(UNKNOWN); break;
}
#undef PRINT_TYPE
#define PRINT_INFO( x ) \
do { \
if ( i_print_type == PRINT_XML ) \
printf( " <SETTING %s=\"%u\"/>\n", STRINGIFY(x), p_ret->info.x ); \
else \
printf( "%s: %u\n", STRINGIFY(x), p_ret->info.x ); \
} while(0)
PRINT_INFO( frequency_min );
PRINT_INFO( frequency_max );
PRINT_INFO( frequency_stepsize );
PRINT_INFO( frequency_tolerance );
PRINT_INFO( symbol_rate_min );
PRINT_INFO( symbol_rate_max );
PRINT_INFO( symbol_rate_tolerance );
PRINT_INFO( notifier_delay );
#undef PRINT_INFO
if ( i_print_type == PRINT_TEXT )
printf("\ncapability list:\n");
#define PRINT_CAPS( x ) \
do { \
if ( p_ret->info.caps & (FE_##x) ) { \
if ( i_print_type == PRINT_XML ) { \
printf( " <CAPABILITY %s=\"1\"/>\n", STRINGIFY(x) ); \
} else { \
printf( "%s\n", STRINGIFY(x) ); \
} \
} \
} while(0)
PRINT_CAPS( IS_STUPID );
PRINT_CAPS( CAN_INVERSION_AUTO );
PRINT_CAPS( CAN_FEC_1_2 );
PRINT_CAPS( CAN_FEC_2_3 );
PRINT_CAPS( CAN_FEC_3_4 );
PRINT_CAPS( CAN_FEC_4_5 );
PRINT_CAPS( CAN_FEC_5_6 );
PRINT_CAPS( CAN_FEC_6_7 );
PRINT_CAPS( CAN_FEC_7_8 );
PRINT_CAPS( CAN_FEC_8_9 );
PRINT_CAPS( CAN_FEC_AUTO );
PRINT_CAPS( CAN_QPSK );
PRINT_CAPS( CAN_QAM_16 );
PRINT_CAPS( CAN_QAM_32 );
PRINT_CAPS( CAN_QAM_64 );
PRINT_CAPS( CAN_QAM_128 );
PRINT_CAPS( CAN_QAM_256 );
PRINT_CAPS( CAN_QAM_AUTO );
PRINT_CAPS( CAN_TRANSMISSION_MODE_AUTO );
PRINT_CAPS( CAN_BANDWIDTH_AUTO );
PRINT_CAPS( CAN_GUARD_INTERVAL_AUTO );
PRINT_CAPS( CAN_HIERARCHY_AUTO );
PRINT_CAPS( CAN_MUTE_TS );
#define DVBAPI_VERSION ((DVB_API_VERSION)*100+(DVB_API_VERSION_MINOR))
#if DVBAPI_VERSION >= 301
PRINT_CAPS( CAN_8VSB );
PRINT_CAPS( CAN_16VSB );
PRINT_CAPS( NEEDS_BENDING );
PRINT_CAPS( CAN_RECOVER );
#endif
#if DVBAPI_VERSION >= 500
PRINT_CAPS( HAS_EXTENDED_CAPS );
#endif
#if DVBAPI_VERSION >= 501
PRINT_CAPS( CAN_2G_MODULATION );
#endif
#undef PRINT_CAPS
if ( i_print_type == PRINT_TEXT )
printf("\nstatus:\n");
#define PRINT_STATUS( x ) \
do { \
if ( p_ret->i_status & (FE_##x) ) { \
if ( i_print_type == PRINT_XML ) { \
printf( " <STATUS status=\"%s\"/>\n", STRINGIFY(x) ); \
} else { \
printf( "%s\n", STRINGIFY(x) ); \
} \
} \
} while(0)
PRINT_STATUS( HAS_SIGNAL );
PRINT_STATUS( HAS_CARRIER );
PRINT_STATUS( HAS_VITERBI );
PRINT_STATUS( HAS_SYNC );
PRINT_STATUS( HAS_LOCK );
PRINT_STATUS( REINIT );
#undef PRINT_STATUS
if ( p_ret->i_status & FE_HAS_LOCK )
{
if ( i_print_type == PRINT_XML )
{
printf(" <VALUE bit_error_rate=\"%d\"/>\n", p_ret->i_ber);
printf(" <VALUE signal_strength=\"%d\"/>\n", p_ret->i_strength);
printf(" <VALUE SNR=\"%d\"/>\n", p_ret->i_snr);
} else {
printf("\nBit error rate: %d\n", p_ret->i_ber);
printf("Signal strength: %d\n", p_ret->i_strength);
printf("SNR: %d\n", p_ret->i_snr);
}
ret = 0;
}
if ( i_print_type == PRINT_XML )
printf("</FRONTEND>\n" );
exit(ret);
break;
}
case RET_MMI_STATUS:
{
struct ret_mmi_status *p_ret =
(struct ret_mmi_status *)&p_buffer[COMM_HEADER_SIZE];
if ( i_size != COMM_HEADER_SIZE + sizeof(struct ret_mmi_status) )
return_error( "Bad MMI status" );
printf("CA interface with %d %s, type:\n", p_ret->caps.slot_num,
p_ret->caps.slot_num == 1 ? "slot" : "slots");
#define PRINT_CAPS( x, s ) \
if ( p_ret->caps.slot_type & (CA_##x) ) \
printf(s "\n");
PRINT_CAPS( CI, "CI high level interface" );
PRINT_CAPS( CI_LINK, "CI link layer level interface" );
PRINT_CAPS( CI_PHYS, "CI physical layer level interface (not supported)" );
PRINT_CAPS( DESCR, "built-in descrambler" );
PRINT_CAPS( SC, "simple smartcard interface" );
#undef PRINT_CAPS
printf("\n%d available %s\n", p_ret->caps.descr_num,
p_ret->caps.descr_num == 1 ? "descrambler (key)" :
"descramblers (keys)");
#define PRINT_DESC( x ) \
if ( p_ret->caps.descr_type & (CA_##x) ) \
printf( STRINGIFY(x) "\n" );
PRINT_DESC( ECD );
PRINT_DESC( NDS );
PRINT_DESC( DSS );
#undef PRINT_DESC
exit( p_ret->caps.slot_num );
break;
}
case RET_MMI_SLOT_STATUS:
{
struct ret_mmi_slot_status *p_ret =
(struct ret_mmi_slot_status *)&p_buffer[COMM_HEADER_SIZE];
if ( i_size < COMM_HEADER_SIZE + sizeof(struct ret_mmi_slot_status) )
return_error( "Bad MMI slot status" );
printf("CA slot #%u: ", p_ret->sinfo.num);
#define PRINT_TYPE( x, s ) \
if ( p_ret->sinfo.type & (CA_##x) ) \
printf(s);
PRINT_TYPE( CI, "high level, " );
PRINT_TYPE( CI_LINK, "link layer level, " );
PRINT_TYPE( CI_PHYS, "physical layer level, " );
#undef PRINT_TYPE
if ( p_ret->sinfo.flags & CA_CI_MODULE_READY )
{
printf("module present and ready\n");
exit(0);
}
if ( p_ret->sinfo.flags & CA_CI_MODULE_PRESENT )
printf("module present, not ready\n");
else
printf("module not present\n");
exit(1);
break;
}
case RET_MMI_RECV:
{
struct ret_mmi_recv *p_ret =
(struct ret_mmi_recv *)&p_buffer[COMM_HEADER_SIZE];
if ( i_size < COMM_HEADER_SIZE + sizeof(struct ret_mmi_recv) )
return_error( "Bad MMI recv" );
en50221_UnserializeMMIObject( &p_ret->object, i_size
- COMM_HEADER_SIZE - ((void *)&p_ret->object - (void *)p_ret) );
switch ( p_ret->object.i_object_type )
{
case EN50221_MMI_ENQ:
printf("%s\n", p_ret->object.u.enq.psz_text);
printf("(empty to cancel)\n");
exit(p_ret->object.u.enq.b_blind ? 253 : 254);
break;
case EN50221_MMI_MENU:
printf("%s\n", p_ret->object.u.menu.psz_title);
printf("%s\n", p_ret->object.u.menu.psz_subtitle);
printf("0 - Cancel\n");
for ( i = 0; i < p_ret->object.u.menu.i_choices; i++ )
printf("%d - %s\n", i + 1,
p_ret->object.u.menu.ppsz_choices[i]);
printf("%s\n", p_ret->object.u.menu.psz_bottom);
exit(p_ret->object.u.menu.i_choices);
break;
case EN50221_MMI_LIST:
printf("%s\n", p_ret->object.u.menu.psz_title);
printf("%s\n", p_ret->object.u.menu.psz_subtitle);
for ( i = 0; i < p_ret->object.u.menu.i_choices; i++ )
printf("%s\n", p_ret->object.u.menu.ppsz_choices[i]);
printf("%s\n", p_ret->object.u.menu.psz_bottom);
printf("(0 to cancel)\n");
exit(0);
break;
default:
return_error( "Unknown MMI object" );
break;
}
exit(255);
break;
}
default:
return_error( "Unknown command answer: %u", c_answer );
}
return 0;
}
static int res_pd_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;
uint32_t 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_PD])
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_PD];
mnl_attr_for_each_nested(nla_entry, nla_table) {
uint32_t local_dma_lkey = 0, unsafe_global_rkey = 0;
struct nlattr *nla_line[RDMA_NLDEV_ATTR_MAX] = {};
char *comm = NULL;
uint32_t pid = 0;
uint64_t users;
int err;
err = mnl_attr_parse_nested(nla_entry, rd_attr_cb, nla_line);
if (err != MNL_CB_OK)
return MNL_CB_ERROR;
if (!nla_line[RDMA_NLDEV_ATTR_RES_USECNT] ||
(!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_RES_LOCAL_DMA_LKEY])
local_dma_lkey = mnl_attr_get_u32(
nla_line[RDMA_NLDEV_ATTR_RES_LOCAL_DMA_LKEY]);
users = mnl_attr_get_u64(nla_line[RDMA_NLDEV_ATTR_RES_USECNT]);
if (rd_check_is_filtered(rd, "users", users))
continue;
if (nla_line[RDMA_NLDEV_ATTR_RES_UNSAFE_GLOBAL_RKEY])
unsafe_global_rkey = mnl_attr_get_u32(
nla_line[RDMA_NLDEV_ATTR_RES_UNSAFE_GLOBAL_RKEY]);
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))
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_dev(rd, idx, name);
if (nla_line[RDMA_NLDEV_ATTR_RES_LOCAL_DMA_LKEY])
print_key(rd, "local_dma_lkey", local_dma_lkey);
print_users(rd, users);
if (nla_line[RDMA_NLDEV_ATTR_RES_UNSAFE_GLOBAL_RKEY])
print_key(rd, "unsafe_global_rkey", unsafe_global_rkey);
print_pid(rd, pid);
print_comm(rd, comm, nla_line);
if (nla_line[RDMA_NLDEV_ATTR_RES_PID])
free(comm);
print_driver_table(rd, nla_line[RDMA_NLDEV_ATTR_DRIVER]);
newline(rd);
}
static int res_mr_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;
uint32_t 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_MR])
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_MR];
mnl_attr_for_each_nested(nla_entry, nla_table) {
struct nlattr *nla_line[RDMA_NLDEV_ATTR_MAX] = {};
uint32_t rkey = 0, lkey = 0;
uint64_t iova = 0, mrlen;
char *comm = NULL;
uint32_t pid = 0;
int err;
err = mnl_attr_parse_nested(nla_entry, rd_attr_cb, nla_line);
if (err != MNL_CB_OK)
return MNL_CB_ERROR;
if (!nla_line[RDMA_NLDEV_ATTR_RES_MRLEN] ||
(!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_RES_RKEY])
rkey = mnl_attr_get_u32(
nla_line[RDMA_NLDEV_ATTR_RES_RKEY]);
if (nla_line[RDMA_NLDEV_ATTR_RES_LKEY])
lkey = mnl_attr_get_u32(
nla_line[RDMA_NLDEV_ATTR_RES_LKEY]);
if (nla_line[RDMA_NLDEV_ATTR_RES_IOVA])
iova = mnl_attr_get_u64(
nla_line[RDMA_NLDEV_ATTR_RES_IOVA]);
mrlen = mnl_attr_get_u64(nla_line[RDMA_NLDEV_ATTR_RES_MRLEN]);
if (rd_check_is_filtered(rd, "mrlen", mrlen))
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_dev(rd, idx, name);
if (nla_line[RDMA_NLDEV_ATTR_RES_RKEY])
print_key(rd, "rkey", rkey);
if (nla_line[RDMA_NLDEV_ATTR_RES_LKEY])
print_key(rd, "lkey", lkey);
if (nla_line[RDMA_NLDEV_ATTR_RES_IOVA])
print_iova(rd, iova);
print_mrlen(rd, mrlen);
print_pid(rd, pid);
print_comm(rd, comm, nla_line);
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;
}
static int res_cq_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;
uint32_t 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_CQ])
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_CQ];
mnl_attr_for_each_nested(nla_entry, nla_table) {
struct nlattr *nla_line[RDMA_NLDEV_ATTR_MAX] = {};
char *comm = NULL;
uint32_t pid = 0;
uint8_t poll_ctx = 0;
uint64_t users;
uint32_t cqe;
int err;
err = mnl_attr_parse_nested(nla_entry, rd_attr_cb, nla_line);
if (err != MNL_CB_OK)
return MNL_CB_ERROR;
if (!nla_line[RDMA_NLDEV_ATTR_RES_CQE] ||
!nla_line[RDMA_NLDEV_ATTR_RES_USECNT] ||
(!nla_line[RDMA_NLDEV_ATTR_RES_PID] &&
!nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME])) {
return MNL_CB_ERROR;
}
cqe = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_CQE]);
users = mnl_attr_get_u64(nla_line[RDMA_NLDEV_ATTR_RES_USECNT]);
if (rd_check_is_filtered(rd, "users", users))
continue;
if (nla_line[RDMA_NLDEV_ATTR_RES_POLL_CTX]) {
poll_ctx = mnl_attr_get_u8(
nla_line[RDMA_NLDEV_ATTR_RES_POLL_CTX]);
if (rd_check_is_string_filtered(rd, "poll-ctx",
poll_ctx_to_str(poll_ctx)))
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_dev(rd, idx, name);
print_cqe(rd, cqe);
print_users(rd, users);
if (nla_line[RDMA_NLDEV_ATTR_RES_POLL_CTX])
print_poll_ctx(rd, poll_ctx);
print_pid(rd, pid);
print_comm(rd, comm, nla_line);
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;
}
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;
}
static int res_qp_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;
uint32_t 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_QP])
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_QP];
mnl_attr_for_each_nested(nla_entry, nla_table) {
struct nlattr *nla_line[RDMA_NLDEV_ATTR_MAX] = {};
uint32_t lqpn, rqpn = 0, rq_psn = 0, sq_psn;
uint8_t type, state, path_mig_state = 0;
uint32_t port = 0, pid = 0;
char *comm = NULL;
int err;
err = mnl_attr_parse_nested(nla_entry, rd_attr_cb, nla_line);
if (err != MNL_CB_OK)
return MNL_CB_ERROR;
if (!nla_line[RDMA_NLDEV_ATTR_RES_LQPN] ||
!nla_line[RDMA_NLDEV_ATTR_RES_SQ_PSN] ||
!nla_line[RDMA_NLDEV_ATTR_RES_TYPE] ||
!nla_line[RDMA_NLDEV_ATTR_RES_STATE] ||
(!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 != rd->port_idx)
continue;
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_RQPN]) {
rqpn = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_RQPN]);
if (rd_check_is_filtered(rd, "rqpn", rqpn))
continue;
} else {
if (rd_check_is_key_exist(rd, "rqpn"))
continue;
}
if (nla_line[RDMA_NLDEV_ATTR_RES_RQ_PSN]) {
rq_psn = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_RQ_PSN]);
if (rd_check_is_filtered(rd, "rq-psn", rq_psn))
continue;
} else {
if (rd_check_is_key_exist(rd, "rq-psn"))
continue;
}
sq_psn = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_SQ_PSN]);
if (rd_check_is_filtered(rd, "sq-psn", sq_psn))
continue;
if (nla_line[RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE]) {
path_mig_state = mnl_attr_get_u8(nla_line[RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE]);
if (rd_check_is_string_filtered(rd, "path-mig-state", path_mig_to_str(path_mig_state)))
continue;
} else {
if (rd_check_is_key_exist(rd, "path-mig-state"))
continue;
}
type = mnl_attr_get_u8(nla_line[RDMA_NLDEV_ATTR_RES_TYPE]);
if (rd_check_is_string_filtered(rd, "type", qp_types_to_str(type)))
continue;
state = mnl_attr_get_u8(nla_line[RDMA_NLDEV_ATTR_RES_STATE]);
if (rd_check_is_string_filtered(rd, "state", qp_states_to_str(state)))
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);
print_lqpn(rd, lqpn);
print_rqpn(rd, rqpn, nla_line);
print_type(rd, type);
print_state(rd, state);
print_rqpsn(rd, rq_psn, nla_line);
print_sqpsn(rd, sq_psn);
print_pathmig(rd, path_mig_state, nla_line);
print_pid(rd, pid);
print_comm(rd, comm, nla_line);
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;
}
void
task_swapper(void)
{
task_t outtask, intask;
int timeout;
int loopcnt = 0;
boolean_t start_swapping;
boolean_t stop_swapping;
int local_page_free_avg;
extern int hz;
thread_swappable(current_act(), FALSE);
stack_privilege(current_thread());
spllo();
for (;;) {
local_page_free_avg = vm_page_free_avg;
while (TRUE) {
#if 0
if (task_swap_debug)
printf("task_swapper: top of loop; cnt = %d\n",loopcnt);
#endif
intask = pick_intask();
start_swapping = ((vm_pageout_rate_avg > swap_start_pageout_rate) ||
(vm_grab_rate_avg > max_grab_rate));
stop_swapping = (vm_pageout_rate_avg < swap_stop_pageout_rate);
/*
* If a lot of paging is going on, or another task should come
* in but memory is tight, find something to swap out and start
* it. Don't swap any task out if task swapping is disabled.
* vm_page_queue_free_lock protects the vm globals.
*/
outtask = TASK_NULL;
if (start_swapping ||
(!stop_swapping && intask &&
((local_page_free_avg / AVE_SCALE) < vm_page_free_target))
) {
if (task_swap_enable &&
(outtask = pick_outtask()) &&
(task_swapout(outtask) == KERN_SUCCESS)) {
unsigned long rss;
#if TASK_SW_DEBUG
if (task_swap_debug)
print_pid(outtask, local_page_free_avg / AVE_SCALE,
vm_page_free_target, "<",
"out");
#endif
rss = outtask->swap_rss;
if (outtask->swap_nswap == 1)
rss /= 2; /* divide by 2 if never out */
local_page_free_avg += (rss/short_avg_interval) * AVE_SCALE;
}
if (outtask != TASK_NULL)
task_deallocate(outtask);
}
/*
* If there is an eligible task to bring in and there are at
* least vm_page_free_target free pages, swap it in. If task
* swapping has been disabled, bring the task in anyway.
*/
if (intask && ((local_page_free_avg / AVE_SCALE) >=
vm_page_free_target ||
stop_swapping || !task_swap_enable)) {
if (task_swapin(intask, FALSE) == KERN_SUCCESS) {
unsigned long rss;
#if TASK_SW_DEBUG
if (task_swap_debug)
print_pid(intask, local_page_free_avg / AVE_SCALE,
vm_page_free_target, ">=",
"in");
#endif
rss = intask->swap_rss;
if (intask->swap_nswap == 1)
rss /= 2; /* divide by 2 if never out */
local_page_free_avg -= (rss/short_avg_interval) * AVE_SCALE;
}
}
/*
* XXX
* Here we have to decide whether to continue swapping
* in and/or out before sleeping. The decision should
* be made based on the previous action (swapin/out) and
* current system parameters, such as paging rates and
* demand.
* The function, compute_vm_averages, which does these
* calculations, depends on being called every second,
* so we can't just do the same thing.
*/
if (++loopcnt < MAX_LOOP)
continue;
/*
* Arrange to be awakened if paging is still heavy or there are
* any tasks partially or completely swapped out. (Otherwise,
* the wakeup will come from the external trigger(s).)
*/
timeout = 0;
if (start_swapping)
timeout = task_swap_cycle_time;
else {
task_swapper_lock();
if (!queue_empty(&swapped_tasks))
timeout = min_swap_time;
task_swapper_unlock();
}
assert_wait((event_t)&swapped_tasks, FALSE);
if (timeout) {
if (task_swap_debug)
printf("task_swapper: set timeout of %d\n",
timeout);
thread_set_timeout(timeout*hz);
}
if (task_swap_debug)
printf("task_swapper: blocking\n");
thread_block((void (*)(void)) 0);
if (timeout) {
reset_timeout_check(¤t_thread()->timer);
}
/* reset locals */
loopcnt = 0;
local_page_free_avg = vm_page_free_avg;
}
}
}