为什么要做深度系统监视器？
为了达到深度操作系统UI/UX大统一的‘雄伟’目标，闲来无事写了深度系统监视器，先发一张图镇楼，哈哈哈。
深度截图_桌面_20170722202445.png
社区的开源爱好者马上会跳出来说，深度你们又造轮子，你们造的轮子比Gnome和KDE的系统监视器好吗？
回答当然是肯定的，如果不秒杀Gnome的系统监视器我造它干嘛呢？
深度系统监视器首先要解决的问题是：提高用户操作的易用性
Gnome的系统监视器默认分开了三个标签，把进程列表和资源总览分开了，看进程列表的状态就不知道资源总览的信息，看资源总览信息就不知道进程列表的状态，而且还在第三个标签提供了一个鸡肋的磁盘设备的空间，只能看啥操作都不能做，还不如放在文件管理器或者磁盘管理工具里面。
深度截图_桌面_20170722202945.png
深度截图_桌面_20170722203015.png
所以针对这些不爽的设计，深度系统监视器把资源总览信息和列表的进程信息放在一起，一眼就可以知道现在电脑的整体负载，而且用户马上就可以在右边查看高资源占用的进程，再也不用来回费劲的切换标签去看这两个本来就应该在一起的信息。
其次，深度系统监视器狠下内功，不但可以对每个进程的CPU、内存状态进行监控，还可以实时查看每个进程的磁盘IO操作和网络操作，一眼就知道哪些进程在狂写硬盘和在后台偷偷下载了。
最后，还提供一些小贴心的功能，比如查找进程启动命令所在的位置（甚至包括Wine程序都可以轻松找到）和类似xkill的功能（点哪杀哪）。
技术原理剖析
今天主要和大家分享一下对进程信息进行监听的原理和实现。
在Linux中，计算机的所有数据的计算都通过读取分析 /proc 文件系统来实现，Linux内核会实时把硬件的状况更新到 /proc 这个内存文件系统中。
下面我们就针对 /proc 不同的部分进行原理和技术实现剖析：
计算总CPU数据
得到计算机的总CPU数据比较简单，直接读取 /proc/stat 文件即可，比如在终端中执行命令
cat /proc/stat
即可得到下面的输出：
cpu 492210 2258 105266 10955786 187778 0 4761 0 0 0
cpu0 89150 320 19660 1276610 76551 0 3102 0 0 0
cpu1 41252 241 10276 1403886 14385 0 350 0 0 0
cpu2 76932 339 16603 1343444 27821 0 678 0 0 0
cpu3 43124 243 8810 1408410 11182 0 143 0 0 0
cpu4 78072 320 16240 1350574 20070 0 215 0 0 0
cpu5 43333 244 8818 1407601 11858 0 77 0 0 0
cpu6 76218 318 15967 1355511 17012 0 139 0 0 0
cpu7 44126 230 8890 1409746 8896 0 55 0 0 0
intr 29214339 19 61901 0 0 0 0 0 0 1 8821 0 0 9987 0 0 0 29 0 1 0 0 0 0 35 0 0 22 7383 136 199974 241715 561627 23 546066 397 746 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
ctxt 92198094
btime 1500712714
processes 36267
procs_running 4
procs_blocked 0
softirq 13122555 137 4225618 144 671154 238659 0 62530 4265310 0 3659003
第一行就是总CPU的占用率，下面的CPU1、CPU2等等表示多核CPU某个核的CPU占有率。
第一行从左到右的数值分别表示：user, nice, system, idle, iowait, irq, softirq, steal, guest, guestnice （这些值分别代表的意义在man手册里面都有讲，今天就不展开了）
计算总CPU的占有率，首先要计算 workTime和totalTime:
workTime = user + nice + system;
totalTime = return user + nice + system + idle + iowait + irq + softirq + steal;
比如我们系统监视器2秒中获取一些当前CPU时间的切片，最后计算CPU占有率的公式就是：
cpuPercent = (currentWorkTime - prevWorkTime) * 100.0 / (currentTotalTime - prevTotalTime)
currentWorkTime和currentTotalTime表示当前的CPU时间
prevWorkTime和prevTotalTime表示2秒前的CPU时间
取得CPU时间的代码实现如下：
unsigned long long getTotalCpuTime(unsigned long long &workTime)
{
FILE* file = fopen("/proc/stat", "r");
if (file == NULL) {
perror("Could not open stat file");
return 0;
}
char buffer[1024];
unsigned long long user = 0, nice = 0, system = 0, idle = 0;
// added between Linux 2.5.41 and 2.6.33, see man proc(5)
unsigned long long iowait = 0, irq = 0, softirq = 0, steal = 0, guest = 0, guestnice = 0;
char* ret = fgets(buffer, sizeof(buffer) - 1, file);
if (ret == NULL) {
perror("Could not read stat file");
fclose(file);
return 0;
}
fclose(file);
sscanf(buffer,
"cpu %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu",
&user, &nice, &system, &idle, &iowait, &irq, &softirq, &steal, &guest, &guestnice);
workTime = user + nice + system;
// sum everything up (except guest and guestnice since they are already included
// in user and nice, see http://unix.stackexchange.com/q/178045/20626)
return user + nice + system + idle + iowait + irq + softirq + steal;
}
具体可以参考: https://github.com/manateelazycat/deepin-system-monitor/blob/master/src/utils.cpp
计算总内存数据
计算机总内存的数据保存在 /proc/meminfo 文件中，你可以通过:
cat /proc/meminfo
得到类似下面的信息：
MemTotal: 8056276 kB
MemFree: 897868 kB
MemAvailable: 4861656 kB
Buffers: 143776 kB
Cached: 4613124 kB
SwapCached: 0 kB
Active: 3455196 kB
Inactive: 3220984 kB
Active(anon): 1932732 kB
Inactive(anon): 736476 kB
Active(file): 1522464 kB
Inactive(file): 2484508 kB
Unevictable: 48 kB
Mlocked: 48 kB
SwapTotal: 36042872 kB
SwapFree: 36042872 kB
Dirty: 356 kB
Writeback: 0 kB
AnonPages: 1919408 kB
Mapped: 888900 kB
Shmem: 749924 kB
Slab: 313304 kB
SReclaimable: 262640 kB
SUnreclaim: 50664 kB
KernelStack: 12960 kB
PageTables: 55112 kB
NFS_Unstable: 0 kB
Bounce: 0 kB
WritebackTmp: 0 kB
CommitLimit: 40071008 kB
Committed_AS: 8831548 kB
VmallocTotal: 34359738367 kB
VmallocUsed: 0 kB
VmallocChunk: 0 kB
HardwareCorrupted: 0 kB
AnonHugePages: 0 kB
ShmemHugePages: 0 kB
ShmemPmdMapped: 0 kB
HugePages_Total: 0
HugePages_Free: 0
HugePages_Rsvd: 0
HugePages_Surp: 0
Hugepagesize: 2048 kB
DirectMap4k: 233872 kB
DirectMap2M: 8032256 kB
DirectMap1G: 0 kB
或者通过命令 free 得到类似的输出：
total used free shared buff/cache available
Mem: 8056276 2167084 861736 756536 5027456 4826836
Swap: 36042872 0 36042872
计算内存的占有就要简单的很多：
memoryPercent = (total - available) * 100.0 / total
注意，当前系统使用的内存是由内存总量total减去可用内存aviailable的值来计算的，不能用
memoryPercent = used * 100.0 / total
因为 used 的值不包括一些被内核占用并且永不释放的缓存内存，如果用 used 的方式来计算内存百分比，会发现最终计算的结果会比实际占用的内存小 15% 左右。
具体的代码实现，我们用 libprocps-dev 这个开发库提供的 meminfo() 函数，然后直接读取 kb_main_total 和 kb_main_available 就可以了，交换空间读取 kb_swap_used 和 kb_swap_total 这两个变量的值。
参考代码实现如下：
meminfo();
memoryPercent = (kb_main_total - kb_main_available) * 100.0 / kb_main_total
swapPercent = kb_swap_used * 100.0 / kb_swap_total
计算总网络数据
计算机总网络数据可以通过读取分析 /proc/net/dev 文件来计算, 执行命令后
cat /proc/net/dev
可以得到类似的数据：
Inter-| Receive | Transmit
face |bytes packets errs drop fifo frame compressed multicast|bytes packets errs drop fifo colls carrier compressed
enp0s25: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
lo: 65691844 116033 0 0 0 0 0 0 65691844 116033 0 0 0 0 0 0
wlp4s0: 1249471414 907278 0 0 0 0 0 0 88564991 428056 0 0 0 0 0 0
这个文件的每一行是一个网络设备，我们需要获得网络设备的第一个和第九个值，第一个值表示下载的总byte数，第九个值表示上传的总byte数。
原理就是读取 /proc/net/dev 的网络设备的下载和上传数据，加在一起求和，同时要排除 lo 这个虚拟网络设备，具体的代码实现如下：
void getNetworkBandWidth(unsigned long long int &receiveBytes, unsigned long long int &sendBytes)
{
char *buf;
static int bufsize;
FILE *devfd;
buf = (char *) calloc(255, 1);
bufsize = 255;
devfd = fopen("/proc/net/dev", "r");
// Ignore the first two lines of the file.
fgets(buf, bufsize, devfd);
fgets(buf, bufsize, devfd);
receiveBytes = 0;
sendBytes = 0;
while (fgets(buf, bufsize, devfd)) {
unsigned long long int rBytes, sBytes;
char *line = strdup(buf);
char *dev;
dev = strtok(line, ":");
// Filter lo (virtual network device).
if (QString::fromStdString(dev).trimmed() != "lo") {
sscanf(buf + strlen(dev) + 2, "%llu %*d %*d %*d %*d %*d %*d %*d %llu", &rBytes, &sBytes);
receiveBytes += rBytes;
sendBytes += sBytes;
}
free(line);
}
fclose(devfd);
free(buf);
}
这样，我们只用每2秒计算一下内存的总上传和下载byte数就可以得知系统总共下载和上传的带宽，总的上传和下载速度就更简单了：
downloadSpeed = (currentDownloadBytes - prevDownloadBytes) / 1024.0
uploadSpeed = (currentUploadBytes - prevUploadBytes) / 1024.0
计算进程的CPU和内存数据
计算进程的CPU比较简单，类似总CPU的计算方式，只是用进程自己的CPU值来计算， 进程自己的CPU值通过读取 /proc/pid/stat 来读取。
进程的内存信息也是从 /proc/pid/stat 文件中读取。
具体的代码实现请参考：https://github.com/manateelazycat/deepin-system-monitor/blob/master/src/status_monitor.cpp
计算进程的磁盘IO数据
计算进程的磁盘IO数据主要通过读取 /proc/pid/io 文件的内容来解析， 执行命令后
sudo cat /proc/pid/io
会得到类似以下的输出：
rchar: 2511751
wchar: 115513
syscr: 18106
syscw: 2864
read_bytes: 0
write_bytes: 0
cancelled_write_bytes: 0
我们只用注意 rchar 和 wchar这两个值， rchar代表进程的写入字符数、wchar代表进程读取字符数，磁盘IO就很容计算：
readKbs = (currentReadChar - prevReadChar) / 2 / 1000
writeKbs = (currentWriteChar - prevWriteChar) / 2 / 1000
具体的代码实现：
bool getProcPidIO(int pid, ProcPidIO &io )
{
std::stringstream ss;
ss << "/proc/" << pid << "/io";
std::ifstream ifs( ss.str().c_str() );
if ( ifs.good() ) {
while ( ifs.good() && !ifs.eof() ) {
std::string s;
getline( ifs, s );
unsigned long t;
if ( sscanf( s.c_str(), "rchar: %lu", &t ) == 1 ) io.rchar = t;
else if ( sscanf( s.c_str(), "wchar: %lu", &t ) == 1 ) io.wchar = t;
else if ( sscanf( s.c_str(), "syscr: %lu", &t ) == 1 ) io.syscr = t;
else if ( sscanf( s.c_str(), "syscw: %lu", &t ) == 1 ) io.syscw = t;
else if ( sscanf( s.c_str(), "read_bytes: %lu", &t ) == 1 ) io.read_bytes = t;
else if ( sscanf( s.c_str(), "write_bytes: %lu", &t ) == 1 ) io.write_bytes = t;
else if ( sscanf( s.c_str(), "cancelled_write_bytes: %lu", &t ) == 1 ) io.cancelled_write_bytes = t;
}
} else {
return false;
}
return true;
}
DiskStatus StatusMonitor::getProcessDiskStatus(int pid)
{
ProcPidIO pidIO;
getProcPidIO(pid, pidIO);
DiskStatus status = {0, 0};
if (processWriteKbs->contains(pid)) {
status.writeKbs = (pidIO.wchar - processWriteKbs->value(pid)) / (updateDuration / 1000.0);
}
(*processWriteKbs)[pid] = pidIO.wchar;
if (processReadKbs->contains(pid)) {
status.readKbs = (pidIO.rchar - processReadKbs->value(pid)) / (updateDuration / 1000.0);
}
(*processReadKbs)[pid] = pidIO.rchar;
return status;
}
计算进程的网络IO数据
计算每个进程的网络IO数据比较复杂，原理步骤如下：
1、获取进程的所有TCP链接的inode, /proc/pid/fd 目录下代表当前进程所有打开的文件描述符，我们举例网易云音乐的进程，内容类似：
andy@andy-PC:~/deepin-system-monitor/build$ ls -al /proc/22269/fd
总用量 0
dr-x------ 2 andy andy 0 7月 22 17:18 .
dr-xr-xr-x 9 andy andy 0 7月 22 17:11 ..
lr-x------ 1 andy andy 64 7月 22 17:18 0 -> pipe:[139620]
l-wx------ 1 andy andy 64 7月 22 17:18 1 -> /dev/null
lrwx------ 1 andy andy 64 7月 22 17:18 10 -> socket:[141559]
lrwx------ 1 andy andy 64 7月 22 17:21 100 -> socket:[564075]
lrwx------ 1 andy andy 64 7月 22 17:18 101 -> /dev/shm/.org.chromium.Chromium.NLubPR (deleted)
l-wx------ 1 andy andy 64 7月 22 17:32 102 -> /home/andy/.cache/netease-cloud-music/AlbumCover/4e3830fa33b1caf266bfe8ff6acd7634.tmp (deleted)
l-wx------ 1 andy andy 64 7月 22 17:32 103 -> /home/andy/.cache/netease-cloud-music/CachedSongs/4176388-320-7c00bba57b7a737c8047bb11bd07827d.mp3.tmp (deleted)
lrwx------ 1 andy andy 64 7月 22 17:32 104 -> socket:[751267]
lrwx------ 1 andy andy 64 7月 22 17:18 105 -> socket:[751268]
lrwx------ 1 andy andy 64 7月 22 17:21 106 -> socket:[756879]
lrwx------ 1 andy andy 64 7月 22 17:18 11 -> socket:[141560]
lrwx------ 1 andy andy 64 7月 22 17:18 110 -> anon_inode:[eventfd]
lrwx------ 1 andy andy 64 7月 22 17:18 111 -> /dev/shm/.org.chromium.Chromium.8IQyY6 (deleted)
lrwx------ 1 andy andy 64 7月 22 17:18 112 -> /home/andy/.cache/netease-cloud-music/Cef/Cache/Local Storage/orpheus_orpheus_0.localstorage
lrwx------ 1 andy andy 64 7月 22 17:24 115 -> socket:[753243]
lrwx------ 1 andy andy 64 7月 22 17:18 116 -> socket:[753244]
lr-x------ 1 andy andy 64 7月 22 17:18 117 -> pipe:[753245]
lrwx------ 1 andy andy 64 7月 22 17:18 118 -> anon_inode:[eventfd]
l-wx------ 1 andy andy 64 7月 22 17:21 119 -> pipe:[753245]
lrwx------ 1 andy andy 64 7月 22 17:18 12 -> anon_inode:[eventfd]
lrwx------ 1 andy andy 64 7月 22 17:18 120 -> socket:[753248]
lrwx------ 1 andy andy 64 7月 22 17:18 121 -> anon_inode:[eventfd]
lr-x------ 1 andy andy 64 7月 22 17:18 122 -> /dev/urandom
lrwx------ 1 andy andy 64 7月 22 17:18 123 -> anon_inode:[eventfd]
lrwx------ 1 andy andy 64 7月 22 17:18 13 -> anon_inode:[eventfd]
lr-x------ 1 andy andy 64 7月 22 17:18 14 -> anon_inode:inotify
lrwx------ 1 andy andy 64 7月 22 17:18 15 -> socket:[143624]
lr-x------ 1 andy andy 64 7月 22 17:18 16 -> /usr/lib/netease-cloud-music/icudtl.dat
lr-x------ 1 andy andy 64 7月 22 17:18 17 -> /usr/lib/netease-cloud-music/snapshot_blob.bin
lr-x------ 1 andy andy 64 7月 22 17:18 18 -> /usr/lib/netease-cloud-music/natives_blob.bin
lr-x------ 1 andy andy 64 7月 22 17:18 19 -> /usr/lib/netease-cloud-music/locales/zh-CN.pak
l-wx------ 1 andy andy 64 7月 22 17:18 2 -> /dev/null
lr-x------ 1 andy andy 64 7月 22 17:18 20 -> /usr/lib/netease-cloud-music/cef.pak
lr-x------ 1 andy andy 64 7月 22 17:18 21 -> /usr/lib/netease-cloud-music/cef_100_percent.pak
lr-x------ 1 andy andy 64 7月 22 17:18 22 -> /usr/lib/netease-cloud-music/cef_200_percent.pak
lr-x------ 1 andy andy 64 7月 22 17:18 23 -> anon_inode:inotify
lr-x------ 1 andy andy 64 7月 22 17:18 24 -> /usr/lib/netease-cloud-music/cef_extensions.pak
lrwx------ 1 andy andy 64 7月 22 17:18 25 -> socket:[141561]
lrwx------ 1 andy andy 64 7月 22 17:18 26 -> socket:[141562]
lr-x------ 1 andy andy 64 7月 22 17:18 27 -> pipe:[141563]
l-wx------ 1 andy andy 64 7月 22 17:18 28 -> pipe:[141563]
lrwx------ 1 andy andy 64 7月 22 17:18 29 -> socket:[141564]
lrwx------ 1 andy andy 64 7月 22 17:18 3 -> socket:[141558]
lrwx------ 1 andy andy 64 7月 22 17:18 30 -> socket:[141605]
lr-x------ 1 andy andy 64 7月 22 17:18 31 -> pipe:[140610]
l-wx------ 1 andy andy 64 7月 22 17:18 32 -> pipe:[140610]
lrwx------ 1 andy andy 64 7月 22 17:18 33 -> anon_inode:[eventpoll]
lrwx------ 1 andy andy 64 7月 22 17:18 34 -> socket:[137178]
lrwx------ 1 andy andy 64 7月 22 17:18 35 -> socket:[137179]
lr-x------ 1 andy andy 64 7月 22 17:18 36 -> pipe:[137180]
l-wx------ 1 andy andy 64 7月 22 17:18 37 -> pipe:[137180]
lrwx------ 1 andy andy 64 7月 22 17:18 38 -> socket:[137181]
lr-x------ 1 andy andy 64 7月 22 17:18 39 -> anon_inode:inotify
lrwx------ 1 andy andy 64 7月 22 17:18 4 -> anon_inode:[eventfd]
lr-x------ 1 andy andy 64 7月 22 17:18 40 -> pipe:[137189]
l-wx------ 1 andy andy 64 7月 22 17:18 41 -> pipe:[137189]
lrwx------ 1 andy andy 64 7月 22 17:18 42 -> anon_inode:[eventpoll]
lrwx------ 1 andy andy 64 7月 22 17:18 43 -> socket:[137190]
lrwx------ 1 andy andy 64 7月 22 17:18 44 -> socket:[137191]
lr-x------ 1 andy andy 64 7月 22 17:18 45 -> pipe:[137192]
l-wx------ 1 andy andy 64 7月 22 17:18 46 -> pipe:[137192]
lrwx------ 1 andy andy 64 7月 22 17:18 47 -> anon_inode:[eventpoll]
lrwx------ 1 andy andy 64 7月 22 17:18 48 -> anon_inode:[eventpoll]
lrwx------ 1 andy andy 64 7月 22 17:18 49 -> socket:[131820]
lrwx------ 1 andy andy 64 7月 22 17:18 5 -> anon_inode:[eventfd]
lrwx------ 1 andy andy 64 7月 22 17:18 50 -> socket:[131821]
lrwx------ 1 andy andy 64 7月 22 17:18 51 -> socket:[137193]
lrwx------ 1 andy andy 64 7月 22 17:18 52 -> socket:[137194]
lr-x------ 1 andy andy 64 7月 22 17:18 53 -> pipe:[137195]
l-wx------ 1 andy andy 64 7月 22 17:18 54 -> pipe:[137195]
lr-x------ 1 andy andy 64 7月 22 17:18 55 -> pipe:[131822]
l-wx------ 1 andy andy 64 7月 22 17:18 56 -> pipe:[131822]
lr-x------ 1 andy andy 64 7月 22 17:18 57 -> pipe:[140611]
l-wx------ 1 andy andy 64 7月 22 17:18 58 -> pipe:[140611]
lrwx------ 1 andy andy 64 7月 22 17:18 59 -> socket:[140614]
lrwx------ 1 andy andy 64 7月 22 17:18 6 -> socket:[138694]
lrwx------ 1 andy andy 64 7月 22 17:18 60 -> anon_inode:[eventfd]
lrwx------ 1 andy andy 64 7月 22 17:18 61 -> anon_inode:[eventfd]
lrwx------ 1 andy andy 64 7月 22 17:18 62 -> socket:[137196]
lr-x------ 1 andy andy 64 7月 22 17:18 63 -> /dev/urandom
lrwx------ 1 andy andy 64 7月 22 17:18 64 -> anon_inode:[eventfd]
lrwx------ 1 andy andy 64 7月 22 17:18 65 -> /home/andy/.cache/netease-cloud-music/Cef/Cache/Visited Links
lrwx------ 1 andy andy 64 7月 22 17:18 66 -> /home/andy/.cache/netease-cloud-music/Cef/Cache/Cookies
l-wx------ 1 andy andy 64 7月 22 17:18 67 -> /home/andy/.cache/netease-cloud-music/Logs/webview.log
l-wx------ 1 andy andy 64 7月 22 17:18 68 -> /home/andy/.cache/netease-cloud-music/Logs/web-statis.log
lrwx------ 1 andy andy 64 7月 22 17:18 69 -> socket:[143663]
lr-x------ 1 andy andy 64 7月 22 17:18 7 -> anon_inode:inotify
lrwx------ 1 andy andy 64 7月 22 17:18 70 -> anon_inode:[eventfd]
lrwx------ 1 andy andy 64 7月 22 17:18 71 -> anon_inode:[eventfd]
lrwx------ 1 andy andy 64 7月 22 17:18 72 -> anon_inode:[eventfd]
lrwx------ 1 andy andy 64 7月 22 17:18 73 -> anon_inode:[eventfd]
lrwx------ 1 andy andy 64 7月 22 17:18 74 -> anon_inode:[eventfd]
lrwx------ 1 andy andy 64 7月 22 17:18 75 -> anon_inode:[eventfd]
lrwx------ 1 andy andy 64 7月 22 17:18 76 -> /home/andy/.pki/nssdb/cert9.db
lrwx------ 1 andy andy 64 7月 22 17:18 77 -> /home/andy/.pki/nssdb/key4.db
lrwx------ 1 andy andy 64 7月 22 17:18 78 -> /home/andy/.config/netease-cloud-music/OfflineLibrary.db
lr-x------ 1 andy andy 64 7月 22 17:18 79 -> anon_inode:inotify
lrwx------ 1 andy andy 64 7月 22 17:18 8 -> anon_inode:[eventfd]
lrwx------ 1 andy andy 64 7月 22 17:18 80 -> /home/andy/.config/netease-cloud-music/OfflineLibrary.db
lrwx------ 1 andy andy 64 7月 22 17:18 81 -> socket:[141607]
lrwx------ 1 andy andy 64 7月 22 17:18 82 -> socket:[141608]
lr-x------ 1 andy andy 64 7月 22 17:18 83 -> anon_inode:inotify
lrwx------ 1 andy andy 64 7月 22 17:18 84 -> /home/andy/.config/netease-cloud-music/OnlineLibrary.db
lrwx------ 1 andy andy 64 7月 22 17:18 85 -> /dev/dri/card1
lrwx------ 1 andy andy 64 7月 22 17:18 86 -> socket:[140638]
lrwx------ 1 andy andy 64 7月 22 17:18 87 -> socket:[754448]
lrwx------ 1 andy andy 64 7月 22 17:18 88 -> socket:[140640]
lrwx------ 1 andy andy 64 7月 22 17:18 89 -> /home/andy/.cache/netease-cloud-music/Cef/Cache/index
lrwx------ 1 andy andy 64 7月 22 17:18 9 -> socket:[143622]
lr-x------ 1 andy andy 64 7月 22 17:18 90 -> /dev/shm/.org.chromium.Chromium.hjPeWY (deleted)
lrwx------ 1 andy andy 64 7月 22 17:18 91 -> /dev/shm/.org.chromium.Chromium.hjPeWY (deleted)
lrwx------ 1 andy andy 64 7月 22 17:18 92 -> /dev/shm/.org.chromium.Chromium.gSxJ28 (deleted)
lrwx------ 1 andy andy 64 7月 22 17:18 93 -> /dev/shm/.org.chromium.Chromium.zxWAqZ (deleted)
lrwx------ 1 andy andy 64 7月 22 17:18 94 -> /home/andy/.cache/netease-cloud-music/Cef/Cache/data_0
lrwx------ 1 andy andy 64 7月 22 17:18 95 -> /home/andy/.cache/netease-cloud-music/Cef/Cache/data_1
lrwx------ 1 andy andy 64 7月 22 17:18 96 -> /home/andy/.cache/netease-cloud-music/Cef/Cache/data_2
lrwx------ 1 andy andy 64 7月 22 17:18 97 -> /home/andy/.cache/netease-cloud-music/Cef/Cache/data_3
lr-x------ 1 andy andy 64 7月 22 17:21 98 -> /home/andy/.cache/netease-cloud-music/Logs/web-statis-tmp.log.zip
lrwx------ 1 andy andy 64 7月 22 17:18 99 -> anon_inode:[eventfd]
注意那些以 socket:[number] 的文件描述符， 这些socket开头的文件描述符就对应一个 TCP 链接，后面的数字就代表链接对应的 TCP inode。
2、列出系统中 TCP inode 对应的链接信息，通过命令
cat /proc/net/tcp
可以得到当前 TCP inode 对应的链接信息列表，内容类似：
sl local_address rem_address st tx_queue rx_queue tr tm->when retrnsmt uid timeout inode
0: 00000000:008B 00000000:0000 0A 00000000:00000000 00:00000000 00000000 0 0 25701 1 ffff89bc3387a7c0 100 0 0 10 0
1: 0100007F:0277 00000000:0000 0A 00000000:00000000 00:00000000 00000000 0 0 21108 1 ffff89bc2d91e7c0 100 0 0 10 0
2: 0100007F:0438 00000000:0000 0A 00000000:00000000 00:00000000 00000000 1000 0 118922 1 ffff89bb9e326040 100 0 0 10 0
3: 00000000:01BD 00000000:0000 0A 00000000:00000000 00:00000000 00000000 0 0 25700 1 ffff89bc3387a040 100 0 0 10 0
4: DEC7A8C0:9E7E AFFD3267:20C4 01 00000000:00000000 00:00000000 00000000 1000 0 760162 1 ffff89bb9e208000 37 4 9 10 12
5: 0100007F:0438 0100007F:D934 01 00000000:00000000 00:00000000 00000000 1000 0 760161 1 ffff89ba60483000 20 4 4 10 -1
6: DEC7A8C0:D9A0 06C7FCDF:1773 01 00000000:00000000 02:00000B05 00000000 1000 0 564075 2 ffff89bb5aced7c0 22 4 29 10 -1
7: DEC7A8C0:9E82 AFFD3267:20C4 01 00000000:00000000 00:00000000 00000000 1000 0 758410 1 ffff89ba0fa4f7c0 57 4 32 18 13
8: DEC7A8C0:B9B8 7DFD1EC0:01BB 01 00000000:00000000 02:00000359 00000000 1000 0 660202 2 ffff89ba989fa800 58 4 25 10 -1
9: 0100007F:D938 0100007F:0438 01 00000000:00000000 02:000006AA 00000000 1000 0 759339 2 ffff89ba6582d800 20 4 30 10 -1
10: DEC7A8C0:A9D6 42522477:0050 01 00000000:00063C60 00:00000000 00000000 1000 0 759725 1 ffff89bbb8d87080 20 4 0 10 -1
11: DEC7A8C0:CAF0 3C011434:01BB 01 00000000:00000000 02:0000089A 00000000 1000 0 564925 2 ffff89bb7c5fd800 72 4 30 10 -1
12: DEC7A8C0:CFC6 DADCDF36:01BB 01 00000000:00000000 02:00000EB7 00000000 1000 0 565035 2 ffff89bb071aa040 22 4 28 10 -1
13: 0100007F:0438 0100007F:D938 01 00000000:00000000 00:00000000 00000000 1000 0 758409 1 ffff89ba6582d080 21 4 20 10 -1
14: 0100007F:D934 0100007F:0438 01 00000000:00000000 02:000002F2 00000000 1000 0 759243 2 ffff89bb6d885080 20 4 11 10 -1
15: DEC7A8C0:E168 5D39C834:01BB 01 00000000:00000000 02:000005E2 00000000 1000 0 565468 2 ffff89bbb8d0f780 57 4 30 10 -1
16: DEC7A8C0:D898 C5A06F3B:0050 08 00000000:00000001 02:00000734 00000000 1000 0 761352 2 ffff89ba989fa080 22 4 24 10 -1
17: DEC7A8C0:93B2 5B822879:1F92 01 00000000:00000000 02:00000226 00000000 1000 0 566332 2 ffff89bb05284780 22 4 28 10 -1
3、使用 libcap 抓包的方法，计算出每个TCP链接对应的网络流量后，然后反向通过步骤一的 pid <-> inode list 信息，最后计算出每个进程的网络流量。
这么绕的计算方法，我觉得这个世间早以有牛人实现了，Google了一下，发现可以直接使用 libnethogs 这个库来计算每个进程的网络流量。
具体的代码实现可以参考：https://github.com/manateelazycat/deepin-system-monitor/blob/master/src/network_traffic_filter.cpp
nethogs这种方式只能计算出TCP链接的网络流量，无法计算UDP链接的网络流量，当然TCP流量分析已经满足了大部分应用的需求。
Wine程序的网络流量
上面说的方法适用于Linux原生应用的网络进城监控，但是无法直接通过监听Wine程序的网络流量，比如基于Wine运行的迅雷。
当一个Wine程序需要进行网络上传和下载的时候， Wine会后台分配一个 wineserver.real 的进程来完成Wine程序网络代理的功能，wineserver.real 获得网络数据以后再传递给 Wine 程序。
所以计算Wine程序的网络流量的步骤是：
1、统计所有Wine程序运行时的环境变量，通过 GIO_LAUNCHED_DESKTOP_FILE 这个环境变量获得 Wine 程序的 desktop 文件路径；
2、统计所有 wineserver.real 进程的环境变量，通过 GIO_LAUNCHED_DESKTOP_FILE 这个环境变量获得wineserver.real 进程 的 desktop 文件路径；
3、分析系统的TCP链接后，找到匹配的 wineserver.real 的pid;
4、通过 wineserver.real 匹配的 desktop 文件找到对应的 Wine 程序的 pid;
5、最后，用 wineserver.real 进程的网络流量数据替换 Wine 程序的网络流量，并清空 wineserver.real 进程的网络流量；
这样用户就可以在系统监视器看到Wine程序的网络流量了，如下图所示：
深度截图_选择区域_20170725110657.png
代码参考实现：
std::string getDesktopFileFromName(int pid, QString procName, QString cmdline)
{
if (desktopfileMaps.contains(cmdline)) {
return desktopfileMaps[cmdline].toStdString();
} else {
// Need found desktop file from process environment, if process is wine program.
if (cmdline.startsWith("c:\\")) {
QString gioDesktopFile = Utils::getProcessEnvironmentVariable(pid, "GIO_LAUNCHED_DESKTOP_FILE");
return gioDesktopFile.toStdString();
} else {
QDirIterator dir("/usr/share/applications", QDirIterator::Subdirectories);
std::string desktopFile;
// Convert to lower characters.
QString procname = procName.toLower();
// Replace "_" instead "-", avoid some applications desktop file can't found, such as, sublime text.
procname.replace("_", "-");
// Concat desktop file.
QString processFilename = procname + ".desktop";
if (GUI_BLACKLIST_MAP.find(procname) == GUI_BLACKLIST_MAP.end()) {
while(dir.hasNext()) {
if (dir.fileInfo().suffix() == "desktop") {
if (dir.fileName().toLower().contains(processFilename)) {
desktopFile = dir.filePath().toStdString();
break;
}
}
dir.next();
}
}
return desktopFile;
}
}
}
wineApplicationDesktopMaps->clear();
wineServerDesktopMaps->clear();
for (auto &i:processes) {
int pid = (&i.second)->tid;
QString cmdline = Utils::getProcessCmdline(pid);
bool isWineProcess = cmdline.startsWith("c:\\");
QString name = getProcessName(&i.second, cmdline);
QString user = (&i.second)->euser;
double cpu = (*processCpuPercents)[pid];
std::string desktopFile = getDesktopFileFromName(pid, name, cmdline);
QString title = findWindowTitle->getWindowTitle(pid);
bool isGui = (title != "");
// Record wine application and wineserver.real desktop file.
// We need transfer wineserver.real network traffic to the corresponding wine program.
if (name == "wineserver.real") {
// Insert pid<->desktopFile to map to search in all network process list.
QString gioDesktopFile = Utils::getProcessEnvironmentVariable(pid, "GIO_LAUNCHED_DESKTOP_FILE");
if (gioDesktopFile != "") {
(*wineServerDesktopMaps)[pid] = gioDesktopFile;
}
} else {
// Insert desktopFile<->pid to map to search in all network process list.
// If title is empty, it's just a wine program, but not wine GUI window.
if (isWineProcess && title != "") {
(*wineApplicationDesktopMaps)[QString::fromStdString(desktopFile)] = pid;
}
}
if (isGui) {
guiProcessNumber++;
} else {
systemProcessNumber++;
}
bool appendItem = false;
if (filterType == OnlyGUI) {
appendItem = (user == currentUsername && isGui);
} else if (filterType == OnlyMe) {
appendItem = (user == currentUsername);
} else if (filterType == AllProcess) {
appendItem = true;
}
if (appendItem) {
if (title == "") {
if (isWineProcess) {
// If wine process's window title is blank, it's not GUI window process.
// Title use process name instead.
title = name;
} else {
title = getDisplayNameFromName(name, desktopFile);
}
}
QString displayName;
if (filterType == AllProcess) {
displayName = QString("[%1] %2").arg(user).arg(title);
} else {
displayName = title;
}
long memory = ((&i.second)->resident - (&i.second)->share) * sysconf(_SC_PAGESIZE);
QPixmap icon;
if (desktopFile.size() == 0) {
icon = findWindowTitle->getWindowIcon(findWindowTitle->getWindow(pid), 24);
} else {
icon = getDesktopFileIcon(desktopFile, 24);
}
ProcessItem *item = new ProcessItem(icon, name, displayName, cpu, memory, pid, user, (&i.second)->state);
items << item;
} else {
// Fill GUI processes information for continue merge action.
if (filterType == OnlyGUI) {
if (childInfoMap.contains(pid)) {
long memory = ((&i.second)->resident - (&i.second)->share) * sysconf(_SC_PAGESIZE);
childInfoMap[pid].cpu = cpu;
childInfoMap[pid].memory = memory;
}
}
}
}
// Transfer wineserver.real network traffic to the corresponding wine program.
QMap<int, NetworkStatus>::iterator i;
for (i = networkStatusSnapshot.begin(); i != networkStatusSnapshot.end(); ++i) {
if (wineServerDesktopMaps->contains(i.key())) {
QString wineDesktopFile = (*wineServerDesktopMaps)[i.key()];
if (wineApplicationDesktopMaps->contains(wineDesktopFile)) {
// Transfer wineserver.real network traffic to the corresponding wine program.
int wineApplicationPid = (*wineApplicationDesktopMaps)[wineDesktopFile];
networkStatusSnapshot[wineApplicationPid] = networkStatusSnapshot[i.key()];
// Reset wineserver network status to zero.
NetworkStatus networkStatus = {0, 0, 0, 0};
networkStatusSnapshot[i.key()] = networkStatus;
}
}
}
找到进程对应的名字
主要的名字主要有三种形式：图形窗口的标题、Desktop文件对应的本地化名称和最后的命令行名称。
图形窗口的标题的步骤是：
1、通过XCB分析 _NET_CLIENT_LIST_STACKING 数据列出所有图形窗口的XID
2、通过XCB分析 _NET_WM_PID 得出每个窗口对应的 pid
3、然后对比图形窗口的 pid list 和 process pid list, 找到所有图形窗口的 pid list
4、最后通过XCB分析 xid 对应的 _NET_WM_NAME 来查找图形窗口的标题
具体的代码实现参考：
QList<xcb_window_t> WindowManager::getWindows()
{
QList<xcb_window_t> windows;
xcb_get_property_reply_t *listReply = getProperty(rootWindow, "_NET_CLIENT_LIST_STACKING", XCB_ATOM_WINDOW);
if (listReply) {
xcb_window_t *windowList = static_cast<xcb_window_t*>(xcb_get_property_value(listReply));
int windowListLength = listReply->length;
for (int i = 0; i < windowListLength; i++) {
xcb_window_t window = windowList[i];
foreach(QString type, getWindowTypes(window)) {
if (type == "_NET_WM_WINDOW_TYPE_NORMAL" ||
type == "_NET_WM_WINDOW_TYPE_DIALOG"
) {
bool needAppend = false;
QStringList states = getWindowStates(window);
if (states.length() == 0 ||
(!states.contains("_NET_WM_STATE_HIDDEN"))) {
if (getWindowWorkspace(window) == getCurrentWorkspace(rootWindow)) {
needAppend = true;
}
}
if (needAppend) {
windows.append(window);
break;
}
}
}
}
free(listReply);
// We need re-sort windows list from up to bottom,
// to make compare cursor with window area from up to bottom.
std::reverse(windows.begin(), windows.end());
// Add desktop window.
windows.append(rootWindow);
// Just use for debug.
// foreach (auto window, windows) {
// qDebug() << getWindowName(window);
// }
}
return windows;
}
int WindowManager::getWindowPid(xcb_window_t window)
{
xcb_get_property_reply_t *reply = getProperty(window, "_NET_WM_PID", XCB_ATOM_CARDINAL);
int pid = 0;
if (reply) {
pid = *((int *) xcb_get_property_value(reply));
free(reply);
}
return pid;
}
QString WindowManager::getWindowName(xcb_window_t window)
{
if (window == rootWindow) {
return tr("Desktop");
} else {
xcb_get_property_reply_t *reply = getProperty(window, "_NET_WM_NAME", getAtom("UTF8_STRING"));
if (reply) {
QString result = QString::fromUtf8(static_cast<char*>(xcb_get_property_value(reply)), xcb_get_property_value_length(reply));
free(reply);
return result;
} else {
return QString();
}
}
}
得到Desktop对应的名称原理：
1、通过读取 /proc/pid/cmdline 得到进程对应的启动命令行
2、提取 cmdline 第一个参数得到启动命令
3、通过启动命令在 /usr/share/applications 目录下查找对应的 *.desktop 文件
4、分析文件的 Name[locale] 字符串，得到本地化的名字， locale 在中文表示 zh_CN
具体的代码实现参考：
QString getProcessCmdline(pid_t pid)
{
std::string temp;
try {
std::fstream fs;
fs.open("/proc/"+std::to_string((long)pid)+"/cmdline", std::fstream::in);
std::getline(fs,temp);
fs.close();
} catch(std::ifstream::failure e) {
return "FAILED TO READ PROC";
}
// change \0 to ' '
std::replace(temp.begin(),temp.end(),'\0',' ');
if (temp.size()<1) {
return "";
}
return QString::fromStdString(temp).trimmed();
}
QString getProcessNameFromCmdLine(const pid_t pid)
{
std::string cmdline = getProcessCmdline(pid).toStdString();
if (cmdline.size()<1) {
return "";
}
// Maintain linux paths.
std::replace(cmdline.begin(),cmdline.end(),'\\','/');
// Get cmdline arguments and first argument name.
auto args = explode(cmdline, ' ');
QString name = QFileInfo(QString::fromStdString(args[0])).fileName();
// Get first argument that start with '/' if first argument is script program, such as 'python'.
auto pos = SCRIPT_PROGRAM_MAP.find(name);
if (pos != SCRIPT_PROGRAM_MAP.end() && args.size() > 1) {
for (unsigned int i = 1; i < args.size(); i++) {
QString argument = QString::fromStdString(args[i]);
// Return first argument that start with '/'.
if (argument.startsWith("/")) {
return QFileInfo(argument).fileName();
}
}
for (unsigned int j = 1; j < args.size(); j++) {
QString argument = QString::fromStdString(args[j]);
// Return first argument that not start with '-'.
if (!argument.startsWith("-")) {
return QFileInfo(argument).fileName();
}
}
}
return name;
}
QString getDisplayNameFromName(QString procName, std::string desktopFile, bool displayProcessName)
{
QString procname = procName.toLower();
if (processDescriptions.contains(procname)) {
if (displayProcessName) {
return QString("%1 ( %2 )").arg(processDescriptions[procname], procName);
} else {
return processDescriptions[procname];
}
}
if (desktopFile.size() == 0) {
return procName;
}
std::ifstream in;
in.open(desktopFile);
QString displayName = procName;
while(!in.eof()) {
std::string line;
std::getline(in,line);
QString lineContent = QString::fromStdString(line);
QString localNameFlag = QString("Name[%1]=").arg(QLocale::system().name());
QString nameFlag = "Name=";
QString genericNameFlag = QString("GenericName[%1]=").arg(QLocale::system().name());
if (lineContent.startsWith(localNameFlag)) {
displayName = lineContent.remove(0, localNameFlag.size());
break;
} else if (lineContent.startsWith(genericNameFlag)) {
displayName = lineContent.remove(0, genericNameFlag.size());
break;
} else if (lineContent.startsWith(nameFlag)) {
displayName = lineContent.remove(0, nameFlag.size());
continue;
} else {
continue;
}
}
in.close();
return displayName;
}
第三种进程名的方式已经在函数 getProcessNameFromCmdLine 的代码实现中体现了。
找到进程二进制文件所在位置
进程管理中除了查看进程的状态，对进程进行简单的结束/暂停管理操作以外，最重要的附加功能就是，我们要知道这个软件到底是哪个命令启动的，这个命令所在的目录，这样对于我们彻底了解进程背后的软件非常有帮助。
深度系统监视器实现了一个 ”查找命令所在位置“ 的右键功能，这个功能的实现分为两种情况：
1、Linux原生应用进程
2、Wine进程
Linux原生应用进程查找二进制的步骤：
1、读取 /proc/pid/cmdline 得到命令行参数
2、获取 cmdline 第一个参数，即命令行路径
3、通过 which 命令来查询命令行的绝对路径
Wine进程查找二进制的步骤：
1、读取 /proc/pid/cmdline 得到命令行参数，一般是 c:\xxxxxxx\xxxx.exe 的Windows路径
2、转换 Windows 路径为： drive_c/xxxxxxx/xxx.exe 的Linux相对路径
3、通过读取 /proc/pid/environ 路径，找到进程的环境变量列表
4、进一步找到 WINEPREFIX 对应的值，一般是 ~/.deepinwine/xxx 的软件安装目录形式
5、最后链接软件安装目录+相对路径的形式，得到Wine进程启动命令的绝对路径，一般是 ~/.deepinwine/xxx/drive_c/xxx/xxx.exe的形式
具体代码参考实现：
void ProcessManager::openProcessDirectory()
{
for (int pid : *actionPids) {
QString cmdline = Utils::getProcessCmdline(pid);
if (cmdline.size() > 0) {
// Found wine program location if cmdline starts with c://.
if (cmdline.startsWith("c:\\")) {
QString winePrefix = Utils::getProcessEnvironmentVariable(pid, "WINEPREFIX");
cmdline = cmdline.replace("\\", "/").replace("c:/", "/drive_c/");
DDesktopServices::showFileItem(winePrefix + cmdline);
}
// Else find program location through 'which' command.
else {
cmdline = cmdline.split(QRegExp("\\s")).at(0);
QProcess whichProcess;
QString exec = "which";
QStringList params;
params << cmdline;
whichProcess.start(exec, params);
whichProcess.waitForFinished();
QString output(whichProcess.readAllStandardOutput());
QString processPath = output.split("\n")[0];
DDesktopServices::showFileItem(processPath);
}
}
}
actionPids->clear();
}
QString getProcessEnvironmentVariable(pid_t pid, QString environmentName)
{
std::string temp;
try {
std::fstream fs;
fs.open("/proc/"+std::to_string((long)pid)+"/environ", std::fstream::in);
std::getline(fs,temp);
fs.close();
} catch(std::ifstream::failure e) {
return "FAILED TO READ PROC";
}
// change \0 to ' '
std::replace(temp.begin(),temp.end(),'\0','\n');
if (temp.size()<1) {
return "";
}
foreach (auto environmentVariable, QString::fromStdString(temp).trimmed().split("\n")) {
if (environmentVariable.startsWith(environmentName)) {
return environmentVariable.remove(0, QString("%1=").arg(environmentName).length());
}
}
return "";
}
用setcap替换setuid的方式给予读取系统目录的权限
上面讲解了深度系统监视器的核心模块的原理和代码参考实现，我们会发现大部分都要读取系统目录 /proc, /proc这个目录的大部分内容只有root用户才有权限读取。
很多初学者喜欢用setuid的方式直接赋予二进制root权限，但是这样非常危险，会造成图形前端获得过大的权限，从而产生安全漏洞。
Linux内核针对这种情况有更好的实现方式，用 setcap 给予二进制特定的权限，保证二进制的特殊权限在最小的范围中，比如在深度系统监视器中就用命令：
sudo setcap cap_kill,cap_net_raw,cap_dac_read_search,cap_sys_ptrace+ep ./deepin-system-monitor
来给予进程相应的能力，比如：
- cap_net_raw 对应网络文件读取权限
- cap_dac_read_search 对应文件读取检查权限
- cap_sys_ptrace 对应进程内存信息读取权限
这样，在保证二进制有对应读取权限的同时，又保证了二进制最小化的权限范围，最大化的保证了应用和系统的安全。
最后，深度系统监视器整个项目都遵守GPLv3许可证协议，欢迎各位大神贡献代码： https://github.com/manateelazycat/deepin-system-monitor
网友评论