diff options
Diffstat (limited to 'lldb/source')
7 files changed, 322 insertions, 17 deletions
diff --git a/lldb/source/API/SBDebugger.cpp b/lldb/source/API/SBDebugger.cpp index d3294dab582..af883acf1ad 100644 --- a/lldb/source/API/SBDebugger.cpp +++ b/lldb/source/API/SBDebugger.cpp @@ -270,6 +270,18 @@ void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) { m_opaque_sp->SetInputFileHandle(fh, transfer_ownership); } +void SBDebugger::FlushDebuggerOutputHandles() { + Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); + + if (log) + log->Printf( + "SBDebugger(%p)::FlushDebuggerOutputHandles ()", + static_cast<void *>(m_opaque_sp.get())); + + if (m_opaque_sp) + m_opaque_sp->FlushDebuggerOutputHandles(); +} + void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) { Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); diff --git a/lldb/source/Core/Debugger.cpp b/lldb/source/Core/Debugger.cpp index a4d78151c75..500913ad41b 100644 --- a/lldb/source/Core/Debugger.cpp +++ b/lldb/source/Core/Debugger.cpp @@ -680,6 +680,15 @@ void Debugger::Destroy(DebuggerSP &debugger_sp) { if (!debugger_sp) return; + /* + * FILE* get flushed on process exit. If those FILEs need to call into python + * to flush, we can't have them flushing after python is already torn down. + * That would result in a segfault. We are still relying on the python script + * to tear down the debugger before it exits. + */ + debugger_sp->m_output_file_sp->Flush(); + debugger_sp->m_error_file_sp->Flush(); + debugger_sp->Clear(); if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) { @@ -896,6 +905,11 @@ void Debugger::SetErrorFileHandle(FILE *fh, bool tranfer_ownership) { err_file.SetStream(stderr, false); } +void Debugger::FlushDebuggerOutputHandles() { + m_output_file_sp->Flush(); + m_error_file_sp->Flush(); +} + void Debugger::SaveInputTerminalState() { if (m_input_file_sp) { File &in_file = m_input_file_sp->GetFile(); diff --git a/lldb/source/Host/common/File.cpp b/lldb/source/Host/common/File.cpp index 6ee4e894756..ec5c435d778 100644 --- a/lldb/source/Host/common/File.cpp +++ b/lldb/source/Host/common/File.cpp @@ -14,6 +14,7 @@ #include <limits.h> #include <stdarg.h> #include <stdio.h> +#include <assert.h> #ifdef _WIN32 #include "lldb/Host/windows/windows.h" @@ -71,6 +72,129 @@ static const char *GetStreamOpenModeFromOptions(uint32_t options) { int File::kInvalidDescriptor = -1; FILE *File::kInvalidStream = NULL; +File::File(File &&rhs) + : IOObject(eFDTypeFile, false), m_descriptor(kInvalidDescriptor), + m_stream(kInvalidStream), m_options(), m_own_stream(false), + m_is_interactive(eLazyBoolCalculate), + m_is_real_terminal(eLazyBoolCalculate), + m_supports_colors(eLazyBoolCalculate) +{ + Swap(rhs); +} + +File& File::operator= (File &&rhs) +{ + Close(); + Swap(rhs); + return *this; +} + +void File::Swap(File &rhs) +{ + std::swap(m_descriptor, rhs.m_descriptor); + std::swap(m_stream, rhs.m_stream); + std::swap(m_own_stream, rhs.m_own_stream); + std::swap(m_options, rhs.m_options); + std::swap(m_is_interactive, rhs.m_is_interactive); + std::swap(m_is_real_terminal, rhs.m_is_real_terminal); + std::swap(m_supports_colors, rhs.m_supports_colors); +} + +#if defined(__linux__) + +struct context { + void *cookie; + int (*readfn)(void *, char *, int); + int (*writefn)(void *, const char *, int); + int (*closefn)(void *); +}; + +static ssize_t +write_wrapper(void *c, const char *buf, size_t size) +{ + auto ctx = (struct context *)c; + if (size > INT_MAX) { + size = INT_MAX; + } + ssize_t wrote = ctx->writefn(ctx->cookie, buf, (int)size); + assert(wrote < 0 || (size_t)wrote <= size); + if (wrote < 0) { + return -1; + } else { + return (int)wrote; + } +} + +static ssize_t +read_wrapper(void *c, char *buf, size_t size) +{ + auto ctx = (struct context *)c; + if (size > INT_MAX) { + size = INT_MAX; + } + ssize_t read = ctx->writefn(ctx->cookie, buf, (int)size); + assert(read < 0 || (size_t)read <= size); + if (read < 0) { + return -1; + } else { + return (int)read; + } +} + +static int +close_wrapper(void *c) +{ + auto ctx = (struct context *)c; + int ret = ctx->closefn(ctx->cookie); + delete ctx; + return ret; +} + +#endif + +File::File(void *cookie, + int (*readfn)(void *, char *, int), + int (*writefn)(void *, const char *, int), + int (*closefn)(void *)) + : IOObject(eFDTypeFile, false), m_descriptor(kInvalidDescriptor), + m_stream(kInvalidStream), m_options(), m_own_stream(false), + m_is_interactive(eLazyBoolCalculate), + m_is_real_terminal(eLazyBoolCalculate), + m_supports_colors(eLazyBoolCalculate) +{ +#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) + m_stream = funopen(cookie, readfn, writefn, NULL, closefn); +#elif defined(__linux__) + cookie_io_functions_t io_funcs = {}; + io_funcs.read = read_wrapper; + io_funcs.write = write_wrapper; + io_funcs.close = close_wrapper; + const char *mode = NULL; + if (readfn && writefn) { + mode = "r+"; + } else if (readfn) { + mode = "r"; + } else if (writefn) { + mode = "w"; + } + if (mode) { + struct context *ctx = new context; + ctx->readfn = readfn; + ctx->writefn = writefn; + ctx->closefn = closefn; + ctx->cookie = cookie; + m_stream = fopencookie(ctx, mode, io_funcs); + if (!m_stream) { + delete ctx; + } + } +#endif + if (m_stream) { + m_own_stream = true; + } +} + + File::File(const char *path, uint32_t options, uint32_t permissions) : IOObject(eFDTypeFile, false), m_descriptor(kInvalidDescriptor), m_stream(kInvalidStream), m_options(), m_own_stream(false), diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp b/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp index 966bdff3ad9..135c19896d4 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp +++ b/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp @@ -17,6 +17,7 @@ #include "PythonDataObjects.h" #include "ScriptInterpreterPython.h" +#include "lldb/Utility/Log.h" #include "lldb/Host/File.h" #include "lldb/Host/FileSystem.h" #include "lldb/Interpreter/ScriptInterpreter.h" @@ -959,8 +960,10 @@ PythonFile::~PythonFile() {} bool PythonFile::Check(PyObject *py_obj) { #if PY_MAJOR_VERSION < 3 - return PyFile_Check(py_obj); -#else + if (PyFile_Check(py_obj)) { + return true; + } +#endif // In Python 3, there is no `PyFile_Check`, and in fact PyFile is not even a // first-class object type anymore. `PyFile_FromFd` is just a thin wrapper // over `io.open()`, which returns some object derived from `io.IOBase`. @@ -977,11 +980,11 @@ bool PythonFile::Check(PyObject *py_obj) { if (1 != PyObject_IsSubclass(object_type.get(), io_base_class.get())) return false; + if (!object_type.HasAttribute("fileno")) return false; return true; -#endif } void PythonFile::Reset(PyRefType type, PyObject *py_obj) { @@ -989,7 +992,7 @@ void PythonFile::Reset(PyRefType type, PyObject *py_obj) { // `py_obj` it still gets decremented if necessary. PythonObject result(type, py_obj); - if (!PythonFile::Check(py_obj)) { + if (py_obj == NULL || !PythonFile::Check(py_obj)) { PythonObject::Reset(); return; } @@ -1034,17 +1037,168 @@ uint32_t PythonFile::GetOptionsFromMode(llvm::StringRef mode) { .Default(0); } +static const char * +str(PyObject *o, const char *defaultt, PyObject **cleanup) +{ + *cleanup = NULL; + if (o == NULL) { + return defaultt; + } + PyObject *string = PyObject_Str(o); + *cleanup = string; + if (string == NULL) { + return defaultt; + } + if (PyUnicode_Check(string)) { + PyObject *bytes = PyUnicode_AsEncodedString(string, "utf-8", "Error ~"); + if (bytes == NULL) { + return defaultt; + } + Py_XDECREF(string); + *cleanup = bytes; + return PyBytes_AS_STRING(bytes); + } else { + return PyBytes_AS_STRING(string); + } +} + + +static void +log_exception(const char *fmt, PyObject *obj) +{ + Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT); + if (!log) { + return; + } + PyObject *pyclass = PyObject_Type(obj); + PyObject *pyclassname = NULL; + if (pyclass) { + pyclassname = PyObject_GetAttrString(pyclass, "__name__"); + } + PyObject *exception = NULL, *v = NULL, *tb = NULL; + PyErr_Fetch(&exception, &v, &tb); + if (exception) { + PyErr_NormalizeException(&exception, &v, &tb); + } + PyObject *cleanup1 = NULL, *cleanup2 = NULL; + log->Printf(fmt, + str(pyclassname, "UknownClass", &cleanup1), + str(v, "unknown error", &cleanup2)); + Py_XDECREF(cleanup1); + Py_XDECREF(cleanup2); + Py_XDECREF(pyclass); + Py_XDECREF(pyclassname); + Py_XDECREF(exception); + Py_XDECREF(v); + Py_XDECREF(tb); + +} + +class GIL +{ +private: + PyGILState_STATE m_state; +public: + GIL() { + m_state = PyGILState_Ensure(); + } + ~GIL() { + PyGILState_Release(m_state); + } +}; + +#define callmethod(obj, name, fmt, ...) \ + PythonObject(PyRefType::Owned, PyObject_CallMethod(obj, (char*)name, (char*)fmt, __VA_ARGS__)) + +#define callmethod0(obj, name, fmt) \ + PythonObject(PyRefType::Owned, PyObject_CallMethod(obj, (char*)name, (char*)fmt)) + +static int readfn(void *ctx, char *buffer, int n) +{ + GIL gil; + auto *file = (PyObject *) ctx; + + PythonObject pyresult = callmethod(file, "read", "(i)", n); + if (!pyresult.IsValid() || PyErr_Occurred()) { + log_exception("read from python %s failed: %s", file); + return -1; + } + if (!PyBytes_Check(pyresult)) { + PyErr_SetString(PyExc_TypeError, "read didn't return bytes"); + log_exception("read from python %s failed: %s", file); + return -1; + } + + int r = 0; + char *data = NULL; + ssize_t length = 0; + r = PyBytes_AsStringAndSize(pyresult, &data, &length); + if (r || length < 0 || PyErr_Occurred()) { + log_exception("read from python %s failed: %s", file); + return -1; + } + + memcpy(buffer, data, length); + return length; +} + +static int writefn(void *ctx, const char *buffer, int n) +{ + GIL gil; + auto *file = (PyObject *) ctx; + + PythonObject pyresult = callmethod(file, "write", "(s#)", buffer, n); + if (!pyresult.IsValid() || PyErr_Occurred()) { + log_exception("write to python %s failed: %s", file); + return -1; + } + + int result = PyLong_AsLong(pyresult); + if (PyErr_Occurred()) { + log_exception("read from python %s failed: %s", file); + return -1; + } + + return result; +} + +static int closefn(void *ctx) { + GIL gil; + auto *file = (PyObject *) ctx; + Py_XDECREF(file); + return 0; +} + bool PythonFile::GetUnderlyingFile(File &file) const { if (!IsValid()) return false; + if (!PythonFile::Check(m_py_obj)) + return false; + file.Close(); - // We don't own the file descriptor returned by this function, make sure the - // File object knows about that. - file.SetDescriptor(PyObject_AsFileDescriptor(m_py_obj), false); - PythonString py_mode = GetAttributeValue("mode").AsType<PythonString>(); - file.SetOptions(PythonFile::GetOptionsFromMode(py_mode.GetString())); - return file.IsValid(); + + int fd = PyObject_AsFileDescriptor(m_py_obj); + if (fd >= 0) { + // We don't own the file descriptor returned by this function, make sure the + // File object knows about that. + file.SetDescriptor(PyObject_AsFileDescriptor(m_py_obj), false); + PythonString py_mode = GetAttributeValue("mode").AsType<PythonString>(); + file.SetOptions(PythonFile::GetOptionsFromMode(py_mode.GetString())); + return file.IsValid(); + } + + bool readable = PyObject_IsTrue(callmethod0(m_py_obj, "readable", "()")); + bool writable = PyObject_IsTrue(callmethod0(m_py_obj, "writable", "()")); + + Py_XINCREF(m_py_obj); + file = File(m_py_obj, readable ? readfn : NULL, writable ? writefn : NULL, closefn); + if (!file.IsValid()) { + closefn(m_py_obj); + return false; + } else { + return true; + } } #endif diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h b/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h index beeb6478236..60e1337b702 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h +++ b/lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h @@ -113,6 +113,8 @@ public: Reset(PyRefType::Borrowed, rhs.m_py_obj); } + operator PyObject*() const { return m_py_obj; } + // PythonObject is implicitly convertible to PyObject *, which will call the // wrong overload. We want to explicitly disallow this, since a PyObject // *always* owns its reference. Therefore the overload which takes a diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp b/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp index 6c39690268c..246da4f07b8 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp +++ b/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp @@ -504,7 +504,7 @@ void ScriptInterpreterPython::LeaveSession() { } bool ScriptInterpreterPython::SetStdHandle(File &file, const char *py_name, - PythonFile &save_file, + PythonObject &save_file, const char *mode) { if (file.IsValid()) { // Flush the file before giving it to python to avoid interleaved output. @@ -512,8 +512,7 @@ bool ScriptInterpreterPython::SetStdHandle(File &file, const char *py_name, PythonDictionary &sys_module_dict = GetSysModuleDictionary(); - save_file = sys_module_dict.GetItemForKey(PythonString(py_name)) - .AsType<PythonFile>(); + save_file = sys_module_dict.GetItemForKey(PythonString(py_name)); PythonFile new_file(file, mode); sys_module_dict.SetItemForKey(PythonString(py_name), new_file); diff --git a/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h b/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h index a71fcea7519..ed200e4294e 100644 --- a/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h +++ b/lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h @@ -541,12 +541,12 @@ protected: bool GetEmbeddedInterpreterModuleObjects(); - bool SetStdHandle(File &file, const char *py_name, PythonFile &save_file, + bool SetStdHandle(File &file, const char *py_name, PythonObject &save_file, const char *mode); - PythonFile m_saved_stdin; - PythonFile m_saved_stdout; - PythonFile m_saved_stderr; + PythonObject m_saved_stdin; + PythonObject m_saved_stdout; + PythonObject m_saved_stderr; PythonObject m_main_module; PythonObject m_lldb_module; PythonDictionary m_session_dict; |
