1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43#ifndef __UBIFS_KEY_H__
44#define __UBIFS_KEY_H__
45
46
47
48
49
50
51
52
53
54static inline uint32_t key_mask_hash(uint32_t hash)
55{
56 hash &= UBIFS_S_KEY_HASH_MASK;
57 if (unlikely(hash <= 2))
58 hash += 3;
59 return hash;
60}
61
62
63
64
65
66
67static inline uint32_t key_r5_hash(const char *s, int len)
68{
69 uint32_t a = 0;
70 const signed char *str = (const signed char *)s;
71
72 while (*str) {
73 a += *str << 4;
74 a += *str >> 4;
75 a *= 11;
76 str++;
77 }
78
79 return key_mask_hash(a);
80}
81
82
83
84
85
86
87static inline uint32_t key_test_hash(const char *str, int len)
88{
89 uint32_t a = 0;
90
91 len = min_t(uint32_t, len, 4);
92 memcpy(&a, str, len);
93 return key_mask_hash(a);
94}
95
96
97
98
99
100
101
102static inline void ino_key_init(const struct ubifs_info *c,
103 union ubifs_key *key, ino_t inum)
104{
105 key->u32[0] = inum;
106 key->u32[1] = UBIFS_INO_KEY << UBIFS_S_KEY_BLOCK_BITS;
107}
108
109
110
111
112
113
114
115static inline void ino_key_init_flash(const struct ubifs_info *c, void *k,
116 ino_t inum)
117{
118 union ubifs_key *key = k;
119
120 key->j32[0] = cpu_to_le32(inum);
121 key->j32[1] = cpu_to_le32(UBIFS_INO_KEY << UBIFS_S_KEY_BLOCK_BITS);
122 memset(k + 8, 0, UBIFS_MAX_KEY_LEN - 8);
123}
124
125
126
127
128
129
130
131static inline void lowest_ino_key(const struct ubifs_info *c,
132 union ubifs_key *key, ino_t inum)
133{
134 key->u32[0] = inum;
135 key->u32[1] = 0;
136}
137
138
139
140
141
142
143
144static inline void highest_ino_key(const struct ubifs_info *c,
145 union ubifs_key *key, ino_t inum)
146{
147 key->u32[0] = inum;
148 key->u32[1] = 0xffffffff;
149}
150
151
152
153
154
155
156
157
158static inline void dent_key_init(const struct ubifs_info *c,
159 union ubifs_key *key, ino_t inum,
160 const struct qstr *nm)
161{
162 uint32_t hash = c->key_hash(nm->name, nm->len);
163
164 ubifs_assert(!(hash & ~UBIFS_S_KEY_HASH_MASK));
165 key->u32[0] = inum;
166 key->u32[1] = hash | (UBIFS_DENT_KEY << UBIFS_S_KEY_HASH_BITS);
167}
168
169
170
171
172
173
174
175
176
177static inline void dent_key_init_hash(const struct ubifs_info *c,
178 union ubifs_key *key, ino_t inum,
179 uint32_t hash)
180{
181 ubifs_assert(!(hash & ~UBIFS_S_KEY_HASH_MASK));
182 key->u32[0] = inum;
183 key->u32[1] = hash | (UBIFS_DENT_KEY << UBIFS_S_KEY_HASH_BITS);
184}
185
186
187
188
189
190
191
192
193static inline void dent_key_init_flash(const struct ubifs_info *c, void *k,
194 ino_t inum, const struct qstr *nm)
195{
196 union ubifs_key *key = k;
197 uint32_t hash = c->key_hash(nm->name, nm->len);
198
199 ubifs_assert(!(hash & ~UBIFS_S_KEY_HASH_MASK));
200 key->j32[0] = cpu_to_le32(inum);
201 key->j32[1] = cpu_to_le32(hash |
202 (UBIFS_DENT_KEY << UBIFS_S_KEY_HASH_BITS));
203 memset(k + 8, 0, UBIFS_MAX_KEY_LEN - 8);
204}
205
206
207
208
209
210
211
212static inline void lowest_dent_key(const struct ubifs_info *c,
213 union ubifs_key *key, ino_t inum)
214{
215 key->u32[0] = inum;
216 key->u32[1] = UBIFS_DENT_KEY << UBIFS_S_KEY_HASH_BITS;
217}
218
219
220
221
222
223
224
225
226static inline void xent_key_init(const struct ubifs_info *c,
227 union ubifs_key *key, ino_t inum,
228 const struct qstr *nm)
229{
230 uint32_t hash = c->key_hash(nm->name, nm->len);
231
232 ubifs_assert(!(hash & ~UBIFS_S_KEY_HASH_MASK));
233 key->u32[0] = inum;
234 key->u32[1] = hash | (UBIFS_XENT_KEY << UBIFS_S_KEY_HASH_BITS);
235}
236
237
238
239
240
241
242
243
244static inline void xent_key_init_flash(const struct ubifs_info *c, void *k,
245 ino_t inum, const struct qstr *nm)
246{
247 union ubifs_key *key = k;
248 uint32_t hash = c->key_hash(nm->name, nm->len);
249
250 ubifs_assert(!(hash & ~UBIFS_S_KEY_HASH_MASK));
251 key->j32[0] = cpu_to_le32(inum);
252 key->j32[1] = cpu_to_le32(hash |
253 (UBIFS_XENT_KEY << UBIFS_S_KEY_HASH_BITS));
254 memset(k + 8, 0, UBIFS_MAX_KEY_LEN - 8);
255}
256
257
258
259
260
261
262
263static inline void lowest_xent_key(const struct ubifs_info *c,
264 union ubifs_key *key, ino_t inum)
265{
266 key->u32[0] = inum;
267 key->u32[1] = UBIFS_XENT_KEY << UBIFS_S_KEY_HASH_BITS;
268}
269
270
271
272
273
274
275
276
277static inline void data_key_init(const struct ubifs_info *c,
278 union ubifs_key *key, ino_t inum,
279 unsigned int block)
280{
281 ubifs_assert(!(block & ~UBIFS_S_KEY_BLOCK_MASK));
282 key->u32[0] = inum;
283 key->u32[1] = block | (UBIFS_DATA_KEY << UBIFS_S_KEY_BLOCK_BITS);
284}
285
286
287
288
289
290
291
292static inline void highest_data_key(const struct ubifs_info *c,
293 union ubifs_key *key, ino_t inum)
294{
295 data_key_init(c, key, inum, UBIFS_S_KEY_BLOCK_MASK);
296}
297
298
299
300
301
302
303
304
305
306
307static inline void trun_key_init(const struct ubifs_info *c,
308 union ubifs_key *key, ino_t inum)
309{
310 key->u32[0] = inum;
311 key->u32[1] = UBIFS_TRUN_KEY << UBIFS_S_KEY_BLOCK_BITS;
312}
313
314
315
316
317
318
319
320
321static inline void invalid_key_init(const struct ubifs_info *c,
322 union ubifs_key *key)
323{
324 key->u32[0] = 0xDEADBEAF;
325 key->u32[1] = UBIFS_INVALID_KEY;
326}
327
328
329
330
331
332
333static inline int key_type(const struct ubifs_info *c,
334 const union ubifs_key *key)
335{
336 return key->u32[1] >> UBIFS_S_KEY_BLOCK_BITS;
337}
338
339
340
341
342
343
344static inline int key_type_flash(const struct ubifs_info *c, const void *k)
345{
346 const union ubifs_key *key = k;
347
348 return le32_to_cpu(key->j32[1]) >> UBIFS_S_KEY_BLOCK_BITS;
349}
350
351
352
353
354
355
356static inline ino_t key_inum(const struct ubifs_info *c, const void *k)
357{
358 const union ubifs_key *key = k;
359
360 return key->u32[0];
361}
362
363
364
365
366
367
368static inline ino_t key_inum_flash(const struct ubifs_info *c, const void *k)
369{
370 const union ubifs_key *key = k;
371
372 return le32_to_cpu(key->j32[0]);
373}
374
375
376
377
378
379
380static inline uint32_t key_hash(const struct ubifs_info *c,
381 const union ubifs_key *key)
382{
383 return key->u32[1] & UBIFS_S_KEY_HASH_MASK;
384}
385
386
387
388
389
390
391static inline uint32_t key_hash_flash(const struct ubifs_info *c, const void *k)
392{
393 const union ubifs_key *key = k;
394
395 return le32_to_cpu(key->j32[1]) & UBIFS_S_KEY_HASH_MASK;
396}
397
398
399
400
401
402
403static inline unsigned int key_block(const struct ubifs_info *c,
404 const union ubifs_key *key)
405{
406 return key->u32[1] & UBIFS_S_KEY_BLOCK_MASK;
407}
408
409
410
411
412
413
414static inline unsigned int key_block_flash(const struct ubifs_info *c,
415 const void *k)
416{
417 const union ubifs_key *key = k;
418
419 return le32_to_cpu(key->j32[1]) & UBIFS_S_KEY_BLOCK_MASK;
420}
421
422
423
424
425
426
427
428static inline void key_read(const struct ubifs_info *c, const void *from,
429 union ubifs_key *to)
430{
431 const union ubifs_key *f = from;
432
433 to->u32[0] = le32_to_cpu(f->j32[0]);
434 to->u32[1] = le32_to_cpu(f->j32[1]);
435}
436
437
438
439
440
441
442
443static inline void key_write(const struct ubifs_info *c,
444 const union ubifs_key *from, void *to)
445{
446 union ubifs_key *t = to;
447
448 t->j32[0] = cpu_to_le32(from->u32[0]);
449 t->j32[1] = cpu_to_le32(from->u32[1]);
450 memset(to + 8, 0, UBIFS_MAX_KEY_LEN - 8);
451}
452
453
454
455
456
457
458
459static inline void key_write_idx(const struct ubifs_info *c,
460 const union ubifs_key *from, void *to)
461{
462 union ubifs_key *t = to;
463
464 t->j32[0] = cpu_to_le32(from->u32[0]);
465 t->j32[1] = cpu_to_le32(from->u32[1]);
466}
467
468
469
470
471
472
473
474static inline void key_copy(const struct ubifs_info *c,
475 const union ubifs_key *from, union ubifs_key *to)
476{
477 to->u64[0] = from->u64[0];
478}
479
480
481
482
483
484
485
486
487
488
489static inline int keys_cmp(const struct ubifs_info *c,
490 const union ubifs_key *key1,
491 const union ubifs_key *key2)
492{
493 if (key1->u32[0] < key2->u32[0])
494 return -1;
495 if (key1->u32[0] > key2->u32[0])
496 return 1;
497 if (key1->u32[1] < key2->u32[1])
498 return -1;
499 if (key1->u32[1] > key2->u32[1])
500 return 1;
501
502 return 0;
503}
504
505
506
507
508
509
510
511
512
513
514static inline int keys_eq(const struct ubifs_info *c,
515 const union ubifs_key *key1,
516 const union ubifs_key *key2)
517{
518 if (key1->u32[0] != key2->u32[0])
519 return 0;
520 if (key1->u32[1] != key2->u32[1])
521 return 0;
522 return 1;
523}
524
525
526
527
528
529
530
531
532static inline int is_hash_key(const struct ubifs_info *c,
533 const union ubifs_key *key)
534{
535 int type = key_type(c, key);
536
537 return type == UBIFS_DENT_KEY || type == UBIFS_XENT_KEY;
538}
539
540
541
542
543
544static inline unsigned long long key_max_inode_size(const struct ubifs_info *c)
545{
546 switch (c->key_fmt) {
547 case UBIFS_SIMPLE_KEY_FMT:
548 return (1ULL << UBIFS_S_KEY_BLOCK_BITS) * UBIFS_BLOCK_SIZE;
549 default:
550 return 0;
551 }
552}
553
554#endif
555