![[first]](../icons/first.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
1 /*
2 * linux/fs/umsdos/dir.c
3 *
4 * Written 1993 by Jacques Gelinas
5 * Inspired from linux/fs/msdos/... : Werner Almesberger
6 *
7 * Extended MS-DOS directory handling functions
8 */
9
10 #ifdef MODULE
11 #include <linux/module.h>
12 #endif
13
14 #include <asm/segment.h>
15
16 #include <linux/sched.h>
17 #include <linux/string.h>
18 #include <linux/fs.h>
19 #include <linux/msdos_fs.h>
20 #include <linux/errno.h>
21 #include <linux/stat.h>
22 #include <linux/limits.h>
23 #include <linux/umsdos_fs.h>
24 #include <linux/malloc.h>
25
26 #define PRINTK(x)
27 #define Printk(x) printk x
28
29 #define UMSDOS_SPECIAL_DIRFPOS 3
30 extern struct inode *pseudo_root;
31 /*
32 So grep * doesn't complain in the presence of directories.
33 */
34 int UMSDOS_dir_read(struct inode *inode,struct file *filp,char *buf,
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
35 int count)
36 {
37 return -EISDIR;
38 }
39
40 struct UMSDOS_DIR_ONCE {
41 void *dirbuf;
42 filldir_t filldir;
43 int count;
44 int stop;
45 };
46
47 /*
48 Record a single entry the first call.
49 Return -EINVAL the next one.
50 */
51 static int umsdos_dir_once(
/* ![[previous]](../icons/left.png)
*/
52 void * buf,
53 const char * name,
54 int name_len,
55 off_t offset,
56 ino_t ino)
57 {
58 int ret = -EINVAL;
59 struct UMSDOS_DIR_ONCE *d = (struct UMSDOS_DIR_ONCE *)buf;
60 if (d->count == 0){
61 #if 0
62 char zname[100];
63 memcpy (zname,name,name_len);
64 zname[name_len] = '\0';
65 Printk (("dir_once :%s: offset %Ld\n",zname,offset));
66 #endif
67 ret = d->filldir (d->dirbuf,name,name_len,offset,ino);
68 d->stop = ret < 0;
69 d->count = 1;
70 }
71 return ret;
72 }
73
74 /*
75 Read count directory entries from directory filp
76 Return a negative value from linux/errno.h.
77 Return > 0 if success (The amount of byte written by filldir).
78
79 This function is used by the normal readdir VFS entry point and by
80 some function who try to find out info on a file from a pure MSDOS
81 inode. See umsdos_locate_ancestor() below.
82 */
83 static int umsdos_readdir_x(
/* */
84 struct inode *dir, /* Point to a description of the super block */
85 struct file *filp, /* Point to a directory which is read */
86 void *dirbuf, /* Will hold count directory entry */
87 /* but filled by the filldir function */
88 int internal_read, /* Called for internal purpose */
89 struct umsdos_dirent *u_entry, /* Optional umsdos entry */
90 int follow_hlink,
91 filldir_t filldir)
92 {
93 int ret = 0;
94
95 umsdos_startlookup(dir);
96 if (filp->f_pos == UMSDOS_SPECIAL_DIRFPOS
97 && dir == pseudo_root
98 && !internal_read){
99 /*
100 We don't need to simulate this pseudo directory
101 when umsdos_readdir_x is called for internal operation
102 of umsdos. This is why dirent_in_fs is tested
103 */
104 /* #Specification: pseudo root / directory /DOS
105 When umsdos operates in pseudo root mode (C:\linux is the
106 linux root), it simulate a directory /DOS which points to
107 the real root of the file system.
108 */
109 if (filldir (dirbuf,"DOS",3,UMSDOS_SPECIAL_DIRFPOS
110 ,dir->i_sb->s_mounted->i_ino) == 0){
111 filp->f_pos++;
112 }
113 }else if (filp->f_pos < 2
114 || (dir != dir->i_sb->s_mounted && filp->f_pos == 32)){
115 /* #Specification: readdir / . and ..
116 The msdos filesystem manage the . and .. entry properly
117 so the EMD file won't hold any info about it.
118
119 In readdir, we assume that for the root directory
120 the read position will be 0 for ".", 1 for "..". For
121 a non root directory, the read position will be 0 for "."
122 and 32 for "..".
123 */
124 /*
125 This is a trick used by the msdos file system (fs/msdos/dir.c)
126 to manage . and .. for the root directory of a file system.
127 Since there is no such entry in the root, fs/msdos/dir.c
128 use the following:
129
130 if f_pos == 0, return ".".
131 if f_pos == 1, return "..".
132
133 So let msdos handle it
134
135 Since umsdos entries are much larger, we share the same f_pos.
136 if f_pos is 0 or 1 or 32, we are clearly looking at . and
137 ..
138
139 As soon as we get f_pos == 2 or f_pos == 64, then back to
140 0, but this time we are reading the EMD file.
141
142 Well, not so true. The problem, is that UMSDOS_REC_SIZE is
143 also 64, so as soon as we read the first record in the
144 EMD, we are back at offset 64. So we set the offset
145 to UMSDOS_SPECIAL_DIRFPOS(3) as soon as we have read the
146 .. entry from msdos.
147
148 Now (linux 1.3), umsdos_readdir can read more than one
149 entry even if we limit (umsdos_dir_once) to only one:
150 It skips over hidden file. So we switch to
151 UMSDOS_SPECIAL_DIRFPOS as soon as we have read successfully
152 the .. entry.
153 */
154 int last_f_pos = filp->f_pos;
155 struct UMSDOS_DIR_ONCE bufk;
156 bufk.dirbuf = dirbuf;
157 bufk.filldir = filldir;
158 bufk.count = 0;
159 ret = msdos_readdir(dir,filp,&bufk,umsdos_dir_once);
160 if (last_f_pos > 0 && filp->f_pos > last_f_pos) filp->f_pos = UMSDOS_SPECIAL_DIRFPOS;
161 if (u_entry != NULL) u_entry->flags = 0;
162 }else{
163 struct inode *emd_dir = umsdos_emd_dir_lookup(dir,0);
164 if (emd_dir != NULL){
165 off_t start_fpos = filp->f_pos;
166 if (filp->f_pos <= UMSDOS_SPECIAL_DIRFPOS+1) filp->f_pos = 0;
167 PRINTK (("f_pos %lu i_size %ld\n",filp->f_pos,emd_dir->i_size));
168 ret = 0;
169 while (filp->f_pos < emd_dir->i_size){
170 struct umsdos_dirent entry;
171 off_t cur_f_pos = filp->f_pos;
172 if (umsdos_emd_dir_readentry (emd_dir,filp,&entry)!=0){
173 ret = -EIO;
174 break;
175 }else if (entry.name_len != 0){
176 /* #Specification: umsdos / readdir
177 umsdos_readdir() should fill a struct dirent with
178 an inode number. The cheap way to get it is to
179 do a lookup in the MSDOS directory for each
180 entry processed by the readdir() function.
181 This is not very efficient, but very simple. The
182 other way around is to maintain a copy of the inode
183 number in the EMD file. This is a problem because
184 this has to be maintained in sync using tricks.
185 Remember that MSDOS (the OS) does not update the
186 modification time (mtime) of a directory. There is
187 no easy way to tell that a directory was modified
188 during a DOS session and synchronise the EMD file.
189
190 Suggestion welcome.
191
192 So the easy way is used!
193 */
194 struct umsdos_info info;
195 struct inode *inode;
196 int lret;
197 umsdos_parse (entry.name,entry.name_len,&info);
198 info.f_pos = cur_f_pos;
199 umsdos_manglename (&info);
200 lret = umsdos_real_lookup (dir,info.fake.fname
201 ,info.fake.len,&inode);
202 PRINTK (("Cherche inode de %s lret %d flags %d\n"
203 ,info.fake.fname,lret,entry.flags));
204 if (lret == 0
205 && (entry.flags & UMSDOS_HLINK)
206 && follow_hlink){
207 struct inode *rinode;
208 lret = umsdos_hlink2inode (inode,&rinode);
209 inode = rinode;
210 }
211 if (lret == 0){
212 /* #Specification: pseudo root / reading real root
213 The pseudo root (/linux) is logically
214 erased from the real root. This mean that
215 ls /DOS, won't show "linux". This avoids
216 infinite recursion /DOS/linux/DOS/linux while
217 walking the file system.
218 */
219 if (inode != pseudo_root
220 && (internal_read
221 || !(entry.flags & UMSDOS_HIDDEN))){
222 if (filldir (dirbuf
223 ,entry.name,entry.name_len
224 ,cur_f_pos, inode->i_ino) < 0){
225 filp->f_pos = cur_f_pos;
226 }
227 PRINTK (("Trouve ino %ld ",inode->i_ino));
228 if (u_entry != NULL) *u_entry = entry;
229 iput (inode);
230 break;
231 }
232 iput (inode);
233 }else{
234 /* #Specification: umsdos / readdir / not in MSDOS
235 During a readdir operation, if the file is not
236 in the MSDOS directory anymore, the entry is
237 removed from the EMD file silently.
238 */
239 ret = umsdos_writeentry (dir,emd_dir,&info,1);
240 if (ret != 0){
241 break;
242 }
243 }
244 }
245 }
246 /*
247 If the fillbuf has failed, f_pos is back to 0.
248 To avoid getting back into the . and .. state
249 (see comments at the beginning), we put back
250 the special offset.
251 */
252 if (filp->f_pos == 0) filp->f_pos = start_fpos;
253 iput(emd_dir);
254 }
255 }
256 umsdos_endlookup(dir);
257 PRINTK (("read dir %p pos %Ld ret %d\n",dir,filp->f_pos,ret));
258 return ret;
259 }
260 /*
261 Read count directory entries from directory filp
262 Return a negative value from linux/errno.h.
263 Return > 0 if success (the amount of byte written to dirent)
264 */
265 static int UMSDOS_readdir(
/* */
266 struct inode *dir, /* Point to a description of the super block */
267 struct file *filp, /* Point to a directory which is read */
268 void *dirbuf, /* Will hold directory entries */
269 filldir_t filldir)
270 {
271 int ret = 0;
272 int count = 0;
273 struct UMSDOS_DIR_ONCE bufk;
274 bufk.dirbuf = dirbuf;
275 bufk.filldir = filldir;
276 bufk.stop = 0;
277 PRINTK (("UMSDOS_readdir in\n"));
278 while (ret == 0 && bufk.stop == 0){
279 struct umsdos_dirent entry;
280 bufk.count = 0;
281 ret = umsdos_readdir_x (dir,filp,&bufk,0,&entry,1,umsdos_dir_once);
282 if (bufk.count == 0) break;
283 count += bufk.count;
284 }
285 PRINTK (("UMSDOS_readdir out %d count %d pos %Ld\n",ret,count
286 ,filp->f_pos));
287 return count == 0 ? -ENOENT : ret;
288 }
289 /*
290 Complete the inode content with info from the EMD file
291 */
292 void umsdos_lookup_patch (
/* */
293 struct inode *dir,
294 struct inode *inode,
295 struct umsdos_dirent *entry,
296 off_t emd_pos)
297 {
298 /*
299 This function modify the state of a dir inode. It decides
300 if the dir is a umsdos dir or a dos dir. This is done
301 deeper in umsdos_patch_inode() called at the end of this function.
302
303 umsdos_patch_inode() may block because it is doing disk access.
304 At the same time, another process may get here to initialise
305 the same dir inode. There is 3 cases.
306
307 1-The inode is already initialised. We do nothing.
308 2-The inode is not initialised. We lock access and do it.
309 3-Like 2 but another process has lock the inode, so we try
310 to lock it and right after check if initialisation is still
311 needed.
312
313
314 Thanks to the mem option of the kernel command line, it was
315 possible to consistently reproduce this problem by limiting
316 my mem to 4 meg and running X.
317 */
318 /*
319 Do this only if the inode is freshly read, because we will lose
320 the current (updated) content.
321 */
322 /*
323 A lookup of a mount point directory yield the inode into
324 the other fs, so we don't care about initialising it. iget()
325 does this automatically.
326 */
327 if (inode->i_sb == dir->i_sb && !umsdos_isinit(inode)){
328 if (S_ISDIR(inode->i_mode)) umsdos_lockcreate(inode);
329 if (!umsdos_isinit(inode)){
330 /* #Specification: umsdos / lookup / inode info
331 After successfully reading an inode from the MSDOS
332 filesystem, we use the EMD file to complete it.
333 We update the following field.
334
335 uid, gid, atime, ctime, mtime, mode.
336
337 We rely on MSDOS for mtime. If the file
338 was modified during an MSDOS session, at least
339 mtime will be meaningful. We do this only for regular
340 file.
341
342 We don't rely on MSDOS for mtime for directory because
343 the MSDOS directory date is creation time (strange
344 MSDOS behavior) which fit nowhere in the three UNIX
345 time stamp.
346 */
347 if (S_ISREG(entry->mode)) entry->mtime = inode->i_mtime;
348 inode->i_mode = entry->mode;
349 inode->i_rdev = to_kdev_t(entry->rdev);
350 inode->i_atime = entry->atime;
351 inode->i_ctime = entry->ctime;
352 inode->i_mtime = entry->mtime;
353 inode->i_uid = entry->uid;
354 inode->i_gid = entry->gid;
355 /* #Specification: umsdos / conversion mode
356 The msdos fs can do some inline conversion
357 of the data of a file. It can translate
358 silently from MsDOS text file format to Unix
359 one (crlf -> lf) while reading, and the reverse
360 while writting. This is activated using the mount
361 option conv=....
362
363 This is not useful for Linux file in promoted
364 directory. It can even be harmful. For this
365 reason, the binary (no conversion) mode is
366 always activated.
367 */
368 /* #Specification: umsdos / conversion mode / todo
369 A flag could be added to file and directories
370 forcing an automatic conversion mode (as
371 done with the msdos fs).
372
373 This flag could be setup on a directory basis
374 (instead of file) and all file in it would
375 logically inherited. If the conversion mode
376 is active (conv=) then the i_binary flag would
377 be left untouched in those directories.
378
379 It was proposed that the sticky bit was used
380 to set this. The problem is that new file would
381 be written incorrectly. The other problem is that
382 the sticky bit has a meaning for directories. So
383 another bit should be used (there is some space
384 in the EMD file for it) and a special utilities
385 would be used to assign the flag to a directory).
386 I don't think it is useful to assign this flag
387 on a single file.
388 */
389
390 MSDOS_I(inode)->i_binary = 1;
391 /* #Specification: umsdos / i_nlink
392 The nlink field of an inode is maintain by the MSDOS file system
393 for directory and by UMSDOS for other file. The logic is that
394 MSDOS is already figuring out what to do for directories and
395 does nothing for other files. For MSDOS, there are no hard link
396 so all file carry nlink==1. UMSDOS use some info in the
397 EMD file to plug the correct value.
398 */
399 if (!S_ISDIR(entry->mode)){
400 if (entry->nlink > 0){
401 inode->i_nlink = entry->nlink;
402 }else{
403 printk ("UMSDOS: lookup_patch entry->nlink < 1 ???\n");
404 }
405 }
406 umsdos_patch_inode(inode,dir,emd_pos);
407 }
408 if (S_ISDIR(inode->i_mode)) umsdos_unlockcreate(inode);
409 if (inode->u.umsdos_i.i_emd_owner==0) printk ("emd_owner still 0 ???\n");
410 }
411 }
412 struct UMSDOS_DIRENT_K{
413 off_t f_pos; /* will hold the offset of the entry in EMD */
414 ino_t ino;
415 };
416
417 /*
418 Just to record the offset of one entry.
419 */
420 static int umsdos_filldir_k(
/* */
421 void * buf,
422 const char * name,
423 int name_len,
424 off_t offset,
425 ino_t ino)
426 {
427 struct UMSDOS_DIRENT_K *d = (struct UMSDOS_DIRENT_K *)buf;
428 d->f_pos = offset;
429 d->ino = ino;
430 return 0;
431 }
432
433 struct UMSDOS_DIR_SEARCH{
434 struct umsdos_dirent *entry;
435 int found;
436 ino_t search_ino;
437 };
438
439 static int umsdos_dir_search (
/* */
440 void * buf,
441 const char * name,
442 int name_len,
443 off_t offset,
444 ino_t ino)
445 {
446 int ret = 0;
447 struct UMSDOS_DIR_SEARCH *d = (struct UMSDOS_DIR_SEARCH *)buf;
448 if (d->search_ino == ino){
449 d->found = 1;
450 memcpy (d->entry->name,name,name_len);
451 d->entry->name[name_len] = '\0';
452 d->entry->name_len = name_len;
453 ret = 1; /* So msdos_readdir will terminate */
454 }
455 return ret;
456 }
457
458
459 /*
460 Locate entry of an inode in a directory.
461 Return 0 or a negative error code.
462
463 Normally, this function must succeed. It means a strange corruption
464 in the file system if not.
465 */
466 int umsdos_inode2entry (
/* */
467 struct inode *dir,
468 struct inode *inode,
469 struct umsdos_dirent *entry) /* Will hold the entry */
470 {
471 int ret = -ENOENT;
472 if (inode == pseudo_root){
473 /*
474 Quick way to find the name.
475 Also umsdos_readdir_x won't show /linux anyway
476 */
477 memcpy (entry->name,UMSDOS_PSDROOT_NAME,UMSDOS_PSDROOT_LEN+1);
478 entry->name_len = UMSDOS_PSDROOT_LEN;
479 ret = 0;
480 }else{
481 struct inode *emddir = umsdos_emd_dir_lookup(dir,0);
482 iput (emddir);
483 if (emddir == NULL){
484 /* This is a DOS directory */
485 struct UMSDOS_DIR_SEARCH bufk;
486 struct file filp;
487 filp.f_reada = 1;
488 filp.f_pos = 0;
489 bufk.entry = entry;
490 bufk.search_ino = inode->i_ino;
491 msdos_readdir (dir,&filp,&bufk,umsdos_dir_search);
492 if (bufk.found){
493 ret = 0;
494 inode->u.umsdos_i.i_dir_owner = dir->i_ino;
495 inode->u.umsdos_i.i_emd_owner = 0;
496 umsdos_setup_dir_inode(inode);
497 }
498 }else{
499 /* skip . and .. see umsdos_readdir_x() */
500 struct file filp;
501 filp.f_reada = 1;
502 filp.f_pos = UMSDOS_SPECIAL_DIRFPOS;
503 while (1){
504 struct UMSDOS_DIRENT_K bufk;
505 if (umsdos_readdir_x(dir,&filp,&bufk
506 ,1,entry,0,umsdos_filldir_k) < 0){
507 printk ("UMSDOS: can't locate inode %ld in EMD file???\n"
508 ,inode->i_ino);
509 break;
510 }else if (bufk.ino == inode->i_ino){
511 ret = 0;
512 umsdos_lookup_patch (dir,inode,entry,bufk.f_pos);
513 break;
514 }
515 }
516 }
517 }
518 return ret;
519 }
520 /*
521 Locate the parent of a directory and the info on that directory
522 Return 0 or a negative error code.
523 */
524 static int umsdos_locate_ancestor (
/* */
525 struct inode *dir,
526 struct inode **result,
527 struct umsdos_dirent *entry)
528 {
529 int ret;
530 umsdos_patch_inode (dir,NULL,0);
531 ret = umsdos_real_lookup (dir,"..",2,result);
532 PRINTK (("result %d %p ",ret,*result));
533 if (ret == 0){
534 struct inode *adir = *result;
535 ret = umsdos_inode2entry (adir,dir,entry);
536 }
537 PRINTK (("\n"));
538 return ret;
539 }
540 /*
541 Build the path name of an inode (relative to the file system.
542 This function is need to set (pseudo) hard link.
543
544 It uses the same strategy as the standard getcwd().
545 */
546 int umsdos_locate_path (
/* */
547 struct inode *inode,
548 char *path)
549 {
550 int ret = 0;
551 struct inode *dir = inode;
552 char *bpath = (char*)kmalloc(PATH_MAX,GFP_KERNEL);
553 if (bpath == NULL){
554 ret = -ENOMEM;
555 }else{
556 struct umsdos_dirent entry;
557 char *ptbpath = bpath+PATH_MAX-1;
558 *ptbpath = '\0';
559 PRINTK (("locate_path mode %x ",inode->i_mode));
560 if (!S_ISDIR(inode->i_mode)){
561 ret = umsdos_get_dirowner (inode,&dir);
562 PRINTK (("locate_path ret %d ",ret));
563 if (ret == 0){
564 ret = umsdos_inode2entry (dir,inode,&entry);
565 if (ret == 0){
566 ptbpath -= entry.name_len;
567 memcpy (ptbpath,entry.name,entry.name_len);
568 PRINTK (("ptbpath :%s: ",ptbpath));
569 }
570 }
571 }else{
572 dir->i_count++;
573 }
574 if (ret == 0){
575 while (dir != dir->i_sb->s_mounted){
576 struct inode *adir;
577 ret = umsdos_locate_ancestor (dir,&adir,&entry);
578 iput (dir);
579 dir = NULL;
580 PRINTK (("ancestor %d ",ret));
581 if (ret == 0){
582 *--ptbpath = '/';
583 ptbpath -= entry.name_len;
584 memcpy (ptbpath,entry.name,entry.name_len);
585 dir = adir;
586 PRINTK (("ptbpath :%s: ",ptbpath));
587 }else{
588 break;
589 }
590 }
591 }
592 strcpy (path,ptbpath);
593 kfree (bpath);
594 }
595 PRINTK (("\n"));
596 iput (dir);
597 return ret;
598 }
599
600 /*
601 Return != 0 if an entry is the pseudo DOS entry in the pseudo root.
602 */
603 int umsdos_is_pseudodos (
/* */
604 struct inode *dir,
605 const char *name,
606 int len)
607 {
608 /* #Specification: pseudo root / DOS hard coded
609 The pseudo sub-directory DOS in the pseudo root is hard coded.
610 The name is DOS. This is done this way to help standardised
611 the umsdos layout. The idea is that from now on /DOS is
612 a reserved path and nobody will think of using such a path
613 for a package.
614 */
615 return dir == pseudo_root
616 && len == 3
617 && name[0] == 'D' && name[1] == 'O' && name[2] == 'S';
618 }
619 /*
620 Check if a file exist in the current directory.
621 Return 0 if ok, negative error code if not (ex: -ENOENT).
622 */
623 static int umsdos_lookup_x (
/* */
624 struct inode *dir,
625 const char *name,
626 int len,
627 struct inode **result, /* Will hold inode of the file, if successful */
628 int nopseudo) /* Don't care about pseudo root mode */
629 {
630 int ret = -ENOENT;
631 *result = NULL;
632 umsdos_startlookup(dir);
633 if (len == 1 && name[0] == '.'){
634 *result = dir;
635 dir->i_count++;
636 ret = 0;
637 }else if (len == 2 && name[0] == '.' && name[1] == '.'){
638 if (pseudo_root != NULL && dir == pseudo_root->i_sb->s_mounted){
639 /* #Specification: pseudo root / .. in real root
640 Whenever a lookup is those in the real root for
641 the directory .., and pseudo root is active, the
642 pseudo root is returned.
643 */
644 ret = 0;
645 *result = pseudo_root;
646 pseudo_root->i_count++;
647 }else{
648 /* #Specification: locating .. / strategy
649 We use the msdos filesystem to locate the parent directory.
650 But it is more complicated than that.
651
652 We have to step back even further to
653 get the parent of the parent, so we can get the EMD
654 of the parent of the parent. Using the EMD file, we can
655 locate all the info on the parent, such a permissions
656 and owner.
657 */
658 ret = umsdos_real_lookup (dir,"..",2,result);
659 PRINTK (("ancestor ret %d dir %p *result %p ",ret,dir,*result));
660 if (ret == 0
661 && *result != dir->i_sb->s_mounted
662 && *result != pseudo_root){
663 struct inode *aadir;
664 struct umsdos_dirent entry;
665 ret = umsdos_locate_ancestor (*result,&aadir,&entry);
666 iput (aadir);
667 }
668 }
669 }else if (umsdos_is_pseudodos(dir,name,len)){
670 /* #Specification: pseudo root / lookup(DOS)
671 A lookup of DOS in the pseudo root will always succeed
672 and return the inode of the real root.
673 */
674 *result = dir->i_sb->s_mounted;
675 (*result)->i_count++;
676 ret = 0;
677 }else{
678 struct umsdos_info info;
679 ret = umsdos_parse (name,len,&info);
680 if (ret == 0) ret = umsdos_findentry (dir,&info,0);
681 PRINTK (("lookup %s pos %lu ret %d len %d ",info.fake.fname,info.f_pos,ret
682 ,info.fake.len));
683 if (ret == 0){
684 /* #Specification: umsdos / lookup
685 A lookup for a file is done in two step. First, we locate
686 the file in the EMD file. If not present, we return
687 an error code (-ENOENT). If it is there, we repeat the
688 operation on the msdos file system. If this fails, it means
689 that the file system is not in sync with the emd file.
690 We silently remove this entry from the emd file,
691 and return ENOENT.
692 */
693 struct inode *inode;
694 ret = umsdos_real_lookup (dir,info.fake.fname,info.fake.len,result);
695 inode = *result;
696 if (inode == NULL){
697 printk ("UMSDOS: Erase entry %s, out of sync with MsDOS\n"
698 ,info.fake.fname);
699 umsdos_delentry (dir,&info,S_ISDIR(info.entry.mode));
700 }else{
701 umsdos_lookup_patch (dir,inode,&info.entry,info.f_pos);
702 PRINTK (("lookup ino %ld flags %d\n",inode->i_ino
703 ,info.entry.flags));
704 if (info.entry.flags & UMSDOS_HLINK){
705 ret = umsdos_hlink2inode (inode,result);
706 }
707 if (*result == pseudo_root && !nopseudo){
708 /* #Specification: pseudo root / dir lookup
709 For the same reason as readdir, a lookup in /DOS for
710 the pseudo root directory (linux) will fail.
711 */
712 /*
713 This has to be allowed for resolving hard link
714 which are recorded independently of the pseudo-root
715 mode.
716 */
717 iput (pseudo_root);
718 *result = NULL;
719 ret = -ENOENT;
720 }
721 }
722 }
723 }
724 umsdos_endlookup(dir);
725 iput (dir);
726 return ret;
727 }
728 /*
729 Check if a file exist in the current directory.
730 Return 0 if ok, negative error code if not (ex: -ENOENT).
731 */
732 int UMSDOS_lookup (
/* */
733 struct inode *dir,
734 const char *name,
735 int len,
736 struct inode **result) /* Will hold inode of the file, if successful */
737 {
738 return umsdos_lookup_x(dir,name,len,result,0);
739 }
740 /*
741 Locate the inode pointed by a (pseudo) hard link
742 Return 0 if ok, a negative error code if not.
743 */
744 int umsdos_hlink2inode (struct inode *hlink, struct inode **result)
/* ![[last]](../icons/n_last.png)
*/
745 {
746 int ret = -EIO;
747 char *path = (char*)kmalloc(PATH_MAX,GFP_KERNEL);
748 *result = NULL;
749 if (path == NULL){
750 ret = -ENOMEM;
751 iput (hlink);
752 }else{
753 struct file filp;
754 filp.f_reada = 1;
755 filp.f_pos = 0;
756 PRINTK (("hlink2inode "));
757 if (umsdos_file_read_kmem (hlink,&filp,path,hlink->i_size)
758 ==hlink->i_size){
759 struct inode *dir;
760 char *pt = path;
761 dir = hlink->i_sb->s_mounted;
762 path[hlink->i_size] = '\0';
763 iput (hlink);
764 dir->i_count++;
765 while (1){
766 char *start = pt;
767 int len;
768 while (*pt != '\0' && *pt != '/') pt++;
769 len = (int)(pt - start);
770 if (*pt == '/') *pt++ = '\0';
771 if (dir->u.umsdos_i.i_emd_dir == 0){
772 /* This is a DOS directory */
773 ret = umsdos_rlookup_x(dir,start,len,result,1);
774 }else{
775 ret = umsdos_lookup_x(dir,start,len,result,1);
776 }
777 PRINTK (("h2n lookup :%s: -> %d ",start,ret));
778 if (ret == 0 && *pt != '\0'){
779 dir = *result;
780 }else{
781 break;
782 }
783 }
784 }else{
785 iput (hlink);
786 }
787 PRINTK (("hlink2inode ret = %d %p -> %p\n",ret,hlink,*result));
788 kfree (path);
789 }
790 return ret;
791 }
792
793 static struct file_operations umsdos_dir_operations = {
794 NULL, /* lseek - default */
795 UMSDOS_dir_read, /* read */
796 NULL, /* write - bad */
797 UMSDOS_readdir, /* readdir */
798 NULL, /* select - default */
799 UMSDOS_ioctl_dir, /* ioctl - default */
800 NULL, /* mmap */
801 NULL, /* no special open code */
802 NULL, /* no special release code */
803 NULL /* fsync */
804 };
805
806 struct inode_operations umsdos_dir_inode_operations = {
807 &umsdos_dir_operations, /* default directory file-ops */
808 UMSDOS_create, /* create */
809 UMSDOS_lookup, /* lookup */
810 UMSDOS_link, /* link */
811 UMSDOS_unlink, /* unlink */
812 UMSDOS_symlink, /* symlink */
813 UMSDOS_mkdir, /* mkdir */
814 UMSDOS_rmdir, /* rmdir */
815 UMSDOS_mknod, /* mknod */
816 UMSDOS_rename, /* rename */
817 NULL, /* readlink */
818 NULL, /* follow_link */
819 NULL, /* bmap */
820 NULL, /* truncate */
821 NULL /* permission */
822 };
823
824
825
826
827
828
829
830
831
832
![[bottom]](../icons/n_bottom.png){kind=icon}
*/