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