From c4d44362639182ee16a960ac786d6437cee1793c Mon Sep 17 00:00:00 2001 From: Vincent Favre-Nicolin Date: Mon, 16 Nov 2026 13:35:22 +0800 Subject: [PATCH 1/4] fix: keep Python wrappers valid when ObjCryst++ releases sub-objects Install ObjCryst++ ReleaseObj() hooks (vincefn/objcryst#106) so that sub-objects deleted internally by ObjCryst++ (reflection profiles, scatterers, scattering powers, refinable parameters, molecule atoms, restraints and rigid groups) no longer leave dangling Python wrappers. - If a Python wrapper exists, the hook hands ownership to it instead of letting ObjCryst++ delete the object; otherwise ObjCryst++ deletes it. - Wrappers of released RefinablePar objects are invalidated, since their value pointer refers to storage of the former owner. - Atoms pin their scattering power, and released restraints and rigid groups pin their atoms while the molecule is alive. - Remove the GetPar SetDeleteRefParInDestructor(0) workaround. - Crystal.RemoveScatterer, RemoveScatteringPower (when unused) and the Molecule.Remove* methods now delete unreferenced objects instead of leaking them. - Update extern/objcryst to a3d75af (vincefn-object-release-hook). Fixes #121, #132. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- extern/objcryst | 2 +- news/objcryst-release-hooks.rst | 25 ++ src/extensions/helpers_nb.hpp | 3 - src/extensions/nb_crystal.cpp | 13 +- src/extensions/nb_module.cpp | 5 + src/extensions/nb_molecule.cpp | 43 +++- src/extensions/nb_refinableobj.cpp | 8 +- src/extensions/nb_release_hooks.cpp | 346 ++++++++++++++++++++++++++++ src/extensions/nb_release_hooks.hpp | 23 ++ tests/test_crystal.py | 81 +++++++ tests/test_molecule.py | 52 +++++ tests/test_powderpattern.py | 44 ++++ tests/test_reflectionprofile.py | 36 +++ 13 files changed, 662 insertions(+), 19 deletions(-) create mode 100644 news/objcryst-release-hooks.rst create mode 100644 src/extensions/nb_release_hooks.cpp create mode 100644 src/extensions/nb_release_hooks.hpp diff --git a/extern/objcryst b/extern/objcryst index ba6ca89..a3d75af 160000 --- a/extern/objcryst +++ b/extern/objcryst @@ -1 +1 @@ -Subproject commit ba6ca893d657fea07760c21a398a6b1b9548cec9 +Subproject commit a3d75afbff0a249616f0732ee03a46dfd840dc25 diff --git a/news/objcryst-release-hooks.rst b/news/objcryst-release-hooks.rst new file mode 100644 index 0000000..980df54 --- /dev/null +++ b/news/objcryst-release-hooks.rst @@ -0,0 +1,25 @@ +**Added:** + +* + +**Changed:** + +* ``Crystal.RemoveScatterer``, ``Crystal.RemoveScatteringPower`` (when the scattering power is no longer used) and the ``Molecule.Remove*`` methods now delete the removed object unless a Python wrapper still references it, instead of leaking it. +* Update the vendored ObjCryst++ to the ``ReleaseObj()`` hook API (vincefn/objcryst#106). + +**Deprecated:** + +* + +**Removed:** + +* + +**Fixed:** + +* Fix dangling Python wrappers, use-after-free and double free when ObjCryst++ deletes sub-objects that are still referenced from Python (#121, #132). Removed or replaced objects (reflection profiles, scatterers, scattering powers, molecule atoms and restraints) now stay valid while a Python wrapper references them, and ``GetProfile`` no longer returns a stale wrapper of the wrong type after ``SetProfile``. Wrappers of deleted ``RefinablePar`` objects (e.g. after ``PowderPatternBackground.SetInterpPoints`` or ``TextureMarchDollase.DeletePhase``) are invalidated and raise ``TypeError`` instead of accessing freed memory. +* Fix the double free when ``Crystal.ConnectAtoms`` merges atoms owned by Python. + +**Security:** + +* diff --git a/src/extensions/helpers_nb.hpp b/src/extensions/helpers_nb.hpp index 01aa100..d770dbb 100644 --- a/src/extensions/helpers_nb.hpp +++ b/src/extensions/helpers_nb.hpp @@ -315,19 +315,16 @@ inline void refobj_fwd_add_par_obj(ObjCryst::RefinableObj& obj, nb::object o, co inline ObjCryst::RefinablePar& refobj_fwd_get_par_long(ObjCryst::RefinableObj& obj, const long i) { - obj.SetDeleteRefParInDestructor(0); return obj.GetPar(i); } inline ObjCryst::RefinablePar& refobj_fwd_get_par_string(ObjCryst::RefinableObj& obj, const std::string& s) { - obj.SetDeleteRefParInDestructor(0); return obj.GetPar(s); } inline ObjCryst::RefinablePar& refobj_fwd_get_par_not_fixed(ObjCryst::RefinableObj& obj, const long i) { - obj.SetDeleteRefParInDestructor(0); return obj.GetParNotFixed(i); } diff --git a/src/extensions/nb_crystal.cpp b/src/extensions/nb_crystal.cpp index 887c603..43ca98a 100644 --- a/src/extensions/nb_crystal.cpp +++ b/src/extensions/nb_crystal.cpp @@ -109,7 +109,7 @@ void _RemoveScatterer(Crystal& crystal, nb::handle obj) } } if (!scatt) throw nb::value_error("Cannot remove nonexistent Scatterer"); - crystal.RemoveScatterer(scatt, false); + crystal.RemoveScatterer(scatt, true); } Scatterer& _GetScattByIndex(Crystal& crystal, int idx) @@ -155,7 +155,16 @@ void _RemoveScatteringPower(Crystal& crystal, nb::handle obj) throw nb::type_error("RemoveScatteringPower: argument must be a ScatteringPower instance"); found: if (!sp) throw nb::value_error("Cannot remove nonexistent ScatteringPower"); - crystal.RemoveScatteringPower(sp, false); + // Only release the scattering power if no scatterer still refers to it, + // otherwise it is kept (and leaked) as before. + bool in_use = false; + const ScatteringComponentList& scl = crystal.GetScatteringComponentList(); + for (long i = 0; i < scl.GetNbComponent(); ++i) + if (scl(i).mpScattPow == sp) in_use = true; + const ObjRegistry& clients = sp->GetClientRegistry(); + for (long i = 0; i < clients.GetNb(); ++i) + if (&clients.GetObj(i) != static_cast(&crystal)) in_use = true; + crystal.RemoveScatteringPower(sp, !in_use); } nb::list _GetScatteringComponentList(Crystal& c) diff --git a/src/extensions/nb_module.cpp b/src/extensions/nb_module.cpp index 267391e..7c0d02e 100644 --- a/src/extensions/nb_module.cpp +++ b/src/extensions/nb_module.cpp @@ -9,6 +9,8 @@ #include #include +#include "nb_release_hooks.hpp" + namespace nb = nanobind; // Forward declarations for all wrap_* functions @@ -133,4 +135,7 @@ NB_MODULE(_pyobjcryst, m) wrap_radiation(m); wrap_zatom(m); wrap_zpolyhedron(m); + + // Let Python wrappers own sub-objects released by ObjCryst + install_release_hooks(); } diff --git a/src/extensions/nb_molecule.cpp b/src/extensions/nb_molecule.cpp index ab7b358..0e59322 100644 --- a/src/extensions/nb_molecule.cpp +++ b/src/extensions/nb_molecule.cpp @@ -2,6 +2,7 @@ #include #include +#include #include #include #include @@ -16,6 +17,7 @@ #include #include "helpers_nb.hpp" +#include "nb_release_hooks.hpp" namespace nb = nanobind; using namespace ObjCryst; @@ -100,6 +102,29 @@ MolAtom& _GetAtomIdx(Molecule& m, int idx) return m.GetAtom(i); } +// Molecule::RemoveAtom only unlists the atom's x/y/z parameters, whose +// values live in the atom. Release them as well, so that any Python wrapper +// of these parameters is invalidated instead of dangling. +void _RemoveAtom(Molecule& m, MolAtom& atom) +{ + RefinablePar* pars[3] = {nullptr, nullptr, nullptr}; + if (std::find(m.GetAtomList().begin(), m.GetAtomList().end(), &atom) + != m.GetAtomList().end()) + { + pars[0] = &m.GetPar(&atom.X()); + pars[1] = &m.GetPar(&atom.Y()); + pars[2] = &m.GetPar(&atom.Z()); + } + // RemoveAtom does not update rigid groups: keep (leak) the atom if one + // still refers to it. + bool del = true; + for (const RigidGroup* rg : m.GetRigidGroupList()) + if (rg->count(&atom) != 0) del = false; + KeepRestraintAtomsAlive guard; + m.RemoveAtom(atom, del); + for (RefinablePar* p : pars) ReleaseObj(p); +} + MolAtom* _FindAtom(Molecule& m, const std::string& name) { auto ii = m.FindAtom(name); @@ -359,8 +384,8 @@ void wrap_molecule(nb::module_& m) nb::arg("x"), nb::arg("y"), nb::arg("z"), nb::arg("pPow").none(), nb::arg("name"), nb::arg("updateDisplay") = true, nb::keep_alive<1,5>(), nb::rv_policy::reference_internal) - .def("RemoveAtom", [](Molecule& mol, MolAtom& a){ mol.RemoveAtom(a, false); }) - .def("RemoveAtom", [](Molecule& mol, int idx){ mol.RemoveAtom(_GetAtomIdx(mol, idx), false); }) + .def("RemoveAtom", &_RemoveAtom) + .def("RemoveAtom", [](Molecule& mol, int idx){ _RemoveAtom(mol, _GetAtomIdx(mol, idx)); }) .def("AddBond", &_AddBond, nb::arg("atom1"), nb::arg("atom2"), nb::arg("length"), nb::arg("sigma"), nb::arg("delta"), nb::arg("bondOrder") = 1., @@ -379,8 +404,8 @@ void wrap_molecule(nb::module_& m) // the Molecule that returned it, so nothing here can dangle // once the redundant direction is removed. nb::rv_policy::reference_internal) - .def("RemoveBond", [](Molecule& mol, const MolBond& b){ mol.RemoveBond(b, false); }) - .def("RemoveBond", [](Molecule& mol, int idx){ mol.RemoveBond(_GetBondIdx(mol, idx), false); }) + .def("RemoveBond", [](Molecule& mol, const MolBond& b){ KeepRestraintAtomsAlive g; mol.RemoveBond(b, true); }) + .def("RemoveBond", [](Molecule& mol, int idx){ KeepRestraintAtomsAlive g; mol.RemoveBond(_GetBondIdx(mol, idx), true); }) .def("GetBond", &_GetBondIdx, nb::rv_policy::reference_internal) .def("FindBond", &_FindBond) .def("AddBondAngle", &_AddBondAngle, @@ -390,8 +415,8 @@ void wrap_molecule(nb::module_& m) // See the comment on AddBond above -- same reasoning applies to // atom1/atom2/atom3 here (§10). nb::rv_policy::reference_internal) - .def("RemoveBondAngle", [](Molecule& mol, MolBondAngle& ba){ mol.RemoveBondAngle(ba, false); }) - .def("RemoveBondAngle", [](Molecule& mol, int idx){ mol.RemoveBondAngle(_GetBondAngleIdx(mol, idx), false); }) + .def("RemoveBondAngle", [](Molecule& mol, MolBondAngle& ba){ KeepRestraintAtomsAlive g; mol.RemoveBondAngle(ba, true); }) + .def("RemoveBondAngle", [](Molecule& mol, int idx){ KeepRestraintAtomsAlive g; mol.RemoveBondAngle(_GetBondAngleIdx(mol, idx), true); }) .def("GetBondAngle", &_GetBondAngleIdx, nb::rv_policy::reference_internal) .def("FindBondAngle", &_FindBondAngle) .def("AddDihedralAngle", &_AddDihedralAngle, @@ -401,8 +426,8 @@ void wrap_molecule(nb::module_& m) // See the comment on AddBond above -- same reasoning applies to // atom1..atom4 here (§10). nb::rv_policy::reference_internal) - .def("RemoveDihedralAngle", [](Molecule& mol, MolDihedralAngle& da){ mol.RemoveDihedralAngle(da, false); }) - .def("RemoveDihedralAngle", [](Molecule& mol, int idx){ mol.RemoveDihedralAngle(_GetDihedralAngleIdx(mol, idx), false); }) + .def("RemoveDihedralAngle", [](Molecule& mol, MolDihedralAngle& da){ KeepRestraintAtomsAlive g; mol.RemoveDihedralAngle(da, true); }) + .def("RemoveDihedralAngle", [](Molecule& mol, int idx){ KeepRestraintAtomsAlive g; mol.RemoveDihedralAngle(_GetDihedralAngleIdx(mol, idx), true); }) .def("GetDihedralAngle", &_GetDihedralAngleIdx, nb::rv_policy::reference_internal) .def("FindDihedralAngle", &_FindDihedralAngle) .def("AddRigidGroup", @@ -413,7 +438,7 @@ void wrap_molecule(nb::module_& m) [](Molecule& mol, nb::object& group, const bool updateDisplay) -> RigidGroup& { return _AddRigidGroupIterable(mol, group, updateDisplay); }, nb::arg("group"), nb::arg("updateDisplay") = true, nb::rv_policy::reference_internal) - .def("RemoveRigidGroup", [](Molecule& mol, RigidGroup& rg, const bool ud){ mol.RemoveRigidGroup(rg, ud, false); }, + .def("RemoveRigidGroup", [](Molecule& mol, RigidGroup& rg, const bool ud){ KeepRestraintAtomsAlive g; mol.RemoveRigidGroup(rg, ud, true); }, nb::arg("group"), nb::arg("updateDisplay") = true) .def("GetAtom", [](Molecule& mol, int idx) -> MolAtom& { return _GetAtomIdx(mol, idx); }, nb::rv_policy::reference_internal) .def("GetAtom", [](Molecule& mol, const std::string& name) -> MolAtom& { return *_GetAtomByName(mol, name); }, nb::rv_policy::reference_internal) diff --git a/src/extensions/nb_refinableobj.cpp b/src/extensions/nb_refinableobj.cpp index 322678d..9b8b545 100644 --- a/src/extensions/nb_refinableobj.cpp +++ b/src/extensions/nb_refinableobj.cpp @@ -3,7 +3,10 @@ * * Changes from ObjCryst::RefinableObj: * - XMLOutput and XMLInput accept python file-like objects or strings - * - SetDeleteRefParInDestructor(false) called in constructors + * - SetDeleteRefParInDestructor(false) called by AddPar, since an added + * parameter may be shared with another object + * - Wrappers of parameters deleted by ObjCryst are invalidated by the + * release hooks (nb_release_hooks.cpp) * - GetParamSet returns a copy * - RemovePar returns None */ @@ -81,19 +84,16 @@ void _AddParObj(RefinableObj& obj, nb::object o, const bool copyParam = false) RefinablePar& _GetParLong(RefinableObj& obj, const long i) { - obj.SetDeleteRefParInDestructor(0); return obj.GetPar(i); } RefinablePar& _GetParString(RefinableObj& obj, const std::string& s) { - obj.SetDeleteRefParInDestructor(0); return obj.GetPar(s); } RefinablePar& _GetParNotFixed(RefinableObj& obj, const long i) { - obj.SetDeleteRefParInDestructor(0); return obj.GetParNotFixed(i); } diff --git a/src/extensions/nb_release_hooks.cpp b/src/extensions/nb_release_hooks.cpp new file mode 100644 index 0000000..bdb2a6a --- /dev/null +++ b/src/extensions/nb_release_hooks.cpp @@ -0,0 +1,346 @@ +/* + * pyobjcryst nanobind port -- ObjCryst release hooks + * + * ObjCryst deletes the sub-objects it owns (reflection profiles, refinable + * parameters, scatterers, molecule atoms, ...) through ObjCryst::ReleaseObj(). + * Python may still hold wrappers for these objects. Without the hooks below + * such wrappers dangle, and nanobind may even return a stale wrapper (with + * the wrong type) for a new object allocated at the same address. + * + * The hooks look for live Python wrappers of the released object: + * - no wrapper: return false, ObjCryst deletes the object; + * - a Python-owned wrapper exists: return true, that wrapper already owns the + * object and deletes it when it is garbage-collected; + * - only non-owning wrappers exist: return true and attach a deleter to one + * of them, so the object is deleted when that wrapper dies. The object + * memory stays allocated as long as any wrapper is alive, so no new object + * can be created at the same address. + * + * RefinablePar is special: its value pointer refers to storage owned by its + * former parent, which may already be freed or reallocated. Wrappers of a + * released parameter are therefore invalidated (any further use raises a + * TypeError), and the parameter is only kept allocated until they die. + */ + +#include + +#include +#include +#include +#include + +#undef B0 +#include +#include +#include +#include +#include +#include +#include +#include + +#include "nb_release_hooks.hpp" + +namespace nb = nanobind; +using namespace ObjCryst; + +namespace { + +struct Probe +{ + const std::type_info* type; + const void* addr; +}; + +int restraint_atoms_alive = 0; + +// Objects currently kept alive by a deleter attached to a wrapper. Only +// accessed with the GIL held. +std::unordered_set& adopted() +{ + static auto* s = new std::unordered_set(); + return *s; +} + +// Look up an existing wrapper registered at `addr` whose type is compatible +// with `type` or with the dynamic type `dyn`. Never returns a new wrapper. +void find_wrapper(const Probe& probe, const std::type_info* dyn, + std::vector& found) +{ + if (probe.addr == nullptr) return; + bool is_new = false; + PyObject* o = NB_CALL(nb_type_put)( + NB_CTX, probe.type, dyn, const_cast(probe.addr), + nb::rv_policy::none, nullptr, &is_new); + if (o == nullptr) + { + PyErr_Clear(); + return; + } + nb::object w = nb::steal(o); + if (w.is_none()) return; + if (is_new) + { + // nanobind creates a fresh wrapper when an unrelated instance is + // registered at the same address. Discard it without running any + // C++ destructor. + nb::inst_set_state(w, true, false); + return; + } + for (const nb::object& f : found) + if (f.is(w)) return; + found.push_back(std::move(w)); +} + +std::vector find_wrappers(const std::vector& probes, + const std::type_info* dyn) +{ + std::vector found; + for (const Probe& p : probes) find_wrapper(p, dyn, found); + return found; +} + +template +void add_probe(std::vector& probes, T* p) +{ + if (Target* t = dynamic_cast(p)) + probes.push_back({&typeid(Target), static_cast(t)}); +} + +template const std::type_info* dynamic_type(T* p) +{ + if constexpr (std::is_polymorphic_v) return &typeid(*p); + else return &typeid(T); +} + +template void delete_adopted(void* p) noexcept +{ + adopted().erase(p); + try { delete static_cast(p); } + catch (...) {} +} + +// Hand ownership of `p` to its Python wrappers. `invalidate` marks all +// non-owning wrappers as unusable. +template +nb::handle adopt(T* p, std::vector& wrappers, bool invalidate) +{ + nb::handle owner; + for (const nb::object& w : wrappers) + if (nb::inst_state(w).second) + { + owner = w; + break; + } + // A Python-owned wrapper already deletes the object when it dies. Its + // object is still valid, even for a RefinablePar (which then uses its + // own storage). + const bool python_owned = owner.is_valid(); + if (!python_owned) + { + owner = wrappers.front(); + adopted().insert(p); + nb::keep_alive_cb(owner, p, &delete_adopted); + } + for (const nb::object& w : wrappers) + { + if (invalidate && !python_owned) nb::inst_set_state(w, false, false); + if (!w.is(owner)) nb::keep_alive_obj(w, owner); + } + return owner; +} + +nb::object wrap_scattering_power(const ScatteringPower& sp) +{ + ScatteringPower* psp = const_cast(&sp); + if (auto* spa = dynamic_cast(psp)) + return nb::cast(spa, nb::rv_policy::reference); + if (auto* gsp = dynamic_cast(psp)) + return nb::cast(gsp, nb::rv_policy::reference); + return nb::cast(psp, nb::rv_policy::reference); +} + +// ~Atom deregisters from its scattering power, which its former Crystal may +// delete later. Keep the scattering power alive as long as the atom: if the +// Crystal releases it, the hook then finds this wrapper and adopts it too. +void pin_dependencies(RefinableObj* p, nb::handle owner) +{ + if (auto* atom = dynamic_cast(p)) + if (!atom->IsDummy()) + nb::keep_alive_obj(owner, wrap_scattering_power(atom->GetScatteringPower())); +} + +void no_pin(void*, nb::handle) {} + +void pin_atom(const MolAtom& atom, nb::handle owner) +{ + nb::object w = nb::cast(const_cast(&atom), nb::rv_policy::reference); + nb::keep_alive_obj(owner, w); +} + +// A restraint or rigid group kept alive by Python must not outlive its atoms. +// The atoms are only accessed in a KeepRestraintAtomsAlive scope: e.g. +// ~Molecule releases atoms before bonds. +void pin_atoms(MolBond* b, nb::handle owner) +{ + if (restraint_atoms_alive == 0) return; + pin_atom(b->GetAtom1(), owner); + pin_atom(b->GetAtom2(), owner); +} + +void pin_atoms(MolBondAngle* b, nb::handle owner) +{ + if (restraint_atoms_alive == 0) return; + pin_atom(b->GetAtom1(), owner); + pin_atom(b->GetAtom2(), owner); + pin_atom(b->GetAtom3(), owner); +} + +void pin_atoms(MolDihedralAngle* b, nb::handle owner) +{ + if (restraint_atoms_alive == 0) return; + pin_atom(b->GetAtom1(), owner); + pin_atom(b->GetAtom2(), owner); + pin_atom(b->GetAtom3(), owner); + pin_atom(b->GetAtom4(), owner); +} + +void pin_atoms(RigidGroup* g, nb::handle owner) +{ + if (restraint_atoms_alive == 0) return; + for (MolAtom* a : *g) pin_atom(*a, owner); +} + +template +bool release_hook(T* p, const std::vector& probes, bool invalidate, + Pin pin) noexcept +{ + if (p == nullptr || !Py_IsInitialized() || !nb::is_alive()) return false; + PyGILState_STATE gstate = PyGILState_Ensure(); + bool keep = false; + { + nb::error_scope scope; + try + { + if (adopted().count(p) != 0) + keep = true; + else + { + std::vector wrappers = + find_wrappers(probes, dynamic_type(p)); + if (!wrappers.empty()) + { + // Even if something fails below, a wrapper still refers + // to the object: leaking it is the safe choice. + keep = true; + nb::handle owner = adopt(p, wrappers, invalidate); + pin(p, owner); + } + } + } + catch (...) + { + } + PyErr_Clear(); + } + PyGILState_Release(gstate); + return keep; +} + +bool release_refinableobj(RefinableObj* p) noexcept +{ + std::vector probes; + try + { + probes.push_back({&typeid(RefinableObj), p}); + add_probe(probes, p); + add_probe(probes, p); + add_probe(probes, p); + add_probe(probes, p); + add_probe(probes, p); + add_probe(probes, p); + add_probe(probes, p); + add_probe(probes, p); + add_probe(probes, p); + probes.push_back({&typeid(*p), dynamic_cast(p)}); + } + catch (...) + { + return false; + } + return release_hook(p, probes, false, &pin_dependencies); +} + +bool release_refinablepar(RefinablePar* p) noexcept +{ + std::vector probes; + try + { + probes.push_back({&typeid(RefinablePar), p}); + probes.push_back({&typeid(Restraint), static_cast(p)}); + } + catch (...) + { + return false; + } + return release_hook(p, probes, true, &no_pin); +} + +template bool release_restraint(T* p) noexcept +{ + std::vector probes; + try + { + probes.push_back({&typeid(T), p}); + probes.push_back({&typeid(Restraint), static_cast(p)}); + } + catch (...) + { + return false; + } + return release_hook(p, probes, false, [](T* r, nb::handle o) { pin_atoms(r, o); }); +} + +template bool release_plain(T* p) noexcept +{ + std::vector probes; + try + { + probes.push_back({&typeid(T), p}); + } + catch (...) + { + return false; + } + return release_hook(p, probes, false, &no_pin); +} + +bool release_rigidgroup(RigidGroup* p) noexcept +{ + std::vector probes; + try + { + probes.push_back({&typeid(RigidGroup), p}); + } + catch (...) + { + return false; + } + return release_hook(p, probes, false, [](RigidGroup* r, nb::handle o) { pin_atoms(r, o); }); +} + +} // namespace + +KeepRestraintAtomsAlive::KeepRestraintAtomsAlive() { ++restraint_atoms_alive; } +KeepRestraintAtomsAlive::~KeepRestraintAtomsAlive() { --restraint_atoms_alive; } + +void install_release_hooks() +{ + SetReleaseObjHook(RefinableObjReleaseHook(&release_refinableobj)); + SetReleaseObjHook(RefinableParReleaseHook(&release_refinablepar)); + SetReleaseObjHook(MolAtomReleaseHook(&release_plain)); + SetReleaseObjHook(MolBondReleaseHook(&release_restraint)); + SetReleaseObjHook(MolBondAngleReleaseHook(&release_restraint)); + SetReleaseObjHook(MolDihedralAngleReleaseHook(&release_restraint)); + SetReleaseObjHook(RigidGroupReleaseHook(&release_rigidgroup)); +} diff --git a/src/extensions/nb_release_hooks.hpp b/src/extensions/nb_release_hooks.hpp new file mode 100644 index 0000000..d181b5d --- /dev/null +++ b/src/extensions/nb_release_hooks.hpp @@ -0,0 +1,23 @@ +/* + * pyobjcryst nanobind port -- ObjCryst release hooks + */ + +#ifndef PYOBJCRYST_NB_RELEASE_HOOKS_HPP +#define PYOBJCRYST_NB_RELEASE_HOOKS_HPP + +// Install the ObjCryst::ReleaseObj hooks (called once at module import). +void install_release_hooks(); + +// While an instance of this guard exists, molecule restraints and rigid +// groups kept alive by a Python wrapper also keep their atoms alive. Only use +// it when all atoms of the released restraints are known to be valid (e.g. +// not from ~Molecule, which releases atoms before bonds). +struct KeepRestraintAtomsAlive +{ + KeepRestraintAtomsAlive(); + ~KeepRestraintAtomsAlive(); + KeepRestraintAtomsAlive(const KeepRestraintAtomsAlive&) = delete; + KeepRestraintAtomsAlive& operator=(const KeepRestraintAtomsAlive&) = delete; +}; + +#endif diff --git a/tests/test_crystal.py b/tests/test_crystal.py index 872d553..003c081 100644 --- a/tests/test_crystal.py +++ b/tests/test_crystal.py @@ -14,6 +14,7 @@ ############################################################################## """Tests for crystal module.""" +import gc import unittest from testutils import ( @@ -24,6 +25,8 @@ ) from pyobjcryst.atom import Atom +from pyobjcryst.crystal import Crystal +from pyobjcryst.scatteringpower import ScatteringPowerAtom class TestCrystal(unittest.TestCase): @@ -168,6 +171,84 @@ def test_display_list(self): c._display_list(enantiomer=True) c._display_list(only_independent_atoms=True) + def testConnectAtomsKeepsHeldAtoms(self): + """Regression test for #132: ConnectAtoms used to delete atoms + owned by Python, causing a double free.""" + c = Crystal(10, 10, 10, "P1") + sp = ScatteringPowerAtom("C", "C") + c.AddScatteringPower(sp) + atoms = [ + Atom(0.1 + 0.14 * i, 0.1, 0.1, "C%d" % i, sp) for i in range(4) + ] + for atom in atoms: + c.AddScatterer(atom) + c.ConnectAtoms() + self.assertEqual(1, c.GetNbScatterer()) + del c + gc.collect() + self.assertEqual( + ["C0", "C1", "C2", "C3"], [a.GetName() for a in atoms] + ) + + def testDefaultCrystalKeepsPythonAtom(self): + """Crystal() deletes its sub-objects in its destructor, but not + those owned by Python.""" + c = Crystal() + sp = ScatteringPowerAtom("C", "C") + c.AddScatteringPower(sp) + atom = Atom(0.1, 0.1, 0.1, "C0", sp) + c.AddScatterer(atom) + del c + gc.collect() + self.assertEqual("C0", atom.GetName()) + self.assertEqual("C", sp.GetName()) + + def testRemoveHeldScatterer(self): + """A removed scatterer stays valid while Python holds it.""" + c = Crystal(10, 10, 10, "P1") + sp = ScatteringPowerAtom("C", "C") + c.AddScatteringPower(sp) + c.AddScatterer(Atom(0.1, 0.1, 0.1, "C0", sp)) + c.AddScatterer(Atom(0.3, 0.1, 0.1, "C1", sp)) + atom = c.GetScatt("C0") + c.RemoveScatterer(atom) + self.assertEqual(1, c.GetNbScatterer()) + self.assertEqual("C1", c.GetScatt(0).GetName()) + del c + gc.collect() + self.assertEqual("C0", atom.GetName()) + self.assertAlmostEqual(0.1, atom.GetX()) + + +def test_connect_atoms_keeps_held_atoms(loadcifdata): + # Test ConnectAtoms on a CIF crystal while Python holds its atoms + # Expected: Removed atoms stay valid after the crystal is deleted. + crystal = loadcifdata("paracetamol.cif") + held = [crystal.GetScatt(i) for i in range(crystal.GetNbScatterer())] + names = [a.GetName() for a in held] + crystal.ConnectAtoms() + assert crystal.GetNbScatterer() < len(held) + del crystal + gc.collect() + assert [a.GetName() for a in held] == names + + +def test_xml_input_keeps_held_scatterers(loadcifdata): + # Test XMLInput into a Crystal() while Python holds its scatterers + # Expected: The old scatterers stay valid and the crystal is replaced. + from pyobjcryst.refinableobj import RefinableObj + + crystal = Crystal() + RefinableObj.XMLInput(crystal, loadcifdata("caffeine.cif").xml()) + held = [crystal.GetScatt(i) for i in range(crystal.GetNbScatterer())] + names = [a.GetName() for a in held] + paracetamol = loadcifdata("paracetamol.cif") + RefinableObj.XMLInput(crystal, paracetamol.xml()) + assert crystal.GetNbScatterer() == paracetamol.GetNbScatterer() + del crystal + gc.collect() + assert [a.GetName() for a in held] == names + if __name__ == "__main__": unittest.main() diff --git a/tests/test_molecule.py b/tests/test_molecule.py index 9025f99..a2ee9d2 100644 --- a/tests/test_molecule.py +++ b/tests/test_molecule.py @@ -14,6 +14,7 @@ ############################################################################## """Tests for molecule module.""" +import gc import unittest import pytest @@ -27,11 +28,13 @@ GetBondLength, GetDihedralAngle, ImportFenskeHallZMatrix, + Molecule, StretchModeBondAngle, StretchModeBondLength, StretchModeTorsion, ) from pyobjcryst.refinableobj import RefinablePar, RefParType +from pyobjcryst.scatteringpower import ScatteringPowerAtom numplaces = 6 @@ -884,5 +887,54 @@ def testDummy(self): # End class TestStretchTorsion + +def make_chain_molecule(): + """Return a crystal and a 5-atom chain molecule with restraints.""" + crystal = Crystal(10, 10, 10, "P1") + sp = ScatteringPowerAtom("C", "C") + crystal.AddScatteringPower(sp) + m = Molecule(crystal, "m") + for i in range(5): + m.AddAtom(1.5 * i, 0.1 * i * i, 0.0, sp, "C%d" % i) + a = [m.GetAtom(i) for i in range(5)] + for i in range(4): + m.AddBond(a[i], a[i + 1], 1.5, 0.01, 0.02) + for i in range(3): + m.AddBondAngle(a[i], a[i + 1], a[i + 2], 2.0, 0.01, 0.02) + m.AddDihedralAngle(a[0], a[1], a[2], a[3], 0.5, 0.01, 0.02) + crystal.AddScatterer(m) + return crystal, m + + +def test_remove_atom_keeps_held_wrappers_valid(): + # Test RemoveAtom while Python holds the atom, its restraints and its + # coordinate parameter + # Expected: The atom and restraints stay usable, the coordinate + # parameter is invalidated, and the molecule is updated. + crystal, m = make_chain_molecule() + atom = m.GetAtom(1) + bond = m.GetBond(0) + angle = m.GetBondAngle(0) + dihedral = m.GetDihedralAngle(0) + xpar = m.GetPar("C1_x") + m.RemoveAtom(atom) + assert (m.GetNbAtoms(), m.GetNbBonds(), m.GetNbBondAngles()) == (4, 2, 1) + assert m.GetNbDihedralAngles() == 0 + with pytest.warns(RuntimeWarning, match="uninitialized"): + with pytest.raises(TypeError): + xpar.GetValue() + m.RemoveBond(m.GetBond(0)) + m.RemoveAtom(0) + del crystal, m + gc.collect() + assert atom.GetName() == "C1" + assert [bond.GetAtom1().GetName(), bond.GetAtom2().GetName()] == [ + "C0", + "C1", + ] + assert angle.GetAtom1().GetName() == "C0" + assert dihedral.GetAtom2().GetName() == "C1" + + if __name__ == "__main__": unittest.main() diff --git a/tests/test_powderpattern.py b/tests/test_powderpattern.py index 84fd164..4616034 100644 --- a/tests/test_powderpattern.py +++ b/tests/test_powderpattern.py @@ -690,6 +690,50 @@ def test_delete_phase( assert actual_par_names == expected_par_names +def assert_par_invalidated(par): + """Assert that the RefinablePar wrapper can no longer be used.""" + with pytest.warns(RuntimeWarning, match="uninitialized"): + with pytest.raises(TypeError): + par.GetValue() + + +def test_delete_phase_invalidates_held_pars(loadcifdata): + # Test that DeletePhase invalidates wrappers of the deleted parameters + # Expected: Deleted parameters raise TypeError, the other phase's + # parameters stay usable. + crystal = loadcifdata("paracetamol.cif") + pattern = build_textured_pattern( + crystal, [(0.7, 0.5, 0, 0, 1), (0.3, 2.0, 1, 1, 0)] + ) + texture = pattern.GetPowderPatternComponent(0).GetTextureMarchDollase() + held = [texture.GetPar(i) for i in range(texture.GetNbPar())] + texture.DeletePhase(0) + for par in held[:5]: + assert_par_invalidated(par) + assert held[5].GetValue() == pytest.approx(0.3) + assert texture.GetPar("Fraction_0").GetValue() == pytest.approx(0.3) + assert pattern.GetPowderPatternCalc().max() > 0 + + +def test_background_set_interp_points_invalidates_held_pars(): + # Test that SetInterpPoints invalidates wrappers of the old + # interpolation point parameters, whose values it reallocates + # Expected: Old Background_Point pars raise TypeError, new pars work. + pattern = PowderPattern() + x = np.deg2rad(np.linspace(5, 40, 101)) + pattern.SetPowderPatternX(x) + pattern.SetPowderPatternObs(np.ones_like(x)) + background = pattern.AddPowderPatternBackground() + background.SetInterpPoints(np.deg2rad([5.0, 20.0, 40.0]), np.ones(3)) + held = background.GetPar("Background_Point_1") + background.SetInterpPoints(np.deg2rad(np.linspace(5, 40, 50)), np.ones(50)) + assert_par_invalidated(held) + par = background.GetPar("Background_Point_3") + par.SetValue(2.0) + assert par.GetValue() == 2.0 + assert pattern.GetPowderPatternCalc().max() > 0 + + def test_get_powder_pattern_calc_after_march_coeff_par_change(loadcifdata): # Test refining the March coefficient through its RefinablePar # Expected: The pattern equals one built with the new March diff --git a/tests/test_reflectionprofile.py b/tests/test_reflectionprofile.py index 74f5694..fc51716 100644 --- a/tests/test_reflectionprofile.py +++ b/tests/test_reflectionprofile.py @@ -289,6 +289,42 @@ def test_set_profile_accepts_temporary(self): self.assertFalse(profile.IsAnisotropic()) self.assertGreater(self.pp.GetPowderPatternCalc().max(), 0) + def test_set_profile_keeps_replaced_profile_valid(self): + """Regression test for #121: a held wrapper of a replaced + profile stays valid, and GetProfile returns the new profile type + even when it is allocated at the address of the old one.""" + held = [] + for i in range(20): + old = self.ppd.GetProfile() + held.append((old, type(old))) + cls = ( + ReflectionProfilePseudoVoigtAnisotropic + if i % 2 == 0 + else ReflectionProfilePseudoVoigt + ) + self.ppd.SetProfile(cls()) + new = self.ppd.GetProfile() + self.assertIs(type(new), cls) + self.assertIsNot(new, old) + for profile, profile_type in held: + self.assertIs(type(profile), profile_type) + self.assertEqual(profile.GetPar("W").GetName(), "W") + self.assertGreater(self.pp.GetPowderPatternCalc().max(), 0) + + def test_set_reflection_profile_par_keeps_replaced_profile_valid(self): + """SetReflectionProfilePar replaces the profile; the held old + profile stays usable after the pattern is deleted.""" + old = self.ppd.GetProfile() + self.ppd.SetReflectionProfilePar(fwhmCagliotiW=2e-6) + new = self.ppd.GetProfile() + self.assertIsNot(new, old) + self.assertAlmostEqual(new.GetPar("W").GetValue(), 2e-6) + old.GetPar("W").SetValue(5e-6) + self.assertAlmostEqual(new.GetPar("W").GetValue(), 2e-6) + del self.pp, self.ppd, new + gc.collect() + self.assertAlmostEqual(old.GetPar("W").GetValue(), 5e-6) + def build_tof_pattern(crystal, profile): """Return a TOF neutron powder pattern of crystal using profile.""" From e886efc934f73bf4295dc4f54caa9045b6d90990 Mon Sep 17 00:00:00 2001 From: Vincent Favre-Nicolin Date: Mon, 16 Nov 2026 13:50:58 +0800 Subject: [PATCH 2/4] chore: update extern/objcryst to merged vincefn/objcryst#106 (0f8dfef) Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- extern/objcryst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/extern/objcryst b/extern/objcryst index a3d75af..0f8dfef 160000 --- a/extern/objcryst +++ b/extern/objcryst @@ -1 +1 @@ -Subproject commit a3d75afbff0a249616f0732ee03a46dfd840dc25 +Subproject commit 0f8dfefcd8e3d2f58509952194ec989ae64769de From f4dbe1e2afc09c50c38700d0fb3fe8e432877b84 Mon Sep 17 00:00:00 2001 From: Vincent Favre-Nicolin Date: Mon, 16 Nov 2026 13:52:32 +0800 Subject: [PATCH 3/4] docs: shorten release-hooks news item Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- news/objcryst-release-hooks.rst | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/news/objcryst-release-hooks.rst b/news/objcryst-release-hooks.rst index 980df54..67f9f78 100644 --- a/news/objcryst-release-hooks.rst +++ b/news/objcryst-release-hooks.rst @@ -4,8 +4,7 @@ **Changed:** -* ``Crystal.RemoveScatterer``, ``Crystal.RemoveScatteringPower`` (when the scattering power is no longer used) and the ``Molecule.Remove*`` methods now delete the removed object unless a Python wrapper still references it, instead of leaking it. -* Update the vendored ObjCryst++ to the ``ReleaseObj()`` hook API (vincefn/objcryst#106). +* Removed scatterers, scattering powers and molecule sub-objects are now deleted instead of leaked, unless still referenced from Python. **Deprecated:** @@ -17,8 +16,7 @@ **Fixed:** -* Fix dangling Python wrappers, use-after-free and double free when ObjCryst++ deletes sub-objects that are still referenced from Python (#121, #132). Removed or replaced objects (reflection profiles, scatterers, scattering powers, molecule atoms and restraints) now stay valid while a Python wrapper references them, and ``GetProfile`` no longer returns a stale wrapper of the wrong type after ``SetProfile``. Wrappers of deleted ``RefinablePar`` objects (e.g. after ``PowderPatternBackground.SetInterpPoints`` or ``TextureMarchDollase.DeletePhase``) are invalidated and raise ``TypeError`` instead of accessing freed memory. -* Fix the double free when ``Crystal.ConnectAtoms`` merges atoms owned by Python. +* Fix crashes (use-after-free, double free) and stale wrappers when ObjCryst++ deletes objects still referenced from Python (#121, #132). **Security:** From 0eed08c495c3f6d74b0691dd980bd947867b7a28 Mon Sep 17 00:00:00 2001 From: Vincent Favre-Nicolin Date: Mon, 16 Nov 2026 14:00:33 +0800 Subject: [PATCH 4/4] chore: rename news item to PR number Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- news/{objcryst-release-hooks.rst => 133.rst} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename news/{objcryst-release-hooks.rst => 133.rst} (100%) diff --git a/news/objcryst-release-hooks.rst b/news/133.rst similarity index 100% rename from news/objcryst-release-hooks.rst rename to news/133.rst