poly000客栈

一些不错的Rust Unstable特性

1348292515@qq.com (Poly000) — Wed, 28 Jul 2021 15:04:00 +0806

注意

本文原文发布于2021-07-26，其中部分内容可能已经过时。请以 Rust RFC 为准。已经稳定的特性见 accepted.rs。

最后一次更新：2024-02-08

关于翻译

主要译者：poly000，比那名居

术语翻译部分参考了 Rust 语言术语中英文对照表。

如果有原文错误，请联系 Ethan Brierley 且联系我更新翻译。

参与：Maverick/demo_src

Credits

原文 by Ethan Brierley

简介

这篇文章介绍了一些尚不稳定的 Rust 编译器特性。我将会简单叙述这些特性，并不会深入太多细节。

什么是Unstable Rust？

Rust 有三个发布版本： stable，beta，nightly。

Nightly 编译器每天都会发布，而且只有它允许你启用 Unstable Rust 特性。

这篇文章只讨论 Unstable 编译器特性，不讨论此版本的标准库特性。

为什么要用 Unstable 特性？

Unstable Rust 可以让你使用在Stable Rust 中不允许使用的API。为此，编译器与标准库都使用了 Unstable 特性。

使用 Unstable 特性总是伴随着一些风险。它们经常会有一些不期望行为，有时甚至会破坏 Rust 的内存安全保证，导致未定义行为。这些特性可能开发的很好，但也能未开发完善。

使用Unstable特性的 Nightly 编译器，遇到“内部编译器错误”并不少见，这种情况通常称为ICE。它发生于编译过程中，编译器将会panic。这可能是由于数据与查询操作因未完成的特性而被破坏，甚至可能只是因为没做完的特性中打了个 todo!()。

如果你遇到了ICE，检查一下是否已经被反馈，没有的话就把它报告给bug tracker。

Rust 不保证在未来继续支持它的 Unstable 特性。作为 Rust 开发者，我们享受着优秀的向下兼容性与稳定性，而启用 Unstable 特性时，Rust不再提供这些保证。今天工作的程序可能明天就寄了！

我决定学习 Unstable 特性，不是因为我需要用它们去解决实际问题，而是觉得他们很有意思。对我来说，使用 Unstable 特性，可以让我有趣地，更多的参与语言本身的开发过程。

Unstable 特性的完整列表见Unstable 特性列表。

启用 Unstable 特性

若要使用 Unstable 特性，首先你需要安装 Nightly 工具链：

rustup toolchain install nightly

临时使用 Nightly 工具链，你可以在运行cargo时加上 +nightly。

<rust-command> +nightly <args>

例如：

cargo +nightly run

另外，你可以将你的默认编译器改为 Nightly ，这样你就不再需要加上 `+nightly。

rustup default nightly

切换到 nightly 编译器后，你就可以使用 Unstable 特性。让我们试一试吧！

fn main() {
    let my_box = box 5;
}

你会得到如下编译错误：

error[E0658]: box expression syntax is experimental; you can call `Box::new` instead
 --> src/main.rs:2:18
  |
2 |     let my_box = box 5;
  |                  ^^^^^
  |
  = note: see issue #49733 <https://github.com/rust-lang/rust/issues/49733> for more information
  = help: add `#![feature(box_syntax)]` to the crate attributes to enable

Rust 在 help 消息中准确地告诉了我们应该做什么—— 我们需要用 #![feature(box_syntax)] 启用这个特性。

#![feature(box_syntax)]
fn main() {
    let my_box = box 5;
}

所有 Unstable 特性都需要用 #![feature(..)] 启用。即使你忘记了，编译器通常也会指出要如何做，虽然不总会是。

现在，我们看看这些特性。我把需要启用的特性名称放在每个特性的标题中的 代码块 中，在代码片段中省略，以保持简洁。

控制流、模式和块

`destructuring_assignment`

于 Rust 1.59 稳定。

在Rust中，我们经常在绑定到定义时解构某个类型。我们一般会使用let绑定：

// 创建两个变量, 一个是 x, 一个是 y 
let Point { x, y } = Point::random();

目前这种写法只得在实例化新的定义时使用。 destructuring_assignment 将它拓展到赋值。

换句话说，我们可以不使用 let 完成解构。

let (mut x, mut y) = (0, 0);

Point { x, y } = Point::random();

从任意块提前返回，`label_break_value`

于 Rust 1.65 稳定。

Rust 有一个不那么广为人知的特性，loop可以带值退出。就像 Rust 中许多其它的结构，在 Rust 中 loop 并不仅仅是语句, 而是表达式。

// 保持请求用户输入一个数字，直到他们给出一个有效的数字。
let number: u8 = loop {
    if let Ok(n) = input().parse() {
        break n;
    } else {
        println!("Invaid number, Please input a valid number");
    }
};

label_break_value 把这拓展到任何被标记的块，而不仅仅是 loop。它的行为，就像是一种提前的 return ，不过适用于任何代码块，而不只是函数体。

标记代码块的语法，和生命周期很相似。

'block: {
     // 这个代码块现在被标记为 "block" 。
}

现在也可以用同样的方式标记loop。

我们可以把标签放在 break 后面，从那个代码块提前返回。

let number = 'block: {
    if s.is_empty() {
      break 'block 0; // 从代码块提前返回
    }
    s.parse().unwrap()
}

这个特性不等价于goto。它没有 goto 那样的破坏性影响，他只是往后继续执行，从一个代码块中退出。

使用 `try_blocks` 内联 `?` 操作符的功能

版本引导用这个例子解释问号运算符的工作方式：

fn read_username_from_file() -> Result<String, io::Error> {
    let f = File::open("username.txt");

    let mut f = match f {
        Ok(file) => file,
        Err(e) => return Err(e),
    };

    let mut s = String::new();

    match f.read_to_string(&mut s) {
        Ok(_) => Ok(s),
        Err(e) => Err(e),
    }
}

使用 ? 操作符简化，可以得到等效的代码：

fn read_username_from_file() -> Result<String, io::Error> {
    let mut f = File::open("username.txt")?;
    let mut s = String::new();

    f.read_to_string(&mut s)?;

    Ok(s)
}

? 可以在函数中提前返回 Err。 try_blocks 提供了适用于任意代码块的相同功能。使用 try_blocks ，我们可以内联 read_usernames_from_file 函数。

try_blocks 和 ? 的关系就像是 label_break_value 和 return 的关系。 try_blocks 的RFC提到了 label_break_value ，作为 try_blocks 一种可能的解糖。

接下来重写我们的 read_username_from_file ，我们得到了一个简单的 let 绑定和 try 代码块。

let read_username_from_file: Result<String, io::Error> = try {
    let mut f = File::open("username.txt")?;
    let mut s = String::new();

    f.read_to_string(&mut s)?;

    Ok(s)
}

我喜欢这个特性。特别是对于较小的表达式，如果不提取成函数，可读性会更好。

`inline_const`

目前，指定某个值编译时计算需要定义一个常量。

const PI_APPROX: f64 = 22.0 / 7.0;

fn main() {
     let value = func(PI_APPROX);
}

有了 inline_const 我们可以用匿名表达式完成同样的事。

fn main() {
     let value = func(const { 22.0 / 7.0 });
}

在这个简单的例子中，因为编译器优化 constant propagation，const 块是不必要的。但是对于更复杂的常量，用块来表示，可能会更好。

这个特性也允许在const块中使用模式匹配。如 match x { 1 + 3 => {} } 会导致语法错误，而 match x { const { 1 + 3 } => {} } 不会。

`if_let_guard`

拓展 match 中的 if 守卫，使其允许使用 if let。

`let_chains`

于 Rust 1.64 稳定。

目前，if let 和 while let 表达式不能以 || 或 && 连接，这个特性添加了支持。

Traits

`associated_type_bounds`

这是一个 stable Rust 函数：

fn fizzbuzz() -> impl Iterator<Item = String> {
    (1..).map(|val| match (val % 3, val % 5) {
        (0, 0) => "FizzBuzz".to_string(),
        (0, _) => "Fizz".to_string(),
        (_, 0) => "Buzz".to_string(),
        (_, _) => val.to_string(),
    })
}

有了 associated_type_bounds 特性，对于这种情况，我们可以使用一个匿名类型：

fn fizzbuzz() -> impl Iterator<Item: Display> { ... }

看看这个冗长重复的函数签名：

fn flatten_twice<T>(iter: T) -> Flatten<Flatten<T>>
where
    T: Iterator,
    <T as Iterator>::Item: IntoIterator,
    <<T as Iterator>::Item as IntoIterator>::Item: IntoIterator,
{
    iter.flatten().flatten()
}

有了这个特性，我们就可以简单地写成：

fn flatten_twice<T>(iter: T) -> Flatten<Flatten<T>>
where
    T: Iterator<Item: IntoIterator<Item: IntoIterator>>,
{
    iter.flatten().flatten()
}

这种写法容易理解许多。

`default_type_parameter_fallback`, `associated_type_defaults`以及`const_generics_defaults`

const_generics_defaults 于 Rust 1.59 稳定。

这些特性允许你为泛型类型, 关联类型以及 const 变量在更多地方指定默认值。

它们允许你作为开发者创建更好的 API 。如果一个crate的用户对细节不感兴趣，而它有默认值，则可以忽略细节。这也让拓展 API 变得容易，无需做出破坏性更新。

`negative_impls` 和 `auto_traits`

这些特性都被标准库使用。Send 和 Sync 都是自动 trait。

Send trait 定义于标准库：

pub unsafe auto trait Send {
    // 空的
}

注意auto关键字，它让编译器为任意结构体/枚举体/联合体自动实现 Send trait，（前提是构成这个类型的类型都实现了Send）

如果每个类型都能简单地实现自动trait ，它们也不会那么有用。这正是引入 negative_impls 的原因。

negative_impls 允许一个类型不实现某个auto trait。举个例子，UnsafeCell。不受限制的 UnsafeCell 在线程间共享非常不安全，因此它被标记为 Sync 也不安全。

impl<T: ?Sized> !Sync for UnsafeCell<T> {}

注意 ! ，表示 “不Sync”。

`marker_trait_attr`

这个特性为 trait 添加了#[marker] 属性。

详见 Unstable Book

Rust 不允许定义trait的实现时覆盖此前的实现。这样编译器就能确定要使用哪个实现——只有一个。

标志为 #[marker] 的 trait 不能在实现中覆盖任何东西。这样它们就能允许重叠的实现，因为所有的实现都是一样的。

`type_alias_impl_trait`, `impl_trait_in_bindings` and `trait_alias`

impl Trait 让编译器推导具体类型，把它换成实现了Trait的类型。目前，impl Trait只能在函数参数或返回类型中使用，无法应用于变量绑定。

注：impl_trait_in_binding 临时被移除(2022-07-26)，可能是因为它导致了破坏性更新

需要注意的是，使用 type_alias_impl_trait 时，类型必须是固定的。编译器会推断且应用单一具体的类型。

#![feature(type_alias_impl_trait)]

type Foo = impl AsRef<str>;

fn foo(_: Foo) {}

fn main() {
    foo(String::new());
    foo("");
}

error[E0308]: mismatched types
 --> src/main.rs:9:9
  |
3 | type Foo = impl AsRef<str>;
  |            --------------- the expected opaque type
...
9 |     foo("");
  |     --- ^^ expected opaque type, found `&str`
  |     |
  |     arguments to this function are incorrect
  |
  = note: expected opaque type `Foo`
               found reference `&'static str`
note: function defined here
 --> src/main.rs:5:4
  |
5 | fn foo(_: Foo) {}
  |    ^^^ ------

`fn_traits` and `unboxed_closures`

Fn，FnMut和FnOnce被认为是fn的trait。它们会被任何函数或者你创建的闭包自动实现，它们允许你给它们传参。

目前它们只能被自动实现。 fn_trait 则允许为任意类型提供自定义实现。这就像是操作符重载，但要自定义的是()调用。

#![feature(unboxed_closures)] // 实现带有`extern "rust-call"`的函数
#![feature(fn_traits)]

struct Multiply;

#[allow(non_upper_case_globals)]
const multiply: Multiply = Multiply;

impl FnOnce<(u32, u32)> for Multiply {
    type Output = u32;
    extern "rust-call" fn call_once(self, a: (u32, u32)) -> Self::Output {
        a.0 * a.1
    }
}

impl FnOnce<(u32, u32, u32)> for Multiply {
    type Output = u32;
    extern "rust-call" fn call_once(self, a: (u32, u32, u32)) -> Self::Output {
        a.0 * a.1 * a.2
    }
}

impl FnOnce<(&str, usize)> for Multiply {
    type Output = String;
    extern "rust-call" fn call_once(self, a: (&str, usize)) -> Self::Output {
        a.0.repeat(a.1)
    }
}

fn main() {
    assert_eq!(multiply(2, 3), 6);
    assert_eq!(multiply(2, 3, 4), 24);
    assert_eq!(multiply("hello ", 3), "hello hello hello ");
}

这可被用于实现有点 hacky 的函数重载和不定参函数.

语法糖

`box_patterns` and `box_syntax`

这两个特性让Box的构造和析构变得更容易。 box关键字将取代Box::new(...)，并且允许在模式匹配中解引用Box。

struct TrashStack<T> {
    head: T,
    body: Option<Box<TrashStack<T>>>,
}

impl<T> TrashStack<T> {
    pub fn push(self, elem: T) -> Self {
        Self {
            head: elem,
            body: Some(box self),
        }
    }

    pub fn peek(self) -> Option<T> {
        if let TrashStack {
            body: Some(box TrashStack { head, .. }),
            ..
        } = self
        {
            Some(head)
        } else {
            None
        }
    }
}

正如原文作者所说，rust（包括内部实现）正在减少box syntax的使用。
所以这个章节咕了（理直气壮）

This makes things a little more ergonomic but I don't think there is much chance that this feature will ever be stabilised. It seems to have existed forever with no plan for stabilisation but instead a little discussion about removing the feature. box_synatx is used heavily in the compiler's source and a little in the standard library.

It is interesting to note that box does not desugar to Box::new but Box::new is implemented in the standard library with box.

impl<T> Box<T> {
    ...
    pub fn new(x: T) -> Self {
        box x
    }
    ...
}

`async_closure`

目前在闭包中使用异步代码你需要加async块。

app.at("/").get(|_| async { Ok("Hi") });

async_closure 允许你将闭包本身标记为异步的，像异步函数那样写

app.at("/").get(async |_| Ok("Hi"));

`in_band_lifetimes`

于 Rust #93845 移除；
原始 RFC 中，不单独标注的提案被 Rust 拒绝。
详见 Rust #44524 。

使用生命周期标记时，必须事先定义：

fn select<'data>(data: &'data Data, params: &Params) -> &'data Item;

使用 in_band_lifetimes ，生命周期可以不先显式定义。

fn select(data: &'data Data, params: &Params) -> &'data Item;

这是生命周期在rust 1.0.0前的写法。

`format_args_capture`

于 Rust 1.58 稳定。

This allows for named arguments to be placed inside of strings inside any macro that depends on std::format_args!. That includes print!, format!, write! and many more.

let name = "Ferris";
let age = 11;
println!("你好{name}，你{age}岁了。");

`crate_visibility_modifier`

已于 Rust #97254 移除。
理由：
pub struct Foo(crate ::std::path::Path);
会产生歧义 ¹

这个特性允许你写 crate struct Foo 而不是 pub(crate) struct Foo ，语义不变。

Types

`type_ascription`

已于 Rust #101728 移除
理由：语法不Rust

用Iterator的collect方法举个例子： collect将迭代器转换到集合

let word = "hello".chars().collect();
println!("{:?}", word);

这个不能编译，因为rust无法推导出word的类型。可以把第一行换成：

let word: Vec<char> = "hello".chars().collect();

有了type_ascription就不需要再加上let绑定，我们可以直接：

println!("{:?}", "hello".chars().collect(): Vec<char>);

: Type 语法可以用在任何一处，提醒编译器“我在这里想要得到这个类型”

`never_type`

你可以定义没有变体的枚举体，这种枚举体也存在于标准库中。

pub enum Infallible {}

你可以在泛型或函数签名中使用该类型，但它不可能被构造。

元类型 () 等价于只有一个变体的枚举。 never_type 引入了一种新的类型，!等价于没有变体的 Infallible。

Because ! can never be constructed it can be given special powers. We don't have to handle the case of ! because we have proven it will never exist.

fn main() -> ! {
    loop {
        println!("Hello, world!");
    }
}

Loops without a break "return !" because they don't ever return.

! can be very useful for expressing impossible outcomes in the type system. Take for example the FromStr implementation on this UserName type. This implementation is infallible because its implementation can never fail. This allows us to set the Err variant to type !.

struct UserName(String);

impl FromStr for UserName {
    type Err = !;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(Self(s.to_owned()))
    }
}

It is then possible to use an empty match on the Err variant because ! has no variants.

let user_name = match UserName::from_str("ethan") {
    Ok(u) => u,
    Err(e) => match e {},
};

`exhaustive_patterns`

译注：原作者的解释和 RFC，Issue 都对不上。
原Issue目标为，不可达的分支可以省略
如析构一个 Result<T, !> ，
fn safe_unwrap<T>(x: Result<T, !>) -> T {
    match x {
        Ok(y) => y,
    }
}

With the feature exhaustive_patterns the type system becomes smart enough for us to eliminate the Err branch altogether.

let user_name = match UserName::from_str("ethan") {
    Ok(u) => u,
};

We can combine this with destructuring to remove the match leaving a beautiful line of code.

let Ok(user_name) = UserName::from_str("ethan");

attribute

这个小节由 @Hinanawi_Tenshi_M 提供翻译，有改动

`optimize_attribute`

你可以用 Cargo.toml 的 opt-level 选项指定你想要怎么优化你的二进制文件。

opt-level 指定的是整个 crate 的优化方式，如果你想要分别控制每一个项目的优化方式，你可以使用 optimize_attribute 选项。

#[optimize(speed)]
fn fast_but_large() {
     ...
}

#[optimize(size)]
fn slow_but_small() {
     ...
}

这对微调应用程序非常有用。在这些应用程序中，大小和性能的权衡特别重要。例如使用 web assembly 时。

`stmt_expr_attributes`

这个特性让你可以在几乎任何地方标记属性，而不仅仅是顶层项目。例如，你可以在一个闭包上放一个optimize attribute

`cfg_version`

该特性允许根据编译器版本进行条件编译。

#[cfg(version("1.42"))] // 1.42 以上
fn a() {
    // ...
}

#[cfg(not(version("1.42")))] // 1.41 以下
fn a() {
    // ...
}

这使得你的 crate 能够使用最新的编译器功能，同时仍然保持对旧编译器的后备支持。

`no_core`

不依赖 ::std 的 #![no_std] 选项已经存在很久了，

#![no_core] 则对应着不依赖 ::core 。

这对于不在完整环境中运行的应用非常重要，如嵌入式系统。嵌入式系统通常没有操作系统，甚至没有动态内存，所以 std 中的许多功能都无法使用。

你现在可以通过 #![no_core] 表明不使用 libcore。

这样不会留下任何东西——你甚至不能使用libc。

其它

Const 泛型

这个小节由 @Hinanawi_Tenshi_M 提供翻译，有改动。
已经在 Stable Rust 部分实现。 ²

在都柏林 Rust 集会中，关于 const_generics ，我做过一场演讲。与其重复那些内容，我更推荐大家去看这个演讲。

Macros 2.0

Rust的声明式宏非常强大。然而， macro_rules! 的一些规则，让我很困惑。

macro_rules! 是一个简单的token转换过程，或者说，

它接受一个token列表，输出新的token列表
可见性原则会遵从宏的调用处的规则。

——因为代码只是被简单地粘贴回原处。

Macros 2.0 介绍了macro_rules!的一种替代。

编写 Macros 2.0 只需使用关键字 macro

它引入了一种新的格式，Hygiene 。Hygiene 允许宏应用它们定义处的可见性规则，而不是调用处。

`generators`

生成器（协程）提供了一种特殊的函数，可以在执行过程中暂停，“yield” 中间值给调用者。

生成器允许你使用yield关键字返回多个值，每次暂停该函数并返回给调用者。

生成器中也可以return单个值，不可再恢复。

大约三年前，我尝试编写算法，沿对角线遍历一个无穷的矩阵。我发现用Rust的迭代器编写它非常困难，最终放弃了。

这是我的实现，使用了Rust的生成器（协程）和一些我们刚刚讨论过的特性。

#![feature(
    try_blocks,
    generators,
    generator_trait,
    associated_type_bounds,
    type_ascription
)]

use std::{
    iter,
    ops::{Generator, GeneratorState},
    pin::Pin,
};

/// Input
/// [[1, 2, 3]
/// ,[4, 5, 6]
/// ,[7, 8, 9]]
/// Output
/// [1, 2, 4, 3, 5, 7]
fn diagonalize<T>(
    mut matrix: impl Iterator<Item: Iterator<Item = T>>,
) -> impl Generator<Yield = T, Return = ()> {
    move || {
        let mut rows = Vec::new();
        (try {
            rows.push(matrix.next()?);
            for height in 0.. {
                for row in 0..height {
                    if row >= rows.len() {
                        rows.push(matrix.next()?);
                    }
                    yield rows[row].next()?;
                }
            }
        }): Option<()>;
    }
}

fn main() {
    let matrix = (0..).map(|x| iter::once(x).cycle().enumerate());
    let mut diagonals = diagonalize(matrix);
    while let GeneratorState::Yielded(value) = Pin::new(&mut diagonals).resume(()) {
        dbg!(value);
    }
}

It is understandable if you found the above snippet hard to interpret. It makes use of a number of features that you may have just been introduced to.
There is a compelling argument against adding too many new features as they can greatly increase the learning curve.

生成器让一些没有这个特性会难以编写甚至无法编写的实现变为可能。

生成器在标准库中是为了实现 async/await 添加的。具体的语义在稳定化前很可能被修改，但它很有趣。

总结

我很抱歉，没有介绍其他三个不错的unstable特性：GAT, 内联汇编和特化。我只是感觉，在这篇文章中，我做不到客观的评价它们，不过将来我可能会尝试。

如果你想了解更多unstable特性，我推荐你看the unstable book，这里会列出绝大部分。 Unstable book会连接到tracking issue，而后者往往会链接到RFC。组合使用这些来源，你可以很好地了解新特性。

Thank you for reading my first blog post 😃. The best way to support me is by following my Twitter. I am also looking for employment opportunities so please get in touch if you would like to talk about that.

C23特性简介

1348292515@qq.com (Poly000) — Sat, 01 Oct 2022 17:38:00 +0806

差异

移除

数据类型

2的补码以外的有符号整数

语言特性

K&R风格函数声明与定义

比如 int main()，是经常被使用的旧式写法。

或者

int add1(value)
int value;
{
  return value + 1;
}

不再允许u/U前缀的字符串字面量/字符常量为非UTF-16/32字符
__alignof_is_defined 和 __alignas_is_defined

标准库

混合使用宽字符的连接
对 realloc() 传递0大小的调用（实现定义改为未定义）
static_assert宏（改为关键字）
thread_local宏（改为关键字）

废弃

标准库

<stdnoreturn.h>，可使用 [[noreturn]]标志
<math.h> 定义的数值界限INFINITY，DEC_INFINITY，NAN，DEC_NAN（移动到 <limits.h）
asctime()，可使用 asctime_s()
ctime()，可使用 ctime_s()
特性测试宏: __STDC_IEC_559__，__STDC_IEC_559_COMPLEX__，

可使用__STDC_IEC_60559_BFP__和__STDC_IEC_559_COMPLEX__。

DECIMAL_DIG，序列化/反序列化long double可能需要的十进制精度
__bool_true_false_are_defeined （现在true/false都成了关键字）

关键字

_Noreturn 函数限定符
[[_Noreturn]] 属性

新增

语言特性

属性 (attribute)

`[[fallthrough]]`

表示从这里直落是有意的，编译器不应警告。

switch (cond) {
    case A:
      if ([expression]) {
          doSomething();
          [[fallthrough]];
      }
    case B:
    case C:
      printf("Error: ...");
      [[fallthrough]];
    case D:
      doSomething();
      break;
}

`[[unsequenced]]`和`[[reproducible]]`

[[unsequenced]] 要求函数无状态，无副作用，幂等，并且独立。

其中：

无状态：没有定义可修改的静态或线程本地对象，也不调用有这种行为的函数。
无副作用：没有可观测的副作用。
幂等：重复的求值应当得到同样的结果。（可以读取全局状态）
独立：不依赖参数和常量以外的状态（可以写入全局变量）

[[reproducible]] 则只要求函数无副作用且幂等。

[[deprecated]]

可通过("reason")添加说明：[[deprecated("WTH are u using this")]]

[[maybe_unused]]

告诉编译器不要因为未使用警告。

[[nodiscard]]

该类型/该函数的返回值不希望被直接丢弃。如错误信息，或者结果存储在返回值的函数。可通过 ("reason")添加说明：[[nodiscard("Error info should be processed")]]。

[[noreturn]]

该函数不通过return语句或达到底部返回。

应用于数组的限定修饰符

数组类型和它的成员的类型现在被认为总是被同样地限定

_Atomic限定不可应用于数组。

const int A[1] = {};
int * ptr = A; // OK until C23
// clang: cannot initialize a variable of type 'int *' with an lvalue of type 'const int[1]'
// Note clang will apply this rule even in C89-C17

关键字

前三项可被编译器为兼容性定义为宏

static_assert
thread_local
true, false
constexpr 存储周期修饰符/函数修饰符

预定义宏

不带message的 _Static_assert 宏（现在应使用static_assert关键字）
unreachable()，表示代码不可达。

#include <stdint.h>
#include <stddef.h> // size_t and not has unreachable()

typedef struct color { uint8_t r, g, b, a; } color;

// color_vec that works over pointer-to-array
#define VEC_TYPE color
#define VEC_NAME color_vec
#include <vec.h>

void generate_texture(color** p_texture, size_t square_wh) {
    switch (square_wh) {
    case 128: [[fallthrough]];
    case 256: [[fallthrough]];
    case 512: /* ... */
        color_vec_clear(p_texture);
        color_vec_resize_init(p_texture,
            square_wh * square_wh,
            (color){0, 0, 0, 0});
        break;
    default:
        unreachable();
    }
}

数据类型

十进制浮点类型

_Decimal32，_Decimal64 以及 _Decimal128。

位精度整数，_BitInt(N)
二进制整数常量，以0b/0B前缀。
nullptr常量和相关的nullptr_t类型
char16_t 和 char32_t 字符串字面量必须是 UTF-16 和 UTF-32

字面量

u8前缀的 UTF-8 字符常量（u8'?'为单字节，u8"..." 为 unsigned char [N]）
数字分隔符 '，如 114'514'1919L

预处理器指令

`#embed`

const unsigned char icon_data[] = { // unsigned char为默认类型
    #embed "art.png"
};

const char blob[] = {
    #embed char "data.bin" // 其中char为类型名
};

const char qwq[] = {
    #embed 32 "/dev/urandom" // 限制参数放在文件名之前；最多可以读入32字节。
    // 注意这是上界，并不意味着一定会读入这么多。
};

该资源的内容以实现定义的方式映射到数据中，它为每个元素使用 CHAR_BIT * sizeof(type-name) 比特。如果该文件不足以多次填充这些位，则需要进行diagnostic。

其中类型名必须是基本整数类型。

#elifdef
#elifndef
#warning

其他

空初始化器 = {} 对于数组或自定义数据结构：对其成员空初始化；对于基本类型变量：对其本身空初始化。
函数定义中的不具名参数
声明或块结尾前的label
函数参数定义转发，可能在对ABI时需要使用。

标准库特性

现代的位运算工具

stdbit.h

有端序的宏和一些常见的位运算工具。

printf()对整数的二进制格式化支持

标准

使用“%b”描述符输出整数为二进制。

为格式化指定位长

标准

当你想要输出一个很大的整数，之前的可移植做法是：

printf("%jd", (intmax_t)some_integer);

但是 int128_t ， int256_t 得以支持后，我们也不能修改现存平台的 intmax_t 定义。于是：

printf("%w128d", my_128b_integer);

你也可以指定打印该数字的低位：

printf("%w8d", 0x114)

带溢出检查的整数运算

标准

#include <stdckdint.h>

bool ckd_add(type1 *result, type2 a, type3 b);
bool ckd_sub(type1 *result, type2 a, type3 b);
bool ckd_mul(type1 *result, type2 a, type3 b);

这三个函数支持任意内建整数类型。

参考资料

软RAID vs 硬RAID

1348292515@qq.com (Poly000) — Fri, 24 Feb 2023 22:08:00 +0806

Credit

原文地址

正文

一个很容易引起争论的问题：硬RAID和软RAID哪个更快和（或）更好？

很多传统观点认为是硬RAID，但我很不同意。让我们问一个相反的问题：硬件RAID如何（或何时）比软件RAID快？

如果你要用RAID-5，硬件可以比你的CPU更快XOR。但是，在现代系统中，XOR的性能基本上受制于内存带宽，而不是CPU的能力。你可能有比CPU更好的内存带宽（显卡就是这样），但这并不便宜。

如果你要用RAID-1，硬件RAID可以减少写的总线带宽，从N个DMA传输到N个磁盘到一个DMA传输到自己。但是，为了使你的系统更快，你需要用写流量使PCI总线带宽饱和，这并不常见。(理论上，你也可以在RAID-5中遇到这种情况）。

就是这样。(欢迎补充和更正）

通常的反驳是，虽然硬件RAID可能不比软件RAID快，但至少把负荷从你的主CPU上转移了，所以系统的整体速度提高了。然而，要达到这种情况，你的系统需要在CPU方面很差，并且要做大量的写入IO（如果你的写入IO不是特别多，那么软RAID的额外CPU使用率也会很小）。这种情况也不太常见。

软件RAID有一个缺点：启动操作系统后才可以使用。这会使早期启动变得复杂。但软件RAID也有很多优点，如不依赖硬件。

The one wildcard I can see in hardware RAID's favour is virtualization, which might deliver a future of heavily used hardware running close to both CPU and IO saturation.

我认为虚拟化是硬RAID的优势所在，可以帮你压榨硬件，达到CPU和IO饱和。

DeepL翻译后润色。

Win32 盘符，设备号和硬盘型号

1348292515@qq.com (Poly000) — Tue, 06 Feb 2024 18:23:00 +0806

原发布地址

原Issue评论，讨论 KDiskMark Windows 支持需要的工作

列出设备

逻辑设备

GetLogicalDrives 会返回一组位码，值为1的位的位置加上'A'就是它代表的盘符

from win32api import GetLogicalDrives

# for example, `0b_1100` means there are C:/ and D:/.
def logical_drives():
   bit_mask = GetLogicalDrives()
   for offset in range(26):
      alphabet = chr(ord('A') + offset)
      if (1 << offset) & bit_mask:
          yield alphabet

卷

使用 Powershell¹:

Get-Volume

使用 `mountvol.exe`

mountvol /L

使用 `FindFirstVolumeW` and `FindNextVolumeW`

from winsys._kernel32 import FindFirstVolume, FindNextVolume
handle, first = FindFirstVolume()
volumes = [first]

while (volume := FindNextVolume(handle)) and isinstance(volume, str):
    volumes.append(volume)

print(volumes)

获取硬盘型号

盘符 -> 硬盘型号

使用 Powershell²

Get-Disk (Get-Partition -DriveLetter 'C').DiskNumber | select -Prop FriendlyName

盘符或任意卷 -> 设备号

使用 Powershell （只支持盘符）

(Get-Partition -DriveLetter 'C').DiskNumber

使用 `IOCTL_STORAGE_GET_DEVICE_NUMBER`

#include <stdio.h>
#include <Windows.h>
#include <fileapi.h>
#include <winioctl.h>

int get_disk_number_by_drive_letter(char letter) {
    char logical_drive_path[7];
    sprintf(logical_drive_path, "\\\\.\\%c:", letter);
    // '\\?\Volume{<GUID>}' is also applicable to this
    HANDLE hDevice = CreateFileA(logical_drive_path, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
    if (hDevice == INVALID_HANDLE_VALUE) {
        fprintf(stderr, "Failed to open device. Error code: %lu\n", GetLastError());
        return -1;
    }

    STORAGE_DEVICE_NUMBER device_number;
    DWORD bytes_returned;
    if (!DeviceIoControl(hDevice, IOCTL_STORAGE_GET_DEVICE_NUMBER, NULL, 0, &device_number, sizeof(device_number), &bytes_returned, NULL)) {
        fprintf(stderr, "IOCTL_STORAGE_GET_DEVICE_NUMBER failed. Error code: %lu\n", GetLastError());
        CloseHandle(hDevice);
        return -1;
    }

    CloseHandle(hDevice);
    return device_number.DeviceNumber;
}

设备号 -> 硬盘型号

使用 Powershell

Get-Disk | select -Prop Number,FriendlyName

使用 wmic

wmic diskdrive get index,model

使用 wmi

from win32com.client import GetObject

def get_diskdrive_info():
    wmi = GetObject(r"winmgmts:\\.\root\cimv2")
    disks = wmi.ExecQuery("SELECT * FROM Win32_DiskDrive")

    disk_info = {disk.Index: disk.Model for disk in disks}
    return disk_info

disk_info = sorted(get_diskdrive_info().items())

for index, model in disk_info:
    print(f"{index}: {model}")

Anyway, the most accurate way is to call smartctl ... X:

其他可能要用到的系统调用

QueryDosDeviceW 可以用来从盘符获取卷编号（也可以用来列出卷，如果传入None），即 \Device\HarddiskVolumeX 中的 X 。

GetDiskFreeSpaceExA 可以拿到对调用用户可用的空间（详见配额），总硬盘大小和总可用空间。

from win32file import GetDiskFreeSpaceEx
list(map(lambda size: size / (1024**3), GetDiskFreeSpaceEx("C:")))
# [58.516212463378906, 117.97948837280273, 58.516212463378906]

尾声

感谢³的 Win32 Paths 解释

QEMU运行Windows启用安全启动

1348292515@qq.com (Poly000) — Thu, 07 Mar 2024 19:08:00 +0806

选项

从 Debian ovmf 提取 OVMF_VARS_4M.ms.fd ¹，使用任意发行版提供的 OVMF_CODE.secboot.4m.fd ：

qemu ... \
  -drive if=pflash,format=raw,readonly=on,file=OVMF_CODE.fd \
  -drive if=pflash,format=raw,file=OVMF_VARS.ms.fd \
  -machine pc-q35-8.2

其中 -machine 是指定一种支持 SecureBoot 的机器型号

效果

qemu-windows-sb

https://bbs.archlinux.org/viewtopic.php?id=275691 ↩

Android 如何保持眼中存储干净

1348292515@qq.com (Poly000) — Thu, 28 Nov 2024 13:27:00 +0806

存储空间隔离

由 RikkaApps 开发。
由于基于目录重定向，垃圾文件实际上是放在了独立的空间

优点

较为可控的目录限制
可以阻止访问主用户隐私数据
不同应用之间，无法基于内置存储中的垃圾文件追踪用户

缺点

付费闭源软件
需要 Magisk/KernelSU/Xposed
常年未更新，Android 14+ 支持未来堪忧
非 Google Play 渠道购买，均为限制单手机使用

MaterialCleaner

类似 #存储空间隔离
这个项目被“酷安大神”搞死了，兼容性问题比较大

IsLand

开发者同《绿色守护》
隔离环境，把国产软件塞一起；
基于Work Profile实现，国产ROM兼容性不一定好

优点

也可用于反取证
单空间使用，无需 Root
可以阻止访问主用户隐私数据
(root+放弃支付软件) 不同应用之间，无法基于内置存储中的垃圾文件追踪用户

缺点

新版本转为闭源软件
需要Root才能开启多个工作资料，互相隔离不同国产应用
输入法、支付应用调用都是分割的，这一点会影响上一条

Insular

#IsLand 的开源复刻实现。

black_and_white_list

代码质量极差，但是目前没人写类似的打包了的东西
定期清理，最原始的方式

优点

较为灵活
提供了白名单，避免误删
应用无关，单纯写路径规则
不同应用之间，无法基于内置存储中的垃圾文件追踪用户

缺点

久年未更
未提供图形化设置方式
配置文件为未知文本解析方式
依赖 Magisk 和大量不规范行为
基于 crond ，古老的定时服务方式

garbage-remove

Rust实现
同样是定期清理

优点

无需Root
高性能，高可读日志
配置文件为 toml 格式
默认不允许删除相对路径
不同应用之间，无法基于内置存储中的垃圾文件追踪用户

缺点

未提供图形化设置方式
过度优化的实现，使用mpmc+多线程删除
未提供模块服务方式运行，需要手动保活

买台 iPhone 备用机

终极方案，长久有效

优点

隐私保护最好的方式
省心，不会遇到各种风控过不去
环境物理隔离，不再担心侧漏检测

缺点

成本较高

基于 Xiu 和 ffmpeg 的局域网录像机平替方案

1348292515@qq.com (Poly000) — Fri, 21 Feb 2025 13:07:00 +0806

硬件需要

路由器/无线光猫

需要可以绑定 MAC 到 LAN IP

摄像头

丐版 (本教程)

一部可以长期供电、固定录制的手机
如果充电不够稳定，可能会出现 ffmpeg 在手机重启、重新开始推送服务后仍然挂起的状态考虑为 ffmpeg 对应服务设置 RuntimeMaxSec 来减少空白期
一台 10w-20w 功率的LED灯，提供手动补光（一体式约15~20 CNY）
一根足够稳定，不会摔坏你手机的摄像支架

家庭版

听闻只有乐橙的网络摄像机不是云存储服务的副产品, 包括 rtsp流/ONVIF 都是公开的。

一台乐橙网络摄像机，需支持接入你的局域网

企业方案

一台专业的，包含 RTSP 协议透明引出的“企业用”溢价的业内品牌网络摄像机

录像机

一台可以长期供电，带有停电时自动关机（你的笔记本电池，何尝不是UPS？）的电脑
- 最好带有可用的硬件视频编码支持。
本教程只考虑了 intel QuickSyncVideo / NVIDIA NVENC 可以自行调整 AMD 支持参数

软件需要

摄像手机

SpyNET Camera，开源软件，2017停更
IP摄像头，广告软件

录像机

运行有 Systemd-based 发行版，或 Windows（自行使用 nssm 管理服务）

Xiu 配置文件

${EDITOR:-nano} ~/xiu.toml

[rtmp]
enabled = true
port = 1935
gop = 1

[hls]
enabled = true
port = 8080
need_record = true

[authsecret]
key = ""
password = ""

ffmpeg 推流+时间戳脚本

此处以 nushell 为例，你可以把它改写成 bash 脚本等

${EDITOR:-nano} ~/rtsp-to-rtmp.nu

QuickSync

#!/usr/bin/nu

# 填入你的 RTSP 推流地址
let rtsp_addr = "rtsp://192.168.xxx.xxx:8080/h264.sdp";
# 填入你的摄像头名称
let camera_prefix = "";

(
  ffmpeg
  -rtsp_transport tcp # 指定TCP协议
  -hwaccel qsv # QuickSyncVideo 加速
  -i $rtsp_addr -framerate 30 # 30 fps
  -c:v h264_qsv -global_quality 30 # ICQ 30
  -f flv -ar 22050 # 音频采样率
  ( "rtmp://127.0.0.1/live/" + $camera_prefix + ( date now | format date "%Y-%m-%d_%H-%M-%S" ))
)

NVENC

#!/usr/bin/nu

# 填入你的 RTSP 推流地址
let rtsp_addr = "rtsp://192.168.xxx.xxx:8080/h264.sdp";
# 填入你的摄像头名称
let camera_prefix = "";

(
  ffmpeg
  -rtsp_transport tcp # 指定TCP协议
  -hwaccel cuda # CUDA加速
  -i $rtsp_addr -framerate 30 # 30 fps
  -c:v h264_nvenc -rc:v vbr_hq -cq 30 # CQR 30
  -f flv -ar 22050 # 音频采样率
  ( "rtmp://127.0.0.1/live/" + $camera_prefix + ( date now | format date "%Y-%m-%d_%H_%M_%S" ))
)

Systemd 服务项

建立目录

mkdir -p ~/.local/share/systemd/user

Xiu

${EDITOR:-nano} ~/.local/share/systemd/user/xiu.service

[Unit]
Description=Xiu Service
After=network-manager.service

[Service]
# user 改为你的用户名
ExecStart=/usr/bin/xiu -c /home/user/xiu.toml
# 此目录为存储 ./live/<时间戳>/*.{ts,m3u8} 的目录
WorkingDirectory=/mnt/Data/monitor
Restart=always

[Install]
WantedBy=default.target

systemctl enable --user --now xiu.service

FFmpeg 转发流

${EDITOR:-nano} ~/.local/share/systemd/user/rtmp-to-rtsp.service

[Unit]
Description=RTSP Push to RTMP Service
After=network-manager.service

[Service]
# user 改为你的用户名
ExecStart=/home/user/rtsp_push_rtmp.nu
Restart=always
# 每小时分一次 vod_[...].m3u8
RuntimeMaxSec=3600

[Install]
WantedBy=default.target

systemctl enable --user --now rtmp-to-rtsp.service

tmpfiles.d 清理视频录像

例如，清理三天前创建的目录/文件:

e /path/to/live 0755 用户名 用户名 cC:3d -

注意，cC分别表示文件和目录的创建时间，不添加 cC: 会导致默认考虑访问时间。

尾声

现在 xiu 就可以在你设置好的存储位置自动产出动态 .m3u8 文件和（每当 Xiu退出/串流停止推往Xiu 时生成）的总 vod_<...>.m3u8 。

使用以下命令将 H264 编码的 *.ts 文件合并为 .mp4 格式，以使 mpv 可以正常seek视频。

使用 nushell 脚本：

# 此处改为你的视频存储路径
cd /path/to/live

for $it in (fd '^vod_.*\.m3u8$' | lines) {
    # 提取文件名部分，这里是配合产生的 `<时间戳>/vod_<时间戳>.m3u8` 路径格式
    let name = ($it | str replace --regex "/.*" "");

    # 合并 .m3u8 视频，不进行重编码
    ffmpeg -i $it -codec copy ($name + ".mp4")

    # 清理合并成功的 .ts 视频分片
    if ($env.LAST_EXIT_CODE == 0) {
        rm -rf $name
    }
}

播放视频时，可以直接使用NuShell脚本：

let prefix = "";
let output = $prefix + "temp.m3u";

# 此处可以自行填写年份，月份，日期，小时等
let pattern = '^' + $prefix + '....-..-.._.._.._..\.mp4$';

fd $pattern out> $output
mpv $output

HN8145XR光猫-河南移动-资料整理

1348292515@qq.com (Poly000) — Wed, 26 Feb 2025 11:30:00 +0806

前言

本人有幸用上了河南移动网络接入，我们井盖省的网络封闭程度一直是内地省份中数一数二。

还原可用的Shell环境

来源: 分享HN8145XR开telnet及补全shell个人心得
Telnet用户：root Telnet密码：adminHW, Hw8@cMcc 等

启动 ONT_telnet_enable.exe
网线连接光猫和电脑/笔记本
打开使能工具，选择对应有线网卡，展开设备列表
断开光猫电源
选择“V5使能”，点击启动
恢复光猫电源，等待出现“Failed”字样，不用管；待到光猫LED灯全部熄灭，点击停止。不要退出使能工具

此处可以检查 telnet 是否已经可以连接。

选择“升级”，版本包选择 shell9.bin
点击开始，再次重启光猫电源
等待光猫LED再次全部熄灭（除下行光），出现 “Failed” ，点击停止，退出使能工具。

基于Telnet获取超管密码

参考：通过telnet取得华为HN8145XR超级密码

telnet 192.168.1.1
# -> root
# -> (telnet密码)
su
shell
cd /mnt/jffs2/
cp hw_ctree.xml myconf.xml.gz
aescrypt2 1 myconf.xml.gz tmp # 此处tmp被忽略了
zcat myconf.xml.gz  | grep 'UserName="CMCCAdmin"' | cut -d " " -f 5 | cut -d = -f 2

可以得到如下结果：

Password="$2...............$"

使用 WW_Dollar2.exe ，点击计算，可以解密 $2 密文。

得到的密文可以需要拼接上 CMCCAdmin / CMCCAdmin# ，如果是中国移动版

作者这里得到了一串sha256sum (-_-||| ) 还好是电话要的密码

考虑到河南移动的做法是 CMCCAdmin + 八位随机字符，目前时代个人算力暂不可能爆破。

从hash后的宽带密码/超级密码计算原密码

来源：PurePeace 的获取移动光猫（如HS8545M5等设备）pppoe密码明文，略有修改
Rust写了一份，可以用来试试看更长的密码另外，移动似乎倾向于设置为手机号后六位。
更建议的方式：通过手机营业厅重置密码，获取新的 PPPoE 拨号密码移动可以发送 CZKDMM 到 10086，发送短信

from sys import argv
import hashlib


def sha256(todo: str):
    return hashlib.sha256(str(todo).encode()).hexdigest()


def md5(todo: str):
    return hashlib.md5(str(todo).encode()).hexdigest()


def find_target(secret: str):
    # 生成六位密码
    for value in range(1000000):
        value = f"{value:06}"
        s = sha256(md5(value))
        if s == secret:
            return value
    return None


if __name__ == "__main__":
    try:
        secret = argv.pop(1)
    except IndexError:
        print("Usage:")
        print(f"    {argv[0]} <sha256hashsecret>")
        exit(1)
    target = find_target(secret)
    print(target if target is not None else "")

恢复华为公版界面

参考：折腾HN8145XR（恢复华为界面等）

需要先备份好宽带帐户，宽带密码，ONT认证密码
如果只修改界面，不直接 restore_xxx.sh ，可能可以保留下来ONT认证密码
作者的OTN注册方式是 Password

启动 WW_Dollar2.exe
在你的电脑启动 ncat:

如果没有ncat，可以 scoop install nmap。

ncat -l -p 9999 > hw_boardinfo

在光猫，使用 busybox nc 把 hw_boardinfo 传过来：

此处 192.168.1.4 为电脑的局域网IP

busybox nc 192.168.1.4 9999 < /mnt/jffs2/hw_boardinfo

备份一份 hw_boardinfo
打开 hw_boardinfo ，修改：

obj.id = "0x0000001a"; obj.value = "COMMON";
obj.id = "0x0000001b"; obj.value = "COMMON";
obj.id = "0x00000031"; obj.value = "NOCHOOSE";

把修改后的 hw_boardinfo 传回覆盖 /mnt/jffs2/hw_boardinfo 和 /mnt/jffs2/hw_boardinfo.bak 。

Frigate + NVIDIA 显卡笔记本的部署

1348292515@qq.com (Poly000) — Mon, 18 Aug 2025 12:22:00 +0806

软件前置

sudo pacman -Syu docker docker-compose nvidia-container-toolkit
sudo systemctl enable --now docker
# 确保 docker0 已经被代理或已设置好连接代理

硬件要求

该方案相比于之前的丐版方案，需要更新的硬件才能解决种种兼容或性能问题。

笔者测试的环境：

-`
                  .o+`
                 `ooo/
                `+oooo:
               `+oooooo:                 poly@mokurin-arch 
               -+oooooo+:                ----------------- 
             `/:-:++oooo+:               OS: Arch Linux x86_64 
            `/++++/+++++++:              Host: Dell G15 5520 
           `/++++++++++++++:             Kernel: 6.15.2-arch1-1 
          `/+++ooooooooooooo/`           Uptime: 22 hours, 2 mins 
         ./ooosssso++osssssso+`          Packages: 2766 (pacman), 8 (flatpak) 
        .oossssso-````/ossssss+`         Shell: zsh 5.9 
       -osssssso.      :ssssssso.        Resolution: 1920x1080 
      :osssssss/        osssso+++.       DE: Plasma 6.3.5 
     /ossssssss/        +ssssooo/-       WM: kwin 
   `/ossssso+/:-        -:/+osssso+-     Theme: Materia [GTK2/3] 
  `+sso+:-`                 `.-/+oso:    Icons: breeze-dark [GTK2/3] 
 `++:.                           `-/+/   Terminal: vscode 
 .`                                 `/   CPU: 12th Gen Intel i7-12700H (20) @ 4.600GHz 
                                         GPU: Intel Alder Lake-P GT2 [Iris Xe Graphics] 
                                         GPU: NVIDIA GeForce RTX 3060 Mobile / Max-Q 
                                         Memory: -- MiB / 15669MiB

使用的文件

init.sh

mkdir -p config storage
mkdir -p config/model_cache/jinaai/jina-clip-v1
# btrfs 改善 sqlite 的性能
chattr -R +C config storage
cp --reflink=auto config.yaml config/
cp --reflink=auto yolo_nas_s.onnx config/

# optional, useless semantic search
# cp --reflink=auto *_fp16.onnx config/model_cache/jinaai/jina-clip-v1/

docker-compose up -d

yolo_nas_s.onnx

该文件由于禁止分发转换模型，建议使用 colab 运行获取。

docker-compose.yml

-tensorrt 只有用N卡加速才需要，AMD / Intel 卡不需要。

services:
  frigate:
    container_name: frigate
    restart: unless-stopped
    stop_grace_period: 30s
    image: ghcr.io/blakeblackshear/frigate:stable-tensorrt
    volumes:
      - ./config:/config
      - ./storage:/media/frigate
      - type: tmpfs # Optional: 1GB of memory, reduces SSD/SD Card wear
        target: /tmp/cache
        tmpfs:
          size: 1000000000
    cap_add:
      - CAP_PERFMON
    ports:
      - "8971:8971"
      - "8554:8554" # RTSP feeds
    runtime: nvidia # migrate to CDI for newest nvidia driver
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              device_ids: ['0']
              capabilities: [gpu, video]

config.yaml

此处以乐橙为例子。大多摄像头可以在 iSpy 的文档找到需要的链接。
顺便一提，乐橙摄像头要求 WIFI 密码必须是字母加数字，否则不可能连接成功。

frigate 在这方面的文档出奇的烂。你需要综合翻阅完整参考配置和小节甚至 issues 。

version: 0.15-1
# 关闭 mqtt 消息队列
mqtt:
  enabled: false
# 关闭 TLS 连接（端口不变）
tls:
  enabled: false
# 关闭网页验证
auth:
  # 如果启用，admin密码会在首次启动时输出到日志。
  # 错过了没关系，看 `docker-compose logs` 输出。
  enabled: false 

ffmpeg:
  # 如果遇到 hardware capacity xxxx 问题，
  # 可以通过官方工具设置使用 H264 编码传输。
  # 如 乐橙: https://www.imou.com/en/support/download
  hwaccel_args: preset-nvidia
  # IMOU 的摄像头rtsp流，udp传输时很容易丢包、重复包、断流。
  input_args: -rtsp_transport tcp


# 保留录制历史，1天的全部视频和30天的警告/识别片段。
record:
  enabled: true
  retain:
    days: 1
    mode: all
  alerts:
    retain:
      days: 30
      mode: motion
  detections:
    retain:
      days: 30
      mode: motion

cameras:
  backyard:
    enabled: true
    ffmpeg:
      inputs:
        - path: 
            # 此处 PASSWORD 和乐橙 app 中设置的一致。
            # CAMIP 即为你的摄像头绑定的 ip 地址。
            rtsp://admin:PASSWORD@CAMIP:554/cam/realmonitor?channel=1&subtype=0
          roles:
            - detect
    detect:
      enabled: true
    # 上下左右。请勿尝试通过 onvif 启用 autotracking ，乐橙这种情况会死机。
    onvif:
      host: CAMIP
      port: 80
      user: admin
      password: PASSWORD


    motion:
      # mask掉乐橙的时间戳区域。
      mask: 0.015,0.041,0.268,0.041,0.267,0.086,0.014,0.089
      threshold: 40 # 减少树叶抖动导致的不必要 detect。
      contour_area: 10
      improve_contrast: true

# 注意：部分旧版显卡可能会遇到 onnxruntime 不支持对应 kernel 版本的问题
# 如果有 Intel CPU 可以考虑 OpenVINO - CPU 运行。
detectors:
  onnx:
    type: onnx

# 此处识别高宽和之前 ipynb 运行时设置一致。
model:
  model_type: yolonas
  width: 320 # <--- should match whatever was set in notebook
  height: 320 # <--- should match whatever was set in notebook
  input_pixel_format: bgr
  input_tensor: nchw
  path: /config/yolo_nas_s.onnx
  labelmap_path: /labelmap/coco-80.txt

如何彻底关闭服务

docker-compose down

如何通过命令行重启服务 (不推荐)

docker-compose stop
sleep 2
docker-compose start

远程桌面控制软件-二开

1348292515@qq.com (mokurin000) — Sat, 03 Jan 2026 14:00:00 +0806

前言

该博文会收录一些关于某远程软件二次开发需要的操作，请大家修改后遵循 GPLv3 要求！

官方高级设置

官方的高级设置均可以对应到 hbb_common::config::keys::OPTION_ 系列变量

hide-tray

src/tray.rs::start_tray 负责启动托盘图标，其在 macos 会强要求托盘图标启动

s/RustDesk/XXXXDesk

# 写死在一些翻译中
src/lang.rs
 -> translate_locale
    - 此处的 s.replace 会判断 upgrade_rustdesk_server_pro* 和
      powered_by_me 两个特殊字段，需要修改 APP_NAME 才会判定需要替换。
# 程序 App name
libs/hbb_common
 -> src/config.rs
    - APP_NAME

替换服务器

libs/hbb_common
 -> src/config.rs
    - RENDEZVOUS_SERVERS
    - RS_PUB_KEY

固定密码

libs/hbb_common
 -> src/config.rs
    - get_permanent_password

免安装启动器

注意：修改图标后可能由于 Windows 资源管理器图标缓存而仍显示为原本图标

Runner 本身的其他信息：

flutter/windows/runner/Runner.rc

使用 libs/portable 前需要放入 Runner.res ，res中的图标会被它的 build.rs 忽略。

Runner 和本体的图标：

res/icon.ico
flutter/windows/runner/resources/app_icon.ico

打包时，

# 包含 flutter runtime, 打印机驱动等, librustdesk.{dll,dylib,so} 的文件夹
build_dir=...
python3 ./generate.py -f ../../${build_dir}/ -o . -e ../../${build_dir}/XXXXDesk.exe

或者于CI中移除 skip_portable_pack 。

输入事件

Rustdesk 有多种不同输入方式，其中 LegacyMode 全权使用 enigo，翻译和 1:1 模式则混合使用 enigo 或 rdev。

顺带一提，Linux 平台下，Rustdesk 可能会启动输入服务并且通过IPC发送输入按键。

src/ui_session_interface.rs 中， get_keyboard_mode 负责返回会话使用的键盘模式。

poly000客栈

一些不错的Rust Unstable特性

注意

关于翻译

Credits

简介

什么是Unstable Rust？

为什么要用 Unstable 特性？

启用 Unstable 特性

控制流、模式和块

destructuring_assignment

从任意块提前返回，label_break_value

使用 try_blocks 内联 ? 操作符的功能

inline_const

if_let_guard

let_chains

Traits

associated_type_bounds

default_type_parameter_fallback, associated_type_defaults以及const_generics_defaults

negative_impls 和 auto_traits

marker_trait_attr

type_alias_impl_trait, impl_trait_in_bindings and trait_alias

fn_traits and unboxed_closures

语法糖

box_patterns and box_syntax

async_closure

in_band_lifetimes

format_args_capture

crate_visibility_modifier

Types

type_ascription

never_type

exhaustive_patterns

attribute

optimize_attribute

stmt_expr_attributes

cfg_version

no_core

其它

Const 泛型

Macros 2.0

generators

总结

C23特性简介

差异

移除

数据类型

语言特性

K&R风格函数声明与定义

标准库

废弃

标准库

关键字

新增

语言特性

应用于数组的限定修饰符

关键字

预定义宏

数据类型

字面量

预处理器指令

其他

标准库特性

现代的位运算工具

printf()对整数的二进制格式化支持

为格式化指定位长

带溢出检查的整数运算

参考资料

软RAID vs 硬RAID

Credit

正文

Win32 盘符，设备号和硬盘型号

原发布地址

列出设备

逻辑设备

卷

使用 Powershell1:

使用 mountvol.exe

使用 FindFirstVolumeW and FindNextVolumeW

获取硬盘型号

`destructuring_assignment`

从任意块提前返回，`label_break_value`

使用 `try_blocks` 内联 `?` 操作符的功能

`inline_const`

`if_let_guard`

`let_chains`

`associated_type_bounds`

`default_type_parameter_fallback`, `associated_type_defaults`以及`const_generics_defaults`

`negative_impls` 和 `auto_traits`

`marker_trait_attr`

`type_alias_impl_trait`, `impl_trait_in_bindings` and `trait_alias`

`fn_traits` and `unboxed_closures`

`box_patterns` and `box_syntax`

`async_closure`

`in_band_lifetimes`

`format_args_capture`

`crate_visibility_modifier`

`type_ascription`

`never_type`

`exhaustive_patterns`

`optimize_attribute`

`stmt_expr_attributes`

`cfg_version`

`no_core`

`generators`

使用 Powershell¹:

使用 `mountvol.exe`

使用 `FindFirstVolumeW` and `FindNextVolumeW`

使用 Powershell²

使用 `IOCTL_STORAGE_GET_DEVICE_NUMBER`