~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/hpfs/dir.c

Version: ~ [ linux-5.2 ] ~ [ linux-5.1.16 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.57 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.132 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.184 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.184 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.69 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  linux/fs/hpfs/dir.c
  3  *
  4  *  Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
  5  *
  6  *  directory VFS functions
  7  */
  8 
  9 #include <linux/slab.h>
 10 #include "hpfs_fn.h"
 11 
 12 static int hpfs_dir_release(struct inode *inode, struct file *filp)
 13 {
 14         hpfs_lock(inode->i_sb);
 15         hpfs_del_pos(inode, &filp->f_pos);
 16         /*hpfs_write_if_changed(inode);*/
 17         hpfs_unlock(inode->i_sb);
 18         return 0;
 19 }
 20 
 21 /* This is slow, but it's not used often */
 22 
 23 static loff_t hpfs_dir_lseek(struct file *filp, loff_t off, int whence)
 24 {
 25         loff_t new_off = off + (whence == 1 ? filp->f_pos : 0);
 26         loff_t pos;
 27         struct quad_buffer_head qbh;
 28         struct inode *i = file_inode(filp);
 29         struct hpfs_inode_info *hpfs_inode = hpfs_i(i);
 30         struct super_block *s = i->i_sb;
 31 
 32         /* Somebody else will have to figure out what to do here */
 33         if (whence == SEEK_DATA || whence == SEEK_HOLE)
 34                 return -EINVAL;
 35 
 36         mutex_lock(&i->i_mutex);
 37         hpfs_lock(s);
 38 
 39         /*pr_info("dir lseek\n");*/
 40         if (new_off == 0 || new_off == 1 || new_off == 11 || new_off == 12 || new_off == 13) goto ok;
 41         pos = ((loff_t) hpfs_de_as_down_as_possible(s, hpfs_inode->i_dno) << 4) + 1;
 42         while (pos != new_off) {
 43                 if (map_pos_dirent(i, &pos, &qbh)) hpfs_brelse4(&qbh);
 44                 else goto fail;
 45                 if (pos == 12) goto fail;
 46         }
 47         hpfs_add_pos(i, &filp->f_pos);
 48 ok:
 49         filp->f_pos = new_off;
 50         hpfs_unlock(s);
 51         mutex_unlock(&i->i_mutex);
 52         return new_off;
 53 fail:
 54         /*pr_warn("illegal lseek: %016llx\n", new_off);*/
 55         hpfs_unlock(s);
 56         mutex_unlock(&i->i_mutex);
 57         return -ESPIPE;
 58 }
 59 
 60 static int hpfs_readdir(struct file *file, struct dir_context *ctx)
 61 {
 62         struct inode *inode = file_inode(file);
 63         struct hpfs_inode_info *hpfs_inode = hpfs_i(inode);
 64         struct quad_buffer_head qbh;
 65         struct hpfs_dirent *de;
 66         int lc;
 67         loff_t next_pos;
 68         unsigned char *tempname;
 69         int c1, c2 = 0;
 70         int ret = 0;
 71 
 72         hpfs_lock(inode->i_sb);
 73 
 74         if (hpfs_sb(inode->i_sb)->sb_chk) {
 75                 if (hpfs_chk_sectors(inode->i_sb, inode->i_ino, 1, "dir_fnode")) {
 76                         ret = -EFSERROR;
 77                         goto out;
 78                 }
 79                 if (hpfs_chk_sectors(inode->i_sb, hpfs_inode->i_dno, 4, "dir_dnode")) {
 80                         ret = -EFSERROR;
 81                         goto out;
 82                 }
 83         }
 84         if (hpfs_sb(inode->i_sb)->sb_chk >= 2) {
 85                 struct buffer_head *bh;
 86                 struct fnode *fno;
 87                 int e = 0;
 88                 if (!(fno = hpfs_map_fnode(inode->i_sb, inode->i_ino, &bh))) {
 89                         ret = -EIOERROR;
 90                         goto out;
 91                 }
 92                 if (!fnode_is_dir(fno)) {
 93                         e = 1;
 94                         hpfs_error(inode->i_sb, "not a directory, fnode %08lx",
 95                                         (unsigned long)inode->i_ino);
 96                 }
 97                 if (hpfs_inode->i_dno != le32_to_cpu(fno->u.external[0].disk_secno)) {
 98                         e = 1;
 99                         hpfs_error(inode->i_sb, "corrupted inode: i_dno == %08x, fnode -> dnode == %08x", hpfs_inode->i_dno, le32_to_cpu(fno->u.external[0].disk_secno));
100                 }
101                 brelse(bh);
102                 if (e) {
103                         ret = -EFSERROR;
104                         goto out;
105                 }
106         }
107         lc = hpfs_sb(inode->i_sb)->sb_lowercase;
108         if (ctx->pos == 12) { /* diff -r requires this (note, that diff -r */
109                 ctx->pos = 13; /* also fails on msdos filesystem in 2.0) */
110                 goto out;
111         }
112         if (ctx->pos == 13) {
113                 ret = -ENOENT;
114                 goto out;
115         }
116         
117         while (1) {
118                 again:
119                 /* This won't work when cycle is longer than number of dirents
120                    accepted by filldir, but what can I do?
121                    maybe killall -9 ls helps */
122                 if (hpfs_sb(inode->i_sb)->sb_chk)
123                         if (hpfs_stop_cycles(inode->i_sb, ctx->pos, &c1, &c2, "hpfs_readdir")) {
124                                 ret = -EFSERROR;
125                                 goto out;
126                         }
127                 if (ctx->pos == 12)
128                         goto out;
129                 if (ctx->pos == 3 || ctx->pos == 4 || ctx->pos == 5) {
130                         pr_err("pos==%d\n", (int)ctx->pos);
131                         goto out;
132                 }
133                 if (ctx->pos == 0) {
134                         if (!dir_emit_dot(file, ctx))
135                                 goto out;
136                         ctx->pos = 11;
137                 }
138                 if (ctx->pos == 11) {
139                         if (!dir_emit(ctx, "..", 2, hpfs_inode->i_parent_dir, DT_DIR))
140                                 goto out;
141                         ctx->pos = 1;
142                 }
143                 if (ctx->pos == 1) {
144                         ctx->pos = ((loff_t) hpfs_de_as_down_as_possible(inode->i_sb, hpfs_inode->i_dno) << 4) + 1;
145                         hpfs_add_pos(inode, &file->f_pos);
146                         file->f_version = inode->i_version;
147                 }
148                 next_pos = ctx->pos;
149                 if (!(de = map_pos_dirent(inode, &next_pos, &qbh))) {
150                         ctx->pos = next_pos;
151                         ret = -EIOERROR;
152                         goto out;
153                 }
154                 if (de->first || de->last) {
155                         if (hpfs_sb(inode->i_sb)->sb_chk) {
156                                 if (de->first && !de->last && (de->namelen != 2
157                                     || de ->name[0] != 1 || de->name[1] != 1))
158                                         hpfs_error(inode->i_sb, "hpfs_readdir: bad ^A^A entry; pos = %08lx", (unsigned long)ctx->pos);
159                                 if (de->last && (de->namelen != 1 || de ->name[0] != 255))
160                                         hpfs_error(inode->i_sb, "hpfs_readdir: bad \\377 entry; pos = %08lx", (unsigned long)ctx->pos);
161                         }
162                         hpfs_brelse4(&qbh);
163                         ctx->pos = next_pos;
164                         goto again;
165                 }
166                 tempname = hpfs_translate_name(inode->i_sb, de->name, de->namelen, lc, de->not_8x3);
167                 if (!dir_emit(ctx, tempname, de->namelen, le32_to_cpu(de->fnode), DT_UNKNOWN)) {
168                         if (tempname != de->name) kfree(tempname);
169                         hpfs_brelse4(&qbh);
170                         goto out;
171                 }
172                 ctx->pos = next_pos;
173                 if (tempname != de->name) kfree(tempname);
174                 hpfs_brelse4(&qbh);
175         }
176 out:
177         hpfs_unlock(inode->i_sb);
178         return ret;
179 }
180 
181 /*
182  * lookup.  Search the specified directory for the specified name, set
183  * *result to the corresponding inode.
184  *
185  * lookup uses the inode number to tell read_inode whether it is reading
186  * the inode of a directory or a file -- file ino's are odd, directory
187  * ino's are even.  read_inode avoids i/o for file inodes; everything
188  * needed is up here in the directory.  (And file fnodes are out in
189  * the boondocks.)
190  *
191  *    - M.P.: this is over, sometimes we've got to read file's fnode for eas
192  *            inode numbers are just fnode sector numbers; iget lock is used
193  *            to tell read_inode to read fnode or not.
194  */
195 
196 struct dentry *hpfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
197 {
198         const unsigned char *name = dentry->d_name.name;
199         unsigned len = dentry->d_name.len;
200         struct quad_buffer_head qbh;
201         struct hpfs_dirent *de;
202         ino_t ino;
203         int err;
204         struct inode *result = NULL;
205         struct hpfs_inode_info *hpfs_result;
206 
207         hpfs_lock(dir->i_sb);
208         if ((err = hpfs_chk_name(name, &len))) {
209                 if (err == -ENAMETOOLONG) {
210                         hpfs_unlock(dir->i_sb);
211                         return ERR_PTR(-ENAMETOOLONG);
212                 }
213                 goto end_add;
214         }
215 
216         /*
217          * '.' and '..' will never be passed here.
218          */
219 
220         de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, NULL, &qbh);
221 
222         /*
223          * This is not really a bailout, just means file not found.
224          */
225 
226         if (!de) goto end;
227 
228         /*
229          * Get inode number, what we're after.
230          */
231 
232         ino = le32_to_cpu(de->fnode);
233 
234         /*
235          * Go find or make an inode.
236          */
237 
238         result = iget_locked(dir->i_sb, ino);
239         if (!result) {
240                 hpfs_error(dir->i_sb, "hpfs_lookup: can't get inode");
241                 goto bail1;
242         }
243         if (result->i_state & I_NEW) {
244                 hpfs_init_inode(result);
245                 if (de->directory)
246                         hpfs_read_inode(result);
247                 else if (le32_to_cpu(de->ea_size) && hpfs_sb(dir->i_sb)->sb_eas)
248                         hpfs_read_inode(result);
249                 else {
250                         result->i_mode |= S_IFREG;
251                         result->i_mode &= ~0111;
252                         result->i_op = &hpfs_file_iops;
253                         result->i_fop = &hpfs_file_ops;
254                         set_nlink(result, 1);
255                 }
256                 unlock_new_inode(result);
257         }
258         hpfs_result = hpfs_i(result);
259         if (!de->directory) hpfs_result->i_parent_dir = dir->i_ino;
260 
261         if (de->has_acl || de->has_xtd_perm) if (!(dir->i_sb->s_flags & MS_RDONLY)) {
262                 hpfs_error(result->i_sb, "ACLs or XPERM found. This is probably HPFS386. This driver doesn't support it now. Send me some info on these structures");
263                 goto bail1;
264         }
265 
266         /*
267          * Fill in the info from the directory if this is a newly created
268          * inode.
269          */
270 
271         if (!result->i_ctime.tv_sec) {
272                 if (!(result->i_ctime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(de->creation_date))))
273                         result->i_ctime.tv_sec = 1;
274                 result->i_ctime.tv_nsec = 0;
275                 result->i_mtime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(de->write_date));
276                 result->i_mtime.tv_nsec = 0;
277                 result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(de->read_date));
278                 result->i_atime.tv_nsec = 0;
279                 hpfs_result->i_ea_size = le32_to_cpu(de->ea_size);
280                 if (!hpfs_result->i_ea_mode && de->read_only)
281                         result->i_mode &= ~0222;
282                 if (!de->directory) {
283                         if (result->i_size == -1) {
284                                 result->i_size = le32_to_cpu(de->file_size);
285                                 result->i_data.a_ops = &hpfs_aops;
286                                 hpfs_i(result)->mmu_private = result->i_size;
287                         /*
288                          * i_blocks should count the fnode and any anodes.
289                          * We count 1 for the fnode and don't bother about
290                          * anodes -- the disk heads are on the directory band
291                          * and we want them to stay there.
292                          */
293                                 result->i_blocks = 1 + ((result->i_size + 511) >> 9);
294                         }
295                 }
296         }
297 
298         hpfs_brelse4(&qbh);
299 
300         /*
301          * Made it.
302          */
303 
304         end:
305         end_add:
306         hpfs_unlock(dir->i_sb);
307         d_add(dentry, result);
308         return NULL;
309 
310         /*
311          * Didn't.
312          */
313         bail1:
314         
315         hpfs_brelse4(&qbh);
316         
317         /*bail:*/
318 
319         hpfs_unlock(dir->i_sb);
320         return ERR_PTR(-ENOENT);
321 }
322 
323 const struct file_operations hpfs_dir_ops =
324 {
325         .llseek         = hpfs_dir_lseek,
326         .read           = generic_read_dir,
327         .iterate        = hpfs_readdir,
328         .release        = hpfs_dir_release,
329         .fsync          = hpfs_file_fsync,
330 };
331 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp