Changeset 854

Timestamp:

08/21/08 21:46:43 (3 years ago)

Author:

mwhitworth

Message:

Convert devfs to use new kfs layer.

Files:

• Whitix/trunk/fs/devfs/devfs.c (modified) (17 diffs)

Whitix/trunk/fs/devfs/devfs.c

@@ -33 +33 @@
 #include <init.h>
 #include <error.h>
+#include <fs/kfs.h>
 #include <print.h>
 
@@ -38 +39 @@
 #include "../devices/storage/ata/ata.h"
 
-/* Local prototypes */
-int DevFsDirSize(struct DevFsDir* dir);
-
 /* Root directory of the device filesystem. */
-struct DevFsDir* rootDir;
-struct DevFsEntry rootEntry;
+struct KeFsDir* rootDir;
+struct KeFsEntry rootEntry;
 
 struct SuperBlockOps devFsSbOps;
@@ -127 +125 @@
 int DevFsReadVNode(struct VNode* vNode)
 {
-        struct DevFsEntry* entry=(struct DevFsEntry*)(vNode->id);
+        struct KeFsEntry* entry=(struct KeFsEntry*)(vNode->id);
+        struct DevFsDevice* device;
         struct StorageDevice* sDevice;
-
-        vNode->extraInfo=entry;
+        
         vNode->vNodeOps=&devFsVOps;
-
         vNode->mode=VFS_ATTR_READ | VFS_ATTR_WRITE;
 
@@ -138 +135 @@
         {
                 vNode->mode |= VFS_ATTR_FILE;
-                vNode->devId.major=entry->device.devId.major;
-                vNode->devId.minor=entry->device.devId.minor;
+                device=(struct DevFsDevice*)entry->file;
+                vNode->devId.major=device->devId.major;
+                vNode->devId.minor=device->devId.minor;
                 if (entry->type & DEVICE_BLOCK)
                 {
@@ -152 +150 @@
                         vNode->mode |= VFS_ATTR_CHAR;
                         /* Just redirect to the usual char devices */
-                        vNode->fileOps=entry->device.ops;
+                        vNode->fileOps=device->ops;
                         vNode->size=0;
                 }
@@ -159 +157 @@
                 vNode->fileOps=&devFsFileOps;
                 vNode->mode|=VFS_ATTR_DIR;
-                vNode->size=DevFsDirSize(&entry->dir);
-        }
-
-        return 0;
-}
-
-int DevFsFreeVNode(struct VNode* vNode)
-{
-        /* This function is so that extraInfo (which contains the DevFsEntry and could be
-        malloc'ed) is not freed by the virtual filesystem layer. */
-        return 0;
-}
-
-int DevFsLookup(struct VNode** retVal,struct VNode* dir,char* name,int nameLength)
-{
-        struct DevFsDir* dDir;
-        struct DevFsEntry* entry;
-
-        entry=(struct DevFsEntry*)(dir->extraInfo);
-        dDir=&entry->dir;
-
-        /* Handle '..'. '..' on the root directory will already have been handled by the VFS. */
-        if (nameLength == 2 && name[0] == '.' && name[1] == '.')
-        {
-                dDir=dDir->parent;
-                entry=(struct DevFsEntry*)(((DWORD)dDir)-offsetof(struct DevFsEntry, dir));
-                goto found;
-        }
-
-        ListForEachEntry(entry,&(dDir->entries),next)
-                if (!strnicmp(entry->name,name,nameLength))
-                        goto found;
-
-        /* Cycled through the whole directory with no luck */
-        return -ENOENT;
-
-found:
-        *retVal=VNodeGet(dir->superBlock,(DWORD)entry);
-        return 0;
-}
-
-struct DevFsDir* DevDirLookup(char* name,int nameLength,struct DevFsDir* dir)
-{
-        struct DevFsEntry* entry;
-        
-        /* Look it up */
-        ListForEachEntry(entry,&(dir->entries),next)
-        {
-                if ((entry->type & VFS_ATTR_DIR) && !strnicmp(entry->name, name, nameLength))
-                        return &entry->dir;
-        }       
-        
-        return NULL;
+                vNode->size=KeFsDirSize(&entry->dir);
+        }
+
+        return 0;
 }
 
 int DevAddDevice(char* name, WORD major, WORD minor, int type, void* ops)
 {
-        struct DevFsEntry* entry;
+        struct KeFsDir* dir=rootDir;
+        struct KeFsEntry* entry;
         struct DevFsDevice* device;
-        struct DevFsDir* dir=rootDir;
-        char* endName;
-        DWORD offset;
 
         /* Sanity checks */
@@ -228 +175 @@
         if (!major)
                 return -EINVAL;
-
-        /* Get to the directory first. */
-        while ((endName=strchr(name,'/')))
-        {
-                offset=(DWORD)(endName-name);
-                dir=DevDirLookup(name, offset,dir);
-                if (!dir)
-                        return -ENOENT;
-                        
-                name+=offset+1;
-        }
-
-//      printf("DevAddDevice(%s)\n", name);
-
-        /* Check if the name exists already */
-        ListForEachEntry(entry,&(dir->entries),next)
-                if (!strnicmp(entry->name,name,strlen(name)))
-                        return -EEXIST;
-
-        /* Allocate the DevFsEntry, and the name with it */
-        entry=(struct DevFsEntry*)malloc(sizeof(struct DevFsEntry)+strlen(name)+1);
+        
+        entry=KeFsAddEntry(dir, name);
+        
         if (!entry)
-                return -ENOMEM;
-
-        /* Always a device */
-        entry->type=type | VFS_ATTR_FILE | VFS_ATTR_READ | VFS_ATTR_WRITE;
-        strcpy(entry->name,name);
-        
-        device=(struct DevFsDevice*)(&entry->device);
+                return -EFAULT;
+
+        device=(struct DevFsDevice*)malloc(sizeof(struct DevFsDevice));
         
         device->ops=ops;
         device->devId.major=major;
         device->devId.minor=minor;
-        ListAddTail(&entry->next,&dir->entries);
+        entry->file=device;
+        
+        entry->type |= type;
 
         return 0;
@@ -274 +201 @@
 {
         /* Any storage devices will be found in the Storage directory. */
-        struct DevFsDir* dir;
-        struct DevFsEntry* entry;
-        
-        dir=DevDirLookup("Storage", strlen("Storage"), rootDir);
+        struct KeFsDir* dir;
+        struct KeFsEntry* entry;
+        struct DevFsDevice* device;
+        
+        dir=KeFsDirLookup("Storage", strlen("Storage"), rootDir);
         
         if (!dir)
                 return NULL;
         
-        ListForEachEntry(entry,&(dir->entries), next)
+        ListForEachEntry(entry,&dir->entries, next)
         {
                 if (entry->type & VFS_ATTR_FILE)
                 {
-                        if (entry->device.devId.major == major && entry->device.devId.minor == minor && (entry->type & DEVICE_BLOCK))
-                                return (struct StorageDevice*)(entry->device.ops);
+                        device=(struct DevFsDevice*)(entry->file);
+                        if (device->devId.major == major && device->devId.minor == minor && (entry->type & DEVICE_BLOCK))
+                                return (struct StorageDevice*)(device->ops);
                 }
         }
@@ -330 +259 @@
         else
                 /* Decode root filesystem here */
-                rootDev=DevFindRootDev(rootDevMajor,rootDevMinor);
+                rootDev=DevFindRootDev(rootDevMajor, rootDevMinor);
 
         if (!rootDev)
@@ -347 +276 @@
 {
         char* endName;
-        DWORD offset;
-        struct DevFsDir* dir=rootDir, *newDir;
-        struct DevFsEntry* entry;       
+        DWORD offset;   
+        struct KeFsDir* dir=rootDir;
         
         /* Get to the directory */
@@ -355 +283 @@
         {
                 offset=(DWORD)(endName-name);
-                dir=DevDirLookup(name, strlen(name),dir);
+                dir=KeFsDirLookup(name, strlen(name),dir);
                 if (!dir)
                         return -ENOENT;
         }
         
-        /* Check it doesn't exist already. */
-        ListForEachEntry(entry,&(dir->entries),next)
-                if (!strnicmp(entry->name,name,strlen(name)))
-                        return -EEXIST;
-        
-        /* Add entry. */
-        entry=(struct DevFsEntry*)malloc(sizeof(struct DevFsEntry)+strlen(name)+1);
-        entry->type=VFS_ATTR_DIR | VFS_ATTR_READ;
-        strcpy(entry->name, name);
-        
-        newDir=&entry->dir;
-        INIT_LIST_HEAD(&newDir->entries);
-        newDir->parent=dir;
-        
-        ListAddTail(&entry->next,&dir->entries);
+        KeFsAddDir(dir, name);
+        
         return 0;
 }
@@ -384 +299 @@
 }
 
-int DevFsPermission(struct VNode* node,int access)
-{
-        KePrint("DevFsPermission\n");
-        return 0;
-}
-
-int DevFsReadDir(struct File* file,void* dirEntries)
-{
-        struct DevFsEntry* entry;
-        struct DevFsEntry* entryDir=(struct DevFsEntry*)(file->vNode->extraInfo);
-        struct DevFsDir* dir=&entryDir->dir;
-        int ret;
-
-        ListForEachEntry(entry, &(dir->entries), next)
-        {
-                ret=FillDir(dirEntries,entry->name,strlen(entry->name),(DWORD)entry);
-                if (ret < 0)
-                        return ret;
-
-                file->position++;
-        }
-
+int DevFsReadDir(struct File* file, void* dirEntries)
+{
+        return KeFsReadDir(file, FillDir, dirEntries);
+}
+
+int DevFsLookup(struct VNode** retVal,struct VNode* dir,char* name,int nameLength)
+{
+        struct KeFsEntry* entry;
+        
+        entry=KeFsLookup(dir, name, nameLength);
+        
+        *retVal=VNodeGet(dir->superBlock, (DWORD)entry);
+        
         return 0;
 }
@@ -412 +318 @@
 {
         .readVNode = DevFsReadVNode,
-        .freeVNode = DevFsFreeVNode,
 };
 
@@ -418 +323 @@
 {
         .lookup=DevFsLookup,
-        .permission=DevFsPermission,
 };
 
@@ -426 +330 @@
         .readDir=DevFsReadDir,
 };
-
-int DevFsDirSize(struct DevFsDir* dir)
-{
-        struct DevFsEntry* entry;
-        int i=0;
-
-        ListForEachEntry(entry, &(dir->entries), next)
-                i++;
-
-        return i;
-}
 
 struct VfsSuperBlock* DevFsReadSuper(struct StorageDevice* dev,int flags,char* data)
@@ -452 +345 @@
         retVal->sbOps=&devFsSbOps;
         retVal->mount=VNodeGet(retVal,(DWORD)&rootEntry);
+        
         retVal->mount->mode=VFS_ATTR_DIR | VFS_ATTR_READ;
-        retVal->mount->size=DevFsDirSize(rootDir);
+        retVal->mount->size=KeFsDirSize(rootDir);
         retVal->mount->vNodeOps=&devFsVOps;
         retVal->mount->fileOps=&devFsFileOps;
-        retVal->mount->extraInfo=(void*)&rootEntry;
 
         return retVal;
@@ -469 +362 @@
 int DevFsInit()
 {
-        /* Set up the data structure here, and DevFsReadSuper doesn't do too much (at the moment) */
         VfsRegisterFileSystem(&devFileSystem);
 
         /* Set up the root directory here, as devices will be added before ReadSuper is called. */
-        rootEntry.type=VFS_ATTR_DIR | VFS_ATTR_READ | VFS_ATTR_WRITE;
-        rootEntry.name[0]='\0';
-        rootEntry.dir.parent=NULL; /* Parent is handled by VFS for the root directory. */
-        INIT_LIST_HEAD(&rootEntry.dir.entries);
+        KeFsInitRoot(&rootEntry);
         rootDir=&rootEntry.dir;