*******************************************************************************
-------------------------------------------------------------------------------
			`	WATCHDOG dla SKZ
			mechaniazm nadzorujacy dzialanie procesow
-------------------------------------------------------------------------------
*******************************************************************************

zawiera nastepujace elementy:
----- Incjalizacja ---------
initWatchdog.c - inicjalizuje elemetny watchdoga
---- aplikacja watchdog ----
watchQS.c
---- demony wywolywane przez watchdoga ----
watd1.c - do obslugi procesu trap&timeout
watd2.c - do obslugi procesu trap&wait

funkcje montowane w nadzorowanych aplikacjach przez watchdog:
snd.c - wysylanie sygnalu z linii polecen do watchdog bez trap
trap.c - teatowanie watchdog z oczekiwaniem 
	 na sygnal zwrotny likwidujacy trap 
	 (uwaga plik zawiera rowniez funckje snd)

-------- funkcje biblioteczne ------------
trap.h - plik do uzycia #include "trap.c" - do uzycia w modulach nadzorowanych
mem_lib.h - interfejs wymiany danych przez memory (uzycie - tylko dla watchdoga)

-------- Wyswietlanie na ekranie lub zrzut ekranu do pliku ------------
memdisplay.c 
W katalogu /ADODATKI znadjuje sie prototyp funkcji file_to_stream,
ktora sluzy do zmiany pliku w strumien jesli uzywana bedzie memdisplay file.
Funkcja file_to_stream jest przeznaczona dla przesylania sygnalow z kodami 
"info" w schemacie: server_Admin <--> client_Admin

memdisplay_code_to_name.h - w tym pliku mozna przypisac do nr kodu jakas nazwe
			    Wowczas zamiast nr kodu bedzie wyswietlana 
			    przypisana nazwa. Rowniez przy zapisie do pliku
			    SCREEN_SAVE bedzie zapisywana nazwa a nie nr kodu.
********************************************************************************
Pliki serwisu mechanizmu TRAPS znajduja sie w katalogu ../watchdog/TRAPTIMER/
README_TRAP znajduje sie rowniez w tym katalogu
********************************************************************************

***************************** BARDZO WAZNE!!! **********************************
****************************** Kompilacja **************************************
********************************************************************************
UWAGA! ./compile tworzy automatycznie katalog: /home/SYSQS/watchdog. 
	Jesli nie dziala to nalezy zmienic sciezke dostepu w operacjach
        kopiowania w plikach compile w katalogach ../watchdog/ 
	oraz ../watchdog/TRAPTIMER/. 
********************************************************************************
1. Kompilacja watchdoga: ../watchdog/compile (nalezy wykonac jako pierwsza)
2. Kompilacja mechanizmu TRAPS: ../watchdog/TRAPTIMER/compile (po kompilacji
   watchdoga)
********************************************************************************
********************************************************************************





*******************************************************************************
-------------------------------------------------------------------------------
			Inicjalizacja watchdoga

1.login jako root
2. z linii polecen lub ze skryptu nalezy wywolac
    ./initWatchdog create
   -zaczyna dzilac jako daemon
   ponowne wywolanie ./initWatchdog create - powoduje restart watchdoga

3. jesli watchdog ma byc uruchomiony wraz mechanizmem sledzenia traps
   to zmiast initWatchdog nalezy uruchomic ./runwatchdog 4 
   (tzn. uruchomic system watchdoga na poziomie 4)

			Zabijanie watchdoga
1. login jako root
2. z linii polecen lub skryptu nalezy wywolac
    ./initWatchdog delete
3. jesli uruchomniony jest watchdog wraz mechanizmem sledzenia traps to
   zatrzymanie lub zabicie wymaga uruchomienia 
	./runwatchdog 2 (poziom 2 zatrzymuje tylko mechanizm trap)
	./runwatchdog 3 (zatrzymuje dzialanie calego watchdoga)

UWAGA! 	inicjalizacja initWatchdog z innymi parametrami niz create/delete nie
	uruchamia ani nie kasuje watchdoga
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------


-------------------------------------------------------------------------------
UWAGA!
watchQS dziala z UID==0 to pracuje na ostatnim core procesora oraz
z najwyzszym priorytetem tzn. -20. 

UWAGA!
wraz z sygnalem mozna przekazac kody (integer)
zakresy kodow przesylanych z sygnalem SIGUSR1 (zarezerwowane)
dla procesu info: 151-250
dla procesu trap&timeout 20-150 (back-signal uzywa kodow 20-150)
dla procesu trap&wait 300-399 (back-signal uzywa kodow 400-499)

UWAGA!
wyslanie funkcja sndsig("watchQS",0) lub sndsig("watchQS",1)
powoduje kill watchdog.
wyslanie sndsig("watd2",10) powoduje kill watd2
zakres kodow 0-19 jest zarezerowany dla sterowania watchdog/demony watchodga

UWAGA!
back-signal SIGUSR2 jest przekazywany z watchdog do kontrolowanego procesu

UWAGA!
Skompilowane aplikacje snd oraz trap sa testowe. Jesli sources trap.c lub snd.c 
maja byc uzyte jako #included w innych modulach SKZ, to nalezy /* int main()*/
Przykladowe uzycie skompilowanej aplikacji snd dla np. zabicia watchdoga
- uruchomic watchdog
- z linii polecen nalezy wyslac: snd watchdog 0 

przykladowe testowe uzycie aplikacji trap
-nalezy uruchomic watchdog
-uruchomic trap
-wyslanie sygnalu z linii polecen snd watd2 401 - skasuje trap, ale wachdog
 dziala nadal
-aby zabic watchdog nalezy wyslac z linii polecen: snd watchdog 0
-------------------------------------------------------------------------------





-------------------------------------------------------------------------------
----------------------------------- watchdog ----------------------------------

watchQS odbiera sygnal SIGUSR1 oraz kod liczbowy (int), 
ktory mozna zdefiniowac wraz z wyslanym sygnalem.
Kod ten jest odczytywany przez watchdog. Ponadto watchdog pobiera
PID procesu z ktorego nastopilo wyslanie sygnalu SIGUSR1.

watchodg dla funkcji trap zasinstalowanej w kontrolowanym procesie
przesyla back-signal o takim samym kodzie za pomoca SIGUSR2.

-------------------------------------------------------------------------------
watchQS kontroluje nastepujace sytuacje:

--- info ---
jesli proces kontrolowany wysyla sygnal SIGUSR1 z kodem z zakresu:
#define MIN_ICODE 151 //minimalna wartosc kodu info
#define MAX_ICODE 250 //max wartosc kodu info
(zakres jest ustalony w bloku definicji watchdog.c)
wowczas wysylany kod jest zapisaywany do pliku tekstowego: /mnt/tmp/WATCH_INFO
kazda linia ma fromat: 2015-08-22 18:15:34 WATCH_INFO&FN=xx&PID=xx&CODE=xx
gdzie:
FN=nazwa procesu kontrolowango przez watchdog
PID=pid procesu kontrolowango przez watchdog
CODE=kod(liczba) przenoszona przez sygnal

---trap&timeout
ustawienie trap w kontrolowanym procesie powoduje 
przeslanie sygnalu do watchdog. Uruchamia process sprawdzenia czy 
kontrolowany proces przebiega w czasie krotszym niz TIMEOUT
#define TIMEOUT 180.0 //[s] w watchdog
przekroczenie czasu TIMEOUT powodwodje restart procesu kontrolowanego
przez watchdog.
Zakres kodow przpisanych od trap&timeout
#define MIN_TCODE 20 //min wartosc kodu dla spr. timeout
#define MAX_TCODE 150 //max wartosc kodu dla spr. timeout


---trap&wait
ustawienie trap w kontrolowanym procesie powoduje wyslanie sygnalu SIGUSR1 do
watchoga wraz z kodem numerycznym (int), ktory mozna wybrac z zakresu:
#define MIN_WCODE 300 //minimalna wartosc kodu wait
#define MAX_WCODE 399 //max wartosc kodu wait
Po wyslaniu trop oczekuje na kod kasujacy, ktory jest rowny kod_wysylany+100
np. jesli proces wysyla kod=301 to aby 
skasowac nalezy przeslac kod_kasujacy=401 (w funkcji clr_trap("301") wysylamy 
taki sam kod jaki byl przypisany do trap tzn. nie dodajemy 100);
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------



-------------------------------------------------------------------------------
-------------------------- funkcje wysylajace sygnal --------------------------
Plik snd.c po kompilacji: snd pozwala na przesylanie sygnalow
z linii polcen:
np.: (snd.c) wysylanie polecen wyglada np.:
#./snd i 151 lub #./snd watchQS 151
kasowanie ustawinej trap 
#./snd t 301 lub #./snd wat2 401 (drugi sposob wymaga dodania 100 do code trap)


w pliku trap.h 
znajduija sie dwie funkcje:  Sa to funkcje
info_watchdog(const char*code)
	sluzy do przesylania sygnalu do watchdoga (watchQS) z kodem = code
	wysylanie kodu: 
		....
		info_watchdog("151");
		...

clr_trap(const char*code)
	sluzy do kasowania  sygnalow zwiazanych z trap&wait
	uzycie: 
	jesli sygnal byl wyslany przez trap z kodem 301
	...
	clr_trap("301");//nie dodajemy 100
	...

w trap.h znajduje sie jeszcze jedna funckja, ktora sluzy do zakladania puplapki
dla trap&time oraz trap&wait:
set_trap(const char*code_send, const char*code_rec)
char code_send jest numerycznym kodem przesylanym do watchdoga
char code_rec jest spodziwanym kodem numerycznym odpowiedzi
(string zostaly uzyte jedynie dla zgodnosci z plikem trap.c -testowym)

przykladowe uzycie:
	(progrm nadzorowany)
	....
	set_trap("301","301")
	...

mozna rowniez do ustawienia pulapki uzyc funkcji bazowej, ktora znajduje sie
w trap.h
przykladowe uzycie w programie nadzorowanym:
	....
	trap(WATCHDOG_NAME,301,301);
	...
UWAGA! definicja WATCHDOG_NAME znajduje sie w pliku trap.h



----- testowanie trap -----
W pliku trap.c znajudja sie w main() testowe przyklady zkaladania pulapek
defaultowo ustawiony jest test2, ktory symuluje ustawiona pulapke w programie
nadzorowanym. Po wywpolanu z linii polcen ./trap 
na ekranie pojawi sie napis "trap&wait ..."
po wyslaniu z lnii polecen ./snd t 301 pulapka zostanie skazowana i
program testowy zakonczy swoje dzialanie napisem "END trap&wait ..."
UWAGA! mozna rowniez wyslac nastepujace polecenie ./snd watd2 401 i efekt bedzie taki sam. W przypadku uzycia funkcji clr_trap tzn. snd z opcja t zamiast watd2 nie dodajemy do codu pulapku 100. 

---------------------------------------------------------------------------------
---------------------------------------------------------------------------------


---------------------------------------------------------------------------------
--------------------------------- demony watchdog -------------------------------
demony sa uwalnianie przez watchdog
watd1.c - jest przeznaczony do obslugi kontroli trap&timeout
w module znajduje sie TEMPLATE, ktore nalezy uzupelnic 
definicjami kontrolowanych procesow wg. wzoru:

		//--------- TEMPLATE ---------
		//przyklad zawsze na koncu musi "&" oraz ch=1;
		//case 20: strcat(boot,"nazwa_apki &");ch=1;break; 
		case 20: strcat(boot,"watchdog &");ch=1;break;
		case 21: /*tu nazwa procesu 1*/; ch=0;break;
		case 22: /*tu nazwa procesu 2*/ch=0;break;
		case 23: /*tu nazwa procesu 3*/ch=0;break;
		// ...
		//------ KONIEC TEMPLATE -------
nazwa prcesu w ktorym znajduje sie trap dla kontroli trap&timeout
nalezy wpisac wedlug wzoru:
strcat(boot,"nazwa_procesu &") - na koncu nalezy doloczyc "&"
				np. "main-loop &"
nalezy rowiniez zamienic ch=0 na ch=1


watd2.c - jest przenaczony do obslugi trap&wait
Uwaga. sygnal kasujacy trap w trap&wait wysylany jest do tego
demona, ktory przekazuje go do kontrolowanego procesu.
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------

------------------------------ Wyswietlanie INFO ------------------------------
mechanizm wyswietlania dla sygnalow typu INFO jest w pliku memdisplay.c
po skompilowniu wywolanie:
#./memdisplay - powoduje wyswitlanie zdarzen i czasu jaki uplywa pomiedzy
                zdarzeniem aktulnym i poprzednim dla wybranego sygnalu
		oraz wyswietla alarmy jesli zostal przekroczny timeout 			(taki sam dla wszystkich INFO, zdefiniowany:
		#define ALARM_ON_MEMDISPLAY x
		x - liczba sekund po ktorej bedzie wyswietlany dla kodu "info"
		kodu sygnalu napis ALARM.
#./memdisplay file (uruchamiany z parametrem file) nie wyswietla na ekranie 			   zdarzen INFO ale zapisuje je do pliku 
		   /mnt/WDbuf/SCREEN_SAVE.
		  format zapisu linii sygnalu z kodem={151..250}:
		  c=code&p=pid&d=diff_time
		  gdzie c-jest kodem "info"
			p-pid procesu gdzie jest wolana funkcja info_watchdog(..)
			diff-time czas w seundach jaki uplynal od ostaniego
			          "info" do aktualnie odebranego



W pliku: memdisplay_code_to_name.h mozna przypisac do kodu {151...250} nazwe
	 ktora bedzie wyswitlana zmaist nr kodu. Jesli nazwa nie bedzie 
	 przypiasana to bedzie wyswietlany nr kodu. Nazwa rowniez zostanie 
	 zapisana w query stringu do pliku SCREEN_SAVE. 
	 Przypisanie nazwy wg. wzoru:
	 #define CODE151 "*" nalezy zamienic na #define CODE151 "jakas nazwa"
	 Nalezy wykonac ./compile

UWAGA! memdisplay mozna uruchomic w dowolnej chwili poniewaz interface memory
	dziala stale w czasie dzialania watchQS (watchdoga).

Ponadto, w katalogu ADODATKI znajduje sie prototyp funkcji (file_to_stream.c)
zmieniajacej plik SCREEN_SAVE na strumien dla przekazu zapisanych danych poprzez
server_Admin do client_Admin. Funkcja strumienia dziala niekolizyjnie
jesli zapis do pliku SCREEN_SAVE dokonuje memdisplay. 		 
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------




-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
			MODEL DZIALANIA WATCHDOGA
-------------------------------------------------------------------------------

				     |------> watd1 (dla "trap&time")
#./initWatchdog create ----> watchQS |
			        |    |------> watd2 (dla "trap&wait")
				|
				|
				V
			   (dla "info")
			memory interface
			  (mem_lib.h)
				|
				|
				|
				V
			   ./memdisplay ---> wyswietla 
					    "CODE: ... PID: ... DTTIME: ...
		    [uruchomienie ./medisplay file]
				|
				|
				V
			 zrzuca zawrtosc ekranu
		    do pliku: /mnt/tmp/SCREEN_SAVE
	           format: c=code&p=pid&d=diff-time
				|
				|
				V
			w katalagu ../ADODATKI
		   znajduje sie prototyp funkcji
			file_to_stream()
		     w pliku file_to_stream.c
		    dla strumieniowania "info"
		      z pliku SCREEN_SAVE 
		 poprzez server_Admin --> client_Admin
		 


UWAGA!
#./initWatchdog delete ---> robi kill procesow watchdoga oraz odmontowuje
                            katalog roboczy /mnt/WDbuf (RAM disk)
			    oraz kasuje katalog /mnt/WDbuf wraz zawartoscia.

-------------------------------------------------------------------------------
-------------------------------------------------------------------------------




-------------------------------------------------------------------------------
----------------- Konstrukcja i dzialanie mechanizmu watchdog -----------------


Przypadek 1
dzialanie dla sygnalow "info"

	info_watchdog("code") 
	 code = {151...250}
	    umieszczona 
		w
	module kontrolowanym --> watchdog --> akcja watchdog
						   |
						   |
						   V
					    zapis do pliku
					    /mnt/tmp/WATCH_INFO








Przypadek 2
dzialanie dla sygnalow "trap&timeout"


    set_trap("code_send","code_rec")
      zazwyczaj code_send=code_rec
    code_send={20...150} dla trap&time
            umieszczona 
		w
	module kontrolowanym --> watchdog --> akcja watchdog 
	     ^					   |
	     |					   |
	     |					   V
	kasowanie trap		         spr. przekroczenia 
	     ^					TIMEOUT
	     |	    brak przekorczenia <-----------
	     |		|     			   |
	     |		|			   |
	     |		V			   V
	      ---- back_signal               przekroczenie
					   uruchamia demona
					        "watd1"
                                                   |
			                           |
						   V
					kill modulu kontrolowanego
						   |
					           |
						   V
					restart modulu kontrolowanego
					          oraz
					   zakonczenie dzialania
					       daemona watd1





Przypadek 3
dzialanie dla sygnalow "trap&wait"


    set_trap("code_send","code_rec")
      zazwyczaj code_send=code_rec
    code_send={300...399} dla trap&wait
	          w
	module kontrolowanym -----> watchdog ---> uruchmia demona
		^				      "watd2"
		|					 |
		|				         |
		|					 V
		|				    demon czeka
		|				     na sygnal
		|					 |
		|					 |
		|					 V
	 	|			         przyjscie sygnalu
		|				     kasujacego
		|				         |
		|					 |
		|					 V
		----------------------------------- demon wysla
						     back-signal 



	sygnal wysylany przez proces kontrolowany: SIGUSR1
        back-signal: SIGUSR2

kasowanie trap: trap.h --> clr_trap("code") code={300..399}
		lub z linii polecen ./snd t code  
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------



-------------------------------------------------------------------------------
--------------------------- Dzialanie mechanizmu watchdog ---------------------
     wewnetrzna synchornizacja cyklow odbierania i przetwarzania sygnalow

	


	trap lub sndsig ------- > loop z pause/sleep
					   |
				           V
				     zapis do matrix
				 	 -------
					|	|
					|	|
					|	V
					 -------
				        loop sync 
				     odczytu z matrix
				            |
					    |
					    V
				    zapis do pliku info
					   lub
				     uwolnienie demonow
				     "watd1" lub "watd2"		
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------















