[linux.git] / block / partitions / aix.c

/*
 *  fs/partitions/aix.c
 *
 *  Copyright (C) 2012-2013 Philippe De Muyter <[email protected]>
 */

#include "check.h"
#include "aix.h"

struct lvm_rec {
	char lvm_id[4]; /* "_LVM" */
	char reserved4[16];
	__be32 lvmarea_len;
	__be32 vgda_len;
	__be32 vgda_psn[2];
	char reserved36[10];
	__be16 pp_size; /* log2(pp_size) */
	char reserved46[12];
	__be16 version;
	};

struct vgda {
	__be32 secs;
	__be32 usec;
	char reserved8[16];
	__be16 numlvs;
	__be16 maxlvs;
	__be16 pp_size;
	__be16 numpvs;
	__be16 total_vgdas;
	__be16 vgda_size;
	};

struct lvd {
	__be16 lv_ix;
	__be16 res2;
	__be16 res4;
	__be16 maxsize;
	__be16 lv_state;
	__be16 mirror;
	__be16 mirror_policy;
	__be16 num_lps;
	__be16 res10[8];
	};

struct lvname {
	char name[64];
	};

struct ppe {
	__be16 lv_ix;
	unsigned short res2;
	unsigned short res4;
	__be16 lp_ix;
	unsigned short res8[12];
	};

struct pvd {
	char reserved0[16];
	__be16 pp_count;
	char reserved18[2];
	__be32 psn_part1;
	char reserved24[8];
	struct ppe ppe[1016];
	};

#define LVM_MAXLVS 256

/**
 * last_lba(): return number of last logical block of device
 * @bdev: block device
 *
 * Description: Returns last LBA value on success, 0 on error.
 * This is stored (by sd and ide-geometry) in
 *  the part[0] entry for this disk, and is the number of
 *  physical sectors available on the disk.
 */
static u64 last_lba(struct block_device *bdev)
{
	if (!bdev || !bdev->bd_inode)
		return 0;
	return (bdev->bd_inode->i_size >> 9) - 1ULL;
}

/**
 * read_lba(): Read bytes from disk, starting at given LBA
 * @state
 * @lba
 * @buffer
 * @count
 *
 * Description:  Reads @count bytes from @state->bdev into @buffer.
 * Returns number of bytes read on success, 0 on error.
 */
static size_t read_lba(struct parsed_partitions *state, u64 lba, u8 *buffer,
			size_t count)
{
	size_t totalreadcount = 0;

	if (!buffer || lba + count / 512 > last_lba(state->bdev))
		return 0;

	while (count) {
		int copied = 512;
		Sector sect;
		unsigned char *data = read_part_sector(state, lba++, &sect);
		if (!data)
			break;
		if (copied > count)
			copied = count;
		memcpy(buffer, data, copied);
		put_dev_sector(sect);
		buffer += copied;
		totalreadcount += copied;
		count -= copied;
	}
	return totalreadcount;
}

/**
 * alloc_pvd(): reads physical volume descriptor
 * @state
 * @lba
 *
 * Description: Returns pvd on success,  NULL on error.
 * Allocates space for pvd and fill it with disk blocks at @lba
 * Notes: remember to free pvd when you're done!
 */
static struct pvd *alloc_pvd(struct parsed_partitions *state, u32 lba)
{
	size_t count = sizeof(struct pvd);
	struct pvd *p;

	p = kmalloc(count, GFP_KERNEL);
	if (!p)
		return NULL;

	if (read_lba(state, lba, (u8 *) p, count) < count) {
		kfree(p);
		return NULL;
	}
	return p;
}

/**
 * alloc_lvn(): reads logical volume names
 * @state
 * @lba
 *
 * Description: Returns lvn on success,  NULL on error.
 * Allocates space for lvn and fill it with disk blocks at @lba
 * Notes: remember to free lvn when you're done!
 */
static struct lvname *alloc_lvn(struct parsed_partitions *state, u32 lba)
{
	size_t count = sizeof(struct lvname) * LVM_MAXLVS;
	struct lvname *p;

	p = kmalloc(count, GFP_KERNEL);
	if (!p)
		return NULL;

	if (read_lba(state, lba, (u8 *) p, count) < count) {
		kfree(p);
		return NULL;
	}
	return p;
}

int aix_partition(struct parsed_partitions *state)
{
	int ret = 0;
	Sector sect;
	unsigned char *d;
	u32 pp_bytes_size;
	u32 pp_blocks_size = 0;
	u32 vgda_sector = 0;
	u32 vgda_len = 0;
	int numlvs = 0;
	struct pvd *pvd;
	struct lv_info {
		unsigned short pps_per_lv;
		unsigned short pps_found;
		unsigned char lv_is_contiguous;
	} *lvip;
	struct lvname *n = NULL;

	d = read_part_sector(state, 7, &sect);
	if (d) {
		struct lvm_rec *p = (struct lvm_rec *)d;
		u16 lvm_version = be16_to_cpu(p->version);
		char tmp[64];

		if (lvm_version == 1) {
			int pp_size_log2 = be16_to_cpu(p->pp_size);

			pp_bytes_size = 1 << pp_size_log2;
			pp_blocks_size = pp_bytes_size / 512;
			snprintf(tmp, sizeof(tmp),
				" AIX LVM header version %u found\n",
				lvm_version);
			vgda_len = be32_to_cpu(p->vgda_len);
			vgda_sector = be32_to_cpu(p->vgda_psn[0]);
		} else {
			snprintf(tmp, sizeof(tmp),
				" unsupported AIX LVM version %d found\n",
				lvm_version);
		}
		strlcat(state->pp_buf, tmp, PAGE_SIZE);
		put_dev_sector(sect);
	}
	if (vgda_sector && (d = read_part_sector(state, vgda_sector, &sect))) {
		struct vgda *p = (struct vgda *)d;

		numlvs = be16_to_cpu(p->numlvs);
		put_dev_sector(sect);
	}
	lvip = kzalloc(sizeof(struct lv_info) * state->limit, GFP_KERNEL);
	if (!lvip)
		return 0;
	if (numlvs && (d = read_part_sector(state, vgda_sector + 1, &sect))) {
		struct lvd *p = (struct lvd *)d;
		int i;

		n = alloc_lvn(state, vgda_sector + vgda_len - 33);
		if (n) {
			int foundlvs = 0;

			for (i = 0; foundlvs < numlvs && i < state->limit; i += 1) {
				lvip[i].pps_per_lv = be16_to_cpu(p[i].num_lps);
				if (lvip[i].pps_per_lv)
					foundlvs += 1;
			}
		}
		put_dev_sector(sect);
	}
	pvd = alloc_pvd(state, vgda_sector + 17);
	if (pvd) {
		int numpps = be16_to_cpu(pvd->pp_count);
		int psn_part1 = be32_to_cpu(pvd->psn_part1);
		int i;
		int cur_lv_ix = -1;
		int next_lp_ix = 1;
		int lp_ix;

		for (i = 0; i < numpps; i += 1) {
			struct ppe *p = pvd->ppe + i;
			unsigned int lv_ix;

			lp_ix = be16_to_cpu(p->lp_ix);
			if (!lp_ix) {
				next_lp_ix = 1;
				continue;
			}
			lv_ix = be16_to_cpu(p->lv_ix) - 1;
			if (lv_ix > state->limit) {
				cur_lv_ix = -1;
				continue;
			}
			lvip[lv_ix].pps_found += 1;
			if (lp_ix == 1) {
				cur_lv_ix = lv_ix;
				next_lp_ix = 1;
			} else if (lv_ix != cur_lv_ix || lp_ix != next_lp_ix) {
				next_lp_ix = 1;
				continue;
			}
			if (lp_ix == lvip[lv_ix].pps_per_lv) {
				char tmp[70];

				put_partition(state, lv_ix + 1,
				  (i + 1 - lp_ix) * pp_blocks_size + psn_part1,
				  lvip[lv_ix].pps_per_lv * pp_blocks_size);
				snprintf(tmp, sizeof(tmp), " <%s>\n",
					 n[lv_ix].name);
				strlcat(state->pp_buf, tmp, PAGE_SIZE);
				lvip[lv_ix].lv_is_contiguous = 1;
				ret = 1;
				next_lp_ix = 1;
			} else
				next_lp_ix += 1;
		}
		for (i = 0; i < state->limit; i += 1)
			if (lvip[i].pps_found && !lvip[i].lv_is_contiguous)
				pr_warn("partition %s (%u pp's found) is "
					"not contiguous\n",
					n[i].name, lvip[i].pps_found);
		kfree(pvd);
	}
	kfree(n);
	kfree(lvip);
	return ret;
}
Commit	Line	Data
6ceea22b PDM	1	/*
	2	* fs/partitions/aix.c
	3	*
	4	* Copyright (C) 2012-2013 Philippe De Muyter <[email protected]>
	5	*/
	6
	7	#include "check.h"
	8	#include "aix.h"
	9
	10	struct lvm_rec {
	11	char lvm_id[4]; /* "_LVM" */
	12	char reserved4[16];
	13	__be32 lvmarea_len;
	14	__be32 vgda_len;
	15	__be32 vgda_psn[2];
	16	char reserved36[10];
	17	__be16 pp_size; /* log2(pp_size) */
	18	char reserved46[12];
	19	__be16 version;
	20	};
	21
	22	struct vgda {
	23	__be32 secs;
	24	__be32 usec;
	25	char reserved8[16];
	26	__be16 numlvs;
	27	__be16 maxlvs;
	28	__be16 pp_size;
	29	__be16 numpvs;
	30	__be16 total_vgdas;
	31	__be16 vgda_size;
	32	};
	33
	34	struct lvd {
	35	__be16 lv_ix;
	36	__be16 res2;
	37	__be16 res4;
	38	__be16 maxsize;
	39	__be16 lv_state;
	40	__be16 mirror;
	41	__be16 mirror_policy;
	42	__be16 num_lps;
	43	__be16 res10[8];
	44	};
	45
	46	struct lvname {
	47	char name[64];
	48	};
	49
	50	struct ppe {
	51	__be16 lv_ix;
	52	unsigned short res2;
	53	unsigned short res4;
	54	__be16 lp_ix;
	55	unsigned short res8[12];
	56	};
	57
	58	struct pvd {
	59	char reserved0[16];
	60	__be16 pp_count;
	61	char reserved18[2];
	62	__be32 psn_part1;
	63	char reserved24[8];
	64	struct ppe ppe[1016];
65	};
66
67	#define LVM_MAXLVS 256
68
69	/**
70	* last_lba(): return number of last logical block of device
71	* @bdev: block device
72	*
73	* Description: Returns last LBA value on success, 0 on error.
74	* This is stored (by sd and ide-geometry) in
75	* the part[0] entry for this disk, and is the number of
76	* physical sectors available on the disk.
77	*/
78	static u64 last_lba(struct block_device *bdev)
79	{
80	if (!bdev \|\| !bdev->bd_inode)
81	return 0;
82	return (bdev->bd_inode->i_size >> 9) - 1ULL;
83	}
84
85	/**
86	* read_lba(): Read bytes from disk, starting at given LBA
87	* @state
88	* @lba
89	* @buffer
90	* @count
91	*
92	* Description: Reads @count bytes from @state->bdev into @buffer.
93	* Returns number of bytes read on success, 0 on error.
94	*/
95	static size_t read_lba(struct parsed_partitions state, u64 lba, u8 buffer,
96	size_t count)
97	{
98	size_t totalreadcount = 0;
99
100	if (!buffer \|\| lba + count / 512 > last_lba(state->bdev))
101	return 0;
102
103	while (count) {
104	int copied = 512;
105	Sector sect;
106	unsigned char *data = read_part_sector(state, lba++, &sect);
107	if (!data)
108	break;
109	if (copied > count)
110	copied = count;
111	memcpy(buffer, data, copied);
112	put_dev_sector(sect);
113	buffer += copied;
114	totalreadcount += copied;
115	count -= copied;
116	}
117	return totalreadcount;
118	}
119
120	/**
121	* alloc_pvd(): reads physical volume descriptor
122	* @state
123	* @lba
124	*
125	* Description: Returns pvd on success, NULL on error.
126	* Allocates space for pvd and fill it with disk blocks at @lba
127	* Notes: remember to free pvd when you're done!
128	*/
129	static struct pvd alloc_pvd(struct parsed_partitions state, u32 lba)
130	{
131	size_t count = sizeof(struct pvd);
132	struct pvd *p;
133
134	p = kmalloc(count, GFP_KERNEL);
135	if (!p)
136	return NULL;
137
138	if (read_lba(state, lba, (u8 *) p, count) < count) {
139	kfree(p);
140	return NULL;
141	}
142	return p;
143	}
144
145	/**
146	* alloc_lvn(): reads logical volume names
147	* @state
148	* @lba
149	*
150	* Description: Returns lvn on success, NULL on error.
151	* Allocates space for lvn and fill it with disk blocks at @lba
152	* Notes: remember to free lvn when you're done!
153	*/
154	static struct lvname alloc_lvn(struct parsed_partitions state, u32 lba)
155	{
156	size_t count = sizeof(struct lvname) * LVM_MAXLVS;
157	struct lvname *p;
158
159	p = kmalloc(count, GFP_KERNEL);
160	if (!p)
161	return NULL;
162
163	if (read_lba(state, lba, (u8 *) p, count) < count) {
164	kfree(p);
165	return NULL;
166	}
167	return p;
168	}
169
170	int aix_partition(struct parsed_partitions *state)
171	{
172	int ret = 0;
173	Sector sect;
174	unsigned char *d;
175	u32 pp_bytes_size;
176	u32 pp_blocks_size = 0;
177	u32 vgda_sector = 0;
178	u32 vgda_len = 0;
179	int numlvs = 0;
180	struct pvd *pvd;
181	struct lv_info {
182	unsigned short pps_per_lv;
183	unsigned short pps_found;
184	unsigned char lv_is_contiguous;
185	} *lvip;
186	struct lvname *n = NULL;
187
188	d = read_part_sector(state, 7, &sect);
189	if (d) {
190	struct lvm_rec p = (struct lvm_rec )d;
191	u16 lvm_version = be16_to_cpu(p->version);
192	char tmp[64];
193
194	if (lvm_version == 1) {
195	int pp_size_log2 = be16_to_cpu(p->pp_size);
196
197	pp_bytes_size = 1 << pp_size_log2;
198	pp_blocks_size = pp_bytes_size / 512;
199	snprintf(tmp, sizeof(tmp),
200	" AIX LVM header version %u found\n",
201	lvm_version);
202	vgda_len = be32_to_cpu(p->vgda_len);
203	vgda_sector = be32_to_cpu(p->vgda_psn[0]);
204	} else {
205	snprintf(tmp, sizeof(tmp),
206	" unsupported AIX LVM version %d found\n",
207	lvm_version);
208	}
209	strlcat(state->pp_buf, tmp, PAGE_SIZE);
210	put_dev_sector(sect);
211	}
212	if (vgda_sector && (d = read_part_sector(state, vgda_sector, &sect))) {
213	struct vgda p = (struct vgda )d;
214
215	numlvs = be16_to_cpu(p->numlvs);
216	put_dev_sector(sect);
217	}
218	lvip = kzalloc(sizeof(struct lv_info) * state->limit, GFP_KERNEL);
219	if (!lvip)
220	return 0;
221	if (numlvs && (d = read_part_sector(state, vgda_sector + 1, &sect))) {
222	struct lvd p = (struct lvd )d;
223	int i;
224
225	n = alloc_lvn(state, vgda_sector + vgda_len - 33);
226	if (n) {
227	int foundlvs = 0;
228
229	for (i = 0; foundlvs < numlvs && i < state->limit; i += 1) {
230	lvip[i].pps_per_lv = be16_to_cpu(p[i].num_lps);
231	if (lvip[i].pps_per_lv)
232	foundlvs += 1;
233	}
234	}
235	put_dev_sector(sect);
236	}
237	pvd = alloc_pvd(state, vgda_sector + 17);
238	if (pvd) {
239	int numpps = be16_to_cpu(pvd->pp_count);
240	int psn_part1 = be32_to_cpu(pvd->psn_part1);
241	int i;
242	int cur_lv_ix = -1;
243	int next_lp_ix = 1;
244	int lp_ix;
245
246	for (i = 0; i < numpps; i += 1) {
247	struct ppe *p = pvd->ppe + i;
248	unsigned int lv_ix;
249
250	lp_ix = be16_to_cpu(p->lp_ix);
251	if (!lp_ix) {
252	next_lp_ix = 1;
253	continue;
254	}
255	lv_ix = be16_to_cpu(p->lv_ix) - 1;
256	if (lv_ix > state->limit) {
257	cur_lv_ix = -1;
258	continue;
259	}
260	lvip[lv_ix].pps_found += 1;
261	if (lp_ix == 1) {
262	cur_lv_ix = lv_ix;
263	next_lp_ix = 1;
264	} else if (lv_ix != cur_lv_ix \|\| lp_ix != next_lp_ix) {
265	next_lp_ix = 1;
266	continue;
267	}
268	if (lp_ix == lvip[lv_ix].pps_per_lv) {
269	char tmp[70];
270
271	put_partition(state, lv_ix + 1,
272	(i + 1 - lp_ix) * pp_blocks_size + psn_part1,
273	lvip[lv_ix].pps_per_lv * pp_blocks_size);
274	snprintf(tmp, sizeof(tmp), " <%s>\n",
275	n[lv_ix].name);
276	strlcat(state->pp_buf, tmp, PAGE_SIZE);
277	lvip[lv_ix].lv_is_contiguous = 1;
278	ret = 1;
279	next_lp_ix = 1;
280	} else
281	next_lp_ix += 1;
282	}
283	for (i = 0; i < state->limit; i += 1)
284	if (lvip[i].pps_found && !lvip[i].lv_is_contiguous)
285	pr_warn("partition %s (%u pp's found) is "
286	"not contiguous\n",
287	n[i].name, lvip[i].pps_found);
288	kfree(pvd);
289	}
290	kfree(n);
291	kfree(lvip);
292	return ret;
293	}