ceph/src/msg/Message.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #ifdef ENCODE_DUMP
   5 # include <typeinfo>
   6 # include <cxxabi.h>
   7 #endif
   8
   9 #include <iostream>
  10
  11 #include "include/types.h"
  12
  13 #include "global/global_context.h"
  14
  15 #include "Message.h"
  16
  17 #include "messages/MPGStats.h"
  18
  19 #include "messages/MGenericMessage.h"
  20
  21 #include "messages/MPGStatsAck.h"
  22
  23 #include "messages/MStatfs.h"
  24 #include "messages/MStatfsReply.h"
  25
  26 #include "messages/MGetPoolStats.h"
  27 #include "messages/MGetPoolStatsReply.h"
  28
  29
  30 #include "messages/MPoolOp.h"
  31 #include "messages/MPoolOpReply.h"
  32
  33 #include "messages/PaxosServiceMessage.h"
  34 #include "messages/MMonCommand.h"
  35 #include "messages/MMonCommandAck.h"
  36 #include "messages/MMonPaxos.h"
  37 #include "messages/MConfig.h"
  38 #include "messages/MGetConfig.h"
  39 #include "messages/MKVData.h"
  40
  41 #include "messages/MMonProbe.h"
  42 #include "messages/MMonJoin.h"
  43 #include "messages/MMonElection.h"
  44 #include "messages/MMonSync.h"
  45 #include "messages/MMonPing.h"
  46 #include "messages/MMonScrub.h"
  47
  48 #include "messages/MLog.h"
  49 #include "messages/MLogAck.h"
  50
  51 #include "messages/MPing.h"
  52
  53 #include "messages/MCommand.h"
  54 #include "messages/MCommandReply.h"
  55 #include "messages/MBackfillReserve.h"
  56 #include "messages/MRecoveryReserve.h"
  57
  58 #include "messages/MRoute.h"
  59 #include "messages/MForward.h"
  60
  61 #include "messages/MOSDBoot.h"
  62 #include "messages/MOSDAlive.h"
  63 #include "messages/MOSDBeacon.h"
  64 #include "messages/MOSDPGTemp.h"
  65 #include "messages/MOSDFailure.h"
  66 #include "messages/MOSDMarkMeDown.h"
  67 #include "messages/MOSDMarkMeDead.h"
  68 #include "messages/MOSDFull.h"
  69 #include "messages/MOSDPing.h"
  70 #include "messages/MOSDOp.h"
  71 #include "messages/MOSDOpReply.h"
  72 #include "messages/MOSDRepOp.h"
  73 #include "messages/MOSDRepOpReply.h"
  74 #include "messages/MOSDMap.h"
  75 #include "messages/MMonGetOSDMap.h"
  76 #include "messages/MMonGetPurgedSnaps.h"
  77 #include "messages/MMonGetPurgedSnapsReply.h"
  78
  79 #include "messages/MOSDPGCreated.h"
  80 #include "messages/MOSDPGNotify.h"
  81 #include "messages/MOSDPGNotify2.h"
  82 #include "messages/MOSDPGQuery.h"
  83 #include "messages/MOSDPGQuery2.h"
  84 #include "messages/MOSDPGLog.h"
  85 #include "messages/MOSDPGRemove.h"
  86 #include "messages/MOSDPGInfo.h"
  87 #include "messages/MOSDPGInfo2.h"
  88 #include "messages/MOSDPGCreate2.h"
  89 #include "messages/MOSDPGTrim.h"
  90 #include "messages/MOSDPGLease.h"
  91 #include "messages/MOSDPGLeaseAck.h"
  92 #include "messages/MOSDScrub2.h"
  93 #include "messages/MOSDScrubReserve.h"
  94 #include "messages/MOSDRepScrub.h"
  95 #include "messages/MOSDRepScrubMap.h"
  96 #include "messages/MOSDForceRecovery.h"
  97 #include "messages/MOSDPGScan.h"
  98 #include "messages/MOSDPGBackfill.h"
  99 #include "messages/MOSDBackoff.h"
 100 #include "messages/MOSDPGBackfillRemove.h"
 101 #include "messages/MOSDPGRecoveryDelete.h"
 102 #include "messages/MOSDPGRecoveryDeleteReply.h"
 103 #include "messages/MOSDPGReadyToMerge.h"
 104
 105 #include "messages/MRemoveSnaps.h"
 106
 107 #include "messages/MMonMap.h"
 108 #include "messages/MMonGetMap.h"
 109 #include "messages/MMonGetVersion.h"
 110 #include "messages/MMonGetVersionReply.h"
 111 #include "messages/MMonHealth.h"
 112 #include "messages/MMonHealthChecks.h"
 113 #include "messages/MAuth.h"
 114 #include "messages/MAuthReply.h"
 115 #include "messages/MMonSubscribe.h"
 116 #include "messages/MMonSubscribeAck.h"
 117 #include "messages/MMonGlobalID.h"
 118 #include "messages/MMonUsedPendingKeys.h"
 119 #include "messages/MClientSession.h"
 120 #include "messages/MClientReconnect.h"
 121 #include "messages/MClientRequest.h"
 122 #include "messages/MClientRequestForward.h"
 123 #include "messages/MClientReply.h"
 124 #include "messages/MClientReclaim.h"
 125 #include "messages/MClientReclaimReply.h"
 126 #include "messages/MClientCaps.h"
 127 #include "messages/MClientCapRelease.h"
 128 #include "messages/MClientLease.h"
 129 #include "messages/MClientSnap.h"
 130 #include "messages/MClientQuota.h"
 131 #include "messages/MClientMetrics.h"
 132
 133 #include "messages/MMDSPeerRequest.h"
 134
 135 #include "messages/MMDSMap.h"
 136 #include "messages/MFSMap.h"
 137 #include "messages/MFSMapUser.h"
 138 #include "messages/MMDSBeacon.h"
 139 #include "messages/MMDSLoadTargets.h"
 140 #include "messages/MMDSResolve.h"
 141 #include "messages/MMDSResolveAck.h"
 142 #include "messages/MMDSCacheRejoin.h"
 143 #include "messages/MMDSFindIno.h"
 144 #include "messages/MMDSFindInoReply.h"
 145 #include "messages/MMDSOpenIno.h"
 146 #include "messages/MMDSOpenInoReply.h"
 147 #include "messages/MMDSSnapUpdate.h"
 148 #include "messages/MMDSScrub.h"
 149 #include "messages/MMDSScrubStats.h"
 150
 151 #include "messages/MDirUpdate.h"
 152 #include "messages/MDiscover.h"
 153 #include "messages/MDiscoverReply.h"
 154
 155 #include "messages/MMDSFragmentNotify.h"
 156 #include "messages/MMDSFragmentNotifyAck.h"
 157
 158 #include "messages/MExportDirDiscover.h"
 159 #include "messages/MExportDirDiscoverAck.h"
 160 #include "messages/MExportDirCancel.h"
 161 #include "messages/MExportDirPrep.h"
 162 #include "messages/MExportDirPrepAck.h"
 163 #include "messages/MExportDir.h"
 164 #include "messages/MExportDirAck.h"
 165 #include "messages/MExportDirNotify.h"
 166 #include "messages/MExportDirNotifyAck.h"
 167 #include "messages/MExportDirFinish.h"
 168
 169 #include "messages/MExportCaps.h"
 170 #include "messages/MExportCapsAck.h"
 171 #include "messages/MGatherCaps.h"
 172
 173
 174 #include "messages/MDentryUnlink.h"
 175 #include "messages/MDentryLink.h"
 176
 177 #include "messages/MHeartbeat.h"
 178
 179 #include "messages/MMDSTableRequest.h"
 180 #include "messages/MMDSMetrics.h"
 181 #include "messages/MMDSPing.h"
 182
 183 //#include "messages/MInodeUpdate.h"
 184 #include "messages/MCacheExpire.h"
 185 #include "messages/MInodeFileCaps.h"
 186
 187 #include "messages/MMgrBeacon.h"
 188 #include "messages/MMgrMap.h"
 189 #include "messages/MMgrDigest.h"
 190 #include "messages/MMgrReport.h"
 191 #include "messages/MMgrOpen.h"
 192 #include "messages/MMgrUpdate.h"
 193 #include "messages/MMgrClose.h"
 194 #include "messages/MMgrConfigure.h"
 195 #include "messages/MMonMgrReport.h"
 196 #include "messages/MMgrCommand.h"
 197 #include "messages/MMgrCommandReply.h"
 198 #include "messages/MServiceMap.h"
 199
 200 #include "messages/MLock.h"
 201
 202 #include "messages/MWatchNotify.h"
 203 #include "messages/MTimeCheck.h"
 204 #include "messages/MTimeCheck2.h"
 205
 206 #include "common/config.h"
 207
 208 #include "messages/MOSDPGPush.h"
 209 #include "messages/MOSDPGPushReply.h"
 210 #include "messages/MOSDPGPull.h"
 211
 212 #include "messages/MOSDECSubOpWrite.h"
 213 #include "messages/MOSDECSubOpWriteReply.h"
 214 #include "messages/MOSDECSubOpRead.h"
 215 #include "messages/MOSDECSubOpReadReply.h"
 216
 217 #include "messages/MOSDPGUpdateLogMissing.h"
 218 #include "messages/MOSDPGUpdateLogMissingReply.h"
 219
 220 #ifdef WITH_BLKIN
 221 #include "Messenger.h"
 222 #endif
 223
 224 #define DEBUGLVL  10    // debug level of output
 225
 226 #define dout_subsys ceph_subsys_ms
 227
 228 void Message::encode(uint64_t features, int crcflags, bool skip_header_crc)
 229 {
 230   // encode and copy out of *m
 231   if (empty_payload()) {
 232     ceph_assert(middle.length() == 0);
 233     encode_payload(features);
 234
 235     if (byte_throttler) {
 236       byte_throttler->take(payload.length() + middle.length());
 237     }
 238
 239     // if the encoder didn't specify past compatibility, we assume it
 240     // is incompatible.
 241     if (header.compat_version == 0)
 242       header.compat_version = header.version;
 243   }
 244   if (crcflags & MSG_CRC_HEADER)
 245     calc_front_crc();
 246
 247   // update envelope
 248   header.front_len = get_payload().length();
 249   header.middle_len = get_middle().length();
 250   header.data_len = get_data().length();
 251   if (!skip_header_crc && (crcflags & MSG_CRC_HEADER))
 252     calc_header_crc();
 253
 254   footer.flags = CEPH_MSG_FOOTER_COMPLETE;
 255
 256   if (crcflags & MSG_CRC_DATA) {
 257     calc_data_crc();
 258
 259 #ifdef ENCODE_DUMP
 260     bufferlist bl;
 261     encode(get_header(), bl);
 262
 263     // dump the old footer format
 264     ceph_msg_footer_old old_footer;
 265     old_footer.front_crc = footer.front_crc;
 266     old_footer.middle_crc = footer.middle_crc;
 267     old_footer.data_crc = footer.data_crc;
 268     old_footer.flags = footer.flags;
 269     encode(old_footer, bl);
 270
 271     encode(get_payload(), bl);
 272     encode(get_middle(), bl);
 273     encode(get_data(), bl);
 274
 275     // this is almost an exponential backoff, except because we count
 276     // bits we tend to sample things we encode later, which should be
 277     // more representative.
 278     static int i = 0;
 279     i++;
 280     int bits = 0;
 281     for (unsigned t = i; t; bits++)
 282       t &= t - 1;
 283     if (bits <= 2) {
 284       char fn[200];
 285       int status;
 286       snprintf(fn, sizeof(fn), ENCODE_STRINGIFY(ENCODE_DUMP) "/%s__%d.%x",
 287                abi::__cxa_demangle(typeid(*this).name(), 0, 0, &status),
 288                getpid(), i++);
 289       int fd = ::open(fn, O_WRONLY|O_TRUNC|O_CREAT|O_CLOEXEC|O_BINARY, 0644);
 290       if (fd >= 0) {
 291         bl.write_fd(fd);
 292         ::close(fd);
 293       }
 294     }
 295 #endif
 296   } else {
 297     footer.flags = (unsigned)footer.flags | CEPH_MSG_FOOTER_NOCRC;
 298   }
 299 }
 300
 301 void Message::dump(ceph::Formatter *f) const
 302 {
 303   std::stringstream ss;
 304   print(ss);
 305   f->dump_string("summary", ss.str());
 306 }
 307
 308 Message *decode_message(CephContext *cct,
 309                         int crcflags,
 310                         ceph_msg_header& header,
 311                         ceph_msg_footer& footer,
 312                         ceph::bufferlist& front,
 313                         ceph::bufferlist& middle,
 314                         ceph::bufferlist& data,
 315                         Message::ConnectionRef conn)
 316 {
 317 #ifdef WITH_SEASTAR
 318   // In crimson, conn is independently maintained outside Message.
 319   ceph_assert(conn == nullptr);
 320 #endif
 321   // verify crc
 322   if (crcflags & MSG_CRC_HEADER) {
 323     __u32 front_crc = front.crc32c(0);
 324     __u32 middle_crc = middle.crc32c(0);
 325
 326     if (front_crc != footer.front_crc) {
 327       if (cct) {
 328         ldout(cct, 0) << "bad crc in front " << front_crc << " != exp " << footer.front_crc
 329                       << " from " << conn->get_peer_addr() << dendl;
 330         ldout(cct, 20) << " ";
 331         front.hexdump(*_dout);
 332         *_dout << dendl;
 333       }
 334       return 0;
 335     }
 336     if (middle_crc != footer.middle_crc) {
 337       if (cct) {
 338         ldout(cct, 0) << "bad crc in middle " << middle_crc << " != exp " << footer.middle_crc
 339                       << " from " << conn->get_peer_addr() << dendl;
 340         ldout(cct, 20) << " ";
 341         middle.hexdump(*_dout);
 342         *_dout << dendl;
 343       }
 344       return 0;
 345     }
 346   }
 347   if (crcflags & MSG_CRC_DATA) {
 348     if ((footer.flags & CEPH_MSG_FOOTER_NOCRC) == 0) {
 349       __u32 data_crc = data.crc32c(0);
 350       if (data_crc != footer.data_crc) {
 351         if (cct) {
 352           ldout(cct, 0) << "bad crc in data " << data_crc << " != exp " << footer.data_crc
 353                         << " from " << conn->get_peer_addr() << dendl;
 354           ldout(cct, 20) << " ";
 355           data.hexdump(*_dout);
 356           *_dout << dendl;
 357         }
 358         return 0;
 359       }
 360     }
 361   }
 362
 363   // make message
 364   ceph::ref_t<Message> m;
 365   int type = header.type;
 366   switch (type) {
 367
 368     // -- with payload --
 369
 370     using ceph::make_message;
 371
 372   case MSG_PGSTATS:
 373     m = make_message<MPGStats>();
 374     break;
 375   case MSG_PGSTATSACK:
 376     m = make_message<MPGStatsAck>();
 377     break;
 378
 379   case CEPH_MSG_STATFS:
 380     m = make_message<MStatfs>();
 381     break;
 382   case CEPH_MSG_STATFS_REPLY:
 383     m = make_message<MStatfsReply>();
 384     break;
 385   case MSG_GETPOOLSTATS:
 386     m = make_message<MGetPoolStats>();
 387     break;
 388   case MSG_GETPOOLSTATSREPLY:
 389     m = make_message<MGetPoolStatsReply>();
 390     break;
 391   case CEPH_MSG_POOLOP:
 392     m = make_message<MPoolOp>();
 393     break;
 394   case CEPH_MSG_POOLOP_REPLY:
 395     m = make_message<MPoolOpReply>();
 396     break;
 397   case MSG_MON_COMMAND:
 398     m = make_message<MMonCommand>();
 399     break;
 400   case MSG_MON_COMMAND_ACK:
 401     m = make_message<MMonCommandAck>();
 402     break;
 403   case MSG_MON_PAXOS:
 404     m = make_message<MMonPaxos>();
 405     break;
 406   case MSG_CONFIG:
 407     m = make_message<MConfig>();
 408     break;
 409   case MSG_GET_CONFIG:
 410     m = make_message<MGetConfig>();
 411     break;
 412   case MSG_KV_DATA:
 413     m = make_message<MKVData>();
 414     break;
 415
 416   case MSG_MON_PROBE:
 417     m = make_message<MMonProbe>();
 418     break;
 419   case MSG_MON_JOIN:
 420     m = make_message<MMonJoin>();
 421     break;
 422   case MSG_MON_ELECTION:
 423     m = make_message<MMonElection>();
 424     break;
 425   case MSG_MON_SYNC:
 426     m = make_message<MMonSync>();
 427     break;
 428   case MSG_MON_PING:
 429     m = make_message<MMonPing>();
 430     break;
 431   case MSG_MON_SCRUB:
 432     m = make_message<MMonScrub>();
 433     break;
 434
 435   case MSG_LOG:
 436     m = make_message<MLog>();
 437     break;
 438   case MSG_LOGACK:
 439     m = make_message<MLogAck>();
 440     break;
 441
 442   case CEPH_MSG_PING:
 443     m = make_message<MPing>();
 444     break;
 445   case MSG_COMMAND:
 446     m = make_message<MCommand>();
 447     break;
 448   case MSG_COMMAND_REPLY:
 449     m = make_message<MCommandReply>();
 450     break;
 451   case MSG_OSD_BACKFILL_RESERVE:
 452     m = make_message<MBackfillReserve>();
 453     break;
 454   case MSG_OSD_RECOVERY_RESERVE:
 455     m = make_message<MRecoveryReserve>();
 456     break;
 457   case MSG_OSD_FORCE_RECOVERY:
 458     m = make_message<MOSDForceRecovery>();
 459     break;
 460
 461   case MSG_ROUTE:
 462     m = make_message<MRoute>();
 463     break;
 464   case MSG_FORWARD:
 465     m = make_message<MForward>();
 466     break;
 467
 468   case CEPH_MSG_MON_MAP:
 469     m = make_message<MMonMap>();
 470     break;
 471   case CEPH_MSG_MON_GET_MAP:
 472     m = make_message<MMonGetMap>();
 473     break;
 474   case CEPH_MSG_MON_GET_OSDMAP:
 475     m = make_message<MMonGetOSDMap>();
 476     break;
 477   case MSG_MON_GET_PURGED_SNAPS:
 478     m = make_message<MMonGetPurgedSnaps>();
 479     break;
 480   case MSG_MON_GET_PURGED_SNAPS_REPLY:
 481     m = make_message<MMonGetPurgedSnapsReply>();
 482     break;
 483   case CEPH_MSG_MON_GET_VERSION:
 484     m = make_message<MMonGetVersion>();
 485     break;
 486   case CEPH_MSG_MON_GET_VERSION_REPLY:
 487     m = make_message<MMonGetVersionReply>();
 488     break;
 489
 490   case MSG_OSD_BOOT:
 491     m = make_message<MOSDBoot>();
 492     break;
 493   case MSG_OSD_ALIVE:
 494     m = make_message<MOSDAlive>();
 495     break;
 496   case MSG_OSD_BEACON:
 497     m = make_message<MOSDBeacon>();
 498     break;
 499   case MSG_OSD_PGTEMP:
 500     m = make_message<MOSDPGTemp>();
 501     break;
 502   case MSG_OSD_FAILURE:
 503     m = make_message<MOSDFailure>();
 504     break;
 505   case MSG_OSD_MARK_ME_DOWN:
 506     m = make_message<MOSDMarkMeDown>();
 507     break;
 508   case MSG_OSD_MARK_ME_DEAD:
 509     m = make_message<MOSDMarkMeDead>();
 510     break;
 511   case MSG_OSD_FULL:
 512     m = make_message<MOSDFull>();
 513     break;
 514   case MSG_OSD_PING:
 515     m = make_message<MOSDPing>();
 516     break;
 517   case CEPH_MSG_OSD_OP:
 518     m = make_message<MOSDOp>();
 519     break;
 520   case CEPH_MSG_OSD_OPREPLY:
 521     m = make_message<MOSDOpReply>();
 522     break;
 523   case MSG_OSD_REPOP:
 524     m = make_message<MOSDRepOp>();
 525     break;
 526   case MSG_OSD_REPOPREPLY:
 527     m = make_message<MOSDRepOpReply>();
 528     break;
 529   case MSG_OSD_PG_CREATED:
 530     m = make_message<MOSDPGCreated>();
 531     break;
 532   case MSG_OSD_PG_UPDATE_LOG_MISSING:
 533     m = make_message<MOSDPGUpdateLogMissing>();
 534     break;
 535   case MSG_OSD_PG_UPDATE_LOG_MISSING_REPLY:
 536     m = make_message<MOSDPGUpdateLogMissingReply>();
 537     break;
 538   case CEPH_MSG_OSD_BACKOFF:
 539     m = make_message<MOSDBackoff>();
 540     break;
 541
 542   case CEPH_MSG_OSD_MAP:
 543     m = make_message<MOSDMap>();
 544     break;
 545
 546   case CEPH_MSG_WATCH_NOTIFY:
 547     m = make_message<MWatchNotify>();
 548     break;
 549
 550   case MSG_OSD_PG_NOTIFY:
 551     m = make_message<MOSDPGNotify>();
 552     break;
 553   case MSG_OSD_PG_NOTIFY2:
 554     m = make_message<MOSDPGNotify2>();
 555     break;
 556   case MSG_OSD_PG_QUERY:
 557     m = make_message<MOSDPGQuery>();
 558     break;
 559   case MSG_OSD_PG_QUERY2:
 560     m = make_message<MOSDPGQuery2>();
 561     break;
 562   case MSG_OSD_PG_LOG:
 563     m = make_message<MOSDPGLog>();
 564     break;
 565   case MSG_OSD_PG_REMOVE:
 566     m = make_message<MOSDPGRemove>();
 567     break;
 568   case MSG_OSD_PG_INFO:
 569     m = make_message<MOSDPGInfo>();
 570     break;
 571   case MSG_OSD_PG_INFO2:
 572     m = make_message<MOSDPGInfo2>();
 573     break;
 574   case MSG_OSD_PG_CREATE2:
 575     m = make_message<MOSDPGCreate2>();
 576     break;
 577   case MSG_OSD_PG_TRIM:
 578     m = make_message<MOSDPGTrim>();
 579     break;
 580   case MSG_OSD_PG_LEASE:
 581     m = make_message<MOSDPGLease>();
 582     break;
 583   case MSG_OSD_PG_LEASE_ACK:
 584     m = make_message<MOSDPGLeaseAck>();
 585     break;
 586
 587   case MSG_OSD_SCRUB2:
 588     m = make_message<MOSDScrub2>();
 589     break;
 590   case MSG_OSD_SCRUB_RESERVE:
 591     m = make_message<MOSDScrubReserve>();
 592     break;
 593   case MSG_REMOVE_SNAPS:
 594     m = make_message<MRemoveSnaps>();
 595     break;
 596   case MSG_OSD_REP_SCRUB:
 597     m = make_message<MOSDRepScrub>();
 598     break;
 599   case MSG_OSD_REP_SCRUBMAP:
 600     m = make_message<MOSDRepScrubMap>();
 601     break;
 602   case MSG_OSD_PG_SCAN:
 603     m = make_message<MOSDPGScan>();
 604     break;
 605   case MSG_OSD_PG_BACKFILL:
 606     m = make_message<MOSDPGBackfill>();
 607     break;
 608   case MSG_OSD_PG_BACKFILL_REMOVE:
 609     m = make_message<MOSDPGBackfillRemove>();
 610     break;
 611   case MSG_OSD_PG_PUSH:
 612     m = make_message<MOSDPGPush>();
 613     break;
 614   case MSG_OSD_PG_PULL:
 615     m = make_message<MOSDPGPull>();
 616     break;
 617   case MSG_OSD_PG_PUSH_REPLY:
 618     m = make_message<MOSDPGPushReply>();
 619     break;
 620   case MSG_OSD_PG_RECOVERY_DELETE:
 621     m = make_message<MOSDPGRecoveryDelete>();
 622     break;
 623   case MSG_OSD_PG_RECOVERY_DELETE_REPLY:
 624     m = make_message<MOSDPGRecoveryDeleteReply>();
 625     break;
 626   case MSG_OSD_PG_READY_TO_MERGE:
 627     m = make_message<MOSDPGReadyToMerge>();
 628     break;
 629   case MSG_OSD_EC_WRITE:
 630     m = make_message<MOSDECSubOpWrite>();
 631     break;
 632   case MSG_OSD_EC_WRITE_REPLY:
 633     m = make_message<MOSDECSubOpWriteReply>();
 634     break;
 635   case MSG_OSD_EC_READ:
 636     m = make_message<MOSDECSubOpRead>();
 637     break;
 638   case MSG_OSD_EC_READ_REPLY:
 639     m = make_message<MOSDECSubOpReadReply>();
 640     break;
 641    // auth
 642   case CEPH_MSG_AUTH:
 643     m = make_message<MAuth>();
 644     break;
 645   case CEPH_MSG_AUTH_REPLY:
 646     m = make_message<MAuthReply>();
 647     break;
 648
 649   case MSG_MON_GLOBAL_ID:
 650     m = make_message<MMonGlobalID>();
 651     break;
 652   case MSG_MON_USED_PENDING_KEYS:
 653     m = make_message<MMonUsedPendingKeys>();
 654     break;
 655
 656     // clients
 657   case CEPH_MSG_MON_SUBSCRIBE:
 658     m = make_message<MMonSubscribe>();
 659     break;
 660   case CEPH_MSG_MON_SUBSCRIBE_ACK:
 661     m = make_message<MMonSubscribeAck>();
 662     break;
 663   case CEPH_MSG_CLIENT_SESSION:
 664     m = make_message<MClientSession>();
 665     break;
 666   case CEPH_MSG_CLIENT_RECONNECT:
 667     m = make_message<MClientReconnect>();
 668     break;
 669   case CEPH_MSG_CLIENT_REQUEST:
 670     m = make_message<MClientRequest>();
 671     break;
 672   case CEPH_MSG_CLIENT_REQUEST_FORWARD:
 673     m = make_message<MClientRequestForward>();
 674     break;
 675   case CEPH_MSG_CLIENT_REPLY:
 676     m = make_message<MClientReply>();
 677     break;
 678   case CEPH_MSG_CLIENT_RECLAIM:
 679     m = make_message<MClientReclaim>();
 680     break;
 681   case CEPH_MSG_CLIENT_RECLAIM_REPLY:
 682     m = make_message<MClientReclaimReply>();
 683     break;
 684   case CEPH_MSG_CLIENT_CAPS:
 685     m = make_message<MClientCaps>();
 686     break;
 687   case CEPH_MSG_CLIENT_CAPRELEASE:
 688     m = make_message<MClientCapRelease>();
 689     break;
 690   case CEPH_MSG_CLIENT_LEASE:
 691     m = make_message<MClientLease>();
 692     break;
 693   case CEPH_MSG_CLIENT_SNAP:
 694     m = make_message<MClientSnap>();
 695     break;
 696   case CEPH_MSG_CLIENT_QUOTA:
 697     m = make_message<MClientQuota>();
 698     break;
 699   case CEPH_MSG_CLIENT_METRICS:
 700     m = make_message<MClientMetrics>();
 701     break;
 702
 703     // mds
 704   case MSG_MDS_PEER_REQUEST:
 705     m = make_message<MMDSPeerRequest>();
 706     break;
 707
 708   case CEPH_MSG_MDS_MAP:
 709     m = make_message<MMDSMap>();
 710     break;
 711   case CEPH_MSG_FS_MAP:
 712     m = make_message<MFSMap>();
 713     break;
 714   case CEPH_MSG_FS_MAP_USER:
 715     m = make_message<MFSMapUser>();
 716     break;
 717   case MSG_MDS_BEACON:
 718     m = make_message<MMDSBeacon>();
 719     break;
 720   case MSG_MDS_OFFLOAD_TARGETS:
 721     m = make_message<MMDSLoadTargets>();
 722     break;
 723   case MSG_MDS_RESOLVE:
 724     m = make_message<MMDSResolve>();
 725     break;
 726   case MSG_MDS_RESOLVEACK:
 727     m = make_message<MMDSResolveAck>();
 728     break;
 729   case MSG_MDS_CACHEREJOIN:
 730     m = make_message<MMDSCacheRejoin>();
 731         break;
 732
 733   case MSG_MDS_DIRUPDATE:
 734     m = make_message<MDirUpdate>();
 735     break;
 736
 737   case MSG_MDS_DISCOVER:
 738     m = make_message<MDiscover>();
 739     break;
 740   case MSG_MDS_DISCOVERREPLY:
 741     m = make_message<MDiscoverReply>();
 742     break;
 743
 744   case MSG_MDS_FINDINO:
 745     m = make_message<MMDSFindIno>();
 746     break;
 747   case MSG_MDS_FINDINOREPLY:
 748     m = make_message<MMDSFindInoReply>();
 749     break;
 750
 751   case MSG_MDS_OPENINO:
 752     m = make_message<MMDSOpenIno>();
 753     break;
 754   case MSG_MDS_OPENINOREPLY:
 755     m = make_message<MMDSOpenInoReply>();
 756     break;
 757
 758   case MSG_MDS_SNAPUPDATE:
 759     m = make_message<MMDSSnapUpdate>();
 760     break;
 761
 762   case MSG_MDS_FRAGMENTNOTIFY:
 763     m = make_message<MMDSFragmentNotify>();
 764     break;
 765
 766   case MSG_MDS_FRAGMENTNOTIFYACK:
 767     m = make_message<MMDSFragmentNotifyAck>();
 768     break;
 769
 770   case MSG_MDS_SCRUB:
 771     m = make_message<MMDSScrub>();
 772     break;
 773
 774   case MSG_MDS_SCRUB_STATS:
 775     m = make_message<MMDSScrubStats>();
 776     break;
 777
 778   case MSG_MDS_EXPORTDIRDISCOVER:
 779     m = make_message<MExportDirDiscover>();
 780     break;
 781   case MSG_MDS_EXPORTDIRDISCOVERACK:
 782     m = make_message<MExportDirDiscoverAck>();
 783     break;
 784   case MSG_MDS_EXPORTDIRCANCEL:
 785     m = make_message<MExportDirCancel>();
 786     break;
 787
 788   case MSG_MDS_EXPORTDIR:
 789     m = make_message<MExportDir>();
 790     break;
 791   case MSG_MDS_EXPORTDIRACK:
 792     m = make_message<MExportDirAck>();
 793     break;
 794   case MSG_MDS_EXPORTDIRFINISH:
 795     m = make_message<MExportDirFinish>();
 796     break;
 797
 798   case MSG_MDS_EXPORTDIRNOTIFY:
 799     m = make_message<MExportDirNotify>();
 800     break;
 801
 802   case MSG_MDS_EXPORTDIRNOTIFYACK:
 803     m = make_message<MExportDirNotifyAck>();
 804     break;
 805
 806   case MSG_MDS_EXPORTDIRPREP:
 807     m = make_message<MExportDirPrep>();
 808     break;
 809
 810   case MSG_MDS_EXPORTDIRPREPACK:
 811     m = make_message<MExportDirPrepAck>();
 812     break;
 813
 814   case MSG_MDS_EXPORTCAPS:
 815     m = make_message<MExportCaps>();
 816     break;
 817   case MSG_MDS_EXPORTCAPSACK:
 818     m = make_message<MExportCapsAck>();
 819     break;
 820   case MSG_MDS_GATHERCAPS:
 821     m = make_message<MGatherCaps>();
 822     break;
 823
 824
 825   case MSG_MDS_DENTRYUNLINK_ACK:
 826     m = make_message<MDentryUnlinkAck>();
 827     break;
 828   case MSG_MDS_DENTRYUNLINK:
 829     m = make_message<MDentryUnlink>();
 830     break;
 831   case MSG_MDS_DENTRYLINK:
 832     m = make_message<MDentryLink>();
 833     break;
 834
 835   case MSG_MDS_HEARTBEAT:
 836     m = make_message<MHeartbeat>();
 837     break;
 838
 839   case MSG_MDS_CACHEEXPIRE:
 840     m = make_message<MCacheExpire>();
 841     break;
 842
 843   case MSG_MDS_TABLE_REQUEST:
 844     m = make_message<MMDSTableRequest>();
 845     break;
 846
 847         /*  case MSG_MDS_INODEUPDATE:
 848     m = make_message<MInodeUpdate>();
 849     break;
 850         */
 851
 852   case MSG_MDS_INODEFILECAPS:
 853     m = make_message<MInodeFileCaps>();
 854     break;
 855
 856   case MSG_MDS_LOCK:
 857     m = make_message<MLock>();
 858     break;
 859
 860   case MSG_MDS_METRICS:
 861     m = make_message<MMDSMetrics>();
 862     break;
 863
 864   case MSG_MDS_PING:
 865     m = make_message<MMDSPing>();
 866     break;
 867
 868   case MSG_MGR_BEACON:
 869     m = make_message<MMgrBeacon>();
 870     break;
 871
 872   case MSG_MON_MGR_REPORT:
 873     m = make_message<MMonMgrReport>();
 874     break;
 875
 876   case MSG_SERVICE_MAP:
 877     m = make_message<MServiceMap>();
 878     break;
 879
 880   case MSG_MGR_MAP:
 881     m = make_message<MMgrMap>();
 882     break;
 883
 884   case MSG_MGR_DIGEST:
 885     m = make_message<MMgrDigest>();
 886     break;
 887
 888   case MSG_MGR_COMMAND:
 889     m = make_message<MMgrCommand>();
 890     break;
 891
 892   case MSG_MGR_COMMAND_REPLY:
 893     m = make_message<MMgrCommandReply>();
 894     break;
 895
 896   case MSG_MGR_OPEN:
 897     m = make_message<MMgrOpen>();
 898     break;
 899
 900   case MSG_MGR_UPDATE:
 901     m = make_message<MMgrUpdate>();
 902     break;
 903
 904   case MSG_MGR_CLOSE:
 905     m = make_message<MMgrClose>();
 906     break;
 907
 908   case MSG_MGR_REPORT:
 909     m = make_message<MMgrReport>();
 910     break;
 911
 912   case MSG_MGR_CONFIGURE:
 913     m = make_message<MMgrConfigure>();
 914     break;
 915
 916   case MSG_TIMECHECK:
 917     m = make_message<MTimeCheck>();
 918     break;
 919   case MSG_TIMECHECK2:
 920     m = make_message<MTimeCheck2>();
 921     break;
 922
 923   case MSG_MON_HEALTH:
 924     m = make_message<MMonHealth>();
 925     break;
 926
 927   case MSG_MON_HEALTH_CHECKS:
 928     m = make_message<MMonHealthChecks>();
 929     break;
 930
 931     // -- simple messages without payload --
 932
 933   case CEPH_MSG_SHUTDOWN:
 934     m = make_message<MGenericMessage>(type);
 935     break;
 936
 937   default:
 938     if (cct) {
 939       ldout(cct, 0) << "can't decode unknown message type " << type << " MSG_AUTH=" << CEPH_MSG_AUTH << dendl;
 940       if (cct->_conf->ms_die_on_bad_msg)
 941         ceph_abort();
 942     }
 943     return 0;
 944   }
 945
 946   m->set_cct(cct);
 947
 948   // m->header.version, if non-zero, should be populated with the
 949   // newest version of the encoding the code supports.  If set, check
 950   // it against compat_version.
 951   if (m->get_header().version &&
 952       m->get_header().version < header.compat_version) {
 953     if (cct) {
 954       ldout(cct, 0) << "will not decode message of type " << type
 955                     << " version " << header.version
 956                     << " because compat_version " << header.compat_version
 957                     << " > supported version " << m->get_header().version << dendl;
 958       if (cct->_conf->ms_die_on_bad_msg)
 959         ceph_abort();
 960     }
 961     return 0;
 962   }
 963
 964   m->set_connection(std::move(conn));
 965   m->set_header(header);
 966   m->set_footer(footer);
 967   m->set_payload(front);
 968   m->set_middle(middle);
 969   m->set_data(data);
 970
 971   try {
 972     m->decode_payload();
 973   }
 974   catch (const ceph::buffer::error &e) {
 975     if (cct) {
 976       lderr(cct) << "failed to decode message of type " << type
 977                  << " v" << header.version
 978                  << ": " << e.what() << dendl;
 979       ldout(cct, ceph::dout::need_dynamic(
 980         cct->_conf->ms_dump_corrupt_message_level)) << "dump: \n";
 981       m->get_payload().hexdump(*_dout);
 982       *_dout << dendl;
 983       if (cct->_conf->ms_die_on_bad_msg)
 984         ceph_abort();
 985     }
 986     return 0;
 987   }
 988
 989   // done!
 990   return m.detach();
 991 }
 992
 993 void Message::encode_trace(ceph::bufferlist &bl, uint64_t features) const
 994 {
 995   using ceph::encode;
 996   auto p = trace.get_info();
 997   static const blkin_trace_info empty = { 0, 0, 0 };
 998   if (!p) {
 999     p = &empty;
1000   }
1001   encode(*p, bl);
1002 }
1003
1004 void Message::decode_trace(ceph::bufferlist::const_iterator &p, bool create)
1005 {
1006   blkin_trace_info info = {};
1007   decode(info, p);
1008
1009 #ifdef WITH_BLKIN
1010   if (!connection)
1011     return;
1012
1013   const auto msgr = connection->get_messenger();
1014   const auto endpoint = msgr->get_trace_endpoint();
1015   if (info.trace_id) {
1016     trace.init(get_type_name().data(), endpoint, &info, true);
1017     trace.event("decoded trace");
1018   } else if (create || (msgr->get_myname().is_osd() &&
1019                         msgr->cct->_conf->osd_blkin_trace_all)) {
1020     // create a trace even if we didn't get one on the wire
1021     trace.init(get_type_name().data(), endpoint);
1022     trace.event("created trace");
1023   }
1024   trace.keyval("tid", get_tid());
1025   trace.keyval("entity type", get_source().type_str());
1026   trace.keyval("entity num", get_source().num());
1027 #endif
1028 }
1029
1030
1031 // This routine is not used for ordinary messages, but only when encapsulating a message
1032 // for forwarding and routing.  It's also used in a backward compatibility test, which only
1033 // effectively tests backward compability for those functions.  To avoid backward compatibility
1034 // problems, we currently always encode and decode using the old footer format that doesn't
1035 // allow for message authentication.  Eventually we should fix that.  PLR
1036
1037 void encode_message(Message *msg, uint64_t features, ceph::bufferlist& payload)
1038 {
1039   ceph_msg_footer_old old_footer;
1040   msg->encode(features, MSG_CRC_ALL);
1041   encode(msg->get_header(), payload);
1042
1043   // Here's where we switch to the old footer format.  PLR
1044   ceph_msg_footer footer = msg->get_footer();
1045   old_footer.front_crc = footer.front_crc;
1046   old_footer.middle_crc = footer.middle_crc;
1047   old_footer.data_crc = footer.data_crc;
1048   old_footer.flags = footer.flags;
1049   encode(old_footer, payload);
1050
1051   using ceph::encode;
1052   encode(msg->get_payload(), payload);
1053   encode(msg->get_middle(), payload);
1054   encode(msg->get_data(), payload);
1055 }
1056
1057 // See above for somewhat bogus use of the old message footer.  We switch to the current footer
1058 // after decoding the old one so the other form of decode_message() doesn't have to change.
1059 // We've slipped in a 0 signature at this point, so any signature checking after this will
1060 // fail.  PLR
1061
1062 Message *decode_message(CephContext *cct, int crcflags, ceph::bufferlist::const_iterator& p)
1063 {
1064   ceph_msg_header h;
1065   ceph_msg_footer_old fo;
1066   ceph_msg_footer f;
1067   ceph::bufferlist fr, mi, da;
1068   decode(h, p);
1069   decode(fo, p);
1070   f.front_crc = fo.front_crc;
1071   f.middle_crc = fo.middle_crc;
1072   f.data_crc = fo.data_crc;
1073   f.flags = fo.flags;
1074   f.sig = 0;
1075   using ceph::decode;
1076   decode(fr, p);
1077   decode(mi, p);
1078   decode(da, p);
1079   return decode_message(cct, crcflags, h, f, fr, mi, da, nullptr);
1080 }