Different return values for functionallity identical calls to openat2 and io_uring_prep_openat2?

[kevincianfarini]

I'm writing bindings for liburing to Kotlin Native via ffi, so my below examples will be in Kotlin. I'll heavily comment them but can conjure a C example if necessary.

I'm using io_uring_prep_openat2 to try and get a file descriptor. Below is an excerpt of that operation:

public suspend fun open(
    filePath: String,
    directoryFileDescriptor: Int = AT_FDCWD, /* A default parameter of AT_FDCWD. */
    flags: Int = 0,
    mode: Int = 0,
    resolve: Int = 0,
): Int {
    val sqe: io_uring_sqe = ring.getSqe() // Get a SQE structure from io_uring
    val how = arena.alloc<open_how> { // Allocate some memory for the open_how struct and populate it with flags

       // All of these flags will be 0 under test. 

        this.flags = flags.convert() // Int.convert() will coerce values to what the C API expects -- in this case unsigned values. 
        this.mode = mode.convert()
        this.resolve = resolve.convert()
    }
    io_uring_prep_openat2(
        sqe = sqe.ptr, // A pointer to the SQE
        dfd = directoryFileDescriptor, // Under test this values if AT_FDCWD.
        path = filePath,  // A relative filepath within the CWD of the process. 
        how = how.ptr, // a pointer to the open_how struct. 
    )
    io_uring_sqe_set_data64(sqe = sqe.ptr, data = /* Some custom data not important in here.*/)
    io_uring_submit(ring.ptr)

    return /* Async process the CQE and return a value */
}

When I run this function I am getting a io_uring_cqe->res value of -2. If I am understanding the manpage for the return value here correctly:

The CQE res field will contain the result of the operation. See the related man page for details on possible values. Note that where synchronous system calls will return -1 on failure and set errno to the actual error value, io_uring never uses errno. Instead it returns the negated errno directly in the CQE res field.

This res value if an errno of 2 and corresponds to a file or directory not being found.

In contrast, when I perform functionally the same operation via the synchronous openat2 syscall I get a valid file descriptor returned with all of the same parameters.

val fd = syscall(
    SYS_openat2,
    AT_FDCWD,
    "./src/linuxX64Test/resources/hello.txt",
    alloc<open_how> {
        this.resolve = 0u
        this.flags = 0u
        this.resolve = 0u
    }.ptr,
    sizeOf<open_how>(),
)

val array = allocArray<ByteVar>(100) // Allocate an array of 100 bytes. 
read(fd.convert(), array, 100.convert())

println(array.toKStringFromUtf8()) /* Prints "hello world!" */

I am curious to hear why this might be occurring and would appreciate any guidance here.

[axboe]

I'll heavily comment them but can conjure a C example if necessary.

Please do, whatever it'll save us/me some time.

[kevincianfarini]

Hi @axboe. Thanks for responding.

It turns out that the pointer I was passing to path was no longer valid once it was no longer on the stack. This is a Kotlin Native quirk and nothing to do with liburing -- it just took a good night's sleep to see the issue.

I apologize for the bother. For anyone else reading this thread in the future, I had to ensure that the pointer to the file path was pinned in memory. This ensures that its address won't change during garbage collection until you unpin that value.

[axboe]

Ah I see. This is true for anything that passes in memory to a struct, it needs to be stable until it has been submitted (not until completion).