mosmon.c

OpenMosix工具

/*  Author(s): Amnon Shiloh  for Mosix                                  */
/*  Adapted to OpenMosix from Mosix and bugfixing by David Santo Orcero */
/*  [e-mail]  http://www.orcero.org/irbis                       */
/* Mosix is (c) of prof. Amnon Barak http://www.mosix.org               */
/* Original code is (c) of prof. Amnon Barak http://www.mosix.org       */
/* OpenMosix is (c) of Moshe Bar http://www.openmosix.com               */
/* Each respective trademark is of its own owner                        */
/* All rights reserved.                                                 */
/* This software is distributed under GPL 2                             */

/* THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTY IS ASSUMED.                */
/* NO LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING             */
/* FROM THE USE OF THIS SOFTWARE WILL BE ACCEPTED. IT CAN BURN               */
/* YOUR HARD DISK, ERASE ALL YOUR DATA AND BROKE DOWN YOUR                   */
/* MICROWAVE OVEN. YOU ARE ADVISED.                                          */


/* THIS SOFTWARE IS PROVIDED IN ITS "AS IS" CONDITION, WITH NO WARRANTY      */
/* WHATSOEVER. NO LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING */
/* FROM THE USE OF THIS SOFTWARE WILL BE ACCEPTED.                           */


/*
** Last modified on 7 April 2004 by Moreno 'baro' Baricevic
**                                                 <baro AT democritos DOT it>
**
** This version of mosmon is independent of kernel headers.
** mosmon guesses the size of struct mosix_info (usually correctly!).
** The user can specify an arbitrary kernel version using the (new) command line
** option "-F <VERSION>". Where version is in the range (2416-2425).
**
** Other fixes/changes:
** - new usage() routine;
** - help fixed;
** - most of the interactive keys have their command line counterpart;
** - log-load display patch (by Tony Travis <[e-mail]>)
**   has been merged as command line option "-L" and interactive key "L";
** - ...
*/

#include <linux/config.h>
#include <stdio.h>
#include <stdlib.h>
#include <termio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <string.h>
#include <termios.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <unistd.h>


#define PROGNAME	"mosmon"
#define PROGVER 	"2.0"


#include "utils.h"
#include "mosix_info.h"


#define USE_LOG_LOAD		// enable log-load display (-L option, L key)

#ifdef USE_LOG_LOAD
# include <math.h>
int log_load = 0;
#endif /* USE_LOG_LOAD */


#include <curses.h>

/**************************************************************
** map some ncurses keys (<ncurses.h>)
*/
#define KEY_DOWN	0402	/* Sent by terminal down arrow key */
#define KEY_UP		0403	/* Sent by terminal up arrow key */
#define KEY_LEFT	0404	/* Sent by terminal left arrow key */
#define KEY_RIGHT	0405	/* Sent by terminal right arrow key */
#define KEY_HOME	0406	/* Sent by home key. */
#define KEY_NPAGE	0522	/* Sent by next-page key */
#define KEY_PPAGE	0523	/* Sent by previous-page key */
#define KEY_ENTER	0527	/* Enter/send (unreliable) */
#define KEY_A1		0534	/* Upper left of keypad */
#define KEY_A3		0535	/* Upper right of keypad */
#define KEY_B2		0536	/* Center of keypad */
#define KEY_C1		0537	/* Lower left of keypad */
#define KEY_C3		0540	/* Lower right of keypad */
#define KEY_END		0550	/* end key */

#define KEY_IC          0513	/* insert-character key */


/**************************************************************
** first help string (basic help message).
** Should fit on 80x24 screen (-2 lines for "\nPress any key...").
*/
#define HELP_STR1	\
"OpenMosix Load Monitor Version " PROGVER ", Based on code (c) by MOSIX GROUP HUJI.\n"	\
"\n"										\
"A load unit represents 100% CPU utilisation of a standard processor. If the\n"	\
"speed of a CPU is the same as the yardstick, one load unit is equivalent\n"	\
"to a load average of 1.0 as displayed by \"top\", \"mtop\" and \"uptime\".\n"	\
"However, nodes with faster CPU's and/or SMP nodes with  multiple CPU's\n"	\
"will show a lower load and nodes with slower CPU's will show a higher load.\n"	\
"\n"										\
"For larger systems (with 10 or more nodes), node-numbers can be shown either\n"\
"horizontally (better looking) or vertically (to see more at a time).\n"	\
"\n"										\
"Help for Interactive Keys:\n"							\
"\n"										\
"q or Q		Quit mosmon\n"							\
"h or H or ?	bring up this help screen\n"					\
"\n"										\
"w/v/V/a\t	horizontal (wide), vertical, super-vertical (tight) or\n"	\
"		automatic selection of numbering (default auto)\n"		\
"s		display processor-speeds (also number of SMP CPU's)\n"		\
"m		display logically-used vs. total memory\n"			\
"r		display raw-used (non-free) memory vs. total memory\n"		\
""

/**************************************************************
** second help string (additional keys)
** Should fit on 80x24 screen (-2 lines for "\nPress any key...").
*/
#define	HELP_STR2	\
"Additional keys:\n"								\
"\n"										\
"l		display loads (default, 1.0 = 100% CPU)\n"			\
"L		toggle display of load on log scale (2.0 = 100% CPU)\n"		\
"d		show dead nodes (configured but not-responding)\n"		\
"t		toggle display of total operational node count\n"		\
"		(not recommended on very large clusters - will be very slow)\n"	\
"y		display the yardstick (i.e. speed of a standard processor)\n"	\
"\n"										\
"Enter		redraw the screen\n"						\
"Insert		force update after OpenMosix is restarted\n"			\
"\n"										\
"When not all nodes fit on the screen, press:\n"				\
"\n"										\
"Left/Right-Arrow or -/+ \n"							\
"		move one node to the left/right\n"				\
"p/n		move one screen to the left/right (previous/next)\n"		\
"\n"										\
"\n"										\
"Try \"" PROGNAME " -h\" to see command line options or "			\
"\"man " PROGNAME "\" for details.\n"						\
"\n"


/**************************************************************
** functions declaration
*/
void usage (const char *errmsg, ...);
void set_mode (int i);
void get_npe (void);
void find_npe (void);
void adjust_first (void);
void ch_alarm (void);
void not_yet_ch (int ch);
int readc_half_second (void);
int my_getch (void);
int is_input (void);
void help (void);
void yardstick (void);
void cb (const char *msg, int y, int x);
void cb_ctr (const char *msg);
void onio (void);
void sleep_or_input (unsigned int secs);
void onint (int i);

/* ! OpenMosix */
static void
not_mosix (void)
{
  fprintf (stderr, PROGNAME ": This is NOT a OpenMosix system!\n");
  exit (1);
}				/* not_mosix */



/**************************************************************
** some useful macros
*/
#define COL_FROM_0	7
#define MAX_SILENT	( -5 )
#define	VERY_DEAD	( MAX_SILENT - 1 )
#define PROC_HPC_SSPEED	"/proc/hpc/admin/sspeed"


/**************************************************************
** global variables (arrays numbering starts at 1)
*/
int screen_width;
mosix_info_s info[MOSIX_MAX + 1];
float load[MOSIX_MAX + 1], other[MOSIX_MAX + 1];
char valid[MOSIX_MAX + 1];

enum
{
  D_GETLOAD,
  D_GETSPEED,
  D_GETUTIL,
  D_GETMEM,
  D_GETBMEM
} item = D_GETLOAD;

int ifd = -1;			/* input file */
int npe = 0;			/* number of record */
int first = 1;			/* first node displayed */


/**************************************************************
** mosix_info_* structures handling stuff
*/
int (*readstruct) (int, mosix_info_s *, size_t);
int vernum = _UNKNOWN;
int recsz = 0;
char mstruct[16];



/************
 *   MAIN   *
 ************/
int
main (int argc, char *argv[])
{
  int l, col;
  register int i = 0, j = 0, k = 0;
  float max, curmax = 0;
  int cool = 0;
  int dead;
  struct winsize ws;
  int vflg = 0, wflg = 0, tflg = 0;
  int dflg = 0;
  int last;
  int base;			/* baseline location */
  int ver = 0;
  int wid;			/* width of processor numbers */
  char need_count = 1;
  int tot = 0, tot_display = 0, cpus_display = 0;
  NCURSES_CONST char *fmt;
  unsigned int turns = 0;
  char space, ospace;
  int rev;
  int first_read, nread;
  const char *file = PROC_HPC_INFOS;

#ifdef DEBUG
  stdreopen ();
#endif

  /*
   ** command line options parser
   */
  while (argc > 1 && (argv[1][0] == '-' || argv[1][0] == '+'))
    {
      if (argv[1][0] == '+')
	{
	  if (!argv[1][1])
	    usage ("+: NODE_NUMBER missing");
	  first = strtoi (&argv[1][1]);
	  if (errno == EINVAL)
	    usage ("+: invalid argument \"%s\"", &argv[1][1]);
	  if (errno == ERANGE)
	    usage ("+: argument out of range \"%s\"", &argv[1][1]);
	  if (first < 1 || first > MOSIX_MAX)
	    usage ("+: NODE_NUMBER out of range (1-%d) \"%s\"", MOSIX_MAX,
		   &argv[1][1]);
	}
      else
	{
	  for (j = 1; argv[1][j]; j++)
	    {
	      switch (argv[1][j])
		{
		default:
		  usage ("unrecognized option '%c' in argument \"%s\"",
			 argv[1][j], argv[1]);
		case 'h':
		case 'H':
		  usage (NULL);
		  //---------------------------------
		case 'v':
		  vflg = 1;
		  wflg = 0;
		  break;
		case 'V':
		  vflg = 2;
		  wflg = 0;
		  break;
		case 'w':
		  vflg = 0;
		  wflg = 1;
		  break;
		case 'a':
		  wflg = vflg = 0;
		  need_count = 1;
		  break;
		  //---------------------------------
		case 's':
		  item = D_GETSPEED;
		  break;
		case 'm':
		  item = D_GETMEM;
		  break;
		case 'r':
		  item = D_GETBMEM;
		  break;
		case 'u':
		  item = D_GETUTIL;
		  break;
#ifdef USE_LOG_LOAD
		case 'L':
		  log_load = 1;	// fall through
#endif /* USE_LOG_LOAD */
		case 'l':
		  item = D_GETLOAD;
		  break;
		  //---------------------------------
		case 't':
		  tflg = 1;
		  break;
		case 'd':
		  dflg = 1;
		  break;
		  //---------------------------------
		case 'F':
		  if (!argv[2] || !*argv[2])
		    usage ("-%c: missing argument", argv[1][j]);
		  {
		    int struct_ver = strtoi (argv[2]);
		    if (errno == EINVAL)
		      usage ("-%c: invalid argument \"%s\"", argv[1][j],
			     argv[2]);
		    if (errno == ERANGE)
		      usage ("-%c: argument out of range \"%s\"", argv[1][j],
			     argv[2]);
		    vernum = force_version (struct_ver);
		    if (vernum == _UNKNOWN)	// your fault, not mine
		      usage ("-%c: unknown version \"%s\"", argv[1][j],
			     argv[2]);
		    fprintf (stderr, "force using struct %s\n", mstruct);
		    argc--;
		    argv++;
		    goto skip_arg;
		  }
		}
	    }
	}
    skip_arg:
      argc--;
      argv++;
    }

  if (argc > 1)
    usage ("too many arguments [%s]", argv[1]);

  DBGprint ("using file \"%s\" ...", file);
  ifd = open (file, O_RDONLY);
  if (ifd == -1)
    not_mosix ();

#ifdef DEBUG
  summary ();
#endif /* DEBUG */

  if (vernum == _UNKNOWN)
    vernum = guess_by_recsz (ifd);
  DBGprint ("vernum = %d", vernum);
  DBGprint ("recsz  = %d", recsz);

/*
//   if ( vernum == _UNKNOWN )
//     die( "*** unsupported record" );
** No. Continue, OpenMosix can be configured later
** (DUMMY struct saves us from segfault)
*/

  get_npe ();			// get the number of records from PROC_HPC_INFOS

  /*
   ** ok, start ncurses
   ** trap some signals in order to clear the screen before exit.
   */
  signal (SIGINT, (sig_t) onint);
  signal (SIGQUIT, (sig_t) onint);
  initscr ();
  noecho ();
  cbreak ();
  system ("stty cbreak -echo");

  for (i = 0; i <= npe; i++)
    load[i] = 0;

  while (1)			// start neverending loop
    {

      // if oM un/configured while we are running, recheck for recsz and npe.
      if (vernum == _UNKNOWN)
	vernum = guess_by_recsz (ifd), get_npe ();

      first_read = nread = 0;

      /* get the new (if changed) win size  */
      if (ioctl (STDIN_FILENO, TIOCGWINSZ, (char *) &ws) == -1)
	fprintf (stderr, "ioctl() failed: [%d] %m\n", errno), onint (1);

      if ((COLS != ws.ws_col) || (LINES != ws.ws_row))
	{
	  initscr ();
	  need_count = 1;
	}

      if (tflg)
	{
	  memset (&info[1], 0, npe * RECSZ_STD);	// clear records buffer

	  (void) lseek (ifd, 0L, SEEK_SET);	// goto start of file
	  j = readstruct (ifd, &info[1], npe);	// read the whole file content
	  DBGprint ("j = %d", j);
	  if (j < npe)
	    {
	      npe = j;
	      adjust_first ();
	    }

	  first_read = 1;
	  nread = npe;

	  /*
	   ** check for invalid records (dead nodes)
	   */
	  for (tot_display = 0, cpus_display = 0, i = 1; i <= npe; i++)
	    {
	      if (info[i].status & DS_MOSIX_UP)
		{
		  tot_display++;
		  cpus_display += info[i].ncpus;
		  valid[i] = 1;
		  load[i] = -1;
		}
	      else if ((info[i].status & DS_MOSIX_DEF) &&
		       valid[i] > (turns >=
				   -MAX_SILENT ? MAX_SILENT : -(int64_t)
				   turns))
		{
		  tot_display++;
		  cpus_display += info[i].ncpus;
		}
	    }
	}

      if (need_count && !vflg && !wflg)
	{
	  get_npe ();
	  k = (COLS - COL_FROM_0 - 1) + 1;
	  tot = 0;

	  /* we only need to answer whether there are at least k
	   * nodes up ahead or not:  once we have the answer,
	   * stop reading.  Of course, with "tflg" we have already
	   * read everything */

	  first_read = first;

	  if (!tflg)
	    nread = 0;

	  for (i = first; i <= npe && tot < k; i += k)
	    {
	      last = i + k - 1;
	      if (last > npe)
		last = npe;
	      if (!tflg)
		{
		  (void) lseek (ifd, i - 1, SEEK_SET);
		  j = readstruct (ifd, &info[i], (last - i + 1));
		  if (j < (last - i + 1))
		    last = npe = i + j - 1;
		  nread = last + 1 - first;
		}
	      for (j = i; j <= last && tot < k; j++)
		if (info[j].status & (dflg ? DS_MOSIX_DEF : DS_MOSIX_UP))
		  tot++;
	    }

	  need_count = 0;
	}

      /* calculate the screen_width */
      wid = 1 + (npe > 9) + (npe > 99) + (npe > 999) + (npe > 9999);
      k = (COLS - COL_FROM_0 - 1) / (wid + 1);

      if (vflg)
	{
	vert:
	  base = LINES - 2 - wid;
	  ver = 1;
	  if (vflg == 2)
	    {
	      wid = 0;
	      screen_width = (COLS - COL_FROM_0 - 1);
	    }
	  else
	    {
	      wid = 1;
	      screen_width = (COLS - COL_FROM_0 - 1) / 2;
	    }
	  adjust_first ();
	}
      else if (wflg || k >= tot || (COLS - COL_FROM_0 - 1) < tot)
	{
	  ver = 0;
	  screen_width = k;
	  base = LINES - 3;
	}
      else
	goto vert;

      move (0, 0);
      clrtobot ();

      if (item == D_GETMEM || item == D_GETBMEM)
	{
	  if (item == D_GETBMEM)
	    {
	      fmt = "Raw Used Memory";
	      i = base / 2 - 8;
	      if (i < 1)
		i = 1;
	    }
	  else
	    {
	      fmt = "Used Memory";
	      i = base / 2 - 6;
	      j = 1;
	    }
	  for (; *fmt; i++)
	    {
	      move (i, 0);
	      addch ((chtype) * fmt++);
	    }
	  while (i == base / 4 || i == base / 2 || i == base * 3 / 4)
	    i++;
	  if (i < base)
	    {
	      move (i, 2);
	      addstr ("(MB)");
	    }
	}
      else if (item == D_GETLOAD)
	{
#ifdef USE_LOG_LOAD
	  int n = (log_load) ? 7 : 3;
	  fmt = (log_load) ? "LOG LOAD" : "LOAD";
#else
	  int n = 3;
	  fmt = "LOAD";
#endif /* USE_LOG_LOAD */