ceph/src/common/ceph_strings.cc

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