All perguntas(unix)

No Linux, como /etc/hostse o DNS trabalham juntos para resolver nomes de host para endereços IP?

1. se um nome de host pode ser resolvido em /etc/hosts, o DNS se aplica depois /etc/hosts de resolver o nome de host ou trata o endereço IP resolvido /etc/hostscomo um "nome de host" para resolver recursivamente?

2. No meu navegador (firefox e google chrome), quando adiciono a /etc/hosts:

   127.0.0.1 google.com www.google.com
   

   digitar www.google.com na barra de endereços dos navegadores e pressionar Enter não conecta ao site. Depois de remover essa linha de /etc/hosts, posso me conectar ao site. Isso significa que /etc/hostssubstitui o DNS para resolver nomes de host?

   Depois de adicionar novamente a linha a /etc/hosts, ainda posso me conectar ao site, mesmo depois de atualizar a página da Web. Por que não se /etc/hostsaplica novamente, para que eu não possa me conectar ao site?

Obrigado.

Abaixo está a saída do comando curl (informações do arquivo sobre o branch), precisa de script ou comando para imprimir o nome do arquivo, tipo de arquivo e tamanho.

Eu tentei com, jqmas consegui buscar um valor único ( jq '.values[].size')

{
  "path": {
    "components": [],
    "name": "",
    "toString": ""
  },
  "revision": "master",
  "children": {
    "size": 5,
    "limit": 500,
    "isLastPage": true,
    "values": [
      {
        "path": {
          "components": [
            ".gitignore"
          ],
          "parent": "",
          "name": ".gitignore",
          "extension": "gitignore",
          "toString": ".gitignore"
        },
        "contentId": "c9e472ef4e603480cdd85012b01bd5f4eddc86c6",
        "type": "FILE",
        "size": 224
      },
      {
        "path": {
          "components": [
            "Jenkinsfile"
          ],
          "parent": "",
          "name": "Jenkinsfile",
          "toString": "Jenkinsfile"
        },
        "contentId": "e878a88eed6b19b2eb0852c39bfd290151b865a4",
        "type": "FILE",
        "size": 1396
      },
      {
        "path": {
          "components": [
            "README.md"
          ],
          "parent": "",
          "name": "README.md",
          "extension": "md",
          "toString": "README.md"
        },
        "contentId": "05782ad495bfe11e00a77c30ea3ce17c7fa39606",
        "type": "FILE",
        "size": 237
      },
      {
        "path": {
          "components": [
            "pom.xml"
          ],
          "parent": "",
          "name": "pom.xml",
          "extension": "xml",
          "toString": "pom.xml"
        },
        "contentId": "9cd4887f8fc8c2ecc69ca08508b0f5d7b019dafd",
        "type": "FILE",
        "size": 2548
      },
      {
        "path": {
          "components": [
            "src"
          ],
          "parent": "",
          "name": "src",
          "toString": "src"
        },
        "node": "395c71003030308d1e4148b7786e9f331c269bdf",
        "type": "DIRECTORY"
      }
    ],
    "start": 0
  }
}

a saída esperada deve ser algo como abaixo

.gitignore    FILE     224

Jenkinsfile   FILE     1396

Conceitos do sistema operacional diz

Considere uma leitura sequencial de um arquivo em disco usando as chamadas padrão do sistema open(), read() e write() . Cada acesso de arquivo requer uma chamada de sistema e acesso ao disco .

Alternativamente, podemos usar as técnicas de memória virtual discutidas até agora para tratar a E/S de arquivo como acessos de memória de rotina. Essa abordagem, conhecida como mapeamento de memória de um arquivo , permite que uma parte do espaço de endereço virtual seja logicamente associada ao arquivo. Como veremos, isso pode levar a aumentos significativos de desempenho. O mapeamento de memória de um arquivo é realizado mapeando um bloco de disco para uma página (ou páginas) na memória. O acesso inicial ao arquivo ocorre por meio de paginação de demanda comum, resultando em uma falha de paginação. No entanto, uma parte do arquivo do tamanho de uma página é lida do sistema de arquivos em uma página física (alguns sistemas podem optar por ler mais do que um pedaço de memória do tamanho de uma página de cada vez). Leituras e escritas subsequentes no arquivo são tratadas como acessos de memória de rotina. Manipular arquivos através da memória em vez de incorrer na sobrecarga de usar as chamadas de sistema read() e write() simplifica e acelera o acesso e uso de arquivos.

Você poderia analisar o desempenho do arquivo mapeado na memória?

Se eu estiver correto, o arquivo de mapeamento de memória funciona da seguinte maneira. É preciso uma chamada de sistema para criar um mapeamento de memória. Então, quando ele acessa a memória mapeada, ocorrem falhas de página. As falhas de página também têm sobrecarga.

Como o mapeamento de memória de um arquivo aumenta significativamente o desempenho em relação às chamadas de sistema de E/S padrão?

Encontrei uma pergunta semelhante, mas ainda não responde às minhas perguntas Os espaços de endereço virtual de todos os processos têm o mesmo conteúdo em suas partes "Kernel"?

1. Primeiro, considerando que os processos do usuário não têm acesso a essa parte e acho que se eles tentarem acessá-la, isso levaria a um erro, então por que incluir essa parte no espaço virtual do processo do usuário? Vocês podem me dar um cenário da vida real dessa parte sendo essencial e útil?

2. Além disso, mais uma pergunta é que eu sempre pensei que a parte do kernel da memória é dinâmica, o que significa que pode crescer, por exemplo, quando usamos bibliotecas dinâmicas em nossos programas, então é verdade? Em caso afirmativo, como o sistema operacional pode determinar o tamanho do kernel no espaço virtual de nossos processos?

3. E quando nosso kernel na memória física cresce ou muda, o mesmo efeito acontece na parte do kernel da memória virtual para todos os processos? O mapeamento desse kernel virtual para o kernel real é um mapeamento de um para um?

Recentemente, configurei os sistemas Fedora 28 e Ubuntu 18.04 e gostaria de configurar minha conta de usuário principal em ambos para que eu possa executar sudocomandos sem ser solicitada uma senha.

Como posso fazer isso nos respectivos sistemas?

Dado este exemplo mínimo

( echo "LINE 1" ; sleep 1 ; echo "LINE 2" ; )

ele gera LINE 1e, em seguida, após um segundo, gera LINE 2, conforme o esperado .

Se canalizarmos isso paragrep LINE

( echo "LINE 1" ; sleep 1 ; echo "LINE 2" ; ) | grep LINE

o comportamento é o mesmo do caso anterior, conforme esperado .

Se, alternativamente, canalizarmos isso paracat

( echo "LINE 1" ; sleep 1 ; echo "LINE 2" ; ) | cat

o comportamento é novamente o mesmo, como esperado .

No entanto , se canalizarmos para grep LINE, e depois para cat,

( echo "LINE 1" ; sleep 1 ; echo "LINE 2" ; ) | grep LINE | cat

não há saída até que um segundo passe, e ambas as linhas aparecem na saída imediatamente, o que eu não esperava .

Por que isso está acontecendo e como posso fazer a última versão se comportar da mesma maneira que os três primeiros comandos?

Eu me deparei com um script Bash hoje que tem nomes de funções com dois-pontos duplos ::neles, por exemplo, file::write()e file::read(). Eu nunca vi essa sintaxe antes em um script Bash e, quando invoquei o script, ele funcionou bem (para minha surpresa).

Depois de vasculhar a página man do Bash no meu sistema (e online), não consigo encontrar nada na documentação que suporte essa sintaxe para nomes de funções. Por exemplo, a seção Shell Defined Functionsdefine a sintaxe para uma função shell ser

function name [()] compound-command [redirection]

e então (em outra parte do manual) o token nameé definido como

name   A word consisting only of alphanumeric characters and
       underscores, and beginning with an alphabetic character
       or an underscore.  Also referred to as an identifier.

Não há menção em nenhum lugar da sintaxe de dois pontos para nomes de funções.

A única outra referência a essa sintaxe de dois pontos que encontrei até agora está neste Shell Style Guide (consulte a subseção Naming Conventions > Function Names) que recomenda o uso da sintaxe de dois pontos para nomes de funções em "pacotes" -- por exemplo, mypackage::myfunction().

Essa sintaxe de dois pontos para nomes de funções é um recurso legítimo do shell Bash ou talvez seja um recurso não documentado? Se for legítimo, onde está documentado no manual do Bash? Procurei e procurei, mas não encontro nada sobre isso no manual. O mais próximo que encontrei é o uso de ::na PATHvariável de ambiente para adicionar o diretório de trabalho atual ao caminho de pesquisa.

EXEMPLO

#!/bin/bash
function abc::def() {
    echo "${FUNCNAME[0]}"
}
abc::def

Eu testei este script em três distribuições Linux diferentes e em todas as três o script imprime abc::defem stdout.

Depois de ler sobre os namespaces do Linux, fiquei com a impressão de que eles são, entre muitos outros recursos, uma alternativa ao chroot. Por exemplo, neste artigo :

Outros usos [de namespaces] incluem [...] o isolamento no estilo chroot() de um processo para uma parte da hierarquia de diretório único.

No entanto, quando clono o namespace mount, por exemplo, com o comando a seguir, ainda vejo toda a árvore raiz original.

unshare --mount -- /bin/bash

Entendo que agora posso executar montagens adicionais no novo namespace que não são compartilhados com o namespace original e, portanto, isso fornece isolamento, mas ainda é a mesma raiz, por exemplo, /etcainda é o mesmo para ambos os namespaces. Ainda preciso chrootalterar a raiz ou existe uma alternativa?

Eu esperava que essa pergunta fornecesse uma resposta, mas a resposta usa apenas chroot, novamente.

EDIÇÃO #1

Havia um comentário agora excluído que mencionava pivot_root. Como isso é realmente parte de linux/fs/namespace.c, na verdade é parte da implementação de namespaces. Isso sugere que alterar o diretório raiz apenas com unsharee mountnão é possível, mas os namespaces fornecem uma versão própria - mais inteligente - do chroot. Ainda não entendi a ideia principal dessa abordagem que a torna fundamentalmente diferente de chroot, mesmo depois de ler o código-fonte (no sentido de, por exemplo, segurança ou melhor isolamento).

EDIÇÃO #2

Esta não é uma duplicata desta pergunta . Depois de executar todos os comandos da resposta, tenho separado /tmp/tmp.vyM9IwnKuY (ou similar), mas o diretório raiz ainda é o mesmo!

Estou usando um scripts de instalação que precisa setcape não é encontrado. Qual pacote contém? libcap2já está instalado.

A partir deste post é mostrado que FS:[0x28]é um stack-canary. Estou gerando esse mesmo código usando o GCC nesta função,

void foo () {
    char a[500] = {};
    printf("%s", a);
}

Especificamente, estou recebendo esta montagem ..

    0x000006b5      64488b042528.  mov rax, qword fs:[0x28]                ; [0x28:8]=0x1978 ; '(' ; "x\x19"
    0x000006be      488945f8       mov qword [local_8h], rax
...stuff...
    0x00000700      488b45f8       mov rax, qword [local_8h]
    0x00000704      644833042528.  xor rax, qword fs:[0x28]
    0x0000070d      7405           je 0x714
    0x0000070f      e85cfeffff     call sym.imp.__stack_chk_fail           ; void __stack_chk_fail(void)
    ; CODE XREF from 0x0000070d (sym.foo)
    0x00000714      c9             leave
    0x00000715      c3             ret

O que está configurando o valor de fs:[0x28]? O kernel, ou o GCC está lançando o código? Você pode mostrar o código no kernel ou compilado no binário que define fs:[0x28]? O canário é regenerado - na inicialização ou no processo de geração? Onde isso está documentado?