Difference between revisions of "Makepkg (Português)"

From ArchWiki
Jump to: navigation, search
(Uso)
(flagged broken section links (interactive))
(Tag: wiki-scripts)
 
(49 intermediate revisions by 7 users not shown)
Line 1: Line 1:
[[Category:Category:Package_development_(Português)]]
+
[[Category:Package development (Português)]]
[[Category:About_Arch_(Português)]]
+
[[Category:About Arch (Português)]]
 
[[ar:Makepkg]]
 
[[ar:Makepkg]]
 
[[el:Makepkg]]
 
[[el:Makepkg]]
 +
[[en:Makepkg]]
 
[[es:Makepkg]]
 
[[es:Makepkg]]
[[en:Makepkg]]
+
[[fa:Makepkg]]
 
[[fr:makepkg]]
 
[[fr:makepkg]]
 
[[it:Makepkg]]
 
[[it:Makepkg]]
 
[[ja:Makepkg]]
 
[[ja:Makepkg]]
 
[[nl:Makepkg]]
 
[[nl:Makepkg]]
[[pt:Makepkg]]
 
 
[[ru:Makepkg]]
 
[[ru:Makepkg]]
 
[[sr:Makepkg]]
 
[[sr:Makepkg]]
[[tr:Makepkg]]
+
[[zh-hans:Makepkg]]
[[zh-CN:Makepkg]]{{DISPLAYTITLE:makepkg}}
+
{{Related articles start (Português)}}
{{Article summary start}}
+
{{Related|Criando pacotes}}
{{Article summary text|makepkg é um script usado para compilar e empacotar programas para uso com o pacman. Este artigo detalha sua configuração e uso.}}
+
{{Related2|PKGBUILD (Português)|PKGBUILD}}
{{Article summary heading|Visão geral}}
+
{{Related2|Arch User Repository (Português)|Arch User Repository}}
{{Article summary text|Os Pacotes no Arch Linux são construídos usando o [[makepkg]] e um script de construção personalizado para cada pacote (conhecido como [[PKGBUILD]]). Uma vez empacotado, o software pode ser instalado e gerenciado com o [[pacman]]. PKGBUILDs para software nos [[repositórios oficiais]] são disponíves na árvore do [[ABS]]; mais de milhares estão disponíveis no (não suportado) [[Arch User Repository]].}}
+
{{Related2|pacman (Português)|pacman}}
{{Article summary heading|Relacionado}}
+
{{Related|Repositórios oficiais}}
{{Article summary wiki|Criando Pacotes}}
+
{{Related2|Arch Build System (Português)|Arch Build System}}
{{Article summary heading|Resources}}
+
{{Related articles end}}
{{Article summary link|makepkg(8) Página do manual|https://www.archlinux.org/pacman/makepkg.8.html}}
 
{{Article summary link|makepkg.conf(5) Página do manual|https://www.archlinux.org/pacman/makepkg.conf.5.html}}
 
{{Article summary end}}
 
  
Makepkg é usado para compilar e construir um pacote adequado para instalação com o [[pacman]], gerenciador de pacotes do Arch Linux. Makepkg é um script automático para a construção do pacote; podendo fazer o download e validar o arquivo, checando as dependências, configurações do tempo de compilação, compilar o código, instalar temporariamente como root, fazer a personalização, gerar informações, e por fim, fazer todo empacotamento.  
+
[https://projects.archlinux.org/pacman.git/tree/scripts/makepkg.sh.in makepkg] é um script usado para automatizar a compilação de pacotes. Os requisitos para usar o script são uma plataforma tipo Unix capaz de compilar e um [[PKGBUILD (Português)|PKGBUILD]].  
  
O Makepkg é fornecido pelos pacotes do  {{Pkg|pacman}} package.
+
O ''makepkg'' é fornecido pelo pacote {{Pkg|pacman}}.
  
 
== Configuração ==
 
== Configuração ==
  
{{ic|/etc/makepkg.conf}} é o principal arquivo de conficaração para o makepkg. A maioria dos usuários desejam ajustar as opções de configuração para construção dos pacotes.  
+
Veja {{man|5|makepkg.conf}} para detalhes sobre as opções de configuração do ''makepkg''.
 +
 
 +
A configuração do sistema está disponível em {{ic|/etc/makepkg.conf}}, mas alterações específicas para cada usu[ario podem ser feitas em {{ic|$XDG_CONFIG_HOME/pacman/makepkg.conf}} ou {{ic|~/.makepkg.conf}}. É recomendado revisar a configuração antes de compilar pacotes.
 +
 
 +
=== Informação do empacotador ===
 +
 
 +
Cada pacote é marcado com metadados identificando, entre outros, também o ''empacotador''. Por padrão, os pacotes compilados pelo usuário são marcados com {{ic|Empacotador desconhecido}}. Se vários usuários estiverem compilando pacotes em um sistema, ou de outra forma distribuindo seus pacotes para outros usuários, é conveniente fornecer contato real. Isso pode ser feito configurando a variável {{ic|PACKAGER}} em {{ic|makepkg.conf}}.
 +
 
 +
Para verificar isso em um pacote instalado:
 +
 
 +
{{hc|$ pacman -Qi ''pacote''|<nowiki>
 +
...
 +
Empacotador      : John Doe <john@doe.com>
 +
...
 +
</nowiki>}}
 +
 
 +
Para automaticamente produzir pacotes assinados, defina também a variável {{ic|GPGKEY}} em {{ic|makepkg.conf}}.
 +
 
 +
=== Saída de pacote ===
 +
 
 +
Por padrão, ''makepkg'' cria os ''tarballs'' de pacote no diretório atual de trabalho e baixa os dados fonte diretamente para o diretório {{ic|src/}}. Caminhos personalizados podem ser configurados, por exemplo, para manter todos os pacotes compilados em {{ic|~/build/pacotes/}} e todos os fontes em {{ic|~/build/fontes/}}.
 +
 
 +
Configure as seguintes variáveis do {{ic|makepkg.conf}}, se necessário:
 +
 
 +
* {{ic|PKGDEST}} &ndash; diretório para armazenar pacotes resultantes
 +
* {{ic|SRCDEST}} &ndash; diretório para armazenar dados [[PKGBUILD (Português)#source|fonte]] (links simbólicos serão colocados em {{ic|src/}} se ele aponta para outro lugar)
 +
* {{ic|SRCPKGDEST}} &ndash; diretório para armazenar os pacotes fontes (compilado com {{ic|makepkg -S}})
 +
 
 +
=== Verificação de assinatura ===
 +
 
 +
{{Nota|A verificação de assinatura implementada no ''makepkg'' não usa o chaveiro do pacman; em vez disso, depende do chaveiro do usuário.[http://allanmcrae.com/2015/01/two-pgp-keyrings-for-package-management-in-arch-linux/]}}
 +
 
 +
Se um arquivo de assinatura na forma de {{ic|.sig}} ou {{ic|.asc}} é parte do vetor fonte do [[PKGBUILD (Português)|PKGBUILD]], o ''makepkg'' tenta automaticamente [[GnuPG#Verify a signature|verificá-la]]. No caso do chaveiro do usuário não contém a chave pública necessária para verificação de assinatura, o ''makepkg'' vai abortar a instalação com uma mensagem de que a chave PGP não pôde ser verificada.
 +
 
 +
Se uma chave pública necessária para um pacote está faltando, o [[PKGBUILD (Português)|PKGBUILD]] muito provavelmente vai conter uma entrada [[PKGBUILD (Português)#validpgpkeys|validpgpkeys]] com os IDs de chaves necessárias. Você pode [[GnuPG#Import_a_public_key|importá-la]] manualmente ou você pode localizá-la [[GnuPG#Use_a_keyserver|em um servidor de chaves]] e importá-la de lá.
 +
 
 +
== Uso ==
 +
 
 +
Antes de continuar, [[instale]] o grupo {{Grp|base-devel}}. Os pacotes que pertencem a este grupo '''não''' são exigidos na lista de dependência de compilação (''makedepends'') nos arquivos [[PKGBUILD (Português)|PKGBUILD]]. Além disso, o grupo {{Grp|base}} é presumido como estando instalado em '''todos''' os sistemas Arch.
 +
 
 +
{{Nota|1=
 +
* Certifique-se de que o [[sudo]] está configurado corretamente para comandos passados para o [[pacman (Português)|pacman]].
 +
* Executar ''makepkg'' em si como root [https://lists.archlinux.org/pipermail/pacman-dev/2014-March/018911.html não é permitido].[https://projects.archlinux.org/pacman.git/tree/NEWS] Além disso, como um {{ic|PKGBUILD}} pode conter comandos arbitrários, compilar como root geralmente é considerado inseguro.[https://bbs.archlinux.org/viewtopic.php?id&#61;67561] Usuários que não possuem acesso a uma conta de usuário comum devem executar o makepkg como o [http://allanmcrae.com/2015/01/replacing-makepkg-asroot/ usuário ''nobody''].
 +
}}
 +
 
 +
Para compilar um pacote, deve-se primeiro criar um [[PKGBUILD (Português)|PKGBUILD]], ou um script de compilação, como descrito em [[Criando pacotes]]. Scripts existentes estão disponíveis na árvore do [[Arch Build System (Português)|Arch Build System]] ''(ABS)'' ou do [[AUR (Português)|AUR]]. Uma vez em posse de um {{ic|PKGBUILD}}, altere o diretório no qual está salvo e execute o seguinte comando para compilar o pacote:
 +
 
 +
$ makepkg
 +
 
 +
Se estiverem faltando dependências necessárias, o ''makepkg'' emitirá um aviso antes de falhar. Para compilar o pacote e instalar as dependências necessárias, adicione a opção {{ic|-s/--syncdeps}}:
 +
 
 +
$ makepkg --syncdeps
 +
 
 +
Adicionar as opções {{ic|-r}}/{{ic|--rmdeps}} faz com que o ''makepkg'' remova as dependências de compilação logo em seguida, já que não são mais necessárias. Se estiver compilando pacotes constantemente, considere usar [[Pacman/Dicas e truques#Removendo pacotes não usados (órfãos)]] de vez em quando.
 +
 
 +
{{Nota|
 +
* Essas dependências devem estar disponíveis nos repositórios configurados; veja [[pacman#Repositórios e espelhos]]{{Broken section link}} para detalhes. Alternativamente, pode-se instalar manualmente as dependências antes de compilar ({{ic|pacman -S --asdeps ''dep1'' ''dep2''}}).
 +
* Apenas valores globais são usados ao instalar dependências, ou seja, qualquer sobrescrição feita em uma função de empacotamento de pacotes divididos não serão sadas.[https://patchwork.archlinux.org/patch/2271/]}}
 +
 
 +
Uma vez que todas as dependências estejam satisfeitas e os pacotes compilados com sucesso, um arquivo de pacote ({{ic|''pkgname''-''pkgver''.pkg.tar.xz}}) será criado no diretório. Para instalar, use {{ic|-i}}/{{ic|--install}} (o mesmo que {{ic|pacman -U ''pkgname''-''pkgver''.pkg.tar.xz}}):
 +
 
 +
# pacman --install
 +
 
 +
Para limpar arquivos e pastas restantes, tais como arquivos extraídos para ${{ic|$srcdir}}, adicione a opção {{ic|-c}}/{{ic|--clean}}. Isso é útil para várias compilações do mesmo pacote ou ao atualizar a versão do pacote, enquanto usa a mesma pasta de compilação. Isso evita arquivos obsoletos e remanescentes de serem carregados para novas compilações:
 +
 
 +
$ makepkg --clean
 +
 
 +
Para mais informações, veja [https://www.archlinux.org/pacman/makepkg.8.html makepkg(8)].
 +
 
 +
== Dicas e truques ==
 +
 
 +
=== Compilando binários otimizados ===
 +
 
 +
Uma melhoria de desempenho do software empacotado pode ser conseguida ao habilitar otimizações do compilador para a máquina host. A desvantagem é que os binários compilados para uma arquitetura de processador específica não serão executados corretamente em outras máquinas. Nas máquinas x86_64, raramente existem ganhos de desempenho reais reais significativos que justificariam investir o tempo para reconstruir pacotes oficiais.
 +
 
 +
No entanto, é muito fácil reduzir o desempenho usando ''flags'' de compilação "não padronizadas". Muitas otimizações de compilação só são úteis em certas situações e não devem ser aplicadas indiscriminadamente em cada pacote. A menos que você possa verificar/avaliar que algo é mais rápido, há uma chance muito boa de não ser! O [http://www.gentoo.org/doc/en/gcc-optimization.xml Guia de Otimização de Compilação] e artigo wiki [http://wiki.gentoo.org/wiki/Safe_CFLAGS CFLAGS Seguras] do Gentoo (ambos em inglês) fornecem mais informações detalhadas sobre a otimização do compilador.
 +
 
 +
As opções passadas para um compilador C/C++ (ex.: {{Pkg|gcc}} ou {{Pkg|clang}}) são controladas pelas variáveis de ambiente {{ic|CFLAGS}}, {{ic|CXXFLAGS}} e{{ic|CPPFLAGS}}. Para usar o sistema de compilação do Arch, o ''makepkg'' expõe essas variáveis de ambiente como opções de configuração no {{ic|makepkg.conf}}. Os valores padrão são configurados para produzir binários genéricos que podem ser instalados em uma ampla gama de máquinas.
 +
 
 +
{{Nota|1=
 +
* Tenha em mente que nem todos os sistemas de compilação usam as variáveis configuradas no {{ic|makepkg.conf}}. Por exemplo, ''cmake'' ignora a variável de ambiente das opções de pré-processador, {{ic|CPPFLAGS}}. Consequentemente, muitos [[PKGBUILD (Português)|PKGBUILD]] contêm soluções alternativas com opções específicas para o sistema de compilação usado pelo software empacotado.
 +
* A configuração fornecida com o código fonte no {{ic|Makefile}} ou em um argumento específico na linha de comando de compilação tem a preferência e pode potencialmente sobrescrever aquela no {{ic|makepkg.conf}}.
 +
}}
 +
 
 +
O GCC pode detectar e habilitar automaticamente otimizações seguras específicas para cada arquitetura. Para usar esse recurso, primeiro remova os sinalizadores {{ic|-march}} e {{ic|-mtune}}, então adicione {{ic|1=-march = native}}. Por exemplo:
 +
{{hc|/etc/makepkg.conf|2=
 +
CFLAGS="'''-march=native''' -O2 -pipe -fstack-protector-strong -fno-plt"
 +
CXXFLAGS="${CFLAGS}"}}
 +
Para ver quais sinalizadores isso habilita em sua máquina, execute:
 +
 
 +
$ gcc -march=native -v -Q --help=target
  
=== Arquitetura, compilação flags ===
+
{{Nota|1=Se você especificar um valor diferente de {{ic|1=-march=native}}, então {{ic|1=-Q --help=target}} '''não vai''' funcionar como esperado.[https://bbs.archlinux.org/viewtopic.php?pid=1616694#p1616694] Você precisa passar por uma fase de compilação para descobrir quais opções estão realmente habilitadas. Veja [https://wiki.gentoo.org/wiki/Safe_CFLAGS#Find_CPU-specific_options Encontre opções específicas da CPU] (inglês) no wiki do Gentoo para instruções.}}
As opções {{ic|MAKEFLAGS}}, {{ic|CFLAGS}}, e {{ic|CXXFLAGS}} são usadas pelo {{Pkg|make}}, {{Pkg|gcc}}, e {{ic|g++}} enquanto a compilação de programa é com makepkg. Por padrão, essas opções de gerar pacotes genéricos podem ser instalados em uma ampla variedade de máquinas. Um ganho de desempenho pode ser alcançado por compilação de ajuste para o computador. A desvantagem é que os pacotes compilados especificamente para o processador do computador podem não funcionar em outras máquinas.
 
  
{{Nota|Tenha em mente que nem todos os sistemas de compilação de pacote usarão suas variáveis ​​exportadas. Algumas as substuem no makefile original ou [[PKGBUILD]].}}
+
=== Melhorando os tempos de compilação ===
  
{{hc|/etc/makepkg.conf|<nowiki>
+
==== Compilação paralela ====
[...]
 
  
#########################################################################
+
O sistema de compilação do {{Pkg|make}} usa a [[environment variable|variável de ambiente]] {{ic|MAKEFLAGS}} para especificar opções adicionais para o ''make''. A variável também pode ser definida no arquivo {{ic|makepkg.conf}}.
# ARCHITECTURE, COMPILE FLAGS
 
#########################################################################
 
#
 
CARCH="x86_64"
 
CHOST="x86_64-unknown-linux-gnu"
 
  
#-- Exclusivo: só vai funcionar em x86_64
+
Os usuários com sistemas multi-core/multiprocessados podem especificar o número de trabalhos a serem executados simultaneamente. Isso pode ser realizado com o uso de ''nproc'' para determinar o número de processadores disponíveis, ex. {{ic|1=MAKEFLAGS="-j$(nproc)"}}. Alguns [[PKGBUILD (Português)|PKGBUILD]] substituem especificamente isso com {{ic|-j1}}, devido a condições de corrida em certas versões ou simplesmente porque não é suportado em primeiro lugar. Os pacotes que não conseguem ser compilados devido a isso devem ser [[Diretrizes de relatórios de erro|relatados]] no rastreador de erros (ou no caso dos pacotes do [[AUR (Português)|AUR]], ao mantenedor do pacote) depois de ter certeza de que o erro está sendo realmente causado pelo seu {{ic|MAKEFLAGS}}.
# -march (ou -mcpu) constrói exclusivamente para uma arquitetura
 
# -mtune otimiza para uma arquitetura, mas constrói para toda família de processadores
 
CPPFLAGS="-D_FORTIFY_SOURCE=2"
 
CFLAGS="-march=x86-64 -mtune=generic -O2 -pipe -fstack-protector --param=ssp-buffer-size=4"
 
CXXFLAGS="-march=x86-64 -mtune=generic -O2 -pipe -fstack-protector --param=ssp-buffer-size=4"
 
LDFLAGS="-Wl,-O1,--sort-common,--as-needed,-z,relro"
 
#-- Make Flags: mude este para sistemas DistCC/SMP
 
#MAKEFLAGS="-j2"
 
  
[...]
+
Veja {{man|1|make}} para uma lista completa de opções disponíveis.
</nowiki>}}
+
 
 +
==== Compilando de arquivos na memória ====
 +
 
 +
Como a compilação requer muitas operações de E/S e lidar com arquivos pequenos, mover o diretório de trabalhos para um [[tmpfs]] pode trazer melhorias em tempos de compilação.
  
O padrão makepkg.conf {{ic|CFLAGS}} e {{ic|CXXFLAGS}} são compatíveis com todas as máquinas dentro de suas respectivas arquiteturas.
+
A variável {{ic|BUILDDIR}} pode ser temporariamente exportada para ''makepkg'' para definir o diretório de compilação para um tmpfs existente. Por exemplo:
  
Em máquinas x86_64, há ganhos raramentes significativos o bastante de desempenho mundial que justifiquem investir o tempo para reconstruir os pacotes oficiais.
+
$ BUILDDIR=/tmp/makepkg makepkg
  
A partir da versão 4.3.0, GCC disponibiliza o {{ic|1=-march=native}} que permite auto-detecção da CPU e seleciona automaticamente as otimizações suportadas pela máquina local no tempo de execução GCC. Para usá-lo, basta modificar as configurações padrão, alterando as linhas {{ic|CFLAGS}} e {{ic|CXXFLAGS}}:
+
{{Atenção|Evite compilar pacotes grandes no tmpfs para evitar ficar sem memória.}}
  
# -march=native também define correto o -mtune=
+
Uma configuração persistente pode ser feita no {{ic|makepkg.conf}} descomentando a opção {{ic|BUILDDIR}}, que é encontrada no fim da seção {{ic|BUILD ENVIRONMENT}} no arquivo padrão {{ic|/etc/makepkg.conf}}. Definir esses valores para, por exemplo, {{ic|1=BUILDDIR=/tmp/makepkg}} fará uso do sistema de arquivos temporário {{ic|/tmp}} padrão do Arch.
CFLAGS="-march=native -O2 -pipe -fstack-protector --param=ssp-buffer-size=4 -D_FORTIFY_SOURCE=2"
 
CXXFLAGS="${CFLAGS}"
 
  
{{Dica |Para ver quais flags o {{ic|1=march=native}} define, execute:
+
{{Nota|1=
<nowiki>$ gcc -march=native -E -v - </dev/null 2>&1 | sed -n 's/.* -v - //p'</nowiki>
+
* A pasta [[tmpfs]] deve ser montada sem a opção {{ic|noexec}}; do contrário, ela vai impedir que binparios sejam executados.
 +
* Tenha em mente que pacotes compilados no [[tmpfs]] não persistirá após reinicialização. Considere configurar a opção [[#Saída de pacote|PKGDEST]] apropriadamente para mover o pacote compilado automaticamente para um diretório persistente.
 
}}
 
}}
  
Otimizar ainda mais para o tipo de CPU pode, teoricamente, aumentar o desempenho, pois o {{ic|1=-march=native}} permite que todas as instruções disponíveis definem e melhorem o agendamento para uma determinada CPU. Isto é especialmente perceptível na reconstrução de aplicativos (por exemplo: áudio/ferramentas de decodifição de video, aplicações científicas, programas matemáticos pesados, etc.) que podem tiram uma boa vantagem de configurações de instruções mais recentes não habilitadas ao usar opções padrão (ou pacotes) fornecido pelo Arch Linux.
+
==== Usando cache de compilação ====
  
É muito fácil reduzir o desempenho usando o CFLAGS "não-padrão", porque compiladores tendem fortamente passar o tamanho do código com loop, mal vetorização, louco inlining, etc. dependendo do compilador. A menos que possa verificar/benchmark que é mais rápido, há uma chance muito boa nisso!
+
O uso de [[ccache (Português)|ccache]] pode melhorar os tempos de compilação ao armazenar em cache os resultados de compilações para uso sucessivo.
  
Veja a página de manual do GCC para uma lista completa de opções disponíveis. O artigo wiki Gentoo [http://www.gentoo.org/doc/en/gcc-optimization.xml Compilation Optimization Guide] e [http://wiki.gentoo.org/wiki/Safe_CFLAGS Safe CFLAGS] fornecem informações mais profundas.
+
=== Gerar novos checksums ===
  
====MAKEFLAGS====
+
Execute o seguinte comando no mesmo diretório que o arquivo PKGBUILD para gerar novas somas de verificação (''checksums''):
A opção {{ic|MAKEFLAGS}} pode ser usada para especificar opções adicionais a fazer. Usuários com sistemas multi-core/multi-processador podem especificar o número de tarefas para executar simultaneamente. Isto pode ser feito com o uso do {{ic|nproc}} para determinar o número de processadores disponíveis, e.x. {{ic|-j4}} ''(onde 4 é a saída de {{ic|nproc}})''. Alguns especificamente do [[PKGBUILD]] substituem isso com {{ic|-j1}}, por causa de corriqueira condições em determinadas versões ou simplesmente porque isso não é suportado, em primeiro lugar. Os pacotes que falham ao construir por causa disso devem ser [[Reporting Bug Guidelines|reportados]] no bug tracker depois de ter certeza que o erro é de fato causado por sua MAKEFLAGS.
 
  
Consulte {{ic|man make}} para obter uma lista completa das opções disponíveis.
+
$ updpkgsums
  
=== Saída de pacote ===
+
=== Usar outros algoritmos de compressão ===
 +
 
 +
Para acelerar o empacotamento e a instalação, com a consequência de ter arquivos de pacotes maiores, você pode alterar {{ic|PKGEXT}}. Por exemplo, o seguinte torna o arquivo de pacote descompactado para apenas uma invocação:
 +
 
 +
$ PKGEXT='.pkg.tar' makepkg
 +
 
 +
Um outro exemplo abaixo mostra o uso do algoritmo lzop, com o pacote {{pkg|lzo}} necessário:
 +
 
 +
$ PKGEXT='.pkg.tar.lzo' makepkg
 +
 
 +
Para fazer uma dessas configurações permanentes, configure {{ic|PKGEXT}} em {{ic|/etc/makepkg.conf}}.
 +
 
 +
=== Usando vários núcleos na compressão ===
  
Em seguida, pode-se configurar onde os arquivos de origem e pacotes deverão ser colocados e identificá-los como empacotadores. Esta etapa é opcional, pacotes serão criados no diretório de trabalho, onde o makepkg é executado por padrão.
+
O {{pkg|xz}} oferece suporte a [[Wikipedia:pt:Multiprocessamento simétrico|multiprocessamento simétrico (SMP)]] por meio do sinalizador {{ic|--threads}} para acelerar a compressão. Por exemplo, para deixar o makepkg usar quantos núcleos de CPU for possível para comprimir os pacotes, edite o vetor {{ic|COMPRESSXZ}} em {{ic|/etc/makepkg.conf}}:
  
{{hc|/etc/makepkg.conf|<nowiki>
+
COMPRESSXZ=(xz -c -z - '''--threads=0''')
[...]
 
  
#########################################################################
+
O {{pkg|pigz}} é uma implementação paralela para o {{pkg|gzip}} que, por padrão, usa todos os núcleos disponíveis na CPU (o sinalizador {{ic|-p/--processes}} pode ser usado para empregar menos núcleos):
# PACKAGE OUTPUT
 
#########################################################################
 
#
 
# Default: put built package and cached source in build directory
 
#
 
#-- Destination: specify a fixed directory where all packages will be placed
 
#PKGDEST=/home/packages
 
#-- Source cache: specify a fixed directory where source files will be cached
 
#SRCDEST=/home/sources
 
#-- Source packages: specify a fixed directory where all src packages will be placed
 
#SRCPKGDEST=/home/srcpackages
 
#-- Packager: name/email of the person or organization building packages
 
#PACKAGER="John Doe <john@doe.com>"
 
  
[...]
+
COMPRESSGZ=('''pigz''' -c -f -n)
</nowiki>}}
 
  
Por exemplo, crie o diretório:
+
=== Mostrar pacotes com um empacotador específico ===
  
$ mkdir /home/$USER/packages
+
Isso mostra todos os pacotes instalados no sistema com o empacotador chamado ''nome-empacotador'':
  
Então modifique a variável {{ic|PKGDEST}} em {{ic|/etc/makepkg.conf}} adequadamente.
+
$ expac "%n %p" | grep "''nome-empacotador''" | column -t
  
A variável {{ic|PACKAGER}} definirá o valor {{ic|packager}} dentro dos arquivos de pacotes compilados metadata' {{ic|.PKGINFO}}. Por padrão, usuários-pacotes compilados exibirão:
+
Isso mostra todos os pacotes instalados no sistema com o empacotador definido na variável {{ic|PACKAGER}} do {{ic|/etc/makepkg}}. Isso mostra apenas pacotes que estão em um repositório definido em {{ic|/etc/pacman.conf}}.
  
{{hc|pacman -Qi package|<nowiki>
+
$ . /etc/makepkg.conf; grep -xvFf <(pacman -Qqm) <(expac "%n\t%p" | grep "$PACKAGER$" | cut -f1)
[...]
 
Packager      : Unknown Packager
 
[...]
 
</nowiki>}}
 
  
Afterwards:
+
=== Compilar pacotes 32 bits em um sistema 64 bits ===
  
{{hc|pacman -Qi package|<nowiki>
+
{{Atenção|Erros foram relatados ao usar esse método par compilar o pacote {{Pkg|linux}}. O [[Install bundled 32-bit system in 64-bit system|método de instalação]] é preferível e verificou-se que funciona para compilar os pacotes do kernel.}}
[...]
 
Packager      : John Doe <john@doe.com>
 
[...]
 
</nowiki>}}
 
  
Será útil se vários usuários copilarem pacotes em um sistema, ou se você for distribuir seus pacotes para outros usuários.
+
Primeiro, habilite o repositório [[multilib (Português)|multilib]] e [[instale]] {{Grp|multilib-devel}}.
  
=== Verificação de assinatura ===
+
Então, crie um arquivo de configuração 32 bits
O procedimento a seguir não é necessário para compilar com makepkg, para a sua configuração inicial, vá para [[#Usage]]. Para desativar temporariamente a verificação de assinatura chame o comando makepkg com a opção {{ic|--skippgpcheck}}.
 
Se um arquivo de assinatura na forma de .sig faz parte da array de orgigem [[PKGBUILD]], makepkg valida a autenticidade dos arquivos de origem. Por exemplo, a assinatura pkgname-pkgver.tar.gz.sig é usada para verificar a integridade do arquivo pkgname-pkgver.tar.gz com o programa gpg. Se desejar,  assinaturas de outros desenvolvedores podem ser adicionadas manualmente ao conjunto de chaves gpg. Veja no artigo [[GnuPG]] para mais informação.
 
  
{{Nota|A verificação de assinatura implementada no makepkg não usa o conjunto de chaves do pacman. Configure gpg como explicado abaixo para permitir que o makepkg leia o conjunto de chaves do pacman.}}
+
{{hc|~/.makepkg.i686.conf|<nowiki>
 +
CARCH="i686"
 +
CHOST="i686-unknown-linux-gnu"
 +
CFLAGS="-m32 -march=i686 -mtune=generic -O2 -pipe -fstack-protector-strong"
 +
CXXFLAGS="${CFLAGS}"
 +
LDFLAGS="-m32 -Wl,-O1,--sort-common,--as-needed,-z,relro"</nowiki>}}
  
As chaves GPG devem ser armazenados no arquivo de usuário {{ic|~/.gnupg/pubring.gpg}}. No caso de não conter a assinatura determinada, makepkg mostra um aviso.
+
e chame o makepkg assim
{{hc|makepkg|<nowiki>
+
$ linux32 makepkg --config ~/.makepkg.i686.conf
[...]
 
==> Verifying source file signatures with gpg...
 
pkgname-pkgver.tar.gz ... FAILED (unknown public key 1234567890)
 
==> WARNING: Warnings have occurred while verifying the signatures.
 
    Please make sure you really trust them.
 
[...]
 
</nowiki>}}
 
Para mostrar a lista atual de chaves GPG use o comando gpg.
 
{{bc|gpg --list-keys}}
 
Se não existe o arquivo pubring.gpg, ele será criado para você imediatamente.
 
Agora você pode prosseguir com a configuração gpg para permitir a compilação de pacotes AUR submetidos pelos desenvolvedores do Arch Linux com verificação com sucesso de assinatura.
 
Adicione a seguinte linha no final do arquivo de configuração gpg para incluir conjunto de chaves pacman no conjunto de chaves pessoal do usuário.
 
{{hc|~/.gnupg/gpg.conf|<nowiki>
 
[...]
 
keyring /etc/pacman.d/gnupg/pubring.gpg
 
</nowiki>}}
 
Quando for configurado como dito anteriormente, a saída de {{ic|gpg --list-keys}} contém uma lista de conjunto de chaves e desenvolvedores. Agora makepkg pode compilar pacotes AUR apresentados pelos desenvolvedores Arch Linux com a verificação com sucesso de assinatura.
 
  
=== {{Ic|fakeroot}} ===
+
== Solução de problemas ==
  
Fakeroot é a permisão normal do usuário sem a necessidade do root para criar um pacote, sem poder alterar o sistema por completo. Se as tentativas de alterar o processo em construção fora do ambiente de compilação, os erros são abordados e mostra a falha – para verificar a qualidade/segurança/integridade nos PKGBUILDs para a distribuição. Por default, o fakeroot é habilitado no diretório “/etc/make.pkg”; o usuário por opção pode por '''!''' no BUILDENV para desabilitar.
+
=== Makepkg algumas vezes falha ao assinar um pacote sem perguntar pela palavra-chave de assinatura ===
  
== Uso ==
+
Com o [https://www.gnupg.org/faq/whats-new-in-2.1.html gnupg 2.1], gpg-agent agora é iniciado automaticamente pelo gpg. O problema surge no estágio do pacote de {{ic|makepkg --sign}}. Para permitir os privilégios corretos, {{pkg|fakeroot}} executa a função {{ic|package()}} iniciando o gpg-agent dentro do mesmo ambiente ''fakeroot''. Na saída, o ''fakeroot'' limpa os semáforos fazendo com que a "escrita" termine o ''pipe'' para fechar para aquela instância do gpg-agent que resultará em um erro de ''pipe'' quebrado. Se o mesmo gpg-agent estiver em execução quando {{ic|makepkg --sign}} estiver próximo de executado, então o gpg-agent retorna código de saída 2; então a seguinte saída ocorre:
  
Antes de continuar, verifique se o grupo {{Grp|base-devel}} está instalado. Os pacotes que pertencem a este grupo não são requeridos na lista de dependência nos arquivos [[PKGBUILD]]. A instalação do grupo "base-devel" é como root:
+
==> Assinando pacote...
 +
==> ATENÇÃO: Falha em assinar arquivo de pacote.
  
# pacman -S base-devel
+
Esse erro está atualmente sendo rastreado: {{Bug|49946}}. Uma solução temporária de contorno para esse problema é executar {{ic|killall gpg-agent && makepkg --sign}}. Esse problema está resolvido no {{aur|pacman-git}}, especificamento no hash de commit {{ic|c6b04c04653ba9933fe978829148312e412a9ea7}}
  
{{Nota|Antes de reclamar sobre a falta (criar) pacotes, lembre-se sobre o grupo “base” que assume a instalação de todo o sistema do Arch Linux. O grupo "base-devel" assume toda a instação durante a construção com o '''makepkg'''.}}
+
=== CFLAGS/CXXFLAGS/CPPFLAGS no makepkg.conf não funciona para pacotes baseados no QMAKE ===
  
A construção do pacote, necessita criar um primeiro [[PKGBUILD]], ou Script, com descrição na [[Creating Packages]], ou obter a partir [[Arch Build System|ABS tree]], [[Arch User Repository]], ou atráves de outras fontes.
+
Qmake configura automaticamente a variável {{ic|CFLAGS}} e {{ic|CXXFLAGS}} de acordo com o que você pensa que deveria ser a configuração correta. Para deixar o qmake usar as variáveis definidas no arquivo de configuração do makepkg, você deve editar o PKGBUILD e passar as variáveis [http://doc.qt.io/qt-5/qmake-variable-reference.html#qmake-cflags-release QMAKE_CFLAGS_RELEASE] e [http://doc.qt.io/qt-5/qmake-variable-reference.html#qmake-cxxflags-release QMAKE_CXXFLAGS_RELEASE] ao qmake. Por exemplo:
  
{{Atenção |Apenas construção/instalação de pacotes com fontes confiáveis.}}
+
{{hc|PKGBUILD|<nowiki>
 +
...
  
Com o {{ic|PKGBUILD}}, mude para o diretório onde ele se encontra e execute o seguinte comando para construir o pacote descrito pelo {{ic|PKGBUILD}}:
+
build() {
 +
  cd "$srcdir/$_pkgname-$pkgver-src"
 +
  qmake-qt4 "$srcdir/$_pkgname-$pkgver-src/$_pkgname.pro" \
 +
    PREFIX=/usr \
 +
    QMAKE_CFLAGS_RELEASE="${CFLAGS}"\
 +
    QMAKE_CXXFLAGS_RELEASE="${CXXFLAGS}"
  
$ makepkg
+
  make
 +
}
  
Para que o makepkg limpe arquivos e pastas restantes, tais como arquivos extraídos para o $srcdir, adicione a seguinte opção. É útil para vários construções do mesmo pacote ou ao atualizar a versão do pacote, enquanto usa a mesma pasta de compilação.
+
...
 +
</nowiki>}}
  
$ makepkg -c
+
Alternativamente, para uma configuração para todo sistema, você pode criar seu próprio {{ic|qmake.conf}} e configurar a variável de ambiente [http://doc.qt.io/qt-5/qmake-environment-reference.html#qmakespec QMAKESPEC].
  
Se está faltando dependências necessárias, makepkg emitirá um aviso antes de falhar. Para construir o pacote e instalar as dependências automaticamente, basta usar o comando:
+
=== Especificando diretório de instalação para pacotes baseados em QMAKE ===
  
$ makepkg -s
+
O makefile gerado pelo qmake usa a variável de ambiente INSTALL_ROOT para especificar onde o programa deve ser instalado. Então, essa função ''package'' deve funcionar:
  
Note que essas dependências devem estar disponíveis nos repositórios configurados, consulte [[pacman#Repositories]] para detalhes. Alternativa para instalação manual de dependência antes da construção ({{ic|pacman -S --asdeps dep1 dep2}}).
+
{{hc|PKGBUILD|<nowiki>
 +
...
  
Uma vez que todas as dependências estão satisfeita e os pacotes construídos, um arquivo de pacote ({{ic|pkgname-pkgver.pkg.tar.xz}}) será criado no diretório. Para instalação, como root:
+
package() {
 +
cd "$srcdir/${pkgname%-git}"
 +
make INSTALL_ROOT="$pkgdir" install
 +
}
  
# pacman -U pkgname-pkgver.pkg.tar.xz
+
...
 +
</nowiki>}}
  
Alternativamente, para instalar, usando o {{ic|-i}} é um jeito mais fácil de executar {{ic|pacman -U pkgname-pkgver.pkg.tar.xz}}, como:
+
Note que o qmake também tem que ser configurado adequadamente. Por exemplo, coloque isso em seu arquivo .pro:
  
$ makepkg -i
+
{{hc|SeuProjeto.pro|<nowiki>
 +
...
  
== Dicas e Truques ==
+
target.path = /usr/local/bin
=== Gerar novos md5sums ===
+
INSTALLS += target
Desde [http://allanmcrae.com/2013/04/pacman-4-1-released/ pacman 4.1] {{ic|makepkg -g >> PKGBUILD}} não é mais necessário como pacman-contrib foi [https://projects.archlinux.org/pacman.git/tree/NEWS merged] juntamente com o script {{ic|updpkgsums}} capaz de gerar novos checksums e substituí-los no PKGBUILD:
 
$ updpkgsums
 
  
=== Makepkg fonte PKGBUILD duas vezes ===
+
...
Makepkg fontes a PKGBUILD duas vezes (uma quando executado, e a segunda sob fakeroot). Qualquer função não-padrão colocada no PKGBUILD será executada duas vezes também.
+
</nowiki>}}
  
 
=== AVISO: O pacote contém referência para $srcdir ===
 
=== AVISO: O pacote contém referência para $srcdir ===
 +
 
De alguma forma, as strings literais {{ic|$srcdir}} ou {{ic|$pkgdir}} acabaram em um dos arquivos instalados no seu pacote.
 
De alguma forma, as strings literais {{ic|$srcdir}} ou {{ic|$pkgdir}} acabaram em um dos arquivos instalados no seu pacote.
  
Line 213: Line 275:
 
  $ grep -R "$(pwd)/src" pkg/
 
  $ grep -R "$(pwd)/src" pkg/
  
[http://www.mail-archive.com/arch-general@archlinux.org/msg15561.html Link] em discussão.
+
[http://www.mail-archive.com/arch-general@archlinux.org/msg15561.html Link] para a discussão.
  
 
== Veja também ==
 
== Veja também ==
* [https://github.com/pixelb/scripts/blob/master/scripts/gcccpuopt gcccpuopt]: Um script para mostrar as opções gcc específicas da CPU adaptados para a CPU atual.
+
 
 +
* [https://www.archlinux.org/pacman/makepkg.8.html Página de manual makepkg(8)]
 +
* [https://www.archlinux.org/pacman/makepkg.conf.5.html Página de manual makepkg.conf(5)]
 +
* [https://gist.github.com/Earnestly/bebad057f40a662b5cc3 Um breve passeio no processo do makepkg]
 +
* [https://projects.archlinux.org/pacman.git/tree/scripts/makepkg.sh.in Código fonte do makepkg]

Latest revision as of 14:45, 13 January 2018

makepkg é um script usado para automatizar a compilação de pacotes. Os requisitos para usar o script são uma plataforma tipo Unix capaz de compilar e um PKGBUILD.

O makepkg é fornecido pelo pacote pacman.

Configuração

Veja makepkg.conf(5) para detalhes sobre as opções de configuração do makepkg.

A configuração do sistema está disponível em /etc/makepkg.conf, mas alterações específicas para cada usu[ario podem ser feitas em $XDG_CONFIG_HOME/pacman/makepkg.conf ou ~/.makepkg.conf. É recomendado revisar a configuração antes de compilar pacotes.

Informação do empacotador

Cada pacote é marcado com metadados identificando, entre outros, também o empacotador. Por padrão, os pacotes compilados pelo usuário são marcados com Empacotador desconhecido. Se vários usuários estiverem compilando pacotes em um sistema, ou de outra forma distribuindo seus pacotes para outros usuários, é conveniente fornecer contato real. Isso pode ser feito configurando a variável PACKAGER em makepkg.conf.

Para verificar isso em um pacote instalado:

$ pacman -Qi pacote
...
Empacotador       : John Doe <john@doe.com>
...

Para automaticamente produzir pacotes assinados, defina também a variável GPGKEY em makepkg.conf.

Saída de pacote

Por padrão, makepkg cria os tarballs de pacote no diretório atual de trabalho e baixa os dados fonte diretamente para o diretório src/. Caminhos personalizados podem ser configurados, por exemplo, para manter todos os pacotes compilados em ~/build/pacotes/ e todos os fontes em ~/build/fontes/.

Configure as seguintes variáveis do makepkg.conf, se necessário:

  • PKGDEST – diretório para armazenar pacotes resultantes
  • SRCDEST – diretório para armazenar dados fonte (links simbólicos serão colocados em src/ se ele aponta para outro lugar)
  • SRCPKGDEST – diretório para armazenar os pacotes fontes (compilado com makepkg -S)

Verificação de assinatura

Nota: A verificação de assinatura implementada no makepkg não usa o chaveiro do pacman; em vez disso, depende do chaveiro do usuário.[1]

Se um arquivo de assinatura na forma de .sig ou .asc é parte do vetor fonte do PKGBUILD, o makepkg tenta automaticamente verificá-la. No caso do chaveiro do usuário não contém a chave pública necessária para verificação de assinatura, o makepkg vai abortar a instalação com uma mensagem de que a chave PGP não pôde ser verificada.

Se uma chave pública necessária para um pacote está faltando, o PKGBUILD muito provavelmente vai conter uma entrada validpgpkeys com os IDs de chaves necessárias. Você pode importá-la manualmente ou você pode localizá-la em um servidor de chaves e importá-la de lá.

Uso

Antes de continuar, instale o grupo base-devel. Os pacotes que pertencem a este grupo não são exigidos na lista de dependência de compilação (makedepends) nos arquivos PKGBUILD. Além disso, o grupo base é presumido como estando instalado em todos os sistemas Arch.

Nota: * Certifique-se de que o sudo está configurado corretamente para comandos passados para o pacman.
  • Executar makepkg em si como root não é permitido.[2] Além disso, como um PKGBUILD pode conter comandos arbitrários, compilar como root geralmente é considerado inseguro.[3] Usuários que não possuem acesso a uma conta de usuário comum devem executar o makepkg como o usuário nobody.

Para compilar um pacote, deve-se primeiro criar um PKGBUILD, ou um script de compilação, como descrito em Criando pacotes. Scripts existentes estão disponíveis na árvore do Arch Build System (ABS) ou do AUR. Uma vez em posse de um PKGBUILD, altere o diretório no qual está salvo e execute o seguinte comando para compilar o pacote:

$ makepkg

Se estiverem faltando dependências necessárias, o makepkg emitirá um aviso antes de falhar. Para compilar o pacote e instalar as dependências necessárias, adicione a opção -s/--syncdeps:

$ makepkg --syncdeps

Adicionar as opções -r/--rmdeps faz com que o makepkg remova as dependências de compilação logo em seguida, já que não são mais necessárias. Se estiver compilando pacotes constantemente, considere usar Pacman/Dicas e truques#Removendo pacotes não usados (órfãos) de vez em quando.

Nota:
  • Essas dependências devem estar disponíveis nos repositórios configurados; veja pacman#Repositórios e espelhos[broken link: invalid section] para detalhes. Alternativamente, pode-se instalar manualmente as dependências antes de compilar (pacman -S --asdeps dep1 dep2).
  • Apenas valores globais são usados ao instalar dependências, ou seja, qualquer sobrescrição feita em uma função de empacotamento de pacotes divididos não serão sadas.[4]

Uma vez que todas as dependências estejam satisfeitas e os pacotes compilados com sucesso, um arquivo de pacote (pkgname-pkgver.pkg.tar.xz) será criado no diretório. Para instalar, use -i/--install (o mesmo que pacman -U pkgname-pkgver.pkg.tar.xz):

# pacman --install

Para limpar arquivos e pastas restantes, tais como arquivos extraídos para $$srcdir, adicione a opção -c/--clean. Isso é útil para várias compilações do mesmo pacote ou ao atualizar a versão do pacote, enquanto usa a mesma pasta de compilação. Isso evita arquivos obsoletos e remanescentes de serem carregados para novas compilações:

$ makepkg --clean

Para mais informações, veja makepkg(8).

Dicas e truques

Compilando binários otimizados

Uma melhoria de desempenho do software empacotado pode ser conseguida ao habilitar otimizações do compilador para a máquina host. A desvantagem é que os binários compilados para uma arquitetura de processador específica não serão executados corretamente em outras máquinas. Nas máquinas x86_64, raramente existem ganhos de desempenho reais reais significativos que justificariam investir o tempo para reconstruir pacotes oficiais.

No entanto, é muito fácil reduzir o desempenho usando flags de compilação "não padronizadas". Muitas otimizações de compilação só são úteis em certas situações e não devem ser aplicadas indiscriminadamente em cada pacote. A menos que você possa verificar/avaliar que algo é mais rápido, há uma chance muito boa de não ser! O Guia de Otimização de Compilação e artigo wiki CFLAGS Seguras do Gentoo (ambos em inglês) fornecem mais informações detalhadas sobre a otimização do compilador.

As opções passadas para um compilador C/C++ (ex.: gcc ou clang) são controladas pelas variáveis de ambiente CFLAGS, CXXFLAGS eCPPFLAGS. Para usar o sistema de compilação do Arch, o makepkg expõe essas variáveis de ambiente como opções de configuração no makepkg.conf. Os valores padrão são configurados para produzir binários genéricos que podem ser instalados em uma ampla gama de máquinas.

Nota: * Tenha em mente que nem todos os sistemas de compilação usam as variáveis configuradas no makepkg.conf. Por exemplo, cmake ignora a variável de ambiente das opções de pré-processador, CPPFLAGS. Consequentemente, muitos PKGBUILD contêm soluções alternativas com opções específicas para o sistema de compilação usado pelo software empacotado.
  • A configuração fornecida com o código fonte no Makefile ou em um argumento específico na linha de comando de compilação tem a preferência e pode potencialmente sobrescrever aquela no makepkg.conf.

O GCC pode detectar e habilitar automaticamente otimizações seguras específicas para cada arquitetura. Para usar esse recurso, primeiro remova os sinalizadores -march e -mtune, então adicione -march = native. Por exemplo:

/etc/makepkg.conf
CFLAGS="-march=native -O2 -pipe -fstack-protector-strong -fno-plt"
CXXFLAGS="${CFLAGS}"

Para ver quais sinalizadores isso habilita em sua máquina, execute:

$ gcc -march=native -v -Q --help=target
Nota: Se você especificar um valor diferente de -march=native, então -Q --help=target não vai funcionar como esperado.[5] Você precisa passar por uma fase de compilação para descobrir quais opções estão realmente habilitadas. Veja Encontre opções específicas da CPU (inglês) no wiki do Gentoo para instruções.

Melhorando os tempos de compilação

Compilação paralela

O sistema de compilação do make usa a variável de ambiente MAKEFLAGS para especificar opções adicionais para o make. A variável também pode ser definida no arquivo makepkg.conf.

Os usuários com sistemas multi-core/multiprocessados podem especificar o número de trabalhos a serem executados simultaneamente. Isso pode ser realizado com o uso de nproc para determinar o número de processadores disponíveis, ex. MAKEFLAGS="-j$(nproc)". Alguns PKGBUILD substituem especificamente isso com -j1, devido a condições de corrida em certas versões ou simplesmente porque não é suportado em primeiro lugar. Os pacotes que não conseguem ser compilados devido a isso devem ser relatados no rastreador de erros (ou no caso dos pacotes do AUR, ao mantenedor do pacote) depois de ter certeza de que o erro está sendo realmente causado pelo seu MAKEFLAGS.

Veja make(1) para uma lista completa de opções disponíveis.

Compilando de arquivos na memória

Como a compilação requer muitas operações de E/S e lidar com arquivos pequenos, mover o diretório de trabalhos para um tmpfs pode trazer melhorias em tempos de compilação.

A variável BUILDDIR pode ser temporariamente exportada para makepkg para definir o diretório de compilação para um tmpfs existente. Por exemplo:

$ BUILDDIR=/tmp/makepkg makepkg
Atenção: Evite compilar pacotes grandes no tmpfs para evitar ficar sem memória.

Uma configuração persistente pode ser feita no makepkg.conf descomentando a opção BUILDDIR, que é encontrada no fim da seção BUILD ENVIRONMENT no arquivo padrão /etc/makepkg.conf. Definir esses valores para, por exemplo, BUILDDIR=/tmp/makepkg fará uso do sistema de arquivos temporário /tmp padrão do Arch.

Nota: * A pasta tmpfs deve ser montada sem a opção noexec; do contrário, ela vai impedir que binparios sejam executados.
  • Tenha em mente que pacotes compilados no tmpfs não persistirá após reinicialização. Considere configurar a opção PKGDEST apropriadamente para mover o pacote compilado automaticamente para um diretório persistente.

Usando cache de compilação

O uso de ccache pode melhorar os tempos de compilação ao armazenar em cache os resultados de compilações para uso sucessivo.

Gerar novos checksums

Execute o seguinte comando no mesmo diretório que o arquivo PKGBUILD para gerar novas somas de verificação (checksums):

$ updpkgsums

Usar outros algoritmos de compressão

Para acelerar o empacotamento e a instalação, com a consequência de ter arquivos de pacotes maiores, você pode alterar PKGEXT. Por exemplo, o seguinte torna o arquivo de pacote descompactado para apenas uma invocação:

$ PKGEXT='.pkg.tar' makepkg

Um outro exemplo abaixo mostra o uso do algoritmo lzop, com o pacote lzo necessário:

$ PKGEXT='.pkg.tar.lzo' makepkg

Para fazer uma dessas configurações permanentes, configure PKGEXT em /etc/makepkg.conf.

Usando vários núcleos na compressão

O xz oferece suporte a multiprocessamento simétrico (SMP) por meio do sinalizador --threads para acelerar a compressão. Por exemplo, para deixar o makepkg usar quantos núcleos de CPU for possível para comprimir os pacotes, edite o vetor COMPRESSXZ em /etc/makepkg.conf:

COMPRESSXZ=(xz -c -z - --threads=0)

O pigz é uma implementação paralela para o gzip que, por padrão, usa todos os núcleos disponíveis na CPU (o sinalizador -p/--processes pode ser usado para empregar menos núcleos):

COMPRESSGZ=(pigz -c -f -n)

Mostrar pacotes com um empacotador específico

Isso mostra todos os pacotes instalados no sistema com o empacotador chamado nome-empacotador:

$ expac "%n %p" | grep "nome-empacotador" | column -t

Isso mostra todos os pacotes instalados no sistema com o empacotador definido na variável PACKAGER do /etc/makepkg. Isso mostra apenas pacotes que estão em um repositório definido em /etc/pacman.conf.

$ . /etc/makepkg.conf; grep -xvFf <(pacman -Qqm) <(expac "%n\t%p" | grep "$PACKAGER$" | cut -f1)

Compilar pacotes 32 bits em um sistema 64 bits

Atenção: Erros foram relatados ao usar esse método par compilar o pacote linux. O método de instalação é preferível e verificou-se que funciona para compilar os pacotes do kernel.

Primeiro, habilite o repositório multilib e instale multilib-devel.

Então, crie um arquivo de configuração 32 bits

~/.makepkg.i686.conf
CARCH="i686"
CHOST="i686-unknown-linux-gnu"
CFLAGS="-m32 -march=i686 -mtune=generic -O2 -pipe -fstack-protector-strong"
CXXFLAGS="${CFLAGS}"
LDFLAGS="-m32 -Wl,-O1,--sort-common,--as-needed,-z,relro"

e chame o makepkg assim

$ linux32 makepkg --config ~/.makepkg.i686.conf

Solução de problemas

Makepkg algumas vezes falha ao assinar um pacote sem perguntar pela palavra-chave de assinatura

Com o gnupg 2.1, gpg-agent agora é iniciado automaticamente pelo gpg. O problema surge no estágio do pacote de makepkg --sign. Para permitir os privilégios corretos, fakeroot executa a função package() iniciando o gpg-agent dentro do mesmo ambiente fakeroot. Na saída, o fakeroot limpa os semáforos fazendo com que a "escrita" termine o pipe para fechar para aquela instância do gpg-agent que resultará em um erro de pipe quebrado. Se o mesmo gpg-agent estiver em execução quando makepkg --sign estiver próximo de executado, então o gpg-agent retorna código de saída 2; então a seguinte saída ocorre:

==> Assinando pacote...
==> ATENÇÃO: Falha em assinar arquivo de pacote.

Esse erro está atualmente sendo rastreado: FS#49946. Uma solução temporária de contorno para esse problema é executar killall gpg-agent && makepkg --sign. Esse problema está resolvido no pacman-gitAUR, especificamento no hash de commit c6b04c04653ba9933fe978829148312e412a9ea7

CFLAGS/CXXFLAGS/CPPFLAGS no makepkg.conf não funciona para pacotes baseados no QMAKE

Qmake configura automaticamente a variável CFLAGS e CXXFLAGS de acordo com o que você pensa que deveria ser a configuração correta. Para deixar o qmake usar as variáveis definidas no arquivo de configuração do makepkg, você deve editar o PKGBUILD e passar as variáveis QMAKE_CFLAGS_RELEASE e QMAKE_CXXFLAGS_RELEASE ao qmake. Por exemplo:

PKGBUILD
...

build() {
  cd "$srcdir/$_pkgname-$pkgver-src"
  qmake-qt4 "$srcdir/$_pkgname-$pkgver-src/$_pkgname.pro" \
    PREFIX=/usr \
    QMAKE_CFLAGS_RELEASE="${CFLAGS}"\
    QMAKE_CXXFLAGS_RELEASE="${CXXFLAGS}"

  make
}

...

Alternativamente, para uma configuração para todo sistema, você pode criar seu próprio qmake.conf e configurar a variável de ambiente QMAKESPEC.

Especificando diretório de instalação para pacotes baseados em QMAKE

O makefile gerado pelo qmake usa a variável de ambiente INSTALL_ROOT para especificar onde o programa deve ser instalado. Então, essa função package deve funcionar:

PKGBUILD
...

package() {
	cd "$srcdir/${pkgname%-git}"
	make INSTALL_ROOT="$pkgdir" install
}

...

Note que o qmake também tem que ser configurado adequadamente. Por exemplo, coloque isso em seu arquivo .pro:

SeuProjeto.pro
...

target.path = /usr/local/bin
INSTALLS += target

...

AVISO: O pacote contém referência para $srcdir

De alguma forma, as strings literais $srcdir ou $pkgdir acabaram em um dos arquivos instalados no seu pacote.

Para identificar quais arquivos, execute o seguinte do diretório de compilação makepkg:

$ grep -R "$(pwd)/src" pkg/

Link para a discussão.

Veja também