studio/cli
2
0
Fork 0
Code Issues Pull Requests Actions Packages Releases 4 Wiki Activity

chore: checkpoint before Python removal

Browse Source
This commit is contained in:
Sienna Meridian Satterwhite
2026-03-26 22:33:59 +00:00
parent 683cec9307
commit e568ddf82a
29972 changed files with 11269302 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
vendor/signal-hook-registry/.cargo-checksum.json vendored Normal file
View File

@@ -0,0 +1 @@
{"files":{".cargo_vcs_info.json":"361ad791d1c8644ed3c8f3681ee707863dfe6355a831984e29b2c4d5549bc56f","Cargo.lock":"642db0d2d67971282b258686fb3f7db492aa920440b1dae543b74051c8920d55","Cargo.toml":"54bcf376404635b6cfc7e20474cc84a756ef5c8b54e2954d3186e44b68854fac","Cargo.toml.orig":"9ecd2e0c16f34b3decc688ddb82b4e886e194e2d94305eee456ba2fdb64f3d3b","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"503558bfefe66ca15e4e3f7955b3cb0ec87fd52f29bf24b336af7bd00e946d5c","README.md":"83d150c85e80ef98abc9a9cd4ffd0ce3d83734f5b332208e611ba1a20cc6e1f3","src/half_lock.rs":"b73a0c35a86ce08f583c241b6fab5ad5b5e2cfef93491af12c5f24251ad76e91","src/lib.rs":"71c67afdcaab442cc75955a6a17e5eb4e17fb725e0db7f8d1930023c680a7204","src/vec_map.rs":"39876dc8381e1823da2f0cfb2a329bf62c13c21eb1857b5b7c4ff84e8c77b50d","tests/unregister_signal.rs":"5baeebbde2bd7e63ae9a1f1e476d33f0bfd368c1edcdab3677de6a62b04f5118"},"package":"c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"}

6
vendor/signal-hook-registry/.cargo_vcs_info.json vendored Normal file
View File

@@ -0,0 +1,6 @@
{
"git": {
"sha1": "4d5fd6a6663be38e70774e4ac733d65916c70951"
},
"path_in_vcs": "signal-hook-registry"
}

120
vendor/signal-hook-registry/Cargo.lock generated vendored Normal file
View File

@@ -0,0 +1,120 @@
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 4
[[package]]
name = "errno"
version = "0.3.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "976dd42dc7e85965fe702eb8164f21f450704bdde31faefd6471dba214cb594e"
dependencies = [
"libc",
"windows-sys",
]
[[package]]
name = "libc"
version = "0.2.172"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
[[package]]
name = "signal-hook"
version = "0.3.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2"
dependencies = [
"libc",
"signal-hook-registry 1.4.3",
]
[[package]]
name = "signal-hook-registry"
version = "1.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c28b4eafe8a2d82f83559ef5941afff1ccba3da8e375c8f148efd75df181bf4f"
dependencies = [
"libc",
]
[[package]]
name = "signal-hook-registry"
version = "1.4.8"
dependencies = [
"errno",
"libc",
"signal-hook",
]
[[package]]
name = "windows-sys"
version = "0.59.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
dependencies = [
"windows-targets",
]
[[package]]
name = "windows-targets"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
dependencies = [
"windows_aarch64_gnullvm",
"windows_aarch64_msvc",
"windows_i686_gnu",
"windows_i686_gnullvm",
"windows_i686_msvc",
"windows_x86_64_gnu",
"windows_x86_64_gnullvm",
"windows_x86_64_msvc",
]
[[package]]
name = "windows_aarch64_gnullvm"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
[[package]]
name = "windows_aarch64_msvc"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
[[package]]
name = "windows_i686_gnu"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
[[package]]
name = "windows_i686_gnullvm"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
[[package]]
name = "windows_i686_msvc"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
[[package]]
name = "windows_x86_64_gnu"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
[[package]]
name = "windows_x86_64_gnullvm"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
[[package]]
name = "windows_x86_64_msvc"
version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"

61
vendor/signal-hook-registry/Cargo.toml vendored Normal file
View File

@@ -0,0 +1,61 @@
# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
#
# When uploading crates to the registry Cargo will automatically
# "normalize" Cargo.toml files for maximal compatibility
# with all versions of Cargo and also rewrite `path` dependencies
# to registry (e.g., crates.io) dependencies.
#
# If you are reading this file be aware that the original Cargo.toml
# will likely look very different (and much more reasonable).
# See Cargo.toml.orig for the original contents.
[package]
rust-version = "1.26"
name = "signal-hook-registry"
version = "1.4.8"
authors = [
"Michal 'vorner' Vaner <vorner@vorner.cz>",
"Masaki Hara <ackie.h.gmai@gmail.com>",
]
build = false
autolib = false
autobins = false
autoexamples = false
autotests = false
autobenches = false
description = "Backend crate for signal-hook"
documentation = "https://docs.rs/signal-hook-registry"
readme = "README.md"
keywords = [
"signal",
"unix",
"daemon",
]
license = "MIT OR Apache-2.0"
repository = "https://github.com/vorner/signal-hook"
[badges.maintenance]
status = "actively-developed"
[badges.travis-ci]
repository = "vorner/signal-hook"
[lib]
name = "signal_hook_registry"
path = "src/lib.rs"
[[test]]
name = "unregister_signal"
path = "tests/unregister_signal.rs"
[dependencies.errno]
version = ">=0.2, <0.4"
[dependencies.libc]
version = "^0.2"
[dev-dependencies.signal-hook]
version = "~0.3"
[lints.clippy]
unnecessary_clippy_cfg = "allow"

201
vendor/signal-hook-registry/LICENSE-APACHE vendored Normal file
View File

@@ -0,0 +1,201 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

25
vendor/signal-hook-registry/LICENSE-MIT vendored Normal file
View File

@@ -0,0 +1,25 @@
Copyright (c) 2017 tokio-jsonrpc developers
Permission is hereby granted, free of charge, to any
person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the
Software without restriction, including without
limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice
shall be included in all copies or substantial portions
of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

25
vendor/signal-hook-registry/README.md vendored Normal file
View File

@@ -0,0 +1,25 @@
# signal-hook-registry
[![Actions Status](https://github.com/vorner/signal-hook/actions/workflows/test.yaml/badge.svg)](https://github.com/vorner/signal-hook/actions)
This is the backend crate for the
[signal-hook](https://crates.io/crates/signal-hook) crate. The general direct
use of this crate is discouraged. See the
[documentation](https://docs.rs/signal-hook-registry) for further details.
## License
Licensed under either of
* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
https://www.apache.org/licenses/LICENSE-2.0)
* MIT license ([LICENSE-MIT](LICENSE-MIT) or
https://opensource.org/license/mit)
at your option.
### Contribution
Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
dual licensed as above, without any additional terms or conditions.

232
vendor/signal-hook-registry/src/half_lock.rs vendored Normal file
View File

@@ -0,0 +1,232 @@
//! The half-lock structure
//!
//! We need a way to protect the structure with configured hooks ‒ a signal may happen in arbitrary
//! thread and needs to read them while another thread might be manipulating the structure.
//!
//! Under ordinary circumstances we would be happy to just use `Mutex<HashMap<c_int, _>>`. However,
//! as we use it in the signal handler, we are severely limited in what we can or can't use. So we
//! choose to implement kind of spin-look thing with atomics.
//!
//! In the reader it is always simply locked and then unlocked, making sure it doesn't disappear
//! while in use.
//!
//! The writer has a separate mutex (that prevents other writers; this is used outside of the
//! signal handler), makes a copy of the data and swaps an atomic pointer to the data structure.
//! But it waits until everything is unlocked (no signal handler has the old data) for dropping the
//! old instance. There's a generation trick to make sure that new signal locks another instance.
//!
//! The downside is, this is an active spin lock at the writer end. However, we assume than:
//!
//! * Signals are one time setup before we actually have threads. We just need to make *sure* we
//! are safe even if this is not true.
//! * Signals are rare, happening at the same time as the write even rarer.
//! * Signals are short, as there is mostly nothing allowed inside them anyway.
//! * Our tool box is severely limited.
//!
//! Therefore this is hopefully reasonable trade-off.
//!
//! # Atomic orderings
//!
//! The whole code uses SeqCst conservatively. Atomics are not used because of performance here and
//! are the minor price around signals anyway. But the comments state which orderings should be
//! enough in practice in case someone wants to get inspired (but do make your own check through
//! them anyway).
use std::isize;
use std::marker::PhantomData;
use std::ops::Deref;
use std::sync::atomic::{self, AtomicPtr, AtomicUsize, Ordering};
use std::sync::{Mutex, MutexGuard, PoisonError};
use std::thread;
use libc;
const YIELD_EVERY: usize = 16;
const MAX_GUARDS: usize = (isize::MAX) as usize;
pub(crate) struct ReadGuard<'a, T: 'a> {
data: &'a T,
lock: &'a AtomicUsize,
}
impl<'a, T> Deref for ReadGuard<'a, T> {
type Target = T;
fn deref(&self) -> &T {
self.data
}
}
impl<'a, T> Drop for ReadGuard<'a, T> {
fn drop(&mut self) {
// We effectively unlock; Release would be enough.
self.lock.fetch_sub(1, Ordering::SeqCst);
}
}
pub(crate) struct WriteGuard<'a, T: 'a> {
_guard: MutexGuard<'a, ()>,
lock: &'a HalfLock<T>,
data: &'a T,
}
impl<'a, T> WriteGuard<'a, T> {
pub(crate) fn store(&mut self, val: T) {
// Move to the heap and convert to raw pointer for AtomicPtr.
let new = Box::into_raw(Box::new(val));
self.data = unsafe { &*new };
// We can just put the new value in here safely, we worry only about dropping the old one.
// Release might (?) be enough, to "upload" the data.
let old = self.lock.data.swap(new, Ordering::SeqCst);
// Now we make sure there's no reader having the old data.
self.lock.write_barrier();
drop(unsafe { Box::from_raw(old) });
}
}
impl<'a, T> Deref for WriteGuard<'a, T> {
type Target = T;
fn deref(&self) -> &T {
// Protected by that mutex
self.data
}
}
pub(crate) struct HalfLock<T> {
// We conceptually contain an instance of T
_t: PhantomData<T>,
// The actual data as a pointer.
data: AtomicPtr<T>,
// The generation of the data. Influences which slot of the lock counter we use.
generation: AtomicUsize,
// How many active locks are there?
lock: [AtomicUsize; 2],
// Mutex for the writers; only one writer.
write_mutex: Mutex<()>,
}
impl<T> HalfLock<T> {
pub(crate) fn new(data: T) -> Self {
// Move to the heap so we can safely point there. Then convert to raw pointer as AtomicPtr
// operates on raw pointers. The AtomicPtr effectively acts like Box for us semantically.
let ptr = Box::into_raw(Box::new(data));
Self {
_t: PhantomData,
data: AtomicPtr::new(ptr),
generation: AtomicUsize::new(0),
lock: [AtomicUsize::new(0), AtomicUsize::new(0)],
write_mutex: Mutex::new(()),
}
}
pub(crate) fn read(&self) -> ReadGuard<'_, T> {
// Relaxed should be enough; we only pick one or the other slot and the writer observes
// that both were 0 at some time. So the actual value doesn't really matter for safety,
// only the changing improves the performance.
let gen = self.generation.load(Ordering::SeqCst);
let lock = &self.lock[gen % 2];
// Effectively locking something, acquire should be enough.
let guard_cnt = lock.fetch_add(1, Ordering::SeqCst);
// This is to prevent overflowing the counter in some degenerate cases, which could lead to
// UB (freeing data while still in use). However, as this data structure is used only
// internally and it's not possible to leak the guard and the guard itself takes some
// memory, it should be really impossible to trigger this case. Still, we include it from
// abundance of caution.
//
// This technically is not fully correct as enough threads being in between here and the
// abort below could still overflow it and it could get freed for some *other* thread, but
// that would mean having too many active threads to fit into RAM too and is even more
// absurd corner case than the above.
if guard_cnt > MAX_GUARDS {
unsafe { libc::abort() };
}
// Acquire should be enough; we need to "download" the data, paired with the swap on the
// same pointer.
let data = self.data.load(Ordering::SeqCst);
// Safe:
// * It did point to valid data when put in.
// * Protected by lock, so still valid.
let data = unsafe { &*data };
ReadGuard { data, lock }
}
fn update_seen(&self, seen_zero: &mut [bool; 2]) {
for (seen, slot) in seen_zero.iter_mut().zip(&self.lock) {
*seen = *seen || slot.load(Ordering::SeqCst) == 0;
}
}
fn write_barrier(&self) {
// Do a first check of seeing zeroes before we switch the generation. At least one of them
// should be zero by now, due to having drained the generation before leaving the previous
// writer.
let mut seen_zero = [false; 2];
self.update_seen(&mut seen_zero);
// By switching the generation to the other slot, we make sure the currently active starts
// draining while the other will start filling up.
self.generation.fetch_add(1, Ordering::SeqCst); // Overflow is fine.
let mut iter = 0usize;
while !seen_zero.iter().all(|s| *s) {
iter = iter.wrapping_add(1);
// Be somewhat less aggressive while looping, switch to the other threads if possible.
if cfg!(not(miri)) {
if iter % YIELD_EVERY == 0 {
thread::yield_now();
} else {
// Replaced by hint::spin_loop, but we want to support older compiler
#[allow(deprecated)]
atomic::spin_loop_hint();
}
}
self.update_seen(&mut seen_zero);
}
}
pub(crate) fn write(&self) -> WriteGuard<'_, T> {
// While it's possible the user code panics, our code in store doesn't and the data gets
// swapped atomically. So if it panics, nothing gets changed, therefore poisons are of no
// interest here.
let guard = self
.write_mutex
.lock()
.unwrap_or_else(PoisonError::into_inner);
// Relaxed should be enough, as we are under the same mutex that was used to get the data
// in.
let data = self.data.load(Ordering::SeqCst);
// Safe:
// * Stored as valid data
// * Only this method, protected by mutex, can change the pointer, so it didn't go away.
let data = unsafe { &*data };
WriteGuard {
data,
_guard: guard,
lock: self,
}
}
}
impl<T> Drop for HalfLock<T> {
fn drop(&mut self) {
// During drop we are sure there are no other borrows of the data so we are free to just
// drop it. Also, the drop impl won't be called in practice in our case, as it is used
// solely as a global variable, but we provide it for completeness and tests anyway.
//
// unsafe: the pointer in there is always valid, we just take the last instance out.
unsafe {
// Acquire should be enough.
let data = Box::from_raw(self.data.load(Ordering::SeqCst));
drop(data);
}
}
}

870
vendor/signal-hook-registry/src/lib.rs vendored Normal file
View File

@@ -0,0 +1,870 @@
#![doc(test(attr(deny(warnings))))]
#![warn(missing_docs)]
#![allow(unknown_lints, renamed_and_remove_lints, bare_trait_objects)]
//! Backend of the [signal-hook] crate.
//!
//! The [signal-hook] crate tries to provide an API to the unix signals, which are a global
//! resource. Therefore, it is desirable an application contains just one version of the crate
//! which manages this global resource. But that makes it impossible to make breaking changes in
//! the API.
//!
//! Therefore, this crate provides very minimal and low level API to the signals that is unlikely
//! to have to change, while there may be multiple versions of the [signal-hook] that all use this
//! low-level API to provide different versions of the high level APIs.
//!
//! It is also possible some other crates might want to build a completely different API. This
//! split allows these crates to still reuse the same low-level routines in this crate instead of
//! going to the (much more dangerous) unix calls.
//!
//! # What this crate provides
//!
//! The only thing this crate does is multiplexing the signals. An application or library can add
//! or remove callbacks and have multiple callbacks for the same signal.
//!
//! It handles dispatching the callbacks and managing them in a way that uses only the
//! [async-signal-safe] functions inside the signal handler. Note that the callbacks are still run
//! inside the signal handler, so it is up to the caller to ensure they are also
//! [async-signal-safe].
//!
//! # What this is for
//!
//! This is a building block for other libraries creating reasonable abstractions on top of
//! signals. The [signal-hook] is the generally preferred way if you need to handle signals in your
//! application and provides several safe patterns of doing so.
//!
//! # Rust version compatibility
//!
//! Currently builds on 1.26.0 an newer and this is very unlikely to change. However, tests
//! require dependencies that don't build there, so tests need newer Rust version (they are run on
//! stable).
//!
//! Note that this ancient version of rustc no longer compiles current versions of `libc`. If you
//! want to use rustc this old, you need to force your dependency resolution to pick old enough
//! version of `libc` (`0.2.156` was found to work, but newer ones may too).
//!
//! # Portability
//!
//! This crate includes a limited support for Windows, based on `signal`/`raise` in the CRT.
//! There are differences in both API and behavior:
//!
//! - Due to lack of `siginfo_t`, we don't provide `register_sigaction` or `register_unchecked`.
//! - Due to lack of signal blocking, there's a race condition.
//! After the call to `signal`, there's a moment where we miss a signal.
//! That means when you register a handler, there may be a signal which invokes
//! neither the default handler or the handler you register.
//! - Handlers registered by `signal` in Windows are cleared on first signal.
//! To match behavior in other platforms, we re-register the handler each time the handler is
//! called, but there's a moment where we miss a handler.
//! That means when you receive two signals in a row, there may be a signal which invokes
//! the default handler, nevertheless you certainly have registered the handler.
//!
//! [signal-hook]: https://docs.rs/signal-hook
//! [async-signal-safe]: http://www.man7.org/linux/man-pages/man7/signal-safety.7.html
extern crate errno;
extern crate libc;
mod half_lock;
mod vec_map;
use std::io::Error;
use std::mem;
use std::ptr;
use std::sync::atomic::{AtomicPtr, Ordering};
// Once::new is now a const-fn. But it is not stable in all the rustc versions we want to support
// yet.
#[allow(deprecated)]
use std::sync::ONCE_INIT;
use std::sync::{Arc, Once};
use errno::Errno;
#[cfg(not(windows))]
use libc::{c_int, c_void, sigaction, siginfo_t};
#[cfg(windows)]
use libc::{c_int, sighandler_t};
#[cfg(not(windows))]
use libc::{SIGFPE, SIGILL, SIGKILL, SIGSEGV, SIGSTOP};
#[cfg(windows)]
use libc::{SIGFPE, SIGILL, SIGSEGV};
use half_lock::HalfLock;
use vec_map::VecMap;
// These constants are not defined in the current version of libc, but it actually
// exists in Windows CRT.
#[cfg(windows)]
const SIG_DFL: sighandler_t = 0;
#[cfg(windows)]
const SIG_IGN: sighandler_t = 1;
#[cfg(windows)]
const SIG_GET: sighandler_t = 2;
#[cfg(windows)]
const SIG_ERR: sighandler_t = !0;
// To simplify implementation. Not to be exposed.
#[cfg(windows)]
#[allow(non_camel_case_types)]
struct siginfo_t;
// # Internal workings
//
// This uses a form of RCU. There's an atomic pointer to the current action descriptors (in the
// form of IndependentArcSwap, to be able to track what, if any, signal handlers still use the
// version). A signal handler takes a copy of the pointer and calls all the relevant actions.
//
// Modifications to that are protected by a mutex, to avoid juggling multiple signal handlers at
// once (eg. not calling sigaction concurrently). This should not be a problem, because modifying
// the signal actions should be initialization only anyway. To avoid all allocations and also
// deallocations inside the signal handler, after replacing the pointer, the modification routine
// needs to busy-wait for the reference count on the old pointer to drop to 1 and take ownership ‒
// that way the one deallocating is the modification routine, outside of the signal handler.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
struct ActionId(u128);
/// An ID of registered action.
///
/// This is returned by all the registration routines and can be used to remove the action later on
/// with a call to [`unregister`].
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct SigId {
signal: c_int,
action: ActionId,
}
// This should be dyn Fn(...), but we want to support Rust 1.26.0 and that one doesn't allow dyn
// yet.
#[allow(unknown_lints, bare_trait_objects)]
type Action = Fn(&siginfo_t) + Send + Sync;
#[derive(Clone)]
struct Slot {
prev: Prev,
// Actions are stored and executed in the order they were registered.
actions: VecMap<ActionId, Arc<Action>>,
}
impl Slot {
#[cfg(windows)]
fn new(signal: libc::c_int) -> Result<Self, Error> {
let old = unsafe { libc::signal(signal, handler as *const () as sighandler_t) };
if old == SIG_ERR {
return Err(Error::last_os_error());
}
Ok(Slot {
prev: Prev { signal, info: old },
actions: VecMap::new(),
})
}
#[cfg(not(windows))]
fn new(signal: libc::c_int) -> Result<Self, Error> {
// C data structure, expected to be zeroed out.
let mut new: libc::sigaction = unsafe { mem::zeroed() };
// Note: AIX fixed their naming in libc 0.2.171.
//
// However, if we mandate that _for everyone_, other systems fail to compile on old Rust
// versions (eg. 1.26.0), because they are no longer able to compile this new libc.
//
// There doesn't seem to be a way to make Cargo force the dependency for only one target
// (it doesn't compile the ones it doesn't need, but it stills considers the other targets
// for version resolution).
//
// Therefore, we let the user have freedom - if they want AIX, they can upgrade to new
// enough libc. If they want ancient rustc, they can force older versions of libc.
//
// See #169.
new.sa_sigaction = handler as *const () as usize; // If it doesn't compile on AIX, upgrade the libc dependency
#[cfg(target_os = "nto")]
let flags = 0;
// SA_RESTART is not supported by qnx https://www.qnx.com/support/knowledgebase.html?id=50130000000SmiD
#[cfg(not(target_os = "nto"))]
let flags = libc::SA_RESTART;
// Android is broken and uses different int types than the rest (and different depending on
// the pointer width). This converts the flags to the proper type no matter what it is on
// the given platform.
#[allow(unused_assignments)]
let mut siginfo = flags;
siginfo = libc::SA_SIGINFO as _;
let flags = flags | siginfo;
new.sa_flags = flags as _;
// C data structure, expected to be zeroed out.
let mut old: libc::sigaction = unsafe { mem::zeroed() };
// FFI ‒ pointers are valid, it doesn't take ownership.
if unsafe { libc::sigaction(signal, &new, &mut old) } != 0 {
return Err(Error::last_os_error());
}
Ok(Slot {
prev: Prev { signal, info: old },
actions: VecMap::new(),
})
}
}
#[derive(Clone)]
struct SignalData {
signals: VecMap<c_int, Slot>,
next_id: u128,
}
#[derive(Clone)]
struct Prev {
signal: c_int,
#[cfg(windows)]
info: sighandler_t,
#[cfg(not(windows))]
info: sigaction,
}
impl Prev {
#[cfg(windows)]
fn detect(signal: c_int) -> Result<Self, Error> {
let old = unsafe { libc::signal(signal, SIG_GET) };
if old == SIG_ERR {
return Err(Error::last_os_error());
}
Ok(Prev { signal, info: old })
}
#[cfg(not(windows))]
fn detect(signal: c_int) -> Result<Self, Error> {
// C data structure, expected to be zeroed out.
let mut old: libc::sigaction = unsafe { mem::zeroed() };
// FFI ‒ pointers are valid, it doesn't take ownership.
if unsafe { libc::sigaction(signal, ptr::null(), &mut old) } != 0 {
return Err(Error::last_os_error());
}
Ok(Prev { signal, info: old })
}
#[cfg(windows)]
fn execute(&self, sig: c_int) {
let fptr = self.info;
if fptr != 0 && fptr != SIG_DFL && fptr != SIG_IGN {
// `sighandler_t` is an integer type. Transmuting it directly from an integer to a
// function pointer seems dubious w.r.t. pointer provenance -- at least Miri complains
// about it. Casting to a raw pointer first side-steps the issue.
let fptr = fptr as *mut ();
// FFI ‒ calling the original signal handler.
unsafe {
let action = mem::transmute::<*mut (), extern "C" fn(c_int)>(fptr);
action(sig);
}
}
}
#[cfg(not(windows))]
// libc re-exports the core::ffi::c_void on rustc >= 1.30, else defines its own type
// cfg_attr is needed because the `allow(clippy::lint)` syntax was added in Rust 1.31
#[cfg_attr(clippy, allow(clippy::incompatible_msrv))]
unsafe fn execute(&self, sig: c_int, info: *mut siginfo_t, data: *mut c_void) {
let fptr = self.info.sa_sigaction;
if fptr != 0 && fptr != libc::SIG_DFL && fptr != libc::SIG_IGN {
// `sa_sigaction` is usually stored as integer type. Transmuting it directly from an
// integer to a function pointer seems dubious w.r.t. pointer provenance -- at least
// Miri complains about it. Casting to a raw pointer first side-steps the issue.
let fptr = fptr as *mut ();
// Android is broken and uses different int types than the rest (and different
// depending on the pointer width). This converts the flags to the proper type no
// matter what it is on the given platform.
//
// The trick is to create the same-typed variable as the sa_flags first and then
// set it to the proper value (does Rust have a way to copy a type in a different
// way?)
#[allow(unused_assignments)]
let mut siginfo = self.info.sa_flags;
siginfo = libc::SA_SIGINFO as _;
if self.info.sa_flags & siginfo == 0 {
let action = mem::transmute::<*mut (), extern "C" fn(c_int)>(fptr);
action(sig);
} else {
type SigAction = extern "C" fn(c_int, *mut siginfo_t, *mut c_void);
let action = mem::transmute::<*mut (), SigAction>(fptr);
action(sig, info, data);
}
}
}
}
/// Lazy-initiated data structure with our global variables.
///
/// Used inside a structure to cut down on boilerplate code to lazy-initialize stuff. We don't dare
/// use anything fancy like lazy-static or once-cell, since we are not sure they are
/// async-signal-safe in their access. Our code uses the [Once], but only on the write end outside
/// of signal handler. The handler assumes it has already been initialized.
struct GlobalData {
/// The data structure describing what needs to be run for each signal.
data: HalfLock<SignalData>,
/// A fallback to fight/minimize a race condition during signal initialization.
///
/// See the comment inside [`register_unchecked_impl`].
race_fallback: HalfLock<Option<Prev>>,
}
static GLOBAL_DATA: AtomicPtr<GlobalData> = AtomicPtr::new(ptr::null_mut());
#[allow(deprecated)]
static GLOBAL_INIT: Once = ONCE_INIT;
impl GlobalData {
fn get() -> &'static Self {
let data = GLOBAL_DATA.load(Ordering::Acquire);
// # Safety
//
// * The data actually does live forever - created by Box::into_raw.
// * It is _never_ modified (apart for interior mutability, but that one is fine).
unsafe { data.as_ref().expect("We shall be set up already") }
}
fn ensure() -> &'static Self {
GLOBAL_INIT.call_once(|| {
let data = Box::into_raw(Box::new(GlobalData {
data: HalfLock::new(SignalData {
signals: VecMap::new(),
next_id: 1,
}),
race_fallback: HalfLock::new(None),
}));
let old = GLOBAL_DATA.swap(data, Ordering::Release);
assert!(old.is_null());
});
Self::get()
}
}
#[cfg(windows)]
extern "C" fn handler(sig: c_int) {
let _errno = ErrnoGuard::new();
if sig != SIGFPE {
// Windows CRT `signal` resets handler every time, unless for SIGFPE.
// Reregister the handler to retain maximal compatibility.
// Problems:
// - It's racy. But this is inevitably racy in Windows.
// - Interacts poorly with handlers outside signal-hook-registry.
let old = unsafe { libc::signal(sig, handler as *const () as sighandler_t) };
if old == SIG_ERR {
// MSDN doesn't describe which errors might occur,
// but we can tell from the Linux manpage that
// EINVAL (invalid signal number) is mostly the only case.
// Therefore, this branch must not occur.
// In any case we can do nothing useful in the signal handler,
// so we're going to abort silently.
unsafe {
libc::abort();
}
}
}
let globals = GlobalData::get();
let fallback = globals.race_fallback.read();
let sigdata = globals.data.read();
if let Some(ref slot) = sigdata.signals.get(&sig) {
slot.prev.execute(sig);
for action in slot.actions.values() {
action(&siginfo_t);
}
} else if let Some(prev) = fallback.as_ref() {
// In case we get called but don't have the slot for this signal set up yet, we are under
// the race condition. We may have the old signal handler stored in the fallback
// temporarily.
if sig == prev.signal {
prev.execute(sig);
}
// else -> probably should not happen, but races with other threads are possible so
// better safe
}
}
#[cfg(not(windows))]
// libc re-exports the core::ffi::c_void on rustc >= 1.30, else defines its own type
// cfg_attr is needed because the `allow(clippy::lint)` syntax was added in Rust 1.31
#[cfg_attr(clippy, allow(clippy::incompatible_msrv))]
extern "C" fn handler(sig: c_int, info: *mut siginfo_t, data: *mut c_void) {
let _errno = ErrnoGuard::new();
let globals = GlobalData::get();
let fallback = globals.race_fallback.read();
let sigdata = globals.data.read();
if let Some(slot) = sigdata.signals.get(&sig) {
unsafe { slot.prev.execute(sig, info, data) };
let info = unsafe { info.as_ref() };
let info = info.unwrap_or_else(|| {
// The info being null seems to be illegal according to POSIX, but has been observed on
// some probably broken platform. We can't do anything about that, that is just broken,
// but we are not allowed to panic in a signal handler, so we are left only with simply
// aborting. We try to write a message what happens, but using the libc stuff
// (`eprintln` is not guaranteed to be async-signal-safe).
unsafe {
const MSG: &[u8] =
b"Platform broken, got NULL as siginfo to signal handler. Aborting";
libc::write(2, MSG.as_ptr() as *const _, MSG.len());
libc::abort();
}
});
for action in slot.actions.values() {
action(info);
}
} else if let Some(prev) = fallback.as_ref() {
// In case we get called but don't have the slot for this signal set up yet, we are under
// the race condition. We may have the old signal handler stored in the fallback
// temporarily.
if prev.signal == sig {
unsafe { prev.execute(sig, info, data) };
}
// else -> probably should not happen, but races with other threads are possible so
// better safe
}
}
struct ErrnoGuard(Errno);
impl ErrnoGuard {
fn new() -> Self {
ErrnoGuard(errno::errno())
}
}
impl Drop for ErrnoGuard {
fn drop(&mut self) {
errno::set_errno(self.0);
}
}
/// List of forbidden signals.
///
/// Some signals are impossible to replace according to POSIX and some are so special that this
/// library refuses to handle them (eg. SIGSEGV). The routines panic in case registering one of
/// these signals is attempted.
///
/// See [`register`].
pub const FORBIDDEN: &[c_int] = FORBIDDEN_IMPL;
#[cfg(windows)]
const FORBIDDEN_IMPL: &[c_int] = &[SIGILL, SIGFPE, SIGSEGV];
#[cfg(not(windows))]
const FORBIDDEN_IMPL: &[c_int] = &[SIGKILL, SIGSTOP, SIGILL, SIGFPE, SIGSEGV];
/// Registers an arbitrary action for the given signal.
///
/// This makes sure there's a signal handler for the given signal. It then adds the action to the
/// ones called each time the signal is delivered. If multiple actions are set for the same signal,
/// all are called, in the order of registration.
///
/// If there was a previous signal handler for the given signal, it is chained ‒ it will be called
/// as part of this library's signal handler, before any actions set through this function.
///
/// On success, the function returns an ID that can be used to remove the action again with
/// [`unregister`].
///
/// # Panics
///
/// If the signal is one of (see [`FORBIDDEN`]):
///
/// * `SIGKILL`
/// * `SIGSTOP`
/// * `SIGILL`
/// * `SIGFPE`
/// * `SIGSEGV`
///
/// The first two are not possible to override (and the underlying C functions simply ignore all
/// requests to do so, which smells of possible bugs, or return errors). The rest can be set, but
/// generally needs very special handling to do so correctly (direct manipulation of the
/// application's address space, `longjmp` and similar). Unless you know very well what you're
/// doing, you'll shoot yourself into the foot and this library won't help you with that.
///
/// # Errors
///
/// Since the library manipulates signals using the low-level C functions, all these can return
/// errors. Generally, the errors mean something like the specified signal does not exist on the
/// given platform ‒ after a program is debugged and tested on a given OS, it should never return
/// an error.
///
/// However, if an error *is* returned, there are no guarantees if the given action was registered
/// or not.
///
/// # Safety
///
/// This function is unsafe, because the `action` is run inside a signal handler. While Rust is
/// somewhat vague about the consequences of such, it is reasonably to assume that similar
/// restrictions as specified in C or C++ apply.
///
/// In particular:
///
/// * Calling any OS functions that are not async-signal-safe as specified as POSIX is not allowed.
/// * Accessing globals or thread-locals without synchronization is not allowed (however, mutexes
/// are not within the async-signal-safe functions, therefore the synchronization is limited to
/// using atomics).
///
/// The underlying reason is, signals are asynchronous (they can happen at arbitrary time) and are
/// run in context of arbitrary thread (with some limited control of at which thread they can run).
/// As a consequence, things like mutexes are prone to deadlocks, memory allocators can likely
/// contain mutexes and the compiler doesn't expect the interruption during optimizations.
///
/// Things that generally are part of the async-signal-safe set (though check specifically) are
/// routines to terminate the program, to further manipulate signals (by the low-level functions,
/// not by this library) and to read and write file descriptors. The async-signal-safety is
/// transitive - that is, a function composed only from computations (with local variables or with
/// variables accessed with proper synchronizations) and other async-signal-safe functions is also
/// safe.
///
/// As panicking from within a signal handler would be a panic across FFI boundary (which is
/// undefined behavior), the passed handler must not panic.
///
/// Note that many innocently-looking functions do contain some of the forbidden routines (a lot of
/// things lock or allocate).
///
/// If you find these limitations hard to satisfy, choose from the helper functions in the
/// [signal-hook](https://docs.rs/signal-hook) crate ‒ these provide safe interface to use some
/// common signal handling patters.
///
/// # Race condition
///
/// Upon registering the first hook for a given signal into this library, there's a short race
/// condition under the following circumstances:
///
/// * The program already has a signal handler installed for this particular signal (through some
/// other library, possibly).
/// * Concurrently, some other thread installs a different signal handler while it is being
/// installed by this library.
/// * At the same time, the signal is delivered.
///
/// Under such conditions signal-hook might wrongly "chain" to the older signal handler for a short
/// while (until the registration is fully complete).
///
/// Note that the exact conditions of the race condition might change in future versions of the
/// library. The recommended way to avoid it is to register signals before starting any additional
/// threads, or at least not to register signals concurrently.
///
/// Alternatively, make sure all signals are handled through this library.
///
/// # Performance
///
/// Even when it is possible to repeatedly install and remove actions during the lifetime of a
/// program, the installation and removal is considered a slow operation and should not be done
/// very often. Also, there's limited (though huge) amount of distinct IDs (they are `u128`).
///
/// # Examples
///
/// ```rust
/// extern crate signal_hook_registry;
///
/// use std::io::Error;
/// use std::process;
///
/// fn main() -> Result<(), Error> {
/// let signal = unsafe {
/// signal_hook_registry::register(signal_hook::consts::SIGTERM, || process::abort())
/// }?;
/// // Stuff here...
/// signal_hook_registry::unregister(signal); // Not really necessary.
/// Ok(())
/// }
/// ```
pub unsafe fn register<F>(signal: c_int, action: F) -> Result<SigId, Error>
where
F: Fn() + Sync + Send + 'static,
{
register_sigaction_impl(signal, Arc::new(move |_: &_| action()))
}
/// Register a signal action.
///
/// This acts in the same way as [`register`], including the drawbacks, panics and performance
/// characteristics. The only difference is the provided action accepts a [`siginfo_t`] argument,
/// providing information about the received signal.
///
/// # Safety
///
/// See the details of [`register`].
#[cfg(not(windows))]
pub unsafe fn register_sigaction<F>(signal: c_int, action: F) -> Result<SigId, Error>
where
F: Fn(&siginfo_t) + Sync + Send + 'static,
{
register_sigaction_impl(signal, Arc::new(action))
}
unsafe fn register_sigaction_impl(signal: c_int, action: Arc<Action>) -> Result<SigId, Error> {
assert!(
!FORBIDDEN.contains(&signal),
"Attempted to register forbidden signal {}",
signal,
);
register_unchecked_impl(signal, action)
}
/// Register a signal action without checking for forbidden signals.
///
/// This acts in the same way as [`register_unchecked`], including the drawbacks, panics and
/// performance characteristics. The only difference is the provided action doesn't accept a
/// [`siginfo_t`] argument.
///
/// # Safety
///
/// See the details of [`register`].
pub unsafe fn register_signal_unchecked<F>(signal: c_int, action: F) -> Result<SigId, Error>
where
F: Fn() + Sync + Send + 'static,
{
register_unchecked_impl(signal, Arc::new(move |_: &_| action()))
}
/// Register a signal action without checking for forbidden signals.
///
/// This acts the same way as [`register_sigaction`], but without checking for the [`FORBIDDEN`]
/// signals. All the signals passed are registered and it is up to the caller to make some sense of
/// them.
///
/// Note that you really need to know what you're doing if you change eg. the `SIGSEGV` signal
/// handler. Generally, you don't want to do that. But unlike the other functions here, this
/// function still allows you to do it.
///
/// # Safety
///
/// See the details of [`register`].
#[cfg(not(windows))]
pub unsafe fn register_unchecked<F>(signal: c_int, action: F) -> Result<SigId, Error>
where
F: Fn(&siginfo_t) + Sync + Send + 'static,
{
register_unchecked_impl(signal, Arc::new(action))
}
unsafe fn register_unchecked_impl(signal: c_int, action: Arc<Action>) -> Result<SigId, Error> {
let globals = GlobalData::ensure();
let mut lock = globals.data.write();
let mut sigdata = SignalData::clone(&lock);
let id = ActionId(sigdata.next_id);
sigdata.next_id += 1;
if sigdata.signals.contains(&signal) {
let slot = sigdata.signals.get_mut(&signal).unwrap();
assert!(slot.actions.insert(id, action).is_none());
} else {
// While the sigaction/signal exchanges the old one atomically, we are not able to
// atomically store it somewhere a signal handler could read it. That poses a race
// condition where we could lose some signals delivered in between changing it and
// storing it.
//
// Therefore we first store the old one in the fallback storage. The fallback only
// covers the cases where the slot is not yet active and becomes "inert" after that,
// even if not removed (it may get overwritten by some other signal, but for that the
// mutex in globals.data must be unlocked here - and by that time we already stored the
// slot.
//
// And yes, this still leaves a short race condition when some other thread could
// replace the signal handler and we would be calling the outdated one for a short
// time, until we install the slot.
globals
.race_fallback
.write()
.store(Some(Prev::detect(signal)?));
let mut slot = Slot::new(signal)?;
slot.actions.insert(id, action);
sigdata.signals.insert(signal, slot);
}
lock.store(sigdata);
Ok(SigId { signal, action: id })
}
/// Removes a previously installed action.
///
/// This function does nothing if the action was already removed. It returns true if it was removed
/// and false if the action wasn't found.
///
/// It can unregister all the actions installed by [`register`] as well as the ones from downstream
/// crates (like [`signal-hook`](https://docs.rs/signal-hook)).
///
/// # Warning
///
/// This does *not* currently return the default/previous signal handler if the last action for a
/// signal was just unregistered. That means that if you replaced for example `SIGTERM` and then
/// removed the action, the program will effectively ignore `SIGTERM` signals from now on, not
/// terminate on them as is the default action. This is OK if you remove it as part of a shutdown,
/// but it is not recommended to remove termination actions during the normal runtime of
/// application (unless the desired effect is to create something that can be terminated only by
/// SIGKILL).
pub fn unregister(id: SigId) -> bool {
let globals = GlobalData::ensure();
let mut replace = false;
let mut lock = globals.data.write();
let mut sigdata = SignalData::clone(&lock);
if let Some(slot) = sigdata.signals.get_mut(&id.signal) {
replace = slot.actions.remove(&id.action).is_some();
}
if replace {
lock.store(sigdata);
}
replace
}
// We keep this one here for strict backwards compatibility, but the API is kind of bad. One can
// delete actions that don't belong to them, which is kind of against the whole idea of not
// breaking stuff for others.
#[deprecated(
since = "1.3.0",
note = "Don't use. Can influence unrelated parts of program / unknown actions"
)]
#[doc(hidden)]
pub fn unregister_signal(signal: c_int) -> bool {
let globals = GlobalData::ensure();
let mut replace = false;
let mut lock = globals.data.write();
let mut sigdata = SignalData::clone(&lock);
if let Some(slot) = sigdata.signals.get_mut(&signal) {
if !slot.actions.is_empty() {
slot.actions.clear();
replace = true;
}
}
if replace {
lock.store(sigdata);
}
replace
}
#[cfg(test)]
mod tests {
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::thread;
use std::time::Duration;
#[cfg(not(windows))]
use libc::{pid_t, SIGUSR1, SIGUSR2};
#[cfg(windows)]
use libc::SIGTERM as SIGUSR1;
#[cfg(windows)]
use libc::SIGTERM as SIGUSR2;
use super::*;
#[test]
#[should_panic]
fn panic_forbidden() {
let _ = unsafe { register(SIGILL, || ()) };
}
/// Registering the forbidden signals is allowed in the _unchecked version.
#[test]
#[allow(clippy::redundant_closure)] // Clippy, you're wrong. Because it changes the return value.
fn forbidden_raw() {
unsafe { register_signal_unchecked(SIGFPE, || std::process::abort()).unwrap() };
}
#[test]
fn signal_without_pid() {
let status = Arc::new(AtomicUsize::new(0));
let action = {
let status = Arc::clone(&status);
move || {
status.store(1, Ordering::Relaxed);
}
};
unsafe {
register(SIGUSR2, action).unwrap();
libc::raise(SIGUSR2);
}
for _ in 0..10 {
thread::sleep(Duration::from_millis(100));
let current = status.load(Ordering::Relaxed);
match current {
// Not yet
0 => continue,
// Good, we are done with the correct result
_ if current == 1 => return,
_ => panic!("Wrong result value {}", current),
}
}
panic!("Timed out waiting for the signal");
}
#[test]
#[cfg(not(windows))]
fn signal_with_pid() {
let status = Arc::new(AtomicUsize::new(0));
let action = {
let status = Arc::clone(&status);
move |siginfo: &siginfo_t| {
// Hack: currently, libc exposes only the first 3 fields of siginfo_t. The pid
// comes somewhat later on. Therefore, we do a Really Ugly Hack and define our
// own structure (and hope it is correct on all platforms). But hey, this is
// only the tests, so we are going to get away with this.
#[repr(C)]
struct SigInfo {
_fields: [c_int; 3],
#[cfg(all(target_pointer_width = "64", target_os = "linux"))]
_pad: c_int,
pid: pid_t,
}
let s: &SigInfo = unsafe {
(siginfo as *const _ as usize as *const SigInfo)
.as_ref()
.unwrap()
};
status.store(s.pid as usize, Ordering::Relaxed);
}
};
let pid;
unsafe {
pid = libc::getpid();
register_sigaction(SIGUSR2, action).unwrap();
libc::raise(SIGUSR2);
}
for _ in 0..10 {
thread::sleep(Duration::from_millis(100));
let current = status.load(Ordering::Relaxed);
match current {
// Not yet (PID == 0 doesn't happen)
0 => continue,
// Good, we are done with the correct result
_ if current == pid as usize => return,
_ => panic!("Wrong status value {}", current),
}
}
panic!("Timed out waiting for the signal");
}
/// Check that registration works as expected and that unregister tells if it did or not.
#[test]
fn register_unregister() {
let signal = unsafe { register(SIGUSR1, || ()).unwrap() };
// It was there now, so we can unregister
assert!(unregister(signal));
// The next time unregistering does nothing and tells us so.
assert!(!unregister(signal));
}
/// Check that errno is not clobbered by the signal handler.
#[test]
fn save_restore_errno() {
const MAGIC_ERRNO: i32 = 123456;
let action = move || {
errno::set_errno(Errno(MAGIC_ERRNO));
};
unsafe {
register(SIGUSR1, action).unwrap();
libc::raise(SIGUSR1);
}
// NB: raise() might clobber errno on some platforms, so this test isn't waterproof. But it
// fails at least sometimes on some platforms if the errno save/restore is removed.
assert!(errno::errno().0 != MAGIC_ERRNO);
}
}

171
vendor/signal-hook-registry/src/vec_map.rs vendored Normal file
View File

@@ -0,0 +1,171 @@
use std::mem;
/// A small map backed by an unsorted vector.
///
/// Maintains key uniqueness at cost of O(n) lookup/insert/remove. Maintains insertion order
/// (`insert` calls that overwrite an existing value don't change order).
#[derive(Clone, Default)]
pub struct VecMap<K, V>(Vec<(K, V)>);
impl<K: Eq, V> VecMap<K, V> {
pub fn new() -> Self {
VecMap(Vec::new())
}
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
pub fn clear(&mut self) {
self.0.clear();
}
fn find(&self, key: &K) -> Option<usize> {
for (i, (k, _)) in self.0.iter().enumerate() {
if k == key {
return Some(i);
}
}
None
}
pub fn contains(&self, key: &K) -> bool {
self.find(key).is_some()
}
pub fn get(&self, key: &K) -> Option<&V> {
match self.find(key) {
Some(i) => Some(&self.0[i].1),
None => None,
}
}
pub fn get_mut(&mut self, key: &K) -> Option<&mut V> {
match self.find(key) {
Some(i) => Some(&mut self.0[i].1),
None => None,
}
}
pub fn insert(&mut self, key: K, value: V) -> Option<V> {
if let Some(old) = self.get_mut(&key) {
return Some(mem::replace(old, value));
}
self.0.push((key, value));
None
}
pub fn remove(&mut self, key: &K) -> Option<V> {
match self.find(key) {
Some(i) => Some(self.0.remove(i).1),
None => None,
}
}
pub fn values(&self) -> impl Iterator<Item = &V> {
self.0.iter().map(|kv| &kv.1)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn empty() {
let m: VecMap<char, u32> = VecMap::new();
assert!(m.is_empty());
assert!(!m.contains(&'a'));
assert!(m.values().next().is_none());
}
#[test]
fn insert_update_get() {
let mut m: VecMap<char, u32> = VecMap::new();
assert!(m.insert('a', 1).is_none());
assert!(m.insert('b', 2).is_none());
assert_eq!(m.get(&'a'), Some(&1));
assert_eq!(m.get(&'b'), Some(&2));
*m.get_mut(&'a').unwrap() += 10;
assert_eq!(m.get(&'a'), Some(&11));
assert_eq!(m.get(&'b'), Some(&2));
}
#[test]
fn insert_overwrite() {
let mut m = VecMap::new();
assert_eq!(m.insert('a', 1), None);
assert_eq!(m.insert('b', 2), None);
assert_eq!(m.insert('a', 3), Some(1));
assert_eq!(m.insert('a', 4), Some(3));
assert_eq!(m.get(&'a').copied(), Some(4));
assert_eq!(m.get(&'b').copied(), Some(2));
assert_eq!(m.insert('b', 5), Some(2));
assert_eq!(m.get(&'a').copied(), Some(4));
assert_eq!(m.get(&'b').copied(), Some(5));
}
#[test]
fn insert_remove() {
let mut m: VecMap<char, u32> = VecMap::new();
assert_eq!(m.remove(&'a'), None);
m.insert('a', 1);
m.insert('b', 2);
assert_eq!(m.remove(&'a'), Some(1));
assert_eq!(m.remove(&'a'), None);
assert_eq!(m.remove(&'b'), Some(2));
assert!(m.is_empty());
}
#[test]
fn insertion_order() {
let mut m: VecMap<char, u32> = VecMap::new();
let values = |m: &VecMap<char, u32>| -> Vec<u32> { m.values().copied().collect() };
m.insert('b', 2);
m.insert('a', 1);
m.insert('c', 3);
assert_eq!(values(&m), vec![2, 1, 3]);
m.insert('a', 11);
m.remove(&'b');
assert_eq!(values(&m), vec![11, 3]);
m.insert('b', 2);
assert_eq!(values(&m), vec![11, 3, 2]);
}
#[test]
fn containment_equivalences() {
let mut m = VecMap::new();
for i in 0u8..=255 {
if i % 10 < 3 {
m.insert(i, i);
}
}
for i in 0u8..=255 {
if m.contains(&i) {
assert_eq!(m.get(&i).copied(), Some(i));
assert_eq!(m.get_mut(&i).copied(), Some(i));
assert_eq!(m.insert(i, i), Some(i));
assert_eq!(m.remove(&i), Some(i));
} else {
assert!(m.get(&i).is_none());
assert!(m.get_mut(&i).is_none());
assert!(m.remove(&i).is_none());
assert!(m.insert(i, i).is_none());
}
}
}
#[test]
fn clear() {
let mut m = VecMap::new();
m.clear();
assert!(m.is_empty());
m.insert('a', 1);
m.insert('b', 2);
assert!(!m.is_empty());
m.clear();
assert!(m.is_empty());
m.insert('c', 3);
assert!(!m.is_empty());
}
}

BIN
vendor/signal-hook-registry/target/package/signal-hook-registry-1.4.8.crate vendored Normal file
View File

Binary file not shown.

0
vendor/signal-hook-registry/target/package/tmp-registry/.cargo-lock vendored Normal file
View File

1
vendor/signal-hook-registry/target/package/tmp-registry/index/si/gn/signal-hook-registry vendored Normal file
View File

@@ -0,0 +1 @@
{"name":"signal-hook-registry","vers":"1.4.8","deps":[{"name":"errno","req":">=0.2, <0.4","features":[],"optional":false,"default_features":true,"target":null,"kind":"normal","registry":"https://github.com/rust-lang/crates.io-index","package":null,"public":null,"artifact":null,"bindep_target":null,"lib":false},{"name":"libc","req":"^0.2","features":[],"optional":false,"default_features":true,"target":null,"kind":"normal","registry":"https://github.com/rust-lang/crates.io-index","package":null,"public":null,"artifact":null,"bindep_target":null,"lib":false},{"name":"signal-hook","req":"~0.3","features":[],"optional":false,"default_features":true,"target":null,"kind":"dev","registry":"https://github.com/rust-lang/crates.io-index","package":null,"public":null,"artifact":null,"bindep_target":null,"lib":false}],"features":{},"features2":null,"cksum":"e447e9102ca6cb4241df2374221440f358b64867a67ede78627828356ff55ac7","yanked":null,"links":null,"rust_version":null,"v":2}

BIN
vendor/signal-hook-registry/target/package/tmp-registry/signal-hook-registry-1.4.8.crate vendored Normal file
View File

Binary file not shown.

59
vendor/signal-hook-registry/tests/unregister_signal.rs vendored Normal file
View File

@@ -0,0 +1,59 @@
//! Tests for the [unregister_signal] function.
//!
//! As a separate integration level test, so it doesn't clash with other tests on the signals.
// The unregister_signal itself is deprecated. But we still want to test it, so it's not deprecated
// and broken at the same time.
#![allow(deprecated)]
extern crate libc;
extern crate signal_hook_registry;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use libc::{SIGINT, SIGTERM}; // We'll use these here because SIGUSR1 is not available on Windows.
use signal_hook_registry::{register, unregister_signal};
#[test]
fn register_unregister() {
let called = Arc::new(AtomicUsize::new(0));
let hook = {
let called = Arc::clone(&called);
move || {
called.fetch_add(1, Ordering::Relaxed);
}
};
unsafe {
register(SIGTERM, hook.clone()).unwrap();
register(SIGTERM, hook.clone()).unwrap();
register(SIGINT, hook.clone()).unwrap();
libc::raise(SIGTERM);
}
// The closure is run twice.
assert_eq!(2, called.load(Ordering::Relaxed));
assert!(unregister_signal(SIGTERM));
unsafe { libc::raise(SIGTERM) };
// Second one unregisters nothing.
assert!(!unregister_signal(SIGTERM));
// After unregistering (both), it is no longer run at all.
assert_eq!(2, called.load(Ordering::Relaxed));
// The SIGINT one is not disturbed.
unsafe { libc::raise(SIGINT) };
assert_eq!(3, called.load(Ordering::Relaxed));
// But it's possible to register it again just fine.
unsafe {
register(SIGTERM, hook).unwrap();
libc::raise(SIGTERM);
}
assert_eq!(4, called.load(Ordering::Relaxed));
}