src/afs/afs_error.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 /*
  11  * Implements:
  12  */
  13 #include <afsconfig.h>
  14 #include "afs/param.h"
  15
  16 RCSID
  17     ("$Header$");
  18
  19 #include "afs/stds.h"
  20 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  21
  22 #ifndef UKERNEL
  23 #if !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD_ENV)
  24 #include <net/if.h>
  25 #include <netinet/in.h>
  26 #endif
  27
  28 #ifdef AFS_SGI62_ENV
  29 #include "h/hashing.h"
  30 #endif
  31 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_FBSD_ENV) && !defined(AFS_DARWIN60_ENV)
  32 #include <netinet/in_var.h>
  33 #endif
  34 #endif /* !UKERNEL */
  35
  36 #include "afsincludes.h"        /* Afs-based standard headers */
  37 #include "afs/afs_stats.h"      /* afs statistics */
  38 #include "afs/afs_util.h"
  39 #include "afs/unified_afs.h"
  40
  41 #if     defined(AFS_SUN56_ENV)
  42 #include <inet/led.h>
  43 #include <inet/common.h>
  44 #if     defined(AFS_SUN58_ENV)
  45 #include <netinet/ip6.h>
  46 #endif
  47 #include <inet/ip.h>
  48 #endif
  49
  50
  51 /* shouldn't do it this way, but for now will do */
  52 #ifndef ERROR_TABLE_BASE_U
  53 #define ERROR_TABLE_BASE_U      (5376L)
  54 #endif /* ubik error base define */
  55
  56 /* shouldn't do it this way, but for now will do */
  57 #ifndef ERROR_TABLE_BASE_uae
  58 #define ERROR_TABLE_BASE_uae    (49733376L)
  59 #endif /* unified afs error base define */
  60
  61 /* same hack for vlserver error base as for ubik error base */
  62 #ifndef ERROR_TABLE_BASE_VL
  63 #define ERROR_TABLE_BASE_VL     (363520L)
  64 #define VL_NOENT                (363524L)
  65 #endif /* vlserver error base define */
  66
  67
  68 static int et2sys[512];
  69
  70 void
  71 init_et_to_sys_error(void)
  72 {
  73     memset(&et2sys, 0, sizeof(et2sys));
  74     et2sys[(UAEPERM - ERROR_TABLE_BASE_uae)] = EPERM;
  75     et2sys[(UAENOENT - ERROR_TABLE_BASE_uae)] = ENOENT;
  76     et2sys[(UAESRCH - ERROR_TABLE_BASE_uae)] = ESRCH;
  77     et2sys[(UAEINTR - ERROR_TABLE_BASE_uae)] = EINTR;
  78     et2sys[(UAEIO - ERROR_TABLE_BASE_uae)] = EIO;
  79     et2sys[(UAENXIO - ERROR_TABLE_BASE_uae)] = ENXIO;
  80     et2sys[(UAE2BIG - ERROR_TABLE_BASE_uae)] = E2BIG;
  81     et2sys[(UAENOEXEC - ERROR_TABLE_BASE_uae)] = ENOEXEC;
  82     et2sys[(UAEBADF - ERROR_TABLE_BASE_uae)] = EBADF;
  83     et2sys[(UAECHILD - ERROR_TABLE_BASE_uae)] = ECHILD;
  84     et2sys[(UAEAGAIN - ERROR_TABLE_BASE_uae)] = EAGAIN;
  85     et2sys[(UAENOMEM - ERROR_TABLE_BASE_uae)] = ENOMEM;
  86     et2sys[(UAEACCES - ERROR_TABLE_BASE_uae)] = EACCES;
  87     et2sys[(UAEFAULT - ERROR_TABLE_BASE_uae)] = EFAULT;
  88     et2sys[(UAENOTBLK - ERROR_TABLE_BASE_uae)] = ENOTBLK;
  89     et2sys[(UAEBUSY - ERROR_TABLE_BASE_uae)] = EBUSY;
  90     et2sys[(UAEEXIST - ERROR_TABLE_BASE_uae)] = EEXIST;
  91     et2sys[(UAEXDEV - ERROR_TABLE_BASE_uae)] = EXDEV;
  92     et2sys[(UAENODEV - ERROR_TABLE_BASE_uae)] = ENODEV;
  93     et2sys[(UAENOTDIR - ERROR_TABLE_BASE_uae)] = ENOTDIR;
  94     et2sys[(UAEISDIR - ERROR_TABLE_BASE_uae)] = EISDIR;
  95     et2sys[(UAEINVAL - ERROR_TABLE_BASE_uae)] = EINVAL;
  96     et2sys[(UAENFILE - ERROR_TABLE_BASE_uae)] = ENFILE;
  97     et2sys[(UAEMFILE - ERROR_TABLE_BASE_uae)] = EMFILE;
  98     et2sys[(UAENOTTY - ERROR_TABLE_BASE_uae)] = ENOTTY;
  99     et2sys[(UAETXTBSY - ERROR_TABLE_BASE_uae)] = ETXTBSY;
 100     et2sys[(UAEFBIG - ERROR_TABLE_BASE_uae)] = EFBIG;
 101     et2sys[(UAENOSPC - ERROR_TABLE_BASE_uae)] = ENOSPC;
 102     et2sys[(UAESPIPE - ERROR_TABLE_BASE_uae)] = ESPIPE;
 103     et2sys[(UAEROFS - ERROR_TABLE_BASE_uae)] = EROFS;
 104     et2sys[(UAEMLINK - ERROR_TABLE_BASE_uae)] = EMLINK;
 105     et2sys[(UAEPIPE - ERROR_TABLE_BASE_uae)] = EPIPE;
 106     et2sys[(UAEDOM - ERROR_TABLE_BASE_uae)] = EDOM;
 107     et2sys[(UAERANGE - ERROR_TABLE_BASE_uae)] = ERANGE;
 108     et2sys[(UAEDEADLK - ERROR_TABLE_BASE_uae)] = EDEADLK;
 109     et2sys[(UAENAMETOOLONG - ERROR_TABLE_BASE_uae)] = ENAMETOOLONG;
 110     et2sys[(UAENOLCK - ERROR_TABLE_BASE_uae)] = ENOLCK;
 111     et2sys[(UAENOSYS - ERROR_TABLE_BASE_uae)] = ENOSYS;
 112     et2sys[(UAENOTEMPTY - ERROR_TABLE_BASE_uae)] = ENOTEMPTY;
 113     et2sys[(UAELOOP - ERROR_TABLE_BASE_uae)] = ELOOP;
 114     et2sys[(UAEWOULDBLOCK - ERROR_TABLE_BASE_uae)] = EWOULDBLOCK;
 115     et2sys[(UAENOMSG - ERROR_TABLE_BASE_uae)] = ENOMSG;
 116     et2sys[(UAEIDRM - ERROR_TABLE_BASE_uae)] = EIDRM;
 117     et2sys[(UAECHRNG - ERROR_TABLE_BASE_uae)] = ECHRNG;
 118     et2sys[(UAEL2NSYNC - ERROR_TABLE_BASE_uae)] = EL2NSYNC;
 119     et2sys[(UAEL3HLT - ERROR_TABLE_BASE_uae)] = EL3HLT;
 120     et2sys[(UAEL3RST - ERROR_TABLE_BASE_uae)] = EL3RST;
 121     et2sys[(UAELNRNG - ERROR_TABLE_BASE_uae)] = ELNRNG;
 122     et2sys[(UAEUNATCH - ERROR_TABLE_BASE_uae)] = EUNATCH;
 123     et2sys[(UAENOCSI - ERROR_TABLE_BASE_uae)] = ENOCSI;
 124     et2sys[(UAEL2HLT - ERROR_TABLE_BASE_uae)] = EL2HLT;
 125     et2sys[(UAEBADE - ERROR_TABLE_BASE_uae)] = EBADE;
 126     et2sys[(UAEBADR - ERROR_TABLE_BASE_uae)] = EBADR;
 127     et2sys[(UAEXFULL - ERROR_TABLE_BASE_uae)] = EXFULL;
 128     et2sys[(UAENOANO - ERROR_TABLE_BASE_uae)] = ENOANO;
 129     et2sys[(UAEBADRQC - ERROR_TABLE_BASE_uae)] = EBADRQC;
 130     et2sys[(UAEBADSLT - ERROR_TABLE_BASE_uae)] = EBADSLT;
 131     et2sys[(UAEBFONT - ERROR_TABLE_BASE_uae)] = EBFONT;
 132     et2sys[(UAENOSTR - ERROR_TABLE_BASE_uae)] = ENOSTR;
 133     et2sys[(UAENODATA - ERROR_TABLE_BASE_uae)] = ENODATA;
 134     et2sys[(UAETIME - ERROR_TABLE_BASE_uae)] = ETIME;
 135     et2sys[(UAENOSR - ERROR_TABLE_BASE_uae)] = ENOSR;
 136     et2sys[(UAENONET - ERROR_TABLE_BASE_uae)] = ENONET;
 137     et2sys[(UAENOPKG - ERROR_TABLE_BASE_uae)] = ENOPKG;
 138     et2sys[(UAEREMOTE - ERROR_TABLE_BASE_uae)] = EREMOTE;
 139     et2sys[(UAENOLINK - ERROR_TABLE_BASE_uae)] = ENOLINK;
 140     et2sys[(UAEADV - ERROR_TABLE_BASE_uae)] = EADV;
 141     et2sys[(UAESRMNT - ERROR_TABLE_BASE_uae)] = ESRMNT;
 142     et2sys[(UAECOMM - ERROR_TABLE_BASE_uae)] = ECOMM;
 143     et2sys[(UAEPROTO - ERROR_TABLE_BASE_uae)] = EPROTO;
 144     et2sys[(UAEMULTIHOP - ERROR_TABLE_BASE_uae)] = EMULTIHOP;
 145     et2sys[(UAEDOTDOT - ERROR_TABLE_BASE_uae)] = EDOTDOT;
 146     et2sys[(UAEBADMSG - ERROR_TABLE_BASE_uae)] = EBADMSG;
 147     et2sys[(UAEOVERFLOW - ERROR_TABLE_BASE_uae)] = EOVERFLOW;
 148     et2sys[(UAENOTUNIQ - ERROR_TABLE_BASE_uae)] = ENOTUNIQ;
 149     et2sys[(UAEBADFD - ERROR_TABLE_BASE_uae)] = EBADFD;
 150     et2sys[(UAEREMCHG - ERROR_TABLE_BASE_uae)] = EREMCHG;
 151     et2sys[(UAELIBACC - ERROR_TABLE_BASE_uae)] = ELIBACC;
 152     et2sys[(UAELIBBAD - ERROR_TABLE_BASE_uae)] = ELIBBAD;
 153     et2sys[(UAELIBSCN - ERROR_TABLE_BASE_uae)] = ELIBSCN;
 154     et2sys[(UAELIBMAX - ERROR_TABLE_BASE_uae)] = ELIBMAX;
 155     et2sys[(UAELIBEXEC - ERROR_TABLE_BASE_uae)] = ELIBEXEC;
 156     et2sys[(UAEILSEQ - ERROR_TABLE_BASE_uae)] = EILSEQ;
 157     et2sys[(UAERESTART - ERROR_TABLE_BASE_uae)] = ERESTART;
 158     et2sys[(UAESTRPIPE - ERROR_TABLE_BASE_uae)] = ESTRPIPE;
 159     et2sys[(UAEUSERS - ERROR_TABLE_BASE_uae)] = EUSERS;
 160     et2sys[(UAENOTSOCK - ERROR_TABLE_BASE_uae)] = ENOTSOCK;
 161     et2sys[(UAEDESTADDRREQ - ERROR_TABLE_BASE_uae)] = EDESTADDRREQ;
 162     et2sys[(UAEMSGSIZE - ERROR_TABLE_BASE_uae)] = EMSGSIZE;
 163     et2sys[(UAEPROTOTYPE - ERROR_TABLE_BASE_uae)] = EPROTOTYPE;
 164     et2sys[(UAENOPROTOOPT - ERROR_TABLE_BASE_uae)] = ENOPROTOOPT;
 165     et2sys[(UAEPROTONOSUPPORT - ERROR_TABLE_BASE_uae)] = EPROTONOSUPPORT;
 166     et2sys[(UAESOCKTNOSUPPORT - ERROR_TABLE_BASE_uae)] = ESOCKTNOSUPPORT;
 167     et2sys[(UAEOPNOTSUPP - ERROR_TABLE_BASE_uae)] = EOPNOTSUPP;
 168     et2sys[(UAEPFNOSUPPORT - ERROR_TABLE_BASE_uae)] = EPFNOSUPPORT;
 169     et2sys[(UAEAFNOSUPPORT - ERROR_TABLE_BASE_uae)] = EAFNOSUPPORT;
 170     et2sys[(UAEADDRINUSE - ERROR_TABLE_BASE_uae)] = EADDRINUSE;
 171     et2sys[(UAEADDRNOTAVAIL - ERROR_TABLE_BASE_uae)] = EADDRNOTAVAIL;
 172     et2sys[(UAENETDOWN - ERROR_TABLE_BASE_uae)] = ENETDOWN;
 173     et2sys[(UAENETUNREACH - ERROR_TABLE_BASE_uae)] = ENETUNREACH;
 174     et2sys[(UAENETRESET - ERROR_TABLE_BASE_uae)] = ENETRESET;
 175     et2sys[(UAECONNABORTED - ERROR_TABLE_BASE_uae)] = ECONNABORTED;
 176     et2sys[(UAECONNRESET - ERROR_TABLE_BASE_uae)] = ECONNRESET;
 177     et2sys[(UAENOBUFS - ERROR_TABLE_BASE_uae)] = ENOBUFS;
 178     et2sys[(UAEISCONN - ERROR_TABLE_BASE_uae)] = EISCONN;
 179     et2sys[(UAENOTCONN - ERROR_TABLE_BASE_uae)] = ENOTCONN;
 180     et2sys[(UAESHUTDOWN - ERROR_TABLE_BASE_uae)] = ESHUTDOWN;
 181     et2sys[(UAETOOMANYREFS - ERROR_TABLE_BASE_uae)] = ETOOMANYREFS;
 182     et2sys[(UAETIMEDOUT - ERROR_TABLE_BASE_uae)] = ETIMEDOUT;
 183     et2sys[(UAECONNREFUSED - ERROR_TABLE_BASE_uae)] = ECONNREFUSED;
 184     et2sys[(UAEHOSTDOWN - ERROR_TABLE_BASE_uae)] = EHOSTDOWN;
 185     et2sys[(UAEHOSTUNREACH - ERROR_TABLE_BASE_uae)] = EHOSTUNREACH;
 186     et2sys[(UAEALREADY - ERROR_TABLE_BASE_uae)] = EALREADY;
 187     et2sys[(UAEINPROGRESS - ERROR_TABLE_BASE_uae)] = EINPROGRESS;
 188     et2sys[(UAESTALE - ERROR_TABLE_BASE_uae)] = ESTALE;
 189     et2sys[(UAEUCLEAN - ERROR_TABLE_BASE_uae)] = EUCLEAN;
 190     et2sys[(UAENOTNAM - ERROR_TABLE_BASE_uae)] = ENOTNAM;
 191     et2sys[(UAENAVAIL - ERROR_TABLE_BASE_uae)] = ENAVAIL;
 192     et2sys[(UAEISNAM - ERROR_TABLE_BASE_uae)] = EISNAM;
 193     et2sys[(UAEREMOTEIO - ERROR_TABLE_BASE_uae)] = EREMOTEIO;
 194     et2sys[(UAEDQUOT - ERROR_TABLE_BASE_uae)] = EDQUOT;
 195     et2sys[(UAENOMEDIUM - ERROR_TABLE_BASE_uae)] = ENOMEDIUM;
 196     et2sys[(UAEMEDIUMTYPE - ERROR_TABLE_BASE_uae)] = EMEDIUMTYPE;
 197 }
 198
 199 afs_int32
 200 et_to_sys_error(afs_int32 in)
 201 {
 202     if (in < ERROR_TABLE_BASE_uae || in >= ERROR_TABLE_BASE_uae + 512)
 203         return in;
 204     if (et2sys[in - ERROR_TABLE_BASE_uae] != 0)
 205         return et2sys[in - ERROR_TABLE_BASE_uae];
 206     return in;
 207 }
 208
 209 void
 210 afs_CopyError(register struct vrequest *afrom, register struct vrequest *ato)
 211 {
 212     AFS_STATCNT(afs_CopyError);
 213     if (!afrom->initd)
 214         return;
 215     afs_FinalizeReq(ato);
 216     if (afrom->accessError)
 217         ato->accessError = 1;
 218     if (afrom->volumeError)
 219         ato->volumeError = 1;
 220     if (afrom->networkError)
 221         ato->networkError = 1;
 222     if (afrom->permWriteError)
 223         ato->permWriteError = 1;
 224
 225 }
 226
 227 void
 228 afs_FinalizeReq(register struct vrequest *areq)
 229 {
 230     AFS_STATCNT(afs_FinalizeReq);
 231     if (areq->initd)
 232         return;
 233     areq->busyCount = 0;
 234     areq->accessError = 0;
 235     areq->volumeError = 0;
 236     areq->networkError = 0;
 237     areq->permWriteError = 0;
 238     areq->initd = 1;
 239
 240 }
 241
 242 int
 243 afs_CheckCode(afs_int32 acode, struct vrequest *areq, int where)
 244 {
 245     AFS_STATCNT(afs_CheckCode);
 246     if (acode) {
 247         afs_Trace2(afs_iclSetp, CM_TRACE_CHECKCODE, ICL_TYPE_INT32, acode,
 248                    ICL_TYPE_INT32, where);
 249     }
 250     if ((acode & ~0xff) == ERROR_TABLE_BASE_uae)
 251         acode = et_to_sys_error(acode);
 252     if (!areq || !areq->initd)
 253         return acode;
 254     if (areq->networkError)
 255         return ETIMEDOUT;
 256     if (acode == 0)
 257         return 0;
 258     if (areq->accessError)
 259         return EACCES;
 260     if (areq->volumeError == VOLMISSING)
 261         return ENODEV;
 262     if (areq->volumeError == VOLBUSY)
 263         return EWOULDBLOCK;
 264     if (acode == VNOVNODE)
 265         return ENOENT;
 266     if (acode == VDISKFULL)
 267         return ENOSPC;
 268     if (acode == VOVERQUOTA)
 269         return
 270 #ifdef EDQUOT
 271             EDQUOT
 272 #else
 273             ENOSPC
 274 #endif
 275             ;
 276
 277     return acode;
 278
 279 }                               /*afs_CheckCode */