#if 0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace DB { namespace ErrorCodes { extern const int ILLEGAL_COLUMN; extern const int ILLEGAL_TYPE_OF_ARGUMENT; extern const int BAD_ARGUMENTS; extern const int CANNOT_ALLOCATE_MEMORY; extern const int CANNOT_DLOPEN; extern const int LOGICAL_ERROR; } /// Various illegal actions to test diagnostic features of ClickHouse itself. Should not be enabled in production builds. class FunctionTrap : public IFunction { private: ContextPtr context; public: static constexpr auto name = "trap"; static FunctionPtr create(ContextPtr context) { return std::make_shared(context); } FunctionTrap(ContextPtr context_) : context(context_) {} String getName() const override { return name; } size_t getNumberOfArguments() const override { return 1; } bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; } DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { if (!isString(arguments[0])) throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "The only argument for function {} must be constant String", getName()); return std::make_shared(); } [[clang::optnone]] ColumnPtr executeImpl(const ColumnsWithTypeAndName & block, const DataTypePtr & result_type, size_t input_rows_count) const override { if (const ColumnConst * column = checkAndGetColumnConst(block[0].column.get())) { String mode = column->getValue(); if (mode == "read nullptr c++") { volatile int x = *reinterpret_cast(0); (void)x; } else if (mode == "read nullptr asm") { __asm__ volatile ("movq $0, %rax"); __asm__ volatile ("movq (%rax), %rax"); } else if (mode == "illegal instruction") { __asm__ volatile ("ud2a"); } else if (mode == "abort") { abort(); } else if (mode == "std::terminate") { std::terminate(); } else if (mode == "use after free") { int * x_ptr; { auto x = std::make_unique(); x_ptr = x.get(); } *x_ptr = 1; (void)x_ptr; } else if (mode == "use after scope") { volatile int * x_ptr; [&]{ volatile int x = 0; x_ptr = &x; (void)x; }(); [&]{ volatile int y = 1; *x_ptr = 2; (void)y; }(); (void)x_ptr; } else if (mode == "uninitialized memory") { int x; (void)write(2, &x, sizeof(x)); } else if (mode == "data race") { int x = 0; std::thread t1([&]{ ++x; }); std::thread t2([&]{ ++x; }); t1.join(); t2.join(); } else if (mode == "throw exception") { std::vector().at(0); } else if (mode == "access context") { (void)context->getCurrentQueryId(); } else if (mode == "stack overflow") { executeImpl(block, result_type, input_rows_count); } else if (mode == "harmful function") { double res = drand48(); (void)res; } else if (mode == "mmap many") { std::vector maps; SCOPE_EXIT( { //for (void * map : maps) // munmap(map, 4096); }); while (true) { void * hint = reinterpret_cast( std::uniform_int_distribution(0x100000000000UL, 0x700000000000UL)(thread_local_rng)); void * map = mmap(hint, 4096, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); if (MAP_FAILED == map) throwFromErrno("Allocator: Cannot mmap", ErrorCodes::CANNOT_ALLOCATE_MEMORY); maps.push_back(map); } } else if (mode == "dlopen") { void * handle = dlopen("libc.so.6", RTLD_NOW); if (!handle) throw Exception(ErrorCodes::CANNOT_DLOPEN, "Cannot dlopen: ({})", dlerror()); // NOLINT(concurrency-mt-unsafe) // MT-Safe on Linux, see man dlerror } else if (mode == "logical error") { throw Exception(ErrorCodes::LOGICAL_ERROR, "Logical error: trap"); } else throw Exception(ErrorCodes::BAD_ARGUMENTS, "Unknown trap mode"); } else throw Exception(ErrorCodes::ILLEGAL_COLUMN, "The only argument for function {} must be constant String", getName()); return result_type->createColumnConst(input_rows_count, 0ULL); } }; REGISTER_FUNCTION(Trap) { factory.registerFunction(); } } #endif