Return to dir.c CVS log

Up to [Early Linux] / linux / fs / minix

Annotation of linux/fs/minix/dir.c, revision 1.1.1.2

1.1       root        1: /*
1.1.1.2 ! root        2:  *  linux/fs/minix/dir.c
1.1       root        3:  *
1.1.1.2 ! root        4:  *  (C) 1991 Linus Torvalds
        !             5:  *
        !             6:  *  minix directory handling functions
1.1       root        7:  */
                      8: 
                      9: #include <errno.h>
                     10: 
                     11: #include <asm/segment.h>
                     12: 
                     13: #include <linux/fs.h>
                     14: #include <linux/minix_fs.h>
1.1.1.2 ! root       15: #include <linux/stat.h>
1.1       root       16: 
                     17: static int minix_readdir(struct inode *, struct file *, struct dirent *, int);
                     18: 
                     19: static struct file_operations minix_dir_operations = {
                     20:        NULL,                   /* lseek - default */
                     21:        minix_file_read,        /* read */
                     22:        NULL,                   /* write - bad */
                     23:        minix_readdir,          /* readdir */
                     24:        NULL,                   /* select - default */
                     25:        NULL,                   /* ioctl - default */
                     26:        NULL,                   /* no special open code */
                     27:        NULL                    /* no special release code */
                     28: };
                     29: 
                     30: /*
                     31:  * directories can handle most operations...
                     32:  */
                     33: struct inode_operations minix_dir_inode_operations = {
                     34:        &minix_dir_operations,  /* default directory file-ops */
                     35:        minix_create,           /* create */
                     36:        minix_lookup,           /* lookup */
                     37:        minix_link,             /* link */
                     38:        minix_unlink,           /* unlink */
                     39:        minix_symlink,          /* symlink */
                     40:        minix_mkdir,            /* mkdir */
                     41:        minix_rmdir,            /* rmdir */
                     42:        minix_mknod,            /* mknod */
                     43:        minix_rename,           /* rename */
                     44:        NULL,                   /* readlink */
                     45:        NULL,                   /* follow_link */
                     46:        minix_bmap,             /* bmap */
                     47:        minix_truncate          /* truncate */
                     48: };
                     49: 
                     50: static int minix_readdir(struct inode * inode, struct file * filp,
                     51:        struct dirent * dirent, int count)
                     52: {
                     53:        unsigned int block,offset,i;
                     54:        char c;
                     55:        struct buffer_head * bh;
                     56:        struct minix_dir_entry * de;
                     57: 
                     58:        if (!inode || !S_ISDIR(inode->i_mode))
                     59:                return -EBADF;
                     60:        if (filp->f_pos & (sizeof (struct minix_dir_entry) - 1))
                     61:                return -EBADF;
                     62:        while (filp->f_pos < inode->i_size) {
                     63:                offset = filp->f_pos & 1023;
                     64:                block = minix_bmap(inode,(filp->f_pos)>>BLOCK_SIZE_BITS);
                     65:                if (!block || !(bh = bread(inode->i_dev,block))) {
                     66:                        filp->f_pos += 1024-offset;
                     67:                        continue;
                     68:                }
                     69:                de = (struct minix_dir_entry *) (offset + bh->b_data);
                     70:                while (offset < 1024 && filp->f_pos < inode->i_size) {
                     71:                        offset += sizeof (struct minix_dir_entry);
                     72:                        filp->f_pos += sizeof (struct minix_dir_entry);
                     73:                        if (de->inode) {
                     74:                                for (i = 0; i < MINIX_NAME_LEN; i++)
                     75:                                        if (c = de->name[i])
                     76:                                                put_fs_byte(c,i+dirent->d_name);
                     77:                                        else
                     78:                                                break;
                     79:                                if (i) {
                     80:                                        put_fs_long(de->inode,&dirent->d_ino);
                     81:                                        put_fs_byte(0,i+dirent->d_name);
                     82:                                        put_fs_word(i,&dirent->d_reclen);
                     83:                                        brelse(bh);
                     84:                                        return i;
                     85:                                }
                     86:                        }
                     87:                        de++;
                     88:                }
                     89:                brelse(bh);
                     90:        }
                     91:        return 0;
                     92: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.