Category Archives: Storage

Linux: How to replace a bad disk on a Linux RAID configuration

Posted on by
Reply

Replacing a failed disk in a Linux RAID configuration involves several steps to ensure that the array remains operational and data integrity is maintained. Below is a step-by-step guide on how to replace a bad disk in a Linux RAID configuration using the mdadm utility:

  1. Identify the Failed Disk:
    • Use the mdadm --detail /dev/mdX command to display detailed information about the RAID array.
    • Look for the state of each device in the array to identify the failed disk.
    • Note the device name (e.g., /dev/sdX) of the failed disk.
  2. Prepare the New Disk:
    • Insert the new disk into the system and ensure it is recognized by the operating system.
    • Partition the new disk using a partitioning tool like fdisk or parted. Create a Linux RAID (type FD) partition on the new disk.
  3. Add the New Disk to the RAID Array:
    • Use the mdadm --manage /dev/mdX --add /dev/sdX1 command to add the new disk to the RAID array.
    • Replace /dev/mdX with the name of your RAID array and /dev/sdX1 with the partition name of the new disk.
    • This command starts the process of rebuilding the RAID array onto the new disk.
  4. Monitor the Rebuild Process:
    • Monitor the rebuild process using the mdadm --detail /dev/mdX command.
    • Check the progress and status of the rebuild operation to ensure it completes successfully.
    • The rebuild process may take some time depending on the size of the RAID array and the performance of the disks.
  5. Verify RAID Array Status:
    • After the rebuild process completes, verify the status of the RAID array using the mdadm --detail /dev/mdX command.
    • Ensure that all devices in the array are in the “active sync” state and that there are no errors or warnings.
  6. Update Configuration Files:
    • Update configuration files such as /etc/mdadm/mdadm.conf to ensure that the new disk is recognized and configured correctly in the RAID array.
  7. Perform Testing and Verification:
    • Perform thorough testing to ensure that the RAID array is functioning correctly and that data integrity is maintained.
    • Test read and write operations on the array to verify its performance and reliability.
  8. Optional: Remove the Failed Disk:
    • Once the rebuild process is complete and the RAID array is fully operational, you can optionally remove the failed disk from the array using the mdadm --manage /dev/mdX --remove /dev/sdX1 command.
    • This step is optional but can help clean up the configuration and remove any references to the failed disk.

By following these steps, you can safely replace a bad disk in a Linux RAID configuration using the mdadm utility while maintaining data integrity and ensuring the continued operation of the RAID array.

What is RAID and how do you configure it in Linux?

Posted on by
Reply

RAID (Redundant Array of Independent Disks) is a technology used to combine multiple physical disk drives into a single logical unit for data storage, with the goal of improving performance, reliability, or both. RAID arrays distribute data across multiple disks, providing redundancy and/or improved performance compared to a single disk.

There are several RAID levels, each with its own characteristics and benefits. Some common RAID levels include RAID 0, RAID 1, RAID 5, RAID 6, and RAID 10. Each RAID level uses a different method to distribute and protect data across the disks in the array.

Here’s a brief overview of some common RAID levels:

  1. RAID 0 (Striping):
    • RAID 0 offers improved performance by striping data across multiple disks without any redundancy.
    • It requires a minimum of two disks.
    • Data is distributed evenly across all disks in the array, which can improve read and write speeds.
    • However, there is no redundancy, so a single disk failure can result in data loss for the entire array.
  2. RAID 1 (Mirroring):
    • RAID 1 provides redundancy by mirroring data across multiple disks.
    • It requires a minimum of two disks.
    • Data written to one disk is simultaneously written to another disk, providing redundancy in case of disk failure.
    • RAID 1 offers excellent data protection but doesn’t provide any performance benefits compared to RAID 0.
  3. RAID 5 (Striping with Parity):
    • RAID 5 combines striping with parity data to provide both improved performance and redundancy.
    • It requires a minimum of three disks.
    • Data is striped across multiple disks, and parity information is distributed across all disks.
    • If one disk fails, data can be reconstructed using parity information stored on the remaining disks.
  4. RAID 6 (Striping with Dual Parity):
    • RAID 6 is similar to RAID 5 but includes an additional level of redundancy.
    • It requires a minimum of four disks.
    • RAID 6 can tolerate the failure of up to two disks simultaneously without data loss.
    • It provides higher fault tolerance than RAID 5 but may have slightly lower performance due to the additional parity calculations.
  5. RAID 10 (Striping and Mirroring):
    • RAID 10 combines striping and mirroring to provide both improved performance and redundancy.
    • It requires a minimum of four disks.
    • Data is striped across mirrored sets of disks, offering both performance and redundancy benefits of RAID 0 and RAID 1.

To configure RAID in Linux, you typically use software-based RAID management tools provided by the operating system. The most commonly used tool for configuring RAID in Linux is mdadm (Multiple Device Administration), which is a command-line utility for managing software RAID devices.

Here’s a basic outline of the steps to configure RAID using mdadm in Linux:

  1. Install mdadm (if not already installed):sudo apt-get install mdadm # For Debian/Ubuntu sudo yum install mdadm # For CentOS/RHEL
  2. Prepare the disks:
    • Ensure that the disks you plan to use for RAID are connected and recognized by the system.
    • Partition the disks using a partitioning tool like fdisk or parted. Create Linux RAID (type FD) partitions on each disk.
  3. Create RAID arrays:
    • Use the mdadm command to create RAID arrays based on the desired RAID level.
    • For example, to create a RAID 1 array with two disks (/dev/sda and /dev/sdb):sudo mdadm --create /dev/md0 --level=1 --raid-devices=2 /dev/sda1 /dev/sdb1
  4. Format and mount the RAID array:
    • Once the RAID array is created, format it with a filesystem of your choice (e.g., ext4) using the mkfs command.
    • Mount the RAID array to a mount point in the filesystem.
  5. Update configuration files:
    • Update configuration files such as /etc/mdadm/mdadm.conf to ensure that the RAID array configuration is persistent across reboots.
  6. Monitor and manage RAID arrays:
    • Use mdadm commands to monitor and manage RAID arrays, such as adding or removing disks, checking array status, and replacing failed disks.

These are general steps for configuring software RAID using mdadm in Linux. The exact commands and procedures may vary depending on the specific RAID level and configuration requirements. It’s essential to refer to the documentation and guides specific to your Linux distribution and RAID configuration.

Linux: Increasing the size of a file system on Linux

Posted on by
Reply

Increasing the size of a file system on Linux that is managed by Logical Volume Manager (LVM) involves several steps. Here’s a general guide assuming you’re working with an LVM-managed file system:

Steps to Increase File System Size Using LVM:

1. Check Current Disk Space:

df -h

2. Check LVM Configuration:

sudo vgdisplay # List volume groups sudo lvdisplay # List logical volumes

3. Extend the Logical Volume:

  • Identify the logical volume (LV) associated with the file system you want to extend.

sudo lvextend -l +100%FREE /dev/vg_name/lv_name

Replace vg_name with your volume group name and lv_name with your logical volume name.

4. Resize the File System:

  • Resize the file system to use the new space.
    • For ext4:bashCopy codesudo resize2fs /dev/vg_name/lv_name
    • For XFS:bashCopy codesudo xfs_growfs /mount_point

Replace /mount_point with the actual mount point of your file system.

5. Verify the Changes:

df -h

That’s it! You’ve successfully increased the size of your file system using LVM. Make sure to replace vg_name and lv_name with your specific volume group and logical volume names.

Example:

Let’s assume you have a volume group named vg_data and a logical volume named lv_data that you want to extend.

# Check current disk space df -h # Check LVM configuration sudo vgdisplay sudo lvdisplay # Extend the logical volume sudo lvextend -l +100%FREE /dev/vg_data/lv_data # Resize the ext4 file system sudo resize2fs /dev/vg_data/lv_data # Verify the changes df -h

Make sure to adapt the commands based on your specific volume group and logical volume names, as well as the file system type you are using. Always perform these operations with caution and have backups available, especially when dealing with critical data.

Linux: How to detect new Logical Unit Numbers (LUNs) on a Linux system

Posted on by
Reply

To detect new Logical Unit Numbers (LUNs) on a Linux system, you can use several methods depending on your storage configuration, including SCSI, Fibre Channel, or iSCSI. Here are the general steps to detect and configure new LUNs:

  1. Scan for New LUNs:
    • For SCSI Devices (e.g., SAS or SATA): Use the rescan-scsi-bus command to rescan the SCSI bus for new devices. You may need to install the sg3_utils package if it’s not already installed.bashCopy codesudo rescan-scsi-bus
    • For Fibre Channel Devices (FC): You can use the rescan-scsi-bus.sh script, which is often available on Linux systems for rescanning the SCSI bus. Run it with the -a flag to scan all HBAs (Host Bus Adapters) or specify the HBA number.sudo rescan-scsi-bus.sh -a
    • For iSCSI Devices: To detect new iSCSI LUNs, you need to rescan the iSCSI target. This typically involves using the iscsiadm command:sudo iscsiadm -m discovery -t st -p <target_IP_or_hostname> sudo iscsiadm -m node -L all
  2. Check for New Devices:After rescanning the bus or targets, you can check for the new devices that have been detected by examining the /sys/class/scsi_device/ directory. You can list the devices by running:bashCopy codels /sys/class/scsi_device/ Each subdirectory corresponds to a SCSI device.
  3. Rescan Partitions:If the newly detected devices include disk partitions, you should rescan the partitions to make them available. You can do this by running:partprobe
  4. Verify and Mount New LUNs:Once the new LUNs are detected, you should be able to use tools like lsblk, fdisk, or parted to verify the presence of new disks. For example:bashCopy codelsblk fdisk -l If you find new disks, you can create partitions and mount them as needed. Make sure to update your /etc/fstab file to ensure the mounts persist across reboots.
  5. Update Multipathing (if applicable):If you’re using multipathing for redundancy, you may need to update the multipath configuration to include the new LUNs. This typically involves editing the /etc/multipath.conf file and running multipath -v2 to refresh the multipath devices.
  6. Configure and Format:If the new LUNs are blank or need to be reformatted, use tools like mkfs to format them with the desired filesystem (e.g., ext4 or XFS).

Remember that detecting and configuring new LUNs may vary based on your specific storage and Linux distribution. Always consult your storage and system documentation for any distribution-specific steps or tools to use. Additionally, ensure you have backups and take precautions when making changes to storage configurations to prevent data loss.