Arch fakeroot binary options

Arch Build System Contents O que é o Arch Build System O Arch Build System é um sistema semelhante a um porto para construir e embalar software a partir do código fonte. Embora o pacman seja a ferramenta especializada do Arch para o gerenciamento de pacotes binários (incluindo pacotes construídos com o ABS), o ABS é uma coleção de ferramentas para compilar fontes em pacotes instaláveis ​​.pkg. tar. xz. O que é um sistema Ports-like Ports é um sistema usado pelo BSD para automatizar o processo de criação de software a partir do código fonte. O sistema usa uma porta para baixar, descompactar, corrigir, compilar e instalar o software fornecido. Uma porta é apenas um pequeno diretório no computador do usuário, nomeado após o software correspondente a ser instalado, que contém alguns arquivos com as instruções para a construção e instalação do software a partir da fonte. Isso torna a instalação do software tão simples como digitar make ou make install clean dentro do diretório ports. ABS é um conceito semelhante ABS é composto de uma árvore de diretório (a árvore ABS) residente sob / var / abs. Esta árvore contém muitos subdiretórios, cada um dentro de um nome de repo e cada nomeado por seu respectivo pacote. Esta árvore representa (mas não contém) todo o software oficial do Arch. Recuperável através do sistema SVN. Você pode se referir a cada subdiretório nomeado por pacote como um ABS, da mesma forma que se referiria a uma porta. Esses ABS (ou subdiretórios) não contêm o pacote de software nem a fonte, mas sim um arquivo PKGBUILD (e às vezes outros arquivos). Um PKGBUILD é um simples script de compilação do Bash, um arquivo de texto contendo as instruções de compilação e empacotamento, assim como o URL do tarball de origem apropriado a ser baixado. (O componente mais importante do ABS são PKGBUILDs.) Ao emitir dentro do comando ABS makepkg, o software é primeiro compilado e depois empacotado dentro do diretório de compilação. Agora você pode usar pacman (o gerenciador de pacotes Arch Linux) para instalar, atualizar e remover o novo pacote. Resumo do ABS O ABS pode ser usado como um termo geral, uma vez que inclui e confia em vários outros componentes, portanto, embora não seja tecnicamente preciso, o ABS pode se referir às seguintes ferramentas como um conjunto completo de ferramentas: Árvore ABS A estrutura de diretório ABS contendo arquivos necessários para construir todos Oficiais (mas não os próprios pacotes nem os arquivos de origem do software). Ele está disponível nos repositórios svn e git eo script abs (do pacote abs) faz o download deles usando o rsync em / var / abs / em sua máquina (local). No sistema local, a árvore contém subdiretórios para cada repositório especificado em /etc/abs. conf. Que por sua vez contêm um subdiretório para cada pacote. Nota: A árvore ABS é sincronizada uma vez por dia, por isso pode ficar atrás do que já está disponível nos repositórios. PKGBUILD Um script Bash que contém o URL do código-fonte junto com as instruções de compilação e empacotamento. Makepkg shell ferramenta de comando que lê o PKGBUILDs, automaticamente downloads e compila as fontes e cria um. pkg. tar de acordo com a matriz PKGEXT em makepkg. conf. Você também pode usar makepkg para criar seus próprios pacotes personalizados a partir de fontes AUR ou de terceiros. Consulte Criando pacotes para obter mais informações. Pacman pacman é completamente separado, mas é necessariamente invocado por makepkg ou manualmente, para instalar e remover os pacotes construídos e para buscar dependências. AUR O Arch User Repository é separado do ABS mas AUR (não suportado) PKGBUILDs são construídos usando makepkg para compilar e empacotar o software. Em contraste com a árvore ABS em sua máquina local, o AUR existe como uma interface de site. Ele contém muitos milhares de PKGBUILDs contribuídos pelos usuários para o software que não está disponível como um pacote oficial do Arch. Se você necessitar construir um pacote fora da árvore oficial do arco, as possibilidades são ele estão no AUR. Aviso: Os PKGBUILDs oficiais supor que os pacotes são construídos em um chroot limpo. Construir software em um sistema de compilação sujo pode falhar ou causar um comportamento inesperado em tempo de execução, porque se o sistema de compilação detectar dependências dinamicamente, o resultado depende de quais pacotes estão disponíveis no sistema de compilação. Por que eu gostaria de usar o ABS O Arch Build System é usado para: Compilar ou recompilar um pacote, por qualquer motivo Faça e instale novos pacotes a partir da fonte de software para os quais ainda não existem pacotes disponíveis (consulte Criação de pacotes) (Por exemplo, com pacbuilder) Construa e instale seu próprio kernel personalizado (veja a compilação do kernel) Obtenha os módulos do kernel trabalhando com seu kernel personalizado Compile e instale facilmente seu próprio kernel personalizado Instalar uma versão mais nova, mais antiga, beta ou de desenvolvimento de um pacote Arch editando o número da versão no PKGBUILD ABS não é necessário usar o Arch Linux, mas é útil para automatizar certas tarefas de compilação de origem. Como usar o ABS Construir pacotes usando abs consiste em estas etapas: Instale o pacote de abs com pacman. Execute abs como root para criar a árvore ABS, sincronizando-a com o servidor Arch Linux. Copie os arquivos de compilação (geralmente residentes em / var / abs / ltrepogt / ltpkgnamegt) para um diretório de compilação. Navegue até esse diretório, edite o PKGBUILD (se desejado / necessário) e faça makepkg. De acordo com as instruções no PKGBUILD, makepkg irá baixar o tarball fonte adequada, descompactá-lo, patch (se desejado), compilar de acordo com CFLAGS especificado em makepkg. conf. E finalmente comprimir os arquivos construídos em um pacote com a extensão. pkg. tar. gz ou. pkg. tar. xz. Instalar é tão fácil como fazer pacman - U lt. pkg. tar. xz filegt. A remoção de pacotes também é feita pelo pacman. Instale as ferramentas Isso irá pegar os scripts abs-sync, vários scripts de compilação e rsync (como uma dependência, se você ainda não tiver). Antes que você possa realmente construir qualquer coisa, no entanto, você também vai precisar de ferramentas básicas de compilação. Estes são facilmente coletados no grupo de pacotes base-devel. Este grupo pode ser instalado com pacman. /etc/abs. conf Edite /etc/abs. conf para incluir seus repositórios desejados. Remova o. Na frente dos repositórios apropriados. Por exemplo: Árvore ABS A árvore ABS é uma hierarquia de diretórios SVN localizada em / var / abs e tem a seguinte aparência: A árvore ABS tem exatamente a mesma estrutura que o banco de dados do pacote: Primeiro nível: Nome do repositório Segundo nível: Terceiro nível: PKGBUILD (contém informações necessárias para construir um pacote) e outros arquivos relacionados (patches, outros arquivos necessários para a construção do pacote) O código-fonte do pacote não está presente no diretório ABS. Em vez disso, o PKGBUILD contém um URL que irá transferir o código de origem quando o pacote é criado. Assim, o tamanho da árvore abs é bastante pequeno. Baixar árvore ABS Sua árvore ABS agora é criada em / var / abs. Observe que os ramos de árvore foram criados correspondendo aos que você especificou no /etc/abs. conf. O comando abs deve ser executado periodicamente para manter em sincronia com os repositórios oficiais. Arquivos individuais do pacote ABS também podem ser baixados com: Desta forma, você não precisa verificar a árvore abs inteira apenas para construir um pacote. /etc/makepkg. conf Notas: use o segundo argumento do modelo para fornecer indicações mais detalhadas. Makepkg s /etc/makepkg. conf especifica variáveis ​​de ambiente globais e sinalizadores de compilador que você pode editar se você estiver usando um sistema SMP ou especificar outras otimizações desejadas. As configurações padrão são para o i686 e x8664 otimizações que funcionará bem para essas arquiteturas em sistemas de CPU única. (Os padrões funcionarão em máquinas SMP, mas só usarão um núcleo / CPU ao compilar see makepkg para detalhes.) Definir a variável PACKAGER em /etc/makepkg. conf Definir a variável PACKAGER em /etc/makepkg. conf é uma opção Mas passo altamente recomendado. Permite que uma bandeira identifique rapidamente quais pacotes foram construídos e / ou instalados por VOCÊ, não o mantenedor oficial. Isto é facilmente realizado usando o expac. Mostrando todos os pacotes (incluindo aqueles de AUR) Mostrando apenas pacotes contidos em repos Este exemplo mostra apenas pacotes contidos nos repos definidos em /etc/pacman. conf. Criar um diretório de compilação É recomendável criar um diretório de compilação onde a compilação real ocorrerá. Nunca deverá modificar a árvore de ABS construindo dentro dela, pois os dados serão perdidos (substituídos) em cada atualização do ABS. É uma boa prática usar seu diretório pessoal, embora alguns usuários do Arch preferem criar um diretório local sob / var / abs /. Propriedade de um usuário normal. Crie seu diretório de compilação. por exemplo. Copie o ABS da árvore (/ var / abs / ltrepositorygt / ltpkgnamegt) para o diretório de compilação. Pacote de compilação No nosso exemplo, vamos construir o pacote de gerenciador de exibição de slim. Copie o ABS slim da árvore ABS para um diretório de construção: Navegue para o diretório de compilação: Modifique o PKGBUILD de acordo com seu gosto. Se você precisar fazer alterações na própria fonte, em vez de apenas no PKGBUILD, consulte Patching no ABS. Em seguida, execute makepkg (com o sinalizador - s para ativar a manipulação automática de dependências de tempo de compilação): Observação: Antes de reclamar sobre dependências ausentes (make), lembre-se de que o grupo base-devel é assumido como sendo instalado ao criar com makepkg. Consulte Instalar ferramentas. Instale como root: É isso. Você acabou de construir slim da fonte e instalou-o de forma limpa para o seu sistema com o pacman. A remoção de pacotes também é tratada pelo pacman com pacman - R slim. O método ABS de instalação de software proporciona conforto, mantendo a transparência completa e controle das funções de construção e instalação incluídas no PKGBUILD. Fakeroot Essencialmente, os mesmos passos estão sendo executados no método tradicional (geralmente incluindo as etapas ./configure, make, make install), mas o software é instalado em um ambiente falso de raiz. (Uma raiz falsa é simplesmente um subdiretório dentro do diretório de compilação que funciona e se comporta como o diretório raiz do sistema. Em conjunto com o programa fakeroot, makepkg cria um diretório raiz falso, e instala os binários compilados e arquivos associados nele, com root como Proprietário.) A raiz falsa. Ou subdiretório que contém o software compilado, é então compactado em um arquivo com a extensão. pkg. tar. xz. Ou um pacote. Quando invocado, o pacman extrai o pacote (o instala) no diretório raiz real do sistema (/). Preservar pacotes modificados A atualização do sistema com o pacman substituirá um pacote modificado do ABS pelo pacote do mesmo nome dos repositórios oficiais. Consulte as instruções a seguir para saber como evitar isso. Insira uma matriz de grupo no PKGBUILD e adicione o pacote a um grupo chamado modificado. Adicione este grupo à seção IgnoreGroup em /etc/pacman. conf. Se novas versões estiverem disponíveis nos repositórios oficiais durante uma atualização do sistema, o pacman imprime uma nota que ignora esta atualização porque está na seção IgnoreGroup. Neste ponto o pacote modificado deve ser reconstruído a partir do ABS para evitar upgrades parciais. Outras ferramentas pbget - recupera PKGBUILDs para pacotes individuais diretamente da interface da web. Inclui suporte AUR. Asp - uma ferramenta para gerenciar os arquivos de origem de compilação usados ​​para criar pacotes Arch Linux. Usa a interface git que oferece fontes mais atualizadas. Criação de pacotes Este artigo tem como objetivo auxiliar os usuários a criar seus próprios pacotes usando o sistema de construção Arch-Linux como sistema de compilação. Também para apresentação em AUR. Abrange a criação de um PKGBUILD 8211 um arquivo de descrição de compilação de pacotes obtido por makepkg para criar um pacote binário de origem. Se já estiver na posse de um PKGBUILD. Consulte makepkg. Para obter instruções sobre as regras existentes e formas de melhorar a qualidade do pacote, consulte Normas de empacotamento do Arch. Sumário Visão geral Os pacotes no Arch Linux são criados usando o utilitário makepkg e as informações armazenadas em um arquivo PKGBUILD. Quando makepkg é executado, ele procura por um PKGBUILD no diretório atual e segue as instruções nele para compilar ou adquirir os arquivos necessários para serem empacotados dentro de um arquivo de pacote (pkgname. pkg. tar. xz). O pacote resultante contém arquivos binários e instruções de instalação facilmente instalados com o pacman. Um pacote Arch não é mais do que um arquivo tar, ou tarball, compactado usando xz, que contém os seguintes arquivos gerados pelo makepkg: Os arquivos binários a serem instalados..PKGINFO. Contém todos os metadados necessários pelo pacman para lidar com pacotes, dependências, etc. MTREE. Contém hashes e timestamps dos arquivos, que estão incluídos no banco de dados local para que o pacman possa verificar a integridade do pacote..INSTALAR. Um arquivo opcional usado para executar comandos após o estágio de instalação / atualização / remoção. (Este arquivo está presente somente se especificado no PKGBUILD.).Chogar. Um arquivo opcional mantido pelo mantenedor do pacote documentando as alterações do pacote. (Não está presente em todos os pacotes.) Meta pacotes e grupos Um grupo de pacotes é um conjunto de pacotes relacionados, definidos pelo packager, que podem ser instalados ou desinstalados simultaneamente usando o nome do grupo como um substituto para cada nome de pacote individual. Enquanto um grupo não é um pacote, ele pode ser instalado de forma semelhante a um pacote, consulte PacmanInstalling grupos de pacotes e PKGBUILDgroups. Um meta pacote, muitas vezes (embora nem sempre) intitulado com o sufixo - meta, fornece funcionalidade semelhante a um grupo de pacotes, pois permite que vários pacotes relacionados sejam instalados ou desinstalados simultaneamente. Meta pacotes podem ser instalados como qualquer outro pacote, consulte PacmanInstalling pacotes específicos. A única diferença entre um pacote meta e um pacote regular é que um pacote meta está vazio e existe puramente para vincular pacotes relacionados juntos via dependências. A vantagem de um meta pacote, em comparação com um grupo, é que qualquer novo membro pacotes serão instalados quando o meta pacote em si é atualizado com um novo conjunto de dependências. Isto está em contraste com um grupo em que os novos membros do grupo não serão instalados automaticamente. A desvantagem de um pacote meta é que ele não é tão flexível quanto um grupo - você pode escolher quais membros do grupo deseja instalar, mas não é possível escolher quais dependências de pacotes meta você deseja instalar. Da mesma forma, você pode desinstalar membros do grupo sem ter que remover o grupo inteiro, mas não é possível remover as dependências do pacote meta sem ter que desinstalar o próprio pacote meta. Preparação Software de pré-requisito Certifique-se primeiro de que as ferramentas necessárias estão instaladas. A instalação do grupo de pacotes base-devel deve ser suficiente, inclui make e ferramentas adicionais necessárias para a compilação a partir da fonte. Uma das principais ferramentas para a criação de pacotes é makepkg (fornecido pelo pacman), que faz o seguinte: Verifica se as dependências do pacote estão instaladas. Faz o download dos arquivos de origem do (s) servidor (es) especificado (s). Descompacta o (s) arquivo (s) de origem. Compila o software e o instala em um ambiente fakeroot. Tira símbolos de binários e bibliotecas. Gera o arquivo meta do pacote que está incluído em cada pacote. Comprime o ambiente fakeroot em um arquivo de pacote. Armazena o arquivo de pacote no diretório de destino configurado, que é o atual diretório de trabalho por padrão. Baixe e teste a instalação Faça o download do tarball de origem do software que deseja empacotar, extraia-o e siga as etapas dos autores para instalar o programa. Anote todos os comandos e / ou etapas necessários para compilá-lo e instalá-lo. Você estará repetindo os mesmos comandos no arquivo PKGBUILD. A maioria dos autores de software adere ao ciclo de compilação de 3 etapas: Este é um bom momento para se certificar de que o programa está funcionando corretamente. Criando um PKGBUILD Quando você executa makepkg. Ele procurará um arquivo PKGBUILD no atual diretório de trabalho. Se um arquivo PKGBUILD for encontrado, ele baixará o código fonte do software e o compilará de acordo com as instruções especificadas no arquivo PKGBUILD. As instruções devem ser totalmente interpretáveis ​​pelo shell Bash. Após a conclusão bem-sucedida, os binários e metadados resultantes do pacote, isto é, a versão do pacote e as dependências, são compactados em um arquivo de pacote pkgname. pkg. tar. xz que pode ser instalado com pacman - U ltpackage filegt. Para começar com um novo pacote, você deve primeiro criar um diretório de trabalho vazio, (preferencialmente / abs / pkgname), mudar para esse diretório e criar um arquivo PKGBUILD. Você pode copiar o protótipo PKGBUILD /usr/share/pacman/PKGBUILD. proto para seu diretório de trabalho ou copiar um PKGBUILD de um pacote similar. O último pode ser útil se você só precisa alterar algumas opções. Aviso: Utilize apenas os protótipos PKGBUILD fornecidos no pacote pacman (PKGBUILD-split. proto, PKGBUILD-vcs. proto e PKGBUILD. proto). Os arquivos de protótipos no pacote abs e no repositório ABS git estão significativamente desatualizados e não devem ser usados. Ver FS34485. Definindo variáveis ​​PKGBUILD Exemplo PKGBUILDs estão localizados em / usr / share / pacman /. Uma explicação de possíveis variáveis ​​PKGBUILD pode ser encontrada no artigo PKGBUILD. Makepkg define duas variáveis ​​que você deve usar como parte do processo de compilação e instalação: srcdir Isso aponta para o diretório em que makepkg extrai ou simboliza todos os arquivos na matriz de origem. Pkgdir Isso aponta para o diretório em que o makepkg agrupa o pacote instalado, que se torna o diretório raiz do seu pacote construído. Todos eles contêm caminhos absolutos, o que significa que você não precisa se preocupar com seu diretório de trabalho se você usar essas variáveis ​​corretamente. Nota: makepkg. E, portanto, as funções build () e package (), são destinadas a ser não-interativo. Utilitários interativos ou scripts chamados nessas funções podem quebrar makepkg. Especialmente se for invocado com o build-logging ativado (-L). (Consulte FS13214.) Observação: Além do atual Pacote Manutenção, podem existir mantenedores anteriores listados acima como Contribuintes. Funções PKGBUILD Existem cinco funções, listadas aqui na ordem em que são executadas, se todas elas existem. Se não existe, simplesmente é ignorado. Nota: Isto não se aplica à função package (), como é necessário em cada PKGBUILD pkgver () Começando com pacman 4.1, você pode atualizar a variável pkgver durante um makepkg. Pkgver () é executado logo após as fontes são obtidas e extraídas. Isto é particularmente útil se você estiver fazendo git / svn / hg / etc. Pacotes. Onde o processo de compilação pode permanecer o mesmo, mas a fonte pode ser atualizada todos os dias, mesmo a cada hora. A velha maneira de fazer isso era colocar a data no campo pkgver que, se o software não foi atualizado, makepkg ainda iria reconstruí-lo pensando que a versão tinha mudado. Alguns comandos úteis para isso são git descrever. Hg identificar - ni. Etc Por favor, teste estes antes de enviar um PKGBUILD, como uma falha na função pkgver () pode parar uma compilação em suas faixas. Observação: pkgver não pode conter espaços ou hifens (-). Usando sed para corrigir isso é comum. Prepare () Pacman 4.1 introduz a função prepare (). Nesta função, os comandos que são usados ​​para preparar fontes para construção são executados, como o patch. Essa função é executada antes da função de compilação e após a extração do pacote. Se a extração é ignorada (makepkg - e), então prepare () não é executado. Nota: (Do homem PKGBUILD) A função é executada no modo bash - e, significando que qualquer comando que sai com um status diferente de zero fará com que a função saia. Build () Agora você precisa implementar a função build () no arquivo PKGBUILD. Esta função usa comandos shell comuns na sintaxe Bash para compilar automaticamente o software e criar um diretório pkg para instalar o software. Isso permite que o makepkg envie arquivos sem ter que passar pelo sistema de arquivos. A primeira etapa na função build () é mudar para o diretório criado descompactando o tarball de origem. Makepkg irá alterar o diretório atual para srcdir antes de executar a função build (). Portanto, na maioria dos casos, como sugerido em /usr/share/pacman/PKGBUILD. proto. O primeiro comando será semelhante a este: Agora, você precisa listar os mesmos comandos que você usou quando você compilou manualmente o software. A função build () basicamente automatiza tudo o que você fez manualmente e compila o software no ambiente de compilação fakeroot. Se o software que você está empacotando usa um script de configuração, é uma boa prática usar --prefix / usr ao construir pacotes para pacman. Um monte de software instala arquivos relativos ao diretório / usr / local, o que só deve ser feito se você estiver construindo manualmente a partir da fonte. Todos os pacotes do Arch Linux devem usar o diretório / usr. Como visto no arquivo /usr/share/pacman/PKGBUILD. proto, as próximas duas linhas geralmente se parecem com isso: Nota: Se o software não precisar construir nada, NÃO use a função build (). A função build () não é necessária, mas a função package () é. Check () Coloque para chamadas para fazer check e rotinas de testes semelhantes. É altamente recomendável ter check (), pois ajuda a garantir que o software foi construído corretamente e funciona bem com suas dependências. Usuários que não precisam dele (e ocasionalmente mantenedores que não conseguem corrigir um pacote para isso passar) podem desativá-lo usando BUILDENV (check) em PKGBUILD / makepkg. conf ou chamar makepkg com --nocheck flag. Package () A etapa final é colocar os arquivos compilados em um diretório onde makepkg pode recuperá-los para criar um pacote. Por padrão, o diretório pkg é um ambiente fakeroot simples. O diretório pkg replica a hierarquia do sistema de arquivos raiz dos caminhos de instalação dos softwares. Se você tiver que colocar arquivos manualmente na raiz do seu sistema de arquivos, você deve instalá-los no diretório pkg sob a mesma estrutura de diretório. Por exemplo, se você deseja instalar um arquivo em / usr / bin. Ele deve ser colocado em pkgdir / usr / bin. Muito poucos procedimentos de instalação exigem que o usuário copie dezenas de arquivos manualmente. Em vez disso, para a maioria dos softwares, chamar make install irá fazê-lo. A última linha deve ser semelhante à seguinte para instalar corretamente o software no diretório pkg: Nota: às vezes é o caso em que DESTDIR não é usado no Makefile você pode precisar usar o prefixo em vez disso. Se o pacote é construído com autoconf / automake. Use DESTDIR isso é o que está documentado nos manuais. Se DESTDIR não funcionar, tente construir com make prefixpkgdir / usr / install. Se isso não funcionar, você terá que olhar mais para os comandos de instalação que são executados por make lt. Gt install. Em alguns casos ímpares, o software espera ser executado a partir de um único diretório. Em tais casos, é aconselhável simplesmente copiá-los para pkgdir / opt. Mais frequentemente do que não, o processo de instalação do software irá criar sub-diretórios abaixo do diretório pkg. No entanto, makepkg irá gerar muitos erros e você precisará criar manualmente subdiretórios adicionando os comandos apropriados do mkdir - p na função build () antes que o procedimento de instalação seja executado. Em pacotes antigos, não havia nenhuma função package (). Assim, os arquivos foram colocados no diretório pkg no final da função build (). Se package () não estiver presente, build () é executado via fakeroot. Em novos pacotes, o pacote () é necessário e é executado via fakeroot e build () executa sem privilégios especiais. Makepkg --repackage executa apenas a função package (), então cria um. pkg. Arquivo sem compilar o pacote. Isto pode poupar tempo, e. Se você apenas mudou a variável dependente do pacote. Nota: A função package () é a única função necessária em um PKGBUILD. Se você só deve copiar arquivos em seus respectivos diretórios para instalar um programa, não o coloque na função build (), coloque isso na função package (). Nota: A criação de links simbólicos é um processo um tanto desajeitado na função package (). Usando a abordagem naive ln - s / from / foo / to / goo resultará em um link simbólico quebrado para o diretório de compilação. A maneira de criar um link adequado é criá-lo apontando para uma fonte inicialmente quebrada, ln - s / from / foo / to / goo. Uma vez que o pacote é instalado, o link irá apontar para o lugar certo. Testando o PKGBUILD eo pacote Como você está escrevendo a função build (), você vai querer testar suas alterações com freqüência para garantir que não haja erros. Você pode fazer isso usando o comando makepkg no diretório que contém o arquivo PKGBUILD. Com um PKGBUILD devidamente formatado. Makepkg criará um pacote com um PKGBUILD quebrado ou inacabado. Ele irá gerar um erro. Se makepkg terminar com êxito, ele colocará um arquivo chamado pkgname-pkgver. pkg. tar. xz em seu diretório de trabalho. Este pacote pode ser instalado com o comando pacman - U. No entanto, apenas porque um arquivo de pacote foi criado não implica que ele é totalmente funcional. Poderia conter apenas o diretório e nenhum arquivo se, por exemplo, um prefixo foi especificado incorretamente. Você pode usar as funções de consulta do pacmans para exibir uma lista de arquivos contidos no pacote e as dependências que ele requer com o arquivo de pacote pacman - Qlp e o arquivo pacman - Qip, respectivamente. Se o pacote parecer sã, então você está concluído No entanto, se você planeja liberar o arquivo PKGBUILD, é imperativo que você verifique e verifique novamente o conteúdo da matriz depende. Certifique-se também de que os binários do pacote realmente funcionam perfeitamente É irritante para liberar um pacote que contém todos os arquivos necessários, mas falha por causa de alguma opção de configuração obscura que não funciona bem com o resto do sistema. Se você só vai compilar pacotes para o seu próprio sistema, no entanto, você não precisa se preocupar muito com esta etapa de garantia de qualidade, como você é a única pessoa que sofre de erros, afinal. Verificação da sanidade do pacote Após testar a funcionalidade do pacote, verifique se há erros usando o namcap. Verifique o conteúdo de PKGBUILD para erros comuns e hierarquia de arquivos de pacote para arquivos desnecessários / incorretos Varre todos os arquivos ELF no pacote usando ldd. Informando automaticamente quais pacotes com bibliotecas compartilhadas necessárias estão faltando de dependentes e que podem ser omitidos como dependências transitivas Heuristicamente procure por dependências em falta e redundantes e muito mais. Adquira o hábito de verificar seus pacotes com namcap para evitar ter que corrigir os erros mais simples após a apresentação do pacote. Enviando pacotes para a AUR Por favor, leia AUR User GuidelinesSubmitting pacotes para uma descrição detalhada do processo de submissão. Resumo Baixe o tarball de origem do software que você deseja compactar. Tente compilar o pacote e instalá-lo em um diretório arbitrário. Copie o protótipo /usr/share/pacman/PKGBUILD. proto e renomeie-o para PKGBUILD em um diretório de trabalho temporário - preferencialmente / abs /. Edite o PKGBUILD de acordo com as necessidades do seu pacote. Execute makepkg e verifique se o pacote resultante é criado corretamente. Caso contrário, repita os dois últimos passos. Avisos Antes de automatizar o processo de construção de pacotes, você deve ter feito manualmente pelo menos uma vez, a menos que saiba exatamente o que está fazendo com antecedência. Caso em que você não estaria lendo isso em primeiro lugar. Infelizmente, apesar de um bom grupo de autores do programa se ater ao ciclo de compilação de 3 etapas do ./configure fazer make install, isso nem sempre é o caso, e as coisas podem ficar muito feias se você tiver que aplicar patches para fazer tudo funcionar em todos . Regra geral: Se você não conseguir obter o programa para compilar do tarball de origem e torná-lo instalar em um subdiretório definido, temporário, você nem precisa tentar empacotá-lo. Não há nenhuma poeira mágica do duende no makepkg que faz com que os problemas da fonte desapareçam. Em alguns casos, os pacotes nem sequer estão disponíveis como fonte e você tem que usar algo como sh installer. run para que ele funcione. Você terá que fazer um pouco de pesquisa (leia READMEs, instruções de instalação, páginas de man, talvez ebuilds de Gentoo ou outros instaladores de pacote, possivelmente até mesmo o MAKEFILEs ou código fonte) para obtê-lo de trabalho. Em alguns casos realmente ruins, você tem que editar os arquivos de origem para obtê-lo para trabalhar em tudo. No entanto, makepkg precisa ser completamente autônomo, sem entrada do usuário. Portanto, se você precisa editar os makefiles, você pode ter que empacotar um patch personalizado com o PKGBUILD e instalá-lo de dentro da função prepare (), ou você pode ter que emitir alguns comandos sed dentro da função prepare (). Diretrizes mais detalhadas Diretrizes de criação de pacotes Veja também3 Etapas fáceis para começar Notícias recentes Sterling cai para um mínimo de 31 ano contra o dólar Opções Binárias Daily Review Por Barry Jenkins. 2016-10-05 O Instituto de Gestão de Abastecimento não-industrial índice nos EUA caiu em agosto para 51,4 de 55,5 em julho, a menor leitura desde fevereiro de 2010 levantando preocupações sobre a saúde geral da economia dos EUA e foi um fator contribuinte para a Federal Reserve não aumentar as taxas de juros em setembro. O índice de atividade de negócios caiu para 51,8 de 59,3 no mês anterior. Os pedidos novos caíram agudamente a 51.4 de 60.3 no mês precedente. Prevê-se que a actividade não-industrial chegue a 53.0 em Setembro. Monitorar o dólar para negociação de opções binárias. Leia mais Brexit preocupações Re-superfície Opções Binárias Daily Review Por Barry Jenkins. 2016-10-04 O PMI de construção no Reino Unido agora postou três leituras retas abaixo do importante nível 50, o que indica que o setor está em contração. A última leitura em agosto mostrou melhora com uma leitura de 49,2. Há pouca mudança esperada na leitura para setembro com uma leitura de 49,0 previsão. Monitorar o Pound para troca de Opções Binárias. Leia mais Bem-vindo ao MarketsWorld - Opções Binárias Licenciadas e Reguladas Trading MarketsWorld é o seu destino de negociação de opções binárias online. Licenciado e regulamentado na Ilha de Man, Grã-Bretanha, garante a segurança de sua conta para que você saiba que seus depósitos e quaisquer ganhos são garantidos. Oferecendo forex, índices e commodities de negociação com os pagamentos mais altos na indústria de opções binárias de até 90 por comércio e os melhores bônus indiscutível e programa de incentivos, há em opções binárias on-line e apostas financeiras. MarketsWorld tem o menor depósito mínimo de apenas 10. Nós também fornecemos acesso a todos os clientes ilimitadas contas demo totalmente gratuito. Veja por que a plataforma de opções binárias licenciada e regulamentada da MarketsWorld britânica é a marca em que você pode confiar. O World is YoursDisclaimer Construir e usar um kernel personalizado tornará muito difícil obter suporte para seu sistema. Embora seja uma experiência de aprendizado para compilar seu próprio kernel, você não terá permissão para registrar bugs no kernel custom-built (se você fizer isso, eles serão Rejeitados sem explicação adicional). Nota: Esta página necessitaria de limpeza significativa. Em vez disso, você pode querer consultar a página do Kernel / BuildYourOwnKernel no wiki do Ubuntu, que é um guia mais limpo e mais atualizado do (simples) edifício do kernel Se você tiver um contrato de suporte comercial com o Ubuntu / Canonical, isso anulará esse suporte. Observe também que esta página descreve como fazer as coisas para o kernel Edgy (2.6.17) e mais recentes. Até esta fonte do kernel, não tínhamos mecanismos no lugar que permitissem às pessoas construir seus próprios kernels facilmente. Isso foi intencional. Esta página NÃO descreve como construir kernels upstream do kernel. org. Isto é como reconstruir o kernel real do Ubuntu a partir da fonte. Razões para compilar um kernel personalizado Você é um desenvolvedor do kernel. Você precisa do kernel compilado de uma maneira especial, que o kernel oficial não é compilado em (por exemplo, com algum recurso experimental habilitado). Você está tentando depurar um problema no kernel do Ubuntu de estoque para o qual você arquivou ou irá arquivar um relatório de bug. Você tem hardware que o kernel Ubuntu não suporta. Você ama computadores e está curioso e interessado em cortar em seu próprio sistema de GNU / Linux para aprender mais sobre como trabalha (com a compreensão que você necessitará reparar qualquer coisa que você quebra). Razões para NÃO compilar um kernel personalizado Você só precisa compilar um driver especial. Para isso, você só precisa instalar os pacotes linux-headers. Você não tem idéia do que está fazendo, e se quebrar algo, você precisará de ajuda para corrigi-lo. Dependendo do que você faz de errado, você pode acabar tendo que reinstalar o seu sistema a partir do zero. Você chegou a esta página por engano, e check-out porque parecia interessante, mas você realmente não quer aprender muito sobre kernels. Se você deseja instalar um novo kernel sem compilação, você pode usar o Synaptic. Procure linux-image e selecione a versão do kernel que deseja instalar. Uma maneira mais fácil é clicar em System gt Administration gt Update Manager. Em seguida, clique no botão Verificar e, finalmente, clique em Aplicar todas as atualizações, incluindo o kernel. Ferramentas que você precisa Para começar, você precisará instalar alguns pacotes. Use uma linha de comando a seguir para instalar com precisão os pacotes necessários para a versão que você está usando: Nota: O pacote makedumpfile não está disponível no Hardy. Get the kernel source There are a few ways to obtain the Ubuntu kernel source: Option A) Use git Use git - This is for users who always want to stay in sync with the latest Ubuntu kernel source. For your information, detailed instructions on it can be found in the Kernel Git Guide The git repository does not include necessary control files, so you must build them by: Option B) Download the source archive Download the source archive - This is for users who want to rebuild the standard Ubuntu packages with additional patches. Note that this will almost always be out of date compared to the latest development source, so you should use git (option A) if you need the latest patches. Use a follow command to install the build dependencies and extract the source (to the current directory): Ubuntu modules source may also be needed if you plan to enable PAE and 64 GiB support in the kernel for 32-bit Hardy (8.04). The Ubuntu supplied modules may not be compatible with a PAE enabled kernel. The source will be downloaded to a subdirectory inside the current directory. Ubuntu Karmic Koala (9.10) and newer releases The source will be downloaded to the current directory as a trio of files (for Lucid, at least) (.orig. tar. gz ..diff. gz . and. dsc ) and a sub-directory. For instance, if uname - r returns 2.6.32-25-generic . youll obtain linux2.6.32.orig. tar. gz . linux2.6.32-25.44.diff. gz . linux2.6.32-25.44.dsc and the sub-directory linux-2.6.32 . Option C) Download the source package Download the source package (detailed instructions are further down this page under Alternate Build Method (B): The Old-Fashioned Debian Way ) - This is for users who simply want to modify, or play around with, the Ubuntu-patched kernel source. Again, this will not be the most up-to-date (use Option A/git if you need the latest source). Please be aware this is NOT the same as Option B/Download the source archive. Modify the source for your needs For most people, simply modifying the configs is enough. If you need to install a patch, read the instructions from the patch provider to learn how to apply it. The stock Ubuntu configs are located in debian/config/ARCH/ where ARCH is the architecture you are building for (Starting with Jaunty this is debian. master/config/ARCH/ ). In this directory there are several files. The config file is the base for all targets in that architecture. Then there are several config. FLAVOUR files that contain options specific to that target. For example, here are the files for 2.6.20, i386: If you do not find the config files under debian/config . you may find them in your /boot directory (for instance, /boot/config-2.6.22-14-generic ) otherwise you should check to see if an alternate location has been specified within debian/debian. env of your kernel source directory. If you need to change a config option, simply modify the file that contains the option. If you modify just the config file, it will affect all targets for this architecture. If you modify one of the target files, it only affects that target. After applying a patch, or adjusting the configs, it is always best to regenerate the config files to ensure they are consistent. There is a helper command for this. To regenerate all architectures run: If you just want to update one architecture . run: Note: If you dont have the debian/ directory after using apt-get source . use dpkg-source - x dsc to extract the sources properly. For these two commands to work, you need to give the scripts in the debian/scripts/misc and debian/scripts directories execute permission with the following command: Build the Kernel(s) There are two listed ways to build the Ubuntu kernel: Build Method A: Build the kernel (when source is from git repository, or from apt-get source) To build the kernel(s) is very simple. Depending on your needs, you may want to build all the kernel targets, or just one specific to your system. However, you also want to make sure that you do not clash with the stock kernels. Note: Though these outside instructions include making a separate and unique branch of the kernel, unlike here, they include thorough explanations of all necessary steps from start to finish. These instructions are specific to the git-tree and for the source downloaded via apt-get source . not when downloading the linux-source package from kernel. org Use this command to build all targets for the architecture you are building on: debian/rules clean creates debian/control . debian/changelog . and so on from debian. ltbranchnamegt/ (e. g. debian. master ). It is necessary in git trees following git commit 3ebd3729ce35b784056239131408b9a72b0288ef UBUNTU: Config Abstract the debian directory. The AUTOBUILD environment variable triggers special features in the kernel build. First, it skips normal ABI checks (ABI is the binary compatibility). It can do this because it also creates a unique ABI ID. If you used a git repo, this unique ID is generated from the git HEAD SHA. If not, it is generated from the uuidgen program (which means every time you execute the debian/rules build, the UUID will be different). Your packages will be named using this ID. (Note that in Intrepid and newer, you will need skipabitrue to skip ABI checks.) To build a specific target . use this command: Where FLAVOUR is one of the main flavours of the kernel (e. g. generic ) To build one of the custom flavours (found in debian/binary-custom. d/ ), use: As of this documentation, custom flavours include xen and rt . If you have a more than one processor or more than one core, you can speed things up by running concurrent compile commands. Prepend CONCURRENCYLEVEL2 for two processors or two cores replace 2 with whatever number suits your hardware setup (for Gutsy and later, you can alternatively use DEBBUILDOPTIONSparallel2 ). If you get ABI errors, you can avoid the ABI check with skipabitrue . For example, To trigger a rebuild, remove the appropriate stamp file from debian/stamps (e. g. stamp-build-server for the server flavour, etc.). The debs are placed in your the parent directory of the kernel source directory. If needed, the Ubuntu modules source for Hardy (8.04) can be built in a similar way. Alternatively, if you need to specify a different kernel than the running one, use If you get an error, try running this in the kerneldir . (example for the generic flavour) Alternate Build Method (B): The Old-Fashioned Debian Way The new Ubuntu build system is great for developers, for people who need the absolute latest bleeding-edge kernel, and people who need to build a diverse set of kernels (several flavours). However it can be a little complex for ordinary users. If you dont need the latest development sources, there is a simpler way to compile your kernel from the linux-source package. As suggested above, all you need for this is: The last command in the sequence brings you into the top directory of a kernel source tree. Before building the kernel, you must configure it. If you wish to re-use the configuration of your currently-running kernel, start with Before you run make menuconfig or make xconfig (which is what the next step tells you to do), make sure you have the necessary packages: If you would like to see what is different between your original kernel config and the new one (and decide whether you want any of the new features), you can run: Since the 2.6.32 kernel, a new feature allows you to update the configuration to only compile modules that are actually used in your system: Then, regardless of whether youre re-using an existing configuration or starting from scratch: What about this. (which is from the Kernel/BuildYourOwnKernel Page in the section Modifying the configuration) If you re-used the existing configuration, note that Ubuntu kernels build with debugging information on, which makes the resulting kernel modules (.ko files) much larger than they would otherwise be. To turn this off, go into the configs Kernel hackinglt-- then, under Kernel debugging, --gt and turn OFF Compile the kernel with debug info. Now you can compile the kernel and create the packages: You can enable parallel make use make - j ). Try 1 number of processor cores . por exemplo. 3 if you have a dual core processor: On a newer kernel, if you only need binary packages and want several builds (while editing the source) to not cause everything to be rebuilt, use: The. deb packages will be created in the parent directory of your Linux source directory (in this example, they would be placed in /src because our Linux source directory is Install the new kernel If you want to see the Ubuntu splash screen (or use text mode) before you get to X instead of just a black screen, youll want to make sure the framebuffer driver loads: Now that youve told initramfs-tools which modules it should include, and once the build is complete, you can install the generated debs using dpkg . Similarly, if you have built the Ubuntu module for Hardy (8.04) earlier, install them as follows: If you use modules from linux-restricted-modules . you will need to recompile this against your new linux-headers package. Note: In response to the various comments in the remainder of this section: On Ubuntu Precise (12.04) it appears that postinst DOES take care of the initramfs stuff. After installing the package my new kernel booted just fine without following any of the methods below. Someone please correct me if Im mistaken. Since Ubuntu Lucid (10.04) the image postinst no longer runs the initramfs creation commands. Instead, there are example scripts provided that will perform the task. These scripts will work for official kernel images as well. For example: Note: I couldnt get the above scripts to help in generating an initrd for the kernel - and so the built kernel couldnt boot the only thing that worked for me was the recommendation in www. debian-administration. org/article/HowDoIMakeaninitrdimage. use initramfs command. It is real solution. what I used (after the custom-built kernels. debs were installed), was: Note (Michael): that is because you need to include the right package scripts to build the initrd at package install time. The make-kpkg option is --overlay-dir . By default, make-kpkg uses /usr/share/kernel-package as an overlay directory, which contains the default, uncustomised scripts for a Debian distribution, and not the ones needed for building a Ubuntu kernel. First copy the default overlay directory to your home directory: Then install the source of the kernel you are using currently, using the exact package name, e. g. which will unpack the sources to HOME/linux-2.6.32. Now copy the control scripts into your new overlay: And now you can execute make-kpkg with the additional command line option --overlay-dirHOME/kernel-package . Rebuilding linux-restricted-modules The linux-restricted-modules (l-r-m) package contains a number of non-DFSG-free drivers (as well as some firmware and the ipw3945 wireless networking daemon) which, in a perfect world, wouldnt have to be packaged separately, but which unfortunately are not available under a GPL-compatible license. If you use any of the hardware supported by the l-r-m package, you will likely find that your system does not work as well after switching to a custom kernel. In this case you should try to compile the l-r-m package. See CustomRestrictedModules on how to rebuild l-r-m (if you use nVidia or ATI binary drivers, you do). Note: you will need around 8 hours of compilation time and around 10 Gb of hard drive space to compile all kernel flavours and restricted modules. Further note: There are no l-r-m or linux-restricted-modules packages in Lucid. Speeding Up the Build Use distcc and, if youre rebuilding often, ccache . A good overview of using distcc on a debian-based system is available at myrddin. org/howto/using-distcc-with-debian. If you have AMD64 machines available on your local area network, they can still participate in building 32-bit code distcc seems to handle that automatically. However, with distcc taking over all compiles by default, you will need to set HOSTCC so that when kernel builds want to use the compiler on the host itself, they dont end up distributing jobs to the 64-bit server. If you fail to do that, youll get link-compatibility failures between 64-bit and 32-bit code. My make-kpkg command, with /usr/lib/ccache at the head of my PATH . looks like: More documentation Comments Please go to the community wiki page for comments, questions and discussion: wiki. ubuntu/KernelCustomBuildHow to: Recompiling / Rebuild Debian / Ubuntu Linux Binary Source File Packages Q. I8217d like to rebuild a Debian / Ubuntu package called foo with additional option. How do I recompile. deb packages A. To build a Debian package, you need the following packages / software installed on system a fakeroot . fakeroot package 8211 runs a command in an environment wherein it appears to have root privileges for file manipulation. This is useful for allowing users to create archives (tar, ar. deb etc.) with files in them with root permissions/ownership. b dpkg-dev . package building tools for Debian c Development environment 8211 You need gcc, make and all other compiler collection installed on system. Under Debian / Ubuntu package build-essential takes care of everything. Step 1: Install required packages Type the following command sudo apt-get install build-essential fakeroot dpkg-dev Step 2: Install source code package First, create a directory to store source package, enter: mkdir build cd build Use apt-get command to install source code for a package called foo sudo apt-get source foo Install all build-dependencies, enter: sudo apt-get build-dep foo Unpacks Debian / Ubuntu source archives with Debian source package (.dsc) manipulation tool, enter: dpkg-source - x fooversion-revision. dsc To just compile the package, you need cd into foo-version directory and issue the command dpkg-buildpackage - rfakeroot - b If you want to pass custom additonal options to configure, you can set up the DEBBUILDOPTIONS environment variable. For instance, if you want pass option called 8211enable-radio 8211enable-gui, enter: DEBBUILDOPTIONS--enable-gui --enable-radio fakeroot debian/rules binary You can also pass some variables to the Makefile. For example, if you want to compile with gcc v3.4, enter: CCgcc-3.4 DEBBUILDOPTIONS--enable-gui --enable-radio fakeroot debian/rules binary A complete example 8211 mplayer Let us see how to rebuild mplayer media player package with 8211enable-radio 8211disable-ivt options: sudo apt-get source mplayer sudo apt-get build-dep mplayer dpkg-source - x mplayerversion-revision. dsc DEBBUILDOPTIONS--enable-gui --enable-radio --disable-ivt fakeroot debian/rules binary Now wait for some time as compile procedure going to take its own time. To install the newly-built package, enter: dpkg - i. /mplayerversion-revisionarch. deb Further readings: