Stefan Fiedler
19 years ago
4 changed files with 980 additions and 50 deletions
Split View
Diff Options
-
+223 -0misc/tools-source/fd_tracker.c
-
+155 -39misc/tools-source/fl_wrapper.c.sh
-
+234 -0misc/tools-source/fl_wrapper_close.c
-
+368 -11misc/tools-source/fl_wrapper_open.c
@ -0,0 +1,223 @@ |
|||
|
|||
/* |
|||
TODO: |
|||
get rid of the compiler warnings: |
|||
|
|||
fl_wrapper.c: In function '_Exit': |
|||
fl_wrapper.c:1100: warning: 'noreturn' function does return |
|||
fl_wrapper.c: In function '_exit': |
|||
fl_wrapper.c:1075: warning: 'noreturn' function does return |
|||
fl_wrapper.c: In function 'exit': |
|||
fl_wrapper.c:1050: warning: 'noreturn' function does return |
|||
|
|||
maybe TODO: |
|||
wrape clone(); catch termination of child process created with clone() |
|||
*/ |
|||
|
|||
# if FD_TRACKER == 1 |
|||
|
|||
/* |
|||
|
|||
Whenever a new file descriptor is opened, it will/should be added to the |
|||
fl_wrapper-internal register, together with its current file status. |
|||
Accordingly, when a file descriptor is closed, it will be removed from this |
|||
register, and handle_file_access_after() will be called with the stored |
|||
filename and status. |
|||
*/ |
|||
|
|||
struct pid_reg |
|||
{ |
|||
pid_t id; |
|||
int executed; |
|||
struct fd_reg *fd_head; |
|||
struct pid_reg *next; |
|||
}; |
|||
|
|||
struct pid_reg *pid_head = 0; |
|||
|
|||
struct fd_reg |
|||
{ |
|||
int fd; |
|||
int closed; |
|||
struct status_t status; |
|||
char *filename; |
|||
struct fd_reg *next; |
|||
}; |
|||
|
|||
void add_pid(pid_t pid) |
|||
{ |
|||
struct pid_reg *newpid = malloc(sizeof(struct pid_reg)); |
|||
|
|||
newpid->id = pid; |
|||
newpid->fd_head = 0; |
|||
newpid->executed = 0; |
|||
|
|||
newpid->next = pid_head; |
|||
pid_head = newpid; |
|||
|
|||
# if DEBUG == 1 |
|||
if (debug) fprintf(stderr, "fl_wrapper.so debug [%d]: PID %d added.\n", |
|||
getpid(), pid); |
|||
# endif |
|||
} |
|||
|
|||
void add_fd(struct pid_reg *pid, int fd, const char *filename, struct status_t *status) |
|||
{ |
|||
struct fd_reg *newfd = malloc(sizeof(struct fd_reg)); |
|||
|
|||
newfd->fd = fd; |
|||
newfd->closed = 0; |
|||
newfd->status = *status; |
|||
newfd->filename = strdup(filename); |
|||
|
|||
newfd->next = pid->fd_head; |
|||
pid->fd_head = newfd; |
|||
|
|||
# if DEBUG == 1 |
|||
if (debug) fprintf(stderr, "fl_wrapper.so debug [%d]: fd %d (%s) added.\n", |
|||
getpid(), fd, filename); |
|||
# endif |
|||
} |
|||
|
|||
void remove_fd(struct fd_reg **fd); |
|||
|
|||
void remove_pid(struct pid_reg **pid) |
|||
{ |
|||
struct pid_reg *tmp = *pid; |
|||
struct fd_reg **fd_iter = &(*pid)->fd_head; |
|||
|
|||
# if DEBUG == 1 |
|||
if (debug) fprintf(stderr, "fl_wrapper.so debug [%d]: PID %d removed.\n", |
|||
getpid(), (*pid)->id); |
|||
# endif |
|||
|
|||
while (*fd_iter) remove_fd(fd_iter); |
|||
*pid = (*pid)->next; |
|||
free(tmp); |
|||
} |
|||
|
|||
void remove_fd(struct fd_reg **fd) |
|||
{ |
|||
struct fd_reg *tmp = *fd; |
|||
|
|||
# if DEBUG == 1 |
|||
if (debug) fprintf(stderr, "fl_wrapper.so debug [%d]: fd %d (%s) removed.\n", |
|||
getpid(), (*fd)->fd, (*fd)->filename); |
|||
# endif |
|||
|
|||
free((*fd)->filename); |
|||
*fd = (*fd)->next; |
|||
free(tmp); |
|||
} |
|||
|
|||
void deregister_fd(int fd); |
|||
|
|||
struct pid_reg **find_pid(pid_t pid) |
|||
{ |
|||
struct pid_reg **pid_iter = &pid_head; |
|||
|
|||
while (*pid_iter) |
|||
{ |
|||
if ((*pid_iter)->executed) |
|||
{ |
|||
struct fd_reg **fd_iter = &(*pid_iter)->fd_head; |
|||
while (*fd_iter) |
|||
{ |
|||
if ((*fd_iter)->closed) |
|||
{ |
|||
handle_file_access_after("exec*", (*fd_iter)->filename, &(*fd_iter)->status); |
|||
deregister_fd((*fd_iter)->fd); |
|||
|
|||
} |
|||
else fd_iter = &(*fd_iter)->next; |
|||
} |
|||
} |
|||
|
|||
if ((*pid_iter)->fd_head == 0) remove_pid(pid_iter); |
|||
else pid_iter = &(*pid_iter)->next; |
|||
} |
|||
|
|||
pid_iter = &pid_head; |
|||
while (*pid_iter) |
|||
{ |
|||
if ((*pid_iter)->id == pid) break; |
|||
pid_iter = &(*pid_iter)->next; |
|||
} |
|||
|
|||
return pid_iter; |
|||
} |
|||
|
|||
struct fd_reg **find_fd(struct pid_reg *pid, int fd) |
|||
{ |
|||
struct fd_reg **fd_iter = &pid->fd_head; |
|||
while (*fd_iter) |
|||
{ |
|||
if ((*fd_iter)->fd == fd) break; |
|||
fd_iter = &(*fd_iter)->next; |
|||
} |
|||
|
|||
return fd_iter; |
|||
} |
|||
|
|||
void register_fd(int fd, const char *filename, struct status_t *status) |
|||
{ |
|||
struct pid_reg *pid_iter = *find_pid(getpid()); |
|||
if (pid_iter == 0) |
|||
{ |
|||
add_pid(getpid()); |
|||
pid_iter = pid_head; |
|||
} |
|||
|
|||
struct fd_reg *fd_iter = *find_fd(pid_iter, fd); |
|||
if (fd_iter == 0) |
|||
{ |
|||
add_fd(pid_iter, fd, filename, status); |
|||
} else { |
|||
# if DEBUG == 1 |
|||
if (debug) fprintf(stderr, "fl_wrapper.so debug [%d]: fd %d already registered (is %s, was %s).\n", |
|||
getpid(), fd, filename, fd_iter->filename); |
|||
# endif |
|||
free(fd_iter->filename); |
|||
fd_iter->filename = strdup(filename); |
|||
fd_iter->status = *status; |
|||
} |
|||
} |
|||
|
|||
/* removes fd from register, returning its filename and status via filename |
|||
and status arguments. |
|||
*/ |
|||
void deregister_fd(int fd) |
|||
{ |
|||
struct pid_reg **pid_iter = find_pid(getpid()); |
|||
if (*pid_iter) |
|||
{ |
|||
struct fd_reg **fd_iter = find_fd(*pid_iter, fd); |
|||
if (*fd_iter) |
|||
{ |
|||
remove_fd(fd_iter); |
|||
if ((*pid_iter)->fd_head == 0) remove_pid(pid_iter); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void copy_fds(pid_t parent, pid_t child) |
|||
{ |
|||
struct pid_reg *pid_iter = *find_pid(parent); |
|||
if (pid_iter) |
|||
{ |
|||
struct fd_reg *fd_iter = pid_iter->fd_head; |
|||
|
|||
add_pid(child); |
|||
struct fd_reg **nextfd = &pid_head->fd_head; |
|||
|
|||
while (fd_iter) |
|||
{ |
|||
*nextfd = malloc(sizeof(struct fd_reg)); |
|||
**nextfd = *fd_iter; |
|||
nextfd = &(*nextfd)->next; |
|||
fd_iter = fd_iter->next; |
|||
} |
|||
} |
|||
} |
|||
|
|||
# endif |
|||
@ -0,0 +1,234 @@ |
|||
extern int close(int fd); |
|||
int (*orig_close)(int fd) = 0; |
|||
|
|||
int close(int fd) |
|||
{ |
|||
int old_errno=errno; |
|||
int rc; |
|||
|
|||
if (!orig_close) orig_close = get_dl_symbol("close"); |
|||
# if DEBUG == 1 |
|||
if (debug) fprintf(stderr, "fl_wrapper.so debug [%d]: going to run original close(%d) at %p (wrapper is at %p).\n", |
|||
getpid(), fd, orig_close, close); |
|||
# endif |
|||
|
|||
errno=old_errno; |
|||
rc = orig_close(fd); |
|||
old_errno=errno; |
|||
|
|||
# if FD_TRACKER == 1 |
|||
if (rc == 0 || errno == EBADF) |
|||
{ |
|||
struct pid_reg *pidreg = *find_pid(getpid()); |
|||
if (pidreg) |
|||
{ |
|||
struct fd_reg *fdreg = *find_fd(pidreg, fd); |
|||
if (fdreg) |
|||
{ |
|||
handle_file_access_after("close", fdreg->filename, &fdreg->status); |
|||
deregister_fd(fd); |
|||
} |
|||
} |
|||
} |
|||
# endif |
|||
|
|||
errno=old_errno; |
|||
return rc; |
|||
} |
|||
|
|||
extern int fclose(FILE* f); |
|||
int (*orig_fclose)(FILE* f) = 0; |
|||
|
|||
int fclose(FILE* f) |
|||
{ |
|||
int old_errno=errno; |
|||
int rc; |
|||
int fd=fileno(f); |
|||
|
|||
if (!orig_fclose) orig_fclose = get_dl_symbol("fclose"); |
|||
# if DEBUG == 1 |
|||
if (debug) fprintf(stderr, "fl_wrapper.so debug [%d]: going to run original fclose(%d) at %p (wrapper is at %p).\n", |
|||
getpid(), fd, orig_fclose, fclose); |
|||
# endif |
|||
|
|||
errno=old_errno; |
|||
rc = orig_fclose(f); |
|||
old_errno=errno; |
|||
|
|||
# if FD_TRACKER == 1 |
|||
if (rc == 0) |
|||
{ |
|||
struct pid_reg *pidreg = *find_pid(getpid()); |
|||
if (pidreg) |
|||
{ |
|||
struct fd_reg *fdreg = *find_fd(pidreg, fd); |
|||
if (fdreg) |
|||
{ |
|||
handle_file_access_after("fclose", fdreg->filename, &fdreg->status); |
|||
deregister_fd(fd); |
|||
} |
|||
} |
|||
} |
|||
# endif |
|||
|
|||
errno=old_errno; |
|||
return rc; |
|||
} |
|||
|
|||
/* |
|||
extern int fcloseall(); |
|||
int (*orig_fcloseall)() = 0; |
|||
|
|||
int fcloseall() |
|||
{ |
|||
int old_errno=errno; |
|||
int rc; |
|||
|
|||
if (!orig_fcloseall) orig_fcloseall = get_dl_symbol("fcloseall"); |
|||
# if DEBUG == 1 |
|||
if (debug) fprintf(stderr, "fl_wrapper.so debug [%d]: going to run original fcloseall() at %p (wrapper is at %p).\n", |
|||
getpid(), orig_fcloseall, fcloseall); |
|||
# endif |
|||
|
|||
errno=old_errno; |
|||
rc = orig_fcloseall(); |
|||
|
|||
return rc; |
|||
} |
|||
*/ |
|||
|
|||
extern int fork(); |
|||
int (*orig_fork)() = 0; |
|||
|
|||
int fork() |
|||
{ |
|||
int old_errno = errno; |
|||
int rc; |
|||
# if FD_TRACKER == 1 |
|||
int caller_pid = getpid(); |
|||
# endif |
|||
|
|||
if (!orig_fork) orig_fork = get_dl_symbol("fork"); |
|||
# if DEBUG == 1 |
|||
if (debug) fprintf(stderr, "fl_wrapper.so debug [%d]: going to run original fork() at %p (wrapper is at %p).\n", |
|||
getpid(), orig_fork, fork); |
|||
# endif |
|||
|
|||
errno = old_errno; |
|||
rc = orig_fork(); |
|||
old_errno = errno; |
|||
|
|||
# if FD_TRACKER == 1 |
|||
if ( rc == 0) copy_fds(caller_pid, getpid()); |
|||
# endif |
|||
|
|||
# if DEBUG == 1 |
|||
struct pid_reg *pid = pid_head; |
|||
while (pid) |
|||
{ |
|||
struct fd_reg *fd = pid->fd_head; |
|||
if (debug) fprintf(stderr, "fl_wrapper.so debug [%d]: fork: found PID %d.\n", |
|||
getpid(), pid->id); |
|||
while (fd) |
|||
{ |
|||
if (debug) fprintf(stderr, "fl_wrapper.so debug [%d]: fork: found fd %d (%s).\n", |
|||
getpid(), fd->fd, fd->filename); |
|||
fd = fd->next; |
|||
} |
|||
pid = pid->next; |
|||
} |
|||
# endif |
|||
|
|||
errno=old_errno; |
|||
return rc; |
|||
} |
|||
|
|||
extern void exit(int status) __attribute__ ((noreturn)); |
|||
void (*orig_exit)(int status) = 0; |
|||
|
|||
void exit(int status) |
|||
{ |
|||
int old_errno = errno; |
|||
|
|||
if (!orig_exit) orig_exit = get_dl_symbol("exit"); |
|||
# if DEBUG == 1 |
|||
if (debug) fprintf(stderr, "fl_wrapper.so debug [%d]: going to run original exit(%d) at %p (wrapper is at %p).\n", |
|||
getpid(), status, orig_exit, exit); |
|||
# endif |
|||
|
|||
# if FD_TRACKER == 1 |
|||
struct pid_reg *pid = *find_pid(getpid()); |
|||
if (pid) |
|||
{ |
|||
struct fd_reg **fd_iter = &pid->fd_head; |
|||
while (*fd_iter) |
|||
{ |
|||
handle_file_access_after("exit", (*fd_iter)->filename, &(*fd_iter)->status); |
|||
deregister_fd((*fd_iter)->fd); |
|||
} |
|||
} |
|||
# endif |
|||
|
|||
errno=old_errno; |
|||
orig_exit(status); |
|||
} |
|||
|
|||
extern void _exit(int status) __attribute__ ((noreturn)); |
|||
void (*orig__exit)(int status) = 0; |
|||
|
|||
void _exit(int status) |
|||
{ |
|||
int old_errno = errno; |
|||
|
|||
if (!orig__exit) orig__exit = get_dl_symbol("_exit"); |
|||
# if DEBUG == 1 |
|||
if (debug) fprintf(stderr, "fl_wrapper.so debug [%d]: going to run original _exit(%d) at %p (wrapper is at %p).\n", |
|||
getpid(), status, orig__exit, _exit); |
|||
# endif |
|||
|
|||
# if FD_TRACKER == 1 |
|||
struct pid_reg *pid = *find_pid(getpid()); |
|||
if (pid) |
|||
{ |
|||
struct fd_reg **fd_iter = &pid->fd_head; |
|||
while (*fd_iter) |
|||
{ |
|||
handle_file_access_after("_exit", (*fd_iter)->filename, &(*fd_iter)->status); |
|||
deregister_fd((*fd_iter)->fd); |
|||
} |
|||
} |
|||
# endif |
|||
|
|||
errno=old_errno; |
|||
orig__exit(status); |
|||
} |
|||
|
|||
extern void _Exit(int status) __attribute__ ((noreturn)); |
|||
void (*orig__Exit)(int status) = 0; |
|||
|
|||
void _Exit(int status) |
|||
{ |
|||
int old_errno = errno; |
|||
|
|||
if (!orig__Exit) orig__Exit = get_dl_symbol("_Exit"); |
|||
# if DEBUG == 1 |
|||
if (debug) fprintf(stderr, "fl_wrapper.so debug [%d]: going to run original _Exit(%d) at %p (wrapper is at %p).\n", |
|||
getpid(), status, orig__Exit, _Exit); |
|||
# endif |
|||
|
|||
# if FD_TRACKER == 1 |
|||
struct pid_reg *pid = *find_pid(getpid()); |
|||
if (pid) |
|||
{ |
|||
struct fd_reg **fd_iter = &pid->fd_head; |
|||
while (*fd_iter) |
|||
{ |
|||
handle_file_access_after("_Exit", (*fd_iter)->filename, &(*fd_iter)->status); |
|||
deregister_fd((*fd_iter)->fd); |
|||
} |
|||
} |
|||
# endif |
|||
|
|||
errno=old_errno; |
|||
orig__Exit(status); |
|||
} |
|||