Fork me on GitHub
fd_table          492 drivers/block/floppy.c int fdc_open(struct inode *i, struct fd *fd_table)
fd_table          508 drivers/block/floppy.c int fdc_close(struct inode *i, struct fd *fd_table)
fd_table          645 drivers/block/ide.c int ide_open(struct inode *i, struct fd *fd_table)
fd_table          660 drivers/block/ide.c 		return ide->drive[drive].fsop->open(i, fd_table);
fd_table          665 drivers/block/ide.c int ide_close(struct inode *i, struct fd *fd_table)
fd_table          680 drivers/block/ide.c 		return ide->drive[drive].fsop->close(i, fd_table);
fd_table          324 drivers/block/ide_cd.c int ide_cd_open(struct inode *i, struct fd *fd_table)
fd_table          395 drivers/block/ide_cd.c int ide_cd_close(struct inode *i, struct fd *fd_table)
fd_table          115 drivers/block/ide_hd.c int ide_hd_open(struct inode *i, struct fd *fd_table)
fd_table          120 drivers/block/ide_hd.c int ide_hd_close(struct inode *i, struct fd *fd_table)
fd_table           82 drivers/block/ramdisk.c int ramdisk_open(struct inode *i, struct fd *fd_table)
fd_table           90 drivers/block/ramdisk.c int ramdisk_close(struct inode *i, struct fd *fd_table)
fd_table           73 drivers/char/fb.c int fb_open(struct inode *i, struct fd *fd_table)
fd_table           78 drivers/char/fb.c int fb_close(struct inode *i, struct fd *fd_table)
fd_table           83 drivers/char/fb.c int fb_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
fd_table           87 drivers/char/fb.c 	if(fd_table->offset >= video.memsize) {
fd_table           91 drivers/char/fb.c 	addr = (unsigned int)video.address + fd_table->offset;
fd_table           92 drivers/char/fb.c 	count = MIN(count, video.memsize - fd_table->offset);
fd_table           94 drivers/char/fb.c 	fd_table->offset += count;
fd_table           98 drivers/char/fb.c int fb_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
fd_table          102 drivers/char/fb.c 	if(fd_table->offset >= video.memsize) {
fd_table          106 drivers/char/fb.c 	addr = (unsigned int)video.address + fd_table->offset;
fd_table          107 drivers/char/fb.c 	count = MIN(count, video.memsize - fd_table->offset);
fd_table          109 drivers/char/fb.c 	fd_table->offset += count;
fd_table          135 drivers/char/lp.c int lp_open(struct inode *i, struct fd *fd_table)
fd_table          153 drivers/char/lp.c int lp_close(struct inode *i, struct fd *fd_table)
fd_table          165 drivers/char/lp.c int lp_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
fd_table          282 drivers/char/memdev.c int mem_open(struct inode *i, struct fd *fd_table)
fd_table          287 drivers/char/memdev.c int mem_close(struct inode *i, struct fd *fd_table)
fd_table          292 drivers/char/memdev.c int mem_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
fd_table          297 drivers/char/memdev.c 	if(fd_table->offset >= physical_memory) {
fd_table          300 drivers/char/memdev.c 	count = MIN(count, physical_memory - fd_table->offset);
fd_table          301 drivers/char/memdev.c 	memcpy_b(buffer, (void *)P2V(fd_table->offset), count);
fd_table          302 drivers/char/memdev.c 	fd_table->offset += count;
fd_table          306 drivers/char/memdev.c int mem_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
fd_table          311 drivers/char/memdev.c 	if(fd_table->offset >= physical_memory) {
fd_table          314 drivers/char/memdev.c 	count = MIN(count, physical_memory - fd_table->offset);
fd_table          315 drivers/char/memdev.c 	memcpy_b((void *)P2V(fd_table->offset), buffer, count);
fd_table          316 drivers/char/memdev.c 	fd_table->offset += count;
fd_table          325 drivers/char/memdev.c int kmem_open(struct inode *i, struct fd *fd_table)
fd_table          330 drivers/char/memdev.c int kmem_close(struct inode *i, struct fd *fd_table)
fd_table          335 drivers/char/memdev.c int kmem_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
fd_table          340 drivers/char/memdev.c 	if(P2V(fd_table->offset + count) < physical_memory) {
fd_table          341 drivers/char/memdev.c 		memcpy_b(buffer, (void *)P2V(fd_table->offset), count);
fd_table          342 drivers/char/memdev.c 		fd_table->offset += count;
fd_table          349 drivers/char/memdev.c int kmem_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
fd_table          354 drivers/char/memdev.c 	if(P2V(fd_table->offset + count) < physical_memory) {
fd_table          355 drivers/char/memdev.c 		memcpy_b((void *)P2V(fd_table->offset), buffer, count);
fd_table          356 drivers/char/memdev.c 		fd_table->offset += count;
fd_table          368 drivers/char/memdev.c int null_open(struct inode *i, struct fd *fd_table)
fd_table          373 drivers/char/memdev.c int null_close(struct inode *i, struct fd *fd_table)
fd_table          378 drivers/char/memdev.c int null_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
fd_table          383 drivers/char/memdev.c int null_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
fd_table          393 drivers/char/memdev.c int zero_open(struct inode *i, struct fd *fd_table)
fd_table          398 drivers/char/memdev.c int zero_close(struct inode *i, struct fd *fd_table)
fd_table          403 drivers/char/memdev.c int zero_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
fd_table          409 drivers/char/memdev.c int zero_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
fd_table          419 drivers/char/memdev.c int urandom_open(struct inode *i, struct fd *fd_table)
fd_table          424 drivers/char/memdev.c int urandom_close(struct inode *i, struct fd *fd_table)
fd_table          429 drivers/char/memdev.c int urandom_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
fd_table          441 drivers/char/memdev.c int urandom_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
fd_table          451 drivers/char/memdev.c int memdev_open(struct inode *i, struct fd *fd_table)
fd_table          479 drivers/char/memdev.c 		return i->fsop->open(i, fd_table);
fd_table          419 drivers/char/tty.c int tty_open(struct inode *i, struct fd *fd_table)
fd_table          425 drivers/char/tty.c 	noctty_flag = fd_table->flags & O_NOCTTY;
fd_table          459 drivers/char/tty.c int tty_close(struct inode *i, struct fd *fd_table)
fd_table          491 drivers/char/tty.c int tty_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
fd_table          562 drivers/char/tty.c 						if(fd_table->flags & O_NONBLOCK) {
fd_table          591 drivers/char/tty.c 						if(fd_table->flags & O_NONBLOCK) {
fd_table          623 drivers/char/tty.c 		if(fd_table->flags & O_NONBLOCK) {
fd_table          639 drivers/char/tty.c int tty_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
fd_table          680 drivers/char/tty.c 		if(fd_table->flags & O_NONBLOCK) {
fd_table          199 fs/devices.c   int chr_dev_open(struct inode *i, struct fd *fd_table)
fd_table          206 fs/devices.c   			return i->fsop->open(i, fd_table);
fd_table          214 fs/devices.c   int blk_dev_open(struct inode *i, struct fd *fd_table)
fd_table          220 fs/devices.c   			return d->fsop->open(i, fd_table);
fd_table          228 fs/devices.c   int blk_dev_close(struct inode *i, struct fd *fd_table)
fd_table          234 fs/devices.c   			return d->fsop->close(i, fd_table);
fd_table          243 fs/devices.c   int blk_dev_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
fd_table          267 fs/devices.c   	count = (fd_table->offset + count > device_size) ? device_size - fd_table->offset : count;
fd_table          268 fs/devices.c   	if(!count || fd_table->offset > device_size) {
fd_table          272 fs/devices.c   		boffset = fd_table->offset % blksize;
fd_table          273 fs/devices.c   		block = (fd_table->offset / blksize);
fd_table          282 fs/devices.c   		fd_table->offset += bytes;
fd_table          288 fs/devices.c   int blk_dev_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
fd_table          312 fs/devices.c   	count = (fd_table->offset + count > device_size) ? device_size - fd_table->offset : count;
fd_table          313 fs/devices.c   	if(!count || fd_table->offset > device_size) {
fd_table          317 fs/devices.c   		boffset = fd_table->offset % blksize;
fd_table          318 fs/devices.c   		block = (fd_table->offset / blksize);
fd_table          327 fs/devices.c   		fd_table->offset += bytes;
fd_table           61 fs/ext2/dir.c  int ext2_dir_open(struct inode *i, struct fd *fd_table)
fd_table           63 fs/ext2/dir.c  	fd_table->offset = 0;
fd_table           67 fs/ext2/dir.c  int ext2_dir_close(struct inode *i, struct fd *fd_table)
fd_table           72 fs/ext2/dir.c  int ext2_dir_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
fd_table           77 fs/ext2/dir.c  int ext2_dir_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
fd_table           82 fs/ext2/dir.c  int ext2_dir_readdir(struct inode *i, struct fd *fd_table, struct dirent *dirent, unsigned int count)
fd_table           97 fs/ext2/dir.c  	if(fd_table->offset > i->i_size) {
fd_table           98 fs/ext2/dir.c  		fd_table->offset = i->i_size;
fd_table          104 fs/ext2/dir.c  	while(fd_table->offset < i->i_size && count > 0) {
fd_table          105 fs/ext2/dir.c  		if((block = bmap(i, fd_table->offset, FOR_READING)) < 0) {
fd_table          113 fs/ext2/dir.c  			doffset = fd_table->offset;
fd_table          114 fs/ext2/dir.c  			offset = fd_table->offset % blksize;
fd_table          142 fs/ext2/dir.c  		fd_table->offset &= ~(blksize - 1);
fd_table          143 fs/ext2/dir.c  		doffset = fd_table->offset;
fd_table          144 fs/ext2/dir.c  		fd_table->offset += offset;
fd_table           62 fs/ext2/file.c int ext2_file_open(struct inode *i, struct fd *fd_table)
fd_table           64 fs/ext2/file.c 	if(fd_table->flags & O_APPEND) {
fd_table           65 fs/ext2/file.c 		fd_table->offset = i->i_size;
fd_table           67 fs/ext2/file.c 		fd_table->offset = 0;
fd_table           69 fs/ext2/file.c 	if(fd_table->flags & O_TRUNC) {
fd_table           76 fs/ext2/file.c int ext2_file_close(struct inode *i, struct fd *fd_table)
fd_table           81 fs/ext2/file.c int ext2_file_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
fd_table           94 fs/ext2/file.c 	if(fd_table->flags & O_APPEND) {
fd_table           95 fs/ext2/file.c 		fd_table->offset = i->i_size;
fd_table           99 fs/ext2/file.c 		boffset = fd_table->offset % blksize;
fd_table          100 fs/ext2/file.c 		if((block = bmap(i, fd_table->offset, FOR_WRITING)) < 0) {
fd_table          111 fs/ext2/file.c 		update_page_cache(i, fd_table->offset, buffer + total_written, bytes);
fd_table          114 fs/ext2/file.c 		fd_table->offset += bytes;
fd_table          117 fs/ext2/file.c 	if(fd_table->offset > i->i_size) {
fd_table          118 fs/ext2/file.c 		i->i_size = fd_table->offset;
fd_table           15 fs/fd.c        struct fd *fd_table;
fd_table           26 fs/fd.c        		if(fd_table[n].count == 0) {
fd_table           27 fs/fd.c        			memset_b(&fd_table[n], NULL, sizeof(struct fd));
fd_table           28 fs/fd.c        			fd_table[n].inode = i;
fd_table           29 fs/fd.c        			fd_table[n].count = 1;
fd_table           43 fs/fd.c        	fd_table[fd].count = 0;
fd_table           49 fs/fd.c        	memset_b(fd_table, NULL, fd_table_size);
fd_table           60 fs/iso9660/dir.c int iso9660_dir_open(struct inode *i, struct fd *fd_table)
fd_table           62 fs/iso9660/dir.c 	fd_table->offset = 0;
fd_table           66 fs/iso9660/dir.c int iso9660_dir_close(struct inode *i, struct fd *fd_table)
fd_table           71 fs/iso9660/dir.c int iso9660_dir_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
fd_table           76 fs/iso9660/dir.c int iso9660_dir_readdir(struct inode *i, struct fd *fd_table, struct dirent *dirent, unsigned int count)
fd_table           93 fs/iso9660/dir.c 	if(fd_table->offset > i->i_size) {
fd_table           94 fs/iso9660/dir.c 		fd_table->offset = i->i_size;
fd_table          101 fs/iso9660/dir.c 		if((block = bmap(i, fd_table->offset, FOR_READING)) < 0) {
fd_table          109 fs/iso9660/dir.c 			doffset = fd_table->offset;
fd_table          110 fs/iso9660/dir.c 			offset = fd_table->offset % blksize;
fd_table          173 fs/iso9660/dir.c 		fd_table->offset = doffset;
fd_table           61 fs/iso9660/file.c int iso9660_file_open(struct inode *i, struct fd *fd_table)
fd_table           63 fs/iso9660/file.c 	if(fd_table->flags & (O_WRONLY | O_RDWR | O_TRUNC | O_APPEND)) {
fd_table           66 fs/iso9660/file.c 	fd_table->offset = 0;
fd_table           70 fs/iso9660/file.c int iso9660_file_close(struct inode *i, struct fd *fd_table)
fd_table           75 fs/locks.c     	i = fd_table[current->fd[ufd]].inode;
fd_table           61 fs/minix/dir.c int minix_dir_open(struct inode *i, struct fd *fd_table)
fd_table           63 fs/minix/dir.c 	fd_table->offset = 0;
fd_table           67 fs/minix/dir.c int minix_dir_close(struct inode *i, struct fd *fd_table)
fd_table           72 fs/minix/dir.c int minix_dir_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
fd_table           77 fs/minix/dir.c int minix_dir_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
fd_table           82 fs/minix/dir.c int minix_dir_readdir(struct inode *i, struct fd *fd_table, struct dirent *dirent, unsigned int count)
fd_table           97 fs/minix/dir.c 	if(fd_table->offset > i->i_size) {
fd_table           98 fs/minix/dir.c 		fd_table->offset = i->i_size;
fd_table          104 fs/minix/dir.c 	while(fd_table->offset < i->i_size && count > 0) {
fd_table          105 fs/minix/dir.c 		if((block = bmap(i, fd_table->offset, FOR_READING)) < 0) {
fd_table          113 fs/minix/dir.c 			doffset = fd_table->offset;
fd_table          114 fs/minix/dir.c 			offset = fd_table->offset % blksize;
fd_table          139 fs/minix/dir.c 		fd_table->offset &= ~(blksize - 1);
fd_table          140 fs/minix/dir.c 		doffset = fd_table->offset;
fd_table          141 fs/minix/dir.c 		fd_table->offset += offset;
fd_table           62 fs/minix/file.c int minix_file_open(struct inode *i, struct fd *fd_table)
fd_table           64 fs/minix/file.c 	if(fd_table->flags & O_APPEND) {
fd_table           65 fs/minix/file.c 		fd_table->offset = i->i_size;
fd_table           67 fs/minix/file.c 		fd_table->offset = 0;
fd_table           69 fs/minix/file.c 	if(fd_table->flags & O_TRUNC) {
fd_table           76 fs/minix/file.c int minix_file_close(struct inode *i, struct fd *fd_table)
fd_table           81 fs/minix/file.c int minix_file_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
fd_table           94 fs/minix/file.c 	if(fd_table->flags & O_APPEND) {
fd_table           95 fs/minix/file.c 		fd_table->offset = i->i_size;
fd_table           99 fs/minix/file.c 		boffset = fd_table->offset % blksize;
fd_table          100 fs/minix/file.c 		if((block = bmap(i, fd_table->offset, FOR_WRITING)) < 0) {
fd_table          111 fs/minix/file.c 		update_page_cache(i, fd_table->offset, buffer + total_written, bytes);
fd_table          114 fs/minix/file.c 		fd_table->offset += bytes;
fd_table          117 fs/minix/file.c 	if(fd_table->offset > i->i_size) {
fd_table          118 fs/minix/file.c 		i->i_size = fd_table->offset;
fd_table           20 fs/pipefs/fifo.c int fifo_open(struct inode *i, struct fd *fd_table)
fd_table           31 fs/pipefs/fifo.c 	if((fd_table->flags & O_ACCMODE) == O_RDONLY) {
fd_table           34 fs/pipefs/fifo.c 		if(!(fd_table->flags & O_NONBLOCK)) {
fd_table           46 fs/pipefs/fifo.c 	if((fd_table->flags & O_ACCMODE) == O_WRONLY) {
fd_table           47 fs/pipefs/fifo.c 		if((fd_table->flags & O_NONBLOCK) && !i->u.pipefs.i_readers) {
fd_table           53 fs/pipefs/fifo.c 		if(!(fd_table->flags & O_NONBLOCK)) {
fd_table           65 fs/pipefs/fifo.c 	if((fd_table->flags & O_ACCMODE) == O_RDWR) {
fd_table           23 fs/pipefs/pipe.c int pipefs_close(struct inode *i, struct fd *fd_table)
fd_table           25 fs/pipefs/pipe.c 	if((fd_table->flags & O_ACCMODE) == O_RDONLY) {
fd_table           31 fs/pipefs/pipe.c 	if((fd_table->flags & O_ACCMODE) == O_WRONLY) {
fd_table           37 fs/pipefs/pipe.c 	if((fd_table->flags & O_ACCMODE) == O_RDWR) {
fd_table           50 fs/pipefs/pipe.c int pipefs_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
fd_table           85 fs/pipefs/pipe.c 				if(fd_table->flags & O_NONBLOCK) {
fd_table          109 fs/pipefs/pipe.c int pipefs_write(struct inode *i, struct fd *fd_table, const char *buffer, __size_t count)
fd_table          161 fs/pipefs/pipe.c 		if(!(fd_table->flags & O_NONBLOCK)) {
fd_table          395 fs/procfs/data.c 		if(fd_table[n].count != 0) {
fd_table          136 fs/procfs/dir.c static int dir_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
fd_table          172 fs/procfs/dir.c 	total_read = fd_table->offset = len;
fd_table          178 fs/procfs/dir.c int procfs_dir_open(struct inode *i, struct fd *fd_table)
fd_table          180 fs/procfs/dir.c 	fd_table->offset = 0;
fd_table          184 fs/procfs/dir.c int procfs_dir_close(struct inode *i, struct fd *fd_table)
fd_table          189 fs/procfs/dir.c int procfs_dir_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
fd_table          194 fs/procfs/dir.c int procfs_dir_readdir(struct inode *i, struct fd *fd_table, struct dirent *dirent, unsigned int count)
fd_table          211 fs/procfs/dir.c 	offset = fd_table->offset;
fd_table          216 fs/procfs/dir.c 	total_read = dir_read(i, fd_table, buffer, PAGE_SIZE);
fd_table          222 fs/procfs/dir.c 	while(boffset < fd_table->offset) {
fd_table          244 fs/procfs/dir.c 	fd_table->offset = boffset;
fd_table           60 fs/procfs/file.c int procfs_file_open(struct inode *i, struct fd *fd_table)
fd_table           62 fs/procfs/file.c 	if(fd_table->flags & (O_WRONLY | O_RDWR | O_TRUNC | O_APPEND)) {
fd_table           65 fs/procfs/file.c 	fd_table->offset = 0;
fd_table           69 fs/procfs/file.c int procfs_file_close(struct inode *i, struct fd *fd_table)
fd_table           74 fs/procfs/file.c int procfs_file_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
fd_table           94 fs/procfs/file.c 	if(fd_table->offset > size) {
fd_table           95 fs/procfs/file.c 		fd_table->offset = size;
fd_table          101 fs/procfs/file.c 		count = (fd_table->offset + count > size) ? size - fd_table->offset : count;
fd_table          106 fs/procfs/file.c 		boffset = fd_table->offset % blksize;
fd_table          112 fs/procfs/file.c 		fd_table->offset += bytes;
fd_table          114 include/fiwix/fs.h extern struct fd *fd_table;
fd_table           26 kernel/syscalls/close.c 	if(--fd_table[fd].count) {
fd_table           29 kernel/syscalls/close.c 	i = fd_table[fd].inode;
fd_table           32 kernel/syscalls/close.c 		i->fsop->close(i, &fd_table[fd]);
fd_table           35 kernel/syscalls/dup.c 	fd_table[current->fd[new_ufd]].count++;
fd_table           36 kernel/syscalls/dup2.c 	fd_table[current->fd[new_ufd]].count++;
fd_table           26 kernel/syscalls/fchdir.c 	i = fd_table[current->fd[ufd]].inode;
fd_table           28 kernel/syscalls/fchmod.c 	i = fd_table[current->fd[ufd]].inode;
fd_table           28 kernel/syscalls/fchown.c 	i = fd_table[current->fd[ufd]].inode;
fd_table           37 kernel/syscalls/fcntl.c 			fd_table[current->fd[new_ufd]].count++;
fd_table           48 kernel/syscalls/fcntl.c 			return fd_table[current->fd[ufd]].flags;
fd_table           50 kernel/syscalls/fcntl.c 			fd_table[current->fd[ufd]].flags &= ~(O_APPEND | O_NONBLOCK);
fd_table           51 kernel/syscalls/fcntl.c 			fd_table[current->fd[ufd]].flags |= arg & (O_APPEND | O_NONBLOCK);
fd_table           26 kernel/syscalls/flock.c 	i = fd_table[current->fd[ufd]].inode;
fd_table          133 kernel/syscalls/fork.c 			fd_table[current->fd[n]].count++;
fd_table           31 kernel/syscalls/fstat.c 	i = fd_table[current->fd[ufd]].inode;
fd_table           30 kernel/syscalls/fstatfs.c 	i = fd_table[current->fd[ufd]].inode;
fd_table           28 kernel/syscalls/fsync.c 	i = fd_table[current->fd[ufd]].inode;
fd_table           29 kernel/syscalls/ftruncate.c 	i = fd_table[current->fd[ufd]].inode;
fd_table           30 kernel/syscalls/ftruncate.c 	if((fd_table[current->fd[ufd]].flags & O_ACCMODE) == O_RDONLY) {
fd_table           31 kernel/syscalls/getdents.c 	i = fd_table[current->fd[ufd]].inode;
fd_table           38 kernel/syscalls/getdents.c 		errno = i->fsop->readdir(i, &fd_table[current->fd[ufd]], dirent, count);
fd_table           25 kernel/syscalls/ioctl.c 	i = fd_table[current->fd[fd]].inode;
fd_table           33 kernel/syscalls/llseek.c 	i = fd_table[current->fd[ufd]].inode;
fd_table           40 kernel/syscalls/llseek.c 			new_offset = fd_table[current->fd[ufd]].offset + offset;
fd_table           48 kernel/syscalls/llseek.c 	fd_table[current->fd[ufd]].offset = new_offset;
fd_table           29 kernel/syscalls/lseek.c 	i = fd_table[current->fd[ufd]].inode;
fd_table           35 kernel/syscalls/lseek.c 			new_offset = fd_table[current->fd[ufd]].offset + offset;
fd_table           47 kernel/syscalls/lseek.c 		fd_table[current->fd[ufd]].offset = new_offset;
fd_table           30 kernel/syscalls/newfstat.c 	i = fd_table[current->fd[ufd]].inode;
fd_table           42 kernel/syscalls/old_mmap.c 		if(!(i = fd_table[current->fd[mmap->fd]].inode)) {
fd_table           45 kernel/syscalls/old_mmap.c 		flags = fd_table[current->fd[mmap->fd]].flags & O_ACCMODE;
fd_table          129 kernel/syscalls/open.c 	fd_table[fd].flags = flags;
fd_table          132 kernel/syscalls/open.c 		if((errno = i->fsop->open(i, &fd_table[fd])) < 0) {
fd_table           64 kernel/syscalls/pipe.c 	fd_table[rfd].flags = O_RDONLY;
fd_table           65 kernel/syscalls/pipe.c 	fd_table[wfd].flags = O_WRONLY;
fd_table           30 kernel/syscalls/read.c 	if(fd_table[current->fd[ufd]].flags & O_WRONLY) {
fd_table           40 kernel/syscalls/read.c 	i = fd_table[current->fd[ufd]].inode;
fd_table           42 kernel/syscalls/read.c 		errno = i->fsop->read(i, &fd_table[current->fd[ufd]], buf, count);
fd_table           62 kernel/syscalls/select.c 			i = fd_table[current->fd[n]].inode;
fd_table           31 kernel/syscalls/write.c 	if(fd_table[current->fd[ufd]].flags & O_RDONLY) {
fd_table           40 kernel/syscalls/write.c 	i = fd_table[current->fd[ufd]].inode;
fd_table           42 kernel/syscalls/write.c 		errno = i->fsop->write(i, &fd_table[current->fd[ufd]], buf, count);
fd_table           46 mm/memory.c    struct fd *fd_table;
fd_table          383 mm/memory.c    	fd_table = (struct fd *)_last_data_addr;
fd_table          280 mm/page.c      	struct fd fd_table;
fd_table          285 mm/page.c      	fd_table.inode = i;
fd_table          286 mm/page.c      	fd_table.flags = 0;
fd_table          287 mm/page.c      	fd_table.count = 0;
fd_table          288 mm/page.c      	fd_table.offset = offset;
fd_table          290 mm/page.c      		errno = i->fsop->write(i, &fd_table, pg->data, size);
fd_table          336 mm/page.c      int file_read(struct inode *i, struct fd *fd_table, char *buffer, __size_t count)
fd_table          344 mm/page.c      	if(fd_table->offset > i->i_size) {
fd_table          345 mm/page.c      		fd_table->offset = i->i_size;
fd_table          351 mm/page.c      		count = (fd_table->offset + count > i->i_size) ? i->i_size - fd_table->offset : count;
fd_table          356 mm/page.c      		poffset = fd_table->offset % PAGE_SIZE;
fd_table          357 mm/page.c      		if(!(pg = search_page_hash(i, fd_table->offset & PAGE_MASK))) {
fd_table          364 mm/page.c      			if(bread_page(pg, i, fd_table->offset & PAGE_MASK, 0, MAP_SHARED)) {
fd_table          380 mm/page.c      		fd_table->offset += bytes;