Files

T

2026-05-16 23:57:04 +02:00

16 KiB

Raw Blame History

Voici une version améliorée et plus pédagogique de ta documentation, avec les sections demandées sur l'installation en VM sous Linux, le montage d'images de disquettes et le partage de dossier.

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 :

# 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) :

qemu-img create -f qcow2 freedos.qcow2 2G

Démarre l'installation depuis l'ISO :

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 :

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

sudo apt install virtualbox    # Debian/Ubuntu

Nouvelle machine → Type : Other, Version : DOS
RAM : 64 Mo, Disque dur : 2 Go (VDI, dynamiquement alloué)
Dans les paramètres de la VM → Stockage → ajoute l'ISO de FreeDOS au lecteur optique
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 :

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 :

Ajoute un contrôleur Floppy s'il n'existe pas
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 :

# 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 :

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 :

# 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 :

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 :

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 :

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 :

mkisofs -o transfert.iso -J -R /chemin/vers/fichiers

Snapshots QEMU pour expérimenter sans risque :

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.

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/

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 :

#!/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 :

chmod +x ~/bin/freedos-vm.sh

Utilisation typique

# 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 :

-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 :

[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.

16 KiB Raw Blame History Unescape Escape