285 lines
8.8 KiB
C++
285 lines
8.8 KiB
C++
/*
|
|
* Mr. 4th Dimention - Allen Webster
|
|
*
|
|
* 20.07.2016
|
|
*
|
|
* File tracking linux.
|
|
*
|
|
*/
|
|
|
|
// TOP
|
|
|
|
#include "4ed_file_track.h"
|
|
#include "4ed_file_track_general.cpp"
|
|
|
|
#include <libgen.h> // dirname
|
|
|
|
typedef struct {
|
|
void *tables;
|
|
int inotify;
|
|
pthread_mutex_t lock;
|
|
char *string_mem_begin;
|
|
char *string_mem_end;
|
|
} Linux_File_Track_Vars;
|
|
|
|
typedef struct {
|
|
File_Index hash;
|
|
char* dir;
|
|
int ref_count;
|
|
} Linux_File_Track_Entry;
|
|
|
|
#define to_vars(s) ((Linux_File_Track_Vars*)(s))
|
|
#define to_tables(v) ((File_Track_Tables*)(v->tables))
|
|
|
|
FILE_TRACK_LINK File_Track_Result
|
|
init_track_system(File_Track_System *system, Partition *scratch, void *table_memory, int32_t table_memory_size, void *listener_memory, int32_t listener_memory_size){
|
|
File_Track_Result result = FileTrack_MemoryTooSmall;
|
|
|
|
Assert(sizeof(Linux_File_Track_Vars) <= sizeof(File_Track_System));
|
|
|
|
Linux_File_Track_Vars *vars = to_vars(system);
|
|
|
|
Assert(sizeof(Linux_File_Track_Entry) <= sizeof(File_Track_Entry));
|
|
|
|
if (enough_memory_to_init_table(table_memory_size)){
|
|
|
|
// NOTE(allen): Initialize main data tables
|
|
vars->tables = (File_Track_Tables*) table_memory;
|
|
File_Track_Tables *tables = to_tables(vars);
|
|
init_table_memory(tables, table_memory_size);
|
|
|
|
vars->inotify = inotify_init1(IN_NONBLOCK);
|
|
|
|
pthread_mutex_init(&vars->lock, NULL);
|
|
|
|
vars->string_mem_begin = (char*)listener_memory;
|
|
vars->string_mem_end = (char*)listener_memory + listener_memory_size;
|
|
|
|
result = FileTrack_Good;
|
|
}
|
|
|
|
LINUX_FN_DEBUG("result: %d", result);
|
|
|
|
return(result);
|
|
}
|
|
|
|
FILE_TRACK_LINK File_Track_Result
|
|
add_listener(File_Track_System *system, Partition *scratch, u8 *filename){
|
|
File_Track_Result result = FileTrack_Good;
|
|
Linux_File_Track_Vars *vars = to_vars(system);
|
|
File_Track_Tables *tables = to_tables(vars);
|
|
|
|
pthread_mutex_lock(&vars->lock);
|
|
|
|
if(tracking_system_has_space(tables, 1)){
|
|
char *dir = dirname(strdupa((char*)filename));
|
|
size_t dir_len = strlen(dir) + 1;
|
|
|
|
if(vars->string_mem_end - vars->string_mem_begin >= dir_len){
|
|
int wd = inotify_add_watch(vars->inotify, dir, IN_CREATE | IN_DELETE | IN_MODIFY | IN_MOVE);
|
|
|
|
if(wd != -1){
|
|
File_Index key = { wd, 1 };
|
|
File_Track_Entry *entry = tracking_system_lookup_entry(tables, key);
|
|
Linux_File_Track_Entry *linux_entry = (Linux_File_Track_Entry*) entry;
|
|
|
|
LINUX_FN_DEBUG("map %s to wd %d", filename, wd);
|
|
|
|
if(entry_is_available(entry)){
|
|
linux_entry->hash = key;
|
|
linux_entry->dir = vars->string_mem_begin;
|
|
linux_entry->ref_count = 1;
|
|
memcpy(vars->string_mem_begin, dir, dir_len);
|
|
vars->string_mem_begin += dir_len;
|
|
++tables->tracked_count;
|
|
} else {
|
|
LINUX_FN_DEBUG("dir already tracked, adding ref");
|
|
++linux_entry->ref_count;
|
|
}
|
|
} else {
|
|
result = FileTrack_FileSystemError;
|
|
}
|
|
} else {
|
|
result = FileTrack_OutOfListenerMemory;
|
|
}
|
|
} else {
|
|
result = FileTrack_OutOfTableMemory;
|
|
}
|
|
|
|
pthread_mutex_unlock(&vars->lock);
|
|
|
|
LINUX_FN_DEBUG("result: %d", result);
|
|
|
|
return(result);
|
|
}
|
|
|
|
FILE_TRACK_LINK File_Track_Result
|
|
remove_listener(File_Track_System *system, Partition *scratch, u8 *filename){
|
|
File_Track_Result result = FileTrack_Good;
|
|
Linux_File_Track_Vars *vars = to_vars(system);
|
|
File_Track_Tables *tables = to_tables(vars);
|
|
File_Track_Entry *entries = (File_Track_Entry*) to_ptr(tables, tables->file_table);
|
|
|
|
pthread_mutex_lock(&vars->lock);
|
|
|
|
char *dir = dirname(strdupa((char*)filename));
|
|
// NOTE(inso): this assumes the filename was previously added
|
|
|
|
for(uint32_t i = 0; i < tables->max; ++i){
|
|
Linux_File_Track_Entry *e = (Linux_File_Track_Entry*)(entries + i);
|
|
if(e->hash.id[1] != 1) continue;
|
|
if(strcmp(e->dir, dir) == 0){
|
|
LINUX_FN_DEBUG("%s found as wd %d", filename, e->hash.id[0]);
|
|
if(--e->ref_count == 0){
|
|
LINUX_FN_DEBUG("refcount == 0, calling rm_watch");
|
|
if(inotify_rm_watch(vars->inotify, e->hash.id[0]) == -1){
|
|
perror("inotify_rm_watch");
|
|
result = FileTrack_FileSystemError;
|
|
}
|
|
internal_free_slot(tables, (File_Track_Entry*)e);
|
|
}
|
|
// NOTE(inso): associated string memory in listeners would be freed here
|
|
break;
|
|
}
|
|
}
|
|
|
|
pthread_mutex_unlock(&vars->lock);
|
|
|
|
LINUX_FN_DEBUG("result: %d", result);
|
|
|
|
return(result);
|
|
}
|
|
|
|
FILE_TRACK_LINK File_Track_Result
|
|
move_track_system(File_Track_System *system, Partition *scratch, void *mem, int32_t size){
|
|
File_Track_Result result = FileTrack_Good;
|
|
Linux_File_Track_Vars *vars = to_vars(system);
|
|
|
|
pthread_mutex_lock(&vars->lock);
|
|
|
|
{
|
|
File_Track_Tables *original_tables = to_tables(vars);
|
|
result = move_table_memory(original_tables, mem, size);
|
|
if (result == FileTrack_Good){
|
|
vars->tables = mem;
|
|
}
|
|
}
|
|
|
|
pthread_mutex_unlock(&vars->lock);
|
|
|
|
LINUX_FN_DEBUG("size: %d, %d", size, result);
|
|
|
|
return(result);
|
|
}
|
|
|
|
FILE_TRACK_LINK File_Track_Result
|
|
expand_track_system_listeners(File_Track_System *system, Partition *scratch, void *mem, int32_t size){
|
|
File_Track_Result result = FileTrack_Good;
|
|
Linux_File_Track_Vars *vars = to_vars(system);
|
|
|
|
pthread_mutex_lock(&vars->lock);
|
|
|
|
// NOTE(inso): pointer to old string mem is lost here.
|
|
// would need to keep it around if we want to free in the future
|
|
|
|
// NOTE(inso): assuming PATH_MAX is a reasonable lower bound of extra memory to get
|
|
|
|
if (size < PATH_MAX){
|
|
result = FileTrack_MemoryTooSmall;
|
|
}
|
|
else{
|
|
vars->string_mem_begin = (char*)mem;
|
|
vars->string_mem_end = (char*)mem + size;;
|
|
}
|
|
|
|
pthread_mutex_unlock(&vars->lock);
|
|
|
|
LINUX_FN_DEBUG("size: %d, result: %d", size, result);
|
|
|
|
return(result);
|
|
}
|
|
|
|
FILE_TRACK_LINK File_Track_Result
|
|
get_change_event(File_Track_System *system, Partition *scratch, u8 *buffer, int32_t max, int32_t *size){
|
|
File_Track_Result result = FileTrack_NoMoreEvents;
|
|
Linux_File_Track_Vars *vars = to_vars(system);
|
|
File_Track_Tables *tables = to_tables(vars);
|
|
|
|
pthread_mutex_lock(&vars->lock);
|
|
|
|
struct inotify_event *ev;
|
|
char buff[sizeof(*ev) + NAME_MAX + 1] __attribute__((aligned(__alignof__(*ev))));
|
|
|
|
// NOTE(inso): make sure we only read one event
|
|
size_t read_count = sizeof(*ev);
|
|
ssize_t n;
|
|
|
|
do {
|
|
n = read(vars->inotify, buff, read_count);
|
|
read_count++;
|
|
} while(n == -1 && errno == EINVAL);
|
|
|
|
if(n == -1 && errno != EAGAIN){
|
|
perror("inotify read");
|
|
} else if(n > 0){
|
|
ev = (struct inotify_event*) buff;
|
|
|
|
File_Index key = { ev->wd, 1 };
|
|
File_Track_Entry *entry = tracking_system_lookup_entry(tables, key);
|
|
Linux_File_Track_Entry *linux_entry = (Linux_File_Track_Entry*) entry;
|
|
|
|
LINUX_FN_DEBUG("mask: %#x", ev->mask);
|
|
|
|
if(!entry_is_available(entry)){
|
|
|
|
char* full_name = (char*) alloca(strlen(linux_entry->dir) + ev->len + 1);
|
|
strcpy(full_name, linux_entry->dir);
|
|
strcat(full_name, "/");
|
|
strcat(full_name, ev->name);
|
|
|
|
LINUX_FN_DEBUG("event from wd %d (%s)", ev->wd, full_name);
|
|
|
|
size_t full_name_size = strlen(full_name);
|
|
if(max < full_name_size){
|
|
result = FileTrack_MemoryTooSmall;
|
|
// NOTE(inso): this event will be dropped, needs to be stashed.
|
|
LINUX_FN_DEBUG("max too small, event dropped");
|
|
} else {
|
|
memcpy(buffer, full_name, full_name_size);
|
|
*size = full_name_size;
|
|
result = FileTrack_Good;
|
|
}
|
|
} else {
|
|
LINUX_FN_DEBUG("dead event from wd %d", ev->wd);
|
|
}
|
|
}
|
|
|
|
pthread_mutex_unlock(&vars->lock);
|
|
|
|
return(result);
|
|
}
|
|
|
|
FILE_TRACK_LINK File_Track_Result
|
|
shut_down_track_system(File_Track_System *system, Partition *scratch){
|
|
File_Track_Result result = FileTrack_Good;
|
|
Linux_File_Track_Vars *vars = to_vars(system);
|
|
|
|
// NOTE(allen): Close all the global track system resources.
|
|
if(close(vars->inotify) == -1){
|
|
result = FileTrack_FileSystemError;
|
|
}
|
|
|
|
pthread_mutex_destroy(&vars->lock);
|
|
|
|
LINUX_FN_DEBUG("result: %d", result);
|
|
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
// BOTTOM
|
|
|
|
|
|
|