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         case CEPH_RELEASE_REEF:
 114                 return "reef";
 115         default:
 116                 if (r < 0)
 117                         return "unspecified";
 118                 return "unknown";
 119         }
 120 }
 121
 122 uint64_t ceph_release_features(int r)
 123 {
 124         uint64_t req = 0;
 125
 126         req |= CEPH_FEATURE_CRUSH_TUNABLES;
 127         if (r <= CEPH_RELEASE_CUTTLEFISH)
 128                 return req;
 129
 130         req |= CEPH_FEATURE_CRUSH_TUNABLES2 |
 131                 CEPH_FEATURE_OSDHASHPSPOOL;
 132         if (r <= CEPH_RELEASE_EMPEROR)
 133                 return req;
 134
 135         req |= CEPH_FEATURE_CRUSH_TUNABLES3 |
 136                 CEPH_FEATURE_OSD_PRIMARY_AFFINITY |
 137                 CEPH_FEATURE_OSD_CACHEPOOL;
 138         if (r <= CEPH_RELEASE_GIANT)
 139                 return req;
 140
 141         req |= CEPH_FEATURE_CRUSH_V4;
 142         if (r <= CEPH_RELEASE_INFERNALIS)
 143                 return req;
 144
 145         req |= CEPH_FEATURE_CRUSH_TUNABLES5;
 146         if (r <= CEPH_RELEASE_JEWEL)
 147                 return req;
 148
 149         req |= CEPH_FEATURE_MSG_ADDR2;
 150         if (r <= CEPH_RELEASE_KRAKEN)
 151                 return req;
 152
 153         req |= CEPH_FEATUREMASK_CRUSH_CHOOSE_ARGS; // and overlaps
 154         if (r <= CEPH_RELEASE_LUMINOUS)
 155                 return req;
 156
 157         return req;
 158 }
 159
 160 /* return oldest/first release that supports these features */
 161 int ceph_release_from_features(uint64_t features)
 162 {
 163         int r = 1;
 164         while (true) {
 165                 uint64_t need = ceph_release_features(r);
 166                 if ((need & features) != need ||
 167                     r == CEPH_RELEASE_MAX) {
 168                         r--;
 169                         need = ceph_release_features(r);
 170                         /* we want the first release that looks like this */
 171                         while (r > 1 && ceph_release_features(r - 1) == need) {
 172                                 r--;
 173                         }
 174                         break;
 175                 }
 176                 ++r;
 177         }
 178         return r;
 179 }
 180
 181 const char *ceph_osd_watch_op_name(int o)
 182 {
 183         switch (o) {
 184         case CEPH_OSD_WATCH_OP_UNWATCH:
 185                 return "unwatch";
 186         case CEPH_OSD_WATCH_OP_WATCH:
 187                 return "watch";
 188         case CEPH_OSD_WATCH_OP_RECONNECT:
 189                 return "reconnect";
 190         case CEPH_OSD_WATCH_OP_PING:
 191                 return "ping";
 192         default:
 193                 return "???";
 194         }
 195 }
 196
 197 const char *ceph_osd_alloc_hint_flag_name(int f)
 198 {
 199         switch (f) {
 200         case CEPH_OSD_ALLOC_HINT_FLAG_SEQUENTIAL_WRITE:
 201                 return "sequential_write";
 202         case CEPH_OSD_ALLOC_HINT_FLAG_RANDOM_WRITE:
 203                 return "random_write";
 204         case CEPH_OSD_ALLOC_HINT_FLAG_SEQUENTIAL_READ:
 205                 return "sequential_read";
 206         case CEPH_OSD_ALLOC_HINT_FLAG_RANDOM_READ:
 207                 return "random_read";
 208         case CEPH_OSD_ALLOC_HINT_FLAG_APPEND_ONLY:
 209                 return "append_only";
 210         case CEPH_OSD_ALLOC_HINT_FLAG_IMMUTABLE:
 211                 return "immutable";
 212         case CEPH_OSD_ALLOC_HINT_FLAG_SHORTLIVED:
 213                 return "shortlived";
 214         case CEPH_OSD_ALLOC_HINT_FLAG_LONGLIVED:
 215                 return "longlived";
 216         case CEPH_OSD_ALLOC_HINT_FLAG_COMPRESSIBLE:
 217                 return "compressible";
 218         case CEPH_OSD_ALLOC_HINT_FLAG_INCOMPRESSIBLE:
 219                 return "incompressible";
 220         default:
 221                 return "???";
 222         }
 223 }
 224
 225 const char *ceph_mds_state_name(int s)
 226 {
 227         switch (s) {
 228                 /* down and out */
 229         case CEPH_MDS_STATE_DNE:        return "down:dne";
 230         case CEPH_MDS_STATE_STOPPED:    return "down:stopped";
 231         case CEPH_MDS_STATE_DAMAGED:   return "down:damaged";
 232                 /* up and out */
 233         case CEPH_MDS_STATE_BOOT:       return "up:boot";
 234         case CEPH_MDS_STATE_STANDBY:    return "up:standby";
 235         case CEPH_MDS_STATE_STANDBY_REPLAY:    return "up:standby-replay";
 236         case CEPH_MDS_STATE_REPLAYONCE: return "up:oneshot-replay";
 237         case CEPH_MDS_STATE_CREATING:   return "up:creating";
 238         case CEPH_MDS_STATE_STARTING:   return "up:starting";
 239                 /* up and in */
 240         case CEPH_MDS_STATE_REPLAY:     return "up:replay";
 241         case CEPH_MDS_STATE_RESOLVE:    return "up:resolve";
 242         case CEPH_MDS_STATE_RECONNECT:  return "up:reconnect";
 243         case CEPH_MDS_STATE_REJOIN:     return "up:rejoin";
 244         case CEPH_MDS_STATE_CLIENTREPLAY: return "up:clientreplay";
 245         case CEPH_MDS_STATE_ACTIVE:     return "up:active";
 246         case CEPH_MDS_STATE_STOPPING:   return "up:stopping";
 247                /* misc */
 248         case CEPH_MDS_STATE_NULL:       return "null";
 249         }
 250         return "???";
 251 }
 252
 253 const char *ceph_session_op_name(int op)
 254 {
 255         switch (op) {
 256         case CEPH_SESSION_REQUEST_OPEN: return "request_open";
 257         case CEPH_SESSION_OPEN: return "open";
 258         case CEPH_SESSION_REQUEST_CLOSE: return "request_close";
 259         case CEPH_SESSION_CLOSE: return "close";
 260         case CEPH_SESSION_REQUEST_RENEWCAPS: return "request_renewcaps";
 261         case CEPH_SESSION_RENEWCAPS: return "renewcaps";
 262         case CEPH_SESSION_STALE: return "stale";
 263         case CEPH_SESSION_RECALL_STATE: return "recall_state";
 264         case CEPH_SESSION_FLUSHMSG: return "flushmsg";
 265         case CEPH_SESSION_FLUSHMSG_ACK: return "flushmsg_ack";
 266         case CEPH_SESSION_FORCE_RO: return "force_ro";
 267         case CEPH_SESSION_REJECT: return "reject";
 268         case CEPH_SESSION_REQUEST_FLUSH_MDLOG: return "request_flushmdlog";
 269         }
 270         return "???";
 271 }
 272
 273 const char *ceph_mds_op_name(int op)
 274 {
 275         switch (op) {
 276         case CEPH_MDS_OP_LOOKUP:  return "lookup";
 277         case CEPH_MDS_OP_LOOKUPHASH:  return "lookuphash";
 278         case CEPH_MDS_OP_LOOKUPPARENT:  return "lookupparent";
 279         case CEPH_MDS_OP_LOOKUPINO:  return "lookupino";
 280         case CEPH_MDS_OP_LOOKUPNAME:  return "lookupname";
 281         case CEPH_MDS_OP_GETATTR:  return "getattr";
 282         case CEPH_MDS_OP_DUMMY:  return "dummy";
 283         case CEPH_MDS_OP_SETXATTR: return "setxattr";
 284         case CEPH_MDS_OP_SETATTR: return "setattr";
 285         case CEPH_MDS_OP_RMXATTR: return "rmxattr";
 286         case CEPH_MDS_OP_SETLAYOUT: return "setlayou";
 287         case CEPH_MDS_OP_SETDIRLAYOUT: return "setdirlayout";
 288         case CEPH_MDS_OP_READDIR: return "readdir";
 289         case CEPH_MDS_OP_MKNOD: return "mknod";
 290         case CEPH_MDS_OP_LINK: return "link";
 291         case CEPH_MDS_OP_UNLINK: return "unlink";
 292         case CEPH_MDS_OP_RENAME: return "rename";
 293         case CEPH_MDS_OP_MKDIR: return "mkdir";
 294         case CEPH_MDS_OP_RMDIR: return "rmdir";
 295         case CEPH_MDS_OP_SYMLINK: return "symlink";
 296         case CEPH_MDS_OP_CREATE: return "create";
 297         case CEPH_MDS_OP_OPEN: return "open";
 298         case CEPH_MDS_OP_LOOKUPSNAP: return "lookupsnap";
 299         case CEPH_MDS_OP_LSSNAP: return "lssnap";
 300         case CEPH_MDS_OP_MKSNAP: return "mksnap";
 301         case CEPH_MDS_OP_RMSNAP: return "rmsnap";
 302         case CEPH_MDS_OP_RENAMESNAP: return "renamesnap";
 303         case CEPH_MDS_OP_READDIR_SNAPDIFF: return "readdir_snapdiff";
 304         case CEPH_MDS_OP_SETFILELOCK: return "setfilelock";
 305         case CEPH_MDS_OP_GETFILELOCK: return "getfilelock";
 306         case CEPH_MDS_OP_FRAGMENTDIR: return "fragmentdir";
 307         case CEPH_MDS_OP_EXPORTDIR: return "exportdir";
 308         case CEPH_MDS_OP_FLUSH: return "flush_path";
 309         case CEPH_MDS_OP_ENQUEUE_SCRUB: return "enqueue_scrub";
 310         case CEPH_MDS_OP_REPAIR_FRAGSTATS: return "repair_fragstats";
 311         case CEPH_MDS_OP_REPAIR_INODESTATS: return "repair_inodestats";
 312         }
 313         return "???";
 314 }
 315
 316 const char *ceph_cap_op_name(int op)
 317 {
 318         switch (op) {
 319         case CEPH_CAP_OP_GRANT: return "grant";
 320         case CEPH_CAP_OP_REVOKE: return "revoke";
 321         case CEPH_CAP_OP_TRUNC: return "trunc";
 322         case CEPH_CAP_OP_EXPORT: return "export";
 323         case CEPH_CAP_OP_IMPORT: return "import";
 324         case CEPH_CAP_OP_UPDATE: return "update";
 325         case CEPH_CAP_OP_DROP: return "drop";
 326         case CEPH_CAP_OP_FLUSH: return "flush";
 327         case CEPH_CAP_OP_FLUSH_ACK: return "flush_ack";
 328         case CEPH_CAP_OP_FLUSHSNAP: return "flushsnap";
 329         case CEPH_CAP_OP_FLUSHSNAP_ACK: return "flushsnap_ack";
 330         case CEPH_CAP_OP_RELEASE: return "release";
 331         case CEPH_CAP_OP_RENEW: return "renew";
 332         }
 333         return "???";
 334 }
 335
 336 const char *ceph_lease_op_name(int o)
 337 {
 338         switch (o) {
 339         case CEPH_MDS_LEASE_REVOKE: return "revoke";
 340         case CEPH_MDS_LEASE_RELEASE: return "release";
 341         case CEPH_MDS_LEASE_RENEW: return "renew";
 342         case CEPH_MDS_LEASE_REVOKE_ACK: return "revoke_ack";
 343         }
 344         return "???";
 345 }
 346
 347 const char *ceph_snap_op_name(int o)
 348 {
 349         switch (o) {
 350         case CEPH_SNAP_OP_UPDATE: return "update";
 351         case CEPH_SNAP_OP_CREATE: return "create";
 352         case CEPH_SNAP_OP_DESTROY: return "destroy";
 353         case CEPH_SNAP_OP_SPLIT: return "split";
 354         }
 355         return "???";
 356 }
 357
 358 const char *ceph_watch_event_name(int e)
 359 {
 360         switch (e) {
 361         case CEPH_WATCH_EVENT_NOTIFY: return "notify";
 362         case CEPH_WATCH_EVENT_NOTIFY_COMPLETE: return "notify_complete";
 363         case CEPH_WATCH_EVENT_DISCONNECT: return "disconnect";
 364         }
 365         return "???";
 366 }
 367
 368 const char *ceph_pool_op_name(int op)
 369 {
 370         switch (op) {
 371         case POOL_OP_CREATE: return "create";
 372         case POOL_OP_DELETE: return "delete";
 373         case POOL_OP_AUID_CHANGE: return "auid change";  // (obsolete)
 374         case POOL_OP_CREATE_SNAP: return "create snap";
 375         case POOL_OP_DELETE_SNAP: return "delete snap";
 376         case POOL_OP_CREATE_UNMANAGED_SNAP: return "create unmanaged snap";
 377         case POOL_OP_DELETE_UNMANAGED_SNAP: return "delete unmanaged snap";
 378         }
 379         return "???";
 380 }
 381
 382 const char *ceph_osd_backoff_op_name(int op)
 383 {
 384         switch (op) {
 385         case CEPH_OSD_BACKOFF_OP_BLOCK: return "block";
 386         case CEPH_OSD_BACKOFF_OP_ACK_BLOCK: return "ack-block";
 387         case CEPH_OSD_BACKOFF_OP_UNBLOCK: return "unblock";
 388         }
 389         return "???";
 390 }