> cd /usr/local

> sudo tar xzf <path to VMware-vix-disklib-*version*.x86_64.tar.gz>.

/**
 * Initialize the library. Must be called at the 
 * beginning of program. Should be called only once 
 * per process. Should call Exit at the end of program
 * for clean up.
 */
func Init(majorVersion uint32, minorVersion uint32, dir string) VddkError {}

/**
 * Notify a host to refrain from relocating a virtual machine.
 * Every PrepareForAccess call should have a matching EndAccess
 * call.
 */
func PrepareForAccess(appGlobal ConnectParams) VddkError {}

/**
 * Connect the library to local/remote server. 
 * Always call Disconnect before end of 
 * program, which invalidates any open file handles.
 * VixDiskLib_PrepareForAccess should be called 
 * before each Connect.
 */
func Connect(appGlobal ConnectParams) (VixDiskLibConnection, VddkError) {} 

/**
 * Create a transport context to access disks 
 * belonging to a particular snapshot of a 
 * particular virtual machine. Using this transport 
 * context enables callers to open virtual disks 
 * using the most efficient data access protocol 
 * available for managed virtual machines, for 
 * improved I/O performance. If you use this call 
 * instead of Connect(), additional input parameters
 * transportmode and snapshotref should be given.
 */
func ConnectEx(appGlobal ConnectParams) (VixDiskLibConnection, VddkError) {}

/**
 * Locally creates a new virtual disk, after being 
 * connected to the host. In createParams, you must 
 * specify the disk type, adapter, hardware version, 
 * and capacity as a number of sectors. This 
 * function supports hosted disk. For managed disk, 
 * first create a hosted type virtual disk, then use 
 * Clone() to convert the virtual disk to managed 
 * disk.
 */
func Create(connection VixDiskLibConnection, path string, createParams VixDiskLibCreateParams, progressCallbackData string) VddkError {}

/**
 * Opens a virtual disk.
 */
func Open(conn VixDiskLibConnection, params ConnectParams) (VixDiskLibHandle, VddkError) {}

/**
 * This function reads a range of sectors from an open virtual disk.
 */
func Read(diskHandle VixDiskLibHandle, startSector uint64, numSectors uint64, buf []byte) VddkError {}

/**
 * This function writes to an open virtual disk.
 */
func Write(diskHandle VixDiskLibHandle, startSector uint64, numSectors uint64, buf []byte) VddkError {}

/**
 * Read Metadata key from disk.
 */
func ReadMetadata(diskHandle VixDiskLibHandle, key string, buf []byte, bufLen uint, requiredLen uint) VddkError {}

/**
 * Get metadata table from disk.
 */
func GetMetadataKeys(diskHandle VixDiskLibHandle, buf []byte, bufLen uint, requireLen uint) VddkError {}

/**
 * Write metadata table to disk.
 */
func WriteMetadata(diskHandle VixDiskLibHandle, key string, val string) VddkError {}

/**
 * Determine allocated blocks.
 */
func QueryAllocatedBlocks(diskHandle VixDiskLibHandle, startSector VixDiskLibSectorType, numSectors VixDiskLibSectorType, chunkSize VixDiskLibSectorType) ([]VixDiskLibBlock, VddkError) {}

/**
 * Destroy the connection. Match to Connect.
 */
func Disconnect(connection VixDiskLibConnection) VddkError {}

/**
 * Notifies the host that a virtual machine’s disk have been closed, so operations that 
 * rely on the virtual disks to be closed, such as vMotion, can now be allowed. Internally
 * this function re-enables the vSphere API method RelocateVM_Task.
 */
func EndAccess(appGlobal ConnectParams) VddkError {}

/** 
 * Releases all resources held by VixDiskLib.
 */
func Exit() {}

/**
 * Will handle the set up operations for a disk, 
 * including prepare for access, connect, open. If 
 * failure happens in the set up stage, will roll 
 * back to initial state. Return a DiskReaderWriter 
 * which allows read or write operations to the 
 * disk.
 */
func Open(globalParams disklib.ConnectParams, logger logrus.FieldLogger) 
                  (DiskReaderWriter, disklib.VddkError) {}

/**
 * Read reads up to len(p) bytes into p. It returns 
 * the number of bytes read (0 <= n <= len(p)) and 
 * any error encountered.
 */
func (this DiskReaderWriter) Read(p []byte) (n int, err error) {}

/** 
 * Read from given offset.
 */
func (this DiskReaderWriter) ReadAt(p []byte, off int64) (n int, err error) {}

/**
 * Write writes len(p) bytes from p to the 
 * underlying data stream. It returns the number of 
 * bytes written from p (0 <= n <= len(p)).
 */
func (this DiskReaderWriter) Write(p []byte) (n int, err error) {}

/**
 * Write from given offset.
 */
func (this DiskConnectHandle) WriteAt(p []byte, off int64) (n int, err error) {}

/**
 * Determine allocated blocks.
 */
func (this DiskReaderWriter) QueryAllocatedBlocks(startSector disklib.VixDiskLibSectorType, numSectors disklib.VixDiskLibSectorType, chunkSize disklib.VixDiskLibSectorType) ([]disklib.VixDiskLibBlock, disklib.VddkError) {}

/**
 * Clear up all the resources held. Should be called in the end.
 */
func (this DiskReaderWriter) Close() error {} 

type DiskReaderWriter struct {
	readerAt io.ReaderAt
	writerAt io.WriterAt
	closer   io.Closer
	offset  *int64
	mutex    sync.Mutex                                                                
	logger   logrus.FieldLogger
}