source: src/linux/universal/linux-3.2/include/linux/squashfs_fs.h @ 31660

Last change on this file since 31660 was 31660, checked in by brainslayer, 3 months ago

use new squashfs in all kernels

File size: 27.1 KB
Line 
1#ifndef SQUASHFS_FS
2#define SQUASHFS_FS
3
4/*
5 * Squashfs
6 *
7 * Copyright (c) 2002, 2003, 2004, 2005, 2006
8 * Phillip Lougher <phillip@lougher.org.uk>
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version 2,
13 * or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23 *
24 * squashfs_fs.h
25 */
26
27#ifndef CONFIG_SQUASHFS_2_0_COMPATIBILITY
28#define CONFIG_SQUASHFS_2_0_COMPATIBILITY
29#endif
30
31//#ifdef CONFIG_SQUASHFS_VMALLOC
32//#define SQUASHFS_ALLOC(a)             vmalloc(a)
33//#define SQUASHFS_FREE(a)              vfree(a)
34//#else
35#define SQUASHFS_ALLOC(a)               kmalloc(a, GFP_KERNEL)
36#define SQUASHFS_FREE(a)                kfree(a)
37//#endif
38#ifdef CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE
39#define SQUASHFS_CACHED_FRAGMENTS       CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE
40#else
41#define SQUASHFS_CACHED_FRAGMENTS       3
42#endif
43#define SQUASHFS_MAJOR                  3
44#define SQUASHFS_MINOR                  0
45#ifndef SQUASHFS_MAGIC
46#define SQUASHFS_MAGIC          0x73717368
47#endif
48#define SQUASHFS_MAGIC_SWAP             0x68737173
49#define SQUASHFS_START                  0
50
51/* size of metadata (inode and directory) blocks */
52#define SQUASHFS_METADATA_SIZE          8192
53#define SQUASHFS_METADATA_LOG           13
54
55/* default size of data blocks */
56#define SQUASHFS_FILE_SIZE              131072
57#define SQUASHFS_FILE_LOG               17
58
59#define SQUASHFS_FILE_MAX_SIZE          1048576
60/*#define SQUASHFS_FILE_SIZE            65536
61#define SQUASHFS_FILE_LOG               16
62
63#define SQUASHFS_FILE_MAX_SIZE          65536*/
64
65/* Max number of uids and gids */
66#define SQUASHFS_UIDS                   256
67#define SQUASHFS_GUIDS                  255
68
69/* Max length of filename (not 255) */
70#define SQUASHFS_NAME_LEN               256
71
72#define SQUASHFS_INVALID                ((long long) 0xffffffffffff)
73#define SQUASHFS_INVALID_FRAG           ((unsigned int) 0xffffffff)
74#define SQUASHFS_INVALID_BLK            ((long long) -1)
75#define SQUASHFS_USED_BLK               ((long long) -2)
76
77/* Filesystem flags */
78#define SQUASHFS_NOI                    0
79#define SQUASHFS_NOD                    1
80#define SQUASHFS_CHECK                  2
81#define SQUASHFS_NOF                    3
82#define SQUASHFS_NO_FRAG                4
83#define SQUASHFS_ALWAYS_FRAG            5
84#define SQUASHFS_DUPLICATE              6
85
86#define SQUASHFS_BIT(flag, bit)         ((flag >> bit) & 1)
87
88#define SQUASHFS_UNCOMPRESSED_INODES(flags)     SQUASHFS_BIT(flags, \
89                                                SQUASHFS_NOI)
90
91#define SQUASHFS_UNCOMPRESSED_DATA(flags)       SQUASHFS_BIT(flags, \
92                                                SQUASHFS_NOD)
93
94#define SQUASHFS_UNCOMPRESSED_FRAGMENTS(flags)  SQUASHFS_BIT(flags, \
95                                                SQUASHFS_NOF)
96
97#define SQUASHFS_NO_FRAGMENTS(flags)            SQUASHFS_BIT(flags, \
98                                                SQUASHFS_NO_FRAG)
99
100#define SQUASHFS_ALWAYS_FRAGMENTS(flags)        SQUASHFS_BIT(flags, \
101                                                SQUASHFS_ALWAYS_FRAG)
102
103#define SQUASHFS_DUPLICATES(flags)              SQUASHFS_BIT(flags, \
104                                                SQUASHFS_DUPLICATE)
105
106#define SQUASHFS_CHECK_DATA(flags)              SQUASHFS_BIT(flags, \
107                                                SQUASHFS_CHECK)
108
109#define SQUASHFS_MKFLAGS(noi, nod, check_data, nof, no_frag, always_frag, \
110                duplicate_checking)     (noi | (nod << 1) | (check_data << 2) \
111                | (nof << 3) | (no_frag << 4) | (always_frag << 5) | \
112                (duplicate_checking << 6))
113
114/* Max number of types and file types */
115#define SQUASHFS_DIR_TYPE               1
116#define SQUASHFS_FILE_TYPE              2
117#define SQUASHFS_SYMLINK_TYPE           3
118#define SQUASHFS_BLKDEV_TYPE            4
119#define SQUASHFS_CHRDEV_TYPE            5
120#define SQUASHFS_FIFO_TYPE              6
121#define SQUASHFS_SOCKET_TYPE            7
122#define SQUASHFS_LDIR_TYPE              8
123#define SQUASHFS_LREG_TYPE              9
124
125/* 1.0 filesystem type definitions */
126#define SQUASHFS_TYPES                  5
127#define SQUASHFS_IPC_TYPE               0
128
129/* Flag whether block is compressed or uncompressed, bit is set if block is
130 * uncompressed */
131#define SQUASHFS_COMPRESSED_BIT         (1 << 15)
132
133#define SQUASHFS_COMPRESSED_SIZE(B)     (((B) & ~SQUASHFS_COMPRESSED_BIT) ? \
134                (B) & ~SQUASHFS_COMPRESSED_BIT :  SQUASHFS_COMPRESSED_BIT)
135
136#define SQUASHFS_COMPRESSED(B)          (!((B) & SQUASHFS_COMPRESSED_BIT))
137
138#define SQUASHFS_COMPRESSED_BIT_BLOCK           (1 << 24)
139
140#define SQUASHFS_COMPRESSED_SIZE_BLOCK(B)       (((B) & \
141        ~SQUASHFS_COMPRESSED_BIT_BLOCK) ? (B) & \
142        ~SQUASHFS_COMPRESSED_BIT_BLOCK : SQUASHFS_COMPRESSED_BIT_BLOCK)
143
144#define SQUASHFS_COMPRESSED_BLOCK(B)    (!((B) & SQUASHFS_COMPRESSED_BIT_BLOCK))
145
146/*
147 * Inode number ops.  Inodes consist of a compressed block number, and an
148 * uncompressed  offset within that block
149 */
150#define SQUASHFS_INODE_BLK(a)           ((unsigned int) ((a) >> 16))
151
152#define SQUASHFS_INODE_OFFSET(a)        ((unsigned int) ((a) & 0xffff))
153
154#define SQUASHFS_MKINODE(A, B)          ((squashfs_inode_t)(((squashfs_inode_t) (A)\
155                                        << 16) + (B)))
156
157/* Compute 32 bit VFS inode number from squashfs inode number */
158#define SQUASHFS_MK_VFS_INODE(a, b)     ((unsigned int) (((a) << 8) + \
159                                        ((b) >> 2) + 1))
160/* XXX */
161
162/* Translate between VFS mode and squashfs mode */
163#define SQUASHFS_MODE(a)                ((a) & 0xfff)
164
165/* fragment and fragment table defines */
166#define SQUASHFS_FRAGMENT_BYTES(A)      (A * sizeof(struct squashfs_fragment_entry))
167
168#define SQUASHFS_FRAGMENT_INDEX(A)      (SQUASHFS_FRAGMENT_BYTES(A) / \
169                                        SQUASHFS_METADATA_SIZE)
170
171#define SQUASHFS_FRAGMENT_INDEX_OFFSET(A)       (SQUASHFS_FRAGMENT_BYTES(A) % \
172                                                SQUASHFS_METADATA_SIZE)
173
174#define SQUASHFS_FRAGMENT_INDEXES(A)    ((SQUASHFS_FRAGMENT_BYTES(A) + \
175                                        SQUASHFS_METADATA_SIZE - 1) / \
176                                        SQUASHFS_METADATA_SIZE)
177
178#define SQUASHFS_FRAGMENT_INDEX_BYTES(A)        (SQUASHFS_FRAGMENT_INDEXES(A) *\
179                                                sizeof(long long))
180
181/* cached data constants for filesystem */
182#define SQUASHFS_CACHED_BLKS            8
183
184#define SQUASHFS_MAX_FILE_SIZE_LOG      64
185
186#define SQUASHFS_MAX_FILE_SIZE          ((long long) 1 << \
187                                        (SQUASHFS_MAX_FILE_SIZE_LOG - 2))
188
189#define SQUASHFS_MARKER_BYTE            0xff
190
191/* meta index cache */
192#define SQUASHFS_META_INDEXES   (SQUASHFS_METADATA_SIZE / sizeof(unsigned int))
193#define SQUASHFS_META_ENTRIES   31
194#define SQUASHFS_META_NUMBER    8
195#define SQUASHFS_SLOTS          4
196
197struct meta_entry {
198        long long               data_block;
199        unsigned int            index_block;
200        unsigned short          offset;
201        unsigned short          pad;
202};
203
204struct meta_index {
205        unsigned int            inode_number;
206        unsigned int            offset;
207        unsigned short          entries;
208        unsigned short          skip;
209        unsigned short          locked;
210        unsigned short          pad;
211        struct meta_entry       meta_entry[SQUASHFS_META_ENTRIES];
212};
213
214
215/*
216 * definitions for structures on disk
217 */
218
219typedef long long               squashfs_block_t;
220typedef long long               squashfs_inode_t;
221
222struct squashfs_super_block {
223        unsigned int            s_magic;
224        unsigned int            inodes;
225        unsigned int            bytes_used_2;
226        unsigned int            uid_start_2;
227        unsigned int            guid_start_2;
228        unsigned int            inode_table_start_2;
229        unsigned int            directory_table_start_2;
230        unsigned int            s_major:16;
231        unsigned int            s_minor:16;
232        unsigned int            block_size_1:16;
233        unsigned int            block_log:16;
234        unsigned int            flags:8;
235        unsigned int            no_uids:8;
236        unsigned int            no_guids:8;
237        unsigned int            mkfs_time /* time of filesystem creation */;
238        squashfs_inode_t        root_inode;
239        unsigned int            block_size;
240        unsigned int            fragments;
241        unsigned int            fragment_table_start_2;
242        long long               bytes_used;
243        long long               uid_start;
244        long long               guid_start;
245        long long               inode_table_start;
246        long long               directory_table_start;
247        long long               fragment_table_start;
248        long long               unused;
249} __attribute__ ((packed));
250
251struct squashfs_dir_index {
252        unsigned int            index;
253        unsigned int            start_block;
254        unsigned char           size;
255        unsigned char           name[0];
256} __attribute__ ((packed));
257
258#define SQUASHFS_BASE_INODE_HEADER              \
259        unsigned int            inode_type:4;   \
260        unsigned int            mode:12;        \
261        unsigned int            uid:8;          \
262        unsigned int            guid:8;         \
263        unsigned int            mtime;          \
264        unsigned int            inode_number;
265
266struct squashfs_base_inode_header {
267        SQUASHFS_BASE_INODE_HEADER;
268} __attribute__ ((packed));
269
270struct squashfs_ipc_inode_header {
271        SQUASHFS_BASE_INODE_HEADER;
272        unsigned int            nlink;
273} __attribute__ ((packed));
274
275struct squashfs_dev_inode_header {
276        SQUASHFS_BASE_INODE_HEADER;
277        unsigned int            nlink;
278        unsigned short          rdev;
279} __attribute__ ((packed));
280       
281struct squashfs_symlink_inode_header {
282        SQUASHFS_BASE_INODE_HEADER;
283        unsigned int            nlink;
284        unsigned short          symlink_size;
285        char                    symlink[0];
286} __attribute__ ((packed));
287
288struct squashfs_reg_inode_header {
289        SQUASHFS_BASE_INODE_HEADER;
290        squashfs_block_t        start_block;
291        unsigned int            fragment;
292        unsigned int            offset;
293        unsigned int            file_size;
294        unsigned short          block_list[0];
295} __attribute__ ((packed));
296
297struct squashfs_lreg_inode_header {
298        SQUASHFS_BASE_INODE_HEADER;
299        unsigned int            nlink;
300        squashfs_block_t        start_block;
301        unsigned int            fragment;
302        unsigned int            offset;
303        long long               file_size;
304        unsigned short          block_list[0];
305} __attribute__ ((packed));
306
307struct squashfs_dir_inode_header {
308        SQUASHFS_BASE_INODE_HEADER;
309        unsigned int            nlink;
310        unsigned int            file_size:19;
311        unsigned int            offset:13;
312        unsigned int            start_block;
313        unsigned int            parent_inode;
314} __attribute__  ((packed));
315
316struct squashfs_ldir_inode_header {
317        SQUASHFS_BASE_INODE_HEADER;
318        unsigned int            nlink;
319        unsigned int            file_size:27;
320        unsigned int            offset:13;
321        unsigned int            start_block;
322        unsigned int            i_count:16;
323        unsigned int            parent_inode;
324        struct squashfs_dir_index       index[0];
325} __attribute__  ((packed));
326
327union squashfs_inode_header {
328        struct squashfs_base_inode_header       base;
329        struct squashfs_dev_inode_header        dev;
330        struct squashfs_symlink_inode_header    symlink;
331        struct squashfs_reg_inode_header        reg;
332        struct squashfs_lreg_inode_header       lreg;
333        struct squashfs_dir_inode_header        dir;
334        struct squashfs_ldir_inode_header       ldir;
335        struct squashfs_ipc_inode_header        ipc;
336};
337       
338struct squashfs_dir_entry {
339        unsigned int            offset:13;
340        unsigned int            type:3;
341        unsigned int            size:8;
342        int                     inode_number:16;
343        char                    name[0];
344} __attribute__ ((packed));
345
346struct squashfs_dir_header {
347        unsigned int            count:8;
348        unsigned int            start_block;
349        unsigned int            inode_number;
350} __attribute__ ((packed));
351
352struct squashfs_fragment_entry {
353        long long               start_block;
354        unsigned int            size;
355        unsigned int            unused;
356} __attribute__ ((packed));
357
358extern int squashfs_uncompress_block(void *d, int dstlen, void *s, int srclen);
359extern int squashfs_uncompress_init(void);
360extern int squashfs_uncompress_exit(void);
361
362/*
363 * macros to convert each packed bitfield structure from little endian to big
364 * endian and vice versa.  These are needed when creating or using a filesystem
365 * on a machine with different byte ordering to the target architecture.
366 *
367 */
368
369#define SQUASHFS_SWAP_START \
370        int bits;\
371        int b_pos;\
372        unsigned long long val;\
373        unsigned char *s;\
374        unsigned char *d;
375
376#define SQUASHFS_SWAP_SUPER_BLOCK(s, d) {\
377        SQUASHFS_SWAP_START\
378        SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_super_block));\
379        SQUASHFS_SWAP((s)->s_magic, d, 0, 32);\
380        SQUASHFS_SWAP((s)->inodes, d, 32, 32);\
381        SQUASHFS_SWAP((s)->bytes_used_2, d, 64, 32);\
382        SQUASHFS_SWAP((s)->uid_start_2, d, 96, 32);\
383        SQUASHFS_SWAP((s)->guid_start_2, d, 128, 32);\
384        SQUASHFS_SWAP((s)->inode_table_start_2, d, 160, 32);\
385        SQUASHFS_SWAP((s)->directory_table_start_2, d, 192, 32);\
386        SQUASHFS_SWAP((s)->s_major, d, 224, 16);\
387        SQUASHFS_SWAP((s)->s_minor, d, 240, 16);\
388        SQUASHFS_SWAP((s)->block_size_1, d, 256, 16);\
389        SQUASHFS_SWAP((s)->block_log, d, 272, 16);\
390        SQUASHFS_SWAP((s)->flags, d, 288, 8);\
391        SQUASHFS_SWAP((s)->no_uids, d, 296, 8);\
392        SQUASHFS_SWAP((s)->no_guids, d, 304, 8);\
393        SQUASHFS_SWAP((s)->mkfs_time, d, 312, 32);\
394        SQUASHFS_SWAP((s)->root_inode, d, 344, 64);\
395        SQUASHFS_SWAP((s)->block_size, d, 408, 32);\
396        SQUASHFS_SWAP((s)->fragments, d, 440, 32);\
397        SQUASHFS_SWAP((s)->fragment_table_start_2, d, 472, 32);\
398        SQUASHFS_SWAP((s)->bytes_used, d, 504, 64);\
399        SQUASHFS_SWAP((s)->uid_start, d, 568, 64);\
400        SQUASHFS_SWAP((s)->guid_start, d, 632, 64);\
401        SQUASHFS_SWAP((s)->inode_table_start, d, 696, 64);\
402        SQUASHFS_SWAP((s)->directory_table_start, d, 760, 64);\
403        SQUASHFS_SWAP((s)->fragment_table_start, d, 824, 64);\
404        SQUASHFS_SWAP((s)->unused, d, 888, 64);\
405}
406
407#define SQUASHFS_SWAP_BASE_INODE_CORE(s, d, n)\
408        SQUASHFS_MEMSET(s, d, n);\
409        SQUASHFS_SWAP((s)->inode_type, d, 0, 4);\
410        SQUASHFS_SWAP((s)->mode, d, 4, 12);\
411        SQUASHFS_SWAP((s)->uid, d, 16, 8);\
412        SQUASHFS_SWAP((s)->guid, d, 24, 8);\
413        SQUASHFS_SWAP((s)->mtime, d, 32, 32);\
414        SQUASHFS_SWAP((s)->inode_number, d, 64, 32);
415
416#define SQUASHFS_SWAP_BASE_INODE_HEADER(s, d, n) {\
417        SQUASHFS_SWAP_START\
418        SQUASHFS_SWAP_BASE_INODE_CORE(s, d, n)\
419}
420
421#define SQUASHFS_SWAP_IPC_INODE_HEADER(s, d) {\
422        SQUASHFS_SWAP_START\
423        SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
424                        sizeof(struct squashfs_ipc_inode_header))\
425        SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
426}
427
428#define SQUASHFS_SWAP_DEV_INODE_HEADER(s, d) {\
429        SQUASHFS_SWAP_START\
430        SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
431                        sizeof(struct squashfs_dev_inode_header)); \
432        SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
433        SQUASHFS_SWAP((s)->rdev, d, 128, 16);\
434}
435
436#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER(s, d) {\
437        SQUASHFS_SWAP_START\
438        SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
439                        sizeof(struct squashfs_symlink_inode_header));\
440        SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
441        SQUASHFS_SWAP((s)->symlink_size, d, 128, 16);\
442}
443
444#define SQUASHFS_SWAP_REG_INODE_HEADER(s, d) {\
445        SQUASHFS_SWAP_START\
446        SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
447                        sizeof(struct squashfs_reg_inode_header));\
448        SQUASHFS_SWAP((s)->start_block, d, 96, 64);\
449        SQUASHFS_SWAP((s)->fragment, d, 160, 32);\
450        SQUASHFS_SWAP((s)->offset, d, 192, 32);\
451        SQUASHFS_SWAP((s)->file_size, d, 224, 32);\
452}
453
454#define SQUASHFS_SWAP_LREG_INODE_HEADER(s, d) {\
455        SQUASHFS_SWAP_START\
456        SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
457                        sizeof(struct squashfs_lreg_inode_header));\
458        SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
459        SQUASHFS_SWAP((s)->start_block, d, 128, 64);\
460        SQUASHFS_SWAP((s)->fragment, d, 192, 32);\
461        SQUASHFS_SWAP((s)->offset, d, 224, 32);\
462        SQUASHFS_SWAP((s)->file_size, d, 256, 64);\
463}
464
465#define SQUASHFS_SWAP_DIR_INODE_HEADER(s, d) {\
466        SQUASHFS_SWAP_START\
467        SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
468                        sizeof(struct squashfs_dir_inode_header));\
469        SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
470        SQUASHFS_SWAP((s)->file_size, d, 128, 19);\
471        SQUASHFS_SWAP((s)->offset, d, 147, 13);\
472        SQUASHFS_SWAP((s)->start_block, d, 160, 32);\
473        SQUASHFS_SWAP((s)->parent_inode, d, 192, 32);\
474}
475
476#define SQUASHFS_SWAP_LDIR_INODE_HEADER(s, d) {\
477        SQUASHFS_SWAP_START\
478        SQUASHFS_SWAP_BASE_INODE_CORE(s, d, \
479                        sizeof(struct squashfs_ldir_inode_header));\
480        SQUASHFS_SWAP((s)->nlink, d, 96, 32);\
481        SQUASHFS_SWAP((s)->file_size, d, 128, 27);\
482        SQUASHFS_SWAP((s)->offset, d, 155, 13);\
483        SQUASHFS_SWAP((s)->start_block, d, 168, 32);\
484        SQUASHFS_SWAP((s)->i_count, d, 200, 16);\
485        SQUASHFS_SWAP((s)->parent_inode, d, 216, 32);\
486}
487
488#define SQUASHFS_SWAP_DIR_INDEX(s, d) {\
489        SQUASHFS_SWAP_START\
490        SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_index));\
491        SQUASHFS_SWAP((s)->index, d, 0, 32);\
492        SQUASHFS_SWAP((s)->start_block, d, 32, 32);\
493        SQUASHFS_SWAP((s)->size, d, 64, 8);\
494}
495
496#define SQUASHFS_SWAP_DIR_HEADER(s, d) {\
497        SQUASHFS_SWAP_START\
498        SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_header));\
499        SQUASHFS_SWAP((s)->count, d, 0, 8);\
500        SQUASHFS_SWAP((s)->start_block, d, 8, 32);\
501        SQUASHFS_SWAP((s)->inode_number, d, 40, 32);\
502}
503
504#define SQUASHFS_SWAP_DIR_ENTRY(s, d) {\
505        SQUASHFS_SWAP_START\
506        SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_entry));\
507        SQUASHFS_SWAP((s)->offset, d, 0, 13);\
508        SQUASHFS_SWAP((s)->type, d, 13, 3);\
509        SQUASHFS_SWAP((s)->size, d, 16, 8);\
510        SQUASHFS_SWAP((s)->inode_number, d, 24, 16);\
511}
512
513#define SQUASHFS_SWAP_FRAGMENT_ENTRY(s, d) {\
514        SQUASHFS_SWAP_START\
515        SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_fragment_entry));\
516        SQUASHFS_SWAP((s)->start_block, d, 0, 64);\
517        SQUASHFS_SWAP((s)->size, d, 64, 32);\
518}
519
520#define SQUASHFS_SWAP_SHORTS(s, d, n) {\
521        int entry;\
522        int bit_position;\
523        SQUASHFS_SWAP_START\
524        SQUASHFS_MEMSET(s, d, n * 2);\
525        for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \
526                        16)\
527                SQUASHFS_SWAP(s[entry], d, bit_position, 16);\
528}
529
530#define SQUASHFS_SWAP_INTS(s, d, n) {\
531        int entry;\
532        int bit_position;\
533        SQUASHFS_SWAP_START\
534        SQUASHFS_MEMSET(s, d, n * 4);\
535        for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \
536                        32)\
537                SQUASHFS_SWAP(s[entry], d, bit_position, 32);\
538}
539
540#define SQUASHFS_SWAP_LONG_LONGS(s, d, n) {\
541        int entry;\
542        int bit_position;\
543        SQUASHFS_SWAP_START\
544        SQUASHFS_MEMSET(s, d, n * 8);\
545        for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \
546                        64)\
547                SQUASHFS_SWAP(s[entry], d, bit_position, 64);\
548}
549
550#define SQUASHFS_SWAP_DATA(s, d, n, bits) {\
551        int entry;\
552        int bit_position;\
553        SQUASHFS_SWAP_START\
554        SQUASHFS_MEMSET(s, d, n * bits / 8);\
555        for(entry = 0, bit_position = 0; entry < n; entry++, bit_position += \
556                        bits)\
557                SQUASHFS_SWAP(s[entry], d, bit_position, bits);\
558}
559
560#define SQUASHFS_SWAP_FRAGMENT_INDEXES(s, d, n) SQUASHFS_SWAP_LONG_LONGS(s, d, n)
561
562#ifdef CONFIG_SQUASHFS_1_0_COMPATIBILITY
563
564struct squashfs_base_inode_header_1 {
565        unsigned int            inode_type:4;
566        unsigned int            mode:12; /* protection */
567        unsigned int            uid:4; /* index into uid table */
568        unsigned int            guid:4; /* index into guid table */
569} __attribute__ ((packed));
570
571struct squashfs_ipc_inode_header_1 {
572        unsigned int            inode_type:4;
573        unsigned int            mode:12; /* protection */
574        unsigned int            uid:4; /* index into uid table */
575        unsigned int            guid:4; /* index into guid table */
576        unsigned int            type:4;
577        unsigned int            offset:4;
578} __attribute__ ((packed));
579
580struct squashfs_dev_inode_header_1 {
581        unsigned int            inode_type:4;
582        unsigned int            mode:12; /* protection */
583        unsigned int            uid:4; /* index into uid table */
584        unsigned int            guid:4; /* index into guid table */
585        unsigned short          rdev;
586} __attribute__ ((packed));
587       
588struct squashfs_symlink_inode_header_1 {
589        unsigned int            inode_type:4;
590        unsigned int            mode:12; /* protection */
591        unsigned int            uid:4; /* index into uid table */
592        unsigned int            guid:4; /* index into guid table */
593        unsigned short          symlink_size;
594        char                    symlink[0];
595} __attribute__ ((packed));
596
597struct squashfs_reg_inode_header_1 {
598        unsigned int            inode_type:4;
599        unsigned int            mode:12; /* protection */
600        unsigned int            uid:4; /* index into uid table */
601        unsigned int            guid:4; /* index into guid table */
602        unsigned int            mtime;
603        unsigned int            start_block;
604        unsigned int            file_size:32;
605        unsigned short          block_list[0];
606} __attribute__ ((packed));
607
608struct squashfs_dir_inode_header_1 {
609        unsigned int            inode_type:4;
610        unsigned int            mode:12; /* protection */
611        unsigned int            uid:4; /* index into uid table */
612        unsigned int            guid:4; /* index into guid table */
613        unsigned int            file_size:19;
614        unsigned int            offset:13;
615        unsigned int            mtime;
616        unsigned int            start_block:24;
617} __attribute__  ((packed));
618
619#define SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, n) \
620        SQUASHFS_MEMSET(s, d, n);\
621        SQUASHFS_SWAP((s)->inode_type, d, 0, 4);\
622        SQUASHFS_SWAP((s)->mode, d, 4, 12);\
623        SQUASHFS_SWAP((s)->uid, d, 16, 4);\
624        SQUASHFS_SWAP((s)->guid, d, 20, 4);
625
626#define SQUASHFS_SWAP_BASE_INODE_HEADER_1(s, d, n) {\
627        SQUASHFS_SWAP_START\
628        SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, n)\
629}
630
631#define SQUASHFS_SWAP_IPC_INODE_HEADER_1(s, d) {\
632        SQUASHFS_SWAP_START\
633        SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
634                        sizeof(struct squashfs_ipc_inode_header_1));\
635        SQUASHFS_SWAP((s)->type, d, 24, 4);\
636        SQUASHFS_SWAP((s)->offset, d, 28, 4);\
637}
638
639#define SQUASHFS_SWAP_DEV_INODE_HEADER_1(s, d) {\
640        SQUASHFS_SWAP_START\
641        SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
642                        sizeof(struct squashfs_dev_inode_header_1));\
643        SQUASHFS_SWAP((s)->rdev, d, 24, 16);\
644}
645
646#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER_1(s, d) {\
647        SQUASHFS_SWAP_START\
648        SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
649                        sizeof(struct squashfs_symlink_inode_header_1));\
650        SQUASHFS_SWAP((s)->symlink_size, d, 24, 16);\
651}
652
653#define SQUASHFS_SWAP_REG_INODE_HEADER_1(s, d) {\
654        SQUASHFS_SWAP_START\
655        SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
656                        sizeof(struct squashfs_reg_inode_header_1));\
657        SQUASHFS_SWAP((s)->mtime, d, 24, 32);\
658        SQUASHFS_SWAP((s)->start_block, d, 56, 32);\
659        SQUASHFS_SWAP((s)->file_size, d, 88, 32);\
660}
661
662#define SQUASHFS_SWAP_DIR_INODE_HEADER_1(s, d) {\
663        SQUASHFS_SWAP_START\
664        SQUASHFS_SWAP_BASE_INODE_CORE_1(s, d, \
665                        sizeof(struct squashfs_dir_inode_header_1));\
666        SQUASHFS_SWAP((s)->file_size, d, 24, 19);\
667        SQUASHFS_SWAP((s)->offset, d, 43, 13);\
668        SQUASHFS_SWAP((s)->mtime, d, 56, 32);\
669        SQUASHFS_SWAP((s)->start_block, d, 88, 24);\
670}
671
672#endif
673
674#ifdef CONFIG_SQUASHFS_2_0_COMPATIBILITY
675
676struct squashfs_dir_index_2 {
677        unsigned int            index:27;
678        unsigned int            start_block:29;
679        unsigned char           size;
680        unsigned char           name[0];
681} __attribute__ ((packed));
682
683struct squashfs_base_inode_header_2 {
684        unsigned int            inode_type:4;
685        unsigned int            mode:12; /* protection */
686        unsigned int            uid:8; /* index into uid table */
687        unsigned int            guid:8; /* index into guid table */
688} __attribute__ ((packed));
689
690struct squashfs_ipc_inode_header_2 {
691        unsigned int            inode_type:4;
692        unsigned int            mode:12; /* protection */
693        unsigned int            uid:8; /* index into uid table */
694        unsigned int            guid:8; /* index into guid table */
695} __attribute__ ((packed));
696
697struct squashfs_dev_inode_header_2 {
698        unsigned int            inode_type:4;
699        unsigned int            mode:12; /* protection */
700        unsigned int            uid:8; /* index into uid table */
701        unsigned int            guid:8; /* index into guid table */
702        unsigned short          rdev;
703} __attribute__ ((packed));
704       
705struct squashfs_symlink_inode_header_2 {
706        unsigned int            inode_type:4;
707        unsigned int            mode:12; /* protection */
708        unsigned int            uid:8; /* index into uid table */
709        unsigned int            guid:8; /* index into guid table */
710        unsigned short          symlink_size;
711        char                    symlink[0];
712} __attribute__ ((packed));
713
714struct squashfs_reg_inode_header_2 {
715        unsigned int            inode_type:4;
716        unsigned int            mode:12; /* protection */
717        unsigned int            uid:8; /* index into uid table */
718        unsigned int            guid:8; /* index into guid table */
719        unsigned int            mtime;
720        unsigned int            start_block;
721        unsigned int            fragment;
722        unsigned int            offset;
723        unsigned int            file_size:32;
724        unsigned short          block_list[0];
725} __attribute__ ((packed));
726
727struct squashfs_dir_inode_header_2 {
728        unsigned int            inode_type:4;
729        unsigned int            mode:12; /* protection */
730        unsigned int            uid:8; /* index into uid table */
731        unsigned int            guid:8; /* index into guid table */
732        unsigned int            file_size:19;
733        unsigned int            offset:13;
734        unsigned int            mtime;
735        unsigned int            start_block:24;
736} __attribute__  ((packed));
737
738struct squashfs_ldir_inode_header_2 {
739        unsigned int            inode_type:4;
740        unsigned int            mode:12; /* protection */
741        unsigned int            uid:8; /* index into uid table */
742        unsigned int            guid:8; /* index into guid table */
743        unsigned int            file_size:27;
744        unsigned int            offset:13;
745        unsigned int            mtime;
746        unsigned int            start_block:24;
747        unsigned int            i_count:16;
748        struct squashfs_dir_index_2     index[0];
749} __attribute__  ((packed));
750
751union squashfs_inode_header_2 {
752        struct squashfs_base_inode_header_2     base;
753        struct squashfs_dev_inode_header_2      dev;
754        struct squashfs_symlink_inode_header_2  symlink;
755        struct squashfs_reg_inode_header_2      reg;
756        struct squashfs_dir_inode_header_2      dir;
757        struct squashfs_ldir_inode_header_2     ldir;
758        struct squashfs_ipc_inode_header_2      ipc;
759};
760       
761struct squashfs_dir_header_2 {
762        unsigned int            count:8;
763        unsigned int            start_block:24;
764} __attribute__ ((packed));
765
766struct squashfs_dir_entry_2 {
767        unsigned int            offset:13;
768        unsigned int            type:3;
769        unsigned int            size:8;
770        char                    name[0];
771} __attribute__ ((packed));
772
773struct squashfs_fragment_entry_2 {
774        unsigned int            start_block;
775        unsigned int            size;
776} __attribute__ ((packed));
777
778#define SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, n)\
779        SQUASHFS_MEMSET(s, d, n);\
780        SQUASHFS_SWAP((s)->inode_type, d, 0, 4);\
781        SQUASHFS_SWAP((s)->mode, d, 4, 12);\
782        SQUASHFS_SWAP((s)->uid, d, 16, 8);\
783        SQUASHFS_SWAP((s)->guid, d, 24, 8);\
784
785#define SQUASHFS_SWAP_BASE_INODE_HEADER_2(s, d, n) {\
786        SQUASHFS_SWAP_START\
787        SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, n)\
788}
789
790#define SQUASHFS_SWAP_IPC_INODE_HEADER_2(s, d) \
791        SQUASHFS_SWAP_BASE_INODE_HEADER_2(s, d, sizeof(struct squashfs_ipc_inode_header_2))
792
793#define SQUASHFS_SWAP_DEV_INODE_HEADER_2(s, d) {\
794        SQUASHFS_SWAP_START\
795        SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
796                        sizeof(struct squashfs_dev_inode_header_2)); \
797        SQUASHFS_SWAP((s)->rdev, d, 32, 16);\
798}
799
800#define SQUASHFS_SWAP_SYMLINK_INODE_HEADER_2(s, d) {\
801        SQUASHFS_SWAP_START\
802        SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
803                        sizeof(struct squashfs_symlink_inode_header_2));\
804        SQUASHFS_SWAP((s)->symlink_size, d, 32, 16);\
805}
806
807#define SQUASHFS_SWAP_REG_INODE_HEADER_2(s, d) {\
808        SQUASHFS_SWAP_START\
809        SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
810                        sizeof(struct squashfs_reg_inode_header_2));\
811        SQUASHFS_SWAP((s)->mtime, d, 32, 32);\
812        SQUASHFS_SWAP((s)->start_block, d, 64, 32);\
813        SQUASHFS_SWAP((s)->fragment, d, 96, 32);\
814        SQUASHFS_SWAP((s)->offset, d, 128, 32);\
815        SQUASHFS_SWAP((s)->file_size, d, 160, 32);\
816}
817
818#define SQUASHFS_SWAP_DIR_INODE_HEADER_2(s, d) {\
819        SQUASHFS_SWAP_START\
820        SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
821                        sizeof(struct squashfs_dir_inode_header_2));\
822        SQUASHFS_SWAP((s)->file_size, d, 32, 19);\
823        SQUASHFS_SWAP((s)->offset, d, 51, 13);\
824        SQUASHFS_SWAP((s)->mtime, d, 64, 32);\
825        SQUASHFS_SWAP((s)->start_block, d, 96, 24);\
826}
827
828#define SQUASHFS_SWAP_LDIR_INODE_HEADER_2(s, d) {\
829        SQUASHFS_SWAP_START\
830        SQUASHFS_SWAP_BASE_INODE_CORE_2(s, d, \
831                        sizeof(struct squashfs_ldir_inode_header_2));\
832        SQUASHFS_SWAP((s)->file_size, d, 32, 27);\
833        SQUASHFS_SWAP((s)->offset, d, 59, 13);\
834        SQUASHFS_SWAP((s)->mtime, d, 72, 32);\
835        SQUASHFS_SWAP((s)->start_block, d, 104, 24);\
836        SQUASHFS_SWAP((s)->i_count, d, 128, 16);\
837}
838
839#define SQUASHFS_SWAP_DIR_INDEX_2(s, d) {\
840        SQUASHFS_SWAP_START\
841        SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_index_2));\
842        SQUASHFS_SWAP((s)->index, d, 0, 27);\
843        SQUASHFS_SWAP((s)->start_block, d, 27, 29);\
844        SQUASHFS_SWAP((s)->size, d, 56, 8);\
845}
846#define SQUASHFS_SWAP_DIR_HEADER_2(s, d) {\
847        SQUASHFS_SWAP_START\
848        SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_header_2));\
849        SQUASHFS_SWAP((s)->count, d, 0, 8);\
850        SQUASHFS_SWAP((s)->start_block, d, 8, 24);\
851}
852
853#define SQUASHFS_SWAP_DIR_ENTRY_2(s, d) {\
854        SQUASHFS_SWAP_START\
855        SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_dir_entry_2));\
856        SQUASHFS_SWAP((s)->offset, d, 0, 13);\
857        SQUASHFS_SWAP((s)->type, d, 13, 3);\
858        SQUASHFS_SWAP((s)->size, d, 16, 8);\
859}
860
861#define SQUASHFS_SWAP_FRAGMENT_ENTRY_2(s, d) {\
862        SQUASHFS_SWAP_START\
863        SQUASHFS_MEMSET(s, d, sizeof(struct squashfs_fragment_entry_2));\
864        SQUASHFS_SWAP((s)->start_block, d, 0, 32);\
865        SQUASHFS_SWAP((s)->size, d, 32, 32);\
866}
867
868#define SQUASHFS_SWAP_FRAGMENT_INDEXES_2(s, d, n) SQUASHFS_SWAP_INTS(s, d, n)
869
870/* fragment and fragment table defines */
871#define SQUASHFS_FRAGMENT_BYTES_2(A)    (A * sizeof(struct squashfs_fragment_entry_2))
872
873#define SQUASHFS_FRAGMENT_INDEX_2(A)    (SQUASHFS_FRAGMENT_BYTES_2(A) / \
874                                        SQUASHFS_METADATA_SIZE)
875
876#define SQUASHFS_FRAGMENT_INDEX_OFFSET_2(A)     (SQUASHFS_FRAGMENT_BYTES_2(A) % \
877                                                SQUASHFS_METADATA_SIZE)
878
879#define SQUASHFS_FRAGMENT_INDEXES_2(A)  ((SQUASHFS_FRAGMENT_BYTES_2(A) + \
880                                        SQUASHFS_METADATA_SIZE - 1) / \
881                                        SQUASHFS_METADATA_SIZE)
882
883#define SQUASHFS_FRAGMENT_INDEX_BYTES_2(A)      (SQUASHFS_FRAGMENT_INDEXES_2(A) *\
884                                                sizeof(int))
885
886#endif
887
888#ifdef __KERNEL__
889
890/*
891 * macros used to swap each structure entry, taking into account
892 * bitfields and different bitfield placing conventions on differing
893 * architectures
894 */
895
896#include <asm/byteorder.h>
897
898#ifdef __BIG_ENDIAN
899        /* convert from little endian to big endian */
900#define SQUASHFS_SWAP(value, p, pos, tbits) _SQUASHFS_SWAP(value, p, pos, \
901                tbits, b_pos)
902#else
903        /* convert from big endian to little endian */
904#define SQUASHFS_SWAP(value, p, pos, tbits) _SQUASHFS_SWAP(value, p, pos, \
905                tbits, 64 - tbits - b_pos)
906#endif
907
908#define _SQUASHFS_SWAP(value, p, pos, tbits, SHIFT) {\
909        b_pos = pos % 8;\
910        val = 0;\
911        s = (unsigned char *)p + (pos / 8);\
912        d = ((unsigned char *) &val) + 7;\
913        for(bits = 0; bits < (tbits + b_pos); bits += 8) \
914                *d-- = *s++;\
915        value = (val >> (SHIFT))/* & ((1 << tbits) - 1)*/;\
916}
917
918#define SQUASHFS_MEMSET(s, d, n)        memset(s, 0, n);
919
920#endif
921#endif
Note: See TracBrowser for help on using the repository browser.