Return to pipe.c CVS log

Up to [Early Linux] / linux / fs

Annotation of linux/fs/pipe.c, revision 1.1.1.1

1.1       root        1: #include <signal.h>
                      2: 
                      3: #include <linux/sched.h>
                      4: #include <linux/mm.h>  /* for get_free_page */
                      5: #include <asm/segment.h>
                      6: 
                      7: int read_pipe(struct m_inode * inode, char * buf, int count)
                      8: {
                      9:        char * b=buf;
                     10: 
                     11:        while (PIPE_EMPTY(*inode)) {
                     12:                wake_up(&inode->i_wait);
                     13:                if (inode->i_count != 2) /* are there any writers left? */
                     14:                        return 0;
                     15:                sleep_on(&inode->i_wait);
                     16:        }
                     17:        while (count>0 && !(PIPE_EMPTY(*inode))) {
                     18:                count --;
                     19:                put_fs_byte(((char *)inode->i_size)[PIPE_TAIL(*inode)],b++);
                     20:                INC_PIPE( PIPE_TAIL(*inode) );
                     21:        }
                     22:        wake_up(&inode->i_wait);
                     23:        return b-buf;
                     24: }
                     25:        
                     26: int write_pipe(struct m_inode * inode, char * buf, int count)
                     27: {
                     28:        char * b=buf;
                     29: 
                     30:        wake_up(&inode->i_wait);
                     31:        if (inode->i_count != 2) { /* no readers */
                     32:                current->signal |= (1<<(SIGPIPE-1));
                     33:                return -1;
                     34:        }
                     35:        while (count-->0) {
                     36:                while (PIPE_FULL(*inode)) {
                     37:                        wake_up(&inode->i_wait);
                     38:                        if (inode->i_count != 2) {
                     39:                                current->signal |= (1<<(SIGPIPE-1));
                     40:                                return b-buf;
                     41:                        }
                     42:                        sleep_on(&inode->i_wait);
                     43:                }
                     44:                ((char *)inode->i_size)[PIPE_HEAD(*inode)] = get_fs_byte(b++);
                     45:                INC_PIPE( PIPE_HEAD(*inode) );
                     46:                wake_up(&inode->i_wait);
                     47:        }
                     48:        wake_up(&inode->i_wait);
                     49:        return b-buf;
                     50: }
                     51: 
                     52: int sys_pipe(unsigned long * fildes)
                     53: {
                     54:        struct m_inode * inode;
                     55:        struct file * f[2];
                     56:        int fd[2];
                     57:        int i,j;
                     58: 
                     59:        j=0;
                     60:        for(i=0;j<2 && i<NR_FILE;i++)
                     61:                if (!file_table[i].f_count)
                     62:                        (f[j++]=i+file_table)->f_count++;
                     63:        if (j==1)
                     64:                f[0]->f_count=0;
                     65:        if (j<2)
                     66:                return -1;
                     67:        j=0;
                     68:        for(i=0;j<2 && i<NR_OPEN;i++)
                     69:                if (!current->filp[i]) {
                     70:                        current->filp[ fd[j]=i ] = f[j];
                     71:                        j++;
                     72:                }
                     73:        if (j==1)
                     74:                current->filp[fd[0]]=NULL;
                     75:        if (j<2) {
                     76:                f[0]->f_count=f[1]->f_count=0;
                     77:                return -1;
                     78:        }
                     79:        if (!(inode=get_pipe_inode())) {
                     80:                current->filp[fd[0]] =
                     81:                        current->filp[fd[1]] = NULL;
                     82:                f[0]->f_count = f[1]->f_count = 0;
                     83:                return -1;
                     84:        }
                     85:        f[0]->f_inode = f[1]->f_inode = inode;
                     86:        f[0]->f_pos = f[1]->f_pos = 0;
                     87:        f[0]->f_mode = 1;               /* read */
                     88:        f[1]->f_mode = 2;               /* write */
                     89:        put_fs_long(fd[0],0+fildes);
                     90:        put_fs_long(fd[1],1+fildes);
                     91:        return 0;
                     92: }

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