src/vol/fssync-client.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  *
   9  * Portions Copyright (c) 2006,2008 Sine Nomine Associates
  10  */
  11
  12 /*
  13         System:         VICE-TWO
  14         Module:         fssync.c
  15         Institution:    The Information Technology Center, Carnegie-Mellon University
  16
  17  */
  18 #ifdef notdef
  19
  20 /* All this is going away in early 1989 */
  21 int newVLDB;                    /* Compatibility flag */
  22
  23 #endif
  24 static int newVLDB = 1;
  25
  26
  27 #ifndef AFS_PTHREAD_ENV
  28 #define USUAL_PRIORITY (LWP_MAX_PRIORITY - 2)
  29
  30 /*
  31  * stack size increased from 8K because the HP machine seemed to have trouble
  32  * with the smaller stack
  33  */
  34 #define USUAL_STACK_SIZE        (24 * 1024)
  35 #endif /* !AFS_PTHREAD_ENV */
  36
  37 /*
  38    fssync-client.c
  39    File server synchronization with external volume utilities.
  40    client-side implementation
  41  */
  42
  43 #include <afsconfig.h>
  44 #include <afs/param.h>
  45
  46 RCSID
  47     ("$Header$");
  48
  49 #include <sys/types.h>
  50 #include <stdio.h>
  51 #ifdef AFS_NT40_ENV
  52 #include <winsock2.h>
  53 #include <time.h>
  54 #else
  55 #include <sys/param.h>
  56 #include <sys/socket.h>
  57 #include <netinet/in.h>
  58 #include <netdb.h>
  59 #include <sys/time.h>
  60 #endif
  61 #include <errno.h>
  62 #ifdef AFS_PTHREAD_ENV
  63 #include <assert.h>
  64 #else /* AFS_PTHREAD_ENV */
  65 #include <afs/assert.h>
  66 #endif /* AFS_PTHREAD_ENV */
  67 #include <signal.h>
  68 #include <string.h>
  69
  70 #include <rx/xdr.h>
  71 #include <afs/afsint.h>
  72 #include "nfs.h"
  73 #include <afs/errors.h>
  74 #include "daemon_com.h"
  75 #include "fssync.h"
  76 #include "lwp.h"
  77 #include "lock.h"
  78 #include <afs/afssyscalls.h>
  79 #include "ihandle.h"
  80 #include "vnode.h"
  81 #include "volume.h"
  82 #include "partition.h"
  83
  84 #ifdef FSSYNC_BUILD_CLIENT
  85
  86 /*@printflike@*/ extern void Log(const char *format, ...);
  87
  88 extern int LogLevel;
  89
  90 static SYNC_client_state fssync_state =
  91     { -1,                    /* file descriptor */
  92       FSSYNC_ENDPOINT_DECL,  /* server endpoint */
  93       FSYNC_PROTO_VERSION,   /* protocol version */
  94       5,                     /* connect retry limit */
  95       120,                   /* hard timeout */
  96       "FSSYNC",              /* protocol name string */
  97     };
  98
  99 #ifdef AFS_PTHREAD_ENV
 100 static pthread_mutex_t vol_fsync_mutex;
 101 static volatile vol_fsync_mutex_init = 0;
 102 #define VFSYNC_LOCK \
 103     assert(pthread_mutex_lock(&vol_fsync_mutex) == 0)
 104 #define VFSYNC_UNLOCK \
 105     assert(pthread_mutex_unlock(&vol_fsync_mutex) == 0)
 106 #else
 107 #define VFSYNC_LOCK
 108 #define VFSYNC_UNLOCK
 109 #endif
 110
 111 int
 112 FSYNC_clientInit(void)
 113 {
 114 #ifdef AFS_PTHREAD_ENV
 115     /* this is safe since it gets called with VOL_LOCK held, or before we go multithreaded */
 116     if (!vol_fsync_mutex_init) {
 117         assert(pthread_mutex_init(&vol_fsync_mutex, NULL) == 0);
 118         vol_fsync_mutex_init = 1;
 119     }
 120 #endif
 121     return SYNC_connect(&fssync_state);
 122 }
 123
 124 void
 125 FSYNC_clientFinis(void)
 126 {
 127     SYNC_closeChannel(&fssync_state);
 128 }
 129
 130 int
 131 FSYNC_clientChildProcReconnect(void)
 132 {
 133     return SYNC_reconnect(&fssync_state);
 134 }
 135
 136 /* fsync client interface */
 137 afs_int32
 138 FSYNC_askfs(SYNC_command * com, SYNC_response * res)
 139 {
 140     afs_int32 code;
 141
 142     VFSYNC_LOCK;
 143     code = SYNC_ask(&fssync_state, com, res);
 144     VFSYNC_UNLOCK;
 145
 146     switch (code) {
 147     case SYNC_OK:
 148     case SYNC_FAILED:
 149         break;
 150     case SYNC_COM_ERROR:
 151     case SYNC_BAD_COMMAND:
 152         Log("FSYNC_askfs: fatal FSSYNC protocol error; volume management functionality disabled until next fileserver restart\n");
 153         break;
 154     case SYNC_DENIED:
 155         Log("FSYNC_askfs: FSSYNC request denied for reason=%d\n", res->hdr.reason);
 156         break;
 157     default:
 158         Log("FSYNC_askfs: unknown protocol response %d\n", code);
 159         break;
 160     }
 161     return code;
 162 }
 163
 164 afs_int32
 165 FSYNC_GenericOp(void * ext_hdr, size_t ext_len,
 166               int command, int reason,
 167               SYNC_response * res_in)
 168 {
 169     SYNC_response res_l, *res;
 170     SYNC_command com;
 171
 172     if (res_in) {
 173         res = res_in;
 174     } else {
 175         res = &res_l;
 176         res_l.payload.buf = NULL;
 177         res_l.payload.len = 0;
 178     }
 179
 180     memset(&com, 0, sizeof(com));
 181
 182     com.hdr.programType = programType;
 183     com.hdr.command = command;
 184     com.hdr.reason = reason;
 185     com.hdr.command_len = sizeof(com.hdr) + ext_len;
 186     com.payload.buf = ext_hdr;
 187     com.payload.len = ext_len;
 188
 189     return FSYNC_askfs(&com, res);
 190 }
 191
 192 afs_int32
 193 FSYNC_VolOp(VolumeId volume, char * partition,
 194             int command, int reason,
 195             SYNC_response * res)
 196 {
 197     FSSYNC_VolOp_hdr vcom;
 198
 199     memset(&vcom, 0, sizeof(vcom));
 200
 201     vcom.volume = volume;
 202     if (partition)
 203         strlcpy(vcom.partName, partition, sizeof(vcom.partName));
 204
 205     return FSYNC_GenericOp(&vcom, sizeof(vcom), command, reason, res);
 206 }
 207
 208 afs_int32
 209 FSYNC_StatsOp(FSSYNC_StatsOp_hdr * scom, int command, int reason,
 210               SYNC_response * res)
 211 {
 212     return FSYNC_GenericOp(scom, sizeof(*scom), command, reason, res);
 213 }
 214
 215
 216 #endif /* FSSYNC_BUILD_CLIENT */