Parsing /proc psinfo and argv returns: Value too large for defined data type error

Question

I have a fairly simple code below for processing /proc/* files in solaris to obtain process information and arguments. For the most part it works (meaning it does present arguments correctly on some processes), but on some process arguments (particularly where they are long), it fails and produces the error Value too large for defined data type

Does anyone have any idea perhaps why it fails?

It is the pread() line for the arguments array that fails at line 108.

It is actually some java processes with many arguments where it fails if that helps.

What's interesting too is that:

1. examining the binary /proc/<pid>/psinfo file, it is very small--the size is clearly not sufficient to contain the kind of long arguments that I am looking at with some processes. Doing hex dump of the contents of the psinfo file confirms that they are not there.

2. the value of pr_argv when there are long arguments is zero.

3. On further digging, it looks like the arguments are in /proc/(pid)/object/tmpfs.394.2.71404854. I wonder why.

Code:

#include <dirent.h>
#include <ctype.h>
#include <assert.h>
#include <malloc.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/processor.h>
#include <sys/sysinfo.h>
#include <sys/param.h>

#include <kstat.h>
#include <procfs.h>

#define PROC_ERRNO ((errno == ENOENT) ? ESRCH : errno)

#define my_pread(fd, ptr, type, offset) \
    (pread(fd, ptr, sizeof(type), offset) == sizeof(type))

static int proc_psinfo_get(psinfo_t *psinfo, pid_t pid)
{
    int fd, retval = 0;
    char buffer[BUFSIZ];

    sprintf(buffer, "/proc/%d/psinfo", pid);

    if ((fd = open(buffer, O_RDONLY)) < 0) {
        return ESRCH;
    }

    if (!my_pread(fd, psinfo, psinfo_t, 0)) {
        retval = errno;
    }

    close(fd);

    return retval;
}

int main(int argc, char **argv)
{
    DIR *dirp = opendir("/proc");
    struct dirent *ent;
    char *models[] = {
        "unknown", "32bit", "64bit"
    };

    while ((ent = readdir(dirp))) {
        pid_t pid;
        psinfo_t psinfo;
        int retval;
        char buffer[BUFSIZ];
        char *argvb[56];
        char **argvp = argvb;

        int n, fd;
        size_t nread = 0;
        unsigned int argv_size;

        if (!isdigit(*ent->d_name)) {
            continue;
        }
        psinfo.pr_dmodel = 0;
        pid = strtoul(ent->d_name, NULL, 10);
        retval = proc_psinfo_get(&psinfo, pid);
        printf("---------------------------------\n");
        printf("pid=%d, status=%s, model=%s\n",
               pid, retval ? strerror(retval) : "OK",
               models[psinfo.pr_dmodel]);

        printf("Parent Pid: %ld\n", psinfo.pr_ppid);
    printf("UID: %ld\n", psinfo.pr_uid);
    printf("size: %ld\n", psinfo.pr_size);
    printf("rss: %ld\n", psinfo.pr_rssize);

        printf("pcpu: %d\n", psinfo.pr_pctcpu);
    printf("pctmem: %d\n", psinfo.pr_pctmem);
    printf("zoneid: %d\n", psinfo.pr_zoneid);

    printf("pr_sname: %c\n", psinfo.pr_lwp.pr_sname);

    printf("Up Start: (%ld, %ld)\n", psinfo.pr_start.tv_sec, psinfo.pr_start.tv_nsec);
        printf("Command: %s\n", psinfo.pr_fname);

    // print argc
        argv_size = sizeof(*argvp) * psinfo.pr_argc;
        sprintf(buffer, "/proc/%d/as", pid);
        printf("argc=%d, argv_size=%d\n",
               psinfo.pr_argc, argv_size);

        if ((fd = open(buffer, O_RDONLY)) < 0) {
            printf("open(%s) == %s\n",
                   buffer, strerror(PROC_ERRNO));
            if (argvp != argvb) {
                free(argvp);
            }
            continue;
        }

        if (argv_size > sizeof(argvb)) {
            argvp = malloc(argv_size);
        }

        if ((long int)(nread = pread(fd, argvp, argv_size, (off_t)psinfo.pr_argv)) <= 0) {
            close(fd);
        printf("error in reading argvp\n");
            printf("   pread(%d, 0x%lx, %d, 0x%lx) == %d (%s)\n",
                   fd, (unsigned long)argvp, argv_size,
                   (unsigned long)psinfo.pr_argv,
                   nread, strerror(errno));
            continue;
        }

    // parse the args here
        for (n = 0; n < psinfo.pr_argc; n++) {
            int alen;
            char *arg;

            if ((long int)(nread = pread(fd, buffer, sizeof(buffer), (off_t)argvp[n])) <= 0) {
                close(fd);
        printf("buffer %d   argvp as ld %ld   argvp as lu %lu ", sizeof(buffer), argvp[n] , argvp[n] );
                printf("   %-2d) pread(%d, 0x%lx, %d, 0x%lx) == %d (%s)\n",
                       n, fd, (unsigned long)&buffer[0], sizeof(buffer),
                       (unsigned long)argvp[n],
                       nread, strerror(errno));
                break;
            }

            printf("   %-2d) nread=%-4d, ", n, nread);
            fflush(stdout);
            alen = strlen(buffer)+1;
            printf(" alen=%-4d ", alen);
            fflush(stdout);
            arg = malloc(alen);
            memcpy(arg, buffer, alen);
            printf(" {%s}\n", arg);
            fflush(stdout);
        }

        if (argvp != argvb) {
            free(argvp);
        }

        close(fd);
    }

    closedir(dirp);

    return 0;
}

Answer 1

You're trying to read from a starting position past the end of the file.

From the pread man page:

ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);

...

EOVERFLOW

The file is a regular file, nbyte is greater than 0, the starting position is before the end-of-file, and the starting position is greater than or equal to the offset maximum established in the open file description associated with fildes.