]> glassweightruler.freedombox.rocks Git - Ventoy.git/blob - SQUASHFS/squashfs-tools-4.4/kernel/kernel-2.4/fs/squashfs/squashfs2_0.c
projects / Ventoy.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add German language (#57)
[Ventoy.git] / SQUASHFS / squashfs-tools-4.4 / kernel / kernel-2.4 / fs / squashfs / squashfs2_0.c
1 /*
2 * Squashfs - a compressed read only filesystem for Linux
3 *
4 * Copyright (c) 2002, 2003, 2004, 2005, 2006
5 * Phillip Lougher <phillip@lougher.demon.co.uk>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2,
10 * or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 *
21 * squashfs2_0.c
22 */
23
24 #include <linux/types.h>
25 #include <linux/squashfs_fs.h>
26 #include <linux/module.h>
27 #include <linux/errno.h>
28 #include <linux/slab.h>
29 #include <linux/zlib.h>
30 #include <linux/fs.h>
31 #include <linux/smp_lock.h>
32 #include <linux/locks.h>
33 #include <linux/init.h>
34 #include <linux/dcache.h>
35 #include <linux/wait.h>
36 #include <linux/zlib.h>
37 #include <linux/blkdev.h>
38 #include <linux/vmalloc.h>
39 #include <asm/uaccess.h>
40 #include <asm/semaphore.h>
41 #include "squashfs.h"
42
43 static int squashfs_readdir_2(struct file *file, void *dirent, filldir_t filldir);
44 static struct dentry *squashfs_lookup_2(struct inode *i, struct dentry *dentry);
45
46 static struct file_operations squashfs_dir_ops_2 = {
47 .read = generic_read_dir,
48 .readdir = squashfs_readdir_2
49 };
50
51 static struct inode_operations squashfs_dir_inode_ops_2 = {
52 .lookup = squashfs_lookup_2
53 };
54
55 static unsigned char squashfs_filetype_table[] = {
56 DT_UNKNOWN, DT_DIR, DT_REG, DT_LNK, DT_BLK, DT_CHR, DT_FIFO, DT_SOCK
57 };
58
59 static int read_fragment_index_table_2(struct super_block *s)
60 {
61 struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
62 struct squashfs_super_block *sblk = &msblk->sblk;
63
64 if (!(msblk->fragment_index_2 = kmalloc(SQUASHFS_FRAGMENT_INDEX_BYTES_2
65 (sblk->fragments), GFP_KERNEL))) {
66 ERROR("Failed to allocate uid/gid table\n");
67 return 0;
68 }
69
70 if (SQUASHFS_FRAGMENT_INDEX_BYTES_2(sblk->fragments) &&
71 !squashfs_read_data(s, (char *)
72 msblk->fragment_index_2,
73 sblk->fragment_table_start,
74 SQUASHFS_FRAGMENT_INDEX_BYTES_2
75 (sblk->fragments) |
76 SQUASHFS_COMPRESSED_BIT_BLOCK, NULL)) {
77 ERROR("unable to read fragment index table\n");
78 return 0;
79 }
80
81 if (msblk->swap) {
82 int i;
83 unsigned int fragment;
84
85 for (i = 0; i < SQUASHFS_FRAGMENT_INDEXES_2(sblk->fragments);
86 i++) {
87 SQUASHFS_SWAP_FRAGMENT_INDEXES_2((&fragment),
88 &msblk->fragment_index_2[i], 1);
89 msblk->fragment_index_2[i] = fragment;
90 }
91 }
92
93 return 1;
94 }
95
96
97 static int get_fragment_location_2(struct super_block *s, unsigned int fragment,
98 long long *fragment_start_block,
99 unsigned int *fragment_size)
100 {
101 struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
102 long long start_block =
103 msblk->fragment_index_2[SQUASHFS_FRAGMENT_INDEX_2(fragment)];
104 int offset = SQUASHFS_FRAGMENT_INDEX_OFFSET_2(fragment);
105 struct squashfs_fragment_entry_2 fragment_entry;
106
107 if (msblk->swap) {
108 struct squashfs_fragment_entry_2 sfragment_entry;
109
110 if (!squashfs_get_cached_block(s, (char *) &sfragment_entry,
111 start_block, offset,
112 sizeof(sfragment_entry), &start_block,
113 &offset))
114 goto out;
115 SQUASHFS_SWAP_FRAGMENT_ENTRY_2(&fragment_entry, &sfragment_entry);
116 } else
117 if (!squashfs_get_cached_block(s, (char *) &fragment_entry,
118 start_block, offset,
119 sizeof(fragment_entry), &start_block,
120 &offset))
121 goto out;
122
123 *fragment_start_block = fragment_entry.start_block;
124 *fragment_size = fragment_entry.size;
125
126 return 1;
127
128 out:
129 return 0;
130 }
131
132
133 static struct inode *squashfs_new_inode(struct super_block *s,
134 struct squashfs_base_inode_header_2 *inodeb, unsigned int ino)
135 {
136 struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
137 struct squashfs_super_block *sblk = &msblk->sblk;
138 struct inode *i = new_inode(s);
139
140 if (i) {
141 i->i_ino = ino;
142 i->i_mtime = sblk->mkfs_time;
143 i->i_atime = sblk->mkfs_time;
144 i->i_ctime = sblk->mkfs_time;
145 i->i_uid = msblk->uid[inodeb->uid];
146 i->i_mode = inodeb->mode;
147 i->i_nlink = 1;
148 i->i_size = 0;
149 if (inodeb->guid == SQUASHFS_GUIDS)
150 i->i_gid = i->i_uid;
151 else
152 i->i_gid = msblk->guid[inodeb->guid];
153 }
154
155 return i;
156 }
157
158
159 static struct inode *squashfs_iget_2(struct super_block *s, squashfs_inode_t inode)
160 {
161 struct inode *i;
162 struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
163 struct squashfs_super_block *sblk = &msblk->sblk;
164 unsigned int block = SQUASHFS_INODE_BLK(inode) +
165 sblk->inode_table_start;
166 unsigned int offset = SQUASHFS_INODE_OFFSET(inode);
167 unsigned int ino = SQUASHFS_MK_VFS_INODE(block
168 - sblk->inode_table_start, offset);
169 long long next_block;
170 unsigned int next_offset;
171 union squashfs_inode_header_2 id, sid;
172 struct squashfs_base_inode_header_2 *inodeb = &id.base,
173 *sinodeb = &sid.base;
174
175 TRACE("Entered squashfs_iget\n");
176
177 if (msblk->swap) {
178 if (!squashfs_get_cached_block(s, (char *) sinodeb, block,
179 offset, sizeof(*sinodeb), &next_block,
180 &next_offset))
181 goto failed_read;
182 SQUASHFS_SWAP_BASE_INODE_HEADER_2(inodeb, sinodeb,
183 sizeof(*sinodeb));
184 } else
185 if (!squashfs_get_cached_block(s, (char *) inodeb, block,
186 offset, sizeof(*inodeb), &next_block,
187 &next_offset))
188 goto failed_read;
189
190 switch(inodeb->inode_type) {
191 case SQUASHFS_FILE_TYPE: {
192 struct squashfs_reg_inode_header_2 *inodep = &id.reg;
193 struct squashfs_reg_inode_header_2 *sinodep = &sid.reg;
194 long long frag_blk;
195 unsigned int frag_size;
196
197 if (msblk->swap) {
198 if (!squashfs_get_cached_block(s, (char *)
199 sinodep, block, offset,
200 sizeof(*sinodep), &next_block,
201 &next_offset))
202 goto failed_read;
203 SQUASHFS_SWAP_REG_INODE_HEADER_2(inodep, sinodep);
204 } else
205 if (!squashfs_get_cached_block(s, (char *)
206 inodep, block, offset,
207 sizeof(*inodep), &next_block,
208 &next_offset))
209 goto failed_read;
210
211 frag_blk = SQUASHFS_INVALID_BLK;
212 if (inodep->fragment != SQUASHFS_INVALID_FRAG &&
213 !get_fragment_location_2(s,
214 inodep->fragment, &frag_blk, &frag_size))
215 goto failed_read;
216
217 if((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
218 goto failed_read1;
219
220 i->i_size = inodep->file_size;
221 i->i_fop = &generic_ro_fops;
222 i->i_mode |= S_IFREG;
223 i->i_mtime = inodep->mtime;
224 i->i_atime = inodep->mtime;
225 i->i_ctime = inodep->mtime;
226 i->i_blocks = ((i->i_size - 1) >> 9) + 1;
227 i->i_blksize = PAGE_CACHE_SIZE;
228 SQUASHFS_I(i)->u.s1.fragment_start_block = frag_blk;
229 SQUASHFS_I(i)->u.s1.fragment_size = frag_size;
230 SQUASHFS_I(i)->u.s1.fragment_offset = inodep->offset;
231 SQUASHFS_I(i)->start_block = inodep->start_block;
232 SQUASHFS_I(i)->u.s1.block_list_start = next_block;
233 SQUASHFS_I(i)->offset = next_offset;
234 if (sblk->block_size > 4096)
235 i->i_data.a_ops = &squashfs_aops;
236 else
237 i->i_data.a_ops = &squashfs_aops_4K;
238
239 TRACE("File inode %x:%x, start_block %x, "
240 "block_list_start %llx, offset %x\n",
241 SQUASHFS_INODE_BLK(inode), offset,
242 inodep->start_block, next_block,
243 next_offset);
244 break;
245 }
246 case SQUASHFS_DIR_TYPE: {
247 struct squashfs_dir_inode_header_2 *inodep = &id.dir;
248 struct squashfs_dir_inode_header_2 *sinodep = &sid.dir;
249
250 if (msblk->swap) {
251 if (!squashfs_get_cached_block(s, (char *)
252 sinodep, block, offset,
253 sizeof(*sinodep), &next_block,
254 &next_offset))
255 goto failed_read;
256 SQUASHFS_SWAP_DIR_INODE_HEADER_2(inodep, sinodep);
257 } else
258 if (!squashfs_get_cached_block(s, (char *)
259 inodep, block, offset,
260 sizeof(*inodep), &next_block,
261 &next_offset))
262 goto failed_read;
263
264 if((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
265 goto failed_read1;
266
267 i->i_size = inodep->file_size;
268 i->i_op = &squashfs_dir_inode_ops_2;
269 i->i_fop = &squashfs_dir_ops_2;
270 i->i_mode |= S_IFDIR;
271 i->i_mtime = inodep->mtime;
272 i->i_atime = inodep->mtime;
273 i->i_ctime = inodep->mtime;
274 SQUASHFS_I(i)->start_block = inodep->start_block;
275 SQUASHFS_I(i)->offset = inodep->offset;
276 SQUASHFS_I(i)->u.s2.directory_index_count = 0;
277 SQUASHFS_I(i)->u.s2.parent_inode = 0;
278
279 TRACE("Directory inode %x:%x, start_block %x, offset "
280 "%x\n", SQUASHFS_INODE_BLK(inode),
281 offset, inodep->start_block,
282 inodep->offset);
283 break;
284 }
285 case SQUASHFS_LDIR_TYPE: {
286 struct squashfs_ldir_inode_header_2 *inodep = &id.ldir;
287 struct squashfs_ldir_inode_header_2 *sinodep = &sid.ldir;
288
289 if (msblk->swap) {
290 if (!squashfs_get_cached_block(s, (char *)
291 sinodep, block, offset,
292 sizeof(*sinodep), &next_block,
293 &next_offset))
294 goto failed_read;
295 SQUASHFS_SWAP_LDIR_INODE_HEADER_2(inodep,
296 sinodep);
297 } else
298 if (!squashfs_get_cached_block(s, (char *)
299 inodep, block, offset,
300 sizeof(*inodep), &next_block,
301 &next_offset))
302 goto failed_read;
303
304 if((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
305 goto failed_read1;
306
307 i->i_size = inodep->file_size;
308 i->i_op = &squashfs_dir_inode_ops_2;
309 i->i_fop = &squashfs_dir_ops_2;
310 i->i_mode |= S_IFDIR;
311 i->i_mtime = inodep->mtime;
312 i->i_atime = inodep->mtime;
313 i->i_ctime = inodep->mtime;
314 SQUASHFS_I(i)->start_block = inodep->start_block;
315 SQUASHFS_I(i)->offset = inodep->offset;
316 SQUASHFS_I(i)->u.s2.directory_index_start = next_block;
317 SQUASHFS_I(i)->u.s2.directory_index_offset =
318 next_offset;
319 SQUASHFS_I(i)->u.s2.directory_index_count =
320 inodep->i_count;
321 SQUASHFS_I(i)->u.s2.parent_inode = 0;
322
323 TRACE("Long directory inode %x:%x, start_block %x, "
324 "offset %x\n",
325 SQUASHFS_INODE_BLK(inode), offset,
326 inodep->start_block, inodep->offset);
327 break;
328 }
329 case SQUASHFS_SYMLINK_TYPE: {
330 struct squashfs_symlink_inode_header_2 *inodep =
331 &id.symlink;
332 struct squashfs_symlink_inode_header_2 *sinodep =
333 &sid.symlink;
334
335 if (msblk->swap) {
336 if (!squashfs_get_cached_block(s, (char *)
337 sinodep, block, offset,
338 sizeof(*sinodep), &next_block,
339 &next_offset))
340 goto failed_read;
341 SQUASHFS_SWAP_SYMLINK_INODE_HEADER_2(inodep,
342 sinodep);
343 } else
344 if (!squashfs_get_cached_block(s, (char *)
345 inodep, block, offset,
346 sizeof(*inodep), &next_block,
347 &next_offset))
348 goto failed_read;
349
350 if((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
351 goto failed_read1;
352
353 i->i_size = inodep->symlink_size;
354 i->i_op = &page_symlink_inode_operations;
355 i->i_data.a_ops = &squashfs_symlink_aops;
356 i->i_mode |= S_IFLNK;
357 SQUASHFS_I(i)->start_block = next_block;
358 SQUASHFS_I(i)->offset = next_offset;
359
360 TRACE("Symbolic link inode %x:%x, start_block %llx, "
361 "offset %x\n",
362 SQUASHFS_INODE_BLK(inode), offset,
363 next_block, next_offset);
364 break;
365 }
366 case SQUASHFS_BLKDEV_TYPE:
367 case SQUASHFS_CHRDEV_TYPE: {
368 struct squashfs_dev_inode_header_2 *inodep = &id.dev;
369 struct squashfs_dev_inode_header_2 *sinodep = &sid.dev;
370
371 if (msblk->swap) {
372 if (!squashfs_get_cached_block(s, (char *)
373 sinodep, block, offset,
374 sizeof(*sinodep), &next_block,
375 &next_offset))
376 goto failed_read;
377 SQUASHFS_SWAP_DEV_INODE_HEADER_2(inodep, sinodep);
378 } else
379 if (!squashfs_get_cached_block(s, (char *)
380 inodep, block, offset,
381 sizeof(*inodep), &next_block,
382 &next_offset))
383 goto failed_read;
384
385 if ((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
386 goto failed_read1;
387
388 i->i_mode |= (inodeb->inode_type ==
389 SQUASHFS_CHRDEV_TYPE) ? S_IFCHR :
390 S_IFBLK;
391 init_special_inode(i, i->i_mode, inodep->rdev);
392
393 TRACE("Device inode %x:%x, rdev %x\n",
394 SQUASHFS_INODE_BLK(inode), offset,
395 inodep->rdev);
396 break;
397 }
398 case SQUASHFS_FIFO_TYPE:
399 case SQUASHFS_SOCKET_TYPE: {
400 if ((i = squashfs_new_inode(s, inodeb, ino)) == NULL)
401 goto failed_read1;
402
403 i->i_mode |= (inodeb->inode_type == SQUASHFS_FIFO_TYPE)
404 ? S_IFIFO : S_IFSOCK;
405 init_special_inode(i, i->i_mode, 0);
406 break;
407 }
408 default:
409 ERROR("Unknown inode type %d in squashfs_iget!\n",
410 inodeb->inode_type);
411 goto failed_read1;
412 }
413
414 insert_inode_hash(i);
415 return i;
416
417 failed_read:
418 ERROR("Unable to read inode [%x:%x]\n", block, offset);
419
420 failed_read1:
421 return NULL;
422 }
423
424
425 static int get_dir_index_using_offset(struct super_block *s, long long
426 *next_block, unsigned int *next_offset,
427 long long index_start,
428 unsigned int index_offset, int i_count,
429 long long f_pos)
430 {
431 struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
432 struct squashfs_super_block *sblk = &msblk->sblk;
433 int i, length = 0;
434 struct squashfs_dir_index_2 index;
435
436 TRACE("Entered get_dir_index_using_offset, i_count %d, f_pos %d\n",
437 i_count, (unsigned int) f_pos);
438
439 if (f_pos == 0)
440 goto finish;
441
442 for (i = 0; i < i_count; i++) {
443 if (msblk->swap) {
444 struct squashfs_dir_index_2 sindex;
445 squashfs_get_cached_block(s, (char *) &sindex,
446 index_start, index_offset,
447 sizeof(sindex), &index_start,
448 &index_offset);
449 SQUASHFS_SWAP_DIR_INDEX_2(&index, &sindex);
450 } else
451 squashfs_get_cached_block(s, (char *) &index,
452 index_start, index_offset,
453 sizeof(index), &index_start,
454 &index_offset);
455
456 if (index.index > f_pos)
457 break;
458
459 squashfs_get_cached_block(s, NULL, index_start, index_offset,
460 index.size + 1, &index_start,
461 &index_offset);
462
463 length = index.index;
464 *next_block = index.start_block + sblk->directory_table_start;
465 }
466
467 *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE;
468
469 finish:
470 return length;
471 }
472
473
474 static int get_dir_index_using_name(struct super_block *s, long long
475 *next_block, unsigned int *next_offset,
476 long long index_start,
477 unsigned int index_offset, int i_count,
478 const char *name, int size)
479 {
480 struct squashfs_sb_info *msblk = &s->u.squashfs_sb;
481 struct squashfs_super_block *sblk = &msblk->sblk;
482 int i, length = 0;
483 char buffer[sizeof(struct squashfs_dir_index_2) + SQUASHFS_NAME_LEN + 1];
484 struct squashfs_dir_index_2 *index = (struct squashfs_dir_index_2 *) buffer;
485 char str[SQUASHFS_NAME_LEN + 1];
486
487 TRACE("Entered get_dir_index_using_name, i_count %d\n", i_count);
488
489 strncpy(str, name, size);
490 str[size] = '\0';
491
492 for (i = 0; i < i_count; i++) {
493 if (msblk->swap) {
494 struct squashfs_dir_index_2 sindex;
495 squashfs_get_cached_block(s, (char *) &sindex,
496 index_start, index_offset,
497 sizeof(sindex), &index_start,
498 &index_offset);
499 SQUASHFS_SWAP_DIR_INDEX_2(index, &sindex);
500 } else
501 squashfs_get_cached_block(s, (char *) index,
502 index_start, index_offset,
503 sizeof(struct squashfs_dir_index_2),
504 &index_start, &index_offset);
505
506 squashfs_get_cached_block(s, index->name, index_start,
507 index_offset, index->size + 1,
508 &index_start, &index_offset);
509
510 index->name[index->size + 1] = '\0';
511
512 if (strcmp(index->name, str) > 0)
513 break;
514
515 length = index->index;
516 *next_block = index->start_block + sblk->directory_table_start;
517 }
518
519 *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE;
520 return length;
521 }
522
523
524 static int squashfs_readdir_2(struct file *file, void *dirent, filldir_t filldir)
525 {
526 struct inode *i = file->f_dentry->d_inode;
527 struct squashfs_sb_info *msblk = &i->i_sb->u.squashfs_sb;
528 struct squashfs_super_block *sblk = &msblk->sblk;
529 long long next_block = SQUASHFS_I(i)->start_block +
530 sblk->directory_table_start;
531 int next_offset = SQUASHFS_I(i)->offset, length = 0,
532 dir_count;
533 struct squashfs_dir_header_2 dirh;
534 char buffer[sizeof(struct squashfs_dir_entry_2) + SQUASHFS_NAME_LEN + 1];
535 struct squashfs_dir_entry_2 *dire = (struct squashfs_dir_entry_2 *) buffer;
536
537 TRACE("Entered squashfs_readdir_2 [%llx:%x]\n", next_block, next_offset);
538
539 length = get_dir_index_using_offset(i->i_sb, &next_block, &next_offset,
540 SQUASHFS_I(i)->u.s2.directory_index_start,
541 SQUASHFS_I(i)->u.s2.directory_index_offset,
542 SQUASHFS_I(i)->u.s2.directory_index_count,
543 file->f_pos);
544
545 while (length < i_size_read(i)) {
546 /* read directory header */
547 if (msblk->swap) {
548 struct squashfs_dir_header_2 sdirh;
549
550 if (!squashfs_get_cached_block(i->i_sb, (char *) &sdirh,
551 next_block, next_offset, sizeof(sdirh),
552 &next_block, &next_offset))
553 goto failed_read;
554
555 length += sizeof(sdirh);
556 SQUASHFS_SWAP_DIR_HEADER_2(&dirh, &sdirh);
557 } else {
558 if (!squashfs_get_cached_block(i->i_sb, (char *) &dirh,
559 next_block, next_offset, sizeof(dirh),
560 &next_block, &next_offset))
561 goto failed_read;
562
563 length += sizeof(dirh);
564 }
565
566 dir_count = dirh.count + 1;
567 while (dir_count--) {
568 if (msblk->swap) {
569 struct squashfs_dir_entry_2 sdire;
570 if (!squashfs_get_cached_block(i->i_sb, (char *)
571 &sdire, next_block, next_offset,
572 sizeof(sdire), &next_block,
573 &next_offset))
574 goto failed_read;
575
576 length += sizeof(sdire);
577 SQUASHFS_SWAP_DIR_ENTRY_2(dire, &sdire);
578 } else {
579 if (!squashfs_get_cached_block(i->i_sb, (char *)
580 dire, next_block, next_offset,
581 sizeof(*dire), &next_block,
582 &next_offset))
583 goto failed_read;
584
585 length += sizeof(*dire);
586 }
587
588 if (!squashfs_get_cached_block(i->i_sb, dire->name,
589 next_block, next_offset,
590 dire->size + 1, &next_block,
591 &next_offset))
592 goto failed_read;
593
594 length += dire->size + 1;
595
596 if (file->f_pos >= length)
597 continue;
598
599 dire->name[dire->size + 1] = '\0';
600
601 TRACE("Calling filldir(%x, %s, %d, %d, %x:%x, %d)\n",
602 (unsigned int) dirent, dire->name,
603 dire->size + 1, (int) file->f_pos,
604 dirh.start_block, dire->offset,
605 squashfs_filetype_table[dire->type]);
606
607 if (filldir(dirent, dire->name, dire->size + 1,
608 file->f_pos, SQUASHFS_MK_VFS_INODE(
609 dirh.start_block, dire->offset),
610 squashfs_filetype_table[dire->type])
611 < 0) {
612 TRACE("Filldir returned less than 0\n");
613 goto finish;
614 }
615 file->f_pos = length;
616 }
617 }
618
619 finish:
620 return 0;
621
622 failed_read:
623 ERROR("Unable to read directory block [%llx:%x]\n", next_block,
624 next_offset);
625 return 0;
626 }
627
628
629 static struct dentry *squashfs_lookup_2(struct inode *i, struct dentry *dentry)
630 {
631 const unsigned char *name = dentry->d_name.name;
632 int len = dentry->d_name.len;
633 struct inode *inode = NULL;
634 struct squashfs_sb_info *msblk = &i->i_sb->u.squashfs_sb;
635 struct squashfs_super_block *sblk = &msblk->sblk;
636 long long next_block = SQUASHFS_I(i)->start_block +
637 sblk->directory_table_start;
638 int next_offset = SQUASHFS_I(i)->offset, length = 0,
639 dir_count;
640 struct squashfs_dir_header_2 dirh;
641 char buffer[sizeof(struct squashfs_dir_entry_2) + SQUASHFS_NAME_LEN];
642 struct squashfs_dir_entry_2 *dire = (struct squashfs_dir_entry_2 *) buffer;
643 int sorted = sblk->s_major == 2 && sblk->s_minor >= 1;
644
645 TRACE("Entered squashfs_lookup [%llx:%x]\n", next_block, next_offset);
646
647 if (len > SQUASHFS_NAME_LEN)
648 goto exit_loop;
649
650 length = get_dir_index_using_name(i->i_sb, &next_block, &next_offset,
651 SQUASHFS_I(i)->u.s2.directory_index_start,
652 SQUASHFS_I(i)->u.s2.directory_index_offset,
653 SQUASHFS_I(i)->u.s2.directory_index_count, name,
654 len);
655
656 while (length < i_size_read(i)) {
657 /* read directory header */
658 if (msblk->swap) {
659 struct squashfs_dir_header_2 sdirh;
660 if (!squashfs_get_cached_block(i->i_sb, (char *) &sdirh,
661 next_block, next_offset, sizeof(sdirh),
662 &next_block, &next_offset))
663 goto failed_read;
664
665 length += sizeof(sdirh);
666 SQUASHFS_SWAP_DIR_HEADER_2(&dirh, &sdirh);
667 } else {
668 if (!squashfs_get_cached_block(i->i_sb, (char *) &dirh,
669 next_block, next_offset, sizeof(dirh),
670 &next_block, &next_offset))
671 goto failed_read;
672
673 length += sizeof(dirh);
674 }
675
676 dir_count = dirh.count + 1;
677 while (dir_count--) {
678 if (msblk->swap) {
679 struct squashfs_dir_entry_2 sdire;
680 if (!squashfs_get_cached_block(i->i_sb, (char *)
681 &sdire, next_block,next_offset,
682 sizeof(sdire), &next_block,
683 &next_offset))
684 goto failed_read;
685
686 length += sizeof(sdire);
687 SQUASHFS_SWAP_DIR_ENTRY_2(dire, &sdire);
688 } else {
689 if (!squashfs_get_cached_block(i->i_sb, (char *)
690 dire, next_block,next_offset,
691 sizeof(*dire), &next_block,
692 &next_offset))
693 goto failed_read;
694
695 length += sizeof(*dire);
696 }
697
698 if (!squashfs_get_cached_block(i->i_sb, dire->name,
699 next_block, next_offset, dire->size + 1,
700 &next_block, &next_offset))
701 goto failed_read;
702
703 length += dire->size + 1;
704
705 if (sorted && name[0] < dire->name[0])
706 goto exit_loop;
707
708 if ((len == dire->size + 1) && !strncmp(name,
709 dire->name, len)) {
710 squashfs_inode_t ino =
711 SQUASHFS_MKINODE(dirh.start_block,
712 dire->offset);
713
714 TRACE("calling squashfs_iget for directory "
715 "entry %s, inode %x:%x, %d\n", name,
716 dirh.start_block, dire->offset, ino);
717
718 inode = (msblk->iget)(i->i_sb, ino);
719
720 goto exit_loop;
721 }
722 }
723 }
724
725 exit_loop:
726 d_add(dentry, inode);
727 return ERR_PTR(0);
728
729 failed_read:
730 ERROR("Unable to read directory block [%llx:%x]\n", next_block,
731 next_offset);
732 goto exit_loop;
733 }
734
735
736 int squashfs_2_0_supported(struct squashfs_sb_info *msblk)
737 {
738 struct squashfs_super_block *sblk = &msblk->sblk;
739
740 msblk->iget = squashfs_iget_2;
741 msblk->read_fragment_index_table = read_fragment_index_table_2;
742
743 sblk->bytes_used = sblk->bytes_used_2;
744 sblk->uid_start = sblk->uid_start_2;
745 sblk->guid_start = sblk->guid_start_2;
746 sblk->inode_table_start = sblk->inode_table_start_2;
747 sblk->directory_table_start = sblk->directory_table_start_2;
748 sblk->fragment_table_start = sblk->fragment_table_start_2;
749
750 return 1;
751 }
https://github.com/ventoy/Ventoy