There are no available options for this view.
Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.2 by mwdavies, Sat Dec 22 18:50:53 2007 UTC revision 1.3 by mwdavies, Sun Dec 30 00:02:41 2007 UTC
# Line 1  Line 1 
1  $NetBSD$  $NetBSD$
2    
3  --- libs/ksysguard/processcore/processes_netbsd_p.cpp.orig      2007-12-20 22:02:51.000000000 +0000  --- libs/ksysguard/processcore/processes_netbsd_p.cpp.orig      2007-12-28 01:16:59.000000000 +1300
4  +++ libs/ksysguard/processcore/processes_netbsd_p.cpp  +++ libs/ksysguard/processcore/processes_netbsd_p.cpp
5  @@ -0,0 +1,323 @@  @@ -0,0 +1,291 @@
6  +/*  This file is part of the KDE project  +/*  This file is part of the KDE project
7  +    Copyright (C) 2007 Manolo Valdes <nolis71cu@gmail.com>  +    Copyright (C) 2007 Manolo Valdes <nolis71cu@gmail.com>
8    +    Copyright (C) 2007 Mark Davies <mark@mcs.vuw.ac.nz>
9  +  +
10  +    This library is free software; you can redistribute it and/or  +    This library is free software; you can redistribute it and/or
11  +    modify it under the terms of the GNU Library General Public  +    modify it under the terms of the GNU Library General Public
12  +    License version 2 as published by the Free Software Foundation.  +    License as published by the Free Software Foundation; either
13    +    version 2 of the License, or (at your option) any later version.
14  +  +
15  +    This library is distributed in the hope that it will be useful,  +    This library is distributed in the hope that it will be useful,
16  +    but WITHOUT ANY WARRANTY; without even the implied warranty of  +    but WITHOUT ANY WARRANTY; without even the implied warranty of
# Line 28  Line 30 
30  +  +
31  +#include <QSet>  +#include <QSet>
32  +  +
33    +#include <kvm.h>
34  +#include <sys/param.h>  +#include <sys/param.h>
35  +#include <sys/sysctl.h>  +#include <sys/sysctl.h>
36  +#include <sys/types.h>  +#include <sys/types.h>
37  +#include <sys/user.h>  +#include <sys/user.h>
38  +#include <sys/resource.h>  +#include <sys/stat.h>
 +#if defined(__DragonFly__)  
 +#include <sys/resourcevar.h>  
 +#include <err.h>  
 +#endif  
39  +#include <signal.h>  +#include <signal.h>
40  +#include <unistd.h>  +#include <unistd.h>
41  +#include <stdlib.h>  +#include <stdlib.h>
# Line 50  Line 49 
49  +  class ProcessesLocal::Private  +  class ProcessesLocal::Private
50  +  {  +  {
51  +    public:  +    public:
52  +      Private() {;}  +      Private() { kd = kvm_open(NULL, NULL, NULL, KVM_NO_FILES, "kvm_open");}
53  +      ~Private() {;}  +      ~Private() { kvm_close(kd);}
54  +      inline bool readProc(long pid, struct kinfo_proc *p);  +      inline bool readProc(long pid, struct kinfo_proc2 **p, int *num);
55  +      inline void readProcStatus(struct kinfo_proc *p, Process *process);  +      inline void readProcStatus(struct kinfo_proc2 *p, Process *process);
56  +      inline void readProcStat(struct kinfo_proc *p, Process *process);  +      inline void readProcStat(struct kinfo_proc2 *p, Process *process);
57  +      inline void readProcStatm(struct kinfo_proc *p, Process *process);  +      inline void readProcStatm(struct kinfo_proc2 *p, Process *process);
58  +      inline bool readProcCmdline(long pid, Process *process);  +      inline bool readProcCmdline(struct kinfo_proc2 *p, Process *process);
59    +
60    +      kvm_t *kd;
61  +    };  +    };
62  +  +
63  +#ifndef _SC_NPROCESSORS_ONLN  +#ifndef _SC_NPROCESSORS_ONLN
# Line 76  Line 77 
77  +}  +}
78  +#endif  +#endif
79  +  +
80  +bool ProcessesLocal::Private::readProc(long pid, struct kinfo_proc *p)  +bool ProcessesLocal::Private::readProc(long pid, struct kinfo_proc2 **p, int *num)
81  +{  +{
82  +    int mib[4];  +    int len;
83  +    size_t len;  +    int op, arg;
84  +  +
85  +    mib[0] = CTL_KERN;  +    if (pid == 0) {
86  +    mib[1] = KERN_PROC;  +        op = KERN_PROC_ALL;
87  +    mib[2] = KERN_PROC_PID;  +        arg = 0;
88  +    mib[3] = pid;  +    } else {
89    +        op = KERN_PROC_PID;
90    +        arg = pid;
91    +    }
92    +    *p = kvm_getproc2(kd, op, arg, sizeof(struct kinfo_proc2), &len);
93  +  +
94  +    len = sizeof (struct kinfo_proc);  +    if (len < 1)
 +    if (sysctl(mib, 4, p, &len, NULL, 0) == -1 || !len)  
95  +        return false;  +        return false;
96    +
97    +    if (num != NULL)
98    +        *num = len;
99  +    return true;  +    return true;
100  +}  +}
101  +  +
102  +void ProcessesLocal::Private::readProcStatus(struct kinfo_proc *p, Process *process)  +void ProcessesLocal::Private::readProcStatus(struct kinfo_proc2 *p, Process *process)
103  +{  +{
104  +    process->uid = 0;  +    process->setUid(p->p_ruid);
105  +    process->gid = 0;  +    process->setEuid(p->p_uid);
106  +    process->tracerpid = 0;  +    process->setGid(p->p_rgid);
107  +  +    process->setEgid(p->p_gid);
108  +  +    process->setTracerpid(0);
109  +#if defined(__FreeBSD__) && __FreeBSD_version >= 500015  +
110  +    process->uid  = p->ki_uid;  +    process->setName(QString(p->p_comm ? p->p_comm : "????"));
 +    process->gid  = p->ki_pgid;  
 +    process->name = QString(p->ki_comm ? p->ki_comm : "????");  
 +#elif defined(__DragonFly__) && __DragonFly_version >= 190000  
 +    process->uid  = p->kp_uid;  
 +    process->gid  = p->kp_pgid;  
 +    process->name = QString(p->kp_comm ? p->kp_comm : "????");  
 +#else  
 +    process->uid  = p->kp_eproc.e_ucred.cr_uid;  
 +    process->gid  = p->kp_eproc.e_pgid;  
 +#endif  
111  +}  +}
112  +  +
113  +void ProcessesLocal::Private::readProcStat(struct kinfo_proc *p, Process *ps)  +void ProcessesLocal::Private::readProcStat(struct kinfo_proc2 *p, Process *ps)
114  +{  +{
115  +    int status;  +    const char *ttname;
116  +    struct rusage pru;  +    dev_t dev;
117  +#if defined(__FreeBSD__) && __FreeBSD_version >= 500015  +
118  +        ps->userTime  = p->ki_runtime / 10000;  +    ps->setUserTime(p->p_uutime_sec*100+p->p_uutime_usec/10000);
119  +        ps->niceLevel = p->ki_nice;  +    ps->setSysTime(p->p_ustime_sec*100+p->p_ustime_usec/10000);
120  +        ps->vmSize    = p->ki_size;  +    ps->setUserUsage(100.0 * ((double)(p->p_pctcpu) / FSCALE));
121  +        ps->vmRSS     = p->ki_rssize * getpagesize();  +    ps->setSysUsage(0);
122  +        status = p->ki_stat;  +
123  +#elif defined(__DragonFly__) && __DragonFly_version >= 190000  +    ps->setNiceLevel(p->p_nice - NZERO);
124  +        if (!getrusage(p->kp_pid, &pru)) {  +    ps->setVmSize((p->p_vm_tsize + p->p_vm_dsize + p->p_vm_ssize)
125  +            errx(1, "failed to get rusage info");  +                  * getpagesize());
126  +        }  +    ps->setVmRSS(p->p_vm_rssize * getpagesize());
 +        ps->userTime  = pru.ru_utime.tv_usec / 1000; /*p_runtime / 1000*/  
 +        ps->niceLevel = p->kp_nice;  
 +        ps->vmSize    = p->kp_vm_map_size;  
 +        ps->vmRSS     = p->kp_vm_rssize * getpagesize();  
 +        status = p->kp_stat;  
 +#else  
 +        ps->userTime  = p->kp_proc.p_rtime.tv_sec*100+p->kp_proc.p_rtime.tv_usec/100;  
 +        ps->niceLevel = p->kp_proc.p_nice;  
 +        ps->vmSize    = p->kp_eproc.e_vm.vm_map.size;  
 +        ps->vmRSS     = p->kp_eproc.e_vm.vm_rssize * getpagesize();  
 +        status = p->kp_proc.p_stat;  
 +#endif  
 +        ps->sysTime   = 0;  
127  +  +
128  +// "idle","run","sleep","stop","zombie"  +// "idle","run","sleep","stop","zombie"
129  +    switch( status ) {  +    switch( p->p_stat ) {
130  +      case '0':  +      case LSRUN:
131  +        ps->status = Process::DiskSleep;  +        ps->setStatus(Process::Running);
132  +       break;  +       break;
133  +      case '1':  +      case LSSLEEP:
134  +        ps->status = Process::Running;  +        ps->setStatus(Process::Sleeping);
135  +       break;  +       break;
136  +      case '2':  +      case LSSTOP:
137  +        ps->status = Process::Sleeping;  +        ps->setStatus(Process::Stopped);
138  +       break;  +       break;
139  +      case '3':  +      case LSZOMB:
140  +        ps->status = Process::Stopped;  +       ps->setStatus(Process::Zombie);
141  +       break;  +       break;
142  +      case '4':  +      case LSONPROC:
143  +         ps->status = Process::Zombie;  +        ps->setStatus(Process::Running);
144  +         break;  +         break;
145  +      default:  +      default:
146  +         ps->status = Process::OtherStatus;  +       ps->setStatus(Process::OtherStatus);
147  +         break;  +         break;
148  +    }  +    }
149    +
150    +    dev = p->p_tdev;
151    +    if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL) {
152    +        ps->setTty(QByteArray());
153    +    } else {
154    +        ps->setTty(QByteArray(ttname));
155    +    }
156  +}  +}
157  +  +
158  +void ProcessesLocal::Private::readProcStatm(struct kinfo_proc *p, Process *process)  +void ProcessesLocal::Private::readProcStatm(struct kinfo_proc2 *p, Process *process)
159  +{  +{
160  +// TODO  +// TODO
161  +  +
162  +//     unsigned long shared;  +//     unsigned long shared;
163  +//     process->vmURSS = process->vmRSS - (shared * sysconf(_SC_PAGESIZE) / 1024);  +//     process->vmURSS = process->vmRSS - (shared * sysconf(_SC_PAGESIZE) / 1024);
164    +  process->setVmURSS(-1);
165  +}  +}
166  +  +
167  +bool ProcessesLocal::Private::readProcCmdline(long pid, Process *process)  +bool ProcessesLocal::Private::readProcCmdline(struct kinfo_proc2 *p, Process *process)
168  +{  +{
169  +    int mib[4];  +    char **argv;
 +    struct kinfo_proc p;  
 +    size_t buflen = 256;  
 +    char buf[256];  
 +  
 +    mib[0] = CTL_KERN;  
 +    mib[1] = KERN_PROC;  
 +    mib[2] = KERN_PROC_ARGS;  
 +    mib[3] = pid;  
170  +  +
171  +    if (sysctl(mib, 4, buf, &buflen, NULL, 0) == -1 || !buflen)  +    if ((argv = kvm_getargv2(kd, p, 256)) == NULL)
172  +        return false;  +        return false;
 +    process->command = QString(buf);  
173  +  +
174  +    //cmdline seperates parameters with the NULL character  +    QString command = QString("");
175  +    process->command.replace('\0', ' ');  +
176  +    process->command = process->command.trimmed();  +    while (*argv) {
177    +        command += *argv;
178    +       command += " ";
179    +       argv++;
180    +    }
181    +    process->setCommand(command.trimmed());
182  +  +
183  +    return true;  +    return true;
184  +}  +}
# Line 202  Line 190 
190  +  +
191  +long ProcessesLocal::getParentPid(long pid) {  +long ProcessesLocal::getParentPid(long pid) {
192  +    long long ppid = 0;  +    long long ppid = 0;
193  +    struct kinfo_proc p;  +    struct kinfo_proc2 *p;
194  +    if(d->readProc(pid, &p))  +    if(d->readProc(pid, &p, 0))
195  +    {  +    {
196  +#if defined(__FreeBSD__) && __FreeBSD_version >= 500015  +        ppid = p->p_ppid;
 +        ppid = p.ki_ppid;  
 +#elif defined(__DragonFly__) && __DragonFly_version >= 190000  
 +        ppid = p.kp_ppid;  
 +#else  
 +        ppid = p.kp_eproc.e_ppid;  
 +#endif  
197  +    }  +    }
198  +    return ppid;  +    return ppid;
199  +}  +}
200  +  +
201  +bool ProcessesLocal::updateProcessInfo( long pid, Process *process)  +bool ProcessesLocal::updateProcessInfo( long pid, Process *process)
202  +{  +{
203  +    struct kinfo_proc p;  +    struct kinfo_proc2 *p;
204  +    if(!d->readProc(pid, &p)) return false;  +    if(!d->readProc(pid, &p, NULL)) return false;
205  +    d->readProcStat(&p, process);  +    d->readProcStat(p, process);
206  +    d->readProcStatus(&p, process);  +    d->readProcStatus(p, process);
207  +    d->readProcStatm(&p, process);  +    d->readProcStatm(p, process);
208  +    if(!d->readProcCmdline(pid, process)) return false;  +    if(!d->readProcCmdline(p, process)) return false;
209  +  +
210  +    return true;  +    return true;
211  +}  +}
# Line 231  Line 213 
213  +QSet<long> ProcessesLocal::getAllPids( )  +QSet<long> ProcessesLocal::getAllPids( )
214  +{  +{
215  +    QSet<long> pids;  +    QSet<long> pids;
216  +    int mib[3];  +    int len;
217  +    size_t len;  +    int num;
218  +    size_t num;  +    struct kinfo_proc2 *p;
219  +    struct kinfo_proc *p;  +
220    +    d->readProc(0, &p, &len);
221    +
222    +    for (num = 0; num < len; num++)
223    +    {
224    +        long pid = p[num].p_pid;
225    +        long long ppid = p[num].p_ppid;
226  +  +
 +    mib[0] = CTL_KERN;  
 +    mib[1] = KERN_PROC;  
 +    mib[2] = KERN_PROC_ALL;  
 +    sysctl(mib, 3, NULL, &len, NULL, 0);  
 +    p = (kinfo_proc *) malloc(len);  
 +    sysctl(mib, 3, p, &len, NULL, 0);  
 +  
 +    for (num = 0; num < len / sizeof(struct kinfo_proc); num++)  
 +    {  
 +#if defined(__FreeBSD__) && __FreeBSD_version >= 500015  
 +        long pid = p[num].ki_pid;  
 +        long long ppid = p[num].ki_ppid;  
 +#elif defined(__DragonFly__) && __DragonFly_version >= 190000  
 +        long pid = p[num].kp_pid;  
 +        long long ppid = p[num].kp_ppid;  
 +#else  
 +        long pid = p[num].kp_proc.p_pid;  
 +        long long ppid = p[num].kp_eproc.e_ppid;  
 +#endif  
227  +        //skip all process with parent id = 0 but init  +        //skip all process with parent id = 0 but init
228  +        if(ppid == 0 && pid != 1)  +        if(ppid == 0 && pid != 1)
229  +            continue;  +            continue;
230  +        pids.insert(pid);  +        pids.insert(pid);
231  +    }  +    }
 +    free(p);  
232  +    return pids;  +    return pids;
233  +}  +}
234  +  +
Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3

SourceForge Help
ViewVC Help
Powered by ViewVC 1.1.6

Copyright © 2010 Geeknet, Inc. All rights reserved. Terms of Use