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