Fix a whole host of warnings in the demand attach code.
Make a broken tvolser build stop the build, rather than carrying on
regardless.
Reviewed-on: http://gerrit.openafs.org/551
Tested-by: Derrick Brashear <shadow@dementia.org>
Reviewed-by: Derrick Brashear <shadow@dementia.org>
*_darwin_[1-6][0-9]) \
echo Not building MT volser for ${SYS_NAME} ;; \
*_darwin_*|alpha_dux*|sgi_*|sun*_5*|rs_aix*|*linux*|hp_ux11*|ia64_hpux*|*obsd*) \
- ${COMPILE_PART1} tvolser ${COMPILE_PART2} ; \
+ ${COMPILE_PART1} tvolser ${COMPILE_PART2} && \
if [ "xyes" = "x$(ENABLE_PTHREADED_UNIK)" ] ; then \
$(MAKE) $(COMPILE_PART2B)_vos; \
fi;; \
hdr_static_inline(unsigned long) afs_printable_uint32_lu(afs_uint32 d) { return (unsigned long) d; }
#if !defined(__GNUC__) || __GNUC__ < 2
-#define AFS_UNUSED_FUNCTION
+#define AFS_UNUSED
#else
-#define AFS_UNUSED_FUNCTION __attribute__((unused))
+#define AFS_UNUSED __attribute__((unused))
#endif
#endif /* OPENAFS_CONFIG_AFS_STDS_H */
#define dpf(args) do { if (rxdebug_active) rxi_DebugPrint args; } while (0)
#else
#ifdef DPF_FSLOG
+#include <afs/afsutil.h>
#define dpf(args) FSLog args
#else
#define dpf(args) do { if (rx_debugFile) rxi_DebugPrint args; } while (0)
#include <rx/xdr.h>
#include <afs/afsint.h>
#include <afs/assert.h>
-
+#include <afs/dir.h>
#include <fcntl.h>
static char * response_code_to_string(afs_int32);
static char * command_code_to_string(afs_int32);
static char * reason_code_to_string(afs_int32);
-static char * program_type_to_string(afs_int32);
static char * state_code_to_string(afs_int32);
{
struct cmd_syndesc *ts;
int err = 0;
- int i;
- extern char cml_version_number[];
/* Initialize directory paths */
if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
common_salv_prolog(struct cmd_syndesc * as, struct state * state)
{
register struct cmd_item *ti;
- char pname[100], *temp;
state->sop = (struct salv_state *) calloc(1, sizeof(struct salv_state));
assert(state->sop != NULL);
printf("}\n");
VDisconnectSALV();
+
+ return 0;
}
static char *
}
}
+#if 0
static char *
program_type_to_string(afs_int32 type)
{
return "**UNKNOWN**";
}
}
+#endif
static char *
state_code_to_string(afs_int32 state)
msync(state->mmap.map, state->mmap.size, MS_SYNC);
- done:
return ret;
}
#else /* !FS_STATE_USE_MMAP */
int ret = 0;
memset(state, 0, sizeof(struct fs_dump_state));
state->fd = -1;
- state->fn = AFSDIR_SERVER_FSSTATE_FILEPATH;
+ state->fn = (char *)AFSDIR_SERVER_FSSTATE_FILEPATH;
state->hdr = (struct fs_state_header *)malloc(sizeof(struct fs_state_header));
state->h_hdr = (struct host_state_header *)malloc(sizeof(struct host_state_header));
state->cb_hdr = (struct callback_state_header *)malloc(sizeof(struct callback_state_header));
byte cb_valid;
} cb_cursor;
-static struct {
- void ** cursor;
-} cb_cache;
-
static void
usage(char * prog)
{
main(int argc, char ** argv)
{
banner();
-
if (argc > 2 || (argc == 2 && !strcmp(argv[1], "-h"))) {
usage(argv[0]);
return 1;
if (openFile(argv[1]))
return 1;
} else {
- if (openFile(AFSDIR_SERVER_FSSTATE_FILEPATH))
+ if (openFile((char *)AFSDIR_SERVER_FSSTATE_FILEPATH))
return 1;
}
goto done;
}
- printf("mapped %d bytes at 0x%x\n", map_len, map);
+ printf("mapped %lu bytes at %"AFS_PTR_FMT"\n", (unsigned long)map_len, map);
done:
if (ret) {
do { \
char * _p = (char *)addr; \
char * _m = (char *)map; \
- printf("loading structure from address 0x%x (offset %u)\n", \
+ printf("loading structure from address %"AFS_PTR_FMT" (offset %u)\n", \
addr, _p-_m); \
} while (0)
static void
dump_he_hcps(void)
{
- char temp_str[40];
afs_int32 * hcps;
int len, i;
{
int i;
unsigned char * p = (unsigned char *)map;
- afs_uint32 c32;
if (!len)
return;
if ((offset + len) > map_len) {
- fprintf(stderr, "offset + length exceeds memory map size (%u > %u)\n",
- offset+len, map_len);
+ fprintf(stderr, "offset + length exceeds memory map size (%u > %lu)\n",
+ offset+len, (unsigned long)map_len);
return;
}
static int
get_cb_timeout(void)
{
- char * buf;
-
if (hdrs.timeout)
return 0;
static int
get_cb_fehash(void)
{
- char * buf;
-
if (hdrs.fehash)
return 0;
static int
get_cb(afs_uint32 idx)
{
- int i;
char * p;
if (get_fe(fe_cursor.idx))
return 0;
}
+#if 0
static int
find_he_by_index(afs_uint32 idx)
{
}
return 1;
}
+#endif
static int
find_fe_by_index(afs_uint32 idx)
ret = 1;
}
- done:
return ret;
}
}
}
- done:
return ret;
}
ret = 1;
}
- done:
return ret;
}
}
}
- done:
return ret;
}
struct CBDiskEntry cbdsk[16];
struct iovec iov[16];
struct FileEntry * fe;
- struct CallBack * cb;
iov[0].iov_base = (char *)&hdr;
iov[0].iov_len = sizeof(hdr);
sprintf(tmpStr, "%04x", host->holds[i]);
(void)STREAM_WRITE(tmpStr, strlen(tmpStr), 1, file);
}
- sprintf(tmpStr, " slot/bit: %d/%d\n", h_holdSlot(), h_holdbit());
+ sprintf(tmpStr, " slot/bit: %ld/%d\n", (long int) h_holdSlot(),
+ h_holdbit());
(void)STREAM_WRITE(tmpStr, strlen(tmpStr), 1, file);
H_UNLOCK;
static int h_stateFillHeader(struct host_state_header * hdr);
static int h_stateCheckHeader(struct host_state_header * hdr);
static int h_stateAllocMap(struct fs_dump_state * state);
-static int h_stateSaveHost(register struct host * host, int held, struct fs_dump_state * state);
+static int h_stateSaveHost(struct host * host, int held, void *rock);
static int h_stateRestoreHost(struct fs_dump_state * state);
-static int h_stateRestoreIndex(struct host * h, int held, struct fs_dump_state * state);
-static int h_stateVerifyHost(struct host * h, int held, struct fs_dump_state * state);
+static int h_stateRestoreIndex(struct host * h, int held, void *rock);
+static int h_stateVerifyHost(struct host * h, int held, void *rock);
static int h_stateVerifyAddrHash(struct fs_dump_state * state, struct host * h, afs_uint32 addr, afs_uint16 port);
static int h_stateVerifyUuidHash(struct fs_dump_state * state, struct host * h);
static void h_hostToDiskEntry_r(struct host * in, struct hostDiskEntry * out);
}
static int
-h_stateRestoreIndex(struct host * h, int held, struct fs_dump_state * state)
+h_stateRestoreIndex(struct host * h, int held, void *rock)
{
+ struct fs_dump_state *state = (struct fs_dump_state *)rock;
if (cb_OldToNew(state, h->cblist, &h->cblist)) {
return H_ENUMERATE_BAIL(held);
}
}
static int
-h_stateVerifyHost(struct host * h, int held, struct fs_dump_state * state)
+h_stateVerifyHost(struct host * h, int held, void* rock)
{
+ struct fs_dump_state *state = (struct fs_dump_state *)rock;
int i;
if (h == NULL) {
state->bail = 1;
}
- done:
return held;
}
{
hdr->stamp.magic = HOST_STATE_MAGIC;
hdr->stamp.version = HOST_STATE_VERSION;
+ return 0;
}
/* check the contents of the host state header structure */
/* function called by h_Enumerate to save a host to disk */
static int
-h_stateSaveHost(register struct host * host, int held, struct fs_dump_state * state)
+h_stateSaveHost(struct host * host, int held, void* rock)
{
- int i, if_len=0, hcps_len=0;
+ struct fs_dump_state *state = (struct fs_dump_state *) rock;
+ int if_len=0, hcps_len=0;
struct hostDiskEntry hdsk;
struct host_state_entry_header hdr;
struct Interface * ifp = NULL;
state->h_hdr->records++;
- done:
if (ifp)
free(ifp);
if (hcps)
*new = state->h_map.entries[old].new_idx;
}
- done:
return ret;
}
#endif /* AFS_DEMAND_ATTACH_FS */
#ifdef AFS_PTHREAD_ENV
static pthread_mutex_t vol_fsync_mutex;
-static volatile vol_fsync_mutex_init = 0;
+static volatile int vol_fsync_mutex_init = 0;
#define VFSYNC_LOCK \
assert(pthread_mutex_lock(&vol_fsync_mutex) == 0)
#define VFSYNC_UNLOCK \
FSYNC_com_VolOn(FSSYNC_VolOp_command * vcom, SYNC_response * res)
{
afs_int32 code = SYNC_OK;
+#ifndef AFS_DEMAND_ATTACH_FS
char tvolName[VMAXPATHLEN];
+#endif
Volume * vp;
Error error;
Volume * vp;
Error error;
#ifdef AFS_DEMAND_ATTACH_FS
- int reserved = 0;
Volume *nvp;
#endif
static struct DiskPartition64 * VLookupPartition_r(char * path);
static void AddPartitionToTable_r(struct DiskPartition64 *);
-static void DeletePartitionFromTable_r(struct DiskPartition64 *);
#endif /* AFS_DEMAND_ATTACH_FS */
#ifdef AFS_SGI_XFS_IOPS_ENV
struct DiskPartition64 *
VGetPartitionById(afs_int32 id, int abortp)
{
- struct Diskpartition64 * dp;
+ struct DiskPartition64 * dp;
VOL_LOCK;
dp = VGetPartitionById_r(id, abortp);
DiskPartitionTable[dp->index] = dp;
}
+#if 0
static void
DeletePartitionFromTable_r(struct DiskPartition64 *dp)
{
assert(dp->index >= 0 && dp->index <= VOLMAXPARTS);
DiskPartitionTable[dp->index] = NULL;
}
+#endif
#endif /* AFS_DEMAND_ATTACH_FS */
#include <afs/afsutil.h>
#include <afs/fileutil.h>
#include <afs/procmgmt.h> /* signal(), kill(), wait(), etc. */
+#include <afs/dir.h>
#ifndef AFS_NT40_ENV
#include <syslog.h>
#endif
#include "salvsync.h"
#include "viceinode.h"
#include "salvage.h"
-#include "volinodes.h" /* header magic number, etc. stuff */
#include "vol-salvage.h"
#ifdef AFS_NT40_ENV
#include <pthread.h>
static void SalvageServer(void);
static void SalvageClient(VolumeId vid, char * pname);
-static int ChildFailed(int status);
-
static int Reap_Child(char * prog, int * pid, int * status);
static void * SalvageLogCleanupThread(void *);
{
register struct cmd_item *ti;
char pname[100], *temp;
- afs_int32 seenpart = 0, seenvol = 0, vid = 0, seenany = 0;
- struct DiskPartition64 *partP;
-
+ afs_int32 seenpart = 0, seenvol = 0, vid = 0;
#ifdef AFS_SGI_VNODE_GLUE
if (afs_init_kernel_config(-1) < 0) {
}
if ((ti = as->parms[15].items)) { /* -datelogs */
- TimeStampLogFile(AFSDIR_SERVER_SALSRVLOG_FILEPATH);
+ TimeStampLogFile((char *)AFSDIR_SERVER_SALSRVLOG_FILEPATH);
}
#endif
int err = 0;
int i;
- extern char cml_version_number[];
#ifdef AFS_AIX32_ENV
/*
* multiple salvagers appending to the log.
*/
- CheckLogFile(AFSDIR_SERVER_SALSRVLOG_FILEPATH);
+ CheckLogFile((char *)AFSDIR_SERVER_SALSRVLOG_FILEPATH);
#ifndef AFS_NT40_ENV
#ifdef AFS_LINUX20_ENV
fcntl(fileno(logFile), F_SETFL, O_APPEND); /* Isn't this redundant? */
DoSalvageVolume(struct SalvageQueueNode * node, int slot)
{
char childLog[AFSDIR_PATH_MAX];
- int ret;
struct DiskPartition64 * partP;
/* do not allow further forking inside salvager */
static void *
SalvageChildReaperThread(void * args)
{
- int slot, pid, status, code, found;
- struct SalvageQueueNode *qp, *nqp;
+ int slot, pid, status;
struct log_cleanup_node * cleanup;
- SALVSYNC_command_info info;
assert(pthread_mutex_lock(&worker_lock) == 0);
SalvageLogScanningThread(void * arg)
{
struct rx_queue log_watch_queue;
- struct log_cleanup_node * cleanup;
queue_Init(&log_watch_queue);
SYNC_response res_l, *res;
SALVSYNC_command_hdr scom;
SALVSYNC_response_hdr sres;
- int n, tot;
memset(&com, 0, sizeof(com));
memset(&scom, 0, sizeof(scom));
SYNC_response res_l, *res;
SALVSYNC_command_hdr scom;
SALVSYNC_response_hdr sres;
- int n, tot;
memset(&com, 0, sizeof(com));
memset(&scom, 0, sizeof(scom));
static void DeleteFromSalvageQueue(struct SalvageQueueNode * node);
static void AddToPendingQueue(struct SalvageQueueNode * node);
static void DeleteFromPendingQueue(struct SalvageQueueNode * node);
-static struct SalvageQueueNode * LookupPendingCommand(SALVSYNC_command_hdr * qry);
static struct SalvageQueueNode * LookupPendingCommandByPid(int pid);
static void UpdateCommandPrio(struct SalvageQueueNode * node);
static void HandlePrio(struct SalvageQueueNode * clone,
static struct SalvageQueueNode * LookupNodeByCommand(SALVSYNC_command_hdr * qry,
struct SalvageQueueNode ** parent);
static void AddNodeToHash(struct SalvageQueueNode * node);
-static void DeleteNodeFromHash(struct SalvageQueueNode * node);
static afs_int32 SALVSYNC_com_Salvage(SALVSYNC_command * com, SALVSYNC_response * res);
static afs_int32 SALVSYNC_com_Cancel(SALVSYNC_command * com, SALVSYNC_response * res);
SalvageHashTable[idx].len++;
}
+#if 0
static void
DeleteNodeFromHash(struct SalvageQueueNode * node)
{
queue_Remove(&node->hash_chain);
SalvageHashTable[idx].len--;
}
+#endif
void
SALVSYNC_salvInit(void)
static void *
SALVSYNC_syncThread(void * args)
{
- int on = 1;
int code;
- int numTries;
- int tid;
SYNC_server_state_t * state = &salvsync_server_state;
/* when we fork, the child needs to close the salvsync server sockets,
#else /* USE_UNIX_SOCKETS */
struct sockaddr_in other;
#endif
- int junk, fd;
+ int fd;
+ socklen_t junk;
+
junk = sizeof(other);
fd = accept(afd, (struct sockaddr *)&other, &junk);
if (fd == -1) {
case SALVSYNC_STATE_UNKNOWN:
node->command.sop.prio = 0;
break;
+ default:
+ break;
}
if (new_prio < clone->command.sop.prio) {
}
}
+#if 0
static struct SalvageQueueNode *
LookupPendingCommand(SALVSYNC_command_hdr * qry)
{
np = NULL;
return np;
}
+#endif
static struct SalvageQueueNode *
LookupPendingCommandByPid(int pid)
struct SalvageQueueNode *
SALVSYNC_getWork(void)
{
- int i, ret;
+ int i;
struct DiskPartition64 * dp = NULL, * fdp;
static afs_int32 next_part_sched = 0;
- struct SalvageQueueNode *node = NULL, *np;
+ struct SalvageQueueNode *node = NULL;
VOL_LOCK;
}
}
- bail:
VOL_UNLOCK;
return node;
}
case VN_STATE_EXCLUSIVE:
case VN_STATE_STORE:
return 1;
+ default:
+ return 0;
}
- return 0;
}
/**
switch (state) {
case VN_STATE_ERROR:
return 1;
+ default:
+ return 0;
}
- return 0;
}
/**
#else
#define NO_LINK_TABLE 1
#endif
+AFS_UNUSED
private struct stuff {
struct versionStamp stamp;
bit32 inodeType;
/* online salvager */
static int VCheckSalvage(register Volume * vp);
static int VUpdateSalvagePriority_r(Volume * vp);
+#ifdef SALVSYNC_BUILD_CLIENT
static int VScheduleSalvage_r(Volume * vp);
+#endif
/* Volume hash table */
static void VReorderHash_r(VolumeHashChainHead * head, Volume * pp, Volume * vp);
* shutdown all remaining volumes
*/
+#ifdef AFS_DEMAND_ATTACH_FS
+
void
VShutdown_r(void)
{
int i;
- register Volume *vp, *np;
- register afs_int32 code;
-#ifdef AFS_DEMAND_ATTACH_FS
struct DiskPartition64 * diskP;
struct diskpartition_queue_t * dpq;
vshutdown_thread_t params;
}
Log("VShutdown: complete.\n");
+}
+
#else /* AFS_DEMAND_ATTACH_FS */
+
+void
+VShutdown_r(void)
+{
+ int i;
+ register Volume *vp, *np;
+ register afs_int32 code;
Log("VShutdown: shutting down on-line volumes...\n");
for (i = 0; i < VolumeHashTable.Size; i++) {
/* try to hold first volume in the hash table */
}
}
Log("VShutdown: complete.\n");
-#endif /* AFS_DEMAND_ATTACH_FS */
}
+#endif /* AFS_DEMAND_ATTACH_FS */
+
void
VShutdown(void)
if (thr_left) {
/* try to assign any leftover threads to partitions that
* had volume lengths closer to needing thread_target+1 */
- int max_residue, max_id;
+ int max_residue, max_id = 0;
/* compute the residues */
for (diskP = DiskPartitionList; diskP; diskP = diskP->next) {
static void *
VShutdownThread(void * args)
{
- struct rx_queue *qp;
- Volume * vp;
vshutdown_thread_t * params;
- int part, code, found, pass, schedule_version_save, count;
+ int found, pass, schedule_version_save, count;
struct DiskPartition64 *diskP;
struct diskpartition_queue_t * dpq;
Device id;
int
VShutdownByPartition_r(struct DiskPartition64 * dp)
{
- int pass, retVal;
+ int pass;
int pass_stats[4];
int total;
Log("VShutdownByPartition: shut down %d volumes on %s (pass[0]=%d, pass[1]=%d, pass[2]=%d, pass[3]=%d)\n",
total, VPartitionPath(dp), pass_stats[0], pass_stats[1], pass_stats[2], pass_stats[3]);
- return retVal;
+ return 0;
}
/* internal shutdown functionality
VOffline_r(vp, "File server was shut down");
}
break;
+ default:
+ break;
}
VCancelReservation_r(vp);
char path[64];
int isbusy = 0;
VolId volumeId;
- Volume * nvp;
+ Volume * nvp = NULL;
VolumeStats stats_save;
*ec = 0;
}
#ifdef AFS_DEMAND_ATTACH_FS
+# ifdef FSSYNC_BUILD_CLIENT
disk_header_loaded:
+#endif
if (!*ec) {
/* check for pending volume operations */
if (VVolOpSetVBusy_r(vp, vp->pending_vol_op)) {
vp->specialStatus = VBUSY;
}
+ default:
+ break;
}
}
void
VOffline_r(Volume * vp, char *message)
{
+#ifndef AFS_DEMAND_ATTACH_FS
Error error;
VolumeId vid = V_id(vp);
+#endif
assert(programType != volumeUtility);
if (!V_inUse(vp)) {
static int
VUpdateSalvagePriority_r(Volume * vp)
{
- int code, ret=0;
- afs_uint32 now;
+ int ret=0;
#ifdef SALVSYNC_BUILD_CLIENT
+ afs_uint32 now;
+ int code;
+
vp->salvage.prio++;
now = FT_ApproxTime();
}
+#ifdef SALVSYNC_BUILD_CLIENT
/**
* schedule a salvage with the salvage server.
*
static int
VScheduleSalvage_r(Volume * vp)
{
- int code, ret=0;
-#ifdef SALVSYNC_BUILD_CLIENT
+ int ret=0;
+ int code;
VolState state_save;
VThreadOptions_t * thread_opts;
char partName[16];
}
}
}
-#endif /* SALVSYNC_BUILD_CLIENT */
return ret;
}
-#ifdef SALVSYNC_BUILD_CLIENT
/**
* connect to the salvageserver SYNC service.
*
int
VDisconnectSALV(void)
{
- int retVal;
VOL_LOCK;
VDisconnectSALV_r();
VOL_UNLOCK;
- return retVal;
+ return 0;
}
/**
static void
VLRU_UpdateAccess_r(Volume * vp)
{
- afs_uint32 live_interval;
Volume * rvp = NULL;
if (!VLRU_enabled)
VLRU_ScannerThread(void * args)
{
afs_uint32 now, min_delay, delay;
- afs_uint32 next_scan[VLRU_GENERATIONS];
- afs_uint32 next_promotion[VLRU_GENERATIONS];
int i, min_idx, min_op, overdue, state;
/* set t=0 for promotion cycle to be
int len, chaining, promote;
afs_uint32 now, thresh;
struct rx_queue *qp, *nqp;
- Volume * vp, *start, *end;
+ Volume * vp, *start = NULL, *end = NULL;
/* get exclusive access to two chains, and drop the glock */
VLRU_Wait_r(&volume_LRU.q[idx]);
int len, chaining, demote;
afs_uint32 now, thresh;
struct rx_queue *qp, *nqp;
- Volume * vp, *start, *end;
+ Volume * vp, *start = NULL, *end = NULL;
Volume ** salv_flag_vec = NULL;
int salv_vec_offset = 0;
V_attachFlags(vp) &= ~(VOL_ON_VLRU);
VCancelReservation_r(vp);
return 0;
+ default:
+ break;
}
/* hold the volume and take it offline.
static int everLogged = 0;
#ifdef AFS_DEMAND_ATTACH_FS
- VolState vp_save, back_save;
+ VolState vp_save = 0, back_save = 0;
/* XXX debug 9/19/05 we've apparently got
* a ref counting bug somewhere that's
void
VPrintExtendedCacheStats_r(int flags)
{
- int i, j;
+ int i;
afs_uint32 vol_sum = 0;
struct stats {
double min;
extern int VRegisterVolOp_r(Volume * vp, FSSYNC_VolOp_info * vopinfo);
extern int VDeregisterVolOp_r(Volume * vp);
extern void VCancelReservation_r(Volume * vp);
+extern int VChildProcReconnectFS_r(void);
+extern void VOfflineForVolOp_r(Error *ec, Volume *vp, char *message);
#endif /* AFS_DEMAND_ATTACH_FS */
extern int VVolOpLeaveOnline_r(Volume * vp, FSSYNC_VolOp_info * vopinfo);
extern int VVolOpSetVBusy_r(Volume * vp, FSSYNC_VolOp_info * vopinfo);
case VOL_STATE_VNODE_CLOSE:
case VOL_STATE_VNODE_RELEASE:
return 1;
+ default:
+ return 0;
}
- return 0;
}
/**
case VOL_STATE_ERROR:
case VOL_STATE_SALVAGING:
return 1;
+ default:
+ return 0;
}
- return 0;
}
/**
case VOL_STATE_ERROR:
case VOL_STATE_SALVAGING:
return 1;
+ default:
+ return 0;
}
- return 0;
}
/**
return 0;
}
-AFS_UNUSED_FUNCTION
+AFS_UNUSED
static afs_int32
DumpStandardTagLen(register struct iod *iodp, char tag, afs_uint32 section,
afs_size_t length)
/* Background daemon for sleeping so the volserver does not become I/O bound */
afs_int32 TTsleep, TTrun;
+#ifndef AFS_PTHREAD_ENV
static void *
BKGSleep(void *unused)
{
}
return NULL;
}
+#endif
#ifndef AFS_NT40_ENV
int
char namehead[9];
struct partList partList;
struct DiskPartition64 *dp;
- int i, j = 0, k;
+ int i, j = 0;
strcpy(namehead, "/vicep"); /*7 including null terminator */
namehead[6] = i + 'a';
namehead[7] = '\0';
} else {
+ int k;
+
k = i - 26;
namehead[6] = 'a' + (k / 26);
namehead[7] = 'a' + (k % 26);
#define _VOLSER_PROTOTYPES_H
/* common.c */
-#ifndef AFS_PTHREAD_ENV
extern void Log(const char *, ...);
-#endif
extern void InitErrTabs(void);
/* vol_split.c */