/*
* Note: we hold the dentry use count while the file is open.
*/
static __be32
nlm_fopen(struct svc_rqst *rqstp, struct nfs_fh *f, struct file **filp)
{
__be32 nfserr;
struct svc_fh fh;
/* must initialize before using! but maxsize doesn't matter */
fh_init(&fh,0);
fh.fh_handle.fh_size = f->size;
memcpy((char*)&fh.fh_handle.fh_base, f->data, f->size);
fh.fh_export = NULL;
exp_readlock();
nfserr = nfsd_open(rqstp, &fh, S_IFREG, NFSD_MAY_LOCK, filp);
fh_put(&fh);
rqstp->rq_client = NULL;
exp_readunlock();
/* We return nlm error codes as nlm doesn't know
* about nfsd, but nfsd does know about nlm..
*/
switch (nfserr) {
case nfs_ok:
return 0;
case nfserr_dropit:
return nlm_drop_reply;
case nfserr_stale:
return nlm_stale_fh;
default:
return nlm_failed;
}
}
/*
* Note: we hold the dentry use count while the file is open.
*/
static u32
nlm_fopen(struct svc_rqst *rqstp, struct nfs_fh *f, struct file **filp)
{
u32 nfserr;
struct svc_fh fh;
/* must initialize before using! but maxsize doesn't matter */
fh_init(&fh,0);
fh.fh_handle.fh_size = f->size;
memcpy((char*)&fh.fh_handle.fh_base, f->data, f->size);
fh.fh_export = NULL;
exp_readlock();
nfserr = nfsd_open(rqstp, &fh, S_IFREG, MAY_LOCK, filp);
fh_put(&fh);
rqstp->rq_client = NULL;
exp_readunlock();
/* nlm and nfsd don't share error codes.
* we invent: 0 = no error
* 1 = stale file handle
* 2 = nfserr_dropit (or -EAGAIN)
* 3 = other error
*/
switch (nfserr) {
case nfs_ok:
return 0;
case nfserr_stale:
return 1;
case nfserr_dropit:
return 2;
default:
return 3;
}
}
/*
* Read data from a file. count must contain the requested read count
* on entry. On return, *count contains the number of bytes actually read.
* N.B. After this call fhp needs an fh_put
*/
int
nfsd_read(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t offset,
char *buf, unsigned long *count)
{
struct raparms *ra;
mm_segment_t oldfs;
int err;
struct file file;
err = nfsd_open(rqstp, fhp, S_IFREG, OPEN_READ, &file);
if (err)
goto out;
err = nfserr_perm;
if (!file.f_op->read)
goto out_close;
/* Get readahead parameters */
ra = nfsd_get_raparms(fhp->fh_handle.fh_dev, fhp->fh_handle.fh_ino);
if (ra) {
file.f_reada = ra->p_reada;
file.f_ramax = ra->p_ramax;
file.f_raend = ra->p_raend;
file.f_ralen = ra->p_ralen;
file.f_rawin = ra->p_rawin;
}
file.f_pos = offset;
oldfs = get_fs(); set_fs(KERNEL_DS);
err = file.f_op->read(&file, buf, *count, &file.f_pos);
set_fs(oldfs);
/* Write back readahead params */
if (ra != NULL) {
dprintk("nfsd: raparms %ld %ld %ld %ld %ld\n",
file.f_reada, file.f_ramax, file.f_raend,
file.f_ralen, file.f_rawin);
ra->p_reada = file.f_reada;
ra->p_ramax = file.f_ramax;
ra->p_raend = file.f_raend;
ra->p_ralen = file.f_ralen;
ra->p_rawin = file.f_rawin;
ra->p_count -= 1;
}
if (err >= 0) {
*count = err;
err = 0;
} else
err = nfserrno(-err);
out_close:
nfsd_close(&file);
out:
return err;
}
/*
* Write data to a file.
* The stable flag requests synchronous writes.
* N.B. After this call fhp needs an fh_put
*/
int
nfsd_write(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t offset,
char *buf, unsigned long cnt, int stable)
{
struct svc_export *exp;
struct file file;
struct dentry *dentry;
struct inode *inode;
mm_segment_t oldfs;
int err = 0;
#ifdef CONFIG_QUOTA
uid_t saved_euid;
#endif
if (!cnt)
goto out;
err = nfsd_open(rqstp, fhp, S_IFREG, OPEN_WRITE, &file);
if (err)
goto out;
err = nfserr_perm;
if (!file.f_op->write)
goto out_close;
dentry = file.f_dentry;
inode = dentry->d_inode;
exp = fhp->fh_export;
/*
* Request sync writes if
* - the sync export option has been set, or
* - the client requested O_SYNC behavior (NFSv3 feature).
* When gathered writes have been configured for this volume,
* flushing the data to disk is handled separately below.
*/
if ((stable || (stable = EX_ISSYNC(exp))) && !EX_WGATHER(exp))
file.f_flags |= O_SYNC;
fh_lock(fhp); /* lock inode */
file.f_pos = offset; /* set write offset */
/* Write the data. */
oldfs = get_fs(); set_fs(KERNEL_DS);
#ifdef CONFIG_QUOTA
/* This is for disk quota. */
saved_euid = current->euid;
current->euid = current->fsuid;
err = file.f_op->write(&file, buf, cnt, &file.f_pos);
current->euid = saved_euid;
#else
err = file.f_op->write(&file, buf, cnt, &file.f_pos);
#endif
set_fs(oldfs);
/* clear setuid/setgid flag after write */
if (err >= 0 && (inode->i_mode & (S_ISUID | S_ISGID))) {
struct iattr ia;
kernel_cap_t saved_cap;
ia.ia_valid = ATTR_MODE;
ia.ia_mode = inode->i_mode & ~(S_ISUID | S_ISGID);
if (current->fsuid != 0) {
saved_cap = current->cap_effective;
cap_clear(current->cap_effective);
}
notify_change(dentry, &ia);
if (current->fsuid != 0)
current->cap_effective = saved_cap;
}
fh_unlock(fhp); /* unlock inode */
if (err >= 0 && stable) {
static unsigned long last_ino = 0;
static kdev_t last_dev = NODEV;
/*
* Gathered writes: If another process is currently
* writing to the file, there's a high chance
* this is another nfsd (triggered by a bulk write
* from a client's biod). Rather than syncing the
* file with each write request, we sleep for 10 msec.
*
* I don't know if this roughly approximates
* C. Juszak's idea of gathered writes, but it's a
* nice and simple solution (IMHO), and it seems to
* work:-)
*/
if (EX_WGATHER(exp) && (inode->i_writecount > 1
|| (last_ino == inode->i_ino && last_dev == inode->i_dev))) {
#if 0
interruptible_sleep_on_timeout(&inode->i_wait, 10 * HZ / 1000);
#else
dprintk("nfsd: write defer %d\n", current->pid);
schedule_timeout((HZ+99)/100);
dprintk("nfsd: write resume %d\n", current->pid);
#endif
}
if (inode->i_state & I_DIRTY) {
dprintk("nfsd: write sync %d\n", current->pid);
nfsd_sync(inode, &file);
write_inode_now(inode);
}
wake_up(&inode->i_wait);
last_ino = inode->i_ino;
last_dev = inode->i_dev;
}
dprintk("nfsd: write complete\n");
if (err >= 0)
err = 0;
else
err = nfserrno(-err);
out_close:
nfsd_close(&file);
out:
return err;
}
/*
* Read entries from a directory.
*/
int
nfsd_readdir(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t offset,
encode_dent_fn func, u32 *buffer, int *countp)
{
struct inode *inode;
u32 *p;
int oldlen, eof, err;
struct file file;
struct readdir_cd cd;
err = 0;
if (offset > ~(u32) 0)
goto out;
err = nfsd_open(rqstp, fhp, S_IFDIR, OPEN_READ, &file);
if (err)
goto out;
err = nfserr_notdir;
if (!file.f_op->readdir)
goto out_close;
file.f_pos = offset;
/* Set up the readdir context */
memset(&cd, 0, sizeof(cd));
cd.rqstp = rqstp;
cd.buffer = buffer;
cd.buflen = *countp; /* count of words */
/*
* Read the directory entries. This silly loop is necessary because
* readdir() is not guaranteed to fill up the entire buffer, but
* may choose to do less.
*/
inode = file.f_dentry->d_inode;
while (1) {
oldlen = cd.buflen;
/*
dprintk("nfsd: f_op->readdir(%x/%ld @ %d) buflen = %d (%d)\n",
file.f_inode->i_dev, file.f_inode->i_ino,
(int) file.f_pos, (int) oldlen, (int) cd.buflen);
*/
down(&inode->i_sem);
err = file.f_op->readdir(&file, &cd, (filldir_t) func);
up(&inode->i_sem);
if (err < 0)
goto out_nfserr;
if (oldlen == cd.buflen)
break;
if (cd.eob)
break;
}
/* If we didn't fill the buffer completely, we're at EOF */
eof = !cd.eob;
if (cd.offset)
*cd.offset = htonl(file.f_pos);
p = cd.buffer;
*p++ = 0; /* no more entries */
*p++ = htonl(eof); /* end of directory */
*countp = (caddr_t) p - (caddr_t) buffer;
dprintk("nfsd: readdir result %d bytes, eof %d offset %ld\n",
*countp, eof,
cd.offset? ntohl(*cd.offset) : -1);
err = 0;
out_close:
nfsd_close(&file);
out:
return err;
out_nfserr:
err = nfserrno(-err);
goto out_close;
}
