Partition full in linux

How to create partitions larger than 2TB in Linux

It’s well known that is impossible to create partitions larger than 2TB in Linux using the default utility fdisk that comes with most of Linux distros, at least for now. In this short tutorial we’ll learn how to create larger than 2TB partitions using parted utility instead of fdisk on CentOS Linux. Assuming that we have to add three new disks to a new fictive server called mydbhost that will be used for a MySQL service for example, being master, slave, standalone it doesn’t matter, all that we care is the partitioning bit.

Installing parted utility

We can start our quick tutorial by checking if we have parted installed on our server, just type the magic command parted —help and if an error comes up saying that parted is not installed then we have to install it like shown in the example below:

Checking available disks on our server

Great, now that we have installed the missing package let’s go straight to disks and let’s have a quick look over how many attached disks are on this particular server:

 $ ls -la /dev/sd* brw-rw---- 1 root disk 8, 0 May 22 07:19 /dev/sda brw-rw---- 1 root disk 8, 1 May 22 07:19 /dev/sda1 brw-rw---- 1 root disk 8, 2 May 22 07:19 /dev/sda2 brw-rw---- 1 root disk 8, 16 May 22 07:19 /dev/sdb brw-rw---- 1 root disk 8, 32 May 22 07:19 /dev/sdc brw-rw---- 1 root disk 8, 48 May 22 07:19 /dev/sdd 

We can clearly see from this output that we have four disks on our server, one being sda having two partitions called sda1 and sda2 and another three disks that aren’t partitioned, those disks being called sdb , sdc and obviously sdd .

Running parted utility

We need now to run parted for each of our attached and unpartitioned disks like this:

We will get a console output similar to the one below where we can see that parted will run for /dev/sdb exactly as instructed in the command above:

 GNU Parted 3.1 Using /dev/sdb Welcome to GNU Parted! Type 'help' to view a list of commands. (parted) 

Creating partition table

Now that we’ve managed to instruct parted that we’ll make changes on sdb disk we can now move to the next step and specify what kind of partition table we want to create for the selected disk. We will instruct parted to create a GPT (GUID Partition Table) partition table for our disks as this can support partitions larger than 2TB:

On the next step we have to check the size of our sdb disk in order to correctly size and create our new partition:

The output of print free command will look similar to this:

 Model: VMware Virtual disk (scsi) Disk /dev/sdb: 537GB Sector size (logical/physical): 512B/512B Partition Table: gpt Disk Flags: Number Start End Size File system Name Flags 17.4kB 537GB 537GB Free Space (parted) 

Creating disk partition

We can see that our sdb disk max capacity is 537GB and the offset size is set to 17.4kB. Let’s create a primary partition for this disk by setting up a higher offset size like 1M and the rest of the available space up to 537GB to be allocated for our new partition:

 (parted) mkpart primary 1M 537GB (parted) 

Let’s check if our previous command has been successfully applied:

We can see that all specified values like offset size, partition size and partition table type were applied:

 Model: VMware Virtual disk (scsi) Disk /dev/sdb: 537GB Sector size (logical/physical): 512B/512B Partition Table: gpt Disk Flags: Number Start End Size File system Name Flags 1 1049kB 537GB 537GB primary (parted) 

Knowing now that our primary partition on sdb disk has been created having the right values we can safely quit parted like shown below:

 (parted) q Information: You may need to update /etc/fstab. 

Repeating the steps above for sdd and sdc disks

On this part of our short tutorial we will repeat the steps above for sdc disk:

 $ parted /dev/sdc GNU Parted 3.1 Using /dev/sdc Welcome to GNU Parted! Type 'help' to view a list of commands. (parted) mklabel gpt (parted) print free Model: VMware Virtual disk (scsi) Disk /dev/sdc: 129GB Sector size (logical/physical): 512B/512B Partition Table: gpt Disk Flags: Number Start End Size File system Name Flags 17.4kB 129GB 129GB Free Space (parted) mkpart primary 1M 129GB (parted) p Model: VMware Virtual disk (scsi) Disk /dev/sdc: 129GB Sector size (logical/physical): 512B/512B Partition Table: gpt Disk Flags: Number Start End Size File system Name Flags 1 1049kB 129GB 129GB primary (parted) q Information: You may need to update /etc/fstab. 

Now we’ll follow the same steps for our 3rd disk called sdd . This is the biggest disk from our fictive server having more than 4TB in total size, being actually the most important disk from our short tutorial about how to create partitions larger than 2TB in Linux:

 $ parted /dev/sdd GNU Parted 3.1 Using /dev/sdd Welcome to GNU Parted! Type 'help' to view a list of commands. (parted) mklabel gpt (parted) print free Model: VMware Virtual disk (scsi) Disk /dev/sdd: 4398GB Sector size (logical/physical): 512B/512B Partition Table: gpt Disk Flags: Number Start End Size File system Name Flags 17.4kB 4398GB 4398GB Free Space (parted) mkpart primary 1M 4398GB (parted) p Model: VMware Virtual disk (scsi) Disk /dev/sdd: 4398GB Sector size (logical/physical): 512B/512B Partition Table: gpt Disk Flags: Number Start End Size File system Name Flags 1 1049kB 4398GB 4398GB primary (parted) q Information: You may need to update /etc/fstab. 

Listing disks and partitions

So far we’ve managed to create our desired partitions on each of the three unpartitioned disks. Let’s list once again the content of our /dev/ directory and see if we have the partitions listed here:

 $ ls -la /dev/sd* brw-rw---- 1 root disk 8, 0 May 22 07:19 /dev/sda brw-rw---- 1 root disk 8, 1 May 22 07:19 /dev/sda1 brw-rw---- 1 root disk 8, 2 May 22 07:19 /dev/sda2 brw-rw---- 1 root disk 8, 16 May 22 07:19 /dev/sdb brw-rw---- 1 root disk 8, 17 May 22 07:19 /dev/sdb1 brw-rw---- 1 root disk 8, 32 May 22 07:19 /dev/sdc brw-rw---- 1 root disk 8, 33 May 22 07:19 /dev/sdc1 brw-rw---- 1 root disk 8, 48 May 22 07:19 /dev/sdd brw-rw---- 1 root disk 8, 49 May 22 07:19 /dev/sdd1 

From the above console output we can see that our newly created partitions are in place being now listed as /dev/sdb1 , /dev/sdc1 and /dev/sdd1 .

Formating partitions

We are now one step closer to use our newly created partitions but this only after making those partitions ext4 and mounting them. In this step we will make use of mkfs utility which will allow us to format the partitions and obviously we will start with our first partition named sdb1 :

A successful console output will look similar to this one listed below:

 mke2fs 1.42.9 (28-Dec-2013) Filesystem label= OS type: Linux Block size=4096 (log=2) Fragment size=4096 (log=2) Stride=0 blocks, Stripe width=0 blocks 32768000 inodes, 131071488 blocks 6553574 blocks (5.00%) reserved for the super user First data block=0 Maximum filesystem blocks=2279604224 4000 block groups 32768 blocks per group, 32768 fragments per group 8192 inodes per group Superblock backups stored on blocks: 32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208, 4096000, 7962624, 11239424, 20480000, 23887872, 71663616, 78675968, 102400000 Allocating group tables: done Writing inode tables: done Creating journal (32768 blocks): done Writing superblocks and filesystem accounting information: done 

Let’s repeat the step above for our sdc1 partition this time:

 $ mkfs.ext4 /dev/sdc1 mke2fs 1.42.9 (28-Dec-2013) Filesystem label= OS type: Linux Block size=4096 (log=2) Fragment size=4096 (log=2) Stride=0 blocks, Stripe width=0 blocks 7864320 inodes, 31456768 blocks 1572838 blocks (5.00%) reserved for the super user First data block=0 Maximum filesystem blocks=2178940928 960 block groups 32768 blocks per group, 32768 fragments per group 8192 inodes per group Superblock backups stored on blocks: 32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208, 4096000, 7962624, 11239424, 20480000, 23887872 Allocating group tables: done Writing inode tables: done Creating journal (32768 blocks): done Writing superblocks and filesystem accounting information: done 

And finally our last partition preparation, sdd1 :

 $ mkfs.ext4 /dev/sdd1 mke2fs 1.42.9 (28-Dec-2013) Filesystem label= OS type: Linux Block size=4096 (log=2) Fragment size=4096 (log=2) Stride=0 blocks, Stripe width=0 blocks 268435456 inodes, 1073741312 blocks 53687065 blocks (5.00%) reserved for the super user First data block=0 Maximum filesystem blocks=3221225472 32768 block groups 32768 blocks per group, 32768 fragments per group 8192 inodes per group Superblock backups stored on blocks: 32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208, 4096000, 7962624, 11239424, 20480000, 23887872, 71663616, 78675968, 102400000, 214990848, 512000000, 550731776, 644972544 Allocating group tables: done Writing inode tables: done Creating journal (32768 blocks): done Writing superblocks and filesystem accounting information: done 

Creating directories before mounting the partitions

Now we can say that we’re in a very good position with our tutorial, we have made a lot of progress like creating partitions using parted and formatting these using mkfs utility. Now all we need to do is just to create some directories and mount these partitions. Let’s start by changing the directory quickly to mnt :

And let’s do a quick list and check if we have any directories on /mnt/ :

 $ ls -la total 0 drwxr-xr-x. 2 root root 6 Apr 10 22:59 . dr-xr-xr-x. 17 root root 244 May 22 03:33 .. 

As we can see there are no directories (in our case). We have to create three new directories, each one for each new partition:

Let’s do a check once again if our newly created directories are in place:

 $ ls -la total 0 drwxr-xr-x. 5 root root 60 May 24 07:32 . dr-xr-xr-x. 17 root root 244 May 22 03:33 .. drwxr-xr-x 2 root root 6 May 24 07:32 mysql-data drwxr-xr-x 2 root root 6 May 24 07:32 mysql-logs drwxr-xr-x 2 root root 6 May 24 07:32 mysql-temp 

All three directories are now present, we can now move to the next step.

Amending fstab file

We have three partitions from our three disks and also and three new directories.
Let’s join these partitions with our directories by editing the fstab file:

Having now fstab open we need to add three new lines at the end of it like shown below:

 . /dev/sdb1 /mnt/mysql-logs ext4 defaults 0 0 /dev/sdc1 /mnt/mysql-temp ext4 defaults 0 0 /dev/sdd1 /mnt/mysql-data ext4 defaults 0 0 

We can now save fstab file and move to the next step where we can mount the partitions.

Mounting partitions

We can achieve this by using mount command like shown below:

If everything went fine and no errors were encountered we should be able to see now our partitions mounted, let’s run df command and make sure that everything we’ve done so far has been successfully:

A successful console output will look like this one below:

 Filesystem Type Size Used Avail Use% Mounted on /dev/mapper/cl_mydbhost-root xfs 28G 2.6G 26G 9% / devtmpfs devtmpfs 17G 0 17G 0% /dev tmpfs tmpfs 17G 0 17G 0% /dev/shm tmpfs tmpfs 17G 21M 17G 1% /run tmpfs tmpfs 17G 0 17G 0% /sys/fs/cgroup /dev/sda1 xfs 1.1G 217M 848M 21% /boot tmpfs tmpfs 3.4G 0 3.4G 0% /run/user/1001 /dev/sdb1 ext4 529G 76M 502G 1% /mnt/mysql-logs /dev/sdc1 ext4 127G 63M 121G 1% /mnt/mysql-temp /dev/sdd1 ext4 4.4T 93M 4.2T 1% /mnt/mysql-data 

We’re now done, we’ve managed to link the partitions with our directories. Now we can start populating these new partitions with files.

Summary of our short tutorial about how to create partitions larger than 2TB in Linux

On this short tutorial called “How to create partitions larger than 2TB in Linux” we have learned quite a few things like:
– How to install parted using yum
– How to view the disks and partitions using ls
– How to create GTP partition tables
– How to create disk partitions with parted
– How to format disk partitions using mkfs utility as ext4 file system
– How to create 3 directories with one command line
– How to add new entries in fstab file
– How to mount disk partitions using mount command
– And how to see all usable partitions on our server using df

Источник