Changeset 782 for Whitix/branches

Timestamp:

07/13/08 20:41:33 (5 months ago)

Author:

mwhitworth

Message:

Add to update code, add basic create and truncate functions.

Files:

• Whitix/branches/fs/fs/ext3/inode.c (modified) (9 diffs)

Whitix/branches/fs/fs/ext3/inode.c

@@ +1 @@
+/*  This file is part of Whitix.
+ *
+ *  Whitix is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Whitix is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Whitix; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
 #include <console.h>
 #include <malloc.h>
@@ -32 +50 @@
         block=groupDescs[desc].iNodeTable+((vNo % sbInfo->iNodesPerGrp)/INODES_PER_BLOCK(vNode->superBlock));
 
-        *buffer=BlockRead(vNode->superBlock->sDevice,block);
+        *buffer=BlockRead(vNode->superBlock->sDevice, block);
 
         if (!*buffer)
                 return -EIO;
 
-        *iNode=((struct Ext3INode*)(*buffer)->data+(vNo % INODES_PER_BLOCK(vNode->superBlock)));
+        *iNode=(((struct Ext3INode*)(*buffer)->data)+(vNo % INODES_PER_BLOCK(vNode->superBlock)));
 
         return 0;
@@ -61 +79 @@
                 return -ENOMEM;
         }
+        
+        /* Copy EXT3-specific data first. */
+        iNodeInfo->blockGroup=(vNode->id-1)/EXT3_SUPERINFO(vNode->superBlock)->iNodesPerGrp;
 
         /* Copy over the blocks */
         for (i=0; i<15; i++)
+        {
                 iNodeInfo->blocks[i]=iNode->blocks[i];
+        }
 
         /* Copy the iNode times over */
@@ -92 +115 @@
 
         /* Force a commit to the journal, to make sure this vNode is written to disk. */
-        PreemptDisable();
         err=JournalForceCommit(EXT3_JOURNAL(vNode));
-        PreemptEnable();
 
         return err;
@@ -118 +139 @@
         struct Buffer* buffer, struct Ext3INode* iNode)
 {
+        struct Ext3INodeInfo* info=EXT3_INFO(vNode);
+        
         if (handle)
         {
@@ -128 +151 @@
         iNode->mTime=vNode->mTime.seconds;
         iNode->size=vNode->size;
-
+        
+        if (vNode->mode & VFS_ATTR_DIR)
+                iNode->mode=0x4000;
+        else if (vNode->mode & VFS_ATTR_FILE)
+                iNode->mode=0x8000;
+                
+        iNode->linksCount=1;
+        iNode->blocksCount=((vNode->size+BYTES_PER_SECTOR(vNode->superBlock)-1)/BYTES_PER_SECTOR(vNode->superBlock));
+        
+        int i;
+        for (i=0; i<15; i++)
+                iNode->blocks[i]=info->blocks[i];
+        
         /* TODO: Complete. */
 
+//      KePrint("Update\n");
+
         JournalDirtyMetadata(handle, buffer);
 
-        BufferRelease(buffer);
+//      BufferRelease(buffer);
 
         return 0;
@@ -161 +198 @@
         JournalStop(handle);
 
+        return err;
+}
+
+static int Ext3AddEntry(struct JournalHandle* handle, char* name, int nameLength,
+        struct VNode* dir, struct VNode* vNode)
+{
+        struct Buffer* buffer;
+        int offset=0, recLen;
+        struct Ext3DirEntry* entry;
+        
+//      KePrint("Here\n");
+        
+        buffer=Ext3BlockRead(dir, 0);
+        
+        if (!buffer)
+                return -EIO;
+        
+        recLen=EXT3_DIR_REC_LEN(nameLength);
+        
+        entry=(struct Ext3DirEntry*)buffer->data;
+        
+        while (1)
+        {
+                if ((char*)entry >= BYTES_PER_SECTOR(vNode->superBlock)+buffer->data)
+                {
+                        KePrint("New block?\n");
+                        cli(); hlt();
+                }
+                
+                KePrint("%u %u\n", entry->iNodeNum, entry->recLen);
+                
+                if ((entry->iNodeNum == 0 && entry->recLen >= recLen) ||
+                        (entry->recLen >= EXT3_DIR_REC_LEN(entry->nameLen) + recLen))
+                {
+                        JournalGetWriteAccess(handle, buffer);
+                        
+                        if (entry->iNodeNum)
+                        {
+                                struct Ext3DirEntry* next;
+                                
+                                next=(struct Ext3DirEntry*)((char*)entry+EXT3_DIR_REC_LEN(entry->nameLen));
+                                next->recLen=entry->recLen-EXT3_DIR_REC_LEN(entry->nameLen);
+                                entry->recLen=EXT3_DIR_REC_LEN(entry->nameLen);
+                                                                
+                                KePrint("de: (%u %u) %u\n", entry->recLen, entry->nameLen, next->recLen);
+                                entry=next;
+                        }
+                        
+                        entry->fileType=EXT3_FT_UNKNOWN;
+                        
+                        if (vNode)
+                        {
+                                entry->iNodeNum=vNode->id;
+                                entry->fileType=Ext3SetFileType(vNode->mode);
+                        }
+                        
+                        entry->nameLen=nameLength;
+                        memcpy(entry->name, name, nameLength);
+                        
+                        JournalDirtyMetadata(handle, buffer);
+                        return 0;
+                }
+                
+                offset+=entry->recLen;
+                entry=(struct Ext3DirEntry*)(((char*)entry)+entry->recLen);
+        }
+        
+        KePrint("Out?\n");
+        cli(); hlt();
+        
+        return 0;
+}
+
+static int Ext3AddNonDirEntry(struct JournalHandle* handle, char* name, int nameLength,
+        struct VNode* dir, struct VNode* vNode)
+{
+        int err;
+        
+        err=Ext3AddEntry(handle, name, nameLength, dir, vNode);
+        
+        if (!err)
+        {
+                err=Ext3DirtyVNode(vNode);
+        }
+        
+        return err;
+}
+
+int Ext3Create(struct VNode** retVal,struct VNode* dir,char* name,int nameLength)
+{
+        struct JournalHandle* handle;
+        struct VNode* vNode;
+        int err;
+        
+        handle=JournalStart(EXT3_JOURNAL(dir), EXT3_DATA_TRANS + 3);
+        
+        vNode=Ext3CreateINode(handle, dir /* mode */);
+        
+        /* Create directory entry. */
+        err=Ext3AddNonDirEntry(handle, name, nameLength, dir, vNode);
+        
+        JournalStop(handle);
+        
+        *retVal=vNode;
+        
         return err;
 }
@@ -201 +343 @@
 }
 
+#define EXT3_DIO_CREDITS (EXT3_RESERVE_TRANS_BLOCKS+32)
+
 int Ext3BlockMap(struct VNode* vNode, DWORD block, int flags)
 {
-        struct Ext3INodeInfo* iNodeInfo=(struct Ext3INodeInfo*)vNode->extraInfo;
         struct Buffer* buff;
-
-        if (block < 12)
-        {
-                if (!iNodeInfo->blocks[block])
-                {
-                        if (!(flags & VFS_MAP_CREATE))
-                                return -EIO;
-
-                        KePrint("Ext3: BlockMap, iNodeInfo->blocks[%d] = 0\n", block);
-                        cli(); hlt();
-                }
-
-                /* The first 12 blocks in the inode structure are direct blocks */
-                return iNodeInfo->blocks[block];
-        }
-
-        block-=12;
-        if (block < (BYTES_PER_SECTOR(vNode->superBlock)/sizeof(unsigned long)))
-        {
-                int sector=iNodeInfo->blocks[12];
-                buff=BlockRead(vNode->superBlock->sDevice,sector);
-                if (!buff)
-                        return -EIO;
-
-                DWORD* data=(DWORD*)buff->data;
-
-                return data[block];
-        }
-
-        KePrint("Ext3BlockMap: block >= 256+12\n");
-        cli(); hlt();
-
+        struct JournalHandle* handle=JournalCurrHandle();
+        int ret=0;
+        
+        if (flags & VFS_MAP_CREATE)
+        {
+                handle=JournalStart(EXT3_JOURNAL(vNode), EXT3_RESERVE_TRANS_BLOCKS);
+#if 0
+                if (handle->numBlocks <= EXT3_RESERVE_TRANS_BLOCKS)
+                {
+                        ret=JournalExtend(handle, EXT3_DIO_CREDITS);
+                        
+                        if (ret)
+                        {
+                                ret=JournalRestart(handle, EXT3_DIO_CREDITS);
+                        }
+                }
+#endif
+
+#if 0
+#endif
+        }
+        
+        if (!ret)
+        {
+                ret=Ext3BlockMapHandle(handle, vNode, block, flags);
+        }
+        
+        if (flags & VFS_MAP_CREATE)
+        {
+                JournalStop(handle);
+        }
+
+        return ret;
+}
+
+int Ext3Truncate(struct VNode* vNode, int size)
+{
+        if (size > vNode->size)
+        {
+                KePrint("Ext3Truncate, %d, %d\n", size, vNode->size);
+        }else if (size < vNode->size)
+        {
+                return Ext3BlockTruncate(vNode, size);
+        }
+        
         return 0;
 }
@@ -283 +439 @@
                 {
                         ext3Entry=(struct Ext3DirEntry*)(buff->data+offset);
+                        
+//                      KePrint("%u %u, %s (%u %u)\n", file->position, file->vNode->size, ext3Entry->name, ext3Entry->nameLen, ext3Entry->recLen);
 
                         if (LIKELY(ext3Entry->iNodeNum))