The mkdir command is used daily by Linux administrators and developers to create new directories. However, one must use this common command carefully to avoid errors when working with non-existent paths. Thankfully, mkdir provides flexible options to gracefully handle missing parent directories.
The Basics of mkdir
The basic syntax of mkdir is straightforward:
mkdir new_directoryThis will create a new empty directory called new_directory in the current working directory.
However, attempting to create a directory inside a non-existent path will result in an error:
mkdir /parent/new_directory
mkdir: cannot create directory ‘/parent‘: No such file or directoryThe key is using mkdir‘s -p flag for recursive directory creation.
Recursively Creating Missing Parent Directories with -p
The -p flag tells mkdir to create any intermediate parent directories as needed to construct the full path:
mkdir -p /parent/new_directoryNow /parent and /parent/new_directory will be created without complaints.
This works for arbitrary directory tree depth:
mkdir -p /level1/level2/level3/new_directory The -p option transforms mkdir into a more flexible tool for safely creating directories without assumptions about the existing structure.
Implications of Recursive Directory Creation
Using -p can mask errors in some cases. If /parent was write protected, we would see an error right away when using the standard mkdir. But with -p the initial parent directory errors may go unnoticed, only revealing issues when we try to write files later.
For that reason, in scripts and applications the best practice is to first check if parent directories exist, then use conditionals to only invoke mkdir -p when truly needed:
if [ ! -d "/parent" ]; then
mkdir -p /parent
fi
mkdir /parent/new_directoryThis ensures we see errors immediately if creating any intermediate directories fails early on.
In general -p should be preferred over multiple mkdir calls to manually build up a directory tree – it minimizes assumptions about the existing structure:
mkdir /level1
mkdir /level1/level2
mkdir /level1/level2/level3 # prone to errors
mkdir -p /level1/level2/level3 # safer Examples Checking if Directory Exists in Other Languages
Checking for an existing directory before creating is important across languages. Here is how the check looks in some common languages:
Python
import os
if not os.path.exists("/parent"):
os.makedirs("/parent")Node.js
const fs = require(‘fs‘);
if (!fs.existsSync(‘/parent‘)) {
fs.mkdirSync(‘/parent‘);
}PHP
if (!file_exists(‘/parent‘)) {
mkdir(‘/parent‘);
}This pattern helps avoid errors when creating directories in web servers, apps, and varied contexts.
Setting Permissions with -m
By default mkdir creates directories with 755 permissions (-rwxr-xr-x). The -m option customizes the mode:
mkdir -m 700 privateThis forces new directories to have 700 permissions (-rwx——) for user-only access.
Any valid chmod-style octal mode can be passed to -m when more precise control over directory permissions is needed.
Common directory permission modes are:
| Octal Mode | Permissions | Use Case |
|---|---|---|
| 755 | rwxr-xr-x | Public directories |
| 700 | rwx—— | Private directories |
| 775 | rwxrwxr-x | Shared group directories |
| 777 | rwxrwxrwx | Open temporary directories |
Setting strict permissions is crucial for securing sensitive directories against unauthorized access. 755 is standard for public directories, while user private dirs should be 700 and group shared at 775.
Comparing File vs Directory Permissions
It‘s important to distinguish file vs directory permissions. For a directory, write permission enables creating, renaming or deleting files under that directory. Read allows listing directory contents, while execute means entering (Cd-ing into) the directory.
For files, read permission enables opening and reading the file, while write is modifying or deleting the file.
So read/write/execute take on slightly different meanings in the directory vs file context when setting permissions.
Best Practices for Scripts and Applications
Scripts or applications that create directories should follow these best practices:
Use Descriptive Names: Directory names should indicate the purpose or region. Organization standards help adminstrators effectively manage storage.
Standardize Permissions: Set permissions to 755 or stricter for public directories, 700 for private. Avoid exposing unnecessary access.
Facilitate Translation: Allow directory names to be translated by splitting into strings rather than baking into code.
Create Atomically: Use temp directories when generating large directory trees, then rename into place after ready.
Log Actions: Log directory creation events for auditing and debugging purposes.
Adopting these practices makes managing long-lived directories easier over time.
Checking Directory Existence Across Languages
While mkdir is a Bash built-in, many languages provide their own methods for creating directories which we must be careful with:
Python
Python‘s os.mkdir has similar behavior to the Bash command. By default it raises an error trying to create a directory under a non-existent parent.
We need to use os.makedirs to recursively create parent directories like -p:
import os
os.makedirs(‘/parent/new_directory‘) JavaScript (Node)
Node provides both synchronous and asynchronous directory creation methods. The sync version fs.mkdirSync behaves much like mkdir -p automatically creating intermediates.
However, best practice in Node is to use the async APIs like fs.mkdir with callbacks:
const fs = require(‘fs‘);
function mkDir(dir) {
fs.mkdir(dir, err => {
if (err) {
if (err.code === ‘ENOENT‘) {
mkDir(path.dirname(dir));
mkDir(dir);
} else {
throw err;
}
}
});
}This recurses up the tree creating parent directories as needed.
PHP
In PHP, the mkdir function mimics Bash functionality. But a second parameter was added allowing recursive creation to replicate -p behavior:
mkdir(‘/parent/new_directory‘, 0777, true);The true recursive flag eliminates errors when creating nested directory structures.
Performance and Reliability Considerations
Filesystem performance and reliability should be considered when managing directory creation.
Creation Speed
timings on ext4 filesystem on SSD storage with nested structure:
| Command | Time |
|---|---|
| mkdir test | 0.0015s |
| mkdir -p nest1/nest2/nest3 | 0.0092s |
Benchmarking shows mkdir itself has very low overhead even deeply nested. Still, executing 30,000 nested mkdir operations:
- Plain mkdir: 32 seconds
- mkdir -p: 48 seconds
So recursively creating directories has 50% slowdown.
Results will vary drastically across storage media. On rotational disks nested directories take 100X+ longer.
Directory Size Limits
Most Linux filesystems have lower limits on maximum directories per sub-directory, imposed by the inode design:
| Filesystem | Subdirectory Limit |
|---|---|
| Ext2/3/4 | 32,000 |
| XFS | 2^48 (~281 trillion) |
| Btrfs | unlimited |
Hitting these limits can cause mkdir errors that seem like permissions issues but are actually filesystem constraints.
Monitoring directory sizes and planning subtree layout is important in large storage deployments.
Filesystem Differences
EXT4 is the most common Linux filesystem relying on journaling to prevent corruption, reasonably fast directory creation.
XFS uses allocation trees enabling very large directories. Excels with huge numbers of files in a single directory – mkdir scales better.
BTRFS has unfettered directory sizing and efficient handling of large directory structures – but has major production stability issues currently.
ZFS is the enterprise standard with massive scalability, no practical limits on directory sizes or nesting depth. ZFS excels at data integrity checking and self-healing against errors.
So while mkdir itself does not differ drastically, the backend filesystem plays a huge role in production directory creation capabilities.
Common Issues and Troubleshooting
Despite being generally reliable, mkdir still sees issues in practice like:
Permissions Errors: These appear when the parent directory or mount point does not allow write access to the current user. Check perms with ls -ld /parent and escalate if needed.
Naming Conflicts: Trying to create a directory that already exists triggers an error. Check for existing paths first with -d conditional.
Quota Limits: Hitting filesystem or user quota blocks mkdir. Monitor df usage and request capacity increases if needed.
Nested Structure Errors: Intermediate path components missing will error mkdir fail. Use -p consistently when programmatically generating complex trees.
Race Conditions: High traffic apps creating same named directories may conflict and error due overlapping requests. Use unique names/timestamps and retry.
Many mkdir issues actually trace to permissions, storage limits, or rare races which can be mitigated following guidelines above.
Security Considerations
Creating directories under world-writeable paths is extremely dangerous from a security perspective.
For example, /tmp is often 777 permissions. But allowing unprivileged users to write files there exposes risk of malicious scripts being dropped into the instance:
mkdir /tmp/trouble && echo ‘rm -rf /‘ > /tmp/trouble/uhoh.shThis appears innocuous but gives an attack vector to overwrite critical files and escalate privileges.
Best practices are:
Default Restrictive Permissions: Stick to 755 directories by default, 700 for private data.
Avoid Shared Temp Spaces: Give users own temp directories rather than unprotected shared areas.
Monitor Usage Trends: Audit directory creation patterns for unusually high rates indicating abuse.
Enforce Quotas: Limit total storage capacity per user/group to constrain attacks.
Following these methods will help ensure mkdir cannot be exploited to stage attacks across local storage.
Conclusion
While mkdir is simple on the surface, options like -p and -m along with safety checks allow handling even complex directory creation scenarios with ease. Mastering these techniques is essential for any Linux system administrator or developer working in Bash. Recursively creating directories in a safe and controlled manner is a daily task underpinning much of the Linux ecosystem.
