posix_io.h File Reference

POSIX-like I/O. More...

#include <stdint.h>

Go to the source code of this file.

Macros
#define	POSIX_FD_MIN   ( 1 )
	Minimum file descriptor that will ever be allocated.
#define	POSIX_FD_MAX   ( 31 )
	Maximum file descriptor that will ever be allocated.

Typedefs
typedef uint32_t	fd_set
	File descriptor set as used for select()

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
int	open (const char *uri_string)
	Open file.
ssize_t	read (int fd, void *buf, size_t len)
	Read data from file.
int	select (fd_set *readfds, int wait)
	Check file descriptors for readiness.
ssize_t	fsize (int fd)
	Determine file size.
int	close (int fd)
	Close file.
static	__attribute__ ((always_inline)) void FD_ZERO(fd_set *set)
	Zero a file descriptor set.

Variables
static fd_set *	set

Detailed Description

POSIX-like I/O.

Definition in file posix_io.h.

Macro Definition Documentation

POSIX_FD_MIN

#define POSIX_FD_MIN   ( 1 )

Minimum file descriptor that will ever be allocated.

Definition at line 15 of file posix_io.h.

Referenced by posix_find_free_fd(), and select().

POSIX_FD_MAX

#define POSIX_FD_MAX   ( 31 )

Maximum file descriptor that will ever be allocated.

Definition at line 18 of file posix_io.h.

Referenced by posix_find_free_fd(), and select().

Typedef Documentation

fd_set

typedef uint32_t fd_set

File descriptor set as used for select()

Definition at line 21 of file posix_io.h.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

open()

int open ( const char * uri_string )

extern

Open file.

Parameters

uri_string

URI string

Return values

fd	File descriptor, or negative error number

Definition at line 176 of file posix_io.c.

                                    {
        struct posix_file *file;
        int fd;
        int rc;
 
        /* Find a free file descriptor to use */
        fd = posix_find_free_fd();
        if ( fd < 0 )
                return fd;
 
        /* Allocate and initialise structure */
        file = zalloc ( sizeof ( *file ) );
        if ( ! file )
                return -ENOMEM;
        ref_init ( &file->refcnt, posix_file_free );
        file->fd = fd;
        file->rc = -EINPROGRESS;
        intf_init ( &file->xfer, &posix_file_xfer_desc, &file->refcnt );
        INIT_LIST_HEAD ( &file->data );
 
        /* Open URI on data transfer interface */
        if ( ( rc = xfer_open_uri_string ( &file->xfer, uri_string ) ) != 0 )
                goto err;
 
        /* Wait for open to succeed or fail */
        while ( list_empty ( &file->data ) ) {
                step();
                if ( file->rc == 0 )
                        break;
                if ( file->rc != -EINPROGRESS ) {
                        rc = file->rc;
                        goto err;
                }
        }
 
        /* Add to list of open files.  List takes reference ownership. */
        list_add ( &file->list, &posix_files );
        DBG ( "POSIX opened %s as file %d\n", uri_string, fd );
        return fd;
 
 err:
        posix_file_finished ( file, rc );
        ref_put ( &file->refcnt );
        return rc;
}

References posix_file::data, DBG, EINPROGRESS, ENOMEM, posix_file::fd, INIT_LIST_HEAD, intf_init(), posix_file::list, list_add, list_empty, posix_file_finished(), posix_file_free(), posix_file_xfer_desc, posix_find_free_fd(), posix_file::rc, rc, ref_init, ref_put, posix_file::refcnt, step(), posix_file::xfer, xfer_open_uri_string(), and zalloc().

Referenced by int22(), peerdist_discovery_reply_values(), pxenv_file_open(), vmbus_open(), and xve_update_state().

read()

ssize_t read ( int fd, void * buf, size_t max_len )

extern

Read data from file.

Parameters

buf	Data buffer
max_len	Maximum length to read

Return values

len	Actual length read, or negative error number

This call is non-blocking; if no data is available to read then -EWOULDBLOCK will be returned.

Definition at line 264 of file posix_io.c.

                                                   {
        struct posix_file *file;
        struct io_buffer *iobuf;
        size_t len;
 
        /* Identify file */
        file = posix_fd_to_file ( fd );
        if ( ! file )
                return -EBADF;
 
        /* Try to fetch more data if none available */
        if ( list_empty ( &file->data ) )
                step();
 
        /* Dequeue at most one received I/O buffer into user buffer */
        list_for_each_entry ( iobuf, &file->data, list ) {
                len = iob_len ( iobuf );
                if ( len > max_len )
                        len = max_len;
                memcpy ( buf, iobuf->data, len );
                iob_pull ( iobuf, len );
                if ( ! iob_len ( iobuf ) ) {
                        list_del ( &iobuf->list );
                        free_iob ( iobuf );
                }
                file->pos += len;
                assert ( len != 0 );
                return len;
        }
 
        /* If file has completed, return (after returning all data) */
        if ( file->rc != -EINPROGRESS ) {
                assert ( list_empty ( &file->data ) );
                return file->rc;
        }
 
        /* No data ready and file still in progress; return -WOULDBLOCK */
        return -EWOULDBLOCK;
}

References assert, io_buffer::data, posix_file::data, EBADF, EINPROGRESS, EWOULDBLOCK, free_iob(), iob_len(), iob_pull, len, io_buffer::list, list_del, list_empty, list_for_each_entry, memcpy(), posix_file::pos, posix_fd_to_file(), posix_file::rc, and step().

select()

int select ( fd_set * readfds, int wait )

extern

Check file descriptors for readiness.

Parameters

readfds	File descriptors to check
wait	Wait until data is ready

Return values

nready

Number of ready file descriptors

Definition at line 229 of file posix_io.c.

                                         {
        struct posix_file *file;
        int fd;
 
        do {
                for ( fd = POSIX_FD_MIN ; fd <= POSIX_FD_MAX ; fd++ ) {
                        if ( ! FD_ISSET ( fd, readfds ) )
                                continue;
                        file = posix_fd_to_file ( fd );
                        if ( ! file )
                                return -EBADF;
                        if ( ( list_empty ( &file->data ) ) &&
                             ( file->rc == -EINPROGRESS ) )
                                continue;
                        /* Data is available or status has changed */
                        FD_ZERO ( readfds );
                        FD_SET ( fd, readfds );
                        return 1;
                }
                step();
        } while ( wait );
 
        return 0;
}

References posix_file::data, EBADF, EINPROGRESS, posix_file::fd, list_empty, POSIX_FD_MAX, POSIX_FD_MIN, posix_fd_to_file(), posix_file::rc, and step().

Referenced by int22(), pxenv_file_select(), and show_menu().

fsize()

ssize_t fsize ( int fd )

extern

Determine file size.

Parameters

fd	File descriptor

Return values

size	File size, or negative error number

Definition at line 310 of file posix_io.c.

                         {
        struct posix_file *file;
 
        /* Identify file */
        file = posix_fd_to_file ( fd );
        if ( ! file )
                return -EBADF;
 
        return file->filesize;
}

References EBADF, posix_file::fd, posix_file::filesize, and posix_fd_to_file().

Referenced by int22(), and pxenv_get_file_size().

close()

int close ( int fd )

extern

Close file.

Parameters

fd	File descriptor

Return values

rc	Return status code

Definition at line 327 of file posix_io.c.

                     {
        struct posix_file *file;
 
        /* Identify file */
        file = posix_fd_to_file ( fd );
        if ( ! file )
                return -EBADF;
 
        /* Terminate data transfer */
        posix_file_finished ( file, 0 );
 
        /* Remove from list of open files and drop reference */
        list_del ( &file->list );
        ref_put ( &file->refcnt );
        return 0;
}

References EBADF, posix_file::fd, posix_file::list, list_del, posix_fd_to_file(), posix_file_finished(), ref_put, and posix_file::refcnt.

__attribute__()

__attribute__ ( (always_inline) )

inlinestatic

Zero a file descriptor set.

Test a bit within a file descriptor set.

Clear a bit within a file descriptor set.

Set a bit within a file descriptor set.

Parameters

set	File descriptor set
fd	File descriptor
set	File descriptor set
fd	File descriptor
set	File descriptor set

Return values

is_set

Corresponding bit is set

Definition at line 34 of file posix_io.h.

                        {
        *set = 0;
}

References set.

Variable Documentation

set

fd_set* set

Initial value:

{
        *set |= ( 1 << fd )

Definition at line 46 of file posix_io.h.