logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

Linux IO工具 iotop的替代品iopp

 点点阅 2020-02-26

iotop无疑在linux IO检测上是个不错的工具，但苦于要求内核版本和Python版本，不少朋友放弃了，我也是。偶然间找到了iopp，用c写的，这个跟iotop是一个作用，nice！给大家分享下

安装方法很简单，首先复制下面源代码保存为iopp.c文件

  1. #include <stdio.h>
  2. #include <sys/types.h>
  3. #include <dirent.h>
  4. #include <ctype.h>
  5. #include <sys/stat.h>
  6. #include <fcntl.h>
  7. #include <unistd.h>
  8. #include <string.h>
  9. #include <stdlib.h>
  10. #include <getopt.h>
  12. #define PROC "/proc"
  14. #define GET_VALUE(v) \
  15. 		p = strchr(p, ':'); \
  16. 		++p; \
  17. 		++p; \
  18. 		q = strchr(p, '\n'); \
  19. 		length = q - p; \
  20. 		if (length >= BUFFERLEN) \
  21. 		{ \
  22. 			printf("ERROR - value is larger than the buffer: %d\n", __LINE__); \
  23. 			exit(1); \
  24. 		} \
  25. 		strncpy(value, p, length); \
  26. 		value[length] = '\0'; \
  27. 		v = atoll(value);
  29. #define BTOKB(b) b >> 10
  30. #define BTOMB(b) b >> 20
  32. #define BUFFERLEN 255
  33. #define COMMANDLEN 1024
  34. #define VALUELEN 63
  36. #define NUM_STRINGS 8
  38. struct io_node
  39. {
  40. 	int pid;
  41. 	long long rchar;
  42. 	long long wchar;
  43. 	long long syscr;
  44. 	long long syscw;
  45. 	long long read_bytes;
  46. 	long long write_bytes;
  47. 	long long cancelled_write_bytes;
  48. 	char command[COMMANDLEN + 1];
  49. 	struct io_node *next;
  50. };
  52. struct io_node *head = NULL;
  53. int command_flag = 0;
  54. int idle_flag = 0;
  55. int mb_flag = 0;
  56. int kb_flag = 0;
  57. int hr_flag = 0;
  59. /* Prototypes */
  60. char *format_b(long long);
  61. struct io_node *get_ion(int);
  62. struct io_node *new_ion(char *);
  63. void upsert_data(struct io_node *);
  65. char *
  66. format_b(long long amt)
  67. {
  68. 	static char retarray[NUM_STRINGS][16];
  69. 	static int	index = 0;
  70. 	register char *ret;
  71. 	register char tag = 'B';
  73. 	ret = retarray[index];
  74. 	index = (index + 1) % NUM_STRINGS;
  76. 	if (amt >= 10000) {
  77. 		amt = (amt + 512) / 1024;
  78. 		tag = 'K';
  79. 		if (amt >= 10000) {
  80. 			amt = (amt + 512) / 1024;
  81. 			tag = 'B';
  82. 			if (amt >= 10000) {
  83. 				amt = (amt + 512) / 1024;
  84. 				tag = 'G';
  85. 			}
  86. 		}
  87. 	}
  89. 	snprintf(ret, sizeof(retarray[index]) - 1, "%lld%c", amt, tag);
  91. 	return (ret);
  92. }
  94. int
  95. get_cmdline(struct io_node *ion)
  96. {
  97. 	int fd;
  98. 	int length;
  99. 	char filename[BUFFERLEN + 1];
  100. 	char buffer[COMMANDLEN + 1];
  101. 	char *p;
  102. 	char *q;
  105. 	length = snprintf(filename, BUFFERLEN, "%s/%d/cmdline", PROC, ion->pid);
  106. 	if (length == BUFFERLEN)
  107. 		printf("WARNING - filename length may be too big for buffer: %d\n",
  108. 				__LINE__);
  109. 	fd = open(filename, O_RDONLY);
  110. 	if (fd == -1)
  111. 		return 1;
  112. 	length = read(fd, buffer, sizeof(buffer) - 1);
  113. 	close(fd);
  114. 	buffer[length] = '\0';
  115. 	if (length == 0)
  116. 		return 2;
  117. 	if (command_flag == 0)
  118. 	{
  119. 		/*
  120. 		 * The command is near the beginning; we don't need to be able to
  121. 		 * the entire stat file.
  122. 		 */
  123. 		p = strchr(buffer, '(');
  124. 		++p;
  125. 		q = strchr(p, ')');
  126. 		length = q - p;
  127. 	}
  128. 	else
  129. 		p = buffer;
  130. 	length = length < COMMANDLEN ? length : COMMANDLEN;
  131. 	strncpy(ion->command, p, length);
  132. 	ion->command[length] = '\0';
  133. 	return 0;
  134. }
  136. struct io_node *
  137. get_ion(int pid)
  138. {
  139. 	struct io_node *c = head;
  141. 	while (c != NULL)
  142. 	{
  143. 		if (c->pid == pid)
  144. 			break;
  145. 		c = c->next;
  146. 	}
  147. 	return c;
  148. }
  150. int
  151. get_tcomm(struct io_node *ion)
  152. {
  153. 	int fd;
  154. 	int length;
  155. 	char filename[BUFFERLEN + 1];
  156. 	char buffer[BUFFERLEN + 1];
  157. 	char *p;
  158. 	char *q;
  160. 	length = snprintf(filename, BUFFERLEN, "%s/%d/stat", PROC, ion->pid);
  161. 	if (length == BUFFERLEN)
  162. 		printf("WARNING - filename length may be too big for buffer: %d\n",
  163. 				__LINE__);
  164. 	fd = open(filename, O_RDONLY);
  165. 	if (fd == -1)
  166. 		return 1;
  167. 	length = read(fd, buffer, sizeof(buffer) - 1);
  168. 	close(fd);
  169. 	/*
  170. 	 * The command is near the beginning; we don't need to be able to
  171. 	 * the entire stat file.
  172. 	 */
  173. 	p = strchr(buffer, '(');
  174. 	++p;
  175. 	q = strchr(p, ')');
  176. 	length = q - p;
  177. 	length = length < BUFFERLEN ? length : BUFFERLEN;
  179. 	strncpy(ion->command, p, length);
  180. 	ion->command[length] = '\0';
  181. 	return 0;
  182. }
  184. struct io_node *
  185. insert_ion(struct io_node *ion)
  186. {
  187. 	struct io_node *c;
  188. 	struct io_node *p;
  190. 	/* Check the head of the list as a special case. */
  191. 	if (ion->pid < head->pid)
  192. 	{
  193. 		ion->next = head;
  194. 		head = ion;
  195. 		return head;
  196. 	}
  198. 	c = head->next;
  199. 	p = head;
  200. 	while (c != NULL)
  201. 	{
  202. 		if (ion->pid < c->pid)
  203. 		{
  204. 			ion->next = c;
  205. 			p->next = ion;
  206. 			return head;
  207. 		}
  208. 		p = c;
  209. 		c = c->next;
  210. 	}
  212. 	/* Append to the end of the list. */
  213. 	if (c == NULL)
  214. 		p->next = ion;
  216. 	return head;
  217. }
  219. void
  220. get_stats()
  221. {
  222. 	DIR *dir = opendir(PROC);
  223. 	struct dirent *ent;
  224. 	char filename[BUFFERLEN + 1];
  225. 	char buffer[BUFFERLEN + 1];
  227. 	char value[BUFFERLEN + 1];
  229. 	/* Display column headers. */
  230. 	if (hr_flag == 1)
  231. 		printf("%5s %5s %5s %8s %8s %5s %6s %7s %s\n", "pid", "rchar", "wchar",
  232. 				"syscr", "syscw", "reads", "writes", "cwrites", "command");
  233. 	else if (kb_flag == 1)
  234. 		printf("%5s %8s %8s %8s %8s %8s %8s %8s %s\n", "pid", "rchar", "wchar",
  235. 				"syscr", "syscw", "rkb", "wkb", "cwkb", "command");
  236. 	else if (mb_flag == 1)
  237. 		printf("%5s %8s %8s %8s %8s %8s %8s %8s %s\n", "pid", "rchar", "wchar",
  238. 				"syscr", "syscw", "rmb", "wmb", "cwmb", "command");
  239. 	else
  240. 		printf("%5s %8s %8s %8s %8s %8s %8s %8s %s\n", "pid", "rchar", "wchar",
  241. 				"syscr", "syscw", "rbytes", "wbytes", "cwbytes", "command");
  243. 	/* Loop through the process table and display a line per pid. */
  244. 	while ((ent = readdir(dir)) != NULL)
  245. 	{
  246. 		int rc;
  247. 		int fd;
  248. 		int length;
  250. 		char *p;
  251. 		char *q;
  253. 		struct io_node *ion;
  254. 		struct io_node *old_ion;
  256. 		long long rchar;
  257. 		long long wchar;
  258. 		long long syscr;
  259. 		long long syscw;
  260. 		long long read_bytes;
  261. 		long long write_bytes;
  262. 		long long cancelled_write_bytes;
  264. 		if (!isdigit(ent->d_name[0]))
  265. 			continue;
  267. 		ion = new_ion(ent->d_name);
  269. 		if (command_flag == 1)
  270. 			rc = get_cmdline(ion);
  271. 		if (command_flag == 0 || rc != 0)
  272. 			/* If the full command line is not asked for or is empty... */
  273. 			rc = get_tcomm(ion);
  275. 		if (rc != 0)
  276. 		{
  277. 			free(ion);
  278. 			continue;
  279. 		}
  281. 		/* Read 'io' file. */
  282. 		length = snprintf(filename, BUFFERLEN, "%s/%s/io", PROC, ent->d_name);
  283. 		if (length == BUFFERLEN)
  284. 			printf("WARNING - filename length may be too big for buffer: %d\n",
  285. 					__LINE__);
  286. 		fd = open(filename, O_RDONLY);
  287. 		if (fd == -1)
  288. 		{
  289. 			free(ion);
  290. 			continue;
  291. 		}
  292. 		length = read(fd, buffer, sizeof(buffer) - 1);
  293. 		close(fd);
  294. 		buffer[length] = '\0';
  296. 		/* Parsing the io file data. */
  297. 		p = buffer;
  298. 		GET_VALUE(ion->rchar);
  299. 		GET_VALUE(ion->wchar);
  300. 		GET_VALUE(ion->syscr);
  301. 		GET_VALUE(ion->syscw);
  302. 		GET_VALUE(ion->read_bytes);
  303. 		GET_VALUE(ion->write_bytes);
  304. 		GET_VALUE(ion->cancelled_write_bytes);
  306. 		old_ion = get_ion(ion->pid);
  308. 		/* Display the pid's io data. */
  309. 		if (old_ion != NULL)
  310. 		{
  311. 			rchar = ion->rchar - old_ion->rchar;
  312. 			wchar = ion->wchar - old_ion->wchar;
  313. 			syscr = ion->syscr - old_ion->syscr;
  314. 			syscw = ion->syscw - old_ion->syscw;
  315. 			read_bytes = ion->read_bytes - old_ion->read_bytes;
  316. 			write_bytes = ion->write_bytes - old_ion->write_bytes;
  317. 			cancelled_write_bytes = ion->cancelled_write_bytes -
  318. 					old_ion->cancelled_write_bytes;
  320. 			if (kb_flag == 1 && hr_flag == 0)
  321. 			{
  322. 				rchar = BTOKB(rchar);
  323. 				wchar = BTOKB(wchar);
  324. 				syscr = BTOKB(syscr);
  325. 				syscw = BTOKB(syscw);
  326. 				read_bytes = BTOKB(read_bytes);
  327. 				write_bytes = BTOKB(write_bytes);
  328. 				cancelled_write_bytes = BTOKB(cancelled_write_bytes);
  329. 			}
  330. 			else if (mb_flag == 1 && hr_flag == 0)
  331. 			{
  332. 				rchar = BTOMB(rchar);
  333. 				wchar = BTOMB(wchar);
  334. 				syscr = BTOMB(syscr);
  335. 				syscw = BTOMB(syscw);
  336. 				read_bytes = BTOMB(read_bytes);
  337. 				write_bytes = BTOMB(write_bytes);
  338. 				cancelled_write_bytes = BTOMB(cancelled_write_bytes);
  339. 			}
  341. 			if (!(idle_flag == 1 && rchar == 0 && wchar == 0 && syscr == 0 &&
  342. 					syscw == 0 && read_bytes == 0 && write_bytes == 0 &&
  343. 					cancelled_write_bytes == 0)) {
  344. 				if (hr_flag == 0)
  345. 					printf("%5d %8lld %8lld %8lld %8lld %8lld %8lld %8lld %s\n",
  346. 							ion->pid,
  347. 							rchar,
  348. 							wchar,
  349. 							syscr,
  350. 							syscw,
  351. 							read_bytes,
  352. 							write_bytes,
  353. 							cancelled_write_bytes,
  354. 							ion->command);
  355. 				else
  356. 					printf("%5d %5s %5s %8lld %8lld %5s %6s %7s %s\n",
  357. 							ion->pid,
  358. 							format_b(rchar),
  359. 							format_b(wchar),
  360. 							syscr,
  361. 							syscw,
  362. 							format_b(read_bytes),
  363. 							format_b(write_bytes),
  364. 							format_b(cancelled_write_bytes),
  365. 							ion->command);
  366. 			}
  367. 		}
  368. 		else if (idle_flag != 1)
  369. 			/*
  370. 			 * No previous data, show 0's instead of calculating negatives
  371. 			 * only if we are shoring idle processes.
  372. 			 */
  373. 			printf("%5d %8d %8d %8d %8d %8d %8d %8d %s\n",
  374. 					ion->pid, 0, 0, 0, 0, 0, 0, 0, ion->command);
  376. 		upsert_data(ion);
  377. 	}
  378. 	closedir(dir);
  379. 	return;
  380. }
  382. struct io_node *
  383. new_ion(char *pid)
  384. {
  385. 	struct io_node *ion;
  387. 	ion = (struct io_node *) malloc(sizeof(struct io_node));
  388. 	bzero(ion, sizeof(struct io_node));
  389. 	ion->pid = atoi(pid);
  391. 	return ion;
  392. }
  394. void
  395. upsert_data(struct io_node *ion)
  396. {
  397. 	struct io_node *n;
  399. 	/* List is empty. */
  400. 	if (head == NULL)
  401. 	{
  402. 		head = ion;
  403. 		return;
  404. 	}
  406. 	/* Check if we have seen this pid before. */
  407. 	n = head;
  408. 	while (n != NULL)
  409. 	{
  410. 		if (n->pid == ion->pid)
  411. 		{
  412. 			n->rchar = ion->rchar;
  413. 			n->wchar = ion->wchar;
  414. 			n->syscr = ion->syscr;
  415. 			n->syscw = ion->syscw;
  416. 			n->read_bytes = ion->read_bytes;
  417. 			n->write_bytes = ion->write_bytes;
  418. 			n->cancelled_write_bytes = ion->cancelled_write_bytes;
  419. 			/*
  420. 			 * If the pids wrap, then the command may be different then before.
  421. 			 */
  422. 			strcpy(n->command, ion->command);
  423. 			free(ion);
  424. 			return;
  425. 		}
  426. 		n = n->next;
  427. 	}
  429. 	/* Add this pid to the list. */
  430. 	head = insert_ion(ion);
  431. 	return;
  432. }
  434. void
  435. usage()
  436. {
  437. 	printf("usage: iopp -h|--help\n");
  438. 	printf("usage: iopp [-ci] [-k|-m] [delay [count]]\n");
  439. 	printf("            -c, --command display full command line\n");
  440. 	printf("            -h, --help display help\n");
  441. 	printf("            -i, --idle hides idle processes\n");
  442. 	printf("            -k, --kilobytes display data in kilobytes\n");
  443. 	printf("            -m, --megabytes display data in megabytes\n");
  444. 	printf("            -u, --human-readable display data in kilo-, mega-, or giga-bytes\n");
  445. }
  447. int
  448. main(int argc, char *argv[])
  449. {
  450. 	int c;
  452. 	int delay = 0;
  453. 	int count = 0;
  454. 	int max_count = 1;
  456. 	while (1)
  457. 	{
  458. 		int option_index = 0;
  459. 		static struct option long_options[] = {
  460. 				{ "command", no_argument, 0, 'c' },
  461. 				{ "help", no_argument, 0, 'h' },
  462. 				{ "human-readable", no_argument, 0, 'u' },
  463. 				{ "idle", no_argument, 0, 'i' },
  464. 				{ "kilobytes", no_argument, 0, 'k' },
  465. 				{ "megabytes", no_argument, 0, 'm' },
  466. 				{ 0, 0, 0, 0 }
  467. 		};
  469. 		c = getopt_long(argc, argv, "chikmu", long_options, &option_index);
  470. 		if (c == -1)
  471. 		{
  472. 			/* Handle delay and count arguments. */
  474. 			if (argc == optind)
  475. 				break; /* No additional arguments. */
  476. 			else if ((argc - optind) == 1)
  477. 			{
  478. 				delay = atoi(argv[optind]);
  479. 				max_count = -1;
  480. 			}
  481. 			else if ((argc - optind) == 2)
  482. 			{
  483. 				delay = atoi(argv[optind]);
  484. 				max_count = atoi(argv[optind + 1]);
  485. 			}
  486. 			else
  487. 			{
  488. 				/* Too many additional arguments. */
  489. 				usage();
  490. 				return 3;
  491. 			}
  492. 			break;
  493. 		}
  495. 		switch (c)
  496. 		{
  497. 		case 'c':
  498. 			command_flag = 1;
  499. 			break;
  500. 		case 'h':
  501. 			usage();
  502. 			return 0;
  503. 		case 'i':
  504. 			idle_flag = 1;
  505. 			break;
  506. 		case 'k':
  507. 			kb_flag = 1;
  508. 			break;
  509. 		case 'm':
  510. 			mb_flag = 1;
  511. 			break;
  512. 		case 'u':
  513. 			hr_flag = 1;
  514. 			break;
  515. 		default:
  516. 			usage();
  517. 			return 2;
  518. 		}
  519. 	}
  521. 	while (max_count == -1 || count++ < max_count)
  522. 	{
  523. 		get_stats();
  524. 		if (count != max_count)
  525. 			sleep(delay);
  526. 	}
  527. 	return 0;
  528. }
然后放到服务器上，gcc -o iopp iopp.c 编译一下

运行  ./iopp -i -k -c 1 > io.log 这个命令就可以把实时的io信息打印出来啦

打印出来的各项含义：

  • pid 进程ID
  • rchar 将要从磁盘读取的字节数
  • wchar 已经写入或应该要写入磁盘的字节数
  • syscr 读I/O数
  • syscw 写I/O数
  • rbytes 真正从磁盘读取的字节数
  • wbytes 真正写入到磁盘的字节数
  • cwbytes 因为清空页面缓存而导致没有发生操作的字节数
  • command 执行的命令

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： 点点阅 > 《linux内核》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多