src/afs/FBSD/osi_file.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <afsconfig.h>
  11 #include "afs/param.h"
  12
  13
  14 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  15 #include "afsincludes.h"        /* Afs-based standard headers */
  16 #include "afs/afs_stats.h"      /* afs statistics */
  17
  18
  19 int afs_osicred_initialized = 0;
  20 #ifndef AFS_FBSD80_ENV  /* cr_groups is now malloc()'d */
  21 afs_ucred_t afs_osi_cred;
  22 #endif
  23 extern struct osi_dev cacheDev;
  24 extern struct mount *afs_cacheVfsp;
  25
  26
  27 void *
  28 osi_UFSOpen(afs_dcache_id_t *ainode)
  29 {
  30     struct osi_file *afile;
  31     struct vnode *vp;
  32     extern int cacheDiskType;
  33     afs_int32 code;
  34
  35     AFS_STATCNT(osi_UFSOpen);
  36     if (cacheDiskType != AFS_FCACHE_TYPE_UFS)
  37         osi_Panic("UFSOpen called for non-UFS cache\n");
  38     afile = osi_AllocSmallSpace(sizeof(struct osi_file));
  39     AFS_GUNLOCK();
  40     code = VFS_VGET(afs_cacheVfsp, (ino_t) ainode->ufs, LK_EXCLUSIVE, &vp);
  41     AFS_GLOCK();
  42     if (code == 0 && vp->v_type == VNON)
  43         code = ENOENT;
  44     if (code) {
  45         osi_FreeSmallSpace(afile);
  46         osi_Panic("UFSOpen: igetinode failed");
  47     }
  48 #if defined(AFS_FBSD80_ENV)
  49     VOP_UNLOCK(vp, 0);
  50 #else
  51     VOP_UNLOCK(vp, 0, curthread);
  52 #endif
  53     afile->vnode = vp;
  54     afile->size = VTOI(vp)->i_size;
  55     afile->offset = 0;
  56     afile->proc = NULL;
  57     return (void *)afile;
  58 }
  59
  60 int
  61 afs_osi_Stat(struct osi_file *afile, struct osi_stat *astat)
  62 {
  63     afs_int32 code;
  64     struct vattr tvattr;
  65     AFS_STATCNT(osi_Stat);
  66     AFS_GUNLOCK();
  67 #if defined(AFS_FBSD80_ENV)
  68     vn_lock(afile->vnode, LK_EXCLUSIVE | LK_RETRY);
  69     code = VOP_GETATTR(afile->vnode, &tvattr, afs_osi_credp);
  70     VOP_UNLOCK(afile->vnode, 0);
  71 #else
  72     vn_lock(afile->vnode, LK_EXCLUSIVE | LK_RETRY, curthread);
  73     code = VOP_GETATTR(afile->vnode, &tvattr, afs_osi_credp, curthread);
  74     VOP_UNLOCK(afile->vnode, LK_EXCLUSIVE, curthread);
  75 #endif
  76     AFS_GLOCK();
  77     if (code == 0) {
  78         astat->size = tvattr.va_size;
  79         astat->mtime = tvattr.va_mtime.tv_sec;
  80         astat->atime = tvattr.va_atime.tv_sec;
  81     }
  82     return code;
  83 }
  84
  85 int
  86 osi_UFSClose(struct osi_file *afile)
  87 {
  88     AFS_STATCNT(osi_Close);
  89     if (afile->vnode) {
  90         AFS_RELE(afile->vnode);
  91     }
  92
  93     osi_FreeSmallSpace(afile);
  94     return 0;
  95 }
  96
  97 int
  98 osi_UFSTruncate(struct osi_file *afile, afs_int32 asize)
  99 {
 100     struct vattr tvattr;
 101     struct vnode *vp;
 102     afs_int32 code, glocked;
 103     AFS_STATCNT(osi_Truncate);
 104
 105     vp = afile->vnode;
 106     /*
 107      * This routine only shrinks files, and most systems
 108      * have very slow truncates, even when the file is already
 109      * small enough.  Check now and save some time.
 110      */
 111     glocked = ISAFS_GLOCK();
 112     if (glocked)
 113       AFS_GUNLOCK();
 114 #if defined(AFS_FBSD80_ENV)
 115     vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 116     code = VOP_GETATTR(afile->vnode, &tvattr, afs_osi_credp);
 117 #else
 118     vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, curthread);
 119     code = VOP_GETATTR(afile->vnode, &tvattr, afs_osi_credp, curthread);
 120 #endif
 121     if (code != 0 || tvattr.va_size <= asize)
 122         goto out;
 123
 124     VATTR_NULL(&tvattr);
 125     tvattr.va_size = asize;
 126 #if defined(AFS_FBSD80_ENV)
 127     code = VOP_SETATTR(vp, &tvattr, afs_osi_credp);
 128 #else
 129     code = VOP_SETATTR(vp, &tvattr, afs_osi_credp, curthread);
 130 #endif
 131
 132 out:
 133 #if defined(AFS_FBSD80_ENV)
 134     VOP_UNLOCK(vp, 0);
 135 #else
 136     VOP_UNLOCK(vp, LK_EXCLUSIVE, curthread);
 137 #endif
 138     if (glocked)
 139       AFS_GLOCK();
 140     return code;
 141 }
 142
 143 void
 144 osi_DisableAtimes(struct vnode *avp)
 145 {
 146     struct inode *ip = VTOI(avp);
 147     ip->i_flag &= ~IN_ACCESS;
 148 }
 149
 150
 151 /* Generic read interface */
 152 int
 153 afs_osi_Read(struct osi_file *afile, int offset, void *aptr,
 154              afs_int32 asize)
 155 {
 156 #if (__FreeBSD_version >= 900505 && __FreeBSD_Version < 1000000) ||__FreeBSD_version >= 1000009
 157     ssize_t resid;
 158 #else
 159     int resid;
 160 #endif
 161     afs_int32 code;
 162     AFS_STATCNT(osi_Read);
 163
 164     /**
 165       * If the osi_file passed in is NULL, panic only if AFS is not shutting
 166       * down. No point in crashing when we are already shutting down
 167       */
 168     if (!afile) {
 169         if (afs_shuttingdown == AFS_RUNNING)
 170             osi_Panic("osi_Read called with null param");
 171         else
 172             return -EIO;
 173     }
 174
 175     if (offset != -1)
 176         afile->offset = offset;
 177     AFS_GUNLOCK();
 178     code =
 179         gop_rdwr(UIO_READ, afile->vnode, (caddr_t) aptr, asize, afile->offset,
 180                  AFS_UIOSYS, IO_UNIT, afs_osi_credp, &resid);
 181     AFS_GLOCK();
 182     if (code == 0) {
 183         code = asize - resid;
 184         afile->offset += code;
 185         osi_DisableAtimes(afile->vnode);
 186     } else {
 187         afs_Trace2(afs_iclSetp, CM_TRACE_READFAILED, ICL_TYPE_INT32, (int)resid,
 188                    ICL_TYPE_INT32, code);
 189         if (code > 0) {
 190             code = -code;
 191         }
 192     }
 193     return code;
 194 }
 195
 196 /* Generic write interface */
 197 int
 198 afs_osi_Write(struct osi_file *afile, afs_int32 offset, void *aptr,
 199               afs_int32 asize)
 200 {
 201 #if (__FreeBSD_version >= 900505 && __FreeBSD_Version < 1000000) ||__FreeBSD_version >= 1000009
 202     ssize_t resid;
 203 #else
 204     int resid;
 205 #endif
 206     afs_int32 code;
 207     AFS_STATCNT(osi_Write);
 208     if (!afile)
 209         osi_Panic("afs_osi_Write called with null param");
 210     if (offset != -1)
 211         afile->offset = offset;
 212     {
 213         AFS_GUNLOCK();
 214         code =
 215             gop_rdwr(UIO_WRITE, afile->vnode, (caddr_t) aptr, asize,
 216                      afile->offset, AFS_UIOSYS, IO_UNIT, afs_osi_credp,
 217                      &resid);
 218         AFS_GLOCK();
 219     }
 220     if (code == 0) {
 221         code = asize - resid;
 222         afile->offset += code;
 223     } else {
 224         if (code > 0) {
 225             code = -code;
 226         }
 227     }
 228     if (afile->proc) {
 229         (*afile->proc) (afile, code);
 230     }
 231     return code;
 232 }
 233
 234
 235 /*  This work should be handled by physstrat in ca/machdep.c.
 236     This routine written from the RT NFS port strategy routine.
 237     It has been generalized a bit, but should still be pretty clear. */
 238 int
 239 afs_osi_MapStrategy(int (*aproc) (), struct buf *bp)
 240 {
 241     afs_int32 returnCode;
 242
 243     AFS_STATCNT(osi_MapStrategy);
 244     returnCode = (*aproc) (bp);
 245
 246     return returnCode;
 247 }
 248
 249
 250
 251 void
 252 shutdown_osifile(void)
 253 {
 254     AFS_STATCNT(shutdown_osifile);
 255     if (afs_cold_shutdown) {
 256         afs_osicred_initialized = 0;
 257     }
 258 }