i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

* Cleanup.

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@30905 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
2009-05-28 21:32:53 +00:00
parent e19ad5ff1a
commit f0c050f60e
1 changed files with 97 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/kernel/file_systems/iso9660/kernel_interface.cpp
+97 -113
View File
@@ -59,9 +59,9 @@ extern fs_vnode_ops gISO9660VnodeOps;
static float static float
fs_identify_partition(int fd, partition_data *partition, void **_cookie) fs_identify_partition(int fd, partition_data* partition, void** _cookie)
{ {
iso9660_info *info = new iso9660_info; iso9660_info* info = new iso9660_info;
status_t status = iso9660_fs_identify(fd, info); status_t status = iso9660_fs_identify(fd, info);
if (status != B_OK) { if (status != B_OK) {
@@ -75,9 +75,9 @@ fs_identify_partition(int fd, partition_data *partition, void **_cookie)
static status_t static status_t
fs_scan_partition(int fd, partition_data *partition, void *_cookie) fs_scan_partition(int fd, partition_data* partition, void* _cookie)
{ {
iso9660_info *info = (iso9660_info *)_cookie; iso9660_info* info = (iso9660_info*)_cookie;
partition->status = B_PARTITION_VALID; partition->status = B_PARTITION_VALID;
partition->flags |= B_PARTITION_FILE_SYSTEM | B_PARTITION_READ_ONLY ; partition->flags |= B_PARTITION_FILE_SYSTEM | B_PARTITION_READ_ONLY ;
@@ -93,9 +93,9 @@ fs_scan_partition(int fd, partition_data *partition, void *_cookie)
static void static void
fs_free_identify_partition_cookie(partition_data *partition, void *_cookie) fs_free_identify_partition_cookie(partition_data* partition, void* _cookie)
{ {
delete (iso9660_info *)_cookie; delete (iso9660_info*)_cookie;
} }
@@ -103,18 +103,18 @@ fs_free_identify_partition_cookie(partition_data *partition, void *_cookie)
static status_t static status_t
fs_mount(fs_volume *_volume, const char *device, uint32 flags, fs_mount(fs_volume* _volume, const char* device, uint32 flags,
const char *args, ino_t *_rootID) const char* args, ino_t* _rootID)
{ {
bool allowJoliet = true; bool allowJoliet = true;
iso9660_volume *volume; iso9660_volume* volume;
// Check for a 'nojoliet' parm // Check for a 'nojoliet' parm
// all we check for is the existance of 'nojoliet' in the parms. // all we check for is the existance of 'nojoliet' in the parms.
if (args != NULL) { if (args != NULL) {
uint32 i; uint32 i;
char *spot; char* spot;
char *buf = strdup(args); char* buf = strdup(args);
uint32 len = strlen(buf); uint32 len = strlen(buf);
// lower case the parms data // lower case the parms data
@@ -153,21 +153,21 @@ fs_mount(fs_volume *_volume, const char *device, uint32 flags,
static status_t static status_t
fs_unmount(fs_volume *_vol) fs_unmount(fs_volume* _volume)
{ {
status_t result = B_NO_ERROR; status_t result = B_NO_ERROR;
iso9660_volume *ns = (iso9660_volume *)_vol->private_volume; iso9660_volume* volume = (iso9660_volume*)_volume->private_volume;
TRACE(("fs_unmount - ENTER\n")); TRACE(("fs_unmount - ENTER\n"));
// Unlike in BeOS, we need to put the reference to our root node ourselves // Unlike in BeOS, we need to put the reference to our root node ourselves
put_vnode(_vol, ISO_ROOTNODE_ID); put_vnode(_volume, ISO_ROOTNODE_ID);
block_cache_delete(ns->fBlockCache, false); block_cache_delete(volume->fBlockCache, false);
close(ns->fdOfSession); close(volume->fdOfSession);
result = close(ns->fd); result = close(volume->fd);
free(ns); free(volume);
TRACE(("fs_unmount - EXIT, result is %s\n", strerror(result))); TRACE(("fs_unmount - EXIT, result is %s\n", strerror(result)));
return result; return result;
@@ -175,39 +175,41 @@ fs_unmount(fs_volume *_vol)
static status_t static status_t
fs_read_fs_stat(fs_volume *_vol, struct fs_info *fss) fs_read_fs_stat(fs_volume* _volume, struct fs_info* info)
{ {
iso9660_volume *ns = (iso9660_volume *)_vol->private_volume; iso9660_volume* volume = (iso9660_volume*)_volume->private_volume;
info->flags = B_FS_IS_PERSISTENT | B_FS_IS_READONLY;
info->block_size = volume->logicalBlkSize[FS_DATA_FORMAT];
info->io_size = 65536;
info->total_blocks = volume->volSpaceSize[FS_DATA_FORMAT];
info->free_blocks = 0;
strlcpy(info->device_name, volume->devicePath, sizeof(info->device_name));
strlcpy(info->volume_name, volume->volIDString, sizeof(info->volume_name));
// strip trailing spaces
int i; int i;
for (i = strlen(info->volume_name) - 1; i >=0 ; i--) {
fss->flags = B_FS_IS_PERSISTENT | B_FS_IS_READONLY; if (info->volume_name[i] != ' ')
fss->block_size = ns->logicalBlkSize[FS_DATA_FORMAT];
fss->io_size = 65536;
fss->total_blocks = ns->volSpaceSize[FS_DATA_FORMAT];
fss->free_blocks = 0;
strncpy(fss->device_name, ns->devicePath, sizeof(fss->device_name));
strncpy(fss->volume_name, ns->volIDString, sizeof(fss->volume_name));
for (i = strlen(fss->volume_name) - 1; i >=0 ; i--) {
if (fss->volume_name[i] != ' ')
break; break;
} }
if (i < 0) if (i < 0)
strcpy(fss->volume_name, "UNKNOWN"); strcpy(info->volume_name, "UNKNOWN");
else else
fss->volume_name[i + 1] = 0; info->volume_name[i + 1] = 0;
strcpy(fss->fsh_name, "iso9660"); strcpy(info->fsh_name, "iso9660");
return B_OK; return B_OK;
} }
static status_t static status_t
fs_get_vnode_name(fs_volume *_vol, fs_vnode *_node, char *buffer, size_t bufferSize) fs_get_vnode_name(fs_volume* _volume, fs_vnode* _node, char* buffer,
size_t bufferSize)
{ {
iso9660_inode *node = (iso9660_inode*)_node->private_node; iso9660_inode* node = (iso9660_inode*)_node->private_node;
strlcpy(buffer, node->name, bufferSize); strlcpy(buffer, node->name, bufferSize);
return B_OK; return B_OK;
@@ -215,11 +217,11 @@ fs_get_vnode_name(fs_volume *_vol, fs_vnode *_node, char *buffer, size_t bufferS
static status_t static status_t
fs_walk(fs_volume *_vol, fs_vnode *_base, const char *file, ino_t *_vnodeID) fs_walk(fs_volume* _volume, fs_vnode* _base, const char* file, ino_t* _vnodeID)
{ {
iso9660_volume *ns = (iso9660_volume *)_vol->private_volume; iso9660_volume* volume = (iso9660_volume*)_volume->private_volume;
iso9660_inode *baseNode = (iso9660_inode*)_base->private_node; iso9660_inode* baseNode = (iso9660_inode*)_base->private_node;
iso9660_inode *newNode = NULL; iso9660_inode* newNode = NULL;
TRACE(("fs_walk - looking for %s in dir file of length %d\n", file, TRACE(("fs_walk - looking for %s in dir file of length %d\n", file,
(int)baseNode->dataLen[FS_DATA_FORMAT])); (int)baseNode->dataLen[FS_DATA_FORMAT]));
@@ -228,12 +230,12 @@ fs_walk(fs_volume *_vol, fs_vnode *_base, const char *file, ino_t *_vnodeID)
// base directory // base directory
TRACE(("fs_walk - found \".\" file.\n")); TRACE(("fs_walk - found \".\" file.\n"));
*_vnodeID = baseNode->id; *_vnodeID = baseNode->id;
return get_vnode(_vol, *_vnodeID, NULL); return get_vnode(_volume, *_vnodeID, NULL);
} else if (strcmp(file, "..") == 0) { } else if (strcmp(file, "..") == 0) {
// parent directory // parent directory
TRACE(("fs_walk - found \"..\" file.\n")); TRACE(("fs_walk - found \"..\" file.\n"));
*_vnodeID = baseNode->parID; *_vnodeID = baseNode->parID;
return get_vnode(_vol, *_vnodeID, NULL); return get_vnode(_volume, *_vnodeID, NULL);
} }
// look up file in the directory // look up file in the directory
@@ -245,7 +247,7 @@ fs_walk(fs_volume *_vol, fs_vnode *_base, const char *file, ino_t *_vnodeID)
while (totalRead < dataLength && !done) { while (totalRead < dataLength && !done) {
off_t cachedBlock = block; off_t cachedBlock = block;
char* blockData = (char*)block_cache_get(ns->fBlockCache, block); char* blockData = (char*)block_cache_get(volume->fBlockCache, block);
if (blockData == NULL) if (blockData == NULL)
break; break;
@@ -260,11 +262,11 @@ fs_walk(fs_volume *_vol, fs_vnode *_base, const char *file, ino_t *_vnodeID)
// Move to the next block if necessary // Move to the next block if necessary
// Don't go over end of buffer, if dir record sits on boundary. // Don't go over end of buffer, if dir record sits on boundary.
while (blockBytesRead < ns->logicalBlkSize[FS_DATA_FORMAT] while (blockBytesRead < volume->logicalBlkSize[FS_DATA_FORMAT]
&& totalRead + blockBytesRead < dataLength && totalRead + blockBytesRead < dataLength
&& blockData[0] != 0 && blockData[0] != 0
&& !done) { && !done) {
initResult = InitNode(ns, &node, blockData, &bytesRead); initResult = InitNode(volume, &node, blockData, &bytesRead);
TRACE(("fs_walk - InitNode returned %s, filename %s, %u bytes " TRACE(("fs_walk - InitNode returned %s, filename %s, %u bytes "
"read\n", strerror(initResult), node.name, (unsigned)bytesRead)); "read\n", strerror(initResult), node.name, (unsigned)bytesRead));
@@ -277,8 +279,7 @@ fs_walk(fs_volume *_vol, fs_vnode *_base, const char *file, ino_t *_vnodeID)
*_vnodeID = (block << 30) + (blockBytesRead & 0xffffffff); *_vnodeID = (block << 30) + (blockBytesRead & 0xffffffff);
TRACE(("fs_walk - New vnode id is %Ld\n", *_vnodeID)); TRACE(("fs_walk - New vnode id is %Ld\n", *_vnodeID));
result = get_vnode(_vol, *_vnodeID, result = get_vnode(_volume, *_vnodeID, (void**)&newNode);
(void **)&newNode);
if (result == B_OK) { if (result == B_OK) {
newNode->parID = baseNode->id; newNode->parID = baseNode->id;
done = true; done = true;
@@ -299,12 +300,12 @@ fs_walk(fs_volume *_vol, fs_vnode *_base, const char *file, ino_t *_vnodeID)
"%Ld/%u).\n", (unsigned)bytesRead, blockBytesRead, "%Ld/%u).\n", (unsigned)bytesRead, blockBytesRead,
(unsigned)baseNode->dataLen[FS_DATA_FORMAT])); (unsigned)baseNode->dataLen[FS_DATA_FORMAT]));
} }
totalRead += ns->logicalBlkSize[FS_DATA_FORMAT]; totalRead += volume->logicalBlkSize[FS_DATA_FORMAT];
block++; block++;
TRACE(("fs_walk - moving to next block %Ld, total read %u\n", TRACE(("fs_walk - moving to next block %Ld, total read %u\n",
block, (unsigned)totalRead)); block, (unsigned)totalRead));
block_cache_put(ns->fBlockCache, cachedBlock); block_cache_put(volume->fBlockCache, cachedBlock);
} }
TRACE(("fs_walk - EXIT, result is %s, vnid is %Lu\n", TRACE(("fs_walk - EXIT, result is %s, vnid is %Lu\n",
@@ -314,12 +315,12 @@ fs_walk(fs_volume *_vol, fs_vnode *_base, const char *file, ino_t *_vnodeID)
static status_t static status_t
fs_read_vnode(fs_volume *_vol, ino_t vnodeID, fs_vnode *_node, fs_read_vnode(fs_volume* _volume, ino_t vnodeID, fs_vnode* _node,
int *_type, uint32 *_flags, bool reenter) int* _type, uint32* _flags, bool reenter)
{ {
iso9660_volume *ns = (iso9660_volume*)_vol->private_volume; iso9660_volume* volume = (iso9660_volume*)_volume->private_volume;
iso9660_inode *newNode = (iso9660_inode*)calloc(sizeof(iso9660_inode), 1); iso9660_inode* newNode = (iso9660_inode*)calloc(sizeof(iso9660_inode), 1);
if (newNode == NULL) if (newNode == NULL)
return B_NO_MEMORY; return B_NO_MEMORY;
@@ -329,19 +330,19 @@ fs_read_vnode(fs_volume *_vol, ino_t vnodeID, fs_vnode *_node,
TRACE(("fs_read_vnode - block = %u, pos = %u, raw = %Lu node %p\n", TRACE(("fs_read_vnode - block = %u, pos = %u, raw = %Lu node %p\n",
(unsigned)block, (unsigned) pos, vnodeID, newNode)); (unsigned)block, (unsigned) pos, vnodeID, newNode));
if (pos > ns->logicalBlkSize[FS_DATA_FORMAT]) { if (pos > volume->logicalBlkSize[FS_DATA_FORMAT]) {
free(newNode); free(newNode);
return B_BAD_VALUE; return B_BAD_VALUE;
} }
char *data = (char *)block_cache_get(ns->fBlockCache, block); char* data = (char*)block_cache_get(volume->fBlockCache, block);
if (data == NULL) { if (data == NULL) {
free(newNode); free(newNode);
return B_IO_ERROR; return B_IO_ERROR;
} }
status_t result = InitNode(ns, newNode, data + pos, NULL); status_t result = InitNode(volume, newNode, data + pos, NULL);
block_cache_put(ns->fBlockCache, block); block_cache_put(volume->fBlockCache, block);
if (result < B_OK) { if (result < B_OK) {
free(newNode); free(newNode);
@@ -356,7 +357,7 @@ fs_read_vnode(fs_volume *_vol, ino_t vnodeID, fs_vnode *_node,
*_flags = 0; *_flags = 0;
if ((newNode->flags & ISO_IS_DIR) == 0) { if ((newNode->flags & ISO_IS_DIR) == 0) {
newNode->cache = file_cache_create(ns->id, vnodeID, newNode->cache = file_cache_create(volume->id, vnodeID,
newNode->dataLen[FS_DATA_FORMAT]); newNode->dataLen[FS_DATA_FORMAT]);
} }
@@ -387,11 +388,11 @@ fs_release_vnode(fs_volume* /*_volume*/, fs_vnode* _node, bool /*reenter*/)
static status_t static status_t
fs_read_pages(fs_volume *_vol, fs_vnode *_node, void * _cookie, off_t pos, fs_read_pages(fs_volume* _volume, fs_vnode* _node, void* _cookie, off_t pos,
const iovec *vecs, size_t count, size_t *_numBytes) const iovec* vecs, size_t count, size_t* _numBytes)
{ {
iso9660_volume *ns = (iso9660_volume *)_vol->private_volume; iso9660_volume* volume = (iso9660_volume*)_volume->private_volume;
iso9660_inode *node = (iso9660_inode *)_node->private_node; iso9660_inode* node = (iso9660_inode*)_node->private_node;
uint32 fileSize = node->dataLen[FS_DATA_FORMAT]; uint32 fileSize = node->dataLen[FS_DATA_FORMAT];
size_t bytesLeft = *_numBytes; size_t bytesLeft = *_numBytes;
@@ -407,27 +408,27 @@ fs_read_pages(fs_volume *_vol, fs_vnode *_node, void * _cookie, off_t pos,
file_io_vec fileVec; file_io_vec fileVec;
fileVec.offset = pos + node->startLBN[FS_DATA_FORMAT] fileVec.offset = pos + node->startLBN[FS_DATA_FORMAT]
* ns->logicalBlkSize[FS_DATA_FORMAT]; * volume->logicalBlkSize[FS_DATA_FORMAT];
fileVec.length = bytesLeft; fileVec.length = bytesLeft;
uint32 vecIndex = 0; uint32 vecIndex = 0;
size_t vecOffset = 0; size_t vecOffset = 0;
return read_file_io_vec_pages(ns->fd, &fileVec, 1, vecs, count, return read_file_io_vec_pages(volume->fd, &fileVec, 1, vecs, count,
&vecIndex, &vecOffset, &bytesLeft); &vecIndex, &vecOffset, &bytesLeft);
} }
static status_t static status_t
fs_read_stat(fs_volume *_vol, fs_vnode *_node, struct stat *st) fs_read_stat(fs_volume* _volume, fs_vnode* _node, struct stat* st)
{ {
iso9660_volume *ns = (iso9660_volume*)_vol->private_volume; iso9660_volume* volume = (iso9660_volume*)_volume->private_volume;
iso9660_inode *node = (iso9660_inode*)_node->private_node; iso9660_inode* node = (iso9660_inode*)_node->private_node;
status_t result = B_NO_ERROR; status_t result = B_NO_ERROR;
time_t time; time_t time;
TRACE(("fs_read_stat - ENTER\n")); TRACE(("fs_read_stat - ENTER\n"));
st->st_dev = ns->id; st->st_dev = volume->id;
st->st_ino = node->id; st->st_ino = node->id;
st->st_nlink = node->attr.stat[FS_DATA_FORMAT].st_nlink; st->st_nlink = node->attr.stat[FS_DATA_FORMAT].st_nlink;
st->st_uid = node->attr.stat[FS_DATA_FORMAT].st_uid; st->st_uid = node->attr.stat[FS_DATA_FORMAT].st_uid;
@@ -448,28 +449,22 @@ fs_read_stat(fs_volume *_vol, fs_vnode *_node, struct stat *st)
static status_t static status_t
fs_open(fs_volume *_vol, fs_vnode *_node, int omode, void **cookie) fs_open(fs_volume* /*_volume*/, fs_vnode* _node, int openMode, void** /*cookie*/)
{ {
status_t result = B_NO_ERROR;
(void)_vol;
(void)cookie;
// Do not allow any of the write-like open modes to get by // Do not allow any of the write-like open modes to get by
if ((omode == O_WRONLY) || (omode == O_RDWR)) if ((openMode & O_RWMASK) == O_WRONLY || (openMode & O_RWMASK) == O_RDWR
result = EROFS; || (openMode & O_TRUNC) != 0 || (openMode & O_CREAT) != 0)
else if((omode & O_TRUNC) || (omode & O_CREAT)) return EROFS;
result = EROFS;
return result; return B_OK;
} }
static status_t static status_t
fs_read(fs_volume *_vol, fs_vnode *_node, void *cookie, off_t pos, void *buffer, fs_read(fs_volume* _volume, fs_vnode* _node, void* cookie, off_t pos,
size_t *_length) void* buffer, size_t* _length)
{ {
iso9660_inode *node = (iso9660_inode *)_node->private_node; iso9660_inode* node = (iso9660_inode*)_node->private_node;
if ((node->flags & ISO_IS_DIR) != 0) if ((node->flags & ISO_IS_DIR) != 0)
return EISDIR; return EISDIR;
@@ -489,42 +484,31 @@ fs_read(fs_volume *_vol, fs_vnode *_node, void *cookie, off_t pos, void *buffer,
static status_t static status_t
fs_close(fs_volume *_vol, fs_vnode *_node, void *cookie) fs_close(fs_volume* /*_volume*/, fs_vnode* /*_node*/, void* /*cookie*/)
{ {
(void)_vol;
(void)_node;
(void)cookie;
return B_OK; return B_OK;
} }
static status_t static status_t
fs_free_cookie(fs_volume *_vol, fs_vnode *_node, void *cookie) fs_free_cookie(fs_volume* /*_volume*/, fs_vnode* /*_node*/, void* /*cookie*/)
{ {
(void)_vol;
(void)_node;
(void)cookie;
return B_OK; return B_OK;
} }
static status_t static status_t
fs_access(fs_volume *_vol, fs_vnode *_node, int mode) fs_access(fs_volume* /*_volume*/, fs_vnode* /*_node*/, int /*mode*/)
{ {
(void)_vol;
(void)_node;
(void)mode;
return B_OK; return B_OK;
} }
static status_t static status_t
fs_read_link(fs_volume *_vol, fs_vnode *_node, char *buffer, size_t *_bufferSize) fs_read_link(fs_volume* _volume, fs_vnode* _node, char* buffer,
size_t* _bufferSize)
{ {
iso9660_inode *node = (iso9660_inode *)_node->private_node; iso9660_inode* node = (iso9660_inode*)_node->private_node;
if (!S_ISLNK(node->attr.stat[FS_DATA_FORMAT].st_mode)) if (!S_ISLNK(node->attr.stat[FS_DATA_FORMAT].st_mode))
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -544,7 +528,7 @@ fs_read_link(fs_volume *_vol, fs_vnode *_node, char *buffer, size_t *_bufferSize
static status_t static status_t
fs_open_dir(fs_volume* /*_volume*/, fs_vnode* _node, void** _cookie) fs_open_dir(fs_volume* /*_volume*/, fs_vnode* _node, void** _cookie)
{ {
iso9660_inode *node = (iso9660_inode *)_node->private_node; iso9660_inode* node = (iso9660_inode*)_node->private_node;
TRACE(("fs_open_dir - node is %p\n", node)); TRACE(("fs_open_dir - node is %p\n", node));
@@ -567,15 +551,15 @@ fs_open_dir(fs_volume* /*_volume*/, fs_vnode* _node, void** _cookie)
static status_t static status_t
fs_read_dir(fs_volume *_vol, fs_vnode *_node, void *_cookie, fs_read_dir(fs_volume* _volume, fs_vnode* _node, void* _cookie,
struct dirent *buffer, size_t bufferSize, uint32 *num) struct dirent* buffer, size_t bufferSize, uint32* num)
{ {
iso9660_volume *ns = (iso9660_volume *)_vol->private_volume; iso9660_volume* volume = (iso9660_volume*)_volume->private_volume;
dircookie *dirCookie = (dircookie *)_cookie; dircookie* dirCookie = (dircookie*)_cookie;
TRACE(("fs_read_dir - ENTER\n")); TRACE(("fs_read_dir - ENTER\n"));
status_t result = ISOReadDirEnt(ns, dirCookie, buffer, bufferSize); status_t result = ISOReadDirEnt(volume, dirCookie, buffer, bufferSize);
// If we succeeded, return 1, the number of dirents we read. // If we succeeded, return 1, the number of dirents we read.
if (result == B_OK) if (result == B_OK)
@@ -595,9 +579,9 @@ fs_read_dir(fs_volume *_vol, fs_vnode *_node, void *_cookie,
static status_t static status_t
fs_rewind_dir(fs_volume *_vol, fs_vnode *_node, void* _cookie) fs_rewind_dir(fs_volume* _volume, fs_vnode* _node, void* _cookie)
{ {
dircookie *cookie = (dircookie*)_cookie; dircookie* cookie = (dircookie*)_cookie;
cookie->block = cookie->startBlock; cookie->block = cookie->startBlock;
cookie->pos = 0; cookie->pos = 0;
@@ -606,14 +590,14 @@ fs_rewind_dir(fs_volume *_vol, fs_vnode *_node, void* _cookie)
static status_t static status_t
fs_close_dir(fs_volume *_vol, fs_vnode *_node, void *cookie) fs_close_dir(fs_volume* _volume, fs_vnode* _node, void* cookie)
{ {
return B_OK; return B_OK;
} }
static status_t static status_t
fs_free_dir_cookie(fs_volume *_vol, fs_vnode *_node, void *cookie) fs_free_dir_cookie(fs_volume* _volume, fs_vnode* _node, void* cookie)
{ {
free(cookie); free(cookie);
return B_OK; return B_OK;
@@ -676,7 +660,7 @@ fs_vnode_ops gISO9660VnodeOps = {
&fs_read_pages, &fs_read_pages,
NULL, NULL,
NULL, // io() NULL, // io()
NULL, // cancel_io() NULL, // cancel_io()
/* cache file access */ /* cache file access */
@@ -778,8 +762,8 @@ static file_system_module_info sISO660FileSystem = {
NULL, NULL,
}; };
module_info *modules[] = { module_info* modules[] = {
(module_info *)&sISO660FileSystem, (module_info*)&sISO660FileSystem,
NULL, NULL,
}; };