驱动程序基础¶

驱动程序入口和出口点¶

module_init¶

module_init (x)

驱动程序初始化入口点

参数

x: 在内核启动时或模块插入时运行的函数

描述

module_init() 将在 do_initcalls() 期间（如果是内置）或在模块插入时（如果是模块）被调用。每个模块只能有一个。

module_exit¶

module_exit (x)

驱动程序退出入口点

参数

x: 驱动程序移除时要运行的函数

描述

当驱动程序是一个模块时，module_exit() 将使用 cleanup_module() 包装驱动程序清理代码，当使用 rmmod 时。如果驱动程序静态编译到内核中，module_exit() 没有效果。每个模块只能有一个。

struct klp_modinfo¶: 从实时补丁模块保留的 ELF 信息

定义:

struct klp_modinfo {
    Elf_Ehdr hdr;
    Elf_Shdr *sechdrs;
    char *secstrings;
    unsigned int symndx;
};

成员

hdr: ELF 头部
sechdrs: 节头部表
secstrings: 节头部的字符串表
symndx: 符号表节索引

bool try_module_get(struct module *module)¶: 获取模块引用计数，除非模块正在被移除

参数

struct module *module: 我们应该检查的模块

描述

只有当模块没有被移除时，才尝试获取模块引用计数。如果模块正在被移除，此调用将失败。

还必须小心确保模块在使用此调用之前存在并且处于活动状态。这可以通过两种方式来保证

直接保护：您知道早期的调用者必须通过 __module_get() 增加了模块引用。这通常可以通过让另一个实体（而不是模块本身）增加模块引用计数来实现。
隐含保护：存在针对模块移除的隐含保护。kernfs / sysfs 使用的隐含保护就是一个例子。sysfs store / read 文件操作通过使用 kernfs 的活动引用（参见 kernfs_active()）来保证存在，并且除非同一个文件不活动，否则 sysfs / kernfs 文件移除不会发生。因此，如果 sysfs 文件正在被读取或写入到创建它的模块，则该模块必须仍然存在。因此，在模块 sysfs store / read ops 上使用 try_module_get() 是安全的。

try_module_get() 的一个真正价值是 module_is_live() 检查，它确保 try_module_get() 的调用者可以屈服于用户空间模块移除请求，并且如果模块正在退出，则可以优雅地失败。

如果引用计数成功增加，则返回 true。

void module_put(struct module *module)¶: 释放模块的引用计数

参数

struct module *module: 我们应该释放引用计数的模块

描述

如果您成功地使用 try_module_get() 提升了模块的引用计数，当您完成时，您必须调用 module_put() 来释放该引用计数。

驱动程序设备表¶

struct usb_device_id¶: 标识用于探测和热插拔的 USB 设备

定义:

struct usb_device_id {
    __u16 match_flags;
    __u16 idVendor;
    __u16 idProduct;
    __u16 bcdDevice_lo;
    __u16 bcdDevice_hi;
    __u8 bDeviceClass;
    __u8 bDeviceSubClass;
    __u8 bDeviceProtocol;
    __u8 bInterfaceClass;
    __u8 bInterfaceSubClass;
    __u8 bInterfaceProtocol;
    __u8 bInterfaceNumber;
    kernel_ulong_t driver_info  ;
};

成员

match_flags: 位掩码，控制其他哪些字段用于匹配新设备。可以使用除 driver_info 之外的任何字段，尽管有些字段只有与其他字段结合使用才有意义。这通常由 USB_DEVICE_*() 宏设置，它设置此结构中的所有其他字段，除了 driver_info。
idVendor: 设备的 USB 供应商 ID；数字由 USB 论坛分配给其成员。
idProduct: 供应商分配的产品 ID。
bcdDevice_lo: 供应商分配的产品版本号的范围的低端。这也用于标识单个产品版本，对于由单个设备组成的范围。
bcdDevice_hi: 版本号范围的高端。产品版本的范围是包含性的。
bDeviceClass: 设备类别；数字由 USB 论坛分配。产品可以选择实现类别，或者采用供应商特定的方式。设备类别指定设备上所有接口的行为。
bDeviceSubClass: 设备子类；与 bDeviceClass 相关联。
bDeviceProtocol: 设备协议；与 bDeviceClass 相关联。
bInterfaceClass: 接口类别；数字由 USB 论坛分配。产品可以选择实现类别，或者采用供应商特定的方式。接口类别仅指定给定接口的行为；其他接口可能支持其他类别。
bInterfaceSubClass: 接口子类；与 bInterfaceClass 相关联。
bInterfaceProtocol: 接口协议；与 bInterfaceClass 相关联。
bInterfaceNumber: 接口编号；复合设备可以使用固定的接口编号来区分供应商特定的接口。
driver_info: 保存驱动程序使用的信息。通常它保存指向驱动程序理解的描述符的指针，或者可能是设备标志。

描述

在大多数情况下，驱动程序将使用 USB_DEVICE() 或类似为此目的设计的宏创建一个设备 ID 表。然后，它们将使用 MODULE_DEVICE_TABLE() 将其导出到用户空间，并通过其 usb_driver 结构将其提供给 USB 核心。

有关如何执行匹配的信息，请参阅 usb_match_id() 函数。简而言之，您通常会使用几个宏中的一个来帮助构造这些条目。您提供的每个条目将标识一个或多个特定产品，或者将标识一类已同意以相同方式运行的产品。您应该将更具体的匹配放在表的开头，以便 driver_info 可以记录特定产品的特性。

ACPI_DEVICE_CLASS¶

ACPI_DEVICE_CLASS (_cls, _msk)

用于描述具有 PCI 定义的类别代码信息的 ACPI 设备的宏

参数

_cls: 此设备的类别、子类、prog-if 三元组
_msk: 此设备的类别掩码

描述

此宏用于创建一个匹配特定 PCI 类别的 struct acpi_device_id。.id 和 .driver_data 字段将保留使用默认值初始化的状态。

struct mdio_device_id¶: 标识 MDIO/MII 总线上的 PHY 设备

定义:

struct mdio_device_id {
    __u32 phy_id;
    __u32 phy_id_mask;
};

成员

phy_id: 此 PHY 类型的 (mdio_read(MII_PHYSID1) << 16 | mdio_read(MII_PHYSID2)) & phy_id_mask 的结果
phy_id_mask: 定义 phy_id 的有效位。值 0 用于终止 struct mdio_device_id 数组。

struct amba_id¶: 标识 AMBA 总线上的设备

定义:

struct amba_id {
    unsigned int            id;
    unsigned int            mask;
    void *data;
};

成员

id: 硬件设备 ID 的有效位
mask: 位掩码，指定匹配时 id 字段的哪些位有效。当 ((硬件设备 ID) & mask) == id 时，驱动程序绑定到设备。
data: 驱动程序使用的私有数据。

struct mips_cdmm_device_id¶: 标识 MIPS CDMM 总线中的设备

定义:

struct mips_cdmm_device_id {
    __u8 type;
};

成员

type: 设备类型标识符。

struct mei_cl_device_id¶: MEI 客户端设备标识符

定义:

struct mei_cl_device_id {
    char name[MEI_CL_NAME_SIZE];
    uuid_le uuid;
    __u8 version;
    kernel_ulong_t driver_info;
};

成员

name: 助手名称
uuid: 客户端 uuid
version: 客户端协议版本
driver_info: 驱动程序使用的信息。

描述

按 uuid 和名称标识 mei 客户端设备

struct rio_device_id¶: RIO 设备标识符

定义:

struct rio_device_id {
    __u16 did, vid;
    __u16 asm_did, asm_vid;
};

成员

did: RapidIO 设备 ID
vid: RapidIO 供应商 ID
asm_did: RapidIO 组合设备 ID
asm_vid: RapidIO 组合供应商 ID

描述

基于设备/供应商 ID 和组合设备/供应商 ID 标识 RapidIO 设备。

struct fsl_mc_device_id¶: MC 对象设备标识符

定义:

struct fsl_mc_device_id {
    __u16 vendor;
    const char obj_type[16];
};

成员

vendor: 供应商 ID
obj_type: MC 对象类型

描述

MC 对象设备驱动程序支持的 MC 对象设备的“设备 Id”表中的条目类型。该表的最后一个条目的 vendor 设置为 0x0

struct tb_service_id¶: Thunderbolt 服务标识符

定义:

struct tb_service_id {
    __u32 match_flags;
    char protocol_key[8 + 1];
    __u32 protocol_id;
    __u32 protocol_version;
    __u32 protocol_revision;
    kernel_ulong_t driver_data;
};

成员

match_flags: 用于匹配结构的标志
protocol_key: 服务支持的协议密钥
protocol_id: 服务支持的协议 id
protocol_version: 协议版本
protocol_revision: 协议软件的修订版
driver_data: 驱动程序特定数据

描述

Thunderbolt XDomain 服务作为设备公开，其中每个设备都携带服务支持的协议信息。Thunderbolt XDomain 服务驱动程序针对该信息进行匹配。

struct typec_device_id¶: USB Type-C 替代模式标识符

定义:

struct typec_device_id {
    __u16 svid;
    __u8 mode;
    kernel_ulong_t driver_data;
};

成员

svid: 标准或供应商 ID
mode: 模式索引
driver_data: 驱动程序特定数据

struct tee_client_device_id¶: 基于 TEE 的设备标识符

定义:

struct tee_client_device_id {
    uuid_t uuid;
};

成员

uuid: 对于基于 TEE 的客户端设备，我们使用设备 uuid 作为标识符。

struct wmi_device_id¶: WMI 设备标识符

定义:

struct wmi_device_id {
    const char guid_string[UUID_STRING_LEN+1];
    const void *context;
};

成员

guid_string: 形式为 fa50ff2b-f2e8-45de-83fa-65417f2f49ba 的 36 个字符的字符串
context: 指向驱动程序特定数据的指针

struct mhi_device_id¶: MHI 设备标识

定义:

struct mhi_device_id {
    const char chan[MHI_NAME_SIZE];
    kernel_ulong_t driver_data;
};

成员

chan: MHI 通道名称
driver_data: 驱动程序数据；

struct dfl_device_id¶: dfl 设备标识符

定义:

struct dfl_device_id {
    __u16 type;
    __u16 feature_id;
    kernel_ulong_t driver_data;
};

成员

type: 设备的 DFL FIU 类型。请参阅 enum dfl_id_type。
feature_id: 特征标识符，对其 DFL FIU 类型是局部的。
driver_data: 驱动程序特定数据。

struct ishtp_device_id¶: ISHTP 设备标识符

定义:

struct ishtp_device_id {
    guid_t guid;
    kernel_ulong_t driver_data;
};

成员

guid: 设备的 GUID。
driver_data: 指向驱动程序特定数据的指针

struct cdx_device_id¶: CDX 设备标识符

定义:

struct cdx_device_id {
    __u16 vendor;
    __u16 device;
    __u16 subvendor;
    __u16 subdevice;
    __u32 class;
    __u32 class_mask;
    __u32 override_only;
};

成员

vendor: Vendor ID
device: 设备 ID
subvendor: 子系统供应商 ID（或 CDX_ANY_ID）
subdevice: 子系统设备 ID（或 CDX_ANY_ID）
class: 设备类别。大多数驱动程序不需要指定类别/class_mask，因为 vendor/device 通常就足够了。
class_mask: 限制比较类别字段的哪些子字段。
override_only: 仅当 dev->driver_override 是此驱动程序时才匹配。

描述

CDX 设备驱动程序支持的 CDX 设备的“设备 Id”表中的条目类型。

struct coreboot_device_id¶: 标识 coreboot 表条目

定义:

struct coreboot_device_id {
    __u32 tag;
    kernel_ulong_t driver_data;
};

成员

tag: 标记 ID
driver_data: 驱动程序特定数据

延迟和调度例程¶

struct prev_cputime¶: 系统和用户 cputime 的快照

定义:

struct prev_cputime {
#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE;
    u64 utime;
    u64 stime;
    raw_spinlock_t lock;
#endif;
};

成员

utime: 花费在用户模式的时间
stime: 花费在系统模式的时间
lock: 保护上述两个字段

描述

存储先前的用户/系统时间值，以便我们可以保证单调性。

int set_cpus_allowed_ptr(struct task_struct *p, const struct cpumask *new_mask)¶: 设置任务的 CPU 亲和性掩码

参数

struct task_struct *p: 任务
const struct cpumask *new_mask: CPU 亲和性掩码

返回

成功时返回零，或返回负错误代码

int task_nice(const struct task_struct *p)¶: 返回给定任务的 nice 值。

参数

const struct task_struct *p: 有问题的任务。

返回

nice 值 [ -20 ... 0 ... 19 ]。

bool is_idle_task(const struct task_struct *p)¶: 指定的任务是否为空闲任务？

参数

const struct task_struct *p: 有问题的任务。

返回

如果 p 是空闲任务，则为 1。否则为 0。

int wake_up_process(struct task_struct *p)¶: 唤醒指定的进程

参数

struct task_struct *p: 要唤醒的进程。

描述

尝试唤醒指定的进程，并将其移动到可运行进程的集合中。

此函数在访问任务状态之前执行完整的内存屏障。

返回

如果进程被唤醒，则为 1，如果进程已在运行，则为 0。

void preempt_notifier_register(struct preempt_notifier *notifier)¶: 当 current 进程被抢占和重新调度时通知我

参数

struct preempt_notifier *notifier: 要注册的通知器结构体

void preempt_notifier_unregister(struct preempt_notifier *notifier)¶: 不再对抢占通知感兴趣

参数

struct preempt_notifier *notifier: 要注销的通知器结构体

描述

从抢占通知器内部调用此函数是不安全的。

__visible void notrace preempt_schedule_notrace(void)¶: tracing 调用的 preempt_schedule

参数

void: 无参数

描述

tracing 基础设施使用 preempt_enable_notrace 来防止递归和由 tracing 基础设施本身引起的 tracing 抢占启用。但是，由于 tracing 可能发生在来自用户空间或即将进入用户空间的区域中，因此可能在调用 user_exit() 之前发生抢占启用。这将导致调度器在系统仍处于用户模式时被调用。

为了防止这种情况，preempt_enable_notrace 将使用此函数代替 preempt_schedule()，以便在调用调度器之前根据需要退出用户上下文。

int cpupri_find_fitness(struct cpupri *cp, struct task_struct *p, struct cpumask *lowest_mask, bool (*fitness_fn)(struct task_struct *p, int cpu))¶: 查找系统中最佳（最低优先级）的 CPU

参数

struct cpupri *cp: cpupri 上下文
struct task_struct *p: 任务
struct cpumask *lowest_mask: 用于填充所选 CPU 的掩码（或 NULL）
bool (*fitness_fn)(struct task_struct *p, int cpu): 指向函数的指针，用于执行自定义检查，以确定 CPU 是否符合特定标准，以便我们只返回这些 CPU。

注意

此函数返回在当前调用期间计算的建议 CPU。在调用返回时，CPU 实际上可能已更改优先级多次。虽然不理想，但这不是正确性的问题，因为正常的重新平衡器逻辑会纠正因与当前优先级配置的不确定性竞争而产生的任何差异。

返回

(int)bool - 找到 CPU

void cpupri_set(struct cpupri *cp, int cpu, int newpri)¶: 更新 CPU 优先级设置

参数

struct cpupri *cp: cpupri 上下文
int cpu: 目标 CPU
int newpri: 要分配给此 CPU 的优先级（INVALID、NORMAL、RT1-RT99、HIGHER）

注意

假定 cpu_rq(cpu)->lock 已锁定

返回

(void)

int cpupri_init(struct cpupri *cp)¶: 初始化 cpupri 结构

参数

struct cpupri *cp: cpupri 上下文

返回

内存分配失败时返回 -ENOMEM。

void cpupri_cleanup(struct cpupri *cp)¶: 清理 cpupri 结构

参数

struct cpupri *cp: cpupri 上下文

void update_tg_load_avg(struct cfs_rq *cfs_rq)¶: 更新 tg 的负载平均值

参数

struct cfs_rq *cfs_rq: 负载平均值发生更改的 cfs_rq

描述

此函数“确保”：tg->load_avg := Sum tg->cfs_rq[]->avg.load。但是，由于 tg->load_avg 是一个全局值，因此存在性能方面的考虑。

为了避免查看其他 cfs_rq，我们使用差异更新，在其中存储我们传播的最后一个值。这反过来允许如果差异“很小”则跳过更新。

更新 tg 的 load_avg 在 update_cfs_share() 之前是必要的。

int update_cfs_rq_load_avg(u64 now, struct cfs_rq *cfs_rq)¶: 更新 cfs_rq 的负载/利用率平均值

参数

u64 now: 当前时间，根据 cfs_rq_clock_pelt()
struct cfs_rq *cfs_rq: 要更新的 cfs_rq

描述

cfs_rq 平均值是其所有实体（阻塞和可运行）平均值的直接总和。直接的推论是所有（公平）任务都必须附加。

cfs_rq->avg 用于 task_h_load() 和 update_cfs_share()，例如。

由于这两个条件都表明 cfs_rq->avg.load 已更改，因此当此函数返回 true 时，我们应调用 update_tg_load_avg()。

返回

如果负载衰减或我们移除了负载，则为 true。

void attach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)¶: 将此实体附加到其 cfs_rq 负载平均值

参数

struct cfs_rq *cfs_rq: 要附加到的 cfs_rq
struct sched_entity *se: 要附加的 sched_entity

描述

必须在此之前调用 update_cfs_rq_load_avg()，因为我们依赖于 cfs_rq->avg.last_update_time 是当前的。

void detach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)¶: 将此实体从其 cfs_rq 负载平均值分离

参数

struct cfs_rq *cfs_rq: 要分离的 cfs_rq
struct sched_entity *se: 要分离的 sched_entity

描述

必须在此之前调用 update_cfs_rq_load_avg()，因为我们依赖于 cfs_rq->avg.last_update_time 是当前的。

unsigned long cpu_util(int cpu, struct task_struct *p, int dst_cpu, int boost)¶: 估计 CFS 任务使用的 CPU 容量。

参数

int cpu: 要获取利用率的 CPU
struct task_struct *p: 应为其预测 CPU 利用率的任务或 NULL
int dst_cpu: p 迁移到的 CPU，如果 p 从 cpu 移动或 p == NULL，则为 -1
int boost: 1 表示启用 boosting，否则为 0

描述

返回值单位必须与 CPU 容量的单位相同，以便可以将 CPU 利用率与 CPU 容量进行比较。

CPU 利用率是可运行任务的运行时间与该 CPU 上当前不可运行任务的最近利用率之和。它表示 CFS 任务当前使用的 CPU 容量，范围为 [0..最大 CPU 容量]，最大 CPU 容量为 f_max 时的 CPU 容量。

估计的 CPU 利用率定义为 CPU 利用率与该 CPU 上当前可运行任务的估计利用率之和之间的最大值。它保留了先前执行的任务的利用率“快照”，这有助于更好地推断长时间休眠的任务唤醒时 CPU 将有多忙。在此时，此类任务对 CPU 利用率的贡献将显着衰减。

提升的 CPU 利用率定义为 max(CPU 可运行, CPU 利用率)。 CFS 任务的 CPU 争用可以通过 CPU 可运行 > CPU 利用率来检测。 Boosting 在 cpu_util() 中实现，以便内部用户（例如 EAS）可以与外部用户（例如 schedutil）一起使用它，后者通过 cpu_util_cfs_boost()。

由于舍入误差以及任务迁移或新任务的唤醒，CPU 利用率可能高于当前 CPU 容量（f_curr/f_max * 最大 CPU 容量）甚至最大 CPU 容量。 CPU 利用率必须被限制为适合 [0..最大 CPU 容量] 范围。否则，一组 CPU（CPU0 util = 121% + CPU1 util = 80%）可能被视为过度利用，即使 CPU1 有 20% 的剩余 CPU 容量。但是，允许 CPU 利用率超过当前 CPU 容量，因为这对于预测任务迁移后所需的 CPU 容量（调度程序驱动的 DVFS）很有用。

返回

指定 CPU 的（提升的）（估计的）利用率。

bool sched_use_asym_prio(struct sched_domain *sd, int cpu)¶: 检查是否必须使用 asym_packing 优先级

参数

struct sched_domain *sd: 负载平衡的调度域
int cpu: 一个 CPU

描述

在 SMT 兄弟之间平衡负载时，始终使用 CPU 优先级。在内核之间平衡负载时，仅 cpu 处于空闲状态是不够的。只有在整个内核都处于空闲状态时，才使用 CPU 优先级。

返回

如果必须遵循 cpu 的优先级，则为 True。否则为 False。

bool sched_group_asym(struct lb_env *env, struct sg_lb_stats *sgs, struct sched_group *group)¶: 检查目标 CPU 是否可以执行 asym_packing 平衡

参数

struct lb_env *env: 负载平衡环境
struct sg_lb_stats *sgs: 候选最繁忙组的负载平衡统计信息
struct sched_group *group: 候选最繁忙组

描述

如果 env::dst_cpu 的优先级高于 group 的首选 CPU，则它可以执行 asym_packing。

返回

如果 env::dst_cpu 可以执行 asym_packing 负载平衡，则为 true。否则为 False。

void update_sg_lb_stats(struct lb_env *env, struct sd_lb_stats *sds, struct sched_group *group, struct sg_lb_stats *sgs, bool *sg_overloaded, bool *sg_overutilized)¶: 更新 sched_group 的负载平衡统计信息。

参数

struct lb_env *env: 负载平衡环境。
struct sd_lb_stats *sds: 带有本地组统计信息的负载平衡数据。
struct sched_group *group: 要更新统计信息的 sched_group。
struct sg_lb_stats *sgs: 用于保存此组的统计信息的变量。
bool *sg_overloaded: sched_group 已过载
bool *sg_overutilized: sched_group 已过度利用

bool update_sd_pick_busiest(struct lb_env *env, struct sd_lb_stats *sds, struct sched_group *sg, struct sg_lb_stats *sgs)¶: 在最繁忙的组上返回 1

参数

struct lb_env *env: 负载平衡环境。
struct sd_lb_stats *sds: sched_domain 统计信息
struct sched_group *sg: 要检查是否为最繁忙的 sched_group 候选者
struct sg_lb_stats *sgs: sched_group 统计信息

描述

确定 sg 是否比先前选择的最繁忙组更繁忙的组。

返回

如果 sg 是比先前选择的最繁忙组更繁忙的组，则为 true。否则为 false。

int idle_cpu_without(int cpu, struct task_struct *p)¶: 如果没有 p，给定的 CPU 是否会空闲？

参数

int cpu: 测试空闲状态的处理器。
struct task_struct *p: 应忽略的任务。

返回

如果 CPU 将会空闲，则为 1。否则为 0。

void update_sd_lb_stats(struct lb_env *env, struct sd_lb_stats *sds)¶: 更新 sched_domain 的负载均衡统计信息。

参数

struct lb_env *env: 负载平衡环境。
struct sd_lb_stats *sds: 用于保存此 sched_domain 的统计信息的变量。

void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *sds)¶: 计算负载均衡期间给定 sched_domain 的组中存在的不平衡量。

参数

struct lb_env *env: 负载均衡环境
struct sd_lb_stats *sds: 要计算不平衡的 sched_domain 的统计信息。

struct sched_group *sched_balance_find_src_group(struct lb_env *env)¶: 如果 sched_domain 中存在不平衡，则返回其中最繁忙的组。

参数

struct lb_env *env: 负载平衡环境。

描述

还计算应移动以恢复平衡的可运行负载量。

返回

如果存在不平衡，则为最繁忙的组。

DECLARE_COMPLETION¶

DECLARE_COMPLETION (work)

声明并初始化一个 completion 结构

参数

工作: completion 结构的标识符

描述

此宏声明并初始化一个 completion 结构。通常用于静态声明。对于自动变量，应使用 _ONSTACK 变体。

DECLARE_COMPLETION_ONSTACK¶

DECLARE_COMPLETION_ONSTACK (work)

声明并初始化一个 completion 结构

参数

工作: completion 结构的标识符

描述

此宏在内核堆栈上声明并初始化一个 completion 结构。

void init_completion(struct completion *x)¶: 初始化动态分配的 completion

参数

struct completion *x: 指向要初始化的 completion 结构的指针

描述

此内联函数将初始化一个动态创建的 completion 结构。

void reinit_completion(struct completion *x)¶: 重新初始化 completion 结构

参数

struct completion *x: 指向要重新初始化的 completion 结构的指针

描述

应使用此内联函数重新初始化 completion 结构，以便可以重复使用它。在使用 complete_all() 之后，这一点尤其重要。

时间和定时器例程¶

u64 get_jiffies_64(void)¶: 读取 64 位非原子 jiffies_64 值

参数

void: 无参数

描述

当 BITS_PER_LONG < 64 时，这将使用序列号采样，并使用 jiffies_lock 来保护 64 位读取。

返回

当前的 64 位 jiffies 值

time_after¶

time_after (a, b)

如果时间 a 在时间 b 之后，则返回 true。

参数

a: 第一个可比较的无符号长整数
b: 第二个可比较的无符号长整数

描述

使用“<0”和“>=0”来仅测试结果的符号。一个好的编译器会生成更好的代码（而一个非常好的编译器不会在意）。Gcc 目前两者都不是。

返回

如果时间 a 在时间 b 之后，则为 true，否则为 false。

time_before¶

time_before (a, b)

如果时间 a 在时间 b 之前，则返回 true。

参数

a: 第一个可比较的无符号长整数
b: 第二个可比较的无符号长整数

返回

如果时间 a 在时间 b 之前，则为 true，否则为 false。

time_after_eq¶

time_after_eq (a, b)

如果时间 a 在时间 b 之后或与时间 b 相同，则返回 true。

参数

a: 第一个可比较的无符号长整数
b: 第二个可比较的无符号长整数

返回

如果时间 a 在时间 b 之后或与时间 b 相同，则为 true，否则为 false。

time_before_eq¶

time_before_eq (a, b)

如果时间 a 在时间 b 之前或与时间 b 相同，则返回 true。

参数

a: 第一个可比较的无符号长整数
b: 第二个可比较的无符号长整数

返回

如果时间 a 在时间 b 之前或与时间 b 相同，则为 true，否则为 false。

time_in_range¶

time_in_range (a, b, c)

计算 a 是否在 [b, c] 的范围内。

参数

a: 要测试的时间
b: 范围的开始
c: 范围的结束

返回

如果时间 a 在 [b, c] 的范围内，则为 true，否则为 false。

time_in_range_open¶

time_in_range_open (a, b, c)

计算 a 是否在 [b, c) 的范围内。

参数

a: 要测试的时间
b: 范围的开始
c: 范围的结束

返回

如果时间 a 在 [b, c) 的范围内，则为 true，否则为 false。

time_after64¶

time_after64 (a, b)

如果时间 a 在时间 b 之后，则返回 true。

参数

a: 第一个可比较的 __u64
b: 第二个可比较的 __u64

描述

在使用 jiffies_64（即 get_jiffies_64() 的返回值）时，必须使用此函数。

返回

如果时间 a 在时间 b 之后，则为 true，否则为 false。

time_before64¶

time_before64 (a, b)

如果时间 a 在时间 b 之前，则返回 true。

参数

a: 第一个可比较的 __u64
b: 第二个可比较的 __u64

描述

在使用 jiffies_64（即 get_jiffies_64() 的返回值）时，必须使用此函数。

返回

如果时间 a 在时间 b 之前，则为 true，否则为 false。

time_after_eq64¶

time_after_eq64 (a, b)

如果时间 a 在时间 b 之后或与时间 b 相同，则返回 true。

参数

a: 第一个可比较的 __u64
b: 第二个可比较的 __u64

描述

在使用 jiffies_64（即 get_jiffies_64() 的返回值）时，必须使用此函数。

返回

如果时间 a 在时间 b 之后或与时间 b 相同，则为 true，否则为 false。

time_before_eq64¶

time_before_eq64 (a, b)

如果时间 a 在时间 b 之前或与时间 b 相同，则返回 true。

参数

a: 第一个可比较的 __u64
b: 第二个可比较的 __u64

描述

在使用 jiffies_64（即 get_jiffies_64() 的返回值）时，必须使用此函数。

返回

如果时间 a 在时间 b 之前或与时间 b 相同，则为 true，否则为 false。

time_in_range64¶

time_in_range64 (a, b, c)

计算 a 是否在 [b, c] 的范围内。

参数

a: 要测试的时间
b: 范围的开始
c: 范围的结束

返回

如果时间 a 在 [b, c] 的范围内，则为 true，否则为 false。

time_is_before_jiffies¶

time_is_before_jiffies (a)

如果 a 在 jiffies 之前，则返回 true

参数

a: 要与 jiffies 进行比较的时间（无符号长整数）

返回

如果时间 a 在 jiffies 之前，则为 true，否则为 false。

time_is_before_jiffies64¶

time_is_before_jiffies64 (a)

如果 a 在 jiffies_64 之前，则返回 true

参数

a: 要与 jiffies_64 进行比较的时间（__u64）

返回

如果时间 a 在 jiffies_64 之前，则为 true，否则为 false。

time_is_after_jiffies¶

time_is_after_jiffies (a)

如果 a 在 jiffies 之后，则返回 true

参数

a: 要与 jiffies 进行比较的时间（无符号长整数）

返回

如果时间 a 在 jiffies 之后，则为 true，否则为 false。

time_is_after_jiffies64¶

time_is_after_jiffies64 (a)

如果 a 在 jiffies_64 之后，则返回 true

参数

a: 要与 jiffies_64 进行比较的时间（__u64）

返回

如果时间 a 在 jiffies_64 之后，则为 true，否则为 false。

time_is_before_eq_jiffies¶

time_is_before_eq_jiffies (a)

如果 a 在 jiffies 之前或与 jiffies 相等，则返回 true

参数

a: 要与 jiffies 进行比较的时间（无符号长整数）

返回

如果时间 a 在 jiffies 之前或与 jiffies 相同，则为 true，否则为 false。

time_is_before_eq_jiffies64¶

time_is_before_eq_jiffies64 (a)

如果 a 在 jiffies_64 之前或与 jiffies_64 相等，则返回 true

参数

a: 要与 jiffies_64 进行比较的时间（__u64）

返回

如果时间 a 在 jiffies_64 之前或与 jiffies_64 相同，则为 true，否则为 false。

time_is_after_eq_jiffies¶

time_is_after_eq_jiffies (a)

如果 a 在 jiffies 之后或与 jiffies 相等，则返回 true

参数

a: 要与 jiffies 进行比较的时间（无符号长整数）

返回

如果时间 a 在 jiffies 之后或与 jiffies 相同，则为 true，否则为 false。

time_is_after_eq_jiffies64¶

time_is_after_eq_jiffies64 (a)

如果 a 在 jiffies_64 之后或与 jiffies_64 相等，则返回 true

参数

a: 要与 jiffies_64 进行比较的时间（__u64）

返回

如果时间 a 在 jiffies_64 之后或与 jiffies_64 相同，则为 true，否则为 false。

u64 jiffies_to_nsecs(const unsigned long j)¶: 将 jiffies 转换为纳秒

参数

const unsigned long j: jiffies 值

返回

纳秒值

unsigned long msecs_to_jiffies(const unsigned int m)¶

将毫秒转换为 jiffies

参数

const unsigned int m: 以毫秒为单位的时间

描述

转换按如下方式完成

负值表示“无限超时”(MAX_JIFFY_OFFSET)
“太大”的值[这将导致大于 MAX_JIFFY_OFFSET 的值]也意味着“无限超时”。
所有其他值都通过将输入值乘以一个因子或除以一个因子并处理任何 32 位溢出来转换为 jiffies。有关详细信息，请参见 _msecs_to_jiffies()

msecs_to_jiffies() 通过 __builtin_constant_p() 检查传入的值是否为常量，从而允许 gcc 删除大部分代码。如果传入的值不允许常量折叠，并且必须在运行时完成实际转换，则调用 __msecs_to_jiffies()。HZ 范围特定的帮助程序 _msecs_to_jiffies() 在此处直接调用，并在无法进行常量折叠的情况下从 __msecs_to_jiffies() 调用。

返回

jiffies 值

secs_to_jiffies¶

secs_to_jiffies (_secs)

将秒转换为 jiffies

参数

_secs: 以秒为单位的时间

描述

通过简单地与 HZ 相乘来完成转换

secs_to_jiffies() 被定义为宏而不是静态内联函数，因此可以在静态初始化器中使用它。

返回

jiffies 值

unsigned long usecs_to_jiffies(const unsigned int u)¶

将微秒转换为 jiffies

参数

const unsigned int u: 以微秒为单位的时间

描述

转换按如下方式完成

“太大”的值[这将导致大于 MAX_JIFFY_OFFSET 的值]也意味着“无限超时”。
所有其他值都通过将输入值乘以一个因子或除以一个因子并处理任何 32 位溢出来转换为 jiffies，如 msecs_to_jiffies 一样。

usecs_to_jiffies() 通过 __builtin_constant_p() 检查传入的值是否为常量，从而允许 gcc 删除大部分代码。如果传入的值不允许常量折叠，并且必须在运行时完成实际转换，则调用 __usecs_to_jiffies()。HZ 范围特定的帮助程序 _usecs_to_jiffies() 在此处直接调用，并在无法进行常量折叠的情况下从 __msecs_to_jiffies() 调用。

返回

jiffies 值

unsigned int jiffies_to_msecs(const unsigned long j)¶: 将jiffies转换为毫秒

参数

const unsigned long j: jiffies 值

描述

避免在两种最常见的HZ情况下进行不必要的乘法/除法。

返回

毫秒值

unsigned int jiffies_to_usecs(const unsigned long j)¶: 将jiffies转换为微秒

参数

const unsigned long j: jiffies 值

返回

微秒值

time64_t mktime64(const unsigned int year0, const unsigned int mon0, const unsigned int day, const unsigned int hour, const unsigned int min, const unsigned int sec)¶: 将日期转换为秒数。

参数

const unsigned int year0: 要转换的年份
const unsigned int mon0: 要转换的月份
const unsigned int day: 要转换的日期
const unsigned int hour: 要转换的小时
const unsigned int min: 要转换的分钟
const unsigned int sec: 要转换的秒

描述

将公历日期转换为自 1970-01-01 00:00:00 以来的秒数。假设输入采用正常日期格式，即 1980-12-31 23:59:59 => year=1980, mon=12, day=31, hour=23, min=59, sec=59。

[对于儒略历（1917 年之前在俄罗斯使用，1752 年之前在英国及其殖民地使用，1582 年之前在其他任何地方使用，并且至今仍被某些社区使用），请省略 -year/100+year/400 项，并加上 10。]

该算法最初由高斯发表（我认为）。

可以通过将此函数与 sec 作为 60 调用来指示闰秒（ISO 8601 允许）。闰秒的处理方式与下一个秒相同，因为它们在 UNIX 时间中不存在。

支持将一天结束时的午夜编码为 24:00:00 - 即。明天的午夜 -（ISO 8601 允许）。

返回

给定输入日期的自纪元时间以来的秒数

void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec)¶: 设置 timespec 秒和纳秒部分并进行规范化

参数

struct timespec64 *ts: 指向要设置的 timespec 变量的指针
time64_t sec: 要设置的秒数
s64 nsec: 要设置的纳秒

描述

设置 timespec 变量的秒和纳秒字段，并规范化为 timespec 存储格式

注意

tv_nsec 部分始终在 0 <= tv_nsec < NSEC_PER_SEC 范围内。对于负值，只有 tv_sec 字段为负！

struct timespec64 ns_to_timespec64(s64 nsec)¶: 将纳秒转换为 timespec64

参数

s64 nsec: 要转换的纳秒值

返回

nsec 参数的 timespec64 表示形式。

unsigned long __msecs_to_jiffies(const unsigned int m)¶

将毫秒转换为 jiffies

参数

const unsigned int m: 以毫秒为单位的时间

描述

转换按如下方式完成

负值表示“无限超时”(MAX_JIFFY_OFFSET)
“太大”的值[这将导致大于 MAX_JIFFY_OFFSET 的值]也意味着“无限超时”。
所有其他值都通过将输入值乘以一个因子或除以一个因子并处理任何 32 位溢出来转换为 jiffies。有关详细信息，请参见 _msecs_to_jiffies()

msecs_to_jiffies() 通过 __builtin_constant_p() 检查传入的值是否为常量，从而允许 gcc 删除大部分代码，如果传递的值不允许常量折叠并且必须在运行时完成实际转换，则调用 __msecs_to_jiffies()。 _msecs_to_jiffies 辅助函数是在 include/linux/jiffies.h 中找到的与 HZ 相关的转换例程

返回

jiffies 值

unsigned long __usecs_to_jiffies(const unsigned int u)¶

将微秒转换为 jiffies

参数

const unsigned int u: 以毫秒为单位的时间

返回

jiffies 值

unsigned long timespec64_to_jiffies(const struct timespec64 *value)¶: 将 timespec64 值转换为 jiffies

参数

const struct timespec64 *value: 指向 struct timespec64 的指针

描述

TICK_NSEC - 1 将值向上舍入到下一个分辨率。请注意，此处的余数减法不起作用，因为分辨率值不落在秒边界上。即：nsec -= nsec % TICK_NSEC; 不是正确的舍入分辨率。请注意，由于此处乘数中的小错误，对于足够大的 tv_nsec 值，此舍入不正确，但格式正确的 timespec 应具有 tv_nsec < NSEC_PER_SEC，因此我们没问题。

相反，我们只需将位从右侧移开。

>> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) 将缩放的纳秒值转换为缩放的秒值。

返回

jiffies 值

void jiffies_to_timespec64(const unsigned long jiffies, struct timespec64 *value)¶: 将 jiffies 值转换为 struct timespec64

参数

const unsigned long jiffies: jiffies 值
struct timespec64 *value: 指向 struct timespec64 的指针

clock_t jiffies_to_clock_t(unsigned long x)¶: 将 jiffies 转换为 clock_t

参数

unsigned long x: jiffies 值

返回

jiffies 转换为 clock_t (CLOCKS_PER_SEC)

unsigned long clock_t_to_jiffies(unsigned long x)¶: 将 clock_t 转换为 jiffies

参数

unsigned long x: clock_t 值

返回

转换为 jiffies 的 clock_t 值

u64 jiffies_64_to_clock_t(u64 x)¶: 将 jiffies_64 转换为 clock_t

参数

u64 x: jiffies_64 值

返回

转换为 64 位“clock_t”的 jiffies_64 值 (CLOCKS_PER_SEC)

u64 jiffies64_to_nsecs(u64 j)¶: 将 jiffies64 转换为纳秒

参数

u64 j: jiffies64 值

返回

纳秒值

u64 jiffies64_to_msecs(const u64 j)¶: 将 jiffies64 转换为毫秒

参数

const u64 j: jiffies64 值

返回

毫秒值

u64 nsecs_to_jiffies64(u64 n)¶: 将 u64 中的 nsecs 转换为 jiffies64

参数

u64 n: u64 中的 nsecs

描述

与 {m,u}secs_to_jiffies 不同，输入的类型不是 unsigned int 而是 u64。并且这不会返回 MAX_JIFFY_OFFSET，因为此函数专为调度程序设计，而不是用于设备驱动程序来计算超时值。

注意

NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512) ULLONG_MAX ns = 18446744073.709551615 secs = 约 584 年

返回

转换为 jiffies64 值的 nsecs

unsigned long nsecs_to_jiffies(u64 n)¶: 将 u64 中的 nsecs 转换为 jiffies

参数

u64 n: u64 中的 nsecs

描述

与 {m,u}secs_to_jiffies 不同，输入的类型不是 unsigned int 而是 u64。并且这不会返回 MAX_JIFFY_OFFSET，因为此函数专为调度程序设计，而不是用于设备驱动程序来计算超时值。

注意

NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512) ULLONG_MAX ns = 18446744073.709551615 secs = 约 584 年

返回

转换为 jiffies 值的 nsecs

int get_timespec64(struct timespec64 *ts, const struct __kernel_timespec __user *uts)¶: 将用户的时间值获取到内核空间

参数

struct timespec64 *ts: 目标 struct timespec64
const struct __kernel_timespec __user *uts: 用户的时间值作为 struct __kernel_timespec

描述

处理兼容模式或 32 位模式。

返回

成功时为 0，出错时为负 errno

int put_timespec64(const struct timespec64 *ts, struct __kernel_timespec __user *uts)¶: 将 timespec64 值转换为 __kernel_timespec 格式，并将后者复制到用户空间

参数

const struct timespec64 *ts: 输入 struct timespec64
struct __kernel_timespec __user *uts: 用户的 struct __kernel_timespec

返回

成功时为 0，出错时为负 errno

int get_old_timespec32(struct timespec64 *ts, const void __user *uts)¶: 将用户的旧格式时间值获取到内核空间

参数

struct timespec64 *ts: 目标 struct timespec64
const void __user *uts: 用户的旧格式时间值 (struct old_timespec32)

描述

处理 X86_X32_ABI 兼容性转换。

返回

成功时为 0，出错时为负 errno

int put_old_timespec32(const struct timespec64 *ts, void __user *uts)¶: 将 timespec64 值转换为 struct old_timespec32 并将后者复制到用户空间

参数

const struct timespec64 *ts: 输入 struct timespec64
void __user *uts: 用户的 struct old_timespec32

描述

处理 X86_X32_ABI 兼容性转换。

返回

成功时为 0，出错时为负 errno

int get_itimerspec64(struct itimerspec64 *it, const struct __kernel_itimerspec __user *uit)¶: 获取用户的 struct __kernel_itimerspec 到内核空间

参数

struct itimerspec64 *it: 目标 struct itimerspec64
const struct __kernel_itimerspec __user *uit: 用户的 struct __kernel_itimerspec

返回

成功时为 0，出错时为负 errno

int put_itimerspec64(const struct itimerspec64 *it, struct __kernel_itimerspec __user *uit)¶: 转换 struct itimerspec64 为 __kernel_itimerspec 格式并将后者复制到用户空间

参数

const struct itimerspec64 *it: 输入 struct itimerspec64
struct __kernel_itimerspec __user *uit: 用户的 struct __kernel_itimerspec

返回

成功时为 0，出错时为负 errno

int get_old_itimerspec32(struct itimerspec64 *its, const struct old_itimerspec32 __user *uits)¶: 获取用户的 struct old_itimerspec32 到内核空间

参数

struct itimerspec64 *its: 目标 struct itimerspec64
const struct old_itimerspec32 __user *uits: 用户的 struct old_itimerspec32

返回

成功时为 0，出错时为负 errno

int put_old_itimerspec32(const struct itimerspec64 *its, struct old_itimerspec32 __user *uits)¶: 转换 struct itimerspec64 为 struct old_itimerspec32 并将后者复制到用户空间

参数

const struct itimerspec64 *its: 输入 struct itimerspec64
struct old_itimerspec32 __user *uits: 用户的 struct old_itimerspec32

返回

成功时为 0，出错时为负 errno

unsigned long __round_jiffies_relative(unsigned long j, int cpu)¶: 将节拍数四舍五入到整秒的函数

参数

unsigned long j: 应该四舍五入的时间（相对）节拍数
int cpu: 超时将发生的处理器编号

描述

__round_jiffies_relative() 将未来的时间增量（以节拍数为单位）向上或向下舍入到（大约）整秒。这对于定时器很有用，只要它们大约每 X 秒触发一次，它们触发的准确时间并不重要。

通过将这些计时器舍入为整秒，所有这些计时器将同时触发，而不是分散在各个时间点。这样做的目的是减少 CPU 的唤醒次数，从而节省电力。

每个处理器的精确舍入都是倾斜的，以避免所有处理器在完全相同的时间触发，这可能导致锁争用或虚假的缓存行跳动。

返回值是参数 **j** 的舍入版本。

unsigned long round_jiffies(unsigned long j)¶: 将节拍数四舍五入到整秒的函数

参数

unsigned long j: 应该四舍五入的时间（绝对）节拍数

描述

round_jiffies() 将未来的绝对时间（以节拍数为单位）向上或向下舍入到（大约）整秒。这对于定时器很有用，只要它们大约每 X 秒触发一次，它们触发的准确时间并不重要。

通过将这些计时器舍入为整秒，所有这些计时器将同时触发，而不是分散在各个时间点。这样做的目的是减少 CPU 的唤醒次数，从而节省电力。

返回值是参数 **j** 的舍入版本。

unsigned long round_jiffies_relative(unsigned long j)¶: 将节拍数四舍五入到整秒的函数

参数

unsigned long j: 应该四舍五入的时间（相对）节拍数

描述

round_jiffies_relative() 将未来的时间增量（以节拍数为单位）向上或向下舍入到（大约）整秒。这对于定时器很有用，只要它们大约每 X 秒触发一次，它们触发的准确时间并不重要。

通过将这些计时器舍入为整秒，所有这些计时器将同时触发，而不是分散在各个时间点。这样做的目的是减少 CPU 的唤醒次数，从而节省电力。

返回值是参数 **j** 的舍入版本。

unsigned long __round_jiffies_up_relative(unsigned long j, int cpu)¶: 将节拍数向上舍入到整秒的函数

参数

unsigned long j: 应该四舍五入的时间（相对）节拍数
int cpu: 超时将发生的处理器编号

描述

这与 __round_jiffies_relative() 相同，除了它永远不会向下舍入。这对于超时很有用，只要它们不会太早触发，它们的准确触发时间并不重要。

unsigned long round_jiffies_up(unsigned long j)¶: 将节拍数向上舍入到整秒的函数

参数

unsigned long j: 应该四舍五入的时间（绝对）节拍数

描述

这与 round_jiffies() 相同，除了它永远不会向下舍入。这对于超时很有用，只要它们不会太早触发，它们的准确触发时间并不重要。

unsigned long round_jiffies_up_relative(unsigned long j)¶: 将节拍数向上舍入到整秒的函数

参数

unsigned long j: 应该四舍五入的时间（相对）节拍数

描述

这与 round_jiffies_relative() 相同，除了它永远不会向下舍入。这对于超时很有用，只要它们不会太早触发，它们的准确触发时间并不重要。

void timer_init_key(struct timer_list *timer, void (*func)(struct timer_list*), unsigned int flags, const char *name, struct lock_class_key *key)¶: 初始化定时器

参数

struct timer_list *timer: 要初始化的定时器
void (*func)(struct timer_list *): 定时器回调函数
unsigned int flags: 定时器标志
const char *name: 定时器的名称
struct lock_class_key *key: 用于跟踪定时器同步锁依赖关系的伪锁的 lockdep 类键

描述

timer_init_key() 必须在调用 _任何_ 其他定时器函数之前对定时器执行。

int mod_timer_pending(struct timer_list *timer, unsigned long expires)¶: 修改挂起定时器的超时

参数

struct timer_list *timer: 要修改的挂起定时器
unsigned long expires: 节拍数中的新绝对超时

描述

对于挂起的定时器，mod_timer_pending() 与 mod_timer() 相同，但不会激活非活动定时器。

如果 **timer->function** == NULL，则会静默丢弃启动操作。

返回

0 - 定时器未激活且未修改，或者处于
关闭状态且操作已丢弃
1 - 定时器已激活并重新排队以在 **expires** 过期

int mod_timer(struct timer_list *timer, unsigned long expires)¶: 修改定时器的超时

参数

struct timer_list *timer: 要修改的定时器
unsigned long expires: 节拍数中的新绝对超时

描述

mod_timer(timer, expires) 等效于

timer_delete(timer); timer->expires = expires; add_timer(timer);

mod_timer() 比上面的开放编码序列更有效。如果定时器未激活，则 timer_delete() 部分是 NOP。在任何情况下，定时器都会使用新的到期时间 **expires** 激活。

请注意，如果同一定时器有多个未序列化的并发用户，则 mod_timer() 是修改超时的唯一安全方法，因为 add_timer() 无法修改已运行的定时器。

如果 **timer->function** == NULL，则会静默丢弃启动操作。在这种情况下，返回值是 0 且无意义。

返回

0 - 定时器未激活并启动，或者处于关闭状态
并且操作已丢弃
1 - 定时器已激活并重新排队以在 **expires** 过期，或者
定时器已激活且未修改，因为 **expires** 没有更改有效到期时间

int timer_reduce(struct timer_list *timer, unsigned long expires)¶: 如果修改定时器的超时会减少超时，则修改定时器的超时

参数

struct timer_list *timer: 要修改的定时器
unsigned long expires: 节拍数中的新绝对超时

描述

timer_reduce() 与 mod_timer() 非常相似，不同之处在于它仅在减少到期时间时才会修改已排队的定时器。如果 **timer** 未排队，则会启动定时器。

如果 **timer->function** == NULL，则会静默丢弃启动操作。

返回

0 - 定时器未激活并启动，或者处于关闭状态
并且操作已丢弃
1 - 定时器已激活并重新排队以在 **expires** 过期，或者
定时器已激活且未修改，因为 **expires** 没有更改有效到期时间，因此定时器不会比已计划的时间更早过期

void add_timer(struct timer_list *timer)¶: 启动定时器

参数

struct timer_list *timer: 要启动的定时器

描述

启动 **timer** 以在未来的 **timer->expires** 到期。 **timer->expires** 是以“节拍数”衡量的绝对到期时间。当定时器过期时，将从软中断上下文中调用 timer->function(timer)。

必须在调用此函数之前设置 **timer->expires** 和 **timer->function** 字段。

如果 **timer->function** == NULL，则会静默丢弃启动操作。

如果 **timer->expires** 已经过去，则会将 **timer** 排队以便在下一个定时器节拍时过期。

这只能对非活动定时器进行操作。尝试对活动定时器调用此操作将发出警告而被拒绝。

void add_timer_local(struct timer_list *timer)¶: 在本地 CPU 上启动定时器

参数

struct timer_list *timer: 要启动的定时器

描述

与 add_timer() 相同，不同之处在于已设置定时器标志 TIMER_PINNED。

有关更多详细信息，请参见 add_timer()。

void add_timer_global(struct timer_list *timer)¶: 启动未设置 TIMER_PINNED 标志的定时器

参数

struct timer_list *timer: 要启动的定时器

描述

与 add_timer() 相同，不同之处在于未设置定时器标志 TIMER_PINNED。

有关更多详细信息，请参见 add_timer()。

void add_timer_on(struct timer_list *timer, int cpu)¶: 在特定 CPU 上启动定时器

参数

struct timer_list *timer: 要启动的定时器
int cpu: 要在其上启动的 CPU

描述

与 add_timer() 相同，不同之处在于它在给定的 CPU 上启动定时器，并且已设置 TIMER_PINNED 标志。当下一次循环中定时器不应是固定的定时器时，应改用 add_timer_global()，因为它会取消设置 TIMER_PINNED 标志。

有关更多详细信息，请参见 add_timer()。

int timer_delete(struct timer_list *timer)¶: 停用定时器

参数

struct timer_list *timer: 要停用的定时器

描述

该函数仅停用待处理的定时器，但与 timer_delete_sync() 不同，它不考虑定时器的回调函数是否在不同的 CPU 上并发执行。它也不会阻止定时器的重新激活。如果可以并发地重新激活 timer，则此函数的返回值没有意义。

返回

0 - 定时器未处于待处理状态
1 - 定时器处于待处理状态并已停用

int timer_shutdown(struct timer_list *timer)¶: 停用定时器并阻止重新激活

参数

struct timer_list *timer: 要停用的定时器

描述

该函数不等待在不同 CPU 上可能正在运行的定时器回调，但它会阻止定时器的重新激活。在此函数返回后，任何激活 timer 的尝试都将被静默忽略。

此函数对于清理代码很有用，并且只有在由于锁定或上下文约束而无法调用 timer_shutdown_sync() 时才应使用。

返回

0 - 定时器未处于待处理状态
1 - 定时器处于待处理状态

int timer_delete_sync_try(struct timer_list *timer)¶: 尝试停用定时器

参数

struct timer_list *timer: 要停用的定时器

描述

此函数尝试停用定时器。成功后，定时器不会排队，并且定时器回调函数不会在任何 CPU 上运行。

此函数不保证在释放基本锁之后无法立即重新激活定时器。如果需要，调用代码需要阻止这种情况。

返回

0 - 定时器未处于待处理状态
1 - 定时器处于待处理状态并已停用
-1 - 定时器回调函数正在不同的 CPU 上运行

int timer_delete_sync(struct timer_list *timer)¶: 停用定时器并等待处理程序完成。

参数

struct timer_list *timer: 要停用的定时器

描述

同步规则：调用者必须阻止定时器的重新启动，否则此函数没有意义。除非定时器是 irqsafe 定时器，否则不得从中断上下文中调用它。调用者不得持有会阻止定时器回调函数完成的锁。定时器的处理程序不得调用 add_timer_on()。退出时，定时器不会排队，并且处理程序不会在任何 CPU 上运行。

对于 !irqsafe 定时器，调用者不得持有在中断上下文中持有的锁。即使锁与有问题的定时器无关。原因如下

CPU0                             CPU1
----                             ----
                                 <SOFTIRQ>
                                   call_timer_fn();
                                   base->running_timer = mytimer;
spin_lock_irq(somelock);
                                 <IRQ>
                                    spin_lock(somelock);
timer_delete_sync(mytimer);
while (base->running_timer == mytimer);

现在 timer_delete_sync() 将永远不会返回，也永远不会释放 somelock。另一个 CPU 上的中断正在等待获取 somelock，但它中断了 CPU0 正在等待完成的软中断。

此函数无法保证定时器在释放基本锁后不会被一些并发或抢占代码再次重新激活。如果存在并发重新激活的可能性，则该函数的返回值没有意义。

如果需要这样的保证，例如，对于清理情况，则改用 timer_shutdown_sync()。

返回

0 - 定时器未处于待处理状态
1 - 定时器处于待处理状态并已停用

int timer_shutdown_sync(struct timer_list *timer)¶: 关闭定时器并阻止重新激活

参数

struct timer_list *timer: 要关闭的定时器

描述

当函数返回时，保证

timer 未排队
timer 的回调函数未运行
timer 无法再次入队。任何重新激活 timer 的尝试都将被静默忽略。

有关同步规则，请参见 timer_delete_sync()。

此函数对于基础结构的最终清理很有用，其中定时器会遇到循环依赖问题。

对此的常见模式是定时器和工作队列，其中定时器可以调度工作，而工作可以激活定时器。在关闭时，必须销毁工作队列，并且必须阻止定时器重新激活。除非代码具有诸如“if (mything->in_shutdown)”之类的条件来阻止这种情况，否则无法使用 timer_delete_sync() 正确地做到这一点。

timer_shutdown_sync() 正在解决此问题。在这种情况下，正确的调用顺序是

timer_shutdown_sync(mything->timer); workqueue_destroy(mything->workqueue);

在此之后，可以安全地释放“mything”。

这显然意味着在关闭操作的其余部分中不需要定时器是功能性的。

返回

0 - 定时器未处于待处理状态
1 - 定时器处于待处理状态

高分辨率定时器¶

ktime_t ktime_set(const s64 secs, const unsigned long nsecs)¶: 从秒/纳秒值设置 ktime_t 变量

参数

const s64 secs: 要设置的秒数
const unsigned long nsecs: 要设置的纳秒

返回

值的 ktime_t 表示形式。

int ktime_compare(const ktime_t cmp1, const ktime_t cmp2)¶: 比较两个 ktime_t 变量的大小、大于或等于

参数

const ktime_t cmp1: 可比较对象 1
const ktime_t cmp2: 可比较对象 2

返回

...: cmp1 < cmp2：返回 <0 cmp1 == cmp2：返回 0 cmp1 > cmp2：返回 >0

bool ktime_after(const ktime_t cmp1, const ktime_t cmp2)¶: 比较 ktime_t 值是否大于另一个值。

参数

const ktime_t cmp1: 可比较对象 1
const ktime_t cmp2: 可比较对象 2

返回

如果 cmp1 发生在 cmp2 之后，则为 true。

bool ktime_before(const ktime_t cmp1, const ktime_t cmp2)¶: 比较 ktime_t 值是否小于另一个值。

参数

const ktime_t cmp1: 可比较对象 1
const ktime_t cmp2: 可比较对象 2

返回

如果 cmp1 发生在 cmp2 之前，则为 true。

bool ktime_to_timespec64_cond(const ktime_t kt, struct timespec64 *ts)¶: 仅当变量包含数据时，才将 ktime_t 变量转换为 timespec64 格式

参数

const ktime_t kt: 要转换的 ktime_t 变量
struct timespec64 *ts: 用于存储结果的 timespec 变量

返回

如果转换成功，则为 true，如果 kt 为 0，则为 false。

struct hrtimer_sleeper¶: 简单的睡眠器结构

定义:

struct hrtimer_sleeper {
    struct hrtimer timer;
    struct task_struct *task;
};

成员

定时器: 嵌入式定时器结构
任务: 要唤醒的任务

描述

当定时器到期时，任务设置为 NULL。

void hrtimer_start(struct hrtimer *timer, ktime_t tim, const enum hrtimer_mode mode)¶: （重新）启动 hrtimer

参数

struct hrtimer *timer: 要添加的定时器
ktime_t tim: 到期时间
const enum hrtimer_mode mode: 定时器模式：绝对 (HRTIMER_MODE_ABS) 或相对 (HRTIMER_MODE_REL) 和固定 (HRTIMER_MODE_PINNED)；基于 softirq 的模式仅用于调试目的！

ktime_t hrtimer_get_remaining(const struct hrtimer *timer)¶: 获取定时器的剩余时间

参数

const struct hrtimer *timer: 要读取的定时器

bool hrtimer_is_queued(struct hrtimer *timer)¶: 检查定时器是否在其中一个队列上

参数

struct hrtimer *timer: 要检查的定时器

返回

如果定时器已排队，则为 True，否则为 false

描述

该函数可以无锁使用，但它仅提供当前快照。

void hrtimer_update_function(struct hrtimer *timer, enum hrtimer_restart (*function)(struct hrtimer*))¶: 更新定时器的回调函数

参数

struct hrtimer *timer: 要更新的定时器
enum hrtimer_restart (*function)(struct hrtimer *): 新的回调函数

描述

仅当定时器未排队时，才可以安全地调用。如果定时器未同时排队，则可以在回调函数中调用（请参见 HRTIMER_STATE_ENQUEUED 上方的注释）。

u64 hrtimer_forward_now(struct hrtimer *timer, ktime_t interval)¶: 转发定时器到期时间，使其在现在之后到期

参数

struct hrtimer *timer: 要转发的 hrtimer
ktime_t interval: 要转发的间隔

描述

它是 hrtimer_forward() 的变体。定时器将在 hrtimer 时钟基准的当前时间之后到期。有关详细信息，请参见 hrtimer_forward()。

u64 hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval)¶: 转发定时器到期时间

参数

struct hrtimer *timer: 要转发的 hrtimer
ktime_t now: 转发到过去的时间
ktime_t interval: 要转发的间隔

描述

转发定时器到期时间，使其在将来到期。

注意

这仅更新定时器到期值，而不重新将定时器排队。

还有 hrtimer_forward_now() 函数的变体。

上下文

可以从 timer 的回调函数中安全地调用。如果从其他上下文中调用，则 timer 既不能排队，也不能运行回调，并且调用者需要注意序列化。

返回

返回超限次数。

void hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim, u64 delta_ns, const enum hrtimer_mode mode)¶: （重新）启动 hrtimer

参数

struct hrtimer *timer: 要添加的定时器
ktime_t tim: 到期时间
u64 delta_ns: 定时器的“松弛”范围
const enum hrtimer_mode mode: 定时器模式：绝对 (HRTIMER_MODE_ABS) 或相对 (HRTIMER_MODE_REL) 和固定 (HRTIMER_MODE_PINNED)；基于 softirq 的模式仅用于调试目的！

int hrtimer_try_to_cancel(struct hrtimer *timer)¶: 尝试停用定时器

参数

struct hrtimer *timer: 要停止的 hrtimer

返回

0 表示定时器未激活

1 表示定时器已激活

-1 表示定时器当前正在执行回调函数，无法停止

int hrtimer_cancel(struct hrtimer *timer)¶: 取消定时器并等待处理程序完成。

参数

struct hrtimer *timer: 要取消的定时器

返回

0 表示定时器未激活 1 表示定时器已激活

ktime_t __hrtimer_get_remaining(const struct hrtimer *timer, bool adjust)¶: 获取定时器的剩余时间

参数

const struct hrtimer *timer: 要读取的定时器
bool adjust: 当 CONFIG_TIME_LOW_RES=y 时，调整相对定时器

void hrtimer_setup(struct hrtimer *timer, enum hrtimer_restart (*function)(struct hrtimer*), clockid_t clock_id, enum hrtimer_mode mode)¶: 初始化计时器到给定的时钟

参数

struct hrtimer *timer

要初始化的定时器

enum hrtimer_restart (*function)(struct hrtimer *)

回调函数

clockid_t clock_id

要使用的时钟

enum hrtimer_mode mode

与初始化相关的模式：HRTIMER_MODE_ABS、HRTIMER_MODE_REL、HRTIMER_MODE_ABS_SOFT、HRTIMER_MODE_REL_SOFT

可以传入上述 PINNED 变体，但 PINNED 位会被忽略，因为 pinning 在 hrtimer 启动时发生

void hrtimer_setup_on_stack(struct hrtimer *timer, enum hrtimer_restart (*function)(struct hrtimer*), clockid_t clock_id, enum hrtimer_mode mode)¶: 在栈内存上初始化一个计时器

参数

struct hrtimer *timer: 要初始化的计时器
enum hrtimer_restart (*function)(struct hrtimer *): 回调函数
clockid_t clock_id: 要使用的时钟
enum hrtimer_mode mode: 计时器模式

描述

与 hrtimer_setup() 类似，但如果 struct hrtimer 在栈内存中，则必须使用此函数。

void hrtimer_sleeper_start_expires(struct hrtimer_sleeper *sl, enum hrtimer_mode mode)¶: 启动一个 hrtimer 休眠计时器

参数

struct hrtimer_sleeper *sl: 要启动的 sleeper
enum hrtimer_mode mode: 计时器模式 abs/rel

描述

hrtimer_start_expires() 的包装器，用于基于 hrtimer_sleeper 的计时器，以允许 PREEMPT_RT 调整传递模式（soft/hardirq 上下文）

void hrtimer_setup_sleeper_on_stack(struct hrtimer_sleeper *sl, clockid_t clock_id, enum hrtimer_mode mode)¶: 在栈内存中初始化一个 sleeper

参数

struct hrtimer_sleeper *sl: 要初始化的 sleeper
clockid_t clock_id: 要使用的时钟
enum hrtimer_mode mode: 计时器模式 abs/rel

等待队列和唤醒事件¶

int waitqueue_active(struct wait_queue_head *wq_head)¶

无锁测试队列上是否有等待者

参数

struct wait_queue_head *wq_head: 要测试是否有等待者的等待队列

描述

如果等待列表不为空，则返回 true

在使用 wait_queue_head::lock 或用于使用额外的 smp_mb() 唤醒时使用，例如

CPU0 - waker                    CPU1 - waiter

                                for (;;) {
@cond = true;                     prepare_to_wait(&wq_head, &wait, state);
smp_mb();                         // smp_mb() from set_current_state()
if (waitqueue_active(wq_head))         if (@cond)
  wake_up(wq_head);                      break;
                                  schedule();
                                }
                                finish_wait(&wq_head, &wait);

因为如果没有显式的 smp_mb()，waitqueue_active() 加载可能会提升到 cond 存储之上，这样我们会在 waiter 可能没有观察到 cond 时观察到空的等待列表。

另请注意，此“优化”将 spin_lock() 换成了 smp_mb()，（当锁未争用时）它们的成本大致相同。

注意

此函数是无锁的，需要小心，不正确的使用 _将_ 导致零星且不明显的故障。

bool wq_has_single_sleeper(struct wait_queue_head *wq_head)¶: 检查是否只有一个 sleeper

参数

struct wait_queue_head *wq_head: 等待队列头

描述

如果 wq_head 在列表上只有一个 sleeper，则返回 true。

请参考 waitqueue_active 的注释。

bool wq_has_sleeper(struct wait_queue_head *wq_head)¶: 检查是否有任何正在等待的进程

参数

struct wait_queue_head *wq_head: 等待队列头

描述

如果 wq_head 有正在等待的进程，则返回 true

请参考 waitqueue_active 的注释。

void wake_up_pollfree(struct wait_queue_head *wq_head)¶: 发出轮询等待队列即将消失的信号

参数

struct wait_queue_head *wq_head: 等待队列头

描述

在非常罕见的情况下，->poll() 实现使用等待队列，其生命周期与任务而不是与正在轮询的“struct file”相关联，则必须在释放等待队列之前调用此函数，以便通知非阻塞轮询（例如 epoll）队列即将消失。

调用者还必须 RCU 延迟等待队列头的释放，例如通过显式的 synchronize_rcu() 或 call_rcu()，或通过 SLAB_TYPESAFE_BY_RCU。

wait_event¶

wait_event (wq_head, condition)

睡眠直到条件为真

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式

描述

进程进入睡眠状态 (TASK_UNINTERRUPTIBLE)，直到 condition 的计算结果为 true。每次唤醒等待队列 wq_head 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

wait_event_freezable¶

wait_event_freezable (wq_head, condition)

睡眠（或冻结）直到条件为真

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式

描述

进程进入睡眠状态 (TASK_INTERRUPTIBLE -- 以不增加系统负载)，直到 condition 的计算结果为 true。每次唤醒等待队列 wq_head 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

wait_event_timeout¶

wait_event_timeout (wq_head, condition, timeout)

睡眠直到条件为真或超时经过

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式
超时: 超时，以 jiffies 为单位

描述

进程进入睡眠状态 (TASK_UNINTERRUPTIBLE)，直到 condition 的计算结果为 true。每次唤醒等待队列 wq_head 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

返回

如果在经过 timeout 后 condition 的计算结果为 false，则为 0，如果在经过 timeout 后 condition 的计算结果为 true，则为 1，或者如果在 timeout 经过之前 condition 的计算结果为 true，则为剩余的 jiffies（至少为 1）。

wait_event_cmd¶

wait_event_cmd (wq_head, condition, cmd1, cmd2)

睡眠直到条件为真

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式
cmd1: 该命令将在睡眠前执行
cmd2: 该命令将在睡眠后执行

描述

进程进入睡眠状态 (TASK_UNINTERRUPTIBLE)，直到 condition 的计算结果为 true。每次唤醒等待队列 wq_head 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

wait_event_interruptible¶

wait_event_interruptible (wq_head, condition)

睡眠直到条件为真

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式

描述

进程进入睡眠状态 (TASK_INTERRUPTIBLE)，直到 condition 的计算结果为 true 或收到信号。每次唤醒等待队列 wq_head 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

如果该函数被信号中断，则返回 -ERESTARTSYS，如果 condition 的计算结果为 true，则返回 0。

wait_event_interruptible_timeout¶

wait_event_interruptible_timeout (wq_head, condition, timeout)

睡眠直到条件为真或超时经过

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式
超时: 超时，以 jiffies 为单位

描述

进程进入睡眠状态 (TASK_INTERRUPTIBLE)，直到 condition 的计算结果为 true 或收到信号。每次唤醒等待队列 wq_head 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

返回

如果在经过 timeout 后 condition 的计算结果为 false，则为 0，如果在经过 timeout 后 condition 的计算结果为 true，则为 1，如果在 timeout 经过之前 condition 的计算结果为 true，则为剩余的 jiffies（至少为 1），或者如果它被信号中断，则为 -ERESTARTSYS。

wait_event_hrtimeout¶

wait_event_hrtimeout (wq_head, condition, timeout)

睡眠直到条件为真或超时经过

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式
超时: 超时，作为 ktime_t

描述

进程进入睡眠状态 (TASK_UNINTERRUPTIBLE)，直到 condition 的计算结果为 true 或收到信号。每次唤醒等待队列 wq_head 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

如果 condition 变为 true，该函数返回 0，如果超时经过，则返回 -ETIME。

wait_event_interruptible_hrtimeout¶

wait_event_interruptible_hrtimeout (wq, condition, timeout)

睡眠直到条件为真或超时经过

参数

wq: 要等待的等待队列
条件: 等待事件的 C 表达式
超时: 超时，作为 ktime_t

描述

进程进入睡眠状态 (TASK_INTERRUPTIBLE)，直到 condition 的计算结果为 true 或收到信号。每次唤醒等待队列 wq 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

如果 condition 变为 true，该函数返回 0，如果它被信号中断，则返回 -ERESTARTSYS，如果超时经过，则返回 -ETIME。

wait_event_idle¶

wait_event_idle (wq_head, condition)

等待一个条件，而不增加系统负载

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式

描述

进程进入睡眠状态 (TASK_IDLE)，直到 condition 的计算结果为 true。每次唤醒等待队列 wq_head 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

wait_event_idle_exclusive¶

wait_event_idle_exclusive (wq_head, condition)

等待一个条件，同时增加系统负载

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式

描述

进程进入睡眠状态 (TASK_IDLE)，直到 condition 的计算结果为 true。每次唤醒等待队列 wq_head 时，都会检查 condition。

进程使用设置的 WQ_FLAG_EXCLUSIVE 标志放置在等待队列中，因此如果其他进程在同一列表中等待，则在唤醒此进程时，将不再考虑其他进程。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

wait_event_idle_timeout¶

wait_event_idle_timeout (wq_head, condition, timeout)

睡眠而不加载，直到条件变为 true 或超时经过

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式
超时: 超时，以 jiffies 为单位

描述

进程进入睡眠状态 (TASK_IDLE)，直到 condition 的计算结果为 true。每次唤醒等待队列 wq_head 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

返回

如果在经过 timeout 后 condition 的计算结果为 false，则为 0，如果在经过 timeout 后 condition 的计算结果为 true，则为 1，或者如果在 timeout 经过之前 condition 的计算结果为 true，则为剩余的 jiffies（至少为 1）。

wait_event_idle_exclusive_timeout¶

wait_event_idle_exclusive_timeout (wq_head, condition, timeout)

睡眠而不加载，直到条件变为 true 或超时经过

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式
超时: 超时，以 jiffies 为单位

描述

进程进入睡眠状态 (TASK_IDLE)，直到 condition 的计算结果为 true。每次唤醒等待队列 wq_head 时，都会检查 condition。

进程使用设置的 WQ_FLAG_EXCLUSIVE 标志放置在等待队列中，因此如果其他进程在同一列表中等待，则在唤醒此进程时，将不再考虑其他进程。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

返回

如果在经过 timeout 后 condition 的计算结果为 false，则为 0，如果在经过 timeout 后 condition 的计算结果为 true，则为 1，或者如果在 timeout 经过之前 condition 的计算结果为 true，则为剩余的 jiffies（至少为 1）。

wait_event_interruptible_locked¶

wait_event_interruptible_locked (wq, condition)

睡眠直到条件为真

参数

wq: 要等待的等待队列
条件: 等待事件的 C 表达式

描述

进程进入睡眠状态 (TASK_INTERRUPTIBLE)，直到 condition 的计算结果为 true 或收到信号。每次唤醒等待队列 wq 时，都会检查 condition。

必须使用持有的 wq.lock 调用它。此自旋锁在睡眠时解锁，但在持有锁时完成 condition 测试，并且当此宏退出时，锁被持有。

锁使用 spin_lock()/spin_unlock() 函数锁定/解锁，这些函数必须与它们在此宏之外锁定/解锁的方式相匹配。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up_locked()。

如果该函数被信号中断，则返回 -ERESTARTSYS，如果 condition 的计算结果为 true，则返回 0。

wait_event_interruptible_locked_irq¶

wait_event_interruptible_locked_irq (wq, condition)

睡眠直到条件为真

参数

wq: 要等待的等待队列
条件: 等待事件的 C 表达式

描述

进程进入睡眠状态 (TASK_INTERRUPTIBLE)，直到 condition 的计算结果为 true 或收到信号。每次唤醒等待队列 wq 时，都会检查 condition。

必须使用持有的 wq.lock 调用它。此自旋锁在睡眠时解锁，但在持有锁时完成 condition 测试，并且当此宏退出时，锁被持有。

锁使用 spin_lock_irq()/spin_unlock_irq() 函数锁定/解锁，这些函数必须与它们在此宏之外锁定/解锁的方式相匹配。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up_locked()。

如果该函数被信号中断，则返回 -ERESTARTSYS，如果 condition 的计算结果为 true，则返回 0。

wait_event_interruptible_exclusive_locked¶

wait_event_interruptible_exclusive_locked (wq, condition)

独占睡眠直到条件为真

参数

wq: 要等待的等待队列
条件: 等待事件的 C 表达式

描述

进程进入睡眠状态 (TASK_INTERRUPTIBLE)，直到 condition 的计算结果为 true 或收到信号。每次唤醒等待队列 wq 时，都会检查 condition。

必须使用持有的 wq.lock 调用它。此自旋锁在睡眠时解锁，但在持有锁时完成 condition 测试，并且当此宏退出时，锁被持有。

锁使用 spin_lock()/spin_unlock() 函数锁定/解锁，这些函数必须与它们在此宏之外锁定/解锁的方式相匹配。

进程使用设置的 WQ_FLAG_EXCLUSIVE 标志放置在等待队列中，因此当其他进程在此列表上等待时，如果唤醒此进程，则不会考虑其他进程。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up_locked()。

如果该函数被信号中断，则返回 -ERESTARTSYS，如果 condition 的计算结果为 true，则返回 0。

wait_event_interruptible_exclusive_locked_irq¶

wait_event_interruptible_exclusive_locked_irq (wq, condition)

睡眠直到条件为真

参数

wq: 要等待的等待队列
条件: 等待事件的 C 表达式

描述

进程进入睡眠状态 (TASK_INTERRUPTIBLE)，直到 condition 的计算结果为 true 或收到信号。每次唤醒等待队列 wq 时，都会检查 condition。

必须使用持有的 wq.lock 调用它。此自旋锁在睡眠时解锁，但在持有锁时完成 condition 测试，并且当此宏退出时，锁被持有。

锁使用 spin_lock_irq()/spin_unlock_irq() 函数锁定/解锁，这些函数必须与它们在此宏之外锁定/解锁的方式相匹配。

进程使用设置的 WQ_FLAG_EXCLUSIVE 标志放置在等待队列中，因此当其他进程在此列表上等待时，如果唤醒此进程，则不会考虑其他进程。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up_locked()。

如果该函数被信号中断，则返回 -ERESTARTSYS，如果 condition 的计算结果为 true，则返回 0。

wait_event_killable¶

wait_event_killable (wq_head, condition)

睡眠直到条件为真

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式

描述

进程进入睡眠状态 (TASK_KILLABLE)，直到 condition 的计算结果为 true 或收到信号。每次唤醒等待队列 wq_head 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

如果该函数被信号中断，则返回 -ERESTARTSYS，如果 condition 的计算结果为 true，则返回 0。

wait_event_state¶

wait_event_state (wq_head, condition, state)

睡眠直到条件为真

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式
状态: 要睡眠的状态

描述

进程进入睡眠状态 (state)，直到 condition 的计算结果为 true 或收到信号（在 state 允许时）。每次唤醒等待队列 wq_head 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

如果该函数被信号中断（在 state 允许时），则返回 -ERESTARTSYS，如果 condition 的计算结果为 true，则返回 0。

wait_event_killable_timeout¶

wait_event_killable_timeout (wq_head, condition, timeout)

睡眠直到条件为真或超时经过

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式
超时: 超时，以 jiffies 为单位

描述

进程进入睡眠状态 (TASK_KILLABLE)，直到 condition 的计算结果为 true 或收到 kill 信号。每次唤醒等待队列 wq_head 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

只有 kill 信号会中断此进程。

返回

如果在经过 timeout 后 condition 的计算结果为 false，则为 0，如果在经过 timeout 后 condition 的计算结果为 true，则为 1，如果在 timeout 经过之前 condition 的计算结果为 true，则为剩余的 jiffies（至少为 1），或者如果它被 kill 信号中断，则为 -ERESTARTSYS。

wait_event_lock_irq_cmd¶

wait_event_lock_irq_cmd (wq_head, condition, lock, cmd)

睡眠直到条件为真。在锁下检查条件。预计将在获取锁的情况下调用此函数。

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式
lock: 一个锁定的 spinlock_t，它将在 cmd 和 schedule() 之前释放并在之后重新获取。
cmd: 在睡眠之前在临界区之外调用的命令

描述

进程进入睡眠状态 (TASK_UNINTERRUPTIBLE)，直到 condition 的计算结果为 true。每次唤醒等待队列 wq_head 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

这应该在持有锁时调用。锁在调用 cmd 和进入睡眠状态之前释放，并在之后重新获取。

wait_event_lock_irq¶

wait_event_lock_irq (wq_head, condition, lock)

睡眠直到条件为真。在锁下检查条件。预计将在获取锁的情况下调用此函数。

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式
lock: 一个锁定的 spinlock_t，它将在 schedule() 之前释放并在之后重新获取。

描述

进程进入睡眠状态 (TASK_UNINTERRUPTIBLE)，直到 condition 的计算结果为 true。每次唤醒等待队列 wq_head 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

这应该在持有锁时调用。锁在进入睡眠状态之前释放，并在之后重新获取。

wait_event_interruptible_lock_irq_cmd¶

wait_event_interruptible_lock_irq_cmd (wq_head, condition, lock, cmd)

睡眠直到条件为真。在锁下检查条件。预计将在获取锁的情况下调用此函数。

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式
lock: 一个锁定的 spinlock_t，它将在 cmd 和 schedule() 之前释放并在之后重新获取。
cmd: 在睡眠之前在临界区之外调用的命令

描述

进程进入睡眠状态 (TASK_INTERRUPTIBLE)，直到 condition 的计算结果为 true 或收到信号。每次唤醒等待队列 wq_head 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

这应该在持有锁时调用。锁在调用 cmd 和进入睡眠状态之前释放，并在之后重新获取。

如果宏被信号中断，则返回 -ERESTARTSYS；如果 condition 评估为真，则返回 0。

wait_event_interruptible_lock_irq¶

wait_event_interruptible_lock_irq (wq_head, condition, lock)

睡眠直到条件为真。在锁下检查条件。预计将在获取锁的情况下调用此函数。

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式
lock: 一个锁定的 spinlock_t，它将在 schedule() 之前释放并在之后重新获取。

描述

进程进入睡眠状态 (TASK_INTERRUPTIBLE)，直到 condition 评估为真或收到信号。每次唤醒等待队列 wq_head 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

这应该在持有锁时调用。锁在进入睡眠状态之前释放，并在之后重新获取。

如果宏被信号中断，则返回 -ERESTARTSYS；如果 condition 评估为真，则返回 0。

wait_event_interruptible_lock_irq_timeout¶

wait_event_interruptible_lock_irq_timeout (wq_head, condition, lock, timeout)

睡眠直到条件为真或超时时间过去。在锁的保护下检查条件。期望在持有锁的情况下调用此函数。

参数

wq_head: 要等待的等待队列
条件: 等待事件的 C 表达式
lock: 一个锁定的 spinlock_t，它将在 schedule() 之前释放并在之后重新获取。
超时: 超时，以 jiffies 为单位

描述

进程进入睡眠状态 (TASK_INTERRUPTIBLE)，直到 condition 评估为真或收到信号。每次唤醒等待队列 wq_head 时，都会检查 condition。

在更改任何可能更改等待条件结果的变量后，必须调用 wake_up()。

这应该在持有锁时调用。锁在进入睡眠状态之前释放，并在之后重新获取。

如果 timeout 时间已过，则函数返回 0；如果被信号中断，则返回 -ERESTARTSYS；如果超时时间过去之前 condition 评估为真，则返回剩余的 jiffies。

int __wake_up(struct wait_queue_head *wq_head, unsigned int mode, int nr_exclusive, void *key)¶: 唤醒在等待队列上阻塞的线程。

参数

struct wait_queue_head *wq_head: 等待队列
unsigned int mode: 哪些线程
int nr_exclusive: 要唤醒的 wake-one 或 wake-many 线程的数量
void *key: 直接传递给唤醒函数

描述

如果此函数唤醒了一个任务，它会在访问任务状态之前执行完整的内存屏障。返回被唤醒的独占任务的数量。

void __wake_up_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void *key)¶: 唤醒在等待队列上阻塞的线程。

参数

struct wait_queue_head *wq_head: 等待队列
unsigned int mode: 哪些线程
void *key: 要传递给唤醒目标的不透明值

描述

同步唤醒的不同之处在于，唤醒者知道它很快就会调度离开，因此虽然目标线程将被唤醒，但它不会迁移到另一个 CPU，即这两个线程是“同步”的。这可以防止在 CPU 之间进行不必要的跳转。

在 UP 上，它可以防止额外的抢占。

如果此函数唤醒了一个任务，它会在访问任务状态之前执行完整的内存屏障。

void __wake_up_locked_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void *key)¶: 唤醒在锁定的等待队列上阻塞的线程。

参数

struct wait_queue_head *wq_head: 等待队列
unsigned int mode: 哪些线程
void *key: 要传递给唤醒目标的不透明值

描述

同步唤醒的不同之处在于，唤醒者知道它很快就会调度离开，因此虽然目标线程将被唤醒，但它不会迁移到另一个 CPU，即这两个线程是“同步”的。这可以防止在 CPU 之间进行不必要的跳转。

在 UP 上，它可以防止额外的抢占。

如果此函数唤醒了一个任务，它会在访问任务状态之前执行完整的内存屏障。

void finish_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)¶: 清理在队列中等待之后

参数

struct wait_queue_head *wq_head: 等待的等待队列
struct wait_queue_entry *wq_entry: 等待描述符

描述

将当前线程设置回运行状态，并从给定的等待队列中移除等待描述符（如果仍在队列中）。

内部函数¶

int wait_task_stopped(struct wait_opts *wo, int ptrace, struct task_struct *p)¶: 等待 TASK_STOPPED 或 TASK_TRACED

参数

struct wait_opts *wo: 等待选项
int ptrace: 是否等待 ptrace
struct task_struct *p: 要等待的任务

描述

处理 p 处于 TASK_STOPPED 或 TASK_TRACED 状态下的 sys_wait4() 工作。

上下文

read_lock(tasklist_lock)，如果返回值非零，则释放该锁。此外，获取并释放 p->sighand->siglock。

返回

如果等待条件不存在并且应该继续搜索其他等待条件，则为 0。非零返回值，失败时为 -errno，成功时为 p 的 pid，意味着 tasklist_lock 已释放，并且应该终止等待条件搜索。

bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask)¶: 设置 jobctl 挂起位

参数

struct task_struct *task: 目标任务
unsigned long mask: 要设置的挂起位

描述

从 task->jobctl 中清除 mask。 mask 必须是 JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME | JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING 的子集。如果正在设置停止信号，则清除现有信号。如果 task 正在被杀死或退出，则此函数变为 noop。

上下文

必须在持有 task->sighand->siglock 的情况下调用。

返回

如果设置了 mask，则为 true；如果因为 task 即将死亡而变为 noop，则为 false。

void task_clear_jobctl_trapping(struct task_struct *task)¶: 清除 jobctl 捕获位

参数

struct task_struct *task: 目标任务

描述

如果设置了 JOBCTL_TRAPPING，则 ptracer 正在等待我们进入 TRACED。清除它并唤醒 ptracer。请注意，我们不需要任何进一步的锁定。 task->siglock 保证 task->parent 指向 ptracer。

上下文

必须在持有 task->sighand->siglock 的情况下调用。

void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask)¶: 清除 jobctl 挂起位

参数

struct task_struct *task: 目标任务
unsigned long mask: 要清除的挂起位

描述

从 task->jobctl 中清除 mask。 mask 必须是 JOBCTL_PENDING_MASK 的子集。如果正在清除 JOBCTL_STOP_PENDING，则会一起清除其他 STOP 位。

如果清除 mask 后没有剩余的停止或捕获挂起，则此函数调用 task_clear_jobctl_trapping()。

上下文

必须在持有 task->sighand->siglock 的情况下调用。

bool task_participate_group_stop(struct task_struct *task)¶: 参与组停止

参数

struct task_struct *task: 参与组停止的任务

描述

task 已设置 JOBCTL_STOP_PENDING 并且正在参与组停止。如果设置了 JOBCTL_STOP_CONSUME，则清除组停止状态并消耗组停止计数。如果消耗完成组停止，则设置相应的 SIGNAL_* 标志。

上下文

必须在持有 task->sighand->siglock 的情况下调用。

返回

如果应将组停止完成通知给父进程，则为 true；否则为 false。

void ptrace_trap_notify(struct task_struct *t)¶: 调度陷阱以通知 ptracer

参数

struct task_struct *t: 想要通知 tracer 的 tracee

描述

此函数调度粘性 ptrace 陷阱，该陷阱在下一次 TRAP_STOP 时被清除，以通知 ptracer 事件。 t 必须已被 ptracer 捕获。

如果 t 正在运行，将执行 STOP 陷阱。如果为 STOP 陷入陷阱并且 ptracer 正在监听事件，则唤醒 tracee，以便它可以为新事件重新陷入陷阱。如果以其他方式陷入陷阱，则最终会执行 STOP 陷阱，而不会在现有陷阱由 PTRACE_CONT 完成后返回到用户空间。

上下文

必须在持有 task->sighand->siglock 的情况下调用。

int force_sig_seccomp(int syscall, int reason, bool force_coredump)¶: 发出信号，以允许进程内系统调用模拟

参数

int syscall: 要发送到用户空间的系统调用号
int reason: 要发送到用户空间的过滤器提供的理由代码（通过 si_errno）
bool force_coredump: true 以触发 core 转储

描述

强制执行 SIGSYS，其代码为 SYS_SECCOMP 和相关的 sigsys 信息。

void do_notify_parent_cldstop(struct task_struct *tsk, bool for_ptracer, int why)¶: 通知父进程停止/继续状态更改

参数

struct task_struct *tsk: 报告状态更改的任务
bool for_ptracer: 该通知适用于 ptracer
int why: 要报告的 CLD_{CONTINUED|STOPPED|TRAPPED}

描述

通知 tsk 的父进程停止/继续状态已更改。如果 for_ptracer 为 false，则 tsk 的组长会通知给它的真实父进程。如果为 true，则 tsk 会报告给 tsk->parent，该进程应该是 ptracer。

上下文

必须在至少读取锁定的情况下调用 tasklist_lock。

bool do_signal_stop(int signr)¶: 处理 SIGSTOP 和其他停止信号的组停止

参数

int signr: 如果发起组停止，则导致组停止的 signr

描述

如果尚未设置 JOBCTL_STOP_PENDING，则使用 signr 发起组停止并参与其中。如果已设置，则参与现有组停止。如果参与了组停止（因此进入睡眠状态），则返回 true，并释放 siglock。

如果被 ptrace，此函数不会自行处理停止。相反，调度 JOBCTL_TRAP_STOP，并且返回 false，并且不修改 siglock。调用者必须确保之后发生 INTERRUPT 陷阱处理。

上下文

必须在持有 current->sighand->siglock 的情况下调用，该锁在返回 true 时释放。

返回

如果已取消组停止或已调度 ptrace 陷阱，则为 false。如果参与了组停止，则为 true。

void do_jobctl_trap(void)¶: 处理 ptrace jobctl 陷阱

参数

void: 无参数

描述

当 PT_SEIZED 时，它用于组停止和显式 SEIZE/INTERRUPT 陷阱。两者都会生成带有附加 siginfo 的 PTRACE_EVENT_STOP 陷阱。如果已停止，则 exit_code 的低八位包含停止信号；否则，为 SIGTRAP。

当 !PT_SEIZED 时，它仅用于以停止信号编号作为 exit_code 且没有 siginfo 的组停止陷阱。

上下文

必须在持有 current->sighand->siglock 的情况下调用，该锁可能会在返回之前被释放并重新获取，并且会进行干预睡眠。

void do_freezer_trap(void)¶: 处理 freezer jobctl 陷阱

参数

void: 无参数

描述

如果该任务没有即将退出，则将该任务置于冻结状态。在这种情况下，它会删除 JOBCTL_TRAP_FREEZE。

上下文

必须在持有 current->sighand->siglock 的情况下调用，该锁始终在返回之前释放。

void signal_delivered(struct ksignal *ksig, int stepping)¶: 在信号传递后调用以更新阻塞信号

参数

struct ksignal *ksig: 内核信号结构
int stepping: 如果正在使用调试器单步执行或块步执行，则为非零

描述

成功传递信号后应调用此函数。它会相应地更新阻塞信号 (ksig->ka.sa.sa_mask 始终被阻塞)，并且该信号本身被阻塞，除非在 ksig->ka.sa.sa_flags 中设置了 SA_NODEFER。通知跟踪。

long sys_restart_syscall(void)¶: 重新启动系统调用

参数

void: 无参数

void set_current_blocked(sigset_t *newset)¶: 更改 current->blocked 掩码

参数

sigset_t *newset: 新掩码

描述

直接更改 ->blocked 是错误的，应使用此助手来确保进程不会错过我们将要阻塞的共享信号。

long sys_rt_sigprocmask(int how, sigset_t __user *nset, sigset_t __user *oset, size_t sigsetsize)¶: 更改当前阻塞信号的列表

参数

int how: 是添加、移除还是设置信号
sigset_t __user * nset: 存储挂起的信号
sigset_t __user * oset: 如果非空，则为信号掩码的先前值
size_t sigsetsize: sigset_t 类型的大小

long sys_rt_sigpending(sigset_t __user *uset, size_t sigsetsize)¶: 检查在阻塞时引发的挂起信号

参数

sigset_t __user * uset: 存储挂起的信号
size_t sigsetsize: sigset_t 类型的大小或更大

void copy_siginfo_to_external32(struct compat_siginfo *to, const struct kernel_siginfo *from)¶: 将内核 siginfo 复制到 compat user siginfo

参数

struct compat_siginfo *to: compat siginfo 目标
const struct kernel_siginfo *from: 内核 siginfo 源

注意

此函数对于 x32 上的 SIGCHLD 无法正常工作，但幸运的是，它不必如此。此函数唯一的有效调用者是 copy_siginfo_to_user32，它被 x32 和 coredump 代码覆盖。后者不在乎，因为 SIGCHLD 永远不会导致 coredump。

int do_sigtimedwait(const sigset_t *which, kernel_siginfo_t *info, const struct timespec64 *ts)¶: 等待 **which** 中指定的排队信号

参数

const sigset_t *which: 要等待的排队信号
kernel_siginfo_t *info: 如果非空，则信号的 siginfo 将在此处返回
const struct timespec64 *ts: 进程时间暂停的上限

long sys_rt_sigtimedwait(const sigset_t __user *uthese, siginfo_t __user *uinfo, const struct __kernel_timespec __user *uts, size_t sigsetsize)¶: 同步等待 uthese 中指定的排队信号

参数

const sigset_t __user * uthese: 要等待的排队信号
siginfo_t __user * uinfo: 如果非空，则信号的 siginfo 将在此处返回
const struct __kernel_timespec __user * uts: 进程时间暂停的上限
size_t sigsetsize: sigset_t 类型的大小

long sys_kill(pid_t pid, int sig)¶: 向进程发送信号

参数

pid_t pid: 进程的 PID
int sig: 要发送的信号

long sys_pidfd_send_signal(int pidfd, int sig, siginfo_t __user *info, unsigned int flags)¶: 通过 pidfd 向进程发送信号

参数

int pidfd: 进程的文件描述符
int sig: 要发送的信号
siginfo_t __user * info: 信号信息
unsigned int flags: 未来的标志

描述

根据 PIDFD_THREAD，将信号发送到线程组或单个线程。在未来，可以扩展 **flags** 以覆盖 **pidfd** 的默认范围。

返回

成功时为 0，失败时为负 errno

long sys_tgkill(pid_t tgid, pid_t pid, int sig)¶: 向一个特定线程发送信号

参数

pid_t tgid

线程的线程组 ID

pid_t pid

线程的 PID

int sig

要发送的信号

此系统调用还会检查 **tgid**，即使 PID 存在但不属于目标进程也会返回 -ESRCH。此方法解决了线程退出和 PID 被重用的问题。

long sys_tkill(pid_t pid, int sig)¶: 向一个特定任务发送信号

参数

pid_t pid

任务的 PID

int sig

要发送的信号

仅向一个任务发送信号，即使它是一个 CLONE_THREAD 任务。

long sys_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t __user *uinfo)¶: 向信号发送信号信息

参数

pid_t pid: 线程的 PID
int sig: 要发送的信号
siginfo_t __user * uinfo: 要发送的信号信息

long sys_sigpending(old_sigset_t __user *uset)¶: 检查挂起的信号

参数

old_sigset_t __user * uset: 返回挂起信号的掩码的位置

long sys_sigprocmask(int how, old_sigset_t __user *nset, old_sigset_t __user *oset)¶: 检查和更改阻塞的信号

参数

int how: 是添加、移除还是设置信号
old_sigset_t __user * nset: 要添加或删除的信号（如果非空）
old_sigset_t __user * oset: 如果非空，则为信号掩码的先前值

描述

某些平台有自己的特殊参数版本；其他平台仅支持 sys_rt_sigprocmask。

long sys_rt_sigaction(int sig, const struct sigaction __user *act, struct sigaction __user *oact, size_t sigsetsize)¶: 更改进程采取的动作

参数

int sig: 要发送的信号
const struct sigaction __user * act: 新的 sigaction
struct sigaction __user * oact: 用于保存先前的 sigaction
size_t sigsetsize: sigset_t 类型的大小

long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)¶: 用 unewset 值替换信号掩码的值，直到收到信号

参数

sigset_t __user * unewset: 新的信号掩码值
size_t sigsetsize: sigset_t 类型的大小

kthread_create¶

kthread_create (threadfn, data, namefmt, arg...)

在当前节点上创建一个 kthread

参数

threadfn: 线程中要运行的函数
data: **threadfn()** 的数据指针
namefmt: 线程名称的 printf 风格格式字符串
arg...: **namefmt** 的参数。

描述

此宏将在当前节点上创建一个 kthread，使其保持停止状态。这只是 kthread_create_on_node() 的一个助手；有关更多详细信息，请参阅该处的文档。

kthread_run¶

kthread_run (threadfn, data, namefmt, ...)

创建并唤醒一个线程。

参数

threadfn: 要运行到 signal_pending(current) 的函数。
data: **threadfn** 的数据指针。
namefmt: 线程的 printf 风格名称。
...: 可变参数

描述

kthread_create() 之后 wake_up_process() 的便捷包装器。返回 kthread 或 ERR_PTR(-ENOMEM)。

struct task_struct *kthread_run_on_cpu(int (*threadfn)(void *data), void *data, unsigned int cpu, const char *namefmt)¶: 创建并唤醒一个 CPU 绑定的线程。

参数

int (*threadfn)(void *data): 要运行到 signal_pending(current) 的函数。
void *data: **threadfn** 的数据指针。
unsigned int cpu: 线程应绑定到的 CPU，
const char *namefmt: 线程的 printf 风格名称。格式限制为 “name.*``u``”。代码会填充 CPU 编号。

描述

kthread_create_on_cpu() 之后 wake_up_process() 的便捷包装器。返回 kthread 或 ERR_PTR(-ENOMEM)。

kthread_run_worker¶

kthread_run_worker (flags, namefmt, ...)

创建并唤醒一个 kthread worker。

参数

flags: 修改 worker 默认行为的标志
namefmt: 线程的 printf 风格名称。
...: 可变参数

描述

kthread_create_worker() 之后 wake_up_process() 的便捷包装器。返回 kthread_worker 或 ERR_PTR(-ENOMEM)。

struct kthread_worker *kthread_run_worker_on_cpu(int cpu, unsigned int flags, const char namefmt[])¶: 创建并唤醒一个 CPU 绑定的 kthread worker。

参数

int cpu: CPU 编号
unsigned int flags: 修改 worker 默认行为的标志
const char namefmt[]: 线程的 printf 风格名称。格式限制为 “name.*``u``”。代码会填充 CPU 编号。

描述

kthread_create_worker_on_cpu() 之后 wake_up_process() 的便捷包装器。返回 kthread_worker 或 ERR_PTR(-ENOMEM)。

bool kthread_should_stop(void)¶: 此 kthread 现在应该返回吗？

参数

void: 无参数

描述

当有人在你的 kthread 上调用 kthread_stop() 时，它将被唤醒，并且该函数会返回 true。然后你应该返回，并且你的返回值将被传递给 kthread_stop()。

bool kthread_should_park(void)¶: 这个 kthread 现在应该停泊（park）吗？

参数

void: 无参数

描述

当有人在你的 kthread 上调用 kthread_park() 时，它将被唤醒，并且该函数会返回 true。然后你应该进行必要的清理并调用 kthread_parkme()

类似于 kthread_should_stop()，但此函数保持线程存活并处于停泊（park）状态。 kthread_unpark() “重启”线程并再次调用线程函数。

bool kthread_freezable_should_stop(bool *was_frozen)¶: 这个可冻结的 kthread 现在应该返回吗？

参数

bool *was_frozen: 可选的 out 参数，指示 current 是否被冻结

描述

用于可冻结 kthread 的 kthread_should_stop()，必要时将进入冷藏状态。此函数可以避免 kthread_stop() / 冷藏器死锁，可冻结 kthread 应该使用此函数，而不是直接调用 try_to_freeze()。

void *kthread_func(struct task_struct *task)¶: 返回 kthread 创建时指定的函数

参数

struct task_struct *task: 有问题的 kthread 任务

描述

如果任务不是 kthread，则返回 NULL。

void *kthread_data(struct task_struct *task)¶: 返回 kthread 创建时指定的数据值

参数

struct task_struct *task: 有问题的 kthread 任务

描述

返回创建 kthread **task** 时指定的数据值。调用者负责在调用此函数时确保 **task** 的有效性。

void __noreturn kthread_exit(long result)¶: 使当前的 kthread 将 **result** 返回给 kthread_stop()。

参数

long result: 要返回给 kthread_stop() 的整数值。

描述

虽然可以调用 kthread_exit，但它的存在是为了可以实现诸如 module_put_and_kthread_exit 之类在非模块化代码中执行一些额外工作的功能。

不返回。

void __noreturn kthread_complete_and_exit(struct completion *comp, long code)¶: 退出当前的 kthread。

参数

struct completion *comp: 要完成的完成量
long code: 要返回给 kthread_stop() 的整数值。

描述

如果存在，则完成 **comp**，然后将代码返回给 kthread_stop()。

其模块可能在 **comp** 完成后被删除的内核线程可以使用此函数安全地退出。

不返回。

struct task_struct *kthread_create_on_node(int (*threadfn)(void *data), void *data, int node, const char namefmt[], ...)¶: 创建一个 kthread。

参数

int (*threadfn)(void *data): 要运行到 signal_pending(current) 的函数。
void *data: **threadfn** 的数据指针。
int node: 线程的任务和线程结构在此节点上分配
const char namefmt[]: 线程的 printf 风格名称。
...: 可变参数

描述

此辅助函数创建并命名一个内核线程。该线程将被停止：使用 wake_up_process() 启动它。另请参见 kthread_run()。新线程具有 SCHED_NORMAL 策略，并且与所有 CPU 仿射。

如果线程将绑定到特定的 cpu，请在 **node** 中指定其节点，以获得 kthread 堆栈的 NUMA 关联性，否则给出 NUMA_NO_NODE。唤醒后，线程将使用 **data** 作为其参数运行 **threadfn()**。 **threadfn()** 可以直接返回，如果它是一个独立的线程，没有人会调用 kthread_stop()，或者当“kthread_should_stop()”为 true 时返回（这意味着已调用 kthread_stop()）。返回值应为零或负错误号；它将被传递给 kthread_stop()。

返回 task_struct 或 ERR_PTR(-ENOMEM) 或 ERR_PTR(-EINTR)。

void kthread_bind(struct task_struct *p, unsigned int cpu)¶: 将刚创建的 kthread 绑定到 cpu。

参数

struct task_struct *p: 由 kthread_create() 创建的线程。
unsigned int cpu: **k** 要运行的 cpu（可能不在线，必须可以）。

描述

此函数等效于 set_cpus_allowed()，除了 **cpu** 不需要在线之外，并且线程必须停止（即，刚从 kthread_create() 返回）。

struct task_struct *kthread_create_on_cpu(int (*threadfn)(void *data), void *data, unsigned int cpu, const char *namefmt)¶: 创建一个 cpu 绑定的 kthread

参数

int (*threadfn)(void *data): 要运行到 signal_pending(current) 的函数。
void *data: **threadfn** 的数据指针。
unsigned int cpu: 线程应绑定到的 CPU，
const char *namefmt: 线程的 printf 风格名称。格式限制为 “name.*``u``”。代码会填充 CPU 编号。

描述

此辅助函数创建并命名一个内核线程

void kthread_unpark(struct task_struct *k)¶: 取消停泊由 kthread_create() 创建的线程。

参数

struct task_struct *k: 由 kthread_create() 创建的线程。

描述

将 kthread_should_park() 设置为 **k** 以返回 false，唤醒它，并等待它返回。如果线程被标记为 percpu，则再次将其绑定到 cpu。

int kthread_park(struct task_struct *k)¶: 停泊由 kthread_create() 创建的线程。

参数

struct task_struct *k: 由 kthread_create() 创建的线程。

描述

将 kthread_should_park() 设置为 **k** 以返回 true，唤醒它，并等待它返回。也可以在调用 kthread_create() 后调用它，而不是调用 wake_up_process()：线程将停泊，而不调用 threadfn()。

如果线程已停泊，则返回 0；如果线程已退出，则返回 -ENOSYS。如果由 kthread 本身调用，则只设置停泊位。

int kthread_stop(struct task_struct *k)¶: 停止由 kthread_create() 创建的线程。

参数

struct task_struct *k: 由 kthread_create() 创建的线程。

描述

将 kthread_should_stop() 设置为 **k** 以返回 true，唤醒它，并等待它退出。也可以在调用 kthread_create() 后调用它，而不是调用 wake_up_process()：线程将退出，而不调用 threadfn()。

如果 threadfn() 可以调用 kthread_exit() 本身，则调用者必须确保 task_struct 不会消失。

返回 threadfn() 的结果，如果从未调用 wake_up_process()，则返回 -EINTR。

int kthread_stop_put(struct task_struct *k)¶: 停止线程并放置其任务结构

参数

struct task_struct *k: 由 kthread_create() 创建的线程。

描述

停止由 kthread_create() 创建的线程并放置其 task_struct。仅在持有通过调用 get_task_struct() 获得的额外任务结构引用时使用。

int kthread_worker_fn(void *worker_ptr)¶: 处理 kthread_worker 的 kthread 函数

参数

void *worker_ptr: 指向已初始化的 kthread_worker 的指针

描述

此函数实现 kthread worker 的主循环。它处理 work_list，直到使用 kthread_stop() 停止它。当队列为空时，它会休眠。

不允许工作在完成时保留任何锁、禁用抢占或中断。定义了一个安全点，用于在完成一项工作之后和启动一项新工作之前进行冻结。

此外，不得由多个 worker 同时处理工作，另请参见 kthread_queue_work()。

struct kthread_worker *kthread_create_worker_on_node(unsigned int flags, int node, const char namefmt[], ...)¶: 创建一个 kthread worker

参数

unsigned int flags: 修改 worker 默认行为的标志
int node: 线程的任务结构在此节点上分配
const char namefmt[]: kthread worker（任务）的 printf 风格名称。
...: 可变参数

描述

成功时返回指向已分配 worker 的指针，当无法分配所需结构时返回 ERR_PTR(-ENOMEM)，当调用者被致命信号终止时返回 ERR_PTR(-EINTR)。

struct kthread_worker *kthread_create_worker_on_cpu(int cpu, unsigned int flags, const char namefmt[])¶: 创建一个 kthread worker 并将其绑定到给定的 CPU 和关联的 NUMA 节点。

参数

int cpu: CPU 编号
unsigned int flags: 修改 worker 默认行为的标志
const char namefmt[]: 线程的 printf 风格名称。格式限制为 “name.*``u``”。代码会填充 CPU 编号。

描述

如果要将 kthread worker 绑定到给定的 CPU 和关联的 NUMA 节点，请使用有效的 CPU 编号。

一个好的做法是将 cpu 编号也添加到 worker 名称中。例如，使用 kthread_create_worker_on_cpu(cpu, “helper/d”, cpu)。

CPU 热插拔：kthread worker API 简单而通用。它只提供了一种创建、使用和销毁 worker 的方法。

如何处理 CPU 热插拔取决于 API 用户。他们必须决定如何处理挂起的工作项、阻止排队新的工作项，以及在 CPU 关闭和打开时恢复功能。有一些注意事项

当在离线 CPU 上调度 CPU 时，CPU 关联性会丢失。

当用户创建 worker 时，如果 CPU 已关闭，则 worker 可能不存在。

一个好的做法是实现两个 CPU 热插拔回调，并在 CPU 关闭/启动时销毁/创建 worker。

返回

成功时返回指向已分配 worker 的指针，当无法分配所需结构时返回 ERR_PTR(-ENOMEM)，当调用者被致命信号终止时返回 ERR_PTR(-EINTR)。

bool kthread_queue_work(struct kthread_worker *worker, struct kthread_work *work)¶: 排队一个 kthread_work

参数

struct kthread_worker *worker: 目标 kthread_worker
struct kthread_work *work: 要排队的 kthread_work

描述

将 **work** 排队到工作处理器 **task** 以进行异步执行。 **task** 必须已使用 kthread_create_worker() 创建。如果 **work** 成功排队，则返回 true，如果它已经在挂起，则返回 false。

如果工作需要被另一个 worker 使用，则重新初始化它。例如，当 worker 停止并再次启动时。

void kthread_delayed_work_timer_fn(struct timer_list *t)¶: 当定时器到期时，将关联的 kthread 延迟工作项加入队列的回调函数。

参数

struct timer_list *t: 指向已到期定时器的指针

描述

此函数的格式由 struct timer_list 定义。它应该已经从 irqsafe 定时器中调用，并且中断已被禁用。

bool kthread_queue_delayed_work(struct kthread_worker *worker, struct kthread_delayed_work *dwork, unsigned long delay)¶: 在延迟后将关联的 kthread 工作项加入队列。

参数

struct kthread_worker *worker: 目标 kthread_worker
struct kthread_delayed_work *dwork: 要加入队列的 kthread_delayed_work
unsigned long delay: 加入队列前要等待的节拍数

描述

如果工作项尚未挂起，它会启动一个定时器，该定时器将在给定的 delay 后将工作项加入队列。如果 delay 为零，它会立即将工作项加入队列。

返回

如果 work 已经挂起，则返回 false。这意味着定时器正在运行或工作项已加入队列。否则，返回 true。

void kthread_flush_work(struct kthread_work *work)¶: 刷新一个 kthread_work

参数

struct kthread_work *work: 要刷新的工作项

描述

如果 work 已加入队列或正在执行，则等待它完成执行。

bool kthread_mod_delayed_work(struct kthread_worker *worker, struct kthread_delayed_work *dwork, unsigned long delay)¶: 修改延迟或将 kthread 延迟工作项加入队列

参数

struct kthread_worker *worker: 要使用的 kthread 工作者
struct kthread_delayed_work *dwork: 要加入队列的 kthread 延迟工作项
unsigned long delay: 加入队列前要等待的节拍数

描述

如果 dwork 处于空闲状态，则等同于 kthread_queue_delayed_work()。否则，修改 dwork 的定时器，使其在 delay 后到期。如果 delay 为零，则保证 work 会立即加入队列。

一种特殊情况是，工作项正在并行取消。这可能是由真实的 kthread_cancel_delayed_work_sync() 或另一个 kthread_mod_delayed_work() 调用引起的。我们让另一个命令获胜并在此处返回 true。返回值可用于引用计数，并且已加入队列的工作项数量保持不变。无论如何，调用者应该以合理的方式同步这些操作。

此函数可以从任何上下文（包括 IRQ 处理程序）中安全调用。有关详细信息，请参见 __kthread_cancel_work() 和 kthread_delayed_work_timer_fn()。

返回

如果 dwork 处于空闲状态并已加入队列，则返回 false，否则返回 true。

bool kthread_cancel_work_sync(struct kthread_work *work)¶: 取消 kthread 工作项并等待其完成

参数

struct kthread_work *work: 要取消的 kthread 工作项

描述

取消 work 并等待其执行完成。即使工作项重新将自身加入队列，也可以使用此函数。从此函数返回时，保证 work 不会挂起或在任何 CPU 上执行。

kthread_cancel_work_sync(delayed_work->work) 不得用于 delayed_work。请改用 kthread_cancel_delayed_work_sync()。

调用者必须确保在函数返回之前，上次将 work 加入队列的工作者无法被销毁。

返回

如果 work 处于挂起状态，则返回 true，否则返回 false。

bool kthread_cancel_delayed_work_sync(struct kthread_delayed_work *dwork)¶: 取消 kthread 延迟工作项并等待其完成。

参数

struct kthread_delayed_work *dwork: 要取消的 kthread 延迟工作项

描述

这是用于延迟工作项的 kthread_cancel_work_sync()。

返回

如果 dwork 处于挂起状态，则返回 true，否则返回 false。

void kthread_flush_worker(struct kthread_worker *worker)¶: 刷新 kthread_worker 上的所有当前工作项

参数

struct kthread_worker *worker: 要刷新的工作者

描述

等待 worker 上当前正在执行或挂起的所有工作项完成。

void kthread_destroy_worker(struct kthread_worker *worker)¶: 销毁一个 kthread 工作者

参数

struct kthread_worker *worker: 要销毁的工作者

描述

刷新并销毁 worker。简单的刷新就足够了，因为 kthread 工作者 API 仅用于简单的场景。不需要多步骤状态机。

请注意，此函数不负责处理延迟工作项，因此调用者应负责在调用此函数之前将所有延迟工作项加入队列或取消。

void kthread_use_mm(struct mm_struct *mm)¶: 使调用 kthread 在一个地址空间上运行

参数

struct mm_struct *mm: 要运行的地址空间

void kthread_unuse_mm(struct mm_struct *mm)¶: 反转 kthread_use_mm() 的效果

参数

struct mm_struct *mm: 要运行的地址空间

void kthread_associate_blkcg(struct cgroup_subsys_state *css)¶: 将 blkcg 与当前 kthread 关联

参数

struct cgroup_subsys_state *css: cgroup 信息

描述

当前线程必须是一个 kthread。该线程代表其他线程运行作业。在某些情况下，我们希望作业附加原始线程的 cgroup 信息，而不是当前线程的信息。此函数将原始线程的 cgroup 信息存储在当前 kthread 上下文中，以便稍后检索。

引用计数¶

void refcount_set(refcount_t *r, int n)¶: 设置引用计数的值

参数

refcount_t *r: 引用计数
int n: 引用计数将被设置的值

void refcount_set_release(refcount_t *r, int n)¶: 使用 release 排序设置引用计数的值

参数

refcount_t *r: 引用计数
int n: 引用计数将被设置的值

描述

当对象占用的内存可能被重用来存储另一个对象时，应该使用此函数 -- 考虑 SLAB_TYPESAFE_BY_RCU。

提供 release 内存排序，这将对该存储之前的内存操作进行排序。这确保了对该对象的所有更新在引用计数设置后都是可见的，并且先前占用该内存的对象的陈旧值将被新值覆盖。

此函数应仅在新对象完全初始化后调用。在此调用之后，应认为该对象对其他任务可见，即使它尚未添加到通常用于发现它的对象集合中。这是因为其他任务可能已经发现了先前占用相同内存的对象，并且在内存重用之后，它们可以成功获取对新对象的引用计数并开始使用它。

unsigned int refcount_read(const refcount_t *r)¶: 获取引用计数的值

参数

const refcount_t *r: 引用计数

返回

引用计数的值

bool refcount_add_not_zero(int i, refcount_t *r)¶: 向引用计数添加一个值，除非它为 0

参数

int i: 要添加到引用计数的值
refcount_t *r: 引用计数

描述

将在 REFCOUNT_SATURATED 处饱和并发出警告。

不提供内存排序，假设调用者已保证对象内存是稳定的（RCU 等）。它确实提供了一个控制依赖关系，从而对未来的存储进行排序。参见顶部的注释。

不建议将此函数用于正常的引用计数用例，在这些用例中，引用一次一个地被获取和释放。在这些情况下，应该使用 refcount_inc() 或其变体之一来递增引用计数。

返回

如果传递的引用计数为 0，则返回 false，否则返回 true

bool refcount_add_not_zero_acquire(int i, refcount_t *r)¶: 向引用计数添加一个值，除非它为 0，否则使用 acquire 排序

参数

int i: 要添加到引用计数的值
refcount_t *r: 引用计数

描述

将在 REFCOUNT_SATURATED 处饱和并发出警告。

当对象占用的内存可能被重用来存储另一个对象时，应该使用此函数 -- 考虑 SLAB_TYPESAFE_BY_RCU。

成功时提供 acquire 内存排序，假设调用者已保证对象内存是稳定的（RCU 等）。它确实提供了一个控制依赖关系，从而对未来的存储进行排序。参见顶部的注释。

不建议将此函数用于正常的引用计数用例，在这些用例中，引用一次一个地被获取和释放。在这些情况下，应该使用 refcount_inc_not_zero_acquire() 来递增引用计数。

返回

如果传递的引用计数为 0，则返回 false，否则返回 true

void refcount_add(int i, refcount_t *r)¶: 向引用计数添加一个值

参数

int i: 要添加到引用计数的值
refcount_t *r: 引用计数

描述

类似于 atomic_add()，但将在 REFCOUNT_SATURATED 处饱和并发出警告。

不提供内存排序，假设调用者已保证对象内存是稳定的（RCU 等）。它确实提供了一个控制依赖关系，从而对未来的存储进行排序。参见顶部的注释。

不建议将此函数用于正常的引用计数用例，在这些用例中，引用一次一个地被获取和释放。在这些情况下，应该使用 refcount_inc() 或其变体之一来递增引用计数。

bool refcount_inc_not_zero(refcount_t *r)¶: 递增引用计数，除非它为 0

参数

refcount_t *r: 要递增的引用计数

描述

类似于 atomic_inc_not_zero()，但将在 REFCOUNT_SATURATED 处饱和并发出警告。

不提供内存排序，假设调用者已保证对象内存是稳定的（RCU 等）。它确实提供了一个控制依赖关系，从而对未来的存储进行排序。参见顶部的注释。

返回

如果递增成功，则返回 true，否则返回 false

bool refcount_inc_not_zero_acquire(refcount_t *r)¶: 递增引用计数，除非它为 0，否则使用 acquire 排序

参数

refcount_t *r: 要递增的引用计数

描述

类似于 refcount_inc_not_zero()，但在成功时提供 acquire 内存排序。

当对象占用的内存可能被重用来存储另一个对象时，应该使用此函数 -- 考虑 SLAB_TYPESAFE_BY_RCU。

成功时提供 acquire 内存排序，假设调用者已保证对象内存是稳定的（RCU 等）。它确实提供了一个控制依赖关系，从而对未来的存储进行排序。参见顶部的注释。

返回

如果递增成功，则返回 true，否则返回 false

void refcount_inc(refcount_t *r)¶: 递增引用计数

参数

refcount_t *r: 要递增的引用计数

描述

类似于 atomic_inc()，但将在 REFCOUNT_SATURATED 处饱和并发出警告。

不提供内存排序，假设调用者已经对对象进行了引用。

如果引用计数为 0，则会发出警告，因为这表示可能存在释放后使用的情况。

bool refcount_sub_and_test(int i, refcount_t *r)¶: 从引用计数中减去一个值并测试它是否为 0

参数

int i: 要从引用计数中减去的量
refcount_t *r: 引用计数

描述

类似于 atomic_dec_and_test()，但它会在下溢时发出警告，返回 false 并最终泄漏，并且当在 REFCOUNT_SATURATED 处饱和时将无法递减。

提供 release 内存排序，以便先完成先前的加载和存储，并在成功时提供 acquire 排序，以便 free() 必须在之后进行。

不建议将此函数用于正常的引用计数用例，在这些用例中，引用一次一个地被获取和释放。在这些情况下，应该使用 refcount_dec() 或其变体之一来递减引用计数。

返回

如果结果引用计数为 0，则返回 true，否则返回 false

bool refcount_dec_and_test(refcount_t *r)¶: 递减引用计数并测试它是否为 0

参数

refcount_t *r: 引用计数

描述

类似于 atomic_dec_and_test()，它会在下溢时发出警告，并且当在 REFCOUNT_SATURATED 处饱和时将无法递减。

提供 release 内存排序，以便先完成先前的加载和存储，并在成功时提供 acquire 排序，以便 free() 必须在之后进行。

返回

如果结果引用计数为 0，则返回 true，否则返回 false

void refcount_dec(refcount_t *r)¶: 减少引用计数

参数

refcount_t *r: 引用计数

描述

类似于 atomic_dec()，它会在下溢时发出警告，并在饱和到 REFCOUNT_SATURATED 时无法减少。

提供释放内存排序，以便在之前完成加载和存储。

bool refcount_dec_if_one(refcount_t *r)¶: 如果引用计数为 1，则减少它

参数

refcount_t *r: 引用计数

描述

没有 atomic_t 对应项，它尝试 1 -> 0 的转换，并返回是否成功。

与所有减少操作一样，它提供释放内存顺序，并提供控制依赖关系。

它可以像尝试删除运算符一样使用；提供了这个显式情况，而不是通用的 cmpxchg，因为这将允许实现不安全的操作。

返回

如果结果引用计数为 0，则返回 true，否则返回 false

bool refcount_dec_not_one(refcount_t *r)¶: 如果引用计数不为 1，则减少它

参数

refcount_t *r: 引用计数

描述

没有 atomic_t 对应项，除非值为 1，否则它会减少，在这种情况下它将返回 false。

通常像这样完成：atomic_add_unless(var, -1, 1)

返回

如果减少操作成功，则为 true，否则为 false

bool refcount_dec_and_mutex_lock(refcount_t *r, struct mutex *lock)¶: 如果能够将引用计数减少到 0，则返回持有互斥锁

参数

refcount_t *r: 引用计数
struct mutex *lock: 要锁定的互斥锁

描述

类似于 atomic_dec_and_mutex_lock()，它会在下溢时发出警告，并在饱和到 REFCOUNT_SATURATED 时无法减少。

提供释放内存排序，以便在之前完成加载和存储，并提供控制依赖关系，以便 free() 必须在之后进行。请参阅顶部的注释。

返回

如果能够将引用计数减少到 0，则为 true 并持有互斥锁，否则为 false: 否则

bool refcount_dec_and_lock(refcount_t *r, spinlock_t *lock)¶: 如果能够将引用计数减少到 0，则返回持有自旋锁

参数

refcount_t *r: 引用计数
spinlock_t *lock: 要锁定的自旋锁

描述

类似于 atomic_dec_and_lock()，它会在下溢时发出警告，并在饱和到 REFCOUNT_SATURATED 时无法减少。

提供释放内存排序，以便在之前完成加载和存储，并提供控制依赖关系，以便 free() 必须在之后进行。请参阅顶部的注释。

返回

如果能够将引用计数减少到 0，则为 true 并持有自旋锁，否则为 false: 否则

bool refcount_dec_and_lock_irqsave(refcount_t *r, spinlock_t *lock, unsigned long *flags)¶: 如果能够将引用计数减少到 0，则返回持有禁用中断的自旋锁

参数

refcount_t *r: 引用计数
spinlock_t *lock: 要锁定的自旋锁
unsigned long *flags: 如果获得了 IRQ，则保存的 IRQ 标志

描述

与上面的 refcount_dec_and_lock() 相同，只是使用禁用中断的方式获得自旋锁。

返回

如果能够将引用计数减少到 0，则为 true 并持有自旋锁，否则为 false: 否则

原子操作¶

int atomic_read(const atomic_t *v)¶: 具有宽松排序的原子加载

参数

const atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用宽松排序加载 v 的值。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_read()。

返回

从 v 加载的值。

int atomic_read_acquire(const atomic_t *v)¶: 具有获取排序的原子加载

参数

const atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用获取排序加载 v 的值。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_read_acquire()。

返回

从 v 加载的值。

void atomic_set(atomic_t *v, int i)¶: 具有宽松排序的原子设置

参数

atomic_t *v: 指向 atomic_t 的指针
int i: 要分配的 int 值

描述

以原子方式使用宽松排序将 v 设置为 i。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_set()。

返回

没有。

void atomic_set_release(atomic_t *v, int i)¶: 具有释放排序的原子设置

参数

atomic_t *v: 指向 atomic_t 的指针
int i: 要分配的 int 值

描述

以原子方式使用释放排序将 v 设置为 i。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_set_release()。

返回

没有。

void atomic_add(int i, atomic_t *v)¶: 具有宽松排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_add()。

返回

没有。

int atomic_add_return(int i, atomic_t *v)¶: 具有完整排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_add_return()。

返回

v 的更新值。

int atomic_add_return_acquire(int i, atomic_t *v)¶: 具有获取排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_add_return_acquire()。

返回

v 的更新值。

int atomic_add_return_release(int i, atomic_t *v)¶: 具有释放排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_add_return_release()。

返回

v 的更新值。

int atomic_add_return_relaxed(int i, atomic_t *v)¶: 具有宽松排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_add_return_relaxed()。

返回

v 的更新值。

int atomic_fetch_add(int i, atomic_t *v)¶: 具有完整排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_fetch_add()。

返回

v 的原始值。

int atomic_fetch_add_acquire(int i, atomic_t *v)¶: 具有获取排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_fetch_add_acquire()。

返回

v 的原始值。

int atomic_fetch_add_release(int i, atomic_t *v)¶: 具有释放排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_fetch_add_release()。

返回

v 的原始值。

int atomic_fetch_add_relaxed(int i, atomic_t *v)¶: 具有宽松排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_fetch_add_relaxed()。

返回

v 的原始值。

void atomic_sub(int i, atomic_t *v)¶: 具有宽松排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_sub()。

返回

没有。

int atomic_sub_return(int i, atomic_t *v)¶: 具有完整排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_sub_return()。

返回

v 的更新值。

int atomic_sub_return_acquire(int i, atomic_t *v)¶: 具有获取排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v - i)。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_sub_return_acquire()。

返回

v 的更新值。

int atomic_sub_return_release(int i, atomic_t *v)¶: 具有释放排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v - i)。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_sub_return_release()。

返回

v 的更新值。

int atomic_sub_return_relaxed(int i, atomic_t *v)¶: 具有宽松排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

在 noinstr 代码中使用不安全；在那里使用 raw_atomic_sub_return_relaxed()。

返回

v 的更新值。

int atomic_fetch_sub(int i, atomic_t *v)¶: 具有完整排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_sub()。

返回

v 的原始值。

int atomic_fetch_sub_acquire(int i, atomic_t *v)¶: 具有获取排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_sub_acquire()。

返回

v 的原始值。

int atomic_fetch_sub_release(int i, atomic_t *v)¶: 具有释放排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_sub_release()。

返回

v 的原始值。

int atomic_fetch_sub_relaxed(int i, atomic_t *v)¶: 具有宽松排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_sub_relaxed()。

返回

v 的原始值。

void atomic_inc(atomic_t *v)¶: 使用宽松排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_inc()。

返回

没有。

int atomic_inc_return(atomic_t *v)¶: 使用完整排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_inc_return()。

返回

v 的更新值。

int atomic_inc_return_acquire(atomic_t *v)¶: 使用获取排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用获取排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_inc_return_acquire()。

返回

v 的更新值。

int atomic_inc_return_release(atomic_t *v)¶: 使用释放排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用释放排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_inc_return_release()。

返回

v 的更新值。

int atomic_inc_return_relaxed(atomic_t *v)¶: 使用宽松排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_inc_return_relaxed()。

返回

v 的更新值。

int atomic_fetch_inc(atomic_t *v)¶: 使用完整排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_inc()。

返回

v 的原始值。

int atomic_fetch_inc_acquire(atomic_t *v)¶: 使用获取排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用获取排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_inc_acquire()。

返回

v 的原始值。

int atomic_fetch_inc_release(atomic_t *v)¶: 使用释放排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用释放排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_inc_release()。

返回

v 的原始值。

int atomic_fetch_inc_relaxed(atomic_t *v)¶: 使用宽松排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_inc_relaxed()。

返回

v 的原始值。

void atomic_dec(atomic_t *v)¶: 使用宽松排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_dec()。

返回

没有。

int atomic_dec_return(atomic_t *v)¶: 使用完整排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_dec_return()。

返回

v 的更新值。

int atomic_dec_return_acquire(atomic_t *v)¶: 使用获取排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用获取排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_dec_return_acquire()。

返回

v 的更新值。

int atomic_dec_return_release(atomic_t *v)¶: 使用释放排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用释放排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_dec_return_release()。

返回

v 的更新值。

int atomic_dec_return_relaxed(atomic_t *v)¶: 使用宽松排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_dec_return_relaxed()。

返回

v 的更新值。

int atomic_fetch_dec(atomic_t *v)¶: 使用完整排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_dec()。

返回

v 的原始值。

int atomic_fetch_dec_acquire(atomic_t *v)¶: 使用获取排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用获取排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_dec_acquire()。

返回

v 的原始值。

int atomic_fetch_dec_release(atomic_t *v)¶: 使用释放排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用释放排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_dec_release()。

返回

v 的原始值。

int atomic_fetch_dec_relaxed(atomic_t *v)¶: 使用宽松排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_dec_relaxed()。

返回

v 的原始值。

void atomic_and(int i, atomic_t *v)¶: 使用宽松排序的原子按位与

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_and()。

返回

没有。

int atomic_fetch_and(int i, atomic_t *v)¶: 使用完整排序的原子按位与

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

使用完整排序原子地更新 v 为 (v & i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_and()。

返回

v 的原始值。

int atomic_fetch_and_acquire(int i, atomic_t *v)¶: 使用获取排序的原子按位与

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

使用获取排序原子地更新 v 为 (v & i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_and_acquire()。

返回

v 的原始值。

int atomic_fetch_and_release(int i, atomic_t *v)¶: 使用释放排序的原子按位与

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

使用释放排序原子地更新 v 为 (v & i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_and_release()。

返回

v 的原始值。

int atomic_fetch_and_relaxed(int i, atomic_t *v)¶: 使用宽松排序的原子按位与

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_and_relaxed()。

返回

v 的原始值。

void atomic_andnot(int i, atomic_t *v)¶: 使用宽松排序的原子按位与非

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & ~i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_andnot()。

返回

没有。

int atomic_fetch_andnot(int i, atomic_t *v)¶: 使用完整排序的原子按位与非

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

使用完整排序原子地更新 v 为 (v & ~i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_andnot()。

返回

v 的原始值。

int atomic_fetch_andnot_acquire(int i, atomic_t *v)¶: 具有获取顺序的原子按位与非操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v & ~i)，并具有获取顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_andnot_acquire()。

返回

v 的原始值。

int atomic_fetch_andnot_release(int i, atomic_t *v)¶: 具有释放顺序的原子按位与非操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v & ~i)，并具有释放顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_andnot_release()。

返回

v 的原始值。

int atomic_fetch_andnot_relaxed(int i, atomic_t *v)¶: 使用宽松排序的原子按位与非

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & ~i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_andnot_relaxed()。

返回

v 的原始值。

void atomic_or(int i, atomic_t *v)¶: 具有宽松顺序的原子按位或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有宽松顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_or()。

返回

没有。

int atomic_fetch_or(int i, atomic_t *v)¶: 具有完整顺序的原子按位或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有完整顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_or()。

返回

v 的原始值。

int atomic_fetch_or_acquire(int i, atomic_t *v)¶: 具有获取顺序的原子按位或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有获取顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_or_acquire()。

返回

v 的原始值。

int atomic_fetch_or_release(int i, atomic_t *v)¶: 具有释放顺序的原子按位或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有释放顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_or_release()。

返回

v 的原始值。

int atomic_fetch_or_relaxed(int i, atomic_t *v)¶: 具有宽松顺序的原子按位或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有宽松顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_or_relaxed()。

返回

v 的原始值。

void atomic_xor(int i, atomic_t *v)¶: 具有宽松顺序的原子按位异或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有宽松顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_xor()。

返回

没有。

int atomic_fetch_xor(int i, atomic_t *v)¶: 具有完整顺序的原子按位异或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有完整顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_xor()。

返回

v 的原始值。

int atomic_fetch_xor_acquire(int i, atomic_t *v)¶: 具有获取顺序的原子按位异或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有获取顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_xor_acquire()。

返回

v 的原始值。

int atomic_fetch_xor_release(int i, atomic_t *v)¶: 具有释放顺序的原子按位异或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有释放顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_xor_release()。

返回

v 的原始值。

int atomic_fetch_xor_relaxed(int i, atomic_t *v)¶: 具有宽松顺序的原子按位异或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有宽松顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_xor_relaxed()。

返回

v 的原始值。

int atomic_xchg(atomic_t *v, int new)¶: 具有完整顺序的原子交换

参数

atomic_t *v: 指向 atomic_t 的指针
int new: 要分配的 int 值

描述

以原子方式更新 v 为 new，并具有完整顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_xchg()。

返回

v 的原始值。

int atomic_xchg_acquire(atomic_t *v, int new)¶: 具有获取顺序的原子交换

参数

atomic_t *v: 指向 atomic_t 的指针
int new: 要分配的 int 值

描述

以原子方式更新 v 为 new，并具有获取顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_xchg_acquire()。

返回

v 的原始值。

int atomic_xchg_release(atomic_t *v, int new)¶: 具有释放顺序的原子交换

参数

atomic_t *v: 指向 atomic_t 的指针
int new: 要分配的 int 值

描述

以原子方式更新 v 为 new，并具有释放顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_xchg_release()。

返回

v 的原始值。

int atomic_xchg_relaxed(atomic_t *v, int new)¶: 具有宽松顺序的原子交换

参数

atomic_t *v: 指向 atomic_t 的指针
int new: 要分配的 int 值

描述

以原子方式更新 v 为 new，并具有宽松顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_xchg_relaxed()。

返回

v 的原始值。

int atomic_cmpxchg(atomic_t *v, int old, int new)¶: 具有完整顺序的原子比较和交换

参数

atomic_t *v: 指向 atomic_t 的指针
int old: 用于比较的整数值
int new: 要分配的 int 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有完整顺序。否则，v 不会被修改，并提供宽松顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_cmpxchg()。

返回

v 的原始值。

int atomic_cmpxchg_acquire(atomic_t *v, int old, int new)¶: 具有获取顺序的原子比较和交换

参数

atomic_t *v: 指向 atomic_t 的指针
int old: 用于比较的整数值
int new: 要分配的 int 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有获取顺序。否则，v 不会被修改，并提供宽松顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_cmpxchg_acquire()。

返回

v 的原始值。

int atomic_cmpxchg_release(atomic_t *v, int old, int new)¶: 具有释放顺序的原子比较和交换

参数

atomic_t *v: 指向 atomic_t 的指针
int old: 用于比较的整数值
int new: 要分配的 int 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有释放顺序。否则，v 不会被修改，并提供宽松顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_cmpxchg_release()。

返回

v 的原始值。

int atomic_cmpxchg_relaxed(atomic_t *v, int old, int new)¶: 具有宽松顺序的原子比较和交换

参数

atomic_t *v: 指向 atomic_t 的指针
int old: 用于比较的整数值
int new: 要分配的 int 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有宽松顺序。否则，v 不会被修改，并提供宽松顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_cmpxchg_relaxed()。

返回

v 的原始值。

bool atomic_try_cmpxchg(atomic_t *v, int *old, int new)¶: 具有完整顺序的原子比较和交换

参数

atomic_t *v: 指向 atomic_t 的指针
int *old: 指向用于比较的整数值的指针
int new: 要分配的 int 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有完整顺序。否则，v 不会被修改， old 会更新为 v 的当前值，并提供宽松顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_try_cmpxchg()。

返回

如果发生交换，则为 true，否则为 false。

bool atomic_try_cmpxchg_acquire(atomic_t *v, int *old, int new)¶: 具有获取顺序的原子比较和交换

参数

atomic_t *v: 指向 atomic_t 的指针
int *old: 指向用于比较的整数值的指针
int new: 要分配的 int 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有获取顺序。否则，v 不会被修改， old 会更新为 v 的当前值，并提供宽松顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_try_cmpxchg_acquire()。

返回

如果发生交换，则为 true，否则为 false。

bool atomic_try_cmpxchg_release(atomic_t *v, int *old, int new)¶: 具有释放顺序的原子比较和交换

参数

atomic_t *v: 指向 atomic_t 的指针
int *old: 指向用于比较的整数值的指针
int new: 要分配的 int 值

描述

如果 (v == old)，则以原子方式使用 release ordering 将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供 relaxed ordering。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic_try_cmpxchg_release()。

返回

如果发生交换，则为 true，否则为 false。

bool atomic_try_cmpxchg_relaxed(atomic_t *v, int *old, int new)¶: 具有宽松顺序的原子比较和交换

参数

atomic_t *v: 指向 atomic_t 的指针
int *old: 指向用于比较的整数值的指针
int new: 要分配的 int 值

描述

如果 (v == old)，则以原子方式使用 relaxed ordering 将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供 relaxed ordering。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic_try_cmpxchg_relaxed()。

返回

如果发生交换，则为 true，否则为 false。

bool atomic_sub_and_test(int i, atomic_t *v)¶: 原子减法并测试是否为零，使用 full ordering

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic_sub_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool atomic_dec_and_test(atomic_t *v)¶: 原子递减并测试是否为零，使用 full ordering

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic_dec_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool atomic_inc_and_test(atomic_t *v)¶: 原子递增并测试是否为零，使用 full ordering

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic_inc_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool atomic_add_negative(int i, atomic_t *v)¶: 原子加法并测试是否为负数，使用 full ordering

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic_add_negative()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool atomic_add_negative_acquire(int i, atomic_t *v)¶: 原子加法并测试是否为负数，使用 acquire ordering

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic_add_negative_acquire()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool atomic_add_negative_release(int i, atomic_t *v)¶: 原子加法并测试是否为负数，使用 release ordering

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic_add_negative_release()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool atomic_add_negative_relaxed(int i, atomic_t *v)¶: 原子加法并测试是否为负数，使用 relaxed ordering

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic_add_negative_relaxed()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

int atomic_fetch_add_unless(atomic_t *v, int a, int u)¶: 原子加法，除非值为 full ordering

参数

atomic_t *v: 指向 atomic_t 的指针
int a: 要添加的 int 值
int u: 用于比较的整数值

描述

如果 (v != u)，则以原子方式使用 full ordering 将 v 更新为 (v + a)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic_fetch_add_unless()。

返回

v 的原始值。

bool atomic_add_unless(atomic_t *v, int a, int u)¶: 原子加法，除非值为 full ordering

参数

atomic_t *v: 指向 atomic_t 的指针
int a: 要添加的 int 值
int u: 用于比较的整数值

描述

如果 (v != u)，则以原子方式使用 full ordering 将 v 更新为 (v + a)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic_add_unless()。

返回

如果 v 已更新，则为 true，否则为 false。

bool atomic_inc_not_zero(atomic_t *v)¶: 原子递增，除非为零，使用 full ordering

参数

atomic_t *v: 指向 atomic_t 的指针

描述

如果 (v != 0)，则以原子方式使用 full ordering 将 v 更新为 (v + 1)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic_inc_not_zero()。

返回

如果 v 已更新，则为 true，否则为 false。

bool atomic_inc_unless_negative(atomic_t *v)¶: 原子递增，除非为负数，使用 full ordering

参数

atomic_t *v: 指向 atomic_t 的指针

描述

如果 (v >= 0)，则以原子方式使用 full ordering 将 v 更新为 (v + 1)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic_inc_unless_negative()。

返回

如果 v 已更新，则为 true，否则为 false。

bool atomic_dec_unless_positive(atomic_t *v)¶: 原子递减，除非为正数，使用 full ordering

参数

atomic_t *v: 指向 atomic_t 的指针

描述

如果 (v <= 0)，则以原子方式使用 full ordering 将 v 更新为 (v - 1)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic_dec_unless_positive()。

返回

如果 v 已更新，则为 true，否则为 false。

int atomic_dec_if_positive(atomic_t *v)¶: 原子递减（如果为正数），使用 full ordering

参数

atomic_t *v: 指向 atomic_t 的指针

描述

如果 (v > 0)，则以原子方式使用 full ordering 将 v 更新为 (v - 1)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic_dec_if_positive()。

返回

(v - 1) 的旧值，无论 v 是否已更新。

s64 atomic64_read(const atomic64_t *v)¶: 具有宽松排序的原子加载

参数

const atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序加载 v 的值。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic64_read()。

返回

从 v 加载的值。

s64 atomic64_read_acquire(const atomic64_t *v)¶: 具有获取排序的原子加载

参数

const atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用获取排序加载 v 的值。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic64_read_acquire()。

返回

从 v 加载的值。

void atomic64_set(atomic64_t *v, s64 i)¶: 具有宽松排序的原子设置

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 i: 要分配的 s64 值

描述

以原子方式使用宽松排序将 v 设置为 i。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic64_set()。

返回

没有。

void atomic64_set_release(atomic64_t *v, s64 i)¶: 具有释放排序的原子设置

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 i: 要分配的 s64 值

描述

以原子方式使用释放排序将 v 设置为 i。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic64_set_release()。

返回

没有。

void atomic64_add(s64 i, atomic64_t *v)¶: 具有宽松排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic64_add()。

返回

没有。

s64 atomic64_add_return(s64 i, atomic64_t *v)¶: 具有完整排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic64_add_return()。

返回

v 的更新值。

s64 atomic64_add_return_acquire(s64 i, atomic64_t *v)¶: 具有获取排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic64_add_return_acquire()。

返回

v 的更新值。

s64 atomic64_add_return_release(s64 i, atomic64_t *v)¶: 具有释放排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic64_add_return_release()。

返回

v 的更新值。

s64 atomic64_add_return_relaxed(s64 i, atomic64_t *v)¶: 具有宽松排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic64_add_return_relaxed()。

返回

v 的更新值。

s64 atomic64_fetch_add(s64 i, atomic64_t *v)¶: 具有完整排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；在那里使用 raw_atomic64_fetch_add()。

返回

v 的原始值。

s64 atomic64_fetch_add_acquire(s64 i, atomic64_t *v)¶: 具有获取排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_fetch_add_acquire()。

返回

v 的原始值。

s64 atomic64_fetch_add_release(s64 i, atomic64_t *v)¶: 具有释放排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_fetch_add_release()。

返回

v 的原始值。

s64 atomic64_fetch_add_relaxed(s64 i, atomic64_t *v)¶: 具有宽松排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_fetch_add_relaxed()。

返回

v 的原始值。

void atomic64_sub(s64 i, atomic64_t *v)¶: 具有宽松排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_sub()。

返回

没有。

s64 atomic64_sub_return(s64 i, atomic64_t *v)¶: 具有完整排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_sub_return()。

返回

v 的更新值。

s64 atomic64_sub_return_acquire(s64 i, atomic64_t *v)¶: 具有获取排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_sub_return_acquire()。

返回

v 的更新值。

s64 atomic64_sub_return_release(s64 i, atomic64_t *v)¶: 具有释放排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_sub_return_release()。

返回

v 的更新值。

s64 atomic64_sub_return_relaxed(s64 i, atomic64_t *v)¶: 具有宽松排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_sub_return_relaxed()。

返回

v 的更新值。

s64 atomic64_fetch_sub(s64 i, atomic64_t *v)¶: 具有完整排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_fetch_sub()。

返回

v 的原始值。

s64 atomic64_fetch_sub_acquire(s64 i, atomic64_t *v)¶: 具有获取排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_fetch_sub_acquire()。

返回

v 的原始值。

s64 atomic64_fetch_sub_release(s64 i, atomic64_t *v)¶: 具有释放排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_fetch_sub_release()。

返回

v 的原始值。

s64 atomic64_fetch_sub_relaxed(s64 i, atomic64_t *v)¶: 具有宽松排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_fetch_sub_relaxed()。

返回

v 的原始值。

void atomic64_inc(atomic64_t *v)¶: 使用宽松排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_inc()。

返回

没有。

s64 atomic64_inc_return(atomic64_t *v)¶: 使用完整排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_inc_return()。

返回

v 的更新值。

s64 atomic64_inc_return_acquire(atomic64_t *v)¶: 使用获取排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用获取排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_inc_return_acquire()。

返回

v 的更新值。

s64 atomic64_inc_return_release(atomic64_t *v)¶: 使用释放排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用释放排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_inc_return_release()。

返回

v 的更新值。

s64 atomic64_inc_return_relaxed(atomic64_t *v)¶: 使用宽松排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_inc_return_relaxed()。

返回

v 的更新值。

s64 atomic64_fetch_inc(atomic64_t *v)¶: 使用完整排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_fetch_inc()。

返回

v 的原始值。

s64 atomic64_fetch_inc_acquire(atomic64_t *v)¶: 使用获取排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用获取排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_fetch_inc_acquire()。

返回

v 的原始值。

s64 atomic64_fetch_inc_release(atomic64_t *v)¶: 使用释放排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用释放排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_fetch_inc_release()。

返回

v 的原始值。

s64 atomic64_fetch_inc_relaxed(atomic64_t *v)¶: 使用宽松排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_fetch_inc_relaxed()。

返回

v 的原始值。

void atomic64_dec(atomic64_t *v)¶: 使用宽松排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_dec()。

返回

没有。

s64 atomic64_dec_return(atomic64_t *v)¶: 使用完整排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_dec_return()。

返回

v 的更新值。

s64 atomic64_dec_return_acquire(atomic64_t *v)¶: 使用获取排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用获取排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_dec_return_acquire()。

返回

v 的更新值。

s64 atomic64_dec_return_release(atomic64_t *v)¶: 使用释放排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用释放排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_dec_return_release()。

返回

v 的更新值。

s64 atomic64_dec_return_relaxed(atomic64_t *v)¶: 使用宽松排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_dec_return_relaxed()。

返回

v 的更新值。

s64 atomic64_fetch_dec(atomic64_t *v)¶: 使用完整排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_fetch_dec()。

返回

v 的原始值。

s64 atomic64_fetch_dec_acquire(atomic64_t *v)¶: 使用获取排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用获取排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_fetch_dec_acquire()。

返回

v 的原始值。

s64 atomic64_fetch_dec_release(atomic64_t *v)¶: 使用释放排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用释放排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_fetch_dec_release()。

返回

v 的原始值。

s64 atomic64_fetch_dec_relaxed(atomic64_t *v)¶: 使用宽松排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_fetch_dec_relaxed()。

返回

v 的原始值。

void atomic64_and(s64 i, atomic64_t *v)¶: 使用宽松排序的原子按位与

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_and()。

返回

没有。

s64 atomic64_fetch_and(s64 i, atomic64_t *v)¶: 使用完整排序的原子按位与

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

使用完整排序原子地更新 v 为 (v & i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_fetch_and()。

返回

v 的原始值。

s64 atomic64_fetch_and_acquire(s64 i, atomic64_t *v)¶: 使用获取排序的原子按位与

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

使用获取排序原子地更新 v 为 (v & i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_fetch_and_acquire()。

返回

v 的原始值。

s64 atomic64_fetch_and_release(s64 i, atomic64_t *v)¶: 使用释放排序的原子按位与

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

使用释放排序原子地更新 v 为 (v & i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_fetch_and_release()。

返回

v 的原始值。

s64 atomic64_fetch_and_relaxed(s64 i, atomic64_t *v)¶: 使用宽松排序的原子按位与

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_fetch_and_relaxed()。

返回

v 的原始值。

void atomic64_andnot(s64 i, atomic64_t *v)¶: 使用宽松排序的原子按位与非

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & ~i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_andnot()。

返回

没有。

s64 atomic64_fetch_andnot(s64 i, atomic64_t *v)¶: 使用完整排序的原子按位与非

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

使用完整排序原子地更新 v 为 (v & ~i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_fetch_andnot()。

返回

v 的原始值。

s64 atomic64_fetch_andnot_acquire(s64 i, atomic64_t *v)¶: 具有获取顺序的原子按位与非操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v & ~i)，并具有获取顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_fetch_andnot_acquire()。

返回

v 的原始值。

s64 atomic64_fetch_andnot_release(s64 i, atomic64_t *v)¶: 具有释放顺序的原子按位与非操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v & ~i)，并具有释放顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_fetch_andnot_release()。

返回

v 的原始值。

s64 atomic64_fetch_andnot_relaxed(s64 i, atomic64_t *v)¶: 使用宽松排序的原子按位与非

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & ~i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_fetch_andnot_relaxed()。

返回

v 的原始值。

void atomic64_or(s64 i, atomic64_t *v)¶: 具有宽松顺序的原子按位或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_or()。

返回

没有。

s64 atomic64_fetch_or(s64 i, atomic64_t *v)¶: 具有完整顺序的原子按位或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有完整顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_fetch_or()。

返回

v 的原始值。

s64 atomic64_fetch_or_acquire(s64 i, atomic64_t *v)¶: 具有获取顺序的原子按位或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有获取顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_fetch_or_acquire()。

返回

v 的原始值。

s64 atomic64_fetch_or_release(s64 i, atomic64_t *v)¶: 具有释放顺序的原子按位或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有释放顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_fetch_or_release()。

返回

v 的原始值。

s64 atomic64_fetch_or_relaxed(s64 i, atomic64_t *v)¶: 具有宽松顺序的原子按位或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_fetch_or_relaxed()。

返回

v 的原始值。

void atomic64_xor(s64 i, atomic64_t *v)¶: 具有宽松顺序的原子按位异或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_xor()。

返回

没有。

s64 atomic64_fetch_xor(s64 i, atomic64_t *v)¶: 具有完整顺序的原子按位异或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有完整顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_fetch_xor()。

返回

v 的原始值。

s64 atomic64_fetch_xor_acquire(s64 i, atomic64_t *v)¶: 具有获取顺序的原子按位异或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有获取顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_fetch_xor_acquire()。

返回

v 的原始值。

s64 atomic64_fetch_xor_release(s64 i, atomic64_t *v)¶: 具有释放顺序的原子按位异或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有释放顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_fetch_xor_release()。

返回

v 的原始值。

s64 atomic64_fetch_xor_relaxed(s64 i, atomic64_t *v)¶: 具有宽松顺序的原子按位异或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_fetch_xor_relaxed()。

返回

v 的原始值。

s64 atomic64_xchg(atomic64_t *v, s64 new)¶: 具有完整顺序的原子交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 new: 要分配的 s64 值

描述

以原子方式更新 v 为 new，并具有完整顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_xchg()。

返回

v 的原始值。

s64 atomic64_xchg_acquire(atomic64_t *v, s64 new)¶: 具有获取顺序的原子交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 new: 要分配的 s64 值

描述

以原子方式更新 v 为 new，并具有获取顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_xchg_acquire()。

返回

v 的原始值。

s64 atomic64_xchg_release(atomic64_t *v, s64 new)¶: 具有释放顺序的原子交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 new: 要分配的 s64 值

描述

以原子方式更新 v 为 new，并具有释放顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_xchg_release()。

返回

v 的原始值。

s64 atomic64_xchg_relaxed(atomic64_t *v, s64 new)¶: 具有宽松顺序的原子交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 new: 要分配的 s64 值

描述

以原子方式更新 v 为 new，并具有宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_xchg_relaxed()。

返回

v 的原始值。

s64 atomic64_cmpxchg(atomic64_t *v, s64 old, s64 new)¶: 具有完整顺序的原子比较和交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 old: 要比较的 s64 值
s64 new: 要分配的 s64 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有完整顺序。否则，v 不会被修改，并提供宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_cmpxchg()。

返回

v 的原始值。

s64 atomic64_cmpxchg_acquire(atomic64_t *v, s64 old, s64 new)¶: 具有获取顺序的原子比较和交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 old: 要比较的 s64 值
s64 new: 要分配的 s64 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有获取顺序。否则，v 不会被修改，并提供宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic64_cmpxchg_acquire()。

返回

v 的原始值。

s64 atomic64_cmpxchg_release(atomic64_t *v, s64 old, s64 new)¶: 具有释放顺序的原子比较和交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 old: 要比较的 s64 值
s64 new: 要分配的 s64 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有释放顺序。否则，v 不会被修改，并提供宽松顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_cmpxchg_release()。

返回

v 的原始值。

s64 atomic64_cmpxchg_relaxed(atomic64_t *v, s64 old, s64 new)¶: 具有宽松顺序的原子比较和交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 old: 要比较的 s64 值
s64 new: 要分配的 s64 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有宽松顺序。否则，v 不会被修改，并提供宽松顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_cmpxchg_relaxed()。

返回

v 的原始值。

bool atomic64_try_cmpxchg(atomic64_t *v, s64 *old, s64 new)¶: 具有完整顺序的原子比较和交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 *old: 与要比较的 s64 值的指针
s64 new: 要分配的 s64 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有完整顺序。否则，v 不会被修改， old 会更新为 v 的当前值，并提供宽松顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_try_cmpxchg()。

返回

如果发生交换，则为 true，否则为 false。

bool atomic64_try_cmpxchg_acquire(atomic64_t *v, s64 *old, s64 new)¶: 具有获取顺序的原子比较和交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 *old: 与要比较的 s64 值的指针
s64 new: 要分配的 s64 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有获取顺序。否则，v 不会被修改， old 会更新为 v 的当前值，并提供宽松顺序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_try_cmpxchg_acquire()。

返回

如果发生交换，则为 true，否则为 false。

bool atomic64_try_cmpxchg_release(atomic64_t *v, s64 *old, s64 new)¶: 具有释放顺序的原子比较和交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 *old: 与要比较的 s64 值的指针
s64 new: 要分配的 s64 值

描述

如果 (v == old)，则以原子方式使用 release ordering 将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供 relaxed ordering。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_try_cmpxchg_release()。

返回

如果发生交换，则为 true，否则为 false。

bool atomic64_try_cmpxchg_relaxed(atomic64_t *v, s64 *old, s64 new)¶: 具有宽松顺序的原子比较和交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 *old: 与要比较的 s64 值的指针
s64 new: 要分配的 s64 值

描述

如果 (v == old)，则以原子方式使用 relaxed ordering 将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供 relaxed ordering。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_try_cmpxchg_relaxed()。

返回

如果发生交换，则为 true，否则为 false。

bool atomic64_sub_and_test(s64 i, atomic64_t *v)¶: 原子减法并测试是否为零，使用 full ordering

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_sub_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool atomic64_dec_and_test(atomic64_t *v)¶: 原子递减并测试是否为零，使用 full ordering

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_dec_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool atomic64_inc_and_test(atomic64_t *v)¶: 原子递增并测试是否为零，使用 full ordering

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_inc_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool atomic64_add_negative(s64 i, atomic64_t *v)¶: 原子加法并测试是否为负数，使用 full ordering

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_add_negative()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool atomic64_add_negative_acquire(s64 i, atomic64_t *v)¶: 原子加法并测试是否为负数，使用 acquire ordering

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_add_negative_acquire()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool atomic64_add_negative_release(s64 i, atomic64_t *v)¶: 原子加法并测试是否为负数，使用 release ordering

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_add_negative_release()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool atomic64_add_negative_relaxed(s64 i, atomic64_t *v)¶: 原子加法并测试是否为负数，使用 relaxed ordering

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_add_negative_relaxed()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

s64 atomic64_fetch_add_unless(atomic64_t *v, s64 a, s64 u)¶: 原子加法，除非值为 full ordering

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 a: 要添加的 s64 值
s64 u: 要比较的 s64 值

描述

如果 (v != u)，则以原子方式使用 full ordering 将 v 更新为 (v + a)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_fetch_add_unless()。

返回

v 的原始值。

bool atomic64_add_unless(atomic64_t *v, s64 a, s64 u)¶: 原子加法，除非值为 full ordering

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 a: 要添加的 s64 值
s64 u: 要比较的 s64 值

描述

如果 (v != u)，则以原子方式使用 full ordering 将 v 更新为 (v + a)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_add_unless()。

返回

如果 v 已更新，则为 true，否则为 false。

bool atomic64_inc_not_zero(atomic64_t *v)¶: 原子递增，除非为零，使用 full ordering

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

如果 (v != 0)，则以原子方式使用 full ordering 将 v 更新为 (v + 1)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_inc_not_zero()。

返回

如果 v 已更新，则为 true，否则为 false。

bool atomic64_inc_unless_negative(atomic64_t *v)¶: 原子递增，除非为负数，使用 full ordering

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

如果 (v >= 0)，则以原子方式使用 full ordering 将 v 更新为 (v + 1)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_inc_unless_negative()。

返回

如果 v 已更新，则为 true，否则为 false。

bool atomic64_dec_unless_positive(atomic64_t *v)¶: 原子递减，除非为正数，使用 full ordering

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

如果 (v <= 0)，则以原子方式使用 full ordering 将 v 更新为 (v - 1)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_dec_unless_positive()。

返回

如果 v 已更新，则为 true，否则为 false。

s64 atomic64_dec_if_positive(atomic64_t *v)¶: 原子递减（如果为正数），使用 full ordering

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

如果 (v > 0)，则以原子方式使用 full ordering 将 v 更新为 (v - 1)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic64_dec_if_positive()。

返回

(v - 1) 的旧值，无论 v 是否已更新。

long atomic_long_read(const atomic_long_t *v)¶: 具有宽松排序的原子加载

参数

const atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用宽松排序加载 v 的值。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_read()。

返回

从 v 加载的值。

long atomic_long_read_acquire(const atomic_long_t *v)¶: 具有获取排序的原子加载

参数

const atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用获取排序加载 v 的值。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_read_acquire()。

返回

从 v 加载的值。

void atomic_long_set(atomic_long_t *v, long i)¶: 具有宽松排序的原子设置

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long i: 要分配的 long 值

描述

以原子方式使用宽松排序将 v 设置为 i。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_set()。

返回

没有。

void atomic_long_set_release(atomic_long_t *v, long i)¶: 具有释放排序的原子设置

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long i: 要分配的 long 值

描述

以原子方式使用释放排序将 v 设置为 i。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_set_release()。

返回

没有。

void atomic_long_add(long i, atomic_long_t *v)¶: 具有宽松排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_add()。

返回

没有。

long atomic_long_add_return(long i, atomic_long_t *v)¶: 具有完整排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_add_return()。

返回

v 的更新值。

long atomic_long_add_return_acquire(long i, atomic_long_t *v)¶: 具有获取排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_add_return_acquire()。

返回

v 的更新值。

long atomic_long_add_return_release(long i, atomic_long_t *v)¶: 具有释放排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_add_return_release()。

返回

v 的更新值。

long atomic_long_add_return_relaxed(long i, atomic_long_t *v)¶: 具有宽松排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_add_return_relaxed()。

返回

v 的更新值。

long atomic_long_fetch_add(long i, atomic_long_t *v)¶: 具有完整排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_add()。

返回

v 的原始值。

long atomic_long_fetch_add_acquire(long i, atomic_long_t *v)¶: 具有获取排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_add_acquire()。

返回

v 的原始值。

long atomic_long_fetch_add_release(long i, atomic_long_t *v)¶: 具有释放排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_add_release()。

返回

v 的原始值。

long atomic_long_fetch_add_relaxed(long i, atomic_long_t *v)¶: 具有宽松排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_add_relaxed()。

返回

v 的原始值。

void atomic_long_sub(long i, atomic_long_t *v)¶: 具有宽松排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_sub()。

返回

没有。

long atomic_long_sub_return(long i, atomic_long_t *v)¶: 具有完整排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_sub_return()。

返回

v 的更新值。

long atomic_long_sub_return_acquire(long i, atomic_long_t *v)¶: 具有获取排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_sub_return_acquire()。

返回

v 的更新值。

long atomic_long_sub_return_release(long i, atomic_long_t *v)¶: 具有释放排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_sub_return_release()。

返回

v 的更新值。

long atomic_long_sub_return_relaxed(long i, atomic_long_t *v)¶: 具有宽松排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_sub_return_relaxed()。

返回

v 的更新值。

long atomic_long_fetch_sub(long i, atomic_long_t *v)¶: 具有完整排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_sub()。

返回

v 的原始值。

long atomic_long_fetch_sub_acquire(long i, atomic_long_t *v)¶: 具有获取排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_sub_acquire()。

返回

v 的原始值。

long atomic_long_fetch_sub_release(long i, atomic_long_t *v)¶: 具有释放排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_sub_release()。

返回

v 的原始值。

long atomic_long_fetch_sub_relaxed(long i, atomic_long_t *v)¶: 具有宽松排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_sub_relaxed()。

返回

v 的原始值。

void atomic_long_inc(atomic_long_t *v)¶: 使用宽松排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_inc()。

返回

没有。

long atomic_long_inc_return(atomic_long_t *v)¶: 使用完整排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_inc_return()。

返回

v 的更新值。

long atomic_long_inc_return_acquire(atomic_long_t *v)¶: 使用获取排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用获取排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_inc_return_acquire()。

返回

v 的更新值。

long atomic_long_inc_return_release(atomic_long_t *v)¶: 使用释放排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用释放排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_inc_return_release()。

返回

v 的更新值。

long atomic_long_inc_return_relaxed(atomic_long_t *v)¶: 使用宽松排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_inc_return_relaxed()。

返回

v 的更新值。

long atomic_long_fetch_inc(atomic_long_t *v)¶: 使用完整排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_inc()。

返回

v 的原始值。

long atomic_long_fetch_inc_acquire(atomic_long_t *v)¶: 使用获取排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用获取排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_inc_acquire()。

返回

v 的原始值。

long atomic_long_fetch_inc_release(atomic_long_t *v)¶: 使用释放排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用释放排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_inc_release()。

返回

v 的原始值。

long atomic_long_fetch_inc_relaxed(atomic_long_t *v)¶: 使用宽松排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_inc_relaxed()。

返回

v 的原始值。

void atomic_long_dec(atomic_long_t *v)¶: 使用宽松排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_dec()。

返回

没有。

long atomic_long_dec_return(atomic_long_t *v)¶: 使用完整排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_dec_return()。

返回

v 的更新值。

long atomic_long_dec_return_acquire(atomic_long_t *v)¶: 使用获取排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用获取排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_dec_return_acquire()。

返回

v 的更新值。

long atomic_long_dec_return_release(atomic_long_t *v)¶: 使用释放排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用释放排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_dec_return_release()。

返回

v 的更新值。

long atomic_long_dec_return_relaxed(atomic_long_t *v)¶: 使用宽松排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_dec_return_relaxed()。

返回

v 的更新值。

long atomic_long_fetch_dec(atomic_long_t *v)¶: 使用完整排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_dec()。

返回

v 的原始值。

long atomic_long_fetch_dec_acquire(atomic_long_t *v)¶: 使用获取排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用获取排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_dec_acquire()。

返回

v 的原始值。

long atomic_long_fetch_dec_release(atomic_long_t *v)¶: 使用释放排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用释放排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_dec_release()。

返回

v 的原始值。

long atomic_long_fetch_dec_relaxed(atomic_long_t *v)¶: 使用宽松排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_dec_relaxed()。

返回

v 的原始值。

void atomic_long_and(long i, atomic_long_t *v)¶: 使用宽松排序的原子按位与

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_and()。

返回

没有。

long atomic_long_fetch_and(long i, atomic_long_t *v)¶: 使用完整排序的原子按位与

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用完整排序原子地更新 v 为 (v & i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_and()。

返回

v 的原始值。

long atomic_long_fetch_and_acquire(long i, atomic_long_t *v)¶: 使用获取排序的原子按位与

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用获取排序原子地更新 v 为 (v & i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_and_acquire()。

返回

v 的原始值。

long atomic_long_fetch_and_release(long i, atomic_long_t *v)¶: 使用释放排序的原子按位与

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用释放排序原子地更新 v 为 (v & i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_and_release()。

返回

v 的原始值。

long atomic_long_fetch_and_relaxed(long i, atomic_long_t *v)¶: 使用宽松排序的原子按位与

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_and_relaxed()。

返回

v 的原始值。

void atomic_long_andnot(long i, atomic_long_t *v)¶: 使用宽松排序的原子按位与非

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & ~i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_andnot()。

返回

没有。

long atomic_long_fetch_andnot(long i, atomic_long_t *v)¶: 使用完整排序的原子按位与非

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用完整排序原子地更新 v 为 (v & ~i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_andnot()。

返回

v 的原始值。

long atomic_long_fetch_andnot_acquire(long i, atomic_long_t *v)¶: 具有获取顺序的原子按位与非操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v & ~i)，并具有获取顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_andnot_acquire()。

返回

v 的原始值。

long atomic_long_fetch_andnot_release(long i, atomic_long_t *v)¶: 具有释放顺序的原子按位与非操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v & ~i)，并具有释放顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_andnot_release()。

返回

v 的原始值。

long atomic_long_fetch_andnot_relaxed(long i, atomic_long_t *v)¶: 使用宽松排序的原子按位与非

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & ~i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_andnot_relaxed()。

返回

v 的原始值。

void atomic_long_or(long i, atomic_long_t *v)¶: 具有宽松顺序的原子按位或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_or()。

返回

没有。

long atomic_long_fetch_or(long i, atomic_long_t *v)¶: 具有完整顺序的原子按位或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有完整顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_or()。

返回

v 的原始值。

long atomic_long_fetch_or_acquire(long i, atomic_long_t *v)¶: 具有获取顺序的原子按位或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有获取顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_or_acquire()。

返回

v 的原始值。

long atomic_long_fetch_or_release(long i, atomic_long_t *v)¶: 具有释放顺序的原子按位或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有释放顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_or_release()。

返回

v 的原始值。

long atomic_long_fetch_or_relaxed(long i, atomic_long_t *v)¶: 具有宽松顺序的原子按位或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_or_relaxed()。

返回

v 的原始值。

void atomic_long_xor(long i, atomic_long_t *v)¶: 具有宽松顺序的原子按位异或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_xor()。

返回

没有。

long atomic_long_fetch_xor(long i, atomic_long_t *v)¶: 具有完整顺序的原子按位异或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有完整顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_xor()。

返回

v 的原始值。

long atomic_long_fetch_xor_acquire(long i, atomic_long_t *v)¶: 具有获取顺序的原子按位异或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有获取顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_xor_acquire()。

返回

v 的原始值。

long atomic_long_fetch_xor_release(long i, atomic_long_t *v)¶: 具有释放顺序的原子按位异或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有释放顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_xor_release()。

返回

v 的原始值。

long atomic_long_fetch_xor_relaxed(long i, atomic_long_t *v)¶: 具有宽松顺序的原子按位异或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_xor_relaxed()。

返回

v 的原始值。

long atomic_long_xchg(atomic_long_t *v, long new)¶: 具有完整顺序的原子交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long new: 要分配的 long 值

描述

以原子方式更新 v 为 new，并具有完整顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_xchg()。

返回

v 的原始值。

long atomic_long_xchg_acquire(atomic_long_t *v, long new)¶: 具有获取顺序的原子交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long new: 要分配的 long 值

描述

以原子方式更新 v 为 new，并具有获取顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_xchg_acquire()。

返回

v 的原始值。

long atomic_long_xchg_release(atomic_long_t *v, long new)¶: 具有释放顺序的原子交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long new: 要分配的 long 值

描述

以原子方式更新 v 为 new，并具有释放顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_xchg_release()。

返回

v 的原始值。

long atomic_long_xchg_relaxed(atomic_long_t *v, long new)¶: 具有宽松顺序的原子交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long new: 要分配的 long 值

描述

以原子方式更新 v 为 new，并具有宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_xchg_relaxed()。

返回

v 的原始值。

long atomic_long_cmpxchg(atomic_long_t *v, long old, long new)¶: 具有完整顺序的原子比较和交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long old: 要比较的 long 值
long new: 要分配的 long 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有完整顺序。否则，v 不会被修改，并提供宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_cmpxchg()。

返回

v 的原始值。

long atomic_long_cmpxchg_acquire(atomic_long_t *v, long old, long new)¶: 具有获取顺序的原子比较和交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long old: 要比较的 long 值
long new: 要分配的 long 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有获取顺序。否则，v 不会被修改，并提供宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_cmpxchg_acquire()。

返回

v 的原始值。

long atomic_long_cmpxchg_release(atomic_long_t *v, long old, long new)¶: 具有释放顺序的原子比较和交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long old: 要比较的 long 值
long new: 要分配的 long 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有释放顺序。否则，v 不会被修改，并提供宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_cmpxchg_release()。

返回

v 的原始值。

long atomic_long_cmpxchg_relaxed(atomic_long_t *v, long old, long new)¶: 具有宽松顺序的原子比较和交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long old: 要比较的 long 值
long new: 要分配的 long 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有宽松顺序。否则，v 不会被修改，并提供宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_cmpxchg_relaxed()。

返回

v 的原始值。

bool atomic_long_try_cmpxchg(atomic_long_t *v, long *old, long new)¶: 具有完整顺序的原子比较和交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long *old: 与要比较的 long 值对应的指针
long new: 要分配的 long 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有完整顺序。否则，v 不会被修改， old 会更新为 v 的当前值，并提供宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_try_cmpxchg()。

返回

如果发生交换，则为 true，否则为 false。

bool atomic_long_try_cmpxchg_acquire(atomic_long_t *v, long *old, long new)¶: 具有获取顺序的原子比较和交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long *old: 与要比较的 long 值对应的指针
long new: 要分配的 long 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有获取顺序。否则，v 不会被修改， old 会更新为 v 的当前值，并提供宽松顺序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_try_cmpxchg_acquire()。

返回

如果发生交换，则为 true，否则为 false。

bool atomic_long_try_cmpxchg_release(atomic_long_t *v, long *old, long new)¶: 具有释放顺序的原子比较和交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long *old: 与要比较的 long 值对应的指针
long new: 要分配的 long 值

描述

如果 (v == old)，则以原子方式使用 release ordering 将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供 relaxed ordering。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_try_cmpxchg_release()。

返回

如果发生交换，则为 true，否则为 false。

bool atomic_long_try_cmpxchg_relaxed(atomic_long_t *v, long *old, long new)¶: 具有宽松顺序的原子比较和交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long *old: 与要比较的 long 值对应的指针
long new: 要分配的 long 值

描述

如果 (v == old)，则以原子方式使用 relaxed ordering 将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供 relaxed ordering。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_try_cmpxchg_relaxed()。

返回

如果发生交换，则为 true，否则为 false。

bool atomic_long_sub_and_test(long i, atomic_long_t *v)¶: 原子减法并测试是否为零，使用 full ordering

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_sub_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool atomic_long_dec_and_test(atomic_long_t *v)¶: 原子递减并测试是否为零，使用 full ordering

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_dec_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool atomic_long_inc_and_test(atomic_long_t *v)¶: 原子递增并测试是否为零，使用 full ordering

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_inc_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool atomic_long_add_negative(long i, atomic_long_t *v)¶: 原子加法并测试是否为负数，使用 full ordering

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_add_negative()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool atomic_long_add_negative_acquire(long i, atomic_long_t *v)¶: 原子加法并测试是否为负数，使用 acquire ordering

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_add_negative_acquire()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool atomic_long_add_negative_release(long i, atomic_long_t *v)¶: 原子加法并测试是否为负数，使用 release ordering

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_add_negative_release()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool atomic_long_add_negative_relaxed(long i, atomic_long_t *v)¶: 原子加法并测试是否为负数，使用 relaxed ordering

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_add_negative_relaxed()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

long atomic_long_fetch_add_unless(atomic_long_t *v, long a, long u)¶: 原子加法，除非值为 full ordering

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long a: 要添加的 long 值
long u: 要比较的 long 值

描述

如果 (v != u)，则以原子方式使用 full ordering 将 v 更新为 (v + a)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_fetch_add_unless()。

返回

v 的原始值。

bool atomic_long_add_unless(atomic_long_t *v, long a, long u)¶: 原子加法，除非值为 full ordering

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long a: 要添加的 long 值
long u: 要比较的 long 值

描述

如果 (v != u)，则以原子方式使用 full ordering 将 v 更新为 (v + a)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_add_unless()。

返回

如果 v 已更新，则为 true，否则为 false。

bool atomic_long_inc_not_zero(atomic_long_t *v)¶: 原子递增，除非为零，使用 full ordering

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

如果 (v != 0)，则以原子方式使用 full ordering 将 v 更新为 (v + 1)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_inc_not_zero()。

返回

如果 v 已更新，则为 true，否则为 false。

bool atomic_long_inc_unless_negative(atomic_long_t *v)¶: 原子递增，除非为负数，使用 full ordering

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

如果 (v >= 0)，则以原子方式使用 full ordering 将 v 更新为 (v + 1)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_inc_unless_negative()。

返回

如果 v 已更新，则为 true，否则为 false。

bool atomic_long_dec_unless_positive(atomic_long_t *v)¶: 原子递减，除非为正数，使用 full ordering

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

如果 (v <= 0)，则以原子方式使用 full ordering 将 v 更新为 (v - 1)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_dec_unless_positive()。

返回

如果 v 已更新，则为 true，否则为 false。

long atomic_long_dec_if_positive(atomic_long_t *v)¶: 原子递减（如果为正数），使用 full ordering

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

如果 (v > 0)，则以原子方式使用 full ordering 将 v 更新为 (v - 1)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_dec_if_positive()。

返回

(v - 1) 的旧值，无论 v 是否已更新。

int raw_atomic_read(const atomic_t *v)¶: 具有宽松排序的原子加载

参数

const atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用宽松排序加载 v 的值。

在 noinstr 代码中使用安全；其他地方首选 atomic_read()。

返回

从 v 加载的值。

int raw_atomic_read_acquire(const atomic_t *v)¶: 具有获取排序的原子加载

参数

const atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用获取排序加载 v 的值。

在 noinstr 代码中使用安全；其他地方首选 atomic_read_acquire()。

返回

从 v 加载的值。

void raw_atomic_set(atomic_t *v, int i)¶: 具有宽松排序的原子设置

参数

atomic_t *v: 指向 atomic_t 的指针
int i: 要分配的 int 值

描述

以原子方式使用宽松排序将 v 设置为 i。

在 noinstr 代码中使用安全；其他地方首选 atomic_set()。

返回

没有。

void raw_atomic_set_release(atomic_t *v, int i)¶: 具有释放排序的原子设置

参数

atomic_t *v: 指向 atomic_t 的指针
int i: 要分配的 int 值

描述

以原子方式使用释放排序将 v 设置为 i。

在 noinstr 代码中使用安全；其他地方首选 atomic_set_release()。

返回

没有。

void raw_atomic_add(int i, atomic_t *v)¶: 具有宽松排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

在 noinstr 代码中使用安全；其他地方首选 atomic_add()。

返回

没有。

int raw_atomic_add_return(int i, atomic_t *v)¶: 具有完整排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

在 noinstr 代码中使用安全；其他地方首选 atomic_add_return()。

返回

v 的更新值。

int raw_atomic_add_return_acquire(int i, atomic_t *v)¶: 具有获取排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

在 noinstr 代码中使用安全；其他地方首选 atomic_add_return_acquire()。

返回

v 的更新值。

int raw_atomic_add_return_release(int i, atomic_t *v)¶: 具有释放排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_add_return_release()。

返回

v 的更新值。

int raw_atomic_add_return_relaxed(int i, atomic_t *v)¶: 具有宽松排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_add_return_relaxed()。

返回

v 的更新值。

int raw_atomic_fetch_add(int i, atomic_t *v)¶: 具有完整排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_fetch_add()。

返回

v 的原始值。

int raw_atomic_fetch_add_acquire(int i, atomic_t *v)¶: 具有获取排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_fetch_add_acquire()。

返回

v 的原始值。

int raw_atomic_fetch_add_release(int i, atomic_t *v)¶: 具有释放排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_fetch_add_release()。

返回

v 的原始值。

int raw_atomic_fetch_add_relaxed(int i, atomic_t *v)¶: 具有宽松排序的原子加法

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_fetch_add_relaxed()。

返回

v 的原始值。

void raw_atomic_sub(int i, atomic_t *v)¶: 具有宽松排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_sub()。

返回

没有。

int raw_atomic_sub_return(int i, atomic_t *v)¶: 具有完整排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_sub_return()。

返回

v 的更新值。

int raw_atomic_sub_return_acquire(int i, atomic_t *v)¶: 具有获取排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v - i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_sub_return_acquire()。

返回

v 的更新值。

int raw_atomic_sub_return_release(int i, atomic_t *v)¶: 具有释放排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v - i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_sub_return_release()。

返回

v 的更新值。

int raw_atomic_sub_return_relaxed(int i, atomic_t *v)¶: 具有宽松排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_sub_return_relaxed()。

返回

v 的更新值。

int raw_atomic_fetch_sub(int i, atomic_t *v)¶: 具有完整排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_fetch_sub()。

返回

v 的原始值。

int raw_atomic_fetch_sub_acquire(int i, atomic_t *v)¶: 具有获取排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v - i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_fetch_sub_acquire()。

返回

v 的原始值。

int raw_atomic_fetch_sub_release(int i, atomic_t *v)¶: 具有释放排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v - i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_fetch_sub_release()。

返回

v 的原始值。

int raw_atomic_fetch_sub_relaxed(int i, atomic_t *v)¶: 具有宽松排序的原子减法

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_fetch_sub_relaxed()。

返回

v 的原始值。

void raw_atomic_inc(atomic_t *v)¶: 使用宽松排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_inc()。

返回

没有。

int raw_atomic_inc_return(atomic_t *v)¶: 使用完整排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_inc_return()。

返回

v 的更新值。

int raw_atomic_inc_return_acquire(atomic_t *v)¶: 使用获取排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用获取排序原子地更新 v 为 (v + 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_inc_return_acquire()。

返回

v 的更新值。

int raw_atomic_inc_return_release(atomic_t *v)¶: 使用释放排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用释放排序原子地更新 v 为 (v + 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_inc_return_release()。

返回

v 的更新值。

int raw_atomic_inc_return_relaxed(atomic_t *v)¶: 使用宽松排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_inc_return_relaxed()。

返回

v 的更新值。

int raw_atomic_fetch_inc(atomic_t *v)¶: 使用完整排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_fetch_inc()。

返回

v 的原始值。

int raw_atomic_fetch_inc_acquire(atomic_t *v)¶: 使用获取排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用获取排序原子地更新 v 为 (v + 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_fetch_inc_acquire()。

返回

v 的原始值。

int raw_atomic_fetch_inc_release(atomic_t *v)¶: 使用释放排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用释放排序原子地更新 v 为 (v + 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_fetch_inc_release()。

返回

v 的原始值。

int raw_atomic_fetch_inc_relaxed(atomic_t *v)¶: 使用宽松排序的原子自增

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_fetch_inc_relaxed()。

返回

v 的原始值。

void raw_atomic_dec(atomic_t *v)¶: 使用宽松排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_dec()。

返回

没有。

int raw_atomic_dec_return(atomic_t *v)¶: 使用完整排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_dec_return()。

返回

v 的更新值。

int raw_atomic_dec_return_acquire(atomic_t *v)¶: 使用获取排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用获取排序原子地更新 v 为 (v - 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_dec_return_acquire()。

返回

v 的更新值。

int raw_atomic_dec_return_release(atomic_t *v)¶: 使用释放排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用释放排序原子地更新 v 为 (v - 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_dec_return_release()。

返回

v 的更新值。

int raw_atomic_dec_return_relaxed(atomic_t *v)¶: 使用宽松排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_dec_return_relaxed()。

返回

v 的更新值。

int raw_atomic_fetch_dec(atomic_t *v)¶: 使用完整排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_fetch_dec()。

返回

v 的原始值。

int raw_atomic_fetch_dec_acquire(atomic_t *v)¶: 使用获取排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用获取排序原子地更新 v 为 (v - 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_fetch_dec_acquire()。

返回

v 的原始值。

int raw_atomic_fetch_dec_release(atomic_t *v)¶: 使用释放排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用释放排序原子地更新 v 为 (v - 1)。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_dec_release()。

返回

v 的原始值。

int raw_atomic_fetch_dec_relaxed(atomic_t *v)¶: 使用宽松排序的原子自减

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_dec_relaxed()。

返回

v 的原始值。

void raw_atomic_and(int i, atomic_t *v)¶: 使用宽松排序的原子按位与

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & i)。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_and()。

返回

没有。

int raw_atomic_fetch_and(int i, atomic_t *v)¶: 使用完整排序的原子按位与

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

使用完整排序原子地更新 v 为 (v & i)。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_and()。

返回

v 的原始值。

int raw_atomic_fetch_and_acquire(int i, atomic_t *v)¶: 使用获取排序的原子按位与

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

使用获取排序原子地更新 v 为 (v & i)。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_and_acquire()。

返回

v 的原始值。

int raw_atomic_fetch_and_release(int i, atomic_t *v)¶: 使用释放排序的原子按位与

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

使用释放排序原子地更新 v 为 (v & i)。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_and_release()。

返回

v 的原始值。

int raw_atomic_fetch_and_relaxed(int i, atomic_t *v)¶: 使用宽松排序的原子按位与

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & i)。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_and_relaxed()。

返回

v 的原始值。

void raw_atomic_andnot(int i, atomic_t *v)¶: 使用宽松排序的原子按位与非

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & ~i)。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_andnot()。

返回

没有。

int raw_atomic_fetch_andnot(int i, atomic_t *v)¶: 使用完整排序的原子按位与非

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

使用完整排序原子地更新 v 为 (v & ~i)。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_andnot()。

返回

v 的原始值。

int raw_atomic_fetch_andnot_acquire(int i, atomic_t *v)¶: 具有获取顺序的原子按位与非操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v & ~i)，并具有获取顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_andnot_acquire()。

返回

v 的原始值。

int raw_atomic_fetch_andnot_release(int i, atomic_t *v)¶: 具有释放顺序的原子按位与非操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v & ~i)，并具有释放顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_andnot_release()。

返回

v 的原始值。

int raw_atomic_fetch_andnot_relaxed(int i, atomic_t *v)¶: 使用宽松排序的原子按位与非

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & ~i)。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_andnot_relaxed()。

返回

v 的原始值。

void raw_atomic_or(int i, atomic_t *v)¶: 具有宽松顺序的原子按位或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有宽松顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_or()。

返回

没有。

int raw_atomic_fetch_or(int i, atomic_t *v)¶: 具有完整顺序的原子按位或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有完整顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_or()。

返回

v 的原始值。

int raw_atomic_fetch_or_acquire(int i, atomic_t *v)¶: 具有获取顺序的原子按位或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有获取顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_or_acquire()。

返回

v 的原始值。

int raw_atomic_fetch_or_release(int i, atomic_t *v)¶: 具有释放顺序的原子按位或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有释放顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_or_release()。

返回

v 的原始值。

int raw_atomic_fetch_or_relaxed(int i, atomic_t *v)¶: 具有宽松顺序的原子按位或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有宽松顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_or_relaxed()。

返回

v 的原始值。

void raw_atomic_xor(int i, atomic_t *v)¶: 具有宽松顺序的原子按位异或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有宽松顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_xor()。

返回

没有。

int raw_atomic_fetch_xor(int i, atomic_t *v)¶: 具有完整顺序的原子按位异或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有完整顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_xor()。

返回

v 的原始值。

int raw_atomic_fetch_xor_acquire(int i, atomic_t *v)¶: 具有获取顺序的原子按位异或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有获取顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_xor_acquire()。

返回

v 的原始值。

int raw_atomic_fetch_xor_release(int i, atomic_t *v)¶: 具有释放顺序的原子按位异或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有释放顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_xor_release()。

返回

v 的原始值。

int raw_atomic_fetch_xor_relaxed(int i, atomic_t *v)¶: 具有宽松顺序的原子按位异或操作

参数

int i: int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有宽松顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_fetch_xor_relaxed()。

返回

v 的原始值。

int raw_atomic_xchg(atomic_t *v, int new)¶: 具有完整顺序的原子交换

参数

atomic_t *v: 指向 atomic_t 的指针
int new: 要分配的 int 值

描述

以原子方式更新 v 为 new，并具有完整顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_xchg()。

返回

v 的原始值。

int raw_atomic_xchg_acquire(atomic_t *v, int new)¶: 具有获取顺序的原子交换

参数

atomic_t *v: 指向 atomic_t 的指针
int new: 要分配的 int 值

描述

以原子方式更新 v 为 new，并具有获取顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_xchg_acquire()。

返回

v 的原始值。

int raw_atomic_xchg_release(atomic_t *v, int new)¶: 具有释放顺序的原子交换

参数

atomic_t *v: 指向 atomic_t 的指针
int new: 要分配的 int 值

描述

以原子方式更新 v 为 new，并具有释放顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_xchg_release()。

返回

v 的原始值。

int raw_atomic_xchg_relaxed(atomic_t *v, int new)¶: 具有宽松顺序的原子交换

参数

atomic_t *v: 指向 atomic_t 的指针
int new: 要分配的 int 值

描述

以原子方式更新 v 为 new，并具有宽松顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_xchg_relaxed()。

返回

v 的原始值。

int raw_atomic_cmpxchg(atomic_t *v, int old, int new)¶: 具有完整顺序的原子比较和交换

参数

atomic_t *v: 指向 atomic_t 的指针
int old: 用于比较的整数值
int new: 要分配的 int 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有完整顺序。否则，v 不会被修改，并提供宽松顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_cmpxchg()。

返回

v 的原始值。

int raw_atomic_cmpxchg_acquire(atomic_t *v, int old, int new)¶: 具有获取顺序的原子比较和交换

参数

atomic_t *v: 指向 atomic_t 的指针
int old: 用于比较的整数值
int new: 要分配的 int 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有获取顺序。否则，v 不会被修改，并提供宽松顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_cmpxchg_acquire()。

返回

v 的原始值。

int raw_atomic_cmpxchg_release(atomic_t *v, int old, int new)¶: 具有释放顺序的原子比较和交换

参数

atomic_t *v: 指向 atomic_t 的指针
int old: 用于比较的整数值
int new: 要分配的 int 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有释放顺序。否则，v 不会被修改，并提供宽松顺序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_cmpxchg_release()。

返回

v 的原始值。

int raw_atomic_cmpxchg_relaxed(atomic_t *v, int old, int new)¶: 具有宽松顺序的原子比较和交换

参数

atomic_t *v: 指向 atomic_t 的指针
int old: 用于比较的整数值
int new: 要分配的 int 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有宽松顺序。否则，v 不会被修改，并提供宽松顺序。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_cmpxchg_relaxed()。

返回

v 的原始值。

bool raw_atomic_try_cmpxchg(atomic_t *v, int *old, int new)¶: 具有完整顺序的原子比较和交换

参数

atomic_t *v: 指向 atomic_t 的指针
int *old: 指向用于比较的整数值的指针
int new: 要分配的 int 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有完整顺序。否则，v 不会被修改， old 会更新为 v 的当前值，并提供宽松顺序。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_try_cmpxchg()。

返回

如果发生交换，则为 true，否则为 false。

bool raw_atomic_try_cmpxchg_acquire(atomic_t *v, int *old, int new)¶: 具有获取顺序的原子比较和交换

参数

atomic_t *v: 指向 atomic_t 的指针
int *old: 指向用于比较的整数值的指针
int new: 要分配的 int 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有获取顺序。否则，v 不会被修改， old 会更新为 v 的当前值，并提供宽松顺序。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_try_cmpxchg_acquire()。

返回

如果发生交换，则为 true，否则为 false。

bool raw_atomic_try_cmpxchg_release(atomic_t *v, int *old, int new)¶: 具有释放顺序的原子比较和交换

参数

atomic_t *v: 指向 atomic_t 的指针
int *old: 指向用于比较的整数值的指针
int new: 要分配的 int 值

描述

如果 (v == old)，则以原子方式使用 release ordering 将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供 relaxed ordering。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_try_cmpxchg_release()。

返回

如果发生交换，则为 true，否则为 false。

bool raw_atomic_try_cmpxchg_relaxed(atomic_t *v, int *old, int new)¶: 具有宽松顺序的原子比较和交换

参数

atomic_t *v: 指向 atomic_t 的指针
int *old: 指向用于比较的整数值的指针
int new: 要分配的 int 值

描述

如果 (v == old)，则以原子方式使用 relaxed ordering 将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供 relaxed ordering。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_try_cmpxchg_relaxed()。

返回

如果发生交换，则为 true，否则为 false。

bool raw_atomic_sub_and_test(int i, atomic_t *v)¶: 原子减法并测试是否为零，使用 full ordering

参数

int i: 要减去的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_sub_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool raw_atomic_dec_and_test(atomic_t *v)¶: 原子递减并测试是否为零，使用 full ordering

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_dec_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool raw_atomic_inc_and_test(atomic_t *v)¶: 原子递增并测试是否为零，使用 full ordering

参数

atomic_t *v: 指向 atomic_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_inc_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool raw_atomic_add_negative(int i, atomic_t *v)¶: 原子加法并测试是否为负数，使用 full ordering

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_add_negative()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool raw_atomic_add_negative_acquire(int i, atomic_t *v)¶: 原子加法并测试是否为负数，使用 acquire ordering

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_add_negative_acquire()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool raw_atomic_add_negative_release(int i, atomic_t *v)¶: 原子加法并测试是否为负数，使用 release ordering

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_add_negative_release()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool raw_atomic_add_negative_relaxed(int i, atomic_t *v)¶: 原子加法并测试是否为负数，使用 relaxed ordering

参数

int i: 要添加的 int 值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_add_negative_relaxed()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

int raw_atomic_fetch_add_unless(atomic_t *v, int a, int u)¶: 原子加法，除非值为 full ordering

参数

atomic_t *v: 指向 atomic_t 的指针
int a: 要添加的 int 值
int u: 用于比较的整数值

描述

如果 (v != u)，则以原子方式使用 full ordering 将 v 更新为 (v + a)。否则，v 不会被修改，并提供 relaxed ordering。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_fetch_add_unless()。

返回

v 的原始值。

bool raw_atomic_add_unless(atomic_t *v, int a, int u)¶: 原子加法，除非值为 full ordering

参数

atomic_t *v: 指向 atomic_t 的指针
int a: 要添加的 int 值
int u: 用于比较的整数值

描述

如果 (v != u)，则以原子方式使用 full ordering 将 v 更新为 (v + a)。否则，v 不会被修改，并提供 relaxed ordering。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_add_unless()。

返回

如果 v 已更新，则为 true，否则为 false。

bool raw_atomic_inc_not_zero(atomic_t *v)¶: 原子递增，除非为零，使用 full ordering

参数

atomic_t *v: 指向 atomic_t 的指针

描述

如果 (v != 0)，则以原子方式使用 full ordering 将 v 更新为 (v + 1)。否则，v 不会被修改，并提供 relaxed ordering。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_inc_not_zero()。

返回

如果 v 已更新，则为 true，否则为 false。

bool raw_atomic_inc_unless_negative(atomic_t *v)¶: 原子递增，除非为负数，使用 full ordering

参数

atomic_t *v: 指向 atomic_t 的指针

描述

如果 (v >= 0)，则以原子方式使用 full ordering 将 v 更新为 (v + 1)。否则，v 不会被修改，并提供 relaxed ordering。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_inc_unless_negative()。

返回

如果 v 已更新，则为 true，否则为 false。

bool raw_atomic_dec_unless_positive(atomic_t *v)¶: 原子递减，除非为正数，使用 full ordering

参数

atomic_t *v: 指向 atomic_t 的指针

描述

如果 (v <= 0)，则以原子方式使用 full ordering 将 v 更新为 (v - 1)。否则，v 不会被修改，并提供 relaxed ordering。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_dec_unless_positive()。

返回

如果 v 已更新，则为 true，否则为 false。

int raw_atomic_dec_if_positive(atomic_t *v)¶: 原子递减（如果为正数），使用 full ordering

参数

atomic_t *v: 指向 atomic_t 的指针

描述

如果 (v > 0)，则以原子方式使用 full ordering 将 v 更新为 (v - 1)。否则，v 不会被修改，并提供 relaxed ordering。

可以在 noinstr 代码中使用；其他地方优先使用 atomic_dec_if_positive()。

返回

(v - 1) 的旧值，无论 v 是否已更新。

s64 raw_atomic64_read(const atomic64_t *v)¶: 具有宽松排序的原子加载

参数

const atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序加载 v 的值。

可以在 noinstr 代码中使用；其他地方优先使用 atomic64_read()。

返回

从 v 加载的值。

s64 raw_atomic64_read_acquire(const atomic64_t *v)¶: 具有获取排序的原子加载

参数

const atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用获取排序加载 v 的值。

可以在 noinstr 代码中使用；其他地方优先使用 atomic64_read_acquire()。

返回

从 v 加载的值。

void raw_atomic64_set(atomic64_t *v, s64 i)¶: 具有宽松排序的原子设置

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 i: 要分配的 s64 值

描述

以原子方式使用宽松排序将 v 设置为 i。

可以在 noinstr 代码中使用；其他地方优先使用 atomic64_set()。

返回

没有。

void raw_atomic64_set_release(atomic64_t *v, s64 i)¶: 具有释放排序的原子设置

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 i: 要分配的 s64 值

描述

以原子方式使用释放排序将 v 设置为 i。

可以在 noinstr 代码中使用；其他地方优先使用 atomic64_set_release()。

返回

没有。

void raw_atomic64_add(s64 i, atomic64_t *v)¶: 具有宽松排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic64_add()。

返回

没有。

s64 raw_atomic64_add_return(s64 i, atomic64_t *v)¶: 具有完整排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic64_add_return()。

返回

v 的更新值。

s64 raw_atomic64_add_return_acquire(s64 i, atomic64_t *v)¶: 具有获取排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic64_add_return_acquire()。

返回

v 的更新值。

s64 raw_atomic64_add_return_release(s64 i, atomic64_t *v)¶: 具有释放排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic64_add_return_release()。

返回

v 的更新值。

s64 raw_atomic64_add_return_relaxed(s64 i, atomic64_t *v)¶: 具有宽松排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic64_add_return_relaxed()。

返回

v 的更新值。

s64 raw_atomic64_fetch_add(s64 i, atomic64_t *v)¶: 具有完整排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

可以在 noinstr 代码中使用；其他地方优先使用 atomic64_fetch_add()。

返回

v 的原始值。

s64 raw_atomic64_fetch_add_acquire(s64 i, atomic64_t *v)¶: 具有获取排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

可在无检测代码中使用；在其他地方首选 atomic64_fetch_add_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_add_release(s64 i, atomic64_t *v)¶: 具有释放排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

可在无检测代码中使用；在其他地方首选 atomic64_fetch_add_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_add_relaxed(s64 i, atomic64_t *v)¶: 具有宽松排序的原子加法

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

可在无检测代码中使用；在其他地方首选 atomic64_fetch_add_relaxed()。

返回

v 的原始值。

void raw_atomic64_sub(s64 i, atomic64_t *v)¶: 具有宽松排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

可在无检测代码中使用；在其他地方首选 atomic64_sub()。

返回

没有。

s64 raw_atomic64_sub_return(s64 i, atomic64_t *v)¶: 具有完整排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

可在无检测代码中使用；在其他地方首选 atomic64_sub_return()。

返回

v 的更新值。

s64 raw_atomic64_sub_return_acquire(s64 i, atomic64_t *v)¶: 具有获取排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v - i)。

可在无检测代码中使用；在其他地方首选 atomic64_sub_return_acquire()。

返回

v 的更新值。

s64 raw_atomic64_sub_return_release(s64 i, atomic64_t *v)¶: 具有释放排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v - i)。

可在无检测代码中使用；在其他地方首选 atomic64_sub_return_release()。

返回

v 的更新值。

s64 raw_atomic64_sub_return_relaxed(s64 i, atomic64_t *v)¶: 具有宽松排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

可在无检测代码中使用；在其他地方首选 atomic64_sub_return_relaxed()。

返回

v 的更新值。

s64 raw_atomic64_fetch_sub(s64 i, atomic64_t *v)¶: 具有完整排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

可在无检测代码中使用；在其他地方首选 atomic64_fetch_sub()。

返回

v 的原始值。

s64 raw_atomic64_fetch_sub_acquire(s64 i, atomic64_t *v)¶: 具有获取排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v - i)。

可在无检测代码中使用；在其他地方首选 atomic64_fetch_sub_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_sub_release(s64 i, atomic64_t *v)¶: 具有释放排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v - i)。

可在无检测代码中使用；在其他地方首选 atomic64_fetch_sub_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_sub_relaxed(s64 i, atomic64_t *v)¶: 具有宽松排序的原子减法

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

可在无检测代码中使用；在其他地方首选 atomic64_fetch_sub_relaxed()。

返回

v 的原始值。

void raw_atomic64_inc(atomic64_t *v)¶: 使用宽松排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

可在无检测代码中使用；在其他地方首选 atomic64_inc()。

返回

没有。

s64 raw_atomic64_inc_return(atomic64_t *v)¶: 使用完整排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

可在无检测代码中使用；在其他地方首选 atomic64_inc_return()。

返回

v 的更新值。

s64 raw_atomic64_inc_return_acquire(atomic64_t *v)¶: 使用获取排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用获取排序原子地更新 v 为 (v + 1)。

可在无检测代码中使用；在其他地方首选 atomic64_inc_return_acquire()。

返回

v 的更新值。

s64 raw_atomic64_inc_return_release(atomic64_t *v)¶: 使用释放排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用释放排序原子地更新 v 为 (v + 1)。

可在无检测代码中使用；在其他地方首选 atomic64_inc_return_release()。

返回

v 的更新值。

s64 raw_atomic64_inc_return_relaxed(atomic64_t *v)¶: 使用宽松排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

可在无检测代码中使用；在其他地方首选 atomic64_inc_return_relaxed()。

返回

v 的更新值。

s64 raw_atomic64_fetch_inc(atomic64_t *v)¶: 使用完整排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

可在无检测代码中使用；在其他地方首选 atomic64_fetch_inc()。

返回

v 的原始值。

s64 raw_atomic64_fetch_inc_acquire(atomic64_t *v)¶: 使用获取排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用获取排序原子地更新 v 为 (v + 1)。

可在无检测代码中使用；在其他地方首选 atomic64_fetch_inc_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_inc_release(atomic64_t *v)¶: 使用释放排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用释放排序原子地更新 v 为 (v + 1)。

可在无检测代码中使用；在其他地方首选 atomic64_fetch_inc_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_inc_relaxed(atomic64_t *v)¶: 使用宽松排序的原子自增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

可在无检测代码中使用；在其他地方首选 atomic64_fetch_inc_relaxed()。

返回

v 的原始值。

void raw_atomic64_dec(atomic64_t *v)¶: 使用宽松排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

可在无检测代码中使用；在其他地方首选 atomic64_dec()。

返回

没有。

s64 raw_atomic64_dec_return(atomic64_t *v)¶: 使用完整排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

可在无检测代码中使用；在其他地方首选 atomic64_dec_return()。

返回

v 的更新值。

s64 raw_atomic64_dec_return_acquire(atomic64_t *v)¶: 使用获取排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用获取排序原子地更新 v 为 (v - 1)。

可在无检测代码中使用；在其他地方首选 atomic64_dec_return_acquire()。

返回

v 的更新值。

s64 raw_atomic64_dec_return_release(atomic64_t *v)¶: 使用释放排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用释放排序原子地更新 v 为 (v - 1)。

可在无检测代码中使用；在其他地方首选 atomic64_dec_return_release()。

返回

v 的更新值。

s64 raw_atomic64_dec_return_relaxed(atomic64_t *v)¶: 使用宽松排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

可在无检测代码中使用；在其他地方首选 atomic64_dec_return_relaxed()。

返回

v 的更新值。

s64 raw_atomic64_fetch_dec(atomic64_t *v)¶: 使用完整排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

可在无检测代码中使用；在其他地方首选 atomic64_fetch_dec()。

返回

v 的原始值。

s64 raw_atomic64_fetch_dec_acquire(atomic64_t *v)¶: 使用获取排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用获取排序原子地更新 v 为 (v - 1)。

可在无检测代码中使用；在其他地方首选 atomic64_fetch_dec_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_dec_release(atomic64_t *v)¶: 使用释放排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用释放排序原子地更新 v 为 (v - 1)。

可在无检测代码中使用；在其他地方首选 atomic64_fetch_dec_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_dec_relaxed(atomic64_t *v)¶: 使用宽松排序的原子自减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

可在无检测代码中使用；在其他地方首选 atomic64_fetch_dec_relaxed()。

返回

v 的原始值。

void raw_atomic64_and(s64 i, atomic64_t *v)¶: 使用宽松排序的原子按位与

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & i)。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_and()。

返回

没有。

s64 raw_atomic64_fetch_and(s64 i, atomic64_t *v)¶: 使用完整排序的原子按位与

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

使用完整排序原子地更新 v 为 (v & i)。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_fetch_and()。

返回

v 的原始值。

s64 raw_atomic64_fetch_and_acquire(s64 i, atomic64_t *v)¶: 使用获取排序的原子按位与

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

使用获取排序原子地更新 v 为 (v & i)。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_fetch_and_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_and_release(s64 i, atomic64_t *v)¶: 使用释放排序的原子按位与

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

使用释放排序原子地更新 v 为 (v & i)。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_fetch_and_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_and_relaxed(s64 i, atomic64_t *v)¶: 使用宽松排序的原子按位与

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & i)。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_fetch_and_relaxed()。

返回

v 的原始值。

void raw_atomic64_andnot(s64 i, atomic64_t *v)¶: 使用宽松排序的原子按位与非

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & ~i)。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_andnot()。

返回

没有。

s64 raw_atomic64_fetch_andnot(s64 i, atomic64_t *v)¶: 使用完整排序的原子按位与非

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

使用完整排序原子地更新 v 为 (v & ~i)。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_fetch_andnot()。

返回

v 的原始值。

s64 raw_atomic64_fetch_andnot_acquire(s64 i, atomic64_t *v)¶: 具有获取顺序的原子按位与非操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v & ~i)，并具有获取顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_fetch_andnot_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_andnot_release(s64 i, atomic64_t *v)¶: 具有释放顺序的原子按位与非操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v & ~i)，并具有释放顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_fetch_andnot_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_andnot_relaxed(s64 i, atomic64_t *v)¶: 使用宽松排序的原子按位与非

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & ~i)。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_fetch_andnot_relaxed()。

返回

v 的原始值。

void raw_atomic64_or(s64 i, atomic64_t *v)¶: 具有宽松顺序的原子按位或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有宽松顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_or()。

返回

没有。

s64 raw_atomic64_fetch_or(s64 i, atomic64_t *v)¶: 具有完整顺序的原子按位或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有完整顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_fetch_or()。

返回

v 的原始值。

s64 raw_atomic64_fetch_or_acquire(s64 i, atomic64_t *v)¶: 具有获取顺序的原子按位或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有获取顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_fetch_or_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_or_release(s64 i, atomic64_t *v)¶: 具有释放顺序的原子按位或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有释放顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_fetch_or_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_or_relaxed(s64 i, atomic64_t *v)¶: 具有宽松顺序的原子按位或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有宽松顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_fetch_or_relaxed()。

返回

v 的原始值。

void raw_atomic64_xor(s64 i, atomic64_t *v)¶: 具有宽松顺序的原子按位异或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有宽松顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_xor()。

返回

没有。

s64 raw_atomic64_fetch_xor(s64 i, atomic64_t *v)¶: 具有完整顺序的原子按位异或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有完整顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_fetch_xor()。

返回

v 的原始值。

s64 raw_atomic64_fetch_xor_acquire(s64 i, atomic64_t *v)¶: 具有获取顺序的原子按位异或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有获取顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_fetch_xor_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_xor_release(s64 i, atomic64_t *v)¶: 具有释放顺序的原子按位异或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有释放顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_fetch_xor_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_xor_relaxed(s64 i, atomic64_t *v)¶: 具有宽松顺序的原子按位异或操作

参数

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有宽松顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_fetch_xor_relaxed()。

返回

v 的原始值。

s64 raw_atomic64_xchg(atomic64_t *v, s64 new)¶: 具有完整顺序的原子交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 new: 要分配的 s64 值

描述

以原子方式更新 v 为 new，并具有完整顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_xchg()。

返回

v 的原始值。

s64 raw_atomic64_xchg_acquire(atomic64_t *v, s64 new)¶: 具有获取顺序的原子交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 new: 要分配的 s64 值

描述

以原子方式更新 v 为 new，并具有获取顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_xchg_acquire()。

返回

v 的原始值。

s64 raw_atomic64_xchg_release(atomic64_t *v, s64 new)¶: 具有释放顺序的原子交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 new: 要分配的 s64 值

描述

以原子方式更新 v 为 new，并具有释放顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_xchg_release()。

返回

v 的原始值。

s64 raw_atomic64_xchg_relaxed(atomic64_t *v, s64 new)¶: 具有宽松顺序的原子交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 new: 要分配的 s64 值

描述

以原子方式更新 v 为 new，并具有宽松顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_xchg_relaxed()。

返回

v 的原始值。

s64 raw_atomic64_cmpxchg(atomic64_t *v, s64 old, s64 new)¶: 具有完整顺序的原子比较和交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 old: 要比较的 s64 值
s64 new: 要分配的 s64 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有完整顺序。否则，v 不会被修改，并提供宽松顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_cmpxchg()。

返回

v 的原始值。

s64 raw_atomic64_cmpxchg_acquire(atomic64_t *v, s64 old, s64 new)¶: 具有获取顺序的原子比较和交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 old: 要比较的 s64 值
s64 new: 要分配的 s64 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有获取顺序。否则，v 不会被修改，并提供宽松顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_cmpxchg_acquire()。

返回

v 的原始值。

s64 raw_atomic64_cmpxchg_release(atomic64_t *v, s64 old, s64 new)¶: 具有释放顺序的原子比较和交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 old: 要比较的 s64 值
s64 new: 要分配的 s64 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有释放顺序。否则，v 不会被修改，并提供宽松顺序。

可在 noinstr 代码中使用；其他地方优先使用 atomic64_cmpxchg_release()。

返回

v 的原始值。

s64 raw_atomic64_cmpxchg_relaxed(atomic64_t *v, s64 old, s64 new)¶: 具有宽松顺序的原子比较和交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 old: 要比较的 s64 值
s64 new: 要分配的 s64 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有宽松顺序。否则，v 不会被修改，并提供宽松顺序。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_cmpxchg_relaxed()。

返回

v 的原始值。

bool raw_atomic64_try_cmpxchg(atomic64_t *v, s64 *old, s64 new)¶: 具有完整顺序的原子比较和交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 *old: 与要比较的 s64 值的指针
s64 new: 要分配的 s64 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有完整顺序。否则，v 不会被修改， old 会更新为 v 的当前值，并提供宽松顺序。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_try_cmpxchg()。

返回

如果发生交换，则为 true，否则为 false。

bool raw_atomic64_try_cmpxchg_acquire(atomic64_t *v, s64 *old, s64 new)¶: 具有获取顺序的原子比较和交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 *old: 与要比较的 s64 值的指针
s64 new: 要分配的 s64 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有获取顺序。否则，v 不会被修改， old 会更新为 v 的当前值，并提供宽松顺序。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_try_cmpxchg_acquire()。

返回

如果发生交换，则为 true，否则为 false。

bool raw_atomic64_try_cmpxchg_release(atomic64_t *v, s64 *old, s64 new)¶: 具有释放顺序的原子比较和交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 *old: 与要比较的 s64 值的指针
s64 new: 要分配的 s64 值

描述

如果 (v == old)，则以原子方式使用 release ordering 将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供 relaxed ordering。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_try_cmpxchg_release()。

返回

如果发生交换，则为 true，否则为 false。

bool raw_atomic64_try_cmpxchg_relaxed(atomic64_t *v, s64 *old, s64 new)¶: 具有宽松顺序的原子比较和交换

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 *old: 与要比较的 s64 值的指针
s64 new: 要分配的 s64 值

描述

如果 (v == old)，则以原子方式使用 relaxed ordering 将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供 relaxed ordering。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_try_cmpxchg_relaxed()。

返回

如果发生交换，则为 true，否则为 false。

bool raw_atomic64_sub_and_test(s64 i, atomic64_t *v)¶: 原子减法并测试是否为零，使用 full ordering

参数

s64 i: 要减去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_sub_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool raw_atomic64_dec_and_test(atomic64_t *v)¶: 原子递减并测试是否为零，使用 full ordering

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_dec_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool raw_atomic64_inc_and_test(atomic64_t *v)¶: 原子递增并测试是否为零，使用 full ordering

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_inc_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool raw_atomic64_add_negative(s64 i, atomic64_t *v)¶: 原子加法并测试是否为负数，使用 full ordering

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_add_negative()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool raw_atomic64_add_negative_acquire(s64 i, atomic64_t *v)¶: 原子加法并测试是否为负数，使用 acquire ordering

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_add_negative_acquire()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool raw_atomic64_add_negative_release(s64 i, atomic64_t *v)¶: 原子加法并测试是否为负数，使用 release ordering

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_add_negative_release()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool raw_atomic64_add_negative_relaxed(s64 i, atomic64_t *v)¶: 原子加法并测试是否为负数，使用 relaxed ordering

参数

s64 i: 要添加的 s64 值
atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_add_negative_relaxed()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

s64 raw_atomic64_fetch_add_unless(atomic64_t *v, s64 a, s64 u)¶: 原子加法，除非值为 full ordering

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 a: 要添加的 s64 值
s64 u: 要比较的 s64 值

描述

如果 (v != u)，则以原子方式使用 full ordering 将 v 更新为 (v + a)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_fetch_add_unless()。

返回

v 的原始值。

bool raw_atomic64_add_unless(atomic64_t *v, s64 a, s64 u)¶: 原子加法，除非值为 full ordering

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 a: 要添加的 s64 值
s64 u: 要比较的 s64 值

描述

如果 (v != u)，则以原子方式使用 full ordering 将 v 更新为 (v + a)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_add_unless()。

返回

如果 v 已更新，则为 true，否则为 false。

bool raw_atomic64_inc_not_zero(atomic64_t *v)¶: 原子递增，除非为零，使用 full ordering

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

如果 (v != 0)，则以原子方式使用 full ordering 将 v 更新为 (v + 1)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_inc_not_zero()。

返回

如果 v 已更新，则为 true，否则为 false。

bool raw_atomic64_inc_unless_negative(atomic64_t *v)¶: 原子递增，除非为负数，使用 full ordering

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

如果 (v >= 0)，则以原子方式使用 full ordering 将 v 更新为 (v + 1)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_inc_unless_negative()。

返回

如果 v 已更新，则为 true，否则为 false。

bool raw_atomic64_dec_unless_positive(atomic64_t *v)¶: 原子递减，除非为正数，使用 full ordering

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

如果 (v <= 0)，则以原子方式使用 full ordering 将 v 更新为 (v - 1)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_dec_unless_positive()。

返回

如果 v 已更新，则为 true，否则为 false。

s64 raw_atomic64_dec_if_positive(atomic64_t *v)¶: 原子递减（如果为正数），使用 full ordering

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

如果 (v > 0)，则以原子方式使用 full ordering 将 v 更新为 (v - 1)。否则，v 不会被修改，并提供 relaxed ordering。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic64_dec_if_positive()。

返回

(v - 1) 的旧值，无论 v 是否已更新。

long raw_atomic_long_read(const atomic_long_t *v)¶: 具有宽松排序的原子加载

参数

const atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用宽松排序加载 v 的值。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic_long_read()。

返回

从 v 加载的值。

long raw_atomic_long_read_acquire(const atomic_long_t *v)¶: 具有获取排序的原子加载

参数

const atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用获取排序加载 v 的值。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic_long_read_acquire()。

返回

从 v 加载的值。

void raw_atomic_long_set(atomic_long_t *v, long i)¶: 具有宽松排序的原子设置

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long i: 要分配的 long 值

描述

以原子方式使用宽松排序将 v 设置为 i。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic_long_set()。

返回

没有。

void raw_atomic_long_set_release(atomic_long_t *v, long i)¶: 具有释放排序的原子设置

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long i: 要分配的 long 值

描述

以原子方式使用释放排序将 v 设置为 i。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic_long_set_release()。

返回

没有。

void raw_atomic_long_add(long i, atomic_long_t *v)¶: 具有宽松排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic_long_add()。

返回

没有。

long raw_atomic_long_add_return(long i, atomic_long_t *v)¶: 具有完整排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic_long_add_return()。

返回

v 的更新值。

long raw_atomic_long_add_return_acquire(long i, atomic_long_t *v)¶: 具有获取排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic_long_add_return_acquire()。

返回

v 的更新值。

long raw_atomic_long_add_return_release(long i, atomic_long_t *v)¶: 具有释放排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic_long_add_return_release()。

返回

v 的更新值。

long raw_atomic_long_add_return_relaxed(long i, atomic_long_t *v)¶: 具有宽松排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

在 noinstr 代码中使用是安全的；在其他地方首选 atomic_long_add_return_relaxed()。

返回

v 的更新值。

long raw_atomic_long_fetch_add(long i, atomic_long_t *v)¶: 具有完整排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_fetch_add()。

返回

v 的原始值。

long raw_atomic_long_fetch_add_acquire(long i, atomic_long_t *v)¶: 具有获取排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_fetch_add_acquire()。

返回

v 的原始值。

long raw_atomic_long_fetch_add_release(long i, atomic_long_t *v)¶: 具有释放排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_fetch_add_release()。

返回

v 的原始值。

long raw_atomic_long_fetch_add_relaxed(long i, atomic_long_t *v)¶: 具有宽松排序的原子加法

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_fetch_add_relaxed()。

返回

v 的原始值。

void raw_atomic_long_sub(long i, atomic_long_t *v)¶: 具有宽松排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_sub()。

返回

没有。

long raw_atomic_long_sub_return(long i, atomic_long_t *v)¶: 具有完整排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_sub_return()。

返回

v 的更新值。

long raw_atomic_long_sub_return_acquire(long i, atomic_long_t *v)¶: 具有获取排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v - i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_sub_return_acquire()。

返回

v 的更新值。

long raw_atomic_long_sub_return_release(long i, atomic_long_t *v)¶: 具有释放排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v - i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_sub_return_release()。

返回

v 的更新值。

long raw_atomic_long_sub_return_relaxed(long i, atomic_long_t *v)¶: 具有宽松排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_sub_return_relaxed()。

返回

v 的更新值。

long raw_atomic_long_fetch_sub(long i, atomic_long_t *v)¶: 具有完整排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_fetch_sub()。

返回

v 的原始值。

long raw_atomic_long_fetch_sub_acquire(long i, atomic_long_t *v)¶: 具有获取排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v - i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_fetch_sub_acquire()。

返回

v 的原始值。

long raw_atomic_long_fetch_sub_release(long i, atomic_long_t *v)¶: 具有释放排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v - i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_fetch_sub_release()。

返回

v 的原始值。

long raw_atomic_long_fetch_sub_relaxed(long i, atomic_long_t *v)¶: 具有宽松排序的原子减法

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_fetch_sub_relaxed()。

返回

v 的原始值。

void raw_atomic_long_inc(atomic_long_t *v)¶: 使用宽松排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_inc()。

返回

没有。

long raw_atomic_long_inc_return(atomic_long_t *v)¶: 使用完整排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_inc_return()。

返回

v 的更新值。

long raw_atomic_long_inc_return_acquire(atomic_long_t *v)¶: 使用获取排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用获取排序原子地更新 v 为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_inc_return_acquire()。

返回

v 的更新值。

long raw_atomic_long_inc_return_release(atomic_long_t *v)¶: 使用释放排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用释放排序原子地更新 v 为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_inc_return_release()。

返回

v 的更新值。

long raw_atomic_long_inc_return_relaxed(atomic_long_t *v)¶: 使用宽松排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_inc_return_relaxed()。

返回

v 的更新值。

long raw_atomic_long_fetch_inc(atomic_long_t *v)¶: 使用完整排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_fetch_inc()。

返回

v 的原始值。

long raw_atomic_long_fetch_inc_acquire(atomic_long_t *v)¶: 使用获取排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用获取排序原子地更新 v 为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_fetch_inc_acquire()。

返回

v 的原始值。

long raw_atomic_long_fetch_inc_release(atomic_long_t *v)¶: 使用释放排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用释放排序原子地更新 v 为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_fetch_inc_release()。

返回

v 的原始值。

long raw_atomic_long_fetch_inc_relaxed(atomic_long_t *v)¶: 使用宽松排序的原子自增

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_fetch_inc_relaxed()。

返回

v 的原始值。

void raw_atomic_long_dec(atomic_long_t *v)¶: 使用宽松排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_dec()。

返回

没有。

long raw_atomic_long_dec_return(atomic_long_t *v)¶: 使用完整排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_dec_return()。

返回

v 的更新值。

long raw_atomic_long_dec_return_acquire(atomic_long_t *v)¶: 使用获取排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用获取排序原子地更新 v 为 (v - 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_dec_return_acquire()。

返回

v 的更新值。

long raw_atomic_long_dec_return_release(atomic_long_t *v)¶: 使用释放排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用释放排序原子地更新 v 为 (v - 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_dec_return_release()。

返回

v 的更新值。

long raw_atomic_long_dec_return_relaxed(atomic_long_t *v)¶: 使用宽松排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_dec_return_relaxed()。

返回

v 的更新值。

long raw_atomic_long_fetch_dec(atomic_long_t *v)¶: 使用完整排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_fetch_dec()。

返回

v 的原始值。

long raw_atomic_long_fetch_dec_acquire(atomic_long_t *v)¶: 使用获取排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用获取排序原子地更新 v 为 (v - 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_fetch_dec_acquire()。

返回

v 的原始值。

long raw_atomic_long_fetch_dec_release(atomic_long_t *v)¶: 使用释放排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用释放排序原子地更新 v 为 (v - 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_fetch_dec_release()。

返回

v 的原始值。

long raw_atomic_long_fetch_dec_relaxed(atomic_long_t *v)¶: 使用宽松排序的原子自减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v - 1)。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_fetch_dec_relaxed()。

返回

v 的原始值。

void raw_atomic_long_and(long i, atomic_long_t *v)¶: 使用宽松排序的原子按位与

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & i)。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_and()。

返回

没有。

long raw_atomic_long_fetch_and(long i, atomic_long_t *v)¶: 使用完整排序的原子按位与

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用完整排序原子地更新 v 为 (v & i)。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_fetch_and()。

返回

v 的原始值。

long raw_atomic_long_fetch_and_acquire(long i, atomic_long_t *v)¶: 使用获取排序的原子按位与

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用获取排序原子地更新 v 为 (v & i)。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_fetch_and_acquire()。

返回

v 的原始值。

long raw_atomic_long_fetch_and_release(long i, atomic_long_t *v)¶: 使用释放排序的原子按位与

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用释放排序原子地更新 v 为 (v & i)。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_fetch_and_release()。

返回

v 的原始值。

long raw_atomic_long_fetch_and_relaxed(long i, atomic_long_t *v)¶: 使用宽松排序的原子按位与

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & i)。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_fetch_and_relaxed()。

返回

v 的原始值。

void raw_atomic_long_andnot(long i, atomic_long_t *v)¶: 使用宽松排序的原子按位与非

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & ~i)。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_andnot()。

返回

没有。

long raw_atomic_long_fetch_andnot(long i, atomic_long_t *v)¶: 使用完整排序的原子按位与非

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用完整排序原子地更新 v 为 (v & ~i)。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_fetch_andnot()。

返回

v 的原始值。

long raw_atomic_long_fetch_andnot_acquire(long i, atomic_long_t *v)¶: 具有获取顺序的原子按位与非操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v & ~i)，并具有获取顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_fetch_andnot_acquire()。

返回

v 的原始值。

long raw_atomic_long_fetch_andnot_release(long i, atomic_long_t *v)¶: 具有释放顺序的原子按位与非操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v & ~i)，并具有释放顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_fetch_andnot_release()。

返回

v 的原始值。

long raw_atomic_long_fetch_andnot_relaxed(long i, atomic_long_t *v)¶: 使用宽松排序的原子按位与非

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用宽松排序原子地更新 v 为 (v & ~i)。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_fetch_andnot_relaxed()。

返回

v 的原始值。

void raw_atomic_long_or(long i, atomic_long_t *v)¶: 具有宽松顺序的原子按位或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有宽松顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_or()。

返回

没有。

long raw_atomic_long_fetch_or(long i, atomic_long_t *v)¶: 具有完整顺序的原子按位或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有完整顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_fetch_or()。

返回

v 的原始值。

long raw_atomic_long_fetch_or_acquire(long i, atomic_long_t *v)¶: 具有获取顺序的原子按位或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有获取顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_fetch_or_acquire()。

返回

v 的原始值。

long raw_atomic_long_fetch_or_release(long i, atomic_long_t *v)¶: 具有释放顺序的原子按位或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有释放顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_fetch_or_release()。

返回

v 的原始值。

long raw_atomic_long_fetch_or_relaxed(long i, atomic_long_t *v)¶: 具有宽松顺序的原子按位或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v | i)，并具有宽松顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_fetch_or_relaxed()。

返回

v 的原始值。

void raw_atomic_long_xor(long i, atomic_long_t *v)¶: 具有宽松顺序的原子按位异或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有宽松顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_xor()。

返回

没有。

long raw_atomic_long_fetch_xor(long i, atomic_long_t *v)¶: 具有完整顺序的原子按位异或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有完整顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_fetch_xor()。

返回

v 的原始值。

long raw_atomic_long_fetch_xor_acquire(long i, atomic_long_t *v)¶: 具有获取顺序的原子按位异或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有获取顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_fetch_xor_acquire()。

返回

v 的原始值。

long raw_atomic_long_fetch_xor_release(long i, atomic_long_t *v)¶: 具有释放顺序的原子按位异或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有释放顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_fetch_xor_release()。

返回

v 的原始值。

long raw_atomic_long_fetch_xor_relaxed(long i, atomic_long_t *v)¶: 具有宽松顺序的原子按位异或操作

参数

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式更新 v 为 (v ^ i)，并具有宽松顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_fetch_xor_relaxed()。

返回

v 的原始值。

long raw_atomic_long_xchg(atomic_long_t *v, long new)¶: 具有完整顺序的原子交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long new: 要分配的 long 值

描述

以原子方式更新 v 为 new，并具有完整顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_xchg()。

返回

v 的原始值。

long raw_atomic_long_xchg_acquire(atomic_long_t *v, long new)¶: 具有获取顺序的原子交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long new: 要分配的 long 值

描述

以原子方式更新 v 为 new，并具有获取顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_xchg_acquire()。

返回

v 的原始值。

long raw_atomic_long_xchg_release(atomic_long_t *v, long new)¶: 具有释放顺序的原子交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long new: 要分配的 long 值

描述

以原子方式更新 v 为 new，并具有释放顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_xchg_release()。

返回

v 的原始值。

long raw_atomic_long_xchg_relaxed(atomic_long_t *v, long new)¶: 具有宽松顺序的原子交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long new: 要分配的 long 值

描述

以原子方式更新 v 为 new，并具有宽松顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_xchg_relaxed()。

返回

v 的原始值。

long raw_atomic_long_cmpxchg(atomic_long_t *v, long old, long new)¶: 具有完整顺序的原子比较和交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long old: 要比较的 long 值
long new: 要分配的 long 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有完整顺序。否则，v 不会被修改，并提供宽松顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_cmpxchg()。

返回

v 的原始值。

long raw_atomic_long_cmpxchg_acquire(atomic_long_t *v, long old, long new)¶: 具有获取顺序的原子比较和交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long old: 要比较的 long 值
long new: 要分配的 long 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有获取顺序。否则，v 不会被修改，并提供宽松顺序。

可以在 noinstr 代码中使用；在其他地方，首选 atomic_long_cmpxchg_acquire()。

返回

v 的原始值。

long raw_atomic_long_cmpxchg_release(atomic_long_t *v, long old, long new)¶: 具有释放顺序的原子比较和交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long old: 要比较的 long 值
long new: 要分配的 long 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有释放顺序。否则，v 不会被修改，并提供宽松顺序。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_cmpxchg_release()。

返回

v 的原始值。

long raw_atomic_long_cmpxchg_relaxed(atomic_long_t *v, long old, long new)¶: 具有宽松顺序的原子比较和交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long old: 要比较的 long 值
long new: 要分配的 long 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有宽松顺序。否则，v 不会被修改，并提供宽松顺序。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_cmpxchg_relaxed()。

返回

v 的原始值。

bool raw_atomic_long_try_cmpxchg(atomic_long_t *v, long *old, long new)¶: 具有完整顺序的原子比较和交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long *old: 与要比较的 long 值对应的指针
long new: 要分配的 long 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有完整顺序。否则，v 不会被修改， old 会更新为 v 的当前值，并提供宽松顺序。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_try_cmpxchg()。

返回

如果发生交换，则为 true，否则为 false。

bool raw_atomic_long_try_cmpxchg_acquire(atomic_long_t *v, long *old, long new)¶: 具有获取顺序的原子比较和交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long *old: 与要比较的 long 值对应的指针
long new: 要分配的 long 值

描述

如果 (v == old)，则以原子方式更新 v 为 new，并具有获取顺序。否则，v 不会被修改， old 会更新为 v 的当前值，并提供宽松顺序。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_try_cmpxchg_acquire()。

返回

如果发生交换，则为 true，否则为 false。

bool raw_atomic_long_try_cmpxchg_release(atomic_long_t *v, long *old, long new)¶: 具有释放顺序的原子比较和交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long *old: 与要比较的 long 值对应的指针
long new: 要分配的 long 值

描述

如果 (v == old)，则以原子方式使用 release ordering 将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供 relaxed ordering。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_try_cmpxchg_release()。

返回

如果发生交换，则为 true，否则为 false。

bool raw_atomic_long_try_cmpxchg_relaxed(atomic_long_t *v, long *old, long new)¶: 具有宽松顺序的原子比较和交换

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long *old: 与要比较的 long 值对应的指针
long new: 要分配的 long 值

描述

如果 (v == old)，则以原子方式使用 relaxed ordering 将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供 relaxed ordering。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_try_cmpxchg_relaxed()。

返回

如果发生交换，则为 true，否则为 false。

bool raw_atomic_long_sub_and_test(long i, atomic_long_t *v)¶: 原子减法并测试是否为零，使用 full ordering

参数

long i: 要减去的长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v - i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_sub_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool raw_atomic_long_dec_and_test(atomic_long_t *v)¶: 原子递减并测试是否为零，使用 full ordering

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用完整排序原子地更新 v 为 (v - 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_dec_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool raw_atomic_long_inc_and_test(atomic_long_t *v)¶: 原子递增并测试是否为零，使用 full ordering

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

使用完整排序原子地更新 v 为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_inc_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool raw_atomic_long_add_negative(long i, atomic_long_t *v)¶: 原子加法并测试是否为负数，使用 full ordering

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用完整排序将 v 更新为 (v + i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_add_negative()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool raw_atomic_long_add_negative_acquire(long i, atomic_long_t *v)¶: 原子加法并测试是否为负数，使用 acquire ordering

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_add_negative_acquire()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool raw_atomic_long_add_negative_release(long i, atomic_long_t *v)¶: 原子加法并测试是否为负数，使用 release ordering

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_add_negative_release()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool raw_atomic_long_add_negative_relaxed(long i, atomic_long_t *v)¶: 原子加法并测试是否为负数，使用 relaxed ordering

参数

long i: 要添加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + i)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_add_negative_relaxed()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

long raw_atomic_long_fetch_add_unless(atomic_long_t *v, long a, long u)¶: 原子加法，除非值为 full ordering

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long a: 要添加的 long 值
long u: 要比较的 long 值

描述

如果 (v != u)，则以原子方式使用 full ordering 将 v 更新为 (v + a)。否则，v 不会被修改，并提供 relaxed ordering。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_fetch_add_unless()。

返回

v 的原始值。

bool raw_atomic_long_add_unless(atomic_long_t *v, long a, long u)¶: 原子加法，除非值为 full ordering

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long a: 要添加的 long 值
long u: 要比较的 long 值

描述

如果 (v != u)，则以原子方式使用 full ordering 将 v 更新为 (v + a)。否则，v 不会被修改，并提供 relaxed ordering。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_add_unless()。

返回

如果 v 已更新，则为 true，否则为 false。

bool raw_atomic_long_inc_not_zero(atomic_long_t *v)¶: 原子递增，除非为零，使用 full ordering

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

如果 (v != 0)，则以原子方式使用 full ordering 将 v 更新为 (v + 1)。否则，v 不会被修改，并提供 relaxed ordering。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_inc_not_zero()。

返回

如果 v 已更新，则为 true，否则为 false。

bool raw_atomic_long_inc_unless_negative(atomic_long_t *v)¶: 原子递增，除非为负数，使用 full ordering

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

如果 (v >= 0)，则以原子方式使用 full ordering 将 v 更新为 (v + 1)。否则，v 不会被修改，并提供 relaxed ordering。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_inc_unless_negative()。

返回

如果 v 已更新，则为 true，否则为 false。

bool raw_atomic_long_dec_unless_positive(atomic_long_t *v)¶: 原子递减，除非为正数，使用 full ordering

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

如果 (v <= 0)，则以原子方式使用 full ordering 将 v 更新为 (v - 1)。否则，v 不会被修改，并提供 relaxed ordering。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_dec_unless_positive()。

返回

如果 v 已更新，则为 true，否则为 false。

long raw_atomic_long_dec_if_positive(atomic_long_t *v)¶: 原子递减（如果为正数），使用 full ordering

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

如果 (v > 0)，则以原子方式使用 full ordering 将 v 更新为 (v - 1)。否则，v 不会被修改，并提供 relaxed ordering。

可在 noinstr 代码中使用；其他地方请优先使用 atomic_long_dec_if_positive()。

返回

(v - 1) 的旧值，无论 v 是否已更新。

内核对象操作¶

char *kobject_get_path(const struct kobject *kobj, gfp_t gfp_mask)¶: 分配内存并填充 kobj 的路径。

参数

const struct kobject *kobj: 有问题的 kobject，用于构建路径
gfp_t gfp_mask: 用于分配路径的分配类型

返回

新分配的内存，调用者必须使用 kfree() 释放。

int kobject_set_name(struct kobject *kobj, const char *fmt, ...)¶: 设置 kobject 的名称。

参数

struct kobject *kobj: 要设置名称的 struct kobject
const char *fmt: 用于构建名称的格式字符串
...: 可变参数

描述

这将设置 kobject 的名称。如果您已经将 kobject 添加到系统，则必须调用 kobject_rename() 才能更改 kobject 的名称。

void kobject_init(struct kobject *kobj, const struct kobj_type *ktype)¶: 初始化 kobject 结构。

参数

struct kobject *kobj: 要初始化的 kobject 的指针
const struct kobj_type *ktype: 此 kobject 的 ktype 的指针。

描述

此函数将正确初始化 kobject，以便随后可以将其传递给 kobject_add() 调用。

调用此函数后，必须通过调用 kobject_put()（而不是直接调用 kfree）来清理 kobject，以确保正确清理所有内存。

int kobject_add(struct kobject *kobj, struct kobject *parent, const char *fmt, ...)¶: 主要的 kobject 添加函数。

参数

struct kobject *kobj: 要添加的 kobject
struct kobject *parent: kobject 的父对象的指针。
const char *fmt: 用于命名 kobject 的格式。
...: 可变参数

描述

在此函数中设置 kobject 名称并将其添加到 kobject 层次结构中。

如果设置了 parent，则 kobj 的父对象将设置为它。如果 parent 为 NULL，则 kobj 的父对象将设置为与分配给此 kobject 的 kset 关联的 kobject。如果没有将 kset 分配给 kobject，则该 kobject 将位于 sysfs 树的根目录中。

注意，此调用不会创建任何“add” uevent，调用者应为该对象设置所有必要的 sysfs 文件，然后使用 UEVENT_ADD 参数调用 kobject_uevent()，以确保用户空间已正确收到此 kobject 创建的通知。

返回

如果此函数返回错误，则必须调用 kobject_put()

以正确清理与该对象关联的内存。在任何情况下，都不应通过调用 kfree() 直接释放传递给此函数的 kobject，这可能会导致内存泄漏。

如果此函数返回成功，则还必须调用 kobject_put()，以正确清理与该对象关联的内存。

简而言之，一旦调用此函数，当对象的使用完成后，必须调用 kobject_put()，以便正确释放所有内容。

int kobject_init_and_add(struct kobject *kobj, const struct kobj_type *ktype, struct kobject *parent, const char *fmt, ...)¶: 初始化一个 kobject 结构体并将其添加到 kobject 层次结构中。

参数

struct kobject *kobj: 要初始化的 kobject 的指针
const struct kobj_type *ktype: 此 kobject 的 ktype 的指针。
struct kobject *parent: 指向此 kobject 的父对象的指针。
const char *fmt: kobject 的名称。
...: 可变参数

描述

此函数结合了对 kobject_init() 和 kobject_add() 的调用。

如果此函数返回错误，则必须调用 kobject_put() 以正确清理与该对象关联的内存。这与调用 kobject_add() 之后的错误处理类型相同，并且 kobject 生命周期规则在此处也相同。

int kobject_rename(struct kobject *kobj, const char *new_name)¶: 更改对象的名称。

参数

struct kobject *kobj: 有问题的对象。
const char *new_name: 对象的新名称

描述

调用方有责任在同一 kobject 上对 kobject_rename 的两个不同调用之间提供互斥，并确保 new_name 有效且不会与其他 kobject 冲突。

int kobject_move(struct kobject *kobj, struct kobject *new_parent)¶: 将对象移动到另一个父对象。

参数

struct kobject *kobj: 有问题的对象。
struct kobject *new_parent: 对象的新父对象（可以为 NULL）

void kobject_del(struct kobject *kobj)¶: 从层次结构中取消链接 kobject。

参数

struct kobject *kobj: 对象。

描述

这是应该调用的函数，用于删除通过 kobject_add() 成功添加的对象。

struct kobject *kobject_get(struct kobject *kobj)¶: 增加对象的引用计数。

参数

struct kobject *kobj: 对象。

void kobject_put(struct kobject *kobj)¶: 减少对象的引用计数。

参数

struct kobject *kobj: 对象。

描述

减少引用计数，如果为 0，则调用 kobject_cleanup()。

struct kobject *kobject_create_and_add(const char *name, struct kobject *parent)¶: 动态创建一个 struct kobject 并将其注册到 sysfs。

参数

const char *name: kobject 的名称
struct kobject *parent: 此 kobject 的父 kobject（如果有）。

描述

此函数动态创建一个 kobject 结构体并将其注册到 sysfs。完成此结构体后，调用 kobject_put()，该结构体将在不再使用时动态释放。

如果无法创建 kobject，将返回 NULL。

int kset_register(struct kset *k)¶: 初始化并添加一个 kset。

参数

struct kset *k: kset。

注意

发生错误时，由 kobj_set_name() 分配的 kset.kobj.name 会被释放，不能再使用。

void kset_unregister(struct kset *k)¶: 删除一个 kset。

参数

struct kset *k: kset。

struct kobject *kset_find_obj(struct kset *kset, const char *name)¶: 在 kset 中搜索对象。

参数

struct kset *kset: 我们要查找的 kset。
const char *name: 对象的名称。

描述

通过 kset->subsys 锁定 kset，并迭代 kset->list，查找匹配的 kobject。如果找到匹配的对象，则获取引用并返回该对象。

struct kset *kset_create_and_add(const char *name, const struct kset_uevent_ops *uevent_ops, struct kobject *parent_kobj)¶: 动态创建一个 struct kset 并将其添加到 sysfs。

参数

const char *name: kset 的名称
const struct kset_uevent_ops *uevent_ops: kset 的 struct kset_uevent_ops
struct kobject *parent_kobj: 此 kset 的父 kobject（如果有）。

描述

此函数动态创建一个 kset 结构体并将其注册到 sysfs。完成此结构体后，调用 kset_unregister()，该结构体将在不再使用时动态释放。

如果无法创建 kset，将返回 NULL。

int kobject_uevent_env(struct kobject *kobj, enum kobject_action action, char *envp_ext[])¶: 发送带有环境数据的 uevent

参数

struct kobject *kobj: 发生操作的 struct kobject
enum kobject_action action: 正在发生的操作
char *envp_ext[]: 指向环境数据的指针

描述

如果 kobject_uevent_env() 成功完成，则返回 0；如果失败，则返回相应的错误。

int kobject_uevent(struct kobject *kobj, enum kobject_action action)¶: 通过发送 uevent 通知用户空间

参数

struct kobject *kobj: 发生操作的 struct kobject
enum kobject_action action: 正在发生的操作

描述

如果 kobject_uevent() 成功完成，则返回 0；如果失败，则返回相应的错误。

int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)¶: 将键值字符串添加到环境变量缓冲区

参数

struct kobj_uevent_env *env: 环境变量缓冲区结构
const char *format: 键=值对的 printf 格式
...: 可变参数

描述

如果成功添加环境变量，则返回 0；如果没有可用空间，则返回 -ENOMEM。

内核实用程序函数¶

might_sleep¶

might_sleep ()

可以休眠的函数的注释

描述

如果在原子上下文中（spinlock，irq-handler，...）执行此宏，它将打印堆栈跟踪。可以使用 non_block_start() 和 non_block_end() 对不允许阻塞的附加部分进行注释。

这是一种有用的调试帮助，可以及早发现问题，并且在调用函数不应该休眠时发生休眠时，不会在以后受到影响。

cant_sleep¶

cant_sleep ()

不能休眠的函数的注释

描述

如果在启用抢占的情况下执行此宏，它将打印堆栈跟踪

cant_migrate¶

cant_migrate ()

无法迁移的函数的注释

描述

如果在可迁移的代码中执行，将打印堆栈跟踪

non_block_start¶

non_block_start ()

注释禁止休眠的部分的开始

描述

这是代表 oom 清理器，特别是当它调用 mmu 通知程序时。问题是，如果通知程序阻塞（例如，在 mutex_lock() 上），并且如果持有该互斥锁的进程执行休眠内存分配，则 oom 清理器现在被阻止完成该内存分配。其他阻塞调用（如 wait_event()）也会带来类似的问题。

non_block_end¶

non_block_end ()

注释禁止休眠的部分的结束

描述

关闭由 non_block_start() 打开的部分。

trace_printk¶

trace_printk (fmt, ...)

ftrace 缓冲区中的 printf 格式

参数

fmt: 用于打印的 printf 格式
...: 可变参数

注意

__trace_printk 是 trace_printk() 的内部函数，: ip 通过 trace_printk() 宏传入。

描述

此函数允许内核开发人员调试不适合 printk 的快速路径部分。通过在代码中散布各种类似 printk 的跟踪，开发人员可以快速查看出现问题的位置。

这仅用作开发人员的调试工具。请避免在代码中散布 trace_printk。（当使用 trace_printk() 时，会使用额外的内存来分配特殊缓冲区。）

这里进行了一些小的优化技巧。如果只有一个参数，则无需扫描字符串的 printf 格式。 trace_puts() 就足够了。但是当 trace_printk() 只有一个参数时，我们如何利用使用 trace_puts() 的优势？通过字符串化参数并检查大小，我们可以判断是否存在参数。当没有参数时，__stringify((__VA_ARGS__)) 将变为 “()0”，大小为 3，其他任何内容都将更大。我们需要做的就是定义一个字符串给它，然后获取它的大小并与 3 进行比较。如果它更大，则使用 do_trace_printk()，否则，将其优化为 trace_puts()。然后让 gcc 优化其余部分。

trace_puts¶

trace_puts (str)

将字符串写入 ftrace 缓冲区

参数

str: 要记录的字符串

注意

__trace_bputs 是 trace_puts 的内部函数，: ip 通过 trace_puts 宏传入。

描述

这类似于 trace_printk()，但它是为那些开发人员希望以最少的 “海森堡” 效应获得的非常快速的路径而设计的，其中打印格式的处理仍然太多。

此函数允许内核开发人员调试不适合 printk 的快速路径部分。通过在代码中散布各种类似 printk 的跟踪，开发人员可以快速查看出现问题的位置。

这仅用作开发人员的调试工具。请避免在代码中散布 trace_puts。（当使用 trace_puts() 时，会使用额外的内存来分配特殊缓冲区。）

返回

如果未写入任何内容，则为 0；如果字符串被写入，则为正数 #。: （当使用 __trace_bputs 时为 1，当使用 __trace_puts 时为 strlen(str)）

void console_list_lock(void)¶: 锁定控制台列表

参数

void: 无参数

描述

用于控制台列表或 console->flags 更新

void console_list_unlock(void)¶: 解锁控制台列表

参数

void: 无参数

描述

与 console_list_lock() 相对应

int console_srcu_read_lock(void)¶: 为受 SRCU 保护的控制台列表注册一个新的读取者

参数

void: 无参数

描述

使用 for_each_console_srcu() 迭代控制台列表

上下文

任何上下文。

返回

一个 cookie 传递给 console_srcu_read_unlock()。

void console_srcu_read_unlock(int cookie)¶: 从受 SRCU 保护的控制台列表注销一个旧的读取者

参数

int cookie: 从 console_srcu_read_lock() 返回的 cookie

描述

与 console_srcu_read_lock() 配对

int match_devname_and_update_preferred_console(const char *devname, const char *name, const short idx)¶: 当找到匹配的 devname 时，更新首选控制台。

参数

const char *devname: DEVNAME:0.0 样式的设备名称
const char *name: 相应控制台驱动程序的名称，例如“ttyS”
const short idx: 控制台索引，例如端口号。

描述

该函数检查是否通过 console=DEVNAME:0.0 命令行选项首选具有给定 **devname** 的设备。它填充缺少的控制台驱动程序名称和控制台索引，以便稍后的 register_console() 调用可以找到（匹配）并启用此设备。

当驱动程序子系统使用已知的 DEVNAME:0.0 样式名称初始化特定设备时，可以使用它。并且它可以预测此设备稍后将与哪个控制台驱动程序名称和索引关联。

返回

成功时为 0，失败时为负错误代码。

void console_lock(void)¶: 阻止控制台子系统打印

参数

void: 无参数

描述

获取一个锁，以保证没有控制台将处于或进入它们的 write() 回调。

可以睡眠，不返回任何内容。

int console_trylock(void)¶: 尝试阻止控制台子系统打印

参数

void: 无参数

描述

尝试获取一个锁，以保证没有控制台将处于或进入它们的 write() 回调。

成功时返回 1，获取锁失败时返回 0。

void console_unlock(void)¶: 解除对传统控制台子系统打印的阻止

参数

void: 无参数

描述

释放调用者持有的 console_lock，以阻止传统控制台子系统的打印。

当持有 console_lock 时，控制台输出可能已被 printk() 缓冲。如果是这种情况，console_unlock() 会在释放锁之前在传统控制台上发出输出。

console_unlock(); 可以从任何上下文中调用。

void console_conditional_schedule(void)¶: 如果需要，让出 CPU

参数

void: 无参数

描述

如果当前允许控制台代码睡眠，并且如果此 CPU 应该将 CPU 让给另一个任务，请在此处执行此操作。

必须在 console_lock() 中调用；。

void console_force_preferred_locked(struct console *con)¶: 强制注册的控制台成为首选

参数

struct console *con: 要强制成为首选的已注册控制台。

描述

必须在 console_list_lock() 下调用。

bool printk_timed_ratelimit(unsigned long *caller_jiffies, unsigned int interval_msecs)¶: 调用者控制的 printk 速率限制

参数

unsigned long *caller_jiffies: 指向调用者的状态的指针
unsigned int interval_msecs: 打印之间的最小间隔

描述

如果自上次 printk_timed_ratelimit() 返回 true 以来，已经过去了超过 **interval_msecs** 毫秒，则 printk_timed_ratelimit() 返回 true。

int kmsg_dump_register(struct kmsg_dumper *dumper)¶: 注册一个内核日志转储器。

参数

struct kmsg_dumper *dumper: 指向 kmsg_dumper 结构的指针

描述

将内核日志转储器添加到系统。当内核出现 oops 或 panic 时，将调用结构中的 dump 回调，并且必须进行设置。成功时返回零，否则返回 -EINVAL 或 -EBUSY。

int kmsg_dump_unregister(struct kmsg_dumper *dumper)¶: 注销 kmsg 转储器。

参数

struct kmsg_dumper *dumper: 指向 kmsg_dumper 结构的指针

描述

从系统中删除转储设备。成功时返回零，否则返回 -EINVAL。

bool kmsg_dump_get_line(struct kmsg_dump_iter *iter, bool syslog, char *line, size_t size, size_t *len)¶: 检索一条 kmsg 日志行

参数

struct kmsg_dump_iter *iter: kmsg 转储迭代器
bool syslog: 包括“<4>”前缀
char *line: 用于复制行的缓冲区
size_t size: 缓冲区的最大大小
size_t *len: 放入缓冲区的行的长度

描述

从 kmsg 缓冲区的开头开始，从最旧的 kmsg 记录开始，并将一条记录复制到提供的缓冲区中。

连续调用将返回下一个可用的记录，并朝着缓冲区末尾移动，其中包含最新的消息。

FALSE 的返回值表示没有更多记录要读取。

bool kmsg_dump_get_buffer(struct kmsg_dump_iter *iter, bool syslog, char *buf, size_t size, size_t *len_out)¶: 复制 kmsg 日志行

参数

struct kmsg_dump_iter *iter: kmsg 转储迭代器
bool syslog: 包括“<4>”前缀
char *buf: 用于复制行的缓冲区
size_t size: 缓冲区的最大大小
size_t *len_out: 放入缓冲区的行的长度

描述

从 kmsg 缓冲区的末尾开始，并用尽可能多的适合它的*最新* kmsg 记录填充提供的缓冲区。如果缓冲区足够大，则所有可用的 kmsg 记录都将通过一次调用进行复制。

连续调用将使用下一块可用的较旧记录填充缓冲区，不包括先前检索到的记录。

FALSE 的返回值表示没有更多记录要读取。

void kmsg_dump_rewind(struct kmsg_dump_iter *iter)¶: 重置迭代器

参数

struct kmsg_dump_iter *iter: kmsg 转储迭代器

描述

重置转储器的迭代器，以便可以再次调用 kmsg_dump_get_line() 和 kmsg_dump_get_buffer()，并在同一个 dumper.dump() 回调中多次使用它们。

void __printk_cpu_sync_wait(void)¶: 忙等待直到 printk cpu 可重入自旋锁不被任何 CPU 拥有。

参数

void: 无参数

上下文

任何上下文。

int __printk_cpu_sync_try_get(void)¶: 尝试获取 printk cpu 可重入自旋锁。

参数

void: 无参数

描述

如果没有处理器拥有该锁，则调用处理器获取该锁并成为所有者。如果调用处理器已经是该锁的所有者，则此函数立即成功。

上下文

任何上下文。希望中断被禁用。

返回

成功时为 1，否则为 0。

void __printk_cpu_sync_put(void)¶: 释放 printk cpu 可重入自旋锁。

参数

void: 无参数

描述

调用处理器必须是该锁的所有者。

上下文

任何上下文。希望中断被禁用。

void panic(const char *fmt, ...)¶: 停止系统

参数

const char *fmt: 要打印的文本字符串
...: 可变参数

描述

显示一条消息，然后执行清理。此函数永远不会返回。

void add_taint(unsigned flag, enum lockdep_ok lockdep_ok)¶: 添加一个 taint 标志（如果尚未设置）。

参数

unsigned flag: TAINT_* 常量之一。
enum lockdep_ok lockdep_ok: 锁调试是否仍然 OK。

描述

如果发生了一些不好的事情，您将希望 **lockdebug_ok** = false，但对于一些值得注意但不具有破坏性的情况，可以将其设置为 true。

设备资源管理¶

void *__devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp, int nid, const char *name)¶: 分配设备资源数据

参数

dr_release_t release: devres 将与之关联的释放函数
size_t size: 分配大小
gfp_t gfp: 分配标志
int nid: NUMA 节点
const char *name: 资源的名称

描述

分配 **size** 字节的 devres。分配的区域被清零，然后与 **release** 关联。返回的指针可以传递给其他 devres_*() 函数。

返回

成功时指向分配的 devres 的指针，失败时为 NULL。

void devres_for_each_res(struct device *dev, dr_release_t release, dr_match_t match, void *match_data, void (*fn)(struct device*, void*, void*), void *data)¶: 资源迭代器

参数

struct device *dev: 从中迭代资源的设备
dr_release_t release: 查找与此释放函数关联的资源
dr_match_t match: 匹配函数（可选）
void *match_data: 匹配函数的数据
void (*fn)(struct device *, void *, void *): 为每个匹配的资源调用的函数。
void *data: **fn** 的数据，**fn** 的第三个参数

描述

为 **dev** 的每个与 **release** 关联且 **match** 返回 1 的 devres 调用 **fn**。

返回

void

void devres_free(void *res)¶: 释放设备资源数据

参数

void *res: 指向要释放的devres数据的指针

描述

释放使用 devres_alloc() 创建的 devres。

void devres_add(struct device *dev, void *res)¶: 注册设备资源

参数

struct device *dev: 要将资源添加到的设备
void *res: 要注册的资源

描述

将 devres res 注册到 dev。 res 应该使用 devres_alloc() 分配。在驱动程序分离时，将自动调用关联的释放函数并释放 devres。

void *devres_find(struct device *dev, dr_release_t release, dr_match_t match, void *match_data)¶: 查找设备资源

参数

struct device *dev: 从中查找资源的设备
dr_release_t release: 查找与此释放函数关联的资源
dr_match_t match: 匹配函数（可选）
void *match_data: 匹配函数的数据

描述

查找 dev 的最新 devres，它与 release 关联，并且 match 返回 1。如果 match 为 NULL，则认为匹配所有。

返回

指向找到的 devres 的指针，如果未找到则为 NULL。

void *devres_get(struct device *dev, void *new_res, dr_match_t match, void *match_data)¶: 查找 devres，如果不存在，则原子地添加一个

参数

struct device *dev: 要查找或添加 devres 的设备
void *new_res: 指向如果未找到则添加的新的初始化 devres 的指针
dr_match_t match: 匹配函数（可选）
void *match_data: 匹配函数的数据

描述

查找 dev 的最新 devres，它具有与 new_res 相同的释放函数，并且 match 返回 1。如果找到，则释放 new_res；否则，原子地添加 new_res。

返回

指向找到或添加的 devres 的指针。

void *devres_remove(struct device *dev, dr_release_t release, dr_match_t match, void *match_data)¶: 查找并删除设备资源

参数

struct device *dev: 从中查找资源的设备
dr_release_t release: 查找与此释放函数关联的资源
dr_match_t match: 匹配函数（可选）
void *match_data: 匹配函数的数据

描述

查找与 release 关联且 match 返回 1 的 dev 的最新 devres。如果 match 为 NULL，则认为匹配所有。如果找到，则原子地删除该资源并返回。

返回

成功时指向已删除的 devres 的指针，如果未找到则为 NULL。

int devres_destroy(struct device *dev, dr_release_t release, dr_match_t match, void *match_data)¶: 查找并销毁设备资源

参数

struct device *dev: 从中查找资源的设备
dr_release_t release: 查找与此释放函数关联的资源
dr_match_t match: 匹配函数（可选）
void *match_data: 匹配函数的数据

描述

查找与 release 关联且 match 返回 1 的 dev 的最新 devres。如果 match 为 NULL，则认为匹配所有。如果找到，则原子地删除并释放该资源。

请注意，不会调用该资源的释放函数，只会释放 devres 分配的数据。调用者负责释放任何其他数据。

返回

如果找到并释放 devres，则为 0，如果未找到则为 -ENOENT。

int devres_release(struct device *dev, dr_release_t release, dr_match_t match, void *match_data)¶: 查找设备资源并销毁它，调用 release

参数

struct device *dev: 从中查找资源的设备
dr_release_t release: 查找与此释放函数关联的资源
dr_match_t match: 匹配函数（可选）
void *match_data: 匹配函数的数据

描述

查找与 release 关联且 match 返回 1 的 dev 的最新 devres。如果 match 为 NULL，则认为匹配所有。如果找到，则原子地删除该资源，调用 release 函数并释放该资源。

返回

如果找到并释放 devres，则为 0，如果未找到则为 -ENOENT。

void *devres_open_group(struct device *dev, void *id, gfp_t gfp)¶: 打开新的 devres 组

参数

struct device *dev: 要为其打开 devres 组的设备
void *id: 分隔符 ID
gfp_t gfp: 分配标志

描述

为 dev 打开一个新的 devres 组，其中包含 id。对于 id，建议使用指向不会用于另一个组的对象的指针。如果 id 为 NULL，则创建地址唯一的 ID。

返回

新组的 ID，失败时为 NULL。

void devres_close_group(struct device *dev, void *id)¶: 关闭一个 devres 组

参数

struct device *dev: 要为其关闭 devres 组的设备
void *id: 目标组的 ID，可以为 NULL

描述

关闭由 id 标识的组。如果 id 为 NULL，则选择最新的打开组。

void devres_remove_group(struct device *dev, void *id)¶: 删除一个 devres 组

参数

struct device *dev: 要为其删除组的设备
void *id: 目标组的 ID，可以为 NULL

描述

删除由 id 标识的组。如果 id 为 NULL，则选择最新的打开组。请注意，删除组不会影响任何其他资源。

int devres_release_group(struct device *dev, void *id)¶: 释放 devres 组中的资源

参数

struct device *dev: 要为其释放组的设备
void *id: 目标组的 ID，可以为 NULL

描述

释放由 id 标识的组中的所有资源。如果 id 为 NULL，则选择最新的打开组。将删除选定的组和正确嵌套在选定组内的组。

返回

已释放的非组资源的数量。

int __devm_add_action(struct device *dev, void (*action)(void*), void *data, const char *name)¶: 将自定义操作添加到托管资源列表

参数

struct device *dev: 拥有该操作的设备
void (*action)(void *): 应调用的函数
void *data: 指向传递给 action 实现的数据的指针
const char *name: 资源的名称（用于调试目的）

描述

这将自定义操作添加到托管资源列表中，以便它作为标准资源展开的一部分执行。

int devm_remove_action_nowarn(struct device *dev, void (*action)(void*), void *data)¶: 删除先前添加的自定义操作

参数

struct device *dev: 拥有该操作的设备
void (*action)(void *): 实现该操作的函数
void *data: 指向传递给 action 实现的数据的指针

描述

删除先前由 devm_add_action() 添加的 action 的实例。action 和 data 都应与现有条目之一匹配。

与 devm_remove_action() 相比，如果没有找到任何条目，此函数不会 WARN()。

只有当 action 包含在具有独立生存期管理的对象中时，才应使用此函数，例如 Devres rust 抽象。

导致常规驱动程序代码发出警告很可能表明滥用了 devres API。

返回

成功时为 0，如果未找到任何条目，则为 -ENOENT。

void devm_release_action(struct device *dev, void (*action)(void*), void *data)¶: 释放先前添加的自定义操作

参数

struct device *dev: 拥有该操作的设备
void (*action)(void *): 实现该操作的函数
void *data: 指向传递给 action 实现的数据的指针

描述

释放并删除先前由 devm_add_action() 添加的 action 的实例。action 和 data 都应与现有条目之一匹配。

void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp)¶: 资源管理的 kmalloc

参数

struct device *dev: 为其分配内存的设备
size_t size: 分配大小
gfp_t gfp: 分配 gfp 标志

描述

托管的 kmalloc。使用此函数分配的内存将在驱动程序分离时自动释放。与所有其他 devres 资源一样，保证的对齐方式为 unsigned long long。

返回

成功时指向已分配内存的指针，失败时为 NULL。

void *devm_krealloc(struct device *dev, void *ptr, size_t new_size, gfp_t gfp)¶: 资源管理的 krealloc()

参数

struct device *dev: 为其重新分配内存的设备
void *ptr: 指向要重新分配的内存块的指针
size_t new_size: 新的分配大小
gfp_t gfp: 分配 gfp 标志

描述

托管的 krealloc()。调整使用 devm_kmalloc() 分配的内存块的大小。其行为类似于常规 krealloc()：如果 ptr 为 NULL 或 ZERO_SIZE_PTR，则等效于 devm_kmalloc()。如果 new_size 为零，它会释放先前分配的内存并返回 ZERO_SIZE_PTR。此函数不会更改将调用重新分配的 devres 的释放回调的顺序（除非回退到 devm_kmalloc() 或在 new_size 为零时释放资源）。内存的内容会保留到新旧大小中较小的一个。

char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp)¶: 分配资源管理的空间并将现有字符串复制到该空间中。

参数

struct device *dev: 为其分配内存的设备
const char *s: 要复制的字符串
gfp_t gfp: 在分配内存时在 devm_kmalloc() 调用中使用的 GFP 掩码

返回

成功时指向已分配字符串的指针，失败时为 NULL。

const char *devm_kstrdup_const(struct device *dev, const char *s, gfp_t gfp)¶: 资源管理的条件字符串复制

参数

struct device *dev: 要为其复制字符串的设备
const char *s: 要复制的字符串
gfp_t gfp: 在分配内存时在 kmalloc() 调用中使用的 GFP 掩码

描述

当分离关联的设备时，将自动释放由 devm_kstrdup_const 分配的字符串。

返回

如果源字符串位于 .rodata 段，则使用该字符串，否则回退到 devm_kstrdup。

char *devm_kvasprintf(struct device *dev, gfp_t gfp, const char *fmt, va_list ap)¶: 分配资源管理的空间，并将字符串格式化到该空间中。

参数

struct device *dev: 为其分配内存的设备
gfp_t gfp: 在分配内存时在 devm_kmalloc() 调用中使用的 GFP 掩码
const char *fmt: printf()-风格的格式字符串
va_list ap: 格式字符串的参数

返回

成功时指向已分配字符串的指针，失败时为 NULL。

char *devm_kasprintf(struct device *dev, gfp_t gfp, const char *fmt, ...)¶: 分配资源管理的空间，并将字符串格式化到该空间中。

参数

struct device *dev: 为其分配内存的设备
gfp_t gfp: 在分配内存时在 devm_kmalloc() 调用中使用的 GFP 掩码
const char *fmt: printf()-风格的格式字符串
...: 格式字符串的参数

返回

成功时指向已分配字符串的指针，失败时为 NULL。

void devm_kfree(struct device *dev, const void *p)¶: 资源管理的 kfree

参数

struct device *dev: 此内存所属的设备
const void *p: 要释放的内存

描述

释放使用 devm_kmalloc() 分配的内存。

void *devm_kmemdup(struct device *dev, const void *src, size_t len, gfp_t gfp)¶: 资源管理的 kmemdup

参数

struct device *dev: 此内存所属的设备
const void *src: 要复制的内存区域
size_t len: 内存区域长度
gfp_t gfp: 要使用的 GFP 掩码

描述

使用资源管理的 kmalloc 复制内存区域

unsigned long devm_get_free_pages(struct device *dev, gfp_t gfp_mask, unsigned int order)¶: 资源管理的 __get_free_pages

参数

struct device *dev: 为其分配内存的设备
gfp_t gfp_mask: 分配 gfp 标志
unsigned int order: 分配大小为 (1 << order) 页

描述

管理的 get_free_pages。使用此函数分配的内存会在驱动程序分离时自动释放。

返回

成功时返回已分配内存的地址，失败时返回 0。

void devm_free_pages(struct device *dev, unsigned long addr)¶: 资源管理的 free_pages

参数

struct device *dev: 此内存所属的设备
unsigned long addr: 要释放的内存

描述

释放使用 devm_get_free_pages() 分配的内存。与 free_pages 不同，无需提供 order。

void __percpu *__devm_alloc_percpu(struct device *dev, size_t size, size_t align)¶: 资源管理的 alloc_percpu

参数

struct device *dev: 要为其分配每 CPU 内存的设备
size_t size: 要分配的每 CPU 内存的大小
size_t align: 要分配的每 CPU 内存的对齐方式

描述

管理的 alloc_percpu。使用此函数分配的每 CPU 内存会在驱动程序分离时自动释放。

返回

成功时指向已分配内存的指针，失败时为 NULL。

void devm_free_percpu(struct device *dev, void __percpu *pdata)¶: 资源管理的 free_percpu

参数

struct device *dev: 此内存所属的设备
void __percpu *pdata: 要释放的每 CPU 内存

描述

释放使用 devm_alloc_percpu() 分配的内存。

Linux 内核

目录

本页

驱动程序基础¶

驱动程序入口和出口点¶

驱动程序设备表¶

延迟和调度例程¶

时间和定时器例程¶

高分辨率定时器¶

等待队列和唤醒事件¶

内部函数¶

引用计数¶

原子操作¶

内核对象操作¶

内核实用程序函数¶

设备资源管理¶