int
machine_get_procs(LinkedList * procs)
{
	struct kinfo_proc *kprocs;
	int nproc, i;
	procinfo_type *p;
	kvm_t *kvmd;

	if ((kvmd = kvm_open(NULL, NULL, NULL, O_RDONLY, "kvm_open")) == NULL) {
		perror("kvm_open");
		return (FALSE);
	}

#if OpenBSD >= 201111
	kprocs = kvm_getprocs(kvmd, KERN_PROC_ALL, 0, sizeof(struct kinfo_proc), &nproc);
#else
	kprocs = kvm_getprocs(kvmd, KERN_PROC_ALL, 0, &nproc);
#endif
	if (kprocs == NULL) {
		perror("kvm_getprocs");
		kvm_close(kvmd);
		return (FALSE);
	}

	for (i = 0; i < nproc; i++) {
		p = malloc(sizeof(procinfo_type));
		if (!p) {
			perror("mem_top_malloc");
			kvm_close(kvmd);
			return (FALSE);
		}
#if OpenBSD >= 201111
		strncpy(p->name, kprocs->p_comm, 15);
		p->name[15] = '\0';
		p->totl = pagetok(PROCSIZE(kprocs));
		p->number = kprocs->p_pid;
#else
		strncpy(p->name, kprocs->kp_proc.p_comm, 15);
		p->name[15] = '\0';
		p->totl = pagetok(PROCSIZE(kprocs->kp_eproc.e_vm));
		p->number = kprocs->kp_proc.p_pid;
#endif
		LL_Push(procs, (void *)p);

		kprocs++;
	}
	kvm_close(kvmd);

	return (TRUE);
}
Exemple #2
0
uv_err_t uv_resident_set_memory(size_t* rss) {
  kvm_t *kd = NULL;
  struct kinfo_proc *kinfo = NULL;
  pid_t pid;
  int nprocs;
  size_t page_size = getpagesize();

  pid = getpid();

  kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, "kvm_open");
  if (kd == NULL) goto error;

  kinfo = kvm_getprocs(kd, KERN_PROC_PID, pid, &nprocs);
  if (kinfo == NULL) goto error;

#ifdef __DragonFly__
  *rss = kinfo->kp_vm_rssize * page_size;
#else
  *rss = kinfo->ki_rssize * page_size;
#endif

  kvm_close(kd);

  return uv_ok_;

error:
  if (kd) kvm_close(kd);
  return uv__new_sys_error(errno);
}
Exemple #3
0
static int pid_to_cmd(pid_t pid, char *cmd, size_t cmd_size)
{
	int cnt, ret;
	kvm_t *kd;
	struct kinfo_proc *kp;

	ret = -1;

	if ((kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, NULL)) == NULL)
		return ret;
	if ((kp = kvm_getprocs(kd, KERN_PROC_PID, (int)pid, sizeof(*kp), &cnt)) == NULL)
		goto out;
	if ((kp->p_flag & P_SYSTEM) != 0)
		goto out;
	if (cnt != 1)
		goto out;
	if (strlcpy(cmd, kp[0].p_comm, cmd_size) >= cmd_size)
		goto out;

	ret = 0;

out:
	kvm_close(kd);
	return ret;
}
Exemple #4
0
/**
 * Get all visible processes including the kernel visible threads
 */
static void
swrun_OS_get_procs(void)
{
	struct kinfo_proc *plist, *kp;
	int i;
	int nproc;
	struct swrun_entry *entry;

	plist = kvm_getprocs(hr_kd, KERN_PROC_ALL, 0, &nproc);
	if (plist == NULL || nproc < 0) {
		syslog(LOG_ERR, "kvm_getprocs() failed: %m");
		return;
	}
	for (i = 0, kp = plist; i < nproc; i++, kp++) {
		/*
		 * The SNMP table's index must begin from 1 (as specified by
		 * this table definition), the PIDs are starting from 0
		 * so we are translating the PIDs to +1
		 */
		entry = swrun_entry_find_by_index((int32_t)kp->ki_pid + 1);
		if (entry == NULL) {
			/* new entry - get memory for it */
			entry = swrun_entry_create((int32_t)kp->ki_pid + 1);
			if (entry == NULL)
				continue;
		}
		entry->flags |= HR_SWRUN_FOUND;	/* mark it as found */

		kinfo_proc_to_swrun_entry(kp, entry);
	}
}
Exemple #5
0
int
os_isrunning(int pid)
{
    static kvm_t *kd;
    struct kinfo_proc *p;
    int i, n_processes;

    if ((kd = kvm_open("/dev/null", "/dev/null", "/dev/null", O_RDONLY, "kvm_open")) == NULL)
    {
	  	return TRUE;
    }
    else
    {
    	p = kvm_getprocs(kd, KERN_PROC_PROC, 0, &n_processes);
    	for (i = 0; i < n_processes; i++)
    	{
    		if (pid == p[i].ki_pid)
    		{
    			return TRUE;
    		}
    	}

    	kvm_close(kd);
    }

    return FALSE;
}
Exemple #6
0
void
glibtop_get_proc_segment_p (glibtop *server,
			    glibtop_proc_segment *buf,
			    pid_t pid)
{
	struct kinfo_proc *pinfo;
	int count = 0;

	memset (buf, 0, sizeof (glibtop_proc_segment));

	/* It does not work for the swapper task. */
	if (pid == 0) return;

	/* Get the process info from the kernel */
	pinfo = kvm_getprocs (server->machine->kd, KERN_PROC_PID, pid, &count);
	if ((pinfo == NULL) || (count != 1)) {
		glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid);
		return;
	}

	buf->text_rss = pinfo[0].ki_tsize * pagesize;
	buf->data_rss = pinfo[0].ki_dsize * pagesize;

	buf->flags = _glibtop_sysdeps_proc_segment;
}
Exemple #7
0
int uv_resident_set_memory(size_t* rss) {
  kvm_t *kd = NULL;
  struct kinfo_proc *kinfo = NULL;
  pid_t pid;
  int nprocs, max_size = sizeof(struct kinfo_proc);
  size_t page_size = getpagesize();

  pid = getpid();

  kd = kvm_open(NULL, _PATH_MEM, NULL, O_RDONLY, "kvm_open");
  if (kd == NULL) goto error;

  kinfo = kvm_getprocs(kd, KERN_PROC_PID, pid, max_size, &nprocs);
  if (kinfo == NULL) goto error;

  *rss = kinfo->p_vm_rssize * page_size;

  kvm_close(kd);

  return 0;

error:
  if (kd) kvm_close(kd);
  return -EPERM;
}
Exemple #8
0
static void
fstat_kvm(int what, int arg)
{
	struct kinfo_proc *p, *plast;
	char buf[_POSIX2_LINE_MAX];
	int cnt;

	ALLOC_OFILES(256);	/* reserve space for file pointers */

	/*
	 * Discard setgid privileges if not the running kernel so that bad
	 * guys can't print interesting stuff from kernel memory.
	 */
	if (nlistf != NULL || memf != NULL)
		setgid(getgid());

	if ((kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, buf)) == NULL)
		errx(1, "%s", buf);
	setgid(getgid());
#ifdef notdef
	if (kvm_nlist(kd, nl) != 0)
		errx(1, "no namelist: %s", kvm_geterr(kd));
#endif
	if ((p = kvm_getprocs(kd, what, arg, &cnt)) == NULL)
		errx(1, "%s", kvm_geterr(kd));
	print_header();
	for (plast = &p[cnt]; p < plast; ++p) {
		if (p->ki_stat == SZOMB)
			continue;
		dofiles(p);
		if (mflg)
			dommap(p);
	}
}
Exemple #9
0
int
main(int ac, char **av)
{
    const char *corefile = NULL;
    const char *sysfile = NULL;
    struct kinfo_proc *kp;
    kvm_t *kd;
    int ch;
    int i;
    int nprocs;

    while ((ch = getopt(ac, av, "M:N:v")) != -1) {
	switch(ch) {
	case 'v':
	    ++verboseopt;
	    break;
	case 'M':
	    corefile = optarg;
	    break;
	case 'N':
	    sysfile = optarg;
	    break;
	default:
	    fprintf(stderr, "%s [-M core] [-N system]\n", av[0]);
	    exit(1);
	}
    }
    ac -= optind;
    av += optind;

    if ((kd = kvm_open(sysfile, corefile, NULL, O_RDONLY, "kvm:")) == NULL) {
	perror("kvm_open");
	exit(1);
    }

    if ((kp = kvm_getprocs(kd, KERN_PROC_ALL, 0, &nprocs)) == NULL)
	errx(1, "%s", kvm_geterr(kd));

    fprintf(stdout, "%-6s %-6s %-20s %-10s %-5s\n",
	"PID",
	"PPID",
	"COMMAND",
	"LOGIN",
	"NICE");

    for (i = 0; i < nprocs; i++) {
	    fprintf(stdout, "%-6d %-6d %-20s %-10s %-5d\n",
		kp[i].kp_pid,
		kp[i].kp_ppid,
		kp[i].kp_comm,
		kp[i].kp_login,
		kp[i].kp_nice);
    }

    kvm_close(kd);

    return 0;

}
Exemple #10
0
void update_total_processes()
{
	int n_processes;

	kvm_init();
	kvm_getprocs(kd, KERN_PROC_ALL, 0, &n_processes);

	info.procs = n_processes;
}
 int ProcessInfo::getVirtualMemorySize() {
     kvm_t *kd = NULL;
     int cnt = 0;
     char err[_POSIX2_LINE_MAX] = {0};
     if ((kd = kvm_open(NULL, "/dev/null", "/dev/null", O_RDONLY, err)) == NULL)
         return -1;
     kinfo_proc * task = kvm_getprocs(kd, KERN_PROC_PID, _pid.toNative(), &cnt);
     kvm_close(kd);
     return task->ki_size / 1024 / 1024; // convert from bytes to MB
 }
 int ProcessInfo::getResidentSize() {
     kvm_t *kd = NULL;
     int cnt = 0;
     char err[_POSIX2_LINE_MAX] = {0};
     if ((kd = kvm_open(NULL, "/dev/null", "/dev/null", O_RDONLY, err)) == NULL)
         return -1;
     kinfo_proc * task = kvm_getprocs(kd, KERN_PROC_PID, _pid.toNative(), &cnt);
     kvm_close(kd);
     return task->ki_rssize * sysconf( _SC_PAGESIZE ) / 1024 / 1024; // convert from pages to MB
 }
Exemple #13
0
void
glibtop_get_proc_kernel_p (glibtop *server,
			   glibtop_proc_kernel *buf,
			   pid_t pid)
{
	struct kinfo_proc *pinfo;
	int count;

	glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_PROC_KERNEL), 0);

	memset (buf, 0, sizeof (glibtop_proc_kernel));

	if (server->sysdeps.proc_time == 0)
		return;

	/* It does not work for the swapper task. */
	if (pid == 0) return;

	glibtop_suid_enter (server);

	/* Get the process information */
	pinfo = kvm_getprocs (server->machine->kd, KERN_PROC_PID, pid,
			      sizeof(*pinfo), &count);
	if (pinfo == NULL) {
		glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid);
		glibtop_suid_leave (server);
		return;
	}

	glibtop_suid_leave (server);

#define	PROC_WCHAN	p_wchan
#define	PROC_WMESG	p_wmesg

	buf->nwchan = (unsigned long) pinfo [0].PROC_WCHAN;

	buf->flags |= (1L << GLIBTOP_PROC_KERNEL_NWCHAN);

	if (pinfo [0].PROC_WCHAN && pinfo [0].PROC_WMESG[0] != 0) {
		g_strlcpy (buf->wchan, pinfo [0].PROC_WMESG,
			 sizeof buf->wchan);
		buf->flags |= (1L << GLIBTOP_PROC_KERNEL_WCHAN);
	} else {
		buf->wchan [0] = 0;
	}

	buf->k_flags = (unsigned long) pinfo [0].p_flag;
	buf->min_flt = (unsigned long) pinfo [0].p_uru_minflt;
	buf->maj_flt = (unsigned long) pinfo [0].p_uru_majflt;

	buf->flags |= _glibtop_sysdeps_proc_kernel_pstats;

	return;
}
Exemple #14
0
char *
glibtop_get_proc_args_p (glibtop *server, glibtop_proc_args *buf,
			 pid_t pid, unsigned max_len)
{
	struct kinfo_proc *pinfo;
	char *retval, **args, **ptr;
	size_t size = 0, pos = 0;
	int count;

	glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_PROC_ARGS), 0);

	memset (buf, 0, sizeof (glibtop_proc_args));

	/* Ignore init */
	if (pid < 2) return NULL;

	glibtop_suid_enter (server);

	/* Get the process data */
	pinfo = kvm_getprocs (server->machine->kd, KERN_PROC_PID, pid,
			       sizeof (*pinfo), &count);
	if (pinfo == NULL) {
		glibtop_suid_leave (server);
		glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid);
		return NULL;
	}

	args = kvm_getargv (server->machine->kd, pinfo, max_len);
	if (args == NULL) {
		glibtop_suid_leave (server);
		glibtop_warn_io_r (server, "kvm_getargv (%d)", pid);
		return NULL;
	}

	glibtop_suid_leave (server);

	for (ptr = args; *ptr; ptr++)
		size += strlen (*ptr)+1;

	size += 2;
	retval = g_malloc0 (size);

	for (ptr = args; *ptr; ptr++) {
		const size_t len = strlen (*ptr)+1;
		memcpy (retval+pos, *ptr, len);
		pos += len;
	}

	buf->size = pos ? pos-1 : 0;

	buf->flags = _glibtop_sysdeps_proc_args;

	return retval;
}
/**
 * Read all processes to initialize the information tree.
 * @param reference  reference of ProcessTree
 * @param pflags Process engine flags
 * @return treesize > 0 if succeeded otherwise 0.
 */
int initprocesstree_sysdep(ProcessTree_T **reference, ProcessEngine_Flags pflags) {
        kvm_t *kvm_handle = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, prog);
        if (! kvm_handle) {
                LogError("system statistic error -- cannot initialize kvm interface\n");
                return 0;
        }

        int treesize;
        struct kinfo_proc *pinfo = kvm_getprocs(kvm_handle, KERN_PROC_ALL, 0, &treesize);
        if (! pinfo || (treesize < 1)) {
                LogError("system statistic error -- cannot get process tree\n");
                kvm_close(kvm_handle);
                return 0;
        }

        ProcessTree_T *pt = CALLOC(sizeof(ProcessTree_T), treesize);

        StringBuffer_T cmdline = NULL;
        if (pflags & ProcessEngine_CollectCommandLine)
                cmdline = StringBuffer_create(64);
        for (int i = 0; i < treesize; i++) {
                pt[i].pid          = pinfo[i].kp_pid;
                pt[i].ppid         = pinfo[i].kp_ppid;
                pt[i].cred.uid     = pinfo[i].kp_ruid;
                pt[i].cred.euid    = pinfo[i].kp_uid;
                pt[i].cred.gid     = pinfo[i].kp_rgid;
                pt[i].threads      = pinfo[i].kp_nthreads;
                pt[i].uptime       = systeminfo.time / 10. - pinfo[i].kp_start.tv_sec;
                pt[i].cpu.time     = (double)((pinfo[i].kp_lwp.kl_uticks + pinfo[i].kp_lwp.kl_sticks + pinfo[i].kp_lwp.kl_iticks) / 1000000.);
                pt[i].memory.usage = (uint64_t)pinfo[i].kp_vm_rssize * (uint64_t)pagesize;
                pt[i].zombie       = pinfo[i].kp_stat == SZOMB ? true : false;
                if (pflags & ProcessEngine_CollectCommandLine) {
                        char **args = kvm_getargv(kvm_handle, &pinfo[i], 0);
                        if (args) {
                                StringBuffer_clear(cmdline);
                                for (int j = 0; args[j]; j++)
                                        StringBuffer_append(cmdline, args[j + 1] ? "%s " : "%s", args[j]);
                                if (StringBuffer_length(cmdline))
                                        pt[i].cmdline = Str_dup(StringBuffer_toString(StringBuffer_trim(cmdline)));
                        }
                        if (! pt[i].cmdline || ! *pt[i].cmdline) {
                                FREE(pt[i].cmdline);
                                pt[i].cmdline = Str_dup(pinfo[i].kp_comm);
                        }
                }
        }
        if (pflags & ProcessEngine_CollectCommandLine)
                StringBuffer_free(&cmdline);

        *reference = pt;
        kvm_close(kvm_handle);

        return treesize;
}
Exemple #16
0
/**
 * Read all processes to initialize the information tree.
 * @param reference  reference of ProcessTree
 * @return treesize>0 if succeeded otherwise =0.
 */
int initprocesstree_sysdep(ProcessTree_T **reference) {
        int                treesize;
        static kvm_t      *kvm_handle;
        ProcessTree_T     *pt;
        struct kinfo_proc *pinfo;

        if (! (kvm_handle = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, prog))) {
                LogError("system statistic error -- cannot initialize kvm interface\n");
                return 0;
        }

        pinfo = kvm_getprocs(kvm_handle, KERN_PROC_PROC, 0, &treesize);
        if (! pinfo || (treesize < 1)) {
                LogError("system statistic error -- cannot get process tree\n");
                kvm_close(kvm_handle);
                return 0;
        }

        pt = CALLOC(sizeof(ProcessTree_T), treesize);

        for (int i = 0; i < treesize; i++) {
                StringBuffer_T cmdline = StringBuffer_create(64);
                pt[i].pid       = pinfo[i].ki_pid;
                pt[i].ppid      = pinfo[i].ki_ppid;
                pt[i].uid       = pinfo[i].ki_ruid;
                pt[i].euid      = pinfo[i].ki_uid;
                pt[i].gid       = pinfo[i].ki_rgid;
                pt[i].starttime = pinfo[i].ki_start.tv_sec;
                pt[i].cputime   = (long)(pinfo[i].ki_runtime / 100000);
                pt[i].mem_kbyte = (unsigned long)(pinfo[i].ki_rssize * pagesize_kbyte);
                int flags       = pinfo[i].ki_stat;
                char * procname = pinfo[i].ki_comm;
                if (flags == SZOMB)
                        pt[i].zombie = true;
                pt[i].cpu_percent = 0;
                pt[i].time = get_float_time();
                char **args;
                if ((args = kvm_getargv(kvm_handle, &pinfo[i], 0))) {
                        for (int j = 0; args[j]; j++)
                                StringBuffer_append(cmdline, args[j + 1] ? "%s " : "%s", args[j]);
                        pt[i].cmdline = Str_dup(StringBuffer_toString(StringBuffer_trim(cmdline)));
                }
                StringBuffer_free(&cmdline);
                if (! pt[i].cmdline || ! *pt[i].cmdline) {
                        FREE(pt[i].cmdline);
                        pt[i].cmdline = Str_dup(procname);
                }
        }

        *reference = pt;
        kvm_close(kvm_handle);

        return treesize;
}
int ProcessInfo::getResidentSize() {
    kvm_t* kd = NULL;
    int cnt = 0;
    char err[_POSIX2_LINE_MAX] = {0};
    if ((kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, err)) == NULL) {
        log() << "Unable to get res mem size: " << err << endl;
        return -1;
    }
    kinfo_proc* task = kvm_getprocs(kd, KERN_PROC_PID, _pid.toNative(), sizeof(kinfo_proc), &cnt);
    kvm_close(kd);
    return (task->p_vm_rssize * sysconf(_SC_PAGESIZE)) / 1048576;  // convert from pages to MB
}
  static  uint32_t  getRunningProcesses( void )
  {
    struct kinfo_proc *kp;
    int i;
    int state;
    int nentries;
    kvm_t *kd = NULL;
    int what = KERN_PROC_ALL;
    
    uint32_t val32;
    
    val32 = 0;
    
    // it looks like we don't need to be root to call kvm_open
    // just to read the process table (in the way that the ps(1) command does).
    kd=kvm_open("/dev/null", "/dev/null", "/dev/null", O_RDONLY, "kvm_open");
    if (kd == NULL) {
      myLog(LOG_ERR, "kvm_open() failed");
    }
    else {
      
#ifdef KERN_PROC_NOTHREADS
      what |= KERN_PROC_NOTHREADS;
#endif
      
      if ((kp = kvm_getprocs(kd, what, 0, &nentries)) == 0 || nentries < 0) {
	myLog(LOG_ERR, "kvm_getprocs() failed");
      }
      else {
	if(debug) myLog(LOG_INFO,"kvm_getprocs found %u entries", nentries);
	
	for (i = 0; i < nentries; kp++, i++) {
#ifdef KINFO_PROC_SIZE
	  state = kp->ki_stat;
#else
	  state = kp->kp_proc.p_stat;
#endif
	  switch(state) {
	  case SRUN:
	  case SIDL:
	    val32++;
	    break;
	  }
	}
      }
      kvm_close(kd);
    }
    
    if (val32 > 0) val32--; // subtract one for me
    return val32;
  }
Exemple #19
0
int
psutil_get_proc_list(struct kinfo_proc **procList, size_t *procCount) {
    // Returns a list of all BSD processes on the system.  This routine
    // allocates the list and puts it in *procList and a count of the
    // number of entries in *procCount.  You are responsible for freeing
    // this list (use "free" from System framework).
    // On success, the function returns 0.
    // On error, the function returns a BSD errno value.
    struct kinfo_proc *result;
    int done;
    static const int name[] = { CTL_KERN, KERN_PROC, KERN_PROC, 0 };
    // Declaring name as const requires us to cast it when passing it to
    // sysctl because the prototype doesn't include the const modifier.
    size_t              length;
    char errbuf[_POSIX2_LINE_MAX];
    struct kinfo_proc *x;
    int cnt;
    kvm_t *kd;

    assert( procList != NULL);
    assert(*procList == NULL);
    assert(procCount != NULL);

    kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf);

    if (kd == NULL) {
        return errno;
    }

    result = kvm_getprocs(kd, KERN_PROC_ALL, 0, sizeof(struct kinfo_proc), &cnt);
    if (result == NULL) {
        err(1, NULL);
        return errno;
    }

    *procCount = (size_t)cnt;

    size_t mlen = cnt * sizeof(struct kinfo_proc);

    if ((*procList = malloc(mlen)) == NULL) {
        err(1, NULL);
        return errno;
    }

    memcpy(*procList, result, mlen);
    assert(*procList != NULL);
    kvm_close(kd);

    return 0;
}
int ProcessInfo::getVirtualMemorySize() {
    kvm_t* kd = NULL;
    int cnt = 0;
    char err[_POSIX2_LINE_MAX] = {0};
    if ((kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, err)) == NULL) {
        log() << "Unable to get virt mem size: " << err << endl;
        return -1;
    }

    kinfo_proc* task = kvm_getprocs(kd, KERN_PROC_PID, _pid.toNative(), sizeof(kinfo_proc), &cnt);
    kvm_close(kd);
    return ((task->p_vm_dsize + task->p_vm_ssize + task->p_vm_tsize) * sysconf(_SC_PAGESIZE)) /
        1048576;
}
Exemple #21
0
int update_total_processes()
{
	int n_processes = 0;

	int max_size = sizeof(struct kinfo_proc);

	kvm_init();
	pthread_mutex_lock(&kvm_mutex);
	kvm_getprocs(kd, KERN_PROC_ALL, 0, max_size, &n_processes);
	pthread_mutex_unlock(&kvm_mutex);

	info.procs = n_processes;
	return 0;
}
void
guess_file_name(int fd, char *buf, int buflen) {
    kvm_t *kd;
    // This doesn't have to do anything with files, it just initializes kvm.
    kvm_chk_ptr(kd = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, kvm_errbuf));

    // Get kernel structure for current process.
    struct kinfo_proc *kp;
    int cnt;
    kp = kvm_getprocs(kd, KERN_PROC_PID, getpid(), &cnt);
    
    // Get file descriptor table of the process.
    struct filedesc filed;

#ifdef __FreeBSD__
    kvm_chk(kvm_read(kd, (unsigned long)kp->ki_fd, &filed, sizeof(filed))); 
#endif

#ifdef __DragonFly__
    kvm_chk(kvm_read(kd, (unsigned long)kp->kp_fd, &filed, sizeof(filed)));
#endif

    printf("Process has <= %d file descriptors\n", filed.fd_lastfile);


    // Get file structures.
    int nfiles = filed.fd_lastfile + 1;
    struct file **ofiles = malloc(nfiles * sizeof(struct file *));
    assert(ofiles != NULL);
#ifdef __FreeBSD__
    kvm_chk(kvm_read(kd, (unsigned long)filed.fd_ofiles, ofiles,
                     nfiles * sizeof(struct file *)));
#endif
#ifdef __DragonFly__
    kvm_chk(kvm_read(kd, (unsigned long)filed.fd_files, ofiles,
                     nfiles * sizeof(struct file *)));
#endif
    // Loop through the files.
    struct file file;
    ssize_t r;
    for (int i = 0; i <= filed.fd_lastfile; i++) {
        if (ofiles[i] == NULL) continue;
        errno = 0;
        kvm_chk((r = kvm_read(kd, (unsigned long)ofiles[i], &file, sizeof(struct file))));
        printf("Filed #%d: %zd bytes read\n", i, r);
    }

    kvm_chk(kvm_close(kd));
}
Exemple #23
0
pid_t *
glibtop_get_proclist_p (glibtop *server, glibtop_proclist *buf,
                        gint64 real_which, gint64 arg)
{
    struct kinfo_proc *pinfo;
    unsigned *pids = NULL;
    int which, count;
    int i,j;

    glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_PROCLIST), 0);

    memset (buf, 0, sizeof (glibtop_proclist));

    which = (int)(real_which & GLIBTOP_KERN_PROC_MASK);

    /* Get the process data */
    pinfo = kvm_getprocs (server->machine->kd, which, arg,
                          sizeof (*pinfo), &count);
    if ((pinfo == NULL) || (count < 1)) {
        glibtop_warn_io_r (server, "kvm_getprocs (proclist)");
        return NULL;
    }
    count--;

    /* Allocate count objects in the pids_chain array
     * Same as malloc is pids is NULL, which it is. */
    pids = g_realloc (pids, count * sizeof (unsigned));
    /* Copy the pids over to this chain */
    for (i=j=0; i < count; i++) {
#define PROC_STAT	p_stat
#define PROC_RUID	p_ruid
#define PROC_PID	p_pid

        if ((real_which & GLIBTOP_EXCLUDE_IDLE) &&
                (pinfo[i].PROC_STAT != SRUN))
            continue;
        else if ((real_which & GLIBTOP_EXCLUDE_SYSTEM) &&
                 (pinfo[i].PROC_RUID == 0))
            continue;
        pids [j++] = (unsigned) pinfo[i].PROC_PID;
    } /* end for */
    /* Set the fields in buf */
    buf->number = j;
    buf->size = sizeof (unsigned);
    buf->total = j * sizeof (unsigned);
    buf->flags = _glibtop_sysdeps_proclist;
    return pids;
}
Exemple #24
0
/**
 * Get number of current processes existing into the system
 */
static int
OS_getSystemProcesses(uint32_t *proc_count)
{
	int pc;

	if (hr_kd == NULL)
		return (SNMP_ERR_GENERR);

	if (kvm_getprocs(hr_kd, KERN_PROC_ALL, 0, &pc) == NULL) {
		syslog(LOG_ERR, "kvm_getprocs failed: %m");
		return (SNMP_ERR_GENERR);
	}

	*proc_count = pc;
	return (SNMP_ERR_NOERROR);
}
Exemple #25
0
void
glibtop_get_proc_signal_p (glibtop *server,
                           glibtop_proc_signal *buf,
                           pid_t pid)
{
    struct kinfo_proc *pinfo;
    int count = 0;

    glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_PROC_SIGNAL), 0);

    memset (buf, 0, sizeof (glibtop_proc_signal));

    /* It does not work for the swapper task. */
    if (pid == 0) return;

    /* Get the process information */
    pinfo = kvm_getprocs (server->machine->kd, KERN_PROC_PID, pid,
                          sizeof (*pinfo), &count);
    if (pinfo == NULL) {
        glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid);
        return;
    }

    /* signal: mask of pending signals.
     *         pinfo [0].kp_proc.p_siglist
     */
    buf->signal [0] = pinfo [0].p_siglist;

    /* blocked: mask of blocked signals.
     *          pinfo [0].kp_proc.p_sigmask
     */
    buf->blocked [0] = pinfo [0].p_sigmask;

    /* sigignore: mask of ignored signals.
     *            pinfo [0].kp_proc.p_sigignore
    */
    buf->sigignore [0] = pinfo [0].p_sigignore;

    /* sigcatch: mask of caught signals.
     *           pinfo [0].kp_proc.p_sigcatch
    */
    buf->sigcatch [0] = pinfo [0].p_sigcatch;

    buf->flags = _glibtop_sysdeps_proc_signal;
}
struct and_procent *openbsd_getfirst ()
{
    char errmsg [_POSIX2_LINE_MAX];
    if (!openbsd_kvm) {
        openbsd_kvm = kvm_openfiles(NULL,NULL,NULL,O_RDONLY,errmsg);
        if (!openbsd_kvm) {
            and_printf(0,"KVM: cannot open (\"%s\"). Aborting.\n",errmsg);
            abort();
        }
        openbsd_init();
    }
    openbsd_pt = kvm_getprocs(openbsd_kvm,KERN_PROC_ALL,0,&openbsd_nproc);
    if (!openbsd_pt) {
        and_printf(0,"KVM: cannot retrieve process table. Aborting.\n");
        abort();
    }
    openbsd_next = 0;
    return openbsd_getnext();
}
Exemple #27
0
FCITX_EXPORT_API
char* fcitx_utils_get_process_name()
{
#if defined(__linux__)
    const size_t bufsize = 4096;
    char buf[bufsize];
    char *result = NULL;
    ssize_t len;
    if ((len = readlink("/proc/self/exe", buf, bufsize)) != -1) {
        buf[len] = '\0';
        result = basename(buf);
    } else {
        buf[0] = '\0';
        result = buf;
    }

    return fcitx_utils_trim(result);
#elif defined(LIBKVM_FOUND)
    kvm_t *vm = kvm_open(0, "/dev/null", 0, O_RDONLY, NULL);
    if (vm == 0)
        return strdup("");

    int cnt;
    int mypid = getpid();
    struct kinfo_proc * kp = kvm_getprocs(vm, KERN_PROC_PID, mypid, &cnt);
    if ((cnt != 1) || (kp == 0))
        return strdup("");
    int i;
    for (i = 0; i < cnt; i++)
        if (kp->ki_pid == mypid)
            break;
    char* result = NULL;
    if (i != cnt)
        result = strdup(kp->ki_comm);
    else
        result = strdup("");
    kvm_close(vm);
    return result;
#else
    return strdup("");
#endif
}
int
machine_get_procs(LinkedList * procs)
{
	struct kinfo_proc *kprocs;
	int nproc, i;
	procinfo_type *p;

	if (kvmd == NULL)
		return (FALSE);

	kprocs = kvm_getprocs(kvmd, KERN_PROC_PROC, 0, &nproc);
	if (kprocs == NULL) {
		perror("kvm_getprocs");
		return (FALSE);
	}

	for (i = 0; i < nproc; i++) {
		p = malloc(sizeof(procinfo_type));
		if (!p) {
			perror("mem_top_malloc");
			return (FALSE);
		}
#if (__FreeBSD_version > 500000)
		strncpy(p->name, kprocs->ki_comm, 15);
#else
		strncpy(p->name, kprocs->kp_proc.p_comm, 15);
#endif
		p->name[15] = '\0';
#if (__FreeBSD_version > 500000)
		p->totl = kprocs->ki_size / 1024;
		p->number = kprocs->ki_pid;
#else
		p->totl = kprocs->kp_eproc.e_vm.vm_map.size / 1024;
		p->number = kprocs->kp_proc.p_pid;
#endif
		LL_Push(procs, (void *)p);

		kprocs++;
	}

	return (TRUE);
}
Exemple #29
0
int update_running_processes()
{
	struct kinfo_proc *p;
	int n_processes = 0;
	int i, cnt = 0;

	kvm_init();
	int max_size = sizeof(struct kinfo_proc);

	pthread_mutex_lock(&kvm_mutex);
	p = kvm_getprocs(kd, KERN_PROC_ALL, 0, max_size, &n_processes);
	pthread_mutex_unlock(&kvm_mutex);
	for (i = 0; i < n_processes; i++) {
		if (p[i].p_stat == SRUN) {
			cnt++;
		}
	}

	info.run_procs = cnt;
	return 0;
}
int main()
{
    int i, proc_count = 0;
    char *cuname;
    char buf[_POSIX2_LINE_MAX];
    const char *execf, *coref;
    static kvm_t *kd;
    struct kinfo_proc *kp;
    static int nproc;
    static struct kinfo_proc *plist;
    
    execf = NULL;
    coref = _PATH_DEVNULL;
    kd = kvm_openfiles(execf, coref, NULL, O_RDONLY, buf);
    plist = kvm_getprocs(kd, KERN_PROC_PROC, 0, &nproc);

    for (i = 0, kp = plist; i < nproc; i++, kp++) proc_count++;
    
    printf("\n");
    printf(" \033[0;0;0m         \033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m0\033[0;0;0m       \033[0;0;0m\033[38;5;16m00\033[0;0;0m       \n");
    printf("\033[38;5;52m1\033[0;0;0m\033[38;5;52m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;131m0\033[0;0;0m\033[38;5;95m0\033[0;0;0m\033[38;5;95m1\033[0;0;0m\033[38;5;52m1\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;59m0\033[0;0;0m\033[38;5;59m1\033[0;0;0m\033[38;5;59m1\033[0;0;0m\033[38;5;102m1\033[0;0;0m\033[38;5;145m1\033[0;0;0m\033[38;5;145m0\033[0;0;0m\033[38;5;145m1\033[0;0;0m\033[38;5;145m0\033[0;0;0m\033[38;5;145m00\033[0;0;0m\033[38;5;145m0\033[0;0;0m\033[38;5;145m0\033[0;0;0m\033[38;5;145m0\033[0;0;0m\033[38;5;102m1\033[0;0;0m\033[38;5;102m1\033[0;0;0m\033[38;5;59m1\033[0;0;0m\033[38;5;59m1\033[0;0;0m\033[38;5;59m1\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;52m0\033[0;0;0m\033[38;5;95m0\033[0;0;0m\033[38;5;95m0\033[0;0;0m\033[38;5;131m1\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;52m0\033[0;0;0m\033[38;5;16m1\033[0;0;0m"); printval("OS", "kern.ostype"); printf(" "); psysctl("hw.machine_arch"); printf("\n");
    printf("\033[38;5;88m1\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;167m1\033[0;0;0m\033[38;5;210m1\033[0;0;0m\033[38;5;217m0\033[0;0;0m\033[38;5;217m1\033[0;0;0m\033[38;5;181m1\033[0;0;0m\033[38;5;180m0\033[0;0;0m\033[38;5;145m0\033[0;0;0m\033[38;5;188m1\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;231m000\033[0;0;0m\033[38;5;231m00\033[0;0;0m\033[38;5;231m0\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;224m0\033[0;0;0m\033[38;5;181m0\033[0;0;0m\033[38;5;181m0\033[0;0;0m\033[38;5;181m1\033[0;0;0m\033[38;5;187m0\033[0;0;0m\033[38;5;144m0\033[0;0;0m\033[38;5;144m1\033[0;0;0m\033[38;5;187m0\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;224m0\033[0;0;0m\033[38;5;210m1\033[0;0;0m\033[38;5;167m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;16m1\033[0;0;0m"); printval("Hostname", "kern.hostname");  printf("\n");
    printf("\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;209m0\033[0;0;0m\033[38;5;224m0\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;231m0\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;231m11\033[0;0;0m\033[38;5;231m0\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;231m01\033[0;0;0m\033[38;5;231m0\033[0;0;0m\033[38;5;231m0\033[0;0;0m\033[38;5;230m1\033[0;0;0m\033[38;5;181m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;173m1\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;231m0\033[0;0;0m\033[38;5;224m0\033[0;0;0m\033[38;5;223m1\033[0;0;0m\033[38;5;210m1\033[0;0;0m\033[38;5;167m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;52m1\033[0;0;0m\033[38;5;16m1\033[0;0;0m"); printval("Kernel", "kern.osrelease");  printf("\n");
    printf("\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;52m0\033[0;0;0m\033[38;5;131m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;131m0\033[0;0;0m\033[38;5;224m0\033[0;0;0m\033[38;5;231m0\033[0;0;0m\033[38;5;231m0\033[0;0;0m\033[38;5;231m0\033[0;0;0m\033[38;5;231m0\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;231m0\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;230m0\033[0;0;0m\033[38;5;230m0\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;224m0\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;224m0\033[0;0;0m\033[38;5;224m11\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;181m0\033[0;0;0m\033[38;5;217m0\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;224m0\033[0;0;0m\033[38;5;217m0\033[0;0;0m\033[38;5;209m1\033[0;0;0m\033[38;5;166m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;131m1\033[0;0;0m\033[38;5;52m1\033[0;0;0m\033[38;5;16m0\033[0;0;0m "); printuptime(); printf("\n");
    printf("\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;59m1\033[0;0;0m\033[38;5;181m0\033[0;0;0m\033[38;5;231m0\033[0;0;0m\033[38;5;230m1\033[0;0;0m\033[38;5;224m0\033[0;0;0m\033[38;5;230m0\033[0;0;0m\033[38;5;231m1\033[0;0;0m\033[38;5;231m0\033[0;0;0m\033[38;5;231m0\033[0;0;0m\033[38;5;230m1\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;224m0\033[0;0;0m\033[38;5;224m0\033[0;0;0m\033[38;5;223m1\033[0;0;0m\033[38;5;223m1\033[0;0;0m\033[38;5;223m0\033[0;0;0m\033[38;5;223m1\033[0;0;0m\033[38;5;217m1\033[0;0;0m\033[38;5;217m1\033[0;0;0m\033[38;5;217m0\033[0;0;0m\033[38;5;217m0\033[0;0;0m\033[38;5;181m1\033[0;0;0m\033[38;5;181m1\033[0;0;0m\033[38;5;181m1\033[0;0;0m\033[38;5;181m0\033[0;0;0m\033[38;5;181m0\033[0;0;0m\033[38;5;173m1\033[0;0;0m\033[38;5;167m0\033[0;0;0m\033[38;5;203m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;131m1\033[0;0;0m\033[38;5;174m0\033[0;0;0m\033[38;5;95m0\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m1\033[0;0;0m"); printf("\033[1;31mProcesses:\033[0;0m %d\n", proc_count);
    printf("\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;181m1\033[0;0;0m\033[38;5;224m0\033[0;0;0m\033[38;5;223m1\033[0;0;0m\033[38;5;223m0\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;230m0\033[0;0;0m\033[38;5;231m0\033[0;0;0m\033[38;5;230m0\033[0;0;0m\033[38;5;224m0\033[0;0;0m\033[38;5;223m0\033[0;0;0m\033[38;5;217m1\033[0;0;0m\033[38;5;216m0\033[0;0;0m\033[38;5;209m0\033[0;0;0m\033[38;5;203m0\033[0;0;0m\033[38;5;203m0\033[0;0;0m\033[38;5;202m1\033[0;0;0m\033[38;5;202m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;131m1\033[0;0;0m\033[38;5;131m0\033[0;0;0m\033[38;5;131m0\033[0;0;0m\033[38;5;131m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;131m0\033[0;0;0m\033[38;5;131m0\033[0;0;0m\033[38;5;138m1\033[0;0;0m\033[38;5;188m1\033[0;0;0m\033[38;5;59m1\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;16m1\033[0;0;0m"); printmem(); printf("\n");
    printf("\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;145m0\033[0;0;0m\033[38;5;181m0\033[0;0;0m\033[38;5;216m1\033[0;0;0m\033[38;5;216m1\033[0;0;0m\033[38;5;223m0\033[0;0;0m\033[38;5;230m1\033[0;0;0m\033[38;5;231m0\033[0;0;0m\033[38;5;224m0\033[0;0;0m\033[38;5;216m0\033[0;0;0m\033[38;5;209m1\033[0;0;0m\033[38;5;202m0\033[0;0;0m\033[38;5;202m0\033[0;0;0m\033[38;5;196m0\033[0;0;0m\033[38;5;196m1\033[0;0;0m\033[38;5;196m1\033[0;0;0m\033[38;5;196m0\033[0;0;0m\033[38;5;196m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;95m0\033[0;0;0m\033[38;5;59m0\033[0;0;0m\033[38;5;95m1\033[0;0;0m\033[38;5;95m1\033[0;0;0m\033[38;5;138m0\033[0;0;0m\033[38;5;188m1\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m1\033[0;0;0m"); printcpu();  printf("\n");
    printf("\033[0;0;0m\033[38;5;59m1\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;174m0\033[0;0;0m\033[38;5;166m1\033[0;0;0m\033[38;5;209m0\033[0;0;0m\033[38;5;215m1\033[0;0;0m\033[38;5;216m1\033[0;0;0m\033[38;5;216m1\033[0;0;0m\033[38;5;209m0\033[0;0;0m\033[38;5;202m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m11\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;52m0\033[0;0;0m\033[38;5;52m1\033[0;0;0m\033[38;5;52m0\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;130m0\033[0;0;0m\033[38;5;188m0\033[0;0;0m\033[38;5;102m1\033[0;0;0m "); printf("\033[1;31mShell:\033[0;0m ", proc_count); printshell(); printf("\n");
    printf("\033[0;0;0m\033[38;5;59m0\033[0;0;0m\033[38;5;188m1\033[0;0;0m\033[38;5;131m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;166m0\033[0;0;0m\033[38;5;166m0\033[0;0;0m\033[38;5;166m0\033[0;0;0m\033[38;5;166m1\033[0;0;0m\033[38;5;202m0\033[0;0;0m\033[38;5;202m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m111\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;52m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;130m1\033[0;0;0m\033[38;5;230m1\033[0;0;0m\033[38;5;138m1\033[0;0;0m\033[38;5;16m1\033[0;0;0m       \n");
    printf("\033[0;0;0m\033[38;5;59m1\033[0;0;0m\033[38;5;224m1\033[0;0;0m\033[38;5;131m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m1001\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;52m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;216m1\033[0;0;0m\033[38;5;230m1\033[0;0;0m\033[38;5;102m1\033[0;0;0m       \n");
    printf("\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;145m0\033[0;0;0m\033[38;5;181m0\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m00\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;173m0\033[0;0;0m\033[38;5;222m1\033[0;0;0m\033[38;5;229m1\033[0;0;0m\033[38;5;188m1\033[0;0;0m\033[38;5;16m0\033[0;0;0m        \n");
    printf(" \033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;145m1\033[0;0;0m\033[38;5;174m0\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;167m1\033[0;0;0m\033[38;5;215m1\033[0;0;0m\033[38;5;223m1\033[0;0;0m\033[38;5;188m0\033[0;0;0m\033[38;5;59m1\033[0;0;0m         \n");
    printf("  \033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;102m0\033[0;0;0m\033[38;5;181m0\033[0;0;0m\033[38;5;88m0\033[0;0;0m\033[38;5;88m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;166m1\033[0;0;0m\033[38;5;166m1\033[0;0;0m\033[38;5;166m0\033[0;0;0m\033[38;5;166m1\033[0;0;0m\033[38;5;173m0\033[0;0;0m\033[38;5;217m0\033[0;0;0m\033[38;5;145m1\033[0;0;0m\033[38;5;59m0\033[0;0;0m\033[38;5;16m1\033[0;0;0m           \n");
    printf("   \033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;59m0\033[0;0;0m\033[38;5;145m0\033[0;0;0m\033[38;5;131m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;124m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;166m1\033[0;0;0m\033[38;5;166m0\033[0;0;0m\033[38;5;166m1\033[0;0;0m\033[38;5;166m0\033[0;0;0m\033[38;5;166m1\033[0;0;0m\033[38;5;166m1\033[0;0;0m\033[38;5;166m1\033[0;0;0m\033[38;5;202m1\033[0;0;0m\033[38;5;202m1\033[0;0;0m\033[38;5;166m1\033[0;0;0m\033[38;5;166m0\033[0;0;0m\033[38;5;209m1\033[0;0;0m\033[38;5;216m1\033[0;0;0m\033[38;5;180m1\033[0;0;0m\033[38;5;59m1\033[0;0;0m\033[38;5;16m1\033[0;0;0m              \n");
    printf("     \033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;59m0\033[0;0;0m\033[38;5;95m1\033[0;0;0m\033[38;5;131m1\033[0;0;0m\033[38;5;131m0\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;124m1\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;166m0\033[0;0;0m\033[38;5;166m0\033[0;0;0m\033[38;5;166m0\033[0;0;0m\033[38;5;202m1\033[0;0;0m\033[38;5;202m0\033[0;0;0m\033[38;5;202m1\033[0;0;0m\033[38;5;208m0\033[0;0;0m\033[38;5;209m1\033[0;0;0m\033[38;5;180m1\033[0;0;0m\033[38;5;137m1\033[0;0;0m\033[38;5;59m0\033[0;0;0m\033[38;5;16m1\033[0;0;0m\n");
    printf("       \033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;16m1\033[0;0;0m\033[38;5;59m0\033[0;0;0m\033[38;5;95m0\033[0;0;0m\033[38;5;131m0\033[0;0;0m\033[38;5;131m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m1\033[0;0;0m\033[38;5;160m0\033[0;0;0m\033[38;5;166m1\033[0;0;0m\033[38;5;166m1\033[0;0;0m\033[38;5;166m0\033[0;0;0m\033[38;5;202m0\033[0;0;0m\033[38;5;172m1\033[0;0;0m\033[38;5;172m0\033[0;0;0m\033[38;5;173m1\033[0;0;0m\033[38;5;137m0\033[0;0;0m\033[38;5;95m0\033[0;0;0m\033[38;5;58m0\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m0\033[0;0;0m\n");
    printf("            \033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;52m0\033[0;0;0m\033[38;5;52m0\033[0;0;0m\033[38;5;52m1\033[0;0;0m\033[38;5;52m0\033[0;0;0m\033[38;5;52m1\033[0;0;0m\033[38;5;58m1\033[0;0;0m\033[38;5;58m0\033[0;0;0m\033[38;5;58m0\033[0;0;0m\033[38;5;58m0\033[0;0;0m\033[38;5;58m0\033[0;0;0m\033[38;5;58m0\033[0;0;0m\033[38;5;52m0\033[0;0;0m\033[38;5;16m0\033[0;0;0m\033[38;5;16m0\033[0;0;0m\n");
    printf("\n");
    return (0);
}