Hello, Dmitry!
DP> предлагаю:
DP> основа внешней памяти - файл, вернее его a-la Internet абстрация (?):
DP> <протокол>://<файл>(<атрибуты файла>)
^^^^^^^^^^ ^^^Это тоже имя, на самом деле
DP> <протокол>:=<имя>(<параметры протокола>)
^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ А вот это все наз. МЕТАДАHHЫМИ,
и наиболее разумно сделать их хранимыми в виде атрибутов, ассоциированных с
именами, т.е. тогда имеешь словарь элементов "имя-значение(метаданные,
их никто кроме средств ОС не видит :-)" + словарь "фильтров (обработчиков/
драйверов)" - "имя-значение(таблица методов)".
Для пояснения - опять же аналогия с HTTP: поле "Content-type: <MIME-type>"
в HTTP-заголовке, который предваряет собственно данные. Браузер, открыв
соединение и получив _поток_, к приходу собственно данных уже знает, что с
ними делать.
Таким образом, ОС, получив вызов OPEN (фактически - установить связь с
поименованной сущностью), при успешном нахождении в пространстве имен
получает метаданные - в т.ч. имя обработчика, и далее вызывает уже его
методы:
DP> весь ввод\вывод идет через OPEN\CLOSE\WRITE\READ\SEEK\...
[...]
DP>> вопрос - какие команды должен поддерживать драйвкр абстрактного
DP>> протокола или устройства ?
DP> PS: кажется, похоже на Unix ?
Hе только - Unix просто был первым :-)
Вот, надеюсь, не буду бит - просто весьма поучительно, это архитектура
BlitzOS:
==============================================================================
[...]
>void * drvr_create( char *name,void *info );
>void drvr_addiface( void *drvr,char *ifacename,void *iface );
>void * drvr_load( char *name );
>void * drvr_getinfo( void *drvr );
>void * drvr_getiface( void *drvr,char *ifacename );
Drivers
A driver in blitz is any program which supports the opening and closing of
one or more instances of 'something'. That something could be anything from
a keyboard to a file.
Each driver in Blitz can provides zero or more 'interfaces'. An interface will
generally be a table of functions for dealing with instances opened by the
user, but can in fact contain anything. To the kernel, the interface is just a
void pointer.
Interfaces are named according to the functionality they provide. For example,
a "stream" interface might provide the following functions:
//a sample stream interface
typedef struct{
void * (*open)( char *name,int flags,void *drvr );
void (*close)( void *inst );
int (*read)( void *inst,char *buff,int size );
int (*write)( void *inst,char *buff,int size ):
}Stream;
[...]
void main(){
void *driver=drvr_create( "Testdriver",0 );
drvr_addiface( drvr,"stream",stream );
task_suspend();
}
Now, a program can make use of the new driver's stream interface like this:
void main(){
void *drvr=drvr_load( "Testdriver" ); //find the 'Testdriver' driver
Stream *stream=drvr_getiface( drvr,"stream" ); //find it's 'stream'
//interface
void *inst=stream->open( "name",2,drvr ); //open an instance
stream->write( inst,"Hello",5 ); //write to it
stream->close( inst ); //close the instance
}
[...]
The Stream Interface
The stream interface is provided by drivers that perform simple sequential IO,
and looks like this:
typedef struct{
void * (*open)( char *name,int flags,void *drvr );
void (*close)( void *inst );
int (*read)( void *inst,char *buff,int size );
int (*write)( void *inst,char *buff,int size );
}Stream;
//flags for open()
#define STREAM_READ 1
#define STREAM_WRITE 2
#define STREAM_NAME "stream"
Some examples of drivers which might provide a stream interface are keyboard,
serial or parallel drivers.
The Block Interface
The block interface is provided by drivers that perform random access IO
using 'blocks' of data, and looks like this:
typedef struct{
void * (*open)( char *name,int flags,void *drvr );
void (*close)( void *inst );
int (*getsize)( void *inst );
int (*read)( void *inst,char *buff,int firstblk,int numblks );
int (*write)( void *inst,char *buff,int firstblk,int numblks );
}Block;
//flags for open()
#define BLOCK_READ 1
#define BLOCK_WRITE 2
#define BLOCK_NAME "block"
Some examples of drivers which might provide a block interface are floppy,
harddisk or cdrom.
The Filesystem Interface
The filesystem interface is provided by drivers that implement a file system,
and looks like this:
typedef struct{
void * (*open)( char *name,int flags,void *drvr );
void (*close)( void *inst );
int (*read)( void *inst,char *buff,int size );
int (*write)( void *inst,char *buff,int size );
int (*next)( void *inst );
int (*prev)( void *inst );
int (*child)( void *inst );
int (*parent)( void *inst );
int (*getsize)( void *inst );
int (*getname)( void *inst,char *buff,int size );
int (*remove)( char *name );
int (*rename)( char *oldname,char *newname );
}Filesys;
//flags for open()
#define FILESYS_READ 1
#define FILESYS_WRITE 2
#define FILESYS_BROWSE 4
#define FILESYS_NAME "filesys"
File manager
The file managers main job is to manage the system namespace, and pass on file
system type requests to the appropriate drivers.
Programs will link directly to the file manager, as opposed to accessing it
through an interface. As there is only one file manager in the system, there
is no need for the abstraction of interfaces.
void * file_open( char *name,int flags );
void file_close( void *file );
int file_read( void *file,char *buff,int size );
int file_write( void *file,char *buff,int size );
int file_next( void *file );
int file_prev( void *file );
int file_child( void *file );
int file_parent( void *file );
int file_getsize( void *file );
int file_getname( void *file,char *buff,int size );
int file_remove( char *name );
int file_rename( char *oldname,char *newname );
//flags for file_open()
#define FILE_READ 1
#define FILE_WRITE 2
#define FILE_BROWSE 4
========================================================================
Я надеюсь, С-нотация не сильно пугает :-)) Что поделать, это обычный язык
в мире ОСей :-)
Кстати, там (http://members.xoom.com/marksibly/) есть и загружаемый бинарник
демо BlitzOS (15 к ;-)
Best regards,Yurij Sysoev. \\ GNU, PE/DLL/ELF loaders, SCADA, X Window: //
udc@naftan.belpak.vitebsk.by // visit to: http://winix.hypermart.net \\
-- end of forwarded message --
--
С тем, что не помешает никогда,
Kittle