* directory or online at http://www.openafs.org/dl/license10.html
*/
+#include <afsconfig.h>
#include <afs/param.h>
+#include <roken.h>
+
#include <afs/stds.h>
#include <afs/cellconfig.h>
+#include <afs/afs_consts.h>
#include <afs/ptserver.h>
#include <ubik.h>
{
long code;
- code = buf_CleanVnode(scp, userp, reqp);
+ code = cm_FSync(scp, userp, reqp, FALSE);
if (!code) {
lock_ObtainWrite(&scp->rw);
cm_DiscardSCache(scp);
#ifdef AFS_FREELANCE_CLIENT
if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
- cm_noteLocalMountPointChange();
+ cm_noteLocalMountPointChange(FALSE);
return 0;
}
#endif
{
afs_int32 code = 0;
cm_scache_t *scp;
- int i;
+ unsigned int i;
#ifdef AFS_FREELANCE_CLIENT
if ( cell == AFS_FAKE_ROOT_CELL_ID && volume == AFS_FAKE_ROOT_VOL_ID ) {
- cm_noteLocalMountPointChange();
+ cm_noteLocalMountPointChange(FALSE);
return 0;
}
#endif
if ((ioctlp->flags & CM_IOCTLFLAG_USEUTF8) == CM_IOCTLFLAG_USEUTF8) {
cchout = cm_ClientStringToUtf8(cstr, cchlen, outp,
- SMB_IOCTL_MAXDATA - (outp - ioctlp->outAllocp));
+ (int)(SMB_IOCTL_MAXDATA - (outp - ioctlp->outAllocp)));
} else {
if (smb_StoreAnsiFilenames) {
cchout = WideCharToMultiByte(CP_ACP, 0, cstr, cchlen,
outp,
- SMB_IOCTL_MAXDATA - (outp - ioctlp->outAllocp),
+ (int)(SMB_IOCTL_MAXDATA - (outp - ioctlp->outAllocp)),
NULL, NULL);
} else {
cchout = WideCharToMultiByte(CP_OEMCP, 0, cstr, cchlen,
outp,
- SMB_IOCTL_MAXDATA - (outp - ioctlp->outAllocp),
+ (int)(SMB_IOCTL_MAXDATA - (outp - ioctlp->outAllocp)),
NULL, NULL);
}
}
cm_ioctlQueryOptions_t *
cm_IoctlGetQueryOptions(struct cm_ioctl *ioctlp, struct cm_user *userp)
{
- afs_uint32 pathlen = strlen(ioctlp->inDatap) + 1;
+ afs_uint32 pathlen = (afs_uint32) strlen(ioctlp->inDatap) + 1;
char *p = ioctlp->inDatap + pathlen;
cm_ioctlQueryOptions_t * optionsp = NULL;
{
cm_ioctlQueryOptions_t * optionsp = (cm_ioctlQueryOptions_t *)ioctlp->inDatap;
ioctlp->inDatap += optionsp->size;
+ ioctlp->inCopied -= optionsp->size;
}
/* format the specified path to look like "/afs/<cellname>/usr", by
if (!cm_ClientStrCmpNI(inpathp, cm_mountRootC, cm_mountRootCLen))
cm_ClientStrCpy(outpathp, cchlen, inpathp);
else if (!cm_ClientStrCmpNI(inpathp, bslash_mountRoot,
- cm_ClientStrLen(bslash_mountRoot)))
+ (int)cm_ClientStrLen(bslash_mountRoot)))
cm_ClientStrCpy(outpathp, cchlen, inpathp);
else if ((inpathp[0] == '/') || (inpathp[0] == '\\'))
cm_ClientStrPrintfN(outpathp, cchlen, _C("%s%s"), cm_mountRootC, inpathp);
int tlen;
struct rx_connection * rxconnp;
+ memset(&volSync, 0, sizeof(volSync));
+
/* now make the get acl call */
#ifdef AFS_FREELANCE_CLIENT
if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
AFSFid fid;
struct rx_connection * rxconnp;
+ memset(&volSync, 0, sizeof(volSync));
+
#ifdef AFS_FREELANCE_CLIENT
if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
code = CM_ERROR_NOACCESS;
{
afs_int32 code;
cm_scache_t *scp;
- int i;
+ unsigned int i;
lock_ObtainWrite(&cm_scacheLock);
for (i=0; i<cm_data.scacheHashTableSize; i++) {
lock_ReleaseWrite(&scp->rw);
#ifdef USE_BPLUS
- code = cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_READ, &dirop);
+ code = cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_READ,
+ CM_DIROP_FLAG_NONE, &dirop);
if (code == 0) {
code = cm_BPlusDirLookupOriginalName(&dirop, cp, &originalName);
/* The cm_Dir* functions can't be used to lookup the
char *tp;
char *cp;
long temp;
- cm_server_t *tsp;
+ cm_server_t *tsp, *csp;
int haveCell;
tp = ioctlp->inDatap;
for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
if (cellp && tsp->cellp != cellp)
continue; /* cell spec'd and wrong */
- if ((tsp->flags & CM_SERVERFLAG_DOWN)
- && tsp->type == CM_SERVER_FILE) {
- memcpy(cp, (char *)&tsp->addr.sin_addr.s_addr, sizeof(long));
- cp += sizeof(long);
+ if (tsp->flags & CM_SERVERFLAG_DOWN) {
+ /*
+ * for a multi-homed file server, if one of the interfaces
+ * is up, do not report the server as down.
+ */
+ if (tsp->type == CM_SERVER_FILE) {
+ for (csp = cm_allServersp; csp; csp=csp->allNextp) {
+ if (csp->type == CM_SERVER_FILE &&
+ !(csp->flags & CM_SERVERFLAG_DOWN) &&
+ afs_uuid_equal(&tsp->uuid, &csp->uuid)) {
+ break;
+ }
+ }
+ if (csp) /* found alternate up interface */
+ continue;
+ }
+
+ /*
+ * all server types are being reported by ipaddr. only report
+ * a server once regardless of how many services are down.
+ */
+ for (tp = ioctlp->outDatap; tp < cp; tp += sizeof(long)) {
+ if (!memcmp(tp, (char *)&tsp->addr.sin_addr.s_addr, sizeof(long)))
+ break;
+ }
+
+ if (tp == cp) {
+ memcpy(cp, (char *)&tsp->addr.sin_addr.s_addr, sizeof(long));
+ cp += sizeof(long);
+ }
}
}
lock_ReleaseRead(&cm_serverLock);
afs_int32
cm_IoctlCheckVolumes(cm_ioctl_t *ioctlp, cm_user_t *userp)
{
- cm_RefreshVolumes();
+ cm_RefreshVolumes(0);
return 0;
}
/* delete all previous server lists - cm_FreeServerList will ask for write on cm_ServerLock*/
cm_FreeServerList(&cp->vlServersp, CM_FREESERVERLIST_DELETE);
- cp->vlServersp = NULL;
lock_ReleaseWrite(&cm_cellLock);
rock.cellp = cp;
code = cm_SearchCellRegistry(1, cp->name, cp->name, cp->linkedName, cm_AddCellProc, &rock);
if (code && code != CM_ERROR_FORCE_DNS_LOOKUP)
code = cm_SearchCellFileEx(cp->name, cp->name, cp->linkedName, cm_AddCellProc, &rock);
-#ifdef AFS_AFSDB_ENV
if (code) {
if (cm_dnsEnabled) {
int ttl;
cp->flags &= ~CM_CELLFLAG_DNS;
lock_ReleaseMutex(&cp->mx);
}
-#endif /* AFS_AFSDB_ENV */
if (code) {
lock_ObtainMutex(&cp->mx);
cp->flags |= CM_CELLFLAG_VLSERVER_INVALID;
}
/*
+ * VIOCNEWCELL2 internals.
+ *
+ * Assumes that pioctl path has been parsed or skipped.
+ *
+ * The pioctl data buffer consists of the following structure:
+ *
+ * afs_uint32 flags
+ * afs_uint32 alternative fs port
+ * afs_uint32 alternative vl port
+ * afs_uint32 count of vldb servers
+ * char[] cellname
+ * char[] linkedcell
+ * n * char[] hostnames
+ */
+afs_int32
+cm_IoctlNewCell2(struct cm_ioctl *ioctlp, struct cm_user *userp)
+{
+ afs_uint32 code = 0;
+ afs_uint32 flags = 0;
+ afs_uint32 fsport = 0;
+ afs_uint32 vlport = 0;
+ afs_uint32 i, host_count = 0;
+ char * cellname = NULL;
+ char * linked_cellname = NULL;
+ char *tp;
+ size_t tplen;
+ afs_uint32 *lp;
+ char * hostname[AFS_MAXHOSTS];
+ size_t len;
+
+ memset(hostname, 0, sizeof(hostname));
+
+ tp = ioctlp->inDatap;
+ tplen = ioctlp->inCopied;
+ lp = (afs_uint32 *)tp;
+
+ if (tplen >= 4 * sizeof(afs_uint32)) {
+ flags = *lp++;
+ fsport = *lp++;
+ vlport = *lp++;
+ host_count = *lp++;
+ tp = (char *)lp;
+ tplen -= 4 * sizeof(afs_uint32);
+ }
+
+ if ( FAILED(StringCbLength(tp, tplen, &len)) ||
+ len + 1 > CELL_MAXNAMELEN)
+ return CM_ERROR_INVAL;
+ cellname = tp;
+ tp += len + 1;
+ tplen -= (len + 1);
+
+ if ( FAILED(StringCbLength(tp, tplen, &len)) ||
+ len + 1 > CELL_MAXNAMELEN)
+ return CM_ERROR_INVAL;
+ linked_cellname = tp;
+ tp += len + 1;
+ tplen -= (len + 1);
+
+ if (!(flags & VIOC_NEWCELL2_FLAG_USEDNS)) {
+ for ( i=0; i<host_count; i++) {
+ if ( FAILED(StringCbLength(tp, tplen, &len)) )
+ return CM_ERROR_INVAL;
+ hostname[i] = tp;
+ tp += len + 1;
+ tplen -= (len + 1);
+ }
+ }
+
+ code = cm_CreateCellWithInfo( cellname, linked_cellname,
+ vlport, host_count,
+ hostname,
+ (flags & VIOC_NEWCELL2_FLAG_USEDNS) ? CM_CELLFLAG_DNS : 0);
+
+ if (code == 0 && (flags & VIOC_NEWCELL2_FLAG_USEREG)) {
+ cm_AddCellToRegistry( cellname, linked_cellname,
+ vlport, host_count,
+ hostname,
+ (flags & VIOC_NEWCELL2_FLAG_USEDNS) ? CM_CELLFLAG_DNS : 0);
+ }
+ return code;
+}
+
+/*
* VIOC_GET_WS_CELL internals.
*
* Assumes that pioctl path has been parsed or skipped.
afs_uint32 setSysName;
char *cp, *cp2;
clientchar_t *inname = NULL;
- int t, count;
+ int t;
+ unsigned int count;
memcpy(&setSysName, ioctlp->inDatap, sizeof(afs_uint32));
ioctlp->inDatap += sizeof(afs_uint32);
}
cm_sysNameCount = setSysName;
} else {
- afs_int32 i32;
+ afs_uint32 i32;
/* return the sysname to the caller */
i32 = cm_sysNameCount;
srvin = &(spin->servers[i]);
rank = srvin->rank + (rand() & 0x000f);
tmp.sin_addr = srvin->host;
+ switch (type) {
+ case CM_SERVER_VLDB:
+ tmp.sin_port = htons(7003);
+ break;
+ case CM_SERVER_FILE:
+ tmp.sin_port = htons(7000);
+ break;
+ }
tmp.sin_family = AF_INET;
tsp = cm_FindServer(&tmp, type);
if ( tsp ) /* an existing server - ref count increased */
{
- tsp->ipRank = rank; /* no need to protect by mutex*/
-
- if (type == CM_SERVER_FILE)
- { /* fileserver */
- /* find volumes which might have RO copy
- /* on server and change the ordering of
+ lock_ObtainMutex(&tsp->mx);
+ tsp->ipRank = rank;
+ tsp->flags |= CM_SERVERFLAG_PREF_SET;
+ tsp->adminRank = tsp->ipRank;
+ lock_ReleaseMutex(&tsp->mx);
+
+ switch (type) {
+ case CM_SERVER_FILE:
+ /*
+ * find volumes which might have RO copy
+ * on server and change the ordering of
* their RO list
*/
cm_ChangeRankVolume(tsp);
- }
- else
- {
+ break;
+ case CM_SERVER_VLDB:
/* set preferences for an existing vlserver */
cm_ChangeRankCellVLServer(tsp);
+ break;
}
}
else /* add a new server without a cell */
{
tsp = cm_NewServer(&tmp, type, NULL, NULL, CM_FLAG_NOPROBE); /* refcount = 1 */
+ lock_ObtainMutex(&tsp->mx);
+ tsp->ipRank = rank;
+ tsp->flags |= CM_SERVERFLAG_PREF_SET;
+ tsp->adminRank = tsp->ipRank;
+ lock_ReleaseMutex(&tsp->mx);
tsp->ipRank = rank;
}
- lock_ObtainMutex(&tsp->mx);
- tsp->flags |= CM_SERVERFLAG_PREF_SET;
- lock_ReleaseMutex(&tsp->mx);
cm_PutServer(tsp); /* decrease refcount */
}
return 0;
lock_ReleaseWrite(&scp->rw);
#ifdef USE_BPLUS
- code = cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_READ, &dirop);
+ code = cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_READ,
+ CM_DIROP_FLAG_NONE, &dirop);
if (code == 0) {
code = cm_BPlusDirLookupOriginalName(&dirop, clientp, &originalName);
/* cm_Dir*() functions can't be used to lookup the original
lock_ReleaseMutex(&userp->mx);
- cm_RegisterNewTokenEvent(uuid, ucellp->sessionKey.data);
+ cm_RegisterNewTokenEvent(uuid, ucellp->sessionKey.data, NULL);
return 0;
}
return code;
}
+
+/*
+ * VIOC_GETUNIXMODE internals.
+ *
+ * Assumes that pioctl path has been parsed or skipped.
+ * scp is held but not locked.
+ */
+afs_int32
+cm_IoctlGetUnixMode(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *scp, cm_req_t *reqp)
+{
+ afs_int32 code = 0;
+ char *cp;
+
+ lock_ObtainWrite(&scp->rw);
+ code = cm_SyncOp(scp, NULL, userp, reqp, 0,
+ CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ if (code == 0)
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ lock_ReleaseWrite(&scp->rw);
+
+ if (code == 0) {
+ /* Copy all this junk into msg->im_data, keeping track of the lengths. */
+ cp = ioctlp->outDatap;
+ memcpy(cp, (char *)&scp->unixModeBits, sizeof(afs_uint32));
+ cp += sizeof(afs_uint32);
+
+ /* return new size */
+ ioctlp->outDatap = cp;
+ }
+ return code;
+}
+
+
+/*
+ * VIOC_SETUNIXMODE internals.
+ *
+ * Assumes that pioctl path has been parsed or skipped
+ * and that cm_ioctlQueryOptions_t have been parsed and skipped.
+ *
+ * scp is held but not locked.
+ */
+afs_int32
+cm_IoctlSetUnixMode(struct cm_ioctl *ioctlp, struct cm_user *userp, cm_scache_t *scp, cm_req_t *reqp)
+{
+ afs_int32 code = 0;
+ char *cp;
+
+ lock_ObtainWrite(&scp->rw);
+ code = cm_SyncOp(scp, NULL, userp, reqp, 0,
+ CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ if (code == 0)
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ lock_ReleaseWrite(&scp->rw);
+
+ if (code == 0) {
+ afs_uint32 unixModeBits;
+ cm_attr_t attr;
+
+ memset(&attr, 0, sizeof(attr));
+
+ cp = ioctlp->inDatap;
+ memcpy((char *)&unixModeBits, cp, sizeof(afs_uint32));
+
+ attr.mask = CM_ATTRMASK_UNIXMODEBITS;
+ attr.unixModeBits = unixModeBits;
+
+ code = cm_SetAttr(scp, &attr, userp, reqp);
+ }
+ return code;
+}
git://git.openafs.org / openafs.git / blobdiff