int hsi_nfs3_rmdir (struct hsfs_inode *parent, const char *name)
{
struct hsfs_super *sb = parent->sb;
int err = 0;
diropargs3 argp;
wccstat3 clnt_res;
DEBUG_IN(" ino:%lu.\n", parent->ino);
memset (&argp, 0, sizeof(diropargs3));
memset (&clnt_res, 0, sizeof(wccstat3));
argp.dir.data.data_len = parent->fh.data.data_len;
argp.dir.data.data_val = parent->fh.data.data_val;
argp.name = (char *) name;
err = hsi_nfs3_clnt_call (sb, sb->clntp, NFSPROC3_RMDIR,
(xdrproc_t) xdr_diropargs3, (caddr_t) &argp,
(xdrproc_t) xdr_wccstat3, (caddr_t) &clnt_res);
if (0 != err)
goto out;
err = hsi_nfs3_stat_to_errno(clnt_res.status); /*nfs error.*/
clnt_freeres(sb->clntp, (xdrproc_t)xdr_wccstat3, (char *)&clnt_res);
out:
DEBUG_OUT(" out, errno is(%d)\n", err);
return err;
};
int hsi_nfs3_access(struct hsfs_inode *hi, int mask)
{
struct access3args args;
struct access3res res;
CLIENT *clntp = NULL;
int status = 0;
DEBUG_IN("MASK = %d", mask);
memset(&args, 0, sizeof(struct access3args));
memset(&res, 0, sizeof(struct access3res));
hsi_nfs3_getfh3(hi, &args.object);
args.access = mask & FULL_ACCESS;
clntp = hi->sb->clntp;
status = hsi_nfs3_clnt_call(hi->sb, clntp, NFSPROC3_ACCESS,
(xdrproc_t)xdr_access3args, (caddr_t)&args,
(xdrproc_t)xdr_access3res, (caddr_t)&res);
if (status)
goto out;
status = hsi_nfs3_stat_to_errno(res.status);
out:
clnt_freeres(clntp, (xdrproc_t)xdr_access3res, (caddr_t)&res);
DEBUG_OUT("Out of hsi_nfs3_access, with STATUS = %d", status);
return status;
}
int hsi_nfs3_rename(struct hsfs_inode *parent, const char *name,
struct hsfs_inode *newparent, const char *newname)
{
int ret = 0;
int err = 0;
struct hsfs_super *sb = parent->sb;
CLIENT *clntp = sb->clntp;
rename3args args;
rename3res res;
DEBUG_IN(" %s to %s", name, newname);
memset(&args, 0, sizeof(args));
memset(&res, 0, sizeof(res));
hsi_nfs3_getfh3(parent, &args.from.dir);
hsi_nfs3_getfh3(newparent, &args.to.dir);
args.from.name = (char *)name;
args.to.name = (char *)newname;
err = hsi_nfs3_clnt_call(sb, clntp, NFSPROC3_RENAME,
(xdrproc_t)xdr_rename3args, (caddr_t)&args,
(xdrproc_t)xdr_rename3res, (caddr_t)&res);
if (err)
goto out1;
ret = res.status;
if (NFS3_OK != ret) {
ERR("Call NFS3 Server failure:(%d).\n", ret);
err = hsi_nfs3_stat_to_errno(ret);
goto out2;
}
/* if(res.rename3res_u.res.fromdir_wcc.after.present) { */
/* memcpy(&(parent->attr), &res.rename3res_u.res.fromdir_wcc. */
/* after.post_op_attr_u.attributes, */
/* sizeof(fattr3)); */
/* } */
/* if(res.rename3res_u.res.todir_wcc.after.present) { */
/* memcpy(&(newparent->attr), &res.rename3res_u.res.todir_wcc. */
/* after.post_op_attr_u.attributes, */
/* sizeof(fattr3)); */
/* } */
out2:
clnt_freeres(clntp, (xdrproc_t)xdr_rename3res, (char *)&res);
out1:
DEBUG_OUT(" %s to %s errno:%d", name, newname, err);
return err;
}
int hsi_nfs3_statfs (struct hsfs_inode *inode)
{
struct hsfs_super *sb = inode->sb;
struct fsstat3res res;
struct fsstat3resok resok;
struct nfs_fh3 fh;
int st = 0;
memset (&res, 0, sizeof(res));
memset (&fh, 0, sizeof(fh));
memset (&resok, 0, sizeof(resok));
hsi_nfs3_getfh3(inode, &fh);
DEBUG_IN("I(%p:%lu)", inode, inode->ino);
st = hsi_nfs3_clnt_call (sb, sb->clntp, NFSPROC3_FSSTAT,
(xdrproc_t)xdr_nfs_fh3, (caddr_t)&fh,
(xdrproc_t)xdr_fsstat3res, (caddr_t)&res);
if (st)
goto out;
st = res.status;
if (NFS3_OK != st){
st = hsi_nfs3_stat_to_errno (st);
ERR ("rpc request failed: %d\n",st);
clnt_freeres (sb->clntp, (xdrproc_t)xdr_fsstat3res,(char *)&res);
goto out;
}
resok = res.fsstat3res_u.resok;
inode->sb->tbytes = resok.tbytes;
inode->sb->fbytes = resok.fbytes;
inode->sb->abytes = resok.abytes;
inode->sb->tfiles = resok.tfiles;
inode->sb->ffiles = resok.ffiles;
inode->sb->afiles = resok.afiles;
clnt_freeres (sb->clntp, (xdrproc_t)xdr_fsstat3res,(char *)&res);
out:
DEBUG_OUT ("(%d)",st);
return st;
}
int hsi_nfs3_do_getattr(struct hsfs_super *sb, struct nfs_fh3 *fh,
struct nfs_fattr *fattr, struct stat *st)
{
struct getattr3res res;
struct fattr3 *attr = NULL;
int err;
DEBUG_IN("(%p, %p, %p, %p)", sb, fh, fattr, st);
memset(&res, 0, sizeof(res));
err = hsi_nfs3_clnt_call(sb, sb->clntp, NFSPROC3_GETATTR,
(xdrproc_t)xdr_nfs_fh3, (caddr_t)fh,
(xdrproc_t)xdr_getattr3res, (caddr_t)&res);
if (err)
goto out_no_free;
if (NFS3_OK != res.status) {
err = hsi_nfs3_stat_to_errno(res.status);
ERR("RPC Server returns failed status : %d.\n", err);
goto out;
}
attr = &res.getattr3res_u.attributes;
if (fattr){
hsi_nfs3_fattr2fattr(attr, fattr);
DEBUG("get nfs_fattr(V:%x, U:%u, G:%u, S:%llu, I:%llu)",
fattr->valid, fattr->uid, fattr->gid, fattr->size, fattr->fileid);
}
if (st)
hsi_nfs3_fattr2stat(attr, st);
out:
clnt_freeres(sb->clntp, (xdrproc_t)xdr_getattr3res, (char *)&res);
out_no_free:
DEBUG_OUT("with errno %d.\n", err);
return err;
}
int hsi_nfs3_setattr(struct hsfs_inode *inode, struct hsfs_sattr *attr)
{
int err = 0;
CLIENT *clntp = NULL;
struct setattr3args args;
struct wccstat3 res;
struct fattr3 *fattr = NULL;
DEBUG_IN("%s", "\n");
clntp= inode->sb->clntp;
memset(&args, 0, sizeof(args));
args.object.data.data_len = inode->fh.data.data_len;
args.object.data.data_val = inode->fh.data.data_val;
if (S_ISSETMODE(attr->valid)) {
args.new_attributes.mode.set = TRUE;
args.new_attributes.mode.set_uint32_u.val = attr->mode;
}
else
args.new_attributes.mode.set = FALSE;
if (S_ISSETUID(attr->valid)) {
args.new_attributes.uid.set = TRUE;
args.new_attributes.uid.set_uint32_u.val = attr->uid;
}
else
args.new_attributes.uid.set = FALSE;
if (S_ISSETGID(attr->valid)) {
args.new_attributes.gid.set = TRUE;
args.new_attributes.gid.set_uint32_u.val = attr->gid;
}
else
args.new_attributes.gid.set = FALSE;
if (S_ISSETSIZE(attr->valid)) {
args.new_attributes.size.set = TRUE;
args.new_attributes.size.set_uint64_u.val = attr->size;
}
else
args.new_attributes.size.set = FALSE;
if (S_ISSETATIME(attr->valid)) {
args.new_attributes.atime.set = SET_TO_CLIENT_TIME;
args.new_attributes.atime.set_time_u.time.seconds = attr->atime.tv_sec;
args.new_attributes.atime.set_time_u.time.nseconds = attr->atime.tv_nsec;
}
else
args.new_attributes.atime.set = DONT_CHANGE;
if (S_ISSETMTIME(attr->valid)) {
args.new_attributes.mtime.set = SET_TO_CLIENT_TIME;
args.new_attributes.mtime.set_time_u.time.seconds = attr->mtime.tv_sec;
args.new_attributes.mtime.set_time_u.time.nseconds = attr->mtime.tv_nsec;
}
else
args.new_attributes.mtime.set = DONT_CHANGE;
if (S_ISSETATIMENOW(attr->valid))
args.new_attributes.atime.set = SET_TO_SERVER_TIME;
if (S_ISSETMTIMENOW(attr->valid))
args.new_attributes.mtime.set = SET_TO_SERVER_TIME;
args.guard.check = FALSE;
memset(&res, 0, sizeof(res));
err = hsi_nfs3_clnt_call(inode->sb, clntp, NFSPROC3_SETATTR,
(xdrproc_t)xdr_setattr3args, (caddr_t)&args,
(xdrproc_t)xdr_wccstat3, (caddr_t)&res);
if (err)
goto out_no_free;
if (NFS3_OK != res.status) {
err = hsi_nfs3_stat_to_errno(res.status);
ERR("RPC Server returns failed status : %d.\n", err);
goto out;
}
if (!res.wccstat3_u.wcc.after.present) {
err = EAGAIN;
ERR("Try again to set file attributes.\n");
goto out;
}
fattr = &res.wccstat3_u.wcc.after.post_op_attr_u.attributes;
inode->attr.type = fattr->type;
inode->attr.mode = fattr->mode;
inode->attr.nlink = fattr->nlink;
inode->attr.uid = fattr->uid;
inode->attr.gid = fattr->gid;
inode->attr.size = fattr->size;
inode->attr.used = fattr->used;
inode->attr.rdev.major = fattr->rdev.major;
inode->attr.rdev.minor = fattr->rdev.minor;
inode->attr.fsid = fattr->fsid;
inode->attr.fileid = fattr->fileid;
inode->attr.atime.seconds = fattr->atime.seconds;
inode->attr.atime.nseconds = fattr->atime.nseconds;
inode->attr.mtime.seconds = fattr->mtime.seconds;
inode->attr.mtime.nseconds = fattr->mtime.nseconds;
inode->attr.ctime.seconds = fattr->ctime.seconds;
inode->attr.ctime.nseconds = fattr->ctime.nseconds;
out:
clnt_freeres(clntp, (xdrproc_t)xdr_wccstat3, (char *)&res);
out_no_free:
DEBUG_OUT("with errno : %d.\n", err);
return err;
}
