static void serve_write(fuse_req_t req, fuse_ino_t fuse_ino, const char * buf,
size_t size, off_t off, struct fuse_file_info * fi)
{
Dprintf("%s(ino = %lu, size = %u, off = %lld)\n",
__FUNCTION__, fuse_ino, size, off);
uint32_t offset = off;
fdesc_t * fdesc;
int nbytes;
int r;
if (offset != off)
{
fprintf(stderr, "%s:%d: fstitchd offset not able to satisfy request for %lld\n", __FILE__, __LINE__, off);
r = fuse_reply_err(req, EINVAL);
fuse_reply_assert(!r);
return;
}
fdesc = fi_get_fdesc(fi);
static_assert(sizeof(uint32_t) == sizeof(size));
nbytes = CALL(reqcfs(req), write, fdesc, NULL, buf, offset, size);
if (nbytes < size)
{
r = fuse_reply_write(req, nbytes);
fuse_reply_assert(!r);
return;
}
r = fuse_reply_write(req, nbytes);
fuse_reply_assert(!r);
}
static void workspace_nfs_write(fuse_req_t req, const char *buff, size_t size, off_t offset, struct workspace_fh_struct *fh)
{
struct resource_struct *resource=fh->object->resource;
struct net_nfs_export_struct *nfs_export=(struct net_nfs_export_struct *) resource->data;
struct nfs_context *nfs_ctx=(struct nfs_context *) nfs_export->data;
struct nfsfh *nfsfh=(struct nfsfh *) fh->handle.data;
int result=0;
logoutput("workspace_nfs_write");
pthread_mutex_lock(&nfs_export->mutex);
result=nfs_pwrite(nfs_ctx, nfsfh, offset, size, (void *) (intptr_t) buff);
pthread_mutex_unlock(&nfs_export->mutex);
if (result>=0) {
fuse_reply_write(req, result);
} else {
fuse_reply_err(req, abs(result));
}
}
void blob_ll_write(fuse_req_t req, fuse_ino_t ino, const char *buf,
size_t size, off_t off, struct fuse_file_info *fi) {
blob_mirror_t *lm = (blob_mirror_t *)fi->fh;
if (lm->write(size, off, buf) != size)
fuse_reply_err(req, EIO);
else
fuse_reply_write(req, size);
}
void hsx_fuse_write(fuse_req_t req, fuse_ino_t ino, const char *buf,
size_t size, off_t off, struct fuse_file_info *fi)
{
struct hsfs_rw_info winfo;
struct hsfs_super * sb = (struct hsfs_super *)fuse_req_userdata(req);
size_t cnt = 0;
int err = 0;
char * buffer = NULL;
DEBUG_IN("offset 0x%x size 0x%x", (unsigned int)off, (unsigned int)size);
buffer = (char *) malloc(sb->wsize);
if( NULL == buffer){
err = ENOMEM;
fuse_reply_err(req, err);
goto out;
}
memset(&winfo, 0, sizeof(struct hsfs_rw_info));
if(fi->direct_io)
winfo.stable = HSFS_FILE_SYNC;
else
winfo.stable = HSFS_UNSTABLE;
if(NULL == (winfo.inode = hsfs_ilookup(sb, ino))){
err = ENOENT;
fuse_reply_err(req, err);
goto out;
}
DEBUG("ino %lu", winfo.inode->ino);
while(cnt < size){
size_t tmp_size = min(size - cnt, sb->wsize);
winfo.rw_size = tmp_size;
winfo.rw_off = off + cnt;
memcpy(buffer, buf + cnt, tmp_size);
winfo.data.data_len = tmp_size;
winfo.data.data_val = buffer;
err = hsi_nfs3_write(&winfo);
if(err){
fuse_reply_err(req, err);
goto out;
}
cnt += winfo.ret_count;
}
fuse_reply_write(req, cnt);
out:
if(NULL != buffer)
free(buffer);
DEBUG_OUT("err %d", err);
return;
}
static void cusexmp_write(fuse_req_t req, const char *buf, size_t size,
off_t off, struct fuse_file_info *fi)
{
(void)fi;
if (cusexmp_expand(off + size)) {
fuse_reply_err(req, ENOMEM);
return;
}
memcpy(cusexmp_buf + off, buf, size);
fuse_reply_write(req, size);
}
static void lfs_ll_write(fuse_req_t req, fuse_ino_t ino, const char *buf,
size_t size, off_t off, struct fuse_file_info *fi){
/*Meta_data new_blk;
//new_blk.file_name=fi->fh;
printf("%s",fi->fh);
if(ino != 1)
fuse_reply_err(req,ENOENT);
else
//pwrite(log_fp, buf, size, offset);*/
fuse_reply_write(req,fi);
}
static void
compiz_write(fuse_req_t req,
fuse_ino_t ino,
const char *buf,
size_t size,
off_t off,
struct fuse_file_info *fi)
{
FuseInode *inode;
inode = fuseFindInode(inodes, ino, WRITE_MASK);
if (inode && fi->fh)
{
FuseWriteBuffer *wb = (FuseWriteBuffer *)(uintptr_t)fi->fh;
if (off + size > wb->size)
{
char *data;
data = realloc(wb->data, off + size + 1);
if (!data)
{
fuse_reply_err(req, ENOBUFS);
return;
}
data[off + size] = '\0';
wb->data = data;
wb->size = off + size;
}
memcpy(wb->data + off, buf, size);
wb->dirty = TRUE;
fuse_reply_write(req, size);
}
else
{
fuse_reply_err(req, ENOENT);
}
}
static int zfsfuse_write(fuse_req_t req, fuse_ino_t ino, const char *buf, size_t size, off_t off, struct fuse_file_info *fi)
{
file_info_t *info = (file_info_t *)(uintptr_t) fi->fh;
vnode_t *vp = info->vp;
ASSERT(vp != NULL);
ASSERT(VTOZ(vp) != NULL);
ASSERT(VTOZ(vp)->z_id == ino);
vfs_t *vfs = (vfs_t *) fuse_req_userdata(req);
zfsvfs_t *zfsvfs = vfs->vfs_data;
ZFS_ENTER(zfsvfs);
iovec_t iovec;
uio_t uio;
uio.uio_iov = &iovec;
uio.uio_iovcnt = 1;
uio.uio_segflg = UIO_SYSSPACE;
uio.uio_fmode = 0;
uio.uio_llimit = RLIM64_INFINITY;
iovec.iov_base = (void *) buf;
iovec.iov_len = size;
uio.uio_resid = iovec.iov_len;
uio.uio_loffset = off;
cred_t cred;
zfsfuse_getcred(req, &cred);
int error = VOP_WRITE(vp, &uio, info->flags, &cred, NULL);
ZFS_EXIT(zfsvfs);
if(!error) {
/* When not using direct_io, we must always write 'size' bytes */
VERIFY(uio.uio_resid == 0);
fuse_reply_write(req, size - uio.uio_resid);
}
return error;
}
static void lfs_ll_create(fuse_req_t req, fuse_ino_t parent, const char *name,
mode_t mode, struct fuse_file_info *fi){
/* Meta_data new_blk;
time_t created_t;
//new_blk.file_name=fi->fh;
struct tm *ts;
char buf[80];
created_t = time(NULL);
tsm = localtime(&created_t);
strftime(buf1, sizeof(buf), "%a %Y-%m-%d %H:%M:%S %Z", ts);
printf("%s",fi->fh);
if(ino != 1)
fuse_reply_err(req,ENOENT);
else
//pwrite(log_fp, buf, size, offset);*/
fuse_reply_write(req,fi);
}
void mfs_meta_read(fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, struct fuse_file_info *fi) {
pathbuf *pathinfo = (pathbuf *)((unsigned long)(fi->fh));
if (ino==MASTERINFO_INODE) {
uint8_t masterinfo[14];
fs_getmasterlocation(masterinfo);
masterproxy_getlocation(masterinfo);
#ifdef MASTERINFO_WITH_VERSION
if (off>=14) {
fuse_reply_buf(req,NULL,0);
} else if (off+size>14) {
fuse_reply_buf(req,(char*)(masterinfo+off),14-off);
#else
if (off>=10) {
fuse_reply_buf(req,NULL,0);
} else if (off+size>10) {
fuse_reply_buf(req,(char*)(masterinfo+off),10-off);
#endif
} else {
fuse_reply_buf(req,(char*)(masterinfo+off),size);
}
return;
}
if (pathinfo==NULL) {
fuse_reply_err(req,EBADF);
return;
}
// if (ino==MASTER_INODE) {
// minfo *masterinfo = (minfo*)(unsigned long)(fi->fh);
// if (masterinfo->sent) {
// int rsize;
// uint8_t *buff;
// buff = malloc(size);
// rsize = fs_direct_read(masterinfo->sd,buff,size);
// fuse_reply_buf(req,(char*)buff,rsize);
//syslog(LOG_WARNING,"master received: %d/%u",rsize,size);
// free(buff);
// } else {
// syslog(LOG_WARNING,"master: read before write");
// fuse_reply_buf(req,NULL,0);
// }
// return;
// }
pthread_mutex_lock(&(pathinfo->lock));
if (off<0) {
pthread_mutex_unlock(&(pathinfo->lock));
fuse_reply_err(req,EINVAL);
return;
}
if ((size_t)off>pathinfo->size) {
fuse_reply_buf(req, NULL, 0);
} else if (off + size > pathinfo->size) {
fuse_reply_buf(req, (pathinfo->p)+off,(pathinfo->size)-off);
} else {
fuse_reply_buf(req, (pathinfo->p)+off,size);
}
pthread_mutex_unlock(&(pathinfo->lock));
}
void mfs_meta_write(fuse_req_t req, fuse_ino_t ino, const char *buf, size_t size, off_t off, struct fuse_file_info *fi) {
pathbuf *pathinfo = (pathbuf *)((unsigned long)(fi->fh));
if (ino==MASTERINFO_INODE) {
fuse_reply_err(req,EACCES);
return;
}
if (pathinfo==NULL) {
fuse_reply_err(req,EBADF);
return;
}
// if (ino==MASTER_INODE) {
// minfo *masterinfo = (minfo*)(unsigned long)(fi->fh);
// int wsize;
// masterinfo->sent=1;
// wsize = fs_direct_write(masterinfo->sd,(const uint8_t*)buf,size);
//syslog(LOG_WARNING,"master sent: %d/%u",wsize,size);
// fuse_reply_write(req,wsize);
// return;
// }
if (off + size > PATH_SIZE_LIMIT) {
fuse_reply_err(req,EINVAL);
return;
}
pthread_mutex_lock(&(pathinfo->lock));
if (pathinfo->changed==0) {
pathinfo->size = 0;
}
if (off+size > pathinfo->size) {
size_t s = pathinfo->size;
pathinfo->p = realloc(pathinfo->p,off+size);
pathinfo->size = off+size;
memset(pathinfo->p+s,0,off+size-s);
}
memcpy((pathinfo->p)+off,buf,size);
pathinfo->changed = 1;
pthread_mutex_unlock(&(pathinfo->lock));
fuse_reply_write(req,size);
}
