Procedure

1. Create a new playbook.yml file with the following content:

   ---
   - name: Configure the storage
     hosts: managed-node-01.example.com
     tasks:
     - name: Create a RAID on sdd, sde, sdf, and sdg
       include_role:
         name: rhel-system-roles.storage
       vars:
       storage_safe_mode: false
       storage_volumes:
         - name: data
           type: raid
           disks: [sdd, sde, sdf, sdg]
           raid_level: raid0
           raid_chunk_size: 32 KiB
           mount_point: /mnt/data
           state: present

   Warning

   Device names might change in certain circumstances, for example, when you add a new disk to a system. Therefore, to prevent data loss, do not use specific disk names in the playbook.

2. Optional: Verify the playbook syntax:

   # ansible-playbook --syntax-check playbook.yml

3. Run the playbook:

   # ansible-playbook -i inventory.file /path/to/file/playbook.yml

Procedure

1. Create a new playbook.yml file with the following content:

   - hosts: all
     vars:
       storage_safe_mode: false
       storage_pools:
         - name: my_pool
           type: lvm
           disks: [sdh, sdi]
           raid_level: raid1
           volumes:
             - name: my_pool
               size: "1 GiB"
               mount_point: "/mnt/app/shared"
               fs_type: xfs
               state: present
     roles:
       - name: rhel-system-roles.storage

   Note

   To create an LVM pool with RAID, you must specify the RAID type using the raid_level parameter.

2. Optional. Verify playbook syntax.

   # ansible-playbook --syntax-check playbook.yml

3. Run the playbook on your inventory file:

   # ansible-playbook -i inventory.file /path/to/file/playbook.yml

Procedure

1. Create a new playbook.yml file with the following content:

   - hosts: all
     vars:
       storage_volumes:
         - name: barefs
           type: disk
           disks:
            - sdb
           fs_type: xfs
           fs_label: label-name
           mount_point: /mnt/data
           encryption: true
           encryption_password: your-password
     roles:
      - rhel-system-roles.storage

2. Optional: Verify playbook syntax:

   # ansible-playbook --syntax-check playbook.yml

3. Run the playbook on your inventory file:

   # ansible-playbook -i inventory.file /path/to/file/playbook.yml

Procedure

1. Start the interactive parted shell:

   # parted block-device

2. Determine if there already is a partition table on the device:

   # (parted) print

   If the device already contains partitions, they will be deleted in the following steps.

3. Create the new partition table:

   # (parted) mklabel table-type

   • Replace table-type with with the intended partition table type:

     • msdos for MBR
     • gpt for GPT

   Example 4.1. Creating a GUID Partition Table (GPT) table

   To create a GPT table on the disk, use:

   # (parted) mklabel gpt

   The changes start applying after you enter this command.

4. View the partition table to confirm that it is created:

   # (parted) print

5. Exit the parted shell:

   # (parted) quit

Procedure

1. Start the parted utility. For example, the following output lists the device /dev/sda:

   # parted /dev/sda

2. View the partition table:

   # (parted) print
   
   Model: ATA SAMSUNG MZNLN256 (scsi)
   Disk /dev/sda: 256GB
   Sector size (logical/physical): 512B/512B
   Partition Table: msdos
   Disk Flags:
   
   Number  Start   End     Size    Type      File system  Flags
    1      1049kB  269MB   268MB   primary   xfs          boot
    2      269MB   34.6GB  34.4GB  primary
    3      34.6GB  45.4GB  10.7GB  primary
    4      45.4GB  256GB   211GB   extended
    5      45.4GB  256GB   211GB   logical

3. Optional: Switch to the device you want to examine next:

   # (parted) select block-device

Procedure

1. Start the parted utility:

   # parted block-device

2. View the current partition table to determine if there is enough free space:

   # (parted) print

   • Resize the partition in case there is not enough free space.

   • From the partition table, determine:

     • The start and end points of the new partition.
     • On MBR, what partition type it should be.

3. Create the new partition:

   # (parted) mkpart part-type name fs-type start end

   • Replace part-type with with primary, logical, or extended. This applies only to the MBR partition table.
   • Replace name with an arbitrary partition name. This is required for GPT partition tables.
   • Replace fs-type with xfs, ext2, ext3, ext4, fat16, fat32, hfs, hfs+, linux-swap, ntfs, or reiserfs. The fs-type parameter is optional. Note that the parted utility does not create the file system on the partition.
   • Replace start and end with the sizes that determine the starting and ending points of the partition, counting from the beginning of the disk. You can use size suffixes, such as 512MiB, 20GiB, or 1.5TiB. The default size is in megabytes.

   Example 4.2. Creating a small primary partition

   To create a primary partition from 1024MiB until 2048MiB on an MBR table, use:

   # (parted) mkpart primary 1024MiB 2048MiB

   The changes start applying after you enter the command.

4. View the partition table to confirm that the created partition is in the partition table with the correct partition type, file system type, and size:

   # (parted) print

5. Exit the parted shell:

   # (parted) quit

6. Register the new device node:

   # udevadm settle

7. Verify that the kernel recognizes the new partition:

   # cat /proc/partitions

Procedure

1. Start the interactive fdisk shell:

   # fdisk block-device

2. View the current partition table to determine the minor partition number:

   Command (m for help): print

   You can see the current partition type in the Type column and its corresponding type ID in the Id column.

3. Enter the partition type command and select a partition using its minor number:

   Command (m for help): type
   Partition number (1,2,3 default 3): 2

4. Optional: View the list in hexadecimal codes:

   Hex code (type L to list all codes): L

5. Set the partition type:

   Hex code (type L to list all codes): 8e

6. Write your changes and exit the fdisk shell:

   Command (m for help): write
   The partition table has been altered.
   Syncing disks.

7. Verify your changes:

   # fdisk --list block-device

Procedure

1. Start the parted utility:

   # parted block-device

2. View the current partition table:

   # (parted) print

   From the partition table, determine:

   • The minor number of the partition.
   • The location of the existing partition and its new ending point after resizing.

3. Resize the partition:

   # (parted) resizepart 1 2GiB

   • Replace 1 with the minor number of the partition that you are resizing.
   • Replace 2 with the size that determines the new ending point of the resized partition, counting from the beginning of the disk. You can use size suffixes, such as 512MiB, 20GiB, or 1.5TiB. The default size is in megabytes.

4. View the partition table to confirm that the resized partition is in the partition table with the correct size:

   # (parted) print

5. Exit the parted shell:

   # (parted) quit

6. Verify that the kernel registers the new partition:

   # cat /proc/partitions

7. Optional: If you extended the partition, extend the file system on it as well.

Procedure

1. Start the interactive parted shell:

   # parted block-device

   • Replace block-device with the path to the device where you want to remove a partition: for example, /dev/sda.

2. View the current partition table to determine the minor number of the partition to remove:

   (parted) print

3. Remove the partition:

   (parted) rm minor-number

   • Replace minor-number with the minor number of the partition you want to remove.

   The changes start applying as soon as you enter this command.

4. Verify that you have removed the partition from the partition table:

   (parted) print

5. Exit the parted shell:

   (parted) quit

6. Verify that the kernel registers that the partition is removed:

   # cat /proc/partitions

7. Remove the partition from the /etc/fstab file, if it is present. Find the line that declares the removed partition, and remove it from the file.

8. Regenerate mount units so that your system registers the new /etc/fstab configuration:

   # systemctl daemon-reload

9. If you have deleted a swap partition or removed pieces of LVM, remove all references to the partition from the kernel command line:

   1. List active kernel options and see if any option references the removed partition:

      # grubby --info=ALL

   2. Remove the kernel options that reference the removed partition:

      # grubby --update-kernel=ALL --remove-args="option"

10. To register the changes in the early boot system, rebuild the initramfs file system:

    # dracut --force --verbose

Procedure

1. Install the targetcli tool:

   # dnf install targetcli

2. Start the target service:

   # systemctl start target

3. Configure target to start at boot time:

   # systemctl enable target

4. Open port 3260 in the firewall and reload the firewall configuration:

   # firewall-cmd --permanent --add-port=3260/tcp
   Success
   
   # firewall-cmd --reload
   Success

Procedure

1. Navigate to the iSCSI directory:

   /> iscsi/

   Note

   The cd command is used to change directories as well as to list the path to move into.

2. Use one of the following options to create an iSCSI target:

   1. Creating an iSCSI target using a default target name:

      /iscsi> create
      
      Created target
      iqn.2003-01.org.linux-iscsi.hostname.x8664:sn.78b473f296ff
      Created TPG1

   2. Creating an iSCSI target using a specific name:

      /iscsi> create iqn.2006-04.com.example:444
      
      Created target iqn.2006-04.com.example:444
      Created TPG1
      Here iqn.2006-04.com.example:444 is target_iqn_name

      Replace iqn.2006-04.com.example:444 with the specific target name.

3. Verify the newly created target:

   /iscsi> ls
   
   o- iscsi.......................................[1 Target]
       o- iqn.2006-04.com.example:444................[1 TPG]
           o- tpg1...........................[enabled, auth]
              o- acls...............................[0 ACL]
               o- luns...............................[0 LUN]
              o- portals.........................[0 Portal]

Procedure

1. Navigate to the fileio/ from the backstores/ directory:

   /> backstores/fileio

2. Create a fileio storage object:

   /backstores/fileio> create file1 /tmp/disk1.img 200M write_back=false
   
   Created fileio file1 with size 209715200

Procedure

1. Navigate to the block/ from the backstores/ directory:

   /> backstores/block/

2. Create a block backstore:

   /backstores/block> create name=block_backend dev=/dev/sdb
   
   Generating a wwn serial.
   Created block storage object block_backend using /dev/vdb.

Procedure

1. Navigate to the pscsi/ from the backstores/ directory:

   /> backstores/pscsi/

2. Create a pscsi backstore for a physical SCSI device, a TYPE_ROM device using /dev/sr0 in this example:

   /backstores/pscsi> create name=pscsi_backend dev=/dev/sr0
   
   Generating a wwn serial.
   Created pscsi storage object pscsi_backend using /dev/sr0

Procedure

1. Navigate to the ramdisk/ from the backstores/ directory:

   /> backstores/ramdisk/

2. Create a 1GB RAM disk backstore:

   /backstores/ramdisk> create name=rd_backend size=1GB
   
   Generating a wwn serial.
   Created rd_mcp ramdisk rd_backend with size 1GB.

Procedure

1. Navigate to the TPG directory:

   /iscsi> iqn.2006-04.example:444/tpg1/

2. Use one of the following options to create an iSCSI portal:

   1. Creating a default portal uses the default iSCSI port 3260 and allows the target to listen to all IP addresses on that port:

      /iscsi/iqn.20...mple:444/tpg1> portals/ create
      
      Using default IP port 3260
      Binding to INADDR_Any (0.0.0.0)
      Created network portal 0.0.0.0:3260

      Note

      When an iSCSI target is created, a default portal is also created. This portal is set to listen to all IP addresses with the default port number that is: 0.0.0.0:3260.

      To remove the default portal, use the following command:

      /iscsi/iqn-name/tpg1/portals delete ip_address=0.0.0.0 ip_port=3260

   2. Creating a portal using a specific IP address:

      /iscsi/iqn.20...mple:444/tpg1> portals/ create 192.168.122.137
      
      Using default IP port 3260
      Created network portal 192.168.122.137:3260

Procedure

1. Create LUNs of already created storage objects:

   /iscsi/iqn.20...mple:444/tpg1> luns/ create /backstores/ramdisk/rd_backend
   Created LUN 0.
   
   /iscsi/iqn.20...mple:444/tpg1> luns/ create /backstores/block/block_backend
   Created LUN 1.
   
   /iscsi/iqn.20...mple:444/tpg1> luns/ create /backstores/fileio/file1
   Created LUN 2.

2. Verify the created LUNs:

   /iscsi/iqn.20...mple:444/tpg1> ls
   
   o- tpg.................................. [enambled, auth]
       o- acls ......................................[0 ACL]
       o- luns .....................................[3 LUNs]
       |  o- lun0.........................[ramdisk/ramdisk1]
       |  o- lun1.................[block/block1 (/dev/vdb1)]
       |  o- lun2...................[fileio/file1 (/foo.img)]
       o- portals ................................[1 Portal]
           o- 192.168.122.137:3260......................[OK]

   Default LUN name starts at 0.

   Important

   By default, LUNs are created with read-write permissions. If a new LUN is added after ACLs are created, LUN automatically maps to all available ACLs and can cause a security risk. To create a LUN with read-only permissions, see Creating a read-only iSCSI LUN.

3. Configure ACLs. For more information, see Creating an iSCSI ACL.

Procedure

1. Set read-only permissions:

   /> set global auto_add_mapped_luns=false
   
   Parameter auto_add_mapped_luns is now 'false'.

   This prevents the auto mapping of LUNs to existing ACLs allowing the manual mapping of LUNs.

2. Navigate to the initiator_iqn_name directory:

   /> iscsi/target_iqn_name/tpg1/acls/initiator_iqn_name/

3. Create the LUN:

   /iscsi/target_iqn_name/tpg1/acls/initiator_iqn_name> create mapped_lun=next_sequential_LUN_number tpg_lun_or_backstore=backstore write_protect=1

   Example:

   /iscsi/target_iqn_name/tpg1/acls/2006-04.com.example.foo:888> create mapped_lun=1 tpg_lun_or_backstore=/backstores/block/block2 write_protect=1
   
   Created LUN 1.
   Created Mapped LUN 1.

4. Verify the created LUN:

   /iscsi/target_iqn_name/tpg1/acls/2006-04.com.example.foo:888> ls
    o- 2006-04.com.example.foo:888 .. [Mapped LUNs: 2]
    | o- mapped_lun0 .............. [lun0 block/disk1 (rw)]
    | o- mapped_lun1 .............. [lun1 block/disk2 (ro)]

   The mapped_lun1 line now has (ro) at the end (unlike mapped_lun0’s (rw)) stating that it is read-only.

5. Configure ACLs. For more information, see Creating an iSCSI ACL.

Procedure

1. Navigate to the acls directory

   /iscsi/iqn.20...mple:444/tpg1> acls/

2. Use one of the following options to create an ACL :

   1. Using the initiator name from /etc/iscsi/initiatorname.iscsi file on the initiator.

   2. Using a name that is easier to remember, see section Creating an iSCSI initiator to ensure ACL matches the initiator.

      /iscsi/iqn.20...444/tpg1/acls> create iqn.2006-04.com.example.foo:888
      
      Created Node ACL for iqn.2006-04.com.example.foo:888
      Created mapped LUN 2.
      Created mapped LUN 1.
      Created mapped LUN 0.

      Note

      The global setting auto_add_mapped_luns used in the preceding example, automatically maps LUNs to any created ACL.

      You can set user-created ACLs within the TPG node on the target server:

      /iscsi/iqn.20...scsi:444/tpg1> set attribute generate_node_acls=1

Procedure

1. Set attribute authentication:

   /iscsi/iqn.20...mple:444/tpg1> set attribute authentication=1
   
   Parameter authentication is now '1'.

2. Set userid and password:

   /tpg1> set auth userid=redhat
   Parameter userid is now 'redhat'.
   
   /iscsi/iqn.20...689dcbb3/tpg1> set auth password=redhat_passwd
   Parameter password is now 'redhat_passwd'.

Procedure

1. Log off from the target:

   # iscsiadm -m node -T iqn.2006-04.example:444 -u

   For more information on how to log in to the target, see Creating an iSCSI initiator.

2. Remove the entire target, including all ACLs, LUNs, and portals:

   /> iscsi/ delete iqn.2006-04.com.example:444

   Replace iqn.2006-04.com.example:444 with the target_iqn_name.

   • To remove an iSCSI backstore:

     /> backstores/backstore-type/ delete block_backend

     • Replace backstore-type with either fileio, block, pscsi, or ramdisk.
     • Replace block_backend with the backstore-name you want to delete.

   • To remove parts of an iSCSI target, such as an ACL:

     /> /iscsi/iqn-name/tpg/acls/ delete iqn.2006-04.com.example:444

Procedure

1. Install iscsi-initiator-utils on client machine:

   # dnf install iscsi-initiator-utils

2. Check the initiator name:

   # cat /etc/iscsi/initiatorname.iscsi
   
   InitiatorName=2006-04.com.example.foo:888

3. If the ACL was given a custom name in Creating an iSCSI ACL, modify the /etc/iscsi/initiatorname.iscsi file accordingly.

   # vi /etc/iscsi/initiatorname.iscsi

4. Discover the target and log in to the target with the displayed target IQN:

   # iscsiadm -m discovery -t st -p 10.64.24.179
       10.64.24.179:3260,1 iqn.2006-04.example:444
   
   # iscsiadm -m node -T iqn.2006-04.example:444 -l
       Logging in to [iface: default, target: iqn.2006-04.example:444, portal: 10.64.24.179,3260] (multiple)
       Login to [iface: default, target: iqn.2006-04.example:444, portal: 10.64.24.179,3260] successful.

   Replace 10.64.24.179 with the target-ip-address.

   You can use this procedure for any number of initiators connected to the same target if their respective initiator names are added to the ACL as described in the Creating an iSCSI ACL.

5. Find the iSCSI disk name and create a file system on this iSCSI disk:

   # grep "Attached SCSI" /var/log/messages
   
   # mkfs.ext4 /dev/disk_name

   Replace disk_name with the iSCSI disk name displayed in the /var/log/messages file.

6. Mount the file system:

   # mkdir /mount/point
   
   # mount /dev/disk_name /mount/point

   Replace /mount/point with the mount point of the partition.

7. Edit the /etc/fstab file to mount the file system automatically when the system boots:

   # vi /etc/fstab
   
   /dev/disk_name /mount/point ext4 _netdev 0 0

   Replace disk_name with the iSCSI disk name and /mount/point with the mount point of the partition.

Procedure

1. Enable CHAP authentication in the iscsid.conf file:

   # vi /etc/iscsi/iscsid.conf
   
   node.session.auth.authmethod = CHAP

   By default, the node.session.auth.authmethod is set to None

2. Add target username and password in the iscsid.conf file:

   node.session.auth.username = redhat
   node.session.auth.password = redhat_passwd

3. Start the iscsid daemon:

   # systemctl start iscsid.service

Procedure

1. Install the iscsi-initiator-utils on client machine:

   # dnf install iscsi-initiator-utils

2. Find information about the running sessions:

   # iscsiadm -m session -P 3

   This command displays the session or device state, session ID (sid), some negotiated parameters, and the SCSI devices accessible through the session.

   • For shorter output, for example, to display only the sid-to-node mapping, run:

     # iscsiadm -m session -P 0
             or
     # iscsiadm -m session
     
     tcp [2] 10.15.84.19:3260,2 iqn.1992-08.com.netapp:sn.33615311
     tcp [3] 10.15.85.19:3260,3 iqn.1992-08.com.netapp:sn.33615311

     These commands print the list of running sessions in the following format: driver [sid] target_ip:port,target_portal_group_tag proper_target_name.

Procedure

1. Determine which devices are paths for a multipath logical unit:

   multipath -ll

2. Re-scan Fibre Channel logical units on a system that uses multipathing:

   $ echo 1 > /sys/block/sdX/device/rescan

Procedure

1. Create the nvmet-rdma subsystem:

   # modprobe nvmet-rdma
   
   # mkdir /sys/kernel/config/nvmet/subsystems/testnqn
   
   # cd /sys/kernel/config/nvmet/subsystems/testnqn

   Replace testnqn with the subsystem name.

2. Allow any host to connect to this controller:

   # echo 1 > attr_allow_any_host

3. Configure a namespace:

   # mkdir namespaces/10
   
   # cd namespaces/10

   Replace 10 with the namespace number

4. Set a path to the NVMe device:

   # echo -n /dev/nvme0n1 > device_path

5. Enable the namespace:

   # echo 1 > enable

6. Create a directory with an NVMe port:

   # mkdir /sys/kernel/config/nvmet/ports/1
   
   # cd /sys/kernel/config/nvmet/ports/1

7. Display the IP address of mlx5_ib0:

   # ip addr show mlx5_ib0
   
   8: mlx5_ib0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 4092 qdisc mq state UP group default qlen 256
       link/infiniband 00:00:06:2f:fe:80:00:00:00:00:00:00:e4:1d:2d:03:00:e7:0f:f6 brd 00:ff:ff:ff:ff:12:40:1b:ff:ff:00:00:00:00:00:00:ff:ff:ff:ff
       inet 172.31.0.202/24 brd 172.31.0.255 scope global noprefixroute mlx5_ib0
          valid_lft forever preferred_lft forever
       inet6 fe80::e61d:2d03:e7:ff6/64 scope link noprefixroute
          valid_lft forever preferred_lft forever

8. Set the transport address for the controller:

   # echo -n 172.31.0.202 > addr_traddr

9. Set RDMA as the transport type:

   # echo rdma > addr_trtype
   
   # echo 4420 > addr_trsvcid

10. Set the address family for the port:

    # echo ipv4 > addr_adrfam

11. Create a soft link:

    # ln -s /sys/kernel/config/nvmet/subsystems/testnqn   /sys/kernel/config/nvmet/ports/1/subsystems/testnqn

Procedure

1. Install the nvmetcli package:

   # dnf install nvmetcli

2. Download the rdma.json file:

   # wget http://git.infradead.org/users/hch/nvmetcli.git/blob_plain/0a6b088db2dc2e5de11e6f23f1e890e4b54fee64:/rdma.json

3. Edit the rdma.json file and change the traddr value to 172.31.0.202.

4. Setup the controller by loading the NVMe controller configuration file:

   # nvmetcli restore rdma.json

Procedure

1. Install the nvme-cli tool:

   # dnf install nvme-cli

2. Load the nvme-rdma module if it is not loaded:

   # modprobe nvme-rdma

3. Discover available subsystems on the NVMe controller:

   # nvme discover -t rdma -a 172.31.0.202 -s 4420
   
   Discovery Log Number of Records 1, Generation counter 2
   =====Discovery Log Entry 0======
   trtype:  rdma
   adrfam:  ipv4
   subtype: nvme subsystem
   treq:    not specified, sq flow control disable supported
   portid:  1
   trsvcid: 4420
   subnqn:  testnqn
   traddr:  172.31.0.202
   rdma_prtype: not specified
   rdma_qptype: connected
   rdma_cms:    rdma-cm
   rdma_pkey: 0x0000

4. Connect to the discovered subsystems:

   # nvme connect -t rdma -n testnqn -a 172.31.0.202 -s 4420
   
   # lsblk
   NAME                         MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
   sda                            8:0    0 465.8G  0 disk
   ├─sda1                         8:1    0     1G  0 part /boot
   └─sda2                         8:2    0 464.8G  0 part
     ├─rhel_rdma--virt--03-root 253:0    0    50G  0 lvm  /
     ├─rhel_rdma--virt--03-swap 253:1    0     4G  0 lvm  [SWAP]
     └─rhel_rdma--virt--03-home 253:2    0 410.8G  0 lvm  /home
   nvme0n1
   
   # cat /sys/class/nvme/nvme0/transport
   rdma

   Replace testnqn with the NVMe subsystem name.

   Replace 172.31.0.202 with the controller IP address.

   Replace 4420 with the port number.

Procedure

1. Install the nvme-cli tool:

   # dnf install nvme-cli

   This creates the hostnqn file in the /etc/nvme/ directory. The hostnqn file identifies the NVMe host.

2. Find the WWNN and WWPN identifiers of the local and remote ports and use the output to find the subsystem NQN:

   # cat /sys/class/scsi_host/host*/nvme_info
   
   NVME Host Enabled
   XRI Dist lpfc0 Total 6144 IO 5894 ELS 250
   NVME LPORT lpfc0 WWPN x10000090fae0b5f5 WWNN x20000090fae0b5f5 DID x010f00 ONLINE
   NVME RPORT       WWPN x204700a098cbcac6 WWNN x204600a098cbcac6 DID x01050e TARGET DISCSRVC ONLINE
   
   NVME Statistics
   LS: Xmt 000000000e Cmpl 000000000e Abort 00000000
   LS XMIT: Err 00000000  CMPL: xb 00000000 Err 00000000
   Total FCP Cmpl 00000000000008ea Issue 00000000000008ec OutIO 0000000000000002
       abort 00000000 noxri 00000000 nondlp 00000000 qdepth 00000000 wqerr 00000000 err 00000000
   FCP CMPL: xb 00000000 Err 00000000

   # nvme discover --transport fc \
                   --traddr nn-0x204600a098cbcac6:pn-0x204700a098cbcac6 \
                   --host-traddr nn-0x20000090fae0b5f5:pn-0x10000090fae0b5f5
   
   Discovery Log Number of Records 2, Generation counter 49530
   =====Discovery Log Entry 0======
   trtype:  fc
   adrfam:  fibre-channel
   subtype: nvme subsystem
   treq:    not specified
   portid:  0
   trsvcid: none
   subnqn:  nqn.1992-08.com.netapp:sn.e18bfca87d5e11e98c0800a098cbcac6:subsystem.st14_nvme_ss_1_1
   traddr:  nn-0x204600a098cbcac6:pn-0x204700a098cbcac6

   Replace nn-0x204600a098cbcac6:pn-0x204700a098cbcac6 with the traddr.

   Replace nn-0x20000090fae0b5f5:pn-0x10000090fae0b5f5 with the host-traddr.

3. Connect to the NVMe controller using the nvme-cli:

   # nvme connect --transport fc \
                  --traddr nn-0x204600a098cbcac6:pn-0x204700a098cbcac6 \
                  --host-traddr nn-0x20000090fae0b5f5:pn-0x10000090fae0b5f5 \
                  -n nqn.1992-08.com.netapp:sn.e18bfca87d5e11e98c0800a098cbcac6:subsystem.st14_nvme_ss_1_1

   Replace nn-0x204600a098cbcac6:pn-0x204700a098cbcac6 with the traddr.

   Replace nn-0x20000090fae0b5f5:pn-0x10000090fae0b5f5 with the host-traddr.

   Replace nqn.1992-08.com.netapp:sn.e18bfca87d5e11e98c0800a098cbcac6:subsystem.st14_nvme_ss_1_1 with the subnqn.

Procedure

1. Install the nvme-cli tool:

   # dnf install nvme-cli

   This creates the hostnqn file in the /etc/nvme/ directory. The hostnqn file identifies the NVMe host.

2. Reload the qla2xxx module:

   # rmmod qla2xxx
   # modprobe qla2xxx

3. Find the WWNN and WWPN identifiers of the local and remote ports:

   # dmesg |grep traddr
   
   [    6.139862] qla2xxx [0000:04:00.0]-ffff:0: register_localport: host-traddr=nn-0x20000024ff19bb62:pn-0x21000024ff19bb62 on portID:10700
   [    6.241762] qla2xxx [0000:04:00.0]-2102:0: qla_nvme_register_remote: traddr=nn-0x203b00a098cbcac6:pn-0x203d00a098cbcac6 PortID:01050d

   Using these host-traddr and traddr values, find the subsystem NQN:

   # nvme discover --transport fc \
                   --traddr nn-0x203b00a098cbcac6:pn-0x203d00a098cbcac6 \
                   --host-traddr nn-0x20000024ff19bb62:pn-0x21000024ff19bb62
   
   Discovery Log Number of Records 2, Generation counter 49530
   =====Discovery Log Entry 0======
   trtype:  fc
   adrfam:  fibre-channel
   subtype: nvme subsystem
   treq:    not specified
   portid:  0
   trsvcid: none
   subnqn:  nqn.1992-08.com.netapp:sn.c9ecc9187b1111e98c0800a098cbcac6:subsystem.vs_nvme_multipath_1_subsystem_468
   traddr:  nn-0x203b00a098cbcac6:pn-0x203d00a098cbcac6

   Replace nn-0x203b00a098cbcac6:pn-0x203d00a098cbcac6 with the traddr.

   Replace nn-0x20000024ff19bb62:pn-0x21000024ff19bb62 with the host-traddr.

4. Connect to the NVMe controller using the nvme-cli tool:

   # nvme connect  --transport fc \
                   --traddr nn-0x203b00a098cbcac6:pn-0x203d00a098cbcac6 \
                   --host-traddr nn-0x20000024ff19bb62:pn-0x21000024ff19bb62 \
                   -n nqn.1992-08.com.netapp:sn.c9ecc9187b1111e98c0800a098cbcac6:subsystem.vs_nvme_multipath_1_subsystem_468

   Replace nn-0x203b00a098cbcac6:pn-0x203d00a098cbcac6 with the traddr.

   Replace nn-0x20000024ff19bb62:pn-0x21000024ff19bb62 with the host-traddr.

   Replace nqn.1992-08.com.netapp:sn.c9ecc9187b1111e98c0800a098cbcac6:subsystem.vs_nvme_multipath_1_subsystem_468 with the subnqn.

Procedure

1. Install the nvme-cli tool:

   # dnf install nvme-cli

   This tool creates the hostnqn file in the /etc/nvme/ directory, which identifies the NVMe host.

2. Find the nvme hostid and hostnqn:

   # cat /etc/nvme/hostnqn
   nqn.2014-08.org.nvmexpress:uuid:8ae2b12c-3d28-4458-83e3-658e571ed4b8
   
   # cat /etc/nvme/hostid
   09e2ce17-ccc9-412d-8dcf-2b0a1d581ee3

   Use the hostid and hostnqn values to configure the NVMe/TCP controller.

3. Check the status of the controller:

   # nmcli device show ens6
   GENERAL.DEVICE:                         ens6
   GENERAL.TYPE:                           ethernet
   GENERAL.HWADDR:                         52:57:02:12:02:02
   GENERAL.MTU:                            1500
   GENERAL.STATE:                          30 (disconnected)
   GENERAL.CONNECTION:                     --
   GENERAL.CON-PATH:                       --
   WIRED-PROPERTIES.CARRIER:               on

4. Configure the host network for a newly installed Ethernet controller with a static IP address:

   # nmcli connection add con-name ens6 ifname ens6 type ethernet ip4 192.168.101.154/24 gw4 192.168.101.1

   Here, replace 192.168.101.154 with the host IP address.

   # nmcli connection mod ens6 ipv4.method manual
   # nmcli connection up ens6

   Since a new network is created to connect the NVMe/TCP host to the NVMe/TCP controller, execute this step on the controller too.

Procedure

1. Load the nvme_tcp module if not already:

   # modprobe nvme_tcp

2. Discover the available subsystems on the NVMe controller:

   # nvme discover --transport=tcp --traddr=192.168.101.55 --host-traddr=192.168.101.154 --trsvcid=8009
   
   Discovery Log Number of Records 2, Generation counter 7
   =====Discovery Log Entry 0======
   trtype:  tcp
   adrfam:  ipv4
   subtype: current discovery subsystem
   treq:	not specified, sq flow control disable supported
   portid:  2
   trsvcid: 8009
   subnqn:  nqn.2014-08.org.nvmexpress.discovery
   traddr:  192.168.101.55
   eflags:  not specified
   sectype: none
   =====Discovery Log Entry 1======
   trtype:  tcp
   adrfam:  ipv4
   subtype: nvme subsystem
   treq:	not specified, sq flow control disable supported
   portid:  2
   trsvcid: 8009
   subnqn:  nqn.2014-08.org.nvmexpress:uuid:0c468c4d-a385-47e0-8299-6e95051277db
   traddr:  192.168.101.55
   eflags:  not specified
   sectype: none

   Here, 192.168.101.55 is the NVMe/TCP controller IP address and 192.168.101.154 is the NVMe/TCP host IP address.

3. Configure the /etc/nvme/discovery.conf file to add the parameters used in the nvme discover command :

   # echo "--transport=tcp --traddr=192.168.101.55 --host-traddr=192.168.101.154 --trsvcid=8009" >> /etc/nvme/discovery.conf

4. Connect the NVMe/TCP host to the controller system:

   # nvme connect-all

Procedure

1. Check if native NVMe multipathing is enabled in the kernel:

   # cat /sys/module/nvme_core/parameters/multipath

   The command displays one of the following:

   N

   Native NVMe multipathing is disabled.

   Y

   Native NVMe multipathing is enabled.

2. If native NVMe multipathing is disabled, enable it using one of the following methods:

   • Using a kernel option:

     1. Add the nvme_core.multipath=Y option on the kernel command line:

        # grubby --update-kernel=ALL --args="nvme_core.multipath=Y"

     2. On the 64-bit IBM Z architecture, update the boot menu:

        # zipl

     3. Reboot the system.

   • Using a kernel module configuration file:

     1. Create the /etc/modprobe.d/nvme_core.conf configuration file with the following content:

        options nvme_core multipath=Y

     2. Back up the initramfs file system:

        # cp /boot/initramfs-$(uname -r).img \
             /boot/initramfs-$(uname -r).bak.$(date +%m-%d-%H%M%S).img

     3. Rebuild the initramfs file system:

        # dracut --force --verbose

     4. Reboot the system.

3. Optional: On the running system, change the I/O policy on NVMe devices to distribute the I/O on all available paths:

   # echo "round-robin" > /sys/class/nvme-subsystem/nvme-subsys0/iopolicy

4. Optional: Set the I/O policy persistently using udev rules. Create the /etc/udev/rules.d/71-nvme-io-policy.rules file with the following content:

   ACTION=="add|change", SUBSYSTEM=="nvme-subsystem", ATTR{iopolicy}="round-robin"

Verification

1. Check that your system recognizes the NVMe devices:

   # nvme list
   
   Node             SN                   Model                                    Namespace Usage                      Format           FW Rev
   ---------------- -------------------- ---------------------------------------- --------- -------------------------- ---------------- --------
   /dev/nvme0n1     a34c4f3a0d6f5cec     Linux                                    1         250.06  GB / 250.06  GB    512   B +  0 B   4.18.0-2
   /dev/nvme0n2     a34c4f3a0d6f5cec     Linux                                    2         250.06  GB / 250.06  GB    512   B +  0 B   4.18.0-2

2. List all connected NVMe subsystems:

   # nvme list-subsys
   
   nvme-subsys0 - NQN=testnqn
   \
    +- nvme0 fc traddr=nn-0x20000090fadd597a:pn-0x10000090fadd597a host_traddr=nn-0x20000090fac7e1dd:pn-0x10000090fac7e1dd live
    +- nvme1 fc traddr=nn-0x20000090fadd5979:pn-0x10000090fadd5979 host_traddr=nn-0x20000090fac7e1dd:pn-0x10000090fac7e1dd live
    +- nvme2 fc traddr=nn-0x20000090fadd5979:pn-0x10000090fadd5979 host_traddr=nn-0x20000090fac7e1de:pn-0x10000090fac7e1de live
    +- nvme3 fc traddr=nn-0x20000090fadd597a:pn-0x10000090fadd597a host_traddr=nn-0x20000090fac7e1de:pn-0x10000090fac7e1de live

   Check the active transport type. For example, nvme0 fc indicates that the device is connected over the Fibre Channel transport, and nvme tcp indicates that the device is connected over TCP.

3. If you edited the kernel options, check that native NVMe multipathing is enabled on the kernel command line:

   # cat /proc/cmdline
   
   BOOT_IMAGE=[...] nvme_core.multipath=Y

4. Check that DM Multipath reports the NVMe namespaces as, for example, nvme0c0n1 through nvme0c3n1, and not as, for example, nvme0n1 through nvme3n1:

   # multipath -e -ll | grep -i nvme
   
   uuid.8ef20f70-f7d3-4f67-8d84-1bb16b2bfe03 [nvme]:nvme0n1 NVMe,Linux,4.18.0-2
   | `- 0:0:1    nvme0c0n1 0:0     n/a   optimized live
   | `- 0:1:1    nvme0c1n1 0:0     n/a   optimized live
   | `- 0:2:1    nvme0c2n1 0:0     n/a   optimized live
     `- 0:3:1    nvme0c3n1 0:0     n/a   optimized live
   
   uuid.44c782b4-4e72-4d9e-bc39-c7be0a409f22 [nvme]:nvme0n2 NVMe,Linux,4.18.0-2
   | `- 0:0:1    nvme0c0n1 0:0     n/a   optimized live
   | `- 0:1:1    nvme0c1n1 0:0     n/a   optimized live
   | `- 0:2:1    nvme0c2n1 0:0     n/a   optimized live
     `- 0:3:1    nvme0c3n1 0:0     n/a   optimized live

5. If you changed the I/O policy, check that round-robin is the active I/O policy on NVMe devices:

   # cat /sys/class/nvme-subsystem/nvme-subsys0/iopolicy
   
   round-robin

Procedure

1. Check that native NVMe multipathing is disabled:

   # cat /sys/module/nvme_core/parameters/multipath

   The command displays one of the following:

   N

   Native NVMe multipathing is disabled.

   Y

   Native NVMe multipathing is enabled.

2. If native NVMe multipathing is enabled, disable it:

   1. Remove the nvme_core.multipath=Y option from the kernel command line:

      # grubby --update-kernel=ALL --remove-args="nvme_core.multipath=Y"

   2. On the 64-bit IBM Z architecture, update the boot menu:

      # zipl

   3. Remove the options nvme_core multipath=Y line from the /etc/modprobe.d/nvme_core.conf file, if it is present.
   4. Reboot the system.

3. Make sure that DM Multipath is enabled:

   # systemctl enable --now multipathd.service

4. Distribute I/O on all available paths. Add the following content in the /etc/multipath.conf file:

   device {
     vendor "NVME"
     product ".*"
     path_grouping_policy    group_by_prio
   }

   Note

   The /sys/class/nvme-subsystem/nvme-subsys0/iopolicy configuration file has no effect on the I/O distribution when DM Multipath manages the NVMe devices.

5. Reload the multipathd service to apply the configuration changes:

   # multipath -r

6. Back up the initramfs file system:

   # cp /boot/initramfs-$(uname -r).img \
        /boot/initramfs-$(uname -r).bak.$(date +%m-%d-%H%M%S).img

7. Rebuild the initramfs file system:

   # dracut --force --verbose

Verification

1. Check that your system recognizes the NVMe devices:

   # nvme list
   
   Node             SN                   Model                                    Namespace Usage                      Format           FW Rev
   ---------------- -------------------- ---------------------------------------- --------- -------------------------- ---------------- --------
   /dev/nvme0n1     a34c4f3a0d6f5cec     Linux                                    1         250.06  GB / 250.06  GB    512   B +  0 B   4.18.0-2
   /dev/nvme0n2     a34c4f3a0d6f5cec     Linux                                    2         250.06  GB / 250.06  GB    512   B +  0 B   4.18.0-2
   /dev/nvme1n1     a34c4f3a0d6f5cec     Linux                                    1         250.06  GB / 250.06  GB    512   B +  0 B   4.18.0-2
   /dev/nvme1n2     a34c4f3a0d6f5cec     Linux                                    2         250.06  GB / 250.06  GB    512   B +  0 B   4.18.0-2
   /dev/nvme2n1     a34c4f3a0d6f5cec     Linux                                    1         250.06  GB / 250.06  GB    512   B +  0 B   4.18.0-2
   /dev/nvme2n2     a34c4f3a0d6f5cec     Linux                                    2         250.06  GB / 250.06  GB    512   B +  0 B   4.18.0-2
   /dev/nvme3n1     a34c4f3a0d6f5cec     Linux                                    1         250.06  GB / 250.06  GB    512   B +  0 B   4.18.0-2
   /dev/nvme3n2     a34c4f3a0d6f5cec     Linux                                    2         250.06  GB / 250.06  GB    512   B +  0 B   4.18.0-2

2. List all connected NVMe subsystems. Check that the command reports them as, for example, nvme0n1 through nvme3n2, and not as, for example, nvme0c0n1 through nvme0c3n1:

   # nvme list-subsys
   
   nvme-subsys0 - NQN=testnqn
   \
    +- nvme0 fc traddr=nn-0x20000090fadd5979:pn-0x10000090fadd5979 host_traddr=nn-0x20000090fac7e1dd:pn-0x10000090fac7e1dd live
    +- nvme1 fc traddr=nn-0x20000090fadd597a:pn-0x10000090fadd597a host_traddr=nn-0x20000090fac7e1dd:pn-0x10000090fac7e1dd live
    +- nvme2 fc traddr=nn-0x20000090fadd5979:pn-0x10000090fadd5979 host_traddr=nn-0x20000090fac7e1de:pn-0x10000090fac7e1de live
    +- nvme3 fc traddr=nn-0x20000090fadd597a:pn-0x10000090fadd597a host_traddr=nn-0x20000090fac7e1de:pn-0x10000090fac7e1de live

   # multipath -ll
   
   mpathae (uuid.8ef20f70-f7d3-4f67-8d84-1bb16b2bfe03) dm-36 NVME,Linux
   size=233G features='1 queue_if_no_path' hwhandler='0' wp=rw
   `-+- policy='service-time 0' prio=50 status=active
     |- 0:1:1:1  nvme0n1 259:0   active ready running
     |- 1:2:1:1  nvme1n1 259:2   active ready running
     |- 2:3:1:1  nvme2n1 259:4   active ready running
     `- 3:4:1:1  nvme3n1 259:6   active ready running
   
   mpathaf (uuid.44c782b4-4e72-4d9e-bc39-c7be0a409f22) dm-39 NVME,Linux
   size=233G features='1 queue_if_no_path' hwhandler='0' wp=rw
   `-+- policy='service-time 0' prio=50 status=active
     |- 0:1:2:2  nvme0n2 259:1   active ready running
     |- 1:2:2:2  nvme1n2 259:3   active ready running
     |- 2:3:2:2  nvme2n2 259:5   active ready running
     `- 3:4:2:2  nvme3n2 259:7   active ready running

Procedure

1. Disable swapping for the associated logical volume:

   # swapoff -v /dev/VolGroup00/LogVol01

2. Resize the LVM2 logical volume by 2 GB:

   # lvresize /dev/VolGroup00/LogVol01 -L +2G

3. Format the new swap space:

   # mkswap /dev/VolGroup00/LogVol01

4. Enable the extended logical volume:

   # swapon -v /dev/VolGroup00/LogVol01

Procedure

1. Create the LVM2 logical volume of size 2 GB:

   # lvcreate VolGroup00 -n LogVol02 -L 2G

2. Format the new swap space:

   # mkswap /dev/VolGroup00/LogVol02

3. Add the following entry to the /etc/fstab file:

   /dev/VolGroup00/LogVol02 swap swap defaults 0 0

4. Regenerate mount units so that your system registers the new configuration:

   # systemctl daemon-reload

5. Activate swap on the logical volume:

   # swapon -v /dev/VolGroup00/LogVol02

Procedure

1. Determine the size of the new swap file in megabytes and multiply by 1024 to determine the number of blocks. For example, the block size of a 64 MB swap file is 65536.

2. Create an empty file:

   # dd if=/dev/zero of=/swapfile bs=1024 count=65536

   Replace 65536 with the value equal to the desired block size.

3. Set up the swap file with the command:

   # mkswap /swapfile

4. Change the security of the swap file so it is not world readable.

   # chmod 0600 /swapfile

5. Edit the /etc/fstab file with the following entries to enable the swap file at boot time:

   /swapfile swap swap defaults 0 0

   The next time the system boots, it activates the new swap file.

6. Regenerate mount units so that your system registers the new /etc/fstab configuration:

   # systemctl daemon-reload

7. Activate the swap file immediately:

   # swapon /swapfile

Procedure

1. Disable swapping for the associated logical volume:

   # swapoff -v /dev/VolGroup00/LogVol01

2. Reduce the LVM2 logical volume by 512 MB:

   # lvreduce /dev/VolGroup00/LogVol01 -L -512M

3. Format the new swap space:

   # mkswap /dev/VolGroup00/LogVol01

4. Activate swap on the logical volume:

   # swapon -v /dev/VolGroup00/LogVol01

Procedure

1. Disable swapping for the associated logical volume:

   # swapoff -v /dev/VolGroup00/LogVol02

2. Remove the LVM2 logical volume:

   # lvremove /dev/VolGroup00/LogVol02

3. Remove the following associated entry from the /etc/fstab file:

   /dev/VolGroup00/LogVol02 swap swap defaults 0 0

4. Regenerate mount units so that your system registers the new configuration:

   # systemctl daemon-reload

Procedure

1. At a shell prompt, execute the following command to disable the swap file, where /swapfile is the swap file:

   # swapoff -v /swapfile

2. Remove its entry from the /etc/fstab file accordingly.

3. Regenerate mount units so that your system registers the new configuration:

   # systemctl daemon-reload

4. Remove the actual file:

   # rm /swapfile

Procedure

1. Install the fcoe-utils package:

   # dnf install fcoe-utils

2. Copy the /etc/fcoe/cfg-ethx template file to /etc/fcoe/cfg-interface_name. For example, if you want to configure the enp1s0 interface to use FCoE, enter the following command:

   # cp /etc/fcoe/cfg-ethx /etc/fcoe/cfg-enp1s0

3. Enable and start the fcoe service:

   # systemctl enable --now fcoe

4. Discover the FCoE VLAN on interface enp1s0, create a network device for the discovered VLAN, and start the initiator:

   # fipvlan -s -c enp1s0
   Created VLAN device enp1s0.200
   Starting FCoE on interface enp1s0.200
   Fibre Channel Forwarders Discovered
   interface       | VLAN | FCF MAC
   ------------------------------------------
   enp1s0          | 200  | 00:53:00:a7:e7:1b

5. Optional: Display details about the discovered targets, the LUNs, and the devices associated with the LUNs:

   # fcoeadm -t
   Interface:        enp1s0.200
   Roles:            FCP Target
   Node Name:        0x500a0980824acd15
   Port Name:        0x500a0982824acd15
   Target ID:        0
   MaxFrameSize:     2048 bytes
   OS Device Name:   rport-11:0-1
   FC-ID (Port ID):  0xba00a0
   State:            Online
   
   LUN ID  Device Name   Capacity   Block Size  Description
   ------  -----------  ----------  ----------  ---------------------
        0  sdb           28.38 GiB      512     NETAPP LUN (rev 820a)
        ...

   This example shows that LUN 0 from the SAN has been attached to the host as the /dev/sdb device.

Prerequisites

1. You have installed the mt-st package. For more information, see Installing tape drive management tool.

2. Load the tape drive:

   # mt -f /dev/st0 load

Procedure

1. Check the tape head:

   # mt -f /dev/st0 status
   
   SCSI 2 tape drive:
   File number=-1, block number=-1, partition=0.
   Tape block size 0 bytes. Density code 0x0 (default).
   Soft error count since last status=0
   General status bits on (50000):
    DR_OPEN IM_REP_EN

   Here:

   • the current file number is -1.
   • the block number defines the tape head. By default, it is set to -1.
   • the block size 0 indicates that the tape device does not have a fixed block size.
   • the Soft error count indicates the number of encountered errors after executing the mt status command.
   • the General status bits explains the stats of the tape device.
   • DR_OPEN indicates that the door is open and the tape device is empty. IM_REP_EN is the immediate report mode.

2. If the tape device is not empty, overwrite it:

   # tar -czf /dev/st0 _/source/directory

   This command overwrites the data on a tape device with the content of /source/directory.

3. Back up the /source/directory to the tape device:

   # tar -czf /dev/st0 _/source/directory
   tar: Removing leading `/' from member names
   /source/directory
   /source/directory/man_db.conf
   /source/directory/DIR_COLORS
   /source/directory/rsyslog.conf
   [...]

4. View the status of the tape device:

   # mt -f /dev/st0  status

Prerequisites

1. You have installed the mt-st package. For more information, see Installing tape drive management tool.

2. Load the tape drive:

   # mt -f /dev/nst0 load

Procedure

1. Check the tape head of the non-rewinding tape device /dev/nst0:

   # mt -f /dev/nst0 status

2. Specify the pointer at the head or at the end of the tape:

   # mt -f /dev/nst0 rewind

3. Append the data on the tape device:

   # mt -f /dev/nst0 eod
   # tar -czf /dev/nst0 /source/directory/

4. Back up the /source/directory/ to the tape device:

   # tar -czf /dev/nst0 /source/directory/
   tar: Removing leading `/' from member names
   /source/directory/
   /source/directory/man_db.conf
   /source/directory/DIR_COLORS
   /source/directory/rsyslog.conf
   [...]

5. View the status of the tape device:

   # mt -f /dev/nst0  status

Prerequisites

1. You have installed the mt-st package. For more information, see Installing tape drive management tool.
2. Data is written to the tape device. Fore more information, see Writing to rewinding tape devices or Writing to non-rewinding tape devices.

Prerequisites

1. You have installed the mt-st package. For more information, see Installing tape drive management tool.
2. Data is written to the tape device. For more information, see Writing to rewinding tape devices or Writing to non-rewinding tape devices.

Prerequisites

1. You have installed the mt-st package. For more information, see Installing tape drive management tool.
2. Data is written to the tape device. For more information, see Writing to rewinding tape devices or Writing to non-rewinding tape devices.

Procedure

1. Erase data from the tape device:

   # mt -f /dev/st0 erase

2. Unload the tape device:

   mt -f /dev/st0 offline

Procedure

1. From the left pane of the Manual Partitioning window, select the required partition.
2. Under the Device(s) section, click Modify. The Configure Mount Point dialog box opens.
3. Select the disks that you want to include in the RAID device and click Select.
4. Click the Device Type drop-down menu and select RAID.
5. Click the File System drop-down menu and select your preferred file system type.
6. Click the RAID Level drop-down menu and select your preferred level of RAID.
7. Click Update Settings to save your changes.
8. Click Done to apply the settings to return to the Installation Summary window.

Procedure

1. Create a RAID of two block devices, for example /dev/sda1 and /dev/sdc1:

   # mdadm --create /dev/md0 --level=2 --raid-devices=2 /dev/sda1 /dev/sdc1
   mdadm: Defaulting to version 1.2 metadata
   mdadm: array /dev/md0 started.

   The level_value option defines the RAID level.

2. Optional: Check the status of the RAID:

   # mdadm --detail /dev/md0
   /dev/md0:
              Version : 1.2
        Creation Time : Thu Oct 13 15:17:39 2022
           Raid Level : raid0
           Array Size : 18649600 (17.79 GiB 19.10 GB)
         Raid Devices : 2
        Total Devices : 2
          Persistence : Superblock is persistent
   
          Update Time : Thu Oct 13 15:17:39 2022
                State : clean
       Active Devices : 2
      Working Devices : 2
       Failed Devices : 0
        Spare Devices : 0
   [...]

3. Optional: Observe the detailed information about each device in the RAID:

   # mdadm --examine /dev/sda1 /dev/sdc1
   /dev/sda1:
             Magic : a92b4efc
           Version : 1.2
       Feature Map : 0x1000
        Array UUID : 77ddfb0a:41529b0e:f2c5cde1:1d72ce2c
              Name : 0
     Creation Time : Thu Oct 13 15:17:39 2022
        Raid Level : raid0
      Raid Devices : 2
   [...]

4. Create a file system on the RAID drive:

   # mkfs -t xfs /dev/md0

   Replace xfs with the file system that you chose to format the drive with.

5. Create a mount point for RAID drive and mount it:

   # mkdir /mnt/raid1
   # mount /dev/md0 /mnt/raid1

   Replace /mnt/raid1 with the mount point.

   If you want that RHEL mounts the md0 RAID device automatically when the system boots, add an entry for your device to the /etc/fstab file:

   /dev/md0   /mnt/raid1 xfs  defaults   0 0

Procedure

1. Create a new playbook.yml file with the following content:

   ---
   - name: Configure the storage
     hosts: managed-node-01.example.com
     tasks:
     - name: Create a RAID on sdd, sde, sdf, and sdg
       include_role:
         name: rhel-system-roles.storage
       vars:
       storage_safe_mode: false
       storage_volumes:
         - name: data
           type: raid
           disks: [sdd, sde, sdf, sdg]
           raid_level: raid0
           raid_chunk_size: 32 KiB
           mount_point: /mnt/data
           state: present

   Warning

   Device names might change in certain circumstances, for example, when you add a new disk to a system. Therefore, to prevent data loss, do not use specific disk names in the playbook.

2. Optional: Verify the playbook syntax:

   # ansible-playbook --syntax-check playbook.yml

3. Run the playbook:

   # ansible-playbook -i inventory.file /path/to/file/playbook.yml

Procedure

1. Extend RAID partitions. For more information, see Resizing a partition with parted.

2. Extend RAID to the maximum of the partition capacity:

   # mdadm --grow --size=max /dev/md0

   To set a specific size, write the value of the --size parameter in kB, for example --size=524228.

3. Increase the size of file system. For example, if the volume uses XFS and is mounted to /mnt/, enter:

   # xfs_growfs /mnt/

Procedure

1. Shrink the file system. For more information, see Managing file systems.

2. Decrease the RAID to the size, for example to 512 MB:

   # mdadm --grow --size=524228 /dev/md0

   Write the --size parameter in kB.

3. Shrink the partition to the size you need.

Procedure

1. Convert the RAID /dev/md0 to RAID level 5:

   # mdadm --grow --level=5 -n 3 /dev/md0 --force

2. Add a new disk to the array:

   # mdadm --manage /dev/md0 --add /dev/sdd

Procedure

1. Copy the contents of the PowerPC Reference Platform (PReP) boot partition from /dev/sda1 to /dev/sdb1:

   # dd if=/dev/sda1 of=/dev/sdb1

2. Update the prep and boot flag on the first partition on both disks:

   $ parted /dev/sda set 1 prep on
   $ parted /dev/sda set 1 boot on
   
   $ parted /dev/sdb set 1 prep on
   $ parted /dev/sdb set 1 boot on

Procedure

1. Insert the install disk.
2. During the initial boot up, select Rescue Mode instead of Install or Upgrade. When the system fully boots into Rescue mode, you can see the command line terminal.

3. From this terminal, execute the following commands:

   1. Create RAID partitions on the target hard drives by using the parted command.
   2. Manually create raid arrays by using the mdadm command from those partitions using any and all settings and options available.
4. Optional: After creating arrays, create file systems on the arrays as well.
5. Reboot the computer and select Install or Upgrade to install. As the Anaconda installer searches the disks in the system, it finds the pre-existing RAID devices.
6. When asked about how to use the disks in the system, select Custom Layout and click Next. In the device listing, the pre-existing MD RAID devices are listed.
7. Select a RAID device and click Edit.
8. Configure its mount point and optionally the type of file system it should use if you did not create one earlier, and then click Done. Anaconda installs to this pre-existing RAID device, preserving the custom options you selected when you created it in Rescue Mode.

Procedure

1. Create the /etc/mdadm.conf configuration file for monitoring array by scanning the RAID details:

   # mdadm --detail --scan >> /etc/mdadm.conf

   Note, that ARRAY and MAILADDR are mandatory variables.

2. Open the /etc/mdadm.conf configuration file with a text editor of your choice and add the MAILADDR variable with the mail address for the notification. For example, add new line:

   MAILADDR example@example.com>

   Here, example@example.com is an email address to which you want to receive the alerts from the array monitoring.

3. Save changes in the /etc/mdadm.conf file and close it.

Procedure

1. Check the failed disk:

   1. View the kernel logs:

      # journalctl -k -f

   2. Search for a message similar to the following:

      md/raid:md0: Disk failure on sdd, disabling device.
      
      md/raid:md0: Operation continuing on 3 devices.

   3. Press Ctrl+C on your keyboard to exit the journalctl program.

2. Mark the failed disk as faulty:

   # mdadm --manage /dev/md0 --fail /dev/sdd

3. Optional: Check if the failed disk was marked correctly:

   # mdadm --detail /dev/md0

   At the end of the output is a list of disks in the /dev/md0 RAID where the disk /dev/sdd has the faulty status:

   Number   Major   Minor   RaidDevice State
      0       8       16        0      active sync   /dev/sdb
      1       8       32        1      active sync   /dev/sdc
      -       0        0        2      removed
      3       8       64        3      active sync   /dev/sde
   
      2       8       48        -      faulty   /dev/sdd

4. Remove the failed disk from the RAID:

   # mdadm --manage /dev/md0 --remove /dev/sdd

   Warning

   If your RAID cannot withstand another disk failure, do not remove any disk until the new disk has the active sync status. You can monitor the progress using the watch cat /proc/mdstat command.

5. Add the new disk to the RAID:

   # mdadm --manage /dev/md0 --add /dev/sdf

   The /dev/md0 RAID now includes the new disk /dev/sdf and the mdadm service will automatically starts copying data to it from other disks.

Procedure

1. Check the array for the failed disks behavior:

   # echo check > /sys/block/md0/md/sync_action

   This checks the array and the /sys/block/md0/md/sync_action file shows the sync action.

2. Open the /sys/block/md0/md/sync_action file with the text editor of your choice and see if there is any message about disk synchronization failures.
3. View the /sys/block/md0/md/mismatch_cnt file. If the mismatch_cnt parameter is not 0, it means that the RAID disks need repair.

4. Repair the disks in the array:

   # echo repair > /sys/block/md0/md/sync_action

   This repairs the disks in the array and writes the result into the /sys/block/md0/md/sync_action file.

5. View the synchronization progress:

   # cat /sys/block/md0/md/sync_action
   repair
   
   # cat /proc/mdstat
   Personalities : [raid0] [raid6] [raid5] [raid4] [raid1]
   md0 : active raid1 sdg[1] dm-3[0]
         511040 blocks super 1.2 [2/2] [UU]
   unused devices: <none>

1. Detect which NVDIMM device is failing
2. Back up data stored on it
3. Physically replace the device

Procedure

1. Detect the broken device:

   # ndctl list --dimms --regions --health
   {
     "dimms":[
       {
         "dev":"nmem1",
         "id":"8089-a2-1834-00001f13",
         "handle":17,
         "phys_id":32,
         "security":"disabled",
         "health":{
           "health_state":"ok",
           "temperature_celsius":35.0,
           [...]
         }
   [...]
   }

2. Find the phys_id attribute of the broken NVDIMM:

   # ndctl list --dimms --human

   From the previous example, you know that nmem0 is the broken NVDIMM. Therefore, find the phys_id attribute of nmem0.

   Example 17.7. The phys_id attributes of NVDIMMs

   In the following example, the phys_id is 0x10:

   # ndctl list --dimms --human
   
   [
     {
       "dev":"nmem1",
       "id":"XXXX-XX-XXXX-XXXXXXXX",
       "handle":"0x120",
       "phys_id":"0x1c"
     },
     {
       "dev":"nmem0",
       "id":"XXXX-XX-XXXX-XXXXXXXX",
       "handle":"0x20",
       "phys_id":"0x10",
       "flag_failed_flush":true,
       "flag_smart_event":true
     }
   ]

3. Find the memory slot of the broken NVDIMM:

   # dmidecode

   In the output, find the entry where the Handle identifier matches the phys_id attribute of the broken NVDIMM. The Locator field lists the memory slot used by the broken NVDIMM.

   Example 17.8. NVDIMM Memory Slot Listing

   In the following example, the nmem0 device matches the 0x0010 identifier and uses the DIMM-XXX-YYYY memory slot:

   # dmidecode
   
   ...
   Handle 0x0010, DMI type 17, 40 bytes
   Memory Device
           Array Handle: 0x0004
           Error Information Handle: Not Provided
           Total Width: 72 bits
           Data Width: 64 bits
           Size: 125 GB
           Form Factor: DIMM
           Set: 1
           Locator: DIMM-XXX-YYYY
           Bank Locator: Bank0
           Type: Other
           Type Detail: Non-Volatile Registered (Buffered)
   ...

4. Back up all data in the namespaces on the NVDIMM. If you do not back up the data before replacing the NVDIMM, the data will be lost when you remove the NVDIMM from your system.

   Warning

   In some cases, such as when the NVDIMM is completely broken, the backup might fail.

   To prevent this, regularly monitor your NVDIMM devices using S.M.A.R.T. as described in Monitoring NVDIMM health using S.M.A.R.T. and replace failing NVDIMMs before they break.

5. List the namespaces on the NVDIMM:

   # ndctl list --namespaces --dimm=DIMM-ID-number

   Example 17.9. NVDIMM namespaces listing

   In the following example, the nmem0 device contains the namespace0.0 and namespace0.2 namespaces, which you need to back up:

   # ndctl list --namespaces --dimm=0
   
   [
     {
       "dev":"namespace0.2",
       "mode":"sector",
       "size":67042312192,
       "uuid":"XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX",
       "raw_uuid":"XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX",
       "sector_size":4096,
       "blockdev":"pmem0.2s",
       "numa_node":0
     },
     {
       "dev":"namespace0.0",
       "mode":"sector",
       "size":67042312192,
       "uuid":"XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX",
       "raw_uuid":"XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX",
       "sector_size":4096,
       "blockdev":"pmem0s",
       "numa_node":0
     }
   ]

6. Replace the broken NVDIMM physically.

Procedure

1. Install packages that provide the Stratis service and command-line utilities:

   # dnf install stratisd stratis-cli

2. Make sure that the stratisd service is enabled:

   # systemctl enable --now stratisd

Procedure

1. Erase any file system, partition table, or RAID signatures that exist on each block device that you want to use in the Stratis pool:

   # wipefs --all block-device

   where block-device is the path to the block device; for example, /dev/sdb.

2. Create the new unencrypted Stratis pool on the selected block device:

   # stratis pool create my-pool block-device

   where block-device is the path to an empty or wiped block device.

   Note

   Specify multiple block devices on a single line:

   # stratis pool create my-pool block-device-1 block-device-2

3. Verify that the new Stratis pool was created:

   # stratis pool list

Procedure

1. Erase any file system, partition table, or RAID signatures that exist on each block device that you want to use in the Stratis pool:

   # wipefs --all block-device

   where block-device is the path to the block device; for example, /dev/sdb.

2. If you have not created a key set already, run the following command and follow the prompts to create a key set to use for the encryption.

   # stratis key set --capture-key key-description

   where key-description is a reference to the key that gets created in the kernel keyring.

3. Create the encrypted Stratis pool and specify the key description to use for the encryption. You can also specify the key path using the --keyfile-path option instead instead of using the key-description option.

   # stratis pool create --key-desc key-description my-pool block-device

   where

   key-description

   References the key that exists in the kernel keyring, which you created in the previous step.

   my-pool

   Specifies the name of the new Stratis pool.

   block-device

   Specifies the path to an empty or wiped block device.

   Note

   Specify multiple block devices on a single line:

   # stratis pool create --key-desc key-description my-pool block-device-1 block-device-2

4. Verify that the new Stratis pool was created:

   # stratis pool list

1. Create a pool from one or more block devices:

   # stratis pool create --no-overprovision pool-name /dev/sdb

   • By using the --no-overprovision option, the pool cannot allocate more logical space than actual available physical space.

2. Set overprovisioning mode in the existing pool:

   # stratis pool overprovision pool-name <yes|no>

   • If set to "yes", you enable overprovisioning to the pool. This means that the sum of the logical sizes of the Stratis filesystems, supported by the pool, can exceed the amount of available data space.

Verification

1. Run the following to view the full list of Stratis pools:

   # stratis pool list
   
   Name          Total Physical                    Properties     UUID                                   Alerts
   pool-name     1.42 TiB / 23.96 MiB / 1.42 TiB   ~Ca,~Cr,~Op    cb7cb4d8-9322-4ac4-a6fd-eb7ae9e1e540

2. Check if there is an indication of the pool overprovisioning mode flag in the stratis pool list output. The " ~ " is a math symbol for "NOT", so ~Op means no-overprovisioning.

3. Optional: Run the following to check overprovisioning on a specific pool:

   # stratis pool overprovision pool-name yes
   
   # stratis pool list
   
   Name          Total Physical                    Properties     UUID                                   Alerts
   pool-name     1.42 TiB / 23.96 MiB / 1.42 TiB   ~Ca,~Cr,~Op    cb7cb4d8-9322-4ac4-a6fd-eb7ae9e1e540

Procedure

1. Re-create the key set using the same key description that was used previously:

   # stratis key set --capture-key key-description

   where key-description references the key that exists in the kernel keyring, which was generated when you created the encrypted Stratis pool.

2. Unlock the Stratis pool and the block device that comprise it:

   # stratis pool unlock keyring

3. Verify that the Stratis pool is visible:

   # stratis pool list

Procedure

1. Unlock the Stratis pool and the block devices that comprise it:

   # stratis pool unlock clevis

2. Verify that the Stratis pool is visible:

   # stratis pool list

Procedure

1. To create a Stratis file system on a pool, use:

   # stratis filesystem create --size number-and-unit my-pool my-fs

   where

   number-and-unit

   Specifies the size of a file system. The specification format must follow the standard size specification format for input, that is B, KiB, MiB, GiB, TiB or PiB.

   my-pool

   Specifies the name of the Stratis pool.

   my-fs

   Specifies an arbitrary name for the file system.

   For example:

   Example 18.1. Creating a Stratis file system

   # stratis filesystem create --size 10GiB pool1 filesystem1

Procedure

1. Determine the UUID attribute of the file system:

   $ lsblk --output=UUID /dev/stratis/my-pool/my-fs

   For example:

   Example 18.2. Viewing the UUID of Stratis file system

   $ lsblk --output=UUID /dev/stratis/my-pool/fs1
   
   UUID
   a1f0b64a-4ebb-4d4e-9543-b1d79f600283

2. If the mount point directory does not exist, create it:

   # mkdir --parents mount-point

3. As root, edit the /etc/fstab file and add a line for the file system, identified by the UUID. Use xfs as the file system type and add the x-systemd.requires=stratisd.service option.

   For example:

   Example 18.3. The /fs1 mount point in /etc/fstab

   UUID=a1f0b64a-4ebb-4d4e-9543-b1d79f600283 /fs1 xfs defaults,x-systemd.requires=stratisd.service 0 0

4. Regenerate mount units so that your system registers the new configuration:

   # systemctl daemon-reload

5. Try mounting the file system to verify that the configuration works:

   # mount mount-point

Procedure