int main(int argc, char ** argv)
{
// initialize and watch the entire directory tree from the current working
// directory downwards for all events
if ( !inotifytools_initialize() || !inotifytools_watch_recursively( "/proc/acpi/ac_adapter/AC/", IN_ALL_EVENTS ) )
{
fprintf(stderr, "%s\n", strerror( inotifytools_error() ) );
return -1;
}
// set time format to 24 hour time, HH:MM:SS
inotifytools_set_printf_timefmt( "%T" );
// Output all events as "<timestamp> <path> <events>"
struct inotify_event * event = inotifytools_next_event( -1 );
if ( event )
{
inotifytools_printf( event, "%T %w%f %e\n" );
event = inotifytools_next_event( -1 );
}
// Configure userspace as the scaling governor in ACPI
write_line(ACPI_GOVERNOR_FILE, "userspace");
// Start past/mdp/avgn/maxperf/maxlife
// Start phoronix-test-suite benchmark mdp
start_pts(argv[2]);
start_dvs_program(argv[1]);
}
int main(int argc, char* argv[]) {
const char* wd = argc > 1? argv[1]: ".";
char fmt[80];
unsigned long trig = IN_CLOSE_WRITE;
if (getenv(DIR_WATCH_FMT)){
strcpy(fmt, getenv(DIR_WATCH_FMT));
strcat(fmt, "\n");
}else{
strcpy(fmt, "%T %w%f %e\n");
}
if (getenv(DIR_WATCH_EVENT)){
trig = strtoul(getenv(DIR_WATCH_EVENT), 0, 0);
}
// initialize and watch the entire directory tree from the current working
// directory downwards for all events
if ( !inotifytools_initialize()
|| !inotifytools_watch_recursively( wd, trig) ) {
fprintf(stderr, "%s\n", strerror( inotifytools_error() ) );
return -1;
}
// set time format to 24 hour time, HH:MM:SS
inotifytools_set_printf_timefmt( "%T" );
// Output all events as "<timestamp> <path> <events>"
struct inotify_event * event = inotifytools_next_event( -1 );
while ( event ) {
inotifytools_printf( event, fmt );
fflush(stdout);
event = inotifytools_next_event( -1 );
}
return 0;
}
// Watcher
void *watcher(void *path) {
char * moved_from = 0;
int events = IN_CREATE | IN_MOVED_TO | IN_MOVED_FROM | IN_DELETE | IN_MODIFY;
int plen = strlen((char *) path);
// initialize and watch the entire directory tree from the current working
// directory downwards for all events
if (!inotifytools_initialize() || !inotifytools_watch_recursively(path,
events)) {
fprintf(stderr, "%s\n", strerror(inotifytools_error()));
return -1;
} else {
fprintf(stderr, "Watching %s\n", (char *) path);
}
// set time format to 24 hour time, HH:MM:SS
inotifytools_set_printf_timefmt("%T");
// Output all events as "<timestamp> <path> <events>"
struct inotify_event * event = inotifytools_next_event(-1);
while (event) {
inotifytools_printf(event, "%T %w%f %e\n");
// For recursivity
if ((event->mask & IN_CREATE) || (!moved_from && (event->mask
& IN_MOVED_TO))) {
// New file - if it is a directory, watch it
static char * new_file;
nasprintf(&new_file, "%s%s", inotifytools_filename_from_wd(
event->wd), event->name);
//ACTION
if(isdir(new_file)) {
int fd;
char buf[4096];
snprintf(buf, sizeof buf, "shell:mkdir \"%s\%s\"", fdir(
inotifytools_filename_from_wd(event->wd), plen), event->name);
fd = adb_connect(buf);
adb_read(fd, buf, 4096);
if (fd < 0) {
fprintf(stderr,"error: %s\n", adb_error());
return -1;
}
adb_close(fd);
} else {
do_sync_push(new_file, fdir(inotifytools_filename_from_wd(
event->wd), plen), 0);
}
if (isdir(new_file) && !inotifytools_watch_recursively(new_file,
events)) {
fprintf(stderr, "Couldn't watch new directory %s: %s\n",
new_file, strerror(inotifytools_error()));
}
free(new_file);
} // IN_CREATE
else if (event->mask & IN_MOVED_FROM) {
/*
* libinotifytools example program.
* Compile with gcc -linotifytools example.c
*/
int main() {
// initialize and watch the entire directory tree from the current working
// directory downwards for all events
if ( !inotifytools_initialize()
|| !inotifytools_watch_recursively( ".", IN_ALL_EVENTS ) ) {
fprintf(stderr, "%s\n", strerror( inotifytools_error() ) );
return -1;
}
// set time format to 24 hour time, HH:MM:SS
inotifytools_set_printf_timefmt( "%T" );
// Output all events as "<timestamp> <path> <events>"
struct inotify_event * event = inotifytools_next_event( -1 );
while ( event ) {
inotifytools_printf( event, "%T %w%f %e\n" );
event = inotifytools_next_event( -1 );
}
}
/*
* libinotifytools example program.
* Compile with g++ -linotifytools example.c
*/
int main(int argc, char *argv[])
{
if (argc != 2)
{
std::cout << "Usage: ./run filename" << std::endl;
return 1;
}
std::string fileName(argv[1]);
if (! inotifytools_initialize())
{
std::cerr << "ERROR: "; // calling inotifytools_initialize(): ";
std::cerr << strerror(inotifytools_error()) << std::endl;
return 1;
}
int event_types = IN_CLOSE_WRITE; // IN_MODIFY
std::cout << "Will watch file \"" << fileName << "\"." << std::endl;
if (! inotifytools_watch_file(fileName.c_str(), event_types))
{
std::cerr << "ERROR: "; // << calling inotifytools_watch_file(\"" <<
// fileName << "\", " << event_types << "): ";
std::cerr << strerror(inotifytools_error()) << std::endl;
return 1;
}
//// set time format to 24 hour time, HH:MM:SS
inotifytools_set_printf_timefmt((char *) "%T");
// Output all events as "<timestamp> <path> <events>"
struct inotify_event *event = NULL;
std::cout << "watching file \"" << fileName << "\"..." << std::endl;
while (true)
{
event = inotifytools_next_event(0); // 0 = non-blocking
if (event)
{
std::cout << "EVENT: ";
inotifytools_printf(event, (char *) "%T %w%f %e\n");
}
else
{
std::cout << "no event...\n";
}
event = NULL;
// std::cout << "zzz ";
//sleep(1);
}
return 0;
}
/* execute the monitor function every 0.5 second to monitor changes
in the MON_DIR
*/
static gboolean
gfpm_icmonitor_monitor (void)
{
if (stop == TRUE)
{
return FALSE;
}
if (changed)
{
return TRUE;
}
event = inotifytools_next_event (0);
while (event)
{
switch (event->mask)
{
case IN_ALL_EVENTS:
case IN_ACCESS:
case IN_CREATE:
case IN_DELETE:
case IN_MODIFY:
{
changed = TRUE;
stop = TRUE;
return FALSE;
break;
}
default:
{
break;
}
}
event = inotifytools_next_event (0);
}
return TRUE;
}
static int pollfiles(al_sec now, void *ptr, luaav_state *S) {
struct inotify_event *e = NULL;
do {
e = inotifytools_next_event(0);
if(e) {
const char *c_fpath = inotifytools_filename_from_wd(e->wd);
if(c_fpath) {
if(e->mask & IN_MOVE_SELF) {
const luaav::FileInfo * f_info = luaav::FileInfo::getInfo(c_fpath);
if(f_info && f_info->cb) {
f_info->cb(c_fpath, f_info->udata);
}
else {
lua::call(luaav_getstate(luaav_app_state()), "fileopen", c_fpath);
}
}
else {
/*const luaav::FileInfo * f_info = luaav::FileInfo::getInfo(c_fpath);
if(f_info) {
string filename(f_info->filename);
FileWatcher::watcher_cb cb = f_info->cb;
void *udata = f_info->udata;
// luaav::FileWatcher::unwatchfile(filename.data());
// luaav::FileWatcher::watchfile(filename.data(), cb, udata);
}
else {
// luaav::FileWatcher::unwatchfile(c_fpath);
// luaav::FileWatcher::watchfile(c_fpath);
}*/
}
}
}
} while(e);
if(FileWatcherImpl::cPolling) {
al::PQHelper queue(luaav_state_mainpq(S));
queue.send(FILEWATCH_PERIOD, FILEWATCH_PERIOD, pollfiles, ptr, S);
}
return 0;
}
int main(int argc, char ** argv)
{
events = 0;
int timeout = 0;
int verbose = 0;
zero = 0;
int recursive = 0;
char * fromfile = 0;
sort = -1;
done = false;
char * regex = NULL;
char * iregex = NULL;
signal( SIGINT, handle_impatient_user );
// Parse commandline options, aborting if something goes wrong
if ( !parse_opts( &argc, &argv, &events, &timeout, &verbose, &zero, &sort,
&recursive, &fromfile, ®ex, &iregex ) ) {
return EXIT_FAILURE;
}
if (
(regex && !inotifytools_ignore_events_by_regex(regex, REG_EXTENDED) ) ||
(iregex && !inotifytools_ignore_events_by_regex(iregex, REG_EXTENDED|
REG_ICASE))
) {
fprintf(stderr, "Error in `exclude' regular expression.\n");
return EXIT_FAILURE;
}
if ( !inotifytools_initialize() ) {
fprintf(stderr, "Couldn't initialize inotify. Are you running Linux "
"2.6.13 or later, and was the\n"
"CONFIG_INOTIFY option enabled when your kernel was "
"compiled? If so, \n"
"something mysterious has gone wrong. Please e-mail "
PACKAGE_BUGREPORT "\n"
" and mention that you saw this message.\n");
return EXIT_FAILURE;
}
// Attempt to watch file
// If events is still 0, make it all events.
if ( !events )
events = IN_ALL_EVENTS;
FileList list = construct_path_list( argc, argv, fromfile );
if (0 == list.watch_files[0]) {
fprintf(stderr, "No files specified to watch!\n");
return EXIT_FAILURE;
}
unsigned int num_watches = 0;
unsigned int status;
fprintf( stderr, "Establishing watches...\n" );
int i;
for ( i = 0; list.watch_files[i]; ++i ) {
char const *this_file = list.watch_files[i];
if ( recursive && verbose ) {
fprintf( stderr, "Setting up watch(es) on %s\n", this_file );
}
if ( recursive ) {
status = inotifytools_watch_recursively_with_exclude(
this_file,
events,
list.exclude_files );
}
else {
status = inotifytools_watch_file( this_file, events );
}
if ( !status ) {
if ( inotifytools_error() == ENOSPC ) {
fprintf(stderr, "Failed to watch %s; upper limit on inotify "
"watches reached!\n", this_file );
fprintf(stderr, "Please increase the amount of inotify watches "
"allowed per user via `/proc/sys/fs/inotify/"
"max_user_watches'.\n");
}
else {
fprintf(stderr, "Failed to watch %s: %s\n", this_file,
strerror( inotifytools_error() ) );
}
return EXIT_FAILURE;
}
if ( recursive && verbose ) {
fprintf( stderr, "OK, %s is now being watched.\n", this_file );
}
}
num_watches = inotifytools_get_num_watches();
if ( verbose ) {
fprintf( stderr, "Total of %d watches.\n",
num_watches );
}
fprintf( stderr, "Finished establishing watches, now collecting statistics.\n" );
if ( timeout && verbose ) {
fprintf( stderr, "Will listen for events for %d seconds.\n", timeout );
}
signal( SIGINT, handle_signal );
signal( SIGHUP, handle_signal );
signal( SIGTERM, handle_signal );
if ( timeout ) {
signal( SIGALRM, handle_signal );
alarm( timeout );
}
signal( SIGUSR1, print_info_now );
inotifytools_initialize_stats();
// Now wait till we get event
struct inotify_event * event;
char * moved_from = 0;
do {
event = inotifytools_next_event( 0 );
if ( !event ) {
if ( !inotifytools_error() ) {
return EXIT_TIMEOUT;
}
else if ( inotifytools_error() != EINTR ) {
fprintf(stderr, "%s\n", strerror( inotifytools_error() ) );
return EXIT_FAILURE;
}
else {
continue;
}
}
// if we last had MOVED_FROM and don't currently have MOVED_TO,
// moved_from file must have been moved outside of tree - so unwatch it.
if ( moved_from && !(event->mask & IN_MOVED_TO) ) {
if ( !inotifytools_remove_watch_by_filename( moved_from ) ) {
fprintf( stderr, "Error removing watch on %s: %s\n",
moved_from, strerror(inotifytools_error()) );
}
free( moved_from );
moved_from = 0;
}
if ( recursive ) {
if ((event->mask & IN_CREATE) ||
(!moved_from && (event->mask & IN_MOVED_TO))) {
// New file - if it is a directory, watch it
static char * new_file;
nasprintf( &new_file, "%s%s",
inotifytools_filename_from_wd( event->wd ),
event->name );
if ( isdir(new_file) &&
!inotifytools_watch_recursively( new_file, events ) ) {
fprintf( stderr, "Couldn't watch new directory %s: %s\n",
new_file, strerror( inotifytools_error() ) );
}
free( new_file );
} // IN_CREATE
else if (event->mask & IN_MOVED_FROM) {
nasprintf( &moved_from, "%s%s/",
inotifytools_filename_from_wd( event->wd ),
event->name );
// if not watched...
if ( inotifytools_wd_from_filename(moved_from) == -1 ) {
free( moved_from );
moved_from = 0;
}
} // IN_MOVED_FROM
else if (event->mask & IN_MOVED_TO) {
if ( moved_from ) {
static char * new_name;
nasprintf( &new_name, "%s%s/",
inotifytools_filename_from_wd( event->wd ),
event->name );
inotifytools_replace_filename( moved_from, new_name );
free( moved_from );
moved_from = 0;
} // moved_from
}
}
} while ( !done );
return print_info();
}
int main(int argc, char ** argv)
{
int events = 0;
int orig_events;
bool monitor = false;
int quiet = 0;
unsigned long int timeout = 0;
int recursive = 0;
bool csv = false;
bool daemon = false;
bool syslog = false;
char * format = NULL;
char * timefmt = NULL;
char * fromfile = NULL;
char * outfile = NULL;
char * regex = NULL;
char * iregex = NULL;
pid_t pid;
int fd;
// Parse commandline options, aborting if something goes wrong
if ( !parse_opts(&argc, &argv, &events, &monitor, &quiet, &timeout,
&recursive, &csv, &daemon, &syslog, &format, &timefmt,
&fromfile, &outfile, ®ex, &iregex) ) {
return EXIT_FAILURE;
}
if ( !inotifytools_initialize() ) {
fprintf(stderr, "Couldn't initialize inotify. Are you running Linux "
"2.6.13 or later, and was the\n"
"CONFIG_INOTIFY option enabled when your kernel was "
"compiled? If so, \n"
"something mysterious has gone wrong. Please e-mail "
PACKAGE_BUGREPORT "\n"
" and mention that you saw this message.\n");
return EXIT_FAILURE;
}
if ( timefmt ) inotifytools_set_printf_timefmt( timefmt );
if (
(regex && !inotifytools_ignore_events_by_regex(regex, REG_EXTENDED) ) ||
(iregex && !inotifytools_ignore_events_by_regex(iregex, REG_EXTENDED|
REG_ICASE))
) {
fprintf(stderr, "Error in `exclude' regular expression.\n");
return EXIT_FAILURE;
}
if ( format ) validate_format(format);
// Attempt to watch file
// If events is still 0, make it all events.
if (events == 0)
events = IN_ALL_EVENTS;
orig_events = events;
if ( monitor && recursive ) {
events = events | IN_CREATE | IN_MOVED_TO | IN_MOVED_FROM;
}
FileList list = construct_path_list( argc, argv, fromfile );
if (0 == list.watch_files[0]) {
fprintf(stderr, "No files specified to watch!\n");
return EXIT_FAILURE;
}
// Daemonize - BSD double-fork approach
if ( daemon ) {
pid = fork();
if (pid < 0) {
fprintf(stderr, "Failed to fork1 whilst daemonizing!\n");
return EXIT_FAILURE;
}
if (pid > 0) {
_exit(0);
}
if (setsid() < 0) {
fprintf(stderr, "Failed to setsid whilst daemonizing!\n");
return EXIT_FAILURE;
}
signal(SIGHUP,SIG_IGN);
pid = fork();
if (pid < 0) {
fprintf(stderr, "Failed to fork2 whilst daemonizing!\n");
return EXIT_FAILURE;
}
if (pid > 0) {
_exit(0);
}
if (chdir("/") < 0) {
fprintf(stderr, "Failed to chdir whilst daemonizing!\n");
return EXIT_FAILURE;
}
// Redirect stdin from /dev/null
fd = open("/dev/null", O_RDONLY);
if (fd != fileno(stdin)) {
dup2(fd, fileno(stdin));
close(fd);
}
// Redirect stdout to a file
fd = open(outfile, O_WRONLY | O_CREAT | O_APPEND, 0600);
if (fd < 0) {
fprintf( stderr, "Failed to open output file %s\n", outfile );
return EXIT_FAILURE;
}
if (fd != fileno(stdout)) {
dup2(fd, fileno(stdout));
close(fd);
}
// Redirect stderr to /dev/null
fd = open("/dev/null", O_WRONLY);
if (fd != fileno(stderr)) {
dup2(fd, fileno(stderr));
close(fd);
}
} else if (outfile != NULL) { // Redirect stdout to a file if specified
fd = open(outfile, O_WRONLY | O_CREAT | O_APPEND, 0600);
if (fd < 0) {
fprintf( stderr, "Failed to open output file %s\n", outfile );
return EXIT_FAILURE;
}
if (fd != fileno(stdout)) {
dup2(fd, fileno(stdout));
close(fd);
}
}
if ( syslog ) {
openlog ("inotifywait", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_DAEMON);
}
if ( !quiet ) {
if ( recursive ) {
output_error( syslog, "Setting up watches. Beware: since -r "
"was given, this may take a while!\n" );
} else {
output_error( syslog, "Setting up watches.\n" );
}
}
// now watch files
for ( int i = 0; list.watch_files[i]; ++i ) {
char const *this_file = list.watch_files[i];
if ( (recursive && !inotifytools_watch_recursively_with_exclude(
this_file,
events,
list.exclude_files ))
|| (!recursive && !inotifytools_watch_file( this_file, events )) ){
if ( inotifytools_error() == ENOSPC ) {
output_error( syslog, "Failed to watch %s; upper limit on inotify "
"watches reached!\n", this_file );
output_error( syslog, "Please increase the amount of inotify watches "
"allowed per user via `/proc/sys/fs/inotify/"
"max_user_watches'.\n");
}
else {
output_error( syslog, "Couldn't watch %s: %s\n", this_file,
strerror( inotifytools_error() ) );
}
return EXIT_FAILURE;
}
}
if ( !quiet ) {
output_error( syslog, "Watches established.\n" );
}
// Now wait till we get event
struct inotify_event * event;
char * moved_from = 0;
do {
event = inotifytools_next_event( timeout );
if ( !event ) {
if ( !inotifytools_error() ) {
return EXIT_TIMEOUT;
}
else {
output_error( syslog, "%s\n", strerror( inotifytools_error() ) );
return EXIT_FAILURE;
}
}
if ( quiet < 2 && (event->mask & orig_events) ) {
if ( csv ) {
output_event_csv( event );
}
else if ( format ) {
inotifytools_printf( event, format );
}
else {
inotifytools_printf( event, "%w %,e %f\n" );
}
}
// if we last had MOVED_FROM and don't currently have MOVED_TO,
// moved_from file must have been moved outside of tree - so unwatch it.
if ( moved_from && !(event->mask & IN_MOVED_TO) ) {
if ( !inotifytools_remove_watch_by_filename( moved_from ) ) {
output_error( syslog, "Error removing watch on %s: %s\n",
moved_from, strerror(inotifytools_error()) );
}
free( moved_from );
moved_from = 0;
}
if ( monitor && recursive ) {
if ((event->mask & IN_CREATE) ||
(!moved_from && (event->mask & IN_MOVED_TO))) {
// New file - if it is a directory, watch it
static char * new_file;
nasprintf( &new_file, "%s%s",
inotifytools_filename_from_wd( event->wd ),
event->name );
if ( isdir(new_file) &&
!inotifytools_watch_recursively( new_file, events ) ) {
output_error( syslog, "Couldn't watch new directory %s: %s\n",
new_file, strerror( inotifytools_error() ) );
}
free( new_file );
} // IN_CREATE
else if (event->mask & IN_MOVED_FROM) {
nasprintf( &moved_from, "%s%s/",
inotifytools_filename_from_wd( event->wd ),
event->name );
// if not watched...
if ( inotifytools_wd_from_filename(moved_from) == -1 ) {
free( moved_from );
moved_from = 0;
}
} // IN_MOVED_FROM
else if (event->mask & IN_MOVED_TO) {
if ( moved_from ) {
static char * new_name;
nasprintf( &new_name, "%s%s/",
inotifytools_filename_from_wd( event->wd ),
event->name );
inotifytools_replace_filename( moved_from, new_name );
free( moved_from );
moved_from = 0;
} // moved_from
}
}
fflush( NULL );
} while ( monitor );
// If we weren't trying to listen for this event...
if ( (events & event->mask) == 0 ) {
// ...then most likely something bad happened, like IGNORE etc.
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
