File: | src/librados/librados.cc |
Location: | line 5945, column 10 |
Description: | Potential leak of memory pointed to by 'oc.c_cursor' |
1 | // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- | |||
2 | // vim: ts=8 sw=2 smarttab | |||
3 | /* | |||
4 | * Ceph - scalable distributed file system | |||
5 | * | |||
6 | * Copyright (C) 2004-2012 Sage Weil <sage@newdream.net> | |||
7 | * | |||
8 | * This is free software; you can redistribute it and/or | |||
9 | * modify it under the terms of the GNU Lesser General Public | |||
10 | * License version 2.1, as published by the Free Software | |||
11 | * Foundation. See file COPYING. | |||
12 | * | |||
13 | */ | |||
14 | ||||
15 | #include <limits.h> | |||
16 | ||||
17 | #include "common/config.h" | |||
18 | #include "common/errno.h" | |||
19 | #include "common/ceph_argparse.h" | |||
20 | #include "common/ceph_json.h" | |||
21 | #include "common/common_init.h" | |||
22 | #include "common/TracepointProvider.h" | |||
23 | #include "common/hobject.h" | |||
24 | #include "include/rados/librados.h" | |||
25 | #include "include/rados/librados.hpp" | |||
26 | #include "include/types.h" | |||
27 | #include <include/stringify.h> | |||
28 | ||||
29 | #include "librados/AioCompletionImpl.h" | |||
30 | #include "librados/IoCtxImpl.h" | |||
31 | #include "librados/PoolAsyncCompletionImpl.h" | |||
32 | #include "librados/RadosClient.h" | |||
33 | #include "librados/RadosXattrIter.h" | |||
34 | #include "librados/ListObjectImpl.h" | |||
35 | #include <cls/lock/cls_lock_client.h> | |||
36 | ||||
37 | #include <string> | |||
38 | #include <map> | |||
39 | #include <set> | |||
40 | #include <vector> | |||
41 | #include <list> | |||
42 | #include <stdexcept> | |||
43 | ||||
44 | #ifdef WITH_LTTNG | |||
45 | #define TRACEPOINT_DEFINE | |||
46 | #define TRACEPOINT_PROBE_DYNAMIC_LINKAGE | |||
47 | #include "tracing/librados.h" | |||
48 | #undef TRACEPOINT_PROBE_DYNAMIC_LINKAGE | |||
49 | #undef TRACEPOINT_DEFINE | |||
50 | #else | |||
51 | #define tracepoint(...) | |||
52 | #endif | |||
53 | ||||
54 | using std::string; | |||
55 | using std::map; | |||
56 | using std::set; | |||
57 | using std::vector; | |||
58 | using std::list; | |||
59 | using std::runtime_error; | |||
60 | ||||
61 | #define dout_subsysceph_subsys_rados ceph_subsys_rados | |||
62 | #undef dout_prefix*_dout << "librados: " | |||
63 | #define dout_prefix*_dout << "librados: " *_dout << "librados: " | |||
64 | ||||
65 | #define RADOS_LIST_MAX_ENTRIES1024 1024 | |||
66 | ||||
67 | namespace { | |||
68 | ||||
69 | TracepointProvider::Traits tracepoint_traits("librados_tp.so", "rados_tracing"); | |||
70 | ||||
71 | } // anonymous namespace | |||
72 | ||||
73 | /* | |||
74 | * Structure of this file | |||
75 | * | |||
76 | * RadosClient and the related classes are the internal implementation of librados. | |||
77 | * Above that layer sits the C API, found in include/rados/librados.h, and | |||
78 | * the C++ API, found in include/rados/librados.hpp | |||
79 | * | |||
80 | * The C++ API sometimes implements things in terms of the C API. | |||
81 | * Both the C++ and C API rely on RadosClient. | |||
82 | * | |||
83 | * Visually: | |||
84 | * +--------------------------------------+ | |||
85 | * | C++ API | | |||
86 | * +--------------------+ | | |||
87 | * | C API | | | |||
88 | * +--------------------+-----------------+ | |||
89 | * | RadosClient | | |||
90 | * +--------------------------------------+ | |||
91 | */ | |||
92 | ||||
93 | namespace librados { | |||
94 | ||||
95 | struct ObjectOperationImpl { | |||
96 | ::ObjectOperation o; | |||
97 | real_time rt; | |||
98 | real_time *prt; | |||
99 | ||||
100 | ObjectOperationImpl() : prt(NULL__null) {} | |||
101 | }; | |||
102 | ||||
103 | } | |||
104 | ||||
105 | size_t librados::ObjectOperation::size() | |||
106 | { | |||
107 | ::ObjectOperation *o = &impl->o; | |||
108 | return o->size(); | |||
109 | } | |||
110 | ||||
111 | static void set_op_flags(::ObjectOperation *o, int flags) | |||
112 | { | |||
113 | int rados_flags = 0; | |||
114 | if (flags & LIBRADOS_OP_FLAG_EXCL) | |||
115 | rados_flags |= CEPH_OSD_OP_FLAG_EXCL; | |||
116 | if (flags & LIBRADOS_OP_FLAG_FAILOK) | |||
117 | rados_flags |= CEPH_OSD_OP_FLAG_FAILOK; | |||
118 | if (flags & LIBRADOS_OP_FLAG_FADVISE_RANDOM) | |||
119 | rados_flags |= CEPH_OSD_OP_FLAG_FADVISE_RANDOM; | |||
120 | if (flags & LIBRADOS_OP_FLAG_FADVISE_SEQUENTIAL) | |||
121 | rados_flags |= CEPH_OSD_OP_FLAG_FADVISE_SEQUENTIAL; | |||
122 | if (flags & LIBRADOS_OP_FLAG_FADVISE_WILLNEED) | |||
123 | rados_flags |= CEPH_OSD_OP_FLAG_FADVISE_WILLNEED; | |||
124 | if (flags & LIBRADOS_OP_FLAG_FADVISE_DONTNEED) | |||
125 | rados_flags |= CEPH_OSD_OP_FLAG_FADVISE_DONTNEED; | |||
126 | if (flags & LIBRADOS_OP_FLAG_FADVISE_NOCACHE) | |||
127 | rados_flags |= CEPH_OSD_OP_FLAG_FADVISE_NOCACHE; | |||
128 | o->set_last_op_flags(rados_flags); | |||
129 | } | |||
130 | ||||
131 | //deprcated | |||
132 | void librados::ObjectOperation::set_op_flags(ObjectOperationFlags flags) | |||
133 | { | |||
134 | ::set_op_flags(&impl->o, (int)flags); | |||
135 | } | |||
136 | ||||
137 | void librados::ObjectOperation::set_op_flags2(int flags) | |||
138 | { | |||
139 | ::ObjectOperation *o = &impl->o; | |||
140 | ::set_op_flags(o, flags); | |||
141 | } | |||
142 | ||||
143 | void librados::ObjectOperation::cmpxattr(const char *name, uint8_t op, const bufferlist& v) | |||
144 | { | |||
145 | ::ObjectOperation *o = &impl->o; | |||
146 | o->cmpxattr(name, op, CEPH_OSD_CMPXATTR_MODE_STRING, v); | |||
147 | } | |||
148 | ||||
149 | void librados::ObjectOperation::cmpxattr(const char *name, uint8_t op, uint64_t v) | |||
150 | { | |||
151 | ::ObjectOperation *o = &impl->o; | |||
152 | bufferlist bl; | |||
153 | ::encode(v, bl); | |||
154 | o->cmpxattr(name, op, CEPH_OSD_CMPXATTR_MODE_U64, bl); | |||
155 | } | |||
156 | ||||
157 | void librados::ObjectOperation::src_cmpxattr(const std::string& src_oid, | |||
158 | const char *name, int op, const bufferlist& v) | |||
159 | { | |||
160 | ::ObjectOperation *o = &impl->o; | |||
161 | object_t oid(src_oid); | |||
162 | o->src_cmpxattr(oid, CEPH_NOSNAP((__u64)(-2)), name, v, op, CEPH_OSD_CMPXATTR_MODE_STRING); | |||
163 | } | |||
164 | ||||
165 | void librados::ObjectOperation::src_cmpxattr(const std::string& src_oid, | |||
166 | const char *name, int op, uint64_t val) | |||
167 | { | |||
168 | ::ObjectOperation *o = &impl->o; | |||
169 | object_t oid(src_oid); | |||
170 | bufferlist bl; | |||
171 | ::encode(val, bl); | |||
172 | o->src_cmpxattr(oid, CEPH_NOSNAP((__u64)(-2)), name, bl, op, CEPH_OSD_CMPXATTR_MODE_U64); | |||
173 | } | |||
174 | ||||
175 | void librados::ObjectOperation::assert_version(uint64_t ver) | |||
176 | { | |||
177 | ::ObjectOperation *o = &impl->o; | |||
178 | o->assert_version(ver); | |||
179 | } | |||
180 | ||||
181 | void librados::ObjectOperation::assert_exists() | |||
182 | { | |||
183 | ::ObjectOperation *o = &impl->o; | |||
184 | o->stat(NULL__null, (ceph::real_time*) NULL__null, NULL__null); | |||
185 | } | |||
186 | ||||
187 | void librados::ObjectOperation::exec(const char *cls, const char *method, bufferlist& inbl) | |||
188 | { | |||
189 | ::ObjectOperation *o = &impl->o; | |||
190 | o->call(cls, method, inbl); | |||
191 | } | |||
192 | ||||
193 | void librados::ObjectOperation::exec(const char *cls, const char *method, bufferlist& inbl, bufferlist *outbl, int *prval) | |||
194 | { | |||
195 | ::ObjectOperation *o = &impl->o; | |||
196 | o->call(cls, method, inbl, outbl, NULL__null, prval); | |||
197 | } | |||
198 | ||||
199 | class ObjectOpCompletionCtx : public Context { | |||
200 | librados::ObjectOperationCompletion *completion; | |||
201 | bufferlist bl; | |||
202 | public: | |||
203 | explicit ObjectOpCompletionCtx(librados::ObjectOperationCompletion *c) : completion(c) {} | |||
204 | void finish(int r) { | |||
205 | completion->handle_completion(r, bl); | |||
206 | delete completion; | |||
207 | } | |||
208 | ||||
209 | bufferlist *outbl() { | |||
210 | return &bl; | |||
211 | } | |||
212 | }; | |||
213 | ||||
214 | void librados::ObjectOperation::exec(const char *cls, const char *method, bufferlist& inbl, librados::ObjectOperationCompletion *completion) | |||
215 | { | |||
216 | ::ObjectOperation *o = &impl->o; | |||
217 | ||||
218 | ObjectOpCompletionCtx *ctx = new ObjectOpCompletionCtx(completion); | |||
219 | ||||
220 | o->call(cls, method, inbl, ctx->outbl(), ctx, NULL__null); | |||
221 | } | |||
222 | ||||
223 | void librados::ObjectReadOperation::stat(uint64_t *psize, time_t *pmtime, int *prval) | |||
224 | { | |||
225 | ::ObjectOperation *o = &impl->o; | |||
226 | o->stat(psize, pmtime, prval); | |||
227 | } | |||
228 | ||||
229 | void librados::ObjectReadOperation::stat2(uint64_t *psize, struct timespec *pts, int *prval) | |||
230 | { | |||
231 | ::ObjectOperation *o = &impl->o; | |||
232 | o->stat(psize, pts, prval); | |||
233 | } | |||
234 | ||||
235 | void librados::ObjectReadOperation::read(size_t off, uint64_t len, bufferlist *pbl, int *prval) | |||
236 | { | |||
237 | ::ObjectOperation *o = &impl->o; | |||
238 | o->read(off, len, pbl, prval, NULL__null); | |||
239 | } | |||
240 | ||||
241 | void librados::ObjectReadOperation::sparse_read(uint64_t off, uint64_t len, | |||
242 | std::map<uint64_t,uint64_t> *m, | |||
243 | bufferlist *data_bl, int *prval) | |||
244 | { | |||
245 | ::ObjectOperation *o = &impl->o; | |||
246 | o->sparse_read(off, len, m, data_bl, prval); | |||
247 | } | |||
248 | ||||
249 | void librados::ObjectReadOperation::tmap_get(bufferlist *pbl, int *prval) | |||
250 | { | |||
251 | ::ObjectOperation *o = &impl->o; | |||
252 | o->tmap_get(pbl, prval); | |||
253 | } | |||
254 | ||||
255 | void librados::ObjectReadOperation::getxattr(const char *name, bufferlist *pbl, int *prval) | |||
256 | { | |||
257 | ::ObjectOperation *o = &impl->o; | |||
258 | o->getxattr(name, pbl, prval); | |||
259 | } | |||
260 | ||||
261 | void librados::ObjectReadOperation::omap_get_vals( | |||
262 | const std::string &start_after, | |||
263 | const std::string &filter_prefix, | |||
264 | uint64_t max_return, | |||
265 | std::map<std::string, bufferlist> *out_vals, | |||
266 | int *prval) | |||
267 | { | |||
268 | ::ObjectOperation *o = &impl->o; | |||
269 | o->omap_get_vals(start_after, filter_prefix, max_return, out_vals, prval); | |||
270 | } | |||
271 | ||||
272 | void librados::ObjectReadOperation::omap_get_vals( | |||
273 | const std::string &start_after, | |||
274 | uint64_t max_return, | |||
275 | std::map<std::string, bufferlist> *out_vals, | |||
276 | int *prval) | |||
277 | { | |||
278 | ::ObjectOperation *o = &impl->o; | |||
279 | o->omap_get_vals(start_after, "", max_return, out_vals, prval); | |||
280 | } | |||
281 | ||||
282 | void librados::ObjectReadOperation::omap_get_keys( | |||
283 | const std::string &start_after, | |||
284 | uint64_t max_return, | |||
285 | std::set<std::string> *out_keys, | |||
286 | int *prval) | |||
287 | { | |||
288 | ::ObjectOperation *o = &impl->o; | |||
289 | o->omap_get_keys(start_after, max_return, out_keys, prval); | |||
290 | } | |||
291 | ||||
292 | void librados::ObjectReadOperation::omap_get_header(bufferlist *bl, int *prval) | |||
293 | { | |||
294 | ::ObjectOperation *o = &impl->o; | |||
295 | o->omap_get_header(bl, prval); | |||
296 | } | |||
297 | ||||
298 | void librados::ObjectReadOperation::omap_get_vals_by_keys( | |||
299 | const std::set<std::string> &keys, | |||
300 | std::map<std::string, bufferlist> *map, | |||
301 | int *prval) | |||
302 | { | |||
303 | ::ObjectOperation *o = &impl->o; | |||
304 | o->omap_get_vals_by_keys(keys, map, prval); | |||
305 | } | |||
306 | ||||
307 | void librados::ObjectOperation::omap_cmp( | |||
308 | const std::map<std::string, pair<bufferlist, int> > &assertions, | |||
309 | int *prval) | |||
310 | { | |||
311 | ::ObjectOperation *o = &impl->o; | |||
312 | o->omap_cmp(assertions, prval); | |||
313 | } | |||
314 | ||||
315 | void librados::ObjectReadOperation::list_watchers( | |||
316 | list<obj_watch_t> *out_watchers, | |||
317 | int *prval) | |||
318 | { | |||
319 | ::ObjectOperation *o = &impl->o; | |||
320 | o->list_watchers(out_watchers, prval); | |||
321 | } | |||
322 | ||||
323 | void librados::ObjectReadOperation::list_snaps( | |||
324 | snap_set_t *out_snaps, | |||
325 | int *prval) | |||
326 | { | |||
327 | ::ObjectOperation *o = &impl->o; | |||
328 | o->list_snaps(out_snaps, prval); | |||
329 | } | |||
330 | ||||
331 | void librados::ObjectReadOperation::is_dirty(bool *is_dirty, int *prval) | |||
332 | { | |||
333 | ::ObjectOperation *o = &impl->o; | |||
334 | o->is_dirty(is_dirty, prval); | |||
335 | } | |||
336 | ||||
337 | int librados::IoCtx::omap_get_vals(const std::string& oid, | |||
338 | const std::string& start_after, | |||
339 | const std::string& filter_prefix, | |||
340 | uint64_t max_return, | |||
341 | std::map<std::string, bufferlist> *out_vals) | |||
342 | { | |||
343 | ObjectReadOperation op; | |||
344 | int r; | |||
345 | op.omap_get_vals(start_after, filter_prefix, max_return, out_vals, &r); | |||
346 | bufferlist bl; | |||
347 | int ret = operate(oid, &op, &bl); | |||
348 | if (ret < 0) | |||
349 | return ret; | |||
350 | ||||
351 | return r; | |||
352 | } | |||
353 | ||||
354 | void librados::ObjectReadOperation::getxattrs(map<string, bufferlist> *pattrs, int *prval) | |||
355 | { | |||
356 | ::ObjectOperation *o = &impl->o; | |||
357 | o->getxattrs(pattrs, prval); | |||
358 | } | |||
359 | ||||
360 | void librados::ObjectWriteOperation::mtime(time_t *pt) | |||
361 | { | |||
362 | if (pt) { | |||
363 | impl->rt = ceph::real_clock::from_time_t(*pt); | |||
364 | impl->prt = &impl->rt; | |||
365 | } | |||
366 | } | |||
367 | ||||
368 | void librados::ObjectWriteOperation::mtime2(struct timespec *pts) | |||
369 | { | |||
370 | if (pts) { | |||
371 | impl->rt = ceph::real_clock::from_timespec(*pts); | |||
372 | impl->prt = &impl->rt; | |||
373 | } | |||
374 | } | |||
375 | ||||
376 | void librados::ObjectWriteOperation::create(bool exclusive) | |||
377 | { | |||
378 | ::ObjectOperation *o = &impl->o; | |||
379 | o->create(exclusive); | |||
380 | } | |||
381 | ||||
382 | void librados::ObjectWriteOperation::create(bool exclusive, | |||
383 | const std::string& category) // unused | |||
384 | { | |||
385 | ::ObjectOperation *o = &impl->o; | |||
386 | o->create(exclusive); | |||
387 | } | |||
388 | ||||
389 | void librados::ObjectWriteOperation::write(uint64_t off, const bufferlist& bl) | |||
390 | { | |||
391 | ::ObjectOperation *o = &impl->o; | |||
392 | bufferlist c = bl; | |||
393 | o->write(off, c); | |||
394 | } | |||
395 | ||||
396 | void librados::ObjectWriteOperation::write_full(const bufferlist& bl) | |||
397 | { | |||
398 | ::ObjectOperation *o = &impl->o; | |||
399 | bufferlist c = bl; | |||
400 | o->write_full(c); | |||
401 | } | |||
402 | ||||
403 | void librados::ObjectWriteOperation::writesame(uint64_t off, uint64_t write_len, | |||
404 | const bufferlist& bl) | |||
405 | { | |||
406 | ::ObjectOperation *o = &impl->o; | |||
407 | bufferlist c = bl; | |||
408 | o->writesame(off, write_len, c); | |||
409 | } | |||
410 | ||||
411 | void librados::ObjectWriteOperation::append(const bufferlist& bl) | |||
412 | { | |||
413 | ::ObjectOperation *o = &impl->o; | |||
414 | bufferlist c = bl; | |||
415 | o->append(c); | |||
416 | } | |||
417 | ||||
418 | void librados::ObjectWriteOperation::remove() | |||
419 | { | |||
420 | ::ObjectOperation *o = &impl->o; | |||
421 | o->remove(); | |||
422 | } | |||
423 | ||||
424 | void librados::ObjectWriteOperation::truncate(uint64_t off) | |||
425 | { | |||
426 | ::ObjectOperation *o = &impl->o; | |||
427 | o->truncate(off); | |||
428 | } | |||
429 | ||||
430 | void librados::ObjectWriteOperation::zero(uint64_t off, uint64_t len) | |||
431 | { | |||
432 | ::ObjectOperation *o = &impl->o; | |||
433 | o->zero(off, len); | |||
434 | } | |||
435 | ||||
436 | void librados::ObjectWriteOperation::rmxattr(const char *name) | |||
437 | { | |||
438 | ::ObjectOperation *o = &impl->o; | |||
439 | o->rmxattr(name); | |||
440 | } | |||
441 | ||||
442 | void librados::ObjectWriteOperation::setxattr(const char *name, const bufferlist& v) | |||
443 | { | |||
444 | ::ObjectOperation *o = &impl->o; | |||
445 | o->setxattr(name, v); | |||
446 | } | |||
447 | ||||
448 | void librados::ObjectWriteOperation::omap_set( | |||
449 | const map<string, bufferlist> &map) | |||
450 | { | |||
451 | ::ObjectOperation *o = &impl->o; | |||
452 | o->omap_set(map); | |||
453 | } | |||
454 | ||||
455 | void librados::ObjectWriteOperation::omap_set_header(const bufferlist &bl) | |||
456 | { | |||
457 | bufferlist c = bl; | |||
458 | ::ObjectOperation *o = &impl->o; | |||
459 | o->omap_set_header(c); | |||
460 | } | |||
461 | ||||
462 | void librados::ObjectWriteOperation::omap_clear() | |||
463 | { | |||
464 | ::ObjectOperation *o = &impl->o; | |||
465 | o->omap_clear(); | |||
466 | } | |||
467 | ||||
468 | void librados::ObjectWriteOperation::omap_rm_keys( | |||
469 | const std::set<std::string> &to_rm) | |||
470 | { | |||
471 | ::ObjectOperation *o = &impl->o; | |||
472 | o->omap_rm_keys(to_rm); | |||
473 | } | |||
474 | ||||
475 | void librados::ObjectWriteOperation::copy_from(const std::string& src, | |||
476 | const IoCtx& src_ioctx, | |||
477 | uint64_t src_version) | |||
478 | { | |||
479 | copy_from2(src, src_ioctx, src_version, 0); | |||
480 | } | |||
481 | ||||
482 | void librados::ObjectWriteOperation::copy_from2(const std::string& src, | |||
483 | const IoCtx& src_ioctx, | |||
484 | uint64_t src_version, | |||
485 | uint32_t src_fadvise_flags) | |||
486 | { | |||
487 | ::ObjectOperation *o = &impl->o; | |||
488 | o->copy_from(object_t(src), src_ioctx.io_ctx_impl->snap_seq, | |||
489 | src_ioctx.io_ctx_impl->oloc, src_version, 0, src_fadvise_flags); | |||
490 | } | |||
491 | ||||
492 | void librados::ObjectWriteOperation::undirty() | |||
493 | { | |||
494 | ::ObjectOperation *o = &impl->o; | |||
495 | o->undirty(); | |||
496 | } | |||
497 | ||||
498 | void librados::ObjectReadOperation::cache_flush() | |||
499 | { | |||
500 | ::ObjectOperation *o = &impl->o; | |||
501 | o->cache_flush(); | |||
502 | } | |||
503 | ||||
504 | void librados::ObjectReadOperation::cache_try_flush() | |||
505 | { | |||
506 | ::ObjectOperation *o = &impl->o; | |||
507 | o->cache_try_flush(); | |||
508 | } | |||
509 | ||||
510 | void librados::ObjectReadOperation::cache_evict() | |||
511 | { | |||
512 | ::ObjectOperation *o = &impl->o; | |||
513 | o->cache_evict(); | |||
514 | } | |||
515 | ||||
516 | void librados::ObjectWriteOperation::tmap_put(const bufferlist &bl) | |||
517 | { | |||
518 | ::ObjectOperation *o = &impl->o; | |||
519 | bufferlist c = bl; | |||
520 | o->tmap_put(c); | |||
521 | } | |||
522 | ||||
523 | void librados::ObjectWriteOperation::tmap_update(const bufferlist& cmdbl) | |||
524 | { | |||
525 | ::ObjectOperation *o = &impl->o; | |||
526 | bufferlist c = cmdbl; | |||
527 | o->tmap_update(c); | |||
528 | } | |||
529 | ||||
530 | void librados::ObjectWriteOperation::clone_range(uint64_t dst_off, | |||
531 | const std::string& src_oid, uint64_t src_off, | |||
532 | size_t len) | |||
533 | { | |||
534 | ::ObjectOperation *o = &impl->o; | |||
535 | o->clone_range(src_oid, src_off, len, dst_off); | |||
536 | } | |||
537 | ||||
538 | void librados::ObjectWriteOperation::selfmanaged_snap_rollback(snap_t snapid) | |||
539 | { | |||
540 | ::ObjectOperation *o = &impl->o; | |||
541 | o->rollback(snapid); | |||
542 | } | |||
543 | ||||
544 | // You must specify the snapid not the name normally used with pool snapshots | |||
545 | void librados::ObjectWriteOperation::snap_rollback(snap_t snapid) | |||
546 | { | |||
547 | ::ObjectOperation *o = &impl->o; | |||
548 | o->rollback(snapid); | |||
549 | } | |||
550 | ||||
551 | void librados::ObjectWriteOperation::set_alloc_hint( | |||
552 | uint64_t expected_object_size, | |||
553 | uint64_t expected_write_size) | |||
554 | { | |||
555 | ::ObjectOperation *o = &impl->o; | |||
556 | o->set_alloc_hint(expected_object_size, expected_write_size, 0); | |||
557 | } | |||
558 | void librados::ObjectWriteOperation::set_alloc_hint2( | |||
559 | uint64_t expected_object_size, | |||
560 | uint64_t expected_write_size, | |||
561 | uint32_t flags) | |||
562 | { | |||
563 | ::ObjectOperation *o = &impl->o; | |||
564 | o->set_alloc_hint(expected_object_size, expected_write_size, flags); | |||
565 | } | |||
566 | ||||
567 | void librados::ObjectWriteOperation::cache_pin() | |||
568 | { | |||
569 | ::ObjectOperation *o = &impl->o; | |||
570 | o->cache_pin(); | |||
571 | } | |||
572 | ||||
573 | void librados::ObjectWriteOperation::cache_unpin() | |||
574 | { | |||
575 | ::ObjectOperation *o = &impl->o; | |||
576 | o->cache_unpin(); | |||
577 | } | |||
578 | ||||
579 | librados::WatchCtx:: | |||
580 | ~WatchCtx() | |||
581 | { | |||
582 | } | |||
583 | ||||
584 | librados::WatchCtx2:: | |||
585 | ~WatchCtx2() | |||
586 | { | |||
587 | } | |||
588 | ||||
589 | ||||
590 | struct librados::ObjListCtx { | |||
591 | bool new_request; | |||
592 | librados::IoCtxImpl dupctx; | |||
593 | librados::IoCtxImpl *ctx; | |||
594 | Objecter::ListContext *lc; | |||
595 | Objecter::NListContext *nlc; | |||
596 | ||||
597 | ObjListCtx(IoCtxImpl *c, Objecter::ListContext *l) : new_request(false), lc(l), nlc(NULL__null) { | |||
598 | // Get our own private IoCtxImpl so that namespace setting isn't changed by caller | |||
599 | // between uses. | |||
600 | ctx = &dupctx; | |||
601 | dupctx.dup(*c); | |||
602 | } | |||
603 | ObjListCtx(IoCtxImpl *c, Objecter::NListContext *nl) : new_request(true), lc(NULL__null), nlc(nl) { | |||
604 | // Get our own private IoCtxImpl so that namespace setting isn't changed by caller | |||
605 | // between uses. | |||
606 | ctx = &dupctx; | |||
607 | dupctx.dup(*c); | |||
608 | } | |||
609 | ~ObjListCtx() { | |||
610 | ctx = NULL__null; | |||
611 | if (new_request) | |||
612 | delete nlc; | |||
613 | else | |||
614 | delete lc; | |||
615 | } | |||
616 | }; | |||
617 | ||||
618 | ///////////////////////////// NObjectIteratorImpl ///////////////////////////// | |||
619 | librados::NObjectIteratorImpl::NObjectIteratorImpl(ObjListCtx *ctx_) | |||
620 | : ctx(ctx_) | |||
621 | { | |||
622 | } | |||
623 | ||||
624 | librados::NObjectIteratorImpl::~NObjectIteratorImpl() | |||
625 | { | |||
626 | ctx.reset(); | |||
627 | } | |||
628 | ||||
629 | librados::NObjectIteratorImpl::NObjectIteratorImpl(const NObjectIteratorImpl &rhs) | |||
630 | { | |||
631 | *this = rhs; | |||
632 | } | |||
633 | ||||
634 | librados::NObjectIteratorImpl& librados::NObjectIteratorImpl::operator=(const librados::NObjectIteratorImpl &rhs) | |||
635 | { | |||
636 | if (&rhs == this) | |||
637 | return *this; | |||
638 | if (rhs.ctx.get() == NULL__null) { | |||
639 | ctx.reset(); | |||
640 | return *this; | |||
641 | } | |||
642 | if (rhs.ctx->new_request) { | |||
643 | Objecter::NListContext *list_ctx = new Objecter::NListContext(*rhs.ctx->nlc); | |||
644 | ctx.reset(new ObjListCtx(rhs.ctx->ctx, list_ctx)); | |||
645 | cur_obj = rhs.cur_obj; | |||
646 | } else { | |||
647 | Objecter::ListContext *list_ctx = new Objecter::ListContext(*rhs.ctx->lc); | |||
648 | ctx.reset(new ObjListCtx(rhs.ctx->ctx, list_ctx)); | |||
649 | cur_obj = rhs.cur_obj; | |||
650 | } | |||
651 | return *this; | |||
652 | } | |||
653 | ||||
654 | bool librados::NObjectIteratorImpl::operator==(const librados::NObjectIteratorImpl& rhs) const { | |||
655 | ||||
656 | if (ctx.get() == NULL__null) { | |||
657 | if (rhs.ctx.get() == NULL__null) | |||
658 | return true; | |||
659 | if (rhs.ctx->new_request) | |||
660 | return rhs.ctx->nlc->at_end(); | |||
661 | else | |||
662 | return rhs.ctx->lc->at_end(); | |||
663 | } | |||
664 | if (rhs.ctx.get() == NULL__null) { | |||
665 | // Redundant but same as ObjectIterator version | |||
666 | if (ctx.get() == NULL__null) | |||
667 | return true; | |||
668 | if (ctx->new_request) | |||
669 | return ctx->nlc->at_end(); | |||
670 | else | |||
671 | return ctx->lc->at_end(); | |||
672 | } | |||
673 | return ctx.get() == rhs.ctx.get(); | |||
674 | } | |||
675 | ||||
676 | bool librados::NObjectIteratorImpl::operator!=(const librados::NObjectIteratorImpl& rhs) const { | |||
677 | return !(*this == rhs); | |||
678 | } | |||
679 | ||||
680 | const librados::ListObject& librados::NObjectIteratorImpl::operator*() const { | |||
681 | return cur_obj; | |||
682 | } | |||
683 | ||||
684 | const librados::ListObject* librados::NObjectIteratorImpl::operator->() const { | |||
685 | return &cur_obj; | |||
686 | } | |||
687 | ||||
688 | librados::NObjectIteratorImpl& librados::NObjectIteratorImpl::operator++() | |||
689 | { | |||
690 | get_next(); | |||
691 | return *this; | |||
692 | } | |||
693 | ||||
694 | librados::NObjectIteratorImpl librados::NObjectIteratorImpl::operator++(int) | |||
695 | { | |||
696 | librados::NObjectIteratorImpl ret(*this); | |||
697 | get_next(); | |||
698 | return ret; | |||
699 | } | |||
700 | ||||
701 | uint32_t librados::NObjectIteratorImpl::seek(uint32_t pos) | |||
702 | { | |||
703 | uint32_t r = rados_nobjects_list_seek(ctx.get(), pos); | |||
704 | get_next(); | |||
705 | return r; | |||
706 | } | |||
707 | ||||
708 | void librados::NObjectIteratorImpl::set_filter(const bufferlist &bl) | |||
709 | { | |||
710 | assert(ctx)((ctx) ? static_cast<void> (0) : __ceph_assert_fail ("ctx" , "/home/brad/working/src/ceph/src/librados/librados.cc", 710 , __PRETTY_FUNCTION__)); | |||
711 | if (ctx->nlc) { | |||
712 | ctx->nlc->filter = bl; | |||
713 | } | |||
714 | ||||
715 | if (ctx->lc) { | |||
716 | ctx->lc->filter = bl; | |||
717 | } | |||
718 | } | |||
719 | ||||
720 | void librados::NObjectIteratorImpl::get_next() | |||
721 | { | |||
722 | const char *entry, *key, *nspace; | |||
723 | if (ctx->new_request) { | |||
724 | if (ctx->nlc->at_end()) | |||
725 | return; | |||
726 | } else { | |||
727 | if (ctx->lc->at_end()) | |||
728 | return; | |||
729 | } | |||
730 | int ret = rados_nobjects_list_next(ctx.get(), &entry, &key, &nspace); | |||
731 | if (ret == -ENOENT2) { | |||
732 | return; | |||
733 | } | |||
734 | else if (ret) { | |||
735 | ostringstream oss; | |||
736 | oss << "rados returned " << cpp_strerror(ret); | |||
737 | throw std::runtime_error(oss.str()); | |||
738 | } | |||
739 | ||||
740 | if (cur_obj.impl == NULL__null) | |||
741 | cur_obj.impl = new ListObjectImpl(); | |||
742 | cur_obj.impl->nspace = nspace; | |||
743 | cur_obj.impl->oid = entry; | |||
744 | cur_obj.impl->locator = key ? key : string(); | |||
745 | } | |||
746 | ||||
747 | uint32_t librados::NObjectIteratorImpl::get_pg_hash_position() const | |||
748 | { | |||
749 | if (ctx->new_request) | |||
750 | return ctx->nlc->get_pg_hash_position(); | |||
751 | else | |||
752 | return ctx->lc->get_pg_hash_position(); | |||
753 | } | |||
754 | ||||
755 | ///////////////////////////// NObjectIterator ///////////////////////////// | |||
756 | librados::NObjectIterator::NObjectIterator(ObjListCtx *ctx_) | |||
757 | { | |||
758 | impl = new NObjectIteratorImpl(ctx_); | |||
759 | } | |||
760 | ||||
761 | librados::NObjectIterator::~NObjectIterator() | |||
762 | { | |||
763 | delete impl; | |||
764 | } | |||
765 | ||||
766 | librados::NObjectIterator::NObjectIterator(const NObjectIterator &rhs) | |||
767 | { | |||
768 | if (rhs.impl == NULL__null) { | |||
769 | impl = NULL__null; | |||
770 | return; | |||
771 | } | |||
772 | impl = new NObjectIteratorImpl(); | |||
773 | *impl = *(rhs.impl); | |||
774 | } | |||
775 | ||||
776 | librados::NObjectIterator& librados::NObjectIterator::operator=(const librados::NObjectIterator &rhs) | |||
777 | { | |||
778 | if (rhs.impl == NULL__null) { | |||
779 | delete impl; | |||
780 | impl = NULL__null; | |||
781 | return *this; | |||
782 | } | |||
783 | if (impl == NULL__null) | |||
784 | impl = new NObjectIteratorImpl(); | |||
785 | *impl = *(rhs.impl); | |||
786 | return *this; | |||
787 | } | |||
788 | ||||
789 | bool librados::NObjectIterator::operator==(const librados::NObjectIterator& rhs) const | |||
790 | { | |||
791 | if (impl && rhs.impl) { | |||
792 | return *impl == *(rhs.impl); | |||
793 | } else { | |||
794 | return impl == rhs.impl; | |||
795 | } | |||
796 | } | |||
797 | ||||
798 | bool librados::NObjectIterator::operator!=(const librados::NObjectIterator& rhs) const | |||
799 | { | |||
800 | return !(*this == rhs); | |||
801 | } | |||
802 | ||||
803 | const librados::ListObject& librados::NObjectIterator::operator*() const { | |||
804 | assert(impl)((impl) ? static_cast<void> (0) : __ceph_assert_fail ("impl" , "/home/brad/working/src/ceph/src/librados/librados.cc", 804 , __PRETTY_FUNCTION__)); | |||
805 | return *(impl->get_listobjectp()); | |||
806 | } | |||
807 | ||||
808 | const librados::ListObject* librados::NObjectIterator::operator->() const { | |||
809 | assert(impl)((impl) ? static_cast<void> (0) : __ceph_assert_fail ("impl" , "/home/brad/working/src/ceph/src/librados/librados.cc", 809 , __PRETTY_FUNCTION__)); | |||
810 | return impl->get_listobjectp(); | |||
811 | } | |||
812 | ||||
813 | librados::NObjectIterator& librados::NObjectIterator::operator++() | |||
814 | { | |||
815 | assert(impl)((impl) ? static_cast<void> (0) : __ceph_assert_fail ("impl" , "/home/brad/working/src/ceph/src/librados/librados.cc", 815 , __PRETTY_FUNCTION__)); | |||
816 | impl->get_next(); | |||
817 | return *this; | |||
818 | } | |||
819 | ||||
820 | librados::NObjectIterator librados::NObjectIterator::operator++(int) | |||
821 | { | |||
822 | librados::NObjectIterator ret(*this); | |||
823 | impl->get_next(); | |||
824 | return ret; | |||
825 | } | |||
826 | ||||
827 | uint32_t librados::NObjectIterator::seek(uint32_t pos) | |||
828 | { | |||
829 | assert(impl)((impl) ? static_cast<void> (0) : __ceph_assert_fail ("impl" , "/home/brad/working/src/ceph/src/librados/librados.cc", 829 , __PRETTY_FUNCTION__)); | |||
830 | return impl->seek(pos); | |||
831 | } | |||
832 | ||||
833 | void librados::NObjectIterator::set_filter(const bufferlist &bl) | |||
834 | { | |||
835 | impl->set_filter(bl); | |||
836 | } | |||
837 | ||||
838 | void librados::NObjectIterator::get_next() | |||
839 | { | |||
840 | assert(impl)((impl) ? static_cast<void> (0) : __ceph_assert_fail ("impl" , "/home/brad/working/src/ceph/src/librados/librados.cc", 840 , __PRETTY_FUNCTION__)); | |||
841 | impl->get_next(); | |||
842 | } | |||
843 | ||||
844 | uint32_t librados::NObjectIterator::get_pg_hash_position() const | |||
845 | { | |||
846 | assert(impl)((impl) ? static_cast<void> (0) : __ceph_assert_fail ("impl" , "/home/brad/working/src/ceph/src/librados/librados.cc", 846 , __PRETTY_FUNCTION__)); | |||
847 | return impl->get_pg_hash_position(); | |||
848 | } | |||
849 | ||||
850 | const librados::NObjectIterator librados::NObjectIterator::__EndObjectIterator(NULL__null); | |||
851 | ||||
852 | // DEPRECATED; Use NObjectIterator instead | |||
853 | ///////////////////////////// ObjectIterator ///////////////////////////// | |||
854 | librados::ObjectIterator::ObjectIterator(ObjListCtx *ctx_) | |||
855 | : ctx(ctx_) | |||
856 | { | |||
857 | } | |||
858 | ||||
859 | librados::ObjectIterator::~ObjectIterator() | |||
860 | { | |||
861 | ctx.reset(); | |||
862 | } | |||
863 | ||||
864 | librados::ObjectIterator::ObjectIterator(const ObjectIterator &rhs) | |||
865 | { | |||
866 | *this = rhs; | |||
867 | } | |||
868 | ||||
869 | librados::ObjectIterator& librados::ObjectIterator::operator=(const librados::ObjectIterator &rhs) | |||
870 | { | |||
871 | if (&rhs == this) | |||
872 | return *this; | |||
873 | if (rhs.ctx.get() == NULL__null) { | |||
874 | ctx.reset(); | |||
875 | return *this; | |||
876 | } | |||
877 | Objecter::ListContext *list_ctx = new Objecter::ListContext(*rhs.ctx->lc); | |||
878 | ctx.reset(new ObjListCtx(rhs.ctx->ctx, list_ctx)); | |||
879 | cur_obj = rhs.cur_obj; | |||
880 | return *this; | |||
881 | } | |||
882 | ||||
883 | bool librados::ObjectIterator::operator==(const librados::ObjectIterator& rhs) const { | |||
884 | if (ctx.get() == NULL__null) | |||
885 | return rhs.ctx.get() == NULL__null || rhs.ctx->lc->at_end(); | |||
886 | if (rhs.ctx.get() == NULL__null) | |||
887 | return ctx.get() == NULL__null || ctx->lc->at_end(); | |||
888 | return ctx.get() == rhs.ctx.get(); | |||
889 | } | |||
890 | ||||
891 | bool librados::ObjectIterator::operator!=(const librados::ObjectIterator& rhs) const { | |||
892 | return !(*this == rhs); | |||
893 | } | |||
894 | ||||
895 | const pair<std::string, std::string>& librados::ObjectIterator::operator*() const { | |||
896 | return cur_obj; | |||
897 | } | |||
898 | ||||
899 | const pair<std::string, std::string>* librados::ObjectIterator::operator->() const { | |||
900 | return &cur_obj; | |||
901 | } | |||
902 | ||||
903 | librados::ObjectIterator& librados::ObjectIterator::operator++() | |||
904 | { | |||
905 | get_next(); | |||
906 | return *this; | |||
907 | } | |||
908 | ||||
909 | librados::ObjectIterator librados::ObjectIterator::operator++(int) | |||
910 | { | |||
911 | librados::ObjectIterator ret(*this); | |||
912 | get_next(); | |||
913 | return ret; | |||
914 | } | |||
915 | ||||
916 | uint32_t librados::ObjectIterator::seek(uint32_t pos) | |||
917 | { | |||
918 | uint32_t r = rados_objects_list_seek(ctx.get(), pos); | |||
919 | get_next(); | |||
920 | return r; | |||
921 | } | |||
922 | ||||
923 | void librados::ObjectIterator::get_next() | |||
924 | { | |||
925 | const char *entry, *key; | |||
926 | if (ctx->lc->at_end()) | |||
927 | return; | |||
928 | int ret = rados_objects_list_next(ctx.get(), &entry, &key); | |||
929 | if (ret == -ENOENT2) { | |||
930 | return; | |||
931 | } | |||
932 | else if (ret) { | |||
933 | ostringstream oss; | |||
934 | oss << "rados returned " << cpp_strerror(ret); | |||
935 | throw std::runtime_error(oss.str()); | |||
936 | } | |||
937 | ||||
938 | cur_obj = make_pair(entry, key ? key : string()); | |||
939 | } | |||
940 | ||||
941 | uint32_t librados::ObjectIterator::get_pg_hash_position() const | |||
942 | { | |||
943 | return ctx->lc->get_pg_hash_position(); | |||
944 | } | |||
945 | ||||
946 | const librados::ObjectIterator librados::ObjectIterator::__EndObjectIterator(NULL__null); | |||
947 | ||||
948 | ///////////////////////////// PoolAsyncCompletion ////////////////////////////// | |||
949 | int librados::PoolAsyncCompletion::PoolAsyncCompletion::set_callback(void *cb_arg, | |||
950 | rados_callback_t cb) | |||
951 | { | |||
952 | PoolAsyncCompletionImpl *c = (PoolAsyncCompletionImpl *)pc; | |||
953 | return c->set_callback(cb_arg, cb); | |||
954 | } | |||
955 | ||||
956 | int librados::PoolAsyncCompletion::PoolAsyncCompletion::wait() | |||
957 | { | |||
958 | PoolAsyncCompletionImpl *c = (PoolAsyncCompletionImpl *)pc; | |||
959 | return c->wait(); | |||
960 | } | |||
961 | ||||
962 | bool librados::PoolAsyncCompletion::PoolAsyncCompletion::is_complete() | |||
963 | { | |||
964 | PoolAsyncCompletionImpl *c = (PoolAsyncCompletionImpl *)pc; | |||
965 | return c->is_complete(); | |||
966 | } | |||
967 | ||||
968 | int librados::PoolAsyncCompletion::PoolAsyncCompletion::get_return_value() | |||
969 | { | |||
970 | PoolAsyncCompletionImpl *c = (PoolAsyncCompletionImpl *)pc; | |||
971 | return c->get_return_value(); | |||
972 | } | |||
973 | ||||
974 | void librados::PoolAsyncCompletion::PoolAsyncCompletion::release() | |||
975 | { | |||
976 | PoolAsyncCompletionImpl *c = (PoolAsyncCompletionImpl *)pc; | |||
977 | c->release(); | |||
978 | delete this; | |||
979 | } | |||
980 | ||||
981 | ///////////////////////////// AioCompletion ////////////////////////////// | |||
982 | int librados::AioCompletion::AioCompletion::set_complete_callback(void *cb_arg, rados_callback_t cb) | |||
983 | { | |||
984 | AioCompletionImpl *c = (AioCompletionImpl *)pc; | |||
985 | return c->set_complete_callback(cb_arg, cb); | |||
986 | } | |||
987 | ||||
988 | int librados::AioCompletion::AioCompletion::set_safe_callback(void *cb_arg, rados_callback_t cb) | |||
989 | { | |||
990 | AioCompletionImpl *c = (AioCompletionImpl *)pc; | |||
991 | return c->set_safe_callback(cb_arg, cb); | |||
992 | } | |||
993 | ||||
994 | int librados::AioCompletion::AioCompletion::wait_for_complete() | |||
995 | { | |||
996 | AioCompletionImpl *c = (AioCompletionImpl *)pc; | |||
997 | return c->wait_for_complete(); | |||
998 | } | |||
999 | ||||
1000 | int librados::AioCompletion::AioCompletion::wait_for_safe() | |||
1001 | { | |||
1002 | AioCompletionImpl *c = (AioCompletionImpl *)pc; | |||
1003 | return c->wait_for_safe(); | |||
1004 | } | |||
1005 | ||||
1006 | bool librados::AioCompletion::AioCompletion::is_complete() | |||
1007 | { | |||
1008 | AioCompletionImpl *c = (AioCompletionImpl *)pc; | |||
1009 | return c->is_complete(); | |||
1010 | } | |||
1011 | ||||
1012 | bool librados::AioCompletion::AioCompletion::is_safe() | |||
1013 | { | |||
1014 | AioCompletionImpl *c = (AioCompletionImpl *)pc; | |||
1015 | return c->is_safe(); | |||
1016 | } | |||
1017 | ||||
1018 | int librados::AioCompletion::AioCompletion::wait_for_complete_and_cb() | |||
1019 | { | |||
1020 | AioCompletionImpl *c = (AioCompletionImpl *)pc; | |||
1021 | return c->wait_for_complete_and_cb(); | |||
1022 | } | |||
1023 | ||||
1024 | int librados::AioCompletion::AioCompletion::wait_for_safe_and_cb() | |||
1025 | { | |||
1026 | AioCompletionImpl *c = (AioCompletionImpl *)pc; | |||
1027 | return c->wait_for_safe_and_cb(); | |||
1028 | } | |||
1029 | ||||
1030 | bool librados::AioCompletion::AioCompletion::is_complete_and_cb() | |||
1031 | { | |||
1032 | AioCompletionImpl *c = (AioCompletionImpl *)pc; | |||
1033 | return c->is_complete_and_cb(); | |||
1034 | } | |||
1035 | ||||
1036 | bool librados::AioCompletion::AioCompletion::is_safe_and_cb() | |||
1037 | { | |||
1038 | AioCompletionImpl *c = (AioCompletionImpl *)pc; | |||
1039 | return c->is_safe_and_cb(); | |||
1040 | } | |||
1041 | ||||
1042 | int librados::AioCompletion::AioCompletion::get_return_value() | |||
1043 | { | |||
1044 | AioCompletionImpl *c = (AioCompletionImpl *)pc; | |||
1045 | return c->get_return_value(); | |||
1046 | } | |||
1047 | ||||
1048 | int librados::AioCompletion::AioCompletion::get_version() | |||
1049 | { | |||
1050 | AioCompletionImpl *c = (AioCompletionImpl *)pc; | |||
1051 | return c->get_version(); | |||
1052 | } | |||
1053 | ||||
1054 | uint64_t librados::AioCompletion::AioCompletion::get_version64() | |||
1055 | { | |||
1056 | AioCompletionImpl *c = (AioCompletionImpl *)pc; | |||
1057 | return c->get_version(); | |||
1058 | } | |||
1059 | ||||
1060 | void librados::AioCompletion::AioCompletion::release() | |||
1061 | { | |||
1062 | AioCompletionImpl *c = (AioCompletionImpl *)pc; | |||
1063 | c->release(); | |||
1064 | delete this; | |||
1065 | } | |||
1066 | ||||
1067 | ///////////////////////////// IoCtx ////////////////////////////// | |||
1068 | librados::IoCtx::IoCtx() : io_ctx_impl(NULL__null) | |||
1069 | { | |||
1070 | } | |||
1071 | ||||
1072 | void librados::IoCtx::from_rados_ioctx_t(rados_ioctx_t p, IoCtx &io) | |||
1073 | { | |||
1074 | IoCtxImpl *io_ctx_impl = (IoCtxImpl*)p; | |||
1075 | ||||
1076 | io.io_ctx_impl = io_ctx_impl; | |||
1077 | if (io_ctx_impl) { | |||
1078 | io_ctx_impl->get(); | |||
1079 | } | |||
1080 | } | |||
1081 | ||||
1082 | librados::IoCtx::IoCtx(const IoCtx& rhs) | |||
1083 | { | |||
1084 | io_ctx_impl = rhs.io_ctx_impl; | |||
1085 | if (io_ctx_impl) { | |||
1086 | io_ctx_impl->get(); | |||
1087 | } | |||
1088 | } | |||
1089 | ||||
1090 | librados::IoCtx& librados::IoCtx::operator=(const IoCtx& rhs) | |||
1091 | { | |||
1092 | if (io_ctx_impl) | |||
1093 | io_ctx_impl->put(); | |||
1094 | io_ctx_impl = rhs.io_ctx_impl; | |||
1095 | io_ctx_impl->get(); | |||
1096 | return *this; | |||
1097 | } | |||
1098 | ||||
1099 | librados::IoCtx::~IoCtx() | |||
1100 | { | |||
1101 | close(); | |||
1102 | } | |||
1103 | ||||
1104 | void librados::IoCtx::close() | |||
1105 | { | |||
1106 | if (io_ctx_impl) | |||
1107 | io_ctx_impl->put(); | |||
1108 | io_ctx_impl = 0; | |||
1109 | } | |||
1110 | ||||
1111 | void librados::IoCtx::dup(const IoCtx& rhs) | |||
1112 | { | |||
1113 | if (io_ctx_impl) | |||
1114 | io_ctx_impl->put(); | |||
1115 | io_ctx_impl = new IoCtxImpl(); | |||
1116 | io_ctx_impl->get(); | |||
1117 | io_ctx_impl->dup(*rhs.io_ctx_impl); | |||
1118 | } | |||
1119 | ||||
1120 | int librados::IoCtx::set_auid(uint64_t auid_) | |||
1121 | { | |||
1122 | return io_ctx_impl->pool_change_auid(auid_); | |||
1123 | } | |||
1124 | ||||
1125 | int librados::IoCtx::set_auid_async(uint64_t auid_, PoolAsyncCompletion *c) | |||
1126 | { | |||
1127 | return io_ctx_impl->pool_change_auid_async(auid_, c->pc); | |||
1128 | } | |||
1129 | ||||
1130 | int librados::IoCtx::get_auid(uint64_t *auid_) | |||
1131 | { | |||
1132 | return rados_ioctx_pool_get_auid(io_ctx_impl, auid_); | |||
1133 | } | |||
1134 | ||||
1135 | bool librados::IoCtx::pool_requires_alignment() | |||
1136 | { | |||
1137 | return io_ctx_impl->client->pool_requires_alignment(get_id()); | |||
1138 | } | |||
1139 | ||||
1140 | int librados::IoCtx::pool_requires_alignment2(bool *requires) | |||
1141 | { | |||
1142 | return io_ctx_impl->client->pool_requires_alignment2(get_id(), requires); | |||
1143 | } | |||
1144 | ||||
1145 | uint64_t librados::IoCtx::pool_required_alignment() | |||
1146 | { | |||
1147 | return io_ctx_impl->client->pool_required_alignment(get_id()); | |||
1148 | } | |||
1149 | ||||
1150 | int librados::IoCtx::pool_required_alignment2(uint64_t *alignment) | |||
1151 | { | |||
1152 | return io_ctx_impl->client->pool_required_alignment2(get_id(), alignment); | |||
1153 | } | |||
1154 | ||||
1155 | std::string librados::IoCtx::get_pool_name() | |||
1156 | { | |||
1157 | std::string s; | |||
1158 | io_ctx_impl->client->pool_get_name(get_id(), &s); | |||
1159 | return s; | |||
1160 | } | |||
1161 | ||||
1162 | std::string librados::IoCtx::get_pool_name() const | |||
1163 | { | |||
1164 | return io_ctx_impl->get_cached_pool_name(); | |||
1165 | } | |||
1166 | ||||
1167 | uint64_t librados::IoCtx::get_instance_id() const | |||
1168 | { | |||
1169 | return io_ctx_impl->client->get_instance_id(); | |||
1170 | } | |||
1171 | ||||
1172 | int librados::IoCtx::create(const std::string& oid, bool exclusive) | |||
1173 | { | |||
1174 | object_t obj(oid); | |||
1175 | return io_ctx_impl->create(obj, exclusive); | |||
1176 | } | |||
1177 | ||||
1178 | int librados::IoCtx::create(const std::string& oid, bool exclusive, | |||
1179 | const std::string& category) // unused | |||
1180 | { | |||
1181 | object_t obj(oid); | |||
1182 | return io_ctx_impl->create(obj, exclusive); | |||
1183 | } | |||
1184 | ||||
1185 | int librados::IoCtx::write(const std::string& oid, bufferlist& bl, size_t len, uint64_t off) | |||
1186 | { | |||
1187 | object_t obj(oid); | |||
1188 | return io_ctx_impl->write(obj, bl, len, off); | |||
1189 | } | |||
1190 | ||||
1191 | int librados::IoCtx::append(const std::string& oid, bufferlist& bl, size_t len) | |||
1192 | { | |||
1193 | object_t obj(oid); | |||
1194 | return io_ctx_impl->append(obj, bl, len); | |||
1195 | } | |||
1196 | ||||
1197 | int librados::IoCtx::write_full(const std::string& oid, bufferlist& bl) | |||
1198 | { | |||
1199 | object_t obj(oid); | |||
1200 | return io_ctx_impl->write_full(obj, bl); | |||
1201 | } | |||
1202 | ||||
1203 | int librados::IoCtx::writesame(const std::string& oid, bufferlist& bl, | |||
1204 | size_t write_len, uint64_t off) | |||
1205 | { | |||
1206 | object_t obj(oid); | |||
1207 | return io_ctx_impl->writesame(obj, bl, write_len, off); | |||
1208 | } | |||
1209 | ||||
1210 | int librados::IoCtx::clone_range(const std::string& dst_oid, uint64_t dst_off, | |||
1211 | const std::string& src_oid, uint64_t src_off, | |||
1212 | size_t len) | |||
1213 | { | |||
1214 | object_t src(src_oid), dst(dst_oid); | |||
1215 | return io_ctx_impl->clone_range(dst, dst_off, src, src_off, len); | |||
1216 | } | |||
1217 | ||||
1218 | int librados::IoCtx::read(const std::string& oid, bufferlist& bl, size_t len, uint64_t off) | |||
1219 | { | |||
1220 | object_t obj(oid); | |||
1221 | return io_ctx_impl->read(obj, bl, len, off); | |||
1222 | } | |||
1223 | ||||
1224 | int librados::IoCtx::remove(const std::string& oid) | |||
1225 | { | |||
1226 | object_t obj(oid); | |||
1227 | return io_ctx_impl->remove(obj); | |||
1228 | } | |||
1229 | ||||
1230 | int librados::IoCtx::remove(const std::string& oid, int flags) | |||
1231 | { | |||
1232 | object_t obj(oid); | |||
1233 | return io_ctx_impl->remove(obj, flags); | |||
1234 | } | |||
1235 | ||||
1236 | int librados::IoCtx::trunc(const std::string& oid, uint64_t size) | |||
1237 | { | |||
1238 | object_t obj(oid); | |||
1239 | return io_ctx_impl->trunc(obj, size); | |||
1240 | } | |||
1241 | ||||
1242 | int librados::IoCtx::mapext(const std::string& oid, uint64_t off, size_t len, | |||
1243 | std::map<uint64_t,uint64_t>& m) | |||
1244 | { | |||
1245 | object_t obj(oid); | |||
1246 | return io_ctx_impl->mapext(obj, off, len, m); | |||
1247 | } | |||
1248 | ||||
1249 | int librados::IoCtx::sparse_read(const std::string& oid, std::map<uint64_t,uint64_t>& m, | |||
1250 | bufferlist& bl, size_t len, uint64_t off) | |||
1251 | { | |||
1252 | object_t obj(oid); | |||
1253 | return io_ctx_impl->sparse_read(obj, m, bl, len, off); | |||
1254 | } | |||
1255 | ||||
1256 | int librados::IoCtx::getxattr(const std::string& oid, const char *name, bufferlist& bl) | |||
1257 | { | |||
1258 | object_t obj(oid); | |||
1259 | return io_ctx_impl->getxattr(obj, name, bl); | |||
1260 | } | |||
1261 | ||||
1262 | int librados::IoCtx::getxattrs(const std::string& oid, map<std::string, bufferlist>& attrset) | |||
1263 | { | |||
1264 | object_t obj(oid); | |||
1265 | return io_ctx_impl->getxattrs(obj, attrset); | |||
1266 | } | |||
1267 | ||||
1268 | int librados::IoCtx::setxattr(const std::string& oid, const char *name, bufferlist& bl) | |||
1269 | { | |||
1270 | object_t obj(oid); | |||
1271 | return io_ctx_impl->setxattr(obj, name, bl); | |||
1272 | } | |||
1273 | ||||
1274 | int librados::IoCtx::rmxattr(const std::string& oid, const char *name) | |||
1275 | { | |||
1276 | object_t obj(oid); | |||
1277 | return io_ctx_impl->rmxattr(obj, name); | |||
1278 | } | |||
1279 | ||||
1280 | int librados::IoCtx::stat(const std::string& oid, uint64_t *psize, time_t *pmtime) | |||
1281 | { | |||
1282 | object_t obj(oid); | |||
1283 | return io_ctx_impl->stat(obj, psize, pmtime); | |||
1284 | } | |||
1285 | ||||
1286 | int librados::IoCtx::stat2(const std::string& oid, uint64_t *psize, struct timespec *pts) | |||
1287 | { | |||
1288 | object_t obj(oid); | |||
1289 | return io_ctx_impl->stat2(obj, psize, pts); | |||
1290 | } | |||
1291 | ||||
1292 | int librados::IoCtx::exec(const std::string& oid, const char *cls, const char *method, | |||
1293 | bufferlist& inbl, bufferlist& outbl) | |||
1294 | { | |||
1295 | object_t obj(oid); | |||
1296 | return io_ctx_impl->exec(obj, cls, method, inbl, outbl); | |||
1297 | } | |||
1298 | ||||
1299 | int librados::IoCtx::tmap_update(const std::string& oid, bufferlist& cmdbl) | |||
1300 | { | |||
1301 | object_t obj(oid); | |||
1302 | return io_ctx_impl->tmap_update(obj, cmdbl); | |||
1303 | } | |||
1304 | ||||
1305 | int librados::IoCtx::tmap_put(const std::string& oid, bufferlist& bl) | |||
1306 | { | |||
1307 | object_t obj(oid); | |||
1308 | return io_ctx_impl->tmap_put(obj, bl); | |||
1309 | } | |||
1310 | ||||
1311 | int librados::IoCtx::tmap_get(const std::string& oid, bufferlist& bl) | |||
1312 | { | |||
1313 | object_t obj(oid); | |||
1314 | return io_ctx_impl->tmap_get(obj, bl); | |||
1315 | } | |||
1316 | ||||
1317 | int librados::IoCtx::tmap_to_omap(const std::string& oid, bool nullok) | |||
1318 | { | |||
1319 | object_t obj(oid); | |||
1320 | return io_ctx_impl->tmap_to_omap(obj, nullok); | |||
1321 | } | |||
1322 | ||||
1323 | int librados::IoCtx::omap_get_vals(const std::string& oid, | |||
1324 | const std::string& start_after, | |||
1325 | uint64_t max_return, | |||
1326 | std::map<std::string, bufferlist> *out_vals) | |||
1327 | { | |||
1328 | ObjectReadOperation op; | |||
1329 | int r; | |||
1330 | op.omap_get_vals(start_after, max_return, out_vals, &r); | |||
1331 | bufferlist bl; | |||
1332 | int ret = operate(oid, &op, &bl); | |||
1333 | if (ret < 0) | |||
1334 | return ret; | |||
1335 | ||||
1336 | return r; | |||
1337 | } | |||
1338 | ||||
1339 | int librados::IoCtx::omap_get_keys(const std::string& oid, | |||
1340 | const std::string& start_after, | |||
1341 | uint64_t max_return, | |||
1342 | std::set<std::string> *out_keys) | |||
1343 | { | |||
1344 | ObjectReadOperation op; | |||
1345 | int r; | |||
1346 | op.omap_get_keys(start_after, max_return, out_keys, &r); | |||
1347 | bufferlist bl; | |||
1348 | int ret = operate(oid, &op, &bl); | |||
1349 | if (ret < 0) | |||
1350 | return ret; | |||
1351 | ||||
1352 | return r; | |||
1353 | } | |||
1354 | ||||
1355 | int librados::IoCtx::omap_get_header(const std::string& oid, | |||
1356 | bufferlist *bl) | |||
1357 | { | |||
1358 | ObjectReadOperation op; | |||
1359 | int r; | |||
1360 | op.omap_get_header(bl, &r); | |||
1361 | bufferlist b; | |||
1362 | int ret = operate(oid, &op, &b); | |||
1363 | if (ret < 0) | |||
1364 | return ret; | |||
1365 | ||||
1366 | return r; | |||
1367 | } | |||
1368 | ||||
1369 | int librados::IoCtx::omap_get_vals_by_keys(const std::string& oid, | |||
1370 | const std::set<std::string>& keys, | |||
1371 | std::map<std::string, bufferlist> *vals) | |||
1372 | { | |||
1373 | ObjectReadOperation op; | |||
1374 | int r; | |||
1375 | bufferlist bl; | |||
1376 | op.omap_get_vals_by_keys(keys, vals, &r); | |||
1377 | int ret = operate(oid, &op, &bl); | |||
1378 | if (ret < 0) | |||
1379 | return ret; | |||
1380 | ||||
1381 | return r; | |||
1382 | } | |||
1383 | ||||
1384 | int librados::IoCtx::omap_set(const std::string& oid, | |||
1385 | const map<string, bufferlist>& m) | |||
1386 | { | |||
1387 | ObjectWriteOperation op; | |||
1388 | op.omap_set(m); | |||
1389 | return operate(oid, &op); | |||
1390 | } | |||
1391 | ||||
1392 | int librados::IoCtx::omap_set_header(const std::string& oid, | |||
1393 | const bufferlist& bl) | |||
1394 | { | |||
1395 | ObjectWriteOperation op; | |||
1396 | op.omap_set_header(bl); | |||
1397 | return operate(oid, &op); | |||
1398 | } | |||
1399 | ||||
1400 | int librados::IoCtx::omap_clear(const std::string& oid) | |||
1401 | { | |||
1402 | ObjectWriteOperation op; | |||
1403 | op.omap_clear(); | |||
1404 | return operate(oid, &op); | |||
1405 | } | |||
1406 | ||||
1407 | int librados::IoCtx::omap_rm_keys(const std::string& oid, | |||
1408 | const std::set<std::string>& keys) | |||
1409 | { | |||
1410 | ObjectWriteOperation op; | |||
1411 | op.omap_rm_keys(keys); | |||
1412 | return operate(oid, &op); | |||
1413 | } | |||
1414 | ||||
1415 | ||||
1416 | ||||
1417 | static int translate_flags(int flags) | |||
1418 | { | |||
1419 | int op_flags = 0; | |||
1420 | if (flags & librados::OPERATION_BALANCE_READS) | |||
1421 | op_flags |= CEPH_OSD_FLAG_BALANCE_READS; | |||
1422 | if (flags & librados::OPERATION_LOCALIZE_READS) | |||
1423 | op_flags |= CEPH_OSD_FLAG_LOCALIZE_READS; | |||
1424 | if (flags & librados::OPERATION_ORDER_READS_WRITES) | |||
1425 | op_flags |= CEPH_OSD_FLAG_RWORDERED; | |||
1426 | if (flags & librados::OPERATION_IGNORE_CACHE) | |||
1427 | op_flags |= CEPH_OSD_FLAG_IGNORE_CACHE; | |||
1428 | if (flags & librados::OPERATION_SKIPRWLOCKS) | |||
1429 | op_flags |= CEPH_OSD_FLAG_SKIPRWLOCKS; | |||
1430 | if (flags & librados::OPERATION_IGNORE_OVERLAY) | |||
1431 | op_flags |= CEPH_OSD_FLAG_IGNORE_OVERLAY; | |||
1432 | if (flags & librados::OPERATION_FULL_TRY) | |||
1433 | op_flags |= CEPH_OSD_FLAG_FULL_TRY; | |||
1434 | if (flags & librados::OPERATION_FULL_FORCE) | |||
1435 | op_flags |= CEPH_OSD_FLAG_FULL_FORCE; | |||
1436 | ||||
1437 | return op_flags; | |||
1438 | } | |||
1439 | ||||
1440 | int librados::IoCtx::operate(const std::string& oid, librados::ObjectWriteOperation *o) | |||
1441 | { | |||
1442 | object_t obj(oid); | |||
1443 | return io_ctx_impl->operate(obj, &o->impl->o, (ceph::real_time *)o->impl->prt); | |||
1444 | } | |||
1445 | ||||
1446 | int librados::IoCtx::operate(const std::string& oid, librados::ObjectReadOperation *o, bufferlist *pbl) | |||
1447 | { | |||
1448 | object_t obj(oid); | |||
1449 | return io_ctx_impl->operate_read(obj, &o->impl->o, pbl); | |||
1450 | } | |||
1451 | ||||
1452 | int librados::IoCtx::aio_operate(const std::string& oid, AioCompletion *c, | |||
1453 | librados::ObjectWriteOperation *o) | |||
1454 | { | |||
1455 | object_t obj(oid); | |||
1456 | return io_ctx_impl->aio_operate(obj, &o->impl->o, c->pc, | |||
1457 | io_ctx_impl->snapc, 0); | |||
1458 | } | |||
1459 | int librados::IoCtx::aio_operate(const std::string& oid, AioCompletion *c, | |||
1460 | ObjectWriteOperation *o, int flags) | |||
1461 | { | |||
1462 | object_t obj(oid); | |||
1463 | return io_ctx_impl->aio_operate(obj, &o->impl->o, c->pc, | |||
1464 | io_ctx_impl->snapc, | |||
1465 | translate_flags(flags)); | |||
1466 | } | |||
1467 | ||||
1468 | int librados::IoCtx::aio_operate(const std::string& oid, AioCompletion *c, | |||
1469 | librados::ObjectWriteOperation *o, | |||
1470 | snap_t snap_seq, std::vector<snap_t>& snaps) | |||
1471 | { | |||
1472 | object_t obj(oid); | |||
1473 | vector<snapid_t> snv; | |||
1474 | snv.resize(snaps.size()); | |||
1475 | for (size_t i = 0; i < snaps.size(); ++i) | |||
1476 | snv[i] = snaps[i]; | |||
1477 | SnapContext snapc(snap_seq, snv); | |||
1478 | return io_ctx_impl->aio_operate(obj, &o->impl->o, c->pc, | |||
1479 | snapc, 0); | |||
1480 | } | |||
1481 | ||||
1482 | int librados::IoCtx::aio_operate(const std::string& oid, AioCompletion *c, | |||
1483 | librados::ObjectReadOperation *o, | |||
1484 | bufferlist *pbl) | |||
1485 | { | |||
1486 | object_t obj(oid); | |||
1487 | return io_ctx_impl->aio_operate_read(obj, &o->impl->o, c->pc, | |||
1488 | 0, pbl); | |||
1489 | } | |||
1490 | ||||
1491 | // deprecated | |||
1492 | int librados::IoCtx::aio_operate(const std::string& oid, AioCompletion *c, | |||
1493 | librados::ObjectReadOperation *o, | |||
1494 | snap_t snapid_unused_deprecated, | |||
1495 | int flags, bufferlist *pbl) | |||
1496 | { | |||
1497 | object_t obj(oid); | |||
1498 | int op_flags = 0; | |||
1499 | if (flags & OPERATION_BALANCE_READS) | |||
1500 | op_flags |= CEPH_OSD_FLAG_BALANCE_READS; | |||
1501 | if (flags & OPERATION_LOCALIZE_READS) | |||
1502 | op_flags |= CEPH_OSD_FLAG_LOCALIZE_READS; | |||
1503 | if (flags & OPERATION_ORDER_READS_WRITES) | |||
1504 | op_flags |= CEPH_OSD_FLAG_RWORDERED; | |||
1505 | ||||
1506 | return io_ctx_impl->aio_operate_read(obj, &o->impl->o, c->pc, | |||
1507 | op_flags, pbl); | |||
1508 | } | |||
1509 | ||||
1510 | int librados::IoCtx::aio_operate(const std::string& oid, AioCompletion *c, | |||
1511 | librados::ObjectReadOperation *o, | |||
1512 | int flags, bufferlist *pbl) | |||
1513 | { | |||
1514 | object_t obj(oid); | |||
1515 | return io_ctx_impl->aio_operate_read(obj, &o->impl->o, c->pc, | |||
1516 | translate_flags(flags), pbl); | |||
1517 | } | |||
1518 | ||||
1519 | ||||
1520 | void librados::IoCtx::snap_set_read(snap_t seq) | |||
1521 | { | |||
1522 | io_ctx_impl->set_snap_read(seq); | |||
1523 | } | |||
1524 | ||||
1525 | int librados::IoCtx::selfmanaged_snap_set_write_ctx(snap_t seq, vector<snap_t>& snaps) | |||
1526 | { | |||
1527 | vector<snapid_t> snv; | |||
1528 | snv.resize(snaps.size()); | |||
1529 | for (unsigned i=0; i<snaps.size(); i++) | |||
1530 | snv[i] = snaps[i]; | |||
1531 | return io_ctx_impl->set_snap_write_context(seq, snv); | |||
1532 | } | |||
1533 | ||||
1534 | int librados::IoCtx::snap_create(const char *snapname) | |||
1535 | { | |||
1536 | return io_ctx_impl->snap_create(snapname); | |||
1537 | } | |||
1538 | ||||
1539 | int librados::IoCtx::snap_lookup(const char *name, snap_t *snapid) | |||
1540 | { | |||
1541 | return io_ctx_impl->snap_lookup(name, snapid); | |||
1542 | } | |||
1543 | ||||
1544 | int librados::IoCtx::snap_get_stamp(snap_t snapid, time_t *t) | |||
1545 | { | |||
1546 | return io_ctx_impl->snap_get_stamp(snapid, t); | |||
1547 | } | |||
1548 | ||||
1549 | int librados::IoCtx::snap_get_name(snap_t snapid, std::string *s) | |||
1550 | { | |||
1551 | return io_ctx_impl->snap_get_name(snapid, s); | |||
1552 | } | |||
1553 | ||||
1554 | int librados::IoCtx::snap_remove(const char *snapname) | |||
1555 | { | |||
1556 | return io_ctx_impl->snap_remove(snapname); | |||
1557 | } | |||
1558 | ||||
1559 | int librados::IoCtx::snap_list(std::vector<snap_t> *snaps) | |||
1560 | { | |||
1561 | return io_ctx_impl->snap_list(snaps); | |||
1562 | } | |||
1563 | ||||
1564 | int librados::IoCtx::snap_rollback(const std::string& oid, const char *snapname) | |||
1565 | { | |||
1566 | return io_ctx_impl->rollback(oid, snapname); | |||
1567 | } | |||
1568 | ||||
1569 | // Deprecated name kept for backward compatibility | |||
1570 | int librados::IoCtx::rollback(const std::string& oid, const char *snapname) | |||
1571 | { | |||
1572 | return snap_rollback(oid, snapname); | |||
1573 | } | |||
1574 | ||||
1575 | int librados::IoCtx::selfmanaged_snap_create(uint64_t *snapid) | |||
1576 | { | |||
1577 | return io_ctx_impl->selfmanaged_snap_create(snapid); | |||
1578 | } | |||
1579 | ||||
1580 | int librados::IoCtx::selfmanaged_snap_remove(uint64_t snapid) | |||
1581 | { | |||
1582 | return io_ctx_impl->selfmanaged_snap_remove(snapid); | |||
1583 | } | |||
1584 | ||||
1585 | int librados::IoCtx::selfmanaged_snap_rollback(const std::string& oid, uint64_t snapid) | |||
1586 | { | |||
1587 | return io_ctx_impl->selfmanaged_snap_rollback_object(oid, | |||
1588 | io_ctx_impl->snapc, | |||
1589 | snapid); | |||
1590 | } | |||
1591 | ||||
1592 | int librados::IoCtx::lock_exclusive(const std::string &oid, const std::string &name, | |||
1593 | const std::string &cookie, | |||
1594 | const std::string &description, | |||
1595 | struct timeval * duration, uint8_t flags) | |||
1596 | { | |||
1597 | utime_t dur = utime_t(); | |||
1598 | if (duration) | |||
1599 | dur.set_from_timeval(duration); | |||
1600 | ||||
1601 | return rados::cls::lock::lock(this, oid, name, LOCK_EXCLUSIVE, cookie, "", | |||
1602 | description, dur, flags); | |||
1603 | } | |||
1604 | ||||
1605 | int librados::IoCtx::lock_shared(const std::string &oid, const std::string &name, | |||
1606 | const std::string &cookie, const std::string &tag, | |||
1607 | const std::string &description, | |||
1608 | struct timeval * duration, uint8_t flags) | |||
1609 | { | |||
1610 | utime_t dur = utime_t(); | |||
1611 | if (duration) | |||
1612 | dur.set_from_timeval(duration); | |||
1613 | ||||
1614 | return rados::cls::lock::lock(this, oid, name, LOCK_SHARED, cookie, tag, | |||
1615 | description, dur, flags); | |||
1616 | } | |||
1617 | ||||
1618 | int librados::IoCtx::unlock(const std::string &oid, const std::string &name, | |||
1619 | const std::string &cookie) | |||
1620 | { | |||
1621 | return rados::cls::lock::unlock(this, oid, name, cookie); | |||
1622 | } | |||
1623 | ||||
1624 | struct AioUnlockCompletion : public librados::ObjectOperationCompletion { | |||
1625 | librados::AioCompletionImpl *completion; | |||
1626 | AioUnlockCompletion(librados::AioCompletion *c) : completion(c->pc) { | |||
1627 | completion->get(); | |||
1628 | }; | |||
1629 | void handle_completion(int r, bufferlist& outbl) { | |||
1630 | rados_callback_t cb = completion->callback_complete; | |||
1631 | void *cb_arg = completion->callback_complete_arg; | |||
1632 | cb(completion, cb_arg); | |||
1633 | completion->lock.Lock(); | |||
1634 | completion->callback_complete = NULL__null; | |||
1635 | completion->cond.Signal(); | |||
1636 | completion->put_unlock(); | |||
1637 | } | |||
1638 | }; | |||
1639 | ||||
1640 | int librados::IoCtx::aio_unlock(const std::string &oid, const std::string &name, | |||
1641 | const std::string &cookie, AioCompletion *c) | |||
1642 | { | |||
1643 | return rados::cls::lock::aio_unlock(this, oid, name, cookie, c); | |||
1644 | } | |||
1645 | ||||
1646 | int librados::IoCtx::break_lock(const std::string &oid, const std::string &name, | |||
1647 | const std::string &client, const std::string &cookie) | |||
1648 | { | |||
1649 | entity_name_t locker; | |||
1650 | if (!locker.parse(client)) | |||
1651 | return -EINVAL22; | |||
1652 | return rados::cls::lock::break_lock(this, oid, name, cookie, locker); | |||
1653 | } | |||
1654 | ||||
1655 | int librados::IoCtx::list_lockers(const std::string &oid, const std::string &name, | |||
1656 | int *exclusive, | |||
1657 | std::string *tag, | |||
1658 | std::list<librados::locker_t> *lockers) | |||
1659 | { | |||
1660 | std::list<librados::locker_t> tmp_lockers; | |||
1661 | map<rados::cls::lock::locker_id_t, rados::cls::lock::locker_info_t> rados_lockers; | |||
1662 | std::string tmp_tag; | |||
1663 | ClsLockType tmp_type; | |||
1664 | int r = rados::cls::lock::get_lock_info(this, oid, name, &rados_lockers, &tmp_type, &tmp_tag); | |||
1665 | if (r < 0) | |||
1666 | return r; | |||
1667 | ||||
1668 | map<rados::cls::lock::locker_id_t, rados::cls::lock::locker_info_t>::iterator map_it; | |||
1669 | for (map_it = rados_lockers.begin(); map_it != rados_lockers.end(); ++map_it) { | |||
1670 | librados::locker_t locker; | |||
1671 | locker.client = stringify(map_it->first.locker); | |||
1672 | locker.cookie = map_it->first.cookie; | |||
1673 | locker.address = stringify(map_it->second.addr); | |||
1674 | tmp_lockers.push_back(locker); | |||
1675 | } | |||
1676 | ||||
1677 | if (lockers) | |||
1678 | *lockers = tmp_lockers; | |||
1679 | if (tag) | |||
1680 | *tag = tmp_tag; | |||
1681 | if (exclusive) { | |||
1682 | if (tmp_type == LOCK_EXCLUSIVE) | |||
1683 | *exclusive = 1; | |||
1684 | else | |||
1685 | *exclusive = 0; | |||
1686 | } | |||
1687 | ||||
1688 | return tmp_lockers.size(); | |||
1689 | } | |||
1690 | ||||
1691 | librados::NObjectIterator librados::IoCtx::nobjects_begin() | |||
1692 | { | |||
1693 | bufferlist bl; | |||
1694 | return nobjects_begin(bl); | |||
1695 | } | |||
1696 | ||||
1697 | librados::NObjectIterator librados::IoCtx::nobjects_begin( | |||
1698 | const bufferlist &filter) | |||
1699 | { | |||
1700 | rados_list_ctx_t listh; | |||
1701 | rados_nobjects_list_open(io_ctx_impl, &listh); | |||
1702 | NObjectIterator iter((ObjListCtx*)listh); | |||
1703 | if (filter.length() > 0) { | |||
1704 | iter.set_filter(filter); | |||
1705 | } | |||
1706 | iter.get_next(); | |||
1707 | return iter; | |||
1708 | } | |||
1709 | ||||
1710 | librados::NObjectIterator librados::IoCtx::nobjects_begin(uint32_t pos) | |||
1711 | { | |||
1712 | bufferlist bl; | |||
1713 | return nobjects_begin(pos, bl); | |||
1714 | } | |||
1715 | ||||
1716 | librados::NObjectIterator librados::IoCtx::nobjects_begin( | |||
1717 | uint32_t pos, const bufferlist &filter) | |||
1718 | { | |||
1719 | rados_list_ctx_t listh; | |||
1720 | rados_nobjects_list_open(io_ctx_impl, &listh); | |||
1721 | NObjectIterator iter((ObjListCtx*)listh); | |||
1722 | if (filter.length() > 0) { | |||
1723 | iter.set_filter(filter); | |||
1724 | } | |||
1725 | iter.seek(pos); | |||
1726 | return iter; | |||
1727 | } | |||
1728 | ||||
1729 | const librados::NObjectIterator& librados::IoCtx::nobjects_end() const | |||
1730 | { | |||
1731 | return NObjectIterator::__EndObjectIterator; | |||
1732 | } | |||
1733 | ||||
1734 | // DEPRECATED; use n versions above | |||
1735 | librados::ObjectIterator librados::IoCtx::objects_begin() | |||
1736 | { | |||
1737 | rados_list_ctx_t listh; | |||
1738 | if (io_ctx_impl->oloc.nspace == librados::all_nspaces) { | |||
1739 | ostringstream oss; | |||
1740 | oss << "rados returned " << cpp_strerror(-EINVAL22); | |||
1741 | throw std::runtime_error(oss.str()); | |||
1742 | } | |||
1743 | rados_objects_list_open(io_ctx_impl, &listh); | |||
1744 | ObjectIterator iter((ObjListCtx*)listh); | |||
1745 | iter.get_next(); | |||
1746 | return iter; | |||
1747 | } | |||
1748 | ||||
1749 | librados::ObjectIterator librados::IoCtx::objects_begin(uint32_t pos) | |||
1750 | { | |||
1751 | rados_list_ctx_t listh; | |||
1752 | if (io_ctx_impl->oloc.nspace == librados::all_nspaces) { | |||
1753 | ostringstream oss; | |||
1754 | oss << "rados returned " << cpp_strerror(-EINVAL22); | |||
1755 | throw std::runtime_error(oss.str()); | |||
1756 | } | |||
1757 | rados_objects_list_open(io_ctx_impl, &listh); | |||
1758 | ObjectIterator iter((ObjListCtx*)listh); | |||
1759 | iter.seek(pos); | |||
1760 | return iter; | |||
1761 | } | |||
1762 | ||||
1763 | const librados::ObjectIterator& librados::IoCtx::objects_end() const | |||
1764 | { | |||
1765 | return ObjectIterator::__EndObjectIterator; | |||
1766 | } | |||
1767 | ||||
1768 | int librados::IoCtx::hit_set_list(uint32_t hash, AioCompletion *c, | |||
1769 | std::list< std::pair<time_t, time_t> > *pls) | |||
1770 | { | |||
1771 | return io_ctx_impl->hit_set_list(hash, c->pc, pls); | |||
1772 | } | |||
1773 | ||||
1774 | int librados::IoCtx::hit_set_get(uint32_t hash, AioCompletion *c, time_t stamp, | |||
1775 | bufferlist *pbl) | |||
1776 | { | |||
1777 | return io_ctx_impl->hit_set_get(hash, c->pc, stamp, pbl); | |||
1778 | } | |||
1779 | ||||
1780 | ||||
1781 | ||||
1782 | uint64_t librados::IoCtx::get_last_version() | |||
1783 | { | |||
1784 | return io_ctx_impl->last_version(); | |||
1785 | } | |||
1786 | ||||
1787 | int librados::IoCtx::aio_read(const std::string& oid, librados::AioCompletion *c, | |||
1788 | bufferlist *pbl, size_t len, uint64_t off) | |||
1789 | { | |||
1790 | return io_ctx_impl->aio_read(oid, c->pc, pbl, len, off, | |||
1791 | io_ctx_impl->snap_seq); | |||
1792 | } | |||
1793 | ||||
1794 | int librados::IoCtx::aio_read(const std::string& oid, librados::AioCompletion *c, | |||
1795 | bufferlist *pbl, size_t len, uint64_t off, | |||
1796 | uint64_t snapid) | |||
1797 | { | |||
1798 | return io_ctx_impl->aio_read(oid, c->pc, pbl, len, off, snapid); | |||
1799 | } | |||
1800 | ||||
1801 | int librados::IoCtx::aio_exec(const std::string& oid, | |||
1802 | librados::AioCompletion *c, const char *cls, | |||
1803 | const char *method, bufferlist& inbl, | |||
1804 | bufferlist *outbl) | |||
1805 | { | |||
1806 | object_t obj(oid); | |||
1807 | return io_ctx_impl->aio_exec(obj, c->pc, cls, method, inbl, outbl); | |||
1808 | } | |||
1809 | ||||
1810 | int librados::IoCtx::aio_sparse_read(const std::string& oid, librados::AioCompletion *c, | |||
1811 | std::map<uint64_t,uint64_t> *m, bufferlist *data_bl, | |||
1812 | size_t len, uint64_t off) | |||
1813 | { | |||
1814 | return io_ctx_impl->aio_sparse_read(oid, c->pc, | |||
1815 | m, data_bl, len, off, | |||
1816 | io_ctx_impl->snap_seq); | |||
1817 | } | |||
1818 | ||||
1819 | int librados::IoCtx::aio_sparse_read(const std::string& oid, librados::AioCompletion *c, | |||
1820 | std::map<uint64_t,uint64_t> *m, bufferlist *data_bl, | |||
1821 | size_t len, uint64_t off, uint64_t snapid) | |||
1822 | { | |||
1823 | return io_ctx_impl->aio_sparse_read(oid, c->pc, | |||
1824 | m, data_bl, len, off, snapid); | |||
1825 | } | |||
1826 | ||||
1827 | int librados::IoCtx::aio_write(const std::string& oid, librados::AioCompletion *c, | |||
1828 | const bufferlist& bl, size_t len, uint64_t off) | |||
1829 | { | |||
1830 | return io_ctx_impl->aio_write(oid, c->pc, bl, len, off); | |||
1831 | } | |||
1832 | ||||
1833 | int librados::IoCtx::aio_append(const std::string& oid, librados::AioCompletion *c, | |||
1834 | const bufferlist& bl, size_t len) | |||
1835 | { | |||
1836 | return io_ctx_impl->aio_append(oid, c->pc, bl, len); | |||
1837 | } | |||
1838 | ||||
1839 | int librados::IoCtx::aio_write_full(const std::string& oid, librados::AioCompletion *c, | |||
1840 | const bufferlist& bl) | |||
1841 | { | |||
1842 | object_t obj(oid); | |||
1843 | return io_ctx_impl->aio_write_full(obj, c->pc, bl); | |||
1844 | } | |||
1845 | ||||
1846 | int librados::IoCtx::aio_writesame(const std::string& oid, librados::AioCompletion *c, | |||
1847 | const bufferlist& bl, size_t write_len, | |||
1848 | uint64_t off) | |||
1849 | { | |||
1850 | return io_ctx_impl->aio_writesame(oid, c->pc, bl, write_len, off); | |||
1851 | } | |||
1852 | ||||
1853 | ||||
1854 | int librados::IoCtx::aio_remove(const std::string& oid, librados::AioCompletion *c) | |||
1855 | { | |||
1856 | return io_ctx_impl->aio_remove(oid, c->pc); | |||
1857 | } | |||
1858 | ||||
1859 | int librados::IoCtx::aio_remove(const std::string& oid, librados::AioCompletion *c, int flags) | |||
1860 | { | |||
1861 | return io_ctx_impl->aio_remove(oid, c->pc, flags); | |||
1862 | } | |||
1863 | ||||
1864 | int librados::IoCtx::aio_flush_async(librados::AioCompletion *c) | |||
1865 | { | |||
1866 | io_ctx_impl->flush_aio_writes_async(c->pc); | |||
1867 | return 0; | |||
1868 | } | |||
1869 | ||||
1870 | int librados::IoCtx::aio_flush() | |||
1871 | { | |||
1872 | io_ctx_impl->flush_aio_writes(); | |||
1873 | return 0; | |||
1874 | } | |||
1875 | ||||
1876 | struct AioGetxattrDataPP { | |||
1877 | AioGetxattrDataPP(librados::AioCompletionImpl *c, bufferlist *_bl) : | |||
1878 | bl(_bl), completion(c) {} | |||
1879 | bufferlist *bl; | |||
1880 | struct librados::C_AioCompleteAndSafe completion; | |||
1881 | }; | |||
1882 | ||||
1883 | static void rados_aio_getxattr_completepp(rados_completion_t c, void *arg) { | |||
1884 | AioGetxattrDataPP *cdata = reinterpret_cast<AioGetxattrDataPP*>(arg); | |||
1885 | int rc = rados_aio_get_return_value(c); | |||
1886 | if (rc >= 0) { | |||
1887 | rc = cdata->bl->length(); | |||
1888 | } | |||
1889 | cdata->completion.finish(rc); | |||
1890 | delete cdata; | |||
1891 | } | |||
1892 | ||||
1893 | int librados::IoCtx::aio_getxattr(const std::string& oid, librados::AioCompletion *c, | |||
1894 | const char *name, bufferlist& bl) | |||
1895 | { | |||
1896 | // create data object to be passed to async callback | |||
1897 | AioGetxattrDataPP *cdata = new AioGetxattrDataPP(c->pc, &bl); | |||
1898 | if (!cdata) { | |||
1899 | return -ENOMEM12; | |||
1900 | } | |||
1901 | // create completion callback | |||
1902 | librados::AioCompletionImpl *comp = new librados::AioCompletionImpl; | |||
1903 | comp->set_complete_callback(cdata, rados_aio_getxattr_completepp); | |||
1904 | // call actual getxattr from IoCtxImpl | |||
1905 | object_t obj(oid); | |||
1906 | return io_ctx_impl->aio_getxattr(obj, comp, name, bl); | |||
1907 | } | |||
1908 | ||||
1909 | int librados::IoCtx::aio_getxattrs(const std::string& oid, AioCompletion *c, | |||
1910 | map<std::string, bufferlist>& attrset) | |||
1911 | { | |||
1912 | object_t obj(oid); | |||
1913 | return io_ctx_impl->aio_getxattrs(obj, c->pc, attrset); | |||
1914 | } | |||
1915 | ||||
1916 | int librados::IoCtx::aio_setxattr(const std::string& oid, AioCompletion *c, | |||
1917 | const char *name, bufferlist& bl) | |||
1918 | { | |||
1919 | object_t obj(oid); | |||
1920 | return io_ctx_impl->aio_setxattr(obj, c->pc, name, bl); | |||
1921 | } | |||
1922 | ||||
1923 | int librados::IoCtx::aio_rmxattr(const std::string& oid, AioCompletion *c, | |||
1924 | const char *name) | |||
1925 | { | |||
1926 | object_t obj(oid); | |||
1927 | return io_ctx_impl->aio_rmxattr(obj, c->pc, name); | |||
1928 | } | |||
1929 | ||||
1930 | int librados::IoCtx::aio_stat(const std::string& oid, librados::AioCompletion *c, | |||
1931 | uint64_t *psize, time_t *pmtime) | |||
1932 | { | |||
1933 | object_t obj(oid); | |||
1934 | return io_ctx_impl->aio_stat(obj, c->pc, psize, pmtime); | |||
1935 | } | |||
1936 | ||||
1937 | int librados::IoCtx::aio_cancel(librados::AioCompletion *c) | |||
1938 | { | |||
1939 | return io_ctx_impl->aio_cancel(c->pc); | |||
1940 | } | |||
1941 | ||||
1942 | int librados::IoCtx::watch(const string& oid, uint64_t ver, uint64_t *cookie, | |||
1943 | librados::WatchCtx *ctx) | |||
1944 | { | |||
1945 | object_t obj(oid); | |||
1946 | return io_ctx_impl->watch(obj, cookie, ctx, NULL__null); | |||
1947 | } | |||
1948 | ||||
1949 | int librados::IoCtx::watch2(const string& oid, uint64_t *cookie, | |||
1950 | librados::WatchCtx2 *ctx2) | |||
1951 | { | |||
1952 | object_t obj(oid); | |||
1953 | return io_ctx_impl->watch(obj, cookie, NULL__null, ctx2); | |||
1954 | } | |||
1955 | ||||
1956 | int librados::IoCtx::watch3(const string& oid, uint64_t *cookie, | |||
1957 | librados::WatchCtx2 *ctx2, uint32_t timeout) | |||
1958 | { | |||
1959 | object_t obj(oid); | |||
1960 | return io_ctx_impl->watch(obj, cookie, NULL__null, ctx2, timeout); | |||
1961 | } | |||
1962 | ||||
1963 | int librados::IoCtx::aio_watch(const string& oid, AioCompletion *c, | |||
1964 | uint64_t *cookie, | |||
1965 | librados::WatchCtx2 *ctx2) | |||
1966 | { | |||
1967 | object_t obj(oid); | |||
1968 | return io_ctx_impl->aio_watch(obj, c->pc, cookie, NULL__null, ctx2); | |||
1969 | } | |||
1970 | ||||
1971 | int librados::IoCtx::aio_watch2(const string& oid, AioCompletion *c, | |||
1972 | uint64_t *cookie, | |||
1973 | librados::WatchCtx2 *ctx2, | |||
1974 | uint32_t timeout) | |||
1975 | { | |||
1976 | object_t obj(oid); | |||
1977 | return io_ctx_impl->aio_watch(obj, c->pc, cookie, NULL__null, ctx2, timeout); | |||
1978 | } | |||
1979 | ||||
1980 | int librados::IoCtx::unwatch(const string& oid, uint64_t handle) | |||
1981 | { | |||
1982 | return io_ctx_impl->unwatch(handle); | |||
1983 | } | |||
1984 | ||||
1985 | int librados::IoCtx::unwatch2(uint64_t handle) | |||
1986 | { | |||
1987 | return io_ctx_impl->unwatch(handle); | |||
1988 | } | |||
1989 | ||||
1990 | int librados::IoCtx::aio_unwatch(uint64_t handle, AioCompletion *c) | |||
1991 | { | |||
1992 | return io_ctx_impl->aio_unwatch(handle, c->pc); | |||
1993 | } | |||
1994 | ||||
1995 | int librados::IoCtx::watch_check(uint64_t handle) | |||
1996 | { | |||
1997 | return io_ctx_impl->watch_check(handle); | |||
1998 | } | |||
1999 | ||||
2000 | int librados::IoCtx::notify(const string& oid, uint64_t ver, bufferlist& bl) | |||
2001 | { | |||
2002 | object_t obj(oid); | |||
2003 | return io_ctx_impl->notify(obj, bl, 0, NULL__null, NULL__null, NULL__null); | |||
2004 | } | |||
2005 | ||||
2006 | int librados::IoCtx::notify2(const string& oid, bufferlist& bl, | |||
2007 | uint64_t timeout_ms, bufferlist *preplybl) | |||
2008 | { | |||
2009 | object_t obj(oid); | |||
2010 | return io_ctx_impl->notify(obj, bl, timeout_ms, preplybl, NULL__null, NULL__null); | |||
2011 | } | |||
2012 | ||||
2013 | int librados::IoCtx::aio_notify(const string& oid, AioCompletion *c, | |||
2014 | bufferlist& bl, uint64_t timeout_ms, | |||
2015 | bufferlist *preplybl) | |||
2016 | { | |||
2017 | object_t obj(oid); | |||
2018 | return io_ctx_impl->aio_notify(obj, c->pc, bl, timeout_ms, preplybl, NULL__null, | |||
2019 | NULL__null); | |||
2020 | } | |||
2021 | ||||
2022 | void librados::IoCtx::notify_ack(const std::string& o, | |||
2023 | uint64_t notify_id, uint64_t handle, | |||
2024 | bufferlist& bl) | |||
2025 | { | |||
2026 | io_ctx_impl->notify_ack(o, notify_id, handle, bl); | |||
2027 | } | |||
2028 | ||||
2029 | int librados::IoCtx::list_watchers(const std::string& oid, | |||
2030 | std::list<obj_watch_t> *out_watchers) | |||
2031 | { | |||
2032 | ObjectReadOperation op; | |||
2033 | int r; | |||
2034 | op.list_watchers(out_watchers, &r); | |||
2035 | bufferlist bl; | |||
2036 | int ret = operate(oid, &op, &bl); | |||
2037 | if (ret < 0) | |||
2038 | return ret; | |||
2039 | ||||
2040 | return r; | |||
2041 | } | |||
2042 | ||||
2043 | int librados::IoCtx::list_snaps(const std::string& oid, | |||
2044 | snap_set_t *out_snaps) | |||
2045 | { | |||
2046 | ObjectReadOperation op; | |||
2047 | int r; | |||
2048 | if (io_ctx_impl->snap_seq != CEPH_SNAPDIR((__u64)(-1))) | |||
2049 | return -EINVAL22; | |||
2050 | op.list_snaps(out_snaps, &r); | |||
2051 | bufferlist bl; | |||
2052 | int ret = operate(oid, &op, &bl); | |||
2053 | if (ret < 0) | |||
2054 | return ret; | |||
2055 | ||||
2056 | return r; | |||
2057 | } | |||
2058 | ||||
2059 | void librados::IoCtx::set_notify_timeout(uint32_t timeout) | |||
2060 | { | |||
2061 | io_ctx_impl->set_notify_timeout(timeout); | |||
2062 | } | |||
2063 | ||||
2064 | int librados::IoCtx::set_alloc_hint(const std::string& o, | |||
2065 | uint64_t expected_object_size, | |||
2066 | uint64_t expected_write_size) | |||
2067 | { | |||
2068 | object_t oid(o); | |||
2069 | return io_ctx_impl->set_alloc_hint(oid, expected_object_size, | |||
2070 | expected_write_size, 0); | |||
2071 | } | |||
2072 | ||||
2073 | int librados::IoCtx::set_alloc_hint2(const std::string& o, | |||
2074 | uint64_t expected_object_size, | |||
2075 | uint64_t expected_write_size, | |||
2076 | uint32_t flags) | |||
2077 | { | |||
2078 | object_t oid(o); | |||
2079 | return io_ctx_impl->set_alloc_hint(oid, expected_object_size, | |||
2080 | expected_write_size, flags); | |||
2081 | } | |||
2082 | ||||
2083 | void librados::IoCtx::set_assert_version(uint64_t ver) | |||
2084 | { | |||
2085 | io_ctx_impl->set_assert_version(ver); | |||
2086 | } | |||
2087 | ||||
2088 | void librados::IoCtx::set_assert_src_version(const std::string& oid, uint64_t ver) | |||
2089 | { | |||
2090 | object_t obj(oid); | |||
2091 | io_ctx_impl->set_assert_src_version(obj, ver); | |||
2092 | } | |||
2093 | ||||
2094 | int librados::IoCtx::cache_pin(const string& oid) | |||
2095 | { | |||
2096 | object_t obj(oid); | |||
2097 | return io_ctx_impl->cache_pin(obj); | |||
2098 | } | |||
2099 | ||||
2100 | int librados::IoCtx::cache_unpin(const string& oid) | |||
2101 | { | |||
2102 | object_t obj(oid); | |||
2103 | return io_ctx_impl->cache_unpin(obj); | |||
2104 | } | |||
2105 | ||||
2106 | void librados::IoCtx::locator_set_key(const string& key) | |||
2107 | { | |||
2108 | io_ctx_impl->oloc.key = key; | |||
2109 | } | |||
2110 | ||||
2111 | void librados::IoCtx::set_namespace(const string& nspace) | |||
2112 | { | |||
2113 | io_ctx_impl->oloc.nspace = nspace; | |||
2114 | } | |||
2115 | ||||
2116 | int64_t librados::IoCtx::get_id() | |||
2117 | { | |||
2118 | return io_ctx_impl->get_id(); | |||
2119 | } | |||
2120 | ||||
2121 | uint32_t librados::IoCtx::get_object_hash_position(const std::string& oid) | |||
2122 | { | |||
2123 | uint32_t hash; | |||
2124 | int r = io_ctx_impl->get_object_hash_position(oid, &hash); | |||
2125 | if (r < 0) | |||
2126 | hash = 0; | |||
2127 | return hash; | |||
2128 | } | |||
2129 | ||||
2130 | uint32_t librados::IoCtx::get_object_pg_hash_position(const std::string& oid) | |||
2131 | { | |||
2132 | uint32_t hash; | |||
2133 | int r = io_ctx_impl->get_object_pg_hash_position(oid, &hash); | |||
2134 | if (r < 0) | |||
2135 | hash = 0; | |||
2136 | return hash; | |||
2137 | } | |||
2138 | ||||
2139 | int librados::IoCtx::get_object_hash_position2( | |||
2140 | const std::string& oid, uint32_t *hash_position) | |||
2141 | { | |||
2142 | return io_ctx_impl->get_object_hash_position(oid, hash_position); | |||
2143 | } | |||
2144 | ||||
2145 | int librados::IoCtx::get_object_pg_hash_position2( | |||
2146 | const std::string& oid, uint32_t *pg_hash_position) | |||
2147 | { | |||
2148 | return io_ctx_impl->get_object_pg_hash_position(oid, pg_hash_position); | |||
2149 | } | |||
2150 | ||||
2151 | librados::config_t librados::IoCtx::cct() | |||
2152 | { | |||
2153 | return (config_t)io_ctx_impl->client->cct; | |||
2154 | } | |||
2155 | ||||
2156 | librados::IoCtx::IoCtx(IoCtxImpl *io_ctx_impl_) | |||
2157 | : io_ctx_impl(io_ctx_impl_) | |||
2158 | { | |||
2159 | } | |||
2160 | ||||
2161 | ///////////////////////////// Rados ////////////////////////////// | |||
2162 | void librados::Rados::version(int *major, int *minor, int *extra) | |||
2163 | { | |||
2164 | rados_version(major, minor, extra); | |||
2165 | } | |||
2166 | ||||
2167 | librados::Rados::Rados() : client(NULL__null) | |||
2168 | { | |||
2169 | } | |||
2170 | ||||
2171 | librados::Rados::Rados(IoCtx &ioctx) | |||
2172 | { | |||
2173 | client = ioctx.io_ctx_impl->client; | |||
2174 | assert(client != NULL)((client != __null) ? static_cast<void> (0) : __ceph_assert_fail ("client != __null", "/home/brad/working/src/ceph/src/librados/librados.cc" , 2174, __PRETTY_FUNCTION__)); | |||
2175 | client->get(); | |||
2176 | } | |||
2177 | ||||
2178 | librados::Rados::~Rados() | |||
2179 | { | |||
2180 | shutdown(); | |||
2181 | } | |||
2182 | ||||
2183 | int librados::Rados::init(const char * const id) | |||
2184 | { | |||
2185 | return rados_create((rados_t *)&client, id); | |||
2186 | } | |||
2187 | ||||
2188 | int librados::Rados::init2(const char * const name, | |||
2189 | const char * const clustername, uint64_t flags) | |||
2190 | { | |||
2191 | return rados_create2((rados_t *)&client, clustername, name, flags); | |||
2192 | } | |||
2193 | ||||
2194 | int librados::Rados::init_with_context(config_t cct_) | |||
2195 | { | |||
2196 | return rados_create_with_context((rados_t *)&client, (rados_config_t)cct_); | |||
2197 | } | |||
2198 | ||||
2199 | int librados::Rados::connect() | |||
2200 | { | |||
2201 | return client->connect(); | |||
2202 | } | |||
2203 | ||||
2204 | librados::config_t librados::Rados::cct() | |||
2205 | { | |||
2206 | return (config_t)client->cct; | |||
2207 | } | |||
2208 | ||||
2209 | int librados::Rados::watch_flush() | |||
2210 | { | |||
2211 | if (!client) | |||
2212 | return -EINVAL22; | |||
2213 | return client->watch_flush(); | |||
2214 | } | |||
2215 | ||||
2216 | int librados::Rados::aio_watch_flush(AioCompletion *c) | |||
2217 | { | |||
2218 | if (!client) | |||
2219 | return -EINVAL22; | |||
2220 | return client->async_watch_flush(c->pc); | |||
2221 | } | |||
2222 | ||||
2223 | void librados::Rados::shutdown() | |||
2224 | { | |||
2225 | if (!client) | |||
2226 | return; | |||
2227 | if (client->put()) { | |||
2228 | client->shutdown(); | |||
2229 | delete client; | |||
2230 | client = NULL__null; | |||
2231 | } | |||
2232 | } | |||
2233 | ||||
2234 | uint64_t librados::Rados::get_instance_id() | |||
2235 | { | |||
2236 | return client->get_instance_id(); | |||
2237 | } | |||
2238 | ||||
2239 | int librados::Rados::conf_read_file(const char * const path) const | |||
2240 | { | |||
2241 | return rados_conf_read_file((rados_t)client, path); | |||
2242 | } | |||
2243 | ||||
2244 | int librados::Rados::conf_parse_argv(int argc, const char ** argv) const | |||
2245 | { | |||
2246 | return rados_conf_parse_argv((rados_t)client, argc, argv); | |||
2247 | } | |||
2248 | ||||
2249 | int librados::Rados::conf_parse_argv_remainder(int argc, const char ** argv, | |||
2250 | const char ** remargv) const | |||
2251 | { | |||
2252 | return rados_conf_parse_argv_remainder((rados_t)client, argc, argv, remargv); | |||
2253 | } | |||
2254 | ||||
2255 | int librados::Rados::conf_parse_env(const char *name) const | |||
2256 | { | |||
2257 | return rados_conf_parse_env((rados_t)client, name); | |||
2258 | } | |||
2259 | ||||
2260 | int librados::Rados::conf_set(const char *option, const char *value) | |||
2261 | { | |||
2262 | return rados_conf_set((rados_t)client, option, value); | |||
2263 | } | |||
2264 | ||||
2265 | int librados::Rados::conf_get(const char *option, std::string &val) | |||
2266 | { | |||
2267 | char *str = NULL__null; | |||
2268 | md_config_t *conf = client->cct->_conf; | |||
2269 | int ret = conf->get_val(option, &str, -1); | |||
2270 | if (ret) { | |||
2271 | free(str); | |||
2272 | return ret; | |||
2273 | } | |||
2274 | val = str; | |||
2275 | free(str); | |||
2276 | return 0; | |||
2277 | } | |||
2278 | ||||
2279 | int librados::Rados::pool_create(const char *name) | |||
2280 | { | |||
2281 | string str(name); | |||
2282 | return client->pool_create(str); | |||
2283 | } | |||
2284 | ||||
2285 | int librados::Rados::pool_create(const char *name, uint64_t auid) | |||
2286 | { | |||
2287 | string str(name); | |||
2288 | return client->pool_create(str, auid); | |||
2289 | } | |||
2290 | ||||
2291 | int librados::Rados::pool_create(const char *name, uint64_t auid, __u8 crush_rule) | |||
2292 | { | |||
2293 | string str(name); | |||
2294 | return client->pool_create(str, auid, crush_rule); | |||
2295 | } | |||
2296 | ||||
2297 | int librados::Rados::pool_create_async(const char *name, PoolAsyncCompletion *c) | |||
2298 | { | |||
2299 | string str(name); | |||
2300 | return client->pool_create_async(str, c->pc); | |||
2301 | } | |||
2302 | ||||
2303 | int librados::Rados::pool_create_async(const char *name, uint64_t auid, PoolAsyncCompletion *c) | |||
2304 | { | |||
2305 | string str(name); | |||
2306 | return client->pool_create_async(str, c->pc, auid); | |||
2307 | } | |||
2308 | ||||
2309 | int librados::Rados::pool_create_async(const char *name, uint64_t auid, __u8 crush_rule, | |||
2310 | PoolAsyncCompletion *c) | |||
2311 | { | |||
2312 | string str(name); | |||
2313 | return client->pool_create_async(str, c->pc, auid, crush_rule); | |||
2314 | } | |||
2315 | ||||
2316 | int librados::Rados::pool_get_base_tier(int64_t pool_id, int64_t* base_tier) | |||
2317 | { | |||
2318 | tracepoint(librados, rados_pool_get_base_tier_enter, (rados_t)client, pool_id)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_get_base_tier_enter .state) *)&(__tracepoint_librados___rados_pool_get_base_tier_enter .state)); })), 0)) __tracepoint_cb_librados___rados_pool_get_base_tier_enter ((rados_t)client, pool_id); } while (0); | |||
2319 | int retval = client->pool_get_base_tier(pool_id, base_tier); | |||
2320 | tracepoint(librados, rados_pool_get_base_tier_exit, retval, *base_tier)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_get_base_tier_exit .state) *)&(__tracepoint_librados___rados_pool_get_base_tier_exit .state)); })), 0)) __tracepoint_cb_librados___rados_pool_get_base_tier_exit (retval, *base_tier); } while (0); | |||
2321 | return retval; | |||
2322 | } | |||
2323 | ||||
2324 | int librados::Rados::pool_delete(const char *name) | |||
2325 | { | |||
2326 | return client->pool_delete(name); | |||
2327 | } | |||
2328 | ||||
2329 | int librados::Rados::pool_delete_async(const char *name, PoolAsyncCompletion *c) | |||
2330 | { | |||
2331 | return client->pool_delete_async(name, c->pc); | |||
2332 | } | |||
2333 | ||||
2334 | int librados::Rados::pool_list(std::list<std::string>& v) | |||
2335 | { | |||
2336 | std::list<std::pair<int64_t, std::string> > pools; | |||
2337 | int r = client->pool_list(pools); | |||
2338 | if (r < 0) { | |||
2339 | return r; | |||
2340 | } | |||
2341 | ||||
2342 | v.clear(); | |||
2343 | for (std::list<std::pair<int64_t, std::string> >::iterator it = pools.begin(); | |||
2344 | it != pools.end(); ++it) { | |||
2345 | v.push_back(it->second); | |||
2346 | } | |||
2347 | return 0; | |||
2348 | } | |||
2349 | ||||
2350 | int librados::Rados::pool_list2(std::list<std::pair<int64_t, std::string> >& v) | |||
2351 | { | |||
2352 | return client->pool_list(v); | |||
2353 | } | |||
2354 | ||||
2355 | int64_t librados::Rados::pool_lookup(const char *name) | |||
2356 | { | |||
2357 | return client->lookup_pool(name); | |||
2358 | } | |||
2359 | ||||
2360 | int librados::Rados::pool_reverse_lookup(int64_t id, std::string *name) | |||
2361 | { | |||
2362 | return client->pool_get_name(id, name); | |||
2363 | } | |||
2364 | ||||
2365 | int librados::Rados::mon_command(string cmd, const bufferlist& inbl, | |||
2366 | bufferlist *outbl, string *outs) | |||
2367 | { | |||
2368 | vector<string> cmdvec; | |||
2369 | cmdvec.push_back(cmd); | |||
2370 | return client->mon_command(cmdvec, inbl, outbl, outs); | |||
2371 | } | |||
2372 | ||||
2373 | int librados::Rados::osd_command(int osdid, std::string cmd, const bufferlist& inbl, | |||
2374 | bufferlist *outbl, std::string *outs) | |||
2375 | { | |||
2376 | vector<string> cmdvec; | |||
2377 | cmdvec.push_back(cmd); | |||
2378 | return client->osd_command(osdid, cmdvec, inbl, outbl, outs); | |||
2379 | } | |||
2380 | ||||
2381 | int librados::Rados::mgr_command(std::string cmd, const bufferlist& inbl, | |||
2382 | bufferlist *outbl, std::string *outs) | |||
2383 | { | |||
2384 | vector<string> cmdvec; | |||
2385 | cmdvec.push_back(cmd); | |||
2386 | return client->mgr_command(cmdvec, inbl, outbl, outs); | |||
2387 | } | |||
2388 | ||||
2389 | ||||
2390 | ||||
2391 | int librados::Rados::pg_command(const char *pgstr, std::string cmd, const bufferlist& inbl, | |||
2392 | bufferlist *outbl, std::string *outs) | |||
2393 | { | |||
2394 | vector<string> cmdvec; | |||
2395 | cmdvec.push_back(cmd); | |||
2396 | ||||
2397 | pg_t pgid; | |||
2398 | if (!pgid.parse(pgstr)) | |||
2399 | return -EINVAL22; | |||
2400 | ||||
2401 | return client->pg_command(pgid, cmdvec, inbl, outbl, outs); | |||
2402 | } | |||
2403 | ||||
2404 | int librados::Rados::ioctx_create(const char *name, IoCtx &io) | |||
2405 | { | |||
2406 | rados_ioctx_t p; | |||
2407 | int ret = rados_ioctx_create((rados_t)client, name, &p); | |||
2408 | if (ret) | |||
2409 | return ret; | |||
2410 | io.close(); | |||
2411 | io.io_ctx_impl = (IoCtxImpl*)p; | |||
2412 | return 0; | |||
2413 | } | |||
2414 | ||||
2415 | int librados::Rados::ioctx_create2(int64_t pool_id, IoCtx &io) | |||
2416 | { | |||
2417 | rados_ioctx_t p; | |||
2418 | int ret = rados_ioctx_create2((rados_t)client, pool_id, &p); | |||
2419 | if (ret) | |||
2420 | return ret; | |||
2421 | io.close(); | |||
2422 | io.io_ctx_impl = (IoCtxImpl*)p; | |||
2423 | return 0; | |||
2424 | } | |||
2425 | ||||
2426 | void librados::Rados::test_blacklist_self(bool set) | |||
2427 | { | |||
2428 | client->blacklist_self(set); | |||
2429 | } | |||
2430 | ||||
2431 | int librados::Rados::get_pool_stats(std::list<string>& v, | |||
2432 | stats_map& result) | |||
2433 | { | |||
2434 | map<string,::pool_stat_t> rawresult; | |||
2435 | int r = client->get_pool_stats(v, rawresult); | |||
2436 | for (map<string,::pool_stat_t>::iterator p = rawresult.begin(); | |||
2437 | p != rawresult.end(); | |||
2438 | ++p) { | |||
2439 | pool_stat_t& pv = result[p->first]; | |||
2440 | object_stat_sum_t *sum = &p->second.stats.sum; | |||
2441 | pv.num_kb = SHIFT_ROUND_UP(sum->num_bytes, 10)(((sum->num_bytes)+(1<<(10))-1) >> (10)); | |||
2442 | pv.num_bytes = sum->num_bytes; | |||
2443 | pv.num_objects = sum->num_objects; | |||
2444 | pv.num_object_clones = sum->num_object_clones; | |||
2445 | pv.num_object_copies = sum->num_object_copies; | |||
2446 | pv.num_objects_missing_on_primary = sum->num_objects_missing_on_primary; | |||
2447 | pv.num_objects_unfound = sum->num_objects_unfound; | |||
2448 | pv.num_objects_degraded = sum->num_objects_degraded; | |||
2449 | pv.num_rd = sum->num_rd; | |||
2450 | pv.num_rd_kb = sum->num_rd_kb; | |||
2451 | pv.num_wr = sum->num_wr; | |||
2452 | pv.num_wr_kb = sum->num_wr_kb; | |||
2453 | } | |||
2454 | return r; | |||
2455 | } | |||
2456 | ||||
2457 | int librados::Rados::get_pool_stats(std::list<string>& v, | |||
2458 | std::map<string, stats_map>& result) | |||
2459 | { | |||
2460 | stats_map m; | |||
2461 | int r = get_pool_stats(v, m); | |||
2462 | if (r < 0) | |||
2463 | return r; | |||
2464 | for (map<string,pool_stat_t>::iterator p = m.begin(); | |||
2465 | p != m.end(); | |||
2466 | ++p) { | |||
2467 | result[p->first][string()] = p->second; | |||
2468 | } | |||
2469 | return r; | |||
2470 | } | |||
2471 | ||||
2472 | int librados::Rados::get_pool_stats(std::list<string>& v, | |||
2473 | string& category, // unused | |||
2474 | std::map<string, stats_map>& result) | |||
2475 | { | |||
2476 | return -EOPNOTSUPP95; | |||
2477 | } | |||
2478 | ||||
2479 | bool librados::Rados::get_pool_is_selfmanaged_snaps_mode(const std::string& pool) | |||
2480 | { | |||
2481 | return client->get_pool_is_selfmanaged_snaps_mode(pool); | |||
2482 | } | |||
2483 | ||||
2484 | int librados::Rados::cluster_stat(cluster_stat_t& result) | |||
2485 | { | |||
2486 | ceph_statfs stats; | |||
2487 | int r = client->get_fs_stats(stats); | |||
2488 | result.kb = stats.kb; | |||
2489 | result.kb_used = stats.kb_used; | |||
2490 | result.kb_avail = stats.kb_avail; | |||
2491 | result.num_objects = stats.num_objects; | |||
2492 | return r; | |||
2493 | } | |||
2494 | ||||
2495 | int librados::Rados::cluster_fsid(string *fsid) | |||
2496 | { | |||
2497 | return client->get_fsid(fsid); | |||
2498 | } | |||
2499 | ||||
2500 | namespace librados { | |||
2501 | struct PlacementGroupImpl { | |||
2502 | pg_t pgid; | |||
2503 | }; | |||
2504 | ||||
2505 | PlacementGroup::PlacementGroup() | |||
2506 | : impl{new PlacementGroupImpl} | |||
2507 | {} | |||
2508 | ||||
2509 | PlacementGroup::PlacementGroup(const PlacementGroup& pg) | |||
2510 | : impl{new PlacementGroupImpl} | |||
2511 | { | |||
2512 | impl->pgid = pg.impl->pgid; | |||
2513 | } | |||
2514 | ||||
2515 | PlacementGroup::~PlacementGroup() | |||
2516 | {} | |||
2517 | ||||
2518 | bool PlacementGroup::parse(const char* s) | |||
2519 | { | |||
2520 | return impl->pgid.parse(s); | |||
2521 | } | |||
2522 | } | |||
2523 | ||||
2524 | std::ostream& librados::operator<<(std::ostream& out, | |||
2525 | const librados::PlacementGroup& pg) | |||
2526 | { | |||
2527 | return out << pg.impl->pgid; | |||
2528 | } | |||
2529 | ||||
2530 | namespace { | |||
2531 | int decode_json(JSONObj *obj, pg_t& pg) | |||
2532 | { | |||
2533 | string pg_str; | |||
2534 | JSONDecoder::decode_json("pgid", pg_str, obj); | |||
2535 | if (pg.parse(pg_str.c_str())) { | |||
2536 | return 0; | |||
2537 | } else { | |||
2538 | return -EINVAL22; | |||
2539 | } | |||
2540 | } | |||
2541 | ||||
2542 | int get_inconsistent_pgs(librados::RadosClient& client, | |||
2543 | int64_t pool_id, | |||
2544 | std::vector<librados::PlacementGroup>* pgs) | |||
2545 | { | |||
2546 | vector<string> cmd = { | |||
2547 | "{\"prefix\": \"pg ls\"," | |||
2548 | "\"pool\": " + std::to_string(pool_id) + "," | |||
2549 | "\"states\": [\"inconsistent\"]," | |||
2550 | "\"format\": \"json\"}" | |||
2551 | }; | |||
2552 | bufferlist inbl, outbl; | |||
2553 | string outstring; | |||
2554 | int ret = client.mon_command(cmd, inbl, &outbl, &outstring); | |||
2555 | if (ret) { | |||
2556 | return ret; | |||
2557 | } | |||
2558 | if (!outbl.length()) { | |||
2559 | // no pg returned | |||
2560 | return ret; | |||
2561 | } | |||
2562 | JSONParser parser; | |||
2563 | if (!parser.parse(outbl.c_str(), outbl.length())) { | |||
2564 | return -EINVAL22; | |||
2565 | } | |||
2566 | if (!parser.is_array()) { | |||
2567 | return -EINVAL22; | |||
2568 | } | |||
2569 | vector<string> v = parser.get_array_elements(); | |||
2570 | for (auto i : v) { | |||
2571 | JSONParser pg_json; | |||
2572 | if (!pg_json.parse(i.c_str(), i.length())) { | |||
2573 | return -EINVAL22; | |||
2574 | } | |||
2575 | librados::PlacementGroup pg; | |||
2576 | if (decode_json(&pg_json, pg.impl->pgid)) { | |||
2577 | return -EINVAL22; | |||
2578 | } | |||
2579 | pgs->emplace_back(pg); | |||
2580 | } | |||
2581 | return 0; | |||
2582 | } | |||
2583 | } | |||
2584 | ||||
2585 | int librados::Rados::get_inconsistent_pgs(int64_t pool_id, | |||
2586 | std::vector<PlacementGroup>* pgs) | |||
2587 | { | |||
2588 | return ::get_inconsistent_pgs(*client, pool_id, pgs); | |||
2589 | } | |||
2590 | ||||
2591 | int librados::Rados::get_inconsistent_objects(const PlacementGroup& pg, | |||
2592 | const object_id_t &start_after, | |||
2593 | unsigned max_return, | |||
2594 | AioCompletion *c, | |||
2595 | std::vector<inconsistent_obj_t>* objects, | |||
2596 | uint32_t* interval) | |||
2597 | { | |||
2598 | IoCtx ioctx; | |||
2599 | const pg_t pgid = pg.impl->pgid; | |||
2600 | int r = ioctx_create2(pgid.pool(), ioctx); | |||
2601 | if (r < 0) { | |||
2602 | return r; | |||
2603 | } | |||
2604 | ||||
2605 | return ioctx.io_ctx_impl->get_inconsistent_objects(pgid, | |||
2606 | start_after, | |||
2607 | max_return, | |||
2608 | c->pc, | |||
2609 | objects, | |||
2610 | interval); | |||
2611 | } | |||
2612 | ||||
2613 | int librados::Rados::get_inconsistent_snapsets(const PlacementGroup& pg, | |||
2614 | const object_id_t &start_after, | |||
2615 | unsigned max_return, | |||
2616 | AioCompletion *c, | |||
2617 | std::vector<inconsistent_snapset_t>* snapsets, | |||
2618 | uint32_t* interval) | |||
2619 | { | |||
2620 | IoCtx ioctx; | |||
2621 | const pg_t pgid = pg.impl->pgid; | |||
2622 | int r = ioctx_create2(pgid.pool(), ioctx); | |||
2623 | if (r < 0) { | |||
2624 | return r; | |||
2625 | } | |||
2626 | ||||
2627 | return ioctx.io_ctx_impl->get_inconsistent_snapsets(pgid, | |||
2628 | start_after, | |||
2629 | max_return, | |||
2630 | c->pc, | |||
2631 | snapsets, | |||
2632 | interval); | |||
2633 | } | |||
2634 | ||||
2635 | int librados::Rados::wait_for_latest_osdmap() | |||
2636 | { | |||
2637 | return client->wait_for_latest_osdmap(); | |||
2638 | } | |||
2639 | ||||
2640 | int librados::Rados::blacklist_add(const std::string& client_address, | |||
2641 | uint32_t expire_seconds) | |||
2642 | { | |||
2643 | return client->blacklist_add(client_address, expire_seconds); | |||
2644 | } | |||
2645 | ||||
2646 | librados::PoolAsyncCompletion *librados::Rados::pool_async_create_completion() | |||
2647 | { | |||
2648 | PoolAsyncCompletionImpl *c = new PoolAsyncCompletionImpl; | |||
2649 | return new PoolAsyncCompletion(c); | |||
2650 | } | |||
2651 | ||||
2652 | librados::AioCompletion *librados::Rados::aio_create_completion() | |||
2653 | { | |||
2654 | AioCompletionImpl *c = new AioCompletionImpl; | |||
2655 | return new AioCompletion(c); | |||
2656 | } | |||
2657 | ||||
2658 | librados::AioCompletion *librados::Rados::aio_create_completion(void *cb_arg, | |||
2659 | callback_t cb_complete, | |||
2660 | callback_t cb_safe) | |||
2661 | { | |||
2662 | AioCompletionImpl *c; | |||
2663 | int r = rados_aio_create_completion(cb_arg, cb_complete, cb_safe, (void**)&c); | |||
2664 | assert(r == 0)((r == 0) ? static_cast<void> (0) : __ceph_assert_fail ( "r == 0", "/home/brad/working/src/ceph/src/librados/librados.cc" , 2664, __PRETTY_FUNCTION__)); | |||
2665 | return new AioCompletion(c); | |||
2666 | } | |||
2667 | ||||
2668 | librados::ObjectOperation::ObjectOperation() | |||
2669 | { | |||
2670 | impl = new ObjectOperationImpl; | |||
2671 | } | |||
2672 | ||||
2673 | librados::ObjectOperation::~ObjectOperation() | |||
2674 | { | |||
2675 | delete impl; | |||
2676 | } | |||
2677 | ||||
2678 | ///////////////////////////// C API ////////////////////////////// | |||
2679 | ||||
2680 | static CephContext *rados_create_cct(const char * const clustername, | |||
2681 | CephInitParameters *iparams) | |||
2682 | { | |||
2683 | // missing things compared to global_init: | |||
2684 | // g_ceph_context, g_conf, g_lockdep, signal handlers | |||
2685 | CephContext *cct = common_preinit(*iparams, CODE_ENVIRONMENT_LIBRARY, 0); | |||
2686 | if (clustername) | |||
2687 | cct->_conf->cluster = clustername; | |||
2688 | cct->_conf->parse_env(); // environment variables override | |||
2689 | cct->_conf->apply_changes(NULL__null); | |||
2690 | ||||
2691 | TracepointProvider::initialize<tracepoint_traits>(cct); | |||
2692 | return cct; | |||
2693 | } | |||
2694 | ||||
2695 | extern "C" int rados_create(rados_t *pcluster, const char * const id) | |||
2696 | { | |||
2697 | CephInitParameters iparams(CEPH_ENTITY_TYPE_CLIENT0x08); | |||
2698 | if (id) { | |||
2699 | iparams.name.set(CEPH_ENTITY_TYPE_CLIENT0x08, id); | |||
2700 | } | |||
2701 | CephContext *cct = rados_create_cct("", &iparams); | |||
2702 | ||||
2703 | tracepoint(librados, rados_create_enter, id)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_create_enter .state) *)&(__tracepoint_librados___rados_create_enter.state )); })), 0)) __tracepoint_cb_librados___rados_create_enter(id ); } while (0); | |||
2704 | *pcluster = reinterpret_cast<rados_t>(new librados::RadosClient(cct)); | |||
2705 | tracepoint(librados, rados_create_exit, 0, *pcluster)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_create_exit .state) *)&(__tracepoint_librados___rados_create_exit.state )); })), 0)) __tracepoint_cb_librados___rados_create_exit(0, * pcluster); } while (0); | |||
2706 | ||||
2707 | cct->put(); | |||
2708 | return 0; | |||
2709 | } | |||
2710 | ||||
2711 | // as above, but | |||
2712 | // 1) don't assume 'client.'; name is a full type.id namestr | |||
2713 | // 2) allow setting clustername | |||
2714 | // 3) flags is for future expansion (maybe some of the global_init() | |||
2715 | // behavior is appropriate for some consumers of librados, for instance) | |||
2716 | ||||
2717 | extern "C" int rados_create2(rados_t *pcluster, const char *const clustername, | |||
2718 | const char * const name, uint64_t flags) | |||
2719 | { | |||
2720 | // client is assumed, but from_str will override | |||
2721 | int retval = 0; | |||
2722 | CephInitParameters iparams(CEPH_ENTITY_TYPE_CLIENT0x08); | |||
2723 | if (!name || !iparams.name.from_str(name)) { | |||
2724 | retval = -EINVAL22; | |||
2725 | } | |||
2726 | ||||
2727 | CephContext *cct = rados_create_cct(clustername, &iparams); | |||
2728 | tracepoint(librados, rados_create2_enter, clustername, name, flags)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_create2_enter .state) *)&(__tracepoint_librados___rados_create2_enter.state )); })), 0)) __tracepoint_cb_librados___rados_create2_enter(clustername , name, flags); } while (0); | |||
2729 | if (retval == 0) { | |||
2730 | *pcluster = reinterpret_cast<rados_t>(new librados::RadosClient(cct)); | |||
2731 | } | |||
2732 | tracepoint(librados, rados_create2_exit, retval, *pcluster)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_create2_exit .state) *)&(__tracepoint_librados___rados_create2_exit.state )); })), 0)) __tracepoint_cb_librados___rados_create2_exit(retval , *pcluster); } while (0); | |||
2733 | ||||
2734 | cct->put(); | |||
2735 | return retval; | |||
2736 | } | |||
2737 | ||||
2738 | /* This function is intended for use by Ceph daemons. These daemons have | |||
2739 | * already called global_init and want to use that particular configuration for | |||
2740 | * their cluster. | |||
2741 | */ | |||
2742 | extern "C" int rados_create_with_context(rados_t *pcluster, rados_config_t cct_) | |||
2743 | { | |||
2744 | CephContext *cct = (CephContext *)cct_; | |||
2745 | TracepointProvider::initialize<tracepoint_traits>(cct); | |||
2746 | ||||
2747 | tracepoint(librados, rados_create_with_context_enter, cct_)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_create_with_context_enter .state) *)&(__tracepoint_librados___rados_create_with_context_enter .state)); })), 0)) __tracepoint_cb_librados___rados_create_with_context_enter (cct_); } while (0); | |||
2748 | librados::RadosClient *radosp = new librados::RadosClient(cct); | |||
2749 | *pcluster = (void *)radosp; | |||
2750 | tracepoint(librados, rados_create_with_context_exit, 0, *pcluster)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_create_with_context_exit .state) *)&(__tracepoint_librados___rados_create_with_context_exit .state)); })), 0)) __tracepoint_cb_librados___rados_create_with_context_exit (0, *pcluster); } while (0); | |||
2751 | return 0; | |||
2752 | } | |||
2753 | ||||
2754 | extern "C" rados_config_t rados_cct(rados_t cluster) | |||
2755 | { | |||
2756 | tracepoint(librados, rados_cct_enter, cluster)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_cct_enter .state) *)&(__tracepoint_librados___rados_cct_enter.state )); })), 0)) __tracepoint_cb_librados___rados_cct_enter(cluster ); } while (0); | |||
2757 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
2758 | rados_config_t retval = (rados_config_t)client->cct; | |||
2759 | tracepoint(librados, rados_cct_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_cct_exit .state) *)&(__tracepoint_librados___rados_cct_exit.state) ); })), 0)) __tracepoint_cb_librados___rados_cct_exit(retval) ; } while (0); | |||
2760 | return retval; | |||
2761 | } | |||
2762 | ||||
2763 | extern "C" int rados_connect(rados_t cluster) | |||
2764 | { | |||
2765 | tracepoint(librados, rados_connect_enter, cluster)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_connect_enter .state) *)&(__tracepoint_librados___rados_connect_enter.state )); })), 0)) __tracepoint_cb_librados___rados_connect_enter(cluster ); } while (0); | |||
2766 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
2767 | int retval = client->connect(); | |||
2768 | tracepoint(librados, rados_connect_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_connect_exit .state) *)&(__tracepoint_librados___rados_connect_exit.state )); })), 0)) __tracepoint_cb_librados___rados_connect_exit(retval ); } while (0); | |||
2769 | return retval; | |||
2770 | } | |||
2771 | ||||
2772 | extern "C" void rados_shutdown(rados_t cluster) | |||
2773 | { | |||
2774 | tracepoint(librados, rados_shutdown_enter, cluster)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_shutdown_enter .state) *)&(__tracepoint_librados___rados_shutdown_enter. state)); })), 0)) __tracepoint_cb_librados___rados_shutdown_enter (cluster); } while (0); | |||
2775 | librados::RadosClient *radosp = (librados::RadosClient *)cluster; | |||
2776 | radosp->shutdown(); | |||
2777 | delete radosp; | |||
2778 | tracepoint(librados, rados_shutdown_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_shutdown_exit .state) *)&(__tracepoint_librados___rados_shutdown_exit.state )); })), 0)) __tracepoint_cb_librados___rados_shutdown_exit() ; } while (0); | |||
2779 | } | |||
2780 | ||||
2781 | extern "C" uint64_t rados_get_instance_id(rados_t cluster) | |||
2782 | { | |||
2783 | tracepoint(librados, rados_get_instance_id_enter, cluster)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_get_instance_id_enter .state) *)&(__tracepoint_librados___rados_get_instance_id_enter .state)); })), 0)) __tracepoint_cb_librados___rados_get_instance_id_enter (cluster); } while (0); | |||
2784 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
2785 | uint64_t retval = client->get_instance_id(); | |||
2786 | tracepoint(librados, rados_get_instance_id_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_get_instance_id_exit .state) *)&(__tracepoint_librados___rados_get_instance_id_exit .state)); })), 0)) __tracepoint_cb_librados___rados_get_instance_id_exit (retval); } while (0); | |||
2787 | return retval; | |||
2788 | } | |||
2789 | ||||
2790 | extern "C" void rados_version(int *major, int *minor, int *extra) | |||
2791 | { | |||
2792 | tracepoint(librados, rados_version_enter, major, minor, extra)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_version_enter .state) *)&(__tracepoint_librados___rados_version_enter.state )); })), 0)) __tracepoint_cb_librados___rados_version_enter(major , minor, extra); } while (0); | |||
2793 | if (major) | |||
2794 | *major = LIBRADOS_VER_MAJOR0; | |||
2795 | if (minor) | |||
2796 | *minor = LIBRADOS_VER_MINOR69; | |||
2797 | if (extra) | |||
2798 | *extra = LIBRADOS_VER_EXTRA1; | |||
2799 | tracepoint(librados, rados_version_exit, LIBRADOS_VER_MAJOR, LIBRADOS_VER_MINOR, LIBRADOS_VER_EXTRA)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_version_exit .state) *)&(__tracepoint_librados___rados_version_exit.state )); })), 0)) __tracepoint_cb_librados___rados_version_exit(0, 69, 1); } while (0); | |||
2800 | } | |||
2801 | ||||
2802 | ||||
2803 | // -- config -- | |||
2804 | extern "C" int rados_conf_read_file(rados_t cluster, const char *path_list) | |||
2805 | { | |||
2806 | tracepoint(librados, rados_conf_read_file_enter, cluster, path_list)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_read_file_enter .state) *)&(__tracepoint_librados___rados_conf_read_file_enter .state)); })), 0)) __tracepoint_cb_librados___rados_conf_read_file_enter (cluster, path_list); } while (0); | |||
2807 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
2808 | md_config_t *conf = client->cct->_conf; | |||
2809 | int ret = conf->parse_config_files(path_list, NULL__null, 0); | |||
2810 | if (ret) { | |||
2811 | tracepoint(librados, rados_conf_read_file_exit, ret)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_read_file_exit .state) *)&(__tracepoint_librados___rados_conf_read_file_exit .state)); })), 0)) __tracepoint_cb_librados___rados_conf_read_file_exit (ret); } while (0); | |||
2812 | return ret; | |||
2813 | } | |||
2814 | conf->parse_env(); // environment variables override | |||
2815 | ||||
2816 | conf->apply_changes(NULL__null); | |||
2817 | client->cct->_conf->complain_about_parse_errors(client->cct); | |||
2818 | tracepoint(librados, rados_conf_read_file_exit, 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_read_file_exit .state) *)&(__tracepoint_librados___rados_conf_read_file_exit .state)); })), 0)) __tracepoint_cb_librados___rados_conf_read_file_exit (0); } while (0); | |||
2819 | return 0; | |||
2820 | } | |||
2821 | ||||
2822 | extern "C" int rados_conf_parse_argv(rados_t cluster, int argc, const char **argv) | |||
2823 | { | |||
2824 | tracepoint(librados, rados_conf_parse_argv_enter, cluster, argc)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_parse_argv_enter .state) *)&(__tracepoint_librados___rados_conf_parse_argv_enter .state)); })), 0)) __tracepoint_cb_librados___rados_conf_parse_argv_enter (cluster, argc); } while (0); | |||
2825 | int i; | |||
2826 | for(i = 0; i < argc; i++) { | |||
2827 | tracepoint(librados, rados_conf_parse_argv_arg, argv[i])do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_parse_argv_arg .state) *)&(__tracepoint_librados___rados_conf_parse_argv_arg .state)); })), 0)) __tracepoint_cb_librados___rados_conf_parse_argv_arg (argv[i]); } while (0); | |||
2828 | } | |||
2829 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
2830 | md_config_t *conf = client->cct->_conf; | |||
2831 | vector<const char*> args; | |||
2832 | argv_to_vec(argc, argv, args); | |||
2833 | int ret = conf->parse_argv(args); | |||
2834 | if (ret) { | |||
2835 | tracepoint(librados, rados_conf_parse_argv_exit, ret)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_parse_argv_exit .state) *)&(__tracepoint_librados___rados_conf_parse_argv_exit .state)); })), 0)) __tracepoint_cb_librados___rados_conf_parse_argv_exit (ret); } while (0); | |||
2836 | return ret; | |||
2837 | } | |||
2838 | conf->apply_changes(NULL__null); | |||
2839 | tracepoint(librados, rados_conf_parse_argv_exit, 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_parse_argv_exit .state) *)&(__tracepoint_librados___rados_conf_parse_argv_exit .state)); })), 0)) __tracepoint_cb_librados___rados_conf_parse_argv_exit (0); } while (0); | |||
2840 | return 0; | |||
2841 | } | |||
2842 | ||||
2843 | // like above, but return the remainder of argv to contain remaining | |||
2844 | // unparsed args. Must be allocated to at least argc by caller. | |||
2845 | // remargv will contain n <= argc pointers to original argv[], the end | |||
2846 | // of which may be NULL | |||
2847 | ||||
2848 | extern "C" int rados_conf_parse_argv_remainder(rados_t cluster, int argc, | |||
2849 | const char **argv, | |||
2850 | const char **remargv) | |||
2851 | { | |||
2852 | tracepoint(librados, rados_conf_parse_argv_remainder_enter, cluster, argc)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_parse_argv_remainder_enter .state) *)&(__tracepoint_librados___rados_conf_parse_argv_remainder_enter .state)); })), 0)) __tracepoint_cb_librados___rados_conf_parse_argv_remainder_enter (cluster, argc); } while (0); | |||
2853 | unsigned int i; | |||
2854 | for(i = 0; i < (unsigned int) argc; i++) { | |||
2855 | tracepoint(librados, rados_conf_parse_argv_remainder_arg, argv[i])do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_parse_argv_remainder_arg .state) *)&(__tracepoint_librados___rados_conf_parse_argv_remainder_arg .state)); })), 0)) __tracepoint_cb_librados___rados_conf_parse_argv_remainder_arg (argv[i]); } while (0); | |||
2856 | } | |||
2857 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
2858 | md_config_t *conf = client->cct->_conf; | |||
2859 | vector<const char*> args; | |||
2860 | for (int i=0; i<argc; i++) | |||
2861 | args.push_back(argv[i]); | |||
2862 | int ret = conf->parse_argv(args); | |||
2863 | if (ret) { | |||
2864 | tracepoint(librados, rados_conf_parse_argv_remainder_exit, ret)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_parse_argv_remainder_exit .state) *)&(__tracepoint_librados___rados_conf_parse_argv_remainder_exit .state)); })), 0)) __tracepoint_cb_librados___rados_conf_parse_argv_remainder_exit (ret); } while (0); | |||
2865 | return ret; | |||
2866 | } | |||
2867 | conf->apply_changes(NULL__null); | |||
2868 | assert(args.size() <= (unsigned int)argc)((args.size() <= (unsigned int)argc) ? static_cast<void > (0) : __ceph_assert_fail ("args.size() <= (unsigned int)argc" , "/home/brad/working/src/ceph/src/librados/librados.cc", 2868 , __PRETTY_FUNCTION__)); | |||
2869 | for (i = 0; i < (unsigned int)argc; ++i) { | |||
2870 | if (i < args.size()) | |||
2871 | remargv[i] = args[i]; | |||
2872 | else | |||
2873 | remargv[i] = (const char *)NULL__null; | |||
2874 | tracepoint(librados, rados_conf_parse_argv_remainder_remarg, remargv[i])do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_parse_argv_remainder_remarg .state) *)&(__tracepoint_librados___rados_conf_parse_argv_remainder_remarg .state)); })), 0)) __tracepoint_cb_librados___rados_conf_parse_argv_remainder_remarg (remargv[i]); } while (0); | |||
2875 | } | |||
2876 | tracepoint(librados, rados_conf_parse_argv_remainder_exit, 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_parse_argv_remainder_exit .state) *)&(__tracepoint_librados___rados_conf_parse_argv_remainder_exit .state)); })), 0)) __tracepoint_cb_librados___rados_conf_parse_argv_remainder_exit (0); } while (0); | |||
2877 | return 0; | |||
2878 | } | |||
2879 | ||||
2880 | extern "C" int rados_conf_parse_env(rados_t cluster, const char *env) | |||
2881 | { | |||
2882 | tracepoint(librados, rados_conf_parse_env_enter, cluster, env)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_parse_env_enter .state) *)&(__tracepoint_librados___rados_conf_parse_env_enter .state)); })), 0)) __tracepoint_cb_librados___rados_conf_parse_env_enter (cluster, env); } while (0); | |||
2883 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
2884 | md_config_t *conf = client->cct->_conf; | |||
2885 | vector<const char*> args; | |||
2886 | env_to_vec(args, env); | |||
2887 | int ret = conf->parse_argv(args); | |||
2888 | if (ret) { | |||
2889 | tracepoint(librados, rados_conf_parse_env_exit, ret)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_parse_env_exit .state) *)&(__tracepoint_librados___rados_conf_parse_env_exit .state)); })), 0)) __tracepoint_cb_librados___rados_conf_parse_env_exit (ret); } while (0); | |||
2890 | return ret; | |||
2891 | } | |||
2892 | conf->apply_changes(NULL__null); | |||
2893 | tracepoint(librados, rados_conf_parse_env_exit, 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_parse_env_exit .state) *)&(__tracepoint_librados___rados_conf_parse_env_exit .state)); })), 0)) __tracepoint_cb_librados___rados_conf_parse_env_exit (0); } while (0); | |||
2894 | return 0; | |||
2895 | } | |||
2896 | ||||
2897 | extern "C" int rados_conf_set(rados_t cluster, const char *option, const char *value) | |||
2898 | { | |||
2899 | tracepoint(librados, rados_conf_set_enter, cluster, option, value)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_set_enter .state) *)&(__tracepoint_librados___rados_conf_set_enter. state)); })), 0)) __tracepoint_cb_librados___rados_conf_set_enter (cluster, option, value); } while (0); | |||
2900 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
2901 | md_config_t *conf = client->cct->_conf; | |||
2902 | int ret = conf->set_val(option, value); | |||
2903 | if (ret) { | |||
2904 | tracepoint(librados, rados_conf_set_exit, ret)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_set_exit .state) *)&(__tracepoint_librados___rados_conf_set_exit.state )); })), 0)) __tracepoint_cb_librados___rados_conf_set_exit(ret ); } while (0); | |||
2905 | return ret; | |||
2906 | } | |||
2907 | conf->apply_changes(NULL__null); | |||
2908 | tracepoint(librados, rados_conf_set_exit, 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_set_exit .state) *)&(__tracepoint_librados___rados_conf_set_exit.state )); })), 0)) __tracepoint_cb_librados___rados_conf_set_exit(0 ); } while (0); | |||
2909 | return 0; | |||
2910 | } | |||
2911 | ||||
2912 | /* cluster info */ | |||
2913 | extern "C" int rados_cluster_stat(rados_t cluster, rados_cluster_stat_t *result) | |||
2914 | { | |||
2915 | tracepoint(librados, rados_cluster_stat_enter, cluster)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_cluster_stat_enter .state) *)&(__tracepoint_librados___rados_cluster_stat_enter .state)); })), 0)) __tracepoint_cb_librados___rados_cluster_stat_enter (cluster); } while (0); | |||
2916 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
2917 | ||||
2918 | ceph_statfs stats; | |||
2919 | int r = client->get_fs_stats(stats); | |||
2920 | result->kb = stats.kb; | |||
2921 | result->kb_used = stats.kb_used; | |||
2922 | result->kb_avail = stats.kb_avail; | |||
2923 | result->num_objects = stats.num_objects; | |||
2924 | tracepoint(librados, rados_cluster_stat_exit, r, result->kb, result->kb_used, result->kb_avail, result->num_objects)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_cluster_stat_exit .state) *)&(__tracepoint_librados___rados_cluster_stat_exit .state)); })), 0)) __tracepoint_cb_librados___rados_cluster_stat_exit (r, result->kb, result->kb_used, result->kb_avail, result ->num_objects); } while (0); | |||
2925 | return r; | |||
2926 | } | |||
2927 | ||||
2928 | extern "C" int rados_conf_get(rados_t cluster, const char *option, char *buf, size_t len) | |||
2929 | { | |||
2930 | tracepoint(librados, rados_conf_get_enter, cluster, option, len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_get_enter .state) *)&(__tracepoint_librados___rados_conf_get_enter. state)); })), 0)) __tracepoint_cb_librados___rados_conf_get_enter (cluster, option, len); } while (0); | |||
2931 | char *tmp = buf; | |||
2932 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
2933 | md_config_t *conf = client->cct->_conf; | |||
2934 | int retval = conf->get_val(option, &tmp, len); | |||
2935 | tracepoint(librados, rados_conf_get_exit, retval, retval ? "" : option)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_conf_get_exit .state) *)&(__tracepoint_librados___rados_conf_get_exit.state )); })), 0)) __tracepoint_cb_librados___rados_conf_get_exit(retval , retval ? "" : option); } while (0); | |||
2936 | return retval; | |||
2937 | } | |||
2938 | ||||
2939 | extern "C" int64_t rados_pool_lookup(rados_t cluster, const char *name) | |||
2940 | { | |||
2941 | tracepoint(librados, rados_pool_lookup_enter, cluster, name)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_lookup_enter .state) *)&(__tracepoint_librados___rados_pool_lookup_enter .state)); })), 0)) __tracepoint_cb_librados___rados_pool_lookup_enter (cluster, name); } while (0); | |||
2942 | librados::RadosClient *radosp = (librados::RadosClient *)cluster; | |||
2943 | int64_t retval = radosp->lookup_pool(name); | |||
2944 | tracepoint(librados, rados_pool_lookup_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_lookup_exit .state) *)&(__tracepoint_librados___rados_pool_lookup_exit .state)); })), 0)) __tracepoint_cb_librados___rados_pool_lookup_exit (retval); } while (0); | |||
2945 | return retval; | |||
2946 | } | |||
2947 | ||||
2948 | extern "C" int rados_pool_reverse_lookup(rados_t cluster, int64_t id, | |||
2949 | char *buf, size_t maxlen) | |||
2950 | { | |||
2951 | tracepoint(librados, rados_pool_reverse_lookup_enter, cluster, id, maxlen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_reverse_lookup_enter .state) *)&(__tracepoint_librados___rados_pool_reverse_lookup_enter .state)); })), 0)) __tracepoint_cb_librados___rados_pool_reverse_lookup_enter (cluster, id, maxlen); } while (0); | |||
2952 | librados::RadosClient *radosp = (librados::RadosClient *)cluster; | |||
2953 | std::string name; | |||
2954 | int r = radosp->pool_get_name(id, &name); | |||
2955 | if (r < 0) { | |||
2956 | tracepoint(librados, rados_pool_reverse_lookup_exit, r, "")do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_reverse_lookup_exit .state) *)&(__tracepoint_librados___rados_pool_reverse_lookup_exit .state)); })), 0)) __tracepoint_cb_librados___rados_pool_reverse_lookup_exit (r, ""); } while (0); | |||
2957 | return r; | |||
2958 | } | |||
2959 | if (name.length() >= maxlen) { | |||
2960 | tracepoint(librados, rados_pool_reverse_lookup_exit, -ERANGE, "")do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_reverse_lookup_exit .state) *)&(__tracepoint_librados___rados_pool_reverse_lookup_exit .state)); })), 0)) __tracepoint_cb_librados___rados_pool_reverse_lookup_exit (-34, ""); } while (0); | |||
2961 | return -ERANGE34; | |||
2962 | } | |||
2963 | strcpy(buf, name.c_str()); | |||
2964 | int retval = name.length(); | |||
2965 | tracepoint(librados, rados_pool_reverse_lookup_exit, retval, buf)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_reverse_lookup_exit .state) *)&(__tracepoint_librados___rados_pool_reverse_lookup_exit .state)); })), 0)) __tracepoint_cb_librados___rados_pool_reverse_lookup_exit (retval, buf); } while (0); | |||
2966 | return retval; | |||
2967 | } | |||
2968 | ||||
2969 | extern "C" int rados_cluster_fsid(rados_t cluster, char *buf, | |||
2970 | size_t maxlen) | |||
2971 | { | |||
2972 | tracepoint(librados, rados_cluster_fsid_enter, cluster, maxlen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_cluster_fsid_enter .state) *)&(__tracepoint_librados___rados_cluster_fsid_enter .state)); })), 0)) __tracepoint_cb_librados___rados_cluster_fsid_enter (cluster, maxlen); } while (0); | |||
2973 | librados::RadosClient *radosp = (librados::RadosClient *)cluster; | |||
2974 | std::string fsid; | |||
2975 | radosp->get_fsid(&fsid); | |||
2976 | if (fsid.length() >= maxlen) { | |||
2977 | tracepoint(librados, rados_cluster_fsid_exit, -ERANGE, "")do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_cluster_fsid_exit .state) *)&(__tracepoint_librados___rados_cluster_fsid_exit .state)); })), 0)) __tracepoint_cb_librados___rados_cluster_fsid_exit (-34, ""); } while (0); | |||
2978 | return -ERANGE34; | |||
2979 | } | |||
2980 | strcpy(buf, fsid.c_str()); | |||
2981 | int retval = fsid.length(); | |||
2982 | tracepoint(librados, rados_cluster_fsid_exit, retval, buf)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_cluster_fsid_exit .state) *)&(__tracepoint_librados___rados_cluster_fsid_exit .state)); })), 0)) __tracepoint_cb_librados___rados_cluster_fsid_exit (retval, buf); } while (0); | |||
2983 | return retval; | |||
2984 | } | |||
2985 | ||||
2986 | extern "C" int rados_wait_for_latest_osdmap(rados_t cluster) | |||
2987 | { | |||
2988 | tracepoint(librados, rados_wait_for_latest_osdmap_enter, cluster)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_wait_for_latest_osdmap_enter .state) *)&(__tracepoint_librados___rados_wait_for_latest_osdmap_enter .state)); })), 0)) __tracepoint_cb_librados___rados_wait_for_latest_osdmap_enter (cluster); } while (0); | |||
2989 | librados::RadosClient *radosp = (librados::RadosClient *)cluster; | |||
2990 | int retval = radosp->wait_for_latest_osdmap(); | |||
2991 | tracepoint(librados, rados_wait_for_latest_osdmap_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_wait_for_latest_osdmap_exit .state) *)&(__tracepoint_librados___rados_wait_for_latest_osdmap_exit .state)); })), 0)) __tracepoint_cb_librados___rados_wait_for_latest_osdmap_exit (retval); } while (0); | |||
2992 | return retval; | |||
2993 | } | |||
2994 | ||||
2995 | extern "C" int rados_blacklist_add(rados_t cluster, char *client_address, | |||
2996 | uint32_t expire_seconds) | |||
2997 | { | |||
2998 | librados::RadosClient *radosp = (librados::RadosClient *)cluster; | |||
2999 | return radosp->blacklist_add(client_address, expire_seconds); | |||
3000 | } | |||
3001 | ||||
3002 | extern "C" int rados_pool_list(rados_t cluster, char *buf, size_t len) | |||
3003 | { | |||
3004 | tracepoint(librados, rados_pool_list_enter, cluster, len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_list_enter .state) *)&(__tracepoint_librados___rados_pool_list_enter .state)); })), 0)) __tracepoint_cb_librados___rados_pool_list_enter (cluster, len); } while (0); | |||
3005 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
3006 | std::list<std::pair<int64_t, std::string> > pools; | |||
3007 | int r = client->pool_list(pools); | |||
3008 | if (r < 0) { | |||
3009 | tracepoint(librados, rados_pool_list_exit, r)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_list_exit .state) *)&(__tracepoint_librados___rados_pool_list_exit. state)); })), 0)) __tracepoint_cb_librados___rados_pool_list_exit (r); } while (0); | |||
3010 | return r; | |||
3011 | } | |||
3012 | ||||
3013 | if (len > 0 && !buf) { | |||
3014 | tracepoint(librados, rados_pool_list_exit, -EINVAL)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_list_exit .state) *)&(__tracepoint_librados___rados_pool_list_exit. state)); })), 0)) __tracepoint_cb_librados___rados_pool_list_exit (-22); } while (0); | |||
3015 | return -EINVAL22; | |||
3016 | } | |||
3017 | ||||
3018 | char *b = buf; | |||
3019 | if (b) | |||
3020 | memset(b, 0, len); | |||
3021 | int needed = 0; | |||
3022 | std::list<std::pair<int64_t, std::string> >::const_iterator i = pools.begin(); | |||
3023 | std::list<std::pair<int64_t, std::string> >::const_iterator p_end = | |||
3024 | pools.end(); | |||
3025 | for (; i != p_end; ++i) { | |||
3026 | int rl = i->second.length() + 1; | |||
3027 | if (len < (unsigned)rl) | |||
3028 | break; | |||
3029 | const char* pool = i->second.c_str(); | |||
3030 | tracepoint(librados, rados_pool_list_pool, pool)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_list_pool .state) *)&(__tracepoint_librados___rados_pool_list_pool. state)); })), 0)) __tracepoint_cb_librados___rados_pool_list_pool (pool); } while (0); | |||
3031 | strncat(b, pool, rl); | |||
3032 | needed += rl; | |||
3033 | len -= rl; | |||
3034 | b += rl; | |||
3035 | } | |||
3036 | for (; i != p_end; ++i) { | |||
3037 | int rl = i->second.length() + 1; | |||
3038 | needed += rl; | |||
3039 | } | |||
3040 | int retval = needed + 1; | |||
3041 | tracepoint(librados, rados_pool_list_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_list_exit .state) *)&(__tracepoint_librados___rados_pool_list_exit. state)); })), 0)) __tracepoint_cb_librados___rados_pool_list_exit (retval); } while (0); | |||
3042 | return retval; | |||
3043 | } | |||
3044 | ||||
3045 | CEPH_RADOS_API__attribute__ ((visibility ("default"))) int rados_inconsistent_pg_list(rados_t cluster, int64_t pool_id, | |||
3046 | char *buf, size_t len) | |||
3047 | { | |||
3048 | tracepoint(librados, rados_inconsistent_pg_list_enter, cluster, pool_id, len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_inconsistent_pg_list_enter .state) *)&(__tracepoint_librados___rados_inconsistent_pg_list_enter .state)); })), 0)) __tracepoint_cb_librados___rados_inconsistent_pg_list_enter (cluster, pool_id, len); } while (0); | |||
3049 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
3050 | std::vector<librados::PlacementGroup> pgs; | |||
3051 | int r = ::get_inconsistent_pgs(*client, pool_id, &pgs); | |||
3052 | if (r < 0) { | |||
3053 | tracepoint(librados, rados_inconsistent_pg_list_exit, r)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_inconsistent_pg_list_exit .state) *)&(__tracepoint_librados___rados_inconsistent_pg_list_exit .state)); })), 0)) __tracepoint_cb_librados___rados_inconsistent_pg_list_exit (r); } while (0); | |||
3054 | return r; | |||
3055 | } | |||
3056 | ||||
3057 | if (len > 0 && !buf) { | |||
3058 | tracepoint(librados, rados_inconsistent_pg_list_exit, -EINVAL)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_inconsistent_pg_list_exit .state) *)&(__tracepoint_librados___rados_inconsistent_pg_list_exit .state)); })), 0)) __tracepoint_cb_librados___rados_inconsistent_pg_list_exit (-22); } while (0); | |||
3059 | return -EINVAL22; | |||
3060 | } | |||
3061 | ||||
3062 | char *b = buf; | |||
3063 | if (b) | |||
3064 | memset(b, 0, len); | |||
3065 | int needed = 0; | |||
3066 | for (const auto pg : pgs) { | |||
3067 | std::ostringstream ss; | |||
3068 | ss << pg; | |||
3069 | auto s = ss.str(); | |||
3070 | unsigned rl = s.length() + 1; | |||
3071 | if (len >= rl) { | |||
3072 | tracepoint(librados, rados_inconsistent_pg_list_pg, s.c_str())do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_inconsistent_pg_list_pg .state) *)&(__tracepoint_librados___rados_inconsistent_pg_list_pg .state)); })), 0)) __tracepoint_cb_librados___rados_inconsistent_pg_list_pg (s.c_str()); } while (0); | |||
3073 | strncat(b, s.c_str(), rl); | |||
3074 | b += rl; | |||
3075 | len -= rl; | |||
3076 | } | |||
3077 | needed += rl; | |||
3078 | } | |||
3079 | int retval = needed + 1; | |||
3080 | tracepoint(librados, rados_inconsistent_pg_list_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_inconsistent_pg_list_exit .state) *)&(__tracepoint_librados___rados_inconsistent_pg_list_exit .state)); })), 0)) __tracepoint_cb_librados___rados_inconsistent_pg_list_exit (retval); } while (0); | |||
3081 | return retval; | |||
3082 | } | |||
3083 | ||||
3084 | static void do_out_buffer(bufferlist& outbl, char **outbuf, size_t *outbuflen) | |||
3085 | { | |||
3086 | if (outbuf) { | |||
3087 | if (outbl.length() > 0) { | |||
3088 | *outbuf = (char *)malloc(outbl.length()); | |||
3089 | memcpy(*outbuf, outbl.c_str(), outbl.length()); | |||
3090 | } else { | |||
3091 | *outbuf = NULL__null; | |||
3092 | } | |||
3093 | } | |||
3094 | if (outbuflen) | |||
3095 | *outbuflen = outbl.length(); | |||
3096 | } | |||
3097 | ||||
3098 | static void do_out_buffer(string& outbl, char **outbuf, size_t *outbuflen) | |||
3099 | { | |||
3100 | if (outbuf) { | |||
3101 | if (outbl.length() > 0) { | |||
3102 | *outbuf = (char *)malloc(outbl.length()); | |||
3103 | memcpy(*outbuf, outbl.c_str(), outbl.length()); | |||
3104 | } else { | |||
3105 | *outbuf = NULL__null; | |||
3106 | } | |||
3107 | } | |||
3108 | if (outbuflen) | |||
3109 | *outbuflen = outbl.length(); | |||
3110 | } | |||
3111 | ||||
3112 | extern "C" int rados_ping_monitor(rados_t cluster, const char *mon_id, | |||
3113 | char **outstr, size_t *outstrlen) | |||
3114 | { | |||
3115 | tracepoint(librados, rados_ping_monitor_enter, cluster, mon_id)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ping_monitor_enter .state) *)&(__tracepoint_librados___rados_ping_monitor_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ping_monitor_enter (cluster, mon_id); } while (0); | |||
3116 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
3117 | string str; | |||
3118 | ||||
3119 | if (!mon_id) { | |||
3120 | tracepoint(librados, rados_ping_monitor_exit, -EINVAL, NULL, NULL)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ping_monitor_exit .state) *)&(__tracepoint_librados___rados_ping_monitor_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ping_monitor_exit (-22, __null, __null); } while (0); | |||
3121 | return -EINVAL22; | |||
3122 | } | |||
3123 | ||||
3124 | int ret = client->ping_monitor(mon_id, &str); | |||
3125 | if (ret == 0) { | |||
3126 | do_out_buffer(str, outstr, outstrlen); | |||
3127 | } | |||
3128 | tracepoint(librados, rados_ping_monitor_exit, ret, ret < 0 ? NULL : outstr, ret < 0 ? NULL : outstrlen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ping_monitor_exit .state) *)&(__tracepoint_librados___rados_ping_monitor_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ping_monitor_exit (ret, ret < 0 ? __null : outstr, ret < 0 ? __null : outstrlen ); } while (0); | |||
3129 | return ret; | |||
3130 | } | |||
3131 | ||||
3132 | extern "C" int rados_mon_command(rados_t cluster, const char **cmd, | |||
3133 | size_t cmdlen, | |||
3134 | const char *inbuf, size_t inbuflen, | |||
3135 | char **outbuf, size_t *outbuflen, | |||
3136 | char **outs, size_t *outslen) | |||
3137 | { | |||
3138 | tracepoint(librados, rados_mon_command_enter, cluster, cmdlen, inbuf, inbuflen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_mon_command_enter .state) *)&(__tracepoint_librados___rados_mon_command_enter .state)); })), 0)) __tracepoint_cb_librados___rados_mon_command_enter (cluster, cmdlen, inbuf, inbuflen); } while (0); | |||
3139 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
3140 | bufferlist inbl; | |||
3141 | bufferlist outbl; | |||
3142 | string outstring; | |||
3143 | vector<string> cmdvec; | |||
3144 | ||||
3145 | for (size_t i = 0; i < cmdlen; i++) { | |||
3146 | tracepoint(librados, rados_mon_command_cmd, cmd[i])do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_mon_command_cmd .state) *)&(__tracepoint_librados___rados_mon_command_cmd .state)); })), 0)) __tracepoint_cb_librados___rados_mon_command_cmd (cmd[i]); } while (0); | |||
3147 | cmdvec.push_back(cmd[i]); | |||
3148 | } | |||
3149 | ||||
3150 | inbl.append(inbuf, inbuflen); | |||
3151 | int ret = client->mon_command(cmdvec, inbl, &outbl, &outstring); | |||
3152 | ||||
3153 | do_out_buffer(outbl, outbuf, outbuflen); | |||
3154 | do_out_buffer(outstring, outs, outslen); | |||
3155 | tracepoint(librados, rados_mon_command_exit, ret, outbuf, outbuflen, outs, outslen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_mon_command_exit .state) *)&(__tracepoint_librados___rados_mon_command_exit .state)); })), 0)) __tracepoint_cb_librados___rados_mon_command_exit (ret, outbuf, outbuflen, outs, outslen); } while (0); | |||
3156 | return ret; | |||
3157 | } | |||
3158 | ||||
3159 | extern "C" int rados_mon_command_target(rados_t cluster, const char *name, | |||
3160 | const char **cmd, | |||
3161 | size_t cmdlen, | |||
3162 | const char *inbuf, size_t inbuflen, | |||
3163 | char **outbuf, size_t *outbuflen, | |||
3164 | char **outs, size_t *outslen) | |||
3165 | { | |||
3166 | tracepoint(librados, rados_mon_command_target_enter, cluster, name, cmdlen, inbuf, inbuflen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_mon_command_target_enter .state) *)&(__tracepoint_librados___rados_mon_command_target_enter .state)); })), 0)) __tracepoint_cb_librados___rados_mon_command_target_enter (cluster, name, cmdlen, inbuf, inbuflen); } while (0); | |||
3167 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
3168 | bufferlist inbl; | |||
3169 | bufferlist outbl; | |||
3170 | string outstring; | |||
3171 | vector<string> cmdvec; | |||
3172 | ||||
3173 | // is this a numeric id? | |||
3174 | char *endptr; | |||
3175 | errno(*__errno_location ()) = 0; | |||
3176 | long rank = strtol(name, &endptr, 10); | |||
3177 | if ((errno(*__errno_location ()) == ERANGE34 && (rank == LONG_MAX9223372036854775807L || rank == LONG_MIN(-9223372036854775807L -1L))) || | |||
3178 | (errno(*__errno_location ()) != 0 && rank == 0) || | |||
3179 | endptr == name || // no digits | |||
3180 | *endptr != '\0') { // extra characters | |||
3181 | rank = -1; | |||
3182 | } | |||
3183 | ||||
3184 | for (size_t i = 0; i < cmdlen; i++) { | |||
3185 | tracepoint(librados, rados_mon_command_target_cmd, cmd[i])do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_mon_command_target_cmd .state) *)&(__tracepoint_librados___rados_mon_command_target_cmd .state)); })), 0)) __tracepoint_cb_librados___rados_mon_command_target_cmd (cmd[i]); } while (0); | |||
3186 | cmdvec.push_back(cmd[i]); | |||
3187 | } | |||
3188 | ||||
3189 | inbl.append(inbuf, inbuflen); | |||
3190 | int ret; | |||
3191 | if (rank >= 0) | |||
3192 | ret = client->mon_command(rank, cmdvec, inbl, &outbl, &outstring); | |||
3193 | else | |||
3194 | ret = client->mon_command(name, cmdvec, inbl, &outbl, &outstring); | |||
3195 | ||||
3196 | do_out_buffer(outbl, outbuf, outbuflen); | |||
3197 | do_out_buffer(outstring, outs, outslen); | |||
3198 | tracepoint(librados, rados_mon_command_target_exit, ret, outbuf, outbuflen, outs, outslen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_mon_command_target_exit .state) *)&(__tracepoint_librados___rados_mon_command_target_exit .state)); })), 0)) __tracepoint_cb_librados___rados_mon_command_target_exit (ret, outbuf, outbuflen, outs, outslen); } while (0); | |||
3199 | return ret; | |||
3200 | } | |||
3201 | ||||
3202 | extern "C" int rados_osd_command(rados_t cluster, int osdid, const char **cmd, | |||
3203 | size_t cmdlen, | |||
3204 | const char *inbuf, size_t inbuflen, | |||
3205 | char **outbuf, size_t *outbuflen, | |||
3206 | char **outs, size_t *outslen) | |||
3207 | { | |||
3208 | tracepoint(librados, rados_osd_command_enter, cluster, osdid, cmdlen, inbuf, inbuflen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_osd_command_enter .state) *)&(__tracepoint_librados___rados_osd_command_enter .state)); })), 0)) __tracepoint_cb_librados___rados_osd_command_enter (cluster, osdid, cmdlen, inbuf, inbuflen); } while (0); | |||
3209 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
3210 | bufferlist inbl; | |||
3211 | bufferlist outbl; | |||
3212 | string outstring; | |||
3213 | vector<string> cmdvec; | |||
3214 | ||||
3215 | for (size_t i = 0; i < cmdlen; i++) { | |||
3216 | tracepoint(librados, rados_osd_command_cmd, cmd[i])do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_osd_command_cmd .state) *)&(__tracepoint_librados___rados_osd_command_cmd .state)); })), 0)) __tracepoint_cb_librados___rados_osd_command_cmd (cmd[i]); } while (0); | |||
3217 | cmdvec.push_back(cmd[i]); | |||
3218 | } | |||
3219 | ||||
3220 | inbl.append(inbuf, inbuflen); | |||
3221 | int ret = client->osd_command(osdid, cmdvec, inbl, &outbl, &outstring); | |||
3222 | ||||
3223 | do_out_buffer(outbl, outbuf, outbuflen); | |||
3224 | do_out_buffer(outstring, outs, outslen); | |||
3225 | tracepoint(librados, rados_osd_command_exit, ret, outbuf, outbuflen, outs, outslen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_osd_command_exit .state) *)&(__tracepoint_librados___rados_osd_command_exit .state)); })), 0)) __tracepoint_cb_librados___rados_osd_command_exit (ret, outbuf, outbuflen, outs, outslen); } while (0); | |||
3226 | return ret; | |||
3227 | } | |||
3228 | ||||
3229 | extern "C" int rados_mgr_command(rados_t cluster, const char **cmd, | |||
3230 | size_t cmdlen, | |||
3231 | const char *inbuf, size_t inbuflen, | |||
3232 | char **outbuf, size_t *outbuflen, | |||
3233 | char **outs, size_t *outslen) | |||
3234 | { | |||
3235 | tracepoint(librados, rados_mgr_command_enter, cluster, cmdlen, inbuf,do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_mgr_command_enter .state) *)&(__tracepoint_librados___rados_mgr_command_enter .state)); })), 0)) __tracepoint_cb_librados___rados_mgr_command_enter (cluster, cmdlen, inbuf, inbuflen); } while (0) | |||
3236 | inbuflen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_mgr_command_enter .state) *)&(__tracepoint_librados___rados_mgr_command_enter .state)); })), 0)) __tracepoint_cb_librados___rados_mgr_command_enter (cluster, cmdlen, inbuf, inbuflen); } while (0); | |||
3237 | ||||
3238 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
3239 | bufferlist inbl; | |||
3240 | bufferlist outbl; | |||
3241 | string outstring; | |||
3242 | vector<string> cmdvec; | |||
3243 | ||||
3244 | for (size_t i = 0; i < cmdlen; i++) { | |||
3245 | tracepoint(librados, rados_mgr_command_cmd, cmd[i])do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_mgr_command_cmd .state) *)&(__tracepoint_librados___rados_mgr_command_cmd .state)); })), 0)) __tracepoint_cb_librados___rados_mgr_command_cmd (cmd[i]); } while (0); | |||
3246 | cmdvec.push_back(cmd[i]); | |||
3247 | } | |||
3248 | ||||
3249 | inbl.append(inbuf, inbuflen); | |||
3250 | int ret = client->mgr_command(cmdvec, inbl, &outbl, &outstring); | |||
3251 | ||||
3252 | do_out_buffer(outbl, outbuf, outbuflen); | |||
3253 | do_out_buffer(outstring, outs, outslen); | |||
3254 | tracepoint(librados, rados_mgr_command_exit, ret, outbuf, outbuflen, outs,do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_mgr_command_exit .state) *)&(__tracepoint_librados___rados_mgr_command_exit .state)); })), 0)) __tracepoint_cb_librados___rados_mgr_command_exit (ret, outbuf, outbuflen, outs, outslen); } while (0) | |||
3255 | outslen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_mgr_command_exit .state) *)&(__tracepoint_librados___rados_mgr_command_exit .state)); })), 0)) __tracepoint_cb_librados___rados_mgr_command_exit (ret, outbuf, outbuflen, outs, outslen); } while (0); | |||
3256 | return ret; | |||
3257 | } | |||
3258 | ||||
3259 | extern "C" int rados_pg_command(rados_t cluster, const char *pgstr, | |||
3260 | const char **cmd, size_t cmdlen, | |||
3261 | const char *inbuf, size_t inbuflen, | |||
3262 | char **outbuf, size_t *outbuflen, | |||
3263 | char **outs, size_t *outslen) | |||
3264 | { | |||
3265 | tracepoint(librados, rados_pg_command_enter, cluster, pgstr, cmdlen, inbuf, inbuflen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pg_command_enter .state) *)&(__tracepoint_librados___rados_pg_command_enter .state)); })), 0)) __tracepoint_cb_librados___rados_pg_command_enter (cluster, pgstr, cmdlen, inbuf, inbuflen); } while (0); | |||
3266 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
3267 | bufferlist inbl; | |||
3268 | bufferlist outbl; | |||
3269 | string outstring; | |||
3270 | pg_t pgid; | |||
3271 | vector<string> cmdvec; | |||
3272 | ||||
3273 | for (size_t i = 0; i < cmdlen; i++) { | |||
3274 | tracepoint(librados, rados_pg_command_cmd, cmd[i])do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pg_command_cmd .state) *)&(__tracepoint_librados___rados_pg_command_cmd. state)); })), 0)) __tracepoint_cb_librados___rados_pg_command_cmd (cmd[i]); } while (0); | |||
3275 | cmdvec.push_back(cmd[i]); | |||
3276 | } | |||
3277 | ||||
3278 | inbl.append(inbuf, inbuflen); | |||
3279 | if (!pgid.parse(pgstr)) | |||
3280 | return -EINVAL22; | |||
3281 | ||||
3282 | int ret = client->pg_command(pgid, cmdvec, inbl, &outbl, &outstring); | |||
3283 | ||||
3284 | do_out_buffer(outbl, outbuf, outbuflen); | |||
3285 | do_out_buffer(outstring, outs, outslen); | |||
3286 | tracepoint(librados, rados_pg_command_exit, ret, outbuf, outbuflen, outs, outslen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pg_command_exit .state) *)&(__tracepoint_librados___rados_pg_command_exit .state)); })), 0)) __tracepoint_cb_librados___rados_pg_command_exit (ret, outbuf, outbuflen, outs, outslen); } while (0); | |||
3287 | return ret; | |||
3288 | } | |||
3289 | ||||
3290 | extern "C" void rados_buffer_free(char *buf) | |||
3291 | { | |||
3292 | tracepoint(librados, rados_buffer_free_enter, buf)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_buffer_free_enter .state) *)&(__tracepoint_librados___rados_buffer_free_enter .state)); })), 0)) __tracepoint_cb_librados___rados_buffer_free_enter (buf); } while (0); | |||
3293 | if (buf) | |||
3294 | free(buf); | |||
3295 | tracepoint(librados, rados_buffer_free_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_buffer_free_exit .state) *)&(__tracepoint_librados___rados_buffer_free_exit .state)); })), 0)) __tracepoint_cb_librados___rados_buffer_free_exit (); } while (0); | |||
3296 | } | |||
3297 | ||||
3298 | extern "C" int rados_monitor_log(rados_t cluster, const char *level, rados_log_callback_t cb, void *arg) | |||
3299 | { | |||
3300 | tracepoint(librados, rados_monitor_log_enter, cluster, level, cb, arg)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_monitor_log_enter .state) *)&(__tracepoint_librados___rados_monitor_log_enter .state)); })), 0)) __tracepoint_cb_librados___rados_monitor_log_enter (cluster, level, cb, arg); } while (0); | |||
3301 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
3302 | int retval = client->monitor_log(level, cb, arg); | |||
3303 | tracepoint(librados, rados_monitor_log_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_monitor_log_exit .state) *)&(__tracepoint_librados___rados_monitor_log_exit .state)); })), 0)) __tracepoint_cb_librados___rados_monitor_log_exit (retval); } while (0); | |||
3304 | return retval; | |||
3305 | } | |||
3306 | ||||
3307 | extern "C" int rados_ioctx_create(rados_t cluster, const char *name, rados_ioctx_t *io) | |||
3308 | { | |||
3309 | tracepoint(librados, rados_ioctx_create_enter, cluster, name)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_create_enter .state) *)&(__tracepoint_librados___rados_ioctx_create_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_create_enter (cluster, name); } while (0); | |||
3310 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
3311 | librados::IoCtxImpl *ctx; | |||
3312 | ||||
3313 | int r = client->create_ioctx(name, &ctx); | |||
3314 | if (r < 0) { | |||
3315 | tracepoint(librados, rados_ioctx_create_exit, r, NULL)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_create_exit .state) *)&(__tracepoint_librados___rados_ioctx_create_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_create_exit (r, __null); } while (0); | |||
3316 | return r; | |||
3317 | } | |||
3318 | ||||
3319 | *io = ctx; | |||
3320 | ctx->get(); | |||
3321 | tracepoint(librados, rados_ioctx_create_exit, 0, ctx)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_create_exit .state) *)&(__tracepoint_librados___rados_ioctx_create_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_create_exit (0, ctx); } while (0); | |||
3322 | return 0; | |||
3323 | } | |||
3324 | ||||
3325 | extern "C" int rados_ioctx_create2(rados_t cluster, int64_t pool_id, | |||
3326 | rados_ioctx_t *io) | |||
3327 | { | |||
3328 | tracepoint(librados, rados_ioctx_create2_enter, cluster, pool_id)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_create2_enter .state) *)&(__tracepoint_librados___rados_ioctx_create2_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_create2_enter (cluster, pool_id); } while (0); | |||
3329 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
3330 | librados::IoCtxImpl *ctx; | |||
3331 | ||||
3332 | int r = client->create_ioctx(pool_id, &ctx); | |||
3333 | if (r < 0) { | |||
3334 | tracepoint(librados, rados_ioctx_create2_exit, r, NULL)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_create2_exit .state) *)&(__tracepoint_librados___rados_ioctx_create2_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_create2_exit (r, __null); } while (0); | |||
3335 | return r; | |||
3336 | } | |||
3337 | ||||
3338 | *io = ctx; | |||
3339 | ctx->get(); | |||
3340 | tracepoint(librados, rados_ioctx_create2_exit, 0, ctx)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_create2_exit .state) *)&(__tracepoint_librados___rados_ioctx_create2_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_create2_exit (0, ctx); } while (0); | |||
3341 | return 0; | |||
3342 | } | |||
3343 | ||||
3344 | extern "C" void rados_ioctx_destroy(rados_ioctx_t io) | |||
3345 | { | |||
3346 | tracepoint(librados, rados_ioctx_destroy_enter, io)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_destroy_enter .state) *)&(__tracepoint_librados___rados_ioctx_destroy_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_destroy_enter (io); } while (0); | |||
3347 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3348 | ctx->put(); | |||
3349 | tracepoint(librados, rados_ioctx_destroy_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_destroy_exit .state) *)&(__tracepoint_librados___rados_ioctx_destroy_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_destroy_exit (); } while (0); | |||
3350 | } | |||
3351 | ||||
3352 | extern "C" int rados_ioctx_pool_stat(rados_ioctx_t io, struct rados_pool_stat_t *stats) | |||
3353 | { | |||
3354 | tracepoint(librados, rados_ioctx_pool_stat_enter, io)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_stat_enter .state) *)&(__tracepoint_librados___rados_ioctx_pool_stat_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_stat_enter (io); } while (0); | |||
3355 | librados::IoCtxImpl *io_ctx_impl = (librados::IoCtxImpl *)io; | |||
3356 | list<string> ls; | |||
3357 | std::string pool_name; | |||
3358 | ||||
3359 | int err = io_ctx_impl->client->pool_get_name(io_ctx_impl->get_id(), &pool_name); | |||
3360 | if (err) { | |||
3361 | tracepoint(librados, rados_ioctx_pool_stat_exit, err, stats)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_stat_exit .state) *)&(__tracepoint_librados___rados_ioctx_pool_stat_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_stat_exit (err, stats); } while (0); | |||
3362 | return err; | |||
3363 | } | |||
3364 | ls.push_back(pool_name); | |||
3365 | ||||
3366 | map<string, ::pool_stat_t> rawresult; | |||
3367 | err = io_ctx_impl->client->get_pool_stats(ls, rawresult); | |||
3368 | if (err) { | |||
3369 | tracepoint(librados, rados_ioctx_pool_stat_exit, err, stats)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_stat_exit .state) *)&(__tracepoint_librados___rados_ioctx_pool_stat_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_stat_exit (err, stats); } while (0); | |||
3370 | return err; | |||
3371 | } | |||
3372 | ||||
3373 | ::pool_stat_t& r = rawresult[pool_name]; | |||
3374 | stats->num_kb = SHIFT_ROUND_UP(r.stats.sum.num_bytes, 10)(((r.stats.sum.num_bytes)+(1<<(10))-1) >> (10)); | |||
3375 | stats->num_bytes = r.stats.sum.num_bytes; | |||
3376 | stats->num_objects = r.stats.sum.num_objects; | |||
3377 | stats->num_object_clones = r.stats.sum.num_object_clones; | |||
3378 | stats->num_object_copies = r.stats.sum.num_object_copies; | |||
3379 | stats->num_objects_missing_on_primary = r.stats.sum.num_objects_missing_on_primary; | |||
3380 | stats->num_objects_unfound = r.stats.sum.num_objects_unfound; | |||
3381 | stats->num_objects_degraded = | |||
3382 | r.stats.sum.num_objects_degraded + | |||
3383 | r.stats.sum.num_objects_misplaced; // FIXME: this is imprecise | |||
3384 | stats->num_rd = r.stats.sum.num_rd; | |||
3385 | stats->num_rd_kb = r.stats.sum.num_rd_kb; | |||
3386 | stats->num_wr = r.stats.sum.num_wr; | |||
3387 | stats->num_wr_kb = r.stats.sum.num_wr_kb; | |||
3388 | tracepoint(librados, rados_ioctx_pool_stat_exit, 0, stats)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_stat_exit .state) *)&(__tracepoint_librados___rados_ioctx_pool_stat_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_stat_exit (0, stats); } while (0); | |||
3389 | return 0; | |||
3390 | } | |||
3391 | ||||
3392 | extern "C" rados_config_t rados_ioctx_cct(rados_ioctx_t io) | |||
3393 | { | |||
3394 | tracepoint(librados, rados_ioctx_cct_enter, io)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_cct_enter .state) *)&(__tracepoint_librados___rados_ioctx_cct_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_cct_enter (io); } while (0); | |||
3395 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3396 | rados_config_t retval = (rados_config_t)ctx->client->cct; | |||
3397 | tracepoint(librados, rados_ioctx_cct_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_cct_exit .state) *)&(__tracepoint_librados___rados_ioctx_cct_exit. state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_cct_exit (retval); } while (0); | |||
3398 | return retval; | |||
3399 | } | |||
3400 | ||||
3401 | extern "C" void rados_ioctx_snap_set_read(rados_ioctx_t io, rados_snap_t seq) | |||
3402 | { | |||
3403 | tracepoint(librados, rados_ioctx_snap_set_read_enter, io, seq)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_set_read_enter .state) *)&(__tracepoint_librados___rados_ioctx_snap_set_read_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_set_read_enter (io, seq); } while (0); | |||
3404 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3405 | ctx->set_snap_read((snapid_t)seq); | |||
3406 | tracepoint(librados, rados_ioctx_snap_set_read_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_set_read_exit .state) *)&(__tracepoint_librados___rados_ioctx_snap_set_read_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_set_read_exit (); } while (0); | |||
3407 | } | |||
3408 | ||||
3409 | extern "C" int rados_ioctx_selfmanaged_snap_set_write_ctx(rados_ioctx_t io, | |||
3410 | rados_snap_t seq, rados_snap_t *snaps, int num_snaps) | |||
3411 | { | |||
3412 | tracepoint(librados, rados_ioctx_selfmanaged_snap_set_write_ctx_enter, io, seq, snaps, num_snaps)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_selfmanaged_snap_set_write_ctx_enter .state) *)&(__tracepoint_librados___rados_ioctx_selfmanaged_snap_set_write_ctx_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_selfmanaged_snap_set_write_ctx_enter (io, seq, snaps, num_snaps); } while (0); | |||
3413 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3414 | vector<snapid_t> snv; | |||
3415 | snv.resize(num_snaps); | |||
3416 | for (int i=0; i<num_snaps; i++) { | |||
3417 | snv[i] = (snapid_t)snaps[i]; | |||
3418 | } | |||
3419 | int retval = ctx->set_snap_write_context((snapid_t)seq, snv); | |||
3420 | tracepoint(librados, rados_ioctx_selfmanaged_snap_set_write_ctx_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_selfmanaged_snap_set_write_ctx_exit .state) *)&(__tracepoint_librados___rados_ioctx_selfmanaged_snap_set_write_ctx_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_selfmanaged_snap_set_write_ctx_exit (retval); } while (0); | |||
3421 | return retval; | |||
3422 | } | |||
3423 | ||||
3424 | extern "C" int rados_write(rados_ioctx_t io, const char *o, const char *buf, size_t len, uint64_t off) | |||
3425 | { | |||
3426 | tracepoint(librados, rados_write_enter, io, o, buf, len, off)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_enter .state) *)&(__tracepoint_librados___rados_write_enter.state )); })), 0)) __tracepoint_cb_librados___rados_write_enter(io, o, buf, len, off); } while (0); | |||
3427 | if (len > UINT_MAX(2147483647 *2U +1U)/2) | |||
3428 | return -E2BIG7; | |||
3429 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3430 | object_t oid(o); | |||
3431 | bufferlist bl; | |||
3432 | bl.append(buf, len); | |||
3433 | int retval = ctx->write(oid, bl, len, off); | |||
3434 | tracepoint(librados, rados_write_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_exit .state) *)&(__tracepoint_librados___rados_write_exit.state )); })), 0)) __tracepoint_cb_librados___rados_write_exit(retval ); } while (0); | |||
3435 | return retval; | |||
3436 | } | |||
3437 | ||||
3438 | extern "C" int rados_append(rados_ioctx_t io, const char *o, const char *buf, size_t len) | |||
3439 | { | |||
3440 | tracepoint(librados, rados_append_enter, io, o, buf, len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_append_enter .state) *)&(__tracepoint_librados___rados_append_enter.state )); })), 0)) __tracepoint_cb_librados___rados_append_enter(io , o, buf, len); } while (0); | |||
3441 | if (len > UINT_MAX(2147483647 *2U +1U)/2) | |||
3442 | return -E2BIG7; | |||
3443 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3444 | object_t oid(o); | |||
3445 | bufferlist bl; | |||
3446 | bl.append(buf, len); | |||
3447 | int retval = ctx->append(oid, bl, len); | |||
3448 | tracepoint(librados, rados_append_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_append_exit .state) *)&(__tracepoint_librados___rados_append_exit.state )); })), 0)) __tracepoint_cb_librados___rados_append_exit(retval ); } while (0); | |||
3449 | return retval; | |||
3450 | } | |||
3451 | ||||
3452 | extern "C" int rados_write_full(rados_ioctx_t io, const char *o, const char *buf, size_t len) | |||
3453 | { | |||
3454 | tracepoint(librados, rados_write_full_enter, io, o, buf, len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_full_enter .state) *)&(__tracepoint_librados___rados_write_full_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_full_enter (io, o, buf, len); } while (0); | |||
3455 | if (len > UINT_MAX(2147483647 *2U +1U)/2) | |||
3456 | return -E2BIG7; | |||
3457 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3458 | object_t oid(o); | |||
3459 | bufferlist bl; | |||
3460 | bl.append(buf, len); | |||
3461 | int retval = ctx->write_full(oid, bl); | |||
3462 | tracepoint(librados, rados_write_full_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_full_exit .state) *)&(__tracepoint_librados___rados_write_full_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_full_exit (retval); } while (0); | |||
3463 | return retval; | |||
3464 | } | |||
3465 | ||||
3466 | extern "C" int rados_writesame(rados_ioctx_t io, | |||
3467 | const char *o, | |||
3468 | const char *buf, | |||
3469 | size_t data_len, | |||
3470 | size_t write_len, | |||
3471 | uint64_t off) | |||
3472 | { | |||
3473 | tracepoint(librados, rados_writesame_enter, io, o, buf, data_len, write_len, off)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_writesame_enter .state) *)&(__tracepoint_librados___rados_writesame_enter .state)); })), 0)) __tracepoint_cb_librados___rados_writesame_enter (io, o, buf, data_len, write_len, off); } while (0); | |||
3474 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3475 | object_t oid(o); | |||
3476 | bufferlist bl; | |||
3477 | bl.append(buf, data_len); | |||
3478 | int retval = ctx->writesame(oid, bl, write_len, off); | |||
3479 | tracepoint(librados, rados_writesame_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_writesame_exit .state) *)&(__tracepoint_librados___rados_writesame_exit. state)); })), 0)) __tracepoint_cb_librados___rados_writesame_exit (retval); } while (0); | |||
3480 | return retval; | |||
3481 | } | |||
3482 | ||||
3483 | extern "C" int rados_clone_range(rados_ioctx_t io, const char *dst, uint64_t dst_off, | |||
3484 | const char *src, uint64_t src_off, size_t len) | |||
3485 | { | |||
3486 | tracepoint(librados, rados_clone_range_enter, io, dst, dst_off, src, src_off, len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_clone_range_enter .state) *)&(__tracepoint_librados___rados_clone_range_enter .state)); })), 0)) __tracepoint_cb_librados___rados_clone_range_enter (io, dst, dst_off, src, src_off, len); } while (0); | |||
3487 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3488 | object_t dst_oid(dst), src_oid(src); | |||
3489 | int retval = ctx->clone_range(dst_oid, dst_off, src_oid, src_off, len); | |||
3490 | tracepoint(librados, rados_clone_range_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_clone_range_exit .state) *)&(__tracepoint_librados___rados_clone_range_exit .state)); })), 0)) __tracepoint_cb_librados___rados_clone_range_exit (retval); } while (0); | |||
3491 | return retval; | |||
3492 | } | |||
3493 | ||||
3494 | extern "C" int rados_trunc(rados_ioctx_t io, const char *o, uint64_t size) | |||
3495 | { | |||
3496 | tracepoint(librados, rados_trunc_enter, io, o, size)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_trunc_enter .state) *)&(__tracepoint_librados___rados_trunc_enter.state )); })), 0)) __tracepoint_cb_librados___rados_trunc_enter(io, o, size); } while (0); | |||
3497 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3498 | object_t oid(o); | |||
3499 | int retval = ctx->trunc(oid, size); | |||
3500 | tracepoint(librados, rados_trunc_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_trunc_exit .state) *)&(__tracepoint_librados___rados_trunc_exit.state )); })), 0)) __tracepoint_cb_librados___rados_trunc_exit(retval ); } while (0); | |||
3501 | return retval; | |||
3502 | } | |||
3503 | ||||
3504 | extern "C" int rados_remove(rados_ioctx_t io, const char *o) | |||
3505 | { | |||
3506 | tracepoint(librados, rados_remove_enter, io, o)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_remove_enter .state) *)&(__tracepoint_librados___rados_remove_enter.state )); })), 0)) __tracepoint_cb_librados___rados_remove_enter(io , o); } while (0); | |||
3507 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3508 | object_t oid(o); | |||
3509 | int retval = ctx->remove(oid); | |||
3510 | tracepoint(librados, rados_remove_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_remove_exit .state) *)&(__tracepoint_librados___rados_remove_exit.state )); })), 0)) __tracepoint_cb_librados___rados_remove_exit(retval ); } while (0); | |||
3511 | return retval; | |||
3512 | } | |||
3513 | ||||
3514 | extern "C" int rados_read(rados_ioctx_t io, const char *o, char *buf, size_t len, uint64_t off) | |||
3515 | { | |||
3516 | tracepoint(librados, rados_read_enter, io, o, buf, len, off)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_enter .state) *)&(__tracepoint_librados___rados_read_enter.state )); })), 0)) __tracepoint_cb_librados___rados_read_enter(io, o , buf, len, off); } while (0); | |||
3517 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3518 | int ret; | |||
3519 | object_t oid(o); | |||
3520 | ||||
3521 | bufferlist bl; | |||
3522 | bufferptr bp = buffer::create_static(len, buf); | |||
3523 | bl.push_back(bp); | |||
3524 | ||||
3525 | ret = ctx->read(oid, bl, len, off); | |||
3526 | if (ret >= 0) { | |||
3527 | if (bl.length() > len) { | |||
3528 | tracepoint(librados, rados_read_exit, -ERANGE, NULL)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_exit .state) *)&(__tracepoint_librados___rados_read_exit.state )); })), 0)) __tracepoint_cb_librados___rados_read_exit(-34, __null ); } while (0); | |||
3529 | return -ERANGE34; | |||
3530 | } | |||
3531 | if (!bl.is_provided_buffer(buf)) | |||
3532 | bl.copy(0, bl.length(), buf); | |||
3533 | ret = bl.length(); // hrm :/ | |||
3534 | } | |||
3535 | ||||
3536 | tracepoint(librados, rados_read_exit, ret, buf)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_exit .state) *)&(__tracepoint_librados___rados_read_exit.state )); })), 0)) __tracepoint_cb_librados___rados_read_exit(ret, buf ); } while (0); | |||
3537 | return ret; | |||
3538 | } | |||
3539 | ||||
3540 | extern "C" uint64_t rados_get_last_version(rados_ioctx_t io) | |||
3541 | { | |||
3542 | tracepoint(librados, rados_get_last_version_enter, io)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_get_last_version_enter .state) *)&(__tracepoint_librados___rados_get_last_version_enter .state)); })), 0)) __tracepoint_cb_librados___rados_get_last_version_enter (io); } while (0); | |||
3543 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3544 | uint64_t retval = ctx->last_version(); | |||
3545 | tracepoint(librados, rados_get_last_version_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_get_last_version_exit .state) *)&(__tracepoint_librados___rados_get_last_version_exit .state)); })), 0)) __tracepoint_cb_librados___rados_get_last_version_exit (retval); } while (0); | |||
3546 | return retval; | |||
3547 | } | |||
3548 | ||||
3549 | extern "C" int rados_pool_create(rados_t cluster, const char *name) | |||
3550 | { | |||
3551 | tracepoint(librados, rados_pool_create_enter, cluster, name)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_create_enter .state) *)&(__tracepoint_librados___rados_pool_create_enter .state)); })), 0)) __tracepoint_cb_librados___rados_pool_create_enter (cluster, name); } while (0); | |||
3552 | librados::RadosClient *radosp = (librados::RadosClient *)cluster; | |||
3553 | string sname(name); | |||
3554 | int retval = radosp->pool_create(sname); | |||
3555 | tracepoint(librados, rados_pool_create_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_create_exit .state) *)&(__tracepoint_librados___rados_pool_create_exit .state)); })), 0)) __tracepoint_cb_librados___rados_pool_create_exit (retval); } while (0); | |||
3556 | return retval; | |||
3557 | } | |||
3558 | ||||
3559 | extern "C" int rados_pool_create_with_auid(rados_t cluster, const char *name, | |||
3560 | uint64_t auid) | |||
3561 | { | |||
3562 | tracepoint(librados, rados_pool_create_with_auid_enter, cluster, name, auid)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_create_with_auid_enter .state) *)&(__tracepoint_librados___rados_pool_create_with_auid_enter .state)); })), 0)) __tracepoint_cb_librados___rados_pool_create_with_auid_enter (cluster, name, auid); } while (0); | |||
3563 | librados::RadosClient *radosp = (librados::RadosClient *)cluster; | |||
3564 | string sname(name); | |||
3565 | int retval = radosp->pool_create(sname, auid); | |||
3566 | tracepoint(librados, rados_pool_create_with_auid_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_create_with_auid_exit .state) *)&(__tracepoint_librados___rados_pool_create_with_auid_exit .state)); })), 0)) __tracepoint_cb_librados___rados_pool_create_with_auid_exit (retval); } while (0); | |||
3567 | return retval; | |||
3568 | } | |||
3569 | ||||
3570 | extern "C" int rados_pool_create_with_crush_rule(rados_t cluster, const char *name, | |||
3571 | __u8 crush_rule_num) | |||
3572 | { | |||
3573 | tracepoint(librados, rados_pool_create_with_crush_rule_enter, cluster, name, crush_rule_num)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_create_with_crush_rule_enter .state) *)&(__tracepoint_librados___rados_pool_create_with_crush_rule_enter .state)); })), 0)) __tracepoint_cb_librados___rados_pool_create_with_crush_rule_enter (cluster, name, crush_rule_num); } while (0); | |||
3574 | librados::RadosClient *radosp = (librados::RadosClient *)cluster; | |||
3575 | string sname(name); | |||
3576 | int retval = radosp->pool_create(sname, 0, crush_rule_num); | |||
3577 | tracepoint(librados, rados_pool_create_with_crush_rule_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_create_with_crush_rule_exit .state) *)&(__tracepoint_librados___rados_pool_create_with_crush_rule_exit .state)); })), 0)) __tracepoint_cb_librados___rados_pool_create_with_crush_rule_exit (retval); } while (0); | |||
3578 | return retval; | |||
3579 | } | |||
3580 | ||||
3581 | extern "C" int rados_pool_create_with_all(rados_t cluster, const char *name, | |||
3582 | uint64_t auid, __u8 crush_rule_num) | |||
3583 | { | |||
3584 | tracepoint(librados, rados_pool_create_with_all_enter, cluster, name, auid, crush_rule_num)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_create_with_all_enter .state) *)&(__tracepoint_librados___rados_pool_create_with_all_enter .state)); })), 0)) __tracepoint_cb_librados___rados_pool_create_with_all_enter (cluster, name, auid, crush_rule_num); } while (0); | |||
3585 | librados::RadosClient *radosp = (librados::RadosClient *)cluster; | |||
3586 | string sname(name); | |||
3587 | int retval = radosp->pool_create(sname, auid, crush_rule_num); | |||
3588 | tracepoint(librados, rados_pool_create_with_all_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_create_with_all_exit .state) *)&(__tracepoint_librados___rados_pool_create_with_all_exit .state)); })), 0)) __tracepoint_cb_librados___rados_pool_create_with_all_exit (retval); } while (0); | |||
3589 | return retval; | |||
3590 | } | |||
3591 | ||||
3592 | extern "C" int rados_pool_get_base_tier(rados_t cluster, int64_t pool_id, int64_t* base_tier) | |||
3593 | { | |||
3594 | tracepoint(librados, rados_pool_get_base_tier_enter, cluster, pool_id)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_get_base_tier_enter .state) *)&(__tracepoint_librados___rados_pool_get_base_tier_enter .state)); })), 0)) __tracepoint_cb_librados___rados_pool_get_base_tier_enter (cluster, pool_id); } while (0); | |||
3595 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
3596 | int retval = client->pool_get_base_tier(pool_id, base_tier); | |||
3597 | tracepoint(librados, rados_pool_get_base_tier_exit, retval, *base_tier)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_get_base_tier_exit .state) *)&(__tracepoint_librados___rados_pool_get_base_tier_exit .state)); })), 0)) __tracepoint_cb_librados___rados_pool_get_base_tier_exit (retval, *base_tier); } while (0); | |||
3598 | return retval; | |||
3599 | } | |||
3600 | ||||
3601 | extern "C" int rados_pool_delete(rados_t cluster, const char *pool_name) | |||
3602 | { | |||
3603 | tracepoint(librados, rados_pool_delete_enter, cluster, pool_name)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_delete_enter .state) *)&(__tracepoint_librados___rados_pool_delete_enter .state)); })), 0)) __tracepoint_cb_librados___rados_pool_delete_enter (cluster, pool_name); } while (0); | |||
3604 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
3605 | int retval = client->pool_delete(pool_name); | |||
3606 | tracepoint(librados, rados_pool_delete_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_pool_delete_exit .state) *)&(__tracepoint_librados___rados_pool_delete_exit .state)); })), 0)) __tracepoint_cb_librados___rados_pool_delete_exit (retval); } while (0); | |||
3607 | return retval; | |||
3608 | } | |||
3609 | ||||
3610 | extern "C" int rados_ioctx_pool_set_auid(rados_ioctx_t io, uint64_t auid) | |||
3611 | { | |||
3612 | tracepoint(librados, rados_ioctx_pool_set_auid_enter, io, auid)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_set_auid_enter .state) *)&(__tracepoint_librados___rados_ioctx_pool_set_auid_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_set_auid_enter (io, auid); } while (0); | |||
3613 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3614 | int retval = ctx->pool_change_auid(auid); | |||
3615 | tracepoint(librados, rados_ioctx_pool_set_auid_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_set_auid_exit .state) *)&(__tracepoint_librados___rados_ioctx_pool_set_auid_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_set_auid_exit (retval); } while (0); | |||
3616 | return retval; | |||
3617 | } | |||
3618 | ||||
3619 | extern "C" int rados_ioctx_pool_get_auid(rados_ioctx_t io, uint64_t *auid) | |||
3620 | { | |||
3621 | tracepoint(librados, rados_ioctx_pool_get_auid_enter, io)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_get_auid_enter .state) *)&(__tracepoint_librados___rados_ioctx_pool_get_auid_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_get_auid_enter (io); } while (0); | |||
3622 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3623 | int retval = ctx->client->pool_get_auid(ctx->get_id(), (unsigned long long *)auid); | |||
3624 | tracepoint(librados, rados_ioctx_pool_get_auid_exit, retval, *auid)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_get_auid_exit .state) *)&(__tracepoint_librados___rados_ioctx_pool_get_auid_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_get_auid_exit (retval, *auid); } while (0); | |||
3625 | return retval; | |||
3626 | } | |||
3627 | ||||
3628 | extern "C" int rados_ioctx_pool_requires_alignment(rados_ioctx_t io) | |||
3629 | { | |||
3630 | tracepoint(librados, rados_ioctx_pool_requires_alignment_enter, io)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_requires_alignment_enter .state) *)&(__tracepoint_librados___rados_ioctx_pool_requires_alignment_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_requires_alignment_enter (io); } while (0); | |||
3631 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3632 | int retval = ctx->client->pool_requires_alignment(ctx->get_id()); | |||
3633 | tracepoint(librados, rados_ioctx_pool_requires_alignment_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_requires_alignment_exit .state) *)&(__tracepoint_librados___rados_ioctx_pool_requires_alignment_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_requires_alignment_exit (retval); } while (0); | |||
3634 | return retval; | |||
3635 | } | |||
3636 | ||||
3637 | extern "C" int rados_ioctx_pool_requires_alignment2(rados_ioctx_t io, | |||
3638 | int *requires) | |||
3639 | { | |||
3640 | tracepoint(librados, rados_ioctx_pool_requires_alignment_enter2, io)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_requires_alignment_enter2 .state) *)&(__tracepoint_librados___rados_ioctx_pool_requires_alignment_enter2 .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_requires_alignment_enter2 (io); } while (0); | |||
3641 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3642 | bool requires_alignment; | |||
3643 | int retval = ctx->client->pool_requires_alignment2(ctx->get_id(), | |||
3644 | &requires_alignment); | |||
3645 | tracepoint(librados, rados_ioctx_pool_requires_alignment_exit2, retval,do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_requires_alignment_exit2 .state) *)&(__tracepoint_librados___rados_ioctx_pool_requires_alignment_exit2 .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_requires_alignment_exit2 (retval, requires_alignment); } while (0) | |||
3646 | requires_alignment)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_requires_alignment_exit2 .state) *)&(__tracepoint_librados___rados_ioctx_pool_requires_alignment_exit2 .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_requires_alignment_exit2 (retval, requires_alignment); } while (0); | |||
3647 | if (requires) | |||
3648 | *requires = requires_alignment; | |||
3649 | return retval; | |||
3650 | } | |||
3651 | ||||
3652 | extern "C" uint64_t rados_ioctx_pool_required_alignment(rados_ioctx_t io) | |||
3653 | { | |||
3654 | tracepoint(librados, rados_ioctx_pool_required_alignment_enter, io)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_required_alignment_enter .state) *)&(__tracepoint_librados___rados_ioctx_pool_required_alignment_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_required_alignment_enter (io); } while (0); | |||
3655 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3656 | uint64_t retval = ctx->client->pool_required_alignment(ctx->get_id()); | |||
3657 | tracepoint(librados, rados_ioctx_pool_required_alignment_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_required_alignment_exit .state) *)&(__tracepoint_librados___rados_ioctx_pool_required_alignment_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_required_alignment_exit (retval); } while (0); | |||
3658 | return retval; | |||
3659 | } | |||
3660 | ||||
3661 | extern "C" int rados_ioctx_pool_required_alignment2(rados_ioctx_t io, | |||
3662 | uint64_t *alignment) | |||
3663 | { | |||
3664 | tracepoint(librados, rados_ioctx_pool_required_alignment_enter2, io)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_required_alignment_enter2 .state) *)&(__tracepoint_librados___rados_ioctx_pool_required_alignment_enter2 .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_required_alignment_enter2 (io); } while (0); | |||
3665 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3666 | int retval = ctx->client->pool_required_alignment2(ctx->get_id(), | |||
3667 | alignment); | |||
3668 | tracepoint(librados, rados_ioctx_pool_required_alignment_exit2, retval,do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_required_alignment_exit2 .state) *)&(__tracepoint_librados___rados_ioctx_pool_required_alignment_exit2 .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_required_alignment_exit2 (retval, *alignment); } while (0) | |||
3669 | *alignment)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_pool_required_alignment_exit2 .state) *)&(__tracepoint_librados___rados_ioctx_pool_required_alignment_exit2 .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_pool_required_alignment_exit2 (retval, *alignment); } while (0); | |||
3670 | return retval; | |||
3671 | } | |||
3672 | ||||
3673 | extern "C" void rados_ioctx_locator_set_key(rados_ioctx_t io, const char *key) | |||
3674 | { | |||
3675 | tracepoint(librados, rados_ioctx_locator_set_key_enter, io, key)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_locator_set_key_enter .state) *)&(__tracepoint_librados___rados_ioctx_locator_set_key_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_locator_set_key_enter (io, key); } while (0); | |||
3676 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3677 | if (key) | |||
3678 | ctx->oloc.key = key; | |||
3679 | else | |||
3680 | ctx->oloc.key = ""; | |||
3681 | tracepoint(librados, rados_ioctx_locator_set_key_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_locator_set_key_exit .state) *)&(__tracepoint_librados___rados_ioctx_locator_set_key_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_locator_set_key_exit (); } while (0); | |||
3682 | } | |||
3683 | ||||
3684 | extern "C" void rados_ioctx_set_namespace(rados_ioctx_t io, const char *nspace) | |||
3685 | { | |||
3686 | tracepoint(librados, rados_ioctx_set_namespace_enter, io, nspace)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_set_namespace_enter .state) *)&(__tracepoint_librados___rados_ioctx_set_namespace_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_set_namespace_enter (io, nspace); } while (0); | |||
3687 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3688 | if (nspace) | |||
3689 | ctx->oloc.nspace = nspace; | |||
3690 | else | |||
3691 | ctx->oloc.nspace = ""; | |||
3692 | tracepoint(librados, rados_ioctx_set_namespace_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_set_namespace_exit .state) *)&(__tracepoint_librados___rados_ioctx_set_namespace_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_set_namespace_exit (); } while (0); | |||
3693 | } | |||
3694 | ||||
3695 | extern "C" rados_t rados_ioctx_get_cluster(rados_ioctx_t io) | |||
3696 | { | |||
3697 | tracepoint(librados, rados_ioctx_get_cluster_enter, io)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_get_cluster_enter .state) *)&(__tracepoint_librados___rados_ioctx_get_cluster_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_get_cluster_enter (io); } while (0); | |||
3698 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3699 | rados_t retval = (rados_t)ctx->client; | |||
3700 | tracepoint(librados, rados_ioctx_get_cluster_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_get_cluster_exit .state) *)&(__tracepoint_librados___rados_ioctx_get_cluster_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_get_cluster_exit (retval); } while (0); | |||
3701 | return retval; | |||
3702 | } | |||
3703 | ||||
3704 | extern "C" int64_t rados_ioctx_get_id(rados_ioctx_t io) | |||
3705 | { | |||
3706 | tracepoint(librados, rados_ioctx_get_id_enter, io)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_get_id_enter .state) *)&(__tracepoint_librados___rados_ioctx_get_id_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_get_id_enter (io); } while (0); | |||
3707 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3708 | int64_t retval = ctx->get_id(); | |||
3709 | tracepoint(librados, rados_ioctx_get_id_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_get_id_exit .state) *)&(__tracepoint_librados___rados_ioctx_get_id_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_get_id_exit (retval); } while (0); | |||
3710 | return retval; | |||
3711 | } | |||
3712 | ||||
3713 | extern "C" int rados_ioctx_get_pool_name(rados_ioctx_t io, char *s, unsigned maxlen) | |||
3714 | { | |||
3715 | tracepoint(librados, rados_ioctx_get_pool_name_enter, io, maxlen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_get_pool_name_enter .state) *)&(__tracepoint_librados___rados_ioctx_get_pool_name_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_get_pool_name_enter (io, maxlen); } while (0); | |||
3716 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3717 | std::string pool_name; | |||
3718 | ||||
3719 | int err = ctx->client->pool_get_name(ctx->get_id(), &pool_name); | |||
3720 | if (err) { | |||
3721 | tracepoint(librados, rados_ioctx_get_pool_name_exit, err, "")do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_get_pool_name_exit .state) *)&(__tracepoint_librados___rados_ioctx_get_pool_name_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_get_pool_name_exit (err, ""); } while (0); | |||
3722 | return err; | |||
3723 | } | |||
3724 | if (pool_name.length() >= maxlen) { | |||
3725 | tracepoint(librados, rados_ioctx_get_pool_name_exit, -ERANGE, "")do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_get_pool_name_exit .state) *)&(__tracepoint_librados___rados_ioctx_get_pool_name_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_get_pool_name_exit (-34, ""); } while (0); | |||
3726 | return -ERANGE34; | |||
3727 | } | |||
3728 | strcpy(s, pool_name.c_str()); | |||
3729 | int retval = pool_name.length(); | |||
3730 | tracepoint(librados, rados_ioctx_get_pool_name_exit, retval, s)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_get_pool_name_exit .state) *)&(__tracepoint_librados___rados_ioctx_get_pool_name_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_get_pool_name_exit (retval, s); } while (0); | |||
3731 | return retval; | |||
3732 | } | |||
3733 | ||||
3734 | // snaps | |||
3735 | ||||
3736 | extern "C" int rados_ioctx_snap_create(rados_ioctx_t io, const char *snapname) | |||
3737 | { | |||
3738 | tracepoint(librados, rados_ioctx_snap_create_enter, io, snapname)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_create_enter .state) *)&(__tracepoint_librados___rados_ioctx_snap_create_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_create_enter (io, snapname); } while (0); | |||
3739 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3740 | int retval = ctx->snap_create(snapname); | |||
3741 | tracepoint(librados, rados_ioctx_snap_create_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_create_exit .state) *)&(__tracepoint_librados___rados_ioctx_snap_create_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_create_exit (retval); } while (0); | |||
3742 | return retval; | |||
3743 | } | |||
3744 | ||||
3745 | extern "C" int rados_ioctx_snap_remove(rados_ioctx_t io, const char *snapname) | |||
3746 | { | |||
3747 | tracepoint(librados, rados_ioctx_snap_remove_enter, io, snapname)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_remove_enter .state) *)&(__tracepoint_librados___rados_ioctx_snap_remove_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_remove_enter (io, snapname); } while (0); | |||
3748 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3749 | int retval = ctx->snap_remove(snapname); | |||
3750 | tracepoint(librados, rados_ioctx_snap_remove_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_remove_exit .state) *)&(__tracepoint_librados___rados_ioctx_snap_remove_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_remove_exit (retval); } while (0); | |||
3751 | return retval; | |||
3752 | } | |||
3753 | ||||
3754 | extern "C" int rados_ioctx_snap_rollback(rados_ioctx_t io, const char *oid, | |||
3755 | const char *snapname) | |||
3756 | { | |||
3757 | tracepoint(librados, rados_ioctx_snap_rollback_enter, io, oid, snapname)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_rollback_enter .state) *)&(__tracepoint_librados___rados_ioctx_snap_rollback_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_rollback_enter (io, oid, snapname); } while (0); | |||
3758 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3759 | int retval = ctx->rollback(oid, snapname); | |||
3760 | tracepoint(librados, rados_ioctx_snap_rollback_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_rollback_exit .state) *)&(__tracepoint_librados___rados_ioctx_snap_rollback_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_rollback_exit (retval); } while (0); | |||
3761 | return retval; | |||
3762 | } | |||
3763 | ||||
3764 | // Deprecated name kept for backward compatibility | |||
3765 | extern "C" int rados_rollback(rados_ioctx_t io, const char *oid, | |||
3766 | const char *snapname) | |||
3767 | { | |||
3768 | return rados_ioctx_snap_rollback(io, oid, snapname); | |||
3769 | } | |||
3770 | ||||
3771 | extern "C" int rados_ioctx_selfmanaged_snap_create(rados_ioctx_t io, | |||
3772 | uint64_t *snapid) | |||
3773 | { | |||
3774 | tracepoint(librados, rados_ioctx_selfmanaged_snap_create_enter, io)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_selfmanaged_snap_create_enter .state) *)&(__tracepoint_librados___rados_ioctx_selfmanaged_snap_create_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_selfmanaged_snap_create_enter (io); } while (0); | |||
3775 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3776 | int retval = ctx->selfmanaged_snap_create(snapid); | |||
3777 | tracepoint(librados, rados_ioctx_selfmanaged_snap_create_exit, retval, *snapid)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_selfmanaged_snap_create_exit .state) *)&(__tracepoint_librados___rados_ioctx_selfmanaged_snap_create_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_selfmanaged_snap_create_exit (retval, *snapid); } while (0); | |||
3778 | return retval; | |||
3779 | } | |||
3780 | ||||
3781 | extern "C" int rados_ioctx_selfmanaged_snap_remove(rados_ioctx_t io, | |||
3782 | uint64_t snapid) | |||
3783 | { | |||
3784 | tracepoint(librados, rados_ioctx_selfmanaged_snap_remove_enter, io, snapid)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_selfmanaged_snap_remove_enter .state) *)&(__tracepoint_librados___rados_ioctx_selfmanaged_snap_remove_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_selfmanaged_snap_remove_enter (io, snapid); } while (0); | |||
3785 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3786 | int retval = ctx->selfmanaged_snap_remove(snapid); | |||
3787 | tracepoint(librados, rados_ioctx_selfmanaged_snap_remove_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_selfmanaged_snap_remove_exit .state) *)&(__tracepoint_librados___rados_ioctx_selfmanaged_snap_remove_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_selfmanaged_snap_remove_exit (retval); } while (0); | |||
3788 | return retval; | |||
3789 | } | |||
3790 | ||||
3791 | extern "C" int rados_ioctx_selfmanaged_snap_rollback(rados_ioctx_t io, | |||
3792 | const char *oid, | |||
3793 | uint64_t snapid) | |||
3794 | { | |||
3795 | tracepoint(librados, rados_ioctx_selfmanaged_snap_rollback_enter, io, oid, snapid)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_selfmanaged_snap_rollback_enter .state) *)&(__tracepoint_librados___rados_ioctx_selfmanaged_snap_rollback_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_selfmanaged_snap_rollback_enter (io, oid, snapid); } while (0); | |||
3796 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3797 | int retval = ctx->selfmanaged_snap_rollback_object(oid, ctx->snapc, snapid); | |||
3798 | tracepoint(librados, rados_ioctx_selfmanaged_snap_rollback_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_selfmanaged_snap_rollback_exit .state) *)&(__tracepoint_librados___rados_ioctx_selfmanaged_snap_rollback_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_selfmanaged_snap_rollback_exit (retval); } while (0); | |||
3799 | return retval; | |||
3800 | } | |||
3801 | ||||
3802 | extern "C" int rados_ioctx_snap_list(rados_ioctx_t io, rados_snap_t *snaps, | |||
3803 | int maxlen) | |||
3804 | { | |||
3805 | tracepoint(librados, rados_ioctx_snap_list_enter, io, maxlen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_list_enter .state) *)&(__tracepoint_librados___rados_ioctx_snap_list_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_list_enter (io, maxlen); } while (0); | |||
3806 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3807 | vector<uint64_t> snapvec; | |||
3808 | int r = ctx->snap_list(&snapvec); | |||
3809 | if (r < 0) { | |||
3810 | tracepoint(librados, rados_ioctx_snap_list_exit, r, snaps, 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_list_exit .state) *)&(__tracepoint_librados___rados_ioctx_snap_list_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_list_exit (r, snaps, 0); } while (0); | |||
3811 | return r; | |||
3812 | } | |||
3813 | if ((int)snapvec.size() <= maxlen) { | |||
3814 | for (unsigned i=0; i<snapvec.size(); i++) { | |||
3815 | snaps[i] = snapvec[i]; | |||
3816 | } | |||
3817 | int retval = snapvec.size(); | |||
3818 | tracepoint(librados, rados_ioctx_snap_list_exit, retval, snaps, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_list_exit .state) *)&(__tracepoint_librados___rados_ioctx_snap_list_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_list_exit (retval, snaps, retval); } while (0); | |||
3819 | return retval; | |||
3820 | } | |||
3821 | int retval = -ERANGE34; | |||
3822 | tracepoint(librados, rados_ioctx_snap_list_exit, retval, snaps, 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_list_exit .state) *)&(__tracepoint_librados___rados_ioctx_snap_list_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_list_exit (retval, snaps, 0); } while (0); | |||
3823 | return retval; | |||
3824 | } | |||
3825 | ||||
3826 | extern "C" int rados_ioctx_snap_lookup(rados_ioctx_t io, const char *name, | |||
3827 | rados_snap_t *id) | |||
3828 | { | |||
3829 | tracepoint(librados, rados_ioctx_snap_lookup_enter, io, name)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_lookup_enter .state) *)&(__tracepoint_librados___rados_ioctx_snap_lookup_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_lookup_enter (io, name); } while (0); | |||
3830 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3831 | int retval = ctx->snap_lookup(name, (uint64_t *)id); | |||
3832 | tracepoint(librados, rados_ioctx_snap_lookup_exit, retval, *id)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_lookup_exit .state) *)&(__tracepoint_librados___rados_ioctx_snap_lookup_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_lookup_exit (retval, *id); } while (0); | |||
3833 | return retval; | |||
3834 | } | |||
3835 | ||||
3836 | extern "C" int rados_ioctx_snap_get_name(rados_ioctx_t io, rados_snap_t id, | |||
3837 | char *name, int maxlen) | |||
3838 | { | |||
3839 | tracepoint(librados, rados_ioctx_snap_get_name_enter, io, id, maxlen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_get_name_enter .state) *)&(__tracepoint_librados___rados_ioctx_snap_get_name_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_get_name_enter (io, id, maxlen); } while (0); | |||
3840 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3841 | std::string sname; | |||
3842 | int r = ctx->snap_get_name(id, &sname); | |||
3843 | if (r < 0) { | |||
3844 | tracepoint(librados, rados_ioctx_snap_get_name_exit, r, "")do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_get_name_exit .state) *)&(__tracepoint_librados___rados_ioctx_snap_get_name_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_get_name_exit (r, ""); } while (0); | |||
3845 | return r; | |||
3846 | } | |||
3847 | if ((int)sname.length() >= maxlen) { | |||
3848 | int retval = -ERANGE34; | |||
3849 | tracepoint(librados, rados_ioctx_snap_get_name_exit, retval, "")do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_get_name_exit .state) *)&(__tracepoint_librados___rados_ioctx_snap_get_name_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_get_name_exit (retval, ""); } while (0); | |||
3850 | return retval; | |||
3851 | } | |||
3852 | strncpy(name, sname.c_str(), maxlen); | |||
3853 | tracepoint(librados, rados_ioctx_snap_get_name_exit, 0, name)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_get_name_exit .state) *)&(__tracepoint_librados___rados_ioctx_snap_get_name_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_get_name_exit (0, name); } while (0); | |||
3854 | return 0; | |||
3855 | } | |||
3856 | ||||
3857 | extern "C" int rados_ioctx_snap_get_stamp(rados_ioctx_t io, rados_snap_t id, time_t *t) | |||
3858 | { | |||
3859 | tracepoint(librados, rados_ioctx_snap_get_stamp_enter, io, id)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_get_stamp_enter .state) *)&(__tracepoint_librados___rados_ioctx_snap_get_stamp_enter .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_get_stamp_enter (io, id); } while (0); | |||
3860 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3861 | int retval = ctx->snap_get_stamp(id, t); | |||
3862 | tracepoint(librados, rados_ioctx_snap_get_stamp_exit, retval, *t)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_ioctx_snap_get_stamp_exit .state) *)&(__tracepoint_librados___rados_ioctx_snap_get_stamp_exit .state)); })), 0)) __tracepoint_cb_librados___rados_ioctx_snap_get_stamp_exit (retval, *t); } while (0); | |||
3863 | return retval; | |||
3864 | } | |||
3865 | ||||
3866 | extern "C" int rados_getxattr(rados_ioctx_t io, const char *o, const char *name, | |||
3867 | char *buf, size_t len) | |||
3868 | { | |||
3869 | tracepoint(librados, rados_getxattr_enter, io, o, name, len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_getxattr_enter .state) *)&(__tracepoint_librados___rados_getxattr_enter. state)); })), 0)) __tracepoint_cb_librados___rados_getxattr_enter (io, o, name, len); } while (0); | |||
3870 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3871 | int ret; | |||
3872 | object_t oid(o); | |||
3873 | bufferlist bl; | |||
3874 | bl.push_back(buffer::create_static(len, buf)); | |||
3875 | ret = ctx->getxattr(oid, name, bl); | |||
3876 | if (ret >= 0) { | |||
3877 | if (bl.length() > len) { | |||
3878 | tracepoint(librados, rados_getxattr_exit, -ERANGE, buf, 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_getxattr_exit .state) *)&(__tracepoint_librados___rados_getxattr_exit.state )); })), 0)) __tracepoint_cb_librados___rados_getxattr_exit(- 34, buf, 0); } while (0); | |||
3879 | return -ERANGE34; | |||
3880 | } | |||
3881 | if (!bl.is_provided_buffer(buf)) | |||
3882 | bl.copy(0, bl.length(), buf); | |||
3883 | ret = bl.length(); | |||
3884 | } | |||
3885 | ||||
3886 | tracepoint(librados, rados_getxattr_exit, ret, buf, ret)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_getxattr_exit .state) *)&(__tracepoint_librados___rados_getxattr_exit.state )); })), 0)) __tracepoint_cb_librados___rados_getxattr_exit(ret , buf, ret); } while (0); | |||
3887 | return ret; | |||
3888 | } | |||
3889 | ||||
3890 | extern "C" int rados_getxattrs(rados_ioctx_t io, const char *oid, | |||
3891 | rados_xattrs_iter_t *iter) | |||
3892 | { | |||
3893 | tracepoint(librados, rados_getxattrs_enter, io, oid)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_getxattrs_enter .state) *)&(__tracepoint_librados___rados_getxattrs_enter .state)); })), 0)) __tracepoint_cb_librados___rados_getxattrs_enter (io, oid); } while (0); | |||
3894 | librados::RadosXattrsIter *it = new librados::RadosXattrsIter(); | |||
3895 | if (!it) { | |||
3896 | tracepoint(librados, rados_getxattrs_exit, -ENOMEM, NULL)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_getxattrs_exit .state) *)&(__tracepoint_librados___rados_getxattrs_exit. state)); })), 0)) __tracepoint_cb_librados___rados_getxattrs_exit (-12, __null); } while (0); | |||
3897 | return -ENOMEM12; | |||
3898 | } | |||
3899 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3900 | object_t obj(oid); | |||
3901 | int ret = ctx->getxattrs(obj, it->attrset); | |||
3902 | if (ret) { | |||
3903 | delete it; | |||
3904 | tracepoint(librados, rados_getxattrs_exit, ret, NULL)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_getxattrs_exit .state) *)&(__tracepoint_librados___rados_getxattrs_exit. state)); })), 0)) __tracepoint_cb_librados___rados_getxattrs_exit (ret, __null); } while (0); | |||
3905 | return ret; | |||
3906 | } | |||
3907 | it->i = it->attrset.begin(); | |||
3908 | ||||
3909 | librados::RadosXattrsIter **iret = (librados::RadosXattrsIter**)iter; | |||
3910 | *iret = it; | |||
3911 | *iter = it; | |||
3912 | tracepoint(librados, rados_getxattrs_exit, 0, *iter)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_getxattrs_exit .state) *)&(__tracepoint_librados___rados_getxattrs_exit. state)); })), 0)) __tracepoint_cb_librados___rados_getxattrs_exit (0, *iter); } while (0); | |||
3913 | return 0; | |||
3914 | } | |||
3915 | ||||
3916 | extern "C" int rados_getxattrs_next(rados_xattrs_iter_t iter, | |||
3917 | const char **name, const char **val, size_t *len) | |||
3918 | { | |||
3919 | tracepoint(librados, rados_getxattrs_next_enter, iter)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_getxattrs_next_enter .state) *)&(__tracepoint_librados___rados_getxattrs_next_enter .state)); })), 0)) __tracepoint_cb_librados___rados_getxattrs_next_enter (iter); } while (0); | |||
3920 | librados::RadosXattrsIter *it = static_cast<librados::RadosXattrsIter*>(iter); | |||
3921 | if (it->i == it->attrset.end()) { | |||
3922 | *name = NULL__null; | |||
3923 | *val = NULL__null; | |||
3924 | *len = 0; | |||
3925 | tracepoint(librados, rados_getxattrs_next_exit, 0, NULL, NULL, 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_getxattrs_next_exit .state) *)&(__tracepoint_librados___rados_getxattrs_next_exit .state)); })), 0)) __tracepoint_cb_librados___rados_getxattrs_next_exit (0, __null, __null, 0); } while (0); | |||
3926 | return 0; | |||
3927 | } | |||
3928 | free(it->val); | |||
3929 | const std::string &s(it->i->first); | |||
3930 | *name = s.c_str(); | |||
3931 | bufferlist &bl(it->i->second); | |||
3932 | size_t bl_len = bl.length(); | |||
3933 | if (!bl_len) { | |||
3934 | // malloc(0) is not guaranteed to return a valid pointer | |||
3935 | *val = (char *)NULL__null; | |||
3936 | } else { | |||
3937 | it->val = (char*)malloc(bl_len); | |||
3938 | if (!it->val) { | |||
3939 | tracepoint(librados, rados_getxattrs_next_exit, -ENOMEM, *name, NULL, 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_getxattrs_next_exit .state) *)&(__tracepoint_librados___rados_getxattrs_next_exit .state)); })), 0)) __tracepoint_cb_librados___rados_getxattrs_next_exit (-12, *name, __null, 0); } while (0); | |||
3940 | return -ENOMEM12; | |||
3941 | } | |||
3942 | memcpy(it->val, bl.c_str(), bl_len); | |||
3943 | *val = it->val; | |||
3944 | } | |||
3945 | *len = bl_len; | |||
3946 | ++it->i; | |||
3947 | tracepoint(librados, rados_getxattrs_next_exit, 0, *name, *val, *len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_getxattrs_next_exit .state) *)&(__tracepoint_librados___rados_getxattrs_next_exit .state)); })), 0)) __tracepoint_cb_librados___rados_getxattrs_next_exit (0, *name, *val, *len); } while (0); | |||
3948 | return 0; | |||
3949 | } | |||
3950 | ||||
3951 | extern "C" void rados_getxattrs_end(rados_xattrs_iter_t iter) | |||
3952 | { | |||
3953 | tracepoint(librados, rados_getxattrs_end_enter, iter)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_getxattrs_end_enter .state) *)&(__tracepoint_librados___rados_getxattrs_end_enter .state)); })), 0)) __tracepoint_cb_librados___rados_getxattrs_end_enter (iter); } while (0); | |||
3954 | librados::RadosXattrsIter *it = static_cast<librados::RadosXattrsIter*>(iter); | |||
3955 | delete it; | |||
3956 | tracepoint(librados, rados_getxattrs_end_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_getxattrs_end_exit .state) *)&(__tracepoint_librados___rados_getxattrs_end_exit .state)); })), 0)) __tracepoint_cb_librados___rados_getxattrs_end_exit (); } while (0); | |||
3957 | } | |||
3958 | ||||
3959 | extern "C" int rados_setxattr(rados_ioctx_t io, const char *o, const char *name, const char *buf, size_t len) | |||
3960 | { | |||
3961 | tracepoint(librados, rados_setxattr_enter, io, o, name, buf, len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_setxattr_enter .state) *)&(__tracepoint_librados___rados_setxattr_enter. state)); })), 0)) __tracepoint_cb_librados___rados_setxattr_enter (io, o, name, buf, len); } while (0); | |||
3962 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3963 | object_t oid(o); | |||
3964 | bufferlist bl; | |||
3965 | bl.append(buf, len); | |||
3966 | int retval = ctx->setxattr(oid, name, bl); | |||
3967 | tracepoint(librados, rados_setxattr_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_setxattr_exit .state) *)&(__tracepoint_librados___rados_setxattr_exit.state )); })), 0)) __tracepoint_cb_librados___rados_setxattr_exit(retval ); } while (0); | |||
3968 | return retval; | |||
3969 | } | |||
3970 | ||||
3971 | extern "C" int rados_rmxattr(rados_ioctx_t io, const char *o, const char *name) | |||
3972 | { | |||
3973 | tracepoint(librados, rados_rmxattr_enter, io, o, name)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_rmxattr_enter .state) *)&(__tracepoint_librados___rados_rmxattr_enter.state )); })), 0)) __tracepoint_cb_librados___rados_rmxattr_enter(io , o, name); } while (0); | |||
3974 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3975 | object_t oid(o); | |||
3976 | int retval = ctx->rmxattr(oid, name); | |||
3977 | tracepoint(librados, rados_rmxattr_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_rmxattr_exit .state) *)&(__tracepoint_librados___rados_rmxattr_exit.state )); })), 0)) __tracepoint_cb_librados___rados_rmxattr_exit(retval ); } while (0); | |||
3978 | return retval; | |||
3979 | } | |||
3980 | ||||
3981 | extern "C" int rados_stat(rados_ioctx_t io, const char *o, uint64_t *psize, time_t *pmtime) | |||
3982 | { | |||
3983 | tracepoint(librados, rados_stat_enter, io, o)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_stat_enter .state) *)&(__tracepoint_librados___rados_stat_enter.state )); })), 0)) __tracepoint_cb_librados___rados_stat_enter(io, o ); } while (0); | |||
3984 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3985 | object_t oid(o); | |||
3986 | int retval = ctx->stat(oid, psize, pmtime); | |||
3987 | tracepoint(librados, rados_stat_exit, retval, psize, pmtime)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_stat_exit .state) *)&(__tracepoint_librados___rados_stat_exit.state )); })), 0)) __tracepoint_cb_librados___rados_stat_exit(retval , psize, pmtime); } while (0); | |||
3988 | return retval; | |||
3989 | } | |||
3990 | ||||
3991 | extern "C" int rados_tmap_update(rados_ioctx_t io, const char *o, const char *cmdbuf, size_t cmdbuflen) | |||
3992 | { | |||
3993 | tracepoint(librados, rados_tmap_update_enter, io, o, cmdbuf, cmdbuflen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_tmap_update_enter .state) *)&(__tracepoint_librados___rados_tmap_update_enter .state)); })), 0)) __tracepoint_cb_librados___rados_tmap_update_enter (io, o, cmdbuf, cmdbuflen); } while (0); | |||
3994 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
3995 | object_t oid(o); | |||
3996 | bufferlist cmdbl; | |||
3997 | cmdbl.append(cmdbuf, cmdbuflen); | |||
3998 | int retval = ctx->tmap_update(oid, cmdbl); | |||
3999 | tracepoint(librados, rados_tmap_update_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_tmap_update_exit .state) *)&(__tracepoint_librados___rados_tmap_update_exit .state)); })), 0)) __tracepoint_cb_librados___rados_tmap_update_exit (retval); } while (0); | |||
4000 | return retval; | |||
4001 | } | |||
4002 | ||||
4003 | extern "C" int rados_tmap_put(rados_ioctx_t io, const char *o, const char *buf, size_t buflen) | |||
4004 | { | |||
4005 | tracepoint(librados, rados_tmap_put_enter, io, o, buf, buflen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_tmap_put_enter .state) *)&(__tracepoint_librados___rados_tmap_put_enter. state)); })), 0)) __tracepoint_cb_librados___rados_tmap_put_enter (io, o, buf, buflen); } while (0); | |||
4006 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4007 | object_t oid(o); | |||
4008 | bufferlist bl; | |||
4009 | bl.append(buf, buflen); | |||
4010 | int retval = ctx->tmap_put(oid, bl); | |||
4011 | tracepoint(librados, rados_tmap_put_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_tmap_put_exit .state) *)&(__tracepoint_librados___rados_tmap_put_exit.state )); })), 0)) __tracepoint_cb_librados___rados_tmap_put_exit(retval ); } while (0); | |||
4012 | return retval; | |||
4013 | } | |||
4014 | ||||
4015 | extern "C" int rados_tmap_get(rados_ioctx_t io, const char *o, char *buf, size_t buflen) | |||
4016 | { | |||
4017 | tracepoint(librados, rados_tmap_get_enter, io, o, buflen)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_tmap_get_enter .state) *)&(__tracepoint_librados___rados_tmap_get_enter. state)); })), 0)) __tracepoint_cb_librados___rados_tmap_get_enter (io, o, buflen); } while (0); | |||
4018 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4019 | object_t oid(o); | |||
4020 | bufferlist bl; | |||
4021 | int r = ctx->tmap_get(oid, bl); | |||
4022 | if (r < 0) { | |||
4023 | tracepoint(librados, rados_tmap_get_exit, r, buf, 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_tmap_get_exit .state) *)&(__tracepoint_librados___rados_tmap_get_exit.state )); })), 0)) __tracepoint_cb_librados___rados_tmap_get_exit(r , buf, 0); } while (0); | |||
4024 | return r; | |||
4025 | } | |||
4026 | if (bl.length() > buflen) { | |||
4027 | tracepoint(librados, rados_tmap_get_exit, -ERANGE, buf, 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_tmap_get_exit .state) *)&(__tracepoint_librados___rados_tmap_get_exit.state )); })), 0)) __tracepoint_cb_librados___rados_tmap_get_exit(- 34, buf, 0); } while (0); | |||
4028 | return -ERANGE34; | |||
4029 | } | |||
4030 | bl.copy(0, bl.length(), buf); | |||
4031 | int retval = bl.length(); | |||
4032 | tracepoint(librados, rados_tmap_get_exit, retval, buf, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_tmap_get_exit .state) *)&(__tracepoint_librados___rados_tmap_get_exit.state )); })), 0)) __tracepoint_cb_librados___rados_tmap_get_exit(retval , buf, retval); } while (0); | |||
4033 | return retval; | |||
4034 | } | |||
4035 | ||||
4036 | extern "C" int rados_tmap_to_omap(rados_ioctx_t io, const char *o, bool nullok) | |||
4037 | { | |||
4038 | tracepoint(librados, rados_tmap_to_omap_enter, io, o, nullok)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_tmap_to_omap_enter .state) *)&(__tracepoint_librados___rados_tmap_to_omap_enter .state)); })), 0)) __tracepoint_cb_librados___rados_tmap_to_omap_enter (io, o, nullok); } while (0); | |||
4039 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4040 | object_t oid(o); | |||
4041 | int retval = ctx->tmap_to_omap(oid, nullok); | |||
4042 | tracepoint(librados, rados_tmap_to_omap_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_tmap_to_omap_exit .state) *)&(__tracepoint_librados___rados_tmap_to_omap_exit .state)); })), 0)) __tracepoint_cb_librados___rados_tmap_to_omap_exit (retval); } while (0); | |||
4043 | return retval; | |||
4044 | } | |||
4045 | ||||
4046 | extern "C" int rados_exec(rados_ioctx_t io, const char *o, const char *cls, const char *method, | |||
4047 | const char *inbuf, size_t in_len, char *buf, size_t out_len) | |||
4048 | { | |||
4049 | tracepoint(librados, rados_exec_enter, io, o, cls, method, inbuf, in_len, out_len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_exec_enter .state) *)&(__tracepoint_librados___rados_exec_enter.state )); })), 0)) __tracepoint_cb_librados___rados_exec_enter(io, o , cls, method, inbuf, in_len, out_len); } while (0); | |||
4050 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4051 | object_t oid(o); | |||
4052 | bufferlist inbl, outbl; | |||
4053 | int ret; | |||
4054 | inbl.append(inbuf, in_len); | |||
4055 | ret = ctx->exec(oid, cls, method, inbl, outbl); | |||
4056 | if (ret >= 0) { | |||
4057 | if (outbl.length()) { | |||
4058 | if (outbl.length() > out_len) { | |||
4059 | tracepoint(librados, rados_exec_exit, -ERANGE, buf, 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_exec_exit .state) *)&(__tracepoint_librados___rados_exec_exit.state )); })), 0)) __tracepoint_cb_librados___rados_exec_exit(-34, buf , 0); } while (0); | |||
4060 | return -ERANGE34; | |||
4061 | } | |||
4062 | outbl.copy(0, outbl.length(), buf); | |||
4063 | ret = outbl.length(); // hrm :/ | |||
4064 | } | |||
4065 | } | |||
4066 | tracepoint(librados, rados_exec_exit, ret, buf, ret)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_exec_exit .state) *)&(__tracepoint_librados___rados_exec_exit.state )); })), 0)) __tracepoint_cb_librados___rados_exec_exit(ret, buf , ret); } while (0); | |||
4067 | return ret; | |||
4068 | } | |||
4069 | ||||
4070 | extern "C" rados_object_list_cursor rados_object_list_begin(rados_ioctx_t io) | |||
4071 | { | |||
4072 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4073 | ||||
4074 | hobject_t *result = new hobject_t(ctx->objecter->enumerate_objects_begin()); | |||
4075 | return (rados_object_list_cursor)result; | |||
4076 | } | |||
4077 | ||||
4078 | extern "C" rados_object_list_cursor rados_object_list_end(rados_ioctx_t io) | |||
4079 | { | |||
4080 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4081 | ||||
4082 | hobject_t *result = new hobject_t(ctx->objecter->enumerate_objects_end()); | |||
4083 | return (rados_object_list_cursor)result; | |||
4084 | } | |||
4085 | ||||
4086 | extern "C" int rados_object_list_is_end( | |||
4087 | rados_ioctx_t io, rados_object_list_cursor cur) | |||
4088 | { | |||
4089 | hobject_t *hobj = (hobject_t*)cur; | |||
4090 | return hobj->is_max(); | |||
4091 | } | |||
4092 | ||||
4093 | extern "C" void rados_object_list_cursor_free( | |||
4094 | rados_ioctx_t io, rados_object_list_cursor cur) | |||
4095 | { | |||
4096 | hobject_t *hobj = (hobject_t*)cur; | |||
4097 | delete hobj; | |||
4098 | } | |||
4099 | ||||
4100 | extern "C" int rados_object_list_cursor_cmp( | |||
4101 | rados_ioctx_t io, | |||
4102 | rados_object_list_cursor lhs_cur, | |||
4103 | rados_object_list_cursor rhs_cur) | |||
4104 | { | |||
4105 | hobject_t *lhs = (hobject_t*)lhs_cur; | |||
4106 | hobject_t *rhs = (hobject_t*)rhs_cur; | |||
4107 | return cmp_bitwise(*lhs, *rhs); | |||
4108 | } | |||
4109 | ||||
4110 | extern "C" int rados_object_list(rados_ioctx_t io, | |||
4111 | const rados_object_list_cursor start, | |||
4112 | const rados_object_list_cursor finish, | |||
4113 | const size_t result_item_count, | |||
4114 | const char *filter_buf, | |||
4115 | const size_t filter_buf_len, | |||
4116 | rados_object_list_item *result_items, | |||
4117 | rados_object_list_cursor *next) | |||
4118 | { | |||
4119 | assert(next)((next) ? static_cast<void> (0) : __ceph_assert_fail ("next" , "/home/brad/working/src/ceph/src/librados/librados.cc", 4119 , __PRETTY_FUNCTION__)); | |||
4120 | ||||
4121 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4122 | ||||
4123 | // Zero out items so that they will be safe to free later | |||
4124 | memset(result_items, 0, sizeof(rados_object_list_item) * result_item_count); | |||
4125 | ||||
4126 | std::list<librados::ListObjectImpl> result; | |||
4127 | hobject_t next_hash; | |||
4128 | ||||
4129 | bufferlist filter_bl; | |||
4130 | if (filter_buf != nullptr) { | |||
4131 | filter_bl.append(filter_buf, filter_buf_len); | |||
4132 | } | |||
4133 | ||||
4134 | C_SaferCond cond; | |||
4135 | ctx->objecter->enumerate_objects( | |||
4136 | ctx->poolid, | |||
4137 | ctx->oloc.nspace, | |||
4138 | *((hobject_t*)start), | |||
4139 | *((hobject_t*)finish), | |||
4140 | result_item_count, | |||
4141 | filter_bl, | |||
4142 | &result, | |||
4143 | &next_hash, | |||
4144 | &cond); | |||
4145 | ||||
4146 | hobject_t *next_hobj = (hobject_t*)(*next); | |||
4147 | assert(next_hobj)((next_hobj) ? static_cast<void> (0) : __ceph_assert_fail ("next_hobj", "/home/brad/working/src/ceph/src/librados/librados.cc" , 4147, __PRETTY_FUNCTION__)); | |||
4148 | ||||
4149 | int r = cond.wait(); | |||
4150 | if (r < 0) { | |||
4151 | *next_hobj = hobject_t::get_max(); | |||
4152 | return r; | |||
4153 | } | |||
4154 | ||||
4155 | assert(result.size() <= result_item_count)((result.size() <= result_item_count) ? static_cast<void > (0) : __ceph_assert_fail ("result.size() <= result_item_count" , "/home/brad/working/src/ceph/src/librados/librados.cc", 4155 , __PRETTY_FUNCTION__)); // Don't overflow! | |||
4156 | ||||
4157 | int k = 0; | |||
4158 | for (std::list<librados::ListObjectImpl>::iterator i = result.begin(); | |||
4159 | i != result.end(); ++i) { | |||
4160 | rados_object_list_item &item = result_items[k++]; | |||
4161 | do_out_buffer(i->oid, &item.oid, &item.oid_length); | |||
4162 | do_out_buffer(i->nspace, &item.nspace, &item.nspace_length); | |||
4163 | do_out_buffer(i->locator, &item.locator, &item.locator_length); | |||
4164 | } | |||
4165 | ||||
4166 | *next_hobj = next_hash; | |||
4167 | ||||
4168 | return result.size(); | |||
4169 | } | |||
4170 | ||||
4171 | extern "C" void rados_object_list_free( | |||
4172 | const size_t result_size, | |||
4173 | rados_object_list_item *results) | |||
4174 | { | |||
4175 | assert(results)((results) ? static_cast<void> (0) : __ceph_assert_fail ("results", "/home/brad/working/src/ceph/src/librados/librados.cc" , 4175, __PRETTY_FUNCTION__)); | |||
4176 | ||||
4177 | for (unsigned int i = 0; i < result_size; ++i) { | |||
4178 | rados_buffer_free(results[i].oid); | |||
4179 | rados_buffer_free(results[i].locator); | |||
4180 | rados_buffer_free(results[i].nspace); | |||
4181 | } | |||
4182 | } | |||
4183 | ||||
4184 | /* list objects */ | |||
4185 | ||||
4186 | extern "C" int rados_nobjects_list_open(rados_ioctx_t io, rados_list_ctx_t *listh) | |||
4187 | { | |||
4188 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4189 | ||||
4190 | // Let's do it the old way for backward compatbility if not using ANY_NSPACES | |||
4191 | if (ctx->oloc.nspace != librados::all_nspaces) | |||
4192 | return rados_objects_list_open(io, listh); | |||
4193 | ||||
4194 | tracepoint(librados, rados_nobjects_list_open_enter, io)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_nobjects_list_open_enter .state) *)&(__tracepoint_librados___rados_nobjects_list_open_enter .state)); })), 0)) __tracepoint_cb_librados___rados_nobjects_list_open_enter (io); } while (0); | |||
4195 | ||||
4196 | Objecter::NListContext *h = new Objecter::NListContext; | |||
4197 | h->pool_id = ctx->poolid; | |||
4198 | h->pool_snap_seq = ctx->snap_seq; | |||
4199 | h->nspace = ctx->oloc.nspace; // After dropping compatibility need nspace | |||
4200 | *listh = (void *)new librados::ObjListCtx(ctx, h); | |||
4201 | tracepoint(librados, rados_nobjects_list_open_exit, 0, *listh)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_nobjects_list_open_exit .state) *)&(__tracepoint_librados___rados_nobjects_list_open_exit .state)); })), 0)) __tracepoint_cb_librados___rados_nobjects_list_open_exit (0, *listh); } while (0); | |||
4202 | return 0; | |||
4203 | } | |||
4204 | ||||
4205 | extern "C" void rados_nobjects_list_close(rados_list_ctx_t h) | |||
4206 | { | |||
4207 | tracepoint(librados, rados_nobjects_list_close_enter, h)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_nobjects_list_close_enter .state) *)&(__tracepoint_librados___rados_nobjects_list_close_enter .state)); })), 0)) __tracepoint_cb_librados___rados_nobjects_list_close_enter (h); } while (0); | |||
4208 | librados::ObjListCtx *lh = (librados::ObjListCtx *)h; | |||
4209 | delete lh; | |||
4210 | tracepoint(librados, rados_nobjects_list_close_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_nobjects_list_close_exit .state) *)&(__tracepoint_librados___rados_nobjects_list_close_exit .state)); })), 0)) __tracepoint_cb_librados___rados_nobjects_list_close_exit (); } while (0); | |||
4211 | } | |||
4212 | ||||
4213 | extern "C" uint32_t rados_nobjects_list_seek(rados_list_ctx_t listctx, | |||
4214 | uint32_t pos) | |||
4215 | { | |||
4216 | librados::ObjListCtx *lh = (librados::ObjListCtx *)listctx; | |||
4217 | ||||
4218 | // Let's do it the old way for backward compatbility if not using ANY_NSPACES | |||
4219 | if (!lh->new_request) | |||
4220 | return rados_objects_list_seek(listctx, pos); | |||
4221 | ||||
4222 | tracepoint(librados, rados_nobjects_list_seek_enter, listctx, pos)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_nobjects_list_seek_enter .state) *)&(__tracepoint_librados___rados_nobjects_list_seek_enter .state)); })), 0)) __tracepoint_cb_librados___rados_nobjects_list_seek_enter (listctx, pos); } while (0); | |||
4223 | uint32_t r = lh->ctx->nlist_seek(lh->nlc, pos); | |||
4224 | tracepoint(librados, rados_nobjects_list_seek_exit, r)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_nobjects_list_seek_exit .state) *)&(__tracepoint_librados___rados_nobjects_list_seek_exit .state)); })), 0)) __tracepoint_cb_librados___rados_nobjects_list_seek_exit (r); } while (0); | |||
4225 | return r; | |||
4226 | } | |||
4227 | ||||
4228 | extern "C" uint32_t rados_nobjects_list_get_pg_hash_position( | |||
4229 | rados_list_ctx_t listctx) | |||
4230 | { | |||
4231 | librados::ObjListCtx *lh = (librados::ObjListCtx *)listctx; | |||
4232 | if (!lh->new_request) | |||
4233 | return rados_objects_list_get_pg_hash_position(listctx); | |||
4234 | ||||
4235 | tracepoint(librados, rados_nobjects_list_get_pg_hash_position_enter, listctx)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_nobjects_list_get_pg_hash_position_enter .state) *)&(__tracepoint_librados___rados_nobjects_list_get_pg_hash_position_enter .state)); })), 0)) __tracepoint_cb_librados___rados_nobjects_list_get_pg_hash_position_enter (listctx); } while (0); | |||
4236 | uint32_t retval = lh->nlc->get_pg_hash_position(); | |||
4237 | tracepoint(librados, rados_nobjects_list_get_pg_hash_position_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_nobjects_list_get_pg_hash_position_exit .state) *)&(__tracepoint_librados___rados_nobjects_list_get_pg_hash_position_exit .state)); })), 0)) __tracepoint_cb_librados___rados_nobjects_list_get_pg_hash_position_exit (retval); } while (0); | |||
4238 | return retval; | |||
4239 | } | |||
4240 | ||||
4241 | // Deprecated, but using it for compatibility with older OSDs | |||
4242 | extern "C" int rados_objects_list_open(rados_ioctx_t io, rados_list_ctx_t *listh) | |||
4243 | { | |||
4244 | tracepoint(librados, rados_objects_list_open_enter, io)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_objects_list_open_enter .state) *)&(__tracepoint_librados___rados_objects_list_open_enter .state)); })), 0)) __tracepoint_cb_librados___rados_objects_list_open_enter (io); } while (0); | |||
4245 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4246 | if (ctx->oloc.nspace == librados::all_nspaces) | |||
4247 | return -EINVAL22; | |||
4248 | Objecter::ListContext *h = new Objecter::ListContext; | |||
4249 | h->pool_id = ctx->poolid; | |||
4250 | h->pool_snap_seq = ctx->snap_seq; | |||
4251 | h->nspace = ctx->oloc.nspace; | |||
4252 | *listh = (void *)new librados::ObjListCtx(ctx, h); | |||
4253 | tracepoint(librados, rados_objects_list_open_exit, 0, *listh)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_objects_list_open_exit .state) *)&(__tracepoint_librados___rados_objects_list_open_exit .state)); })), 0)) __tracepoint_cb_librados___rados_objects_list_open_exit (0, *listh); } while (0); | |||
4254 | return 0; | |||
4255 | } | |||
4256 | ||||
4257 | // Deprecated, but using it for compatibility with older OSDs | |||
4258 | extern "C" void rados_objects_list_close(rados_list_ctx_t h) | |||
4259 | { | |||
4260 | tracepoint(librados, rados_objects_list_close_enter, h)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_objects_list_close_enter .state) *)&(__tracepoint_librados___rados_objects_list_close_enter .state)); })), 0)) __tracepoint_cb_librados___rados_objects_list_close_enter (h); } while (0); | |||
4261 | librados::ObjListCtx *lh = (librados::ObjListCtx *)h; | |||
4262 | delete lh; | |||
4263 | tracepoint(librados, rados_objects_list_close_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_objects_list_close_exit .state) *)&(__tracepoint_librados___rados_objects_list_close_exit .state)); })), 0)) __tracepoint_cb_librados___rados_objects_list_close_exit (); } while (0); | |||
4264 | } | |||
4265 | ||||
4266 | extern "C" uint32_t rados_objects_list_seek(rados_list_ctx_t listctx, | |||
4267 | uint32_t pos) | |||
4268 | { | |||
4269 | tracepoint(librados, rados_objects_list_seek_enter, listctx, pos)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_objects_list_seek_enter .state) *)&(__tracepoint_librados___rados_objects_list_seek_enter .state)); })), 0)) __tracepoint_cb_librados___rados_objects_list_seek_enter (listctx, pos); } while (0); | |||
4270 | librados::ObjListCtx *lh = (librados::ObjListCtx *)listctx; | |||
4271 | uint32_t r = lh->ctx->list_seek(lh->lc, pos); | |||
4272 | tracepoint(librados, rados_objects_list_seek_exit, r)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_objects_list_seek_exit .state) *)&(__tracepoint_librados___rados_objects_list_seek_exit .state)); })), 0)) __tracepoint_cb_librados___rados_objects_list_seek_exit (r); } while (0); | |||
4273 | return r; | |||
4274 | } | |||
4275 | ||||
4276 | extern "C" uint32_t rados_objects_list_get_pg_hash_position( | |||
4277 | rados_list_ctx_t listctx) | |||
4278 | { | |||
4279 | tracepoint(librados, rados_objects_list_get_pg_hash_position_enter, listctx)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_objects_list_get_pg_hash_position_enter .state) *)&(__tracepoint_librados___rados_objects_list_get_pg_hash_position_enter .state)); })), 0)) __tracepoint_cb_librados___rados_objects_list_get_pg_hash_position_enter (listctx); } while (0); | |||
4280 | librados::ObjListCtx *lh = (librados::ObjListCtx *)listctx; | |||
4281 | uint32_t retval = lh->lc->get_pg_hash_position(); | |||
4282 | tracepoint(librados, rados_objects_list_get_pg_hash_position_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_objects_list_get_pg_hash_position_exit .state) *)&(__tracepoint_librados___rados_objects_list_get_pg_hash_position_exit .state)); })), 0)) __tracepoint_cb_librados___rados_objects_list_get_pg_hash_position_exit (retval); } while (0); | |||
4283 | return retval; | |||
4284 | } | |||
4285 | ||||
4286 | extern "C" int rados_nobjects_list_next(rados_list_ctx_t listctx, const char **entry, const char **key, const char **nspace) | |||
4287 | { | |||
4288 | tracepoint(librados, rados_nobjects_list_next_enter, listctx)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_nobjects_list_next_enter .state) *)&(__tracepoint_librados___rados_nobjects_list_next_enter .state)); })), 0)) __tracepoint_cb_librados___rados_nobjects_list_next_enter (listctx); } while (0); | |||
4289 | librados::ObjListCtx *lh = (librados::ObjListCtx *)listctx; | |||
4290 | if (!lh->new_request) { | |||
4291 | int retval = rados_objects_list_next(listctx, entry, key); | |||
4292 | // Let's return nspace as you would expect even when asking | |||
4293 | // for a specific one, since you know what it must be. | |||
4294 | if (retval == 0 && nspace) | |||
4295 | *nspace = lh->ctx->oloc.nspace.c_str(); | |||
4296 | return retval; | |||
4297 | } | |||
4298 | Objecter::NListContext *h = lh->nlc; | |||
4299 | ||||
4300 | // if the list is non-empty, this method has been called before | |||
4301 | if (!h->list.empty()) | |||
4302 | // so let's kill the previously-returned object | |||
4303 | h->list.pop_front(); | |||
4304 | ||||
4305 | if (h->list.empty()) { | |||
4306 | int ret = lh->ctx->nlist(lh->nlc, RADOS_LIST_MAX_ENTRIES1024); | |||
4307 | if (ret < 0) { | |||
4308 | tracepoint(librados, rados_nobjects_list_next_exit, ret, NULL, NULL, NULL)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_nobjects_list_next_exit .state) *)&(__tracepoint_librados___rados_nobjects_list_next_exit .state)); })), 0)) __tracepoint_cb_librados___rados_nobjects_list_next_exit (ret, __null, __null, __null); } while (0); | |||
4309 | return ret; | |||
4310 | } | |||
4311 | if (h->list.empty()) { | |||
4312 | tracepoint(librados, rados_nobjects_list_next_exit, -ENOENT, NULL, NULL, NULL)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_nobjects_list_next_exit .state) *)&(__tracepoint_librados___rados_nobjects_list_next_exit .state)); })), 0)) __tracepoint_cb_librados___rados_nobjects_list_next_exit (-2, __null, __null, __null); } while (0); | |||
4313 | return -ENOENT2; | |||
4314 | } | |||
4315 | } | |||
4316 | ||||
4317 | *entry = h->list.front().oid.c_str(); | |||
4318 | ||||
4319 | if (key) { | |||
4320 | if (h->list.front().locator.size()) | |||
4321 | *key = h->list.front().locator.c_str(); | |||
4322 | else | |||
4323 | *key = NULL__null; | |||
4324 | } | |||
4325 | if (nspace) | |||
4326 | *nspace = h->list.front().nspace.c_str(); | |||
4327 | tracepoint(librados, rados_nobjects_list_next_exit, 0, *entry, key, nspace)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_nobjects_list_next_exit .state) *)&(__tracepoint_librados___rados_nobjects_list_next_exit .state)); })), 0)) __tracepoint_cb_librados___rados_nobjects_list_next_exit (0, *entry, key, nspace); } while (0); | |||
4328 | return 0; | |||
4329 | } | |||
4330 | ||||
4331 | // DEPRECATED | |||
4332 | extern "C" int rados_objects_list_next(rados_list_ctx_t listctx, const char **entry, const char **key) | |||
4333 | { | |||
4334 | tracepoint(librados, rados_objects_list_next_enter, listctx)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_objects_list_next_enter .state) *)&(__tracepoint_librados___rados_objects_list_next_enter .state)); })), 0)) __tracepoint_cb_librados___rados_objects_list_next_enter (listctx); } while (0); | |||
4335 | librados::ObjListCtx *lh = (librados::ObjListCtx *)listctx; | |||
4336 | Objecter::ListContext *h = lh->lc; | |||
4337 | ||||
4338 | // Calling wrong interface after rados_nobjects_list_open() | |||
4339 | if (lh->new_request) | |||
4340 | return -EINVAL22; | |||
4341 | ||||
4342 | // if the list is non-empty, this method has been called before | |||
4343 | if (!h->list.empty()) | |||
4344 | // so let's kill the previously-returned object | |||
4345 | h->list.pop_front(); | |||
4346 | ||||
4347 | if (h->list.empty()) { | |||
4348 | int ret = lh->ctx->list(lh->lc, RADOS_LIST_MAX_ENTRIES1024); | |||
4349 | if (ret < 0) { | |||
4350 | tracepoint(librados, rados_objects_list_next_exit, ret, NULL, NULL)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_objects_list_next_exit .state) *)&(__tracepoint_librados___rados_objects_list_next_exit .state)); })), 0)) __tracepoint_cb_librados___rados_objects_list_next_exit (ret, __null, __null); } while (0); | |||
4351 | return ret; | |||
4352 | } | |||
4353 | if (h->list.empty()) { | |||
4354 | tracepoint(librados, rados_objects_list_next_exit, -ENOENT, NULL, NULL)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_objects_list_next_exit .state) *)&(__tracepoint_librados___rados_objects_list_next_exit .state)); })), 0)) __tracepoint_cb_librados___rados_objects_list_next_exit (-2, __null, __null); } while (0); | |||
4355 | return -ENOENT2; | |||
4356 | } | |||
4357 | } | |||
4358 | ||||
4359 | *entry = h->list.front().first.name.c_str(); | |||
4360 | ||||
4361 | if (key) { | |||
4362 | if (h->list.front().second.size()) | |||
4363 | *key = h->list.front().second.c_str(); | |||
4364 | else | |||
4365 | *key = NULL__null; | |||
4366 | } | |||
4367 | tracepoint(librados, rados_objects_list_next_exit, 0, *entry, key)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_objects_list_next_exit .state) *)&(__tracepoint_librados___rados_objects_list_next_exit .state)); })), 0)) __tracepoint_cb_librados___rados_objects_list_next_exit (0, *entry, key); } while (0); | |||
4368 | return 0; | |||
4369 | } | |||
4370 | ||||
4371 | ||||
4372 | ||||
4373 | // ------------------------- | |||
4374 | // aio | |||
4375 | ||||
4376 | extern "C" int rados_aio_create_completion(void *cb_arg, | |||
4377 | rados_callback_t cb_complete, | |||
4378 | rados_callback_t cb_safe, | |||
4379 | rados_completion_t *pc) | |||
4380 | { | |||
4381 | tracepoint(librados, rados_aio_create_completion_enter, cb_arg, cb_complete, cb_safe)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_create_completion_enter .state) *)&(__tracepoint_librados___rados_aio_create_completion_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_create_completion_enter (cb_arg, cb_complete, cb_safe); } while (0); | |||
4382 | librados::AioCompletionImpl *c = new librados::AioCompletionImpl; | |||
4383 | if (cb_complete) | |||
4384 | c->set_complete_callback(cb_arg, cb_complete); | |||
4385 | if (cb_safe) | |||
4386 | c->set_safe_callback(cb_arg, cb_safe); | |||
4387 | *pc = c; | |||
4388 | tracepoint(librados, rados_aio_create_completion_exit, 0, *pc)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_create_completion_exit .state) *)&(__tracepoint_librados___rados_aio_create_completion_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_create_completion_exit (0, *pc); } while (0); | |||
4389 | return 0; | |||
4390 | } | |||
4391 | ||||
4392 | extern "C" int rados_aio_wait_for_complete(rados_completion_t c) | |||
4393 | { | |||
4394 | tracepoint(librados, rados_aio_wait_for_complete_enter, c)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_wait_for_complete_enter .state) *)&(__tracepoint_librados___rados_aio_wait_for_complete_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_wait_for_complete_enter (c); } while (0); | |||
4395 | int retval = ((librados::AioCompletionImpl*)c)->wait_for_complete(); | |||
4396 | tracepoint(librados, rados_aio_wait_for_complete_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_wait_for_complete_exit .state) *)&(__tracepoint_librados___rados_aio_wait_for_complete_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_wait_for_complete_exit (retval); } while (0); | |||
4397 | return retval; | |||
4398 | } | |||
4399 | ||||
4400 | extern "C" int rados_aio_wait_for_safe(rados_completion_t c) | |||
4401 | { | |||
4402 | tracepoint(librados, rados_aio_wait_for_safe_enter, c)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_wait_for_safe_enter .state) *)&(__tracepoint_librados___rados_aio_wait_for_safe_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_wait_for_safe_enter (c); } while (0); | |||
4403 | int retval = ((librados::AioCompletionImpl*)c)->wait_for_safe(); | |||
4404 | tracepoint(librados, rados_aio_wait_for_safe_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_wait_for_safe_exit .state) *)&(__tracepoint_librados___rados_aio_wait_for_safe_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_wait_for_safe_exit (retval); } while (0); | |||
4405 | return retval; | |||
4406 | } | |||
4407 | ||||
4408 | extern "C" int rados_aio_is_complete(rados_completion_t c) | |||
4409 | { | |||
4410 | tracepoint(librados, rados_aio_is_complete_enter, c)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_is_complete_enter .state) *)&(__tracepoint_librados___rados_aio_is_complete_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_is_complete_enter (c); } while (0); | |||
4411 | int retval = ((librados::AioCompletionImpl*)c)->is_complete(); | |||
4412 | tracepoint(librados, rados_aio_is_complete_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_is_complete_exit .state) *)&(__tracepoint_librados___rados_aio_is_complete_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_is_complete_exit (retval); } while (0); | |||
4413 | return retval; | |||
4414 | } | |||
4415 | ||||
4416 | extern "C" int rados_aio_is_safe(rados_completion_t c) | |||
4417 | { | |||
4418 | tracepoint(librados, rados_aio_is_safe_enter, c)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_is_safe_enter .state) *)&(__tracepoint_librados___rados_aio_is_safe_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_is_safe_enter (c); } while (0); | |||
4419 | int retval = ((librados::AioCompletionImpl*)c)->is_safe(); | |||
4420 | tracepoint(librados, rados_aio_is_safe_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_is_safe_exit .state) *)&(__tracepoint_librados___rados_aio_is_safe_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_is_safe_exit (retval); } while (0); | |||
4421 | return retval; | |||
4422 | } | |||
4423 | ||||
4424 | extern "C" int rados_aio_wait_for_complete_and_cb(rados_completion_t c) | |||
4425 | { | |||
4426 | tracepoint(librados, rados_aio_wait_for_complete_and_cb_enter, c)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_wait_for_complete_and_cb_enter .state) *)&(__tracepoint_librados___rados_aio_wait_for_complete_and_cb_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_wait_for_complete_and_cb_enter (c); } while (0); | |||
4427 | int retval = ((librados::AioCompletionImpl*)c)->wait_for_complete_and_cb(); | |||
4428 | tracepoint(librados, rados_aio_wait_for_complete_and_cb_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_wait_for_complete_and_cb_exit .state) *)&(__tracepoint_librados___rados_aio_wait_for_complete_and_cb_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_wait_for_complete_and_cb_exit (retval); } while (0); | |||
4429 | return retval; | |||
4430 | } | |||
4431 | ||||
4432 | extern "C" int rados_aio_wait_for_safe_and_cb(rados_completion_t c) | |||
4433 | { | |||
4434 | tracepoint(librados, rados_aio_wait_for_safe_and_cb_enter, c)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_wait_for_safe_and_cb_enter .state) *)&(__tracepoint_librados___rados_aio_wait_for_safe_and_cb_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_wait_for_safe_and_cb_enter (c); } while (0); | |||
4435 | int retval = ((librados::AioCompletionImpl*)c)->wait_for_safe_and_cb(); | |||
4436 | tracepoint(librados, rados_aio_wait_for_safe_and_cb_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_wait_for_safe_and_cb_exit .state) *)&(__tracepoint_librados___rados_aio_wait_for_safe_and_cb_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_wait_for_safe_and_cb_exit (retval); } while (0); | |||
4437 | return retval; | |||
4438 | } | |||
4439 | ||||
4440 | extern "C" int rados_aio_is_complete_and_cb(rados_completion_t c) | |||
4441 | { | |||
4442 | tracepoint(librados, rados_aio_is_complete_and_cb_enter, c)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_is_complete_and_cb_enter .state) *)&(__tracepoint_librados___rados_aio_is_complete_and_cb_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_is_complete_and_cb_enter (c); } while (0); | |||
4443 | int retval = ((librados::AioCompletionImpl*)c)->is_complete_and_cb(); | |||
4444 | tracepoint(librados, rados_aio_is_complete_and_cb_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_is_complete_and_cb_exit .state) *)&(__tracepoint_librados___rados_aio_is_complete_and_cb_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_is_complete_and_cb_exit (retval); } while (0); | |||
4445 | return retval; | |||
4446 | } | |||
4447 | ||||
4448 | extern "C" int rados_aio_is_safe_and_cb(rados_completion_t c) | |||
4449 | { | |||
4450 | tracepoint(librados, rados_aio_is_safe_and_cb_enter, c)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_is_safe_and_cb_enter .state) *)&(__tracepoint_librados___rados_aio_is_safe_and_cb_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_is_safe_and_cb_enter (c); } while (0); | |||
4451 | int retval = ((librados::AioCompletionImpl*)c)->is_safe_and_cb(); | |||
4452 | tracepoint(librados, rados_aio_is_safe_and_cb_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_is_safe_and_cb_exit .state) *)&(__tracepoint_librados___rados_aio_is_safe_and_cb_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_is_safe_and_cb_exit (retval); } while (0); | |||
4453 | return retval; | |||
4454 | } | |||
4455 | ||||
4456 | extern "C" int rados_aio_get_return_value(rados_completion_t c) | |||
4457 | { | |||
4458 | tracepoint(librados, rados_aio_get_return_value_enter, c)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_get_return_value_enter .state) *)&(__tracepoint_librados___rados_aio_get_return_value_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_get_return_value_enter (c); } while (0); | |||
4459 | int retval = ((librados::AioCompletionImpl*)c)->get_return_value(); | |||
4460 | tracepoint(librados, rados_aio_get_return_value_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_get_return_value_exit .state) *)&(__tracepoint_librados___rados_aio_get_return_value_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_get_return_value_exit (retval); } while (0); | |||
4461 | return retval; | |||
4462 | } | |||
4463 | ||||
4464 | extern "C" uint64_t rados_aio_get_version(rados_completion_t c) | |||
4465 | { | |||
4466 | tracepoint(librados, rados_aio_get_version_enter, c)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_get_version_enter .state) *)&(__tracepoint_librados___rados_aio_get_version_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_get_version_enter (c); } while (0); | |||
4467 | uint64_t retval = ((librados::AioCompletionImpl*)c)->get_version(); | |||
4468 | tracepoint(librados, rados_aio_get_version_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_get_version_exit .state) *)&(__tracepoint_librados___rados_aio_get_version_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_get_version_exit (retval); } while (0); | |||
4469 | return retval; | |||
4470 | } | |||
4471 | ||||
4472 | extern "C" void rados_aio_release(rados_completion_t c) | |||
4473 | { | |||
4474 | tracepoint(librados, rados_aio_release_enter, c)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_release_enter .state) *)&(__tracepoint_librados___rados_aio_release_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_release_enter (c); } while (0); | |||
4475 | ((librados::AioCompletionImpl*)c)->put(); | |||
4476 | tracepoint(librados, rados_aio_release_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_release_exit .state) *)&(__tracepoint_librados___rados_aio_release_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_release_exit (); } while (0); | |||
4477 | } | |||
4478 | ||||
4479 | extern "C" int rados_aio_read(rados_ioctx_t io, const char *o, | |||
4480 | rados_completion_t completion, | |||
4481 | char *buf, size_t len, uint64_t off) | |||
4482 | { | |||
4483 | tracepoint(librados, rados_aio_read_enter, io, o, completion, len, off)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_read_enter .state) *)&(__tracepoint_librados___rados_aio_read_enter. state)); })), 0)) __tracepoint_cb_librados___rados_aio_read_enter (io, o, completion, len, off); } while (0); | |||
4484 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4485 | object_t oid(o); | |||
4486 | int retval = ctx->aio_read(oid, (librados::AioCompletionImpl*)completion, | |||
4487 | buf, len, off, ctx->snap_seq); | |||
4488 | tracepoint(librados, rados_aio_read_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_read_exit .state) *)&(__tracepoint_librados___rados_aio_read_exit.state )); })), 0)) __tracepoint_cb_librados___rados_aio_read_exit(retval ); } while (0); | |||
4489 | return retval; | |||
4490 | } | |||
4491 | ||||
4492 | extern "C" int rados_aio_write(rados_ioctx_t io, const char *o, | |||
4493 | rados_completion_t completion, | |||
4494 | const char *buf, size_t len, uint64_t off) | |||
4495 | { | |||
4496 | tracepoint(librados, rados_aio_write_enter, io, o, completion, buf, len, off)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_write_enter .state) *)&(__tracepoint_librados___rados_aio_write_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_write_enter (io, o, completion, buf, len, off); } while (0); | |||
4497 | if (len > UINT_MAX(2147483647 *2U +1U)/2) | |||
4498 | return -E2BIG7; | |||
4499 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4500 | object_t oid(o); | |||
4501 | bufferlist bl; | |||
4502 | bl.append(buf, len); | |||
4503 | int retval = ctx->aio_write(oid, (librados::AioCompletionImpl*)completion, | |||
4504 | bl, len, off); | |||
4505 | tracepoint(librados, rados_aio_write_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_write_exit .state) *)&(__tracepoint_librados___rados_aio_write_exit. state)); })), 0)) __tracepoint_cb_librados___rados_aio_write_exit (retval); } while (0); | |||
4506 | return retval; | |||
4507 | } | |||
4508 | ||||
4509 | extern "C" int rados_aio_append(rados_ioctx_t io, const char *o, | |||
4510 | rados_completion_t completion, | |||
4511 | const char *buf, size_t len) | |||
4512 | { | |||
4513 | tracepoint(librados, rados_aio_append_enter, io, o, completion, buf, len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_append_enter .state) *)&(__tracepoint_librados___rados_aio_append_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_append_enter (io, o, completion, buf, len); } while (0); | |||
4514 | if (len > UINT_MAX(2147483647 *2U +1U)/2) | |||
4515 | return -E2BIG7; | |||
4516 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4517 | object_t oid(o); | |||
4518 | bufferlist bl; | |||
4519 | bl.append(buf, len); | |||
4520 | int retval = ctx->aio_append(oid, (librados::AioCompletionImpl*)completion, | |||
4521 | bl, len); | |||
4522 | tracepoint(librados, rados_aio_append_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_append_exit .state) *)&(__tracepoint_librados___rados_aio_append_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_append_exit (retval); } while (0); | |||
4523 | return retval; | |||
4524 | } | |||
4525 | ||||
4526 | extern "C" int rados_aio_write_full(rados_ioctx_t io, const char *o, | |||
4527 | rados_completion_t completion, | |||
4528 | const char *buf, size_t len) | |||
4529 | { | |||
4530 | tracepoint(librados, rados_aio_write_full_enter, io, o, completion, buf, len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_write_full_enter .state) *)&(__tracepoint_librados___rados_aio_write_full_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_write_full_enter (io, o, completion, buf, len); } while (0); | |||
4531 | if (len > UINT_MAX(2147483647 *2U +1U)/2) | |||
4532 | return -E2BIG7; | |||
4533 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4534 | object_t oid(o); | |||
4535 | bufferlist bl; | |||
4536 | bl.append(buf, len); | |||
4537 | int retval = ctx->aio_write_full(oid, (librados::AioCompletionImpl*)completion, bl); | |||
4538 | tracepoint(librados, rados_aio_write_full_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_write_full_exit .state) *)&(__tracepoint_librados___rados_aio_write_full_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_write_full_exit (retval); } while (0); | |||
4539 | return retval; | |||
4540 | } | |||
4541 | ||||
4542 | extern "C" int rados_aio_writesame(rados_ioctx_t io, const char *o, | |||
4543 | rados_completion_t completion, | |||
4544 | const char *buf, size_t data_len, | |||
4545 | size_t write_len, uint64_t off) | |||
4546 | { | |||
4547 | tracepoint(librados, rados_aio_writesame_enter, io, o, completion, buf,do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_writesame_enter .state) *)&(__tracepoint_librados___rados_aio_writesame_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_writesame_enter (io, o, completion, buf, data_len, write_len, off); } while ( 0) | |||
4548 | data_len, write_len, off)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_writesame_enter .state) *)&(__tracepoint_librados___rados_aio_writesame_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_writesame_enter (io, o, completion, buf, data_len, write_len, off); } while ( 0); | |||
4549 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4550 | object_t oid(o); | |||
4551 | bufferlist bl; | |||
4552 | bl.append(buf, data_len); | |||
4553 | int retval = ctx->aio_writesame(o, (librados::AioCompletionImpl*)completion, | |||
4554 | bl, write_len, off); | |||
4555 | tracepoint(librados, rados_aio_writesame_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_writesame_exit .state) *)&(__tracepoint_librados___rados_aio_writesame_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_writesame_exit (retval); } while (0); | |||
4556 | return retval; | |||
4557 | } | |||
4558 | ||||
4559 | extern "C" int rados_aio_remove(rados_ioctx_t io, const char *o, | |||
4560 | rados_completion_t completion) | |||
4561 | { | |||
4562 | tracepoint(librados, rados_aio_remove_enter, io, o, completion)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_remove_enter .state) *)&(__tracepoint_librados___rados_aio_remove_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_remove_enter (io, o, completion); } while (0); | |||
4563 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4564 | object_t oid(o); | |||
4565 | int retval = ctx->aio_remove(oid, (librados::AioCompletionImpl*)completion); | |||
4566 | tracepoint(librados, rados_aio_remove_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_remove_exit .state) *)&(__tracepoint_librados___rados_aio_remove_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_remove_exit (retval); } while (0); | |||
4567 | return retval; | |||
4568 | } | |||
4569 | ||||
4570 | extern "C" int rados_aio_flush_async(rados_ioctx_t io, | |||
4571 | rados_completion_t completion) | |||
4572 | { | |||
4573 | tracepoint(librados, rados_aio_flush_async_enter, io, completion)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_flush_async_enter .state) *)&(__tracepoint_librados___rados_aio_flush_async_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_flush_async_enter (io, completion); } while (0); | |||
4574 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4575 | ctx->flush_aio_writes_async((librados::AioCompletionImpl*)completion); | |||
4576 | tracepoint(librados, rados_aio_flush_async_exit, 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_flush_async_exit .state) *)&(__tracepoint_librados___rados_aio_flush_async_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_flush_async_exit (0); } while (0); | |||
4577 | return 0; | |||
4578 | } | |||
4579 | ||||
4580 | extern "C" int rados_aio_flush(rados_ioctx_t io) | |||
4581 | { | |||
4582 | tracepoint(librados, rados_aio_flush_enter, io)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_flush_enter .state) *)&(__tracepoint_librados___rados_aio_flush_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_flush_enter (io); } while (0); | |||
4583 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4584 | ctx->flush_aio_writes(); | |||
4585 | tracepoint(librados, rados_aio_flush_exit, 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_flush_exit .state) *)&(__tracepoint_librados___rados_aio_flush_exit. state)); })), 0)) __tracepoint_cb_librados___rados_aio_flush_exit (0); } while (0); | |||
4586 | return 0; | |||
4587 | } | |||
4588 | ||||
4589 | struct AioGetxattrData { | |||
4590 | AioGetxattrData(char* buf, rados_completion_t c, size_t l) : | |||
4591 | user_buf(buf), len(l), user_completion((librados::AioCompletionImpl*)c) {} | |||
4592 | bufferlist bl; | |||
4593 | char* user_buf; | |||
4594 | size_t len; | |||
4595 | struct librados::C_AioCompleteAndSafe user_completion; | |||
4596 | }; | |||
4597 | ||||
4598 | static void rados_aio_getxattr_complete(rados_completion_t c, void *arg) { | |||
4599 | AioGetxattrData *cdata = reinterpret_cast<AioGetxattrData*>(arg); | |||
4600 | int rc = rados_aio_get_return_value(c); | |||
4601 | if (rc >= 0) { | |||
4602 | if (cdata->bl.length() > cdata->len) { | |||
4603 | rc = -ERANGE34; | |||
4604 | } else { | |||
4605 | if (!cdata->bl.is_provided_buffer(cdata->user_buf)) | |||
4606 | cdata->bl.copy(0, cdata->bl.length(), cdata->user_buf); | |||
4607 | rc = cdata->bl.length(); | |||
4608 | } | |||
4609 | } | |||
4610 | cdata->user_completion.finish(rc); | |||
4611 | delete cdata; | |||
4612 | } | |||
4613 | ||||
4614 | extern "C" int rados_aio_getxattr(rados_ioctx_t io, const char *o, | |||
4615 | rados_completion_t completion, | |||
4616 | const char *name, char *buf, size_t len) | |||
4617 | { | |||
4618 | tracepoint(librados, rados_aio_getxattr_enter, io, o, completion, name, len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_getxattr_enter .state) *)&(__tracepoint_librados___rados_aio_getxattr_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_getxattr_enter (io, o, completion, name, len); } while (0); | |||
4619 | // create data object to be passed to async callback | |||
4620 | AioGetxattrData *cdata = new AioGetxattrData(buf, completion, len); | |||
4621 | if (!cdata) { | |||
4622 | tracepoint(librados, rados_aio_getxattr_exit, -ENOMEM, NULL, 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_getxattr_exit .state) *)&(__tracepoint_librados___rados_aio_getxattr_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_getxattr_exit (-12, __null, 0); } while (0); | |||
4623 | return -ENOMEM12; | |||
4624 | } | |||
4625 | cdata->bl.push_back(buffer::create_static(len, buf)); | |||
4626 | // create completion callback | |||
4627 | librados::AioCompletionImpl *c = new librados::AioCompletionImpl; | |||
4628 | c->set_complete_callback(cdata, rados_aio_getxattr_complete); | |||
4629 | // call async getxattr of IoCtx | |||
4630 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4631 | object_t oid(o); | |||
4632 | int ret = ctx->aio_getxattr(oid, c, name, cdata->bl); | |||
4633 | tracepoint(librados, rados_aio_getxattr_exit, ret, buf, ret)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_getxattr_exit .state) *)&(__tracepoint_librados___rados_aio_getxattr_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_getxattr_exit (ret, buf, ret); } while (0); | |||
4634 | return ret; | |||
4635 | } | |||
4636 | ||||
4637 | struct AioGetxattrsData { | |||
4638 | AioGetxattrsData(rados_completion_t c, rados_xattrs_iter_t *_iter) : | |||
4639 | iter(_iter), user_completion((librados::AioCompletionImpl*)c) { | |||
4640 | it = new librados::RadosXattrsIter(); | |||
4641 | } | |||
4642 | ~AioGetxattrsData() { | |||
4643 | if (it) delete it; | |||
4644 | } | |||
4645 | librados::RadosXattrsIter *it; | |||
4646 | rados_xattrs_iter_t *iter; | |||
4647 | struct librados::C_AioCompleteAndSafe user_completion; | |||
4648 | }; | |||
4649 | ||||
4650 | static void rados_aio_getxattrs_complete(rados_completion_t c, void *arg) { | |||
4651 | AioGetxattrsData *cdata = reinterpret_cast<AioGetxattrsData*>(arg); | |||
4652 | int rc = rados_aio_get_return_value(c); | |||
4653 | if (rc) { | |||
4654 | cdata->user_completion.finish(rc); | |||
4655 | } else { | |||
4656 | cdata->it->i = cdata->it->attrset.begin(); | |||
4657 | *cdata->iter = cdata->it; | |||
4658 | cdata->it = 0; | |||
4659 | cdata->user_completion.finish(0); | |||
4660 | } | |||
4661 | delete cdata; | |||
4662 | } | |||
4663 | ||||
4664 | extern "C" int rados_aio_getxattrs(rados_ioctx_t io, const char *oid, | |||
4665 | rados_completion_t completion, | |||
4666 | rados_xattrs_iter_t *iter) | |||
4667 | { | |||
4668 | tracepoint(librados, rados_aio_getxattrs_enter, io, oid, completion)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_getxattrs_enter .state) *)&(__tracepoint_librados___rados_aio_getxattrs_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_getxattrs_enter (io, oid, completion); } while (0); | |||
4669 | // create data object to be passed to async callback | |||
4670 | AioGetxattrsData *cdata = new AioGetxattrsData(completion, iter); | |||
4671 | if (!cdata) { | |||
4672 | tracepoint(librados, rados_getxattrs_exit, -ENOMEM, NULL)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_getxattrs_exit .state) *)&(__tracepoint_librados___rados_getxattrs_exit. state)); })), 0)) __tracepoint_cb_librados___rados_getxattrs_exit (-12, __null); } while (0); | |||
4673 | return -ENOMEM12; | |||
4674 | } | |||
4675 | // create completion callback | |||
4676 | librados::AioCompletionImpl *c = new librados::AioCompletionImpl; | |||
4677 | c->set_complete_callback(cdata, rados_aio_getxattrs_complete); | |||
4678 | // call async getxattrs of IoCtx | |||
4679 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4680 | object_t obj(oid); | |||
4681 | int ret = ctx->aio_getxattrs(obj, c, cdata->it->attrset); | |||
4682 | tracepoint(librados, rados_aio_getxattrs_exit, ret, cdata->it)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_getxattrs_exit .state) *)&(__tracepoint_librados___rados_aio_getxattrs_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_getxattrs_exit (ret, cdata->it); } while (0); | |||
4683 | return ret; | |||
4684 | } | |||
4685 | ||||
4686 | extern "C" int rados_aio_setxattr(rados_ioctx_t io, const char *o, | |||
4687 | rados_completion_t completion, | |||
4688 | const char *name, const char *buf, size_t len) | |||
4689 | { | |||
4690 | tracepoint(librados, rados_aio_setxattr_enter, io, o, completion, name, buf, len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_setxattr_enter .state) *)&(__tracepoint_librados___rados_aio_setxattr_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_setxattr_enter (io, o, completion, name, buf, len); } while (0); | |||
4691 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4692 | object_t oid(o); | |||
4693 | bufferlist bl; | |||
4694 | bl.append(buf, len); | |||
4695 | int retval = ctx->aio_setxattr(oid, (librados::AioCompletionImpl*)completion, name, bl); | |||
4696 | tracepoint(librados, rados_aio_setxattr_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_setxattr_exit .state) *)&(__tracepoint_librados___rados_aio_setxattr_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_setxattr_exit (retval); } while (0); | |||
4697 | return retval; | |||
4698 | } | |||
4699 | ||||
4700 | extern "C" int rados_aio_rmxattr(rados_ioctx_t io, const char *o, | |||
4701 | rados_completion_t completion, | |||
4702 | const char *name) | |||
4703 | { | |||
4704 | tracepoint(librados, rados_aio_rmxattr_enter, io, o, completion, name)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_rmxattr_enter .state) *)&(__tracepoint_librados___rados_aio_rmxattr_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_rmxattr_enter (io, o, completion, name); } while (0); | |||
4705 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4706 | object_t oid(o); | |||
4707 | int retval = ctx->aio_rmxattr(oid, (librados::AioCompletionImpl*)completion, name); | |||
4708 | tracepoint(librados, rados_aio_rmxattr_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_rmxattr_exit .state) *)&(__tracepoint_librados___rados_aio_rmxattr_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_rmxattr_exit (retval); } while (0); | |||
4709 | return retval; | |||
4710 | } | |||
4711 | ||||
4712 | extern "C" int rados_aio_stat(rados_ioctx_t io, const char *o, | |||
4713 | rados_completion_t completion, | |||
4714 | uint64_t *psize, time_t *pmtime) | |||
4715 | { | |||
4716 | tracepoint(librados, rados_aio_stat_enter, io, o, completion)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_stat_enter .state) *)&(__tracepoint_librados___rados_aio_stat_enter. state)); })), 0)) __tracepoint_cb_librados___rados_aio_stat_enter (io, o, completion); } while (0); | |||
4717 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4718 | object_t oid(o); | |||
4719 | int retval = ctx->aio_stat(oid, (librados::AioCompletionImpl*)completion, | |||
4720 | psize, pmtime); | |||
4721 | tracepoint(librados, rados_aio_stat_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_stat_exit .state) *)&(__tracepoint_librados___rados_aio_stat_exit.state )); })), 0)) __tracepoint_cb_librados___rados_aio_stat_exit(retval ); } while (0); | |||
4722 | return retval; | |||
4723 | } | |||
4724 | ||||
4725 | extern "C" int rados_aio_cancel(rados_ioctx_t io, rados_completion_t completion) | |||
4726 | { | |||
4727 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4728 | return ctx->aio_cancel((librados::AioCompletionImpl*)completion); | |||
4729 | } | |||
4730 | ||||
4731 | extern "C" int rados_aio_exec(rados_ioctx_t io, const char *o, | |||
4732 | rados_completion_t completion, | |||
4733 | const char *cls, const char *method, | |||
4734 | const char *inbuf, size_t in_len, | |||
4735 | char *buf, size_t out_len) | |||
4736 | { | |||
4737 | tracepoint(librados, rados_aio_exec_enter, io, o, completion)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_exec_enter .state) *)&(__tracepoint_librados___rados_aio_exec_enter. state)); })), 0)) __tracepoint_cb_librados___rados_aio_exec_enter (io, o, completion); } while (0); | |||
4738 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4739 | object_t oid(o); | |||
4740 | bufferlist inbl; | |||
4741 | inbl.append(inbuf, in_len); | |||
4742 | int retval = ctx->aio_exec(oid, (librados::AioCompletionImpl*)completion, | |||
4743 | cls, method, inbl, buf, out_len); | |||
4744 | tracepoint(librados, rados_aio_exec_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_exec_exit .state) *)&(__tracepoint_librados___rados_aio_exec_exit.state )); })), 0)) __tracepoint_cb_librados___rados_aio_exec_exit(retval ); } while (0); | |||
4745 | return retval; | |||
4746 | } | |||
4747 | ||||
4748 | struct C_WatchCB : public librados::WatchCtx { | |||
4749 | rados_watchcb_t wcb; | |||
4750 | void *arg; | |||
4751 | C_WatchCB(rados_watchcb_t _wcb, void *_arg) : wcb(_wcb), arg(_arg) {} | |||
4752 | void notify(uint8_t opcode, uint64_t ver, bufferlist& bl) { | |||
4753 | wcb(opcode, ver, arg); | |||
4754 | } | |||
4755 | }; | |||
4756 | ||||
4757 | extern "C" int rados_watch(rados_ioctx_t io, const char *o, uint64_t ver, | |||
4758 | uint64_t *handle, | |||
4759 | rados_watchcb_t watchcb, void *arg) | |||
4760 | { | |||
4761 | tracepoint(librados, rados_watch_enter, io, o, ver, watchcb, arg)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_watch_enter .state) *)&(__tracepoint_librados___rados_watch_enter.state )); })), 0)) __tracepoint_cb_librados___rados_watch_enter(io, o, ver, watchcb, arg); } while (0); | |||
4762 | uint64_t *cookie = handle; | |||
4763 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4764 | object_t oid(o); | |||
4765 | C_WatchCB *wc = new C_WatchCB(watchcb, arg); | |||
4766 | int retval = ctx->watch(oid, cookie, wc, NULL__null, true); | |||
4767 | tracepoint(librados, rados_watch_exit, retval, *handle)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_watch_exit .state) *)&(__tracepoint_librados___rados_watch_exit.state )); })), 0)) __tracepoint_cb_librados___rados_watch_exit(retval , *handle); } while (0); | |||
4768 | return retval; | |||
4769 | } | |||
4770 | ||||
4771 | struct C_WatchCB2 : public librados::WatchCtx2 { | |||
4772 | rados_watchcb2_t wcb; | |||
4773 | rados_watcherrcb_t errcb; | |||
4774 | void *arg; | |||
4775 | C_WatchCB2(rados_watchcb2_t _wcb, | |||
4776 | rados_watcherrcb_t _errcb, | |||
4777 | void *_arg) : wcb(_wcb), errcb(_errcb), arg(_arg) {} | |||
4778 | void handle_notify(uint64_t notify_id, | |||
4779 | uint64_t cookie, | |||
4780 | uint64_t notifier_gid, | |||
4781 | bufferlist& bl) { | |||
4782 | wcb(arg, notify_id, cookie, notifier_gid, bl.c_str(), bl.length()); | |||
4783 | } | |||
4784 | void handle_error(uint64_t cookie, int err) { | |||
4785 | if (errcb) | |||
4786 | errcb(arg, cookie, err); | |||
4787 | } | |||
4788 | }; | |||
4789 | ||||
4790 | extern "C" int rados_watch2(rados_ioctx_t io, const char *o, uint64_t *handle, | |||
4791 | rados_watchcb2_t watchcb, | |||
4792 | rados_watcherrcb_t watcherrcb, | |||
4793 | void *arg) { | |||
4794 | return rados_watch3(io, o, handle, watchcb, watcherrcb, 0, arg); | |||
4795 | } | |||
4796 | ||||
4797 | extern "C" int rados_watch3(rados_ioctx_t io, const char *o, uint64_t *handle, | |||
4798 | rados_watchcb2_t watchcb, | |||
4799 | rados_watcherrcb_t watcherrcb, | |||
4800 | uint32_t timeout, | |||
4801 | void *arg) | |||
4802 | { | |||
4803 | tracepoint(librados, rados_watch3_enter, io, o, handle, watchcb, timeout, arg)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_watch3_enter .state) *)&(__tracepoint_librados___rados_watch3_enter.state )); })), 0)) __tracepoint_cb_librados___rados_watch3_enter(io , o, handle, watchcb, timeout, arg); } while (0); | |||
4804 | int ret; | |||
4805 | if (!watchcb || !o || !handle) { | |||
4806 | ret = -EINVAL22; | |||
4807 | } else { | |||
4808 | uint64_t *cookie = handle; | |||
4809 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4810 | object_t oid(o); | |||
4811 | C_WatchCB2 *wc = new C_WatchCB2(watchcb, watcherrcb, arg); | |||
4812 | ret = ctx->watch(oid, cookie, NULL__null, wc, timeout, true); | |||
4813 | } | |||
4814 | tracepoint(librados, rados_watch3_exit, ret, handle ? *handle : 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_watch3_exit .state) *)&(__tracepoint_librados___rados_watch3_exit.state )); })), 0)) __tracepoint_cb_librados___rados_watch3_exit(ret , handle ? *handle : 0); } while (0); | |||
4815 | return ret; | |||
4816 | } | |||
4817 | ||||
4818 | extern "C" int rados_aio_watch(rados_ioctx_t io, const char *o, | |||
4819 | rados_completion_t completion, | |||
4820 | uint64_t *handle, | |||
4821 | rados_watchcb2_t watchcb, | |||
4822 | rados_watcherrcb_t watcherrcb, void *arg) { | |||
4823 | return rados_aio_watch2(io, o, completion, handle, watchcb, watcherrcb, 0, arg); | |||
4824 | } | |||
4825 | ||||
4826 | extern "C" int rados_aio_watch2(rados_ioctx_t io, const char *o, | |||
4827 | rados_completion_t completion, | |||
4828 | uint64_t *handle, | |||
4829 | rados_watchcb2_t watchcb, | |||
4830 | rados_watcherrcb_t watcherrcb, | |||
4831 | uint32_t timeout, void *arg) | |||
4832 | { | |||
4833 | tracepoint(librados, rados_aio_watch2_enter, io, o, completion, handle, watchcb, timeout, arg)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_watch2_enter .state) *)&(__tracepoint_librados___rados_aio_watch2_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_watch2_enter (io, o, completion, handle, watchcb, timeout, arg); } while ( 0); | |||
4834 | int ret; | |||
4835 | if (!completion || !watchcb || !o || !handle) { | |||
4836 | ret = -EINVAL22; | |||
4837 | } else { | |||
4838 | uint64_t *cookie = handle; | |||
4839 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4840 | object_t oid(o); | |||
4841 | librados::AioCompletionImpl *c = | |||
4842 | reinterpret_cast<librados::AioCompletionImpl*>(completion); | |||
4843 | C_WatchCB2 *wc = new C_WatchCB2(watchcb, watcherrcb, arg); | |||
4844 | ret = ctx->aio_watch(oid, c, cookie, NULL__null, wc, timeout, true); | |||
4845 | } | |||
4846 | tracepoint(librados, rados_aio_watch2_exit, ret, handle ? *handle : 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_watch2_exit .state) *)&(__tracepoint_librados___rados_aio_watch2_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_watch2_exit (ret, handle ? *handle : 0); } while (0); | |||
4847 | return ret; | |||
4848 | } | |||
4849 | ||||
4850 | ||||
4851 | extern "C" int rados_unwatch(rados_ioctx_t io, const char *o, uint64_t handle) | |||
4852 | { | |||
4853 | tracepoint(librados, rados_unwatch_enter, io, o, handle)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_unwatch_enter .state) *)&(__tracepoint_librados___rados_unwatch_enter.state )); })), 0)) __tracepoint_cb_librados___rados_unwatch_enter(io , o, handle); } while (0); | |||
4854 | uint64_t cookie = handle; | |||
4855 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4856 | int retval = ctx->unwatch(cookie); | |||
4857 | tracepoint(librados, rados_unwatch_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_unwatch_exit .state) *)&(__tracepoint_librados___rados_unwatch_exit.state )); })), 0)) __tracepoint_cb_librados___rados_unwatch_exit(retval ); } while (0); | |||
4858 | return retval; | |||
4859 | } | |||
4860 | ||||
4861 | extern "C" int rados_unwatch2(rados_ioctx_t io, uint64_t handle) | |||
4862 | { | |||
4863 | tracepoint(librados, rados_unwatch2_enter, io, handle)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_unwatch2_enter .state) *)&(__tracepoint_librados___rados_unwatch2_enter. state)); })), 0)) __tracepoint_cb_librados___rados_unwatch2_enter (io, handle); } while (0); | |||
4864 | uint64_t cookie = handle; | |||
4865 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4866 | int retval = ctx->unwatch(cookie); | |||
4867 | tracepoint(librados, rados_unwatch2_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_unwatch2_exit .state) *)&(__tracepoint_librados___rados_unwatch2_exit.state )); })), 0)) __tracepoint_cb_librados___rados_unwatch2_exit(retval ); } while (0); | |||
4868 | return retval; | |||
4869 | } | |||
4870 | ||||
4871 | extern "C" int rados_aio_unwatch(rados_ioctx_t io, uint64_t handle, | |||
4872 | rados_completion_t completion) | |||
4873 | { | |||
4874 | tracepoint(librados, rados_aio_unwatch_enter, io, handle, completion)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_unwatch_enter .state) *)&(__tracepoint_librados___rados_aio_unwatch_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_unwatch_enter (io, handle, completion); } while (0); | |||
4875 | uint64_t cookie = handle; | |||
4876 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4877 | librados::AioCompletionImpl *c = | |||
4878 | reinterpret_cast<librados::AioCompletionImpl*>(completion); | |||
4879 | int retval = ctx->aio_unwatch(cookie, c); | |||
4880 | tracepoint(librados, rados_aio_unwatch_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_unwatch_exit .state) *)&(__tracepoint_librados___rados_aio_unwatch_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_unwatch_exit (retval); } while (0); | |||
4881 | return retval; | |||
4882 | } | |||
4883 | ||||
4884 | extern "C" int rados_watch_check(rados_ioctx_t io, uint64_t handle) | |||
4885 | { | |||
4886 | tracepoint(librados, rados_watch_check_enter, io, handle)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_watch_check_enter .state) *)&(__tracepoint_librados___rados_watch_check_enter .state)); })), 0)) __tracepoint_cb_librados___rados_watch_check_enter (io, handle); } while (0); | |||
4887 | uint64_t cookie = handle; | |||
4888 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4889 | int retval = ctx->watch_check(cookie); | |||
4890 | tracepoint(librados, rados_watch_check_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_watch_check_exit .state) *)&(__tracepoint_librados___rados_watch_check_exit .state)); })), 0)) __tracepoint_cb_librados___rados_watch_check_exit (retval); } while (0); | |||
4891 | return retval; | |||
4892 | } | |||
4893 | ||||
4894 | extern "C" int rados_notify(rados_ioctx_t io, const char *o, | |||
4895 | uint64_t ver, const char *buf, int buf_len) | |||
4896 | { | |||
4897 | tracepoint(librados, rados_notify_enter, io, o, ver, buf, buf_len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_notify_enter .state) *)&(__tracepoint_librados___rados_notify_enter.state )); })), 0)) __tracepoint_cb_librados___rados_notify_enter(io , o, ver, buf, buf_len); } while (0); | |||
4898 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4899 | object_t oid(o); | |||
4900 | bufferlist bl; | |||
4901 | if (buf) { | |||
4902 | bufferptr p = buffer::create(buf_len); | |||
4903 | memcpy(p.c_str(), buf, buf_len); | |||
4904 | bl.push_back(p); | |||
4905 | } | |||
4906 | int retval = ctx->notify(oid, bl, 0, NULL__null, NULL__null, NULL__null); | |||
4907 | tracepoint(librados, rados_notify_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_notify_exit .state) *)&(__tracepoint_librados___rados_notify_exit.state )); })), 0)) __tracepoint_cb_librados___rados_notify_exit(retval ); } while (0); | |||
4908 | return retval; | |||
4909 | } | |||
4910 | ||||
4911 | extern "C" int rados_notify2(rados_ioctx_t io, const char *o, | |||
4912 | const char *buf, int buf_len, | |||
4913 | uint64_t timeout_ms, | |||
4914 | char **reply_buffer, | |||
4915 | size_t *reply_buffer_len) | |||
4916 | { | |||
4917 | tracepoint(librados, rados_notify2_enter, io, o, buf, buf_len, timeout_ms)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_notify2_enter .state) *)&(__tracepoint_librados___rados_notify2_enter.state )); })), 0)) __tracepoint_cb_librados___rados_notify2_enter(io , o, buf, buf_len, timeout_ms); } while (0); | |||
4918 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4919 | object_t oid(o); | |||
4920 | bufferlist bl; | |||
4921 | if (buf) { | |||
4922 | bufferptr p = buffer::create(buf_len); | |||
4923 | memcpy(p.c_str(), buf, buf_len); | |||
4924 | bl.push_back(p); | |||
4925 | } | |||
4926 | int ret = ctx->notify(oid, bl, timeout_ms, NULL__null, reply_buffer, reply_buffer_len); | |||
4927 | tracepoint(librados, rados_notify2_exit, ret)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_notify2_exit .state) *)&(__tracepoint_librados___rados_notify2_exit.state )); })), 0)) __tracepoint_cb_librados___rados_notify2_exit(ret ); } while (0); | |||
4928 | return ret; | |||
4929 | } | |||
4930 | ||||
4931 | extern "C" int rados_aio_notify(rados_ioctx_t io, const char *o, | |||
4932 | rados_completion_t completion, | |||
4933 | const char *buf, int buf_len, | |||
4934 | uint64_t timeout_ms, char **reply_buffer, | |||
4935 | size_t *reply_buffer_len) | |||
4936 | { | |||
4937 | tracepoint(librados, rados_aio_notify_enter, io, o, completion, buf, buf_len,do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_notify_enter .state) *)&(__tracepoint_librados___rados_aio_notify_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_notify_enter (io, o, completion, buf, buf_len, timeout_ms); } while (0) | |||
4938 | timeout_ms)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_notify_enter .state) *)&(__tracepoint_librados___rados_aio_notify_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_notify_enter (io, o, completion, buf, buf_len, timeout_ms); } while (0); | |||
4939 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4940 | object_t oid(o); | |||
4941 | bufferlist bl; | |||
4942 | if (buf) { | |||
4943 | bl.push_back(buffer::copy(buf, buf_len)); | |||
4944 | } | |||
4945 | librados::AioCompletionImpl *c = | |||
4946 | reinterpret_cast<librados::AioCompletionImpl*>(completion); | |||
4947 | int ret = ctx->aio_notify(oid, c, bl, timeout_ms, NULL__null, reply_buffer, | |||
4948 | reply_buffer_len); | |||
4949 | tracepoint(librados, rados_aio_notify_exit, ret)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_notify_exit .state) *)&(__tracepoint_librados___rados_aio_notify_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_notify_exit (ret); } while (0); | |||
4950 | return ret; | |||
4951 | } | |||
4952 | ||||
4953 | extern "C" int rados_notify_ack(rados_ioctx_t io, const char *o, | |||
4954 | uint64_t notify_id, uint64_t handle, | |||
4955 | const char *buf, int buf_len) | |||
4956 | { | |||
4957 | tracepoint(librados, rados_notify_ack_enter, io, o, notify_id, handle, buf, buf_len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_notify_ack_enter .state) *)&(__tracepoint_librados___rados_notify_ack_enter .state)); })), 0)) __tracepoint_cb_librados___rados_notify_ack_enter (io, o, notify_id, handle, buf, buf_len); } while (0); | |||
4958 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4959 | object_t oid(o); | |||
4960 | bufferlist bl; | |||
4961 | if (buf) { | |||
4962 | bufferptr p = buffer::create(buf_len); | |||
4963 | memcpy(p.c_str(), buf, buf_len); | |||
4964 | bl.push_back(p); | |||
4965 | } | |||
4966 | ctx->notify_ack(oid, notify_id, handle, bl); | |||
4967 | tracepoint(librados, rados_notify_ack_exit, 0)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_notify_ack_exit .state) *)&(__tracepoint_librados___rados_notify_ack_exit .state)); })), 0)) __tracepoint_cb_librados___rados_notify_ack_exit (0); } while (0); | |||
4968 | return 0; | |||
4969 | } | |||
4970 | ||||
4971 | extern "C" int rados_watch_flush(rados_t cluster) | |||
4972 | { | |||
4973 | tracepoint(librados, rados_watch_flush_enter, cluster)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_watch_flush_enter .state) *)&(__tracepoint_librados___rados_watch_flush_enter .state)); })), 0)) __tracepoint_cb_librados___rados_watch_flush_enter (cluster); } while (0); | |||
4974 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
4975 | int retval = client->watch_flush(); | |||
4976 | tracepoint(librados, rados_watch_flush_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_watch_flush_exit .state) *)&(__tracepoint_librados___rados_watch_flush_exit .state)); })), 0)) __tracepoint_cb_librados___rados_watch_flush_exit (retval); } while (0); | |||
4977 | return retval; | |||
4978 | } | |||
4979 | ||||
4980 | extern "C" int rados_aio_watch_flush(rados_t cluster, rados_completion_t completion) | |||
4981 | { | |||
4982 | tracepoint(librados, rados_aio_watch_flush_enter, cluster, completion)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_watch_flush_enter .state) *)&(__tracepoint_librados___rados_aio_watch_flush_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_watch_flush_enter (cluster, completion); } while (0); | |||
4983 | librados::RadosClient *client = (librados::RadosClient *)cluster; | |||
4984 | librados::AioCompletionImpl *c = (librados::AioCompletionImpl*)completion; | |||
4985 | int retval = client->async_watch_flush(c); | |||
4986 | tracepoint(librados, rados_aio_watch_flush_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_watch_flush_exit .state) *)&(__tracepoint_librados___rados_aio_watch_flush_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_watch_flush_exit (retval); } while (0); | |||
4987 | return retval; | |||
4988 | } | |||
4989 | ||||
4990 | extern "C" int rados_set_alloc_hint(rados_ioctx_t io, const char *o, | |||
4991 | uint64_t expected_object_size, | |||
4992 | uint64_t expected_write_size) | |||
4993 | { | |||
4994 | tracepoint(librados, rados_set_alloc_hint_enter, io, o, expected_object_size, expected_write_size)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_set_alloc_hint_enter .state) *)&(__tracepoint_librados___rados_set_alloc_hint_enter .state)); })), 0)) __tracepoint_cb_librados___rados_set_alloc_hint_enter (io, o, expected_object_size, expected_write_size); } while ( 0); | |||
4995 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
4996 | object_t oid(o); | |||
4997 | int retval = ctx->set_alloc_hint(oid, expected_object_size, | |||
4998 | expected_write_size, 0); | |||
4999 | tracepoint(librados, rados_set_alloc_hint_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_set_alloc_hint_exit .state) *)&(__tracepoint_librados___rados_set_alloc_hint_exit .state)); })), 0)) __tracepoint_cb_librados___rados_set_alloc_hint_exit (retval); } while (0); | |||
5000 | return retval; | |||
5001 | } | |||
5002 | ||||
5003 | extern "C" int rados_set_alloc_hint2(rados_ioctx_t io, const char *o, | |||
5004 | uint64_t expected_object_size, | |||
5005 | uint64_t expected_write_size, | |||
5006 | uint32_t flags) | |||
5007 | { | |||
5008 | tracepoint(librados, rados_set_alloc_hint2_enter, io, o, expected_object_size, expected_write_size, flags)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_set_alloc_hint2_enter .state) *)&(__tracepoint_librados___rados_set_alloc_hint2_enter .state)); })), 0)) __tracepoint_cb_librados___rados_set_alloc_hint2_enter (io, o, expected_object_size, expected_write_size, flags); } while (0); | |||
5009 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
5010 | object_t oid(o); | |||
5011 | int retval = ctx->set_alloc_hint(oid, expected_object_size, | |||
5012 | expected_write_size, flags); | |||
5013 | tracepoint(librados, rados_set_alloc_hint2_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_set_alloc_hint2_exit .state) *)&(__tracepoint_librados___rados_set_alloc_hint2_exit .state)); })), 0)) __tracepoint_cb_librados___rados_set_alloc_hint2_exit (retval); } while (0); | |||
5014 | return retval; | |||
5015 | } | |||
5016 | ||||
5017 | extern "C" int rados_lock_exclusive(rados_ioctx_t io, const char * o, | |||
5018 | const char * name, const char * cookie, | |||
5019 | const char * desc, struct timeval * duration, | |||
5020 | uint8_t flags) | |||
5021 | { | |||
5022 | tracepoint(librados, rados_lock_exclusive_enter, io, o, name, cookie, desc, duration, flags)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_lock_exclusive_enter .state) *)&(__tracepoint_librados___rados_lock_exclusive_enter .state)); })), 0)) __tracepoint_cb_librados___rados_lock_exclusive_enter (io, o, name, cookie, desc, duration, flags); } while (0); | |||
5023 | librados::IoCtx ctx; | |||
5024 | librados::IoCtx::from_rados_ioctx_t(io, ctx); | |||
5025 | ||||
5026 | int retval = ctx.lock_exclusive(o, name, cookie, desc, duration, flags); | |||
5027 | tracepoint(librados, rados_lock_exclusive_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_lock_exclusive_exit .state) *)&(__tracepoint_librados___rados_lock_exclusive_exit .state)); })), 0)) __tracepoint_cb_librados___rados_lock_exclusive_exit (retval); } while (0); | |||
5028 | return retval; | |||
5029 | } | |||
5030 | ||||
5031 | extern "C" int rados_lock_shared(rados_ioctx_t io, const char * o, | |||
5032 | const char * name, const char * cookie, | |||
5033 | const char * tag, const char * desc, | |||
5034 | struct timeval * duration, uint8_t flags) | |||
5035 | { | |||
5036 | tracepoint(librados, rados_lock_shared_enter, io, o, name, cookie, tag, desc, duration, flags)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_lock_shared_enter .state) *)&(__tracepoint_librados___rados_lock_shared_enter .state)); })), 0)) __tracepoint_cb_librados___rados_lock_shared_enter (io, o, name, cookie, tag, desc, duration, flags); } while (0 ); | |||
5037 | librados::IoCtx ctx; | |||
5038 | librados::IoCtx::from_rados_ioctx_t(io, ctx); | |||
5039 | ||||
5040 | int retval = ctx.lock_shared(o, name, cookie, tag, desc, duration, flags); | |||
5041 | tracepoint(librados, rados_lock_shared_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_lock_shared_exit .state) *)&(__tracepoint_librados___rados_lock_shared_exit .state)); })), 0)) __tracepoint_cb_librados___rados_lock_shared_exit (retval); } while (0); | |||
5042 | return retval; | |||
5043 | } | |||
5044 | extern "C" int rados_unlock(rados_ioctx_t io, const char *o, const char *name, | |||
5045 | const char *cookie) | |||
5046 | { | |||
5047 | tracepoint(librados, rados_unlock_enter, io, o, name, cookie)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_unlock_enter .state) *)&(__tracepoint_librados___rados_unlock_enter.state )); })), 0)) __tracepoint_cb_librados___rados_unlock_enter(io , o, name, cookie); } while (0); | |||
5048 | librados::IoCtx ctx; | |||
5049 | librados::IoCtx::from_rados_ioctx_t(io, ctx); | |||
5050 | ||||
5051 | int retval = ctx.unlock(o, name, cookie); | |||
5052 | tracepoint(librados, rados_unlock_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_unlock_exit .state) *)&(__tracepoint_librados___rados_unlock_exit.state )); })), 0)) __tracepoint_cb_librados___rados_unlock_exit(retval ); } while (0); | |||
5053 | return retval; | |||
5054 | } | |||
5055 | ||||
5056 | extern "C" int rados_aio_unlock(rados_ioctx_t io, const char *o, const char *name, | |||
5057 | const char *cookie, rados_completion_t completion) | |||
5058 | { | |||
5059 | tracepoint(librados, rados_aio_unlock_enter, io, o, name, cookie, completion)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_unlock_enter .state) *)&(__tracepoint_librados___rados_aio_unlock_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_unlock_enter (io, o, name, cookie, completion); } while (0); | |||
5060 | librados::IoCtx ctx; | |||
5061 | librados::IoCtx::from_rados_ioctx_t(io, ctx); | |||
5062 | librados::AioCompletionImpl *comp = (librados::AioCompletionImpl*)completion; | |||
5063 | librados::AioCompletion c(comp); | |||
5064 | int retval = ctx.aio_unlock(o, name, cookie, &c); | |||
5065 | tracepoint(librados, rados_aio_unlock_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_unlock_exit .state) *)&(__tracepoint_librados___rados_aio_unlock_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_unlock_exit (retval); } while (0); | |||
5066 | return retval; | |||
5067 | } | |||
5068 | ||||
5069 | extern "C" ssize_t rados_list_lockers(rados_ioctx_t io, const char *o, | |||
5070 | const char *name, int *exclusive, | |||
5071 | char *tag, size_t *tag_len, | |||
5072 | char *clients, size_t *clients_len, | |||
5073 | char *cookies, size_t *cookies_len, | |||
5074 | char *addrs, size_t *addrs_len) | |||
5075 | { | |||
5076 | tracepoint(librados, rados_list_lockers_enter, io, o, name, *tag_len, *clients_len, *cookies_len, *addrs_len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_list_lockers_enter .state) *)&(__tracepoint_librados___rados_list_lockers_enter .state)); })), 0)) __tracepoint_cb_librados___rados_list_lockers_enter (io, o, name, *tag_len, *clients_len, *cookies_len, *addrs_len ); } while (0); | |||
5077 | librados::IoCtx ctx; | |||
5078 | librados::IoCtx::from_rados_ioctx_t(io, ctx); | |||
5079 | std::string name_str = name; | |||
5080 | std::string oid = o; | |||
5081 | std::string tag_str; | |||
5082 | int tmp_exclusive; | |||
5083 | std::list<librados::locker_t> lockers; | |||
5084 | int r = ctx.list_lockers(oid, name_str, &tmp_exclusive, &tag_str, &lockers); | |||
5085 | if (r < 0) { | |||
5086 | tracepoint(librados, rados_list_lockers_exit, r, *exclusive, "", *tag_len, *clients_len, *cookies_len, *addrs_len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_list_lockers_exit .state) *)&(__tracepoint_librados___rados_list_lockers_exit .state)); })), 0)) __tracepoint_cb_librados___rados_list_lockers_exit (r, *exclusive, "", *tag_len, *clients_len, *cookies_len, *addrs_len ); } while (0); | |||
5087 | return r; | |||
5088 | } | |||
5089 | ||||
5090 | size_t clients_total = 0; | |||
5091 | size_t cookies_total = 0; | |||
5092 | size_t addrs_total = 0; | |||
5093 | list<librados::locker_t>::const_iterator it; | |||
5094 | for (it = lockers.begin(); it != lockers.end(); ++it) { | |||
5095 | clients_total += it->client.length() + 1; | |||
5096 | cookies_total += it->cookie.length() + 1; | |||
5097 | addrs_total += it->address.length() + 1; | |||
5098 | } | |||
5099 | ||||
5100 | bool too_short = ((clients_total > *clients_len) || | |||
5101 | (cookies_total > *cookies_len) || | |||
5102 | (addrs_total > *addrs_len) || | |||
5103 | (tag_str.length() + 1 > *tag_len)); | |||
5104 | *clients_len = clients_total; | |||
5105 | *cookies_len = cookies_total; | |||
5106 | *addrs_len = addrs_total; | |||
5107 | *tag_len = tag_str.length() + 1; | |||
5108 | if (too_short) { | |||
5109 | tracepoint(librados, rados_list_lockers_exit, -ERANGE, *exclusive, "", *tag_len, *clients_len, *cookies_len, *addrs_len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_list_lockers_exit .state) *)&(__tracepoint_librados___rados_list_lockers_exit .state)); })), 0)) __tracepoint_cb_librados___rados_list_lockers_exit (-34, *exclusive, "", *tag_len, *clients_len, *cookies_len, * addrs_len); } while (0); | |||
5110 | return -ERANGE34; | |||
5111 | } | |||
5112 | ||||
5113 | strcpy(tag, tag_str.c_str()); | |||
5114 | char *clients_p = clients; | |||
5115 | char *cookies_p = cookies; | |||
5116 | char *addrs_p = addrs; | |||
5117 | for (it = lockers.begin(); it != lockers.end(); ++it) { | |||
5118 | strcpy(clients_p, it->client.c_str()); | |||
5119 | strcpy(cookies_p, it->cookie.c_str()); | |||
5120 | strcpy(addrs_p, it->address.c_str()); | |||
5121 | tracepoint(librados, rados_list_lockers_locker, clients_p, cookies_p, addrs_p)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_list_lockers_locker .state) *)&(__tracepoint_librados___rados_list_lockers_locker .state)); })), 0)) __tracepoint_cb_librados___rados_list_lockers_locker (clients_p, cookies_p, addrs_p); } while (0); | |||
5122 | clients_p += it->client.length() + 1; | |||
5123 | cookies_p += it->cookie.length() + 1; | |||
5124 | addrs_p += it->address.length() + 1; | |||
5125 | } | |||
5126 | if (tmp_exclusive) | |||
5127 | *exclusive = 1; | |||
5128 | else | |||
5129 | *exclusive = 0; | |||
5130 | ||||
5131 | int retval = lockers.size(); | |||
5132 | tracepoint(librados, rados_list_lockers_exit, retval, *exclusive, tag, *tag_len, *clients_len, *cookies_len, *addrs_len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_list_lockers_exit .state) *)&(__tracepoint_librados___rados_list_lockers_exit .state)); })), 0)) __tracepoint_cb_librados___rados_list_lockers_exit (retval, *exclusive, tag, *tag_len, *clients_len, *cookies_len , *addrs_len); } while (0); | |||
5133 | return retval; | |||
5134 | } | |||
5135 | ||||
5136 | extern "C" int rados_break_lock(rados_ioctx_t io, const char *o, | |||
5137 | const char *name, const char *client, | |||
5138 | const char *cookie) | |||
5139 | { | |||
5140 | tracepoint(librados, rados_break_lock_enter, io, o, name, client, cookie)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_break_lock_enter .state) *)&(__tracepoint_librados___rados_break_lock_enter .state)); })), 0)) __tracepoint_cb_librados___rados_break_lock_enter (io, o, name, client, cookie); } while (0); | |||
5141 | librados::IoCtx ctx; | |||
5142 | librados::IoCtx::from_rados_ioctx_t(io, ctx); | |||
5143 | ||||
5144 | int retval = ctx.break_lock(o, name, client, cookie); | |||
5145 | tracepoint(librados, rados_break_lock_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_break_lock_exit .state) *)&(__tracepoint_librados___rados_break_lock_exit .state)); })), 0)) __tracepoint_cb_librados___rados_break_lock_exit (retval); } while (0); | |||
5146 | return retval; | |||
5147 | } | |||
5148 | ||||
5149 | extern "C" rados_write_op_t rados_create_write_op() | |||
5150 | { | |||
5151 | tracepoint(librados, rados_create_write_op_enter)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_create_write_op_enter .state) *)&(__tracepoint_librados___rados_create_write_op_enter .state)); })), 0)) __tracepoint_cb_librados___rados_create_write_op_enter (); } while (0); | |||
5152 | rados_write_op_t retval = new (std::nothrow)::ObjectOperation; | |||
5153 | tracepoint(librados, rados_create_write_op_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_create_write_op_exit .state) *)&(__tracepoint_librados___rados_create_write_op_exit .state)); })), 0)) __tracepoint_cb_librados___rados_create_write_op_exit (retval); } while (0); | |||
5154 | return retval; | |||
5155 | } | |||
5156 | ||||
5157 | extern "C" void rados_release_write_op(rados_write_op_t write_op) | |||
5158 | { | |||
5159 | tracepoint(librados, rados_release_write_op_enter, write_op)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_release_write_op_enter .state) *)&(__tracepoint_librados___rados_release_write_op_enter .state)); })), 0)) __tracepoint_cb_librados___rados_release_write_op_enter (write_op); } while (0); | |||
5160 | delete (::ObjectOperation*)write_op; | |||
5161 | tracepoint(librados, rados_release_write_op_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_release_write_op_exit .state) *)&(__tracepoint_librados___rados_release_write_op_exit .state)); })), 0)) __tracepoint_cb_librados___rados_release_write_op_exit (); } while (0); | |||
5162 | } | |||
5163 | ||||
5164 | extern "C" void rados_write_op_set_flags(rados_write_op_t write_op, int flags) | |||
5165 | { | |||
5166 | tracepoint(librados, rados_write_op_set_flags_enter, write_op, flags)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_set_flags_enter .state) *)&(__tracepoint_librados___rados_write_op_set_flags_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_set_flags_enter (write_op, flags); } while (0); | |||
5167 | set_op_flags((::ObjectOperation *)write_op, flags); | |||
5168 | tracepoint(librados, rados_write_op_set_flags_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_set_flags_exit .state) *)&(__tracepoint_librados___rados_write_op_set_flags_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_set_flags_exit (); } while (0); | |||
5169 | } | |||
5170 | ||||
5171 | extern "C" void rados_write_op_assert_version(rados_write_op_t write_op, uint64_t ver) | |||
5172 | { | |||
5173 | tracepoint(librados, rados_write_op_assert_version_enter, write_op, ver)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_assert_version_enter .state) *)&(__tracepoint_librados___rados_write_op_assert_version_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_assert_version_enter (write_op, ver); } while (0); | |||
5174 | ((::ObjectOperation *)write_op)->assert_version(ver); | |||
5175 | tracepoint(librados, rados_write_op_assert_version_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_assert_version_exit .state) *)&(__tracepoint_librados___rados_write_op_assert_version_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_assert_version_exit (); } while (0); | |||
5176 | } | |||
5177 | ||||
5178 | extern "C" void rados_write_op_assert_exists(rados_write_op_t write_op) | |||
5179 | { | |||
5180 | tracepoint(librados, rados_write_op_assert_exists_enter, write_op)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_assert_exists_enter .state) *)&(__tracepoint_librados___rados_write_op_assert_exists_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_assert_exists_enter (write_op); } while (0); | |||
5181 | ((::ObjectOperation *)write_op)->stat(NULL__null, (ceph::real_time *)NULL__null, NULL__null); | |||
5182 | tracepoint(librados, rados_write_op_assert_exists_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_assert_exists_exit .state) *)&(__tracepoint_librados___rados_write_op_assert_exists_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_assert_exists_exit (); } while (0); | |||
5183 | } | |||
5184 | ||||
5185 | extern "C" void rados_write_op_cmpxattr(rados_write_op_t write_op, | |||
5186 | const char *name, | |||
5187 | uint8_t comparison_operator, | |||
5188 | const char *value, | |||
5189 | size_t value_len) | |||
5190 | { | |||
5191 | tracepoint(librados, rados_write_op_cmpxattr_enter, write_op, name, comparison_operator, value, value_len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_cmpxattr_enter .state) *)&(__tracepoint_librados___rados_write_op_cmpxattr_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_cmpxattr_enter (write_op, name, comparison_operator, value, value_len); } while (0); | |||
5192 | bufferlist bl; | |||
5193 | bl.append(value, value_len); | |||
5194 | ((::ObjectOperation *)write_op)->cmpxattr(name, | |||
5195 | comparison_operator, | |||
5196 | CEPH_OSD_CMPXATTR_MODE_STRING, | |||
5197 | bl); | |||
5198 | tracepoint(librados, rados_write_op_cmpxattr_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_cmpxattr_exit .state) *)&(__tracepoint_librados___rados_write_op_cmpxattr_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_cmpxattr_exit (); } while (0); | |||
5199 | } | |||
5200 | ||||
5201 | static void rados_c_omap_cmp(ObjectOperation *op, | |||
5202 | const char *key, | |||
5203 | uint8_t comparison_operator, | |||
5204 | const char *val, | |||
5205 | size_t val_len, | |||
5206 | int *prval) | |||
5207 | { | |||
5208 | bufferlist bl; | |||
5209 | bl.append(val, val_len); | |||
5210 | std::map<std::string, pair<bufferlist, int> > assertions; | |||
5211 | assertions[key] = std::make_pair(bl, comparison_operator); | |||
5212 | op->omap_cmp(assertions, prval); | |||
5213 | } | |||
5214 | ||||
5215 | extern "C" void rados_write_op_omap_cmp(rados_write_op_t write_op, | |||
5216 | const char *key, | |||
5217 | uint8_t comparison_operator, | |||
5218 | const char *val, | |||
5219 | size_t val_len, | |||
5220 | int *prval) | |||
5221 | { | |||
5222 | tracepoint(librados, rados_write_op_omap_cmp_enter, write_op, key, comparison_operator, val, val_len, prval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_omap_cmp_enter .state) *)&(__tracepoint_librados___rados_write_op_omap_cmp_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_omap_cmp_enter (write_op, key, comparison_operator, val, val_len, prval); } while (0); | |||
5223 | rados_c_omap_cmp((::ObjectOperation *)write_op, key, comparison_operator, | |||
5224 | val, val_len, prval); | |||
5225 | tracepoint(librados, rados_write_op_omap_cmp_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_omap_cmp_exit .state) *)&(__tracepoint_librados___rados_write_op_omap_cmp_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_omap_cmp_exit (); } while (0); | |||
5226 | } | |||
5227 | ||||
5228 | extern "C" void rados_write_op_setxattr(rados_write_op_t write_op, | |||
5229 | const char *name, | |||
5230 | const char *value, | |||
5231 | size_t value_len) | |||
5232 | { | |||
5233 | tracepoint(librados, rados_write_op_setxattr_enter, write_op, name, value, value_len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_setxattr_enter .state) *)&(__tracepoint_librados___rados_write_op_setxattr_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_setxattr_enter (write_op, name, value, value_len); } while (0); | |||
5234 | bufferlist bl; | |||
5235 | bl.append(value, value_len); | |||
5236 | ((::ObjectOperation *)write_op)->setxattr(name, bl); | |||
5237 | tracepoint(librados, rados_write_op_setxattr_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_setxattr_exit .state) *)&(__tracepoint_librados___rados_write_op_setxattr_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_setxattr_exit (); } while (0); | |||
5238 | } | |||
5239 | ||||
5240 | extern "C" void rados_write_op_rmxattr(rados_write_op_t write_op, | |||
5241 | const char *name) | |||
5242 | { | |||
5243 | tracepoint(librados, rados_write_op_rmxattr_enter, write_op, name)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_rmxattr_enter .state) *)&(__tracepoint_librados___rados_write_op_rmxattr_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_rmxattr_enter (write_op, name); } while (0); | |||
5244 | ((::ObjectOperation *)write_op)->rmxattr(name); | |||
5245 | tracepoint(librados, rados_write_op_rmxattr_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_rmxattr_exit .state) *)&(__tracepoint_librados___rados_write_op_rmxattr_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_rmxattr_exit (); } while (0); | |||
5246 | } | |||
5247 | ||||
5248 | extern "C" void rados_write_op_create(rados_write_op_t write_op, | |||
5249 | int exclusive, | |||
5250 | const char* category) // unused | |||
5251 | { | |||
5252 | tracepoint(librados, rados_write_op_create_enter, write_op, exclusive)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_create_enter .state) *)&(__tracepoint_librados___rados_write_op_create_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_create_enter (write_op, exclusive); } while (0); | |||
5253 | ::ObjectOperation *oo = (::ObjectOperation *) write_op; | |||
5254 | oo->create(!!exclusive); | |||
5255 | tracepoint(librados, rados_write_op_create_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_create_exit .state) *)&(__tracepoint_librados___rados_write_op_create_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_create_exit (); } while (0); | |||
5256 | } | |||
5257 | ||||
5258 | extern "C" void rados_write_op_write(rados_write_op_t write_op, | |||
5259 | const char *buffer, | |||
5260 | size_t len, | |||
5261 | uint64_t offset) | |||
5262 | { | |||
5263 | tracepoint(librados, rados_write_op_write_enter, write_op, buffer, len, offset)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_write_enter .state) *)&(__tracepoint_librados___rados_write_op_write_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_write_enter (write_op, buffer, len, offset); } while (0); | |||
5264 | bufferlist bl; | |||
5265 | bl.append(buffer,len); | |||
5266 | ((::ObjectOperation *)write_op)->write(offset, bl); | |||
5267 | tracepoint(librados, rados_write_op_write_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_write_exit .state) *)&(__tracepoint_librados___rados_write_op_write_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_write_exit (); } while (0); | |||
5268 | } | |||
5269 | ||||
5270 | extern "C" void rados_write_op_write_full(rados_write_op_t write_op, | |||
5271 | const char *buffer, | |||
5272 | size_t len) | |||
5273 | { | |||
5274 | tracepoint(librados, rados_write_op_write_full_enter, write_op, buffer, len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_write_full_enter .state) *)&(__tracepoint_librados___rados_write_op_write_full_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_write_full_enter (write_op, buffer, len); } while (0); | |||
5275 | bufferlist bl; | |||
5276 | bl.append(buffer,len); | |||
5277 | ((::ObjectOperation *)write_op)->write_full(bl); | |||
5278 | tracepoint(librados, rados_write_op_write_full_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_write_full_exit .state) *)&(__tracepoint_librados___rados_write_op_write_full_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_write_full_exit (); } while (0); | |||
5279 | } | |||
5280 | ||||
5281 | extern "C" void rados_write_op_writesame(rados_write_op_t write_op, | |||
5282 | const char *buffer, | |||
5283 | size_t data_len, | |||
5284 | size_t write_len, | |||
5285 | uint64_t offset) | |||
5286 | { | |||
5287 | tracepoint(librados, rados_write_op_writesame_enter, write_op, buffer, data_len, write_len, offset)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_writesame_enter .state) *)&(__tracepoint_librados___rados_write_op_writesame_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_writesame_enter (write_op, buffer, data_len, write_len, offset); } while (0); | |||
5288 | bufferlist bl; | |||
5289 | bl.append(buffer, data_len); | |||
5290 | ((::ObjectOperation *)write_op)->writesame(offset, write_len, bl); | |||
5291 | tracepoint(librados, rados_write_op_writesame_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_writesame_exit .state) *)&(__tracepoint_librados___rados_write_op_writesame_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_writesame_exit (); } while (0); | |||
5292 | } | |||
5293 | ||||
5294 | extern "C" void rados_write_op_append(rados_write_op_t write_op, | |||
5295 | const char *buffer, | |||
5296 | size_t len) | |||
5297 | { | |||
5298 | tracepoint(librados, rados_write_op_append_enter, write_op, buffer, len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_append_enter .state) *)&(__tracepoint_librados___rados_write_op_append_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_append_enter (write_op, buffer, len); } while (0); | |||
5299 | bufferlist bl; | |||
5300 | bl.append(buffer,len); | |||
5301 | ((::ObjectOperation *)write_op)->append(bl); | |||
5302 | tracepoint(librados, rados_write_op_append_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_append_exit .state) *)&(__tracepoint_librados___rados_write_op_append_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_append_exit (); } while (0); | |||
5303 | } | |||
5304 | ||||
5305 | extern "C" void rados_write_op_remove(rados_write_op_t write_op) | |||
5306 | { | |||
5307 | tracepoint(librados, rados_write_op_remove_enter, write_op)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_remove_enter .state) *)&(__tracepoint_librados___rados_write_op_remove_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_remove_enter (write_op); } while (0); | |||
5308 | ((::ObjectOperation *)write_op)->remove(); | |||
5309 | tracepoint(librados, rados_write_op_remove_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_remove_exit .state) *)&(__tracepoint_librados___rados_write_op_remove_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_remove_exit (); } while (0); | |||
5310 | } | |||
5311 | ||||
5312 | extern "C" void rados_write_op_truncate(rados_write_op_t write_op, | |||
5313 | uint64_t offset) | |||
5314 | { | |||
5315 | tracepoint(librados, rados_write_op_truncate_enter, write_op, offset)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_truncate_enter .state) *)&(__tracepoint_librados___rados_write_op_truncate_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_truncate_enter (write_op, offset); } while (0); | |||
5316 | ((::ObjectOperation *)write_op)->truncate(offset); | |||
5317 | tracepoint(librados, rados_write_op_truncate_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_truncate_exit .state) *)&(__tracepoint_librados___rados_write_op_truncate_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_truncate_exit (); } while (0); | |||
5318 | } | |||
5319 | ||||
5320 | extern "C" void rados_write_op_zero(rados_write_op_t write_op, | |||
5321 | uint64_t offset, | |||
5322 | uint64_t len) | |||
5323 | { | |||
5324 | tracepoint(librados, rados_write_op_zero_enter, write_op, offset, len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_zero_enter .state) *)&(__tracepoint_librados___rados_write_op_zero_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_zero_enter (write_op, offset, len); } while (0); | |||
5325 | ((::ObjectOperation *)write_op)->zero(offset, len); | |||
5326 | tracepoint(librados, rados_write_op_zero_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_zero_exit .state) *)&(__tracepoint_librados___rados_write_op_zero_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_zero_exit (); } while (0); | |||
5327 | } | |||
5328 | ||||
5329 | extern "C" void rados_write_op_exec(rados_write_op_t write_op, | |||
5330 | const char *cls, | |||
5331 | const char *method, | |||
5332 | const char *in_buf, | |||
5333 | size_t in_len, | |||
5334 | int *prval) | |||
5335 | { | |||
5336 | tracepoint(librados, rados_write_op_exec_enter, write_op, cls, method, in_buf, in_len, prval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_exec_enter .state) *)&(__tracepoint_librados___rados_write_op_exec_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_exec_enter (write_op, cls, method, in_buf, in_len, prval); } while (0); | |||
5337 | bufferlist inbl; | |||
5338 | inbl.append(in_buf, in_len); | |||
5339 | ((::ObjectOperation *)write_op)->call(cls, method, inbl, NULL__null, NULL__null, prval); | |||
5340 | tracepoint(librados, rados_write_op_exec_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_exec_exit .state) *)&(__tracepoint_librados___rados_write_op_exec_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_exec_exit (); } while (0); | |||
5341 | } | |||
5342 | ||||
5343 | extern "C" void rados_write_op_omap_set(rados_write_op_t write_op, | |||
5344 | char const* const* keys, | |||
5345 | char const* const* vals, | |||
5346 | const size_t *lens, | |||
5347 | size_t num) | |||
5348 | { | |||
5349 | tracepoint(librados, rados_write_op_omap_set_enter, write_op, num)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_omap_set_enter .state) *)&(__tracepoint_librados___rados_write_op_omap_set_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_omap_set_enter (write_op, num); } while (0); | |||
5350 | std::map<std::string, bufferlist> entries; | |||
5351 | for (size_t i = 0; i < num; ++i) { | |||
5352 | tracepoint(librados, rados_write_op_omap_set_entry, keys[i], vals[i], lens[i])do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_omap_set_entry .state) *)&(__tracepoint_librados___rados_write_op_omap_set_entry .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_omap_set_entry (keys[i], vals[i], lens[i]); } while (0); | |||
5353 | bufferlist bl(lens[i]); | |||
5354 | bl.append(vals[i], lens[i]); | |||
5355 | entries[keys[i]] = bl; | |||
5356 | } | |||
5357 | ((::ObjectOperation *)write_op)->omap_set(entries); | |||
5358 | tracepoint(librados, rados_write_op_omap_set_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_omap_set_exit .state) *)&(__tracepoint_librados___rados_write_op_omap_set_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_omap_set_exit (); } while (0); | |||
5359 | } | |||
5360 | ||||
5361 | extern "C" void rados_write_op_omap_rm_keys(rados_write_op_t write_op, | |||
5362 | char const* const* keys, | |||
5363 | size_t keys_len) | |||
5364 | { | |||
5365 | tracepoint(librados, rados_write_op_omap_rm_keys_enter, write_op, keys_len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_omap_rm_keys_enter .state) *)&(__tracepoint_librados___rados_write_op_omap_rm_keys_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_omap_rm_keys_enter (write_op, keys_len); } while (0); | |||
5366 | for(size_t i = 0; i < keys_len; i++) { | |||
5367 | tracepoint(librados, rados_write_op_omap_rm_keys_entry, keys[i])do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_omap_rm_keys_entry .state) *)&(__tracepoint_librados___rados_write_op_omap_rm_keys_entry .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_omap_rm_keys_entry (keys[i]); } while (0); | |||
5368 | } | |||
5369 | std::set<std::string> to_remove(keys, keys + keys_len); | |||
5370 | ((::ObjectOperation *)write_op)->omap_rm_keys(to_remove); | |||
5371 | tracepoint(librados, rados_write_op_omap_rm_keys_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_omap_rm_keys_exit .state) *)&(__tracepoint_librados___rados_write_op_omap_rm_keys_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_omap_rm_keys_exit (); } while (0); | |||
5372 | } | |||
5373 | ||||
5374 | extern "C" void rados_write_op_omap_clear(rados_write_op_t write_op) | |||
5375 | { | |||
5376 | tracepoint(librados, rados_write_op_omap_clear_enter, write_op)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_omap_clear_enter .state) *)&(__tracepoint_librados___rados_write_op_omap_clear_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_omap_clear_enter (write_op); } while (0); | |||
5377 | ((::ObjectOperation *)write_op)->omap_clear(); | |||
5378 | tracepoint(librados, rados_write_op_omap_clear_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_omap_clear_exit .state) *)&(__tracepoint_librados___rados_write_op_omap_clear_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_omap_clear_exit (); } while (0); | |||
5379 | } | |||
5380 | ||||
5381 | extern "C" void rados_write_op_set_alloc_hint(rados_write_op_t write_op, | |||
5382 | uint64_t expected_object_size, | |||
5383 | uint64_t expected_write_size) | |||
5384 | { | |||
5385 | tracepoint(librados, rados_write_op_set_alloc_hint_enter, write_op, expected_object_size, expected_write_size)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_set_alloc_hint_enter .state) *)&(__tracepoint_librados___rados_write_op_set_alloc_hint_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_set_alloc_hint_enter (write_op, expected_object_size, expected_write_size); } while (0); | |||
5386 | ((::ObjectOperation *)write_op)->set_alloc_hint(expected_object_size, | |||
5387 | expected_write_size, 0); | |||
5388 | tracepoint(librados, rados_write_op_set_alloc_hint_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_set_alloc_hint_exit .state) *)&(__tracepoint_librados___rados_write_op_set_alloc_hint_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_set_alloc_hint_exit (); } while (0); | |||
5389 | } | |||
5390 | ||||
5391 | extern "C" void rados_write_op_set_alloc_hint2(rados_write_op_t write_op, | |||
5392 | uint64_t expected_object_size, | |||
5393 | uint64_t expected_write_size, | |||
5394 | uint32_t flags) | |||
5395 | { | |||
5396 | tracepoint(librados, rados_write_op_set_alloc_hint2_enter, write_op, expected_object_size, expected_write_size, flags)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_set_alloc_hint2_enter .state) *)&(__tracepoint_librados___rados_write_op_set_alloc_hint2_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_set_alloc_hint2_enter (write_op, expected_object_size, expected_write_size, flags); } while (0); | |||
5397 | ((::ObjectOperation *)write_op)->set_alloc_hint(expected_object_size, | |||
5398 | expected_write_size, | |||
5399 | flags); | |||
5400 | tracepoint(librados, rados_write_op_set_alloc_hint2_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_set_alloc_hint2_exit .state) *)&(__tracepoint_librados___rados_write_op_set_alloc_hint2_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_set_alloc_hint2_exit (); } while (0); | |||
5401 | } | |||
5402 | ||||
5403 | extern "C" int rados_write_op_operate(rados_write_op_t write_op, | |||
5404 | rados_ioctx_t io, | |||
5405 | const char *oid, | |||
5406 | time_t *mtime, | |||
5407 | int flags) | |||
5408 | { | |||
5409 | tracepoint(librados, rados_write_op_operate_enter, write_op, io, oid, mtime, flags)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_operate_enter .state) *)&(__tracepoint_librados___rados_write_op_operate_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_operate_enter (write_op, io, oid, mtime, flags); } while (0); | |||
5410 | object_t obj(oid); | |||
5411 | ::ObjectOperation *oo = (::ObjectOperation *) write_op; | |||
5412 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
5413 | ||||
5414 | ceph::real_time *prt = NULL__null; | |||
5415 | ceph::real_time rt; | |||
5416 | ||||
5417 | if (mtime) { | |||
5418 | rt = ceph::real_clock::from_time_t(*mtime); | |||
5419 | prt = &rt; | |||
5420 | } | |||
5421 | ||||
5422 | int retval = ctx->operate(obj, oo, prt, translate_flags(flags)); | |||
5423 | tracepoint(librados, rados_write_op_operate_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_operate_exit .state) *)&(__tracepoint_librados___rados_write_op_operate_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_operate_exit (retval); } while (0); | |||
5424 | return retval; | |||
5425 | } | |||
5426 | ||||
5427 | extern "C" int rados_write_op_operate2(rados_write_op_t write_op, | |||
5428 | rados_ioctx_t io, | |||
5429 | const char *oid, | |||
5430 | struct timespec *ts, | |||
5431 | int flags) | |||
5432 | { | |||
5433 | tracepoint(librados, rados_write_op_operate2_enter, write_op, io, oid, ts, flags)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_operate2_enter .state) *)&(__tracepoint_librados___rados_write_op_operate2_enter .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_operate2_enter (write_op, io, oid, ts, flags); } while (0); | |||
5434 | object_t obj(oid); | |||
5435 | ::ObjectOperation *oo = (::ObjectOperation *) write_op; | |||
5436 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
5437 | ||||
5438 | ceph::real_time *prt = NULL__null; | |||
5439 | ceph::real_time rt; | |||
5440 | ||||
5441 | if (ts) { | |||
5442 | rt = ceph::real_clock::from_timespec(*ts); | |||
5443 | prt = &rt; | |||
5444 | } | |||
5445 | ||||
5446 | int retval = ctx->operate(obj, oo, prt, translate_flags(flags)); | |||
5447 | tracepoint(librados, rados_write_op_operate_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_write_op_operate_exit .state) *)&(__tracepoint_librados___rados_write_op_operate_exit .state)); })), 0)) __tracepoint_cb_librados___rados_write_op_operate_exit (retval); } while (0); | |||
5448 | return retval; | |||
5449 | } | |||
5450 | ||||
5451 | extern "C" int rados_aio_write_op_operate(rados_write_op_t write_op, | |||
5452 | rados_ioctx_t io, | |||
5453 | rados_completion_t completion, | |||
5454 | const char *oid, | |||
5455 | time_t *mtime, | |||
5456 | int flags) | |||
5457 | { | |||
5458 | tracepoint(librados, rados_aio_write_op_operate_enter, write_op, io, completion, oid, mtime, flags)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_write_op_operate_enter .state) *)&(__tracepoint_librados___rados_aio_write_op_operate_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_write_op_operate_enter (write_op, io, completion, oid, mtime, flags); } while (0); | |||
5459 | object_t obj(oid); | |||
5460 | ::ObjectOperation *oo = (::ObjectOperation *) write_op; | |||
5461 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
5462 | librados::AioCompletionImpl *c = (librados::AioCompletionImpl*)completion; | |||
5463 | int retval = ctx->aio_operate(obj, oo, c, ctx->snapc, translate_flags(flags)); | |||
5464 | tracepoint(librados, rados_aio_write_op_operate_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_write_op_operate_exit .state) *)&(__tracepoint_librados___rados_aio_write_op_operate_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_write_op_operate_exit (retval); } while (0); | |||
5465 | return retval; | |||
5466 | } | |||
5467 | ||||
5468 | extern "C" rados_read_op_t rados_create_read_op() | |||
5469 | { | |||
5470 | tracepoint(librados, rados_create_read_op_enter)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_create_read_op_enter .state) *)&(__tracepoint_librados___rados_create_read_op_enter .state)); })), 0)) __tracepoint_cb_librados___rados_create_read_op_enter (); } while (0); | |||
5471 | rados_read_op_t retval = new (std::nothrow)::ObjectOperation; | |||
5472 | tracepoint(librados, rados_create_read_op_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_create_read_op_exit .state) *)&(__tracepoint_librados___rados_create_read_op_exit .state)); })), 0)) __tracepoint_cb_librados___rados_create_read_op_exit (retval); } while (0); | |||
5473 | return retval; | |||
5474 | } | |||
5475 | ||||
5476 | extern "C" void rados_release_read_op(rados_read_op_t read_op) | |||
5477 | { | |||
5478 | tracepoint(librados, rados_release_read_op_enter, read_op)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_release_read_op_enter .state) *)&(__tracepoint_librados___rados_release_read_op_enter .state)); })), 0)) __tracepoint_cb_librados___rados_release_read_op_enter (read_op); } while (0); | |||
5479 | delete (::ObjectOperation *)read_op; | |||
5480 | tracepoint(librados, rados_release_read_op_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_release_read_op_exit .state) *)&(__tracepoint_librados___rados_release_read_op_exit .state)); })), 0)) __tracepoint_cb_librados___rados_release_read_op_exit (); } while (0); | |||
5481 | } | |||
5482 | ||||
5483 | extern "C" void rados_read_op_set_flags(rados_read_op_t read_op, int flags) | |||
5484 | { | |||
5485 | tracepoint(librados, rados_read_op_set_flags_enter, read_op, flags)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_set_flags_enter .state) *)&(__tracepoint_librados___rados_read_op_set_flags_enter .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_set_flags_enter (read_op, flags); } while (0); | |||
5486 | set_op_flags((::ObjectOperation *)read_op, flags); | |||
5487 | tracepoint(librados, rados_read_op_set_flags_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_set_flags_exit .state) *)&(__tracepoint_librados___rados_read_op_set_flags_exit .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_set_flags_exit (); } while (0); | |||
5488 | } | |||
5489 | ||||
5490 | extern "C" void rados_read_op_assert_version(rados_read_op_t read_op, uint64_t ver) | |||
5491 | { | |||
5492 | tracepoint(librados, rados_read_op_assert_version_enter, read_op, ver)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_assert_version_enter .state) *)&(__tracepoint_librados___rados_read_op_assert_version_enter .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_assert_version_enter (read_op, ver); } while (0); | |||
5493 | ((::ObjectOperation *)read_op)->assert_version(ver); | |||
5494 | tracepoint(librados, rados_read_op_assert_version_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_assert_version_exit .state) *)&(__tracepoint_librados___rados_read_op_assert_version_exit .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_assert_version_exit (); } while (0); | |||
5495 | } | |||
5496 | ||||
5497 | extern "C" void rados_read_op_assert_exists(rados_read_op_t read_op) | |||
5498 | { | |||
5499 | tracepoint(librados, rados_read_op_assert_exists_enter, read_op)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_assert_exists_enter .state) *)&(__tracepoint_librados___rados_read_op_assert_exists_enter .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_assert_exists_enter (read_op); } while (0); | |||
5500 | ((::ObjectOperation *)read_op)->stat(NULL__null, (ceph::real_time *)NULL__null, NULL__null); | |||
5501 | tracepoint(librados, rados_read_op_assert_exists_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_assert_exists_exit .state) *)&(__tracepoint_librados___rados_read_op_assert_exists_exit .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_assert_exists_exit (); } while (0); | |||
5502 | } | |||
5503 | ||||
5504 | extern "C" void rados_read_op_cmpxattr(rados_read_op_t read_op, | |||
5505 | const char *name, | |||
5506 | uint8_t comparison_operator, | |||
5507 | const char *value, | |||
5508 | size_t value_len) | |||
5509 | { | |||
5510 | tracepoint(librados, rados_read_op_cmpxattr_enter, read_op, name, comparison_operator, value, value_len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_cmpxattr_enter .state) *)&(__tracepoint_librados___rados_read_op_cmpxattr_enter .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_cmpxattr_enter (read_op, name, comparison_operator, value, value_len); } while (0); | |||
5511 | bufferlist bl; | |||
5512 | bl.append(value, value_len); | |||
5513 | ((::ObjectOperation *)read_op)->cmpxattr(name, | |||
5514 | comparison_operator, | |||
5515 | CEPH_OSD_CMPXATTR_MODE_STRING, | |||
5516 | bl); | |||
5517 | tracepoint(librados, rados_read_op_cmpxattr_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_cmpxattr_exit .state) *)&(__tracepoint_librados___rados_read_op_cmpxattr_exit .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_cmpxattr_exit (); } while (0); | |||
5518 | } | |||
5519 | ||||
5520 | extern "C" void rados_read_op_omap_cmp(rados_read_op_t read_op, | |||
5521 | const char *key, | |||
5522 | uint8_t comparison_operator, | |||
5523 | const char *val, | |||
5524 | size_t val_len, | |||
5525 | int *prval) | |||
5526 | { | |||
5527 | tracepoint(librados, rados_read_op_omap_cmp_enter, read_op, key, comparison_operator, val, val_len, prval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_omap_cmp_enter .state) *)&(__tracepoint_librados___rados_read_op_omap_cmp_enter .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_omap_cmp_enter (read_op, key, comparison_operator, val, val_len, prval); } while (0); | |||
5528 | rados_c_omap_cmp((::ObjectOperation *)read_op, key, comparison_operator, | |||
5529 | val, val_len, prval); | |||
5530 | tracepoint(librados, rados_read_op_omap_cmp_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_omap_cmp_exit .state) *)&(__tracepoint_librados___rados_read_op_omap_cmp_exit .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_omap_cmp_exit (); } while (0); | |||
5531 | } | |||
5532 | ||||
5533 | extern "C" void rados_read_op_stat(rados_read_op_t read_op, | |||
5534 | uint64_t *psize, | |||
5535 | time_t *pmtime, | |||
5536 | int *prval) | |||
5537 | { | |||
5538 | tracepoint(librados, rados_read_op_stat_enter, read_op, psize, pmtime, prval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_stat_enter .state) *)&(__tracepoint_librados___rados_read_op_stat_enter .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_stat_enter (read_op, psize, pmtime, prval); } while (0); | |||
5539 | ((::ObjectOperation *)read_op)->stat(psize, pmtime, prval); | |||
5540 | tracepoint(librados, rados_read_op_stat_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_stat_exit .state) *)&(__tracepoint_librados___rados_read_op_stat_exit .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_stat_exit (); } while (0); | |||
5541 | } | |||
5542 | ||||
5543 | class C_bl_to_buf : public Context { | |||
5544 | char *out_buf; | |||
5545 | size_t out_len; | |||
5546 | size_t *bytes_read; | |||
5547 | int *prval; | |||
5548 | public: | |||
5549 | bufferlist out_bl; | |||
5550 | C_bl_to_buf(char *out_buf, | |||
5551 | size_t out_len, | |||
5552 | size_t *bytes_read, | |||
5553 | int *prval) : out_buf(out_buf), out_len(out_len), | |||
5554 | bytes_read(bytes_read), prval(prval) {} | |||
5555 | void finish(int r) { | |||
5556 | if (out_bl.length() > out_len) { | |||
5557 | if (prval) | |||
5558 | *prval = -ERANGE34; | |||
5559 | if (bytes_read) | |||
5560 | *bytes_read = 0; | |||
5561 | return; | |||
5562 | } | |||
5563 | if (bytes_read) | |||
5564 | *bytes_read = out_bl.length(); | |||
5565 | if (out_buf && !out_bl.is_provided_buffer(out_buf)) | |||
5566 | out_bl.copy(0, out_bl.length(), out_buf); | |||
5567 | } | |||
5568 | }; | |||
5569 | ||||
5570 | extern "C" void rados_read_op_read(rados_read_op_t read_op, | |||
5571 | uint64_t offset, | |||
5572 | size_t len, | |||
5573 | char *buf, | |||
5574 | size_t *bytes_read, | |||
5575 | int *prval) | |||
5576 | { | |||
5577 | tracepoint(librados, rados_read_op_read_enter, read_op, offset, len, buf, bytes_read, prval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_read_enter .state) *)&(__tracepoint_librados___rados_read_op_read_enter .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_read_enter (read_op, offset, len, buf, bytes_read, prval); } while (0); | |||
5578 | C_bl_to_buf *ctx = new C_bl_to_buf(buf, len, bytes_read, prval); | |||
5579 | ctx->out_bl.push_back(buffer::create_static(len, buf)); | |||
5580 | ((::ObjectOperation *)read_op)->read(offset, len, &ctx->out_bl, prval, ctx); | |||
5581 | tracepoint(librados, rados_read_op_read_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_read_exit .state) *)&(__tracepoint_librados___rados_read_op_read_exit .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_read_exit (); } while (0); | |||
5582 | } | |||
5583 | ||||
5584 | class C_out_buffer : public Context { | |||
5585 | char **out_buf; | |||
5586 | size_t *out_len; | |||
5587 | public: | |||
5588 | bufferlist out_bl; | |||
5589 | C_out_buffer(char **out_buf, size_t *out_len) : out_buf(out_buf), | |||
5590 | out_len(out_len) {} | |||
5591 | void finish(int r) { | |||
5592 | // ignore r since we don't know the meaning of return values | |||
5593 | // from custom class methods | |||
5594 | do_out_buffer(out_bl, out_buf, out_len); | |||
5595 | } | |||
5596 | }; | |||
5597 | ||||
5598 | extern "C" void rados_read_op_exec(rados_read_op_t read_op, | |||
5599 | const char *cls, | |||
5600 | const char *method, | |||
5601 | const char *in_buf, | |||
5602 | size_t in_len, | |||
5603 | char **out_buf, | |||
5604 | size_t *out_len, | |||
5605 | int *prval) | |||
5606 | { | |||
5607 | tracepoint(librados, rados_read_op_exec_enter, read_op, cls, method, in_buf, in_len, out_buf, out_len, prval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_exec_enter .state) *)&(__tracepoint_librados___rados_read_op_exec_enter .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_exec_enter (read_op, cls, method, in_buf, in_len, out_buf, out_len, prval ); } while (0); | |||
5608 | bufferlist inbl; | |||
5609 | inbl.append(in_buf, in_len); | |||
5610 | C_out_buffer *ctx = new C_out_buffer(out_buf, out_len); | |||
5611 | ((::ObjectOperation *)read_op)->call(cls, method, inbl, &ctx->out_bl, ctx, | |||
5612 | prval); | |||
5613 | tracepoint(librados, rados_read_op_exec_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_exec_exit .state) *)&(__tracepoint_librados___rados_read_op_exec_exit .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_exec_exit (); } while (0); | |||
5614 | } | |||
5615 | ||||
5616 | extern "C" void rados_read_op_exec_user_buf(rados_read_op_t read_op, | |||
5617 | const char *cls, | |||
5618 | const char *method, | |||
5619 | const char *in_buf, | |||
5620 | size_t in_len, | |||
5621 | char *out_buf, | |||
5622 | size_t out_len, | |||
5623 | size_t *used_len, | |||
5624 | int *prval) | |||
5625 | { | |||
5626 | tracepoint(librados, rados_read_op_exec_user_buf_enter, read_op, cls, method, in_buf, in_len, out_buf, out_len, used_len, prval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_exec_user_buf_enter .state) *)&(__tracepoint_librados___rados_read_op_exec_user_buf_enter .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_exec_user_buf_enter (read_op, cls, method, in_buf, in_len, out_buf, out_len, used_len , prval); } while (0); | |||
5627 | C_bl_to_buf *ctx = new C_bl_to_buf(out_buf, out_len, used_len, prval); | |||
5628 | bufferlist inbl; | |||
5629 | inbl.append(in_buf, in_len); | |||
5630 | ((::ObjectOperation *)read_op)->call(cls, method, inbl, &ctx->out_bl, ctx, | |||
5631 | prval); | |||
5632 | tracepoint(librados, rados_read_op_exec_user_buf_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_exec_user_buf_exit .state) *)&(__tracepoint_librados___rados_read_op_exec_user_buf_exit .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_exec_user_buf_exit (); } while (0); | |||
5633 | } | |||
5634 | ||||
5635 | struct RadosOmapIter { | |||
5636 | std::map<std::string, bufferlist> values; | |||
5637 | std::map<std::string, bufferlist>::iterator i; | |||
5638 | }; | |||
5639 | ||||
5640 | class C_OmapIter : public Context { | |||
5641 | RadosOmapIter *iter; | |||
5642 | public: | |||
5643 | explicit C_OmapIter(RadosOmapIter *iter) : iter(iter) {} | |||
5644 | void finish(int r) { | |||
5645 | iter->i = iter->values.begin(); | |||
5646 | } | |||
5647 | }; | |||
5648 | ||||
5649 | class C_XattrsIter : public Context { | |||
5650 | librados::RadosXattrsIter *iter; | |||
5651 | public: | |||
5652 | explicit C_XattrsIter(librados::RadosXattrsIter *iter) : iter(iter) {} | |||
5653 | void finish(int r) { | |||
5654 | iter->i = iter->attrset.begin(); | |||
5655 | } | |||
5656 | }; | |||
5657 | ||||
5658 | extern "C" void rados_read_op_getxattrs(rados_read_op_t read_op, | |||
5659 | rados_xattrs_iter_t *iter, | |||
5660 | int *prval) | |||
5661 | { | |||
5662 | tracepoint(librados, rados_read_op_getxattrs_enter, read_op, prval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_getxattrs_enter .state) *)&(__tracepoint_librados___rados_read_op_getxattrs_enter .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_getxattrs_enter (read_op, prval); } while (0); | |||
5663 | librados::RadosXattrsIter *xattrs_iter = new librados::RadosXattrsIter; | |||
5664 | ((::ObjectOperation *)read_op)->getxattrs(&xattrs_iter->attrset, prval); | |||
5665 | ((::ObjectOperation *)read_op)->add_handler(new C_XattrsIter(xattrs_iter)); | |||
5666 | *iter = xattrs_iter; | |||
5667 | tracepoint(librados, rados_read_op_getxattrs_exit, *iter)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_getxattrs_exit .state) *)&(__tracepoint_librados___rados_read_op_getxattrs_exit .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_getxattrs_exit (*iter); } while (0); | |||
5668 | } | |||
5669 | ||||
5670 | extern "C" void rados_read_op_omap_get_vals(rados_read_op_t read_op, | |||
5671 | const char *start_after, | |||
5672 | const char *filter_prefix, | |||
5673 | uint64_t max_return, | |||
5674 | rados_omap_iter_t *iter, | |||
5675 | int *prval) | |||
5676 | { | |||
5677 | tracepoint(librados, rados_read_op_omap_get_vals_enter, read_op, start_after, filter_prefix, max_return, prval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_omap_get_vals_enter .state) *)&(__tracepoint_librados___rados_read_op_omap_get_vals_enter .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_omap_get_vals_enter (read_op, start_after, filter_prefix, max_return, prval); } while (0); | |||
5678 | RadosOmapIter *omap_iter = new RadosOmapIter; | |||
5679 | const char *start = start_after ? start_after : ""; | |||
5680 | const char *filter = filter_prefix ? filter_prefix : ""; | |||
5681 | ((::ObjectOperation *)read_op)->omap_get_vals(start, | |||
5682 | filter, | |||
5683 | max_return, | |||
5684 | &omap_iter->values, | |||
5685 | prval); | |||
5686 | ((::ObjectOperation *)read_op)->add_handler(new C_OmapIter(omap_iter)); | |||
5687 | *iter = omap_iter; | |||
5688 | tracepoint(librados, rados_read_op_omap_get_vals_exit, *iter)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_omap_get_vals_exit .state) *)&(__tracepoint_librados___rados_read_op_omap_get_vals_exit .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_omap_get_vals_exit (*iter); } while (0); | |||
5689 | } | |||
5690 | ||||
5691 | struct C_OmapKeysIter : public Context { | |||
5692 | RadosOmapIter *iter; | |||
5693 | std::set<std::string> keys; | |||
5694 | explicit C_OmapKeysIter(RadosOmapIter *iter) : iter(iter) {} | |||
5695 | void finish(int r) { | |||
5696 | // map each key to an empty bl | |||
5697 | for (std::set<std::string>::const_iterator i = keys.begin(); | |||
5698 | i != keys.end(); ++i) { | |||
5699 | iter->values[*i]; | |||
5700 | } | |||
5701 | iter->i = iter->values.begin(); | |||
5702 | } | |||
5703 | }; | |||
5704 | ||||
5705 | extern "C" void rados_read_op_omap_get_keys(rados_read_op_t read_op, | |||
5706 | const char *start_after, | |||
5707 | uint64_t max_return, | |||
5708 | rados_omap_iter_t *iter, | |||
5709 | int *prval) | |||
5710 | { | |||
5711 | tracepoint(librados, rados_read_op_omap_get_keys_enter, read_op, start_after, max_return, prval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_omap_get_keys_enter .state) *)&(__tracepoint_librados___rados_read_op_omap_get_keys_enter .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_omap_get_keys_enter (read_op, start_after, max_return, prval); } while (0); | |||
5712 | RadosOmapIter *omap_iter = new RadosOmapIter; | |||
5713 | C_OmapKeysIter *ctx = new C_OmapKeysIter(omap_iter); | |||
5714 | ((::ObjectOperation *)read_op)->omap_get_keys(start_after ? start_after : "", | |||
5715 | max_return, &ctx->keys, prval); | |||
5716 | ((::ObjectOperation *)read_op)->add_handler(ctx); | |||
5717 | *iter = omap_iter; | |||
5718 | tracepoint(librados, rados_read_op_omap_get_keys_exit, *iter)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_omap_get_keys_exit .state) *)&(__tracepoint_librados___rados_read_op_omap_get_keys_exit .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_omap_get_keys_exit (*iter); } while (0); | |||
5719 | } | |||
5720 | ||||
5721 | extern "C" void rados_read_op_omap_get_vals_by_keys(rados_read_op_t read_op, | |||
5722 | char const* const* keys, | |||
5723 | size_t keys_len, | |||
5724 | rados_omap_iter_t *iter, | |||
5725 | int *prval) | |||
5726 | { | |||
5727 | tracepoint(librados, rados_read_op_omap_get_vals_by_keys_enter, read_op, keys, keys_len, iter, prval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_omap_get_vals_by_keys_enter .state) *)&(__tracepoint_librados___rados_read_op_omap_get_vals_by_keys_enter .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_omap_get_vals_by_keys_enter (read_op, keys, keys_len, iter, prval); } while (0); | |||
5728 | std::set<std::string> to_get(keys, keys + keys_len); | |||
5729 | ||||
5730 | RadosOmapIter *omap_iter = new RadosOmapIter; | |||
5731 | ((::ObjectOperation *)read_op)->omap_get_vals_by_keys(to_get, | |||
5732 | &omap_iter->values, | |||
5733 | prval); | |||
5734 | ((::ObjectOperation *)read_op)->add_handler(new C_OmapIter(omap_iter)); | |||
5735 | *iter = omap_iter; | |||
5736 | tracepoint(librados, rados_read_op_omap_get_vals_by_keys_exit, *iter)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_omap_get_vals_by_keys_exit .state) *)&(__tracepoint_librados___rados_read_op_omap_get_vals_by_keys_exit .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_omap_get_vals_by_keys_exit (*iter); } while (0); | |||
5737 | } | |||
5738 | ||||
5739 | extern "C" int rados_omap_get_next(rados_omap_iter_t iter, | |||
5740 | char **key, | |||
5741 | char **val, | |||
5742 | size_t *len) | |||
5743 | { | |||
5744 | tracepoint(librados, rados_omap_get_next_enter, iter)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_omap_get_next_enter .state) *)&(__tracepoint_librados___rados_omap_get_next_enter .state)); })), 0)) __tracepoint_cb_librados___rados_omap_get_next_enter (iter); } while (0); | |||
5745 | RadosOmapIter *it = static_cast<RadosOmapIter *>(iter); | |||
5746 | if (it->i == it->values.end()) { | |||
5747 | *key = NULL__null; | |||
5748 | *val = NULL__null; | |||
5749 | *len = 0; | |||
5750 | tracepoint(librados, rados_omap_get_next_exit, 0, key, val, len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_omap_get_next_exit .state) *)&(__tracepoint_librados___rados_omap_get_next_exit .state)); })), 0)) __tracepoint_cb_librados___rados_omap_get_next_exit (0, key, val, len); } while (0); | |||
5751 | return 0; | |||
5752 | } | |||
5753 | if (key) | |||
5754 | *key = (char*)it->i->first.c_str(); | |||
5755 | if (val) | |||
5756 | *val = it->i->second.c_str(); | |||
5757 | if (len) | |||
5758 | *len = it->i->second.length(); | |||
5759 | ++it->i; | |||
5760 | tracepoint(librados, rados_omap_get_next_exit, 0, key, val, len)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_omap_get_next_exit .state) *)&(__tracepoint_librados___rados_omap_get_next_exit .state)); })), 0)) __tracepoint_cb_librados___rados_omap_get_next_exit (0, key, val, len); } while (0); | |||
5761 | return 0; | |||
5762 | } | |||
5763 | ||||
5764 | extern "C" void rados_omap_get_end(rados_omap_iter_t iter) | |||
5765 | { | |||
5766 | tracepoint(librados, rados_omap_get_end_enter, iter)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_omap_get_end_enter .state) *)&(__tracepoint_librados___rados_omap_get_end_enter .state)); })), 0)) __tracepoint_cb_librados___rados_omap_get_end_enter (iter); } while (0); | |||
5767 | RadosOmapIter *it = static_cast<RadosOmapIter *>(iter); | |||
5768 | delete it; | |||
5769 | tracepoint(librados, rados_omap_get_end_exit)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_omap_get_end_exit .state) *)&(__tracepoint_librados___rados_omap_get_end_exit .state)); })), 0)) __tracepoint_cb_librados___rados_omap_get_end_exit (); } while (0); | |||
5770 | } | |||
5771 | ||||
5772 | extern "C" int rados_read_op_operate(rados_read_op_t read_op, | |||
5773 | rados_ioctx_t io, | |||
5774 | const char *oid, | |||
5775 | int flags) | |||
5776 | { | |||
5777 | tracepoint(librados, rados_read_op_operate_enter, read_op, io, oid, flags)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_operate_enter .state) *)&(__tracepoint_librados___rados_read_op_operate_enter .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_operate_enter (read_op, io, oid, flags); } while (0); | |||
5778 | object_t obj(oid); | |||
5779 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
5780 | int retval = ctx->operate_read(obj, (::ObjectOperation *)read_op, NULL__null, | |||
5781 | translate_flags(flags)); | |||
5782 | tracepoint(librados, rados_read_op_operate_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_read_op_operate_exit .state) *)&(__tracepoint_librados___rados_read_op_operate_exit .state)); })), 0)) __tracepoint_cb_librados___rados_read_op_operate_exit (retval); } while (0); | |||
5783 | return retval; | |||
5784 | } | |||
5785 | ||||
5786 | extern "C" int rados_aio_read_op_operate(rados_read_op_t read_op, | |||
5787 | rados_ioctx_t io, | |||
5788 | rados_completion_t completion, | |||
5789 | const char *oid, | |||
5790 | int flags) | |||
5791 | { | |||
5792 | tracepoint(librados, rados_aio_read_op_operate_enter, read_op, io, completion, oid, flags)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_read_op_operate_enter .state) *)&(__tracepoint_librados___rados_aio_read_op_operate_enter .state)); })), 0)) __tracepoint_cb_librados___rados_aio_read_op_operate_enter (read_op, io, completion, oid, flags); } while (0); | |||
5793 | object_t obj(oid); | |||
5794 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
5795 | librados::AioCompletionImpl *c = (librados::AioCompletionImpl*)completion; | |||
5796 | int retval = ctx->aio_operate_read(obj, (::ObjectOperation *)read_op, | |||
5797 | c, translate_flags(flags), NULL__null); | |||
5798 | tracepoint(librados, rados_aio_read_op_operate_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_aio_read_op_operate_exit .state) *)&(__tracepoint_librados___rados_aio_read_op_operate_exit .state)); })), 0)) __tracepoint_cb_librados___rados_aio_read_op_operate_exit (retval); } while (0); | |||
5799 | return retval; | |||
5800 | } | |||
5801 | ||||
5802 | extern "C" int rados_cache_pin(rados_ioctx_t io, const char *o) | |||
5803 | { | |||
5804 | tracepoint(librados, rados_cache_pin_enter, io, o)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_cache_pin_enter .state) *)&(__tracepoint_librados___rados_cache_pin_enter .state)); })), 0)) __tracepoint_cb_librados___rados_cache_pin_enter (io, o); } while (0); | |||
5805 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
5806 | object_t oid(o); | |||
5807 | int retval = ctx->cache_pin(oid); | |||
5808 | tracepoint(librados, rados_cache_pin_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_cache_pin_exit .state) *)&(__tracepoint_librados___rados_cache_pin_exit. state)); })), 0)) __tracepoint_cb_librados___rados_cache_pin_exit (retval); } while (0); | |||
5809 | return retval; | |||
5810 | } | |||
5811 | ||||
5812 | extern "C" int rados_cache_unpin(rados_ioctx_t io, const char *o) | |||
5813 | { | |||
5814 | tracepoint(librados, rados_cache_unpin_enter, io, o)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_cache_unpin_enter .state) *)&(__tracepoint_librados___rados_cache_unpin_enter .state)); })), 0)) __tracepoint_cb_librados___rados_cache_unpin_enter (io, o); } while (0); | |||
5815 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
5816 | object_t oid(o); | |||
5817 | int retval = ctx->cache_unpin(oid); | |||
5818 | tracepoint(librados, rados_cache_unpin_exit, retval)do { ; if (__builtin_expect(!!(__extension__ ({ __asm__ __volatile__ ("" : : : "memory"); (*(__volatile__ __typeof__(__tracepoint_librados___rados_cache_unpin_exit .state) *)&(__tracepoint_librados___rados_cache_unpin_exit .state)); })), 0)) __tracepoint_cb_librados___rados_cache_unpin_exit (retval); } while (0); | |||
5819 | return retval; | |||
5820 | } | |||
5821 | ||||
5822 | ||||
5823 | ///////////////////////////// ListObject ////////////////////////////// | |||
5824 | librados::ListObject::ListObject() : impl(NULL__null) | |||
5825 | { | |||
5826 | } | |||
5827 | ||||
5828 | librados::ListObject::ListObject(librados::ListObjectImpl *i): impl(i) | |||
5829 | { | |||
5830 | } | |||
5831 | ||||
5832 | librados::ListObject::ListObject(const ListObject& rhs) | |||
5833 | { | |||
5834 | if (rhs.impl == NULL__null) { | |||
5835 | impl = NULL__null; | |||
5836 | return; | |||
5837 | } | |||
5838 | impl = new ListObjectImpl(); | |||
5839 | *impl = *(rhs.impl); | |||
5840 | } | |||
5841 | ||||
5842 | librados::ListObject& librados::ListObject::operator=(const ListObject& rhs) | |||
5843 | { | |||
5844 | if (rhs.impl == NULL__null) { | |||
5845 | delete impl; | |||
5846 | impl = NULL__null; | |||
5847 | return *this; | |||
5848 | } | |||
5849 | if (impl == NULL__null) | |||
5850 | impl = new ListObjectImpl(); | |||
5851 | *impl = *(rhs.impl); | |||
5852 | return *this; | |||
5853 | } | |||
5854 | ||||
5855 | librados::ListObject::~ListObject() | |||
5856 | { | |||
5857 | if (impl) | |||
5858 | delete impl; | |||
5859 | impl = NULL__null; | |||
5860 | } | |||
5861 | ||||
5862 | const std::string& librados::ListObject::get_nspace() const | |||
5863 | { | |||
5864 | return impl->get_nspace(); | |||
5865 | } | |||
5866 | ||||
5867 | const std::string& librados::ListObject::get_oid() const | |||
5868 | { | |||
5869 | return impl->get_oid(); | |||
5870 | } | |||
5871 | ||||
5872 | const std::string& librados::ListObject::get_locator() const | |||
5873 | { | |||
5874 | return impl->get_locator(); | |||
5875 | } | |||
5876 | ||||
5877 | std::ostream& librados::operator<<(std::ostream& out, const librados::ListObject& lop) | |||
5878 | { | |||
5879 | out << *(lop.impl); | |||
5880 | return out; | |||
5881 | } | |||
5882 | ||||
5883 | CEPH_RADOS_API__attribute__ ((visibility ("default"))) void rados_object_list_slice( | |||
5884 | rados_ioctx_t io, | |||
5885 | const rados_object_list_cursor start, | |||
5886 | const rados_object_list_cursor finish, | |||
5887 | const size_t n, | |||
5888 | const size_t m, | |||
5889 | rados_object_list_cursor *split_start, | |||
5890 | rados_object_list_cursor *split_finish) | |||
5891 | { | |||
5892 | librados::IoCtxImpl *ctx = (librados::IoCtxImpl *)io; | |||
5893 | ||||
5894 | assert(split_start)((split_start) ? static_cast<void> (0) : __ceph_assert_fail ("split_start", "/home/brad/working/src/ceph/src/librados/librados.cc" , 5894, __PRETTY_FUNCTION__)); | |||
5895 | assert(split_finish)((split_finish) ? static_cast<void> (0) : __ceph_assert_fail ("split_finish", "/home/brad/working/src/ceph/src/librados/librados.cc" , 5895, __PRETTY_FUNCTION__)); | |||
5896 | hobject_t *split_start_hobj = (hobject_t*)(*split_start); | |||
5897 | hobject_t *split_finish_hobj = (hobject_t*)(*split_finish); | |||
5898 | assert(split_start_hobj)((split_start_hobj) ? static_cast<void> (0) : __ceph_assert_fail ("split_start_hobj", "/home/brad/working/src/ceph/src/librados/librados.cc" , 5898, __PRETTY_FUNCTION__)); | |||
5899 | assert(split_finish_hobj)((split_finish_hobj) ? static_cast<void> (0) : __ceph_assert_fail ("split_finish_hobj", "/home/brad/working/src/ceph/src/librados/librados.cc" , 5899, __PRETTY_FUNCTION__)); | |||
5900 | hobject_t *start_hobj = (hobject_t*)(start); | |||
5901 | hobject_t *finish_hobj = (hobject_t*)(finish); | |||
5902 | ||||
5903 | ctx->object_list_slice( | |||
5904 | *start_hobj, | |||
5905 | *finish_hobj, | |||
5906 | n, | |||
5907 | m, | |||
5908 | split_start_hobj, | |||
5909 | split_finish_hobj); | |||
5910 | } | |||
5911 | ||||
5912 | librados::ObjectCursor::ObjectCursor() | |||
5913 | { | |||
5914 | c_cursor = new hobject_t(); | |||
5915 | } | |||
5916 | ||||
5917 | librados::ObjectCursor::~ObjectCursor() | |||
5918 | { | |||
5919 | hobject_t *h = (hobject_t *)c_cursor; | |||
5920 | delete h; | |||
5921 | } | |||
5922 | ||||
5923 | bool librados::ObjectCursor::operator<(const librados::ObjectCursor &rhs) | |||
5924 | { | |||
5925 | const hobject_t lhs_hobj = (c_cursor == nullptr) ? hobject_t() : *((hobject_t*)c_cursor); | |||
5926 | const hobject_t rhs_hobj = (rhs.c_cursor == nullptr) ? hobject_t() : *((hobject_t*)(rhs.c_cursor)); | |||
5927 | return cmp_bitwise(lhs_hobj, rhs_hobj) == -1; | |||
5928 | } | |||
5929 | ||||
5930 | librados::ObjectCursor::ObjectCursor(const librados::ObjectCursor &rhs) | |||
5931 | { | |||
5932 | if (rhs.c_cursor != nullptr) { | |||
5933 | hobject_t *h = (hobject_t*)rhs.c_cursor; | |||
5934 | c_cursor = (rados_object_list_cursor)(new hobject_t(*h)); | |||
5935 | } else { | |||
5936 | c_cursor = nullptr; | |||
5937 | } | |||
5938 | } | |||
5939 | ||||
5940 | librados::ObjectCursor librados::IoCtx::object_list_begin() | |||
5941 | { | |||
5942 | hobject_t *h = new hobject_t(io_ctx_impl->objecter->enumerate_objects_begin()); | |||
5943 | ObjectCursor oc; | |||
| ||||
5944 | oc.c_cursor = (rados_object_list_cursor)h; | |||
5945 | return oc; | |||
| ||||
5946 | } | |||
5947 | ||||
5948 | ||||
5949 | librados::ObjectCursor librados::IoCtx::object_list_end() | |||
5950 | { | |||
5951 | hobject_t *h = new hobject_t(io_ctx_impl->objecter->enumerate_objects_end()); | |||
5952 | librados::ObjectCursor oc; | |||
5953 | oc.c_cursor = (rados_object_list_cursor)h; | |||
5954 | return oc; | |||
5955 | } | |||
5956 | ||||
5957 | ||||
5958 | void librados::ObjectCursor::set(rados_object_list_cursor c) | |||
5959 | { | |||
5960 | delete (hobject_t*)c_cursor; | |||
5961 | c_cursor = c; | |||
5962 | } | |||
5963 | ||||
5964 | bool librados::IoCtx::object_list_is_end(const ObjectCursor &oc) | |||
5965 | { | |||
5966 | hobject_t *h = (hobject_t *)oc.c_cursor; | |||
5967 | return h->is_max(); | |||
5968 | } | |||
5969 | ||||
5970 | int librados::IoCtx::object_list(const ObjectCursor &start, | |||
5971 | const ObjectCursor &finish, | |||
5972 | const size_t result_item_count, | |||
5973 | const bufferlist &filter, | |||
5974 | std::vector<ObjectItem> *result, | |||
5975 | ObjectCursor *next) | |||
5976 | { | |||
5977 | assert(result != nullptr)((result != nullptr) ? static_cast<void> (0) : __ceph_assert_fail ("result != nullptr", "/home/brad/working/src/ceph/src/librados/librados.cc" , 5977, __PRETTY_FUNCTION__)); | |||
5978 | assert(next != nullptr)((next != nullptr) ? static_cast<void> (0) : __ceph_assert_fail ("next != nullptr", "/home/brad/working/src/ceph/src/librados/librados.cc" , 5978, __PRETTY_FUNCTION__)); | |||
5979 | result->clear(); | |||
5980 | ||||
5981 | C_SaferCond cond; | |||
5982 | hobject_t next_hash; | |||
5983 | std::list<librados::ListObjectImpl> obj_result; | |||
5984 | io_ctx_impl->objecter->enumerate_objects( | |||
5985 | io_ctx_impl->poolid, | |||
5986 | io_ctx_impl->oloc.nspace, | |||
5987 | *((hobject_t*)start.c_cursor), | |||
5988 | *((hobject_t*)finish.c_cursor), | |||
5989 | result_item_count, | |||
5990 | filter, | |||
5991 | &obj_result, | |||
5992 | &next_hash, | |||
5993 | &cond); | |||
5994 | ||||
5995 | int r = cond.wait(); | |||
5996 | if (r < 0) { | |||
5997 | next->set((rados_object_list_cursor)(new hobject_t(hobject_t::get_max()))); | |||
5998 | return r; | |||
5999 | } | |||
6000 | ||||
6001 | next->set((rados_object_list_cursor)(new hobject_t(next_hash))); | |||
6002 | ||||
6003 | for (std::list<librados::ListObjectImpl>::iterator i = obj_result.begin(); | |||
6004 | i != obj_result.end(); ++i) { | |||
6005 | ObjectItem oi; | |||
6006 | oi.oid = i->oid; | |||
6007 | oi.nspace = i->nspace; | |||
6008 | oi.locator = i->locator; | |||
6009 | result->push_back(oi); | |||
6010 | } | |||
6011 | ||||
6012 | return obj_result.size(); | |||
6013 | } | |||
6014 | ||||
6015 | void librados::IoCtx::object_list_slice( | |||
6016 | const ObjectCursor start, | |||
6017 | const ObjectCursor finish, | |||
6018 | const size_t n, | |||
6019 | const size_t m, | |||
6020 | ObjectCursor *split_start, | |||
6021 | ObjectCursor *split_finish) | |||
6022 | { | |||
6023 | assert(split_start != nullptr)((split_start != nullptr) ? static_cast<void> (0) : __ceph_assert_fail ("split_start != nullptr", "/home/brad/working/src/ceph/src/librados/librados.cc" , 6023, __PRETTY_FUNCTION__)); | |||
6024 | assert(split_finish != nullptr)((split_finish != nullptr) ? static_cast<void> (0) : __ceph_assert_fail ("split_finish != nullptr", "/home/brad/working/src/ceph/src/librados/librados.cc" , 6024, __PRETTY_FUNCTION__)); | |||
6025 | ||||
6026 | io_ctx_impl->object_list_slice( | |||
6027 | *((hobject_t*)(start.c_cursor)), | |||
6028 | *((hobject_t*)(finish.c_cursor)), | |||
6029 | n, | |||
6030 | m, | |||
6031 | (hobject_t*)(split_start->c_cursor), | |||
6032 | (hobject_t*)(split_finish->c_cursor)); | |||
6033 | } | |||
6034 |