Wat zijn bestandsdescriptors, uitgelegd in eenvoudige bewoordingen?

Antwoord 1, autoriteit 100%

In eenvoudige bewoordingen, wanneer u een bestand opent, maakt het besturingssysteem een item om dat bestand weer te geven en de informatie over dat geopende bestand op te slaan. Dus als er 100 bestanden zijn geopend in uw besturingssysteem, dan zijn er 100 vermeldingen in het besturingssysteem (ergens in de kernel). Deze items worden weergegeven door gehele getallen zoals (…100, 101, 102….). Dit invoernummer is de bestandsdescriptor.
Het is dus gewoon een geheel getal dat op unieke wijze een geopend bestand in het besturingssysteem vertegenwoordigt.
Als uw proces 10 bestanden opent, heeft uw procestabel 10 vermeldingen voor bestandsbeschrijvingen.

Op dezelfde manier als u een netwerksocket opent, wordt deze ook weergegeven door een geheel getal en wordt deze Socket Descriptor genoemd.
Ik hoop dat je het begrijpt.

Antwoord 2, autoriteit 22%

Een bestandsdescriptor is een ondoorzichtige handgreep die wordt gebruikt in de interface tussen gebruiker en kernelruimte om bestands-/socketbronnen te identificeren. Daarom, wanneer u open()of socket()gebruikt (systeemaanroepen voor interface naar de kernel), krijgt u een bestandsdescriptor, die een geheel getal is (het is eigenlijk een index in de processen u-structuur – maar dat is niet belangrijk). Daarom, als je rechtstreeks met de kernel wilt communiceren, gebruik dan systeemaanroepen naar read(), write(), close()etc. de handle die je gebruikt is een bestandsdescriptor.

Er is een abstractielaag over de systeemaanroepen heen gelegd, wat de stdio-interface is. Dit biedt meer functionaliteit/functies dan de basissysteemaanroepen. Voor deze interface is het ondoorzichtige handvat dat u krijgt een FILE*, die wordt geretourneerd door de fopen()-aanroep. Er zijn veel functies die gebruik maken van de stdiointerface fprintf(), fscanf(), fclose(), die er zijn om uw leven gemakkelijker te maken. In C zijn STDIN, STDOUTen STDERRFILE*, die in UNIX respectievelijk verwijzen naar bestandsdescriptors 0, 1en 2.

Antwoord 3, autoriteit 19%

Hoor het uit de paardenmond: APUE (Richard Stevens).
Naar de kernel wordt naar alle geopende bestanden verwezen door File Descriptors. Een bestandsdescriptor is een niet-negatief getal.

Als we een bestaand bestand openen of een nieuw bestand maken, stuurt de kernel een bestandsdescriptor terug naar het proces.De kernel houdt een tabel bij van alle open bestandsdescriptors die in gebruik zijn. De toewijzing van bestandsdescriptors is over het algemeen sequentieel en ze worden aan het bestand toegewezen als de volgende vrije bestandsdescriptor uit de pool van gratis bestandsdescriptors. Wanneer we het bestand sluiten, wordt de bestandsdescriptor vrijgegeven en is deze beschikbaar voor verdere toewijzing.
Zie deze afbeelding voor meer details:

Als we een bestand willen lezen of schrijven, identificeren we het bestand met de bestandsdescriptor die werd geretourneerd door de functieaanroep open()of create(), en gebruik het als argument voor read()of write().
Volgens afspraak associeert UNIX-systeemshells de bestandsdescriptor 0 met Standaardinvoervan een proces, bestandsdescriptor 1 met Standaarduitvoeren bestandsdescriptor 2 met Standaardfout.
Bestandsdescriptor varieert van 0 tot OPEN_MAX. De maximale waarde van de bestandsdescriptor kan worden verkregen met ulimit -n. Lees voor meer informatie het derde hoofdstuk van APUE Book.

Antwoord 4, autoriteit 9%

Andere antwoorden hebben geweldige dingen toegevoegd. Ik zal alleen mijn 2 cent toevoegen.

Volgens Wikipedia weten we het zeker: een bestandsdescriptor is een niet-negatief geheel getal. Het belangrijkste dat volgens mij ontbreekt, zou zijn om te zeggen:

Bestandsbeschrijvingen zijn gebonden aan een proces-ID.

We weten dat de meest bekende bestandsdescriptors 0, 1 en 2 zijn.
0 komt overeen met STDIN, 1 met STDOUTen 2 met STDERR.

Zeg, neem shell-processen als voorbeeld en hoe is het daarop van toepassing?

Bekijk deze code

#>sleep 1000 &
[12] 14726

We hebben een proces gemaakt met de id 14726 (PID).
Met behulp van de lsof -p 14726kunnen we de dingen als volgt krijgen:

COMMAND   PID USER   FD   TYPE DEVICE SIZE/OFF    NODE NAME
sleep   14726 root  cwd    DIR    8,1     4096 1201140 /home/x
sleep   14726 root  rtd    DIR    8,1     4096       2 /
sleep   14726 root  txt    REG    8,1    35000  786587 /bin/sleep
sleep   14726 root  mem    REG    8,1 11864720 1186503 /usr/lib/locale/locale-archive
sleep   14726 root  mem    REG    8,1  2030544  137184 /lib/x86_64-linux-gnu/libc-2.27.so
sleep   14726 root  mem    REG    8,1   170960  137156 /lib/x86_64-linux-gnu/ld-2.27.so
sleep   14726 root    0u   CHR  136,6      0t0       9 /dev/pts/6
sleep   14726 root    1u   CHR  136,6      0t0       9 /dev/pts/6
sleep   14726 root    2u   CHR  136,6      0t0       9 /dev/pts/6

De 4-TH Column FD en het zeer volgende kolomtype komen overeen met de bestandsdescriptor en het type bestandsdescriptor.

Enkele waarden voor de FD kunnen zijn:

cwd – Current Working Directory
txt – Text file
mem – Memory mapped file
mmap – Memory mapped device

Maar de echte bestandsdescriptor staat onder:

NUMBER – Represent the actual file descriptor. 

Het teken na het nummer I.E “1U”, vertegenwoordigt de modus waarin het bestand wordt geopend. r voor lezen, w voor schrijven, u voor lezen en schrijven.

Type Specificeert het type van het bestand. Sommige van de waarden van typen zijn:

REG – Regular File
DIR – Directory
FIFO – First In First Out

Maar alle bestandsdescriptoren zijn
Chr – Character Special File (of tekenapparaatbestand)

Nu, we kunnen de bestandsdescriptoren identificeren voor STDIN, STDOUTen STDERReenvoudig met lsof -p PID, of we kunnen hetzelfde zien als we ls /proc/PID/fd.

OPMERKING Ook dat de bestanden descriptor tabel die kernel bijhoudt, is niet hetzelfde als bestanden tabel of inodes tabel. Deze zijn gescheiden, zoals sommige andere antwoorden uitgelegd.

U kunt u afvragen of deze bestandsdescriptoren fysiek zijn en wat wordt opgeslagen in /dev/pts/6bijvoorbeeld

sleep   14726 root    0u   CHR  136,6      0t0       9 /dev/pts/6
sleep   14726 root    1u   CHR  136,6      0t0       9 /dev/pts/6
sleep   14726 root    2u   CHR  136,6      0t0       9 /dev/pts/6

Nou, /dev/pts/6leeft puur in het geheugen. Dit zijn geen gewone bestanden, maar zogenaamde character device-bestanden. Je kunt dit controleren met: ls -l /dev/pts/6en ze beginnen met c, in mijn geval crw--w----.

Om de meeste Linux-achtige besturingssystemen terug te roepen, definieer je zeven soorten bestanden:

• Gewone bestanden
• Mappen
• Apparaatbestanden van tekens
• Apparaatbestanden blokkeren
• Lokale domein-sockets
• Named pipes (FIFO’s) en
• Symbolische links

Antwoord 5, autoriteit 3%

Meer punten met betrekking tot File Descriptor:

1. File Descriptors(FD) zijn niet-negatieve gehele getallen (0, 1, 2, ...)die zijn gekoppeld aan bestanden die worden geopend.

2. 0, 1, 2zijn standaard FD‘s die overeenkomen met STDIN_FILENO, STDOUT_FILENOen STDERR_FILENO(gedefinieerd in unistd.h) standaard geopend namens shell wanneer het programma start.

3. FD’s worden toegewezen in de sequentiële volgorde, wat de laagst mogelijke niet-toegewezen gehele waarde betekent.

4. FD’s voor een bepaald proces zijn te vinden in /proc/$pid/fd(op Unix-gebaseerde systemen).

Antwoord 6, autoriteit 3%

Bestandsbeschrijvingen (FD):

• In Linux/Unixis alles een bestand. Regulier bestand, Directory’s,
  en zelfs Apparaten zijn bestanden. Elk bestand heeft een bijbehorend nummer genaamd File Descriptor (FD).
• Uw scherm heeft ook een bestandsdescriptor. Wanneer een programma wordt uitgevoerd
  de uitvoer wordt naar de File Descriptor van het scherm gestuurd en je ziet:
  programma-uitvoer op uw monitor. Als de uitvoer naar Bestand wordt verzonden
  Descriptor van de printer, de programma-uitvoer zou zijn geweest:
  gedrukt.

  Foutomleiding:
  
  Telkens wanneer u een programma/opdracht uitvoert op de terminal, zijn er altijd 3 bestanden open

  1. standaard invoer
  2. standaard uitvoer
  3. standaardfout.

  Deze bestanden zijn altijd aanwezig wanneer een programma wordt uitgevoerd. Zoals eerder uitgelegd, is een bestandsdescriptor gekoppeld aan elk van
  deze bestanden.
  Bestand                    ;               Bestandsbeschrijving
  Standaardinvoer STDIN              0
  Standaarduitgang STDOUT       1
  Standaardfout STDERR          2

• Bij het zoeken naar bestanden, bijvoorbeeld,
  krijgt meestal toestemming geweigerde fouten of een ander soort fouten. Deze fouten kunnen in een bepaald bestand worden opgeslagen.
  Voorbeeld 1

$ ls mijndir 2>errorsfile.txt

De bestandsdescriptor voor standaardfout is 2.
Als er geen map met de naam mydir is, wordt de uitvoer van de opdracht opgeslagen in het bestand errorfile.txt
“2>” gebruiken we sturen de foutuitvoer om naar een bestand met de naam “errorfile.txt”
De programma-uitvoer is dus niet vol met fouten.

Ik hoop dat je je antwoord hebt gekregen.

Antwoord 7, autoriteit 3%

Als aanvulling op andere antwoorden beschouwt Unix alles als een bestandssysteem. Je toetsenbord is een bestand dat alleen kan worden gelezen vanuit het perspectief van de kernel. Het scherm is een alleen-schrijven bestand. Evenzo worden mappen, invoer-uitvoerapparaten enz. ook als bestanden beschouwd. Telkens wanneer een bestand wordt geopend, bijvoorbeeld wanneer de apparaatstuurprogramma’s [voor apparaatbestanden] een open() verzoekt, of een proces een gebruikersbestand opent, wijst de kernel een bestandsdescriptor toe, een geheel getal dat de toegang tot dat bestand specificeert zodat het alleen-lezen is , alleen schrijven etc. [ter referentie: https://en.wikipedia.org/wiki/Everything_is_a_file]

Antwoord 8, autoriteit 2%

Bestandsbeschrijvingen

• Naar Kernel wordt naar alle geopende bestanden verwezen met bestandsdescriptors.
• Een bestandsdescriptor is een niet – negatief geheel getal.
• Als we een bestaand bestand openen of een nieuw bestand maken, retourneert de kernel een bestandsdescriptor naar een proces.
• Als we een bestand willen lezen of schrijven, identificeren we het bestand met de bestandsdescriptor die opnieuw is afgestemd door openen of maken, als een argument om te lezen of te schrijven.
• Elk UNIX-proces heeft 20 bestandsdescriptors en kan worden verwijderd, genummerd van 0 tot en met 19 maar
  het werd door veel systemen uitgebreid tot 63.
• De eerste drie zijn al geopend wanneer het proces begint
  0: De standaard invoer
  1: De standaarduitvoer:
  2: De standaardfoutuitvoer:
• Als het bovenliggende proces een proces splitst, erft het onderliggende proces de bestandsbeschrijvingen van het bovenliggende proces

Antwoord 9

Elk besturingssysteem heeft processen (p’s) die draaien, zeg p1, p2, p3enzovoort. Elk proces maakt gewoonlijk voortdurend gebruik van bestanden.

Elk proces bestaat uit een procesboom (of een procestabel, in een andere formulering).

Meestal vertegenwoordigen de besturingssystemen elk bestand in elk proces door een nummer (dat wil zeggen, in elke processtructuur / tafel).

Het eerste bestand dat in het proces wordt gebruikt, is Bestand0 , de tweede is Bestand1 , derde is FILE2 , enzovoort.

een dergelijk nummer is een bestandsdescriptor.

Bestandsdescriptoren zijn meestal gehele getallen (0, 1, 2 en niet 0,5, 1,5, 2.5).

Gegeven, beschrijven we vaak processen als “process-tafels” en aangezien tabellen rijen (vermeldingen) hebben, kunnen we zeggen dat de bestandscriptorcel in elk item wordt gebruikt om het hele item te vertegenwoordigen.

Op een vergelijkbare manier, wanneer u een netwerkcontact opent, heeft deze een socket-descriptor.

In sommige besturingssystemen kunt u geen bestandsdescriptoren oplopen, maar een dergelijk geval is uiterst zeldzaam en de gemiddelde computergebruiker moet daar geen zorgen van maken.

Bestandsdescriptoren kunnen wereldwijd zijn (proces A begint in Say 0 en eindigt in 1; Process B begint in 2 en eindigt in 3) enzovoort, maar voor zover ik weet, meestal in moderne werking Systemen, bestandsdescriptoren zijn niet globaal en zijn eigenlijk processpecifiek (proces A begint in zeg 0 en eindigt in 5, terwijl het proces B begint in 0 en eindigt in 10).

Antwoord 10

Bestandsdescriptoren zijn niets anders dan referenties voor elke open hulpbron. Zodra u een resource opent, gaat de kernel ervan uit dat u er enkele bewerkingen op gaat. Alle communicatie via uw programma en de resource gebeurt over een interface en deze interface wordt geleverd door de bestandscriptor.

Aangezien een proces meer dan één resource kan openen, is het mogelijk dat een resource meer dan één bestandsdescriptoren heeft.
U kunt alle bestandsdescriptoren bekijken die verband houden met het proces door eenvoudig te draaien,
ls -li /proc/<pid>/fd/Hier PID is de process-ID van uw proces

Antwoord 11

aanvulling op bovenal vereenvoudigde reacties.

Als u met bestanden in Bash-script werkt, is het beter om de bestandsdescriptor te gebruiken.

Bijvoorbeeld:
Als u wilt lezen en schrijven / schrijven / naar het bestand “Test.txt”, gebruikt u de Bestandsdescriptor als hieronder tonen:

FILE=$1 # give the name of file in the command line
exec 5<>$FILE # '5' here act as the file descriptor
# Reading from the file line by line using file descriptor
while read LINE; do
    echo "$LINE"
done <&5
# Writing to the file using descriptor
echo "Adding the date: `date`" >&5 
exec 5<&- # Closing a file descriptor

Antwoord 12

Bestandsdescriptoren zijn de descriptors naar een bestand. Ze geven links naar een bestand. Met de hulp van hen kunnen we een bestand lezen, schrijven en openen.