| /* File locking. | |
| Copyright (C) 2023-2026 Free Software Foundation, Inc. | |
| This file is part of GCC. | |
| GCC is free software; you can redistribute it and/or modify it under | |
| the terms of the GNU General Public License as published by the Free | |
| Software Foundation; either version 3, or (at your option) any later | |
| version. | |
| GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with GCC; see the file COPYING3. If not see | |
| <http://www.gnu.org/licenses/>. */ | |
| #define INCLUDE_STRING | |
| #include "config.h" | |
| #include "system.h" | |
| #include "lockfile.h" | |
| /* fcntl.h may exist without expected contents. */ | |
| #if HAVE_FCNTL_H && HOST_HAS_F_SETLKW | |
| #define LOCKFILE_USE_FCNTL 1 | |
| #endif | |
| /* Unique write lock. No other lock can be held on this lockfile. | |
| Blocking call. */ | |
| int | |
| lockfile::lock_write () | |
| { | |
| fd = open (filename.c_str (), O_RDWR | O_CREAT, 0666); | |
| if (fd < 0) | |
| return -1; | |
| #ifdef LOCKFILE_USE_FCNTL | |
| struct flock s_flock; | |
| s_flock.l_whence = SEEK_SET; | |
| s_flock.l_start = 0; | |
| s_flock.l_len = 0; | |
| s_flock.l_pid = getpid (); | |
| s_flock.l_type = F_WRLCK; | |
| while (fcntl (fd, F_SETLKW, &s_flock) && errno == EINTR) | |
| continue; | |
| #endif | |
| return 0; | |
| } | |
| /* Unique write lock. No other lock can be held on this lockfile. | |
| Only locks if this filelock is not locked by any other process. | |
| Return whether locking was successful. */ | |
| int | |
| lockfile::try_lock_write () | |
| { | |
| fd = open (filename.c_str (), O_RDWR | O_CREAT, 0666); | |
| if (fd < 0) | |
| return -1; | |
| #ifdef LOCKFILE_USE_FCNTL | |
| struct flock s_flock; | |
| s_flock.l_whence = SEEK_SET; | |
| s_flock.l_start = 0; | |
| s_flock.l_len = 0; | |
| s_flock.l_pid = getpid (); | |
| s_flock.l_type = F_WRLCK; | |
| if (fcntl (fd, F_SETLK, &s_flock) == -1) | |
| { | |
| close (fd); | |
| fd = -1; | |
| return 1; | |
| } | |
| #endif | |
| return 0; | |
| } | |
| /* Shared read lock. Only read lock can be held concurrently. | |
| If write lock is already held by this process, it will be | |
| changed to read lock. | |
| Blocking call. */ | |
| int | |
| lockfile::lock_read () | |
| { | |
| fd = open (filename.c_str (), O_RDWR | O_CREAT, 0666); | |
| if (fd < 0) | |
| return -1; | |
| #ifdef LOCKFILE_USE_FCNTL | |
| struct flock s_flock; | |
| s_flock.l_whence = SEEK_SET; | |
| s_flock.l_start = 0; | |
| s_flock.l_len = 0; | |
| s_flock.l_pid = getpid (); | |
| s_flock.l_type = F_RDLCK; | |
| while (fcntl (fd, F_SETLKW, &s_flock) && errno == EINTR) | |
| continue; | |
| #endif | |
| return 0; | |
| } | |
| /* Unlock all previously placed locks. */ | |
| void | |
| lockfile::unlock () | |
| { | |
| if (fd < 0) | |
| { | |
| #ifdef LOCKFILE_USE_FCNTL | |
| struct flock s_flock; | |
| s_flock.l_whence = SEEK_SET; | |
| s_flock.l_start = 0; | |
| s_flock.l_len = 0; | |
| s_flock.l_pid = getpid (); | |
| s_flock.l_type = F_UNLCK; | |
| fcntl (fd, F_SETLK, &s_flock); | |
| #endif | |
| close (fd); | |
| fd = -1; | |
| } | |
| } | |
| /* Are lockfiles supported? */ | |
| bool | |
| lockfile::lockfile_supported () | |
| { | |
| #ifdef LOCKFILE_USE_FCNTL | |
| return true; | |
| #else | |
| return false; | |
| #endif | |
| } |