humanityANDpeace's questions

Eu sou um pouco ignorante sobre localização em DE, já que prefiro o original em inglês para textos de qualquer maneira. No entanto, instalei um GNOME DE para algumas pessoas que só falam alemão. Eu poderia definir o idioma do GNOME/display para alemão e basicamente aproveitar Dateino lugar de filetodos os lugares (como por mágica).

O problema é que em um lugar minúsculo (o indicador de configuração de energia / bateria) diz "Não carregando" deixando um ponto de imperfeição, pois deveria ser mais preciso em alemão algo como " Nicht ladend ".

Agora eu fiz um:

 grep -iIr 'Not charging' /usr

esperando que me encontrasse o lugar onde residem as traduções/rótulos traduzidos. Infelizmente não dá nenhum resultado.

Onde estão os arquivos de tradução de localização que o GNOME usa para fornecer uma interface do usuário em alemão?

É um pouco difícil consultar uma documentação, pois uma pesquisa na web a respeito Gnome translation files localizationé mais provável que mostre guias de como se engajar em fazer parte do desenvolvimento e se tornar um tradutor, mas não indica onde os arquivos ou dados eventualmente são armazenados

Os e-mails da minha conta são buscados usando o protocolo POP3 usando o cliente de e-mail mutt.

Será desejável que o mutt baixe os (novos) e-mails (por tê-los disponíveis off-line), esses e-mails não serão excluídos do servidor de e-mail, pelo simples motivo de eu buscar meu e-mail usando duas máquinas diferentes e baixá-lo e depois excluí-lo torna impossível ter todos os e-mails disponíveis em todas as máquinas.

O problema para a configuração e o cerne da questão é o seguinte. Dizer ao mutt para não excluir os e-mails do servidor após o download, atualmente leva a duplicatas e downloads duplicados cada vez mais longos dos e-mails.

Existe uma maneira de configurar mutt, para manter os e-mails armazenados no servidor, mas não para baixar novamente os e-mails que já existem nas buscas de e-mail anteriores?

Lembro que outros clientes de e-mail, poderiam realizar tal tarefa me fazendo pensar que não é uma limitação inerente ao POP3protocolo.

Eu li algumas perguntas, que pedem conselhos sobre como rsyncdistribuir arquivos esparsos com eficiência, mencionando os arquivos /var/log/lastloge /var/log/faillog. Na verdade, eu mesmo tropecei no fato de esses arquivos serem um "problema", pois o backup via rsync os torna "unsparse".

O que eu me pergunto é, qual é a motivação de necessidade/fundo para ter esses arquivos como arquivos esparsos e enormes (no meu caso, era 1,1 TB)?

Também em relação a isso, um acompanhamento: Como eu estava assumindo que eles eram arquivos de log, não me importo excessivamente em truncar esses arquivos, corrompi alguma coisa ao truncar esses arquivos?

Com a intenção de desligar o display/monitor/tela instantaneamente (e só ser reativado ao pressionar a tecla), recorro a esta solução:

• um /bin/blankvtroteiro:

  #!/bin/sh
  
  echo 1 > /sys/devices/pci0000:00/0000:00:02.0/graphics/fb0/blank
  read keypress
  chvt 2
  

• um /bin/blankroteiro:

  #!/bin/sh
  
  openvt -s -f -c 40 /bin/blankvt
  

Tendo configurado isso, posso simplesmente chamar blankna linha de comando e a tela será desligada e a energia será economizada. Excelente!

Embora esta solução funcione agora, parece hackish e frágil e o que procuro é a maneira correta de obter o mesmo efeito. Digitar blankno prompt do shell deve resultar no desligamento da tela.

Minha pergunta, portanto: como posso mudar o monitor " corretamente "?

Antecedentes/Motivação

Não estou conectado à rede elétrica, economizar energia é primordial para mim. Eu preciso que o laptop/PC faça alguns cálculos, mas gostaria de desligar o consumo de energia supérfluo pela tela (que parece um consumidor não negligenciável de qualquer maneira).

Melhor se eu pudesse conseguir isso dentro de:

• GNOME Shell 3.32.2.
• Linux 5.xx

usando straceencontrei um comportamento de ldconfig(glibc), não consigo entender

lstat("/usr/lib/libext2fs.so.2", {st_mode=S_IFLNK|0777, st_size=16, ...}) = 0
unlink("/usr/lib/libext2fs.so.2")       = 0
symlink("libselinux.so.1", "/usr/lib/libext2fs.so.2") = 0

Existe alguma necessidade de ter a biblioteca de objetos compartilhados para ext2fs( libext2fs.so.2) ser um link simbólico para libselinux.so.1.

Como o ldconfig sabe o que fazer? Não me parece lógico que esse binário estático /usr/bin/ldconfigtenha esse comportamento codificado, certo. No entanto, seu arquivo de configuração /etc/ld.so.confnão me ajuda muito a esclarecer esse mistério.

O que torna tudo isso ainda mais confuso/suspeito com minhas ferramentas de distribuição (Arch Linux) não consigo encontrar nenhum pacote ao qual o arquivo pertença.

$ pkgfile /usr/lib/libselinux.so.1

não mostra nenhum pacote, enquanto $ pkgfile /usr/lib/libext2fs.so

saídascore/e2fsprogs

Então minha pergunta é especificamente:

1. qual é o papel deste libselinux.so.1 aqui
2. como o ldconfig decide criar esse link simbólico (que btw. quebra e2fsck)

Background: Li recentemente sobre um bug do freedesktop.org que permitia executar qualquer systemctlcomando para uid> INT_MAX. Assim corri:

root@host$> useradd -u 4000000000 largeuiduser
root@host$> su largeuiduser
largeuiduser@host$> systemctl ["whatever"]
[bug exists, and "whatever" gets executed]
largeuiduser@host$> exit
root@host$> userdel largeuiduser

Procurando uma maneira mais limpa que mais tarde encontrei

root@host$> setpriv --reuid 4000000000 systemctl ["whatever"]
[bug exists, and "whatever" stuff gets executed]

Mostrando que para explorar o bug, não há necessidade de um nome de usuário (temporário). Também ficou claro que eu não tinha certeza sobre: ​​quão essenciais são os nomes de usuário? .

Pergunta Minha pergunta, portanto, é. Quão dispensáveis ​​são os nomes de usuário, da perspectiva do kernel (linux/posix)? Eles são necessários, eles podem ser usados?

A minha suspeita é que o nome de usuário é apenas uma espécie de "amenidade" usada exclusivamente no espaço do usuário.

Uma boa resposta seria tentar esclarecer isso, fornecendo informações sobre em quais configurações os nomes de usuário se tornam "necessários" e em quais configurações eles são "dispensáveis".

Descobri que, ao se deparar com uma situação OOM de falta de memória, minha interface do usuário da caixa linux congela completamente por muito tempo.

Eu configurei a magic-sysrq-key e, em seguida, usando echo 1 | tee /proc/sys/kernel/sysrqe encontrando uma situação OOM->UI-unresponsive foi capaz de pressionar Alt-Sysrq-fque, como o dmesglog mostrou, faz com que o OOM encerre/mate um processo e, com isso, resolva a situação do OOM.

Minha pergunta é agora. Por que o linux não responde tanto quanto a GUI congelou, no entanto, parecia não acionar o mesmo OOM-Killer, que eu acionei manualmente por meio da Alt-Sysrq-fcombinação de teclas?

Considerando que na situação "congelada" do OOM o sistema não responde a ponto de nem mesmo permitir uma resposta oportuna (< 10 segundos) ao pressionar o Ctrl-Alt-F3(alternar para tty3), eu teria que assumir que o kernel deve estar ciente de sua falta de resposta, mas ainda assim não invocou por si só o Alt-Sysrq-fOOM-Killer, por quê?

Estas são algumas configurações que podem ter impacto no comportamento descrito.

$> mount | grep memory
cgroup on /sys/fs/cgroup/memory type cgroup (rw,nosuid,nodev,noexec,relatime,memory)
$> cat /sys/fs/cgroup/memory/memory.oom_control 
oom_kill_disable 0
under_oom 0
oom_kill 0

que enquanto eu entendo afirma que o cgroup de memória não tem OOM nem ativado nem desativado (evidentemente deve haver uma boa razão para ter o OOM_kill ativo e desativado, ou talvez eu não possa interpretar corretamente a saída, também under_oom 0não está claro, ainda )

Depois de ter aberto a parte master de um pseudoterminal

int fd_pseudo_term_master = open("/dev/ptmx",O_RDWR);

aí está o arquivo /dev/pts/[NUMBER]criado, representando a slaveparte do pseudo-terminal.

Pessoas ignorantes, como eu, podem imaginar que, depois de ter feito ptsname(fd_pseudo_term_master,filename_pseudo_term_slave,buflen);, deve-se simplesmente fazer int fd_pseudo_term_slave = open(filename_pseudo_term_slave,O_RDWR);e ser bom.

No entanto, deve haver um caso de uso muito importante de escravos pseudo-terminais "bloqueados", pois para simplificar as coisas, antes que a openchamada possa ser feita, é necessário usar man 3 unlockpt , para "desbloqueá-lo".

Não consegui descobrir o que é esse caso de uso? Qual a necessidade do pseudo-terminal estar inicialmente bloqueado? O que é alcançado com o código (retirado de uma libc)

/* Unlock the slave pseudo terminal associated with the master pseudo
   terminal specified by FD.  */
int
unlockpt (int fd)
{
#ifdef TIOCSPTLCK
  int save_errno = errno;
  int unlock = 0;

  if (ioctl (fd, TIOCSPTLCK, &unlock))
    {
      if (errno == EINVAL)
        {
          errno = save_errno;
          return 0;
        }
      else
        return -1;
    }
#endif
  /* If we have no TIOCSPTLCK ioctl, all slave pseudo terminals are
     unlocked by default.  */
  return 0;
}

Se possível, uma resposta detalharia um caso de uso, histórico ou atual.

A parte bônus da pergunta seria:

Os kernels linux atuais ainda contam com essa funcionalidade de "escravos de pseudo terminal bloqueados?"

Ideia: Esta é uma tentativa ineficiente de evitar condições de corrida?

Esperando por uma resposta, examinei mais a fonte do kernel linux sem ter uma boa resposta. No entanto, parece que um uso que pode ser "extraído" de um caso de bloqueio inicial do pseudo-terminal é fornecer algum tempo para o processo mestre do pseudo-terminal configurar alguns direitos de acesso ao arquivo em /dev/pts/[NUMBER], para evitar que algum usuário para acessar o arquivo em primeiro lugar. Isso pode ser parte da resposta? Estranhamente, no entanto, parece que esse estado de "bloqueio inicial" não parece realmente capaz de impedir várias aberturas do arquivo escravo, pelo menos para o que concebo como atomicidade garantida aqui.

Executando straceno bashshell que é instruído a executar mkdirforneceu esta saída que mostra muitas estatísticas antes de executar o mkdirbinário real:

BASH$> strace -f sh -c "bash -c \"mkdir /tmp\" 2>&1 | nl | grep -e "execve\|stat\|access" 
[.....]
  2766  [pid 17371] stat(".", {st_mode=S_IFDIR|0750, st_size=17262, ...}) = 0
  2767  [pid 17371] stat("/usr/local/sbin/mkdir", 0x7ffd87aad0a0) = -1 ENOENT      2767 (No such file or directory)
  2768  [pid 17371] stat("/usr/local/bin/mkdir", 0x7ffd87aad0a0) = -1 ENOENT (No such file or directory)
  2769  [pid 17371] stat("/usr/bin/mkdir", {st_mode=S_IFREG|0755, st_size=51136, ...}) = 0
  2770  [pid 17371] stat("/usr/bin/mkdir", {st_mode=S_IFREG|0755, st_size=51136, ...}) = 0
  2771  [pid 17371] access("/usr/bin/mkdir", X_OK) = 0
  2772  [pid 17371] stat("/usr/bin/mkdir", {st_mode=S_IFREG|0755, st_size=51136, ...}) = 0
  2773  [pid 17371] access("/usr/bin/mkdir", R_OK) = 0
  2774  [pid 17371] stat("/usr/bin/mkdir", {st_mode=S_IFREG|0755, st_size=51136, ...}) = 0
  2775  [pid 17371] stat("/usr/bin/mkdir", {st_mode=S_IFREG|0755, st_size=51136, ...}) = 0
  2776  [pid 17371] access("/usr/bin/mkdir", X_OK) = 0
  2777  [pid 17371] stat("/usr/bin/mkdir", {st_mode=S_IFREG|0755, st_size=51136, ...}) = 0
  2778  [pid 17371] access("/usr/bin/mkdir", R_OK) = 0
  2779  [pid 17371] execve("/usr/bin/mkdir", ["mkdir", "/tmp"], 0x557ec7e15920 /* 5 vars */) = 0

Minha pergunta é: É normal (e se sim por qual motivo) é /usr/bin/mkdir stat()ed muito? As linhas de saída são numeradas e, em particular, eu me pergunto que sentido a linha 2776fará uma vez que já 2771tenha sido executada. Também fiquei com a impressão de que o bash poderia ter salvo todas as chamadas do sistema desde 2770a final execve, pois statdeveria ter fornecido as informações de uma só vez? o que estou perdendo?

Desde então, procurei uma explicação e verifiquei como um shell alternativo dashse comportaria, ele também mostra algumas coisas stat():

DASH$> strace -f sh -c "dash -c \"mkdir /tmp\" 2>&1 | nl | grep -e "execve\|stat\|access" 
[....]
  2792  [pid 17372] stat("/usr/local/sbin/mkdir", 0x7ffc66010b50) = -1 ENOENT (No such file or directory)
  2793  [pid 17372] stat("/usr/local/bin/mkdir", 0x7ffc66010b50) = -1 ENOENT (No such file or directory)
  2794  [pid 17372] stat("/usr/sbin/mkdir", {st_mode=S_IFREG|0755, st_size=51136, ...}) = 0
  2795  [pid 17372] execve("/usr/sbin/mkdir", ["mkdir", "/run"], 0x55d8d3453bb8 /* 6 vars */) = 0

Estou ciente de que as linhas 2792, 2793, semelhantes às linhas 2767, 2768 are because of searching the executable in the various directories in the currentPATH`.

Se isso for descontado, então dashsó faz uma única estatística e bashfaz 10. Novamente levantando a questão: isso é normal?

ATUALIZAÇÃO: Havia mais geteuid(), getguid()e getuid()misturado getgid()nas estatísticas do bash

BASH$>strace -f sh -c "bash -c \"mkdir /tmp\"" 2>&1 | grep -e "execve\|stat\|access\|geteuid\|getegid\|getuid\|getgid" 
[....]
[pid 24534] stat("/usr/local/bin/mkdir", 0x7fffda480f30) = -1 ENOENT (No such file or directory)
[pid 24534] stat("/usr/local/sbin/mkdir", 0x7fffda480f30) = -1 ENOENT (No such file or directory)
[pid 24534] stat("/usr/bin/mkdir", {st_mode=S_IFREG|0755, st_size=51136, ...}) = 0
[pid 24534] stat("/usr/bin/mkdir", {st_mode=S_IFREG|0755, st_size=51136, ...}) = 0
[pid 24534] geteuid()                   = 1000
[pid 24534] getegid()                   = 1000
[pid 24534] getuid()                    = 1000
[pid 24534] getgid()                    = 1000
[pid 24534] access("/usr/bin/mkdir", X_OK) = 0
[pid 24534] stat("/usr/bin/mkdir", {st_mode=S_IFREG|0755, st_size=51136, ...}) = 0
[pid 24534] geteuid()                   = 1000
[pid 24534] getegid()                   = 1000
[pid 24534] getuid()                    = 1000
[pid 24534] getgid()                    = 1000
[pid 24534] access("/usr/bin/mkdir", R_OK) = 0
[pid 24534] stat("/usr/bin/mkdir", {st_mode=S_IFREG|0755, st_size=51136, ...}) = 0
[pid 24534] stat("/usr/bin/mkdir", {st_mode=S_IFREG|0755, st_size=51136, ...}) = 0
[pid 24534] geteuid()                   = 1000
[pid 24534] getegid()                   = 1000
[pid 24534] getuid()                    = 1000
[pid 24534] getgid()                    = 1000
[pid 24534] access("/usr/bin/mkdir", X_OK) = 0
[pid 24534] stat("/usr/bin/mkdir", {st_mode=S_IFREG|0755, st_size=51136, ...}) = 0
[pid 24534] geteuid()                   = 1000
[pid 24534] getegid()                   = 1000
[pid 24534] getuid()                    = 1000
[pid 24534] getgid()                    = 1000
[pid 24534] access("/usr/bin/mkdir", R_OK) = 0
[pid 24534] execve("/usr/bin/mkdir", ["mkdir", "/tmp"], 0x55adcd4dc040 /* 55 vars */) = 0

então talvez isso possa dar uma pista do que está "acontecendo aqui" com o bash? Está fazendo alguma verificação para evitar setuidexplorações?

**ATUALIZAÇÃO 2: ** O combo geteuid(), getguid(), getuid()e getgid()access parece ser a marca registrada do uso glibcda int eaccess(const char *pathname, int mode);função de biblioteca do . Cada uso de eaccessincorre no uso de all geteuid, getguid, e getuid, já que o bash executa a função findcmd.c , que por sua vez executa eaccess duas vezes assim.getgidaccessfile_status

#if defined (HAVE_EACCESS)
  /* Use eaccess(2) if we have it to take things like ACLs and other
     file access mechanisms into account.  eaccess uses the effective
     user and group IDs, not the real ones.  We could use sh_eaccess,
     but we don't want any special treatment for /dev/fd. */
  if (eaccess (name, X_OK) == 0)
    r |= FS_EXECABLE;
  if (eaccess (name, R_OK) == 0)
    r |= FS_READABLE;

onde cada eaccess pode ser vinculado a 4 syscalls.

atualização tentativa de esclarecer mais, usando um exemplo, faz os seguintes comandos de shell:

SHELLVARIABLE="1st line,
2nd line,
3rd line,
" 
printf '%s' "$SHELLVARIABLE"

gere esta saída:

1st line,<newline>2nd line,<newline>3rd line,<newline>

<newline>sendo o personagem 0x0a/ \n?

Formulação da pergunta original

Qual é a maneira correta (confirmação POSIX) de armazenar um caractere de nova linha0x0a (também conhecido por seu estilo commen c escap \n) em uma variável de shell.

Eu quero ter certeza de que fazendo o seguinte:

SHELLVARIABLE="
"

é, não apenas trabalhar por acaso, mas sim o caminho correto.

Como o printf do POSIX é perfeitamente capaz de produzir um caractere de nova linha (ou seja printf '\n', ou printf '%b' '\0012'), primeiro tentei uma forma mais explícita (? ou correta?):

SHELLVARIABLE="$(printf '\n')"

embora seja uma abordagem tentadora, não funciona. Conforme o padrão , a substituição de comandos (ou seja, via $()e ` `) deve remover

sequências de uma ou mais novas linhas no final da substituição.

Nota: Pedir para armazenar uma única nova linha final em uma variável shell é apenas abstrair o caso de uso mais geral (eu realmente procuro resposta) que é como armazenar uma string na variável shell POSIX que termina com o caractere de nova linha .

Eu gostaria de configurar o carregamento correto do módulo do kernel. Por esse motivo, estou interessado na saída do uname -rkernel personalizado que compilei e estou prestes a configurar.

Como esse kernel, é claro, ainda não está em execução, não tenho ideia de como posso obter as informações uname -rdesse kernel, pois ele ainda não foi inicializado e unameapenas exibe o ID do kernel atual.

Existe uma maneira de determinar a saída do uname -rkernel que acabei de compilar?

Na minha compreensão, a chamada de sistema aberta e fechada parece muito relacionada.

• ambos lidam com arquivos
• disponível na maioria dos sabores de unix (? existe algum unix que não os apresente?)

Portanto, esperava encontrá-los declarados no arquivo de /usr/include/unistd.hcabeçalho. No entanto - estranhamente - há apenas "fechar", mas nenhum "aberto" declarado lá (no meu sistema de kernel linux 4.17)?

A omissão da chamada do sistema abertounistd.h parece confirmada lendo o The Open Group Base Specifications Issue 7, 2018 edition

que diz no parágrafo "Declarações"

As seguintes devem ser declaradas como funções e também podem ser definidas como macros. Protótipos de função devem ser fornecidos.

int access(const char *, int);
alarme não assinado (não assinado);
int chdir(const char *);
int chown(const char *,> uid_t, gid_t);
int fechar(int);
[... mais algumas declarações, mas nenhum "aberto"]

Então - estranhamente para mim novamente - o arquivo /usr/include/asm/unistd_64.hcontém a linha

#define __NR_open 2

como se unistd.h ainda se importasse um pouco com "abertura de arquivos"?

Gostaria de saber, supondo que eu conecte um dispositivo não confiável (via porta USB ao meu sistema), quanto coloco meu sistema Linux em risco? Em particular, estou preocupado que, embora eu escreva udevregras para bloquear qualquer coisa, exceto (ou seja, abordagem de lista branca) um determinado dispositivo, o kernel seria vulnerável de qualquer maneira?

O udev tem a capacidade de impedir que o kernel (supondo que seja modular) carregue módulos que normalmente seriam carregados como forma de interagir com um dispositivo usb?

Na seguinte situaçãols -alh

total 0
drwxrwx--- 1 user http  20 Nov 30 08:08 .
drwxrws--- 1 user http 310 Nov 30 08:07 ..
drwx------ 1 http http  10 Nov 30 08:08 empty-subdir
drwx------ 1 http http  12 Nov 30 08:08 non-empty-subdir

onde existem dois subdiretórios (não pertencentes a mim), que listo como:

sudo ls empty-subdir -alh
total 0
drwx------ 1 http http 10 Nov 30 08:08 .
drwxrwx--- 1 user http 20 Nov 30 08:08 ..

sudo ls non-empty-subdir -alh
total 0
drwx------ 1 http http 12 Nov 30 08:08 .
drwxrwx--- 1 user http 20 Nov 30 08:08 ..
drwx------ 1 http http  0 Nov 30 08:08 subdir

A diferença entre os dois subdiretórios é que o não vazio non-empty-subdircontém uma pasta.

Minha pergunta é se é por design que tento rm -rfremover os subdiretórios que obtenho resultados:

$ rm empty-subdir -rf
$ rm non-empty-subdir -rf
rm: cannot remove 'non-empty-subdir': Permission denied
$ ls -alh
total 0
drwxrwx---+ 1 user http  10 Nov 30 08:14 .
drwxrws---+ 1 user http 310 Nov 30 08:07 ..
drwx------+ 1 http http  12 Nov 30 08:08 non-empty-subdir

Parece que o usuário com permissões de gravação em um diretório pode remover uma entrada de um arquivo ou um subdiretório vazio de algum outro usuário, mas não um subdiretório não vazio .

Uma resposta ideal para essa pergunta forneceria informações como:

• uma confirmação de que o comportamento descrito é reproduzível em outras máquinas (e não meras peculiaridades da minha caixa estragada)
• uma justificativa para explicar esse comportamento (por exemplo, existem casos de uso?)
• uma visão geral se houver diferenças entre os sistemas (BSD, Linux....)

Atualização : Com relação ao comentário de Ipor Sircer, testei novamente o cenário, sem nenhum recurso de ACL e é o mesmo. Portanto, modifiquei a pergunta para remover os +es das listagens para não dar origem a uma ideia de que o comportamento pode estar relacionado a ACLs.

A execução exec echo "some "; echo "test"no bash nunca imprime "algum teste"?

Gostaria de obter confirmação para esta pergunta, pois estou escrevendo um pequeno script de shell e gostaria que nada continuasse depois que o execcomando fosse chamado.

Acho que não precisaria me preocupar, conforme meu entendimento, após consultar:

• man 3 exec
• man 1p exec

Os scripts de shell, quando executados pelo shell, farão

1. o shell executa o programa exec, que
2. usa as exec***chamadas de sistema da família que substituem o shell/bash que está executando o script, impedindo assim outras ações do shell (que foi "substituído")

Conforme exposto anteriormente, o objetivo principal desta questão é buscar a confirmação do meu raciocínio para evitar que qualquer coisa no script que ocorra após o exec (como echo test) seja executada.

Agradeceria uma resposta geral (POSIX), na medida do possível, mas apenas em caso de particularidades, estou mais interessado em GNU/Linux e GNU/Bash