È necessario un file system quando non si desidera archiviare alcun dato

Ho fatto una domanda qui È obbligatorio avere un file system

Uno dei commenti è:

come un sistema senza file system funzionerebbe su Linux poiché anche una stampante o una scheda Ethernet è considerata un file? Qual è il tuo obiettivo qui? ... Kiwy, 24 febbraio alle 14:18

Ora ecco un messaggio di registro quando si avvia linux senza un file system (che si blocca alla fine):

    [Tue Apr 08 20:07:18.298 2014] 
[Tue Apr 08 20:07:18.298 2014] 
[Tue Apr 08 20:07:18.298 2014] U-Boot 2013.07 (Apr 08 2014 - 14:27:03)
[Tue Apr 08 20:07:18.298 2014] 
[Tue Apr 08 20:07:18.298 2014] Memory: ECC disabled
[Tue Apr 08 20:07:18.298 2014] DRAM:  1 GiB
[Tue Apr 08 20:07:18.308 2014] SF: Detected N25Q128A with page size 64 KiB, total 16 MiB
[Tue Apr 08 20:07:18.341 2014] *** Warning - bad CRC, using default environment
[Tue Apr 08 20:07:18.341 2014] 
[Tue Apr 08 20:07:18.341 2014] In:    serial
[Tue Apr 08 20:07:18.341 2014] Out:   serial
[Tue Apr 08 20:07:18.341 2014] Err:   serial
[Tue Apr 08 20:07:18.341 2014] U-BOOT for Xilinx-ZC702-14.7
[Tue Apr 08 20:07:18.341 2014] 
[Tue Apr 08 20:07:18.341 2014] 
[Tue Apr 08 20:07:18.341 2014] SF: Detected N25Q128A with page size 64 KiB, total 16 MiB
[Tue Apr 08 20:07:18.697 2014] Linux
[Tue Apr 08 20:07:18.697 2014]      Load Address: 0x00008000
[Tue Apr 08 20:07:18.697 2014]      Entry Point:  0x00008000
[Tue Apr 08 20:07:18.697 2014]    Verifying Hash Integrity ... OK
[Tue Apr 08 20:07:18.697 2014] ## Loading fdt from FIT Image at 01000000 ...
[Tue Apr 08 20:07:18.697 2014]    Using 'conf@1' configuration
[Tue Apr 08 20:07:18.697 2014]    Trying 'fdt@1' fdt subimage
[Tue Apr 08 20:07:18.697 2014]      Description:  Flattened Device Tree blob
[Tue Apr 08 20:07:18.697 2014]      Type:         Flat Device Tree
[Tue Apr 08 20:07:18.697 2014]      Compression:  uncompressed
[Tue Apr 08 20:07:18.697 2014]      Data Start:   0x0111d344
[Tue Apr 08 20:07:18.697 2014]      Data Size:    11179 Bytes = 10.9 KiB
[Tue Apr 08 20:07:18.697 2014]      Architecture: ARM
[Tue Apr 08 20:07:18.697 2014]      Hash algo:    crc32
[Tue Apr 08 20:07:18.697 2014]      Hash value:   a7a92b47
[Tue Apr 08 20:07:18.697 2014]      Hash algo:    sha1sha1+ OK
[Tue Apr 08 20:07:18.702 2014]    Booting using the fdt blob at 0x111d344
[Tue Apr 08 20:07:18.702 2014]    UncomprOK
[Tue Apr 08 20:07:18.702 2014]    Loading Device Tree to 07ffa000, end 07fffbaa ... OK
[Tue Apr 08 20:07:18.702 2014] 
[Tue Apr 08 20:07:18.702 2014] Starting kernel ...
[Tue Apr 08 20:07:18.702 2014] 
[Tue Apr 08 20:07:19.453 2014] u @c0a7b000 s5568 r8192 d14912 u32768
[Tue Apr 08 20:07:19.453 2014] Built 1 zonelists in Zone order, mobility grouping on.  Total pages: 260096
[Tue Apr 08 20:07:19.453 2014] Kernel command line: root=mtd:jffs2 rw rootfstype=jffs2 console=ttyPS0,115200
[Tue Apr 08 20:07:19.453 2014] PID hash table entries: 4096 (order: 2, 16384 bytes)
[Tue Apr 08 20:07:19.453 2014] Dentry cache hash table entries: 131072 (order: 7, 524288 bytes)
[Tue Apr 08 20:07:19.453 2014] Inode-cache hash table entries: 65536 (order: 6, 262144 bytes)
[Tue Apr 08 20:07:19.453 2014] __ex_table already sorted, skipping sort
[Tue Apr 08 20:07:19.453 2014] Memory: 1024MB = 1024MB total
[Tue Apr 08 20:07:19.453 2014] Memory: 1036960k/1036960k available, 11616k reserved, 270339 16




[Tue Apr 08 20:07:19.625 2014] I reach build/linux/kernel/xlnx-3.8/source/net/socket.c:





[Tue Apr 08 20:07:19.625 2014] DMA: preallocated 256 KiB pool for atomic coherent allocations
[Tue Apr 08 20:07:19.625 2014] xgpiops e000a000.ps7-gpio: gpio at 0xe000a000 mapped to 0xf004e000
[Tue Apr 08 20:07:19.625 2014] GPIO IRQ not connected
[Tue Apr 08 20:07:19.625 2014] XGpio: /amba@0/gpio@41220000: registered, base is 255
[Tue Apr 08 20:07:19.625 2014] GPIO IRQ not connected
[Tue Apr 08 20:07:19.625 2014] XGpio: /amba@0/gpio@41200000: registered, base is 251
[Tue Apr 08 20:07:19.625 2014] usbcore: registered new interface driver usbfs
[Tue Apr 08 20:07:19.625 2014] usbcore: registered new interface driver hub
[Tue Apr 08 20:07:19.625 2014] usbcore: registered new device driver usb
[Tue Apr 08 20:07:19.625 2014] Switching to clocksoutyPS0 at MMIO 0xe0001000 (irq = 82) is a xuartps
[Tue Apr 08 20:07:19.629 2014] console [ttyPSxusbps-ehci xusbps-ehci.0: irq 53, io mem 0x00000000
[Tue Apr 08 20:07:19.670 2014] xusbps-ehci xusbps-ehci.0: USB 2.0 started, EHCI 1.00
[Tue Apr 08 20:07:19.675 2014] hub 1-0:1.0: USB hub found
[Tue Apr 08 20:07:19.675 2014] hub 1-0:1.0: 1 port detected
[Tue Apr 08 20:07:19.681 2014] xi2cps e0004000.ps7-i2c: 400 kHz mmio e0004000 irq 57
[Tue Apr 08 20:07:19.686 2014] xadcps f8007100.ps7-xadc: enabled:   yes reference:  external
[Tue Apr 08 20:07:19.709 2014] xwdtps f8005000.ps7-wdt: Xilinx Watchdog Timer at f00ea000 with timeout 10s
[Tue Apr 08 20:07:19.709 2014] sdhci: Secure Digital Host Controller Interface driver
[Tue Apr 08 20:07:19.709 2014] sdhci: Copyright(c) Pierre Ossman
[Tue Apr 08 20:07:19.709 2014] sdhci-pltfm: SDHCI platform and OF driver helper
[Tue Apr 08 20:07:19.729 2014] usbcore: registered new interface driver usbhid
[Tue Apr 08 20:07:19.729 2014] usbhid: USB HID core driver


[Tue Apr 08 20:07:19.729 2014]  I am at build/linux/kernel/xlnx-3.8/source/drivers/hid/usbhid/hid-core.c



[Tue Apr 08 20:07:19.729 2014] VFP support v0.3: implementor 41 architecture 3 part 30 variant 9 rev 4
[Tue Apr 08 20:07:19.781 2014] MTD: MTD device with name "jffs2" not found.
[Tue Apr 08 20:07:19.781 2014] List of all partitions:
[Tue Apr 08 20:07:19.781 2014] No filesystem could mount root, tried:  jffs2
[Tue Apr 08 20:07:19.781 2014] Kernel panic - not syncing: VFS: Unable to mount root fs on mtd:jffs2
[Tue Apr 08 20:07:19.781 2014] CPU1: stopping
[Tue Apr 08 20:07:19.781 2014] Backtrace: 
[Tue Apr 08 20:07:19.781 2014] Function entered at [<c0011094>] from [<c01c6408>]
[Tue Apr 08 20:07:19.781 2014]  r6:c0246418 r5:00000000 r4:00000001 r3:60000193
[Tue Apr 08 20:07:19.781 2014] Function entered at [<c01c63f0>] from [<c0011fbc>]
[Tue Apr 08 20:07:19.781 2014] Function entered at [<c0011f78>] from [<c0012270>]
[Tue Apr 08 20:07:19.781 2014]  r4:c0247ef4 r3:c0011f78
[Tue Apr 08 20:07:19.781 2014] Function entered at [<c001220c>] from [<c00084e4>]
[Tue Apr 08 20:07:19.781 2014]  r5:ef07bf68 r4:f8f00100
[Tue Apr 08 20:07:19.824 2014] Function entered at [<c0008484>] from [<c000da00>]
[Tue Apr 08 20:07:19.824 2014] Exception stack(0xef07bf68 to 0xef07bfb0)
[Tue Apr 08 20:07:19.824 2014] bf60:                   c0a838d0 00000000 00000003 00000000 ef07a000 c01cd528
[Tue Apr 08 20:07:19.824 2014] bf80: ef07a000 c025c418 0000406a 413fc090 00000000 ef07bfbc ef07bfc0 ef07bfb0
[Tue Apr 08 20:07:19.824 2014] bfa0: c000e94c c000e950 60000113 ffffffff
[Tue Apr 08 20:07:19.824 2014]  r6:ffffffff r5:60000113 r4:c000e950 r3:c000e94c
[Tue Apr 08 20:07:19.824 2014] Function entered at [<c000e924>] from [<c000eacc>]
[Tue Apr 08 20:07:19.824 2014] Function entered at [<c000ea40>] from [<c01c4208>]
[Tue Apr 08 20:07:19.824 2014]  r5:00000001 r4:c024cf68
[Tue Apr 08 20:07:19.824 2014] Function entered at [<c01c4118>] from [<001c37c8>]
[Tue Apr 08 20:07:19.844 2014]  r6:10c03c7d r5:00000015 r4:2f06406a r3:c01c37b0
[Tue Apr 08 20:07:19.844 2014] MTD: MTD device with name "jffs2" not found.
[Tue Apr 08 20:07:19.844 2014] List of all partitions:
[Tue Apr 08 20:07:19.844 2014] No filesystem could mount root, tried:  jffs2
[Tue Apr 08 20:07:19.844 2014] Kernel panic - not syncing: VFS: Unable to mount root fs on mtd:

Sto avviando dal flash.

Ora dal registro è molto chiaro che molti dei driver sono già caricati anche se il caricamento del file system non è riuscito (perché non ho intenzionalmente messo il file system rootfs.jffs2 in flash).

Ora, facendo riferimento al commento sopra, se tutto è file in Linux, come mai i driver vengono caricati correttamente? Puoi vedere USB, GPIO, SD tutto sta arrivando prima che richieda il file system (e non è riuscito).

Quindi è tecnicamente corretto dirlo

Linux DEVE avere un file system

Alcuni retroscena Quello che sto cercando di ottenere è avere Linux in esecuzione su un sistema in cui verrà eseguita un'applicazione di controllo. L'applicazione acquisisce solo alcuni dati e li invia ad alcuni slave. Non si tratta di memorizzare TUTTI i dati. Quindi vorrei eliminare completamente il file system. Secondo la mia comprensione del file system è necessario per l'archiviazione dei dati e poiché non memorizzerò alcun dato, quindi perché avere un file system e aumentare l'utilizzo delle risorse?

Aggiornare

Anche se l'ho menzionato in background , ma per essere specifici l'invio dei dati avverrebbe tramite USB o Ethernet, quindi è naturale disporre di driver corrispondenti.

Se hai bisogno di Linux, hai bisogno di un filesystem.

(Voglio dire Linux qui il sistema operativo, piuttosto che Linux il kernel del sistema operativo. Passerò a questa interpretazione più ristretta di seguito.)

La tua osservazione sul caricamento dei driver di dispositivo all'avvio prima che esista il filesystem è un'aringa rossa. Puoi caricare un driver senza avere un filesystem. Quello che non puoi fare è fd = open("/dev/foo", O_RDONLY)senza un filesystem.

Ciò non significa che è necessario un supporto di archiviazione riscrivibile persistente formattato con un file system tradizionale, come nell'esempio JFFS2. Tutto ciò che serve per supportare un /devalbero tradizionale è una struttura di dati che si comporti come un filesystem su disco. I moderni Linux usano udev su un filesystem in memoria per consentire l'accesso ai /devnodi senza bisogno di archiviazione permanente per i /devnodi, per esempio.

È inoltre necessario un filesystem per utilizzare diverse altre funzionalità di Linux-the-OS:

• Hai bisogno di librerie condivise o moduli del linguaggio di scripting? Avete bisogno di un filesystem per memorizzare /lib/libfoo.*, /usr/lib/perl5/*, /lib/ld.so, /etc/ld.so.cache, etc.

• Hai bisogno di moduli kernel caricabili? È necessario un filesystem per/lib/modules/$(uname -r)/*

• Hai bisogno di più di un eseguibile, come una shell o un editor di testo? Hanno bisogno di un filesystem in cui vivere.

• Hai bisogno del kernel per imporre il controllo dell'accesso? La maggior parte di ciò avviene tramite bit di autorizzazione , ACL e etichette SELinux su un file o una directory da qualche parte.

Probabilmente potrei trovare altri esempi, ma lo farà.

È possibile caricare tutte le risorse di cui il sistema ha bisogno dalla memoria permanente nella RAM, in modo che una volta avviato, il sistema non usi affatto la memoria permanente. Le distribuzioni Live Linux lo fanno. È anche comune per i sistemi operativi Linux incorporati costruire l'intero file system nella RAM all'avvio, in modo che una volta avviato, non continuino più a fare riferimento allo storage persistente come un dispositivo di archiviazione flash .

Se stai costruendo un sistema embedded mono-task a ambito ristretto, probabilmente non hai bisogno di Linux-the-OS. Potrebbe essere necessario solo un sistema operativo integrato più piccolo e con meno funzionalità , oppure potresti essere in grado di scrivere direttamente sul metallo .

Alcune delle altre risposte qui parlano di spogliare Linux fino al punto in cui tutto ciò che ti rimane è Linux-the-kernel, o accoppiato con un singolo eseguibile - il tuo programma, eseguito sotto il kernel - o eseguito come un programma monolitico con il tuo codice incorporato staticamente al suo interno. In entrambi i casi, puoi allontanarti completamente dalla necessità di un filesystem, ma ciò che si ottiene non è più Linux-the-OS.

Ho scritto una risposta a una domanda correlata che descrive in dettaglio come il concetto di un file sia fondamentale per il modo in cui Unix funziona e, dato che non è possibile avere un file senza un qualche tipo di filesystem, significa che sicuramente ne hai bisogno.

Tuttavia è possibile sopravvivere senza un filesystem esistente su qualsiasi supporto di memorizzazione persistente. L' initramfsimmagine può essere compilata nel kernel stesso (o altrimenti posizionata in un punto in cui il bootloader può accedervi). Tecnicamente l'immagine che viene scritta sul supporto di memorizzazione è un archivio e non un filesystem; diventa tale solo dopo che è stato caricato. Se si inseriscono tutti i file binari necessari al suo interno, non è necessario inserirli in un filesystem su supporti di archiviazione. In questo modo, puoi assicurarti che tutti i filesystem necessari che il sistema deve eseguire esistano puramente in memoria.

Ovviamente gli svantaggi sono che dal momento che tutto ciò di cui il sistema ha bisogno deve esistere in memoria, potresti scoprire che non hai abbastanza per quello che vuoi fare. Inoltre avrai difficoltà a scrivere qualsiasi dato che desideri persistere dopo un riavvio.

In realtà, tecnicamente parlando non hai bisogno di un file system. Il comportamento predefinito è disporre di un file system da cui avviare. (ad es. /sbin/initviene lanciato da lì). Tuttavia, se ti piace, puoi vedere cosa succede do_basic_setup()dentro linux-source/init/main.c. Quando viene chiamata quella routine, il kernel e la CPU0 sono pronti per il vero lavoro. Puoi distruggere tutto il lavoro necessario per avviare initramfs, che è anche un filesystem! - e tutto il resto e sostituirlo con il proprio codice per funzionare senza i filesystem.

È quindi possibile utilizzare i thread del kernel per generare qualsiasi processo desiderato. Tuttavia, tutto ciò sarebbe super brutto.

Un filesystem fornisce più di un semplice posto dove archiviare i file. È dove vivono gli eseguibili (programmi), le librerie e i file di configurazione per il tuo sistema. Come minimo il kernel di Linux richiede un filesystem per permettergli di trovare / eseguire il processo " init " che è responsabile di assicurare che altri processi siano avviati nel modo appropriato per il tuo sistema.

Riguardo a tutto ciò che è un file, questa frase indica che i sistemi Linux / Unix forniscono accesso a dispositivi, risorse e file tramite un'astrazione di file. Ciò significa che esiste un'interfaccia coerente (aperta, chiusa, lettura, scrittura, ...) a (quasi!) Tutto.

La tua confusione con i driver di dispositivo deriva dal fatto che stai confondendo l'origine delle istruzioni del driver del dispositivo con le istruzioni della macchina eseguibile effettiva che implementano il driver del dispositivo. Nell'esempio fornito, i driver di dispositivo sono integrati direttamente nel kernel e possono essere eseguiti dopo che l'immagine del kernel è stata caricata in memoria. Se i driver di dispositivo sono costruiti come moduli , sono contenuti nei file nel filesystem e le istruzioni della macchina eseguibile vengono caricate dal file nella memoria del kernel dove vengono eseguite. Una volta che il driver di dispositivo è caricato e in esecuzione, in genere rende i dispositivi che controlla disponibili in / dev tramite il file system.

Una volta che il kernel sta eseguendo il processo init e tutti i suoi figli devono accedere al file per interagire con altri processi, accedere ai dispositivi, richiedere memoria virtuale, ottenere fonti di numeri casuali, scambiarsi messaggi. Questo è per la parte principale eseguita tramite l'accesso al filesystem. L'invio / la ricezione tramite la rete è un'eccezione alla necessità di accedere al filesystem, ma probabilmente troverai comunque la necessità di accedere a un filesystem molto rapidamente.

Davvero dato il tuo caso d'uso dovresti guardare usando una piccola distribuzione configurabile come OpenWrt . Con ciò puoi costruire un sistema che ha un set minimo di software installato e che fondamentalmente gira dalla RAM senza che sia necessario scrivere nulla nella memoria stabile. Una volta eseguita questa operazione, è sempre possibile rimuovere i componenti non necessari, ma non sottovalutare l'aiuto fornito da una distribuzione con strumenti di debug e una base utente attiva.

I file system sono un mezzo per i sistemi operativi per organizzare i dati memorizzati in modo persistente. In particolare, consentono al sistema operativo di archiviare e recuperare i dati in modo efficiente. Quando si dice che si è avviato da un'unità flash, significa che questa unità flash ha sicuramente un file system. Il fatto che il kernel abbia caricato un driver significa che deve aver avuto modo di trovarlo da qualche parte. Questo "trova da qualche parte" è raggiunto dal file system. Ma anche se il kernel è monolitico e ha tutto compilato, almeno il boot loader deve aver avuto un modo per trovare il kernel.

In teoria, potresti farlo senza un sofisticato file system, mettere tutto in una posizione fissa e codificare quella posizione, ma quale scopo servirebbe? E non stiamo ancora parlando dei tuoi file di dati come e-mail e quant'altro. Senza un file system, non esiste un modo valido per archiviarli (e successivamente trovarli). Anche se non si desidera archiviare alcun file, il sistema operativo è molto più di un semplice kernel, include vari servizi e programmi di destinazione dell'utente che sono memorizzati in file.

Per farla breve, è necessario disporre di un file system da qualche parte, perché se il kernel non ne trova (come nel tuo esempio) va in panico (come mostra il tuo registro) - il che significa che si rifiuta di fare qualsiasi cosa. Ma se eseguire un'installazione di Linux da un'unità flash (con un file system) soddisfa le tue esigenze, allora non hai bisogno di un file system su disco o altrove.

Se si desidera che il sistema operativo Linux funzioni, è necessario disporre di un file system.

Ma non è necessario che il file system sia su un disco rigido (o SSD ecc.). In realtà non è nemmeno richiesto che Linux sia sul dispositivo.

È possibile utilizzare il protocollo BOOTP per caricare il sistema operativo in rete. Hai bisogno di un bel po 'di RAM perché questo sia efficace. Il boot loader è una ROM standard sulla scheda di rete. Tutto il resto viene trasferito tramite la rete e archiviato in un file system virtuale creato nella RAM.

Tuttavia, per un dispositivo dedicato sarebbe meglio installare la memoria flash con l'equivalente di un disco USB Live Boot ed eseguire il programma da lì. Sembra che tu stia già cercando di fare qualcosa del genere. Quando viene eseguito da un Flash Disk o ROM, viene creato anche un file system virtuale nella RAM, ma è necessario meno RAM se si utilizza il metodo BOOTP.

A differenza di Ubuntu, Debian usa un'immagine di avvio ibrida che può essere copiata direttamente su un disco flash USB usando dd, potresti trovarlo più facile da lavorare, specialmente dal momento che Ubuntu richiede l'uso di un programma speciale per creare l'USB avviabile e quel programma è un po 'buggy.

È possibile aggiungere i propri programmi a un'immagine del sistema operativo utilizzando vari strumenti per montare ISO come file system di lettura / scrittura. È possibile utilizzare rc.local per avviare il programma, ma attenzione che rc.local viene eseguito più volte durante l'avvio. Potresti anche creare uno script /etc/init.d/ ma questo è più complicato.

In breve: il tuo programma non ha bisogno di un file system, ma il sistema operativo lo fa, tuttavia non è necessario alcun disco reale / fisico.

I computer precedenti (e alcuni moderni sistemi embedded) non hanno un filesystem. My Apple] [(e Commodore PET della scuola) aveva il sistema operativo in ROM ed era pronto a partire circa 2 secondi dopo un avvio a freddo. Vuoi caricare il software? Digitare la sorgente manualmente oppure digitare LOAD, premere Invio, quindi PLAY sul registratore. Quindi abbiamo ottenuto un'unità disco e ci sono state molte gioie.

Tuttavia, il vero nucleo di Linux presuppone che sia presente un filesystem e quasi tutto il resto si basa su questo. Se si desidera implementare un vero sistema operativo senza file system, è certamente possibile, ma l'hardware e il sistema operativo dovranno essere costruiti attorno al concetto.

Il metodo di Apple era di collegare il sistema operativo negli ultimi 16k di memoria, il processore (MC6502) era cablato per saltare alla posizione memorizzata in modo permanente negli ultimi 2 byte di memoria.

No, Linux non ha bisogno di avere un filesystem in senso molto stretto. Nel tuo caso hai un problema diverso.

"Nessun filesystem può montare root, provato: jffs2" "MTD: dispositivo MTD con nome" jffs2 "non trovato."

La mia ipotesi è parte del processo di caricamento o non sta trovando un / il posto da montare o non ha la possibilità di montare quel filesystem.