Ollama storage: Stop root disk fill on Linux

Disk pressure arrives before model fatigue. Pull a few variants on a Linux host, and your root filesystem fills up while you are still waiting for the first token. This guide asserts that relocating Ollama model storage via systemd overrides is the only reliable method to prevent root filesystem saturation. You will learn to measure current usage with `du`, migrate data to secondary drives like `/srv/ollama-models`, and enforce persistence without breaking the Linux service.

Running Ollama on Linux defaults to storing models under `/usr/share/ollama/.ollama/models`, a path that fills rapidly. LocalAIMaster reports that while 8 GB of RAM is the minimum requirement, targeting 16 GB ensures comfortable daily use, yet disk space often vanishes quicker than memory. The article details how to identify active processes using `ollama ps` and safely stop them before moving gigabytes of data to a dedicated mount point.

The procedure avoids fragile symlinks in favor of setting the `OLLAMA_MODELS` environment variable through a systemd override. This approach ensures the ollama service account retains proper read/write access to the new directory. By following these steps, operators can maintain a clean root partition while keeping large language models accessible and performant on secondary storage.

The Impact of Ollama Model Storage on Linux Root Filesystems

Ollama Model Storage Architecture and Disk Consumption

Default installations stash model binaries and manifests inside `/usr/share/ollama/.ollama/models`. This design isolates runtime data but invites root partition saturation. The local LLM runtime drops quantized weights straight onto the host filesystem. A single Llama 3 instance consumes approximately an undisclosed amount of space. Adding smaller variants like Mistral, which requires an undisclosed amount of memory, accelerates storage depletion on systems with limited capacity.

Defining the `OLLAMA_MODELS` environment variable before service initialization redirects this traffic effectively. The configuration points the daemon toward a dedicated data mount, separating large binary blobs from OS critical files. Moving storage demands adjusting systemd unit files via an override to set the environment variable persistently. Proper implementation requires setting directory ownership to the `ollama` user and ensuring the service account retains write access to the new path. Unused model variants accumulate quickly, creating artificial pressure that pruning policies must address regularly.

Measuring Ollama Directory Size with Linux Du Commands

Quantifying recursive disk usage helps administrators spot root filesystem saturation before service failure strikes.

Running `sudo du -sh /usr/share/ollama/.ollama/models` provides an immediate total of the model binary footprint. This single command confirms whether the storage directory has crossed critical thresholds that threaten OS stability. For granular analysis, executing `sudo du -h --max-depth=2 /usr/share/ollama/.ollama/models | sort -h` reveals which specific model variants consume the most space. This detailed view is necessary when managing libraries approaching a substantial size, a size increasingly common as organizations deploy larger parameter sets.

Distinguishing between active model weights and transient cache files during measurement presents an analytical challenge. Standard tooling often conflates these layers, leading administrators to prune active dependencies or retain obsolete data. Accurate measurement requires checking `ollama ps` to see if models are currently loaded into memory. If a model is actively loaded, it should be stopped before moving files to ensure data consistency.

Root Filesystem Pressure from Active Model Loading

Root filesystem saturation happens when the default storage location fills the root partition with model data, not RAM consumption. The minimum system requirement for running Ollama is 8 GB of RAM, though 16 GB is the target for comfortable daily use to prevent memory starvation during inference.

If a model is actively loaded, it must be stopped before moving files to avoid data corruption or service failure. This constraint exists because the service must be stopped cleanly via `systemctl` before copying or moving model data. Shifting large datasets requires careful handling if the target volume uses a non-native filesystem, as Linux permission models may not translate correctly. Operators should prioritize stopping the service entirely via systemd before any disk operations to guarantee consistency. This approach eliminates race conditions between the running process and file system modifications.

Evaluating Storage Relocation Strategies for AI Models

Local NVMe versus Network Mount Latency for Model Loading

Local NVMe storage delivers the consistent low latency and high throughput that rapid model loading sequences demand. Network mounts bring variable latency, degrading performance during weight initialization. Operators prioritizing throughput select fast local media to minimize I/O wait states during pull operations. Slow or unreliable network mounts pose risks unless latency and failure behavior undergo rigorous testing. Placing binaries on untested network paths invites performance degradation.

Shared access via network protocols trades stability for convenience, introducing transient failures that interrupt service availability. Local storage remains simpler and quicker, sidestepping network dependency complexities. Shared storage simplifies architecture yet complicates failure domains. If the network stack stalls, the AI service becomes unresponsive regardless of CPU availability. Administrators weigh centralization convenience against strict timing requirements of local inference engines. Testing failure modes is mandatory before production deployment on non-local filesystems.

Creating and Owning the /srv/ollama-models Directory

Provisioning the `/srv/ollama-models` path requires explicit `ollama:ollama` ownership to prevent permission errors during model ingestion. Storage options vary based on infrastructure needs:

• A larger secondary SSD such as /srv/ollama-models
• A dedicated data mount such as /mnt/ai/ollama-models
• Fast local NVMe for optimized pull and load speed

Executing `sudo install -d -o ollama -g ollama -m 0755 /srv/ollama-models` creates the directory and assigns correct service account privileges efficiently. This single command combines creation and permission setting, ensuring the directory is ready for the daemon immediately. An alternative multi-step method using `mkdir` followed by `chown` and `chmod` achieves the same result but requires multiple commands:

• `sudo mkdir -p /srv/ollama-models`
• `sudo chown -R ollama:ollama /srv/ollama-models`
• `sudo chmod 755 /srv/ollama-models`

A critical oversight in many deployments involves systemd environment propagation; simply creating the directory is insufficient if the service environment does not explicitly define the new `OLLAMA_MODELS` path. Without a systemd override, the daemon ignores the new location and reverts to the default user directory, rendering manual directory creation moot. This mismatch between filesystem preparation and service configuration causes frequent "missing model" errors after migration. Administrators verify directory permissions align with systemd unit file expectations before pulling new weights. Validating ownership immediately after creation ensures the runtime can write binary data without escalation.

Storage Consumption Risks from Multi-GB Model Files

Individual model binaries like the large Command R file impose immediate pressure on limited root partitions. This specific high-capacity requirement forces migration from default system drives to dedicated secondary SSDs. Expanding beyond standard text generators to include specialized embedding models further accelerates storage exhaustion. Operators avoid placing these large datasets on unreliable network mounts without first validating failure behaviors.

The Qwen2.5:7b variant alone consumes several gigabytes, demonstrating how quickly aggregate usage scales across a diverse library. Relocating the model directory to a path like `/mnt/ai/ollama-models` prevents the root filesystem from filling up, a common issue when running Ollama on Linux for extended periods. This architectural separation ensures routine model updates or addition of new parameters does not compromise system stability. Neglecting this separation leaves the root filesystem vulnerable to rapid saturation as the local library expands.

Migrating Ollama Models to Secondary Storage with Systemd Persistence

Systemd Override Mechanics for OLLAMA_MODELS Persistence

A systemd drop-in override permanently redirects the OLLAMA_MODELS environment variable so the daemon loads weights from secondary storage after reboot. Simple shell exports fail because the service manager isolates the runtime environment from user sessions. Making the change persistent requires a systemd override instead of relying on shell profiles. Administrators execute `sudo systemctl edit ollama` to inject configuration directly into the service definition.

1. Run `sudo systemctl edit ollama` to open the override editor.
2. Insert `[Service]` followed by `Environment="OLLAMA_MODELS=/srv/ollama-models"`.
3. Save the file and reload the daemon with `sudo systemctl daemon-reload`.

This mechanism supersedes default path logic, forcing Ollama to ignore the root filesystem entirely during initialization. Neglecting to reload the systemd manager causes the service to ignore the new override file, leaving the root partition vulnerable to capacity exhaustion despite correct file placement. Operators verify the active configuration using `systemctl show ollama --property=Environment` before attempting to purge original data files. Validating service account permissions on the target directory immediately after reloading prevents startup failures caused by inaccessible paths.

Executing Safe Model Migration with Rsync and Rollback Verification

Terminating the active daemon via `sudo systemctl stop ollama` prevents file locking conflicts during data transfer. Operators must verify the service state returns `inactive` before initiating copy operations to avoid corruption.

1. Execute `sudo rsync -aHAX --info=progress2` to synchronize the source directory to the new volume.
2. Compare recursive sizes of both paths to confirm bit-for-bit equivalence before altering configurations.
3. Retain the original files as a temporary rollback point until full operational stability is verified.

The `rsync` utility provides a restartable copy mechanism that preserves extended attributes necessary for model integrity. This approach mitigates risks of partial transfers occurring with standard move commands during network interruptions or power loss. Immediate space recovery conflicts with data safety; deleting the source prematurely removes the only recovery path if the systemd override fails. Listing models at the new path before removing the legacy directory is recommended. The constraint is temporary doubling of storage requirements, necessitating sufficient free space on the target volume during transition. Failure to verify permissions on the new location often results in Permission denied errors when the service attempts to write new layers.

Troubleshooting Checklist for Missing Models and Permission Denied Errors

Verify the service environment variable points to the correct target path before investigating file system permissions. Run `systemctl show ollama --property=Environment` to confirm the OLLAMA_MODELS setting matches the new directory exactly, as incorrect paths prevent the daemon from locating model files.

1. Inspect the target directory with `sudo ls -lah /srv/ollama-models` to ensure model files exist and are not empty.
2. Trace the full path resolution using `sudo namei -l /srv/ollama-models` to identify broken symlinks or mount point errors.
3. Apply correct ownership via `sudo chown -R ollama:ollama /srv/ollama-models` if the output shows root ownership instead of the service account.

A Permission denied error typically indicates that the service account lacks write access despite the directory appearing present. Incorrect systemd configuration often leads to silent failures where the service starts but serves no models because it cannot read the storage path. Always reload the daemon manager with `sudo systemctl daemon-reload` after modifying override files to ensure changes take effect. If models remain missing, verify that the copy operation completed successfully and that the environment variable is correctly applied before restarting the service.

Operational Hygiene for Managing and Pruning Unused Models

Defining Safe Pruning Triggers for Ollama Model Directories

Check `ollama ps` before pruning anything to stop runtime crashes during file deletion. Distinguishing dormant files eating disk space from active weights locked in memory matters because removing the latter while loaded breaks service immediately. A model like Qwen2.5:14b occupies significant space, yet deleting it without checking process lists interrupts ongoing API requests. Completed batch jobs, scheduled maintenance windows, or explicit administrator commands serve as safe triggers instead of relying on automated disk-pressure thresholds alone.

Run `ollama ls` to inventory available tags before sending results to removal tools.

• Confirm zero active sessions using `ollama ps`.
• Identify specific model tags targeting removal.
• Execute `ollama rm :` for precise deletion.
• Validate the service state post-pruning to guarantee the daemon reflects the reduced footprint.

Reclaiming storage immediately creates tension with maintaining availability for concurrent users requesting a cold model. The `ollama rm` command updates the local registry safely, keeping metadata consistent across the system. This procedure stops orphaned references that happen when manually unlinking blobs from the storage backend. AI Agents News recommends this validation step to keep operations smooth.

Executing Safe Ollama Model Removal Commands

Deleting model files directly via the shell bypasses the internal Ollama registry and leaves orphaned metadata that corrupts the local index. Administrators must use the `ollama rm` command exclusively so the model registry updates correctly alongside filesystem changes. Verify no active sessions hold locks on target weights using `ollama ps` before executing removal because terminating a loaded model causes immediate inference failures.

The removal workflow needs strict sequencing to maintain system integrity:

1. Identify the specific tag to remove with `ollama ls` to avoid deleting the wrong variant.
2. Execute `ollama rm :` to safely unlink the file and update the database.
3. Confirm disk space reclamation by checking the storage directory size immediately after the command finishes.

Bulk operations carry higher risk since piping `xargs` to remove all models at once can accidentally purge dependencies needed by running agents. The CLI tool handles reference counting for shared layers unlike manual file deletion, which prevents premature data loss when multiple models share base weights. Disk space may not appear fully reclaimed until all tags referencing a specific layer are removed due to this safety mechanism.

Treat model pruning as a scheduled maintenance task rather than an emergency response to disk pressure. Regular audits stop the accumulation of unused variants that consume significant storage over time. Consult the latest guides from AI Agents News for detailed workflows on managing these inventories across different environments. This disciplined approach keeps the storage backend lean without compromising active service stability.

Risks of Deleting Active Ollama Models During Runtime

Removing model files while the inference engine holds them in memory triggers immediate service instability and potential data corruption. The operating system might allow a file handle to persist temporarily when a user removes a blob from the disk that the running process still references, but subsequent read operations fail silently or crash the daemon. New requests cannot be satisfied when this race condition between filesystem removal and memory unloading leaves the application in an undefined state.

Linux users keeping models on NTFS partitions face heightened risks since these filesystems handle permission changes and file locking differently than native ext4 structures, complicating the cleanup of active handles. The standard operational procedure using `systemctl` ensures the service stops completely before any file manipulation occurs, preventing the scenario where disk deletion outpaces process termination. Attempting to prune without first verifying `ollama ps` output often results in a corrupted model registry that requires a full restart to recover.

Treat the active process list as the single source of truth before executing any storage maintenance. Builders should consult resources from AI Agents News for further guidance on maintaining operational hygiene.

References

• Ollama System Requirements 2026: 8GB RAM Minimum, No GPU
• Releases · ollama/ollama: 2026-06-26T19:00:30Z · ollama-darwin.tgz · sha256:4620272018aa974fb146741e51fa69dbecd141922143
• r/ollama: I have been using Ollama on my HP