Lançamento do Rust 1.88. Sistema operacional Munal e utilitário rsched em Rust

Foi publicado o lançamento da linguagem de programação de propósito geral Rust 1.88, originalmente desenvolvida pelo projeto Mozilla, mas atualmente mantida sob a tutela da organização sem fins lucrativos Rust Foundation. A linguagem foca na manipulação segura da memória e fornece recursos para alcançar alto paralelismo na execução de tarefas, sem fazer uso de coletor de lixo e runtime (o runtime se resume à inicialização básica e ao suporte da biblioteca padrão).

Os métodos de manipulação de memória em Rust protegem o desenvolvedor de erros ao trabalhar com ponteiros e evitam problemas decorrentes de manipulação de memória de baixo nível, como acesso a áreas de memória após sua liberação, desreferenciação de ponteiros nulos, e estouro de buffer, entre outros. Para distribuição de bibliotecas, construção e gerenciamento de dependências, o projeto conta com o gerenciador de pacotes Cargo. O repositório crates.io é suportado para hospedagem de bibliotecas.

A manipulação segura da memória em Rust é garantida em tempo de compilação através da verificação de referências, rastreamento de propriedade de objetos, controle do tempo de vida dos objetos (escopos) e avaliação da correção do acesso à memória durante a execução do código. Rust também oferece mecanismos para proteção contra estouros inteiros, exige a inicialização obrigatória de valores de variáveis antes do uso, trata erros de forma superior na biblioteca padrão, aplica o conceito de referências e variáveis imutáveis (immutable) por padrão e oferece uma forte tipagem estática para minimizar erros lógicos.

Principais novidades:

• Adicionada a possibilidade de especificar várias expressões "let" dentro de blocos condicionais "if" e "while" usando o operador "&&" (E lógico) para combiná-las. Expressões "let" podem ser combinadas com expressões condicionais booleanas. Variáveis declaradas em expressões let podem ser usadas em expressões condicionais subsequentes e também dentro dos blocos "if" e "while". if let Channel::Stable(v) = release_info() && let Semver { major, minor, .. } = v && major == 1 && minor == 88 {
• Foi adicionada a suporte para a definição de funções "nuas" marcadas com o atributo "#[unsafe(naked)]", que contêm dentro uma única chamada "naked_asm!". Funções criadas dessa forma não têm epílogos e prólogos gerados pelo compilador, permitindo que o desenvolvedor tenha controle total sobre o código de montagem auxiliar anexado à função (uma função "nua" contém apenas as instruções de montagem especificadas pelo desenvolvedor, sem incluir manipuladores especiais de argumentos e valores de retorno adicionados pelo compilador). Funções "nuas" são consideradas uma alternativa mais conveniente às funções definidas em blocos "global_asm!". #[unsafe(naked)] pub unsafe extern "sysv64" fn wrapping_add(a: u64, b: u64) -> u64 { core::arch::naked_asm!( "add rax, rdi, rsi", "ret" ); }
• O sistema de predicado aplicável nos atributos de compilação condicional "cfg" e "cfg_attr" (que permitem incluir ou excluir partes do código dependendo das condições especificadas) agora suporta literais booleanos "true" e "false", que são identificados com configurações que sempre estão ativadas ou sempre estão desativadas. Esses literais também podem ser usados no macro "cfg!" e em tabelas "[target]" nos manifestos e configurações do Cargo. As expressões cfg(true) e cfg(false) podem ser utilizadas em vez de cfg(all()) e cfg(any()) para expressar suas intenções de forma mais clara.
• O gerenciador de pacotes Cargo agora inclui a execução automática do coletor de lixo para limpar o cache no diretório home do usuário. Pacotes anteriormente armazenados em cache, contendo dependências baixadas, não eram removidos, resultando em um uso crescente de espaço em disco. O mecanismo de coleta de lixo irá automaticamente excluir arquivos crate baixados externamente que não foram acessados por mais de 3 meses e arquivos crate instalados localmente que não foram acessados por mais de um mês. A limpeza do cache não é iniciada ao utilizar no cargo as opções "--offline" ou "--frozen."
• Uma nova leva de APIs foi traduzida para a categoria estável, incluindo estabilizações de métodos e implementações de traits:
  • Cell::update
  • impl Default for *const T
  • impl Default for *mut T
  • mod ffi::c_str
  • HashMap::extract_if
  • HashSet::extract_if
  • hint::select_unpredictable
  • proc_macro::Span::line
  • proc_macro::Span::column
  • proc_macro::Span::start
  • proc_macro::Span::end
  • proc_macro::Span::file
  • proc_macro::Span::local_file
  • ::as_chunks
  • ::as_rchunks
  • ::as_chunks_unchecked
  • ::as_chunks_mut
  • ::as_rchunks_mut
  • ::as_chunks_unchecked_mut
• O modificador «const» é aplicado em funções:
  • NonNull::replace
  • ::replace
  • std::ptr::swap_nonoverlapping
  • Cell::replace
  • Cell::get
  • Cell::get_mut
  • Cell::from_mut
  • Cell::as_slice_of_cells
• O primeiro nível de suporte para a plataforma de destino i686-pc-windows-gnu foi removido.

Além disso, podem ser mencionados eventos relacionados ao Rust:

• O projeto Munal OS está desenvolvendo um sistema operacional experimental, escrito em Rust e baseado na concepção de unikernel. O Munal OS não utiliza multitarefa preemptiva, mapeamento de páginas de memória e espaço de endereço virtual (usa o layout de memória do UEFI). O núcleo e os aplicativos são executados em um único espaço de endereço utilizando um modelo de segurança baseado em isolamento sandbox WASM (inclui o mecanismo wasmi para executar aplicativos na forma de bytecode WebAssembly).

  O sistema operacional vem com uma interface gráfica e suporta controle via teclado e mouse. Para o desenvolvimento de aplicativos gráficos, é utilizado um kit de ferramentas próprio com uma biblioteca de widgets. Para interação em rede, são oferecidos um stack TCP e um driver de dispositivo de rede. Entre os aplicativos disponíveis para o Munal OS estão: um navegador web com suporte básico a HTML e HTTPS, um editor de texto e um terminal para executar código Python. O código é aberto sob a licença MIT.

  
• Foi lançado o núcleo Asterinas 0.15.2, escrito em Rust e oferecendo ABI compatível com o núcleo do Linux. O núcleo suporta as arquiteturas x86-64 e RISC-V, e implementa 206 dos 368 syscalls do Linux. No desenvolvimento do núcleo participam 45 desenvolvedores, principalmente de várias universidades chinesas. O núcleo é construído utilizando a arquitetura «framekernel», na qual os componentes do núcleo são alocados em um espaço de endereço comum, e a segurança é alcançada no nível da separação lógica de código seguro e código que pode apresentar problemas de segurança. Todos os syscalls, sistemas de arquivos e drivers são implementados no nível de Serviços OS e não podem incluir blocos unsafe. O código é distribuído sob a licença MPL 2.0.
• Uma ferramenta chamada rsched foi desenvolvida para o núcleo Linux, permitindo analisar estatísticas sobre o funcionamento do agendador de tarefas. Na prática, a ferramenta permite avaliar as decisões do agendador relacionadas à alocação de recursos para processos, bem como monitorar as latências que surgem durante o agendamento. Para coletar dados no núcleo, é utilizada a subsistema BPF, e o conjunto de ferramentas em espaço de usuário é escrito em Rust. O autor da ferramenta é Chris Mason, criador e arquiteto principal do sistema de arquivos Btrfs.
• A empresa Collabora anunciou o desenvolvimento de uma variante da ferramenta Coccinelle para a linguagem Rust. O Coccinelle foi originalmente projetado para automatizar a busca e a transformação de código em C no núcleo Linux. As transformações são definidas na forma de regras que se assemelham a patches abstratos, não vinculados a uma posição específica no código.
• Os desenvolvedores do GNOME apresentaram uma biblioteca para carregamento de imagens chamada glycin, escrita em Rust, que fornece a decodificação de imagens com uso de isolamento sandbox. Suporte é oferecido para a entrega do conteúdo decodificado através de gdk::Textures e extração de metadados. Wraps são fornecidos para usar o glycin no GTK4, bem como um backend para implementar o glycin na biblioteca GdkPixbuf, utilizada no GNOME para carregamento de imagens. O glycin já está implementado no visualizador de imagens Loupe, que é fornecido por padrão no GNOME. O backend para o GdkPixbuf permite o uso do glycin no GNOME Shell, geradores de miniaturas e aplicações diversas do GNOME, sem a necessidade de modificar esses programas.

Fonte: opennet.ru