1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * attrib.c - NTFS attribute operations. Part of the Linux-NTFS project. |
4 | * |
5 | * Copyright (c) 2001-2012 Anton Altaparmakov and Tuxera Inc. |
6 | * Copyright (c) 2002 Richard Russon |
7 | */ |
8 | |
9 | #include <linux/buffer_head.h> |
10 | #include <linux/sched.h> |
11 | #include <linux/slab.h> |
12 | #include <linux/swap.h> |
13 | #include <linux/writeback.h> |
14 | |
15 | #include "attrib.h" |
16 | #include "debug.h" |
17 | #include "layout.h" |
18 | #include "lcnalloc.h" |
19 | #include "malloc.h" |
20 | #include "mft.h" |
21 | #include "ntfs.h" |
22 | #include "types.h" |
23 | |
24 | /** |
25 | * ntfs_map_runlist_nolock - map (a part of) a runlist of an ntfs inode |
26 | * @ni: ntfs inode for which to map (part of) a runlist |
27 | * @vcn: map runlist part containing this vcn |
28 | * @ctx: active attribute search context if present or NULL if not |
29 | * |
30 | * Map the part of a runlist containing the @vcn of the ntfs inode @ni. |
31 | * |
32 | * If @ctx is specified, it is an active search context of @ni and its base mft |
33 | * record. This is needed when ntfs_map_runlist_nolock() encounters unmapped |
34 | * runlist fragments and allows their mapping. If you do not have the mft |
35 | * record mapped, you can specify @ctx as NULL and ntfs_map_runlist_nolock() |
36 | * will perform the necessary mapping and unmapping. |
37 | * |
38 | * Note, ntfs_map_runlist_nolock() saves the state of @ctx on entry and |
39 | * restores it before returning. Thus, @ctx will be left pointing to the same |
40 | * attribute on return as on entry. However, the actual pointers in @ctx may |
41 | * point to different memory locations on return, so you must remember to reset |
42 | * any cached pointers from the @ctx, i.e. after the call to |
43 | * ntfs_map_runlist_nolock(), you will probably want to do: |
44 | * m = ctx->mrec; |
45 | * a = ctx->attr; |
46 | * Assuming you cache ctx->attr in a variable @a of type ATTR_RECORD * and that |
47 | * you cache ctx->mrec in a variable @m of type MFT_RECORD *. |
48 | * |
49 | * Return 0 on success and -errno on error. There is one special error code |
50 | * which is not an error as such. This is -ENOENT. It means that @vcn is out |
51 | * of bounds of the runlist. |
52 | * |
53 | * Note the runlist can be NULL after this function returns if @vcn is zero and |
54 | * the attribute has zero allocated size, i.e. there simply is no runlist. |
55 | * |
56 | * WARNING: If @ctx is supplied, regardless of whether success or failure is |
57 | * returned, you need to check IS_ERR(@ctx->mrec) and if 'true' the @ctx |
58 | * is no longer valid, i.e. you need to either call |
59 | * ntfs_attr_reinit_search_ctx() or ntfs_attr_put_search_ctx() on it. |
60 | * In that case PTR_ERR(@ctx->mrec) will give you the error code for |
61 | * why the mapping of the old inode failed. |
62 | * |
63 | * Locking: - The runlist described by @ni must be locked for writing on entry |
64 | * and is locked on return. Note the runlist will be modified. |
65 | * - If @ctx is NULL, the base mft record of @ni must not be mapped on |
66 | * entry and it will be left unmapped on return. |
67 | * - If @ctx is not NULL, the base mft record must be mapped on entry |
68 | * and it will be left mapped on return. |
69 | */ |
70 | int ntfs_map_runlist_nolock(ntfs_inode *ni, VCN vcn, ntfs_attr_search_ctx *ctx) |
71 | { |
72 | VCN end_vcn; |
73 | unsigned long flags; |
74 | ntfs_inode *base_ni; |
75 | MFT_RECORD *m; |
76 | ATTR_RECORD *a; |
77 | runlist_element *rl; |
78 | struct page *put_this_page = NULL; |
79 | int err = 0; |
80 | bool ctx_is_temporary, ctx_needs_reset; |
81 | ntfs_attr_search_ctx old_ctx = { NULL, }; |
82 | |
83 | ntfs_debug("Mapping runlist part containing vcn 0x%llx." , |
84 | (unsigned long long)vcn); |
85 | if (!NInoAttr(ni)) |
86 | base_ni = ni; |
87 | else |
88 | base_ni = ni->ext.base_ntfs_ino; |
89 | if (!ctx) { |
90 | ctx_is_temporary = ctx_needs_reset = true; |
91 | m = map_mft_record(ni: base_ni); |
92 | if (IS_ERR(ptr: m)) |
93 | return PTR_ERR(ptr: m); |
94 | ctx = ntfs_attr_get_search_ctx(ni: base_ni, mrec: m); |
95 | if (unlikely(!ctx)) { |
96 | err = -ENOMEM; |
97 | goto err_out; |
98 | } |
99 | } else { |
100 | VCN allocated_size_vcn; |
101 | |
102 | BUG_ON(IS_ERR(ctx->mrec)); |
103 | a = ctx->attr; |
104 | BUG_ON(!a->non_resident); |
105 | ctx_is_temporary = false; |
106 | end_vcn = sle64_to_cpu(x: a->data.non_resident.highest_vcn); |
107 | read_lock_irqsave(&ni->size_lock, flags); |
108 | allocated_size_vcn = ni->allocated_size >> |
109 | ni->vol->cluster_size_bits; |
110 | read_unlock_irqrestore(&ni->size_lock, flags); |
111 | if (!a->data.non_resident.lowest_vcn && end_vcn <= 0) |
112 | end_vcn = allocated_size_vcn - 1; |
113 | /* |
114 | * If we already have the attribute extent containing @vcn in |
115 | * @ctx, no need to look it up again. We slightly cheat in |
116 | * that if vcn exceeds the allocated size, we will refuse to |
117 | * map the runlist below, so there is definitely no need to get |
118 | * the right attribute extent. |
119 | */ |
120 | if (vcn >= allocated_size_vcn || (a->type == ni->type && |
121 | a->name_length == ni->name_len && |
122 | !memcmp(p: (u8*)a + le16_to_cpu(a->name_offset), |
123 | q: ni->name, size: ni->name_len) && |
124 | sle64_to_cpu(x: a->data.non_resident.lowest_vcn) |
125 | <= vcn && end_vcn >= vcn)) |
126 | ctx_needs_reset = false; |
127 | else { |
128 | /* Save the old search context. */ |
129 | old_ctx = *ctx; |
130 | /* |
131 | * If the currently mapped (extent) inode is not the |
132 | * base inode we will unmap it when we reinitialize the |
133 | * search context which means we need to get a |
134 | * reference to the page containing the mapped mft |
135 | * record so we do not accidentally drop changes to the |
136 | * mft record when it has not been marked dirty yet. |
137 | */ |
138 | if (old_ctx.base_ntfs_ino && old_ctx.ntfs_ino != |
139 | old_ctx.base_ntfs_ino) { |
140 | put_this_page = old_ctx.ntfs_ino->page; |
141 | get_page(page: put_this_page); |
142 | } |
143 | /* |
144 | * Reinitialize the search context so we can lookup the |
145 | * needed attribute extent. |
146 | */ |
147 | ntfs_attr_reinit_search_ctx(ctx); |
148 | ctx_needs_reset = true; |
149 | } |
150 | } |
151 | if (ctx_needs_reset) { |
152 | err = ntfs_attr_lookup(type: ni->type, name: ni->name, name_len: ni->name_len, |
153 | ic: CASE_SENSITIVE, lowest_vcn: vcn, NULL, val_len: 0, ctx); |
154 | if (unlikely(err)) { |
155 | if (err == -ENOENT) |
156 | err = -EIO; |
157 | goto err_out; |
158 | } |
159 | BUG_ON(!ctx->attr->non_resident); |
160 | } |
161 | a = ctx->attr; |
162 | /* |
163 | * Only decompress the mapping pairs if @vcn is inside it. Otherwise |
164 | * we get into problems when we try to map an out of bounds vcn because |
165 | * we then try to map the already mapped runlist fragment and |
166 | * ntfs_mapping_pairs_decompress() fails. |
167 | */ |
168 | end_vcn = sle64_to_cpu(x: a->data.non_resident.highest_vcn) + 1; |
169 | if (unlikely(vcn && vcn >= end_vcn)) { |
170 | err = -ENOENT; |
171 | goto err_out; |
172 | } |
173 | rl = ntfs_mapping_pairs_decompress(vol: ni->vol, attr: a, old_rl: ni->runlist.rl); |
174 | if (IS_ERR(ptr: rl)) |
175 | err = PTR_ERR(ptr: rl); |
176 | else |
177 | ni->runlist.rl = rl; |
178 | err_out: |
179 | if (ctx_is_temporary) { |
180 | if (likely(ctx)) |
181 | ntfs_attr_put_search_ctx(ctx); |
182 | unmap_mft_record(ni: base_ni); |
183 | } else if (ctx_needs_reset) { |
184 | /* |
185 | * If there is no attribute list, restoring the search context |
186 | * is accomplished simply by copying the saved context back over |
187 | * the caller supplied context. If there is an attribute list, |
188 | * things are more complicated as we need to deal with mapping |
189 | * of mft records and resulting potential changes in pointers. |
190 | */ |
191 | if (NInoAttrList(ni: base_ni)) { |
192 | /* |
193 | * If the currently mapped (extent) inode is not the |
194 | * one we had before, we need to unmap it and map the |
195 | * old one. |
196 | */ |
197 | if (ctx->ntfs_ino != old_ctx.ntfs_ino) { |
198 | /* |
199 | * If the currently mapped inode is not the |
200 | * base inode, unmap it. |
201 | */ |
202 | if (ctx->base_ntfs_ino && ctx->ntfs_ino != |
203 | ctx->base_ntfs_ino) { |
204 | unmap_extent_mft_record(ni: ctx->ntfs_ino); |
205 | ctx->mrec = ctx->base_mrec; |
206 | BUG_ON(!ctx->mrec); |
207 | } |
208 | /* |
209 | * If the old mapped inode is not the base |
210 | * inode, map it. |
211 | */ |
212 | if (old_ctx.base_ntfs_ino && |
213 | old_ctx.ntfs_ino != |
214 | old_ctx.base_ntfs_ino) { |
215 | retry_map: |
216 | ctx->mrec = map_mft_record( |
217 | ni: old_ctx.ntfs_ino); |
218 | /* |
219 | * Something bad has happened. If out |
220 | * of memory retry till it succeeds. |
221 | * Any other errors are fatal and we |
222 | * return the error code in ctx->mrec. |
223 | * Let the caller deal with it... We |
224 | * just need to fudge things so the |
225 | * caller can reinit and/or put the |
226 | * search context safely. |
227 | */ |
228 | if (IS_ERR(ptr: ctx->mrec)) { |
229 | if (PTR_ERR(ptr: ctx->mrec) == |
230 | -ENOMEM) { |
231 | schedule(); |
232 | goto retry_map; |
233 | } else |
234 | old_ctx.ntfs_ino = |
235 | old_ctx. |
236 | base_ntfs_ino; |
237 | } |
238 | } |
239 | } |
240 | /* Update the changed pointers in the saved context. */ |
241 | if (ctx->mrec != old_ctx.mrec) { |
242 | if (!IS_ERR(ptr: ctx->mrec)) |
243 | old_ctx.attr = (ATTR_RECORD*)( |
244 | (u8*)ctx->mrec + |
245 | ((u8*)old_ctx.attr - |
246 | (u8*)old_ctx.mrec)); |
247 | old_ctx.mrec = ctx->mrec; |
248 | } |
249 | } |
250 | /* Restore the search context to the saved one. */ |
251 | *ctx = old_ctx; |
252 | /* |
253 | * We drop the reference on the page we took earlier. In the |
254 | * case that IS_ERR(ctx->mrec) is true this means we might lose |
255 | * some changes to the mft record that had been made between |
256 | * the last time it was marked dirty/written out and now. This |
257 | * at this stage is not a problem as the mapping error is fatal |
258 | * enough that the mft record cannot be written out anyway and |
259 | * the caller is very likely to shutdown the whole inode |
260 | * immediately and mark the volume dirty for chkdsk to pick up |
261 | * the pieces anyway. |
262 | */ |
263 | if (put_this_page) |
264 | put_page(page: put_this_page); |
265 | } |
266 | return err; |
267 | } |
268 | |
269 | /** |
270 | * ntfs_map_runlist - map (a part of) a runlist of an ntfs inode |
271 | * @ni: ntfs inode for which to map (part of) a runlist |
272 | * @vcn: map runlist part containing this vcn |
273 | * |
274 | * Map the part of a runlist containing the @vcn of the ntfs inode @ni. |
275 | * |
276 | * Return 0 on success and -errno on error. There is one special error code |
277 | * which is not an error as such. This is -ENOENT. It means that @vcn is out |
278 | * of bounds of the runlist. |
279 | * |
280 | * Locking: - The runlist must be unlocked on entry and is unlocked on return. |
281 | * - This function takes the runlist lock for writing and may modify |
282 | * the runlist. |
283 | */ |
284 | int ntfs_map_runlist(ntfs_inode *ni, VCN vcn) |
285 | { |
286 | int err = 0; |
287 | |
288 | down_write(sem: &ni->runlist.lock); |
289 | /* Make sure someone else didn't do the work while we were sleeping. */ |
290 | if (likely(ntfs_rl_vcn_to_lcn(ni->runlist.rl, vcn) <= |
291 | LCN_RL_NOT_MAPPED)) |
292 | err = ntfs_map_runlist_nolock(ni, vcn, NULL); |
293 | up_write(sem: &ni->runlist.lock); |
294 | return err; |
295 | } |
296 | |
297 | /** |
298 | * ntfs_attr_vcn_to_lcn_nolock - convert a vcn into a lcn given an ntfs inode |
299 | * @ni: ntfs inode of the attribute whose runlist to search |
300 | * @vcn: vcn to convert |
301 | * @write_locked: true if the runlist is locked for writing |
302 | * |
303 | * Find the virtual cluster number @vcn in the runlist of the ntfs attribute |
304 | * described by the ntfs inode @ni and return the corresponding logical cluster |
305 | * number (lcn). |
306 | * |
307 | * If the @vcn is not mapped yet, the attempt is made to map the attribute |
308 | * extent containing the @vcn and the vcn to lcn conversion is retried. |
309 | * |
310 | * If @write_locked is true the caller has locked the runlist for writing and |
311 | * if false for reading. |
312 | * |
313 | * Since lcns must be >= 0, we use negative return codes with special meaning: |
314 | * |
315 | * Return code Meaning / Description |
316 | * ========================================== |
317 | * LCN_HOLE Hole / not allocated on disk. |
318 | * LCN_ENOENT There is no such vcn in the runlist, i.e. @vcn is out of bounds. |
319 | * LCN_ENOMEM Not enough memory to map runlist. |
320 | * LCN_EIO Critical error (runlist/file is corrupt, i/o error, etc). |
321 | * |
322 | * Locking: - The runlist must be locked on entry and is left locked on return. |
323 | * - If @write_locked is 'false', i.e. the runlist is locked for reading, |
324 | * the lock may be dropped inside the function so you cannot rely on |
325 | * the runlist still being the same when this function returns. |
326 | */ |
327 | LCN ntfs_attr_vcn_to_lcn_nolock(ntfs_inode *ni, const VCN vcn, |
328 | const bool write_locked) |
329 | { |
330 | LCN lcn; |
331 | unsigned long flags; |
332 | bool is_retry = false; |
333 | |
334 | BUG_ON(!ni); |
335 | ntfs_debug("Entering for i_ino 0x%lx, vcn 0x%llx, %s_locked." , |
336 | ni->mft_no, (unsigned long long)vcn, |
337 | write_locked ? "write" : "read" ); |
338 | BUG_ON(!NInoNonResident(ni)); |
339 | BUG_ON(vcn < 0); |
340 | if (!ni->runlist.rl) { |
341 | read_lock_irqsave(&ni->size_lock, flags); |
342 | if (!ni->allocated_size) { |
343 | read_unlock_irqrestore(&ni->size_lock, flags); |
344 | return LCN_ENOENT; |
345 | } |
346 | read_unlock_irqrestore(&ni->size_lock, flags); |
347 | } |
348 | retry_remap: |
349 | /* Convert vcn to lcn. If that fails map the runlist and retry once. */ |
350 | lcn = ntfs_rl_vcn_to_lcn(rl: ni->runlist.rl, vcn); |
351 | if (likely(lcn >= LCN_HOLE)) { |
352 | ntfs_debug("Done, lcn 0x%llx." , (long long)lcn); |
353 | return lcn; |
354 | } |
355 | if (lcn != LCN_RL_NOT_MAPPED) { |
356 | if (lcn != LCN_ENOENT) |
357 | lcn = LCN_EIO; |
358 | } else if (!is_retry) { |
359 | int err; |
360 | |
361 | if (!write_locked) { |
362 | up_read(sem: &ni->runlist.lock); |
363 | down_write(sem: &ni->runlist.lock); |
364 | if (unlikely(ntfs_rl_vcn_to_lcn(ni->runlist.rl, vcn) != |
365 | LCN_RL_NOT_MAPPED)) { |
366 | up_write(sem: &ni->runlist.lock); |
367 | down_read(sem: &ni->runlist.lock); |
368 | goto retry_remap; |
369 | } |
370 | } |
371 | err = ntfs_map_runlist_nolock(ni, vcn, NULL); |
372 | if (!write_locked) { |
373 | up_write(sem: &ni->runlist.lock); |
374 | down_read(sem: &ni->runlist.lock); |
375 | } |
376 | if (likely(!err)) { |
377 | is_retry = true; |
378 | goto retry_remap; |
379 | } |
380 | if (err == -ENOENT) |
381 | lcn = LCN_ENOENT; |
382 | else if (err == -ENOMEM) |
383 | lcn = LCN_ENOMEM; |
384 | else |
385 | lcn = LCN_EIO; |
386 | } |
387 | if (lcn != LCN_ENOENT) |
388 | ntfs_error(ni->vol->sb, "Failed with error code %lli." , |
389 | (long long)lcn); |
390 | return lcn; |
391 | } |
392 | |
393 | /** |
394 | * ntfs_attr_find_vcn_nolock - find a vcn in the runlist of an ntfs inode |
395 | * @ni: ntfs inode describing the runlist to search |
396 | * @vcn: vcn to find |
397 | * @ctx: active attribute search context if present or NULL if not |
398 | * |
399 | * Find the virtual cluster number @vcn in the runlist described by the ntfs |
400 | * inode @ni and return the address of the runlist element containing the @vcn. |
401 | * |
402 | * If the @vcn is not mapped yet, the attempt is made to map the attribute |
403 | * extent containing the @vcn and the vcn to lcn conversion is retried. |
404 | * |
405 | * If @ctx is specified, it is an active search context of @ni and its base mft |
406 | * record. This is needed when ntfs_attr_find_vcn_nolock() encounters unmapped |
407 | * runlist fragments and allows their mapping. If you do not have the mft |
408 | * record mapped, you can specify @ctx as NULL and ntfs_attr_find_vcn_nolock() |
409 | * will perform the necessary mapping and unmapping. |
410 | * |
411 | * Note, ntfs_attr_find_vcn_nolock() saves the state of @ctx on entry and |
412 | * restores it before returning. Thus, @ctx will be left pointing to the same |
413 | * attribute on return as on entry. However, the actual pointers in @ctx may |
414 | * point to different memory locations on return, so you must remember to reset |
415 | * any cached pointers from the @ctx, i.e. after the call to |
416 | * ntfs_attr_find_vcn_nolock(), you will probably want to do: |
417 | * m = ctx->mrec; |
418 | * a = ctx->attr; |
419 | * Assuming you cache ctx->attr in a variable @a of type ATTR_RECORD * and that |
420 | * you cache ctx->mrec in a variable @m of type MFT_RECORD *. |
421 | * Note you need to distinguish between the lcn of the returned runlist element |
422 | * being >= 0 and LCN_HOLE. In the later case you have to return zeroes on |
423 | * read and allocate clusters on write. |
424 | * |
425 | * Return the runlist element containing the @vcn on success and |
426 | * ERR_PTR(-errno) on error. You need to test the return value with IS_ERR() |
427 | * to decide if the return is success or failure and PTR_ERR() to get to the |
428 | * error code if IS_ERR() is true. |
429 | * |
430 | * The possible error return codes are: |
431 | * -ENOENT - No such vcn in the runlist, i.e. @vcn is out of bounds. |
432 | * -ENOMEM - Not enough memory to map runlist. |
433 | * -EIO - Critical error (runlist/file is corrupt, i/o error, etc). |
434 | * |
435 | * WARNING: If @ctx is supplied, regardless of whether success or failure is |
436 | * returned, you need to check IS_ERR(@ctx->mrec) and if 'true' the @ctx |
437 | * is no longer valid, i.e. you need to either call |
438 | * ntfs_attr_reinit_search_ctx() or ntfs_attr_put_search_ctx() on it. |
439 | * In that case PTR_ERR(@ctx->mrec) will give you the error code for |
440 | * why the mapping of the old inode failed. |
441 | * |
442 | * Locking: - The runlist described by @ni must be locked for writing on entry |
443 | * and is locked on return. Note the runlist may be modified when |
444 | * needed runlist fragments need to be mapped. |
445 | * - If @ctx is NULL, the base mft record of @ni must not be mapped on |
446 | * entry and it will be left unmapped on return. |
447 | * - If @ctx is not NULL, the base mft record must be mapped on entry |
448 | * and it will be left mapped on return. |
449 | */ |
450 | runlist_element *ntfs_attr_find_vcn_nolock(ntfs_inode *ni, const VCN vcn, |
451 | ntfs_attr_search_ctx *ctx) |
452 | { |
453 | unsigned long flags; |
454 | runlist_element *rl; |
455 | int err = 0; |
456 | bool is_retry = false; |
457 | |
458 | BUG_ON(!ni); |
459 | ntfs_debug("Entering for i_ino 0x%lx, vcn 0x%llx, with%s ctx." , |
460 | ni->mft_no, (unsigned long long)vcn, ctx ? "" : "out" ); |
461 | BUG_ON(!NInoNonResident(ni)); |
462 | BUG_ON(vcn < 0); |
463 | if (!ni->runlist.rl) { |
464 | read_lock_irqsave(&ni->size_lock, flags); |
465 | if (!ni->allocated_size) { |
466 | read_unlock_irqrestore(&ni->size_lock, flags); |
467 | return ERR_PTR(error: -ENOENT); |
468 | } |
469 | read_unlock_irqrestore(&ni->size_lock, flags); |
470 | } |
471 | retry_remap: |
472 | rl = ni->runlist.rl; |
473 | if (likely(rl && vcn >= rl[0].vcn)) { |
474 | while (likely(rl->length)) { |
475 | if (unlikely(vcn < rl[1].vcn)) { |
476 | if (likely(rl->lcn >= LCN_HOLE)) { |
477 | ntfs_debug("Done." ); |
478 | return rl; |
479 | } |
480 | break; |
481 | } |
482 | rl++; |
483 | } |
484 | if (likely(rl->lcn != LCN_RL_NOT_MAPPED)) { |
485 | if (likely(rl->lcn == LCN_ENOENT)) |
486 | err = -ENOENT; |
487 | else |
488 | err = -EIO; |
489 | } |
490 | } |
491 | if (!err && !is_retry) { |
492 | /* |
493 | * If the search context is invalid we cannot map the unmapped |
494 | * region. |
495 | */ |
496 | if (IS_ERR(ptr: ctx->mrec)) |
497 | err = PTR_ERR(ptr: ctx->mrec); |
498 | else { |
499 | /* |
500 | * The @vcn is in an unmapped region, map the runlist |
501 | * and retry. |
502 | */ |
503 | err = ntfs_map_runlist_nolock(ni, vcn, ctx); |
504 | if (likely(!err)) { |
505 | is_retry = true; |
506 | goto retry_remap; |
507 | } |
508 | } |
509 | if (err == -EINVAL) |
510 | err = -EIO; |
511 | } else if (!err) |
512 | err = -EIO; |
513 | if (err != -ENOENT) |
514 | ntfs_error(ni->vol->sb, "Failed with error code %i." , err); |
515 | return ERR_PTR(error: err); |
516 | } |
517 | |
518 | /** |
519 | * ntfs_attr_find - find (next) attribute in mft record |
520 | * @type: attribute type to find |
521 | * @name: attribute name to find (optional, i.e. NULL means don't care) |
522 | * @name_len: attribute name length (only needed if @name present) |
523 | * @ic: IGNORE_CASE or CASE_SENSITIVE (ignored if @name not present) |
524 | * @val: attribute value to find (optional, resident attributes only) |
525 | * @val_len: attribute value length |
526 | * @ctx: search context with mft record and attribute to search from |
527 | * |
528 | * You should not need to call this function directly. Use ntfs_attr_lookup() |
529 | * instead. |
530 | * |
531 | * ntfs_attr_find() takes a search context @ctx as parameter and searches the |
532 | * mft record specified by @ctx->mrec, beginning at @ctx->attr, for an |
533 | * attribute of @type, optionally @name and @val. |
534 | * |
535 | * If the attribute is found, ntfs_attr_find() returns 0 and @ctx->attr will |
536 | * point to the found attribute. |
537 | * |
538 | * If the attribute is not found, ntfs_attr_find() returns -ENOENT and |
539 | * @ctx->attr will point to the attribute before which the attribute being |
540 | * searched for would need to be inserted if such an action were to be desired. |
541 | * |
542 | * On actual error, ntfs_attr_find() returns -EIO. In this case @ctx->attr is |
543 | * undefined and in particular do not rely on it not changing. |
544 | * |
545 | * If @ctx->is_first is 'true', the search begins with @ctx->attr itself. If it |
546 | * is 'false', the search begins after @ctx->attr. |
547 | * |
548 | * If @ic is IGNORE_CASE, the @name comparisson is not case sensitive and |
549 | * @ctx->ntfs_ino must be set to the ntfs inode to which the mft record |
550 | * @ctx->mrec belongs. This is so we can get at the ntfs volume and hence at |
551 | * the upcase table. If @ic is CASE_SENSITIVE, the comparison is case |
552 | * sensitive. When @name is present, @name_len is the @name length in Unicode |
553 | * characters. |
554 | * |
555 | * If @name is not present (NULL), we assume that the unnamed attribute is |
556 | * being searched for. |
557 | * |
558 | * Finally, the resident attribute value @val is looked for, if present. If |
559 | * @val is not present (NULL), @val_len is ignored. |
560 | * |
561 | * ntfs_attr_find() only searches the specified mft record and it ignores the |
562 | * presence of an attribute list attribute (unless it is the one being searched |
563 | * for, obviously). If you need to take attribute lists into consideration, |
564 | * use ntfs_attr_lookup() instead (see below). This also means that you cannot |
565 | * use ntfs_attr_find() to search for extent records of non-resident |
566 | * attributes, as extents with lowest_vcn != 0 are usually described by the |
567 | * attribute list attribute only. - Note that it is possible that the first |
568 | * extent is only in the attribute list while the last extent is in the base |
569 | * mft record, so do not rely on being able to find the first extent in the |
570 | * base mft record. |
571 | * |
572 | * Warning: Never use @val when looking for attribute types which can be |
573 | * non-resident as this most likely will result in a crash! |
574 | */ |
575 | static int ntfs_attr_find(const ATTR_TYPE type, const ntfschar *name, |
576 | const u32 name_len, const IGNORE_CASE_BOOL ic, |
577 | const u8 *val, const u32 val_len, ntfs_attr_search_ctx *ctx) |
578 | { |
579 | ATTR_RECORD *a; |
580 | ntfs_volume *vol = ctx->ntfs_ino->vol; |
581 | ntfschar *upcase = vol->upcase; |
582 | u32 upcase_len = vol->upcase_len; |
583 | |
584 | /* |
585 | * Iterate over attributes in mft record starting at @ctx->attr, or the |
586 | * attribute following that, if @ctx->is_first is 'true'. |
587 | */ |
588 | if (ctx->is_first) { |
589 | a = ctx->attr; |
590 | ctx->is_first = false; |
591 | } else |
592 | a = (ATTR_RECORD*)((u8*)ctx->attr + |
593 | le32_to_cpu(ctx->attr->length)); |
594 | for (;; a = (ATTR_RECORD*)((u8*)a + le32_to_cpu(a->length))) { |
595 | u8 *mrec_end = (u8 *)ctx->mrec + |
596 | le32_to_cpu(ctx->mrec->bytes_allocated); |
597 | u8 *name_end; |
598 | |
599 | /* check whether ATTR_RECORD wrap */ |
600 | if ((u8 *)a < (u8 *)ctx->mrec) |
601 | break; |
602 | |
603 | /* check whether Attribute Record Header is within bounds */ |
604 | if ((u8 *)a > mrec_end || |
605 | (u8 *)a + sizeof(ATTR_RECORD) > mrec_end) |
606 | break; |
607 | |
608 | /* check whether ATTR_RECORD's name is within bounds */ |
609 | name_end = (u8 *)a + le16_to_cpu(a->name_offset) + |
610 | a->name_length * sizeof(ntfschar); |
611 | if (name_end > mrec_end) |
612 | break; |
613 | |
614 | ctx->attr = a; |
615 | if (unlikely(le32_to_cpu(a->type) > le32_to_cpu(type) || |
616 | a->type == AT_END)) |
617 | return -ENOENT; |
618 | if (unlikely(!a->length)) |
619 | break; |
620 | |
621 | /* check whether ATTR_RECORD's length wrap */ |
622 | if ((u8 *)a + le32_to_cpu(a->length) < (u8 *)a) |
623 | break; |
624 | /* check whether ATTR_RECORD's length is within bounds */ |
625 | if ((u8 *)a + le32_to_cpu(a->length) > mrec_end) |
626 | break; |
627 | |
628 | if (a->type != type) |
629 | continue; |
630 | /* |
631 | * If @name is present, compare the two names. If @name is |
632 | * missing, assume we want an unnamed attribute. |
633 | */ |
634 | if (!name) { |
635 | /* The search failed if the found attribute is named. */ |
636 | if (a->name_length) |
637 | return -ENOENT; |
638 | } else if (!ntfs_are_names_equal(s1: name, s1_len: name_len, |
639 | s2: (ntfschar*)((u8*)a + le16_to_cpu(a->name_offset)), |
640 | s2_len: a->name_length, ic, upcase, upcase_size: upcase_len)) { |
641 | register int rc; |
642 | |
643 | rc = ntfs_collate_names(name1: name, name1_len: name_len, |
644 | name2: (ntfschar*)((u8*)a + |
645 | le16_to_cpu(a->name_offset)), |
646 | name2_len: a->name_length, err_val: 1, ic: IGNORE_CASE, |
647 | upcase, upcase_len); |
648 | /* |
649 | * If @name collates before a->name, there is no |
650 | * matching attribute. |
651 | */ |
652 | if (rc == -1) |
653 | return -ENOENT; |
654 | /* If the strings are not equal, continue search. */ |
655 | if (rc) |
656 | continue; |
657 | rc = ntfs_collate_names(name1: name, name1_len: name_len, |
658 | name2: (ntfschar*)((u8*)a + |
659 | le16_to_cpu(a->name_offset)), |
660 | name2_len: a->name_length, err_val: 1, ic: CASE_SENSITIVE, |
661 | upcase, upcase_len); |
662 | if (rc == -1) |
663 | return -ENOENT; |
664 | if (rc) |
665 | continue; |
666 | } |
667 | /* |
668 | * The names match or @name not present and attribute is |
669 | * unnamed. If no @val specified, we have found the attribute |
670 | * and are done. |
671 | */ |
672 | if (!val) |
673 | return 0; |
674 | /* @val is present; compare values. */ |
675 | else { |
676 | register int rc; |
677 | |
678 | rc = memcmp(p: val, q: (u8*)a + le16_to_cpu( |
679 | a->data.resident.value_offset), |
680 | min_t(u32, val_len, le32_to_cpu( |
681 | a->data.resident.value_length))); |
682 | /* |
683 | * If @val collates before the current attribute's |
684 | * value, there is no matching attribute. |
685 | */ |
686 | if (!rc) { |
687 | register u32 avl; |
688 | |
689 | avl = le32_to_cpu( |
690 | a->data.resident.value_length); |
691 | if (val_len == avl) |
692 | return 0; |
693 | if (val_len < avl) |
694 | return -ENOENT; |
695 | } else if (rc < 0) |
696 | return -ENOENT; |
697 | } |
698 | } |
699 | ntfs_error(vol->sb, "Inode is corrupt. Run chkdsk." ); |
700 | NVolSetErrors(vol); |
701 | return -EIO; |
702 | } |
703 | |
704 | /** |
705 | * load_attribute_list - load an attribute list into memory |
706 | * @vol: ntfs volume from which to read |
707 | * @runlist: runlist of the attribute list |
708 | * @al_start: destination buffer |
709 | * @size: size of the destination buffer in bytes |
710 | * @initialized_size: initialized size of the attribute list |
711 | * |
712 | * Walk the runlist @runlist and load all clusters from it copying them into |
713 | * the linear buffer @al. The maximum number of bytes copied to @al is @size |
714 | * bytes. Note, @size does not need to be a multiple of the cluster size. If |
715 | * @initialized_size is less than @size, the region in @al between |
716 | * @initialized_size and @size will be zeroed and not read from disk. |
717 | * |
718 | * Return 0 on success or -errno on error. |
719 | */ |
720 | int load_attribute_list(ntfs_volume *vol, runlist *runlist, u8 *al_start, |
721 | const s64 size, const s64 initialized_size) |
722 | { |
723 | LCN lcn; |
724 | u8 *al = al_start; |
725 | u8 *al_end = al + initialized_size; |
726 | runlist_element *rl; |
727 | struct buffer_head *bh; |
728 | struct super_block *sb; |
729 | unsigned long block_size; |
730 | unsigned long block, max_block; |
731 | int err = 0; |
732 | unsigned char block_size_bits; |
733 | |
734 | ntfs_debug("Entering." ); |
735 | if (!vol || !runlist || !al || size <= 0 || initialized_size < 0 || |
736 | initialized_size > size) |
737 | return -EINVAL; |
738 | if (!initialized_size) { |
739 | memset(al, 0, size); |
740 | return 0; |
741 | } |
742 | sb = vol->sb; |
743 | block_size = sb->s_blocksize; |
744 | block_size_bits = sb->s_blocksize_bits; |
745 | down_read(sem: &runlist->lock); |
746 | rl = runlist->rl; |
747 | if (!rl) { |
748 | ntfs_error(sb, "Cannot read attribute list since runlist is " |
749 | "missing." ); |
750 | goto err_out; |
751 | } |
752 | /* Read all clusters specified by the runlist one run at a time. */ |
753 | while (rl->length) { |
754 | lcn = ntfs_rl_vcn_to_lcn(rl, vcn: rl->vcn); |
755 | ntfs_debug("Reading vcn = 0x%llx, lcn = 0x%llx." , |
756 | (unsigned long long)rl->vcn, |
757 | (unsigned long long)lcn); |
758 | /* The attribute list cannot be sparse. */ |
759 | if (lcn < 0) { |
760 | ntfs_error(sb, "ntfs_rl_vcn_to_lcn() failed. Cannot " |
761 | "read attribute list." ); |
762 | goto err_out; |
763 | } |
764 | block = lcn << vol->cluster_size_bits >> block_size_bits; |
765 | /* Read the run from device in chunks of block_size bytes. */ |
766 | max_block = block + (rl->length << vol->cluster_size_bits >> |
767 | block_size_bits); |
768 | ntfs_debug("max_block = 0x%lx." , max_block); |
769 | do { |
770 | ntfs_debug("Reading block = 0x%lx." , block); |
771 | bh = sb_bread(sb, block); |
772 | if (!bh) { |
773 | ntfs_error(sb, "sb_bread() failed. Cannot " |
774 | "read attribute list." ); |
775 | goto err_out; |
776 | } |
777 | if (al + block_size >= al_end) |
778 | goto do_final; |
779 | memcpy(al, bh->b_data, block_size); |
780 | brelse(bh); |
781 | al += block_size; |
782 | } while (++block < max_block); |
783 | rl++; |
784 | } |
785 | if (initialized_size < size) { |
786 | initialize: |
787 | memset(al_start + initialized_size, 0, size - initialized_size); |
788 | } |
789 | done: |
790 | up_read(sem: &runlist->lock); |
791 | return err; |
792 | do_final: |
793 | if (al < al_end) { |
794 | /* |
795 | * Partial block. |
796 | * |
797 | * Note: The attribute list can be smaller than its allocation |
798 | * by multiple clusters. This has been encountered by at least |
799 | * two people running Windows XP, thus we cannot do any |
800 | * truncation sanity checking here. (AIA) |
801 | */ |
802 | memcpy(al, bh->b_data, al_end - al); |
803 | brelse(bh); |
804 | if (initialized_size < size) |
805 | goto initialize; |
806 | goto done; |
807 | } |
808 | brelse(bh); |
809 | /* Real overflow! */ |
810 | ntfs_error(sb, "Attribute list buffer overflow. Read attribute list " |
811 | "is truncated." ); |
812 | err_out: |
813 | err = -EIO; |
814 | goto done; |
815 | } |
816 | |
817 | /** |
818 | * ntfs_external_attr_find - find an attribute in the attribute list of an inode |
819 | * @type: attribute type to find |
820 | * @name: attribute name to find (optional, i.e. NULL means don't care) |
821 | * @name_len: attribute name length (only needed if @name present) |
822 | * @ic: IGNORE_CASE or CASE_SENSITIVE (ignored if @name not present) |
823 | * @lowest_vcn: lowest vcn to find (optional, non-resident attributes only) |
824 | * @val: attribute value to find (optional, resident attributes only) |
825 | * @val_len: attribute value length |
826 | * @ctx: search context with mft record and attribute to search from |
827 | * |
828 | * You should not need to call this function directly. Use ntfs_attr_lookup() |
829 | * instead. |
830 | * |
831 | * Find an attribute by searching the attribute list for the corresponding |
832 | * attribute list entry. Having found the entry, map the mft record if the |
833 | * attribute is in a different mft record/inode, ntfs_attr_find() the attribute |
834 | * in there and return it. |
835 | * |
836 | * On first search @ctx->ntfs_ino must be the base mft record and @ctx must |
837 | * have been obtained from a call to ntfs_attr_get_search_ctx(). On subsequent |
838 | * calls @ctx->ntfs_ino can be any extent inode, too (@ctx->base_ntfs_ino is |
839 | * then the base inode). |
840 | * |
841 | * After finishing with the attribute/mft record you need to call |
842 | * ntfs_attr_put_search_ctx() to cleanup the search context (unmapping any |
843 | * mapped inodes, etc). |
844 | * |
845 | * If the attribute is found, ntfs_external_attr_find() returns 0 and |
846 | * @ctx->attr will point to the found attribute. @ctx->mrec will point to the |
847 | * mft record in which @ctx->attr is located and @ctx->al_entry will point to |
848 | * the attribute list entry for the attribute. |
849 | * |
850 | * If the attribute is not found, ntfs_external_attr_find() returns -ENOENT and |
851 | * @ctx->attr will point to the attribute in the base mft record before which |
852 | * the attribute being searched for would need to be inserted if such an action |
853 | * were to be desired. @ctx->mrec will point to the mft record in which |
854 | * @ctx->attr is located and @ctx->al_entry will point to the attribute list |
855 | * entry of the attribute before which the attribute being searched for would |
856 | * need to be inserted if such an action were to be desired. |
857 | * |
858 | * Thus to insert the not found attribute, one wants to add the attribute to |
859 | * @ctx->mrec (the base mft record) and if there is not enough space, the |
860 | * attribute should be placed in a newly allocated extent mft record. The |
861 | * attribute list entry for the inserted attribute should be inserted in the |
862 | * attribute list attribute at @ctx->al_entry. |
863 | * |
864 | * On actual error, ntfs_external_attr_find() returns -EIO. In this case |
865 | * @ctx->attr is undefined and in particular do not rely on it not changing. |
866 | */ |
867 | static int ntfs_external_attr_find(const ATTR_TYPE type, |
868 | const ntfschar *name, const u32 name_len, |
869 | const IGNORE_CASE_BOOL ic, const VCN lowest_vcn, |
870 | const u8 *val, const u32 val_len, ntfs_attr_search_ctx *ctx) |
871 | { |
872 | ntfs_inode *base_ni, *ni; |
873 | ntfs_volume *vol; |
874 | ATTR_LIST_ENTRY *al_entry, *next_al_entry; |
875 | u8 *al_start, *al_end; |
876 | ATTR_RECORD *a; |
877 | ntfschar *al_name; |
878 | u32 al_name_len; |
879 | int err = 0; |
880 | static const char *es = " Unmount and run chkdsk." ; |
881 | |
882 | ni = ctx->ntfs_ino; |
883 | base_ni = ctx->base_ntfs_ino; |
884 | ntfs_debug("Entering for inode 0x%lx, type 0x%x." , ni->mft_no, type); |
885 | if (!base_ni) { |
886 | /* First call happens with the base mft record. */ |
887 | base_ni = ctx->base_ntfs_ino = ctx->ntfs_ino; |
888 | ctx->base_mrec = ctx->mrec; |
889 | } |
890 | if (ni == base_ni) |
891 | ctx->base_attr = ctx->attr; |
892 | if (type == AT_END) |
893 | goto not_found; |
894 | vol = base_ni->vol; |
895 | al_start = base_ni->attr_list; |
896 | al_end = al_start + base_ni->attr_list_size; |
897 | if (!ctx->al_entry) |
898 | ctx->al_entry = (ATTR_LIST_ENTRY*)al_start; |
899 | /* |
900 | * Iterate over entries in attribute list starting at @ctx->al_entry, |
901 | * or the entry following that, if @ctx->is_first is 'true'. |
902 | */ |
903 | if (ctx->is_first) { |
904 | al_entry = ctx->al_entry; |
905 | ctx->is_first = false; |
906 | } else |
907 | al_entry = (ATTR_LIST_ENTRY*)((u8*)ctx->al_entry + |
908 | le16_to_cpu(ctx->al_entry->length)); |
909 | for (;; al_entry = next_al_entry) { |
910 | /* Out of bounds check. */ |
911 | if ((u8*)al_entry < base_ni->attr_list || |
912 | (u8*)al_entry > al_end) |
913 | break; /* Inode is corrupt. */ |
914 | ctx->al_entry = al_entry; |
915 | /* Catch the end of the attribute list. */ |
916 | if ((u8*)al_entry == al_end) |
917 | goto not_found; |
918 | if (!al_entry->length) |
919 | break; |
920 | if ((u8*)al_entry + 6 > al_end || (u8*)al_entry + |
921 | le16_to_cpu(al_entry->length) > al_end) |
922 | break; |
923 | next_al_entry = (ATTR_LIST_ENTRY*)((u8*)al_entry + |
924 | le16_to_cpu(al_entry->length)); |
925 | if (le32_to_cpu(al_entry->type) > le32_to_cpu(type)) |
926 | goto not_found; |
927 | if (type != al_entry->type) |
928 | continue; |
929 | /* |
930 | * If @name is present, compare the two names. If @name is |
931 | * missing, assume we want an unnamed attribute. |
932 | */ |
933 | al_name_len = al_entry->name_length; |
934 | al_name = (ntfschar*)((u8*)al_entry + al_entry->name_offset); |
935 | if (!name) { |
936 | if (al_name_len) |
937 | goto not_found; |
938 | } else if (!ntfs_are_names_equal(s1: al_name, s1_len: al_name_len, s2: name, |
939 | s2_len: name_len, ic, upcase: vol->upcase, upcase_size: vol->upcase_len)) { |
940 | register int rc; |
941 | |
942 | rc = ntfs_collate_names(name1: name, name1_len: name_len, name2: al_name, |
943 | name2_len: al_name_len, err_val: 1, ic: IGNORE_CASE, |
944 | upcase: vol->upcase, upcase_len: vol->upcase_len); |
945 | /* |
946 | * If @name collates before al_name, there is no |
947 | * matching attribute. |
948 | */ |
949 | if (rc == -1) |
950 | goto not_found; |
951 | /* If the strings are not equal, continue search. */ |
952 | if (rc) |
953 | continue; |
954 | /* |
955 | * FIXME: Reverse engineering showed 0, IGNORE_CASE but |
956 | * that is inconsistent with ntfs_attr_find(). The |
957 | * subsequent rc checks were also different. Perhaps I |
958 | * made a mistake in one of the two. Need to recheck |
959 | * which is correct or at least see what is going on... |
960 | * (AIA) |
961 | */ |
962 | rc = ntfs_collate_names(name1: name, name1_len: name_len, name2: al_name, |
963 | name2_len: al_name_len, err_val: 1, ic: CASE_SENSITIVE, |
964 | upcase: vol->upcase, upcase_len: vol->upcase_len); |
965 | if (rc == -1) |
966 | goto not_found; |
967 | if (rc) |
968 | continue; |
969 | } |
970 | /* |
971 | * The names match or @name not present and attribute is |
972 | * unnamed. Now check @lowest_vcn. Continue search if the |
973 | * next attribute list entry still fits @lowest_vcn. Otherwise |
974 | * we have reached the right one or the search has failed. |
975 | */ |
976 | if (lowest_vcn && (u8*)next_al_entry >= al_start && |
977 | (u8*)next_al_entry + 6 < al_end && |
978 | (u8*)next_al_entry + le16_to_cpu( |
979 | next_al_entry->length) <= al_end && |
980 | sle64_to_cpu(x: next_al_entry->lowest_vcn) <= |
981 | lowest_vcn && |
982 | next_al_entry->type == al_entry->type && |
983 | next_al_entry->name_length == al_name_len && |
984 | ntfs_are_names_equal(s1: (ntfschar*)((u8*) |
985 | next_al_entry + |
986 | next_al_entry->name_offset), |
987 | s1_len: next_al_entry->name_length, |
988 | s2: al_name, s2_len: al_name_len, ic: CASE_SENSITIVE, |
989 | upcase: vol->upcase, upcase_size: vol->upcase_len)) |
990 | continue; |
991 | if (MREF_LE(al_entry->mft_reference) == ni->mft_no) { |
992 | if (MSEQNO_LE(al_entry->mft_reference) != ni->seq_no) { |
993 | ntfs_error(vol->sb, "Found stale mft " |
994 | "reference in attribute list " |
995 | "of base inode 0x%lx.%s" , |
996 | base_ni->mft_no, es); |
997 | err = -EIO; |
998 | break; |
999 | } |
1000 | } else { /* Mft references do not match. */ |
1001 | /* If there is a mapped record unmap it first. */ |
1002 | if (ni != base_ni) |
1003 | unmap_extent_mft_record(ni); |
1004 | /* Do we want the base record back? */ |
1005 | if (MREF_LE(al_entry->mft_reference) == |
1006 | base_ni->mft_no) { |
1007 | ni = ctx->ntfs_ino = base_ni; |
1008 | ctx->mrec = ctx->base_mrec; |
1009 | } else { |
1010 | /* We want an extent record. */ |
1011 | ctx->mrec = map_extent_mft_record(base_ni, |
1012 | le64_to_cpu( |
1013 | al_entry->mft_reference), ntfs_ino: &ni); |
1014 | if (IS_ERR(ptr: ctx->mrec)) { |
1015 | ntfs_error(vol->sb, "Failed to map " |
1016 | "extent mft record " |
1017 | "0x%lx of base inode " |
1018 | "0x%lx.%s" , |
1019 | MREF_LE(al_entry-> |
1020 | mft_reference), |
1021 | base_ni->mft_no, es); |
1022 | err = PTR_ERR(ptr: ctx->mrec); |
1023 | if (err == -ENOENT) |
1024 | err = -EIO; |
1025 | /* Cause @ctx to be sanitized below. */ |
1026 | ni = NULL; |
1027 | break; |
1028 | } |
1029 | ctx->ntfs_ino = ni; |
1030 | } |
1031 | ctx->attr = (ATTR_RECORD*)((u8*)ctx->mrec + |
1032 | le16_to_cpu(ctx->mrec->attrs_offset)); |
1033 | } |
1034 | /* |
1035 | * ctx->vfs_ino, ctx->mrec, and ctx->attr now point to the |
1036 | * mft record containing the attribute represented by the |
1037 | * current al_entry. |
1038 | */ |
1039 | /* |
1040 | * We could call into ntfs_attr_find() to find the right |
1041 | * attribute in this mft record but this would be less |
1042 | * efficient and not quite accurate as ntfs_attr_find() ignores |
1043 | * the attribute instance numbers for example which become |
1044 | * important when one plays with attribute lists. Also, |
1045 | * because a proper match has been found in the attribute list |
1046 | * entry above, the comparison can now be optimized. So it is |
1047 | * worth re-implementing a simplified ntfs_attr_find() here. |
1048 | */ |
1049 | a = ctx->attr; |
1050 | /* |
1051 | * Use a manual loop so we can still use break and continue |
1052 | * with the same meanings as above. |
1053 | */ |
1054 | do_next_attr_loop: |
1055 | if ((u8*)a < (u8*)ctx->mrec || (u8*)a > (u8*)ctx->mrec + |
1056 | le32_to_cpu(ctx->mrec->bytes_allocated)) |
1057 | break; |
1058 | if (a->type == AT_END) |
1059 | break; |
1060 | if (!a->length) |
1061 | break; |
1062 | if (al_entry->instance != a->instance) |
1063 | goto do_next_attr; |
1064 | /* |
1065 | * If the type and/or the name are mismatched between the |
1066 | * attribute list entry and the attribute record, there is |
1067 | * corruption so we break and return error EIO. |
1068 | */ |
1069 | if (al_entry->type != a->type) |
1070 | break; |
1071 | if (!ntfs_are_names_equal(s1: (ntfschar*)((u8*)a + |
1072 | le16_to_cpu(a->name_offset)), s1_len: a->name_length, |
1073 | s2: al_name, s2_len: al_name_len, ic: CASE_SENSITIVE, |
1074 | upcase: vol->upcase, upcase_size: vol->upcase_len)) |
1075 | break; |
1076 | ctx->attr = a; |
1077 | /* |
1078 | * If no @val specified or @val specified and it matches, we |
1079 | * have found it! |
1080 | */ |
1081 | if (!val || (!a->non_resident && le32_to_cpu( |
1082 | a->data.resident.value_length) == val_len && |
1083 | !memcmp(p: (u8*)a + |
1084 | le16_to_cpu(a->data.resident.value_offset), |
1085 | q: val, size: val_len))) { |
1086 | ntfs_debug("Done, found." ); |
1087 | return 0; |
1088 | } |
1089 | do_next_attr: |
1090 | /* Proceed to the next attribute in the current mft record. */ |
1091 | a = (ATTR_RECORD*)((u8*)a + le32_to_cpu(a->length)); |
1092 | goto do_next_attr_loop; |
1093 | } |
1094 | if (!err) { |
1095 | ntfs_error(vol->sb, "Base inode 0x%lx contains corrupt " |
1096 | "attribute list attribute.%s" , base_ni->mft_no, |
1097 | es); |
1098 | err = -EIO; |
1099 | } |
1100 | if (ni != base_ni) { |
1101 | if (ni) |
1102 | unmap_extent_mft_record(ni); |
1103 | ctx->ntfs_ino = base_ni; |
1104 | ctx->mrec = ctx->base_mrec; |
1105 | ctx->attr = ctx->base_attr; |
1106 | } |
1107 | if (err != -ENOMEM) |
1108 | NVolSetErrors(vol); |
1109 | return err; |
1110 | not_found: |
1111 | /* |
1112 | * If we were looking for AT_END, we reset the search context @ctx and |
1113 | * use ntfs_attr_find() to seek to the end of the base mft record. |
1114 | */ |
1115 | if (type == AT_END) { |
1116 | ntfs_attr_reinit_search_ctx(ctx); |
1117 | return ntfs_attr_find(type: AT_END, name, name_len, ic, val, val_len, |
1118 | ctx); |
1119 | } |
1120 | /* |
1121 | * The attribute was not found. Before we return, we want to ensure |
1122 | * @ctx->mrec and @ctx->attr indicate the position at which the |
1123 | * attribute should be inserted in the base mft record. Since we also |
1124 | * want to preserve @ctx->al_entry we cannot reinitialize the search |
1125 | * context using ntfs_attr_reinit_search_ctx() as this would set |
1126 | * @ctx->al_entry to NULL. Thus we do the necessary bits manually (see |
1127 | * ntfs_attr_init_search_ctx() below). Note, we _only_ preserve |
1128 | * @ctx->al_entry as the remaining fields (base_*) are identical to |
1129 | * their non base_ counterparts and we cannot set @ctx->base_attr |
1130 | * correctly yet as we do not know what @ctx->attr will be set to by |
1131 | * the call to ntfs_attr_find() below. |
1132 | */ |
1133 | if (ni != base_ni) |
1134 | unmap_extent_mft_record(ni); |
1135 | ctx->mrec = ctx->base_mrec; |
1136 | ctx->attr = (ATTR_RECORD*)((u8*)ctx->mrec + |
1137 | le16_to_cpu(ctx->mrec->attrs_offset)); |
1138 | ctx->is_first = true; |
1139 | ctx->ntfs_ino = base_ni; |
1140 | ctx->base_ntfs_ino = NULL; |
1141 | ctx->base_mrec = NULL; |
1142 | ctx->base_attr = NULL; |
1143 | /* |
1144 | * In case there are multiple matches in the base mft record, need to |
1145 | * keep enumerating until we get an attribute not found response (or |
1146 | * another error), otherwise we would keep returning the same attribute |
1147 | * over and over again and all programs using us for enumeration would |
1148 | * lock up in a tight loop. |
1149 | */ |
1150 | do { |
1151 | err = ntfs_attr_find(type, name, name_len, ic, val, val_len, |
1152 | ctx); |
1153 | } while (!err); |
1154 | ntfs_debug("Done, not found." ); |
1155 | return err; |
1156 | } |
1157 | |
1158 | /** |
1159 | * ntfs_attr_lookup - find an attribute in an ntfs inode |
1160 | * @type: attribute type to find |
1161 | * @name: attribute name to find (optional, i.e. NULL means don't care) |
1162 | * @name_len: attribute name length (only needed if @name present) |
1163 | * @ic: IGNORE_CASE or CASE_SENSITIVE (ignored if @name not present) |
1164 | * @lowest_vcn: lowest vcn to find (optional, non-resident attributes only) |
1165 | * @val: attribute value to find (optional, resident attributes only) |
1166 | * @val_len: attribute value length |
1167 | * @ctx: search context with mft record and attribute to search from |
1168 | * |
1169 | * Find an attribute in an ntfs inode. On first search @ctx->ntfs_ino must |
1170 | * be the base mft record and @ctx must have been obtained from a call to |
1171 | * ntfs_attr_get_search_ctx(). |
1172 | * |
1173 | * This function transparently handles attribute lists and @ctx is used to |
1174 | * continue searches where they were left off at. |
1175 | * |
1176 | * After finishing with the attribute/mft record you need to call |
1177 | * ntfs_attr_put_search_ctx() to cleanup the search context (unmapping any |
1178 | * mapped inodes, etc). |
1179 | * |
1180 | * Return 0 if the search was successful and -errno if not. |
1181 | * |
1182 | * When 0, @ctx->attr is the found attribute and it is in mft record |
1183 | * @ctx->mrec. If an attribute list attribute is present, @ctx->al_entry is |
1184 | * the attribute list entry of the found attribute. |
1185 | * |
1186 | * When -ENOENT, @ctx->attr is the attribute which collates just after the |
1187 | * attribute being searched for, i.e. if one wants to add the attribute to the |
1188 | * mft record this is the correct place to insert it into. If an attribute |
1189 | * list attribute is present, @ctx->al_entry is the attribute list entry which |
1190 | * collates just after the attribute list entry of the attribute being searched |
1191 | * for, i.e. if one wants to add the attribute to the mft record this is the |
1192 | * correct place to insert its attribute list entry into. |
1193 | * |
1194 | * When -errno != -ENOENT, an error occurred during the lookup. @ctx->attr is |
1195 | * then undefined and in particular you should not rely on it not changing. |
1196 | */ |
1197 | int ntfs_attr_lookup(const ATTR_TYPE type, const ntfschar *name, |
1198 | const u32 name_len, const IGNORE_CASE_BOOL ic, |
1199 | const VCN lowest_vcn, const u8 *val, const u32 val_len, |
1200 | ntfs_attr_search_ctx *ctx) |
1201 | { |
1202 | ntfs_inode *base_ni; |
1203 | |
1204 | ntfs_debug("Entering." ); |
1205 | BUG_ON(IS_ERR(ctx->mrec)); |
1206 | if (ctx->base_ntfs_ino) |
1207 | base_ni = ctx->base_ntfs_ino; |
1208 | else |
1209 | base_ni = ctx->ntfs_ino; |
1210 | /* Sanity check, just for debugging really. */ |
1211 | BUG_ON(!base_ni); |
1212 | if (!NInoAttrList(ni: base_ni) || type == AT_ATTRIBUTE_LIST) |
1213 | return ntfs_attr_find(type, name, name_len, ic, val, val_len, |
1214 | ctx); |
1215 | return ntfs_external_attr_find(type, name, name_len, ic, lowest_vcn, |
1216 | val, val_len, ctx); |
1217 | } |
1218 | |
1219 | /** |
1220 | * ntfs_attr_init_search_ctx - initialize an attribute search context |
1221 | * @ctx: attribute search context to initialize |
1222 | * @ni: ntfs inode with which to initialize the search context |
1223 | * @mrec: mft record with which to initialize the search context |
1224 | * |
1225 | * Initialize the attribute search context @ctx with @ni and @mrec. |
1226 | */ |
1227 | static inline void ntfs_attr_init_search_ctx(ntfs_attr_search_ctx *ctx, |
1228 | ntfs_inode *ni, MFT_RECORD *mrec) |
1229 | { |
1230 | *ctx = (ntfs_attr_search_ctx) { |
1231 | .mrec = mrec, |
1232 | /* Sanity checks are performed elsewhere. */ |
1233 | .attr = (ATTR_RECORD*)((u8*)mrec + |
1234 | le16_to_cpu(mrec->attrs_offset)), |
1235 | .is_first = true, |
1236 | .ntfs_ino = ni, |
1237 | }; |
1238 | } |
1239 | |
1240 | /** |
1241 | * ntfs_attr_reinit_search_ctx - reinitialize an attribute search context |
1242 | * @ctx: attribute search context to reinitialize |
1243 | * |
1244 | * Reinitialize the attribute search context @ctx, unmapping an associated |
1245 | * extent mft record if present, and initialize the search context again. |
1246 | * |
1247 | * This is used when a search for a new attribute is being started to reset |
1248 | * the search context to the beginning. |
1249 | */ |
1250 | void ntfs_attr_reinit_search_ctx(ntfs_attr_search_ctx *ctx) |
1251 | { |
1252 | if (likely(!ctx->base_ntfs_ino)) { |
1253 | /* No attribute list. */ |
1254 | ctx->is_first = true; |
1255 | /* Sanity checks are performed elsewhere. */ |
1256 | ctx->attr = (ATTR_RECORD*)((u8*)ctx->mrec + |
1257 | le16_to_cpu(ctx->mrec->attrs_offset)); |
1258 | /* |
1259 | * This needs resetting due to ntfs_external_attr_find() which |
1260 | * can leave it set despite having zeroed ctx->base_ntfs_ino. |
1261 | */ |
1262 | ctx->al_entry = NULL; |
1263 | return; |
1264 | } /* Attribute list. */ |
1265 | if (ctx->ntfs_ino != ctx->base_ntfs_ino) |
1266 | unmap_extent_mft_record(ni: ctx->ntfs_ino); |
1267 | ntfs_attr_init_search_ctx(ctx, ni: ctx->base_ntfs_ino, mrec: ctx->base_mrec); |
1268 | return; |
1269 | } |
1270 | |
1271 | /** |
1272 | * ntfs_attr_get_search_ctx - allocate/initialize a new attribute search context |
1273 | * @ni: ntfs inode with which to initialize the search context |
1274 | * @mrec: mft record with which to initialize the search context |
1275 | * |
1276 | * Allocate a new attribute search context, initialize it with @ni and @mrec, |
1277 | * and return it. Return NULL if allocation failed. |
1278 | */ |
1279 | ntfs_attr_search_ctx *ntfs_attr_get_search_ctx(ntfs_inode *ni, MFT_RECORD *mrec) |
1280 | { |
1281 | ntfs_attr_search_ctx *ctx; |
1282 | |
1283 | ctx = kmem_cache_alloc(cachep: ntfs_attr_ctx_cache, GFP_NOFS); |
1284 | if (ctx) |
1285 | ntfs_attr_init_search_ctx(ctx, ni, mrec); |
1286 | return ctx; |
1287 | } |
1288 | |
1289 | /** |
1290 | * ntfs_attr_put_search_ctx - release an attribute search context |
1291 | * @ctx: attribute search context to free |
1292 | * |
1293 | * Release the attribute search context @ctx, unmapping an associated extent |
1294 | * mft record if present. |
1295 | */ |
1296 | void ntfs_attr_put_search_ctx(ntfs_attr_search_ctx *ctx) |
1297 | { |
1298 | if (ctx->base_ntfs_ino && ctx->ntfs_ino != ctx->base_ntfs_ino) |
1299 | unmap_extent_mft_record(ni: ctx->ntfs_ino); |
1300 | kmem_cache_free(s: ntfs_attr_ctx_cache, objp: ctx); |
1301 | return; |
1302 | } |
1303 | |
1304 | #ifdef NTFS_RW |
1305 | |
1306 | /** |
1307 | * ntfs_attr_find_in_attrdef - find an attribute in the $AttrDef system file |
1308 | * @vol: ntfs volume to which the attribute belongs |
1309 | * @type: attribute type which to find |
1310 | * |
1311 | * Search for the attribute definition record corresponding to the attribute |
1312 | * @type in the $AttrDef system file. |
1313 | * |
1314 | * Return the attribute type definition record if found and NULL if not found. |
1315 | */ |
1316 | static ATTR_DEF *ntfs_attr_find_in_attrdef(const ntfs_volume *vol, |
1317 | const ATTR_TYPE type) |
1318 | { |
1319 | ATTR_DEF *ad; |
1320 | |
1321 | BUG_ON(!vol->attrdef); |
1322 | BUG_ON(!type); |
1323 | for (ad = vol->attrdef; (u8*)ad - (u8*)vol->attrdef < |
1324 | vol->attrdef_size && ad->type; ++ad) { |
1325 | /* We have not found it yet, carry on searching. */ |
1326 | if (likely(le32_to_cpu(ad->type) < le32_to_cpu(type))) |
1327 | continue; |
1328 | /* We found the attribute; return it. */ |
1329 | if (likely(ad->type == type)) |
1330 | return ad; |
1331 | /* We have gone too far already. No point in continuing. */ |
1332 | break; |
1333 | } |
1334 | /* Attribute not found. */ |
1335 | ntfs_debug("Attribute type 0x%x not found in $AttrDef." , |
1336 | le32_to_cpu(type)); |
1337 | return NULL; |
1338 | } |
1339 | |
1340 | /** |
1341 | * ntfs_attr_size_bounds_check - check a size of an attribute type for validity |
1342 | * @vol: ntfs volume to which the attribute belongs |
1343 | * @type: attribute type which to check |
1344 | * @size: size which to check |
1345 | * |
1346 | * Check whether the @size in bytes is valid for an attribute of @type on the |
1347 | * ntfs volume @vol. This information is obtained from $AttrDef system file. |
1348 | * |
1349 | * Return 0 if valid, -ERANGE if not valid, or -ENOENT if the attribute is not |
1350 | * listed in $AttrDef. |
1351 | */ |
1352 | int ntfs_attr_size_bounds_check(const ntfs_volume *vol, const ATTR_TYPE type, |
1353 | const s64 size) |
1354 | { |
1355 | ATTR_DEF *ad; |
1356 | |
1357 | BUG_ON(size < 0); |
1358 | /* |
1359 | * $ATTRIBUTE_LIST has a maximum size of 256kiB, but this is not |
1360 | * listed in $AttrDef. |
1361 | */ |
1362 | if (unlikely(type == AT_ATTRIBUTE_LIST && size > 256 * 1024)) |
1363 | return -ERANGE; |
1364 | /* Get the $AttrDef entry for the attribute @type. */ |
1365 | ad = ntfs_attr_find_in_attrdef(vol, type); |
1366 | if (unlikely(!ad)) |
1367 | return -ENOENT; |
1368 | /* Do the bounds check. */ |
1369 | if (((sle64_to_cpu(x: ad->min_size) > 0) && |
1370 | size < sle64_to_cpu(x: ad->min_size)) || |
1371 | ((sle64_to_cpu(x: ad->max_size) > 0) && size > |
1372 | sle64_to_cpu(x: ad->max_size))) |
1373 | return -ERANGE; |
1374 | return 0; |
1375 | } |
1376 | |
1377 | /** |
1378 | * ntfs_attr_can_be_non_resident - check if an attribute can be non-resident |
1379 | * @vol: ntfs volume to which the attribute belongs |
1380 | * @type: attribute type which to check |
1381 | * |
1382 | * Check whether the attribute of @type on the ntfs volume @vol is allowed to |
1383 | * be non-resident. This information is obtained from $AttrDef system file. |
1384 | * |
1385 | * Return 0 if the attribute is allowed to be non-resident, -EPERM if not, and |
1386 | * -ENOENT if the attribute is not listed in $AttrDef. |
1387 | */ |
1388 | int ntfs_attr_can_be_non_resident(const ntfs_volume *vol, const ATTR_TYPE type) |
1389 | { |
1390 | ATTR_DEF *ad; |
1391 | |
1392 | /* Find the attribute definition record in $AttrDef. */ |
1393 | ad = ntfs_attr_find_in_attrdef(vol, type); |
1394 | if (unlikely(!ad)) |
1395 | return -ENOENT; |
1396 | /* Check the flags and return the result. */ |
1397 | if (ad->flags & ATTR_DEF_RESIDENT) |
1398 | return -EPERM; |
1399 | return 0; |
1400 | } |
1401 | |
1402 | /** |
1403 | * ntfs_attr_can_be_resident - check if an attribute can be resident |
1404 | * @vol: ntfs volume to which the attribute belongs |
1405 | * @type: attribute type which to check |
1406 | * |
1407 | * Check whether the attribute of @type on the ntfs volume @vol is allowed to |
1408 | * be resident. This information is derived from our ntfs knowledge and may |
1409 | * not be completely accurate, especially when user defined attributes are |
1410 | * present. Basically we allow everything to be resident except for index |
1411 | * allocation and $EA attributes. |
1412 | * |
1413 | * Return 0 if the attribute is allowed to be non-resident and -EPERM if not. |
1414 | * |
1415 | * Warning: In the system file $MFT the attribute $Bitmap must be non-resident |
1416 | * otherwise windows will not boot (blue screen of death)! We cannot |
1417 | * check for this here as we do not know which inode's $Bitmap is |
1418 | * being asked about so the caller needs to special case this. |
1419 | */ |
1420 | int ntfs_attr_can_be_resident(const ntfs_volume *vol, const ATTR_TYPE type) |
1421 | { |
1422 | if (type == AT_INDEX_ALLOCATION) |
1423 | return -EPERM; |
1424 | return 0; |
1425 | } |
1426 | |
1427 | /** |
1428 | * ntfs_attr_record_resize - resize an attribute record |
1429 | * @m: mft record containing attribute record |
1430 | * @a: attribute record to resize |
1431 | * @new_size: new size in bytes to which to resize the attribute record @a |
1432 | * |
1433 | * Resize the attribute record @a, i.e. the resident part of the attribute, in |
1434 | * the mft record @m to @new_size bytes. |
1435 | * |
1436 | * Return 0 on success and -errno on error. The following error codes are |
1437 | * defined: |
1438 | * -ENOSPC - Not enough space in the mft record @m to perform the resize. |
1439 | * |
1440 | * Note: On error, no modifications have been performed whatsoever. |
1441 | * |
1442 | * Warning: If you make a record smaller without having copied all the data you |
1443 | * are interested in the data may be overwritten. |
1444 | */ |
1445 | int ntfs_attr_record_resize(MFT_RECORD *m, ATTR_RECORD *a, u32 new_size) |
1446 | { |
1447 | ntfs_debug("Entering for new_size %u." , new_size); |
1448 | /* Align to 8 bytes if it is not already done. */ |
1449 | if (new_size & 7) |
1450 | new_size = (new_size + 7) & ~7; |
1451 | /* If the actual attribute length has changed, move things around. */ |
1452 | if (new_size != le32_to_cpu(a->length)) { |
1453 | u32 new_muse = le32_to_cpu(m->bytes_in_use) - |
1454 | le32_to_cpu(a->length) + new_size; |
1455 | /* Not enough space in this mft record. */ |
1456 | if (new_muse > le32_to_cpu(m->bytes_allocated)) |
1457 | return -ENOSPC; |
1458 | /* Move attributes following @a to their new location. */ |
1459 | memmove((u8*)a + new_size, (u8*)a + le32_to_cpu(a->length), |
1460 | le32_to_cpu(m->bytes_in_use) - ((u8*)a - |
1461 | (u8*)m) - le32_to_cpu(a->length)); |
1462 | /* Adjust @m to reflect the change in used space. */ |
1463 | m->bytes_in_use = cpu_to_le32(new_muse); |
1464 | /* Adjust @a to reflect the new size. */ |
1465 | if (new_size >= offsetof(ATTR_REC, length) + sizeof(a->length)) |
1466 | a->length = cpu_to_le32(new_size); |
1467 | } |
1468 | return 0; |
1469 | } |
1470 | |
1471 | /** |
1472 | * ntfs_resident_attr_value_resize - resize the value of a resident attribute |
1473 | * @m: mft record containing attribute record |
1474 | * @a: attribute record whose value to resize |
1475 | * @new_size: new size in bytes to which to resize the attribute value of @a |
1476 | * |
1477 | * Resize the value of the attribute @a in the mft record @m to @new_size bytes. |
1478 | * If the value is made bigger, the newly allocated space is cleared. |
1479 | * |
1480 | * Return 0 on success and -errno on error. The following error codes are |
1481 | * defined: |
1482 | * -ENOSPC - Not enough space in the mft record @m to perform the resize. |
1483 | * |
1484 | * Note: On error, no modifications have been performed whatsoever. |
1485 | * |
1486 | * Warning: If you make a record smaller without having copied all the data you |
1487 | * are interested in the data may be overwritten. |
1488 | */ |
1489 | int ntfs_resident_attr_value_resize(MFT_RECORD *m, ATTR_RECORD *a, |
1490 | const u32 new_size) |
1491 | { |
1492 | u32 old_size; |
1493 | |
1494 | /* Resize the resident part of the attribute record. */ |
1495 | if (ntfs_attr_record_resize(m, a, |
1496 | le16_to_cpu(a->data.resident.value_offset) + new_size)) |
1497 | return -ENOSPC; |
1498 | /* |
1499 | * The resize succeeded! If we made the attribute value bigger, clear |
1500 | * the area between the old size and @new_size. |
1501 | */ |
1502 | old_size = le32_to_cpu(a->data.resident.value_length); |
1503 | if (new_size > old_size) |
1504 | memset((u8*)a + le16_to_cpu(a->data.resident.value_offset) + |
1505 | old_size, 0, new_size - old_size); |
1506 | /* Finally update the length of the attribute value. */ |
1507 | a->data.resident.value_length = cpu_to_le32(new_size); |
1508 | return 0; |
1509 | } |
1510 | |
1511 | /** |
1512 | * ntfs_attr_make_non_resident - convert a resident to a non-resident attribute |
1513 | * @ni: ntfs inode describing the attribute to convert |
1514 | * @data_size: size of the resident data to copy to the non-resident attribute |
1515 | * |
1516 | * Convert the resident ntfs attribute described by the ntfs inode @ni to a |
1517 | * non-resident one. |
1518 | * |
1519 | * @data_size must be equal to the attribute value size. This is needed since |
1520 | * we need to know the size before we can map the mft record and our callers |
1521 | * always know it. The reason we cannot simply read the size from the vfs |
1522 | * inode i_size is that this is not necessarily uptodate. This happens when |
1523 | * ntfs_attr_make_non_resident() is called in the ->truncate call path(s). |
1524 | * |
1525 | * Return 0 on success and -errno on error. The following error return codes |
1526 | * are defined: |
1527 | * -EPERM - The attribute is not allowed to be non-resident. |
1528 | * -ENOMEM - Not enough memory. |
1529 | * -ENOSPC - Not enough disk space. |
1530 | * -EINVAL - Attribute not defined on the volume. |
1531 | * -EIO - I/o error or other error. |
1532 | * Note that -ENOSPC is also returned in the case that there is not enough |
1533 | * space in the mft record to do the conversion. This can happen when the mft |
1534 | * record is already very full. The caller is responsible for trying to make |
1535 | * space in the mft record and trying again. FIXME: Do we need a separate |
1536 | * error return code for this kind of -ENOSPC or is it always worth trying |
1537 | * again in case the attribute may then fit in a resident state so no need to |
1538 | * make it non-resident at all? Ho-hum... (AIA) |
1539 | * |
1540 | * NOTE to self: No changes in the attribute list are required to move from |
1541 | * a resident to a non-resident attribute. |
1542 | * |
1543 | * Locking: - The caller must hold i_mutex on the inode. |
1544 | */ |
1545 | int ntfs_attr_make_non_resident(ntfs_inode *ni, const u32 data_size) |
1546 | { |
1547 | s64 new_size; |
1548 | struct inode *vi = VFS_I(ni); |
1549 | ntfs_volume *vol = ni->vol; |
1550 | ntfs_inode *base_ni; |
1551 | MFT_RECORD *m; |
1552 | ATTR_RECORD *a; |
1553 | ntfs_attr_search_ctx *ctx; |
1554 | struct page *page; |
1555 | runlist_element *rl; |
1556 | u8 *kaddr; |
1557 | unsigned long flags; |
1558 | int mp_size, mp_ofs, name_ofs, arec_size, err, err2; |
1559 | u32 attr_size; |
1560 | u8 old_res_attr_flags; |
1561 | |
1562 | /* Check that the attribute is allowed to be non-resident. */ |
1563 | err = ntfs_attr_can_be_non_resident(vol, type: ni->type); |
1564 | if (unlikely(err)) { |
1565 | if (err == -EPERM) |
1566 | ntfs_debug("Attribute is not allowed to be " |
1567 | "non-resident." ); |
1568 | else |
1569 | ntfs_debug("Attribute not defined on the NTFS " |
1570 | "volume!" ); |
1571 | return err; |
1572 | } |
1573 | /* |
1574 | * FIXME: Compressed and encrypted attributes are not supported when |
1575 | * writing and we should never have gotten here for them. |
1576 | */ |
1577 | BUG_ON(NInoCompressed(ni)); |
1578 | BUG_ON(NInoEncrypted(ni)); |
1579 | /* |
1580 | * The size needs to be aligned to a cluster boundary for allocation |
1581 | * purposes. |
1582 | */ |
1583 | new_size = (data_size + vol->cluster_size - 1) & |
1584 | ~(vol->cluster_size - 1); |
1585 | if (new_size > 0) { |
1586 | /* |
1587 | * Will need the page later and since the page lock nests |
1588 | * outside all ntfs locks, we need to get the page now. |
1589 | */ |
1590 | page = find_or_create_page(mapping: vi->i_mapping, index: 0, |
1591 | gfp_mask: mapping_gfp_mask(mapping: vi->i_mapping)); |
1592 | if (unlikely(!page)) |
1593 | return -ENOMEM; |
1594 | /* Start by allocating clusters to hold the attribute value. */ |
1595 | rl = ntfs_cluster_alloc(vol, start_vcn: 0, count: new_size >> |
1596 | vol->cluster_size_bits, start_lcn: -1, zone: DATA_ZONE, is_extension: true); |
1597 | if (IS_ERR(ptr: rl)) { |
1598 | err = PTR_ERR(ptr: rl); |
1599 | ntfs_debug("Failed to allocate cluster%s, error code " |
1600 | "%i." , (new_size >> |
1601 | vol->cluster_size_bits) > 1 ? "s" : "" , |
1602 | err); |
1603 | goto page_err_out; |
1604 | } |
1605 | } else { |
1606 | rl = NULL; |
1607 | page = NULL; |
1608 | } |
1609 | /* Determine the size of the mapping pairs array. */ |
1610 | mp_size = ntfs_get_size_for_mapping_pairs(vol, rl, first_vcn: 0, last_vcn: -1); |
1611 | if (unlikely(mp_size < 0)) { |
1612 | err = mp_size; |
1613 | ntfs_debug("Failed to get size for mapping pairs array, error " |
1614 | "code %i." , err); |
1615 | goto rl_err_out; |
1616 | } |
1617 | down_write(sem: &ni->runlist.lock); |
1618 | if (!NInoAttr(ni)) |
1619 | base_ni = ni; |
1620 | else |
1621 | base_ni = ni->ext.base_ntfs_ino; |
1622 | m = map_mft_record(ni: base_ni); |
1623 | if (IS_ERR(ptr: m)) { |
1624 | err = PTR_ERR(ptr: m); |
1625 | m = NULL; |
1626 | ctx = NULL; |
1627 | goto err_out; |
1628 | } |
1629 | ctx = ntfs_attr_get_search_ctx(ni: base_ni, mrec: m); |
1630 | if (unlikely(!ctx)) { |
1631 | err = -ENOMEM; |
1632 | goto err_out; |
1633 | } |
1634 | err = ntfs_attr_lookup(type: ni->type, name: ni->name, name_len: ni->name_len, |
1635 | ic: CASE_SENSITIVE, lowest_vcn: 0, NULL, val_len: 0, ctx); |
1636 | if (unlikely(err)) { |
1637 | if (err == -ENOENT) |
1638 | err = -EIO; |
1639 | goto err_out; |
1640 | } |
1641 | m = ctx->mrec; |
1642 | a = ctx->attr; |
1643 | BUG_ON(NInoNonResident(ni)); |
1644 | BUG_ON(a->non_resident); |
1645 | /* |
1646 | * Calculate new offsets for the name and the mapping pairs array. |
1647 | */ |
1648 | if (NInoSparse(ni) || NInoCompressed(ni)) |
1649 | name_ofs = (offsetof(ATTR_REC, |
1650 | data.non_resident.compressed_size) + |
1651 | sizeof(a->data.non_resident.compressed_size) + |
1652 | 7) & ~7; |
1653 | else |
1654 | name_ofs = (offsetof(ATTR_REC, |
1655 | data.non_resident.compressed_size) + 7) & ~7; |
1656 | mp_ofs = (name_ofs + a->name_length * sizeof(ntfschar) + 7) & ~7; |
1657 | /* |
1658 | * Determine the size of the resident part of the now non-resident |
1659 | * attribute record. |
1660 | */ |
1661 | arec_size = (mp_ofs + mp_size + 7) & ~7; |
1662 | /* |
1663 | * If the page is not uptodate bring it uptodate by copying from the |
1664 | * attribute value. |
1665 | */ |
1666 | attr_size = le32_to_cpu(a->data.resident.value_length); |
1667 | BUG_ON(attr_size != data_size); |
1668 | if (page && !PageUptodate(page)) { |
1669 | kaddr = kmap_atomic(page); |
1670 | memcpy(kaddr, (u8*)a + |
1671 | le16_to_cpu(a->data.resident.value_offset), |
1672 | attr_size); |
1673 | memset(kaddr + attr_size, 0, PAGE_SIZE - attr_size); |
1674 | kunmap_atomic(kaddr); |
1675 | flush_dcache_page(page); |
1676 | SetPageUptodate(page); |
1677 | } |
1678 | /* Backup the attribute flag. */ |
1679 | old_res_attr_flags = a->data.resident.flags; |
1680 | /* Resize the resident part of the attribute record. */ |
1681 | err = ntfs_attr_record_resize(m, a, new_size: arec_size); |
1682 | if (unlikely(err)) |
1683 | goto err_out; |
1684 | /* |
1685 | * Convert the resident part of the attribute record to describe a |
1686 | * non-resident attribute. |
1687 | */ |
1688 | a->non_resident = 1; |
1689 | /* Move the attribute name if it exists and update the offset. */ |
1690 | if (a->name_length) |
1691 | memmove((u8*)a + name_ofs, (u8*)a + le16_to_cpu(a->name_offset), |
1692 | a->name_length * sizeof(ntfschar)); |
1693 | a->name_offset = cpu_to_le16(name_ofs); |
1694 | /* Setup the fields specific to non-resident attributes. */ |
1695 | a->data.non_resident.lowest_vcn = 0; |
1696 | a->data.non_resident.highest_vcn = cpu_to_sle64(x: (new_size - 1) >> |
1697 | vol->cluster_size_bits); |
1698 | a->data.non_resident.mapping_pairs_offset = cpu_to_le16(mp_ofs); |
1699 | memset(&a->data.non_resident.reserved, 0, |
1700 | sizeof(a->data.non_resident.reserved)); |
1701 | a->data.non_resident.allocated_size = cpu_to_sle64(x: new_size); |
1702 | a->data.non_resident.data_size = |
1703 | a->data.non_resident.initialized_size = |
1704 | cpu_to_sle64(x: attr_size); |
1705 | if (NInoSparse(ni) || NInoCompressed(ni)) { |
1706 | a->data.non_resident.compression_unit = 0; |
1707 | if (NInoCompressed(ni) || vol->major_ver < 3) |
1708 | a->data.non_resident.compression_unit = 4; |
1709 | a->data.non_resident.compressed_size = |
1710 | a->data.non_resident.allocated_size; |
1711 | } else |
1712 | a->data.non_resident.compression_unit = 0; |
1713 | /* Generate the mapping pairs array into the attribute record. */ |
1714 | err = ntfs_mapping_pairs_build(vol, dst: (u8*)a + mp_ofs, |
1715 | dst_len: arec_size - mp_ofs, rl, first_vcn: 0, last_vcn: -1, NULL); |
1716 | if (unlikely(err)) { |
1717 | ntfs_debug("Failed to build mapping pairs, error code %i." , |
1718 | err); |
1719 | goto undo_err_out; |
1720 | } |
1721 | /* Setup the in-memory attribute structure to be non-resident. */ |
1722 | ni->runlist.rl = rl; |
1723 | write_lock_irqsave(&ni->size_lock, flags); |
1724 | ni->allocated_size = new_size; |
1725 | if (NInoSparse(ni) || NInoCompressed(ni)) { |
1726 | ni->itype.compressed.size = ni->allocated_size; |
1727 | if (a->data.non_resident.compression_unit) { |
1728 | ni->itype.compressed.block_size = 1U << (a->data. |
1729 | non_resident.compression_unit + |
1730 | vol->cluster_size_bits); |
1731 | ni->itype.compressed.block_size_bits = |
1732 | ffs(ni->itype.compressed.block_size) - |
1733 | 1; |
1734 | ni->itype.compressed.block_clusters = 1U << |
1735 | a->data.non_resident.compression_unit; |
1736 | } else { |
1737 | ni->itype.compressed.block_size = 0; |
1738 | ni->itype.compressed.block_size_bits = 0; |
1739 | ni->itype.compressed.block_clusters = 0; |
1740 | } |
1741 | vi->i_blocks = ni->itype.compressed.size >> 9; |
1742 | } else |
1743 | vi->i_blocks = ni->allocated_size >> 9; |
1744 | write_unlock_irqrestore(&ni->size_lock, flags); |
1745 | /* |
1746 | * This needs to be last since the address space operations ->read_folio |
1747 | * and ->writepage can run concurrently with us as they are not |
1748 | * serialized on i_mutex. Note, we are not allowed to fail once we flip |
1749 | * this switch, which is another reason to do this last. |
1750 | */ |
1751 | NInoSetNonResident(ni); |
1752 | /* Mark the mft record dirty, so it gets written back. */ |
1753 | flush_dcache_mft_record_page(ni: ctx->ntfs_ino); |
1754 | mark_mft_record_dirty(ni: ctx->ntfs_ino); |
1755 | ntfs_attr_put_search_ctx(ctx); |
1756 | unmap_mft_record(ni: base_ni); |
1757 | up_write(sem: &ni->runlist.lock); |
1758 | if (page) { |
1759 | set_page_dirty(page); |
1760 | unlock_page(page); |
1761 | put_page(page); |
1762 | } |
1763 | ntfs_debug("Done." ); |
1764 | return 0; |
1765 | undo_err_out: |
1766 | /* Convert the attribute back into a resident attribute. */ |
1767 | a->non_resident = 0; |
1768 | /* Move the attribute name if it exists and update the offset. */ |
1769 | name_ofs = (offsetof(ATTR_RECORD, data.resident.reserved) + |
1770 | sizeof(a->data.resident.reserved) + 7) & ~7; |
1771 | if (a->name_length) |
1772 | memmove((u8*)a + name_ofs, (u8*)a + le16_to_cpu(a->name_offset), |
1773 | a->name_length * sizeof(ntfschar)); |
1774 | mp_ofs = (name_ofs + a->name_length * sizeof(ntfschar) + 7) & ~7; |
1775 | a->name_offset = cpu_to_le16(name_ofs); |
1776 | arec_size = (mp_ofs + attr_size + 7) & ~7; |
1777 | /* Resize the resident part of the attribute record. */ |
1778 | err2 = ntfs_attr_record_resize(m, a, new_size: arec_size); |
1779 | if (unlikely(err2)) { |
1780 | /* |
1781 | * This cannot happen (well if memory corruption is at work it |
1782 | * could happen in theory), but deal with it as well as we can. |
1783 | * If the old size is too small, truncate the attribute, |
1784 | * otherwise simply give it a larger allocated size. |
1785 | * FIXME: Should check whether chkdsk complains when the |
1786 | * allocated size is much bigger than the resident value size. |
1787 | */ |
1788 | arec_size = le32_to_cpu(a->length); |
1789 | if ((mp_ofs + attr_size) > arec_size) { |
1790 | err2 = attr_size; |
1791 | attr_size = arec_size - mp_ofs; |
1792 | ntfs_error(vol->sb, "Failed to undo partial resident " |
1793 | "to non-resident attribute " |
1794 | "conversion. Truncating inode 0x%lx, " |
1795 | "attribute type 0x%x from %i bytes to " |
1796 | "%i bytes to maintain metadata " |
1797 | "consistency. THIS MEANS YOU ARE " |
1798 | "LOSING %i BYTES DATA FROM THIS %s." , |
1799 | vi->i_ino, |
1800 | (unsigned)le32_to_cpu(ni->type), |
1801 | err2, attr_size, err2 - attr_size, |
1802 | ((ni->type == AT_DATA) && |
1803 | !ni->name_len) ? "FILE" : "ATTRIBUTE" ); |
1804 | write_lock_irqsave(&ni->size_lock, flags); |
1805 | ni->initialized_size = attr_size; |
1806 | i_size_write(inode: vi, i_size: attr_size); |
1807 | write_unlock_irqrestore(&ni->size_lock, flags); |
1808 | } |
1809 | } |
1810 | /* Setup the fields specific to resident attributes. */ |
1811 | a->data.resident.value_length = cpu_to_le32(attr_size); |
1812 | a->data.resident.value_offset = cpu_to_le16(mp_ofs); |
1813 | a->data.resident.flags = old_res_attr_flags; |
1814 | memset(&a->data.resident.reserved, 0, |
1815 | sizeof(a->data.resident.reserved)); |
1816 | /* Copy the data from the page back to the attribute value. */ |
1817 | if (page) { |
1818 | kaddr = kmap_atomic(page); |
1819 | memcpy((u8*)a + mp_ofs, kaddr, attr_size); |
1820 | kunmap_atomic(kaddr); |
1821 | } |
1822 | /* Setup the allocated size in the ntfs inode in case it changed. */ |
1823 | write_lock_irqsave(&ni->size_lock, flags); |
1824 | ni->allocated_size = arec_size - mp_ofs; |
1825 | write_unlock_irqrestore(&ni->size_lock, flags); |
1826 | /* Mark the mft record dirty, so it gets written back. */ |
1827 | flush_dcache_mft_record_page(ni: ctx->ntfs_ino); |
1828 | mark_mft_record_dirty(ni: ctx->ntfs_ino); |
1829 | err_out: |
1830 | if (ctx) |
1831 | ntfs_attr_put_search_ctx(ctx); |
1832 | if (m) |
1833 | unmap_mft_record(ni: base_ni); |
1834 | ni->runlist.rl = NULL; |
1835 | up_write(sem: &ni->runlist.lock); |
1836 | rl_err_out: |
1837 | if (rl) { |
1838 | if (ntfs_cluster_free_from_rl(vol, rl) < 0) { |
1839 | ntfs_error(vol->sb, "Failed to release allocated " |
1840 | "cluster(s) in error code path. Run " |
1841 | "chkdsk to recover the lost " |
1842 | "cluster(s)." ); |
1843 | NVolSetErrors(vol); |
1844 | } |
1845 | ntfs_free(addr: rl); |
1846 | page_err_out: |
1847 | unlock_page(page); |
1848 | put_page(page); |
1849 | } |
1850 | if (err == -EINVAL) |
1851 | err = -EIO; |
1852 | return err; |
1853 | } |
1854 | |
1855 | /** |
1856 | * ntfs_attr_extend_allocation - extend the allocated space of an attribute |
1857 | * @ni: ntfs inode of the attribute whose allocation to extend |
1858 | * @new_alloc_size: new size in bytes to which to extend the allocation to |
1859 | * @new_data_size: new size in bytes to which to extend the data to |
1860 | * @data_start: beginning of region which is required to be non-sparse |
1861 | * |
1862 | * Extend the allocated space of an attribute described by the ntfs inode @ni |
1863 | * to @new_alloc_size bytes. If @data_start is -1, the whole extension may be |
1864 | * implemented as a hole in the file (as long as both the volume and the ntfs |
1865 | * inode @ni have sparse support enabled). If @data_start is >= 0, then the |
1866 | * region between the old allocated size and @data_start - 1 may be made sparse |
1867 | * but the regions between @data_start and @new_alloc_size must be backed by |
1868 | * actual clusters. |
1869 | * |
1870 | * If @new_data_size is -1, it is ignored. If it is >= 0, then the data size |
1871 | * of the attribute is extended to @new_data_size. Note that the i_size of the |
1872 | * vfs inode is not updated. Only the data size in the base attribute record |
1873 | * is updated. The caller has to update i_size separately if this is required. |
1874 | * WARNING: It is a BUG() for @new_data_size to be smaller than the old data |
1875 | * size as well as for @new_data_size to be greater than @new_alloc_size. |
1876 | * |
1877 | * For resident attributes this involves resizing the attribute record and if |
1878 | * necessary moving it and/or other attributes into extent mft records and/or |
1879 | * converting the attribute to a non-resident attribute which in turn involves |
1880 | * extending the allocation of a non-resident attribute as described below. |
1881 | * |
1882 | * For non-resident attributes this involves allocating clusters in the data |
1883 | * zone on the volume (except for regions that are being made sparse) and |
1884 | * extending the run list to describe the allocated clusters as well as |
1885 | * updating the mapping pairs array of the attribute. This in turn involves |
1886 | * resizing the attribute record and if necessary moving it and/or other |
1887 | * attributes into extent mft records and/or splitting the attribute record |
1888 | * into multiple extent attribute records. |
1889 | * |
1890 | * Also, the attribute list attribute is updated if present and in some of the |
1891 | * above cases (the ones where extent mft records/attributes come into play), |
1892 | * an attribute list attribute is created if not already present. |
1893 | * |
1894 | * Return the new allocated size on success and -errno on error. In the case |
1895 | * that an error is encountered but a partial extension at least up to |
1896 | * @data_start (if present) is possible, the allocation is partially extended |
1897 | * and this is returned. This means the caller must check the returned size to |
1898 | * determine if the extension was partial. If @data_start is -1 then partial |
1899 | * allocations are not performed. |
1900 | * |
1901 | * WARNING: Do not call ntfs_attr_extend_allocation() for $MFT/$DATA. |
1902 | * |
1903 | * Locking: This function takes the runlist lock of @ni for writing as well as |
1904 | * locking the mft record of the base ntfs inode. These locks are maintained |
1905 | * throughout execution of the function. These locks are required so that the |
1906 | * attribute can be resized safely and so that it can for example be converted |
1907 | * from resident to non-resident safely. |
1908 | * |
1909 | * TODO: At present attribute list attribute handling is not implemented. |
1910 | * |
1911 | * TODO: At present it is not safe to call this function for anything other |
1912 | * than the $DATA attribute(s) of an uncompressed and unencrypted file. |
1913 | */ |
1914 | s64 ntfs_attr_extend_allocation(ntfs_inode *ni, s64 new_alloc_size, |
1915 | const s64 new_data_size, const s64 data_start) |
1916 | { |
1917 | VCN vcn; |
1918 | s64 ll, allocated_size, start = data_start; |
1919 | struct inode *vi = VFS_I(ni); |
1920 | ntfs_volume *vol = ni->vol; |
1921 | ntfs_inode *base_ni; |
1922 | MFT_RECORD *m; |
1923 | ATTR_RECORD *a; |
1924 | ntfs_attr_search_ctx *ctx; |
1925 | runlist_element *rl, *rl2; |
1926 | unsigned long flags; |
1927 | int err, mp_size; |
1928 | u32 attr_len = 0; /* Silence stupid gcc warning. */ |
1929 | bool mp_rebuilt; |
1930 | |
1931 | #ifdef DEBUG |
1932 | read_lock_irqsave(&ni->size_lock, flags); |
1933 | allocated_size = ni->allocated_size; |
1934 | read_unlock_irqrestore(&ni->size_lock, flags); |
1935 | ntfs_debug("Entering for i_ino 0x%lx, attribute type 0x%x, " |
1936 | "old_allocated_size 0x%llx, " |
1937 | "new_allocated_size 0x%llx, new_data_size 0x%llx, " |
1938 | "data_start 0x%llx." , vi->i_ino, |
1939 | (unsigned)le32_to_cpu(ni->type), |
1940 | (unsigned long long)allocated_size, |
1941 | (unsigned long long)new_alloc_size, |
1942 | (unsigned long long)new_data_size, |
1943 | (unsigned long long)start); |
1944 | #endif |
1945 | retry_extend: |
1946 | /* |
1947 | * For non-resident attributes, @start and @new_size need to be aligned |
1948 | * to cluster boundaries for allocation purposes. |
1949 | */ |
1950 | if (NInoNonResident(ni)) { |
1951 | if (start > 0) |
1952 | start &= ~(s64)vol->cluster_size_mask; |
1953 | new_alloc_size = (new_alloc_size + vol->cluster_size - 1) & |
1954 | ~(s64)vol->cluster_size_mask; |
1955 | } |
1956 | BUG_ON(new_data_size >= 0 && new_data_size > new_alloc_size); |
1957 | /* Check if new size is allowed in $AttrDef. */ |
1958 | err = ntfs_attr_size_bounds_check(vol, type: ni->type, size: new_alloc_size); |
1959 | if (unlikely(err)) { |
1960 | /* Only emit errors when the write will fail completely. */ |
1961 | read_lock_irqsave(&ni->size_lock, flags); |
1962 | allocated_size = ni->allocated_size; |
1963 | read_unlock_irqrestore(&ni->size_lock, flags); |
1964 | if (start < 0 || start >= allocated_size) { |
1965 | if (err == -ERANGE) { |
1966 | ntfs_error(vol->sb, "Cannot extend allocation " |
1967 | "of inode 0x%lx, attribute " |
1968 | "type 0x%x, because the new " |
1969 | "allocation would exceed the " |
1970 | "maximum allowed size for " |
1971 | "this attribute type." , |
1972 | vi->i_ino, (unsigned) |
1973 | le32_to_cpu(ni->type)); |
1974 | } else { |
1975 | ntfs_error(vol->sb, "Cannot extend allocation " |
1976 | "of inode 0x%lx, attribute " |
1977 | "type 0x%x, because this " |
1978 | "attribute type is not " |
1979 | "defined on the NTFS volume. " |
1980 | "Possible corruption! You " |
1981 | "should run chkdsk!" , |
1982 | vi->i_ino, (unsigned) |
1983 | le32_to_cpu(ni->type)); |
1984 | } |
1985 | } |
1986 | /* Translate error code to be POSIX conformant for write(2). */ |
1987 | if (err == -ERANGE) |
1988 | err = -EFBIG; |
1989 | else |
1990 | err = -EIO; |
1991 | return err; |
1992 | } |
1993 | if (!NInoAttr(ni)) |
1994 | base_ni = ni; |
1995 | else |
1996 | base_ni = ni->ext.base_ntfs_ino; |
1997 | /* |
1998 | * We will be modifying both the runlist (if non-resident) and the mft |
1999 | * record so lock them both down. |
2000 | */ |
2001 | down_write(sem: &ni->runlist.lock); |
2002 | m = map_mft_record(ni: base_ni); |
2003 | if (IS_ERR(ptr: m)) { |
2004 | err = PTR_ERR(ptr: m); |
2005 | m = NULL; |
2006 | ctx = NULL; |
2007 | goto err_out; |
2008 | } |
2009 | ctx = ntfs_attr_get_search_ctx(ni: base_ni, mrec: m); |
2010 | if (unlikely(!ctx)) { |
2011 | err = -ENOMEM; |
2012 | goto err_out; |
2013 | } |
2014 | read_lock_irqsave(&ni->size_lock, flags); |
2015 | allocated_size = ni->allocated_size; |
2016 | read_unlock_irqrestore(&ni->size_lock, flags); |
2017 | /* |
2018 | * If non-resident, seek to the last extent. If resident, there is |
2019 | * only one extent, so seek to that. |
2020 | */ |
2021 | vcn = NInoNonResident(ni) ? allocated_size >> vol->cluster_size_bits : |
2022 | 0; |
2023 | /* |
2024 | * Abort if someone did the work whilst we waited for the locks. If we |
2025 | * just converted the attribute from resident to non-resident it is |
2026 | * likely that exactly this has happened already. We cannot quite |
2027 | * abort if we need to update the data size. |
2028 | */ |
2029 | if (unlikely(new_alloc_size <= allocated_size)) { |
2030 | ntfs_debug("Allocated size already exceeds requested size." ); |
2031 | new_alloc_size = allocated_size; |
2032 | if (new_data_size < 0) |
2033 | goto done; |
2034 | /* |
2035 | * We want the first attribute extent so that we can update the |
2036 | * data size. |
2037 | */ |
2038 | vcn = 0; |
2039 | } |
2040 | err = ntfs_attr_lookup(type: ni->type, name: ni->name, name_len: ni->name_len, |
2041 | ic: CASE_SENSITIVE, lowest_vcn: vcn, NULL, val_len: 0, ctx); |
2042 | if (unlikely(err)) { |
2043 | if (err == -ENOENT) |
2044 | err = -EIO; |
2045 | goto err_out; |
2046 | } |
2047 | m = ctx->mrec; |
2048 | a = ctx->attr; |
2049 | /* Use goto to reduce indentation. */ |
2050 | if (a->non_resident) |
2051 | goto do_non_resident_extend; |
2052 | BUG_ON(NInoNonResident(ni)); |
2053 | /* The total length of the attribute value. */ |
2054 | attr_len = le32_to_cpu(a->data.resident.value_length); |
2055 | /* |
2056 | * Extend the attribute record to be able to store the new attribute |
2057 | * size. ntfs_attr_record_resize() will not do anything if the size is |
2058 | * not changing. |
2059 | */ |
2060 | if (new_alloc_size < vol->mft_record_size && |
2061 | !ntfs_attr_record_resize(m, a, |
2062 | le16_to_cpu(a->data.resident.value_offset) + |
2063 | new_alloc_size)) { |
2064 | /* The resize succeeded! */ |
2065 | write_lock_irqsave(&ni->size_lock, flags); |
2066 | ni->allocated_size = le32_to_cpu(a->length) - |
2067 | le16_to_cpu(a->data.resident.value_offset); |
2068 | write_unlock_irqrestore(&ni->size_lock, flags); |
2069 | if (new_data_size >= 0) { |
2070 | BUG_ON(new_data_size < attr_len); |
2071 | a->data.resident.value_length = |
2072 | cpu_to_le32((u32)new_data_size); |
2073 | } |
2074 | goto flush_done; |
2075 | } |
2076 | /* |
2077 | * We have to drop all the locks so we can call |
2078 | * ntfs_attr_make_non_resident(). This could be optimised by try- |
2079 | * locking the first page cache page and only if that fails dropping |
2080 | * the locks, locking the page, and redoing all the locking and |
2081 | * lookups. While this would be a huge optimisation, it is not worth |
2082 | * it as this is definitely a slow code path. |
2083 | */ |
2084 | ntfs_attr_put_search_ctx(ctx); |
2085 | unmap_mft_record(ni: base_ni); |
2086 | up_write(sem: &ni->runlist.lock); |
2087 | /* |
2088 | * Not enough space in the mft record, try to make the attribute |
2089 | * non-resident and if successful restart the extension process. |
2090 | */ |
2091 | err = ntfs_attr_make_non_resident(ni, data_size: attr_len); |
2092 | if (likely(!err)) |
2093 | goto retry_extend; |
2094 | /* |
2095 | * Could not make non-resident. If this is due to this not being |
2096 | * permitted for this attribute type or there not being enough space, |
2097 | * try to make other attributes non-resident. Otherwise fail. |
2098 | */ |
2099 | if (unlikely(err != -EPERM && err != -ENOSPC)) { |
2100 | /* Only emit errors when the write will fail completely. */ |
2101 | read_lock_irqsave(&ni->size_lock, flags); |
2102 | allocated_size = ni->allocated_size; |
2103 | read_unlock_irqrestore(&ni->size_lock, flags); |
2104 | if (start < 0 || start >= allocated_size) |
2105 | ntfs_error(vol->sb, "Cannot extend allocation of " |
2106 | "inode 0x%lx, attribute type 0x%x, " |
2107 | "because the conversion from resident " |
2108 | "to non-resident attribute failed " |
2109 | "with error code %i." , vi->i_ino, |
2110 | (unsigned)le32_to_cpu(ni->type), err); |
2111 | if (err != -ENOMEM) |
2112 | err = -EIO; |
2113 | goto conv_err_out; |
2114 | } |
2115 | /* TODO: Not implemented from here, abort. */ |
2116 | read_lock_irqsave(&ni->size_lock, flags); |
2117 | allocated_size = ni->allocated_size; |
2118 | read_unlock_irqrestore(&ni->size_lock, flags); |
2119 | if (start < 0 || start >= allocated_size) { |
2120 | if (err == -ENOSPC) |
2121 | ntfs_error(vol->sb, "Not enough space in the mft " |
2122 | "record/on disk for the non-resident " |
2123 | "attribute value. This case is not " |
2124 | "implemented yet." ); |
2125 | else /* if (err == -EPERM) */ |
2126 | ntfs_error(vol->sb, "This attribute type may not be " |
2127 | "non-resident. This case is not " |
2128 | "implemented yet." ); |
2129 | } |
2130 | err = -EOPNOTSUPP; |
2131 | goto conv_err_out; |
2132 | #if 0 |
2133 | // TODO: Attempt to make other attributes non-resident. |
2134 | if (!err) |
2135 | goto do_resident_extend; |
2136 | /* |
2137 | * Both the attribute list attribute and the standard information |
2138 | * attribute must remain in the base inode. Thus, if this is one of |
2139 | * these attributes, we have to try to move other attributes out into |
2140 | * extent mft records instead. |
2141 | */ |
2142 | if (ni->type == AT_ATTRIBUTE_LIST || |
2143 | ni->type == AT_STANDARD_INFORMATION) { |
2144 | // TODO: Attempt to move other attributes into extent mft |
2145 | // records. |
2146 | err = -EOPNOTSUPP; |
2147 | if (!err) |
2148 | goto do_resident_extend; |
2149 | goto err_out; |
2150 | } |
2151 | // TODO: Attempt to move this attribute to an extent mft record, but |
2152 | // only if it is not already the only attribute in an mft record in |
2153 | // which case there would be nothing to gain. |
2154 | err = -EOPNOTSUPP; |
2155 | if (!err) |
2156 | goto do_resident_extend; |
2157 | /* There is nothing we can do to make enough space. )-: */ |
2158 | goto err_out; |
2159 | #endif |
2160 | do_non_resident_extend: |
2161 | BUG_ON(!NInoNonResident(ni)); |
2162 | if (new_alloc_size == allocated_size) { |
2163 | BUG_ON(vcn); |
2164 | goto alloc_done; |
2165 | } |
2166 | /* |
2167 | * If the data starts after the end of the old allocation, this is a |
2168 | * $DATA attribute and sparse attributes are enabled on the volume and |
2169 | * for this inode, then create a sparse region between the old |
2170 | * allocated size and the start of the data. Otherwise simply proceed |
2171 | * with filling the whole space between the old allocated size and the |
2172 | * new allocated size with clusters. |
2173 | */ |
2174 | if ((start >= 0 && start <= allocated_size) || ni->type != AT_DATA || |
2175 | !NVolSparseEnabled(vol) || NInoSparseDisabled(ni)) |
2176 | goto skip_sparse; |
2177 | // TODO: This is not implemented yet. We just fill in with real |
2178 | // clusters for now... |
2179 | ntfs_debug("Inserting holes is not-implemented yet. Falling back to " |
2180 | "allocating real clusters instead." ); |
2181 | skip_sparse: |
2182 | rl = ni->runlist.rl; |
2183 | if (likely(rl)) { |
2184 | /* Seek to the end of the runlist. */ |
2185 | while (rl->length) |
2186 | rl++; |
2187 | } |
2188 | /* If this attribute extent is not mapped, map it now. */ |
2189 | if (unlikely(!rl || rl->lcn == LCN_RL_NOT_MAPPED || |
2190 | (rl->lcn == LCN_ENOENT && rl > ni->runlist.rl && |
2191 | (rl-1)->lcn == LCN_RL_NOT_MAPPED))) { |
2192 | if (!rl && !allocated_size) |
2193 | goto first_alloc; |
2194 | rl = ntfs_mapping_pairs_decompress(vol, attr: a, old_rl: ni->runlist.rl); |
2195 | if (IS_ERR(ptr: rl)) { |
2196 | err = PTR_ERR(ptr: rl); |
2197 | if (start < 0 || start >= allocated_size) |
2198 | ntfs_error(vol->sb, "Cannot extend allocation " |
2199 | "of inode 0x%lx, attribute " |
2200 | "type 0x%x, because the " |
2201 | "mapping of a runlist " |
2202 | "fragment failed with error " |
2203 | "code %i." , vi->i_ino, |
2204 | (unsigned)le32_to_cpu(ni->type), |
2205 | err); |
2206 | if (err != -ENOMEM) |
2207 | err = -EIO; |
2208 | goto err_out; |
2209 | } |
2210 | ni->runlist.rl = rl; |
2211 | /* Seek to the end of the runlist. */ |
2212 | while (rl->length) |
2213 | rl++; |
2214 | } |
2215 | /* |
2216 | * We now know the runlist of the last extent is mapped and @rl is at |
2217 | * the end of the runlist. We want to begin allocating clusters |
2218 | * starting at the last allocated cluster to reduce fragmentation. If |
2219 | * there are no valid LCNs in the attribute we let the cluster |
2220 | * allocator choose the starting cluster. |
2221 | */ |
2222 | /* If the last LCN is a hole or simillar seek back to last real LCN. */ |
2223 | while (rl->lcn < 0 && rl > ni->runlist.rl) |
2224 | rl--; |
2225 | first_alloc: |
2226 | // FIXME: Need to implement partial allocations so at least part of the |
2227 | // write can be performed when start >= 0. (Needed for POSIX write(2) |
2228 | // conformance.) |
2229 | rl2 = ntfs_cluster_alloc(vol, start_vcn: allocated_size >> vol->cluster_size_bits, |
2230 | count: (new_alloc_size - allocated_size) >> |
2231 | vol->cluster_size_bits, start_lcn: (rl && (rl->lcn >= 0)) ? |
2232 | rl->lcn + rl->length : -1, zone: DATA_ZONE, is_extension: true); |
2233 | if (IS_ERR(ptr: rl2)) { |
2234 | err = PTR_ERR(ptr: rl2); |
2235 | if (start < 0 || start >= allocated_size) |
2236 | ntfs_error(vol->sb, "Cannot extend allocation of " |
2237 | "inode 0x%lx, attribute type 0x%x, " |
2238 | "because the allocation of clusters " |
2239 | "failed with error code %i." , vi->i_ino, |
2240 | (unsigned)le32_to_cpu(ni->type), err); |
2241 | if (err != -ENOMEM && err != -ENOSPC) |
2242 | err = -EIO; |
2243 | goto err_out; |
2244 | } |
2245 | rl = ntfs_runlists_merge(drl: ni->runlist.rl, srl: rl2); |
2246 | if (IS_ERR(ptr: rl)) { |
2247 | err = PTR_ERR(ptr: rl); |
2248 | if (start < 0 || start >= allocated_size) |
2249 | ntfs_error(vol->sb, "Cannot extend allocation of " |
2250 | "inode 0x%lx, attribute type 0x%x, " |
2251 | "because the runlist merge failed " |
2252 | "with error code %i." , vi->i_ino, |
2253 | (unsigned)le32_to_cpu(ni->type), err); |
2254 | if (err != -ENOMEM) |
2255 | err = -EIO; |
2256 | if (ntfs_cluster_free_from_rl(vol, rl: rl2)) { |
2257 | ntfs_error(vol->sb, "Failed to release allocated " |
2258 | "cluster(s) in error code path. Run " |
2259 | "chkdsk to recover the lost " |
2260 | "cluster(s)." ); |
2261 | NVolSetErrors(vol); |
2262 | } |
2263 | ntfs_free(addr: rl2); |
2264 | goto err_out; |
2265 | } |
2266 | ni->runlist.rl = rl; |
2267 | ntfs_debug("Allocated 0x%llx clusters." , (long long)(new_alloc_size - |
2268 | allocated_size) >> vol->cluster_size_bits); |
2269 | /* Find the runlist element with which the attribute extent starts. */ |
2270 | ll = sle64_to_cpu(x: a->data.non_resident.lowest_vcn); |
2271 | rl2 = ntfs_rl_find_vcn_nolock(rl, vcn: ll); |
2272 | BUG_ON(!rl2); |
2273 | BUG_ON(!rl2->length); |
2274 | BUG_ON(rl2->lcn < LCN_HOLE); |
2275 | mp_rebuilt = false; |
2276 | /* Get the size for the new mapping pairs array for this extent. */ |
2277 | mp_size = ntfs_get_size_for_mapping_pairs(vol, rl: rl2, first_vcn: ll, last_vcn: -1); |
2278 | if (unlikely(mp_size <= 0)) { |
2279 | err = mp_size; |
2280 | if (start < 0 || start >= allocated_size) |
2281 | ntfs_error(vol->sb, "Cannot extend allocation of " |
2282 | "inode 0x%lx, attribute type 0x%x, " |
2283 | "because determining the size for the " |
2284 | "mapping pairs failed with error code " |
2285 | "%i." , vi->i_ino, |
2286 | (unsigned)le32_to_cpu(ni->type), err); |
2287 | err = -EIO; |
2288 | goto undo_alloc; |
2289 | } |
2290 | /* Extend the attribute record to fit the bigger mapping pairs array. */ |
2291 | attr_len = le32_to_cpu(a->length); |
2292 | err = ntfs_attr_record_resize(m, a, new_size: mp_size + |
2293 | le16_to_cpu(a->data.non_resident.mapping_pairs_offset)); |
2294 | if (unlikely(err)) { |
2295 | BUG_ON(err != -ENOSPC); |
2296 | // TODO: Deal with this by moving this extent to a new mft |
2297 | // record or by starting a new extent in a new mft record, |
2298 | // possibly by extending this extent partially and filling it |
2299 | // and creating a new extent for the remainder, or by making |
2300 | // other attributes non-resident and/or by moving other |
2301 | // attributes out of this mft record. |
2302 | if (start < 0 || start >= allocated_size) |
2303 | ntfs_error(vol->sb, "Not enough space in the mft " |
2304 | "record for the extended attribute " |
2305 | "record. This case is not " |
2306 | "implemented yet." ); |
2307 | err = -EOPNOTSUPP; |
2308 | goto undo_alloc; |
2309 | } |
2310 | mp_rebuilt = true; |
2311 | /* Generate the mapping pairs array directly into the attr record. */ |
2312 | err = ntfs_mapping_pairs_build(vol, dst: (u8*)a + |
2313 | le16_to_cpu(a->data.non_resident.mapping_pairs_offset), |
2314 | dst_len: mp_size, rl: rl2, first_vcn: ll, last_vcn: -1, NULL); |
2315 | if (unlikely(err)) { |
2316 | if (start < 0 || start >= allocated_size) |
2317 | ntfs_error(vol->sb, "Cannot extend allocation of " |
2318 | "inode 0x%lx, attribute type 0x%x, " |
2319 | "because building the mapping pairs " |
2320 | "failed with error code %i." , vi->i_ino, |
2321 | (unsigned)le32_to_cpu(ni->type), err); |
2322 | err = -EIO; |
2323 | goto undo_alloc; |
2324 | } |
2325 | /* Update the highest_vcn. */ |
2326 | a->data.non_resident.highest_vcn = cpu_to_sle64(x: (new_alloc_size >> |
2327 | vol->cluster_size_bits) - 1); |
2328 | /* |
2329 | * We now have extended the allocated size of the attribute. Reflect |
2330 | * this in the ntfs_inode structure and the attribute record. |
2331 | */ |
2332 | if (a->data.non_resident.lowest_vcn) { |
2333 | /* |
2334 | * We are not in the first attribute extent, switch to it, but |
2335 | * first ensure the changes will make it to disk later. |
2336 | */ |
2337 | flush_dcache_mft_record_page(ni: ctx->ntfs_ino); |
2338 | mark_mft_record_dirty(ni: ctx->ntfs_ino); |
2339 | ntfs_attr_reinit_search_ctx(ctx); |
2340 | err = ntfs_attr_lookup(type: ni->type, name: ni->name, name_len: ni->name_len, |
2341 | ic: CASE_SENSITIVE, lowest_vcn: 0, NULL, val_len: 0, ctx); |
2342 | if (unlikely(err)) |
2343 | goto restore_undo_alloc; |
2344 | /* @m is not used any more so no need to set it. */ |
2345 | a = ctx->attr; |
2346 | } |
2347 | write_lock_irqsave(&ni->size_lock, flags); |
2348 | ni->allocated_size = new_alloc_size; |
2349 | a->data.non_resident.allocated_size = cpu_to_sle64(x: new_alloc_size); |
2350 | /* |
2351 | * FIXME: This would fail if @ni is a directory, $MFT, or an index, |
2352 | * since those can have sparse/compressed set. For example can be |
2353 | * set compressed even though it is not compressed itself and in that |
2354 | * case the bit means that files are to be created compressed in the |
2355 | * directory... At present this is ok as this code is only called for |
2356 | * regular files, and only for their $DATA attribute(s). |
2357 | * FIXME: The calculation is wrong if we created a hole above. For now |
2358 | * it does not matter as we never create holes. |
2359 | */ |
2360 | if (NInoSparse(ni) || NInoCompressed(ni)) { |
2361 | ni->itype.compressed.size += new_alloc_size - allocated_size; |
2362 | a->data.non_resident.compressed_size = |
2363 | cpu_to_sle64(x: ni->itype.compressed.size); |
2364 | vi->i_blocks = ni->itype.compressed.size >> 9; |
2365 | } else |
2366 | vi->i_blocks = new_alloc_size >> 9; |
2367 | write_unlock_irqrestore(&ni->size_lock, flags); |
2368 | alloc_done: |
2369 | if (new_data_size >= 0) { |
2370 | BUG_ON(new_data_size < |
2371 | sle64_to_cpu(a->data.non_resident.data_size)); |
2372 | a->data.non_resident.data_size = cpu_to_sle64(x: new_data_size); |
2373 | } |
2374 | flush_done: |
2375 | /* Ensure the changes make it to disk. */ |
2376 | flush_dcache_mft_record_page(ni: ctx->ntfs_ino); |
2377 | mark_mft_record_dirty(ni: ctx->ntfs_ino); |
2378 | done: |
2379 | ntfs_attr_put_search_ctx(ctx); |
2380 | unmap_mft_record(ni: base_ni); |
2381 | up_write(sem: &ni->runlist.lock); |
2382 | ntfs_debug("Done, new_allocated_size 0x%llx." , |
2383 | (unsigned long long)new_alloc_size); |
2384 | return new_alloc_size; |
2385 | restore_undo_alloc: |
2386 | if (start < 0 || start >= allocated_size) |
2387 | ntfs_error(vol->sb, "Cannot complete extension of allocation " |
2388 | "of inode 0x%lx, attribute type 0x%x, because " |
2389 | "lookup of first attribute extent failed with " |
2390 | "error code %i." , vi->i_ino, |
2391 | (unsigned)le32_to_cpu(ni->type), err); |
2392 | if (err == -ENOENT) |
2393 | err = -EIO; |
2394 | ntfs_attr_reinit_search_ctx(ctx); |
2395 | if (ntfs_attr_lookup(type: ni->type, name: ni->name, name_len: ni->name_len, ic: CASE_SENSITIVE, |
2396 | lowest_vcn: allocated_size >> vol->cluster_size_bits, NULL, val_len: 0, |
2397 | ctx)) { |
2398 | ntfs_error(vol->sb, "Failed to find last attribute extent of " |
2399 | "attribute in error code path. Run chkdsk to " |
2400 | "recover." ); |
2401 | write_lock_irqsave(&ni->size_lock, flags); |
2402 | ni->allocated_size = new_alloc_size; |
2403 | /* |
2404 | * FIXME: This would fail if @ni is a directory... See above. |
2405 | * FIXME: The calculation is wrong if we created a hole above. |
2406 | * For now it does not matter as we never create holes. |
2407 | */ |
2408 | if (NInoSparse(ni) || NInoCompressed(ni)) { |
2409 | ni->itype.compressed.size += new_alloc_size - |
2410 | allocated_size; |
2411 | vi->i_blocks = ni->itype.compressed.size >> 9; |
2412 | } else |
2413 | vi->i_blocks = new_alloc_size >> 9; |
2414 | write_unlock_irqrestore(&ni->size_lock, flags); |
2415 | ntfs_attr_put_search_ctx(ctx); |
2416 | unmap_mft_record(ni: base_ni); |
2417 | up_write(sem: &ni->runlist.lock); |
2418 | /* |
2419 | * The only thing that is now wrong is the allocated size of the |
2420 | * base attribute extent which chkdsk should be able to fix. |
2421 | */ |
2422 | NVolSetErrors(vol); |
2423 | return err; |
2424 | } |
2425 | ctx->attr->data.non_resident.highest_vcn = cpu_to_sle64( |
2426 | x: (allocated_size >> vol->cluster_size_bits) - 1); |
2427 | undo_alloc: |
2428 | ll = allocated_size >> vol->cluster_size_bits; |
2429 | if (ntfs_cluster_free(ni, start_vcn: ll, count: -1, ctx) < 0) { |
2430 | ntfs_error(vol->sb, "Failed to release allocated cluster(s) " |
2431 | "in error code path. Run chkdsk to recover " |
2432 | "the lost cluster(s)." ); |
2433 | NVolSetErrors(vol); |
2434 | } |
2435 | m = ctx->mrec; |
2436 | a = ctx->attr; |
2437 | /* |
2438 | * If the runlist truncation fails and/or the search context is no |
2439 | * longer valid, we cannot resize the attribute record or build the |
2440 | * mapping pairs array thus we mark the inode bad so that no access to |
2441 | * the freed clusters can happen. |
2442 | */ |
2443 | if (ntfs_rl_truncate_nolock(vol, runlist: &ni->runlist, new_length: ll) || IS_ERR(ptr: m)) { |
2444 | ntfs_error(vol->sb, "Failed to %s in error code path. Run " |
2445 | "chkdsk to recover." , IS_ERR(m) ? |
2446 | "restore attribute search context" : |
2447 | "truncate attribute runlist" ); |
2448 | NVolSetErrors(vol); |
2449 | } else if (mp_rebuilt) { |
2450 | if (ntfs_attr_record_resize(m, a, new_size: attr_len)) { |
2451 | ntfs_error(vol->sb, "Failed to restore attribute " |
2452 | "record in error code path. Run " |
2453 | "chkdsk to recover." ); |
2454 | NVolSetErrors(vol); |
2455 | } else /* if (success) */ { |
2456 | if (ntfs_mapping_pairs_build(vol, dst: (u8*)a + le16_to_cpu( |
2457 | a->data.non_resident. |
2458 | mapping_pairs_offset), dst_len: attr_len - |
2459 | le16_to_cpu(a->data.non_resident. |
2460 | mapping_pairs_offset), rl: rl2, first_vcn: ll, last_vcn: -1, |
2461 | NULL)) { |
2462 | ntfs_error(vol->sb, "Failed to restore " |
2463 | "mapping pairs array in error " |
2464 | "code path. Run chkdsk to " |
2465 | "recover." ); |
2466 | NVolSetErrors(vol); |
2467 | } |
2468 | flush_dcache_mft_record_page(ni: ctx->ntfs_ino); |
2469 | mark_mft_record_dirty(ni: ctx->ntfs_ino); |
2470 | } |
2471 | } |
2472 | err_out: |
2473 | if (ctx) |
2474 | ntfs_attr_put_search_ctx(ctx); |
2475 | if (m) |
2476 | unmap_mft_record(ni: base_ni); |
2477 | up_write(sem: &ni->runlist.lock); |
2478 | conv_err_out: |
2479 | ntfs_debug("Failed. Returning error code %i." , err); |
2480 | return err; |
2481 | } |
2482 | |
2483 | /** |
2484 | * ntfs_attr_set - fill (a part of) an attribute with a byte |
2485 | * @ni: ntfs inode describing the attribute to fill |
2486 | * @ofs: offset inside the attribute at which to start to fill |
2487 | * @cnt: number of bytes to fill |
2488 | * @val: the unsigned 8-bit value with which to fill the attribute |
2489 | * |
2490 | * Fill @cnt bytes of the attribute described by the ntfs inode @ni starting at |
2491 | * byte offset @ofs inside the attribute with the constant byte @val. |
2492 | * |
2493 | * This function is effectively like memset() applied to an ntfs attribute. |
2494 | * Note this function actually only operates on the page cache pages belonging |
2495 | * to the ntfs attribute and it marks them dirty after doing the memset(). |
2496 | * Thus it relies on the vm dirty page write code paths to cause the modified |
2497 | * pages to be written to the mft record/disk. |
2498 | * |
2499 | * Return 0 on success and -errno on error. An error code of -ESPIPE means |
2500 | * that @ofs + @cnt were outside the end of the attribute and no write was |
2501 | * performed. |
2502 | */ |
2503 | int ntfs_attr_set(ntfs_inode *ni, const s64 ofs, const s64 cnt, const u8 val) |
2504 | { |
2505 | ntfs_volume *vol = ni->vol; |
2506 | struct address_space *mapping; |
2507 | struct page *page; |
2508 | u8 *kaddr; |
2509 | pgoff_t idx, end; |
2510 | unsigned start_ofs, end_ofs, size; |
2511 | |
2512 | ntfs_debug("Entering for ofs 0x%llx, cnt 0x%llx, val 0x%hx." , |
2513 | (long long)ofs, (long long)cnt, val); |
2514 | BUG_ON(ofs < 0); |
2515 | BUG_ON(cnt < 0); |
2516 | if (!cnt) |
2517 | goto done; |
2518 | /* |
2519 | * FIXME: Compressed and encrypted attributes are not supported when |
2520 | * writing and we should never have gotten here for them. |
2521 | */ |
2522 | BUG_ON(NInoCompressed(ni)); |
2523 | BUG_ON(NInoEncrypted(ni)); |
2524 | mapping = VFS_I(ni)->i_mapping; |
2525 | /* Work out the starting index and page offset. */ |
2526 | idx = ofs >> PAGE_SHIFT; |
2527 | start_ofs = ofs & ~PAGE_MASK; |
2528 | /* Work out the ending index and page offset. */ |
2529 | end = ofs + cnt; |
2530 | end_ofs = end & ~PAGE_MASK; |
2531 | /* If the end is outside the inode size return -ESPIPE. */ |
2532 | if (unlikely(end > i_size_read(VFS_I(ni)))) { |
2533 | ntfs_error(vol->sb, "Request exceeds end of attribute." ); |
2534 | return -ESPIPE; |
2535 | } |
2536 | end >>= PAGE_SHIFT; |
2537 | /* If there is a first partial page, need to do it the slow way. */ |
2538 | if (start_ofs) { |
2539 | page = read_mapping_page(mapping, index: idx, NULL); |
2540 | if (IS_ERR(ptr: page)) { |
2541 | ntfs_error(vol->sb, "Failed to read first partial " |
2542 | "page (error, index 0x%lx)." , idx); |
2543 | return PTR_ERR(ptr: page); |
2544 | } |
2545 | /* |
2546 | * If the last page is the same as the first page, need to |
2547 | * limit the write to the end offset. |
2548 | */ |
2549 | size = PAGE_SIZE; |
2550 | if (idx == end) |
2551 | size = end_ofs; |
2552 | kaddr = kmap_atomic(page); |
2553 | memset(kaddr + start_ofs, val, size - start_ofs); |
2554 | flush_dcache_page(page); |
2555 | kunmap_atomic(kaddr); |
2556 | set_page_dirty(page); |
2557 | put_page(page); |
2558 | balance_dirty_pages_ratelimited(mapping); |
2559 | cond_resched(); |
2560 | if (idx == end) |
2561 | goto done; |
2562 | idx++; |
2563 | } |
2564 | /* Do the whole pages the fast way. */ |
2565 | for (; idx < end; idx++) { |
2566 | /* Find or create the current page. (The page is locked.) */ |
2567 | page = grab_cache_page(mapping, index: idx); |
2568 | if (unlikely(!page)) { |
2569 | ntfs_error(vol->sb, "Insufficient memory to grab " |
2570 | "page (index 0x%lx)." , idx); |
2571 | return -ENOMEM; |
2572 | } |
2573 | kaddr = kmap_atomic(page); |
2574 | memset(kaddr, val, PAGE_SIZE); |
2575 | flush_dcache_page(page); |
2576 | kunmap_atomic(kaddr); |
2577 | /* |
2578 | * If the page has buffers, mark them uptodate since buffer |
2579 | * state and not page state is definitive in 2.6 kernels. |
2580 | */ |
2581 | if (page_has_buffers(page)) { |
2582 | struct buffer_head *bh, *head; |
2583 | |
2584 | bh = head = page_buffers(page); |
2585 | do { |
2586 | set_buffer_uptodate(bh); |
2587 | } while ((bh = bh->b_this_page) != head); |
2588 | } |
2589 | /* Now that buffers are uptodate, set the page uptodate, too. */ |
2590 | SetPageUptodate(page); |
2591 | /* |
2592 | * Set the page and all its buffers dirty and mark the inode |
2593 | * dirty, too. The VM will write the page later on. |
2594 | */ |
2595 | set_page_dirty(page); |
2596 | /* Finally unlock and release the page. */ |
2597 | unlock_page(page); |
2598 | put_page(page); |
2599 | balance_dirty_pages_ratelimited(mapping); |
2600 | cond_resched(); |
2601 | } |
2602 | /* If there is a last partial page, need to do it the slow way. */ |
2603 | if (end_ofs) { |
2604 | page = read_mapping_page(mapping, index: idx, NULL); |
2605 | if (IS_ERR(ptr: page)) { |
2606 | ntfs_error(vol->sb, "Failed to read last partial page " |
2607 | "(error, index 0x%lx)." , idx); |
2608 | return PTR_ERR(ptr: page); |
2609 | } |
2610 | kaddr = kmap_atomic(page); |
2611 | memset(kaddr, val, end_ofs); |
2612 | flush_dcache_page(page); |
2613 | kunmap_atomic(kaddr); |
2614 | set_page_dirty(page); |
2615 | put_page(page); |
2616 | balance_dirty_pages_ratelimited(mapping); |
2617 | cond_resched(); |
2618 | } |
2619 | done: |
2620 | ntfs_debug("Done." ); |
2621 | return 0; |
2622 | } |
2623 | |
2624 | #endif /* NTFS_RW */ |
2625 | |