publish: FreeDOS

This commit is contained in:
Cédrix
2026-05-16 23:59:22 +02:00
parent 64f7a9a25e
commit ba5b9ed308
5 changed files with 713 additions and 715 deletions
@@ -1,17 +0,0 @@
{
"title": "FreeDOS",
"_updated_at": "2026-05-16 21:59:18",
"slug": "freedos",
"published": true,
"published_at": "2023-02-28 20:54",
"category": "Informatique",
"tags": {
"tags": [
"FreeDOS",
"QEMU",
"VirtualBox"
]
},
"seo_title": "",
"seo_description": "FreeDOS est un système d'exploitation libre et open source compatible avec MS-DOS. Il permet d'exécuter de vieux programmes et jeux des années 80-90 sur du matériel moderne ou dans une machine virtuel"
}
@@ -1,675 +0,0 @@
# FreeDOS
FreeDOS est un système d'exploitation libre et open source compatible avec MS-DOS. Il permet d'exécuter de vieux programmes et jeux des années 80-90 sur du matériel moderne ou dans une machine virtuelle. Distribué sous licence GPL, il est entièrement gratuit et activement maintenu par sa communauté.
**Cas d'usage typiques :**
- Faire tourner d'anciens jeux DOS (Doom, Commander Keen, etc.)
- Exécuter des logiciels professionnels legacy (comptabilité, CAO ancienne)
- Flasher un BIOS depuis un environnement DOS
- Apprendre l'histoire de l'informatique
---
# Installer FreeDOS dans une machine virtuelle sous Linux
L'approche en VM est de loin la plus pratique : pas de risque pour ton système, snapshots possibles, et configuration matérielle reproductible. Voici la méthode avec **QEMU/KVM** (natif Linux, léger) et **VirtualBox** (plus visuel).
## Prérequis communs
Télécharge l'image ISO sur le site officiel : https://www.freedos.org/download/ (choisis le **LiveCD** ou **FullUSB** au format `.iso`).
## Méthode 1 — QEMU (recommandée sous Linux)
Installation des paquets selon ta distribution :
```bash
# Debian / Ubuntu
sudo apt install qemu-system-x86 qemu-utils
# Fedora
sudo dnf install qemu-system-x86 qemu-img
# Arch
sudo pacman -S qemu-full
```
Crée un disque dur virtuel de 2 Go (largement suffisant pour DOS) :
```bash
qemu-img create -f qcow2 freedos.qcow2 2G
```
Démarre l'installation depuis l'ISO :
```bash
qemu-system-i386 \
-m 64 \
-hda freedos.qcow2 \
-cdrom FD13LIVE.iso \
-boot d
```
Une fois FreeDOS installé sur le disque virtuel, démarre directement dessus :
```bash
qemu-system-i386 -m 64 -hda freedos.qcow2 -boot c
```
> 64 Mo de RAM (`-m 64`) suffisent largement — DOS n'utilise nativement que 640 Ko de mémoire conventionnelle.
## Méthode 2 — VirtualBox
```bash
sudo apt install virtualbox # Debian/Ubuntu
```
1. **Nouvelle machine** → Type : *Other*, Version : *DOS*
2. RAM : 64 Mo, Disque dur : 2 Go (VDI, dynamiquement alloué)
3. Dans les **paramètres** de la VM → *Stockage* → ajoute l'ISO de FreeDOS au lecteur optique
4. Démarre la VM et suis l'installateur de FreeDOS
---
# Monter des images de disquettes
Très utile pour faire tourner des vieux logiciels distribués en `.img` ou `.ima`.
## Avec QEMU
Ajoute simplement l'option `-fda` (floppy A:) au lancement :
```bash
qemu-system-i386 -m 64 -hda freedos.qcow2 -fda jeu.img -boot c
```
Dans FreeDOS, le contenu sera accessible via `A:`. Tu peux aussi monter deux disquettes simultanément avec `-fda` et `-fdb`.
## Avec VirtualBox
Dans *Paramètres → Stockage* :
1. Ajoute un contrôleur **Floppy** s'il n'existe pas
2. Attache ton fichier `.img` ou `.ima` comme lecteur de disquette
## Inspecter une image disquette directement sous Linux
Tu peux lire le contenu d'une image avant même de la monter dans la VM :
```bash
# Monter en lecture seule sur Linux hôte
sudo mkdir /mnt/floppy
sudo mount -o loop,ro disquette.img /mnt/floppy
ls /mnt/floppy
sudo umount /mnt/floppy
```
Pour créer une image de disquette vierge formatée FAT12 :
```bash
dd if=/dev/zero of=vierge.img bs=512 count=2880 # 1.44 Mo
mkfs.fat -F 12 vierge.img
```
---
# Partager un dossier entre Linux et FreeDOS
C'est le point souvent bloquant : DOS ne connaît ni les partages réseau modernes, ni les Guest Additions. Voici trois approches qui fonctionnent.
## Solution 1 — Image disque partagée (la plus simple avec QEMU)
Crée une image FAT que tu peux monter alternativement sous Linux et sous DOS :
```bash
# Créer une image de 100 Mo formatée FAT16
dd if=/dev/zero of=partage.img bs=1M count=100
mkfs.fat -F 16 partage.img
```
Côté Linux, pour y déposer des fichiers :
```bash
sudo mount -o loop partage.img /mnt/partage
sudo cp mon_programme.exe /mnt/partage/
sudo umount /mnt/partage
```
Côté QEMU, attache-la comme second disque :
```bash
qemu-system-i386 -m 64 -hda freedos.qcow2 -hdb partage.img -boot c
```
Dans FreeDOS, elle apparaîtra en `D:`.
> ⚠️ Évite d'écrire des deux côtés en même temps — démonte toujours du côté Linux avant de lancer la VM.
## Solution 2 — Dossier partagé via QEMU `-drive` avec VVFAT
QEMU peut exposer un dossier Linux comme un disque FAT virtuel, sans avoir à le monter :
```bash
qemu-system-i386 -m 64 -hda freedos.qcow2 \
-drive file=fat:rw:/home/utilisateur/dossier_partage,format=raw
```
Le dossier `dossier_partage` apparaît comme un disque dans FreeDOS. Pratique mais à utiliser avec précaution : le mode `rw` (lecture/écriture) peut corrompre des fichiers si la VM crashe.
## Solution 3 — Dossiers partagés VirtualBox
VirtualBox propose nativement des *Shared Folders*, mais **ils ne fonctionnent pas directement sous DOS** (pas de Guest Additions DOS). Il faut passer par un pilote tiers comme **VBSF for DOS** ou simplement utiliser la solution 1 (image disque attachée).
---
# Astuces utiles
**Transférer des fichiers ponctuellement :** crée une ISO contenant tes fichiers et monte-la comme CD-ROM dans la VM :
```bash
mkisofs -o transfert.iso -J -R /chemin/vers/fichiers
```
**Snapshots QEMU** pour expérimenter sans risque :
```bash
qemu-img snapshot -c avant_test freedos.qcow2
# ... après expérimentation ratée :
qemu-img snapshot -a avant_test freedos.qcow2
```
**Réseau dans FreeDOS** : possible avec le paquet `mTCP` inclus dans FreeDOS — utile pour FTP, Telnet, ou IRC depuis ta VM.
---
# Note sur la taille de l'image
Une image FreeDOS complète pèse environ 230 Mio, bien plus qu'une disquette 3,5" de 1,44 Mo. C'est parce qu'elle inclut un installateur, des utilitaires, des pilotes, et des programmes optionnels. L'installation finale sur disque peut tenir en moins de 20 Mo si tu sélectionnes uniquement le strict nécessaire (kernel + COMMAND.COM + quelques utilitaires).
À titre de comparaison historique : disquette 5,25" originale = 160 Ko, disquette 3,5" HD = 1,44 Mo, première version de MS-DOS = tenait sur une seule disquette.
---
# Optimisation de la mémoire EMS/XMS sous DOS
DOS a été conçu à une époque où 640 Ko de RAM semblaient infinis. Cette limite — la fameuse *conventional memory* — est devenue un casse-tête dès que les programmes ont grossi. Comprendre les différents types de mémoire est essentiel pour faire tourner correctement les vieux jeux et logiciels.
## Les différents types de mémoire
**Conventional memory (0 640 Ko)** : la mémoire de base utilisable par tous les programmes DOS. C'est la ressource la plus précieuse — beaucoup de jeux exigent 580 Ko ou plus de libre.
**Upper Memory Area / UMA (640 Ko 1 Mo)** : zone réservée au BIOS et aux périphériques, mais avec des "trous" (UMB, *Upper Memory Blocks*) où l'on peut loger des pilotes pour libérer la mémoire conventionnelle.
**High Memory Area / HMA (1024 1088 Ko)** : les premiers 64 Ko au-dessus de 1 Mo, accessibles en mode réel grâce à une astuce du 80286. On y charge typiquement une partie de DOS.
**Extended Memory / XMS (au-delà de 1 Mo)** : mémoire linéaire au-delà du premier mégaoctet, gérée par `HIMEM.SYS`. Utilisée par Windows 3.x, les jeux récents (Doom, Quake DOS), les disques RAM et caches.
**Expanded Memory / EMS** : ancien système de pagination (fenêtre de 64 Ko qui pointe vers une grande zone de RAM). Demandé par des jeux et logiciels plus anciens (Ultima 7, Wing Commander, Lotus 1-2-3). Émulé via `EMM386.EXE` à partir de la mémoire étendue.
## Configuration recommandée pour FreeDOS
Édite (ou crée) le fichier `C:\FDCONFIG.SYS` — l'équivalent de `CONFIG.SYS` sous FreeDOS :
```
DOS=HIGH,UMB
DEVICE=C:\FREEDOS\BIN\HIMEM.EXE
DEVICE=C:\FREEDOS\BIN\EMM386.EXE RAM
DEVICEHIGH=C:\FREEDOS\BIN\ANSI.SYS
FILES=40
BUFFERS=20
STACKS=9,256
SHELL=C:\FREEDOS\BIN\COMMAND.COM /E:512 /P
```
**Explication ligne par ligne :**
- `DOS=HIGH,UMB` : charge le noyau DOS dans la HMA et active l'usage des UMB
- `HIMEM.EXE` : gestionnaire de mémoire XMS, indispensable
- `EMM386.EXE RAM` : active à la fois EMS (émulé) et UMB. Utilise `NOEMS` à la place si tu n'as besoin que des UMB sans émulation EMS (libère plus de RAM)
- `DEVICEHIGH=` : charge un pilote dans les UMB plutôt qu'en mémoire conventionnelle
- `SHELL=... /E:512` : agrandit l'environnement DOS à 512 octets (utile pour les chemins longs)
Et dans `C:\AUTOEXEC.BAT`, charge les TSR (programmes résidents) en mémoire haute avec `LH` (*LoadHigh*) :
```
@ECHO OFF
SET PATH=C:\FREEDOS\BIN;C:\
SET TEMP=C:\TEMP
LH C:\FREEDOS\BIN\SHARE.EXE
LH C:\FREEDOS\BIN\MOUSE.EXE
PROMPT $P$G
```
## Vérifier le résultat
La commande `MEM` (ou `MEM /C` pour le détail par programme) affiche la répartition mémoire :
```
C:\> MEM /C /P
```
Tu devrais voir quelque chose comme :
```
Memory Type Total Used Free
---------------- ------- ------- -------
Conventional 640K 35K 605K
Upper 155K 48K 107K
Reserved 384K 384K 0K
Extended (XMS) 15,232K 1,088K 14,144K
---------------- ------- ------- -------
Total memory 16,411K 1,555K 14,856K
Largest executable program size 605K (619,328 bytes)
Largest free upper memory block 107K (109,568 bytes)
```
L'objectif : **maximiser le "Largest executable program size"** (idéalement >600 Ko).
## Choix EMS vs XMS selon les jeux
| Logiciel typique | Besoin |
|---|---|
| Doom, Quake, Duke Nukem 3D | XMS uniquement → `EMM386 NOEMS` |
| Ultima 7, Wing Commander, Master of Orion | EMS requis → `EMM386 RAM` |
| Lotus 1-2-3, AutoCAD ancien | EMS recommandé |
| Commander Keen, Prince of Persia | Aucun → désactiver EMM386 |
**Astuce** : maintiens deux fichiers de config différents et utilise le menu de démarrage de FreeDOS (`!menu` dans `FDCONFIG.SYS`) pour choisir au boot — exactement comme on faisait dans les années 90.
---
# Script de lancement automatisé pour QEMU
Plutôt que retaper de longues commandes QEMU, voici un script Bash complet et paramétrable.
## Script principal
Crée le fichier `~/bin/freedos-vm.sh` :
```bash
#!/usr/bin/env bash
#
# Lanceur FreeDOS sous QEMU
# Usage : freedos-vm.sh [commande] [options]
#
set -euo pipefail
# --- Configuration ---------------------------------------------------------
VM_DIR="${HOME}/VMs/freedos"
DISK="${VM_DIR}/freedos.qcow2"
ISO="${VM_DIR}/FD13LIVE.iso"
SHARE_DIR="${VM_DIR}/partage"
SHARE_IMG="${VM_DIR}/partage.img"
FLOPPY_DIR="${VM_DIR}/floppies"
RAM="64" # Mo de RAM
DISK_SIZE="2G" # Taille du disque dur virtuel
SHARE_SIZE_MB="100" # Taille de l'image de partage en Mo
QEMU="qemu-system-i386"
QEMU_OPTS=(
-m "${RAM}"
-rtc base=localtime # Horloge synchronisée
-vga std # Carte graphique standard
-display gtk # Remplace par "sdl" si besoin
)
# --- Couleurs --------------------------------------------------------------
RED=$'\033[0;31m'; GRN=$'\033[0;32m'; YEL=$'\033[1;33m'; NC=$'\033[0m'
log() { echo "${GRN}[+]${NC} $*"; }
warn() { echo "${YEL}[!]${NC} $*"; }
err() { echo "${RED}[x]${NC} $*" >&2; exit 1; }
# --- Fonctions -------------------------------------------------------------
init() {
log "Initialisation de l'environnement dans ${VM_DIR}"
mkdir -p "${VM_DIR}" "${SHARE_DIR}" "${FLOPPY_DIR}"
if [[ ! -f "${DISK}" ]]; then
log "Création du disque dur virtuel (${DISK_SIZE})"
qemu-img create -f qcow2 "${DISK}" "${DISK_SIZE}"
else
warn "Le disque ${DISK} existe déjà"
fi
if [[ ! -f "${SHARE_IMG}" ]]; then
log "Création de l'image de partage (${SHARE_SIZE_MB} Mo, FAT16)"
dd if=/dev/zero of="${SHARE_IMG}" bs=1M count="${SHARE_SIZE_MB}" status=none
mkfs.fat -F 16 -n PARTAGE "${SHARE_IMG}" >/dev/null
fi
if [[ ! -f "${ISO}" ]]; then
warn "ISO FreeDOS absente. Télécharge-la depuis https://www.freedos.org/download/"
warn "puis place-la ici : ${ISO}"
fi
}
install() {
[[ -f "${ISO}" ]] || err "ISO manquante : ${ISO}"
log "Démarrage en mode INSTALLATION (boot CD)"
"${QEMU}" "${QEMU_OPTS[@]}" \
-hda "${DISK}" \
-cdrom "${ISO}" \
-boot d
}
run() {
local floppy="${1:-}"
local qemu_extra=()
if [[ -n "${floppy}" ]]; then
[[ -f "${floppy}" ]] || err "Disquette introuvable : ${floppy}"
log "Disquette montée en A: : ${floppy}"
qemu_extra+=(-fda "${floppy}")
fi
log "Démarrage de FreeDOS"
"${QEMU}" "${QEMU_OPTS[@]}" \
-hda "${DISK}" \
-hdb "${SHARE_IMG}" \
"${qemu_extra[@]}" \
-boot c
}
mount_share() {
local mp="/tmp/freedos-share-$$"
sudo mkdir -p "${mp}"
sudo mount -o loop,uid="$(id -u)",gid="$(id -g)" "${SHARE_IMG}" "${mp}"
log "Image de partage montée sur ${mp}"
log "N'oublie pas de démonter avec : sudo umount ${mp} && rmdir ${mp}"
}
umount_share() {
for mp in /tmp/freedos-share-*; do
[[ -d "${mp}" ]] || continue
sudo umount "${mp}" && sudo rmdir "${mp}" && log "Démonté : ${mp}"
done
}
snapshot() {
local name="${1:?nom de snapshot requis}"
qemu-img snapshot -c "${name}" "${DISK}"
log "Snapshot '${name}' créé"
}
restore() {
local name="${1:?nom de snapshot requis}"
qemu-img snapshot -a "${name}" "${DISK}"
log "Snapshot '${name}' restauré"
}
list_snapshots() {
qemu-img snapshot -l "${DISK}"
}
usage() {
cat <<EOF
Usage : $(basename "$0") <commande> [arguments]
Commandes :
init Crée disque, image de partage et arborescence
install Lance la VM en mode installation (boot ISO)
run [disquette] Démarre FreeDOS (avec disquette optionnelle en A:)
mount Monte l'image de partage côté Linux
umount Démonte toutes les images de partage
snap <nom> Crée un snapshot du disque
restore <nom> Restaure un snapshot
snaps Liste les snapshots
help Affiche cette aide
Exemples :
$(basename "$0") init
$(basename "$0") install
$(basename "$0") run
$(basename "$0") run ${FLOPPY_DIR}/jeu.img
$(basename "$0") snap avant_test_doom
EOF
}
# --- Dispatcher ------------------------------------------------------------
cmd="${1:-help}"
shift || true
case "${cmd}" in
init) init ;;
install) install ;;
run) run "${@:-}" ;;
mount) mount_share ;;
umount) umount_share ;;
snap) snapshot "$@" ;;
restore) restore "$@" ;;
snaps) list_snapshots ;;
help|-h|--help) usage ;;
*) err "Commande inconnue : ${cmd}. Voir '$(basename "$0") help'" ;;
esac
```
Rends-le exécutable :
```bash
chmod +x ~/bin/freedos-vm.sh
```
## Utilisation typique
```bash
# Première fois : crée l'arborescence et les disques
freedos-vm.sh init
# Télécharge l'ISO depuis freedos.org et place-la dans ~/VMs/freedos/
# Lance l'installation
freedos-vm.sh install
# Démarrages quotidiens
freedos-vm.sh run
# Tester un jeu sur disquette
freedos-vm.sh run ~/VMs/freedos/floppies/keen1.img
# Avant une manip risquée
freedos-vm.sh snap config_stable
# ...si ça casse :
freedos-vm.sh restore config_stable
# Copier des fichiers depuis Linux vers FreeDOS
freedos-vm.sh mount
cp ~/Downloads/programme.zip /tmp/freedos-share-*/
freedos-vm.sh umount
freedos-vm.sh run
```
## Variante avec dossier partagé direct (VVFAT)
Pour éviter le mount/umount manuel, remplace la ligne `-hdb "${SHARE_IMG}"` par :
```bash
-drive file=fat:rw:"${SHARE_DIR}",format=raw,if=ide
```
Le dossier `~/VMs/freedos/partage` est alors directement vu comme un disque dans FreeDOS, sans démontage. Attention : en cas de crash brutal de la VM, le contenu peut être corrompu — à réserver pour des transferts ponctuels.
## Raccourci bureau (optionnel)
Crée `~/.local/share/applications/freedos.desktop` :
```ini
[Desktop Entry]
Name=FreeDOS VM
Comment=Démarrer la machine virtuelle FreeDOS
Exec=/home/UTILISATEUR/bin/freedos-vm.sh run
Icon=computer
Terminal=false
Type=Application
Categories=System;Emulator;
```
Remplace `UTILISATEUR` par ton nom d'utilisateur. FreeDOS apparaîtra alors dans le menu d'applications de ton bureau.
---
# Émulation SoundBlaster sous QEMU
Sans son, un vieux jeu DOS perd la moitié de son charme — les bips de Doom, la musique MIDI de Monkey Island, les sample digitalisés de Wing Commander font partie de l'expérience. QEMU peut émuler plusieurs cartes son de l'époque, et FreeDOS dispose des pilotes nécessaires pour les exploiter.
## Les cartes son émulées par QEMU
QEMU propose plusieurs modèles. Pour DOS, seuls quelques-uns sont pertinents :
| Option QEMU | Carte émulée | Compatibilité DOS |
|---|---|---|
| `sb16` | SoundBlaster 16 | ★★★ Excellente — le standard de facto |
| `adlib` | AdLib (Yamaha YM3812) | ★★ Bonne pour les jeux pré-1992 (musique FM uniquement) |
| `gus` | Gravis UltraSound | ★ Limité, peu de jeux le supportent nativement |
| `pcspk` | Haut-parleur interne PC | ★★★ Toujours dispo, son bipé d'origine |
| `cs4231a` | Windows Sound System | À éviter sous DOS |
**Recommandation** : utilise `sb16` qui couvre 95% des jeux DOS et inclut une émulation AdLib intégrée (donc compatibilité descendante avec les jeux plus anciens).
## Activation dans QEMU
Ajoute les options audio au lancement. La syntaxe a évolué entre les versions de QEMU — voici la forme moderne (QEMU ≥ 5.0) :
```bash
qemu-system-i386 \
-m 64 \
-hda freedos.qcow2 \
-audiodev pa,id=snd0 \
-machine pcspk-audiodev=snd0 \
-device sb16,audiodev=snd0 \
-boot c
```
**Explication des options :**
- `-audiodev pa,id=snd0` : backend audio **PulseAudio** (utilise `alsa` pour ALSA pur, `pipewire` sur les distros récentes, `oss` pour OSS)
- `-machine pcspk-audiodev=snd0` : active le haut-parleur interne
- `-device sb16,audiodev=snd0` : ajoute la carte SoundBlaster 16
Pour la **SoundBlaster + AdLib** simultanément (utile pour les jeux qui détectent les deux séparément) :
```bash
-device sb16,audiodev=snd0 \
-device adlib,audiodev=snd0
```
## Adapter le script de lancement
Reprends le script `freedos-vm.sh` de la section précédente et modifie le tableau `QEMU_OPTS` :
```bash
# Détection automatique du backend audio
detect_audio() {
if command -v pipewire &>/dev/null && pgrep -x pipewire &>/dev/null; then
echo "pipewire"
elif pgrep -x pulseaudio &>/dev/null; then
echo "pa"
else
echo "alsa"
fi
}
AUDIO_BACKEND="$(detect_audio)"
QEMU_OPTS=(
-m "${RAM}"
-rtc base=localtime
-vga std
-display gtk
-audiodev "${AUDIO_BACKEND},id=snd0"
-machine "pcspk-audiodev=snd0"
-device sb16,audiodev=snd0
)
```
Le script choisira automatiquement PipeWire, PulseAudio ou ALSA selon ce qui tourne sur ton système.
## Configuration côté FreeDOS
Pour que les jeux trouvent la SoundBlaster, il faut définir la variable d'environnement `BLASTER` dans `AUTOEXEC.BAT`. C'est la convention historique que tous les jeux DOS lisent au démarrage.
Ajoute cette ligne :
```
SET BLASTER=A220 I5 D1 H5 T6
```
**Décodage des paramètres :**
| Paramètre | Signification | Valeur émulée par QEMU |
|---|---|---|
| `A220` | Port d'E/S de base | `0x220` (standard) |
| `I5` | IRQ | `5` (parfois `7`) |
| `D1` | Canal DMA 8 bits | `1` |
| `H5` | Canal DMA 16 bits | `5` (SB16 uniquement) |
| `T6` | Type de carte | `6` = SoundBlaster 16 |
Tu peux aussi ajouter le port MIDI/MPU-401 si tu en as besoin :
```
SET BLASTER=A220 I5 D1 H5 T6 P330
SET MIDI=SYNTH:1 MAP:E MODE:0
```
## Configuration des jeux
La plupart des jeux DOS ont un programme de configuration audio à lancer une fois (`SETUP.EXE`, `INSTALL.EXE`, `SETSOUND.EXE` selon le titre). Choisis :
- **Effets sonores** : *SoundBlaster 16* ou *SoundBlaster Pro*
- **Musique** : *SoundBlaster 16* (pour OPL3) ou *General MIDI* via MPU-401 si tu veux la qualité supérieure
Pour les jeux qui demandent un test, le programme jouera un échantillon — si tu l'entends, c'est gagné.
## Test rapide après installation
Sous FreeDOS, le paquet officiel inclut souvent un petit utilitaire de test. Sinon, télécharge un module `.MOD` et lance un player comme **MODPLAY** ou **DOSMID** pour les fichiers MIDI :
```
C:\> MODPLAY musique.mod
```
Tu peux aussi simplement lancer un jeu connu pour son audio : Doom, Duke Nukem 3D, Commander Keen 4 → ils détecteront la SB16 et joueront leurs musiques OPL3.
## Problèmes courants
**Pas de son du tout :**
- Vérifie que `BLASTER` est bien défini : `SET` dans le prompt DOS doit l'afficher
- Lance QEMU avec `-d guest_errors` pour voir les éventuelles erreurs d'I/O
- Teste le backend : remplace `pa` par `alsa` ou inversement
**Son saccadé ou crachotant :**
- Augmente la RAM allouée (`-m 128`)
- Ajoute `-cpu pentium` pour ralentir l'émulation CPU (certains jeux audio sont sensibles à la vitesse)
- Sur des distros avec PipeWire récent, essaie `-audiodev pipewire,id=snd0`
**Musique sans effets, ou inverse :**
- Le jeu utilise probablement deux périphériques séparés (AdLib pour la musique, SB pour les SFX) → ajoute `-device adlib,audiodev=snd0` en plus
**Tempo MIDI trop rapide/lent :**
- Bien configurer la variable `BLASTER` avec le bon IRQ et port MPU-401 (`P330`)
## Pour aller plus loin : DOSBox vs QEMU
Soyons honnête : pour le **jeu DOS pur**, [DOSBox](https://www.dosbox.com/) (et surtout son fork **DOSBox-X** ou **DOSBox Staging**) offre une émulation audio bien plus fidèle que QEMU — émulation cycle-accurate du Yamaha OPL3, support natif MT-32, General MIDI logiciel intégré, etc.
QEMU reste préférable quand :
- Tu veux un vrai environnement DOS complet (multitâche avec FreeDOS, accès réseau via mTCP, snapshots disque)
- Tu fais autre chose que jouer (développement, BIOS flashing, scripts batch)
- Tu veux une VM persistante et configurable comme un vrai PC
Pour le jeu, l'approche hybride est gagnante : **FreeDOS sous QEMU** pour explorer et bidouiller, **DOSBox Staging** pour lancer un jeu spécifique avec le meilleur son possible.
---
# Bibliographie
- Site officiel : https://www.freedos.org/
- Wiki d'installation VirtualBox : https://wiki.freedos.org/wiki/index.php/VirtualBox
- Documentation QEMU : https://www.qemu.org/docs/master/system/index.html
- mTCP (réseau sous DOS) : https://www.brutman.com/mTCP/
+660 -18
View File
@@ -1,33 +1,675 @@
# FreeDOS
FreeDOS est un système d'exploitation libre et open source conçu pour être compatible avec les applications et les jeux MS-DOS (Microsoft Disk Operating System). Il a été développé pour fournir une alternative gratuite à MS-DOS, qui était un système d'exploitation très populaire dans les années 1980 et 1990.
FreeDOS est un système d'exploitation libre et open source compatible avec MS-DOS. Il permet d'exécuter de vieux programmes et jeux des années 80-90 sur du matériel moderne ou dans une machine virtuelle. Distribué sous licence GPL, il est entièrement gratuit et activement maintenu par sa communauté.
FreeDOS offre un ensemble de commandes et d'outils compatibles avec MS-DOS, ce qui signifie qu'il peut exécuter des programmes et des jeux conçus pour fonctionner sous MS-DOS. Il est également compatible avec certains programmes Windows 16 bits et peut être utilisé pour exécuter des tâches simples telles que la gestion de fichiers, la création de partitions de disque dur, la sauvegarde de données, etc.
**Cas d'usage typiques :**
- Faire tourner d'anciens jeux DOS (Doom, Commander Keen, etc.)
- Exécuter des logiciels professionnels legacy (comptabilité, CAO ancienne)
- Flasher un BIOS depuis un environnement DOS
- Apprendre l'histoire de l'informatique
FreeDOS est un système d'exploitation léger et rapide qui peut être utilisé sur des ordinateurs plus anciens ou sur des machines virtuelles. Il est distribué sous licence GPL (General Public License), ce qui signifie qu'il peut être utilisé gratuitement, copié, modifié et distribué librement.
---
# Installer FreeDOS
L'installation de FreeDOS peut varier en fonction de l'utilisation prévue et du matériel de votre ordinateur. Voici les étapes générales pour installer FreeDOS sur un ordinateur :
# Installer FreeDOS dans une machine virtuelle sous Linux
- Téléchargez la dernière version de FreeDOS sur le site officiel (https:*www.freedos.org/download/).
L'approche en VM est de loin la plus pratique : pas de risque pour ton système, snapshots possibles, et configuration matérielle reproductible. Voici la méthode avec **QEMU/KVM** (natif Linux, léger) et **VirtualBox** (plus visuel).
- Créez une clé USB bootable avec l'image ISO de FreeDOS en utilisant un logiciel de création de clé USB bootable, comme Rufus.
## Prérequis communs
- Insérez la clé USB bootable dans l'ordinateur sur lequel vous souhaitez installer FreeDOS, puis redémarrez l'ordinateur.
Télécharge l'image ISO sur le site officiel : https://www.freedos.org/download/ (choisis le **LiveCD** ou **FullUSB** au format `.iso`).
- Dans le BIOS de l'ordinateur, modifiez l'ordre de démarrage pour démarrer à partir de la clé USB bootable.
## Méthode 1 — QEMU (recommandée sous Linux)
- Suivez les instructions d'installation de FreeDOS qui s'affichent à l'écran. Vous pouvez choisir d'installer FreeDOS sur un disque dur ou de l'utiliser en mode Live CD à partir de la clé USB.
Installation des paquets selon ta distribution :
- Après l'installation, redémarrez l'ordinateur et vous devriez voir l'invite de commande de FreeDOS.
```bash
# Debian / Ubuntu
sudo apt install qemu-system-x86 qemu-utils
<callout icon="fa fa-slack">
Une image FreeDOS pèse 232.9 MiB, ce qui est beaucoup plus grande qu'une disquette MS-DOS standard, qui avait une capacité de stockage maximale de 1,44 Mo. Les disquettes MS-DOS étaient utilisées comme supports de stockage amovibles pour les ordinateurs personnels dans les années 80 et 90, avant que les clés USB et les disques durs externes ne deviennent plus populaires.
# Fedora
sudo dnf install qemu-system-x86 qemu-img
L'image de disque de 232.9 MiB est destinée à être utilisée pour installer FreeDOS sur un disque dur ou une clé USB, plutôt que pour l'utiliser directement à partir d'une disquette.
# Arch
sudo pacman -S qemu-full
```
Crée un disque dur virtuel de 2 Go (largement suffisant pour DOS) :
```bash
qemu-img create -f qcow2 freedos.qcow2 2G
```
Démarre l'installation depuis l'ISO :
```bash
qemu-system-i386 \
-m 64 \
-hda freedos.qcow2 \
-cdrom FD13LIVE.iso \
-boot d
```
Une fois FreeDOS installé sur le disque virtuel, démarre directement dessus :
```bash
qemu-system-i386 -m 64 -hda freedos.qcow2 -boot c
```
> 64 Mo de RAM (`-m 64`) suffisent largement — DOS n'utilise nativement que 640 Ko de mémoire conventionnelle.
## Méthode 2 — VirtualBox
```bash
sudo apt install virtualbox # Debian/Ubuntu
```
1. **Nouvelle machine** → Type : *Other*, Version : *DOS*
2. RAM : 64 Mo, Disque dur : 2 Go (VDI, dynamiquement alloué)
3. Dans les **paramètres** de la VM → *Stockage* → ajoute l'ISO de FreeDOS au lecteur optique
4. Démarre la VM et suis l'installateur de FreeDOS
---
# Monter des images de disquettes
Très utile pour faire tourner des vieux logiciels distribués en `.img` ou `.ima`.
## Avec QEMU
Ajoute simplement l'option `-fda` (floppy A:) au lancement :
```bash
qemu-system-i386 -m 64 -hda freedos.qcow2 -fda jeu.img -boot c
```
Dans FreeDOS, le contenu sera accessible via `A:`. Tu peux aussi monter deux disquettes simultanément avec `-fda` et `-fdb`.
## Avec VirtualBox
Dans *Paramètres → Stockage* :
1. Ajoute un contrôleur **Floppy** s'il n'existe pas
2. Attache ton fichier `.img` ou `.ima` comme lecteur de disquette
## Inspecter une image disquette directement sous Linux
Tu peux lire le contenu d'une image avant même de la monter dans la VM :
```bash
# Monter en lecture seule sur Linux hôte
sudo mkdir /mnt/floppy
sudo mount -o loop,ro disquette.img /mnt/floppy
ls /mnt/floppy
sudo umount /mnt/floppy
```
Pour créer une image de disquette vierge formatée FAT12 :
```bash
dd if=/dev/zero of=vierge.img bs=512 count=2880 # 1.44 Mo
mkfs.fat -F 12 vierge.img
```
---
# Partager un dossier entre Linux et FreeDOS
C'est le point souvent bloquant : DOS ne connaît ni les partages réseau modernes, ni les Guest Additions. Voici trois approches qui fonctionnent.
## Solution 1 — Image disque partagée (la plus simple avec QEMU)
Crée une image FAT que tu peux monter alternativement sous Linux et sous DOS :
```bash
# Créer une image de 100 Mo formatée FAT16
dd if=/dev/zero of=partage.img bs=1M count=100
mkfs.fat -F 16 partage.img
```
Côté Linux, pour y déposer des fichiers :
```bash
sudo mount -o loop partage.img /mnt/partage
sudo cp mon_programme.exe /mnt/partage/
sudo umount /mnt/partage
```
Côté QEMU, attache-la comme second disque :
```bash
qemu-system-i386 -m 64 -hda freedos.qcow2 -hdb partage.img -boot c
```
Dans FreeDOS, elle apparaîtra en `D:`.
> ⚠️ Évite d'écrire des deux côtés en même temps — démonte toujours du côté Linux avant de lancer la VM.
## Solution 2 — Dossier partagé via QEMU `-drive` avec VVFAT
QEMU peut exposer un dossier Linux comme un disque FAT virtuel, sans avoir à le monter :
```bash
qemu-system-i386 -m 64 -hda freedos.qcow2 \
-drive file=fat:rw:/home/utilisateur/dossier_partage,format=raw
```
Le dossier `dossier_partage` apparaît comme un disque dans FreeDOS. Pratique mais à utiliser avec précaution : le mode `rw` (lecture/écriture) peut corrompre des fichiers si la VM crashe.
## Solution 3 — Dossiers partagés VirtualBox
VirtualBox propose nativement des *Shared Folders*, mais **ils ne fonctionnent pas directement sous DOS** (pas de Guest Additions DOS). Il faut passer par un pilote tiers comme **VBSF for DOS** ou simplement utiliser la solution 1 (image disque attachée).
---
# Astuces utiles
**Transférer des fichiers ponctuellement :** crée une ISO contenant tes fichiers et monte-la comme CD-ROM dans la VM :
```bash
mkisofs -o transfert.iso -J -R /chemin/vers/fichiers
```
**Snapshots QEMU** pour expérimenter sans risque :
```bash
qemu-img snapshot -c avant_test freedos.qcow2
# ... après expérimentation ratée :
qemu-img snapshot -a avant_test freedos.qcow2
```
**Réseau dans FreeDOS** : possible avec le paquet `mTCP` inclus dans FreeDOS — utile pour FTP, Telnet, ou IRC depuis ta VM.
---
# Note sur la taille de l'image
Une image FreeDOS complète pèse environ 230 Mio, bien plus qu'une disquette 3,5" de 1,44 Mo. C'est parce qu'elle inclut un installateur, des utilitaires, des pilotes, et des programmes optionnels. L'installation finale sur disque peut tenir en moins de 20 Mo si tu sélectionnes uniquement le strict nécessaire (kernel + COMMAND.COM + quelques utilitaires).
À titre de comparaison historique : disquette 5,25" originale = 160 Ko, disquette 3,5" HD = 1,44 Mo, première version de MS-DOS = tenait sur une seule disquette.
---
# Optimisation de la mémoire EMS/XMS sous DOS
DOS a été conçu à une époque où 640 Ko de RAM semblaient infinis. Cette limite — la fameuse *conventional memory* — est devenue un casse-tête dès que les programmes ont grossi. Comprendre les différents types de mémoire est essentiel pour faire tourner correctement les vieux jeux et logiciels.
## Les différents types de mémoire
**Conventional memory (0 640 Ko)** : la mémoire de base utilisable par tous les programmes DOS. C'est la ressource la plus précieuse — beaucoup de jeux exigent 580 Ko ou plus de libre.
**Upper Memory Area / UMA (640 Ko 1 Mo)** : zone réservée au BIOS et aux périphériques, mais avec des "trous" (UMB, *Upper Memory Blocks*) où l'on peut loger des pilotes pour libérer la mémoire conventionnelle.
**High Memory Area / HMA (1024 1088 Ko)** : les premiers 64 Ko au-dessus de 1 Mo, accessibles en mode réel grâce à une astuce du 80286. On y charge typiquement une partie de DOS.
**Extended Memory / XMS (au-delà de 1 Mo)** : mémoire linéaire au-delà du premier mégaoctet, gérée par `HIMEM.SYS`. Utilisée par Windows 3.x, les jeux récents (Doom, Quake DOS), les disques RAM et caches.
**Expanded Memory / EMS** : ancien système de pagination (fenêtre de 64 Ko qui pointe vers une grande zone de RAM). Demandé par des jeux et logiciels plus anciens (Ultima 7, Wing Commander, Lotus 1-2-3). Émulé via `EMM386.EXE` à partir de la mémoire étendue.
## Configuration recommandée pour FreeDOS
Édite (ou crée) le fichier `C:\FDCONFIG.SYS` — l'équivalent de `CONFIG.SYS` sous FreeDOS :
```
DOS=HIGH,UMB
DEVICE=C:\FREEDOS\BIN\HIMEM.EXE
DEVICE=C:\FREEDOS\BIN\EMM386.EXE RAM
DEVICEHIGH=C:\FREEDOS\BIN\ANSI.SYS
FILES=40
BUFFERS=20
STACKS=9,256
SHELL=C:\FREEDOS\BIN\COMMAND.COM /E:512 /P
```
**Explication ligne par ligne :**
- `DOS=HIGH,UMB` : charge le noyau DOS dans la HMA et active l'usage des UMB
- `HIMEM.EXE` : gestionnaire de mémoire XMS, indispensable
- `EMM386.EXE RAM` : active à la fois EMS (émulé) et UMB. Utilise `NOEMS` à la place si tu n'as besoin que des UMB sans émulation EMS (libère plus de RAM)
- `DEVICEHIGH=` : charge un pilote dans les UMB plutôt qu'en mémoire conventionnelle
- `SHELL=... /E:512` : agrandit l'environnement DOS à 512 octets (utile pour les chemins longs)
Et dans `C:\AUTOEXEC.BAT`, charge les TSR (programmes résidents) en mémoire haute avec `LH` (*LoadHigh*) :
```
@ECHO OFF
SET PATH=C:\FREEDOS\BIN;C:\
SET TEMP=C:\TEMP
LH C:\FREEDOS\BIN\SHARE.EXE
LH C:\FREEDOS\BIN\MOUSE.EXE
PROMPT $P$G
```
## Vérifier le résultat
La commande `MEM` (ou `MEM /C` pour le détail par programme) affiche la répartition mémoire :
```
C:\> MEM /C /P
```
Tu devrais voir quelque chose comme :
```
Memory Type Total Used Free
---------------- ------- ------- -------
Conventional 640K 35K 605K
Upper 155K 48K 107K
Reserved 384K 384K 0K
Extended (XMS) 15,232K 1,088K 14,144K
---------------- ------- ------- -------
Total memory 16,411K 1,555K 14,856K
Largest executable program size 605K (619,328 bytes)
Largest free upper memory block 107K (109,568 bytes)
```
L'objectif : **maximiser le "Largest executable program size"** (idéalement >600 Ko).
## Choix EMS vs XMS selon les jeux
| Logiciel typique | Besoin |
|---|---|
| Doom, Quake, Duke Nukem 3D | XMS uniquement → `EMM386 NOEMS` |
| Ultima 7, Wing Commander, Master of Orion | EMS requis → `EMM386 RAM` |
| Lotus 1-2-3, AutoCAD ancien | EMS recommandé |
| Commander Keen, Prince of Persia | Aucun → désactiver EMM386 |
**Astuce** : maintiens deux fichiers de config différents et utilise le menu de démarrage de FreeDOS (`!menu` dans `FDCONFIG.SYS`) pour choisir au boot — exactement comme on faisait dans les années 90.
---
# Script de lancement automatisé pour QEMU
Plutôt que retaper de longues commandes QEMU, voici un script Bash complet et paramétrable.
## Script principal
Crée le fichier `~/bin/freedos-vm.sh` :
```bash
#!/usr/bin/env bash
#
# Lanceur FreeDOS sous QEMU
# Usage : freedos-vm.sh [commande] [options]
#
set -euo pipefail
# --- Configuration ---------------------------------------------------------
VM_DIR="${HOME}/VMs/freedos"
DISK="${VM_DIR}/freedos.qcow2"
ISO="${VM_DIR}/FD13LIVE.iso"
SHARE_DIR="${VM_DIR}/partage"
SHARE_IMG="${VM_DIR}/partage.img"
FLOPPY_DIR="${VM_DIR}/floppies"
RAM="64" # Mo de RAM
DISK_SIZE="2G" # Taille du disque dur virtuel
SHARE_SIZE_MB="100" # Taille de l'image de partage en Mo
QEMU="qemu-system-i386"
QEMU_OPTS=(
-m "${RAM}"
-rtc base=localtime # Horloge synchronisée
-vga std # Carte graphique standard
-display gtk # Remplace par "sdl" si besoin
)
# --- Couleurs --------------------------------------------------------------
RED=$'\033[0;31m'; GRN=$'\033[0;32m'; YEL=$'\033[1;33m'; NC=$'\033[0m'
log() { echo "${GRN}[+]${NC} $*"; }
warn() { echo "${YEL}[!]${NC} $*"; }
err() { echo "${RED}[x]${NC} $*" >&2; exit 1; }
# --- Fonctions -------------------------------------------------------------
init() {
log "Initialisation de l'environnement dans ${VM_DIR}"
mkdir -p "${VM_DIR}" "${SHARE_DIR}" "${FLOPPY_DIR}"
if [[ ! -f "${DISK}" ]]; then
log "Création du disque dur virtuel (${DISK_SIZE})"
qemu-img create -f qcow2 "${DISK}" "${DISK_SIZE}"
else
warn "Le disque ${DISK} existe déjà"
fi
if [[ ! -f "${SHARE_IMG}" ]]; then
log "Création de l'image de partage (${SHARE_SIZE_MB} Mo, FAT16)"
dd if=/dev/zero of="${SHARE_IMG}" bs=1M count="${SHARE_SIZE_MB}" status=none
mkfs.fat -F 16 -n PARTAGE "${SHARE_IMG}" >/dev/null
fi
if [[ ! -f "${ISO}" ]]; then
warn "ISO FreeDOS absente. Télécharge-la depuis https://www.freedos.org/download/"
warn "puis place-la ici : ${ISO}"
fi
}
install() {
[[ -f "${ISO}" ]] || err "ISO manquante : ${ISO}"
log "Démarrage en mode INSTALLATION (boot CD)"
"${QEMU}" "${QEMU_OPTS[@]}" \
-hda "${DISK}" \
-cdrom "${ISO}" \
-boot d
}
run() {
local floppy="${1:-}"
local qemu_extra=()
if [[ -n "${floppy}" ]]; then
[[ -f "${floppy}" ]] || err "Disquette introuvable : ${floppy}"
log "Disquette montée en A: : ${floppy}"
qemu_extra+=(-fda "${floppy}")
fi
log "Démarrage de FreeDOS"
"${QEMU}" "${QEMU_OPTS[@]}" \
-hda "${DISK}" \
-hdb "${SHARE_IMG}" \
"${qemu_extra[@]}" \
-boot c
}
mount_share() {
local mp="/tmp/freedos-share-$$"
sudo mkdir -p "${mp}"
sudo mount -o loop,uid="$(id -u)",gid="$(id -g)" "${SHARE_IMG}" "${mp}"
log "Image de partage montée sur ${mp}"
log "N'oublie pas de démonter avec : sudo umount ${mp} && rmdir ${mp}"
}
umount_share() {
for mp in /tmp/freedos-share-*; do
[[ -d "${mp}" ]] || continue
sudo umount "${mp}" && sudo rmdir "${mp}" && log "Démonté : ${mp}"
done
}
snapshot() {
local name="${1:?nom de snapshot requis}"
qemu-img snapshot -c "${name}" "${DISK}"
log "Snapshot '${name}' créé"
}
restore() {
local name="${1:?nom de snapshot requis}"
qemu-img snapshot -a "${name}" "${DISK}"
log "Snapshot '${name}' restauré"
}
list_snapshots() {
qemu-img snapshot -l "${DISK}"
}
usage() {
cat <<EOF
Usage : $(basename "$0") <commande> [arguments]
Commandes :
init Crée disque, image de partage et arborescence
install Lance la VM en mode installation (boot ISO)
run [disquette] Démarre FreeDOS (avec disquette optionnelle en A:)
mount Monte l'image de partage côté Linux
umount Démonte toutes les images de partage
snap <nom> Crée un snapshot du disque
restore <nom> Restaure un snapshot
snaps Liste les snapshots
help Affiche cette aide
Exemples :
$(basename "$0") init
$(basename "$0") install
$(basename "$0") run
$(basename "$0") run ${FLOPPY_DIR}/jeu.img
$(basename "$0") snap avant_test_doom
EOF
}
# --- Dispatcher ------------------------------------------------------------
cmd="${1:-help}"
shift || true
case "${cmd}" in
init) init ;;
install) install ;;
run) run "${@:-}" ;;
mount) mount_share ;;
umount) umount_share ;;
snap) snapshot "$@" ;;
restore) restore "$@" ;;
snaps) list_snapshots ;;
help|-h|--help) usage ;;
*) err "Commande inconnue : ${cmd}. Voir '$(basename "$0") help'" ;;
esac
```
Rends-le exécutable :
```bash
chmod +x ~/bin/freedos-vm.sh
```
## Utilisation typique
```bash
# Première fois : crée l'arborescence et les disques
freedos-vm.sh init
# Télécharge l'ISO depuis freedos.org et place-la dans ~/VMs/freedos/
# Lance l'installation
freedos-vm.sh install
# Démarrages quotidiens
freedos-vm.sh run
# Tester un jeu sur disquette
freedos-vm.sh run ~/VMs/freedos/floppies/keen1.img
# Avant une manip risquée
freedos-vm.sh snap config_stable
# ...si ça casse :
freedos-vm.sh restore config_stable
# Copier des fichiers depuis Linux vers FreeDOS
freedos-vm.sh mount
cp ~/Downloads/programme.zip /tmp/freedos-share-*/
freedos-vm.sh umount
freedos-vm.sh run
```
## Variante avec dossier partagé direct (VVFAT)
Pour éviter le mount/umount manuel, remplace la ligne `-hdb "${SHARE_IMG}"` par :
```bash
-drive file=fat:rw:"${SHARE_DIR}",format=raw,if=ide
```
Le dossier `~/VMs/freedos/partage` est alors directement vu comme un disque dans FreeDOS, sans démontage. Attention : en cas de crash brutal de la VM, le contenu peut être corrompu — à réserver pour des transferts ponctuels.
## Raccourci bureau (optionnel)
Crée `~/.local/share/applications/freedos.desktop` :
```ini
[Desktop Entry]
Name=FreeDOS VM
Comment=Démarrer la machine virtuelle FreeDOS
Exec=/home/UTILISATEUR/bin/freedos-vm.sh run
Icon=computer
Terminal=false
Type=Application
Categories=System;Emulator;
```
Remplace `UTILISATEUR` par ton nom d'utilisateur. FreeDOS apparaîtra alors dans le menu d'applications de ton bureau.
---
# Émulation SoundBlaster sous QEMU
Sans son, un vieux jeu DOS perd la moitié de son charme — les bips de Doom, la musique MIDI de Monkey Island, les sample digitalisés de Wing Commander font partie de l'expérience. QEMU peut émuler plusieurs cartes son de l'époque, et FreeDOS dispose des pilotes nécessaires pour les exploiter.
## Les cartes son émulées par QEMU
QEMU propose plusieurs modèles. Pour DOS, seuls quelques-uns sont pertinents :
| Option QEMU | Carte émulée | Compatibilité DOS |
|---|---|---|
| `sb16` | SoundBlaster 16 | ★★★ Excellente — le standard de facto |
| `adlib` | AdLib (Yamaha YM3812) | ★★ Bonne pour les jeux pré-1992 (musique FM uniquement) |
| `gus` | Gravis UltraSound | ★ Limité, peu de jeux le supportent nativement |
| `pcspk` | Haut-parleur interne PC | ★★★ Toujours dispo, son bipé d'origine |
| `cs4231a` | Windows Sound System | À éviter sous DOS |
**Recommandation** : utilise `sb16` qui couvre 95% des jeux DOS et inclut une émulation AdLib intégrée (donc compatibilité descendante avec les jeux plus anciens).
## Activation dans QEMU
Ajoute les options audio au lancement. La syntaxe a évolué entre les versions de QEMU — voici la forme moderne (QEMU ≥ 5.0) :
```bash
qemu-system-i386 \
-m 64 \
-hda freedos.qcow2 \
-audiodev pa,id=snd0 \
-machine pcspk-audiodev=snd0 \
-device sb16,audiodev=snd0 \
-boot c
```
**Explication des options :**
- `-audiodev pa,id=snd0` : backend audio **PulseAudio** (utilise `alsa` pour ALSA pur, `pipewire` sur les distros récentes, `oss` pour OSS)
- `-machine pcspk-audiodev=snd0` : active le haut-parleur interne
- `-device sb16,audiodev=snd0` : ajoute la carte SoundBlaster 16
Pour la **SoundBlaster + AdLib** simultanément (utile pour les jeux qui détectent les deux séparément) :
```bash
-device sb16,audiodev=snd0 \
-device adlib,audiodev=snd0
```
## Adapter le script de lancement
Reprends le script `freedos-vm.sh` de la section précédente et modifie le tableau `QEMU_OPTS` :
```bash
# Détection automatique du backend audio
detect_audio() {
if command -v pipewire &>/dev/null && pgrep -x pipewire &>/dev/null; then
echo "pipewire"
elif pgrep -x pulseaudio &>/dev/null; then
echo "pa"
else
echo "alsa"
fi
}
AUDIO_BACKEND="$(detect_audio)"
QEMU_OPTS=(
-m "${RAM}"
-rtc base=localtime
-vga std
-display gtk
-audiodev "${AUDIO_BACKEND},id=snd0"
-machine "pcspk-audiodev=snd0"
-device sb16,audiodev=snd0
)
```
Le script choisira automatiquement PipeWire, PulseAudio ou ALSA selon ce qui tourne sur ton système.
## Configuration côté FreeDOS
Pour que les jeux trouvent la SoundBlaster, il faut définir la variable d'environnement `BLASTER` dans `AUTOEXEC.BAT`. C'est la convention historique que tous les jeux DOS lisent au démarrage.
Ajoute cette ligne :
```
SET BLASTER=A220 I5 D1 H5 T6
```
**Décodage des paramètres :**
| Paramètre | Signification | Valeur émulée par QEMU |
|---|---|---|
| `A220` | Port d'E/S de base | `0x220` (standard) |
| `I5` | IRQ | `5` (parfois `7`) |
| `D1` | Canal DMA 8 bits | `1` |
| `H5` | Canal DMA 16 bits | `5` (SB16 uniquement) |
| `T6` | Type de carte | `6` = SoundBlaster 16 |
Tu peux aussi ajouter le port MIDI/MPU-401 si tu en as besoin :
```
SET BLASTER=A220 I5 D1 H5 T6 P330
SET MIDI=SYNTH:1 MAP:E MODE:0
```
## Configuration des jeux
La plupart des jeux DOS ont un programme de configuration audio à lancer une fois (`SETUP.EXE`, `INSTALL.EXE`, `SETSOUND.EXE` selon le titre). Choisis :
- **Effets sonores** : *SoundBlaster 16* ou *SoundBlaster Pro*
- **Musique** : *SoundBlaster 16* (pour OPL3) ou *General MIDI* via MPU-401 si tu veux la qualité supérieure
Pour les jeux qui demandent un test, le programme jouera un échantillon — si tu l'entends, c'est gagné.
## Test rapide après installation
Sous FreeDOS, le paquet officiel inclut souvent un petit utilitaire de test. Sinon, télécharge un module `.MOD` et lance un player comme **MODPLAY** ou **DOSMID** pour les fichiers MIDI :
```
C:\> MODPLAY musique.mod
```
Tu peux aussi simplement lancer un jeu connu pour son audio : Doom, Duke Nukem 3D, Commander Keen 4 → ils détecteront la SB16 et joueront leurs musiques OPL3.
## Problèmes courants
**Pas de son du tout :**
- Vérifie que `BLASTER` est bien défini : `SET` dans le prompt DOS doit l'afficher
- Lance QEMU avec `-d guest_errors` pour voir les éventuelles erreurs d'I/O
- Teste le backend : remplace `pa` par `alsa` ou inversement
**Son saccadé ou crachotant :**
- Augmente la RAM allouée (`-m 128`)
- Ajoute `-cpu pentium` pour ralentir l'émulation CPU (certains jeux audio sont sensibles à la vitesse)
- Sur des distros avec PipeWire récent, essaie `-audiodev pipewire,id=snd0`
**Musique sans effets, ou inverse :**
- Le jeu utilise probablement deux périphériques séparés (AdLib pour la musique, SB pour les SFX) → ajoute `-device adlib,audiodev=snd0` en plus
**Tempo MIDI trop rapide/lent :**
- Bien configurer la variable `BLASTER` avec le bon IRQ et port MPU-401 (`P330`)
## Pour aller plus loin : DOSBox vs QEMU
Soyons honnête : pour le **jeu DOS pur**, [DOSBox](https://www.dosbox.com/) (et surtout son fork **DOSBox-X** ou **DOSBox Staging**) offre une émulation audio bien plus fidèle que QEMU — émulation cycle-accurate du Yamaha OPL3, support natif MT-32, General MIDI logiciel intégré, etc.
QEMU reste préférable quand :
- Tu veux un vrai environnement DOS complet (multitâche avec FreeDOS, accès réseau via mTCP, snapshots disque)
- Tu fais autre chose que jouer (développement, BIOS flashing, scripts batch)
- Tu veux une VM persistante et configurable comme un vrai PC
Pour le jeu, l'approche hybride est gagnante : **FreeDOS sous QEMU** pour explorer et bidouiller, **DOSBox Staging** pour lancer un jeu spécifique avec le meilleur son possible.
---
Il est intéressant de noter que la capacité de stockage des disquettes a augmenté au fil des ans, passant de 160 Ko pour les premières disquettes de 5,25 pouces à 1,44 Mo pour les disquettes de 3,5 pouces utilisées à la fin des années 90. Cependant, leur utilisation est aujourd'hui très limitée en raison de leur faible capacité de stockage et de leur fiabilité limitée.
</callout>
# Bibliographie
Installer FreeDOS dans une machine virtuelle VirtualBox
http:*wiki.freedos.org/wiki/index.php/VirtualBox
- Site officiel : https://www.freedos.org/
- Wiki d'installation VirtualBox : https://wiki.freedos.org/wiki/index.php/VirtualBox
- Documentation QEMU : https://www.qemu.org/docs/master/system/index.html
- mTCP (réseau sous DOS) : https://www.brutman.com/mTCP/
+20 -5
View File
@@ -4,15 +4,30 @@
"title": "FreeDOS",
"author": "cedric@abonnel.fr",
"published": true,
"published_at": "2023-02-28 20:54:18",
"featured": false,
"published_at": "2023-02-28 20:54",
"created_at": "2023-02-28 20:54:18",
"updated_at": "2023-02-28 20:54:18",
"revisions": [],
"updated_at": "2026-05-16 21:59:22",
"revisions": [
{
"n": 1,
"date": "2026-05-16 21:59:22",
"comment": "Tags modifiés, contenu modifié",
"title": "FreeDOS"
}
],
"cover": "",
"files_meta": [],
"external_links": [],
"seo_title": "",
"seo_description": "",
"seo_description": "FreeDOS est un système d'exploitation libre et open source compatible avec MS-DOS. Il permet d'exécuter de vieux programmes et jeux des années 80-90 sur du matériel moderne ou dans une machine virtuel",
"og_image": "",
"category": "Informatique"
"category": "Informatique",
"tags": {
"tags": [
"FreeDOS",
"QEMU",
"VirtualBox"
]
}
}
@@ -0,0 +1,33 @@
# FreeDOS
FreeDOS est un système d'exploitation libre et open source conçu pour être compatible avec les applications et les jeux MS-DOS (Microsoft Disk Operating System). Il a été développé pour fournir une alternative gratuite à MS-DOS, qui était un système d'exploitation très populaire dans les années 1980 et 1990.
FreeDOS offre un ensemble de commandes et d'outils compatibles avec MS-DOS, ce qui signifie qu'il peut exécuter des programmes et des jeux conçus pour fonctionner sous MS-DOS. Il est également compatible avec certains programmes Windows 16 bits et peut être utilisé pour exécuter des tâches simples telles que la gestion de fichiers, la création de partitions de disque dur, la sauvegarde de données, etc.
FreeDOS est un système d'exploitation léger et rapide qui peut être utilisé sur des ordinateurs plus anciens ou sur des machines virtuelles. Il est distribué sous licence GPL (General Public License), ce qui signifie qu'il peut être utilisé gratuitement, copié, modifié et distribué librement.
# Installer FreeDOS
L'installation de FreeDOS peut varier en fonction de l'utilisation prévue et du matériel de votre ordinateur. Voici les étapes générales pour installer FreeDOS sur un ordinateur :
- Téléchargez la dernière version de FreeDOS sur le site officiel (https:*www.freedos.org/download/).
- Créez une clé USB bootable avec l'image ISO de FreeDOS en utilisant un logiciel de création de clé USB bootable, comme Rufus.
- Insérez la clé USB bootable dans l'ordinateur sur lequel vous souhaitez installer FreeDOS, puis redémarrez l'ordinateur.
- Dans le BIOS de l'ordinateur, modifiez l'ordre de démarrage pour démarrer à partir de la clé USB bootable.
- Suivez les instructions d'installation de FreeDOS qui s'affichent à l'écran. Vous pouvez choisir d'installer FreeDOS sur un disque dur ou de l'utiliser en mode Live CD à partir de la clé USB.
- Après l'installation, redémarrez l'ordinateur et vous devriez voir l'invite de commande de FreeDOS.
<callout icon="fa fa-slack">
Une image FreeDOS pèse 232.9 MiB, ce qui est beaucoup plus grande qu'une disquette MS-DOS standard, qui avait une capacité de stockage maximale de 1,44 Mo. Les disquettes MS-DOS étaient utilisées comme supports de stockage amovibles pour les ordinateurs personnels dans les années 80 et 90, avant que les clés USB et les disques durs externes ne deviennent plus populaires.
L'image de disque de 232.9 MiB est destinée à être utilisée pour installer FreeDOS sur un disque dur ou une clé USB, plutôt que pour l'utiliser directement à partir d'une disquette.
Il est intéressant de noter que la capacité de stockage des disquettes a augmenté au fil des ans, passant de 160 Ko pour les premières disquettes de 5,25 pouces à 1,44 Mo pour les disquettes de 3,5 pouces utilisées à la fin des années 90. Cependant, leur utilisation est aujourd'hui très limitée en raison de leur faible capacité de stockage et de leur fiabilité limitée.
</callout>
# Bibliographie
Installer FreeDOS dans une machine virtuelle VirtualBox
http:*wiki.freedos.org/wiki/index.php/VirtualBox