Comme je n’avais plus manipulé ce type d’objet depuis un certain temps, je me suis replongé dans ce petit tutoriel, mais je lui ai trouvé un manque que je m’apprète à combler ici même.

La manipulation des SLIST est très aisée lorsque l’on a la possibilité de déclarer sa liste de manière globale, il suffit alors, dans chaque fonction, d’appeler la “tête de liste”, souvent appelée head, via les multiples macros présentes dans queue.h.
J’ai ecrit, toujours dans la documentation sus-citée, un minuscule passage sur la façon d’utiliser les SLIST avec les macros SLIST_FIRST et SLIST_NEXT, mais je m’aperçois qu’on ne se rend pas compte de leur utilité.

Prenons le cas suivant, je veux créer une liste chainée de type SLIST dans une fonction. Je souhaite pouvoir ballader cette liste de fonctions en fonctions, et evidemment, la libérer à la fin de mes travaux. Nous utiliserons notre liste de la sorte :

/* headers et diverses déclarations */
#include <sys/queue.h>

typedef struct Mastruct {
	int id;
	char *element;
	SLIST_ENTRY(, Mastruct) next;
} Mastruct;

/* plein de trucs */

Mastruct *
initialisation(int id, const char *str)
{
	Mastruct *mesdatas;

	/* on déclare la tête de liste */
	SLIST_HEAD(, Mastruct) datahead;
	/* on l'initialise à NULL */
	SLIST_INIT(&datahead);

	if ((mesdatas = malloc(sizeof(Mastruct)) == NULL)
		err("malloc error");

	mesdatas->id = id;
	if (str != NULL) {
		mesdatas->element = strdup(str);
	} else {
		mesdatas->element = NULL;
	}

	/* on accroche la structure fraichement allouée à la tête de liste */
	SLIST_INSERT_HEAD(&datahead, mesdatas, next);

	/* et on renvoie le premier élément de datahead, ici, mesdatas*/
	return SLIST_FIRST(&datahead);
}

Dans ce cas de figure, nous ne renvoyons pas la tête de la liste mais simplement le premier élément de la liste chainée. Pour parcourir simplement cette liste, nous utiliserons la macro SLIST_NEXT :

	Mastruct *mesdatas, *p;

	/* des trucs */

	mesdatas = initialisation(id, unechaine);

	for (p = mesdatas; p != NULL; p = SLIST_NEXT(p, next))
		printf("%d -> %s", p->id, p->element);

De la même façon, on pourra simplement libérer cette liste simplement chainée grace à une boucle de ce type :

void
free_datas(Mastruct *mesdatas)
{
	struct Mastruct *p;

	/* on boucle tant que le nouveau chainon n'est pas nul */
	while (mesdatas != NULL) {
		/* on sauvegarde le prochain chainon */
		p = SLIST_NEXT(mesdatas, next);
		/* on libère le contenu */
		free(mesdatas->element);
		/* puis le chainon courant */
		free(mesdatas);
		/* puis on fait pointer la variable principale vers la sauvegarde */
		mesdatas = p;
	}
}

Désormais, avec un effort minimum, nous voici en mesure de très simplement créer des listes de données rapides et dynamiques.

Source Code Secrets: The Basic Kernel” de William et Lynne Jolitz, ou l’histoire “codée” du portage de BSD vers l’architecture i386.

Je l’ai rapidement feuilleté, et ce bouquin est encore plus fascinant que je le pensais: il s’agit de l’explication, pratiquement ligne-à-ligne de ce portage, code et schémas d’archi à l’appui. C’est un peu comme un conte de fées quoi.

Pour Noël, nourrissant l’illusion que je vais reussir à m’accrocher à un projet plus de 2 mois, j’ai topé le domaine beastiebox.org, qui, aussi surprenant que cela puisse paraitre, était disponible. Alors plutot que de se le faire squatter hein…

Toujours sur ce sujet, j’ai reçu juste avant mon départ un mail de monsieur Thorsten Glaser du projet MirBSD qui me demandait si je pouvais intégrer mksh dans BeastieBox. C’est chose faite, mais sa compilation est désactivée par défaut car ce shell, un clone léger du Korn Shell, pèse tout de même autour de 160K, soit deux fois plus que sh(1) dans sa version BBOX. J’ai par contre été assez bluffé par la qualité du code de mksh, ultra propre, ultra portable, je vous le recommande :)

J’ai beaucoup apprecié lire chez Hubert un peu de pub pour mon projet du moment, mais je me rend compte que le principal objectif de BBOX, reduire la taille des outils UNIX indispensables, ne semble pas être assez explicite sur la page du projet.

Enfin, J’ai commandé la relique “Source Code Secrets: The Basic Kernel by Jolitz, Lynne G.; Jolitz, William”, ou l’histoire du premier portage de 4.4BSD vers i386. Je l’attend impatiemment…

Mon approche est un tantinet differente du fonctionnement de BusyBox. Afin de permettre l’écriture simple et rapide de plugins, je supporte deux modes, un mode statique (ala BB), et un mode dynamique grace aux interfaces DLFCN(3).

Ainsi, toujours sur le modèle de BB, un ln -s du programme principal vers la fonction souhaitée appellera :

• dans le cas d’une compilation dynamique, le symbole “fonction” dans la librairie libfonction.so, par exemple command_ifconfig dans libifconfig.so
• dans le cas d’une compilation statique, le symbole souhaité dans le propre executable en utilisant une astuce décrite ici

Afin de viser la plus petite taille possible pour l’ensemble, je suis en train de porter les outils de base d’un NetBSD 1.0, et aussi surprenant que cela puisse paraitre, le portage est relativement simple.

Si d’aucuns dans l’assemblée sont interessés par le projet, au doux nom de BeastieBox, les premiers morceaux de code sont disponibles sur SourceForge.

Update

Et maintenant, ça boot !

Update

Le projet a maintenant sa page officielle