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