注意

本文档适用于 Ceph 的开发版本。

Librados (C)

librados 提供对 RADOS 服务的低级访问。有关 RADOS 的概述，请参阅 架构。

示例：连接和写入对象

要使用 Librados，您需要实例化一个 rados_t 变量（一个集群句柄）并调用 rados_create()，传入指向该变量的指针。

int err;
rados_t cluster;

err = rados_create(&cluster, NULL);
if (err < 0) {
        fprintf(stderr, "%s: cannot create a cluster handle: %s\n", argv[0], strerror(-err));
        exit(1);
}

然后，您配置您的 rados_t 以连接到您的集群，可以通过设置单独的值 (rados_conf_set())，使用配置文件 (rados_conf_read_file())，使用命令行选项 (rados_conf_parse_argv())，或环境变量 (rados_conf_parse_env())。

err = rados_conf_read_file(cluster, "/path/to/myceph.conf");
if (err < 0) {
        fprintf(stderr, "%s: cannot read config file: %s\n", argv[0], strerror(-err));
        exit(1);
}

集群句柄配置完成后，您可以使用 rados_connect() 连接到集群。

err = rados_connect(cluster);
if (err < 0) {
        fprintf(stderr, "%s: cannot connect to cluster: %s\n", argv[0], strerror(-err));
        exit(1);
}

然后，您使用 rados_ioctx_create() 打开一个“IO 上下文”，即 rados_ioctx_t。

rados_ioctx_t io;
char *poolname = "mypool";

err = rados_ioctx_create(cluster, poolname, &io);
if (err < 0) {
        fprintf(stderr, "%s: cannot open rados pool %s: %s\n", argv[0], poolname, strerror(-err));
        rados_shutdown(cluster);
        exit(1);
}

请注意，您尝试访问的池必须存在。

然后您可以使用 RADOS 数据操作函数，例如使用 rados_write_full() 写入名为 greeting 的对象。

err = rados_write_full(io, "greeting", "hello", 5);
if (err < 0) {
        fprintf(stderr, "%s: cannot write pool %s: %s\n", argv[0], poolname, strerror(-err));
        rados_ioctx_destroy(io);
        rados_shutdown(cluster);
        exit(1);
}

最后，您需要使用 rados_ioctx_destroy() 和 rados_shutdown() 关闭 IO 上下文和与 RADOS 的连接。

rados_ioctx_destroy(io);
rados_shutdown(cluster);

异步 IO

在执行大量 IO 时，通常不需要等待一个操作完成后再开始下一个操作。Librados 提供了几个操作的异步版本：

对于每个操作，您必须首先通过调用 rados_aio_create_completion() 创建一个 rados_completion_t>，它表示操作安全或完成时要执行的操作。如果您不需要任何特殊操作，可以传递 NULL。

rados_completion_t comp;
err = rados_aio_create_completion(NULL, NULL, NULL, &comp);
if (err < 0) {
        fprintf(stderr, "%s: could not create aio completion: %s\n", argv[0], strerror(-err));
        rados_ioctx_destroy(io);
        rados_shutdown(cluster);
        exit(1);
}

现在您可以调用任何 aio 操作，并等待它在所有副本上进入内存或写入磁盘。

err = rados_aio_write(io, "foo", comp, "bar", 3, 0);
if (err < 0) {
        fprintf(stderr, "%s: could not schedule aio write: %s\n", argv[0], strerror(-err));
        rados_aio_release(comp);
        rados_ioctx_destroy(io);
        rados_shutdown(cluster);
        exit(1);
}
rados_aio_wait_for_complete(comp); // in memory
rados_aio_wait_for_safe(comp); // on disk

最后，我们需要使用 rados_aio_release() 释放完成对象使用的内存。

rados_aio_release(comp);

您可以使用回调函数来告知您的应用程序写入何时持久化，或者读取缓冲区何时已满。例如，如果您想在向多个对象追加数据时测量每个操作的延迟，您可以安排多次写入，并将确认（ack）时间和提交（commit）时间存储在相应的回调函数中，然后使用 rados_aio_flush() 等待所有操作完成，然后再分析延迟。

typedef struct {
        struct timeval start;
        struct timeval ack_end;
        struct timeval commit_end;
} req_duration;

void ack_callback(rados_completion_t comp, void *arg) {
        req_duration *dur = (req_duration *) arg;
        gettimeofday(&dur->ack_end, NULL);
}

void commit_callback(rados_completion_t comp, void *arg) {
        req_duration *dur = (req_duration *) arg;
        gettimeofday(&dur->commit_end, NULL);
}

int output_append_latency(rados_ioctx_t io, const char *data, size_t len, size_t num_writes) {
        req_duration times[num_writes];
        rados_completion_t comps[num_writes];
        for (size_t i = 0; i < num_writes; ++i) {
                gettimeofday(&times[i].start, NULL);
                int err = rados_aio_create_completion((void*) &times[i], ack_callback, commit_callback, &comps[i]);
                if (err < 0) {
                        fprintf(stderr, "Error creating rados completion: %s\n", strerror(-err));
                        return err;
                }
                char obj_name[100];
                snprintf(obj_name, sizeof(obj_name), "foo%ld", (unsigned long)i);
                err = rados_aio_append(io, obj_name, comps[i], data, len);
                if (err < 0) {
                        fprintf(stderr, "Error from rados_aio_append: %s", strerror(-err));
                        return err;
                }
        }
        // wait until all requests finish *and* the callbacks complete
        rados_aio_flush(io);
        // the latencies can now be analyzed
        printf("Request # | Ack latency (s) | Commit latency (s)\n");
        for (size_t i = 0; i < num_writes; ++i) {
                // don't forget to free the completions
                rados_aio_release(comps[i]);
                struct timeval ack_lat, commit_lat;
                timersub(&times[i].ack_end, &times[i].start, &ack_lat);
                timersub(&times[i].commit_end, &times[i].start, &commit_lat);
                printf("%9ld | %8ld.%06ld | %10ld.%06ld\n", (unsigned long) i, ack_lat.tv_sec, ack_lat.tv_usec, commit_lat.tv_sec, commit_lat.tv_usec);
        }
        return 0;
}

请注意，所有 rados_completion_t> 都必须使用 rados_aio_release() 释放，以避免内存泄漏。

API 调用

定义

LIBRADOS_ALL_NSPACES

在调用 rados_nobjects_list_open() 之前，将其作为 nspace 参数传递给 rados_ioctx_set_namespace() 以返回所有命名空间中的所有对象。

struct obj_watch_t
#include <rados_types.h>

list_watchers 中的一项

公共成员

char addr[256]

监视器的地址。

int64_t watcher_id

监视器 ID。

uint64_t cookie

Cookie。

uint32_t timeout_seconds

超时时间（秒）。

struct notify_ack_t

公共成员

uint64_t notifier_id
uint64_t cookie
char *payload
uint64_t payload_len
struct notify_timeout_t

公共成员

uint64_t notifier_id
uint64_t cookie

xattr 比较操作

用于比较对象上的 xattr，如果比较失败则中止 rados_read_op 或 rados_write_op 事务的操作符。

enum [anonymous]

值

enumerator LIBRADOS_CMPXATTR_OP_EQ
enumerator LIBRADOS_CMPXATTR_OP_NE
enumerator LIBRADOS_CMPXATTR_OP_GT
enumerator LIBRADOS_CMPXATTR_OP_GTE
enumerator LIBRADOS_CMPXATTR_OP_LT
enumerator LIBRADOS_CMPXATTR_OP_LTE

操作标志

用于 rados_read_op_operate()、rados_write_op_operate()、rados_aio_read_op_operate() 和 rados_aio_write_op_operate() 的标志。详见 librados.hpp。

enum [anonymous]

值

enumerator LIBRADOS_OPERATION_NOFLAG
enumerator LIBRADOS_OPERATION_BALANCE_READS
enumerator LIBRADOS_OPERATION_LOCALIZE_READS
enumerator LIBRADOS_OPERATION_ORDER_READS_WRITES
enumerator LIBRADOS_OPERATION_IGNORE_CACHE
enumerator LIBRADOS_OPERATION_SKIPRWLOCKS
enumerator LIBRADOS_OPERATION_IGNORE_OVERLAY
enumerator LIBRADOS_OPERATION_FULL_TRY
enumerator LIBRADOS_OPERATION_FULL_FORCE
enumerator LIBRADOS_OPERATION_IGNORE_REDIRECT
enumerator LIBRADOS_OPERATION_ORDERSNAP
enumerator LIBRADOS_OPERATION_RETURNVEC

分配提示标志

用于 rados_write_op_alloc_hint2() 和 rados_set_alloc_hint2() 的标志，指示未来的 IO 模式。

enum [anonymous]

值

enumerator LIBRADOS_ALLOC_HINT_FLAG_SEQUENTIAL_WRITE
enumerator LIBRADOS_ALLOC_HINT_FLAG_RANDOM_WRITE
enumerator LIBRADOS_ALLOC_HINT_FLAG_SEQUENTIAL_READ
enumerator LIBRADOS_ALLOC_HINT_FLAG_RANDOM_READ
enumerator LIBRADOS_ALLOC_HINT_FLAG_APPEND_ONLY
enumerator LIBRADOS_ALLOC_HINT_FLAG_IMMUTABLE
enumerator LIBRADOS_ALLOC_HINT_FLAG_SHORTLIVED
enumerator LIBRADOS_ALLOC_HINT_FLAG_LONGLIVED
enumerator LIBRADOS_ALLOC_HINT_FLAG_COMPRESSIBLE
enumerator LIBRADOS_ALLOC_HINT_FLAG_INCOMPRESSIBLE
enumerator LIBRADOS_ALLOC_HINT_FLAG_LOG

异步 I/O

非阻塞地读取和写入对象。

typedef void (*rados_callback_t)(rados_completion_t cb, void *arg)

异步操作的回调函数接受两个参数

  • cb 已完成的完成对象

  • arg 传递给回调函数的应用程序定义数据

int rados_aio_create_completion(void *cb_arg, rados_callback_t cb_complete, rados_callback_t cb_safe, rados_completion_t *pc)

构造用于异步操作的完成对象

complete 和 safe 回调分别对应操作被确认（acked）和提交（committed）。回调按接收顺序调用，因此 safe 回调可能在 complete 回调之前触发，反之亦然。这受 OSD 上的日志记录影响。

TODO: 在其他地方（在 RADOS 文档中？）提供更完整的文档

注意

读取操作只获取 complete 回调。

注意

BUG: 这应该检查 ENOMEM 而不是抛出异常

参数:

  • cb_arg -- 传递给回调函数的应用程序定义数据

  • cb_complete -- 当操作在所有副本上进入内存时调用的函数

  • cb_safe -- 当操作在所有副本上的稳定存储上时调用的函数

  • pc -- 存储完成对象的位置

返回:

0

int rados_aio_create_completion2(void *cb_arg, rados_callback_t cb_complete, rados_completion_t *pc)

构造用于异步操作的完成对象

complete 回调对应于操作被确认。

注意

BUG: 这应该检查 ENOMEM 而不是抛出异常

参数:

  • cb_arg -- 传递给回调函数的应用程序定义数据

  • cb_complete -- 当操作在所有副本上提交时调用的函数

  • pc -- 存储完成对象的位置

返回:

0

int rados_aio_wait_for_complete(rados_completion_t c)

阻塞直到操作完成

这意味着它在所有副本上都已进入内存。

注意

BUG: 这应该返回 void

参数:

  • c -- 要等待的操作

返回:

0

int rados_aio_wait_for_safe(rados_completion_t c) __attribute__((deprecated))

阻塞直到操作安全

这意味着它在所有副本上的稳定存储上。

注意

BUG: 这应该返回 void

参数:

  • c -- 要等待的操作

返回:

0

int rados_aio_is_complete(rados_completion_t c)

异步操作是否已完成？

警告

这并不意味着 complete 回调已完成

参数:

  • c -- 要检查的异步操作

返回:

c 是否完成

int rados_aio_is_safe(rados_completion_t c)

异步操作是否安全？

警告

这并不意味着 safe 回调已完成

参数:

  • c -- 要检查的异步操作

返回:

c 是否安全

int rados_aio_wait_for_complete_and_cb(rados_completion_t c)

阻塞直到操作完成并且回调完成

这意味着它在所有副本上都已进入内存并且可以读取。

注意

BUG: 这应该返回 void

参数:

  • c -- 要等待的操作

返回:

0

int rados_aio_wait_for_safe_and_cb(rados_completion_t c) __attribute__((deprecated))

阻塞直到操作安全并且回调完成

这意味着它在所有副本上的稳定存储上。

注意

BUG: 这应该返回 void

参数:

  • c -- 要等待的操作

返回:

0

int rados_aio_is_complete_and_cb(rados_completion_t c)

异步操作和回调是否已完成

参数:

  • c -- 要检查的异步操作

返回:

c 是否完成

int rados_aio_is_safe_and_cb(rados_completion_t c)

异步操作是否安全并且回调已完成

参数:

  • c -- 要检查的异步操作

返回:

c 是否安全

int rados_aio_get_return_value(rados_completion_t c)

获取异步操作的返回值

返回值在操作完成或安全时设置，以先发生者为准。

注意

BUG: 当在 complete 消息之前接收到 safe 消息时，complete 回调可能永远不会被调用

参数:

  • c -- 要检查的异步操作

前提：

操作已安全或完成

返回:

操作的返回值

uint64_t rados_aio_get_version(rados_completion_t c)

获取异步操作目标的内部对象版本

返回值在操作完成或安全时设置，以先发生者为准。

注意

BUG: 当在 complete 消息之前接收到 safe 消息时，complete 回调可能永远不会被调用

参数:

  • c -- 要检查的异步操作

前提：

操作已安全或完成

返回:

异步操作目标的版本号

void rados_aio_release(rados_completion_t c)

释放完成对象

当您不再需要完成对象时调用此函数。如果操作尚未确认和提交，它可能不会立即释放。

参数:

  • c -- 要释放的完成对象

int rados_aio_write(rados_ioctx_t io, const char *oid, rados_completion_t completion, const char *buf, size_t len, uint64_t off)

异步写入数据到对象

将写入操作排队并返回。完成对象的返回值成功时为 0，失败时为负错误码。

参数:

  • io -- 发生写入的上下文

  • oid -- 对象的名称

  • completion -- 写入安全且完成时要执行的操作

  • buf -- 要写入的数据

  • len -- 数据的长度（字节）

  • off -- 在对象中开始写入的字节偏移量

返回:

成功时为 0，如果 io 上下文指定的 snap_seq 不是 LIBRADOS_SNAP_HEAD，则为 -EROFS

int rados_aio_append(rados_ioctx_t io, const char *oid, rados_completion_t completion, const char *buf, size_t len)

异步追加数据到对象

将追加操作排队并返回。

完成对象的返回值成功时为 0，失败时为负错误码。

参数:

  • io -- 操作所在的上下文

  • oid -- 对象的名称

  • completion -- 追加安全且完成时要执行的操作

  • buf -- 要追加的数据

  • len -- buf 的长度（字节）

返回:

成功时为 0，如果 io 上下文指定的 snap_seq 不是 LIBRADOS_SNAP_HEAD，则为 -EROFS

int rados_aio_write_full(rados_ioctx_t io, const char *oid, rados_completion_t completion, const char *buf, size_t len)

异步写入整个对象

对象将用提供的数据填充。如果对象存在，它会被原子地截断，然后写入。将 write_full 操作排队并返回。

完成对象的返回值成功时为 0，失败时为负错误码。

参数:

  • io -- 发生写入的 io 上下文

  • oid -- 对象的名称

  • completion -- write_full 安全且完成时要执行的操作

  • buf -- 要写入的数据

  • len -- 数据的长度（字节）

返回:

成功时为 0，如果 io 上下文指定的 snap_seq 不是 LIBRADOS_SNAP_HEAD，则为 -EROFS

int rados_aio_writesame(rados_ioctx_t io, const char *oid, rados_completion_t completion, const char *buf, size_t data_len, size_t write_len, uint64_t off)

异步多次写入相同的缓冲区

将 writesame 操作排队并返回。

完成对象的返回值成功时为 0，失败时为负错误码。

参数:

  • io -- 发生写入的 io 上下文

  • oid -- 对象的名称

  • completion -- writesame 安全且完成时要执行的操作

  • buf -- 要写入的数据

  • data_len -- 数据的长度（字节）

  • write_len -- 要写入的总字节数

  • off -- 在对象中开始写入的字节偏移量

返回:

成功时为 0，如果 io 上下文指定的 snap_seq 不是 LIBRADOS_SNAP_HEAD，则为 -EROFS

int rados_aio_remove(rados_ioctx_t io, const char *oid, rados_completion_t completion)

异步删除对象

将 remove 操作排队并返回。

完成对象的返回值成功时为 0，失败时为负错误码。

参数:

  • io -- 操作所在的上下文

  • oid -- 对象的名称

  • completion -- remove 安全且完成时要执行的操作

返回:

成功时为 0，如果 io 上下文指定的 snap_seq 不是 LIBRADOS_SNAP_HEAD，则为 -EROFS

int rados_aio_read(rados_ioctx_t io, const char *oid, rados_completion_t completion, char *buf, size_t len, uint64_t off)

异步读取对象中的数据

如果通过 rados_ioctx_snap_set_read() 设置了快照，io 上下文将确定要从中读取的快照。

完成对象的返回值成功时为读取的字节数，失败时为负错误码。

注意

只会调用完成对象的 'complete' 回调。

参数:

  • io -- 执行读取的上下文

  • oid -- 要读取的对象的名称

  • completion -- 读取完成时要执行的操作

  • buf -- 存储结果的位置

  • len -- 要读取的字节数

  • off -- 在对象中开始读取的偏移量

返回:

成功时为 0，失败时为负错误码

int rados_aio_flush(rados_ioctx_t io)

阻塞直到 io 上下文中所有待处理的写入都安全

这不等同于对所有写入完成对象调用 rados_aio_wait_for_safe()，因为这也会等待相关的回调完成。

注意

BUG: 始终返回 0，应该返回 void 或接受超时参数

参数:

  • io -- 要刷新的上下文

返回:

成功时为 0，失败时为负错误码

int rados_aio_flush_async(rados_ioctx_t io, rados_completion_t completion)

安排一个回调函数，以便在所有当前待处理的 aio 写入安全时调用。这是 rados_aio_flush() 的非阻塞版本。

参数:

  • io -- 要刷新的上下文

  • completion -- 写入安全时要执行的操作

返回:

成功时为 0，失败时为负错误码

int rados_aio_stat(rados_ioctx_t io, const char *o, rados_completion_t completion, uint64_t *psize, time_t *pmtime)

异步获取对象统计信息（大小/修改时间）

参数:

  • io -- ioctx

  • o -- 对象名称

  • completion -- 统计完成时要执行的操作

  • psize -- 存储对象大小的位置

  • pmtime -- 存储修改时间的位置

返回:

成功时为 0，失败时为负错误码

int rados_aio_stat2(rados_ioctx_t io, const char *o, rados_completion_t completion, uint64_t *psize, struct timespec *pmtime)
int rados_aio_cmpext(rados_ioctx_t io, const char *o, rados_completion_t completion, const char *cmp_buf, size_t cmp_len, uint64_t off)

异步比较磁盘上的对象范围和缓冲区

参数:

  • io -- 执行比较的上下文

  • o -- 要比较的对象的名称

  • completion -- 比较完成时要执行的操作

  • cmp_buf -- 包含要与对象内容进行比较的字节的缓冲区

  • cmp_len -- 要比较的长度和 cmp_buf 的大小（字节）

  • off -- 在对象中开始比较的字节偏移量

返回:

成功时为 0，失败时为负错误码，不匹配时为 (-MAX_ERRNO - mismatch_off)

int rados_aio_cancel(rados_ioctx_t io, rados_completion_t completion)

取消异步操作

参数:

  • io -- ioctx

  • completion -- 完成句柄

返回:

成功时为 0，失败时为负错误码

int rados_aio_exec(rados_ioctx_t io, const char *o, rados_completion_t completion, const char *cls, const char *method, const char *in_buf, size_t in_len, char *buf, size_t out_len)

异步在对象上执行 OSD 类方法

OSD 有一种插件机制，用于以原子方式对对象执行复杂操作。这些插件称为类。此函数允许 librados 用户调用自定义方法。输入和输出格式由类定义。ceph.git 中的类可以在 src/cls 子目录中找到。

参数:

  • io -- 调用方法的上下文

  • o -- 对象的名称

  • completion -- exec 完成时要执行的操作

  • cls -- 类的名称

  • method -- 方法的名称

  • in_buf -- 查找输入的位置

  • in_len -- in_buf 的长度（字节）

  • buf -- 存储输出的位置

  • out_len -- buf 的长度（字节）

返回:

成功时为 0，失败时为负错误码

监视/通知

监视/通知是一种帮助客户端之间通信的协议。它可以用于同步客户端状态。所需要的只是一个众所周知的对象名称（例如，rbd 使用映像的头部对象）。

监视器注册对对象的兴趣，并接收该对象上的所有通知。通知尝试与监视该对象的所有客户端通信，并在每个客户端响应或达到超时之前阻塞通知者。

有关详细信息，请参阅 rados_watch() 和 rados_notify()。

typedef void (*rados_watchcb_t)(uint8_t opcode, uint64_t ver, void *arg)

在监视的对象上接收到通知时激活的回调函数。

注意

BUG: opcode 是不应暴露的内部细节

注意

BUG: ver 未使用

Param opcode:

未定义

Param ver:

监视对象的版本

Param arg:

应用程序特定的数据

typedef void (*rados_watchcb2_t)(void *arg, uint64_t notify_id, uint64_t handle, uint64_t notifier_id, void *data, size_t data_len)

在监视的对象上接收到通知时激活的回调函数。

Param arg:

提供给 rados_watch2() 的不透明用户定义值

Param notify_id:

此通知事件的 ID

Param handle:

我们正在通知的监视器句柄

Param notifier_id:

通知者的唯一客户端 ID

Param data:

来自通知者的有效载荷

Param data_len:

有效载荷缓冲区的长度

typedef void (*rados_watcherrcb_t)(void *pre, uint64_t cookie, int err)

当我们遇到监视会话错误时激活的回调函数。当对象的位置在集群内移动，我们未能向新的对象位置注册监视时，或者当我们与对象 OSD 的连接中断时，可能会发生这种情况，我们可能错过了通知事件。

Param pre:

提供给 rados_watch2() 的不透明用户定义值

Param cookie:

分配给监视会话的内部 ID

Param err:

错误码

int rados_watch(rados_ioctx_t io, const char *o, uint64_t ver, uint64_t *cookie, rados_watchcb_t watchcb, void *arg) __attribute__((deprecated))

注册对对象的兴趣

监视操作将客户端注册为对对象上的通知感兴趣。OSD 会将监视信息保存在持久存储上，因此它们在正常的恢复过程中会跨集群更改而保留。如果客户端失去与被监视对象的主 OSD 的连接，监视将在 30 秒后被删除。当建立新连接或放置组切换 OSD 时，监视会自动重新建立。

注意

BUG: librados 应该提供一种方式让监视器注意到连接重置

注意

BUG: ver 参数不起作用，并且永远不会返回 -ERANGE（参见 URL tracker.ceph.com/issues/2592）

参数:

  • io -- 对象所在的池

  • o -- 要监视的对象

  • ver -- 对象的预期版本

  • cookie -- 存储分配给此监视的内部 ID 的位置

  • watchcb -- 在此对象上接收到通知时要执行的操作

  • arg -- 调用 watchcb 时要传递的应用程序定义数据

返回:

成功时为 0，失败时为负错误码

返回:

如果对象的版本大于 ver，则返回 -ERANGE

int rados_watch2(rados_ioctx_t io, const char *o, uint64_t *cookie, rados_watchcb2_t watchcb, rados_watcherrcb_t watcherrcb, void *arg)

注册对对象的兴趣

监视操作将客户端注册为对对象上的通知感兴趣。OSD 会将监视信息保存在持久存储上，因此它们在正常的恢复过程中会跨集群更改而保留。如果客户端失去与被监视对象的主 OSD 的连接，监视将在通过 osd_client_watch_timeout 配置的超时时间后被删除。当建立新连接或放置组切换 OSD 时，监视会自动重新建立。

参数:

  • io -- 对象所在的池

  • o -- 要监视的对象

  • cookie -- 存储分配给此监视的内部 ID 的位置

  • watchcb -- 在此对象上接收到通知时要执行的操作

  • watcherrcb -- 监视会话遇到错误时要执行的操作

  • arg -- 传递给回调函数的不透明值

返回:

成功时为 0，失败时为负错误码

int rados_watch3(rados_ioctx_t io, const char *o, uint64_t *cookie, rados_watchcb2_t watchcb, rados_watcherrcb_t watcherrcb, uint32_t timeout, void *arg)

注册对对象的兴趣

监视操作将客户端注册为对对象上的通知感兴趣。OSD 会将监视信息保存在持久存储上，因此它们在正常的恢复过程中会跨集群更改而保留。当建立新连接或放置组切换 OSD 时，监视会自动重新建立。

参数:

  • io -- 对象所在的池

  • o -- 要监视的对象

  • cookie -- 存储分配给此监视的内部 ID 的位置

  • watchcb -- 在此对象上接收到通知时要执行的操作

  • watcherrcb -- 监视会话遇到错误时要执行的操作

  • timeout -- 断开连接后连接将保持的秒数

  • arg -- 传递给回调函数的不透明值

返回:

成功时为 0，失败时为负错误码

int rados_aio_watch(rados_ioctx_t io, const char *o, rados_completion_t completion, uint64_t *handle, rados_watchcb2_t watchcb, rados_watcherrcb_t watcherrcb, void *arg)

异步注册对对象的兴趣

监视操作将客户端注册为对对象上的通知感兴趣。OSD 会将监视信息保存在持久存储上，因此它们在正常的恢复过程中会跨集群更改而保留。如果客户端失去与被监视对象的主 OSD 的连接，监视将在 30 秒后被删除。当建立新连接或放置组切换 OSD 时，监视会自动重新建立。

参数:

  • io -- 对象所在的池

  • o -- 要监视的对象

  • completion -- 尝试操作完成时要执行的操作

  • handle -- 存储分配给此监视的内部 ID 的位置

  • watchcb -- 在此对象上接收到通知时要执行的操作

  • watcherrcb -- 监视会话遇到错误时要执行的操作

  • arg -- 传递给回调函数的不透明值

返回:

成功时为 0，失败时为负错误码

int rados_aio_watch2(rados_ioctx_t io, const char *o, rados_completion_t completion, uint64_t *handle, rados_watchcb2_t watchcb, rados_watcherrcb_t watcherrcb, uint32_t timeout, void *arg)

异步注册对对象的兴趣

监视操作将客户端注册为对对象上的通知感兴趣。OSD 会将监视信息保存在持久存储上，因此它们在正常的恢复过程中会跨集群更改而保留。如果客户端失去与被监视对象的主 OSD 的连接，监视将在 timeout 参数配置的秒数后被删除。当建立新连接或放置组切换 OSD 时，监视会自动重新建立。

参数:

  • io -- 对象所在的池

  • o -- 要监视的对象

  • completion -- 尝试操作完成时要执行的操作

  • handle -- 存储分配给此监视的内部 ID 的位置

  • watchcb -- 在此对象上接收到通知时要执行的操作

  • watcherrcb -- 监视会话遇到错误时要执行的操作

  • timeout -- 断开连接后连接将保持的秒数

  • arg -- 传递给回调函数的不透明值

返回:

成功时为 0，失败时为负错误码

int rados_watch_check(rados_ioctx_t io, uint64_t cookie)

检查监视的状态

返回自上次确认监视以来的毫秒数。或者，如果发生错误，则返回错误码。

如果发生错误，监视不再有效，应使用 rados_unwatch2() 销毁。如果用户仍然对该对象感兴趣，应使用 rados_watch2() 创建新的监视。

参数:

  • io -- 对象所在的池

  • cookie -- 监视句柄

返回:

成功时返回自上次确认以来的毫秒数，失败时返回负错误码

int rados_unwatch(rados_ioctx_t io, const char *o, uint64_t cookie) __attribute__((deprecated))

取消对对象的兴趣注册

一旦完成，将不再向我们发送有关此监视的通知。应调用此函数以清理不需要的监视器。

参数:

  • io -- 对象所在的池

  • o -- 被监视对象的名称 (已忽略)

  • cookie -- 要取消注册的监视句柄

返回:

成功时为 0，失败时为负错误码

int rados_unwatch2(rados_ioctx_t io, uint64_t cookie)

取消对对象的兴趣注册

一旦完成，将不再向我们发送有关此监视的通知。应调用此函数以清理不需要的监视器。

参数:

  • io -- 对象所在的池

  • cookie -- 要取消注册的监视句柄

返回:

成功时为 0，失败时为负错误码

int rados_aio_unwatch(rados_ioctx_t io, uint64_t cookie, rados_completion_t completion)

异步取消对对象的兴趣注册

一旦完成，将不再向我们发送有关此监视的通知。应调用此函数以清理不需要的监视器。

参数:

  • io -- 对象所在的池

  • completion -- 尝试操作完成时要执行的操作

  • cookie -- 要取消注册的监视句柄

返回:

成功时为 0，失败时为负错误码

int rados_notify(rados_ioctx_t io, const char *o, uint64_t ver, const char *buf, int buf_len) __attribute__((deprecated))

同步通知对象的监视器

此调用将阻塞，直到所有对象的监视器都收到并对通知做出反应，或者达到超时。

注意

BUG: 无法通过 C API 更改超时时间

注意

BUG: rados_watchcb_t 中无法访问 bufferlist

参数:

  • io -- 对象所在的池

  • o -- 对象的名称

  • ver -- 已过时 - 只需传递零

  • buf -- 要发送给监视器的数据

  • buf_len -- buf 的长度（字节）

返回:

成功时为 0，失败时为负错误码

int rados_aio_notify(rados_ioctx_t io, const char *o, rados_completion_t completion, const char *buf, int buf_len, uint64_t timeout_ms, char **reply_buffer, size_t *reply_buffer_len)

同步通知对象的监视器

此调用将阻塞，直到所有对象的监视器都收到并对通知做出反应，或者达到超时。

回复缓冲区是可选的。如果指定，客户端将收到一个编码缓冲区，其中包含确认通知的客户端 ID 以及它们的通知确认有效负载（如果有）。超时的客户端不包括在内。即使是不包含通知确认有效负载的客户端也包含在列表中，但它们的有效负载长度为 0。格式如下：

le32 num_acks { le64 gid 客户端的全局 ID（对于 client.1234，即 1234） le64 cookie 客户端的 cookie le32 buflen 回复消息缓冲区长度 u8 * buflen 有效负载 } * num_acks le32 num_timeouts { le64 gid 客户端的全局 ID le64 cookie 客户端的 cookie } * num_timeouts

注意：如果通过同一客户端注册了多个监视器，则可能存在同一 gid 的多个实例。

注意：当用户不再需要回复缓冲区时，必须使用 rados_buffer_free() 释放它。

注意：由于结果缓冲区包括超时的客户端，即使 rados_notify() 返回错误代码（如 -ETIMEDOUT），它也会被设置。

参数:

  • io -- 对象所在的池

  • completion -- 尝试操作完成时要执行的操作

  • o -- 对象的名称

  • buf -- 要发送给监视器的数据

  • buf_len -- buf 的长度（字节）

  • timeout_ms -- 通知超时时间（毫秒）

  • reply_buffer -- 指向回复缓冲区指针的指针（使用 rados_buffer_free 释放）

  • reply_buffer_len -- 指向回复缓冲区大小的指针

返回:

成功时为 0，失败时为负错误码

int rados_notify2(rados_ioctx_t io, const char *o, const char *buf, int buf_len, uint64_t timeout_ms, char **reply_buffer, size_t *reply_buffer_len)
int rados_decode_notify_response(char *reply_buffer, size_t reply_buffer_len, struct notify_ack_t **acks, size_t *nr_acks, struct notify_timeout_t **timeouts, size_t *nr_timeouts)

解码通知响应

将通知响应（来自 rados_aio_notify() 调用）解码为确认和超时数组。

参数:

  • reply_buffer -- 来自 rados_aio_notify() 调用的缓冲区

  • reply_buffer_len -- reply_buffer 长度

  • acks -- 指向 struct notify_ack_t 指针的指针

  • nr_acks -- 指向确认计数的指针

  • timeouts -- 指向 notify_timeout_t 指针的指针

  • nr_timeouts -- 指向超时计数的指针

返回:

成功时返回 0

void rados_free_notify_response(struct notify_ack_t *acks, size_t nr_acks, struct notify_timeout_t *timeouts)

释放通知分配的缓冲区

释放由 rados_decode_notify_response() 调用分配的内存

参数:

  • acks -- notify_ack_t 结构（来自 rados_decode_notify_response()）

  • nr_acks -- 确认计数

  • timeouts -- notify_timeout_t 结构（来自 rados_decode_notify_response()）

int rados_notify_ack(rados_ioctx_t io, const char *o, uint64_t notify_id, uint64_t cookie, const char *buf, int buf_len)

确认收到通知

参数:

  • io -- 对象所在的池

  • o -- 对象的名称

  • notify_id -- 我们在 watchcb2_t 回调中获得的 notify_id

  • cookie -- 监视器句柄

  • buf -- 返回给通知者的有效负载（可选）

  • buf_len -- 有效负载长度

返回:

成功时返回 0

int rados_watch_flush(rados_t cluster)

刷新监视/通知回调

此调用将阻塞，直到所有待处理的监视/通知回调都已执行且队列为空。通常应在关闭 ioctx 或 librados 之前，在关闭任何监视之后调用此函数，以确保任何回调不会误用 ioctx（例如，在 ioctx 被销毁后调用 rados_notify_ack）。

参数:

  • cluster -- 集群句柄

int rados_aio_watch_flush(rados_t cluster, rados_completion_t completion)

刷新监视/通知回调

此调用将是非阻塞的，并且完成回调将在所有待处理的监视/通知回调都已执行且队列为空时被调用。通常应在关闭 ioctx 或 librados 之前，在关闭任何监视之后调用此函数，以确保任何回调不会误用 ioctx（例如，在 ioctx 被销毁后调用 rados_notify_ack）。

参数:

  • cluster -- 集群句柄

  • completion -- 尝试操作完成时要执行的操作

Mon/OSD/PG 命令

这些接口发送与监视器、OSD 或 PG 相关的命令。

typedef void (*rados_log_callback_t)(void *arg, const char *line, const char *who, uint64_t sec, uint64_t nsec, uint64_t seq, const char *level, const char *msg)
typedef void (*rados_log_callback2_t)(void *arg, const char *line, const char *channel, const char *who, const char *name, uint64_t sec, uint64_t nsec, uint64_t seq, const char *level, const char *msg)
int rados_mon_command(rados_t cluster, const char **cmd, size_t cmdlen, const char *inbuf, size_t inbuflen, char **outbuf, size_t *outbuflen, char **outs, size_t *outslen)

发送监视器命令。

结果缓冲区是在堆上分配的；调用者需要使用 rados_buffer_free() 释放该内存。缓冲区和长度指针都可以为 NULL，在这种情况下它们不会被填充。

注意

命令字符串采用精心格式化的 JSON；必须匹配定义的命令、类型等。

参数:

  • cluster -- 集群句柄

  • cmd -- 代表命令的 char * 数组

  • cmdlen -- cmd 中有效条目的计数

  • inbuf -- 任何批量输入数据（crush map 等）

  • inbuflen -- 输入缓冲区长度

  • outbuf -- 输出缓冲区双指针

  • outbuflen -- 指向输出缓冲区长度的指针

  • outs -- 状态字符串双指针

  • outslen -- 指向状态字符串长度的指针

返回:

成功时为 0，失败时为负错误码

int rados_mgr_command(rados_t cluster, const char **cmd, size_t cmdlen, const char *inbuf, size_t inbuflen, char **outbuf, size_t *outbuflen, char **outs, size_t *outslen)

发送 ceph-mgr 命令。

结果缓冲区是在堆上分配的；调用者需要使用 rados_buffer_free() 释放该内存。缓冲区和长度指针都可以为 NULL，在这种情况下它们不会被填充。

注意

命令字符串采用精心格式化的 JSON；必须匹配定义的命令、类型等。

参数:

  • cluster -- 集群句柄

  • cmd -- 代表命令的 char * 数组

  • cmdlen -- cmd 中有效条目的计数

  • inbuf -- 任何批量输入数据（crush map 等）

  • inbuflen -- 输入缓冲区长度

  • outbuf -- 输出缓冲区双指针

  • outbuflen -- 指向输出缓冲区长度的指针

  • outs -- 状态字符串双指针

  • outslen -- 指向状态字符串长度的指针

返回:

成功时为 0，失败时为负错误码

int rados_mgr_command_target(rados_t cluster, const char *name, const char **cmd, size_t cmdlen, const char *inbuf, size_t inbuflen, char **outbuf, size_t *outbuflen, char **outs, size_t *outslen)

发送 ceph-mgr tell 命令。

结果缓冲区是在堆上分配的；调用者需要使用 rados_buffer_free() 释放该内存。缓冲区和长度指针都可以为 NULL，在这种情况下它们不会被填充。

注意

命令字符串采用精心格式化的 JSON；必须匹配定义的命令、类型等。

参数:

  • cluster -- 集群句柄

  • name -- 目标 mgr 名称

  • cmd -- 代表命令的 char * 数组

  • cmdlen -- cmd 中有效条目的计数

  • inbuf -- 任何批量输入数据（crush map 等）

  • inbuflen -- 输入缓冲区长度

  • outbuf -- 输出缓冲区双指针

  • outbuflen -- 指向输出缓冲区长度的指针

  • outs -- 状态字符串双指针

  • outslen -- 指向状态字符串长度的指针

返回:

成功时为 0，失败时为负错误码

int rados_mon_command_target(rados_t cluster, const char *name, const char **cmd, size_t cmdlen, const char *inbuf, size_t inbuflen, char **outbuf, size_t *outbuflen, char **outs, size_t *outslen)

向特定的监视器发送监视器命令。

结果缓冲区是在堆上分配的；调用者需要使用 rados_buffer_free() 释放该内存。缓冲区和长度指针都可以为 NULL，在这种情况下它们不会被填充。

注意

命令字符串采用精心格式化的 JSON；必须匹配定义的命令、类型等。

参数:

  • cluster -- 集群句柄

  • name -- 目标监视器的名称

  • cmd -- 代表命令的 char * 数组

  • cmdlen -- cmd 中有效条目的计数

  • inbuf -- 任何批量输入数据（crush map 等）

  • inbuflen -- 输入缓冲区长度

  • outbuf -- 输出缓冲区双指针

  • outbuflen -- 指向输出缓冲区长度的指针

  • outs -- 状态字符串双指针

  • outslen -- 指向状态字符串长度的指针

返回:

成功时为 0，失败时为负错误码

void rados_buffer_free(char *buf)

释放 rados 分配的缓冲区

释放由 librados 调用（如 rados_mon_command()）分配的内存。

参数:

  • buf -- 缓冲区指针

int rados_osd_command(rados_t cluster, int osdid, const char **cmd, size_t cmdlen, const char *inbuf, size_t inbuflen, char **outbuf, size_t *outbuflen, char **outs, size_t *outslen)
int rados_pg_command(rados_t cluster, const char *pgstr, const char **cmd, size_t cmdlen, const char *inbuf, size_t inbuflen, char **outbuf, size_t *outbuflen, char **outs, size_t *outslen)
int rados_monitor_log(rados_t cluster, const char *level, rados_log_callback_t cb, void *arg)
int rados_monitor_log2(rados_t cluster, const char *level, rados_log_callback2_t cb, void *arg)
int rados_service_register(rados_t cluster, const char *service, const char *daemon, const char *metadata_dict)

注册守护进程实例以提供服务

将我们注册为提供特定服务的守护进程。我们指定服务（例如 'rgw'）和我们的实例名称（例如 'rgw.$hostname'）。元数据是此实例的任意静态元数据的键值映射。编码是一系列以 NULL 结尾的字符串，交替出现键名和值，以空键名终止。例如，“foo\0bar\0this\0that\0\0”是字典 {foo=bar,this=that}。

在 librados 实例的生命周期内，将定期向集群发送信标以维护我们在服务映射中的注册。

参数:

  • cluster -- 句柄

  • service -- 服务名称

  • daemon -- 守护进程实例名称

  • metadata_dict -- 静态守护进程元数据字典

int rados_service_update_status(rados_t cluster, const char *status_dict)

更新守护进程状态

更新我们在服务映射中可变的状态信息。

状态字典的编码方式与 rados_service_register 的守护进程元数据编码方式相同。例如，“foo\0bar\0this\0that\0\0”是 {foo=bar,this=that}。

参数:

  • cluster -- rados 集群句柄

  • status_dict -- 状态字典

设置和拆卸

这些是使用 librados 时应该调用的第一个和最后一个函数。

int rados_create(rados_t *cluster, const char *const id)

创建一个用于与 RADOS 集群通信的句柄。

调用此函数时会读取 Ceph 环境变量，因此如果 $CEPH_ARGS 指定了连接所需的一切，则无需进一步配置。

参数:

  • cluster -- 存储句柄的位置

  • id -- 要连接的用户（即 admin，而不是 client.admin）

返回:

成功时为 0，失败时为负错误码

int rados_create2(rados_t *pcluster, const char *const clustername, const char *const name, uint64_t flags)

rados_create 的扩展版本。

与 rados_create 类似，但 1) 不假定 'client.'+id；允许完整指定名称 2) 允许指定集群名称 3) 标志用于未来扩展

int rados_create_with_context(rados_t *cluster, rados_config_t cct)

从现有配置初始化集群句柄。

与另一个 rados_t 实例共享配置状态。

参数:

  • cluster -- 存储句柄的位置

  • cct -- 要使用的现有配置

返回:

成功时为 0，失败时为负错误码

int rados_ping_monitor(rados_t cluster, const char *mon_id, char **outstr, size_t *outstrlen)

ping ID 为 mon_id 的监视器，将结果回复存储在 buf 中（如果指定），最大大小为 len。

结果缓冲区是在堆上分配的；调用者需要使用 rados_buffer_free() 释放该内存。缓冲区和长度指针可以为 NULL，在这种情况下它们不会被填充。

参数:

  • cluster -- 集群句柄

  • mon_id -- [in] 要 ping 的监视器 ID

  • outstr -- [out] 包含结果回复的双指针

  • outstrlen -- [out] 指向 outstr 中回复大小的指针

int rados_connect(rados_t cluster)

连接到集群。

注意

BUG: 在调用此函数之前，调用与集群通信的函数将导致崩溃。

参数:

  • cluster -- 要连接的集群。

前提：

集群句柄至少配置了一个监视器地址。如果启用了 cephx，还必须设置客户端名称和密钥。

Post:

如果成功，可以使用 librados 中的任何函数

返回:

成功时为 0，失败时为负错误码

void rados_shutdown(rados_t cluster)

断开与集群的连接。

为了清理，只有在 rados_connect() 成功后才需要此操作。

警告

这不保证所有异步写入都已完成。为此，必须在所有打开的 io 上下文上调用 rados_aio_flush()。

警告

我们在关闭时隐式调用 rados_watch_flush()。如果正在使用监视，则应在销毁相关 IoCtx 之前显式调用此函数。我们在此处将其作为安全措施。

参数:

  • cluster -- 要关闭的集群

Post:

集群句柄不能再次使用

配置

这些函数读取和更新集群句柄的 Ceph 配置。任何配置更改都必须在连接到集群之前完成。

librados 用户可能想要设置的选项包括

  • mon_host

  • auth_supported

  • 使用 cephx 时的 key、keyfile 或 keyring

  • log_file、log_to_stderr、err_to_stderr 和 log_to_syslog

  • debug_rados、debug_objecter、debug_monc、debug_auth 或 debug_ms

有关可用配置选项的信息，请参阅 docs.ceph.com

int rados_conf_read_file(rados_t cluster, const char *path)

使用 Ceph 配置文件配置集群句柄

如果 path 为 NULL，则搜索默认位置，并使用找到的第一个位置。位置包括

  • $CEPH_CONF（环境变量）

  • /etc/ceph/ceph.conf

  • ~/.ceph/config

  • ceph.conf（在当前工作目录中）

参数:

  • cluster -- 要配置的集群句柄

  • path -- Ceph 配置文件的路径

前提：

尚未在集群句柄上调用 rados_connect()

返回:

成功时为 0，失败时为负错误码

int rados_conf_parse_argv(rados_t cluster, int argc, const char **argv)

使用命令行参数配置集群句柄

argv 可以包含任何常见的 Ceph 命令行选项，包括以 '--' 为前缀并用破折号或下划线替换空格的任何配置参数。例如，以下选项是等效的

  • --mon-host 10.0.0.1:6789

  • --mon_host 10.0.0.1:6789

  • -m 10.0.0.1:6789

参数:

  • cluster -- 要配置的集群句柄

  • argc -- argv 中的参数数量

  • argv -- 要解析的参数

前提：

尚未在集群句柄上调用 rados_connect()

返回:

成功时为 0，失败时为负错误码

int rados_conf_parse_argv_remainder(rados_t cluster, int argc, const char **argv, const char **remargv)

使用命令行参数配置集群句柄，返回任何剩余参数。与 rados_conf_parse_argv 相同，只是多了一个 remargv 参数用于保存返回的无法识别的参数。

参数:

  • cluster -- 要配置的集群句柄

  • argc -- argv 中的参数数量

  • argv -- 要解析的参数

  • remargv -- 用于返回无法识别参数的 char* 数组

前提：

尚未在集群句柄上调用 rados_connect()

返回:

成功时为 0，失败时为负错误码

int rados_conf_parse_env(rados_t cluster, const char *var)

根据环境变量配置集群句柄

环境变量的内容被解析为 Ceph 命令行选项。如果 var 为 NULL，则使用 CEPH_ARGS 环境变量。

注意

BUG: 此函数不是线程安全的 - 它使用静态缓冲区

参数:

  • cluster -- 要配置的集群句柄

  • var -- 要读取的环境变量名称

前提：

尚未在集群句柄上调用 rados_connect()

返回:

成功时为 0，失败时为负错误码

int rados_conf_set(rados_t cluster, const char *option, const char *value)

设置配置选项

参数:

  • cluster -- 要配置的集群句柄

  • option -- 要设置的选项

  • value -- 选项的值

前提：

尚未在集群句柄上调用 rados_connect()

返回:

成功时为 0，失败时为负错误码

返回:

当选项不是 Ceph 配置选项时返回 -ENOENT

int rados_conf_get(rados_t cluster, const char *option, char *buf, size_t len)

获取配置选项的值

参数:

  • cluster -- 要读取的配置

  • option -- 要读取的选项

  • buf -- 写入配置值的位置

  • len -- buf 的大小（字节）

返回:

成功时为 0，失败时为负错误码

返回:

如果缓冲区太短无法容纳请求的值，则返回 -ENAMETOOLONG

池

RADOS 池是对象的独立命名空间。池可以关联不同的 crush 规则，因此它们可能具有不同的复制级别或放置策略。RADOS 权限也与池绑定 - 用户可以根据每个池具有不同的读取、写入和执行权限。

int rados_pool_list(rados_t cluster, char *buf, size_t len)

列出池

获取以 NULL 结尾的池名称字符串列表。池名称将按顺序放置在提供的缓冲区中。在最后一个池名称之后，将有两个连续的 0 字节。

如果 len 太短，无法容纳所有需要的池名称条目，我们将填充尽可能多的内容。

Buf 可以为 null 以确定列出所有池所需的缓冲区大小。

参数:

  • cluster -- 集群句柄

  • buf -- 输出缓冲区

  • len -- 输出缓冲区长度

返回:

列出所有池所需的缓冲区长度

int rados_inconsistent_pg_list(rados_t cluster, int64_t pool, char *buf, size_t len)

列出给定池的不一致放置组

获取以 NULL 结尾的不一致放置组名称字符串列表。放置组名称将按顺序放置在提供的缓冲区中。在最后一个名称之后，将有两个连续的 0 字节。

如果 len 太短，无法容纳所有需要的放置组条目，我们将填充尽可能多的内容。

参数:

  • cluster -- 集群句柄

  • pool -- 池 ID

  • buf -- 输出缓冲区

  • len -- 输出缓冲区长度

返回:

列出所有池所需的缓冲区长度

rados_config_t rados_cct(rados_t cluster)

获取 rados 集群句柄的配置句柄

此句柄仅在集群句柄有效期间有效。

参数:

  • cluster -- 集群句柄

返回:

此集群的配置句柄

uint64_t rados_get_instance_id(rados_t cluster)

获取当前实例的全局 ID

此 ID 是当前与集群连接的唯一表示

参数:

  • cluster -- 集群句柄

返回:

实例全局 ID

int rados_get_min_compatible_osd(rados_t cluster, int8_t *require_osd_release)

获取最低兼容 OSD 版本

参数:

  • cluster -- 集群句柄

  • require_osd_release -- [out] 基于当前功能的最低兼容 OSD 版本

返回:

成功时返回 0，失败时返回负错误代码

int rados_get_min_compatible_client(rados_t cluster, int8_t *min_compat_client, int8_t *require_min_compat_client)

获取最低兼容客户端版本

参数:

  • cluster -- 集群句柄

  • min_compat_client -- [out] 基于当前功能的最低兼容客户端版本

  • require_min_compat_client -- [out] 基于显式设置的所需最低客户端版本

返回:

成功时为 0，失败时为负错误码

int rados_ioctx_create(rados_t cluster, const char *pool_name, rados_ioctx_t *ioctx)

创建 io 上下文

io 上下文允许您在特定池中执行操作。有关更多详细信息，请参阅 rados_ioctx_t。

参数:

  • cluster -- 池所在的集群

  • pool_name -- 池的名称

  • ioctx -- 存储 io 上下文的位置

返回:

成功时为 0，失败时为负错误码

int rados_ioctx_create2(rados_t cluster, int64_t pool_id, rados_ioctx_t *ioctx)
void rados_ioctx_destroy(rados_ioctx_t io)

与 rados_ioctx_create 相反

这只是告诉 librados 您不再需要使用 io 上下文。如果上面有待处理的异步请求，它可能不会立即释放，但在调用此函数后，您不应再次使用 io 上下文。

警告

这不保证所有异步写入都已完成。为此，您必须在销毁 io 上下文之前在其上调用 rados_aio_flush()。

警告

如果此 ioctx 用于 rados_watch，调用者需要确保所有已注册的监视都已通过 rados_unwatch() 断开连接，并且已调用 rados_watch_flush()。这可确保竞争监视回调不会使用已销毁的 ioctx。

参数:

  • io -- 要处理的 io 上下文

rados_config_t rados_ioctx_cct(rados_ioctx_t io)

获取池句柄的配置句柄

参数:

  • io -- 池句柄

返回:

此集群的 rados_config_t

rados_t rados_ioctx_get_cluster(rados_ioctx_t io)

获取此 rados_ioctx_t 使用的集群句柄。请注意，这是一个弱引用，不应通过 rados_shutdown() 销毁。

参数:

  • io -- io 上下文

返回:

此 io 上下文的集群句柄

int rados_ioctx_pool_stat(rados_ioctx_t io, struct rados_pool_stat_t *stats)

获取池使用情况统计信息

在查询集群后填充 rados_pool_stat_t。

参数:

  • io -- 确定要查询的池

  • stats -- 存储结果的位置

返回:

成功时为 0，失败时为负错误码

int64_t rados_pool_lookup(rados_t cluster, const char *pool_name)

获取池的 ID

参数:

  • cluster -- 池所在的集群

  • pool_name -- 要查找的池

返回:

池的 ID

返回:

如果找不到池，则返回 -ENOENT

int rados_pool_reverse_lookup(rados_t cluster, int64_t id, char *buf, size_t maxlen)

获取池的名称

参数:

  • cluster -- 池所在的集群

  • id -- 池的 ID

  • buf -- 存储池名称的位置

  • maxlen -- 存储名称的缓冲区大小

返回:

存储字符串的长度，如果缓冲区太小则返回 -ERANGE

int rados_pool_create(rados_t cluster, const char *pool_name)

创建具有默认设置的池

默认 crush 规则是规则 0。

参数:

  • cluster -- 将在其中创建池的集群

  • pool_name -- 新池的名称

返回:

成功时为 0，失败时为负错误码

int rados_pool_create_with_auid(rados_t cluster, const char *pool_name, uint64_t auid) __attribute__((deprecated))

创建由特定 auid 拥有的池。

已弃用：auid 支持已移除，此调用将在未来版本中移除。

参数:

  • cluster -- 将在其中创建池的集群

  • pool_name -- 新池的名称

  • auid -- 新池所有者的 ID

返回:

成功时为 0，失败时为负错误码

int rados_pool_create_with_crush_rule(rados_t cluster, const char *pool_name, uint8_t crush_rule_num)

创建具有特定 CRUSH 规则的池

参数:

  • cluster -- 将在其中创建池的集群

  • pool_name -- 新池的名称

  • crush_rule_num -- 用于在新池中进行放置的规则编号1

返回:

成功时为 0，失败时为负错误码

int rados_pool_create_with_all(rados_t cluster, const char *pool_name, uint64_t auid, uint8_t crush_rule_num) __attribute__((deprecated))

创建具有特定 CRUSH 规则和 auid 的池

已弃用：auid 支持已移除，此调用将在未来版本中移除。

这是 rados_pool_create_with_crush_rule() 和 rados_pool_create_with_auid() 的组合。

参数:

  • cluster -- 将在其中创建池的集群

  • pool_name -- 新池的名称

  • crush_rule_num -- 用于在新池中进行放置的规则编号2

  • auid -- 新池所有者的 ID

返回:

成功时为 0，失败时为负错误码

int rados_pool_get_base_tier(rados_t cluster, int64_t pool, int64_t *base_tier)

返回作为此池基本层的池。

返回值是应用于读取/写入的池的 ID。如果未为此池设置分层，则返回 pool。

参数:

  • cluster -- 池所在的集群

  • pool -- 要查询的池 ID

  • base_tier -- [out] 基本层，如果未配置分层则为 pool

返回:

成功时为 0，失败时为负错误码

int rados_pool_delete(rados_t cluster, const char *pool_name)

删除池及其中的所有数据

池会立即从集群中删除，但实际数据会在后台删除。

参数:

  • cluster -- 池所在的集群

  • pool_name -- 要删除的池名称

返回:

成功时为 0，失败时为负错误码

int rados_ioctx_pool_set_auid(rados_ioctx_t io, uint64_t auid) __attribute__((deprecated))

尝试更改 io 上下文关联的 auid“所有者”

已弃用：auid 支持已被删除，此调用无效。

需要您对当前和新的 auid 都具有写入权限。

参数:

  • io -- 要更改的池的引用。

  • auid -- 您希望 io 具有的 auid。

返回:

成功时为 0，失败时为负错误码

int rados_ioctx_pool_get_auid(rados_ioctx_t io, uint64_t *auid) __attribute__((deprecated))

获取池的 auid

已弃用：auid 支持已被删除，此调用始终报告 CEPH_AUTH_UID_DEFAULT (-1)。

参数:

  • io -- 要查询的池

  • auid -- 存储 auid 的位置

返回:

成功时为 0，失败时为负错误码

int rados_ioctx_pool_requires_alignment(rados_ioctx_t io) __attribute__((deprecated))
int rados_ioctx_pool_requires_alignment2(rados_ioctx_t io, int *req)

测试指定的池是否需要对齐。

参数:

  • io -- 要查询的池

  • req -- 如果支持对齐，则为 1；否则为 0。

返回:

成功时为 0，失败时为负错误码

uint64_t rados_ioctx_pool_required_alignment(rados_ioctx_t io) __attribute__((deprecated))
int rados_ioctx_pool_required_alignment2(rados_ioctx_t io, uint64_t *alignment)

获取池的对齐类型

参数:

  • io -- 要查询的池

  • alignment -- 存储对齐类型的位置

返回:

成功时为 0，失败时为负错误码

int64_t rados_ioctx_get_id(rados_ioctx_t io)

获取 io 上下文的池 ID

参数:

  • io -- 要查询的 io 上下文

返回:

io 上下文使用的池 ID

int rados_ioctx_get_pool_name(rados_ioctx_t io, char *buf, unsigned maxlen)

获取 io 上下文的池名称

参数:

  • io -- 要查询的 io 上下文

  • buf -- 存储名称的缓冲区指针

  • maxlen -- 存储名称的缓冲区大小

返回:

存储字符串的长度，如果缓冲区太小则返回 -ERANGE

对象定位器

void rados_ioctx_locator_set_key(rados_ioctx_t io, const char *key)

设置用于将对象映射到 io 上下文中的 pgs 的键。

该键用于代替对象名称来确定对象放入哪个放置组。这会影响 io 上下文的所有后续操作 - 在设置不同的定位器键之前，此 io 上下文中的所有对象都将放置在同一 pg 中。

参数:

  • io -- 要更改的 io 上下文

  • key -- 用作对象定位器的键，或 NULL 以丢弃先前设置的键

void rados_ioctx_set_namespace(rados_ioctx_t io, const char *nspace)

设置 io 上下文中对象的命名空间

命名空间规范进一步将池细分为不同的域。对象到 pgs 的映射也基于此值。

参数:

  • io -- 要更改的 io 上下文

  • nspace -- 用作命名空间的名称，或 NULL 以使用默认命名空间

int rados_ioctx_get_namespace(rados_ioctx_t io, char *buf, unsigned maxlen)

获取 io 上下文中对象的命名空间

参数:

  • io -- 要查询的 io 上下文

  • buf -- 存储名称的缓冲区指针

  • maxlen -- 存储名称的缓冲区大小

返回:

存储字符串的长度，如果缓冲区太小则返回 -ERANGE

列出对象

int rados_nobjects_list_open(rados_ioctx_t io, rados_list_ctx_t *ctx)

开始列出池中的对象

参数:

  • io -- 要从中列出的池

  • ctx -- 存储列表上下文的句柄

返回:

成功时为 0，失败时为负错误码

uint32_t rados_nobjects_list_get_pg_hash_position(rados_list_ctx_t ctx)

返回迭代器的哈希位置，四舍五入到当前 PG

参数:

  • ctx -- 标记您在列表中位置的迭代器

返回:

当前哈希位置，四舍五入到当前 pg

uint32_t rados_nobjects_list_seek(rados_list_ctx_t ctx, uint32_t pos)

将对象迭代器重新定位到不同的哈希位置

参数:

  • ctx -- 标记您在列表中位置的迭代器

  • pos -- 要移动到的哈希位置

返回:

我们移动到的实际（四舍五入）位置

uint32_t rados_nobjects_list_seek_cursor(rados_list_ctx_t ctx, rados_object_list_cursor cursor)

将对象迭代器重新定位到不同的位置

参数:

  • ctx -- 标记您在列表中位置的迭代器

  • cursor -- 要移动到的位置

返回:

我们移动到的四舍五入位置

int rados_nobjects_list_get_cursor(rados_list_ctx_t ctx, rados_object_list_cursor *cursor)

将对象迭代器重新定位到不同的位置

返回的句柄必须使用 rados_object_list_cursor_free() 释放。

参数:

  • ctx -- 标记您在列表中位置的迭代器

  • cursor -- 存储游标的位置

返回:

成功时为 0，失败时为负错误码

int rados_nobjects_list_next(rados_list_ctx_t ctx, const char **entry, const char **key, const char **nspace)

获取池中的下一个对象名称和定位器

entry 和 *key 在下一次调用 rados_nobjects_list_ 之前有效

参数:

  • ctx -- 标记您在列表中位置的迭代器

  • entry -- 存储条目名称的位置

  • key -- 存储对象定位器的位置（设置为 NULL 以忽略）

  • nspace -- 存储对象命名空间的位置（设置为 NULL 以忽略）

返回:

成功时为 0，失败时为负错误码

返回:

当没有更多对象可列出时返回 -ENOENT

int rados_nobjects_list_next2(rados_list_ctx_t ctx, const char **entry, const char **key, const char **nspace, size_t *entry_size, size_t *key_size, size_t *nspace_size)

获取池中的下一个对象名称、定位器及其大小

大小允许列出包含 \0（NUL 字符）的对象，例如 *entry。看到此类对象名称很不寻常，但客户端中的一个错误使得也需要处理它们。*entry 和 *key 在下一次调用 rados_nobjects_list_ 之前有效

参数:

  • ctx -- 标记您在列表中位置的迭代器

  • entry -- 存储条目名称的位置

  • key -- 存储对象定位器的位置（设置为 NULL 以忽略）

  • nspace -- 存储对象命名空间的位置（设置为 NULL 以忽略）

  • entry_size -- 存储条目名称大小的位置

  • key_size -- 存储对象定位器大小的位置（设置为 NULL 以忽略）

  • nspace_size -- 存储对象命名空间大小的位置（设置为 NULL 以忽略）

返回:

成功时为 0，失败时为负错误码

返回:

当没有更多对象可列出时返回 -ENOENT

void rados_nobjects_list_close(rados_list_ctx_t ctx)

关闭对象列表句柄。

不再需要句柄时应调用此函数。关闭后不应使用该句柄。

参数:

  • ctx -- 要关闭的句柄

rados_object_list_cursor rados_object_list_begin(rados_ioctx_t io)

获取指向池开头的游标句柄。

这是一个指向池开头的非透明句柄。必须使用 rados_object_list_cursor_free() 释放。

参数:

  • io -- 池的 ioctx

返回:

池的句柄，错误时为 NULL（池不存在）

rados_object_list_cursor rados_object_list_end(rados_ioctx_t io)

获取指向池末尾的游标句柄。

这是一个指向池开头的非透明句柄。必须使用 rados_object_list_cursor_free() 释放。

参数:

  • io -- 池的 ioctx

返回:

池的句柄，错误时为 NULL（池不存在）

int rados_object_list_is_end(rados_ioctx_t io, rados_object_list_cursor cur)

检查游标是否已到达池的末尾

参数:

  • io -- ioctx

  • cur -- 游标

返回:

如果游标已到达池的末尾，则为 1；否则为 0

void rados_object_list_cursor_free(rados_ioctx_t io, rados_object_list_cursor cur)

释放游标

释放游标。此后不得使用该句柄。

参数:

  • io -- ioctx

  • cur -- 游标

int rados_object_list_cursor_cmp(rados_ioctx_t io, rados_object_list_cursor lhs, rados_object_list_cursor rhs)

比较两个游标位置

比较两个游标，并指示第一个游标是在第二个游标之前、匹配还是之后。

参数:

  • io -- ioctx

  • lhs -- 第一个游标

  • rhs -- 第二个游标

返回:

对于 lhs < rhs、lhs == rhs 或 lhs > rhs，返回 -1、0 或 1

int rados_object_list(rados_ioctx_t io, const rados_object_list_cursor start, const rados_object_list_cursor finish, const size_t result_size, const char *filter_buf, const size_t filter_buf_len, rados_object_list_item *results, rados_object_list_cursor *next)
返回:

results 数组中设置的项数

void rados_object_list_free(const size_t result_size, rados_object_list_item *results)
void rados_object_list_slice(rados_ioctx_t io, const rados_object_list_cursor start, const rados_object_list_cursor finish, const size_t n, const size_t m, rados_object_list_cursor *split_start, rados_object_list_cursor *split_finish)

获取描绘范围子集的游标。当您想要拆分迭代全局命名空间的工作时，请使用此功能。预期的用例是当您并行迭代时，有 m 个 worker，每个 worker 占用一个 id n。

参数:

  • io -- ioctx

  • start -- 要切片的范围的开始（包含）

  • finish -- 要切片的范围的结束（独占）

  • n -- 您希望为其获取游标的 m 个块中的哪一个

  • m -- 将 start-finish 划分为多少个块

  • split_start -- 填充了子范围开始位置的游标（包含）

  • split_finish -- 填充了子范围结束位置的游标（独占）

快照

RADOS 快照基于形成快照上下文的序列号。它们是池特定的。快照上下文由池的当前快照序列号和拍摄快照时按降序排列的序列号数组组成。每当创建或删除快照时，池的快照序列号都会增加。要添加新快照，新快照序列号必须增加并添加到快照上下文中。

在 RADOS 集群中有两种管理这些快照上下文的方式

  1. 在 RADOS 集群内 这些称为池快照，并将快照上下文存储在 OSDMap 中。它们代表池中所有对象的快照。

  2. 在 RADOS 客户端内 这些称为自管理快照，并将跟踪快照上下文的责任推给客户端。对于每次写入，客户端都必须发送快照上下文。在 librados 中，这通过 rados_selfmanaged_snap_set_write_ctx() 来实现。这些更难管理，但仅限于特定对象，而不是应用于整个池。

int rados_ioctx_snap_create(rados_ioctx_t io, const char *snapname)

创建池范围的快照

参数:

  • io -- 要创建快照的池

  • snapname -- 快照的名称

返回:

成功时为 0，失败时为负错误码

int rados_ioctx_snap_remove(rados_ioctx_t io, const char *snapname)

删除池快照

参数:

  • io -- 要从中删除快照的池

  • snapname -- 要删除的快照名称

返回:

成功时为 0，失败时为负错误码

int rados_ioctx_snap_rollback(rados_ioctx_t io, const char *oid, const char *snapname)

将对象回滚到池快照

对象的内容将与拍摄快照时相同。

参数:

  • io -- 存储对象的池

  • oid -- 要回滚的对象名称

  • snapname -- 要回滚到的快照名称

返回:

成功时为 0，失败时为负错误码

int rados_rollback(rados_ioctx_t io, const char *oid, const char *snapname) __attribute__((deprecated))

警告

已弃用：请改用 rados_ioctx_snap_rollback()

void rados_ioctx_snap_set_read(rados_ioctx_t io, rados_snap_t snap)

设置从中执行读取的快照。

随后的读取将返回快照拍摄时的数据。

参数:

  • io -- 要更改的 io 上下文

  • snap -- 要设置的快照 ID，或 LIBRADOS_SNAP_HEAD 表示没有快照（即正常操作）

int rados_ioctx_selfmanaged_snap_create(rados_ioctx_t io, rados_snap_t *snapid)

为自管理快照分配 ID

获取一个唯一的 ID 放入快照上下文以创建快照。直到完成使用新快照上下文的写入操作，才会创建对象的克隆。

参数:

  • io -- 快照将存在的池

  • snapid -- 存储新分配的快照 ID 的位置

返回:

成功时为 0，失败时为负错误码

void rados_aio_ioctx_selfmanaged_snap_create(rados_ioctx_t io, rados_snap_t *snapid, rados_completion_t completion)
int rados_ioctx_selfmanaged_snap_remove(rados_ioctx_t io, rados_snap_t snapid)

删除自管理快照

这会增加快照序列号，这将导致快照被延迟删除。

参数:

  • io -- 快照将存在的池

  • snapid -- 存储新分配的快照 ID 的位置

返回:

成功时为 0，失败时为负错误码

void rados_aio_ioctx_selfmanaged_snap_remove(rados_ioctx_t io, rados_snap_t snapid, rados_completion_t completion)
int rados_ioctx_selfmanaged_snap_rollback(rados_ioctx_t io, const char *oid, rados_snap_t snapid)

将对象回滚到自管理快照

对象的内容将与拍摄快照时相同。

参数:

  • io -- 存储对象的池

  • oid -- 要回滚的对象名称

  • snapid -- 要回滚到的快照 ID

返回:

成功时为 0，失败时为负错误码

int rados_ioctx_selfmanaged_snap_set_write_ctx(rados_ioctx_t io, rados_snap_t seq, rados_snap_t *snaps, int num_snaps)

设置用于写入对象的快照上下文

这存储在 io 上下文中，并适用于所有未来的写入。

参数:

  • io -- 要更改的 io 上下文

  • seq -- 池的最新快照序列号

  • snaps -- 按 ID 降序排列的快照数组

  • num_snaps -- snaps 数组中有多少个快照

返回:

成功时为 0，失败时为负错误码

返回:

如果快照未按降序排列，则返回 -EINVAL

int rados_ioctx_snap_list(rados_ioctx_t io, rados_snap_t *snaps, int maxlen)

列出所有池快照的 ID

如果输出数组没有足够的空间来容纳所有快照，则返回 -ERANGE，调用者应使用更大的数组重试。

参数:

  • io -- 要从中读取的池

  • snaps -- 存储结果的位置

  • maxlen -- snaps 数组中可容纳的 rados_snap_t 数量

返回:

成功时返回快照数量，失败时返回负错误代码

返回:

如果 snaps 数组太短，则返回 -ERANGE

int rados_ioctx_snap_lookup(rados_ioctx_t io, const char *name, rados_snap_t *id)

获取池快照的 ID

参数:

  • io -- 要从中读取的池

  • name -- 要查找的快照名称

  • id -- 存储结果的位置

返回:

成功时为 0，失败时为负错误码

int rados_ioctx_snap_get_name(rados_ioctx_t io, rados_snap_t id, char *name, int maxlen)

获取池快照的名称

参数:

  • io -- 要从中读取的池

  • id -- 要查找的快照 ID

  • name -- 存储结果的位置

  • maxlen -- 名称数组的大小

返回:

成功时为 0，失败时为负错误码

返回:

如果名称数组太小，则返回 -ERANGE

int rados_ioctx_snap_get_stamp(rados_ioctx_t io, rados_snap_t id, time_t *t)

查找池快照发生的时间

参数:

  • io -- 拍摄快照的池

  • id -- 要查找的快照 ID

  • t -- 存储结果的位置

返回:

成功时为 0，失败时为负错误码

同步 I/O

写入根据它们所在的池的配置复制到多个 OSD。这些写入功能会阻塞，直到数据在它们正在写入的对象的所有副本的内存中 - 它们等同于执行相应的异步写入，然后调用 rados_ioctx_wait_for_complete()。为了获得更高的数据安全性，请使用异步功能和 rados_aio_wait_for_safe()。

uint64_t rados_get_last_version(rados_ioctx_t io)

返回最后读取或写入的对象的版本。

这会公开通过此 io 上下文读取或写入的最后一个对象的内部版本号

参数:

  • io -- 要检查的 io 上下文

返回:

最后读取或写入的对象版本

int rados_write(rados_ioctx_t io, const char *oid, const char *buf, size_t len, uint64_t off)

将 buf 中的 len 个字节写入 oid 对象，从偏移量 off 开始。len 的值必须 <= UINT_MAX/2。

注意

这将永远不会返回不等于 len 的正值。

参数:

  • io -- 发生写入的 io 上下文

  • oid -- 对象的名称

  • buf -- 要写入的数据

  • len -- 数据的长度（字节）

  • off -- 在对象中开始写入的字节偏移量

返回:

成功时为 0，失败时为负错误码

int rados_write_full(rados_ioctx_t io, const char *oid, const char *buf, size_t len)

将 buf 中的 len 个字节写入 oid 对象。len 的值必须 <= UINT_MAX/2。

对象将填充所提供的数据。如果对象存在，它会被原子地截断，然后写入。

参数:

  • io -- 发生写入的 io 上下文

  • oid -- 对象的名称

  • buf -- 要写入的数据

  • len -- 数据的长度（字节）

返回:

成功时为 0，失败时为负错误码

int rados_writesame(rados_ioctx_t io, const char *oid, const char *buf, size_t data_len, size_t write_len, uint64_t off)

将 buf 中相同的 data_len 字节多次写入 oid 对象。总共写入 write_len 个字节，这必须是 data_len 的倍数。write_len 和 data_len 的值必须 <= UINT_MAX/2。

参数:

  • io -- 发生写入的 io 上下文

  • oid -- 对象的名称

  • buf -- 要写入的数据

  • data_len -- 数据的长度（字节）

  • write_len -- 要写入的总字节数

  • off -- 在对象中开始写入的字节偏移量

返回:

成功时为 0，失败时为负错误码

int rados_append(rados_ioctx_t io, const char *oid, const char *buf, size_t len)

将 buf 中的 len 个字节附加到 oid 对象中。len 的值必须 <= UINT_MAX/2。

参数:

  • io -- 操作所在的上下文

  • oid -- 对象的名称

  • buf -- 要追加的数据

  • len -- buf 的长度（字节）

返回:

成功时为 0，失败时为负错误码

int rados_read(rados_ioctx_t io, const char *oid, char *buf, size_t len, uint64_t off)

从对象读取数据

如果通过 rados_ioctx_snap_set_read() 设置了快照，io 上下文将确定要从中读取的快照。

参数:

  • io -- 执行读取的上下文

  • oid -- 要读取的对象的名称

  • buf -- 存储结果的位置

  • len -- 要读取的字节数

  • off -- 在对象中开始读取的偏移量

返回:

成功时返回读取的字节数，失败时返回负错误代码

int rados_checksum(rados_ioctx_t io, const char *oid, rados_checksum_type_t type, const char *init_value, size_t init_value_len, size_t len, uint64_t off, size_t chunk_size, char *pchecksum, size_t checksum_len)

计算对象数据的校验和

io 上下文确定要校验的快照（如果通过 rados_ioctx_snap_set_read() 设置了）。init_value 和结果校验和的长度取决于校验和类型

XXHASH64: le64 XXHASH32: le32 CRC32C: le32

校验和结果的编码方式如下

le32 num_checksum_chunks { leXX checksum for chunk (where XX = appropriate size for the checksum type) } * num_checksum_chunks

参数:

  • io -- 执行校验和的上下文

  • oid -- 要校验的对象名称

  • type -- 要使用的校验和算法

  • init_value -- 算法的初始值

  • init_value_len -- 初始值的长度

  • len -- 要校验的字节数

  • off -- 在对象中开始校验和的偏移量

  • chunk_size -- 可选的长度对齐的校验和块大小

  • pchecksum -- 存储校验和结果的位置

  • checksum_len -- 结果可用的字节数

返回:

失败时返回负错误代码

int rados_remove(rados_ioctx_t io, const char *oid)

删除对象

注意

这不会删除对象的任何快照。

参数:

  • io -- 要从中删除对象的池

  • oid -- 要删除的对象名称

返回:

成功时为 0，失败时为负错误码

int rados_trunc(rados_ioctx_t io, const char *oid, uint64_t size)

调整对象大小

如果这会增大对象，则新区域会逻辑上填充零。如果这会缩小对象，则多余的数据将被删除。

参数:

  • io -- 执行截断的上下文

  • oid -- 对象的名称

  • size -- 对象的新大小（以字节为单位）

返回:

成功时为 0，失败时为负错误码

int rados_cmpext(rados_ioctx_t io, const char *o, const char *cmp_buf, size_t cmp_len, uint64_t off)

将磁盘上的对象范围与缓冲区进行比较

参数:

  • io -- 执行比较的上下文

  • o -- 对象的名称

  • cmp_buf -- 包含要与对象内容进行比较的字节的缓冲区

  • cmp_len -- 要比较的长度和 cmp_buf 的大小（字节）

  • off -- 在对象中开始比较的字节偏移量

返回:

成功时为 0，失败时为负错误码，不匹配时为 (-MAX_ERRNO - mismatch_off)

Xattrs

扩展属性作为扩展属性存储在代表 OSD 上对象的文件的文件系统上。因此，它们具有与底层文件系统相同的限制。在 ext4 上，这意味着存储在 xattrs 中的总数据不能超过 4KB。

int rados_getxattr(rados_ioctx_t io, const char *o, const char *name, char *buf, size_t len)

获取对象上的扩展属性值。

参数:

  • io -- 读取属性的上下文

  • o -- 对象的名称

  • name -- 要读取的扩展属性名称

  • buf -- 存储结果的位置

  • len -- buf 的大小（以字节为单位）

返回:

成功时返回 xattr 值的长度，失败时返回负错误代码

int rados_setxattr(rados_ioctx_t io, const char *o, const char *name, const char *buf, size_t len)

设置对象上的扩展属性。

参数:

  • io -- 设置 xattr 的上下文

  • o -- 对象的名称

  • name -- 要设置的扩展属性名称

  • buf -- 要存储在 xattr 中的内容

  • len -- buf 中的字节数

返回:

成功时为 0，失败时为负错误码

int rados_rmxattr(rados_ioctx_t io, const char *o, const char *name)

从对象中删除扩展属性。

参数:

  • io -- 删除 xattr 的上下文

  • o -- 对象的名称

  • name -- 要删除的 xattr 名称

返回:

成功时为 0，失败时为负错误码

int rados_getxattrs(rados_ioctx_t io, const char *oid, rados_xattrs_iter_t *iter)

开始迭代对象上的 xattrs。

参数:

  • io -- 列出 xattrs 的上下文

  • oid -- 对象的名称

  • iter -- 存储迭代器的位置

Post:

iter 是一个有效的迭代器

返回:

成功时为 0，失败时为负错误码

int rados_getxattrs_next(rados_xattrs_iter_t iter, const char **name, const char **val, size_t *len)

获取对象上的下一个 xattr

参数:

  • iter -- 要前进的迭代器

  • name -- 存储下一个 xattr 名称的位置

  • val -- 存储下一个 xattr 值的位置

  • len -- val 中的字节数

前提：

iter 是一个有效的迭代器

Post:

name 是下一个 xattr 的以 NULL 结尾的名称，val 包含 xattr 的值，其长度为 len。如果已到达列表末尾，则 name 和 val 为 NULL，len 为 0。

返回:

成功时为 0，失败时为负错误码

void rados_getxattrs_end(rados_xattrs_iter_t iter)

关闭 xattr 迭代器。

调用此函数后不应使用 iter。

参数:

  • iter -- 要关闭的迭代器

异步 Xattrs

扩展属性作为扩展属性存储在代表 OSD 上对象的文件的文件系统上。因此，它们具有与底层文件系统相同的限制。在 ext4 上，这意味着存储在 xattrs 中的总数据不能超过 4KB。

int rados_aio_getxattr(rados_ioctx_t io, const char *o, rados_completion_t completion, const char *name, char *buf, size_t len)

异步获取对象上的扩展属性值。

参数:

  • io -- 读取属性的上下文

  • o -- 对象的名称

  • completion -- getxattr 完成时要执行的操作

  • name -- 要读取的扩展属性名称

  • buf -- 存储结果的位置

  • len -- buf 的大小（以字节为单位）

返回:

成功时返回 xattr 值的长度，失败时返回负错误代码

int rados_aio_setxattr(rados_ioctx_t io, const char *o, rados_completion_t completion, const char *name, const char *buf, size_t len)

异步设置对象上的扩展属性。

参数:

  • io -- 设置 xattr 的上下文

  • o -- 对象的名称

  • completion -- setxattr 完成时要执行的操作

  • name -- 要设置的扩展属性名称

  • buf -- 要存储在 xattr 中的内容

  • len -- buf 中的字节数

返回:

成功时为 0，失败时为负错误码

int rados_aio_rmxattr(rados_ioctx_t io, const char *o, rados_completion_t completion, const char *name)

异步删除对象上的扩展属性。

参数:

  • io -- 删除 xattr 的上下文

  • o -- 对象的名称

  • completion -- rmxattr 完成时要执行的操作

  • name -- 要删除的 xattr 名称

返回:

成功时为 0，失败时为负错误码

int rados_aio_getxattrs(rados_ioctx_t io, const char *oid, rados_completion_t completion, rados_xattrs_iter_t *iter)

异步开始迭代对象上的 xattrs。

参数:

  • io -- 列出 xattrs 的上下文

  • oid -- 对象的名称

  • completion -- getxattrs 完成时要执行的操作

  • iter -- 存储迭代器的位置

Post:

iter 是一个有效的迭代器

返回:

成功时为 0，失败时为负错误码

提示

int rados_set_alloc_hint(rados_ioctx_t io, const char *o, uint64_t expected_object_size, uint64_t expected_write_size)

设置对象的分配提示

这是一个建议性操作，它总是会成功（就像它是在设置了 LIBRADOS_OP_FLAG_FAILOK 标志的情况下提交的一样），并且不保证在后端执行任何操作。

参数:

  • io -- 对象所在的池

  • o -- 对象的名称

  • expected_object_size -- 对象的预期大小（以字节为单位）

  • expected_write_size -- 写入对象的预期大小（以字节为单位）

返回:

成功时为 0，失败时为负错误码

int rados_set_alloc_hint2(rados_ioctx_t io, const char *o, uint64_t expected_object_size, uint64_t expected_write_size, uint32_t flags)

设置对象的分配提示

这是一个建议性操作，它总是会成功（就像它是在设置了 LIBRADOS_OP_FLAG_FAILOK 标志的情况下提交的一样），并且不保证在后端执行任何操作。

参数:

  • io -- 对象所在的池

  • o -- 对象的名称

  • expected_object_size -- 对象的预期大小（以字节为单位）

  • expected_write_size -- 写入对象的预期大小（以字节为单位）

  • flags -- 关于未来 IO 模式的提示

返回:

成功时为 0，失败时为负错误码

对象操作

单个 rados 操作可以原子地对一个对象执行多个操作。整个操作将成功或失败，并且不会显示部分结果。

操作可以是读取（可以返回数据）或写入（不能返回数据）。写入的效果会一次性应用并可见，因此设置 xattr 然后检查其值的操作不会看到更新后的值。

rados_write_op_t rados_create_write_op(void)

创建一个新的 rados_write_op_t 写入操作。这将存储所有要原子执行的操作。完成后必须调用 rados_release_write_op。

注意

写入操作的所有权会传递给执行操作的函数，因此同一 rados_write_op_t 实例在执行后不能再次使用。

返回:

成功时返回非 NULL，内存分配错误时返回 NULL。

void rados_release_write_op(rados_write_op_t write_op)

释放一个 rados_write_op_t，完成后必须调用。

参数:

  • write_op -- 要释放的操作，通过 rados_create_write_op 创建

void rados_write_op_set_flags(rados_write_op_t write_op, int flags)

为添加到此 write_op 的最后一个操作设置标志。至少已向 write_op 添加了一个操作。

参数:

  • write_op -- 要添加此操作的操作

  • flags -- 参见 librados.h 中以 LIBRADOS_OP_FLAG 开头的常量

void rados_write_op_assert_exists(rados_write_op_t write_op)

确保对象在写入之前存在

参数:

  • write_op -- 要添加此操作的操作

void rados_write_op_assert_version(rados_write_op_t write_op, uint64_t ver)

确保对象存在，并且在写入之前其内部版本号等于“ver”。“ver”应该是先前通过 rados_get_last_version() 获取的版本号。

  • 如果对象的版本大于断言的版本，则 rados_write_op_operate 将返回 -ERANGE 而不是执行操作。

  • 如果对象的版本小于断言的版本，则 rados_write_op_operate 将返回 -EOVERFLOW 而不是执行操作。

参数:

  • write_op -- 要添加此操作的操作

  • ver -- 对象版本号

void rados_write_op_cmpext(rados_write_op_t write_op, const char *cmp_buf, size_t cmp_len, uint64_t off, int *prval)

确保给定的对象范围（extent）满足比较条件。

参数:

  • write_op -- 要添加此操作的操作

  • cmp_buf -- 包含要与对象内容进行比较的字节的缓冲区

  • cmp_len -- 要比较的长度和 cmp_buf 的大小（字节）

  • off -- 在对象中开始比较的字节偏移量

  • prval -- 返回的比较结果，成功时为 0，失败时为负错误代码，不匹配时为 (-MAX_ERRNO - mismatch_off)

void rados_write_op_cmpxattr(rados_write_op_t write_op, const char *name, uint8_t comparison_operator, const char *value, size_t value_len)

确保给定的 xattr 满足比较条件。如果比较不满足，操作的返回代码将为 -ECANCELED

参数:

  • write_op -- 要添加此操作的操作

  • name -- 要查找的 xattr 名称

  • comparison_operator -- 目前未记录，请在 librados.h 中查找 LIBRADOS_CMPXATTR_OP_EQ

  • value -- 用于与实际 xattr 值进行比较的缓冲区

  • value_len -- 用于与实际 xattr 值进行比较的缓冲区长度

void rados_write_op_omap_cmp(rados_write_op_t write_op, const char *key, uint8_t comparison_operator, const char *val, size_t val_len, int *prval)

确保 omap 值满足比较条件，其中提供的值在右侧（即对于 OP_LT，比较为 actual_value < value）。

参数:

  • write_op -- 要添加此操作的操作

  • key -- 要比较的 omap 值

  • comparison_operator -- LIBRADOS_CMPXATTR_OP_EQ、LIBRADOS_CMPXATTR_OP_LT 或 LIBRADOS_CMPXATTR_OP_GT 之一

  • val -- 要比较的值

  • val_len -- 值的长度（以字节为单位）

  • prval -- 存储此操作返回值的地址

void rados_write_op_omap_cmp2(rados_write_op_t write_op, const char *key, uint8_t comparison_operator, const char *val, size_t key_len, size_t val_len, int *prval)

确保 omap 值满足比较条件，其中提供的值在右侧（即对于 OP_LT，比较为 actual_value < value）。

参数:

  • write_op -- 要添加此操作的操作

  • key -- 要比较的 omap 值

  • comparison_operator -- LIBRADOS_CMPXATTR_OP_EQ、LIBRADOS_CMPXATTR_OP_LT 或 LIBRADOS_CMPXATTR_OP_GT 之一

  • val -- 要比较的值

  • key_len -- 键的长度（以字节为单位）

  • val_len -- 值的长度（以字节为单位）

  • prval -- 存储此操作返回值的地址

void rados_write_op_setxattr(rados_write_op_t write_op, const char *name, const char *value, size_t value_len)

设置 xattr

参数:

  • write_op -- 要添加此操作的操作

  • name -- xattr 名称

  • value -- 用于设置 xattr 的缓冲区

  • value_len -- 用于设置 xattr 的缓冲区长度

void rados_write_op_rmxattr(rados_write_op_t write_op, const char *name)

删除 xattr

参数:

  • write_op -- 要添加此操作的操作

  • name -- 要删除的 xattr 名称

void rados_write_op_create(rados_write_op_t write_op, int exclusive, const char *category)

创建对象

参数:

  • write_op -- 要添加此操作的操作

  • exclusive -- 设置为 LIBRADOS_CREATE_EXCLUSIVE 或 LIBRADOS_CREATE_IDEMPOTENT，如果对象已存在则会出错。

  • category -- 类别字符串（已弃用，无效）

void rados_write_op_write(rados_write_op_t write_op, const char *buffer, size_t len, uint64_t offset)

写入偏移量

参数:

  • write_op -- 要添加此操作的操作

  • offset -- 写入的偏移量

  • buffer -- 要写入的字节

  • len -- 缓冲区长度

void rados_write_op_write_full(rados_write_op_t write_op, const char *buffer, size_t len)

写入整个对象，原子地替换它。

参数:

  • write_op -- 要添加此操作的操作

  • buffer -- 要写入的字节

  • len -- 缓冲区长度

void rados_write_op_writesame(rados_write_op_t write_op, const char *buffer, size_t data_len, size_t write_len, uint64_t offset)

多次写入同一缓冲区

参数:

  • write_op -- 要添加此操作的操作

  • buffer -- 要写入的字节

  • data_len -- 缓冲区长度

  • write_len -- 要写入的总字节数，是 data_len 的倍数

  • offset -- 写入的偏移量

void rados_write_op_append(rados_write_op_t write_op, const char *buffer, size_t len)

追加到对象末尾。

参数:

  • write_op -- 要添加此操作的操作

  • buffer -- 要写入的字节

  • len -- 缓冲区长度

void rados_write_op_remove(rados_write_op_t write_op)

删除对象

参数:

  • write_op -- 要添加此操作的操作

void rados_write_op_truncate(rados_write_op_t write_op, uint64_t offset)

截断对象

参数:

  • write_op -- 要添加此操作的操作

  • offset -- 截断的偏移量

void rados_write_op_zero(rados_write_op_t write_op, uint64_t offset, uint64_t len)

将对象的一部分归零

参数:

  • write_op -- 要添加此操作的操作

  • offset -- 归零的偏移量

  • len -- 归零的长度

void rados_write_op_exec(rados_write_op_t write_op, const char *cls, const char *method, const char *in_buf, size_t in_len, int *prval)

在对象上执行 OSD 类方法。有关一般描述，请参见 rados_exec()。

参数:

  • write_op -- 要添加此操作的操作

  • cls -- 类的名称

  • method -- 方法的名称

  • in_buf -- 查找输入的位置

  • in_len -- in_buf 的长度（字节）

  • prval -- 存储方法返回值的地址

void rados_write_op_omap_set(rados_write_op_t write_op, char const *const *keys, char const *const *vals, const size_t *lens, size_t num)

设置对象的键/值对

参数:

  • write_op -- 要添加此操作的操作

  • keys -- 表示要设置的键的以 null 结尾的字符数组指针数组

  • vals -- 要设置的值的指针数组

  • lens -- 对应每个值的长度数组

  • num -- 要设置的键/值对数量

void rados_write_op_omap_set2(rados_write_op_t write_op, char const *const *keys, char const *const *vals, const size_t *key_lens, const size_t *val_lens, size_t num)

设置对象的键/值对

参数:

  • write_op -- 要添加此操作的操作

  • keys -- 表示要设置的键的以 null 结尾的字符数组指针数组

  • vals -- 要设置的值的指针数组

  • key_lens -- 对应每个键的长度数组

  • val_lens -- 对应每个值的长度数组

  • num -- 要设置的键/值对数量

void rados_write_op_omap_rm_keys(rados_write_op_t write_op, char const *const *keys, size_t keys_len)

从对象中删除键/值对

参数:

  • write_op -- 要添加此操作的操作

  • keys -- 表示要删除的键的以 null 结尾的字符数组指针数组

  • keys_len -- 要删除的键/值对数量

void rados_write_op_omap_rm_keys2(rados_write_op_t write_op, char const *const *keys, const size_t *key_lens, size_t keys_len)

从对象中删除键/值对

参数:

  • write_op -- 要添加此操作的操作

  • keys -- 表示要删除的键的字符数组指针数组

  • key_lens -- 表示每个键长度的 size_t 值数组

  • keys_len -- 要删除的键/值对数量

void rados_write_op_omap_rm_range2(rados_write_op_t write_op, const char *key_begin, size_t key_begin_len, const char *key_end, size_t key_end_len)

删除对象中键在范围 [key_begin, key_end) 内的键/值对

参数:

  • write_op -- 要添加此操作的操作

  • key_begin -- 要删除的键范围的下限

  • key_begin_len -- key_begin 的长度

  • key_end -- 要删除的键范围的上限

  • key_end_len -- key_end 的长度

void rados_write_op_omap_clear(rados_write_op_t write_op)

从对象中删除所有键/值对

参数:

  • write_op -- 要添加此操作的操作

void rados_write_op_set_alloc_hint(rados_write_op_t write_op, uint64_t expected_object_size, uint64_t expected_write_size)

设置对象的分配提示

参数:

  • write_op -- 要添加此操作的操作

  • expected_object_size -- 对象的预期大小（以字节为单位）

  • expected_write_size -- 写入对象的预期大小（以字节为单位）

void rados_write_op_set_alloc_hint2(rados_write_op_t write_op, uint64_t expected_object_size, uint64_t expected_write_size, uint32_t flags)

设置对象的分配提示

参数:

  • write_op -- 要添加此操作的操作

  • expected_object_size -- 对象的预期大小（以字节为单位）

  • expected_write_size -- 写入对象的预期大小（以字节为单位）

  • flags -- 关于未来 IO 模式的提示

int rados_write_op_operate(rados_write_op_t write_op, rados_ioctx_t io, const char *oid, time_t *mtime, int flags)

同步执行写入操作

参数:

  • write_op -- 要执行的操作

  • io -- 对象所在的 ioctx

  • oid -- 对象 ID

  • mtime -- 要设置的修改时间，NULL 表示当前时间

  • flags -- 应用于整个操作的标志 (LIBRADOS_OPERATION_*)

int rados_write_op_operate2(rados_write_op_t write_op, rados_ioctx_t io, const char *oid, struct timespec *mtime, int flags)

同步执行写入操作

参数:

  • write_op -- 要执行的操作

  • io -- 对象所在的 ioctx

  • oid -- 对象 ID

  • mtime -- 要设置的修改时间，NULL 表示当前时间

  • flags -- 应用于整个操作的标志 (LIBRADOS_OPERATION_*)

int rados_aio_write_op_operate(rados_write_op_t write_op, rados_ioctx_t io, rados_completion_t completion, const char *oid, time_t *mtime, int flags)

异步执行写入操作

参数:

  • write_op -- 要执行的操作

  • io -- 对象所在的 ioctx

  • completion -- 尝试操作完成时要执行的操作

  • oid -- 对象 ID

  • mtime -- 要设置的修改时间，NULL 表示当前时间

  • flags -- 应用于整个操作的标志 (LIBRADOS_OPERATION_*)

int rados_aio_write_op_operate2(rados_write_op_t write_op, rados_ioctx_t io, rados_completion_t completion, const char *oid, struct timespec *mtime, int flags)

异步执行写入操作

参数:

  • write_op -- 要执行的操作

  • io -- 对象所在的 ioctx

  • completion -- 尝试操作完成时要执行的操作

  • oid -- 对象 ID

  • mtime -- 要设置的修改时间，NULL 表示当前时间

  • flags -- 应用于整个操作的标志 (LIBRADOS_OPERATION_*)

rados_read_op_t rados_create_read_op(void)

创建一个新的 rados_read_op_t 读取操作。这将存储所有要原子执行的操作。完成后必须调用 rados_release_read_op（在完成之后，或者决定不发送它）。

注意

读取操作的所有权会传递给执行操作的函数，因此同一 rados_read_op_t 实例在执行后不能再次使用。

返回:

成功时返回非 NULL，内存分配错误时返回 NULL。

void rados_release_read_op(rados_read_op_t read_op)

释放一个 rados_read_op_t，完成后必须调用。

参数:

  • read_op -- 要释放的操作，通过 rados_create_read_op 创建

void rados_read_op_set_flags(rados_read_op_t read_op, int flags)

为添加到此 read_op 的最后一个操作设置标志。至少已向 read_op 添加了一个操作。

参数:

  • read_op -- 要添加此操作的操作

  • flags -- 参见 librados.h 中以 LIBRADOS_OP_FLAG 开头的常量

void rados_read_op_assert_exists(rados_read_op_t read_op)

确保对象在读取之前存在

参数:

  • read_op -- 要添加此操作的操作

void rados_read_op_assert_version(rados_read_op_t read_op, uint64_t ver)

确保对象存在，并且在读取之前其内部版本号等于“ver”。“ver”应该是先前通过 rados_get_last_version() 获取的版本号。

  • 如果对象的版本大于断言的版本，则 rados_read_op_operate 将返回 -ERANGE 而不是执行操作。

  • 如果对象的版本小于断言的版本，则 rados_read_op_operate 将返回 -EOVERFLOW 而不是执行操作。

参数:

  • read_op -- 要添加此操作的操作

  • ver -- 对象版本号

void rados_read_op_cmpext(rados_read_op_t read_op, const char *cmp_buf, size_t cmp_len, uint64_t off, int *prval)

确保给定的对象范围（extent）满足比较条件。

参数:

  • read_op -- 要添加此操作的操作

  • cmp_buf -- 包含要与对象内容进行比较的字节的缓冲区

  • cmp_len -- 要比较的长度和 cmp_buf 的大小（字节）

  • off -- 在对象中开始比较的字节偏移量

  • prval -- 返回的比较结果，成功时为 0，失败时为负错误代码，不匹配时为 (-MAX_ERRNO - mismatch_off)

void rados_read_op_cmpxattr(rados_read_op_t read_op, const char *name, uint8_t comparison_operator, const char *value, size_t value_len)

确保 xattr 满足比较条件。如果比较不满足，操作的返回代码将为 -ECANCELED

参数:

  • read_op -- 要添加此操作的操作

  • name -- 要查找的 xattr 名称

  • comparison_operator -- 目前未记录，请在 librados.h 中查找 LIBRADOS_CMPXATTR_OP_EQ

  • value -- 用于与实际 xattr 值进行比较的缓冲区

  • value_len -- 用于与实际 xattr 值进行比较的缓冲区长度

void rados_read_op_getxattrs(rados_read_op_t read_op, rados_xattrs_iter_t *iter, int *prval)

开始迭代对象上的 xattrs。

参数:

  • read_op -- 要添加此操作的操作

  • iter -- 存储迭代器的位置

  • prval -- 存储此操作返回值的地址

void rados_read_op_omap_cmp(rados_read_op_t read_op, const char *key, uint8_t comparison_operator, const char *val, size_t val_len, int *prval)

确保 omap 值满足比较条件，其中提供的值在右侧（即对于 OP_LT，比较为 actual_value < value）。

参数:

  • read_op -- 要添加此操作的操作

  • key -- 要比较的 omap 值

  • comparison_operator -- LIBRADOS_CMPXATTR_OP_EQ、LIBRADOS_CMPXATTR_OP_LT 或 LIBRADOS_CMPXATTR_OP_GT 之一

  • val -- 要比较的值

  • val_len -- 值的长度（以字节为单位）

  • prval -- 存储此操作返回值的地址

void rados_read_op_omap_cmp2(rados_read_op_t read_op, const char *key, uint8_t comparison_operator, const char *val, size_t key_len, size_t val_len, int *prval)

确保 omap 值满足比较条件，其中提供的值在右侧（即对于 OP_LT，比较为 actual_value < value）。

参数:

  • read_op -- 要添加此操作的操作

  • key -- 要比较的 omap 值

  • comparison_operator -- LIBRADOS_CMPXATTR_OP_EQ、LIBRADOS_CMPXATTR_OP_LT 或 LIBRADOS_CMPXATTR_OP_GT 之一

  • val -- 要比较的值

  • key_len -- 键的长度（以字节为单位）

  • val_len -- 值的长度（以字节为单位）

  • prval -- 存储此操作返回值的地址

void rados_read_op_stat(rados_read_op_t read_op, uint64_t *psize, time_t *pmtime, int *prval)

获取对象大小和修改时间

参数:

  • read_op -- 要添加此操作的操作

  • psize -- 存储对象大小的位置

  • pmtime -- 存储修改时间的位置

  • prval -- 存储此操作返回值的地址

void rados_read_op_stat2(rados_read_op_t read_op, uint64_t *psize, struct timespec *pmtime, int *prval)
void rados_read_op_read(rados_read_op_t read_op, uint64_t offset, size_t len, char *buffer, size_t *bytes_read, int *prval)

从偏移量读取字节到缓冲区。

如果成功，prlen 将填充读取的字节数。只有当读取达到对象末尾时才会发生短读取。

参数:

  • read_op -- 要添加此操作的操作

  • offset -- 读取的偏移量

  • len -- 缓冲区长度

  • buffer -- 放置数据的位置

  • bytes_read -- 存储此操作读取的字节数的位置

  • prval -- 存储此操作返回值的地址

void rados_read_op_checksum(rados_read_op_t read_op, rados_checksum_type_t type, const char *init_value, size_t init_value_len, uint64_t offset, size_t len, size_t chunk_size, char *pchecksum, size_t checksum_len, int *prval)

计算对象数据的校验和

参数:

  • read_op -- 要添加此操作的操作

  • type -- 要使用的校验和算法

  • init_value -- 算法的初始值

  • init_value_len -- 初始值的长度

  • offset -- 在对象中开始校验和计算的偏移量

  • len -- 要校验的字节数

  • chunk_size -- 可选的长度对齐的校验和块大小

  • pchecksum -- 存储此操作校验和结果的位置

  • checksum_len -- 结果可用的字节数

  • prval -- 存储此操作返回值的地址

void rados_read_op_exec(rados_read_op_t read_op, const char *cls, const char *method, const char *in_buf, size_t in_len, char **out_buf, size_t *out_len, int *prval)

在对象上执行 OSD 类方法。有关一般描述，请参见 rados_exec()。

输出缓冲区在堆上分配；调用者应使用 rados_buffer_free() 释放该内存。缓冲区和长度指针都可以为 NULL，在这种情况下它们不会被填充。

参数:

  • read_op -- 要添加此操作的操作

  • cls -- 类的名称

  • method -- 方法的名称

  • in_buf -- 查找输入的位置

  • in_len -- in_buf 的长度（字节）

  • out_buf -- 存储 librados 分配的输出缓冲区的位置

  • out_len -- out_buf 的长度（以字节为单位）

  • prval -- 存储方法返回值的地址

void rados_read_op_exec_user_buf(rados_read_op_t read_op, const char *cls, const char *method, const char *in_buf, size_t in_len, char *out_buf, size_t out_len, size_t *used_len, int *prval)

在对象上执行 OSD 类方法。有关一般描述，请参见 rados_exec()。

如果输出缓冲区太小，prval 将设置为 -ERANGE，used_len 将为 0。

参数:

  • read_op -- 要添加此操作的操作

  • cls -- 类的名称

  • method -- 方法的名称

  • in_buf -- 查找输入的位置

  • in_len -- in_buf 的长度（字节）

  • out_buf -- 用户提供的用于读取的缓冲区

  • out_len -- out_buf 的长度（以字节为单位）

  • used_len -- 存储读取到 out_buf 的字节数的位置

  • prval -- 存储方法返回值的地址

void rados_read_op_omap_get_vals(rados_read_op_t read_op, const char *start_after, const char *filter_prefix, uint64_t max_return, rados_omap_iter_t *iter, int *prval) __attribute__((deprecated))

开始迭代对象上的键/值对。

它们将按键排序返回。

参数:

  • read_op -- 要添加此操作的操作

  • start_after -- 列出 start_after 之后的键

  • filter_prefix -- 仅列出以 filter_prefix 开头的键

  • max_return -- 最多列出 max_return 个键/值对

  • iter -- 存储迭代器的位置

  • prval -- 存储此操作返回值的地址

void rados_read_op_omap_get_vals2(rados_read_op_t read_op, const char *start_after, const char *filter_prefix, uint64_t max_return, rados_omap_iter_t *iter, unsigned char *pmore, int *prval)

开始迭代对象上的键/值对。

它们将按键排序返回。

参数:

  • read_op -- 要添加此操作的操作

  • start_after -- 列出 start_after 之后的键

  • filter_prefix -- 仅列出以 filter_prefix 开头的键

  • max_return -- 最多列出 max_return 个键/值对

  • iter -- 存储迭代器的位置

  • pmore -- 指示是否还有更多键要获取的标志

  • prval -- 存储此操作返回值的地址

void rados_read_op_omap_get_keys(rados_read_op_t read_op, const char *start_after, uint64_t max_return, rados_omap_iter_t *iter, int *prval) __attribute__((deprecated))

开始迭代对象上的键。

它们将按键排序返回，如果指定，迭代器将为所有值填充 NULL。

参数:

  • read_op -- 要添加此操作的操作

  • start_after -- 列出 start_after 之后的键

  • max_return -- 最多列出 max_return 个键

  • iter -- 存储迭代器的位置

  • prval -- 存储此操作返回值的地址

void rados_read_op_omap_get_keys2(rados_read_op_t read_op, const char *start_after, uint64_t max_return, rados_omap_iter_t *iter, unsigned char *pmore, int *prval)

开始迭代对象上的键。

它们将按键排序返回，如果指定，迭代器将为所有值填充 NULL。

参数:

  • read_op -- 要添加此操作的操作

  • start_after -- 列出 start_after 之后的键

  • max_return -- 最多列出 max_return 个键

  • iter -- 存储迭代器的位置

  • pmore -- 指示是否还有更多键要获取的标志

  • prval -- 存储此操作返回值的地址

void rados_read_op_omap_get_vals_by_keys(rados_read_op_t read_op, char const *const *keys, size_t keys_len, rados_omap_iter_t *iter, int *prval)

开始迭代特定的键/值对

它们将按键排序返回。

参数:

  • read_op -- 要添加此操作的操作

  • keys -- 要获取的以 null 结尾的键指针数组

  • keys_len -- keys 中的字符串数量

  • iter -- 存储迭代器的位置

  • prval -- 存储此操作返回值的地址

void rados_read_op_omap_get_vals_by_keys2(rados_read_op_t read_op, char const *const *keys, size_t num_keys, const size_t *key_lens, rados_omap_iter_t *iter, int *prval)

开始迭代特定的键/值对

它们将按键排序返回。

参数:

  • read_op -- 要添加此操作的操作

  • keys -- 要获取的键指针数组

  • num_keys -- 键中字符串的数量

  • key_lens -- 描述每个键长度（以字节为单位）的 size_t 数组

  • iter -- 存储迭代器的位置

  • prval -- 存储此操作返回值的地址

int rados_read_op_operate(rados_read_op_t read_op, rados_ioctx_t io, const char *oid, int flags)

同步执行读取操作

参数:

  • read_op -- 要执行的操作

  • io -- 对象所在的 ioctx

  • oid -- 对象 ID

  • flags -- 应用于整个操作的标志 (LIBRADOS_OPERATION_*)

int rados_aio_read_op_operate(rados_read_op_t read_op, rados_ioctx_t io, rados_completion_t completion, const char *oid, int flags)

异步执行读取操作

参数:

  • read_op -- 要执行的操作

  • io -- 对象所在的 ioctx

  • completion -- 尝试操作完成时要执行的操作

  • oid -- 对象 ID

  • flags -- 应用于整个操作的标志 (LIBRADOS_OPERATION_*)

定义

CEPH_OSD_TMAP_HDR
CEPH_OSD_TMAP_SET
CEPH_OSD_TMAP_CREATE
CEPH_OSD_TMAP_RM
LIBRADOS_VER_MAJOR
LIBRADOS_VER_MINOR
LIBRADOS_VER_EXTRA
LIBRADOS_VERSION(maj, min, extra)
LIBRADOS_VERSION_CODE
LIBRADOS_SUPPORTS_WATCH
LIBRADOS_SUPPORTS_SERVICES
LIBRADOS_SUPPORTS_GETADDRS
LIBRADOS_SUPPORTS_APP_METADATA
LIBRADOS_LOCK_FLAG_RENEW
LIBRADOS_LOCK_FLAG_MAY_RENEW
LIBRADOS_LOCK_FLAG_MUST_RENEW
LIBRADOS_CREATE_EXCLUSIVE
LIBRADOS_CREATE_IDEMPOTENT
CEPH_RADOS_API
LIBRADOS_SNAP_HEAD
LIBRADOS_SNAP_DIR
VOIDPTR_RADOS_T

类型定义

typedef void *rados_t

用于与 RADOS 集群交互的句柄。它封装了所有 RADOS 客户端配置，包括用户名、身份验证密钥、日志记录和调试。与不同集群或与同一集群使用不同用户进行通信需要不同的集群句柄。

typedef void *rados_config_t

rados_t 集群实例的 ceph 配置上下文句柄。这可用于在 librados 实例之间共享配置上下文/状态（例如，日志配置）。

警告

配置上下文没有独立的引用计数。因此，从给定 rados_t 检索到的 rados_config_t 句柄仅在 rados_t 有效时才有效。

typedef void *rados_ioctx_t

IO 上下文封装了对其执行的所有 I/O 操作的一些设置

  • 池 - 在创建 io 上下文时设置（请参阅 rados_ioctx_create()）

  • 写入的快照上下文（请参阅 rados_ioctx_selfmanaged_snap_set_write_ctx()）

  • 要从中读取的快照 ID（请参阅 rados_ioctx_snap_set_read()）

  • 所有单对象操作的对象定位符（请参阅 rados_ioctx_locator_set_key()）

  • 所有单对象操作的命名空间（请参阅 rados_ioctx_set_namespace()）。在 rados_nobjects_list_open() 将列出所有命名空间中的所有对象之前，将其设置为 LIBRADOS_ALL_NSPACES。

警告

更改这些设置中的任何一个都不是线程安全的 - librados 用户必须自行同步这些更改，或者为每个线程使用单独的 io 上下文

typedef void *rados_list_ctx_t

用于列出池中对象的迭代器。与 rados_nobjects_list_open()、rados_nobjects_list_next()、rados_nobjects_list_next2() 和 rados_nobjects_list_close() 一起使用。

typedef void *rados_object_list_cursor

与 rados_enumerate_objects 和相关方法一起使用的游标。

typedef uint64_t rados_snap_t

快照的 ID。

typedef void *rados_xattrs_iter_t

用于列出对象上的扩展属性的迭代器。与 rados_getxattrs()、rados_getxattrs_next() 和 rados_getxattrs_end() 一起使用。

typedef void *rados_omap_iter_t

用于列出对象上的 omap 键/值对的迭代器。与 rados_read_op_omap_get_keys()、rados_read_op_omap_get_vals()、rados_read_op_omap_get_vals_by_keys()、rados_omap_get_next() 和 rados_omap_get_end() 一起使用。

typedef void *rados_write_op_t

对象写入操作存储了一些可以原子执行的操作。用法请参见

  • 创建和删除：rados_create_write_op() rados_release_write_op()

  • 扩展属性操作：rados_write_op_cmpxattr() rados_write_op_cmpxattr(), rados_write_op_setxattr(), rados_write_op_rmxattr()

  • 对象映射键/值对：rados_write_op_omap_set(), rados_write_op_omap_rm_keys(), rados_write_op_omap_clear(), rados_write_op_omap_cmp()

  • 对象属性：rados_write_op_assert_exists(), rados_write_op_assert_version()

  • 创建对象：rados_write_op_create()

  • 对象上的 IO：rados_write_op_append(), rados_write_op_write(), rados_write_op_zero rados_write_op_write_full(), rados_write_op_writesame(), rados_write_op_remove, rados_write_op_truncate(), rados_write_op_zero(), rados_write_op_cmpext()

  • 提示：rados_write_op_set_alloc_hint()

  • 执行操作：rados_write_op_operate(), rados_aio_write_op_operate()

typedef void *rados_read_op_t

对象读取操作存储了一些可以原子执行的操作。用法请参见

  • 创建和删除：rados_create_read_op() rados_release_read_op()

  • 扩展属性操作：rados_read_op_cmpxattr(), rados_read_op_getxattr(), rados_read_op_getxattrs()

  • 对象映射键/值对：rados_read_op_omap_get_vals(), rados_read_op_omap_get_keys(), rados_read_op_omap_get_vals_by_keys(), rados_read_op_omap_cmp()

  • 对象属性：rados_read_op_stat(), rados_read_op_assert_exists(), rados_read_op_assert_version()

  • 对象上的 IO：rados_read_op_read(), rados_read_op_checksum(), rados_read_op_cmpext()

  • 自定义操作：rados_read_op_exec(), rados_read_op_exec_user_buf()

  • 请求属性：rados_read_op_set_flags()

  • 执行操作：rados_read_op_operate(), rados_aio_read_op_operate()

typedef void *rados_completion_t

表示异步操作的状态 - 操作完成后包含返回值，可用于阻塞直到操作完成或安全。

枚举

enum [anonymous]

值

enumerator LIBRADOS_OP_FLAG_EXCL
enumerator LIBRADOS_OP_FLAG_FAILOK
enumerator LIBRADOS_OP_FLAG_FADVISE_RANDOM
enumerator LIBRADOS_OP_FLAG_FADVISE_SEQUENTIAL
enumerator LIBRADOS_OP_FLAG_FADVISE_WILLNEED
enumerator LIBRADOS_OP_FLAG_FADVISE_DONTNEED
enumerator LIBRADOS_OP_FLAG_FADVISE_NOCACHE
enumerator LIBRADOS_OP_FLAG_FADVISE_FUA
enum rados_checksum_type_t

值

enumerator LIBRADOS_CHECKSUM_TYPE_XXHASH32
enumerator LIBRADOS_CHECKSUM_TYPE_XXHASH64
enumerator LIBRADOS_CHECKSUM_TYPE_CRC32C

函数

void rados_version(int *major, int *minor, int *extra)

获取 librados 的版本。

版本号为 major.minor.extra。请注意，这与 Ceph 版本号无关。

待办事项：定义版本语义，即

  • 增加主要版本用于向后不兼容的更改

  • 增加次要版本用于向后兼容的更改

  • 增加额外版本用于错误修复

参数:

  • major -- 存储主要版本号的位置

  • minor -- 存储次要版本号的位置

  • extra -- 存储额外版本号的位置

int rados_cluster_stat(rados_t cluster, struct rados_cluster_stat_t *result)

读取有关集群的使用信息

这会告诉你总空间、已用空间、可用空间和对象数。这些不是在写入数据时立即更新的，它们是最终一致的。

参数:

  • cluster -- 要查询的集群

  • result -- 存储结果的位置

返回:

成功时为 0，失败时为负错误码

int rados_cluster_fsid(rados_t cluster, char *buf, size_t len)

获取集群的 fsid 作为十六进制字符串。

fsid 是整个 Ceph 集群的唯一 ID。

参数:

  • cluster -- 获取 fsid 的位置

  • buf -- 写入 fsid 的位置

  • len -- buf 的大小（以字节为单位）（应为 37）

返回:

成功时返回字符串长度，失败时返回负错误代码

返回:

-ERANGE 如果缓冲区太短无法容纳 fsid

int rados_wait_for_latest_osdmap(rados_t cluster)

获取/等待最新的 osdmap

参数:

  • cluster -- 要关闭的集群

返回:

成功时为 0，失败时为负错误码

int rados_omap_get_next(rados_omap_iter_t iter, char **key, char **val, size_t *len)

获取对象上的下一个 omap 键/值对

参数:

  • iter -- 要前进的迭代器

  • key -- 存储下一个 omap 条目键的位置

  • val -- 存储下一个 omap 条目值的位置

  • len -- 存储 val 中字节数的位置

前提：

iter 是一个有效的迭代器

Post:

key 和 val 是下一个键/值对。key 以 null 终止，val 的长度为 len。如果已到达列表末尾，则 key 和 val 为 NULL，len 为 0。在对 iter 调用 rados_omap_get_end() 之后，key 和 val 将不可访问，因此如果之后需要它们，应将其复制。

返回:

成功时为 0，失败时为负错误码

int rados_omap_get_next2(rados_omap_iter_t iter, char **key, char **val, size_t *key_len, size_t *val_len)

获取对象上的下一个 omap 键/值对。请注意，混合调用 rados_omap_get_next 和 rados_omap_get_next2 是完全安全的。

参数:

  • iter -- 要前进的迭代器

  • key -- 存储下一个 omap 条目键的位置

  • val -- 存储下一个 omap 条目值的位置

  • key_len -- 存储 key 中字节数的位置

  • val_len -- 存储 val 中字节数的位置

前提：

iter 是一个有效的迭代器

Post:

key 和 val 是下一个键/值对。key 的长度为 keylen，val 的长度为 vallen。如果已到达列表末尾，则 key 和 val 为 NULL，keylen 和 vallen 为 0。在对 iter 调用 rados_omap_get_end() 之后，key 和 val 将不可访问，因此如果之后需要它们，应将其复制。

返回:

成功时为 0，失败时为负错误码

unsigned int rados_omap_iter_size(rados_omap_iter_t iter)

返回迭代器中的元素数

参数:

  • iter -- 要返回大小的迭代器

void rados_omap_get_end(rados_omap_iter_t iter)

关闭 omap 迭代器。

调用此函数后不应使用 iter。

参数:

  • iter -- 要关闭的迭代器

int rados_stat(rados_ioctx_t io, const char *o, uint64_t *psize, time_t *pmtime)

从 OSD 获取对象大小和最近更新时间。

参数:

  • io -- ioctx

  • o -- 对象名称

  • psize -- 存储对象大小的位置

  • pmtime -- 存储修改时间的位置

返回:

成功时为 0，失败时为负错误码

int rados_stat2(rados_ioctx_t io, const char *o, uint64_t *psize, struct timespec *pmtime)
int rados_exec(rados_ioctx_t io, const char *oid, const char *cls, const char *method, const char *in_buf, size_t in_len, char *buf, size_t out_len)

在对象上执行 OSD 类方法

OSD 有一种插件机制，用于以原子方式对对象执行复杂操作。这些插件称为类。此函数允许 librados 用户调用自定义方法。输入和输出格式由类定义。ceph.git 中的类可以在 src/cls 子目录中找到。

参数:

  • io -- 调用方法的上下文

  • oid -- 要调用方法的对象

  • cls -- 类的名称

  • method -- 方法的名称

  • in_buf -- 查找输入的位置

  • in_len -- in_buf 的长度（字节）

  • buf -- 存储输出的位置

  • out_len -- buf 的长度（字节）

返回:

输出的长度，如果 out_buf 没有足够的空间来存储它，则为 -ERANGE（对于返回数据的方法）。对于不返回数据的方法，返回值是方法特定的。

int rados_cache_pin(rados_ioctx_t io, const char *o)

将对象固定在缓存层中

当对象固定在缓存层中时，它会保留在缓存层中，并且不会被清除。

参数:

  • io -- 对象所在的池

  • o -- 对象 ID

返回:

成功时为 0，失败时为负错误码

int rados_cache_unpin(rados_ioctx_t io, const char *o)

取消固定缓存层中的对象

在缓存层中取消固定对象后，它可以被清除

参数:

  • io -- 对象所在的池

  • o -- 对象 ID

返回:

成功时为 0，失败时为负错误码

int rados_lock_exclusive(rados_ioctx_t io, const char *oid, const char *name, const char *cookie, const char *desc, struct timeval *duration, uint8_t flags)

对对象进行排他锁定。

参数:

  • io -- 操作所在的上下文

  • oid -- 对象的名称

  • name -- 锁的名称

  • cookie -- 锁的此实例的用户定义标识符

  • desc -- 用户定义的锁描述

  • duration -- 锁的持续时间。设置为 NULL 表示无限持续时间。

  • flags -- 锁标志

返回:

成功时为 0，失败时为负错误码

返回:

-EBUSY 如果锁已被另一个（客户端、cookie）对持有

返回:

-EEXIST 如果锁已被同一（客户端、cookie）对持有

int rados_lock_shared(rados_ioctx_t io, const char *o, const char *name, const char *cookie, const char *tag, const char *desc, struct timeval *duration, uint8_t flags)

对对象进行共享锁定。

参数:

  • io -- 操作所在的上下文

  • o -- 对象的名称

  • name -- 锁的名称

  • cookie -- 锁的此实例的用户定义标识符

  • tag -- 锁的标签

  • desc -- 用户定义的锁描述

  • duration -- 锁的持续时间。设置为 NULL 表示无限持续时间。

  • flags -- 锁标志

返回:

成功时为 0，失败时为负错误码

返回:

-EBUSY 如果锁已被另一个（客户端、cookie）对持有

返回:

-EEXIST 如果锁已被同一（客户端、cookie）对持有

int rados_unlock(rados_ioctx_t io, const char *o, const char *name, const char *cookie)

释放对象上的共享或排他锁。

参数:

  • io -- 操作所在的上下文

  • o -- 对象的名称

  • name -- 锁的名称

  • cookie -- 锁实例的用户定义标识符

返回:

成功时为 0，失败时为负错误码

返回:

-ENOENT 如果锁未被指定的（客户端、cookie）对持有

int rados_aio_unlock(rados_ioctx_t io, const char *o, const char *name, const char *cookie, rados_completion_t completion)

异步释放对象上的共享或排他锁。

参数:

  • io -- 操作所在的上下文

  • o -- 对象的名称

  • name -- 锁的名称

  • cookie -- 锁实例的用户定义标识符

  • completion -- 尝试操作完成时要执行的操作

返回:

成功时为 0，失败时为负错误码

ssize_t rados_list_lockers(rados_ioctx_t io, const char *o, const char *name, int *exclusive, char *tag, size_t *tag_len, char *clients, size_t *clients_len, char *cookies, size_t *cookies_len, char *addrs, size_t *addrs_len)

列出已锁定命名对象锁定的客户端以及有关该锁定的信息。

每个缓冲区所需的字节数放在相应的 size out 参数中。如果提供的任何缓冲区太短，则在填充这些大小后返回 -ERANGE。

参数:

  • io -- 操作所在的上下文

  • o -- 对象的名称

  • name -- 锁的名称

  • exclusive -- 存储锁是排他（1）还是共享（0）的位置

  • tag -- 存储与对象锁关联的标签的位置

  • tag_len -- 标签缓冲区中的字节数

  • clients -- 存储锁定客户端的缓冲区，用 '\0' 分隔

  • clients_len -- 客户端缓冲区中的字节数

  • cookies -- 存储锁定 cookie 的缓冲区，用 '\0' 分隔

  • cookies_len -- cookie 缓冲区中的字节数

  • addrs -- 存储锁定地址的缓冲区，用 '\0' 分隔

  • addrs_len -- 客户端缓冲区中的字节数

返回:

成功时返回锁定者数量，失败时返回负错误代码

返回:

-ERANGE 如果任何缓冲区太短

int rados_break_lock(rados_ioctx_t io, const char *o, const char *name, const char *client, const char *cookie)

释放由指定客户端持有的对象上的共享或排他锁。

参数:

  • io -- 操作所在的上下文

  • o -- 对象的名称

  • name -- 锁的名称

  • client -- 当前持有锁的客户端

  • cookie -- 锁实例的用户定义标识符

返回:

成功时为 0，失败时为负错误码

返回:

-ENOENT 如果锁未被指定的（客户端、cookie）对持有

返回:

-EINVAL 如果客户端无法解析

int rados_blocklist_add(rados_t cluster, char *client_address, uint32_t expire_seconds)

将指定的客户端列入 OSD 的块列表

参数:

  • cluster -- 集群句柄

  • client_address -- 客户端地址

  • expire_seconds -- 列入块列表的秒数（0 表示默认值）

返回:

成功时为 0，失败时为负错误码

int rados_blacklist_add(rados_t cluster, char *client_address, uint32_t expire_seconds) __attribute__((deprecated))
int rados_getaddrs(rados_t cluster, char **addrs)

获取 RADOS 会话的地址，适用于列入块列表。

参数:

  • cluster -- 集群句柄

  • addrs -- 输出字符串。

返回:

成功时为 0，失败时为负错误码

void rados_set_osdmap_full_try(rados_ioctx_t io) __attribute__((deprecated))
void rados_unset_osdmap_full_try(rados_ioctx_t io) __attribute__((deprecated))
void rados_set_pool_full_try(rados_ioctx_t io)
void rados_unset_pool_full_try(rados_ioctx_t io)
int rados_application_enable(rados_ioctx_t io, const char *app_name, int force)

在池上启用应用程序

参数:

  • io -- 池 ioctx

  • app_name -- 应用程序名称

  • force -- 0 如果每个池只有一个应用程序

返回:

成功时为 0，失败时为负错误码

int rados_application_list(rados_ioctx_t io, char *values, size_t *values_len)

列出所有已启用的应用程序

如果提供的缓冲区太短，则填充所需的长度并返回 -ERANGE。否则，缓冲区中将填充应用程序名称，每个名称后跟一个 '\0'。

参数:

  • io -- 池 ioctx

  • values -- 存储应用程序名称的缓冲区

  • values_len -- values 缓冲区中的字节数

返回:

成功时为 0，失败时为负错误码

返回:

-ERANGE 如果任一缓冲区太短

int rados_application_metadata_get(rados_ioctx_t io, const char *app_name, const char *key, char *value, size_t *value_len)

从池中获取应用程序元数据值

参数:

  • io -- 池 ioctx

  • app_name -- 应用程序名称

  • key -- 元数据键

  • value -- 结果缓冲区

  • value_len -- value 的最大长度

返回:

成功时为 0，失败时为负错误码

int rados_application_metadata_set(rados_ioctx_t io, const char *app_name, const char *key, const char *value)

在池上设置应用程序元数据

参数:

  • io -- 池 ioctx

  • app_name -- 应用程序名称

  • key -- 元数据键

  • value -- 元数据键

返回:

成功时为 0，失败时为负错误码

int rados_application_metadata_remove(rados_ioctx_t io, const char *app_name, const char *key)

从池中删除应用程序元数据

参数:

  • io -- 池 ioctx

  • app_name -- 应用程序名称

  • key -- 元数据键

返回:

成功时为 0，失败时为负错误码

int rados_application_metadata_list(rados_ioctx_t io, const char *app_name, char *keys, size_t *key_len, char *values, size_t *vals_len)

列出与应用程序关联的所有元数据键/值对。

这会迭代所有元数据，key_len 和 val_len 会填充放入 keys 和 values 缓冲区中的字节数。

如果提供的缓冲区太短，则填充所需的长度并返回 -ERANGE。否则，缓冲区中将填充元数据的键和值，每个键和值后跟一个 '\0'。

参数:

  • io -- 池 ioctx

  • app_name -- 应用程序名称

  • keys -- 存储键名称的缓冲区

  • key_len -- keys 缓冲区中的字节数

  • values -- 存储值的缓冲区

  • vals_len -- values 缓冲区中的字节数

返回:

成功时为 0，失败时为负错误码

返回:

-ERANGE 如果任一缓冲区太短

int rados_objects_list_open(rados_ioctx_t io, rados_list_ctx_t *ctx) __attribute__((deprecated))
uint32_t rados_objects_list_get_pg_hash_position(rados_list_ctx_t ctx) __attribute__((deprecated))
uint32_t rados_objects_list_seek(rados_list_ctx_t ctx, uint32_t pos) __attribute__((deprecated))
int rados_objects_list_next(rados_list_ctx_t ctx, const char **entry, const char **key) __attribute__((deprecated))
void rados_objects_list_close(rados_list_ctx_t ctx) __attribute__((deprecated))
struct rados_object_list_item
#include <librados.h>

rados_object_list 在结果数组中填充的项。

公共成员

size_t oid_length

oid 长度

char *oid

对象名称

size_t nspace_length

命名空间长度

char *nspace

对象命名空间

size_t locator_length

定位符长度

char *locator

对象定位符

struct rados_pool_stat_t
#include <librados.h>

池的使用信息。

公共成员

uint64_t num_bytes

已用空间（字节）

uint64_t num_kb

已用空间（KB）

uint64_t num_objects

池中的对象数

uint64_t num_object_clones

对象克隆数

uint64_t num_object_copies

num_objects * num_replicas

uint64_t num_objects_missing_on_primary

主节点上缺失的对象数

uint64_t num_objects_unfound

在任何 OSD 上都未找到的对象数

uint64_t num_objects_degraded

复制次数少于应有次数的对象数（但在至少一个 OSD 上找到）

uint64_t num_rd

读取的对象数

uint64_t num_rd_kb

读取的对象（KB）

uint64_t num_wr

写入的对象数

uint64_t num_wr_kb

写入的对象（KB）

uint64_t num_user_bytes

用户最初提供的字节数

uint64_t compressed_bytes_orig

通过压缩的字节数

uint64_t compressed_bytes

压缩后产生的字节数

uint64_t compressed_bytes_alloc

分配给存储的字节数

struct rados_cluster_stat_t
#include <librados.h>

集群范围的使用信息

公共成员

uint64_t kb

设备总大小

uint64_t kb_used

总已用空间

uint64_t kb_avail

总可用/空闲空间

uint64_t num_objects

对象数

由 Ceph 基金会为您呈现

Ceph 文档是由非营利性 Ceph 基金会 资助和托管的社区资源。如果您希望支持这项工作和我们的其他努力，请考虑 立即加入。