squashfs: add support for xattr reading
[linux-3.10.git] / fs / squashfs / squashfs_fs.h
1 #ifndef SQUASHFS_FS
2 #define SQUASHFS_FS
3 /*
4  * Squashfs
5  *
6  * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
7  * Phillip Lougher <phillip@lougher.demon.co.uk>
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version 2,
12  * or (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
22  *
23  * squashfs_fs.h
24  */
25
26 #define SQUASHFS_CACHED_FRAGMENTS       CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE
27 #define SQUASHFS_MAJOR                  4
28 #define SQUASHFS_MINOR                  0
29 #define SQUASHFS_START                  0
30
31 /* size of metadata (inode and directory) blocks */
32 #define SQUASHFS_METADATA_SIZE          8192
33 #define SQUASHFS_METADATA_LOG           13
34
35 /* default size of data blocks */
36 #define SQUASHFS_FILE_SIZE              131072
37 #define SQUASHFS_FILE_LOG               17
38
39 #define SQUASHFS_FILE_MAX_SIZE          1048576
40 #define SQUASHFS_FILE_MAX_LOG           20
41
42 /* Max number of uids and gids */
43 #define SQUASHFS_IDS                    65536
44
45 /* Max length of filename (not 255) */
46 #define SQUASHFS_NAME_LEN               256
47
48 #define SQUASHFS_INVALID_FRAG           (0xffffffffU)
49 #define SQUASHFS_INVALID_XATTR          (0xffffffffU)
50 #define SQUASHFS_INVALID_BLK            (-1LL)
51
52 /* Filesystem flags */
53 #define SQUASHFS_NOI                    0
54 #define SQUASHFS_NOD                    1
55 #define SQUASHFS_NOF                    3
56 #define SQUASHFS_NO_FRAG                4
57 #define SQUASHFS_ALWAYS_FRAG            5
58 #define SQUASHFS_DUPLICATE              6
59 #define SQUASHFS_EXPORT                 7
60
61 #define SQUASHFS_BIT(flag, bit)         ((flag >> bit) & 1)
62
63 #define SQUASHFS_UNCOMPRESSED_INODES(flags)     SQUASHFS_BIT(flags, \
64                                                 SQUASHFS_NOI)
65
66 #define SQUASHFS_UNCOMPRESSED_DATA(flags)       SQUASHFS_BIT(flags, \
67                                                 SQUASHFS_NOD)
68
69 #define SQUASHFS_UNCOMPRESSED_FRAGMENTS(flags)  SQUASHFS_BIT(flags, \
70                                                 SQUASHFS_NOF)
71
72 #define SQUASHFS_NO_FRAGMENTS(flags)            SQUASHFS_BIT(flags, \
73                                                 SQUASHFS_NO_FRAG)
74
75 #define SQUASHFS_ALWAYS_FRAGMENTS(flags)        SQUASHFS_BIT(flags, \
76                                                 SQUASHFS_ALWAYS_FRAG)
77
78 #define SQUASHFS_DUPLICATES(flags)              SQUASHFS_BIT(flags, \
79                                                 SQUASHFS_DUPLICATE)
80
81 #define SQUASHFS_EXPORTABLE(flags)              SQUASHFS_BIT(flags, \
82                                                 SQUASHFS_EXPORT)
83
84 /* Max number of types and file types */
85 #define SQUASHFS_DIR_TYPE               1
86 #define SQUASHFS_REG_TYPE               2
87 #define SQUASHFS_SYMLINK_TYPE           3
88 #define SQUASHFS_BLKDEV_TYPE            4
89 #define SQUASHFS_CHRDEV_TYPE            5
90 #define SQUASHFS_FIFO_TYPE              6
91 #define SQUASHFS_SOCKET_TYPE            7
92 #define SQUASHFS_LDIR_TYPE              8
93 #define SQUASHFS_LREG_TYPE              9
94 #define SQUASHFS_LSYMLINK_TYPE          10
95 #define SQUASHFS_LBLKDEV_TYPE           11
96 #define SQUASHFS_LCHRDEV_TYPE           12
97 #define SQUASHFS_LFIFO_TYPE             13
98 #define SQUASHFS_LSOCKET_TYPE           14
99
100 /* Xattr types */
101 #define SQUASHFS_XATTR_USER             0
102 #define SQUASHFS_XATTR_TRUSTED          1
103 #define SQUASHFS_XATTR_SECURITY         2
104 #define SQUASHFS_XATTR_VALUE_OOL        256
105 #define SQUASHFS_XATTR_PREFIX_MASK      0xff
106
107 /* Flag whether block is compressed or uncompressed, bit is set if block is
108  * uncompressed */
109 #define SQUASHFS_COMPRESSED_BIT         (1 << 15)
110
111 #define SQUASHFS_COMPRESSED_SIZE(B)     (((B) & ~SQUASHFS_COMPRESSED_BIT) ? \
112                 (B) & ~SQUASHFS_COMPRESSED_BIT :  SQUASHFS_COMPRESSED_BIT)
113
114 #define SQUASHFS_COMPRESSED(B)          (!((B) & SQUASHFS_COMPRESSED_BIT))
115
116 #define SQUASHFS_COMPRESSED_BIT_BLOCK   (1 << 24)
117
118 #define SQUASHFS_COMPRESSED_SIZE_BLOCK(B)       ((B) & \
119                                                 ~SQUASHFS_COMPRESSED_BIT_BLOCK)
120
121 #define SQUASHFS_COMPRESSED_BLOCK(B)    (!((B) & SQUASHFS_COMPRESSED_BIT_BLOCK))
122
123 /*
124  * Inode number ops.  Inodes consist of a compressed block number, and an
125  * uncompressed offset within that block
126  */
127 #define SQUASHFS_INODE_BLK(A)           ((unsigned int) ((A) >> 16))
128
129 #define SQUASHFS_INODE_OFFSET(A)        ((unsigned int) ((A) & 0xffff))
130
131 #define SQUASHFS_MKINODE(A, B)          ((long long)(((long long) (A)\
132                                         << 16) + (B)))
133
134 /* Translate between VFS mode and squashfs mode */
135 #define SQUASHFS_MODE(A)                ((A) & 0xfff)
136
137 /* fragment and fragment table defines */
138 #define SQUASHFS_FRAGMENT_BYTES(A)      \
139                                 ((A) * sizeof(struct squashfs_fragment_entry))
140
141 #define SQUASHFS_FRAGMENT_INDEX(A)      (SQUASHFS_FRAGMENT_BYTES(A) / \
142                                         SQUASHFS_METADATA_SIZE)
143
144 #define SQUASHFS_FRAGMENT_INDEX_OFFSET(A)       (SQUASHFS_FRAGMENT_BYTES(A) % \
145                                                 SQUASHFS_METADATA_SIZE)
146
147 #define SQUASHFS_FRAGMENT_INDEXES(A)    ((SQUASHFS_FRAGMENT_BYTES(A) + \
148                                         SQUASHFS_METADATA_SIZE - 1) / \
149                                         SQUASHFS_METADATA_SIZE)
150
151 #define SQUASHFS_FRAGMENT_INDEX_BYTES(A)        (SQUASHFS_FRAGMENT_INDEXES(A) *\
152                                                 sizeof(u64))
153
154 /* inode lookup table defines */
155 #define SQUASHFS_LOOKUP_BYTES(A)        ((A) * sizeof(u64))
156
157 #define SQUASHFS_LOOKUP_BLOCK(A)        (SQUASHFS_LOOKUP_BYTES(A) / \
158                                         SQUASHFS_METADATA_SIZE)
159
160 #define SQUASHFS_LOOKUP_BLOCK_OFFSET(A) (SQUASHFS_LOOKUP_BYTES(A) % \
161                                         SQUASHFS_METADATA_SIZE)
162
163 #define SQUASHFS_LOOKUP_BLOCKS(A)       ((SQUASHFS_LOOKUP_BYTES(A) + \
164                                         SQUASHFS_METADATA_SIZE - 1) / \
165                                         SQUASHFS_METADATA_SIZE)
166
167 #define SQUASHFS_LOOKUP_BLOCK_BYTES(A)  (SQUASHFS_LOOKUP_BLOCKS(A) *\
168                                         sizeof(u64))
169
170 /* uid/gid lookup table defines */
171 #define SQUASHFS_ID_BYTES(A)            ((A) * sizeof(unsigned int))
172
173 #define SQUASHFS_ID_BLOCK(A)            (SQUASHFS_ID_BYTES(A) / \
174                                         SQUASHFS_METADATA_SIZE)
175
176 #define SQUASHFS_ID_BLOCK_OFFSET(A)     (SQUASHFS_ID_BYTES(A) % \
177                                         SQUASHFS_METADATA_SIZE)
178
179 #define SQUASHFS_ID_BLOCKS(A)           ((SQUASHFS_ID_BYTES(A) + \
180                                         SQUASHFS_METADATA_SIZE - 1) / \
181                                         SQUASHFS_METADATA_SIZE)
182
183 #define SQUASHFS_ID_BLOCK_BYTES(A)      (SQUASHFS_ID_BLOCKS(A) *\
184                                         sizeof(u64))
185 /* xattr id lookup table defines */
186 #define SQUASHFS_XATTR_BYTES(A)         ((A) * sizeof(struct squashfs_xattr_id))
187
188 #define SQUASHFS_XATTR_BLOCK(A)         (SQUASHFS_XATTR_BYTES(A) / \
189                                         SQUASHFS_METADATA_SIZE)
190
191 #define SQUASHFS_XATTR_BLOCK_OFFSET(A)  (SQUASHFS_XATTR_BYTES(A) % \
192                                         SQUASHFS_METADATA_SIZE)
193
194 #define SQUASHFS_XATTR_BLOCKS(A)        ((SQUASHFS_XATTR_BYTES(A) + \
195                                         SQUASHFS_METADATA_SIZE - 1) / \
196                                         SQUASHFS_METADATA_SIZE)
197
198 #define SQUASHFS_XATTR_BLOCK_BYTES(A)   (SQUASHFS_XATTR_BLOCKS(A) *\
199                                         sizeof(u64))
200 #define SQUASHFS_XATTR_BLK(A)           ((unsigned int) ((A) >> 16))
201
202 #define SQUASHFS_XATTR_OFFSET(A)        ((unsigned int) ((A) & 0xffff))
203
204 /* cached data constants for filesystem */
205 #define SQUASHFS_CACHED_BLKS            8
206
207 #define SQUASHFS_MAX_FILE_SIZE_LOG      64
208
209 #define SQUASHFS_MAX_FILE_SIZE          (1LL << \
210                                         (SQUASHFS_MAX_FILE_SIZE_LOG - 2))
211
212 /* meta index cache */
213 #define SQUASHFS_META_INDEXES   (SQUASHFS_METADATA_SIZE / sizeof(unsigned int))
214 #define SQUASHFS_META_ENTRIES   127
215 #define SQUASHFS_META_SLOTS     8
216
217 struct meta_entry {
218         u64                     data_block;
219         unsigned int            index_block;
220         unsigned short          offset;
221         unsigned short          pad;
222 };
223
224 struct meta_index {
225         unsigned int            inode_number;
226         unsigned int            offset;
227         unsigned short          entries;
228         unsigned short          skip;
229         unsigned short          locked;
230         unsigned short          pad;
231         struct meta_entry       meta_entry[SQUASHFS_META_ENTRIES];
232 };
233
234
235 /*
236  * definitions for structures on disk
237  */
238 #define ZLIB_COMPRESSION        1
239 #define LZMA_COMPRESSION        2
240 #define LZO_COMPRESSION         3
241
242 struct squashfs_super_block {
243         __le32                  s_magic;
244         __le32                  inodes;
245         __le32                  mkfs_time;
246         __le32                  block_size;
247         __le32                  fragments;
248         __le16                  compression;
249         __le16                  block_log;
250         __le16                  flags;
251         __le16                  no_ids;
252         __le16                  s_major;
253         __le16                  s_minor;
254         __le64                  root_inode;
255         __le64                  bytes_used;
256         __le64                  id_table_start;
257         __le64                  xattr_id_table_start;
258         __le64                  inode_table_start;
259         __le64                  directory_table_start;
260         __le64                  fragment_table_start;
261         __le64                  lookup_table_start;
262 };
263
264 struct squashfs_dir_index {
265         __le32                  index;
266         __le32                  start_block;
267         __le32                  size;
268         unsigned char           name[0];
269 };
270
271 struct squashfs_base_inode {
272         __le16                  inode_type;
273         __le16                  mode;
274         __le16                  uid;
275         __le16                  guid;
276         __le32                  mtime;
277         __le32                  inode_number;
278 };
279
280 struct squashfs_ipc_inode {
281         __le16                  inode_type;
282         __le16                  mode;
283         __le16                  uid;
284         __le16                  guid;
285         __le32                  mtime;
286         __le32                  inode_number;
287         __le32                  nlink;
288 };
289
290 struct squashfs_dev_inode {
291         __le16                  inode_type;
292         __le16                  mode;
293         __le16                  uid;
294         __le16                  guid;
295         __le32                  mtime;
296         __le32                  inode_number;
297         __le32                  nlink;
298         __le32                  rdev;
299 };
300
301 struct squashfs_symlink_inode {
302         __le16                  inode_type;
303         __le16                  mode;
304         __le16                  uid;
305         __le16                  guid;
306         __le32                  mtime;
307         __le32                  inode_number;
308         __le32                  nlink;
309         __le32                  symlink_size;
310         char                    symlink[0];
311 };
312
313 struct squashfs_reg_inode {
314         __le16                  inode_type;
315         __le16                  mode;
316         __le16                  uid;
317         __le16                  guid;
318         __le32                  mtime;
319         __le32                  inode_number;
320         __le32                  start_block;
321         __le32                  fragment;
322         __le32                  offset;
323         __le32                  file_size;
324         __le16                  block_list[0];
325 };
326
327 struct squashfs_lreg_inode {
328         __le16                  inode_type;
329         __le16                  mode;
330         __le16                  uid;
331         __le16                  guid;
332         __le32                  mtime;
333         __le32                  inode_number;
334         __le64                  start_block;
335         __le64                  file_size;
336         __le64                  sparse;
337         __le32                  nlink;
338         __le32                  fragment;
339         __le32                  offset;
340         __le32                  xattr;
341         __le16                  block_list[0];
342 };
343
344 struct squashfs_dir_inode {
345         __le16                  inode_type;
346         __le16                  mode;
347         __le16                  uid;
348         __le16                  guid;
349         __le32                  mtime;
350         __le32                  inode_number;
351         __le32                  start_block;
352         __le32                  nlink;
353         __le16                  file_size;
354         __le16                  offset;
355         __le32                  parent_inode;
356 };
357
358 struct squashfs_ldir_inode {
359         __le16                  inode_type;
360         __le16                  mode;
361         __le16                  uid;
362         __le16                  guid;
363         __le32                  mtime;
364         __le32                  inode_number;
365         __le32                  nlink;
366         __le32                  file_size;
367         __le32                  start_block;
368         __le32                  parent_inode;
369         __le16                  i_count;
370         __le16                  offset;
371         __le32                  xattr;
372         struct squashfs_dir_index       index[0];
373 };
374
375 union squashfs_inode {
376         struct squashfs_base_inode              base;
377         struct squashfs_dev_inode               dev;
378         struct squashfs_symlink_inode           symlink;
379         struct squashfs_reg_inode               reg;
380         struct squashfs_lreg_inode              lreg;
381         struct squashfs_dir_inode               dir;
382         struct squashfs_ldir_inode              ldir;
383         struct squashfs_ipc_inode               ipc;
384 };
385
386 struct squashfs_dir_entry {
387         __le16                  offset;
388         __le16                  inode_number;
389         __le16                  type;
390         __le16                  size;
391         char                    name[0];
392 };
393
394 struct squashfs_dir_header {
395         __le32                  count;
396         __le32                  start_block;
397         __le32                  inode_number;
398 };
399
400 struct squashfs_fragment_entry {
401         __le64                  start_block;
402         __le32                  size;
403         unsigned int            unused;
404 };
405
406 struct squashfs_xattr_entry {
407         __le16                  type;
408         __le16                  size;
409         char                    data[0];
410 };
411
412 struct squashfs_xattr_val {
413         __le32                  vsize;
414         char                    value[0];
415 };
416
417 struct squashfs_xattr_id {
418         __le64                  xattr;
419         __le32                  count;
420         __le32                  size;
421 };
422
423 struct squashfs_xattr_id_table {
424         __le64                  xattr_table_start;
425         __le32                  xattr_ids;
426         __le32                  unused;
427 };
428
429 #endif