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 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_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 * bh = NULL, * tmp, * bha[16]; 115 kernel_lb_addr bloc, eloc; 116 uint32_t extoffset, elen, offset; 117 int i, num; 118 unsigned int dt_type; 119 120 if (nf_pos >= size) 121 return 0; 122 123 if (nf_pos == 0) 124 nf_pos = (udf_ext0_offset(dir) >> 2); 125 126 fibh.soffset = fibh.eoffset = (nf_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2; 127 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) 128 fibh.sbh = fibh.ebh = NULL; 129 else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2), 130 &bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30)) 131 { 132 offset >>= dir->i_sb->s_blocksize_bits; 133 block = udf_get_lb_pblock(dir->i_sb, eloc, offset); 134 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) 135 { 136 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT) 137 extoffset -= sizeof(short_ad); 138 else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG) 139 extoffset -= sizeof(long_ad); 140 } 141 else 142 offset = 0; 143 144 if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block))) 145 { 146 udf_release_data(bh); 147 return -EIO; 148 } 149 150 if (!(offset & ((16 >> (dir->i_sb->s_blocksize_bits - 9))-1))) 151 { 152 i = 16 >> (dir->i_sb->s_blocksize_bits - 9); 153 if (i+offset > (elen >> dir->i_sb->s_blocksize_bits)) 154 i = (elen >> dir->i_sb->s_blocksize_bits)-offset; 155 for (num=0; i>0; i--) 156 { 157 block = udf_get_lb_pblock(dir->i_sb, eloc, offset+i); 158 tmp = udf_tgetblk(dir->i_sb, block); 159 if (tmp && !buffer_uptodate(tmp) && !buffer_locked(tmp)) 160 bha[num++] = tmp; 161 else 162 brelse(tmp); 163 } 164 if (num) 165 { 166 ll_rw_block(READA, num, bha); 167 for (i=0; i<num; i++) 168 brelse(bha[i]); 169 } 170 } 171 } 172 else 173 { 174 udf_release_data(bh); 175 return -ENOENT; 176 } 177 178 while ( nf_pos < size ) 179 { 180 filp->f_pos = nf_pos + 1; 181 182 fi = udf_fileident_read(dir, &nf_pos, &fibh, &cfi, &bloc, &extoffset, &eloc, &elen, &offset, &bh); 183 184 if (!fi) 185 { 186 if (fibh.sbh != fibh.ebh) 187 udf_release_data(fibh.ebh); 188 udf_release_data(fibh.sbh); 189 udf_release_data(bh); 190 return 0; 191 } 192 193 liu = le16_to_cpu(cfi.lengthOfImpUse); 194 lfi = cfi.lengthFileIdent; 195 196 if (fibh.sbh == fibh.ebh) 197 nameptr = fi->fileIdent + liu; 198 else 199 { 200 int poffset; /* Unpaded ending offset */ 201 202 poffset = fibh.soffset + sizeof(struct fileIdentDesc) + liu + lfi; 203 204 if (poffset >= lfi) 205 nameptr = (char *)(fibh.ebh->b_data + poffset - lfi); 206 else 207 { 208 nameptr = fname; 209 memcpy(nameptr, fi->fileIdent + liu, lfi - poffset); 210 memcpy(nameptr + lfi - poffset, fibh.ebh->b_data, poffset); 211 } 212 } 213 214 if ( (cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) != 0 ) 215 { 216 if ( !UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNDELETE) ) 217 continue; 218 } 219 220 if ( (cfi.fileCharacteristics & FID_FILE_CHAR_HIDDEN) != 0 ) 221 { 222 if ( !UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNHIDE) ) 223 continue; 224 } 225 226 if ( cfi.fileCharacteristics & FID_FILE_CHAR_PARENT ) 227 { 228 iblock = parent_ino(filp->f_dentry); 229 flen = 2; 230 memcpy(fname, "..", flen); 231 dt_type = DT_DIR; 232 } 233 else 234 { 235 kernel_lb_addr tloc = lelb_to_cpu(cfi.icb.extLocation); 236 237 iblock = udf_get_lb_pblock(dir->i_sb, tloc, 0); 238 flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi); 239 dt_type = DT_UNKNOWN; 240 } 241 242 if (flen) 243 { 244 if (filldir(dirent, fname, flen, filp->f_pos, iblock, dt_type) < 0) 245 { 246 if (fibh.sbh != fibh.ebh) 247 udf_release_data(fibh.ebh); 248 udf_release_data(fibh.sbh); 249 udf_release_data(bh); 250 return 0; 251 } 252 } 253 } /* end while */ 254 255 filp->f_pos = nf_pos + 1; 256 257 if (fibh.sbh != fibh.ebh) 258 udf_release_data(fibh.ebh); 259 udf_release_data(fibh.sbh); 260 udf_release_data(bh); 261 262 return 0; 263 } 264