workspace/ksysguard/ksysguardd/Irix/ProcessList.c

   1 /*
   2     KSysGuard, the KDE System Guard
   3
   4         Copyright (c) 1999, 2000 Chris Schlaeger <cs@kde.org>
   5
   6         Irix support by Carsten Kroll <ckroll@pinnaclesys.com>
   7
   8     This program is free software; you can redistribute it and/or
   9     modify it under the terms of version 2 of the GNU General Public
  10     License as published by the Free Software Foundation.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20
  21 */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <unistd.h>
  26 #include <string.h>
  27 #include <errno.h>
  28 #include <fcntl.h>
  29 #include <signal.h>
  30 #include <sys/types.h>
  31 #include <dirent.h>
  32 #include <pwd.h>
  33 #include <sys/resource.h>
  34 #include <sys/procfs.h>
  35 #include <sys/statfs.h>
  36 #include <sys/sysmp.h>
  37 #include <sys/sysinfo.h>
  38
  39 #include "ccont.h"
  40 #include "../../gui/SignalIDs.h"
  41 #include "ksysguardd.h"
  42
  43 #include "Command.h"
  44 #include "ProcessList.h"
  45
  46 #define BUFSIZE 1024
  47 #define KDEINITLEN strlen("kdeinit: ")
  48
  49 typedef struct {
  50         int     alive;          /*  for "garbage collection"            */
  51         pid_t   pid;            /*  process ID                          */
  52         pid_t   ppid;           /*  parent process ID                   */
  53         uid_t   uid;            /*  process owner (real UID)            */
  54         gid_t   gid;            /*  process group (real GID)            */
  55         char    *userName;      /*  process owner (name)                */
  56         int     nThreads;       /*  # of threads in this process        */
  57         int     Prio;           /*  scheduling priority                 */
  58         size_t  Size;           /*  total size of process image         */
  59         size_t  RSSize;         /*  resident set size                   */
  60         char    State[8];       /*  process state                       */
  61         double  Time;           /*  CPU time for the process in 100ms   */
  62         double  Load;           /*  CPU load in %                       */
  63         char    Command[PRCOMSIZ];/*  command name                      */
  64         char    CmdLine[PRARGSZ];/*  command line                       */
  65         double  centStamp;      /*  timestamp for CPU load              */
  66 } ProcessInfo;
  67
  68 static CONTAINER ProcessList = 0;
  69 static unsigned ProcessCount = 0;       /*  # of processes        */
  70 static DIR *procdir;                    /*  handle for /proc      */
  71 static int pagesz;
  72
  73 #define KBYTES 1024
  74
  75 /*
  76  *  lwpStateName()  --  return string representation of process state
  77  */
  78 char *lwpStateName( prpsinfo_t lwpinfo ) {
  79
  80         static char result[8];
  81
  82         switch( lwpinfo.pr_sname ) {
  83                 case 'S':
  84                         sprintf( result, "%s", "sleep" );
  85                         break;
  86                 case 'R':
  87                         sprintf( result, "%s", "run" );
  88                         break;
  89                 case 'Z':
  90                         sprintf( result, "%s", "zombie" );
  91                         break;
  92                 case 'T':
  93                         sprintf( result, "%s", "stop" );
  94                         break;
  95                 case 'I':
  96                         sprintf( result, "%s", "start" );
  97                         break;
  98                 case 'X':
  99                         sprintf( result, "%s", "wmem" );
 100                 case '0':
 101                         sprintf( result, "%s/%d", "cpu", (int) lwpinfo.pr_sonproc );
 102                         break;
 103                 default:
 104                         sprintf( result, "%s", "???" );
 105                         break;
 106         }
 107
 108         return( result );
 109 }
 110
 111 static void validateStr( char *string ) {
 112
 113         char    *ptr = string;
 114
 115         /*
 116          *  remove all chars that might screw up communication
 117          */
 118         while( *ptr != '\0' ) {
 119                 if( *ptr == '\t' || *ptr == '\n' || *ptr == '\r' )
 120                         *ptr = ' ';
 121                 ptr++;
 122         }
 123         /*
 124          *  make sure there's at least one char
 125          */
 126         if( string[0] == '\0' )
 127                 strcpy( string, " " );
 128 }
 129
 130 static int processCmp( void *p1, void *p2 ) {
 131
 132         return( ((ProcessInfo *) p1)->pid - ((ProcessInfo *) p2)->pid );
 133 }
 134
 135 static ProcessInfo *findProcessInList( pid_t pid ) {
 136
 137         ProcessInfo     key;
 138         long            index;
 139
 140         key.pid = pid;
 141         if( (index = search_ctnr( ProcessList, processCmp, &key )) < 0 )
 142                 return( NULL );
 143
 144         return( get_ctnr( ProcessList, index ));
 145 }
 146
 147 static int updateProcess( pid_t pid ) {
 148         ProcessInfo     *ps;
 149         int             fd;
 150         char            buf[BUFSIZE];
 151         prpsinfo_t      psinfo;
 152         struct passwd   *pw;
 153         register double newCentStamp,timeDiff, usDiff,usTime;
 154         struct timeval tv;
 155
 156         if( (ps = findProcessInList( pid )) == NULL ) {
 157                 if( (ps = (ProcessInfo *) malloc( sizeof( ProcessInfo )))
 158                                 == NULL ) {
 159                         print_error( "cannot malloc()\n" );
 160                         return( -1 );
 161                 }
 162                 ps->pid = pid;
 163                 ps->userName = NULL;
 164                 ps->alive = 0;
 165
 166                 gettimeofday(&tv, 0);
 167                 ps->centStamp = (double)tv.tv_sec * 100.0 + (double)tv.tv_usec / 10000.0;
 168
 169                 push_ctnr( ProcessList, ps );
 170                 bsort_ctnr( ProcessList, processCmp );
 171         }
 172
 173         sprintf( buf, "%s/pinfo/%ld", PROCDIR, pid );
 174         if( (fd = open( buf, O_RDONLY )) < 0 ) {
 175                 /* process terminated */
 176                 return( -1 );
 177         }
 178
 179
 180
 181         if( ioctl(fd,PIOCPSINFO,&psinfo) < 0) {
 182                 print_error( "cannot read psinfo from \"%s\"\n", buf );
 183                 close( fd );
 184                 return( -1 );
 185         }
 186         close( fd );
 187
 188         ps->ppid = psinfo.pr_ppid;
 189         ps->uid = psinfo.pr_uid;
 190         ps->gid = psinfo.pr_gid;
 191
 192         pw = getpwuid( psinfo.pr_uid );
 193         if( ps->userName != NULL )
 194                 free( ps->userName );
 195         ps->userName = strdup( pw->pw_name );
 196
 197         strncpy (ps->State,lwpStateName( psinfo ),8);
 198         ps->State[7]='\0';
 199
 200
 201         ps->Prio = psinfo.pr_pri;
 202
 203         gettimeofday(&tv, 0);
 204         newCentStamp = (double)tv.tv_sec * 100.0 + (double) tv.tv_usec / 10000.0;
 205         usTime = (double) psinfo.pr_time.tv_sec * 100.0 + (double)psinfo.pr_time.tv_nsec / 10000000.0;
 206
 207         timeDiff = newCentStamp - ps->centStamp;
 208         usDiff = usTime - ps->Time;
 209
 210         if ((timeDiff > 0.0) && (usDiff >= 0.0))
 211         {
 212                 ps->Load = (usDiff / timeDiff) * 100.0;
 213                 /* During startup we get bigger loads since the time diff
 214                 * cannot be correct. So we force it to 0. */
 215                 ps->Load = (ps->Load > 100.0) ? 0.0 : ps->Load;
 216         }
 217         else
 218                 ps->Load = 0.0;
 219
 220         ps->centStamp = newCentStamp;
 221         ps->Time = usTime;
 222
 223         ps->Size = (psinfo.pr_size * pagesz)/KBYTES;
 224         ps->RSSize = (psinfo.pr_rssize * pagesz)/KBYTES;
 225
 226         strncpy(ps->Command,psinfo.pr_fname,PRCOMSIZ);
 227         ps->Command[PRCOMSIZ-1]='\0';
 228
 229         strncpy(ps->CmdLine,psinfo.pr_psargs,PRARGSZ);
 230         ps->CmdLine[PRARGSZ-1]='\0';
 231
 232         validateStr( ps->Command );
 233         validateStr( ps->CmdLine );
 234
 235         ps->alive = 1;
 236         return( 0 );
 237 }
 238
 239 static void cleanupProcessList( void ) {
 240
 241         ProcessInfo *ps;
 242
 243         ProcessCount = 0;
 244         for( ps = first_ctnr( ProcessList ); ps; ps = next_ctnr( ProcessList )) {
 245                 if( ps->alive ) {
 246                         /* Process is still alive. Just clear flag. */
 247                         ps->alive = 0;
 248                         ProcessCount++;
 249                 } else {
 250                         /* Process has probably died. We remove it from the list and
 251                          * destruct the data structure. */
 252                         free( remove_ctnr( ProcessList ));
 253                 }
 254         }
 255 }
 256
 257 void initProcessList( struct SensorModul* sm ) {
 258
 259         if( (procdir = opendir( PROCDIR )) == NULL ) {
 260                 print_error( "cannot open \"%s\" for reading\n", PROCDIR );
 261                 return;
 262         }
 263         pagesz=getpagesize();
 264         ProcessList = new_ctnr();
 265         updateProcessList();
 266
 267         /*
 268          *  register the supported monitors & commands
 269          */
 270         registerMonitor( "pscount", "integer",
 271                                 printProcessCount, printProcessCountInfo, sm );
 272         registerMonitor( "ps", "table",
 273                                 printProcessList, printProcessListInfo, sm );
 274
 275         if (!RunAsDaemon)
 276         {
 277                 registerCommand("kill", killProcess);
 278                 registerCommand("setpriority", setPriority);
 279         }
 280 }
 281
 282 void exitProcessList( void ) {
 283
 284         removeMonitor("ps");
 285         removeMonitor("pscount");
 286
 287         if (!RunAsDaemon)
 288         {
 289                 removeCommand("kill");
 290                 removeCommand("setpriority");
 291         }
 292
 293         destr_ctnr( ProcessList, free );
 294 }
 295
 296 int updateProcessList( void ) {
 297
 298         struct dirent   *de;
 299         struct statfs sf;
 300
 301         statfs("/proc/pinfo",&sf,sizeof(sf),0);
 302         ProcessCount = sf.f_files;
 303
 304         rewinddir( procdir );
 305         while( (de = readdir( procdir )) != NULL ) {
 306                 /*
 307                  *  skip '.' and '..'
 308                  */
 309                 if( de->d_name[0] == '.' )
 310                         continue;
 311
 312                 /*
 313                  *  fetch the process info and insert it into the info table
 314                  */
 315                 updateProcess( (pid_t) atol( de->d_name ));
 316         }
 317         cleanupProcessList();
 318
 319         return( 0 );
 320 }
 321
 322 void printProcessListInfo( const char *cmd ) {
 323         fprintf(CurrentClient, "Name\tPID\tPPID\tGID\tStatus\tUser"
 324                 "\tSize\tResident\t%% CPU\tPriority\tCommand\n" );
 325         fprintf(CurrentClient, "s\td\td\td\ts\ts\tD\tD\tf\td\ts\n" );
 326 }
 327
 328 void printProcessList( const char *cmd ) {
 329
 330         ProcessInfo *ps;
 331
 332         for( ps = first_ctnr( ProcessList ); ps; ps = next_ctnr( ProcessList )) {
 333                 fprintf(CurrentClient,
 334                         "%s\t%ld\t%ld\t%ld\t%s\t%s\t%d\t%d\t%.2f\t%d\t%s\n",
 335                         ps->Command,
 336                         (long) ps->pid,
 337                         (long) ps->ppid,
 338                         (long) ps->gid,
 339                         ps->State,
 340                         ps->userName,
 341                         ps->Size,
 342                         ps->RSSize,
 343                         ps->Load,
 344                         ps->Prio,
 345                         ps->CmdLine);
 346         }
 347
 348         fprintf(CurrentClient, "\n");
 349 }
 350
 351 void printProcessCount( const char *cmd ) {
 352         fprintf(CurrentClient, "%d\n", ProcessCount );
 353 }
 354
 355 void printProcessCountInfo( const char *cmd ) {
 356         fprintf(CurrentClient, "Number of Processes\t0\t0\t\n" );
 357 }
 358
 359 void killProcess( const char *cmd ) {
 360
 361         int sig, pid;
 362
 363         sscanf( cmd, "%*s %d %d", &pid, &sig );
 364
 365         switch( sig ) {
 366                 case MENU_ID_SIGABRT:
 367                         sig = SIGABRT;
 368                         break;
 369                 case MENU_ID_SIGALRM:
 370                         sig = SIGALRM;
 371                         break;
 372                 case MENU_ID_SIGCHLD:
 373                         sig = SIGCHLD;
 374                         break;
 375                 case MENU_ID_SIGCONT:
 376                         sig = SIGCONT;
 377                         break;
 378                 case MENU_ID_SIGFPE:
 379                         sig = SIGFPE;
 380                         break;
 381                 case MENU_ID_SIGHUP:
 382                         sig = SIGHUP;
 383                         break;
 384                 case MENU_ID_SIGILL:
 385                         sig = SIGILL;
 386                         break;
 387                 case MENU_ID_SIGINT:
 388                         sig = SIGINT;
 389                         break;
 390                 case MENU_ID_SIGKILL:
 391                         sig = SIGKILL;
 392                         break;
 393                 case MENU_ID_SIGPIPE:
 394                         sig = SIGPIPE;
 395                         break;
 396                 case MENU_ID_SIGQUIT:
 397                         sig = SIGQUIT;
 398                         break;
 399                 case MENU_ID_SIGSEGV:
 400                         sig = SIGSEGV;
 401                         break;
 402                 case MENU_ID_SIGSTOP:
 403                         sig = SIGSTOP;
 404                         break;
 405                 case MENU_ID_SIGTERM:
 406                         sig = SIGTERM;
 407                         break;
 408                 case MENU_ID_SIGTSTP:
 409                         sig = SIGTSTP;
 410                         break;
 411                 case MENU_ID_SIGTTIN:
 412                         sig = SIGTTIN;
 413                         break;
 414                 case MENU_ID_SIGTTOU:
 415                         sig = SIGTTOU;
 416                         break;
 417                 case MENU_ID_SIGUSR1:
 418                         sig = SIGUSR1;
 419                         break;
 420                 case MENU_ID_SIGUSR2:
 421                         sig = SIGUSR2;
 422                         break;
 423         }
 424         if( kill( (pid_t) pid, sig )) {
 425                 switch( errno ) {
 426                         case EINVAL:
 427                                 fprintf(CurrentClient, "4\n" );
 428                                 break;
 429                         case ESRCH:
 430                                 fprintf(CurrentClient, "3\n" );
 431                                 break;
 432                         case EPERM:
 433                                 fprintf(CurrentClient, "2\n" );
 434                                 break;
 435                         default:
 436                                 fprintf(CurrentClient, "1\n" ); /* unknown error */
 437                                 break;
 438                 }
 439         } else
 440                 fprintf(CurrentClient, "0\n");
 441 }
 442
 443 void setPriority( const char *cmd ) {
 444         int pid, prio;
 445
 446         sscanf( cmd, "%*s %d %d", &pid, &prio );
 447         if( setpriority( PRIO_PROCESS, pid, prio )) {
 448                 switch( errno ) {
 449                         case EINVAL:
 450                                 fprintf(CurrentClient, "4\n" );
 451                                 break;
 452                         case ESRCH:
 453                                 fprintf(CurrentClient, "3\n" );
 454                                 break;
 455                         case EPERM:
 456                         case EACCES:
 457                                 fprintf(CurrentClient, "2\n" );
 458                                 break;
 459                         default:
 460                                 fprintf(CurrentClient, "1\n" ); /* unknown error */
 461                                 break;
 462                 }
 463         } else
 464                 fprintf(CurrentClient, "0\n");
 465 }