From 10b87ec0129dccc350fae39d02f167bb0fd43a16 Mon Sep 17 00:00:00 2001
From: Charlie <root@rama.hawaii.rr.com>
Date: Sat, 25 Dec 2010 13:01:23 -1000
Subject: [PATCH 1/2] KDE4 fixes.

---
 x11/kdebase-workspace4/distinfo         |    1 +
 x11/kdebase-workspace4/patches/patch-zz |  390 +++++++++++++++++++++++++++++++
 2 files changed, 391 insertions(+), 0 deletions(-)
 create mode 100644 x11/kdebase-workspace4/patches/patch-zz

diff --git a/x11/kdebase-workspace4/distinfo b/x11/kdebase-workspace4/distinfo
index 64ad252..16e0f23 100644
--- a/x11/kdebase-workspace4/distinfo
+++ b/x11/kdebase-workspace4/distinfo
@@ -25,3 +25,4 @@ SHA1 (patch-be) = e58dc4a0a7be7350251f26de34a8949e7508c983
 SHA1 (patch-bo) = e682d488c61ca2540ed4b2112c9bffc45bbe5e8d
 SHA1 (patch-ca) = 61b886388aa5d0831581eacb7db79de0ae5eaf80
 SHA1 (patch-cb) = 8bfcc8b7e91eafd6b444f4103d3860fb6434a535
+SHA1 (patch-zz) = d627e7ac211c63bd59359bacb0b5e32fdea64360
diff --git a/x11/kdebase-workspace4/patches/patch-zz b/x11/kdebase-workspace4/patches/patch-zz
new file mode 100644
index 0000000..281b935
--- /dev/null
+++ b/x11/kdebase-workspace4/patches/patch-zz
@@ -0,0 +1,390 @@
+Index: libs/ksysguard/processcore/processes_local_p.cpp
+===================================================================
+--- libs/ksysguard/processcore/processes_local_p.cpp	(revision 1206517)
++++ libs/ksysguard/processcore/processes_local_p.cpp	(working copy)
+@@ -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__
+Index: libs/ksysguard/processcore/processes_freebsd_p.cpp
+===================================================================
+--- libs/ksysguard/processcore/processes_freebsd_p.cpp	(revision 1206517)
++++ libs/ksysguard/processcore/processes_freebsd_p.cpp	(working copy)
+@@ -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 @@
+     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 @@
+     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 @@
+ 
+     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;
+Index: libs/ksysguard/processcore/processes_dragonfly_p.cpp
+===================================================================
+--- libs/ksysguard/processcore/processes_dragonfly_p.cpp	(revision 0)
++++ libs/ksysguard/processcore/processes_dragonfly_p.cpp	(revision 0)
+@@ -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;
++}
++
++}
-- 
1.7.3.4

