Categoria: Howto

TrueNAS connessione a disco iSCSI

Ho un box TrueNAS con 4 dischi da 3TB in RaidZ ma si sa, lo spazio non è mai abbastanza. Non potendo aggiungere altri dischi all’interno dello stesso server ho allestito un secondo box, con altrettanti dischi da 3TB ed esportato un disco iSCSI che ho montato (via rete) sul primo server.

Vediamo come.

Per prima cosa creiamo un volume all’interno di un pool, in questo caso “targetDisk”.

Adesso dobbiamo condividere il volume attraverso l’iSCSI, quindi partiamo da “Sharing” -> “Block Shares (iSCSI)
Possiamo utilizzare il wizard, che ci aiuta a creare portale, iniziatore, target e extent:

La configurazione globale, da cui prendiamo il “Base Name“: “iqn.2005-10.org.freenas.ctl” (1)
Il portale con Group ID 1 e l’interfaccia (ip) su cui ascolta
Il gruppo di iniziatori, con le reti autorizzate a connettersi
Il Target, con il nome “targetDisk” che ci servirà tra poco
L’extent con il nome “targetdisk” (occhio che qui è tutto minuscolo)
Ed infine il target associato con nome “targetdisk” (2)

A questo punto è tutto ok, ricordiamoci di avviare la condivisione iSCSI dal pannello dei servizi.

Ci spostiamo sul nodo TrueNAS che deve importare il disco che abbiamo esportato sopra e ci connettiamo in SSH (oppure avviamo la Shell dal pannello web).
Dobbiamo creare (o modificare) il file /conf/base/etc/iscsi.conf così:

t0 {
  TargetAddress = 10.20.30.251
  TargetName = iqn.2005-10.org.freenas.ctl:targetdisk
}

In questo caso il TargetAddress è l’indirizzo del nodo che espone il disco iSCSI e il nome è composto dal BaseName del punto 1 e dal nome targetdisk, quello del target associato del punto 2, divisi da “:”
Dobbiamo anche modificare il file “/conf/base/etc/rc.conf” aggiungendo queste righe al termine del file:

iscsid_enable="YES"
iscsictl_enable="YES"
iscsictl_flags="-Aa"

Una ultima modifica al file “/conf/base/etc/ix.rc.d/ix-zfs” dove dobbiamo modificare la linea:

# REQUIRE: hostid mountcritlocal

con:

# REQUIRE: hostid mountcritlocal iscsictl

A questo punto possiamo riavviare il nodo e dovremmo trovare un nuovo disco “da0” tipo questo:

Possiamo aggiungere quindi un nuovo pool (Storage -> Pools) indicando il disco “da0” come unico membro del nuovo pool di nome “targetDisk“. La dashboard, adesso, ci permette di vedere entrambi i volumi:

Abbiamo un po’ più spazio.

Windows Server 2019 in dominio, icone di sistema sul desktop

Le classiche icone “Questo PC”, “Rete”, “Pannello di controllo” non possono essere visualizzate sul desktop di un Windows Server connesso ad un dominio da “Impostazioni” -> “Personalizzazione” -> “Temi” -> “Impostazioni delle icone del desktop“:

Per ovviare a questo problema, dato che le icone di sistema ci piacciono molto (siamo abituati così…) dobbiamo modificare una regola sui criteri di gruppo.

Eseguiamo “gpedit.msc” da start/esegui e scegliamo le opzioni:

Criteri Computer Locale” -> “Configurazione Computer” -> “Impostazioni di Windows” -> “Impostazioni di Sicurezza” -> “Criteri Locali” -> “Opzioni di Sicurezza“, fino ad arrivare all’opzione “Controllo account utente: modalità Approvazione amministratore per l’account amministratore predefinito

A questo punto dobbiamo impostare l’opzione ad “Attivato“:

Ecco fatto, un riavvio e possiamo attivare le nostre icone sul desktop:

Ottimo!

Rimuovere o modificare parte di nome su più file in bash

Una ricetta reve breve ma utile.

Dobbiamo rinominare una serie di file e rimuovere una parte del nome:

screenshot-primo.png
screenshot-secondo.png
screenshot-terzo.png
screenshot-quarto.png
screenshot-quinto.png

rimuoviamo una parte del nome (screenshot-) così:

for x in screenshot-*.png; do
echo $x | sed -r 's/screenshot-(.+)\.png/mv -v "\0" "\1.png"/';
done | sh -e

per tranquillità possiamo rimuovere l’ultima parte del comando (sh -e) per controllare quello che cerca di fare lo script.

se abbiamo, nel nome, anche una parte variabile da modificare possiamo utilizzare il carattere “.” per ogni lettera del nome.

Per esempio, per rinominare questi file:

100-immagini-primo.png
101-immagini-secondo.png
102-immagini-terzo.png
201-immagini-quarto.png
202-immagini-quinto.png

useremo questo script:

for x in *-immagini-*.png; do
echo $x | sed -r 's/...-immagini-(.+)\.png/mv -v "\0" "\1.png"/';
done | sh -e

fatto!

🙂

Da rete pubblica a privata

Dopo una installazione, dopo un riavvio o un cambio di switch il nostro caro Windows (10/11, server) si convince di essere connesso ad una rete pubblica.

Possiamo convertire la rete a cui è connesso il pc/server a rete privata in vari modi. Qui vediamo come farlo da powershell.

Apriamo una PowerShell con diritti di amministratore ed eseguiamo:

PS C:\Users\Administrator> Get-NetConnectionProfile

Name             : Network
InterfaceAlias   : Lan
InterfaceIndex   : 7
NetworkCategory  : Private
IPv4Connectivity : Internet
IPv6Connectivity : NoTraffic

Name             : Unidentified network
InterfaceAlias   : Lan10G
InterfaceIndex   : 11
NetworkCategory  : Public
IPv4Connectivity : NoTraffic
IPv6Connectivity : NoTraffic

Possiamo notare che la seconda rete in lista è una rete pubblica. L’interface Index è 11.

Adesso con il comando “Set-NetConnectionProfile” convertiamo la rete con indice 11 in privata:

PS C:\Users\Administrator> Set-NetConnectionProfile -InterfaceIndex 11 -NetworkCategory Private

Verifichiamo nuovamente lo stato delle reti

PS C:\Users\Administrator> Get-NetConnectionProfile

Name             : Network
InterfaceAlias   : Lan
InterfaceIndex   : 7
NetworkCategory  : Private
IPv4Connectivity : Internet
IPv6Connectivity : NoTraffic

Name             : Unidentified network
InterfaceAlias   : Lan10G
InterfaceIndex   : 11
NetworkCategory  : Private
IPv4Connectivity : NoTraffic
IPv6Connectivity : NoTraffic

Adesso, la rete con indice 11, è privata. Dannato Windows.

Non esagerate con i trucchetti

Greg writes:

Here’s a quick and clean way to swap data in place without having to resort to using a temporary memory location:

short *aPtr, *bPtr;

*aPtr ^= *bPtr;
*bPtr ^= *aPtr;
*aPtr ^= *bPtr;

While this is mathematically cool, lets take a look at the assembly code that it generates and see what’s really happening. First, for comparison, a couple of more pedestrian implementations:

void swap2(short *aPtr, short *bPtr) {
  short a = *aPtr; // a version with two temporaries
  short b = *bPtr;

  *aPtr = b;
  *bPtr = a;
}

void swap1(short *aPtr, short *bPtr) {
  short a = *aPtr; // a version with one temporary

  *aPtr = *bPtr;
  *bPtr = a;
}

void swap0(short *aPtr, short *bPtr) {
  *aPtr ^= *bPtr; // Greg’s tip
  *bPtr ^= *aPtr;
  *aPtr ^= *bPtr;
}

Now, let’s take a look at what the compiler actually generates for these functions. (I’m using CodeWarrior with all optimizations on for these examples.)

Recall that as processsors have gotten faster, memory has not. For instance 1/80ns (the speed on memory in most Macintoshes) = 12.5 MHz. This means that if adjacent instructions have to address memory with no intervening computation, it’s as if the processor has slowed to 12.5MHz.

First the 68K compiler, starting with the two temp case:

Name="swap2"(6) Size=26
  MOVEA.L $0004(A7),A1
  MOVEA.L $0008(A7),A0
  MOVE.W (A1),D0
  MOVE.W (A0),D1
  MOVE.W D1,(A1)
  MOVE.W D0,(A0)
  RTS

gnoring the two MOVEA.L’s which set up the address registers and the return, this takes four instructions, all of which touch memory. Notice, however that there are no cases where the result of an instruction is used an an input to the next instruction, meaning that most of the instructions can overlap in the processor pipeline.

Next with one temp:

Name="swap1"(4) Size=24
  MOVEA.L $0004(A7),A1
  MOVEA.L $0008(A7),A0
  MOVE.W (A1),D0
  MOVE.W (A0),(A1)
  MOVE.W D0,(A0)
  RTS

Here we have three instructions, all accessing memory and all can overlap. This is smaller than the example above. Whether it is faster depends on the relative timing of the MOVE.W (A0),(A1) instruction. (If anyone wants to time this, I’ll print the results.)

Now Greg’s ‘tip’:

Name="swap0"(1) Size=30
  MOVEA.L $0004(A7),A1
  MOVEA.L $0008(A7),A0
  MOVE.W (A0),D0
  EOR.W D0,(A1)
  MOVE.W (A1),D0
  EOR.W D0,(A0)
  MOVE.W (A0),D0
  EOR.W D0,(A1)
  RTS

This generates six instructions, all of which touch memory. Furthermore three of these are read-modify-write cycles, which are slower that a read or write and each instruction depends on the result of the instructon directly before it, meaning it won’t overlap in the pipeline, making this both the largest and slowest implementation of the three.

Now lets look at the PowerPC code:

Name=".swap2"(6) Size=20
  lha r0,0(r3)
  lha r5,0(r4)
  sth r5,0(r3)
  sth r0,0(r4)
  blr

Name=".swap1"(4) Size=20
  lha r5,0(r3)
  lha r0,0(r4)
  sth r0,0(r3)
  sth r5,0(r4)
  blr

Note that both of the versions with temporaries generated the same code (4 instructions, all touching memory but pipelineable). This is because RISC processors typically don’t have memory to memory operations; instead, they must move data to a register before operating on it.

Now our ‘tip’:

Name=".swap0"(1) Size=52
  lha r5,0(r4)
  lha r0,0(r3)
  xor r0,r0,r5
  sth r0,0(r3)
  lha r5,0(r3)
  lha r0,0(r4)
  xor r0,r0,r5
  sth r0,0(r4)
  lha r4,0(r4)
  lha r0,0(r3)
  xor r0,r0,r4
  sth r0,0(r3)
  blr

This implementation is by far the largest and slowest, generating 12 instructions, including 6 memory accesses. Furthermore there are 2 pipeline stalls. Clearly this implementation is the largest and slowest of all.

The moral of the story is: don’t get tricky. C programmers often try to minimize the number of lines of C in their program without consideration for what the compiler will generate. When in doubt, write clear code and give the optimizer a chance to maximize performance. Look at the compiler output. Your code will be easier to debug and probably faster too.

’Till next time

ESXi aggiornamento da linea di comando

Aggiorniamo il nostro server ESXi da linea di comando.

Ci connettiamo attraverso SSH al server (ssh root@esxi) e controlliamo la versione installata:

esxcli system version get
 Product: VMware ESXi
 Version: 6.5.0
 Build: Releasebuild-4887370
 Update: 0
 Patch: 9

a questo punto abilitiamo le connessioni in uscita http:

esxcli network firewall ruleset set -e true -r httpClient

e vediamo quali versioni sono disponibili per l’aggiornamento:

esxcli software sources profile list -d https://hostupdate.vmware.com/software/VUM/PRODUCTION/main/vmw-depot-index.xml | grep ESXi-6.5

ESXi-6.5.0-20170304101-no-tools VMware, Inc. PartnerSupported 2017-04-07T06:05:06 2017-04-07T06:05:06
ESXi-6.5.0-20170104001-no-tools VMware, Inc. PartnerSupported 2017-04-07T06:05:07 2017-04-07T06:05:07
ESXi-6.5.0-4564106-no-tools VMware, Inc. PartnerSupported 2016-10-27T05:43:44 2016-10-27T05:43:44
ESXi-6.5.0-20170304001-standard VMware, Inc. PartnerSupported 2017-04-07T06:05:06 2017-04-07T06:05:06
ESXi-6.5.0-20170301001s-no-tools VMware, Inc. PartnerSupported 2017-04-07T06:05:07 2017-04-07T06:05:07
ESXi-6.5.0-20170404001-standard VMware, Inc. PartnerSupported 2017-04-07T06:05:06 2017-04-07T06:05:06
ESXi-6.5.0-4564106-standard VMware, Inc. PartnerSupported 2016-10-27T05:43:44 2016-10-27T05:43:44
ESXi-6.5.0-20170404001-no-tools VMware, Inc. PartnerSupported 2017-04-07T06:05:06 2017-04-07T06:05:06
ESXi-6.5.0-20170304001-no-tools VMware, Inc. PartnerSupported 2017-04-07T06:05:07 2017-04-07T06:05:07
ESXi-6.5.0-20170104001-standard VMware, Inc. PartnerSupported 2017-04-07T06:05:07 2017-04-07T06:05:07
ESXi-6.5.0-20170301001s-standard VMware, Inc. PartnerSupported 2017-04-07T06:05:06 2017-04-07T06:05:06
ESXi-6.5.0-20170304101-standard VMware, Inc. PartnerSupported 2017-04-07T06:05:06 2017-04-07T06:05:06

La lista è limitata dal “grep ESXi-6.5” per essere un minimo più leggibile.

L’ultima versione disponibile è la “ESXi-6.5.0-20170404001-standard“.

La installiamo con il comando:

esxcli software profile update -d https://hostupdate.vmware.com/software/VUM/PRODUCTION/main/vmw-depot-index.xml -p ESXi-6.5.0-20170404001-standard

A questo punto è necessario un riavvio
Dopo il riavvio dell’host controlliamo la versione installa:

esxcli system version get
 Product: VMware ESXi
 Version: 6.5.0
 Build: Releasebuild-5310538
 Update: 0
 Patch: 19

🙂

ISC DHCP e log dei lease

Ecco come fare per loggare i client che richiedono un ip al nostro server dhcp in modo moooolto elegante!

nel file /etc/dhcp/dhcp.conf si aggiunge una direttiva come questa:

on commit {
  set ClientIP = binary-to-ascii(10, 8, ".", leased-address);
  set ClientMac = binary-to-ascii(16, 8, ":", substring(hardware, 1, 6));
  log(concat("Commit: IP: ", ClientIP, " Mac: ", ClientMac));
  execute("/root/scripts/dhcp-event", "commit", ClientIP, ClientMac);
}

e poi creiamo un semplice script (/root/scripts/dhcp-event):

#!/bin/bash
date=$(date)
echo "date: "$date >> /tmp/dhlog
echo "orig: "$1 >> /tmp/dhlog
echo " ip: "$2 >> /tmp/dhlog
echo " mac: "$3 >> /tmp/dhlog
a=$(host $2)
name=$(echo $a | cut -d" " -f5)
echo "name: "$name >> /tmp/dhlog

a questo punto è banale prendere questi dati e metterli su un database oppure generare la lista di conversione ip/nomi per sarg (così, tanto per fare un esempio…)

le direttive che possiamo usare (in modo pressochè identico) sono:

– on commit
– on release
– on expiry

🙂

a.

rList

rList è un progetto in linguaggio C per risolvere in modo elegante e diverso dal solito il classico problema delle liste di oggetti collegati.

rList fa uso di function-pointer e strutture dati per dare alla sintassi una struttura simile alla programmazione ad oggetti.

La definzione della lista è estremamente banale:

si include l’header:

#include "rList.h"

poi si definiscono struttura e nodi:

struct rList * list = NULL;
struct rNode * rn = NULL;

si inizializza la lista:

list = rListInit(0,0);

per aggiungere un nodo alla lista:

rn = list->AddNode(list);

per cancellare un nodo:

rn->Destroy(rn);

nella lista possono essere aggiunti nodi come abbiamo appena visto ma può anche essere utilizzato un id custom e, su ogni nodo, può essere collegata una struttura di memoria che la lista si occupa di deallocare alla distruzione di un nodo o della lista stessa.

La lista fornisce un token che può essere usato per scorrere la lista (in modo lineare o circolare) con semplici funzioni (tipo rn->TokenStep(rn))

rList si trova su SourceForge.net e può essere scaricata da qui!