Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
6ceea22b PDM |
2 | /* |
3 | * fs/partitions/aix.c | |
4 | * | |
5 | * Copyright (C) 2012-2013 Philippe De Muyter <phdm@macqel.be> | |
6 | */ | |
7 | ||
8 | #include "check.h" | |
6ceea22b PDM |
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 | ||
6ceea22b PDM |
69 | /** |
70 | * read_lba(): Read bytes from disk, starting at given LBA | |
71 | * @state | |
72 | * @lba | |
73 | * @buffer | |
74 | * @count | |
75 | * | |
a08aa9bc | 76 | * Description: Reads @count bytes from @state->disk into @buffer. |
6ceea22b PDM |
77 | * Returns number of bytes read on success, 0 on error. |
78 | */ | |
79 | static size_t read_lba(struct parsed_partitions *state, u64 lba, u8 *buffer, | |
80 | size_t count) | |
81 | { | |
82 | size_t totalreadcount = 0; | |
83 | ||
a08aa9bc | 84 | if (!buffer || lba + count / 512 > get_capacity(state->disk) - 1ULL) |
6ceea22b PDM |
85 | return 0; |
86 | ||
87 | while (count) { | |
88 | int copied = 512; | |
89 | Sector sect; | |
90 | unsigned char *data = read_part_sector(state, lba++, §); | |
91 | if (!data) | |
92 | break; | |
93 | if (copied > count) | |
94 | copied = count; | |
95 | memcpy(buffer, data, copied); | |
96 | put_dev_sector(sect); | |
97 | buffer += copied; | |
98 | totalreadcount += copied; | |
99 | count -= copied; | |
100 | } | |
101 | return totalreadcount; | |
102 | } | |
103 | ||
104 | /** | |
105 | * alloc_pvd(): reads physical volume descriptor | |
106 | * @state | |
107 | * @lba | |
108 | * | |
109 | * Description: Returns pvd on success, NULL on error. | |
110 | * Allocates space for pvd and fill it with disk blocks at @lba | |
111 | * Notes: remember to free pvd when you're done! | |
112 | */ | |
113 | static struct pvd *alloc_pvd(struct parsed_partitions *state, u32 lba) | |
114 | { | |
115 | size_t count = sizeof(struct pvd); | |
116 | struct pvd *p; | |
117 | ||
118 | p = kmalloc(count, GFP_KERNEL); | |
119 | if (!p) | |
120 | return NULL; | |
121 | ||
122 | if (read_lba(state, lba, (u8 *) p, count) < count) { | |
123 | kfree(p); | |
124 | return NULL; | |
125 | } | |
126 | return p; | |
127 | } | |
128 | ||
129 | /** | |
130 | * alloc_lvn(): reads logical volume names | |
131 | * @state | |
132 | * @lba | |
133 | * | |
134 | * Description: Returns lvn on success, NULL on error. | |
135 | * Allocates space for lvn and fill it with disk blocks at @lba | |
136 | * Notes: remember to free lvn when you're done! | |
137 | */ | |
138 | static struct lvname *alloc_lvn(struct parsed_partitions *state, u32 lba) | |
139 | { | |
140 | size_t count = sizeof(struct lvname) * LVM_MAXLVS; | |
141 | struct lvname *p; | |
142 | ||
143 | p = kmalloc(count, GFP_KERNEL); | |
144 | if (!p) | |
145 | return NULL; | |
146 | ||
147 | if (read_lba(state, lba, (u8 *) p, count) < count) { | |
148 | kfree(p); | |
149 | return NULL; | |
150 | } | |
151 | return p; | |
152 | } | |
153 | ||
154 | int aix_partition(struct parsed_partitions *state) | |
155 | { | |
156 | int ret = 0; | |
157 | Sector sect; | |
158 | unsigned char *d; | |
159 | u32 pp_bytes_size; | |
160 | u32 pp_blocks_size = 0; | |
161 | u32 vgda_sector = 0; | |
162 | u32 vgda_len = 0; | |
163 | int numlvs = 0; | |
14cb2c8a | 164 | struct pvd *pvd = NULL; |
6ceea22b PDM |
165 | struct lv_info { |
166 | unsigned short pps_per_lv; | |
167 | unsigned short pps_found; | |
168 | unsigned char lv_is_contiguous; | |
169 | } *lvip; | |
170 | struct lvname *n = NULL; | |
171 | ||
172 | d = read_part_sector(state, 7, §); | |
173 | if (d) { | |
174 | struct lvm_rec *p = (struct lvm_rec *)d; | |
175 | u16 lvm_version = be16_to_cpu(p->version); | |
176 | char tmp[64]; | |
177 | ||
178 | if (lvm_version == 1) { | |
179 | int pp_size_log2 = be16_to_cpu(p->pp_size); | |
180 | ||
181 | pp_bytes_size = 1 << pp_size_log2; | |
182 | pp_blocks_size = pp_bytes_size / 512; | |
183 | snprintf(tmp, sizeof(tmp), | |
184 | " AIX LVM header version %u found\n", | |
185 | lvm_version); | |
186 | vgda_len = be32_to_cpu(p->vgda_len); | |
187 | vgda_sector = be32_to_cpu(p->vgda_psn[0]); | |
188 | } else { | |
189 | snprintf(tmp, sizeof(tmp), | |
190 | " unsupported AIX LVM version %d found\n", | |
191 | lvm_version); | |
192 | } | |
193 | strlcat(state->pp_buf, tmp, PAGE_SIZE); | |
194 | put_dev_sector(sect); | |
195 | } | |
196 | if (vgda_sector && (d = read_part_sector(state, vgda_sector, §))) { | |
197 | struct vgda *p = (struct vgda *)d; | |
198 | ||
199 | numlvs = be16_to_cpu(p->numlvs); | |
200 | put_dev_sector(sect); | |
201 | } | |
472d5e2a | 202 | lvip = kcalloc(state->limit, sizeof(struct lv_info), GFP_KERNEL); |
6ceea22b PDM |
203 | if (!lvip) |
204 | return 0; | |
205 | if (numlvs && (d = read_part_sector(state, vgda_sector + 1, §))) { | |
206 | struct lvd *p = (struct lvd *)d; | |
207 | int i; | |
208 | ||
209 | n = alloc_lvn(state, vgda_sector + vgda_len - 33); | |
210 | if (n) { | |
211 | int foundlvs = 0; | |
212 | ||
213 | for (i = 0; foundlvs < numlvs && i < state->limit; i += 1) { | |
214 | lvip[i].pps_per_lv = be16_to_cpu(p[i].num_lps); | |
215 | if (lvip[i].pps_per_lv) | |
216 | foundlvs += 1; | |
217 | } | |
14cb2c8a MFO |
218 | /* pvd loops depend on n[].name and lvip[].pps_per_lv */ |
219 | pvd = alloc_pvd(state, vgda_sector + 17); | |
6ceea22b PDM |
220 | } |
221 | put_dev_sector(sect); | |
222 | } | |
6ceea22b PDM |
223 | if (pvd) { |
224 | int numpps = be16_to_cpu(pvd->pp_count); | |
225 | int psn_part1 = be32_to_cpu(pvd->psn_part1); | |
226 | int i; | |
227 | int cur_lv_ix = -1; | |
228 | int next_lp_ix = 1; | |
229 | int lp_ix; | |
230 | ||
231 | for (i = 0; i < numpps; i += 1) { | |
232 | struct ppe *p = pvd->ppe + i; | |
233 | unsigned int lv_ix; | |
234 | ||
235 | lp_ix = be16_to_cpu(p->lp_ix); | |
236 | if (!lp_ix) { | |
237 | next_lp_ix = 1; | |
238 | continue; | |
239 | } | |
240 | lv_ix = be16_to_cpu(p->lv_ix) - 1; | |
d97a86c1 | 241 | if (lv_ix >= state->limit) { |
6ceea22b PDM |
242 | cur_lv_ix = -1; |
243 | continue; | |
244 | } | |
245 | lvip[lv_ix].pps_found += 1; | |
246 | if (lp_ix == 1) { | |
247 | cur_lv_ix = lv_ix; | |
248 | next_lp_ix = 1; | |
249 | } else if (lv_ix != cur_lv_ix || lp_ix != next_lp_ix) { | |
250 | next_lp_ix = 1; | |
251 | continue; | |
252 | } | |
253 | if (lp_ix == lvip[lv_ix].pps_per_lv) { | |
254 | char tmp[70]; | |
255 | ||
256 | put_partition(state, lv_ix + 1, | |
257 | (i + 1 - lp_ix) * pp_blocks_size + psn_part1, | |
258 | lvip[lv_ix].pps_per_lv * pp_blocks_size); | |
259 | snprintf(tmp, sizeof(tmp), " <%s>\n", | |
260 | n[lv_ix].name); | |
261 | strlcat(state->pp_buf, tmp, PAGE_SIZE); | |
262 | lvip[lv_ix].lv_is_contiguous = 1; | |
263 | ret = 1; | |
264 | next_lp_ix = 1; | |
265 | } else | |
266 | next_lp_ix += 1; | |
267 | } | |
268 | for (i = 0; i < state->limit; i += 1) | |
d43fdae7 MFO |
269 | if (lvip[i].pps_found && !lvip[i].lv_is_contiguous) { |
270 | char tmp[sizeof(n[i].name) + 1]; // null char | |
271 | ||
272 | snprintf(tmp, sizeof(tmp), "%s", n[i].name); | |
6ceea22b PDM |
273 | pr_warn("partition %s (%u pp's found) is " |
274 | "not contiguous\n", | |
d43fdae7 MFO |
275 | tmp, lvip[i].pps_found); |
276 | } | |
6ceea22b PDM |
277 | kfree(pvd); |
278 | } | |
279 | kfree(n); | |
280 | kfree(lvip); | |
281 | return ret; | |
282 | } |