2 * This file is part of UBIFS.
4 * Copyright (C) 2006-2008 Nokia Corporation
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 as published by
8 * the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc., 51
17 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 * Authors: Adrian Hunter
20 * Artem Bityutskiy (Битюцкий Артём)
24 * This file implements the scan which is a general-purpose function for
25 * determining what nodes are in an eraseblock. The scan is used to replay the
26 * journal, to do garbage collection. for the TNC in-the-gaps method, and by
27 * debugging functions.
33 * scan_padding_bytes - scan for padding bytes.
34 * @buf: buffer to scan
35 * @len: length of buffer
37 * This function returns the number of padding bytes on success and
38 * %SCANNED_GARBAGE on failure.
40 static int scan_padding_bytes(void *buf
, int len
)
42 int pad_len
= 0, max_pad_len
= min_t(int, UBIFS_PAD_NODE_SZ
, len
);
45 dbg_scan("not a node");
47 while (pad_len
< max_pad_len
&& *p
++ == UBIFS_PADDING_BYTE
)
50 if (!pad_len
|| (pad_len
& 7))
51 return SCANNED_GARBAGE
;
53 dbg_scan("%d padding bytes", pad_len
);
59 * ubifs_scan_a_node - scan for a node or padding.
60 * @c: UBIFS file-system description object
61 * @buf: buffer to scan
62 * @len: length of buffer
63 * @lnum: logical eraseblock number
64 * @offs: offset within the logical eraseblock
65 * @quiet: print no messages
67 * This function returns a scanning code to indicate what was scanned.
69 int ubifs_scan_a_node(const struct ubifs_info
*c
, void *buf
, int len
, int lnum
,
72 struct ubifs_ch
*ch
= buf
;
75 magic
= le32_to_cpu(ch
->magic
);
77 if (magic
== 0xFFFFFFFF) {
78 dbg_scan("hit empty space");
79 return SCANNED_EMPTY_SPACE
;
82 if (magic
!= UBIFS_NODE_MAGIC
)
83 return scan_padding_bytes(buf
, len
);
85 if (len
< UBIFS_CH_SZ
)
86 return SCANNED_GARBAGE
;
88 dbg_scan("scanning %s", dbg_ntype(ch
->node_type
));
90 if (ubifs_check_node(c
, buf
, lnum
, offs
, quiet
, 1))
91 return SCANNED_A_CORRUPT_NODE
;
93 if (ch
->node_type
== UBIFS_PAD_NODE
) {
94 struct ubifs_pad_node
*pad
= buf
;
95 int pad_len
= le32_to_cpu(pad
->pad_len
);
96 int node_len
= le32_to_cpu(ch
->len
);
98 /* Validate the padding node */
100 offs
+ node_len
+ pad_len
> c
->leb_size
) {
102 ubifs_err("bad pad node at LEB %d:%d",
104 dbg_dump_node(c
, pad
);
106 return SCANNED_A_BAD_PAD_NODE
;
109 /* Make the node pads to 8-byte boundary */
110 if ((node_len
+ pad_len
) & 7) {
112 dbg_err("bad padding length %d - %d",
113 offs
, offs
+ node_len
+ pad_len
);
114 return SCANNED_A_BAD_PAD_NODE
;
117 dbg_scan("%d bytes padded, offset now %d",
118 pad_len
, ALIGN(offs
+ node_len
+ pad_len
, 8));
120 return node_len
+ pad_len
;
123 return SCANNED_A_NODE
;
127 * ubifs_start_scan - create LEB scanning information at start of scan.
128 * @c: UBIFS file-system description object
129 * @lnum: logical eraseblock number
130 * @offs: offset to start at (usually zero)
131 * @sbuf: scan buffer (must be c->leb_size)
133 * This function returns %0 on success and a negative error code on failure.
135 struct ubifs_scan_leb
*ubifs_start_scan(const struct ubifs_info
*c
, int lnum
,
136 int offs
, void *sbuf
)
138 struct ubifs_scan_leb
*sleb
;
141 dbg_scan("scan LEB %d:%d", lnum
, offs
);
143 sleb
= kzalloc(sizeof(struct ubifs_scan_leb
), GFP_NOFS
);
145 return ERR_PTR(-ENOMEM
);
148 INIT_LIST_HEAD(&sleb
->nodes
);
151 err
= ubi_read(c
->ubi
, lnum
, sbuf
+ offs
, offs
, c
->leb_size
- offs
);
152 if (err
&& err
!= -EBADMSG
) {
153 ubifs_err("cannot read %d bytes from LEB %d:%d,"
154 " error %d", c
->leb_size
- offs
, lnum
, offs
, err
);
166 * ubifs_end_scan - update LEB scanning information at end of scan.
167 * @c: UBIFS file-system description object
168 * @sleb: scanning information
169 * @lnum: logical eraseblock number
170 * @offs: offset to start at (usually zero)
172 * This function returns %0 on success and a negative error code on failure.
174 void ubifs_end_scan(const struct ubifs_info
*c
, struct ubifs_scan_leb
*sleb
,
178 dbg_scan("stop scanning LEB %d at offset %d", lnum
, offs
);
179 ubifs_assert(offs
% c
->min_io_size
== 0);
181 sleb
->endpt
= ALIGN(offs
, c
->min_io_size
);
185 * ubifs_add_snod - add a scanned node to LEB scanning information.
186 * @c: UBIFS file-system description object
187 * @sleb: scanning information
188 * @buf: buffer containing node
189 * @offs: offset of node on flash
191 * This function returns %0 on success and a negative error code on failure.
193 int ubifs_add_snod(const struct ubifs_info
*c
, struct ubifs_scan_leb
*sleb
,
196 struct ubifs_ch
*ch
= buf
;
197 struct ubifs_ino_node
*ino
= buf
;
198 struct ubifs_scan_node
*snod
;
200 snod
= kmalloc(sizeof(struct ubifs_scan_node
), GFP_NOFS
);
204 snod
->sqnum
= le64_to_cpu(ch
->sqnum
);
205 snod
->type
= ch
->node_type
;
207 snod
->len
= le32_to_cpu(ch
->len
);
210 switch (ch
->node_type
) {
212 case UBIFS_DENT_NODE
:
213 case UBIFS_XENT_NODE
:
214 case UBIFS_DATA_NODE
:
216 * The key is in the same place in all keyed
219 key_read(c
, &ino
->key
, &snod
->key
);
222 invalid_key_init(c
, &snod
->key
);
225 list_add_tail(&snod
->list
, &sleb
->nodes
);
226 sleb
->nodes_cnt
+= 1;
231 * ubifs_scanned_corruption - print information after UBIFS scanned corruption.
232 * @c: UBIFS file-system description object
233 * @lnum: LEB number of corruption
234 * @offs: offset of corruption
235 * @buf: buffer containing corruption
237 void ubifs_scanned_corruption(const struct ubifs_info
*c
, int lnum
, int offs
,
242 ubifs_err("corruption at LEB %d:%d", lnum
, offs
);
243 if (dbg_failure_mode
)
245 len
= c
->leb_size
- offs
;
248 dbg_err("first %d bytes from LEB %d:%d", len
, lnum
, offs
);
249 print_hex_dump(KERN_DEBUG
, "", DUMP_PREFIX_OFFSET
, 32, 4, buf
, len
, 1);
253 * ubifs_scan - scan a logical eraseblock.
254 * @c: UBIFS file-system description object
255 * @lnum: logical eraseblock number
256 * @offs: offset to start at (usually zero)
257 * @sbuf: scan buffer (must be of @c->leb_size bytes in size)
258 * @quiet: print no messages
260 * This function scans LEB number @lnum and returns complete information about
261 * its contents. Returns the scaned information in case of success and,
262 * %-EUCLEAN if the LEB neads recovery, and other negative error codes in case
265 * If @quiet is non-zero, this function does not print large and scary
266 * error messages and flash dumps in case of errors.
268 struct ubifs_scan_leb
*ubifs_scan(const struct ubifs_info
*c
, int lnum
,
269 int offs
, void *sbuf
, int quiet
)
271 void *buf
= sbuf
+ offs
;
272 int err
, len
= c
->leb_size
- offs
;
273 struct ubifs_scan_leb
*sleb
;
275 sleb
= ubifs_start_scan(c
, lnum
, offs
, sbuf
);
280 struct ubifs_ch
*ch
= buf
;
283 dbg_scan("look at LEB %d:%d (%d bytes left)",
288 ret
= ubifs_scan_a_node(c
, buf
, len
, lnum
, offs
, quiet
);
290 /* Padding bytes or a valid padding node */
297 if (ret
== SCANNED_EMPTY_SPACE
)
298 /* Empty space is checked later */
302 case SCANNED_GARBAGE
:
307 case SCANNED_A_CORRUPT_NODE
:
308 case SCANNED_A_BAD_PAD_NODE
:
317 err
= ubifs_add_snod(c
, sleb
, buf
, offs
);
321 node_len
= ALIGN(le32_to_cpu(ch
->len
), 8);
327 if (offs
% c
->min_io_size
) {
329 ubifs_err("empty space starts at non-aligned offset %d",
334 ubifs_end_scan(c
, sleb
, lnum
, offs
);
336 for (; len
> 4; offs
+= 4, buf
= buf
+ 4, len
-= 4)
337 if (*(uint32_t *)buf
!= 0xffffffff)
339 for (; len
; offs
++, buf
++, len
--)
340 if (*(uint8_t *)buf
!= 0xff) {
342 ubifs_err("corrupt empty space at LEB %d:%d",
351 ubifs_scanned_corruption(c
, lnum
, offs
, buf
);
352 ubifs_err("LEB %d scanning failed", lnum
);
355 ubifs_scan_destroy(sleb
);
359 ubifs_err("LEB %d scanning failed, error %d", lnum
, err
);
360 ubifs_scan_destroy(sleb
);
365 * ubifs_scan_destroy - destroy LEB scanning information.
366 * @sleb: scanning information to free
368 void ubifs_scan_destroy(struct ubifs_scan_leb
*sleb
)
370 struct ubifs_scan_node
*node
;
371 struct list_head
*head
;
374 while (!list_empty(head
)) {
375 node
= list_entry(head
->next
, struct ubifs_scan_node
, list
);
376 list_del(&node
->list
);
This page took 0.037747 seconds and 5 git commands to generate.