驅動程式基礎¶

驅動程式入口和出口點¶

module_init¶

module_init (x)

驅動程式初始化入口點

引數

x: 在核心啟動時或模組插入時執行的函式

描述

module_init() 將在 do_initcalls() 期間（如果是內建）或在模組插入時（如果是模組）被呼叫。每個模組只能有一個。

module_exit¶

module_exit (x)

驅動程式退出入口點

引數

x: 驅動程式移除時要執行的函式

描述

當驅動程式是一個模組時，module_exit() 將使用 cleanup_module() 包裝驅動程式清理程式碼，當使用 rmmod 時。如果驅動程式靜態編譯到核心中，module_exit() 沒有效果。每個模組只能有一個。

struct klp_modinfo¶: 從即時補丁模組保留的 ELF 資訊

定義:

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

成員

hdr: ELF 頭部
sechdrs: 節頭部表
secstrings: 節頭部的字串表
symndx: 符號表節索引

bool try_module_get(struct module *module)¶: 獲取模組引用計數，除非模組正在被移除

引數

struct module *module: 我們應該檢查的模組

描述

只有當模組沒有被移除時，才嘗試獲取模組引用計數。如果模組正在被移除，此呼叫將失敗。

還必須小心確保模組在使用此呼叫之前存在並且處於活動狀態。這可以透過兩種方式來保證

直接保護：您知道早期的呼叫者必須透過 __module_get() 增加了模組引用。這通常可以透過讓另一個實體（而不是模組本身）增加模組引用計數來實現。
隱含保護：存在針對模組移除的隱含保護。kernfs / sysfs 使用的隱含保護就是一個例子。sysfs store / read 檔案操作透過使用 kernfs 的活動引用（參見 kernfs_active()）來保證存在，並且除非同一個檔案不活動，否則 sysfs / kernfs 檔案移除不會發生。因此，如果 sysfs 檔案正在被讀取或寫入到建立它的模組，則該模組必須仍然存在。因此，在模組 sysfs store / read ops 上使用 try_module_get() 是安全的。

try_module_get() 的一個真正價值是 module_is_live() 檢查，它確保 try_module_get() 的呼叫者可以屈服於使用者空間模組移除請求，並且如果模組正在退出，則可以優雅地失敗。

如果引用計數成功增加，則返回 true。

void module_put(struct module *module)¶: 釋放模組的引用計數

引數

struct module *module: 我們應該釋放引用計數的模組

描述

如果您成功地使用 try_module_get() 提升了模組的引用計數，當您完成時，您必須呼叫 module_put() 來釋放該引用計數。

驅動程式裝置表¶

struct usb_device_id¶: 標識用於探測和熱插拔的 USB 裝置

定義:

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

成員

match_flags: 位掩碼，控制其他哪些欄位用於匹配新裝置。可以使用除 driver_info 之外的任何欄位，儘管有些欄位只有與其他欄位結合使用才有意義。這通常由 USB_DEVICE_*() 宏設定，它設定此結構中的所有其他欄位，除了 driver_info。
idVendor: 裝置的 USB 供應商 ID；數字由 USB 論壇分配給其成員。
idProduct: 供應商分配的產品 ID。
bcdDevice_lo: 供應商分配的產品版本號的範圍的低端。這也用於標識單個產品版本，對於由單個裝置組成的範圍。
bcdDevice_hi: 版本號範圍的高階。產品版本的範圍是包含性的。
bDeviceClass: 裝置類別；數字由 USB 論壇分配。產品可以選擇實現類別，或者採用供應商特定的方式。裝置類別指定裝置上所有介面的行為。
bDeviceSubClass: 裝置子類；與 bDeviceClass 相關聯。
bDeviceProtocol: 裝置協議；與 bDeviceClass 相關聯。
bInterfaceClass: 介面類別；數字由 USB 論壇分配。產品可以選擇實現類別，或者採用供應商特定的方式。介面類別僅指定給定介面的行為；其他介面可能支援其他類別。
bInterfaceSubClass: 介面子類；與 bInterfaceClass 相關聯。
bInterfaceProtocol: 介面協議；與 bInterfaceClass 相關聯。
bInterfaceNumber: 介面編號；複合裝置可以使用固定的介面編號來區分供應商特定的介面。
driver_info: 儲存驅動程式使用的資訊。通常它儲存指向驅動程式理解的描述符的指標，或者可能是裝置標誌。

描述

在大多數情況下，驅動程式將使用 USB_DEVICE() 或類似為此目的設計的宏建立一個裝置 ID 表。然後，它們將使用 MODULE_DEVICE_TABLE() 將其匯出到使用者空間，並透過其 usb_driver 結構將其提供給 USB 核心。

有關如何執行匹配的資訊，請參閱 usb_match_id() 函式。簡而言之，您通常會使用幾個宏中的一個來幫助構造這些條目。您提供的每個條目將標識一個或多個特定產品，或者將標識一類已同意以相同方式執行的產品。您應該將更具體的匹配放在表的開頭，以便 driver_info 可以記錄特定產品的特性。

ACPI_DEVICE_CLASS¶

ACPI_DEVICE_CLASS (_cls, _msk)

用於描述具有 PCI 定義的類別程式碼資訊的 ACPI 裝置的宏

引數

_cls: 此裝置的類別、子類、prog-if 三元組
_msk: 此裝置的類別掩碼

描述

此宏用於建立一個匹配特定 PCI 類別的 struct acpi_device_id。.id 和 .driver_data 欄位將保留使用預設值初始化的狀態。

struct mdio_device_id¶: 標識 MDIO/MII 總線上的 PHY 裝置

定義:

struct mdio_device_id {
    __u32 phy_id;
    __u32 phy_id_mask;
};

成員

phy_id: 此 PHY 型別的 (mdio_read(MII_PHYSID1) << 16 | mdio_read(MII_PHYSID2)) & phy_id_mask 的結果
phy_id_mask: 定義 phy_id 的有效位。值 0 用於終止 struct mdio_device_id 陣列。

struct amba_id¶: 標識 AMBA 總線上的裝置

定義:

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

成員

id: 硬體裝置 ID 的有效位
mask: 位掩碼，指定匹配時 id 欄位的哪些位有效。當 ((硬體裝置 ID) & mask) == id 時，驅動程式繫結到裝置。
data: 驅動程式使用的私有資料。

struct mips_cdmm_device_id¶: 標識 MIPS CDMM 匯流排中的裝置

定義:

struct mips_cdmm_device_id {
    __u8 type;
};

成員

type: 裝置型別識別符號。

struct mei_cl_device_id¶: MEI 客戶端裝置識別符號

定義:

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

成員

name: 助手名稱
uuid: 客戶端 uuid
version: 客戶端協議版本
driver_info: 驅動程式使用的資訊。

描述

按 uuid 和名稱標識 mei 客戶端裝置

struct rio_device_id¶: RIO 裝置識別符號

定義:

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

成員

did: RapidIO 裝置 ID
vid: RapidIO 供應商 ID
asm_did: RapidIO 組合裝置 ID
asm_vid: RapidIO 組合供應商 ID

描述

基於裝置/供應商 ID 和組合裝置/供應商 ID 標識 RapidIO 裝置。

struct fsl_mc_device_id¶: MC 物件裝置識別符號

定義:

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

成員

vendor: 供應商 ID
obj_type: MC 物件型別

描述

MC 物件裝置驅動程式支援的 MC 物件裝置的“裝置 Id”表中的條目型別。該表的最後一個條目的 vendor 設定為 0x0

struct tb_service_id¶: Thunderbolt 服務識別符號

定義:

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

成員

match_flags: 用於匹配結構的標誌
protocol_key: 服務支援的協議金鑰
protocol_id: 服務支援的協議 id
protocol_version: 協議版本
protocol_revision: 協議軟體的修訂版
driver_data: 驅動程式特定資料

描述

Thunderbolt XDomain 服務作為裝置公開，其中每個裝置都攜帶服務支援的協議資訊。Thunderbolt XDomain 服務驅動程式針對該資訊進行匹配。

struct typec_device_id¶: USB Type-C 替代模式識別符號

定義:

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

成員

svid: 標準或供應商 ID
mode: 模式索引
driver_data: 驅動程式特定資料

struct tee_client_device_id¶: 基於 TEE 的裝置識別符號

定義:

struct tee_client_device_id {
    uuid_t uuid;
};

成員

uuid: 對於基於 TEE 的客戶端裝置，我們使用裝置 uuid 作為識別符號。

struct wmi_device_id¶: WMI 裝置識別符號

定義:

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

成員

guid_string: 形式為 fa50ff2b-f2e8-45de-83fa-65417f2f49ba 的 36 個字元的字串
context: 指向驅動程式特定資料的指標

struct mhi_device_id¶: MHI 裝置標識

定義:

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

成員

chan: MHI 通道名稱
driver_data: 驅動程式資料；

struct dfl_device_id¶: dfl 裝置識別符號

定義:

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

成員

type: 裝置的 DFL FIU 型別。請參閱 enum dfl_id_type。
feature_id: 特徵識別符號，對其 DFL FIU 型別是區域性的。
driver_data: 驅動程式特定資料。

struct ishtp_device_id¶: ISHTP 裝置識別符號

定義:

struct ishtp_device_id {
    guid_t guid;
    kernel_ulong_t driver_data;
};

成員

guid: 裝置的 GUID。
driver_data: 指向驅動程式特定資料的指標

struct cdx_device_id¶: CDX 裝置識別符號

定義:

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

成員

vendor: Vendor ID
device: 裝置 ID
subvendor: 子系統供應商 ID（或 CDX_ANY_ID）
subdevice: 子系統裝置 ID（或 CDX_ANY_ID）
class: 裝置類別。大多數驅動程式不需要指定類別/class_mask，因為 vendor/device 通常就足夠了。
class_mask: 限制比較類別欄位的哪些子欄位。
override_only: 僅當 dev->driver_override 是此驅動程式時才匹配。

描述

CDX 裝置驅動程式支援的 CDX 裝置的“裝置 Id”表中的條目型別。

struct coreboot_device_id¶: 標識 coreboot 表條目

定義:

struct coreboot_device_id {
    __u32 tag;
    kernel_ulong_t driver_data;
};

成員

tag: 標記 ID
driver_data: 驅動程式特定資料

延遲和排程例程¶

struct prev_cputime¶: 系統和使用者 cputime 的快照

定義:

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

成員

utime: 花費在使用者模式的時間
stime: 花費在系統模式的時間
lock: 保護上述兩個欄位

描述

儲存先前的使用者/系統時間值，以便我們可以保證單調性。

int set_cpus_allowed_ptr(struct task_struct *p, const struct cpumask *new_mask)¶: 設定任務的 CPU 親和性掩碼

引數

struct task_struct *p: 任務
const struct cpumask *new_mask: CPU 親和性掩碼

返回

成功時返回零，或返回負錯誤程式碼

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

引數

const struct task_struct *p: 有問題的任務。

返回

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

bool is_idle_task(const struct task_struct *p)¶: 指定的任務是否為空閒任務？

引數

const struct task_struct *p: 有問題的任務。

返回

如果 p 是空閒任務，則為 1。否則為 0。

int wake_up_process(struct task_struct *p)¶: 喚醒指定的程序

引數

struct task_struct *p: 要喚醒的程序。

描述

嘗試喚醒指定的程序，並將其移動到可執行程序的集合中。

此函式在訪問任務狀態之前執行完整的記憶體屏障。

返回

如果程序被喚醒，則為 1，如果程序已在執行，則為 0。

void preempt_notifier_register(struct preempt_notifier *notifier)¶: 當 current 程序被搶佔和重新排程時通知我

引數

struct preempt_notifier *notifier: 要註冊的通知器結構體

void preempt_notifier_unregister(struct preempt_notifier *notifier)¶: 不再對搶佔通知感興趣

引數

struct preempt_notifier *notifier: 要登出的通知器結構體

描述

從搶佔通知器內部呼叫此函式是不安全的。

__visible void notrace preempt_schedule_notrace(void)¶: tracing 呼叫的 preempt_schedule

引數

void: 無引數

描述

tracing 基礎設施使用 preempt_enable_notrace 來防止遞迴和由 tracing 基礎設施本身引起的 tracing 搶佔啟用。但是，由於 tracing 可能發生在來自使用者空間或即將進入使用者空間的區域中，因此可能在呼叫 user_exit() 之前發生搶佔啟用。這將導致排程器在系統仍處於使用者模式時被呼叫。

為了防止這種情況，preempt_enable_notrace 將使用此函式代替 preempt_schedule()，以便在呼叫排程器之前根據需要退出使用者上下文。

int cpupri_find_fitness(struct cpupri *cp, struct task_struct *p, struct cpumask *lowest_mask, bool (*fitness_fn)(struct task_struct *p, int cpu))¶: 查詢系統中最佳（最低優先順序）的 CPU

引數

struct cpupri *cp: cpupri 上下文
struct task_struct *p: 任務
struct cpumask *lowest_mask: 用於填充所選 CPU 的掩碼（或 NULL）
bool (*fitness_fn)(struct task_struct *p, int cpu): 指向函式的指標，用於執行自定義檢查，以確定 CPU 是否符合特定標準，以便我們只返回這些 CPU。

注意

此函式返回在當前呼叫期間計算的建議 CPU。在呼叫返回時，CPU 實際上可能已更改優先順序多次。雖然不理想，但這不是正確性的問題，因為正常的重新平衡器邏輯會糾正因與當前優先順序配置的不確定性競爭而產生的任何差異。

返回

(int)bool - 找到 CPU

void cpupri_set(struct cpupri *cp, int cpu, int newpri)¶: 更新 CPU 優先順序設定

引數

struct cpupri *cp: cpupri 上下文
int cpu: 目標 CPU
int newpri: 要分配給此 CPU 的優先順序（INVALID、NORMAL、RT1-RT99、HIGHER）

注意

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

返回

(void)

int cpupri_init(struct cpupri *cp)¶: 初始化 cpupri 結構

引數

struct cpupri *cp: cpupri 上下文

返回

記憶體分配失敗時返回 -ENOMEM。

void cpupri_cleanup(struct cpupri *cp)¶: 清理 cpupri 結構

引數

struct cpupri *cp: cpupri 上下文

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

引數

struct cfs_rq *cfs_rq: 負載平均值發生更改的 cfs_rq

描述

此函式“確保”：tg->load_avg := Sum tg->cfs_rq[]->avg.load。但是，由於 tg->load_avg 是一個全域性值，因此存在效能方面的考慮。

為了避免檢視其他 cfs_rq，我們使用差異更新，在其中儲存我們傳播的最後一個值。這反過來允許如果差異“很小”則跳過更新。

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

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

引數

u64 now: 當前時間，根據 cfs_rq_clock_pelt()
struct cfs_rq *cfs_rq: 要更新的 cfs_rq

描述

cfs_rq 平均值是其所有實體（阻塞和可執行）平均值的直接總和。直接的推論是所有（公平）任務都必須附加。

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

由於這兩個條件都表明 cfs_rq->avg.load 已更改，因此當此函式返回 true 時，我們應呼叫 update_tg_load_avg()。

返回

如果負載衰減或我們移除了負載，則為 true。

void attach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)¶: 將此實體附加到其 cfs_rq 負載平均值

引數

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

描述

必須在此之前呼叫 update_cfs_rq_load_avg()，因為我們依賴於 cfs_rq->avg.last_update_time 是當前的。

void detach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se)¶: 將此實體從其 cfs_rq 負載平均值分離

引數

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

描述

必須在此之前呼叫 update_cfs_rq_load_avg()，因為我們依賴於 cfs_rq->avg.last_update_time 是當前的。

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

引數

int cpu: 要獲取利用率的 CPU
struct task_struct *p: 應為其預測 CPU 利用率的任務或 NULL
int dst_cpu: p 遷移到的 CPU，如果 p 從 cpu 移動或 p == NULL，則為 -1
int boost: 1 表示啟用 boosting，否則為 0

描述

返回值單位必須與 CPU 容量的單位相同，以便可以將 CPU 利用率與 CPU 容量進行比較。

CPU 利用率是可執行任務的執行時間與該 CPU 上當前不可執行任務的最近利用率之和。它表示 CFS 任務當前使用的 CPU 容量，範圍為 [0..最大 CPU 容量]，最大 CPU 容量為 f_max 時的 CPU 容量。

估計的 CPU 利用率定義為 CPU 利用率與該 CPU 上當前可執行任務的估計利用率之和之間的最大值。它保留了先前執行的任務的利用率“快照”，這有助於更好地推斷長時間休眠的任務喚醒時 CPU 將有多忙。在此時，此類任務對 CPU 利用率的貢獻將顯著衰減。

提升的 CPU 利用率定義為 max(CPU 可執行, CPU 利用率)。 CFS 任務的 CPU 爭用可以透過 CPU 可執行 > CPU 利用率來檢測。 Boosting 在 cpu_util() 中實現，以便內部使用者（例如 EAS）可以與外部使用者（例如 schedutil）一起使用它，後者透過 cpu_util_cfs_boost()。

由於舍入誤差以及任務遷移或新任務的喚醒，CPU 利用率可能高於當前 CPU 容量（f_curr/f_max * 最大 CPU 容量）甚至最大 CPU 容量。 CPU 利用率必須被限制為適合 [0..最大 CPU 容量] 範圍。否則，一組 CPU（CPU0 util = 121% + CPU1 util = 80%）可能被視為過度利用，即使 CPU1 有 20% 的剩餘 CPU 容量。但是，允許 CPU 利用率超過當前 CPU 容量，因為這對於預測任務遷移後所需的 CPU 容量（排程程式驅動的 DVFS）很有用。

返回

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

bool sched_use_asym_prio(struct sched_domain *sd, int cpu)¶: 檢查是否必須使用 asym_packing 優先順序

引數

struct sched_domain *sd: 負載平衡的排程域
int cpu: 一個 CPU

描述

在 SMT 兄弟之間平衡負載時，始終使用 CPU 優先順序。在核心之間平衡負載時，僅 cpu 處於空閒狀態是不夠的。只有在整個核心都處於空閒狀態時，才使用 CPU 優先順序。

返回

如果必須遵循 cpu 的優先順序，則為 True。否則為 False。

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

引數

struct lb_env *env: 負載平衡環境
struct sg_lb_stats *sgs: 候選最繁忙組的負載平衡統計資訊
struct sched_group *group: 候選最繁忙組

描述

如果 env::dst_cpu 的優先順序高於 group 的首選 CPU，則它可以執行 asym_packing。

返回

如果 env::dst_cpu 可以執行 asym_packing 負載平衡，則為 true。否則為 False。

void update_sg_lb_stats(struct lb_env *env, struct sd_lb_stats *sds, struct sched_group *group, struct sg_lb_stats *sgs, bool *sg_overloaded, bool *sg_overutilized)¶: 更新 sched_group 的負載平衡統計資訊。

引數

struct lb_env *env: 負載平衡環境。
struct sd_lb_stats *sds: 帶有本地組統計資訊的負載平衡資料。
struct sched_group *group: 要更新統計資訊的 sched_group。
struct sg_lb_stats *sgs: 用於儲存此組的統計資訊的變數。
bool *sg_overloaded: sched_group 已過載
bool *sg_overutilized: sched_group 已過度利用

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

引數

struct lb_env *env: 負載平衡環境。
struct sd_lb_stats *sds: sched_domain 統計資訊
struct sched_group *sg: 要檢查是否為最繁忙的 sched_group 候選者
struct sg_lb_stats *sgs: sched_group 統計資訊

描述

確定 sg 是否比先前選擇的最繁忙組更繁忙的組。

返回

如果 sg 是比先前選擇的最繁忙組更繁忙的組，則為 true。否則為 false。

int idle_cpu_without(int cpu, struct task_struct *p)¶: 如果沒有 p，給定的 CPU 是否會空閒？

引數

int cpu: 測試空閒狀態的處理器。
struct task_struct *p: 應忽略的任務。

返回

如果 CPU 將會空閒，則為 1。否則為 0。

void update_sd_lb_stats(struct lb_env *env, struct sd_lb_stats *sds)¶: 更新 sched_domain 的負載均衡統計資訊。

引數

struct lb_env *env: 負載平衡環境。
struct sd_lb_stats *sds: 用於儲存此 sched_domain 的統計資訊的變數。

void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *sds)¶: 計算負載均衡期間給定 sched_domain 的組中存在的不平衡量。

引數

struct lb_env *env: 負載均衡環境
struct sd_lb_stats *sds: 要計算不平衡的 sched_domain 的統計資訊。

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

引數

struct lb_env *env: 負載平衡環境。

描述

還計算應移動以恢復平衡的可執行負載量。

返回

如果存在不平衡，則為最繁忙的組。

DECLARE_COMPLETION¶

DECLARE_COMPLETION (work)

宣告並初始化一個 completion 結構

引數

工作: completion 結構的識別符號

描述

此宏宣告並初始化一個 completion 結構。通常用於靜態宣告。對於自動變數，應使用 _ONSTACK 變體。

DECLARE_COMPLETION_ONSTACK¶

DECLARE_COMPLETION_ONSTACK (work)

宣告並初始化一個 completion 結構

引數

工作: completion 結構的識別符號

描述

此宏在核心堆疊上宣告並初始化一個 completion 結構。

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

引數

struct completion *x: 指向要初始化的 completion 結構的指標

描述

此行內函數將初始化一個動態建立的 completion 結構。

void reinit_completion(struct completion *x)¶: 重新初始化 completion 結構

引數

struct completion *x: 指向要重新初始化的 completion 結構的指標

描述

應使用此行內函數重新初始化 completion 結構，以便可以重複使用它。在使用 complete_all() 之後，這一點尤其重要。

時間和定時器例程¶

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

引數

void: 無引數

描述

當 BITS_PER_LONG < 64 時，這將使用序列號取樣，並使用 jiffies_lock 來保護 64 位讀取。

返回

當前的 64 位 jiffies 值

time_after¶

time_after (a, b)

如果時間 a 在時間 b 之後，則返回 true。

引數

a: 第一個可比較的無符號長整數
b: 第二個可比較的無符號長整數

描述

使用“<0”和“>=0”來僅測試結果的符號。一個好的編譯器會生成更好的程式碼（而一個非常好的編譯器不會在意）。Gcc 目前兩者都不是。

返回

如果時間 a 在時間 b 之後，則為 true，否則為 false。

time_before¶

time_before (a, b)

如果時間 a 在時間 b 之前，則返回 true。

引數

a: 第一個可比較的無符號長整數
b: 第二個可比較的無符號長整數

返回

如果時間 a 在時間 b 之前，則為 true，否則為 false。

time_after_eq¶

time_after_eq (a, b)

如果時間 a 在時間 b 之後或與時間 b 相同，則返回 true。

引數

a: 第一個可比較的無符號長整數
b: 第二個可比較的無符號長整數

返回

如果時間 a 在時間 b 之後或與時間 b 相同，則為 true，否則為 false。

time_before_eq¶

time_before_eq (a, b)

如果時間 a 在時間 b 之前或與時間 b 相同，則返回 true。

引數

a: 第一個可比較的無符號長整數
b: 第二個可比較的無符號長整數

返回

如果時間 a 在時間 b 之前或與時間 b 相同，則為 true，否則為 false。

time_in_range¶

time_in_range (a, b, c)

計算 a 是否在 [b, c] 的範圍內。

引數

a: 要測試的時間
b: 範圍的開始
c: 範圍的結束

返回

如果時間 a 在 [b, c] 的範圍內，則為 true，否則為 false。

time_in_range_open¶

time_in_range_open (a, b, c)

計算 a 是否在 [b, c) 的範圍內。

引數

a: 要測試的時間
b: 範圍的開始
c: 範圍的結束

返回

如果時間 a 在 [b, c) 的範圍內，則為 true，否則為 false。

time_after64¶

time_after64 (a, b)

如果時間 a 在時間 b 之後，則返回 true。

引數

a: 第一個可比較的 __u64
b: 第二個可比較的 __u64

描述

在使用 jiffies_64（即 get_jiffies_64() 的返回值）時，必須使用此函式。

返回

如果時間 a 在時間 b 之後，則為 true，否則為 false。

time_before64¶

time_before64 (a, b)

如果時間 a 在時間 b 之前，則返回 true。

引數

a: 第一個可比較的 __u64
b: 第二個可比較的 __u64

描述

在使用 jiffies_64（即 get_jiffies_64() 的返回值）時，必須使用此函式。

返回

如果時間 a 在時間 b 之前，則為 true，否則為 false。

time_after_eq64¶

time_after_eq64 (a, b)

如果時間 a 在時間 b 之後或與時間 b 相同，則返回 true。

引數

a: 第一個可比較的 __u64
b: 第二個可比較的 __u64

描述

在使用 jiffies_64（即 get_jiffies_64() 的返回值）時，必須使用此函式。

返回

如果時間 a 在時間 b 之後或與時間 b 相同，則為 true，否則為 false。

time_before_eq64¶

time_before_eq64 (a, b)

如果時間 a 在時間 b 之前或與時間 b 相同，則返回 true。

引數

a: 第一個可比較的 __u64
b: 第二個可比較的 __u64

描述

在使用 jiffies_64（即 get_jiffies_64() 的返回值）時，必須使用此函式。

返回

如果時間 a 在時間 b 之前或與時間 b 相同，則為 true，否則為 false。

time_in_range64¶

time_in_range64 (a, b, c)

計算 a 是否在 [b, c] 的範圍內。

引數

a: 要測試的時間
b: 範圍的開始
c: 範圍的結束

返回

如果時間 a 在 [b, c] 的範圍內，則為 true，否則為 false。

time_is_before_jiffies¶

time_is_before_jiffies (a)

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

引數

a: 要與 jiffies 進行比較的時間（無符號長整數）

返回

如果時間 a 在 jiffies 之前，則為 true，否則為 false。

time_is_before_jiffies64¶

time_is_before_jiffies64 (a)

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

引數

a: 要與 jiffies_64 進行比較的時間（__u64）

返回

如果時間 a 在 jiffies_64 之前，則為 true，否則為 false。

time_is_after_jiffies¶

time_is_after_jiffies (a)

如果 a 在 jiffies 之後，則返回 true

引數

a: 要與 jiffies 進行比較的時間（無符號長整數）

返回

如果時間 a 在 jiffies 之後，則為 true，否則為 false。

time_is_after_jiffies64¶

time_is_after_jiffies64 (a)

如果 a 在 jiffies_64 之後，則返回 true

引數

a: 要與 jiffies_64 進行比較的時間（__u64）

返回

如果時間 a 在 jiffies_64 之後，則為 true，否則為 false。

time_is_before_eq_jiffies¶

time_is_before_eq_jiffies (a)

如果 a 在 jiffies 之前或與 jiffies 相等，則返回 true

引數

a: 要與 jiffies 進行比較的時間（無符號長整數）

返回

如果時間 a 在 jiffies 之前或與 jiffies 相同，則為 true，否則為 false。

time_is_before_eq_jiffies64¶

time_is_before_eq_jiffies64 (a)

如果 a 在 jiffies_64 之前或與 jiffies_64 相等，則返回 true

引數

a: 要與 jiffies_64 進行比較的時間（__u64）

返回

如果時間 a 在 jiffies_64 之前或與 jiffies_64 相同，則為 true，否則為 false。

time_is_after_eq_jiffies¶

time_is_after_eq_jiffies (a)

如果 a 在 jiffies 之後或與 jiffies 相等，則返回 true

引數

a: 要與 jiffies 進行比較的時間（無符號長整數）

返回

如果時間 a 在 jiffies 之後或與 jiffies 相同，則為 true，否則為 false。

time_is_after_eq_jiffies64¶

time_is_after_eq_jiffies64 (a)

如果 a 在 jiffies_64 之後或與 jiffies_64 相等，則返回 true

引數

a: 要與 jiffies_64 進行比較的時間（__u64）

返回

如果時間 a 在 jiffies_64 之後或與 jiffies_64 相同，則為 true，否則為 false。

u64 jiffies_to_nsecs(const unsigned long j)¶: 將 jiffies 轉換為納秒

引數

const unsigned long j: jiffies 值

返回

納秒值

unsigned long msecs_to_jiffies(const unsigned int m)¶

將毫秒轉換為 jiffies

引數

const unsigned int m: 以毫秒為單位的時間

描述

轉換按如下方式完成

負值表示“無限超時”(MAX_JIFFY_OFFSET)
“太大”的值[這將導致大於 MAX_JIFFY_OFFSET 的值]也意味著“無限超時”。
所有其他值都透過將輸入值乘以一個因子或除以一個因子並處理任何 32 位溢位來轉換為 jiffies。有關詳細資訊，請參見 _msecs_to_jiffies()

msecs_to_jiffies() 透過 __builtin_constant_p() 檢查傳入的值是否為常量，從而允許 gcc 刪除大部分程式碼。如果傳入的值不允許常量摺疊，並且必須在執行時完成實際轉換，則呼叫 __msecs_to_jiffies()。HZ 範圍特定的幫助程式 _msecs_to_jiffies() 在此處直接呼叫，並在無法進行常量摺疊的情況下從 __msecs_to_jiffies() 呼叫。

返回

jiffies 值

secs_to_jiffies¶

secs_to_jiffies (_secs)

將秒轉換為 jiffies

引數

_secs: 以秒為單位的時間

描述

透過簡單地與 HZ 相乘來完成轉換

secs_to_jiffies() 被定義為宏而不是靜態行內函數，因此可以在靜態初始化器中使用它。

返回

jiffies 值

unsigned long usecs_to_jiffies(const unsigned int u)¶

將微秒轉換為 jiffies

引數

const unsigned int u: 以微秒為單位的時間

描述

轉換按如下方式完成

“太大”的值[這將導致大於 MAX_JIFFY_OFFSET 的值]也意味著“無限超時”。
所有其他值都透過將輸入值乘以一個因子或除以一個因子並處理任何 32 位溢位來轉換為 jiffies，如 msecs_to_jiffies 一樣。

usecs_to_jiffies() 透過 __builtin_constant_p() 檢查傳入的值是否為常量，從而允許 gcc 刪除大部分程式碼。如果傳入的值不允許常量摺疊，並且必須在執行時完成實際轉換，則呼叫 __usecs_to_jiffies()。HZ 範圍特定的幫助程式 _usecs_to_jiffies() 在此處直接呼叫，並在無法進行常量摺疊的情況下從 __msecs_to_jiffies() 呼叫。

返回

jiffies 值

unsigned int jiffies_to_msecs(const unsigned long j)¶: 將jiffies轉換為毫秒

引數

const unsigned long j: jiffies 值

描述

避免在兩種最常見的HZ情況下進行不必要的乘法/除法。

返回

毫秒值

unsigned int jiffies_to_usecs(const unsigned long j)¶: 將jiffies轉換為微秒

引數

const unsigned long j: jiffies 值

返回

微秒值

time64_t mktime64(const unsigned int year0, const unsigned int mon0, const unsigned int day, const unsigned int hour, const unsigned int min, const unsigned int sec)¶: 將日期轉換為秒數。

引數

const unsigned int year0: 要轉換的年份
const unsigned int mon0: 要轉換的月份
const unsigned int day: 要轉換的日期
const unsigned int hour: 要轉換的小時
const unsigned int min: 要轉換的分鐘
const unsigned int sec: 要轉換的秒

描述

將公曆日期轉換為自 1970-01-01 00:00:00 以來的秒數。假設輸入採用正常日期格式，即 1980-12-31 23:59:59 => year=1980, mon=12, day=31, hour=23, min=59, sec=59。

[對於儒略曆（1917 年之前在俄羅斯使用，1752 年之前在英國及其殖民地使用，1582 年之前在其他任何地方使用，並且至今仍被某些社群使用），請省略 -year/100+year/400 項，並加上 10。]

該演算法最初由高斯發表（我認為）。

可以透過將此函式與 sec 作為 60 呼叫來指示閏秒（ISO 8601 允許）。閏秒的處理方式與下一個秒相同，因為它們在 UNIX 時間中不存在。

支援將一天結束時的午夜編碼為 24:00:00 - 即。明天的午夜 -（ISO 8601 允許）。

返回

給定輸入日期的自紀元時間以來的秒數

void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec)¶: 設定 timespec 秒和納秒部分並進行規範化

引數

struct timespec64 *ts: 指向要設定的 timespec 變數的指標
time64_t sec: 要設定的秒數
s64 nsec: 要設定的納秒

描述

設定 timespec 變數的秒和納秒欄位，並規範化為 timespec 儲存格式

注意

tv_nsec 部分始終在 0 <= tv_nsec < NSEC_PER_SEC 範圍內。對於負值，只有 tv_sec 欄位為負！

struct timespec64 ns_to_timespec64(s64 nsec)¶: 將納秒轉換為 timespec64

引數

s64 nsec: 要轉換的納秒值

返回

nsec 引數的 timespec64 表示形式。

unsigned long __msecs_to_jiffies(const unsigned int m)¶

將毫秒轉換為 jiffies

引數

const unsigned int m: 以毫秒為單位的時間

描述

轉換按如下方式完成

負值表示“無限超時”(MAX_JIFFY_OFFSET)
“太大”的值[這將導致大於 MAX_JIFFY_OFFSET 的值]也意味著“無限超時”。
所有其他值都透過將輸入值乘以一個因子或除以一個因子並處理任何 32 位溢位來轉換為 jiffies。有關詳細資訊，請參見 _msecs_to_jiffies()

msecs_to_jiffies() 透過 __builtin_constant_p() 檢查傳入的值是否為常量，從而允許 gcc 刪除大部分程式碼，如果傳遞的值不允許常量摺疊並且必須在執行時完成實際轉換，則呼叫 __msecs_to_jiffies()。 _msecs_to_jiffies 輔助函式是在 include/linux/jiffies.h 中找到的與 HZ 相關的轉換例程

返回

jiffies 值

unsigned long __usecs_to_jiffies(const unsigned int u)¶

將微秒轉換為 jiffies

引數

const unsigned int u: 以毫秒為單位的時間

返回

jiffies 值

unsigned long timespec64_to_jiffies(const struct timespec64 *value)¶: 將 timespec64 值轉換為 jiffies

引數

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

描述

TICK_NSEC - 1 將值向上舍入到下一個解析度。請注意，此處的餘數減法不起作用，因為解析度值不落在秒邊界上。即：nsec -= nsec % TICK_NSEC; 不是正確的舍入解析度。請注意，由於此處乘數中的小錯誤，對於足夠大的 tv_nsec 值，此舍入不正確，但格式正確的 timespec 應具有 tv_nsec < NSEC_PER_SEC，因此我們沒問題。

相反，我們只需將位從右側移開。

>> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) 將縮放的納秒值轉換為縮放的秒值。

返回

jiffies 值

void jiffies_to_timespec64(const unsigned long jiffies, struct timespec64 *value)¶: 將 jiffies 值轉換為 struct timespec64

引數

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

clock_t jiffies_to_clock_t(unsigned long x)¶: 將 jiffies 轉換為 clock_t

引數

unsigned long x: jiffies 值

返回

jiffies 轉換為 clock_t (CLOCKS_PER_SEC)

unsigned long clock_t_to_jiffies(unsigned long x)¶: 將 clock_t 轉換為 jiffies

引數

unsigned long x: clock_t 值

返回

轉換為 jiffies 的 clock_t 值

u64 jiffies_64_to_clock_t(u64 x)¶: 將 jiffies_64 轉換為 clock_t

引數

u64 x: jiffies_64 值

返回

轉換為 64 位“clock_t”的 jiffies_64 值 (CLOCKS_PER_SEC)

u64 jiffies64_to_nsecs(u64 j)¶: 將 jiffies64 轉換為納秒

引數

u64 j: jiffies64 值

返回

納秒值

u64 jiffies64_to_msecs(const u64 j)¶: 將 jiffies64 轉換為毫秒

引數

const u64 j: jiffies64 值

返回

毫秒值

u64 nsecs_to_jiffies64(u64 n)¶: 將 u64 中的 nsecs 轉換為 jiffies64

引數

u64 n: u64 中的 nsecs

描述

與 {m,u}secs_to_jiffies 不同，輸入的型別不是 unsigned int 而是 u64。並且這不會返回 MAX_JIFFY_OFFSET，因為此函式專為排程程式設計，而不是用於裝置驅動程式來計算超時值。

注意

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

返回

轉換為 jiffies64 值的 nsecs

unsigned long nsecs_to_jiffies(u64 n)¶: 將 u64 中的 nsecs 轉換為 jiffies

引數

u64 n: u64 中的 nsecs

描述

與 {m,u}secs_to_jiffies 不同，輸入的型別不是 unsigned int 而是 u64。並且這不會返回 MAX_JIFFY_OFFSET，因為此函式專為排程程式設計，而不是用於裝置驅動程式來計算超時值。

注意

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

返回

轉換為 jiffies 值的 nsecs

int get_timespec64(struct timespec64 *ts, const struct __kernel_timespec __user *uts)¶: 將使用者的時間值獲取到核心空間

引數

struct timespec64 *ts: 目標 struct timespec64
const struct __kernel_timespec __user *uts: 使用者的時間值作為 struct __kernel_timespec

描述

處理相容模式或 32 位模式。

返回

成功時為 0，出錯時為負 errno

int put_timespec64(const struct timespec64 *ts, struct __kernel_timespec __user *uts)¶: 將 timespec64 值轉換為 __kernel_timespec 格式，並將後者複製到使用者空間

引數

const struct timespec64 *ts: 輸入 struct timespec64
struct __kernel_timespec __user *uts: 使用者的 struct __kernel_timespec

返回

成功時為 0，出錯時為負 errno

int get_old_timespec32(struct timespec64 *ts, const void __user *uts)¶: 將使用者的舊格式時間值獲取到核心空間

引數

struct timespec64 *ts: 目標 struct timespec64
const void __user *uts: 使用者的舊格式時間值 (struct old_timespec32)

描述

處理 X86_X32_ABI 相容性轉換。

返回

成功時為 0，出錯時為負 errno

int put_old_timespec32(const struct timespec64 *ts, void __user *uts)¶: 將 timespec64 值轉換為 struct old_timespec32 並將後者複製到使用者空間

引數

const struct timespec64 *ts: 輸入 struct timespec64
void __user *uts: 使用者的 struct old_timespec32

描述

處理 X86_X32_ABI 相容性轉換。

返回

成功時為 0，出錯時為負 errno

int get_itimerspec64(struct itimerspec64 *it, const struct __kernel_itimerspec __user *uit)¶: 獲取使用者的 struct __kernel_itimerspec 到核心空間

引數

struct itimerspec64 *it: 目標 struct itimerspec64
const struct __kernel_itimerspec __user *uit: 使用者的 struct __kernel_itimerspec

返回

成功時為 0，出錯時為負 errno

int put_itimerspec64(const struct itimerspec64 *it, struct __kernel_itimerspec __user *uit)¶: 轉換 struct itimerspec64 為 __kernel_itimerspec 格式並將後者複製到使用者空間

引數

const struct itimerspec64 *it: 輸入 struct itimerspec64
struct __kernel_itimerspec __user *uit: 使用者的 struct __kernel_itimerspec

返回

成功時為 0，出錯時為負 errno

int get_old_itimerspec32(struct itimerspec64 *its, const struct old_itimerspec32 __user *uits)¶: 獲取使用者的 struct old_itimerspec32 到核心空間

引數

struct itimerspec64 *its: 目標 struct itimerspec64
const struct old_itimerspec32 __user *uits: 使用者的 struct old_itimerspec32

返回

成功時為 0，出錯時為負 errno

int put_old_itimerspec32(const struct itimerspec64 *its, struct old_itimerspec32 __user *uits)¶: 轉換 struct itimerspec64 為 struct old_itimerspec32 並將後者複製到使用者空間

引數

const struct itimerspec64 *its: 輸入 struct itimerspec64
struct old_itimerspec32 __user *uits: 使用者的 struct old_itimerspec32

返回

成功時為 0，出錯時為負 errno

unsigned long __round_jiffies_relative(unsigned long j, int cpu)¶: 將節拍數四捨五入到整秒的函式

引數

unsigned long j: 應該四捨五入的時間（相對）節拍數
int cpu: 超時將發生的處理器編號

描述

__round_jiffies_relative() 將未來的時間增量（以節拍數為單位）向上或向下舍入到（大約）整秒。這對於定時器很有用，只要它們大約每 X 秒觸發一次，它們觸發的準確時間並不重要。

透過將這些計時器舍入為整秒，所有這些計時器將同時觸發，而不是分散在各個時間點。這樣做的目的是減少 CPU 的喚醒次數，從而節省電力。

每個處理器的精確舍入都是傾斜的，以避免所有處理器在完全相同的時間觸發，這可能導致鎖爭用或虛假的快取行跳動。

返回值是引數 **j** 的舍入版本。

unsigned long round_jiffies(unsigned long j)¶: 將節拍數四捨五入到整秒的函式

引數

unsigned long j: 應該四捨五入的時間（絕對）節拍數

描述

round_jiffies() 將未來的絕對時間（以節拍數為單位）向上或向下舍入到（大約）整秒。這對於定時器很有用，只要它們大約每 X 秒觸發一次，它們觸發的準確時間並不重要。

透過將這些計時器舍入為整秒，所有這些計時器將同時觸發，而不是分散在各個時間點。這樣做的目的是減少 CPU 的喚醒次數，從而節省電力。

返回值是引數 **j** 的舍入版本。

unsigned long round_jiffies_relative(unsigned long j)¶: 將節拍數四捨五入到整秒的函式

引數

unsigned long j: 應該四捨五入的時間（相對）節拍數

描述

round_jiffies_relative() 將未來的時間增量（以節拍數為單位）向上或向下舍入到（大約）整秒。這對於定時器很有用，只要它們大約每 X 秒觸發一次，它們觸發的準確時間並不重要。

透過將這些計時器舍入為整秒，所有這些計時器將同時觸發，而不是分散在各個時間點。這樣做的目的是減少 CPU 的喚醒次數，從而節省電力。

返回值是引數 **j** 的舍入版本。

unsigned long __round_jiffies_up_relative(unsigned long j, int cpu)¶: 將節拍數向上舍入到整秒的函式

引數

unsigned long j: 應該四捨五入的時間（相對）節拍數
int cpu: 超時將發生的處理器編號

描述

這與 __round_jiffies_relative() 相同，除了它永遠不會向下舍入。這對於超時很有用，只要它們不會太早觸發，它們的準確觸發時間並不重要。

unsigned long round_jiffies_up(unsigned long j)¶: 將節拍數向上舍入到整秒的函式

引數

unsigned long j: 應該四捨五入的時間（絕對）節拍數

描述

這與 round_jiffies() 相同，除了它永遠不會向下舍入。這對於超時很有用，只要它們不會太早觸發，它們的準確觸發時間並不重要。

unsigned long round_jiffies_up_relative(unsigned long j)¶: 將節拍數向上舍入到整秒的函式

引數

unsigned long j: 應該四捨五入的時間（相對）節拍數

描述

這與 round_jiffies_relative() 相同，除了它永遠不會向下舍入。這對於超時很有用，只要它們不會太早觸發，它們的準確觸發時間並不重要。

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

引數

struct timer_list *timer: 要初始化的定時器
void (*func)(struct timer_list *): 定時器回撥函式
unsigned int flags: 定時器標誌
const char *name: 定時器的名稱
struct lock_class_key *key: 用於跟蹤定時器同步鎖依賴關係的偽鎖的 lockdep 類鍵

描述

timer_init_key() 必須在呼叫 _任何_ 其他定時器函式之前對定時器執行。

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

引數

struct timer_list *timer: 要修改的掛起定時器
unsigned long expires: 節拍數中的新絕對超時

描述

對於掛起的定時器，mod_timer_pending() 與 mod_timer() 相同，但不會啟用非活動定時器。

如果 **timer->function** == NULL，則會靜默丟棄啟動操作。

返回

0 - 定時器未啟用且未修改，或者處於
關閉狀態且操作已丟棄
1 - 定時器已啟用並重新排隊以在 **expires** 過期

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

引數

struct timer_list *timer: 要修改的定時器
unsigned long expires: 節拍數中的新絕對超時

描述

mod_timer(timer, expires) 等效於

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

mod_timer() 比上面的開放編碼序列更有效。如果定時器未啟用，則 timer_delete() 部分是 NOP。在任何情況下，定時器都會使用新的到期時間 **expires** 啟用。

請注意，如果同一定時器有多個未序列化的併發使用者，則 mod_timer() 是修改超時的唯一安全方法，因為 add_timer() 無法修改已執行的定時器。

如果 **timer->function** == NULL，則會靜默丟棄啟動操作。在這種情況下，返回值是 0 且無意義。

返回

0 - 定時器未啟用並啟動，或者處於關閉狀態
並且操作已丟棄
1 - 定時器已啟用並重新排隊以在 **expires** 過期，或者
定時器已啟用且未修改，因為 **expires** 沒有更改有效到期時間

int timer_reduce(struct timer_list *timer, unsigned long expires)¶: 如果修改定時器的超時會減少超時，則修改定時器的超時

引數

struct timer_list *timer: 要修改的定時器
unsigned long expires: 節拍數中的新絕對超時

描述

timer_reduce() 與 mod_timer() 非常相似，不同之處在於它僅在減少到期時間時才會修改已排隊的定時器。如果 **timer** 未排隊，則會啟動定時器。

如果 **timer->function** == NULL，則會靜默丟棄啟動操作。

返回

0 - 定時器未啟用並啟動，或者處於關閉狀態
並且操作已丟棄
1 - 定時器已啟用並重新排隊以在 **expires** 過期，或者
定時器已啟用且未修改，因為 **expires** 沒有更改有效到期時間，因此定時器不會比已計劃的時間更早過期

void add_timer(struct timer_list *timer)¶: 啟動定時器

引數

struct timer_list *timer: 要啟動的定時器

描述

啟動 **timer** 以在未來的 **timer->expires** 到期。 **timer->expires** 是以“節拍數”衡量的絕對到期時間。當定時器過期時，將從軟中斷上下文中呼叫 timer->function(timer)。

必須在呼叫此函式之前設定 **timer->expires** 和 **timer->function** 欄位。

如果 **timer->function** == NULL，則會靜默丟棄啟動操作。

如果 **timer->expires** 已經過去，則會將 **timer** 排隊以便在下一個定時器節拍時過期。

這隻能對非活動定時器進行操作。嘗試對活動定時器呼叫此操作將發出警告而被拒絕。

void add_timer_local(struct timer_list *timer)¶: 在本地 CPU 上啟動定時器

引數

struct timer_list *timer: 要啟動的定時器

描述

與 add_timer() 相同，不同之處在於已設定定時器標誌 TIMER_PINNED。

有關更多詳細資訊，請參見 add_timer()。

void add_timer_global(struct timer_list *timer)¶: 啟動未設定 TIMER_PINNED 標誌的定時器

引數

struct timer_list *timer: 要啟動的定時器

描述

與 add_timer() 相同，不同之處在於未設定定時器標誌 TIMER_PINNED。

有關更多詳細資訊，請參見 add_timer()。

void add_timer_on(struct timer_list *timer, int cpu)¶: 在特定 CPU 上啟動定時器

引數

struct timer_list *timer: 要啟動的定時器
int cpu: 要在其上啟動的 CPU

描述

與 add_timer() 相同，不同之處在於它在給定的 CPU 上啟動定時器，並且已設定 TIMER_PINNED 標誌。當下一次迴圈中定時器不應是固定的定時器時，應改用 add_timer_global()，因為它會取消設定 TIMER_PINNED 標誌。

有關更多詳細資訊，請參見 add_timer()。

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

引數

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

描述

該函式僅停用待處理的定時器，但與 timer_delete_sync() 不同，它不考慮定時器的回撥函式是否在不同的 CPU 上併發執行。它也不會阻止定時器的重新啟用。如果可以併發地重新啟用 timer，則此函式的返回值沒有意義。

返回

0 - 定時器未處於待處理狀態
1 - 定時器處於待處理狀態並已停用

int timer_shutdown(struct timer_list *timer)¶: 停用定時器並阻止重新啟用

引數

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

描述

該函式不等待在不同 CPU 上可能正在執行的定時器回撥，但它會阻止定時器的重新啟用。在此函式返回後，任何啟用 timer 的嘗試都將被靜默忽略。

此函式對於清理程式碼很有用，並且只有在由於鎖定或上下文約束而無法呼叫 timer_shutdown_sync() 時才應使用。

返回

0 - 定時器未處於待處理狀態
1 - 定時器處於待處理狀態

int timer_delete_sync_try(struct timer_list *timer)¶: 嘗試停用定時器

引數

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

描述

此函式嘗試停用定時器。成功後，定時器不會排隊，並且定時器回撥函式不會在任何 CPU 上執行。

此函式不保證在釋放基本鎖之後無法立即重新啟用定時器。如果需要，呼叫程式碼需要阻止這種情況。

返回

0 - 定時器未處於待處理狀態
1 - 定時器處於待處理狀態並已停用
-1 - 定時器回撥函式正在不同的 CPU 上執行

int timer_delete_sync(struct timer_list *timer)¶: 停用定時器並等待處理程式完成。

引數

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

描述

同步規則：呼叫者必須阻止定時器的重新啟動，否則此函式沒有意義。除非定時器是 irqsafe 定時器，否則不得從中斷上下文中呼叫它。呼叫者不得持有會阻止定時器回撥函式完成的鎖。定時器的處理程式不得呼叫 add_timer_on()。退出時，定時器不會排隊，並且處理程式不會在任何 CPU 上執行。

對於 !irqsafe 定時器，呼叫者不得持有在中斷上下文中持有的鎖。即使鎖與有問題的定時器無關。原因如下

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

現在 timer_delete_sync() 將永遠不會返回，也永遠不會釋放 somelock。另一個 CPU 上的中斷正在等待獲取 somelock，但它中斷了 CPU0 正在等待完成的軟中斷。

此函式無法保證定時器在釋放基本鎖後不會被一些併發或搶佔程式碼再次重新啟用。如果存在併發重新啟用的可能性，則該函式的返回值沒有意義。

如果需要這樣的保證，例如，對於清理情況，則改用 timer_shutdown_sync()。

返回

0 - 定時器未處於待處理狀態
1 - 定時器處於待處理狀態並已停用

int timer_shutdown_sync(struct timer_list *timer)¶: 關閉定時器並阻止重新啟用

引數

struct timer_list *timer: 要關閉的定時器

描述

當函式返回時，保證

timer 未排隊
timer 的回撥函式未執行
timer 無法再次入隊。任何重新啟用 timer 的嘗試都將被靜默忽略。

有關同步規則，請參見 timer_delete_sync()。

此函式對於基礎結構的最終清理很有用，其中定時器會遇到迴圈依賴問題。

對此的常見模式是定時器和工作佇列，其中定時器可以排程工作，而工作可以啟用定時器。在關閉時，必須銷燬工作佇列，並且必須阻止定時器重新啟用。除非程式碼具有諸如“if (mything->in_shutdown)”之類的條件來阻止這種情況，否則無法使用 timer_delete_sync() 正確地做到這一點。

timer_shutdown_sync() 正在解決此問題。在這種情況下，正確的呼叫順序是

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

在此之後，可以安全地釋放“mything”。

這顯然意味著在關閉操作的其餘部分中不需要定時器是功能性的。

返回

0 - 定時器未處於待處理狀態
1 - 定時器處於待處理狀態

高解析度定時器¶

ktime_t ktime_set(const s64 secs, const unsigned long nsecs)¶: 從秒/納秒值設定 ktime_t 變數

引數

const s64 secs: 要設定的秒數
const unsigned long nsecs: 要設定的納秒

返回

值的 ktime_t 表示形式。

int ktime_compare(const ktime_t cmp1, const ktime_t cmp2)¶: 比較兩個 ktime_t 變數的大小、大於或等於

引數

const ktime_t cmp1: 可比較物件 1
const ktime_t cmp2: 可比較物件 2

返回

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

bool ktime_after(const ktime_t cmp1, const ktime_t cmp2)¶: 比較 ktime_t 值是否大於另一個值。

引數

const ktime_t cmp1: 可比較物件 1
const ktime_t cmp2: 可比較物件 2

返回

如果 cmp1 發生在 cmp2 之後，則為 true。

bool ktime_before(const ktime_t cmp1, const ktime_t cmp2)¶: 比較 ktime_t 值是否小於另一個值。

引數

const ktime_t cmp1: 可比較物件 1
const ktime_t cmp2: 可比較物件 2

返回

如果 cmp1 發生在 cmp2 之前，則為 true。

bool ktime_to_timespec64_cond(const ktime_t kt, struct timespec64 *ts)¶: 僅當變數包含資料時，才將 ktime_t 變數轉換為 timespec64 格式

引數

const ktime_t kt: 要轉換的 ktime_t 變數
struct timespec64 *ts: 用於儲存結果的 timespec 變數

返回

如果轉換成功，則為 true，如果 kt 為 0，則為 false。

struct hrtimer_sleeper¶: 簡單的睡眠器結構

定義:

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

成員

定時器: 嵌入式定時器結構
任務: 要喚醒的任務

描述

當定時器到期時，任務設定為 NULL。

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

引數

struct hrtimer *timer: 要新增的定時器
ktime_t tim: 到期時間
const enum hrtimer_mode mode: 定時器模式：絕對 (HRTIMER_MODE_ABS) 或相對 (HRTIMER_MODE_REL) 和固定 (HRTIMER_MODE_PINNED)；基於 softirq 的模式僅用於除錯目的！

ktime_t hrtimer_get_remaining(const struct hrtimer *timer)¶: 獲取定時器的剩餘時間

引數

const struct hrtimer *timer: 要讀取的定時器

bool hrtimer_is_queued(struct hrtimer *timer)¶: 檢查定時器是否在其中一個佇列上

引數

struct hrtimer *timer: 要檢查的定時器

返回

如果定時器已排隊，則為 True，否則為 false

描述

該函式可以無鎖使用，但它僅提供當前快照。

void hrtimer_update_function(struct hrtimer *timer, enum hrtimer_restart (*function)(struct hrtimer*))¶: 更新定時器的回撥函式

引數

struct hrtimer *timer: 要更新的定時器
enum hrtimer_restart (*function)(struct hrtimer *): 新的回撥函式

描述

僅當定時器未排隊時，才可以安全地呼叫。如果定時器未同時排隊，則可以在回撥函式中呼叫（請參見 HRTIMER_STATE_ENQUEUED 上方的註釋）。

u64 hrtimer_forward_now(struct hrtimer *timer, ktime_t interval)¶: 轉發定時器到期時間，使其在現在之後到期

引數

struct hrtimer *timer: 要轉發的 hrtimer
ktime_t interval: 要轉發的間隔

描述

它是 hrtimer_forward() 的變體。定時器將在 hrtimer 時鐘基準的當前時間之後到期。有關詳細資訊，請參見 hrtimer_forward()。

u64 hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval)¶: 轉發定時器到期時間

引數

struct hrtimer *timer: 要轉發的 hrtimer
ktime_t now: 轉發到過去的時間
ktime_t interval: 要轉發的間隔

描述

轉發定時器到期時間，使其在將來到期。

注意

這僅更新定時器到期值，而不重新將定時器排隊。

還有 hrtimer_forward_now() 函式的變體。

上下文

可以從 timer 的回撥函式中安全地呼叫。如果從其他上下文中呼叫，則 timer 既不能排隊，也不能執行回撥，並且呼叫者需要注意序列化。

返回

返回超限次數。

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

引數

struct hrtimer *timer: 要新增的定時器
ktime_t tim: 到期時間
u64 delta_ns: 定時器的“鬆弛”範圍
const enum hrtimer_mode mode: 定時器模式：絕對 (HRTIMER_MODE_ABS) 或相對 (HRTIMER_MODE_REL) 和固定 (HRTIMER_MODE_PINNED)；基於 softirq 的模式僅用於除錯目的！

int hrtimer_try_to_cancel(struct hrtimer *timer)¶: 嘗試停用定時器

引數

struct hrtimer *timer: 要停止的 hrtimer

返回

0 表示定時器未啟用

1 表示定時器已啟用

-1 表示定時器當前正在執行回撥函式，無法停止

int hrtimer_cancel(struct hrtimer *timer)¶: 取消定時器並等待處理程式完成。

引數

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

返回

0 表示定時器未啟用 1 表示定時器已啟用

ktime_t __hrtimer_get_remaining(const struct hrtimer *timer, bool adjust)¶: 獲取定時器的剩餘時間

引數

const struct hrtimer *timer: 要讀取的定時器
bool adjust: 當 CONFIG_TIME_LOW_RES=y 時，調整相對定時器

void hrtimer_setup(struct hrtimer *timer, enum hrtimer_restart (*function)(struct hrtimer*), clockid_t clock_id, enum hrtimer_mode mode)¶: 初始化計時器到給定的時鐘

引數

struct hrtimer *timer

要初始化的定時器

enum hrtimer_restart (*function)(struct hrtimer *)

回撥函式

clockid_t clock_id

要使用的時鐘

enum hrtimer_mode mode

與初始化相關的模式：HRTIMER_MODE_ABS、HRTIMER_MODE_REL、HRTIMER_MODE_ABS_SOFT、HRTIMER_MODE_REL_SOFT

可以傳入上述 PINNED 變體，但 PINNED 位會被忽略，因為 pinning 在 hrtimer 啟動時發生

void hrtimer_setup_on_stack(struct hrtimer *timer, enum hrtimer_restart (*function)(struct hrtimer*), clockid_t clock_id, enum hrtimer_mode mode)¶: 在棧記憶體上初始化一個計時器

引數

struct hrtimer *timer: 要初始化的計時器
enum hrtimer_restart (*function)(struct hrtimer *): 回撥函式
clockid_t clock_id: 要使用的時鐘
enum hrtimer_mode mode: 計時器模式

描述

與 hrtimer_setup() 類似，但如果 struct hrtimer 在棧記憶體中，則必須使用此函式。

void hrtimer_sleeper_start_expires(struct hrtimer_sleeper *sl, enum hrtimer_mode mode)¶: 啟動一個 hrtimer 休眠計時器

引數

struct hrtimer_sleeper *sl: 要啟動的 sleeper
enum hrtimer_mode mode: 計時器模式 abs/rel

描述

hrtimer_start_expires() 的包裝器，用於基於 hrtimer_sleeper 的計時器，以允許 PREEMPT_RT 調整傳遞模式（soft/hardirq 上下文）

void hrtimer_setup_sleeper_on_stack(struct hrtimer_sleeper *sl, clockid_t clock_id, enum hrtimer_mode mode)¶: 在棧記憶體中初始化一個 sleeper

引數

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

等待佇列和喚醒事件¶

int waitqueue_active(struct wait_queue_head *wq_head)¶

無鎖測試佇列上是否有等待者

引數

struct wait_queue_head *wq_head: 要測試是否有等待者的等待佇列

描述

如果等待列表不為空，則返回 true

在使用 wait_queue_head::lock 或用於使用額外的 smp_mb() 喚醒時使用，例如

CPU0 - waker                    CPU1 - waiter

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

因為如果沒有顯式的 smp_mb()，waitqueue_active() 載入可能會提升到 cond 儲存之上，這樣我們會在 waiter 可能沒有觀察到 cond 時觀察到空的等待列表。

另請注意，此“最佳化”將 spin_lock() 換成了 smp_mb()，（當鎖未爭用時）它們的成本大致相同。

注意

此函式是無鎖的，需要小心，不正確的使用 _將_ 導致零星且不明顯的故障。

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

引數

struct wait_queue_head *wq_head: 等待佇列頭

描述

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

請參考 waitqueue_active 的註釋。

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

引數

struct wait_queue_head *wq_head: 等待佇列頭

描述

如果 wq_head 有正在等待的程序，則返回 true

請參考 waitqueue_active 的註釋。

void wake_up_pollfree(struct wait_queue_head *wq_head)¶: 發出輪詢等待佇列即將消失的訊號

引數

struct wait_queue_head *wq_head: 等待佇列頭

描述

在非常罕見的情況下，->poll() 實現使用等待佇列，其生命週期與任務而不是與正在輪詢的“struct file”相關聯，則必須在釋放等待佇列之前呼叫此函式，以便通知非阻塞輪詢（例如 epoll）佇列即將消失。

呼叫者還必須 RCU 延遲等待佇列頭的釋放，例如透過顯式的 synchronize_rcu() 或 call_rcu()，或透過 SLAB_TYPESAFE_BY_RCU。

wait_event¶

wait_event (wq_head, condition)

睡眠直到條件為真

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式

描述

程序進入睡眠狀態 (TASK_UNINTERRUPTIBLE)，直到 condition 的計算結果為 true。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

wait_event_freezable¶

wait_event_freezable (wq_head, condition)

睡眠（或凍結）直到條件為真

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式

描述

程序進入睡眠狀態 (TASK_INTERRUPTIBLE -- 以不增加系統負載)，直到 condition 的計算結果為 true。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

wait_event_timeout¶

wait_event_timeout (wq_head, condition, timeout)

睡眠直到條件為真或超時經過

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式
超時: 超時，以 jiffies 為單位

描述

程序進入睡眠狀態 (TASK_UNINTERRUPTIBLE)，直到 condition 的計算結果為 true。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

返回

如果在經過 timeout 後 condition 的計算結果為 false，則為 0，如果在經過 timeout 後 condition 的計算結果為 true，則為 1，或者如果在 timeout 經過之前 condition 的計算結果為 true，則為剩餘的 jiffies（至少為 1）。

wait_event_cmd¶

wait_event_cmd (wq_head, condition, cmd1, cmd2)

睡眠直到條件為真

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式
cmd1: 該命令將在睡眠前執行
cmd2: 該命令將在睡眠後執行

描述

程序進入睡眠狀態 (TASK_UNINTERRUPTIBLE)，直到 condition 的計算結果為 true。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

wait_event_interruptible¶

wait_event_interruptible (wq_head, condition)

睡眠直到條件為真

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式

描述

程序進入睡眠狀態 (TASK_INTERRUPTIBLE)，直到 condition 的計算結果為 true 或收到訊號。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

如果該函式被訊號中斷，則返回 -ERESTARTSYS，如果 condition 的計算結果為 true，則返回 0。

wait_event_interruptible_timeout¶

wait_event_interruptible_timeout (wq_head, condition, timeout)

睡眠直到條件為真或超時經過

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式
超時: 超時，以 jiffies 為單位

描述

程序進入睡眠狀態 (TASK_INTERRUPTIBLE)，直到 condition 的計算結果為 true 或收到訊號。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

返回

如果在經過 timeout 後 condition 的計算結果為 false，則為 0，如果在經過 timeout 後 condition 的計算結果為 true，則為 1，如果在 timeout 經過之前 condition 的計算結果為 true，則為剩餘的 jiffies（至少為 1），或者如果它被訊號中斷，則為 -ERESTARTSYS。

wait_event_hrtimeout¶

wait_event_hrtimeout (wq_head, condition, timeout)

睡眠直到條件為真或超時經過

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式
超時: 超時，作為 ktime_t

描述

程序進入睡眠狀態 (TASK_UNINTERRUPTIBLE)，直到 condition 的計算結果為 true 或收到訊號。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

如果 condition 變為 true，該函式返回 0，如果超時經過，則返回 -ETIME。

wait_event_interruptible_hrtimeout¶

wait_event_interruptible_hrtimeout (wq, condition, timeout)

睡眠直到條件為真或超時經過

引數

wq: 要等待的等待佇列
條件: 等待事件的 C 表示式
超時: 超時，作為 ktime_t

描述

程序進入睡眠狀態 (TASK_INTERRUPTIBLE)，直到 condition 的計算結果為 true 或收到訊號。每次喚醒等待佇列 wq 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

如果 condition 變為 true，該函式返回 0，如果它被訊號中斷，則返回 -ERESTARTSYS，如果超時經過，則返回 -ETIME。

wait_event_idle¶

wait_event_idle (wq_head, condition)

等待一個條件，而不增加系統負載

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式

描述

程序進入睡眠狀態 (TASK_IDLE)，直到 condition 的計算結果為 true。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

wait_event_idle_exclusive¶

wait_event_idle_exclusive (wq_head, condition)

等待一個條件，同時增加系統負載

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式

描述

程序進入睡眠狀態 (TASK_IDLE)，直到 condition 的計算結果為 true。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

程序使用設定的 WQ_FLAG_EXCLUSIVE 標誌放置在等待佇列中，因此如果其他程序在同一列表中等待，則在喚醒此程序時，將不再考慮其他程序。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

wait_event_idle_timeout¶

wait_event_idle_timeout (wq_head, condition, timeout)

睡眠而不載入，直到條件變為 true 或超時經過

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式
超時: 超時，以 jiffies 為單位

描述

程序進入睡眠狀態 (TASK_IDLE)，直到 condition 的計算結果為 true。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

返回

如果在經過 timeout 後 condition 的計算結果為 false，則為 0，如果在經過 timeout 後 condition 的計算結果為 true，則為 1，或者如果在 timeout 經過之前 condition 的計算結果為 true，則為剩餘的 jiffies（至少為 1）。

wait_event_idle_exclusive_timeout¶

wait_event_idle_exclusive_timeout (wq_head, condition, timeout)

睡眠而不載入，直到條件變為 true 或超時經過

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式
超時: 超時，以 jiffies 為單位

描述

程序進入睡眠狀態 (TASK_IDLE)，直到 condition 的計算結果為 true。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

程序使用設定的 WQ_FLAG_EXCLUSIVE 標誌放置在等待佇列中，因此如果其他程序在同一列表中等待，則在喚醒此程序時，將不再考慮其他程序。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

返回

如果在經過 timeout 後 condition 的計算結果為 false，則為 0，如果在經過 timeout 後 condition 的計算結果為 true，則為 1，或者如果在 timeout 經過之前 condition 的計算結果為 true，則為剩餘的 jiffies（至少為 1）。

wait_event_interruptible_locked¶

wait_event_interruptible_locked (wq, condition)

睡眠直到條件為真

引數

wq: 要等待的等待佇列
條件: 等待事件的 C 表示式

描述

程序進入睡眠狀態 (TASK_INTERRUPTIBLE)，直到 condition 的計算結果為 true 或收到訊號。每次喚醒等待佇列 wq 時，都會檢查 condition。

必須使用持有的 wq.lock 呼叫它。此自旋鎖在睡眠時解鎖，但在持有鎖時完成 condition 測試，並且當此宏退出時，鎖被持有。

鎖使用 spin_lock()/spin_unlock() 函式鎖定/解鎖，這些函式必須與它們在此宏之外鎖定/解鎖的方式相匹配。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up_locked()。

如果該函式被訊號中斷，則返回 -ERESTARTSYS，如果 condition 的計算結果為 true，則返回 0。

wait_event_interruptible_locked_irq¶

wait_event_interruptible_locked_irq (wq, condition)

睡眠直到條件為真

引數

wq: 要等待的等待佇列
條件: 等待事件的 C 表示式

描述

程序進入睡眠狀態 (TASK_INTERRUPTIBLE)，直到 condition 的計算結果為 true 或收到訊號。每次喚醒等待佇列 wq 時，都會檢查 condition。

必須使用持有的 wq.lock 呼叫它。此自旋鎖在睡眠時解鎖，但在持有鎖時完成 condition 測試，並且當此宏退出時，鎖被持有。

鎖使用 spin_lock_irq()/spin_unlock_irq() 函式鎖定/解鎖，這些函式必須與它們在此宏之外鎖定/解鎖的方式相匹配。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up_locked()。

如果該函式被訊號中斷，則返回 -ERESTARTSYS，如果 condition 的計算結果為 true，則返回 0。

wait_event_interruptible_exclusive_locked¶

wait_event_interruptible_exclusive_locked (wq, condition)

獨佔睡眠直到條件為真

引數

wq: 要等待的等待佇列
條件: 等待事件的 C 表示式

描述

程序進入睡眠狀態 (TASK_INTERRUPTIBLE)，直到 condition 的計算結果為 true 或收到訊號。每次喚醒等待佇列 wq 時，都會檢查 condition。

必須使用持有的 wq.lock 呼叫它。此自旋鎖在睡眠時解鎖，但在持有鎖時完成 condition 測試，並且當此宏退出時，鎖被持有。

鎖使用 spin_lock()/spin_unlock() 函式鎖定/解鎖，這些函式必須與它們在此宏之外鎖定/解鎖的方式相匹配。

程序使用設定的 WQ_FLAG_EXCLUSIVE 標誌放置在等待佇列中，因此當其他程序在此列表上等待時，如果喚醒此程序，則不會考慮其他程序。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up_locked()。

如果該函式被訊號中斷，則返回 -ERESTARTSYS，如果 condition 的計算結果為 true，則返回 0。

wait_event_interruptible_exclusive_locked_irq¶

wait_event_interruptible_exclusive_locked_irq (wq, condition)

睡眠直到條件為真

引數

wq: 要等待的等待佇列
條件: 等待事件的 C 表示式

描述

程序進入睡眠狀態 (TASK_INTERRUPTIBLE)，直到 condition 的計算結果為 true 或收到訊號。每次喚醒等待佇列 wq 時，都會檢查 condition。

必須使用持有的 wq.lock 呼叫它。此自旋鎖在睡眠時解鎖，但在持有鎖時完成 condition 測試，並且當此宏退出時，鎖被持有。

鎖使用 spin_lock_irq()/spin_unlock_irq() 函式鎖定/解鎖，這些函式必須與它們在此宏之外鎖定/解鎖的方式相匹配。

程序使用設定的 WQ_FLAG_EXCLUSIVE 標誌放置在等待佇列中，因此當其他程序在此列表上等待時，如果喚醒此程序，則不會考慮其他程序。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up_locked()。

如果該函式被訊號中斷，則返回 -ERESTARTSYS，如果 condition 的計算結果為 true，則返回 0。

wait_event_killable¶

wait_event_killable (wq_head, condition)

睡眠直到條件為真

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式

描述

程序進入睡眠狀態 (TASK_KILLABLE)，直到 condition 的計算結果為 true 或收到訊號。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

如果該函式被訊號中斷，則返回 -ERESTARTSYS，如果 condition 的計算結果為 true，則返回 0。

wait_event_state¶

wait_event_state (wq_head, condition, state)

睡眠直到條件為真

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式
狀態: 要睡眠的狀態

描述

程序進入睡眠狀態 (state)，直到 condition 的計算結果為 true 或收到訊號（在 state 允許時）。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

如果該函式被訊號中斷（在 state 允許時），則返回 -ERESTARTSYS，如果 condition 的計算結果為 true，則返回 0。

wait_event_killable_timeout¶

wait_event_killable_timeout (wq_head, condition, timeout)

睡眠直到條件為真或超時經過

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式
超時: 超時，以 jiffies 為單位

描述

程序進入睡眠狀態 (TASK_KILLABLE)，直到 condition 的計算結果為 true 或收到 kill 訊號。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

只有 kill 訊號會中斷此程序。

返回

如果在經過 timeout 後 condition 的計算結果為 false，則為 0，如果在經過 timeout 後 condition 的計算結果為 true，則為 1，如果在 timeout 經過之前 condition 的計算結果為 true，則為剩餘的 jiffies（至少為 1），或者如果它被 kill 訊號中斷，則為 -ERESTARTSYS。

wait_event_lock_irq_cmd¶

wait_event_lock_irq_cmd (wq_head, condition, lock, cmd)

睡眠直到條件為真。在鎖下檢查條件。預計將在獲取鎖的情況下呼叫此函式。

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式
lock: 一個鎖定的 spinlock_t，它將在 cmd 和 schedule() 之前釋放並在之後重新獲取。
cmd: 在睡眠之前在臨界區之外呼叫的命令

描述

程序進入睡眠狀態 (TASK_UNINTERRUPTIBLE)，直到 condition 的計算結果為 true。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

這應該在持有鎖時呼叫。鎖在呼叫 cmd 和進入睡眠狀態之前釋放，並在之後重新獲取。

wait_event_lock_irq¶

wait_event_lock_irq (wq_head, condition, lock)

睡眠直到條件為真。在鎖下檢查條件。預計將在獲取鎖的情況下呼叫此函式。

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式
lock: 一個鎖定的 spinlock_t，它將在 schedule() 之前釋放並在之後重新獲取。

描述

程序進入睡眠狀態 (TASK_UNINTERRUPTIBLE)，直到 condition 的計算結果為 true。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

這應該在持有鎖時呼叫。鎖在進入睡眠狀態之前釋放，並在之後重新獲取。

wait_event_interruptible_lock_irq_cmd¶

wait_event_interruptible_lock_irq_cmd (wq_head, condition, lock, cmd)

睡眠直到條件為真。在鎖下檢查條件。預計將在獲取鎖的情況下呼叫此函式。

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式
lock: 一個鎖定的 spinlock_t，它將在 cmd 和 schedule() 之前釋放並在之後重新獲取。
cmd: 在睡眠之前在臨界區之外呼叫的命令

描述

程序進入睡眠狀態 (TASK_INTERRUPTIBLE)，直到 condition 的計算結果為 true 或收到訊號。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

這應該在持有鎖時呼叫。鎖在呼叫 cmd 和進入睡眠狀態之前釋放，並在之後重新獲取。

如果宏被訊號中斷，則返回 -ERESTARTSYS；如果 condition 評估為真，則返回 0。

wait_event_interruptible_lock_irq¶

wait_event_interruptible_lock_irq (wq_head, condition, lock)

睡眠直到條件為真。在鎖下檢查條件。預計將在獲取鎖的情況下呼叫此函式。

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式
lock: 一個鎖定的 spinlock_t，它將在 schedule() 之前釋放並在之後重新獲取。

描述

程序進入睡眠狀態 (TASK_INTERRUPTIBLE)，直到 condition 評估為真或收到訊號。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

這應該在持有鎖時呼叫。鎖在進入睡眠狀態之前釋放，並在之後重新獲取。

如果宏被訊號中斷，則返回 -ERESTARTSYS；如果 condition 評估為真，則返回 0。

wait_event_interruptible_lock_irq_timeout¶

wait_event_interruptible_lock_irq_timeout (wq_head, condition, lock, timeout)

睡眠直到條件為真或超時時間過去。在鎖的保護下檢查條件。期望在持有鎖的情況下呼叫此函式。

引數

wq_head: 要等待的等待佇列
條件: 等待事件的 C 表示式
lock: 一個鎖定的 spinlock_t，它將在 schedule() 之前釋放並在之後重新獲取。
超時: 超時，以 jiffies 為單位

描述

程序進入睡眠狀態 (TASK_INTERRUPTIBLE)，直到 condition 評估為真或收到訊號。每次喚醒等待佇列 wq_head 時，都會檢查 condition。

在更改任何可能更改等待條件結果的變數後，必須呼叫 wake_up()。

這應該在持有鎖時呼叫。鎖在進入睡眠狀態之前釋放，並在之後重新獲取。

如果 timeout 時間已過，則函式返回 0；如果被訊號中斷，則返回 -ERESTARTSYS；如果超時時間過去之前 condition 評估為真，則返回剩餘的 jiffies。

int __wake_up(struct wait_queue_head *wq_head, unsigned int mode, int nr_exclusive, void *key)¶: 喚醒在等待佇列上阻塞的執行緒。

引數

struct wait_queue_head *wq_head: 等待佇列
unsigned int mode: 哪些執行緒
int nr_exclusive: 要喚醒的 wake-one 或 wake-many 執行緒的數量
void *key: 直接傳遞給喚醒函式

描述

如果此函式喚醒了一個任務，它會在訪問任務狀態之前執行完整的記憶體屏障。返回被喚醒的獨佔任務的數量。

void __wake_up_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void *key)¶: 喚醒在等待佇列上阻塞的執行緒。

引數

struct wait_queue_head *wq_head: 等待佇列
unsigned int mode: 哪些執行緒
void *key: 要傳遞給喚醒目標的不透明值

描述

同步喚醒的不同之處在於，喚醒者知道它很快就會排程離開，因此雖然目標執行緒將被喚醒，但它不會遷移到另一個 CPU，即這兩個執行緒是“同步”的。這可以防止在 CPU 之間進行不必要的跳轉。

在 UP 上，它可以防止額外的搶佔。

如果此函式喚醒了一個任務，它會在訪問任務狀態之前執行完整的記憶體屏障。

void __wake_up_locked_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void *key)¶: 喚醒在鎖定的等待佇列上阻塞的執行緒。

引數

struct wait_queue_head *wq_head: 等待佇列
unsigned int mode: 哪些執行緒
void *key: 要傳遞給喚醒目標的不透明值

描述

同步喚醒的不同之處在於，喚醒者知道它很快就會排程離開，因此雖然目標執行緒將被喚醒，但它不會遷移到另一個 CPU，即這兩個執行緒是“同步”的。這可以防止在 CPU 之間進行不必要的跳轉。

在 UP 上，它可以防止額外的搶佔。

如果此函式喚醒了一個任務，它會在訪問任務狀態之前執行完整的記憶體屏障。

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

引數

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

描述

將當前執行緒設定回執行狀態，並從給定的等待佇列中移除等待描述符（如果仍在佇列中）。

內部函式¶

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

引數

struct wait_opts *wo: 等待選項
int ptrace: 是否等待 ptrace
struct task_struct *p: 要等待的任務

描述

處理 p 處於 TASK_STOPPED 或 TASK_TRACED 狀態下的 sys_wait4() 工作。

上下文

read_lock(tasklist_lock)，如果返回值非零，則釋放該鎖。此外，獲取並釋放 p->sighand->siglock。

返回

如果等待條件不存在並且應該繼續搜尋其他等待條件，則為 0。非零返回值，失敗時為 -errno，成功時為 p 的 pid，意味著 tasklist_lock 已釋放，並且應該終止等待條件搜尋。

bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask)¶: 設定 jobctl 掛起位

引數

struct task_struct *task: 目標任務
unsigned long mask: 要設定的掛起位

描述

從 task->jobctl 中清除 mask。 mask 必須是 JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME | JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING 的子集。如果正在設定停止訊號，則清除現有訊號。如果 task 正在被殺死或退出，則此函式變為 noop。

上下文

必須在持有 task->sighand->siglock 的情況下呼叫。

返回

如果設定了 mask，則為 true；如果因為 task 即將死亡而變為 noop，則為 false。

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

引數

struct task_struct *task: 目標任務

描述

如果設定了 JOBCTL_TRAPPING，則 ptracer 正在等待我們進入 TRACED。清除它並喚醒 ptracer。請注意，我們不需要任何進一步的鎖定。 task->siglock 保證 task->parent 指向 ptracer。

上下文

必須在持有 task->sighand->siglock 的情況下呼叫。

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

引數

struct task_struct *task: 目標任務
unsigned long mask: 要清除的掛起位

描述

從 task->jobctl 中清除 mask。 mask 必須是 JOBCTL_PENDING_MASK 的子集。如果正在清除 JOBCTL_STOP_PENDING，則會一起清除其他 STOP 位。

如果清除 mask 後沒有剩餘的停止或捕獲掛起，則此函式呼叫 task_clear_jobctl_trapping()。

上下文

必須在持有 task->sighand->siglock 的情況下呼叫。

bool task_participate_group_stop(struct task_struct *task)¶: 參與組停止

引數

struct task_struct *task: 參與組停止的任務

描述

task 已設定 JOBCTL_STOP_PENDING 並且正在參與組停止。如果設定了 JOBCTL_STOP_CONSUME，則清除組停止狀態並消耗組停止計數。如果消耗完成組停止，則設定相應的 SIGNAL_* 標誌。

上下文

必須在持有 task->sighand->siglock 的情況下呼叫。

返回

如果應將組停止完成通知給父程序，則為 true；否則為 false。

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

引數

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

描述

此函式排程粘性 ptrace 陷阱，該陷阱在下一次 TRAP_STOP 時被清除，以通知 ptracer 事件。 t 必須已被 ptracer 捕獲。

如果 t 正在執行，將執行 STOP 陷阱。如果為 STOP 陷入陷阱並且 ptracer 正在監聽事件，則喚醒 tracee，以便它可以為新事件重新陷入陷阱。如果以其他方式陷入陷阱，則最終會執行 STOP 陷阱，而不會在現有陷阱由 PTRACE_CONT 完成後返回到使用者空間。

上下文

必須在持有 task->sighand->siglock 的情況下呼叫。

int force_sig_seccomp(int syscall, int reason, bool force_coredump)¶: 發出訊號，以允許程序內系統呼叫模擬

引數

int syscall: 要傳送到使用者空間的系統呼叫號
int reason: 要傳送到使用者空間的過濾器提供的理由程式碼（透過 si_errno）
bool force_coredump: true 以觸發 core 轉儲

描述

強制執行 SIGSYS，其程式碼為 SYS_SECCOMP 和相關的 sigsys 資訊。

void do_notify_parent_cldstop(struct task_struct *tsk, bool for_ptracer, int why)¶: 通知父程序停止/繼續狀態更改

引數

struct task_struct *tsk: 報告狀態更改的任務
bool for_ptracer: 該通知適用於 ptracer
int why: 要報告的 CLD_{CONTINUED|STOPPED|TRAPPED}

描述

通知 tsk 的父程序停止/繼續狀態已更改。如果 for_ptracer 為 false，則 tsk 的組長會通知給它的真實父程序。如果為 true，則 tsk 會報告給 tsk->parent，該程序應該是 ptracer。

上下文

必須在至少讀取鎖定的情況下呼叫 tasklist_lock。

bool do_signal_stop(int signr)¶: 處理 SIGSTOP 和其他停止訊號的組停止

引數

int signr: 如果發起組停止，則導致組停止的 signr

描述

如果尚未設定 JOBCTL_STOP_PENDING，則使用 signr 發起組停止並參與其中。如果已設定，則參與現有組停止。如果參與了組停止（因此進入睡眠狀態），則返回 true，並釋放 siglock。

如果被 ptrace，此函式不會自行處理停止。相反，排程 JOBCTL_TRAP_STOP，並且返回 false，並且不修改 siglock。呼叫者必須確保之後發生 INTERRUPT 陷阱處理。

上下文

必須在持有 current->sighand->siglock 的情況下呼叫，該鎖在返回 true 時釋放。

返回

如果已取消組停止或已排程 ptrace 陷阱，則為 false。如果參與了組停止，則為 true。

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

引數

void: 無引數

描述

當 PT_SEIZED 時，它用於組停止和顯式 SEIZE/INTERRUPT 陷阱。兩者都會生成帶有附加 siginfo 的 PTRACE_EVENT_STOP 陷阱。如果已停止，則 exit_code 的低八位包含停止訊號；否則，為 SIGTRAP。

當 !PT_SEIZED 時，它僅用於以停止訊號編號作為 exit_code 且沒有 siginfo 的組停止陷阱。

上下文

必須在持有 current->sighand->siglock 的情況下呼叫，該鎖可能會在返回之前被釋放並重新獲取，並且會進行干預睡眠。

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

引數

void: 無引數

描述

如果該任務沒有即將退出，則將該任務置於凍結狀態。在這種情況下，它會刪除 JOBCTL_TRAP_FREEZE。

上下文

必須在持有 current->sighand->siglock 的情況下呼叫，該鎖始終在返回之前釋放。

void signal_delivered(struct ksignal *ksig, int stepping)¶: 在訊號傳遞後呼叫以更新阻塞訊號

引數

struct ksignal *ksig: 核心訊號結構
int stepping: 如果正在使用偵錯程式單步執行或塊步執行，則為非零

描述

成功傳遞訊號後應呼叫此函式。它會相應地更新阻塞訊號 (ksig->ka.sa.sa_mask 始終被阻塞)，並且該訊號本身被阻塞，除非在 ksig->ka.sa.sa_flags 中設定了 SA_NODEFER。通知跟蹤。

long sys_restart_syscall(void)¶: 重新啟動系統呼叫

引數

void: 無引數

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

引數

sigset_t *newset: 新掩碼

描述

直接更改 ->blocked 是錯誤的，應使用此助手來確保程序不會錯過我們將要阻塞的共享訊號。

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

引數

int how: 是新增、移除還是設定訊號
sigset_t __user * nset: 儲存掛起的訊號
sigset_t __user * oset: 如果非空，則為訊號掩碼的先前值
size_t sigsetsize: sigset_t 型別的大小

long sys_rt_sigpending(sigset_t __user *uset, size_t sigsetsize)¶: 檢查在阻塞時引發的掛起訊號

引數

sigset_t __user * uset: 儲存掛起的訊號
size_t sigsetsize: sigset_t 型別的大小或更大

void copy_siginfo_to_external32(struct compat_siginfo *to, const struct kernel_siginfo *from)¶: 將核心 siginfo 複製到 compat user siginfo

引數

struct compat_siginfo *to: compat siginfo 目標
const struct kernel_siginfo *from: 核心 siginfo 源

注意

此函式對於 x32 上的 SIGCHLD 無法正常工作，但幸運的是，它不必如此。此函式唯一的有效呼叫者是 copy_siginfo_to_user32，它被 x32 和 coredump 程式碼覆蓋。後者不在乎，因為 SIGCHLD 永遠不會導致 coredump。

int do_sigtimedwait(const sigset_t *which, kernel_siginfo_t *info, const struct timespec64 *ts)¶: 等待 **which** 中指定的排隊訊號

引數

const sigset_t *which: 要等待的排隊訊號
kernel_siginfo_t *info: 如果非空，則訊號的 siginfo 將在此處返回
const struct timespec64 *ts: 程序時間暫停的上限

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

引數

const sigset_t __user * uthese: 要等待的排隊訊號
siginfo_t __user * uinfo: 如果非空，則訊號的 siginfo 將在此處返回
const struct __kernel_timespec __user * uts: 程序時間暫停的上限
size_t sigsetsize: sigset_t 型別的大小

long sys_kill(pid_t pid, int sig)¶: 向程序傳送訊號

引數

pid_t pid: 程序的 PID
int sig: 要傳送的訊號

long sys_pidfd_send_signal(int pidfd, int sig, siginfo_t __user *info, unsigned int flags)¶: 透過 pidfd 向程序傳送訊號

引數

int pidfd: 程序的檔案描述符
int sig: 要傳送的訊號
siginfo_t __user * info: 訊號資訊
unsigned int flags: 未來的標誌

描述

根據 PIDFD_THREAD，將訊號傳送到執行緒組或單個執行緒。在未來，可以擴充套件 **flags** 以覆蓋 **pidfd** 的預設範圍。

返回

成功時為 0，失敗時為負 errno

long sys_tgkill(pid_t tgid, pid_t pid, int sig)¶: 向一個特定執行緒傳送訊號

引數

pid_t tgid

執行緒的執行緒組 ID

pid_t pid

執行緒的 PID

int sig

要傳送的訊號

此係統呼叫還會檢查 **tgid**，即使 PID 存在但不屬於目標程序也會返回 -ESRCH。此方法解決了執行緒退出和 PID 被重用的問題。

long sys_tkill(pid_t pid, int sig)¶: 向一個特定任務傳送訊號

引數

pid_t pid

任務的 PID

int sig

要傳送的訊號

僅向一個任務傳送訊號，即使它是一個 CLONE_THREAD 任務。

long sys_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t __user *uinfo)¶: 向訊號傳送訊號資訊

引數

pid_t pid: 執行緒的 PID
int sig: 要傳送的訊號
siginfo_t __user * uinfo: 要傳送的訊號資訊

long sys_sigpending(old_sigset_t __user *uset)¶: 檢查掛起的訊號

引數

old_sigset_t __user * uset: 返回掛起訊號的掩碼的位置

long sys_sigprocmask(int how, old_sigset_t __user *nset, old_sigset_t __user *oset)¶: 檢查和更改阻塞的訊號

引數

int how: 是新增、移除還是設定訊號
old_sigset_t __user * nset: 要新增或刪除的訊號（如果非空）
old_sigset_t __user * oset: 如果非空，則為訊號掩碼的先前值

描述

某些平臺有自己的特殊引數版本；其他平臺僅支援 sys_rt_sigprocmask。

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

引數

int sig: 要傳送的訊號
const struct sigaction __user * act: 新的 sigaction
struct sigaction __user * oact: 用於儲存先前的 sigaction
size_t sigsetsize: sigset_t 型別的大小

long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)¶: 用 unewset 值替換訊號掩碼的值，直到收到訊號

引數

sigset_t __user * unewset: 新的訊號掩碼值
size_t sigsetsize: sigset_t 型別的大小

kthread_create¶

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

在當前節點上建立一個 kthread

引數

threadfn: 執行緒中要執行的函式
data: **threadfn()** 的資料指標
namefmt: 執行緒名稱的 printf 風格格式字串
arg...: **namefmt** 的引數。

描述

此宏將在當前節點上建立一個 kthread，使其保持停止狀態。這只是 kthread_create_on_node() 的一個助手；有關更多詳細資訊，請參閱該處的文件。

kthread_run¶

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

建立並喚醒一個執行緒。

引數

threadfn: 要執行到 signal_pending(current) 的函式。
data: **threadfn** 的資料指標。
namefmt: 執行緒的 printf 風格名稱。
...: 可變引數

描述

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

struct task_struct *kthread_run_on_cpu(int (*threadfn)(void *data), void *data, unsigned int cpu, const char *namefmt)¶: 建立並喚醒一個 CPU 繫結的執行緒。

引數

int (*threadfn)(void *data): 要執行到 signal_pending(current) 的函式。
void *data: **threadfn** 的資料指標。
unsigned int cpu: 執行緒應繫結到的 CPU，
const char *namefmt: 執行緒的 printf 風格名稱。格式限制為 “name.*``u``”。程式碼會填充 CPU 編號。

描述

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

kthread_run_worker¶

kthread_run_worker (flags, namefmt, ...)

建立並喚醒一個 kthread worker。

引數

flags: 修改 worker 預設行為的標誌
namefmt: 執行緒的 printf 風格名稱。
...: 可變引數

描述

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

struct kthread_worker *kthread_run_worker_on_cpu(int cpu, unsigned int flags, const char namefmt[])¶: 建立並喚醒一個 CPU 繫結的 kthread worker。

引數

int cpu: CPU 編號
unsigned int flags: 修改 worker 預設行為的標誌
const char namefmt[]: 執行緒的 printf 風格名稱。格式限制為 “name.*``u``”。程式碼會填充 CPU 編號。

描述

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

bool kthread_should_stop(void)¶: 此 kthread 現在應該返回嗎？

引數

void: 無引數

描述

當有人在你的 kthread 上呼叫 kthread_stop() 時，它將被喚醒，並且該函式會返回 true。然後你應該返回，並且你的返回值將被傳遞給 kthread_stop()。

bool kthread_should_park(void)¶: 這個 kthread 現在應該停泊（park）嗎？

引數

void: 無引數

描述

當有人在你的 kthread 上呼叫 kthread_park() 時，它將被喚醒，並且該函式會返回 true。然後你應該進行必要的清理並呼叫 kthread_parkme()

類似於 kthread_should_stop()，但此函式保持執行緒存活並處於停泊（park）狀態。 kthread_unpark() “重啟”執行緒並再次呼叫執行緒函式。

bool kthread_freezable_should_stop(bool *was_frozen)¶: 這個可凍結的 kthread 現在應該返回嗎？

引數

bool *was_frozen: 可選的 out 引數，指示 current 是否被凍結

描述

用於可凍結 kthread 的 kthread_should_stop()，必要時將進入冷藏狀態。此函式可以避免 kthread_stop() / 冷藏器死鎖，可凍結 kthread 應該使用此函式，而不是直接呼叫 try_to_freeze()。

void *kthread_func(struct task_struct *task)¶: 返回 kthread 建立時指定的函式

引數

struct task_struct *task: 有問題的 kthread 任務

描述

如果任務不是 kthread，則返回 NULL。

void *kthread_data(struct task_struct *task)¶: 返回 kthread 建立時指定的資料值

引數

struct task_struct *task: 有問題的 kthread 任務

描述

返回建立 kthread **task** 時指定的資料值。呼叫者負責在呼叫此函式時確保 **task** 的有效性。

void __noreturn kthread_exit(long result)¶: 使當前的 kthread 將 **result** 返回給 kthread_stop()。

引數

long result: 要返回給 kthread_stop() 的整數值。

描述

雖然可以呼叫 kthread_exit，但它的存在是為了可以實現諸如 module_put_and_kthread_exit 之類在非模組化程式碼中執行一些額外工作的功能。

不返回。

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

引數

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

描述

如果存在，則完成 **comp**，然後將程式碼返回給 kthread_stop()。

其模組可能在 **comp** 完成後被刪除的核心執行緒可以使用此函式安全地退出。

不返回。

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

引數

int (*threadfn)(void *data): 要執行到 signal_pending(current) 的函式。
void *data: **threadfn** 的資料指標。
int node: 執行緒的任務和執行緒結構在此節點上分配
const char namefmt[]: 執行緒的 printf 風格名稱。
...: 可變引數

描述

此輔助函式建立並命名一個核心執行緒。該執行緒將被停止：使用 wake_up_process() 啟動它。另請參見 kthread_run()。新執行緒具有 SCHED_NORMAL 策略，並且與所有 CPU 仿射。

如果執行緒將繫結到特定的 cpu，請在 **node** 中指定其節點，以獲得 kthread 堆疊的 NUMA 關聯性，否則給出 NUMA_NO_NODE。喚醒後，執行緒將使用 **data** 作為其引數執行 **threadfn()**。 **threadfn()** 可以直接返回，如果它是一個獨立的執行緒，沒有人會呼叫 kthread_stop()，或者當“kthread_should_stop()”為 true 時返回（這意味著已呼叫 kthread_stop()）。返回值應為零或負錯誤號；它將被傳遞給 kthread_stop()。

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

void kthread_bind(struct task_struct *p, unsigned int cpu)¶: 將剛建立的 kthread 繫結到 cpu。

引數

struct task_struct *p: 由 kthread_create() 建立的執行緒。
unsigned int cpu: **k** 要執行的 cpu（可能不線上，必須可以）。

描述

此函式等效於 set_cpus_allowed()，除了 **cpu** 不需要線上之外，並且執行緒必須停止（即，剛從 kthread_create() 返回）。

struct task_struct *kthread_create_on_cpu(int (*threadfn)(void *data), void *data, unsigned int cpu, const char *namefmt)¶: 建立一個 cpu 繫結的 kthread

引數

int (*threadfn)(void *data): 要執行到 signal_pending(current) 的函式。
void *data: **threadfn** 的資料指標。
unsigned int cpu: 執行緒應繫結到的 CPU，
const char *namefmt: 執行緒的 printf 風格名稱。格式限制為 “name.*``u``”。程式碼會填充 CPU 編號。

描述

此輔助函式建立並命名一個核心執行緒

void kthread_unpark(struct task_struct *k)¶: 取消停泊由 kthread_create() 建立的執行緒。

引數

struct task_struct *k: 由 kthread_create() 建立的執行緒。

描述

將 kthread_should_park() 設定為 **k** 以返回 false，喚醒它，並等待它返回。如果執行緒被標記為 percpu，則再次將其繫結到 cpu。

int kthread_park(struct task_struct *k)¶: 停泊由 kthread_create() 建立的執行緒。

引數

struct task_struct *k: 由 kthread_create() 建立的執行緒。

描述

將 kthread_should_park() 設定為 **k** 以返回 true，喚醒它，並等待它返回。也可以在呼叫 kthread_create() 後呼叫它，而不是呼叫 wake_up_process()：執行緒將停泊，而不呼叫 threadfn()。

如果執行緒已停泊，則返回 0；如果執行緒已退出，則返回 -ENOSYS。如果由 kthread 本身呼叫，則只設置停泊位。

int kthread_stop(struct task_struct *k)¶: 停止由 kthread_create() 建立的執行緒。

引數

struct task_struct *k: 由 kthread_create() 建立的執行緒。

描述

將 kthread_should_stop() 設定為 **k** 以返回 true，喚醒它，並等待它退出。也可以在呼叫 kthread_create() 後呼叫它，而不是呼叫 wake_up_process()：執行緒將退出，而不呼叫 threadfn()。

如果 threadfn() 可以呼叫 kthread_exit() 本身，則呼叫者必須確保 task_struct 不會消失。

返回 threadfn() 的結果，如果從未呼叫 wake_up_process()，則返回 -EINTR。

int kthread_stop_put(struct task_struct *k)¶: 停止執行緒並放置其任務結構

引數

struct task_struct *k: 由 kthread_create() 建立的執行緒。

描述

停止由 kthread_create() 建立的執行緒並放置其 task_struct。僅在持有透過呼叫 get_task_struct() 獲得的額外任務結構引用時使用。

int kthread_worker_fn(void *worker_ptr)¶: 處理 kthread_worker 的 kthread 函式

引數

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

描述

此函式實現 kthread worker 的主迴圈。它處理 work_list，直到使用 kthread_stop() 停止它。當佇列為空時，它會休眠。

不允許工作在完成時保留任何鎖、停用搶佔或中斷。定義了一個安全點，用於在完成一項工作之後和啟動一項新工作之前進行凍結。

此外，不得由多個 worker 同時處理工作，另請參見 kthread_queue_work()。

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

引數

unsigned int flags: 修改 worker 預設行為的標誌
int node: 執行緒的任務結構在此節點上分配
const char namefmt[]: kthread worker（任務）的 printf 風格名稱。
...: 可變引數

描述

成功時返回指向已分配 worker 的指標，當無法分配所需結構時返回 ERR_PTR(-ENOMEM)，當呼叫者被致命訊號終止時返回 ERR_PTR(-EINTR)。

struct kthread_worker *kthread_create_worker_on_cpu(int cpu, unsigned int flags, const char namefmt[])¶: 建立一個 kthread worker 並將其繫結到給定的 CPU 和關聯的 NUMA 節點。

引數

int cpu: CPU 編號
unsigned int flags: 修改 worker 預設行為的標誌
const char namefmt[]: 執行緒的 printf 風格名稱。格式限制為 “name.*``u``”。程式碼會填充 CPU 編號。

描述

如果要將 kthread worker 繫結到給定的 CPU 和關聯的 NUMA 節點，請使用有效的 CPU 編號。

一個好的做法是將 cpu 編號也新增到 worker 名稱中。例如，使用 kthread_create_worker_on_cpu(cpu, “helper/d”, cpu)。

CPU 熱插拔：kthread worker API 簡單而通用。它只提供了一種建立、使用和銷燬 worker 的方法。

如何處理 CPU 熱插拔取決於 API 使用者。他們必須決定如何處理掛起的工作項、阻止排隊新的工作項，以及在 CPU 關閉和開啟時恢復功能。有一些注意事項

當在離線 CPU 上排程 CPU 時，CPU 關聯性會丟失。

當用戶建立 worker 時，如果 CPU 已關閉，則 worker 可能不存在。

一個好的做法是實現兩個 CPU 熱插拔回調，並在 CPU 關閉/啟動時銷燬/建立 worker。

返回

成功時返回指向已分配 worker 的指標，當無法分配所需結構時返回 ERR_PTR(-ENOMEM)，當呼叫者被致命訊號終止時返回 ERR_PTR(-EINTR)。

bool kthread_queue_work(struct kthread_worker *worker, struct kthread_work *work)¶: 排隊一個 kthread_work

引數

struct kthread_worker *worker: 目標 kthread_worker
struct kthread_work *work: 要排隊的 kthread_work

描述

將 **work** 排隊到工作處理器 **task** 以進行非同步執行。 **task** 必須已使用 kthread_create_worker() 建立。如果 **work** 成功排隊，則返回 true，如果它已經在掛起，則返回 false。

如果工作需要被另一個 worker 使用，則重新初始化它。例如，當 worker 停止並再次啟動時。

void kthread_delayed_work_timer_fn(struct timer_list *t)¶: 當定時器到期時，將關聯的 kthread 延遲工作項加入佇列的回撥函式。

引數

struct timer_list *t: 指向已到期定時器的指標

描述

此函式的格式由 struct timer_list 定義。它應該已經從 irqsafe 定時器中呼叫，並且中斷已被停用。

bool kthread_queue_delayed_work(struct kthread_worker *worker, struct kthread_delayed_work *dwork, unsigned long delay)¶: 在延遲後將關聯的 kthread 工作項加入佇列。

引數

struct kthread_worker *worker: 目標 kthread_worker
struct kthread_delayed_work *dwork: 要加入佇列的 kthread_delayed_work
unsigned long delay: 加入佇列前要等待的節拍數

描述

如果工作項尚未掛起，它會啟動一個定時器，該定時器將在給定的 delay 後將工作項加入佇列。如果 delay 為零，它會立即將工作項加入佇列。

返回

如果 work 已經掛起，則返回 false。這意味著定時器正在執行或工作項已加入佇列。否則，返回 true。

void kthread_flush_work(struct kthread_work *work)¶: 重新整理一個 kthread_work

引數

struct kthread_work *work: 要重新整理的工作項

描述

如果 work 已加入佇列或正在執行，則等待它完成執行。

bool kthread_mod_delayed_work(struct kthread_worker *worker, struct kthread_delayed_work *dwork, unsigned long delay)¶: 修改延遲或將 kthread 延遲工作項加入佇列

引數

struct kthread_worker *worker: 要使用的 kthread 工作者
struct kthread_delayed_work *dwork: 要加入佇列的 kthread 延遲工作項
unsigned long delay: 加入佇列前要等待的節拍數

描述

如果 dwork 處於空閒狀態，則等同於 kthread_queue_delayed_work()。否則，修改 dwork 的定時器，使其在 delay 後到期。如果 delay 為零，則保證 work 會立即加入佇列。

一種特殊情況是，工作項正在並行取消。這可能是由真實的 kthread_cancel_delayed_work_sync() 或另一個 kthread_mod_delayed_work() 呼叫引起的。我們讓另一個命令獲勝並在此處返回 true。返回值可用於引用計數，並且已加入佇列的工作項數量保持不變。無論如何，呼叫者應該以合理的方式同步這些操作。

此函式可以從任何上下文（包括 IRQ 處理程式）中安全呼叫。有關詳細資訊，請參見 __kthread_cancel_work() 和 kthread_delayed_work_timer_fn()。

返回

如果 dwork 處於空閒狀態並已加入佇列，則返回 false，否則返回 true。

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

引數

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

描述

取消 work 並等待其執行完成。即使工作項重新將自身加入佇列，也可以使用此函式。從此函式返回時，保證 work 不會掛起或在任何 CPU 上執行。

kthread_cancel_work_sync(delayed_work->work) 不得用於 delayed_work。請改用 kthread_cancel_delayed_work_sync()。

呼叫者必須確保在函式返回之前，上次將 work 加入佇列的工作者無法被銷燬。

返回

如果 work 處於掛起狀態，則返回 true，否則返回 false。

bool kthread_cancel_delayed_work_sync(struct kthread_delayed_work *dwork)¶: 取消 kthread 延遲工作項並等待其完成。

引數

struct kthread_delayed_work *dwork: 要取消的 kthread 延遲工作項

描述

這是用於延遲工作項的 kthread_cancel_work_sync()。

返回

如果 dwork 處於掛起狀態，則返回 true，否則返回 false。

void kthread_flush_worker(struct kthread_worker *worker)¶: 重新整理 kthread_worker 上的所有當前工作項

引數

struct kthread_worker *worker: 要重新整理的工作者

描述

等待 worker 上當前正在執行或掛起的所有工作項完成。

void kthread_destroy_worker(struct kthread_worker *worker)¶: 銷燬一個 kthread 工作者

引數

struct kthread_worker *worker: 要銷燬的工作者

描述

重新整理並銷燬 worker。簡單的重新整理就足夠了，因為 kthread 工作者 API 僅用於簡單的場景。不需要多步驟狀態機。

請注意，此函式不負責處理延遲工作項，因此呼叫者應負責在呼叫此函式之前將所有延遲工作項加入佇列或取消。

void kthread_use_mm(struct mm_struct *mm)¶: 使呼叫 kthread 在一個地址空間上執行

引數

struct mm_struct *mm: 要執行的地址空間

void kthread_unuse_mm(struct mm_struct *mm)¶: 反轉 kthread_use_mm() 的效果

引數

struct mm_struct *mm: 要執行的地址空間

void kthread_associate_blkcg(struct cgroup_subsys_state *css)¶: 將 blkcg 與當前 kthread 關聯

引數

struct cgroup_subsys_state *css: cgroup 資訊

描述

當前執行緒必須是一個 kthread。該執行緒代表其他執行緒執行作業。在某些情況下，我們希望作業附加原始執行緒的 cgroup 資訊，而不是當前執行緒的資訊。此函式將原始執行緒的 cgroup 資訊儲存在當前 kthread 上下文中，以便稍後檢索。

引用計數¶

void refcount_set(refcount_t *r, int n)¶: 設定引用計數的值

引數

refcount_t *r: 引用計數
int n: 引用計數將被設定的值

void refcount_set_release(refcount_t *r, int n)¶: 使用 release 排序設定引用計數的值

引數

refcount_t *r: 引用計數
int n: 引用計數將被設定的值

描述

當物件佔用的記憶體可能被重用來儲存另一個物件時，應該使用此函式 -- 考慮 SLAB_TYPESAFE_BY_RCU。

提供 release 記憶體排序，這將對該儲存之前的記憶體操作進行排序。這確保了對該物件的所有更新在引用計數設定後都是可見的，並且先前佔用該記憶體的物件的陳舊值將被新值覆蓋。

此函式應僅在新物件完全初始化後呼叫。在此呼叫之後，應認為該物件對其他任務可見，即使它尚未新增到通常用於發現它的物件集合中。這是因為其他任務可能已經發現了先前佔用相同記憶體的物件，並且在記憶體重用之後，它們可以成功獲取對新物件的引用計數並開始使用它。

unsigned int refcount_read(const refcount_t *r)¶: 獲取引用計數的值

引數

const refcount_t *r: 引用計數

返回

引用計數的值

bool refcount_add_not_zero(int i, refcount_t *r)¶: 向引用計數新增一個值，除非它為 0

引數

int i: 要新增到引用計數的值
refcount_t *r: 引用計數

描述

將在 REFCOUNT_SATURATED 處飽和併發出警告。

不提供記憶體排序，假設呼叫者已保證物件記憶體是穩定的（RCU 等）。它確實提供了一個控制依賴關係，從而對未來的儲存進行排序。參見頂部的註釋。

不建議將此函式用於正常的引用計數用例，在這些用例中，引用一次一個地被獲取和釋放。在這些情況下，應該使用 refcount_inc() 或其變體之一來遞增引用計數。

返回

如果傳遞的引用計數為 0，則返回 false，否則返回 true

bool refcount_add_not_zero_acquire(int i, refcount_t *r)¶: 向引用計數新增一個值，除非它為 0，否則使用 acquire 排序

引數

int i: 要新增到引用計數的值
refcount_t *r: 引用計數

描述

將在 REFCOUNT_SATURATED 處飽和併發出警告。

當物件佔用的記憶體可能被重用來儲存另一個物件時，應該使用此函式 -- 考慮 SLAB_TYPESAFE_BY_RCU。

成功時提供 acquire 記憶體排序，假設呼叫者已保證物件記憶體是穩定的（RCU 等）。它確實提供了一個控制依賴關係，從而對未來的儲存進行排序。參見頂部的註釋。

不建議將此函式用於正常的引用計數用例，在這些用例中，引用一次一個地被獲取和釋放。在這些情況下，應該使用 refcount_inc_not_zero_acquire() 來遞增引用計數。

返回

如果傳遞的引用計數為 0，則返回 false，否則返回 true

void refcount_add(int i, refcount_t *r)¶: 向引用計數新增一個值

引數

int i: 要新增到引用計數的值
refcount_t *r: 引用計數

描述

類似於 atomic_add()，但將在 REFCOUNT_SATURATED 處飽和併發出警告。

不提供記憶體排序，假設呼叫者已保證物件記憶體是穩定的（RCU 等）。它確實提供了一個控制依賴關係，從而對未來的儲存進行排序。參見頂部的註釋。

不建議將此函式用於正常的引用計數用例，在這些用例中，引用一次一個地被獲取和釋放。在這些情況下，應該使用 refcount_inc() 或其變體之一來遞增引用計數。

bool refcount_inc_not_zero(refcount_t *r)¶: 遞增引用計數，除非它為 0

引數

refcount_t *r: 要遞增的引用計數

描述

類似於 atomic_inc_not_zero()，但將在 REFCOUNT_SATURATED 處飽和併發出警告。

不提供記憶體排序，假設呼叫者已保證物件記憶體是穩定的（RCU 等）。它確實提供了一個控制依賴關係，從而對未來的儲存進行排序。參見頂部的註釋。

返回

如果遞增成功，則返回 true，否則返回 false

bool refcount_inc_not_zero_acquire(refcount_t *r)¶: 遞增引用計數，除非它為 0，否則使用 acquire 排序

引數

refcount_t *r: 要遞增的引用計數

描述

類似於 refcount_inc_not_zero()，但在成功時提供 acquire 記憶體排序。

當物件佔用的記憶體可能被重用來儲存另一個物件時，應該使用此函式 -- 考慮 SLAB_TYPESAFE_BY_RCU。

成功時提供 acquire 記憶體排序，假設呼叫者已保證物件記憶體是穩定的（RCU 等）。它確實提供了一個控制依賴關係，從而對未來的儲存進行排序。參見頂部的註釋。

返回

如果遞增成功，則返回 true，否則返回 false

void refcount_inc(refcount_t *r)¶: 遞增引用計數

引數

refcount_t *r: 要遞增的引用計數

描述

類似於 atomic_inc()，但將在 REFCOUNT_SATURATED 處飽和併發出警告。

不提供記憶體排序，假設呼叫者已經對物件進行了引用。

如果引用計數為 0，則會發出警告，因為這表示可能存在釋放後使用的情況。

bool refcount_sub_and_test(int i, refcount_t *r)¶: 從引用計數中減去一個值並測試它是否為 0

引數

int i: 要從引用計數中減去的量
refcount_t *r: 引用計數

描述

類似於 atomic_dec_and_test()，但它會在下溢時發出警告，返回 false 並最終洩漏，並且當在 REFCOUNT_SATURATED 處飽和時將無法遞減。

提供 release 記憶體排序，以便先完成先前的載入和儲存，並在成功時提供 acquire 排序，以便 free() 必須在之後進行。

不建議將此函式用於正常的引用計數用例，在這些用例中，引用一次一個地被獲取和釋放。在這些情況下，應該使用 refcount_dec() 或其變體之一來遞減引用計數。

返回

如果結果引用計數為 0，則返回 true，否則返回 false

bool refcount_dec_and_test(refcount_t *r)¶: 遞減引用計數並測試它是否為 0

引數

refcount_t *r: 引用計數

描述

類似於 atomic_dec_and_test()，它會在下溢時發出警告，並且當在 REFCOUNT_SATURATED 處飽和時將無法遞減。

提供 release 記憶體排序，以便先完成先前的載入和儲存，並在成功時提供 acquire 排序，以便 free() 必須在之後進行。

返回

如果結果引用計數為 0，則返回 true，否則返回 false

void refcount_dec(refcount_t *r)¶: 減少引用計數

引數

refcount_t *r: 引用計數

描述

類似於 atomic_dec()，它會在下溢時發出警告，並在飽和到 REFCOUNT_SATURATED 時無法減少。

提供釋放記憶體排序，以便在之前完成載入和儲存。

bool refcount_dec_if_one(refcount_t *r)¶: 如果引用計數為 1，則減少它

引數

refcount_t *r: 引用計數

描述

沒有 atomic_t 對應項，它嘗試 1 -> 0 的轉換，並返回是否成功。

與所有減少操作一樣，它提供釋放記憶體順序，並提供控制依賴關係。

它可以像嘗試刪除運算子一樣使用；提供了這個顯式情況，而不是通用的 cmpxchg，因為這將允許實現不安全的操作。

返回

如果結果引用計數為 0，則返回 true，否則返回 false

bool refcount_dec_not_one(refcount_t *r)¶: 如果引用計數不為 1，則減少它

引數

refcount_t *r: 引用計數

描述

沒有 atomic_t 對應項，除非值為 1，否則它會減少，在這種情況下它將返回 false。

通常像這樣完成：atomic_add_unless(var, -1, 1)

返回

如果減少操作成功，則為 true，否則為 false

bool refcount_dec_and_mutex_lock(refcount_t *r, struct mutex *lock)¶: 如果能夠將引用計數減少到 0，則返回持有互斥鎖

引數

refcount_t *r: 引用計數
struct mutex *lock: 要鎖定的互斥鎖

描述

類似於 atomic_dec_and_mutex_lock()，它會在下溢時發出警告，並在飽和到 REFCOUNT_SATURATED 時無法減少。

提供釋放記憶體排序，以便在之前完成載入和儲存，並提供控制依賴關係，以便 free() 必須在之後進行。請參閱頂部的註釋。

返回

如果能夠將引用計數減少到 0，則為 true 並持有互斥鎖，否則為 false: 否則

bool refcount_dec_and_lock(refcount_t *r, spinlock_t *lock)¶: 如果能夠將引用計數減少到 0，則返回持有自旋鎖

引數

refcount_t *r: 引用計數
spinlock_t *lock: 要鎖定的自旋鎖

描述

類似於 atomic_dec_and_lock()，它會在下溢時發出警告，並在飽和到 REFCOUNT_SATURATED 時無法減少。

提供釋放記憶體排序，以便在之前完成載入和儲存，並提供控制依賴關係，以便 free() 必須在之後進行。請參閱頂部的註釋。

返回

如果能夠將引用計數減少到 0，則為 true 並持有自旋鎖，否則為 false: 否則

bool refcount_dec_and_lock_irqsave(refcount_t *r, spinlock_t *lock, unsigned long *flags)¶: 如果能夠將引用計數減少到 0，則返回持有停用中斷的自旋鎖

引數

refcount_t *r: 引用計數
spinlock_t *lock: 要鎖定的自旋鎖
unsigned long *flags: 如果獲得了 IRQ，則儲存的 IRQ 標誌

描述

與上面的 refcount_dec_and_lock() 相同，只是使用停用中斷的方式獲得自旋鎖。

返回

如果能夠將引用計數減少到 0，則為 true 並持有自旋鎖，否則為 false: 否則

原子操作¶

int atomic_read(const atomic_t *v)¶: 具有寬鬆排序的原子載入

引數

const atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用寬鬆排序載入 v 的值。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_read()。

返回

從 v 載入的值。

int atomic_read_acquire(const atomic_t *v)¶: 具有獲取排序的原子載入

引數

const atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用獲取排序載入 v 的值。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_read_acquire()。

返回

從 v 載入的值。

void atomic_set(atomic_t *v, int i)¶: 具有寬鬆排序的原子設定

引數

atomic_t *v: 指向 atomic_t 的指標
int i: 要分配的 int 值

描述

以原子方式使用寬鬆排序將 v 設定為 i。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_set()。

返回

沒有。

void atomic_set_release(atomic_t *v, int i)¶: 具有釋放排序的原子設定

引數

atomic_t *v: 指向 atomic_t 的指標
int i: 要分配的 int 值

描述

以原子方式使用釋放排序將 v 設定為 i。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_set_release()。

返回

沒有。

void atomic_add(int i, atomic_t *v)¶: 具有寬鬆排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_add()。

返回

沒有。

int atomic_add_return(int i, atomic_t *v)¶: 具有完整排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_add_return()。

返回

v 的更新值。

int atomic_add_return_acquire(int i, atomic_t *v)¶: 具有獲取排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_add_return_acquire()。

返回

v 的更新值。

int atomic_add_return_release(int i, atomic_t *v)¶: 具有釋放排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_add_return_release()。

返回

v 的更新值。

int atomic_add_return_relaxed(int i, atomic_t *v)¶: 具有寬鬆排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_add_return_relaxed()。

返回

v 的更新值。

int atomic_fetch_add(int i, atomic_t *v)¶: 具有完整排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_fetch_add()。

返回

v 的原始值。

int atomic_fetch_add_acquire(int i, atomic_t *v)¶: 具有獲取排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_fetch_add_acquire()。

返回

v 的原始值。

int atomic_fetch_add_release(int i, atomic_t *v)¶: 具有釋放排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_fetch_add_release()。

返回

v 的原始值。

int atomic_fetch_add_relaxed(int i, atomic_t *v)¶: 具有寬鬆排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_fetch_add_relaxed()。

返回

v 的原始值。

void atomic_sub(int i, atomic_t *v)¶: 具有寬鬆排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_sub()。

返回

沒有。

int atomic_sub_return(int i, atomic_t *v)¶: 具有完整排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_sub_return()。

返回

v 的更新值。

int atomic_sub_return_acquire(int i, atomic_t *v)¶: 具有獲取排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_sub_return_acquire()。

返回

v 的更新值。

int atomic_sub_return_release(int i, atomic_t *v)¶: 具有釋放排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_sub_return_release()。

返回

v 的更新值。

int atomic_sub_return_relaxed(int i, atomic_t *v)¶: 具有寬鬆排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用不安全；在那裡使用 raw_atomic_sub_return_relaxed()。

返回

v 的更新值。

int atomic_fetch_sub(int i, atomic_t *v)¶: 具有完整排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_sub()。

返回

v 的原始值。

int atomic_fetch_sub_acquire(int i, atomic_t *v)¶: 具有獲取排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_sub_acquire()。

返回

v 的原始值。

int atomic_fetch_sub_release(int i, atomic_t *v)¶: 具有釋放排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_sub_release()。

返回

v 的原始值。

int atomic_fetch_sub_relaxed(int i, atomic_t *v)¶: 具有寬鬆排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_sub_relaxed()。

返回

v 的原始值。

void atomic_inc(atomic_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_inc()。

返回

沒有。

int atomic_inc_return(atomic_t *v)¶: 使用完整排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_inc_return()。

返回

v 的更新值。

int atomic_inc_return_acquire(atomic_t *v)¶: 使用獲取排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用獲取排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_inc_return_acquire()。

返回

v 的更新值。

int atomic_inc_return_release(atomic_t *v)¶: 使用釋放排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用釋放排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_inc_return_release()。

返回

v 的更新值。

int atomic_inc_return_relaxed(atomic_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_inc_return_relaxed()。

返回

v 的更新值。

int atomic_fetch_inc(atomic_t *v)¶: 使用完整排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_inc()。

返回

v 的原始值。

int atomic_fetch_inc_acquire(atomic_t *v)¶: 使用獲取排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用獲取排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_inc_acquire()。

返回

v 的原始值。

int atomic_fetch_inc_release(atomic_t *v)¶: 使用釋放排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用釋放排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_inc_release()。

返回

v 的原始值。

int atomic_fetch_inc_relaxed(atomic_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_inc_relaxed()。

返回

v 的原始值。

void atomic_dec(atomic_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_dec()。

返回

沒有。

int atomic_dec_return(atomic_t *v)¶: 使用完整排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_dec_return()。

返回

v 的更新值。

int atomic_dec_return_acquire(atomic_t *v)¶: 使用獲取排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用獲取排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_dec_return_acquire()。

返回

v 的更新值。

int atomic_dec_return_release(atomic_t *v)¶: 使用釋放排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用釋放排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_dec_return_release()。

返回

v 的更新值。

int atomic_dec_return_relaxed(atomic_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_dec_return_relaxed()。

返回

v 的更新值。

int atomic_fetch_dec(atomic_t *v)¶: 使用完整排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_dec()。

返回

v 的原始值。

int atomic_fetch_dec_acquire(atomic_t *v)¶: 使用獲取排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用獲取排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_dec_acquire()。

返回

v 的原始值。

int atomic_fetch_dec_release(atomic_t *v)¶: 使用釋放排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用釋放排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_dec_release()。

返回

v 的原始值。

int atomic_fetch_dec_relaxed(atomic_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_dec_relaxed()。

返回

v 的原始值。

void atomic_and(int i, atomic_t *v)¶: 使用寬鬆排序的原子按位與

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_and()。

返回

沒有。

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

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

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

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_and()。

返回

v 的原始值。

int atomic_fetch_and_acquire(int i, atomic_t *v)¶: 使用獲取排序的原子按位與

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

使用獲取排序原子地更新 v 為 (v & i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_and_acquire()。

返回

v 的原始值。

int atomic_fetch_and_release(int i, atomic_t *v)¶: 使用釋放排序的原子按位與

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

使用釋放排序原子地更新 v 為 (v & i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_and_release()。

返回

v 的原始值。

int atomic_fetch_and_relaxed(int i, atomic_t *v)¶: 使用寬鬆排序的原子按位與

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_and_relaxed()。

返回

v 的原始值。

void atomic_andnot(int i, atomic_t *v)¶: 使用寬鬆排序的原子按位與非

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & ~i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_andnot()。

返回

沒有。

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

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

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

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_andnot()。

返回

v 的原始值。

int atomic_fetch_andnot_acquire(int i, atomic_t *v)¶: 具有獲取順序的原子按位與非操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v & ~i)，並具有獲取順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_andnot_acquire()。

返回

v 的原始值。

int atomic_fetch_andnot_release(int i, atomic_t *v)¶: 具有釋放順序的原子按位與非操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v & ~i)，並具有釋放順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_andnot_release()。

返回

v 的原始值。

int atomic_fetch_andnot_relaxed(int i, atomic_t *v)¶: 使用寬鬆排序的原子按位與非

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & ~i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_andnot_relaxed()。

返回

v 的原始值。

void atomic_or(int i, atomic_t *v)¶: 具有寬鬆順序的原子按位或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有寬鬆順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_or()。

返回

沒有。

int atomic_fetch_or(int i, atomic_t *v)¶: 具有完整順序的原子按位或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有完整順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_or()。

返回

v 的原始值。

int atomic_fetch_or_acquire(int i, atomic_t *v)¶: 具有獲取順序的原子按位或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有獲取順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_or_acquire()。

返回

v 的原始值。

int atomic_fetch_or_release(int i, atomic_t *v)¶: 具有釋放順序的原子按位或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有釋放順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_or_release()。

返回

v 的原始值。

int atomic_fetch_or_relaxed(int i, atomic_t *v)¶: 具有寬鬆順序的原子按位或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有寬鬆順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_or_relaxed()。

返回

v 的原始值。

void atomic_xor(int i, atomic_t *v)¶: 具有寬鬆順序的原子按位異或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有寬鬆順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_xor()。

返回

沒有。

int atomic_fetch_xor(int i, atomic_t *v)¶: 具有完整順序的原子按位異或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有完整順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_xor()。

返回

v 的原始值。

int atomic_fetch_xor_acquire(int i, atomic_t *v)¶: 具有獲取順序的原子按位異或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有獲取順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_xor_acquire()。

返回

v 的原始值。

int atomic_fetch_xor_release(int i, atomic_t *v)¶: 具有釋放順序的原子按位異或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有釋放順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_xor_release()。

返回

v 的原始值。

int atomic_fetch_xor_relaxed(int i, atomic_t *v)¶: 具有寬鬆順序的原子按位異或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有寬鬆順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_fetch_xor_relaxed()。

返回

v 的原始值。

int atomic_xchg(atomic_t *v, int new)¶: 具有完整順序的原子交換

引數

atomic_t *v: 指向 atomic_t 的指標
int new: 要分配的 int 值

描述

以原子方式更新 v 為 new，並具有完整順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_xchg()。

返回

v 的原始值。

int atomic_xchg_acquire(atomic_t *v, int new)¶: 具有獲取順序的原子交換

引數

atomic_t *v: 指向 atomic_t 的指標
int new: 要分配的 int 值

描述

以原子方式更新 v 為 new，並具有獲取順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_xchg_acquire()。

返回

v 的原始值。

int atomic_xchg_release(atomic_t *v, int new)¶: 具有釋放順序的原子交換

引數

atomic_t *v: 指向 atomic_t 的指標
int new: 要分配的 int 值

描述

以原子方式更新 v 為 new，並具有釋放順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_xchg_release()。

返回

v 的原始值。

int atomic_xchg_relaxed(atomic_t *v, int new)¶: 具有寬鬆順序的原子交換

引數

atomic_t *v: 指向 atomic_t 的指標
int new: 要分配的 int 值

描述

以原子方式更新 v 為 new，並具有寬鬆順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_xchg_relaxed()。

返回

v 的原始值。

int atomic_cmpxchg(atomic_t *v, int old, int new)¶: 具有完整順序的原子比較和交換

引數

atomic_t *v: 指向 atomic_t 的指標
int old: 用於比較的整數值
int new: 要分配的 int 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有完整順序。否則，v 不會被修改，並提供寬鬆順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_cmpxchg()。

返回

v 的原始值。

int atomic_cmpxchg_acquire(atomic_t *v, int old, int new)¶: 具有獲取順序的原子比較和交換

引數

atomic_t *v: 指向 atomic_t 的指標
int old: 用於比較的整數值
int new: 要分配的 int 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有獲取順序。否則，v 不會被修改，並提供寬鬆順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_cmpxchg_acquire()。

返回

v 的原始值。

int atomic_cmpxchg_release(atomic_t *v, int old, int new)¶: 具有釋放順序的原子比較和交換

引數

atomic_t *v: 指向 atomic_t 的指標
int old: 用於比較的整數值
int new: 要分配的 int 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有釋放順序。否則，v 不會被修改，並提供寬鬆順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_cmpxchg_release()。

返回

v 的原始值。

int atomic_cmpxchg_relaxed(atomic_t *v, int old, int new)¶: 具有寬鬆順序的原子比較和交換

引數

atomic_t *v: 指向 atomic_t 的指標
int old: 用於比較的整數值
int new: 要分配的 int 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有寬鬆順序。否則，v 不會被修改，並提供寬鬆順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_cmpxchg_relaxed()。

返回

v 的原始值。

bool atomic_try_cmpxchg(atomic_t *v, int *old, int new)¶: 具有完整順序的原子比較和交換

引數

atomic_t *v: 指向 atomic_t 的指標
int *old: 指向用於比較的整數值的指標
int new: 要分配的 int 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有完整順序。否則，v 不會被修改， old 會更新為 v 的當前值，並提供寬鬆順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_try_cmpxchg()。

返回

如果發生交換，則為 true，否則為 false。

bool atomic_try_cmpxchg_acquire(atomic_t *v, int *old, int new)¶: 具有獲取順序的原子比較和交換

引數

atomic_t *v: 指向 atomic_t 的指標
int *old: 指向用於比較的整數值的指標
int new: 要分配的 int 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有獲取順序。否則，v 不會被修改， old 會更新為 v 的當前值，並提供寬鬆順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_try_cmpxchg_acquire()。

返回

如果發生交換，則為 true，否則為 false。

bool atomic_try_cmpxchg_release(atomic_t *v, int *old, int new)¶: 具有釋放順序的原子比較和交換

引數

atomic_t *v: 指向 atomic_t 的指標
int *old: 指向用於比較的整數值的指標
int new: 要分配的 int 值

描述

如果 (v == old)，則以原子方式使用 release ordering 將 v 更新為 new。否則，v 不會被修改，old 會被更新為 v 的當前值，並提供 relaxed ordering。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic_try_cmpxchg_release()。

返回

如果發生交換，則為 true，否則為 false。

bool atomic_try_cmpxchg_relaxed(atomic_t *v, int *old, int new)¶: 具有寬鬆順序的原子比較和交換

引數

atomic_t *v: 指向 atomic_t 的指標
int *old: 指向用於比較的整數值的指標
int new: 要分配的 int 值

描述

如果 (v == old)，則以原子方式使用 relaxed ordering 將 v 更新為 new。否則，v 不會被修改，old 會被更新為 v 的當前值，並提供 relaxed ordering。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic_try_cmpxchg_relaxed()。

返回

如果發生交換，則為 true，否則為 false。

bool atomic_sub_and_test(int i, atomic_t *v)¶: 原子減法並測試是否為零，使用 full ordering

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic_sub_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool atomic_dec_and_test(atomic_t *v)¶: 原子遞減並測試是否為零，使用 full ordering

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic_dec_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool atomic_inc_and_test(atomic_t *v)¶: 原子遞增並測試是否為零，使用 full ordering

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic_inc_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool atomic_add_negative(int i, atomic_t *v)¶: 原子加法並測試是否為負數，使用 full ordering

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic_add_negative()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool atomic_add_negative_acquire(int i, atomic_t *v)¶: 原子加法並測試是否為負數，使用 acquire ordering

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic_add_negative_acquire()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool atomic_add_negative_release(int i, atomic_t *v)¶: 原子加法並測試是否為負數，使用 release ordering

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic_add_negative_release()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool atomic_add_negative_relaxed(int i, atomic_t *v)¶: 原子加法並測試是否為負數，使用 relaxed ordering

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic_add_negative_relaxed()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

int atomic_fetch_add_unless(atomic_t *v, int a, int u)¶: 原子加法，除非值為 full ordering

引數

atomic_t *v: 指向 atomic_t 的指標
int a: 要新增的 int 值
int u: 用於比較的整數值

描述

如果 (v != u)，則以原子方式使用 full ordering 將 v 更新為 (v + a)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic_fetch_add_unless()。

返回

v 的原始值。

bool atomic_add_unless(atomic_t *v, int a, int u)¶: 原子加法，除非值為 full ordering

引數

atomic_t *v: 指向 atomic_t 的指標
int a: 要新增的 int 值
int u: 用於比較的整數值

描述

如果 (v != u)，則以原子方式使用 full ordering 將 v 更新為 (v + a)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic_add_unless()。

返回

如果 v 已更新，則為 true，否則為 false。

bool atomic_inc_not_zero(atomic_t *v)¶: 原子遞增，除非為零，使用 full ordering

引數

atomic_t *v: 指向 atomic_t 的指標

描述

如果 (v != 0)，則以原子方式使用 full ordering 將 v 更新為 (v + 1)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic_inc_not_zero()。

返回

如果 v 已更新，則為 true，否則為 false。

bool atomic_inc_unless_negative(atomic_t *v)¶: 原子遞增，除非為負數，使用 full ordering

引數

atomic_t *v: 指向 atomic_t 的指標

描述

如果 (v >= 0)，則以原子方式使用 full ordering 將 v 更新為 (v + 1)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic_inc_unless_negative()。

返回

如果 v 已更新，則為 true，否則為 false。

bool atomic_dec_unless_positive(atomic_t *v)¶: 原子遞減，除非為正數，使用 full ordering

引數

atomic_t *v: 指向 atomic_t 的指標

描述

如果 (v <= 0)，則以原子方式使用 full ordering 將 v 更新為 (v - 1)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic_dec_unless_positive()。

返回

如果 v 已更新，則為 true，否則為 false。

int atomic_dec_if_positive(atomic_t *v)¶: 原子遞減（如果為正數），使用 full ordering

引數

atomic_t *v: 指向 atomic_t 的指標

描述

如果 (v > 0)，則以原子方式使用 full ordering 將 v 更新為 (v - 1)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic_dec_if_positive()。

返回

(v - 1) 的舊值，無論 v 是否已更新。

s64 atomic64_read(const atomic64_t *v)¶: 具有寬鬆排序的原子載入

引數

const atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用寬鬆排序載入 v 的值。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic64_read()。

返回

從 v 載入的值。

s64 atomic64_read_acquire(const atomic64_t *v)¶: 具有獲取排序的原子載入

引數

const atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用獲取排序載入 v 的值。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic64_read_acquire()。

返回

從 v 載入的值。

void atomic64_set(atomic64_t *v, s64 i)¶: 具有寬鬆排序的原子設定

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 i: 要分配的 s64 值

描述

以原子方式使用寬鬆排序將 v 設定為 i。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic64_set()。

返回

沒有。

void atomic64_set_release(atomic64_t *v, s64 i)¶: 具有釋放排序的原子設定

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 i: 要分配的 s64 值

描述

以原子方式使用釋放排序將 v 設定為 i。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic64_set_release()。

返回

沒有。

void atomic64_add(s64 i, atomic64_t *v)¶: 具有寬鬆排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic64_add()。

返回

沒有。

s64 atomic64_add_return(s64 i, atomic64_t *v)¶: 具有完整排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic64_add_return()。

返回

v 的更新值。

s64 atomic64_add_return_acquire(s64 i, atomic64_t *v)¶: 具有獲取排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic64_add_return_acquire()。

返回

v 的更新值。

s64 atomic64_add_return_release(s64 i, atomic64_t *v)¶: 具有釋放排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic64_add_return_release()。

返回

v 的更新值。

s64 atomic64_add_return_relaxed(s64 i, atomic64_t *v)¶: 具有寬鬆排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic64_add_return_relaxed()。

返回

v 的更新值。

s64 atomic64_fetch_add(s64 i, atomic64_t *v)¶: 具有完整排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；在那裡使用 raw_atomic64_fetch_add()。

返回

v 的原始值。

s64 atomic64_fetch_add_acquire(s64 i, atomic64_t *v)¶: 具有獲取排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_fetch_add_acquire()。

返回

v 的原始值。

s64 atomic64_fetch_add_release(s64 i, atomic64_t *v)¶: 具有釋放排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_fetch_add_release()。

返回

v 的原始值。

s64 atomic64_fetch_add_relaxed(s64 i, atomic64_t *v)¶: 具有寬鬆排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_fetch_add_relaxed()。

返回

v 的原始值。

void atomic64_sub(s64 i, atomic64_t *v)¶: 具有寬鬆排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_sub()。

返回

沒有。

s64 atomic64_sub_return(s64 i, atomic64_t *v)¶: 具有完整排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_sub_return()。

返回

v 的更新值。

s64 atomic64_sub_return_acquire(s64 i, atomic64_t *v)¶: 具有獲取排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_sub_return_acquire()。

返回

v 的更新值。

s64 atomic64_sub_return_release(s64 i, atomic64_t *v)¶: 具有釋放排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_sub_return_release()。

返回

v 的更新值。

s64 atomic64_sub_return_relaxed(s64 i, atomic64_t *v)¶: 具有寬鬆排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_sub_return_relaxed()。

返回

v 的更新值。

s64 atomic64_fetch_sub(s64 i, atomic64_t *v)¶: 具有完整排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_fetch_sub()。

返回

v 的原始值。

s64 atomic64_fetch_sub_acquire(s64 i, atomic64_t *v)¶: 具有獲取排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_fetch_sub_acquire()。

返回

v 的原始值。

s64 atomic64_fetch_sub_release(s64 i, atomic64_t *v)¶: 具有釋放排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_fetch_sub_release()。

返回

v 的原始值。

s64 atomic64_fetch_sub_relaxed(s64 i, atomic64_t *v)¶: 具有寬鬆排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_fetch_sub_relaxed()。

返回

v 的原始值。

void atomic64_inc(atomic64_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_inc()。

返回

沒有。

s64 atomic64_inc_return(atomic64_t *v)¶: 使用完整排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_inc_return()。

返回

v 的更新值。

s64 atomic64_inc_return_acquire(atomic64_t *v)¶: 使用獲取排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用獲取排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_inc_return_acquire()。

返回

v 的更新值。

s64 atomic64_inc_return_release(atomic64_t *v)¶: 使用釋放排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用釋放排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_inc_return_release()。

返回

v 的更新值。

s64 atomic64_inc_return_relaxed(atomic64_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_inc_return_relaxed()。

返回

v 的更新值。

s64 atomic64_fetch_inc(atomic64_t *v)¶: 使用完整排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_fetch_inc()。

返回

v 的原始值。

s64 atomic64_fetch_inc_acquire(atomic64_t *v)¶: 使用獲取排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用獲取排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_fetch_inc_acquire()。

返回

v 的原始值。

s64 atomic64_fetch_inc_release(atomic64_t *v)¶: 使用釋放排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用釋放排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_fetch_inc_release()。

返回

v 的原始值。

s64 atomic64_fetch_inc_relaxed(atomic64_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_fetch_inc_relaxed()。

返回

v 的原始值。

void atomic64_dec(atomic64_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_dec()。

返回

沒有。

s64 atomic64_dec_return(atomic64_t *v)¶: 使用完整排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_dec_return()。

返回

v 的更新值。

s64 atomic64_dec_return_acquire(atomic64_t *v)¶: 使用獲取排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用獲取排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_dec_return_acquire()。

返回

v 的更新值。

s64 atomic64_dec_return_release(atomic64_t *v)¶: 使用釋放排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用釋放排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_dec_return_release()。

返回

v 的更新值。

s64 atomic64_dec_return_relaxed(atomic64_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_dec_return_relaxed()。

返回

v 的更新值。

s64 atomic64_fetch_dec(atomic64_t *v)¶: 使用完整排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_fetch_dec()。

返回

v 的原始值。

s64 atomic64_fetch_dec_acquire(atomic64_t *v)¶: 使用獲取排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用獲取排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_fetch_dec_acquire()。

返回

v 的原始值。

s64 atomic64_fetch_dec_release(atomic64_t *v)¶: 使用釋放排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用釋放排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_fetch_dec_release()。

返回

v 的原始值。

s64 atomic64_fetch_dec_relaxed(atomic64_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_fetch_dec_relaxed()。

返回

v 的原始值。

void atomic64_and(s64 i, atomic64_t *v)¶: 使用寬鬆排序的原子按位與

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & i)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_and()。

返回

沒有。

s64 atomic64_fetch_and(s64 i, atomic64_t *v)¶: 使用完整排序的原子按位與

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

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

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_fetch_and()。

返回

v 的原始值。

s64 atomic64_fetch_and_acquire(s64 i, atomic64_t *v)¶: 使用獲取排序的原子按位與

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

使用獲取排序原子地更新 v 為 (v & i)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_fetch_and_acquire()。

返回

v 的原始值。

s64 atomic64_fetch_and_release(s64 i, atomic64_t *v)¶: 使用釋放排序的原子按位與

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

使用釋放排序原子地更新 v 為 (v & i)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_fetch_and_release()。

返回

v 的原始值。

s64 atomic64_fetch_and_relaxed(s64 i, atomic64_t *v)¶: 使用寬鬆排序的原子按位與

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & i)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_fetch_and_relaxed()。

返回

v 的原始值。

void atomic64_andnot(s64 i, atomic64_t *v)¶: 使用寬鬆排序的原子按位與非

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & ~i)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_andnot()。

返回

沒有。

s64 atomic64_fetch_andnot(s64 i, atomic64_t *v)¶: 使用完整排序的原子按位與非

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

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

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_fetch_andnot()。

返回

v 的原始值。

s64 atomic64_fetch_andnot_acquire(s64 i, atomic64_t *v)¶: 具有獲取順序的原子按位與非操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v & ~i)，並具有獲取順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_fetch_andnot_acquire()。

返回

v 的原始值。

s64 atomic64_fetch_andnot_release(s64 i, atomic64_t *v)¶: 具有釋放順序的原子按位與非操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v & ~i)，並具有釋放順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_fetch_andnot_release()。

返回

v 的原始值。

s64 atomic64_fetch_andnot_relaxed(s64 i, atomic64_t *v)¶: 使用寬鬆排序的原子按位與非

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & ~i)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_fetch_andnot_relaxed()。

返回

v 的原始值。

void atomic64_or(s64 i, atomic64_t *v)¶: 具有寬鬆順序的原子按位或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_or()。

返回

沒有。

s64 atomic64_fetch_or(s64 i, atomic64_t *v)¶: 具有完整順序的原子按位或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有完整順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_fetch_or()。

返回

v 的原始值。

s64 atomic64_fetch_or_acquire(s64 i, atomic64_t *v)¶: 具有獲取順序的原子按位或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有獲取順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_fetch_or_acquire()。

返回

v 的原始值。

s64 atomic64_fetch_or_release(s64 i, atomic64_t *v)¶: 具有釋放順序的原子按位或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有釋放順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_fetch_or_release()。

返回

v 的原始值。

s64 atomic64_fetch_or_relaxed(s64 i, atomic64_t *v)¶: 具有寬鬆順序的原子按位或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_fetch_or_relaxed()。

返回

v 的原始值。

void atomic64_xor(s64 i, atomic64_t *v)¶: 具有寬鬆順序的原子按位異或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_xor()。

返回

沒有。

s64 atomic64_fetch_xor(s64 i, atomic64_t *v)¶: 具有完整順序的原子按位異或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有完整順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_fetch_xor()。

返回

v 的原始值。

s64 atomic64_fetch_xor_acquire(s64 i, atomic64_t *v)¶: 具有獲取順序的原子按位異或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有獲取順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_fetch_xor_acquire()。

返回

v 的原始值。

s64 atomic64_fetch_xor_release(s64 i, atomic64_t *v)¶: 具有釋放順序的原子按位異或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有釋放順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_fetch_xor_release()。

返回

v 的原始值。

s64 atomic64_fetch_xor_relaxed(s64 i, atomic64_t *v)¶: 具有寬鬆順序的原子按位異或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_fetch_xor_relaxed()。

返回

v 的原始值。

s64 atomic64_xchg(atomic64_t *v, s64 new)¶: 具有完整順序的原子交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 new: 要分配的 s64 值

描述

以原子方式更新 v 為 new，並具有完整順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_xchg()。

返回

v 的原始值。

s64 atomic64_xchg_acquire(atomic64_t *v, s64 new)¶: 具有獲取順序的原子交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 new: 要分配的 s64 值

描述

以原子方式更新 v 為 new，並具有獲取順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_xchg_acquire()。

返回

v 的原始值。

s64 atomic64_xchg_release(atomic64_t *v, s64 new)¶: 具有釋放順序的原子交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 new: 要分配的 s64 值

描述

以原子方式更新 v 為 new，並具有釋放順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_xchg_release()。

返回

v 的原始值。

s64 atomic64_xchg_relaxed(atomic64_t *v, s64 new)¶: 具有寬鬆順序的原子交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 new: 要分配的 s64 值

描述

以原子方式更新 v 為 new，並具有寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_xchg_relaxed()。

返回

v 的原始值。

s64 atomic64_cmpxchg(atomic64_t *v, s64 old, s64 new)¶: 具有完整順序的原子比較和交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 old: 要比較的 s64 值
s64 new: 要分配的 s64 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有完整順序。否則，v 不會被修改，並提供寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_cmpxchg()。

返回

v 的原始值。

s64 atomic64_cmpxchg_acquire(atomic64_t *v, s64 old, s64 new)¶: 具有獲取順序的原子比較和交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 old: 要比較的 s64 值
s64 new: 要分配的 s64 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有獲取順序。否則，v 不會被修改，並提供寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic64_cmpxchg_acquire()。

返回

v 的原始值。

s64 atomic64_cmpxchg_release(atomic64_t *v, s64 old, s64 new)¶: 具有釋放順序的原子比較和交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 old: 要比較的 s64 值
s64 new: 要分配的 s64 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有釋放順序。否則，v 不會被修改，並提供寬鬆順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_cmpxchg_release()。

返回

v 的原始值。

s64 atomic64_cmpxchg_relaxed(atomic64_t *v, s64 old, s64 new)¶: 具有寬鬆順序的原子比較和交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 old: 要比較的 s64 值
s64 new: 要分配的 s64 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有寬鬆順序。否則，v 不會被修改，並提供寬鬆順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_cmpxchg_relaxed()。

返回

v 的原始值。

bool atomic64_try_cmpxchg(atomic64_t *v, s64 *old, s64 new)¶: 具有完整順序的原子比較和交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 *old: 與要比較的 s64 值的指標
s64 new: 要分配的 s64 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有完整順序。否則，v 不會被修改， old 會更新為 v 的當前值，並提供寬鬆順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_try_cmpxchg()。

返回

如果發生交換，則為 true，否則為 false。

bool atomic64_try_cmpxchg_acquire(atomic64_t *v, s64 *old, s64 new)¶: 具有獲取順序的原子比較和交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 *old: 與要比較的 s64 值的指標
s64 new: 要分配的 s64 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有獲取順序。否則，v 不會被修改， old 會更新為 v 的當前值，並提供寬鬆順序。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_try_cmpxchg_acquire()。

返回

如果發生交換，則為 true，否則為 false。

bool atomic64_try_cmpxchg_release(atomic64_t *v, s64 *old, s64 new)¶: 具有釋放順序的原子比較和交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 *old: 與要比較的 s64 值的指標
s64 new: 要分配的 s64 值

描述

如果 (v == old)，則以原子方式使用 release ordering 將 v 更新為 new。否則，v 不會被修改，old 會被更新為 v 的當前值，並提供 relaxed ordering。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_try_cmpxchg_release()。

返回

如果發生交換，則為 true，否則為 false。

bool atomic64_try_cmpxchg_relaxed(atomic64_t *v, s64 *old, s64 new)¶: 具有寬鬆順序的原子比較和交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 *old: 與要比較的 s64 值的指標
s64 new: 要分配的 s64 值

描述

如果 (v == old)，則以原子方式使用 relaxed ordering 將 v 更新為 new。否則，v 不會被修改，old 會被更新為 v 的當前值，並提供 relaxed ordering。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_try_cmpxchg_relaxed()。

返回

如果發生交換，則為 true，否則為 false。

bool atomic64_sub_and_test(s64 i, atomic64_t *v)¶: 原子減法並測試是否為零，使用 full ordering

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_sub_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool atomic64_dec_and_test(atomic64_t *v)¶: 原子遞減並測試是否為零，使用 full ordering

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_dec_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool atomic64_inc_and_test(atomic64_t *v)¶: 原子遞增並測試是否為零，使用 full ordering

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_inc_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool atomic64_add_negative(s64 i, atomic64_t *v)¶: 原子加法並測試是否為負數，使用 full ordering

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_add_negative()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool atomic64_add_negative_acquire(s64 i, atomic64_t *v)¶: 原子加法並測試是否為負數，使用 acquire ordering

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_add_negative_acquire()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool atomic64_add_negative_release(s64 i, atomic64_t *v)¶: 原子加法並測試是否為負數，使用 release ordering

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_add_negative_release()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool atomic64_add_negative_relaxed(s64 i, atomic64_t *v)¶: 原子加法並測試是否為負數，使用 relaxed ordering

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_add_negative_relaxed()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

s64 atomic64_fetch_add_unless(atomic64_t *v, s64 a, s64 u)¶: 原子加法，除非值為 full ordering

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 a: 要新增的 s64 值
s64 u: 要比較的 s64 值

描述

如果 (v != u)，則以原子方式使用 full ordering 將 v 更新為 (v + a)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_fetch_add_unless()。

返回

v 的原始值。

bool atomic64_add_unless(atomic64_t *v, s64 a, s64 u)¶: 原子加法，除非值為 full ordering

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 a: 要新增的 s64 值
s64 u: 要比較的 s64 值

描述

如果 (v != u)，則以原子方式使用 full ordering 將 v 更新為 (v + a)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_add_unless()。

返回

如果 v 已更新，則為 true，否則為 false。

bool atomic64_inc_not_zero(atomic64_t *v)¶: 原子遞增，除非為零，使用 full ordering

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

如果 (v != 0)，則以原子方式使用 full ordering 將 v 更新為 (v + 1)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_inc_not_zero()。

返回

如果 v 已更新，則為 true，否則為 false。

bool atomic64_inc_unless_negative(atomic64_t *v)¶: 原子遞增，除非為負數，使用 full ordering

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

如果 (v >= 0)，則以原子方式使用 full ordering 將 v 更新為 (v + 1)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_inc_unless_negative()。

返回

如果 v 已更新，則為 true，否則為 false。

bool atomic64_dec_unless_positive(atomic64_t *v)¶: 原子遞減，除非為正數，使用 full ordering

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

如果 (v <= 0)，則以原子方式使用 full ordering 將 v 更新為 (v - 1)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_dec_unless_positive()。

返回

如果 v 已更新，則為 true，否則為 false。

s64 atomic64_dec_if_positive(atomic64_t *v)¶: 原子遞減（如果為正數），使用 full ordering

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

如果 (v > 0)，則以原子方式使用 full ordering 將 v 更新為 (v - 1)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic64_dec_if_positive()。

返回

(v - 1) 的舊值，無論 v 是否已更新。

long atomic_long_read(const atomic_long_t *v)¶: 具有寬鬆排序的原子載入

引數

const atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用寬鬆排序載入 v 的值。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_read()。

返回

從 v 載入的值。

long atomic_long_read_acquire(const atomic_long_t *v)¶: 具有獲取排序的原子載入

引數

const atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用獲取排序載入 v 的值。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_read_acquire()。

返回

從 v 載入的值。

void atomic_long_set(atomic_long_t *v, long i)¶: 具有寬鬆排序的原子設定

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long i: 要分配的 long 值

描述

以原子方式使用寬鬆排序將 v 設定為 i。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_set()。

返回

沒有。

void atomic_long_set_release(atomic_long_t *v, long i)¶: 具有釋放排序的原子設定

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long i: 要分配的 long 值

描述

以原子方式使用釋放排序將 v 設定為 i。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_set_release()。

返回

沒有。

void atomic_long_add(long i, atomic_long_t *v)¶: 具有寬鬆排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_add()。

返回

沒有。

long atomic_long_add_return(long i, atomic_long_t *v)¶: 具有完整排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_add_return()。

返回

v 的更新值。

long atomic_long_add_return_acquire(long i, atomic_long_t *v)¶: 具有獲取排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_add_return_acquire()。

返回

v 的更新值。

long atomic_long_add_return_release(long i, atomic_long_t *v)¶: 具有釋放排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_add_return_release()。

返回

v 的更新值。

long atomic_long_add_return_relaxed(long i, atomic_long_t *v)¶: 具有寬鬆排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_add_return_relaxed()。

返回

v 的更新值。

long atomic_long_fetch_add(long i, atomic_long_t *v)¶: 具有完整排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_fetch_add()。

返回

v 的原始值。

long atomic_long_fetch_add_acquire(long i, atomic_long_t *v)¶: 具有獲取排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_fetch_add_acquire()。

返回

v 的原始值。

long atomic_long_fetch_add_release(long i, atomic_long_t *v)¶: 具有釋放排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_fetch_add_release()。

返回

v 的原始值。

long atomic_long_fetch_add_relaxed(long i, atomic_long_t *v)¶: 具有寬鬆排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_fetch_add_relaxed()。

返回

v 的原始值。

void atomic_long_sub(long i, atomic_long_t *v)¶: 具有寬鬆排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_sub()。

返回

沒有。

long atomic_long_sub_return(long i, atomic_long_t *v)¶: 具有完整排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_sub_return()。

返回

v 的更新值。

long atomic_long_sub_return_acquire(long i, atomic_long_t *v)¶: 具有獲取排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_sub_return_acquire()。

返回

v 的更新值。

long atomic_long_sub_return_release(long i, atomic_long_t *v)¶: 具有釋放排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_sub_return_release()。

返回

v 的更新值。

long atomic_long_sub_return_relaxed(long i, atomic_long_t *v)¶: 具有寬鬆排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_sub_return_relaxed()。

返回

v 的更新值。

long atomic_long_fetch_sub(long i, atomic_long_t *v)¶: 具有完整排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_fetch_sub()。

返回

v 的原始值。

long atomic_long_fetch_sub_acquire(long i, atomic_long_t *v)¶: 具有獲取排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_fetch_sub_acquire()。

返回

v 的原始值。

long atomic_long_fetch_sub_release(long i, atomic_long_t *v)¶: 具有釋放排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_fetch_sub_release()。

返回

v 的原始值。

long atomic_long_fetch_sub_relaxed(long i, atomic_long_t *v)¶: 具有寬鬆排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_fetch_sub_relaxed()。

返回

v 的原始值。

void atomic_long_inc(atomic_long_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_inc()。

返回

沒有。

long atomic_long_inc_return(atomic_long_t *v)¶: 使用完整排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_inc_return()。

返回

v 的更新值。

long atomic_long_inc_return_acquire(atomic_long_t *v)¶: 使用獲取排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用獲取排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_inc_return_acquire()。

返回

v 的更新值。

long atomic_long_inc_return_release(atomic_long_t *v)¶: 使用釋放排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用釋放排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_inc_return_release()。

返回

v 的更新值。

long atomic_long_inc_return_relaxed(atomic_long_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_inc_return_relaxed()。

返回

v 的更新值。

long atomic_long_fetch_inc(atomic_long_t *v)¶: 使用完整排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_fetch_inc()。

返回

v 的原始值。

long atomic_long_fetch_inc_acquire(atomic_long_t *v)¶: 使用獲取排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用獲取排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_fetch_inc_acquire()。

返回

v 的原始值。

long atomic_long_fetch_inc_release(atomic_long_t *v)¶: 使用釋放排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用釋放排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_fetch_inc_release()。

返回

v 的原始值。

long atomic_long_fetch_inc_relaxed(atomic_long_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_fetch_inc_relaxed()。

返回

v 的原始值。

void atomic_long_dec(atomic_long_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_dec()。

返回

沒有。

long atomic_long_dec_return(atomic_long_t *v)¶: 使用完整排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_dec_return()。

返回

v 的更新值。

long atomic_long_dec_return_acquire(atomic_long_t *v)¶: 使用獲取排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用獲取排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_dec_return_acquire()。

返回

v 的更新值。

long atomic_long_dec_return_release(atomic_long_t *v)¶: 使用釋放排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用釋放排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_dec_return_release()。

返回

v 的更新值。

long atomic_long_dec_return_relaxed(atomic_long_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_dec_return_relaxed()。

返回

v 的更新值。

long atomic_long_fetch_dec(atomic_long_t *v)¶: 使用完整排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是不安全的；請在那裡使用 raw_atomic_long_fetch_dec()。

返回

v 的原始值。

long atomic_long_fetch_dec_acquire(atomic_long_t *v)¶: 使用獲取排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用獲取排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_dec_acquire()。

返回

v 的原始值。

long atomic_long_fetch_dec_release(atomic_long_t *v)¶: 使用釋放排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用釋放排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_dec_release()。

返回

v 的原始值。

long atomic_long_fetch_dec_relaxed(atomic_long_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_dec_relaxed()。

返回

v 的原始值。

void atomic_long_and(long i, atomic_long_t *v)¶: 使用寬鬆排序的原子按位與

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & i)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_and()。

返回

沒有。

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

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

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

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_and()。

返回

v 的原始值。

long atomic_long_fetch_and_acquire(long i, atomic_long_t *v)¶: 使用獲取排序的原子按位與

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用獲取排序原子地更新 v 為 (v & i)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_and_acquire()。

返回

v 的原始值。

long atomic_long_fetch_and_release(long i, atomic_long_t *v)¶: 使用釋放排序的原子按位與

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用釋放排序原子地更新 v 為 (v & i)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_and_release()。

返回

v 的原始值。

long atomic_long_fetch_and_relaxed(long i, atomic_long_t *v)¶: 使用寬鬆排序的原子按位與

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & i)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_and_relaxed()。

返回

v 的原始值。

void atomic_long_andnot(long i, atomic_long_t *v)¶: 使用寬鬆排序的原子按位與非

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & ~i)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_andnot()。

返回

沒有。

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

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

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

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_andnot()。

返回

v 的原始值。

long atomic_long_fetch_andnot_acquire(long i, atomic_long_t *v)¶: 具有獲取順序的原子按位與非操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v & ~i)，並具有獲取順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_andnot_acquire()。

返回

v 的原始值。

long atomic_long_fetch_andnot_release(long i, atomic_long_t *v)¶: 具有釋放順序的原子按位與非操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v & ~i)，並具有釋放順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_andnot_release()。

返回

v 的原始值。

long atomic_long_fetch_andnot_relaxed(long i, atomic_long_t *v)¶: 使用寬鬆排序的原子按位與非

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & ~i)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_andnot_relaxed()。

返回

v 的原始值。

void atomic_long_or(long i, atomic_long_t *v)¶: 具有寬鬆順序的原子按位或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_or()。

返回

沒有。

long atomic_long_fetch_or(long i, atomic_long_t *v)¶: 具有完整順序的原子按位或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有完整順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_or()。

返回

v 的原始值。

long atomic_long_fetch_or_acquire(long i, atomic_long_t *v)¶: 具有獲取順序的原子按位或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有獲取順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_or_acquire()。

返回

v 的原始值。

long atomic_long_fetch_or_release(long i, atomic_long_t *v)¶: 具有釋放順序的原子按位或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有釋放順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_or_release()。

返回

v 的原始值。

long atomic_long_fetch_or_relaxed(long i, atomic_long_t *v)¶: 具有寬鬆順序的原子按位或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_or_relaxed()。

返回

v 的原始值。

void atomic_long_xor(long i, atomic_long_t *v)¶: 具有寬鬆順序的原子按位異或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_xor()。

返回

沒有。

long atomic_long_fetch_xor(long i, atomic_long_t *v)¶: 具有完整順序的原子按位異或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有完整順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_xor()。

返回

v 的原始值。

long atomic_long_fetch_xor_acquire(long i, atomic_long_t *v)¶: 具有獲取順序的原子按位異或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有獲取順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_xor_acquire()。

返回

v 的原始值。

long atomic_long_fetch_xor_release(long i, atomic_long_t *v)¶: 具有釋放順序的原子按位異或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有釋放順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_xor_release()。

返回

v 的原始值。

long atomic_long_fetch_xor_relaxed(long i, atomic_long_t *v)¶: 具有寬鬆順序的原子按位異或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_xor_relaxed()。

返回

v 的原始值。

long atomic_long_xchg(atomic_long_t *v, long new)¶: 具有完整順序的原子交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long new: 要分配的 long 值

描述

以原子方式更新 v 為 new，並具有完整順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_xchg()。

返回

v 的原始值。

long atomic_long_xchg_acquire(atomic_long_t *v, long new)¶: 具有獲取順序的原子交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long new: 要分配的 long 值

描述

以原子方式更新 v 為 new，並具有獲取順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_xchg_acquire()。

返回

v 的原始值。

long atomic_long_xchg_release(atomic_long_t *v, long new)¶: 具有釋放順序的原子交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long new: 要分配的 long 值

描述

以原子方式更新 v 為 new，並具有釋放順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_xchg_release()。

返回

v 的原始值。

long atomic_long_xchg_relaxed(atomic_long_t *v, long new)¶: 具有寬鬆順序的原子交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long new: 要分配的 long 值

描述

以原子方式更新 v 為 new，並具有寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_xchg_relaxed()。

返回

v 的原始值。

long atomic_long_cmpxchg(atomic_long_t *v, long old, long new)¶: 具有完整順序的原子比較和交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long old: 要比較的 long 值
long new: 要分配的 long 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有完整順序。否則，v 不會被修改，並提供寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_cmpxchg()。

返回

v 的原始值。

long atomic_long_cmpxchg_acquire(atomic_long_t *v, long old, long new)¶: 具有獲取順序的原子比較和交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long old: 要比較的 long 值
long new: 要分配的 long 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有獲取順序。否則，v 不會被修改，並提供寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_cmpxchg_acquire()。

返回

v 的原始值。

long atomic_long_cmpxchg_release(atomic_long_t *v, long old, long new)¶: 具有釋放順序的原子比較和交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long old: 要比較的 long 值
long new: 要分配的 long 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有釋放順序。否則，v 不會被修改，並提供寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_cmpxchg_release()。

返回

v 的原始值。

long atomic_long_cmpxchg_relaxed(atomic_long_t *v, long old, long new)¶: 具有寬鬆順序的原子比較和交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long old: 要比較的 long 值
long new: 要分配的 long 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有寬鬆順序。否則，v 不會被修改，並提供寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_cmpxchg_relaxed()。

返回

v 的原始值。

bool atomic_long_try_cmpxchg(atomic_long_t *v, long *old, long new)¶: 具有完整順序的原子比較和交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long *old: 與要比較的 long 值對應的指標
long new: 要分配的 long 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有完整順序。否則，v 不會被修改， old 會更新為 v 的當前值，並提供寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_try_cmpxchg()。

返回

如果發生交換，則為 true，否則為 false。

bool atomic_long_try_cmpxchg_acquire(atomic_long_t *v, long *old, long new)¶: 具有獲取順序的原子比較和交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long *old: 與要比較的 long 值對應的指標
long new: 要分配的 long 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有獲取順序。否則，v 不會被修改， old 會更新為 v 的當前值，並提供寬鬆順序。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_try_cmpxchg_acquire()。

返回

如果發生交換，則為 true，否則為 false。

bool atomic_long_try_cmpxchg_release(atomic_long_t *v, long *old, long new)¶: 具有釋放順序的原子比較和交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long *old: 與要比較的 long 值對應的指標
long new: 要分配的 long 值

描述

如果 (v == old)，則以原子方式使用 release ordering 將 v 更新為 new。否則，v 不會被修改，old 會被更新為 v 的當前值，並提供 relaxed ordering。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_try_cmpxchg_release()。

返回

如果發生交換，則為 true，否則為 false。

bool atomic_long_try_cmpxchg_relaxed(atomic_long_t *v, long *old, long new)¶: 具有寬鬆順序的原子比較和交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long *old: 與要比較的 long 值對應的指標
long new: 要分配的 long 值

描述

如果 (v == old)，則以原子方式使用 relaxed ordering 將 v 更新為 new。否則，v 不會被修改，old 會被更新為 v 的當前值，並提供 relaxed ordering。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_try_cmpxchg_relaxed()。

返回

如果發生交換，則為 true，否則為 false。

bool atomic_long_sub_and_test(long i, atomic_long_t *v)¶: 原子減法並測試是否為零，使用 full ordering

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_sub_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool atomic_long_dec_and_test(atomic_long_t *v)¶: 原子遞減並測試是否為零，使用 full ordering

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_dec_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool atomic_long_inc_and_test(atomic_long_t *v)¶: 原子遞增並測試是否為零，使用 full ordering

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_inc_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool atomic_long_add_negative(long i, atomic_long_t *v)¶: 原子加法並測試是否為負數，使用 full ordering

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_add_negative()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool atomic_long_add_negative_acquire(long i, atomic_long_t *v)¶: 原子加法並測試是否為負數，使用 acquire ordering

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_add_negative_acquire()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool atomic_long_add_negative_release(long i, atomic_long_t *v)¶: 原子加法並測試是否為負數，使用 release ordering

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_add_negative_release()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool atomic_long_add_negative_relaxed(long i, atomic_long_t *v)¶: 原子加法並測試是否為負數，使用 relaxed ordering

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_add_negative_relaxed()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

long atomic_long_fetch_add_unless(atomic_long_t *v, long a, long u)¶: 原子加法，除非值為 full ordering

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long a: 要新增的 long 值
long u: 要比較的 long 值

描述

如果 (v != u)，則以原子方式使用 full ordering 將 v 更新為 (v + a)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_fetch_add_unless()。

返回

v 的原始值。

bool atomic_long_add_unless(atomic_long_t *v, long a, long u)¶: 原子加法，除非值為 full ordering

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long a: 要新增的 long 值
long u: 要比較的 long 值

描述

如果 (v != u)，則以原子方式使用 full ordering 將 v 更新為 (v + a)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_add_unless()。

返回

如果 v 已更新，則為 true，否則為 false。

bool atomic_long_inc_not_zero(atomic_long_t *v)¶: 原子遞增，除非為零，使用 full ordering

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

如果 (v != 0)，則以原子方式使用 full ordering 將 v 更新為 (v + 1)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_inc_not_zero()。

返回

如果 v 已更新，則為 true，否則為 false。

bool atomic_long_inc_unless_negative(atomic_long_t *v)¶: 原子遞增，除非為負數，使用 full ordering

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

如果 (v >= 0)，則以原子方式使用 full ordering 將 v 更新為 (v + 1)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_inc_unless_negative()。

返回

如果 v 已更新，則為 true，否則為 false。

bool atomic_long_dec_unless_positive(atomic_long_t *v)¶: 原子遞減，除非為正數，使用 full ordering

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

如果 (v <= 0)，則以原子方式使用 full ordering 將 v 更新為 (v - 1)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_dec_unless_positive()。

返回

如果 v 已更新，則為 true，否則為 false。

long atomic_long_dec_if_positive(atomic_long_t *v)¶: 原子遞減（如果為正數），使用 full ordering

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

如果 (v > 0)，則以原子方式使用 full ordering 將 v 更新為 (v - 1)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用不安全；請在那裡使用 raw_atomic_long_dec_if_positive()。

返回

(v - 1) 的舊值，無論 v 是否已更新。

int raw_atomic_read(const atomic_t *v)¶: 具有寬鬆排序的原子載入

引數

const atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用寬鬆排序載入 v 的值。

在 noinstr 程式碼中使用安全；其他地方首選 atomic_read()。

返回

從 v 載入的值。

int raw_atomic_read_acquire(const atomic_t *v)¶: 具有獲取排序的原子載入

引數

const atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用獲取排序載入 v 的值。

在 noinstr 程式碼中使用安全；其他地方首選 atomic_read_acquire()。

返回

從 v 載入的值。

void raw_atomic_set(atomic_t *v, int i)¶: 具有寬鬆排序的原子設定

引數

atomic_t *v: 指向 atomic_t 的指標
int i: 要分配的 int 值

描述

以原子方式使用寬鬆排序將 v 設定為 i。

在 noinstr 程式碼中使用安全；其他地方首選 atomic_set()。

返回

沒有。

void raw_atomic_set_release(atomic_t *v, int i)¶: 具有釋放排序的原子設定

引數

atomic_t *v: 指向 atomic_t 的指標
int i: 要分配的 int 值

描述

以原子方式使用釋放排序將 v 設定為 i。

在 noinstr 程式碼中使用安全；其他地方首選 atomic_set_release()。

返回

沒有。

void raw_atomic_add(int i, atomic_t *v)¶: 具有寬鬆排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用安全；其他地方首選 atomic_add()。

返回

沒有。

int raw_atomic_add_return(int i, atomic_t *v)¶: 具有完整排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用安全；其他地方首選 atomic_add_return()。

返回

v 的更新值。

int raw_atomic_add_return_acquire(int i, atomic_t *v)¶: 具有獲取排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用安全；其他地方首選 atomic_add_return_acquire()。

返回

v 的更新值。

int raw_atomic_add_return_release(int i, atomic_t *v)¶: 具有釋放排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_add_return_release()。

返回

v 的更新值。

int raw_atomic_add_return_relaxed(int i, atomic_t *v)¶: 具有寬鬆排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_add_return_relaxed()。

返回

v 的更新值。

int raw_atomic_fetch_add(int i, atomic_t *v)¶: 具有完整排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_fetch_add()。

返回

v 的原始值。

int raw_atomic_fetch_add_acquire(int i, atomic_t *v)¶: 具有獲取排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_fetch_add_acquire()。

返回

v 的原始值。

int raw_atomic_fetch_add_release(int i, atomic_t *v)¶: 具有釋放排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_fetch_add_release()。

返回

v 的原始值。

int raw_atomic_fetch_add_relaxed(int i, atomic_t *v)¶: 具有寬鬆排序的原子加法

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_fetch_add_relaxed()。

返回

v 的原始值。

void raw_atomic_sub(int i, atomic_t *v)¶: 具有寬鬆排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_sub()。

返回

沒有。

int raw_atomic_sub_return(int i, atomic_t *v)¶: 具有完整排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_sub_return()。

返回

v 的更新值。

int raw_atomic_sub_return_acquire(int i, atomic_t *v)¶: 具有獲取排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v - i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_sub_return_acquire()。

返回

v 的更新值。

int raw_atomic_sub_return_release(int i, atomic_t *v)¶: 具有釋放排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v - i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_sub_return_release()。

返回

v 的更新值。

int raw_atomic_sub_return_relaxed(int i, atomic_t *v)¶: 具有寬鬆排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_sub_return_relaxed()。

返回

v 的更新值。

int raw_atomic_fetch_sub(int i, atomic_t *v)¶: 具有完整排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_fetch_sub()。

返回

v 的原始值。

int raw_atomic_fetch_sub_acquire(int i, atomic_t *v)¶: 具有獲取排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v - i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_fetch_sub_acquire()。

返回

v 的原始值。

int raw_atomic_fetch_sub_release(int i, atomic_t *v)¶: 具有釋放排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v - i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_fetch_sub_release()。

返回

v 的原始值。

int raw_atomic_fetch_sub_relaxed(int i, atomic_t *v)¶: 具有寬鬆排序的原子減法

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_fetch_sub_relaxed()。

返回

v 的原始值。

void raw_atomic_inc(atomic_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_inc()。

返回

沒有。

int raw_atomic_inc_return(atomic_t *v)¶: 使用完整排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_inc_return()。

返回

v 的更新值。

int raw_atomic_inc_return_acquire(atomic_t *v)¶: 使用獲取排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用獲取排序原子地更新 v 為 (v + 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_inc_return_acquire()。

返回

v 的更新值。

int raw_atomic_inc_return_release(atomic_t *v)¶: 使用釋放排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用釋放排序原子地更新 v 為 (v + 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_inc_return_release()。

返回

v 的更新值。

int raw_atomic_inc_return_relaxed(atomic_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_inc_return_relaxed()。

返回

v 的更新值。

int raw_atomic_fetch_inc(atomic_t *v)¶: 使用完整排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_fetch_inc()。

返回

v 的原始值。

int raw_atomic_fetch_inc_acquire(atomic_t *v)¶: 使用獲取排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用獲取排序原子地更新 v 為 (v + 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_fetch_inc_acquire()。

返回

v 的原始值。

int raw_atomic_fetch_inc_release(atomic_t *v)¶: 使用釋放排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用釋放排序原子地更新 v 為 (v + 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_fetch_inc_release()。

返回

v 的原始值。

int raw_atomic_fetch_inc_relaxed(atomic_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_fetch_inc_relaxed()。

返回

v 的原始值。

void raw_atomic_dec(atomic_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_dec()。

返回

沒有。

int raw_atomic_dec_return(atomic_t *v)¶: 使用完整排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_dec_return()。

返回

v 的更新值。

int raw_atomic_dec_return_acquire(atomic_t *v)¶: 使用獲取排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用獲取排序原子地更新 v 為 (v - 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_dec_return_acquire()。

返回

v 的更新值。

int raw_atomic_dec_return_release(atomic_t *v)¶: 使用釋放排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用釋放排序原子地更新 v 為 (v - 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_dec_return_release()。

返回

v 的更新值。

int raw_atomic_dec_return_relaxed(atomic_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_dec_return_relaxed()。

返回

v 的更新值。

int raw_atomic_fetch_dec(atomic_t *v)¶: 使用完整排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_fetch_dec()。

返回

v 的原始值。

int raw_atomic_fetch_dec_acquire(atomic_t *v)¶: 使用獲取排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用獲取排序原子地更新 v 為 (v - 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_fetch_dec_acquire()。

返回

v 的原始值。

int raw_atomic_fetch_dec_release(atomic_t *v)¶: 使用釋放排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用釋放排序原子地更新 v 為 (v - 1)。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_dec_release()。

返回

v 的原始值。

int raw_atomic_fetch_dec_relaxed(atomic_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_dec_relaxed()。

返回

v 的原始值。

void raw_atomic_and(int i, atomic_t *v)¶: 使用寬鬆排序的原子按位與

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & i)。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_and()。

返回

沒有。

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

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

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

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_and()。

返回

v 的原始值。

int raw_atomic_fetch_and_acquire(int i, atomic_t *v)¶: 使用獲取排序的原子按位與

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

使用獲取排序原子地更新 v 為 (v & i)。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_and_acquire()。

返回

v 的原始值。

int raw_atomic_fetch_and_release(int i, atomic_t *v)¶: 使用釋放排序的原子按位與

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

使用釋放排序原子地更新 v 為 (v & i)。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_and_release()。

返回

v 的原始值。

int raw_atomic_fetch_and_relaxed(int i, atomic_t *v)¶: 使用寬鬆排序的原子按位與

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & i)。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_and_relaxed()。

返回

v 的原始值。

void raw_atomic_andnot(int i, atomic_t *v)¶: 使用寬鬆排序的原子按位與非

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & ~i)。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_andnot()。

返回

沒有。

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

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

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

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_andnot()。

返回

v 的原始值。

int raw_atomic_fetch_andnot_acquire(int i, atomic_t *v)¶: 具有獲取順序的原子按位與非操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v & ~i)，並具有獲取順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_andnot_acquire()。

返回

v 的原始值。

int raw_atomic_fetch_andnot_release(int i, atomic_t *v)¶: 具有釋放順序的原子按位與非操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v & ~i)，並具有釋放順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_andnot_release()。

返回

v 的原始值。

int raw_atomic_fetch_andnot_relaxed(int i, atomic_t *v)¶: 使用寬鬆排序的原子按位與非

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & ~i)。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_andnot_relaxed()。

返回

v 的原始值。

void raw_atomic_or(int i, atomic_t *v)¶: 具有寬鬆順序的原子按位或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有寬鬆順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_or()。

返回

沒有。

int raw_atomic_fetch_or(int i, atomic_t *v)¶: 具有完整順序的原子按位或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有完整順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_or()。

返回

v 的原始值。

int raw_atomic_fetch_or_acquire(int i, atomic_t *v)¶: 具有獲取順序的原子按位或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有獲取順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_or_acquire()。

返回

v 的原始值。

int raw_atomic_fetch_or_release(int i, atomic_t *v)¶: 具有釋放順序的原子按位或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有釋放順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_or_release()。

返回

v 的原始值。

int raw_atomic_fetch_or_relaxed(int i, atomic_t *v)¶: 具有寬鬆順序的原子按位或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有寬鬆順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_or_relaxed()。

返回

v 的原始值。

void raw_atomic_xor(int i, atomic_t *v)¶: 具有寬鬆順序的原子按位異或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有寬鬆順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_xor()。

返回

沒有。

int raw_atomic_fetch_xor(int i, atomic_t *v)¶: 具有完整順序的原子按位異或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有完整順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_xor()。

返回

v 的原始值。

int raw_atomic_fetch_xor_acquire(int i, atomic_t *v)¶: 具有獲取順序的原子按位異或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有獲取順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_xor_acquire()。

返回

v 的原始值。

int raw_atomic_fetch_xor_release(int i, atomic_t *v)¶: 具有釋放順序的原子按位異或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有釋放順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_xor_release()。

返回

v 的原始值。

int raw_atomic_fetch_xor_relaxed(int i, atomic_t *v)¶: 具有寬鬆順序的原子按位異或操作

引數

int i: int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有寬鬆順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_fetch_xor_relaxed()。

返回

v 的原始值。

int raw_atomic_xchg(atomic_t *v, int new)¶: 具有完整順序的原子交換

引數

atomic_t *v: 指向 atomic_t 的指標
int new: 要分配的 int 值

描述

以原子方式更新 v 為 new，並具有完整順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_xchg()。

返回

v 的原始值。

int raw_atomic_xchg_acquire(atomic_t *v, int new)¶: 具有獲取順序的原子交換

引數

atomic_t *v: 指向 atomic_t 的指標
int new: 要分配的 int 值

描述

以原子方式更新 v 為 new，並具有獲取順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_xchg_acquire()。

返回

v 的原始值。

int raw_atomic_xchg_release(atomic_t *v, int new)¶: 具有釋放順序的原子交換

引數

atomic_t *v: 指向 atomic_t 的指標
int new: 要分配的 int 值

描述

以原子方式更新 v 為 new，並具有釋放順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_xchg_release()。

返回

v 的原始值。

int raw_atomic_xchg_relaxed(atomic_t *v, int new)¶: 具有寬鬆順序的原子交換

引數

atomic_t *v: 指向 atomic_t 的指標
int new: 要分配的 int 值

描述

以原子方式更新 v 為 new，並具有寬鬆順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_xchg_relaxed()。

返回

v 的原始值。

int raw_atomic_cmpxchg(atomic_t *v, int old, int new)¶: 具有完整順序的原子比較和交換

引數

atomic_t *v: 指向 atomic_t 的指標
int old: 用於比較的整數值
int new: 要分配的 int 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有完整順序。否則，v 不會被修改，並提供寬鬆順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_cmpxchg()。

返回

v 的原始值。

int raw_atomic_cmpxchg_acquire(atomic_t *v, int old, int new)¶: 具有獲取順序的原子比較和交換

引數

atomic_t *v: 指向 atomic_t 的指標
int old: 用於比較的整數值
int new: 要分配的 int 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有獲取順序。否則，v 不會被修改，並提供寬鬆順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_cmpxchg_acquire()。

返回

v 的原始值。

int raw_atomic_cmpxchg_release(atomic_t *v, int old, int new)¶: 具有釋放順序的原子比較和交換

引數

atomic_t *v: 指向 atomic_t 的指標
int old: 用於比較的整數值
int new: 要分配的 int 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有釋放順序。否則，v 不會被修改，並提供寬鬆順序。

可在 noinstr 程式碼中使用；在其他地方，請優先使用 atomic_cmpxchg_release()。

返回

v 的原始值。

int raw_atomic_cmpxchg_relaxed(atomic_t *v, int old, int new)¶: 具有寬鬆順序的原子比較和交換

引數

atomic_t *v: 指向 atomic_t 的指標
int old: 用於比較的整數值
int new: 要分配的 int 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有寬鬆順序。否則，v 不會被修改，並提供寬鬆順序。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_cmpxchg_relaxed()。

返回

v 的原始值。

bool raw_atomic_try_cmpxchg(atomic_t *v, int *old, int new)¶: 具有完整順序的原子比較和交換

引數

atomic_t *v: 指向 atomic_t 的指標
int *old: 指向用於比較的整數值的指標
int new: 要分配的 int 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有完整順序。否則，v 不會被修改， old 會更新為 v 的當前值，並提供寬鬆順序。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_try_cmpxchg()。

返回

如果發生交換，則為 true，否則為 false。

bool raw_atomic_try_cmpxchg_acquire(atomic_t *v, int *old, int new)¶: 具有獲取順序的原子比較和交換

引數

atomic_t *v: 指向 atomic_t 的指標
int *old: 指向用於比較的整數值的指標
int new: 要分配的 int 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有獲取順序。否則，v 不會被修改， old 會更新為 v 的當前值，並提供寬鬆順序。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_try_cmpxchg_acquire()。

返回

如果發生交換，則為 true，否則為 false。

bool raw_atomic_try_cmpxchg_release(atomic_t *v, int *old, int new)¶: 具有釋放順序的原子比較和交換

引數

atomic_t *v: 指向 atomic_t 的指標
int *old: 指向用於比較的整數值的指標
int new: 要分配的 int 值

描述

如果 (v == old)，則以原子方式使用 release ordering 將 v 更新為 new。否則，v 不會被修改，old 會被更新為 v 的當前值，並提供 relaxed ordering。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_try_cmpxchg_release()。

返回

如果發生交換，則為 true，否則為 false。

bool raw_atomic_try_cmpxchg_relaxed(atomic_t *v, int *old, int new)¶: 具有寬鬆順序的原子比較和交換

引數

atomic_t *v: 指向 atomic_t 的指標
int *old: 指向用於比較的整數值的指標
int new: 要分配的 int 值

描述

如果 (v == old)，則以原子方式使用 relaxed ordering 將 v 更新為 new。否則，v 不會被修改，old 會被更新為 v 的當前值，並提供 relaxed ordering。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_try_cmpxchg_relaxed()。

返回

如果發生交換，則為 true，否則為 false。

bool raw_atomic_sub_and_test(int i, atomic_t *v)¶: 原子減法並測試是否為零，使用 full ordering

引數

int i: 要減去的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_sub_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool raw_atomic_dec_and_test(atomic_t *v)¶: 原子遞減並測試是否為零，使用 full ordering

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_dec_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool raw_atomic_inc_and_test(atomic_t *v)¶: 原子遞增並測試是否為零，使用 full ordering

引數

atomic_t *v: 指向 atomic_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_inc_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool raw_atomic_add_negative(int i, atomic_t *v)¶: 原子加法並測試是否為負數，使用 full ordering

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_add_negative()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool raw_atomic_add_negative_acquire(int i, atomic_t *v)¶: 原子加法並測試是否為負數，使用 acquire ordering

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_add_negative_acquire()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool raw_atomic_add_negative_release(int i, atomic_t *v)¶: 原子加法並測試是否為負數，使用 release ordering

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_add_negative_release()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool raw_atomic_add_negative_relaxed(int i, atomic_t *v)¶: 原子加法並測試是否為負數，使用 relaxed ordering

引數

int i: 要新增的 int 值
atomic_t *v: 指向 atomic_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_add_negative_relaxed()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

int raw_atomic_fetch_add_unless(atomic_t *v, int a, int u)¶: 原子加法，除非值為 full ordering

引數

atomic_t *v: 指向 atomic_t 的指標
int a: 要新增的 int 值
int u: 用於比較的整數值

描述

如果 (v != u)，則以原子方式使用 full ordering 將 v 更新為 (v + a)。否則，v 不會被修改，並提供 relaxed ordering。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_fetch_add_unless()。

返回

v 的原始值。

bool raw_atomic_add_unless(atomic_t *v, int a, int u)¶: 原子加法，除非值為 full ordering

引數

atomic_t *v: 指向 atomic_t 的指標
int a: 要新增的 int 值
int u: 用於比較的整數值

描述

如果 (v != u)，則以原子方式使用 full ordering 將 v 更新為 (v + a)。否則，v 不會被修改，並提供 relaxed ordering。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_add_unless()。

返回

如果 v 已更新，則為 true，否則為 false。

bool raw_atomic_inc_not_zero(atomic_t *v)¶: 原子遞增，除非為零，使用 full ordering

引數

atomic_t *v: 指向 atomic_t 的指標

描述

如果 (v != 0)，則以原子方式使用 full ordering 將 v 更新為 (v + 1)。否則，v 不會被修改，並提供 relaxed ordering。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_inc_not_zero()。

返回

如果 v 已更新，則為 true，否則為 false。

bool raw_atomic_inc_unless_negative(atomic_t *v)¶: 原子遞增，除非為負數，使用 full ordering

引數

atomic_t *v: 指向 atomic_t 的指標

描述

如果 (v >= 0)，則以原子方式使用 full ordering 將 v 更新為 (v + 1)。否則，v 不會被修改，並提供 relaxed ordering。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_inc_unless_negative()。

返回

如果 v 已更新，則為 true，否則為 false。

bool raw_atomic_dec_unless_positive(atomic_t *v)¶: 原子遞減，除非為正數，使用 full ordering

引數

atomic_t *v: 指向 atomic_t 的指標

描述

如果 (v <= 0)，則以原子方式使用 full ordering 將 v 更新為 (v - 1)。否則，v 不會被修改，並提供 relaxed ordering。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_dec_unless_positive()。

返回

如果 v 已更新，則為 true，否則為 false。

int raw_atomic_dec_if_positive(atomic_t *v)¶: 原子遞減（如果為正數），使用 full ordering

引數

atomic_t *v: 指向 atomic_t 的指標

描述

如果 (v > 0)，則以原子方式使用 full ordering 將 v 更新為 (v - 1)。否則，v 不會被修改，並提供 relaxed ordering。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic_dec_if_positive()。

返回

(v - 1) 的舊值，無論 v 是否已更新。

s64 raw_atomic64_read(const atomic64_t *v)¶: 具有寬鬆排序的原子載入

引數

const atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用寬鬆排序載入 v 的值。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic64_read()。

返回

從 v 載入的值。

s64 raw_atomic64_read_acquire(const atomic64_t *v)¶: 具有獲取排序的原子載入

引數

const atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用獲取排序載入 v 的值。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic64_read_acquire()。

返回

從 v 載入的值。

void raw_atomic64_set(atomic64_t *v, s64 i)¶: 具有寬鬆排序的原子設定

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 i: 要分配的 s64 值

描述

以原子方式使用寬鬆排序將 v 設定為 i。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic64_set()。

返回

沒有。

void raw_atomic64_set_release(atomic64_t *v, s64 i)¶: 具有釋放排序的原子設定

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 i: 要分配的 s64 值

描述

以原子方式使用釋放排序將 v 設定為 i。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic64_set_release()。

返回

沒有。

void raw_atomic64_add(s64 i, atomic64_t *v)¶: 具有寬鬆排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic64_add()。

返回

沒有。

s64 raw_atomic64_add_return(s64 i, atomic64_t *v)¶: 具有完整排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic64_add_return()。

返回

v 的更新值。

s64 raw_atomic64_add_return_acquire(s64 i, atomic64_t *v)¶: 具有獲取排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic64_add_return_acquire()。

返回

v 的更新值。

s64 raw_atomic64_add_return_release(s64 i, atomic64_t *v)¶: 具有釋放排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic64_add_return_release()。

返回

v 的更新值。

s64 raw_atomic64_add_return_relaxed(s64 i, atomic64_t *v)¶: 具有寬鬆排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic64_add_return_relaxed()。

返回

v 的更新值。

s64 raw_atomic64_fetch_add(s64 i, atomic64_t *v)¶: 具有完整排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

可以在 noinstr 程式碼中使用；其他地方優先使用 atomic64_fetch_add()。

返回

v 的原始值。

s64 raw_atomic64_fetch_add_acquire(s64 i, atomic64_t *v)¶: 具有獲取排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_fetch_add_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_add_release(s64 i, atomic64_t *v)¶: 具有釋放排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_fetch_add_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_add_relaxed(s64 i, atomic64_t *v)¶: 具有寬鬆排序的原子加法

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_fetch_add_relaxed()。

返回

v 的原始值。

void raw_atomic64_sub(s64 i, atomic64_t *v)¶: 具有寬鬆排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_sub()。

返回

沒有。

s64 raw_atomic64_sub_return(s64 i, atomic64_t *v)¶: 具有完整排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_sub_return()。

返回

v 的更新值。

s64 raw_atomic64_sub_return_acquire(s64 i, atomic64_t *v)¶: 具有獲取排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v - i)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_sub_return_acquire()。

返回

v 的更新值。

s64 raw_atomic64_sub_return_release(s64 i, atomic64_t *v)¶: 具有釋放排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v - i)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_sub_return_release()。

返回

v 的更新值。

s64 raw_atomic64_sub_return_relaxed(s64 i, atomic64_t *v)¶: 具有寬鬆排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_sub_return_relaxed()。

返回

v 的更新值。

s64 raw_atomic64_fetch_sub(s64 i, atomic64_t *v)¶: 具有完整排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_fetch_sub()。

返回

v 的原始值。

s64 raw_atomic64_fetch_sub_acquire(s64 i, atomic64_t *v)¶: 具有獲取排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v - i)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_fetch_sub_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_sub_release(s64 i, atomic64_t *v)¶: 具有釋放排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v - i)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_fetch_sub_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_sub_relaxed(s64 i, atomic64_t *v)¶: 具有寬鬆排序的原子減法

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_fetch_sub_relaxed()。

返回

v 的原始值。

void raw_atomic64_inc(atomic64_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_inc()。

返回

沒有。

s64 raw_atomic64_inc_return(atomic64_t *v)¶: 使用完整排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_inc_return()。

返回

v 的更新值。

s64 raw_atomic64_inc_return_acquire(atomic64_t *v)¶: 使用獲取排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用獲取排序原子地更新 v 為 (v + 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_inc_return_acquire()。

返回

v 的更新值。

s64 raw_atomic64_inc_return_release(atomic64_t *v)¶: 使用釋放排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用釋放排序原子地更新 v 為 (v + 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_inc_return_release()。

返回

v 的更新值。

s64 raw_atomic64_inc_return_relaxed(atomic64_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_inc_return_relaxed()。

返回

v 的更新值。

s64 raw_atomic64_fetch_inc(atomic64_t *v)¶: 使用完整排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_fetch_inc()。

返回

v 的原始值。

s64 raw_atomic64_fetch_inc_acquire(atomic64_t *v)¶: 使用獲取排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用獲取排序原子地更新 v 為 (v + 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_fetch_inc_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_inc_release(atomic64_t *v)¶: 使用釋放排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用釋放排序原子地更新 v 為 (v + 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_fetch_inc_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_inc_relaxed(atomic64_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_fetch_inc_relaxed()。

返回

v 的原始值。

void raw_atomic64_dec(atomic64_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_dec()。

返回

沒有。

s64 raw_atomic64_dec_return(atomic64_t *v)¶: 使用完整排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_dec_return()。

返回

v 的更新值。

s64 raw_atomic64_dec_return_acquire(atomic64_t *v)¶: 使用獲取排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用獲取排序原子地更新 v 為 (v - 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_dec_return_acquire()。

返回

v 的更新值。

s64 raw_atomic64_dec_return_release(atomic64_t *v)¶: 使用釋放排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用釋放排序原子地更新 v 為 (v - 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_dec_return_release()。

返回

v 的更新值。

s64 raw_atomic64_dec_return_relaxed(atomic64_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_dec_return_relaxed()。

返回

v 的更新值。

s64 raw_atomic64_fetch_dec(atomic64_t *v)¶: 使用完整排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_fetch_dec()。

返回

v 的原始值。

s64 raw_atomic64_fetch_dec_acquire(atomic64_t *v)¶: 使用獲取排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用獲取排序原子地更新 v 為 (v - 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_fetch_dec_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_dec_release(atomic64_t *v)¶: 使用釋放排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用釋放排序原子地更新 v 為 (v - 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_fetch_dec_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_dec_relaxed(atomic64_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

可在無檢測程式碼中使用；在其他地方首選 atomic64_fetch_dec_relaxed()。

返回

v 的原始值。

void raw_atomic64_and(s64 i, atomic64_t *v)¶: 使用寬鬆排序的原子按位與

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & i)。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_and()。

返回

沒有。

s64 raw_atomic64_fetch_and(s64 i, atomic64_t *v)¶: 使用完整排序的原子按位與

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

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

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_fetch_and()。

返回

v 的原始值。

s64 raw_atomic64_fetch_and_acquire(s64 i, atomic64_t *v)¶: 使用獲取排序的原子按位與

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

使用獲取排序原子地更新 v 為 (v & i)。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_fetch_and_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_and_release(s64 i, atomic64_t *v)¶: 使用釋放排序的原子按位與

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

使用釋放排序原子地更新 v 為 (v & i)。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_fetch_and_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_and_relaxed(s64 i, atomic64_t *v)¶: 使用寬鬆排序的原子按位與

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & i)。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_fetch_and_relaxed()。

返回

v 的原始值。

void raw_atomic64_andnot(s64 i, atomic64_t *v)¶: 使用寬鬆排序的原子按位與非

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & ~i)。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_andnot()。

返回

沒有。

s64 raw_atomic64_fetch_andnot(s64 i, atomic64_t *v)¶: 使用完整排序的原子按位與非

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

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

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_fetch_andnot()。

返回

v 的原始值。

s64 raw_atomic64_fetch_andnot_acquire(s64 i, atomic64_t *v)¶: 具有獲取順序的原子按位與非操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v & ~i)，並具有獲取順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_fetch_andnot_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_andnot_release(s64 i, atomic64_t *v)¶: 具有釋放順序的原子按位與非操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v & ~i)，並具有釋放順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_fetch_andnot_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_andnot_relaxed(s64 i, atomic64_t *v)¶: 使用寬鬆排序的原子按位與非

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & ~i)。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_fetch_andnot_relaxed()。

返回

v 的原始值。

void raw_atomic64_or(s64 i, atomic64_t *v)¶: 具有寬鬆順序的原子按位或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有寬鬆順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_or()。

返回

沒有。

s64 raw_atomic64_fetch_or(s64 i, atomic64_t *v)¶: 具有完整順序的原子按位或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有完整順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_fetch_or()。

返回

v 的原始值。

s64 raw_atomic64_fetch_or_acquire(s64 i, atomic64_t *v)¶: 具有獲取順序的原子按位或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有獲取順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_fetch_or_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_or_release(s64 i, atomic64_t *v)¶: 具有釋放順序的原子按位或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有釋放順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_fetch_or_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_or_relaxed(s64 i, atomic64_t *v)¶: 具有寬鬆順序的原子按位或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有寬鬆順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_fetch_or_relaxed()。

返回

v 的原始值。

void raw_atomic64_xor(s64 i, atomic64_t *v)¶: 具有寬鬆順序的原子按位異或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有寬鬆順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_xor()。

返回

沒有。

s64 raw_atomic64_fetch_xor(s64 i, atomic64_t *v)¶: 具有完整順序的原子按位異或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有完整順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_fetch_xor()。

返回

v 的原始值。

s64 raw_atomic64_fetch_xor_acquire(s64 i, atomic64_t *v)¶: 具有獲取順序的原子按位異或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有獲取順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_fetch_xor_acquire()。

返回

v 的原始值。

s64 raw_atomic64_fetch_xor_release(s64 i, atomic64_t *v)¶: 具有釋放順序的原子按位異或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有釋放順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_fetch_xor_release()。

返回

v 的原始值。

s64 raw_atomic64_fetch_xor_relaxed(s64 i, atomic64_t *v)¶: 具有寬鬆順序的原子按位異或操作

引數

s64 i: s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有寬鬆順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_fetch_xor_relaxed()。

返回

v 的原始值。

s64 raw_atomic64_xchg(atomic64_t *v, s64 new)¶: 具有完整順序的原子交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 new: 要分配的 s64 值

描述

以原子方式更新 v 為 new，並具有完整順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_xchg()。

返回

v 的原始值。

s64 raw_atomic64_xchg_acquire(atomic64_t *v, s64 new)¶: 具有獲取順序的原子交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 new: 要分配的 s64 值

描述

以原子方式更新 v 為 new，並具有獲取順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_xchg_acquire()。

返回

v 的原始值。

s64 raw_atomic64_xchg_release(atomic64_t *v, s64 new)¶: 具有釋放順序的原子交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 new: 要分配的 s64 值

描述

以原子方式更新 v 為 new，並具有釋放順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_xchg_release()。

返回

v 的原始值。

s64 raw_atomic64_xchg_relaxed(atomic64_t *v, s64 new)¶: 具有寬鬆順序的原子交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 new: 要分配的 s64 值

描述

以原子方式更新 v 為 new，並具有寬鬆順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_xchg_relaxed()。

返回

v 的原始值。

s64 raw_atomic64_cmpxchg(atomic64_t *v, s64 old, s64 new)¶: 具有完整順序的原子比較和交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 old: 要比較的 s64 值
s64 new: 要分配的 s64 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有完整順序。否則，v 不會被修改，並提供寬鬆順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_cmpxchg()。

返回

v 的原始值。

s64 raw_atomic64_cmpxchg_acquire(atomic64_t *v, s64 old, s64 new)¶: 具有獲取順序的原子比較和交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 old: 要比較的 s64 值
s64 new: 要分配的 s64 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有獲取順序。否則，v 不會被修改，並提供寬鬆順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_cmpxchg_acquire()。

返回

v 的原始值。

s64 raw_atomic64_cmpxchg_release(atomic64_t *v, s64 old, s64 new)¶: 具有釋放順序的原子比較和交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 old: 要比較的 s64 值
s64 new: 要分配的 s64 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有釋放順序。否則，v 不會被修改，並提供寬鬆順序。

可在 noinstr 程式碼中使用；其他地方優先使用 atomic64_cmpxchg_release()。

返回

v 的原始值。

s64 raw_atomic64_cmpxchg_relaxed(atomic64_t *v, s64 old, s64 new)¶: 具有寬鬆順序的原子比較和交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 old: 要比較的 s64 值
s64 new: 要分配的 s64 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有寬鬆順序。否則，v 不會被修改，並提供寬鬆順序。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_cmpxchg_relaxed()。

返回

v 的原始值。

bool raw_atomic64_try_cmpxchg(atomic64_t *v, s64 *old, s64 new)¶: 具有完整順序的原子比較和交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 *old: 與要比較的 s64 值的指標
s64 new: 要分配的 s64 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有完整順序。否則，v 不會被修改， old 會更新為 v 的當前值，並提供寬鬆順序。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_try_cmpxchg()。

返回

如果發生交換，則為 true，否則為 false。

bool raw_atomic64_try_cmpxchg_acquire(atomic64_t *v, s64 *old, s64 new)¶: 具有獲取順序的原子比較和交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 *old: 與要比較的 s64 值的指標
s64 new: 要分配的 s64 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有獲取順序。否則，v 不會被修改， old 會更新為 v 的當前值，並提供寬鬆順序。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_try_cmpxchg_acquire()。

返回

如果發生交換，則為 true，否則為 false。

bool raw_atomic64_try_cmpxchg_release(atomic64_t *v, s64 *old, s64 new)¶: 具有釋放順序的原子比較和交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 *old: 與要比較的 s64 值的指標
s64 new: 要分配的 s64 值

描述

如果 (v == old)，則以原子方式使用 release ordering 將 v 更新為 new。否則，v 不會被修改，old 會被更新為 v 的當前值，並提供 relaxed ordering。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_try_cmpxchg_release()。

返回

如果發生交換，則為 true，否則為 false。

bool raw_atomic64_try_cmpxchg_relaxed(atomic64_t *v, s64 *old, s64 new)¶: 具有寬鬆順序的原子比較和交換

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 *old: 與要比較的 s64 值的指標
s64 new: 要分配的 s64 值

描述

如果 (v == old)，則以原子方式使用 relaxed ordering 將 v 更新為 new。否則，v 不會被修改，old 會被更新為 v 的當前值，並提供 relaxed ordering。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_try_cmpxchg_relaxed()。

返回

如果發生交換，則為 true，否則為 false。

bool raw_atomic64_sub_and_test(s64 i, atomic64_t *v)¶: 原子減法並測試是否為零，使用 full ordering

引數

s64 i: 要減去的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_sub_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool raw_atomic64_dec_and_test(atomic64_t *v)¶: 原子遞減並測試是否為零，使用 full ordering

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_dec_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool raw_atomic64_inc_and_test(atomic64_t *v)¶: 原子遞增並測試是否為零，使用 full ordering

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_inc_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool raw_atomic64_add_negative(s64 i, atomic64_t *v)¶: 原子加法並測試是否為負數，使用 full ordering

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_add_negative()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool raw_atomic64_add_negative_acquire(s64 i, atomic64_t *v)¶: 原子加法並測試是否為負數，使用 acquire ordering

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_add_negative_acquire()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool raw_atomic64_add_negative_release(s64 i, atomic64_t *v)¶: 原子加法並測試是否為負數，使用 release ordering

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_add_negative_release()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool raw_atomic64_add_negative_relaxed(s64 i, atomic64_t *v)¶: 原子加法並測試是否為負數，使用 relaxed ordering

引數

s64 i: 要新增的 s64 值
atomic64_t *v: 指向 atomic64_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_add_negative_relaxed()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

s64 raw_atomic64_fetch_add_unless(atomic64_t *v, s64 a, s64 u)¶: 原子加法，除非值為 full ordering

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 a: 要新增的 s64 值
s64 u: 要比較的 s64 值

描述

如果 (v != u)，則以原子方式使用 full ordering 將 v 更新為 (v + a)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_fetch_add_unless()。

返回

v 的原始值。

bool raw_atomic64_add_unless(atomic64_t *v, s64 a, s64 u)¶: 原子加法，除非值為 full ordering

引數

atomic64_t *v: 指向 atomic64_t 的指標
s64 a: 要新增的 s64 值
s64 u: 要比較的 s64 值

描述

如果 (v != u)，則以原子方式使用 full ordering 將 v 更新為 (v + a)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_add_unless()。

返回

如果 v 已更新，則為 true，否則為 false。

bool raw_atomic64_inc_not_zero(atomic64_t *v)¶: 原子遞增，除非為零，使用 full ordering

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

如果 (v != 0)，則以原子方式使用 full ordering 將 v 更新為 (v + 1)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_inc_not_zero()。

返回

如果 v 已更新，則為 true，否則為 false。

bool raw_atomic64_inc_unless_negative(atomic64_t *v)¶: 原子遞增，除非為負數，使用 full ordering

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

如果 (v >= 0)，則以原子方式使用 full ordering 將 v 更新為 (v + 1)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_inc_unless_negative()。

返回

如果 v 已更新，則為 true，否則為 false。

bool raw_atomic64_dec_unless_positive(atomic64_t *v)¶: 原子遞減，除非為正數，使用 full ordering

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

如果 (v <= 0)，則以原子方式使用 full ordering 將 v 更新為 (v - 1)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_dec_unless_positive()。

返回

如果 v 已更新，則為 true，否則為 false。

s64 raw_atomic64_dec_if_positive(atomic64_t *v)¶: 原子遞減（如果為正數），使用 full ordering

引數

atomic64_t *v: 指向 atomic64_t 的指標

描述

如果 (v > 0)，則以原子方式使用 full ordering 將 v 更新為 (v - 1)。否則，v 不會被修改，並提供 relaxed ordering。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic64_dec_if_positive()。

返回

(v - 1) 的舊值，無論 v 是否已更新。

long raw_atomic_long_read(const atomic_long_t *v)¶: 具有寬鬆排序的原子載入

引數

const atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用寬鬆排序載入 v 的值。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic_long_read()。

返回

從 v 載入的值。

long raw_atomic_long_read_acquire(const atomic_long_t *v)¶: 具有獲取排序的原子載入

引數

const atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用獲取排序載入 v 的值。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic_long_read_acquire()。

返回

從 v 載入的值。

void raw_atomic_long_set(atomic_long_t *v, long i)¶: 具有寬鬆排序的原子設定

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long i: 要分配的 long 值

描述

以原子方式使用寬鬆排序將 v 設定為 i。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic_long_set()。

返回

沒有。

void raw_atomic_long_set_release(atomic_long_t *v, long i)¶: 具有釋放排序的原子設定

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long i: 要分配的 long 值

描述

以原子方式使用釋放排序將 v 設定為 i。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic_long_set_release()。

返回

沒有。

void raw_atomic_long_add(long i, atomic_long_t *v)¶: 具有寬鬆排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic_long_add()。

返回

沒有。

long raw_atomic_long_add_return(long i, atomic_long_t *v)¶: 具有完整排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic_long_add_return()。

返回

v 的更新值。

long raw_atomic_long_add_return_acquire(long i, atomic_long_t *v)¶: 具有獲取排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic_long_add_return_acquire()。

返回

v 的更新值。

long raw_atomic_long_add_return_release(long i, atomic_long_t *v)¶: 具有釋放排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic_long_add_return_release()。

返回

v 的更新值。

long raw_atomic_long_add_return_relaxed(long i, atomic_long_t *v)¶: 具有寬鬆排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

在 noinstr 程式碼中使用是安全的；在其他地方首選 atomic_long_add_return_relaxed()。

返回

v 的更新值。

long raw_atomic_long_fetch_add(long i, atomic_long_t *v)¶: 具有完整排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_fetch_add()。

返回

v 的原始值。

long raw_atomic_long_fetch_add_acquire(long i, atomic_long_t *v)¶: 具有獲取排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_fetch_add_acquire()。

返回

v 的原始值。

long raw_atomic_long_fetch_add_release(long i, atomic_long_t *v)¶: 具有釋放排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_fetch_add_release()。

返回

v 的原始值。

long raw_atomic_long_fetch_add_relaxed(long i, atomic_long_t *v)¶: 具有寬鬆排序的原子加法

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_fetch_add_relaxed()。

返回

v 的原始值。

void raw_atomic_long_sub(long i, atomic_long_t *v)¶: 具有寬鬆排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_sub()。

返回

沒有。

long raw_atomic_long_sub_return(long i, atomic_long_t *v)¶: 具有完整排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_sub_return()。

返回

v 的更新值。

long raw_atomic_long_sub_return_acquire(long i, atomic_long_t *v)¶: 具有獲取排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v - i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_sub_return_acquire()。

返回

v 的更新值。

long raw_atomic_long_sub_return_release(long i, atomic_long_t *v)¶: 具有釋放排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v - i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_sub_return_release()。

返回

v 的更新值。

long raw_atomic_long_sub_return_relaxed(long i, atomic_long_t *v)¶: 具有寬鬆排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_sub_return_relaxed()。

返回

v 的更新值。

long raw_atomic_long_fetch_sub(long i, atomic_long_t *v)¶: 具有完整排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_fetch_sub()。

返回

v 的原始值。

long raw_atomic_long_fetch_sub_acquire(long i, atomic_long_t *v)¶: 具有獲取排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v - i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_fetch_sub_acquire()。

返回

v 的原始值。

long raw_atomic_long_fetch_sub_release(long i, atomic_long_t *v)¶: 具有釋放排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v - i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_fetch_sub_release()。

返回

v 的原始值。

long raw_atomic_long_fetch_sub_relaxed(long i, atomic_long_t *v)¶: 具有寬鬆排序的原子減法

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v - i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_fetch_sub_relaxed()。

返回

v 的原始值。

void raw_atomic_long_inc(atomic_long_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_inc()。

返回

沒有。

long raw_atomic_long_inc_return(atomic_long_t *v)¶: 使用完整排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_inc_return()。

返回

v 的更新值。

long raw_atomic_long_inc_return_acquire(atomic_long_t *v)¶: 使用獲取排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用獲取排序原子地更新 v 為 (v + 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_inc_return_acquire()。

返回

v 的更新值。

long raw_atomic_long_inc_return_release(atomic_long_t *v)¶: 使用釋放排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用釋放排序原子地更新 v 為 (v + 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_inc_return_release()。

返回

v 的更新值。

long raw_atomic_long_inc_return_relaxed(atomic_long_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_inc_return_relaxed()。

返回

v 的更新值。

long raw_atomic_long_fetch_inc(atomic_long_t *v)¶: 使用完整排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_fetch_inc()。

返回

v 的原始值。

long raw_atomic_long_fetch_inc_acquire(atomic_long_t *v)¶: 使用獲取排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用獲取排序原子地更新 v 為 (v + 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_fetch_inc_acquire()。

返回

v 的原始值。

long raw_atomic_long_fetch_inc_release(atomic_long_t *v)¶: 使用釋放排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用釋放排序原子地更新 v 為 (v + 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_fetch_inc_release()。

返回

v 的原始值。

long raw_atomic_long_fetch_inc_relaxed(atomic_long_t *v)¶: 使用寬鬆排序的原子自增

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v + 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_fetch_inc_relaxed()。

返回

v 的原始值。

void raw_atomic_long_dec(atomic_long_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_dec()。

返回

沒有。

long raw_atomic_long_dec_return(atomic_long_t *v)¶: 使用完整排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_dec_return()。

返回

v 的更新值。

long raw_atomic_long_dec_return_acquire(atomic_long_t *v)¶: 使用獲取排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用獲取排序原子地更新 v 為 (v - 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_dec_return_acquire()。

返回

v 的更新值。

long raw_atomic_long_dec_return_release(atomic_long_t *v)¶: 使用釋放排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用釋放排序原子地更新 v 為 (v - 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_dec_return_release()。

返回

v 的更新值。

long raw_atomic_long_dec_return_relaxed(atomic_long_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_dec_return_relaxed()。

返回

v 的更新值。

long raw_atomic_long_fetch_dec(atomic_long_t *v)¶: 使用完整排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_fetch_dec()。

返回

v 的原始值。

long raw_atomic_long_fetch_dec_acquire(atomic_long_t *v)¶: 使用獲取排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用獲取排序原子地更新 v 為 (v - 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_fetch_dec_acquire()。

返回

v 的原始值。

long raw_atomic_long_fetch_dec_release(atomic_long_t *v)¶: 使用釋放排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用釋放排序原子地更新 v 為 (v - 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_fetch_dec_release()。

返回

v 的原始值。

long raw_atomic_long_fetch_dec_relaxed(atomic_long_t *v)¶: 使用寬鬆排序的原子自減

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v - 1)。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_fetch_dec_relaxed()。

返回

v 的原始值。

void raw_atomic_long_and(long i, atomic_long_t *v)¶: 使用寬鬆排序的原子按位與

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & i)。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_and()。

返回

沒有。

long raw_atomic_long_fetch_and(long i, atomic_long_t *v)¶: 使用完整排序的原子按位與

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

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

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_fetch_and()。

返回

v 的原始值。

long raw_atomic_long_fetch_and_acquire(long i, atomic_long_t *v)¶: 使用獲取排序的原子按位與

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用獲取排序原子地更新 v 為 (v & i)。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_fetch_and_acquire()。

返回

v 的原始值。

long raw_atomic_long_fetch_and_release(long i, atomic_long_t *v)¶: 使用釋放排序的原子按位與

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用釋放排序原子地更新 v 為 (v & i)。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_fetch_and_release()。

返回

v 的原始值。

long raw_atomic_long_fetch_and_relaxed(long i, atomic_long_t *v)¶: 使用寬鬆排序的原子按位與

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & i)。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_fetch_and_relaxed()。

返回

v 的原始值。

void raw_atomic_long_andnot(long i, atomic_long_t *v)¶: 使用寬鬆排序的原子按位與非

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & ~i)。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_andnot()。

返回

沒有。

long raw_atomic_long_fetch_andnot(long i, atomic_long_t *v)¶: 使用完整排序的原子按位與非

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

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

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_fetch_andnot()。

返回

v 的原始值。

long raw_atomic_long_fetch_andnot_acquire(long i, atomic_long_t *v)¶: 具有獲取順序的原子按位與非操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v & ~i)，並具有獲取順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_fetch_andnot_acquire()。

返回

v 的原始值。

long raw_atomic_long_fetch_andnot_release(long i, atomic_long_t *v)¶: 具有釋放順序的原子按位與非操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v & ~i)，並具有釋放順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_fetch_andnot_release()。

返回

v 的原始值。

long raw_atomic_long_fetch_andnot_relaxed(long i, atomic_long_t *v)¶: 使用寬鬆排序的原子按位與非

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用寬鬆排序原子地更新 v 為 (v & ~i)。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_fetch_andnot_relaxed()。

返回

v 的原始值。

void raw_atomic_long_or(long i, atomic_long_t *v)¶: 具有寬鬆順序的原子按位或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有寬鬆順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_or()。

返回

沒有。

long raw_atomic_long_fetch_or(long i, atomic_long_t *v)¶: 具有完整順序的原子按位或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有完整順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_fetch_or()。

返回

v 的原始值。

long raw_atomic_long_fetch_or_acquire(long i, atomic_long_t *v)¶: 具有獲取順序的原子按位或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有獲取順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_fetch_or_acquire()。

返回

v 的原始值。

long raw_atomic_long_fetch_or_release(long i, atomic_long_t *v)¶: 具有釋放順序的原子按位或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有釋放順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_fetch_or_release()。

返回

v 的原始值。

long raw_atomic_long_fetch_or_relaxed(long i, atomic_long_t *v)¶: 具有寬鬆順序的原子按位或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v | i)，並具有寬鬆順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_fetch_or_relaxed()。

返回

v 的原始值。

void raw_atomic_long_xor(long i, atomic_long_t *v)¶: 具有寬鬆順序的原子按位異或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有寬鬆順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_xor()。

返回

沒有。

long raw_atomic_long_fetch_xor(long i, atomic_long_t *v)¶: 具有完整順序的原子按位異或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有完整順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_fetch_xor()。

返回

v 的原始值。

long raw_atomic_long_fetch_xor_acquire(long i, atomic_long_t *v)¶: 具有獲取順序的原子按位異或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有獲取順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_fetch_xor_acquire()。

返回

v 的原始值。

long raw_atomic_long_fetch_xor_release(long i, atomic_long_t *v)¶: 具有釋放順序的原子按位異或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有釋放順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_fetch_xor_release()。

返回

v 的原始值。

long raw_atomic_long_fetch_xor_relaxed(long i, atomic_long_t *v)¶: 具有寬鬆順序的原子按位異或操作

引數

long i: long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式更新 v 為 (v ^ i)，並具有寬鬆順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_fetch_xor_relaxed()。

返回

v 的原始值。

long raw_atomic_long_xchg(atomic_long_t *v, long new)¶: 具有完整順序的原子交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long new: 要分配的 long 值

描述

以原子方式更新 v 為 new，並具有完整順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_xchg()。

返回

v 的原始值。

long raw_atomic_long_xchg_acquire(atomic_long_t *v, long new)¶: 具有獲取順序的原子交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long new: 要分配的 long 值

描述

以原子方式更新 v 為 new，並具有獲取順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_xchg_acquire()。

返回

v 的原始值。

long raw_atomic_long_xchg_release(atomic_long_t *v, long new)¶: 具有釋放順序的原子交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long new: 要分配的 long 值

描述

以原子方式更新 v 為 new，並具有釋放順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_xchg_release()。

返回

v 的原始值。

long raw_atomic_long_xchg_relaxed(atomic_long_t *v, long new)¶: 具有寬鬆順序的原子交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long new: 要分配的 long 值

描述

以原子方式更新 v 為 new，並具有寬鬆順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_xchg_relaxed()。

返回

v 的原始值。

long raw_atomic_long_cmpxchg(atomic_long_t *v, long old, long new)¶: 具有完整順序的原子比較和交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long old: 要比較的 long 值
long new: 要分配的 long 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有完整順序。否則，v 不會被修改，並提供寬鬆順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_cmpxchg()。

返回

v 的原始值。

long raw_atomic_long_cmpxchg_acquire(atomic_long_t *v, long old, long new)¶: 具有獲取順序的原子比較和交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long old: 要比較的 long 值
long new: 要分配的 long 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有獲取順序。否則，v 不會被修改，並提供寬鬆順序。

可以在 noinstr 程式碼中使用；在其他地方，首選 atomic_long_cmpxchg_acquire()。

返回

v 的原始值。

long raw_atomic_long_cmpxchg_release(atomic_long_t *v, long old, long new)¶: 具有釋放順序的原子比較和交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long old: 要比較的 long 值
long new: 要分配的 long 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有釋放順序。否則，v 不會被修改，並提供寬鬆順序。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_cmpxchg_release()。

返回

v 的原始值。

long raw_atomic_long_cmpxchg_relaxed(atomic_long_t *v, long old, long new)¶: 具有寬鬆順序的原子比較和交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long old: 要比較的 long 值
long new: 要分配的 long 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有寬鬆順序。否則，v 不會被修改，並提供寬鬆順序。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_cmpxchg_relaxed()。

返回

v 的原始值。

bool raw_atomic_long_try_cmpxchg(atomic_long_t *v, long *old, long new)¶: 具有完整順序的原子比較和交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long *old: 與要比較的 long 值對應的指標
long new: 要分配的 long 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有完整順序。否則，v 不會被修改， old 會更新為 v 的當前值，並提供寬鬆順序。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_try_cmpxchg()。

返回

如果發生交換，則為 true，否則為 false。

bool raw_atomic_long_try_cmpxchg_acquire(atomic_long_t *v, long *old, long new)¶: 具有獲取順序的原子比較和交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long *old: 與要比較的 long 值對應的指標
long new: 要分配的 long 值

描述

如果 (v == old)，則以原子方式更新 v 為 new，並具有獲取順序。否則，v 不會被修改， old 會更新為 v 的當前值，並提供寬鬆順序。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_try_cmpxchg_acquire()。

返回

如果發生交換，則為 true，否則為 false。

bool raw_atomic_long_try_cmpxchg_release(atomic_long_t *v, long *old, long new)¶: 具有釋放順序的原子比較和交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long *old: 與要比較的 long 值對應的指標
long new: 要分配的 long 值

描述

如果 (v == old)，則以原子方式使用 release ordering 將 v 更新為 new。否則，v 不會被修改，old 會被更新為 v 的當前值，並提供 relaxed ordering。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_try_cmpxchg_release()。

返回

如果發生交換，則為 true，否則為 false。

bool raw_atomic_long_try_cmpxchg_relaxed(atomic_long_t *v, long *old, long new)¶: 具有寬鬆順序的原子比較和交換

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long *old: 與要比較的 long 值對應的指標
long new: 要分配的 long 值

描述

如果 (v == old)，則以原子方式使用 relaxed ordering 將 v 更新為 new。否則，v 不會被修改，old 會被更新為 v 的當前值，並提供 relaxed ordering。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_try_cmpxchg_relaxed()。

返回

如果發生交換，則為 true，否則為 false。

bool raw_atomic_long_sub_and_test(long i, atomic_long_t *v)¶: 原子減法並測試是否為零，使用 full ordering

引數

long i: 要減去的長整型值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v - i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_sub_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool raw_atomic_long_dec_and_test(atomic_long_t *v)¶: 原子遞減並測試是否為零，使用 full ordering

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用完整排序原子地更新 v 為 (v - 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_dec_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool raw_atomic_long_inc_and_test(atomic_long_t *v)¶: 原子遞增並測試是否為零，使用 full ordering

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

使用完整排序原子地更新 v 為 (v + 1)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_inc_and_test()。

返回

如果 v 的結果值為零，則為 true，否則為 false。

bool raw_atomic_long_add_negative(long i, atomic_long_t *v)¶: 原子加法並測試是否為負數，使用 full ordering

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用完整排序將 v 更新為 (v + i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_add_negative()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool raw_atomic_long_add_negative_acquire(long i, atomic_long_t *v)¶: 原子加法並測試是否為負數，使用 acquire ordering

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用獲取排序將 v 更新為 (v + i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_add_negative_acquire()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool raw_atomic_long_add_negative_release(long i, atomic_long_t *v)¶: 原子加法並測試是否為負數，使用 release ordering

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用釋放排序將 v 更新為 (v + i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_add_negative_release()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

bool raw_atomic_long_add_negative_relaxed(long i, atomic_long_t *v)¶: 原子加法並測試是否為負數，使用 relaxed ordering

引數

long i: 要新增的 long 值
atomic_long_t *v: 指向 atomic_long_t 的指標

描述

以原子方式使用寬鬆排序將 v 更新為 (v + i)。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_add_negative_relaxed()。

返回

如果 v 的結果值為負數，則為 true，否則為 false。

long raw_atomic_long_fetch_add_unless(atomic_long_t *v, long a, long u)¶: 原子加法，除非值為 full ordering

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long a: 要新增的 long 值
long u: 要比較的 long 值

描述

如果 (v != u)，則以原子方式使用 full ordering 將 v 更新為 (v + a)。否則，v 不會被修改，並提供 relaxed ordering。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_fetch_add_unless()。

返回

v 的原始值。

bool raw_atomic_long_add_unless(atomic_long_t *v, long a, long u)¶: 原子加法，除非值為 full ordering

引數

atomic_long_t *v: 指向 atomic_long_t 的指標
long a: 要新增的 long 值
long u: 要比較的 long 值

描述

如果 (v != u)，則以原子方式使用 full ordering 將 v 更新為 (v + a)。否則，v 不會被修改，並提供 relaxed ordering。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_add_unless()。

返回

如果 v 已更新，則為 true，否則為 false。

bool raw_atomic_long_inc_not_zero(atomic_long_t *v)¶: 原子遞增，除非為零，使用 full ordering

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

如果 (v != 0)，則以原子方式使用 full ordering 將 v 更新為 (v + 1)。否則，v 不會被修改，並提供 relaxed ordering。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_inc_not_zero()。

返回

如果 v 已更新，則為 true，否則為 false。

bool raw_atomic_long_inc_unless_negative(atomic_long_t *v)¶: 原子遞增，除非為負數，使用 full ordering

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

如果 (v >= 0)，則以原子方式使用 full ordering 將 v 更新為 (v + 1)。否則，v 不會被修改，並提供 relaxed ordering。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_inc_unless_negative()。

返回

如果 v 已更新，則為 true，否則為 false。

bool raw_atomic_long_dec_unless_positive(atomic_long_t *v)¶: 原子遞減，除非為正數，使用 full ordering

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

如果 (v <= 0)，則以原子方式使用 full ordering 將 v 更新為 (v - 1)。否則，v 不會被修改，並提供 relaxed ordering。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_dec_unless_positive()。

返回

如果 v 已更新，則為 true，否則為 false。

long raw_atomic_long_dec_if_positive(atomic_long_t *v)¶: 原子遞減（如果為正數），使用 full ordering

引數

atomic_long_t *v: 指向 atomic_long_t 的指標

描述

如果 (v > 0)，則以原子方式使用 full ordering 將 v 更新為 (v - 1)。否則，v 不會被修改，並提供 relaxed ordering。

可在 noinstr 程式碼中使用；其他地方請優先使用 atomic_long_dec_if_positive()。

返回

(v - 1) 的舊值，無論 v 是否已更新。

核心物件操作¶

char *kobject_get_path(const struct kobject *kobj, gfp_t gfp_mask)¶: 分配記憶體並填充 kobj 的路徑。

引數

const struct kobject *kobj: 有問題的 kobject，用於構建路徑
gfp_t gfp_mask: 用於分配路徑的分配型別

返回

新分配的記憶體，呼叫者必須使用 kfree() 釋放。

int kobject_set_name(struct kobject *kobj, const char *fmt, ...)¶: 設定 kobject 的名稱。

引數

struct kobject *kobj: 要設定名稱的 struct kobject
const char *fmt: 用於構建名稱的格式字串
...: 可變引數

描述

這將設定 kobject 的名稱。如果您已經將 kobject 新增到系統，則必須呼叫 kobject_rename() 才能更改 kobject 的名稱。

void kobject_init(struct kobject *kobj, const struct kobj_type *ktype)¶: 初始化 kobject 結構。

引數

struct kobject *kobj: 要初始化的 kobject 的指標
const struct kobj_type *ktype: 此 kobject 的 ktype 的指標。

描述

此函式將正確初始化 kobject，以便隨後可以將其傳遞給 kobject_add() 呼叫。

呼叫此函式後，必須透過呼叫 kobject_put()（而不是直接呼叫 kfree）來清理 kobject，以確保正確清理所有記憶體。

int kobject_add(struct kobject *kobj, struct kobject *parent, const char *fmt, ...)¶: 主要的 kobject 新增函式。

引數

struct kobject *kobj: 要新增的 kobject
struct kobject *parent: kobject 的父物件的指標。
const char *fmt: 用於命名 kobject 的格式。
...: 可變引數

描述

在此函式中設定 kobject 名稱並將其新增到 kobject 層次結構中。

如果設定了 parent，則 kobj 的父物件將設定為它。如果 parent 為 NULL，則 kobj 的父物件將設定為與分配給此 kobject 的 kset 關聯的 kobject。如果沒有將 kset 分配給 kobject，則該 kobject 將位於 sysfs 樹的根目錄中。

注意，此呼叫不會建立任何“add” uevent，呼叫者應為該物件設定所有必要的 sysfs 檔案，然後使用 UEVENT_ADD 引數呼叫 kobject_uevent()，以確保使用者空間已正確收到此 kobject 建立的通知。

返回

如果此函式返回錯誤，則必須呼叫 kobject_put()

以正確清理與該物件關聯的記憶體。在任何情況下，都不應透過呼叫 kfree() 直接釋放傳遞給此函式的 kobject，這可能會導致記憶體洩漏。

如果此函式返回成功，則還必須呼叫 kobject_put()，以正確清理與該物件關聯的記憶體。

簡而言之，一旦呼叫此函式，當物件的使用完成後，必須呼叫 kobject_put()，以便正確釋放所有內容。

int kobject_init_and_add(struct kobject *kobj, const struct kobj_type *ktype, struct kobject *parent, const char *fmt, ...)¶: 初始化一個 kobject 結構體並將其新增到 kobject 層次結構中。

引數

struct kobject *kobj: 要初始化的 kobject 的指標
const struct kobj_type *ktype: 此 kobject 的 ktype 的指標。
struct kobject *parent: 指向此 kobject 的父物件的指標。
const char *fmt: kobject 的名稱。
...: 可變引數

描述

此函式結合了對 kobject_init() 和 kobject_add() 的呼叫。

如果此函式返回錯誤，則必須呼叫 kobject_put() 以正確清理與該物件關聯的記憶體。這與呼叫 kobject_add() 之後的錯誤處理型別相同，並且 kobject 生命週期規則在此處也相同。

int kobject_rename(struct kobject *kobj, const char *new_name)¶: 更改物件的名稱。

引數

struct kobject *kobj: 有問題的物件。
const char *new_name: 物件的新名稱

描述

呼叫方有責任在同一 kobject 上對 kobject_rename 的兩個不同調用之間提供互斥，並確保 new_name 有效且不會與其他 kobject 衝突。

int kobject_move(struct kobject *kobj, struct kobject *new_parent)¶: 將物件移動到另一個父物件。

引數

struct kobject *kobj: 有問題的物件。
struct kobject *new_parent: 物件的新父物件（可以為 NULL）

void kobject_del(struct kobject *kobj)¶: 從層次結構中取消連結 kobject。

引數

struct kobject *kobj: 物件。

描述

這是應該呼叫的函式，用於刪除透過 kobject_add() 成功新增的物件。

struct kobject *kobject_get(struct kobject *kobj)¶: 增加物件的引用計數。

引數

struct kobject *kobj: 物件。

void kobject_put(struct kobject *kobj)¶: 減少物件的引用計數。

引數

struct kobject *kobj: 物件。

描述

減少引用計數，如果為 0，則呼叫 kobject_cleanup()。

struct kobject *kobject_create_and_add(const char *name, struct kobject *parent)¶: 動態建立一個 struct kobject 並將其註冊到 sysfs。

引數

const char *name: kobject 的名稱
struct kobject *parent: 此 kobject 的父 kobject（如果有）。

描述

此函式動態建立一個 kobject 結構體並將其註冊到 sysfs。完成此結構體後，呼叫 kobject_put()，該結構體將在不再使用時動態釋放。

如果無法建立 kobject，將返回 NULL。

int kset_register(struct kset *k)¶: 初始化並新增一個 kset。

引數

struct kset *k: kset。

注意

發生錯誤時，由 kobj_set_name() 分配的 kset.kobj.name 會被釋放，不能再使用。

void kset_unregister(struct kset *k)¶: 刪除一個 kset。

引數

struct kset *k: kset。

struct kobject *kset_find_obj(struct kset *kset, const char *name)¶: 在 kset 中搜索物件。

引數

struct kset *kset: 我們要查詢的 kset。
const char *name: 物件的名稱。

描述

透過 kset->subsys 鎖定 kset，並迭代 kset->list，查詢匹配的 kobject。如果找到匹配的物件，則獲取引用並返回該物件。

struct kset *kset_create_and_add(const char *name, const struct kset_uevent_ops *uevent_ops, struct kobject *parent_kobj)¶: 動態建立一個 struct kset 並將其新增到 sysfs。

引數

const char *name: kset 的名稱
const struct kset_uevent_ops *uevent_ops: kset 的 struct kset_uevent_ops
struct kobject *parent_kobj: 此 kset 的父 kobject（如果有）。

描述

此函式動態建立一個 kset 結構體並將其註冊到 sysfs。完成此結構體後，呼叫 kset_unregister()，該結構體將在不再使用時動態釋放。

如果無法建立 kset，將返回 NULL。

int kobject_uevent_env(struct kobject *kobj, enum kobject_action action, char *envp_ext[])¶: 傳送帶有環境資料的 uevent

引數

struct kobject *kobj: 發生操作的 struct kobject
enum kobject_action action: 正在發生的操作
char *envp_ext[]: 指向環境資料的指標

描述

如果 kobject_uevent_env() 成功完成，則返回 0；如果失敗，則返回相應的錯誤。

int kobject_uevent(struct kobject *kobj, enum kobject_action action)¶: 透過傳送 uevent 通知使用者空間

引數

struct kobject *kobj: 發生操作的 struct kobject
enum kobject_action action: 正在發生的操作

描述

如果 kobject_uevent() 成功完成，則返回 0；如果失敗，則返回相應的錯誤。

int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)¶: 將鍵值字串新增到環境變數緩衝區

引數

struct kobj_uevent_env *env: 環境變數緩衝區結構
const char *format: 鍵=值對的 printf 格式
...: 可變引數

描述

如果成功新增環境變數，則返回 0；如果沒有可用空間，則返回 -ENOMEM。

核心實用程式函式¶

might_sleep¶

might_sleep ()

可以休眠的函式的註釋

描述

如果在原子上下文中（spinlock，irq-handler，...）執行此宏，它將列印堆疊跟蹤。可以使用 non_block_start() 和 non_block_end() 對不允許阻塞的附加部分進行註釋。

這是一種有用的除錯幫助，可以及早發現問題，並且在呼叫函式不應該休眠時發生休眠時，不會在以後受到影響。

cant_sleep¶

cant_sleep ()

不能休眠的函式的註釋

描述

如果在啟用搶佔的情況下執行此宏，它將列印堆疊跟蹤

cant_migrate¶

cant_migrate ()

無法遷移的函式的註釋

描述

如果在可遷移的程式碼中執行，將列印堆疊跟蹤

non_block_start¶

non_block_start ()

註釋禁止休眠的部分的開始

描述

這是代表 oom 清理器，特別是當它呼叫 mmu 通知程式時。問題是，如果通知程式阻塞（例如，在 mutex_lock() 上），並且如果持有該互斥鎖的程序執行休眠記憶體分配，則 oom 清理器現在被阻止完成該記憶體分配。其他阻塞呼叫（如 wait_event()）也會帶來類似的問題。

non_block_end¶

non_block_end ()

註釋禁止休眠的部分的結束

描述

關閉由 non_block_start() 開啟的部分。

trace_printk¶

trace_printk (fmt, ...)

ftrace 緩衝區中的 printf 格式

引數

fmt: 用於列印的 printf 格式
...: 可變引數

注意

__trace_printk 是 trace_printk() 的內部函式，: ip 透過 trace_printk() 宏傳入。

描述

此函式允許核心開發人員除錯不適合 printk 的快速路徑部分。透過在程式碼中散佈各種類似 printk 的跟蹤，開發人員可以快速查看出現問題的位置。

這僅用作開發人員的除錯工具。請避免在程式碼中散佈 trace_printk。（當使用 trace_printk() 時，會使用額外的記憶體來分配特殊緩衝區。）

這裡進行了一些小的最佳化技巧。如果只有一個引數，則無需掃描字串的 printf 格式。 trace_puts() 就足夠了。但是當 trace_printk() 只有一個引數時，我們如何利用使用 trace_puts() 的優勢？透過字串化引數並檢查大小，我們可以判斷是否存在引數。當沒有引數時，__stringify((__VA_ARGS__)) 將變為 “()0”，大小為 3，其他任何內容都將更大。我們需要做的就是定義一個字串給它，然後獲取它的大小並與 3 進行比較。如果它更大，則使用 do_trace_printk()，否則，將其最佳化為 trace_puts()。然後讓 gcc 最佳化其餘部分。

trace_puts¶

trace_puts (str)

將字串寫入 ftrace 緩衝區

引數

str: 要記錄的字串

注意

__trace_bputs 是 trace_puts 的內部函式，: ip 透過 trace_puts 宏傳入。

描述

這類似於 trace_printk()，但它是為那些開發人員希望以最少的 “海森堡” 效應獲得的非常快速的路徑而設計的，其中列印格式的處理仍然太多。

此函式允許核心開發人員除錯不適合 printk 的快速路徑部分。透過在程式碼中散佈各種類似 printk 的跟蹤，開發人員可以快速查看出現問題的位置。

這僅用作開發人員的除錯工具。請避免在程式碼中散佈 trace_puts。（當使用 trace_puts() 時，會使用額外的記憶體來分配特殊緩衝區。）

返回

如果未寫入任何內容，則為 0；如果字串被寫入，則為正數 #。: （當使用 __trace_bputs 時為 1，當使用 __trace_puts 時為 strlen(str)）

void console_list_lock(void)¶: 鎖定控制檯列表

引數

void: 無引數

描述

用於控制檯列表或 console->flags 更新

void console_list_unlock(void)¶: 解鎖控制檯列表

引數

void: 無引數

描述

與 console_list_lock() 相對應

int console_srcu_read_lock(void)¶: 為受 SRCU 保護的控制檯列表註冊一個新的讀取者

引數

void: 無引數

描述

使用 for_each_console_srcu() 迭代控制檯列表

上下文

任何上下文。

返回

一個 cookie 傳遞給 console_srcu_read_unlock()。

void console_srcu_read_unlock(int cookie)¶: 從受 SRCU 保護的控制檯列表登出一箇舊的讀取者

引數

int cookie: 從 console_srcu_read_lock() 返回的 cookie

描述

與 console_srcu_read_lock() 配對

int match_devname_and_update_preferred_console(const char *devname, const char *name, const short idx)¶: 當找到匹配的 devname 時，更新首選控制檯。

引數

const char *devname: DEVNAME:0.0 樣式的裝置名稱
const char *name: 相應控制檯驅動程式的名稱，例如“ttyS”
const short idx: 控制檯索引，例如埠號。

描述

該函式檢查是否透過 console=DEVNAME:0.0 命令列選項首選具有給定 **devname** 的裝置。它填充缺少的控制檯驅動程式名稱和控制檯索引，以便稍後的 register_console() 呼叫可以找到（匹配）並啟用此裝置。

當驅動程式子系統使用已知的 DEVNAME:0.0 樣式名稱初始化特定裝置時，可以使用它。並且它可以預測此裝置稍後將與哪個控制檯驅動程式名稱和索引關聯。

返回

成功時為 0，失敗時為負錯誤程式碼。

void console_lock(void)¶: 阻止控制檯子系統列印

引數

void: 無引數

描述

獲取一個鎖，以保證沒有控制檯將處於或進入它們的 write() 回撥。

可以睡眠，不返回任何內容。

int console_trylock(void)¶: 嘗試阻止控制檯子系統列印

引數

void: 無引數

描述

嘗試獲取一個鎖，以保證沒有控制檯將處於或進入它們的 write() 回撥。

成功時返回 1，獲取鎖失敗時返回 0。

void console_unlock(void)¶: 解除對傳統控制檯子系統列印的阻止

引數

void: 無引數

描述

釋放呼叫者持有的 console_lock，以阻止傳統控制檯子系統的列印。

當持有 console_lock 時，控制檯輸出可能已被 printk() 緩衝。如果是這種情況，console_unlock() 會在釋放鎖之前在傳統控制檯上發出輸出。

console_unlock(); 可以從任何上下文中呼叫。

void console_conditional_schedule(void)¶: 如果需要，讓出 CPU

引數

void: 無引數

描述

如果當前允許控制檯程式碼睡眠，並且如果此 CPU 應該將 CPU 讓給另一個任務，請在此處執行此操作。

必須在 console_lock() 中呼叫；。

void console_force_preferred_locked(struct console *con)¶: 強制註冊的控制檯成為首選

引數

struct console *con: 要強制成為首選的已註冊控制檯。

描述

必須在 console_list_lock() 下呼叫。

bool printk_timed_ratelimit(unsigned long *caller_jiffies, unsigned int interval_msecs)¶: 呼叫者控制的 printk 速率限制

引數

unsigned long *caller_jiffies: 指向呼叫者的狀態的指標
unsigned int interval_msecs: 列印之間的最小間隔

描述

如果自上次 printk_timed_ratelimit() 返回 true 以來，已經過去了超過 **interval_msecs** 毫秒，則 printk_timed_ratelimit() 返回 true。

int kmsg_dump_register(struct kmsg_dumper *dumper)¶: 註冊一個核心日誌轉儲器。

引數

struct kmsg_dumper *dumper: 指向 kmsg_dumper 結構的指標

描述

將核心日誌轉儲器新增到系統。當核心出現 oops 或 panic 時，將呼叫結構中的 dump 回撥，並且必須進行設定。成功時返回零，否則返回 -EINVAL 或 -EBUSY。

int kmsg_dump_unregister(struct kmsg_dumper *dumper)¶: 登出 kmsg 轉儲器。

引數

struct kmsg_dumper *dumper: 指向 kmsg_dumper 結構的指標

描述

從系統中刪除轉儲裝置。成功時返回零，否則返回 -EINVAL。

bool kmsg_dump_get_line(struct kmsg_dump_iter *iter, bool syslog, char *line, size_t size, size_t *len)¶: 檢索一條 kmsg 日誌行

引數

struct kmsg_dump_iter *iter: kmsg 轉儲迭代器
bool syslog: 包括“<4>”字首
char *line: 用於複製行的緩衝區
size_t size: 緩衝區的最大大小
size_t *len: 放入緩衝區的行的長度

描述

從 kmsg 緩衝區的開頭開始，從最舊的 kmsg 記錄開始，並將一條記錄複製到提供的緩衝區中。

連續呼叫將返回下一個可用的記錄，並朝著緩衝區末尾移動，其中包含最新的訊息。

FALSE 的返回值表示沒有更多記錄要讀取。

bool kmsg_dump_get_buffer(struct kmsg_dump_iter *iter, bool syslog, char *buf, size_t size, size_t *len_out)¶: 複製 kmsg 日誌行

引數

struct kmsg_dump_iter *iter: kmsg 轉儲迭代器
bool syslog: 包括“<4>”字首
char *buf: 用於複製行的緩衝區
size_t size: 緩衝區的最大大小
size_t *len_out: 放入緩衝區的行的長度

描述

從 kmsg 緩衝區的末尾開始，並用儘可能多的適合它的*最新* kmsg 記錄填充提供的緩衝區。如果緩衝區足夠大，則所有可用的 kmsg 記錄都將透過一次呼叫進行復制。

連續呼叫將使用下一塊可用的較舊記錄填充緩衝區，不包括先前檢索到的記錄。

FALSE 的返回值表示沒有更多記錄要讀取。

void kmsg_dump_rewind(struct kmsg_dump_iter *iter)¶: 重置迭代器

引數

struct kmsg_dump_iter *iter: kmsg 轉儲迭代器

描述

重置轉儲器的迭代器，以便可以再次呼叫 kmsg_dump_get_line() 和 kmsg_dump_get_buffer()，並在同一個 dumper.dump() 回撥中多次使用它們。

void __printk_cpu_sync_wait(void)¶: 忙等待直到 printk cpu 可重入自旋鎖不被任何 CPU 擁有。

引數

void: 無引數

上下文

任何上下文。

int __printk_cpu_sync_try_get(void)¶: 嘗試獲取 printk cpu 可重入自旋鎖。

引數

void: 無引數

描述

如果沒有處理器擁有該鎖，則呼叫處理器獲取該鎖併成為所有者。如果呼叫處理器已經是該鎖的所有者，則此函式立即成功。

上下文

任何上下文。希望中斷被停用。

返回

成功時為 1，否則為 0。

void __printk_cpu_sync_put(void)¶: 釋放 printk cpu 可重入自旋鎖。

引數

void: 無引數

描述

呼叫處理器必須是該鎖的所有者。

上下文

任何上下文。希望中斷被停用。

void panic(const char *fmt, ...)¶: 停止系統

引數

const char *fmt: 要列印的文字字串
...: 可變引數

描述

顯示一條訊息，然後執行清理。此函式永遠不會返回。

void add_taint(unsigned flag, enum lockdep_ok lockdep_ok)¶: 新增一個 taint 標誌（如果尚未設定）。

引數

unsigned flag: TAINT_* 常量之一。
enum lockdep_ok lockdep_ok: 鎖除錯是否仍然 OK。

描述

如果發生了一些不好的事情，您將希望 **lockdebug_ok** = false，但對於一些值得注意但不具有破壞性的情況，可以將其設定為 true。

裝置資源管理¶

void *__devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp, int nid, const char *name)¶: 分配裝置資源資料

引數

dr_release_t release: devres 將與之關聯的釋放函式
size_t size: 分配大小
gfp_t gfp: 分配標誌
int nid: NUMA 節點
const char *name: 資源的名稱

描述

分配 **size** 位元組的 devres。分配的區域被清零，然後與 **release** 關聯。返回的指標可以傳遞給其他 devres_*() 函式。

返回

成功時指向分配的 devres 的指標，失敗時為 NULL。

void devres_for_each_res(struct device *dev, dr_release_t release, dr_match_t match, void *match_data, void (*fn)(struct device*, void*, void*), void *data)¶: 資源迭代器

引數

struct device *dev: 從中迭代資源的裝置
dr_release_t release: 查詢與此釋放函式關聯的資源
dr_match_t match: 匹配函式（可選）
void *match_data: 匹配函式的資料
void (*fn)(struct device *, void *, void *): 為每個匹配的資源呼叫的函式。
void *data: **fn** 的資料，**fn** 的第三個引數

描述

為 **dev** 的每個與 **release** 關聯且 **match** 返回 1 的 devres 呼叫 **fn**。

返回

void

void devres_free(void *res)¶: 釋放裝置資源資料

引數

void *res: 指向要釋放的devres資料的指標

描述

釋放使用 devres_alloc() 建立的 devres。

void devres_add(struct device *dev, void *res)¶: 註冊裝置資源

引數

struct device *dev: 要將資源新增到的裝置
void *res: 要註冊的資源

描述

將 devres res 註冊到 dev。 res 應該使用 devres_alloc() 分配。在驅動程式分離時，將自動呼叫關聯的釋放函式並釋放 devres。

void *devres_find(struct device *dev, dr_release_t release, dr_match_t match, void *match_data)¶: 查詢裝置資源

引數

struct device *dev: 從中查詢資源的裝置
dr_release_t release: 查詢與此釋放函式關聯的資源
dr_match_t match: 匹配函式（可選）
void *match_data: 匹配函式的資料

描述

查詢 dev 的最新 devres，它與 release 關聯，並且 match 返回 1。如果 match 為 NULL，則認為匹配所有。

返回

指向找到的 devres 的指標，如果未找到則為 NULL。

void *devres_get(struct device *dev, void *new_res, dr_match_t match, void *match_data)¶: 查詢 devres，如果不存在，則原子地新增一個

引數

struct device *dev: 要查詢或新增 devres 的裝置
void *new_res: 指向如果未找到則新增的新的初始化 devres 的指標
dr_match_t match: 匹配函式（可選）
void *match_data: 匹配函式的資料

描述

查詢 dev 的最新 devres，它具有與 new_res 相同的釋放函式，並且 match 返回 1。如果找到，則釋放 new_res；否則，原子地新增 new_res。

返回

指向找到或新增的 devres 的指標。

void *devres_remove(struct device *dev, dr_release_t release, dr_match_t match, void *match_data)¶: 查詢並刪除裝置資源

引數

struct device *dev: 從中查詢資源的裝置
dr_release_t release: 查詢與此釋放函式關聯的資源
dr_match_t match: 匹配函式（可選）
void *match_data: 匹配函式的資料

描述

查詢與 release 關聯且 match 返回 1 的 dev 的最新 devres。如果 match 為 NULL，則認為匹配所有。如果找到，則原子地刪除該資源並返回。

返回

成功時指向已刪除的 devres 的指標，如果未找到則為 NULL。

int devres_destroy(struct device *dev, dr_release_t release, dr_match_t match, void *match_data)¶: 查詢並銷燬裝置資源

引數

struct device *dev: 從中查詢資源的裝置
dr_release_t release: 查詢與此釋放函式關聯的資源
dr_match_t match: 匹配函式（可選）
void *match_data: 匹配函式的資料

描述

查詢與 release 關聯且 match 返回 1 的 dev 的最新 devres。如果 match 為 NULL，則認為匹配所有。如果找到，則原子地刪除並釋放該資源。

請注意，不會呼叫該資源的釋放函式，只會釋放 devres 分配的資料。呼叫者負責釋放任何其他資料。

返回

如果找到並釋放 devres，則為 0，如果未找到則為 -ENOENT。

int devres_release(struct device *dev, dr_release_t release, dr_match_t match, void *match_data)¶: 查詢裝置資源並銷燬它，呼叫 release

引數

struct device *dev: 從中查詢資源的裝置
dr_release_t release: 查詢與此釋放函式關聯的資源
dr_match_t match: 匹配函式（可選）
void *match_data: 匹配函式的資料

描述

查詢與 release 關聯且 match 返回 1 的 dev 的最新 devres。如果 match 為 NULL，則認為匹配所有。如果找到，則原子地刪除該資源，呼叫 release 函式並釋放該資源。

返回

如果找到並釋放 devres，則為 0，如果未找到則為 -ENOENT。

void *devres_open_group(struct device *dev, void *id, gfp_t gfp)¶: 開啟新的 devres 組

引數

struct device *dev: 要為其開啟 devres 組的裝置
void *id: 分隔符 ID
gfp_t gfp: 分配標誌

描述

為 dev 開啟一個新的 devres 組，其中包含 id。對於 id，建議使用指向不會用於另一個組的物件的指標。如果 id 為 NULL，則建立地址唯一的 ID。

返回

新組的 ID，失敗時為 NULL。

void devres_close_group(struct device *dev, void *id)¶: 關閉一個 devres 組

引數

struct device *dev: 要為其關閉 devres 組的裝置
void *id: 目標組的 ID，可以為 NULL

描述

關閉由 id 標識的組。如果 id 為 NULL，則選擇最新的開啟組。

void devres_remove_group(struct device *dev, void *id)¶: 刪除一個 devres 組

引數

struct device *dev: 要為其刪除組的裝置
void *id: 目標組的 ID，可以為 NULL

描述

刪除由 id 標識的組。如果 id 為 NULL，則選擇最新的開啟組。請注意，刪除組不會影響任何其他資源。

int devres_release_group(struct device *dev, void *id)¶: 釋放 devres 組中的資源

引數

struct device *dev: 要為其釋放組的裝置
void *id: 目標組的 ID，可以為 NULL

描述

釋放由 id 標識的組中的所有資源。如果 id 為 NULL，則選擇最新的開啟組。將刪除選定的組和正確巢狀在選定組內的組。

返回

已釋放的非組資源的數量。

int __devm_add_action(struct device *dev, void (*action)(void*), void *data, const char *name)¶: 將自定義操作新增到託管資源列表

引數

struct device *dev: 擁有該操作的裝置
void (*action)(void *): 應呼叫的函式
void *data: 指向傳遞給 action 實現的資料的指標
const char *name: 資源的名稱（用於除錯目的）

描述

這將自定義操作新增到託管資源列表中，以便它作為標準資源展開的一部分執行。

int devm_remove_action_nowarn(struct device *dev, void (*action)(void*), void *data)¶: 刪除先前新增的自定義操作

引數

struct device *dev: 擁有該操作的裝置
void (*action)(void *): 實現該操作的函式
void *data: 指向傳遞給 action 實現的資料的指標

描述

刪除先前由 devm_add_action() 新增的 action 的例項。action 和 data 都應與現有條目之一匹配。

與 devm_remove_action() 相比，如果沒有找到任何條目，此函式不會 WARN()。

只有當 action 包含在具有獨立生存期管理的物件中時，才應使用此函式，例如 Devres rust 抽象。

導致常規驅動程式程式碼發出警告很可能表明濫用了 devres API。

返回

成功時為 0，如果未找到任何條目，則為 -ENOENT。

void devm_release_action(struct device *dev, void (*action)(void*), void *data)¶: 釋放先前新增的自定義操作

引數

struct device *dev: 擁有該操作的裝置
void (*action)(void *): 實現該操作的函式
void *data: 指向傳遞給 action 實現的資料的指標

描述

釋放並刪除先前由 devm_add_action() 新增的 action 的例項。action 和 data 都應與現有條目之一匹配。

void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp)¶: 資源管理的 kmalloc

引數

struct device *dev: 為其分配記憶體的裝置
size_t size: 分配大小
gfp_t gfp: 分配 gfp 標誌

描述

託管的 kmalloc。使用此函式分配的記憶體將在驅動程式分離時自動釋放。與所有其他 devres 資源一樣，保證的對齊方式為 unsigned long long。

返回

成功時指向已分配記憶體的指標，失敗時為 NULL。

void *devm_krealloc(struct device *dev, void *ptr, size_t new_size, gfp_t gfp)¶: 資源管理的 krealloc()

引數

struct device *dev: 為其重新分配記憶體的裝置
void *ptr: 指向要重新分配的記憶體塊的指標
size_t new_size: 新的分配大小
gfp_t gfp: 分配 gfp 標誌

描述

託管的 krealloc()。調整使用 devm_kmalloc() 分配的記憶體塊的大小。其行為類似於常規 krealloc()：如果 ptr 為 NULL 或 ZERO_SIZE_PTR，則等效於 devm_kmalloc()。如果 new_size 為零，它會釋放先前分配的記憶體並返回 ZERO_SIZE_PTR。此函式不會更改將呼叫重新分配的 devres 的釋放回調的順序（除非回退到 devm_kmalloc() 或在 new_size 為零時釋放資源）。記憶體的內容會保留到新舊大小中較小的一個。

char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp)¶: 分配資源管理的空間並將現有字串複製到該空間中。

引數

struct device *dev: 為其分配記憶體的裝置
const char *s: 要複製的字串
gfp_t gfp: 在分配記憶體時在 devm_kmalloc() 呼叫中使用的 GFP 掩碼

返回

成功時指向已分配字串的指標，失敗時為 NULL。

const char *devm_kstrdup_const(struct device *dev, const char *s, gfp_t gfp)¶: 資源管理的條件字串複製

引數

struct device *dev: 要為其複製字串的裝置
const char *s: 要複製的字串
gfp_t gfp: 在分配記憶體時在 kmalloc() 呼叫中使用的 GFP 掩碼

描述

當分離關聯的裝置時，將自動釋放由 devm_kstrdup_const 分配的字串。

返回

如果源字串位於 .rodata 段，則使用該字串，否則回退到 devm_kstrdup。

char *devm_kvasprintf(struct device *dev, gfp_t gfp, const char *fmt, va_list ap)¶: 分配資源管理的空間，並將字串格式化到該空間中。

引數

struct device *dev: 為其分配記憶體的裝置
gfp_t gfp: 在分配記憶體時在 devm_kmalloc() 呼叫中使用的 GFP 掩碼
const char *fmt: printf()-風格的格式字串
va_list ap: 格式字串的引數

返回

成功時指向已分配字串的指標，失敗時為 NULL。

char *devm_kasprintf(struct device *dev, gfp_t gfp, const char *fmt, ...)¶: 分配資源管理的空間，並將字串格式化到該空間中。

引數

struct device *dev: 為其分配記憶體的裝置
gfp_t gfp: 在分配記憶體時在 devm_kmalloc() 呼叫中使用的 GFP 掩碼
const char *fmt: printf()-風格的格式字串
...: 格式字串的引數

返回

成功時指向已分配字串的指標，失敗時為 NULL。

void devm_kfree(struct device *dev, const void *p)¶: 資源管理的 kfree

引數

struct device *dev: 此記憶體所屬的裝置
const void *p: 要釋放的記憶體

描述

釋放使用 devm_kmalloc() 分配的記憶體。

void *devm_kmemdup(struct device *dev, const void *src, size_t len, gfp_t gfp)¶: 資源管理的 kmemdup

引數

struct device *dev: 此記憶體所屬的裝置
const void *src: 要複製的記憶體區域
size_t len: 記憶體區域長度
gfp_t gfp: 要使用的 GFP 掩碼

描述

使用資源管理的 kmalloc 複製記憶體區域

unsigned long devm_get_free_pages(struct device *dev, gfp_t gfp_mask, unsigned int order)¶: 資源管理的 __get_free_pages

引數

struct device *dev: 為其分配記憶體的裝置
gfp_t gfp_mask: 分配 gfp 標誌
unsigned int order: 分配大小為 (1 << order) 頁

描述

管理的 get_free_pages。使用此函式分配的記憶體會在驅動程式分離時自動釋放。

返回

成功時返回已分配記憶體的地址，失敗時返回 0。

void devm_free_pages(struct device *dev, unsigned long addr)¶: 資源管理的 free_pages

引數

struct device *dev: 此記憶體所屬的裝置
unsigned long addr: 要釋放的記憶體

描述

釋放使用 devm_get_free_pages() 分配的記憶體。與 free_pages 不同，無需提供 order。

void __percpu *__devm_alloc_percpu(struct device *dev, size_t size, size_t align)¶: 資源管理的 alloc_percpu

引數

struct device *dev: 要為其分配每 CPU 記憶體的裝置
size_t size: 要分配的每 CPU 記憶體的大小
size_t align: 要分配的每 CPU 記憶體的對齊方式

描述

管理的 alloc_percpu。使用此函式分配的每 CPU 記憶體會在驅動程式分離時自動釋放。

返回

成功時指向已分配記憶體的指標，失敗時為 NULL。

void devm_free_percpu(struct device *dev, void __percpu *pdata)¶: 資源管理的 free_percpu

引數

struct device *dev: 此記憶體所屬的裝置
void __percpu *pdata: 要釋放的每 CPU 記憶體

描述

釋放使用 devm_alloc_percpu() 分配的記憶體。

Linux 核心

目錄

本頁

驅動程式基礎¶

驅動程式入口和出口點¶

驅動程式裝置表¶

延遲和排程例程¶

時間和定時器例程¶

高解析度定時器¶

等待佇列和喚醒事件¶

內部函式¶

引用計數¶

原子操作¶

核心物件操作¶

核心實用程式函式¶

裝置資源管理¶