#include <afsconfig.h>
#include <afs/param.h>
+#include <afs/stds.h>
#include <roken.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
#ifdef AFS_SGI_ENV
#undef SHARED /* XXX */
#endif
-#ifdef AFS_NT40_ENV
-#include <fcntl.h>
-#else
-#include <sys/param.h>
-#include <sys/file.h>
-#include <sys/ioctl.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <string.h>
-
-#ifndef AFS_LINUX20_ENV
+
+#ifdef HAVE_NET_IF_H
#include <net/if.h>
-#ifndef AFS_ARM_DARWIN_ENV
+#endif
+
+#ifdef HAVE_NETINET_IF_ETHER_H
#include <netinet/if_ether.h>
#endif
+
+#if !defined(AFS_SGI_ENV) && defined(HAVE_SYS_MAP_H)
+#include <sys/map.h>
+#endif
+
+#ifdef HAVE_SYS_STATFS_H
+#include <sys/statfs.h>
#endif
+
+#ifdef HAVE_SYS_LOCKF_H
+#include <sys/lockf.h>
#endif
+
+#ifdef HAVE_SYS_DK_H
+#include <sys/dk.h>
+#endif
+
#ifdef AFS_HPUX_ENV
/* included early because of name conflict on IOPEN */
#include <sys/inode.h>
#undef IOPEN
#endif
#endif /* AFS_HPUX_ENV */
-#include <afs/stds.h>
+
#include <rx/xdr.h>
#include <afs/nfs.h>
#include <afs/afs_assert.h>
#include <afs/acl.h>
#include <rx/rx.h>
#include <rx/rx_globals.h>
-#include <sys/stat.h>
-#if ! defined(AFS_SGI_ENV) && ! defined(AFS_AIX32_ENV) && ! defined(AFS_NT40_ENV) && ! defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_XBSD_ENV)
-#include <sys/map.h>
-#endif
-#if !defined(AFS_NT40_ENV)
-#include <unistd.h>
-#endif
-#if !defined(AFS_SGI_ENV) && !defined(AFS_NT40_ENV)
-#ifdef AFS_AIX_ENV
-#include <sys/statfs.h>
-#include <sys/lockf.h>
-#else
-#if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_XBSD_ENV)
-#include <sys/dk.h>
-#endif
-#endif
-#endif
+
#include <afs/cellconfig.h>
#include <afs/keys.h>
-#include <signal.h>
#include <afs/partition.h>
#include "viced_prototypes.h"
#include "viced.h"
pthread_mutex_t fileproc_glock_mutex;
#endif /* AFS_PTHREAD_ENV */
-#ifdef O_LARGEFILE
-#define afs_stat stat64
-#define afs_fstat fstat64
-#define afs_open open64
-#else /* !O_LARGEFILE */
-#define afs_stat stat
-#define afs_fstat fstat
-#define afs_open open
-#endif /* !O_LARGEFILE */
-
-
/* Useful local defines used by this module */
#define DONTCHECK 0
FS_UNLOCK;
} /*SetVolumeSync */
+/**
+ * Verify that the on-disk size for a vnode matches the length in the vnode
+ * index.
+ *
+ * @param[in] vp Volume pointer
+ * @param[in] vnp Vnode pointer
+ * @param[in] alen Size of the vnode on disk, if known. If unknown, give -1,
+ * and CheckLength itself will determine the on-disk size.
+ *
+ * @return operation status
+ * @retval 0 lengths match
+ * @retval nonzero Error; either the lengths do not match or there was an
+ * error determining the on-disk size. The volume should be
+ * taken offline and salvaged.
+ */
+static int
+CheckLength(struct Volume *vp, struct Vnode *vnp, afs_sfsize_t alen)
+{
+ afs_sfsize_t vlen;
+ VN_GET_LEN(vlen, vnp);
+
+ if (alen < 0) {
+ FdHandle_t *fdP;
+
+ fdP = IH_OPEN(vnp->handle);
+ if (fdP == NULL) {
+ ViceLog(0, ("CheckLength: cannot open inode for fid %lu.%lu.%lu\n",
+ afs_printable_uint32_lu(vp->hashid),
+ afs_printable_uint32_lu(Vn_id(vnp)),
+ afs_printable_uint32_lu(vnp->disk.uniquifier)));
+ return -1;
+ }
+ alen = FDH_SIZE(fdP);
+ FDH_CLOSE(fdP);
+ if (alen < 0) {
+ afs_int64 alen64 = alen;
+ ViceLog(0, ("CheckLength: cannot get size for inode for fid "
+ "%lu.%lu.%lu; FDH_SIZE returned %" AFS_INT64_FMT "\n",
+ afs_printable_uint32_lu(vp->hashid),
+ afs_printable_uint32_lu(Vn_id(vnp)),
+ afs_printable_uint32_lu(vnp->disk.uniquifier),
+ alen64));
+ return -1;
+ }
+ }
+
+ if (alen != vlen) {
+ afs_int64 alen64 = alen, vlen64 = vlen;
+ ViceLog(0, ("Fid %lu.%lu.%lu has inconsistent length (index "
+ "%lld inode %lld ); volume must be salvaged\n",
+ afs_printable_uint32_lu(vp->hashid),
+ afs_printable_uint32_lu(Vn_id(vnp)),
+ afs_printable_uint32_lu(vnp->disk.uniquifier),
+ vlen64, alen64));
+ return -1;
+ }
+ return 0;
+}
+
/*
* Note that this function always returns a held host, so
* that CallPostamble can block without the host's disappearing.
} else { /* file */
/* must have read access, or be owner and have insert access */
if (!(rights & PRSFS_READ)
- && !(OWNSp(client, targetptr) && (rights & PRSFS_INSERT)))
+ && !((OWNSp(client, targetptr) && (rights & PRSFS_INSERT)
+ && (client->ViceId != AnonymousID))))
return (EACCES);
}
if (CallingRoutine == CHK_FETCHDATA
/* watch for invalid names */
if (!strcmp(Name, ".") || !strcmp(Name, ".."))
return (EINVAL);
+
+ if (CheckLength(volptr, parentptr, -1)) {
+ VTakeOffline(volptr);
+ return VSALVAGE;
+ }
+
if (parentptr->disk.cloned) {
ViceLog(25, ("DeleteTarget : CopyOnWrite called\n"));
if ((errorCode = CopyOnWrite(parentptr, volptr, 0, MAXFSIZE))) {
AdjustDiskUsage(volptr, BlocksPreallocatedForVnode,
BlocksPreallocatedForVnode))) {
ViceLog(25,
- ("Insufficient space to allocate %" AFS_INT64_FMT " blocks\n",
+ ("Insufficient space to allocate %lld blocks\n",
(afs_intmax_t) BlocksPreallocatedForVnode));
return (errorCode);
}
+ if (CheckLength(volptr, parentptr, -1)) {
+ VAdjustDiskUsage(&temp, volptr, -BlocksPreallocatedForVnode, 0);
+ VTakeOffline(volptr);
+ return VSALVAGE;
+ }
+
*targetptr = VAllocVnode(&errorCode, volptr, FileType);
if (errorCode != 0) {
VAdjustDiskUsage(&temp, volptr, -BlocksPreallocatedForVnode, 0);
temp = strlen(V_name(volptr)) + 1;
*name = malloc(temp);
if (!*name) {
- ViceLog(0, ("Failed malloc in RXGetVolumeStatus\n"));
- osi_Panic("Failed malloc in RXGetVolumeStatus\n");
+ ViceLogThenPanic(0, ("Failed malloc in RXGetVolumeStatus\n"));
}
strcpy(*name, V_name(volptr));
temp = strlen(V_offlineMessage(volptr)) + 1;
*offMsg = malloc(temp);
if (!*offMsg) {
- ViceLog(0, ("Failed malloc in RXGetVolumeStatus\n"));
- osi_Panic("Failed malloc in RXGetVolumeStatus\n");
+ ViceLogThenPanic(0, ("Failed malloc in RXGetVolumeStatus\n"));
}
strcpy(*offMsg, V_offlineMessage(volptr));
#if OPENAFS_VOL_STATS
*motd = malloc(1);
if (!*motd) {
- ViceLog(0, ("Failed malloc in RXGetVolumeStatus\n"));
- osi_Panic("Failed malloc in RXGetVolumeStatus\n");
+ ViceLogThenPanic(0, ("Failed malloc in RXGetVolumeStatus\n"));
}
strcpy(*motd, nullString);
#else
temp = strlen(V_motd(volptr)) + 1;
*motd = malloc(temp);
if (!*motd) {
- ViceLog(0, ("Failed malloc in RXGetVolumeStatus\n"));
- osi_Panic("Failed malloc in RXGetVolumeStatus\n");
+ ViceLogThenPanic(0, ("Failed malloc in RXGetVolumeStatus\n"));
}
strcpy(*motd, V_motd(volptr));
#endif /* FS_STATS_DETAILED */
FS_UNLOCK;
tmp = malloc(sendBufSize);
if (!tmp) {
- ViceLog(0, ("Failed malloc in AllocSendBuffer\n"));
- osi_Panic("Failed malloc in AllocSendBuffer\n");
+ ViceLogThenPanic(0, ("Failed malloc in AllocSendBuffer\n"));
}
return tmp;
}
AccessList->AFSOpaque_len = 0;
AccessList->AFSOpaque_val = malloc(AFSOPAQUEMAX);
if (!AccessList->AFSOpaque_val) {
- ViceLog(0, ("Failed malloc in SRXAFS_FetchACL\n"));
- osi_Panic("Failed malloc in SRXAFS_FetchACL\n");
+ ViceLogThenPanic(0, ("Failed malloc in SRXAFS_FetchACL\n"));
}
/*
OutStats->AFSBulkStats_val = (struct AFSFetchStatus *)
malloc(nfiles * sizeof(struct AFSFetchStatus));
if (!OutStats->AFSBulkStats_val) {
- ViceLog(0, ("Failed malloc in SRXAFS_BulkStatus\n"));
- osi_Panic("Failed malloc in SRXAFS_BulkStatus\n");
+ ViceLogThenPanic(0, ("Failed malloc in SRXAFS_BulkStatus\n"));
}
OutStats->AFSBulkStats_len = nfiles;
CallBacks->AFSCBs_val = (struct AFSCallBack *)
malloc(nfiles * sizeof(struct AFSCallBack));
if (!CallBacks->AFSCBs_val) {
- ViceLog(0, ("Failed malloc in SRXAFS_BulkStatus\n"));
- osi_Panic("Failed malloc in SRXAFS_BulkStatus\n");
+ ViceLogThenPanic(0, ("Failed malloc in SRXAFS_BulkStatus\n"));
}
CallBacks->AFSCBs_len = nfiles;
OutStats->AFSBulkStats_val = (struct AFSFetchStatus *)
malloc(nfiles * sizeof(struct AFSFetchStatus));
if (!OutStats->AFSBulkStats_val) {
- ViceLog(0, ("Failed malloc in SRXAFS_FetchStatus\n"));
- osi_Panic("Failed malloc in SRXAFS_FetchStatus\n");
+ ViceLogThenPanic(0, ("Failed malloc in SRXAFS_FetchStatus\n"));
}
OutStats->AFSBulkStats_len = nfiles;
CallBacks->AFSCBs_val = (struct AFSCallBack *)
malloc(nfiles * sizeof(struct AFSCallBack));
if (!CallBacks->AFSCBs_val) {
- ViceLog(0, ("Failed malloc in SRXAFS_FetchStatus\n"));
- osi_Panic("Failed malloc in SRXAFS_FetchStatus\n");
+ ViceLogThenPanic(0, ("Failed malloc in SRXAFS_FetchStatus\n"));
}
CallBacks->AFSCBs_len = nfiles;
goto Bad_Rename;
}
+ if (CheckLength(volptr, oldvptr, -1) ||
+ CheckLength(volptr, newvptr, -1)) {
+ VTakeOffline(volptr);
+ errorCode = VSALVAGE;
+ goto Bad_Rename;
+ }
+
/* The CopyOnWrite might return ENOSPC ( disk full). Even if the second
* call to CopyOnWrite returns error, it is not necessary to revert back
* the effects of the first call because the contents of the volume is
goto Bad_Link;
}
+ if (CheckLength(volptr, parentptr, -1)) {
+ VTakeOffline(volptr);
+ errorCode = VSALVAGE;
+ goto Bad_Link;
+ }
+
/* get the file vnode */
if ((errorCode =
CheckVnode(ExistingFid, &volptr, &targetptr, WRITE_LOCK))) {
volptr->hashid));
return EIO;
}
+ if (CheckLength(volptr, targetptr, tlen)) {
+ FDH_CLOSE(fdP);
+ VTakeOffline(volptr);
+ return VSALVAGE;
+ }
if (Pos > tlen) {
Len = 0;
}
volptr->hashid));
return EIO;
}
+ if (CheckLength(volptr, targetptr, DataLength)) {
+ FDH_CLOSE(fdP);
+ VTakeOffline(volptr);
+ return VSALVAGE;
+ }
if (linkCount != 1) {
afs_fsize_t size;
if (fdP == NULL) {
ViceLog(25,
("StoreData : Reopen after CopyOnWrite failed\n"));
- FDH_CLOSE(origfdP);
+ FDH_REALLYCLOSE(origfdP);
return ENOENT;
}
}
AdjustDiskUsage(volptr, adjustSize,
adjustSize - SpareComp(volptr)))) {
FDH_CLOSE(fdP);
- if (origfdP) FDH_CLOSE(origfdP);
+ if (origfdP) FDH_REALLYCLOSE(origfdP);
return (errorCode);
}
targetptr->changed_newTime = 1;
if (origfdP && (bytesTransfered < Length)) /* Need to "finish" CopyOnWrite still */
CopyOnWrite2(origfdP, fdP, Pos + bytesTransfered, NewLength - Pos - bytesTransfered);
- if (origfdP) FDH_CLOSE(origfdP);
+ if (origfdP) FDH_REALLYCLOSE(origfdP);
FDH_CLOSE(fdP);
/* set disk usage to be correct */
VAdjustDiskUsage(&errorCode, volptr,
afs_printable_VnodeId_u(targetptr->vnodeNumber),
V_name(volptr), CoW_off, CoW_len, errorCode));
}
- FDH_CLOSE(origfdP);
+ FDH_REALLYCLOSE(origfdP);
}
FDH_CLOSE(fdP);