[ceph.git] / ceph / src / common / ceph_strings.cc

/*
 * Ceph string constants
 */
#include "ceph_strings.h"
#include "include/types.h"
#include "include/ceph_features.h"

const char *ceph_entity_type_name(int type)
{
	switch (type) {
	case CEPH_ENTITY_TYPE_MDS: return "mds";
	case CEPH_ENTITY_TYPE_OSD: return "osd";
	case CEPH_ENTITY_TYPE_MON: return "mon";
	case CEPH_ENTITY_TYPE_MGR: return "mgr";
	case CEPH_ENTITY_TYPE_CLIENT: return "client";
	case CEPH_ENTITY_TYPE_AUTH: return "auth";
	default: return "unknown";
	}
}

const char *ceph_con_mode_name(int con_mode)
{
	switch (con_mode) {
	case CEPH_CON_MODE_UNKNOWN: return "unknown";
	case CEPH_CON_MODE_CRC: return "crc";
	case CEPH_CON_MODE_SECURE: return "secure";
	default: return "???";
	}
}

const char *ceph_osd_op_name(int op)
{
	switch (op) {
#define GENERATE_CASE(op, opcode, str)	case CEPH_OSD_OP_##op: return (str);
__CEPH_FORALL_OSD_OPS(GENERATE_CASE)
#undef GENERATE_CASE
	default:
		return "???";
	}
}

const char *ceph_osd_state_name(int s)
{
	switch (s) {
	case CEPH_OSD_EXISTS:
		return "exists";
	case CEPH_OSD_UP:
		return "up";
	case CEPH_OSD_AUTOOUT:
		return "autoout";
	case CEPH_OSD_NEW:
		return "new";
	case CEPH_OSD_FULL:
		return "full";
	case CEPH_OSD_NEARFULL:
		return "nearfull";
	case CEPH_OSD_BACKFILLFULL:
		return "backfillfull";
        case CEPH_OSD_DESTROYED:
                return "destroyed";
        case CEPH_OSD_NOUP:
                return "noup";
        case CEPH_OSD_NODOWN:
                return "nodown";
        case CEPH_OSD_NOIN:
                return "noin";
        case CEPH_OSD_NOOUT:
                return "noout";
        case CEPH_OSD_STOP:
                return "stop";
	default:
		return "???";
	}
}

const char *ceph_release_name(int r)
{
	switch (r) {
	case CEPH_RELEASE_ARGONAUT:
		return "argonaut";
	case CEPH_RELEASE_BOBTAIL:
		return "bobtail";
	case CEPH_RELEASE_CUTTLEFISH:
		return "cuttlefish";
	case CEPH_RELEASE_DUMPLING:
		return "dumpling";
	case CEPH_RELEASE_EMPEROR:
		return "emperor";
	case CEPH_RELEASE_FIREFLY:
		return "firefly";
	case CEPH_RELEASE_GIANT:
		return "giant";
	case CEPH_RELEASE_HAMMER:
		return "hammer";
	case CEPH_RELEASE_INFERNALIS:
		return "infernalis";
	case CEPH_RELEASE_JEWEL:
		return "jewel";
	case CEPH_RELEASE_KRAKEN:
		return "kraken";
	case CEPH_RELEASE_LUMINOUS:
		return "luminous";
	case CEPH_RELEASE_MIMIC:
		return "mimic";
	case CEPH_RELEASE_NAUTILUS:
		return "nautilus";
	case CEPH_RELEASE_OCTOPUS:
		return "octopus";
	case CEPH_RELEASE_PACIFIC:
		return "pacific";
	default:
		if (r < 0)
			return "unspecified";
		return "unknown";
	}
}

uint64_t ceph_release_features(int r)
{
	uint64_t req = 0;

	req |= CEPH_FEATURE_CRUSH_TUNABLES;
	if (r <= CEPH_RELEASE_CUTTLEFISH)
		return req;

	req |= CEPH_FEATURE_CRUSH_TUNABLES2 |
		CEPH_FEATURE_OSDHASHPSPOOL;
	if (r <= CEPH_RELEASE_EMPEROR)
		return req;

	req |= CEPH_FEATURE_CRUSH_TUNABLES3 |
		CEPH_FEATURE_OSD_PRIMARY_AFFINITY |
		CEPH_FEATURE_OSD_CACHEPOOL;
	if (r <= CEPH_RELEASE_GIANT)
		return req;

	req |= CEPH_FEATURE_CRUSH_V4;
	if (r <= CEPH_RELEASE_INFERNALIS)
		return req;

	req |= CEPH_FEATURE_CRUSH_TUNABLES5;
	if (r <= CEPH_RELEASE_JEWEL)
		return req;

	req |= CEPH_FEATURE_MSG_ADDR2;
	if (r <= CEPH_RELEASE_KRAKEN)
		return req;

	req |= CEPH_FEATUREMASK_CRUSH_CHOOSE_ARGS; // and overlaps
	if (r <= CEPH_RELEASE_LUMINOUS)
		return req;

	return req;
}

/* return oldest/first release that supports these features */
int ceph_release_from_features(uint64_t features)
{
	int r = 1;
	while (true) {
		uint64_t need = ceph_release_features(r);
		if ((need & features) != need ||
		    r == CEPH_RELEASE_MAX) {
			r--;
			need = ceph_release_features(r);
			/* we want the first release that looks like this */
			while (r > 1 && ceph_release_features(r - 1) == need) {
				r--;
			}
			break;
		}
		++r;
	}
	return r;
}

const char *ceph_osd_watch_op_name(int o)
{
	switch (o) {
	case CEPH_OSD_WATCH_OP_UNWATCH:
		return "unwatch";
	case CEPH_OSD_WATCH_OP_WATCH:
		return "watch";
	case CEPH_OSD_WATCH_OP_RECONNECT:
		return "reconnect";
	case CEPH_OSD_WATCH_OP_PING:
		return "ping";
	default:
		return "???";
	}
}

const char *ceph_osd_alloc_hint_flag_name(int f)
{
	switch (f) {
	case CEPH_OSD_ALLOC_HINT_FLAG_SEQUENTIAL_WRITE:
		return "sequential_write";
	case CEPH_OSD_ALLOC_HINT_FLAG_RANDOM_WRITE:
		return "random_write";
	case CEPH_OSD_ALLOC_HINT_FLAG_SEQUENTIAL_READ:
		return "sequential_read";
	case CEPH_OSD_ALLOC_HINT_FLAG_RANDOM_READ:
		return "random_read";
	case CEPH_OSD_ALLOC_HINT_FLAG_APPEND_ONLY:
		return "append_only";
	case CEPH_OSD_ALLOC_HINT_FLAG_IMMUTABLE:
		return "immutable";
	case CEPH_OSD_ALLOC_HINT_FLAG_SHORTLIVED:
		return "shortlived";
	case CEPH_OSD_ALLOC_HINT_FLAG_LONGLIVED:
		return "longlived";
	case CEPH_OSD_ALLOC_HINT_FLAG_COMPRESSIBLE:
		return "compressible";
	case CEPH_OSD_ALLOC_HINT_FLAG_INCOMPRESSIBLE:
		return "incompressible";
	default:
		return "???";
	}
}

const char *ceph_mds_state_name(int s)
{
	switch (s) {
		/* down and out */
	case CEPH_MDS_STATE_DNE:        return "down:dne";
	case CEPH_MDS_STATE_STOPPED:    return "down:stopped";
	case CEPH_MDS_STATE_DAMAGED:   return "down:damaged";
		/* up and out */
	case CEPH_MDS_STATE_BOOT:       return "up:boot";
	case CEPH_MDS_STATE_STANDBY:    return "up:standby";
	case CEPH_MDS_STATE_STANDBY_REPLAY:    return "up:standby-replay";
	case CEPH_MDS_STATE_REPLAYONCE: return "up:oneshot-replay";
	case CEPH_MDS_STATE_CREATING:   return "up:creating";
	case CEPH_MDS_STATE_STARTING:   return "up:starting";
		/* up and in */
	case CEPH_MDS_STATE_REPLAY:     return "up:replay";
	case CEPH_MDS_STATE_RESOLVE:    return "up:resolve";
	case CEPH_MDS_STATE_RECONNECT:  return "up:reconnect";
	case CEPH_MDS_STATE_REJOIN:     return "up:rejoin";
	case CEPH_MDS_STATE_CLIENTREPLAY: return "up:clientreplay";
	case CEPH_MDS_STATE_ACTIVE:     return "up:active";
	case CEPH_MDS_STATE_STOPPING:   return "up:stopping";
               /* misc */
	case CEPH_MDS_STATE_NULL:       return "null";
	}
	return "???";
}

const char *ceph_session_op_name(int op)
{
	switch (op) {
	case CEPH_SESSION_REQUEST_OPEN: return "request_open";
	case CEPH_SESSION_OPEN: return "open";
	case CEPH_SESSION_REQUEST_CLOSE: return "request_close";
	case CEPH_SESSION_CLOSE: return "close";
	case CEPH_SESSION_REQUEST_RENEWCAPS: return "request_renewcaps";
	case CEPH_SESSION_RENEWCAPS: return "renewcaps";
	case CEPH_SESSION_STALE: return "stale";
	case CEPH_SESSION_RECALL_STATE: return "recall_state";
	case CEPH_SESSION_FLUSHMSG: return "flushmsg";
	case CEPH_SESSION_FLUSHMSG_ACK: return "flushmsg_ack";
	case CEPH_SESSION_FORCE_RO: return "force_ro";
	case CEPH_SESSION_REJECT: return "reject";
	case CEPH_SESSION_REQUEST_FLUSH_MDLOG: return "request_flushmdlog";
	}
	return "???";
}

const char *ceph_mds_op_name(int op)
{
	switch (op) {
	case CEPH_MDS_OP_LOOKUP:  return "lookup";
	case CEPH_MDS_OP_LOOKUPHASH:  return "lookuphash";
	case CEPH_MDS_OP_LOOKUPPARENT:  return "lookupparent";
	case CEPH_MDS_OP_LOOKUPINO:  return "lookupino";
	case CEPH_MDS_OP_LOOKUPNAME:  return "lookupname";
	case CEPH_MDS_OP_GETATTR:  return "getattr";
	case CEPH_MDS_OP_SETXATTR: return "setxattr";
	case CEPH_MDS_OP_SETATTR: return "setattr";
	case CEPH_MDS_OP_RMXATTR: return "rmxattr";
	case CEPH_MDS_OP_SETLAYOUT: return "setlayou";
	case CEPH_MDS_OP_SETDIRLAYOUT: return "setdirlayout";
	case CEPH_MDS_OP_READDIR: return "readdir";
	case CEPH_MDS_OP_MKNOD: return "mknod";
	case CEPH_MDS_OP_LINK: return "link";
	case CEPH_MDS_OP_UNLINK: return "unlink";
	case CEPH_MDS_OP_RENAME: return "rename";
	case CEPH_MDS_OP_MKDIR: return "mkdir";
	case CEPH_MDS_OP_RMDIR: return "rmdir";
	case CEPH_MDS_OP_SYMLINK: return "symlink";
	case CEPH_MDS_OP_CREATE: return "create";
	case CEPH_MDS_OP_OPEN: return "open";
	case CEPH_MDS_OP_LOOKUPSNAP: return "lookupsnap";
	case CEPH_MDS_OP_LSSNAP: return "lssnap";
	case CEPH_MDS_OP_MKSNAP: return "mksnap";
	case CEPH_MDS_OP_RMSNAP: return "rmsnap";
	case CEPH_MDS_OP_RENAMESNAP: return "renamesnap";
	case CEPH_MDS_OP_SETFILELOCK: return "setfilelock";
	case CEPH_MDS_OP_GETFILELOCK: return "getfilelock";
	case CEPH_MDS_OP_FRAGMENTDIR: return "fragmentdir";
	case CEPH_MDS_OP_EXPORTDIR: return "exportdir";
	case CEPH_MDS_OP_FLUSH: return "flush_path";
	case CEPH_MDS_OP_ENQUEUE_SCRUB: return "enqueue_scrub";
	case CEPH_MDS_OP_REPAIR_FRAGSTATS: return "repair_fragstats";
	case CEPH_MDS_OP_REPAIR_INODESTATS: return "repair_inodestats";
	}
	return "???";
}

const char *ceph_cap_op_name(int op)
{
	switch (op) {
	case CEPH_CAP_OP_GRANT: return "grant";
	case CEPH_CAP_OP_REVOKE: return "revoke";
	case CEPH_CAP_OP_TRUNC: return "trunc";
	case CEPH_CAP_OP_EXPORT: return "export";
	case CEPH_CAP_OP_IMPORT: return "import";
	case CEPH_CAP_OP_UPDATE: return "update";
	case CEPH_CAP_OP_DROP: return "drop";
	case CEPH_CAP_OP_FLUSH: return "flush";
	case CEPH_CAP_OP_FLUSH_ACK: return "flush_ack";
	case CEPH_CAP_OP_FLUSHSNAP: return "flushsnap";
	case CEPH_CAP_OP_FLUSHSNAP_ACK: return "flushsnap_ack";
	case CEPH_CAP_OP_RELEASE: return "release";
	case CEPH_CAP_OP_RENEW: return "renew";
	}
	return "???";
}

const char *ceph_lease_op_name(int o)
{
	switch (o) {
	case CEPH_MDS_LEASE_REVOKE: return "revoke";
	case CEPH_MDS_LEASE_RELEASE: return "release";
	case CEPH_MDS_LEASE_RENEW: return "renew";
	case CEPH_MDS_LEASE_REVOKE_ACK: return "revoke_ack";
	}
	return "???";
}

const char *ceph_snap_op_name(int o)
{
	switch (o) {
	case CEPH_SNAP_OP_UPDATE: return "update";
	case CEPH_SNAP_OP_CREATE: return "create";
	case CEPH_SNAP_OP_DESTROY: return "destroy";
	case CEPH_SNAP_OP_SPLIT: return "split";
	}
	return "???";
}

const char *ceph_watch_event_name(int e)
{
	switch (e) {
	case CEPH_WATCH_EVENT_NOTIFY: return "notify";
	case CEPH_WATCH_EVENT_NOTIFY_COMPLETE: return "notify_complete";
	case CEPH_WATCH_EVENT_DISCONNECT: return "disconnect";
	}
	return "???";
}

const char *ceph_pool_op_name(int op)
{
	switch (op) {
	case POOL_OP_CREATE: return "create";
	case POOL_OP_DELETE: return "delete";
	case POOL_OP_AUID_CHANGE: return "auid change";  // (obsolete)
	case POOL_OP_CREATE_SNAP: return "create snap";
	case POOL_OP_DELETE_SNAP: return "delete snap";
	case POOL_OP_CREATE_UNMANAGED_SNAP: return "create unmanaged snap";
	case POOL_OP_DELETE_UNMANAGED_SNAP: return "delete unmanaged snap";
	}
	return "???";
}

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