/*  * Filesystem client functions.  *  * Copyright (C) 2018, 2019, 2020, 2021 Paul Boddie <paul@boddie.org.uk>  *  * This program is free software; you can redistribute it and/or  * modify it under the terms of the GNU General Public License as  * published by the Free Software Foundation; either version 2 of  * the License, or (at your option) any later version.  *  * This program is distributed in the hope that it will be useful,  * but WITHOUT ANY WARRANTY; without even the implied warranty of  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  * GNU General Public License for more details.  *  * You should have received a copy of the GNU General Public License  * along with this program; if not, write to the Free Software  * Foundation, Inc., 51 Franklin Street, Fifth Floor,  * Boston, MA  02110-1301, USA  */  #include <l4/re/env.h>  #include <stdio.h> #include <stdlib.h>  #include "client.h"    /* Default size of pipe regions. */  const offset_t DEFAULT_PIPE_SIZE = 4096;    /* Access the given position and synchronise state with the file object. */  static long _access(file_t *file, offset_t position) {   long err;    if (file->can_mmap)   {     /* Where the position is outside the current region, re-map. */      if ((position < file->start_pos) || (position >= file->end_pos))     {       if (file_mmap(file, position, file_span(file)))         return -L4_EIO;     }      /* Otherwise, flush any written data in the current region and update the        file size details. */      else     {       err = client_flush(file);       if (err)         return err;     }   }   else   {     /* Strict conditions for region navigation in pipes. */      if ((position < file->start_pos) || (position > file->end_pos))     {       return -L4_EIO;     }      /* The next region is only available at the end of the mapped memory. */      else if (position == file->end_pos)     {       err = client_next_region(file);       if (err)         return err;        file->data_current = 0;       return L4_EOK;     }      /* Within the current pipe region, synchronise with the pipe object. */      else     {       err = client_current_region(file);       if (err)         return err;     }   }    /* Update the current data offset. */    file->data_current = position - file->start_pos;    return L4_EOK; }    /* Return whether an access could occur, blocking if necessary. */  static int _access_blocking(file_t *file, offset_t position) {   long err;    while ((err = _access(file, position)))   {     /* Exit if blocking is not configured or suitable. */      if ((err != -L4_EBUSY) || !file->can_block)       return 0;      /* Handle an inability to access by blocking, exiting if waiting failed. */      if (client_wait_file(file))       return 0;   }    return 1; }    /* Ensure that memory is mapped for accessing the given file, using the    indicated count as a region size hint. */  static void *_map_memory(file_t *file, offset_t count) {   if (file->memory == NULL)   {     if (file->can_mmap)       return client_mmap(file, client_tell(file), count);     else if (pipe_current(file))       return NULL;   }    return file->memory; }    /* Open a file opening object. */  l4_cap_idx_t client_open_for_user(user_t user) {   l4_cap_idx_t server = l4re_env_get_cap("server");    return client_open_for_user_using(user, server); }  /* Open a file opening object via a named capability. */  l4_cap_idx_t client_open_for_user_using(user_t user, l4_cap_idx_t server) {   if (l4_is_invalid_cap(server))     return L4_INVALID_CAP;    l4_cap_idx_t opener;   long err = file_open_for_user(user, server, &opener);    if (err)     return L4_INVALID_CAP;    return opener; }    /* Close a filesystem object. */  void client_close(file_t *file) {   if (file == NULL)     return;    file_close(file);   free(file); }    /* Open a filesystem object. */  file_t *client_open(const char *name, flags_t flags) {   l4_cap_idx_t server = l4re_env_get_cap("server");    return client_open_using(name, flags, server); }  /* Open a filesystem object via a named capability. */  file_t *client_open_using(const char *name, flags_t flags, l4_cap_idx_t server) {   if (l4_is_invalid_cap(server))     return NULL;    file_t *file = (file_t *) malloc(sizeof(file_t));    if (file == NULL)     return NULL;    if (file_open(file, name, flags, server))   {     free(file);     return NULL;   }    return file; }    /* Open a pipe object. */  long client_pipe(file_t **reader, file_t **writer) {   l4_cap_idx_t server = l4re_env_get_cap("pipes");    return client_pipe_using(reader, writer, server); }  long client_pipe_using(file_t **reader, file_t **writer, l4_cap_idx_t server) {   if (l4_is_invalid_cap(server))     return -L4_EINVAL;    *reader = (file_t *) malloc(sizeof(file_t));    if (*reader == NULL)     return -L4_ENOMEM;    *writer = (file_t *) malloc(sizeof(file_t));    if (*writer == NULL)   {     free(*reader);     return -L4_ENOMEM;   }    long err = pipe_open(DEFAULT_PIPE_SIZE, *reader, *writer, server);    if (err)   {     free(*reader);     free(*writer);   }    return err; }    /* Flush data explicitly to the filesystem object. */  long client_flush(file_t *file) {   if (file == NULL)     return -L4_EINVAL;    /* Flush and retain most buffer settings. */    return file_flush(file); }    /* Map a memory region to a file. */  void *client_mmap(file_t *file, offset_t position, offset_t length) {   if ((file == NULL) || (file_mmap(file, position, length)))     return NULL;    return file->memory; }    /* Obtain the current region of a pipe. */  long client_current_region(file_t *file) {   if (file == NULL)     return -L4_EINVAL;    return pipe_current(file); }    /* Obtain the next region of a pipe. */  long client_next_region(file_t *file) {   if (file == NULL)     return -L4_EINVAL;    return pipe_next(file); }    /* Read from the filesystem object into the buffer provided. */  offset_t client_read(file_t *file, void *buf, offset_t count) {   if (file == NULL)     return 0;    /* Map memory if none has been mapped so far. */    if (_map_memory(file, count) == NULL)     return 0;    /* Amount available in the descriptor buffer already. */    offset_t available = file_data_available(file);   offset_t to_transfer, total = 0;    while (count > 0)   {     /* If there is no data, try and obtain more data. */      if (!available)     {       /* Flush any unwritten data, preparing to read from the file position at          the end of the data, and returning if no new data is available. */        if (!_access_blocking(file, file_data_end_position(file)))         break;        available = file_data_available(file);        if (!available)         break;     }      /* Transfer data into the supplied buffer. */      to_transfer = available <= count ? available : count;      file_data_read(file, (char *) buf, to_transfer);      /* Update counters. */      available -= to_transfer;      count -= to_transfer;     total += to_transfer;      buf = ((char *) buf + to_transfer);   }    return total; }    /* Ensure that the buffer can provide the needed data. */  offset_t client_seek(file_t *file, offset_t offset, int whence) {   if (file == NULL)     return 0;    offset_t position, current = file_data_current_position(file), change;    switch (whence)   {     case SEEK_SET:       position = offset;       break;      case SEEK_CUR:       position = current + offset;       break;      case SEEK_END:       position = file->size + offset;       break;      default:       /* NOTE: Set errno to EINVAL. */       return current;   }    /* Retain the current position if unchanged. */    if (position == current)     return position;    /* Move forward in the file. */    if (position > current)   {     change = position - current;      /* Move towards the end of available data.        Request new data if not enough is available. */      if (change <= file_data_available(file))     {       file->data_current += change;       return position;     }   }    /* Move backward in the file. */    else   {     change = current - position;      /* Move towards the start of available data.        Request new data if moving beyond the start of the data. */      if (change <= file->data_current)     {       file->data_current -= change;       return position;     }   }    /* Handle unwritten data and reset the buffer for reading. */    if (_access(file, position))     return current;    return position; }    /* Set or unset blocking access for a file. */  long client_set_blocking(file_t *file, notify_flags_t flags) {   long err;    if (file->can_block == flags)     return L4_EOK;    // NOTE: Set appropriate flags.    if (flags)     err = client_subscribe(file, flags);   else     err = client_unsubscribe(file);    if (err)     return err;    file->can_block = flags;   return L4_EOK; }    /* Subscribe from events concerning a file. */  long client_subscribe(file_t *file, notify_flags_t flags) {   if (file == NULL)     return -L4_EINVAL;    return file_notify_subscribe(file, flags); }    /* Return the current position in the file. */  long client_tell(file_t *file) {   if (file == NULL)     return -L4_EINVAL;    return file_data_current_position(file); }    /* Unsubscribe from events concerning a file. */  long client_unsubscribe(file_t *file) {   if (file == NULL)     return -L4_EINVAL;    return file_notify_unsubscribe(file); }    /* Wait for events involving a specific file. */  long client_wait_file(file_t *file) {   if (file == NULL)     return -L4_EINVAL;    return file_notify_wait_file(file); }  /* Wait for events concerning files, referencing a file object if an event is    delivered. */  long client_wait_files(file_t **file) {   return file_notify_wait_files(file); }    /* Write to the filesystem object from the buffer provided. */  offset_t client_write(file_t *file, const void *buf, offset_t count) {   if (file == NULL)     return 0;    /* Map memory if none has been mapped so far. */    if (_map_memory(file, count) == NULL)     return 0;    /* Attempt to ensure that the file can accept the amount of data to be      written. This may not resize to the needed amount if a file has a fixed      size, but data will still be written to any available space. */    offset_t needed_size = file_data_current_position(file) + count;    if (file->has_size)   {     if (file->size < needed_size)     {       file_resize(file, needed_size);        if (file->size < needed_size)         count = file->size - file_data_current_position(file);     }   }    /* Space remaining in the descriptor buffer. */    offset_t space = file_data_space(file);   offset_t to_transfer, total = 0;    while (count > 0)   {     /* If no space is available, try and send data, reset the buffer. */      if (!space)     {       /* Flush any unwritten data and continue writing from the current data          position. */        if (!_access_blocking(file, file_data_current_position(file)))         break;        space = file_data_space(file);     }      /* Transfer data into the supplied buffer. */      to_transfer = space <= count ? space : count;      file_data_write(file, (char *) buf, to_transfer);      /* Update counters. */      space -= to_transfer;      count -= to_transfer;     total += to_transfer;      buf = ((char *) buf + to_transfer);   }    return total; }  // vim: tabstop=2 expandtab shiftwidth=2