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