1 /* 2 * Copyright (C) 2018 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #pragma once 17 18 #include "common/vsoc/shm/base.h" 19 #include "common/vsoc/shm/circqueue.h" 20 #include "common/vsoc/shm/lock.h" 21 22 // Memory layout for wifi packet exchange region. 23 namespace vsoc { 24 namespace layout { 25 namespace socket_forward { 26 27 constexpr std::size_t kMaxPacketSize = 8192; 28 constexpr std::size_t kNumQueues = 16; 29 30 enum class QueueState : std::uint32_t { 31 INACTIVE = 0, 32 HOST_CONNECTED = 1, 33 BOTH_CONNECTED = 2, 34 HOST_CLOSED = 3, 35 GUEST_CLOSED = 4, 36 // If both are closed then the queue goes back to INACTIVE 37 // BOTH_CLOSED = 0, 38 }; 39 static_assert(ShmTypeValidator<QueueState, 4>::valid, 40 "Compilation error. Please fix above errors and retry."); 41 42 struct Queue { 43 static constexpr size_t layout_size = 44 CircularPacketQueue<16, kMaxPacketSize>::layout_size + 4; 45 46 CircularPacketQueue<16, kMaxPacketSize> queue; 47 48 QueueState queue_state_; 49 50 bool Recover() { 51 return queue.Recover(); 52 } 53 }; 54 ASSERT_SHM_COMPATIBLE(Queue); 55 56 struct QueuePair { 57 static constexpr size_t layout_size = 2 * Queue::layout_size + 8; 58 59 // Traffic originating from host that proceeds towards guest. 60 Queue host_to_guest; 61 // Traffic originating from guest that proceeds towards host. 62 Queue guest_to_host; 63 64 std::uint32_t port_; 65 66 SpinLock queue_state_lock_; 67 68 69 bool Recover() { 70 // TODO: Put queue_state_ and port_ recovery here, probably after grabbing 71 bool recovered = false; 72 recovered = recovered || host_to_guest.Recover(); 73 recovered = recovered || guest_to_host.Recover(); 74 recovered = recovered || queue_state_lock_.Recover(); 75 return recovered; 76 } 77 }; 78 ASSERT_SHM_COMPATIBLE(QueuePair); 79 80 struct SocketForwardLayout : public RegionLayout { 81 static constexpr size_t layout_size = QueuePair::layout_size * kNumQueues + 8; 82 83 bool Recover() { 84 bool recovered = false; 85 for (auto& i : queues_) { 86 bool rval = i.Recover(); 87 recovered = recovered || rval; 88 } 89 //TODO: consider handling the sequence number here 90 return recovered; 91 } 92 93 QueuePair queues_[kNumQueues]; 94 std::atomic_uint32_t seq_num; // incremented for every new connection 95 std::atomic_uint32_t generation_num; // incremented for every new socket forward process 96 static const char* region_name; 97 }; 98 99 ASSERT_SHM_COMPATIBLE(SocketForwardLayout); 100 101 } // namespace socket_forward 102 } // namespace layout 103 } // namespace vsoc 104