[BUG] Binding many properties of an object leads to a SIGABRT crash

[Daru-san]

Bug description

I am writing a program that needs to continuously bind and unbind properties of one object to the properties of multiple other objects.

Using Object::bind_property, this eventually leads to a core dump with SIGABRT.

An representation of how the bindings are created is shown below. The bind function may be called multiple times in the same minute, for different instances of SomeObject but the same instance of MusicPlayer.

Even if the frequency at which bind is called is reduced, after about 5 calls, spaced out between multiple minutes, the program still crashes.

fn bind(player: &MusicPlayer, object: &SomeObject) {
    player
        .bind_property("title", object, "prop-1")
        .sync_create()
        .build();
    player
        .bind_property("artist", object, "prop-2")
        .sync_create()
        .build();
    player
        .bind_property("album", object, "prop-3")
        .sync_create()
        .build();
    player
        .bind_property("album-artist", object, "prop-4")
        .sync_create()
        .build();
}

Backtrace

The provided logs have been routed through tracing.

2025-12-22T08:57:50.319536Z ERROR backend::gtk: Too many GWeakRef registered
2025-12-22T08:57:50.319555Z ERROR scarlet: **
GLib-GObject:ERROR:../gobject/gbinding.c:805:g_binding_constructed: assertion failed: (source != NULL)

[sdroege]

Can you provide a minimal testcase for this problem?

Specifically, Too many GWeakRef registered is also very interesting.

[sdroege]

That warning comes from GLib only allowing up to 65535 weak references to the same object btw, and each property binding involves weak references. Is it expected in your case to have that many pointing to the same object?

[carlosmn]

Well I can certainly reproduce this with

    let a: A = Object::new();
    let b: B = Object::new();

    loop {
        let binding = a.bind_property("field", &b, "field").sync_create().build();
    }

but not if I call binding.unbind().

I was a bit surprised it doesn't unref on Drop but I suppose it makes sense for convenience if you do want to rely on the destruction of the objects involved, though the docs from GTK imply that's what you probably want to do.

Either way, it does look like you could end up with the binding leaking if you the bind() function is as described and the objects are not destroyed, but otherwise, it looks like it should be working like in my attempt at a repro

    let a: A = Object::new();

    loop {
        let b: B = Object::new();
        let binding = a.bind_property("field", &b, "field").sync_create().build();
    }

where the b object does get destroyed at the end of each iteration and it will happily keep running that loop until I kill it.

[sdroege]

For destroying a binding, you either need to call unbind() on it or one of the two objects involved needs to be destroyed (i.e. its last reference needs to be dropped). So this seems all intentional and correct.

[Daru-san]

I have a case similar to the one shown below.
I bind one property of one object to those of many, at the end, I call unbind for all the bindings, but I do not free the objects.

When this process runs a few times, the program eventually crashes. It seems as if the existing weak references are not freed, even after unbind is called.

let a: A = Object::new();
let mut bindings = Vec::<Binding>::new();
let mut objects = Vec::<C>::new();

loop {
  // We need to bind the properties of one object to those of many others
  for _ in 1..50 {
    let object : C = Object::new();
    bindings.push(a.bind_property("field", object, "field").sync_create().build());
    objects.push(object);
  }

  // .. Do some other stuff

  // Unbind
  bindings.drain(..).for_each(|binding|{
    binding.unbind();
  });
}

When using Object::connect to create a similar binding effect, the program does not crash.

let a: A = Object::new();
let mut signal_handler_ids = Vec::<SignalHandlerId>::new();
let mut objects = Vec::<C>::new();

loop {
  // We need to bind the properties of one object to those of many others
  for _ in 1..50 {
    let object : C = Object::new();
    signal_handler_ids.push(a.connect_field_notify(glib::clone!(
      #[weak]
      object,
      move |a| {
        object.set_field(a.field());
      }
    ));

    // We need to call notify to replicate the `sync_create` functionality of `Object::bind_property`.
    a.notify("field");

    objects.push(object);
  }

  // .. Do some other stuff

 signal_handler_ids.drain(..).for_each(|signal_handler_id| {
  a.disconnect(signal_handler_id); 
});
}

When Binding::unbind is called, are the weak references to the objects bound to each other also freed?
The same goes with Object::connect.

[sdroege]

That's all handled inside GObject (the C library) so you probably want to bring that up over at https://gitlab.gnome.org/GNOME/glib/-/issues/new , ideally with a C testcase.