From c7fc24dc4420057f103afe8fc64524ebc25c5d37 Mon Sep 17 00:00:00 2001 From: Ralf Baechle Date: Tue, 25 Aug 1998 09:12:35 +0000 Subject: o Merge with Linux 2.1.116. o New Newport console code. o New G364 console code. --- fs/umsdos/emd.c | 964 ++++++++++++++++++++++++++------------------------------ 1 file changed, 450 insertions(+), 514 deletions(-) (limited to 'fs/umsdos/emd.c') diff --git a/fs/umsdos/emd.c b/fs/umsdos/emd.c index 6cb630b1c..bf52a4d96 100644 --- a/fs/umsdos/emd.c +++ b/fs/umsdos/emd.c @@ -24,200 +24,118 @@ #define Printk(x) printk x /* - * makes empty filp - * + * Read a file into kernel space memory + * returns how many bytes read (from fat_file_read) */ - -void fill_new_filp (struct file *filp, struct dentry *dentry) -{ - Printk (("/mn/ fill_new_filp: filling empty filp at %p\n", filp)); - if (dentry) - Printk ((" dentry=%.*s\n", (int) dentry->d_name.len, dentry->d_name.name)); - else - Printk ((" dentry is NULL ! you must fill it later...\n")); - - memset (filp, 0, sizeof (struct file)); - - filp->f_pos = 0; - filp->f_reada = 1; - filp->f_flags = O_RDWR; - filp->f_dentry = dentry; - filp->f_op = &umsdos_file_operations; /* /mn/ - we have to fill it with SOMETHING */ -} - -/* - * makes dentry. for name name with length len. /mn/ - * if inode is not NULL, puts it also. - * - */ - -struct dentry *creat_dentry (const char *name, const int len, struct inode *inode, struct dentry *parent) +ssize_t umsdos_file_read_kmem ( struct inode *emd_dir, + struct file *filp, + char *buf, + size_t count, + loff_t *offs) { -/* FIXME /mn/: parent is not passed many times... if it is not, dentry should be destroyed before someone else gets to use it */ - - struct dentry *ret; - struct qstr qname; - - if (inode) - Printk ((KERN_DEBUG "/mn/ creat_dentry: creating dentry with inode=%lu for %.*s\n", inode->i_ino, len, name)); - else - Printk ((KERN_DEBUG "/mn/ creat_dentry: creating empty dentry for %.*s\n", len, name)); - - qname.name = name; - qname.len = len; - qname.hash = 0; - - ret = d_alloc (parent,&qname); /* create new dentry */ - ret->d_inode = NULL; - - if (inode) d_add (ret, inode); - - return ret; -} - + int ret; -/* - * removes temporary dentry created by creat_dentry - * - */ - -void kill_dentry (struct dentry *dentry) -{ - if (dentry) { - Printk (("/mn/ kill_dentry: kill_dentry %.*s :", (int) dentry->d_name.len, dentry->d_name.name)); - if (dentry->d_inode) - Printk (("inode=%lu\n", dentry->d_inode->i_ino)); - else - Printk (("inode is NULL\n")); - - /* FIXME: is this ok ?! /mn/ */ - /* d_invalidate (dentry); */ - /*dput (dentry);*/ - } else { - Printk (("/mn/ kill_dentry: dentry is NULL ?!\n")); - } - - - Printk ((KERN_DEBUG "/mn/ kill_dentry: exiting...\n")); - return; -} + struct dentry *old_dentry; + mm_segment_t old_fs = get_fs (); + set_fs (KERNEL_DS); + old_dentry = filp->f_dentry; /* save it */ + filp->f_dentry = creat_dentry (UMSDOS_EMD_FILE, UMSDOS_EMD_NAMELEN, emd_dir, NULL); + *offs = filp->f_pos; + + PRINTK ((KERN_DEBUG "umsdos_file_read_kmem /mn/: Checkin: filp=%p, buf=%p, size=%d, offs=%p\n", filp, buf, count, offs)); + PRINTK ((KERN_DEBUG " using emd=%ld\n", emd_dir->i_ino)); + PRINTK ((KERN_DEBUG " inode=%lu, i_size=%lu\n", filp->f_dentry->d_inode->i_ino, filp->f_dentry->d_inode->i_size)); + PRINTK ((KERN_DEBUG " ofs=%ld\n", (unsigned long) *offs)); + PRINTK ((KERN_DEBUG " f_pos=%Lu\n", filp->f_pos)); + PRINTK ((KERN_DEBUG " name=%.*s\n", (int) filp->f_dentry->d_name.len, filp->f_dentry->d_name.name)); + PRINTK ((KERN_DEBUG " i_binary(sb)=%d\n", MSDOS_I (filp->f_dentry->d_inode)->i_binary)); + PRINTK ((KERN_DEBUG " f_count=%d, f_flags=%d\n", filp->f_count, filp->f_flags)); + PRINTK ((KERN_DEBUG " f_owner=%d\n", filp->f_owner.uid)); + PRINTK ((KERN_DEBUG " f_version=%ld\n", filp->f_version)); + PRINTK ((KERN_DEBUG " f_reada=%ld, f_ramax=%ld, f_raend=%ld, f_ralen=%ld, f_rawin=%ld\n", filp->f_reada, filp->f_ramax, filp->f_raend, filp->f_ralen, filp->f_rawin)); + + MSDOS_I (filp->f_dentry->d_inode)->i_binary = 2; + ret = fat_file_read (filp, buf, count, offs); + PRINTK ((KERN_DEBUG "fat_file_read returned with %d!\n", ret)); + + filp->f_pos = *offs; /* we needed *filp only for this? grrrr... /mn/ */ + /* FIXME: I have no idea what f_pos is used for. It seems to be used this way before offs was introduced. + * this probably needs fixing /mn/ */ + + d_drop (filp->f_dentry); /* FIXME: hmmmm... we should not dispose of it in this way ? */ + filp->f_dentry = old_dentry; /* restore orig. dentry (it is dentry of file we need info about. Dunno why it gets passed to us + * since we have no use for it, expect to store totally unrelated data of offset of EMD_FILE + * end not directory in it. But what the hell now... fat_file_read requires it also, but prolly expects + * it to be file* of EMD not file we want to read EMD entry about... ugh. complicated to explain :) /mn/ */ + + /* FIXME: we probably need to destroy original filp->f_dentry first ? Do we ? And how ? this way we leave all sorts of dentries, inodes etc. lying around */ + /* Also FIXME: all the same problems in umsdos_file_write_kmem */ + + PRINTK ((KERN_DEBUG " (ret) using emd=%lu\n", emd_dir->i_ino)); + PRINTK ((KERN_DEBUG " (ret) inode=%lu, i_size=%lu\n", filp->f_dentry->d_inode->i_ino, filp->f_dentry->d_inode->i_size)); + PRINTK ((KERN_DEBUG " (ret) ofs=%Lu\n", *offs)); + PRINTK ((KERN_DEBUG " (ret) f_pos=%Lu\n", filp->f_pos)); + PRINTK ((KERN_DEBUG " (ret) name=%.*s\n", (int) filp->f_dentry->d_name.len, filp->f_dentry->d_name.name)); + PRINTK ((KERN_DEBUG " (ret) i_binary(sb)=%d\n", MSDOS_I (filp->f_dentry->d_inode)->i_binary)); + PRINTK ((KERN_DEBUG " (ret) f_count=%d, f_flags=%d\n", filp->f_count, filp->f_flags)); + PRINTK ((KERN_DEBUG " (ret) f_owner=%d\n", filp->f_owner.uid)); + PRINTK ((KERN_DEBUG " (ret) f_version=%ld\n", filp->f_version)); + PRINTK ((KERN_DEBUG " (ret) f_reada=%ld, f_ramax=%ld, f_raend=%ld, f_ralen=%ld, f_rawin=%ld\n", filp->f_reada, filp->f_ramax, filp->f_raend, filp->f_ralen, filp->f_rawin)); -/* - * Read a file into kernel space memory - * returns how many bytes read (from fat_file_read) - */ +#if 0 + { + struct umsdos_dirent *mydirent = buf; -ssize_t umsdos_file_read_kmem (struct inode *emd_dir, - struct file *filp, - char *buf, - size_t count, - loff_t *offs - ) -{ - int ret; - - struct dentry *old_dentry; - mm_segment_t old_fs = get_fs(); - - set_fs (KERNEL_DS); - - old_dentry=filp->f_dentry; /* save it */ - filp->f_dentry = creat_dentry (UMSDOS_EMD_FILE, UMSDOS_EMD_NAMELEN, emd_dir, NULL); - *offs = filp->f_pos; - - PRINTK ((KERN_DEBUG "umsdos_file_read_kmem /mn/: Checkin: filp=%p, buf=%p, size=%d, offs=%p\n", filp, buf, count, offs)); - PRINTK ((KERN_DEBUG " using emd=%ld\n", emd_dir->i_ino)); - PRINTK ((KERN_DEBUG " inode=%lu, i_size=%lu\n", filp->f_dentry->d_inode->i_ino, filp->f_dentry->d_inode->i_size)); - PRINTK ((KERN_DEBUG " ofs=%ld\n",(unsigned long) *offs)); - PRINTK ((KERN_DEBUG " f_pos=%Lu\n", filp->f_pos)); - PRINTK ((KERN_DEBUG " name=%.*s\n", (int) filp->f_dentry->d_name.len, filp->f_dentry->d_name.name)); - PRINTK ((KERN_DEBUG " i_binary(sb)=%d\n", MSDOS_I(filp->f_dentry->d_inode)->i_binary )); - PRINTK ((KERN_DEBUG " f_count=%d, f_flags=%d\n", filp->f_count, filp->f_flags)); - PRINTK ((KERN_DEBUG " f_owner=%d\n", filp->f_owner.uid)); - PRINTK ((KERN_DEBUG " f_version=%ld\n", filp->f_version)); - PRINTK ((KERN_DEBUG " f_reada=%ld, f_ramax=%ld, f_raend=%ld, f_ralen=%ld, f_rawin=%ld\n", filp->f_reada, filp->f_ramax, filp->f_raend, filp->f_ralen, filp->f_rawin)); - - MSDOS_I(filp->f_dentry->d_inode)->i_binary=2; - ret = fat_file_read(filp,buf,count,offs); - PRINTK ((KERN_DEBUG "fat_file_read returned with %d!\n", ret)); - - filp->f_pos = *offs; /* we needed *filp only for this? grrrr... /mn/ */ - /* FIXME: I have no idea what f_pos is used for. It seems to be used this way before offs was introduced. - this probably needs fixing /mn/ */ - - filp->f_dentry=old_dentry; /* restore orig. dentry (it is dentry of file we need info about. Dunno why it gets passed to us - since we have no use for it, expect to store totally unrelated data of offset of EMD_FILE - end not directory in it. But what the hell now... fat_file_read requires it also, but prolly expects - it to be file* of EMD not file we want to read EMD entry about... ugh. complicated to explain :) /mn/ */ - - /* FIXME: we probably need to destroy originl filp->f_dentry first ? Do we ? And how ? this way we leave all sorts of dentries, inodes etc. lying around */ - /* Also FIXME: all the same problems in umsdos_file_write_kmem */ - - PRINTK ((KERN_DEBUG " (ret) using emd=%lu\n", emd_dir->i_ino)); - PRINTK ((KERN_DEBUG " (ret) inode=%lu, i_size=%lu\n", filp->f_dentry->d_inode->i_ino, filp->f_dentry->d_inode->i_size)); - PRINTK ((KERN_DEBUG " (ret) ofs=%Lu\n", *offs)); - PRINTK ((KERN_DEBUG " (ret) f_pos=%Lu\n", filp->f_pos)); - PRINTK ((KERN_DEBUG " (ret) name=%.*s\n", (int) filp->f_dentry->d_name.len, filp->f_dentry->d_name.name)); - PRINTK ((KERN_DEBUG " (ret) i_binary(sb)=%d\n", MSDOS_I(filp->f_dentry->d_inode)->i_binary )); - PRINTK ((KERN_DEBUG " (ret) f_count=%d, f_flags=%d\n", filp->f_count, filp->f_flags)); - PRINTK ((KERN_DEBUG " (ret) f_owner=%d\n", filp->f_owner.uid)); - PRINTK ((KERN_DEBUG " (ret) f_version=%ld\n", filp->f_version)); - PRINTK ((KERN_DEBUG " (ret) f_reada=%ld, f_ramax=%ld, f_raend=%ld, f_ralen=%ld, f_rawin=%ld\n", filp->f_reada, filp->f_ramax, filp->f_raend, filp->f_ralen, filp->f_rawin)); + PRINTK ((KERN_DEBUG " (DDD) uid=%d\n", mydirent->uid)); + PRINTK ((KERN_DEBUG " (DDD) gid=%d\n", mydirent->gid)); + PRINTK ((KERN_DEBUG " (DDD) name=>%.20s<\n", mydirent->name)); + } +#endif -#if 0 - { - struct umsdos_dirent *mydirent=buf; - - PRINTK ((KERN_DEBUG " (DDD) uid=%d\n",mydirent->uid)); - PRINTK ((KERN_DEBUG " (DDD) gid=%d\n",mydirent->gid)); - PRINTK ((KERN_DEBUG " (DDD) name=>%.20s<\n",mydirent->name)); - } -#endif - - set_fs (old_fs); - return ret; + set_fs (old_fs); + return ret; } /* - * Write to file from kernel space. - * Does the real job, assumes all structures are initialized ! + * Write to file from kernel space. + * Does the real job, assumes all structures are initialized ! */ - -ssize_t umsdos_file_write_kmem_real (struct file *filp, - const char *buf, - size_t count, - loff_t *offs) + +ssize_t umsdos_file_write_kmem_real (struct file * filp, + const char *buf, + size_t count, + loff_t * offs) { ssize_t ret; - mm_segment_t old_fs = get_fs(); - + mm_segment_t old_fs = get_fs (); + set_fs (KERNEL_DS); - Printk ((KERN_DEBUG "umsdos_file_write_kmem /mn/: Checkin: filp=%p, buf=%p, size=%d, offs=%p\n", filp, buf, count, offs)); - Printk ((KERN_DEBUG " struct dentry=%p\n", filp->f_dentry)); - Printk ((KERN_DEBUG " struct inode=%p\n", filp->f_dentry->d_inode)); - Printk ((KERN_DEBUG " inode=%lu, i_size=%lu\n", filp->f_dentry->d_inode->i_ino, filp->f_dentry->d_inode->i_size)); - Printk ((KERN_DEBUG " ofs=%ld\n",(unsigned long) *offs)); - Printk ((KERN_DEBUG " f_pos=%Lu\n", filp->f_pos)); - Printk ((KERN_DEBUG " name=%.*s\n", (int) filp->f_dentry->d_name.len, filp->f_dentry->d_name.name)); - Printk ((KERN_DEBUG " i_binary(sb)=%d\n", MSDOS_I(filp->f_dentry->d_inode)->i_binary )); - Printk ((KERN_DEBUG " f_count=%d, f_flags=%d\n", filp->f_count, filp->f_flags)); - Printk ((KERN_DEBUG " f_owner=%d\n", filp->f_owner.uid)); - Printk ((KERN_DEBUG " f_version=%ld\n", filp->f_version)); - Printk ((KERN_DEBUG " f_reada=%ld, f_ramax=%ld, f_raend=%ld, f_ralen=%ld, f_rawin=%ld\n", filp->f_reada, filp->f_ramax, filp->f_raend, filp->f_ralen, filp->f_rawin)); + PRINTK ((KERN_DEBUG "umsdos_file_write_kmem /mn/: Checkin: filp=%p, buf=%p, size=%d, offs=%p\n", filp, buf, count, offs)); + PRINTK ((KERN_DEBUG " struct dentry=%p\n", filp->f_dentry)); + PRINTK ((KERN_DEBUG " struct inode=%p\n", filp->f_dentry->d_inode)); + PRINTK ((KERN_DEBUG " inode=%lu, i_size=%lu\n", filp->f_dentry->d_inode->i_ino, filp->f_dentry->d_inode->i_size)); + PRINTK ((KERN_DEBUG " ofs=%ld\n", (unsigned long) *offs)); + PRINTK ((KERN_DEBUG " f_pos=%Lu\n", filp->f_pos)); + PRINTK ((KERN_DEBUG " name=%.*s\n", (int) filp->f_dentry->d_name.len, filp->f_dentry->d_name.name)); + PRINTK ((KERN_DEBUG " i_binary(sb)=%d\n", MSDOS_I (filp->f_dentry->d_inode)->i_binary)); + PRINTK ((KERN_DEBUG " f_count=%d, f_flags=%d\n", filp->f_count, filp->f_flags)); + PRINTK ((KERN_DEBUG " f_owner=%d\n", filp->f_owner.uid)); + PRINTK ((KERN_DEBUG " f_version=%ld\n", filp->f_version)); + PRINTK ((KERN_DEBUG " f_reada=%ld, f_ramax=%ld, f_raend=%ld, f_ralen=%ld, f_rawin=%ld\n", filp->f_reada, filp->f_ramax, filp->f_raend, filp->f_ralen, filp->f_rawin)); /* note: i_binary=2 is for CVF-FAT. We put it here, instead of - umsdos_file_write_kmem, since it is also wise not to compress symlinks - (in unlikely event that they are > 512 bytes and can be compressed - FIXME: should we set it when reading symlink too ? */ + * umsdos_file_write_kmem, since it is also wise not to compress symlinks + * (in unlikely event that they are > 512 bytes and can be compressed + * FIXME: should we set it when reading symlink too ? */ + + MSDOS_I (filp->f_dentry->d_inode)->i_binary = 2; - MSDOS_I(filp->f_dentry->d_inode)->i_binary=2; - ret = fat_file_write (filp, buf, count, offs); PRINTK ((KERN_DEBUG "fat_file_write returned with %ld!\n", ret)); @@ -227,32 +145,32 @@ ssize_t umsdos_file_write_kmem_real (struct file *filp, /* - * Write to a file from kernel space + * Write to a file from kernel space */ - -ssize_t umsdos_file_write_kmem (struct inode *emd_dir, - struct file *filp, + +ssize_t umsdos_file_write_kmem (struct inode * emd_dir, + struct file * filp, const char *buf, - size_t count, - loff_t *offs - ) + size_t count, + loff_t * offs) { int ret; struct dentry *old_dentry; - + Printk ((KERN_DEBUG " STARTED WRITE_KMEM /mn/\n")); - Printk ((KERN_DEBUG " using emd=%ld\n", emd_dir->i_ino)); + Printk ((KERN_DEBUG " using emd=%ld\n", emd_dir->i_ino)); - old_dentry=filp->f_dentry; /* save it */ + old_dentry = filp->f_dentry; /* save it */ filp->f_dentry = creat_dentry (UMSDOS_EMD_FILE, UMSDOS_EMD_NAMELEN, emd_dir, NULL); *offs = filp->f_pos; /* FIXME, in read_kmem also: offs is not used so why pass it ?!!! /mn/ */ - ret=umsdos_file_write_kmem_real (filp, buf, count, offs); + ret = umsdos_file_write_kmem_real (filp, buf, count, offs); + d_drop (filp->f_dentry); filp->f_pos = *offs; - filp->f_dentry=old_dentry; + filp->f_dentry = old_dentry; return ret; } @@ -261,26 +179,27 @@ ssize_t umsdos_file_write_kmem (struct inode *emd_dir, /* - Write a block of bytes into one EMD file. - The block of data is NOT in user space. - - Return 0 if ok, a negative error code if not. -*/ -ssize_t umsdos_emd_dir_write (struct inode *emd_dir, - struct file *filp, - char *buf, /* buffer in kernel memory, not in user space */ - size_t count, - loff_t *offs - ) + * Write a block of bytes into one EMD file. + * The block of data is NOT in user space. + * + * Return 0 if ok, a negative error code if not. + */ + +ssize_t umsdos_emd_dir_write ( struct inode * emd_dir, + struct file * filp, + char *buf, /* buffer in kernel memory, not in user space */ + size_t count, + loff_t * offs) { int written; - loff_t myofs=0; - + loff_t myofs = 0; + #ifdef __BIG_ENDIAN - struct umsdos_dirent *d = (struct umsdos_dirent *)buf; + struct umsdos_dirent *d = (struct umsdos_dirent *) buf; + #endif filp->f_flags = 0; -#ifdef __BIG_ENDIAN +#ifdef __BIG_ENDIAN d->nlink = cpu_to_le16 (d->nlink); d->uid = cpu_to_le16 (d->uid); d->gid = cpu_to_le16 (d->gid); @@ -289,15 +208,17 @@ ssize_t umsdos_emd_dir_write (struct inode *emd_dir, d->ctime = cpu_to_le32 (d->ctime); d->rdev = cpu_to_le16 (d->rdev); d->mode = cpu_to_le16 (d->mode); -#endif - - if (offs) myofs=*offs; /* if offs is not NULL, read it */ +#endif + + if (offs) + myofs = *offs; /* if offs is not NULL, read it */ Printk (("umsdos_emd_dir_write /mn/: calling write_kmem with %p, %p, %p, %d, %Ld\n", emd_dir, filp, buf, count, myofs)); written = umsdos_file_write_kmem (emd_dir, filp, buf, count, &myofs); Printk (("umsdos_emd_dir_write /mn/: write_kmem returned\n")); - if (offs) *offs=myofs; /* if offs is not NULL, store myofs there */ - -#ifdef __BIG_ENDIAN + if (offs) + *offs = myofs; /* if offs is not NULL, store myofs there */ + +#ifdef __BIG_ENDIAN d->nlink = le16_to_cpu (d->nlink); d->uid = le16_to_cpu (d->uid); d->gid = le16_to_cpu (d->gid); @@ -306,12 +227,12 @@ ssize_t umsdos_emd_dir_write (struct inode *emd_dir, d->ctime = le32_to_cpu (d->ctime); d->rdev = le16_to_cpu (d->rdev); d->mode = le16_to_cpu (d->mode); -#endif - -#ifdef 1 - if (written != count) Printk ((KERN_ERR "umsdos_emd_dir_write: ERROR: written (%d) != count (%d)\n", written, count)); #endif +#if 1 + if (written != count) + Printk ((KERN_ERR "umsdos_emd_dir_write: ERROR: written (%d) != count (%d)\n", written, count)); +#endif return written != count ? -EIO : 0; } @@ -319,36 +240,36 @@ ssize_t umsdos_emd_dir_write (struct inode *emd_dir, /* - * Read a block of bytes from one EMD file. - * The block of data is NOT in user space. - * Return 0 if ok, -EIO if any error. + * Read a block of bytes from one EMD file. + * The block of data is NOT in user space. + * Return 0 if ok, -EIO if any error. */ - -ssize_t umsdos_emd_dir_read (struct inode *emd_dir, - struct file *filp, - char *buf, /* buffer in kernel memory, not in user space */ - size_t count, - loff_t *offs - ) + +ssize_t umsdos_emd_dir_read (struct inode * emd_dir, + struct file * filp, + char *buf, /* buffer in kernel memory, not in user space */ + size_t count, + loff_t * offs) { - loff_t myofs=0; + loff_t myofs = 0; long int ret = 0; int sizeread; - - + + #ifdef __BIG_ENDIAN - struct umsdos_dirent *d = (struct umsdos_dirent *)buf; + struct umsdos_dirent *d = (struct umsdos_dirent *) buf; + #endif - if (offs) myofs=*offs; /* if offs is not NULL, read it */ + if (offs) + myofs = *offs; /* if offs is not NULL, read it */ filp->f_flags = 0; sizeread = umsdos_file_read_kmem (emd_dir, filp, buf, count, &myofs); - if (sizeread != count){ - printk ("UMSDOS: problem with EMD file. Can't read pos = %Ld (%d != %d)\n" - ,filp->f_pos,sizeread,count); + if (sizeread != count) { + printk ("UMSDOS: problem with EMD file. Can't read pos = %Ld (%d != %d)\n", filp->f_pos, sizeread, count); ret = -EIO; } -#ifdef __BIG_ENDIAN +#ifdef __BIG_ENDIAN d->nlink = le16_to_cpu (d->nlink); d->uid = le16_to_cpu (d->uid); d->gid = le16_to_cpu (d->gid); @@ -357,8 +278,9 @@ ssize_t umsdos_emd_dir_read (struct inode *emd_dir, d->ctime = le32_to_cpu (d->ctime); d->rdev = le16_to_cpu (d->rdev); d->mode = le16_to_cpu (d->mode); -#endif - if (offs) *offs=myofs; /* if offs is not NULL, store myofs there */ +#endif + if (offs) + *offs = myofs; /* if offs is not NULL, store myofs there */ return ret; } @@ -367,92 +289,95 @@ ssize_t umsdos_emd_dir_read (struct inode *emd_dir, /* - Locate the EMD file in a directory . + * Locate the EMD file in a directory . + * + * Return NULL if error. If ok, dir->u.umsdos_i.emd_inode + */ - Return NULL if error. If ok, dir->u.umsdos_i.emd_inode -*/ struct inode *umsdos_emd_dir_lookup (struct inode *dir, int creat) { - struct inode *ret = NULL; - int res; - PRINTK ((KERN_DEBUG "Entering umsdos_emd_dir_lookup\n")); - if (dir->u.umsdos_i.i_emd_dir != 0){ - ret = iget (dir->i_sb,dir->u.umsdos_i.i_emd_dir); - Printk (("umsdos_emd_dir_lookup: deja trouve %ld %p\n" - ,dir->u.umsdos_i.i_emd_dir,ret)); - } else { - PRINTK ((KERN_DEBUG "umsdos /mn/: Looking for %.*s -", UMSDOS_EMD_NAMELEN, UMSDOS_EMD_FILE)); - res = compat_umsdos_real_lookup (dir, UMSDOS_EMD_FILE, UMSDOS_EMD_NAMELEN, &ret); - PRINTK ((KERN_DEBUG "-returned %d\n", res)); - Printk ((KERN_INFO "emd_dir_lookup ")); - if (ret != NULL){ - Printk (("Found --linux ")); - dir->u.umsdos_i.i_emd_dir = ret->i_ino; - } else if (creat) { - int code; - Printk ((" * ERROR * /mn/: creat not yet implemented!!!!" )); - Printk ((KERN_DEBUG "avant create ")); - dir->i_count++; - - code = compat_msdos_create (dir,UMSDOS_EMD_FILE,UMSDOS_EMD_NAMELEN - ,S_IFREG|0777,&ret); - Printk ((KERN_WARNING "Creat EMD code %d ret %p ", code, ret)); - if (ret != NULL){ - dir->u.umsdos_i.i_emd_dir = ret->i_ino; - }else{ - printk (KERN_WARNING "UMSDOS: Can't create EMD file\n"); - } - } - - if (ret != NULL){ - /* Disable UMSDOS_notify_change() for EMD file */ - ret->u.umsdos_i.i_emd_owner = 0xffffffff; + struct inode *ret = NULL; + int res; + + Printk ((KERN_DEBUG "Entering umsdos_emd_dir_lookup\n")); + if (dir->u.umsdos_i.i_emd_dir != 0) { + ret = iget (dir->i_sb, dir->u.umsdos_i.i_emd_dir); + Printk (("umsdos_emd_dir_lookup: deja trouve %ld %p\n" + ,dir->u.umsdos_i.i_emd_dir, ret)); + } else { + PRINTK ((KERN_DEBUG "umsdos /mn/: Looking for %.*s -", UMSDOS_EMD_NAMELEN, UMSDOS_EMD_FILE)); + res = compat_umsdos_real_lookup (dir, UMSDOS_EMD_FILE, UMSDOS_EMD_NAMELEN, &ret); + PRINTK ((KERN_DEBUG "-returned %d\n", res)); + Printk ((KERN_INFO "emd_dir_lookup ")); + if (ret != NULL) { + Printk (("Found --linux ")); + dir->u.umsdos_i.i_emd_dir = ret->i_ino; + } else if (creat) { + int code; + + Printk ((" * ERROR * /mn/: creat not yet implemented? not fixed? ")); + Printk (("avant create ")); + inc_count (dir); + + check_inode (ret); + code = compat_msdos_create (dir, UMSDOS_EMD_FILE, UMSDOS_EMD_NAMELEN, S_IFREG | 0777, &ret); + check_inode (ret); + Printk (("Creat EMD code %d ret %p ", code, ret)); + if (ret != NULL) { + Printk ((" ino=%lu", ret->i_ino)); + dir->u.umsdos_i.i_emd_dir = ret->i_ino; + } else { + printk (KERN_WARNING "UMSDOS: Can't create EMD file\n"); + } + } + if (ret != NULL) { + /* Disable UMSDOS_notify_change() for EMD file */ + ret->u.umsdos_i.i_emd_owner = 0xffffffff; + } + } - } - -#if 0 - PRINTK ((KERN_DEBUG "umsdos_emd_dir_lookup returning %p /mn/\n", ret)); - if (ret != NULL) PRINTK ((KERN_DEBUG " debug : returning ino=%lu\n", ret->i_ino)); -#endif - return ret; +#if 1 + Printk ((KERN_DEBUG "umsdos_emd_dir_lookup returning %p /mn/\n", ret)); + if (ret != NULL) + Printk ((KERN_DEBUG " returning ino=%lu\n", ret->i_ino)); +#endif + return ret; } -/* - creates an EMD file - Return NULL if error. If ok, dir->u.umsdos_i.emd_inode -*/ -struct inode *umsdos_emd_dir_create(struct inode *dir, struct dentry *dentry,int mode) +/* + * creates an EMD file + * + * Return NULL if error. If ok, dir->u.umsdos_i.emd_inode + */ + +struct inode *umsdos_emd_dir_create (struct inode *dir, struct dentry *dentry, int mode) { struct inode *ret = NULL; - if (dir->u.umsdos_i.i_emd_dir != 0){ - ret = iget (dir->i_sb,dir->u.umsdos_i.i_emd_dir); + + if (dir->u.umsdos_i.i_emd_dir != 0) { + ret = iget (dir->i_sb, dir->u.umsdos_i.i_emd_dir); Printk (("deja trouve %lu %p", dir->u.umsdos_i.i_emd_dir, ret)); - }else{ - - int code; - Printk (("avant create ")); - dir->i_count++; - /* - code = msdos_create (dir,UMSDOS_EMD_FILE,UMSDOS_EMD_NAMELEN - ,S_IFREG|0777,&ret); - - FIXME, I think I need a new dentry here - */ - code = compat_msdos_create (dir,UMSDOS_EMD_FILE,UMSDOS_EMD_NAMELEN, S_IFREG|0777, &ret); - Printk (("Creat EMD code %d ret %p ", code, ret)); - if (ret != NULL){ - dir->u.umsdos_i.i_emd_dir = ret->i_ino; - }else{ - printk ("UMSDOS: Can't create EMD file\n"); - } + } else { + + int code; + + Printk (("avant create ")); + inc_count (dir); + code = compat_msdos_create (dir, UMSDOS_EMD_FILE, UMSDOS_EMD_NAMELEN, S_IFREG | 0777, &ret); + Printk (("Creat EMD code %d ret %p ", code, ret)); + if (ret != NULL) { + dir->u.umsdos_i.i_emd_dir = ret->i_ino; + } else { + printk ("UMSDOS: Can't create EMD file\n"); + } } - if (ret != NULL){ - /* Disable UMSDOS_notify_change() for EMD file */ - ret->u.umsdos_i.i_emd_owner = 0xffffffff; + if (ret != NULL) { + /* Disable UMSDOS_notify_change() for EMD file */ + ret->u.umsdos_i.i_emd_owner = 0xffffffff; } return ret; } @@ -460,28 +385,29 @@ struct inode *umsdos_emd_dir_create(struct inode *dir, struct dentry *dentry,int /* - Read an entry from the EMD file. - Support variable length record. - Return -EIO if error, 0 if ok. -*/ + * Read an entry from the EMD file. + * Support variable length record. + * Return -EIO if error, 0 if ok. + */ + int umsdos_emd_dir_readentry ( - struct inode *emd_dir, - struct file *filp, - struct umsdos_dirent *entry) + struct inode *emd_dir, + struct file *filp, + struct umsdos_dirent *entry) { int ret; + Printk ((KERN_DEBUG "umsdos_emd_dir_readentry /mn/: entering.\n")); Printk (("umsdos_emd_dir_readentry /mn/: trying to lookup %.*s (ino=%lu) using EMD %lu\n", (int) filp->f_dentry->d_name.len, filp->f_dentry->d_name.name, filp->f_dentry->d_inode->i_ino, emd_dir->i_ino)); - - ret = umsdos_emd_dir_read(emd_dir, filp, (char*)entry, UMSDOS_REC_SIZE, NULL); - if (ret == 0){ /* note /mn/: is this wrong? ret is allways 0 or -EIO. but who knows. It used to work this way... */ + + ret = umsdos_emd_dir_read (emd_dir, filp, (char *) entry, UMSDOS_REC_SIZE, NULL); + if (ret == 0) { /* note /mn/: is this wrong? ret is always 0 or -EIO. but who knows. It used to work this way... */ /* Variable size record. Maybe, we have to read some more */ int recsize = umsdos_evalrecsize (entry->name_len); - Printk ((KERN_DEBUG "umsdos_emd_dir_readentry /mn/: FIXME if %d > %d?\n",recsize, UMSDOS_REC_SIZE)); - if (recsize > UMSDOS_REC_SIZE){ - ret = umsdos_emd_dir_read(emd_dir, filp - ,((char*)entry)+UMSDOS_REC_SIZE,recsize - UMSDOS_REC_SIZE,NULL); - + + Printk ((KERN_DEBUG "umsdos_emd_dir_readentry /mn/: FIXME if %d > %d?\n", recsize, UMSDOS_REC_SIZE)); + if (recsize > UMSDOS_REC_SIZE) { + ret = umsdos_emd_dir_read (emd_dir, filp, ((char *) entry) + UMSDOS_REC_SIZE, recsize - UMSDOS_REC_SIZE, NULL); } } Printk (("umsdos_emd_dir_readentry /mn/: returning %d.\n", ret)); @@ -492,61 +418,62 @@ int umsdos_emd_dir_readentry ( /* - Write an entry in the EMD file. - Return 0 if ok, -EIO if some error. -*/ + * Write an entry in the EMD file. + * Return 0 if ok, -EIO if some error. + */ + int umsdos_writeentry ( - struct inode *dir, - struct inode *emd_dir, - struct umsdos_info *info, - int free_entry) /* This entry is deleted, so Write all 0's */ -{ + struct inode *dir, + struct inode *emd_dir, + struct umsdos_info *info, + int free_entry) + +{ /* This entry is deleted, so Write all 0's */ int ret = 0; struct dentry *emd_dentry; struct file filp; struct umsdos_dirent *entry = &info->entry; struct umsdos_dirent entry0; - fill_new_filp (&filp, NULL); + fill_new_filp (&filp, NULL); Printk (("umsdos_writeentry /mn/: entering...\n")); - emd_dentry=creat_dentry ("wremd_mn", 8, emd_dir, NULL); - - if (free_entry){ + emd_dentry = creat_dentry ("wremd_mn", 8, emd_dir, NULL); + + if (free_entry) { /* #Specification: EMD file / empty entries - Unused entry in the EMD file are identify - by the name_len field equal to 0. However to - help future extension (or bug correction :-( ), - empty entries are filled with 0. - */ - memset (&entry0,0,sizeof(entry0)); + * Unused entry in the EMD file are identify + * by the name_len field equal to 0. However to + * help future extension (or bug correction :-( ), + * empty entries are filled with 0. + */ + memset (&entry0, 0, sizeof (entry0)); entry = &entry0; - }else if (entry->name_len > 0){ - memset (entry->name+entry->name_len,'\0' - ,sizeof(entry->name)-entry->name_len); + } else if (entry->name_len > 0) { + memset (entry->name + entry->name_len, '\0', sizeof (entry->name) - entry->name_len); /* #Specification: EMD file / spare bytes - 10 bytes are unused in each record of the EMD. They - are set to 0 all the time. So it will be possible - to do new stuff and rely on the state of those - bytes in old EMD file around. - */ - memset (entry->spare,0,sizeof(entry->spare)); + * 10 bytes are unused in each record of the EMD. They + * are set to 0 all the time. So it will be possible + * to do new stuff and rely on the state of those + * bytes in old EMD file around. + */ + memset (entry->spare, 0, sizeof (entry->spare)); } - Printk (("umsdos_writeentry /mn/: if passed...\n")); - if (!info) printk (KERN_ERR "umsdosfs: /mn/ info is empty ! ooops...\n"); + if (!info) + printk (KERN_ERR "umsdosfs: /mn/ info is empty ! ooops...\n"); filp.f_pos = info->f_pos; filp.f_reada = 0; filp.f_flags = O_RDWR; filp.f_dentry = emd_dentry; - filp.f_op = &umsdos_file_operations; /* /mn/ - we have to fill it with dummy values so we won't segfault */ - - ret = umsdos_emd_dir_write (emd_dir, &filp, (char*)entry, info->recsize, NULL); + filp.f_op = &umsdos_file_operations; /* /mn/ - we have to fill it with dummy values so we won't segfault */ + + ret = umsdos_emd_dir_write (emd_dir, &filp, (char *) entry, info->recsize, NULL); Printk (("emd_dir_write returned with %d!\n", ret)); - if (ret != 0){ + if (ret != 0) { printk ("UMSDOS: problem with EMD file. Can't write\n"); - }else{ + } else { dir->i_ctime = dir->i_mtime = CURRENT_TIME; /* dir->i_dirt = 1; FIXME iput/dput ??? */ } @@ -558,10 +485,10 @@ int umsdos_writeentry ( #define CHUNK_SIZE (8*UMSDOS_REC_SIZE) -struct find_buffer{ +struct find_buffer { char buffer[CHUNK_SIZE]; - int pos; /* read offset in buffer */ - int size; /* Current size of buffer */ + int pos; /* read offset in buffer */ + int size; /* Current size of buffer */ struct file filp; }; @@ -570,34 +497,36 @@ struct find_buffer{ /* - Fill the read buffer and take care of the byte remaining inside. - Unread bytes are simply move to the beginning. + * Fill the read buffer and take care of the byte remaining inside. + * Unread bytes are simply move to the beginning. + * + * Return -ENOENT if EOF, 0 if ok, a negative error code if any problem. + */ - Return -ENOENT if EOF, 0 if ok, a negative error code if any problem. -*/ static int umsdos_fillbuf ( - struct inode *inode, - struct find_buffer *buf) + struct inode *inode, + struct find_buffer *buf) { int ret = -ENOENT; int mustmove = buf->size - buf->pos; int mustread; int remain; - + PRINTK ((KERN_DEBUG "Entering umsdos_fillbuf, for inode %lu, buf=%p\n", inode->i_ino, buf)); - - if (mustmove > 0){ - memcpy (buf->buffer,buf->buffer+buf->pos,mustmove); + + if (mustmove > 0) { + memcpy (buf->buffer, buf->buffer + buf->pos, mustmove); } buf->pos = 0; mustread = CHUNK_SIZE - mustmove; remain = inode->i_size - buf->filp.f_pos; - if (remain < mustread) mustread = remain; - if (mustread > 0){ - ret = umsdos_emd_dir_read (inode, &buf->filp,buf->buffer+mustmove - ,mustread,NULL); - if (ret == 0) buf->size = mustmove + mustread; - }else if (mustmove){ + if (remain < mustread) + mustread = remain; + if (mustread > 0) { + ret = umsdos_emd_dir_read (inode, &buf->filp, buf->buffer + mustmove, mustread, NULL); + if (ret == 0) + buf->size = mustmove + mustread; + } else if (mustmove) { buf->size = mustmove; ret = 0; } @@ -607,61 +536,61 @@ static int umsdos_fillbuf ( /* - General search, locate a name in the EMD file or an empty slot to - store it. if info->entry.name_len == 0, search the first empty - slot (of the proper size). - - Caller must do iput on *pt_emd_dir. - - Return 0 if found, -ENOENT if not found, another error code if - other problem. - - So this routine is used to either find an existing entry or to - create a new one, while making sure it is a new one. After you - get -ENOENT, you make sure the entry is stuffed correctly and - call umsdos_writeentry(). - - To delete an entry, you find it, zero out the entry (memset) - and call umsdos_writeentry(). + * General search, locate a name in the EMD file or an empty slot to + * store it. if info->entry.name_len == 0, search the first empty + * slot (of the proper size). + * + * Caller must do iput on *pt_emd_dir. + * + * Return 0 if found, -ENOENT if not found, another error code if + * other problem. + * + * So this routine is used to either find an existing entry or to + * create a new one, while making sure it is a new one. After you + * get -ENOENT, you make sure the entry is stuffed correctly and + * call umsdos_writeentry(). + * + * To delete an entry, you find it, zero out the entry (memset) + * and call umsdos_writeentry(). + * + * All this to say that umsdos_writeentry must be call after this + * function since it rely on the f_pos field of info. + */ - All this to say that umsdos_writeentry must be call after this - function since it rely on the f_pos field of info. -*/ static int umsdos_find ( - struct inode *dir, - struct umsdos_info *info, /* Hold name and name_len */ - /* Will hold the entry found */ - struct inode **pt_emd_dir) /* Will hold the emd_dir inode */ - /* or NULL if not found */ + struct inode *dir, + struct umsdos_info *info, /* Hold name and name_len */ + /* Will hold the entry found */ + struct inode **pt_emd_dir) /* Will hold the emd_dir inode or NULL if not found */ + { /* #Specification: EMD file structure - The EMD file uses a fairly simple layout. It is made of records - (UMSDOS_REC_SIZE == 64). When a name can't be written is a single - record, multiple contiguous record are allocated. - */ + * The EMD file uses a fairly simple layout. It is made of records + * (UMSDOS_REC_SIZE == 64). When a name can't be written is a single + * record, multiple contiguous record are allocated. + */ int ret = -ENOENT; struct inode *emd_dir; struct umsdos_dirent *entry = &info->entry; - + Printk (("umsdos_find: locating %.*s in dir %lu\n", entry->name_len, entry->name, dir->i_ino)); - + emd_dir = umsdos_emd_dir_lookup (dir, 1); - if (emd_dir != NULL){ + if (emd_dir != NULL) { int recsize = info->recsize; struct { off_t posok; /* Position available to store the entry */ - int found; /* A valid empty position has been found */ - off_t one; /* One empty position -> maybe <- large enough */ + int found; /* A valid empty position has been found */ + off_t one; /* One empty position -> maybe <- large enough */ int onesize; /* size of empty region starting at one */ - }empty; + } empty; + /* Read several entries at a time to speed up the search */ struct find_buffer buf; struct dentry *dentry; - memset (&buf.filp, 0, sizeof (buf.filp)); - dentry = creat_dentry ("umsfind-mn", 10, emd_dir, NULL); - + fill_new_filp (&buf.filp, dentry); buf.pos = 0; @@ -670,218 +599,225 @@ static int umsdos_find ( empty.found = 0; empty.posok = emd_dir->i_size; empty.onesize = 0; - while (1){ - struct umsdos_dirent *rentry = (struct umsdos_dirent*) - (buf.buffer + buf.pos); + while (1) { + struct umsdos_dirent *rentry = (struct umsdos_dirent *) + (buf.buffer + buf.pos); int file_pos = buf.filp.f_pos - buf.size + buf.pos; - if (buf.pos == buf.size){ - ret = umsdos_fillbuf (emd_dir,&buf); - if (ret < 0){ + + if (buf.pos == buf.size) { + ret = umsdos_fillbuf (emd_dir, &buf); + if (ret < 0) { /* Not found, so note where it can be added */ info->f_pos = empty.posok; break; } - }else if (rentry->name_len == 0){ + } else if (rentry->name_len == 0) { /* We are looking for an empty section at least */ /* recsize large */ - if (entry->name_len == 0){ + if (entry->name_len == 0) { info->f_pos = file_pos; ret = 0; break; - }else if (!empty.found){ - if (empty.onesize == 0){ + } else if (!empty.found) { + if (empty.onesize == 0) { /* This is the first empty record of a section */ empty.one = file_pos; } /* grow the empty section */ empty.onesize += UMSDOS_REC_SIZE; - if (empty.onesize == recsize){ + if (empty.onesize == recsize) { /* here is a large enough section */ empty.posok = empty.one; empty.found = 1; } } buf.pos += UMSDOS_REC_SIZE; - }else{ - int entry_size = umsdos_evalrecsize(rentry->name_len); - if (buf.pos+entry_size > buf.size){ - ret = umsdos_fillbuf (emd_dir,&buf); - if (ret < 0){ + } else { + int entry_size = umsdos_evalrecsize (rentry->name_len); + + if (buf.pos + entry_size > buf.size) { + ret = umsdos_fillbuf (emd_dir, &buf); + if (ret < 0) { /* Not found, so note where it can be added */ info->f_pos = empty.posok; break; } - }else{ + } else { empty.onesize = 0; /* Reset the free slot search */ if (entry->name_len == rentry->name_len - && memcmp(entry->name,rentry->name,rentry->name_len) - ==0){ + && memcmp (entry->name, rentry->name, rentry->name_len) + == 0) { info->f_pos = file_pos; *entry = *rentry; ret = 0; break; - }else{ + } else { buf.pos += entry_size; } } - } + } } - umsdos_manglename(info); + umsdos_manglename (info); } *pt_emd_dir = emd_dir; - + Printk (("umsdos_find: returning %d\n", ret)); return ret; } + /* - Add a new entry in the emd file - Return 0 if ok or a negative error code. - Return -EEXIST if the entry already exist. + * Add a new entry in the emd file + * Return 0 if ok or a negative error code. + * Return -EEXIST if the entry already exist. + * + * Complete the information missing in info. + */ - Complete the information missing in info. -*/ int umsdos_newentry ( - struct inode *dir, - struct umsdos_info *info) + struct inode *dir, + struct umsdos_info *info) { struct inode *emd_dir; - int ret = umsdos_find (dir,info,&emd_dir); - if (ret == 0){ + int ret = umsdos_find (dir, info, &emd_dir); + + if (ret == 0) { ret = -EEXIST; - }else if (ret == -ENOENT){ - ret = umsdos_writeentry(dir,emd_dir,info,0); - Printk (("umsdos_newentry EMD ret = %d\n",ret)); + } else if (ret == -ENOENT) { + ret = umsdos_writeentry (dir, emd_dir, info, 0); + Printk (("umsdos_writeentry EMD ret = %d\n", ret)); } - /* iput (emd_dir); FIXME */ + iput (emd_dir); /* FIXME? */ return ret; } + /* - Create a new hidden link. - Return 0 if ok, an error code if not. -*/ + * Create a new hidden link. + * Return 0 if ok, an error code if not. + */ + int umsdos_newhidden ( - struct inode *dir, - struct umsdos_info *info) + struct inode *dir, + struct umsdos_info *info) { struct inode *emd_dir; int ret; - umsdos_parse ("..LINK",6,info); + + umsdos_parse ("..LINK", 6, info); info->entry.name_len = 0; - ret = umsdos_find (dir,info,&emd_dir); - /* iput (emd_dir); FIXME */ - if (ret == -ENOENT || ret == 0){ + ret = umsdos_find (dir, info, &emd_dir); + iput (emd_dir); /* FIXME? */ + if (ret == -ENOENT || ret == 0) { /* #Specification: hard link / hidden name - When a hard link is created, the original file is renamed - to a hidden name. The name is "..LINKNNN" where NNN is a - number define from the entry offset in the EMD file. - */ - info->entry.name_len = sprintf (info->entry.name,"..LINK%ld" - ,info->f_pos); + * When a hard link is created, the original file is renamed + * to a hidden name. The name is "..LINKNNN" where NNN is a + * number define from the entry offset in the EMD file. + */ + info->entry.name_len = sprintf (info->entry.name, "..LINK%ld" + ,info->f_pos); ret = 0; } return ret; } /* - Remove an entry from the emd file - Return 0 if ok, a negative error code otherwise. + * Remove an entry from the emd file + * Return 0 if ok, a negative error code otherwise. + * + * Complete the information missing in info. + */ - Complete the information missing in info. -*/ int umsdos_delentry ( - struct inode *dir, - struct umsdos_info *info, - int isdir) + struct inode *dir, + struct umsdos_info *info, + int isdir) { struct inode *emd_dir; - int ret = umsdos_find (dir,info,&emd_dir); - if (ret == 0){ - if (info->entry.name_len != 0){ - if ((isdir != 0) != (S_ISDIR(info->entry.mode) != 0)){ - if (S_ISDIR(info->entry.mode)){ + int ret = umsdos_find (dir, info, &emd_dir); + + if (ret == 0) { + if (info->entry.name_len != 0) { + if ((isdir != 0) != (S_ISDIR (info->entry.mode) != 0)) { + if (S_ISDIR (info->entry.mode)) { ret = -EISDIR; - }else{ + } else { ret = -ENOTDIR; } - }else{ - ret = umsdos_writeentry(dir,emd_dir,info,1); + } else { + ret = umsdos_writeentry (dir, emd_dir, info, 1); } } } - /* iput(emd_dir); FIXME */ + iput(emd_dir); /* FIXME? */ return ret; } /* - Verify is a EMD directory is empty. - Return 0 if not empty - 1 if empty - 2 if empty, no EMD file. -*/ + * Verify is a EMD directory is empty. + * Return 0 if not empty + * 1 if empty + * 2 if empty, no EMD file. + */ + int umsdos_isempty (struct inode *dir) { struct dentry *dentry; - + int ret = 2; - struct inode *emd_dir = umsdos_emd_dir_lookup(dir,0); + struct inode *emd_dir = umsdos_emd_dir_lookup (dir, 0); + /* If the EMD file does not exist, it is certainly empty :-) */ - if (emd_dir != NULL){ + if (emd_dir != NULL) { struct file filp; - fill_new_filp (&filp, NULL); - - /* Find an empty slot */ - memset (&filp, 0, sizeof (filp)); dentry = creat_dentry ("isempty-mn", 10, dir, NULL); - - filp.f_pos = 0; - filp.f_reada = 1; + fill_new_filp (&filp, dentry); filp.f_flags = O_RDONLY; - filp.f_dentry = dentry; - filp.f_op = &umsdos_file_operations; /* /mn/ - we have to fill it with dummy values so we won't segfault */ - + ret = 1; - while (filp.f_pos < emd_dir->i_size){ + while (filp.f_pos < emd_dir->i_size) { struct umsdos_dirent entry; - if (umsdos_emd_dir_readentry(emd_dir,&filp,&entry)!=0){ + + if (umsdos_emd_dir_readentry (emd_dir, &filp, &entry) != 0) { ret = 0; break; - }else if (entry.name_len != 0){ + } else if (entry.name_len != 0) { ret = 0; break; - } + } } - /* iput (emd_dir); FIXME */ + iput (emd_dir); /* FIXME? */ } return ret; } /* - Locate an entry in a EMD directory. - Return 0 if ok, errcod if not, generally -ENOENT. -*/ + * Locate an entry in a EMD directory. + * Return 0 if ok, errcod if not, generally -ENOENT. + */ + int umsdos_findentry ( - struct inode *dir, - struct umsdos_info *info, - int expect) /* 0: anything */ - /* 1: file */ - /* 2: directory */ -{ + struct inode *dir, + struct umsdos_info *info, + int expect) +{ /* 0: anything */ + /* 1: file */ + /* 2: directory */ struct inode *emd_dir; - int ret = umsdos_find (dir,info,&emd_dir); - if (ret == 0){ - if (expect != 0){ - if (S_ISDIR(info->entry.mode)){ - if (expect != 2) ret = -EISDIR; - }else if (expect == 2){ + int ret = umsdos_find (dir, info, &emd_dir); + + if (ret == 0) { + if (expect != 0) { + if (S_ISDIR (info->entry.mode)) { + if (expect != 2) + ret = -EISDIR; + } else if (expect == 2) { ret = -ENOTDIR; } } } - /* iput (emd_dir); FIXME */ + iput (emd_dir); /* FIXME? */ Printk (("umsdos_findentry: returning %d\n", ret)); return ret; } - -- cgit v1.2.3