[mirror_ubuntu-zesty-kernel.git] / fs / udf / partition.c

/*
 * partition.c
 *
 * PURPOSE
 *      Partition handling routines for the OSTA-UDF(tm) filesystem.
 *
 * COPYRIGHT
 *      This file is distributed under the terms of the GNU General Public
 *      License (GPL). Copies of the GPL can be obtained from:
 *              ftp://prep.ai.mit.edu/pub/gnu/GPL
 *      Each contributing author retains all rights to their own work.
 *
 *  (C) 1998-2001 Ben Fennema
 *
 * HISTORY
 *
 * 12/06/98 blf  Created file.
 *
 */

#include "udfdecl.h"
#include "udf_sb.h"
#include "udf_i.h"

#include <linux/fs.h>
#include <linux/string.h>
#include <linux/udf_fs.h>
#include <linux/slab.h>
#include <linux/buffer_head.h>

inline uint32_t udf_get_pblock(struct super_block *sb, uint32_t block,
			       uint16_t partition, uint32_t offset)
{
	if (partition >= UDF_SB_NUMPARTS(sb)) {
		udf_debug("block=%d, partition=%d, offset=%d: invalid partition\n",
			  block, partition, offset);
		return 0xFFFFFFFF;
	}
	if (UDF_SB_PARTFUNC(sb, partition))
		return UDF_SB_PARTFUNC(sb, partition)(sb, block, partition, offset);
	else
		return UDF_SB_PARTROOT(sb, partition) + block + offset;
}

uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
			       uint16_t partition, uint32_t offset)
{
	struct buffer_head *bh = NULL;
	uint32_t newblock;
	uint32_t index;
	uint32_t loc;

	index = (sb->s_blocksize - UDF_SB_TYPEVIRT(sb,partition).s_start_offset) / sizeof(uint32_t);

	if (block > UDF_SB_TYPEVIRT(sb,partition).s_num_entries) {
		udf_debug("Trying to access block beyond end of VAT (%d max %d)\n",
			  block, UDF_SB_TYPEVIRT(sb,partition).s_num_entries);
		return 0xFFFFFFFF;
	}

	if (block >= index) {
		block -= index;
		newblock = 1 + (block / (sb->s_blocksize / sizeof(uint32_t)));
		index = block % (sb->s_blocksize / sizeof(uint32_t));
	} else {
		newblock = 0;
		index = UDF_SB_TYPEVIRT(sb,partition).s_start_offset / sizeof(uint32_t) + block;
	}

	loc = udf_block_map(UDF_SB_VAT(sb), newblock);

	if (!(bh = sb_bread(sb, loc))) {
		udf_debug("get_pblock(UDF_VIRTUAL_MAP:%p,%d,%d) VAT: %d[%d]\n",
			  sb, block, partition, loc, index);
		return 0xFFFFFFFF;
	}

	loc = le32_to_cpu(((__le32 *)bh->b_data)[index]);

	brelse(bh);

	if (UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum == partition) {
		udf_debug("recursive call to udf_get_pblock!\n");
		return 0xFFFFFFFF;
	}

	return udf_get_pblock(sb, loc,
			      UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum,
			      offset);
}

inline uint32_t udf_get_pblock_virt20(struct super_block * sb, uint32_t block,
				      uint16_t partition, uint32_t offset)
{
	return udf_get_pblock_virt15(sb, block, partition, offset);
}

uint32_t udf_get_pblock_spar15(struct super_block * sb, uint32_t block,
			       uint16_t partition, uint32_t offset)
{
	int i;
	struct sparingTable *st = NULL;
	uint32_t packet = (block + offset) & ~(UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1);

	for (i = 0; i < 4; i++) {
		if (UDF_SB_TYPESPAR(sb,partition).s_spar_map[i] != NULL) {
			st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,partition).s_spar_map[i]->b_data;
			break;
		}
	}

	if (st) {
		for (i = 0; i < le16_to_cpu(st->reallocationTableLen); i++) {
			if (le32_to_cpu(st->mapEntry[i].origLocation) >= 0xFFFFFFF0) {
				break;
			} else if (le32_to_cpu(st->mapEntry[i].origLocation) == packet) {
				return le32_to_cpu(st->mapEntry[i].mappedLocation) +
					((block + offset) & (UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1));
			} else if (le32_to_cpu(st->mapEntry[i].origLocation) > packet) {
				break;
			}
		}
	}

	return UDF_SB_PARTROOT(sb,partition) + block + offset;
}

int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
{
	struct udf_sparing_data *sdata;
	struct sparingTable *st = NULL;
	struct sparingEntry mapEntry;
	uint32_t packet;
	int i, j, k, l;

	for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
		if (old_block > UDF_SB_PARTROOT(sb,i) &&
		    old_block < UDF_SB_PARTROOT(sb,i) + UDF_SB_PARTLEN(sb,i)) {
			sdata = &UDF_SB_TYPESPAR(sb,i);
			packet = (old_block - UDF_SB_PARTROOT(sb,i)) & ~(sdata->s_packet_len - 1);

			for (j = 0; j < 4; j++) {
				if (UDF_SB_TYPESPAR(sb,i).s_spar_map[j] != NULL) {
					st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
					break;
				}
			}

			if (!st)
				return 1;

			for (k = 0; k < le16_to_cpu(st->reallocationTableLen); k++) {
				if (le32_to_cpu(st->mapEntry[k].origLocation) == 0xFFFFFFFF) {
					for (; j < 4; j++) {
						if (sdata->s_spar_map[j]) {
							st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
							st->mapEntry[k].origLocation = cpu_to_le32(packet);
							udf_update_tag((char *)st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) * sizeof(struct sparingEntry));
							mark_buffer_dirty(sdata->s_spar_map[j]);
						}
					}
					*new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
						((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
					return 0;
				} else if (le32_to_cpu(st->mapEntry[k].origLocation) == packet) {
					*new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
						((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
					return 0;
				} else if (le32_to_cpu(st->mapEntry[k].origLocation) > packet) {
					break;
				}
			}

			for (l = k; l < le16_to_cpu(st->reallocationTableLen); l++) {
				if (le32_to_cpu(st->mapEntry[l].origLocation) == 0xFFFFFFFF) {
					for (; j < 4; j++) {
						if (sdata->s_spar_map[j]) {
							st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
							mapEntry = st->mapEntry[l];
							mapEntry.origLocation = cpu_to_le32(packet);
							memmove(&st->mapEntry[k + 1], &st->mapEntry[k], (l - k) * sizeof(struct sparingEntry));
							st->mapEntry[k] = mapEntry;
							udf_update_tag((char *)st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) * sizeof(struct sparingEntry));
							mark_buffer_dirty(sdata->s_spar_map[j]);
						}
					}
					*new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
						((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
					return 0;
				}
			}

			return 1;
		} /* if old_block */
	}

	if (i == UDF_SB_NUMPARTS(sb)) {
		/* outside of partitions */
		/* for now, fail =) */
		return 1;
	}

	return 0;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* partition.c
	3	*
	4	* PURPOSE
	5	* Partition handling routines for the OSTA-UDF(tm) filesystem.
	6	*
1da177e4 LT	7	* COPYRIGHT
	8	* This file is distributed under the terms of the GNU General Public
	9	* License (GPL). Copies of the GPL can be obtained from:
	10	* ftp://prep.ai.mit.edu/pub/gnu/GPL
	11	* Each contributing author retains all rights to their own work.
	12	*
	13	* (C) 1998-2001 Ben Fennema
	14	*
	15	* HISTORY
	16	*
28de7948	17	* 12/06/98 blf Created file.
1da177e4 LT	18	*
	19	*/
	20
	21	#include "udfdecl.h"
	22	#include "udf_sb.h"
	23	#include "udf_i.h"
	24
	25	#include <linux/fs.h>
	26	#include <linux/string.h>
	27	#include <linux/udf_fs.h>
	28	#include <linux/slab.h>
	29	#include <linux/buffer_head.h>
	30
cb00ea35 CG	31	inline uint32_t udf_get_pblock(struct super_block *sb, uint32_t block,
cb00ea35 CG	32	uint16_t partition, uint32_t offset)
1da177e4	33	{
cb00ea35	34	if (partition >= UDF_SB_NUMPARTS(sb)) {
28de7948 CG	35	udf_debug("block=%d, partition=%d, offset=%d: invalid partition\n",
28de7948 CG	36	block, partition, offset);
1da177e4 LT	37	return 0xFFFFFFFF;
	38	}
	39	if (UDF_SB_PARTFUNC(sb, partition))
28de7948	40	return UDF_SB_PARTFUNC(sb, partition)(sb, block, partition, offset);
1da177e4 LT	41	else
	42	return UDF_SB_PARTROOT(sb, partition) + block + offset;
	43	}
	44
28de7948	45	uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
cb00ea35	46	uint16_t partition, uint32_t offset)
1da177e4 LT	47	{
	48	struct buffer_head *bh = NULL;
	49	uint32_t newblock;
	50	uint32_t index;
	51	uint32_t loc;
	52
28de7948	53	index = (sb->s_blocksize - UDF_SB_TYPEVIRT(sb,partition).s_start_offset) / sizeof(uint32_t);
1da177e4	54
28de7948 CG	55	if (block > UDF_SB_TYPEVIRT(sb,partition).s_num_entries) {
	56	udf_debug("Trying to access block beyond end of VAT (%d max %d)\n",
	57	block, UDF_SB_TYPEVIRT(sb,partition).s_num_entries);
1da177e4 LT	58	return 0xFFFFFFFF;
	59	}
	60
cb00ea35	61	if (block >= index) {
1da177e4 LT	62	block -= index;
	63	newblock = 1 + (block / (sb->s_blocksize / sizeof(uint32_t)));
	64	index = block % (sb->s_blocksize / sizeof(uint32_t));
cb00ea35	65	} else {
1da177e4	66	newblock = 0;
28de7948	67	index = UDF_SB_TYPEVIRT(sb,partition).s_start_offset / sizeof(uint32_t) + block;
1da177e4 LT	68	}
	69
	70	loc = udf_block_map(UDF_SB_VAT(sb), newblock);
	71
cb00ea35	72	if (!(bh = sb_bread(sb, loc))) {
1da177e4	73	udf_debug("get_pblock(UDF_VIRTUAL_MAP:%p,%d,%d) VAT: %d[%d]\n",
cb00ea35	74	sb, block, partition, loc, index);
1da177e4 LT	75	return 0xFFFFFFFF;
	76	}
	77
28de7948	78	loc = le32_to_cpu(((__le32 *)bh->b_data)[index]);
1da177e4	79
3bf25cb4	80	brelse(bh);
1da177e4	81
cb00ea35	82	if (UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum == partition) {
1da177e4 LT	83	udf_debug("recursive call to udf_get_pblock!\n");
	84	return 0xFFFFFFFF;
	85	}
	86
cb00ea35	87	return udf_get_pblock(sb, loc,
28de7948 CG	88	UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum,
28de7948 CG	89	offset);
1da177e4 LT	90	}
1da177e4 LT	91
cb00ea35 CG	92	inline uint32_t udf_get_pblock_virt20(struct super_block * sb, uint32_t block,
cb00ea35 CG	93	uint16_t partition, uint32_t offset)
1da177e4 LT	94	{
	95	return udf_get_pblock_virt15(sb, block, partition, offset);
	96	}
	97
cb00ea35 CG	98	uint32_t udf_get_pblock_spar15(struct super_block * sb, uint32_t block,
cb00ea35 CG	99	uint16_t partition, uint32_t offset)
1da177e4 LT	100	{
	101	int i;
	102	struct sparingTable *st = NULL;
28de7948	103	uint32_t packet = (block + offset) & ~(UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1);
1da177e4	104
cb00ea35	105	for (i = 0; i < 4; i++) {
28de7948 CG	106	if (UDF_SB_TYPESPAR(sb,partition).s_spar_map[i] != NULL) {
28de7948 CG	107	st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,partition).s_spar_map[i]->b_data;
1da177e4 LT	108	break;
	109	}
	110	}
	111
cb00ea35 CG	112	if (st) {
cb00ea35 CG	113	for (i = 0; i < le16_to_cpu(st->reallocationTableLen); i++) {
28de7948	114	if (le32_to_cpu(st->mapEntry[i].origLocation) >= 0xFFFFFFF0) {
1da177e4	115	break;
28de7948 CG	116	} else if (le32_to_cpu(st->mapEntry[i].origLocation) == packet) {
	117	return le32_to_cpu(st->mapEntry[i].mappedLocation) +
	118	((block + offset) & (UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1));
	119	} else if (le32_to_cpu(st->mapEntry[i].origLocation) > packet) {
1da177e4	120	break;
28de7948	121	}
1da177e4 LT	122	}
1da177e4 LT	123	}
28de7948 CG	124
28de7948 CG	125	return UDF_SB_PARTROOT(sb,partition) + block + offset;
1da177e4 LT	126	}
	127
	128	int udf_relocate_blocks(struct super_block sb, long old_block, long new_block)
	129	{
	130	struct udf_sparing_data *sdata;
	131	struct sparingTable *st = NULL;
	132	struct sparingEntry mapEntry;
	133	uint32_t packet;
	134	int i, j, k, l;
	135
cb00ea35	136	for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
28de7948 CG	137	if (old_block > UDF_SB_PARTROOT(sb,i) &&
	138	old_block < UDF_SB_PARTROOT(sb,i) + UDF_SB_PARTLEN(sb,i)) {
	139	sdata = &UDF_SB_TYPESPAR(sb,i);
	140	packet = (old_block - UDF_SB_PARTROOT(sb,i)) & ~(sdata->s_packet_len - 1);
cb00ea35 CG	141
cb00ea35 CG	142	for (j = 0; j < 4; j++) {
28de7948 CG	143	if (UDF_SB_TYPESPAR(sb,i).s_spar_map[j] != NULL) {
28de7948 CG	144	st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
1da177e4 LT	145	break;
	146	}
	147	}
	148
	149	if (!st)
	150	return 1;
	151
28de7948 CG	152	for (k = 0; k < le16_to_cpu(st->reallocationTableLen); k++) {
28de7948 CG	153	if (le32_to_cpu(st->mapEntry[k].origLocation) == 0xFFFFFFFF) {
cb00ea35 CG	154	for (; j < 4; j++) {
cb00ea35 CG	155	if (sdata->s_spar_map[j]) {
28de7948 CG	156	st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
	157	st->mapEntry[k].origLocation = cpu_to_le32(packet);
	158	udf_update_tag((char )st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) sizeof(struct sparingEntry));
	159	mark_buffer_dirty(sdata->s_spar_map[j]);
1da177e4 LT	160	}
1da177e4 LT	161	}
28de7948 CG	162	*new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
28de7948 CG	163	((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
1da177e4	164	return 0;
28de7948 CG	165	} else if (le32_to_cpu(st->mapEntry[k].origLocation) == packet) {
	166	*new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
	167	((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
1da177e4	168	return 0;
28de7948	169	} else if (le32_to_cpu(st->mapEntry[k].origLocation) > packet) {
1da177e4	170	break;
28de7948	171	}
1da177e4	172	}
28de7948 CG	173
	174	for (l = k; l < le16_to_cpu(st->reallocationTableLen); l++) {
	175	if (le32_to_cpu(st->mapEntry[l].origLocation) == 0xFFFFFFFF) {
cb00ea35 CG	176	for (; j < 4; j++) {
cb00ea35 CG	177	if (sdata->s_spar_map[j]) {
28de7948 CG	178	st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
	179	mapEntry = st->mapEntry[l];
	180	mapEntry.origLocation = cpu_to_le32(packet);
	181	memmove(&st->mapEntry[k + 1], &st->mapEntry[k], (l - k) * sizeof(struct sparingEntry));
	182	st->mapEntry[k] = mapEntry;
	183	udf_update_tag((char )st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) sizeof(struct sparingEntry));
	184	mark_buffer_dirty(sdata->s_spar_map[j]);
1da177e4 LT	185	}
1da177e4 LT	186	}
28de7948 CG	187	*new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
28de7948 CG	188	((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
1da177e4 LT	189	return 0;
	190	}
	191	}
28de7948	192
1da177e4	193	return 1;
28de7948	194	} /* if old_block */
1da177e4	195	}
28de7948	196
cb00ea35	197	if (i == UDF_SB_NUMPARTS(sb)) {
1da177e4 LT	198	/* outside of partitions */
	199	/* for now, fail =) */
	200	return 1;
	201	}
	202
	203	return 0;
	204	}