windows-server-2003/base/cluster/resdll/ndquorum/undo.c

/*++

Copyright (c) 2000  Microsoft Corporation

Module Name:

    undo.c

Abstract:

    Implements undo of records during replica recovery

Author:

    Ahmed Mohamed (ahmedm) 1-Feb-2000

Revision History:

--*/
#include <nt.h>
#include <ntdef.h>
#include <ntrtl.h>
#include <nturtl.h>


#include <windows.h>
#include <stdio.h>
#include <ntddvol.h>
#include <string.h>
#include <assert.h>

#include "fs.h"
#include "fsp.h"
#include "fsutil.h"

NTSTATUS
fs_undo_create(VolInfo_t *volinfo,
                 fs_log_rec_t *lrec, int nid, int mid)
{
    NTSTATUS err;
    // find the objectid 
    HANDLE vfd = FS_GET_VOL_HANDLE(volinfo, nid);
    WCHAR name[MAXPATH];
    int name_len = sizeof(name);

    name[0] = '\0';

    // note: use id instead of fs_id since we don't have fs_id till
    // a prepare has committed.
    FsLogUndo(("fs_undo_create: try %I64x:%I64x\n",
                  lrec->id[0], lrec->id[1]));

    err = xFsGetPathById(vfd, &lrec->id, name, &name_len);

    if (err == STATUS_SUCCESS) {
        int relative_name_len;
        LPWSTR relative_name;

        relative_name = xFsBuildRelativePath(volinfo, nid, name);
        relative_name_len = wcslen(relative_name);

        err = xFsDelete(vfd, relative_name, relative_name_len);
    } else if (err == STATUS_OBJECT_PATH_NOT_FOUND) {
        // if we can't find file in the master disk, the file/dir
        // must have already been delete. Just return success, since
        // we are trying to remove this file anyway.
        err = STATUS_SUCCESS;
    }


    FsLogUndo(("fs_undo_create: status %x\n", err));

    return err;
}


NTSTATUS
fs_undo_setattr(VolInfo_t *volinfo,
                fs_log_rec_t *lrec, int nid, int mid)
{
    NTSTATUS err;
    // find the objectid 
    HANDLE vfd = FS_GET_VOL_HANDLE(volinfo, nid);
    HANDLE mvfd = FS_GET_VOL_HANDLE(volinfo, mid);
    WCHAR       name[MAXPATH];
    int         name_len=sizeof(name);
    

    name[0] = '\0';

    FsLogUndo(("fs_undo_setattr: try %I64x:%I64x\n",
                  lrec->fs_id[0], lrec->fs_id[1]));

    err = xFsGetPathById(mvfd, &lrec->fs_id, name, &name_len);

    if (err == STATUS_SUCCESS) {
        int relative_name_len;
        LPWSTR relative_name;
        HANDLE fd;
        FILE_NETWORK_OPEN_INFORMATION attr;
        FILE_BASIC_INFORMATION new_attr;

        // build relative name and get current attribute from
        // master disk and apply it to 'nid' disk
        relative_name = xFsBuildRelativePath(volinfo, mid, name);
        relative_name_len = wcslen(relative_name);

        err = xFsQueryAttrName(mvfd, relative_name, relative_name_len,
                               &attr);

        if (err == STATUS_SUCCESS) {
            // we now apply attribute to nid disk
            err = xFsOpenWA(&fd, vfd, relative_name, relative_name_len);
            if (err == STATUS_SUCCESS) {

                new_attr.CreationTime = attr.CreationTime;
                new_attr.LastAccessTime = attr.LastAccessTime;
                new_attr.LastWriteTime = attr.LastWriteTime;
                new_attr.ChangeTime = attr.ChangeTime;
                new_attr.FileAttributes = attr.FileAttributes;
                err = xFsSetAttr(fd, &new_attr);
                xFsClose(fd);
            }
        }

    } else if (err == STATUS_OBJECT_PATH_NOT_FOUND) {
        // if we can't find file in the master disk, the file/dir
        // must have already been delete. Just return success, since
        // we will get to remove this dir/file anyway during the
        // replay phase
        err = STATUS_SUCCESS;
    }

    FsLogUndo(("fs_undo_setattr: status %x\n", err));

    return err;
}

NTSTATUS
fs_undo_mkdir(VolInfo_t *volinfo,
                 fs_log_rec_t *lrec, int nid, int mid)
{
    NTSTATUS err;
    // find the objectid 
    HANDLE vfd = FS_GET_VOL_HANDLE(volinfo, nid);
    WCHAR name[MAXPATH];
    int name_len=sizeof(name);

    name[0] = '\0';

    // note: use id instead of fs_id since we don't have fs_id till
    // a prepare has committed.
    FsLogUndo(("fs_undo_mkdir: try %I64x:%I64x\n",
                  lrec->id[0], lrec->id[1]));

    err = xFsGetPathById(vfd, &lrec->id, name, &name_len);

    if (err == STATUS_SUCCESS) {
        int relative_name_len;
        WCHAR *relative_name;

        relative_name = xFsBuildRelativePath(volinfo, nid, name);
        relative_name_len = wcslen(relative_name);

        err = xFsDelete(vfd, relative_name, relative_name_len);
    }

    FsLogUndo(("fs_undo_mkdir: status %x\n", err));

    return err;
}

NTSTATUS
fs_undo_remove(VolInfo_t *volinfo,
               fs_log_rec_t *lrec, int nid, int mid)

{

    // we need to recreate the file with same name and attributes.
    // if file is not a directory, we also need to copy data
    // from master disk to nid disk
    NTSTATUS err;
    // find the objectid 
    HANDLE vfd = FS_GET_VOL_HANDLE(volinfo, nid);
    HANDLE mvfd = FS_GET_VOL_HANDLE(volinfo, mid);
    WCHAR       name[MAXPATH];
    int         name_len=sizeof(name);
    

    name[0] = '\0';
    FsLogUndo(("fs_undo_remove: try %I64x:%I64x\n",
                  lrec->fs_id[0], lrec->fs_id[1]));

    err = xFsGetPathById(mvfd, &lrec->fs_id, name, &name_len);

    if (err == STATUS_SUCCESS) {
        int relative_name_len;
        WCHAR *relative_name;

        // build relative name
        relative_name = xFsBuildRelativePath(volinfo, mid, name);
        relative_name_len = wcslen(relative_name);

        // duplicate file or dir
        err = xFsDupFile(mvfd, vfd, relative_name, relative_name_len, FALSE);

    } else if (err == STATUS_OBJECT_PATH_NOT_FOUND) {
        // if we can't find file in the master disk, the file/dir
        // must have already been delete. 
        err = STATUS_SUCCESS;
    }

    FsLogUndo(("fs_undo_remove: status %x\n", err));

    return err;

}

NTSTATUS
fs_undo_rename(VolInfo_t *volinfo,
               fs_log_rec_t *lrec, int nid, int mid)

{
    // we need to recreate the file with same name and attributes.
    // if file is not a directory, we also need to copy data
    // from master disk to nid disk
    NTSTATUS err;
    // find the objectid 
    HANDLE vfd = FS_GET_VOL_HANDLE(volinfo, nid);
    HANDLE mvfd = FS_GET_VOL_HANDLE(volinfo, mid);
    WCHAR       name[MAXPATH];
    int         name_len=sizeof(name);
    

    name[0] = '\0';
    FsLogUndo(("fs_undo_rename: try %I64x:%I64x\n",
                  lrec->fs_id[0], lrec->fs_id[1]));

    err = xFsGetPathById(mvfd, &lrec->fs_id, name, &name_len);

    if (err == STATUS_SUCCESS) {
        int relative_name_len;
        WCHAR *relative_name;
        HANDLE fd;

        // build relative name and get current attribute from
        // master disk
        relative_name = xFsBuildRelativePath(volinfo, mid, name);
        relative_name_len = wcslen(relative_name);

        // we open the file on the nid disk
        err = xFsGetHandleById(vfd, &lrec->fs_id, FILE_GENERIC_WRITE, &fd);
        if (err == STATUS_SUCCESS) {
            err = xFsRename(fd, vfd, relative_name, relative_name_len);
            xFsClose(fd);
        }

    } else if (err == STATUS_OBJECT_PATH_NOT_FOUND) {
        // if we can't find file in the master disk, the file/dir
        // must have already been delete. 
        err = STATUS_SUCCESS;
    }

    FsLogUndo(("fs_undo_rename: status %x\n", err));

    return err;

}

NTSTATUS
fs_undo_write(VolInfo_t *volinfo, fs_log_rec_t *lrec, int nid, int mid)
{
    NTSTATUS err;
    IO_STATUS_BLOCK ios;
    HANDLE shdl = INVALID_HANDLE_VALUE;
    HANDLE dhdl = INVALID_HANDLE_VALUE;
    WCHAR *buf = NULL;
    HANDLE      vfd = FS_GET_VOL_HANDLE(volinfo, nid);
    HANDLE      mvfd = FS_GET_VOL_HANDLE(volinfo, mid);


    FsLogUndo(("fs_undo_write: %I64x:%I64x\n", lrec->fs_id[0],
                  lrec->fs_id[1]));

    // get the master file
    err = xFsGetHandleById(mvfd, &lrec->fs_id, FILE_GENERIC_READ, &shdl);

    if (err == STATUS_SUCCESS) {
        ULONG sz = 0;
        LARGE_INTEGER off;

        // get nid disk file
        err = xFsGetHandleById(vfd, &lrec->fs_id, FILE_GENERIC_WRITE, &dhdl);
        if (err != STATUS_SUCCESS) {
            // this is a very bad error, must abort now
            FsLogUndo(("Aborting replay_write err %x\n", err));
            err = STATUS_TRANSACTION_ABORTED;
            goto done;
        }


        // we need to read the new data from the sfd first
        if (lrec->length > 0) {
            // allocate buf
            buf = VirtualAlloc(NULL, lrec->length, MEM_COMMIT, PAGE_READWRITE);

            if (buf == NULL) {
                FsLogError(("Unable to allocate write buffer to replay\n"));
                err = STATUS_TRANSACTION_ABORTED;
                goto done;
            }


            off.LowPart = lrec->offset;
            off.HighPart = 0;

            // read local data. todo: what if the file is locked? 
            err = NtReadFile(shdl, NULL, NULL, NULL, &ios, buf,
                             lrec->length, &off, NULL);

            if (err == STATUS_PENDING) {
                EventWait(shdl);
            }

            if (ios.Status != STATUS_SUCCESS) {
                FsLogUndo(("Read failed for replay %x\n", ios.Status));
                err = STATUS_TRANSACTION_ABORTED;
                goto done;
            }
        } else {
            buf = NULL;
            ios.Information = 0;
        }
                        
        sz = (ULONG) ios.Information;
        off.LowPart = lrec->offset;
        off.HighPart = 0;
        if (sz > 0) {
            err = NtWriteFile(dhdl, NULL, NULL, (PVOID) NULL,
                              &ios, buf, sz, &off, NULL);
        } else {
            FILE_END_OF_FILE_INFORMATION x;

            x.EndOfFile = off;

            err = NtSetInformationFile(dhdl, &ios,
                                       (char *) &x, sizeof(x),
                                       FileEndOfFileInformation);

        }
        if (err == STATUS_PENDING) {
            EventWait(dhdl);
            err = ios.Status;
        }
        sz = (ULONG) ios.Information;

        // check if we have the same size, otherwise abort
        if (sz != lrec->length) {
            FsLogError(("Write sz mismatch, %d expected %d\n", sz, lrec->length));
            err = STATUS_TRANSACTION_ABORTED;
        }

    } else if (err == STATUS_OBJECT_PATH_NOT_FOUND) {
        // if we can't find file in the master disk, the file/dir
        // must have already been delete. 
        err = STATUS_SUCCESS;
    }

 done:
    if (buf != NULL) {
        VirtualFree(buf, 0, MEM_RELEASE);
    }

    if (shdl != INVALID_HANDLE_VALUE)
        xFsClose(shdl);

    if (dhdl != INVALID_HANDLE_VALUE)
        xFsClose(dhdl);

    FsLogUndo(("Undo write offset %d len %d err %x\n", 
                 lrec->offset, lrec->length, err));

    return err;
}

FsReplayHandler_t FsUndoCallTable[] = {
    fs_undo_create,
    fs_undo_setattr,
    fs_undo_write,
    fs_undo_mkdir,
    fs_undo_remove,
    fs_undo_rename
};

NTSTATUS
FsUndoXid(VolInfo_t *volinfo, int nid, PVOID arg, int action, int mid)
{
    fs_log_rec_t        *p = (fs_log_rec_t *) arg;
    NTSTATUS            err;
    fs_id_t             *fs_id;
    HANDLE              vhdl;

    vhdl = FS_GET_VOL_HANDLE(volinfo, mid);
    if (vhdl == INVALID_HANDLE_VALUE) {
        FsLogUndo(("FsUndoXid Failed to get crs handle %d\n",
                     mid));
        return STATUS_TRANSACTION_ABORTED;
    }

    vhdl = FS_GET_VOL_HANDLE(volinfo, nid);
    if (vhdl == INVALID_HANDLE_VALUE) {
        FsLogUndo(("FsUndoXid Failed to get crs handle %d\n", nid));
        return STATUS_TRANSACTION_ABORTED;
    }

    fs_id = &p->fs_id;

    FsLogUndo(("Undo action %d nid %d objid %I64x:%I64x\n", p->command,
               nid,
               (*fs_id)[0], (*fs_id)[1]));

    err = FsUndoCallTable[p->command](volinfo, p, nid, mid);

    FsLogUndo(("Undo Status %x\n", err));

    return err;
}