Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * dir.c | |
3 | * | |
4 | * PURPOSE | |
5 | * Directory handling routines for the OSTA-UDF(tm) filesystem. | |
6 | * | |
1da177e4 LT |
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 | ||
4b6f5d20 | 45 | const struct file_operations udf_dir_operations = { |
1da177e4 LT |
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 | } |