All perguntas(unix)

Eu tenho vários arquivos (notebooks Jupyter, .ipynb) que são arquivos de texto. Todos eles contêm alguma marcação LaTeX. Mas quando eu executo file, recebo:

$ file nb_*          
nb_1.ipynb:      ASCII text
nb_2.ipynb:      ASCII text
nb_3.ipynb:      ASCII text, with very long lines
nb_4.ipynb:      LaTeX document, ASCII text, with very long lines
nb_5.ipynb:      text, with very long lines

Como fileos distingue? Eu gostaria que todos os arquivos tivessem o mesmo tipo.

(Por que os arquivos devem ter o mesmo tipo? Estou enviando-os para um sistema online para compartilhamento. O sistema os classifica de alguma forma e os trata de maneira diferente, sem possibilidade de eu alterar isso. Suspeito que a plataforma use fileou talvez libmagic internamente e gostaria de contornar isso.)

Gostaria de saber os passos completos para criar e registrar um novo tipo mime personalizado no meu sistema . Se for importante, estou executando o KDE no Arch Linux.

As etapas devem incluir escrever o arquivo XML e associar um ícone ao tipo de arquivo e qualquer outra coisa que eu precise fazer. Eu prefiro usar xdg-mimeapenas utilitários de linha de comando.

Desejo entender a adição dessa associação mime para 1) minha conta de usuário e 2) em todo o sistema.

Por exemplo, digamos que eu queira abrir arquivos de certificado com um aplicativo personalizado que chamarei de MyCertInspector. Eu acredito que o XML deve ser semelhante a este:

<?xml version="1.0" encoding="utf-8"?>
<mime-info xmlns='http://www.freedesktop.org/standards/shared-mime-info'>
  <mime-type type="text/publickey">
    <glob-deleteall/>
    <glob pattern="*.crt"/>
    <glob pattern="*.cert"/>
  </mime-type>
</mime-info>

Pelo que entendi, ao incluir glob-deleteallem uma definição local do usuário, ele remove quaisquer associações mime existentes em todo o sistema. Gostaria de confirmar que meu entendimento está correto.

Eu também entendo que o primeiro passo neste processo é verificar a existência de um tipo mime com a extensão de arquivo que pretendo usar. Não sei exatamente como fazer isso no Arch porque não há /usr/share/applications/defaults.list no Arch e (pelo menos no meu sistema) não há nenhum mimeapps.listarquivo em todo o sistema.

Para a resposta, espero um guia passo a passo que cubra todas as etapas necessárias e que mencione os diretórios específicos onde as coisas devem estar localizadas em um sistema Arch Linux.

Da minha pesquisa até agora, acredito que as etapas gerais são:

1. verifique a existência de um tipo mime com a extensão de arquivo que pretendo usar
2. crie um arquivo XML para o meu tipo mime desejado.
3. registrar meu arquivo XML usando sudo xdg-mime install [options](e devemos abordar tanto o modo do sistema quanto o modo de usuário local.
4. associe o novo tipo mime ao(s) aplicativo(s) usado(s) para abri-lo.
5. registre o ícone para o tipo mime.
6. qualquer outra coisa (como verificações e etapas de verificação que uma pessoa deve fazer)

Meu objetivo é que qualquer pessoa que leia a resposta a esta pergunta seja capaz de dominar todo o processo completo de criação e instalação de um tipo mime personalizado em seu sistema.

Como posso adicionar um monitor virtual com driver proprietário da Nvidia? Anteriormente, usei uma placa Intel com esta solução, que funcionou bem: Adicionar saída VIRTUAL ao Xorg .

Agora quero mudar para um novo hardware, sem uma placa Intel. A solução mencionada no VNC-Server como um monitor X11 virtual para expandir a tela não funciona no meu caso. Quando quero adicionar o modo a uma saída, xrandrgera um erro.

xrandr --newmode test 173.00  1920 2048 2248 2576  1080 1083 1088 1120 -hsync +vsync
xrandr --addmode "DP-1" test
X Error of failed request:  BadMatch (invalid parameter attributes)
  Major opcode of failed request:  140 (RANDR)
  Minor opcode of failed request:  18 (RRAddOutputMode)
  Serial number of failed request:  41
  Current serial number in output stream:  42

Dados básicos:

• Hardware: HP ZBook 15 G3, configurado para gráficos discretos (Optimus não funciona!)
• Software: Debian 10.0.2; Kernel: 4.19.0, Nvidia-Driver-Module: xserver-xorg-video-nvidia-legacy-390xx

Se você perguntar, por que estou fazendo isso: eu uso um software para transferir a tela virtual para outra máquina via ethernet para conseguir dois monitores com dois notebooks. ( https://github.com/B-LechCode/sooScreenShare )

Atualização: agora existe uma solução proposta que funciona na minha máquina, mas não é possível adicionar novos modos como 1920x1200. Talvez alguém tenha uma ideia?

O que é necessário aqui é um comando que gere seis datas em um intervalo de anos (1987 a 2017). Por exemplo:

12/10/1987
30/04/1998
22/02/2014
17/08/2017
19/07/2011
14/05/2004

Como isso poderia ser feito, com sed, gawk, etc?

Eu sei que quando uma página de cache de página é modificada, ela é marcada como suja e requer um write-back, mas o que acontece quando:

Cenário: O arquivo /apps/EXE, que é um arquivo executável, é paginado completamente no cache da página (todas suas páginas estão em cache/memória) e sendo executado pelo processo P

A liberação contínua substitui /apps/EXE por um novo executável.

Suposição 1: suponho que o processo P (e qualquer outra pessoa com um descritor de arquivo referenciando o executável antigo) continuará usando o antigo, na memória /apps/EXE sem problemas, e qualquer novo processo que tentar executar esse caminho obterá o novo executável.

Suposição 2: Presumo que, se nem todas as páginas do arquivo forem mapeadas na memória, tudo ficará bem até que haja uma falha de página exigindo páginas do arquivo que foram substituídas e provavelmente ocorrerá uma falha de segmentação?

Pergunta 1: Se você bloquear todas as páginas do arquivo com algo como vmtouch, isso altera o cenário?

Pergunta 2: Se /apps/EXE estiver em um NFS remoto, isso faria alguma diferença? (presumo que não)

Por favor, corrija ou valide minhas 2 suposições e responda minhas 2 perguntas.

Vamos supor que esta é uma caixa CentOS 7.6 com algum tipo de kernel 3.10.0-957.el7

Atualização: Pensando mais sobre isso, gostaria de saber se esse cenário não é diferente de qualquer outro cenário de página suja.

Suponho que o processo que escreve o novo binário fará uma leitura e obterá todas as páginas de cache, pois todas as páginas serão paginadas e, em seguida, todas essas páginas serão marcadas como sujas. Se eles estiverem bloqueados, eles serão apenas páginas inúteis ocupando a memória central depois que a contagem de referências chegar a zero.

Eu suspeito que quando os programas atualmente em execução terminarem, qualquer outra coisa usará o novo binário. Supondo que tudo esteja correto, acho que só é interessante quando apenas parte do arquivo é paginado.

Suponha que um programa peça alguma memória, mas não haja memória livre suficiente. Existem várias maneiras diferentes de o Linux responder. Uma resposta é selecionar alguma outra memória usada, que não foi acessada recentemente, e mover essa memória inativa para swap.

No entanto, vejo muitos artigos e comentários que vão além disso. Eles dizem que mesmo quando há uma grande quantidade de memória livre, o Linux às vezes decide escrever memória inativa para trocar. Gravar para swap com antecedência significa que, quando eventualmente quisermos usar essa memória, não teremos que esperar por uma gravação no disco. Eles dizem que esta é uma estratégia deliberada para otimizar o desempenho.

Eles estão certos? Ou isso é um mito? Cite sua(s) fonte(s).

Por favor, entenda esta questão usando as seguintes definições:

• troca
• memória livre - a memória "livre" exibida pelo comando free . Este é o MemFreevalor de /proc/meminfo. /proc/meminfoé um arquivo de texto virtual fornecido pelo kernel. Consulte proc(5) ou documentos do RHEL .
• mesmo quando há uma grande quantidade de memória livre - para fins de argumento, imagine que há mais de 10% de memória livre.

Referências

Aqui estão alguns termos de pesquisa: linux "troca oportunista" OU (trocar "quando o sistema não tem nada melhor para fazer" OU "quando não tem nada melhor para fazer" OU "quando o sistema está ocioso" OU "durante o tempo ocioso")

No segundo resultado mais alto do Google, um usuário do StackExchange pergunta "Por que usar swap quando há espaço livre mais do que suficiente na RAM?" e copia os resultados do freecomando mostrando cerca de 20% de memória livre. Em resposta a esta pergunta específica, vejo que esta resposta é altamente votada:

O Linux começa a trocar antes que a RAM seja preenchida. Isso é feito para melhorar o desempenho e a capacidade de resposta:

• O desempenho é aumentado porque às vezes a RAM é melhor usada para cache de disco do que para armazenar memória de programa. Portanto, é melhor trocar um programa que está inativo por um tempo e, em vez disso, manter os arquivos usados ​​com frequência no cache.

• A capacidade de resposta é melhorada pela troca de páginas quando o sistema está ocioso, em vez de quando a memória está cheia e algum programa está sendo executado e solicitando mais RAM para concluir uma tarefa.

A troca diminui a velocidade do sistema, é claro - mas a alternativa à troca não é não trocar, é ter mais RAM ou usar menos RAM.

O primeiro resultado no Google foi marcado como uma duplicata da pergunta acima :-). Nesse caso, o autor da pergunta copiou os detalhes mostrando 7 MemFreeGB de 16 GB. A pergunta tem uma resposta aceita e votada:

Trocar apenas quando não há memória livre é apenas o caso se você definir swappinesscomo 0. Caso contrário, durante o tempo ocioso, o kernel fará a troca de memória. Ao fazer isso, os dados não são removidos da memória, mas uma cópia é feita na partição swap.

Isso significa que, se ocorrer uma situação de esgotamento da memória, ela não precisará gravar no disco imediatamente. Neste caso, o kernel pode apenas sobrescrever as páginas de memória que já foram trocadas, para as quais ele sabe que possui uma cópia dos dados.

O swappinessparâmetro basicamente apenas controla o quanto ele faz isso.

A outra citação não afirma explicitamente que os dados trocados também são retidos na memória. Mas parece que você preferiria essa abordagem, se estiver trocando mesmo quando tiver 20% de memória livre, e o motivo pelo qual está fazendo isso é melhorar o desempenho.

Até onde eu sei, o Linux suporta manter uma cópia dos mesmos dados na memória principal e no espaço de troca.

Também notei a alegação comum de que "troca oportunista" acontece "durante o tempo ocioso". Entendo que isso deve ajudar a me tranquilizar de que esse recurso geralmente é bom para o desempenho. Não incluo isso na minha definição acima, porque acho que já tem detalhes suficientes para fazer uma boa pergunta clara. Eu não quero tornar isso mais complicado do que precisa ser.

Motivação original

atop mostra `swout` (troca) quando tenho gigabytes de memória livre. Por quê?

Existem alguns relatórios como este, de Linux escrevendo para trocar quando há muita memória livre. A "troca oportunista" pode explicar esses relatórios. Ao mesmo tempo, pelo menos uma causa alternativa foi sugerida. Como primeiro passo para analisar as possíveis causas: O Linux alguma vez executa "troca oportunista" conforme definido acima?

No exemplo que relatei, a pergunta já foi respondida. A causa não foi a troca oportunista.

Tenho dois servidores hospedados no IDC. Só posso usar as portas 20/21/22/23/3389/33101-33109 para estabelecer conexões entre dois servidores. O dispositivo de rede IDC bloqueará quaisquer outros pacotes cuja porta de origem ou destino não esteja na lista/intervalo 20/21/22/23/80/3389/33101-33109. Mas a porta de origem do SSH é aleatória.

Usando o comando pode-se especificar facilmente uma porta remota.ssh username@server -p remote_port

Então, existe um sshparâmetro de comando ou alguma outra maneira de especificar uma porta de origem local para que eu possa usar, por exemplo, a porta 33101 para estabelecer a conexão SSH?

Minha topologia de rede é assim:

Aqui está meu arquivo de exemplo

user@linux:~$ cat file.txt 
Line 1
Line 2
Line 3
Line 4
Line 5
user@linux:~$ 

Eu posso imprimir a linha 2-4 comgrep -A2 'e 2' file.txt

user@linux:~$ grep -A2 'e 2' file.txt 
Line 2
Line 3
Line 4
user@linux:~$ 

Também posso imprimir o número da linha comgrep -n

user@linux:~$ grep -nA2 'e 2' file.txt 
2:Line 2
3-Line 3
4-Line 4
user@linux:~$ 

Além disso, o mesmo pode ser feito comsed -n 2,4p file.txt

user@linux:~$ sed -n 2,4p file.txt 
Line 2
Line 3
Line 4
user@linux:~$ 

Mas não tenho certeza de como imprimir o número da linha comsed

Seria possível imprimir o número da linha com sed?

Ao tentar ligar /dev/tcp/www.google.com/80, digitando

/dev/tcp/www.google.com/80

Bash diz no such file or directory. Ao olhar para o código de outras pessoas online, eles usam sintaxe como

 3<>/dev/tcp/www.google.com/80

Percebi que isso também funciona:

</dev/tcp/www.google.com/80

Por que esses símbolos são necessários para chamar certas coisas no bash?

Estou basicamente procurando arquivos e depois classificar pelo tamanho. O script funciona se eu não classificar o tamanho por ser humano legível. Mas eu quero que o tamanho seja legível para humanos. Como posso classificar tamanhos que são legíveis por humanos?

Por exemplo:

 ls -l | sort -k 5 -n | awk '{print $9 " " $5}'

Isso funciona como esperado, recebi o tamanho dos meus arquivos em bytes ascendentes:

1.txt 1
test.txt 3
bash.sh* 573
DocGeneration.txt 1131
andres_stuff.txt 1465
Branches.xlsx 15087
foo 23735
bar 60566
2016_stuff.pdf 996850

Agora, quero que o tamanho seja legível por humanos, então adicionei um parâmetro -h ao LS e agora alguns arquivos estão fora de ordem:

 ls -lh | sort -k 5 -n | awk '{print $9 " " $5}'

1.txt 1
DocGeneration.txt 1.2K
andres_stuff.txt 1.5K
test.txt 3
Branches.xlsx 15K
foo 24K
bar 60K
bash.sh* 573
2016_stuff.pdf 974K