Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
2 | /* |
3 | * fs/partitions/amiga.c | |
4 | * | |
5 | * Code extracted from drivers/block/genhd.c | |
6 | * | |
7 | * Copyright (C) 1991-1998 Linus Torvalds | |
8 | * Re-organised Feb 1998 Russell King | |
9 | */ | |
10 | ||
600ffc5e FF |
11 | #define pr_fmt(fmt) fmt |
12 | ||
1da177e4 | 13 | #include <linux/types.h> |
b6f3f28f MS |
14 | #include <linux/mm_types.h> |
15 | #include <linux/overflow.h> | |
1da177e4 LT |
16 | #include <linux/affs_hardblocks.h> |
17 | ||
18 | #include "check.h" | |
1da177e4 | 19 | |
b6f3f28f MS |
20 | /* magic offsets in partition DosEnvVec */ |
21 | #define NR_HD 3 | |
22 | #define NR_SECT 5 | |
23 | #define LO_CYL 9 | |
24 | #define HI_CYL 10 | |
25 | ||
1da177e4 LT |
26 | static __inline__ u32 |
27 | checksum_block(__be32 *m, int size) | |
28 | { | |
29 | u32 sum = 0; | |
30 | ||
31 | while (size--) | |
32 | sum += be32_to_cpu(*m++); | |
33 | return sum; | |
34 | } | |
35 | ||
1493bf21 | 36 | int amiga_partition(struct parsed_partitions *state) |
1da177e4 LT |
37 | { |
38 | Sector sect; | |
39 | unsigned char *data; | |
40 | struct RigidDiskBlock *rdb; | |
41 | struct PartitionBlock *pb; | |
b6f3f28f MS |
42 | u64 start_sect, nr_sects; |
43 | sector_t blk, end_sect; | |
44 | u32 cylblk; /* rdb_CylBlocks = nr_heads*sect_per_track */ | |
45 | u32 nr_hd, nr_sect, lo_cyl, hi_cyl; | |
46 | int part, res = 0; | |
47 | unsigned int blksize = 1; /* Multiplier for disk block size */ | |
1da177e4 | 48 | int slot = 1; |
1da177e4 LT |
49 | |
50 | for (blk = 0; ; blk++, put_dev_sector(sect)) { | |
51 | if (blk == RDB_ALLOCATION_LIMIT) | |
52 | goto rdb_done; | |
1493bf21 | 53 | data = read_part_sector(state, blk, §); |
1da177e4 | 54 | if (!data) { |
b6f3f28f | 55 | pr_err("Dev %s: unable to read RDB block %llu\n", |
a08aa9bc | 56 | state->disk->disk_name, blk); |
57881dd9 | 57 | res = -1; |
1da177e4 LT |
58 | goto rdb_done; |
59 | } | |
60 | if (*(__be32 *)data != cpu_to_be32(IDNAME_RIGIDDISK)) | |
61 | continue; | |
62 | ||
63 | rdb = (struct RigidDiskBlock *)data; | |
64 | if (checksum_block((__be32 *)data, be32_to_cpu(rdb->rdb_SummedLongs) & 0x7F) == 0) | |
65 | break; | |
66 | /* Try again with 0xdc..0xdf zeroed, Windows might have | |
67 | * trashed it. | |
68 | */ | |
69 | *(__be32 *)(data+0xdc) = 0; | |
70 | if (checksum_block((__be32 *)data, | |
71 | be32_to_cpu(rdb->rdb_SummedLongs) & 0x7F)==0) { | |
b6f3f28f | 72 | pr_err("Trashed word at 0xd0 in block %llu ignored in checksum calculation\n", |
600ffc5e | 73 | blk); |
1da177e4 LT |
74 | break; |
75 | } | |
76 | ||
b6f3f28f | 77 | pr_err("Dev %s: RDB in block %llu has bad checksum\n", |
a08aa9bc | 78 | state->disk->disk_name, blk); |
1da177e4 LT |
79 | } |
80 | ||
81 | /* blksize is blocks per 512 byte standard block */ | |
82 | blksize = be32_to_cpu( rdb->rdb_BlockBytes ) / 512; | |
83 | ||
9c867fbe AD |
84 | { |
85 | char tmp[7 + 10 + 1 + 1]; | |
86 | ||
87 | /* Be more informative */ | |
88 | snprintf(tmp, sizeof(tmp), " RDSK (%d)", blksize * 512); | |
89 | strlcat(state->pp_buf, tmp, PAGE_SIZE); | |
90 | } | |
1da177e4 LT |
91 | blk = be32_to_cpu(rdb->rdb_PartitionList); |
92 | put_dev_sector(sect); | |
7eb1e476 | 93 | for (part = 1; (s32) blk>0 && part<=16; part++, put_dev_sector(sect)) { |
b6f3f28f MS |
94 | /* Read in terms partition table understands */ |
95 | if (check_mul_overflow(blk, (sector_t) blksize, &blk)) { | |
96 | pr_err("Dev %s: overflow calculating partition block %llu! Skipping partitions %u and beyond\n", | |
97 | state->disk->disk_name, blk, part); | |
98 | break; | |
99 | } | |
1493bf21 | 100 | data = read_part_sector(state, blk, §); |
1da177e4 | 101 | if (!data) { |
b6f3f28f | 102 | pr_err("Dev %s: unable to read partition block %llu\n", |
a08aa9bc | 103 | state->disk->disk_name, blk); |
57881dd9 | 104 | res = -1; |
1da177e4 LT |
105 | goto rdb_done; |
106 | } | |
107 | pb = (struct PartitionBlock *)data; | |
108 | blk = be32_to_cpu(pb->pb_Next); | |
109 | if (pb->pb_ID != cpu_to_be32(IDNAME_PARTITION)) | |
110 | continue; | |
111 | if (checksum_block((__be32 *)pb, be32_to_cpu(pb->pb_SummedLongs) & 0x7F) != 0 ) | |
112 | continue; | |
113 | ||
b6f3f28f MS |
114 | /* RDB gives us more than enough rope to hang ourselves with, |
115 | * many times over (2^128 bytes if all fields max out). | |
116 | * Some careful checks are in order, so check for potential | |
117 | * overflows. | |
118 | * We are multiplying four 32 bit numbers to one sector_t! | |
119 | */ | |
120 | ||
121 | nr_hd = be32_to_cpu(pb->pb_Environment[NR_HD]); | |
122 | nr_sect = be32_to_cpu(pb->pb_Environment[NR_SECT]); | |
123 | ||
124 | /* CylBlocks is total number of blocks per cylinder */ | |
125 | if (check_mul_overflow(nr_hd, nr_sect, &cylblk)) { | |
126 | pr_err("Dev %s: heads*sects %u overflows u32, skipping partition!\n", | |
127 | state->disk->disk_name, cylblk); | |
128 | continue; | |
129 | } | |
130 | ||
131 | /* check for consistency with RDB defined CylBlocks */ | |
132 | if (cylblk > be32_to_cpu(rdb->rdb_CylBlocks)) { | |
133 | pr_warn("Dev %s: cylblk %u > rdb_CylBlocks %u!\n", | |
134 | state->disk->disk_name, cylblk, | |
135 | be32_to_cpu(rdb->rdb_CylBlocks)); | |
136 | } | |
137 | ||
138 | /* RDB allows for variable logical block size - | |
139 | * normalize to 512 byte blocks and check result. | |
140 | */ | |
141 | ||
142 | if (check_mul_overflow(cylblk, blksize, &cylblk)) { | |
143 | pr_err("Dev %s: partition %u bytes per cyl. overflows u32, skipping partition!\n", | |
144 | state->disk->disk_name, part); | |
145 | continue; | |
146 | } | |
147 | ||
148 | /* Calculate partition start and end. Limit of 32 bit on cylblk | |
149 | * guarantees no overflow occurs if LBD support is enabled. | |
150 | */ | |
151 | ||
152 | lo_cyl = be32_to_cpu(pb->pb_Environment[LO_CYL]); | |
153 | start_sect = ((u64) lo_cyl * cylblk); | |
154 | ||
155 | hi_cyl = be32_to_cpu(pb->pb_Environment[HI_CYL]); | |
156 | nr_sects = (((u64) hi_cyl - lo_cyl + 1) * cylblk); | |
1da177e4 | 157 | |
1da177e4 LT |
158 | if (!nr_sects) |
159 | continue; | |
b6f3f28f MS |
160 | |
161 | /* Warn user if partition end overflows u32 (AmigaDOS limit) */ | |
162 | ||
163 | if ((start_sect + nr_sects) > UINT_MAX) { | |
164 | pr_warn("Dev %s: partition %u (%llu-%llu) needs 64 bit device support!\n", | |
165 | state->disk->disk_name, part, | |
166 | start_sect, start_sect + nr_sects); | |
167 | } | |
168 | ||
169 | if (check_add_overflow(start_sect, nr_sects, &end_sect)) { | |
170 | pr_err("Dev %s: partition %u (%llu-%llu) needs LBD device support, skipping partition!\n", | |
171 | state->disk->disk_name, part, | |
172 | start_sect, end_sect); | |
173 | continue; | |
174 | } | |
175 | ||
176 | /* Tell Kernel about it */ | |
177 | ||
1da177e4 LT |
178 | put_partition(state,slot++,start_sect,nr_sects); |
179 | { | |
180 | /* Be even more informative to aid mounting */ | |
181 | char dostype[4]; | |
9c867fbe AD |
182 | char tmp[42]; |
183 | ||
1da177e4 LT |
184 | __be32 *dt = (__be32 *)dostype; |
185 | *dt = pb->pb_Environment[16]; | |
186 | if (dostype[3] < ' ') | |
9c867fbe | 187 | snprintf(tmp, sizeof(tmp), " (%c%c%c^%c)", |
1da177e4 LT |
188 | dostype[0], dostype[1], |
189 | dostype[2], dostype[3] + '@' ); | |
190 | else | |
9c867fbe | 191 | snprintf(tmp, sizeof(tmp), " (%c%c%c%c)", |
1da177e4 LT |
192 | dostype[0], dostype[1], |
193 | dostype[2], dostype[3]); | |
9c867fbe AD |
194 | strlcat(state->pp_buf, tmp, PAGE_SIZE); |
195 | snprintf(tmp, sizeof(tmp), "(res %d spb %d)", | |
1da177e4 LT |
196 | be32_to_cpu(pb->pb_Environment[6]), |
197 | be32_to_cpu(pb->pb_Environment[4])); | |
9c867fbe | 198 | strlcat(state->pp_buf, tmp, PAGE_SIZE); |
1da177e4 LT |
199 | } |
200 | res = 1; | |
201 | } | |
9c867fbe | 202 | strlcat(state->pp_buf, "\n", PAGE_SIZE); |
1da177e4 LT |
203 | |
204 | rdb_done: | |
205 | return res; | |
206 | } |