errno to Go errors

I'm trying to issue KVM ioctls from Go code. At the moment I have something as follows:

func (vm *Vm) RegisterIrqFd(efd *EventFd, gsi uint32) error {
	irqfd := (*C.struct_kvm_irqfd)(C.calloc(1, C.sizeof_struct_kvm_irqfd))
	defer C.free(unsafe.Pointer(irqfd))
	irqfd.fd = C.uint(efd.Fd())
	irqfd.gsi = C.uint(gsi)
	if _, err := sysutils.Ioctl(vm.Fd(), C.KVM_IRQFD, uintptr(unsafe.Pointer(irqfd))); err != nil {
		return fmt.Errorf("RegisterIrqFd failed: %v", err)
	}
	return nil
}

The Ioctl function is implemented as follows :

func Ioctl(fd uintptr, cmd C.uint, arg uintptr) (uintptr, error) {
	ret, _, errno := syscall.Syscall(
		syscall.SYS_IOCTL,
		fd,
		uintptr(cmd),
		uintptr(arg),
	)
	if int64(ret) == -1 {
		return ret, ErrnoToErr(errno)
	}
	return ret, nil
}

And the ErrnoToErr function is implemented as follows :

func ErrnoToErr(errno syscall.Errno) error {
	return fmt.Errorf("%v", errno.Error())
}

1. Inside GetSupportedCpuid, the argument for the ioctl, cpuid is allocated using C.calloc. If this were C code cpuid could just be allocated on the stack. Is there any way I can get around allocating using calloc and using free? Any alternatives that would be more idiomatic?
2. Would there be a way to have ErrnoToErr return a go error type corresponding to the errno? Currently it uses the (e Errno) Error() inside syscall/syscall_unix.go; so it just dereferences a list of strings and returns the string. It would be nice to have a type, so that I can test for specific errors in my unit tests.

Replying just to the updated example, we could do this:

func (vm *Vm) RegisterIrqFd(efd *EventFd, gsi uint32) error {
    irqfd := C.struct_kvm_irqfd{}
    irqfd.fd = C.uint(efd.Fd())
    irqfd.gsi = C.uint(gsi)
    if _, err := sysutils.Ioctl(vm.Fd(), C.KVM_IRQFD, uintptr(unsafe.Pointer(&irqfd))); err != nil {
        return fmt.Errorf("RegisterIrqFd failed: %v", err)
    }
    return nil
}

I think this is safe, but we might find that irqfd escapes to heap anyway since we take its address here, in which case there's not much savings. Even so, as long as this doesn't violate Go pointer rules (I don't think it does) it's a lot nicer to read.

Read the documentation syscall.Errno

So convertion may be performed like this

func ErrnoToErr(errno syscall.Errno) error {
	if errno != 0 {
		return errno
	}
	return nil
}

For equality it only states

> Errno values can be tested against error values from the os package
> using errors.Is.

The question of comparing errors was already considered here How to compare Go errors