1 // SPDX-License-Identifier: GPL-2.0-or-later 1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* AFS Cache Manager Service 2 /* AFS Cache Manager Service 3 * 3 * 4 * Copyright (C) 2002 Red Hat, Inc. All Rights 4 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved. 5 * Written by David Howells (dhowells@redhat.c 5 * Written by David Howells (dhowells@redhat.com) 6 */ 6 */ 7 7 8 #include <linux/module.h> 8 #include <linux/module.h> 9 #include <linux/init.h> 9 #include <linux/init.h> 10 #include <linux/slab.h> 10 #include <linux/slab.h> 11 #include <linux/sched.h> 11 #include <linux/sched.h> 12 #include <linux/ip.h> 12 #include <linux/ip.h> 13 #include "internal.h" 13 #include "internal.h" 14 #include "afs_cm.h" 14 #include "afs_cm.h" 15 #include "protocol_yfs.h" 15 #include "protocol_yfs.h" 16 #define RXRPC_TRACE_ONLY_DEFINE_ENUMS << 17 #include <trace/events/rxrpc.h> << 18 16 19 static int afs_deliver_cb_init_call_back_state 17 static int afs_deliver_cb_init_call_back_state(struct afs_call *); 20 static int afs_deliver_cb_init_call_back_state 18 static int afs_deliver_cb_init_call_back_state3(struct afs_call *); 21 static int afs_deliver_cb_probe(struct afs_cal 19 static int afs_deliver_cb_probe(struct afs_call *); 22 static int afs_deliver_cb_callback(struct afs_ 20 static int afs_deliver_cb_callback(struct afs_call *); 23 static int afs_deliver_cb_probe_uuid(struct af 21 static int afs_deliver_cb_probe_uuid(struct afs_call *); 24 static int afs_deliver_cb_tell_me_about_yourse 22 static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *); 25 static void afs_cm_destructor(struct afs_call 23 static void afs_cm_destructor(struct afs_call *); 26 static void SRXAFSCB_CallBack(struct work_stru 24 static void SRXAFSCB_CallBack(struct work_struct *); 27 static void SRXAFSCB_InitCallBackState(struct 25 static void SRXAFSCB_InitCallBackState(struct work_struct *); 28 static void SRXAFSCB_Probe(struct work_struct 26 static void SRXAFSCB_Probe(struct work_struct *); 29 static void SRXAFSCB_ProbeUuid(struct work_str 27 static void SRXAFSCB_ProbeUuid(struct work_struct *); 30 static void SRXAFSCB_TellMeAboutYourself(struc 28 static void SRXAFSCB_TellMeAboutYourself(struct work_struct *); 31 29 32 static int afs_deliver_yfs_cb_callback(struct 30 static int afs_deliver_yfs_cb_callback(struct afs_call *); 33 31 >> 32 #define CM_NAME(name) \ >> 33 char afs_SRXCB##name##_name[] __tracepoint_string = \ >> 34 "CB." #name >> 35 34 /* 36 /* 35 * CB.CallBack operation type 37 * CB.CallBack operation type 36 */ 38 */ >> 39 static CM_NAME(CallBack); 37 static const struct afs_call_type afs_SRXCBCal 40 static const struct afs_call_type afs_SRXCBCallBack = { 38 .name = "CB.CallBack", !! 41 .name = afs_SRXCBCallBack_name, 39 .deliver = afs_deliver_cb_callb 42 .deliver = afs_deliver_cb_callback, 40 .destructor = afs_cm_destructor, 43 .destructor = afs_cm_destructor, 41 .work = SRXAFSCB_CallBack, 44 .work = SRXAFSCB_CallBack, 42 }; 45 }; 43 46 44 /* 47 /* 45 * CB.InitCallBackState operation type 48 * CB.InitCallBackState operation type 46 */ 49 */ >> 50 static CM_NAME(InitCallBackState); 47 static const struct afs_call_type afs_SRXCBIni 51 static const struct afs_call_type afs_SRXCBInitCallBackState = { 48 .name = "CB.InitCallBackStat !! 52 .name = afs_SRXCBInitCallBackState_name, 49 .deliver = afs_deliver_cb_init_ 53 .deliver = afs_deliver_cb_init_call_back_state, 50 .destructor = afs_cm_destructor, 54 .destructor = afs_cm_destructor, 51 .work = SRXAFSCB_InitCallBac 55 .work = SRXAFSCB_InitCallBackState, 52 }; 56 }; 53 57 54 /* 58 /* 55 * CB.InitCallBackState3 operation type 59 * CB.InitCallBackState3 operation type 56 */ 60 */ >> 61 static CM_NAME(InitCallBackState3); 57 static const struct afs_call_type afs_SRXCBIni 62 static const struct afs_call_type afs_SRXCBInitCallBackState3 = { 58 .name = "CB.InitCallBackStat !! 63 .name = afs_SRXCBInitCallBackState3_name, 59 .deliver = afs_deliver_cb_init_ 64 .deliver = afs_deliver_cb_init_call_back_state3, 60 .destructor = afs_cm_destructor, 65 .destructor = afs_cm_destructor, 61 .work = SRXAFSCB_InitCallBac 66 .work = SRXAFSCB_InitCallBackState, 62 }; 67 }; 63 68 64 /* 69 /* 65 * CB.Probe operation type 70 * CB.Probe operation type 66 */ 71 */ >> 72 static CM_NAME(Probe); 67 static const struct afs_call_type afs_SRXCBPro 73 static const struct afs_call_type afs_SRXCBProbe = { 68 .name = "CB.Probe", !! 74 .name = afs_SRXCBProbe_name, 69 .deliver = afs_deliver_cb_probe 75 .deliver = afs_deliver_cb_probe, 70 .destructor = afs_cm_destructor, 76 .destructor = afs_cm_destructor, 71 .work = SRXAFSCB_Probe, 77 .work = SRXAFSCB_Probe, 72 }; 78 }; 73 79 74 /* 80 /* 75 * CB.ProbeUuid operation type 81 * CB.ProbeUuid operation type 76 */ 82 */ >> 83 static CM_NAME(ProbeUuid); 77 static const struct afs_call_type afs_SRXCBPro 84 static const struct afs_call_type afs_SRXCBProbeUuid = { 78 .name = "CB.ProbeUuid", !! 85 .name = afs_SRXCBProbeUuid_name, 79 .deliver = afs_deliver_cb_probe 86 .deliver = afs_deliver_cb_probe_uuid, 80 .destructor = afs_cm_destructor, 87 .destructor = afs_cm_destructor, 81 .work = SRXAFSCB_ProbeUuid, 88 .work = SRXAFSCB_ProbeUuid, 82 }; 89 }; 83 90 84 /* 91 /* 85 * CB.TellMeAboutYourself operation type 92 * CB.TellMeAboutYourself operation type 86 */ 93 */ >> 94 static CM_NAME(TellMeAboutYourself); 87 static const struct afs_call_type afs_SRXCBTel 95 static const struct afs_call_type afs_SRXCBTellMeAboutYourself = { 88 .name = "CB.TellMeAboutYours !! 96 .name = afs_SRXCBTellMeAboutYourself_name, 89 .deliver = afs_deliver_cb_tell_ 97 .deliver = afs_deliver_cb_tell_me_about_yourself, 90 .destructor = afs_cm_destructor, 98 .destructor = afs_cm_destructor, 91 .work = SRXAFSCB_TellMeAbout 99 .work = SRXAFSCB_TellMeAboutYourself, 92 }; 100 }; 93 101 94 /* 102 /* 95 * YFS CB.CallBack operation type 103 * YFS CB.CallBack operation type 96 */ 104 */ >> 105 static CM_NAME(YFS_CallBack); 97 static const struct afs_call_type afs_SRXYFSCB 106 static const struct afs_call_type afs_SRXYFSCB_CallBack = { 98 .name = "YFSCB.CallBack", !! 107 .name = afs_SRXCBYFS_CallBack_name, 99 .deliver = afs_deliver_yfs_cb_c 108 .deliver = afs_deliver_yfs_cb_callback, 100 .destructor = afs_cm_destructor, 109 .destructor = afs_cm_destructor, 101 .work = SRXAFSCB_CallBack, 110 .work = SRXAFSCB_CallBack, 102 }; 111 }; 103 112 104 /* 113 /* 105 * route an incoming cache manager call 114 * route an incoming cache manager call 106 * - return T if supported, F if not 115 * - return T if supported, F if not 107 */ 116 */ 108 bool afs_cm_incoming_call(struct afs_call *cal 117 bool afs_cm_incoming_call(struct afs_call *call) 109 { 118 { 110 _enter("{%u, CB.OP %u}", call->service 119 _enter("{%u, CB.OP %u}", call->service_id, call->operation_ID); 111 120 >> 121 call->epoch = rxrpc_kernel_get_epoch(call->net->socket, call->rxcall); >> 122 112 switch (call->operation_ID) { 123 switch (call->operation_ID) { 113 case CBCallBack: 124 case CBCallBack: 114 call->type = &afs_SRXCBCallBac 125 call->type = &afs_SRXCBCallBack; 115 return true; 126 return true; 116 case CBInitCallBackState: 127 case CBInitCallBackState: 117 call->type = &afs_SRXCBInitCal 128 call->type = &afs_SRXCBInitCallBackState; 118 return true; 129 return true; 119 case CBInitCallBackState3: 130 case CBInitCallBackState3: 120 call->type = &afs_SRXCBInitCal 131 call->type = &afs_SRXCBInitCallBackState3; 121 return true; 132 return true; 122 case CBProbe: 133 case CBProbe: 123 call->type = &afs_SRXCBProbe; 134 call->type = &afs_SRXCBProbe; 124 return true; 135 return true; 125 case CBProbeUuid: 136 case CBProbeUuid: 126 call->type = &afs_SRXCBProbeUu 137 call->type = &afs_SRXCBProbeUuid; 127 return true; 138 return true; 128 case CBTellMeAboutYourself: 139 case CBTellMeAboutYourself: 129 call->type = &afs_SRXCBTellMeA 140 call->type = &afs_SRXCBTellMeAboutYourself; 130 return true; 141 return true; 131 case YFSCBCallBack: 142 case YFSCBCallBack: 132 if (call->service_id != YFS_CM 143 if (call->service_id != YFS_CM_SERVICE) 133 return false; 144 return false; 134 call->type = &afs_SRXYFSCB_Cal 145 call->type = &afs_SRXYFSCB_CallBack; 135 return true; 146 return true; 136 default: 147 default: 137 return false; 148 return false; 138 } 149 } 139 } 150 } 140 151 141 /* 152 /* >> 153 * Record a probe to the cache manager from a server. >> 154 */ >> 155 static int afs_record_cm_probe(struct afs_call *call, struct afs_server *server) >> 156 { >> 157 _enter(""); >> 158 >> 159 if (test_bit(AFS_SERVER_FL_HAVE_EPOCH, &server->flags) && >> 160 !test_bit(AFS_SERVER_FL_PROBING, &server->flags)) { >> 161 if (server->cm_epoch == call->epoch) >> 162 return 0; >> 163 >> 164 if (!server->probe.said_rebooted) { >> 165 pr_notice("kAFS: FS rebooted %pU\n", &server->uuid); >> 166 server->probe.said_rebooted = true; >> 167 } >> 168 } >> 169 >> 170 spin_lock(&server->probe_lock); >> 171 >> 172 if (!test_bit(AFS_SERVER_FL_HAVE_EPOCH, &server->flags)) { >> 173 server->cm_epoch = call->epoch; >> 174 server->probe.cm_epoch = call->epoch; >> 175 goto out; >> 176 } >> 177 >> 178 if (server->probe.cm_probed && >> 179 call->epoch != server->probe.cm_epoch && >> 180 !server->probe.said_inconsistent) { >> 181 pr_notice("kAFS: FS endpoints inconsistent %pU\n", >> 182 &server->uuid); >> 183 server->probe.said_inconsistent = true; >> 184 } >> 185 >> 186 if (!server->probe.cm_probed || call->epoch == server->cm_epoch) >> 187 server->probe.cm_epoch = server->cm_epoch; >> 188 >> 189 out: >> 190 server->probe.cm_probed = true; >> 191 spin_unlock(&server->probe_lock); >> 192 return 0; >> 193 } >> 194 >> 195 /* 142 * Find the server record by peer address and 196 * Find the server record by peer address and record a probe to the cache 143 * manager from a server. 197 * manager from a server. 144 */ 198 */ 145 static int afs_find_cm_server_by_peer(struct a 199 static int afs_find_cm_server_by_peer(struct afs_call *call) 146 { 200 { 147 struct sockaddr_rxrpc srx; 201 struct sockaddr_rxrpc srx; 148 struct afs_server *server; 202 struct afs_server *server; 149 struct rxrpc_peer *peer; << 150 203 151 peer = rxrpc_kernel_get_call_peer(call !! 204 rxrpc_kernel_get_peer(call->net->socket, call->rxcall, &srx); 152 205 153 server = afs_find_server(call->net, pe !! 206 server = afs_find_server(call->net, &srx); 154 if (!server) { 207 if (!server) { 155 trace_afs_cm_no_server(call, & 208 trace_afs_cm_no_server(call, &srx); 156 return 0; 209 return 0; 157 } 210 } 158 211 159 call->server = server; 212 call->server = server; 160 return 0; !! 213 return afs_record_cm_probe(call, server); 161 } 214 } 162 215 163 /* 216 /* 164 * Find the server record by server UUID and r 217 * Find the server record by server UUID and record a probe to the cache 165 * manager from a server. 218 * manager from a server. 166 */ 219 */ 167 static int afs_find_cm_server_by_uuid(struct a 220 static int afs_find_cm_server_by_uuid(struct afs_call *call, 168 struct a 221 struct afs_uuid *uuid) 169 { 222 { 170 struct afs_server *server; 223 struct afs_server *server; 171 224 172 rcu_read_lock(); 225 rcu_read_lock(); 173 server = afs_find_server_by_uuid(call- 226 server = afs_find_server_by_uuid(call->net, call->request); 174 rcu_read_unlock(); 227 rcu_read_unlock(); 175 if (!server) { 228 if (!server) { 176 trace_afs_cm_no_server_u(call, 229 trace_afs_cm_no_server_u(call, call->request); 177 return 0; 230 return 0; 178 } 231 } 179 232 180 call->server = server; 233 call->server = server; 181 return 0; !! 234 return afs_record_cm_probe(call, server); 182 } 235 } 183 236 184 /* 237 /* 185 * Clean up a cache manager call. 238 * Clean up a cache manager call. 186 */ 239 */ 187 static void afs_cm_destructor(struct afs_call 240 static void afs_cm_destructor(struct afs_call *call) 188 { 241 { 189 kfree(call->buffer); 242 kfree(call->buffer); 190 call->buffer = NULL; 243 call->buffer = NULL; 191 } 244 } 192 245 193 /* 246 /* 194 * Abort a service call from within an action << 195 */ << 196 static void afs_abort_service_call(struct afs_ << 197 enum rxrpc_ << 198 { << 199 rxrpc_kernel_abort_call(call->net->soc << 200 abort_code, er << 201 afs_set_call_complete(call, error, 0); << 202 } << 203 << 204 /* << 205 * The server supplied a list of callbacks tha 247 * The server supplied a list of callbacks that it wanted to break. 206 */ 248 */ 207 static void SRXAFSCB_CallBack(struct work_stru 249 static void SRXAFSCB_CallBack(struct work_struct *work) 208 { 250 { 209 struct afs_call *call = container_of(w 251 struct afs_call *call = container_of(work, struct afs_call, work); 210 252 211 _enter(""); 253 _enter(""); 212 254 213 /* We need to break the callbacks befo 255 /* We need to break the callbacks before sending the reply as the 214 * server holds up change visibility t 256 * server holds up change visibility till it receives our reply so as 215 * to maintain cache coherency. 257 * to maintain cache coherency. 216 */ 258 */ 217 if (call->server) { 259 if (call->server) { 218 trace_afs_server(call->server- !! 260 trace_afs_server(call->server, atomic_read(&call->server->usage), 219 refcount_read << 220 atomic_read(& << 221 afs_server_tr 261 afs_server_trace_callback); 222 afs_break_callbacks(call->serv 262 afs_break_callbacks(call->server, call->count, call->request); 223 } 263 } 224 264 225 afs_send_empty_reply(call); 265 afs_send_empty_reply(call); 226 afs_put_call(call); 266 afs_put_call(call); 227 _leave(""); 267 _leave(""); 228 } 268 } 229 269 230 /* 270 /* 231 * deliver request data to a CB.CallBack call 271 * deliver request data to a CB.CallBack call 232 */ 272 */ 233 static int afs_deliver_cb_callback(struct afs_ 273 static int afs_deliver_cb_callback(struct afs_call *call) 234 { 274 { 235 struct afs_callback_break *cb; 275 struct afs_callback_break *cb; 236 __be32 *bp; 276 __be32 *bp; 237 int ret, loop; 277 int ret, loop; 238 278 239 _enter("{%u}", call->unmarshall); 279 _enter("{%u}", call->unmarshall); 240 280 241 switch (call->unmarshall) { 281 switch (call->unmarshall) { 242 case 0: 282 case 0: 243 afs_extract_to_tmp(call); 283 afs_extract_to_tmp(call); 244 call->unmarshall++; 284 call->unmarshall++; 245 285 246 /* extract the FID array and i 286 /* extract the FID array and its count in two steps */ 247 fallthrough; !! 287 /* fall through */ 248 case 1: 288 case 1: 249 _debug("extract FID count"); 289 _debug("extract FID count"); 250 ret = afs_extract_data(call, t 290 ret = afs_extract_data(call, true); 251 if (ret < 0) 291 if (ret < 0) 252 return ret; 292 return ret; 253 293 254 call->count = ntohl(call->tmp) 294 call->count = ntohl(call->tmp); 255 _debug("FID count: %u", call-> 295 _debug("FID count: %u", call->count); 256 if (call->count > AFSCBMAX) 296 if (call->count > AFSCBMAX) 257 return afs_protocol_er !! 297 return afs_protocol_error(call, -EBADMSG, >> 298 afs_eproto_cb_fid_count); 258 299 259 call->buffer = kmalloc(array3_ 300 call->buffer = kmalloc(array3_size(call->count, 3, 4), 260 GFP_KER 301 GFP_KERNEL); 261 if (!call->buffer) 302 if (!call->buffer) 262 return -ENOMEM; 303 return -ENOMEM; 263 afs_extract_to_buf(call, call- 304 afs_extract_to_buf(call, call->count * 3 * 4); 264 call->unmarshall++; 305 call->unmarshall++; 265 306 266 fallthrough; !! 307 /* Fall through */ 267 case 2: 308 case 2: 268 _debug("extract FID array"); 309 _debug("extract FID array"); 269 ret = afs_extract_data(call, t 310 ret = afs_extract_data(call, true); 270 if (ret < 0) 311 if (ret < 0) 271 return ret; 312 return ret; 272 313 273 _debug("unmarshall FID array") 314 _debug("unmarshall FID array"); 274 call->request = kcalloc(call-> 315 call->request = kcalloc(call->count, 275 sizeof 316 sizeof(struct afs_callback_break), 276 GFP_KE 317 GFP_KERNEL); 277 if (!call->request) 318 if (!call->request) 278 return -ENOMEM; 319 return -ENOMEM; 279 320 280 cb = call->request; 321 cb = call->request; 281 bp = call->buffer; 322 bp = call->buffer; 282 for (loop = call->count; loop 323 for (loop = call->count; loop > 0; loop--, cb++) { 283 cb->fid.vid = ntoh 324 cb->fid.vid = ntohl(*bp++); 284 cb->fid.vnode = ntoh 325 cb->fid.vnode = ntohl(*bp++); 285 cb->fid.unique = ntoh 326 cb->fid.unique = ntohl(*bp++); 286 } 327 } 287 328 288 afs_extract_to_tmp(call); 329 afs_extract_to_tmp(call); 289 call->unmarshall++; 330 call->unmarshall++; 290 331 291 /* extract the callback array 332 /* extract the callback array and its count in two steps */ 292 fallthrough; !! 333 /* fall through */ 293 case 3: 334 case 3: 294 _debug("extract CB count"); 335 _debug("extract CB count"); 295 ret = afs_extract_data(call, t 336 ret = afs_extract_data(call, true); 296 if (ret < 0) 337 if (ret < 0) 297 return ret; 338 return ret; 298 339 299 call->count2 = ntohl(call->tmp 340 call->count2 = ntohl(call->tmp); 300 _debug("CB count: %u", call->c 341 _debug("CB count: %u", call->count2); 301 if (call->count2 != call->coun 342 if (call->count2 != call->count && call->count2 != 0) 302 return afs_protocol_er !! 343 return afs_protocol_error(call, -EBADMSG, 303 call->iter = &call->def_iter; !! 344 afs_eproto_cb_count); 304 iov_iter_discard(&call->def_it !! 345 call->_iter = &call->iter; >> 346 iov_iter_discard(&call->iter, READ, call->count2 * 3 * 4); 305 call->unmarshall++; 347 call->unmarshall++; 306 348 307 fallthrough; !! 349 /* Fall through */ 308 case 4: 350 case 4: 309 _debug("extract discard %zu/%u 351 _debug("extract discard %zu/%u", 310 iov_iter_count(call->it !! 352 iov_iter_count(&call->iter), call->count2 * 3 * 4); 311 353 312 ret = afs_extract_data(call, f 354 ret = afs_extract_data(call, false); 313 if (ret < 0) 355 if (ret < 0) 314 return ret; 356 return ret; 315 357 316 call->unmarshall++; 358 call->unmarshall++; 317 fallthrough; << 318 << 319 case 5: 359 case 5: 320 break; 360 break; 321 } 361 } 322 362 323 if (!afs_check_call_state(call, AFS_CA 363 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING)) 324 return afs_io_error(call, afs_ 364 return afs_io_error(call, afs_io_error_cm_reply); 325 365 326 /* we'll need the file server record a 366 /* we'll need the file server record as that tells us which set of 327 * vnodes to operate upon */ 367 * vnodes to operate upon */ 328 return afs_find_cm_server_by_peer(call 368 return afs_find_cm_server_by_peer(call); 329 } 369 } 330 370 331 /* 371 /* 332 * allow the fileserver to request callback st 372 * allow the fileserver to request callback state (re-)initialisation 333 */ 373 */ 334 static void SRXAFSCB_InitCallBackState(struct 374 static void SRXAFSCB_InitCallBackState(struct work_struct *work) 335 { 375 { 336 struct afs_call *call = container_of(w 376 struct afs_call *call = container_of(work, struct afs_call, work); 337 377 338 _enter("{%p}", call->server); 378 _enter("{%p}", call->server); 339 379 340 if (call->server) 380 if (call->server) 341 afs_init_callback_state(call-> 381 afs_init_callback_state(call->server); 342 afs_send_empty_reply(call); 382 afs_send_empty_reply(call); 343 afs_put_call(call); 383 afs_put_call(call); 344 _leave(""); 384 _leave(""); 345 } 385 } 346 386 347 /* 387 /* 348 * deliver request data to a CB.InitCallBackSt 388 * deliver request data to a CB.InitCallBackState call 349 */ 389 */ 350 static int afs_deliver_cb_init_call_back_state 390 static int afs_deliver_cb_init_call_back_state(struct afs_call *call) 351 { 391 { 352 int ret; 392 int ret; 353 393 354 _enter(""); 394 _enter(""); 355 395 356 afs_extract_discard(call, 0); 396 afs_extract_discard(call, 0); 357 ret = afs_extract_data(call, false); 397 ret = afs_extract_data(call, false); 358 if (ret < 0) 398 if (ret < 0) 359 return ret; 399 return ret; 360 400 361 /* we'll need the file server record a 401 /* we'll need the file server record as that tells us which set of 362 * vnodes to operate upon */ 402 * vnodes to operate upon */ 363 return afs_find_cm_server_by_peer(call 403 return afs_find_cm_server_by_peer(call); 364 } 404 } 365 405 366 /* 406 /* 367 * deliver request data to a CB.InitCallBackSt 407 * deliver request data to a CB.InitCallBackState3 call 368 */ 408 */ 369 static int afs_deliver_cb_init_call_back_state 409 static int afs_deliver_cb_init_call_back_state3(struct afs_call *call) 370 { 410 { 371 struct afs_uuid *r; 411 struct afs_uuid *r; 372 unsigned loop; 412 unsigned loop; 373 __be32 *b; 413 __be32 *b; 374 int ret; 414 int ret; 375 415 376 _enter(""); 416 _enter(""); 377 417 378 _enter("{%u}", call->unmarshall); 418 _enter("{%u}", call->unmarshall); 379 419 380 switch (call->unmarshall) { 420 switch (call->unmarshall) { 381 case 0: 421 case 0: 382 call->buffer = kmalloc_array(1 422 call->buffer = kmalloc_array(11, sizeof(__be32), GFP_KERNEL); 383 if (!call->buffer) 423 if (!call->buffer) 384 return -ENOMEM; 424 return -ENOMEM; 385 afs_extract_to_buf(call, 11 * 425 afs_extract_to_buf(call, 11 * sizeof(__be32)); 386 call->unmarshall++; 426 call->unmarshall++; 387 427 388 fallthrough; !! 428 /* Fall through */ 389 case 1: 429 case 1: 390 _debug("extract UUID"); 430 _debug("extract UUID"); 391 ret = afs_extract_data(call, f 431 ret = afs_extract_data(call, false); 392 switch (ret) { 432 switch (ret) { 393 case 0: break; 433 case 0: break; 394 case -EAGAIN: return 0; 434 case -EAGAIN: return 0; 395 default: return ret; 435 default: return ret; 396 } 436 } 397 437 398 _debug("unmarshall UUID"); 438 _debug("unmarshall UUID"); 399 call->request = kmalloc(sizeof 439 call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL); 400 if (!call->request) 440 if (!call->request) 401 return -ENOMEM; 441 return -ENOMEM; 402 442 403 b = call->buffer; 443 b = call->buffer; 404 r = call->request; 444 r = call->request; 405 r->time_low 445 r->time_low = b[0]; 406 r->time_mid 446 r->time_mid = htons(ntohl(b[1])); 407 r->time_hi_and_version 447 r->time_hi_and_version = htons(ntohl(b[2])); 408 r->clock_seq_hi_and_reserved 448 r->clock_seq_hi_and_reserved = ntohl(b[3]); 409 r->clock_seq_low 449 r->clock_seq_low = ntohl(b[4]); 410 450 411 for (loop = 0; loop < 6; loop+ 451 for (loop = 0; loop < 6; loop++) 412 r->node[loop] = ntohl( 452 r->node[loop] = ntohl(b[loop + 5]); 413 453 414 call->unmarshall++; 454 call->unmarshall++; 415 fallthrough; << 416 455 417 case 2: 456 case 2: 418 break; 457 break; 419 } 458 } 420 459 421 if (!afs_check_call_state(call, AFS_CA 460 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING)) 422 return afs_io_error(call, afs_ 461 return afs_io_error(call, afs_io_error_cm_reply); 423 462 424 /* we'll need the file server record a 463 /* we'll need the file server record as that tells us which set of 425 * vnodes to operate upon */ 464 * vnodes to operate upon */ 426 return afs_find_cm_server_by_uuid(call 465 return afs_find_cm_server_by_uuid(call, call->request); 427 } 466 } 428 467 429 /* 468 /* 430 * allow the fileserver to see if the cache ma 469 * allow the fileserver to see if the cache manager is still alive 431 */ 470 */ 432 static void SRXAFSCB_Probe(struct work_struct 471 static void SRXAFSCB_Probe(struct work_struct *work) 433 { 472 { 434 struct afs_call *call = container_of(w 473 struct afs_call *call = container_of(work, struct afs_call, work); 435 474 436 _enter(""); 475 _enter(""); 437 afs_send_empty_reply(call); 476 afs_send_empty_reply(call); 438 afs_put_call(call); 477 afs_put_call(call); 439 _leave(""); 478 _leave(""); 440 } 479 } 441 480 442 /* 481 /* 443 * deliver request data to a CB.Probe call 482 * deliver request data to a CB.Probe call 444 */ 483 */ 445 static int afs_deliver_cb_probe(struct afs_cal 484 static int afs_deliver_cb_probe(struct afs_call *call) 446 { 485 { 447 int ret; 486 int ret; 448 487 449 _enter(""); 488 _enter(""); 450 489 451 afs_extract_discard(call, 0); 490 afs_extract_discard(call, 0); 452 ret = afs_extract_data(call, false); 491 ret = afs_extract_data(call, false); 453 if (ret < 0) 492 if (ret < 0) 454 return ret; 493 return ret; 455 494 456 if (!afs_check_call_state(call, AFS_CA 495 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING)) 457 return afs_io_error(call, afs_ 496 return afs_io_error(call, afs_io_error_cm_reply); 458 return afs_find_cm_server_by_peer(call 497 return afs_find_cm_server_by_peer(call); 459 } 498 } 460 499 461 /* 500 /* 462 * Allow the fileserver to quickly find out if !! 501 * allow the fileserver to quickly find out if the fileserver has been rebooted 463 * rebooted. << 464 */ 502 */ 465 static void SRXAFSCB_ProbeUuid(struct work_str 503 static void SRXAFSCB_ProbeUuid(struct work_struct *work) 466 { 504 { 467 struct afs_call *call = container_of(w 505 struct afs_call *call = container_of(work, struct afs_call, work); 468 struct afs_uuid *r = call->request; 506 struct afs_uuid *r = call->request; 469 507 470 _enter(""); 508 _enter(""); 471 509 472 if (memcmp(r, &call->net->uuid, sizeof 510 if (memcmp(r, &call->net->uuid, sizeof(call->net->uuid)) == 0) 473 afs_send_empty_reply(call); 511 afs_send_empty_reply(call); 474 else 512 else 475 afs_abort_service_call(call, 1 !! 513 rxrpc_kernel_abort_call(call->net->socket, call->rxcall, >> 514 1, 1, "K-1"); 476 515 477 afs_put_call(call); 516 afs_put_call(call); 478 _leave(""); 517 _leave(""); 479 } 518 } 480 519 481 /* 520 /* 482 * deliver request data to a CB.ProbeUuid call 521 * deliver request data to a CB.ProbeUuid call 483 */ 522 */ 484 static int afs_deliver_cb_probe_uuid(struct af 523 static int afs_deliver_cb_probe_uuid(struct afs_call *call) 485 { 524 { 486 struct afs_uuid *r; 525 struct afs_uuid *r; 487 unsigned loop; 526 unsigned loop; 488 __be32 *b; 527 __be32 *b; 489 int ret; 528 int ret; 490 529 491 _enter("{%u}", call->unmarshall); 530 _enter("{%u}", call->unmarshall); 492 531 493 switch (call->unmarshall) { 532 switch (call->unmarshall) { 494 case 0: 533 case 0: 495 call->buffer = kmalloc_array(1 534 call->buffer = kmalloc_array(11, sizeof(__be32), GFP_KERNEL); 496 if (!call->buffer) 535 if (!call->buffer) 497 return -ENOMEM; 536 return -ENOMEM; 498 afs_extract_to_buf(call, 11 * 537 afs_extract_to_buf(call, 11 * sizeof(__be32)); 499 call->unmarshall++; 538 call->unmarshall++; 500 539 501 fallthrough; !! 540 /* Fall through */ 502 case 1: 541 case 1: 503 _debug("extract UUID"); 542 _debug("extract UUID"); 504 ret = afs_extract_data(call, f 543 ret = afs_extract_data(call, false); 505 switch (ret) { 544 switch (ret) { 506 case 0: break; 545 case 0: break; 507 case -EAGAIN: return 0; 546 case -EAGAIN: return 0; 508 default: return ret; 547 default: return ret; 509 } 548 } 510 549 511 _debug("unmarshall UUID"); 550 _debug("unmarshall UUID"); 512 call->request = kmalloc(sizeof 551 call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL); 513 if (!call->request) 552 if (!call->request) 514 return -ENOMEM; 553 return -ENOMEM; 515 554 516 b = call->buffer; 555 b = call->buffer; 517 r = call->request; 556 r = call->request; 518 r->time_low 557 r->time_low = b[0]; 519 r->time_mid 558 r->time_mid = htons(ntohl(b[1])); 520 r->time_hi_and_version 559 r->time_hi_and_version = htons(ntohl(b[2])); 521 r->clock_seq_hi_and_reserved 560 r->clock_seq_hi_and_reserved = ntohl(b[3]); 522 r->clock_seq_low 561 r->clock_seq_low = ntohl(b[4]); 523 562 524 for (loop = 0; loop < 6; loop+ 563 for (loop = 0; loop < 6; loop++) 525 r->node[loop] = ntohl( 564 r->node[loop] = ntohl(b[loop + 5]); 526 565 527 call->unmarshall++; 566 call->unmarshall++; 528 fallthrough; << 529 567 530 case 2: 568 case 2: 531 break; 569 break; 532 } 570 } 533 571 534 if (!afs_check_call_state(call, AFS_CA 572 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING)) 535 return afs_io_error(call, afs_ 573 return afs_io_error(call, afs_io_error_cm_reply); 536 return afs_find_cm_server_by_peer(call !! 574 return afs_find_cm_server_by_uuid(call, call->request); 537 } 575 } 538 576 539 /* 577 /* 540 * allow the fileserver to ask about the cache 578 * allow the fileserver to ask about the cache manager's capabilities 541 */ 579 */ 542 static void SRXAFSCB_TellMeAboutYourself(struc 580 static void SRXAFSCB_TellMeAboutYourself(struct work_struct *work) 543 { 581 { 544 struct afs_call *call = container_of(w 582 struct afs_call *call = container_of(work, struct afs_call, work); 545 int loop; 583 int loop; 546 584 547 struct { 585 struct { 548 struct /* InterfaceAddr */ { 586 struct /* InterfaceAddr */ { 549 __be32 nifs; 587 __be32 nifs; 550 __be32 uuid[11]; 588 __be32 uuid[11]; 551 __be32 ifaddr[32]; 589 __be32 ifaddr[32]; 552 __be32 netmask[32]; 590 __be32 netmask[32]; 553 __be32 mtu[32]; 591 __be32 mtu[32]; 554 } ia; 592 } ia; 555 struct /* Capabilities */ { 593 struct /* Capabilities */ { 556 __be32 capcount; 594 __be32 capcount; 557 __be32 caps[1]; 595 __be32 caps[1]; 558 } cap; 596 } cap; 559 } reply; 597 } reply; 560 598 561 _enter(""); 599 _enter(""); 562 600 563 memset(&reply, 0, sizeof(reply)); 601 memset(&reply, 0, sizeof(reply)); 564 602 565 reply.ia.uuid[0] = call->net->uuid.tim 603 reply.ia.uuid[0] = call->net->uuid.time_low; 566 reply.ia.uuid[1] = htonl(ntohs(call->n 604 reply.ia.uuid[1] = htonl(ntohs(call->net->uuid.time_mid)); 567 reply.ia.uuid[2] = htonl(ntohs(call->n 605 reply.ia.uuid[2] = htonl(ntohs(call->net->uuid.time_hi_and_version)); 568 reply.ia.uuid[3] = htonl((s8) call->ne 606 reply.ia.uuid[3] = htonl((s8) call->net->uuid.clock_seq_hi_and_reserved); 569 reply.ia.uuid[4] = htonl((s8) call->ne 607 reply.ia.uuid[4] = htonl((s8) call->net->uuid.clock_seq_low); 570 for (loop = 0; loop < 6; loop++) 608 for (loop = 0; loop < 6; loop++) 571 reply.ia.uuid[loop + 5] = hton 609 reply.ia.uuid[loop + 5] = htonl((s8) call->net->uuid.node[loop]); 572 610 573 reply.cap.capcount = htonl(1); 611 reply.cap.capcount = htonl(1); 574 reply.cap.caps[0] = htonl(AFS_CAP_ERRO 612 reply.cap.caps[0] = htonl(AFS_CAP_ERROR_TRANSLATION); 575 afs_send_simple_reply(call, &reply, si 613 afs_send_simple_reply(call, &reply, sizeof(reply)); 576 afs_put_call(call); 614 afs_put_call(call); 577 _leave(""); 615 _leave(""); 578 } 616 } 579 617 580 /* 618 /* 581 * deliver request data to a CB.TellMeAboutYou 619 * deliver request data to a CB.TellMeAboutYourself call 582 */ 620 */ 583 static int afs_deliver_cb_tell_me_about_yourse 621 static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call) 584 { 622 { 585 int ret; 623 int ret; 586 624 587 _enter(""); 625 _enter(""); 588 626 589 afs_extract_discard(call, 0); 627 afs_extract_discard(call, 0); 590 ret = afs_extract_data(call, false); 628 ret = afs_extract_data(call, false); 591 if (ret < 0) 629 if (ret < 0) 592 return ret; 630 return ret; 593 631 594 if (!afs_check_call_state(call, AFS_CA 632 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING)) 595 return afs_io_error(call, afs_ 633 return afs_io_error(call, afs_io_error_cm_reply); 596 return afs_find_cm_server_by_peer(call 634 return afs_find_cm_server_by_peer(call); 597 } 635 } 598 636 599 /* 637 /* 600 * deliver request data to a YFS CB.CallBack c 638 * deliver request data to a YFS CB.CallBack call 601 */ 639 */ 602 static int afs_deliver_yfs_cb_callback(struct 640 static int afs_deliver_yfs_cb_callback(struct afs_call *call) 603 { 641 { 604 struct afs_callback_break *cb; 642 struct afs_callback_break *cb; 605 struct yfs_xdr_YFSFid *bp; 643 struct yfs_xdr_YFSFid *bp; 606 size_t size; 644 size_t size; 607 int ret, loop; 645 int ret, loop; 608 646 609 _enter("{%u}", call->unmarshall); 647 _enter("{%u}", call->unmarshall); 610 648 611 switch (call->unmarshall) { 649 switch (call->unmarshall) { 612 case 0: 650 case 0: 613 afs_extract_to_tmp(call); 651 afs_extract_to_tmp(call); 614 call->unmarshall++; 652 call->unmarshall++; 615 653 616 /* extract the FID array and i 654 /* extract the FID array and its count in two steps */ 617 fallthrough; !! 655 /* Fall through */ 618 case 1: 656 case 1: 619 _debug("extract FID count"); 657 _debug("extract FID count"); 620 ret = afs_extract_data(call, t 658 ret = afs_extract_data(call, true); 621 if (ret < 0) 659 if (ret < 0) 622 return ret; 660 return ret; 623 661 624 call->count = ntohl(call->tmp) 662 call->count = ntohl(call->tmp); 625 _debug("FID count: %u", call-> 663 _debug("FID count: %u", call->count); 626 if (call->count > YFSCBMAX) 664 if (call->count > YFSCBMAX) 627 return afs_protocol_er !! 665 return afs_protocol_error(call, -EBADMSG, >> 666 afs_eproto_cb_fid_count); 628 667 629 size = array_size(call->count, 668 size = array_size(call->count, sizeof(struct yfs_xdr_YFSFid)); 630 call->buffer = kmalloc(size, G 669 call->buffer = kmalloc(size, GFP_KERNEL); 631 if (!call->buffer) 670 if (!call->buffer) 632 return -ENOMEM; 671 return -ENOMEM; 633 afs_extract_to_buf(call, size) 672 afs_extract_to_buf(call, size); 634 call->unmarshall++; 673 call->unmarshall++; 635 674 636 fallthrough; !! 675 /* Fall through */ 637 case 2: 676 case 2: 638 _debug("extract FID array"); 677 _debug("extract FID array"); 639 ret = afs_extract_data(call, f 678 ret = afs_extract_data(call, false); 640 if (ret < 0) 679 if (ret < 0) 641 return ret; 680 return ret; 642 681 643 _debug("unmarshall FID array") 682 _debug("unmarshall FID array"); 644 call->request = kcalloc(call-> 683 call->request = kcalloc(call->count, 645 sizeof 684 sizeof(struct afs_callback_break), 646 GFP_KE 685 GFP_KERNEL); 647 if (!call->request) 686 if (!call->request) 648 return -ENOMEM; 687 return -ENOMEM; 649 688 650 cb = call->request; 689 cb = call->request; 651 bp = call->buffer; 690 bp = call->buffer; 652 for (loop = call->count; loop 691 for (loop = call->count; loop > 0; loop--, cb++) { 653 cb->fid.vid = xdr_ 692 cb->fid.vid = xdr_to_u64(bp->volume); 654 cb->fid.vnode = xdr_ 693 cb->fid.vnode = xdr_to_u64(bp->vnode.lo); 655 cb->fid.vnode_hi = nto 694 cb->fid.vnode_hi = ntohl(bp->vnode.hi); 656 cb->fid.unique = ntoh 695 cb->fid.unique = ntohl(bp->vnode.unique); 657 bp++; 696 bp++; 658 } 697 } 659 698 660 afs_extract_to_tmp(call); 699 afs_extract_to_tmp(call); 661 call->unmarshall++; 700 call->unmarshall++; 662 fallthrough; << 663 701 664 case 3: 702 case 3: 665 break; 703 break; 666 } 704 } 667 705 668 if (!afs_check_call_state(call, AFS_CA 706 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING)) 669 return afs_io_error(call, afs_ 707 return afs_io_error(call, afs_io_error_cm_reply); 670 708 671 /* We'll need the file server record a 709 /* We'll need the file server record as that tells us which set of 672 * vnodes to operate upon. 710 * vnodes to operate upon. 673 */ 711 */ 674 return afs_find_cm_server_by_peer(call 712 return afs_find_cm_server_by_peer(call); 675 } 713 } 676 714
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.