src/ceph/src/common/ceph_strings.cc

   1 /*
   2  * Ceph string constants
   3  */
   4 #include "include/types.h"
   5 #include "include/ceph_features.h"
   6
   7 const char *ceph_entity_type_name(int type)
   8 {
   9         switch (type) {
  10         case CEPH_ENTITY_TYPE_MDS: return "mds";
  11         case CEPH_ENTITY_TYPE_OSD: return "osd";
  12         case CEPH_ENTITY_TYPE_MON: return "mon";
  13         case CEPH_ENTITY_TYPE_MGR: return "mgr";
  14         case CEPH_ENTITY_TYPE_CLIENT: return "client";
  15         case CEPH_ENTITY_TYPE_AUTH: return "auth";
  16         default: return "unknown";
  17         }
  18 }
  19
  20 const char *ceph_osd_op_name(int op)
  21 {
  22         switch (op) {
  23 #define GENERATE_CASE(op, opcode, str)  case CEPH_OSD_OP_##op: return (str);
  24 __CEPH_FORALL_OSD_OPS(GENERATE_CASE)
  25 #undef GENERATE_CASE
  26         default:
  27                 return "???";
  28         }
  29 }
  30
  31 const char *ceph_osd_state_name(int s)
  32 {
  33         switch (s) {
  34         case CEPH_OSD_EXISTS:
  35                 return "exists";
  36         case CEPH_OSD_UP:
  37                 return "up";
  38         case CEPH_OSD_AUTOOUT:
  39                 return "autoout";
  40         case CEPH_OSD_NEW:
  41                 return "new";
  42         case CEPH_OSD_FULL:
  43                 return "full";
  44         case CEPH_OSD_NEARFULL:
  45                 return "nearfull";
  46         case CEPH_OSD_BACKFILLFULL:
  47                 return "backfillfull";
  48         case CEPH_OSD_DESTROYED:
  49                 return "destroyed";
  50         case CEPH_OSD_NOUP:
  51                 return "noup";
  52         case CEPH_OSD_NODOWN:
  53                 return "nodown";
  54         case CEPH_OSD_NOIN:
  55                 return "noin";
  56         case CEPH_OSD_NOOUT:
  57                 return "noout";
  58         default:
  59                 return "???";
  60         }
  61 }
  62
  63 const char *ceph_release_name(int r)
  64 {
  65         switch (r) {
  66         case CEPH_RELEASE_ARGONAUT:
  67                 return "argonaut";
  68         case CEPH_RELEASE_BOBTAIL:
  69                 return "bobtail";
  70         case CEPH_RELEASE_CUTTLEFISH:
  71                 return "cuttlefish";
  72         case CEPH_RELEASE_DUMPLING:
  73                 return "dumpling";
  74         case CEPH_RELEASE_EMPEROR:
  75                 return "emperor";
  76         case CEPH_RELEASE_FIREFLY:
  77                 return "firefly";
  78         case CEPH_RELEASE_GIANT:
  79                 return "giant";
  80         case CEPH_RELEASE_HAMMER:
  81                 return "hammer";
  82         case CEPH_RELEASE_INFERNALIS:
  83                 return "infernalis";
  84         case CEPH_RELEASE_JEWEL:
  85                 return "jewel";
  86         case CEPH_RELEASE_KRAKEN:
  87                 return "kraken";
  88         case CEPH_RELEASE_LUMINOUS:
  89                 return "luminous";
  90         case CEPH_RELEASE_MIMIC:
  91                 return "mimic";
  92         default:
  93                 return "unknown";
  94         }
  95 }
  96
  97 int ceph_release_from_name(const char *s)
  98 {
  99         if (!s) {
 100                 return -1;
 101         }
 102         if (strcmp(s, "mimic") == 0) {
 103                 return CEPH_RELEASE_MIMIC;
 104         }
 105         if (strcmp(s, "luminous") == 0) {
 106                 return CEPH_RELEASE_LUMINOUS;
 107         }
 108         if (strcmp(s, "kraken") == 0) {
 109                 return CEPH_RELEASE_KRAKEN;
 110         }
 111         if (strcmp(s, "jewel") == 0) {
 112                 return CEPH_RELEASE_JEWEL;
 113         }
 114         if (strcmp(s, "infernalis") == 0) {
 115                 return CEPH_RELEASE_INFERNALIS;
 116         }
 117         if (strcmp(s, "hammer") == 0) {
 118                 return CEPH_RELEASE_HAMMER;
 119         }
 120         if (strcmp(s, "giant") == 0) {
 121                 return CEPH_RELEASE_GIANT;
 122         }
 123         if (strcmp(s, "firefly") == 0) {
 124                 return CEPH_RELEASE_FIREFLY;
 125         }
 126         if (strcmp(s, "emperor") == 0) {
 127                 return CEPH_RELEASE_EMPEROR;
 128         }
 129         if (strcmp(s, "dumpling") == 0) {
 130                 return CEPH_RELEASE_DUMPLING;
 131         }
 132         if (strcmp(s, "cuttlefish") == 0) {
 133                 return CEPH_RELEASE_CUTTLEFISH;
 134         }
 135         if (strcmp(s, "bobtail") == 0) {
 136                 return CEPH_RELEASE_BOBTAIL;
 137         }
 138         if (strcmp(s, "argonaut") == 0) {
 139                 return CEPH_RELEASE_ARGONAUT;
 140         }
 141         return -1;
 142 }
 143
 144 uint64_t ceph_release_features(int r)
 145 {
 146         uint64_t req = 0;
 147
 148         req |= CEPH_FEATURE_CRUSH_TUNABLES;
 149         if (r <= CEPH_RELEASE_CUTTLEFISH)
 150                 return req;
 151
 152         req |= CEPH_FEATURE_CRUSH_TUNABLES2 |
 153                 CEPH_FEATURE_OSDHASHPSPOOL;
 154         if (r <= CEPH_RELEASE_EMPEROR)
 155                 return req;
 156
 157         req |= CEPH_FEATURE_CRUSH_TUNABLES3 |
 158                 CEPH_FEATURE_OSD_PRIMARY_AFFINITY |
 159                 CEPH_FEATURE_OSD_CACHEPOOL;
 160         if (r <= CEPH_RELEASE_GIANT)
 161                 return req;
 162
 163         req |= CEPH_FEATURE_CRUSH_V4;
 164         if (r <= CEPH_RELEASE_INFERNALIS)
 165                 return req;
 166
 167         req |= CEPH_FEATURE_CRUSH_TUNABLES5;
 168         if (r <= CEPH_RELEASE_JEWEL)
 169                 return req;
 170
 171         req |= CEPH_FEATURE_MSG_ADDR2;
 172         if (r <= CEPH_RELEASE_KRAKEN)
 173                 return req;
 174
 175         req |= CEPH_FEATUREMASK_CRUSH_CHOOSE_ARGS; // and overlaps
 176         if (r <= CEPH_RELEASE_LUMINOUS)
 177                 return req;
 178
 179         return req;
 180 }
 181
 182 /* return oldest/first release that supports these features */
 183 int ceph_release_from_features(uint64_t features)
 184 {
 185         int r = 1;
 186         while (true) {
 187                 uint64_t need = ceph_release_features(r);
 188                 if ((need & features) != need ||
 189                     r == CEPH_RELEASE_MAX) {
 190                         r--;
 191                         need = ceph_release_features(r);
 192                         /* we want the first release that looks like this */
 193                         while (r > 1 && ceph_release_features(r - 1) == need) {
 194                                 r--;
 195                         }
 196                         break;
 197                 }
 198                 ++r;
 199         }
 200         return r;
 201 }
 202
 203 const char *ceph_osd_watch_op_name(int o)
 204 {
 205         switch (o) {
 206         case CEPH_OSD_WATCH_OP_UNWATCH:
 207                 return "unwatch";
 208         case CEPH_OSD_WATCH_OP_WATCH:
 209                 return "watch";
 210         case CEPH_OSD_WATCH_OP_RECONNECT:
 211                 return "reconnect";
 212         case CEPH_OSD_WATCH_OP_PING:
 213                 return "ping";
 214         default:
 215                 return "???";
 216         }
 217 }
 218
 219 const char *ceph_osd_alloc_hint_flag_name(int f)
 220 {
 221         switch (f) {
 222         case CEPH_OSD_ALLOC_HINT_FLAG_SEQUENTIAL_WRITE:
 223                 return "sequential_write";
 224         case CEPH_OSD_ALLOC_HINT_FLAG_RANDOM_WRITE:
 225                 return "random_write";
 226         case CEPH_OSD_ALLOC_HINT_FLAG_SEQUENTIAL_READ:
 227                 return "sequential_read";
 228         case CEPH_OSD_ALLOC_HINT_FLAG_RANDOM_READ:
 229                 return "random_read";
 230         case CEPH_OSD_ALLOC_HINT_FLAG_APPEND_ONLY:
 231                 return "append_only";
 232         case CEPH_OSD_ALLOC_HINT_FLAG_IMMUTABLE:
 233                 return "immutable";
 234         case CEPH_OSD_ALLOC_HINT_FLAG_SHORTLIVED:
 235                 return "shortlived";
 236         case CEPH_OSD_ALLOC_HINT_FLAG_LONGLIVED:
 237                 return "longlived";
 238         case CEPH_OSD_ALLOC_HINT_FLAG_COMPRESSIBLE:
 239                 return "compressible";
 240         case CEPH_OSD_ALLOC_HINT_FLAG_INCOMPRESSIBLE:
 241                 return "incompressible";
 242         default:
 243                 return "???";
 244         }
 245 }
 246
 247 const char *ceph_mds_state_name(int s)
 248 {
 249         switch (s) {
 250                 /* down and out */
 251         case CEPH_MDS_STATE_DNE:        return "down:dne";
 252         case CEPH_MDS_STATE_STOPPED:    return "down:stopped";
 253         case CEPH_MDS_STATE_DAMAGED:   return "down:damaged";
 254                 /* up and out */
 255         case CEPH_MDS_STATE_BOOT:       return "up:boot";
 256         case CEPH_MDS_STATE_STANDBY:    return "up:standby";
 257         case CEPH_MDS_STATE_STANDBY_REPLAY:    return "up:standby-replay";
 258         case CEPH_MDS_STATE_REPLAYONCE: return "up:oneshot-replay";
 259         case CEPH_MDS_STATE_CREATING:   return "up:creating";
 260         case CEPH_MDS_STATE_STARTING:   return "up:starting";
 261                 /* up and in */
 262         case CEPH_MDS_STATE_REPLAY:     return "up:replay";
 263         case CEPH_MDS_STATE_RESOLVE:    return "up:resolve";
 264         case CEPH_MDS_STATE_RECONNECT:  return "up:reconnect";
 265         case CEPH_MDS_STATE_REJOIN:     return "up:rejoin";
 266         case CEPH_MDS_STATE_CLIENTREPLAY: return "up:clientreplay";
 267         case CEPH_MDS_STATE_ACTIVE:     return "up:active";
 268         case CEPH_MDS_STATE_STOPPING:   return "up:stopping";
 269         }
 270         return "???";
 271 }
 272
 273 const char *ceph_session_op_name(int op)
 274 {
 275         switch (op) {
 276         case CEPH_SESSION_REQUEST_OPEN: return "request_open";
 277         case CEPH_SESSION_OPEN: return "open";
 278         case CEPH_SESSION_REQUEST_CLOSE: return "request_close";
 279         case CEPH_SESSION_CLOSE: return "close";
 280         case CEPH_SESSION_REQUEST_RENEWCAPS: return "request_renewcaps";
 281         case CEPH_SESSION_RENEWCAPS: return "renewcaps";
 282         case CEPH_SESSION_STALE: return "stale";
 283         case CEPH_SESSION_RECALL_STATE: return "recall_state";
 284         case CEPH_SESSION_FLUSHMSG: return "flushmsg";
 285         case CEPH_SESSION_FLUSHMSG_ACK: return "flushmsg_ack";
 286         case CEPH_SESSION_FORCE_RO: return "force_ro";
 287         case CEPH_SESSION_REJECT: return "reject";
 288         }
 289         return "???";
 290 }
 291
 292 const char *ceph_mds_op_name(int op)
 293 {
 294         switch (op) {
 295         case CEPH_MDS_OP_LOOKUP:  return "lookup";
 296         case CEPH_MDS_OP_LOOKUPHASH:  return "lookuphash";
 297         case CEPH_MDS_OP_LOOKUPPARENT:  return "lookupparent";
 298         case CEPH_MDS_OP_LOOKUPINO:  return "lookupino";
 299         case CEPH_MDS_OP_LOOKUPNAME:  return "lookupname";
 300         case CEPH_MDS_OP_GETATTR:  return "getattr";
 301         case CEPH_MDS_OP_SETXATTR: return "setxattr";
 302         case CEPH_MDS_OP_SETATTR: return "setattr";
 303         case CEPH_MDS_OP_RMXATTR: return "rmxattr";
 304         case CEPH_MDS_OP_SETLAYOUT: return "setlayou";
 305         case CEPH_MDS_OP_SETDIRLAYOUT: return "setdirlayout";
 306         case CEPH_MDS_OP_READDIR: return "readdir";
 307         case CEPH_MDS_OP_MKNOD: return "mknod";
 308         case CEPH_MDS_OP_LINK: return "link";
 309         case CEPH_MDS_OP_UNLINK: return "unlink";
 310         case CEPH_MDS_OP_RENAME: return "rename";
 311         case CEPH_MDS_OP_MKDIR: return "mkdir";
 312         case CEPH_MDS_OP_RMDIR: return "rmdir";
 313         case CEPH_MDS_OP_SYMLINK: return "symlink";
 314         case CEPH_MDS_OP_CREATE: return "create";
 315         case CEPH_MDS_OP_OPEN: return "open";
 316         case CEPH_MDS_OP_LOOKUPSNAP: return "lookupsnap";
 317         case CEPH_MDS_OP_LSSNAP: return "lssnap";
 318         case CEPH_MDS_OP_MKSNAP: return "mksnap";
 319         case CEPH_MDS_OP_RMSNAP: return "rmsnap";
 320         case CEPH_MDS_OP_RENAMESNAP: return "renamesnap";
 321         case CEPH_MDS_OP_SETFILELOCK: return "setfilelock";
 322         case CEPH_MDS_OP_GETFILELOCK: return "getfilelock";
 323         case CEPH_MDS_OP_FRAGMENTDIR: return "fragmentdir";
 324         case CEPH_MDS_OP_EXPORTDIR: return "exportdir";
 325         case CEPH_MDS_OP_FLUSH: return "flush_path";
 326         case CEPH_MDS_OP_ENQUEUE_SCRUB: return "enqueue_scrub";
 327         case CEPH_MDS_OP_REPAIR_FRAGSTATS: return "repair_fragstats";
 328         case CEPH_MDS_OP_REPAIR_INODESTATS: return "repair_inodestats";
 329         }
 330         return "???";
 331 }
 332
 333 const char *ceph_cap_op_name(int op)
 334 {
 335         switch (op) {
 336         case CEPH_CAP_OP_GRANT: return "grant";
 337         case CEPH_CAP_OP_REVOKE: return "revoke";
 338         case CEPH_CAP_OP_TRUNC: return "trunc";
 339         case CEPH_CAP_OP_EXPORT: return "export";
 340         case CEPH_CAP_OP_IMPORT: return "import";
 341         case CEPH_CAP_OP_UPDATE: return "update";
 342         case CEPH_CAP_OP_DROP: return "drop";
 343         case CEPH_CAP_OP_FLUSH: return "flush";
 344         case CEPH_CAP_OP_FLUSH_ACK: return "flush_ack";
 345         case CEPH_CAP_OP_FLUSHSNAP: return "flushsnap";
 346         case CEPH_CAP_OP_FLUSHSNAP_ACK: return "flushsnap_ack";
 347         case CEPH_CAP_OP_RELEASE: return "release";
 348         case CEPH_CAP_OP_RENEW: return "renew";
 349         }
 350         return "???";
 351 }
 352
 353 const char *ceph_lease_op_name(int o)
 354 {
 355         switch (o) {
 356         case CEPH_MDS_LEASE_REVOKE: return "revoke";
 357         case CEPH_MDS_LEASE_RELEASE: return "release";
 358         case CEPH_MDS_LEASE_RENEW: return "renew";
 359         case CEPH_MDS_LEASE_REVOKE_ACK: return "revoke_ack";
 360         }
 361         return "???";
 362 }
 363
 364 const char *ceph_snap_op_name(int o)
 365 {
 366         switch (o) {
 367         case CEPH_SNAP_OP_UPDATE: return "update";
 368         case CEPH_SNAP_OP_CREATE: return "create";
 369         case CEPH_SNAP_OP_DESTROY: return "destroy";
 370         case CEPH_SNAP_OP_SPLIT: return "split";
 371         }
 372         return "???";
 373 }
 374
 375 const char *ceph_watch_event_name(int e)
 376 {
 377         switch (e) {
 378         case CEPH_WATCH_EVENT_NOTIFY: return "notify";
 379         case CEPH_WATCH_EVENT_NOTIFY_COMPLETE: return "notify_complete";
 380         case CEPH_WATCH_EVENT_DISCONNECT: return "disconnect";
 381         }
 382         return "???";
 383 }
 384
 385 const char *ceph_pool_op_name(int op)
 386 {
 387         switch (op) {
 388         case POOL_OP_CREATE: return "create";
 389         case POOL_OP_DELETE: return "delete";
 390         case POOL_OP_AUID_CHANGE: return "auid change";
 391         case POOL_OP_CREATE_SNAP: return "create snap";
 392         case POOL_OP_DELETE_SNAP: return "delete snap";
 393         case POOL_OP_CREATE_UNMANAGED_SNAP: return "create unmanaged snap";
 394         case POOL_OP_DELETE_UNMANAGED_SNAP: return "delete unmanaged snap";
 395         }
 396         return "???";
 397 }
 398
 399 const char *ceph_osd_backoff_op_name(int op)
 400 {
 401         switch (op) {
 402         case CEPH_OSD_BACKOFF_OP_BLOCK: return "block";
 403         case CEPH_OSD_BACKOFF_OP_ACK_BLOCK: return "ack-block";
 404         case CEPH_OSD_BACKOFF_OP_UNBLOCK: return "unblock";
 405         }
 406         return "???";
 407 }