1 /* 2 * Squashfs - a compressed read only filesystem for Linux 3 * 4 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008 5 * Phillip Lougher <phillip@squashfs.org.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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 20 * 21 * dir.c 22 */ 23 24 /* 25 * This file implements code to read directories from disk. 26 * 27 * See namei.c for a description of directory organisation on disk. 28 */ 29 30 #include <linux/fs.h> 31 #include <linux/vfs.h> 32 #include <linux/slab.h> 33 34 #include "squashfs_fs.h" 35 #include "squashfs_fs_sb.h" 36 #include "squashfs_fs_i.h" 37 #include "squashfs.h" 38 39 static const unsigned char squashfs_filetype_table[] = { 40 DT_UNKNOWN, DT_DIR, DT_REG, DT_LNK, DT_BLK, DT_CHR, DT_FIFO, DT_SOCK 41 }; 42 43 /* 44 * Lookup offset (f_pos) in the directory index, returning the 45 * metadata block containing it. 46 * 47 * If we get an error reading the index then return the part of the index 48 * (if any) we have managed to read - the index isn't essential, just 49 * quicker. 50 */ 51 static int get_dir_index_using_offset(struct super_block *sb, 52 u64 *next_block, int *next_offset, u64 index_start, int index_offset, 53 int i_count, u64 f_pos) 54 { 55 struct squashfs_sb_info *msblk = sb->s_fs_info; 56 int err, i, index, length = 0; 57 struct squashfs_dir_index dir_index; 58 59 TRACE("Entered get_dir_index_using_offset, i_count %d, f_pos %lld\n", 60 i_count, f_pos); 61 62 /* 63 * Translate from external f_pos to the internal f_pos. This 64 * is offset by 3 because we invent "." and ".." entries which are 65 * not actually stored in the directory. 66 */ 67 if (f_pos <= 3) 68 return f_pos; 69 f_pos -= 3; 70 71 for (i = 0; i < i_count; i++) { 72 err = squashfs_read_metadata(sb, &dir_index, &index_start, 73 &index_offset, sizeof(dir_index)); 74 if (err < 0) 75 break; 76 77 index = le32_to_cpu(dir_index.index); 78 if (index > f_pos) 79 /* 80 * Found the index we're looking for. 81 */ 82 break; 83 84 err = squashfs_read_metadata(sb, NULL, &index_start, 85 &index_offset, le32_to_cpu(dir_index.size) + 1); 86 if (err < 0) 87 break; 88 89 length = index; 90 *next_block = le32_to_cpu(dir_index.start_block) + 91 msblk->directory_table; 92 } 93 94 *next_offset = (length + *next_offset) % SQUASHFS_METADATA_SIZE; 95 96 /* 97 * Translate back from internal f_pos to external f_pos. 98 */ 99 return length + 3; 100 } 101 102 103 static int squashfs_readdir(struct file *file, struct dir_context *ctx) 104 { 105 struct inode *inode = file_inode(file); 106 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; 107 u64 block = squashfs_i(inode)->start + msblk->directory_table; 108 int offset = squashfs_i(inode)->offset, length, dir_count, size, 109 type, err; 110 unsigned int inode_number; 111 struct squashfs_dir_header dirh; 112 struct squashfs_dir_entry *dire; 113 114 TRACE("Entered squashfs_readdir [%llx:%x]\n", block, offset); 115 116 dire = kmalloc(sizeof(*dire) + SQUASHFS_NAME_LEN + 1, GFP_KERNEL); 117 if (dire == NULL) { 118 ERROR("Failed to allocate squashfs_dir_entry\n"); 119 goto finish; 120 } 121 122 /* 123 * Return "." and ".." entries as the first two filenames in the 124 * directory. To maximise compression these two entries are not 125 * stored in the directory, and so we invent them here. 126 * 127 * It also means that the external f_pos is offset by 3 from the 128 * on-disk directory f_pos. 129 */ 130 while (ctx->pos < 3) { 131 char *name; 132 int i_ino; 133 134 if (ctx->pos == 0) { 135 name = "."; 136 size = 1; 137 i_ino = inode->i_ino; 138 } else { 139 name = ".."; 140 size = 2; 141 i_ino = squashfs_i(inode)->parent; 142 } 143 144 if (!dir_emit(ctx, name, size, i_ino, 145 squashfs_filetype_table[1])) 146 goto finish; 147 148 ctx->pos += size; 149 } 150 151 length = get_dir_index_using_offset(inode->i_sb, &block, &offset, 152 squashfs_i(inode)->dir_idx_start, 153 squashfs_i(inode)->dir_idx_offset, 154 squashfs_i(inode)->dir_idx_cnt, 155 ctx->pos); 156 157 while (length < i_size_read(inode)) { 158 /* 159 * Read directory header 160 */ 161 err = squashfs_read_metadata(inode->i_sb, &dirh, &block, 162 &offset, sizeof(dirh)); 163 if (err < 0) 164 goto failed_read; 165 166 length += sizeof(dirh); 167 168 dir_count = le32_to_cpu(dirh.count) + 1; 169 170 if (dir_count > SQUASHFS_DIR_COUNT) 171 goto failed_read; 172 173 while (dir_count--) { 174 /* 175 * Read directory entry. 176 */ 177 err = squashfs_read_metadata(inode->i_sb, dire, &block, 178 &offset, sizeof(*dire)); 179 if (err < 0) 180 goto failed_read; 181 182 size = le16_to_cpu(dire->size) + 1; 183 184 /* size should never be larger than SQUASHFS_NAME_LEN */ 185 if (size > SQUASHFS_NAME_LEN) 186 goto failed_read; 187 188 err = squashfs_read_metadata(inode->i_sb, dire->name, 189 &block, &offset, size); 190 if (err < 0) 191 goto failed_read; 192 193 length += sizeof(*dire) + size; 194 195 if (ctx->pos >= length) 196 continue; 197 198 dire->name[size] = '\0'; 199 inode_number = le32_to_cpu(dirh.inode_number) + 200 ((short) le16_to_cpu(dire->inode_number)); 201 type = le16_to_cpu(dire->type); 202 203 if (!dir_emit(ctx, dire->name, size, 204 inode_number, 205 squashfs_filetype_table[type])) 206 goto finish; 207 208 ctx->pos = length; 209 } 210 } 211 212 finish: 213 kfree(dire); 214 return 0; 215 216 failed_read: 217 ERROR("Unable to read directory block [%llx:%x]\n", block, offset); 218 kfree(dire); 219 return 0; 220 } 221 222 223 const struct file_operations squashfs_dir_ops = { 224 .read = generic_read_dir, 225 .iterate = squashfs_readdir, 226 .llseek = default_llseek, 227 }; 228