int
osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
{
afs_ucred_t *oldCred;
struct vattr tvattr;
afs_int32 code;
struct osi_stat tstat;
AFS_STATCNT(osi_Truncate);
/* This routine only shrinks files, and most systems
* have very slow truncates, even when the file is already
* small enough. Check now and save some time.
*/
code = afs_osi_Stat(afile, &tstat);
if (code || tstat.size <= asize)
return code;
ObtainWriteLock(&afs_xosi, 321);
AFS_GUNLOCK();
#ifdef AFS_DARWIN80_ENV
VATTR_INIT(&tvattr);
VATTR_SET(&tvattr, va_size, asize);
code = vnode_setattr(afile->vnode, &tvattr, afs_osi_ctxtp);
#else
VATTR_NULL(&tvattr);
tvattr.va_size = asize;
code = VOP_SETATTR(afile->vnode, &tvattr, &afs_osi_cred, current_proc());
#endif
AFS_GLOCK();
ReleaseWriteLock(&afs_xosi);
return code;
}
int
osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
{
afs_ucred_t *oldCred;
struct vattr tvattr;
afs_int32 code;
struct osi_stat tstat;
mon_state_t ms;
AFS_STATCNT(osi_Truncate);
/* This routine only shrinks files, and most systems
* have very slow truncates, even when the file is already
* small enough. Check now and save some time.
*/
code = afs_osi_Stat(afile, &tstat);
if (code || tstat.size <= asize)
return code;
ObtainWriteLock(&afs_xosi, 321);
AFS_GUNLOCK();
tvattr.va_mask = AT_SIZE;
tvattr.va_size = asize;
AFS_VOP_SETATTR(afile->vnode, &tvattr, 0, &afs_osi_cred, code);
AFS_GLOCK();
ReleaseWriteLock(&afs_xosi);
return code;
}
int
osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
{
afs_ucred_t *oldCred;
struct vattr tvattr;
afs_int32 code;
struct osi_stat tstat;
AFS_STATCNT(osi_Truncate);
/* This routine only shrinks files, and most systems
* have very slow truncates, even when the file is already
* small enough. Check now and save some time.
*/
code = afs_osi_Stat(afile, &tstat);
if (code || tstat.size <= asize)
return code;
ObtainWriteLock(&afs_xosi, 321);
VATTR_NULL(&tvattr);
/* note that this credential swapping stuff is only necessary because
* of ufs's references directly to u.u_cred instead of to
* credentials parameter. Probably should fix ufs some day. */
oldCred = p_cred(u.u_procp);
set_p_cred(u.u_procp, &afs_osi_cred);
tvattr.va_size = asize;
AFS_GUNLOCK();
code = VOP_SETATTR(afile->vnode, &tvattr, &afs_osi_cred, 0);
AFS_GLOCK();
set_p_cred(u.u_procp, oldCred); /* restore */
ReleaseWriteLock(&afs_xosi);
return code;
}
int
osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
{
afs_ucred_t *oldCred;
struct vattr tvattr;
afs_int32 code;
struct osi_stat tstat;
afs_int32 mode = FWRITE | FSYNC;
AFS_STATCNT(osi_Truncate);
/* This routine only shrinks files, and most systems
* have very slow truncates, even when the file is already
* small enough. Check now and save some time.
*/
code = afs_osi_Stat(afile, &tstat);
if (code || tstat.size <= asize)
return code;
ObtainWriteLock(&afs_xosi, 321);
/*
* If we're truncating an unopened file to a non-zero length,
* we need to bind it to a vm segment
* Note that that the binding will actually happen inside
* jfs by xix_ftrunc; setting mode to 0 will enable that.
*/
if (asize && !VTOGP(afile->vnode)->gn_seg)
mode = 0;
AFS_GUNLOCK();
code = VNOP_FTRUNC(afile->vnode, mode, asize, (caddr_t) 0, &afs_osi_cred);
AFS_GLOCK();
ReleaseWriteLock(&afs_xosi);
return code;
}
int
osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
{
struct vattr tvattr;
afs_int32 code;
struct osi_stat tstat;
AFS_STATCNT(osi_Truncate);
/*
* This routine only shrinks files, and most systems
* have very slow truncates, even when the file is already
* small enough. Check now and save some time.
*/
code = afs_osi_Stat(afile, &tstat);
if (code || tstat.size <= asize)
return code;
ObtainWriteLock(&afs_xosi, 321);
VATTR_NULL(&tvattr);
tvattr.va_size = asize;
AFS_GUNLOCK();
VOP_LOCK(afile->vnode, LK_EXCLUSIVE | LK_RETRY, curproc);
code = VOP_SETATTR(afile->vnode, &tvattr, afs_osi_credp, curproc);
VOP_UNLOCK(afile->vnode, 0, curproc);
AFS_GLOCK();
if (code == 0)
afile->size = asize;
ReleaseWriteLock(&afs_xosi);
return code;
}
int
osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
{
afs_ucred_t *oldCred;
struct vattr tvattr;
afs_int32 code;
struct osi_stat tstat;
AFS_STATCNT(osi_Truncate);
/* This routine only shrinks files, and most systems
* have very slow truncates, even when the file is already
* small enough. Check now and save some time.
*/
code = afs_osi_Stat(afile, &tstat);
if (code || tstat.size <= asize)
return code;
ObtainWriteLock(&afs_xosi, 321);
tvattr.va_mask = AT_SIZE;
tvattr.va_size = asize;
/*
* The only time a flag is used (ATTR_UTIME) is when we're changing the time
*/
AFS_GUNLOCK();
#ifdef AFS_SUN510_ENV
code = VOP_SETATTR(afile->vnode, &tvattr, 0, afs_osi_credp, NULL);
#else
code = VOP_SETATTR(afile->vnode, &tvattr, 0, afs_osi_credp);
#endif
AFS_GLOCK();
ReleaseWriteLock(&afs_xosi);
return code;
}
int
osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
{
afs_int32 code;
struct osi_stat tstat;
struct iattr newattrs;
struct inode *inode = OSIFILE_INODE(afile);
AFS_STATCNT(osi_Truncate);
/* This routine only shrinks files, and most systems
* have very slow truncates, even when the file is already
* small enough. Check now and save some time.
*/
code = afs_osi_Stat(afile, &tstat);
if (code || tstat.size <= asize)
return code;
ObtainWriteLock(&afs_xosi, 321);
AFS_GUNLOCK();
afs_linux_lock_inode(inode);
#ifdef STRUCT_INODE_HAS_I_ALLOC_SEM
down_write(&inode->i_alloc_sem);
#endif
newattrs.ia_size = asize;
newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
newattrs.ia_ctime = CURRENT_TIME;
/* avoid notify_change() since it wants to update dentry->d_parent */
#ifdef HAVE_LINUX_SETATTR_PREPARE
code = setattr_prepare(file_dentry(afile->filp), &newattrs);
#else
code = inode_change_ok(inode, &newattrs);
#endif
if (!code)
code = afs_inode_setattr(afile, &newattrs);
if (!code)
truncate_inode_pages(&inode->i_data, asize);
code = -code;
#ifdef STRUCT_INODE_HAS_I_ALLOC_SEM
up_write(&inode->i_alloc_sem);
#endif
afs_linux_unlock_inode(inode);
AFS_GLOCK();
ReleaseWriteLock(&afs_xosi);
return code;
}
void *
osi_UFSOpen(afs_dcache_id_t *ainode)
{
struct vnode *vp;
struct vattr va;
struct osi_file *afile = NULL;
extern int cacheDiskType;
afs_int32 code = 0;
int dummy;
char fname[1024];
struct osi_stat tstat;
AFS_STATCNT(osi_UFSOpen);
if (cacheDiskType != AFS_FCACHE_TYPE_UFS) {
osi_Panic("UFSOpen called for non-UFS cache\n");
}
if (!afs_osicred_initialized) {
/* valid for alpha_osf, SunOS, Ultrix */
memset(&afs_osi_cred, 0, sizeof(afs_ucred_t));
afs_osi_cred.cr_ref++;
#ifndef AFS_DARWIN110_ENV
afs_osi_cred.cr_ngroups = 1;
#endif
afs_osicred_initialized = 1;
}
afile = (struct osi_file *)osi_AllocSmallSpace(sizeof(struct osi_file));
AFS_GUNLOCK();
#ifdef AFS_CACHE_VNODE_PATH
if (!ainode->ufs) {
osi_Panic("No cache inode\n");
}
code = vnode_open(ainode->ufs, O_RDWR, 0, 0, &vp, afs_osi_ctxtp);
#else
#ifndef AFS_DARWIN80_ENV
if (afs_CacheFSType == AFS_APPL_HFS_CACHE)
code = igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, &ainode->ufs, &vp, &va, &dummy); /* XXX hfs is broken */
else if (afs_CacheFSType == AFS_APPL_UFS_CACHE)
#endif
code =
igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, (ino_t) ainode->ufs,
&vp, &va, &dummy);
#ifndef AFS_DARWIN80_ENV
else
panic("osi_UFSOpen called before cacheops initialized\n");
#endif
#endif
AFS_GLOCK();
if (code) {
osi_FreeSmallSpace(afile);
osi_Panic("UFSOpen: igetinode failed");
}
afile->vnode = vp;
afile->offset = 0;
afile->proc = (int (*)())0;
#ifndef AFS_CACHE_VNODE_PATH
afile->size = va.va_size;
#else
code = afs_osi_Stat(afile, &tstat);
afile->size = tstat.size;
#endif
return (void *)afile;
}
int
osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
{
afs_int32 code;
struct osi_stat tstat;
struct iattr newattrs;
struct inode *inode = OSIFILE_INODE(afile);
AFS_STATCNT(osi_Truncate);
/* This routine only shrinks files, and most systems
* have very slow truncates, even when the file is already
* small enough. Check now and save some time.
*/
code = afs_osi_Stat(afile, &tstat);
if (code || tstat.size <= asize)
return code;
ObtainWriteLock(&afs_xosi, 321);
AFS_GUNLOCK();
#ifdef STRUCT_INODE_HAS_I_ALLOC_SEM
down_write(&inode->i_alloc_sem);
#endif
#ifdef STRUCT_INODE_HAS_I_MUTEX
mutex_lock(&inode->i_mutex);
#else
down(&inode->i_sem);
#endif
newattrs.ia_size = asize;
newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
#if defined(AFS_LINUX24_ENV)
newattrs.ia_ctime = CURRENT_TIME;
/* avoid notify_change() since it wants to update dentry->d_parent */
lock_kernel();
code = inode_change_ok(inode, &newattrs);
if (!code) {
#ifdef INODE_SETATTR_NOT_VOID
code = inode_setattr(inode, &newattrs);
#else
inode_setattr(inode, &newattrs);
#endif
}
unlock_kernel();
if (!code)
truncate_inode_pages(&inode->i_data, asize);
#else
i_size_write(inode, asize);
if (inode->i_sb->s_op && inode->i_sb->s_op->notify_change) {
code = inode->i_sb->s_op->notify_change(&afile->dentry, &newattrs);
}
if (!code) {
truncate_inode_pages(inode, asize);
if (inode->i_op && inode->i_op->truncate)
inode->i_op->truncate(inode);
}
#endif
code = -code;
#ifdef STRUCT_INODE_HAS_I_MUTEX
mutex_unlock(&inode->i_mutex);
#else
up(&inode->i_sem);
#endif
#ifdef STRUCT_INODE_HAS_I_ALLOC_SEM
up_write(&inode->i_alloc_sem);
#endif
AFS_GLOCK();
ReleaseWriteLock(&afs_xosi);
return code;
}
void *
osi_UfsOpen(afs_dcache_id_t *ainode)
{
#ifdef AFS_CACHE_VNODE_PATH
struct vnode *vp;
#else
struct inode *ip;
#endif
struct osi_file *afile = NULL;
afs_int32 code = 0;
int dummy;
#ifdef AFS_CACHE_VNODE_PATH
char namebuf[1024];
struct pathname lookpn;
#endif
struct osi_stat tstat;
afile = osi_AllocSmallSpace(sizeof(struct osi_file));
AFS_GUNLOCK();
/*
* AFS_CACHE_VNODE_PATH can be used with any file system, including ZFS or tmpfs.
* The ainode is not an inode number but a path.
*/
#ifdef AFS_CACHE_VNODE_PATH
/* Can not use vn_open or lookupname, they use user's CRED()
* We need to run as root So must use low level lookuppnvp
* assume fname starts with /
*/
code = pn_get_buf(ainode->ufs, AFS_UIOSYS, &lookpn, namebuf, sizeof(namebuf));
if (code != 0)
osi_Panic("UfsOpen: pn_get_buf failed %ld %s", code, ainode->ufs);
VN_HOLD(rootdir); /* released in loopuppnvp */
code = lookuppnvp(&lookpn, NULL, FOLLOW, NULL, &vp,
rootdir, rootdir, afs_osi_credp);
if (code != 0)
osi_Panic("UfsOpen: lookuppnvp failed %ld %s", code, ainode->ufs);
#ifdef AFS_SUN511_ENV
code = VOP_OPEN(&vp, FREAD|FWRITE, afs_osi_credp, NULL);
#else
code = VOP_OPEN(&vp, FREAD|FWRITE, afs_osi_credp);
#endif
if (code != 0)
osi_Panic("UfsOpen: VOP_OPEN failed %ld %s", code, ainode->ufs);
#else
code =
igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, ainode->ufs, &ip,
CRED(), &dummy);
#endif
AFS_GLOCK();
if (code) {
osi_FreeSmallSpace(afile);
osi_Panic("UfsOpen: igetinode failed %ld %s", code, ainode->ufs);
}
#ifdef AFS_CACHE_VNODE_PATH
afile->vnode = vp;
code = afs_osi_Stat(afile, &tstat);
afile->size = tstat.size;
#else
afile->vnode = ITOV(ip);
afile->size = VTOI(afile->vnode)->i_size;
#endif
afile->offset = 0;
afile->proc = (int (*)())0;
return (void *)afile;
}
