How to get how many processes running on a Linx machine?

Hi! All:
I know that /proc/ provides one dirctory to store the useful information for each process! But is there any way to get how many processes currently running on a machine, and get a list of pid? Thank you very much!

try

ps aux

man ps

will help u more

regards

ps is verey useful as masand suggested

take a look of pstree and top also.

Thank you very much! But I just hope I can write a program to minitor the information for the processes such like "top" . I just wanna know there is any API wich can get how many processes running on a linux machine and get the pid list! Thanks!

if u use kde then u can use the kde system monitor

regards

I believe programs like ps and top simply view the contents of the /proc directory. The directories that are pure numbers are all the running process id.

If nothing else you could use this program:

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <unistd.h>
#include <dirent.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>

int is_all_digits(char *str)
{
  while(*str)
  {
    if(!isdigit(*str))
      break;
    str++;
  }

  return *str ? 0 : 1;
}

int main(void)
{
  DIR *dir;
  struct dirent *dent;
  struct stat stbuf;
  char buf[PATH_MAX];

  if(!(dir = opendir("/proc")))
  {
    perror("opendir()");
    exit(EXIT_FAILURE);
  }

  while((dent = readdir(dir)))
  {
    if(!is_all_digits(dent->d_name))
      continue;

    snprintf(buf, PATH_MAX, "/proc/%s", dent->d_name);
    if((stat(buf, &stbuf)) == -1)
    {
      perror("stat()");
      continue;
    }

    if(S_ISDIR(stbuf.st_mode))
      puts(dent->d_name);
  }

  closedir(dir);

  return EXIT_SUCCESS;
}

itsme@dreams:~/C$ ./listpids | head
1
2
3
4
5
6
7
84
90
93
itsme@dreams:~/C$

Thank you very much!

What if you are just looking to see if a particular process is running ( via C/C++ ) by name, how could that been done?

Originally posted by fortezza What if you are just looking to see if a particular process is running ( via C/C++ ) by name, how could that been done?

Changed the code itsme86 posted to do that:

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <unistd.h>
#include <dirent.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>

int checkexe(char *pid, char *searchexe)
{
    int len;
    char *exefile;
    char exepath[PATH_MAX];
    char symlink[PATH_MAX];

    /* Symlink /proc/<pid>/exe points to the executable file
     * which is running in the process.
     *
     * Resolve the symlink, remove the directory part of the path,
     * and compare that to the exe-name we are looking for.
     */
    
    snprintf(symlink, PATH_MAX, "/proc/%s/exe", pid);
    len = readlink(symlink, exepath, PATH_MAX);

    /* Catch some readlink() errors: */
    if (len >= PATH_MAX) {
        fprintf(stderr, "Path for pid #%s too long. Truncated.\n", pid);
        return 0;
    }
    if (len < 0) {  /* Often harmless error, e.g. "permission denied". */
        return 0;   /* No error message, just returning false silently here. */
    }
    exepath[len] = '\0';

    /* Skip directory part of the path to get to the filename */
    exefile = strrchr(exepath, '/');
    if (exefile == NULL) 
        exefile = exepath;
    else if (++exefile == '\0')
        exefile = exepath;

    /* Compare the exe-name searching for with the file-name linked to
     * by /proc/<pid>/exe.
     */
    return !strcasecmp(exefile, searchexe);
}


int is_all_digits(char *str)
{
    while (*str) {
        if (!isdigit(*str))
            break;
        str++;
    }

    return *str ? 0 : 1;
}


int main(int argc, char *argv[])
{
    DIR *dir;
    struct dirent *dent;
    struct stat stbuf;
    char procpath[PATH_MAX];

    if (argc != 2) {
        fprintf(stderr, "Usage: %s <process executable name>\n\n", *argv);
        exit(EXIT_FAILURE);
    }

    if (!(dir = opendir("/proc"))) {
        perror("opendir()");
        exit(EXIT_FAILURE);
    }

    while ((dent = readdir(dir))) {
        if (!is_all_digits(dent->d_name))
            continue;

        snprintf(procpath, PATH_MAX, "/proc/%s", dent->d_name);
        if ((stat(procpath, &stbuf)) == -1) {
            perror("stat()");
            continue;
        }

        if (S_ISDIR(stbuf.st_mode))
            if (checkexe(dent->d_name, argv[1]))
                printf("%s is running in PID #%s.\n", argv[1], dent->d_name);
    }

    closedir(dir);
    return EXIT_SUCCESS;
}

It checks the /proc/<pid>/exe symlinks for the name. It works well, but now I started thinking it may be better to read the /proc/<pid>/cmdline files to check for the name, because non-privileged users more often have permissions to read /proc/<pid>/cmdline than to resolve the /proc/<pid>/exe symlink.

OTOH, I think /proc/<pid>/exe may be more accurate.

The overrall goal was to write a C++ program that could detect if a process was running and start it in the correct display if it wasn't.

Here is what just got working about 20 minutes ago. It needs some cleanup/commenting/error checking, but for now it gets the job done. The hard part was starting the process and then exiting, since every C++ function to start a process insists on waiting the the process to end. My workaround was to start the process under a thread, detach the thread, wait for the process to be in the process list, and then exit the main program. My compiler won't let me terminate the program until the child process is closed, but from the command line it works fine ( starts the external program and exits ).


Here it is:

#include <pthread.h>
#include <iostream.h>
#include <unistd.h>


#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <unistd.h>
#include <dirent.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fstream.h>
#include <iostream.h>
#include <string.h>
#include <sys/signal.h>
#include <unistd.h>
#include <fcntl.h> 



using namespace std;


class Thread {
	private:
		pthread_t thread;
		static void * dispatch(void *);
	protected:
		virtual void run() = 0;
	public:
		virtual ~Thread();
		void start();
		void join();
		void detach();
};



Thread::~Thread()
{}

void * Thread::dispatch(void * ptr)
{
	if (!ptr) return 0;
	static_cast<Thread *>(ptr)->run();
	pthread_exit(ptr);
	return 0;
}

void Thread::start()
{
	pthread_create(&thread, 0, Thread::dispatch, this);
}

void Thread::join()
{
	pthread_join( thread, 0 );
	//pthread_join(thread, 0);
}

void Thread::detach() {
	pthread_detach( thread );

}


class Test : public Thread
{
	private:
		string image;
		string display;
	protected:
		virtual void run();
	public:
		Test(string image, string display ) : image(image),display(display) {}
};

void Test::run()
{
	//cout << "Starting Amule!\n";
	char buf[100];
	if ( display.length()  ) {
		sprintf( buf, "DISPLAY=\":0.%s\" %s &",display.c_str(),image.c_str() ); 
	}
	else {
		sprintf( buf, "DISPLAY=\":0.0\" %s &", image.c_str() ); 
	}
	
	system( buf );
}


using namespace std;


bool isRunning( string procName );

int is_all_digits(char *str)
{
  while(*str)
  {
    if(!isdigit(*str))
      break;
    str++;
  }

  return *str ? 0 : 1;
}


int main( int argc, char *argv[] )
{
	Test *a;
	if ( argc == 2 ) {
		a = new Test( argv[1], ""  );
	}
	else if ( argc ==3 ) {
		a = new Test( argv[1], argv[2]  );
	}
	else {
		cout << "Command syntax is: startproc <image name> <display 0>." << endl;
		return 1;
	}
	a->start();
	a->detach();
	while ( not isRunning( argv[1] ) ) {
		usleep( 1000 );
	}
	return 0;
}

bool isRunning( string procName ) {

  DIR *dir;
  struct dirent *dent;
  struct stat stbuf;
  char buf[PATH_MAX];
  bool found = false;
  if(!(dir = opendir("/proc")))
  {
    perror("opendir()");
    exit(EXIT_FAILURE);
  }

  while((dent = readdir(dir)))
  {
    if(!is_all_digits(dent->d_name))
      continue;
	char filepath[2000];
	char str2[2000];
	sprintf( filepath, "/proc/%s/cmdline",dent->d_name );
    fstream file_op( filepath ,ios::in);
	while ( ! file_op.eof() ) {
		file_op.getline( str2, 2000 );
		string strName( str2 );
		int index = strName.find( procName );
	    //snprintf(buf, PATH_MAX, "str=%s", str);
		if ( index >= 0 ) {
			//printf( "Command=%s, index=%d\n", strName.c_str(), index );
			found = true;
			break;
			//cout << strName << endl;
		}
	}	  
	file_op.close();
  }
  if ( found ) {
  	printf( "%s is running :)\n", procName.c_str() );
	//return true;
  }
  else {
  	printf( "%s is not running :(\n", procName.c_str() );
  }
  closedir(dir);
  return found;

}