]> git.decadent.org.uk Git - nfs-utils.git/blob - utils/mount/error.c
480c944c88020b0cd14821b636c3c81b2489fb1a
[nfs-utils.git] / utils / mount / error.c
1 /*
2  * error.c -- Common error handling functions
3  *
4  * Copyright (C) 2007 Oracle.  All rights reserved.
5  * Copyright (C) 2007 Chuck Lever <chuck.lever@oracle.com>
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public
18  * License along with this program; if not, write to the
19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20  * Boston, MA 021110-1307, USA.
21  *
22  * To Do:
23  *  + Proper support for internationalization
24  */
25
26 #include "config.h"
27 #include <unistd.h>
28 #include <sys/types.h>
29 #include <stdio.h>
30 #include <string.h>
31 #include <errno.h>
32 #include <fcntl.h>
33 #include <syslog.h>
34 #include <rpc/rpc.h>
35 #include <rpc/pmap_prot.h>
36 #include <rpc/pmap_clnt.h>
37
38 #include "xcommon.h"
39 #include "nls.h"
40 #include "mount.h"
41 #include "error.h"
42
43 #ifdef HAVE_RPCSVC_NFS_PROT_H
44 #include <rpcsvc/nfs_prot.h>
45 #else
46 #include <linux/nfs.h>
47 #define nfsstat nfs_stat
48 #endif
49
50 extern char *progname;
51
52 static char errbuf[BUFSIZ];
53 static char *erreob = &errbuf[BUFSIZ];
54
55 /* Convert RPC errors into strings */
56 static int rpc_strerror(int spos)
57 {
58         int cf_stat = rpc_createerr.cf_stat;
59         int pos = 0, cf_errno = rpc_createerr.cf_error.re_errno;
60         char *ptr, *estr = clnt_sperrno(cf_stat);
61         char *tmp;
62
63         if (estr) {
64                 if ((ptr = index(estr, ':')))
65                         estr = ++ptr;
66
67                 tmp = &errbuf[spos];
68                 if (cf_stat == RPC_SYSTEMERROR)
69                         pos = snprintf(tmp, (erreob - tmp),
70                                         _("System Error: %s"),
71                                                 strerror(cf_errno));
72                 else
73                         pos = snprintf(tmp, (erreob - tmp),
74                                         _("RPC Error:%s"), estr);
75         }
76         return pos;
77 }
78
79 /**
80  * rpc_mount_errors - log an RPC error that occurred during a user-space mount
81  * @server: C string containing name of server we are attempting to mount
82  * @will_retry: one indicates mount will retry at some later point
83  * @bg: one indicates this is a background mount
84  *
85  * Extracts the error code from the user-space RPC library, and reports it
86  * on stderr (fg mount) or in the system log (bg mount).
87  */
88 void rpc_mount_errors(char *server, int will_retry, int bg)
89 {
90         int pos = 0;
91         char *tmp;
92         static int onlyonce = 0;
93
94         tmp = &errbuf[pos];
95         if (bg)
96                 pos = snprintf(tmp, (erreob - tmp),
97                                 _("mount to NFS server '%s' failed: "),
98                                         server);
99         else
100                 pos = snprintf(tmp, (erreob - tmp),
101                                 _("%s: mount to NFS server '%s' failed: "),
102                                         progname, server);
103
104         tmp = &errbuf[pos];
105         if (rpc_createerr.cf_stat == RPC_TIMEDOUT) {
106                 if (will_retry)
107                         pos = snprintf(tmp, (erreob - tmp),
108                                         _("timed out, retrying"));
109                 else
110                         pos = snprintf(tmp, (erreob - tmp),
111                                         _("timed out, giving up"));
112         } else {
113                 pos += rpc_strerror(pos);
114                 tmp = &errbuf[pos];
115                 if (bg) {
116                         if (will_retry)
117                                 pos = snprintf(tmp, (erreob - tmp),
118                                                 _(", retrying"));
119                         else
120                                 pos = snprintf(tmp, (erreob - tmp),
121                                                 _(", giving up"));
122                 }
123         }
124
125         if (bg) {
126                 if (onlyonce++ < 1)
127                         openlog("mount", LOG_CONS|LOG_PID, LOG_AUTH);
128                 syslog(LOG_ERR, "%s", errbuf);
129         } else
130                 fprintf(stderr, "%s\n", errbuf);
131 }
132
133 /**
134  * sys_mount_errors - log an error that occurred during a mount system call
135  * @server: C string containing name of server we are attempting to mount
136  * @error: errno value to report
137  * @will_retry: one indicates mount will retry at some later point
138  * @bg: one indicates this is a background mount
139  *
140  * Passed an errno value generated by a mount system call, and reports it
141  * on stderr (fg mount) or in the system log (bg mount).
142  */
143 void sys_mount_errors(char *server, int error, int will_retry, int bg)
144 {
145         int pos = 0;
146         char *tmp;
147         static int onlyonce = 0;
148
149         tmp = &errbuf[pos];
150         if (bg)
151                 pos = snprintf(tmp, (erreob - tmp),
152                                 _("mount to NFS server '%s' failed: "),
153                                         server);
154         else
155                 pos = snprintf(tmp, (erreob - tmp),
156                                 _("%s: mount to NFS server '%s' failed: "),
157                                         progname, server);
158
159         tmp = &errbuf[pos];
160         if (error == ETIMEDOUT) {
161                 if (will_retry)
162                         pos = snprintf(tmp, (erreob - tmp),
163                                         _("timed out, retrying"));
164                 else
165                         pos = snprintf(tmp, (erreob - tmp),
166                                         _("timed out, giving up"));
167         } else {
168                 if (bg) {
169                         if (will_retry)
170                                 pos = snprintf(tmp, (erreob - tmp),
171                                                 _("%s, retrying"),
172                                                 strerror(error));
173                         else
174                                 pos = snprintf(tmp, (erreob - tmp),
175                                                 _("%s, giving up"),
176                                                 strerror(error));
177                 }
178         }
179
180         if (bg) {
181                 if (onlyonce++ < 1)
182                         openlog("mount", LOG_CONS|LOG_PID, LOG_AUTH);
183                 syslog(LOG_ERR, "%s", errbuf);
184         } else
185                 fprintf(stderr, "%s\n", errbuf);
186 }
187
188 /*
189  * mount_error - report a foreground mount error
190  * @spec: C string containing the device name being mounted
191  * @mount_point: C string containing the pathname of the local mounted on dir
192  * @error: errno value to report
193  *
194  */
195 void mount_error(const char *spec, const char *mount_point, int error)
196 {
197         switch(error) {
198         case ENOTDIR:
199                 nfs_error(_("%s: mount point %s is not a directory"),
200                                 progname, mount_point);
201                 break;
202         case EBUSY:
203                 nfs_error(_("%s: %s is already mounted or busy"),
204                         progname, mount_point);
205                 break;
206         case ENOENT:
207                 if (spec)
208                         nfs_error(_("%s: mounting %s failed, "
209                                 "reason given by server:\n  %s"),
210                                 progname, spec, strerror(error));
211                 else
212                         nfs_error(_("%s: mount point %s does not exist"),
213                                 progname, mount_point);
214                 break;
215         default:
216                 nfs_error(_("%s: %s"),
217                         progname, strerror(error));
218         }
219 }
220
221 /*
222  * umount_error - report a failed umount request
223  * @err: errno value to report
224  * @dev: C string containing the pathname of the local mounted on dir
225  *
226  */
227 void umount_error(int err, const char *dev)
228 {
229         switch (err) {
230         case ENXIO:
231                 nfs_error(_("%s: %s: invalid block device"),
232                         progname, dev);
233                 break;
234         case EINVAL:
235                 nfs_error(_("%s: %s: not mounted"),
236                         progname, dev);
237                 break;
238         case EIO:
239                 nfs_error(_("%s: %s: can't write superblock"),
240                         progname, dev);
241                 break;
242         case EBUSY:
243                 nfs_error(_("%s: %s: device is busy"),
244                         progname, dev);
245                 break;
246         case ENOENT:
247                 nfs_error(_("%s: %s: not found"),
248                         progname, dev);
249                 break;
250         case EPERM:
251                 nfs_error(_("%s: %s: must be superuser to umount"),
252                         progname, dev);
253                 break;
254         case EACCES:
255                 nfs_error(_("%s: %s: block devices not permitted on fs"),
256                         progname, dev);
257                 break;
258         default:
259                 nfs_error(_("%s: %s: %s"),
260                         progname, dev, strerror(err));
261                 break;
262         }
263 }
264
265 /*
266  * We need to translate between nfs status return values and
267  * the local errno values which may not be the same.
268  *
269  * Andreas Schwab <schwab@LS5.informatik.uni-dortmund.de>: change errno:
270  * "after #include <errno.h> the symbol errno is reserved for any use,
271  *  it cannot even be used as a struct tag or field name".
272  */
273
274 #ifndef EDQUOT
275 #define EDQUOT  ENOSPC
276 #endif
277
278 static struct {
279         enum nfsstat stat;
280         int errnum;
281 } nfs_errtbl[] = {
282         { NFS_OK,               0               },
283         { NFSERR_PERM,          EPERM           },
284         { NFSERR_NOENT,         ENOENT          },
285         { NFSERR_IO,            EIO             },
286         { NFSERR_NXIO,          ENXIO           },
287         { NFSERR_ACCES,         EACCES          },
288         { NFSERR_EXIST,         EEXIST          },
289         { NFSERR_NODEV,         ENODEV          },
290         { NFSERR_NOTDIR,        ENOTDIR         },
291         { NFSERR_ISDIR,         EISDIR          },
292 #ifdef NFSERR_INVAL
293         { NFSERR_INVAL,         EINVAL          },      /* that Sun forgot */
294 #endif
295         { NFSERR_FBIG,          EFBIG           },
296         { NFSERR_NOSPC,         ENOSPC          },
297         { NFSERR_ROFS,          EROFS           },
298         { NFSERR_NAMETOOLONG,   ENAMETOOLONG    },
299         { NFSERR_NOTEMPTY,      ENOTEMPTY       },
300         { NFSERR_DQUOT,         EDQUOT          },
301         { NFSERR_STALE,         ESTALE          },
302 #ifdef EWFLUSH
303         { NFSERR_WFLUSH,        EWFLUSH         },
304 #endif
305         /* Throw in some NFSv3 values for even more fun (HP returns these) */
306         { 71,                   EREMOTE         },
307
308         { -1,                   EIO             }
309 };
310
311 char *nfs_strerror(int stat)
312 {
313         int i;
314         static char buf[256];
315
316         for (i = 0; nfs_errtbl[i].stat != -1; i++) {
317                 if (nfs_errtbl[i].stat == stat)
318                         return strerror(nfs_errtbl[i].errnum);
319         }
320         sprintf(buf, _("unknown nfs status return value: %d"), stat);
321         return buf;
322 }