// swap_init - init swap fs, two swap lists, alloc memory & init for swap_entry record array mem_map
// - init the hash list.
void
swap_init(void) {
swapfs_init();
swap_list_init(&active_list);
swap_list_init(&inactive_list);
if (!(512 <= max_swap_offset && max_swap_offset < MAX_SWAP_OFFSET_LIMIT)) {
panic("bad max_swap_offset %08x.\n", max_swap_offset);
}
mem_map = kmalloc(sizeof(short) * max_swap_offset);
assert(mem_map != NULL);
size_t offset;
for (offset = 0; offset < max_swap_offset; offset ++) {
mem_map[offset] = SWAP_UNUSED;
}
int i;
for (i = 0; i < HASH_LIST_SIZE; i ++) {
list_init(hash_list + i);
}
sem_init(&swap_in_sem, 1);
check_swap();
check_mm_swap();
check_mm_shm_swap();
wait_queue_init(&kswapd_done);
swap_init_ok = 1;
}
static void first_pile_check(t_pushswap *data)
{
if (data->length_a == 3
&& check_pile_reverse(data->pile_a, data->length_a))
{
reverse_rotate_a(data, 0);
swap_a(data, 0);
}
if (data->pile_a[0] < data->pile_a[1])
check_swap_beg(data);
if (data->pos_smallest_a == data->length_a - 2)
check_swap(data);
}
INT wmain(INT argc, WCHAR **argv)
{
printInfoStruct printInfo = { };
po::variables_map vm;
INT ret = parseArguments(argc, argv, vm, printInfo);
if (ret != -1)
return ret;
ret = check_swap(printInfo);
if (ret != -1)
return ret;
return printOutput(printInfo);
}
int swap_init(void)
{
swapfs_init();
if (!(1024 <= max_swap_offset && max_swap_offset < MAX_SWAP_OFFSET_LIMIT))
{
panic("bad max_swap_offset %08x.\n", max_swap_offset);
}
sm = &swap_manager_fifo;
int r = sm->init();
if (r == 0)
{
swap_init_ok = 1;
cprintf("SWAP: manager = %s\n", sm->name);
check_swap();
}
return r;
}
void
do_install(void)
{
msg_display(MSG_installusure);
process_menu(MENU_noyes, NULL);
if (!yesno)
return;
get_ramsize();
if (find_disks(msg_string(MSG_install)) < 0)
return;
clear();
refresh();
if (check_swap(diskdev, 0) > 0) {
msg_display(MSG_swapactive);
process_menu(MENU_ok, NULL);
if (check_swap(diskdev, 1) < 0) {
msg_display(MSG_swapdelfailed);
process_menu(MENU_ok, NULL);
if (!debug)
return;
}
}
process_menu(MENU_distset, NULL);
if (!md_get_info()) {
msg_display(MSG_abort);
process_menu(MENU_ok, NULL);
return;
}
if (md_make_bsd_partitions() == 0) {
msg_display(MSG_abort);
process_menu(MENU_ok, NULL);
return;
}
/* Last chance ... do you really want to do this? */
clear();
refresh();
msg_display(MSG_lastchance, diskdev);
process_menu(MENU_noyes, NULL);
if (!yesno)
return;
if (md_pre_disklabel() != 0)
return;
if (write_disklabel() != 0)
return;
if (md_post_disklabel() != 0)
return;
if (make_filesystems())
return;
if (make_fstab() != 0)
return;
if (md_post_newfs() != 0)
return;
/* Unpack the distribution. */
if (get_and_unpack_sets(0, MSG_disksetupdone,
MSG_extractcomplete, MSG_abortinst) != 0)
return;
if (md_post_extract() != 0)
return;
do_configmenu();
sanity_check();
md_cleanup_install();
msg_display(MSG_instcomplete);
process_menu(MENU_ok, NULL);
}
int
main (int argc, char **argv)
{
int percent_used, percent;
float total_swap_mb = 0, used_swap_mb = 0, free_swap_mb = 0;
float dsktotal_mb = 0, dskused_mb = 0, dskfree_mb = 0, tmp_mb = 0;
int result = STATE_UNKNOWN;
char input_buffer[MAX_INPUT_BUFFER];
#ifdef HAVE_PROC_MEMINFO
FILE *fp;
#else
int conv_factor = SWAP_CONVERSION;
# ifdef HAVE_SWAP
char *temp_buffer;
char *swap_command;
char *swap_format;
# else
# ifdef HAVE_DECL_SWAPCTL
int i=0, nswaps=0, swapctl_res=0;
# ifdef CHECK_SWAP_SWAPCTL_SVR4
swaptbl_t *tbl=NULL;
swapent_t *ent=NULL;
# else
# ifdef CHECK_SWAP_SWAPCTL_BSD
struct swapent *ent;
# endif /* CHECK_SWAP_SWAPCTL_BSD */
# endif /* CHECK_SWAP_SWAPCTL_SVR4 */
# endif /* HAVE_DECL_SWAPCTL */
# endif
#endif
char str[32];
char *status;
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
status = strdup ("");
/* Parse extra opts if any */
argv=np_extra_opts (&argc, argv, progname);
if (process_arguments (argc, argv) == ERROR)
usage4 (_("Could not parse arguments"));
#ifdef HAVE_PROC_MEMINFO
if (verbose >= 3) {
printf("Reading PROC_MEMINFO at %s\n", PROC_MEMINFO);
}
fp = fopen (PROC_MEMINFO, "r");
while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, fp)) {
if (sscanf (input_buffer, "%*[S]%*[w]%*[a]%*[p]%*[:] %f %f %f", &dsktotal_mb, &dskused_mb, &dskfree_mb) == 3) {
dsktotal_mb = dsktotal_mb / 1048576; /* Apply conversion */
dskused_mb = dskused_mb / 1048576;
dskfree_mb = dskfree_mb / 1048576;
total_swap_mb += dsktotal_mb;
used_swap_mb += dskused_mb;
free_swap_mb += dskfree_mb;
if (allswaps) {
if (dsktotal_mb == 0)
percent=100.0;
else
percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
result = max_state (result, check_swap (percent, dskfree_mb));
if (verbose)
xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent);
}
}
else if (sscanf (input_buffer, "%*[S]%*[w]%*[a]%*[p]%[TotalFre]%*[:] %f %*[k]%*[B]", str, &tmp_mb)) {
if (verbose >= 3) {
printf("Got %s with %f\n", str, tmp_mb);
}
/* I think this part is always in Kb, so convert to mb */
if (strcmp ("Total", str) == 0) {
dsktotal_mb = tmp_mb / 1024;
}
else if (strcmp ("Free", str) == 0) {
dskfree_mb = tmp_mb / 1024;
}
}
}
fclose(fp);
dskused_mb = dsktotal_mb - dskfree_mb;
total_swap_mb = dsktotal_mb;
used_swap_mb = dskused_mb;
free_swap_mb = dskfree_mb;
#else
# ifdef HAVE_SWAP
xasprintf(&swap_command, "%s", SWAP_COMMAND);
xasprintf(&swap_format, "%s", SWAP_FORMAT);
/* These override the command used if a summary (and thus ! allswaps) is required */
/* The summary flag returns more accurate information about swap usage on these OSes */
# ifdef _AIX
if (!allswaps) {
xasprintf(&swap_command, "%s", "/usr/sbin/lsps -s");
xasprintf(&swap_format, "%s", "%f%*s %f");
conv_factor = 1;
}
# endif
if (verbose >= 2)
printf (_("Command: %s\n"), swap_command);
if (verbose >= 3)
printf (_("Format: %s\n"), swap_format);
child_process = spopen (swap_command);
if (child_process == NULL) {
printf (_("Could not open pipe: %s\n"), swap_command);
return STATE_UNKNOWN;
}
child_stderr = fdopen (child_stderr_array[fileno (child_process)], "r");
if (child_stderr == NULL)
printf (_("Could not open stderr for %s\n"), swap_command);
sprintf (str, "%s", "");
/* read 1st line */
fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process);
if (strcmp (swap_format, "") == 0) {
temp_buffer = strtok (input_buffer, " \n");
while (temp_buffer) {
if (strstr (temp_buffer, "blocks"))
sprintf (str, "%s %s", str, "%f");
else if (strstr (temp_buffer, "dskfree"))
sprintf (str, "%s %s", str, "%f");
else
sprintf (str, "%s %s", str, "%*s");
temp_buffer = strtok (NULL, " \n");
}
}
/* If different swap command is used for summary switch, need to read format differently */
# ifdef _AIX
if (!allswaps) {
fgets(input_buffer, MAX_INPUT_BUFFER - 1, child_process); /* Ignore first line */
sscanf (input_buffer, swap_format, &total_swap_mb, &used_swap_mb);
free_swap_mb = total_swap_mb * (100 - used_swap_mb) /100;
used_swap_mb = total_swap_mb - free_swap_mb;
if (verbose >= 3)
printf (_("total=%.0f, used=%.0f, free=%.0f\n"), total_swap_mb, used_swap_mb, free_swap_mb);
} else {
# endif
while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) {
sscanf (input_buffer, swap_format, &dsktotal_mb, &dskfree_mb);
dsktotal_mb = dsktotal_mb / conv_factor;
/* AIX lists percent used, so this converts to dskfree in MBs */
# ifdef _AIX
dskfree_mb = dsktotal_mb * (100 - dskfree_mb) / 100;
# else
dskfree_mb = dskfree_mb / conv_factor;
# endif
if (verbose >= 3)
printf (_("total=%.0f, free=%.0f\n"), dsktotal_mb, dskfree_mb);
dskused_mb = dsktotal_mb - dskfree_mb;
total_swap_mb += dsktotal_mb;
used_swap_mb += dskused_mb;
free_swap_mb += dskfree_mb;
if (allswaps) {
percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
result = max_state (result, check_swap (percent, dskfree_mb));
if (verbose)
xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent);
}
}
# ifdef _AIX
}
# endif
/* If we get anything on STDERR, at least set warning */
while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr))
result = max_state (result, STATE_WARNING);
/* close stderr */
(void) fclose (child_stderr);
/* close the pipe */
if (spclose (child_process))
result = max_state (result, STATE_WARNING);
# else
# ifdef CHECK_SWAP_SWAPCTL_SVR4
/* get the number of active swap devices */
if((nswaps=swapctl(SC_GETNSWP, NULL))== -1)
die(STATE_UNKNOWN, _("Error getting swap devices\n") );
if(nswaps == 0)
die(STATE_OK, _("SWAP OK: No swap devices defined\n"));
if(verbose >= 3)
printf("Found %d swap device(s)\n", nswaps);
/* initialize swap table + entries */
tbl=(swaptbl_t*)malloc(sizeof(swaptbl_t)+(sizeof(swapent_t)*nswaps));
if(tbl==NULL)
die(STATE_UNKNOWN, _("malloc() failed!\n"));
memset(tbl, 0, sizeof(swaptbl_t)+(sizeof(swapent_t)*nswaps));
tbl->swt_n=nswaps;
for(i=0;i<nswaps;i++){
if((tbl->swt_ent[i].ste_path=(char*)malloc(sizeof(char)*MAXPATHLEN)) == NULL)
die(STATE_UNKNOWN, _("malloc() failed!\n"));
}
/* and now, tally 'em up */
swapctl_res=swapctl(SC_LIST, tbl);
if(swapctl_res < 0){
perror(_("swapctl failed: "));
die(STATE_UNKNOWN, _("Error in swapctl call\n"));
}
for(i=0;i<nswaps;i++){
dsktotal_mb = (float) tbl->swt_ent[i].ste_pages / SWAP_CONVERSION;
dskfree_mb = (float) tbl->swt_ent[i].ste_free / SWAP_CONVERSION;
dskused_mb = ( dsktotal_mb - dskfree_mb );
if (verbose >= 3)
printf ("dsktotal_mb=%.0f dskfree_mb=%.0f dskused_mb=%.0f\n", dsktotal_mb, dskfree_mb, dskused_mb);
if(allswaps && dsktotal_mb > 0){
percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
result = max_state (result, check_swap (percent, dskfree_mb));
if (verbose) {
xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent);
}
}
total_swap_mb += dsktotal_mb;
free_swap_mb += dskfree_mb;
used_swap_mb += dskused_mb;
}
/* and clean up after ourselves */
for(i=0;i<nswaps;i++){
free(tbl->swt_ent[i].ste_path);
}
free(tbl);
# else
# ifdef CHECK_SWAP_SWAPCTL_BSD
/* get the number of active swap devices */
nswaps=swapctl(SWAP_NSWAP, NULL, 0);
/* initialize swap table + entries */
ent=(struct swapent*)malloc(sizeof(struct swapent)*nswaps);
/* and now, tally 'em up */
swapctl_res=swapctl(SWAP_STATS, ent, nswaps);
if(swapctl_res < 0){
perror(_("swapctl failed: "));
die(STATE_UNKNOWN, _("Error in swapctl call\n"));
}
for(i=0;i<nswaps;i++){
dsktotal_mb = (float) ent[i].se_nblks / conv_factor;
dskused_mb = (float) ent[i].se_inuse / conv_factor;
dskfree_mb = ( dsktotal_mb - dskused_mb );
if(allswaps && dsktotal_mb > 0){
percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
result = max_state (result, check_swap (percent, dskfree_mb));
if (verbose) {
xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent);
}
}
total_swap_mb += dsktotal_mb;
free_swap_mb += dskfree_mb;
used_swap_mb += dskused_mb;
}
/* and clean up after ourselves */
free(ent);
# endif /* CHECK_SWAP_SWAPCTL_BSD */
# endif /* CHECK_SWAP_SWAPCTL_SVR4 */
# endif /* HAVE_SWAP */
#endif /* HAVE_PROC_MEMINFO */
/* if total_swap_mb == 0, let's not divide by 0 */
if(total_swap_mb) {
percent_used = 100 * ((double) used_swap_mb) / ((double) total_swap_mb);
} else {
percent_used = 0;
}
result = max_state (result, check_swap (percent_used, free_swap_mb));
printf (_("SWAP %s - %d%% free (%d MB out of %d MB) %s|"),
state_text (result),
(100 - percent_used), (int) free_swap_mb, (int) total_swap_mb, status);
puts (perfdata ("swap", (long) free_swap_mb, "MB",
TRUE, (long) max (warn_size_bytes/(1024 * 1024), warn_percent/100.0*total_swap_mb),
TRUE, (long) max (crit_size_bytes/(1024 * 1024), crit_percent/100.0*total_swap_mb),
TRUE, 0,
TRUE, (long) total_swap_mb));
return result;
}