Início / unix / Perguntas / 705522
Accepted
dotancohen
Asked: 2022-06-10 00:26:38 +0800 CST

Como saber o que são comandos, chamadas de sistema, bash built-ins, etc?

  • 772

Um colega de trabalho perguntou recentemente "O que é man"? Depois de ser informado de que nem todas as coisas acessíveis a partir do Bash CLI são comandos , fiquei cauteloso ao chamar manum comando.

man manapenas chama de interface:

NAME
       man - an interface to the on-line reference manuals

mantem um executável:

$ which man
/usr/bin/man
$ file /usr/bin/man
/usr/bin/man: ELF 64-bit LSB shared object

Então é manum programa, porque tem um executável? Que outros substantivos poderiam manser? Que substantivo seria para descrevê-lo? Realmente, estou interessado no caso geral de como eu poderia determinar o que é um arbitrário thing on the cli, mané apenas um exemplo.

Por falar nisso, qual é a palavra para todas as coisas que se pode usar no Bash CLI? Uma palavra que engloba comandos, aliases, chamadas de sistema, etc?

command-line terminology

3 respostas

  1. Em termos POSIX, qualquer coisa que possa pedir ao shell para fazer algo é um comando :

    Uma diretiva para o shell para executar uma tarefa específica.

    Então

    man man

    é um comando, como é (tecnicamente)

    man

    mantambém é um utilitário :

    Um programa, excluindo utilitários internos especiais fornecidos como parte do Shell Command Language, que pode ser chamado pelo nome de um shell para executar uma tarefa específica ou um conjunto relacionado de tarefas.

    (A exclusão não é significativa aqui; é mencionada porque utilitários integrados especiais têm propriedades específicas .)

    Para descobrir o que é um determinado comando, use type. Isto lhe dirá se está embutido, ou um programa no PATH(e onde), ou um alias etc. (ou desconhecido).

    Observe que as chamadas do sistema não podem ser usadas como comandos do shell.

    Veja também São comandos ou utilitários? e Qual é a diferença entre um comando interno e um que não é?

    • 9

  2. A partir do nível mais baixo:

    Chamadas do sistema

    As chamadas do sistema são a maneira como as tarefas do usuário (devem) usar para solicitar algum serviço do kernel e executar no modo de kernel privilegiado.

    Digamos, por exemplo, C é sua linguagem de programação e você quer que sua tarefa mude seu diretório atual, você precisará inserir uma instrução chdir() em seu programa.

    É claro que esses procedimentos não são imediatamente acessíveis a partir da linha de comando. vg digitar chdir na linha de comando não chamará a chamada de sistema chdir.

    A lista de todas as chamadas de sistema disponíveis é obviamente dependente do kernel e a única fonte confiável é certamente o include/linux/syscalls.harquivo de cabeçalho de sua distribuição de fonte do kernel.

    Instruções

    Uma CLI é uma interface para a tarefa que você está executando. Tudo o que você digita é chamado de instrução simplesmente porque deveria instruir a tarefa a realizar alguma ação.

    Comandos

    O que você digita passará primeiro por um interpretador que realizará alguma análise léxica nos tokens digitados e, no caso particular de um shell, poderá reconhecer o nome de um comando (entendido como não uma atribuição de variável) e decidir incidentalmente que precisa recorrer a outro programa para atender ao seu pedido. Ele então bifurcará um processo filho que executará o binário desse outro programa.

    Mas existem casos especiais para os quais a tarefa pode achar mais fácil satisfazer o pedido sem recorrer a programas externos (cálculo trivial por exemplo) ou, mais importante, deve executar o seu pedido internamente.

    Comandos integrados

    Voltando à nossa vontade inicial de mudar o diretório ativo, o usuário emitirá o conhecido comando shell cd. O que o usuário realmente quer é que o diretório atual de seu shell seja alterado. E como a chamada do sistema chdir altera apenas o diretório de trabalho atual do chamador, o shell simplesmente não pode bifurcar outro processo que não alteraria nada para seu pai. O shell deve executar a chamada de sistema chdir internamente.

    Os comandos internos do shell são listados em todas as yourshellnamepáginas man.

    Apelido

    Os aliases nada mais são do que sinônimos que qualquer usuário pode configurar e que serão traduzidos pelo interpretador de linha de comando na string desejada (supostamente para representar qualquer instrução legal para o shell).

    A lista de todos os aliases atualmente ativos pode ser obtida graças ao comando interno do shell alias.

    • 5
  3. Best Answer

    Eu tenho um pequeno shellscript, que pode me ajudar a identificar um comando: que tipo de comando é e se instalado por meio de um pacote de programa, qual pacote. Talvez use o what-aboutnome

    #!/bin/bash

LANG=C
inversvid="\0033[7m"
resetvid="\0033[0m"

if [ $# -ne 1 ]
then
 echo "Usage: ${0##*/} <program-name>"
 echo "Will try to find corresponding package"
 echo "and tell what kind of program it is"
 exit 1
fi
command="$1"

str=;for ((i=1;i<=$(tput cols);i++)) do str="-$str";done
tmp="$command"
first=true
curdir="$(pwd)"
tmq=$(which "$command")
tdr="${tmq%/*}"
tex="${tmq##*/}"
if test -d "$tdr"; then cd "$tdr"; fi
#echo "cwd='$(pwd)' ################# d"

while $first || [ "${tmp:0:1}" == "l" ]
do
 first=false
 tmp=${tmp##*\ }
 tmq="$tmp"
 tmp=$(ls -l "$(which "$tmp")" 2>/dev/null)
 tdr="${tmq%/*}"
 tex="${tmq##*/}"
 if test -d "$tdr"; then cd "$tdr"; fi
# echo "cwd='$(pwd)' ################# d"
 if [ "$tmp" == "" ]
 then
  tmp=$(ls -l "$tex" 2>/dev/null)
  tmp=${tmp##*\ }
  if [ "$tmp" == "" ]
  then
   echo "$command is not in PATH"
#   package=$(bash -ic "$command -v 2>&1")
#   echo "package=$package XXXXX 0"
   bash -ic "alias '$command' > /dev/null 2>&1" > /dev/null 2>&1
   if [ $? -ne 0 ]
   then
    echo 'looking for package ...'
    package=$(bash -ic "$command -v 2>&1"| sed -e '0,/with:/d'| grep -v '^$')
   else
    echo 'alias, hence not looking for package'
   fi
#   echo "package=$package XXXXX 1"
   if [ "$package" != "" ]
   then
    echo "$str"
    echo "package: [to get command '$1']"
    echo -e "${inversvid}${package}${resetvid}"
   fi
   else
    echo "$tmp"
   fi
 else
  echo "$tmp"
 fi
done
tmp=${tmp##*\ }
if [ "$tmp" != "" ]
then
 echo "$str"
 program="$tex"
 program="$(pwd)/$tex"
 file "$program"
 if [ "$program" == "/usr/bin/snap" ]
 then
  echo "$str"
  echo "/usr/bin/snap run $command     # run $command "
  sprog=$(find /snap/"$command" -type f -iname "$command" \
   -exec file {} \; 2>/dev/null | sort | tail -n1)
  echo -e "${inversvid}file: $sprog$resetvid"
  echo "/usr/bin/snap list $command    # list $command"
  slist="$(/usr/bin/snap list "$command")"
  echo -e "${inversvid}$slist$resetvid"
 else
  package=$(dpkg -S "$program")
  if [ "$package" == "" ]
  then
   package=$(dpkg -S "$tex" | grep -e " /bin/$tex$" -e " /sbin/$tex$")
   if [ "$package" != "" ]
   then
    ls -l /bin /sbin
   fi
  fi
  if [ "$package" != "" ]
  then
   echo "$str"
   echo " package: /path/program  [for command '$1']"
   echo -e "${inversvid} $package ${resetvid}"
  fi
 fi
fi
echo "$str"
#alias=$(grep "alias $command=" "$HOME/.bashrc")
alias=$(bash -ic "alias '$command' 2>/dev/null"| grep "$command")
if [ "$alias" != "" ]
then
 echo "$alias"
fi
type=$(type "$command" 2>/dev/null)
if [ "$type" != "" ]
then
 echo "type: $type"
elif [ "$alias" == "" ]
then
 echo "type: $command: not found"
fi
cd "$curdir"

    Às vezes, há duas alternativas, por exemplo, para echo, um programa compilado separado e um comando interno do shell. O shell embutido terá prioridade e será usado, a menos que você use o caminho completo do programa separado,

    $ what-about echo
-rwxr-xr-x 1 root root 35000 jan 18  2018 /bin/echo
----------------------------------------------------------------------------------
/bin/echo: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically
linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0,
BuildID[sha1]=057373f1356c861e0ec5b52c72804c86c6842cd5, stripped
----------------------------------------------------------------------------------
 package: /path/program  [for command 'echo']
 coreutils: /bin/echo 
----------------------------------------------------------------------------------
type: echo is a shell builtin

    Às vezes um comando está vinculado ao programa, que pode estar oculto, por exemplo, a versão renameque eu uso,

    $ what-about rename
lrwxrwxrwx 1 root root 24 maj 12  2018 /usr/bin/rename -> /etc/alternatives/rename
lrwxrwxrwx 1 root root 20 maj 12  2018 /etc/alternatives/rename -> /usr/bin/file-rename
-rwxr-xr-x 1 root root 3085 feb 20  2018 /usr/bin/file-rename
----------------------------------------------------------------------------------
/usr/bin/file-rename: Perl script text executable
----------------------------------------------------------------------------------
 package: /path/program  [for command 'rename']
 rename: /usr/bin/file-rename 
----------------------------------------------------------------------------------
type: rename is /usr/bin/rename

    Eu tenho um alias para rmpara evitar erros, e o alias tem prioridade sobre o programa em PATH. Você pode prefixar com barra invertida, \rmpara pular o alias e executar o programa diretamente. (Lembre-se de que o alias se aplica apenas ao usuário específico, e não a sudooutros usuários, a menos que tenham definido um alias semelhante.)

    $ what-about rm
-rwxr-xr-x 1 root root 63704 jan 18  2018 /bin/rm
---------------------------------------------------------------------------
/bin/rm: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV),
dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for
GNU/Linux 3.2.0, uildID[sha1]=864c9bbef111ce358b3452cf7ea457d292ba93f0,
stripped
---------------------------------------------------------------------------
 package: /path/program  [for command 'rm']
 coreutils: /bin/rm 
---------------------------------------------------------------------------
alias rm='rm -i'
type: rm is /bin/rm
    • 2

relate perguntas