kpriv/pkgsrc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Fix build on DragonFly. PR#44350 fix from kde bug id 247614

Browse source
This commit is contained in:
markd 2011-01-10 11:55:18 +00:00
parent 3745fc9f13
commit 9704e835c5
4 changed files with 394 additions and 1 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
x11/kdebase-workspace4/distinfo
View file

@ -1,4 +1,4 @@
$NetBSD: distinfo,v 1.13 2010/12/06 11:43:42 markd Exp $
$NetBSD: distinfo,v 1.14 2011/01/10 11:55:18 markd Exp $
SHA1 (Daemon.README) = eb1e6af52adc02ded77af17e8953134b7e60d23b
RMD160 (Daemon.README) = 39edd92ed4314397080f32a8caff0ac3f716ecf4
@ -25,3 +25,6 @@ SHA1 (patch-be) = e58dc4a0a7be7350251f26de34a8949e7508c983
SHA1 (patch-bo) = e682d488c61ca2540ed4b2112c9bffc45bbe5e8d
SHA1 (patch-ca) = 61b886388aa5d0831581eacb7db79de0ae5eaf80
SHA1 (patch-cb) = 8bfcc8b7e91eafd6b444f4103d3860fb6434a535
SHA1 (patch-cc) = f0c92eb5edc2690008d028652820cad77bf50b07
SHA1 (patch-cd) = c9e7b32b39b8191f5f54a799bdfa7009136429f9
SHA1 (patch-ce) = b02c04dae0005bec33a13ecf09254d35a0e4cd0b

16
x11/kdebase-workspace4/patches/patch-cc Normal file
View file

@ -0,0 +1,16 @@
$NetBSD: patch-cc,v 1.1 2011/01/10 11:55:18 markd Exp $
--- libs/ksysguard/processcore/processes_local_p.cpp.orig 2009-12-14 10:43:38.000000000 +0000
+++ libs/ksysguard/processcore/processes_local_p.cpp
@@ -21,8 +21,10 @@
#if defined __linux__
#include "processes_linux_p.cpp"
-#elif defined __FreeBSD__ || defined __FreeBSD_kernel__ || defined __DragonFly__
+#elif defined __FreeBSD__ || defined __FreeBSD_kernel__
#include "processes_freebsd_p.cpp"
+#elif defined __DragonFly__
+#include "processes_dragonfly_p.cpp"
#elif defined __OpenBSD__
#include "processes_openbsd_p.cpp"
#elif defined __NetBSD__

102
x11/kdebase-workspace4/patches/patch-cd Normal file
View file

@ -0,0 +1,102 @@
$NetBSD: patch-cd,v 1.1 2011/01/10 11:55:18 markd Exp $
--- libs/ksysguard/processcore/processes_freebsd_p.cpp.orig 2010-02-20 11:31:44.000000000 +0000
+++ libs/ksysguard/processcore/processes_freebsd_p.cpp
@@ -29,10 +29,6 @@
#include <sys/types.h>
#include <sys/user.h>
#include <sys/resource.h>
-#if defined(__DragonFly__)
-#include <sys/resourcevar.h>
-#include <err.h>
-#endif
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
@@ -77,53 +73,25 @@ void ProcessesLocal::Private::readProcSt
process->setGid(0);
process->setTracerpid(0);
-
-#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
process->setEuid(p->ki_uid);
process->setUid(p->ki_ruid);
process->setEgid(p->ki_svgid);
process->setGid(p->ki_rgid);
process->setName(QString(p->ki_comm ? p->ki_comm : "????"));
-#elif defined(__DragonFly__) && __DragonFly_version >= 190000
- process->setUid(p->kp_uid);
- process->setGid(p->kp_pgid);
- process->setName(QString(p->kp_comm ? p->kp_comm : "????"));
-#else
- process->setUid(p->kp_eproc.e_ucred.cr_uid);
- process->setGid(p->kp_eproc.e_pgid);
-#endif
}
void ProcessesLocal::Private::readProcStat(struct kinfo_proc *p, Process *ps)
{
int status;
struct rusage pru;
-#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+
ps->setUserTime(p->ki_rusage.ru_utime.tv_sec * 100 + p->ki_rusage.ru_utime.tv_usec / 10000);
ps->setSysTime(p->ki_rusage.ru_stime.tv_sec * 100 + p->ki_rusage.ru_stime.tv_usec / 10000);
ps->setNiceLevel(p->ki_nice);
ps->setVmSize(p->ki_size / 1024);
ps->setVmRSS(p->ki_rssize * getpagesize() / 1024);
status = p->ki_stat;
-#elif defined(__DragonFly__)
-#if __DragonFly_version >= 190000
- if (!getrusage(p->kp_pid, &pru)) {
- errx(1, "failed to get rusage info");
- }
- ps->setUserTime(pru.ru_utime.tv_usec / 1000); /*p_runtime / 1000*/
- ps->setNiceLevel(p->kp_nice);
- ps->setVmSize(p->kp_vm_map_size);
- ps->setVmRSS(p->kp_vm_rssize * getpagesize());
- status = p->kp_stat;
-#else
- ps->setUserTime(p->kp_proc.p_rtime.tv_sec*100+p->kp_proc.p_rtime.tv_usec/100);
- ps->setNiceLevel(p->kp_proc.p_nice);
- ps->setVmSize(p->kp_eproc.e_vm.vm_map.size);
- ps->setVmRSS(p->kp_eproc.e_vm.vm_rssize * getpagesize());
- status = p->kp_proc.p_stat;
-#endif
ps->setSysTime(0);
-#endif
// "idle","run","sleep","stop","zombie"
switch( status ) {
@@ -185,13 +153,7 @@ long ProcessesLocal::getParentPid(long p
struct kinfo_proc p;
if(d->readProc(pid, &p))
{
-#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
ppid = p.ki_ppid;
-#elif defined(__DragonFly__) && __DragonFly_version >= 190000
- ppid = p.kp_ppid;
-#else
- ppid = p.kp_eproc.e_ppid;
-#endif
}
return ppid;
}
@@ -230,16 +192,9 @@ QSet<long> ProcessesLocal::getAllPids( )
for (num = 0; num < len / sizeof(struct kinfo_proc); num++)
{
-#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
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
+
//skip all process with parent id = 0 but init
if(ppid == 0 && pid != 1)
continue;

272
x11/kdebase-workspace4/patches/patch-ce Normal file
View file

@ -0,0 +1,272 @@
$NetBSD: patch-ce,v 1.1 2011/01/10 11:55:18 markd Exp $
--- libs/ksysguard/processcore/processes_dragonfly_p.cpp.orig 2011-01-10 11:40:21.000000000 +0000
+++ libs/ksysguard/processcore/processes_dragonfly_p.cpp
@@ -0,0 +1,267 @@
+/* This file is part of the KDE project
+ Copyright (C) 2007 Manolo Valdes <nolis71cu@gmail.com>
+ Copyright (C) 2010 Alex Hornung <ahornung@gmail.com>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include "processes_local_p.h"
+#include "process.h"
+
+#include <klocale.h>
+
+#include <QSet>
+
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#include <sys/types.h>
+#include <sys/user.h>
+#include <sys/resource.h>
+#include <sys/resourcevar.h>
+#include <err.h>
+#include <signal.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sched.h>
+
+#define PP(pp, field) ((pp)->kp_ ## field)
+#define LP(pp, field) ((pp)->kp_lwp.kl_ ## field)
+#define VP(pp, field) ((pp)->kp_vm_ ## field)
+
+namespace KSysGuard
+{
+
+ class ProcessesLocal::Private
+ {
+ public:
+ Private() {;}
+ ~Private() {;}
+ inline bool readProc(long pid, struct kinfo_proc *p);
+ inline void readProcStatus(struct kinfo_proc *p, Process *process);
+ inline void readProcStat(struct kinfo_proc *p, Process *process);
+ inline void readProcStatm(struct kinfo_proc *p, Process *process);
+ inline bool readProcCmdline(long pid, Process *process);
+ };
+
+bool ProcessesLocal::Private::readProc(long pid, struct kinfo_proc *p)
+{
+ int mib[4];
+ size_t len;
+
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_PROC;
+ mib[2] = KERN_PROC_PID;
+ mib[3] = pid;
+
+ len = sizeof (struct kinfo_proc);
+ if (sysctl(mib, 4, p, &len, NULL, 0) == -1 || !len)
+ return false;
+ return true;
+}
+
+void ProcessesLocal::Private::readProcStatus(struct kinfo_proc *p, Process *process)
+{
+ process->setUid(0);
+ process->setGid(0);
+ process->setTracerpid(0);
+
+ process->setEuid(PP(p, uid));
+ process->setUid(PP(p, ruid));
+ process->setEgid(PP(p, svgid));
+ process->setGid(PP(p, rgid));
+ process->setName(QString(PP(p, comm)));
+}
+
+void ProcessesLocal::Private::readProcStat(struct kinfo_proc *p, Process *ps)
+{
+ ps->setUserTime(LP(p, uticks) / 10000);
+ ps->setSysTime((LP(p, sticks) + LP(p, iticks)) / 10000);
+ ps->setNiceLevel(PP(p, nice));
+ ps->setVmSize(VP(p, map_size) / 1024); /* convert to KiB */
+ ps->setVmRSS(VP(p, prssize) * getpagesize() / 1024); /* convert to KiB */
+
+// "idle","run","sleep","stop","zombie"
+ switch( LP(p, stat) ) {
+ case LSRUN:
+ ps->setStatus(Process::Running);
+ break;
+ case LSSLEEP:
+ ps->setStatus(Process::Sleeping);
+ break;
+ case LSSTOP:
+ ps->setStatus(Process::Stopped);
+ break;
+ default:
+ ps->setStatus(Process::OtherStatus);
+ break;
+ }
+ if (PP(p, stat) == SZOMB)
+ ps->setStatus(Process::Zombie);
+}
+
+void ProcessesLocal::Private::readProcStatm(struct kinfo_proc *p, Process *process)
+{
+ process->setVmURSS(-1);
+}
+
+bool ProcessesLocal::Private::readProcCmdline(long pid, Process *process)
+{
+ int mib[4];
+ size_t buflen = 256;
+ char buf[256];
+
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_PROC;
+ mib[2] = KERN_PROC_ARGS;
+ mib[3] = pid;
+
+ if (sysctl(mib, 4, buf, &buflen, NULL, 0) == -1 || (buflen == 0))
+ return false;
+ QString command = QString(buf);
+
+ //cmdline seperates parameters with the NULL character
+ command = command.replace('\0', ' ');
+ process->setCommand(command.trimmed());
+
+ return true;
+}
+
+ProcessesLocal::ProcessesLocal() : d(new Private())
+{
+
+}
+
+long ProcessesLocal::getParentPid(long pid) {
+ long long ppid = 0;
+ struct kinfo_proc p;
+ if(d->readProc(pid, &p))
+ ppid = PP(&p, ppid);
+
+ return ppid;
+}
+
+bool ProcessesLocal::updateProcessInfo( long pid, Process *process)
+{
+ struct kinfo_proc p;
+ if(!d->readProc(pid, &p)) return false;
+ d->readProcStat(&p, process);
+ d->readProcStatus(&p, process);
+ d->readProcStatm(&p, process);
+ if(!d->readProcCmdline(pid, process)) return false;
+
+ return true;
+}
+
+QSet<long> ProcessesLocal::getAllPids( )
+{
+ QSet<long> pids;
+ int mib[3];
+ size_t len;
+ size_t num;
+ struct kinfo_proc *p;
+
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_PROC;
+ mib[2] = KERN_PROC_ALL;
+ if (sysctl(mib, 3, NULL, &len, NULL, 0) == -1)
+ return pids;
+ if ((p = (kinfo_proc *) malloc(len)) == NULL)
+ return pids;
+ if (sysctl(mib, 3, p, &len, NULL, 0) == -1) {
+ free(p);
+ return pids;
+ }
+
+ for (num = 0; num < len / sizeof(struct kinfo_proc); num++)
+ {
+ long pid = PP((&p[num]), pid);
+ long long ppid = PP((&p[num]), ppid);
+
+ //skip all process with parent id = 0 but init
+ if(ppid == 0 && pid != 1)
+ continue;
+ pids.insert(pid);
+ }
+ free(p);
+ return pids;
+}
+
+bool ProcessesLocal::sendSignal(long pid, int sig) {
+ if ( kill( (pid_t)pid, sig ) ) {
+ //Kill failed
+ return false;
+ }
+ return true;
+}
+
+bool ProcessesLocal::setNiceness(long pid, int priority) {
+ if ( setpriority( PRIO_PROCESS, pid, priority ) ) {
+ //set niceness failed
+ return false;
+ }
+ return true;
+}
+
+bool ProcessesLocal::setScheduler(long pid, int priorityClass, int priority)
+{
+ if(priorityClass == KSysGuard::Process::Other || priorityClass == KSysGuard::Process::Batch)
+ priority = 0;
+ if(pid <= 0) return false; // check the parameters
+ struct sched_param params;
+ params.sched_priority = priority;
+ switch(priorityClass) {
+ case (KSysGuard::Process::Other):
+ return (sched_setscheduler( pid, SCHED_OTHER, &params) == 0);
+ case (KSysGuard::Process::RoundRobin):
+ return (sched_setscheduler( pid, SCHED_RR, &params) == 0);
+ case (KSysGuard::Process::Fifo):
+ return (sched_setscheduler( pid, SCHED_FIFO, &params) == 0);
+#ifdef SCHED_BATCH
+ case (KSysGuard::Process::Batch):
+ return (sched_setscheduler( pid, SCHED_BATCH, &params) == 0);
+#endif
+ default:
+ return false;
+ }
+}
+
+bool ProcessesLocal::setIoNiceness(long pid, int priorityClass, int priority) {
+ return false; //Not yet supported
+}
+
+bool ProcessesLocal::supportsIoNiceness() {
+ return false;
+}
+
+long long ProcessesLocal::totalPhysicalMemory() {
+
+ size_t Total;
+ size_t len;
+
+ len = sizeof (Total);
+ if (sysctlbyname("hw.physmem", &Total, &len, NULL, 0) == -1)
+ return 0;
+
+ Total *= getpagesize() / 1024;
+ return Total;
+}
+
+ProcessesLocal::~ProcessesLocal()
+{
+ delete d;
+}
+
+}