Perguntas[linux](unix)

Instalei o Ubuntu Linux com WSL no meu PC com Windows 11. Criei um nome de usuário durante a instalação, perdiem. Quando tudo estava funcionando, fui cdpara ~, e o diretório em que acabei foi /home/ls. Não sei bem por que isso acontece; pensei que seria meu nome de usuário. Também é estranho que seja, na verdade, um comando do Linux — meio confuso.

Isso não é um problema, mas alguém sabe por que lsé estabelecido como o diretório inicial e não meu nome de usuário?

Saída de id:

uid=1000(ls) gid=1000(ls) groups=1000(ls),4(adm),20(dialout),24(cdrom),25(floppy),27(sudo),29(audio),30(dip),44(video),46(plugdev),100(users),107(netdev)

Saída de grep /home/ls /etc/passwd:

ls:x:1000:1000:,,,:/home/ls:/bin/bash

Estou trabalhando em uma aplicação C++ no Ubuntu 20.04 que usa PCIe DMA para transferir dados de um buffer de espaço do usuário para o hardware. O buffer é mapeado para uma região fixa de 1K de memória física por meio de uma biblioteca personalizada (plib->copyDataToBuffer). Depois de chamar fork() e executar um processo filho (que apenas chama um programa externo e sai), notei que as gravações subsequentes no buffer pelo processo pai não são refletidas na memória física — o kernel ainda vê os dados antigos de antes da bifurcação.

Detalhes principais: O buffer de 1K é mapeado especificamente para DMA; ele é fixado e mapeado para um endereço físico conhecido.

Antes do fork(), uma chamada para plib->copyDataToBuffer atualiza corretamente a memória física.

Após fork(), o processo pai chama plib->copyDataToBuffer novamente com novos dados, e msync retorna sucesso, mas o conteúdo da memória física permanece inalterado.

O processo filho não toca no buffer; ele apenas executa um comando não relacionado via execvp.

Minhas suposições e preocupações: fork() causa COW (Copy-on-Write), mas como somente o pai grava no buffer, eu esperava que o conteúdo atualizado refletisse na memória física.

O comportamento do COW ou o remapeamento de memória pós-bifurcação podem estar interferindo nas regiões de memória mapeadas por DMA?

Confirmei que plib->copyDataToBuffer executa a gravação corretamente de uma perspectiva de software, mas o conteúdo real da memória física (verificado a partir do espaço do kernel) permanece obsoleto.

Pergunta: Por que a memória física que dá suporte ao meu buffer DMA retém dados obsoletos após um fork() + exec em um processo filho, mesmo que o pai grave novos dados depois?

Quais são as melhores práticas para garantir atualizações consistentes de memória física para buffers DMA em chamadas fork()?

Observo que, no Ubuntu 24.04.2 com coreutilsversão 9.4-3ubuntu6, executando:

$ tail -c 4097 /dev/zero
$ echo $?
0

sai imediatamente com um código de status 0. Eu esperava que o comando bloqueasse indefinidamente, já que /dev/zero é um fluxo infinito.

Em contraste, os seguintes comandos se comportam conforme o esperado (ou seja, eles bloqueiam até serem interrompidos):

$ tail -c 4096 /dev/zero
^C
$ echo $?
130
$ cat /dev/zero | tail -c 4097
^C
$ echo $?
130

Tentativa de depuração

A saída do strace mostra diferenças entre as duas invocações:

Tenho um Raspberry PI Pico por aí e estava pensando em criar um dispositivo que, quando eu precisasse me autenticar no Linux, eu pudesse simplesmente clicar em um botão soldado no Pico, que então enviaria uma mensagem ao computador que me autenticaria.

Este dispositivo estaria conectado a um computador seguro, então não haveria problema.

A questão é: como posso fazer isso? Não tenho experiência com programação em Linux, então não sei se já existe um serviço ou biblioteca que possa ser usado para isso. Sei que a YubiKey tem dispositivos com um botão que funciona mais ou menos assim, mas também li que eles precisam de conexão com a internet para funcionar, o que é inaceitável.

Recentemente atualizamos um servidor SFTP CentOS 7 de alto volume openssh/internal-sftppara o Rocky Linux 8.

No entanto, desde a atualização, estamos enfrentando problemas de tempo limite de login após o servidor estar em execução por 1 a 2 horas. Isso parece estar relacionado ao número de sessões e/ou systemd --userprocessos SFTP abertos.

Após 1-2 horas, novos logins SFTP tornam-se extremamente lentos e começamos a ver essas mensagens no log

Apr 14 12:16:58 sftp sshd[330585]: pam_systemd(sshd:session): Failed to create session: Connection timed out

Às vezes, o problema desaparece se sessões SFTP forem fechadas com rapidez suficiente, mas, na maioria das vezes, precisamos reiniciar o servidor para restaurar o serviço normal.

Seria aconselhável desabilitar, systemd-logindjá que isso não parece necessário para SSH?

ATUALIZAÇÃO
Não tenho certeza se isso é relevante, mas systemctl list-units --state=abandonedretorna centenas de sessões abandonadas.

ATUALIZAÇÃO 2
Após a desativação, pam_systemd.soo sistema voltou a funcionar normalmente. Isso efetivamente desativa systemd-logindas sessões SSH.

Uma redução de 80% na carga do sistema indica uma grande perda de desempenho ao usar systemd-logind.

Isso é normal?!

Tenho um HDD grande e lento e um SSD pequeno e rápido. Isso se refere a leituras, não a RAID . Meu desktop trava quase até parar ao retornar ao Firefox ou às páginas de manual após (re)carregar mais de 12 GiB de árvores de compilação do kernel Linux e 39 GiB no total de LLMs diferentes no SSD, enquanto eu só tenho 31 GiB de RAM:

$ free -h
               total        used        free      shared  buff/cache   available
Mem:            31Gi        10Gi       2.4Gi       1.0Gi        19Gi        20Gi
Swap:             0B          0B          0B
$ lsblk
NAME                  MAJ:MIN RM   SIZE RO TYPE  MOUNTPOINTS
sda                     8:0    0   1.8T  0 disk  
├─sda1                  8:1    0   512M  0 part  /boot/efi
├─sda2                  8:2    0   1.7G  0 part  /boot
└─sda3                  8:3    0   1.8T  0 part  
  └─sda3_crypt        254:0    0   1.8T  0 crypt 
    ├─vgubuntu-root   254:1    0   1.8T  0 lvm   /
    └─vgubuntu-swap_1 254:2    0   1.9G  0 lvm   
nvme0n1               259:0    0 953.9G  0 disk  
└─nvme0n1p1           259:1    0   100G  0 part  
  └─luks-...          254:3    0   100G  0 crypt /media/...
$ sysctl vm.swappiness
vm.swappiness = 60

O SSD é rápido, então prefiro que o Linux remova os arquivos em cache de página do SSD primeiro. O tempo de leitura sem cache é de segundos, de qualquer forma. O que deve impedir é a remoção de qualquer arquivo em /usrou /home. Meus man basharquivos e dpkg -S bin/bashretornam instantaneamente do cache de página, mas sem cache, levam meio minuto após sair dos LLMs. Mais gravemente, o Firefox precisa da minha ~/.mozillapasta para histórico e cache; com ela sem cache, esperar a barra de endereços funcionar leva minutos.

Estou procurando uma opção de configuração. systemd-runPoderia definir MemoryMax para ktorrent, mas reinicio frequentemente llama-serverpara alternar entre os LLMs de ~6 GiB e não quero um daemon separado para manter o cgroup ativo. Os problemas mancom e dpkgserão corrigidos quando meu /sistema migrar para o SSD, assim que eu resolver fscryptmeus problemas; enquanto isso, o /usrLLM tmpfsdeixaria RAM disponível insuficiente e overlayfsseria muito complexo. A carga de trabalho do LLM poderia, mas não deveria, remontar o SSD como uma solução alternativa. Isso deixa a nicecarga de trabalho de compilação do kernel em d ainda limpando o cache do meu navegador web.

Procurei /sys/block, mas não consegui encontrar a configuração correta. O Cgroups v2 tem opções por dispositivo, mas apenas para cargas de trabalho de gravação paralelas ( io.max), não para controlar como as cargas de trabalho sequenciais afetam o cache. Um patch de 2011 e uma pergunta de 2023 não veem nenhuma interface de espaço do usuário. Qual configuração pode ser usada para forçar a remoção do cache de páginas do SSD antes do cache do HDD?

Desde a atualização do CentOS 7 para o Rocky Linux 8, nosso maxloginslimite de PAM não está mais sendo aplicado para sessões SFTP.

Os usuários do SFTP pertencem ao sftpgrupo e temos isso em/etc/security/limits.d/10-maxlogins.conf

@sftp        -       maxlogins       1

Usamos internal-sftppara sessões SFTP e temos isso em/etc/ssh/sshd_config

Subsystem sftp  internal-sftp -l INFO

Match Group sftp
        ChrootDirectory %h
        ForceCommand internal-sftp
        AllowTcpForwarding no

No entanto, os usuários ainda conseguem abrir > 1 sessão SFTP simultânea. Deveríamos fazer algo diferente no EL8 para impor esses limites?

ATUALIZAÇÃO:
O registro de depuração do PAM está habilitado e é possível verificar se ele está lendo os arquivos de configuração relevantes. No entanto, o limite não é imposto.

Apr 10 16:13:04 sftp-test sshd[40955]: Accepted password for sftptest from 10.3.200.146 port 60976 ssh2
Apr 10 16:13:04 sftp-test sshd[40955]: pam_limits(sshd:session): reading settings from '/etc/security/limits.conf'
Apr 10 16:13:04 sftp-test sshd[40955]: pam_limits(sshd:session): reading settings from '/etc/security/limits.d/10-max-logins.conf'
Apr 10 16:13:04 sftp-test sshd[40955]: pam_limits(sshd:session): checking if sftptest is in group sftp
Apr 10 16:13:04 sftp-test sshd[40955]: pam_limits(sshd:session): process_limit: processing - maxlogins 1 for GROUP
Apr 10 16:13:04 sftp-test sshd[40955]: pam_limits(sshd:session): checking logins for 'sftptest' (maximum of 1)
Apr 10 16:13:04 sftp-test systemd[40960]: pam_unix(systemd-user:session): session opened for user sftptest(uid=1000) by sftptest(uid=0)
Apr 10 16:13:04 sftp-test sshd[40955]: pam_unix(sshd:session): session opened for user sftptest(uid=1000) by sftptest(uid=0)
Apr 10 16:13:26 sftp-test sshd[40986]: Accepted password for sftptest from 10.3.200.146 port 52110 ssh2
Apr 10 16:13:26 sftp-test sshd[40986]: pam_limits(sshd:session): reading settings from '/etc/security/limits.conf'
Apr 10 16:13:26 sftp-test sshd[40986]: pam_limits(sshd:session): reading settings from '/etc/security/limits.d/10-max-logins.conf'
Apr 10 16:13:26 sftp-test sshd[40986]: pam_limits(sshd:session): checking if sftptest is in group sftp
Apr 10 16:13:26 sftp-test sshd[40986]: pam_limits(sshd:session): process_limit: processing - maxlogins 1 for GROUP
Apr 10 16:13:26 sftp-test sshd[40986]: pam_limits(sshd:session): checking logins for 'sftptest' (maximum of 1)
Apr 10 16:13:26 sftp-test sshd[40986]: pam_unix(sshd:session): session opened for user sftptest(uid=1000) by sftptest(uid=0)

Quero testar uma aplicação que executa uma pilha IPv6 completa no espaço do usuário. A aplicação deve processar e enviar quadros Ethernet. Para isso, quero configurar uma interface de rede no Linux que eu possa acessar do meu computador local como se fosse outro participante da rede. Li que deveria usar um dispositivo de tap para isso. Então, criei um script para configurar uma interface e uma aplicação de teste.

Aqui está meu script para configurar a interface:

#!/bin/bash

MAC_ADDR="00:11:22:33:44:55"
IP_ADDR="2001:db8::2"

setup() {
    # Create the TAP interface (if not already created)
    ip tuntap add dev tap0 mode tap

    # Assign an IPv6 address to the TAP interface
    ip -6 addr add "${IP_ADDR}/64" dev tap0

    # Bring the TAP interface up
    ip link set dev tap0 up

    # Set a custom MAC address for the TAP interface
    # (Replace with your desired MAC address)
    ip link set dev tap0 address $MAC_ADDR

    # Disable kernel IPv6 handling on this interface
    sysctl -w net.ipv6.conf.tap0.forwarding=0
    sysctl -w net.ipv6.conf.tap0.accept_ra=0

    # Print interface details to verify the MAC address and IP
    ip addr show dev tap0
}

cleanup() {
    ip link set tap0 down || true
    ip tuntap del dev tap0 mode tap
}

# Setup tap interface
setup

# Cleanup when exiting
trap cleanup SIGINT

# Keep the interface up indefinitely
echo "Press Ctrl+C to bring down the interface"
sleep infinity

Esta é minha aplicação de teste:

// TunInterface.h
#pragma once

#include <string>
#include <functional>
#include <sys/socket.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <fcntl.h>
#include <cstring>
#include <iostream>
#include <netinet/if_ether.h>
#include <netinet/ip.h>

class TunInterface {
public:
    TunInterface(const std::string& dev_name,
                 std::function<void(const unsigned char*, size_t)> recv_callback,
                 const unsigned char* mac_address = nullptr)
        : dev_name(dev_name), receive_callback(recv_callback), mac_filter(mac_address) {
        // Open the TUN device
        tun_fd = open("/dev/net/tun", O_RDWR);
        if (tun_fd < 0) {
            std::cerr << "Failed to open TUN device" << std::endl;
            exit(1);
        }

        struct ifreq ifr;
        std::memset(&ifr, 0, sizeof(ifr));
        std::strncpy(ifr.ifr_name, dev_name.c_str(), IFNAMSIZ);

               // Set up the TUN interface
        if (ioctl(tun_fd, TUNSETIFF, &ifr) < 0) {
            std::cerr << "Failed to configure TUN interface" << std::endl;
            close(tun_fd);
            exit(1);
        }

        std::cout << "TUN interface " << dev_name << " configured successfully." << std::endl;
    }

    ~TunInterface() {
        close(tun_fd);
    }

           // Function to start receiving and calling the callback on incoming packets
    void receive() {
        unsigned char buffer[2048];  // Adjust the buffer size as needed
        while (true) {
            ssize_t len = read(tun_fd, buffer, sizeof(buffer));
            if (len < 0) {
                std::cerr << "Error reading from TUN interface" << std::endl;
                continue;
            }

                   // Call the user-defined callback
            if (mac_filter && !is_mac_filtered(buffer)) {
                // If the MAC address does not match the filter, skip the packet
                continue;
            }

            receive_callback(buffer, len);
        }
    }

           // Function to send a packet
    void send(const unsigned char* data, size_t len) {
        ssize_t bytes_written = write(tun_fd, data, len);
        if (bytes_written < 0) {
            std::cerr << "Error writing to TUN interface" << std::endl;
        }
    }

private:
    int tun_fd;
    std::string dev_name;
    std::function<void(const unsigned char*, size_t)> receive_callback;
    const unsigned char* mac_filter;  // If nullptr, no filtering is done

    bool is_mac_filtered(const unsigned char* packet) {
        if (mac_filter) {
            struct ethhdr* eth_header = reinterpret_cast<struct ethhdr*>(const_cast<unsigned char*>(packet));
            return std::memcmp(eth_header->h_dest, mac_filter, ETH_ALEN) == 0;
        }
        return true;  // No filter if mac_filter is nullptr
    }
};

#endif

#include "TapInterface.h"
#include <iostream>

int main() {
    // Define the MAC address for filtering (e.g., 00:11:22:33:44:55)
    uint8_t macAddr[6] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 };

           // Create a TapInterface with MAC filtering enabled
    TapInterface tap("tap0", macAddr);

    if (!tap.isValid()) {
        std::cerr << "Failed to create TAP interface\n";
        return 1;
    }

           // Register a callback to handle received frames
    tap.registerReceiveCallback([](const uint8_t* data, size_t len) {
        std::cout << "Received frame of length " << len << " bytes\n";
    });

    std::cout << "Listening on tap0. Press Ctrl-C to exit.\n";
    while (true) pause(); // Or use any other suitable loop
}

Quando executo, ping6 2001:db8::2espero ver pelo menos quadros Ethernet de descoberta de vizinhos no meu aplicativo de teste. Mas não vejo nada. Em vez disso, recebo respostas às minhas tentativas de ping6 assim que inicio o aplicativo de teste. Parece que o kernel ainda está interferindo. Tentei uma abordagem semelhante usando um dispositivo tun e funcionou, mas não funcionou na Camada 2. Estou usando o Ubuntu 24.04.

O que pode estar errado? Obrigado.

Recentemente, descobri que existe um arquivo de configuração do Service Switch nsswitch.confem alguns sistemas operacionais do tipo Unix. Podemos alterar a ordem de resolução de nomes de domínio usando nsswitch.conf.

A ordem mais comum deve ser priorizar os arquivos locais em vez do DNS. No nsswitch.conf, deve ser definido como

hosts:          files DNS

Gostaria de saber se há outros casos de uso que NÃO estão configurados como os acima? Por exemplo,

hosts:          DNS

Quais são os motivos pelos quais eles usam essa configuração?

Opcional: você conhece algum outro uso divertido, mas não muito conhecido nsswitch.conf?

No Linux, usando Bash, tenho dois scripts:

1. script.shé o roteiro principal, e
2. script_config.shé a configuração para script.sh.

Em script.sh, eu source script_config.shcarrego todas as configurações de lá.

Em script_config.sh, eu faço coisas como:

TEMPDIR=/mnt/sda1/temp

Não sei se essa é a melhor maneira, mas para mim está tudo bem, tenho a configuração em um arquivo separado e posso carregá-la no script principal.

Em uma versão antiga do script.sh, eu costumava shufler um arquivo ( cipher_to_use.txt) para obter uma entrada aleatória sobre qual cifra usar com cryptsetup.

Em cipher_to_use.txt, há apenas 6 cifras diferentes listadas, mas algumas linhas aparecem até 10 vezes, então shufas escolhi com mais frequência, mas ainda aleatoriamente. Isso funciona bem para mim.

Mas agora, com script_config.sh, estou procurando uma maneira de continuar essa abordagem,
mas não quero escrever as 6 cifras mais de uma vez em script_config.sh.

Como posso usar cifras diferentes com shuf, mas fazer com que algumas apareçam com mais frequência do que outras, enquanto listo cada cifra apenas uma vez em script_config.sh?

:editar

Obrigado nbanana pelas suas ideias, mas há alguma maneira de fazer algo um pouco diferente do seu jeito?

se eu escrever aqui script_config.sh:

(chk = cifra tem chave)

chk1_name_="--cipher aes-cbc-essiv:sha256      --hash sha512  --key-size 256"
chk1_weigt="15"

chk2_name_="--cipher serpent-cbc-essiv:sha256  --hash sha512  --key-size 256"
chk2_weigt="1"

chk3_name_="--cipher twofish-cbc-essiv:sha256  --hash sha512  --key-size 256"
chk3_weigt="1"

chk4_name_="--cipher aes-xts-plain64           --hash sha512  --key-size 512"
chk4_weigt="4"

chk5_name_="--cipher serpent-xts-plain64       --hash sha512  --key-size 512"
chk5_weigt="1"

chk6_name_="--cipher twofish-xts-plain64       --hash sha512  --key-size 512"
chk6_weigt="1"

o que devo adicionar script.shpara se tornar um ciphers_has_key_listarquivo -

com 15 vezes no chk1, 1 chk2 e assim por diante...?

e se o chk6 não existir mais?

e se houver um chk7 e um chk8?