Exemple #1
0
        public virtual void Backup(System.IO.Stream streamOut)
        {
            lock (this)
            {
                if (!opened)
                    throw new StorageError(StorageError.STORAGE_NOT_OPENED);
                objectCache.Flush();

                int curr = 1 - currIndex;
                int nObjects = header.root[curr].indexUsed;
                long indexOffs = header.root[curr].index;
                int i, j, k;
                int nUsedIndexPages = (nObjects + dbHandlesPerPage - 1) / dbHandlesPerPage;
                int nIndexPages = (int) ((header.root[curr].indexSize + dbHandlesPerPage - 1) / dbHandlesPerPage);
                long totalRecordsSize = 0;
                long nPagedObjects = 0;
                int bitmapExtent = header.root[curr].bitmapExtent;
                long[] index = new long[nObjects];
                int[] oids = new int[nObjects];

                if (bitmapExtent == 0)
                    bitmapExtent = Int32.MaxValue;

                for (i = 0, j = 0; i < nUsedIndexPages; i++)
                {
                    Page pg = pool.GetPage(indexOffs + (long) i * Page.pageSize);
                    for (k = 0; k < dbHandlesPerPage && j < nObjects; k++, j++)
                    {
                        long pos = Bytes.Unpack8(pg.data, k * 8);
                        index[j] = pos;
                        oids[j] = j;
                        if ((pos & dbFreeHandleFlag) == 0)
                        {
                            if ((pos & dbPageObjectFlag) != 0)
                            {
                                nPagedObjects += 1;
                            }
                            else if (pos != 0)
                            {
                                int offs = (int) pos & (Page.pageSize - 1);
                                Page op = pool.GetPage(pos - offs);
                                int size = ObjectHeader.GetSize(op.data, offs & ~dbFlagsMask);
                                size = (size + dbAllocationQuantum - 1) & ~ (dbAllocationQuantum - 1);
                                totalRecordsSize += size;
                                pool.Unfix(op);
                            }
                        }
                    }
                    pool.Unfix(pg);
                }

                Header newHeader = new Header();
                newHeader.curr = 0;
                newHeader.dirty = false;
                newHeader.initialized = true;
                long newFileSize = (long) (nPagedObjects + nIndexPages * 2 + 1) * Page.pageSize + totalRecordsSize;
                newFileSize = (newFileSize + Page.pageSize - 1) & ~ (Page.pageSize - 1);
                newHeader.root = new RootPage[2];
                newHeader.root[0] = new RootPage();
                newHeader.root[1] = new RootPage();
                newHeader.root[0].size = newHeader.root[1].size = newFileSize;
                newHeader.root[0].index = newHeader.root[1].shadowIndex = Page.pageSize;
                newHeader.root[0].shadowIndex = newHeader.root[1].index = Page.pageSize + (long) nIndexPages * Page.pageSize;
                newHeader.root[0].shadowIndexSize = newHeader.root[0].indexSize = newHeader.root[1].shadowIndexSize = newHeader.root[1].indexSize = nIndexPages * dbHandlesPerPage;
                newHeader.root[0].indexUsed = newHeader.root[1].indexUsed = nObjects;
                newHeader.root[0].freeList = newHeader.root[1].freeList = header.root[curr].freeList;
                newHeader.root[0].bitmapEnd = newHeader.root[1].bitmapEnd = header.root[curr].bitmapEnd;

                newHeader.root[0].rootObject = newHeader.root[1].rootObject = header.root[curr].rootObject;
                newHeader.root[0].classDescList = newHeader.root[1].classDescList = header.root[curr].classDescList;
                newHeader.root[0].bitmapExtent = newHeader.root[1].bitmapExtent = header.root[curr].bitmapExtent;
                byte[] page = new byte[Page.pageSize];
                newHeader.Pack(page);
                streamOut.Write(page, 0, page.Length);

                long pageOffs = (long) (nIndexPages * 2 + 1) * Page.pageSize;
                long recOffs = (long) (nPagedObjects + nIndexPages * 2 + 1) * Page.pageSize;
                GenericSort.Sort(new AnonymousClassGenericSortArray(nObjects, index, oids, this));
                byte[] newIndex = new byte[nIndexPages * dbHandlesPerPage * 8];
                for (i = 0; i < nObjects; i++)
                {
                    long pos = index[i];
                    int oid = oids[i];
                    if ((pos & dbFreeHandleFlag) == 0)
                    {
                        if ((pos & dbPageObjectFlag) != 0)
                        {
                            Bytes.Pack8(newIndex, oid * 8, pageOffs | dbPageObjectFlag);
                            pageOffs += Page.pageSize;
                        }
                        else if (pos != 0)
                        {
                            Bytes.Pack8(newIndex, oid * 8, recOffs);
                            int offs = (int) pos & (Page.pageSize - 1);
                            Page op = pool.GetPage(pos - offs);
                            int size = ObjectHeader.GetSize(op.data, offs & ~dbFlagsMask);
                            size = (size + dbAllocationQuantum - 1) & ~ (dbAllocationQuantum - 1);
                            recOffs += size;
                            pool.Unfix(op);
                        }
                    }
                    else
                    {
                        Bytes.Pack8(newIndex, oid * 8, pos);
                    }
                }
                streamOut.Write(newIndex, 0, newIndex.Length);
                streamOut.Write(newIndex, 0, newIndex.Length);

                for (i = 0; i < nObjects; i++)
                {
                    long pos = index[i];
                    if (((int) pos & (dbFreeHandleFlag | dbPageObjectFlag)) == dbPageObjectFlag)
                    {
                        if (oids[i] < dbBitmapId + dbBitmapPages || (oids[i] >= bitmapExtent && oids[i] < bitmapExtent + dbLargeBitmapPages - dbBitmapPages))
                        {
                            int pageId = oids[i] < dbBitmapId + dbBitmapPages ? oids[i] - dbBitmapId : oids[i] - bitmapExtent;
                            long mappedSpace = (long) pageId * Page.pageSize * 8 * dbAllocationQuantum;
                            if (mappedSpace >= newFileSize)
                            {
                                SupportClass.ArraySupport.Fill(page, 0);
                            }
                            else if (mappedSpace + Page.pageSize * 8 * dbAllocationQuantum <= newFileSize)
                            {
                                SupportClass.ArraySupport.Fill(page, 0xff);
                            }
                            else
                            {
                                int nBits = (int) ((newFileSize - mappedSpace) >> dbAllocationQuantumBits);
                                SupportClass.ArraySupport.Fill(page, 0, nBits >> 3, 0xff);
                                page[nBits >> 3] = (byte) ((1 << (nBits & 7)) - 1);
                                SupportClass.ArraySupport.Fill(page, (nBits >> 3) + 1, Page.pageSize, 0);
                            };
                            streamOut.Write(page, 0, page.Length);
                        }
                        else
                        {
                            Page pg = pool.GetPage(pos & ~ dbFlagsMask);
                            streamOut.Write(pg.data, 0, pg.data.Length);
                            pool.Unfix(pg);
                        }
                    }
                }

                for (i = 0; i < nObjects; i++)
                {
                    long pos = index[i];
                    if (pos != 0 && ((int) pos & (dbFreeHandleFlag | dbPageObjectFlag)) == 0)
                    {
                        pos &= ~ dbFlagsMask;
                        int offs = (int) pos & (Page.pageSize - 1);
                        Page pg = pool.GetPage(pos - offs);
                        int size = ObjectHeader.GetSize(pg.data, offs);
                        size = (size + dbAllocationQuantum - 1) & ~ (dbAllocationQuantum - 1);

                        while (true)
                        {
                            if (Page.pageSize - offs >= size)
                            {
                                streamOut.Write(pg.data, offs, size);
                                break;
                            }
                            streamOut.Write(pg.data, offs, Page.pageSize - offs);
                            size -= (Page.pageSize - offs);
                            pos += Page.pageSize - offs;
                            offs = 0;
                            pool.Unfix(pg);
                            pg = pool.GetPage(pos);
                        }
                        pool.Unfix(pg);
                    }
                }

                if (recOffs != newFileSize)
                {
                    Assert.That(newFileSize - recOffs < Page.pageSize);
                    int align = (int) (newFileSize - recOffs);
                    SupportClass.ArraySupport.Fill(page, 0, align, (byte) 0);
                    streamOut.Write(page, 0, align);
                }
            }
        }
Exemple #2
0
        public virtual void Open(IFile file, int pagePoolSize)
        {
            lock (this)
            {
                if (opened)
                {
                    throw new StorageError(StorageError.STORAGE_ALREADY_OPENED);
                }
                if (lockFile)
                {
                    if (!file.Lock())
                    {
                        throw new StorageError(StorageError.STORAGE_IS_USED);
                    }
                }
                Page pg;
                int i;
                int indexSize = initIndexSize;
                if (indexSize < dbFirstUserId)
                {
                    indexSize = dbFirstUserId;
                }
                indexSize = (indexSize + dbHandlesPerPage - 1) & ~ (dbHandlesPerPage - 1);

                dirtyPagesMap = new int[dbDirtyPageBitmapSize / 4 + 1];
                gcThreshold = Int64.MaxValue;
                backgroundGcMonitor = new object();
                backgroundGcStartMonitor = new object();
                gcThread = null;
                gcActive = false;
                gcDone = false;
                allocatedDelta = 0;

                nNestedTransactions = 0;
                nBlockedTransactions = 0;
                nCommittedTransactions = 0;
                scheduledCommitTime = Int64.MaxValue;
                transactionMonitor = new object();
                transactionLock = new PersistentResource();

                modified = false;

                objectCache = CreateObjectCache(cacheKind, pagePoolSize, objectCacheInitSize);

                //UPGRADE_TODO: Class 'java.util.HashMap' was converted to 'System.Collections.Hashtable' which has a different behavior.
                classDescMap = new Hashtable();
                descList = null;

                header = new Header();
                byte[] buf = new byte[Header.Sizeof];
                int rc = file.Read(0, buf);
                if (rc > 0 && rc < Header.Sizeof)
                {
                    throw new StorageError(StorageError.DATABASE_CORRUPTED);
                }

                header.Unpack(buf);
                if (header.curr < 0 || header.curr > 1)
                {
                    throw new StorageError(StorageError.DATABASE_CORRUPTED);
                }

                if (pool == null)
                {
                    pool = new PagePool(pagePoolSize / Page.pageSize);
                    pool.Open(file);
                }

                if (!header.initialized)
                {
                    header.curr = currIndex = 0;
                    long used = Page.pageSize;
                    header.root[0].index = used;
                    header.root[0].indexSize = indexSize;
                    header.root[0].indexUsed = dbFirstUserId;
                    header.root[0].freeList = 0;
                    used += indexSize * 8L;
                    header.root[1].index = used;
                    header.root[1].indexSize = indexSize;
                    header.root[1].indexUsed = dbFirstUserId;
                    header.root[1].freeList = 0;
                    used += indexSize * 8L;

                    header.root[0].shadowIndex = header.root[1].index;
                    header.root[1].shadowIndex = header.root[0].index;
                    header.root[0].shadowIndexSize = indexSize;
                    header.root[1].shadowIndexSize = indexSize;

                    int bitmapPages = (int) ((used + Page.pageSize * (dbAllocationQuantum * 8 - 1) - 1) / (Page.pageSize * (dbAllocationQuantum * 8 - 1)));
                    long bitmapSize = (long) bitmapPages * Page.pageSize;
                    int usedBitmapSize = (int) (SupportClass.URShift((used + bitmapSize), (dbAllocationQuantumBits + 3)));

                    for (i = 0; i < bitmapPages; i++)
                    {
                        pg = pool.PutPage(used + (long) i * Page.pageSize);
                        byte[] bitmap = pg.data;
                        int n = usedBitmapSize > Page.pageSize ? Page.pageSize : usedBitmapSize;
                        for (int j = 0; j < n; j++)
                        {
                            bitmap[j] = (byte) 0xFF;
                        }
                        usedBitmapSize -= Page.pageSize;
                        pool.Unfix(pg);
                    }

                    int bitmapIndexSize = ((dbBitmapId + dbBitmapPages) * 8 + Page.pageSize - 1) & ~ (Page.pageSize - 1);
                    byte[] index = new byte[bitmapIndexSize];
                    Bytes.Pack8(index, dbInvalidId * 8, dbFreeHandleFlag);
                    for (i = 0; i < bitmapPages; i++)
                    {
                        Bytes.Pack8(index, (dbBitmapId + i) * 8, used | dbPageObjectFlag);
                        used += Page.pageSize;
                    }
                    header.root[0].bitmapEnd = dbBitmapId + i;
                    header.root[1].bitmapEnd = dbBitmapId + i;
                    while (i < dbBitmapPages)
                    {
                        Bytes.Pack8(index, (dbBitmapId + i) * 8, dbFreeHandleFlag);
                        i += 1;
                    }

                    header.root[0].size = used;
                    header.root[1].size = used;
                    usedSize = used;
                    committedIndexSize = currIndexSize = dbFirstUserId;

                    pool.Write(header.root[1].index, index);
                    pool.Write(header.root[0].index, index);

                    header.dirty = true;
                    header.root[0].size = header.root[1].size;
                    pg = pool.PutPage(0);
                    header.Pack(pg.data);
                    pool.Flush();
                    pool.Modify(pg);
                    header.initialized = true;
                    header.Pack(pg.data);
                    pool.Unfix(pg);
                    pool.Flush();
                }
                else
                {
                    int curr = header.curr;
                    currIndex = curr;
                    if (header.root[curr].indexSize != header.root[curr].shadowIndexSize)
                    {
                        throw new StorageError(StorageError.DATABASE_CORRUPTED);
                    }

                    if (IsDirty())
                    {
                        if (listener != null)
                        {
                            listener.DatabaseCorrupted();
                        }

                        Console.Error.WriteLine("Database was not normally closed: start recovery");
                        header.root[1 - curr].size = header.root[curr].size;
                        header.root[1 - curr].indexUsed = header.root[curr].indexUsed;
                        header.root[1 - curr].freeList = header.root[curr].freeList;
                        header.root[1 - curr].index = header.root[curr].shadowIndex;
                        header.root[1 - curr].indexSize = header.root[curr].shadowIndexSize;
                        header.root[1 - curr].shadowIndex = header.root[curr].index;
                        header.root[1 - curr].shadowIndexSize = header.root[curr].indexSize;
                        header.root[1 - curr].bitmapEnd = header.root[curr].bitmapEnd;
                        header.root[1 - curr].rootObject = header.root[curr].rootObject;
                        header.root[1 - curr].classDescList = header.root[curr].classDescList;
                        header.root[1 - curr].bitmapExtent = header.root[curr].bitmapExtent;

                        pg = pool.PutPage(0);
                        header.Pack(pg.data);
                        pool.Unfix(pg);

                        pool.Copy(header.root[1 - curr].index, header.root[curr].index, (header.root[curr].indexUsed * 8L + Page.pageSize - 1) & ~(Page.pageSize - 1));
                        if (listener != null)
                        {
                            listener.RecoveryCompleted();
                        }
                        Console.Error.WriteLine("Recovery completed");
                    }
                    currIndexSize = header.root[1 - curr].indexUsed;
                    committedIndexSize = currIndexSize;
                    usedSize = header.root[curr].size;
                }
                int bitmapSize2 = header.root[1 - currIndex].bitmapExtent == 0 ? dbBitmapPages : dbLargeBitmapPages;
                bitmapPageAvailableSpace = new int[bitmapSize2];
                for (i = 0; i < bitmapPageAvailableSpace.Length; i++)
                {
                    bitmapPageAvailableSpace[i] = Int32.MaxValue;
                }

                currRBitmapPage = currPBitmapPage = 0;
                currRBitmapOffs = currPBitmapOffs = 0;

                opened = true;
                ReloadScheme();
            }
        }