fix: Python Function Block compilation and cleanup

[thiagoralves]

Summary

• Fix compilation error for Python Function Blocks (getpid() implicit declaration)
• Fix runtime crash when stopping PLC with active Python Function Blocks

Problem

Issue 1: Compilation failure
When uploading a PLC project with Python Function Blocks, compilation failed with:

error: implicit declaration of function 'getpid' [-Wimplicit-function-declaration]

Issue 2: Runtime crash on stop
When stopping the PLC while a Python Function Block was actively printing to stdout, the runtime crashed and was automatically restarted by the webserver, making it impossible to stop the PLC.

Root Cause

Issue 1: iec_python.h included <sys/types.h> (for pid_t) but was missing <unistd.h> (for getpid()).

Issue 2: python_loader.c is compiled into libplc_*.so. Runner threads reading Python stdout were detached and never tracked. When dlclose() unloaded the library, the threads crashed because their code (runner_thread function) was unmapped from memory.

Changes

• Add #include <unistd.h> to iec_python.h
• Track all Python blocks with thread IDs, PIDs, and shared memory info
• Use fork()/exec() instead of popen() to get Python subprocess PIDs
• Add python_blocks_cleanup() function that:
  • Sends SIGTERM to all Python processes (then SIGKILL if needed)
  • Joins all runner threads (they exit on EOF when Python dies)
  • Unmaps and unlinks shared memory regions
  • Removes Python script files
• Call python_blocks_cleanup() before dlclose() in unload_plc_program()
• Increase MAX_PYTHON_BLOCKS from 32 to 128

Test plan

• Upload a PLC project with a Python Function Block
• Verify compilation succeeds
• Start the PLC and verify Python FB runs (check logs for [Python] messages)
• Stop the PLC and verify it stops cleanly without crashing
• Verify cleanup logs appear: [Python loader] Cleaning up... and [Python loader] Cleanup complete

🤖 Generated with Claude Code

[Copilot]

Pull request overview

This PR fixes compilation and runtime issues with Python Function Blocks by adding the missing <unistd.h> include and implementing proper cleanup to prevent crashes during PLC shutdown.

Changes:

• Added <unistd.h> to resolve getpid() implicit declaration
• Implemented tracking of Python blocks with thread IDs, PIDs, and shared memory info
• Added python_blocks_cleanup() function to properly terminate Python processes and join threads before library unload

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 7 comments.

File	Description
core/src/plc_app/python_loader.c	Implements Python block tracking, replaces popen() with fork()/exec(), adds comprehensive cleanup function
core/src/plc_app/plc_state_manager.c	Calls python_blocks_cleanup() before dlclose() to prevent crashes
core/src/plc_app/include/iec_python.h	Adds <unistd.h> include and declares python_blocks_cleanup() function

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

The python_cleanup_in_progress flag is checked in both the while condition and immediately inside the loop. This is redundant - the inner check on lines 123-126 is unnecessary since the while condition will already exit the loop if python_cleanup_in_progress becomes true.

Suggested change

	// Check if cleanup started while we were blocked
	if (python_cleanup_in_progress)
	{
	break;
	}

[Copilot]

The file descriptor shm_in_fd is closed here after successful mapping, but in the error paths (lines 224, 232) it's also closed before jumping to cleanup. This could lead to confusion. Consider setting shm_in_fd = -1 after closing it here so error paths can check if it's already closed.

Suggested change

	close(shm_in_fd);
	close(shm_in_fd);
	shm_in_fd = -1;

[Copilot]

The exit code 127 is typically reserved for 'command not found' in shells. While this makes sense here (exec failed), it would be clearer to log an error message before exiting. Since all file descriptors including stderr have been redirected to the pipe, the parent will never see why exec failed.

Suggested change

	// If exec fails
	// If exec fails, report the error through stderr (redirected to the pipe)
	{
	int saved_errno = errno;
	dprintf(STDERR_FILENO,
	"[Python loader] execlp(\"python3\") failed: %s\n",
	strerror(saved_errno));
	}

[Copilot]

The hardcoded 100ms grace period for Python processes to exit is arbitrary and may be insufficient for processes with cleanup handlers or large state. Consider making this configurable or implementing a polling loop with a timeout to avoid unnecessary delay when processes exit quickly.

[Copilot]

This call to pthread_join happens while holding python_blocks_mutex. If the runner thread is blocked in fgets() and hasn't noticed python_cleanup_in_progress yet, this could deadlock if the runner thread needs to acquire the same mutex. The mutex should be released before joining threads.

Suggested change

	pthread_join(block->thread, NULL);
	pthread_t thread = block->thread;
	pthread_mutex_unlock(&python_blocks_mutex);
	pthread_join(thread, NULL);
	pthread_mutex_lock(&python_blocks_mutex);

[Copilot]

When fopen() fails on line 191, the error jumps to error_deactivate which decrements python_block_count on line 329. However, the count was already incremented on line 186, so this is correct. But the error message doesn't inform the user that the slot has been freed, which could be helpful for debugging resource exhaustion issues.

[Copilot]

The double cast *(void **)(&python_cleanup) is used to suppress compiler warnings about converting between function and object pointers, but this is a POSIX extension not guaranteed by C standard. A more portable pattern would be to use a union to perform the type-punning, though this may be acceptable for this codebase if targeting POSIX systems exclusively.

Suggested change

	*(void **)(&python_cleanup) =
	plugin_manager_get_symbol(pm, "python_blocks_cleanup");
	union
	{
	void *obj;
	void (*func)(void);
	} sym;
	sym.obj = plugin_manager_get_symbol(pm, "python_blocks_cleanup");
	python_cleanup = sym.func;