1 | /* |
2 | * JFFS2 -- Journalling Flash File System, Version 2. |
3 | * |
4 | * Copyright © 2006 NEC Corporation |
5 | * |
6 | * Created by KaiGai Kohei <kaigai@ak.jp.nec.com> |
7 | * |
8 | * For licensing information, see the file 'LICENCE' in this directory. |
9 | * |
10 | */ |
11 | |
12 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
13 | |
14 | #define JFFS2_XATTR_IS_CORRUPTED 1 |
15 | |
16 | #include <linux/kernel.h> |
17 | #include <linux/slab.h> |
18 | #include <linux/fs.h> |
19 | #include <linux/time.h> |
20 | #include <linux/pagemap.h> |
21 | #include <linux/highmem.h> |
22 | #include <linux/crc32.h> |
23 | #include <linux/jffs2.h> |
24 | #include <linux/xattr.h> |
25 | #include <linux/posix_acl_xattr.h> |
26 | #include <linux/mtd/mtd.h> |
27 | #include "nodelist.h" |
28 | /* -------- xdatum related functions ---------------- |
29 | * xattr_datum_hashkey(xprefix, xname, xvalue, xsize) |
30 | * is used to calcurate xdatum hashkey. The reminder of hashkey into XATTRINDEX_HASHSIZE is |
31 | * the index of the xattr name/value pair cache (c->xattrindex). |
32 | * is_xattr_datum_unchecked(c, xd) |
33 | * returns 1, if xdatum contains any unchecked raw nodes. if all raw nodes are not |
34 | * unchecked, it returns 0. |
35 | * unload_xattr_datum(c, xd) |
36 | * is used to release xattr name/value pair and detach from c->xattrindex. |
37 | * reclaim_xattr_datum(c) |
38 | * is used to reclaim xattr name/value pairs on the xattr name/value pair cache when |
39 | * memory usage by cache is over c->xdatum_mem_threshold. Currently, this threshold |
40 | * is hard coded as 32KiB. |
41 | * do_verify_xattr_datum(c, xd) |
42 | * is used to load the xdatum informations without name/value pair from the medium. |
43 | * It's necessary once, because those informations are not collected during mounting |
44 | * process when EBS is enabled. |
45 | * 0 will be returned, if success. An negative return value means recoverable error, and |
46 | * positive return value means unrecoverable error. Thus, caller must remove this xdatum |
47 | * and xref when it returned positive value. |
48 | * do_load_xattr_datum(c, xd) |
49 | * is used to load name/value pair from the medium. |
50 | * The meanings of return value is same as do_verify_xattr_datum(). |
51 | * load_xattr_datum(c, xd) |
52 | * is used to be as a wrapper of do_verify_xattr_datum() and do_load_xattr_datum(). |
53 | * If xd need to call do_verify_xattr_datum() at first, it's called before calling |
54 | * do_load_xattr_datum(). The meanings of return value is same as do_verify_xattr_datum(). |
55 | * save_xattr_datum(c, xd) |
56 | * is used to write xdatum to medium. xd->version will be incremented. |
57 | * create_xattr_datum(c, xprefix, xname, xvalue, xsize) |
58 | * is used to create new xdatum and write to medium. |
59 | * unrefer_xattr_datum(c, xd) |
60 | * is used to delete a xdatum. When nobody refers this xdatum, JFFS2_XFLAGS_DEAD |
61 | * is set on xd->flags and chained xattr_dead_list or release it immediately. |
62 | * In the first case, the garbage collector release it later. |
63 | * -------------------------------------------------- */ |
64 | static uint32_t xattr_datum_hashkey(int xprefix, const char *xname, const char *xvalue, int xsize) |
65 | { |
66 | int name_len = strlen(xname); |
67 | |
68 | return crc32(xprefix, xname, name_len) ^ crc32(xprefix, xvalue, xsize); |
69 | } |
70 | |
71 | static int is_xattr_datum_unchecked(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd) |
72 | { |
73 | struct jffs2_raw_node_ref *raw; |
74 | int rc = 0; |
75 | |
76 | spin_lock(lock: &c->erase_completion_lock); |
77 | for (raw=xd->node; raw != (void *)xd; raw=raw->next_in_ino) { |
78 | if (ref_flags(raw) == REF_UNCHECKED) { |
79 | rc = 1; |
80 | break; |
81 | } |
82 | } |
83 | spin_unlock(lock: &c->erase_completion_lock); |
84 | return rc; |
85 | } |
86 | |
87 | static void unload_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd) |
88 | { |
89 | /* must be called under down_write(xattr_sem) */ |
90 | D1(dbg_xattr("%s: xid=%u, version=%u\n" , __func__, xd->xid, xd->version)); |
91 | if (xd->xname) { |
92 | c->xdatum_mem_usage -= (xd->name_len + 1 + xd->value_len); |
93 | kfree(objp: xd->xname); |
94 | } |
95 | |
96 | list_del_init(entry: &xd->xindex); |
97 | xd->hashkey = 0; |
98 | xd->xname = NULL; |
99 | xd->xvalue = NULL; |
100 | } |
101 | |
102 | static void reclaim_xattr_datum(struct jffs2_sb_info *c) |
103 | { |
104 | /* must be called under down_write(xattr_sem) */ |
105 | struct jffs2_xattr_datum *xd, *_xd; |
106 | uint32_t target, before; |
107 | static int index = 0; |
108 | int count; |
109 | |
110 | if (c->xdatum_mem_threshold > c->xdatum_mem_usage) |
111 | return; |
112 | |
113 | before = c->xdatum_mem_usage; |
114 | target = c->xdatum_mem_usage * 4 / 5; /* 20% reduction */ |
115 | for (count = 0; count < XATTRINDEX_HASHSIZE; count++) { |
116 | list_for_each_entry_safe(xd, _xd, &c->xattrindex[index], xindex) { |
117 | if (xd->flags & JFFS2_XFLAGS_HOT) { |
118 | xd->flags &= ~JFFS2_XFLAGS_HOT; |
119 | } else if (!(xd->flags & JFFS2_XFLAGS_BIND)) { |
120 | unload_xattr_datum(c, xd); |
121 | } |
122 | if (c->xdatum_mem_usage <= target) |
123 | goto out; |
124 | } |
125 | index = (index+1) % XATTRINDEX_HASHSIZE; |
126 | } |
127 | out: |
128 | JFFS2_NOTICE("xdatum_mem_usage from %u byte to %u byte (%u byte reclaimed)\n" , |
129 | before, c->xdatum_mem_usage, before - c->xdatum_mem_usage); |
130 | } |
131 | |
132 | static int do_verify_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd) |
133 | { |
134 | /* must be called under down_write(xattr_sem) */ |
135 | struct jffs2_eraseblock *jeb; |
136 | struct jffs2_raw_node_ref *raw; |
137 | struct jffs2_raw_xattr rx; |
138 | size_t readlen; |
139 | uint32_t crc, offset, totlen; |
140 | int rc; |
141 | |
142 | spin_lock(lock: &c->erase_completion_lock); |
143 | offset = ref_offset(xd->node); |
144 | if (ref_flags(xd->node) == REF_PRISTINE) |
145 | goto complete; |
146 | spin_unlock(lock: &c->erase_completion_lock); |
147 | |
148 | rc = jffs2_flash_read(c, ofs: offset, len: sizeof(rx), retlen: &readlen, buf: (char *)&rx); |
149 | if (rc || readlen != sizeof(rx)) { |
150 | JFFS2_WARNING("jffs2_flash_read()=%d, req=%zu, read=%zu at %#08x\n" , |
151 | rc, sizeof(rx), readlen, offset); |
152 | return rc ? rc : -EIO; |
153 | } |
154 | crc = crc32(0, &rx, sizeof(rx) - 4); |
155 | if (crc != je32_to_cpu(rx.node_crc)) { |
156 | JFFS2_ERROR("node CRC failed at %#08x, read=%#08x, calc=%#08x\n" , |
157 | offset, je32_to_cpu(rx.hdr_crc), crc); |
158 | xd->flags |= JFFS2_XFLAGS_INVALID; |
159 | return JFFS2_XATTR_IS_CORRUPTED; |
160 | } |
161 | totlen = PAD(sizeof(rx) + rx.name_len + 1 + je16_to_cpu(rx.value_len)); |
162 | if (je16_to_cpu(rx.magic) != JFFS2_MAGIC_BITMASK |
163 | || je16_to_cpu(rx.nodetype) != JFFS2_NODETYPE_XATTR |
164 | || je32_to_cpu(rx.totlen) != totlen |
165 | || je32_to_cpu(rx.xid) != xd->xid |
166 | || je32_to_cpu(rx.version) != xd->version) { |
167 | JFFS2_ERROR("inconsistent xdatum at %#08x, magic=%#04x/%#04x, " |
168 | "nodetype=%#04x/%#04x, totlen=%u/%u, xid=%u/%u, version=%u/%u\n" , |
169 | offset, je16_to_cpu(rx.magic), JFFS2_MAGIC_BITMASK, |
170 | je16_to_cpu(rx.nodetype), JFFS2_NODETYPE_XATTR, |
171 | je32_to_cpu(rx.totlen), totlen, |
172 | je32_to_cpu(rx.xid), xd->xid, |
173 | je32_to_cpu(rx.version), xd->version); |
174 | xd->flags |= JFFS2_XFLAGS_INVALID; |
175 | return JFFS2_XATTR_IS_CORRUPTED; |
176 | } |
177 | xd->xprefix = rx.xprefix; |
178 | xd->name_len = rx.name_len; |
179 | xd->value_len = je16_to_cpu(rx.value_len); |
180 | xd->data_crc = je32_to_cpu(rx.data_crc); |
181 | |
182 | spin_lock(lock: &c->erase_completion_lock); |
183 | complete: |
184 | for (raw=xd->node; raw != (void *)xd; raw=raw->next_in_ino) { |
185 | jeb = &c->blocks[ref_offset(raw) / c->sector_size]; |
186 | totlen = PAD(ref_totlen(c, jeb, raw)); |
187 | if (ref_flags(raw) == REF_UNCHECKED) { |
188 | c->unchecked_size -= totlen; c->used_size += totlen; |
189 | jeb->unchecked_size -= totlen; jeb->used_size += totlen; |
190 | } |
191 | raw->flash_offset = ref_offset(raw) | ((xd->node==raw) ? REF_PRISTINE : REF_NORMAL); |
192 | } |
193 | spin_unlock(lock: &c->erase_completion_lock); |
194 | |
195 | /* unchecked xdatum is chained with c->xattr_unchecked */ |
196 | list_del_init(entry: &xd->xindex); |
197 | |
198 | dbg_xattr("success on verifying xdatum (xid=%u, version=%u)\n" , |
199 | xd->xid, xd->version); |
200 | |
201 | return 0; |
202 | } |
203 | |
204 | static int do_load_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd) |
205 | { |
206 | /* must be called under down_write(xattr_sem) */ |
207 | char *data; |
208 | size_t readlen; |
209 | uint32_t crc, length; |
210 | int i, ret, retry = 0; |
211 | |
212 | BUG_ON(ref_flags(xd->node) != REF_PRISTINE); |
213 | BUG_ON(!list_empty(&xd->xindex)); |
214 | retry: |
215 | length = xd->name_len + 1 + xd->value_len; |
216 | data = kmalloc(size: length, GFP_KERNEL); |
217 | if (!data) |
218 | return -ENOMEM; |
219 | |
220 | ret = jffs2_flash_read(c, ref_offset(xd->node)+sizeof(struct jffs2_raw_xattr), |
221 | len: length, retlen: &readlen, buf: data); |
222 | |
223 | if (ret || length!=readlen) { |
224 | JFFS2_WARNING("jffs2_flash_read() returned %d, request=%d, readlen=%zu, at %#08x\n" , |
225 | ret, length, readlen, ref_offset(xd->node)); |
226 | kfree(objp: data); |
227 | return ret ? ret : -EIO; |
228 | } |
229 | |
230 | data[xd->name_len] = '\0'; |
231 | crc = crc32(0, data, length); |
232 | if (crc != xd->data_crc) { |
233 | JFFS2_WARNING("node CRC failed (JFFS2_NODETYPE_XATTR)" |
234 | " at %#08x, read: 0x%08x calculated: 0x%08x\n" , |
235 | ref_offset(xd->node), xd->data_crc, crc); |
236 | kfree(objp: data); |
237 | xd->flags |= JFFS2_XFLAGS_INVALID; |
238 | return JFFS2_XATTR_IS_CORRUPTED; |
239 | } |
240 | |
241 | xd->flags |= JFFS2_XFLAGS_HOT; |
242 | xd->xname = data; |
243 | xd->xvalue = data + xd->name_len+1; |
244 | |
245 | c->xdatum_mem_usage += length; |
246 | |
247 | xd->hashkey = xattr_datum_hashkey(xprefix: xd->xprefix, xname: xd->xname, xvalue: xd->xvalue, xsize: xd->value_len); |
248 | i = xd->hashkey % XATTRINDEX_HASHSIZE; |
249 | list_add(new: &xd->xindex, head: &c->xattrindex[i]); |
250 | if (!retry) { |
251 | retry = 1; |
252 | reclaim_xattr_datum(c); |
253 | if (!xd->xname) |
254 | goto retry; |
255 | } |
256 | |
257 | dbg_xattr("success on loading xdatum (xid=%u, xprefix=%u, xname='%s')\n" , |
258 | xd->xid, xd->xprefix, xd->xname); |
259 | |
260 | return 0; |
261 | } |
262 | |
263 | static int load_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd) |
264 | { |
265 | /* must be called under down_write(xattr_sem); |
266 | * rc < 0 : recoverable error, try again |
267 | * rc = 0 : success |
268 | * rc > 0 : Unrecoverable error, this node should be deleted. |
269 | */ |
270 | int rc = 0; |
271 | |
272 | BUG_ON(xd->flags & JFFS2_XFLAGS_DEAD); |
273 | if (xd->xname) |
274 | return 0; |
275 | if (xd->flags & JFFS2_XFLAGS_INVALID) |
276 | return JFFS2_XATTR_IS_CORRUPTED; |
277 | if (unlikely(is_xattr_datum_unchecked(c, xd))) |
278 | rc = do_verify_xattr_datum(c, xd); |
279 | if (!rc) |
280 | rc = do_load_xattr_datum(c, xd); |
281 | return rc; |
282 | } |
283 | |
284 | static int save_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd) |
285 | { |
286 | /* must be called under down_write(xattr_sem) */ |
287 | struct jffs2_raw_xattr rx; |
288 | struct kvec vecs[2]; |
289 | size_t length; |
290 | int rc, totlen; |
291 | uint32_t phys_ofs = write_ofs(c); |
292 | |
293 | BUG_ON(!xd->xname); |
294 | BUG_ON(xd->flags & (JFFS2_XFLAGS_DEAD|JFFS2_XFLAGS_INVALID)); |
295 | |
296 | vecs[0].iov_base = ℞ |
297 | vecs[0].iov_len = sizeof(rx); |
298 | vecs[1].iov_base = xd->xname; |
299 | vecs[1].iov_len = xd->name_len + 1 + xd->value_len; |
300 | totlen = vecs[0].iov_len + vecs[1].iov_len; |
301 | |
302 | /* Setup raw-xattr */ |
303 | memset(&rx, 0, sizeof(rx)); |
304 | rx.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); |
305 | rx.nodetype = cpu_to_je16(JFFS2_NODETYPE_XATTR); |
306 | rx.totlen = cpu_to_je32(PAD(totlen)); |
307 | rx.hdr_crc = cpu_to_je32(crc32(0, &rx, sizeof(struct jffs2_unknown_node) - 4)); |
308 | |
309 | rx.xid = cpu_to_je32(xd->xid); |
310 | rx.version = cpu_to_je32(++xd->version); |
311 | rx.xprefix = xd->xprefix; |
312 | rx.name_len = xd->name_len; |
313 | rx.value_len = cpu_to_je16(xd->value_len); |
314 | rx.data_crc = cpu_to_je32(crc32(0, vecs[1].iov_base, vecs[1].iov_len)); |
315 | rx.node_crc = cpu_to_je32(crc32(0, &rx, sizeof(struct jffs2_raw_xattr) - 4)); |
316 | |
317 | rc = jffs2_flash_writev(c, vecs, count: 2, to: phys_ofs, retlen: &length, ino: 0); |
318 | if (rc || totlen != length) { |
319 | JFFS2_WARNING("jffs2_flash_writev()=%d, req=%u, wrote=%zu, at %#08x\n" , |
320 | rc, totlen, length, phys_ofs); |
321 | rc = rc ? rc : -EIO; |
322 | if (length) |
323 | jffs2_add_physical_node_ref(c, ofs: phys_ofs | REF_OBSOLETE, PAD(totlen), NULL); |
324 | |
325 | return rc; |
326 | } |
327 | /* success */ |
328 | jffs2_add_physical_node_ref(c, ofs: phys_ofs | REF_PRISTINE, PAD(totlen), ic: (void *)xd); |
329 | |
330 | dbg_xattr("success on saving xdatum (xid=%u, version=%u, xprefix=%u, xname='%s')\n" , |
331 | xd->xid, xd->version, xd->xprefix, xd->xname); |
332 | |
333 | return 0; |
334 | } |
335 | |
336 | static struct jffs2_xattr_datum *create_xattr_datum(struct jffs2_sb_info *c, |
337 | int xprefix, const char *xname, |
338 | const char *xvalue, int xsize) |
339 | { |
340 | /* must be called under down_write(xattr_sem) */ |
341 | struct jffs2_xattr_datum *xd; |
342 | uint32_t hashkey, name_len; |
343 | char *data; |
344 | int i, rc; |
345 | |
346 | /* Search xattr_datum has same xname/xvalue by index */ |
347 | hashkey = xattr_datum_hashkey(xprefix, xname, xvalue, xsize); |
348 | i = hashkey % XATTRINDEX_HASHSIZE; |
349 | list_for_each_entry(xd, &c->xattrindex[i], xindex) { |
350 | if (xd->hashkey==hashkey |
351 | && xd->xprefix==xprefix |
352 | && xd->value_len==xsize |
353 | && !strcmp(xd->xname, xname) |
354 | && !memcmp(p: xd->xvalue, q: xvalue, size: xsize)) { |
355 | atomic_inc(v: &xd->refcnt); |
356 | return xd; |
357 | } |
358 | } |
359 | |
360 | /* Not found, Create NEW XATTR-Cache */ |
361 | name_len = strlen(xname); |
362 | |
363 | xd = jffs2_alloc_xattr_datum(); |
364 | if (!xd) |
365 | return ERR_PTR(error: -ENOMEM); |
366 | |
367 | data = kmalloc(size: name_len + 1 + xsize, GFP_KERNEL); |
368 | if (!data) { |
369 | jffs2_free_xattr_datum(xd); |
370 | return ERR_PTR(error: -ENOMEM); |
371 | } |
372 | strcpy(p: data, q: xname); |
373 | memcpy(data + name_len + 1, xvalue, xsize); |
374 | |
375 | atomic_set(v: &xd->refcnt, i: 1); |
376 | xd->xid = ++c->highest_xid; |
377 | xd->flags |= JFFS2_XFLAGS_HOT; |
378 | xd->xprefix = xprefix; |
379 | |
380 | xd->hashkey = hashkey; |
381 | xd->xname = data; |
382 | xd->xvalue = data + name_len + 1; |
383 | xd->name_len = name_len; |
384 | xd->value_len = xsize; |
385 | xd->data_crc = crc32(0, data, xd->name_len + 1 + xd->value_len); |
386 | |
387 | rc = save_xattr_datum(c, xd); |
388 | if (rc) { |
389 | kfree(objp: xd->xname); |
390 | jffs2_free_xattr_datum(xd); |
391 | return ERR_PTR(error: rc); |
392 | } |
393 | |
394 | /* Insert Hash Index */ |
395 | i = hashkey % XATTRINDEX_HASHSIZE; |
396 | list_add(new: &xd->xindex, head: &c->xattrindex[i]); |
397 | |
398 | c->xdatum_mem_usage += (xd->name_len + 1 + xd->value_len); |
399 | reclaim_xattr_datum(c); |
400 | |
401 | return xd; |
402 | } |
403 | |
404 | static void unrefer_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd) |
405 | { |
406 | /* must be called under down_write(xattr_sem) */ |
407 | if (atomic_dec_and_lock(&xd->refcnt, &c->erase_completion_lock)) { |
408 | unload_xattr_datum(c, xd); |
409 | xd->flags |= JFFS2_XFLAGS_DEAD; |
410 | if (xd->node == (void *)xd) { |
411 | BUG_ON(!(xd->flags & JFFS2_XFLAGS_INVALID)); |
412 | jffs2_free_xattr_datum(xd); |
413 | } else { |
414 | list_add(new: &xd->xindex, head: &c->xattr_dead_list); |
415 | } |
416 | spin_unlock(lock: &c->erase_completion_lock); |
417 | |
418 | dbg_xattr("xdatum(xid=%u, version=%u) was removed.\n" , |
419 | xd->xid, xd->version); |
420 | } |
421 | } |
422 | |
423 | /* -------- xref related functions ------------------ |
424 | * verify_xattr_ref(c, ref) |
425 | * is used to load xref information from medium. Because summary data does not |
426 | * contain xid/ino, it's necessary to verify once while mounting process. |
427 | * save_xattr_ref(c, ref) |
428 | * is used to write xref to medium. If delete marker is marked, it write |
429 | * a delete marker of xref into medium. |
430 | * create_xattr_ref(c, ic, xd) |
431 | * is used to create a new xref and write to medium. |
432 | * delete_xattr_ref(c, ref) |
433 | * is used to delete jffs2_xattr_ref. It marks xref XREF_DELETE_MARKER, |
434 | * and allows GC to reclaim those physical nodes. |
435 | * jffs2_xattr_delete_inode(c, ic) |
436 | * is called to remove xrefs related to obsolete inode when inode is unlinked. |
437 | * jffs2_xattr_free_inode(c, ic) |
438 | * is called to release xattr related objects when unmounting. |
439 | * check_xattr_ref_inode(c, ic) |
440 | * is used to confirm inode does not have duplicate xattr name/value pair. |
441 | * jffs2_xattr_do_crccheck_inode(c, ic) |
442 | * is used to force xattr data integrity check during the initial gc scan. |
443 | * -------------------------------------------------- */ |
444 | static int verify_xattr_ref(struct jffs2_sb_info *c, struct jffs2_xattr_ref *ref) |
445 | { |
446 | struct jffs2_eraseblock *jeb; |
447 | struct jffs2_raw_node_ref *raw; |
448 | struct jffs2_raw_xref rr; |
449 | size_t readlen; |
450 | uint32_t crc, offset, totlen; |
451 | int rc; |
452 | |
453 | spin_lock(lock: &c->erase_completion_lock); |
454 | if (ref_flags(ref->node) != REF_UNCHECKED) |
455 | goto complete; |
456 | offset = ref_offset(ref->node); |
457 | spin_unlock(lock: &c->erase_completion_lock); |
458 | |
459 | rc = jffs2_flash_read(c, ofs: offset, len: sizeof(rr), retlen: &readlen, buf: (char *)&rr); |
460 | if (rc || sizeof(rr) != readlen) { |
461 | JFFS2_WARNING("jffs2_flash_read()=%d, req=%zu, read=%zu, at %#08x\n" , |
462 | rc, sizeof(rr), readlen, offset); |
463 | return rc ? rc : -EIO; |
464 | } |
465 | /* obsolete node */ |
466 | crc = crc32(0, &rr, sizeof(rr) - 4); |
467 | if (crc != je32_to_cpu(rr.node_crc)) { |
468 | JFFS2_ERROR("node CRC failed at %#08x, read=%#08x, calc=%#08x\n" , |
469 | offset, je32_to_cpu(rr.node_crc), crc); |
470 | return JFFS2_XATTR_IS_CORRUPTED; |
471 | } |
472 | if (je16_to_cpu(rr.magic) != JFFS2_MAGIC_BITMASK |
473 | || je16_to_cpu(rr.nodetype) != JFFS2_NODETYPE_XREF |
474 | || je32_to_cpu(rr.totlen) != PAD(sizeof(rr))) { |
475 | JFFS2_ERROR("inconsistent xref at %#08x, magic=%#04x/%#04x, " |
476 | "nodetype=%#04x/%#04x, totlen=%u/%zu\n" , |
477 | offset, je16_to_cpu(rr.magic), JFFS2_MAGIC_BITMASK, |
478 | je16_to_cpu(rr.nodetype), JFFS2_NODETYPE_XREF, |
479 | je32_to_cpu(rr.totlen), PAD(sizeof(rr))); |
480 | return JFFS2_XATTR_IS_CORRUPTED; |
481 | } |
482 | ref->ino = je32_to_cpu(rr.ino); |
483 | ref->xid = je32_to_cpu(rr.xid); |
484 | ref->xseqno = je32_to_cpu(rr.xseqno); |
485 | if (ref->xseqno > c->highest_xseqno) |
486 | c->highest_xseqno = (ref->xseqno & ~XREF_DELETE_MARKER); |
487 | |
488 | spin_lock(lock: &c->erase_completion_lock); |
489 | complete: |
490 | for (raw=ref->node; raw != (void *)ref; raw=raw->next_in_ino) { |
491 | jeb = &c->blocks[ref_offset(raw) / c->sector_size]; |
492 | totlen = PAD(ref_totlen(c, jeb, raw)); |
493 | if (ref_flags(raw) == REF_UNCHECKED) { |
494 | c->unchecked_size -= totlen; c->used_size += totlen; |
495 | jeb->unchecked_size -= totlen; jeb->used_size += totlen; |
496 | } |
497 | raw->flash_offset = ref_offset(raw) | ((ref->node==raw) ? REF_PRISTINE : REF_NORMAL); |
498 | } |
499 | spin_unlock(lock: &c->erase_completion_lock); |
500 | |
501 | dbg_xattr("success on verifying xref (ino=%u, xid=%u) at %#08x\n" , |
502 | ref->ino, ref->xid, ref_offset(ref->node)); |
503 | return 0; |
504 | } |
505 | |
506 | static int save_xattr_ref(struct jffs2_sb_info *c, struct jffs2_xattr_ref *ref) |
507 | { |
508 | /* must be called under down_write(xattr_sem) */ |
509 | struct jffs2_raw_xref rr; |
510 | size_t length; |
511 | uint32_t xseqno, phys_ofs = write_ofs(c); |
512 | int ret; |
513 | |
514 | rr.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); |
515 | rr.nodetype = cpu_to_je16(JFFS2_NODETYPE_XREF); |
516 | rr.totlen = cpu_to_je32(PAD(sizeof(rr))); |
517 | rr.hdr_crc = cpu_to_je32(crc32(0, &rr, sizeof(struct jffs2_unknown_node) - 4)); |
518 | |
519 | xseqno = (c->highest_xseqno += 2); |
520 | if (is_xattr_ref_dead(ref)) { |
521 | xseqno |= XREF_DELETE_MARKER; |
522 | rr.ino = cpu_to_je32(ref->ino); |
523 | rr.xid = cpu_to_je32(ref->xid); |
524 | } else { |
525 | rr.ino = cpu_to_je32(ref->ic->ino); |
526 | rr.xid = cpu_to_je32(ref->xd->xid); |
527 | } |
528 | rr.xseqno = cpu_to_je32(xseqno); |
529 | rr.node_crc = cpu_to_je32(crc32(0, &rr, sizeof(rr) - 4)); |
530 | |
531 | ret = jffs2_flash_write(c, ofs: phys_ofs, len: sizeof(rr), retlen: &length, buf: (char *)&rr); |
532 | if (ret || sizeof(rr) != length) { |
533 | JFFS2_WARNING("jffs2_flash_write() returned %d, request=%zu, retlen=%zu, at %#08x\n" , |
534 | ret, sizeof(rr), length, phys_ofs); |
535 | ret = ret ? ret : -EIO; |
536 | if (length) |
537 | jffs2_add_physical_node_ref(c, ofs: phys_ofs | REF_OBSOLETE, PAD(sizeof(rr)), NULL); |
538 | |
539 | return ret; |
540 | } |
541 | /* success */ |
542 | ref->xseqno = xseqno; |
543 | jffs2_add_physical_node_ref(c, ofs: phys_ofs | REF_PRISTINE, PAD(sizeof(rr)), ic: (void *)ref); |
544 | |
545 | dbg_xattr("success on saving xref (ino=%u, xid=%u)\n" , ref->ic->ino, ref->xd->xid); |
546 | |
547 | return 0; |
548 | } |
549 | |
550 | static struct jffs2_xattr_ref *create_xattr_ref(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic, |
551 | struct jffs2_xattr_datum *xd) |
552 | { |
553 | /* must be called under down_write(xattr_sem) */ |
554 | struct jffs2_xattr_ref *ref; |
555 | int ret; |
556 | |
557 | ref = jffs2_alloc_xattr_ref(); |
558 | if (!ref) |
559 | return ERR_PTR(error: -ENOMEM); |
560 | ref->ic = ic; |
561 | ref->xd = xd; |
562 | |
563 | ret = save_xattr_ref(c, ref); |
564 | if (ret) { |
565 | jffs2_free_xattr_ref(ref); |
566 | return ERR_PTR(error: ret); |
567 | } |
568 | |
569 | /* Chain to inode */ |
570 | ref->next = ic->xref; |
571 | ic->xref = ref; |
572 | |
573 | return ref; /* success */ |
574 | } |
575 | |
576 | static void delete_xattr_ref(struct jffs2_sb_info *c, struct jffs2_xattr_ref *ref) |
577 | { |
578 | /* must be called under down_write(xattr_sem) */ |
579 | struct jffs2_xattr_datum *xd; |
580 | |
581 | xd = ref->xd; |
582 | ref->xseqno |= XREF_DELETE_MARKER; |
583 | ref->ino = ref->ic->ino; |
584 | ref->xid = ref->xd->xid; |
585 | spin_lock(lock: &c->erase_completion_lock); |
586 | ref->next = c->xref_dead_list; |
587 | c->xref_dead_list = ref; |
588 | spin_unlock(lock: &c->erase_completion_lock); |
589 | |
590 | dbg_xattr("xref(ino=%u, xid=%u, xseqno=%u) was removed.\n" , |
591 | ref->ino, ref->xid, ref->xseqno); |
592 | |
593 | unrefer_xattr_datum(c, xd); |
594 | } |
595 | |
596 | void jffs2_xattr_delete_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic) |
597 | { |
598 | /* It's called from jffs2_evict_inode() on inode removing. |
599 | When an inode with XATTR is removed, those XATTRs must be removed. */ |
600 | struct jffs2_xattr_ref *ref, *_ref; |
601 | |
602 | if (!ic || ic->pino_nlink > 0) |
603 | return; |
604 | |
605 | down_write(sem: &c->xattr_sem); |
606 | for (ref = ic->xref; ref; ref = _ref) { |
607 | _ref = ref->next; |
608 | delete_xattr_ref(c, ref); |
609 | } |
610 | ic->xref = NULL; |
611 | up_write(sem: &c->xattr_sem); |
612 | } |
613 | |
614 | void jffs2_xattr_free_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic) |
615 | { |
616 | /* It's called from jffs2_free_ino_caches() until unmounting FS. */ |
617 | struct jffs2_xattr_datum *xd; |
618 | struct jffs2_xattr_ref *ref, *_ref; |
619 | |
620 | down_write(sem: &c->xattr_sem); |
621 | for (ref = ic->xref; ref; ref = _ref) { |
622 | _ref = ref->next; |
623 | xd = ref->xd; |
624 | if (atomic_dec_and_test(v: &xd->refcnt)) { |
625 | unload_xattr_datum(c, xd); |
626 | jffs2_free_xattr_datum(xd); |
627 | } |
628 | jffs2_free_xattr_ref(ref); |
629 | } |
630 | ic->xref = NULL; |
631 | up_write(sem: &c->xattr_sem); |
632 | } |
633 | |
634 | static int check_xattr_ref_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic) |
635 | { |
636 | /* success of check_xattr_ref_inode() means that inode (ic) dose not have |
637 | * duplicate name/value pairs. If duplicate name/value pair would be found, |
638 | * one will be removed. |
639 | */ |
640 | struct jffs2_xattr_ref *ref, *cmp, **pref, **pcmp; |
641 | int rc = 0; |
642 | |
643 | if (likely(ic->flags & INO_FLAGS_XATTR_CHECKED)) |
644 | return 0; |
645 | down_write(sem: &c->xattr_sem); |
646 | retry: |
647 | rc = 0; |
648 | for (ref=ic->xref, pref=&ic->xref; ref; pref=&ref->next, ref=ref->next) { |
649 | if (!ref->xd->xname) { |
650 | rc = load_xattr_datum(c, xd: ref->xd); |
651 | if (unlikely(rc > 0)) { |
652 | *pref = ref->next; |
653 | delete_xattr_ref(c, ref); |
654 | goto retry; |
655 | } else if (unlikely(rc < 0)) |
656 | goto out; |
657 | } |
658 | for (cmp=ref->next, pcmp=&ref->next; cmp; pcmp=&cmp->next, cmp=cmp->next) { |
659 | if (!cmp->xd->xname) { |
660 | ref->xd->flags |= JFFS2_XFLAGS_BIND; |
661 | rc = load_xattr_datum(c, xd: cmp->xd); |
662 | ref->xd->flags &= ~JFFS2_XFLAGS_BIND; |
663 | if (unlikely(rc > 0)) { |
664 | *pcmp = cmp->next; |
665 | delete_xattr_ref(c, ref: cmp); |
666 | goto retry; |
667 | } else if (unlikely(rc < 0)) |
668 | goto out; |
669 | } |
670 | if (ref->xd->xprefix == cmp->xd->xprefix |
671 | && !strcmp(ref->xd->xname, cmp->xd->xname)) { |
672 | if (ref->xseqno > cmp->xseqno) { |
673 | *pcmp = cmp->next; |
674 | delete_xattr_ref(c, ref: cmp); |
675 | } else { |
676 | *pref = ref->next; |
677 | delete_xattr_ref(c, ref); |
678 | } |
679 | goto retry; |
680 | } |
681 | } |
682 | } |
683 | ic->flags |= INO_FLAGS_XATTR_CHECKED; |
684 | out: |
685 | up_write(sem: &c->xattr_sem); |
686 | |
687 | return rc; |
688 | } |
689 | |
690 | void jffs2_xattr_do_crccheck_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic) |
691 | { |
692 | check_xattr_ref_inode(c, ic); |
693 | } |
694 | |
695 | /* -------- xattr subsystem functions --------------- |
696 | * jffs2_init_xattr_subsystem(c) |
697 | * is used to initialize semaphore and list_head, and some variables. |
698 | * jffs2_find_xattr_datum(c, xid) |
699 | * is used to lookup xdatum while scanning process. |
700 | * jffs2_clear_xattr_subsystem(c) |
701 | * is used to release any xattr related objects. |
702 | * jffs2_build_xattr_subsystem(c) |
703 | * is used to associate xdatum and xref while super block building process. |
704 | * jffs2_setup_xattr_datum(c, xid, version) |
705 | * is used to insert xdatum while scanning process. |
706 | * -------------------------------------------------- */ |
707 | void jffs2_init_xattr_subsystem(struct jffs2_sb_info *c) |
708 | { |
709 | int i; |
710 | |
711 | for (i=0; i < XATTRINDEX_HASHSIZE; i++) |
712 | INIT_LIST_HEAD(list: &c->xattrindex[i]); |
713 | INIT_LIST_HEAD(list: &c->xattr_unchecked); |
714 | INIT_LIST_HEAD(list: &c->xattr_dead_list); |
715 | c->xref_dead_list = NULL; |
716 | c->xref_temp = NULL; |
717 | |
718 | init_rwsem(&c->xattr_sem); |
719 | c->highest_xid = 0; |
720 | c->highest_xseqno = 0; |
721 | c->xdatum_mem_usage = 0; |
722 | c->xdatum_mem_threshold = 32 * 1024; /* Default 32KB */ |
723 | } |
724 | |
725 | static struct jffs2_xattr_datum *jffs2_find_xattr_datum(struct jffs2_sb_info *c, uint32_t xid) |
726 | { |
727 | struct jffs2_xattr_datum *xd; |
728 | int i = xid % XATTRINDEX_HASHSIZE; |
729 | |
730 | /* It's only used in scanning/building process. */ |
731 | BUG_ON(!(c->flags & (JFFS2_SB_FLAG_SCANNING|JFFS2_SB_FLAG_BUILDING))); |
732 | |
733 | list_for_each_entry(xd, &c->xattrindex[i], xindex) { |
734 | if (xd->xid==xid) |
735 | return xd; |
736 | } |
737 | return NULL; |
738 | } |
739 | |
740 | void jffs2_clear_xattr_subsystem(struct jffs2_sb_info *c) |
741 | { |
742 | struct jffs2_xattr_datum *xd, *_xd; |
743 | struct jffs2_xattr_ref *ref, *_ref; |
744 | int i; |
745 | |
746 | for (ref=c->xref_temp; ref; ref = _ref) { |
747 | _ref = ref->next; |
748 | jffs2_free_xattr_ref(ref); |
749 | } |
750 | |
751 | for (ref=c->xref_dead_list; ref; ref = _ref) { |
752 | _ref = ref->next; |
753 | jffs2_free_xattr_ref(ref); |
754 | } |
755 | |
756 | for (i=0; i < XATTRINDEX_HASHSIZE; i++) { |
757 | list_for_each_entry_safe(xd, _xd, &c->xattrindex[i], xindex) { |
758 | list_del(entry: &xd->xindex); |
759 | kfree(objp: xd->xname); |
760 | jffs2_free_xattr_datum(xd); |
761 | } |
762 | } |
763 | |
764 | list_for_each_entry_safe(xd, _xd, &c->xattr_dead_list, xindex) { |
765 | list_del(entry: &xd->xindex); |
766 | jffs2_free_xattr_datum(xd); |
767 | } |
768 | list_for_each_entry_safe(xd, _xd, &c->xattr_unchecked, xindex) { |
769 | list_del(entry: &xd->xindex); |
770 | jffs2_free_xattr_datum(xd); |
771 | } |
772 | } |
773 | |
774 | #define XREF_TMPHASH_SIZE (128) |
775 | int jffs2_build_xattr_subsystem(struct jffs2_sb_info *c) |
776 | { |
777 | struct jffs2_xattr_ref *ref, *_ref; |
778 | struct jffs2_xattr_ref **xref_tmphash; |
779 | struct jffs2_xattr_datum *xd, *_xd; |
780 | struct jffs2_inode_cache *ic; |
781 | struct jffs2_raw_node_ref *raw; |
782 | int i, xdatum_count = 0, xdatum_unchecked_count = 0, xref_count = 0; |
783 | int xdatum_orphan_count = 0, xref_orphan_count = 0, xref_dead_count = 0; |
784 | |
785 | BUG_ON(!(c->flags & JFFS2_SB_FLAG_BUILDING)); |
786 | |
787 | xref_tmphash = kcalloc(XREF_TMPHASH_SIZE, |
788 | size: sizeof(struct jffs2_xattr_ref *), GFP_KERNEL); |
789 | if (!xref_tmphash) |
790 | return -ENOMEM; |
791 | |
792 | /* Phase.1 : Merge same xref */ |
793 | for (ref=c->xref_temp; ref; ref=_ref) { |
794 | struct jffs2_xattr_ref *tmp; |
795 | |
796 | _ref = ref->next; |
797 | if (ref_flags(ref->node) != REF_PRISTINE) { |
798 | if (verify_xattr_ref(c, ref)) { |
799 | BUG_ON(ref->node->next_in_ino != (void *)ref); |
800 | ref->node->next_in_ino = NULL; |
801 | jffs2_mark_node_obsolete(c, raw: ref->node); |
802 | jffs2_free_xattr_ref(ref); |
803 | continue; |
804 | } |
805 | } |
806 | |
807 | i = (ref->ino ^ ref->xid) % XREF_TMPHASH_SIZE; |
808 | for (tmp=xref_tmphash[i]; tmp; tmp=tmp->next) { |
809 | if (tmp->ino == ref->ino && tmp->xid == ref->xid) |
810 | break; |
811 | } |
812 | if (tmp) { |
813 | raw = ref->node; |
814 | if (ref->xseqno > tmp->xseqno) { |
815 | tmp->xseqno = ref->xseqno; |
816 | raw->next_in_ino = tmp->node; |
817 | tmp->node = raw; |
818 | } else { |
819 | raw->next_in_ino = tmp->node->next_in_ino; |
820 | tmp->node->next_in_ino = raw; |
821 | } |
822 | jffs2_free_xattr_ref(ref); |
823 | continue; |
824 | } else { |
825 | ref->next = xref_tmphash[i]; |
826 | xref_tmphash[i] = ref; |
827 | } |
828 | } |
829 | c->xref_temp = NULL; |
830 | |
831 | /* Phase.2 : Bind xref with inode_cache and xattr_datum */ |
832 | for (i=0; i < XREF_TMPHASH_SIZE; i++) { |
833 | for (ref=xref_tmphash[i]; ref; ref=_ref) { |
834 | xref_count++; |
835 | _ref = ref->next; |
836 | if (is_xattr_ref_dead(ref)) { |
837 | ref->next = c->xref_dead_list; |
838 | c->xref_dead_list = ref; |
839 | xref_dead_count++; |
840 | continue; |
841 | } |
842 | /* At this point, ref->xid and ref->ino contain XID and inode number. |
843 | ref->xd and ref->ic are not valid yet. */ |
844 | xd = jffs2_find_xattr_datum(c, xid: ref->xid); |
845 | ic = jffs2_get_ino_cache(c, ino: ref->ino); |
846 | if (!xd || !ic || !ic->pino_nlink) { |
847 | dbg_xattr("xref(ino=%u, xid=%u, xseqno=%u) is orphan.\n" , |
848 | ref->ino, ref->xid, ref->xseqno); |
849 | ref->xseqno |= XREF_DELETE_MARKER; |
850 | ref->next = c->xref_dead_list; |
851 | c->xref_dead_list = ref; |
852 | xref_orphan_count++; |
853 | continue; |
854 | } |
855 | ref->xd = xd; |
856 | ref->ic = ic; |
857 | atomic_inc(v: &xd->refcnt); |
858 | ref->next = ic->xref; |
859 | ic->xref = ref; |
860 | } |
861 | } |
862 | |
863 | /* Phase.3 : Link unchecked xdatum to xattr_unchecked list */ |
864 | for (i=0; i < XATTRINDEX_HASHSIZE; i++) { |
865 | list_for_each_entry_safe(xd, _xd, &c->xattrindex[i], xindex) { |
866 | xdatum_count++; |
867 | list_del_init(entry: &xd->xindex); |
868 | if (!atomic_read(v: &xd->refcnt)) { |
869 | dbg_xattr("xdatum(xid=%u, version=%u) is orphan.\n" , |
870 | xd->xid, xd->version); |
871 | xd->flags |= JFFS2_XFLAGS_DEAD; |
872 | list_add(new: &xd->xindex, head: &c->xattr_unchecked); |
873 | xdatum_orphan_count++; |
874 | continue; |
875 | } |
876 | if (is_xattr_datum_unchecked(c, xd)) { |
877 | dbg_xattr("unchecked xdatum(xid=%u, version=%u)\n" , |
878 | xd->xid, xd->version); |
879 | list_add(new: &xd->xindex, head: &c->xattr_unchecked); |
880 | xdatum_unchecked_count++; |
881 | } |
882 | } |
883 | } |
884 | /* build complete */ |
885 | JFFS2_NOTICE("complete building xattr subsystem, %u of xdatum" |
886 | " (%u unchecked, %u orphan) and " |
887 | "%u of xref (%u dead, %u orphan) found.\n" , |
888 | xdatum_count, xdatum_unchecked_count, xdatum_orphan_count, |
889 | xref_count, xref_dead_count, xref_orphan_count); |
890 | kfree(objp: xref_tmphash); |
891 | return 0; |
892 | } |
893 | |
894 | struct jffs2_xattr_datum *jffs2_setup_xattr_datum(struct jffs2_sb_info *c, |
895 | uint32_t xid, uint32_t version) |
896 | { |
897 | struct jffs2_xattr_datum *xd; |
898 | |
899 | xd = jffs2_find_xattr_datum(c, xid); |
900 | if (!xd) { |
901 | xd = jffs2_alloc_xattr_datum(); |
902 | if (!xd) |
903 | return ERR_PTR(error: -ENOMEM); |
904 | xd->xid = xid; |
905 | xd->version = version; |
906 | if (xd->xid > c->highest_xid) |
907 | c->highest_xid = xd->xid; |
908 | list_add_tail(new: &xd->xindex, head: &c->xattrindex[xid % XATTRINDEX_HASHSIZE]); |
909 | } |
910 | return xd; |
911 | } |
912 | |
913 | /* -------- xattr subsystem functions --------------- |
914 | * xprefix_to_handler(xprefix) |
915 | * is used to translate xprefix into xattr_handler. |
916 | * jffs2_listxattr(dentry, buffer, size) |
917 | * is an implementation of listxattr handler on jffs2. |
918 | * do_jffs2_getxattr(inode, xprefix, xname, buffer, size) |
919 | * is an implementation of getxattr handler on jffs2. |
920 | * do_jffs2_setxattr(inode, xprefix, xname, buffer, size, flags) |
921 | * is an implementation of setxattr handler on jffs2. |
922 | * -------------------------------------------------- */ |
923 | const struct xattr_handler * const jffs2_xattr_handlers[] = { |
924 | &jffs2_user_xattr_handler, |
925 | #ifdef CONFIG_JFFS2_FS_SECURITY |
926 | &jffs2_security_xattr_handler, |
927 | #endif |
928 | &jffs2_trusted_xattr_handler, |
929 | NULL |
930 | }; |
931 | |
932 | static const char *jffs2_xattr_prefix(int xprefix, struct dentry *dentry) |
933 | { |
934 | const struct xattr_handler *ret = NULL; |
935 | |
936 | switch (xprefix) { |
937 | case JFFS2_XPREFIX_USER: |
938 | ret = &jffs2_user_xattr_handler; |
939 | break; |
940 | #ifdef CONFIG_JFFS2_FS_SECURITY |
941 | case JFFS2_XPREFIX_SECURITY: |
942 | ret = &jffs2_security_xattr_handler; |
943 | break; |
944 | #endif |
945 | #ifdef CONFIG_JFFS2_FS_POSIX_ACL |
946 | case JFFS2_XPREFIX_ACL_ACCESS: |
947 | ret = &nop_posix_acl_access; |
948 | break; |
949 | case JFFS2_XPREFIX_ACL_DEFAULT: |
950 | ret = &nop_posix_acl_default; |
951 | break; |
952 | #endif |
953 | case JFFS2_XPREFIX_TRUSTED: |
954 | ret = &jffs2_trusted_xattr_handler; |
955 | break; |
956 | default: |
957 | return NULL; |
958 | } |
959 | |
960 | if (!xattr_handler_can_list(handler: ret, dentry)) |
961 | return NULL; |
962 | |
963 | return xattr_prefix(handler: ret); |
964 | } |
965 | |
966 | ssize_t jffs2_listxattr(struct dentry *dentry, char *buffer, size_t size) |
967 | { |
968 | struct inode *inode = d_inode(dentry); |
969 | struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); |
970 | struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); |
971 | struct jffs2_inode_cache *ic = f->inocache; |
972 | struct jffs2_xattr_ref *ref, **pref; |
973 | struct jffs2_xattr_datum *xd; |
974 | const char *prefix; |
975 | ssize_t prefix_len, len, rc; |
976 | int retry = 0; |
977 | |
978 | rc = check_xattr_ref_inode(c, ic); |
979 | if (unlikely(rc)) |
980 | return rc; |
981 | |
982 | down_read(sem: &c->xattr_sem); |
983 | retry: |
984 | len = 0; |
985 | for (ref=ic->xref, pref=&ic->xref; ref; pref=&ref->next, ref=ref->next) { |
986 | BUG_ON(ref->ic != ic); |
987 | xd = ref->xd; |
988 | if (!xd->xname) { |
989 | /* xdatum is unchached */ |
990 | if (!retry) { |
991 | retry = 1; |
992 | up_read(sem: &c->xattr_sem); |
993 | down_write(sem: &c->xattr_sem); |
994 | goto retry; |
995 | } else { |
996 | rc = load_xattr_datum(c, xd); |
997 | if (unlikely(rc > 0)) { |
998 | *pref = ref->next; |
999 | delete_xattr_ref(c, ref); |
1000 | goto retry; |
1001 | } else if (unlikely(rc < 0)) |
1002 | goto out; |
1003 | } |
1004 | } |
1005 | |
1006 | prefix = jffs2_xattr_prefix(xprefix: xd->xprefix, dentry); |
1007 | if (!prefix) |
1008 | continue; |
1009 | prefix_len = strlen(prefix); |
1010 | rc = prefix_len + xd->name_len + 1; |
1011 | |
1012 | if (buffer) { |
1013 | if (rc > size - len) { |
1014 | rc = -ERANGE; |
1015 | goto out; |
1016 | } |
1017 | memcpy(buffer, prefix, prefix_len); |
1018 | buffer += prefix_len; |
1019 | memcpy(buffer, xd->xname, xd->name_len); |
1020 | buffer += xd->name_len; |
1021 | *buffer++ = 0; |
1022 | } |
1023 | len += rc; |
1024 | } |
1025 | rc = len; |
1026 | out: |
1027 | if (!retry) { |
1028 | up_read(sem: &c->xattr_sem); |
1029 | } else { |
1030 | up_write(sem: &c->xattr_sem); |
1031 | } |
1032 | return rc; |
1033 | } |
1034 | |
1035 | int do_jffs2_getxattr(struct inode *inode, int xprefix, const char *xname, |
1036 | char *buffer, size_t size) |
1037 | { |
1038 | struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); |
1039 | struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); |
1040 | struct jffs2_inode_cache *ic = f->inocache; |
1041 | struct jffs2_xattr_datum *xd; |
1042 | struct jffs2_xattr_ref *ref, **pref; |
1043 | int rc, retry = 0; |
1044 | |
1045 | rc = check_xattr_ref_inode(c, ic); |
1046 | if (unlikely(rc)) |
1047 | return rc; |
1048 | |
1049 | down_read(sem: &c->xattr_sem); |
1050 | retry: |
1051 | for (ref=ic->xref, pref=&ic->xref; ref; pref=&ref->next, ref=ref->next) { |
1052 | BUG_ON(ref->ic!=ic); |
1053 | |
1054 | xd = ref->xd; |
1055 | if (xd->xprefix != xprefix) |
1056 | continue; |
1057 | if (!xd->xname) { |
1058 | /* xdatum is unchached */ |
1059 | if (!retry) { |
1060 | retry = 1; |
1061 | up_read(sem: &c->xattr_sem); |
1062 | down_write(sem: &c->xattr_sem); |
1063 | goto retry; |
1064 | } else { |
1065 | rc = load_xattr_datum(c, xd); |
1066 | if (unlikely(rc > 0)) { |
1067 | *pref = ref->next; |
1068 | delete_xattr_ref(c, ref); |
1069 | goto retry; |
1070 | } else if (unlikely(rc < 0)) { |
1071 | goto out; |
1072 | } |
1073 | } |
1074 | } |
1075 | if (!strcmp(xname, xd->xname)) { |
1076 | rc = xd->value_len; |
1077 | if (buffer) { |
1078 | if (size < rc) { |
1079 | rc = -ERANGE; |
1080 | } else { |
1081 | memcpy(buffer, xd->xvalue, rc); |
1082 | } |
1083 | } |
1084 | goto out; |
1085 | } |
1086 | } |
1087 | rc = -ENODATA; |
1088 | out: |
1089 | if (!retry) { |
1090 | up_read(sem: &c->xattr_sem); |
1091 | } else { |
1092 | up_write(sem: &c->xattr_sem); |
1093 | } |
1094 | return rc; |
1095 | } |
1096 | |
1097 | int do_jffs2_setxattr(struct inode *inode, int xprefix, const char *xname, |
1098 | const char *buffer, size_t size, int flags) |
1099 | { |
1100 | struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); |
1101 | struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); |
1102 | struct jffs2_inode_cache *ic = f->inocache; |
1103 | struct jffs2_xattr_datum *xd; |
1104 | struct jffs2_xattr_ref *ref, *newref, **pref; |
1105 | uint32_t length, request; |
1106 | int rc; |
1107 | |
1108 | rc = check_xattr_ref_inode(c, ic); |
1109 | if (unlikely(rc)) |
1110 | return rc; |
1111 | |
1112 | request = PAD(sizeof(struct jffs2_raw_xattr) + strlen(xname) + 1 + size); |
1113 | rc = jffs2_reserve_space(c, minsize: request, len: &length, |
1114 | ALLOC_NORMAL, JFFS2_SUMMARY_XATTR_SIZE); |
1115 | if (rc) { |
1116 | JFFS2_WARNING("jffs2_reserve_space()=%d, request=%u\n" , rc, request); |
1117 | return rc; |
1118 | } |
1119 | |
1120 | /* Find existing xattr */ |
1121 | down_write(sem: &c->xattr_sem); |
1122 | retry: |
1123 | for (ref=ic->xref, pref=&ic->xref; ref; pref=&ref->next, ref=ref->next) { |
1124 | xd = ref->xd; |
1125 | if (xd->xprefix != xprefix) |
1126 | continue; |
1127 | if (!xd->xname) { |
1128 | rc = load_xattr_datum(c, xd); |
1129 | if (unlikely(rc > 0)) { |
1130 | *pref = ref->next; |
1131 | delete_xattr_ref(c, ref); |
1132 | goto retry; |
1133 | } else if (unlikely(rc < 0)) |
1134 | goto out; |
1135 | } |
1136 | if (!strcmp(xd->xname, xname)) { |
1137 | if (flags & XATTR_CREATE) { |
1138 | rc = -EEXIST; |
1139 | goto out; |
1140 | } |
1141 | if (!buffer) { |
1142 | ref->ino = ic->ino; |
1143 | ref->xid = xd->xid; |
1144 | ref->xseqno |= XREF_DELETE_MARKER; |
1145 | rc = save_xattr_ref(c, ref); |
1146 | if (!rc) { |
1147 | *pref = ref->next; |
1148 | spin_lock(lock: &c->erase_completion_lock); |
1149 | ref->next = c->xref_dead_list; |
1150 | c->xref_dead_list = ref; |
1151 | spin_unlock(lock: &c->erase_completion_lock); |
1152 | unrefer_xattr_datum(c, xd); |
1153 | } else { |
1154 | ref->ic = ic; |
1155 | ref->xd = xd; |
1156 | ref->xseqno &= ~XREF_DELETE_MARKER; |
1157 | } |
1158 | goto out; |
1159 | } |
1160 | goto found; |
1161 | } |
1162 | } |
1163 | /* not found */ |
1164 | if (flags & XATTR_REPLACE) { |
1165 | rc = -ENODATA; |
1166 | goto out; |
1167 | } |
1168 | if (!buffer) { |
1169 | rc = -ENODATA; |
1170 | goto out; |
1171 | } |
1172 | found: |
1173 | xd = create_xattr_datum(c, xprefix, xname, xvalue: buffer, xsize: size); |
1174 | if (IS_ERR(ptr: xd)) { |
1175 | rc = PTR_ERR(ptr: xd); |
1176 | goto out; |
1177 | } |
1178 | up_write(sem: &c->xattr_sem); |
1179 | jffs2_complete_reservation(c); |
1180 | |
1181 | /* create xattr_ref */ |
1182 | request = PAD(sizeof(struct jffs2_raw_xref)); |
1183 | rc = jffs2_reserve_space(c, minsize: request, len: &length, |
1184 | ALLOC_NORMAL, JFFS2_SUMMARY_XREF_SIZE); |
1185 | down_write(sem: &c->xattr_sem); |
1186 | if (rc) { |
1187 | JFFS2_WARNING("jffs2_reserve_space()=%d, request=%u\n" , rc, request); |
1188 | unrefer_xattr_datum(c, xd); |
1189 | up_write(sem: &c->xattr_sem); |
1190 | return rc; |
1191 | } |
1192 | if (ref) |
1193 | *pref = ref->next; |
1194 | newref = create_xattr_ref(c, ic, xd); |
1195 | if (IS_ERR(ptr: newref)) { |
1196 | if (ref) { |
1197 | ref->next = ic->xref; |
1198 | ic->xref = ref; |
1199 | } |
1200 | rc = PTR_ERR(ptr: newref); |
1201 | unrefer_xattr_datum(c, xd); |
1202 | } else if (ref) { |
1203 | delete_xattr_ref(c, ref); |
1204 | } |
1205 | out: |
1206 | up_write(sem: &c->xattr_sem); |
1207 | jffs2_complete_reservation(c); |
1208 | return rc; |
1209 | } |
1210 | |
1211 | /* -------- garbage collector functions ------------- |
1212 | * jffs2_garbage_collect_xattr_datum(c, xd, raw) |
1213 | * is used to move xdatum into new node. |
1214 | * jffs2_garbage_collect_xattr_ref(c, ref, raw) |
1215 | * is used to move xref into new node. |
1216 | * jffs2_verify_xattr(c) |
1217 | * is used to call do_verify_xattr_datum() before garbage collecting. |
1218 | * jffs2_release_xattr_datum(c, xd) |
1219 | * is used to release an in-memory object of xdatum. |
1220 | * jffs2_release_xattr_ref(c, ref) |
1221 | * is used to release an in-memory object of xref. |
1222 | * -------------------------------------------------- */ |
1223 | int jffs2_garbage_collect_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd, |
1224 | struct jffs2_raw_node_ref *raw) |
1225 | { |
1226 | uint32_t totlen, length, old_ofs; |
1227 | int rc = 0; |
1228 | |
1229 | down_write(sem: &c->xattr_sem); |
1230 | if (xd->node != raw) |
1231 | goto out; |
1232 | if (xd->flags & (JFFS2_XFLAGS_DEAD|JFFS2_XFLAGS_INVALID)) |
1233 | goto out; |
1234 | |
1235 | rc = load_xattr_datum(c, xd); |
1236 | if (unlikely(rc)) { |
1237 | rc = (rc > 0) ? 0 : rc; |
1238 | goto out; |
1239 | } |
1240 | old_ofs = ref_offset(xd->node); |
1241 | totlen = PAD(sizeof(struct jffs2_raw_xattr) |
1242 | + xd->name_len + 1 + xd->value_len); |
1243 | rc = jffs2_reserve_space_gc(c, minsize: totlen, len: &length, JFFS2_SUMMARY_XATTR_SIZE); |
1244 | if (rc) { |
1245 | JFFS2_WARNING("jffs2_reserve_space_gc()=%d, request=%u\n" , rc, totlen); |
1246 | goto out; |
1247 | } |
1248 | rc = save_xattr_datum(c, xd); |
1249 | if (!rc) |
1250 | dbg_xattr("xdatum (xid=%u, version=%u) GC'ed from %#08x to %08x\n" , |
1251 | xd->xid, xd->version, old_ofs, ref_offset(xd->node)); |
1252 | out: |
1253 | if (!rc) |
1254 | jffs2_mark_node_obsolete(c, raw); |
1255 | up_write(sem: &c->xattr_sem); |
1256 | return rc; |
1257 | } |
1258 | |
1259 | int jffs2_garbage_collect_xattr_ref(struct jffs2_sb_info *c, struct jffs2_xattr_ref *ref, |
1260 | struct jffs2_raw_node_ref *raw) |
1261 | { |
1262 | uint32_t totlen, length, old_ofs; |
1263 | int rc = 0; |
1264 | |
1265 | down_write(sem: &c->xattr_sem); |
1266 | BUG_ON(!ref->node); |
1267 | |
1268 | if (ref->node != raw) |
1269 | goto out; |
1270 | if (is_xattr_ref_dead(ref) && (raw->next_in_ino == (void *)ref)) |
1271 | goto out; |
1272 | |
1273 | old_ofs = ref_offset(ref->node); |
1274 | totlen = ref_totlen(c, c->gcblock, ref->node); |
1275 | |
1276 | rc = jffs2_reserve_space_gc(c, minsize: totlen, len: &length, JFFS2_SUMMARY_XREF_SIZE); |
1277 | if (rc) { |
1278 | JFFS2_WARNING("%s: jffs2_reserve_space_gc() = %d, request = %u\n" , |
1279 | __func__, rc, totlen); |
1280 | goto out; |
1281 | } |
1282 | rc = save_xattr_ref(c, ref); |
1283 | if (!rc) |
1284 | dbg_xattr("xref (ino=%u, xid=%u) GC'ed from %#08x to %08x\n" , |
1285 | ref->ic->ino, ref->xd->xid, old_ofs, ref_offset(ref->node)); |
1286 | out: |
1287 | if (!rc) |
1288 | jffs2_mark_node_obsolete(c, raw); |
1289 | up_write(sem: &c->xattr_sem); |
1290 | return rc; |
1291 | } |
1292 | |
1293 | int jffs2_verify_xattr(struct jffs2_sb_info *c) |
1294 | { |
1295 | struct jffs2_xattr_datum *xd, *_xd; |
1296 | struct jffs2_eraseblock *jeb; |
1297 | struct jffs2_raw_node_ref *raw; |
1298 | uint32_t totlen; |
1299 | int rc; |
1300 | |
1301 | down_write(sem: &c->xattr_sem); |
1302 | list_for_each_entry_safe(xd, _xd, &c->xattr_unchecked, xindex) { |
1303 | rc = do_verify_xattr_datum(c, xd); |
1304 | if (rc < 0) |
1305 | continue; |
1306 | list_del_init(entry: &xd->xindex); |
1307 | spin_lock(lock: &c->erase_completion_lock); |
1308 | for (raw=xd->node; raw != (void *)xd; raw=raw->next_in_ino) { |
1309 | if (ref_flags(raw) != REF_UNCHECKED) |
1310 | continue; |
1311 | jeb = &c->blocks[ref_offset(raw) / c->sector_size]; |
1312 | totlen = PAD(ref_totlen(c, jeb, raw)); |
1313 | c->unchecked_size -= totlen; c->used_size += totlen; |
1314 | jeb->unchecked_size -= totlen; jeb->used_size += totlen; |
1315 | raw->flash_offset = ref_offset(raw) |
1316 | | ((xd->node == (void *)raw) ? REF_PRISTINE : REF_NORMAL); |
1317 | } |
1318 | if (xd->flags & JFFS2_XFLAGS_DEAD) |
1319 | list_add(new: &xd->xindex, head: &c->xattr_dead_list); |
1320 | spin_unlock(lock: &c->erase_completion_lock); |
1321 | } |
1322 | up_write(sem: &c->xattr_sem); |
1323 | return list_empty(head: &c->xattr_unchecked) ? 1 : 0; |
1324 | } |
1325 | |
1326 | void jffs2_release_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datum *xd) |
1327 | { |
1328 | /* must be called under spin_lock(&c->erase_completion_lock) */ |
1329 | if (atomic_read(v: &xd->refcnt) || xd->node != (void *)xd) |
1330 | return; |
1331 | |
1332 | list_del(entry: &xd->xindex); |
1333 | jffs2_free_xattr_datum(xd); |
1334 | } |
1335 | |
1336 | void jffs2_release_xattr_ref(struct jffs2_sb_info *c, struct jffs2_xattr_ref *ref) |
1337 | { |
1338 | /* must be called under spin_lock(&c->erase_completion_lock) */ |
1339 | struct jffs2_xattr_ref *tmp, **ptmp; |
1340 | |
1341 | if (ref->node != (void *)ref) |
1342 | return; |
1343 | |
1344 | for (tmp=c->xref_dead_list, ptmp=&c->xref_dead_list; tmp; ptmp=&tmp->next, tmp=tmp->next) { |
1345 | if (ref == tmp) { |
1346 | *ptmp = tmp->next; |
1347 | break; |
1348 | } |
1349 | } |
1350 | jffs2_free_xattr_ref(ref); |
1351 | } |
1352 | |