tools

fbmon.cpp (13239B)

---

 // Copyright (c) 2020 Morel Bérenger
 // 
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
 // arising from the use of this software.
 // 
 // Permission is granted to anyone to use this software for any purpose,
 // including commercial applications, and to alter it and redistribute it
 // freely, subject to the following restrictions:
 // 
 // 1. The origin of this software must not be misrepresented; you must not
 //    claim that you wrote the original software. If you use this software
 //    in a product, an acknowledgment in the product documentation would be
 //    appreciated but is not required.
 // 2. Altered source versions must be plainly marked as such, and must not be
 //    misrepresented as being the original software.
 // 3. This notice may not be removed or altered from any source distribution.
 
 #ifdef LIBCPP_MUSL_STATIC
 #define __GLIBC_PREREQ(x,y) 0
 #endif
 
 #include <string.h>
 #include <assert.h>
 #include <math.h>
 #include <limits.h>
 
 #include <iterator>
 #include <algorithm>
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <poll.h>
 
 #include <termios.h>
 #include <sys/ioctl.h>
 
 #include <utils.hpp>
 #include <vector.hpp>
 #include <optparser.hpp>
 
 #include "service_info.hpp"
 
 // compatibility:
 // this code assumes (because of inotify API and behavior) a linux
 // kernel, v2.6.21 minimum. Previous versions may contain bugs, but
 // I won't hunt them. If you spot one, feel free to send the patch,
 // *if* it does not makes the code more complex.
 #include <linux/limits.h>
 #include <sys/inotify.h>
 
 void print_help( char const* pgm, FILE* target, opt_desc_t const* start, opt_desc_t const* end );
 
 static const char serv_infos_desc[] =
 "description of a service to watch, separated with ':': path:filename:start_regex:death_regex:alive_delay";
 
 bool close_file( service_info_t& svc );
 bool linux_event_handling( size_t start, vector<service_info_t>& svcs, vector<pollfd>& pfds );
 void term_resize( int );
 int update_screen_info( void );
 
 static bool term_resized = true;
 area_t g_screen_area;
 
 int main( int argc, char **argv )
 {
 	vector<service_info_t> services;
 	vector<pollfd> pfds;
 	int refresh_delay = 1;//TODO: use. Or remove, not sure. Why keep? To show date?
 	//int fbdev;
 	//char* fbpath = nullptr;
 	//char* ftpath = nullptr;
 
 	opt_desc_t opts[] =
 	{
 		STD_HELP,
 		{ "service", serv_infos_desc, 's', 0, &services, add_serv_info, show_serv_info },
 		{ "refresh_delay", "seconds between 2 refresh (r<0: on event only)", 'r', 0, &refresh_delay, set<int>, show<int> },
 		//{ "framebuffer", "path to the framebuffer device", 'f', 0, &fbpath, set<char const**>, show<char*> },
 		//{ "font", "path to the font to use (PSF formats)", 'F', 0, &ftpath, set<char const**>, show<char*> },
 	};
 
 	// adds the "master" inotify watched
 	// must be done before parsing arguments
 	g_inotify_watch_fd = inotify_init();
 	if( -1 == g_inotify_watch_fd )
 	{
 		syserr( "failed to initialise inotify" );
 		return EXIT_FAILURE;
 	}
 	fputs( "inotify initialised\n", stderr );
 
 	//TODO: catch resize events
 	if( -1 == update_screen_info() )
 	{
 		syserr( "failed to retrieve screen's size (input term, really)" );
 		return EXIT_FAILURE;
 	}
 
 	auto b_opts = std::begin( opts );
 	auto e_opts = std::end( opts );
 
 	char **arg = &argv[1];
 	assert( argc > 0 );
 	for( int iarg = 1; iarg != argc; ++iarg, ++arg )
 	{
 		auto error = parse_cmd_opt( *arg, b_opts, e_opts );
 		switch( error )
 		{
 			case MAX_COUNT:
 				arg_warning( *arg, error );
 				break;
 			case NONE:
 			case IGNORED:
 				break;
 			case SET_NO_VAL:
 			case SET_VAL_IGN:
 			case SET_FAIL:
 			case BAD_ARGS:
 			case BAD_SETTER:
 				print_help( argv[0], stderr, b_opts, e_opts );
 				arg_error( *arg, error );
 				return EXIT_FAILURE;
 		}
 	}
 
 	if( opts[0].count ) //check if --help was found
 	{
 		print_help( argv[0], stderr, b_opts, e_opts );
 		return EXIT_SUCCESS;
 	}
 	if( services.empty() )
 	{
 		print_help( argv[0], stderr, b_opts, e_opts );
 		return EXIT_FAILURE;
 	}
 
 	// this program works with the assumption already opened FDs
 	// are "packed", the numbers do not have holes. This assumption
 	// is done for ease of code and performance reasons.
 	// reserve nb services pollfd instances plus:
 	// _ inotify fd
 	const size_t INOTIF_FD = pfds.size();
 	pfds.reserve( pfds.size() + 1 + INOTIF_FD + services.size() );
 	pfds.push_back( { g_inotify_watch_fd, POLLIN | POLLPRI, 0 } );
 
 	uint8_t max_width = 0;
 	for( auto const &svc : services )
 	{
 		pfds.push_back( { svc.file_fd, POLLIN|POLLPRI, 0 } );
 		//compute max width to use with some margins
 		max_width = std::max( max_width, static_cast<uint8_t>( name_sz( svc ) + 3 ) );
 		fprintf( stderr, "now polling fd %d\n", svc.file_fd );
 	}
 	const uint16_t max_cols = static_cast<uint16_t>( ceil( g_screen_area.w / static_cast<float>( max_width ) ) );
 	const uint16_t col_size = g_screen_area.w / max_cols;
 	const uint16_t row_size = 2;
 
 	uint16_t col = 0, row = 0;
 	for( auto &svc : services )
 	{
 		svc.draw_area.x = 2 + col * col_size;
 		svc.draw_area.y = 1 + row * row_size;
 		//TODO: implement limits, so that a more graphical mode can be implemented
 		//svc.draw_area.w = ...;
 		//svc.draw_area.h = ...;
 		++col;
 		row += col / max_cols;
 		col %= max_cols;
 	}
 
 	int nbev;
 	bool stop = false;
 	assert( g_inotify_watch_fd != 0 && "TODO: 0 can't be disabled in poll" );
 	time_t prev_time = time( nullptr );
 	time_t curr_time;
 	ssize_t dist_time = 0;
 	while( !stop )
 	{
 		if( dist_time == 0 )
 		{
 			dist_time = refresh_delay;
 		}
 		assert( dist_time * 1000 <= INT_MAX );
 		nbev = poll( pfds.data(), pfds.size(), static_cast<int>( dist_time * 1000 ) );
 		curr_time = time( nullptr );
 		dist_time = curr_time - prev_time;
 		prev_time = curr_time;
 		//got interrupted or reached timeout
 		if( -1 == nbev || 0 == nbev )
 		{
 			for( size_t i = 1; i < pfds.size(); ++i )
 			{
 				refresh( services[i-1], dist_time );
 			}
 			continue;
 		}
 
 		for( size_t i = 0; i < pfds.size(); ++i )
 		{
 			short rev = pfds[i].revents;
 			if( 0 == rev )
 			{
 				continue;
 			}
 
 			// dynamic FDs: target files
 			if( i > INOTIF_FD )
 			{
 				if( rev & ( POLLIN | POLLPRI ) )
 				{
 					update( services[i-1] );
 					pfds[i].fd = -pfds[i].fd;
 				}
 				refresh( services[i-1], dist_time );
 			}
 			else
 			{
 				assert( g_inotify_watch_fd >= 0 );
 				if( INOTIF_FD == i && linux_event_handling( INOTIF_FD, services, pfds ) )
 				{
 					abort();
 				}
 			}
 		}
 	}
 	return EXIT_SUCCESS;
 }
 
 void term_resize( int )
 {
 	term_resized = true;
 }
 
 int update_screen_info( void )
 {
 	winsize wsz;
 	if( term_resized )
 	{
 		int ioc = ioctl( STDIN_FILENO, TIOCGWINSZ, &wsz );
 		//TODO move in loop
 		//TODO don't do anything as long as areas are not ok
 		//if( -1 == ioc && errno != EINTR )
 		if( -1 == ioc && errno != EINTR )
 		{
 			perror( "open" );
 			return -1;
 		}
 		if( g_screen_area.w != wsz.ws_row || g_screen_area.h != wsz.ws_col )
 		{
 			g_screen_area.x = 0;
 			g_screen_area.y = 0;
 			g_screen_area.w = wsz.ws_col;
 			g_screen_area.h = wsz.ws_row;
 			// TODO update all client's areas
 		}
 		return 0;
 	}
 	return -1;
 }
 
 void print_help( char const* pgm, FILE* target, opt_desc_t const* start, opt_desc_t const* end )
 {
 	fputs( "Usage: ", target );
 	fputs( pgm, target );
 	fputs( " [OPTIONS]\n"
 			"Description:\n"
 			"This program constantly watches log files to guess a service's state: starting, alive, dead.\n"
 			"Guessing is based on 3 things:\n"
 			"\t* a \"starting\" regex;\n"
 			"\t* a \"dead\" regex;\n"
 			"\t* a time-to-start delay, in seconds;\n"
 			"\n"
 			"Results are printed on choosen TTY.\n"
 			"For each watched file:\n"
 			"\t* full path of file\n"
 			"\t* current status\n"
 			"\t* timestamp of last known running state\n"
 			"\t* timestamp of last known death\n"
 			"\n"
 			"Regex syntax POSIX Extended (for now)\n"
 			//"Regex syntax is intentionnally trivial and a lot simpler that what you might know, only reserved characters are:\n"
 			//"\t* '*': matches the SMALLER possible string\n"
 			//"\t* '(': start the ONLY allowed capture\n"
 			//"\t* ')': ends the capture\n"
 			//"\t* '|': ends the regex\n"
 			//"\t* '\\': escape next character\n"
 			"TODO:\n"
 			"do not scoll, instead, update informations\n"
 			"show an even log\n"
 			"have colours to know more easily a service's state\n"
 			"reduce footprint and dependencies.\n"
 			"static build (monitors should be 100% independent)\n"
 			"only work when the correct TTY is \"focused\"\n"
 			"Options:\n"
 			, target );
 	print_opts( target, start, end );
 }
 
 // for each service, there can be 2 kind of events registered:
 // * event on parent directory:
 //     only interesting if pdir is removed (unregister (0ed it?) the
 //     service, close file if open) or if affected file is watched file
 // * event on watched file:
 //     enable polling of target FD
 // but it's also possible that polling was enabled for file. If so,  it
 // should stay enabled as long as read() returns the maximum number of bytes.
 //
 // read a chunk (can't do better, number of bytes there can't be guessed)
 // for each event in chunk:
 //   locate the service it belongs to
 //   if event affects directory
 //     linked pollfd is inotify_fd + distance( services.begin(), service )
 //     if event implies a file change of name or deletion:
 //       close FD in service
 //     if event is appearance of target
 //       open file and store into service
 //     polling becomes FD
 //   if event affects target file
 //     enable polling
 //
 
 // pfds[start]: inotify's pollfd
 // pfds[start+x]: service N's pollfd
 bool linux_event_handling( size_t start, vector<service_info_t>& svcs, vector<pollfd>& pfds )
 {
 	//that code taken from manpage is *really* ugly
 	char buf[sizeof(inotify_event) + PATH_MAX] __attribute__ ((aligned(__alignof__(struct inotify_event))));
 	assert( pfds[start].fd > 0 );
 	ssize_t len = read( pfds[start].fd, buf, sizeof( buf ) );
 	if( -1 == len && errno == EINVAL )
 	{
 		fputs( "failed to read: inotify's API is fucked up.", stderr );
 		return true;
 	}
 	const inotify_event* event;
 	for( const char * ptr = buf; ptr < buf + len; ptr += sizeof( inotify_event ) + event->len )
 	{
 		event = reinterpret_cast<const inotify_event*>( ptr );
 
 		auto svc_it = std::find_if( svcs.begin(), svcs.end(),
 				[&]( service_info_t const& s )
 				{
 					return s.dir_wfd == event->wd || s.file_wfd == event->wd;
 				} );
 		if( svc_it == svcs.end() )
 		{
 			continue;
 		}
 
 		assert( svc_it >= svcs.begin() );
 		pollfd& pfd = pfds[start + 1 + static_cast<size_t>( svc_it - svcs.begin() ) ];
 		// work on dir
 		if( svc_it->dir_wfd == event->wd )
 		{
 			assert( event->mask & (
 						IN_DELETE_SELF | IN_MOVE_SELF | // disable service
 						IN_DELETE | IN_MOVE | // close target FD and update pollfd
 						IN_CREATE // open target and updated pollfd
 						) );
 
 			if( 0 != strcmp( svc_it->path + 1 + svc_it->filename, event->name ) )
 			{
 				continue;
 			}
 			// this will happen when a file gets IN_MOVE, because it can be both
 			// IN_MOVED_TO and IN_MOVED_FROM
 			if( event->mask & ( IN_DELETE | IN_MOVE ) && svc_it->file_fd != -1 )
 			{
 				if( close_file( *svc_it ) )
 				{
 					fputs( "fucking API!\n", stderr );
 				}
 				pfd.fd = -1;
 			}
 			if( event->mask & ( IN_CREATE ) )
 			{
 				//TODO: this code is everything but safe. Should be moved out of here.
 				assert( svc_it->file_fd == -1 );
 				svc_it->file_wfd = inotify_add_watch( g_inotify_watch_fd, svc_it->path, 0
 						| IN_MODIFY
 						//| IN_MOVE_SELF   // would be dup of dir_wfd, I guess
 						//| IN_DELETE_SELF // would be dup of dir_wfd, I guess
 						| IN_EXCL_UNLINK   // don't care about unlinked files
 						);
 				if( -1 == svc_it->file_wfd )
 				{
 					fprintf( stderr, HEADER_LOG ": failed to watch file: \"%s\" %s(0x%x)",
 							svc_it->path, strerror( errno ), errno );
 					return true;
 				}
 				if( -1 == ( pfd.fd = svc_it->file_fd = open( svc_it->path, O_RDONLY ) ) )
 				{
 					syserr( "unable to open service's file" );
 					return true;
 				}
 			}
 			if( event->mask & ( IN_DELETE_SELF | IN_MOVE_SELF ) )
 			{
 				// failure here is not that much of a problem...
 
 				//TODO: actually remove both pollfd and service instances
 				//      from the vectors (swap with last element and resize)
 				if( close_file( *svc_it ) )
 				{
 					fputs( "fucking API!\n", stderr );
 				}
 				if( -1 == inotify_rm_watch( g_inotify_watch_fd, svc_it->dir_wfd ) )
 				{
 					syserr( "failed to remove dir WD" );
 				}
 				svc_it->dir_wfd  = -1;
 				svc_it->birth_time = UINT16_MAX;
 				pfd.fd = -1;
 			}
 		}
 		else
 		{
 			assert( event->mask & IN_MODIFY );
 			assert( svc_it->file_fd >= 0 );
 			pfd.fd = svc_it->file_fd;
 		}
 
 		assert( -1 != event->wd );
 		assert( svc_it->dir_wfd != svc_it->file_wfd );
 	}
 	return false;
 }
 
 bool close_file( service_info_t& svc )
 {
 	bool ret = false;
 	if( -1 == close( svc.file_fd ) )
 	{
 		syserr( "failed to close service FD" );
 		ret = true;
 	}
 	svc.file_fd  = -1;
 	if( -1 == inotify_rm_watch( g_inotify_watch_fd, svc.file_wfd ) )
 	{
 		syserr( "failed to remove file WD" );
 		ret = true;
 	}
 	svc.file_wfd = -1;
 	return ret;
 }
 
 // red
 char const* g_color_down = "41";
 // green
 char const* g_color_up = "42";
 // yellow
 char const* g_color_wake = "43";