nix-super/src/libstore/pathlocks.hh

#pragma once
///@file

#include "file-descriptor.hh"

namespace nix {

class PathLocks
{
private:
    typedef std::pair<int, Path> FDPair;
    std::list<FDPair> fds;
    bool deletePaths;

public:
    PathLocks();
    PathLocks(const PathSet & paths,
        const std::string & waitMsg = "");
    bool lockPaths(const PathSet & _paths,
        const std::string & waitMsg = "",
        bool wait = true);
    ~PathLocks();
    void unlock();
    void setDeletion(bool deletePaths);
};

}

#include "pathlocks-impl.hh"
Use "#pragma once" to prevent repeated header file inclusion 2012-07-18 21:59:03 +03:00			`#pragma once`
Ensure all headers have `#pragma once` and are in API docs `///@file` makes them show up in the internal API dos. A tiny few were missing `#pragma once`. 2023-04-01 06:18:41 +03:00			`///@file`
* normaliseFState() now locks all output paths prior to building, thus ensuring that simultaneous invocations of Nix don't clobber each other's builds. * Fixed a bug in `make install'. 2003-08-01 17:11:19 +03:00
Split up `util.{hh,cc}` All OS and IO operations should be moved out, leaving only some misc portable pure functions. This is useful to avoid copious CPP when doing things like Windows and Emscripten ports. Newly exposed functions to break cycles: - `restoreSignals` - `updateWindowSize` 2023-10-25 07:43:36 +03:00			`#include "file-descriptor.hh"`
* Use a proper namespace. * Optimise header file usage a bit. * Compile the parser as C++. 2006-09-05 00:06:23 +03:00
			`namespace nix {`
* normaliseFState() now locks all output paths prior to building, thus ensuring that simultaneous invocations of Nix don't clobber each other's builds. * Fixed a bug in `make install'. 2003-08-01 17:11:19 +03:00
openLockFile: Return an AutoCloseFD 2017-01-25 13:51:35 +02:00			`class PathLocks`
* normaliseFState() now locks all output paths prior to building, thus ensuring that simultaneous invocations of Nix don't clobber each other's builds. * Fixed a bug in `make install'. 2003-08-01 17:11:19 +03:00			`{`
			`private:`
* Use a proper namespace. * Optimise header file usage a bit. * Compile the parser as C++. 2006-09-05 00:06:23 +03:00			`typedef std::pair<int, Path> FDPair;`
Remove std::list alias 2022-02-21 17:25:12 +02:00			`std::list<FDPair> fds;`
* Remove lock files after building. 2003-11-21 18:05:19 +02:00			`bool deletePaths;`
* normaliseFState() now locks all output paths prior to building, thus ensuring that simultaneous invocations of Nix don't clobber each other's builds. * Fixed a bug in `make install'. 2003-08-01 17:11:19 +03:00
			`public:`
* True parallel builds. Nix can now run as many build jobs in parallel as possible (similar to GNU Make's `-j' switch). This is useful on SMP systems, but it is especially useful for doing builds on multiple machines. The idea is that a large derivation is initiated on one master machine, which then distributes sub-derivations to any number of slave machines. This should not happen synchronously or in lock-step, so the master must be capable of dealing with multiple parallel build jobs. We now have the infrastructure to support this. TODO: substitutes are currently broken. 2004-05-11 21:05:44 +03:00			`PathLocks();`
* In `nix-env -i\|-u\|-e', lock the profile to prevent races between concurrent nix-env operations on the same profile. Fixes NIX-7. 2006-06-15 14:56:49 +03:00			`PathLocks(const PathSet & paths,`
Remove std::string alias (for real this time) Also use std::string_view in a few more places. 2022-02-25 17:00:00 +02:00			`const std::string & waitMsg = "");`
* No longer block while waiting for a lock on a store path. Instead poll for it (i.e. if we can't acquire the lock, then let the main select() loop wait for at most a few seconds and then try again). This improves parallelism: if two nix-store processes are both trying to build a path at the same time, the second one shouldn't block; it should first see if it can build other goals. Also, it prevents the deadlocks that have been occuring in Hydra lately, where a process waits for a lock held by another process that's waiting for a lock held by the first. The downside is that polling isn't really elegant, but POSIX doesn't provide a way to wait for locks in a select() loop. The only solution would be to spawn a thread for each lock to do a blocking fcntl() and then signal the main thread, but that would require pthreads. 2009-03-23 03:05:54 +02:00			`bool lockPaths(const PathSet & _paths,`
Remove std::string alias (for real this time) Also use std::string_view in a few more places. 2022-02-25 17:00:00 +02:00			`const std::string & waitMsg = "",`
* No longer block while waiting for a lock on a store path. Instead poll for it (i.e. if we can't acquire the lock, then let the main select() loop wait for at most a few seconds and then try again). This improves parallelism: if two nix-store processes are both trying to build a path at the same time, the second one shouldn't block; it should first see if it can build other goals. Also, it prevents the deadlocks that have been occuring in Hydra lately, where a process waits for a lock held by another process that's waiting for a lock held by the first. The downside is that polling isn't really elegant, but POSIX doesn't provide a way to wait for locks in a select() loop. The only solution would be to spawn a thread for each lock to do a blocking fcntl() and then signal the main thread, but that would require pthreads. 2009-03-23 03:05:54 +02:00			`bool wait = true);`
* normaliseFState() now locks all output paths prior to building, thus ensuring that simultaneous invocations of Nix don't clobber each other's builds. * Fixed a bug in `make install'. 2003-08-01 17:11:19 +03:00			`~PathLocks();`
* Release output locks as soon as possible, not when the destructor of the DerivationGoal runs. Otherwise, if a goal is a top-level goal, then the lock won't be released until nix-store finishes. With --keep-going and lots of top-level goals, it's possible to run out of file descriptors (this happened sometimes in the build farm for Nixpkgs). Also, for failed derivation, it won't be possible to build it again until the lock is released. * Idem for locks on build users: these weren't released in a timely manner for failed top-level derivation goals. So if there were more than (say) 10 such failed builds, you would get an error about having run out of build users. 2009-02-16 11:24:20 +02:00			`void unlock();`
* Remove lock files after building. 2003-11-21 18:05:19 +02:00			`void setDeletion(bool deletePaths);`
* normaliseFState() now locks all output paths prior to building, thus ensuring that simultaneous invocations of Nix don't clobber each other's builds. * Fixed a bug in `make install'. 2003-08-01 17:11:19 +03:00			`};`

* Use a proper namespace. * Optimise header file usage a bit. * Compile the parser as C++. 2006-09-05 00:06:23 +03:00			`}`
Create no-op Window pathlocks implementation This keeps the call sites simple, eventually this should be filled in. 2024-04-17 18:34:09 +03:00
			`#include "pathlocks-impl.hh"`