#include <afsconfig.h>
#include <afs/param.h>
+#include <roken.h>
#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
#endif
#include <errno.h>
-#ifdef AFS_PTHREAD_ENV
-#include <assert.h>
-#else /* AFS_PTHREAD_ENV */
-#include <afs/assert.h>
-#endif /* AFS_PTHREAD_ENV */
+#include <afs/afs_assert.h>
#include <signal.h>
#include <string.h>
* fssync server socket handle.
*/
static SYNC_server_state_t fssync_server_state =
- { -1, /* file descriptor */
+ { OSI_NULLSOCKET, /* file descriptor */
FSSYNC_ENDPOINT_DECL, /* server endpoint */
FSYNC_PROTO_VERSION, /* protocol version */
5, /* bind() retry limit */
Lock_Init(&FSYNC_handler_lock);
#ifdef AFS_PTHREAD_ENV
- assert(pthread_attr_init(&tattr) == 0);
- assert(pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED) == 0);
- assert(pthread_create(&tid, &tattr, FSYNC_sync, NULL) == 0);
+ osi_Assert(pthread_attr_init(&tattr) == 0);
+ osi_Assert(pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED) == 0);
+ osi_Assert(pthread_create(&tid, &tattr, FSYNC_sync, NULL) == 0);
#else /* AFS_PTHREAD_ENV */
- assert(LWP_CreateProcess
+ osi_Assert(LWP_CreateProcess
(FSYNC_sync, USUAL_STACK_SIZE, USUAL_PRIORITY, (void *)0,
"FSYNC_sync", &pid) == LWP_SUCCESS);
#endif /* AFS_PTHREAD_ENV */
#ifdef AFS_DEMAND_ATTACH_FS
queue_Init(&fsync_salv.head);
- assert(pthread_cond_init(&fsync_salv.cv, NULL) == 0);
- assert(pthread_create(&tid, &tattr, FSYNC_salvageThread, NULL) == 0);
+ CV_INIT(&fsync_salv.cv, "fsync salv", CV_DEFAULT, 0);
+ osi_Assert(pthread_create(&tid, &tattr, FSYNC_salvageThread, NULL) == 0);
#endif /* AFS_DEMAND_ATTACH_FS */
}
int min_vinit = 1;
#endif /* AFS_DEMAND_ATTACH_FS */
+ /* we must not be called before vol package initialization, since we use
+ * vol package mutexes and conds etc */
+ osi_Assert(VInit);
+
SYNC_getAddr(&state->endpoint, &state->addr);
SYNC_cleanupSock(state);
#ifdef AFS_PTHREAD_ENV
/* set our 'thread-id' so that the host hold table works */
- MUTEX_ENTER(&rx_stats_mutex); /* protects rxi_pthread_hinum */
- tid = ++rxi_pthread_hinum;
- MUTEX_EXIT(&rx_stats_mutex);
+ tid = rx_NewThreadId();
pthread_setspecific(rx_thread_id_key, (void *)(intptr_t)tid);
Log("Set thread id %d for FSYNC_sync\n", tid);
#endif /* AFS_PTHREAD_ENV */
+ VOL_LOCK;
+
while (VInit < min_vinit) {
/* Let somebody else run until all volumes have been preattached
* (DAFS), or we have started attaching volumes (non-DAFS). This
* doesn't mean that all volumes have been attached.
*/
#ifdef AFS_PTHREAD_ENV
- pthread_yield();
+ VOL_CV_WAIT(&vol_vinit_cond);
#else /* AFS_PTHREAD_ENV */
LWP_DispatchProcess();
#endif /* AFS_PTHREAD_ENV */
}
+
+ VOL_UNLOCK;
+
state->fd = SYNC_getSock(&state->endpoint);
code = SYNC_bindSock(state);
- assert(!code);
+ osi_Assert(!code);
#ifdef AFS_DEMAND_ATTACH_FS
/*
}
memcpy(thread_opts, &VThread_defaults, sizeof(VThread_defaults));
thread_opts->disallow_salvsync = 1;
- assert(pthread_setspecific(VThread_key, thread_opts) == 0);
+ osi_Assert(pthread_setspecific(VThread_key, thread_opts) == 0);
code = VVGCache_PkgInit();
- assert(code == 0);
+ osi_Assert(code == 0);
#endif
InitHandler();
}
queue_Append(&fsync_salv.head, node);
- assert(pthread_cond_broadcast(&fsync_salv.cv) == 0);
+ CV_BROADCAST(&fsync_salv.cv);
}
#endif /* AFS_DEMAND_ATTACH_FS */
socklen_t junk;
junk = sizeof(other);
fd = accept(afd, (struct sockaddr *)&other, &junk);
- if (fd == -1) {
+ if (fd == OSI_NULLSOCKET) {
Log("FSYNC_newconnection: accept failed, errno==%d\n", errno);
- assert(1 == 2);
+ osi_Assert(1 == 2);
} else if (!AddHandler(fd, FSYNC_com)) {
AcceptOff();
- assert(AddHandler(fd, FSYNC_com));
+ osi_Assert(AddHandler(fd, FSYNC_com));
}
}
case FSYNC_VOL_DONE:
case FSYNC_VOL_QUERY:
case FSYNC_VOL_QUERY_HDR:
- case FSYNC_VOL_QUERY_VOP:
#ifdef AFS_DEMAND_ATTACH_FS
+ case FSYNC_VOL_QUERY_VOP:
case FSYNC_VG_QUERY:
case FSYNC_VG_SCAN:
case FSYNC_VG_SCAN_ALL:
if (vcom->hdr->command == FSYNC_VOL_LEAVE_OFF) {
/* nothing much to do if we're leaving the volume offline */
#ifdef AFS_DEMAND_ATTACH_FS
- if (vp) {
+ if (vp && V_attachState(vp) != VOL_STATE_DELETED) {
if (FSYNC_partMatch(vcom, vp, 1)) {
if ((V_attachState(vp) == VOL_STATE_UNATTACHED) ||
(V_attachState(vp) == VOL_STATE_PREATTACHED)) {
res->hdr.reason = FSYNC_WRONG_PART;
}
} else {
- code = SYNC_DENIED;
+ code = SYNC_FAILED;
res->hdr.reason = FSYNC_UNKNOWN_VOLID;
}
#endif
VDeregisterVolOp_r(vp);
}
#else /* !AFS_DEMAND_ATTACH_FS */
- tvolName[0] = '/';
+ tvolName[0] = OS_DIRSEPC;
snprintf(&tvolName[1], sizeof(tvolName)-1, VFORMAT, afs_printable_uint32_lu(vcom->vop->volume));
tvolName[sizeof(tvolName)-1] = '\0';
if (vp->salvage.requested && !vp->salvage.scheduled) {
vp->salvage.scheduled = 1;
}
+
+ /* If the volume is in VOL_STATE_SALVAGE_REQ, we need to wait
+ * for the vol to go offline before we can give it away. Also
+ * make sure we don't come out with vp in an excl state. */
+ while (V_attachState(vp) == VOL_STATE_SALVAGE_REQ ||
+ VIsExclusiveState(V_attachState(vp))) {
+
+ VOL_CV_WAIT(&V_attachCV(vp));
+ }
+
case debugUtility:
break;
case volumeUtility:
case volumeServer:
- if (V_attachState(vp) == VOL_STATE_SALVAGING ||
- vp->salvage.requested) {
-
+ if (VIsSalvaging(vp)) {
Log("denying offline request for volume %lu; volume is in salvaging state\n",
afs_printable_uint32_lu(vp->hashid));
res->hdr.reason = FSYNC_SALVAGE;
case VOL_STATE_PREATTACHED:
case VOL_STATE_SALVAGING:
case VOL_STATE_ERROR:
+ case VOL_STATE_DELETED:
/* register the volume operation metadata with the volume
*
* if the volume is currently pre-attached, attach2()
/* convert to heavyweight ref */
nvp = VGetVolumeByVp_r(&error, vp);
- VCancelReservation_r(rvp);
- rvp = NULL;
-
if (!nvp) {
/*
* It's possible for VGetVolumeByVp_r to have dropped and
case VOL_STATE_PREATTACHED:
case VOL_STATE_SALVAGING:
case VOL_STATE_ERROR:
+ case VOL_STATE_DELETED:
/* register the volume operation metadata with the volume
*
* if the volume is currently pre-attached, attach2()
break;
}
- Log("FSYNC_com_VolOff: failed to get heavyweight reference to volume %u\n",
- vcom->vop->volume);
+ Log("FSYNC_com_VolOff: failed to get heavyweight reference to volume %u (state=%u, flags=0x%x)\n",
+ vcom->vop->volume, V_attachState(vp), V_attachFlags(vp));
res->hdr.reason = FSYNC_VOL_PKG_ERROR;
goto deny;
} else if (nvp != vp) {
vp = nvp;
}
+ /* kill off lightweight ref to ensure we can't deadlock against ourselves later... */
+ VCancelReservation_r(rvp);
+ rvp = NULL;
+
/* register the volume operation metadata with the volume */
VRegisterVolOp_r(vp, &info);
#ifdef AFS_DEMAND_ATTACH_FS
VOfflineForVolOp_r(&error, vp, "A volume utility is running.");
if (error==0) {
- assert(vp->nUsers==0);
+ osi_Assert(vp->nUsers==0);
vp->pending_vol_op->vol_op_state = FSSYNC_VolOpRunningOffline;
}
else {
VChangeState_r(vp, VOL_STATE_DELETED);
VDeregisterVolOp_r(vp);
+ /* Volume is gone; clear out old salvage stats */
+ memset(&vp->salvage, 0, sizeof(vp->salvage));
+
/* Someday we should free the vp, too, after about 2 hours,
* possibly by putting the vp back on the VLRU. */
vp = VLookupVolume_r(&error, vcom->vop->volume, NULL);
if (vp && vp->pending_vol_op) {
- assert(sizeof(FSSYNC_VolOp_info) <= res->payload.len);
+ osi_Assert(sizeof(FSSYNC_VolOp_info) <= res->payload.len);
memcpy(res->payload.buf, vp->pending_vol_op, sizeof(FSSYNC_VolOp_info));
res->hdr.response_len += sizeof(FSSYNC_VolOp_info);
} else {
- if (vp) {
- res->hdr.reason = FSYNC_NO_PENDING_VOL_OP;
- } else {
+ if (!vp || V_attachState(vp) == VOL_STATE_DELETED) {
res->hdr.reason = FSYNC_UNKNOWN_VOLID;
+ } else if (!FSYNC_partMatch(vcom, vp, 1)) {
+ res->hdr.reason = FSYNC_WRONG_PART;
+ } else {
+ res->hdr.reason = FSYNC_NO_PENDING_VOL_OP;
}
code = SYNC_FAILED;
}
goto done;
}
- assert(sizeof(FSSYNC_VGQry_response_t) <= res->payload.len);
+ osi_Assert(sizeof(FSSYNC_VGQry_response_t) <= res->payload.len);
rc = VVGCache_query_r(dp, vcom->vop->volume, res->payload.buf);
switch (rc) {
Volume *vp;
- tvolName[0] = '/';
+ tvolName[0] = OS_DIRSEPC;
sprintf(&tvolName[1], VFORMAT, afs_printable_uint32_lu(p[i].volumeID));
vp = VAttachVolumeByName_r(&error, p[i].partName, tvolName,
V_VOLUPD);
AcceptOn(void)
{
if (AcceptHandler == -1) {
- assert(AddHandler(fssync_server_state.fd, FSYNC_newconnection));
+ osi_Assert(AddHandler(fssync_server_state.fd, FSYNC_newconnection));
AcceptHandler = FindHandler(fssync_server_state.fd);
}
}
AcceptOff(void)
{
if (AcceptHandler != -1) {
- assert(RemoveHandler(fssync_server_state.fd));
+ osi_Assert(RemoveHandler(fssync_server_state.fd));
AcceptHandler = -1;
}
}
int i;
ObtainWriteLock(&FSYNC_handler_lock);
for (i = 0; i < MAXHANDLERS; i++) {
- HandlerFD[i] = -1;
+ HandlerFD[i] = OSI_NULLSOCKET;
HandlerProc[i] = 0;
}
ReleaseWriteLock(&FSYNC_handler_lock);
int i;
ObtainWriteLock(&FSYNC_handler_lock);
for (i = 0; i < MAXHANDLERS; i++)
- if (HandlerFD[i] == -1)
+ if (HandlerFD[i] == OSI_NULLSOCKET)
break;
if (i >= MAXHANDLERS) {
ReleaseWriteLock(&FSYNC_handler_lock);
return i;
}
ReleaseReadLock(&FSYNC_handler_lock); /* just in case */
- assert(1 == 2);
+ osi_Assert(1 == 2);
return -1; /* satisfy compiler */
}
if (HandlerFD[i] == afd) {
return i;
}
- assert(1 == 2);
+ osi_Assert(1 == 2);
return -1; /* satisfy compiler */
}
RemoveHandler(osi_socket afd)
{
ObtainWriteLock(&FSYNC_handler_lock);
- HandlerFD[FindHandler_r(afd)] = -1;
+ HandlerFD[FindHandler_r(afd)] = OSI_NULLSOCKET;
ReleaseWriteLock(&FSYNC_handler_lock);
return 1;
}
int fdi = 0;
ObtainReadLock(&FSYNC_handler_lock);
for (i = 0; i < MAXHANDLERS; i++)
- if (HandlerFD[i] != -1) {
- assert(fdi<maxfds);
+ if (HandlerFD[i] != OSI_NULLSOCKET) {
+ osi_Assert(fdi<maxfds);
fds[fdi].fd = HandlerFD[i];
fds[fdi].events = events;
fds[fdi].revents = 0;
FD_ZERO(fdsetp);
ObtainReadLock(&FSYNC_handler_lock); /* just in case */
for (i = 0; i < MAXHANDLERS; i++)
- if (HandlerFD[i] != -1) {
+ if (HandlerFD[i] != OSI_NULLSOCKET) {
FD_SET(HandlerFD[i], fdsetp);
#ifndef AFS_NT40_ENV
/* On Windows the nfds parameter to select() is ignored */
git://git.openafs.org / openafs.git / blobdiff