Il s'agit du correctif de commande qui peut être exécuté dans le fournisseur d'hébergement gratuit OnWorks à l'aide de l'un de nos multiples postes de travail en ligne gratuits tels que Ubuntu Online, Fedora Online, l'émulateur en ligne Windows ou l'émulateur en ligne MAC OS.
PROGRAMME:
Nom
patcher - un outil de maintenance des correctifs
SYNOPSIS
patcher [-n ] [ ]
Éditer dans le cadre du patch .
patcher -r Actualiser le patch actuel.
patcher [-f] -b Recule d'un patch au précédent.
patcher [-f] -b
Revenir en série jusqu'à ce que nous soyons à .
patcher [-f] -b
Reculer patchs en série.
patcher -a Appliquer le patch suivant de la série.
patcher -a Appliquez tous les patchs de la série jusqu'à ce que nous ayons atteint .
patcher -a Postulez ensuite patchs de la série.
patcher -n [-p ] -je
Importer un fichier diff externe dans patch . Déshabiller niveaux
à partir des noms de répertoire. Veuillez noter que le patch autorise '-p1', mais nous
seulement '-p 1'.
patcher [-f] [-n ] [-p ] -je
Importer un fichier diff externe dans patch . Déshabiller niveaux
à partir des noms de répertoire. Veuillez noter que le patch autorise '-p1', mais nous
seulement '-p 1'.
CONCEPT
Patcher est un script perl que j'utilise pour gérer les correctifs. C'est assez puissant, facile à
utilisation, et rapide.
Patcher garde une trace des fichiers que vous modifiez. Il peut ensuite générer des correctifs à partir de votre
changements, pas besoin de manipuler l'outil diff manuellement.
Vous pouvez avoir plus d'un enregistrement de modifications de fichiers, nous appelons cela un correctif. Un patch est
quelque chose que le pièce(1) la commande peut s'appliquer.
Les patchs peuvent être empilés en série, ils définissent l'ordre dans lequel ils doivent être appliqués. Patcher
conserve les informations sur la série ainsi que les informations sur les correctifs appliqués et les
pas.
DESCRIPTION
Plus tard, nous aurons une procédure pas à pas, mais permettez-moi d'abord d'expliquer les modes de fonctionnement de base de
patcher :
Le Montage fichiers
Lorsque vous appelez patcher avec un nom de fichier, patch fera une sauvegarde de ce fichier (si le fichier
existe). Vous pouvez maintenant créer ou modifier le fichier. Plus tard, vous pouvez demander à patcher de créer un
diff unifié avec tous vos changements.
La création unifiée différences
Appelez simplement "patcher -r" et vous obtiendrez un diff unifié de tous vos ajouts, modifications
et suppressions. Le diff sera stocké dans .patches/ .pièce. C'est sous une forme qui
permet une application directe via pièce(1) ou, bien sûr, via "patcher -i".
Chaque fois que vous faites "patcher -r" votre .patches/ Le fichier .patch est actualisé.
Retour ande a pièce
Pour révoquer vos modifications et revenir à la version précédente, saisissez simplement "patcher -b". Patcher
veillera à ce que vous ne perdiez pas vos modifications en vous demandant de créer un diff si
quelque chose a changé depuis la dernière actualisation. Vous pouvez utiliser -f (ou --force) patcher pour aller
de retour quand même.
Vous pouvez annuler plus d'un patch en spécifiant un numéro et un nom de patch après -b.
Réappliquer a pièce
Avec "patcher -n -a" on peut appliquer un patch géré déjà existant. A
le correctif géré est un correctif déjà stocké dans le répertoire .patches et mentionné
dans le fichier .patches/series. Patcher teste si le patch s'appliquerait sans problème et
l'applique. Si le correctif est rejeté, vous pouvez utiliser -f (ou --force) pour appliquer le correctif
de toute façon.
Vous pouvez appliquer plusieurs correctifs en spécifiant un numéro et un nom de correctif après -a.
Importation externe patchs
Parfois, vous avez un patch externe. C'est l'opposé d'un correctif géré, le correctif est
pas stocké dans le répertoire .patches. En l'important, il deviendra un patch géré.
Importez le patch simplement avec -i . Vous pouvez utiliser -p pour spécifier le répertoire
niveau, similaire au -p possibilité de pièce(1). Mais gardez à l'esprit que nous avons besoin d'un
espace entre -p et le nombre.
Normalement, seuls les correctifs propres seront importés. Pour importer un correctif qui crée des rejets, utilisez
-f (ou --force). Vous verrez une liste de fichiers où le correctif ne s'est pas appliqué correctement, corrigez le
problèmes manuellement.
Plus tard, vous pouvez utiliser "patcher -r" pour créer un patch propre.
INSTALLATION
Placez simplement le patcher quelque part sur votre chemin. C'est tout.
Pour chaque projet, Patcher requiert un répertoire spécial appelé ".patches". Ce sera
rechercher ce répertoire. S'il n'existe pas, Patcher le crée automatiquement.
INTERNES
Tout le travail s'effectue avec une seule arborescence de répertoires. Toutes les commandes sont invoquées à la racine de
cet arbre (À FAIRE : cela peut et doit changer). Patcher gère une "pile" de correctifs.
Chaque patch est un ensemble de modifications par rapport à l'arborescence de base plus les patchs précédents.
Tous les correctifs sont répertoriés, dans l'ordre, dans le fichier ".patches/series". Patcher ajoute des correctifs dans
ce fichier, mais ne supprime jamais les entrées. Vous pouvez éditer ce fichier avec un éditeur de texte, mais
veuillez ne le faire que si le correctif que vous supprimez n'est actuellement pas appliqué.
Tous les correctifs actuellement appliqués sont répertoriés dans le fichier ".patches/applied". Le patcher gère
ce fichier, il n'est pas nécessaire que vous éditiez ce fichier manuellement.
Chaque patch affecte un certain nombre de fichiers dans l'arborescence. Ces fichiers sont répertoriés dans une liste de fichiers
nommé ".patches/*.files". Patcher les gère. Lorsque vous annulez un correctif, ce fichier sera
supprimé. Ou, en d'autres termes, ce fichier n'existe que pour les correctifs appliqués. Il n'est utilisé que par
"patcher -r".
Les correctifs sont placés dans des fichiers ".patches/*.patch". Ce sont toujours des différences unifiées avec -p1
comme patchlevel. Vous pouvez alors copier n'importe où, le pièce(1) l'utilitaire les lira sans
problèmes.
En option, vous pouvez mettre des descriptions pour les correctifs dans des fichiers nommés ".patches/*.txt".
Ainsi, pour un patch particulier "mon-premier-patch", ce qui suit existera :
- Une entrée "my-first-patch.patch" dans ".patches/series".
- Une entrée "my-first-patch" dans ".patches/applied" (si elle est actuellement appliquée)
- Un fichier ".patches/my-first-patch.files" qui contient les noms des fichiers que my-
le premier correctif modifie, ajoute ou supprime
- Un fichier ".patches/my-first-patch.patch", qui est le diff de contexte, en gros le principal
sortie de patcher.
- En option un fichier ".patches/my-first-patch.txt" qui contient le changelog du patch,
description ou ce que vous y mettez.
PARCOURS
Commençons.
Allez dans /usr/src/linux (ou ailleurs).
Commençons maintenant par modifier certains fichiers sources :
patcher -n mon-patch kernel/sched.c
OK, le patcher a copié kernel/sched.c dans kernel/sched.c~my-patch pour vous, le programme a aussi
fait de la magie dans le répertoire .patches, qui ne nous intéresse plus maintenant.
Maintenant, modifiez le bit kernel/sched.ca.
Nous sommes maintenant prêts à documenter le correctif :
Créer .patches/my-patch.txt
Générez maintenant un patch :
correctif -r
Cela générera ".patches/my-patch.patch". Jetez un œil à ce fichier.
Maintenant, nous supprimons notre modification de sched.c en revenant en arrière :
correctif -b
Regardez où nous en sommes maintenant :
correctif -s
Ajoutons maintenant un autre fichier à my-patch. Tout d'abord, nous réappliquons le correctif :
correctif -a
Modifiez maintenant un deuxième fichier :
patcher noyau/printk.c
Notez qu'ici nous avons donné à patcher un seul argument, sans options de ligne de commande. Cette
dit toujours au patcher d'ajouter un autre fichier au patch actuel.
Modifier kernel/printk.c
Rafraîchir mon patch :
correctif -r
Commencez maintenant un deuxième patch :
patcher -n mon-second-patch kernel/sched.c
Ici, nous avons un nom de fichier dans la ligne de commande pour patcher, nous éditons donc un fichier. Mais maintenant nous
a spécifié un nom de patch avec -n. Cela a dit à Patcher de créer un nouveau patch. Maintenant patcher
gère deux patchs, "my-patch" et "my-second-patch".
Editer kernel/sched.c, pour apporter quelques modifications à my-second-patch
Générer mon deuxième patch :
correctif -r
Jetez un œil à ".patches/my-second-patch.patch".
Notez également que "my-second-patch.patch" a été ajouté au fichier de la série. Quand tu
commencer manuellement un patch, il sera automatiquement mis dans le fichier de série.
De cette façon, l'ensemble est empilable. Si vous avez appliqué quatre patchs, dites
"patch-1", "patch-2", "patch-3" et "patch-4", et si patch-2 et patch-4 se touchent tous les deux
kernel/sched.c alors vous aurez :
kernel/sched.c~patch-2 Copie originale, avant patch-2
kernel/sched.c~patch-4 Copie avant patch-4. Contient les modifications du patch-2
kernel/sched.c Copie de travail actuelle. Contient les modifications du patch-4.
Cela signifie que vos en-têtes diff contiennent "~patch-name", ce qui est pratique
Documentation.
Pour terminer notre visite, nous supprimons les deux patchs :
correctif -b
correctif -b
C'est à peu près ça, vraiment.
Utiliser patcher en ligne à l'aide des services onworks.net
