Search  

---

C:/temp/src/j2k/QNX4/ResMgr1.c

Go to the documentation of this file.

// Resource Manager Template

#include <j2k/Fred/Basic.hpp>
#include <j2k/Fred/System.hpp>
#include <j2k/Fred/Boolean.hpp>
#include <j2k/Fred/StdTypes.hpp>

#include <sys/fd.h>
#include <sys/prfx.h>
#include <sys/io_msg.h>

#define  DEBUG_ON

char* progname = "ResMgr.c";
char* prefix   = "/sample";

// A union of all message type that we are going to handle
typedef union {
  USHORT                   type;
  USHORT                   status;
  struct _io_open          open;
  struct _io_open_reply    open_reply;
  struct _io_close         close; 
  struct _io_close_reply   close_reply;
  struct _io_read          read;
  struct _io_read_reply    read_reply;
  struct _io_write         write;
  struct _io_write_reply   write_reply;
} ResMsg_t;

/*

 The OCB

 In our case, we've kept it very simple.
 Simply the current position into the resource.
 This would be a great place to add any per-open
 data that you want to store.

*/

typedef struct {
  off_t  offset;
} ResOCB_t;

/* With a "real" resource manager, you'd set this dynamically based on a
 * command-line argument or grow the arrays as necessary while running... */

// Maximum number of sessions
#define MAX_OCBS  16

ResMsg_t   msg;                  // The message structure
void*      fd_ctrl;              // The kernel file descriptor interface
int        in_use[ MAX_OCBS ];   // Flags indicating "ocbs" availability
ResOCB_t*  ocbs[   MAX_OCBS ];   // Array of ocbs, by kernel fd index

/*

Resource Manager Section

These functions, up to the 'Connect and I/O functions' header,
are responsible for the ResMgr impl. details.

*/

int main() {
  int devno;

  // Attach a major device number
  if ( (devno = qnx_device_attach()) == -1 ) {
    fprintf( stderr,
             "%s: couldn't qnx_device_attach() %s, errno %d \n",
             progname, prefix, errno );

    perror( NULL );
    exit( EXIT_FAILURE );
  }

  // Register our prefix
  if ( qnx_prefix_attach( prefix, NULL, devno ) == -1 ) {
    fprintf( stderr,
             "%s: couldn't qnx_prefix_attach() %s, errno %d \n",
             progname, prefix, errno );

    perror( NULL );
    exit( EXIT_FAILURE );
  }

  // Initialize the kernel fd interface
  if ( (fd_ctrl = __init_fd( getpid() )) == NULL ) {
    fprintf( stderr,
             "%s: couldn't register kernel fd I/F \n",
             progname );

    perror( NULL );
    exit( EXIT_FAILURE );
  }

  in_use[0] = 1;   // Mark 0 as in use, since it's not valid !

  printf("%s successfully attached as device #%d \n", prefix, devno );
  serviceRequests();

  // Shouldn't get here
  return ( EXIT_SUCCESS );
}

void serviceRequests() {
  pid_t  pid;
  int    replyAction;
  int    index;

  for(;;) {
    pid = Receive( 0, &msg, sizeof( msg ) );
    printf( "Got a message of type 0x%04X from PID %d\n", msg.type, pid );

    switch( msg.type ) {
      // Connect Message
      case _IO_OPEN :
        replyAction = io_open( &msg, pid );
        break;

      // I/O Message
      case _IO_READ :
        if ( (index = __get_fd( pid, msg.read.fd, fd_ctrl ) ) == -1 ) {
          msg.status = EBADF;
          replyAction = sizeof( msg.read_reply );
        } else {
          replyAction = io_read( &msg, ocbs[index] );
        }
        break;

      case _IO_WRITE :
        if ( (index = __get_fd( pid, msg.write.fd, fd_ctrl ) ) == -1 ) {
          msg.status = EBADF;
          replyAction = sizeof( msg.write_reply );
        } else {
          replyAction = io_write( &msg, ocbs[index] );
        }
        break;

      case _IO_CLOSE :
        if ( (index = __get_fd( pid, msg.close.fd, fd_ctrl ) ) == -1 ) {
          msg.status = EBADF;
          replyAction = sizeof( msg.close_reply );
        } else {
          replyAction = io_close( &msg, ocbs[index] );

          // Remove it from the internal tables
          in_use[ index ] = 0;
          ocbs[   index ] = NULL;

          // Release it from the kernel's fd table
          qnx_fd_attach( pid, msg.close.fd, 0, 0, 0, 0 );
        }
        break;

      // add others as required.

      // Print an error for ones we didn't know what to do
      // Return ENOSYS so that the client knows that we didn't handle it.
      default :
        printf( "Got an unimplemented message of type 0x%04X from PID %d\n",
                msg.type, pid );

        msg.status = ENOSYS;
        replyAction = sizeof( msg.status );
        break;
    }

    // Didn't reply yet ?
    if ( replyAction > 0 ) {
      Reply( pid, &msg, replyAction );
    }
  }
}

/*

 Connect and I/O functions

 The philosophy for these functions is that they should know as little as
 possible about the details of the resource manager interface, and should
 instead focus as much as possible on the client specific information.

*/

/*
 io_open()

 Our io_open handler prints out the information that we got from the
 _IO_OPEN message, allocates space for an OCB, initialize the OCB
 for later usage, and binds the OCb into the "ocbs" data structure
 and the kernel's "fd" table.

 Upon completion, it return an "EOK"  message to the client.
*/

int io_open( ResMsg_t* msg, pid_t pid ) {
 ResOCB_t* ocb;
 int index;

 // Print out the information we got from the _IO_OPEN message
 printf( "Got an _IO_OPEN message \n" );
 printf( "  type:          0x%04X \n", msg->open.type  );
 printf( "  fd:            %d     \n", msg->open.fd    );
 printf( "  unit:          %d     \n", msg->open.unit  );
 printf( "  version_cycle: %d     \n", msg->open.version_cycle );
 printf( "  eflag:         0x%02X \n", msg->open.eflag );
 printf( "  nid:           %d     \n", msg->open.nid   );
 printf( "  pid:           %d     \n", msg->open.pid   );
 printf( "  sflag:         0x%02X \n", msg->open.sflag );
 printf( "  oflag:         0x%02X \n", msg->open.oflag );
 printf( "  mode:          %d     \n", msg->open.mode  );
 printf( "  path:          %d     \n", msg->open.path  );

 // Allocate space for the OCB (and clear)
 if ( (ocb = calloc( sizeof(*ocb), 1 )) == NULL ) {
   msg->open_reply.status = ENOMEM;
   return ( sizeof( msg->open_reply ) );
 }

 // Initialize any OCB fields
 for( index = 0; index < MAX_OCBS; index++ ) {
   if ( in_use[index] == 0 ) {
     if ( qnx_fd_attach( pid, msg->open.fd, 0,0,0,0, index ) == -1 ) {

    fprintf( stderr,
             "%s: couldn't attach fd \n",
             progname );

    perror( NULL );
    exit( EXIT_FAILURE );
    }

    // Bind OCB into table, mark as "in use"
    ocbs[index] = ocb;
    in_use[index] = 1;
    break;
   }
 }

 // If OCB table is full, then error msg
 if ( index == MAX_OCBS ) {
   free( ocb );
   msg->open_reply.status = EAGAIN;  // Try later
   return ( sizeof( msg->open_reply ) );
 }

 // Tell the client that everything is fine
 msg->open_reply.status = EOK;
 return ( sizeof( msg->open_reply ) );
}

/*
 io_read()

 Our io_read handler functions just like /dev/null
 It returns EOF. =(
*/

int io_read( ResMsg_t* msg, ResOCB_t* ocb ) {

 // Print out the information we got from the _IO_READ message
 printf( "Got an _IO_READ message \n" );
 printf( "  type:          0x%04X \n", msg->read.type   );
 printf( "  fd:            %d     \n", msg->read.fd     );
 printf( "  nbytes:        %d     \n", msg->read.nbytes );

 // Setup the return portion to the client
 // Tell him that 0 bytes are available for reading
 msg->read_reply.nbytes = 0;
 msg->read_reply.status = EOK;
 msg->read_reply.zero   = 0;    // Reserved, MUST be 0

 return ( sizeof( msg->read_reply ) );
}

/*
 io_write()

 Our io_write handler functions just like /dev/null
 We tell him that all bytes where written, in fact, no where. =(
*/

int io_write( ResMsg_t* msg, ResOCB_t* ocb ) {

 // Print out the information we got from the _IO_WRITE message
 printf( "Got an _IO_WRITE message \n" );
 printf( "  type:          0x%04X \n", msg->write.type   );
 printf( "  fd:            %d     \n", msg->write.fd     );
 printf( "  nbytes:        %d     \n", msg->write.nbytes );
                                                 
 // Setup the return portion to the client
 // Tell him that all bytes were written.
 msg->write_reply.nbytes = msg->write.nbytes;
 msg->write_reply.status = EOK;
 msg->write_reply.zero   = 0;    // Reserved, MUST be 0

 return ( sizeof( msg->write_reply ) );
}

/*
 io_close()

 Doesn't do much from the client's perspective except to return EOK.

 From the ResMgr perspective, the message causes the OCB storage area,
 ocb/in_use tables, and kernel fd area to be deleted.

 However, the ocbs/in_use and kernel fd area work is done in the calling
 routine above !
*/

int io_close( ResMsg_t* msg, ResOCB_t* ocb ) {

 // Print out the information we got from the _IO_CLOSE message
 printf( "Got an _IO_CLOSE message \n" );
 printf( "  type:          0x%04X \n", msg->close.type   );
 printf( "  fd:            %d     \n", msg->close.fd     );
                                                 
 // Setup the return portion to the client
 // Close was successful
 msg->write_reply.status = EOK;

 free( ocb );

 return ( sizeof( msg->close_reply ) );
}

---