2009/10/20

CBlog bientôt une release donc un ports

Une nouvelle fonctionnalité vient de faire son apparition dans CBlog : la possibilité de pouvoir désactiver les commentaires via un simple "Comments: false" dans l'entête d'un message (à la demande de rhaamo - oui il y a au moins deux utilisateurs de CBlog :)).

En fait c'est encore mieux que ça, un nouveau champs Posts.nb.allow_comments est disponible dans le HDF (datafile) du coup vous pouvez faire ce que vous voulez avec dans votre template, il correspond au contenu de l'entête Comments:. Dans le template d'exemple si il est égale à false, il n'affiche pas le formulaire de commentaires.

Il me reste deux fonctionnalités à implémenter pour faire une release 1.0 :

Bien sûr il reste toujours du nettoyage a faire pour rendre plus propre et robuste le code, de la documentation :)

En ce qui concerne CPlanet il n'y a plus que du nettoyage car je ne vois pour le moment aucun besoin de rajouter de fonctionnalitées.

Dans tous les cas dès la release venue, un joli ports FreeBSD fera son entrée.

Toute contribution est la bienvenue, surtout que pour le moment le code n'a été testé que sous FreeBSD.

2009/08/28

Reconstruire les paquets cassés

Voici un petit script ZSH pour rechercher les binaires systèmes qui ne trouvent pas les bibliothèques dont ils dépendent et les reconstruire en utilisant portmaster.

#!/usr/local/bin/zsh

typeset -a torebuild

rep=(/usr/local/bin/**/*(.))
rep+=(/usr/local/lib/**/*.so(.))
rep+=(/usr/local/sbin/**/*(.))

for bin ($rep) {
    file $bin | grep -q "ELF" && {
        ldd =$bin | grep -q "not found" && {
            torebuild+=$(pkg_info -qoW $bin)
        }
    }
}
portmaster -f ${(u)torebuild}

2009/08/27

Convertir l'arbre CVS des ports en git

Voulant pouvoir jouer tranquillement avec les ports via git, je me suis dit que j'allais convertir les CVS des ports en git tout simplement.

Récupération du CVSROOT

Créer le fichier de config suivant pour csup

*default host=cvsup.free.org
*default base=/var/db
*default prefix=/usr/portsdev
*default release=cvs
*default delete use-rel-suffix

*default compress

ports-all

Puis récupérer le cvsroot :

$ csup cvsroot-supfile

Récupération et construction de parsecvs

Récupérer les sources

$ git clone git://anongit.freedesktop.org/~keithp/parsecvs

Contruire les lib git qui seront nécessaires, sans les installer.

$ make -C /usr/ports/devel/git

Modifier le Makefile de parsecvs pour qu'il ressemble à celui-ci

GCC_WARNINGS1=-Wall -Wpointer-arith -Wstrict-prototypes
GCC_WARNINGS2=-Wmissing-prototypes -Wmissing-declarations
GCC_WARNINGS3=-Wnested-externs -fno-strict-aliasing
GCC_WARNINGS=$(GCC_WARNINGS1) $(GCC_WARNINGS2) $(GCC_WARNINGS3)
GITPATH=/usr/ports/devel/git/work/git-1.6.4
CFLAGS=-O2 -g $(GCC_WARNINGS) -I$(GITPATH) -DSHA1_HEADER='<openssl/sha.h>' -I/usr/local/include
LIBS=-L$(GITPATH) -lgit $(GITPATH)/xdiff/lib.a -lssl -lcrypto -lz -liconv -L/usr/local/lib
YFLAGS=-d -l
LFLAGS=-l

OBJS=gram.o lex.o parsecvs.o cvsutil.o revdir.o \
        revlist.o atom.o revcvs.o git.o gitutil.o rcs2git.o \
        nodehash.o tags.o tree.o

parsecvs: $(OBJS)
        cc $(CFLAGS) -o $@ $(OBJS) $(LIBS)

$(OBJS): cvs.h
lex.o: y.tab.h

lex.o: lex.c

y.tab.h: gram.c

clean:
        rm -f $(OBJS) y.tab.h gram.c lex.c parsecvs
install:
        cp parsecvs edit-change-log ${HOME}/bin

Construction et installation de parsecvs

$ gmake
$ cp parsecvs edit-change-log /usr/local/bin

Conversion du CVSROOT en git

$ cd /usr/portsdev/ports

Si vous utilisez zsh :

$ print -l **/*,v | parsecvs

Sinon

$ find . -name "*,v" -print | parsecvs

Attention c'est long, très long : 17h30 sur un Q6600 avec 4Go de RAM et un disque SATA 150 en zfs Le facteur principal est la vitesse du disque dur en effet la consommation de RAM et CPU est négligeable comparée à l'utilisation disque.

Une fois cette étape terminée vous disposez d'un répertoire git fonctionnel mais énorme : plus de 4Go

Repack du rep

$ git repack -a -f -d -l

Cette étape est très longue aussi et dépend de la vitesse de votre disque pour beaucoup. Ici ça a pris 28h50

Une fois cette étape finie vous voila avec un répertoire git de 400M ce qui est quand même beaucoup mieux.

Préparation pour les mises à jour

Alors comme cvsps foire prodigieusement souvent via git cvsimport, il faut le lancer de côté :

$ export CVS_RSH=ssh
$ export CVSROOT=anoncvs@anoncvs.fr.FreeBSD.org:/home/ncvs
$ cvsps -x --norc -u -A ports > /tmp/cvsps.out

Mise à jour de l'arbre git

$ git cvsimport -o master -P /tmp/cvsps.out ports

Vous voila avec un git à jour, pour continuer à mettre à jour, recommencer les deux dernières étapes.

En un seul coup pour zsh :

$ git cvsimport -o master -P <(cvsps -x --norc -u -A ports) ports

2009/08/27

zcp un wrapper pour cp

L'autre jour sidh me demandait si je n'avais rien en zsh pour pouvoir suivre la progression d'un cp volumineux et je n'avais rien, mais j'ai trouvé l'idée intéressante. Un petit man cp plus tard, je me rend compte que le cp de FreeBSD il est beau et bien foutu, en lui envoyant un SIGINFO il nous dis ce qu'il fait et ou il en est. De là a wrapper tout dans un petit script zsh il n'y avait qu'un pas.

De plus zsh permet de créer un tty virtuel (zpty) dans lequel on peut exécuter des commandes et interagir, du coup, voici un petit script bien pratique :

#!/usr/local/bin/zsh
setopt extendedglob
zmodload zsh/zpty
zpty copy "cp $@ 2>&1"     
ZPTYPID=${${=${(M)${(f)"$(ps -o pid,ppid,command)"}:#[[:space:]]#[[:digit:]]##[[:space:]][[:space:]]#$$*zsh*}}[1]}
CPPID=${${=${(M)${(f)"$(ps -o pid,ppid,command)"}:#[[:space:]]#[[:digit:]]##[[:space:]][[:space:]]#${ZPTYPID}*cp*}}[1]}
line=""
while [ : ]
do
    zpty -rt copy out
    if [[ $#out -gt 0 ]]
    then
        newline=${${=${out}}[0,-2]}
        percent=${${=${out}}[-1]}
        if [[ -z $line || "x$newline" != "x$line" ]]
        then
            [[ -n $line ]] && print "${line}: done"
            line=$newline
            print "${line}: ${(l: ::4:)percent}\c"
        else
            print "\r${line}: ${(l: ::4:)percent}\c"
        fi
    fi
        kill -SIGINFO $CPPID 2>/dev/null || break
done
[[ -n $line ]] && print "${line}: done"
zpty -d copy

la sortie donne : # zcp toto.iso bla/ toto.iso -> bla/toto.iso: 48%

UPDATE: Apparemment ça ne fonctionne qu'avec zsh 4.3.10+

2009/08/05

Du nouveau sous le capot

Depuis quelques temps déjà je me suis mis à essayer de faire du C pour de vrai. Pour cela il me fallait un vrai projet, alors je me suis dit tiens un planet BSD pour les BSDistes actifs francophone ça sera pas mal, du coup j'ai codé CPlanet. Ce qui m'a fait découvir une bibliothèque vraiment choupi s'il en ait pour faire du Web en C : clearsilver.

Résultat : planet.etoilebsd.net

CPlanet est donc un aggrégateur de flux rss et atom (merci libmrss) qui génère un site statique. Il utilise un fichier de conf vraiment simplissime. C'est la solution pour qui souhaite mettre en place un planet sans contrainte, puisque celui-ci n'utilise aucun langage de script, ni de base de données, juste un tout petit binaire.

Tout ça m'a bien motivé alors vlati pas que je me dis que blosxom c'est sympa, mais ça fait pas tout ce que je veux et en plus ça m'oblige à ajouter des lib perl de partout pour les plugins. Je ressors donc mon plus beau vim, mon petit clearsilver tout choupi qui ne me quitte plus et je me lance. Cerise sur le gâteau, je découvre discount, une jolie lib pour transformer du texte en html en suivant la syntaxe markdown.

Resultat : un moteur de blog en C (sous la forme d'un cgi) qui ne nécessite donc pas de langage de script, qui ne nécessite pas non plus de base de donnée toute bloatée. Il reprend le format de post de bloxsom si vous l'utilisiez avec les plugins tags et markdown.

CBlog est bien sûr libre sous license BSD.

Ce blog est donc maintenant propulsé par CBlog version de développement j'ai changé mes rewrite rules afin que le minimum de liens soit cassé.

Et non pour le mauvaise langue ce n'est pas à cause de cblog que mon site de sera pas disponible pendant 15 jours à compter de samedi, c'est pour cause de vacances et de coupure de machine.

EDIT CPlanet et CBlog sont écologiques !!! comme ils ne sont pas plein de bloat de partout, ils vous font économiser du CPU donc des Watts, alors il n'y a aucune raison de ne pas les utiliser.

PS: si vous avez des flux pour le planet à proposer je suis preneur à noter que si les gens sur le planet doivent être francophone, leurs posts n'ont pas besoin de l'être.

2009/06/11

Zsh avec Ncurses c'est beau

Depuis un moment déjà zsh a un nouveau module zsh/curses qui permet de faire de belles interface en ncurses directemet en script zsh. Depuis le temps que je voulais essayer, j'ai fini par me décider.

Pour mon premier bout de zsh/curses, j'ai décider de me faire un mixer tout joli utilisant mixer(8), je m'inspire donc de rexima dont j'aime bien l'ui et je suis donc parti pour me faire un zmixer.

De plus j'ai découvert que l'on pouvais faire du ZSH avec une syntaxe "un peu objet" alors voila le code obtenu :

#!/usr/bin/env zsh

zmodload zsh/curses

zmix()
{
    local mixer
    local -a zmix_dev
    integer y
    integer posy
    integer length
    #get list of devices
    zmix.draw()
    {
        zcurses addwin main $(( $LINES - 2 )) $(( $COLUMNS - 2 )) 1 1
        title="zmixer"
        zcurses move main 1 $(( ($COLUMNS - 2 - $#title) / 2 ))
        zcurses string main $title
        y=4
        for dev ($zmix_dev);do
            y+=1
            zcurses move main $y 5
            zcurses string main $dev
            zcurses move main $y 15
            zcurses string main ":"
            # Set the recording device
            if [[ "x$dev" = "x$record" ]]; then
                zcurses addwin record 1 1 $(( y + 1 )) 4 main
                zcurses attr record red/black bold
                zcurses string record "*"
            fi
            level=${${(f)"$(/usr/sbin/mixer -s $dev)"}[(w)2]}
            numlevel=${${(s#:#)level}[1]}
            zcurses move main $(( y )) 17
            line="|"
            zcurses string main "[${(r:$length::-:)${(l:$(( numlevel / 2))::=:)line}}] ($level)"
        done
        if (( posy == 0 ));then
            posy=5
        fi
        zmix.sel $posy
        zcurses refresh main
    }
    zmix.listen()
    {
        while true;do
            if [[ -z $key ]];then
                zcurses input main REPLY key
            fi
            newkey=$key
            key=
            case $newkey in
                (UP)
                if (( posy <= 5 )); then
                    zmix.sel $y
                else
                    zmix.sel $(( posy - 1 ))
                fi
                ;;
                (DOWN)
                if (( posy >= y )); then
                    zmix.sel 5
                else
                    zmix.sel $(( posy + 1 ))
                fi
                ;;
                (LEFT)
                dev=$zmix_dev[$(( posy - 4 ))]
                mixer $dev -1 2>&1 >/dev/null
                zmix.redraw $dev
                ;;
                (RIGHT)
                dev=$zmix_dev[$(( posy - 4 ))]
                mixer $dev +1 2>&1 >/dev/null
                zmix.redraw $dev
                ;;
                ("")
                if [[ -z $REPLY ]];then
                    zcurses delwin record
                    zcurses delwin main
                    zcurses clear stdscr redraw
                    zcurses refresh stdscr
                    zmix.draw
                else
                    break
                fi
                ;;
            esac
        done
    }
    zmix.sel()
    {
        zcurses move main $posy 0
        zcurses string main "  "
        posy=$1
        zcurses move main $posy  0
        zcurses string main "->"
        zcurses refresh main
    }
    zmix.redraw()
    {
        dev=$1
        level=${${(f)"$(/usr/sbin/mixer -s $dev)"}[(w)2]}
        numlevel=${${(s#:#)level}[1]}
        zcurses move main $posy 16
        zcurses clear main eol
        level=${${(f)"$(/usr/sbin/mixer -s $dev)"}[(w)2]}
        numlevel=${${(s#:#)level}[1]}
        zcurses move main $posy 17
        line="|"
        zcurses string main "[${(r:$length::-:)${(l:$(( numlevel / 2))::=:)line}}] ($level)"
        zcurses move main $posy 2
        zcurses refresh main
    }
    #Constructor
    {
        length=50
        mixer=(${=${(f)"$(/usr/sbin/mixer -S)"}})
        for line ($mixer);do
            [[ -n ${line:#*:*:*} ]] && continue
            zmix_dev+=${${(s#:#)line}[1]}
        done
        record=$mixer[$#mixer]
        zcurses init
        zmix.draw
        zmix.listen
    } always
    {
        #cleanup all windows
        for win ($zcurses_windows);do
            [[ -z ${win:#(main|stdscr)} ]] && continue
            zcurses delwin $win
        done
        zcurses delwin main
        zcurses end
    }
}
zmix

Je sais pas vous mais moi je trouve ça beau.

Le résultat en image :

zmixer

EDIT: Promis dès que ça sera plus propre ça ira dans zen

2009/05/27

Migrer sur du Full ZFS

Depuis peu : les derniers commit en -STABLE ont eu lieu ce WE, il est possible d'avoir un FreeBSD 100% en ZFS, avant il y avait une solution qui consistait à passer ses disques du format MBR au format GPT, mais nous pouvons maintenant le faire directement sur du MBR.

De plus il est possible de booter sur des RAID-Z ou des MIRROR zfs.

Attention : la manipulation suivante doit se faire avec un système 7-STABLE ou 8-CURRENT très récent, de plus il faut rajouter l'option LOADER_ZFS_SUPPORT=YES dans le /etc/src.conf ou /etc/make.conf suivant les goûts afin que le loader sache travailler sur du ZFS.

Dans le cas présent nous allons donc migrer un système FreeBSD-Current tout frais mono-disque d'une installation UFS vers ZFS. Dans mon cas je voulais changer le disque dur au passage donc tout est parfait.

Création du POOL

Après avoir ajouter le disque (ici ad6) dans la machine, et de l'avoir vidé de toutes ses éventuelles partitions, nous allons créer notre zpool, il est donc possible ici de faire du mirror ou des raidz :

$ zpool create tank ad6
$ zpool export tank

Ajout de ZFSBOOT dans le mbr

$ dd if=/boot/zfsboot of=/dev/ad6 bs=512 count=1
$ dd if=/boot/zfsboot of=/dev/ad6 bs=512 skip=1 seek=1024

Si vous voulez booter sur un mirror zfs n'oubliez pas de faire la même chose sur l'autre disque.

Réactivation du pool

$ zpool import tank

Vous pouvez maintenant créer tous les FS que vous voulez dedans. attention si vous décidez de créer des FS spécifique pour /usr ou /var, vous devrez changer le mountpoint après un reboot en mode single sur le nouveau disque ZFS.

dans mon cas j'ai créé un swap de 1G :

$ zfs create -V 1g tank/swap
$ zfs set org.freebsd:swap=on tank/swap

La dernière option permet d'activer le swap automatiquement au boot lors de l'activation du zpool tank.

Et comme les checksum ça sert à rien sur du swap :

$ zfs set checksum=off tank/swap

migration des données

Pour migrer les données vous avez tout le choix des outils habituels, dans mon cas j'ai pris rsync ce coup ci et j'y suis allé gaiement à coup de rsync, par exemple :

$ rsync -av /boot /tank
$ ...
$ rsync -av /var /tank

En ne migrant pas bien entendu /dev ou autre FS "particulier".

Finalisation

pour finir il faut vous assurez que

si ce dernier n'y est pas ou que vous voulez le recréer par précaution :

$ zpool export tank && zpool import tank
$ zfs mount -a
$ cp /boot/zfs/zpool.cache /tank/boot/zfs/zpool.cache

Si tout ça est bon, il ne nous reste plus qu'à préciser à votre zfs quel est votre FS de boot

$ zpool set bootfs=tank tank

et Enfin de ne pas spécifier de point de montage pour tank :

$ zfs set mountpoint=legacy tank

c'est bon vous pouvez redémarrer sur le nouveau disque en 100% ZFS et supprimer votre disque UFS.

2009/04/29

Colorize la vie

Blosxom est très sympathique, très simple à utiliser, dispose de plein de plugin bien foutu, mais j'avais quand même un reproche à lui faire : impossible de trouver un plugin de colorisation syntaxique.

Bref je me dis que ça doit pas être trop compliqué à faire, alors je sors mon plus beau vim et je m'apprête à en code un moi même.

Un petit tour sur le CPAN et je trouve deux projet permettant de mettre des belle couleurs sur du texte :

Je choisis le second car Text::VimColor fait des appels système à vim ce qui ne me plait pas. Ensuite je jette un oeil sur la doc développeur de blosxom, et je me rends vite compte que c'est très très simple de faire de nouveau plugin.

Pour la rédaction j'utilise Markdown, celui-ci génère des blocs de code html entre les balises <pre><code>...</code></pre>, Il ne me reste plus qu'a récupérer le contenu de ces balises, positionner un marqueur pour le choix du langage, et à passer le tout dans la Syntax::Highlight::Engine::Kate, puis de le remettre dans la page d'origine.

Ce qui donne colorize le marquer à mettre en début de bloc est [_langage_], la liste des langages est disponibles dans la doc de Syntax::Highlight::Engine::Kate

2009/04/29

On Change !!

J'en avais ras le bol de l'hébergement Free, j'avais surtout marre de ne pas pouvoir éditer mes billets en vim proprement sans passer par des outils/add-ons tordus, j'ai donc mis un petit blosxom directement chez moi, après l'ajout de quelques plugins : antispam, tags, tagcloud, metaclear, metamail, paging, entries_index, Markdown et writeback, je me retrouve avec un beau blog en perl pour lequel j'édite les news en vim directement, que demande le peuple.

J'ai quand même du me coder moi même un petit plugin pour faire de la colorisation syntaxique des bloques de codes, mais quoi de plus simple avec perl et Syntax::Highlight::Engine::Kate.

Un petit script perl maison pour importer les données de dotclear via l'interface XMLRPC :

use Data::Dumper;
use Encode;
use Date::Manip;
use HTML::WikiConverter;
use RPC::XML::Client;
use RPC::XML;
use strict;

my $xmlrpc = RPC::XML::Client->new('http://baptux.free.fr/index.php?xmlrpc/default');
my $request = RPC::XML::request->new("metaWeblog.getRecentPosts",RPC::XML::string->new("1"),RPC::XML::string->new("bapt"),RPC::XML::string->new("secret"),RPC::XML::int->new(25));
my $result=$xmlrpc->send_request($request);
my %entries={};
for my $value (@{$result->value}) {
        my $filename=encode("utf-8",decode("iso-8859-1",$value->{title}));
        my $title=encode("utf-8",decode("iso-8859-1",$value->{title}));
        $filename =~ s/\s+/_/g;
        $filename =~ s/é/e/g;
        $filename =~ s/è/e/g;
        $filename =~ s/à/a/g;
        $filename =~ s/"//g;
        $filename =~ s/'//g;
        $filename =~ s/\(//g;
        $filename =~ s/\)//g;
        open(FILE,">data/$filename.txt");
        print FILE "Title: $title\n";
        print FILE "Tags: ",$value->{mt_keywords},"\n\n";
        my $content = encode("utf-8",decode("iso-8859-1",$value->{description}));
        $content =~ s/<br\ \/>/<br>/g;
        my $wc = new HTML::WikiConverter( dialect => 'Markdown' );
        print FILE $wc->html2wiki( $content );
        close FILE;
        print $filename, $value->{dateCreated},"\n";
        my $date = ParseDate($value->{dateCreated});
        $entries{"/usr/local/www/virtualhosts/blog/data/$filename.txt"}=UnixDate($date,"%s");
}
open(ENTRIES,">plugins/state/.entries_index.index");
print ENTRIES Dumper \%entries;
close ENTRIES;

Ce script se connecte sur mon ancien blog récupère la liste des posts (25 car je n'en avais que 25) crée dans un répertoire data et fichier .txt pour chaque post, les convertis au format markdown et en utf8.

Afin de conserver les dates des posts, il crée aussi un fichier plugins/state/.entries_index.index contenant les dates epoch de création de chaque post.

Ce script n'est pas parfait j'ai du faire quelques manipulations à la main pour finaliser le formattage des posts, mais il fait quand même le plus gros du boulot.

Par contre j'ai perdu tous les commentaires, dommage.

Dans quelques jours je vous parlerai plus en détail du petit plugin de colorisation syntaxique

EDIT : oui je sais mon code perl est pas beau, on peut faire plus simple et beau mieux :)

EDIT2 : il n'y a pas de grosse base de donnée SQL qui pu derrière, juste du bon vieux flat file

2009/04/18

Changer le disque système sur FreeBSD

La manipulation suivante a été faite sur un FreeBSD 8-CURRENT récent "kern.osreldate: 800074" Je ne sais pas si elle fonctionne sur les versions 7.x out of box. Qui plus est gjournal pour la partition / pose des soucis sur les freebsd plus vieux que FreeBSD 7.2.

La disque système de ma machine commençait à faire des siennes dessus il y avait mon / et mon /home le reste était réparti sur les autres disques durs.

Je voulais donc changer de disque dur sans me prendre la tête (ie sans livecd, sans réinstaller) Comme c'est une machine perso je ne me suis pas pris la tête sur le partitionnement, le disque faisant 80Gio j'ai mis :

J'ai donc rajouté un disque de la même taille sur la machine (il m'en restait un qui traînait dans un coin), enfin n'importe quel disque aurait pu faire l'affaire.

Une fois la machine bootée je me retrouve avec mon nouveau disque (ad2) et mon ancien disque (ad3)

Préparation du disque ad2

Pour le fun je me suis dis que j'allais partitionner mon disque au format GPT, puisque c'est à la mode (ça sert à rien dans mon cas, mais je voulais jouer avec)

j'ai donc détruit le partionnement existant :

$ gpart destroy ad2

Puis recréer en précisant le système de partitionnement GPT

$ gpart create -s GPT ad2

Une vérification que tout c'est bien passé :

$ gpart show
=>       34  156301421  ad2  GPT  (75G)
    	 34  156301421        - free -  (75G)

Les BIOS classiques ne sont pas capable de booter sur du GPT, mais sous FreeBSD il y a une astuce qui marche impeccable

$ gpart add -b 34 -s 16 -t freebsd-boot ad2
$ gpart bootcode -b /boot/pmbr ad2
$ cp /boot/gptboot /tmp
$ dd if=/dev/zero bs=641 count=1 >> /tmp/gptboot
$ dd if=/tmp/gptboot of=/dev/ad2p1 bs=512

ainsi le système est bootable;

j'ai plus qu'à recréer mes partitions

$ gpart add -b 50 -s 20971520 -t freebsd-ufs ad2
$ gpart add -b 20971570 -s 4194304 -t freebsd-swap ad2
$ gpart add -b 25165874 -s 131135581 -t freebssd-ufs ad2

Vérification :

$ gpart show
=>       34  156301421  ad2  GPT  (75G)
	 34         16    1  freebsd-boot  (8.0K)
	 50   20971520    2  freebsd-ufs  (10G)
   20971570    4194304    3  freebsd-swap  (2.0G)
   25165874  131135581    4  freebsd-ufs  (63G)

maintenant j'active le gjournal pour les partitions ufs

$ gjournal label /dev/ad2p2
$ gjournal label /dev/ad2p4

On format le tout (pour rappel sous freebsd pas besoin de formatter les partitions swap

$ newfs -J -L root /dev/ad2p2.journal
$ newfs -J -L home /dev/ad2p4.journal

Le -L signifie que l'on écrit un label ainsi les partitions sont facilement montable grâce à GLABEL qui les représente sous la forme : /dev/ufs/LABEL

Migration des données

maintenant il s'agit de migrer le contenu des partitions / et /home sur les nouvelles le tout à chaud :

$ mkdir /newroot
$ mount -o async /dev/ufs/root /newroot
$ cd /newroot
$ dump -0uanL -f - / | restore -rf -
$ mkdir /home2
$ mount -o async /dev/ufs/home /home2
$ cd /home2
$ dump -0uanL -f - /home | restore -rf -

il faut pour finir modifier la fstab du nouveau root pour rajouter :

Le fichier /etc/fstab obtenu est donc :

# Device		Mountpoint	FStype	Options		Dump	Pass#
/dev/ad2p3		none		swap	sw		0	0
/dev/ufs/root		/		ufs	rw,async	1	1
/dev/ufs/bapt		/home	ufs	rw,async	1	1

Il ne reste plus qu'à rebooter dessus.

Pages : 1 2 3 4 5 6 7