Provided by: manpages-it-dev_4.23.1-1_all bug

NOME

       mount - monta i filesystem

LIBRERIA

       Libreria C standard (libc, -lc)

SINTASSI

       #include <sys/mount.h>

       int mount(const char *source, const char *target,
                 const char *filesystemtype, unsigned long mountflags,
                 const void *_Nullable data);

DESCRIZIONE

       mount()  collega il filesystem specificato da source (che è spesso un nome di percorso che
       individua un dispositivo, ma può anche essere il nome di percorso di una directory o di un
       file,  o  una  stringa  fittizia) alla posizione (una directory o un file) specificata dal
       nome di percorso in target.

       Per montare dei filesystem è  necessario  avere  le  autorizzazioni  adeguate  (Linux:  la
       funzionalità CAP_SYS_ADMIN).

       I   valori   dell'argomento   filesystemtype   supportati  dal  kernel  sono  elencati  in
       /proc/filesystems (p.es, "btrfs", "ext4", "jfs", "xfs", "vfat", "fuse", "tmpfs", "cgroup",
       "proc",  "mqueue",  "nfs", "cifs", "iso9660"). Ulteriori tipi di filesystem possono essere
       resi disponibili se sono stati caricati i moduli appropriati.

       L'argomento data è interpretato dai differenti filesystem. Tipicamente è  una  stringa  di
       opzioni,  separate  da virgole, riconosciute da un determinato filesystem. Vedere mount(8)
       per dettagli sulle opzioni disponibili per ciascun tipo di  filesystem.  Questo  argomento
       può essere specificato come NULL, se non ci sono opzioni.

       Una  chiamata a mount() esegue una tra le molte operazioni di tipo generale, basandosi sui
       bit specificati in  mountflags.  La  scelta  dell'operazione  da  eseguire  è  determinata
       controllando i bit impostati in mountflags, effettuando dei test nell'ordine qui elencato:

       •  Rimontare un montaggio già in essere: mountflags include MS_REMOUNT.

       •  Creare un montaggio di tipo bind: mountflags include MS_BIND.

       •  Cambiare  il tipo di propagazione di un montaggio esistente: mountflags include uno tra
          MS_SHARED, MS_PRIVATE, MS_SLAVE o MS_UNBINDABLE.

       •  Spostare un montaggio esistente in una nuova posizione: mountflags include MS_MOVE.

       •  Creare un nuovo montaggio: mountflags non include nessuno dei flag di cui sopra.

       Ciascuna di queste operazioni è descritta nel  dettaglio  più  avanti  in  questa  pagina.
       Ulteriori flag possono essere specificati in mountflags per modificare il comportamento di
       mount(), come'è descritto qua sotto.

   Ulteriori flag per il montaggio
       L'elenco seguente descrive i flag aggiuntivi che possono venir specificati in  mountflags.
       Si  noti che alcuni tipi di operazione ignorano alcuni o tutti questi flag, come descritto
       più avanti in questa pagina.

       MS_DIRSYNC (a partire da Linux 2.5.19)
              Sincronizza le modifiche di directory in questo  filesystem.  (Questa  funzionalità
              può essere richiesta per singole directory o per sottoalberi usando chattr(1).)

       MS_LAZYTIME (a partire da Linux 4.0)
              Riduce  gli  aggiornamenti  su  disco  delle marcature temporali dell'inode (atime,
              mtime,  ctime)  effettuando  questi  cambiamenti  solo  in  memoria.  Le  marcature
              temporali su disco vengono aggiornato solo quando:

              •  l'inode  necessita  di  un  aggiornamento per delle modifiche non correlate alle
                 marcature temporali del file;

              •  l'applicazione si serve di fsync(2), syncfs(2) o sync(2);

              •  un inode ancora esistente è estromesso dalla memoria; o

              •  son passate più di 24 ore da quando l'inode è stato scritto su disco.

              Quest'opzione di  mount  riduce  significativamente  le  scritture  necessarie  per
              aggiornare   le   marcature  temporali  dell'inode,  specialmente  mtime  e  atime.
              Comunque, nell'eventualità di un crash di sistema, i campi atime e mtime  su  disco
              potrebbero non contenere gli aggiornamenti già effettuati, fino a un massimo 24 ore
              prima del crash.

              Come esempi di situazioni in cui quest'opzione potrebbe essere di notevole  utilità
              si può citare il caso di frequenti scritture casuali su file preallocati, e anche i
              casi in cui anche l'opzione di mount MS_STRICTATIME è abilitata. (Il  vantaggio  di
              combinare  MS_STRICTATIME e MS_LAZYTIME è che stat(2) restituirà il valore di atime
              correttamente aggiornato, ma gli aggiornamenti  di  atime  verranno  trasferiti  su
              disco solo nei casi sopra elencati.)

       MS_MANDLOCK
              Permit  mandatory  locking  on  files  in this filesystem.  (Mandatory locking must
              still be enabled on a per-file basis, as described in fcntl(2).)  Since Linux  4.5,
              this  mount  option  requires  the CAP_SYS_ADMIN capability and a kernel configured
              with the CONFIG_MANDATORY_FILE_LOCKING option.  Mandatory locking  has  been  fully
              deprecated in Linux 5.15, so this flag should be considered deprecated.

       MS_NOATIME
              Non aggiorna l'ora di accesso per (tutti i tipi di) file su questo filesystem.

       MS_NODEV
              Non permette l'accesso a dispositivi (file speciali) in questo filesystem.

       MS_NODIRATIME
              Non  aggiorna  l'ora  di  accesso  per  directory su questo filesystem. Questo flag
              fornisce un sottoinsieme di funzioni messe a disposizione  da  MS_NOATIME;  vale  a
              dire che MS_NOATIME implica MS_NODIRATIME.

       MS_NOEXEC
              Non permette l'esecuzione di programmi su questo filesystem.

       MS_NOSUID
              Do  not honor set-user-ID and set-group-ID bits or file capabilities when executing
              programs from this filesystem.  In addition, SELinux domain transitions require the
              permission  nosuid_transition,  which  in  turn  needs  also  the policy capability
              nnp_nosuid_transition.

       MS_RDONLY
              Monta il filesystem in sola lettura.

       MS_REC (a partire da Linux 2.4.11)
              Usata insieme a MS_BIND per creare un montaggio "bind" ricorsivo, e assieme ai flag
              per  il tipo di condivisione per cambiare ricorsivamente il tipo di condivisione di
              tutti i montaggi in un sottoalbero. Vedere più avanti per ulteriori dettagli.

       MS_RELATIME (a partire da Linux 2.6.20)
              Quando si accede a un file in questo filesystem, aggiorna l'ora dell'ultimo accesso
              al  file  (atime)  solo  se  il  valore attuale di atime è minore o uguale a quello
              dell'ultima modifica del file (mtime) o all'ora dell'ultimo  cambiamento  di  stato
              (ctime).  Quest'opzione  è  utile  per programmi come mutt(1), che hanno bisogno di
              sapere quando un file è stato letto dopo l'ultima  modifica.  A  partire  da  Linux
              2.6.30, il kernel rende predefinito il comportamento fornito da questo flag (a meno
              che non sia stata specificato MS_NOATIME), e il flag MS_STRICTATIME è richiesto per
              ottenere  il  comportamento  tradizionale.  Inoltre,  a partire da Linux 2.6.30, il
              tempo dell'ultimo accesso al file viene sempre aggiornato se  risale  a  più  di  1
              giorno prima.

       MS_SILENT (a partire da Linux 2.6.17)
              Sopprime  la  visualizzazione  di  alcuni messaggi di avvertimento (printk()) nelle
              registrazioni del kernel.Questo flag sostituisce  il  flag  (disponibile  da  Linux
              2.4.12) MS_VERBOSE, che ha lo stesso significato.

       MS_STRICTATIME (a partire da Linux 2.6.30)
              L'ultimo  tempo  di  accesso  è  sempre  aggiornato (atime) quando i file su questo
              filesystem sono acceduti. (Questo era il comportamento predefinito prima  di  Linux
              2.6.30.) Specificando questo flag l'effetto dell'impostazione dei flag MS_NOATIME e
              MS_RELATIME viene ignorato.

       MS_SYNCHRONOUS
              Rende sincrone le scritture su questo filesystem (come se il flag O_SYNC di open(2)
              fosse specificata per tutti i file aperti in questo filesystem).

       MS_NOSYMFOLLOW (a partire da Linux 5.10)
              Non  segue  i collegamenti simbolici nella risoluzione dei percorsi. I collegamenti
              simbolici possono essere sempre creati, e readlink(1), readlink(2),  realpath(1)  e
              realpath(3)  continueranno a funzionare in modo appropriato.

       Da  Linux  2.4  in  poi,  alcuni  dei  flag visti sopra sono impostabili a livello di ogni
       singolo montaggio, mentre altri si applicano al superblocco del filesystem montato, il che
       vuol   dire   che  tutti  i  montaggi  dello  stesso  filesystem  condividono  tali  flag.
       (Precedentemente, tutti i flag erano a livello di superblocco.)

       I flag per singolo punto di montaggio sono i seguenti:

       •  Da Linux 2.4: MS_NODEV, MS_NOEXEC e MS_NOSUID possono essere  impostati  a  livello  di
          ogni singolo punto di montaggio.

       •  Inoltre, dal kernel 2.6.16: MS_NOATIME e MS_NODIRATIME.

       •  Inoltre, da Linux 2.6.20: MS_RELATIME.

       The  following  flags are per-superblock: MS_DIRSYNC, MS_LAZYTIME, MS_MANDLOCK, MS_SILENT,
       and MS_SYNCHRONOUS.  The initial settings of these flags are determined on the first mount
       of  the  filesystem,  and  will be shared by all subsequent mounts of the same filesystem.
       Subsequently, the settings of the flags can  be  changed  via  a  remount  operation  (see
       below).  Such changes will be visible via all mounts associated with the filesystem.

       Da Linux 2.6.16 MS_RDONLY può essere impostato o annullato a livello di ogni singolo punto
       di montaggio, nonché a livello del superblocco del filesystem sottostante.  Il  filesystem
       montato  sarà  scrivibile  solo  se né il filesystem né il punto di montaggio sono marcati
       come di sola lettura.

   Rimontare un montaggio esistente
       Un montaggio esistente può essere montato di nuovo specificando MS_REMOUNT in  mountflags.
       Questo  permette di cambiare mountflags e i dati di un montaggio già in essere senza dover
       smontare e rimontare il filesystem. target deve avere gli stessi valori specificati  nella
       chiamata mount() iniziale.

       Gli argomenti source e filesystemtype sono ignorati.

       Gli  argomenti mountflags e data dovrebbero corrispondere ai valori nella chiamata mount()
       originale, ad eccezione dei parametri che si desidera modificare.

       The following mountflags can be changed: MS_LAZYTIME, MS_MANDLOCK,  MS_NOATIME,  MS_NODEV,
       MS_NODIRATIME,  MS_NOEXEC, MS_NOSUID, MS_RELATIME, MS_RDONLY, MS_STRICTATIME (whose effect
       is to clear the MS_NOATIME and MS_RELATIME flags), and MS_SYNCHRONOUS.  Attempts to change
       the  setting  of the MS_DIRSYNC and MS_SILENT flags during a remount are silently ignored.
       Note that changes to per-superblock flags are visible via all  mounts  of  the  associated
       filesystem (because the per-superblock flags are shared by all mounts).

       A  partire  da   Linux  3.17,  se  nessuno  tra MS_NOATIME, MS_NODIRATIME, MS_RELATIME, or
       MS_STRICTATIME viene specificato in mountflags, l'operazione  di  rimontaggio  preserva  i
       valori   esistenti  di  questi  flag  (piuttosto  che  impostarli  al  valore  predefinito
       MS_RELATIME).

       Since Linux 2.6.26, the MS_REMOUNT flag can be  used  with  MS_BIND  to  modify  only  the
       per-mount-point   flags.   This  is  particularly  useful  for  setting  or  clearing  the
       "read-only" flag on a  mount  without  changing  the  underlying  filesystem.   Specifying
       mountflags as:

           MS_REMOUNT | MS_BIND | MS_RDONLY

       will make access through this mountpoint read-only, without affecting other mounts.

   Creare un montaggio di tipo bind
       Se  mountflags  comprende  MS_BIND  (disponibile  da  Linux  2.4 in poi) viene eseguito un
       montaggio di tipo bind. Un montaggio di tipo bind  rende  un  file  o  un  sottoalbero  di
       directory  visibile  a  un  altro  punto  all'interno dell'unica gerarchia di directory. I
       montaggi di  tipo  bind  possono  attraversare  i  filesystem  e  oltrepassare  le  gabbie
       chroot(2).

       Gli argomenti filesystemtype e data sono ignorati.

       The  remaining  bits  (other  than MS_REC, described below) in the mountflags argument are
       also ignored.  (The bind mount has the  same  mount  options  as  the  underlying  mount.)
       However,  see  the discussion of remounting above, for a method of making an existing bind
       mount read-only.

       In modo predefinito, quando una directory è montata con un montaggio di tipo  bind,  viene
       montata  solo quella particolare directory; se ci sono dei sottomontaggi nell'albero della
       directory, questi non sono montati nel montaggio di tipo bind. Se viene specificato  anche
       il  flag MS_REC, viene effettuata un'operazione di montaggio di tipo bind ricorsiva: tutti
       i sottomontaggi nel sottoalbero source (tranne i montaggi non  condivisibile  (unbindable)
       con un'operazione di bind) sono anche montati con un montaggio di tipo bind alla posizione
       corrispondente nel sottoalbero target.

   Cambiare il tipo di condivisione di un montaggio esistente
       Se mountflags include uno tra  MS_SHARED,  MS_PRIVATE,  MS_SLAVE  o  MS_UNBINDABLE  (tutti
       disponibili  a partire da Linux 2.6.15), il tipo di condivisione di un montaggio esistente
       viene cambiato. Se si specifica più d'uno di questi flag, viene prodotto un errore.

       I soli altri flag che possono essere specificati nel cambiare il tipo di condivisione sono
       MS_REC (descritto sotto) e MS_SILENT (che viene ignorato).

       Gli argomenti source, filesystemtype e data sono ignorati.

       I tipi di condivisione richiesti dai flag hanno il seguente significato:

       MS_SHARED
              Make this mount shared.  Mount and unmount events immediately under this mount will
              propagate to the other  mounts  that  are  members  of  this  mount's  peer  group.
              Propagation  here  means  that  the  same mount or unmount will automatically occur
              under all of the other mounts in the peer group.   Conversely,  mount  and  unmount
              events that take place under peer mounts will propagate to this mount.

       MS_PRIVATE
              Make  this mount private.  Mount and unmount events do not propagate into or out of
              this mount.

       MS_SLAVE
              If this is a shared mount that is a member of a  peer  group  that  contains  other
              members,  convert  it to a slave mount.  If this is a shared mount that is a member
              of a peer group that contains no other members, convert  it  to  a  private  mount.
              Otherwise, the propagation type of the mount is left unchanged.

              When  a  mount  is a slave, mount and unmount events propagate into this mount from
              the (master) shared peer group of which  it  was  formerly  a  member.   Mount  and
              unmount events under this mount do not propagate to any peer.

              A mount can be the slave of another peer group while at the same time sharing mount
              and unmount events with a peer group of which it is a member.

       MS_UNBINDABLE
              Rende questo montaggio non condivisibile unbindaable) con un'operazione di bind.  È
              come un montaggio privato (private mount), e in più questo montaggio non può essere
              montato con un montaggio di tipo bind. Quando un montaggio di tipo  bind  ricorsivo
              (mount()  con i flag MS_BIND e MS_REC) è effettuato su un sottoalbero di directory,
              qualsiasi montaggio  non  condivisibile  (unbindable)  con  un'operazione  di  bind
              all'interno del sottoalbero è automaticamente smontato (cioè, non replicato) quando
              si replica questo sottoalbero per produrre il sottoalbero di destinazione.

       By default, changing the propagation type affects only the target mount.   If  the  MS_REC
       flag is also specified in mountflags, then the propagation type of all mounts under target
       is also changed.

       Per ulteriori dettagli sui tipi  di  condivisione  del  montaggio  (compreso  il  tipo  di
       condivisione predefinito assegnato ai nuovi montaggi, si veda mount_namespaces(7).

   Spostare un montaggio
       If  mountflags  contains  the  flag  MS_MOVE  (available  since Linux 2.4.18), then move a
       subtree: source specifies an existing mount and target specifies the new location to which
       that mount is to be relocated.  The move is atomic: at no point is the subtree unmounted.

       I rimanenti bit nell'argomento mountflags vengono ignorati, poiché essi sono gli argomenti
       di filesystemtype e data.

   Creating a new mount
       If none of MS_REMOUNT, MS_BIND, MS_MOVE, MS_SHARED, MS_PRIVATE, MS_SLAVE, or MS_UNBINDABLE
       is  specified  in  mountflags,  then  mount()  performs its default action: creating a new
       mount.  source specifies the source for the new mount, and target specifies the  directory
       at which to create the mount point.

       Vengono  impiegati  gli  argomenti  filesystemtype  e data, e ulteriori bit possono essere
       specificati in mountflags per modificare il comportamento della chiamata.

VALORE RESTITUITO

       In caso di successo restituisce zero. In caso di errore  restituisce  -1,  e  errno  verrà
       impostato  per indicare l'errore.

ERRORI

       I  valori  di  errore  indicati di seguito sono causati da errori indipendenti dal tipo di
       filesystem. Ciascun tipo di filesystem può  avere  i  propri  errori  speciali  e  il  suo
       comportamento speciale. Vedere il codice sorgente del kernel per dettagli.

       EACCES Un   componente   di   un  percorso  non  poteva  essere  acceduto.  (Vedere  anche
              path_resolution(7).)

       EACCES È stato tentato il montaggio di un filesystem in sola lettura senza  dare  il  flag
              MS_RDONLY.

              Il filesystem può essere di sola lettura per diverse ragioni, tra le quali: risiede
              in un disco ottico di sola lettura;risiede su un  dispositivo  con  un  interrutore
              fisico  che  è  stato impostato per marcare il dispositivo come di sola lettura; il
              filesystem in questione è stato creato per supportare la sola lettura; oppure  sono
              stati  riscontrati errori durante montaggio iniziale del filesystem, per cui esso è
              stato marcato come di sola lettura e non può essere rimontato in  lettura-scrittura
              (fino a quando gli errori non siano stati corretti).

              Alcuni  filesystem  restituiscono l'errore EROFS su un tentativo di montaggio di un
              filesystem di sola lettura.

       EACCES Il dispositivo a blocchi source si trova su un  filesystem  montato  con  l'opzione
              MS_NODEV.

       EBUSY  È  stato  fatto un tentativo per sistemare un nuovo punto di montaggio in cima a un
              punto di montaggio  esistente  che  era  stato  creato  in  questo  "namespace"  di
              montaggio con lo stesso source e target.

       EBUSY  source non può essere rimontato in sola lettura, perché contiene ancora file aperti
              in scrittura.

       EFAULT Uno dei puntatori  agli  argomenti  punta  fuori  dallo  spazio  di  indirizzamento
              dell'utente.

       EINVAL source ha un superblocco non valido.

       EINVAL È stato tentata un'operazione di rimontaggio (MS_REMOUNT), ma source non era ancora
              stato montato su target.

       EINVAL A move operation (MS_MOVE)  was attempted, but the mount tree under source includes
              unbindable mounts and target is a mount that has propagation type MS_SHARED.

       EINVAL È  stata  tentata  un'operazione  di  spostamento  (MS_MOVE),  ma  il montaggio del
              filesystem genitore  source  di  questo  montaggio  ha  una  propagazione  di  tipo
              MS_SHARED.

       EINVAL A move operation (MS_MOVE)  was attempted, but source was not a mount, or was '/'.

       EINVAL A  bind  operation (MS_BIND)  was requested where source referred a mount namespace
              magic link (i.e., a /proc/pid/ns/mnt magic link or a bind mount  to  such  a  link)
              and  the  propagation  type  of  the  parent  mount  of  target  was MS_SHARED, but
              propagation of the requested bind mount could lead to a  circular  dependency  that
              might prevent the mount namespace from ever being freed.

       EINVAL mountflags  include  più  d'uno  di  questi flag: MS_SHARED, MS_PRIVATE, MS_SLAVE o
              MS_UNBINDABLE.

       EINVAL mountflags include MS_SHARED, MS_PRIVATE, MS_SLAVE o MS_UNBINDABLE e include  anche
              un flag diverso da MS_REC o MS_SILENT.

       EINVAL Si  è  tentato  di  montare in modalità bind un montaggio non montabile in modalità
              bind (unbindable mount).

       EINVAL In uno spazio dei nomi di montaggio senza privilegi (i.e., uno spazio dei  nomi  di
              montaggio  di  proprietà  di  uno spazio dei nomi utente che era stato creato da un
              utente senza privilegi), è stata tentata un'operazione di montaggio  di  tipo  bind
              (MS_BIND) senza specificare (MS_REC), che avrebbe rivelato la posizione dell'albero
              del filesystem sotto uno dei submontaggi della directory da collegare.

       ELOOP  Troppi collegamenti incontrati durante la risoluzione di un percorso.

       ELOOP  È stato tentato uno spostamento, mentre target è discendente (è un sottoalbero)  di
              source.

       EMFILE (Nel  caso non sia necessario un dispositivo a blocchi:) La tabella dei dispositivi
              fittizi è piena.

       ENAMETOOLONG
              Un nome di percorso è più lungo di MAXPATHLEN.

       ENODEV filesystemtype non configurato nel kernel.

       ENOENT Un nome di percorso era vuoto o aveva un componente inesistente.

       ENOMEM Il kernel non può allocare una pagina libera in cui copiare nomi di file o dati.

       ENOTBLK
              source non è un dispositivo a blocchi (ed era necessario un dispositivo  di  questo
              tipo).

       ENOTDIR
              target, o un prefisso di source, non è una directory.

       ENXIO  Il "numero principale" del dispositivo a blocchi source è fuori limite.

       EPERM  Il chiamante non ha i privilegi necessari.

       EPERM  An  attempt was made to modify (MS_REMOUNT)  the MS_RDONLY, MS_NOSUID, or MS_NOEXEC
              flag, or one of the "atime" flags (MS_NOATIME, MS_NODIRATIME, MS_RELATIME)   of  an
              existing mount, but the mount is locked; see mount_namespaces(7).

       EROFS  Si  è  tentato  di  montare un filesystem di sola lettura senza specificare il flag
              MS_RDONLY. Si veda EACCES, sopra.

CONFORME A

       Linux.

STORIA

       The definitions  of  MS_DIRSYNC,  MS_MOVE,  MS_PRIVATE,  MS_REC,  MS_RELATIME,  MS_SHARED,
       MS_SLAVE, MS_STRICTATIME, and MS_UNBINDABLE were added to glibc headers in glibc 2.12.

       A  partire  da  Linux  2.4  un singolo filesystem può essere montato su punti di montaggio
       multipli, e su uno stesso punto di montaggio possono essere impilati più montaggi.

       The mountflags argument may have the magic number 0xC0ED (MS_MGC_VAL) in the top 16  bits.
       (All  of  the  other  flags  discussed  in  DESCRIPTION  occupy  the  low order 16 bits of
       mountflags.)  Specifying MS_MGC_VAL was required before Linux 2.4, but since Linux 2.4  is
       no longer required and is ignored if specified.

       Il  flag  originale  MS_SYNC  è  stato  rinominato MS_SYNCHRONOUS in 1.1.69 quando è stato
       aggiunto un diverso MS_SYNC a <mman.h>.

       Prima di Linux  2.4,  un  tentativo  di  eseguire  un  programma  che  usa  set-user-ID  o
       set-group-ID  su un filesystem montato con MS_NOSUID falliva con EPERM. A partire da Linux
       2.4 la richiesta di set-user-ID e set-group-ID in questo caso è  ignorata  senza  emettere
       messaggi.

NOTE

   Spazi dei nomi di montaggio
       Starting with Linux 2.4.19, Linux provides mount namespaces.  A mount namespace is the set
       of filesystem mounts that are visible to a process.  Mount namespaces can be (and  usually
       are)   shared  between  multiple processes, and changes to the namespace (i.e., mounts and
       unmounts) by one process are visible to all other processes sharing  the  same  namespace.
       (The  pre-2.4.19  Linux situation can be considered as one in which a single namespace was
       shared by every process on the system.)

       Un processo figlio creato da fork(2) condivide lo spazio dei nomi  di  montaggio  del  suo
       genitore: lo spazio dei nomi di montaggio viene preservato se si invoca execve(2).

       Un  processo  può  ottenere  uno  spazio  dei nomi di montaggio privato se: è stato creato
       usando il flag CLONE_NEWNS di clone(), e in questo caso il suo nuovo spazio dei nomi viene
       inizializzato come copia degli spazi dei nomi del processo che ha chiamato clone(); oppure
       se chiama unshare(2) con il flag CLONE_NEWNS,  che  permette  allo  spazio  dei  nomi  del
       chiamante  di  ottenere  una  copia  privata  dello  spazio  dei  nomi  che  in precedenza
       condivideva con altri processi, in modo che chiamate a montaggi e smontaggi  futuri  siano
       invisibili  agli altri processi (ad eccezione di processi figli creati successivamente dal
       chiamante), e viceversa.

       Per ulteriori dettagli sugli spazi dei nomi dei montaggi si veda: mount_namespaces(7).

   Parental relationship between mounts
       Each mount has a parent mount.  The overall parental relationship of  all  mounts  defines
       the single directory hierarchy seen by the processes within a mount namespace.

       The  parent  of  a new mount is defined when the mount is created.  In the usual case, the
       parent of a new mount is the mount of the filesystem containing the directory or  file  at
       which  the  new  mount is attached.  In the case where a new mount is stacked on top of an
       existing mount, the parent of the new mount is the previous mount that was stacked at that
       location.

       The  parental  relationship  between  mounts can be discovered via the /proc/pid/mountinfo
       file (see below).

   /proc/pid/mounts and /proc/pid/mountinfo
       The Linux-specific /proc/pid/mounts file exposes the list of mounts in the mount namespace
       of  the  process  with  the  specified ID.  The /proc/pid/mountinfo file exposes even more
       information about mounts, including the propagation type and  mount  ID  information  that
       makes  it possible to discover the parental relationship between mounts.  See proc(5)  and
       mount_namespaces(7)  for details of this file.

VEDERE ANCHE

       mountpoint(1), chroot(2),  ioctl_iflags(2),  mount_setattr(2),  pivot_root(2),  umount(2),
       mount_namespaces(7), path_resolution(7), findmnt(8), lsblk(8), mount(8), umount(8)

TRADUZIONE

       La  traduzione  italiana  di  questa  pagina  di  manuale è stata creata da Giulio Daprelà
       <giulio@pluto.it>,   Elisabetta   Galli    <lab@kkk.it>,    Antonio    Giovanni    Colombo
       <azc100@gmail.com> e Marco Curreli <marcocurreli@tiscali.it>

       Questa  traduzione è documentazione libera; leggere la GNU General Public License Versione
       3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ o successiva per le condizioni di copyright.
       Non ci assumiamo alcuna responsabilità.

       Per  segnalare  errori nella traduzione di questa pagina di manuale inviare un messaggio a
       ⟨pluto-ildp@lists.pluto.it⟩.