Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
1da177e4 LT |
2 | * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com> |
3 | * Volker Sameske <sameske@de.ibm.com> | |
4 | * Bugreports.to..: <Linux390@de.ibm.com> | |
46e88947 | 5 | * Copyright IBM Corp. 1999, 2012 |
1da177e4 LT |
6 | */ |
7 | ||
1da177e4 LT |
8 | #include <linux/buffer_head.h> |
9 | #include <linux/hdreg.h> | |
10 | #include <linux/slab.h> | |
11 | #include <asm/dasd.h> | |
12 | #include <asm/ebcdic.h> | |
13 | #include <asm/uaccess.h> | |
14 | #include <asm/vtoc.h> | |
15 | ||
16 | #include "check.h" | |
17 | #include "ibm.h" | |
18 | ||
46e88947 SW |
19 | |
20 | union label_t { | |
21 | struct vtoc_volume_label_cdl vol; | |
22 | struct vtoc_volume_label_ldl lnx; | |
23 | struct vtoc_cms_label cms; | |
24 | }; | |
25 | ||
1da177e4 | 26 | /* |
ef1597d5 | 27 | * compute the block number from a |
1da177e4 LT |
28 | * cyl-cyl-head-head structure |
29 | */ | |
46e88947 SW |
30 | static sector_t cchh2blk(struct vtoc_cchh *ptr, struct hd_geometry *geo) |
31 | { | |
b44b0ab3 SW |
32 | sector_t cyl; |
33 | __u16 head; | |
34 | ||
46e88947 | 35 | /* decode cylinder and heads for large volumes */ |
b44b0ab3 SW |
36 | cyl = ptr->hh & 0xFFF0; |
37 | cyl <<= 12; | |
38 | cyl |= ptr->cc; | |
39 | head = ptr->hh & 0x000F; | |
40 | return cyl * geo->heads * geo->sectors + | |
41 | head * geo->sectors; | |
1da177e4 LT |
42 | } |
43 | ||
1da177e4 | 44 | /* |
ef1597d5 | 45 | * compute the block number from a |
1da177e4 LT |
46 | * cyl-cyl-head-head-block structure |
47 | */ | |
46e88947 SW |
48 | static sector_t cchhb2blk(struct vtoc_cchhb *ptr, struct hd_geometry *geo) |
49 | { | |
b44b0ab3 SW |
50 | sector_t cyl; |
51 | __u16 head; | |
52 | ||
46e88947 | 53 | /* decode cylinder and heads for large volumes */ |
b44b0ab3 SW |
54 | cyl = ptr->hh & 0xFFF0; |
55 | cyl <<= 12; | |
56 | cyl |= ptr->cc; | |
57 | head = ptr->hh & 0x000F; | |
58 | return cyl * geo->heads * geo->sectors + | |
59 | head * geo->sectors + | |
1da177e4 LT |
60 | ptr->b; |
61 | } | |
62 | ||
46e88947 SW |
63 | static int find_label(struct parsed_partitions *state, |
64 | dasd_information2_t *info, | |
65 | struct hd_geometry *geo, | |
66 | int blocksize, | |
67 | sector_t *labelsect, | |
68 | char name[], | |
69 | char type[], | |
70 | union label_t *label) | |
71 | { | |
72 | Sector sect; | |
73 | unsigned char *data; | |
74 | sector_t testsect[3]; | |
75 | unsigned char temp[5]; | |
76 | int found = 0; | |
77 | int i, testcount; | |
78 | ||
79 | /* There a three places where we may find a valid label: | |
80 | * - on an ECKD disk it's block 2 | |
81 | * - on an FBA disk it's block 1 | |
82 | * - on an CMS formatted FBA disk it is sector 1, even if the block size | |
83 | * is larger than 512 bytes (possible if the DIAG discipline is used) | |
84 | * If we have a valid info structure, then we know exactly which case we | |
85 | * have, otherwise we just search through all possebilities. | |
86 | */ | |
87 | if (info) { | |
88 | if ((info->cu_type == 0x6310 && info->dev_type == 0x9336) || | |
89 | (info->cu_type == 0x3880 && info->dev_type == 0x3370)) | |
90 | testsect[0] = info->label_block; | |
91 | else | |
92 | testsect[0] = info->label_block * (blocksize >> 9); | |
93 | testcount = 1; | |
94 | } else { | |
95 | testsect[0] = 1; | |
96 | testsect[1] = (blocksize >> 9); | |
97 | testsect[2] = 2 * (blocksize >> 9); | |
98 | testcount = 3; | |
99 | } | |
100 | for (i = 0; i < testcount; ++i) { | |
101 | data = read_part_sector(state, testsect[i], §); | |
102 | if (data == NULL) | |
103 | continue; | |
104 | memcpy(label, data, sizeof(*label)); | |
105 | memcpy(temp, data, 4); | |
106 | temp[4] = 0; | |
107 | EBCASC(temp, 4); | |
108 | put_dev_sector(sect); | |
109 | if (!strcmp(temp, "VOL1") || | |
110 | !strcmp(temp, "LNX1") || | |
111 | !strcmp(temp, "CMS1")) { | |
112 | if (!strcmp(temp, "VOL1")) { | |
113 | strncpy(type, label->vol.vollbl, 4); | |
114 | strncpy(name, label->vol.volid, 6); | |
115 | } else { | |
116 | strncpy(type, label->lnx.vollbl, 4); | |
117 | strncpy(name, label->lnx.volid, 6); | |
118 | } | |
119 | EBCASC(type, 4); | |
120 | EBCASC(name, 6); | |
121 | *labelsect = testsect[i]; | |
122 | found = 1; | |
123 | break; | |
124 | } | |
125 | } | |
126 | if (!found) | |
127 | memset(label, 0, sizeof(*label)); | |
128 | ||
129 | return found; | |
130 | } | |
131 | ||
132 | static int find_vol1_partitions(struct parsed_partitions *state, | |
133 | struct hd_geometry *geo, | |
134 | int blocksize, | |
135 | char name[], | |
136 | union label_t *label) | |
137 | { | |
138 | sector_t blk; | |
139 | int counter; | |
140 | char tmp[64]; | |
141 | Sector sect; | |
142 | unsigned char *data; | |
143 | loff_t offset, size; | |
144 | struct vtoc_format1_label f1; | |
145 | int secperblk; | |
146 | ||
147 | snprintf(tmp, sizeof(tmp), "VOL1/%8s:", name); | |
148 | strlcat(state->pp_buf, tmp, PAGE_SIZE); | |
149 | /* | |
150 | * get start of VTOC from the disk label and then search for format1 | |
151 | * and format8 labels | |
152 | */ | |
153 | secperblk = blocksize >> 9; | |
154 | blk = cchhb2blk(&label->vol.vtoc, geo) + 1; | |
155 | counter = 0; | |
156 | data = read_part_sector(state, blk * secperblk, §); | |
157 | while (data != NULL) { | |
158 | memcpy(&f1, data, sizeof(struct vtoc_format1_label)); | |
159 | put_dev_sector(sect); | |
160 | /* skip FMT4 / FMT5 / FMT7 labels */ | |
161 | if (f1.DS1FMTID == _ascebc['4'] | |
162 | || f1.DS1FMTID == _ascebc['5'] | |
163 | || f1.DS1FMTID == _ascebc['7'] | |
164 | || f1.DS1FMTID == _ascebc['9']) { | |
165 | blk++; | |
166 | data = read_part_sector(state, blk * secperblk, §); | |
167 | continue; | |
168 | } | |
169 | /* only FMT1 and 8 labels valid at this point */ | |
170 | if (f1.DS1FMTID != _ascebc['1'] && | |
171 | f1.DS1FMTID != _ascebc['8']) | |
172 | break; | |
173 | /* OK, we got valid partition data */ | |
174 | offset = cchh2blk(&f1.DS1EXT1.llimit, geo); | |
175 | size = cchh2blk(&f1.DS1EXT1.ulimit, geo) - | |
176 | offset + geo->sectors; | |
177 | offset *= secperblk; | |
178 | size *= secperblk; | |
179 | if (counter >= state->limit) | |
180 | break; | |
181 | put_partition(state, counter + 1, offset, size); | |
182 | counter++; | |
183 | blk++; | |
184 | data = read_part_sector(state, blk * secperblk, §); | |
185 | } | |
186 | strlcat(state->pp_buf, "\n", PAGE_SIZE); | |
187 | ||
188 | if (!data) | |
189 | return -1; | |
190 | ||
191 | return 1; | |
192 | } | |
193 | ||
194 | static int find_lnx1_partitions(struct parsed_partitions *state, | |
195 | struct hd_geometry *geo, | |
196 | int blocksize, | |
197 | char name[], | |
198 | union label_t *label, | |
199 | sector_t labelsect, | |
200 | loff_t i_size, | |
201 | dasd_information2_t *info) | |
202 | { | |
203 | loff_t offset, geo_size, size; | |
204 | char tmp[64]; | |
205 | int secperblk; | |
206 | ||
207 | snprintf(tmp, sizeof(tmp), "LNX1/%8s:", name); | |
208 | strlcat(state->pp_buf, tmp, PAGE_SIZE); | |
209 | secperblk = blocksize >> 9; | |
210 | if (label->lnx.ldl_version == 0xf2) { | |
211 | size = label->lnx.formatted_blocks * secperblk; | |
212 | } else { | |
213 | /* | |
214 | * Formated w/o large volume support. If the sanity check | |
215 | * 'size based on geo == size based on i_size' is true, then | |
216 | * we can safely assume that we know the formatted size of | |
217 | * the disk, otherwise we need additional information | |
218 | * that we can only get from a real DASD device. | |
219 | */ | |
220 | geo_size = geo->cylinders * geo->heads | |
221 | * geo->sectors * secperblk; | |
222 | size = i_size >> 9; | |
223 | if (size != geo_size) { | |
224 | if (!info) { | |
225 | strlcat(state->pp_buf, "\n", PAGE_SIZE); | |
226 | return 1; | |
227 | } | |
228 | if (!strcmp(info->type, "ECKD")) | |
229 | if (geo_size < size) | |
230 | size = geo_size; | |
231 | /* else keep size based on i_size */ | |
232 | } | |
233 | } | |
234 | /* first and only partition starts in the first block after the label */ | |
235 | offset = labelsect + secperblk; | |
236 | put_partition(state, 1, offset, size - offset); | |
237 | strlcat(state->pp_buf, "\n", PAGE_SIZE); | |
238 | return 1; | |
239 | } | |
240 | ||
241 | static int find_cms1_partitions(struct parsed_partitions *state, | |
242 | struct hd_geometry *geo, | |
243 | int blocksize, | |
244 | char name[], | |
245 | union label_t *label, | |
246 | sector_t labelsect) | |
247 | { | |
248 | loff_t offset, size; | |
249 | char tmp[64]; | |
250 | int secperblk; | |
251 | ||
252 | /* | |
253 | * VM style CMS1 labeled disk | |
254 | */ | |
255 | blocksize = label->cms.block_size; | |
256 | secperblk = blocksize >> 9; | |
257 | if (label->cms.disk_offset != 0) { | |
258 | snprintf(tmp, sizeof(tmp), "CMS1/%8s(MDSK):", name); | |
259 | strlcat(state->pp_buf, tmp, PAGE_SIZE); | |
260 | /* disk is reserved minidisk */ | |
261 | offset = label->cms.disk_offset * secperblk; | |
262 | size = (label->cms.block_count - 1) * secperblk; | |
263 | } else { | |
264 | snprintf(tmp, sizeof(tmp), "CMS1/%8s:", name); | |
265 | strlcat(state->pp_buf, tmp, PAGE_SIZE); | |
266 | /* | |
267 | * Special case for FBA devices: | |
268 | * If an FBA device is CMS formatted with blocksize > 512 byte | |
269 | * and the DIAG discipline is used, then the CMS label is found | |
270 | * in sector 1 instead of block 1. However, the partition is | |
271 | * still supposed to start in block 2. | |
272 | */ | |
273 | if (labelsect == 1) | |
274 | offset = 2 * secperblk; | |
275 | else | |
276 | offset = labelsect + secperblk; | |
277 | size = label->cms.block_count * secperblk; | |
278 | } | |
279 | ||
280 | put_partition(state, 1, offset, size-offset); | |
281 | strlcat(state->pp_buf, "\n", PAGE_SIZE); | |
282 | return 1; | |
283 | } | |
284 | ||
285 | ||
1da177e4 | 286 | /* |
46e88947 | 287 | * This is the main function, called by check.c |
1da177e4 | 288 | */ |
1493bf21 | 289 | int ibm_partition(struct parsed_partitions *state) |
1da177e4 | 290 | { |
1493bf21 | 291 | struct block_device *bdev = state->bdev; |
b44b0ab3 | 292 | int blocksize, res; |
46e88947 | 293 | loff_t i_size, offset, size; |
bf1a95a2 | 294 | dasd_information2_t *info; |
1da177e4 LT |
295 | struct hd_geometry *geo; |
296 | char type[5] = {0,}; | |
297 | char name[7] = {0,}; | |
cffab6bc | 298 | sector_t labelsect; |
46e88947 | 299 | union label_t *label; |
1da177e4 | 300 | |
57881dd9 | 301 | res = 0; |
e1defc4f | 302 | blocksize = bdev_logical_block_size(bdev); |
90f0094d | 303 | if (blocksize <= 0) |
57881dd9 | 304 | goto out_exit; |
90f0094d HH |
305 | i_size = i_size_read(bdev->bd_inode); |
306 | if (i_size == 0) | |
57881dd9 | 307 | goto out_exit; |
bf1a95a2 SH |
308 | info = kmalloc(sizeof(dasd_information2_t), GFP_KERNEL); |
309 | if (info == NULL) | |
57881dd9 | 310 | goto out_exit; |
bf1a95a2 SH |
311 | geo = kmalloc(sizeof(struct hd_geometry), GFP_KERNEL); |
312 | if (geo == NULL) | |
1da177e4 | 313 | goto out_nogeo; |
bf1a95a2 SH |
314 | label = kmalloc(sizeof(union label_t), GFP_KERNEL); |
315 | if (label == NULL) | |
56dc6a88 | 316 | goto out_nolab; |
46e88947 | 317 | if (ioctl_by_bdev(bdev, HDIO_GETGEO, (unsigned long)geo) != 0) |
57881dd9 | 318 | goto out_freeall; |
46e88947 SW |
319 | if (ioctl_by_bdev(bdev, BIODASDINFO2, (unsigned long)info) != 0) { |
320 | kfree(info); | |
321 | info = NULL; | |
b44b0ab3 | 322 | } |
57881dd9 | 323 | |
46e88947 SW |
324 | if (find_label(state, info, geo, blocksize, &labelsect, name, type, |
325 | label)) { | |
326 | if (!strncmp(type, "VOL1", 4)) { | |
327 | res = find_vol1_partitions(state, geo, blocksize, name, | |
328 | label); | |
329 | } else if (!strncmp(type, "LNX1", 4)) { | |
330 | res = find_lnx1_partitions(state, geo, blocksize, name, | |
331 | label, labelsect, i_size, | |
332 | info); | |
333 | } else if (!strncmp(type, "CMS1", 4)) { | |
334 | res = find_cms1_partitions(state, geo, blocksize, name, | |
335 | label, labelsect); | |
b44b0ab3 | 336 | } |
46e88947 | 337 | } else if (info) { |
1da177e4 | 338 | /* |
46e88947 SW |
339 | * ugly but needed for backward compatibility: |
340 | * If the block device is a DASD (i.e. BIODASDINFO2 works), | |
341 | * then we claim it in any case, even though it has no valid | |
342 | * label. If it has the LDL format, then we simply define a | |
343 | * partition as if it had an LNX1 label. | |
1da177e4 | 344 | */ |
46e88947 SW |
345 | res = 1; |
346 | if (info->format == DASD_FORMAT_LDL) { | |
347 | strlcat(state->pp_buf, "(nonl)", PAGE_SIZE); | |
348 | size = i_size >> 9; | |
349 | offset = (info->label_block + 1) * (blocksize >> 9); | |
350 | put_partition(state, 1, offset, size-offset); | |
351 | strlcat(state->pp_buf, "\n", PAGE_SIZE); | |
352 | } | |
353 | } else | |
354 | res = 0; | |
ef1597d5 | 355 | |
57881dd9 | 356 | out_freeall: |
56dc6a88 PO |
357 | kfree(label); |
358 | out_nolab: | |
1da177e4 LT |
359 | kfree(geo); |
360 | out_nogeo: | |
361 | kfree(info); | |
57881dd9 S |
362 | out_exit: |
363 | return res; | |
1da177e4 | 364 | } |