Accueil

CPU_SET
INFINITY
MB_CUR_MAX
MB_LEN_MAX
__setfpucw
_exit
_syscall
a64l
abort
abs
accept
access
acct
acos
acosh
addpart
addseverity
adduser
adjtime
adjtimex
aio_cancel
aio_error
aio_fsync
aio_read
aio_return
aio_suspend
aio_write
alarm
alloc_hugepages
alloca
apropos
arch
arch_prctl
argz_add
armscii-8
arp
ascii
asin
asinh
asprintf
assert
assert_perror
at
atan
atan2
atanh
atd
atexit
atof
atoi
atq
atrm
atrun
backend-spec
backtrace
basename
bash
bashbug
batch
bcmp
bcopy
bdflush
bind
bindresvport
blockdev
boot
bootlogd
bootparam
bosskill
brk
bsd_signal
bsearch
bstring
btowc
btree
builtin
builtins
byteorder
bzero
c
cabs
cacheflush
cacos
cacosh
cal
canonicalize_file_name
capabilities
capget
carg
casin
casinh
catan
catanh
catgets
catopen
cbrt
ccos
ccosh
ceil
cerf
cexp
cexp2
cfree
chage
charmap
charsets
chatise
chdir
chgrp
chmod
chown
chpasswd
chroot
chrt
chsh
cimag
clearenv
clock
clock_getcpuclockid
clock_getres
clock_nanosleep
clog
clog10
clog2
clone
close
closedir
cmp
cmsg
col
complex
confstr
conj
connect
console
console_codes
console_ioctl
consoletype
copysign
core
cos
cosh
cp
cp1251
cpow
cproj
cpuid
cpuset
creal
create_module
createrepo
credentials
cron
crond
crontab
crypt
crypttab
csin
csinh
csqrt
ctan
ctanh
ctermid
ctime
ctluser
ctrlaltdel
daemon
db2dvi
db2html
db2pdf
db2ps
db2rtf
dbopen
dd
ddp
delete_module
delpart
depmod
des_crypt
df
diff
diff3
difftime
dir
dir_colors
dircolors
dirfd
div
dl_iterate_phdr
dlopen
dmesg
docbook2dvi
docbook2html
docbook2man
docbook2man-spec
docbook2pdf
docbook2ps
docbook2rtf
docbook2tex
docbook2texi
docbook2texi-spec
docbook2txt
doexec
domainname
dprintf
drand48
drand48_r
dsp56k
du
dup
dysize
ecvt
ecvt_r
egrep
eject
elf
encrypt
end
endian
environ
envz_add
epoll
epoll_create
epoll_ctl
epoll_wait
erf
erfc
err
errno
error
ether_aton
ethers
euidaccess
eventfd
evim
exec
execve
exit
exit_group
exp
exp10
exp2
expm1
exportfs
exports
fabs
faccessat
faillog
fallocate
fchmodat
fchownat
fclose
fcloseall
fcntl
fd
fdformat
fdim
fdisk
feature_test_macros
fenv
ferror
fexecve
fflush
ffs
fgetgrent
fgetpwent
fgetwc
fgetws
fgrep
fifo
filesystems
finite
flock
flockfile
floor
fma
fmax
fmemopen
fmin
fmod
fmtmsg
fnmatch
fopen
fopencookie
fork
fpathconf
fpclassify
fpurge
fputwc
fputws
fread
free
frexp
frontend-spec
fseek
fseeko
fstab
fstab-decode
fstatat
fsync
ftime
ftok
ftpusers
fts
ftw
full
fuser
futex
futimes
futimesat
fwide
gamma
gcvt
get_kernel_syms
get_mempolicy
get_thread_area
getaddrinfo
getcontext
getcpu
getcwd
getdate
getdents
getdirentries
getdomainname
getdtablesize
getenv
getfsent
getgid
getgrent
getgrent_r
getgrnam
getgrouplist
getgroups
gethostbyname
gethostid
gethostname
getifaddrs
getipnodebyname
getitimer
getkey
getline
getloadavg
getlogin
getmntent
getnameinfo
getnetent
getnetent_r
getopt
getpagesize
getpass
getpeername
getpid
getpriority
getprotoent
getprotoent_r
getpt
getpw
getpwent
getpwent_r
getpwnam
getresuid
getrlimit
getrpcent
getrpcent_r
getrpcport
getrusage
gets
getservent
getservent_r
getsid
getsockname
getsockopt
getsubopt
gettid
gettimeofday
getttyent
getuid
getumask
getusershell
getutent
getutmp
getw
getwchar
getxattr
glob
gnu_get_libc_version
gpasswd
grantpt
grep
group
groupadd
groupdel
groupmod
grpck
grpconv
grpunconv
gshadow
gsignal
gssd
gunzip
guru
gzexe
gzip
halt
hash
hd
hier
host
hostname
hosts
hsearch
hypot
i386
icmp
iconv
iconv_close
iconv_open
idle
idmapd
ifconfig
ilogb
index
inet
inet_ntop
inet_pton
infnan
init
init_module
initgroups
initlog
initrd
initscript
inittab
inotify
inotify_add_watch
inotify_init
inotify_rm_watch
insmod
insque
install
install-catalog
intro
io_cancel
io_destroy
io_getevents
io_setup
io_submit
ioctl
ioctl_list
ioperm
iopl
ioprio_set
ip
ipc
ipcalc
ipcrm
ipcs
ipv6
isalpha
isatty
isgreater
iso_8859-1
iso_8859-10
iso_8859-11
iso_8859-13
iso_8859-14
iso_8859-15
iso_8859-16
iso_8859-2
iso_8859-3
iso_8859-4
iso_8859-5
iso_8859-6
iso_8859-7
iso_8859-8
iso_8859-9
issue
iswalnum
iswalpha
iswblank
iswcntrl
iswctype
iswdigit
iswgraph
iswlower
iswprint
iswpunct
iswspace
iswupper
iswxdigit
j0
jade
jw
key_setsecret
kill
killall
killall5
killpg
koi8-r
koi8-u
last
lastb
lastlog
ld
ldconfig
ldd
ldexp
lgamma
libc
link
linkat
linux32
linux64
listen
listxattr
llseek
ln
locale
localeconv
lockd
lockf
log
log10
log1p
log2
logb
login
longjmp
lookup_dcookie
lp
lrint
lround
ls
lsearch
lseek
lseek64
lsmod
lspci
lsusb
madvise
mailaddr
makecontext
makedev
makewhatis
malloc
malloc_hook
man
man-pages
math_error
matherr
mbind
mblen
mbrlen
mbrtowc
mbsinit
mbsnrtowcs
mbsrtowcs
mbstowcs
mbtowc
mcookie
mdoc
mem
memccpy
memchr
memcmp
memcpy
memfrob
memmem
memmove
mempcpy
memset
mesg
mincore
mkdir
mkdirat
mkdtemp
mkfifo
mkfifoat
mkfs
mknod
mknodat
mkstemp
mkswap
mktemp
mlock
mmap
mmap2
modf
modify_ldt
modifyrepo
modinfo
modprobe
more
motd
mount
mountd
mountpoint
mouse
move_pages
mpool
mprotect
mq_close
mq_getattr
mq_getsetattr
mq_notify
mq_open
mq_overview
mq_receive
mq_send
mq_unlink
mremap
msgctl
msgget
msgop
msr
msync
mtrace
mv
nan
nanosleep
netdevice
netlink
netreport
netstat
networks
newgrp
newusers
nextafter
nfs
nfsd
nfsservctl
nfsstat
nice
nicknames
nisdomainname
nl_langinfo
nmap
nologin
nscd
nsgmls
nsswitch
ntpd
ntpdc
null
numa
offsetof
on_exit
onsgmls
open
openat
opendir
openjade
openpty
operator
osgmlnorm
ospam
ospcat
ospent
osx
outb
package-cleanup
packet
passwd
path_resolution
pause
pciconfig_read
pcilib
perror
personality
pgrep
pidof
pipe
pivot_root
pkill
plipconfig
pmap
poll
popen
posix_fadvise
posix_fallocate
posix_memalign
posix_openpt
posixoptions
pow
pow10
poweroff
ppp-watch
pppoe
pppoe-connect
pppoe-relay
pppoe-server
pppoe-setup
pppoe-sniff
pppoe-start
pppoe-status
pppoe-stop
pppoe-wrapper
prctl
pread
printf
proc
profil
program_invocation_name
protocols
psignal
pstree
pthread_atfork
pthread_attr_destroy
pthread_attr_getdetachstate
pthread_attr_getinheritsched
pthread_attr_getschedparam
pthread_attr_getschedpolicy
pthread_attr_getscope
pthread_attr_init
pthread_attr_setaffinity_np
pthread_attr_setdetachstate
pthread_attr_setguardsize
pthread_attr_setinheritsched
pthread_attr_setschedparam
pthread_attr_setschedpolicy
pthread_attr_setscope
pthread_attr_setstack
pthread_attr_setstackaddr
pthread_attr_setstacksize
pthread_cancel
pthread_cleanup_pop
pthread_cleanup_pop_restore_np
pthread_cleanup_push
pthread_cleanup_push_defer_np
pthread_cond_broadcast
pthread_cond_destroy
pthread_cond_init
pthread_cond_signal
pthread_cond_timedwait
pthread_cond_wait
pthread_condattr_destroy
pthread_condattr_init
pthread_create
pthread_detach
pthread_equal
pthread_exit
pthread_getattr_np
pthread_getcpuclockid
pthread_getschedparam
pthread_getspecific
pthread_join
pthread_key_create
pthread_key_delete
pthread_kill
pthread_kill_other_threads_np
pthread_mutex_destroy
pthread_mutex_init
pthread_mutex_lock
pthread_mutex_trylock
pthread_mutex_unlock
pthread_mutexattr_destroy
pthread_mutexattr_getkind_np
pthread_mutexattr_gettype
pthread_mutexattr_init
pthread_mutexattr_setkind_np
pthread_mutexattr_settype
pthread_once
pthread_self
pthread_setaffinity_np
pthread_setcancelstate
pthread_setcanceltype
pthread_setconcurrency
pthread_setschedparam
pthread_setschedprio
pthread_setspecific
pthread_sigmask
pthread_testcancel
pthread_tryjoin_np
pthread_yield
pthreads
ptrace
pts
ptsname
pty
putenv
putgrent
putpwent
puts
putwchar
pwck
pwconv
pwdx
pwunconv
qecvt
qsort
query_module
queue
quotactl
raise
ram
rand
random
random_r
raw
rbash
rcmd
re_comp
read
readahead
readdir
readlink
readlinkat
readv
realpath
reboot
recno
recv
regex
remainder
remap_file_pages
remove
removexattr
remquo
rename
renameat
renice
repo-rss
repoquery
reposync
resolv
resolver
rev
rewinddir
rexec
rgrep
rint
rm
rmdir
rmmod
round
route
rpc
rpm
rpmatch
rquotad
rtc
rtime
rtld-audit
rtnetlink
runlevel
scalb
scalbln
scandir
scanf
sched_get_priority_max
sched_getcpu
sched_rr_get_interval
sched_setaffinity
sched_setparam
sched_setscheduler
sched_yield
sd
sdiff
securetty
sed
seekdir
select
select_tut
sem_close
sem_destroy
sem_getvalue
sem_init
sem_open
sem_overview
sem_post
sem_unlink
sem_wait
semctl
semget
semop
send
sendfile
service
services
set_mempolicy
set_thread_area
set_tid_address
setaliasent
setarch
setbuf
setenv
seteuid
setfsgid
setfsuid
setgid
setjmp
setlocale
setlogmask
setnetgrent
setpci
setpgid
setresuid
setreuid
setsid
setuid
setup
setxattr
sfdisk
sg
sgetmask
sgmldiff
sgmlnorm
shadow
shells
shm_open
shm_overview
shmctl
shmget
shmop
showmount
shutdown
sigaction
sigaltstack
siginterrupt
signal
signalfd
signbit
significand
sigpause
sigpending
sigprocmask
sigqueue
sigreturn
sigset
sigsetops
sigsuspend
sigvec
sigwait
sigwaitinfo
sin
sincos
sinh
sk98lin
skill
slabinfo
slabtop
slattach
sleep
snice
sockatmark
socket
socketcall
socketpair
spam
spent
splice
spu_create
spu_run
spufs
sqrt
st
standards
stat
statd
statfs
statvfs
stdarg
stdin
stdio
stdio_ext
stime
stpcpy
stpncpy
strcasecmp
strcat
strchr
strcmp
strcoll
strcpy
strdup
strerror
strfmon
strfry
strftime
string
strlen
strnlen
strpbrk
strptime
strsep
strsignal
strspn
strstr
strtod
strtoimax
strtok
strtol
strtoul
strverscmp
strxfrm
suffixes
sulogin
svcgssd
svipc
swab
swapoff
swapon
switchdesk
sx
symlink
symlinkat
sync
sync_file_range
sys-unconfig
syscall
syscalls
sysconf
sysctl
sysfs
sysinfo
syslog
system
sysv_signal
tailf
tan
tanh
tcgetpgrp
tcgetsid
tcp
tee
telinit
telldir
tempnam
termcap
termio
termios
tgamma
time
timegm
timer_create
timer_delete
timer_getoverrun
timer_settime
timeradd
timerfd_create
times
tkill
tkpppoe
tload
tmpfile
tmpnam
toascii
touch
toupper
towctrans
towlower
towupper
trunc
truncate
tsearch
tty
ttyS
tty_ioctl
ttyname
ttyslot
ttytype
tzfile
tzselect
tzset
ualarm
udp
udplite
ulimit
umask
umount
uname
undocumented
ungetwc
unicode
unimplemented
units
unix
unlink
unlinkat
unlocked_stdio
unlockpt
unshare
update-pciids
updwtmp
uptime
uri
uselib
useradd
userdel
usermod
usernetctl
usleep
ustat
utf-8
utime
utimensat
utmp
vcs
vdir
vfork
vhangup
vigr
vim
vimdiff
vimtutor
vipw
vm86
vmsplice
vmstat
volname
w
wait
wait4
wall
watch
wavelan
wcpcpy
wcpncpy
wcrtomb
wcscasecmp
wcscat
wcschr
wcscmp
wcscpy
wcscspn
wcsdup
wcslen
wcsncasecmp
wcsncat
wcsncmp
wcsncpy
wcsnlen
wcsnrtombs
wcspbrk
wcsrchr
wcsrtombs
wcsspn
wcsstr
wcstoimax
wcstok
wcstombs
wcswidth
wctob
wctomb
wctrans
wctype
wcwidth
whatis
whereis
wmemchr
wmemcmp
wmemcpy
wmemmove
wmemset
wordexp
wprintf
write
x25
x86_64
xcrypt
xdr
xxd
y0
ypcat
ypchfn
ypchsh
ypdomainname
ypmatch
yppasswd
yppoll
ypset
yptest
ypwhich
yum
yum-builddep
yum-complete-transaction
yum-shell
yum-updatesd
yum-utils
yum-verify
yumdownloader
zcat
zcmp
zdiff
zdump
zforce
zgrep
zic
zmore
znew

Pages de MAN

FCNTL(2)		  Manuel du programmeur Linux		      FCNTL(2)



NOM
       fcntl - Manipuler un descripteur de fichier

SYNOPSIS
       #include 
       #include 

       int fcntl(int fd, int cmd, ... /* arg */ );

DESCRIPTION
       fcntl() permet de se livrer à diverses opérations sur le descripteur de
       fichier fd. L'opération en question est déterminée  par	la  valeur  de
       l'argument cmd.

       fcntl() prend un troisième paramètre optionnel. La nécessité de fournir
       ce paramètre dépend de cmd. le paramètre	 doit  être  du	 type  indiqué
       entre parenthèses après chaque nom de commande cmd (dans la plupart des
       cas, le type requis est un long, et le paramètre est identifié en util-
       isant le nom arg), ou void est indiqué si le paramètre n'est pas néces-
       saire.

   Dupliquer un descripteur de fichier
       F_DUPFD (long)
	      Trouver le plus petit numéro de descripteur libre	 supérieur  ou
	      égal  à arg et le transformer en copie de fd. Ceci est différent
	      de dup2(2), qui utilise exactement le descripteur transmis.

	      En cas de réussite, le nouveau descripteur est renvoyé.

	      Voir dup(2) pour plus d'informations.

       F_DUPFD_CLOEXEC (long ; depuis Linux 2.6.24)
	      Comme  pour  F_DUPFD,  mais  positionne	en   plus   l'attribut
	      « close-on-exec »	 pour  le  descripteur dupliqué. Spécifier cet
	      attribut	permet	d'éviter  une  opération  F_SETFD  de  fcntl()
	      supplémentaire  pour positionner l'attribut FD_CLOEXEC. Pour une
	      explication sur ce en quoi  cet  attribut	 est  utile,  voir  la
	      description de O_CLOEXEC dans open(2).

   Attributs du descripteur de fichier
       Les commandes suivantes manipulent les attributs associés à un descrip-
       teur de fichier. Actuellement, un seul attribut est défini : il	s'agit
       de  FD_CLOEXEC,	l'attribut « close-on-exec ». Si le bit FD_CLOEXEC est
       0, le descripteur de fichier reste ouvert au  travers  d'un  execve(2),
       autrement il sera fermé.

       F_GETFD (void)
	      Lire les attributs du descripteur de fichier ; arg est ignoré.

       F_SETFD (long)
	      Positionner  les	attributs  du  descripteur  de fichier avec la
	      valeur précisée par arg.

   Attribut d'état du fichier
       Un descripteur de fichier dispose de  certains  attributs,  initialisés
       par  open(2) et éventuellement modifiés par fcntl(). Les attributs sont
       partagés	 entre	les  copies  (obtenues	avec  dup(2),  fcntl(F_DUPFD),
       fork(2), etc.) du même descripteur de fichier.

       Les attributs et leurs sémantiques sont décrits dans la page open(2).

       F_GETFL (void)
	      Lire les attributs d'état du fichier ; arg est ignoré.

       F_SETFL (long)
	      Positionner  les	nouveaux  attributs  pour  le  descripteur  de
	      fichier à la valeur indiquée par arg. Les bits de	 mode  d'accès
	      (O_RDONLY,  O_WRONLY,  O_RDWR)  et  les  attributs  de  création
	      (O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC) de arg sont	ignorés.  Sous
	      Linux,  cette  commande  ne  peut changer que O_APPEND, O_ASYNC,
	      O_DIRECT, O_NOATIME et O_NONBLOCK.

   Verrouillages coopératifs
       F_GETLK, F_SETLK et F_SETLKW servent à gérer les verrouillages d'enreg-
       istrements  (de segments ou de régions de fichiers). Le troisième argu-
       ment, lock, est un pointeur sur une structure qui a au moins les champs
       suivants (dans un ordre non spécifié).

	   struct flock {
	       ...
	       short l_type;	/* Type de verrouillage : F_RDLCK,
				   F_WRLCK, F_UNLCK */
	       short l_whence;	/* Interprétation de l_start:
				   SEEK_SET, SEEK_CUR, SEEK_END */
	       off_t l_start;	/* Décalage de début du verrouillage */
	       off_t l_len;	/* Nombre d'octets du verrouillage */
	       pid_t l_pid;	/* PID du processus bloquant notre verrou
				   (F_GETLK seulement) */
	       ...
	   };

       Les  champs  l_whence,  l_start	et  l_len de cette structure indiquent
       l'intervalle d'octets à verrouiller. Des octets après la fin du fichier
       peuvent être verrouillé, mais pas des octets avant le début du fichier.

       l_start est la position de début du verrou, et est interprété de	 façon
       relative : au début du fichier (si l_whence vaut SEEK_SET) ; à la posi-
       tion actuelle dans le fichier (si l_whence vaut SEEK_CUR) ; à la fin du
       fichier	(si  l_whence  vaut  SEEK_END).	 Dans  les  deux derniers cas,
       l_start peut être un nombre négatif, à partir du moment où la  position
       fournie ne pointe pas avant le début du fichier.

       l_len  indique  le nombre d'octets à verrouiller. Si l_len est positif,
       alors l'intervalle à verrouiller couvre les octets à partir de  l_start
       jusqu'à	l_start+l_len-1 (inclus). Indiquer 0 dans l_len a une signifi-
       cation particulière : cela verrouille tous les octets à	partir	de  la
       position	 indiquée  par	l_whence et l_start jusqu'à la fin du fichier,
       quelle que soit la taille que prendra la fichier.

       POSIX.1-2001 permet (mais n'impose pas) à une implémentation de prendre
       en  charge  des	valeurs	 de  l_len  négatives ;	 si l_len est négatif,
       l'intervalle décrivant le verrou lock couvre les	 octets	 l_start+l_len
       jusqu'à	l_start-1  inclus. Ceci est supporté par Linux depuis les ver-
       sions 2.4.21 et 2.5.49.

       Le champ l_type peut servir à placer un verrou en lecture (F_RDLCK)  ou
       en écriture (F_WRLCK) sur un fichier. Un nombre quelconque de processus
       peuvent tenir un verrou en  lecture  (partagé),	sur  une  région  d'un
       fichier,	 mais  un seul peut avoir un verrou en écriture (exclusif). Un
       verrou en écriture exclut tous les autres verrous, aussi bien  en  lec-
       ture qu'en écriture. Un processus donné ne peut tenir qu'un seul verrou
       sur une région d'un fichier, si un nouveau verrou y est appliqué, alors
       le  verrou  précédent  est  converti suivant le nouveau type. Ceci peut
       entraîner le découpage, la réduction ou l'extension du verrou  existant
       si le nombre d'octets du nouveau verrou ne coïncide pas exactement avec
       celui de l'ancien.

       F_SETLK (struct flock *)
	      Acquérir (si l_type vaut F_RDLCK	ou  F_WRLCK)  ou  libérer  (si
	      l_type  vaut  F_UNLCK) le verrou sur les octets indiqués par les
	      champs l_whence, l_start, et l_len de lock. Si un	 conflit  avec
	      un  verrou tenu par un autre processus existe, cet appel renvoie
	      -1 et positionne errno aux valeurs EACCES ou EAGAIN.

       F_SETLKW (struct flock *)
	      Comme F_SETLK, mais attend la libération du verrou  au  lieu  de
	      retourner	 une  erreur. Si un signal à intercepter est reçu pen-
	      dant l'attente, l'appel est interrompu et renverra immédiatement
	      (après  retour  du  gestionnaire de signaux) la valeur -1. errno
	      sera remplie avec la valeur EINTR ; voir signal(7).

       F_GETLK (struct flock *)
	      En entrée dans cette routine, lock décrit	 un  verrou  que  nous
	      aimerions	 placer	 sur le fichier. Si le verrouillage est possi-
	      ble, fcntl() ne le fait pas, mais renvoie F_UNLCK dans le	 champ
	      l_type  de  lock	et  laisse  les	 autres champs de la structure
	      inchangés.  Si  un  ou  plusieurs	 verrouillages	 incompatibles
	      empêchaient l'action, alors fcntl() renvoie des informations sur
	      l'un de ces verrous dans les champs l_type,  l_whence,  l_start,
	      et  l_len de lock et remplit l_pid avec le PID du processus ten-
	      ant le verrou.

       Pour pouvoir placer un verrou en lecture, fd doit être ouvert au	 moins
       en  lecture.  Pour placer un verrou en écriture, fd doit être ouvert en
       écriture. Pour placer les deux types de verrous, il faut une  ouverture
       en lecture-écriture.

       Outre la suppression par un F_UNLCK explicite, les verrous sont automa-
       tiquement libérés lorsque le processus se termine, ou s'il  ferme  l'un
       des descripteurs se référant au fichier sur lequel le verrou est placé.
       C'est dangereux : cela signifie qu'un processus peut perdre  un	verrou
       sur un fichier comme /etc/passwd ou /etc/mtab si, pour une raison quel-
       conque, une fonction de bibliothèque décide  de	l'ouvrir  puis	de  le
       refermer.

       Les verrouillages d'enregistrements ne sont pas hérités par les enfants
       lors d'un fork(2), mais sont conservés au travers d'un execve(2).

       À cause des tampons gérés par la bibliothèque  stdio(3),	 l'utilisation
       des  verrous d'enregistrements avec les routines de celle-ci est décon-
       seillé. Utilisez plutôt read(2) et write(2).

   Verrouillage obligatoire
       (Non POSIX) Les verrous	d'enregistrements  décrits  ci-dessus  peuvent
       être coopératifs ou impératifs, et sont coopératifs par défaut.

       Les  verrouillages  coopératifs	ne sont pas imposés, donc ils ne fonc-
       tionnent qu'entre processus qui les utilisent.

       Les verrous impératifs sont appliqués à tous les processus. Si un  pro-
       cessus  tente d'effectuer un accès incompatible (par exemple read(2) ou
       write(2)) sur une zone d'un fichier  qui	 a  un	verrou	impératif,  le
       résultat	 dépend	 de  l'attribut	 O_NONBLOCK du descripteur de fichier.
       S'il n'est pas activé, l'appel système est bloqué  jusqu'à  ce  que  le
       verrou  soit  enlevé  ou	 converti  en  un mode compatible avec l'accès
       demandé. Si l'attribut O_NONBLOCK est activé,  l'appel  système	échoue
       avec l'erreur EAGAIN.

       Pour utiliser des verrous impératifs, ce type de verrouillage doit être
       activé sur le système de fichiers contenant le  fichier	à  verrouiller
       (en utilisant l'option « -o mand » de mount(8)), ou l'attribut MS_MAND-
       LOCK de mount(2). Le verrouillage impératif est activé pour un  fichier
       en  désactivant	la  permission d'exécution du groupe et en activant le
       bit de permission Set-GID (voir chmod(1) et chmod(2)).

       L'implémentation Linux des verrouillages obligatoires n'est pas fiable.
       Voir la section BOGUES ci-dessous.

   Gestion des signaux
       F_GETOWN, F_SETOWN, F_GETSIG et F_SETSIG servent à gérer les signaux de
       disponibilité d'entrée-sortie :

       F_GETOWN (void)
	      Renvoyer (comme résultat de la  fonction)	 le  PID  ou  l'ID  du
	      groupe  de processus qui reçoit les signaux SIGIO et SIGURG pour
	      les événements concernant le  descripteur	 de  fichier  fd.  Les
	      groupes  de  processus  sont  renvoyés  sous  forme  de  valeurs
	      négatives (voir la section BOGUES ci-dessous). arg est ignoré.

       F_SETOWN (long)
	      Fixer le	PID  ou	 l'identifiant	du  groupe  de	processus  qui
	      recevront	 les  signaux SIGIO et SIGURG pour les événements con-
	      cernant le descripteur fd, à l'identifiant fourni par  arg.  Les
	      groupes	de   processus	sont  formulés	en  tant  que  valeurs
	      négatives. En général, le processus appelant indique son	propre
	      PID comme argument (arg est donc getpid(2)).

	      Si  vous	fixez l'attribut O_ASYNC sur un descripteur de fichier
	      en utilisant la commande F_SETFL de fcntl(), un signal SIGIO est
	      envoyé  dès  que	l'entrée  ou  la  sortie sont possibles sur ce
	      descripteur. F_SETSIG peut être utilisé pour recevoir  un	 autre
	      signal  que  SIGIO. Si la vérification de permissions échoue, le
	      signal est ignoré silencieusement.

	      L'envoi d'un  signal  au	processus  (ou	groupe	de  processus)
	      spécifié	par  F_SETOWN  est conditionné par les mêmes vérifica-
	      tions de permissions que l'envoi d'un signal par kill(2), où  le
	      processus	 envoyant  le  signal  est  celui qui utilise F_SETOWN
	      (voir la	section	 BOGUES	 ci-dessous).  Si  cette  vérification
	      échoue, le signal est ignoré.

	      Si  le  descripteur fd est une socket, F_SETOWN permet également
	      la réception de signaux SIGURG lorsque  des  données  hors-bande
	      arrivent	sur la socket. (SIGURG est émis dans toutes les situa-
	      tions où l'appel select(2) aurait indiqué que la socket est dans
	      une « situation exceptionnelle ».)

	      Si  une valeur non nulle est passée à F_SETSIG dans un processus
	      multithreadé utilisant une bibliothèque de  threads  gérant  les
	      groupes  de  threads  (par  exemple  NPTL),  une valeur positive
	      passée à F_SETOWN	 a  une	 signification	différente :  au  lieu
	      d'être  un  PID  identifiant  tout  un processus, il s'agit d'un
	      identifiant de thread, référant à un thread spécifique  dans  un
	      processus.  Par  conséquent, il peut être nécessaire de passer à
	      F_SETOWN la valeur renvoyée par gettid(2) plutôt que celle  ren-
	      voyée  par  getpid(2)  pour  obtenir  les résultats souhaités si
	      F_SETSIG est utilisé. (Dans les  implémentations	actuelles  des
	      threads  sous  Linux,  l'identifiant  de	thread (TID) du thread
	      principal est son identifiant de processus. Cela signifie	 qu'un
	      processus	 avec un seul thread peut utiliser indifféremment get-
	      tid(2) ou getpid(2).) Veuillez toutefois noter que les remarques
	      de  ce  paragraphe  ne  s'appliquent pas au signal SIGURG généré
	      lorsque des données hors-bande sont disponibles sur une socket :
	      ce  signal  est  toujours	 envoyé soit à un processus, soit à un
	      groupe de processus, selon la valeur donnée  à  F_SETOWN.	 Notez
	      également	 que  Linux  impose  une  limite  au nombre de signaux
	      temps-réel pouvant être mis en attente pour un  processus	 (voir
	      getrlimit(2)   et	  signal(7)),  et  lorsque  cette  limite  est
	      atteinte, le noyau recommence à envoyer SIGIO, qui est envoyé  à
	      tout le processus, et non à un thread en particulier.

       F_GETSIG (void)
	      Renvoyer	(comme	résultat  de  la fonction) le numéro du signal
	      émis lorsque l'entrée ou la  sortie  deviennent  possibles.  Une
	      valeur nulle signifie l'émission de SIGIO. Toute autre valeur (y
	      compris SIGIO) précise  le  signal  émis,	 et  des  informations
	      supplémentaires seront disponibles pour le gestionnaire s'il est
	      installé avec SA_SIGINFO. arg est ignoré.

       F_SETSIG (long)
	      Définir le signal à émettre lorsque l'entrée ou la sortie	 devi-
	      ennent  possibles	 à la valeur fournie par arg. Une valeur nulle
	      signifie l'émission de SIGIO.  Toute  autre  valeur  (y  compris
	      SIGIO)   précise	le  signal  à  émettre,	 et  des  informations
	      supplémentaires seront disponibles pour le gestionnaire s'il est
	      installé avec SA_SIGINFO.

	      En passant une valeur non nulle à F_SETSIG, le récepteur du sig-
	      nal est un thread spécifique,  plutôt  qu'un  processus  entier.
	      Voir la description de F_SETOWN pour plus de détails.

	      En  utilisant F_SETSIG avec une valeur non nulle, et en configu-
	      rant SA_SIGINFO pour le gestionnaire  (voir  sigaction(2)),  des
	      informations  supplémentaires  sur les événements d'entrées-sor-
	      ties sont fournies au gestionnaire à travers une structure  sig-
	      info_t.  Si le champ si_code indique que la source est SI_SIGIO,
	      le champ si_fd fournit le descripteur du	fichier	 concerné  par
	      l'événement.  Sinon  il n'y a pas d'indication du descripteur en
	      attente, et il faut utiliser le mécanisme	 habituel  (select(2),
	      poll(2), read(2) avec O_NONBLOCK configuré etc.) pour déterminer
	      quels descripteurs sont disponibles pour les entrées-sorties.

	      En sélectionnant un signal temps réel (valeur >=	SIGRTMIN),  de
	      multiples	 événements  d'entrées-sorties	peuvent être mémorisés
	      avec le même  numéro  (la	 mémorisation  dépend  de  la  mémoire
	      disponible).  Des informations supplémentaires sont disponibles,
	      comme ci-dessus, si SA_SIGINFO est configuré  pour  le  gestion-
	      naire.

       En   utilisant  ces  mécanismes,	 un  programme	peut  implémenter  des
       entrées-sorties totalement asynchrones, la plupart du temps sans	 avoir
       besoin d'invoquer select(2) ou poll(2).

       L'utilisation  de  O_ASYNC,  F_GETOWN,  F_SETOWN	 est spécifique BSD et
       Linux. F_GETSIG et F_SETSIG sont spécifiques  à	Linux.	POSIX  dispose
       d'entrées-sorties  asynchrones  et  de  la  structure aio_sigevent pour
       effectuer la même chose. Ceci est également disponible sous Linux  dans
       la bibliothèque GNU C (Glibc).

   Baux
       F_SETLEASE  et  F_GETLEASE  (depuis Linux 2.4) servent respectivement à
       établir un nouveau bail et à consulter le bail actuel sur  le  descrip-
       teur  de	 fichier  indiqué  par	fd.  (NdT :  je	 traduis « lease » par
       « bail », faute de terme plus technique.) Le bail sur un fichier	 four-
       nit  un	mécanisme par lequel un processus détenteur du bail est averti
       (par délivrance d'un signal) lorsqu'un autre processus (le « casseur de
       bail »)	essaye	d'appeler open(2) ou truncate(2) sur le fichier pointé
       par ce descripteur de fichier

       F_SETLEASE (long)
	      Fixe ou supprime un bail de fichier en  fonction	de  la	valeur
	      fournie dans l'entier arg :

	      F_RDLCK
		     Prendre  un  bail	en lecture. Le processus appelant sera
		     prévenu lorsqu'un autre processus ouvrira le  fichier  en
		     écriture ou le tronquera. Un bail en lecture ne peut être
		     placé que sur un descripteur de fichier ouvert en lecture
		     seule.

	      F_WRLCK
		     Prendre  un  bail en écriture. Le processus appelant sera
		     prévenu lorsqu'un autre processus ouvrira le fichier  (en
		     lecture ou écriture) ou le tronquera. Un bail en écriture
		     ne peut être pris sur le fichier que  s'il	 n'y  a	 aucun
		     autre descripteur de fichier ouvert pour le fichier.

	      F_UNLCK
		     Supprimer le bail sur un fichier.

       Les  baux  sont	associés  à  une  description  de fichier ouvert (voir
       open(2)). Cela signifie que les descripteurs de fichier dupliqués (créé
       par,  par  exemple,  fork(2) ou dup(2)) font référence au même bail, et
       que ce bail peut être modifié ou relâché par n'importe  lequel  de  ces
       descripteurs.  De  plus,	 le  bail  est	relâché soit par une opération
       F_UNLCK explicite sur n'importe lequel de ces  descripteurs  dupliqués,
       soit lorsque tous ces descripteurs ont été fermés.

       Les  baux ne peuvent être pris que sur des fichiers normaux. Un proces-
       sus non privilégié ne peut prendre un bail  que	sur  un	 fichier  dont
       l'UID (le propriétaire) correspond au FS-UID du processus. Un processus
       possédant la capacité CAP_LEASE peut prendre un bail sur n'importe quel
       fichier.

       F_GETLEASE (void)
	      Indique le type de bail possédé sur le descripteur de fichier fd
	      en renvoyant F_RDLCK, F_WRLCK, ou	 F_UNLCK,  signifiant  respec-
	      tivement	que le processus appelant a un bail en lecture, écrit-
	      ure, ou pas de bail sur le fichier. arg est ignoré.

       Lorsqu'un processus (le « casseur de bail » appelle  open(2)  ou	 trun-
       cate(2)	en conflit avec un bail établi par F_SETLEASE, l'appel système
       est bloqué par le noyau et le noyau avertit le processus tenant le bail
       par  l'envoi  d'un  signal  (SIGIO  par défaut). Le tenant du bail doit
       répondre à ce signal en effectuant tout le  nettoyage  nécessaire  pour
       que  le	fichier soit accessible par un autre processus (par exemple en
       vidant des tampons internes) et en supprimant ou déclassant  son	 bail.
       Un bail est supprimé en appelant la commande F_SETLEASE avec arg valant
       F_UNLCK. Si le tenant du bail  possède  un  bail	 en  écriture  sur  le
       fichier	et  que le casseur de bail ouvre le fichier en lecture, il est
       suffisant que le tenant du bail déclasse le bail en un bail en lecture.
       Cela  est  effectué  en appelant la commande F_SETLEASE avec arg valant
       F_RDLCK.

       Si le détenteur du bail n'arrive pas à le  déclasser  ou	 le  supprimer
       avant  le nombre de secondes indiqué dans /proc/sys/fs/lease-break-time
       alors le noyau supprimera ou déclassera de force le bail	 du  processus
       qui le tient.

       Dès  que	 le  bail a été, de gré ou de force, résilié ou déclassé et en
       supposant que le casseur de bail n'a pas débloqué son appel système, le
       noyau permet à ce dernier de se dérouler.

       Si  l'appel  à open(2) ou truncate(2) du casseur de bail est interrompu
       par un gestionnaire de signal, l'appel  système	échoue	avec  l'erreur
       EINTR, mais les autres étapes décrites ci-dessous se déroulent normale-
       ment. Si le casseur de bail est tué par un signal pendant que son appel
       système	open(2)	 ou  truncate(2)  bloque, tout se déroule comme décrit
       ci-dessus. De même, si le casseur de bail utilise  l'option  O_NONBLOCK
       de  open(2),  l'appel retourne immédiatement avec l'erreur EWOULDBLOCK,
       mais les autres étapes se déroulent comme décrit ci-dessus.

       Le signal de notification par défaut pour le tenant du bail est	SIGIO,
       mais  on	 peut  le  modifier  avec  la commande F_SETSIG de la fonction
       fcntl(). Si une commande F_SETSIG est réalisée (même pour SIGIO), et si
       le  gestionnaire	 de  signal  est  installé  avec  SA_SIGINFO, alors il
       recevra une structure siginfo_t en second argument, et le  champ	 si_fd
       contiendra le descripteur de fichier du bail où il y a eu une tentative
       d'accès par un autre processus. (Ceci sert si le	 processus  tient  des
       baux sur plusieurs fichiers.)

   Notification de modification de fichier et de répertoire (dnotify)
       F_NOTIFY (long)
	      (Depuis  Linux  2.4)  Fournit un avertissement lorsque le réper-
	      toire correspondant à fd ou l'un des fichiers qu'il contient est
	      modifié.	Les événements à notifier sont précisés dans arg, sous
	      forme de masque regroupant  par  un  OU  binaire	zéro,  une  ou
	      plusieurs des constantes suivantes :

	      DN_ACCESS	  Accès à un fichier (read, pread, readv)
	      DN_MODIFY	  Modification	d'un fichier (write, pwrite, truncate,
			  ftruncate).
	      DN_CREATE	  Création d'un fichier (open,	creat,	mknod,	mkdir,
			  link, symlink, rename).
	      DN_DELETE	  Suppression  d'un fichier (unlink, renommage dans un
			  autre répertoire, rmdir).
	      DN_RENAME	  Un fichier a été renommé  dans  le  même  répertoire
			  (nerame).
	      DN_ATTRIB	  Les  attributs d'un fichier ont été modifiés (chown,
			  chmod, utime[s]).

	      (Afin d'obtenir ces définitions, la macro _GNU_SOURCE doit  être
	      définie avant l'inclusion de .)

	      Les  notifications de répertoire sont habituellement uniques, et
	      l'application doit réenregistrer une demande pour les  notifica-
	      tions ultérieures. Inversement, si DN_MULTISHOT est incluse dans
	      arg, les notifications resteront en effet	 jusqu'à  une  demande
	      explicite de suppression.

	      Une  série de F_NOTIFY sont cumulés, les événements décrits dans
	      arg étant ajoutés à l'ensemble des événements  déjà  surveillés.
	      Pour supprimer les notifications de tous les événements, il faut
	      invoquer F_NOTIFY avec arg valant 0.

	      La notification se produit par l'occurrence d'un signal. Le sig-
	      nal  par	défaut est SIGIO, mais on peut le changer avec la com-
	      mande F_SETSIG de fcntl(). Dans ce cas, le gestionnaire de  sig-
	      nal  reçoit  une	structure  siginfo_t en second argument (si le
	      gestionnaire a été installé avec SA_SIGINFO) dont le champ si_fd
	      contient	le descripteur du fichier qui a déclenché la notifica-
	      tion (utile pour superviser plusieurs répertoires).

	      En outre, avec DN_MULTISHOT, un signal temps-réel	 devrait  être
	      utilisé  pour la notification pour pouvoir empiler les notifica-
	      tions successives.

	      NOTE : Les nouvelles applications devraient utiliser l'interface
	      inotify  (disponible  depuis Linux 2.6.13), qui fournit une bien
	      meilleure interface pour obtenir des notifications  d'événements
	      sur le système de fichiers. Voir inotify(7).

VALEUR RENVOYÉE
       La valeur renvoyée par fcntl() varie suivant le type d'opération :

       F_DUPFD	Le nouveau descripteur.

       F_GETFD	La valeur des attributs.

       F_GETFL	La valeur des attributs.

       F_GETLEASE
		Le type bail tenu sur le descripteur de fichier.

       F_GETOWN Le propriétaire du descripteur de fichier.

       F_GETSIG La  valeur  du	signal envoyé lorsque la lecture ou l'écriture
		deviennent possibles, ou zéro pour le comportement SIGIO  tra-
		ditionnel.

       Toutes les autres commandes :
		Zéro.

       En  cas d'erreur, la valeur de retour est -1, et errno contient le code
       d'erreur.

ERREURS
       EACCES ou EAGAIN
	      L'opération  est	interdire  en  raison  de  verrous  tenus  par
	      d'autres processus.

       EAGAIN L'opération  est	impossible à cause d'une projection en mémoire
	      effectuée par un autre processus.

       EBADF  fd n'est pas un descripteur de fichier ouvert,  ou  la  commande
	      était  F_SETLK ou F_SETLKW et le mode d'ouverture du descripteur
	      de fichier ne correspond pas au type de verrou demandé.

       EDEADLK
	      Le verrouillage F_SETLKW conduirait à un blocage.

       EFAULT lock se trouve en dehors de l'espace d'adressage.

       EINTR  Pour F_SETLKW, la commande a été	interrompue  par  un  signal ;
	      voir  signal(7).	Pour  F_GETLK  et  F_SETLK,  la commande a été
	      interrompue par un signal avant la vérification ou l'acquisition
	      du  verrou.  Se  produit	surtout lors d'un verrouillage distant
	      (par exemple à travers NFS), mais peut également arriver locale-
	      ment.

       EINVAL Pour F_DUPFD, arg est soit négatif, soit trop grand. Pour F_SET-
	      SIG, arg n'est pas un numéro de signal correct.

       EMFILE Pour F_DUPFD, le processus a déjà ouvert le  nombre  maximal  de
	      descripteurs de fichier.

       ENOLCK Trop  de	verrous	 sont  ouverts,	 ou  la	 table des verrous est
	      pleine, ou le verrouillage  distant  (par	 exemple  via  NFS)  a
	      échoué.

       EPERM  Essai  d'effacement  de l'attribut O_APPEND sur un fichier, mais
	      il est considéré comme en-ajout-seulement.

CONFORMITÉ
       SVr4, BSD 4.3, POSIX.1-2001. Seules les	opérations  F_DUPFD,  F_GETFD,
       F_SETFD,	 F_GETFL,  F_SETFL,  F_GETLK,  F_SETLK,	 F_SETLKW, F_GETOWN et
       F_SETOWN sont spécifiées dans POSIX.1-2001.

       F_DUPFD_CLOEXEC est spécifié dans POSIX.1-2008.

       F_GETSIG, F_SETSIG, F_NOTIFY, F_GETLEASE et F_SETLEASE sont spécifiques
       à  Linux. (Définissez la macro _GNU_SOURCE pour avoir ces définitions).

NOTES
       Les erreurs renvoyées par dup2(2) ne sont pas les mêmes que celles ren-
       voyées par F_DUPFD.

       Depuis  le  noyau  2.0,	il  n'y	 a pas d'interaction entre les verrous
       placés par flock(2) et ceux de fcntl().

       Plusieurs systèmes ont d'autres champs dans  struct  flock  comme,  par
       exemple,	 l_sysid.  Clairement, l_pid seul ne sera pas très utile si le
       processus tenant le verrou s'exécute sur une autre machine.

BOGUES
       En raison d'une limitation des conventions d'appels  système  sur  cer-
       taines  architectures  (en  particulier	i386),	si F_GETOWN renvoie un
       identifiant de groupe de processus compris entre -1 et -4095, la valeur
       de  retour  est	interprétée  par glibc comme une erreur ; la valeur de
       retour de fcntl() sera -1 et errno contiendra l'identifiant  du	groupe
       de processus (positif).

       Sous  Linux  2.4	 et  précédents,  lorsqu'un  processus	non privilégié
       utilise F_SETOWN pour indiquer le propriétaire d'une  socket,  avec  un
       identifiant  de (groupe de) processus autre que celui de l'appelant, un
       bogue peut survenir. Dans ce cas, fcntl() peut renvoyer -1, avec	 errno
       positionné à EPERM, même si l'appelant a le droit d'envoyer un signal à
       ce (groupe de) processus. En dépit de cette erreur, le propriétaire  du
       descripteur de fichier est positionné, et les signaux seront envoyés au
       propriétaire.

       L'implémentation du verrouillage obligatoire dans toutes	 les  versions
       connues de Linux est sujet à des conditions de concurrence qui la rende
       non fiable : un appel à write(2) qui chevauche un verrou peut  modifier
       les  données  après que le verrouillage obligatoire ait été acquis ; un
       appel à read(2) qui chevauche un verrou peut détecter des modifications
       sur  des	 données  qui  ont  été faites seulement après qu'un verrou en
       écriture ait été	 acquis.  Des  conditions  de  concurrence  similaires
       existent	 entre les verrous obligatoires et mmap(2). Il est donc décon-
       seillé de faire confiance au verrouillage obligatoire.

VOIR AUSSI
       dup2(2), flock(2), open(2), socket(2), lockf(3), capabilities(7),  fea-
       ture_test_macros(7)

       Consultez aussi locks.txt, mandatory-locking.txt et dnotify.txt dans le
       répertoire  Documentation/filesystems  des  sources   du	  noyau	  (sur
       d'anciens  noyaux, ces fichiers se trouvent dans le répertoire Documen-
       tation/ et mandatory-locking.txt est appelé mandatory.txt).

COLOPHON
       Cette page fait partie de  la  publication  3.23	 du  projet  man-pages
       Linux.  Une description du projet et des instructions pour signaler des
       anomalies  peuvent  être	 trouvées  à  l'adresse	  .

TRADUCTION
       Depuis  2010,  cette  traduction est maintenue à l'aide de l'outil po4a
        par l'équipe de traduction franco-
       phone	     au		sein	     du		projet	      perkamon
       .

       Christophe Blaess    (1996-2003),
       Alain   Portal  	 (2003-2006).	Julien
       Cristau et l'équipe francophone de traduction de Debian (2006-2009).

       Veuillez signaler toute erreur de  traduction  en  écrivant  à  .

       Vous  pouvez  toujours avoir accès à la version anglaise de ce document
       en utilisant la commande « LC_ALL=C man 
». Linux 25 juillet 2009 FCNTL(2)

 


www.eurower.info