Ars Longa, Vita Brevis

Сброс дискового кеша в Linux

2012-05-19T17:55:07Z

При проведении различных тестов иногда бывает весьма полезно очистить дисковый кеш.

Делается это так:

sudo sh -c 'sync; echo 3 > /proc/sys/vm/drop_caches'

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

Доступ к закрытым свойствам класса в PHP

2012-05-14T15:06:43Z

Крутили гайку номер шесть ключом на восемнадцать…

Иногда встречаются ситуации, когда нужно расширить функциональность класса сторонней библиотеки; при этом нужный класс реализован так, что вместо наследования проще переписать, ибо функциональность завязана на закрытых (private) свойствах класса, для которых он не предоставляет акцессоров.

Чтобы далеко не ходить за примером, можно посмотреть на реализацию работы с базой данных в Yii — если требуется что-то нестандартное и не предусмотренное разработчиками — придётся извращаться. Например, если нужно добавить поддержку SELECT … FOR UPDATE/SELECT … LOCK IN SHARE MODE (кстати, весьма нужный довесок для высоконагруженных сайтов с активной работой с базой данных), кажется вполне логичным унаследоваться от класса CDbCommand и добавить свои методы для организации блокировки и переопределить метод buildQuery. В теории это выглядит хорошо, но на практике имеем, что вся функциональность завязана на закрытое свойство CDbCommand::_q, в котором хранятся все параметры запроса. Кроме того, для поддержки этого хозяйства в Active Record придётся унаследоваться от CActiveRecord, а там такая же петрушка.

На правах лирического отступления: при всей моей любви к Yii, некоторые архитектурные решения выглядят весьма непродуманными и вызывают во мне любимый жест капитана Пикара: множественные косяки с закрытыми свойствами, проверки method_exists() идут вразрез с идеологией CComponent (например, использование mixin (behavior) как метода форматирования в класс, порождённый от CFormatter, закончится исключением), неудачное разбиение на методы, из-за которого наследование временами превращается в копипаст и т.д.

PHP — это не C++, поэтому антипаттерн Паблик Морозов (#define private public) здесь не пройдёт. К счастью, костылестроение в PHP поставлено на поток, поэтому решение всё же есть…

В PHP есть достаточно мощное Reflection API (хотя местами плохо документированное), позволяющее разработчику творить чудеса.

Например, есть у нас такой фрагмент класса:

class CDbCommand extends CComponent
{
private $_query;
}

API этого класса не предоставляет никакого доступа к закрытому свойству $_query, но, тем не менее, доступ к нему очень нужен, чтобы не переписывать большую часть исходного класса.

Для начала нужно создать отражение класса: $reflected = new ReflectionClass($this);
Затем нужно переместиться в класс-предок: $reflected = $reflected=>getParentClass();
Потом получаем свойство $_query: $p_query = $reflected->getProperty('_query');
После чего делаем его доступным для чтения/изменения через Reflection API: $p_query->setAccessible(true);

Чтение свойства: $p_query->getValue($this);
Изменение свойства: $p_query->setValue($this, $new_value);

Полный пример (с минимальным количеством кода):

class DbCommand extends CDbCommand
{
const LOCK_SHARED = 'r';
const LOCK_EXCLUSIVE = 'w';

private $p_query;

public function __construct(CDbConnection $connection, $query = null)
{
parent::__construct($connection, $query);

$reflected = new ReflectionClass($this);
$reflected = $reflected->getParentClass();
$this->p_query = $reflected->getProperty('_query');
$this->p_query->setAccessible(true);
}

public function sharedLock()
{
$v = $this->p_query->getValue($this);
$v['lock'] = self::LOCK_SHARED;
$this->p_query->setValue($this, $v);
}
}

При использовании Reflection API в конструкторе для получения информации о родительском классе следует помнить о значении $this: если у класса нет детей, то $this будет соответствовать данному классу; если же потомки есть и создаётся именно класс-потомок, то $this будет соответствовать именно тому потомку.

Решить это можно так:

$reflected = new ReflectionClass($this);
$me = strtlower(__CLASS__);
while (strtolower($reflected->getName()) != $me) {
$reflected = $reflected->getParentClass();
}

Безусловно, Reflection API в PHP — мощный инструмент, но, как и все подобные инструменты, применять его нужно осторожно и с умом

Отслеживание источника исключения в С++

2012-04-30T02:51:57Z

Лезем в глубокие дебри C++ и его ABI

Обобщённая версия статьи «Отслеживание источника исключения в Qt».

Решение проблемы отлова не пойманного исключения при помощи gdb — задача не из приятных, особенно при отладке многопоточных приложений. К счастью, есть и более простой способ.

Чтобы понять, как организована работа с исключениями на уровне стандартной библиотеки, нужно тщательно выкурить ABI языка C++, в частности, главу, посвящённую обработке исключений.

Из всей главы нам интересны две функции:

void __cxa_throw (void *thrown_exception, std::type_info *tinfo, void (*dest) (void *) );
void __cxa_rethrow ();

Первая функция кидает исключение (thrown_exception — кидаемое исключение, tinfo — указатель на информацию о типе исключения (тип std::type_info определён в заголовке <typeinfo>), dest — указатель на деструктор исключения). В принципе, единственное, что нам может быть полезно — это tinfo: tinfo->name() даст нам имя типа исключения.

Имя исключения будет иметь вид St13runtime_error (mangled name); для декодирования можно использовать функцию

extern "C" char* abi::__cxa_demangle (const char* mangled_name, char* buf, size_t* n, int* status);

char* demangled = abi:: __cxa_demangle(tinfo->name(), 0, 0, 0);
std::cerr << "Thrown exception of type " << (demangled ? demangled : tinfo->name()) << std::endl;
if (demangled) {
std::free(demangled);
}

При большом желании можно проверить, наследуется ли брошенное исключение от std::exception; если да, то можно вывести на экран значение exception::what(). Проблема здесь в том, что thrown_exception типа void* — как следствие, dynamic_cast не сработает. Поэтому для такой магии придётся разбираться, как работает dynamic_cast.

Если вкратце, на помощь приходит функция

extern "C" void* __dynamic_cast (const void *sub, const abi::__class_type_info *src, const abi::__class_type_info *dst, std::ptrdiff_t src2dst_offset);

Алгоритм тут такой:

Проверить, является ли tinfo экземпляром класса abi::__class_type_info; если нет, то брошенное исключение — не объект.
Привести &typeid(std::exception) к типу const abi::__class_type_info* (преобразование просто должно сработать).
Вызвав __dynamic_cast, проверить, унаследовано ли thrown_exception от std::exception.

const abi::__class_type_info* exc = dynamic_cast<const abi::__class_type_info*>(&typeid(std::exception));
const abi::__class_type_info* cti = dynamic_cast<abi::__class_type_info*>(tinfo);
if (cti && exc) {
std::exception* the_exception = reinterpret_cast<std::exception*>(abi::__dynamic_cast(thrown_exception, exc, cti, -1));
if (the_exception) {
std::cout << the_exception->what() << std::endl;
}
}

Осталось получить backtrace. Здесь нет ничего сложного.

Вторая функция (__cxa_rethrow) вызывается из catch-блока и кидает обрабатываемое исключение ещё раз. Так как у функции нет аргументов (совсем нет), то бросаемое исключение придётся получать самостоятельно. Для этого используется функция

extern "C" __cxa_eh_globals *__cxa_get_globals(void); struct __cxa_eh_globals { __cxa_exception* caughtExceptions; unsigned int uncaughtExceptions; };

__cxa_exception — заголовок исключения; непосредственно за ним следует бросаемый объект.

__cxa_eh_globals* g = __cxa_get_globals();
if (g && g->caughtExceptions) {
void* thrown_exception = reinterpret_cast<uint8_t*>(g->caughtExceptions) + sizeof(struct __cxa_exception);
std::type_info* tinfo = g->caughtExceptions->exceptionType;

// Далее всё аналогично __cxa_throw
}

Всё готово, дело за малым: перехватить вызовы __cxa_throw и __cxa_rethrow. Тут всё просто:

#include <dlfcn.h>

typedef void(*cxa_throw_type)(void* , std::type_info*, void(*)(void*));
typedef void(*cxa_rethrow_type)(void);

cxa_throw_type orig_cxa_throw = reinterpret_cast<cxa_throw_type>(dlsym(RTLD_NEXT, "__cxa_throw"));
cxa_rethrow_type orig_cxa_rethrow = reinterpret_cast<cxa_rethrow_type>(dlsym(RTLD_NEXT, "__cxa_rethrow"));

А теперь всё вместе:

#include <typeinfo>
#include <exception>
#include <dlfcn.h>
#include <pthread.h>
#include <cstdio>
#include <cstdlib>
#include <inttypes.h>
#include <execinfo.h>
#include <cxxabi.h> // Определяет типы из namespace abi
#include <cstring>
#include <stdexcept>
#include <unistd.h>

namespace { // Важно: без анонимного пространства имён gcc начинает клинить

typedef uint64_t uint64; // В документации тип зовётся uint64

// Типы/структуры данных из http://sourcery.mentor.com/public/cxx-abi/abi-eh.html
typedef enum {
_URC_NO_REASON = 0,
_URC_FOREIGN_EXCEPTION_CAUGHT = 1,
_URC_FATAL_PHASE2_ERROR = 2,
_URC_FATAL_PHASE1_ERROR = 3,
_URC_NORMAL_STOP = 4,
_URC_END_OF_STACK = 5,
_URC_HANDLER_FOUND = 6,
_URC_INSTALL_CONTEXT = 7,
_URC_CONTINUE_UNWIND = 8
} _Unwind_Reason_Code;

typedef void (*_Unwind_Exception_Cleanup_Fn)(_Unwind_Reason_Code reason, struct _Unwind_Exception* exc);

struct _Unwind_Exception {
uint64 exception_class;
_Unwind_Exception_Cleanup_Fn exception_cleanup;
uint64 private_1;
uint64 private_2;
};

struct __cxa_exception {
std::type_info* exceptionType;
void (*exceptionDestructor)(void*);
std::unexpected_handler unexpectedHandler;
std::terminate_handler terminateHandler;
__cxa_exception* nextException;
int handlerCount;
int handlerSwitchValue;
const char* actionRecord;
const char* languageSpecificData;
void* catchTemp;
void* adjustedPtr;
_Unwind_Exception unwindHeader;
};

struct __cxa_eh_globals {
__cxa_exception* caughtExceptions;
unsigned int uncaughtExceptions;
};

extern "C" __cxa_eh_globals* __cxa_get_globals(void);

// Тип функции __cxa_throw
typedef void(*cxa_throw_type)(void*, std::type_info*, void(*)(void*));
// Тип функции __cxa_rethrow
typedef void(*cxa_rethrow_type)(void);

static cxa_throw_type orig_cxa_throw = 0; // Адрес оригинальной функции __cxa_throw
static cxa_rethrow_type orig_cxa_rethrow = 0; // Адрес оригинальной функции __cxa_rethrow

static pthread_mutex_t guard = PTHREAD_MUTEX_INITIALIZER; // Мьютекс на всякий пожарный

// Получение трассы вызовов
// Здесь и далее сознательно используются функции из стандартной библиотеки C, так как они не генерируют исключений
// Исключение в низкоуровневом обработчике исключения - это что-то
static void get_backtrace(void)
{
static void* buf[128];

int n = backtrace(buf, 128);
std::fprintf(stderr, "%s\n", "*** BACKTRACE ***");
backtrace_symbols_fd(buf, n, STDERR_FILENO);

// Код, приведённый далее, предполагает наличие программ readlink и addr2line
// идея состоит в скармливании адресов, полученных backtrace(3), addr2line(1)
// с целью получения понятного человеку результата
std::size_t bufsize = 19*n + std::strlen("/usr/bin/addr2line -pifCa -e `/bin/readlink /proc/XXXXX/exe` 1>&2") + 1;
char* space = reinterpret_cast<char*>(std::calloc(bufsize, 1));
if (space) {
char* orig = space;
int c = std::sprintf(space, "/usr/bin/addr2line -pifCa -e `/bin/readlink /proc/%d/exe` ", getpid());
space += c;
for (int i=0; i<n; ++i) {
c = std::sprintf(space, "%p ", buf[i]);
space += c;
}

std::fprintf(stderr, "%s\n", "\n*** DECODED BACKTRACE ***");
std::sprintf(space, "%s", "1>&2");

std::fprintf(stderr, "%s\n", orig);
if (std::system(orig)) {} // Чтобы не ругался gcc
std::free(orig);
}
}

// Обработка исключения, общая для __cxz_throw и __cxa_rethrow
static void handle_exception(void* thrown_exception, std::type_info* tinfo, bool rethrown)
{
char* demangled = abi:: __cxa_demangle(tinfo->name(), 0, 0, 0);
std::fprintf(stderr, "%s exception of type %s\n", (rethrown ? "Rethrown" : "Thrown"), (demangled ? demangled : tinfo->name()));
if (demangled) {
std::free(demangled);
}

const abi::__class_type_info* exc = dynamic_cast<const abi::__class_type_info*>(&typeid(std::exception));
const abi::__class_type_info* cti = dynamic_cast<abi::__class_type_info*>(tinfo);

if (cti && exc) {
std::exception* the_exception = reinterpret_cast<std::exception*>(abi::__dynamic_cast(thrown_exception, exc, cti, -1));
if (the_exception) {
std::fprintf(stderr, "what(): %s\n", the_exception->what());
}
}

get_backtrace();
std::fprintf(stderr, "\n\n");
}

extern "C" void __cxa_throw(void* thrown_exception, std::type_info* tinfo, void (*dest)(void*))
{
pthread_mutex_lock(&guard);
handle_exception(thrown_exception, tinfo, false);
pthread_mutex_unlock(&guard);

if (orig_cxa_throw) {
orig_cxa_throw(thrown_exception, tinfo, dest);
}
else {
std::terminate();
}
}

extern "C" void __cxa_rethrow(void)
{
pthread_mutex_lock(&guard);
__cxa_eh_globals* g = __cxa_get_globals();
if (g && g->caughtExceptions) {
void* thrown_exception = reinterpret_cast<uint8_t*>(g->caughtExceptions) + sizeof(struct __cxa_exception);
handle_exception(thrown_exception, g->caughtExceptions->exceptionType, true);
}

pthread_mutex_unlock(&guard);

if (orig_cxa_rethrow) {
orig_cxa_rethrow();
}
else {
std::terminate();
}
}

// Инициализация переменных. Можно сделать это и в обработчике, но так безопаснее
static void initialize(void)
{
orig_cxa_throw = reinterpret_cast<cxa_throw_type>(dlsym(RTLD_NEXT, "__cxa_throw"));
orig_cxa_rethrow = reinterpret_cast<cxa_rethrow_type>(dlsym(RTLD_NEXT, "__cxa_rethrow"));
}

}

int main(int, char**)
{
initialize();

try {
try {
throw std::runtime_error("123");
}
catch (const std::exception& e) {
std::printf("e.what(): %s\n", e.what());
throw;
}
}
catch (const std::exception& d) {
std::printf("d.what(): %s\n", d.what());
}

try {
throw 1;
}
catch (int x) {
std::printf("%d\n", x);
}

return 0;
}

Пример работы (у меня в оригинале кода нет комментариев, так что номера строк будут отличаться):

$ g++ test.cpp -O2 -g -o test -ldl
$ ./test
Thrown exception of type std::runtime_error
what(): 123
*** BACKTRACE ***
./test[0x401127]
./test(__cxa_throw+0x33)[0x401303]
./test[0x40141f]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xed)[0x7f3c05c2576d]
./test[0x400fa9]

*** DECODED BACKTRACE ***
/usr/bin/addr2line -pifCa -e `/bin/readlink /proc/4387/exe` 0x401127 0x401303 0x40141f 0x7f3c05c2576d 0x400fa9 1>&2
0x0000000000401127: fprintf at /usr/include/x86_64-linux-gnu/bits/stdio2.h:99
(inlined by) get_backtrace at /home/vladimir/test/test.cpp:73
(inlined by) handle_exception at /home/vladimir/test/test.cpp:114
0x0000000000401303: __cxa_throw at /home/vladimir/test/test.cpp:122
0x000000000040141f: main at /home/vladimir/test/test.cpp:167
0x00007f3c05c2576d: ??
??:0
0x0000000000400fa9: _start at ??:0

e.what(): 123
Rethrown exception of type std::runtime_error
what(): 123
*** BACKTRACE ***
./test[0x401127]
./test(__cxa_rethrow+0x31)[0x401371]
./test[0x4014de]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xed)[0x7f3c05c2576d]
./test[0x400fa9]

*** DECODED BACKTRACE ***
/usr/bin/addr2line -pifCa -e `/bin/readlink /proc/4387/exe` 0x401127 0x401371 0x4014de 0x7f3c05c2576d 0x400fa9 1>&2
0x0000000000401127: fprintf at /usr/include/x86_64-linux-gnu/bits/stdio2.h:99
(inlined by) get_backtrace at /home/vladimir/test/test.cpp:73
(inlined by) handle_exception at /home/vladimir/test/test.cpp:114
0x0000000000401371: __cxa_rethrow at /home/vladimir/test/test.cpp:141
0x00000000004014de: main at /home/vladimir/test/test.cpp:179
0x00007f3c05c2576d: ??
??:0
0x0000000000400fa9: _start at ??:0

d.what(): 123
Thrown exception of type int
*** BACKTRACE ***
./test[0x401127]
./test(__cxa_throw+0x33)[0x401303]
./test[0x4014b7]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xed)[0x7f3c05c2576d]
./test[0x400fa9]

*** DECODED BACKTRACE ***
/usr/bin/addr2line -pifCa -e `/bin/readlink /proc/4387/exe` 0x401127 0x401303 0x4014b7 0x7f3c05c2576d 0x400fa9 1>&2
0x0000000000401127: fprintf at /usr/include/x86_64-linux-gnu/bits/stdio2.h:99
(inlined by) get_backtrace at /home/vladimir/test/test.cpp:73
(inlined by) handle_exception at /home/vladimir/test/test.cpp:114
0x0000000000401303: __cxa_throw at /home/vladimir/test/test.cpp:122
0x00000000004014b7: main at /home/vladimir/test/test.cpp:167
0x00007f3c05c2576d: ??
??:0
0x0000000000400fa9: _start at ??:0

1

Для proof of concept очень даже неплохо.

Совмещение различных конфигураций сборок при использовании qmake

2012-04-28T23:45:14Z

Недокументированные костыли qmake

В продолжение темы одновременной сборки взаимно несовместимых конфигураций.

В предыдущей записи было показано, что qmake позволяет собирать одновременно взаимно несовместимые конфигурации, как-то: отладочная и релиз-версия приложения, статическая и динамическая версия библиотеки.

Тем не менее, без лишних телодвижений совместить несколько конфигураций сборок (например, отладочная и релиз-версия статической и динамической библиотеки) проблематично.

В частности, если задать такую конфигурацию:

CONFIG += static_and_shared debug_and_release build_all

qmake сгенерирует только каталоги debug и release, хотя и создаст все пять Makefile:

$ ls -1
debug
Makefile
Makefile.SharedDebug
Makefile.SharedRelease
Makefile.StaticDebug
Makefile.StaticRelease
release

Выполнив make, видим, что с таким подходом результат может быть весьма непредсказуемым: в моём случае сначала собиралась цель shared-release, затем shared-debug, затем из объектных файлов, собранных для цели shared-release, собиралась статическая библиотека для цели static-release; аналогично со static-debug.

Плохо это по крайней мере по двум причинам:

Ломается параллельная сборка: при сборке библиотеки может случиться ситуация, когда смешиваются по-разному скомпилированные объектные файлы (например, с и без PIC); в лучшем случае получим предупреждение от компоновщика (что-нибудь загадочное вида error: /tmp/ccdxxjfh.ltrans1.ltrans.o: requires dynamic R_X86_64_PC32 reloc against 'vtable for ClassName' which may overflow at runtime; recompile with -fPIC), в худшем — столкнёмся с весьма интересными ошибками
Однозадачная сборка зависит от порядка сборки целей: например, если собирать сначала статическую цель, затем — динамическую, и если при этом статическая библиотека явно не экспортирует функции (например, собирается с -fvisibility=hidden), то динамическая цель, собранная из файлов для статической цели, может оказаться неработоспособной.

Причина, по которой это происходит, лежит в недрах qmake: всё дело в том, что сборка несовместимых конфигураций является неким костылём. Костыльность эта заключается именно в обработке целей:

начальная конфигурация: static_and_shared debug_and_release build_all
изначально имеем пустую переменную OBJECTS_DIR
qmake начинает с релизной сборки из debug_and_release
обработка первой цели (Release) поместит в OBJECTS_DIR значение release
qmake обрабатывает «вложенную» сборку: shared из static_and_shared
костыль: qmake предполагает, что предыдущей сборки либо не было (OBJECTS_DIR и компания пусты — в этом случае каталог для временных файлов будет совпадать с именем сборки, в нашем случае это shared), либо конфигурация предыдущей сборки была «антиподом» текущей (то есть static в данном случае) — тогда в OBJECTS_DIR и сопуствующих переменных static заменяется на shared. Но проблема тут в том, что предыдущая конфигурация была release, а не static; как следствие, замена не получится, каталогом для временных файлов останется release
затем обрабатывается конфигурация debug; в OBJECTS_DIR release успешно заменяется на debug
затем обрабатывается подконфигурация shared; OBJECTS_DIR остаётся без изменений
краткий итог: конфигурация release/shared собрана в release, debug/shared — в debug
затем обрабатывается конфигурация static; OBJECTS_DIR опять остаётся без изменений (debug)
обрабатывается подконфигурация release; в OBJECTS_DIR debug успешно заменяется на release; в результате static/release будет собираться в release, где собиралась конфигурация release/shared
совершенно аналогично static/debug будет собираться в debug, где собиралась конфигурация debug/shared

Временные файлы (в зависимости от их типа) помещаются в каталоги, указанные переменными OBJECTS_DIR, MOC_DIR и RCC_DIR.

Для того, чтобы сборка прошла успешно, нужно устанавливать их значения самостоятельно.

У меня получилось так:

CONFIG += static_and_shared debug_and_release build_all

debug: TARGET = $$join(TARGET,,,_debug)

StaticDebug: OBJECTS_DIR = StaticDebug
SharedDebug: OBJECTS_DIR = SharedDebug
StaticRelease: OBJECTS_DIR = StaticRelease
SharedRelease: OBJECTS_DIR = SharedRelease

MOC_DIR = $$OBJECTS_DIR
RCC_DIR = $$OBJECTS_DIR

Если отладочная и релизная версия должны размещаться в разных каталогах, нужно также изменять переменную DESTDIR.

В общем, happy hackin’!

Одновременная сборка статической и динамической библиотеки с qmake

2012-04-28T21:47:44Z

Недокументированные возможности qmake

Задача: заставить qmake генерировать статическую и динамическую библиотеку при использовании шаблона сборки lib.

Решение: хотя считается, что без костылей такая возможность не реализуется, на самом деле это не так: поддержка одновременной сборки статической и динамической версии библиотеки присутствует по крайней мере со времён Qt 4.5.

Всё дело в волшебных prf-файлах. Цитируя официальную документацию,

qmake lets you create your own features that can be included in project files by adding their names to the list of values specified by the CONFIG variable. Features are collections of custom functions and definitions in .prf files that can reside in one of many standard directories.

Если посмотреть каталог mkspec/features в Qt (например, в Ubuntu/Debian это /usr/share/qt4/mkspecs/features/), можно увидеть файл static_and_shared.prf, отвечающий за одновременную сборку статической и динамической версии библиотек.

Использовать это можно так:

TEMPLATE = lib
CONFIG += static_and_shared create_prl build_all

TEMPLATE = lib задаёт шаблон сборки (библиотека), static_and_shared задаёт режим сборки, create_prl (используется при сборке статической библиотеки) включает режим отслеживания зависимостей библиотеки, build_all указывает, что собирать нужно обе версии.

Из параметров CONFIG недокументированным является только static_and_shared.

Задать различные опции для статической и динамической сборки можно через функцию CONFIG:

build_pass: CONFIG(static, static|shared) {
# Опции для статической библиотеки
}

build_pass: CONFIG(shared, static|shared) {
# Опции для динамической библиотеки
}

На закуску еще две полезных опции для использования в CONFIG для Linux/UNIX:

hide_symbols: установка видимости символов по умолчанию в hidden. Для чего нужно, читаем здесь.
bsymbolic_functions: привязка ссылок на глобальные функции к определениям этих функций в самой библиотеке (что не позволит привязывать ссылки из библиотеки на свои функции к функциям, экспортируемым из другой библиотеки)

Отслеживание источника исключения в Qt

2012-04-13T21:05:31Z

Получение трассы вызовов к источнику исключений в Qt

Если приложение (или сама библиотека Qt) бросает исключение, которое не обрабатывается приложением, исключение попадает в цикл обработки событий Qt (известный как event loop), который выводит сообщение наподобие:

Qt has caught an exception thrown from an event handler. Throwing
exceptions from an event handler is not supported in Qt. You must
reimplement QApplication::notify() and catch all exceptions there.

При использовании libstdc++ может быть выдана дополнительная диагностика:

terminate called after throwing an instance of ‘std::bad_alloc’
what(): std::bad_alloc

Получение стека вызовов из обработчика не пойманных исключений (std::set_terminate) здесь не поможет: трасса приведёт к тому месту, откуда исключение было брошено повторно — то есть в цикл обработки событий Qt.

В случае использования gcc проблему можно решить, поставив в отладчике точку прерывания на функцию __cxa_throw.

Например, в случае с gdb:

$ gdb buggy_app
GNU gdb (Ubuntu/Linaro 7.4-2012.02-0ubuntu2) 7.4-2012.02
Copyright (C) 2012 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
For bug reporting instructions, please see:
<http://bugs.launchpad.net/gdb-linaro/>...
Reading symbols from /path/to/buggy_app...done.
(gdb) start
Temporary breakpoint 1 at 0x405f6d: file main.cpp, line 75.
Starting program: /path/to/buggy_app
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Temporary breakpoint 1, main (argc=3, argv=0x7fffffffe008) at main.cpp:75
75 QCoreApplication a(argc, argv);
(gdb) b __cxa_throw
Breakpoint 2 at 0x7ffff7154910
(gdb) c
Continuing.

Breakpoint 2, 0x00007ffff7154910 in __cxa_throw () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
(gdb) bt
#0 0x00007ffff7154910 in __cxa_throw () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
#1 0x00007ffff762d102 in qBadAlloc () at global/qglobal.cpp:1994
#2 0x00007ffff7fe6e7e in DnsRequestQueuePrivate::_q_resultsReady (this=0x43af90, r=..., id=11771, code=0, ctx=...) at dnsrequestqueue.cpp:83
#3 0x00007ffff7fe7629 in DnsRequestQueue::qt_static_metacall (_o=0x7fffffffded8, _c=QMetaObject::InvokeMetaMethod, _id=1, _a=0x43d130) at debug/moc_dnsrequestqueue.cpp:53
#4 0x00007ffff7750446 in QObject::event (this=0x7fffffffded8, e=<optimized out>) at kernel/qobject.cpp:1195
#5 0x00007ffff7736e9c in QCoreApplication::notifyInternal (this=0x7fffffffdf00, receiver=0x7fffffffded8, event=0x43d310) at kernel/qcoreapplication.cpp:876
...

Для экстремалов есть такое решение: Hijacking throw

Undefined reference на специализацию шаблона статического поля

2012-03-31T20:29:50Z

GCC временами весьма капризен

Столкнулся на работе с такой проблемой при написании расширения для QtScript: код вида

template<typename T>
class EnumWrapper {
/* ... */

protected:
static QMap<int, QString> m_enum_map;
static QString m_class;
/* ... */
};

template<> QMap<int, QString> EnumWrapper<QTextStream::RealNumberNotation>::m_enum_map;
template<> QString EnumWrapper<QTextStream::RealNumberNotation>::m_class(QLatin1String("QTextStream"));

class QTextStream_RealNumberNotation : public EnumWrapper<QTextStream::RealNumberNotation> {
public:
QTextStream_RealNumberNotation(void)
{
EnumWrapper<QTextStream::RealNumberNotation>::m_enum_map.insert(int(QTextStream::SmartNotation), QLatin1String("SmartNotation"));
EnumWrapper<QTextStream::RealNumberNotation>::m_enum_map.insert(int(QTextStream::FixedNotation), QLatin1String("FixedNotation"));
EnumWrapper<QTextStream::RealNumberNotation>::m_enum_map.insert(int(QTextStream::ScientificNotation), QLatin1String("ScientificNotation"));
}
};

/* ... */

QTextStream_RealNumberNotation c;

делает полученную библиотеку незагружаемой.

Методом проб и ошибок было установлено, что всему виной такая декларация:

template<> QMap<int, QString> EnumWrapper<QTextStream::RealNumberNotation>::m_enum_map;

Чтобы лучше понять суть проблемы, набросал небольшой test case, который не использует сторонних библиотек (мало ли, вдруг Qt виноват):

#include <map>
#include <utility>

template<typename T>
class Test {
public:
Test(void)
{
m_map.insert(std::make_pair(0, 0));
}

static std::map<int, int> m_map;
};

template<> std::map<int, int> Test<char>::m_map;

int main(int, char**)
{
Test<char> t;
return 0;
}

И вот оно, gcc громко ругается:

$ g++ test.cpp -o test
/tmp/ccyD9dfl.o:test.cpp:function Test<char>::Test(): error: undefined reference to 'Test<char>::m_map'
collect2: ld returned 1 exit status

Компоновщик почему-то в упор отказывается замечать декларацию

template<> std::map<int, int> Test<char>::m_map;

В VC9 такое не проявляется.

На решение натолкнула следующая за QMap декларация:

template<> QString EnumWrapper<QTextStream::RealNumberNotation>::m_class(QLatin1String("QTextStream"));

На неё компоновщик не ругается. А вся разница — в явном вызове конструктора. Поэтому, если сделать как-то так:

template<> std::map<int, int> Test<char>::m_map = std::map<int, int>();

// Для исходного случая:

template<> QMap<int, QString> EnumWrapper<QTextStream::RealNumberNotation>::m_enum_map = QMap<int, QString>();

то компоновщик перестаёт ругаться.

Шаблонная магия и костылестроение.

Может, кому-то пригодится.

DropBox, Upstart и официальная Wiki

2012-03-31T19:56:41Z

Почему официальный рецепт не работает

В официальной Wiki DropBox приведён рецепт запуска dropbox при старте системе с использованием Upstart:

start on runlevel 2
start on runlevel 3
start on runlevel 4
start on runlevel 5
stop on shutdown
respawn
script
# Without next line DB does not sync non ASCII characters (ubuntu 10.04-x86_64, db 0.7.110)
export LANG=en_US.UTF-8
cd /home/dropbox
exec sudo -H -u dropbox ./.dropbox-dist/dropbox
end script

Тем не менее, если использовать данный рецепт на сервере (при условии, что на сервере X-сервер не используется), то работать не будет.

Причина, как обычно, в том, что разработчики имеют трудности с чтением документации на те продуты, которые они используют, а также с тестированием предлагаемых решений

В частности, man 5 init говорит:

If a stanza is duplicated, the last occurence will be used.

Поэтому конфигурация

start on runlevel 2
start on runlevel 3
start on runlevel 4
start on runlevel 5

будет иметь тот же эффект, что и

start on runlevel 5

Правильный вариант:

start on runlevel [2345]

Исправление проблемы обхода хранителя экрана в X11

2012-01-19T12:18:51Z

Программистов всё больше, а профессионалов всё меньше

В X.Org Server 1.11 обнаружена уязвимость, позволяющая через манипуляции с клавиатурой обойти режим блокировки экрана и получить доступ к заблокированному рабочему окружению пользователя.

Подробности либо по ссылке выше, либо на OpenNet.

Исправление: в файле /usr/share/X11/xkb/compat/xfree86 закомментировать следующие строки:

interpret XF86_Ungrab {
action = Private(type=0x86, data="Ungrab");
};
interpret XF86_ClearGrab {
action = Private(type=0x86, data="ClsGrb");
};

После чего перезапустить X Server.

Автоматическое добавление ссылки на источник при копировании текста с сайта

2012-01-14T03:42:35Z

Навязчивое добавление ссылки на оригинал при копировании текста с сайта

Идея: когда пользователь выделяет часть текста и копирует её в буфер обмена (например, чтобы выложить на своём сайте), автоматически добавлять к выделению ссылку на источник.

Реализация:

Настраиваемые параметры:

source_link — текст, который будет добавляться к копируемому фрагменту. В данном примере задаётся статически, но при желании генерацию ссылки можно усложнить (например, при копировании с текста с домашней страницы можно возвращать ссылку на статью, из которой взята данная цитата). Для этого в строке magic_div.append(range.cloneContents(), source_link); вместо source_link нужно использовать свою функцию, возвращающую HTML для вставки в копируемый фрагмент.
'#content div.post' — выражение, задающее один или более контейнер с текстом, при копировании которого нужно добавлять ссылку на оригинал. Идея в том, что добавлять ссылку на статью при копировании, скажем, части текста одного из комментариев к статье было бы нелогично. С помощью данного выражения можно задать требуемые защищаемые объекты.

Возможные улучшения: проверка длины копируемого текста. Например, если пользователь копирует меньше 20 слов, не добавлять ссылку. Получить выделенный текст можно через range.cloneContents().textContent.