Go vet reports "possible misuse of reflect.SliceHeader"

I have the following code snippet which "go vet" complains about with the warning "possible misuse of reflect.SliceHeader". I can not find very much information about this warning other then this. After reading that it is not very clear to me what is needed to do this in a way that makes go vet happy - and without possible gc issues.

The goal of the snippet is to have a go function copy data to memory which is managed by an opaque C library. The Go function expects a []byte as a parameter.

func Callback(ptr unsafe.Pointer, buffer unsafe.Pointer, size C.longlong) C.longlong {
        ...
        sh := &reflect.SliceHeader{
                Data: uintptr(buffer),
                Len:  int(size),
                Cap:  int(size),
        }
        buf := *(*[]byte)(unsafe.Pointer(sh))
        err := CopyToSlice(buf)
	    if err != nil {
		   log.Fatal("failed to copy to slice")
	    }
        ...
}

https://pkg.go.dev/unsafe@go1.19.4#Pointer

> Pointer represents a pointer to an arbitrary type. There are four
> special operations available for type Pointer that are not available
> for other types:
>
> - A pointer value of any type can be converted to a Pointer.
> - A Pointer can be converted to a pointer value of any type.
> - A uintptr can be converted to a Pointer.
> - A Pointer can be converted to a uintptr.
>
> Pointer therefore allows a program to defeat the type system and read
> and write arbitrary memory. It should be used with extreme care.
>
> The following patterns involving Pointer are valid. Code not using
> these patterns is likely to be invalid today or to become invalid in
> the future. Even the valid patterns below come with important caveats.
>
> Running "go vet" can help find uses of Pointer that do not conform to
> these patterns, but silence from "go vet" is not a guarantee that the
> code is valid.

> (6) Conversion of a reflect.SliceHeader or reflect.StringHeader Data
> field to or from Pointer.
>
> As in the previous case, the reflect data structures SliceHeader and
> StringHeader declare the field Data as a uintptr to keep callers from
> changing the result to an arbitrary type without first importing
> "unsafe". However, this means that SliceHeader and StringHeader are
> only valid when interpreting the content of an actual slice or string
> value.
>
> go
> var s string
> hdr := (*reflect.StringHeader)(unsafe.Pointer(&s)) // case 1
> hdr.Data = uintptr(unsafe.Pointer(p)) // case 6 (this case)
> hdr.Len = n
>
>
> In this usage hdr.Data is really an alternate way to refer to the
> underlying pointer in the string header, not a uintptr variable
> itself.
>
> In general, reflect.SliceHeader and reflect.StringHeader should be used only as *reflect.SliceHeader and *reflect.StringHeader pointing at actual slices or strings, never as plain structs. A program should not declare or allocate variables of these struct types.
>
> go
> // INVALID: a directly-declared header will not hold Data as a reference.
> var hdr reflect.StringHeader
> hdr.Data = uintptr(unsafe.Pointer(p))
> hdr.Len = n
> s := *(*string)(unsafe.Pointer(&hdr)) // p possibly already lost
>

It looks like JimB (from the comments) hinted upon the most correct answer, though he didn't post it as an answer and he didn't include an example. The following passes go vet, staticcheck, and golangci-lint - and doesn't segfault so I think it is the correct answer.

func Callback(ptr unsafe.Pointer, buffer unsafe.Pointer, size C.longlong) C.longlong {
        ...
        buf := unsafe.Slice((*byte)(buffer), size)
        err := CopyToSlice(buf)
        if err != nil {
           log.Fatal("failed to copy to slice")
        }
        ...
}