Onde exatamente existe o diretório raiz no sistema de arquivos Linux?

Estou fornecendo isso como uma resposta simples, proporcional à pergunta feita, na esperança de que seja acessível ao OP. as outras respostas são ótimas como estão, mas ficam um pouco complexas.

Então, primeiro, há uma pequena colisão terminológica.

Seu sistema possui uma “partição raiz” onde os arquivos do sistema operacional são armazenados. Essa partição não é realmente /. /na verdade, não "existe" em nenhum lugar quando o sistema está desligado. quando você inicializa, /surge do nada.

/é uma abstração usada para o nível mais primário da hierarquia de armazenamento que um sistema Linux pode endereçar. todo o armazenamento montado nesse sistema será montado em um local em algum lugar do /.

Assim, quando o sistema inicializa, ele estabelece a ideia de /montar o armazenamento nele. O armazenamento mais importante que ele monta é o volume em que o sistema operacional está armazenado, comumente chamado de "partição raiz", e acredito que essa seja a fonte da sua confusão. A "partição raiz" é montada /para que o nome faça sentido de uma perspectiva normal, mas torna perguntas como a sua estranhas. É também por isso que não existe um "loop", como você disse. A partição raiz contém apenas os arquivos que devem ser montados /, não / ela mesma.

Uma maneira de conceituar a diferença é, digamos que eu peguei a unidade que contém a "partição raiz" do meu laptop Ubuntu e a instalei no meu PC Debian para poder corrigir um problema de corrupção de dados. Eu escolho montá-lo em /mnt/laptop-drive/. Só porque a partição estava /no meu laptop não significa que ela esteja /no meu PC. Meu PC já tem um /e tem Debian nele. Portanto, a "partição raiz" é apenas uma partição como qualquer outra. se ele "contivesse" /, eu não seria capaz de montá-lo em um caminho arbitrário em outro sistema, mas em vez disso ele contém apenas "os arquivos que deveriam estar em /". Veja a diferença?

Parte da confusão vem das comparações com o Windows. O Windows apresenta cada unidade montada como algo independente. Tente pensar assim: em vez de ter uma coleção de discos montados independentes, é mais parecido com c e d e quaisquer outras unidades montadas no sistema operacional, então \é mais parecido com \c:\, \d:\, ..., \n:\, para que funcione da maneira da mesma forma que o Linux faz. Existe um nível mais primário na hierarquia de armazenamento que contém os discos que são montados pelo sistema operacional.

Espero que ajude.

Onde exatamente existe o diretório raiz no sistema de arquivos Linux?

Em uma instalação típica do Linux em que o computador possui um dispositivo de armazenamento, como um disco rígido ou unidade de estado sólido, o sistema de arquivos raiz residirá em uma partição desse dispositivo de armazenamento.

Toda a árvore de diretórios de um sistema Linux pode estar localizada em uma única partição.

Opcionalmente, alguns diretórios poderiam residir em partições separadas. Neste caso, o sistema de arquivos raiz é montado primeiro e então essas partições serão montadas sobre ele.

Por exemplo, uma instalação específica do Linux pode exigir que o /homediretório esteja localizado em uma partição separada. Neste caso, o dispositivo de armazenamento poderia ser configurado para conter duas partições, que poderiam ser reconhecidas pelo kernel do Linux como /dev/sda1e /dev/sda2. Durante o processo de inicialização, o arquivo /dev/sda1será montado como /e depois /dev/sda2será montado como /home.

A partição do /homediretório pode residir em um dispositivo de armazenamento separado, digamos, em uma segunda partição de um disco rígido adicional - /dev/sdb2.

Em instalações Linux mais sofisticadas, o diretório raiz pode existir completamente na RAM. Por exemplo, o diretório raiz pode ser compactado em uma imagem SquashFS , que é copiada de um local de rede remoto durante o processo de inicialização e montada em modo somente leitura como arquivo /.

Ou a imagem SquashFS pode residir em uma unidade USB e ser montada a /partir daí. Neste caso, o sistema de arquivos raiz existe na referida unidade USB.

O sistema de arquivos raiz pode existir como uma montagem do Network File System ; nesse caso, o sistema de arquivos existe em uma máquina separada e o kernel do Linux o monta durante o processo de inicialização.

A execução do comando mountsem argumentos deve listar todos os sistemas de arquivos montados atualmente. Além disso, esta lista existe no /proc/mountsarquivo. Entre as entradas deve haver uma para o sistema de arquivos raiz - que tem /como ponto de montagem, por exemplo:

/dev/sda3 on / type ext4 (rw,relatime)

Com isso, deverá ser possível ver onde existe o sistema de arquivos raiz para este sistema específico.

EDITAR:

Além disso, o root deve estar dentro de sda1, que é a unidade em que o sistema operacional está instalado e que é um loop, então como isso funciona?

Se assumirmos que o sistema de arquivos raiz do sistema operacional está localizado na /dev/sda1partição, o fato de a sda1entrada estar localizada no /devdiretório não cria uma dependência do tipo ovo de galinha.

Nenhuma das entradas no /devdiretório são arquivos regulares e não são armazenadas em um dispositivo de armazenamento, mas simplesmente listadas lá. Este diretório serve como um local onde o sistema Linux fornece entradas para vários dispositivos, para que possam ser consultados quando usados ​​em outros contextos.

Uma analogia grosseira para esse problema de "loop" no mundo Windows seria pensar: "Como é que a C:\unidade está listada no gerenciador de dispositivos enquanto o próprio gerenciador de dispositivos precisa ser carregado a partir da C:\unidade"? Esta é uma analogia muito grosseira, mas deve demonstrar que o gerenciador de dispositivos é um local onde os dispositivos são exibidos em um sistema Windows. No contexto desta comparação pode-se dizer (em termos muito imprecisos) que o /devdiretório em um sistema Linux é uma contrapartida do gerenciador de dispositivos no Windows.

Bem-vindo à inicialização do sistema 101.

O BIOS UEFI procura nas variáveis ​​​​do firmware e vê que diz "execute WDC100037/EFI/debian/grubx64.efi", onde WDC100037 é o número de série do seu disco rígido. grubx64.efipor sua vez, lê grub.cfg do mesmo diretório que informa como encontrar /boot. Na maioria dos casos, será um UUID fs; então ele apenas verifica todas as partições em todos os discos rígidos para ver qual delas contém /boot e o caminho do diretório raiz desse sistema de arquivos (cada sistema de arquivos tem um diretório raiz) grub.cfge lê isso.

grub.cfgé essa maneira ridiculamente projetada de dizer "carregar este kernel com este initramfs e esta linha de comando" e pular para ele. Em quase todos os casos, os kernels residem em /boot e é daí que são lidos. O cabeçalho do kernel possui slots livres para os números maiores e menores do dispositivo. grub pode e irá usá-los; no entanto, na maioria das vezes, prefere fazer outra coisa.

A forma mais comum é que o initramfs contém udev e mount_root. O que acontece na inicialização do kernel é que um novo ramdrive é criado do nada e o initramfs é desarquivado nele (o equivalente lógico de gunzip | cpio -i). Em seguida /init, é executado, que inicia o udev e analisa a linha de comando do kernel procurando por root=, espera que esse dispositivo seja criado, depois o monta em /root e, finalmente, o faz exec chroot /root /sbin/init.

Se não houver initrd, o kernel tenta analisar sua linha de comando por conta própria e identificar o argumento root=. Se for algo bastante simples, basta montar esse dispositivo. O modo de análise aqui é muito simples. Ele reconhece coisas como /dev/sd[af][1-16] e as transforma em números maiores e menores e as monta. Esta transformação pode não estar de acordo com o que está em /dev; e o kernel não tem como verificar. Falhando nisso, ele apenas olha o número maior e menor em seu cabeçalho e o monta. Se ainda for 0 ou a montagem falhar, ele entra em pânico.

Se você observar a entrada /dev/sda com um editor hexadecimal no dispositivo de disco, descobrirá que ela ocupa zero bytes. É um nó de dispositivo de bloco, e o campo rdev informa ao kernel qual deles. Na maioria dos sistemas, /dev é algum tipo de ramdisk; no entanto, um/dev físico é possível. Eu costumava deixá-lo preenchido em / até que ficasse muito instável devido à detecção dinâmica de dispositivos.

A ideia de nós de dispositivos é crítica. Na verdade, é tão crítico que até o Windows o possui. \.\PHYSICALDRIVE0 é o seu disco rígido. Não, você não pode dizer algo como \.\PHYSICALDRIVE0\C:\Users ; não é assim que funciona. Os nós de dispositivo são o dispositivo de disco como um único arquivo, não como um sistema de arquivos montado. O Windows pode montar um sistema de arquivos em um caminho; é tão raramente feito que você não está acostumado a ver.

Algumas das outras respostas são muito boas, mas notei que nenhuma delas explica completamente a diferença entre partições, pontos de montagem e sistema de arquivos. Com base na sua pergunta, acho que essa é a raiz da sua confusão (sem trocadilhos!), Então deixe-me tentar esclarecer.

(Aviso justo aos pedantes: estou sacrificando alguma precisão no que se segue para evitar que a postagem fique muito complicada.)

Uma partição em uma unidade é apenas uma sequência de bytes armazenados nessa unidade. Não sei sobre o Windows, mas no Linux, você pode examinar esses bytes lendo arquivos como /dev/sda1outros - esses arquivos são "arquivos de dispositivo" especiais que (entre outros propósitos) fornecem ao sistema acesso direto ao conteúdo bruto de a partição. Por exemplo, eu tenho uma partição que pode ser lida em /dev/sdc1, e aqui está uma exibição dos primeiros 256 bytes dessa partição:

$ sudo head -c 256 /dev/sdc1 | hexdump
0000000 5652 1bbe e881 0139 bf5e 81f4 8b66 832d
0000010 087d 0f00 e284 8000 ff7c 7400 6646 1d8b
0000020 8b66 044d 3166 b0c0 397f 0845 037f 458b
0000030 2908 0845 0166 6605 5583 0004 04c7 0010
0000040 4489 6602 5c89 6608 4c89 c70c 0644 7000
0000050 c750 0444 0000 42b4 13cd 820f 00af 00bb
0000060 eb70 6666 458b 6604 c009 850f 0097 8b66
0000070 6605 d231 f766 8834 0a54 3166 66d2 74f7
0000080 8804 0b54 4489 3b0c 0844 797d 048b 442a
0000090 390a 0845 037f 458b 2908 0845 0166 6605
00000a0 5583 0004 548a c00d 06e2 4c8a fe0a 08c1
00000b0 8ad1 0c6c 525a 748a 500b 00bb 8e70 31c3
00000c0 b4db cd02 7213 8c46 8ec3 0a45 c158 05e0
00000d0 4501 600a c11e 03e0 c189 ff31 f631 db8e
00000e0 f3fc 1fa5 23be e881 0057 8361 087d 0f00
00000f0 2485 83ff 0cef 16e9 beff 8125 42e8 5a00
0000100

Como você pode imaginar, esta não é apenas uma sequência de bytes qualquer; é uma sequência especial de bytes que pode ser interpretada por um software chamado driver de sistema de arquivos. Existem muitos drivers de sistema de arquivos diferentes, cada um deles reconhecendo suas próprias sequências especiais de bytes. Mas o que todos eles têm em comum é que interpretam suas respectivas sequências de bytes como uma hierarquia de pastas e arquivos. Quando você monta uma partição, o kernel diz ao driver do sistema de arquivos "vá olhar esses bytes e me diga a hierarquia de arquivos que representa", então ele constrói essa hierarquia de arquivos na memória do seu computador e faz com que apareçam como diretórios e arquivos que você pode usar .

Quero enfatizar que: diretórios e arquivos existem na memória do seu computador , enquanto partições são apenas sequências de bytes que especificam quais diretórios e arquivos devem existir e qual é o seu conteúdo.

A maioria dos drivers de sistema de arquivos usa sequências de bytes altamente otimizadas que são difíceis de serem interpretadas por humanos, mas você também pode ter um que interprete bytes em um arquivo de texto legível por humanos. Por exemplo, suponha que você crie este trecho de JSON:

{
  "file1": "here is a string which is the contents of file1",
  "directory1": {
    "file2": "this string is the contents of file2",
    "file3": "and this string is the contents of file3"
  }
}

Você pode salvar isso em um arquivo no disco - digamos, você poderia chamá-lo sdj1.json- e são apenas alguns bytes. Mas se você tiver um driver de sistema de arquivos capaz de interpretar esses bytes como diretórios e arquivos , poderá montá-lo:

$ mkdir mount-point
$ ffs.linux --in-place --mount mount-point sdj1.json &

e então, pronto, você tem arquivos e diretórios cujo conteúdo é determinado pelos bytes desse arquivo JSON.

$ ls mount-point/
directory1  file1
$ cat mount-point/file1
here is a string which is the contents of file1
$ ls mount-point/directory1/
file2  file3
$ rm mount-point/directory1/file3
$ echo "I am replacing the contents of file3 with this string" >mount-point/directory1/file3
$ cat mount-point/directory1/file3
I am replacing the contents of file3 with this string
$ umount mount-point
$ cat sdj1.json
{"directory1":{"file2":"this string is the contents of file2","file3":"I am replacing the contents of file3 with this string"},"file1":"here is a string which is the contents of file1"}

Isso é basicamente o que está acontecendo com sua partição /dev/sda1e seu sistema de arquivos.

No Linux, o sistema operacional é instalado na partição principal, que /dev/sda1está dentro do diretório raiz. Então está /homedentro /dev/sda1?

Não é realmente o caso que /homeestá dentro /dev/sda1 , assim como não é realmente o caso que mount-point/directory1está dentro sdj1.json . Seu /dev/sda1or sdj1.jsoné apenas uma fonte de bytes; ele não contém nenhum arquivo ou pasta. Mas ele contém (ou realmente fornece acesso a) os bytes que seu sistema pode usar para determinar o que está dentro /home.

Além disso, o root deve estar dentro de sda1, que é a unidade em que o sistema operacional está instalado e que é um loop, então como isso funciona?

Again, the root directory / isn't inside sda1, kind of like how mount-point isn't inside sdj1.json, but the reason is a little different in this case. Actually, there are two differences:

First, when you mount a partition, you need somewhere to mount it, basically some kind of name that the system uses to know that you're referring to something in that partition. In Windows, that name is a drive letter. In Linux, that name is a path to some directory, i.e. the "mount point". In the commands I posted earlier, when I used a path like mount-point/directory1/file3, Linux was able to look up that mount-point was the mount point of a filesystem, because it has (effectively) a table in the kernel showing which partitions are mounted on which paths. You can view that table on a Linux system by looking at /proc/mounts:

$ cat /proc/mounts
/dev/root / ext4 rw,relatime 0 0
[...omitted...]
sdj1 /home/diazona/tmp/ffs-test/mount-point fuse rw,nosuid,nodev,relatime,user_id=1000,group_id=1000 0 0

This is how Linux knows that, when I ask for a file or something that lives inside /home/diazona/tmp/ffs-test/mount-point, it needs to ask the filesystem driver that I used to mount that JSON file.

The second reason is what Frank's answer explained: the root directory / is a little special. You may have noticed the chicken-and-egg problem here: if you need a directory to mount a partition, but you need a partition to tell you that a directory exists, what comes first? Well, that's where it comes in handy that directories and files only exist in your computer's memory, because you actually don't need a partition on a hard drive or SSD in order for a directory to exist. The kernel can just do the thing in memory that corresponds to making a directory, and thereafter, that directory exists. This is basically what happens early in the process of starting up a Linux system to create /. Then the kernel looks for a partition on your drive, the root partition (which is specified by a command-line argument to the kernel, more or less... that's a long story which is partially explained by Joshua's answer), and mounts that partition on /. As I mentioned before, the filesystem driver uses the content of the partition to tell the system what files and directories exist under /, things like /bin and /usr and so on. In Windows, this process happens a little differently, but the general idea is the same: the system creates C: in memory and uses the bytes from a particular partition to tell it what files and directories should exist inside that drive.

No Linux, a pasta /dev contém "arquivos" de suas partições e de todo o disco:

1. sda - este é o arquivo do primeiro disco inteiro
2. sda1 - esta é uma partição no disco chamada "sda"
3. sdb - este é o segundo disco inteiro

Esses não são arquivos reais, mas lê-los permite ler o disco bruto do início ao fim. É por isso que esses arquivos de dispositivo também podem ser usados ​​para clonar discos brutos.

O Windows também tem isso, mas está oculto.

• \Device\HarddiskVolume1 - esta é uma partição de dispositivo no Windows.

Eles também permitem ler os discos brutos, mas não na linha de comando; você precisa de uma linguagem de programação real para acessar esses dispositivos.

O que o sistema operacional faz: O sistema operacional monta esses dispositivos em um local específico. Os locais de montagem da partição de inicialização padrão:

• Janelas:C:\
• Linux, MacOS, Android e iOS:\
• MacOS também possui: \Volumes\VolumeName

Outras partições podem opcionalmente ser montadas em locais personalizados:

• Windows: C:\SomeNTFSMountPoint
• Linux:\mnt\CustomMountPoint
• MacOS: \Volumes\CustomMountPoint

As respostas às suas perguntas:

/home está dentro de /dev/sda1?

Sim, /home está dentro de /dev/sda1, mas não na forma de um arquivo ou pasta que você normalmente pode visualizar no seu explorador de arquivos. /home dentro de /dev/sda1 é a forma mais bruta de /home, ou seja, binária. Os 1s e 0s que compõem /home (na tabela de arquivos mestre) são armazenados em sda1.

Como pode /dev/sda1 estar dentro da raiz se a raiz está dentro de /dev/sda1?

Isso pode parecer estranho no início, mas faz sentido. Linux tem arquivos falsos. Na verdade, esses arquivos não existem, mas parecem arquivos para facilitar o acesso a eles a partir do terminal, que é muito importante no Linux. Isso significa que /dev/sda1é montado, /mas um "atalho" para a partição bruta é criado /dev/, de modo que parece que a partição está dentro de si, mas não é porque sda1 não é um arquivo, é um atalho falso fingindo ser um arquivo. As operações de leitura e gravação feitas neste arquivo falso são encaminhadas para sua partição bruta.

Você pode pensar em cada sistema de arquivos como tendo um diretório "inferior" especial. Esse diretório realmente não tem um nome, mas vamos chamá-lo .por enquanto. Assim, por exemplo, sua partição de inicialização do Windows possui arquivos em .\Users, .\Windows, .\pagefile.sys, etc. Quando o Windows é inicializado, ele "anexa" essa .pasta sem nome a C:. De agora em diante, C:\Userssignifica "o arquivo .\Usersno sistema de arquivos rotulado como C:." Se você inicializasse uma partição diferente, o Windows poderia decidir anexar o primeiro sistema de arquivos D:.D:\Usersainda está acessando os mesmos arquivos, apenas possui um rótulo diferente. É por isso que você pode alterar as letras da unidade se souber onde procurar: você não está movendo nenhum arquivo, apenas alterando o rótulo do sistema de arquivos. (Você pode alterar o rótulo da sua partição de inicialização C:, mas é uma má ideia.)

O Linux funciona muito assim, mas os sistemas de arquivos são anexados a diretórios em vez de letras de unidade. Seu sistema de arquivos raiz é apenas um sistema de arquivos que contém coisas como ./usr, ./home, ./etc. Você poderia montar este sistema de arquivos /mnte então /mnt/usrsignificaria "o arquivo ./usrno sistema de arquivos montado em /mnt." Quando o kernel inicializa, ele nem sequer possui /, então, em um caso especial, ele encontra seu sistema de arquivos raiz e o anexa lá. Para o kernel /significa apenas "o sistema de arquivos raiz que escolhi na inicialização".

Conforme observado, o Linux permite montar coisas em qualquer diretório, então pode ficar um pouco complicado. Você pode ter uma unidade USB montada /home/foo/mnt, onde /homehá uma partição inicial separada no disco rígido. Então você tem três sistemas de arquivos separados: sua partição raiz em /, a partição inicial em /homee a unidade USB em /home/foo/mnt.

/devé estranho. Na verdade, é um sistema de arquivos especial chamado devfsque só existe na memória do kernel. Nenhum dos arquivos nele existe, mas o kernel sabe a quais dispositivos eles se referem. /dev/sda1significa algo como "a primeira partição no primeiro dispositivo SCSI". Porém, é apenas um rótulo para o dispositivo, não uma pasta. Para acessar os arquivos, você deve montar esse dispositivo em uma pasta.

In linux the OS is installed into the main partition which is say /dev/sda1 which is inside the root directory. So is /home inside /dev/sda1?

It's inside the device that /dev/sda1 represents, but it's not literally inside /dev/sda1. The items in /dev aren't the actual devices – they're only pointers into in-kernel objects, which exist regardless of /dev. It's kind of like an address book for devices.

(Windows has a similar thing: /dev/sda1 is \\.\Device\Harddisk0Partition1.)

But in addition to that, the whole /dev isn't physically part of your /; it's a separate virtual filesystem that is mounted sometime during boot. Your real partition only contains an empty directory onto which the virtual "devtmpfs" filesystem is mounted. (You can see this in findmnt.)

Also root has to be inside sda1 which is the drive the OS is installed in which is a loop, so how does that work?

Due to the general flexibility of Linux, there are several answers, in particular depending on whether your Linux distribution uses something called an "initramfs" the process can go two entirely different ways:

• Without an initramfs: Mounting of / is done entirely by the kernel itself.

  The kernel doesn't need to go through /dev because it's what creates the device nodes under /dev to begin with; therefore names like "sda1" are already known internally to the kernel even before they show up in /dev.

  (Again: The items in /dev aren't the actual devices; they're just pointers, and the devices exist regardless of them.)

  So the kernel can just take a shortcut, interpreting the "root=/dev/sda1" parameter in a different way without any relation to the file­system: it just discards the whole "/dev/" part and looks for a device that it internally calls "sda1".

• With an initramfs: Mounting of / is done by… a whole another mini-Linux system that exists in RAM and works as the initial, temporary / until the real one is mounted.

  There is an initrd.img file somewhere in your /boot which contains a small Linux root, just enough to include a few kernel modules and tools like /bin/mount. It is pre-loaded into memory by your bootloader (in the same way as the kernel itself is loaded), so the kernel doesn't need to know where to load it from.

  When the kernel starts, it mounts an empty memory filesystem (kind of like a "RAM disk") at / and unpacks the contents of the (already pre-loaded) initramfs into it. Since the initramfs is a fully-functioning Linux root and even has its own /dev, it can just mount /dev/sda1 like normal, then use a special call to swap the original in-memory / with your real one.