oceanbase

ob_signal_handle.cpp
262 строки · 7.4 Кб
Перенос по словам
1
/**
2
 * Copyright (c) 2021 OceanBase
3
 * OceanBase CE is licensed under Mulan PubL v2.
4
 * You can use this software according to the terms and conditions of the Mulan PubL v2.
5
 * You may obtain a copy of Mulan PubL v2 at:
6
 *          http://license.coscl.org.cn/MulanPubL-2.0
7
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
8
 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
9
 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
10
 * See the Mulan PubL v2 for more details.
11
 */
12

13
#define USING_LOG_PREFIX SERVER
14

15
#include "observer/ob_signal_handle.h"
16

17
#include "io/easy_log.h"
18

19
#include "share/ob_define.h"
20
#include "share/ob_errno.h"
21
#include "lib/allocator/ob_malloc.h"
22
#include "lib/profile/ob_profile_log.h"
23
#include "lib/profile/ob_perf_event.h"
24
#include "lib/profile/ob_atomic_event.h"
25
#include "lib/signal/ob_signal_struct.h"
26
#include "storage/memtable/ob_memtable.h"
27
#include "observer/ob_server.h"
28
#include "observer/ob_dump_task_generator.h"
29
#include "sql/ob_sql_init.h"
30
#include "lib/allocator/ob_pcounter.h"
31
#include "storage/tx_storage/ob_tenant_memory_printer.h"
32

33
namespace oceanbase
34
{
35
using namespace common;
36
using namespace storage;
37
namespace observer
38
{
39

40
void ObSignalHandle::run1()
41
{
42

43

44
  int ret = OB_SUCCESS;
45
  lib::set_thread_name("SignalHandle");
46
  sigset_t   waitset;
47
  if (OB_FAIL(add_signums_to_set(waitset))) {
48
    LOG_ERROR("Add signal set error", K(ret));
49
  } else {
50
    int signum = -1;
51
    //to check _stop every second
52
    struct timespec timeout = {1, 0};
53
    while (!has_set_stop()) {//need not to check ret
54
      {
55
        oceanbase::lib::Thread::WaitGuard guard(oceanbase::lib::Thread::WAIT);
56
        signum = sigtimedwait(&waitset, NULL, &timeout);
57
      }
58
      if (-1 == signum) {
59
        //do not log error, because timeout will also return -1.
60
      } else if (OB_FAIL(deal_signals(signum))) {
61
        LOG_WARN("Deal signal error", K(ret), K(signum));
62
      } else {
63
        //do nothing
64
      }
65
    }
66
  }
67
}
68

69
int ObSignalHandle::change_signal_mask()
70
{
71
  int ret = OB_SUCCESS;
72
  sigset_t block_set, old_set;
73
  if (OB_FAIL(add_signums_to_set(block_set))) {
74
    LOG_ERROR("Add signal set error", K(ret));
75
  } else if (0 != pthread_sigmask(SIG_BLOCK, &block_set, &old_set)) {
76
    ret = OB_ERR_UNEXPECTED;
77
    LOG_ERROR("Fail to change mask of blcked signals", K(ret));
78
  } else {
79
    //do nothing
80
  }
81
  return ret;
82
}
83

84
int ObSignalHandle::add_signums_to_set(sigset_t &sig_set)
85
{
86
  int ret = OB_SUCCESS;
87
  if (0 != sigemptyset(&sig_set)) {
88
    ret = OB_ERR_UNEXPECTED;
89
    LOG_ERROR("Empty signal set error", K(ret));
90
  } else {
91
    int rc = 0;
92
    int signals[] = {SIGPIPE, SIGTERM, SIGUSR1,
93
                     40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
94
                     50, 51, 52, 53, 55, 56, 57, 59, 60, 62,
95
                     63, 64};
96
    for (int64_t i = 0; OB_SUCC(ret) && i < ARRAYSIZEOF(signals); ++i) {
97
      if (0 != (rc = sigaddset(&sig_set, signals[i]))) {
98
        ret = OB_ERR_UNEXPECTED;
99
        LOG_ERROR("failed to add signal to block", "signum", signals[i], K(ret), K(rc));
100
      }
101
    }
102
  }
103
  return ret;
104
}
105

106
//signal http://blog.csdn.net/yiyeguzhou100/article/details/51316175
107
int ObSignalHandle::deal_signals(int signum)
108
{
109
  int ret = OB_SUCCESS;
110
  LOG_INFO("received signal", K(signum));
111
  switch (signum)
112
  {
113
    case SIGPIPE: {
114
      break;
115
    }
116
    case SIGTERM: {
117
      raise(SIGKILL);
118
      break;
119
    }
120
    case SIGUSR1: {
121
      ObServer::get_instance().prepare_stop();
122
      ObServer::get_instance().set_stop();
123
      break;
124
    }
125
    case 40: {
126
      OB_LOGGER.check_file();
127
      break;
128
    }
129
    case 41: {
130
      int64_t version = ::oceanbase::common::ObTimeUtility::current_time();
131
      OB_LOGGER.down_log_level(version);
132
      // ASYNC_LOG_LOGGER.down_log_level();
133
      //to echo info when change to warn level
134
      LOG_WARN("Signal 41 down ObLogger level", "current level", OB_LOGGER.get_level());
135
      break;
136
    }
137
    case 42: {
138
      int64_t version = ::oceanbase::common::ObTimeUtility::current_time();
139
      OB_LOGGER.up_log_level(version);
140
      // ASYNC_LOG_LOGGER.up_log_level();
141
      LOG_WARN("Signal 42 up ObLogger level", "current level", OB_LOGGER.get_level());
142
      break;
143
    }
144
    case 43: {  // toggle atomic operation profiler
145
      if (OB_ATOMIC_EVENT_IS_ENABLED()) {
146
        OB_DISABLE_ATOMIC_EVENT();
147
        LOG_WARN("atomic operation profiler disabled, see `atomic.pfda'");
148
      } else {
149
        OB_ENABLE_ATOMIC_EVENT();
150
        LOG_WARN("atomic operation profiler enabled");
151
      }
152
      break;
153
    }
154
    case 45: {
155
      if (OB_ISNULL(ObProfileLogger::getInstance())) {
156
        ret = OB_ERR_UNEXPECTED;
157
        LOG_ERROR("ObProfileLogger instance should not be NULL", K(ret));
158
      } else {
159
        ObProfileLogger::getInstance()->setLogLevel("INFO");
160
      }
161
      break;
162
    }
163
    case 46: {
164
      if (OB_ISNULL(ObProfileLogger::getInstance())) {
165
        ret = OB_ERR_UNEXPECTED;
166
        LOG_ERROR("ObProfileLogger instance should not be NULL", K(ret));
167
      } else {
168
        ObProfileLogger::getInstance()->setLogLevel("DEBUG");
169
      }
170
      break;
171
    }
172
    case 47: {
173
      easy_log_level = static_cast<easy_log_level_t>(static_cast<int>(easy_log_level) + 1);
174
      LOG_INFO("libeasy log level changed", K(easy_log_level));
175
      break;
176
    }
177
    case 48: {
178
      easy_log_level = static_cast<easy_log_level_t>(static_cast<int>(easy_log_level) - 1);
179
      LOG_INFO("libeasy log level changed", K(easy_log_level));
180
      break;
181
    }
182
    case 49: {
183
      ob_print_mod_memory_usage();
184
      //GARL_PRINT();
185
      PC_REPORT();
186
      ObTenantMemoryPrinter::get_instance().print_tenant_usage();
187
      break;
188
    }
189
    case 50: {
190
      ENABLE_PERF_EVENT();
191
      LOG_WARN("perf event enabled");
192
      break;
193
    }
194
    case 51: {
195
      DISABLE_PERF_EVENT();
196
      LOG_WARN("perf event disabled");
197
      break;
198
    }
199
    case 53: {
200
      // debug SQL modules
201
      if (OB_FAIL(
202
          ObLogger::get_logger().set_mod_log_levels("ALL.*:ERROR, SQL.*:DEBUG, RPC.*:WARN"))) {
203
        LOG_WARN("Set mod log level error", K(ret));
204
      }
205
      break;
206
    }
207
    case 55: {
208
      if (OB_ISNULL(ObServer::get_instance().get_gctx().omt_)) {
209
        ret = OB_ERR_UNEXPECTED;
210
        LOG_ERROR("ObMultiTenant in global context should not be NULL", K(ret));
211
      } else {
212
        ObServer::get_instance().get_gctx().omt_->set_cpu_dump();
213
        LOG_INFO("CPU_DUMP: switch on");
214
      }
215
      break;
216
    }
217
    case 56: {
218
      if (OB_ISNULL(ObServer::get_instance().get_gctx().omt_)) {
219
        ret = OB_ERR_UNEXPECTED;
220
        LOG_ERROR("ObMultiTenant in global context should not be NULL", K(ret));
221
      } else {
222
        ObServer::get_instance().get_gctx().omt_->unset_cpu_dump();
223
        LOG_INFO("CPU_DUMP: switch off");
224
      }
225
      break;
226
    }
227
    case 57: {
228
      // clog::ObBatchSubmitMockTest::handle_signal();
229
      break;
230
    }
231
    case 59: {               // similar to 49, verbose mode
232
      ob_print_mod_memory_usage(false, true);
233
      sql::print_sql_stat();
234
      break;
235
    }
236
    case 60: {
237
    #ifndef OB_USE_ASAN
238
      send_request_and_wait(VERB_LEVEL_1,
239
                            syscall(SYS_gettid)/*exclude_id*/);
240
    #endif
241
      break;
242
    }
243
    case 62: {
244
      //RESP_DUMP_TRACE_TO_FILE();
245
      ObDumpTaskGenerator::generate_task_from_file();
246
      break;
247
    }
248
    case 63: {
249
      // print tenant memstore consumption condition by wenduo.swd
250
      ObTenantMemoryPrinter::get_instance().print_tenant_usage();
251
      break;
252
    }
253
    default: {
254
      LOG_WARN("Ignore unknown signal", K(signum));
255
      break;
256
    }
257
  }
258
  return ret;
259
}
260

261
}
262
}
263
oceanbase

Использование cookies
