Overall architecture

[jamescowens]

I will make a few relevant comments here as I have put a lot of thought and effort into this over the past month.

The complete picture for idle time CANNOT be obtained at the standard user (non-root) level due to permissions issues. The existing code in the boinc-client for polling XSS (the x screensaver module) for getting idle time DOES NOT work when running the boinc-client as a separate user (which is best practice), without opening up the GUI session user's X session for external access via the xhost command. This is a non-starter security-wise.

Wayland is much more complicated as there is no standardization of the idle query, it is up to the compositor to implement.

Given all of the above constraints. I am implementing the following architecture, largely as a separate service from BOINC. Note that I did a proof of concept in bash shell script, and am currently working on the C++ implementation. Event_detect is essentially finished and idle_detect C++ version is a work in progress. (The shell version works currently with the C++ event_detect version.)

Note the C++ is implemented in modern C++-17 compliant code, in an object oriented manner. It also is multithreaded with appropriate locking/critical section control.

1. There is a system level (run as root) service, event_detect, run in a tightly controlled systemd service, dc_event_detection.service, that checks three things for idle time:

• the /dev/input/event devices that are pointing devices. (This catches all phyiscal mouse movement.)
• the pts/tty devices for atime (which provides idle time for terminals/pseudo terminals, including ssh sessions.)
• an input event via a named-pipe from user level detector (more on that below)

The output of the event_detect is a file last_active_time.dat, which is in /run/event_detect. Note that on all reasonably recent Linux distributions, the /run directory is a tmpfs which is in memory only. Using an output file (and for the input events) a named pipe in the same directory is much simpler than using a shared memory (which would require complicated semaphore work to coordinate access), and presents less of a security risk. The ONLY thing written to the last_active_time.dat is an int64 in string format that represents unix epoch time in seconds UTC.

2. There is a user level service, idle_detect, run as a user level systemd service (i.e. systemctl --user ...) that does the following things:

• determines the session type, i.e. X, Wayland, or tty (non GUI)
• for X, checks XSS for idle time. This properly catches idle inhibit on an X session with someone playing a movie if the movie app properly inhibits idle
• for Wayland (this is still in progress) checks ext-idle-notify-v1 interface (for KDE Plasma-wayland and other compositors that use that interface), with a fallback to the dbus Gnome mutter interface for Gnome if necessary to get Wayland session based idle time. This will properly get idle inhibit on Wayland sessions if successful for the running compositor
• for text based session, essentially a no-op
• reports the combined last_active_time from all of the above by writing to the named pipe set up by event_detect a short message in the form of timestamp:USER_ACTIVE, which is received by an asynchronous, non-blocking read thread on the event_detect side, which does validation on the message to prevent a security risk.
• optionally can run dc control scripts itself to control dc programs directly based on idle time.

Since event_detect receives update last_active_times from its own sources AND all user level idle_detect instances running on the machine, and provides an overall last_active_time in last_active_time.dat, the BOINC client will simply poll the last_idle_time.dat file once a second to determine idleness.

This pretty much will resolve 99% of the issues we have been having with idle detection.