Orkun Karaduman

How to reload all SCSI hosts and devices on Linux

2022-09-01T18:06:00+00:00

After inserted a new SCSI disk, you may need to scan disks on the SCSI host. On the other side; you grow the current disk, you may need to re-scan disk to show new size. Most of cloud providers do this using cloud agents. But there may be some cases where it doesn't work!

SCSI hosts

You can find SCSI hosts under /sys/class/scsi_host/.

ls -l /sys/class/scsi_host/

Example output is:

total 0
lrwxrwxrwx 1 root root 0 Sep 1 09:38 host0 -> ../../devices/pci0000:00/0000:00:04.0/virtio2/host0/scsi_host/host0
lrwxrwxrwx 1 root root 0 Sep 1 09:38 host1 -> ../../devices/pci0000:00/0000:00:01.1/ata1/host1/scsi_host/host1
lrwxrwxrwx 1 root root 0 Sep 1 09:38 host2 -> ../../devices/pci0000:00/0000:00:01.1/ata2/host2/scsi_host/host2

To scan example SCSI host which is host2:

echo "---" > "/sys/class/scsi_host/host2/scan"

SCSI devices

You can find SCSI devices under /sys/class/scsi_device/.

ls -l /sys/class/scsi_device/

Example output is:

total 0
lrwxrwxrwx 1 root root 0 Sep 1 09:38 0:0:0:0 -> ../../devices/pci0000:00/0000:00:04.0/virtio2/host0/target0:0:0/0:0:0:0/scsi_device/0:0:0:0

To re-scan example SCSI device which is 0:0:0:0 on host0:

echo 1 > "/sys/class/scsi_device/0:0:0:0/device/rescan"

SCSI disks

You can check whether your disk is under SCSI device:

ls -l /sys/block

Example output is:

total 0
lrwxrwxrwx 1 root root 0 Sep 12 09:38 sda -> ../devices/pci0000:00/0000:00:04.0/virtio2/host0/target0:0:0/0:0:0:0/block/sda

You can see the disk under SCSI devices.

Conclusion

The following script reloads all SCSI hosts and devices and also SCSI disks:

#! /usr/bin/env bash

for h in $(find /sys/class/scsi_host/ -mindepth 1 -maxdepth 1)
do
  echo "$h"
  echo "---" > "$h/scan"
done

for h in $(find /sys/class/scsi_device/ -mindepth 1 -maxdepth 1)
do
  echo "$h"
  echo 1 > "$h/device/rescan"
done

GRUB2 config make

2022-08-31T18:00:00+00:00

If you change grub parameters (example /etc/default/grub), you need to make GRUB2 configurations in /boot.

grub2-mkconfig -o /boot/grub2/grub.cfg

If your grub installed with EFI, you may need some configurations. Example for CentOS:

grub2-mkconfig -o /boot/grub2/grub.cfg
grub2-mkconfig -o /boot/efi/EFI/centos/grub.cfg
rm -f /boot/grub2/grubenv
ln -s ../efi/EFI/centos/grubenv /boot/grub2/grubenv

Advisory File locking with Go

2022-08-31T14:50:00+00:00

File Locking is generally useful in an environment where multiple applications or processes may want to access(read/write) the same file. In such cases, it becomes important to protect integrity of file data and provide consistent view of data to all the processes.

This post studies only advisory file locks with Go on Unix based systems such as Linux, FreeBSD.

Lock types

There are two types of locks:

Read or Shared locks
Write or Exclusive locks

Read or Shared locks

Multiple reader (processes, threads, goroutines, ...) can hold read locks on the same handler (such as file, programming object) unless any exclusive lock held.

This is like sync.RWMutex.RLock() in go.

Write or Exclusive locks

At a time only one writer can hold a write lock on the handler. So no other handler should be able to acquire a read or write lock on a handler already write locked by a different reader or writer.

This is like sync.RWMutex.Lock() in go.

Advisory File Locking

Advisory File Locking requires cooperation from all the involved processes. Once a process(say P1) has taken a read/shared lock on a file “F”, there is really nothing done by Operating System to prevent a process(say P2) from going ahead and issuing a write system call. As mentioned, this method requires the participating processes to obey some locking protocol/API and hence cooperate with each other. As long as these processes first make use of the provided locking protocol, and respect its result before issuing read or write system calls, advisory locking scheme is going to work.

There are two types of file locking in Unix based OSes.

BSD Lock (flock)
Posix Lock

BSD Lock (flock)

BSD locks are associated with individual file descriptors and not to processes. So, all the different file descriptors acquired by the process for a particular file are treated independently. For example, a process opens a file “F” and takes a write lock on it. It now opens the same file again, and gets another descriptor. Any lock attempt by the process on this file descriptor will result in a “Lock-Conflict” error.

flock is originally implemented in 4.2BSD Operating System. In Linux; since kernel 2.0, flock() is implemented as a system call in its own right rather than being emulated in the GNU C library as a call to fcntl(2). Locks set by flock system call are usually referred to as BSD locks. flock supports only advisory locking. Also, it does not provide byte-range locks, instead all locks are full-file locks.

import(
    "fmt"
    "os"
    "syscall"
)

func Lock(path string, exclusive bool) (f *os.File, err error) {
    f, err = os.OpenFile(path, os.O_WRONLY|os.O_CREATE, 0666)
    if err != nil {
        return nil, fmt.Errorf("open error: %w", err)
    }
    flags := syscall.LOCK_NB
    if exclusive {
        flags |= syscall.LOCK_EX
    } else {
        flags |= syscall.LOCK_SH
    }
    err = syscall.Flock(int(f.Fd()), flags)
    if err != nil {
        f.Close()
        if err != syscall.EWOULDBLOCK {
            return nil, fmt.Errorf("syscall error: %w", err)
        }
        return nil, nil
    }
    return
}

Posix lock

On most Unixes, advisory locking is the default scheme provided to applications.

Locks can be placed over file in two different forms:

Full-File locks are placed over the entire file. It implies that entire region starting from first byte offset to the largest byte offset of the file is locked by the process.
Byte-Range locks are placed over specific byte-offset ranges in the file.

fcntl system call is the most popular way of using advisory locks on Unix systems. By default, locks set by fcntl are advisory in nature. Locks set by fcntl system call are usually referred to as POSIX locks as it adheres to POSIX standards of file locking, and is available on most compliant operating systems.

import(
    "fmt"
    "os"
    "syscall"
)

func Lock(path string, exclusive bool) (f *os.File, err error) {
    locksMu.Lock()
    defer locksMu.Unlock()
    if _, ok := locks[path]; ok {
        return nil, nil
    }
    f, err = os.OpenFile(path, os.O_WRONLY|os.O_CREATE, 0666)
    if err != nil {
        return nil, fmt.Errorf("open error: %w", err)
    }
    typ := syscall.F_RDLCK
    if exclusive {}
        typ = syscall.F_WRLCK
    }
    flockT := &syscall.Flock_t{
        Type:   typ,
        Whence: 0,
        Start:  0,
        Len:    0,
    }
    err = syscall.FcntlFlock(f.Fd(), syscall.F_SETLK, flockT)
    if err != nil {
        f.Close()
        if err != syscall.EWOULDBLOCK {
            return nil, fmt.Errorf("syscall error: %w", err)
        }
        return nil, nil
    }
    locks[path] = f
    return
}

func Unlock(path string) {
    locksMu.Lock()
    defer locksMu.Unlock()
    if f, ok := locks[path]; ok {
        f.Close()
        delete(locks, path)
    }
}

var locks = make(map[string]*os.File)
var locksMu sync.Mutex

You can see the above example has an internal locking with locks map. Because posix locks don't lock the file descriptor as bsd locks. It locks processes against the file.

How to change root password of cloud image

2022-08-30T18:00:00+00:00

There are ways to manipulate cloud images. I'm going to prefer libguestfs to change root password.

Install libguestfs and tools:

yum install guestfs-tools
yum install libguestfs libguestfs-appliance libguestfs-xfs

Change root password, mymagicpass is clean password, mydisk.img is primary disk image:

LIBGUESTFS_BACKEND=direct virt-customize --root-password password:mymagicpass -a mydisk.img …

How to enable serial console

2022-08-29T18:00:00+00:00

We've been talking about cloud servers too much in recent years. How many of you remember the famous COM1, COM2 ports from old times? In this post, we are streaming console to serial ports again to access console from cloud providers.

On Linux

We just have to add this parameter to linux command line to redirect console to primary serial port ttyS0.

console=ttyS0,115200n8

We can add this parameter using GRUB, on boot (Ctrl-X) or permanently.

Edit /etc/default/grub. Example config from CentOS 9 Stream:

GRUB_TIMEOUT=1
GRUB_DISTRIBUTOR="$(sed 's, release .*$,,g' /etc/system-release)"
GRUB_DEFAULT=saved
GRUB_DISABLE_SUBMENU=true
GRUB_TERMINAL_OUTPUT="console"
GRUB_CMDLINE_LINUX="console=ttyS0,115200n8 no_timer_check net.ifnames=0 crashkernel=1G-4G:192M,4G-64G:256M,64G-:512M"
GRUB_DISABLE_RECOVERY="true"
GRUB_ENABLE_BLSCFG=true

Don't forget grub make config:

grub2-mkconfig -o /boot/grub2/grub.cfg

https://www.kernel.org/doc/html/v4.14/admin-guide/kernel-parameters.html

On FreeBSD

I just want to share this shell script about. Please review changed files after.

echo 'console="comconsole"' >> /boot/loader.conf
echo '-h' >> /boot.config
echo 'console "/usr/libexec/getty Pc" cons25 on secure' >>/etc/ttys