Dyson

#ifdef __sun__

#define __EXTENSIONS__

/* PATH_MAX */

#include <limits.h>

#include <sys/ucontext.h>

#include <procfs.h>

#include <fcntl.h>

#include <sys/types32.h>

#include <assert.h>

#define va_list __va_list

#include <procfs.h>

#endif

#ifndef __sun__

#include <mntent.h>

#endif

#ifdef __sun__

const char* checkProc = "/proc/0";

#else

const char* checkProc = "/proc/version";

#endif

if (stat(checkProc, &st) < 0 && errno == ENOENT) {

if (stat(checkProc, &st) < 0) {

#ifdef __sun__

void init_nfs(void) { }

#else

#endif /* not __sun__ */

#ifdef __sun__

static int openProcFile(const char* format, int pid)

{

char procfile[100];

snprintf(procfile, 100, format, pid);

int fd;

if ((fd = open(procfile, O_RDONLY)) < 0) {

fprintf(stderr, "Error opening %s", procfile);

perror(" ");

exit(1);

}

return fd;

}

static int readStringFromAs(int asFd, uint64_t offset, char** strOut, int strOutSize)

{

char* initStr = *strOut;

if (pread(asFd, initStr, strOutSize, offset) < 0) {

return 0;

}

initStr[strOutSize] = '\0';

int length = strlen(initStr);

if (length == strOutSize) {

// need a bigger buffer.

strOutSize *= 2;

*strOut = realloc(initStr, strOutSize);

assert(*strOut);

return readStringFromAs(asFd, offset, strOut, strOutSize);

}

return length;

}

static char* getArguments(psinfo_t* psinfo)

{

int asFd = openProcFile("/proc/%d/as", psinfo->pr_pid);

uintptr_t addrArgs = psinfo->pr_argv;

int argCount = psinfo->pr_argc;

// argPointers point to the arguments in the process's memory space.

// args point to the copies of them in our memory space.

uintptr_t* argPointers = malloc(argCount * sizeof(uintptr_t));

char** args = malloc(argCount * sizeof(uintptr_t));

assert(argPointers && args);

if (psinfo->pr_dmodel == PR_MODEL_NATIVE) {

pread(asFd, argPointers, argCount * sizeof(uintptr_t), addrArgs);

} else {

// we are 64-bit, target is 32-bit

caddr32_t* argPointers32 = (caddr32_t*) argPointers;

pread(asFd, argPointers32, argCount * sizeof(caddr32_t), addrArgs);

// convert from 32-bit to 64-bit in place

for (int i = argCount - 1; i >= 0; --i) {

argPointers[i] = argPointers32[i];

}

}

int totalLength = 0;

for (int i = 0; i < argCount; i++) {

char* arg = malloc(16);

assert(arg);

totalLength += readStringFromAs(asFd, argPointers[i], &arg, 16);

args[i] = arg;

}

close(asFd);

// Merge everything into one buffer representing a list of null terminated strings.

char* out = malloc(totalLength + argCount + 4);

assert(out);

memcpy(out, &argCount, 4);

int index = 4;

for (int i = 0; i < argCount; i++) {

int length = strlen(args[i]);

memcpy(out + index, args[i], length+1);

index += length+1;

free(args[i]);

}

free(argPointers);

return out;

}

static char* baseName(char* name)

{

if (!name) { return NULL; }

char* base = strrchr(name, '/');

return (base) ? base+1 : name;

}

static void getNfsInodeNumberAndDevice(int do_stat, psinfo_t* psinfo, struct proc* procOut)

{

char path[PATH_MAX+1];

snprintf(path, sizeof(path), "/proc/%d/path/a.out", psinfo->pr_pid);

procOut->nfs = 0;

if (do_stat == DO_NETFS) {

char buff[PATH_MAX+1];

procOut->nfs = check4nfs(path, buff);

} else if (do_stat != DO_STAT) {

return;

}

struct stat st = { .st_dev = 0 };

if (stat(path, &st)) { fprintf(stderr, "Failed to stat [%s]\n", path); }

procOut->dev = st.st_dev;

procOut->ino = st.st_ino;

}

static void getProcInfo(int pid, int do_stat, struct proc* procOut)

{

psinfo_t psinfo;

{

int psinfoFd = openProcFile("%d/psinfo", pid);

read(psinfoFd, &psinfo, sizeof(psinfo_t));

close(psinfoFd);

}

// argv0, argv1

procOut->argv0 = procOut->argv1 = NULL;

{

char* args = getArguments(&psinfo);

int argCount;

memcpy(&argCount, args, 4);

char* argv = args+4;

for (int i = 0; i < argCount; i++) {

if (i == 0) {

procOut->argv0 = strdup(argv);

assert(procOut->argv0);

} else if (argv[0] != '-') {

procOut->argv1 = strdup(argv);

assert(procOut->argv1);

break;

}

argv += strlen(argv) + 1;

}

free(args);

}

// argv0base, argv1base

procOut->argv0base = baseName(procOut->argv0);

procOut->argv1base = baseName(procOut->argv1);

// statname is compared to argv1base used to decide if it's executing a script.

procOut->statname = strdup(psinfo.pr_fname);

// Is it a kernel thread or zombie.

// Linux detects this by checking the upper and lower bounds of the address space.

// From some basic testing I see that Illumos sets the size of obvious kernel threads

// such as sched to 0 so we'll assume that kernel threads are defined by image size

// being zero.

procOut->kernel = (psinfo.pr_size == 0);

if (!procOut->kernel) {

// nfs, ino, dev

getNfsInodeNumberAndDevice(do_stat, &psinfo, procOut);

}

procOut->pid = psinfo.pr_pid;

procOut->sid = psinfo.pr_sid;

}

void freeProcList()

{

PROC* p;

PROC* n = plist;

for (p = plist; n; p = n) {

n = p->next;

if (p->argv0) { free(p->argv0); }

if (p->argv1) { free(p->argv1); }

if (p->statname) { free(p->statname); }

free(p);

}

plist = NULL;

}

int readproc(int do_stat)

{

/* Open the /proc directory. */

if (chdir("/proc") == -1) {

nsyslog(LOG_ERR, "chdir /proc failed");

return -1;

}

DIR* procDir;

if ((procDir = opendir(".")) == NULL) {

nsyslog(LOG_ERR, "cannot opendir(/proc)");

return -1;

}

/* Free the already existing process list. */

freeProcList();

/* Walk through the directory. */

struct dirent* d;

while ((d = readdir(procDir)) != NULL) {

/* See if this is a process */

int pid;

if ((pid = atoi(d->d_name)) == 0) { continue; }

/* Get a PROC struct . */

PROC* p = xmalloc(sizeof(PROC));

memset(p, 0, sizeof(PROC));

getProcInfo(pid, do_stat, p);

/* Link it into the list. */

p->next = plist;

plist = p;

}

closedir(procDir);

/* Done. */

return 0;

}

#else /* __sun__ */

#endif /* not __sun__ */