Need help understanding how scm_init_guile works (with FUSE)

Hi guile-users,

I am working on a guile program to interact with FUSE. The code is at 
https://gitlab.com/danielittlewood0/diffuse. I have managed to get it to 
basically work, but there are some things I don't understand. It 
consists of essentially two files at the moment:

  * other.scm, which implements the actual logic of the filesystem in guile.
  * hello.c, which does the plumbing into the FUSE library.

I managed to get it to work by doing the following in each of the FUSE 
handlers:

scm_init_guile()
scm_c_primitive_load("/full/path/to/other.scm")
scm_call_1(scm_variable_ref(scm_c_lookup("whatever-function-I-want")))

That worked fine, but I was a bit confused about having to call 
scm_init_guile so many times. I expected to just call it once in main 
and then never again. If I do that, i.e. just move scm_init_guile to 
main and remove all the other callers (rest of the code unchanged) I get 
a segfault.

I was also surprised that I had to give the absolute file path of my 
guile script to scm_c_primitive_load. If I called it from main then I 
didn't have to do that. If I call scm_c_primitive_load from main then I 
can give a relative path, but from e.g. hello_read I get a "No such file 
or directory" error and have to provide the absolute path.

I think this is something peculiar to how FUSE is set up, but I don't 
know what exactly. I don't actually call the handlers, I pass the 
function pointers to the library and the library calls them for me. For 
instance if I try to print the current working directory from within one 
of the handlers, I get / - which probably refers to the root of the FUSE 
filesystem tree. I managed to avoid giving the absolute path by calling 
scm_init_guile() and then scm_c_primitive_load("other.scm") from main. 
This works (with the relative path). What's surprising to me is:

  * I still have to call scm_init_guile before every use of guile within
    the current function, even if I called it in main.
  * When I call scm_init_guile a second time, I don't have to call
    scm_primitive_load a second time. I can just call scm_variable_ref
    immediately.

This is a bit confusing to me. I could understand if I had to load the 
code every time I call scm_init_guile (although then I'd want to reduce 
the boilerplate) and I could understand calling scm_init_guile and 
scm_c_primitive_load only once, but the arrangement above doesn't make 
sense to me. I feel like I must be missing something.

Note that this is the first project I've really written in either C or 
guile, so I might be missing something obvious.

Best wishes,
Dan