AsyncRead wrapper over sync read

I met this problem while implementing AsyncRead over a synchronized read to adjust to the async world in Rust.

The sync read implementation I'm handling is a wrapper over a raw C sync implementation, much like the std::fs::File::read; therefore I would use std::io::Read for simplicity hereafter.

Here's the code:

use futures::{AsyncRead, Future};
use std::task::{Context, Poll};
use std::pin::Pin;
use tokio::task;
use std::fs::File;
use std::io::Read;
use std::io::Result;

struct FileAsyncRead {
    path: String
}

impl AsyncRead for FileAsyncRead {
    fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut [u8]) -> Poll<Result<usize>> {
        let path = self.path.to_owned();
        let buf_len = buf.len();
        let mut handle = task::spawn_blocking(move || {
            let mut vec = vec![0u8; buf_len];
            let mut file = File::open(path).unwrap();
            let len = file.read(vec.as_mut_slice());
            (vec, len)
        });

        match Pin::new(&mut handle).poll(cx) {
            Poll::Ready(l) => {
                let v_l = l.unwrap();
                let _c_l = v_l.0.as_slice().read(buf);
                Poll::Ready(v_l.1)
            }
            Poll::Pending => Poll::Pending
        }
    }
}

The current implementation is creating a new vector of the same size with the outer buf: &mut [u8] each time because of :

`buf` has an anonymous lifetime `'_` but it needs to satisfy a `'static` lifetime requirement

 buf: &mut [u8],
    |                --------- this data with an anonymous lifetime `'_`...

My question is:

1. Is that possible to avoid the vector creation in spwan_blocking and mutate the buf in poll_read? To avoid vector allocation as well as copying?
2. Is there a better way to express this "wrapper" logic instead of spawn_blocking as well as Pin::new(&mut handle).poll(cx)? What's the more idiomatic way to do this in Rust?