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 11 struct 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 23 struct 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 35 struct 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 47 struct lvname { 48 char name[64]; 49 }; 50 51 struct ppe { 52 __be16 lv_ix; 53 unsigned short res2; 54 unsigned short res4; 55 __be16 lp_ix; 56 unsigned short res8[12]; 57 }; 58 59 struct 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 */ 79 static 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 */ 96 static 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++, §); 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 */ 130 static 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 */ 155 static 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 171 int 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, §); 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, §))) { 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, §))) { 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 } 295