home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / KERNEL-S / V1.2 / LINUX-1.2 / LINUX-1 / linux / fs / xiafs / dir.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-23  |  3.9 KB  |  140 lines
  1. /*
  2.  *  linux/fs/xiafs/dir.c
  3.  *  
  4.  *  Copyright (C) Q. Frank Xia, 1993.
  5.  *  
  6.  *  Based on Linus' minix/dir.c
  7.  *  Copyright (C) Linus Torvalds, 1991, 1992.
  8.  *
  9.  *  This software may be redistributed per Linux Copyright.
  10.  */
  11.  
  12. #ifdef MODULE
  13. #include <linux/module.h>
  14. #endif
  15.  
  16. #include <asm/segment.h>
  17. #include <linux/sched.h>
  18. #include <linux/errno.h>
  19. #include <linux/kernel.h>
  20. #include <linux/fs.h>
  21. #include <linux/xia_fs.h>
  22. #include <linux/stat.h>
  23.  
  24. #include "xiafs_mac.h"
  25.  
  26. #define NAME_OFFSET(de) ((int) ((de)->d_name - (char *) (de)))
  27. #define ROUND_UP(x) (((x)+3) & ~3)
  28.  
  29. static int xiafs_dir_read(struct inode *, struct file *, char *, int);
  30. static int xiafs_readdir(struct inode *, struct file *, struct dirent *, int);
  31.  
  32. static struct file_operations xiafs_dir_operations = {
  33.     NULL,        /* lseek - default */
  34.     xiafs_dir_read,    /* read */
  35.     NULL,        /* write - bad */
  36.     xiafs_readdir,    /* readdir */
  37.     NULL,        /* select - default */
  38.     NULL,        /* ioctl - default */
  39.     NULL,        /* mmap */
  40.     NULL,        /* no special open code */
  41.     NULL,        /* no special release code */
  42.     file_fsync        /* default fsync */
  43. };
  44.  
  45. /*
  46.  * directories can handle most operations...
  47.  */
  48. struct inode_operations xiafs_dir_inode_operations = {
  49.     &xiafs_dir_operations,    /* default directory file-ops */
  50.     xiafs_create,            /* create */
  51.     xiafs_lookup,            /* lookup */
  52.     xiafs_link,            /* link */
  53.     xiafs_unlink,            /* unlink */
  54.     xiafs_symlink,        /* symlink */
  55.     xiafs_mkdir,            /* mkdir */
  56.     xiafs_rmdir,            /* rmdir */
  57.     xiafs_mknod,            /* mknod */
  58.     xiafs_rename,            /* rename */
  59.     NULL,            /* readlink */
  60.     NULL,            /* follow_link */
  61.     NULL,            /* bmap */
  62.     xiafs_truncate,        /* truncate */
  63.     NULL            /* permission */
  64. };
  65.  
  66. static int xiafs_dir_read(struct inode * inode, 
  67.             struct file * filp, char * buf, int count)
  68. {
  69.   return -EISDIR;
  70. }
  71.  
  72. static int xiafs_readdir(struct inode * inode, 
  73.                struct file * filp, struct dirent * dirent, int count)
  74. {
  75.     u_int offset, i,ret;
  76.     struct buffer_head * bh;
  77.     struct xiafs_direct * de;
  78.  
  79.     if (!inode || !inode->i_sb || !S_ISDIR(inode->i_mode))
  80.         return -EBADF;
  81.     if (inode->i_size & (XIAFS_ZSIZE(inode->i_sb) - 1) )
  82.         return -EBADF;
  83.     ret = 0;
  84.     while (!ret && filp->f_pos < inode->i_size) {
  85.         offset = filp->f_pos & (XIAFS_ZSIZE(inode->i_sb) - 1);
  86.     bh = xiafs_bread(inode, filp->f_pos >> XIAFS_ZSIZE_BITS(inode->i_sb),0);
  87.     if (!bh) {
  88.         filp->f_pos += XIAFS_ZSIZE(inode->i_sb)-offset;
  89.         continue;
  90.     }
  91.     for (i = 0; i < XIAFS_ZSIZE(inode->i_sb) && i < offset; ) {
  92.         de = (struct xiafs_direct *) (bh->b_data + i);
  93.         if (!de->d_rec_len)
  94.         break;
  95.         i += de->d_rec_len;
  96.     }
  97.     offset = i;
  98.     de = (struct xiafs_direct *) (offset + bh->b_data);
  99.     
  100.     while (!ret && offset < XIAFS_ZSIZE(inode->i_sb) && filp->f_pos < inode->i_size) {
  101.         if (de->d_ino > inode->i_sb->u.xiafs_sb.s_ninodes ||
  102.         de->d_rec_len < 12 || 
  103.         (char *)de+de->d_rec_len > XIAFS_ZSIZE(inode->i_sb)+bh->b_data ||
  104.         de->d_name_len < 1 || de->d_name_len + 8 > de->d_rec_len ||
  105.         de->d_name_len > _XIAFS_NAME_LEN ||
  106.         de->d_name[de->d_name_len] ) {
  107.             printk("XIA-FS: bad directory entry (%s %d)\n", WHERE_ERR);
  108.         brelse(bh);
  109.         return 0;
  110.         }  
  111.         offset += de->d_rec_len;
  112.         filp->f_pos += de->d_rec_len;
  113.         if (de->d_ino) {
  114.             for (i = 0; i < de->d_name_len ; i++)
  115.             put_fs_byte(de->d_name[i],i+dirent->d_name);
  116.         put_fs_byte(0,i+dirent->d_name);
  117.         put_fs_long(de->d_ino,&dirent->d_ino);
  118.         put_fs_word(i,&dirent->d_reclen);
  119.         if (!IS_RDONLY (inode)) {
  120.             inode->i_atime=CURRENT_TIME;            
  121.             inode->i_dirt=1;
  122.         }
  123.         ret = ROUND_UP(NAME_OFFSET(dirent)+i+1);
  124.         break;
  125.         }
  126.         de = (struct xiafs_direct *) (offset + bh->b_data);
  127.     }
  128.     brelse(bh);
  129.     if (offset > XIAFS_ZSIZE(inode->i_sb)) {
  130.         printk("XIA-FS: bad directory (%s %d)\n", WHERE_ERR);
  131.         return 0;
  132.     }
  133.     }
  134.     if (!IS_RDONLY (inode)) {
  135.     inode->i_atime=CURRENT_TIME;            
  136.     inode->i_dirt=1;
  137.     }
  138.     return ret;
  139. }
  140.