src/volser/physio.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 #include <roken.h>
  14
  15 #include <sys/types.h>
  16 #ifdef AFS_NT40_ENV
  17 #include <fcntl.h>
  18 #else
  19 #include <sys/file.h>
  20 #include <netinet/in.h>
  21 #include <unistd.h>
  22 #endif
  23 #include <string.h>
  24 #ifdef  AFS_SUN5_ENV
  25 #include <sys/fcntl.h>
  26 #endif
  27 #include <errno.h>
  28 #include <rx/xdr.h>
  29 #include <rx/rx.h>
  30 #include <stdio.h>
  31 #include <afs/afsint.h>
  32 #include <afs/nfs.h>
  33 #include <afs/afs_assert.h>
  34 #include <afs/dir.h>
  35 #include <afs/ihandle.h>
  36 #include "vol.h"
  37 #include "physio.h"
  38
  39 /* returns 0 on success, errno on failure */
  40 int
  41 ReallyRead(DirHandle * file, int block, char *data)
  42 {
  43     FdHandle_t *fdP;
  44     int code;
  45     ssize_t nBytes;
  46     errno = 0;
  47     fdP = IH_OPEN(file->dirh_handle);
  48     if (fdP == NULL) {
  49         code = errno;
  50         return code;
  51     }
  52     nBytes = FDH_PREAD(fdP, data, AFS_PAGESIZE, ((afs_foff_t)block) * AFS_PAGESIZE);
  53     if (nBytes != AFS_PAGESIZE) {
  54         if (nBytes < 0)
  55             code = errno;
  56         else
  57             code = EIO;
  58         FDH_REALLYCLOSE(fdP);
  59         return code;
  60     }
  61     FDH_CLOSE(fdP);
  62     return 0;
  63 }
  64
  65 /* returns 0 on success, errno on failure */
  66 int
  67 ReallyWrite(DirHandle * file, int block, char *data)
  68 {
  69     FdHandle_t *fdP;
  70     extern int VolumeChanged;
  71     int code;
  72     ssize_t nBytes;
  73
  74     errno = 0;
  75
  76     fdP = IH_OPEN(file->dirh_handle);
  77     if (fdP == NULL) {
  78         code = errno;
  79         return code;
  80     }
  81     nBytes = FDH_PWRITE(fdP, data, AFS_PAGESIZE, ((afs_foff_t)block) * AFS_PAGESIZE);
  82     if (nBytes != AFS_PAGESIZE) {
  83         if (nBytes < 0)
  84             code = errno;
  85         else
  86             code = EIO;
  87         FDH_REALLYCLOSE(fdP);
  88         return code;
  89     }
  90     FDH_CLOSE(fdP);
  91     VolumeChanged = 1;
  92     return 0;
  93 }
  94
  95 /* SetSalvageDirHandle:
  96  * Create a handle to a directory entry and reference it (IH_INIT).
  97  * The handle needs to be dereferenced with the FidZap() routine.
  98  */
  99 void
 100 SetSalvageDirHandle(DirHandle * dir, afs_uint32 volume, afs_int32 device,
 101                     Inode inode)
 102 {
 103     private int SalvageCacheCheck = 1;
 104     memset(dir, 0, sizeof(DirHandle));
 105
 106     dir->dirh_volume = volume;
 107     dir->dirh_device = device;
 108     dir->dirh_inode = inode;
 109     IH_INIT(dir->dirh_handle, device, volume, inode);
 110
 111     /* Always re-read for a new dirhandle */
 112     dir->dirh_cacheCheck = SalvageCacheCheck++;
 113 }
 114
 115 void
 116 FidZap(DirHandle * file)
 117 {
 118     IH_RELEASE(file->dirh_handle);
 119     memset(file, 0, sizeof(DirHandle));
 120 }
 121
 122 void
 123 FidZero(DirHandle * file)
 124 {
 125     memset(file, 0, sizeof(DirHandle));
 126 }
 127
 128 int
 129 FidEq(DirHandle * afile, DirHandle * bfile)
 130 {
 131     if (afile->dirh_volume != bfile->dirh_volume)
 132         return 0;
 133     if (afile->dirh_device != bfile->dirh_device)
 134         return 0;
 135     if (afile->dirh_cacheCheck != bfile->dirh_cacheCheck)
 136         return 0;
 137     if (afile->dirh_inode != bfile->dirh_inode)
 138         return 0;
 139     return 1;
 140 }
 141
 142 int
 143 FidVolEq(DirHandle * afile, afs_int32 vid)
 144 {
 145     if (afile->dirh_volume != vid)
 146         return 0;
 147     return 1;
 148 }
 149
 150 void
 151 FidCpy(DirHandle * tofile, DirHandle * fromfile)
 152 {
 153     *tofile = *fromfile;
 154     IH_COPY(tofile->dirh_handle, fromfile->dirh_handle);
 155 }
 156
 157 void
 158 Die(char *msg)
 159 {
 160     printf("%s\n", msg);
 161     osi_Panic("%s\n", msg);
 162 }