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