read_write.c





/*
* linux/fs/read_write.c
*
* Copyright (C) 1991, 1992 Linus Torvalds
*/

#include <linux/types.h>
#include <linux/errno.h>
#include <linux/stat.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/fcntl.h>
#include <linux/file.h>
#include <linux/mm.h>
#include <linux/uio.h>

#include <asm/segment.h>

asmlinkage long sys_lseek(unsigned int fd, off_t offset, unsigned int origin)
{
struct file * file;
long tmp = -1;

if (fd >= NR_OPEN || !(file=current->files->fd[fd]) || !(file->f_inode))
return -EBADF;
if (origin > 2)
return -EINVAL;
if (file->f_op && file->f_op->lseek)
return file->f_op->lseek(file->f_inode,file,offset,origin);

/* this is the default handler if no lseek handler is present */
switch (origin) {
case 0:
tmp = offset;
break;
case 1:
tmp = file->f_pos + offset;
break;
case 2:
if (!file->f_inode)
return -EINVAL;
tmp = file->f_inode->i_size + offset;
break;
}
if (tmp < 0)
return -EINVAL;
if (tmp != file->f_pos) {
file->f_pos = tmp;
file->f_reada = 0;
file->f_version = ++event;
}
return file->f_pos;
}

asmlinkage int sys_llseek(unsigned int fd, unsigned long offset_high,
unsigned long offset_low, loff_t * result,
unsigned int origin)
{
struct file * file;
loff_t tmp = -1;
loff_t offset;
int err;

if (fd >= NR_OPEN || !(file=current->files->fd[fd]) || !(file->f_inode))
return -EBADF;
if (origin > 2)
return -EINVAL;
if ((err = verify_area(VERIFY_WRITE, result, sizeof(loff_t))))
return err;
offset = (loff_t) (((unsigned long long) offset_high << 32) | offset_low);

/* if there is a fs-specific handler, we can't just ignore it.. */
/* accept llseek() only for the signed long subset of long long */
if (file->f_op && file->f_op->lseek) {
if (offset != (long) offset)
return -EINVAL;
return file->f_op->lseek(file->f_inode,file,offset,origin);
}

switch (origin) {
case 0:
tmp = offset;
break;
case 1:
tmp = file->f_pos + offset;
break;
case 2:
if (!file->f_inode)
return -EINVAL;
tmp = file->f_inode->i_size + offset;
break;
}
if (tmp < 0)
return -EINVAL;
if (tmp != file->f_pos) {
file->f_pos = tmp;
file->f_reada = 0;
file->f_version = ++event;
}
memcpy_tofs(result, &file->f_pos, sizeof(loff_t));
return 0;
}


asmlinkage int sys_read(unsigned int fd,char * buf,int count)
{
int error;
struct file * file;
struct inode * inode;

error = -EBADF;
file = fget(fd);
if (!file)
goto bad_file;
inode = file->f_inode;
if (!inode)
goto out;
error = -EBADF;
if (!(file->f_mode & 1))
goto out;
error = -EINVAL;
if (!file->f_op || !file->f_op->read)
goto out;
error = 0;
if (count <= 0)
goto out;
error = locks_verify_area(FLOCK_VERIFY_READ,inode,file,file->f_pos,count);
if (error)
goto out;
error = verify_area(VERIFY_WRITE,buf,count);
if (error)
goto out;
error = file->f_op->read(inode,file,buf,count);
out:
fput(file, inode);
bad_file:
return error;
}





(Link do: cz.2 kodu write(). -system
Ext2)

asmlinkage int sys_write(unsigned int fd,char * buf,unsigned int
count)
{

int error;
struct file * file;
struct inode * inode;
int written;

if (fd>=NR_OPEN || !(file=current->files->fd[fd]) || !(inode=file->f_inode))


/* fd[fd] daje plik w tablicy plikow - globalnej
file->f_inode zwraca w-wezel z tablicy i-wezlow */


return -EBADF; /* blad: BAD FILE */

if (!(file->f_mode & 2))
/* sprawdzenie prawa pisania do otwartego pliku w tablicy plikow */
return -EBADF;

if (!file->f_op || !file->f_op->write)
return -EINVAL;
/* to znaczy, ze musi byc okreslona struktura file_operations dla pliku oraz
w niej funkcja write, czyli nie ma defaultowej (NULL) write */

if (!count)
return 0;
/* czyli kazalismy przeczytac 0 bajtow */
error = locks_verify_area(FLOCK_VERIFY_WRITE,inode,file,file->f_pos,count);
/* gosc od lock'ow nam powie! */

if (error)
return error;
error = verify_area(VERIFY_READ,buf,count);
/* zdefiniowane w mm/memory.c - sprawdza, czy mozemy pisac w obszarze
zaczynajacym sie od buf o dlugosci count */

if (error)
return error;
/* Jesli dane zostaly zapisane do pliku, usun bity: setuid oraz setgid.

Ustawienie ATTR_FORCE spowoduje bezwarunkowa zmiane tych bitow */

if (!suser() && (inode->i_mode & (S_ISUID | S_ISGID))) {
/* bit setuid, bit setgid */

struct iattr newattrs;
/* ta strukture opisalem w chown */

/* Nie wylaczaj bitu setgid jesli nie ma prawa wykonywania dla grupy.

Ten szczegolny przypadek oznacza kandydata na obowiazkowe blokowanie */

newattrs.ia_mode = inode->i_mode &
~(S_ISUID | ((inode->i_mode & S_IXGRP) ? S_ISGID : 0));

newattrs.ia_valid = ATTR_CTIME | ATTR_MODE | ATTR_FORCE;
notify_change(inode, &newattrs);
/* gdy mamy FORCE, to zmiana bedzie bezwarunkowa */
}

down(&inode->i_sem);
/* opusc semafor,
down jest w sched.h (i sched.c):
dopoki semafor <=0, wykonuj schedule() itd. (spanie),
jesli semafor>0, to zmniejsz go */

written = file->f_op->write(inode,file,buf,count);
up(&inode->i_sem);
/* podnies semafor, tzn. zwieksz jego wartosc i obudz procesy
czekajace */*
return written;
/* zwraca liczbe zapisanych bajtow */
}



static int sock_readv_writev(int type, struct inode * inode, struct file * file,
const struct iovec * iov, long count, long size)
{
struct msghdr msg;
struct socket *sock;

sock = &inode->u.socket_i;
if (!sock->ops)
return -EOPNOTSUPP;
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_control = NULL;
msg.msg_iov = (struct iovec *) iov;
msg.msg_iovlen = count;

/* read() does a VERIFY_WRITE */
if (type == VERIFY_WRITE) {
if (!sock->ops->recvmsg)
return -EOPNOTSUPP;
return sock->ops->recvmsg(sock, &msg, size,
(file->f_flags & O_NONBLOCK), 0, NULL);
}
if (!sock->ops->sendmsg)
return -EOPNOTSUPP;
return sock->ops->sendmsg(sock, &msg, size,
(file->f_flags & O_NONBLOCK), 0);
}

typedef int (*IO_fn_t)(struct inode *, struct file *, char *, int);

static int do_readv_writev(int type, struct inode * inode, struct file * file,
const struct iovec * vector, unsigned long count)
{
size_t tot_len;
struct iovec iov[UIO_MAXIOV];
int retval, i;
IO_fn_t fn;

/*
* First get the "struct iovec" from user memory and
* verify all the pointers
*/
if (!count)
return 0;
if (count > UIO_MAXIOV)
return -EINVAL;
retval = verify_area(VERIFY_READ, vector, count*sizeof(*vector));
if (retval)
return retval;
memcpy_fromfs(iov, vector, count*sizeof(*vector));
tot_len = 0;
for (i = 0 ; i < count ; i++) {
tot_len += iov[i].iov_len;
retval = verify_area(type, iov[i].iov_base, iov[i].iov_len);
if (retval)
return retval;
}

retval = locks_verify_area(type == VERIFY_READ ? FLOCK_VERIFY_READ : FLOCK_VERIFY_WRITE,
inode, file, file->f_pos, tot_len);
if (retval)
return retval;

/*
* Then do the actual IO. Note that sockets need to be handled
* specially as they have atomicity guarantees and can handle
* iovec's natively
*/
if (inode->i_sock)
return sock_readv_writev(type, inode, file, iov, count, tot_len);

if (!file->f_op)
return -EINVAL;
/* VERIFY_WRITE actually means a read, as we write to user space */
fn = file->f_op->read;
if (type == VERIFY_READ)
fn = (IO_fn_t) file->f_op->write;
vector = iov;
while (count > 0) {
void * base;
int len, nr;

base = vector->iov_base;
len = vector->iov_len;
vector++;
count--;
nr = fn(inode, file, base, len);
if (nr < 0) {
if (retval)
break;
retval = nr;
break;
}
retval += nr;
if (nr != len)
break;
}
return retval;
}

asmlinkage int sys_readv(unsigned long fd, const struct iovec * vector, long count)
{
struct file * file;
struct inode * inode;

if (fd >= NR_OPEN || !(file = current->files->fd[fd]) || !(inode = file->f_inode))
return -EBADF;
if (!(file->f_mode & 1))
return -EBADF;
return do_readv_writev(VERIFY_WRITE, inode, file, vector, count);
}

asmlinkage int sys_writev(unsigned long fd, const struct iovec * vector, long count)
{
int error;
struct file * file;
struct inode * inode;

if (fd >= NR_OPEN || !(file = current->files->fd[fd]) || !(inode = file->f_inode))
return -EBADF;
if (!(file->f_mode & 2))
return -EBADF;
down(&inode->i_sem);
error = do_readv_writev(VERIFY_READ, inode, file, vector, count);
up(&inode->i_sem);
return error;
}