Cleanup: Uppercase the Object and Content for FSS Basic List Write help.

Bugfix: FSS Basic Read and FSS Basic List Read problems and cleanups.

The delimit is not being calculated correctly.
The fss_basic_read_load() and fss_basic_list_read_load functions are out of place.
The parameter order for some functions like fss_basic_read_print_at() are not adhering to the ordering practices (constants on the left).
The total is not consistently being counted.

The FSS Basic Read is not taking into consideration when Content is empty and --object is or is not selected for some line specific processing.
When there is only --content, then whether or not Content is empty matters.
When there is --object (or both --object and --content), then whether or not Content is empty does not matter because Object is already taking up a given line.

Cleanup: Update case of Object and Content in help of FSS write programs.

Cleanup: Use number instead of word in FSS Basic Read help.

While committing the FSS Basic List changes to be in sync with this, I noticed that I had "..start at 0 instead of one..".
This is inconsistent.
I either need to use both words ("zero" and "one") or both numbers ("0" and "1").
I opted to use the numbers.

Update: Get FSS Basic List Read in sync with FSS Basic Read changes.

Apply all changes recently performed on FSS Basic Read as appropriate.

Update: Improvements and tweaks in FSS Basic Read.

Add additional help information.
Cleanup comments.

In some cases the total printing is inverted by accident.
The print_object function pointer doesn't really need to exist anymore.
Add missing print for when both total and line parameters are specified.

Cleanup: Comments in IKI Read functions.

Bugfix: Status codes F_complete_not_utf_stop and F_complete_not_utf_eos are not handled properly.

The previous commit: "Bugfix: UTF-8 characters are not being fully printed" exposed that these error codes are being improperly handled.

Bugfix: UTF-8 characters buffer is incorrectly returning an error.

The previous commit: "Bugfix: UTF-8 characters are not being fully printed" exposed that for UTF-8 characters (width 2 or greater), an error is always returned.

When the width properly fits in the requested range, return the appropriate success code instead of an error.

Bugfix: UTF-8 characters are not being fully printed.

The UTF-8 bytes are correctly checked but when it comes time to print, the fputc() is only called for the first byte.

Cleanup the operators to have '++' and '--' to be prepended rather than appended.

Get out of the practice of using "register".
I don't have time to focus on these kinds of optimizations.
Just leave it to the compiler for now.

Update: FSS Basic Read --delimit parameter improvements.

The previous implementation is weak in that there is no good way to just delimit Object or just delimit Content.

Redesign to allow for specifying the delimit parameter multiple times and therefore allow for customizing what to specify.
Rename "depth" to "content" in the delimit enum to better communicate that this is for "content" delimiting.

Examples:
  - "fss_basic_read --delimit object": Results in delimited Objects but not Content.
  - "fss_basic_read --delimit 0+": Results in delimited Content (position 0 and greater) but not Objects.
  - "fss_basic_read --delimit object --delimit 1-": Results in delimited Objects and delimit Content (position 1 or less).

For this standard, there is no delimit support in Content so the use of the numeric range is superfluous.
Having this functionality, however, makes it consistent with the rest of the FSS Read programs.

Regression: FSS Basic read --select is always returning empty sting or 0.

After changing the code structure, the check to see if the select number is non-zero was lost.
As a result the code is always operating as if the select number is non-zero.

When the select number is zero, all existing operations should continue.

Cleanup: Uppercase the Object and Content for FSS Basic Read help.

Bugfix: Incorrect macro definition structure resulting in invalid inverse (!) checks.

I seem to have forgotten to wrap these macro checks in parenthesis.

As a result something like "!macro_f_file_type_is_block()" would expand to "!macro_f_file_type_get(mode) == f_file_type_block".
What it should expand to should be logically equivalent to "macro_f_file_type_get(mode) != f_file_type_block".
The expansion with the parenthesis would be: "!(macro_f_file_type_get(mode) == f_file_type_block)" and that is indeed logically equivalent.

Cleanup: Remove unused variables and other minor changes.

Thanks to GCC's -Wall, I was able to find and remove several unused variables.

Also perform some minor cleanups of things that I happened to notice while removing the unused variables.

Cleanup: Disable parenthesis warning in GCC.

This is another case where the compiler is overstepping itself.
The programmer should understand the language and the order of operations.
Disable the warning by passing -Wno-parentheses.
(The warning only appears if -Wall is given, but if -Wall is passed then -Wno-parentheses should be already in place.)

Cleanup: Sloppy use of "main" inside of "main()", oops.

I cannot believe I let this one slip through (and so did the compilers).

When I refactored "data" to be "main" this included the refactor in the function called "main".

This is dangerous at worst and at best bad practice.
Given that "data" is no longer to be used in the main(), just rename the uses of "main" back to "data" for the variable name only (not the typedef structure name).

Cleanup: FSS Basic Read parameter processing, file variable related, and some ++/--.

Simplify the parameter processing using an array to avoid repeating similar code.

Relocate the file variable so that it goes out of scope and is removed from the stack before processing.
The file variable is no longer needed during processing with the current design so don't hold it in memory after it is no longer needed.

Relocate the file stream close so that it doesn't need to be specified as many times in the code.

There are some ++/-- postfixes in use that would be better as prefixes (such as changing i++ to ++i).

Regression: FSS Basic Read default should be Content.

When redesigning the code structure, I forgot to ensure that Content is the default if neither --object nor --content is specified.

Feature: Add F_success and F_success_not status codes.

After some consideration I have decided to support the compliment of F_failure and F_failure_not.

Update: Implement data structure in FSS Read.

This is the designated follow up commit for resolving the need for a "data" structure.
The parameters are now extracted into a bitwise "option" property on the "data" structure.

The process is now broken up into multiple functions.

Update: Remove the "amount" from file stream functions.

The "amount" is present to support the parameters that fread() and fwrite() utilize.
This makes no sense to me and it is annoying and confusing.
I end up having to just put 1.

Get rid of it and just use the file.size_read and file.size_write to specify the buffer size to read/write.

The only things that I can thing of might be atomic operations, locking, and calling the function multiple times.
These are good reasons to have an "amount".

If I end up wanting o needing an "amount", I may add additional functions later on.

Cleanup: Standard code practices refresh.

This is a "quick" run through to refresh the syntax and style with the latest practices.
This fixes any observed styling change.

I noticed some probably errors and added appropriate @fixme comments.

Update: FSS Basic Read program to use memory allocate/dellocate functions and fix error messages.

Remove the allocation and deallocate macros.
Add allocation and deallocation functions in their place.

This makes the common.h and common.c structure more consistent.

Some of the error messages are not respecting verbosity.
They were probably written before the current verbosity implementation was fully realized.

Cleanup: Always have private-common.h and private-common.c for programs.

I am now introducing a new standard practice of always having a private-common.h and private-common.c for programs.
The private data types shared across the program will be stored in these.
These will also provide any functions for allocating, deallocating, or otherwise managing those private structures.

This makes no effort to move over or implement any of the allocation/deallocation functions.

Individual programs will be updated on an as able basis to address this.

The Controller program already has this but it has a bit more than this practice.
The Controller program will see some structural cleanup in the future.

Refactor: Relocate 'macro' prefix in names for macros.

Placing 'macro' after the project name, such as 'fll_' or 'fake_', is a good idea for keeping the function names consistent and contained within the project naming structure.
For short names like 'f_' and 'f_string_t' this is not a problem.
For complex and usually longer names, such as 'fake_' and 'fake_main_t', this becomes confusing quickly,

I have decided to favor the less consistent macro as a prefix to the project name, to make the code a bit more readable.
For example: 'fake_main_macro_delete' would become 'macro_fake_main_delete".

Refactor: Use 'main' instead of 'data'.

The original goal of 'data' is to be used as the main store of data for the program.
A program using the programs as a library are also expected to get and use this structure.

The problem is that the programs are designed such that the caller to the program (as a library) should not have access to internal details.
Refactor 'data' to 'main'.
This is a more precise name in that it is the structure passed as if it were called from 'main(argc, argv)'.
This also frees up 'data' for internal use such that 'data' can now be the more generalized 'data' without exposing anything to 'main'.

The Controller program is already using 'main', so that 'main' was refactored to 'global'.

There are still more changes to do, such as restructuring the 'main' types to ensure nothing unwanted is exposed to a caller.
These additional changes, however, are beyond this scope of this commit.

Bugfix: Several of the parameters are not handling the desired set of possible combinations.

With recent changes, more parameters may be used together than before.
This exposed how several combinations simply did nothing or did not do what was expected.

Redesign and even simplify the code to allow these parameters to work together.

Some of the code is abstracted out into their own functions.

There is a goal to have a data structure for passing setting, but before that is done I want to make other significant changes FLL-wide.
For this reason, I am putting in place a temporary 'print_this' bitwise variable.

Update: Redesign Basic List loading logic to load all files into a single buffer.

Upon further use and review I believe that it is better to treat all input sources as a single buffer.
This allows for all of the parameters to work closer to what feels like normal logic.
If I want to get the total lines for all listed files, then I should get that.
If I want to get the total lines for each listed file, then I can call this program once for each file to get that.

I am working on Basic List first but this will be repeated for all of the other FSS read projects as well (likely in a single commit).

One of the downsides of this is that it exposes a current design limitation where the max buffer size is more likely to be reached.
Future work will most likely address this in some manner.

Regression: Incorrect char type resulted in SIGPIPE.

The uint8_t/int8_t was changed into char recently.
This change appears to have be incomplete for the Byte Dump program.

Update the code to be aware of PIPE by passing a NULL string to represent a PIPE instead of a file.

While fixing this, go ahead and replace read() with fgetc().
This is more efficient due to the use of a file stream.
The use of read() is originally done for testing some of the lower-level FLL design.
This testing is no longer necessary so it is worth switching to fgetc().

Future design may merit reading larger chunks than 1 character at a time.

The use of fseek() is now available and in use (for non-PIPEs).

Minor code tweaks, such as changing i++ to ++i.

Feature: Provide fll_program_parameter_process_empty().

This should further simplify the standard color processing code for when color codes are replaced with empty strings.

Update: Lift the restrictions on specifying -o with -l, -s, and -t for the FSS read programs.

At some point the FSS read functions were not designed to allow -o and -c at the same time.

This is no longer necessary.
Remove the checks and the code appears to work as expected.

Update: Next micro version (0.5.4).

Bugfix: Previous uint8_t to char resulted in accidental changes.

This should remain int8_t.

Update: Replace static strings with extern defined in common file.

This makes the controller program more consistent with the FLL projects.
This should make it easier to use the controller program as a library as well.

Update: Fix problems and make changes after testing LLVM's Clang compiler.

Add flags "-Wno-logical-not-parentheses" "-Wno-logical-op-parentheses".
Programmers should be expected to understand the language they are working.
Having the compiler for a style is bad practice.

The cap_to_text() needs ssize_t, do not use f_array_length_t.

The project is inconsistently using int8_t and uint8_t for character types.
Furthermore, clang likes to complain about uint8_t being converted to char.
(I believe uint8_t is supposed to be of type unsigned char and char by default is supposed to be unsigned.)
Fix the inconsistency and just use char, which happens to make clang happy without any complaints from gcc.

Clang does a much better job at detecting some problems than GCC.
Compiling with clang resulted in revealing several printf related problems that now should be fixed.

The f_gcc_attribute_visibility_internal (and related) have the "_gcc" removed because these seem to exist beyond just gcc (such as with clang).

Make sure something is always returned.
There are some functions that didn't have a return.

One of the UTF processing functions has an accidental hex character in the condition.
Remove the extra character, which I am pretty sure is the leading "d".
I have not validated the correct sequence and so further investigation in the proper sequence for U+1D7CE to U+1D7D7 may be warranted.

The clang compiler claims that int main() should only be an integer for the argc.
This is unfortunate but that is fine, switch to use an int instead of an unsigned long.

Update: Support legacy-only capability by default.

Bugfix: Fake should ceate parent directories for the "path_headers".

This really should be done for all cases like this, but for now just fix "path_headers" and add a todo comment.

Cleanup: Relocate headers into appropriate sub-directories.

Have the FLL project contain its headers within a sub-directory of 'fll'.
This promotes better organization.

The level_3 programs are just that, programs, and as such will not be under 'fll' but instead will be under their own sub-directory.

The programs are moved out of level_3 and into the program include directory, with their sub-directory using the program name.

Bugfix: Setting path_headers_preserve should still honor path_headers setting.

When both path_headers_preserve and path_headers are provided, the path_headers should still be used.

Cleanup: Use simpler logic for used > 0 check.

The logic fo checking if used > 0 can be made simpler by simply checking used.
(Given that used is always unsigned.)

Update: Include example settings when building Controller.

Update: Support legacy-only capability by default.

Bugfix: cap_mode_t is not available in legacy capability.

Cleanup: rename program data delete functions.

Previously the style was to have "action" and then "data".
The new approach is to completely represent the name and then display the "action".

Thus byte_dump_delete_data() becomes byte_dump_data_delete() because the data structure is called "byte_dump_data_t".

Update: Remove init program.

The controller program can fully operate as a init program.

The pre_init/pivot_root will likely have its own dedicated program and/or scripts.

Bugfix: PID and PID file should account for multiples during process execution.

I forgot all about needing to do this so I am considering this a bug.

Each process may execute multiple Actions.
Each Action has its own PID.

In the case of foreground (synchronous) execution, having only a single PID and PID file path on the Process structure is not a problem.
When with PID file (asynchronous) execution operates, multiple PIDs (and respective PID files) may exist for any single Process structure.

Use an array of PIDs and PID file paths.

Cleanup: Replace 'test' with 'simulate'.

Prior to this "test" is being used interchangeably with "simulate".
Changing "test" to "simulate" makes the program more consistent with itself.

In the help, use the word "parameter" instead of "operation".

Regression: Entry error after failure or during validation is not propogating.

When an Entry fails and successfully executes a failsafe, the failure is not propagated.
The failsafe is meant to bail out and not continue onward, so after a successful or failed failsafe, return F_failure (with error bit as appropriate).

When passing --validate without --test, the program is not exiting as it should.
This is because the state is not being handled just like the status is not being handled.

When joining threads, be sure to reset the identifiers.

Remove now extra Exit processing block.
This is now handled fully by the cancellation function.

Restore the thread enabled state after operating failsafe.

Get rid of simulate variable, instead use the console parameter directly.
This saves memory by a trivial amount.

Regression: validation is printing "synchronous" when it should print "asynchronous".

Update: Implement "execute" support and fix bugs.

Provide new feature for executing into another program.
This is provided via the new Item Action "execute".

The function controller_perform_ready() is being called and the status is being checked but the status is not being assigned.

There are a few cases where thread.enabled needs to be checked and a few cases it does not need to be checked.

Several of the threads need to be aware of the normal/other status to properly determine the thread.eneabled situation.
Without this, they make incorrect decisions that result in bugs.
I did not want to implement a new structure to resolve this so instead provide custom wrapper functions to call that set the appropriate normal/other state.

The functon controller_thread_process_cancel() now needs to be caller aware so that the caller does not get cancelled.

Feature: add support for F_execute and F_execute_not status codes.

Update: Add documentation about the design problems around POSIX cancellation.

Cleanup: remove extra newline printing on exit after failsafe in verbose mode.

Update: Improve entry/exit verbose messages, display exit with -tv, and wait all with read lock fix.

The verbose messages should be distinguishing between an entry and an exit now.

When both --simulate and --test are specified, the printout should include both the entry and the exit.
Previously, only the entry was printed.

The wait all should only be triggered to wait for all processes at the current moment in time.
Furthermore, the read lock is being held too long (for the entire loop).
Maintain the read lock long enough to build a list of all processes to wait for.

Update: signal wait after each time the state becomes "idle".

This should give processes waiting more opportunities to wake up.

Cleanup: display "exit" instead of "entry" when finished process an exit file.

Progress: redesign processing logic to accommodate different process Rule Actions and update dependency design accordingly.

When I implemented the "exit" support (opposite of an "entry") I noticed a oversight in the design whereas there was no way to distinguish between a process that successfully started via the "entry" or the "exit".
Change the design to now utilize unique Rule Processes for each Rule Action requested.

This required further changes to the status handling.
A rule status is now an array of all possible Rule Actions.
This is utilized using a static array for simplicity purposes (there is no need for a dynamic array here).

All of the recent changes introduced a lot more complex code.
There are now helper functions to help facility common tasks.
This should also make updating easier as there is only one place to update.
The downside is the introduction of an additional function call (which is a tiny runtime cost).

To facility this new design, the Rule files must also be aware of the different Rule Actions.
The "need", "want", and "wish" have been relocated into a new Rule Action called "on".
Additional parameters for an "on" allow for describing the Rule Action in which the dependency applies to.
This allows, for example, a "stop" Action to operate in a different order than a "start" Action.
An example of this is provided.
Look at the data/settings/example/rules/serial/*.rule files.

An example syntax is:
  on start need serial s_1
  on stop need serial s_3

When validate is passed, do not wait for asynchronous processes because they are not run.
Normally this is not noticeable but is exposed when 'script/fail' failed to execute and return ('script/fail' should execute, fail, and return).
This bug is caused by the wait functions not checking to see if the caller is the same as the current process (it was waiting for itself).
This may have been introduced as a result of the redesign.

Progress: Redesign enty/exit rule handling, now requiring Action instead of "rule".

The Entry and Exit files are using "rule" to designate a Rule to operate.
This is designed on the assumption that an Entry always runs a "start" and Exit always runs a "stop".

This behavior is changed such that "rule" is no longer specified and one of the 9 supported Actions may be used.
Such as "start" or "stop", for example.

There is still more work to do as this change doesn't fix the Exit in terms of dependency handling.
Currently, the process structure does not distinguish the Rule action, such as "start" or "stop".
Additional changes to the process structure are needed.

Progress: controller program, add exit support.

This implements the initial work needed to get exit files working.

A new thread is added to handle both "entry" and "exit" to free up the "rule" thread and allow for the "exit" to start will the "rule" thread exists.

The thread enabled process is now more complex given that there needs to be stages so that "exit" threads can work while "entry" or "control" operations begin terminating.
Add several helper functions to help simplify the detection.

Add an "alert" lock to send/receive alerts.
This is a more general purpose lock that tells something waiting on the alert to wake up and see if anything you care about changed.

The file loading now needs to be aware of "optional" files, namely the exit files.
If the named exit file does not exist, then do not care as it is not required (unlike entry and rule files).

Many of the read and write locks are now timed so that they can check to see if the controller is enabled or not.

While working on this I noticed some oversights and things that I did not previously consider.
I need to follow this up with a redesign in the entry/exit rule handling.

Instead of "rule", I should have the rule actions like "start" and "stop".

There needs to be support for default behaviors, such as allow for "stop" to not have a parameter and to correctly find and terminate a service.

There needs to be consideration on dependencies when exiting, perhaps there needs to be an exit-specific dependency management.

Progress: exit prep work, reserve and implement "setting" in entries and exits, add option to "ready', and update documentation.

Add documentation, specifications, and basic structural changes for the "exit" files.

The "entry" and "exit" files now reserve "setting" for designating settings.
Currently, only "entry" supports a setting and that setting is "mode".

The "mode" setting designates how the entry program is intended to behave.
When operating as a "service", the controller program will wait indefinitely for commands (via the not yet implemented "control" program or "control" socket).
When operating as a "program", the controller program will immediately exit after completion.

The "ready" Entry Action now supports "wait".
When "wait" is provided, the "ready" operation will wait for all current asynchronous processes to complete before operating.

Update documentation and specifications, adding the "exit" files.
Cleanup the existing documentation and specifications, fixing wording.

Update: display when done processing entry when verbosity is set to verbose.

Update: include rule status when wait all function when waiting.

Bugfix: asynchronous processes not executing properly according to dependencies.

The controller_process_wait() function is returning immediately because the status is being changed and is only checking for F_time.

Add status_lock to separate it from status.
Return if status is an error.

Require Rule status to be both not F_known_not and not one of "active" or "busy".

If processes are waiting for a while and a signal is received, decrease the wait timer.

Update: use the action of the process type, preparing for implementing exit files and the control program.

Update: implement with pid execution, simplify related rules.

Implement the with pid execution.
This expects the process to be spawned in the background.

After some review, I decided to remove "use" and "create", replacing those with "pid_file".
The reasons are:
- For "use", the spawned service manages the pid file, so it would be overly complicated to try and manage it in addition to the spawned service.
- For "create", if the process is to go into the background, in order to manage it then there would still need to be a running process (this defeats the purpose).

When the termination signal is received, then inform any background process spawned by the controller program to exit, based on the existence of the pid file.

Update: generalize the pid file creation and deletion.

The PID create and delete functions were written as intended specifically for the main controller program.

PID files are to be used by services and utilities, therefore the PID create and delete functions should also be used there.

Detect if the main PID file is created and then only attempt to delete it on exit (and then do not do so for child processes).

Bugfix: invalid file descptor error on stream close.

This caused both flushing to fail and closing to fail.

Make flushing more flexible and more optional, expanding the close functions to be non-autoflushing and autoflushing.

The fclose() closes the file stream and therefore the descriptor will be invalid.
In this case, the descriptor need only be reset to -1.

If the stream property is not populated and "complete" is designated, then close the file by the file descriptor id.

Update: fix file stream error return, improve file error messages, add new status types and remove status types.

The f_file_stream_close() function is missing some errors.

The file error message printer is missing several error messages.
There is also some cleanup is needed in the file error messages (consistency problems, mostly).

Add F_file_overflow, and F_file_underflow for file specific overflow and underflow.
Add missing F_file_descriptor_not.

Remove F_file_allocation and F_file_deallocation, only the generalized F_memory and F_memory_not are used now.

Update: handle F_failure error in fll print function.

Cleanup: relocate fl_color code to f_color and remove fl_color.

Ever since f_string became a core/required/special project where all level_0 could depend on it, fl_color no longer needed to be at level_1.
Relocate fl_color into f_color, removing the fl_color project entirely.

Update all dependencies.
This exposed some missing dependencies in fll_program that fl_color is secretly handling.
Fix that as well.

Feature: controller program must support "with full_path".

This is necessary to accomodate fickle programs like SSHD where the full path in argument[0] is required.

This implements a general feature called "with" which is provided to add flags on a per Rule Type basis.
These flags will tweak the Rule Type is some manner.

Only one flag is suppoted at this time: "full_path".
The "full_path" provides the necessary functionality to make SSHD happy.

Update: redesign fl_execute_parameter_option_path in fll_execute.

The previous design of fl_execute_parameter_option_path seemed pointless because it could be detected if a slash is in the progam name.
Recent changes have utilized the slash in the path to do just that.

While working with the controller program the SSHD program revealed that some programs are fickle about what is in their argument[0].
SSHD wants the full path and as such it needs to be provided.
This makes sense as the normal behavior of most programs when started with a full path general expect a full path in argument[0].

The fl_execute_parameter_option_path is redesigned to instead provide a full path for program and for argument[0].

Examples:
  - "bash my_script.sh" (without fl_execute_parameter_option_path), results in: program="bash", argument[0]="bash", argument[1]="my_script.sh".
  - "/bin/bash my_script.sh" (without fl_execute_parameter_option_path), results in: program="/bin/bash", argument[0]="bash", argument[1]="my_script.sh".
  - "bash my_script.sh" (with fl_execute_parameter_option_path), results in: program="/bin/bash", argument[0]="/bin/bash", argument[1]="my_script.sh".
  - "/bin/bash my_script.sh" (with fl_execute_parameter_option_path), results in: program="/bin/bash", argument[0]="/bin/bash", argument[1]="my_script.sh".

Bugfix: fll_execute does not execute full path.

When passed a full path to a program (rather than depending on detecting in from just a program name) the program does not execute.

There are several logic flaws and mistakes.
- The last_slash should have "+1" to avoid including the slash itself.
- When environment is cleared, it need to potentially use "program" or "arguments.array[0].string" if a slash already exists in the provided name.
- The final NULL at the end of the program_path string is missing.
- The "program" or "arguments.array[0].string" should be used in general instead of always the "program" only.
- The fixated_is is being used incorrectly in private_fll_execute_path_arguments_fixate (and the documentation is incorrect).

I suspect that these functions are messy due to changes in design that were not fully updated (including the appropriate documentation).

Bugfix: properly configure example.

The reason why controller is attempting to execute "/var/run/sshd.pid" is not because it is incorrectly attempting to process the "use" as a start.
Instead, it is because it is properly attempting to do so because it is being told to.

Oops! This is just a simple misconfiguration and not a bug in the code.
A bug in the configuration.

Progress: controller program, begin working on pid file related executions.

It occurred to me that I could quickly create a process with a PID file using a script.
I then realized that "service" only applies to binaries and not scripts.
Add a new type called "utility" that is identical to "service" in purpose except that it processes scripts.

Begin implementing the PID file related code.
It seems there are a few things to address, such as proper test output display.
For example, I am seeing "Simulating execution of '/var/run/sshd.pid' with the arguments: '' from 'SSH Service'.".
That "/var/run/sshd.pid" should instead be "/usr/sbin/sshd".

Creating or checking existence of the PID files is not yet written.
The behavior of after a process forks is not yet written either.

An error needs to be printed and F_failure (with error bit set) should be returned.

The "success = F_failure" should probably have error bit set.

Add new rules and entries for testing this (to be implemented) functionality.

Update the documentation.
Some of the documentation is outdated and as a result, wrong.

Update: implement read lock handlings support.

There are some cases where I am able to figure out a way to make the logic continue on on failure and handle the case of read lock failure.
There are other cases where I am not yet sure how to handle.
Expect more changes in the future to address ability to continue onward on lock failure.

Some functions now return F_lock (with error bit) to designate that the lock failed.
In these cases, it is for functions that require the caller to have a read lock (such as process->lock) locked before starting.
When such functions return the caller now has a way of knowing that the read lock is no longer held.

Remove now pointless "busy" variable.

Update documentation comments with @todo.

Update: handle write lock failures, begin adding support for handling read lock failures.

Get the response on write lock failure.
Present an error message.
Return the error status.

Increase the cancellation timeouts from 0.06 seconds to 0.6 seconds, making it less aggresive.
This results in a 90 second max timeout, which gives more problematic exists a lot more time to cleanly exit.

Begin adding support for getting and handing read lock failures.
Read locks attempts will be in a loop that checks main thread enabled as well.
The timeout is longer than write locks to reduce the CPU overhead as there will be a lot of read locks.
Follow up work will utilize this read lock status handling.

Remove the additional thread enabled check that follows a write lock.
The write lock already checks if the main thread is enabled.

Update: f_thread_lock_read_timed() should return F_resource_not.

The pthread_rwlock_timedrdlock() potentially returns EAGAIN.
This needs to be handled, translated into F_resource_not (with error bit), and then returned.

Update: handle asynchronous failures for failsafe, update locks, and related fixes.

The failsafe needs to be triggered when a required but asynchronous process fails.
I originally planned on implementing this via locks but I would rather avoid adding even more locks.
This approach instead provides a wait loop at the end of the entry waiting only on all required processes.
If any of these fail, then the wait will return the requirement failure.
This is a change to the wait all function and behavior, which is updating to now return statuses.

Get rid of process->status, it is no longer needed now that process->rule.status exists.
Having it remain is wasteful and confusing.

The entry processing is updated to be failsafe aware.
This now potentially operates the failsafe rule item.
The failsafe must not do a wait all like normal operation inside of the entry processing function.

There are some discrepancies between "process options" and "rule options".
Technically, there are no "options" on a rule as this is a concept introduced for/by entries.
The process uses these options but most of them were named "rule options".
I then later created a "process options" to add override so that even if the rule is requested asynchronous, if a dependant thread is requiring it, then it will instead run synchronously in the thread of the depending process.
This resulted in both "process options" and "rule options".
They really are the same, so instead remove the current "process options" and rename all "rule options" into "process options".
There are now no longer any "rule options".
I then renamed the "process options" variables to "force options".

Remove signal_all from delete process.
The signals should now all be timed and will exit when thread disabled is set.

The execution used to be designed with the intent that is where the asynchronous processing would handle.
After multiple iterations in design, this is no longer the case.
Update the code to always pass parameter option fl_execute_parameter_option_return instead of doing it only for asynchronous processes.

Add missing re-locks.
Some of the functions require that a certain (read) lock be held prior to calling the function.
When the function returns, the expected lock should still be held.
It so happens that this is not consistently the case.
Certain error or exit states are returning without re-establishing the expected (read) locks.

The controller_rule_find() returns a boolean and not a status with potential error bits.
Fix a block of code where it is checking for error bit on the return value of this function.

The controller_rule_read() also returns a boolean and is being handled as a status with a bit.
In this case, change it to return a status given that this make more sense in this particular case.

Remove relevant/related stale code and add missing comments.

Update: f_thread_lock_read() should return F_resource_not.

The pthread_rwlock_rdlock() potentially returns EAGAIN.
This needs to be handled, translated into F_resource_not (with error bit), and then returned.

Progress: controller program, implementing failsafe.

Minor code cleanup:
- Removing no longer valid documentation.
- Cleaning up syntax, such as spacing.
- Updating documentation comments.
- Pass controller_main_t as a pointer in the entry function, updating all uses.
- Remove @fixme for considering status handling because I don't plan on bothering with this now.

A lot of the controller_print_unlock_flush() calls are using the incorrect stream.

Use status_lock as a return in cases where the status that is retuned shouldn't become lost when processing the locks.
Otherwise, the errors may never properly bubble to the parent and therefore may never trigger the failsafe.

The failsafe is not a rule id, but instead an item id.

If and when failsafe support is enabled, trigger it.
The currently implemented code only handles synchronous failures.

Begin work with adding a "failed" flag so that asynchronous, but required, failures can be detected for the purposes of failsafe execution.

Update: add comments, fix action type error reporting, and fix entry documentation.

Be consistent and add comments when dealing with nanoseconds.

Action types "consider" and "rule" should be the ".. or more.." error messages.

The entry documentation should be using the word "need" and not "require".
Improve wording.

Update: properly process and support -c/--control custom control group file path.

This is a directory path to the sysfs cgroups directory.
It must end in a path separator '/'.

There is existing code that needed to be updated to use the -c/--control.
It was being ignored!

Cleanup: fix parameter order of fl_conversion_* functions.

Cleanup: remove "local" workaround in execute function.

At the time I was unable to determine the cause.

Now, I strongly suspect it was due to the way threads were being created on the parent stack and the child threads could not access them once a resize function happened.
The resize can, on occasion (and likely more often than not), relocate the address location of the range (array).
This relocation in memory likely caused the weird memory behavior.

Now that the memory is allocated such that the it is an array of allocated pointers, the memory addresses should not change when the array of pointers is resized.
The address to the pointers might change, but from the perspective of the child threads, they don't exist or otherwise matter anyway.

Removing the work around cleans up some clutter and what is essentially a waste of resources.

Update: cleanup @todo/@fixme that no longer matter and implement multistep thread wait timeout.

Bugfix: validation is not processing dependencies.

There is a return statement that must no longer be there.
Make sure to always pass the validation bit.

Bugfix: test mode (-t), should be simulating not executing.

The rule_options is setup but it seems that I forgot to actually pass it.
Set the controller_process_option_execute on the rule_options and then pass rule_options instead of directly passing controller_process_option_execute.

Bugfix: child process PID is not being passed properly and child process prints failure message on terminate signal.

The child process PID was not being assigned because the wrong variable was being passed.

The child processes should not present error messages on exit when termination signal is received.
Make sure that when the child process exists and the main thread is disabled, exit with F_signal.

Bugfix: main process doesn't always exit.

Remove stale lock and unlock that was used for testing or experimentally.
This was causing it to wait for something that would never release the lock because it was closed resulting in a deadlock and the main process hanging on exit.

Bugfix: rules not properly handling status.

The status F_known_not was incorrectly being treated as busy.
Make sure to guarantee lock and then unlock of the process_other lock (read lock) to prevent execution of dependent rule while analyzing state of dependent rule.

Read the rule's status after executing from the rule in the rules array and not on the process.
The rules on the rules array is updated after execution but the process is not guaranteed this.
The status of process is generally reserved for the process to manage the status and not to represent the rule status.

Expanded the example serial execution test entries and rules.
Add a new alternative serial so that one uses normal execution and other uses dependent execution (execution is executed by something depending on it rather than being directly started via the entry).

Bugfix: nanoseconds should become seconds when a second is at least reached.

When adding to nanoseconds would result in a value greater than or equal to a second, instead increment by 1 second.

Progress: controller program.

I completely overlooked that the thread time related functions are relative to the absolute system clock.
The timed locks were all acting crazy because I used relative values!

The process status is not being initialized, resulting in invalid and error prone checks.

Begin fixing problems with the asynchronous processing.
Between incorrect uses of times and some stuctural problems, the asynchronous behavior was not operating in the order of the dependencies.
The current work fixes that, but there is still more work to do.
I expect this code to not work just yet.

There also seems to be a locking issue somewhere in here that prevents the program from fully exiting.
Check the thread conditions as those have had problems in the past.
.

Update: Finish implementing the thread condition functions.

It looks like the f_thread_condition_wait() f_thread_condition_wait_timed() functions were not fully written.
Add missing handlers.
The f_thread_condition_wait_timed() was even missing the return case of F_time!

Update the comments as the "time" value is relative to the absolute system clock time.

Add F_dead, F_live, and related.

Bugfix: improve cancellation point processing and handling.

This avoids the use of f_thread_cancel_test() which is horribly limited in design.
Because f_thread_cancel_test() never returns when thread is in cancelled state, the caller cannot properly handle the situation.
This limits the code design in order to properly use f_thread_cancel_test().

There are already cancellation points in place due to the extensive use of thread.enabled.
Improve these cancellation points, adding timed checks to write locks to further check if a cancellation was received (via thread.enabled).
The timeout is arbitrarily pick as "0.1 seconds".
Hopefully, this doesn't make things too busy, but really the write locks should (ideally) never have to be waiting that long anyway.

Remove stale code in private-common.c involving a write lock and then an immediate unlock on deallocation.

Add additional thread.enabled checks.

There were some places where cancellation points were being returned but were not properly unlocking all held locks that are within the scope of the function.

All threads should now be set to PTHREAD_CANCEL_DEFERRED.

The forced thread termination via kill signals are now removed.
They shouldn't be needed now that cancellation (should be) guaranteed.
This will have to be tested over time to confirm the truth of.

Update: handle POSIX compatibility automatically in f_thread_cancel_state_set().

The POSIX standard does not explicitly define that this parameter can be NULL.
To prevent any possible problems, allow NULL but when NULL is received, use a temporary variable in its place.

Bugfix: thread exiting issues and related.

My attempt to add locks to make helgrind ended up backfired on me.
It seems that when an interrupt is received, the cancel is being sent and it happens at any point in time.
Which includes when locks are opened.
When an interrupt cancels a thread with an open lock, that lock is never closed.
Then, using the same locks to handle cleanup of threads resulted in an occasional deadlock.
Remove all locking in the main thread.
The logic should be safe as the only cases where there might be a conflict, a f_thread_join() is in protected between them.
The cancel function should avoid locks to, where possible.
I am somewhat more nervous about this case, I need to review and confirm if main->thread->processs.size does not change.

I previously updated the force cancel exit thread to use waits and locks.
It later dawned on me that I could just get rid of the force cancel exit thread entirely and implement the same functionality in the cancel thread.

Update: redesign forced exit to utilize timed waits.

Update: lock handling tweaks.

Move the rule lock to inside the if condition block because part of the rule is still being read.

Add missing unlock for other process active lock before break.
Relocate the other process active lock in some cases to be after the last access to the rule.

Utilize process r/w locks around starting and joining the main threads.

On exit, check to see if id_exit thread is actually used before attempting to join it.