In this lesson, you will learn how environment variables are passed from a parent process to its children when a new process is spawned.
The Lifecycle of an Environment
In Linux, every process is a descendant of another process (starting from init or systemd). When a process creates a child, it essentially "clones" a portion of its state. One of the most important pieces of state passed down is the environment block.
When a parent process decides to spawn a child, the kernel copies the current environment variables into the memory space of the new process. This is a one-way street: the child receives a snapshot of the parent's environment at the moment of execution.
Modifying the Inheritance
Because the child receives a copy, it can modify its own variables without affecting the parent. Conversely, if the parent changes an environment variable after spawning the child, the child will not see that change.
Consider this bash-style illustration of the process hierarchy:
# Parent process sets a variable
export APP_PORT=8080
# Parent spawns a child process (the 'sh' shell)
# The child inherits APP_PORT
sh -c 'echo "Child sees APP_PORT as: $APP_PORT"'
# If the child changes the variable, the parent remains unaffected
sh -c 'APP_PORT=9090; echo "Child changed it to: $APP_PORT"'
echo "Parent still sees APP_PORT as: $APP_PORT"
Why this matters for the Filesystem
Environment variables often act as configuration hooks for programs. For example, many tools look for PATH or LD_LIBRARY_PATH to know where to find executable binaries or libraries within the filesystem hierarchy. By controlling the environment before spawning a sub-process, you essentially dictate the "context" in which that child will interact with the filesystem. If you change a child's PATH, it will resolve file paths differently than its parent, even though they are running on the same underlying system.
This mechanism ensures that configurations are localized to specific process trees, preventing a global change in one application from accidentally breaking others.
Key Takeaway: When a process spawns a child, it passes a snapshot of its environment variables to the child, creating an isolated copy that allows child processes to operate with specialized configurations while keeping the parent's environment secure and unchanged.