Bug Summary

File:src/librados/librados.cc
Location:line 5945, column 10
Description:Potential leak of memory pointed to by 'oc.c_cursor'

Annotated Source Code

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
54using std::string;
55using std::map;
56using std::set;
57using std::vector;
58using std::list;
59using 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
67namespace {
68
69TracepointProvider::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
93namespace librados {
94
95struct ObjectOperationImpl {
96 ::ObjectOperation o;
97 real_time rt;
98 real_time *prt;
99
100 ObjectOperationImpl() : prt(NULL__null) {}
101};
102
103}
104
105size_t librados::ObjectOperation::size()
106{
107 ::ObjectOperation *o = &impl->o;
108 return o->size();
109}
110
111static 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
132void librados::ObjectOperation::set_op_flags(ObjectOperationFlags flags)
133{
134 ::set_op_flags(&impl->o, (int)flags);
135}
136
137void librados::ObjectOperation::set_op_flags2(int flags)
138{
139 ::ObjectOperation *o = &impl->o;
140 ::set_op_flags(o, flags);
141}
142
143void 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
149void 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
157void 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
165void 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
175void librados::ObjectOperation::assert_version(uint64_t ver)
176{
177 ::ObjectOperation *o = &impl->o;
178 o->assert_version(ver);
179}
180
181void librados::ObjectOperation::assert_exists()
182{
183 ::ObjectOperation *o = &impl->o;
184 o->stat(NULL__null, (ceph::real_time*) NULL__null, NULL__null);
185}
186
187void 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
193void 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
199class ObjectOpCompletionCtx : public Context {
200 librados::ObjectOperationCompletion *completion;
201 bufferlist bl;
202public:
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
214void 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
223void 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
229void 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
235void 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
241void 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
249void librados::ObjectReadOperation::tmap_get(bufferlist *pbl, int *prval)
250{
251 ::ObjectOperation *o = &impl->o;
252 o->tmap_get(pbl, prval);
253}
254
255void librados::ObjectReadOperation::getxattr(const char *name, bufferlist *pbl, int *prval)
256{
257 ::ObjectOperation *o = &impl->o;
258 o->getxattr(name, pbl, prval);
259}
260
261void 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
272void 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
282void 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
292void librados::ObjectReadOperation::omap_get_header(bufferlist *bl, int *prval)
293{
294 ::ObjectOperation *o = &impl->o;
295 o->omap_get_header(bl, prval);
296}
297
298void 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
307void 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
315void 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
323void 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
331void librados::ObjectReadOperation::is_dirty(bool *is_dirty, int *prval)
332{
333 ::ObjectOperation *o = &impl->o;
334 o->is_dirty(is_dirty, prval);
335}
336
337int 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
354void librados::ObjectReadOperation::getxattrs(map<string, bufferlist> *pattrs, int *prval)
355{
356 ::ObjectOperation *o = &impl->o;
357 o->getxattrs(pattrs, prval);
358}
359
360void 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
368void 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
376void librados::ObjectWriteOperation::create(bool exclusive)
377{
378 ::ObjectOperation *o = &impl->o;
379 o->create(exclusive);
380}
381
382void librados::ObjectWriteOperation::create(bool exclusive,
383 const std::string& category) // unused
384{
385 ::ObjectOperation *o = &impl->o;
386 o->create(exclusive);
387}
388
389void 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
396void librados::ObjectWriteOperation::write_full(const bufferlist& bl)
397{
398 ::ObjectOperation *o = &impl->o;
399 bufferlist c = bl;
400 o->write_full(c);
401}
402
403void 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
411void librados::ObjectWriteOperation::append(const bufferlist& bl)
412{
413 ::ObjectOperation *o = &impl->o;
414 bufferlist c = bl;
415 o->append(c);
416}
417
418void librados::ObjectWriteOperation::remove()
419{
420 ::ObjectOperation *o = &impl->o;
421 o->remove();
422}
423
424void librados::ObjectWriteOperation::truncate(uint64_t off)
425{
426 ::ObjectOperation *o = &impl->o;
427 o->truncate(off);
428}
429
430void librados::ObjectWriteOperation::zero(uint64_t off, uint64_t len)
431{
432 ::ObjectOperation *o = &impl->o;
433 o->zero(off, len);
434}
435
436void librados::ObjectWriteOperation::rmxattr(const char *name)
437{
438 ::ObjectOperation *o = &impl->o;
439 o->rmxattr(name);
440}
441
442void librados::ObjectWriteOperation::setxattr(const char *name, const bufferlist& v)
443{
444 ::ObjectOperation *o = &impl->o;
445 o->setxattr(name, v);
446}
447
448void librados::ObjectWriteOperation::omap_set(
449 const map<string, bufferlist> &map)
450{
451 ::ObjectOperation *o = &impl->o;
452 o->omap_set(map);
453}
454
455void 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
462void librados::ObjectWriteOperation::omap_clear()
463{
464 ::ObjectOperation *o = &impl->o;
465 o->omap_clear();
466}
467
468void 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
475void 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
482void 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
492void librados::ObjectWriteOperation::undirty()
493{
494 ::ObjectOperation *o = &impl->o;
495 o->undirty();
496}
497
498void librados::ObjectReadOperation::cache_flush()
499{
500 ::ObjectOperation *o = &impl->o;
501 o->cache_flush();
502}
503
504void librados::ObjectReadOperation::cache_try_flush()
505{
506 ::ObjectOperation *o = &impl->o;
507 o->cache_try_flush();
508}
509
510void librados::ObjectReadOperation::cache_evict()
511{
512 ::ObjectOperation *o = &impl->o;
513 o->cache_evict();
514}
515
516void librados::ObjectWriteOperation::tmap_put(const bufferlist &bl)
517{
518 ::ObjectOperation *o = &impl->o;
519 bufferlist c = bl;
520 o->tmap_put(c);
521}
522
523void librados::ObjectWriteOperation::tmap_update(const bufferlist& cmdbl)
524{
525 ::ObjectOperation *o = &impl->o;
526 bufferlist c = cmdbl;
527 o->tmap_update(c);
528}
529
530void 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
538void 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
545void librados::ObjectWriteOperation::snap_rollback(snap_t snapid)
546{
547 ::ObjectOperation *o = &impl->o;
548 o->rollback(snapid);
549}
550
551void 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}
558void 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
567void librados::ObjectWriteOperation::cache_pin()
568{
569 ::ObjectOperation *o = &impl->o;
570 o->cache_pin();
571}
572
573void librados::ObjectWriteOperation::cache_unpin()
574{
575 ::ObjectOperation *o = &impl->o;
576 o->cache_unpin();
577}
578
579librados::WatchCtx::
580~WatchCtx()
581{
582}
583
584librados::WatchCtx2::
585~WatchCtx2()
586{
587}
588
589
590struct 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 /////////////////////////////
619librados::NObjectIteratorImpl::NObjectIteratorImpl(ObjListCtx *ctx_)
620 : ctx(ctx_)
621{
622}
623
624librados::NObjectIteratorImpl::~NObjectIteratorImpl()
625{
626 ctx.reset();
627}
628
629librados::NObjectIteratorImpl::NObjectIteratorImpl(const NObjectIteratorImpl &rhs)
630{
631 *this = rhs;
632}
633
634librados::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
654bool 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
676bool librados::NObjectIteratorImpl::operator!=(const librados::NObjectIteratorImpl& rhs) const {
677 return !(*this == rhs);
678}
679
680const librados::ListObject& librados::NObjectIteratorImpl::operator*() const {
681 return cur_obj;
682}
683
684const librados::ListObject* librados::NObjectIteratorImpl::operator->() const {
685 return &cur_obj;
686}
687
688librados::NObjectIteratorImpl& librados::NObjectIteratorImpl::operator++()
689{
690 get_next();
691 return *this;
692}
693
694librados::NObjectIteratorImpl librados::NObjectIteratorImpl::operator++(int)
695{
696 librados::NObjectIteratorImpl ret(*this);
697 get_next();
698 return ret;
699}
700
701uint32_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
708void 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
720void 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
747uint32_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 /////////////////////////////
756librados::NObjectIterator::NObjectIterator(ObjListCtx *ctx_)
757{
758 impl = new NObjectIteratorImpl(ctx_);
759}
760
761librados::NObjectIterator::~NObjectIterator()
762{
763 delete impl;
764}
765
766librados::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
776librados::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
789bool 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
798bool librados::NObjectIterator::operator!=(const librados::NObjectIterator& rhs) const
799{
800 return !(*this == rhs);
801}
802
803const 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
808const 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
813librados::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
820librados::NObjectIterator librados::NObjectIterator::operator++(int)
821{
822 librados::NObjectIterator ret(*this);
823 impl->get_next();
824 return ret;
825}
826
827uint32_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
833void librados::NObjectIterator::set_filter(const bufferlist &bl)
834{
835 impl->set_filter(bl);
836}
837
838void 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
844uint32_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
850const librados::NObjectIterator librados::NObjectIterator::__EndObjectIterator(NULL__null);
851
852// DEPRECATED; Use NObjectIterator instead
853///////////////////////////// ObjectIterator /////////////////////////////
854librados::ObjectIterator::ObjectIterator(ObjListCtx *ctx_)
855 : ctx(ctx_)
856{
857}
858
859librados::ObjectIterator::~ObjectIterator()
860{
861 ctx.reset();
862}
863
864librados::ObjectIterator::ObjectIterator(const ObjectIterator &rhs)
865{
866 *this = rhs;
867}
868
869librados::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
883bool 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
891bool librados::ObjectIterator::operator!=(const librados::ObjectIterator& rhs) const {
892 return !(*this == rhs);
893}
894
895const pair<std::string, std::string>& librados::ObjectIterator::operator*() const {
896 return cur_obj;
897}
898
899const pair<std::string, std::string>* librados::ObjectIterator::operator->() const {
900 return &cur_obj;
901}
902
903librados::ObjectIterator& librados::ObjectIterator::operator++()
904{
905 get_next();
906 return *this;
907}
908
909librados::ObjectIterator librados::ObjectIterator::operator++(int)
910{
911 librados::ObjectIterator ret(*this);
912 get_next();
913 return ret;
914}
915
916uint32_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
923void 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
941uint32_t librados::ObjectIterator::get_pg_hash_position() const
942{
943 return ctx->lc->get_pg_hash_position();
944}
945
946const librados::ObjectIterator librados::ObjectIterator::__EndObjectIterator(NULL__null);
947
948///////////////////////////// PoolAsyncCompletion //////////////////////////////
949int 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
956int librados::PoolAsyncCompletion::PoolAsyncCompletion::wait()
957{
958 PoolAsyncCompletionImpl *c = (PoolAsyncCompletionImpl *)pc;
959 return c->wait();
960}
961
962bool librados::PoolAsyncCompletion::PoolAsyncCompletion::is_complete()
963{
964 PoolAsyncCompletionImpl *c = (PoolAsyncCompletionImpl *)pc;
965 return c->is_complete();
966}
967
968int librados::PoolAsyncCompletion::PoolAsyncCompletion::get_return_value()
969{
970 PoolAsyncCompletionImpl *c = (PoolAsyncCompletionImpl *)pc;
971 return c->get_return_value();
972}
973
974void librados::PoolAsyncCompletion::PoolAsyncCompletion::release()
975{
976 PoolAsyncCompletionImpl *c = (PoolAsyncCompletionImpl *)pc;
977 c->release();
978 delete this;
979}
980
981///////////////////////////// AioCompletion //////////////////////////////
982int 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
988int 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
994int librados::AioCompletion::AioCompletion::wait_for_complete()
995{
996 AioCompletionImpl *c = (AioCompletionImpl *)pc;
997 return c->wait_for_complete();
998}
999
1000int librados::AioCompletion::AioCompletion::wait_for_safe()
1001{
1002 AioCompletionImpl *c = (AioCompletionImpl *)pc;
1003 return c->wait_for_safe();
1004}
1005
1006bool librados::AioCompletion::AioCompletion::is_complete()
1007{
1008 AioCompletionImpl *c = (AioCompletionImpl *)pc;
1009 return c->is_complete();
1010}
1011
1012bool librados::AioCompletion::AioCompletion::is_safe()
1013{
1014 AioCompletionImpl *c = (AioCompletionImpl *)pc;
1015 return c->is_safe();
1016}
1017
1018int librados::AioCompletion::AioCompletion::wait_for_complete_and_cb()
1019{
1020 AioCompletionImpl *c = (AioCompletionImpl *)pc;
1021 return c->wait_for_complete_and_cb();
1022}
1023
1024int librados::AioCompletion::AioCompletion::wait_for_safe_and_cb()
1025{
1026 AioCompletionImpl *c = (AioCompletionImpl *)pc;
1027 return c->wait_for_safe_and_cb();
1028}
1029
1030bool librados::AioCompletion::AioCompletion::is_complete_and_cb()
1031{
1032 AioCompletionImpl *c = (AioCompletionImpl *)pc;
1033 return c->is_complete_and_cb();
1034}
1035
1036bool librados::AioCompletion::AioCompletion::is_safe_and_cb()
1037{
1038 AioCompletionImpl *c = (AioCompletionImpl *)pc;
1039 return c->is_safe_and_cb();
1040}
1041
1042int librados::AioCompletion::AioCompletion::get_return_value()
1043{
1044 AioCompletionImpl *c = (AioCompletionImpl *)pc;
1045 return c->get_return_value();
1046}
1047
1048int librados::AioCompletion::AioCompletion::get_version()
1049{
1050 AioCompletionImpl *c = (AioCompletionImpl *)pc;
1051 return c->get_version();
1052}
1053
1054uint64_t librados::AioCompletion::AioCompletion::get_version64()
1055{
1056 AioCompletionImpl *c = (AioCompletionImpl *)pc;
1057 return c->get_version();
1058}
1059
1060void librados::AioCompletion::AioCompletion::release()
1061{
1062 AioCompletionImpl *c = (AioCompletionImpl *)pc;
1063 c->release();
1064 delete this;
1065}
1066
1067///////////////////////////// IoCtx //////////////////////////////
1068librados::IoCtx::IoCtx() : io_ctx_impl(NULL__null)
1069{
1070}
1071
1072void 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
1082librados::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
1090librados::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
1099librados::IoCtx::~IoCtx()
1100{
1101 close();
1102}
1103
1104void librados::IoCtx::close()
1105{
1106 if (io_ctx_impl)
1107 io_ctx_impl->put();
1108 io_ctx_impl = 0;
1109}
1110
1111void 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
1120int librados::IoCtx::set_auid(uint64_t auid_)
1121{
1122 return io_ctx_impl->pool_change_auid(auid_);
1123}
1124
1125int 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
1130int librados::IoCtx::get_auid(uint64_t *auid_)
1131{
1132 return rados_ioctx_pool_get_auid(io_ctx_impl, auid_);
1133}
1134
1135bool librados::IoCtx::pool_requires_alignment()
1136{
1137 return io_ctx_impl->client->pool_requires_alignment(get_id());
1138}
1139
1140int librados::IoCtx::pool_requires_alignment2(bool *requires)
1141{
1142 return io_ctx_impl->client->pool_requires_alignment2(get_id(), requires);
1143}
1144
1145uint64_t librados::IoCtx::pool_required_alignment()
1146{
1147 return io_ctx_impl->client->pool_required_alignment(get_id());
1148}
1149
1150int librados::IoCtx::pool_required_alignment2(uint64_t *alignment)
1151{
1152 return io_ctx_impl->client->pool_required_alignment2(get_id(), alignment);
1153}
1154
1155std::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
1162std::string librados::IoCtx::get_pool_name() const
1163{
1164 return io_ctx_impl->get_cached_pool_name();
1165}
1166
1167uint64_t librados::IoCtx::get_instance_id() const
1168{
1169 return io_ctx_impl->client->get_instance_id();
1170}
1171
1172int 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
1178int 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
1185int 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
1191int 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
1197int 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
1203int 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
1210int 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
1218int 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
1224int librados::IoCtx::remove(const std::string& oid)
1225{
1226 object_t obj(oid);
1227 return io_ctx_impl->remove(obj);
1228}
1229
1230int 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
1236int 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
1242int 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
1249int 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
1256int 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
1262int 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
1268int 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
1274int 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
1280int 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
1286int 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
1292int 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
1299int 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
1305int 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
1311int 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
1317int 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
1323int 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
1339int 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
1355int 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
1369int 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
1384int 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
1392int 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
1400int librados::IoCtx::omap_clear(const std::string& oid)
1401{
1402 ObjectWriteOperation op;
1403 op.omap_clear();
1404 return operate(oid, &op);
1405}
1406
1407int 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
1417static 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
1440int 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
1446int 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
1452int 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}
1459int 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
1468int 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
1482int 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
1492int 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
1510int 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
1520void librados::IoCtx::snap_set_read(snap_t seq)
1521{
1522 io_ctx_impl->set_snap_read(seq);
1523}
1524
1525int 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
1534int librados::IoCtx::snap_create(const char *snapname)
1535{
1536 return io_ctx_impl->snap_create(snapname);
1537}
1538
1539int librados::IoCtx::snap_lookup(const char *name, snap_t *snapid)
1540{
1541 return io_ctx_impl->snap_lookup(name, snapid);
1542}
1543
1544int librados::IoCtx::snap_get_stamp(snap_t snapid, time_t *t)
1545{
1546 return io_ctx_impl->snap_get_stamp(snapid, t);
1547}
1548
1549int librados::IoCtx::snap_get_name(snap_t snapid, std::string *s)
1550{
1551 return io_ctx_impl->snap_get_name(snapid, s);
1552}
1553
1554int librados::IoCtx::snap_remove(const char *snapname)
1555{
1556 return io_ctx_impl->snap_remove(snapname);
1557}
1558
1559int librados::IoCtx::snap_list(std::vector<snap_t> *snaps)
1560{
1561 return io_ctx_impl->snap_list(snaps);
1562}
1563
1564int 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
1570int librados::IoCtx::rollback(const std::string& oid, const char *snapname)
1571{
1572 return snap_rollback(oid, snapname);
1573}
1574
1575int librados::IoCtx::selfmanaged_snap_create(uint64_t *snapid)
1576{
1577 return io_ctx_impl->selfmanaged_snap_create(snapid);
1578}
1579
1580int librados::IoCtx::selfmanaged_snap_remove(uint64_t snapid)
1581{
1582 return io_ctx_impl->selfmanaged_snap_remove(snapid);
1583}
1584
1585int 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
1592int 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
1605int 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
1618int 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
1624struct 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
1640int 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
1646int 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
1655int 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
1691librados::NObjectIterator librados::IoCtx::nobjects_begin()
1692{
1693 bufferlist bl;
1694 return nobjects_begin(bl);
1695}
1696
1697librados::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
1710librados::NObjectIterator librados::IoCtx::nobjects_begin(uint32_t pos)
1711{
1712 bufferlist bl;
1713 return nobjects_begin(pos, bl);
1714}
1715
1716librados::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
1729const librados::NObjectIterator& librados::IoCtx::nobjects_end() const
1730{
1731 return NObjectIterator::__EndObjectIterator;
1732}
1733
1734// DEPRECATED; use n versions above
1735librados::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
1749librados::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
1763const librados::ObjectIterator& librados::IoCtx::objects_end() const
1764{
1765 return ObjectIterator::__EndObjectIterator;
1766}
1767
1768int 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
1774int 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
1782uint64_t librados::IoCtx::get_last_version()
1783{
1784 return io_ctx_impl->last_version();
1785}
1786
1787int 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
1794int 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
1801int 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
1810int 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
1819int 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
1827int 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
1833int 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
1839int 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
1846int 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
1854int librados::IoCtx::aio_remove(const std::string& oid, librados::AioCompletion *c)
1855{
1856 return io_ctx_impl->aio_remove(oid, c->pc);
1857}
1858
1859int 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
1864int librados::IoCtx::aio_flush_async(librados::AioCompletion *c)
1865{
1866 io_ctx_impl->flush_aio_writes_async(c->pc);
1867 return 0;
1868}
1869
1870int librados::IoCtx::aio_flush()
1871{
1872 io_ctx_impl->flush_aio_writes();
1873 return 0;
1874}
1875
1876struct AioGetxattrDataPP {
1877 AioGetxattrDataPP(librados::AioCompletionImpl *c, bufferlist *_bl) :
1878 bl(_bl), completion(c) {}
1879 bufferlist *bl;
1880 struct librados::C_AioCompleteAndSafe completion;
1881};
1882
1883static 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
1893int 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
1909int 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
1916int 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
1923int 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
1930int 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
1937int librados::IoCtx::aio_cancel(librados::AioCompletion *c)
1938{
1939 return io_ctx_impl->aio_cancel(c->pc);
1940}
1941
1942int 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
1949int 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
1956int 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
1963int 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
1971int 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
1980int librados::IoCtx::unwatch(const string& oid, uint64_t handle)
1981{
1982 return io_ctx_impl->unwatch(handle);
1983}
1984
1985int librados::IoCtx::unwatch2(uint64_t handle)
1986{
1987 return io_ctx_impl->unwatch(handle);
1988}
1989
1990int librados::IoCtx::aio_unwatch(uint64_t handle, AioCompletion *c)
1991{
1992 return io_ctx_impl->aio_unwatch(handle, c->pc);
1993}
1994
1995int librados::IoCtx::watch_check(uint64_t handle)
1996{
1997 return io_ctx_impl->watch_check(handle);
1998}
1999
2000int 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
2006int 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
2013int 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
2022void 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
2029int 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
2043int 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
2059void librados::IoCtx::set_notify_timeout(uint32_t timeout)
2060{
2061 io_ctx_impl->set_notify_timeout(timeout);
2062}
2063
2064int 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
2073int 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
2083void librados::IoCtx::set_assert_version(uint64_t ver)
2084{
2085 io_ctx_impl->set_assert_version(ver);
2086}
2087
2088void 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
2094int librados::IoCtx::cache_pin(const string& oid)
2095{
2096 object_t obj(oid);
2097 return io_ctx_impl->cache_pin(obj);
2098}
2099
2100int librados::IoCtx::cache_unpin(const string& oid)
2101{
2102 object_t obj(oid);
2103 return io_ctx_impl->cache_unpin(obj);
2104}
2105
2106void librados::IoCtx::locator_set_key(const string& key)
2107{
2108 io_ctx_impl->oloc.key = key;
2109}
2110
2111void librados::IoCtx::set_namespace(const string& nspace)
2112{
2113 io_ctx_impl->oloc.nspace = nspace;
2114}
2115
2116int64_t librados::IoCtx::get_id()
2117{
2118 return io_ctx_impl->get_id();
2119}
2120
2121uint32_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
2130uint32_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
2139int 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
2145int 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
2151librados::config_t librados::IoCtx::cct()
2152{
2153 return (config_t)io_ctx_impl->client->cct;
2154}
2155
2156librados::IoCtx::IoCtx(IoCtxImpl *io_ctx_impl_)
2157 : io_ctx_impl(io_ctx_impl_)
2158{
2159}
2160
2161///////////////////////////// Rados //////////////////////////////
2162void librados::Rados::version(int *major, int *minor, int *extra)
2163{
2164 rados_version(major, minor, extra);
2165}
2166
2167librados::Rados::Rados() : client(NULL__null)
2168{
2169}
2170
2171librados::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
2178librados::Rados::~Rados()
2179{
2180 shutdown();
2181}
2182
2183int librados::Rados::init(const char * const id)
2184{
2185 return rados_create((rados_t *)&client, id);
2186}
2187
2188int 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
2194int librados::Rados::init_with_context(config_t cct_)
2195{
2196 return rados_create_with_context((rados_t *)&client, (rados_config_t)cct_);
2197}
2198
2199int librados::Rados::connect()
2200{
2201 return client->connect();
2202}
2203
2204librados::config_t librados::Rados::cct()
2205{
2206 return (config_t)client->cct;
2207}
2208
2209int librados::Rados::watch_flush()
2210{
2211 if (!client)
2212 return -EINVAL22;
2213 return client->watch_flush();
2214}
2215
2216int librados::Rados::aio_watch_flush(AioCompletion *c)
2217{
2218 if (!client)
2219 return -EINVAL22;
2220 return client->async_watch_flush(c->pc);
2221}
2222
2223void 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
2234uint64_t librados::Rados::get_instance_id()
2235{
2236 return client->get_instance_id();
2237}
2238
2239int librados::Rados::conf_read_file(const char * const path) const
2240{
2241 return rados_conf_read_file((rados_t)client, path);
2242}
2243
2244int 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
2249int 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
2255int librados::Rados::conf_parse_env(const char *name) const
2256{
2257 return rados_conf_parse_env((rados_t)client, name);
2258}
2259
2260int librados::Rados::conf_set(const char *option, const char *value)
2261{
2262 return rados_conf_set((rados_t)client, option, value);
2263}
2264
2265int 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
2279int librados::Rados::pool_create(const char *name)
2280{
2281 string str(name);
2282 return client->pool_create(str);
2283}
2284
2285int librados::Rados::pool_create(const char *name, uint64_t auid)
2286{
2287 string str(name);
2288 return client->pool_create(str, auid);
2289}
2290
2291int 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
2297int 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
2303int 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
2309int 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
2316int 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
2324int librados::Rados::pool_delete(const char *name)
2325{
2326 return client->pool_delete(name);
2327}
2328
2329int librados::Rados::pool_delete_async(const char *name, PoolAsyncCompletion *c)
2330{
2331 return client->pool_delete_async(name, c->pc);
2332}
2333
2334int 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
2350int librados::Rados::pool_list2(std::list<std::pair<int64_t, std::string> >& v)
2351{
2352 return client->pool_list(v);
2353}
2354
2355int64_t librados::Rados::pool_lookup(const char *name)
2356{
2357 return client->lookup_pool(name);
2358}
2359
2360int librados::Rados::pool_reverse_lookup(int64_t id, std::string *name)
2361{
2362 return client->pool_get_name(id, name);
2363}
2364
2365int 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
2373int 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
2381int 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
2391int 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
2404int 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
2415int 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
2426void librados::Rados::test_blacklist_self(bool set)
2427{
2428 client->blacklist_self(set);
2429}
2430
2431int 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
2457int 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
2472int 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
2479bool 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
2484int 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
2495int librados::Rados::cluster_fsid(string *fsid)
2496{
2497 return client->get_fsid(fsid);
2498}
2499
2500namespace 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
2524std::ostream& librados::operator<<(std::ostream& out,
2525 const librados::PlacementGroup& pg)
2526{
2527 return out << pg.impl->pgid;
2528}
2529
2530namespace {
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
2585int 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
2591int 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
2613int 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
2635int librados::Rados::wait_for_latest_osdmap()
2636{
2637 return client->wait_for_latest_osdmap();
2638}
2639
2640int 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
2646librados::PoolAsyncCompletion *librados::Rados::pool_async_create_completion()
2647{
2648 PoolAsyncCompletionImpl *c = new PoolAsyncCompletionImpl;
2649 return new PoolAsyncCompletion(c);
2650}
2651
2652librados::AioCompletion *librados::Rados::aio_create_completion()
2653{
2654 AioCompletionImpl *c = new AioCompletionImpl;
2655 return new AioCompletion(c);
2656}
2657
2658librados::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
2668librados::ObjectOperation::ObjectOperation()
2669{
2670 impl = new ObjectOperationImpl;
2671}
2672
2673librados::ObjectOperation::~ObjectOperation()
2674{
2675 delete impl;
2676}
2677
2678///////////////////////////// C API //////////////////////////////
2679
2680static 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
2695extern "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
2717extern "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 */
2742extern "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
2754extern "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
2763extern "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
2772extern "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
2781extern "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
2790extern "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 --
2804extern "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
2822extern "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
2848extern "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
2880extern "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
2897extern "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 */
2913extern "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
2928extern "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
2939extern "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
2948extern "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
2969extern "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
2986extern "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
2995extern "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
3002extern "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
3045CEPH_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
3084static 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
3098static 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
3112extern "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
3132extern "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
3159extern "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
3202extern "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
3229extern "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
3259extern "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
3290extern "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
3298extern "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
3307extern "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
3325extern "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
3344extern "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
3352extern "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
3392extern "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
3401extern "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
3409extern "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
3424extern "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
3438extern "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
3452extern "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
3466extern "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
3483extern "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
3494extern "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
3504extern "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
3514extern "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
3540extern "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
3549extern "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
3559extern "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
3570extern "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
3581extern "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
3592extern "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
3601extern "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
3610extern "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
3619extern "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
3628extern "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
3637extern "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
3652extern "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
3661extern "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
3673extern "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
3684extern "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
3695extern "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
3704extern "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
3713extern "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
3736extern "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
3745extern "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
3754extern "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
3765extern "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
3771extern "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
3781extern "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
3791extern "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
3802extern "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
3826extern "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
3836extern "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
3857extern "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
3866extern "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
3890extern "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
3916extern "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
3951extern "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
3959extern "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
3971extern "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
3981extern "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
3991extern "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
4003extern "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
4015extern "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
4036extern "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
4046extern "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
4070extern "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
4078extern "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
4086extern "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
4093extern "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
4100extern "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
4110extern "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
4171extern "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
4186extern "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
4205extern "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
4213extern "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
4228extern "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
4242extern "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
4258extern "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
4266extern "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
4276extern "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
4286extern "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
4332extern "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
4376extern "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
4392extern "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
4400extern "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
4408extern "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
4416extern "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
4424extern "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
4432extern "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
4440extern "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
4448extern "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
4456extern "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
4464extern "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
4472extern "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
4479extern "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
4492extern "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
4509extern "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
4526extern "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
4542extern "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
4559extern "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
4570extern "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
4580extern "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
4589struct 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
4598static 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
4614extern "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
4637struct 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
4650static 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
4664extern "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
4686extern "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
4700extern "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
4712extern "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
4725extern "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
4731extern "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
4748struct 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
4757extern "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
4771struct 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
4790extern "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
4797extern "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
4818extern "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
4826extern "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
4851extern "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
4861extern "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
4871extern "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
4884extern "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
4894extern "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
4911extern "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
4931extern "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
4953extern "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
4971extern "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
4980extern "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
4990extern "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
5003extern "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
5017extern "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
5031extern "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}
5044extern "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
5056extern "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
5069extern "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
5136extern "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
5149extern "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
5157extern "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
5164extern "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
5171extern "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
5178extern "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
5185extern "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
5201static 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
5215extern "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
5228extern "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
5240extern "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
5248extern "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
5258extern "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
5270extern "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
5281extern "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
5294extern "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
5305extern "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
5312extern "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
5320extern "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
5329extern "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
5343extern "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
5361extern "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
5374extern "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
5381extern "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
5391extern "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
5403extern "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
5427extern "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
5451extern "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
5468extern "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
5476extern "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
5483extern "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
5490extern "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
5497extern "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
5504extern "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
5520extern "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
5533extern "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
5543class C_bl_to_buf : public Context {
5544 char *out_buf;
5545 size_t out_len;
5546 size_t *bytes_read;
5547 int *prval;
5548public:
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
5570extern "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
5584class C_out_buffer : public Context {
5585 char **out_buf;
5586 size_t *out_len;
5587public:
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
5598extern "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
5616extern "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
5635struct RadosOmapIter {
5636 std::map<std::string, bufferlist> values;
5637 std::map<std::string, bufferlist>::iterator i;
5638};
5639
5640class C_OmapIter : public Context {
5641 RadosOmapIter *iter;
5642public:
5643 explicit C_OmapIter(RadosOmapIter *iter) : iter(iter) {}
5644 void finish(int r) {
5645 iter->i = iter->values.begin();
5646 }
5647};
5648
5649class C_XattrsIter : public Context {
5650 librados::RadosXattrsIter *iter;
5651public:
5652 explicit C_XattrsIter(librados::RadosXattrsIter *iter) : iter(iter) {}
5653 void finish(int r) {
5654 iter->i = iter->attrset.begin();
5655 }
5656};
5657
5658extern "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
5670extern "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
5691struct 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
5705extern "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
5721extern "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
5739extern "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
5764extern "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
5772extern "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
5786extern "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
5802extern "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
5812extern "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 //////////////////////////////
5824librados::ListObject::ListObject() : impl(NULL__null)
5825{
5826}
5827
5828librados::ListObject::ListObject(librados::ListObjectImpl *i): impl(i)
5829{
5830}
5831
5832librados::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
5842librados::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
5855librados::ListObject::~ListObject()
5856{
5857 if (impl)
5858 delete impl;
5859 impl = NULL__null;
5860}
5861
5862const std::string& librados::ListObject::get_nspace() const
5863{
5864 return impl->get_nspace();
5865}
5866
5867const std::string& librados::ListObject::get_oid() const
5868{
5869 return impl->get_oid();
5870}
5871
5872const std::string& librados::ListObject::get_locator() const
5873{
5874 return impl->get_locator();
5875}
5876
5877std::ostream& librados::operator<<(std::ostream& out, const librados::ListObject& lop)
5878{
5879 out << *(lop.impl);
5880 return out;
5881}
5882
5883CEPH_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
5912librados::ObjectCursor::ObjectCursor()
5913{
5914 c_cursor = new hobject_t();
2
Memory is allocated
5915}
5916
5917librados::ObjectCursor::~ObjectCursor()
5918{
5919 hobject_t *h = (hobject_t *)c_cursor;
5920 delete h;
5921}
5922
5923bool 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
5930librados::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
5940librados::ObjectCursor librados::IoCtx::object_list_begin()
5941{
5942 hobject_t *h = new hobject_t(io_ctx_impl->objecter->enumerate_objects_begin());
5943 ObjectCursor oc;
1
Calling default constructor for 'ObjectCursor'
3
Returning from default constructor for 'ObjectCursor'
5944 oc.c_cursor = (rados_object_list_cursor)h;
5945 return oc;
4
Potential leak of memory pointed to by 'oc.c_cursor'
5946}
5947
5948
5949librados::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
5958void librados::ObjectCursor::set(rados_object_list_cursor c)
5959{
5960 delete (hobject_t*)c_cursor;
5961 c_cursor = c;
5962}
5963
5964bool 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
5970int 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
6015void 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