Browsing data is a trivial but critical activity when using any system. A major part of that activity is switching directories, commonly with cd.
In this tutorial, we tackle the scenario in which we’re unable to enter a given directory. First, we delve into invalid paths in Linux. Next, we check other reasons for the inability to access a directory. After that, the focus is on the permissions we need to change into a directory and how to assess and correct them. Finally, we provide a comprehensive example.
We tested the code in this tutorial on Debian 11 (Bullseye) with GNU Bash 5.1.4. It should work in most POSIX-compliant environments.
2. Invalid Path
Since it’s perhaps one of the most common problems when using cd, let’s get invalid paths out of the way first.
2.1. Typos in the Path
While a human may detect simple typos like /dirs/ubdir instead of /dir/subdir or incorrect spelling, machines are rarely equipped to do so by default. The problem is tougher when we get similar-looking characters wrong:
$ cd /dirl $ pwd /dirl $ cd /dir1 -bash: cd: /dir1: No such file or directory
Depending on the font, we can have trouble distinguishing a one (1) from a lowercase “L” (l). Of course, this is easy to correct by listing / in this example, but the problem may be at any point in a long path.
2.2. Incorrect Syntax
Linux has a strict standard for paths, which includes predefined tokens like the / forward slash separator.
Using a \ backslash instead of a forward slash can lead to incorrect results. For example, /dir/file is a file within /dir, but /dir\subdir is the dirsubdir file in root:
$ cd /dir/subdir $ cd /dir\subdir -bash: cd: /dirsubdir: No such file or directory
On the other hand, shells often treat multiple forward slashes in paths as one, so that’s acceptable.
Many UNIX tools also have switches that force input interpretation, output generation, or both to use NULL (\0) as the separator. The reason for this is that only NULL and forward slash are forbidden as parts of names in Linux, but the latter is the path separator.
2.3. Whitespace Not Escaped
Whitespaces are allowed in Linux paths. Even newlines can be a part of object names. This can be very confusing, especially when we list directory contents.
$ cd /dir\ 1 $ pwd /dir 1 $ cd /dir 1 -bash: cd: too many arguments
Here, we enter /dir 1 by escaping the single space and confirm we’re inside the correct directory. However, if we try to avoid escaping the space, cd complains about the number of arguments since 1 is superfluous.
2.4. Incorrect Capitalization
Finally, unlike Microsoft Windows, the Linux operating system is case-sensitive. This means that /dir/subDir is not the same as /dir/subdir.
To make things more problematic, we can have both at the same time:
$ ls /dir subdir subDir
The situation is even worse when both are directories. Naturally, this is also an organizational problem, but still a valid scenario.
After looking at the many ways seemingly valid paths can actually be invalid, let’s explore what else can prevent us from entering a valid path.
3. Reasons for Directory Entry Problems
Of course, even with a valid path, different issues can arise when attempting to enter a directory. Let’s look at some of them.
3.1. Not a Directory
Supplying a path that’s not an actual directory is the first trivial reason for the inability to enter. For example, we might be attempting to access a nonexistent directory that was moved, deleted, or renamed if it even existed in the first place.
In other cases, the object we expect to be a directory can turn out to be a file.
If we have a valid path that’s a directory, but we’re still unable to get in with cd, it’s most commonly due to the following error:
$ cd /dir/subdir bash: cd: /dir/subdir: Permission denied
Here, the error text tells us that we don’t have the necessary permissions. Let’s dive further into this scenario and explore how to remedy it.
4. Checking and Changing Directory Permissions
Linux file and directory permissions dictate which actors can perform what actions over which objects.
An easy way to check the permissions for an object is the ls command:
$ ls -l /dir [...] drwxr-xr-x 2 baeldung baeldung 4096 Oct 28 16:50 subdir
In its long listing (-l) format, ls provides the following information about each item from the second row onwards, column by column:
- Number of links to the file
- Owning user
- Owning group
- Last modification date and time
From these, the permissions and owning user and group are of interest to us. By default, each user is the sole member of a group with the user’s name.
Indeed, the permissions are represented by a string of letters. The first letter identifies the object type (d means directory). Following are three 3-letter clusters of rwx, responsible for the [r]ead, [w]rite, and e[x]excute permissions of the owning user, owning group, and everyone else, respectively. If a position has a – dash instead of a letter, it means that the permission is unavailable for the given actor.
Importantly, to change into a directory, a user must have the x execute permission over it. This can happen if our user is:
- the owning user, while there is an x in the first 3-letter cluster
- part of the owning group, while there is an x in the second 3-letter cluster
- not the owning user or part of the owning group, while there is an x in the third 3-letter cluster
Finally, we change the owning user and group via chown, while chmod is the command for changing all permissions.
Armed with the knowledge above, we can combine all commands in an example.
5. Example Scenario
Let’s create a path structure as user1:
$ whoami user1 $ mkdir --parents /dir/subdir $ ls -l /dir/ [...] drwxr-xr-x 2 user1 user1 4096 Oct 28 16:56 subdir
5.1. Default Behavior
Let’s describe the default permissions of the subdirectory in this case:
- user user1 has full permissions
- group user1 does not have the write permission
- everyone else also does not have the write permissions
Of course, that means we can freely cd into the directory as any user:
$ whoami user2 $ cd /dir/subdir $
How do we change that?
5.2. Deny Execute
Naturally, we can use chmod to strip the x permissions for all actors:
$ chmod -x /dir/subdir $ ls -l /dir/ [...] drw-r--r-- 2 user1 user1 4096 Oct 28 16:56 subdir $ cd /dir/subdir bash: cd: /dir/subdir: Permission denied
Now, we’re locked out. Still, we can change permissions as the owner or a superuser.
As usual, even if we don’t have a particular permission as a given user, superusers can access and change most objects:
$ whoami root $ cd /dir/subdir $
$ sudo cd /dir/subdir $
Even the owner does not always have all permissions.
5.4. Allow Execute for Others
Let’s add the execute permission only for non-owner users that are not part of the owner group:
$ chmod o+x /dir/subdir $ ls -l /dir/ [...] drw-r--r-x 2 user1 user1 4096 Oct 28 16:56 subdir
At this point, we can cd with user2 as long as it’s not part of the user1 group as returned by getent:
$ getent group user1 user1:user1:1001: $ whoami user2 $ cd /dir/subdir $
However, we still can’t change to /dir/subdir with user1, as it’s the owner and doesn’t have the necessary permissions:
$ whoami user1 $ cd /dir/subdir bash: cd: /dir/subdir: Permission denied
To work around this, we can also change the owner.
5.5. Changing the Owner
We can use chown to modify the current owning user of /dir/subdir:
$ chown user2 /dir/subdir $ ls -l /dir/ [...] drw-r--r-x 2 user1 user1 4096 Oct 28 16:56 subdir
After this, we can’t access the subdirectory with user2 anymore since that user, as the owner, does not have the x permission:
$ whoami user2 $ cd /dir/subdir bash: cd: /dir/subdir: Permission denied
Note that the owner group has not changed, so now the permissions applicable to user1 come from the second 3-letter cluster.
Finally, we can restore the defaults:
$ chown user1 /dir/subdir $ chmod 0755 /dir/subdir $ ls -l /dir/ [...] drwxr-xr-x 2 user1 user1 4096 Oct 28 16:56 subdir
At this point, we’re back to the original permissions.
In this article, we explored why we might not be able to change into a given directory. Specifically, we paid attention to permissions problems and how to fix them.
In conclusion, while there are many reasons a directory can be inaccessible, we can typically remedy each one as long as we can identify it correctly.