Commit | Line | Data |
---|---|---|
a1d312de | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
1da177e4 LT |
2 | /* |
3 | * mst.c - NTFS multi sector transfer protection handling code. Part of the | |
4 | * Linux-NTFS project. | |
5 | * | |
6 | * Copyright (c) 2001-2004 Anton Altaparmakov | |
1da177e4 LT |
7 | */ |
8 | ||
9 | #include "ntfs.h" | |
10 | ||
11 | /** | |
12 | * post_read_mst_fixup - deprotect multi sector transfer protected data | |
13 | * @b: pointer to the data to deprotect | |
14 | * @size: size in bytes of @b | |
15 | * | |
16 | * Perform the necessary post read multi sector transfer fixup and detect the | |
17 | * presence of incomplete multi sector transfers. - In that case, overwrite the | |
18 | * magic of the ntfs record header being processed with "BAAD" (in memory only!) | |
19 | * and abort processing. | |
20 | * | |
21 | * Return 0 on success and -EINVAL on error ("BAAD" magic will be present). | |
22 | * | |
23 | * NOTE: We consider the absence / invalidity of an update sequence array to | |
24 | * mean that the structure is not protected at all and hence doesn't need to | |
25 | * be fixed up. Thus, we return success and not failure in this case. This is | |
26 | * in contrast to pre_write_mst_fixup(), see below. | |
27 | */ | |
28 | int post_read_mst_fixup(NTFS_RECORD *b, const u32 size) | |
29 | { | |
30 | u16 usa_ofs, usa_count, usn; | |
31 | u16 *usa_pos, *data_pos; | |
32 | ||
33 | /* Setup the variables. */ | |
34 | usa_ofs = le16_to_cpu(b->usa_ofs); | |
35 | /* Decrement usa_count to get number of fixups. */ | |
36 | usa_count = le16_to_cpu(b->usa_count) - 1; | |
37 | /* Size and alignment checks. */ | |
38 | if ( size & (NTFS_BLOCK_SIZE - 1) || | |
39 | usa_ofs & 1 || | |
40 | usa_ofs + (usa_count * 2) > size || | |
41 | (size >> NTFS_BLOCK_SIZE_BITS) != usa_count) | |
42 | return 0; | |
43 | /* Position of usn in update sequence array. */ | |
44 | usa_pos = (u16*)b + usa_ofs/sizeof(u16); | |
45 | /* | |
46 | * The update sequence number which has to be equal to each of the | |
47 | * u16 values before they are fixed up. Note no need to care for | |
48 | * endianness since we are comparing and moving data for on disk | |
49 | * structures which means the data is consistent. - If it is | |
50 | * consistenty the wrong endianness it doesn't make any difference. | |
51 | */ | |
52 | usn = *usa_pos; | |
53 | /* | |
54 | * Position in protected data of first u16 that needs fixing up. | |
55 | */ | |
56 | data_pos = (u16*)b + NTFS_BLOCK_SIZE/sizeof(u16) - 1; | |
57 | /* | |
58 | * Check for incomplete multi sector transfer(s). | |
59 | */ | |
60 | while (usa_count--) { | |
61 | if (*data_pos != usn) { | |
62 | /* | |
63 | * Incomplete multi sector transfer detected! )-: | |
64 | * Set the magic to "BAAD" and return failure. | |
65 | * Note that magic_BAAD is already converted to le32. | |
66 | */ | |
67 | b->magic = magic_BAAD; | |
68 | return -EINVAL; | |
69 | } | |
70 | data_pos += NTFS_BLOCK_SIZE/sizeof(u16); | |
71 | } | |
72 | /* Re-setup the variables. */ | |
73 | usa_count = le16_to_cpu(b->usa_count) - 1; | |
74 | data_pos = (u16*)b + NTFS_BLOCK_SIZE/sizeof(u16) - 1; | |
75 | /* Fixup all sectors. */ | |
76 | while (usa_count--) { | |
77 | /* | |
78 | * Increment position in usa and restore original data from | |
79 | * the usa into the data buffer. | |
80 | */ | |
81 | *data_pos = *(++usa_pos); | |
82 | /* Increment position in data as well. */ | |
83 | data_pos += NTFS_BLOCK_SIZE/sizeof(u16); | |
84 | } | |
85 | return 0; | |
86 | } | |
87 | ||
88 | /** | |
89 | * pre_write_mst_fixup - apply multi sector transfer protection | |
90 | * @b: pointer to the data to protect | |
91 | * @size: size in bytes of @b | |
92 | * | |
93 | * Perform the necessary pre write multi sector transfer fixup on the data | |
94 | * pointer to by @b of @size. | |
95 | * | |
96 | * Return 0 if fixup applied (success) or -EINVAL if no fixup was performed | |
97 | * (assumed not needed). This is in contrast to post_read_mst_fixup() above. | |
98 | * | |
99 | * NOTE: We consider the absence / invalidity of an update sequence array to | |
100 | * mean that the structure is not subject to protection and hence doesn't need | |
101 | * to be fixed up. This means that you have to create a valid update sequence | |
102 | * array header in the ntfs record before calling this function, otherwise it | |
103 | * will fail (the header needs to contain the position of the update sequence | |
104 | * array together with the number of elements in the array). You also need to | |
105 | * initialise the update sequence number before calling this function | |
106 | * otherwise a random word will be used (whatever was in the record at that | |
107 | * position at that time). | |
108 | */ | |
109 | int pre_write_mst_fixup(NTFS_RECORD *b, const u32 size) | |
110 | { | |
111 | le16 *usa_pos, *data_pos; | |
112 | u16 usa_ofs, usa_count, usn; | |
113 | le16 le_usn; | |
114 | ||
115 | /* Sanity check + only fixup if it makes sense. */ | |
116 | if (!b || ntfs_is_baad_record(b->magic) || | |
117 | ntfs_is_hole_record(b->magic)) | |
118 | return -EINVAL; | |
119 | /* Setup the variables. */ | |
120 | usa_ofs = le16_to_cpu(b->usa_ofs); | |
121 | /* Decrement usa_count to get number of fixups. */ | |
122 | usa_count = le16_to_cpu(b->usa_count) - 1; | |
123 | /* Size and alignment checks. */ | |
124 | if ( size & (NTFS_BLOCK_SIZE - 1) || | |
125 | usa_ofs & 1 || | |
126 | usa_ofs + (usa_count * 2) > size || | |
127 | (size >> NTFS_BLOCK_SIZE_BITS) != usa_count) | |
128 | return -EINVAL; | |
129 | /* Position of usn in update sequence array. */ | |
130 | usa_pos = (le16*)((u8*)b + usa_ofs); | |
131 | /* | |
132 | * Cyclically increment the update sequence number | |
133 | * (skipping 0 and -1, i.e. 0xffff). | |
134 | */ | |
135 | usn = le16_to_cpup(usa_pos) + 1; | |
136 | if (usn == 0xffff || !usn) | |
137 | usn = 1; | |
138 | le_usn = cpu_to_le16(usn); | |
139 | *usa_pos = le_usn; | |
140 | /* Position in data of first u16 that needs fixing up. */ | |
141 | data_pos = (le16*)b + NTFS_BLOCK_SIZE/sizeof(le16) - 1; | |
142 | /* Fixup all sectors. */ | |
143 | while (usa_count--) { | |
144 | /* | |
145 | * Increment the position in the usa and save the | |
146 | * original data from the data buffer into the usa. | |
147 | */ | |
148 | *(++usa_pos) = *data_pos; | |
149 | /* Apply fixup to data. */ | |
150 | *data_pos = le_usn; | |
151 | /* Increment position in data as well. */ | |
152 | data_pos += NTFS_BLOCK_SIZE/sizeof(le16); | |
153 | } | |
154 | return 0; | |
155 | } | |
156 | ||
157 | /** | |
158 | * post_write_mst_fixup - fast deprotect multi sector transfer protected data | |
159 | * @b: pointer to the data to deprotect | |
160 | * | |
161 | * Perform the necessary post write multi sector transfer fixup, not checking | |
162 | * for any errors, because we assume we have just used pre_write_mst_fixup(), | |
163 | * thus the data will be fine or we would never have gotten here. | |
164 | */ | |
165 | void post_write_mst_fixup(NTFS_RECORD *b) | |
166 | { | |
167 | le16 *usa_pos, *data_pos; | |
168 | ||
169 | u16 usa_ofs = le16_to_cpu(b->usa_ofs); | |
170 | u16 usa_count = le16_to_cpu(b->usa_count) - 1; | |
171 | ||
172 | /* Position of usn in update sequence array. */ | |
173 | usa_pos = (le16*)b + usa_ofs/sizeof(le16); | |
174 | ||
175 | /* Position in protected data of first u16 that needs fixing up. */ | |
176 | data_pos = (le16*)b + NTFS_BLOCK_SIZE/sizeof(le16) - 1; | |
177 | ||
178 | /* Fixup all sectors. */ | |
179 | while (usa_count--) { | |
180 | /* | |
181 | * Increment position in usa and restore original data from | |
182 | * the usa into the data buffer. | |
183 | */ | |
184 | *data_pos = *(++usa_pos); | |
185 | ||
186 | /* Increment position in data as well. */ | |
187 | data_pos += NTFS_BLOCK_SIZE/sizeof(le16); | |
188 | } | |
189 | } |