You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

10 KiB

Raw Blame History

Some random and useful recipes

Take a HDMI screenshot via console on Pi-KVM

# curl --unix-socket /run/kvmd/ustreamer.sock http://localhost/snapshot -o screen.jpg

Get installed KVMD version via console

# pacman -Q | grep kvmd

Upload .ISO images manually

Specifically to v2.

Remount internal storage to rw (read-write):
```
# kvmd-helper-otgmsd-remount rw
```
Upload the .ISO image(s) to /var/lib/kvmd/msd/images via scp or similar.
Create an empty file in /var/lib/kvmd/msd/meta/ with the exact name (case sensitive!) of the uploaded image. This will indicate Pi-KVM that the uploaded image is okay and can be used. For example:
```
/var/lib/kvmd/msd/meta/ubuntu-18.04.4-desktop-amd64.iso.complete
```
Remount internal storage back to ro (read-only):
```
# kvmd-helper-otgmsd-remount ro
```

Enable Serial-over-USB connection

Specifically to v2. This can be used for terminal access from the managed server to the Pi-KVM, or for any other purpose that requires a serial connection. In the last case, you only need to perform step 1 and reboot.

Edit /etc/kvmd/override.yaml (remove {} if this your first configuration entry) and add these lines:
```
otg:
    devices:
        serial:
            enabled: true
```
Run the following command:
```
# echo ttyGS0 >> /etc/securetty
```
Create the directory /etc/systemd/system/getty@ttyGS0.service.d and add a file file named ttyGS0.override into it. Afterwards edit the file and copy this into it:
```
[Service]
TTYReset=no
TTYVHangup=no
TTYVTDisallocate=no
```

Run these comands:

# systemctl enable getty@ttyGS0.service
# reboot

Once Pi-KVM is rebooted you will have access to a virtual serial port on the server that the USB is connected to. Use mingetty, screen, putty, or something like this to access the kvm from the server. The port is called /dev/ttyAMA0.

Enable Ethernet-over-USB network

Specifically to v2. When combined with configuring a DNS server, FTP, or SMB (for example), this is a powerful way to extend the capabilities of Pi-KVM.

Edit /etc/kvmd/override.yaml (remove {} if this your first configuration entry) and add these lines:
```
otg:
    devices:
        ethernet:
            enabled: true
            driver: ecm
            host_mac: 48:6f:73:74:50:43
            kvm_mac: 42:61:64:55:53:42
```
The host_mac address will be used on the server's network interface. The kvm_mac means the address that will be assigned to the local interface on the Pi-KVM. The KVM interface will be called usb0.r's network interface. If the host_mac or kvm_mac is not specified, a random value will be used. The driver parameter means the protocol that will be used for the USB network. The default value is ecm so it can be passed it this example. Other possible values are eem, ncm and rndis.
To automatically configure the USB network on the server recommended using the service kvmd-otgnet. It configures the firewall, assigns an address to the local Pi-KVM interface usb0 and starts DHCP so the managed server can get the IPv4 address. By default, the address 169.254.0.1/28 to interface usb0 will be assigned. One of the other addresses from the network 169.254.0.0./28 will be assigned to the server when it requests it via DHCP. For security reasons, all incoming connections from the server to the Pi-KVM side are blocked (except for ICMP and UDP port 67 which is used for DHCP). If you want to allow access from the server to the Pi-KVM interface, then you need to add ports 80 and 443 to the whitelist using /etc/kvmd/override.yaml file like this:
```
otgnet:
    firewall:
        allow_tcp: [80, 443]
```
To view other available configuration parameters, use the command kvmd -m.
To enable the service, use the command systemctl enable kvmd-otgnet.
Perform reboot.

❗ The USB-Ethernet features are experimental, so some of the default settings may be changed in future releases.

Mass Storage Drives

Specifically to v2. Unless explicitly disabled by default, Pi-KVM creates only one drive for Mass Storage emulation. However, you can create additional drives and manage them manually via the terminal. This is useful if you want to boot the server from a ISO CD (specified in the web interface), then connect a virtual flash drive to the server and download some files from to Pi-KVM from it.

❗ The presence of an additional Mass Storage device should not interfere with the boot, but for reasons of compatibility paranoia, this is disabled by default. We recommend setting up the drives in advance, making sure that booting from the ISO CD is still working, and then using the drives as needed.

How to enable extra drives:

Switch the root filesystem to rw mode.

Edit /etc/kvmd/override.yaml (remove {} if this your first configuration entry) and add these lines:

otg:
    devices:
        drives:
            enabled: true  # Set it to true to enable
            count: 1  # +1 drive, default value
            default:  # Default configuration for the all extra drives
                cdrom: false  # Defaut value (false for the generic flash drive)
                rw: false # Read-only by default

If you specify count: N, you will create N additional drives configured the same way, as described in the default section.

Reboot.

How to create RW flash drive:

Switch the root filesystem to rw mode:
```
# rw
```
Create the empty image file of the desire size (1Gb in this example.
```
# dd if=/dev/zero of=/root/flash.img bs=1024
```
Connect it to the drive 1:
```
# kvmd-otgmsd -i 1 --set-rw=1 --set-cdrom=0 --set-image=/root/flash.img
```
After that you will have access to the flash drive from the server.
❗ Drive 0 represents a drive that is controlled via a web interface and API. Don't use it with kvmd-otgmsd if you don't know exactly what you're doing.

View the driver state:

# kvmd-otgmsd -i 1
Image file:  /root/flash.img
CD-ROM flag: no
RW flag:     yes

To disable the flash drive and view the files on it from the KVM, run:
```
# kvmd-otgmsd -i 1 --unlock --eject
```
❗ This command will interrupt the current IO operation on ALL DRIVES including the one that is managed via the web interface. The same result is achieved by clicking the disable media button in the web interface. Right now, the Linux kernel does not allow to distinguish between internal threads that manage different drives. It is recommended to eject the media when you know that this will not cause problems for the other media.
Don't forget to remount the root filesystem to read-only mode:
```
# ro
```
You can download the resulting image via SCP or mount it as a loop device on the Pi-KVM.

Disable mass storage emulation

To disable mass storage emulation altogether, you can place the following piece of configuration into /etc/kvmd/override.yaml

    kvmd:
        msd:
            type:  disabled

Create a Microsoft Windows based Flash disk image

This procedure will create a disk image of a USB stick. This is mostly required for Microsoft Windows (TM) based images since they are larger than the CDROM based limit of 2.2GB. You can create a bootable USB stick with the normal Microsoft tools, e.g. Media Creation Tool. Creating a bootable USB stick can also be made from an ISO file with other tools like Rufus.

Without resizing, the full size of the USB stick will be used, so keep the stick as small as possible (e.g. 4GB or 8GB) but still large enough for all Windows files. The Media Creation tool will tell you what the minum size is.

Before creating the image file, you can use a tool like "EaseUS Partition Master Free" or "GParted" to resize the main FAT32 partition on the USB stick. This will save space on PiKVM.

You can also perform these steps on a separate unix machine and transfer the image over to pikvm with e.g. SCP. Or, on Windows you could use a program like PassMark ImageUSB (only for full USB size images) or 'dd' for Windows to create the image. Then use WinSCP to tranfer the image over to PiKVM.

Once you have the desired USB stick perform the following on the RPi to create the image directly to the PiKVM image storage folder.

Insert Windows based USB stick into Pi4, generated with Microsoft USB creation tool. SSH to PiKVM as root.

# dmesg
[ 3025.025401] usb-storage 2-1:1.0: USB Mass Storage device detected
[ 3025.038911] scsi host0: usb-storage 2-1:1.0
[ 3026.132248] scsi 0:0:0:0: Direct-Access     Kingston DataTraveler 3.0 PMAP PQ: 0 ANSI: 6
[ 3026.771425] sd 0:0:0:0: [sda] 15360000 512-byte logical blocks: (7.86 GB/7.32 GiB)
[ 3026.790276] sd 0:0:0:0: [sda] Write Protect is off
[ 3026.802530] sd 0:0:0:0: [sda] Mode Sense: 23 00 00 00
[ 3026.804450] sd 0:0:0:0: [sda] No Caching mode page found
[ 3026.814082] sd 0:0:0:0: [sda] Assuming drive cache: write through
[ 3026.908712]  sda: sda1
[ 3026.922794] sd 0:0:0:0: [sda] Attached SCSI removable disk
[root@pikvm ~]#

USB devices shows as "sda". We will use "sda1" as the Microsoft Windows (TM) partition.

mount msd folder as read/write
```
# kvmd-helper-otgmsd-remount rw
```

Create image of USB data PARTITION to an image file, this will take some time, in this case about 12 minutes (RPi4).

# dd if=/dev/sda1 of=/var/lib/kvmd/msd/images/windows10-2004.bin bs=8M status=progress
4458545152 bytes (4.5 GB, 4.2 GiB) copied, 736 s, 6.1 MB/s
531+1 records in
531+1 records out
4458545152 bytes (4.5 GB, 4.2 GiB) copied, 736.213 s, 6.1 MB/s

Correct ownership of new image and make sure the website reports the file as complete (pay attention to the different folder).
```
# chown kvmd:kvmd /var/lib/kvmd/msd/images/windows10-2004.bin
# touch /var/lib/kvmd/msd/meta/windows10-2004.bin.complete
```
Remount msd folder as read only
```
# kvmd-helper-otgmsd-remount ro
```
On PiKVM webpage, under Storage select the new image and connect it in Drive Mode: Flash to the server.

Boot the server and select boot device like you normally would. E.g. in a AMI BIOS the boot device is called "Linux File-CD Gadget 0504".

10 KiB Raw Blame History