.\" -*- coding: UTF-8 -*-
.\" Copyright (c) 2016 Julia Computing Inc, Keno Fischer
.\" Description based on include/uapi/fuse.h and code in fs/fuse
.\"
.\" SPDX-License-Identifier: Linux-man-pages-copyleft
.\"
.\"*******************************************************************
.\"
.\" This file was generated with po4a. Translate the source file.
.\"
.\"*******************************************************************
.TH fuse 4 "2 mai 2024" "Pagini de manual de Linux 6.9.1" 
.SH NUME
fuse \- dispozitiv cu sistem de fișiere în spațiul utilizatorului
(„Filesystem in Userspace”: FUSE)
.SH SINOPSIS
.nf
\fB#include <linux/fuse.h>\fP
.fi
.SH DESCRIERE
Acest dispozitiv este interfața principală dintre controlorul sistemului de
fișiere FUSE și un proces din spațiul utilizatorului care dorește să
furnizeze sistemul de fișiere (denumit în restul acestei pagini de manual
\fIdemon de sistem de fișiere\fP). Această pagină de manual este destinată
celor interesați să înțeleagă interfața nucleului în sine. Cei care
implementează un sistem de fișiere FUSE pot dori să utilizeze o bibliotecă
din spațiul utilizatorului, cum ar fi \fIlibfuse\fP, care abstractizează
interfața de nivel scăzut.
.P
.\"
În esența sa, FUSE este un protocol client\-server simplu, în care nucleul
Linux este clientul, iar demonul este serverul. După obținerea unui
descriptor de fișier pentru acest dispozitiv, demonul poate \fBread\fP(2)
cereri de la acel descriptor de fișier și se așteaptă să \fBwrite\fP(2) înapoi
răspunsurile sale. Este important de reținut că un descriptor de fișier este
asociat cu un sistem de fișiere FUSE unic. În special, deschiderea unei a
doua copii a acestui dispozitiv, nu va permite accesul la resursele create
prin intermediul primului descriptor de fișier (și viceversa).
.SS "Protocolul de bază"
Fiecare mesaj citit de daemon începe cu un antet descris de următoarea
structură:
.P
.in +4n
.EX
struct fuse_in_header {
    uint32_t len;       /* Lungimea totală a datelor,
                           inclusiv acest antet */
    uint32_t opcode;    /* Tipul de operație (a se vedea mai jos) */
    uint64_t unique;    /* Un identificator unic pentru această cerere */
    uint64_t nodeid;    /* ID\-ul obiectului sistemului de fișiere
                           asupra căruia se operează */
    uint32_t uid;       /* UID\-ul procesului solicitant */
    uint32_t gid;       /* GID\-ul procesului solicitant */
    uint32_t pid;       /* PID\-ul procesului solicitant */
    uint32_t padding;
};
.EE
.in
.P
Antetul este urmat de o porțiune de date de lungime variabilă (care poate fi
goală) specifică operației solicitate (operația solicitată este indicată
prin \fIopcode\fP).
.P
Demonul ar trebui apoi să proceseze cererea și, dacă este cazul, să trimită
un răspuns (aproape toate operațiile necesită un răspuns; dacă nu, acest
lucru este documentat mai jos), prin efectuarea unui \fBwrite\fP(2) către
descriptorul de fișier. Toate răspunsurile trebuie să înceapă cu următorul
antet:
.P
.in +4n
.EX
struct fuse_out_header {
    uint32_t len;       /* Lungimea totală a datelor scrise
                           în descriptorul de fișier */
    int32_t  error;     /* Orice eroare apărută (0 dacă nu există) */
    uint64_t unique;    /* Valoarea din cererea
                           corespondentă */
};
.EE
.in
.P
.\"
Acest antet este urmat, de asemenea, de date de dimensiune variabilă
(potențial goale) în funcție de cererea executată. Cu toate acestea, dacă
răspunsul este un răspuns de eroare (și anume, \fIerror\fP este configurată),
atunci nu trebuie trimise alte date utile, independent de cerere.
.SS "Mesaje schimbate"
Această secțiune ar trebui să conțină documentația pentru fiecare dintre
mesajele din protocol. Această pagină de manual este în prezent incompletă,
astfel încât nu toate mesajele sunt documentate. Pentru fiecare mesaj, este
prezentată mai întâi structura trimisă de nucleu, urmată de o descriere a
semanticii mesajului.
.TP 
\fBFUSE_INIT\fP
.IP
.in +4n
.EX
struct fuse_init_in {
    uint32_t major;
    uint32_t minor;
    uint32_t max_readahead; /* Începând cu protocolul v7.6 */
    uint32_t flags;         /* Începând cu protocolul v7.6 */
};
.EE
.in
.IP
Aceasta este prima solicitare trimisă de nucleu către demon. Aceasta este
utilizată pentru a negocia versiunea protocolului și alți parametri ai
sistemului de fișiere. Rețineți că versiunea protocolului poate afecta
aspectul oricărei structuri din protocol (inclusiv această structură). Prin
urmare, demonul trebuie să memoreze versiunea și fanioanele negociate pentru
fiecare sesiune. La momentul redactării acestei pagini de manual, cea mai
mare versiune de protocol a nucleului acceptată este \fI7.26\fP.
.IP
Utilizatorii trebuie să fie conștienți de faptul că descrierile din această
pagină de manual pot fi incomplete sau incorecte pentru versiunile de
protocol mai vechi sau mai recente.
.IP
Răspunsul pentru această cerere are următorul format:
.IP
.in +4n
.EX
struct fuse_init_out {
    uint32_t major;
    uint32_t minor;
    uint32_t max_readahead;   /* Începând cu v7.6 */
    uint32_t flags;           /* Începând cu v7.6; unii biți de
                                 fanioane au fost introduși târziu */
    uint16_t max_background;  /* Începând cu v7.13 */
    uint16_t congestion_threshold;  /* Începând cu v7.13 */
    uint32_t max_write;       /* Începând cu v7.5 */
    uint32_t time_gran;       /* Începând cu v7.6 */
    uint32_t unused[9];
};
.EE
.in
.IP
În cazul în care versiunea majoră admisă de nucleu este mai mare decât cea
admisă de demon, răspunsul va consta doar din \fIuint32_t major\fP (după
antetul obișnuit), indicând cea mai mare versiune majoră admisă de
demon. Nucleul va emite apoi o nouă cerere \fBFUSE_INIT\fP conformă cu
versiunea mai veche. În cazul invers, demonul ar trebui să revină în liniște
la versiunea majoră a nucleului.
.IP
Versiunea minoră negociată este considerată a fi cea mai mică dintre
versiunile minore furnizate de demon și de nucleu și ambele părți trebuie să
utilizeze protocolul corespunzător versiunii minore respective.
.TP 
\fBFUSE_GETATTR\fP
.IP
.in +4n
.EX
struct fuse_getattr_in {
    uint32_t getattr_flags;
    uint32_t dummy;
    uint64_t fh;      /* Definit doar dacă
                         (getattr_flags & FUSE_GETATTR_FH)
};
.EE
.in
.IP
Operația solicitată constă în calcularea atributelor care urmează să fie
returnate de \fBstat\fP(2) și alte operații similare pentru obiectul sistemului
de fișiere dat. Obiectul pentru care ar trebui calculate atributele este
indicat fie prin \fIheader\->nodeid\fP, fie, în cazul în care fanionul
\fBFUSE_GETATTR_FH\fP este activat, prin gestionarul de fișier \fIfh\fP. Acest din
urmă caz de operare este analog cu \fBfstat\fP(2).
.IP
Din motive de performanță, aceste atribute pot fi stocate în memoria cache a
nucleului pentru o anumită perioadă de timp. Atât timp cât timpul de
așteptare în cache nu a fost depășit, atributele vor fi servite din cache și
nu vor cauza cereri suplimentare \fBFUSE_GETATTR\fP.
.IP
Atributele calculate și timpul de așteptare în cache solicitat ar trebui
apoi returnate în următoarea structură:
.IP
.in +4n
.EX
struct fuse_attr_out {
    /* Durata cache\-ului de atribute (secunde + nanosecunde) */
    uint64_t attr_valid;
    uint32_t attr_valid_nsec;
    uint32_t dummy;
    struct fuse_attr {
        uint64_t ino;
        uint64_t size;
        uint64_t blocks;
        uint64_t atime;
        uint64_t mtime;
        uint64_t ctime;
        uint32_t atimensec;
        uint32_t mtimensec;
        uint32_t ctimensec;
        uint32_t mode;
        uint32_t nlink;
        uint32_t uid;
        uint32_t gid;
        uint32_t rdev;
        uint32_t blksize;
        uint32_t padding;
    } attr;
};
.EE
.in
.TP 
\fBFUSE_ACCESS\fP
.IP
.in +4n
.EX
struct fuse_access_in {
    uint32_t mask;
    uint32_t padding;
};
.EE
.in
.IP
Dacă opțiunile de montare \fIdefault_permissions\fP nu sunt utilizate, această
cerere poate fi utilizată pentru verificarea permisiunilor. Nu se așteaptă
date de răspuns, dar erorile pot fi indicate ca de obicei prin definirea
câmpului \fIerror\fP din antetul răspunsului (în special, erorile de acces
refuzat pot fi indicate prin returnarea \fB\-EACCES\fP).
.TP 
\fBFUSE_OPEN\fP și \fBFUSE_OPENDIR\fP
.in +4n
.EX
struct fuse_open_in {
    uint32_t flags;     /* Fanioanele care au fost transmise
                           către open(2) */
    uint32_t unused;
};
.EE
.in
.IP
Operația solicitată este de a deschide nodul indicat de
\fIheader\->nodeid\fP. Semantica exactă a ceea ce înseamnă acest lucru va
depinde de sistemul de fișiere implementat  Cu toate acestea, cel puțin
sistemul de fișiere ar trebui să valideze că \fIfanioanele\fP solicitate sunt
valabile pentru resursa indicată și apoi să trimită un răspuns cu următorul
format:
.IP
.in +4n
.EX
struct fuse_open_out {
    uint64_t fh;
    uint32_t open_flags;
    uint32_t padding;
};
.EE
.in
.IP
Câmpul \fIfh\fP este un identificator opac pe care nucleul îl va utiliza pentru
a se referi la această resursă. Câmpul \fIopen_flags\fP este o mască de biți a
oricărui număr de fanioane care indică proprietățile acestui gestionar de
fișier pentru nucleu:
.RS 7
.TP  18
\fBFOPEN_DIRECT_IO\fP
Ocolește cache\-ul paginii pentru acest fișier deschis.
.TP 
\fBFOPEN_KEEP_CACHE\fP
Nu se invalidează memoria cache de date la deschidere.
.TP 
\fBFOPEN_NONSEEKABLE\fP
Fișierul nu poate fi explorat.
.RE
.TP 
\fBFUSE_READ\fP și \fBFUSE_READDIR\fP
.IP
.in +4n
.EX
struct fuse_read_in {
    uint64_t fh;
    uint64_t offset;
    uint32_t size;
    uint32_t read_flags;
    uint64_t lock_owner;
    uint32_t flags;
    uint32_t padding;
};
.EE
.in
.IP
Acțiunea solicitată este de a citi până la \fIsize\fP octeți din fișier sau
director, începând de la \fIoffset\fP. Octeții ar trebui să fie returnați
direct după antetul de răspuns obișnuit.
.TP 
\fBFUSE_INTERRUPT\fP
.in +4n
.EX
struct fuse_interrupt_in {
    uint64_t unique;
};
.EE
.in
.IP
Acțiunea solicitată este de a anula operația în așteptare indicată de
\fIunique\fP. Această cerere nu necesită răspuns. Cu toate acestea, primirea
acestui mesaj nu anulează de la sine operația indicată. Nucleul va aștepta
în continuare un răspuns la operația respectivă (de exemplu, o eroare
\fIEINTR\fP sau o citire scurtă). Pentru o operație dată va fi emisă cel mult o
cerere \fBFUSE_INTERRUPT\fP. După emiterea operației respective, nucleul va
aștepta neîntrerupt finalizarea cererii indicate.
.TP 
\fBFUSE_LOOKUP\fP
Imediat după antet urmează un nume de fișier care trebuie căutat în
directorul indicat de \fIheader\->nodeid\fP. Răspunsul așteptat este de
forma:
.IP
.in +4n
.EX
struct fuse_entry_out {
    uint64_t nodeid;            /* ID\-ul nodului\-i */
    uint64_t generation;        /* Generarea nodului\-i */
    uint64_t entry_valid;
    uint64_t attr_valid;
    uint32_t entry_valid_nsec;
    uint32_t attr_valid_nsec;
    struct fuse_attr attr;
};
.EE
.in
.IP
Combinația de \fInodeid\fP și \fIgeneration\fP trebuie să fie unică pe durata de
viață a sistemului de fișiere.
.IP
Interpretarea timpilor de așteptare și a \fIattr\fP este aceeași ca pentru
\fBFUSE_GETATTR\fP.
.TP 
\fBFUSE_FLUSH\fP
.in +4n
.EX
struct fuse_flush_in {
    uint64_t fh;
    uint32_t unused;
    uint32_t padding;
    uint64_t lock_owner;
};
.EE
.in
.IP
Acțiunea solicitată este de a șterge orice modificări în așteptare pentru
gestionarul fișierului indicat. Nu sunt așteptate date de răspuns. Cu toate
acestea, un mesaj de răspuns gol trebuie să fie emis după finalizarea
operației de golire.
.TP 
\fBFUSE_RELEASE\fP și \fBFUSE_RELEASEDIR\fP
.in +4n
.EX
struct fuse_release_in {
    uint64_t fh;
    uint32_t flags;
    uint32_t release_flags;
    uint64_t lock_owner;
};
.EE
.in
.IP
Acestea sunt inversul lui \fBFUSE_OPEN\fP și respectiv
\fBFUSE_OPENDIR\fP. Daemonul poate elibera acum orice resurse asociate cu
gestionarul fișierului \fIfh\fP, deoarece nucleul nu se va mai referi la
acesta. Nu există date de răspuns asociate cu această cerere, dar un răspuns
trebuie să fie emis după ce cererea a fost complet procesată.
.TP 
\fBFUSE_STATFS\fP
Această operație implementează \fBstatfs\fP(2) pentru acest sistem de
fișiere. Nu există date de intrare asociate cu această cerere. Datele de
răspuns așteptate au următoarea structură:
.IP
.in +4n
.EX
struct fuse_kstatfs {
    uint64_t blocks;
    uint64_t bfree;
    uint64_t bavail;
    uint64_t files;
    uint64_t ffree;
    uint32_t bsize;
    uint32_t namelen;
    uint32_t frsize;
    uint32_t padding;
    uint32_t spare[6];
};
\&
struct fuse_statfs_out {
    struct fuse_kstatfs st;
};
.EE
.in
.IP
Pentru interpretarea acestor câmpuri, a se vedea \fBstatfs\fP(2).
.SH ERORI\-IEȘIRE
.TP 
\fBE2BIG\fP
Returnată din operațiile \fBread\fP(2) atunci când solicitarea nucleului este
prea mare pentru memoria tampon furnizată și solicitarea a fost
\fBFUSE_SETXATTR\fP.
.TP 
\fBEINVAL\fP
Returnată de la \fBwrite\fP(2) dacă validarea răspunsului a eșuat. Nu toate
erorile din răspunsuri vor fi detectate de această validare. Cu toate
acestea, greșelile de bază, cum ar fi răspunsurile scurte sau o valoare
\fIunique\fP incorectă, sunt detectate.
.TP 
\fBEIO\fP
Returnată de operațiile \fBread\fP(2) atunci când solicitarea nucleului este
prea mare pentru memoria tampon furnizată.
.IP
\fINotă\fP: Există diverse moduri în care utilizarea incorectă a acestor
interfețe poate cauza eșecul operațiilor asupra fișierelor și directoarelor
din sistemul de fișiere furnizat cu \fBEIO\fP.  Printre posibilele utilizări
incorecte se numără:
.RS
.IP \[bu] 3
schimbarea \fImode & S_IFMT\fP pentru un nod\-i care a fost raportat anterior
către nucleu; sau
.IP \[bu]
furnizarea de răspunsuri către nucleu care sunt mai scurte decât cele
așteptate de acesta.
.RE
.TP 
\fBENODEV\fP
Returnată de \fBread\fP(2) și \fBwrite\fP(2) dacă sistemul de fișiere FUSE a fost
demontat.
.TP 
\fBEPERM\fP
Returnată în urma operațiilor pe un descriptor de fișier \fI/dev/fuse\fP care
nu a fost montat.
.SH STANDARDE
Linux.
.SH NOTE
Următoarele mesaje nu sunt încă documentate în această pagină de manual:
.P
.\" FIXME: Document the following.
.in +4n
.EX
\fBFUSE_BATCH_FORGET\fP
\fBFUSE_BMAP\fP
\fBFUSE_CREATE\fP
\fBFUSE_DESTROY\fP
\fBFUSE_FALLOCATE\fP
\fBFUSE_FORGET\fP
\fBFUSE_FSYNC\fP
\fBFUSE_FSYNCDIR\fP
\fBFUSE_GETLK\fP
\fBFUSE_GETXATTR\fP
\fBFUSE_IOCTL\fP
\fBFUSE_LINK\fP
\fBFUSE_LISTXATTR\fP
\fBFUSE_LSEEK\fP
\fBFUSE_MKDIR\fP
\fBFUSE_MKNOD\fP
\fBFUSE_NOTIFY_REPLY\fP
\fBFUSE_POLL\fP
\fBFUSE_READDIRPLUS\fP
\fBFUSE_READLINK\fP
\fBFUSE_REMOVEXATTR\fP
\fBFUSE_RENAME\fP
\fBFUSE_RENAME2\fP
\fBFUSE_RMDIR\fP
\fBFUSE_SETATTR\fP
\fBFUSE_SETLK\fP
\fBFUSE_SETLKW\fP
\fBFUSE_SYMLINK\fP
\fBFUSE_UNLINK\fP
\fBFUSE_WRITE\fP
.EE
.in
.SH "CONSULTAȚI ȘI"
\fBfusermount\fP(1), \fBmount.fuse\fP(8)
.PP
.SH TRADUCERE
Traducerea în limba română a acestui manual a fost făcută de
Remus-Gabriel Chelu <remusgabriel.chelu@disroot.org>
.
.PP
Această traducere este documentație gratuită; citiți
.UR https://www.gnu.org/licenses/gpl-3.0.html
Licența publică generală GNU Versiunea 3
.UE
sau o versiune ulterioară cu privire la condiții privind drepturile de autor.
NU se asumă NICIO RESPONSABILITATE.
.PP
Dacă găsiți erori în traducerea acestui manual,
vă rugăm să trimiteți un e-mail la
.MT translation-team-ro@lists.sourceforge.net
.ME .