src/core/posix_io.c

   1 /*
   2  * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 FILE_LICENCE ( GPL2_OR_LATER );
  20
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <errno.h>
  24 #include <gpxe/list.h>
  25 #include <gpxe/xfer.h>
  26 #include <gpxe/open.h>
  27 #include <gpxe/process.h>
  28 #include <gpxe/posix_io.h>
  29
  30 /** @file
  31  *
  32  * POSIX-like I/O
  33  *
  34  * These functions provide traditional blocking I/O semantics.  They
  35  * are designed to be used by the PXE TFTP API.  Because they block,
  36  * they may not be used by most other portions of the gPXE codebase.
  37  */
  38
  39 /** An open file */
  40 struct posix_file {
  41         /** Reference count for this object */
  42         struct refcnt refcnt;
  43         /** List of open files */
  44         struct list_head list;
  45         /** File descriptor */
  46         int fd;
  47         /** Overall status
  48          *
  49          * Set to -EINPROGRESS while data transfer is in progress.
  50          */
  51         int rc;
  52         /** Data transfer interface */
  53         struct xfer_interface xfer;
  54         /** Current seek position */
  55         size_t pos;
  56         /** File size */
  57         size_t filesize;
  58         /** Received data queue */
  59         struct list_head data;
  60 };
  61
  62 /** List of open files */
  63 static LIST_HEAD ( posix_files );
  64
  65 /**
  66  * Free open file
  67  *
  68  * @v refcnt            Reference counter
  69  */
  70 static void posix_file_free ( struct refcnt *refcnt ) {
  71         struct posix_file *file =
  72                 container_of ( refcnt, struct posix_file, refcnt );
  73         struct io_buffer *iobuf;
  74         struct io_buffer *tmp;
  75
  76         list_for_each_entry_safe ( iobuf, tmp, &file->data, list ) {
  77                 list_del ( &iobuf->list );
  78                 free_iob ( iobuf );
  79         }
  80         free ( file );
  81 }
  82
  83 /**
  84  * Terminate file data transfer
  85  *
  86  * @v file              POSIX file
  87  * @v rc                Reason for termination
  88  */
  89 static void posix_file_finished ( struct posix_file *file, int rc ) {
  90         xfer_nullify ( &file->xfer );
  91         xfer_close ( &file->xfer, rc );
  92         file->rc = rc;
  93 }
  94
  95 /**
  96  * Handle close() event
  97  *
  98  * @v xfer              POSIX file data transfer interface
  99  * @v rc                Reason for close
 100  */
 101 static void posix_file_xfer_close ( struct xfer_interface *xfer, int rc ) {
 102         struct posix_file *file =
 103                 container_of ( xfer, struct posix_file, xfer );
 104
 105         posix_file_finished ( file, rc );
 106 }
 107
 108 /**
 109  * Handle deliver_iob() event
 110  *
 111  * @v xfer              POSIX file data transfer interface
 112  * @v iobuf             I/O buffer
 113  * @v meta              Data transfer metadata
 114  * @ret rc              Return status code
 115  */
 116 static int
 117 posix_file_xfer_deliver_iob ( struct xfer_interface *xfer,
 118                               struct io_buffer *iobuf,
 119                               struct xfer_metadata *meta ) {
 120         struct posix_file *file =
 121                 container_of ( xfer, struct posix_file, xfer );
 122
 123         /* Keep track of file position solely for the filesize */
 124         if ( meta->whence != SEEK_CUR )
 125                 file->pos = 0;
 126         file->pos += meta->offset;
 127         if ( file->filesize < file->pos )
 128                 file->filesize = file->pos;
 129
 130         if ( iob_len ( iobuf ) ) {
 131                 list_add_tail ( &iobuf->list, &file->data );
 132         } else {
 133                 free_iob ( iobuf );
 134         }
 135
 136         return 0;
 137 }
 138
 139 /** POSIX file data transfer interface operations */
 140 static struct xfer_interface_operations posix_file_xfer_operations = {
 141         .close          = posix_file_xfer_close,
 142         .vredirect      = xfer_vreopen,
 143         .window         = unlimited_xfer_window,
 144         .alloc_iob      = default_xfer_alloc_iob,
 145         .deliver_iob    = posix_file_xfer_deliver_iob,
 146         .deliver_raw    = xfer_deliver_as_iob,
 147 };
 148
 149 /**
 150  * Identify file by file descriptor
 151  *
 152  * @v fd                File descriptor
 153  * @ret file            Corresponding file, or NULL
 154  */
 155 static struct posix_file * posix_fd_to_file ( int fd ) {
 156         struct posix_file *file;
 157
 158         list_for_each_entry ( file, &posix_files, list ) {
 159                 if ( file->fd == fd )
 160                         return file;
 161         }
 162         return NULL;
 163 }
 164
 165 /**
 166  * Find an available file descriptor
 167  *
 168  * @ret fd              File descriptor, or negative error number
 169  */
 170 static int posix_find_free_fd ( void ) {
 171         int fd;
 172
 173         for ( fd = POSIX_FD_MIN ; fd <= POSIX_FD_MAX ; fd++ ) {
 174                 if ( ! posix_fd_to_file ( fd ) )
 175                         return fd;
 176         }
 177         DBG ( "POSIX could not find free file descriptor\n" );
 178         return -ENFILE;
 179 }
 180
 181 /**
 182  * Open file
 183  *
 184  * @v uri_string        URI string
 185  * @ret fd              File descriptor, or negative error number
 186  */
 187 int open ( const char *uri_string ) {
 188         struct posix_file *file;
 189         int fd;
 190         int rc;
 191
 192         /* Find a free file descriptor to use */
 193         fd = posix_find_free_fd();
 194         if ( fd < 0 )
 195                 return fd;
 196
 197         /* Allocate and initialise structure */
 198         file = zalloc ( sizeof ( *file ) );
 199         if ( ! file )
 200                 return -ENOMEM;
 201         ref_init ( &file->refcnt, posix_file_free );
 202         file->fd = fd;
 203         file->rc = -EINPROGRESS;
 204         xfer_init ( &file->xfer, &posix_file_xfer_operations,
 205                     &file->refcnt );
 206         INIT_LIST_HEAD ( &file->data );
 207
 208         /* Open URI on data transfer interface */
 209         if ( ( rc = xfer_open_uri_string ( &file->xfer, uri_string ) ) != 0 )
 210                 goto err;
 211
 212         /* Wait for open to succeed or fail */
 213         while ( list_empty ( &file->data ) ) {
 214                 step();
 215                 if ( file->rc == 0 )
 216                         break;
 217                 if ( file->rc != -EINPROGRESS ) {
 218                         rc = file->rc;
 219                         goto err;
 220                 }
 221         }
 222
 223         /* Add to list of open files.  List takes reference ownership. */
 224         list_add ( &file->list, &posix_files );
 225         DBG ( "POSIX opened %s as file %d\n", uri_string, fd );
 226         return fd;
 227
 228  err:
 229         posix_file_finished ( file, rc );
 230         ref_put ( &file->refcnt );
 231         return rc;
 232 }
 233
 234 /**
 235  * Check file descriptors for readiness
 236  *
 237  * @v readfds           File descriptors to check
 238  * @v wait              Wait until data is ready
 239  * @ret nready          Number of ready file descriptors
 240  */
 241 int select ( fd_set *readfds, int wait ) {
 242         struct posix_file *file;
 243         int fd;
 244
 245         do {
 246                 for ( fd = POSIX_FD_MIN ; fd <= POSIX_FD_MAX ; fd++ ) {
 247                         if ( ! FD_ISSET ( fd, readfds ) )
 248                                 continue;
 249                         file = posix_fd_to_file ( fd );
 250                         if ( ! file )
 251                                 return -EBADF;
 252                         if ( ( list_empty ( &file->data ) ) &&
 253                              ( file->rc == -EINPROGRESS ) )
 254                                 continue;
 255                         /* Data is available or status has changed */
 256                         FD_ZERO ( readfds );
 257                         FD_SET ( fd, readfds );
 258                         return 1;
 259                 }
 260                 step();
 261         } while ( wait );
 262
 263         return 0;
 264 }
 265
 266 /**
 267  * Read data from file
 268  *
 269  * @v buffer            Data buffer
 270  * @v offset            Starting offset within data buffer
 271  * @v len               Maximum length to read
 272  * @ret len             Actual length read, or negative error number
 273  *
 274  * This call is non-blocking; if no data is available to read then
 275  * -EWOULDBLOCK will be returned.
 276  */
 277 ssize_t read_user ( int fd, userptr_t buffer, off_t offset, size_t max_len ) {
 278         struct posix_file *file;
 279         struct io_buffer *iobuf;
 280         size_t len;
 281
 282         /* Identify file */
 283         file = posix_fd_to_file ( fd );
 284         if ( ! file )
 285                 return -EBADF;
 286
 287         /* Try to fetch more data if none available */
 288         if ( list_empty ( &file->data ) )
 289                 step();
 290
 291         /* Dequeue at most one received I/O buffer into user buffer */
 292         list_for_each_entry ( iobuf, &file->data, list ) {
 293                 len = iob_len ( iobuf );
 294                 if ( len > max_len )
 295                         len = max_len;
 296                 copy_to_user ( buffer, offset, iobuf->data, len );
 297                 iob_pull ( iobuf, len );
 298                 if ( ! iob_len ( iobuf ) ) {
 299                         list_del ( &iobuf->list );
 300                         free_iob ( iobuf );
 301                 }
 302                 file->pos += len;
 303                 assert ( len != 0 );
 304                 return len;
 305         }
 306
 307         /* If file has completed, return (after returning all data) */
 308         if ( file->rc != -EINPROGRESS ) {
 309                 assert ( list_empty ( &file->data ) );
 310                 return file->rc;
 311         }
 312
 313         /* No data ready and file still in progress; return -WOULDBLOCK */
 314         return -EWOULDBLOCK;
 315 }
 316
 317 /**
 318  * Determine file size
 319  *
 320  * @v fd                File descriptor
 321  * @ret size            File size, or negative error number
 322  */
 323 ssize_t fsize ( int fd ) {
 324         struct posix_file *file;
 325
 326         /* Identify file */
 327         file = posix_fd_to_file ( fd );
 328         if ( ! file )
 329                 return -EBADF;
 330
 331         return file->filesize;
 332 }
 333
 334 /**
 335  * Close file
 336  *
 337  * @v fd                File descriptor
 338  * @ret rc              Return status code
 339  */
 340 int close ( int fd ) {
 341         struct posix_file *file;
 342
 343         /* Identify file */
 344         file = posix_fd_to_file ( fd );
 345         if ( ! file )
 346                 return -EBADF;
 347
 348         /* Terminate data transfer */
 349         posix_file_finished ( file, 0 );
 350
 351         /* Remove from list of open files and drop reference */
 352         list_del ( &file->list );
 353         ref_put ( &file->refcnt );
 354         return 0;
 355 }