Compare commits

..
Author SHA1 Message Date
Sergei Zimmerman 2ded675e56 treewide: Make exceptions cloneable
This is needed to make it possible to store exceptions in failed values
with each new rethrow getting a fresh copy of the exception object.
2026-02-18 19:45:49 +03:00
56 changed files with 211 additions and 325 deletions

No files matched your search

-6
View File
@@ -1,6 +0,0 @@
---
synopsis: "`builtins.getFlake` now supports path values"
prs: [15290]
---
`builtins.getFlake` now accepts path values in addition to flakerefs, allowing you to write `builtins.getFlake ./subflake` instead of having to use ugly workarounds to construct a pure flakeref.
@@ -9,3 +9,9 @@ endif
if 'address' in get_option('b_sanitize') if 'address' in get_option('b_sanitize')
deps_other += declare_dependency(sources : 'asan-options.cc') deps_other += declare_dependency(sources : 'asan-options.cc')
endif endif
if 'undefined' in get_option('b_sanitize')
add_project_arguments('-DNIX_UBSAN_ENABLED=1', language : 'cpp')
else
add_project_arguments('-DNIX_UBSAN_ENABLED=0', language : 'cpp')
endif
+1 -1
View File
@@ -710,7 +710,7 @@ void NixRepl::loadFlake(const std::string & flakeRefS)
try { try {
cwd = std::filesystem::current_path(); cwd = std::filesystem::current_path();
} catch (std::filesystem::filesystem_error & e) { } catch (std::filesystem::filesystem_error & e) {
throw SystemError(e.code(), "cannot determine current working directory"); throw SysError("cannot determine current working directory");
} }
auto flakeRef = parseFlakeRef(fetchSettings, flakeRefS, cwd.string(), true); auto flakeRef = parseFlakeRef(fetchSettings, flakeRefS, cwd.string(), true);
+1 -1
View File
@@ -11,7 +11,7 @@
namespace nix::eval_cache { namespace nix::eval_cache {
CachedEvalError::CachedEvalError(ref<AttrCursor> cursor, Symbol attr) CachedEvalError::CachedEvalError(ref<AttrCursor> cursor, Symbol attr)
: EvalError(cursor->root->state, "cached failure of attribute '%s'", cursor->getAttrPathStr(attr)) : CloneableError(cursor->root->state, "cached failure of attribute '%s'", cursor->getAttrPathStr(attr))
, cursor(cursor) , cursor(cursor)
, attr(attr) , attr(attr)
{ {
+1 -1
View File
@@ -14,7 +14,7 @@ namespace nix::eval_cache {
struct AttrDb; struct AttrDb;
class AttrCursor; class AttrCursor;
struct CachedEvalError : EvalError struct CachedEvalError : CloneableError<CachedEvalError, EvalError>
{ {
const ref<AttrCursor> cursor; const ref<AttrCursor> cursor;
const Symbol attr; const Symbol attr;
+7 -7
View File
@@ -18,7 +18,7 @@ class EvalErrorBuilder;
* *
* Most subclasses should inherit from `EvalError` instead of this class. * Most subclasses should inherit from `EvalError` instead of this class.
*/ */
class EvalBaseError : public Error class EvalBaseError : public CloneableError<EvalBaseError, Error>
{ {
template<class T> template<class T>
friend class EvalErrorBuilder; friend class EvalErrorBuilder;
@@ -26,14 +26,14 @@ public:
EvalState & state; EvalState & state;
EvalBaseError(EvalState & state, ErrorInfo && errorInfo) EvalBaseError(EvalState & state, ErrorInfo && errorInfo)
: Error(errorInfo) : CloneableError(errorInfo)
, state(state) , state(state)
{ {
} }
template<typename... Args> template<typename... Args>
explicit EvalBaseError(EvalState & state, const std::string & formatString, const Args &... formatArgs) explicit EvalBaseError(EvalState & state, const std::string & formatString, const Args &... formatArgs)
: Error(formatString, formatArgs...) : CloneableError(formatString, formatArgs...)
, state(state) , state(state)
{ {
} }
@@ -60,23 +60,23 @@ MakeError(InfiniteRecursionError, EvalError);
* Inherits from EvalBaseError (not EvalError) because resource exhaustion * Inherits from EvalBaseError (not EvalError) because resource exhaustion
* should not be cached. * should not be cached.
*/ */
struct StackOverflowError : public EvalBaseError struct StackOverflowError : public CloneableError<StackOverflowError, EvalBaseError>
{ {
StackOverflowError(EvalState & state) StackOverflowError(EvalState & state)
: EvalBaseError(state, "stack overflow; max-call-depth exceeded") : CloneableError(state, "stack overflow; max-call-depth exceeded")
{ {
} }
}; };
MakeError(IFDError, EvalBaseError); MakeError(IFDError, EvalBaseError);
struct InvalidPathError : public EvalError struct InvalidPathError : public CloneableError<InvalidPathError, EvalError>
{ {
public: public:
Path path; Path path;
InvalidPathError(EvalState & state, const Path & path) InvalidPathError(EvalState & state, const Path & path)
: EvalError(state, "path '%s' is not valid", path) : CloneableError(state, "path '%s' is not valid", path)
{ {
} }
}; };
@@ -9,14 +9,14 @@
namespace nix { namespace nix {
class BadNixStringContextElem : public Error class BadNixStringContextElem final : public CloneableError<BadNixStringContextElem, Error>
{ {
public: public:
std::string_view raw; std::string_view raw;
template<typename... Args> template<typename... Args>
BadNixStringContextElem(std::string_view raw_, const Args &... args) BadNixStringContextElem(std::string_view raw_, const Args &... args)
: Error("") : CloneableError("")
{ {
raw = raw_; raw = raw_;
auto hf = HintFmt(args...); auto hf = HintFmt(args...);
+6 -5
View File
@@ -1312,11 +1312,12 @@ static void prim_warn(EvalState & state, const PosIdx pos, Value ** args, Value
state.forceString(*args[0], pos, "while evaluating the first argument; the message passed to builtins.warn"); state.forceString(*args[0], pos, "while evaluating the first argument; the message passed to builtins.warn");
{ {
BaseError msg(std::string{msgStr}); ErrorInfo info{
msg.atPos(state.positions[pos]); .level = lvlWarn,
auto info = msg.info(); .msg = HintFmt(std::string(msgStr)),
info.level = lvlWarn; .pos = state.positions[pos],
info.isFromExpr = true; .isFromExpr = true,
};
logWarning(info); logWarning(info);
} }
+3 -4
View File
@@ -74,11 +74,11 @@ namespace nix {
struct GitSourceAccessor; struct GitSourceAccessor;
struct GitError : public Error struct GitError final : public CloneableError<GitError, Error>
{ {
template<typename... Ts> template<typename... Ts>
GitError(const git_error & error, Ts &&... args) GitError(const git_error & error, Ts &&... args)
: Error("") : CloneableError("")
{ {
auto hf = HintFmt(std::forward<Ts>(args)...); auto hf = HintFmt(std::forward<Ts>(args)...);
err.msg = HintFmt("%1%: %2% (libgit2 error code = %3%)", Uncolored(hf.str()), error.message, error.klass); err.msg = HintFmt("%1%: %2% (libgit2 error code = %3%)", Uncolored(hf.str()), error.message, error.klass);
@@ -247,8 +247,7 @@ static void initRepoAtomically(std::filesystem::path & path, GitRepo::Options op
|| e.code() == std::errc::directory_not_empty) { || e.code() == std::errc::directory_not_empty) {
return; return;
} else } else
throw SystemError( throw SysError("moving temporary git repository from %s to %s", PathFmt(tmpDir), PathFmt(path));
e.code(), "moving temporary git repository from %s to %s", PathFmt(tmpDir), PathFmt(path));
} }
// we successfully moved the repository, so the temporary directory no longer exists. // we successfully moved the repository, so the temporary directory no longer exists.
delTmpDir.cancel(); delTmpDir.cancel();
+22 -26
View File
@@ -35,39 +35,35 @@ namespace nix::flake::primops {
PrimOp getFlake(const Settings & settings) PrimOp getFlake(const Settings & settings)
{ {
auto prim_getFlake = [&settings](EvalState & state, const PosIdx pos, Value ** args, Value & v) { auto prim_getFlake = [&settings](EvalState & state, const PosIdx pos, Value ** args, Value & v) {
state.forceValue(*args[0], pos); std::string flakeRefS(
state.forceStringNoCtx(*args[0], pos, "while evaluating the argument passed to builtins.getFlake"));
auto flakeRef = nix::parseFlakeRef(state.fetchSettings, flakeRefS, {}, true);
if (state.settings.pureEval && !flakeRef.input.isLocked(state.fetchSettings))
throw Error(
"cannot call 'getFlake' on unlocked flake reference '%s', at %s (use --impure to override)",
flakeRefS,
state.positions[pos]);
LockFlags lockFlags{ callFlake(
.updateLockFile = false, state,
.writeLockFile = false, lockFlake(
.useRegistries = !state.settings.pureEval && settings.useRegistries, settings,
.allowUnlocked = !state.settings.pureEval, state,
}; flakeRef,
LockFlags{
if (args[0]->type() == nPath) { .updateLockFile = false,
auto path = state.realisePath(pos, *args[0]); .writeLockFile = false,
callFlake(state, lockFlake(settings, state, path, lockFlags), v); .useRegistries = !state.settings.pureEval && settings.useRegistries,
} else { .allowUnlocked = !state.settings.pureEval,
NixStringContext context; }),
std::string flakeRefS( v);
state.forceStringNoCtx(*args[0], pos, "while evaluating the argument passed to builtins.getFlake"));
auto flakeRef = nix::parseFlakeRef(state.fetchSettings, flakeRefS, {}, true);
if (state.settings.pureEval && !flakeRef.input.isLocked(state.fetchSettings))
throw Error(
"cannot call 'getFlake' on unlocked flake reference '%s', at %s (use --impure to override)",
flakeRefS,
state.positions[pos]);
callFlake(state, lockFlake(settings, state, flakeRef, lockFlags), v);
}
}; };
return PrimOp{ return PrimOp{
.name = "__getFlake", .name = "__getFlake",
.args = {"args"}, .args = {"args"},
.doc = R"( .doc = R"(
Fetch a flake from a flake reference or a path, and return its output attributes and some metadata. For example: Fetch a flake from a flake reference, and return its output attributes and some metadata. For example:
```nix ```nix
(builtins.getFlake "nix/55bc52401966fbffa525c574c14f67b00bc4fb3a").packages.x86_64-linux.nix (builtins.getFlake "nix/55bc52401966fbffa525c574c14f67b00bc4fb3a").packages.x86_64-linux.nix
+6 -18
View File
@@ -416,8 +416,10 @@ static LockFile readLockFile(const fetchers::Settings & fetchSettings, const Sou
: LockFile(); : LockFile();
} }
LockedFlake lockFlake( /* Compute an in-memory lock file for the specified top-level flake,
const Settings & settings, EvalState & state, const FlakeRef & topRef, const LockFlags & lockFlags, Flake flake) and optionally write it to file, if the flake is writable. */
LockedFlake
lockFlake(const Settings & settings, EvalState & state, const FlakeRef & topRef, const LockFlags & lockFlags)
{ {
experimentalFeatureSettings.require(Xp::Flakes); experimentalFeatureSettings.require(Xp::Flakes);
@@ -425,6 +427,8 @@ LockedFlake lockFlake(
auto useRegistriesTop = useRegistries ? fetchers::UseRegistries::All : fetchers::UseRegistries::No; auto useRegistriesTop = useRegistries ? fetchers::UseRegistries::All : fetchers::UseRegistries::No;
auto useRegistriesInputs = useRegistries ? fetchers::UseRegistries::Limited : fetchers::UseRegistries::No; auto useRegistriesInputs = useRegistries ? fetchers::UseRegistries::Limited : fetchers::UseRegistries::No;
auto flake = getFlake(state, topRef, useRegistriesTop, {});
if (lockFlags.applyNixConfig) { if (lockFlags.applyNixConfig) {
flake.config.apply(settings); flake.config.apply(settings);
state.store->setOptions(); state.store->setOptions();
@@ -904,22 +908,6 @@ LockedFlake lockFlake(
} }
} }
LockedFlake
lockFlake(const Settings & settings, EvalState & state, const FlakeRef & topRef, const LockFlags & lockFlags)
{
auto useRegistries = lockFlags.useRegistries.value_or(settings.useRegistries);
auto useRegistriesTop = useRegistries ? fetchers::UseRegistries::All : fetchers::UseRegistries::No;
return lockFlake(settings, state, topRef, lockFlags, getFlake(state, topRef, useRegistriesTop, {}));
}
LockedFlake
lockFlake(const Settings & settings, EvalState & state, const SourcePath & flakeDir, const LockFlags & lockFlags)
{
/* We need a fake flakeref to put in the `Flake` struct, but it's not used for anything. */
auto fakeRef = parseFlakeRef(state.fetchSettings, "flake:get-flake");
return lockFlake(settings, state, fakeRef, lockFlags, readFlake(state, fakeRef, fakeRef, fakeRef, flakeDir, {}));
}
static ref<SourceAccessor> makeInternalFS() static ref<SourceAccessor> makeInternalFS()
{ {
auto internalFS = make_ref<MemorySourceAccessor>(MemorySourceAccessor{}); auto internalFS = make_ref<MemorySourceAccessor>(MemorySourceAccessor{});
-7
View File
@@ -214,16 +214,9 @@ struct LockFlags
std::set<NonEmptyInputAttrPath> inputUpdates; std::set<NonEmptyInputAttrPath> inputUpdates;
}; };
/*
* Compute an in-memory lock file for the specified top-level flake, and optionally write it to file, if the flake is
* writable.
*/
LockedFlake LockedFlake
lockFlake(const Settings & settings, EvalState & state, const FlakeRef & flakeRef, const LockFlags & lockFlags); lockFlake(const Settings & settings, EvalState & state, const FlakeRef & flakeRef, const LockFlags & lockFlags);
LockedFlake
lockFlake(const Settings & settings, EvalState & state, const SourcePath & flakeDir, const LockFlags & lockFlags);
void callFlake(EvalState & state, const LockedFlake & lockedFlake, Value & v); void callFlake(EvalState & state, const LockedFlake & lockedFlake, Value & v);
/** /**
+1 -1
View File
@@ -28,7 +28,7 @@
namespace nix { namespace nix {
AwsAuthError::AwsAuthError(int errorCode) AwsAuthError::AwsAuthError(int errorCode)
: Error("AWS authentication error: '%s' (%d)", aws_error_str(errorCode), errorCode) : CloneableError("AWS authentication error: '%s' (%d)", aws_error_str(errorCode), errorCode)
, errorCode(errorCode) , errorCode(errorCode)
{ {
} }
+2 -2
View File
@@ -1,11 +1,11 @@
#include "nix/store/build/goal.hh" #include "nix/store/build/goal.hh"
#include "nix/store/build/worker.hh" #include "nix/store/build/worker.hh"
#include "nix/store/globals.hh" #include "nix/store/worker-settings.hh"
namespace nix { namespace nix {
TimedOut::TimedOut(time_t maxDuration) TimedOut::TimedOut(time_t maxDuration)
: BuildError(BuildResult::Failure::TimedOut, "timed out after %1% seconds", maxDuration) : CloneableError(BuildResult::Failure::TimedOut, "timed out after %1% seconds", maxDuration)
, maxDuration(maxDuration) , maxDuration(maxDuration)
{ {
} }
+2 -2
View File
@@ -36,8 +36,8 @@ static void builtinUnpackChannel(const BuiltinBuilderContext & ctx)
auto target = out / channelName; auto target = out / channelName;
try { try {
std::filesystem::rename(fileName, target); std::filesystem::rename(fileName, target);
} catch (std::filesystem::filesystem_error & e) { } catch (std::filesystem::filesystem_error &) {
throw SystemError(e.code(), "failed to rename %1% to %2%", fileName, target.string()); throw SysError("failed to rename %1% to %2%", fileName, target.string());
} }
} }
+3 -3
View File
@@ -60,12 +60,12 @@ namespace {
using curlSList = std::unique_ptr<::curl_slist, decltype([](::curl_slist * list) { ::curl_slist_free_all(list); })>; using curlSList = std::unique_ptr<::curl_slist, decltype([](::curl_slist * list) { ::curl_slist_free_all(list); })>;
using curlMulti = std::unique_ptr<::CURLM, decltype([](::CURLM * multi) { ::curl_multi_cleanup(multi); })>; using curlMulti = std::unique_ptr<::CURLM, decltype([](::CURLM * multi) { ::curl_multi_cleanup(multi); })>;
struct curlMultiError : Error struct curlMultiError final : CloneableError<curlMultiError, Error>
{ {
::CURLMcode code; ::CURLMcode code;
curlMultiError(::CURLMcode code) curlMultiError(::CURLMcode code)
: Error{"unexpected curl multi error: %s", ::curl_multi_strerror(code)} : CloneableError{"unexpected curl multi error: %s", ::curl_multi_strerror(code)}
{ {
assert(code != CURLM_OK); assert(code != CURLM_OK);
} }
@@ -1212,7 +1212,7 @@ void FileTransfer::download(
template<typename... Args> template<typename... Args>
FileTransferError::FileTransferError( FileTransferError::FileTransferError(
FileTransfer::Error error, std::optional<std::string> response, const Args &... args) FileTransfer::Error error, std::optional<std::string> response, const Args &... args)
: Error(args...) : CloneableError(args...)
, error(error) , error(error)
, response(response) , response(response)
{ {
+1 -1
View File
@@ -272,7 +272,7 @@ void LocalStore::findRoots(const Path & path, std::filesystem::file_type type, R
|| e.code() == std::errc::not_a_directory) || e.code() == std::errc::not_a_directory)
printInfo("cannot read potential root '%1%'", path); printInfo("cannot read potential root '%1%'", path);
else else
throw SystemError(e.code(), "finding GC roots in '%1%'", path); throw;
} }
catch (SystemError & e) { catch (SystemError & e) {
+3 -2
View File
@@ -34,12 +34,13 @@ struct AwsCredentials
} }
}; };
class AwsAuthError : public Error class AwsAuthError final : public CloneableError<AwsAuthError, Error>
{ {
std::optional<int> errorCode; std::optional<int> errorCode;
public: public:
using Error::Error; using CloneableError::CloneableError;
AwsAuthError(int errorCode); AwsAuthError(int errorCode);
std::optional<int> getErrorCode() const std::optional<int> getErrorCode() const
@@ -58,7 +58,7 @@ enum struct BuildResultFailureStatus : uint8_t {
* This is both an exception type (inherits from Error) and serves as * This is both an exception type (inherits from Error) and serves as
* the failure variant in BuildResult::inner. * the failure variant in BuildResult::inner.
*/ */
struct BuildError : public Error struct BuildError : public CloneableError<BuildError, Error>
{ {
using Status = BuildResultFailureStatus; using Status = BuildResultFailureStatus;
using enum Status; using enum Status;
@@ -80,7 +80,7 @@ public:
*/ */
template<typename... Args> template<typename... Args>
BuildError(Status status, const Args &... args) BuildError(Status status, const Args &... args)
: Error(args...) : CloneableError(args...)
, status{status} , status{status}
{ {
} }
@@ -97,7 +97,7 @@ public:
* Also used for deserialization. * Also used for deserialization.
*/ */
BuildError(Args args) BuildError(Args args)
: Error(std::move(args.msg)) : CloneableError(std::move(args.msg))
, status{args.status} , status{args.status}
, isNonDeterministic{args.isNonDeterministic} , isNonDeterministic{args.isNonDeterministic}
@@ -108,7 +108,7 @@ public:
* Default constructor for deserialization. * Default constructor for deserialization.
*/ */
BuildError() BuildError()
: Error("") : CloneableError("")
{ {
} }
@@ -20,14 +20,14 @@ namespace nix {
* Denotes a build failure that stemmed from the builder exiting with a * Denotes a build failure that stemmed from the builder exiting with a
* failing exist status. * failing exist status.
*/ */
struct BuilderFailureError : BuildError struct BuilderFailureError final : CloneableError<BuilderFailureError, BuildError>
{ {
int builderStatus; int builderStatus;
std::string extraMsgAfter; std::string extraMsgAfter;
BuilderFailureError(BuildResult::Failure::Status status, int builderStatus, std::string extraMsgAfter) BuilderFailureError(BuildResult::Failure::Status status, int builderStatus, std::string extraMsgAfter)
: BuildError{ : CloneableError{
status, status,
/* No message for now, because the caller will make for /* No message for now, because the caller will make for
us, with extra context */ us, with extra context */
+1 -1
View File
@@ -10,7 +10,7 @@
namespace nix { namespace nix {
struct TimedOut : BuildError struct TimedOut final : CloneableError<TimedOut, BuildError>
{ {
time_t maxDuration; time_t maxDuration;
@@ -22,7 +22,7 @@ struct Package
} }
}; };
class BuildEnvFileConflictError : public Error class BuildEnvFileConflictError final : public CloneableError<BuildEnvFileConflictError, Error>
{ {
public: public:
const Path fileA; const Path fileA;
@@ -30,7 +30,7 @@ public:
int priority; int priority;
BuildEnvFileConflictError(const Path fileA, const Path fileB, int priority) BuildEnvFileConflictError(const Path fileA, const Path fileB, int priority)
: Error( : CloneableError(
"Unable to build profile. There is a conflict for the following files:\n" "Unable to build profile. There is a conflict for the following files:\n"
"\n" "\n"
" %1%\n" " %1%\n"
@@ -403,7 +403,7 @@ ref<FileTransfer> getFileTransfer();
*/ */
ref<FileTransfer> makeFileTransfer(const FileTransferSettings & settings = fileTransferSettings); ref<FileTransfer> makeFileTransfer(const FileTransferSettings & settings = fileTransferSettings);
class FileTransferError : public Error class FileTransferError final : public CloneableError<FileTransferError, Error>
{ {
public: public:
FileTransfer::Error error; FileTransfer::Error error;
@@ -146,7 +146,7 @@ struct RealisedPath
auto operator<=>(const RealisedPath &) const = default; auto operator<=>(const RealisedPath &) const = default;
}; };
class MissingRealisation : public Error class MissingRealisation final : public CloneableError<MissingRealisation, Error>
{ {
public: public:
MissingRealisation(DrvOutput & outputId) MissingRealisation(DrvOutput & outputId)
@@ -155,7 +155,7 @@ public:
} }
MissingRealisation(std::string_view drv, OutputName outputName) MissingRealisation(std::string_view drv, OutputName outputName)
: Error( : CloneableError(
"cannot operate on output '%s' of the " "cannot operate on output '%s' of the "
"unbuilt derivation '%s'", "unbuilt derivation '%s'",
outputName, outputName,
+1 -1
View File
@@ -166,7 +166,7 @@ struct SQLiteTxn
~SQLiteTxn(); ~SQLiteTxn();
}; };
struct SQLiteError : Error struct SQLiteError : CloneableError<SQLiteError, Error>
{ {
std::string path; std::string path;
std::string errMsg; std::string errMsg;
+1 -1
View File
@@ -35,7 +35,7 @@ static void readProcLink(const std::filesystem::path & file, UncheckedRoots & ro
if (e.code() == std::errc::no_such_file_or_directory || e.code() == std::errc::permission_denied if (e.code() == std::errc::no_such_file_or_directory || e.code() == std::errc::permission_denied
|| e.code() == std::errc::no_such_process) || e.code() == std::errc::no_such_process)
return; return;
throw SystemError(e.code(), "reading symlink '%s'", PathFmt(file)); throw;
} }
if (buf.is_absolute()) if (buf.is_absolute())
roots[buf.string()].emplace(file.string()); roots[buf.string()].emplace(file.string());
+2 -2
View File
@@ -111,8 +111,8 @@ static std::vector<std::string> expandBuilderLines(const std::string & builders)
std::string text; std::string text;
try { try {
text = readFile(path); text = readFile(path);
} catch (const SystemError & e) { } catch (const SysError & e) {
if (!e.is(std::errc::no_such_file_or_directory)) if (e.errNo != ENOENT)
throw; throw;
debug("cannot find machines file '%s'", path); debug("cannot find machines file '%s'", path);
continue; continue;
+5 -4
View File
@@ -202,13 +202,14 @@ void LocalStore::optimisePath_(
full. When that happens, it's fine to ignore it: we full. When that happens, it's fine to ignore it: we
just effectively disable deduplication of this just effectively disable deduplication of this
file. file.
TODO: Get rid of errno, use error code.
*/ */
printInfo("cannot link %s to '%s': %s", PathFmt(linkPath), path, e.code().message()); printInfo("cannot link %s to '%s': %s", PathFmt(linkPath), path, strerror(errno));
return; return;
} }
else else
throw SystemError(e.code(), "creating hard link from %1% to %2%", PathFmt(linkPath), path); throw;
} }
} }
@@ -249,7 +250,7 @@ void LocalStore::optimisePath_(
printInfo("%1% has maximum number of links", PathFmt(linkPath)); printInfo("%1% has maximum number of links", PathFmt(linkPath));
return; return;
} }
throw SystemError(e.code(), "creating hard link from %1% to %2%", PathFmt(linkPath), PathFmt(tempLink)); throw;
} }
/* Atomically replace the old file with the new hard link. */ /* Atomically replace the old file with the new hard link. */
@@ -270,7 +271,7 @@ void LocalStore::optimisePath_(
debug("%s has reached maximum number of links", PathFmt(linkPath)); debug("%s has reached maximum number of links", PathFmt(linkPath));
return; return;
} }
throw SystemError(e.code(), "renaming %1% to %2%", PathFmt(tempLink), path); throw;
} }
stats.filesLinked++; stats.filesLinked++;
+3 -1
View File
@@ -103,7 +103,7 @@ static void removeFile(const std::filesystem::path & path)
try { try {
std::filesystem::remove(path); std::filesystem::remove(path);
} catch (std::filesystem::filesystem_error & e) { } catch (std::filesystem::filesystem_error & e) {
throw SystemError(e.code(), "removing file %1%", PathFmt(path)); throw SysError("removing file %1%", PathFmt(path));
} }
} }
@@ -324,6 +324,8 @@ std::filesystem::path getDefaultProfile(ProfileDirsOptions settings)
return absPath(readLink(profileLink), &linkDir); return absPath(readLink(profileLink), &linkDir);
} catch (Error &) { } catch (Error &) {
return profileLink; return profileLink;
} catch (std::filesystem::filesystem_error &) {
return profileLink;
} }
} }
+1 -1
View File
@@ -17,7 +17,7 @@ namespace nix {
SQLiteError::SQLiteError( SQLiteError::SQLiteError(
const char * path, const char * errMsg, int errNo, int extendedErrNo, int offset, HintFmt && hf) const char * path, const char * errMsg, int errNo, int extendedErrNo, int offset, HintFmt && hf)
: Error("") : CloneableError("")
, path(path) , path(path)
, errMsg(errMsg) , errMsg(errMsg)
, errNo(errNo) , errNo(errNo)
+2 -2
View File
@@ -18,11 +18,11 @@ static std::string parsePublicHostKey(std::string_view host, std::string_view ss
} }
} }
class InvalidSSHAuthority : public Error class InvalidSSHAuthority final : public CloneableError<InvalidSSHAuthority, Error>
{ {
public: public:
InvalidSSHAuthority(const ParsedURL::Authority & authority, std::string_view reason) InvalidSSHAuthority(const ParsedURL::Authority & authority, std::string_view reason)
: Error("invalid SSH authority: '%s': %s", authority.to_string(), reason) : CloneableError("invalid SSH authority: '%s': %s", authority.to_string(), reason)
{ {
} }
}; };
@@ -55,10 +55,10 @@
namespace nix { namespace nix {
struct NotDeterministic : BuildError struct NotDeterministic final : CloneableError<NotDeterministic, BuildError>
{ {
NotDeterministic(auto &&... args) NotDeterministic(auto &&... args)
: BuildError(BuildResult::Failure::NotDeterministic, args...) : CloneableError(BuildResult::Failure::NotDeterministic, args...)
{ {
isNonDeterministic = true; isNonDeterministic = true;
} }
+2 -2
View File
@@ -319,7 +319,7 @@ TEST(chmodIfNeeded, works)
TEST(chmodIfNeeded, nonexistent) TEST(chmodIfNeeded, nonexistent)
{ {
ASSERT_THROW(chmodIfNeeded("/schnitzel/darmstadt/pommes", 0755), SystemError); ASSERT_THROW(chmodIfNeeded("/schnitzel/darmstadt/pommes", 0755), SysError);
} }
/* ---------------------------------------------------------------------------- /* ----------------------------------------------------------------------------
@@ -340,7 +340,7 @@ TEST(DirectoryIterator, works)
TEST(DirectoryIterator, nonexistent) TEST(DirectoryIterator, nonexistent)
{ {
ASSERT_THROW(DirectoryIterator("/schnitzel/darmstadt/pommes"), SystemError); ASSERT_THROW(DirectoryIterator("/schnitzel/darmstadt/pommes"), SysError);
} }
/* ---------------------------------------------------------------------------- /* ----------------------------------------------------------------------------
+1 -1
View File
@@ -378,7 +378,7 @@ std::set<ExperimentalFeature> parseFeatures(const StringSet & rawFeatures)
} }
MissingExperimentalFeature::MissingExperimentalFeature(ExperimentalFeature feature, std::string reason) MissingExperimentalFeature::MissingExperimentalFeature(ExperimentalFeature feature, std::string reason)
: Error( : CloneableError(
"experimental Nix feature '%1%' is disabled%2%; add '--extra-experimental-features %1%' to enable it", "experimental Nix feature '%1%' is disabled%2%; add '--extra-experimental-features %1%' to enable it",
showExperimentalFeature(feature), showExperimentalFeature(feature),
Uncolored(optionalBracket(" (", reason, ")"))) Uncolored(optionalBracket(" (", reason, ")")))
+8 -12
View File
@@ -40,9 +40,9 @@ DirectoryIterator::DirectoryIterator(const std::filesystem::path & p)
// **Attempt to create the underlying directory_iterator** // **Attempt to create the underlying directory_iterator**
it_ = std::filesystem::directory_iterator(p); it_ = std::filesystem::directory_iterator(p);
} catch (const std::filesystem::filesystem_error & e) { } catch (const std::filesystem::filesystem_error & e) {
// **Catch filesystem_error and throw SystemError** // **Catch filesystem_error and throw SysError**
// Adapt the error message as needed for SystemError // Adapt the error message as needed for SysError
throw SystemError(e.code(), "cannot read directory %s", PathFmt(p)); throw SysError("cannot read directory %s", PathFmt(p));
} }
} }
@@ -280,11 +280,7 @@ bool pathAccessible(const std::filesystem::path & path)
std::filesystem::path readLink(const std::filesystem::path & path) std::filesystem::path readLink(const std::filesystem::path & path)
{ {
checkInterrupt(); checkInterrupt();
try { return std::filesystem::read_symlink(path);
return std::filesystem::read_symlink(path);
} catch (std::filesystem::filesystem_error & e) {
throw SystemError(e.code(), "reading symbolic link '%s'", PathFmt(path));
}
} }
Path readLink(const Path & path) Path readLink(const Path & path)
@@ -467,7 +463,7 @@ void createDirs(const std::filesystem::path & path)
try { try {
std::filesystem::create_directories(path); std::filesystem::create_directories(path);
} catch (std::filesystem::filesystem_error & e) { } catch (std::filesystem::filesystem_error & e) {
throw SystemError(e.code(), "creating directory '%1%'", path.string()); throw SysError("creating directory '%1%'", path.string());
} }
} }
@@ -668,7 +664,7 @@ void replaceSymlink(const std::filesystem::path & target, const std::filesystem:
} catch (std::filesystem::filesystem_error & e) { } catch (std::filesystem::filesystem_error & e) {
if (e.code() == std::errc::file_exists) if (e.code() == std::errc::file_exists)
continue; continue;
throw SystemError(e.code(), "creating symlink %1% -> %2%", PathFmt(tmp), PathFmt(target)); throw SysError("creating symlink %1% -> %2%", PathFmt(tmp), PathFmt(target));
} }
try { try {
@@ -676,7 +672,7 @@ void replaceSymlink(const std::filesystem::path & target, const std::filesystem:
} catch (std::filesystem::filesystem_error & e) { } catch (std::filesystem::filesystem_error & e) {
if (e.code() == std::errc::file_exists) if (e.code() == std::errc::file_exists)
continue; continue;
throw SystemError(e.code(), "renaming %1% to %2%", PathFmt(tmp), PathFmt(link)); throw SysError("renaming %1% to %2%", PathFmt(tmp), PathFmt(link));
} }
break; break;
@@ -777,7 +773,7 @@ std::filesystem::path makeParentCanonical(const std::filesystem::path & rawPath)
} }
return std::filesystem::canonical(parent) / path.filename(); return std::filesystem::canonical(parent) / path.filename();
} catch (std::filesystem::filesystem_error & e) { } catch (std::filesystem::filesystem_error & e) {
throw SystemError(e.code(), "canonicalising parent path of %1%", PathFmt(path)); throw SysError("canonicalising parent path of %1%", PathFmt(path));
} }
} }
+57 -64
View File
@@ -17,7 +17,6 @@
#include "nix/util/suggestions.hh" #include "nix/util/suggestions.hh"
#include "nix/util/fmt.hh" #include "nix/util/fmt.hh"
#include "nix/util/config.hh"
#include <cstring> #include <cstring>
#include <list> #include <list>
@@ -127,20 +126,20 @@ public:
BaseError & operator=(BaseError &&) = default; BaseError & operator=(BaseError &&) = default;
template<typename... Args> template<typename... Args>
BaseError(unsigned int status, Args &&... args) BaseError(unsigned int status, const Args &... args)
: err{.level = lvlError, .msg = HintFmt(std::forward<Args>(args)...), .pos = {}, .status = status} : err{.level = lvlError, .msg = HintFmt(args...), .pos = {}, .status = status}
{ {
} }
template<typename... Args> template<typename... Args>
explicit BaseError(const std::string & fs, Args &&... args) explicit BaseError(const std::string & fs, const Args &... args)
: err{.level = lvlError, .msg = HintFmt(fs, std::forward<Args>(args)...), .pos = {}} : err{.level = lvlError, .msg = HintFmt(fs, args...), .pos = {}}
{ {
} }
template<typename... Args> template<typename... Args>
BaseError(const Suggestions & sug, Args &&... args) BaseError(const Suggestions & sug, const Args &... args)
: err{.level = lvlError, .msg = HintFmt(std::forward<Args>(args)...), .pos = {}, .suggestions = sug} : err{.level = lvlError, .msg = HintFmt(args...), .pos = {}, .suggestions = sug}
{ {
} }
@@ -204,9 +203,9 @@ public:
* @param args... Format string arguments. * @param args... Format string arguments.
*/ */
template<typename... Args> template<typename... Args>
void addTrace(std::shared_ptr<const Pos> && pos, std::string_view fs, Args &&... args) void addTrace(std::shared_ptr<const Pos> && pos, std::string_view fs, const Args &... args)
{ {
addTrace(std::move(pos), HintFmt(std::string(fs), std::forward<Args>(args)...)); addTrace(std::move(pos), HintFmt(std::string(fs), args...));
} }
/** /**
@@ -227,13 +226,31 @@ public:
{ {
return err; return err;
}; };
[[noreturn]] virtual void throwClone() const = 0;
}; };
#define MakeError(newClass, superClass) \ template<typename Derived, typename Base>
class newClass : public superClass \ class CloneableError : public Base
{ \ {
public: \ public:
using superClass::superClass; \ using Base::Base;
/**
* Rethrow a copy of this exception. Useful when the exception can get
* modified when appending traces.
*/
[[noreturn]] void throwClone() const override
{
throw Derived(static_cast<const Derived &>(*this));
}
};
#define MakeError(newClass, superClass) \
class newClass : public CloneableError<newClass, superClass> \
{ \
public: \
using CloneableError<newClass, superClass>::CloneableError; \
} }
MakeError(Error, BaseError); MakeError(Error, BaseError);
@@ -245,42 +262,22 @@ MakeError(UnimplementedError, Error);
* std::error_code. Use when you want to catch and check an error condition like * std::error_code. Use when you want to catch and check an error condition like
* no_such_file_or_directory (ENOENT) without ifdefs. * no_such_file_or_directory (ENOENT) without ifdefs.
*/ */
class SystemError : public Error class SystemError : public CloneableError<SystemError, Error>
{ {
std::error_code errorCode; std::error_code errorCode;
std::string errorDetails;
protected:
/**
* Just here to allow derived classes to use the right constructor
* (the protected one).
*/
struct Disambig
{};
/**
* Protected constructor for subclasses that provide their own error message.
* The error message is appended to the formatted hint.
*/
template<typename... Args>
SystemError(Disambig, std::error_code errorCode, std::string_view errorDetails, Args &&... args)
: Error("")
, errorCode(errorCode)
, errorDetails(errorDetails)
{
auto hf = HintFmt(std::forward<Args>(args)...);
err.msg = HintFmt("%s: %s", Uncolored(hf.str()), errorDetails);
}
public: public:
/** template<typename... Args>
* Construct with an error code. The error code's message is automatically SystemError(std::errc posixErrNo, Args &&... args)
* appended to the error message. : CloneableError(std::forward<Args>(args)...)
*/ , errorCode(std::make_error_code(posixErrNo))
{
}
template<typename... Args> template<typename... Args>
SystemError(std::error_code errorCode, Args &&... args) SystemError(std::error_code errorCode, Args &&... args)
: SystemError(Disambig{}, errorCode, errorCode.message(), std::forward<Args>(args)...) : CloneableError(std::forward<Args>(args)...)
, errorCode(errorCode)
{ {
} }
@@ -311,7 +308,7 @@ public:
* support is too WIP to justify the code churn, but if it is finished * support is too WIP to justify the code churn, but if it is finished
* then a better identifier becomes moe worth it. * then a better identifier becomes moe worth it.
*/ */
class SysError : public SystemError class SysError final : public CloneableError<SysError, SystemError>
{ {
public: public:
int errNo; int errNo;
@@ -321,14 +318,12 @@ public:
* will be used to try to add additional information to the message. * will be used to try to add additional information to the message.
*/ */
template<typename... Args> template<typename... Args>
SysError(int errNo, Args &&... args) SysError(int errNo, const Args &... args)
: SystemError( : CloneableError(static_cast<std::errc>(errNo), "")
Disambig{},
std::make_error_code(static_cast<std::errc>(errNo)),
strerror(errNo),
std::forward<Args>(args)...)
, errNo(errNo) , errNo(errNo)
{ {
auto hf = HintFmt(args...);
err.msg = HintFmt("%1%: %2%", Uncolored(hf.str()), strerror(errNo));
} }
/** /**
@@ -338,8 +333,8 @@ public:
* calling this constructor! * calling this constructor!
*/ */
template<typename... Args> template<typename... Args>
SysError(Args &&... args) SysError(const Args &... args)
: SysError(errno, std::forward<Args>(args)...) : SysError(errno, args...)
{ {
} }
}; };
@@ -373,7 +368,7 @@ int handleExceptions(const std::string & programName, std::function<void()> fun)
*/ */
[[gnu::noinline, gnu::cold, noreturn]] void unreachable(std::source_location loc = std::source_location::current()); [[gnu::noinline, gnu::cold, noreturn]] void unreachable(std::source_location loc = std::source_location::current());
#if NIX_UBSAN_ENABLED #if NIX_UBSAN_ENABLED == 1
/* When building with sanitizers, also enable expensive unreachable checks. In /* When building with sanitizers, also enable expensive unreachable checks. In
optimised builds this explicitly invokes UB with std::unreachable for better optimised builds this explicitly invokes UB with std::unreachable for better
optimisations. */ optimisations. */
@@ -392,7 +387,7 @@ namespace windows {
* Unless you need to catch a specific error number, don't catch this in * Unless you need to catch a specific error number, don't catch this in
* portable code. Catch `SystemError` instead. * portable code. Catch `SystemError` instead.
*/ */
class WinError : public SystemError class WinError : public CloneableError<WinError, SystemError>
{ {
public: public:
DWORD lastError; DWORD lastError;
@@ -403,14 +398,12 @@ public:
* information to the message. * information to the message.
*/ */
template<typename... Args> template<typename... Args>
WinError(DWORD lastError, Args &&... args) WinError(DWORD lastError, const Args &... args)
: SystemError( : CloneableError(std::error_code(lastError, std::system_category()), "")
Disambig{},
std::error_code(lastError, std::system_category()),
renderError(lastError),
std::forward<Args>(args)...)
, lastError(lastError) , lastError(lastError)
{ {
auto hf = HintFmt(args...);
err.msg = HintFmt("%1%: %2%", Uncolored(hf.str()), renderError(lastError));
} }
/** /**
@@ -420,14 +413,14 @@ public:
* before calling this constructor! * before calling this constructor!
*/ */
template<typename... Args> template<typename... Args>
WinError(Args &&... args) WinError(const Args &... args)
: WinError(GetLastError(), std::forward<Args>(args)...) : WinError(GetLastError(), args...)
{ {
} }
private: private:
static std::string renderError(DWORD lastError); std::string renderError(DWORD lastError);
}; };
} // namespace windows } // namespace windows
@@ -80,7 +80,7 @@ std::set<ExperimentalFeature> parseFeatures(const StringSet &);
* An experimental feature was required for some (experimental) * An experimental feature was required for some (experimental)
* operation, but was not enabled. * operation, but was not enabled.
*/ */
class MissingExperimentalFeature : public Error class MissingExperimentalFeature final : public CloneableError<MissingExperimentalFeature, Error>
{ {
public: public:
/** /**
@@ -75,7 +75,7 @@ namespace linux {
* *
* @see https://man7.org/linux/man-pages/man2/openat2.2.html * @see https://man7.org/linux/man-pages/man2/openat2.2.html
* @see https://man7.org/linux/man-pages/man2/open_how.2type.html * @see https://man7.org/linux/man-pages/man2/open_how.2type.html
* v*
* @param flags O_* flags * @param flags O_* flags
* @param mode Mode for O_{CREAT,TMPFILE} * @param mode Mode for O_{CREAT,TMPFILE}
* @param resolve RESOLVE_* flags * @param resolve RESOLVE_* flags
+8 -6
View File
@@ -189,19 +189,21 @@ Path readLink(const Path & path);
*/ */
std::filesystem::path readLink(const std::filesystem::path & path); std::filesystem::path readLink(const std::filesystem::path & path);
#ifdef _WIN32
namespace windows {
/** /**
* Get the path associated with a file descriptor. * Get the path associated with a file handle.
* *
* @note One MUST only use this for error handling, because it creates * @note One MUST only use this for error handling, because it creates
* TOCTOU issues. We don't mind if error messages point to out of date * TOCTOU issues. We don't mind if error messages point to out of date
* paths (that is a rather trivial TOCTOU --- the error message is best * paths (that is a rather trivial TOCTOU --- the error message is best
* effort) but for anything else we do. * effort) but for anything else we do.
*
* @note this function will clobber `errno` (Unix) / "last error"
* (Windows), so care must be used to get those error codes, then call
* this, then build a `SysError` / `WinError` with the saved error code.
*/ */
std::filesystem::path descriptorToPath(Descriptor fd); std::filesystem::path handleToPath(Descriptor handle);
} // namespace windows
#endif
/** /**
* Open a `Descriptor` with read-only access to the given directory. * Open a `Descriptor` with read-only access to the given directory.
+1 -6
View File
@@ -2,12 +2,7 @@
include_dirs = [ include_directories('../..') ] include_dirs = [ include_directories('../..') ]
config_pub_h = configure_file( headers = files(
configuration : configdata_pub,
output : 'config.hh',
)
headers = [ config_pub_h ] + files(
'abstract-setting-to-json.hh', 'abstract-setting-to-json.hh',
'alignment.hh', 'alignment.hh',
'ansicolor.hh', 'ansicolor.hh',
+2 -2
View File
@@ -133,14 +133,14 @@ std::pair<int, std::string> runProgram(RunOptions && options);
void runProgram2(const RunOptions & options); void runProgram2(const RunOptions & options);
class ExecError : public Error class ExecError final : public CloneableError<ExecError, Error>
{ {
public: public:
int status; int status;
template<typename... Args> template<typename... Args>
ExecError(int status, const Args &... args) ExecError(int status, const Args &... args)
: Error(args...) : CloneableError(args...)
, status(status) , status(status)
{ {
} }
@@ -231,19 +231,19 @@ ref<SourceAccessor> makeEmptySourceAccessor();
*/ */
MakeError(RestrictedPathError, Error); MakeError(RestrictedPathError, Error);
struct SymlinkNotAllowed : public Error struct SymlinkNotAllowed final : public CloneableError<SymlinkNotAllowed, Error>
{ {
CanonPath path; CanonPath path;
SymlinkNotAllowed(CanonPath path) SymlinkNotAllowed(CanonPath path)
: Error("relative path '%s' points to a symlink, which is not allowed", path.rel()) : CloneableError("relative path '%s' points to a symlink, which is not allowed", path.rel())
, path(std::move(path)) , path(std::move(path))
{ {
} }
template<typename... Args> template<typename... Args>
SymlinkNotAllowed(CanonPath path, const std::string & fs, Args &&... args) SymlinkNotAllowed(CanonPath path, const std::string & fs, Args &&... args)
: Error(fs, std::forward<Args>(args)...) : CloneableError(fs, std::forward<Args>(args)...)
, path(std::move(path)) , path(std::move(path))
{ {
} }
+4 -11
View File
@@ -16,8 +16,7 @@ cxx = meson.get_compiler('cpp')
subdir('nix-meson-build-support/deps-lists') subdir('nix-meson-build-support/deps-lists')
configdata_pub = configuration_data() configdata = configuration_data()
configdata_priv = configuration_data()
deps_private_maybe_subproject = [] deps_private_maybe_subproject = []
deps_public_maybe_subproject = [] deps_public_maybe_subproject = []
@@ -35,15 +34,9 @@ check_funcs = [
foreach funcspec : check_funcs foreach funcspec : check_funcs
define_name = 'HAVE_' + funcspec[0].underscorify().to_upper() define_name = 'HAVE_' + funcspec[0].underscorify().to_upper()
define_value = cxx.has_function(funcspec[0]).to_int() define_value = cxx.has_function(funcspec[0]).to_int()
configdata_priv.set(define_name, define_value, description : funcspec[1]) configdata.set(define_name, define_value, description : funcspec[1])
endforeach endforeach
configdata_pub.set(
'NIX_UBSAN_ENABLED',
('undefined' in get_option('b_sanitize')).to_int(),
description : 'Whether nix has been built with UBSan enabled',
)
subdir('nix-meson-build-support/libatomic') subdir('nix-meson-build-support/libatomic')
if host_machine.system() == 'windows' if host_machine.system() == 'windows'
@@ -111,7 +104,7 @@ cpuid = dependency(
version : '>= 0.7.0', version : '>= 0.7.0',
required : cpuid_required, required : cpuid_required,
) )
configdata_priv.set('HAVE_LIBCPUID', cpuid.found().to_int()) configdata.set('HAVE_LIBCPUID', cpuid.found().to_int())
deps_private += cpuid deps_private += cpuid
nlohmann_json = dependency('nlohmann_json', version : '>= 3.9') nlohmann_json = dependency('nlohmann_json', version : '>= 3.9')
@@ -120,7 +113,7 @@ deps_public += nlohmann_json
cxx = meson.get_compiler('cpp') cxx = meson.get_compiler('cpp')
config_priv_h = configure_file( config_priv_h = configure_file(
configuration : configdata_priv, configuration : configdata,
output : 'util-config-private.hh', output : 'util-config-private.hh',
) )
+1 -1
View File
@@ -170,7 +170,7 @@ SourceAccessor::DirEntries PosixSourceAccessor::readDirectory(const CanonPath &
if (e.code() == std::errc::permission_denied || e.code() == std::errc::operation_not_permitted) if (e.code() == std::errc::permission_denied || e.code() == std::errc::operation_not_permitted)
return std::nullopt; return std::nullopt;
else else
throw SystemError(e.code(), "getting status of '%s'", PathFmt(entry.path())); throw;
} }
}(); }();
res.emplace(entry.path().filename().string(), type); res.emplace(entry.path().filename().string(), type);
+4 -8
View File
@@ -49,8 +49,7 @@ void readFull(int fd, char * buf, size_t count)
pollFD(fd, POLLIN); pollFD(fd, POLLIN);
continue; continue;
} }
auto savedErrno = errno; throw SysError("reading from file");
throw SysError(savedErrno, "reading from file %s", PathFmt(descriptorToPath(fd)));
} }
if (res == 0) if (res == 0)
throw EndOfFile("unexpected end-of-file"); throw EndOfFile("unexpected end-of-file");
@@ -73,8 +72,7 @@ void writeFull(int fd, std::string_view s, bool allowInterrupts)
pollFD(fd, POLLOUT); pollFD(fd, POLLOUT);
continue; continue;
} }
auto savedErrno = errno; throw SysError("writing to file");
throw SysError(savedErrno, "writing to file %s", PathFmt(descriptorToPath(fd)));
} }
if (res > 0) if (res > 0)
s.remove_prefix(res); s.remove_prefix(res);
@@ -97,10 +95,8 @@ std::string readLine(int fd, bool eofOk, char terminator)
pollFD(fd, POLLIN); pollFD(fd, POLLIN);
continue; continue;
} }
default: { default:
auto savedErrno = errno; throw SysError("reading a line");
throw SysError(savedErrno, "reading a line from %s", PathFmt(descriptorToPath(fd)));
}
} }
} else if (rd == 0) { } else if (rd == 0) {
if (eofOk) if (eofOk)
+13 -24
View File
@@ -71,10 +71,8 @@ void unix::fchmodatTryNoFollow(Descriptor dirFd, const CanonPath & path, mode_t
if (res < 0) { if (res < 0) {
if (errno == ENOSYS) if (errno == ENOSYS)
fchmodat2Unsupported.test_and_set(); fchmodat2Unsupported.test_and_set();
else { else
auto savedErrno = errno; throw SysError("fchmodat2 '%s' relative to parent directory", path.rel());
throw SysError(savedErrno, "fchmodat2 %s", PathFmt(descriptorToPath(dirFd) / path.rel()));
}
} else } else
return; return;
} }
@@ -82,13 +80,10 @@ void unix::fchmodatTryNoFollow(Descriptor dirFd, const CanonPath & path, mode_t
#ifdef __linux__ #ifdef __linux__
AutoCloseFD pathFd = ::openat(dirFd, path.rel_c_str(), O_PATH | O_NOFOLLOW | O_CLOEXEC); AutoCloseFD pathFd = ::openat(dirFd, path.rel_c_str(), O_PATH | O_NOFOLLOW | O_CLOEXEC);
if (!pathFd) { if (!pathFd)
auto savedErrno = errno;
throw SysError( throw SysError(
savedErrno, "opening '%s' relative to parent directory to get an O_PATH file descriptor (fchmodat2 is unsupported)",
"opening %s to get an O_PATH file descriptor (fchmodat2 is unsupported)", path.rel());
PathFmt(descriptorToPath(dirFd) / path.rel()));
}
struct ::stat st; struct ::stat st;
/* Possible since https://github.com/torvalds/linux/commit/55815f70147dcfa3ead5738fd56d3574e2e3c1c2 (3.6) */ /* Possible since https://github.com/torvalds/linux/commit/55815f70147dcfa3ead5738fd56d3574e2e3c1c2 (3.6) */
@@ -96,7 +91,7 @@ void unix::fchmodatTryNoFollow(Descriptor dirFd, const CanonPath & path, mode_t
throw SysError("statting '%s' relative to parent directory via O_PATH file descriptor", path.rel()); throw SysError("statting '%s' relative to parent directory via O_PATH file descriptor", path.rel());
if (S_ISLNK(st.st_mode)) if (S_ISLNK(st.st_mode))
throw SysError(EOPNOTSUPP, "can't change mode of symlink %s", PathFmt(descriptorToPath(dirFd) / path.rel())); throw SysError(EOPNOTSUPP, "can't change mode of symlink '%s' relative to parent directory", path.rel());
static std::atomic_flag dontHaveProc{}; static std::atomic_flag dontHaveProc{};
if (!dontHaveProc.test()) { if (!dontHaveProc.test()) {
@@ -106,11 +101,8 @@ void unix::fchmodatTryNoFollow(Descriptor dirFd, const CanonPath & path, mode_t
if (int res = ::chmod(selfProcFdPath.c_str(), mode); res == -1) { if (int res = ::chmod(selfProcFdPath.c_str(), mode); res == -1) {
if (errno == ENOENT) if (errno == ENOENT)
dontHaveProc.test_and_set(); dontHaveProc.test_and_set();
else { else
auto savedErrno = errno; throw SysError("chmod '%s' ('%s' relative to parent directory)", selfProcFdPath, path);
throw SysError(
savedErrno, "chmod %s (%s)", selfProcFdPath, PathFmt(descriptorToPath(dirFd) / path.rel()));
}
} else } else
return; return;
} }
@@ -130,10 +122,8 @@ void unix::fchmodatTryNoFollow(Descriptor dirFd, const CanonPath & path, mode_t
#endif #endif
); );
if (res == -1) { if (res == -1)
auto savedErrno = errno; throw SysError("fchmodat '%s' relative to parent directory", path.rel());
throw SysError(savedErrno, "fchmodat %s", PathFmt(descriptorToPath(dirFd) / path.rel()));
}
} }
static Descriptor static Descriptor
@@ -216,10 +206,9 @@ OsString readLinkAt(Descriptor dirFd, const CanonPath & path)
checkInterrupt(); checkInterrupt();
buf.resize(bufSize); buf.resize(bufSize);
ssize_t rlSize = ::readlinkat(dirFd, path.rel_c_str(), buf.data(), bufSize); ssize_t rlSize = ::readlinkat(dirFd, path.rel_c_str(), buf.data(), bufSize);
if (rlSize == -1) { if (rlSize == -1)
auto savedErrno = errno; throw SysError("reading symbolic link '%1%' relative to parent directory", path.rel());
throw SysError(savedErrno, "reading symbolic link %1%", PathFmt(descriptorToPath(dirFd) / path.rel())); else if (rlSize < bufSize)
} else if (rlSize < bufSize)
return {buf.data(), static_cast<std::size_t>(rlSize)}; return {buf.data(), static_cast<std::size_t>(rlSize)};
} }
} }
-25
View File
@@ -46,31 +46,6 @@ Descriptor openNewFileForWrite(const std::filesystem::path & path, mode_t mode,
return open(path.c_str(), flags, mode); return open(path.c_str(), flags, mode);
} }
std::filesystem::path descriptorToPath(Descriptor fd)
{
if (fd == STDIN_FILENO)
return "<stdin>";
if (fd == STDOUT_FILENO)
return "<stdout>";
if (fd == STDERR_FILENO)
return "<stderr>";
#if defined(__linux__)
try {
return readLink("/proc/self/fd/" + std::to_string(fd));
} catch (SystemError &) {
}
#elif HAVE_F_GETPATH
/* F_GETPATH requires PATH_MAX buffer per POSIX */
char buf[PATH_MAX];
if (fcntl(fd, F_GETPATH, buf) != -1)
return buf;
#endif
/* Fallback for unknown fd or unsupported platform */
return "<fd " + std::to_string(fd) + ">";
}
std::filesystem::path defaultTempDir() std::filesystem::path defaultTempDir()
{ {
return getEnvNonEmpty("TMPDIR").value_or("/tmp"); return getEnvNonEmpty("TMPDIR").value_or("/tmp");
-6
View File
@@ -8,12 +8,6 @@ configdata_unix.set(
description : 'Optionally used for changing the files and symlinks.', description : 'Optionally used for changing the files and symlinks.',
) )
configdata_unix.set(
'HAVE_F_GETPATH',
cxx.has_header_symbol('fcntl.h', 'F_GETPATH').to_int(),
description : 'Optionally used for getting the path of a file descriptor (macOS).',
)
# Check for each of these functions, and create a define like `#define # Check for each of these functions, and create a define like `#define
# HAVE_CLOSE_RANGE 1`. # HAVE_CLOSE_RANGE 1`.
check_funcs_unix = [ check_funcs_unix = [
+2 -2
View File
@@ -45,9 +45,9 @@ void writeFull(HANDLE handle, std::string_view s, bool allowInterrupts)
checkInterrupt(); checkInterrupt();
DWORD res; DWORD res;
if (!WriteFile(handle, s.data(), s.size(), &res, NULL)) { if (!WriteFile(handle, s.data(), s.size(), &res, NULL)) {
// Do this because `descriptorToPath` will overwrite the last error. // Do this because `handleToPath` will overwrite the last error.
auto lastError = GetLastError(); auto lastError = GetLastError();
auto path = descriptorToPath(handle); auto path = handleToPath(handle);
throw WinError(lastError, "writing to file %d:%s", handle, PathFmt(path)); throw WinError(lastError, "writing to file %d:%s", handle, PathFmt(path));
} }
if (res > 0) if (res > 0)
+3 -3
View File
@@ -156,13 +156,13 @@ OsString readSymlinkTarget(HANDLE linkHandle)
size_t path_buf_offset = offsetof(ReparseDataBuffer, SymbolicLinkReparseBuffer.PathBuffer[0]); size_t path_buf_offset = offsetof(ReparseDataBuffer, SymbolicLinkReparseBuffer.PathBuffer[0]);
if (out < path_buf_offset) { if (out < path_buf_offset) {
auto fullPath = descriptorToPath(linkHandle); auto fullPath = handleToPath(linkHandle);
throw WinError( throw WinError(
DWORD{ERROR_REPARSE_TAG_INVALID}, "invalid reparse data for %d:%s", linkHandle, PathFmt(fullPath)); DWORD{ERROR_REPARSE_TAG_INVALID}, "invalid reparse data for %d:%s", linkHandle, PathFmt(fullPath));
} }
if (reparse->ReparseTag != IO_REPARSE_TAG_SYMLINK) { if (reparse->ReparseTag != IO_REPARSE_TAG_SYMLINK) {
auto fullPath = descriptorToPath(linkHandle); auto fullPath = handleToPath(linkHandle);
throw WinError(DWORD{ERROR_REPARSE_TAG_INVALID}, "not a symlink: %d:%s", linkHandle, PathFmt(fullPath)); throw WinError(DWORD{ERROR_REPARSE_TAG_INVALID}, "not a symlink: %d:%s", linkHandle, PathFmt(fullPath));
} }
@@ -179,7 +179,7 @@ OsString readSymlinkTarget(HANDLE linkHandle)
} }
if (path_buf_offset + name_offset + name_length > out) { if (path_buf_offset + name_offset + name_length > out) {
auto fullPath = descriptorToPath(linkHandle); auto fullPath = handleToPath(linkHandle);
throw WinError( throw WinError(
DWORD{ERROR_REPARSE_TAG_INVALID}, "invalid symlink data for %d:%s", linkHandle, PathFmt(fullPath)); DWORD{ERROR_REPARSE_TAG_INVALID}, "invalid symlink data for %d:%s", linkHandle, PathFmt(fullPath));
} }
+1 -1
View File
@@ -83,7 +83,7 @@ void deletePath(const std::filesystem::path & path, uint64_t & bytesFreed)
deletePath(path); deletePath(path);
} }
std::filesystem::path descriptorToPath(Descriptor handle) std::filesystem::path windows::handleToPath(HANDLE handle)
{ {
std::vector<wchar_t> buf(0x100); std::vector<wchar_t> buf(0x100);
DWORD dw = GetFinalPathNameByHandleW(handle, buf.data(), buf.size(), FILE_NAME_OPENED); DWORD dw = GetFinalPathNameByHandleW(handle, buf.data(), buf.size(), FILE_NAME_OPENED);
@@ -43,8 +43,8 @@ void removeOldGenerations(std::filesystem::path dir)
std::string link; std::string link;
try { try {
link = readLink(path); link = readLink(path);
} catch (SystemError & e) { } catch (std::filesystem::filesystem_error & e) {
if (e.is(std::errc::no_such_file_or_directory)) if (e.code() == std::errc::no_such_file_or_directory)
continue; continue;
throw; throw;
} }
+1
View File
@@ -1419,6 +1419,7 @@ static int main_nix_env(int argc, char ** argv)
replaceSymlink(defaultChannelsDir(profilesDirOpts), nixExprPath / "channels"); replaceSymlink(defaultChannelsDir(profilesDirOpts), nixExprPath / "channels");
if (!isRootUser()) if (!isRootUser())
replaceSymlink(rootChannelsDir(profilesDirOpts), nixExprPath / "channels_root"); replaceSymlink(rootChannelsDir(profilesDirOpts), nixExprPath / "channels_root");
} catch (std::filesystem::filesystem_error &) {
} catch (Error &) { } catch (Error &) {
} }
} }
-2
View File
@@ -32,8 +32,6 @@ writeSimpleFlake() {
baseName = builtins.baseNameOf ./.; baseName = builtins.baseNameOf ./.;
root = ./.; root = ./.;
number = 123;
}; };
} }
EOF EOF
-26
View File
@@ -1,26 +0,0 @@
#!/usr/bin/env bash
source ./common.sh
createFlake1
mkdir -p "$flake1Dir/subflake"
cat > "$flake1Dir/subflake/flake.nix" <<EOF
{
outputs = { self }:
let
# Bad, legacy way of getting a flake from an input.
parentFlake = builtins.getFlake (builtins.flakeRefToString { type = "path"; path = self.sourceInfo.outPath; narHash = self.narHash; });
# Better way using a path value.
parentFlake2 = builtins.getFlake ./..;
in {
x = parentFlake.number;
y = parentFlake2.number;
};
}
EOF
git -C "$flake1Dir" add subflake/flake.nix
[[ $(nix eval "$flake1Dir/subflake#x") = 123 ]]
[[ $(nix eval "$flake1Dir/subflake#y") = 123 ]]
-1
View File
@@ -34,7 +34,6 @@ suites += {
'source-paths.sh', 'source-paths.sh',
'old-lockfiles.sh', 'old-lockfiles.sh',
'trace-ifd.sh', 'trace-ifd.sh',
'get-flake.sh',
], ],
'workdir' : meson.current_source_dir(), 'workdir' : meson.current_source_dir(),
} }