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/MOSDPGCreate.h"
  89 #include "messages/MOSDPGCreate2.h"
  90 #include "messages/MOSDPGTrim.h"
  91 #include "messages/MOSDPGLease.h"
  92 #include "messages/MOSDPGLeaseAck.h"
  93 #include "messages/MOSDScrub.h"
  94 #include "messages/MOSDScrub2.h"
  95 #include "messages/MOSDScrubReserve.h"
  96 #include "messages/MOSDRepScrub.h"
  97 #include "messages/MOSDRepScrubMap.h"
  98 #include "messages/MOSDForceRecovery.h"
  99 #include "messages/MOSDPGScan.h"
 100 #include "messages/MOSDPGBackfill.h"
 101 #include "messages/MOSDBackoff.h"
 102 #include "messages/MOSDPGBackfillRemove.h"
 103 #include "messages/MOSDPGRecoveryDelete.h"
 104 #include "messages/MOSDPGRecoveryDeleteReply.h"
 105 #include "messages/MOSDPGReadyToMerge.h"
 106
 107 #include "messages/MRemoveSnaps.h"
 108
 109 #include "messages/MMonMap.h"
 110 #include "messages/MMonGetMap.h"
 111 #include "messages/MMonGetVersion.h"
 112 #include "messages/MMonGetVersionReply.h"
 113 #include "messages/MMonHealth.h"
 114 #include "messages/MMonHealthChecks.h"
 115 #include "messages/MAuth.h"
 116 #include "messages/MAuthReply.h"
 117 #include "messages/MMonSubscribe.h"
 118 #include "messages/MMonSubscribeAck.h"
 119 #include "messages/MMonGlobalID.h"
 120 #include "messages/MClientSession.h"
 121 #include "messages/MClientReconnect.h"
 122 #include "messages/MClientRequest.h"
 123 #include "messages/MClientRequestForward.h"
 124 #include "messages/MClientReply.h"
 125 #include "messages/MClientReclaim.h"
 126 #include "messages/MClientReclaimReply.h"
 127 #include "messages/MClientCaps.h"
 128 #include "messages/MClientCapRelease.h"
 129 #include "messages/MClientLease.h"
 130 #include "messages/MClientSnap.h"
 131 #include "messages/MClientQuota.h"
 132 #include "messages/MClientMetrics.h"
 133
 134 #include "messages/MMDSPeerRequest.h"
 135
 136 #include "messages/MMDSMap.h"
 137 #include "messages/MFSMap.h"
 138 #include "messages/MFSMapUser.h"
 139 #include "messages/MMDSBeacon.h"
 140 #include "messages/MMDSLoadTargets.h"
 141 #include "messages/MMDSResolve.h"
 142 #include "messages/MMDSResolveAck.h"
 143 #include "messages/MMDSCacheRejoin.h"
 144 #include "messages/MMDSFindIno.h"
 145 #include "messages/MMDSFindInoReply.h"
 146 #include "messages/MMDSOpenIno.h"
 147 #include "messages/MMDSOpenInoReply.h"
 148 #include "messages/MMDSSnapUpdate.h"
 149 #include "messages/MMDSScrub.h"
 150 #include "messages/MMDSScrubStats.h"
 151
 152 #include "messages/MDirUpdate.h"
 153 #include "messages/MDiscover.h"
 154 #include "messages/MDiscoverReply.h"
 155
 156 #include "messages/MMDSFragmentNotify.h"
 157 #include "messages/MMDSFragmentNotifyAck.h"
 158
 159 #include "messages/MExportDirDiscover.h"
 160 #include "messages/MExportDirDiscoverAck.h"
 161 #include "messages/MExportDirCancel.h"
 162 #include "messages/MExportDirPrep.h"
 163 #include "messages/MExportDirPrepAck.h"
 164 #include "messages/MExportDir.h"
 165 #include "messages/MExportDirAck.h"
 166 #include "messages/MExportDirNotify.h"
 167 #include "messages/MExportDirNotifyAck.h"
 168 #include "messages/MExportDirFinish.h"
 169
 170 #include "messages/MExportCaps.h"
 171 #include "messages/MExportCapsAck.h"
 172 #include "messages/MGatherCaps.h"
 173
 174
 175 #include "messages/MDentryUnlink.h"
 176 #include "messages/MDentryLink.h"
 177
 178 #include "messages/MHeartbeat.h"
 179
 180 #include "messages/MMDSTableRequest.h"
 181 #include "messages/MMDSMetrics.h"
 182 #include "messages/MMDSPing.h"
 183
 184 //#include "messages/MInodeUpdate.h"
 185 #include "messages/MCacheExpire.h"
 186 #include "messages/MInodeFileCaps.h"
 187
 188 #include "messages/MMgrBeacon.h"
 189 #include "messages/MMgrMap.h"
 190 #include "messages/MMgrDigest.h"
 191 #include "messages/MMgrReport.h"
 192 #include "messages/MMgrOpen.h"
 193 #include "messages/MMgrUpdate.h"
 194 #include "messages/MMgrClose.h"
 195 #include "messages/MMgrConfigure.h"
 196 #include "messages/MMonMgrReport.h"
 197 #include "messages/MMgrCommand.h"
 198 #include "messages/MMgrCommandReply.h"
 199 #include "messages/MServiceMap.h"
 200
 201 #include "messages/MLock.h"
 202
 203 #include "messages/MWatchNotify.h"
 204 #include "messages/MTimeCheck.h"
 205 #include "messages/MTimeCheck2.h"
 206
 207 #include "common/config.h"
 208
 209 #include "messages/MOSDPGPush.h"
 210 #include "messages/MOSDPGPushReply.h"
 211 #include "messages/MOSDPGPull.h"
 212
 213 #include "messages/MOSDECSubOpWrite.h"
 214 #include "messages/MOSDECSubOpWriteReply.h"
 215 #include "messages/MOSDECSubOpRead.h"
 216 #include "messages/MOSDECSubOpReadReply.h"
 217
 218 #include "messages/MOSDPGUpdateLogMissing.h"
 219 #include "messages/MOSDPGUpdateLogMissingReply.h"
 220
 221 #ifdef WITH_BLKIN
 222 #include "Messenger.h"
 223 #endif
 224
 225 #define DEBUGLVL  10    // debug level of output
 226
 227 #define dout_subsys ceph_subsys_ms
 228
 229 void Message::encode(uint64_t features, int crcflags, bool skip_header_crc)
 230 {
 231   // encode and copy out of *m
 232   if (empty_payload()) {
 233     ceph_assert(middle.length() == 0);
 234     encode_payload(features);
 235
 236     if (byte_throttler) {
 237       byte_throttler->take(payload.length() + middle.length());
 238     }
 239
 240     // if the encoder didn't specify past compatibility, we assume it
 241     // is incompatible.
 242     if (header.compat_version == 0)
 243       header.compat_version = header.version;
 244   }
 245   if (crcflags & MSG_CRC_HEADER)
 246     calc_front_crc();
 247
 248   // update envelope
 249   header.front_len = get_payload().length();
 250   header.middle_len = get_middle().length();
 251   header.data_len = get_data().length();
 252   if (!skip_header_crc && (crcflags & MSG_CRC_HEADER))
 253     calc_header_crc();
 254
 255   footer.flags = CEPH_MSG_FOOTER_COMPLETE;
 256
 257   if (crcflags & MSG_CRC_DATA) {
 258     calc_data_crc();
 259
 260 #ifdef ENCODE_DUMP
 261     bufferlist bl;
 262     encode(get_header(), bl);
 263
 264     // dump the old footer format
 265     ceph_msg_footer_old old_footer;
 266     old_footer.front_crc = footer.front_crc;
 267     old_footer.middle_crc = footer.middle_crc;
 268     old_footer.data_crc = footer.data_crc;
 269     old_footer.flags = footer.flags;
 270     encode(old_footer, bl);
 271
 272     encode(get_payload(), bl);
 273     encode(get_middle(), bl);
 274     encode(get_data(), bl);
 275
 276     // this is almost an exponential backoff, except because we count
 277     // bits we tend to sample things we encode later, which should be
 278     // more representative.
 279     static int i = 0;
 280     i++;
 281     int bits = 0;
 282     for (unsigned t = i; t; bits++)
 283       t &= t - 1;
 284     if (bits <= 2) {
 285       char fn[200];
 286       int status;
 287       snprintf(fn, sizeof(fn), ENCODE_STRINGIFY(ENCODE_DUMP) "/%s__%d.%x",
 288                abi::__cxa_demangle(typeid(*this).name(), 0, 0, &status),
 289                getpid(), i++);
 290       int fd = ::open(fn, O_WRONLY|O_TRUNC|O_CREAT|O_CLOEXEC|O_BINARY, 0644);
 291       if (fd >= 0) {
 292         bl.write_fd(fd);
 293         ::close(fd);
 294       }
 295     }
 296 #endif
 297   } else {
 298     footer.flags = (unsigned)footer.flags | CEPH_MSG_FOOTER_NOCRC;
 299   }
 300 }
 301
 302 void Message::dump(ceph::Formatter *f) const
 303 {
 304   std::stringstream ss;
 305   print(ss);
 306   f->dump_string("summary", ss.str());
 307 }
 308
 309 Message *decode_message(CephContext *cct,
 310                         int crcflags,
 311                         ceph_msg_header& header,
 312                         ceph_msg_footer& footer,
 313                         ceph::bufferlist& front,
 314                         ceph::bufferlist& middle,
 315                         ceph::bufferlist& data,
 316                         Message::ConnectionRef conn)
 317 {
 318   // verify crc
 319   if (crcflags & MSG_CRC_HEADER) {
 320     __u32 front_crc = front.crc32c(0);
 321     __u32 middle_crc = middle.crc32c(0);
 322
 323     if (front_crc != footer.front_crc) {
 324       if (cct) {
 325         ldout(cct, 0) << "bad crc in front " << front_crc << " != exp " << footer.front_crc
 326                       << " from " << conn->get_peer_addr() << dendl;
 327         ldout(cct, 20) << " ";
 328         front.hexdump(*_dout);
 329         *_dout << dendl;
 330       }
 331       return 0;
 332     }
 333     if (middle_crc != footer.middle_crc) {
 334       if (cct) {
 335         ldout(cct, 0) << "bad crc in middle " << middle_crc << " != exp " << footer.middle_crc
 336                       << " from " << conn->get_peer_addr() << dendl;
 337         ldout(cct, 20) << " ";
 338         middle.hexdump(*_dout);
 339         *_dout << dendl;
 340       }
 341       return 0;
 342     }
 343   }
 344   if (crcflags & MSG_CRC_DATA) {
 345     if ((footer.flags & CEPH_MSG_FOOTER_NOCRC) == 0) {
 346       __u32 data_crc = data.crc32c(0);
 347       if (data_crc != footer.data_crc) {
 348         if (cct) {
 349           ldout(cct, 0) << "bad crc in data " << data_crc << " != exp " << footer.data_crc
 350                         << " from " << conn->get_peer_addr() << dendl;
 351           ldout(cct, 20) << " ";
 352           data.hexdump(*_dout);
 353           *_dout << dendl;
 354         }
 355         return 0;
 356       }
 357     }
 358   }
 359
 360   // make message
 361   ceph::ref_t<Message> m;
 362   int type = header.type;
 363   switch (type) {
 364
 365     // -- with payload --
 366
 367     using ceph::make_message;
 368
 369   case MSG_PGSTATS:
 370     m = make_message<MPGStats>();
 371     break;
 372   case MSG_PGSTATSACK:
 373     m = make_message<MPGStatsAck>();
 374     break;
 375
 376   case CEPH_MSG_STATFS:
 377     m = make_message<MStatfs>();
 378     break;
 379   case CEPH_MSG_STATFS_REPLY:
 380     m = make_message<MStatfsReply>();
 381     break;
 382   case MSG_GETPOOLSTATS:
 383     m = make_message<MGetPoolStats>();
 384     break;
 385   case MSG_GETPOOLSTATSREPLY:
 386     m = make_message<MGetPoolStatsReply>();
 387     break;
 388   case CEPH_MSG_POOLOP:
 389     m = make_message<MPoolOp>();
 390     break;
 391   case CEPH_MSG_POOLOP_REPLY:
 392     m = make_message<MPoolOpReply>();
 393     break;
 394   case MSG_MON_COMMAND:
 395     m = make_message<MMonCommand>();
 396     break;
 397   case MSG_MON_COMMAND_ACK:
 398     m = make_message<MMonCommandAck>();
 399     break;
 400   case MSG_MON_PAXOS:
 401     m = make_message<MMonPaxos>();
 402     break;
 403   case MSG_CONFIG:
 404     m = make_message<MConfig>();
 405     break;
 406   case MSG_GET_CONFIG:
 407     m = make_message<MGetConfig>();
 408     break;
 409   case MSG_KV_DATA:
 410     m = make_message<MKVData>();
 411     break;
 412
 413   case MSG_MON_PROBE:
 414     m = make_message<MMonProbe>();
 415     break;
 416   case MSG_MON_JOIN:
 417     m = make_message<MMonJoin>();
 418     break;
 419   case MSG_MON_ELECTION:
 420     m = make_message<MMonElection>();
 421     break;
 422   case MSG_MON_SYNC:
 423     m = make_message<MMonSync>();
 424     break;
 425   case MSG_MON_PING:
 426     m = make_message<MMonPing>();
 427     break;
 428   case MSG_MON_SCRUB:
 429     m = make_message<MMonScrub>();
 430     break;
 431
 432   case MSG_LOG:
 433     m = make_message<MLog>();
 434     break;
 435   case MSG_LOGACK:
 436     m = make_message<MLogAck>();
 437     break;
 438
 439   case CEPH_MSG_PING:
 440     m = make_message<MPing>();
 441     break;
 442   case MSG_COMMAND:
 443     m = make_message<MCommand>();
 444     break;
 445   case MSG_COMMAND_REPLY:
 446     m = make_message<MCommandReply>();
 447     break;
 448   case MSG_OSD_BACKFILL_RESERVE:
 449     m = make_message<MBackfillReserve>();
 450     break;
 451   case MSG_OSD_RECOVERY_RESERVE:
 452     m = make_message<MRecoveryReserve>();
 453     break;
 454   case MSG_OSD_FORCE_RECOVERY:
 455     m = make_message<MOSDForceRecovery>();
 456     break;
 457
 458   case MSG_ROUTE:
 459     m = make_message<MRoute>();
 460     break;
 461   case MSG_FORWARD:
 462     m = make_message<MForward>();
 463     break;
 464
 465   case CEPH_MSG_MON_MAP:
 466     m = make_message<MMonMap>();
 467     break;
 468   case CEPH_MSG_MON_GET_MAP:
 469     m = make_message<MMonGetMap>();
 470     break;
 471   case CEPH_MSG_MON_GET_OSDMAP:
 472     m = make_message<MMonGetOSDMap>();
 473     break;
 474   case MSG_MON_GET_PURGED_SNAPS:
 475     m = make_message<MMonGetPurgedSnaps>();
 476     break;
 477   case MSG_MON_GET_PURGED_SNAPS_REPLY:
 478     m = make_message<MMonGetPurgedSnapsReply>();
 479     break;
 480   case CEPH_MSG_MON_GET_VERSION:
 481     m = make_message<MMonGetVersion>();
 482     break;
 483   case CEPH_MSG_MON_GET_VERSION_REPLY:
 484     m = make_message<MMonGetVersionReply>();
 485     break;
 486
 487   case MSG_OSD_BOOT:
 488     m = make_message<MOSDBoot>();
 489     break;
 490   case MSG_OSD_ALIVE:
 491     m = make_message<MOSDAlive>();
 492     break;
 493   case MSG_OSD_BEACON:
 494     m = make_message<MOSDBeacon>();
 495     break;
 496   case MSG_OSD_PGTEMP:
 497     m = make_message<MOSDPGTemp>();
 498     break;
 499   case MSG_OSD_FAILURE:
 500     m = make_message<MOSDFailure>();
 501     break;
 502   case MSG_OSD_MARK_ME_DOWN:
 503     m = make_message<MOSDMarkMeDown>();
 504     break;
 505   case MSG_OSD_MARK_ME_DEAD:
 506     m = make_message<MOSDMarkMeDead>();
 507     break;
 508   case MSG_OSD_FULL:
 509     m = make_message<MOSDFull>();
 510     break;
 511   case MSG_OSD_PING:
 512     m = make_message<MOSDPing>();
 513     break;
 514   case CEPH_MSG_OSD_OP:
 515     m = make_message<MOSDOp>();
 516     break;
 517   case CEPH_MSG_OSD_OPREPLY:
 518     m = make_message<MOSDOpReply>();
 519     break;
 520   case MSG_OSD_REPOP:
 521     m = make_message<MOSDRepOp>();
 522     break;
 523   case MSG_OSD_REPOPREPLY:
 524     m = make_message<MOSDRepOpReply>();
 525     break;
 526   case MSG_OSD_PG_CREATED:
 527     m = make_message<MOSDPGCreated>();
 528     break;
 529   case MSG_OSD_PG_UPDATE_LOG_MISSING:
 530     m = make_message<MOSDPGUpdateLogMissing>();
 531     break;
 532   case MSG_OSD_PG_UPDATE_LOG_MISSING_REPLY:
 533     m = make_message<MOSDPGUpdateLogMissingReply>();
 534     break;
 535   case CEPH_MSG_OSD_BACKOFF:
 536     m = make_message<MOSDBackoff>();
 537     break;
 538
 539   case CEPH_MSG_OSD_MAP:
 540     m = make_message<MOSDMap>();
 541     break;
 542
 543   case CEPH_MSG_WATCH_NOTIFY:
 544     m = make_message<MWatchNotify>();
 545     break;
 546
 547   case MSG_OSD_PG_NOTIFY:
 548     m = make_message<MOSDPGNotify>();
 549     break;
 550   case MSG_OSD_PG_NOTIFY2:
 551     m = make_message<MOSDPGNotify2>();
 552     break;
 553   case MSG_OSD_PG_QUERY:
 554     m = make_message<MOSDPGQuery>();
 555     break;
 556   case MSG_OSD_PG_QUERY2:
 557     m = make_message<MOSDPGQuery2>();
 558     break;
 559   case MSG_OSD_PG_LOG:
 560     m = make_message<MOSDPGLog>();
 561     break;
 562   case MSG_OSD_PG_REMOVE:
 563     m = make_message<MOSDPGRemove>();
 564     break;
 565   case MSG_OSD_PG_INFO:
 566     m = make_message<MOSDPGInfo>();
 567     break;
 568   case MSG_OSD_PG_INFO2:
 569     m = make_message<MOSDPGInfo2>();
 570     break;
 571   case MSG_OSD_PG_CREATE:
 572     m = make_message<MOSDPGCreate>();
 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_SCRUB:
 588     m = make_message<MOSDScrub>();
 589     break;
 590   case MSG_OSD_SCRUB2:
 591     m = make_message<MOSDScrub2>();
 592     break;
 593   case MSG_OSD_SCRUB_RESERVE:
 594     m = make_message<MOSDScrubReserve>();
 595     break;
 596   case MSG_REMOVE_SNAPS:
 597     m = make_message<MRemoveSnaps>();
 598     break;
 599   case MSG_OSD_REP_SCRUB:
 600     m = make_message<MOSDRepScrub>();
 601     break;
 602   case MSG_OSD_REP_SCRUBMAP:
 603     m = make_message<MOSDRepScrubMap>();
 604     break;
 605   case MSG_OSD_PG_SCAN:
 606     m = make_message<MOSDPGScan>();
 607     break;
 608   case MSG_OSD_PG_BACKFILL:
 609     m = make_message<MOSDPGBackfill>();
 610     break;
 611   case MSG_OSD_PG_BACKFILL_REMOVE:
 612     m = make_message<MOSDPGBackfillRemove>();
 613     break;
 614   case MSG_OSD_PG_PUSH:
 615     m = make_message<MOSDPGPush>();
 616     break;
 617   case MSG_OSD_PG_PULL:
 618     m = make_message<MOSDPGPull>();
 619     break;
 620   case MSG_OSD_PG_PUSH_REPLY:
 621     m = make_message<MOSDPGPushReply>();
 622     break;
 623   case MSG_OSD_PG_RECOVERY_DELETE:
 624     m = make_message<MOSDPGRecoveryDelete>();
 625     break;
 626   case MSG_OSD_PG_RECOVERY_DELETE_REPLY:
 627     m = make_message<MOSDPGRecoveryDeleteReply>();
 628     break;
 629   case MSG_OSD_PG_READY_TO_MERGE:
 630     m = make_message<MOSDPGReadyToMerge>();
 631     break;
 632   case MSG_OSD_EC_WRITE:
 633     m = make_message<MOSDECSubOpWrite>();
 634     break;
 635   case MSG_OSD_EC_WRITE_REPLY:
 636     m = make_message<MOSDECSubOpWriteReply>();
 637     break;
 638   case MSG_OSD_EC_READ:
 639     m = make_message<MOSDECSubOpRead>();
 640     break;
 641   case MSG_OSD_EC_READ_REPLY:
 642     m = make_message<MOSDECSubOpReadReply>();
 643     break;
 644    // auth
 645   case CEPH_MSG_AUTH:
 646     m = make_message<MAuth>();
 647     break;
 648   case CEPH_MSG_AUTH_REPLY:
 649     m = make_message<MAuthReply>();
 650     break;
 651
 652   case MSG_MON_GLOBAL_ID:
 653     m = make_message<MMonGlobalID>();
 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:
 826     m = make_message<MDentryUnlink>();
 827     break;
 828   case MSG_MDS_DENTRYLINK:
 829     m = make_message<MDentryLink>();
 830     break;
 831
 832   case MSG_MDS_HEARTBEAT:
 833     m = make_message<MHeartbeat>();
 834     break;
 835
 836   case MSG_MDS_CACHEEXPIRE:
 837     m = make_message<MCacheExpire>();
 838     break;
 839
 840   case MSG_MDS_TABLE_REQUEST:
 841     m = make_message<MMDSTableRequest>();
 842     break;
 843
 844         /*  case MSG_MDS_INODEUPDATE:
 845     m = make_message<MInodeUpdate>();
 846     break;
 847         */
 848
 849   case MSG_MDS_INODEFILECAPS:
 850     m = make_message<MInodeFileCaps>();
 851     break;
 852
 853   case MSG_MDS_LOCK:
 854     m = make_message<MLock>();
 855     break;
 856
 857   case MSG_MDS_METRICS:
 858     m = make_message<MMDSMetrics>();
 859     break;
 860
 861   case MSG_MDS_PING:
 862     m = make_message<MMDSPing>();
 863     break;
 864
 865   case MSG_MGR_BEACON:
 866     m = make_message<MMgrBeacon>();
 867     break;
 868
 869   case MSG_MON_MGR_REPORT:
 870     m = make_message<MMonMgrReport>();
 871     break;
 872
 873   case MSG_SERVICE_MAP:
 874     m = make_message<MServiceMap>();
 875     break;
 876
 877   case MSG_MGR_MAP:
 878     m = make_message<MMgrMap>();
 879     break;
 880
 881   case MSG_MGR_DIGEST:
 882     m = make_message<MMgrDigest>();
 883     break;
 884
 885   case MSG_MGR_COMMAND:
 886     m = make_message<MMgrCommand>();
 887     break;
 888
 889   case MSG_MGR_COMMAND_REPLY:
 890     m = make_message<MMgrCommandReply>();
 891     break;
 892
 893   case MSG_MGR_OPEN:
 894     m = make_message<MMgrOpen>();
 895     break;
 896
 897   case MSG_MGR_UPDATE:
 898     m = make_message<MMgrUpdate>();
 899     break;
 900
 901   case MSG_MGR_CLOSE:
 902     m = make_message<MMgrClose>();
 903     break;
 904
 905   case MSG_MGR_REPORT:
 906     m = make_message<MMgrReport>();
 907     break;
 908
 909   case MSG_MGR_CONFIGURE:
 910     m = make_message<MMgrConfigure>();
 911     break;
 912
 913   case MSG_TIMECHECK:
 914     m = make_message<MTimeCheck>();
 915     break;
 916   case MSG_TIMECHECK2:
 917     m = make_message<MTimeCheck2>();
 918     break;
 919
 920   case MSG_MON_HEALTH:
 921     m = make_message<MMonHealth>();
 922     break;
 923
 924   case MSG_MON_HEALTH_CHECKS:
 925     m = make_message<MMonHealthChecks>();
 926     break;
 927
 928     // -- simple messages without payload --
 929
 930   case CEPH_MSG_SHUTDOWN:
 931     m = make_message<MGenericMessage>(type);
 932     break;
 933
 934   default:
 935     if (cct) {
 936       ldout(cct, 0) << "can't decode unknown message type " << type << " MSG_AUTH=" << CEPH_MSG_AUTH << dendl;
 937       if (cct->_conf->ms_die_on_bad_msg)
 938         ceph_abort();
 939     }
 940     return 0;
 941   }
 942
 943   m->set_cct(cct);
 944
 945   // m->header.version, if non-zero, should be populated with the
 946   // newest version of the encoding the code supports.  If set, check
 947   // it against compat_version.
 948   if (m->get_header().version &&
 949       m->get_header().version < header.compat_version) {
 950     if (cct) {
 951       ldout(cct, 0) << "will not decode message of type " << type
 952                     << " version " << header.version
 953                     << " because compat_version " << header.compat_version
 954                     << " > supported version " << m->get_header().version << dendl;
 955       if (cct->_conf->ms_die_on_bad_msg)
 956         ceph_abort();
 957     }
 958     return 0;
 959   }
 960
 961   m->set_connection(std::move(conn));
 962   m->set_header(header);
 963   m->set_footer(footer);
 964   m->set_payload(front);
 965   m->set_middle(middle);
 966   m->set_data(data);
 967
 968   try {
 969     m->decode_payload();
 970   }
 971   catch (const ceph::buffer::error &e) {
 972     if (cct) {
 973       lderr(cct) << "failed to decode message of type " << type
 974                  << " v" << header.version
 975                  << ": " << e.what() << dendl;
 976       ldout(cct, ceph::dout::need_dynamic(
 977         cct->_conf->ms_dump_corrupt_message_level)) << "dump: \n";
 978       m->get_payload().hexdump(*_dout);
 979       *_dout << dendl;
 980       if (cct->_conf->ms_die_on_bad_msg)
 981         ceph_abort();
 982     }
 983     return 0;
 984   }
 985
 986   // done!
 987   return m.detach();
 988 }
 989
 990 void Message::encode_trace(ceph::bufferlist &bl, uint64_t features) const
 991 {
 992   using ceph::encode;
 993   auto p = trace.get_info();
 994   static const blkin_trace_info empty = { 0, 0, 0 };
 995   if (!p) {
 996     p = &empty;
 997   }
 998   encode(*p, bl);
 999 }
1000
1001 void Message::decode_trace(ceph::bufferlist::const_iterator &p, bool create)
1002 {
1003   blkin_trace_info info = {};
1004   decode(info, p);
1005
1006 #ifdef WITH_BLKIN
1007   if (!connection)
1008     return;
1009
1010   const auto msgr = connection->get_messenger();
1011   const auto endpoint = msgr->get_trace_endpoint();
1012   if (info.trace_id) {
1013     trace.init(get_type_name().data(), endpoint, &info, true);
1014     trace.event("decoded trace");
1015   } else if (create || (msgr->get_myname().is_osd() &&
1016                         msgr->cct->_conf->osd_blkin_trace_all)) {
1017     // create a trace even if we didn't get one on the wire
1018     trace.init(get_type_name().data(), endpoint);
1019     trace.event("created trace");
1020   }
1021   trace.keyval("tid", get_tid());
1022   trace.keyval("entity type", get_source().type_str());
1023   trace.keyval("entity num", get_source().num());
1024 #endif
1025 }
1026
1027
1028 // This routine is not used for ordinary messages, but only when encapsulating a message
1029 // for forwarding and routing.  It's also used in a backward compatibility test, which only
1030 // effectively tests backward compability for those functions.  To avoid backward compatibility
1031 // problems, we currently always encode and decode using the old footer format that doesn't
1032 // allow for message authentication.  Eventually we should fix that.  PLR
1033
1034 void encode_message(Message *msg, uint64_t features, ceph::bufferlist& payload)
1035 {
1036   ceph_msg_footer_old old_footer;
1037   msg->encode(features, MSG_CRC_ALL);
1038   encode(msg->get_header(), payload);
1039
1040   // Here's where we switch to the old footer format.  PLR
1041   ceph_msg_footer footer = msg->get_footer();
1042   old_footer.front_crc = footer.front_crc;
1043   old_footer.middle_crc = footer.middle_crc;
1044   old_footer.data_crc = footer.data_crc;
1045   old_footer.flags = footer.flags;
1046   encode(old_footer, payload);
1047
1048   using ceph::encode;
1049   encode(msg->get_payload(), payload);
1050   encode(msg->get_middle(), payload);
1051   encode(msg->get_data(), payload);
1052 }
1053
1054 // See above for somewhat bogus use of the old message footer.  We switch to the current footer
1055 // after decoding the old one so the other form of decode_message() doesn't have to change.
1056 // We've slipped in a 0 signature at this point, so any signature checking after this will
1057 // fail.  PLR
1058
1059 Message *decode_message(CephContext *cct, int crcflags, ceph::bufferlist::const_iterator& p)
1060 {
1061   ceph_msg_header h;
1062   ceph_msg_footer_old fo;
1063   ceph_msg_footer f;
1064   ceph::bufferlist fr, mi, da;
1065   decode(h, p);
1066   decode(fo, p);
1067   f.front_crc = fo.front_crc;
1068   f.middle_crc = fo.middle_crc;
1069   f.data_crc = fo.data_crc;
1070   f.flags = fo.flags;
1071   f.sig = 0;
1072   using ceph::decode;
1073   decode(fr, p);
1074   decode(mi, p);
1075   decode(da, p);
1076   return decode_message(cct, crcflags, h, f, fr, mi, da, nullptr);
1077 }