Support clang builds; fix the defects clang and its sanitizers exposed

Clang (22.1.8 on the host, 14.0.6 in the Debian VM) now builds the tree
warning-free with --enable-warnings, in-tree and out-of-tree, with -j, and
the full VM battery passes with CC=clang: 12/12. ASan/UBSan builds run the
real tool paths (mkfs, check, tune, resize, rollback save/restore/reject)
with halt_on_error and report zero errors. Documented in tests/vm/RESULTS.md;
the CI gained clang+warnings, out-of-tree and sanitizer jobs.

Fixes found by this work:

- reiserfscore/Makefile.am: reiserfs_err.c and reiserfs_err.h shared one
  recipe. With -j, make runs the recipe once per stale target, so two
  compile_et invocations race: one deletes reiserfs_err.c ("no input
  files") while another job compiles it. Attached the recipe to
  reiserfs_err.c only; reiserfs_err.h merely depends on it. Reproduced
  with clang+ASan, stable across 5 clang / 3 asan / 3 gcc parallel builds.

- reiserfscore/Makefile.am: the rule read the source-local
  reiserfs_err.et, so VPATH builds could not find it. Use $(srcdir)/.
  make distcheck now passes.

- reiserfscore/reiserfslib.c: reiserfs_close() did fsync(fs->fs_dev) after
  reiserfs_free() released fs -- a 4-byte heap-use-after-free, flagged
  exactly at reiserfslib.c:406/407 by ASan (found by clang+ASan; gcc never
  caught it because the freed heap usually still holds the old value).
  Moved fsync before the free; reiserfs_flush() has already written
  journal and dirty buffers at that point and free_buffers() never
  writes, so the ordering preserves durability semantics.

- fsck/semantic_check.c, fsck/semantic_rebuild.c: three %K arguments passed
  &tmp_deh->deh2_dir_id where a struct reiserfs_key * is expected. It
  printed the right values only because deh2_dir_id sits at offset 4 and
  the key is read from the pointer as if dir_id sat at offset 0. Build a
  proper local key with set_key_dirid()/set_key_objectid() (the same
  idiom debugreiserfs/scan.c already uses). Verified -Waddress-of-packed-
  member (clang-only) is gone and output is unchanged.

- reiserfscore/hashes.c: four unreachable *(int *)0 = 0 stores (guarded by
  len >= 16/12/8/4 tests that cannot hold after the while (len >= 16)
  loop, len <= 15). Removed; clang's -Wnull-dereference goes quiet.
  Behavior verified: keyed_hash/yura_hash/r5_hash outputs for 16 inputs
  from 0 to 17 bytes are byte-identical before and after.

run_in_vm.sh: propagate CC into the guest, force a remount of /mnt/data
(the host rewrites the backing file under the guest), exclude generated
reiserfs_err.[ch] from the source tar. run_tests.sh: report which compiler
the battery actually used.

tests/vm/README.md

@@ -27,7 +27,7 @@ do libvirt: a conectividade vem do backend `passt` em modo *user*.
 
 ```mermaid
 graph LR
-  H[host] -->|qemu:///session| D[rfs-debian<br/>Debian 12 · gcc]
+  H[host] -->|qemu:///session| D[rfs-debian<br/>Debian 12 · gcc + clang]
   H -->|qemu:///session| A[rfs-alpine<br/>Alpine 3.20 · gcc/musl]
   D -->|passt :2222| S[ssh opcional]
   A -->|passt| S
@@ -58,13 +58,34 @@ cd tests/vm
 ./setup_env.sh
 
 # 2. rodar a bateria em uma VM
-./run_in_vm.sh rfs-alpine
-./run_in_vm.sh rfs-debian
+./run_in_vm.sh rfs-debian              # gcc do guest
+CC=clang ./run_in_vm.sh rfs-debian     # clang do guest
+./run_in_vm.sh rfs-alpine              # esperado FALHAR no configure (musl)
 
 # 3. destruir tudo
 ./teardown_env.sh
 ```
 
+No Debian, instale o clang no guest uma vez (a rede user-mode do `passt`
+precisa de resolver manual antes do apt):
+
+```sh
+python3 guestcmd.py rfs-debian 'ip addr add 192.168.1.5/24 dev enp1s0;
+  ip link set enp1s0 up; ip route add default via 192.168.1.1;
+  echo nameserver 8.8.8.8 > /etc/resolv.conf;
+  apt-get update -qq && DEBIAN_FRONTEND=noninteractive \
+    apt-get install -y -qq clang'
+```
+
+## Compiladores suportados
+
+O projeto compila **sem warnings** com `-Wall -Wextra` em gcc (>= 12) e
+clang (>= 14; validado em 14.0.6 e 22.1.8). Os mesmos builds são exercitados
+sob **AddressSanitizer + UndefinedBehaviorSanitizer** (`CC=clang
+CFLAGS="-g -O1 -fsanitize=address,undefined ..."`) tanto no host (CI) quanto
+manualmente; resultados em `RESULTS.md`.
+
+
 ## O que a bateria cobre (`tests/vm/run_tests.sh`)
 
 Executado **dentro** do guest, sobre o código extraído do `vdb`:

tests/vm/RESULTS.md

@@ -99,6 +99,72 @@ Em `fsck/semantic_rebuild.c` o caminho equivalente é seguro: o bloco
 (linhas 808–822), então `new_ih` é escrito antes do `case RELOCATED:`
 (linha 999).
 
+## Validação com clang
+
+Ferramentaria: Fedora 44 (host) com **clang 22.1.8**, Debian 12 na VM com
+**clang 14.0.6**. Todos os builds abaixo usam `--enable-warnings`
+(-Wall -Wextra).
+
+| Build | Resultado |
+|---|---|
+| host clang in-tree, -j | 0/5 falhas, **0 warnings** |
+| host clang out-of-tree, -j | passa, 0 warnings |
+| host clang + ASan/UBSan out-of-tree, -j | 0/3 falhas, 0 warnings |
+| host gcc out-of-tree, -j | 3/3 limpo |
+| host `make distcheck` | passa (VPATH + install/uninstall + tarballs) |
+| VM Debian clang 14.0.6, bateria completa | **12/12, 0 warnings** |
+
+### O que clang expôs (e foi corrigido)
+
+1. **Corrida de build paralela em `compile_et`** (`reiserfscore/Makefile.am`):
+   `reiserfs_err.c` e `reiserfs_err.h` eram alvos de UMA mesma receita; com
+   `-j` o make executa a receita duas vezes em paralelo e um processo apaga
+   o `.c` enquanto o outro compila → `clang: error: no input files`.
+   Reproduzido com clang+ASan; a correção vale para qualquer compilador.
+   A receita ficou atrelada apenas a `reiserfs_err.c`, e
+   `reiserfs_err.h: reiserfs_err.c` apenas ordena os dois. 5/5 builds
+   paralelos limpos após a correção.
+
+2. **Build out-of-tree quebrado** (pré-existente, também com gcc): a regra
+   referenciava `reiserfs_err.et` sem `$(srcdir)/`. Corrigido junto.
+
+3. **`-Waddress-of-packed-member`** (só o clang aponta; 3 sítios):
+   `fsck/semantic_check.c` e `fsck/semantic_rebuild.c` passavam
+   `&tmp_deh->deh2_dir_id` como argumento `%K`, que espera
+   `struct reiserfs_key *`. Funcionava por coincidência de offsets
+   (`deh2_dir_id` em 4 lido como `k2_dir_id` em 0 do cast). Agora montam uma
+   `reiserfs_key` local via `set_key_dirid`/`set_key_objectid` — saída
+   idêntica, sem depender de coincidência.
+
+4. **`-Wnull-dereference` em `reiserfscore/hashes.c`**: quatro stores mortos
+   `*(int *)0 = 0` protegidos por condições inalcançáveis (após o loop
+   `while (len >= 16)`, `len <= 15`; os ramos testavam `len >= 16/12/8/4`).
+   Removidos. Comportamento verificado: saída de `keyed_hash`, `yura_hash` e
+   `r5_hash` para 16 entradas (vazio a 17 bytes) **byte a byte idêntica**
+   antes e depois (diff vazio).
+
+5. **heap-use-after-free real, encontrado por ASan com clang**:
+   `reiserfs_close()` chamava `fsync(fs->fs_dev)` DEPOIS de
+   `reiserfs_free()`, que libera o `fs` — leitura pendente de 4 bytes em
+   memória libertada (o ASan apontou exatamente `reiserfslib.c:406/407`; o
+   gcc nunca acusou porque o heap ainda "devolve" o valor velho). Corrigido
+   movendo o `fsync` para antes do free — a escrita já está no dispositivo
+   neste ponto (`reiserfs_flush()` despeja journal e buffers; os
+   `free_buffers()` de `reiserfs_free()` apenas validam e libertam, sem
+   escrever). Revalidado com ASan+UBSan em `halt_on_error`: mkfs, check,
+   tune, debugreiserfs, resize 64→128 MiB e rollback completo — **zero
+   erros**; bateria completa no host gcc continua 12/12.
+
+### Não-bugs registrados
+
+- LeakSanitizer: 136 bytes, 1 alocação em `debugreiserfs` (`getmem` no
+  `main`, de vida de processo; o `exit` recolhe). Aceitável para
+  ferramenta one-shot; por isso o job de CI com sanitizadores roda com
+  `detect_leaks=0`.
+- `AddressSanitizer: WARNING: unexpected format specifier ... %U`: o
+  interceptor do ASan não conhece os especificadores customizados do
+  projeto. Informativo, uma vez por processo.
+
 ## Achado 3: limitação do ambiente (não do código)
 
 Nas imagens cloud o `cloud-init` não aplicou a senha do usuário: o datasource
@@ -116,9 +182,14 @@ resolver manualmente para instalar pacotes nas VMs.
 ```sh
 cd tests/vm
 ./setup_env.sh                 # imagens + VMs (uma vez)
-./run_in_vm.sh rfs-debian      # build + bateria completa
+./run_in_vm.sh rfs-debian      # gcc: build + bateria completa
+CC=clang ./run_in_vm.sh rfs-debian   # clang no guest (instalar antes: ver README)
 ./run_in_vm.sh rfs-alpine      # deve falhar no configure (esperado)
 ./teardown_env.sh
+
+# host: builds paralelos in-tree e out-of-tree, distcheck
+make distcheck
+CC=clang ./configure --enable-warnings && make -j"$(nproc)"
 ```
 
 Detalhes do ambiente, topologia e limitações: `tests/vm/README.md`.

tests/vm/run_in_vm.sh

@@ -2,7 +2,8 @@
 # Envia o codigo-fonte e o script de teste para dentro de uma VM e executa.
 #
 # Uso: run_in_vm.sh <dominio>
-# Requer: guestcmd.py (mesmo diretorio), mkisofs, libvirt.
+#      CC=clang run_in_vm.sh rfs-debian    # build no guest com clang
+# Requer: guestcmd.py (mesmo diretorio), mkisofs, libvirt, sudo (loop mount).
 set -e
 
 DOMAIN=${1:?uso: run_in_vm.sh <dominio>}
@@ -17,13 +18,16 @@ tar czf "$WORK/rfs-src.tar.gz" -C "$REPO" \
     --exclude=autom4te.cache --exclude=config.h --exclude=config.log \
     --exclude=config.status --exclude=libtool \
     --exclude='Makefile' --exclude='Makefile.in' --exclude=configure \
-    --exclude=aclocal.m4 --exclude='*.8' \
+    --exclude=aclocal.m4 --exclude='*.8' --exclude=stamp-h1 \
+    --exclude='reiserfscore/reiserfs_err.c' \
+    --exclude='reiserfscore/reiserfs_err.h' \
     .
 
 echo "== montando o disco de dados =="
 rm -rf /tmp/vmdata.$$ && mkdir -p /tmp/vmdata.$$
 sudo mount -o loop "$WORK/data.img" /tmp/vmdata.$$
 sudo cp "$WORK/rfs-src.tar.gz" "$HERE/run_tests.sh" /tmp/vmdata.$$
+sync
 sudo umount /tmp/vmdata.$$ && rmdir /tmp/vmdata.$$
 
 echo "== transferindo para $DOMAIN =="
@@ -38,14 +42,17 @@ EOF
 virsh attach-device "$DOMAIN" "$ATTACH" --live >/dev/null 2>&1 || true
 rm -f "$ATTACH"
 
-echo "== extraindo e rodando os testes =="
-"$HERE/guestcmd.py" "$DOMAIN" '
+echo "== extraindo e rodando os testes ${CC:+com CC=$CC} =="
+"$HERE/guestcmd.py" "$DOMAIN" "
 set -e
 mkdir -p /mnt/data
-mountpoint -q /mnt/data || mount -o ro /dev/vdb /mnt/data
+# remount forcado: o host trocou o conteudo do disco por baixo do guest
+umount /mnt/data 2>/dev/null || true
+mount -o ro /dev/vdb /mnt/data
+rm -rf /root/rfs
 mkdir -p /root/rfs
 tar xzf /mnt/data/rfs-src.tar.gz -C /root/rfs
 cp /mnt/data/run_tests.sh /root/run_tests.sh
 chmod +x /root/run_tests.sh
-SRC=/root/rfs sh /root/run_tests.sh
-' 900
+SRC=/root/rfs ${CC:+CC=$CC }sh /root/run_tests.sh
+" 1800

tests/vm/run_tests.sh

@@ -16,7 +16,8 @@ cd "$SRC" || { echo "FAIL: $SRC nao existe"; exit 1; }
 
 echo "=== ambiente ==="
 uname -srm
-(cc --version 2>/dev/null || echo "sem cc") | head -1
+echo "CC=${CC:-cc}"
+${CC:-cc} --version 2>/dev/null | head -1 || echo "sem ${CC:-cc}"
 ldd --version 2>&1 | head -1
 
 echo