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