Sottoroutine MIO_open

Finalità

Apre un file per la lettura o la scrittura attraverso la libreria MIO.

Libreria

Libreria I/O modulare (libmio.a)

Sintassi

#include <libmio.h>
 
int MIO_open (Path, OFlag, Mode, Extra)
char *Path;
int OFlag;
int Mode;
struct mio_extra *Extra;

Descrizione

La sottoroutine MIO_open è un reindirizzamento alla sottoroutine MIO_open64 ed è un punto di ingresso della libreria MIO. Per utilizzare la libreria MIO, i file devono essere aperti con la bandiera O_LARGEFILE . Per ulteriori dettagli sull'indicatore O_LARGEFILE , consultare il file fcntl.h .

Utilizzare la sottoroutine MIO_open per strumentare la tua applicazione con la libreria MIO. È possibile sostituire la sottoroutine di open kernel I/O con questa subroutine MIO equivalente. Consultare l' Modular I/O in Performance management per l'implementazione della libreria MIO.

Utilizzare questa sottoroutine per aprire un file tramite la libreria MIO (Modular I/O). Questa libreria crea il contesto per questo file aperto, in base alla configurazione impostata nelle variabili di ambiente MIO o nel parametro Extra .

Per analizzare l'I/O delle applicazioni e ottimizzare l'I/O, utilizzare le subroutine MIO al posto delle subroutine I/O standard.

Parametri

struct mio_extra {
                  int   cookie ;
                  /* Default value:  MIO_EXTRA_COOKIE/

                  int   taskid ; 
                  /*  for later */

                  int64 bufsiz ;
                  /* if > 1 : force the prefetch for write pffw */

                  char *modules ; 
      /* explicit module name, 
       if any modules returns from MIO_FILES environment variable match */

                  char *logical_name ;
      /* logical file name to open 
       if file name don't match with MIO_FILES regexp */                        
                  
                  int   flags ; 
      /* if MIO_EXTRA_SKIP_MIO_FILES_FLAG : 
       don't use MIO_FILES env variable, but use extra->modules */
                   } ;

Variabili di ambiente

MIO è controllato attraverso le seguenti quattro variabili di ambiente. Queste variabili di ambiente, che definiscono le funzioni MIO, vengono elaborate dalla sottoroutine MIO_open64 .

La variabile MIO_STATS viene utilizzata per indicare un file che verrà utilizzato come repository per i messaggi diagnostici e per l'output richiesto dai moduli MIO. Viene interpretato come un nome di file con due casi particolari. Se il file è l'outputstderr o stdout , l'output verrà indirizzato verso il flusso di file appropriato. Se il primo carattere della variabile MIO_STATS è un segno più (+), il nome del file da utilizzare è la stringa che segue il segno più (+) e il file viene aperto per appendere. Senza il segno più precedente (+), il file è sovrascritto.

La variabile MIO_FILES è la chiave per determinare quali moduli devono essere richiamati per un determinato file quando viene richiamata la sottoroutine MIO_open64 . Il formato per la variabile MIO_FILES è il seguente:

first_file_name_list [ module list ] second_file_name_list [ module list]

Quando viene richiamata la sottoroutine MIO_open64 , MIO verifica l'esistenza della variabile MIO_FILES e la analizza nel modo seguente:

Se la maschera del nome file non contiene una barra (/), tutte le informazioni sulla directory del percorso nel nome file inoltrato alla sottoroutine MIO_open64 vengono ignorate e la corrispondenza viene applicata solo al nome file del file che si sta aprendo.

Se il nome del file che si apre è corrispondente da uno dei modelli di nome del file nella lista dei nomi file allora l'elenco dei moduli da richiamare viene assunto come stringa tra parentesi ([]). Se il nome del file corrisponde a due o più modelli di nome file, viene presa in considerazione la prima corrispondenza. Se il nome del file che si sta aprendo non corrisponde ad alcun modello di nome di file in nessuno degli elenchi di nomi di file, il file viene aperto con un'invocazione predefinita del modulo AIX®.

Se si è verificata una corrispondenza, i moduli da richiamare vengono prelevati dall'elenco dei moduli associati nella variabile MIO_FILES . I moduli vengono richiamati da sinistra a destra, con il sinistro più vicino al programma utente e il destro - più vicini al sistema operativo. Se l'elenco dei moduli non inizia con il modulo MIO, viene aggiunto un richiamo predefinito del modulo MIO come prefisso. Se il moduloAIX non viene specificato, viene accostato un richiamo predefinito del moduloAIX .

setenv MIO_FILES " *.dat [ trace/stats ]"

MIO_FILES= *.dat:*.scr [ trace ] *.f01:*.f02:*.f03 [ trace | pf | trace ]

mio | trace | aix

mio | trace | pf | trace | aix

MIO_FILES= *.dat : *.scr [ trace/stats=my.stats ]

Le opzioni per un modulo sono delimitate con una barra (/). Alcune opzioni richiedono un valore di stringa associato e altri potrebbero richiedere un valore intero. Per chi richiede un valore di stringa, se la stringa include una barra (/), racchiudere la stringa in parentesi ({ }).

Per quelle opzioni che richiedono un valore intero, accodare il valore intero con un k, m, g o t per rappresentare kilo, mega, giga o tera. Si potrebbero anche inserire valori interi in base 10, 8 o 16. Se si aggiunge un0xprefisso al valore intero, il numero intero viene interpretato come base 16. Se si aggiunge un0prefisso al valore intero, il numero intero viene interpretato come base 8. Se non aggiungi né un0xprefisso né un0prefisso al valore intero, il numero intero viene interpretato come base 10.

La variabile MIO_DEFAULTS è intesa come un modo per mantenere più leggibile la variabile MIO_FILES . Se l'utente sta specificando diversi moduli per più coppie di nomi di file e coppie di moduli, allora la variabile MIO_FILES potrebbe diventare piuttosto lunga. Per sovrascrivere ripetutamente i default hardcoded nello stesso modo, è possibile specificare nuovi default per un modulo specificando tali default nella variabile MIO_DEFAULTS . La variabile MIO_DEFAULTS è un elenco separato da virgola dei moduli con i relativi nuovi default.

setenv MIO_DEFAULTS " trace/kbytes "

MIO_DEFAULTS = trace/events=prob.events , aix/debug

Qualsiasi richiamo predefinito del modulo di traccia avrà la traccia di eventi binari abilitata e indirizzata verso il file prob.events e qualsiasi richiamo predefinito del modulo AIX avrà il debug abilitato.

La variabile MIO_DEBUG è intesa come un aiuto nel debug dell'utilizzo di MIO. MIO ricerca la variabile MIO_DEFAULTS per le parole chiave e fornisce l'output di debug per l'opzione. Le parole chiave disponibili sono le seguenti:

TUTTO

Attiva tutte le parole chiave variabili MIO_DEBUG .

Amb

Outmette le richieste di corrispondenza delle variabili di ambiente.

APERTO

Emette le richieste aperte effettuate alla sottoroutine MIO_open64 .

Moduli

Moduli di output richiamati per ogni chiamata alla sottoroutine MIO_open64 .

TIMESTAMP

Posisce una registrazione data / ora che precede ogni voce in un file stats .

DEF

Outmette la tabella di definizione di ciascun modulo. Quando il file si apre, vengono elaborati gli output di tutte le definizioni della libreria MIO per tutti i moduli della libreria MIO.

Valori di ritorno

I valori di ritorno sono quelli della corrispondente chiamata di sistema POSIX standard open64.

Codici di errore

I codici di errore sono quelli della corrispondente chiamata di sistema POSIX standard open64.

Output standard

Non esiste un output della libreria MIO per la sottoroutine MIO_open64 .

In example.stats. File di output MIO, la traccia del modulo è impostata e segnalata e le richieste aperte sono in uscita. Tutti i valori sono in kilobyte.

Esempi

Il seguente file example.c emette 100 scritture di 16 KB, cerca all'inizio del file, emette 100 letture di 16 KB e quindi cerca all'indietro attraverso il file che legge 16 KB di record. Alla fine il file viene troncato a 0 bytes di lunghezza.

L'argomento filename al seguente esempio è il file da creare, scritto a e leggere avanti e indietro:

--------------------------------------------------------------------------------
#define _LARGE_FILES
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>

#include "libmio.h"

/* Define open64, lseek64 and ftruncate64,  not 
 * open, lseek, and ftruncate that are used in the code.  This is
 * because libmio.h defines _LARGE_FILES which forces <fcntl.h> to
 * redefine open, lseek, and ftruncate as open64, lseek64, and
 * ftruncate64
 */

#define open64(a,b,c) MIO_open64(a,b,c,0)
#define close         MIO_close
#define lseek64       MIO_lseek64
#define write         MIO_write
#define read          MIO_read
#define ftruncate64   MIO_ftruncate64

#define RECSIZE 16384
#define NREC    100

main(int argc, char **argv)
{
int i, fd, status ;
char *name ;
char *buffer ;
int64 ret64 ;

      if( argc < 2 ){
      fprintf(stderr,"Usage : example file_name\n");
      exit(-1);
   }
   name = argv[1] ;

   buffer = (char *)malloc(RECSIZE);
   memset( buffer, 0, RECSIZE ) ;

   fd = open(name, O_RDWR|O_TRUNC|O_CREAT, 0640 ) ;
   if( fd < 0 ){
      fprintf(stderr,"Unable to open file %s errno=%d\n",name,errno);
      exit(-1);
   }

/* write the file */
   for(i=0;i<NREC;i++){
      status = write( fd, buffer, RECSIZE ) ;
   }

/* read the file forwards */
   ret64 = lseek(fd, 0, SEEK_SET ) ;
   for(i=0;i<NREC;i++){
      status = read( fd, buffer, RECSIZE ) ;
   }
/* read the file backwards */
   for(i=0;i<NREC;i++){
      ret64 = lseek(fd, (NREC-i-1)*RECSIZE, SEEK_SET ) ;
      status = read( fd, buffer, RECSIZE ) ;
   }

/* truncate the file back to 0 bytes*/
   status = ftruncate( fd, 0 ) ;

   free(buffer);

/* close the file */
   status = close(fd);
}

--------------------------------------------------------------------------------

cc -o example example.c  -lmio 

./example file.dat

Le seguenti variabili di ambiente sono impostate per configurare MIO:

Consultare i file /usr/samples/libmio/README e i file di esempio per i dettagli.

Ubicazione

/usr/lib/libmio.a