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 / minix / dir.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-23  |  2.7 KB  |  113 lines
  1. /*
  2.  *  linux/fs/minix/dir.c
  3.  *
  4.  *  Copyright (C) 1991, 1992 Linus Torvalds
  5.  *
  6.  *  minix directory handling functions
  7.  */
  8.  
  9. #ifdef MODULE
  10. #include <linux/module.h>
  11. #endif
  12.  
  13. #include <asm/segment.h>
  14.  
  15. #include <linux/errno.h>
  16. #include <linux/fs.h>
  17. #include <linux/minix_fs.h>
  18. #include <linux/stat.h>
  19.  
  20. #define NAME_OFFSET(de) ((int) ((de)->d_name - (char *) (de)))
  21. #define ROUND_UP(x) (((x)+3) & ~3)
  22.  
  23. static int minix_dir_read(struct inode * inode, struct file * filp, char * buf, int count)
  24. {
  25.     return -EISDIR;
  26. }
  27.  
  28. static int minix_readdir(struct inode *, struct file *, struct dirent *, int);
  29.  
  30. static struct file_operations minix_dir_operations = {
  31.     NULL,            /* lseek - default */
  32.     minix_dir_read,        /* read */
  33.     NULL,            /* write - bad */
  34.     minix_readdir,        /* readdir */
  35.     NULL,            /* select - default */
  36.     NULL,            /* ioctl - default */
  37.     NULL,            /* mmap */
  38.     NULL,            /* no special open code */
  39.     NULL,            /* no special release code */
  40.     file_fsync        /* default fsync */
  41. };
  42.  
  43. /*
  44.  * directories can handle most operations...
  45.  */
  46. struct inode_operations minix_dir_inode_operations = {
  47.     &minix_dir_operations,    /* default directory file-ops */
  48.     minix_create,        /* create */
  49.     minix_lookup,        /* lookup */
  50.     minix_link,        /* link */
  51.     minix_unlink,        /* unlink */
  52.     minix_symlink,        /* symlink */
  53.     minix_mkdir,        /* mkdir */
  54.     minix_rmdir,        /* rmdir */
  55.     minix_mknod,        /* mknod */
  56.     minix_rename,        /* rename */
  57.     NULL,            /* readlink */
  58.     NULL,            /* follow_link */
  59.     NULL,            /* bmap */
  60.     minix_truncate,        /* truncate */
  61.     NULL            /* permission */
  62. };
  63.  
  64. static int minix_readdir(struct inode * inode, struct file * filp,
  65.     struct dirent * dirent, int count)
  66. {
  67.     unsigned int offset,i,ret;
  68.     int version;
  69.     char c;
  70.     struct buffer_head * bh;
  71.     struct minix_dir_entry * de;
  72.     struct minix_sb_info * info;
  73.  
  74.     if (!inode || !inode->i_sb || !S_ISDIR(inode->i_mode))
  75.         return -EBADF;
  76.     info = &inode->i_sb->u.minix_sb;
  77.     if (filp->f_pos & (info->s_dirsize - 1))
  78.         return -EBADF;
  79.     ret = 0;
  80.     while (!ret && filp->f_pos < inode->i_size) {
  81.         offset = filp->f_pos & 1023;
  82.         bh = minix_bread(inode,(filp->f_pos)>>BLOCK_SIZE_BITS,0);
  83.         if (!bh) {
  84.             filp->f_pos += 1024-offset;
  85.             continue;
  86.         }
  87.         while (!ret && offset < 1024 && filp->f_pos < inode->i_size) {
  88.             de = (struct minix_dir_entry *) (offset + bh->b_data);
  89.             offset += info->s_dirsize;
  90.             filp->f_pos += info->s_dirsize;
  91. retry:
  92.             if (de->inode) {
  93.                 version = inode->i_version;
  94.                 for (i = 0; i < info->s_namelen; i++)
  95.                     if ((c = de->name[i]) != 0)
  96.                         put_fs_byte(c,i+dirent->d_name);
  97.                     else
  98.                         break;
  99.                 if (i) {
  100.                     put_fs_long(de->inode,&dirent->d_ino);
  101.                     put_fs_byte(0,i+dirent->d_name);
  102.                     put_fs_word(i,&dirent->d_reclen);
  103.                     if (version != inode->i_version)
  104.                         goto retry;
  105.                     ret = ROUND_UP(NAME_OFFSET(dirent)+i+1);
  106.                 }
  107.             }
  108.         }
  109.         brelse(bh);
  110.     }
  111.     return ret;
  112. }
  113.