1 /* 2 * dir.c 3 * 4 * PURPOSE 5 * Directory handling routines for the OSTA-UDF(tm) filesystem. 6 * 7 * COPYRIGHT 8 * This file is distributed under the terms of the GNU General Public 9 * License (GPL). Copies of the GPL can be obtained from: 10 * ftp://prep.ai.mit.edu/pub/gnu/GPL 11 * Each contributing author retains all rights to their own work. 12 * 13 * (C) 1998-2004 Ben Fennema 14 * 15 * HISTORY 16 * 17 * 10/05/98 dgb Split directory operations into its own file 18 * Implemented directory reads via do_udf_readdir 19 * 10/06/98 Made directory operations work! 20 * 11/17/98 Rewrote directory to support ICBTAG_FLAG_AD_LONG 21 * 11/25/98 blf Rewrote directory handling (readdir+lookup) to support reading 22 * across blocks. 23 * 12/12/98 Split out the lookup code to namei.c. bulk of directory 24 * code now in directory.c:udf_fileident_read. 25 */ 26 27 #include "udfdecl.h" 28 29 #include <linux/string.h> 30 #include <linux/errno.h> 31 #include <linux/mm.h> 32 #include <linux/slab.h> 33 #include <linux/smp_lock.h> 34 #include <linux/buffer_head.h> 35 36 #include "udf_i.h" 37 #include "udf_sb.h" 38 39 /* Prototypes for file operations */ 40 static int udf_readdir(struct file *, void *, filldir_t); 41 static int do_udf_readdir(struct inode *, struct file *, filldir_t, void *); 42 43 /* readdir and lookup functions */ 44 45 const struct file_operations udf_dir_operations = { 46 .read = generic_read_dir, 47 .readdir = udf_readdir, 48 .ioctl = udf_ioctl, 49 .fsync = udf_fsync_file, 50 }; 51 52 /* 53 * udf_readdir 54 * 55 * PURPOSE 56 * Read a directory entry. 57 * 58 * DESCRIPTION 59 * Optional - sys_getdents() will return -ENOTDIR if this routine is not 60 * available. 61 * 62 * Refer to sys_getdents() in fs/readdir.c 63 * sys_getdents() -> . 64 * 65 * PRE-CONDITIONS 66 * filp Pointer to directory file. 67 * buf Pointer to directory entry buffer. 68 * filldir Pointer to filldir function. 69 * 70 * POST-CONDITIONS 71 * <return> >=0 on success. 72 * 73 * HISTORY 74 * July 1, 1997 - Andrew E. Mileski 75 * Written, tested, and released. 76 */ 77 78 int udf_readdir(struct file *filp, void *dirent, filldir_t filldir) 79 { 80 struct inode *dir = filp->f_path.dentry->d_inode; 81 int result; 82 83 lock_kernel(); 84 85 if ( filp->f_pos == 0 ) 86 { 87 if (filldir(dirent, ".", 1, filp->f_pos, dir->i_ino, DT_DIR) < 0) 88 { 89 unlock_kernel(); 90 return 0; 91 } 92 filp->f_pos ++; 93 } 94 95 result = do_udf_readdir(dir, filp, filldir, dirent); 96 unlock_kernel(); 97 return result; 98 } 99 100 static int 101 do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *dirent) 102 { 103 struct udf_fileident_bh fibh; 104 struct fileIdentDesc *fi=NULL; 105 struct fileIdentDesc cfi; 106 int block, iblock; 107 loff_t nf_pos = filp->f_pos - 1; 108 int flen; 109 char fname[UDF_NAME_LEN]; 110 char *nameptr; 111 uint16_t liu; 112 uint8_t lfi; 113 loff_t size = (udf_ext0_offset(dir) + dir->i_size) >> 2; 114 struct buffer_head *tmp, *bha[16]; 115 kernel_lb_addr eloc; 116 uint32_t elen; 117 sector_t offset; 118 int i, num; 119 unsigned int dt_type; 120 struct extent_position epos = { NULL, 0, {0, 0}}; 121 122 if (nf_pos >= size) 123 return 0; 124 125 if (nf_pos == 0) 126 nf_pos = (udf_ext0_offset(dir) >> 2); 127 128 fibh.soffset = fibh.eoffset = (nf_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2; 129 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) 130 fibh.sbh = fibh.ebh = NULL; 131 else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2), 132 &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) 133 { 134 block = udf_get_lb_pblock(dir->i_sb, eloc, offset); 135 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) 136 { 137 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT) 138 epos.offset -= sizeof(short_ad); 139 else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG) 140 epos.offset -= sizeof(long_ad); 141 } 142 else 143 offset = 0; 144 145 if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block))) 146 { 147 brelse(epos.bh); 148 return -EIO; 149 } 150 151 if (!(offset & ((16 >> (dir->i_sb->s_blocksize_bits - 9))-1))) 152 { 153 i = 16 >> (dir->i_sb->s_blocksize_bits - 9); 154 if (i+offset > (elen >> dir->i_sb->s_blocksize_bits)) 155 i = (elen >> dir->i_sb->s_blocksize_bits)-offset; 156 for (num=0; i>0; i--) 157 { 158 block = udf_get_lb_pblock(dir->i_sb, eloc, offset+i); 159 tmp = udf_tgetblk(dir->i_sb, block); 160 if (tmp && !buffer_uptodate(tmp) && !buffer_locked(tmp)) 161 bha[num++] = tmp; 162 else 163 brelse(tmp); 164 } 165 if (num) 166 { 167 ll_rw_block(READA, num, bha); 168 for (i=0; i<num; i++) 169 brelse(bha[i]); 170 } 171 } 172 } 173 else 174 { 175 brelse(epos.bh); 176 return -ENOENT; 177 } 178 179 while ( nf_pos < size ) 180 { 181 filp->f_pos = nf_pos + 1; 182 183 fi = udf_fileident_read(dir, &nf_pos, &fibh, &cfi, &epos, &eloc, &elen, &offset); 184 185 if (!fi) 186 { 187 if (fibh.sbh != fibh.ebh) 188 brelse(fibh.ebh); 189 brelse(fibh.sbh); 190 brelse(epos.bh); 191 return 0; 192 } 193 194 liu = le16_to_cpu(cfi.lengthOfImpUse); 195 lfi = cfi.lengthFileIdent; 196 197 if (fibh.sbh == fibh.ebh) 198 nameptr = fi->fileIdent + liu; 199 else 200 { 201 int poffset; /* Unpaded ending offset */ 202 203 poffset = fibh.soffset + sizeof(struct fileIdentDesc) + liu + lfi; 204 205 if (poffset >= lfi) 206 nameptr = (char *)(fibh.ebh->b_data + poffset - lfi); 207 else 208 { 209 nameptr = fname; 210 memcpy(nameptr, fi->fileIdent + liu, lfi - poffset); 211 memcpy(nameptr + lfi - poffset, fibh.ebh->b_data, poffset); 212 } 213 } 214 215 if ( (cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) != 0 ) 216 { 217 if ( !UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNDELETE) ) 218 continue; 219 } 220 221 if ( (cfi.fileCharacteristics & FID_FILE_CHAR_HIDDEN) != 0 ) 222 { 223 if ( !UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNHIDE) ) 224 continue; 225 } 226 227 if ( cfi.fileCharacteristics & FID_FILE_CHAR_PARENT ) 228 { 229 iblock = parent_ino(filp->f_path.dentry); 230 flen = 2; 231 memcpy(fname, "..", flen); 232 dt_type = DT_DIR; 233 } 234 else 235 { 236 kernel_lb_addr tloc = lelb_to_cpu(cfi.icb.extLocation); 237 238 iblock = udf_get_lb_pblock(dir->i_sb, tloc, 0); 239 flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi); 240 dt_type = DT_UNKNOWN; 241 } 242 243 if (flen) 244 { 245 if (filldir(dirent, fname, flen, filp->f_pos, iblock, dt_type) < 0) 246 { 247 if (fibh.sbh != fibh.ebh) 248 brelse(fibh.ebh); 249 brelse(fibh.sbh); 250 brelse(epos.bh); 251 return 0; 252 } 253 } 254 } /* end while */ 255 256 filp->f_pos = nf_pos + 1; 257 258 if (fibh.sbh != fibh.ebh) 259 brelse(fibh.ebh); 260 brelse(fibh.sbh); 261 brelse(epos.bh); 262 263 return 0; 264 } 265