驱动程序基础¶

驱动程序入口和退出点¶

module_init¶

module_init (x)

驱动程序初始化入口点

参数

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

描述

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

module_exit¶

module_exit (x)

驱动程序退出入口点

参数

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

描述

当驱动程序是模块时，使用 rmmod 时，module_exit() 将使用 cleanup_module() 包装驱动程序清理代码。如果驱动程序是静态编译到内核中的，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 使用的隐含保护。通过使用 kernfs 的活动引用（请参阅 kernfs_active()），保证了 sysfs 存储/读取文件操作的存在，并且除非同一文件不处于活动状态，否则 sysfs / kernfs 文件移除不会发生。因此，如果正在读取或写入 sysfs 文件，则创建它的模块必须仍然存在。因此，在模块 sysfs 存储/读取操作中使用 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 类型。请参阅枚举 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/class_mask，因为通常 vendor/device 就足够了。
class_mask: 限制比较 class 字段的哪些子字段。
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)¶: 当当前进程被抢占和重新调度时通知我

参数

struct preempt_notifier *notifier: 要注册的通知程序结构

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

参数

struct preempt_notifier *notifier: 要取消注册的通知程序结构

描述

在抢占通知器中调用此函数是不安全的。

__visible void notrace preempt_schedule_notrace(void)¶: 由跟踪调用的 preempt_schedule

参数

void: 无参数

描述

跟踪基础架构使用 preempt_enable_notrace 来防止递归和由跟踪基础架构本身引起的跟踪抢占启用。但是，由于跟踪可能发生在来自用户空间或即将进入用户空间的区域中，因此可能会在调用 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，我们使用微分更新来存储我们传播的最后一个值。反过来，如果差值“小”，则允许跳过更新。

在 update_cfs_share() 之前，必须更新 tg 的 load_avg。

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 表示启用提升，否则为 0

描述

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

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

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

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

由于舍入误差以及任务迁移或新任务唤醒，CPU 利用率可能高于当前的 CPU 容量（f_curr/f_max * 最大 CPU 容量），甚至高于最大 CPU 容量。CPU 利用率必须限制在 [0..最大 CPU 容量] 范围内。否则，一组 CPU（CPU0 利用率 = 121% + CPU1 利用率 = 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 结构

参数

work: completion 结构的标识符

描述

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

DECLARE_COMPLETION_ONSTACK¶

DECLARE_COMPLETION_ONSTACK (work)

声明并初始化一个 completion 结构

参数

work: 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 的值] 也表示“无限超时”。
所有其他值都通过将输入值乘以一个因子或除以一个因子来转换为节拍数，并像处理 msecs_to_jiffies 一样处理任何 32 位溢出。

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 值

返回

转换为 clock_t (CLOCKS_PER_SEC) 的节拍数 (jiffies)

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”（CLOCKS_PER_SEC）的 jiffies_64 值

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 中的纳秒转换为 jiffies64

参数

u64 n: u64 中的纳秒

描述

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

注意

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

返回

转换为 jiffies64 值的纳秒

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

参数

u64 n: u64 中的纳秒

描述

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

注意

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

返回

转换为 jiffies 值的纳秒

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(unsigned long j, int cpu)¶: 将节拍数四舍五入到整秒的函数

参数

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

描述

__round_jiffies() 将未来（以节拍数表示）的绝对时间向上或向下舍入到（大约）整秒。这对于那些触发的确切时间不太重要，只要它们大约每 X 秒触发一次的计时器很有用。

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

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

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

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(unsigned long j, int cpu)¶: 将节拍数向上舍入到整秒的函数

参数

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

描述

这与 __round_jiffies() 相同，只是它永远不会向下舍入。这对于那些触发的确切时间不太重要，只要它们不会太早触发的超时很有用。

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 init_timer_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: 用于跟踪定时器同步锁依赖关系的伪锁的锁依赖类键

描述

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

int mod_timer_pending(struct timer_list *timer, unsigned long expires)¶: 修改待处理定时器的超时时间

参数

struct timer_list *timer: 要修改的待处理定时器
unsigned long expires: 以jiffies为单位的新的绝对超时时间

描述

对于待处理的定时器，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: 以jiffies为单位的新的绝对超时时间

描述

mod_timer(timer, expires) 等效于

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

mod_timer() 比上述开放编码序列效率更高。如果定时器处于非活动状态，则 del_timer() 部分为 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: 以jiffies为单位的新的绝对超时时间

描述

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 是以“jiffies”为单位测量的绝对到期时间。当定时器到期时，将从软中断上下文中调用 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 try_to_del_timer_sync(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)；仅出于调试目的才考虑基于软中断的模式！

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)；仅出于调试目的才考虑基于软中断的模式！

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_init(struct hrtimer *timer, clockid_t clock_id, enum hrtimer_mode mode)¶: 使用给定的时钟初始化定时器

参数

struct hrtimer *timer

要初始化的定时器

clockid_t clock_id

要使用的时钟

enum hrtimer_mode mode

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

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

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 位，因为固定发生在 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: 要启动的休眠器
enum hrtimer_mode mode: 定时器模式 abs/rel

描述

围绕 hrtimer_start_expires() 的封装，用于基于 hrtimer_sleeper 的定时器，允许 PREEMPT_RT 调整传递模式（软/硬中断上下文）。

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

参数

struct hrtimer_sleeper *sl: 要初始化的休眠器。
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 存储之上，这样我们会在等待者可能没有观察到 cond 的情况下观察到一个空的等待列表。

还要注意，这种“优化”将 spin_lock() 换成了 smp_mb()，（当锁没有争用时）它们的成本大致相等。

注意

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

bool wq_has_single_sleeper(struct wait_queue_head *wq_head)¶: 检查是否只有一个休眠者。

参数

struct wait_queue_head *wq_head: 等待队列头。

描述

如果 wq_head 的列表上只有一个休眠者，则返回 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 延迟释放 wait_queue_head，例如，通过显式的 synchronize_rcu() 或 call_rcu()，或通过 SLAB_TYPESAFE_BY_RCU。

wait_event¶

wait_event (wq_head, condition)

睡眠直到条件变为 true。

参数

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

描述

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

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

wait_event_freezable¶

wait_event_freezable (wq_head, condition)

睡眠（或冻结）直到条件变为 true。

参数

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

描述

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

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

wait_event_timeout¶

wait_event_timeout (wq_head, condition, timeout)

睡眠直到条件变为 true 或超时时间结束。

参数

wq_head: 要等待的等待队列。
condition: 要等待的事件的 C 表达式。
timeout: 超时时间，以 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)

睡眠直到条件变为 true。

参数

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

描述

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

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

wait_event_interruptible¶

wait_event_interruptible (wq_head, condition)

睡眠直到条件变为 true。

参数

wq_head: 要等待的等待队列。
condition: 要等待的事件的 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)

睡眠直到条件变为 true 或超时时间结束。

参数

wq_head: 要等待的等待队列。
condition: 要等待的事件的 C 表达式。
timeout: 超时时间，以 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)

睡眠直到条件变为 true 或超时时间结束。

参数

wq_head: 要等待的等待队列。
condition: 要等待的事件的 C 表达式。
timeout: 超时时间，以 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)

睡眠直到条件变为 true 或超时时间结束。

参数

wq: 要等待的等待队列。
condition: 要等待的事件的 C 表达式。
timeout: 超时时间，以 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: 要等待的等待队列。
condition: 要等待的事件的 C 表达式。

描述

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

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

wait_event_idle_exclusive¶

wait_event_idle_exclusive (wq_head, condition)

等待条件成立，且不增加系统负载。

参数

wq_head: 要等待的等待队列。
condition: 要等待的事件的 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)

休眠直到条件为真或超时，且不增加系统负载。

参数

wq_head: 要等待的等待队列。
condition: 要等待的事件的 C 表达式。
timeout: 超时时间，以 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)

休眠直到条件为真或超时，且不增加系统负载。

参数

wq_head: 要等待的等待队列。
condition: 要等待的事件的 C 表达式。
timeout: 超时时间，以 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)

睡眠直到条件变为 true。

参数

wq: 要等待的等待队列。
condition: 要等待的事件的 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)

睡眠直到条件变为 true。

参数

wq: 要等待的等待队列。
condition: 要等待的事件的 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: 要等待的等待队列。
condition: 要等待的事件的 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)

睡眠直到条件变为 true。

参数

wq: 要等待的等待队列。
condition: 要等待的事件的 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)

睡眠直到条件变为 true。

参数

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

描述

该进程进入休眠状态 (TASK_KILLABLE)，直到 **condition** 的值为 true 或收到信号。每次唤醒等待队列 **wq_head** 时，都会检查 **condition**。

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

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

wait_event_state¶

wait_event_state (wq_head, condition, state)

睡眠直到条件变为 true。

参数

wq_head: 要等待的等待队列。
condition: 要等待的事件的 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)

睡眠直到条件变为 true 或超时时间结束。

参数

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

描述

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

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

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

返回

如果在 **timeout** 结束后 **condition** 的值为 false，则返回 0；如果在 **timeout** 结束后 **condition** 的值为 true，则返回 1；如果在 **timeout** 结束前 **condition** 的值为 true，则返回剩余的时间滴答数（至少为 1）；如果被 kill 信号中断，则返回 -ERESTARTSYS。

wait_event_lock_irq_cmd¶

wait_event_lock_irq_cmd (wq_head, condition, lock, cmd)

休眠直到条件为真。该条件在锁下检查。预计在持有锁的情况下调用。

参数

wq_head: 要等待的等待队列。
condition: 要等待的事件的 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: 要等待的等待队列。
condition: 要等待的事件的 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: 要等待的等待队列。
condition: 要等待的事件的 C 表达式。
lock: 一个锁定的 spinlock_t，在 cmd 和 schedule() 之前释放，之后重新获取。
cmd: 在休眠之前，在临界区之外调用的命令

描述

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

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

这应该在持有锁的情况下调用。在调用 cmd 并进入休眠状态之前，该锁被释放，之后重新获取。

如果被信号中断，该宏将返回 -ERESTARTSYS，如果 **condition** 的值为 true，则返回 0。

wait_event_interruptible_lock_irq¶

wait_event_interruptible_lock_irq (wq_head, condition, lock)

休眠直到条件为真。该条件在锁下检查。预计在持有锁的情况下调用。

参数

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

描述

该进程进入休眠状态 (TASK_INTERRUPTIBLE)，直到 **condition** 的值为 true 或收到信号。每次唤醒等待队列 **wq_head** 时，都会检查 **condition**。

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

这应该在持有锁的情况下调用。在进入休眠状态之前，该锁被释放，之后重新获取。

如果被信号中断，该宏将返回 -ERESTARTSYS，如果 **condition** 的值为 true，则返回 0。

wait_event_interruptible_lock_irq_timeout¶

wait_event_interruptible_lock_irq_timeout (wq_head, condition, lock, timeout)

休眠直到条件为真或超时。该条件在锁下检查。预计在持有锁的情况下调用。

参数

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

描述

该进程进入休眠状态 (TASK_INTERRUPTIBLE)，直到 **condition** 的值为 true 或收到信号。每次唤醒等待队列 **wq_head** 时，都会检查 **condition**。

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

这应该在持有锁的情况下调用。在进入休眠状态之前，该锁被释放，之后重新获取。

如果 **timeout** 结束，则函数返回 0；如果被信号中断，则返回 -ERESTARTSYS；否则，如果条件在超时结束前为真，则返回剩余的时间滴答数。

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: 唤醒多少个唤醒一个或唤醒多个线程
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: 要传递给唤醒目标的 opaque 值

描述

同步唤醒的不同之处在于，唤醒器知道它将很快被调度离开，因此，虽然目标线程将被唤醒，但它不会被迁移到另一个 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: 要传递给唤醒目标的 opaque 值

描述

同步唤醒的不同之处在于，唤醒者知道它很快就会被调度走，因此，当目标线程被唤醒时，它不会被迁移到另一个 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 的子集。如果要设置 stop signo，则会清除现有的 signo。如果 task 已经正在被杀死或退出，则此函数变为无操作。

上下文

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

返回

如果设置了 mask，则为 true；如果因为 task 正在消亡而变为无操作，则为 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: 想要通知跟踪器的被跟踪者

描述

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

如果 t 正在运行，则会发生 STOP 陷阱。如果因为 STOP 而被捕获，并且 ptracer 正在侦听事件，则会唤醒被跟踪者，以便它可以为新事件重新捕获。如果以其他方式被捕获，则在 PTRACE_CONT 完成现有陷阱后，最终会发生 STOP 陷阱，而不会返回到用户空间。

上下文

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

int force_sig_seccomp(int syscall, int reason, bool force_coredump)¶: 向任务发送信号以允许进程内系统调用仿真

参数

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

描述

强制发送一个代码为 SYS_SECCOMP 和相关 sigsys 信息的 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 发起组停止并参与其中。如果已设置，则参与现有的组停止。如果参与了组停止（并因此休眠），则会释放 siglock 并返回 true。

如果被 ptraced，此函数本身不处理停止。相反，会调度 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: 如果为非 null，则为信号掩码的先前值
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 用户 siginfo 中

参数

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

注意

此函数不适用于 x32 上的 SIGCHLD，但幸运的是它不必如此。此函数的唯一有效调用方是 copy_siginfo_to_user32，它为 x32 和 coredump 代码重写。后者并不关心，因为 SIGCHLD 永远不会导致 core dump。

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: 如果为非 null，则为信号掩码的先前值

描述

某些平台有自己的特殊参数版本；其他平台仅支持 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)。

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

参数

void: 无参数

描述

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

bool kthread_should_park(void)¶: 此 kthread 现在应该暂停吗？

参数

void: 无参数

描述

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

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

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

参数

bool *was_frozen: 可选的输出参数，指示 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: 要完成的 Completion
long code: 要返回到 kthread_stop() 的整数值。

描述

如果存在，则完成 comp，然后将 code 返回到 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() 创建的线程。

描述

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

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

参数

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

描述

设置 k 的 kthread_should_park() 返回 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() 创建的线程。

描述

设置 k 的 kthread_should_stop() 返回 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)¶: 停止线程并释放其 task struct

参数

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

描述

停止由 kthread_create() 创建的线程，并释放其 task_struct。仅当持有通过调用 get_task_struct() 获取的额外的 task struct 引用时才使用。

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

参数

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

描述

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

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

此外，不允许同时由多个工作器处理这些工作，另请参阅 kthread_queue_work()。

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

参数

unsigned int flags: 修改工作器默认行为的标志
const char namefmt[]: kthread worker（任务）的 printf 风格的名称。
...: 可变参数

描述

成功时返回指向已分配的工作器的指针，当无法分配所需结构时返回 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: 修改工作器默认行为的标志
const char namefmt[]: kthread worker（任务）的 printf 风格的名称。
...: 可变参数

描述

如果您想将 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 处于关闭状态，则工作器可能不存在。

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

返回

成功时返回指向已分配的工作器的指针，当无法分配所需结构时返回 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_worker_create() 创建。如果 work 已成功排队，则返回 true，如果它已挂起，则返回 false。

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

void kthread_delayed_work_timer_fn(struct timer_list *t)¶: 当计时器到期时，将关联的 kthread 延迟工作排队的 callback。

参数

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

描述

该函数的格式由 struct timer_list 定义。它应该已从 irqsafe 计时器调用，并且已关闭 irq。

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: 在排队之前等待的 jiffies 数

描述

如果工作尚未挂起，它将启动一个计时器，该计时器将在给定的 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 worker
struct kthread_delayed_work *dwork: 要排队的 kthread 延迟工作
unsigned long delay: 在排队之前等待的 jiffies 数

描述

如果 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 排队的 worker 不会被销毁。

返回

如果 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

描述

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

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

参数

struct kthread_worker *worker: 要销毁的 worker

描述

刷新并销毁 worker。简单的刷新就足够了，因为 kthread worker 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: 引用计数将被设置为的值

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

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

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 处饱和时将无法递减。

提供释放内存排序，使得之前的加载和存储操作在当前操作之前完成，并且在成功时提供获取排序，使得 free() 操作必须在当前操作之后执行。

不建议在通常的引用计数用例中使用此函数，在这些用例中，引用是一次获取和释放一个的。在这些情况下，应该使用 refcount_dec() 或其变体之一来递减引用计数。

返回

如果结果引用计数为 0，则为 true；否则为 false。

bool refcount_dec_and_test(refcount_t *r)¶: 递减引用计数并测试是否为 0

参数

refcount_t *r: 引用计数

描述

与 atomic_dec_and_test() 类似，当发生下溢时会发出警告，并且当饱和到 REFCOUNT_SATURATED 时无法递减。

提供释放内存排序，使得之前的加载和存储操作在当前操作之前完成，并且在成功时提供获取排序，使得 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 的转换并返回转换是否成功。

像所有递减操作一样，它提供释放内存排序并提供控制依赖。

它可以像 try-delete 操作符一样使用；提供了这个显式的情况，而不是通用的 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 标志

描述

与上面的 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: 要减去的整数值
atomic_t *v: 指向 atomic_t 的指针

描述

以松弛顺序原子更新 v 为 (v - i)。

在 noinstr 代码中不安全使用；请在那里使用 raw_atomic_sub()。

返回

无。

int atomic_sub_return(int i, atomic_t *v)¶: 带完全顺序的原子减操作

参数

int i: 要减去的整数值
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: 要减去的整数值
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: 要减去的整数值
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: 要减去的整数值
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: 要减去的整数值
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: 要减去的整数值
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: 要减去的整数值
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: 要减去的整数值
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: 整数值
atomic_t *v: 指向 atomic_t 的指针

描述

原子地将 v 更新为 (v & i)，使用宽松的排序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_and()。

返回

无。

int atomic_fetch_and(int i, atomic_t *v)¶: 原子按位与，使用完整排序

参数

int i: 整数值
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: 整数值
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: 整数值
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: 整数值
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: 整数值
atomic_t *v: 指向 atomic_t 的指针

描述

原子地将 v 更新为 (v & ~i)，使用宽松的排序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_andnot()。

返回

无。

int atomic_fetch_andnot(int i, atomic_t *v)¶: 原子按位与非，使用完整排序

参数

int i: 整数值
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: 整数值
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: 整数值
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: 整数值
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: 整数值
atomic_t *v: 指向 atomic_t 的指针

描述

原子地将 v 更新为 (v | i)，使用宽松的排序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_or()。

返回

无。

int atomic_fetch_or(int i, atomic_t *v)¶: 原子按位或，使用完整排序

参数

int i: 整数值
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: 整数值
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: 整数值
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: 整数值
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: 整数值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式将 v 更新为 (v ^ i)，使用宽松排序。

在 noinstr 代码中使用是不安全的；请在此处使用 raw_atomic_xor()。

返回

无。

int atomic_fetch_xor(int i, atomic_t *v)¶: 原子按位异或操作，使用完全排序。

参数

int i: 整数值
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: 整数值
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: 整数值
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: 整数值
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)，则以释放排序原子地将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供宽松排序。

在 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)，则以宽松排序原子地将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供宽松排序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_try_cmpxchg_relaxed()。

返回

如果发生交换，则返回 true，否则返回 false。

bool atomic_sub_and_test(int i, atomic_t *v)¶: 原子减法并测试是否为零，使用完整排序

参数

int i: 要减去的整数值
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)¶: 原子递减并测试是否为零，使用完整排序

参数

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)¶: 原子递增并测试是否为零，使用完整排序

参数

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)¶: 原子加法并测试是否为负数，使用完整排序

参数

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)¶: 原子加法并测试是否为负数，使用获取排序

参数

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)¶: 原子加法并测试是否为负数，使用释放排序

参数

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)¶: 原子加法并测试是否为负数，使用宽松排序

参数

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)¶: 原子加法，除非值与指定值相等，使用完整排序

参数

atomic_t *v: 指向 atomic_t 的指针
int a: 要添加的 int 值
int u: 用于比较的整数值。

描述

如果 (v != u)，则以完整排序原子地将 v 更新为 (v + a)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_fetch_add_unless()。

返回

v 的原始值。

bool atomic_add_unless(atomic_t *v, int a, int u)¶: 原子加法，除非值与指定值相等，使用完整排序

参数

atomic_t *v: 指向 atomic_t 的指针
int a: 要添加的 int 值
int u: 用于比较的整数值。

描述

如果 (v != u)，则以完整排序原子地将 v 更新为 (v + a)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中使用是不安全的；请在那里使用 raw_atomic_add_unless()。

返回

如果 v 被更新，则为 true，否则为 false。

bool atomic_inc_not_zero(atomic_t *v)¶: 原子递增，除非为零，使用完整排序

参数

atomic_t *v: 指向 atomic_t 的指针

描述

如果 (v != 0)，则以完整排序原子地将 v 更新为 (v + 1)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_inc_not_zero()。

返回

如果 v 被更新，则为 true，否则为 false。

bool atomic_inc_unless_negative(atomic_t *v)¶: 原子递增，除非为负数，并具有完整排序

参数

atomic_t *v: 指向 atomic_t 的指针

描述

如果 (v >= 0)，则以原子方式将 v 更新为 (v + 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_inc_unless_negative()。

返回

如果 v 被更新，则为 true，否则为 false。

bool atomic_dec_unless_positive(atomic_t *v)¶: 原子递减，除非为正数，并具有完整排序

参数

atomic_t *v: 指向 atomic_t 的指针

描述

如果 (v <= 0)，则以原子方式将 v 更新为 (v - 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_dec_unless_positive()。

返回

如果 v 被更新，则为 true，否则为 false。

int atomic_dec_if_positive(atomic_t *v)¶: 如果为正数则原子递减，并具有完整排序

参数

atomic_t *v: 指向 atomic_t 的指针

描述

如果 (v > 0)，则以原子方式将 v 更新为 (v - 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

在 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)，则以释放排序原子地将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供宽松排序。

在 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)，则以宽松排序原子地将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供宽松排序。

在 noinstr 代码中不安全；请在此处使用 raw_atomic64_try_cmpxchg_relaxed()。

返回

如果发生交换，则返回 true，否则返回 false。

bool atomic64_sub_and_test(s64 i, atomic64_t *v)¶: 原子减法并测试是否为零，使用完整排序

参数

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)¶: 原子递减并测试是否为零，使用完整排序

参数

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)¶: 原子递增并测试是否为零，使用完整排序

参数

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)¶: 原子加法并测试是否为负数，使用完整排序

参数

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)¶: 原子加法并测试是否为负数，使用获取排序

参数

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)¶: 原子加法并测试是否为负数，使用释放排序

参数

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)¶: 原子加法并测试是否为负数，使用宽松排序

参数

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)¶: 原子加法，除非值与指定值相等，使用完整排序

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 a: 要添加的 s64 值
s64 u: 用于比较的s64值

描述

如果 (v != u)，则以完整排序原子地将 v 更新为 (v + a)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中不安全；请在此处使用 raw_atomic64_fetch_add_unless()。

返回

v 的原始值。

bool atomic64_add_unless(atomic64_t *v, s64 a, s64 u)¶: 原子加法，除非值与指定值相等，使用完整排序

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 a: 要添加的 s64 值
s64 u: 用于比较的s64值

描述

如果 (v != u)，则以完整排序原子地将 v 更新为 (v + a)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中使用是不安全的；请在此处使用 raw_atomic64_add_unless()。

返回

如果 v 被更新，则为 true，否则为 false。

bool atomic64_inc_not_zero(atomic64_t *v)¶: 原子递增，除非为零，使用完整排序

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

如果 (v != 0)，则以完整排序原子地将 v 更新为 (v + 1)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中使用是不安全的；请在此处使用 raw_atomic64_inc_not_zero()。

返回

如果 v 被更新，则为 true，否则为 false。

bool atomic64_inc_unless_negative(atomic64_t *v)¶: 原子递增，除非为负数，并具有完整排序

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

如果 (v >= 0)，则以原子方式将 v 更新为 (v + 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中使用是不安全的；请在此处使用 raw_atomic64_inc_unless_negative()。

返回

如果 v 被更新，则为 true，否则为 false。

bool atomic64_dec_unless_positive(atomic64_t *v)¶: 原子递减，除非为正数，并具有完整排序

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

如果 (v <= 0)，则以原子方式将 v 更新为 (v - 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中使用是不安全的；请在此处使用 raw_atomic64_dec_unless_positive()。

返回

如果 v 被更新，则为 true，否则为 false。

s64 atomic64_dec_if_positive(atomic64_t *v)¶: 如果为正数则原子递减，并具有完整排序

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

如果 (v > 0)，则以原子方式将 v 更新为 (v - 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

在 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: 要减去的 long 值
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: 要减去的 long 值
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: 要减去的 long 值
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: 要减去的 long 值
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: 要减去的 long 值
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: 要减去的 long 值
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: 要减去的 long 值
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: 要减去的 long 值
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: 要减去的 long 值
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)。

在无指令代码中使用是不安全的；请在那里使用 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)。

在无指令代码中使用是不安全的；请在那里使用 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)。

在无指令代码中使用是不安全的；请在那里使用 raw_atomic_long_dec()。

返回

无。

long atomic_long_dec_return(atomic_long_t *v)¶: 具有完全排序的原子递减

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用完全排序将 v 更新为 (v - 1)。

在无指令代码中使用是不安全的；请在那里使用 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)。

在无指令代码中使用是不安全的；请在那里使用 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)。

在无指令代码中使用是不安全的；请在那里使用 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)。

在无指令代码中使用是不安全的；请在那里使用 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)。

在无指令代码中使用是不安全的；请在那里使用 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)。

在无指令代码中使用是不安全的；请在那里使用 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)。

在无指令代码中使用是不安全的；请在那里使用 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)。

在无指令代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_dec_relaxed()。

返回

v 的原始值。

void atomic_long_and(long i, atomic_long_t *v)¶: 原子按位与，使用宽松的排序

参数

long i: 长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

原子地将 v 更新为 (v & i)，使用宽松的排序。

在无指令代码中使用是不安全的；请在那里使用 raw_atomic_long_and()。

返回

无。

long atomic_long_fetch_and(long i, atomic_long_t *v)¶: 原子按位与，使用完整排序

参数

long i: 长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

原子地将 v 更新为 (v & i)，使用完整排序。

在无指令代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_and()。

返回

v 的原始值。

long atomic_long_fetch_and_acquire(long i, atomic_long_t *v)¶: 原子按位与，使用获取排序

参数

long i: 长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

原子地将 v 更新为 (v & i)，使用获取排序。

在无指令代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_and_acquire()。

返回

v 的原始值。

long atomic_long_fetch_and_release(long i, atomic_long_t *v)¶: 原子按位与，使用释放排序

参数

long i: 长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

原子地将 v 更新为 (v & i)，使用释放排序。

在无指令代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_and_release()。

返回

v 的原始值。

long atomic_long_fetch_and_relaxed(long i, atomic_long_t *v)¶: 原子按位与，使用宽松的排序

参数

long i: 长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

原子地将 v 更新为 (v & i)，使用宽松的排序。

在无指令代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_and_relaxed()。

返回

v 的原始值。

void atomic_long_andnot(long i, atomic_long_t *v)¶: 原子按位与非，使用宽松的排序

参数

long i: 长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

原子地将 v 更新为 (v & ~i)，使用宽松的排序。

在无指令代码中使用是不安全的；请在那里使用 raw_atomic_long_andnot()。

返回

无。

long atomic_long_fetch_andnot(long i, atomic_long_t *v)¶: 原子按位与非，使用完整排序

参数

long i: 长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

原子地将 v 更新为 (v & ~i)，使用完整排序。

在无指令代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_andnot()。

返回

v 的原始值。

long atomic_long_fetch_andnot_acquire(long i, atomic_long_t *v)¶: 原子按位与非，使用获取排序

参数

long i: 长整型值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

原子地将 v 更新为 (v & ~i)，使用获取排序。

在无指令代码中使用是不安全的；请在那里使用 raw_atomic_long_fetch_andnot_acquire()。

返回

v 的原始值。

long atomic_long_fetch_andnot_release(long i, atomic_long_t *v)¶: 原子按位与非，使用释放排序

参数

long i: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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)，则以释放排序原子地将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供宽松排序。

在 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)，则以宽松排序原子地将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供宽松排序。

在 noinstr 代码中使用是不安全的；请在此处使用 raw_atomic_long_try_cmpxchg_relaxed()。

返回

如果发生交换，则返回 true，否则返回 false。

bool atomic_long_sub_and_test(long i, atomic_long_t *v)¶: 原子减法并测试是否为零，使用完整排序

参数

long i: 要减去的 long 值
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)¶: 原子递减并测试是否为零，使用完整排序

参数

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)¶: 原子递增并测试是否为零，使用完整排序

参数

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)¶: 原子加法并测试是否为负数，使用完整排序

参数

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)¶: 原子加法并测试是否为负数，使用获取排序

参数

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)¶: 原子加法并测试是否为负数，使用释放排序

参数

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)¶: 原子加法并测试是否为负数，使用宽松排序

参数

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)¶: 原子加法，除非值与指定值相等，使用完整排序

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long a: 要加的 long 值
long u: 用于比较的 long 值

描述

如果 (v != u)，则以完整排序原子地将 v 更新为 (v + a)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中使用是不安全的；请在此处使用 raw_atomic_long_fetch_add_unless()。

返回

v 的原始值。

bool atomic_long_add_unless(atomic_long_t *v, long a, long u)¶: 原子加法，除非值与指定值相等，使用完整排序

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long a: 要加的 long 值
long u: 用于比较的 long 值

描述

如果 (v != u)，则以完整排序原子地将 v 更新为 (v + a)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中使用是不安全的；请在此处使用 raw_atomic_long_add_unless()。

返回

如果 v 被更新，则为 true，否则为 false。

bool atomic_long_inc_not_zero(atomic_long_t *v)¶: 原子递增，除非为零，使用完整排序

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

如果 (v != 0)，则以完整排序原子地将 v 更新为 (v + 1)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中使用是不安全的；请在此处使用 raw_atomic_long_inc_not_zero()。

返回

如果 v 被更新，则为 true，否则为 false。

bool atomic_long_inc_unless_negative(atomic_long_t *v)¶: 原子递增，除非为负数，并具有完整排序

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

如果 (v >= 0)，则以原子方式将 v 更新为 (v + 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_inc_unless_negative()。

返回

如果 v 被更新，则为 true，否则为 false。

bool atomic_long_dec_unless_positive(atomic_long_t *v)¶: 原子递减，除非为正数，并具有完整排序

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

如果 (v <= 0)，则以原子方式将 v 更新为 (v - 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中使用不安全；请在那里使用 raw_atomic_long_dec_unless_positive()。

返回

如果 v 被更新，则为 true，否则为 false。

long atomic_long_dec_if_positive(atomic_long_t *v)¶: 如果为正数则原子递减，并具有完整排序

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

如果 (v > 0)，则以原子方式将 v 更新为 (v - 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

在 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: 要减去的整数值
atomic_t *v: 指向 atomic_t 的指针

描述

以松弛顺序原子更新 v 为 (v - i)。

在 noinstr 代码中可以安全使用；其他情况下首选 atomic_sub()。

返回

无。

int raw_atomic_sub_return(int i, atomic_t *v)¶: 带完全顺序的原子减操作

参数

int i: 要减去的整数值
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: 要减去的整数值
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: 要减去的整数值
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: 要减去的整数值
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: 要减去的整数值
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: 要减去的整数值
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: 要减去的整数值
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: 要减去的整数值
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: 整数值
atomic_t *v: 指向 atomic_t 的指针

描述

原子地将 v 更新为 (v & i)，使用宽松的排序。

在 noinstr 代码中可以安全使用；在其他地方，请优先使用 atomic_and()。

返回

无。

int raw_atomic_fetch_and(int i, atomic_t *v)¶: 原子按位与，使用完整排序

参数

int i: 整数值
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: 整数值
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: 整数值
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: 整数值
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: 整数值
atomic_t *v: 指向 atomic_t 的指针

描述

原子地将 v 更新为 (v & ~i)，使用宽松的排序。

在 noinstr 代码中可以安全使用；在其他地方，请优先使用 atomic_andnot()。

返回

无。

int raw_atomic_fetch_andnot(int i, atomic_t *v)¶: 原子按位与非，使用完整排序

参数

int i: 整数值
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: 整数值
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: 整数值
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: 整数值
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: 整数值
atomic_t *v: 指向 atomic_t 的指针

描述

原子地将 v 更新为 (v | i)，使用宽松的排序。

在 noinstr 代码中可以安全使用；在其他地方，请优先使用 atomic_or()。

返回

无。

int raw_atomic_fetch_or(int i, atomic_t *v)¶: 原子按位或，使用完整排序

参数

int i: 整数值
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: 整数值
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: 整数值
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: 整数值
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: 整数值
atomic_t *v: 指向 atomic_t 的指针

描述

以原子方式将 v 更新为 (v ^ i)，使用宽松排序。

可在 noinstr 代码中使用；在其他地方，请优先使用 atomic_xor()。

返回

无。

int raw_atomic_fetch_xor(int i, atomic_t *v)¶: 原子按位异或操作，使用完全排序。

参数

int i: 整数值
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: 整数值
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: 整数值
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: 整数值
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)，则以释放排序原子地将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供宽松排序。

在 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)，则以宽松排序原子地将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供宽松排序。

在 noinstr 代码中可以安全使用；其他情况下，首选 atomic_try_cmpxchg_relaxed()。

返回

如果发生交换，则返回 true，否则返回 false。

bool raw_atomic_sub_and_test(int i, atomic_t *v)¶: 原子减法并测试是否为零，使用完整排序

参数

int i: 要减去的整数值
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)¶: 原子递减并测试是否为零，使用完整排序

参数

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)¶: 原子递增并测试是否为零，使用完整排序

参数

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)¶: 原子加法并测试是否为负数，使用完整排序

参数

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)¶: 原子加法并测试是否为负数，使用获取排序

参数

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)¶: 原子加法并测试是否为负数，使用释放排序

参数

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)¶: 原子加法并测试是否为负数，使用宽松排序

参数

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)¶: 原子加法，除非值与指定值相等，使用完整排序

参数

atomic_t *v: 指向 atomic_t 的指针
int a: 要添加的 int 值
int u: 用于比较的整数值。

描述

如果 (v != u)，则以完整排序原子地将 v 更新为 (v + a)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中可以安全使用；其他情况下，首选 atomic_fetch_add_unless()。

返回

v 的原始值。

bool raw_atomic_add_unless(atomic_t *v, int a, int u)¶: 原子加法，除非值与指定值相等，使用完整排序

参数

atomic_t *v: 指向 atomic_t 的指针
int a: 要添加的 int 值
int u: 用于比较的整数值。

描述

如果 (v != u)，则以完整排序原子地将 v 更新为 (v + a)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中可以安全使用；其他情况下，首选 atomic_add_unless()。

返回

如果 v 被更新，则为 true，否则为 false。

bool raw_atomic_inc_not_zero(atomic_t *v)¶: 原子递增，除非为零，使用完整排序

参数

atomic_t *v: 指向 atomic_t 的指针

描述

如果 (v != 0)，则以完整排序原子地将 v 更新为 (v + 1)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中可以安全使用；其他情况下，首选 atomic_inc_not_zero()。

返回

如果 v 被更新，则为 true，否则为 false。

bool raw_atomic_inc_unless_negative(atomic_t *v)¶: 原子递增，除非为负数，并具有完整排序

参数

atomic_t *v: 指向 atomic_t 的指针

描述

如果 (v >= 0)，则以原子方式将 v 更新为 (v + 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中可以安全使用；其他情况下，首选 atomic_inc_unless_negative()。

返回

如果 v 被更新，则为 true，否则为 false。

bool raw_atomic_dec_unless_positive(atomic_t *v)¶: 原子递减，除非为正数，并具有完整排序

参数

atomic_t *v: 指向 atomic_t 的指针

描述

如果 (v <= 0)，则以原子方式将 v 更新为 (v - 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

可在 noinstr 代码中使用；其他情况下请优先使用 atomic_dec_unless_positive()。

返回

如果 v 被更新，则为 true，否则为 false。

int raw_atomic_dec_if_positive(atomic_t *v)¶: 如果为正数则原子递减，并具有完整排序

参数

atomic_t *v: 指向 atomic_t 的指针

描述

如果 (v > 0)，则以原子方式将 v 更新为 (v - 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

可在 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)。

可在 noinstr 代码中使用；其他情况下请优先使用 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)。

可在 noinstr 代码中使用；其他情况下请优先使用 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)。

可在 noinstr 代码中使用；其他情况下请优先使用 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)。

可在 noinstr 代码中使用；其他情况下请优先使用 atomic64_sub()。

返回

无。

s64 raw_atomic64_sub_return(s64 i, atomic64_t *v)¶: 带完全顺序的原子减操作

参数

s64 i: 要减去的值，类型为 s64。
atomic64_t *v: 指向 atomic64_t 的指针

描述

以完全顺序原子更新 v 为 (v - i)。

可在 noinstr 代码中使用；其他情况下请优先使用 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)。

可在 noinstr 代码中使用；其他情况下请优先使用 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)。

可在 noinstr 代码中使用；其他情况下请优先使用 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)。

可在 noinstr 代码中使用；其他情况下请优先使用 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)。

可在 noinstr 代码中使用；其他地方请优先使用 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)。

可在 noinstr 代码中使用；其他地方请优先使用 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)。

可在 noinstr 代码中使用；其他地方请优先使用 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)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_fetch_sub_relaxed()。

返回

v 的原始值。

void raw_atomic64_inc(atomic64_t *v)¶: 具有宽松排序的原子递增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_inc()。

返回

无。

s64 raw_atomic64_inc_return(atomic64_t *v)¶: 具有完全排序的原子递增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用完全排序将 v 更新为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_inc_return()。

返回

v 的更新值。

s64 raw_atomic64_inc_return_acquire(atomic64_t *v)¶: 具有获取排序的原子递增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_inc_return_acquire()。

返回

v 的更新值。

s64 raw_atomic64_inc_return_release(atomic64_t *v)¶: 具有释放排序的原子递增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_inc_return_release()。

返回

v 的更新值。

s64 raw_atomic64_inc_return_relaxed(atomic64_t *v)¶: 具有宽松排序的原子递增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_inc_return_relaxed()。

返回

v 的更新值。

s64 raw_atomic64_fetch_inc(atomic64_t *v)¶: 具有完全排序的原子递增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用完全排序将 v 更新为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_fetch_inc()。

返回

v 的原始值。

s64 raw_atomic64_fetch_inc_acquire(atomic64_t *v)¶: 具有获取排序的原子递增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_fetch_inc_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_inc_release(atomic64_t *v)¶: 具有释放排序的原子递增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_fetch_inc_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_inc_relaxed(atomic64_t *v)¶: 具有宽松排序的原子递增

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v + 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_fetch_inc_relaxed()。

返回

v 的原始值。

void raw_atomic64_dec(atomic64_t *v)¶: 具有宽松排序的原子递减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_dec()。

返回

无。

s64 raw_atomic64_dec_return(atomic64_t *v)¶: 具有完全排序的原子递减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用完全排序将 v 更新为 (v - 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_dec_return()。

返回

v 的更新值。

s64 raw_atomic64_dec_return_acquire(atomic64_t *v)¶: 具有获取排序的原子递减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v - 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_dec_return_acquire()。

返回

v 的更新值。

s64 raw_atomic64_dec_return_release(atomic64_t *v)¶: 具有释放排序的原子递减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v - 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_dec_return_release()。

返回

v 的更新值。

s64 raw_atomic64_dec_return_relaxed(atomic64_t *v)¶: 具有宽松排序的原子递减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_dec_return_relaxed()。

返回

v 的更新值。

s64 raw_atomic64_fetch_dec(atomic64_t *v)¶: 具有完全排序的原子递减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用完全排序将 v 更新为 (v - 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_fetch_dec()。

返回

v 的原始值。

s64 raw_atomic64_fetch_dec_acquire(atomic64_t *v)¶: 具有获取排序的原子递减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用获取排序将 v 更新为 (v - 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_fetch_dec_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_dec_release(atomic64_t *v)¶: 具有释放排序的原子递减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用释放排序将 v 更新为 (v - 1)。

可在 noinstr 代码中使用；其他地方请优先使用 atomic64_fetch_dec_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_dec_relaxed(atomic64_t *v)¶: 具有宽松排序的原子递减

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

以原子方式使用宽松排序将 v 更新为 (v - 1)。

在 noinstr 代码中可以安全使用；在其他地方请优先使用 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)，则以释放排序原子地将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供宽松排序。

可在 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)，则以宽松排序原子地将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供宽松排序。

可在 noinstr 代码中使用；其他地方首选 atomic64_try_cmpxchg_relaxed()。

返回

如果发生交换，则返回 true，否则返回 false。

bool raw_atomic64_sub_and_test(s64 i, atomic64_t *v)¶: 原子减法并测试是否为零，使用完整排序

参数

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)¶: 原子递减并测试是否为零，使用完整排序

参数

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)¶: 原子递增并测试是否为零，使用完整排序

参数

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)¶: 原子加法并测试是否为负数，使用完整排序

参数

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)¶: 原子加法并测试是否为负数，使用获取排序

参数

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)¶: 原子加法并测试是否为负数，使用释放排序

参数

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)¶: 原子加法并测试是否为负数，使用宽松排序

参数

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)¶: 原子加法，除非值与指定值相等，使用完整排序

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 a: 要添加的 s64 值
s64 u: 用于比较的s64值

描述

如果 (v != u)，则以完整排序原子地将 v 更新为 (v + a)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中可以安全使用；在其他地方首选 atomic64_fetch_add_unless()。

返回

v 的原始值。

bool raw_atomic64_add_unless(atomic64_t *v, s64 a, s64 u)¶: 原子加法，除非值与指定值相等，使用完整排序

参数

atomic64_t *v: 指向 atomic64_t 的指针
s64 a: 要添加的 s64 值
s64 u: 用于比较的s64值

描述

如果 (v != u)，则以完整排序原子地将 v 更新为 (v + a)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中可以安全使用；在其他地方首选 atomic64_add_unless()。

返回

如果 v 被更新，则为 true，否则为 false。

bool raw_atomic64_inc_not_zero(atomic64_t *v)¶: 原子递增，除非为零，使用完整排序

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

如果 (v != 0)，则以完整排序原子地将 v 更新为 (v + 1)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中可以安全使用；在其他地方首选 atomic64_inc_not_zero()。

返回

如果 v 被更新，则为 true，否则为 false。

bool raw_atomic64_inc_unless_negative(atomic64_t *v)¶: 原子递增，除非为负数，并具有完整排序

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

如果 (v >= 0)，则以原子方式将 v 更新为 (v + 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中可以安全使用；在其他地方首选 atomic64_inc_unless_negative()。

返回

如果 v 被更新，则为 true，否则为 false。

bool raw_atomic64_dec_unless_positive(atomic64_t *v)¶: 原子递减，除非为正数，并具有完整排序

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

如果 (v <= 0)，则以原子方式将 v 更新为 (v - 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中可以安全使用；在其他地方首选 atomic64_dec_unless_positive()。

返回

如果 v 被更新，则为 true，否则为 false。

s64 raw_atomic64_dec_if_positive(atomic64_t *v)¶: 如果为正数则原子递减，并具有完整排序

参数

atomic64_t *v: 指向 atomic64_t 的指针

描述

如果 (v > 0)，则以原子方式将 v 更新为 (v - 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

在 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: 要减去的 long 值
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: 要减去的 long 值
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: 要减去的 long 值
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: 要减去的 long 值
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: 要减去的 long 值
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: 要减去的 long 值
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: 要减去的 long 值
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: 要减去的 long 值
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: 要减去的 long 值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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: 长整型值
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，使用宽松排序。

可在无检测代码中使用；在其他地方，请优先使用 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 不会被修改，并提供宽松排序。

可在无检测代码中使用；在其他地方，请优先使用 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 不会被修改，并提供宽松排序。

可在无检测代码中使用；在其他地方，请优先使用 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 不会被修改，并提供宽松排序。

可在无检测代码中使用；在其他地方，请优先使用 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 不会被修改，并提供宽松排序。

可在无检测代码中使用；在其他地方，请优先使用 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 的当前值，并提供宽松排序。

可在无检测代码中使用；在其他地方，请优先使用 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 的当前值，并提供宽松排序。

可在无检测代码中使用；在其他地方，请优先使用 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)，则以释放排序原子地将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供宽松排序。

可在无检测代码中使用；在其他地方，请优先使用 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)，则以宽松排序原子地将 v 更新为 new。否则，v 不会被修改，old 会被更新为 v 的当前值，并提供宽松排序。

可在无检测代码中使用；在其他地方，请优先使用 atomic_long_try_cmpxchg_relaxed()。

返回

如果发生交换，则返回 true，否则返回 false。

bool raw_atomic_long_sub_and_test(long i, atomic_long_t *v)¶: 原子减法并测试是否为零，使用完整排序

参数

long i: 要减去的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以完全顺序原子更新 v 为 (v - i)。

可在无检测代码中使用；在其他地方，请优先使用 atomic_long_sub_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool raw_atomic_long_dec_and_test(atomic_long_t *v)¶: 原子递减并测试是否为零，使用完整排序

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用完全排序将 v 更新为 (v - 1)。

可在无检测代码中使用；在其他地方，请优先使用 atomic_long_dec_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool raw_atomic_long_inc_and_test(atomic_long_t *v)¶: 原子递增并测试是否为零，使用完整排序

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以原子方式使用完全排序将 v 更新为 (v + 1)。

可在无检测代码中使用；在其他地方，请优先使用 atomic_long_inc_and_test()。

返回

如果 v 的结果值为零，则为 true，否则为 false。

bool raw_atomic_long_add_negative(long i, atomic_long_t *v)¶: 原子加法并测试是否为负数，使用完整排序

参数

long i: 要加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以完整排序原子更新 v 为 (v + i)。

可在无检测代码中使用；在其他地方，请优先使用 atomic_long_add_negative()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool raw_atomic_long_add_negative_acquire(long i, atomic_long_t *v)¶: 原子加法并测试是否为负数，使用获取排序

参数

long i: 要加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以获取排序原子更新 v 为 (v + i)。

可在无检测代码中使用；在其他地方，请优先使用 atomic_long_add_negative_acquire()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool raw_atomic_long_add_negative_release(long i, atomic_long_t *v)¶: 原子加法并测试是否为负数，使用释放排序

参数

long i: 要加的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指针

描述

以释放顺序原子更新 v 为 (v + i)。

可在无检测代码中使用；在其他地方，请优先使用 atomic_long_add_negative_release()。

返回

如果 v 的结果值为负数，则为 true，否则为 false。

bool raw_atomic_long_add_negative_relaxed(long i, atomic_long_t *v)¶: 原子加法并测试是否为负数，使用宽松排序

参数

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)¶: 原子加法，除非值与指定值相等，使用完整排序

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long a: 要加的 long 值
long u: 用于比较的 long 值

描述

如果 (v != u)，则以完整排序原子地将 v 更新为 (v + a)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中可以安全使用；其他地方请优先使用 atomic_long_fetch_add_unless()。

返回

v 的原始值。

bool raw_atomic_long_add_unless(atomic_long_t *v, long a, long u)¶: 原子加法，除非值与指定值相等，使用完整排序

参数

atomic_long_t *v: 指向 atomic_long_t 的指针
long a: 要加的 long 值
long u: 用于比较的 long 值

描述

如果 (v != u)，则以完整排序原子地将 v 更新为 (v + a)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中可以安全使用；其他地方请优先使用 atomic_long_add_unless()。

返回

如果 v 被更新，则为 true，否则为 false。

bool raw_atomic_long_inc_not_zero(atomic_long_t *v)¶: 原子递增，除非为零，使用完整排序

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

如果 (v != 0)，则以完整排序原子地将 v 更新为 (v + 1)。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中可以安全使用；其他地方请优先使用 atomic_long_inc_not_zero()。

返回

如果 v 被更新，则为 true，否则为 false。

bool raw_atomic_long_inc_unless_negative(atomic_long_t *v)¶: 原子递增，除非为负数，并具有完整排序

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

如果 (v >= 0)，则以原子方式将 v 更新为 (v + 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中可以安全使用；其他地方请优先使用 atomic_long_inc_unless_negative()。

返回

如果 v 被更新，则为 true，否则为 false。

bool raw_atomic_long_dec_unless_positive(atomic_long_t *v)¶: 原子递减，除非为正数，并具有完整排序

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

如果 (v <= 0)，则以原子方式将 v 更新为 (v - 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

在 noinstr 代码中可以安全使用；其他地方请优先使用 atomic_long_dec_unless_positive()。

返回

如果 v 被更新，则为 true，否则为 false。

long raw_atomic_long_dec_if_positive(atomic_long_t *v)¶: 如果为正数则原子递减，并具有完整排序

参数

atomic_long_t *v: 指向 atomic_long_t 的指针

描述

如果 (v > 0)，则以原子方式将 v 更新为 (v - 1)，并具有完整排序。否则，v 不会被修改，并提供宽松排序。

在 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: 要设置名称的 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() 清理 kobject，而不是直接调用 kfree，以确保所有内存都得到正确清理。

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。如果没有为 kobject 分配 kset，则 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。

内核实用程序函数¶

might_sleep¶

might_sleep ()

可睡眠的函数的注释

描述

如果在原子上下文（自旋锁、irq 处理程序...）中执行此宏，它将打印堆栈跟踪。可以使用 non_block_start() 和 non_block_end() 对来注释不允许阻塞的其他部分。

这是一个有用的调试帮助，可以尽早捕获问题，而不是在调用函数不应该睡眠时碰巧睡眠时稍后被咬伤。

cant_sleep¶

cant_sleep ()

用于标记不能睡眠的函数的注解

描述

如果此宏在启用抢占的情况下执行，则会打印堆栈跟踪

cant_migrate¶

cant_migrate ()

用于标记不能迁移的函数的注解

描述

如果在可迁移的代码中执行，则会打印堆栈跟踪

non_block_start¶

non_block_start ()

标记禁止睡眠的区域的开始

描述

这是代表 OOM reaper，特别是在它调用 mmu 通知器时。问题是如果通知器阻塞（例如，mutex_lock()），并且如果持有该互斥锁的进程执行睡眠内存分配，则 OOM reaper 现在会被阻塞，等待该内存分配完成。其他阻塞调用（如 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_printks。（当使用 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()，但适用于那些开发人员希望尽可能减少“海森堡效应”的快速路径，其中 print 格式的处理仍然太多。

此函数允许内核开发人员调试不适合使用 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() 迭代控制台列表

上下文

任何上下文。

返回

要传递给 console_srcu_read_unlock() 的 cookie。

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 时，将调用结构中的转储回调，必须设置该回调。成功时返回零，否则返回 -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 转储迭代器

描述

重置转储器的迭代器，以便可以在同一个 dumper.dump() 回调中再次调用 kmsg_dump_get_line() 和 kmsg_dump_get_buffer() 并多次使用。

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)¶: 如果尚未设置，则添加一个污点标记。

参数

unsigned flag: TAINT_* 常量之一。
enum lockdep_ok lockdep_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，该 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，该 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)¶: 查找并销毁设备资源，调用释放函数。

参数

struct device *dev: 要从中查找资源的设备
dr_release_t release: 查找与此释放函数关联的资源
dr_match_t match: 匹配函数（可选）
void *match_data: 匹配函数的数据

描述

查找与 **dev** 关联且与 **release** 相关联的最近的 devres，并且 **match** 返回 1。如果 **match** 为 NULL，则视为匹配所有。如果找到，则原子地删除资源，调用释放函数并释放资源。

返回

如果找到并释放 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: 资源的名称（用于调试目的）。

描述

这会向托管资源列表添加一个自定义操作，以便在标准资源释放过程中执行该操作。

void devm_remove_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_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 内核

目录

本页

驱动程序基础¶

驱动程序入口和退出点¶

驱动程序设备表¶

延迟和调度例程¶

时间和定时器例程¶

高分辨率定时器¶

等待队列和唤醒事件¶

内部函数¶

引用计数¶

原子操作¶

内核对象操作¶

内核实用程序函数¶

设备资源管理¶