Introdução ao Rust
A linguagem de programação "Rust"
foi projetada para ser uma linguagem segura, simultânea e prática.
Esse pacote é atualizado em um ciclo de lançamento de seis semanas.
Por ser um pacote tão grande e lento de construir, no momento
exigido somente por uns poucos pacotes neste livro, e
particularmente porque as versões mais recentes tendem a quebrar
pacotes "Mozilla" mais antigos, os(as) editores(as) do BLFS
consideram que ele somente deveria ser atualizado quando isso for
necessário (seja para corrigir problemas ou para permitir a
construção de uma nova versão de um pacote).
Tal como acontece com muitas outras linguagens de programação, o
"Rustc" (o compilador "Rust") precisa de um binário a partir do
qual inicializar. Ele baixará um binário stage0 no início da
construção, de forma que você não consegue compilá-lo sem uma
conexão com a Internet.
![[Nota]](../images/note.png)
Nota
Embora o BLFS normalmente instale em "/usr", quando você atualizar posteriormente
para uma versão mais recente do "rust", as bibliotecas antigas em
"/usr/lib/rustlib" permanecerão,
com vários "hashes" nos nomes delas, mas não serão usáveis e
desperdiçarão espaço. Os(As) editores(as) recomendam colocar os
arquivos no diretório "/opt". Em
particular, se você tiver motivos para reconstruir com uma
configuração modificada (por exemplo, usando o "LLVM" enviado
após construir com "LLVM" compartilhado, talvez para compilar
caixas para arquiteturas que a construção "LLVM" do BLFS não
suporta), [então] é possível que a instalação deixe um aplicativo
quebrado "cargo".
Em tal situação, remova a instalação existente primeiro ou use um
prefixo diferente, como "/opt/rustc-1.67.1-build2".
Se preferir, você pode, certamente, mudar o prefixo para
"/usr".
O atual sistema de construção "rustbuild" usará todos os processadores,
embora não escale bem e frequentemente retorne a usar apenas um
núcleo enquanto espera que uma biblioteca compile. No entanto, ele
pode ser limitado, principalmente a um número especificado de
processadores, por uma combinação de adicionar a chave
"--jobs <N>" (por exemplo,
"--jobs 4" para limitar a quatro processadores) em cada invocação
de "python3 ./x.py"
e usar uma variável de
ambiente "CARGO_BUILD_JOBS=<N>".
No momento, isso não é eficaz quando alguns dos testes "rustc" são
executados.
A versão atual da caixa "num_cpus" do "Rust" agora reconhece que
"cgroups" pode ser usado para restringir quais processadores ele
está autorizado a usar. Portanto, se sua máquina carece de "DRAM"
(normalmente, menos de dois (02) GB de "DRAM" por núcleo), [então]
isso pode ser uma alternativa para colocar "CPUs" fora de linha.
Em sistemas "sysv", "cgroups" exige libcgroup.
No momento, "Rust" não oferece
nenhuma garantia de uma "ABI" estável.
Nota
O padrão do "Rustc" é o de construir para TODAS as arquiteturas
suportadas, usando uma cópia enviada do "LLVM". No BLFS a
construção é somente para a arquitetura "X86". Se você pretende
desenvolver caixas "Rust", [então] essa construção possivelmente
não seja boa o suficiente para os teus propósitos.
Os tempos de construção dessa versão, quando repetidos na mesma
máquina, costumam ser razoavelmente consistentes, mas como
acontece com todas as compilações usando "rustc", pode existir alguns
valores discrepantes muito lentos.
Esse pacote é conhecido por construir e funcionar adequadamente
usando uma plataforma LFS 11.3.
Informação do Pacote
-
Transferência (HTTP): https://static.rust-lang.org/dist/rustc-1.67.1-src.tar.xz
-
Transferência (FTP):
-
Soma de verificação MD5 da transferência:
e5e47e53c52574ce89ea200e52819f81
-
Tamanho da transferência: 136 MB
-
Espaço em disco estimado exigido: 8,5 GB (501 MB instalado);
adicionar 7,5 GB se executar os testes
-
Tempo de construção estimado: 13 UPC (incluindo o tempo de
transferência; adicionar 16 UPC para os testes, ambos usando
paralelismo=4)
Dependências do “Rust”
Exigidas
CMake-3.25.2
Recomendadas
cURL-7.88.1, libssh2-1.10.0 e LLVM-15.0.7 (construído com
"-DLLVM_LINK_LLVM_DYLIB=ON" de forma que "Rust" consiga vincular ao
"LLVM" do sistema em vez de construir a versão enviada dele)
Nota
Se uma dependência recomendada não estiver instalada, [então] uma
cópia enviada no "tarball" do fonte do "Rustc" será construída e
usada.
Opcionais
"GDB-13.1"
(usado pela suíte de teste se estiver presente) e "libgit2"
Observações de Usuário(a): https://wiki.linuxfromscratch.org/blfs/wiki/rust
Instalação do Rust
Nota
Atualmente o compilador "Rust" produz instruções "SSE2" para
"x86" de 32 bits, fazendo com que o código gerado seja quebrado
em sistemas de 32 bits sem um processador compatível com "SSE2".
Todos os modelos de processador "x86" lançados após 2004 deveriam
ser compatíveis com "SSE2". Execute "lscpu | grep sse2" como teste.
Se gerar alguma coisa, [então] tua "CPU" é compatível com "SSE2"
e está OK. Caso contrário, você pode tentar construir esse pacote
em um sistema compatível com
"SSE2" com a seguinte correção aplicada:
sed 's@pentium4@pentiumpro@' -i \
compiler/rustc_target/src/spec/i686_unknown_linux_gnu.rs
E copie o "/opt/rustc-1.67.1"
resultante para o sistema sem capacidade "SSE2". Mas, essa
mudança ainda está sob revisão do(a) desenvolvedor(a) e não foi
testada pelos(as) editores(as) do BLFS.
Para instalar no diretório "/opt",
remova qualquer link simbólico "/opt/rustc" existente e crie um novo diretório
(ou seja, com um nome diferente se tentar uma construção modificada
da mesma versão). Como o(a) usuário(a) "root":
mkdir -pv /opt/rustc-1.67.1 &&
ln -svfn rustc-1.67.1 /opt/rustc
Nota
Se múltiplas versões do "Rust"
estiverem instaladas em "/opt",
[então] a mudança para outra versão exige somente mudar o link
simbólico "/opt/rustc" e então
executar "ldconfig".
Crie um arquivo "config.toml"
adequado que configurará a construção.
cat << EOF > config.toml
# Veja-se "config.toml.example" para mais opções possíveis
# Veja-se o livro 8.4 para um exemplo antigo usando "LLVM" enviado
# por exemplo, se não instalar "clang", ou usar uma versão anterior a 13.0
# Diz ao "x.py" para não permanecer imprimindo um aviso irritante
changelog-seen = 2
[llvm]
# por padrão, "rust" construirá para uma miríade de arquiteturas
targets = "X86"
# Quando usar o "LLVM" do sistema prefira bibliotecas compartilhadas
link-shared = true
[build]
# Omita os documentos para economizar tempo e espaço (padrão é para construí-los)
docs = false
# Instala ferramentas estendidas: cargo, clippy, etc
extended = true
# Não consulte novas versões de dependências online.
locked-deps = true
# Especifique quais ferramentas estendidas (aquelas oriundas da instalação padrão).
tools = ["cargo", "clippy", "rustfmt"]
# Use o código-fonte enviado no "tarball" para as dependências.
# A combinação disto e da entrada "locked-deps" evita baixar
# muitas caixas a partir da Internet, e torna a construção do "Rustc" mais estável.
vendor = true
[install]
prefix = "/opt/rustc-1.67.1"
docdir = "share/doc/rustc-1.67.1"
[rust]
channel = "stable"
description = "para BLFS 11.3"
# BLFS costumava não instalar o executável "FileCheck" originário do "LLVM",
# de forma que desabilitava os testes "codegen". Os testes "assembly" dependem de "FileCheck"
# e não podem ser facilmente desabilitados, de forma que eles falharão de qualquer maneira se
# "FileCheck" não tiver sido instalado.
#codegen-tests = false
[target.x86_64-unknown-linux-gnu]
# Observe bem: a saída gerada do "llvm-config" (ou seja, opções de ajuda) pode ser
# despejada na tela quando "config.toml" é analisado.
llvm-config = "/usr/bin/llvm-config"
[target.i686-unknown-linux-gnu]
# Observe bem: a saída gerada do "llvm-config" (ou seja, opções de ajuda) pode ser
# despejada na tela quando "config.toml" é analisado.
llvm-config = "/usr/bin/llvm-config"
EOF
Compile "Rust" executando os
seguintes comandos:
{ [ ! -e /usr/include/libssh2.h ] ||
export LIBSSH2_SYS_USE_PKG_CONFIG=1; } &&
python3 ./x.py build
Nota
A suíte de teste gerará algumas mensagens no registro do sistema para interceptações em
códigos inválidos de operação e para falhas de segmentação. Por
si só, isso não é motivo de preocupação, apenas uma maneira do
teste ser terminado.
Para executar os testes (novamente usando todas as "CPUs"
disponíveis), emita:
python3 ./x.py test --verbose --no-fail-fast | tee rustc-testlog
Se o "FileCheck"
originário do "LLVM" não tiver
sido instalado, [então] todos os quarenta e sete (47) testes da
suíte “assembly” falharão.
Tal como acontece com todas as grandes suítes de teste, outros
testes podem falhar em algumas máquinas - se o número de falhas
adicionais estiver na casa de um dígito, [então] verifique se
existem 'failures:' no registro e revise as linhas acima,
especialmente as linhas 'stderr:'. Qualquer menção ao "SIGSEGV" ou
ao sinal onze (11) em um teste falho é motivo de preocupação.
Se você receber algum outro
teste falho que informe um número de problema, então você deveria
procurar por esse problema. Por exemplo, quando "Rustc" >=
1.41.1 era construído com uma versão do "LLVM" do sistema anterior
à 10.0, o teste para o problema "69225" falhava https://github.com/rust-lang/rust/issues/69225
e isso deveria ser considerado como uma falha crítica (eles(as)
lançaram 1.41.1 por causa disso). A maioria das outras falhas não
será crítica.
Portanto, você deveria determinar o número de falhas.
O número de testes que passaram e falharam pode ser encontrado
executando:
grep '^test result:' rustc-testlog |
awk '{sum1 += $4; sum2 += $6} END { print sum1 " passed; " sum2 " failed" }'
Os outros campos disponíveis são "$8" para aqueles que foram
ignorados (ou seja, pulados), "$10" para 'medido' e "$12" para
'filtrado', mas ambos os dois últimos provavelmente sejam zero.
Agora, como o(a) usuário(a) "root",
instale o pacote:
Nota
Se "sudo" ou
"su" for invocado
para comutar para o usuário "root", garanta que "LIBSSH2_SYS_USE_PKG_CONFIG" seja passada
corretamente ou o comando seguinte possivelmente reconstrua
completamente esse pacote. Para "sudo", use a opção
"--preserve-env=LIBSSH2_SYS_USE_PKG_CONFIG".
Para "su",
não use o "-" ou o "--login".
python3 ./x.py install
Explicações do Comando
ln -svfn rustc-1.67.1
/opt/rustc: se esse não for o primeiro uso do link
simbólico /opt/rustc, [então]
sobrescreva-o forçando e use o sinalizador '-n' para evitar
resultados confusos oriundos, por exemplo, de ls -l.
targets = "X86": isso
evita construir todos os compiladores cruzados disponíveis do
"Linux" ("AArch64", "MIPS", "PowerPC", "SystemZ", etc).
Infelizmente, o "Rust" insiste em instalar os arquivos fonte para
esses abaixo de "/opt/rustc/lib/src".
extended = true: isso
instala várias ferramentas (especificadas pela entrada
"tools") juntamente com o
"rustc".
tools = ["cargo", "clippy",
"rustfmt"]: se as ferramentas não forem
especificadas, [então] a ausência de Miri agora causa falha na instalação. Mas
Miri não é construído no canal
estável. Algumas das outras ferramentas são improváveis de serem
úteis, a menos que se usem analisadores (antigos) de código ou se
edite a biblioteca padrão. Esse conjunto corresponde àquelas
originárias do perfil 'default' no comando binário rustup que são recomendadas para
a maioria dos usuários, exceto que a documentação foi desabilitada
no início da seção '[build]'.
channel = "stable":
isso garante que somente recursos estáveis possam ser usados. O
padrão no "config.toml" é o de usar
recursos de desenvolvimento, o que não é apropriado para uma versão
lançada.
[target.x86_64-unknown-linux-gnu]:
a sintaxe do "config.toml" exige uma
entrada "llvm-config" para cada alvo
para o qual o "LLVM" do sistema seja para ser usado. Mude o alvo
para "[target.i686-unknown-linux-gnu]"
se você estiver construindo em "x86" de 32 bits. Essa seção inteira
pode ser omitida se você desejar construir contra o "LLVM" enviado
ou não tiver "clang", mas a construção resultante será maior e
demorará mais.
export
LIBSSH2_SYS_USE_PKG_CONFIG=1: Permite que o
"cargo" se vincule à
"libssh2" do sistema.
--verbose: essa chave
às vezes pode fornecer mais informações relativas a um teste que
falhe.
--no-fail-fast: essa
chave garante que a suíte de teste não parará no primeiro erro.