vol-osi-assert-20080401
[openafs.git] / 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 */