/*  * Filesystem client functions.  *  * Copyright (C) 2018-2024 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 <string.h>  #include <mem/memory_utils.h> #include <systypes/env.h> #include <systypes/fcntl.h>  #include "client.h"    /* Default size of pipe regions. */  static const offset_t DEFAULT_PIPE_SIZE = 4096;  /* Size of the core member region of a directory entry structure. */  static const offset_t DIRENT_CORE_SIZE = (sizeof(struct dirent) - sizeof(((struct dirent *) 0)->d_name));    /* Merging of region flags from protection and access flags. */  static rm_flags_t _combine_region_flags(rm_flags_t region_flags, flags_t flags) {   return region_flags & (file_region_flags(flags) | L4RE_RM_F_X); }  /* Conversion of protection and access flags to region flags. */  rm_flags_t client_region_flags(prot_t prot, flags_t flags) {   rm_flags_t rm_flags = 0;    if (prot & PROT_READ)     rm_flags |= L4RE_RM_F_R;   if (prot & PROT_WRITE)     rm_flags |= L4RE_RM_F_W;   if (prot & PROT_EXEC)     rm_flags |= L4RE_RM_F_X;    return _combine_region_flags(rm_flags, flags); }    /* Access the given position and synchronise state with the file object. Pipe    objects may return busy conditions indicating that the desired access cannot    yet be fulfilled. */  static long _access(file_t *file, offset_t position) {   long err;    if (file->object_flags & OBJECT_SUPPORTS_MMAP)   {     offset_t adjusted_position = position;      /* Where the position is outside the current region, re-map. */      if ((position < file->start_pos) || (position >= file->end_pos))     {       offset_t length = file_span(file);        if (!length)         length = PAGE_SIZE;        /* Avoid growth of the mapped region when the end of the region is          calculated to be position + span, which is then rounded up, whereas the          start of the region is rounded down. */        adjusted_position = trunc(position, PAGE_SIZE);        if (file_mmap(file, adjusted_position, length, 0, 0,                     file_region_flags(file->flags)))         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;     }      /* Update the current data offset. */      file->data_current = position - file->start_pos;      return L4_EOK;   }   else   {     bool initial = (file->memory == NULL);      /* Handle the initial condition with no current region. */      if (initial)     {       err = client_current_region(file);       if (err)         return err;     }      /* 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)     {       return client_next_region(file);     }      /* Within the current pipe region, synchronise with the pipe object. */      else     {       if (initial)         return L4_EOK;       else         return client_current_region(file);     }   } }    /* Return whether an operation on file should block for more content or more    space. A file must be configured for blocking, not be closed, and must either    be lacking content (if reading) or space (if writing). */  static int _operation_blocking(file_t *file, int reading) {   return (file->can_block && !(file->notifiable.notifications & NOTIFY_PEER_CLOSED) && (           (reading && !file_data_available(file)) ||           (!reading && !file_data_space(file)))); }    /* Return whether an access could occur, blocking if necessary. */  static int _access_blocking(file_t *file, offset_t position, int reading) {   long err;    /* Attempt to access the position, handling an error condition or a blocking      condition. */    while ((err = _access(file, position)) || _operation_blocking(file, reading))   {     position = file->data_current;      /* Exit if blocking is not configured or suitable. */      if ((err && (err != -L4_EBUSY)) || !file->can_block)       return 0;      /* Handle an inability to access by blocking, exiting if waiting failed. */      if (client_wait_file(file, client_notifier_task()))       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->object_flags & OBJECT_SUPPORTS_MMAP)       return client_mmap(file, client_tell(file), count, 0, 0,                          file_region_flags(file->flags));     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(ENV_FILESYSTEM_SERVER_NAME);    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;    if (file->metadata != NULL)     client_close(file->metadata);    file_flush(file);   file_close(file);   free(file); }    /* Obtain a stream from the environment. */  file_t *client_get_stream(const char *name, flags_t flags) {   l4_cap_idx_t ref = l4re_env_get_cap(name);   file_t *stream;    if (l4_is_invalid_cap(ref))     return NULL;    stream = (file_t *) malloc(sizeof(file_t));    file_init(stream);   stream->flags = flags;   stream->ref = ref;    /* Restore the state of the stream. */    client_sync_stream(stream);    /* Enforce blocking if necessary.      NOTE: Ignoring any event subscription error. */    if (!(flags & O_NONBLOCK))     client_set_blocking(stream, file_notify_flags(flags));    return stream; }  /* Initialise the stream data position to the end of any existing data for an    output stream. For an input stream, initialise the position to the end of    consumed data, preserving any unconsumed data. */  long client_sync_stream(file_t *file) {   if (!client_opened(file))     return -L4_EINVAL;    return file_refresh(file); }    /* Open a filesystem object. */  file_t *client_open(const char *name, flags_t flags) {   l4_cap_idx_t server = l4re_env_get_cap(ENV_FILESYSTEM_SERVER_NAME);    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;    /* Return any allocated structure even if an error occurs. */    file->error = file_open(file, name, flags, server);   return file; }    /* Open a directory listing stream via the given named directory. */  file_t *client_opendir(const char *name) {   l4_cap_idx_t server = l4re_env_get_cap(ENV_FILESYSTEM_SERVER_NAME);    return client_opendir_using(name, server); }  /* Open a directory listing stream via the given named directory and a named    capability, returning the directory object with a metadata file object    reference to the directory listing stream. */  file_t *client_opendir_using(const char *name, l4_cap_idx_t server) {   file_t *file = client_open_using(name, O_DIRECTORY, server);    /* Return the directory structure itself for error handling. */    if (!client_opened(file))     return file;    file->metadata = client_opendir_reader(file);    /* Return the directory even if an error occurs. */    return file; }    /* Open a directory listing stream via the given directory. */  file_t *client_opendir_reader(file_t *file) {   file_t *reader = (file_t *) malloc(sizeof(file_t));    if (reader == NULL)     return NULL;    /* Return any allocated structure even if an error occurs. */    reader->error = directory_opendir(file, reader);    /* Set blocking read mode to be able to conveniently read directory entries      from the stream. If this fails, the error is set on the structure, but the      stream will be open. */    if (!reader->error)     reader->error = client_set_blocking(reader, NOTIFY_CONTENT_AVAILABLE | NOTIFY_PEER_CLOSED);    return reader; }    /* Open another instance of an opened filesystem object. */  file_t *client_reopen(file_t *file, flags_t flags) {   if (file == NULL)     return NULL;    file_t *new_file = (file_t *) malloc(sizeof(file_t));    if (new_file == NULL)     return NULL;    /* Return any allocated structure even if an error occurs. */    new_file->error = file_reopen(file, new_file, flags);   return new_file; }    /* Open a pipe object, returning any error condition. */  long client_pipe(file_t **reader, file_t **writer, flags_t flags) {   l4_cap_idx_t server = l4re_env_get_cap(ENV_PIPE_SERVER_NAME);    return client_pipe_using(reader, writer, flags, server); }  long client_pipe_using(file_t **reader, file_t **writer, flags_t flags, l4_cap_idx_t server) {   *reader = NULL;   *writer = NULL;    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, flags, server);    /* Set blocking if successful and non-blocking is not indicated. */    if (!err && !(flags & O_NONBLOCK))   {     err = client_set_blocking(*reader, NOTIFY_CONTENT_AVAILABLE | NOTIFY_PEER_CLOSED);     if (!err)       err = client_set_blocking(*writer, NOTIFY_SPACE_AVAILABLE | NOTIFY_PEER_CLOSED);   }    if (err)   {     free(*reader);     free(*writer);   }    return err; }    /* Determine whether a file has been successfully opened. */  int client_opened(file_t *file) {   return (file != NULL) && !file->error; }    /* Make a directory in the filesystem. */  long client_mkdir(const char *path, mode_t mode) {   l4_cap_idx_t server = l4re_env_get_cap(ENV_FILESYSTEM_SERVER_NAME);    return client_mkdir_using(path, mode, server); }  /* Make a directory in the filesystem via a named capability. */  long client_mkdir_using(const char *path, mode_t mode, l4_cap_idx_t server) {   return file_mkdir(path, mode, server); }    /* Remove a file from the filesystem. */  long client_remove(const char *path) {   l4_cap_idx_t server = l4re_env_get_cap(ENV_FILESYSTEM_SERVER_NAME);    return client_remove_using(path, server); }  /* Remove a file from the filesystem via a named capability. */  long client_remove_using(const char *path, l4_cap_idx_t server) {   return file_remove(path, server); }    /* Rename a file in the filesystem. */  long client_rename(const char *source, const char *target) {   l4_cap_idx_t server = l4re_env_get_cap(ENV_FILESYSTEM_SERVER_NAME);    return client_rename_using(source, target, server); }  /* Rename a file in the filesystem via a named capability. */  long client_rename_using(const char *source, const char *target, l4_cap_idx_t server) {   return file_rename(source, target, server); }    /* Obtain filesystem object statistics. */  long client_stat(const char *path, struct stat *st) {   l4_cap_idx_t server = l4re_env_get_cap(ENV_FILESYSTEM_SERVER_NAME);    return client_stat_using(path, st, server); }  /* Obtain object statistics from the filesystem via a named capability. */  long client_stat_using(const char *path, struct stat *st, l4_cap_idx_t server) {   return file_stat(path, st, server); }    /* Obtain the current region of a pipe, updating the extent of populated data    and only changing the current position if no populated data exists. */  long client_current_region(file_t *file) {   if (!client_opened(file))     return -L4_EINVAL;    return pipe_current(file); }    /* Flush data explicitly to the filesystem object. */  long client_flush(file_t *file) {   if (!client_opened(file))     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,                   offset_t start_visible, offset_t end_visible,                   rm_flags_t region_flags) {   if (!client_opened(file) || file_mmap(file, position, length, start_visible,                                         end_visible, region_flags))     return NULL;    return file->memory; }    /* Obtain the next region of a pipe. */  long client_next_region(file_t *file) {   if (!client_opened(file))     return -L4_EINVAL;    return pipe_next(file); }    /* Close a notifier object. */  void client_notifier_close(notifier_t *notifier) {   notify_close(notifier); }  /* Obtain a local notifier object. */  notifier_t *client_notifier_local() {   return notify_get_local(); }  /* Obtain a task-wide notifier object. */  notifier_t *client_notifier_task() {   return notify_get_task(); }    /* Read a directory entry. This must be freed by the caller after use. */  struct dirent *client_readdir(file_t *file) {   if ((file == NULL) || (file->metadata == NULL))     return NULL;    char buffer[DIRENT_CORE_SIZE];   offset_t nread = client_read(file->metadata, buffer, DIRENT_CORE_SIZE);    /* Stop if no new structure can be successfully read. */    if (nread != DIRENT_CORE_SIZE)     return NULL;    struct dirent *dirent = (struct dirent *) buffer;   offset_t remaining = dirent->d_reclen - DIRENT_CORE_SIZE;    /* Allocate a buffer for the complete structure. */    char *entry = (char *) calloc(DIRENT_CORE_SIZE + remaining, sizeof(char));    if (entry == NULL)     return NULL;    /* Copy the start of the entry into a new buffer. */    memcpy(entry, buffer, DIRENT_CORE_SIZE);    /* Append to the entry buffer. */    char *current = entry + DIRENT_CORE_SIZE;    nread = client_read(file->metadata, current, remaining);    /* Stop if no complete structure can be successfully read. */    if (nread != remaining)   {     free(entry);     return NULL;   }    return (struct dirent *) entry; }  /* Rewind directory reading. */  void client_rewinddir(file_t *file) {   if ((file == NULL) || (file->metadata == NULL))     return;    client_close(file->metadata);    file->metadata = client_opendir_reader(file); }    /* Read from the filesystem object into the buffer provided. */  offset_t client_read(file_t *file, void *buf, offset_t count) {   if (!client_opened(file))     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), 1))         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 (!client_opened(file))     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;    /* Since blocking access is used with specific file notifications, the      per-task notifier is used. */    notifier_t *notifier = client_notifier_task();    if (flags)     err = client_subscribe(file, flags, notifier);   else     err = client_unsubscribe(file, notifier);    if (err)     return err;    file->can_block = flags;   return L4_EOK; }    /* Subscribe to events concerning a file. */  long client_subscribe(file_t *file, notify_flags_t flags, notifier_t *notifier) {   if (!client_opened(file))     return -L4_EINVAL;    return notify_subscribe(file_notifiable(file), flags, notifier); }    /* Return the current position in the file. */  offset_t client_tell(file_t *file) {   if (!client_opened(file))     return -L4_EINVAL;    return file_data_current_position(file); }    /* Unsubscribe from events concerning a file. */  long client_unsubscribe(file_t *file, notifier_t *notifier) {   if (!client_opened(file))     return -L4_EINVAL;    return notify_unsubscribe(file_notifiable(file), notifier); }    /* Wait for events involving a specific file. */  long client_wait_file(file_t *file, notifier_t *notifier) {   if (!client_opened(file))     return -L4_EINVAL;    return file_notify_wait_file(file, notifier); }  /* Wait for events concerning files, referencing a file object if an event is    delivered. */  long client_wait_files(file_t **file, notifier_t *notifier) {   return file_notify_wait_files(file, notifier); }    /* Write to the filesystem object from the buffer provided. */  offset_t client_write(file_t *file, const void *buf, offset_t count) {   if (!client_opened(file))     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->object_flags & OBJECT_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), 0))         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