Arch Build System Vad är Arch Build System Arch Build System är ett portliknande system för bygg - och förpackningssoftware från källkod. Medan Pacman är det specialiserade Arch-verktyget för binär pakethantering (inklusive paket som är uppbyggda med ABS), är ABS en samling verktyg för att kompilera källan i installerbara. pkg. tar. xz-paket. Vad är ett portliknande system Portar är ett system som används av BSD för att automatisera processen med att bygga programvara från källkod. Systemet använder en port för att ladda ner, packa upp, lappa, kompilera och installera den angivna mjukvaran. En port är bara en liten katalog på användarens dator, namngiven efter motsvarande programvara som ska installeras, som innehåller några filer med anvisningarna för att bygga och installera programvaran från källan. Detta gör att installera programvara så enkelt som att skriva gör eller göra installationen ren i portkatalogen. ABS är ett liknande begrepp ABS består av ett katalogträd (ABS-trädet) som ligger under varabs. Detta träd innehåller många underkataloger, var och en inom ett repo-namn och varje namnges av deras respektive paket. Detta träd representerar (men innehåller inte) alla officiella Arch-program. återvinnas via SVN-systemet. Du kan referera till varje paket-namngivna underkatalog som en ABS, ungefär som man skulle referera till en port. Dessa ABS (eller underkataloger) innehåller inte mjukvarupaketet eller källan utan snarare en PKGBUILD-fil (och ibland andra filer). En PKGBUILD är ett enkelt Bash build-skript en textfil som innehåller kompilerings - och förpackningsinstruktioner samt URL-adressen för den lämpliga källtarbaren som ska hämtas. (Den viktigaste delen av ABS är PKGBUILD.) Genom att utfärda inuti ABS makepkg-kommandot, sammanställs programvaran först och packas sedan i byggkatalogen. Nu kan du använda pacman (Arch Linux-pakethanteraren) för att installera, uppgradera och ta bort ditt nya paket. ABS-översikt ABS kan användas som paraplytid eftersom det ingår och bygger på flera andra komponenter, men ABS-tekniken är inte tekniskt korrekt. ABS kan se följande verktyg som en komplett verktygslåda: ABS-träd ABS-katalogstrukturen innehåller filer som behövs för att bygga alla officiella paket (men inte själva paketet eller programvarans källfiler). Det finns tillgängligt i svn - och git-repositories och abs-scriptet (från abs-paketet) laddar ner dem med hjälp av rsync till varabs på din (lokala) maskin. På det lokala systemet innehåller trädet underkataloger för varje förråd som anges i etcabs. conf. som i sin tur innehåller en underkatalog för varje paket. Obs! ABS-trädet synkroniseras en gång om dagen så det kan gå efter det som redan finns i förvaret. PKGBUILD Ett Bash-skript som innehåller URL-adressen till källkoden tillsammans med kompilerings - och förpackningsinstruktionerna. makepkg shell kommandot verktyg som läser PKGBUILDs, laddar ner automatiskt och sammanställer källorna och skapar en. pkg. tar enligt PKGEXT arrayen i makepkg. conf. Du kan också använda makepkg för att skapa egna anpassade paket från AUR - eller tredjepartskällorna. Se Skapa paket för mer information. pacman pacman är helt separat, men krävs nödvändigtvis antingen av makepkg eller manuellt för att installera och ta bort de inbyggda paketen och för att hämta avhängighet. AUR Arch User Repository är separat från ABS men AUR (stöds inte) PKGBUILDs är byggda med makepkg för att kompilera och paketera programvara. I motsats till ABS-trädet på din lokala maskin finns AUR som ett webbgränssnitt. Den innehåller tusentals användarbidragna PKGBUILDs för programvara som inte är tillgänglig som officiellt Arch-paket. Om du behöver bygga ett paket utanför det officiella Arch-trädet är chansen att det är i AUR. Varning: Officiella PKGBUILDs antar att paket är inbyggda i en ren chroot. Att bygga programvara på ett smutsigt byggsystem kan misslyckas eller orsaka oväntat beteende vid körning, för om byggsystemet upptäcker beroende dynamiskt beror resultatet på vilka paket som finns tillgängliga på byggsystemet. Varför skulle jag vilja använda ABS? Ark Build System används för att: Kompilera eller kompilera ett paket, av någon anledning. Gör och installera nya paket från källkod för vilken inga paket ännu finns tillgängliga (se Skapa paket). Anpassa befintliga paket för att passa dina behov (aktivera eller inaktivera alternativ, patch) Återuppbygga hela systemet med kompilatorflaggor, la FreeBSD (t. ex. med pacbuilder) Rengör och bygga upp din egen anpassade kärna (se Kärnkompilering) Få kärnmoduler som arbetar med din egen kärna. Kompilera enkelt och installera en nyare, äldre, beta eller utvecklingsversion av ett Arch-paket genom att redigera versionsnumret i PKGBUILD ABS är inte nödvändigt för att använda Arch Linux, men det är användbart för att automatisera vissa uppgifter om källkompilering. Så här använder du ABS-byggpaket med hjälp av magsäcken består av följande steg: Installera abs-paketet med pacman. Kör abs som root för att skapa ABS-trädet genom att synkronisera det med Arch Linux-servern. Kopiera byggfilerna (vanligtvis bosatt under varabsltrepogtltpkgnamegt) till en byggkatalog. Navigera till den katalogen, ändra PKGBUILD (om önskad) och gör makepkg. Enligt instruktionerna i PKGBUILD kommer makepkg att hämta lämplig källa tarball, packa upp den, patch (om så önskas), kompilera enligt CFLAGS som anges i makepkg. conf. och slutligen komprimera de inbyggda filerna till ett paket med förlängningen. pkg. tar. gz eller. pkg. tar. xz. Installera är lika enkelt som att göra pacman - U lt. pkg. tar. xz filegt. Paketavlägsnande hanteras också av pacman. Installera verktyg Detta kommer att ta tag i abs-sync-skript, olika byggskript och rsync (som ett beroende om du inte redan har det). Innan du faktiskt kan bygga något, behöver du också grundläggande kompileringsverktyg. Dessa samlas in i paketpaketet bas-devel. Denna grupp kan installeras med pacman. etcabs. conf Redigera etcabs. conf för att inkludera dina önskade repositorier. Ta bort. framför lämpliga förråd. Till exempel: ABS-trädet är en SVN-kataloghierarki som ligger under varabs och ser ut så här: ABS-trädet har exakt samma struktur som paketdatabasen: Första nivån: Förvaringsnamn Avancerad nivå: Paketnamnskataloger Tredje nivån: PKGBUILD ( innehåller information som behövs för att bygga ett paket) och andra relaterade filer (patchar, andra filer som behövs för att bygga paketet) Källkoden för paketet finns inte i ABS-katalogen. Istället innehåller PKGBUILD en URL som kommer att hämta källkoden när paketet är byggt. Så storleken på abs-trädet är ganska litet. Ladda ner ABS Tree Ditt ABS-träd är nu skapat under varabs. Observera att trädgrenar skapades som motsvarar de som du angav i etcabs. conf. Abs-kommandot bör köras regelbundet för att hålla synkronisering med de officiella arkiverna. Individuella ABS-paketfiler kan också laddas ner med: Så här behöver du inte kolla hela abs-trädet för att bara bygga ett paket. etcmakepkg. conf Anteckningar: använd det andra argumentet i mallen för att ge mer detaljerade indikationer. (Diskutera i Talk: Arch Build System) makepkg s etcmakepkg. conf anger globala miljövariabler och kompilatorflaggor som du kanske vill redigera om du använder ett SMP-system, eller för att ange andra önskade optimeringar. Standardinställningarna är för optimering av i686 och x8664 som fungerar bra för de arkitekturerna på en-CPU-system. (Standardvärdena kommer att fungera på SMP-maskiner, men kommer bara att använda en coreCPU när du sammanställer se makepkg för detaljer.) Ställ in PACKAGER-variabeln i etcmakepkg. conf. Inställning av PACKAGER-variabeln i etcmakepkg. conf är ett valfritt men rekommenderat steg. Det gör det möjligt för en flagga att snabbt identifiera vilka paket som har byggts och installerats av DIG, inte den officiella underhållaren. Det här uppnås enkelt med expac. Visar alla paket (inklusive de från AUR) Visar endast paket som finns i repos Detta exempel visar bara paket som finns i repos definierade i etcpacman. conf. Skapa en byggkatalog Det rekommenderas att skapa en byggkatalog där den faktiska kompileringen ska ske. Du ska aldrig ändra ABS-trädet genom att bygga in det, eftersom data kommer att gå vilse (överskridits) på varje ABS-uppdatering. Det är bra att använda din hemkatalog, men vissa Arch-användare föredrar att skapa en lokal katalog under varabs. ägs av en vanlig användare. Skapa din byggkatalog. t. ex. Kopiera ABS från trädet (varabsltrepositorygtltpkgnamegt) till byggkatalogen. Byggpaket I vårt exempel kommer vi att bygga det smala bildskärmshanteringspaketet. Kopiera den slanka ABS från ABS-trädet till en byggkatalog: Navigera till byggkatalogen: Ändra PKGBUILD efter eget tycke. Om du behöver göra ändringar i källan själv, istället för bara PKGBUILD, se Patching in ABS. Kör sedan makepkg (med - s-flaggan för att möjliggöra automatisk hantering av beredskapshantering): Obs! Innan du klagar på saknade (beroende) beroenden, kom ihåg att gruppbas-devel antas installeras när du bygger med makepkg. Se Installera verktyg. Installera som root: Det är det. Du har just byggt smal från källan och installerat den på ditt system med pacman. Paketavlägsnande hanteras också av pacman med pacman-R slim. ABS-metoden för installation av programvara ger bekvämlighet, samtidigt som du behåller fullständig öppenhet och kontroll över de bygg - och installationsfunktioner som ingår i PKGBUILD. I huvudsak utförs samma steg i den traditionella metoden (allmänt inklusive. konfigurera, skapa, göra installationssteg) men programvaran är installerad i en falsk rotmiljö. (En falsk rutt är helt enkelt en underkatalog i byggkatalogen som fungerar och fungerar som systemets rotkatalog. I kombination med fakerootprogrammet skapar makepkg en falsk rotkatalog och installerar de sammanställda binärerna och tillhörande filer i den med rot som ägare.) Den falska roten. eller underkatalog som innehåller den sammanställda mjukvaran, komprimeras sedan till ett arkiv med förlängningen. pkg. tar. xz. eller ett paket. När den påkallas paketerar pacman paketet (installerar det) i systemets verkliga rotkatalog (). Bevara modifierade paket Uppdatering av systemet med pacman kommer att ersätta ett modifierat paket från ABS med paketet med samma namn från de officiella arkiverna. Se följande instruktioner för hur du undviker detta. Lägg in en gruppmatris i PKGBUILD, och lägg till paketet till en grupp som heter modifierad. Lägg till den här gruppen i avsnittet Ignorera Grupp i etcpacman. conf. Om nya versioner finns tillgängliga i de officiella arkiverna under en systemuppdatering skriver pacman en anteckning om att den hoppar över den här uppdateringen eftersom den ligger i avsnittet Ignorera grupp. Vid detta tillfälle bör det modifierade paketet byggas om från ABS för att undvika partiella uppgraderingar. Andra verktyg pbget - hämta PKGBUILDs för enskilda paket direkt från webbgränssnittet. Innehåller AUR-stöd. asp - ett verktyg för att hantera byggkällarfilerna som används för att skapa Arch Linux-paket. Använder git-gränssnittet som erbjuder mer aktuella källor. Ansvarsbegränsning Att bygga och använda en anpassad kärna gör det väldigt svårt att få stöd för ditt system. Medan det är en lärande erfarenhet för att kompilera din egen kärna, kommer du inte att kunna filma fel på den anpassade kärnan (om du gör det, kommer de att avvisas utan ytterligare förklaring). Obs! Denna sida skulle behöva betydande rengöring. Du kanske vill referera till KernelBuildYourOwnKernel-sidan i Ubuntu wiki istället, vilket är en renare och mer aktuell guide till (enkel) kärnbyggnad. Om du har ett kommersiellt supportavtal med UbuntuCanonical kommer detta att upphäva sådant stöd. Observera också att den här sidan beskriver hur man gör saker för den äkta (2.6.17) kärnan och nyare. Till den här kärnkällan hade vi inga mekanismer som gör det möjligt för människor att enkelt bygga sina egna kärnor. Detta var avsiktligt. Den här sidan beskriver INTE hur man bygger uppströms kärnor från kernel. org. Så här bygger du upp den aktuella Ubuntu-kärnan från källan. Skäl för att skapa en anpassad kärna Du är en kärnutvecklare. Du behöver kärnan sammanställd på ett speciellt sätt, att den officiella kärnan inte är sammanställd (till exempel med någon experimentell funktion aktiverad). Du försöker att felsöka ett problem i den lager Ubuntu-kärnan som du har arkiverat eller kommer att lägga till en felrapport. Du har hårdvara som inte innehåller Ubuntu-kärnan. Du älskar datorer och är nyfiken och intresserad av att hacka på ditt eget GNULinux-system för att lära dig mer om hur det fungerar (med förståelse att du måste fixa allt du bryter). Skäl för att INTE sammanställa en anpassad kärna Du behöver bara kompilera en särskild drivrutin. För detta behöver du bara installera paketet linux-headers. Du har ingen aning om vad du gör, och om du bryter något, behöver du hjälp med att fixa det. Beroende på vad du gör fel kan du behöva sluta installera om ditt system från början. Du kommer till den här sidan av misstag och checkar ut det eftersom det såg ut som intressant, men du vill inte lära dig mycket om kärnor. Om du vill installera en ny kärna utan kompilering kan du använda Synaptic. leta efter linux-image och välj den kärnversion du vill installera. Ett enklare sätt är att klicka på System gt Administration gt Update Manager. klicka sedan på knappen Kontrollera och slutligen klicka på Använd alla uppdateringar inklusive kärnan. Verktyg du måste starta måste du installera några paket. Använd följande kommandorad för att installera exakt de paket som behövs för den version du använder: Obs! Paketet makedumpfile är inte tillgängligt i Hardy. Få kärnkällan Det finns några sätt att få Ubuntu-kärnkällan: Alternativ A) Använd git Använd git - Det här är för användare som alltid vill synkronisera med den senaste Ubuntu-kärnkällan. För din information finns det detaljerade instruktioner om det i Kernelgitguiden. Git-förvaret innehåller inte nödvändiga kontrollfiler, så du måste bygga dem genom: Alternativ B) Hämta källarkivet Hämta källarkivet - Det här är för användare som vill bygga upp de vanliga Ubuntu-paketen med ytterligare patchar. Observera att det nästan alltid kommer att vara föråldrat jämfört med den senaste utvecklingskällan, så du bör använda git (alternativ A) om du behöver de senaste patcherna. Använd ett kommandot för att installera byggnadsberoende och extrahera källan (till den aktuella katalogen): Ubuntu-modulkällan kan också behövas om du planerar att aktivera PAE och 64 GiB-stöd i kärnan för 32-bitars Hardy (8.04). Ubuntu-tillförda moduler kanske inte är kompatibla med en PAE-aktiverad kärna. Källan hämtas till en underkatalog i den aktuella katalogen. Ubuntu Karmic Koala (9.10) och nyare versioner Källan kommer hämtas till den aktuella katalogen som en trio av filer (för Lucid, åtminstone) (.orig. tar. gz..diff. gz och. dsc) och en del --Directory. Till exempel, om uname - r returnerar 2.6.32-25-generic. du kommer att få linux2.6.32.orig. tar. gz. linux2.6.32-25.44.diff. gz. linux2.6.32-25.44.dsc och underkatalogen linux-2.6.32. Alternativ C) Hämta källkodspaketet Ladda ner källkodspaketet (detaljerad information finns längre ner på den här sidan under Alternativ byggnadsmetod (B): Det gammaldags Debian-sättet) - Det här är för användare som helt enkelt vill modifiera eller leka med, den Ubuntu-patched kärnkällan. Återigen är det inte den mest aktuella (använd alternativ Agit om du behöver den senaste källan). Var medveten om att detta inte är detsamma som alternativ BDownload källarkivet. Ändra källan till dina behov För de flesta är det bara att ändra konfigurerna. Om du behöver installera en korrigeringsfil läser du instruktionerna från patchleverantören för att lära dig hur du applicerar det. Beståndet Ubuntu configs finns i debianconfigARCH där ARCH är arkitekturen du bygger för (Börja med Jaunty det här är debian. masterconfigARCH). I den här katalogen finns det flera filer. Konfigureringsfilen är basen för alla mål i den arkitekturen. Då finns det flera config. FLAVOUR-filer som innehåller alternativ som är specifika för det målet. Till exempel, här är filerna för 2.6.20, i386: Om du inte hittar config-filerna under debianconfig. du kan hitta dem i din startkatalog (till exempel bootconfig-2.6.22-14-generic) annars bör du kontrollera om en alternativ plats har angivits inom debiandebian. env i din kärnkällkatalog. Om du behöver ändra ett config-alternativ, ändra bara filen som innehåller alternativet. Om du bara ändrar konfigurationsfilen påverkar den alla mål för denna arkitektur. Om du ändrar en av målfilerna påverkar den bara det målet. När du har applicerat en korrigeringsfil eller justerat konfigurerar, är det alltid bäst att regenerera config-filerna för att säkerställa att de är konsekventa. Det finns ett hjälprandom för detta. För att regenerera kör alla arkitekturer: Om du bara vill uppdatera en arkitektur. kör: Obs! Om du inte har debian-katalogen efter att du har använt apt-source. använd dpkg-source - x dsc för att extrahera källorna korrekt. För att dessa två kommandon ska fungera måste du ge skripten i debianscriptsmisc - och debianscripts-katalogerna exekvera tillstånd med följande kommando: Bygg kärnan (er) Det finns två listade sätt att bygga Ubuntu-kärnan: Byggmetod A: Bygg kärnan (när källan är från git repository eller från apt-get source) Att bygga kärnan (er) är mycket enkel. Beroende på dina behov kanske du vill bygga alla kärnmål, eller bara en specifik för ditt system. Men du vill också se till att du inte kolliderar med lagerkärnorna. Obs! Även om dessa externa instruktioner inkluderar att skapa en separat och unik gren av kärnan, till skillnad från här, innehåller de noggranna förklaringar av alla nödvändiga steg från början till slut. Dessa instruktioner är specifika för git-tree och för källan som hämtas via apt-get-källan. inte när du hämtar paketet linux-source från kernel. org Använd det här kommandot för att bygga alla mål för den arkitektur du bygger på: debianrules clean skapar debiancontrol. debianchangelog. och så vidare från debian. ltbranchnamegt (t ex debian. master). Det är nödvändigt i git-träd efter git-commit 3ebd3729ce35b784056239131408b9a72b0288ef UBUNTU: Config Sammanfattning Debian-katalogen. AUTOBUILD-miljövariabeln utlöser specialfunktioner i kärnbyggnaden. Först hoppar det över normala ABI-kontroller (ABI är binärkompatibiliteten). Det kan göra det eftersom det också skapar ett unikt ABI ID. Om du använde en git repo, genereras detta unika ID från git HEAD SHA. Om inte, genereras det från uuidgen-programmet (vilket innebär att varje gång du utför debianrulesna bygger UUID annorlunda). Dina paket kommer att namnges med detta ID. (Observera att i Intrepid och newer behöver du skipabitrue för att hoppa över ABI-kontroller.) Att bygga ett specifikt mål. använd det här kommandot: där FLAVOR är en av huvudkärnorna i kärnan (t ex generisk) För att bygga en av de anpassade smakerna (finns i debianbinary-custom. d), använd: Som av den här dokumentationen innehåller anpassade smaker xen och rt. Om du har mer än en processor eller mer än en kärna kan du påskynda saker genom att köra samtidigt kompilera kommandon. Förbered CONCURRENCYLEVEL2 för två processorer eller två kärnor ersätt 2 med vilket antal som passar din hårdvaruinstallation (för Gutsy och senare kan du alternativt använda DEBBUILDOPTIONSparallel2). Om du får ABI-fel kan du undvika ABI-kontrollen med skipabitrue. Till exempel, för att utlösa en ombyggnad, ta bort den korrekta stämpelfilen från debianstamps (t ex stämpel-bygg-server för serverns smak etc.). Debiterna placeras i din moderkatalog i kärnkällans katalog. Om så behövs kan Ubuntu-modulkällan för Hardy (8.04) byggas på liknande sätt. Alternativt, om du behöver ange en annan kärna än den löpande, använd Om du får ett fel, försök att köra det här i kerneldiren. (exempel på generisk smak) Alternativ byggmetod (B): Det gammaldags Debian-sättet Det nya Ubuntu-byggsystemet är utmärkt för utvecklare, för personer som behöver den absolut senaste blödningskärnan och personer som behöver bygga en mångsidig uppsättning kärnor (flera smaker). Men det kan vara ett litet komplex för vanliga användare. Om du inte behöver de senaste utvecklingskällorna finns det ett enklare sätt att kompilera din kärna från Linux-källkodspaketet. Såsom föreslagits ovan är allt du behöver för detta: Det sista kommandot i sekvensen leder dig till den översta katalogen i ett kärnkällträd. Innan du bygger kärnan måste du konfigurera den. Om du vill återanvända konfigurationen för din kärna som körs, börja med Innan du kör gör menuconfig eller gör xconfig (vilket är vad nästa steg säger att du ska göra), se till att du har nödvändiga paket: Om du skulle gillar att se vad som skiljer sig från din ursprungliga kärnkonfiguration och den nya (och bestämmer om du vill ha någon av de nya funktionerna), kan du köra: Sedan 2.6.32-kärnan kan en ny funktion du bara uppdatera konfigurationen till kompilera moduler som faktiskt används i ditt system: Då oavsett om du återanvändar en befintlig konfiguration eller börjar från början: Vad händer med detta. (som är från KernelBuildYourOwnKernel-sidan i avsnittet Ändra konfigurationen) Om du använde den befintliga konfigurationen, notera att Ubuntu-kärnor bygger med felsökningsinformation på, vilket gör de resulterande kärnmodulerna (.ko-filer) mycket större än de annars skulle vara. För att stänga av det, gå in i Configs Kernel hackinglt - då, under Kernel debugging, --gt och stäng av. Kompilera kärnan med felsökning info. Nu kan du kompilera kärnan och skapa paket: Du kan aktivera parallell make use make - j). Prova 1 antal processorkärnor. t. ex. 3 om du har en dubbelkärnig processor: Om du bara behöver binära paket och vill ha flera byggnader (medan du redigerar källan) för att inte göra att allt ska byggas om, använd:.deb-paketen kommer att skapas i föräldern katalog i din Linux-källkatalog (i det här exemplet skulle de placeras i src eftersom vår Linux-källkatalog är Installera den nya kärnan Om du vill se Ubuntu-skärmen (eller använd textläge) innan du kommer till X istället för bara En svart skärm, du vill se till att Framebuffer-drivrutinen laddar: Nu när du har sagt till initramfs-verktygen vilka moduler den ska innehålla, och när byggnaden är klar kan du installera de genererade debiterna med dpkg. Om du har byggt Ubuntu-modulen för Hardy (8.04) tidigare, installera dem enligt följande: Om du använder moduler från Linux-begränsade moduler måste du kompilera detta mot ditt nya Linux-headers-paket. Obs! Som svar på de olika kommentarerna i resten av detta avsnitt: På Ub untu Precise (12.04) verkar det som postinst DOES tar hand om initramfs grejer. Efter installationen av paketet startade min nya kärna bara bra utan att följa någon av metoderna nedan. Någon rätta mig om jag misstänker. Sedan Ubuntu Lucid (10.04) körs inte poststödets startkommandon. Istället finns det exempelskript förutsatt att den ska utföra uppgiften. Dessa skript kommer också att fungera för officiella kärnbilder. Till exempel: Obs! Jag kunde inte hämta ovanstående skript för att generera en initrd för kärnan - och så kunde den inbyggda kärnan inte starta det enda som fungerade för mig var rekommendationen i debian-administration. orgarticleHowDoIMakeaninitrdimage. använd initramfs-kommandot. Det är riktig lösning. vad jag använde (efter de anpassade kärnorna. debs installerades) var: Obs (Michael): det beror på att du måste inkludera rätt paketskript för att bygga initrd vid paketets installationstid. Make-kpkg-alternativet är - överlay-dir. Som standard använder make-kpkg usrsharekernel-paketet som en överlagskatalog, som innehåller de vanliga, oanpassade skripten för en Debian-distribution, och inte de som behövs för att bygga en Ubuntu-kärna. Först kopierar standardöverlagringskatalogen till din hemkatalog: Installera sedan källan till kärnan du använder för närvarande, med det exakta paketnamnet, t. ex. som kommer att packa upp källorna till HOMElinux-2.6.32. Kopiera nu kontrollskripten till ditt nya överlägg: Och nu kan du utföra make-kpkg med extra kommandoradsalternativet --overlay-dirHOMEkernel-paketet. Ombyggnad av Linux-begränsade moduler Paketet linux-restricted-modules (lrm) innehåller ett antal icke-DFSG-fria drivrutiner (liksom vissa firmware och ipw3945 trådlösa nätverksdemon) som i en perfekt värld inte skulle vara förpackas separat, men som tyvärr inte är tillgängliga enligt en GPL-kompatibel licens. Om du använder någon av de hårdvaror som stöds av l-r-m-paketet kommer du troligen att upptäcka att ditt system inte fungerar lika bra efter att ha bytt till en anpassad kärna. I det här fallet bör du försöka kompilera l-r-m-paketet. Se CustomRestrictedModules om hur man bygger om l-r-m (om du använder nVidia eller ATI binära drivrutiner, gör du). Obs! Du behöver cirka 8 timmars sammanställningstid och cirka 10 GB hårddiskutrymme för att kompilera alla kärnsmakningar och begränsade moduler. Ytterligare anmärkning: Det finns inga paket l-r-m eller linux-restricted-modules i Lucid. Snabba upp byggnaden Använd distcc och, om du återuppbygger ofta, ccache. En bra översikt över hur du använder distcc på ett debianbaserat system finns på myrddin. orghowtousing-distcc-with-debian. Om du har AMD64-maskiner tillgängliga i ditt lokala nätverk, kan de fortfarande delta i att bygga 32-bitars kod, distcc verkar hantera det automatiskt. Men med distcc tar över alla kompiler som standard måste du ställa in HOSTCC så att när kärnbyggnader vill använda kompilatorn på värden själv slutar de inte distribuera jobb till 64-bitars servern. Om du misslyckas med att göra det får du felkompatibilitetsfel mellan 64-bitars och 32-bitars kod. Mitt make-kpkg-kommando, med usrlibccache i huvudet på min PATH. ser ut som: Mer dokumentation Vänligen gå till communitywiki-sidan för kommentarer, frågor och diskussioner: wiki. ubuntuKernelCustomBuildCreating packages Den här artikeln syftar till att hjälpa användare att skapa egna paket med Arch Linux-portliknande byggsystem. även för inlämning i AUR. Det täcker skapandet av en PKGBUILD 8211 en paketuppbyggnadsbeskrivning fil som kommer från makepkg för att skapa ett binärt paket från källan. Om du redan har en PKGBUILD. se makepkg. För instruktioner om befintliga regler och sätt att förbättra pakkkvaliteten, se Arch förpackningsstandarder. Paket i Arch Linux är byggda med hjälp av makepkg-verktyget och informationen som lagras i en PKGBUILD-fil. När makepkg körs söker den efter en PKGBUILD i den aktuella katalogen och följer instruktionerna i den för att förvärva de obligatoriska filerna och eller kompilera dem för att vara förpackade i en paketfil (pkgname. pkg. tar. xz). Det resulterande paketet innehåller binära filer och installationsanvisningar redo att installeras av pacman. En Arch-paket är inte mer än ett tjärarkiv eller tarball, komprimerat med xz, som innehåller följande filer som genereras av makepkg: De binära filer som ska installeras..PKGINFO. innehåller alla metadata som behövs av Pacman för att hantera paket, beroenden, etc..MTREE. innehåller hash och tidsstämplar för filerna, som ingår i den lokala databasen så att pacman kan verifiera paketets integritet..INSTALLERA. en valfri fil som används för att utföra kommandon efter installationsuppgraderingsfasen. (Den här filen är endast tillgänglig om den anges i PKGBUILD.).Changelog. En valfri fil som förvaras av pakethållaren som dokumenterar paketets ändringar. (Den finns inte i alla paket.) Metapaket och grupper En paketgrupp är en uppsättning relaterade paket, definierade av förpackaren, som kan installeras eller avinstalleras samtidigt genom att använda gruppnamnet som ersättning för varje enskilt paketnamn. Medan en grupp inte är ett paket kan det installeras på liknande sätt som ett paket, se PacmanInstalling-paketgrupper och PKGBUILDgroups. Ett metapaket, som ofta (men inte alltid) titlar med meta-suffixet, ger liknande funktionalitet till en paketgrupp genom att det möjliggör att flera relaterade paket installeras eller avinstalleras samtidigt. Metapaket kan installeras precis som alla andra paket, se PacmanInstalling specifika paket. Den enda skillnaden mellan ett metapaket och ett vanligt paket är att ett metapaket är tomt och existerar för att länka relaterade paket tillsammans via beroenden. Fördelen med ett metapaket, jämfört med en grupp, är att alla nya medlemspaket kommer att installeras när metapaketet själv uppdateras med en ny uppsättning beroenden. Detta står i kontrast till en grupp där nya gruppmedlemmar inte automatiskt installeras. Nackdelen med ett metapaket är att det inte är så flexibelt som en grupp - du kan välja vilka gruppmedlemmar du vill installera men du kan inte välja vilka meta paketberoende som du vill installera. På samma sätt kan du avinstallera gruppmedlemmar utan att behöva ta bort hela gruppen, men du kan inte ta bort metapaketberoende utan att behöva avinstallera metapaketet själv. Förberedelse Förutsatt programvara Kontrollera först att de nödvändiga verktygen är installerade. Installera paketgruppens bas-devel ska vara tillräcklig. Det inkluderar tillverkningsverktyg och extraverktyg som behövs för att kompilera från källan. Ett av nyckelverktygen för att bygga paket är makepkg (tillhandahållet av pacman), vilket gör följande: Kontrollerar om paketberoende är installerade. Nedladdningar av källfilen från den angivna servern (erna). Packar upp källfilen / filerna. Kompilerar programvaran och installerar den under en fakeroot-miljö. Strips symboler från binärer och bibliotek. Genererar paketmeta-filen som ingår i varje paket. Komprimerar fakeroot-miljön i en paketfil. Lagrar paketfilen i den konfigurerade destinationskatalogen, som är den aktuella arbetsmappen som standard. Ladda ner och testa installationen Ladda ner källkoden tarballen till den programvara du vill paketera, extrahera den och följ författarens steg för att installera programmet. Notera alla kommandon och / eller steg som behövs för att kompilera och installera det. Du kommer att upprepa samma kommandon i PKGBUILD-filen. De flesta programvaruutgivare håller sig till 3-stegs byggcykeln: Det här är en bra tid att se till att programmet fungerar korrekt. Skapa en PKGBUILD När du kör makepkg. Det kommer att leta efter en PKGBUILD-fil i den nuvarande arbetsmappen. Om en PKGBUILD-fil hittas hämtar den mjukvarukällkoden och sammanställer den enligt instruktionerna i PKGBUILD-filen. Anvisningarna måste tolkas fullständigt av Bash-skalet. After successful completion, the resulting binaries and metadata of the package, i. e. package version and dependencies, are packed in a pkgname. pkg. tar. xz package file that can be installed with pacman - U ltpackage filegt . To begin with a new package, you should first create an empty working directory, (preferably abs pkgname ), change into that directory, and create a PKGBUILD file. You can either copy the prototype PKGBUILD usrsharepacmanPKGBUILD. proto to your working directory or copy a PKGBUILD from a similar package. The latter may be useful if you only need to change a few options. Warning: Use only the PKGBUILD prototypes provided in the pacman package (PKGBUILD-split. proto, PKGBUILD-vcs. proto and PKGBUILD. proto). The prototypes files in the abs package and in the ABS git repository are significantly out of date and should not be used. See FS34485 . Defining PKGBUILD variables Example PKGBUILDs are located in usrsharepacman. An explanation of possible PKGBUILD variables can be found in the PKGBUILD article. makepkg defines two variables that you should use as part of the build and install process: srcdir This points to the directory where makepkg extracts or symlinks all files in the source array. pkgdir This points to the directory where makepkg bundles the installed package, which becomes the root directory of your built package. All of them contain absolute paths, which means, you do not have to worry about your working directory if you use these variables properly. Note: makepkg . and thus the build() and package() functions, are intended to be non-interactive. Interactive utilities or scripts called in those functions may break makepkg . particularly if it is invoked with build-logging enabled ( - L ). (See FS13214 .) Note: Apart from the current package Maintainer, there may be previous maintainers listed above as Contributors. PKGBUILD functions There are five functions, listed here in the order they are executed if all of them exist. If one does not exist, it is simply skipped. Note: This does not apply to the package() function, as it is required in every PKGBUILD This function, commands that are used to prepare sources for building are run, such as patching. This function runs right after package extraction, before pkgver() and the build function. If extraction is skipped ( makepkg - e ), then prepare() is not run. Note: (From man PKGBUILD ) The function is run in bash - e mode, meaning any command that exits with a non-zero status will cause the function to exit. pkgver() runs after the sources are fetched, extracted and prepare() executed. So you can update the pkgver variable during a makepkg stage. This is particularly useful if you are making gitsvnhgetc. packages. where the build process may remain the same, but the source could be updated every day, even every hour. The old way of doing this was to put the date into the pkgver field which, if the software was not updated, makepkg would still rebuild it thinking the version had changed. Some useful commands for this are git describe. hg identify - ni. etc. Please test these before submitting a PKGBUILD, as a failure in the pkgver() function can stop a build in its tracks. Note: pkgver cannot contain spaces or hyphens ( - ). Using sed to correct this is common. Now you need to implement the build() function in the PKGBUILD file. This function uses common shell commands in Bash syntax to automatically compile software and create a pkg directory to install the software to. This allows makepkg to package files without having to sift through your file system. The first step in the build() function is to change into the directory created by uncompressing the source tarball. makepkg will change the current directory to srcdir before executing the build() function. Therefore, in most cases, like suggested in usrsharepacmanPKGBUILD. proto. the first command will look like this: Now, you need to list the same commands you used when you manually compiled the software. The build() function in essence automates everything you did by hand and compiles the software in the fakeroot build environment. If the software you are packaging uses a configure script, it is good practice to use --prefixusr when building packages for pacman. A lot of software installs files relative to the usrlocal directory, which should only be done if you are manually building from source. All Arch Linux packages should use the usr directory. As seen in the usrsharepacmanPKGBUILD. proto file, the next two lines often look like this: Note: If your software does not need to build anything, DO NOT use the build() function. The build() function is not required, but the package() function is. Place for calls to make check and similar testing routines. It is highly recommended to have check() as it helps to make sure software has been built correctly and works fine with its dependencies. Users who do not need it (and occasionally maintainers who can not fix a package for this to pass) can disable it using BUILDENV(check) in PKGBUILDmakepkg. conf or call makepkg with --nocheck flag. The final step is to put the compiled files in a directory where makepkg can retrieve them to create a package. This by default is the pkg directorya simple fakeroot environment. The pkg directory replicates the hierarchy of the root file system of the softwares installation paths. If you have to manually place files under the root of your filesystem, you should install them in the pkg directory under the same directory structure. For example, if you want to install a file to usrbin. it should instead be placed under pkgdirusrbin. Very few install procedures require the user to copy dozens of files manually. Instead, for most software, calling make install will do so. The final line should look like the following in order to correctly install the software in the pkg directory: Note: It is sometimes the case where DESTDIR is not used in the Makefile you may need to use prefix instead. If the package is built with autoconf automake . use DESTDIR this is what is documented in the manuals. If DESTDIR does not work, try building with make prefixpkgdirusr install. If that does not work, you will have to look further into the install commands that are executed by make lt. gt install . In some odd cases, the software expects to be run from a single directory. In such cases, it is wise to simply copy these to pkgdiropt. More often than not, the installation process of the software will create sub-directories below the pkg directory. If it does not, however, makepkg will generate a lot of errors and you will need to manually create sub-directories by adding the appropriate mkdir - p commands in the build() function before the installation procedure is run. In old packages, there was no package() function. So, files were put into the pkg directory at the end of the build() function. If package() is not present, build() runs via fakeroot . In new packages, package() is required and runs via fakeroot instead, and build() runs without any special privileges. makepkg --repackage runs only the package() function, so it creates a. pkg. file without compiling the package. This may save time e. g. if you just have changed the depends variable of the package. Note: The package() function is the only required function in a PKGBUILD. If you must only copy files into their respective directories to install a program, do not put it in the build() function, put that in the package() function. Note: Creating symlinks is a slightly awkward process in the package() function. Using the naive approach ln - s fromfoo togoo will result in a broken symlink to the build directory. The way to create a proper link is to create it pointing to an initially-broken source, ln - s fromfoo togoo. Once the package is installed, the link will point to the right place. Testing the PKGBUILD and package As you are writing the build() function, you will want to test your changes frequently to ensure there are no bugs. You can do this using the makepkg command in the directory containing the PKGBUILD file. With a properly formatted PKGBUILD. makepkg will create a package with a broken or unfinished PKGBUILD. it will raise an error. If makepkg finishes successfully, it will place a file named pkgname-pkgver. pkg. tar. xz in your working directory. This package can be installed with the pacman - U command. However, just because a package file was built does not imply that it is fully functional. It might conceivably contain only the directory and no files whatsoever if, for example, a prefix was specified improperly. You can use pacmans query functions to display a list of files contained in the package and the dependencies it requires with pacman - Qlp package file and pacman - Qip package file respectively. If the package looks sane, then you are done However, if you plan on releasing the PKGBUILD file, it is imperative that you check and double-check the contents of the depends array. Also ensure that the package binaries actually run flawlessly It is annoying to release a package that contains all necessary files, but crashes because of some obscure configuration option that does not quite work well with the rest of the system. If you are only going to compile packages for your own system, though, you do not need to worry too much about this quality assurance step, as you are the only person suffering from mistakes, after all. Checking package sanity After testing package functionality check it for errors using namcap. Check PKGBUILD contents for common errors and package file hierarchy for unnecessarymisplaced files Scan all ELF files in package using ldd. automatically reporting which packages with required shared libraries are missing from depends and which can be omitted as transitive dependencies Heuristically search for missing and redundant dependencies and much more. Get into the habit of checking your packages with namcap to avoid having to fix the simplest mistakes after package submission. Submitting packages to the AUR Please read AUR User GuidelinesSubmitting packages for a detailed description of the submission process. Download the source tarball of the software you want to package. Try compiling the package and installing it into an arbitrary directory. Copy over the prototype usrsharepacmanPKGBUILD. proto and rename it to PKGBUILD in a temporary working directory -- preferably abs . Edit the PKGBUILD according to the needs of your package. Run makepkg and see whether the resulting package is built correctly. If not, repeat the last two steps. Before you can automate the package building process, you should have done it manually at least once unless you know exactly what you are doing in advance . in which case you would not be reading this in the first place. Unfortunately, although a good bunch of program authors stick to the 3-step build cycle of. configure make make install , this is not always the case, and things can get real ugly if you have to apply patches to make everything work at all. Rule of thumb: If you cannot get the program to compile from the source tarball, and make it install itself to a defined, temporary subdirectory, you do not even need to try packaging it. There is not any magic pixie dust in makepkg that makes source problems go away. In a few cases, the packages are not even available as source and you have to use something like sh installer. run to get it to work. You will have to do quite a bit of research (read READMEs, INSTALL instructions, man pages, perhaps ebuilds from Gentoo or other package installers, possibly even the MAKEFILEs or source code) to get it working. In some really bad cases, you have to edit the source files to get it to work at all. However, makepkg needs to be completely autonomous, with no user input. Therefore if you need to edit the makefiles, you may have to bundle a custom patch with the PKGBUILD and install it from inside the prepare() function, or you might have to issue some sed commands from inside the prepare() function. More detailed guidelines Package creation guidelines
No comments:
Post a Comment