如何在c中重复读取FILE的同一行？

Question

I want to monitor a file that keeps changing a specific line. Specifically, I am monitoring a processes memory usage in /proc/[PID]/smaps.

Right now, I check smaps with:

fp = popen("/bin/cat /proc/19596/smaps | grep stack --after-context=1", "r");
 if (fp == NULL) {
   printf("Failed to run command\n" );
   exit;
 }

 /* Read the output a line at a time - output it. */
 while(1){
    while (fgets(path, sizeof(path)-1, fp) != NULL) {
      printf("%s", path);
    }
 }
 /* close */
 pclose(fp);

but this is not updating. How can I keep printing out the lines of the file as they open? Do I need to close the file each time or is there a faster way?

Answer 1

/proc/ is a Linux specific filesystem made of pseudo-files, which you should access sequentially. See proc(5) .

So in practice, you need to reopen that /proc/19596/smaps file. Read it is very quick and does not involve any disk I/O! It is about as fast as reading from a pipe(7) .

You are wrong in using popen (with a useless use of cat ). You should better open (using fopen(3) ) the /proc/19596/smaps file, loop on reading every line (eg using fgets(3) ), comparing it (using eg strstr(3) ) with "stack" literal string, and reading the next line, and finally fclose it immediately after.

BTW, if your process 19596 happens to have several threads, I am not sure that you are measuring a meaningful stack size.

Answer 2

Honestly speaking I don't see why you want to do this in C.

#define _XOPEN_SOURCE 500

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>

#include <getopt.h>
#include <unistd.h>

enum { ERR = -1 };

static int s_running = 1;

static void sigintHandler(int s) {
    (void)s;
    s_running = 0;
}

int main(int argc, char *argv[]) {
    int pid = -1, sleepMsec = 1000;
    char optchr, buf[260];
    FILE *fp;

    signal(SIGINT, sigintHandler);

    while (ERR != (optchr = getopt(argc, argv, "p:s:"))) {
        switch (optchr) {
            case 'p': pid = strtol(optarg, NULL, 0); break;
            case 's': sleepMsec = strtol(optarg, NULL, 0); break;
            default:
                fprintf(stderr, "USAGE: smap -p pid [-s msec]\n");
                return -10;
        }
    }

    snprintf(buf, sizeof buf, "/proc/%d/smaps", pid);
    buf[sizeof buf - 1] = '\0';
    fp = fopen(buf, "r");
    if (NULL == fp) {
        char buf1[sizeof buf];
        snprintf(buf1, sizeof buf1, "fopen for [%s]", buf);
        buf1[sizeof buf1 - 1] = '\0';
        perror(buf1);
        return -20;
    }

    for (;;) {
        if (ERR == fseek(fp, 0, SEEK_SET)) {
            perror("fseek(3)");
            return -30;
        }
        while (fgets(buf, sizeof buf, fp)) {
            if (strstr(buf, "stack")) {
                printf("%s", buf);
                if ( ! fgets(buf, sizeof buf, fp)) {
                    fprintf(stderr, "fgets(3) found EOF\n");
                    return -40;
                }
                printf("%s", buf);
            }
        }
        usleep(1000 * sleepMsec);
        if ( ! s_running)
            break;
    }

    printf("Bye!\n");
    return 0;
}

I recommend you to use scripting languages such as Python for this kind of task.

#! /usr/bin/env python

from __future__ import print_function

import time
import sys
import getopt


def main(args):
    pid = -1
    sleepMsec = 1000
    opts, _ = getopt.getopt(args, "p:s:")
    for (k,a) in opts:
        if "-p" == k:
            pid = int(a)
        elif "-s" == k:
            sleepMsec = int(a)

    try:
        with open("/proc/{}/smaps".format(pid)) as fp:
            while True:
                fp.seek(0)
                while True:
                    line = fp.readline()
                    if not line:
                        break
                    if 0 <= line.find("stack0"):
                        print(line, fp.readline(), sep='', end='')
                        break
                time.sleep(1e-3 * sleepMsec)
    except KeyboardInterrupt:
        print("Bye!")

if "__main__" == __name__:
    main(sys.argv[1: ])

Combination of Bash and standard Linux commands is an option, too. Indeed you already used grep for your initial version.

Note that you cannot use fseek(3) against a pipe (it's a stream in a strict sense) but the /proc/PID/smaps pseudo-filesystem supports it.

• http://lxr.free-electrons.com/source/fs/proc/task_mmu.c#L657

Answer 3

Not sure if this works optimally with the files in /proc but you can use Linux's inotify system to have the kernel notify you of changes on watched files so that you don't have to poll. You can access the system in C, but trying it out in the shell by using the inotifywait tool should be a good starting point (the following should be way more efficient than the C code in your question).

pid=19596
file=/proc/$pid/smaps
cmd="grep stack --after-context=1"
while intofitywait -e modify "$file"; do $cmd "$file"; done