ceph/src/librados/IoCtxImpl.h

   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 #ifndef CEPH_LIBRADOS_IOCTXIMPL_H
  16 #define CEPH_LIBRADOS_IOCTXIMPL_H
  17
  18 #include <atomic>
  19
  20 #include "common/Cond.h"
  21 #include "common/ceph_mutex.h"
  22 #include "common/snap_types.h"
  23 #include "common/zipkin_trace.h"
  24 #include "include/types.h"
  25 #include "include/rados/librados.h"
  26 #include "include/rados/librados.hpp"
  27 #include "include/xlist.h"
  28 #include "osd/osd_types.h"
  29 #include "osdc/Objecter.h"
  30
  31 class RadosClient;
  32
  33 struct librados::IoCtxImpl {
  34   std::atomic<uint64_t> ref_cnt = { 0 };
  35   RadosClient *client = nullptr;
  36   int64_t poolid = 0;
  37   snapid_t snap_seq;
  38   ::SnapContext snapc;
  39   uint64_t assert_ver = 0;
  40   version_t last_objver = 0;
  41   uint32_t notify_timeout = 30;
  42   object_locator_t oloc;
  43   int extra_op_flags = 0;
  44
  45   ceph::mutex aio_write_list_lock =
  46     ceph::make_mutex("librados::IoCtxImpl::aio_write_list_lock");
  47   ceph_tid_t aio_write_seq = 0;
  48   ceph::condition_variable aio_write_cond;
  49   xlist<AioCompletionImpl*> aio_write_list;
  50   map<ceph_tid_t, std::list<AioCompletionImpl*> > aio_write_waiters;
  51
  52   Objecter *objecter = nullptr;
  53
  54   IoCtxImpl();
  55   IoCtxImpl(RadosClient *c, Objecter *objecter,
  56             int64_t poolid, snapid_t s);
  57
  58   void dup(const IoCtxImpl& rhs) {
  59     // Copy everything except the ref count
  60     client = rhs.client;
  61     poolid = rhs.poolid;
  62     snap_seq = rhs.snap_seq;
  63     snapc = rhs.snapc;
  64     assert_ver = rhs.assert_ver;
  65     last_objver = rhs.last_objver;
  66     notify_timeout = rhs.notify_timeout;
  67     oloc = rhs.oloc;
  68     objecter = rhs.objecter;
  69   }
  70
  71   void set_snap_read(snapid_t s);
  72   int set_snap_write_context(snapid_t seq, vector<snapid_t>& snaps);
  73
  74   void get() {
  75     ref_cnt++;
  76   }
  77
  78   void put() {
  79     if (--ref_cnt == 0)
  80       delete this;
  81   }
  82
  83   void queue_aio_write(struct AioCompletionImpl *c);
  84   void complete_aio_write(struct AioCompletionImpl *c);
  85   void flush_aio_writes_async(AioCompletionImpl *c);
  86   void flush_aio_writes();
  87
  88   int64_t get_id() {
  89     return poolid;
  90   }
  91
  92   string get_cached_pool_name();
  93
  94   int get_object_hash_position(const std::string& oid, uint32_t *hash_position);
  95   int get_object_pg_hash_position(const std::string& oid, uint32_t *pg_hash_position);
  96
  97   ::ObjectOperation *prepare_assert_ops(::ObjectOperation *op);
  98
  99   // snaps
 100   int snap_list(vector<uint64_t> *snaps);
 101   int snap_lookup(const char *name, uint64_t *snapid);
 102   int snap_get_name(uint64_t snapid, std::string *s);
 103   int snap_get_stamp(uint64_t snapid, time_t *t);
 104   int snap_create(const char* snapname);
 105   int selfmanaged_snap_create(uint64_t *snapid);
 106   void aio_selfmanaged_snap_create(uint64_t *snapid, AioCompletionImpl *c);
 107   int snap_remove(const char* snapname);
 108   int rollback(const object_t& oid, const char *snapName);
 109   int selfmanaged_snap_remove(uint64_t snapid);
 110   void aio_selfmanaged_snap_remove(uint64_t snapid, AioCompletionImpl *c);
 111   int selfmanaged_snap_rollback_object(const object_t& oid,
 112                                        ::SnapContext& snapc, uint64_t snapid);
 113
 114   // io
 115   int nlist(Objecter::NListContext *context, int max_entries);
 116   uint32_t nlist_seek(Objecter::NListContext *context, uint32_t pos);
 117   uint32_t nlist_seek(Objecter::NListContext *context, const rados_object_list_cursor& cursor);
 118   rados_object_list_cursor nlist_get_cursor(Objecter::NListContext *context);
 119   void object_list_slice(
 120     const hobject_t start,
 121     const hobject_t finish,
 122     const size_t n,
 123     const size_t m,
 124     hobject_t *split_start,
 125     hobject_t *split_finish);
 126
 127   int create(const object_t& oid, bool exclusive);
 128   int write(const object_t& oid, bufferlist& bl, size_t len, uint64_t off);
 129   int append(const object_t& oid, bufferlist& bl, size_t len);
 130   int write_full(const object_t& oid, bufferlist& bl);
 131   int writesame(const object_t& oid, bufferlist& bl,
 132                 size_t write_len, uint64_t offset);
 133   int read(const object_t& oid, bufferlist& bl, size_t len, uint64_t off);
 134   int mapext(const object_t& oid, uint64_t off, size_t len,
 135              std::map<uint64_t,uint64_t>& m);
 136   int sparse_read(const object_t& oid, std::map<uint64_t,uint64_t>& m,
 137                   bufferlist& bl, size_t len, uint64_t off);
 138   int checksum(const object_t& oid, uint8_t type, const bufferlist &init_value,
 139                size_t len, uint64_t off, size_t chunk_size, bufferlist *pbl);
 140   int remove(const object_t& oid);
 141   int remove(const object_t& oid, int flags);
 142   int stat(const object_t& oid, uint64_t *psize, time_t *pmtime);
 143   int stat2(const object_t& oid, uint64_t *psize, struct timespec *pts);
 144   int trunc(const object_t& oid, uint64_t size);
 145   int cmpext(const object_t& oid, uint64_t off, bufferlist& cmp_bl);
 146
 147   int tmap_update(const object_t& oid, bufferlist& cmdbl);
 148
 149   int exec(const object_t& oid, const char *cls, const char *method, bufferlist& inbl, bufferlist& outbl);
 150
 151   int getxattr(const object_t& oid, const char *name, bufferlist& bl);
 152   int setxattr(const object_t& oid, const char *name, bufferlist& bl);
 153   int getxattrs(const object_t& oid, map<string, bufferlist>& attrset);
 154   int rmxattr(const object_t& oid, const char *name);
 155
 156   int operate(const object_t& oid, ::ObjectOperation *o, ceph::real_time *pmtime, int flags=0);
 157   int operate_read(const object_t& oid, ::ObjectOperation *o, bufferlist *pbl, int flags=0);
 158   int aio_operate(const object_t& oid, ::ObjectOperation *o,
 159                   AioCompletionImpl *c, const SnapContext& snap_context,
 160                   int flags, const blkin_trace_info *trace_info = nullptr);
 161   int aio_operate_read(const object_t& oid, ::ObjectOperation *o,
 162                        AioCompletionImpl *c, int flags, bufferlist *pbl, const blkin_trace_info *trace_info = nullptr);
 163
 164   struct C_aio_stat_Ack : public Context {
 165     librados::AioCompletionImpl *c;
 166     time_t *pmtime;
 167     ceph::real_time mtime;
 168     C_aio_stat_Ack(AioCompletionImpl *_c, time_t *pm);
 169     void finish(int r) override;
 170   };
 171
 172   struct C_aio_stat2_Ack : public Context {
 173     librados::AioCompletionImpl *c;
 174     struct timespec *pts;
 175     ceph::real_time mtime;
 176     C_aio_stat2_Ack(AioCompletionImpl *_c, struct timespec *pts);
 177     void finish(int r) override;
 178   };
 179
 180   struct C_aio_Complete : public Context {
 181 #if defined(WITH_EVENTTRACE)
 182     object_t oid;
 183 #endif
 184     AioCompletionImpl *c;
 185     explicit C_aio_Complete(AioCompletionImpl *_c);
 186     void finish(int r) override;
 187   };
 188
 189   int aio_read(const object_t oid, AioCompletionImpl *c,
 190                bufferlist *pbl, size_t len, uint64_t off, uint64_t snapid,
 191                const blkin_trace_info *info = nullptr);
 192   int aio_read(object_t oid, AioCompletionImpl *c,
 193                char *buf, size_t len, uint64_t off, uint64_t snapid,
 194                const blkin_trace_info *info = nullptr);
 195   int aio_sparse_read(const object_t oid, AioCompletionImpl *c,
 196                       std::map<uint64_t,uint64_t> *m, bufferlist *data_bl,
 197                       size_t len, uint64_t off, uint64_t snapid);
 198   int aio_cmpext(const object_t& oid, AioCompletionImpl *c, uint64_t off,
 199                       bufferlist& cmp_bl);
 200   int aio_cmpext(const object_t& oid, AioCompletionImpl *c,
 201                       const char *cmp_buf, size_t cmp_len, uint64_t off);
 202   int aio_write(const object_t &oid, AioCompletionImpl *c,
 203                 const bufferlist& bl, size_t len, uint64_t off,
 204                 const blkin_trace_info *info = nullptr);
 205   int aio_append(const object_t &oid, AioCompletionImpl *c,
 206                  const bufferlist& bl, size_t len);
 207   int aio_write_full(const object_t &oid, AioCompletionImpl *c,
 208                      const bufferlist& bl);
 209   int aio_writesame(const object_t &oid, AioCompletionImpl *c,
 210                     const bufferlist& bl, size_t write_len, uint64_t off);
 211   int aio_remove(const object_t &oid, AioCompletionImpl *c, int flags=0);
 212   int aio_exec(const object_t& oid, AioCompletionImpl *c, const char *cls,
 213                const char *method, bufferlist& inbl, bufferlist *outbl);
 214   int aio_exec(const object_t& oid, AioCompletionImpl *c, const char *cls,
 215                const char *method, bufferlist& inbl, char *buf, size_t out_len);
 216   int aio_stat(const object_t& oid, AioCompletionImpl *c, uint64_t *psize, time_t *pmtime);
 217   int aio_stat2(const object_t& oid, AioCompletionImpl *c, uint64_t *psize, struct timespec *pts);
 218   int aio_getxattr(const object_t& oid, AioCompletionImpl *c,
 219                    const char *name, bufferlist& bl);
 220   int aio_setxattr(const object_t& oid, AioCompletionImpl *c,
 221                    const char *name, bufferlist& bl);
 222   int aio_getxattrs(const object_t& oid, AioCompletionImpl *c,
 223                     map<string, bufferlist>& attrset);
 224   int aio_rmxattr(const object_t& oid, AioCompletionImpl *c,
 225                   const char *name);
 226   int aio_cancel(AioCompletionImpl *c);
 227
 228   int hit_set_list(uint32_t hash, AioCompletionImpl *c,
 229                    std::list< std::pair<time_t, time_t> > *pls);
 230   int hit_set_get(uint32_t hash, AioCompletionImpl *c, time_t stamp,
 231                   bufferlist *pbl);
 232
 233   int get_inconsistent_objects(const pg_t& pg,
 234                                const librados::object_id_t& start_after,
 235                                uint64_t max_to_get,
 236                                AioCompletionImpl *c,
 237                                std::vector<inconsistent_obj_t>* objects,
 238                                uint32_t* interval);
 239
 240   int get_inconsistent_snapsets(const pg_t& pg,
 241                                 const librados::object_id_t& start_after,
 242                                 uint64_t max_to_get,
 243                                 AioCompletionImpl *c,
 244                                 std::vector<inconsistent_snapset_t>* snapsets,
 245                                 uint32_t* interval);
 246
 247   void set_sync_op_version(version_t ver);
 248   int watch(const object_t& oid, uint64_t *cookie, librados::WatchCtx *ctx,
 249             librados::WatchCtx2 *ctx2, bool internal = false);
 250   int watch(const object_t& oid, uint64_t *cookie, librados::WatchCtx *ctx,
 251             librados::WatchCtx2 *ctx2, uint32_t timeout, bool internal = false);
 252   int aio_watch(const object_t& oid, AioCompletionImpl *c, uint64_t *cookie,
 253                 librados::WatchCtx *ctx, librados::WatchCtx2 *ctx2,
 254                 bool internal = false);
 255   int aio_watch(const object_t& oid, AioCompletionImpl *c, uint64_t *cookie,
 256                 librados::WatchCtx *ctx, librados::WatchCtx2 *ctx2,
 257                 uint32_t timeout, bool internal = false);
 258   int watch_check(uint64_t cookie);
 259   int unwatch(uint64_t cookie);
 260   int aio_unwatch(uint64_t cookie, AioCompletionImpl *c);
 261   int notify(const object_t& oid, bufferlist& bl, uint64_t timeout_ms,
 262              bufferlist *preplybl, char **preply_buf, size_t *preply_buf_len);
 263   int notify_ack(const object_t& oid, uint64_t notify_id, uint64_t cookie,
 264                  bufferlist& bl);
 265   int aio_notify(const object_t& oid, AioCompletionImpl *c, bufferlist& bl,
 266                  uint64_t timeout_ms, bufferlist *preplybl, char **preply_buf,
 267                  size_t *preply_buf_len);
 268
 269   int set_alloc_hint(const object_t& oid,
 270                      uint64_t expected_object_size,
 271                      uint64_t expected_write_size,
 272                      uint32_t flags);
 273
 274   version_t last_version();
 275   void set_assert_version(uint64_t ver);
 276   void set_notify_timeout(uint32_t timeout);
 277
 278   int cache_pin(const object_t& oid);
 279   int cache_unpin(const object_t& oid);
 280
 281   int application_enable(const std::string& app_name, bool force);
 282   void application_enable_async(const std::string& app_name, bool force,
 283                                 PoolAsyncCompletionImpl *c);
 284   int application_list(std::set<std::string> *app_names);
 285   int application_metadata_get(const std::string& app_name,
 286                                const std::string &key,
 287                                std::string* value);
 288   int application_metadata_set(const std::string& app_name,
 289                                const std::string &key,
 290                                const std::string& value);
 291   int application_metadata_remove(const std::string& app_name,
 292                                   const std::string &key);
 293   int application_metadata_list(const std::string& app_name,
 294                                 std::map<std::string, std::string> *values);
 295
 296 };
 297
 298 #endif