/** * device.c - Low level device io functions. Originated from the Linux-NTFS project. * * Copyright (c) 2004-2006 Anton Altaparmakov * Copyright (c) 2004-2006 Szabolcs Szakacsits * * This program/include file 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. * * This program/include file 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 this program (in the main directory of the NTFS-3G * distribution in the file COPYING); if not, write to the Free Software * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */#ifdef HAVE_CONFIG_H#include "config.h"#endif#ifdef HAVE_UNISTD_H#include <unistd.h>#endif#ifdef HAVE_STDLIB_H#include <stdlib.h>#endif#ifdef HAVE_STRING_H#include <string.h>#endif#ifdef HAVE_ERRNO_H#include <errno.h>#endif#ifdef HAVE_STDIO_H#include <stdio.h>#endif#ifdef HAVE_SYS_TYPES_H#include <sys/types.h>#endif#ifdef HAVE_SYS_STAT_H#include <sys/stat.h>#endif#ifdef HAVE_FCNTL_H#include <fcntl.h>#endif#ifdef HAVE_SYS_IOCTL_H#include <sys/ioctl.h>#endif#ifdef HAVE_SYS_PARAM_H#include <sys/param.h>#endif#ifdef HAVE_SYS_MOUNT_H#include <sys/mount.h>#endif#ifdef HAVE_LINUX_FD_H#include <linux/fd.h>#endif#ifdef HAVE_LINUX_HDREG_H#include <linux/hdreg.h>#endif#include "types.h"#include "mst.h"#include "debug.h"#include "device.h"#include "logging.h"#include "misc.h"#if defined(linux) && defined(_IO) && !defined(BLKGETSIZE)#define BLKGETSIZE	_IO(0x12,96)  /* Get device size in 512-byte blocks. */#endif#if defined(linux) && defined(_IOR) && !defined(BLKGETSIZE64)#define BLKGETSIZE64	_IOR(0x12,114,size_t)	/* Get device size in bytes. */#endif#if defined(linux) && !defined(HDIO_GETGEO)#define HDIO_GETGEO	0x0301	/* Get device geometry. */#endif#if defined(linux) && defined(_IO) && !defined(BLKSSZGET)#	define BLKSSZGET _IO(0x12,104) /* Get device sector size in bytes. */#endif#if defined(linux) && defined(_IO) && !defined(BLKBSZSET)#	define BLKBSZSET _IOW(0x12,113,size_t) /* Set device block size in bytes. */#endif/** * ntfs_device_alloc - allocate an ntfs device structure and pre-initialize it * @name:	name of the device (must be present) * @state:	initial device state (usually zero) * @dops:	ntfs device operations to use with the device (must be present) * @priv_data:	pointer to private data (optional) * * Allocate an ntfs device structure and pre-initialize it with the user- * specified device operations @dops, device state @state, device name @name, * and optional private data @priv_data. * * Note, @name is copied and can hence be freed after this functions returns. * * On success return a pointer to the allocated ntfs device structure and on * error return NULL with errno set to the error code returned by ntfs_malloc(). */struct ntfs_device *ntfs_device_alloc(const char *name, const long state,		struct ntfs_device_operations *dops, void *priv_data){	struct ntfs_device *dev;	if (!name) {		errno = EINVAL;		return NULL;	}	dev = ntfs_malloc(sizeof(struct ntfs_device));	if (dev) {		if (!(dev->d_name = strdup(name))) {			int eo = errno;			free(dev);			errno = eo;			return NULL;		}		dev->d_ops = dops;		dev->d_state = state;		dev->d_private = priv_data;	}	return dev;}/** * ntfs_device_free - free an ntfs device structure * @dev:	ntfs device structure to free * * Free the ntfs device structure @dev. * * Return 0 on success or -1 on error with errno set to the error code. The * following error codes are defined: *	EINVAL		Invalid pointer @dev. *	EBUSY		Device is still open. Close it before freeing it! */int ntfs_device_free(struct ntfs_device *dev){	if (!dev) {		errno = EINVAL;		return -1;	}	if (NDevOpen(dev)) {		errno = EBUSY;		return -1;	}	free(dev->d_name);	free(dev);	return 0;}/** * ntfs_pread - positioned read from disk * @dev:	device to read from * @pos:	position in device to read from * @count:	number of bytes to read * @b:		output data buffer * * This function will read @count bytes from device @dev at position @pos into * the data buffer @b. * * On success, return the number of successfully read bytes. If this number is * lower than @count this means that we have either reached end of file or * encountered an error during the read so that the read is partial. 0 means * end of file or nothing to read (@count is 0). * * On error and nothing has been read, return -1 with errno set appropriately * to the return code of either seek, read, or set to EINVAL in case of * invalid arguments. */s64 ntfs_pread(struct ntfs_device *dev, const s64 pos, s64 count, void *b){	s64 br, total;	struct ntfs_device_operations *dops;	ntfs_log_trace("Entering for pos 0x%llx, count 0x%llx.\n", pos, count);		if (!b || count < 0 || pos < 0) {		errno = EINVAL;		return -1;	}	if (!count)		return 0;		dops = dev->d_ops;	for (total = 0; count; count -= br, total += br) {		br = dops->pread(dev, (char*)b + total, count, pos + total);		/* If everything ok, continue. */		if (br > 0)			continue;		/* If EOF or error return number of bytes read. */		if (!br || total)			return total;		/* Nothing read and error, return error status. */		return br;	}	/* Finally, return the number of bytes read. */	return total;}/** * ntfs_pwrite - positioned write to disk * @dev:	device to write to * @pos:	position in file descriptor to write to * @count:	number of bytes to write * @b:		data buffer to write to disk * * This function will write @count bytes from data buffer @b to the device @dev * at position @pos. * * On success, return the number of successfully written bytes. If this number * is lower than @count this means that the write has been interrupted in * flight or that an error was encountered during the write so that the write * is partial. 0 means nothing was written (also return 0 when @count is 0). * * On error and nothing has been written, return -1 with errno set * appropriately to the return code of either seek, write, or set * to EINVAL in case of invalid arguments. */s64 ntfs_pwrite(struct ntfs_device *dev, const s64 pos, s64 count,		const void *b){	s64 written, total, ret = -1;	struct ntfs_device_operations *dops;	ntfs_log_trace("Entering for pos 0x%llx, count 0x%llx.\n", pos, count);	if (!b || count < 0 || pos < 0) {		errno = EINVAL;		goto out;	}	if (!count)		return 0;	if (NDevReadOnly(dev)) {		errno = EROFS;		goto out;	}		dops = dev->d_ops;	NDevSetDirty(dev);	for (total = 0; count; count -= written, total += written) {		written = dops->pwrite(dev, (const char*)b + total, count,				       pos + total);		/* If everything ok, continue. */		if (written > 0)			continue;		/*		 * If nothing written or error return number of bytes written.		 */		if (!written || total)			break;		/* Nothing written and error, return error status. */		total = written;		break;	}	ret = total;out:		return ret;}/** * ntfs_mst_pread - multi sector transfer (mst) positioned read * @dev:	device to read from * @pos:	position in file descriptor to read from * @count:	number of blocks to read * @bksize:	size of each block that needs mst deprotecting * @b:		output data buffer * * Multi sector transfer (mst) positioned read. This function will read @count * blocks of size @bksize bytes each from device @dev at position @pos into the * the data buffer @b. * * On success, return the number of successfully read blocks. If this number is * lower than @count this means that we have reached end of file, that the read * was interrupted, or that an error was encountered during the read so that * the read is partial. 0 means end of file or nothing was read (also return 0 * when @count or @bksize are 0). * * On error and nothing was read, return -1 with errno set appropriately to the * return code of either seek, read, or set to EINVAL in case of invalid * arguments. * * NOTE: If an incomplete multi sector transfer has been detected the magic * will have been changed to magic_BAAD but no error will be returned. Thus it * is possible that we return count blocks as being read but that any number * (between zero and count!) of these blocks is actually subject to a multi * sector transfer error. This should be detected by the caller by checking for * the magic being "BAAD". */s64 ntfs_mst_pread(struct ntfs_device *dev, const s64 pos, s64 count,		const u32 bksize, void *b){	s64 br, i;	if (bksize & (bksize - 1) || bksize % NTFS_BLOCK_SIZE) {		errno = EINVAL;		return -1;	}	/* Do the read. */	br = ntfs_pread(dev, pos, count * bksize, b);	if (br < 0)		return br;	/*	 * Apply fixups to successfully read data, disregarding any errors	 * returned from the MST fixup function. This is because we want to	 * fixup everything possible and we rely on the fact that the "BAAD"	 * magic will be detected later on.	 */	count = br / bksize;	for (i = 0; i < count; ++i)		ntfs_mst_post_read_fixup((NTFS_RECORD*)				((u8*)b + i * bksize), bksize);	/* Finally, return the number of complete blocks read. */	return count;}/** * ntfs_mst_pwrite - multi sector transfer (mst) positioned write * @dev:	device to write to * @pos:	position in file descriptor to write to * @count:	number of blocks to write * @bksize:	size of each block that needs mst protecting * @b:		data buffer to write to disk * * Multi sector transfer (mst) positioned write. This function will write * @count blocks of size @bksize bytes each from data buffer @b to the device * @dev at position @pos. * * On success, return the number of successfully written blocks. If this number * is lower than @count this means that the write has been interrupted or that * an error was encountered during the write so that the write is partial. 0 * means nothing was written (also return 0 when @count or @bksize are 0). * * On error and nothing has been written, return -1 with errno set * appropriately to the return code of either seek, write, or set * to EINVAL in case of invalid arguments. * * NOTE: We mst protect the data, write it, then mst deprotect it using a quick * deprotect algorithm (no checking). This saves us from making a copy before * the write and at the same time causes the usn to be incremented in the * buffer. This conceptually fits in better with the idea that cached data is * always deprotected and protection is performed when the data is actually * going to hit the disk and the cache is immediately deprotected again * simulating an mst read on the written data. This way cache coherency is * achieved. */s64 ntfs_mst_pwrite(struct ntfs_device *dev, const s64 pos, s64 count,		const u32 bksize, void *b){	s64 written, i;	if (count < 0 || bksize % NTFS_BLOCK_SIZE) {		errno = EINVAL;		return -1;	}	if (!count)		return 0;	/* Prepare data for writing. */	for (i = 0; i < count; ++i) {