/**
* @brief Function to send packet
*
* @param pmlan_adapter A pointer to mlan_adapter structure
* @param pmbuf A pointer to mlan_buffer structure
*
* @return MLAN_STATUS_PENDING
*/
mlan_status
mlan_send_packet(IN t_void * pmlan_adapter, IN pmlan_buffer pmbuf)
{
mlan_status ret = MLAN_STATUS_PENDING;
mlan_adapter *pmadapter = (mlan_adapter *) pmlan_adapter;
ENTER();
MASSERT(pmlan_adapter && pmbuf);
MASSERT(pmbuf->bss_index < pmadapter->priv_num);
pmbuf->flags = MLAN_BUF_FLAG_MOAL_TX_BUF;
if (((pmadapter->priv[pmbuf->bss_index]->port_ctrl_mode == MTRUE) &&
((mlan_ntohs(*(t_u16 *) & pmbuf->pbuf[pmbuf->data_offset +
MLAN_ETHER_PKT_TYPE_OFFSET]) ==
MLAN_ETHER_PKT_TYPE_EAPOL)
||
(mlan_ntohs
(*(t_u16 *) & pmbuf->
pbuf[pmbuf->data_offset + MLAN_ETHER_PKT_TYPE_OFFSET]) ==
MLAN_ETHER_PKT_TYPE_WAPI)
))
|| (pmbuf->buf_type == MLAN_BUF_TYPE_RAW_DATA)
) {
PRINTM(MINFO, "mlan_send_pkt(): enq(bybass_txq)\n");
wlan_add_buf_bypass_txqueue(pmadapter, pmbuf);
} else {
/* Transmit the packet */
wlan_wmm_add_buf_txqueue(pmadapter, pmbuf);
}
LEAVE();
return ret;
}
static void *mlowerfs_ext3_start(struct inode *inode, int op)
{
int nblocks = EXT3_SINGLEDATA_TRANS_BLOCKS;
//journal_t *journal = NULL;
void *handle = NULL;
MENTRY();
if (current->journal_info) {
goto journal_start;
}
/* Increase block number according to operation type */
journal_start:
MASSERT(nblocks > 0);
handle = _mlowerfs_ext3_journal_start(inode, nblocks);
if (!IS_ERR(handle)) {
MASSERT(current->journal_info == handle);
} else {
MERROR("error starting handle for op %u (%u credits): rc %ld\n",
op, nblocks, PTR_ERR(handle));
}
MRETURN(handle);
}
void SPostProcess::DrawRBO(bool redraw)
{
if (p_prog->IsReady)
{
MASSERT(!d_RBO);
MASSERT(!d_resultRBO);
d_resultRBO->Bind(redraw);
Draw();
}
}
int mtfs_branch_getflag(struct inode *inode, mtfs_bindex_t bindex, __u32 *mtfs_flag)
{
struct inode *hidden_inode = mtfs_i2branch(inode, bindex);
struct mtfs_lowerfs *lowerfs = mtfs_i2blowerfs(inode, bindex);
int ret = 0;
MENTRY();
MASSERT(hidden_inode);
MASSERT(lowerfs);
ret = mlowerfs_getflag(lowerfs, hidden_inode, mtfs_flag);
MRETURN(ret);
}
static int ext_support_init(void)
{
int ret = 0;
unsigned long address = 0;
MDEBUG("registering mtfs lowerfs for ext\n");
ret = mtfs_symbol_get("ext3", "ext3_bread", &address, &_mlowerfs_ext3_bread_owner);
if (ret) {
MERROR("failed to get address of symbple ext3_bread, ret = %d\n", ret);
goto out;
}
MASSERT(_mlowerfs_ext3_bread_owner != NULL);
_mlowerfs_ext3_bread_pointer = (_mlowerfs_ext3_bread_t)address;
ret = mtfs_symbol_get("ext3", "ext3_iget", &address, &_mlowerfs_ext3_iget_owner);
if (ret) {
MERROR("failed to get address of symbple ext3_bread, ret = %d\n", ret);
goto out_ext3_bread_put;
}
MASSERT(_mlowerfs_ext3_iget_owner != NULL);
_mlowerfs_ext3_iget_pointer = (_mlowerfs_ext3_iget_t)address;
ret = mlowerfs_register(&lowerfs_ext2);
if (ret) {
MERROR("failed to register lowerfs for ext2, ret = %d\n", ret);
goto out_ext3_iget_put;
}
ret = mlowerfs_register(&lowerfs_ext3);
if (ret) {
MERROR("failed to register lowerfs for ext3, ret = %d\n", ret);
goto out_unregister_ext2;
}
ret = mlowerfs_register(&lowerfs_ext4);
if (ret) {
MERROR("failed to register lowerfs for ext4, ret = %d\n", ret);
goto out_unregister_ext3;
}
goto out;
out_unregister_ext3:
mlowerfs_unregister(&lowerfs_ext3);
out_unregister_ext2:
mlowerfs_unregister(&lowerfs_ext2);
out_ext3_iget_put:
mtfs_symbol_put(_mlowerfs_ext3_iget_owner);
out_ext3_bread_put:
mtfs_symbol_put(_mlowerfs_ext3_bread_owner);
out:
return ret;
}
int mtfs_branch_invalidate_flag(struct inode *inode, mtfs_bindex_t bindex, __u32 valid_flags)
{
struct inode *hidden_inode = mtfs_i2branch(inode, bindex);
struct mtfs_lowerfs *lowerfs = NULL;
int ret = 0;
MENTRY();
MASSERT(hidden_inode);
lowerfs = mtfs_i2blowerfs(inode, bindex);
MASSERT(lowerfs);
ret = mlowerfs_invalidate(lowerfs, hidden_inode, valid_flags);
MRETURN(ret);
}
const Hashtable<const String *, AbstractReflectSessionRef> &
ServerComponent ::
GetSessions() const
{
MASSERT(_owner, "Can not call GetSessions() while not attached to the server");
return _owner->GetSessions();
}
status_t
ServerComponent ::
RemoveAcceptFactory(uint16 port, const IPAddress & optInterfaceIP)
{
MASSERT(_owner, "Can not call RemoveAcceptFactory() while not attached to the server");
return _owner->RemoveAcceptFactory(port, optInterfaceIP);
}
Message &
ServerComponent ::
GetCentralState() const
{
MASSERT(_owner, "Can not call GetCentralState() while not attached to the server");
return _owner->GetCentralState();
}
bool
AbstractReflectSession ::
DisconnectSession()
{
MASSERT(IsAttachedToServer(), "Can not call DisconnectSession() while not attached to the server");
return GetOwner()->DisconnectSession(this);
}
status_t
ServerComponent ::
PutAcceptFactory(uint16 port, const ReflectSessionFactoryRef & factoryRef, const IPAddress & optInterfaceIP, uint16 * optRetPort)
{
MASSERT(_owner, "Can not call PutAcceptFactory() while not attached to the server");
return _owner->PutAcceptFactory(port, factoryRef, optInterfaceIP, optRetPort);
}
ReflectSessionFactoryRef
ServerComponent ::
GetFactory(uint16 port) const
{
MASSERT(_owner, "Can not call GetFactory() while not attached to the server");
return _owner->GetFactory(port);
}
status_t
ServerComponent ::
AddNewDormantConnectSession(const AbstractReflectSessionRef & ref, const IPAddress & ip, uint16 port, uint64 autoReconnectDelay, uint64 maxAsyncConnectPeriod)
{
MASSERT(_owner, "Can not call AddNewDormantConnectSession() while not attached to the server");
return _owner->AddNewDormantConnectSession(ref, ip, port, autoReconnectDelay, maxAsyncConnectPeriod);
}
bool Net::send(node_t *src, node_id_t dst,
std::unique_ptr<net_msg_t> msg) {
auto inqit = inqs.find(dst);
MASSERT(inqs.count(src->get_nid()) > 0, "src unregisterd to network");
if( inqit == inqs.end() ) {
// Can happen when you send to dead node
l::og(l::DEBUG, "send: No inq for node %s\n", id_str(dst));
msg = nullptr;
return false;
}
// "NIC" fills in pkt_num and source of message
// NB: Clients can copy messages before sending them, so best to
// assign number here rather than at message creation
msg->pkt_num = net_msg_t::_pkt_num++;
msg->sent_tick = now();
msg->src = src->get_nid();
stat.tot_msg_send++;
stat.sends[src->get_nid()]++;
// Just log recv
//l::og(l::DEBUG,
// "%s %s to %s S(%03lld)\n",
// src->id_str(), msg->descr, id_str(dst), msg->pkt_num);
inqit->second->push_back(std::move(msg));
return true;
}
uint16
AbstractReflectSession ::
GetPort() const
{
MASSERT(IsAttachedToServer(), "Can not call GetPort() while not attached to the server");
return _ipAddressAndPort.GetPort();
}
const IPAddress &
AbstractReflectSession ::
GetLocalInterfaceAddress() const
{
MASSERT(IsAttachedToServer(), "Can not call LocalInterfaceAddress() while not attached to the server");
return _ipAddressAndPort.GetIPAddress();
}
void paxserver::do_fake_init_vc() {
node_id_t pr = nid;
view_t v;
v.backups.insert(pr);
for (const auto id : net->get_serv_ids(nid)) {
v.backups.insert((node_id_t)id);
if (pr < id) {
pr = id;
}
}
v.backups.erase(pr);
MASSERT(v.backups.size() >= 2,
"For fault tolerance, paxos generally runs"
"at least 3 servers");
v.primary = pr;
v.vid.counter = 1;
v.vid.manager = pr;
vc_state.mode = vc_state_t::ACTIVE;
vc_mgr = {};
vc_state.view = v;
vc_state.accepted_view = nullptr;
if (nid == pr) {
ts = 1ULL;
viewstamp_t last_vs_old_view = paxlog.latest_exec();
vc_state.latest_seen = last_vs_old_view;
vc_state.proposed_vid = v.vid;
LOG(l::DBG_VC, "Initial view " << v << "\n");
} else {
viewstamp_t new_vs;
new_vs.vid = vc_state.view.vid;
new_vs.ts = 0ULL;
paxlog.set_latest_exec(new_vs);
}
}
status_t
AbstractReflectSession ::
AddOutgoingMessage(const MessageRef & ref)
{
MASSERT(IsAttachedToServer(), "Can not call AddOutgoingMessage() while not attached to the server");
return (_gateway()) ? _gateway()->AddOutgoingMessage(ref) : B_ERROR;
}
static int mlowerfs_ext3_commit_async(struct inode *inode, void *h,
void **wait_handle)
{
unsigned long tid = 0;
transaction_t *transaction = NULL;
handle_t *handle = h;
journal_t *journal = NULL;
int ret = 0;
MENTRY();
MASSERT(current->journal_info == handle);
transaction = handle->h_transaction;
journal = transaction->t_journal;
tid = transaction->t_tid;
/* we don't want to be blocked */
handle->h_sync = 0;
ret = _mlowerfs_ext3_journal_stop(handle);
if (ret) {
MERROR("error while stopping transaction: %d\n", ret);
goto out;
}
log_start_commit(journal, tid);
*wait_handle = (void *) tid;
out:
MRETURN(ret);
}
static int mlowerfs_ext3_extend(struct inode *inode, unsigned int nblocks, void *h)
{
handle_t *handle = h;
int ret = 0;
MENTRY();
/* fsfilt_extend called with nblocks = 0 for testing in special cases */
if (nblocks == 0) {
handle->h_buffer_credits = 0;
MWARN("setting credits of handle %p to zero by request\n", h);
}
if (handle->h_buffer_credits > nblocks) {
ret = 0;
goto out;
}
if (_mlowerfs_ext3_journal_extend(handle, nblocks) == 0) {
ret = 0;
goto out;
}
MASSERT(inode->i_sb->s_op->dirty_inode);
inode->i_sb->s_op->dirty_inode(inode);
ret = _lowerfs_ext3_journal_restart(handle, nblocks);
out:
MRETURN(ret);
}
AbstractReflectSessionRef
ServerComponent ::
GetSession(const String & id) const
{
MASSERT(_owner, "Can not call GetSession() while not attached to the server");
return _owner->GetSession(id);
}
const String &
AbstractReflectSession ::
GetHostName() const
{
MASSERT(IsAttachedToServer(), "Can not call GetHostName() while not attached to the server");
return _hostName;
}
const Hashtable<IPAddressAndPort, ReflectSessionFactoryRef> &
ServerComponent ::
GetFactories() const
{
MASSERT(_owner, "Can not call GetFactories() while not attached to the server");
return _owner->GetFactories();
}
uint64
ServerComponent ::
GetServerSessionID() const
{
MASSERT(_owner, "Can not call GetServerSessionID() while not attached to the server");
return _owner->GetServerSessionID();
}
status_t
ServerComponent ::
AddNewSession(const AbstractReflectSessionRef & ref, const ConstSocketRef & socket)
{
MASSERT(_owner, "Can not call AddNewSession() while not attached to the server");
return _owner->AddNewSession(ref, socket);
}
uint64
ServerComponent ::
GetNumUsedBytes() const
{
MASSERT(_owner, "Can not call GetNumUsedBytes() while not attached to the server");
return _owner->GetNumUsedBytes();
}
void SPostProcess::Clean()
{
MASSERT(!d_resultRBO);
d_resultRBO->Clean();
}
status_t
AbstractReflectSession ::
ReplaceSession(const AbstractReflectSessionRef & replaceMeWithThis)
{
MASSERT(IsAttachedToServer(), "Can not call ReplaceSession() while not attached to the server");
return GetOwner()->ReplaceSession(replaceMeWithThis, this);
}
/**
* @brief Packet send completion handling
*
* @param pmadapter A pointer to mlan_adapter structure
* @param pmbuf A pointer to mlan_buffer structure
* @param status Callback status
*
* @return MLAN_STATUS_SUCCESS
*/
mlan_status
wlan_write_data_complete(IN pmlan_adapter pmadapter,
IN pmlan_buffer pmbuf, IN mlan_status status)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
pmlan_callbacks pcb;
ENTER();
MASSERT(pmadapter && pmbuf);
pcb = &pmadapter->callbacks;
if (pmbuf->flags & MLAN_BUF_FLAG_TCP_ACK) {
pmbuf->flags &= ~MLAN_BUF_FLAG_TCP_ACK;
pcb->moal_tcp_ack_tx_ind(pmadapter->pmoal_handle, pmbuf);
}
if ((pmbuf->buf_type == MLAN_BUF_TYPE_DATA) ||
(pmbuf->buf_type == MLAN_BUF_TYPE_RAW_DATA)) {
PRINTM(MINFO, "wlan_write_data_complete: DATA %p\n", pmbuf);
if (pmbuf->flags & MLAN_BUF_FLAG_MOAL_TX_BUF) {
/* pmbuf was allocated by MOAL */
pcb->moal_send_packet_complete(pmadapter->pmoal_handle,
pmbuf, status);
} else {
/* pmbuf was allocated by MLAN */
wlan_free_mlan_buffer(pmadapter, pmbuf);
}
}
LEAVE();
return ret;
}
void
ServerComponent ::
EndServer()
{
MASSERT(_owner, "Can not call EndServer() while not attached to the server");
_owner->EndServer();
}
