Linux mkdir with permissions

How to create a directory and give permission in single command

How to create a directory and give permission in single command in Linux? I have to create lots of folder with full permission 777 .

Commands

mkdir path/foldername chmod 777 path/foldername 

mkdir temp; chmod 777 temp is one line. You could make ‘temp’ a variable and save it as a bash command. Is this what you’re looking to do?

hi @white-rose, please see the latest answer, it should be the accepted answer. bonus, it combines mkdir, chmod AND chown in a single bullet!

8 Answers 8

mkdir -p -m is broken, since the mode is only applied to the last directory in the path you type. For example, mkdir -p -m 707 one/two/three. Even if all three directories are newly created, only the last one will have the requested permissions, and the others, default. install -d -m is broken the same way.

@Crossfit_and_Beer the above statement IS valid (at least for me on Debian 8 and 9). The emphasis is on the -p/—parents option. Do the test: mkdir -p -m777 /tmp/foo/bar/baz and you’ll see the created directories will have their permissions set in accordance to the current umask, except the last one which will get the desired mode.

@Crossfit_and_Beer the difference is — as I emphasized it — the —parent switch. You should create a chain of dirs like follows: $ umask 022; mkdir -p -m777 /tmp/foo/bar/baz; ls -lR /tmp/ drwxr-xr-x 3 tylla tylla 4096 dec 26 23:39 foo drwxr-xr-x 3 tylla tylla 4096 dec 26 23:39 bar drwxrwxrwx 2 tylla tylla 4096 dec 26 23:39 baz where /tmp was empty previously. If you’re creating two separate dirs as you did, you won’t notice the difference.

When the directory already exist:

mkdir -m 777 /path/to/your/dir 

When the directory does not exist and you want to create the parent directories:

mkdir -m 777 -p /parent/dirs/to/create/your/dir 

This will only give permission 777 to the final subdirectory. How can I do this and give permission 777 to all the parent directories too?

I don’t have an answer for this but I believe the answer for this is here: stackoverflow.com/questions/3740152/…

Note that this command is to solve this problem «How to create a directory and give permission in single command». I believe the solution to your question will be something like: find /your/dirs -type d -exec chmod 755 <> \;

should give you what you want. Be aware that every user has the right to write add and delete files in that directory.

It’s broken. install -d -m 070 one/two/three. Even if all three directories in the path are newly created, only the last one will have the requested permissions set. mkdir -p -m is broken in the same manner.

@DisplayName: which nevertheless sets the correct permissions for three , with the default permissions being sufficient for the path to it.

@MarkusWMahlberg what’s the point of having the correct permissions to just one path component, if the end result the same as if it didn’t set them: I gonna have to run chmod -R for the whole hierarchy?

IMO, it’s better to use the install command in such situations. I was trying to make systemd-journald persistent across reboots.

install -d -g systemd-journal -m 2755 -v /var/log/journal 

You could write a simple shell script, for example:

#!/bin/bash mkdir "$1" chmod 777 "$1" 

Once saved, and the executable flag enabled, you could run it instead of mkdir and chmod:

./scriptname path/foldername 

However, alex’s answer is much better because it spawns one process instead of three. I didn’t know about the -m option.

you can use following command to create directory and give permissions at the same time

mkdir -m777 path/foldername 

Just to expand on and improve some of the above answers:

First, I’ll check the mkdir man page for GNU Coreutils 8.26 — it gives us this information about the option ‘-m’ and ‘-p’ (can also be given as —mode=MODE and —parents, respectively):

. set[s] file mode (as in chmod), not a=rwx — umask

. no error if existing, make parent directories as needed

The statements are vague and unclear in my opinion. But basically, it says that you can make the directory with permissions specified by «chmod numeric notation» (octals) or you can go «the other way» and use a/your umask.

Side note: I say «the other way» since the umask value is actually exactly what it sounds like — a mask, hiding/removing permissions rather than «granting» them as with chmod’s numeric octal notation.

You can execute the shell-builtin command umask to see what your 3-digit umask is; for me, it’s 022 . This means that when I execute mkdir yodirectory in a given folder (say, mahome) and stat it, I’ll get some output resembling this:

 755 richard:richard /mahome/yodirectory # permissions user:group what I just made (yodirectory), # (owner,group,others--in that order) where I made it (i.e. in mahome) # 

Now, to add just a tiny bit more about those octal permissions. When you make a directory, «your system» take your default directory perms’ [which applies for new directories (its value should 777)] and slaps on yo(u)mask, effectively hiding some of those perms’. My umask is 022—now if we «subtract» 022 from 777 (technically subtracting is an oversimplification and not always correct — we are actually turning off perms or masking them). we get 755 as stated (or «statted») earlier.

We can omit the ‘0’ in front of the 3-digit octal (so they don’t have to be 4 digits) since in our case we didn’t want (or rather didn’t mention) any sticky bits, setuids or setgids (you might want to look into those, btw, they might be useful since you are going 777). So in other words, 0777 implies (or is equivalent to) 777 (but 777 isn’t necessarily equivalent to 0777—since 777 only specifies the permissions, not the setuids, setgids, etc.)

Now, to apply this to your question in a broader sense—you have (already) got a few options. All the answers above work (at least according to my coreutils). But you may (or are pretty likely to) run into problems with the above solutions when you want to create subdirectories (nested directories) with 777 permissions all at once. Specifically, if I do the following in mahome with a umask of 022:

mkdir -m 777 -p yodirectory/yostuff/mastuffinyostuff # OR (you can swap 777 for 0777 if you so desire, outcome will be the same) install -d -m 777 -p yodirectory/yostuff/mastuffinyostuff 

I will get perms 755 for both yodirectory and yostuff , with only 777 perms for mastuffinyostuff . So it appears that the umask is all that’s slapped on yodirectory and yostuff . to get around this we can use a subshell:

( umask 000 && mkdir -p yodirectory/yostuff/mastuffinyostuff )

and that’s it. 777 perms for yostuff, mastuffinyostuff, and yodirectory.

Источник

How to Use mkdir Command to Make or Create a Linux Directory

With mkdir , you can also set permissions, create multiple directories (folders) at once, and much more.

This tutorial will show you how to use the mkdir command in Linux.

• Linux or UNIX-like system.
• Access to a terminal/command line.
• A user with permissions to create and change directory settings.

mkdir Command Syntax in Linux

The basic command for creating directories in Linux consists of the mkdir command and the name of the directory. As you can add options to this command, the syntax looks like this:

To understand better how to use mkdir , refer to the examples we provide in the rest of the guide.

Tip: Use cd to navigate to the directory where you want to create a sub-directory. You can also use the direct path. Use ls to list the directories in the current location.

How to Make a New Directory In Linux

To create a directory using the terminal, pass the desired name to the mkdir command.

In this example, we created a directory Linux on the desktop. Remember commands in Linux and options are case sensitive.

If the operation is successful, the terminal returns an empty line.

To verify, use ls .

Note: To create a hidden directory, follow our guide on how to show and create hidden files in Linux.

How to Create Multiple Directories with mkdir

You can create directories one by one with mkdir, but this can be time-consuming. To avoid that, you can run a single mkdir command to create multiple directories at once.

To do so, use the curly brackets <> with mkdir and state the directory names, separated by a comma.

Do not add any spaces in the curly brackets for the directory names. If you do, the names in question will include the extra characters:

How to Make Parent Directories

Building a structure with multiple subdirectories using mkdir requires adding the -p option. This makes sure that mkdir adds any missing parent directories in the process.

For example, if you want to create “dirtest2” in “dirtest1” inside the Linux directory (i.e., Linux/dirtest1/dirtest2), run the command:

mkdir –p Linux/dirtest1/dirtest2

Use ls -R to show the recursive directory tree.

Without the -p option, the terminal returns an error if one of the directories in the string does not exist.

How to Set Permissions When Making a Directory

The mkdir command by default gives rwx permissions for the current user only.
To add read, write, and execute permission for all users, add the -m option with the user 777 when creating a directory.

To create a directory DirM with rwx permissions:

To list all directories and show the permissions sets: -l

The directory with rwx permissions for all users is highlighted. As you can see on the image above, two other directories by default have rwx permission for the owner, xr for the group and x for other users.

How to Verify Directories

When executing mkdir commands, there is no feedback for successful operations. To see the details of the mkdir process, append the -v option to the terminal command.

Let’s create a Details directory inside Dir1 and print the operation status:

By getting the feedback from the process, you do not have to run the ls command to verify the directory was created.

mkdir Command Options and Syntax Summary

Option / Syntax	Description
mkdir directory_name	Creates a directory in the current location
mkdir	Creates multiple directories in the current location. Do not use spaces inside <>
mkdir –p directory/path/newdir	Creates a directory structure with the missing parent directories (if any)
mkdir –m777 directory_name	Creates a directory and sets full read, write, execute permissions for all users
mkdir –v directory_name(s)	Creates a directory in the current location

Note: Learn to fully manage directories by learning to move a directory in a system running a Linux distribution.

This guide covered all commands you need to create directories in Linux.

Now you understand how to use the Linux mkdir command. It’s straightforward and simple to use.

If you have the necessary permissions, there should be no error messages when you follow the instructions in this article.

Источник