[GitHub/mt8127/android_kernel_alcatel_ttab.git] / block / partitions / check.c

/*
 *  fs/partitions/check.c
 *
 *  Code extracted from drivers/block/genhd.c
 *  Copyright (C) 1991-1998  Linus Torvalds
 *  Re-organised Feb 1998 Russell King
 *
 *  We now have independent partition support from the
 *  block drivers, which allows all the partition code to
 *  be grouped in one location, and it to be mostly self
 *  contained.
 *
 *  Added needed MAJORS for new pairs, {hdi,hdj}, {hdk,hdl}
 */

#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/ctype.h>
#include <linux/genhd.h>

#include "check.h"

#include "acorn.h"
#include "amiga.h"
#include "atari.h"
#include "ldm.h"
#include "mac.h"
#include "msdos.h"
#include "osf.h"
#include "sgi.h"
#include "sun.h"
#include "ibm.h"
#include "ultrix.h"
#include "efi.h"
#include "karma.h"
#include "sysv68.h"

int warn_no_part = 1; /*This is ugly: should make genhd removable media aware*/

static int (*check_part[])(struct parsed_partitions *) = {
	/*
	 * Probe partition formats with tables at disk address 0
	 * that also have an ADFS boot block at 0xdc0.
	 */
#ifdef CONFIG_ACORN_PARTITION_ICS
	adfspart_check_ICS,
#endif
#ifdef CONFIG_ACORN_PARTITION_POWERTEC
	adfspart_check_POWERTEC,
#endif
#ifdef CONFIG_ACORN_PARTITION_EESOX
	adfspart_check_EESOX,
#endif

	/*
	 * Now move on to formats that only have partition info at
	 * disk address 0xdc0.  Since these may also have stale
	 * PC/BIOS partition tables, they need to come before
	 * the msdos entry.
	 */
#ifdef CONFIG_ACORN_PARTITION_CUMANA
	adfspart_check_CUMANA,
#endif
#ifdef CONFIG_ACORN_PARTITION_ADFS
	adfspart_check_ADFS,
#endif

#ifdef CONFIG_EFI_PARTITION
	efi_partition,		/* this must come before msdos */
#endif
#ifdef CONFIG_SGI_PARTITION
	sgi_partition,
#endif
#ifdef CONFIG_LDM_PARTITION
	ldm_partition,		/* this must come before msdos */
#endif
#ifdef CONFIG_MSDOS_PARTITION
	msdos_partition,
#endif
#ifdef CONFIG_OSF_PARTITION
	osf_partition,
#endif
#ifdef CONFIG_SUN_PARTITION
	sun_partition,
#endif
#ifdef CONFIG_AMIGA_PARTITION
	amiga_partition,
#endif
#ifdef CONFIG_ATARI_PARTITION
	atari_partition,
#endif
#ifdef CONFIG_MAC_PARTITION
	mac_partition,
#endif
#ifdef CONFIG_ULTRIX_PARTITION
	ultrix_partition,
#endif
#ifdef CONFIG_IBM_PARTITION
	ibm_partition,
#endif
#ifdef CONFIG_KARMA_PARTITION
	karma_partition,
#endif
#ifdef CONFIG_SYSV68_PARTITION
	sysv68_partition,
#endif
	NULL
};

static struct parsed_partitions *allocate_partitions(struct gendisk *hd)
{
	struct parsed_partitions *state;
	int nr;

	state = kzalloc(sizeof(*state), GFP_KERNEL);
	if (!state)
		return NULL;

	nr = disk_max_parts(hd);
	state->parts = vzalloc(nr * sizeof(state->parts[0]));
	if (!state->parts) {
		kfree(state);
		return NULL;
	}

	state->limit = nr;

	return state;
}

void free_partitions(struct parsed_partitions *state)
{
	vfree(state->parts);
	kfree(state);
}

struct parsed_partitions *
check_partition(struct gendisk *hd, struct block_device *bdev)
{
	struct parsed_partitions *state;
	int i, res, err;

	state = allocate_partitions(hd);
	if (!state)
		return NULL;
	state->pp_buf = (char *)__get_free_page(GFP_KERNEL);
	if (!state->pp_buf) {
		free_partitions(state);
		return NULL;
	}
	state->pp_buf[0] = '\0';

	state->bdev = bdev;
	disk_name(hd, 0, state->name);
	snprintf(state->pp_buf, PAGE_SIZE, " %s:", state->name);
	if (isdigit(state->name[strlen(state->name)-1]))
		sprintf(state->name, "p");

	i = res = err = 0;
	while (!res && check_part[i]) {
		memset(state->parts, 0, state->limit * sizeof(state->parts[0]));
		res = check_part[i++](state);
		if (res < 0) {
			/* We have hit an I/O error which we don't report now.
		 	* But record it, and let the others do their job.
		 	*/
			err = res;
			res = 0;
		}

	}
	if (res > 0) {
		printk(KERN_INFO "%s", state->pp_buf);

		free_page((unsigned long)state->pp_buf);
		return state;
	}
	if (state->access_beyond_eod)
		err = -ENOSPC;
	if (err)
	/* The partition is unrecognized. So report I/O errors if there were any */
		res = err;
	if (!res)
		strlcat(state->pp_buf, " unknown partition table\n", PAGE_SIZE);
	else if (warn_no_part)
		strlcat(state->pp_buf, " unable to read partition table\n", PAGE_SIZE);

	printk(KERN_INFO "%s", state->pp_buf);

	free_page((unsigned long)state->pp_buf);
	free_partitions(state);
	return ERR_PTR(res);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* fs/partitions/check.c
	3	*
	4	* Code extracted from drivers/block/genhd.c
	5	* Copyright (C) 1991-1998 Linus Torvalds
	6	* Re-organised Feb 1998 Russell King
	7	*
	8	* We now have independent partition support from the
	9	* block drivers, which allows all the partition code to
	10	* be grouped in one location, and it to be mostly self
	11	* contained.
	12	*
	13	* Added needed MAJORS for new pairs, {hdi,hdj}, {hdk,hdl}
	14	*/
	15
5a0e3ad6	16	#include <linux/slab.h>
ac2e5327	17	#include <linux/vmalloc.h>
1da177e4	18	#include <linux/ctype.h>
6f2576af	19	#include <linux/genhd.h>
1da177e4 LT	20
1da177e4 LT	21	#include "check.h"
1da177e4 LT	22
	23	#include "acorn.h"
	24	#include "amiga.h"
	25	#include "atari.h"
	26	#include "ldm.h"
	27	#include "mac.h"
	28	#include "msdos.h"
	29	#include "osf.h"
	30	#include "sgi.h"
	31	#include "sun.h"
	32	#include "ibm.h"
	33	#include "ultrix.h"
	34	#include "efi.h"
0e6e1db4	35	#include "karma.h"
19d0e8ce	36	#include "sysv68.h"
1da177e4	37
1da177e4 LT	38	int warn_no_part = 1; /This is ugly: should make genhd removable media aware/
1da177e4 LT	39
1493bf21	40	static int (check_part[])(struct parsed_partitions ) = {
1da177e4 LT	41	/*
	42	* Probe partition formats with tables at disk address 0
	43	* that also have an ADFS boot block at 0xdc0.
	44	*/
	45	#ifdef CONFIG_ACORN_PARTITION_ICS
	46	adfspart_check_ICS,
	47	#endif
	48	#ifdef CONFIG_ACORN_PARTITION_POWERTEC
	49	adfspart_check_POWERTEC,
	50	#endif
	51	#ifdef CONFIG_ACORN_PARTITION_EESOX
	52	adfspart_check_EESOX,
	53	#endif
	54
	55	/*
	56	* Now move on to formats that only have partition info at
	57	* disk address 0xdc0. Since these may also have stale
	58	* PC/BIOS partition tables, they need to come before
	59	* the msdos entry.
	60	*/
	61	#ifdef CONFIG_ACORN_PARTITION_CUMANA
	62	adfspart_check_CUMANA,
	63	#endif
	64	#ifdef CONFIG_ACORN_PARTITION_ADFS
	65	adfspart_check_ADFS,
	66	#endif
	67
	68	#ifdef CONFIG_EFI_PARTITION
	69	efi_partition, /* this must come before msdos */
	70	#endif
	71	#ifdef CONFIG_SGI_PARTITION
	72	sgi_partition,
	73	#endif
	74	#ifdef CONFIG_LDM_PARTITION
	75	ldm_partition, /* this must come before msdos */
	76	#endif
1da177e4 LT	77	#ifdef CONFIG_MSDOS_PARTITION
	78	msdos_partition,
	79	#endif
	80	#ifdef CONFIG_OSF_PARTITION
	81	osf_partition,
	82	#endif
	83	#ifdef CONFIG_SUN_PARTITION
	84	sun_partition,
	85	#endif
	86	#ifdef CONFIG_AMIGA_PARTITION
	87	amiga_partition,
	88	#endif
	89	#ifdef CONFIG_ATARI_PARTITION
	90	atari_partition,
	91	#endif
	92	#ifdef CONFIG_MAC_PARTITION
	93	mac_partition,
	94	#endif
	95	#ifdef CONFIG_ULTRIX_PARTITION
	96	ultrix_partition,
	97	#endif
	98	#ifdef CONFIG_IBM_PARTITION
	99	ibm_partition,
0e6e1db4 BC	100	#endif
	101	#ifdef CONFIG_KARMA_PARTITION
	102	karma_partition,
19d0e8ce PDM	103	#endif
	104	#ifdef CONFIG_SYSV68_PARTITION
	105	sysv68_partition,
1da177e4 LT	106	#endif
	107	NULL
	108	};
1da177e4	109
ac2e5327 ML	110	static struct parsed_partitions allocate_partitions(struct gendisk hd)
	111	{
	112	struct parsed_partitions *state;
	113	int nr;
	114
	115	state = kzalloc(sizeof(*state), GFP_KERNEL);
	116	if (!state)
	117	return NULL;
	118
	119	nr = disk_max_parts(hd);
	120	state->parts = vzalloc(nr * sizeof(state->parts[0]));
	121	if (!state->parts) {
	122	kfree(state);
	123	return NULL;
	124	}
	125
	126	state->limit = nr;
	127
	128	return state;
	129	}
	130
	131	void free_partitions(struct parsed_partitions *state)
	132	{
	133	vfree(state->parts);
	134	kfree(state);
	135	}
	136
94ea4158	137	struct parsed_partitions *
1da177e4 LT	138	check_partition(struct gendisk hd, struct block_device bdev)
	139	{
	140	struct parsed_partitions *state;
57881dd9	141	int i, res, err;
1da177e4	142
ac2e5327	143	state = allocate_partitions(hd);
1da177e4 LT	144	if (!state)
1da177e4 LT	145	return NULL;
9c867fbe AD	146	state->pp_buf = (char *)__get_free_page(GFP_KERNEL);
9c867fbe AD	147	if (!state->pp_buf) {
ac2e5327	148	free_partitions(state);
9c867fbe AD	149	return NULL;
	150	}
	151	state->pp_buf[0] = '\0';
1da177e4	152
1493bf21	153	state->bdev = bdev;
a2964188	154	disk_name(hd, 0, state->name);
9c867fbe	155	snprintf(state->pp_buf, PAGE_SIZE, " %s:", state->name);
a2964188	156	if (isdigit(state->name[strlen(state->name)-1]))
1da177e4	157	sprintf(state->name, "p");
a2964188	158
57881dd9	159	i = res = err = 0;
1da177e4	160	while (!res && check_part[i]) {
ac2e5327	161	memset(state->parts, 0, state->limit * sizeof(state->parts[0]));
1493bf21	162	res = check_part[i++](state);
57881dd9 S	163	if (res < 0) {
	164	/* We have hit an I/O error which we don't report now.
	165	* But record it, and let the others do their job.
	166	*/
	167	err = res;
	168	res = 0;
	169	}
	170
1da177e4	171	}
9c867fbe AD	172	if (res > 0) {
	173	printk(KERN_INFO "%s", state->pp_buf);
	174
	175	free_page((unsigned long)state->pp_buf);
1da177e4	176	return state;
9c867fbe	177	}
b403a98e TH	178	if (state->access_beyond_eod)
b403a98e TH	179	err = -ENOSPC;
9bebff6c	180	if (err)
57881dd9 S	181	/* The partition is unrecognized. So report I/O errors if there were any */
57881dd9 S	182	res = err;
1da177e4	183	if (!res)
9c867fbe	184	strlcat(state->pp_buf, " unknown partition table\n", PAGE_SIZE);
1da177e4	185	else if (warn_no_part)
9c867fbe AD	186	strlcat(state->pp_buf, " unable to read partition table\n", PAGE_SIZE);
	187
	188	printk(KERN_INFO "%s", state->pp_buf);
	189
	190	free_page((unsigned long)state->pp_buf);
ac2e5327	191	free_partitions(state);
5127d002	192	return ERR_PTR(res);
1da177e4	193	}