pub fn run(mut self) -> io::Result<()> {
        // Size of a buffer for reading one request from the kernel. Since the kernel may send up
        // to `max_write_size` bytes in a write request, we use that value plus some extra space.
        // FIXME: This should depend on the actual page size the kernel uses
        let buffer_size = self.max_write_size + 4096;

        // Buffer for receiving requests from the kernel. Only one is allocated for now and it's
        // reused immediately after dispatching to conserve memory and allocations.
        // TODO: Implement multiple buffers and concurrent dispatch of async operations
        // TODO: Add a configurable pool of preallocated/dynamic buffers
        let mut buffer = vec![0; buffer_size];

        // Read and dispatch requests from the kernel driver
        while let Some(packet) = self.next_packet(&mut buffer)? {
            match Request::try_from(packet) {
                // Request parsed successfully, dispatch it
                Ok(request) => {
                    self.dispatch_request(request);
                }
                // Error parsing the request, log a warning and try next
                Err(err) => warn!("{}", err),
            }
        }
        Ok(())
    }
/// Run the session.
///
/// Runs the session loop of a mounted filesystem. The session loop receives filesystem
/// operation requests from the FUSE kernel driver and dispatches them to method calls into the
/// filesystem implementation until the filesystem gets unmounted.
///
/// This function doesn't return until the filesystem is unmounted.
Run the session.
Runs the session loop of a mounted filesystem. The session loop receives filesystem
operation requests from the FUSE kernel driver and dispatches them to method calls into the
filesystem implementation until the filesystem gets unmounted.

This function doesn't return until the filesystem is unmounted.
Run the session . Runs the session loop of a mounted filesystem . The session loop receives filesystem operation requests from the FUSE kernel driver and dispatches them to method calls into the filesystem implementation until the filesystem gets unmounted . This function doesn ' t return until the filesystem is unmounted .
pub fn run(mut self) -> io::Result<()> {
        // Size of a buffer for reading one request from the kernel. Since the kernel may send up
        // to `max_write_size` bytes in a write request, we use that value plus some extra space.
        // FIXME: This should depend on the actual page size the kernel uses
        let buffer_size = self.max_write_size + 4096;
        // Buffer for receiving requests from the kernel. Only one is allocated for now and it's
        // reused immediately after dispatching to conserve memory and allocations.
        // TODO: Implement multiple buffers and concurrent dispatch of async operations
        // TODO: Add a configurable pool of preallocated/dynamic buffers
        let mut buffer = vec![0; buffer_size];
        // Read and dispatch requests from the kernel driver
        while let Some(packet) = self.next_packet(&mut buffer)? {
            match Request::try_from(packet) {
                // Request parsed successfully, dispatch it
                Ok(request) => {
                    self.dispatch_request(request);
                }
                // Error parsing the request, log a warning and try next
                Err(err) => warn!("{}", err),
            }
        }
        Ok(())
    }
pub fn run ( mut self ) -> io :: Result < ( ) > { // Size of a buffer for reading one request from the kernel. Since the kernel may send up // to `max_write_size` bytes in a write request, we use that value plus some extra space. // FIXME: This should depend on the actual page size the kernel uses let buffer_size = self . max_write_size + 4096 ; // Buffer for receiving requests from the kernel. Only one is allocated for now and it's // reused immediately after dispatching to conserve memory and allocations. // TODO: Implement multiple buffers and concurrent dispatch of async operations // TODO: Add a configurable pool of preallocated/dynamic buffers let mut buffer = vec ! [ 0 buffer_size ] ; // Read and dispatch requests from the kernel driver while let Some ( packet ) = self . next_packet ( & mut buffer ) ? { match Request :: try_from ( packet ) { // Request parsed successfully, dispatch it Ok ( request ) => { self . dispatch_request ( request ) ; } // Error parsing the request, log a warning and try next Err ( err ) => warn ! ( " " err ) , } } Ok ( ( ) ) }
Run the session.
Run the session .
mut self
mut self