PentHertz
/
srsLTE
mirror of https://github.com/PentHertz/srsLTE.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

simplified NAS rrc connection request procedure 

move non-type-specific methods of proc_t to its base class.
procedure state machine was simplified via a future-type. Now procedures dont get stuck until the user reads the procedure outcome.
made the NAS procedures more event trigger/reaction-based.
This commit is contained in:
Francisco Paisana 2019-10-02 11:06:39 +01:00 committed by Andre Puschmann
parent 8864787f59
commit f2d88e5a5b
10 changed files with 661 additions and 602 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

456
lib/include/srslte/common/stack_procedure.h
View File

@ -30,23 +30,23 @@
namespace srslte { namespace srslte {
enum class proc_state_t { on_going, success, error, inactive };
enum class proc_outcome_t { repeat, yield, success, error }; enum class proc_outcome_t { repeat, yield, success, error };
/************************************************************************************** /**************************************************************************************
* helper functions for overloading * helper functions for method optional overloading
************************************************************************************/ ************************************************************************************/
namespace detail { namespace detail {
// used by proc_manager to call proc finally() method only if it exists // used by proc_t<T> to call T::then() method only if it exists
template <class T> template <typename T, typename ProcResult>
auto optional_complete(T* obj, int is_success) -> decltype(obj->on_complete(is_success)) auto optional_then(T* obj, const ProcResult& result) -> decltype(obj->then(result))
{ {
obj->on_complete(is_success); obj->then(result);
} }
inline auto optional_complete(...) -> void inline auto optional_then(...) -> void
{ {
// do nothing // do nothing
} }
// used by proc_t<T> to call proc T::clear() method only if it exists
template <class T> template <class T>
auto optional_clear(T* obj) -> decltype(obj->clear()) auto optional_clear(T* obj) -> decltype(obj->clear())
{ {
@ -56,27 +56,34 @@ inline auto optional_clear(...) -> void
{ {
// do nothing // do nothing
} }
template <class T>
auto get_result_type(const T& obj) -> decltype(obj.get_result());
inline auto get_result_type(...) -> void;
} // namespace detail } // namespace detail
/************************************************************************************** /**************************************************************************************
* class: callback_list_t * class: callback_group_t<Args...>
* Bundles several callbacks with callable interface "void(Args...)".
* Calls to operator(Args&&...) call all the registered callbacks.
* Two methods to register a callback - call it once, or always call it.
************************************************************************************/ ************************************************************************************/
template <typename Func> template <typename... Args>
class callback_list_t class callback_group_t
{ {
public: public:
using id_type = uint32_t; using callback_id_t = uint32_t;
using callback_t = Func; using callback_t = std::function<void(Args...)>;
// register new callbacks
id_type call_once(callback_t f_) //! register callback, that gets called once
callback_id_t on_next_call(callback_t f_)
{ {
uint32_t idx = get_new_callback(); uint32_t idx = get_new_callback();
func_list[idx].func = std::move(f_); func_list[idx].func = std::move(f_);
func_list[idx].call_always = false; func_list[idx].call_always = false;
return idx; return idx;
} }
id_type call_always(callback_t f_) callback_id_t on_every_call(callback_t f_)
{ {
uint32_t idx = get_new_callback(); uint32_t idx = get_new_callback();
func_list[idx].func = std::move(f_); func_list[idx].func = std::move(f_);
@ -85,11 +92,12 @@ public:
} }
// call all callbacks // call all callbacks
void run(bool is_success) template <typename... ArgsRef>
void operator()(const ArgsRef&... args)
{ {
for (auto& f : func_list) { for (auto& f : func_list) {
if (f.active) { if (f.active) {
f.func(is_success); f.func(args...);
if (not f.call_always) { if (not f.call_always) {
f.active = false; f.active = false;
} }
@ -112,19 +120,89 @@ private:
struct call_item_t { struct call_item_t {
bool active; bool active;
std::function<void(bool)> func; callback_t func;
bool call_always; bool call_always;
}; };
std::vector<call_item_t> func_list; std::vector<call_item_t> func_list;
}; };
/************************************************************************************** /**************************************************************************************
* class: proc_itf_t * class: proc_result_t
* Stores the result of a procedure run. Can optionally contain a value T, in case of a
* successful run.
**************************************************************************************/
namespace detail {
struct proc_result_base_t {
bool is_success() const { return state == result_state_t::value; }
bool is_error() const { return state == result_state_t::error; }
bool is_complete() const { return state != result_state_t::none; }
void set_val() { state = result_state_t::value; }
void set_error() { state = result_state_t::error; }
void clear() { state = result_state_t::none; }
protected:
enum class result_state_t { none, value, error } state = result_state_t::none;
};
} // namespace detail
template <typename T>
struct proc_result_t : public detail::proc_result_base_t {
const T* value() const { return state == result_state_t::value ? &t : nullptr; }
void set_val(const T& t_)
{
proc_result_base_t::set_val();
t = t_;
}
template <typename Proc>
void extract_val(Proc& p)
{
set_val(p.get_result());
}
protected:
T t;
};
template <>
struct proc_result_t<void> : public detail::proc_result_base_t {
template <typename Proc>
void extract_val(Proc& p)
{
set_val();
}
};
/**************************************************************************************
* class: proc_future_t
* Contains a pointer to the result of a procedure run. This pointer gets updated with
* the actual result once the procedure completes.
**************************************************************************************/
template <typename ResultType>
class proc_future_t
{
public:
proc_future_t() = default;
explicit proc_future_t(const std::shared_ptr<proc_result_t<ResultType> >& p_) : ptr(p_) {}
bool is_error() const { return ptr->is_error(); }
bool is_success() const { return ptr->is_success(); }
bool is_complete() const { return ptr->is_complete(); }
const ResultType* value() const { return is_success() ? ptr->value() : nullptr; }
private:
std::shared_ptr<proc_result_t<ResultType> > ptr;
};
using proc_future_state_t = proc_future_t<void>;
/**************************************************************************************
* class: proc_base_t
* Provides a polymorphic interface for resumable procedures. This base can then be used * Provides a polymorphic interface for resumable procedures. This base can then be used
* by a procedure manager container via the virtual method "proc_itf_t::run()". * by a "proc_manager_list_t" via the virtual method "proc_base_t::run()".
* With methods: * With public methods:
* - run() - executes a procedure, returning true if the procedure is still running * - run() - executes proc_t<T>::step(), and updates procedure state.
* or false, if it has completed * - is_busy()/is_idle() - tells if procedure is currently running. Busy procedures
* cannot be re-launched
* - then() - called automatically when a procedure has finished. Useful for actions
* upon procedure completion, like sending back a response or logging.
* With protected methods:
* - step() - method overriden by child class that will be called by run(). step() * - step() - method overriden by child class that will be called by run(). step()
* executes a procedure "action" based on its current internal state, * executes a procedure "action" based on its current internal state,
* and return a proc_outcome_t variable with possible values: * and return a proc_outcome_t variable with possible values:
@ -133,77 +211,88 @@ private:
* recall step() again (probably the procedure state has changed) * recall step() again (probably the procedure state has changed)
* - error - the procedure has finished unsuccessfully * - error - the procedure has finished unsuccessfully
* - success - the procedure has completed successfully * - success - the procedure has completed successfully
* - finally() - called automatically when a procedure has finished. Useful for actions
* upon procedure completion, like sending back a response.
* - set_proc_state() / is_#() - setter and getters for current procedure state
************************************************************************************/ ************************************************************************************/
class proc_manager_itf_t class proc_base_t
{ {
public: public:
virtual bool run() = 0; virtual ~proc_base_t() = default;
virtual ~proc_manager_itf_t() = default;
};
template <typename T> //! common proc::run() interface. Returns true if procedure is still running
struct proc_result_t; bool run()
/**************************************************************************************
* class: proc_manager_t<T>
* Manages the lifetime, of a procedure T, including its alloc, launching,
* and reset back to initial, uninit state once the procedure has been
* completed and the user has extracted its results.
* Every procedure starts in inactive state, and finishes with success or error.
* Can only be re-launched when a procedure T becomes inactive.
* It uses a unique_ptr<T> to allow the use of procedures that are forward declared.
* It provides the following methods:
* - run() - calls T::step() and update the procedure state.
* - launch() - initializes the procedure T by calling T::init(...). Handles the case
* of failed initialization, and forbids the initialization of procedures
* that are already active.
* - pop() - extracts the result of the procedure if it has finished, and sets
* proc_t<T> back to inactive
* - trigger_event(Event) - used for handling external events. The procedure T will
* have to define a method "trigger_event(Event)" as well,
* specifying how each event type should be handled.
************************************************************************************/
template <class T>
class proc_t final : public proc_manager_itf_t
{
using complete_callback_list_t = callback_list_t<std::function<void(bool)> >;
public:
template <typename... Args>
explicit proc_t(Args&&... args) : proc_impl_ptr(new T(std::forward<Args>(args)...))
{
}
bool run() override
{ {
proc_outcome_t outcome = proc_outcome_t::repeat; proc_outcome_t outcome = proc_outcome_t::repeat;
while (is_running() and outcome == proc_outcome_t::repeat) { while (is_busy() and outcome == proc_outcome_t::repeat) {
outcome = proc_impl_ptr->step(); outcome = step();
handle_outcome(outcome); handle_outcome(outcome);
} }
return is_running(); return is_busy();
} }
void clear() //! interface to check if proc is still running
bool is_busy() const { return proc_state == proc_status_t::on_going; }
bool is_idle() const { return proc_state == proc_status_t::idle; }
protected:
enum class proc_status_t { idle, on_going };
virtual proc_outcome_t step() = 0;
virtual void run_then(bool is_success) = 0;
void handle_outcome(proc_outcome_t outcome)
{ {
// resets procedure and sets proc_t back to inactive if (outcome == proc_outcome_t::error or outcome == proc_outcome_t::success) {
detail::optional_clear(proc_impl_ptr.get()); bool success = outcome == proc_outcome_t::success;
proc_state = proc_state_t::inactive; run_then(success);
}
} }
const T* get() const { return proc_impl_ptr.get(); } proc_status_t proc_state = proc_status_t::idle;
bool is_active() const { return proc_state != proc_state_t::inactive; } };
bool is_complete() const { return proc_state == proc_state_t::success or proc_state == proc_state_t::error; }
T* release() { return proc_impl_ptr.release(); }
/**************************************************************************************
* class: proc_t<T, ResultType>
* Manages the lifetime of a procedure of type T, including its alloc, launching,
* and reset back to "inactive" state once the procedure has been completed.
* The result of a procedure run is of type "proc_result_t<ResultType>". ResultType has
* to coincide with the type returned by the method "T::get_result()".
* There are three main ways to use the result of a procedure run:
* - "T::then(const proc_result_t<T>&)" - method in T that runs on completion, and
* gets as argument the result of the run
* - "proc_t<T>::get_future()" - returns a proc_future_t<T> which the user can use
* directly to check the result of a run
* - "proc_t<T>::then/then_always()" - provide dynamically a continuation task, for
* instance, by providing a lambda
* It uses a unique_ptr<T> to allow the use of procedures that are forward declared.
************************************************************************************/
// Implementation of the Procedure Manager functionality, including launching, trigger events, clearing
template <class T, typename ResultType = void>
class proc_t : public proc_base_t
{
public:
// cannot derive automatically this type
using result_type = ResultType;
using proc_result_type = proc_result_t<result_type>;
using proc_future_type = proc_future_t<result_type>;
using then_callback_list_t = callback_group_t<proc_result_type>;
using callback_t = typename then_callback_list_t::callback_t;
using callback_id_t = typename then_callback_list_t::callback_id_t;
template <typename... Args>
explicit proc_t(Args&&... args) : proc_ptr(new T(std::forward<Args>(args)...))
{
static_assert(std::is_same<result_type, decltype(detail::get_result_type(std::declval<T>()))>::value,
"The types \"proc_t::result_type\" and the return of T::get_result() have to match");
}
const T* get() const { return proc_ptr.get(); }
T* release() { return proc_ptr.release(); }
//! method to handle external events. "T" must have the method "T::react(const Event&)" for the trigger to take effect
template <class Event> template <class Event>
void trigger_event(Event&& e) void trigger(Event&& e)
{ {
if (is_running()) { if (is_busy()) {
proc_outcome_t outcome = proc_impl_ptr->trigger_event(std::forward<Event>(e)); proc_outcome_t outcome = proc_ptr->react(std::forward<Event>(e));
handle_outcome(outcome); handle_outcome(outcome);
if (outcome == proc_outcome_t::repeat) { if (outcome == proc_outcome_t::repeat) {
run(); run();
@ -211,87 +300,106 @@ public:
} }
} }
//! returns an object which the user can use to check if the procedure has ended.
proc_future_type get_future()
{
if (future_result == nullptr) {
future_result = std::make_shared<proc_result_type>(proc_result);
}
return proc_future_type{future_result};
}
//! methods to schedule continuation tasks
callback_id_t then(const callback_t& c) { return complete_callbacks.on_next_call(c); }
callback_id_t then_always(const callback_t& c) { return complete_callbacks.on_every_call(c); }
//! launch a procedure, returning true if successful or running and false if it error or it failed to launch
template <class... Args> template <class... Args>
bool launch(Args&&... args) bool launch(Args&&... args)
{ {
if (is_active()) { if (is_busy()) {
// if already active
return false; return false;
} }
proc_state = proc_state_t::on_going; proc_state = proc_base_t::proc_status_t::on_going;
proc_outcome_t init_ret = proc_impl_ptr->init(std::forward<Args>(args)...); proc_outcome_t init_ret = proc_ptr->init(std::forward<Args>(args)...);
handle_outcome(init_ret);
switch (init_ret) { switch (init_ret) {
case proc_outcome_t::error: case proc_outcome_t::error:
handle_outcome(init_ret);
clear();
return false; return false;
case proc_outcome_t::success:
handle_outcome(init_ret);
// does not reset, and returns true
break;
case proc_outcome_t::repeat: case proc_outcome_t::repeat:
run(); // call run right away run(); // call run right away
break; break;
case proc_outcome_t::yield: default:
break; break;
} }
return true; return true;
} }
proc_result_t<T> pop();
// on_complete interface
complete_callback_list_t::id_type then(const complete_callback_list_t::callback_t& c)
{
return complete_callbacks.call_once(c);
}
complete_callback_list_t::id_type then_always(const complete_callback_list_t::callback_t& c)
{
return complete_callbacks.call_always(c);
}
protected: protected:
friend proc_result_t<T>; proc_outcome_t step() final { return proc_ptr->step(); }
bool is_running() const { return proc_state == proc_state_t::on_going; }
void handle_outcome(proc_outcome_t outcome) void run_then(bool is_success) final
{ {
if (outcome == proc_outcome_t::error or outcome == proc_outcome_t::success) { // update result state
bool success = outcome == proc_outcome_t::success; if (is_success) {
proc_state = success ? proc_state_t::success : proc_state_t::error; proc_result.extract_val(*proc_ptr);
detail::optional_complete(proc_impl_ptr.get(), success); } else {
complete_callbacks.run(success); proc_result.set_error();
} }
// call T::then() if it exists
detail::optional_then(proc_ptr.get(), proc_result);
// signal continuations
complete_callbacks(proc_result);
// propagate proc_result to future if it exists, and release future
if (future_result != nullptr) {
*future_result = proc_result;
future_result.reset();
}
// reset the current result, to prepare it for a new run.
proc_result.clear();
// back to inactive
detail::optional_clear(proc_ptr.get());
proc_state = proc_status_t::idle;
} }
proc_state_t proc_state = proc_state_t::inactive; std::unique_ptr<T> proc_ptr;
std::unique_ptr<T> proc_impl_ptr; proc_result_type proc_result;
complete_callback_list_t complete_callbacks; std::shared_ptr<proc_result_type> future_result; //! used if get_future() itf is used.
then_callback_list_t complete_callbacks;
}; };
template <typename T> /**************************************************************************************
struct proc_result_t { * class: event_handler_t<Args...>
explicit proc_result_t(proc_t<T>* parent_) : parent(parent_) {} * Bundles several proc_managers together with same trigger(Args...) itf.
~proc_result_t() * Once trigger(...) is called, all registered proc_managers get triggered
* as well.
************************************************************************************/
// NOTE: Potential improvements: a method "trigger_during_this_run" that unregisters the handler
// once the procedure run is finished.
template <typename EventType>
class event_handler_t
{
public:
using callback_id_t = typename callback_group_t<EventType>::callback_id_t;
template <typename Proc, typename ResultType>
callback_id_t on_next_trigger(proc_t<Proc, ResultType>& p)
{ {
if (parent->is_complete()) { return callbacks.on_next_call([&p](EventType&& ev) { p.trigger(std::forward<EventType>(ev)); });
parent->clear();
} }
template <typename Proc, typename ResultType>
callback_id_t on_every_trigger(proc_t<Proc, ResultType>& p)
{
return callbacks.on_every_call([&p](EventType&& ev) { p.trigger(std::forward<EventType>(ev)); });
} }
const T* proc() const { return parent->is_complete() ? parent->proc_impl_ptr.get() : nullptr; }
bool is_success() const { return parent->proc_state == proc_state_t::success; } void trigger(EventType&& ev) { callbacks(std::forward<EventType>(ev)); }
bool is_error() const { return parent->proc_state == proc_state_t::error; }
bool is_complete() const { return parent->is_complete(); }
private: private:
proc_t<T>* parent; callback_group_t<EventType> callbacks;
}; };
template <typename T>
proc_result_t<T> proc_t<T>::pop()
{
return proc_result_t<T>{this};
}
/************************************************************************************** /**************************************************************************************
* class: func_proc_t * class: func_proc_t
* A proc used to store lambda functions and other function pointers as a step() * A proc used to store lambda functions and other function pointers as a step()
@ -308,106 +416,52 @@ private:
std::function<proc_outcome_t()> step_func; std::function<proc_outcome_t()> step_func;
}; };
/**************************************************************************************
* class: query_proc_t
* A helper proc_impl_t whose step()/finally() are no op, but has a trigger_event() that
* signals that the method has finished and store a result of type OutcomeType.
************************************************************************************/
template <class OutcomeType>
class query_proc_t
{
public:
proc_outcome_t init() { return proc_outcome_t::yield; }
proc_outcome_t step() { return proc_outcome_t::yield; }
proc_outcome_t trigger_event(const OutcomeType& outcome_)
{
outcome = outcome_;
return proc_outcome_t::success;
}
const OutcomeType& result() const { return outcome; }
private:
OutcomeType outcome;
};
/************************************************************************************** /**************************************************************************************
* class: proc_manager_list_t * class: proc_manager_list_t
* Stores procedure managers and, when run() is called, calls sequentially all * Stores procedure managers and, when run() is called, calls sequentially all
* the stored procedures run() method, and removes the procedures if they have * the stored procedures run() method, and removes the procedures if they have
* completed. * already completed.
* There are different ways to add a procedure to the list: * There are two ways to add a procedure to the list:
* - add_proc(...) - adds a proc_t<T>, and once the procedure has completed, takes it * - add_proc(...) - adds a proc_t<T>, and once the procedure has completed, takes it
* out of the container without resetting it back to its initial state * out of the container. In case a r-value ref is passed, this class
* or deleting. This is useful, if the user wants to extract the * calls its destructor.
* procedure result after it has been taken off the manager list. * - add_task(...) - same as add_proc(...) but takes a function pointer that
* "proc" variable has to outlive its completion
* - consume_proc(...) - receives a proc_t<T> as a rvalue, and calls the proc_t<T>
* destructor once the procedure has ended. Useful, for procedures
* for which the user is not interested in the result, or reusing
* - defer_proc(...) - same as add_proc(...), but once the procedure has finished, it
* automatically sets the procedure back to its initial state.
* Useful if the user is not interested in handling the result
* - defer_task(...) - same as consume_proc(...) but takes a function pointer that
* specifies a proc_impl_t step() function * specifies a proc_impl_t step() function
************************************************************************************/ ************************************************************************************/
class proc_manager_list_t class proc_manager_list_t
{ {
using proc_deleter_t = std::function<void(proc_manager_itf_t*)>; using proc_deleter_t = std::function<void(proc_base_t*)>;
using proc_obj_t = std::unique_ptr<proc_manager_itf_t, proc_deleter_t>; using proc_obj_t = std::unique_ptr<proc_base_t, proc_deleter_t>;
template <typename T>
struct recycle_deleter_t {
void operator()(proc_manager_itf_t* p)
{
if (p != nullptr) {
T* Tp = static_cast<T*>(p);
Tp->clear();
// just resets back to inactive, and does not dealloc
}
}
};
public: public:
template <typename T> template <typename T, typename ResultType>
void add_proc(proc_t<T>& proc) void add_proc(proc_t<T, ResultType>& proc)
{ {
if (proc.is_complete()) { if (proc.is_idle()) {
return; return;
} }
proc_obj_t ptr(&proc, [](proc_manager_itf_t* p) { /* do nothing */ }); proc_obj_t ptr(&proc, [](proc_base_t* p) { /* do nothing */ });
proc_list.push_back(std::move(ptr)); proc_list.push_back(std::move(ptr));
} }
template <class T> // since it receives a r-value, it calls the default destructor
void consume_proc(proc_t<T>&& proc) template <class T, typename ResultType>
void add_proc(proc_t<T, ResultType>&& proc)
{ {
if (proc.is_complete()) { if (proc.is_idle()) {
return; return;
} }
proc_obj_t ptr(new proc_t<T>(std::move(proc)), std::default_delete<proc_manager_itf_t>()); proc_obj_t ptr(new proc_t<T, ResultType>(std::move(proc)), std::default_delete<proc_base_t>());
proc_list.push_back(std::move(ptr)); proc_list.push_back(std::move(ptr));
} }
template <typename T> bool add_task(std::function<proc_outcome_t()> step_func)
void defer_proc(proc_t<T>& proc)
{
if (proc.is_complete()) {
proc.clear();
return;
}
proc_obj_t ptr(&proc, recycle_deleter_t<proc_t<T> >());
proc_list.push_back(std::move(ptr));
}
bool defer_task(std::function<proc_outcome_t()> step_func)
{ {
proc_t<func_proc_t> proc(std::move(step_func)); proc_t<func_proc_t> proc(std::move(step_func));
if (not proc.launch()) { if (not proc.launch()) {
return false; return false;
} }
consume_proc(std::move(proc)); add_proc(std::move(proc));
return true; return true;
} }

7
lib/include/srslte/interfaces/ue_interfaces.h
View File

@ -196,14 +196,15 @@ public:
typedef enum { BARRING_NONE = 0, BARRING_MO_DATA, BARRING_MO_SIGNALLING, BARRING_MT, BARRING_ALL } barring_t; typedef enum { BARRING_NONE = 0, BARRING_MO_DATA, BARRING_MO_SIGNALLING, BARRING_MT, BARRING_ALL } barring_t;
virtual void left_rrc_connected() = 0; virtual void left_rrc_connected() = 0;
virtual void set_barring(barring_t barring) = 0; virtual void set_barring(barring_t barring) = 0;
virtual void paging(srslte::s_tmsi_t* ue_identity) = 0; virtual bool paging(srslte::s_tmsi_t* ue_identity) = 0;
virtual bool is_attached() = 0; virtual bool is_attached() = 0;
virtual void write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t pdu) = 0; virtual void write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t pdu) = 0;
virtual uint32_t get_k_enb_count() = 0; virtual uint32_t get_k_enb_count() = 0;
virtual bool get_k_asme(uint8_t* k_asme_, uint32_t n) = 0; virtual bool get_k_asme(uint8_t* k_asme_, uint32_t n) = 0;
virtual uint32_t get_ipv4_addr() = 0; virtual uint32_t get_ipv4_addr() = 0;
virtual bool get_ipv6_addr(uint8_t* ipv6_addr) = 0; virtual bool get_ipv6_addr(uint8_t* ipv6_addr) = 0;
virtual void plmn_search_completed(rrc_interface_nas::found_plmn_t found_plmns[rrc_interface_nas::MAX_FOUND_PLMNS], virtual void
plmn_search_completed(const rrc_interface_nas::found_plmn_t found_plmns[rrc_interface_nas::MAX_FOUND_PLMNS],
int nof_plmns) = 0; int nof_plmns) = 0;
virtual bool connection_request_completed(bool outcome) = 0; virtual bool connection_request_completed(bool outcome) = 0;
virtual void run_tti(uint32_t tti) = 0; virtual void run_tti(uint32_t tti) = 0;
@ -213,7 +214,7 @@ public:
class nas_interface_ue class nas_interface_ue
{ {
public: public:
virtual void start_attach_request(srslte::proc_state_t* proc_result, srslte::establishment_cause_t cause_) = 0; virtual void start_attach_request(srslte::proc_result_t<void>* proc_result, srslte::establishment_cause_t cause_) = 0;
virtual bool detach_request(const bool switch_off) = 0; virtual bool detach_request(const bool switch_off) = 0;
}; };

247
lib/test/common/stack_procedure_test.cc
View File

@ -60,6 +60,7 @@ public:
printf("TestObj copy ctor called: {%s,%d} <- {%s,%d}!!!\n", to_string(state), id, to_string(other.state), other.id); printf("TestObj copy ctor called: {%s,%d} <- {%s,%d}!!!\n", to_string(state), id, to_string(other.state), other.id);
id = other.id; id = other.id;
state = obj_state_t::copy_ctor; state = obj_state_t::copy_ctor;
counters = other.counters;
copy_counter++; copy_counter++;
} }
TestObj(TestObj&& other) noexcept TestObj(TestObj&& other) noexcept
@ -67,6 +68,7 @@ public:
printf("TestObj move ctor called: {%s,%d} <- {%s,%d}!!!\n", to_string(state), id, to_string(other.state), other.id); printf("TestObj move ctor called: {%s,%d} <- {%s,%d}!!!\n", to_string(state), id, to_string(other.state), other.id);
id = other.id; id = other.id;
state = obj_state_t::move_ctor; state = obj_state_t::move_ctor;
counters = other.counters;
other.state = obj_state_t::from_move_ctor; other.state = obj_state_t::from_move_ctor;
move_counter++; move_counter++;
} }
@ -84,6 +86,7 @@ public:
other.id); other.id);
id = other.id; id = other.id;
state = other.state; state = other.state;
counters = other.counters;
copy_counter++; copy_counter++;
return *this; return *this;
} }
@ -97,6 +100,7 @@ public:
if (&other != this) { if (&other != this) {
id = other.id; id = other.id;
state = other.state; state = other.state;
counters = other.counters;
other.state = obj_state_t::from_move_assign; other.state = obj_state_t::from_move_assign;
move_counter++; move_counter++;
} }
@ -105,6 +109,11 @@ public:
obj_state_t state = obj_state_t::default_ctor; obj_state_t state = obj_state_t::default_ctor;
int id = 0; int id = 0;
struct stats_t {
int then_counter = 0;
int reset_counter = 0;
};
mutable stats_t counters;
static int copy_counter; static int copy_counter;
static int move_counter; static int move_counter;
static int dtor_counter; static int dtor_counter;
@ -133,7 +142,6 @@ public:
return proc_outcome_t::error; return proc_outcome_t::error;
} }
obj.id = a_; obj.id = a_;
reset_called = false;
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
proc_outcome_t step() proc_outcome_t step()
@ -143,13 +151,19 @@ public:
} }
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
void on_complete(bool is_success) { printf("TestObj %d stop() was called\n", obj.id); } void then(const srslte::proc_result_t<int>& result) const
{
printf("TestObj %d then() was called\n", obj.id);
obj.counters.then_counter++;
}
const char* name() const { return "custom proc"; } const char* name() const { return "custom proc"; }
void clear() void clear()
{ {
reset_called = true; reset_called = true;
printf("TestObj was reset\n"); printf("TestObj was reset\n");
} }
int get_result() const { return obj.id; }
TestObj obj; TestObj obj;
const int ctor_value = 5; const int ctor_value = 5;
@ -165,54 +179,64 @@ public:
proc_outcome_t init() proc_outcome_t init()
{ {
exit_val = "init"; exit_val = "init";
event_val = "";
counter = 0; counter = 0;
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
proc_outcome_t step() proc_outcome_t step()
{ {
if (counter++ > 5) { if (counter++ > 5) {
exit_val = "success";
return proc_outcome_t::success; return proc_outcome_t::success;
} }
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
void on_complete(bool is_success) // trigger itf
struct event_t {
std::string event_val;
};
proc_outcome_t react(const event_t& event)
{ {
if (is_success) { event_val = event.event_val;
exit_val = "success"; return proc_outcome_t::yield;
} else {
exit_val = "fail";
}
} }
std::string get_result() const { return exit_val; }
std::string exit_val = ""; std::string exit_val = "";
std::string event_val = "";
int counter = 0; int counter = 0;
}; };
static_assert(std::is_same<typename srslte::proc_t<custom_proc, int>::result_type, int>::value,
"Failed derivation of result type");
static_assert(std::is_same<typename srslte::proc_t<custom_proc, std::string>::result_type, std::string>::value,
"Failed derivation of result type");
int test_local_1() int test_local_1()
{ {
/*
* Description: Test if a procedure is cleaned automatically after is lifetime has ended
*/
new_test(); new_test();
printf("\n--- Test %s ---\n", __func__); printf("\n--- Test %s ---\n", __func__);
srslte::proc_t<custom_proc> proc; srslte::proc_t<custom_proc, int> proc;
TESTASSERT(not proc.is_active()); TESTASSERT(proc.is_idle() and not proc.is_busy())
proc.launch(1); proc.launch(1);
TESTASSERT(proc.is_active()); TESTASSERT(not proc.is_idle() and proc.is_busy())
TESTASSERT(not proc.is_complete()); TESTASSERT(not proc.get()->reset_called)
TESTASSERT(not proc.get()->reset_called);
while (proc.run()) { while (proc.run()) {
} }
TESTASSERT(proc.is_idle() and not proc.is_busy())
TESTASSERT(proc.is_active()); TESTASSERT(proc.get()->obj.counters.then_counter == 1)
TESTASSERT(proc.is_complete()); TESTASSERT(proc.get()->reset_called) // Proc is ready to be reused
const custom_proc& procobj = *proc.get(); const custom_proc& procobj = *proc.get();
TESTASSERT(procobj.obj.id == 1); TESTASSERT(procobj.obj.id == 1)
TESTASSERT(proc.is_active()); TESTASSERT(not proc.is_busy() and proc.is_idle())
printf("clear() being called\n"); TESTASSERT(proc.get()->ctor_value == 5)
proc.clear();
TESTASSERT(not proc.is_active());
TESTASSERT(proc.get()->reset_called); // Proc is ready to be reused
TESTASSERT(proc.get()->ctor_value == 5);
printf("EXIT\n"); printf("EXIT\n");
TESTASSERT(TestObj::copy_counter == 0); TESTASSERT(TestObj::copy_counter == 0);
@ -225,38 +249,34 @@ int test_callback_1()
{ {
/* /*
* Description: Test a procedure inserted in a manager list via "proc_manager_list_t::add_proc(...)" * Description: Test a procedure inserted in a manager list via "proc_manager_list_t::add_proc(...)"
* - check if the proc is not cleared automatically after it finished (need to check the result) * - check if the proc is cleared automatically after it finished
* - check if pop() works as expected, and resets proc after proc_result_t<T> goes out of scope * - check if the proc_future value is correctly updated
* - check if creating a new future does not affect previous one
*/ */
new_test(); new_test();
printf("\n--- Test %s ---\n", __func__); printf("\n--- Test %s ---\n", __func__);
srslte::proc_manager_list_t callbacks; srslte::proc_manager_list_t callbacks;
srslte::proc_t<custom_proc> proc; srslte::proc_t<custom_proc, int> proc;
TESTASSERT(not proc.is_active()); TESTASSERT(not proc.is_busy() and proc.is_idle())
TESTASSERT(proc.launch(2)); TESTASSERT(proc.launch(2))
callbacks.add_proc(proc); // We have to call pop() explicitly to take the result callbacks.add_proc(proc); // We have to call pop() explicitly to take the result
TESTASSERT(callbacks.size() == 1); TESTASSERT(callbacks.size() == 1)
srslte::proc_future_t<int> proc_fut = proc.get_future();
while (callbacks.size() > 0) { while (callbacks.size() > 0) {
TESTASSERT(proc.is_active()); TESTASSERT(not proc_fut.is_complete())
TESTASSERT(not proc.is_complete()); TESTASSERT(proc.is_busy())
callbacks.run(); callbacks.run();
} }
TESTASSERT(proc.is_active()); TESTASSERT(proc.is_idle());
TESTASSERT(proc.is_complete()); TESTASSERT(proc_fut.is_success() and *proc_fut.value() == 2)
TESTASSERT(proc.get()->obj.id == 2)
TESTASSERT(proc.get()->obj.counters.then_counter == 1)
TESTASSERT(proc.get()->reset_called) // Proc is ready to be reused
TESTASSERT(proc.get()->obj.id == 2); srslte::proc_future_t<int> proc_fut2 = proc.get_future();
TESTASSERT(proc.is_active()); TESTASSERT(not proc_fut2.is_complete() and proc_fut.is_complete())
{
printf("pop being called\n");
srslte::proc_result_t<custom_proc> ret = proc.pop();
TESTASSERT(proc.is_active());
TESTASSERT(ret.is_success());
// proc::reset() is finally called
}
TESTASSERT(not proc.is_active());
TESTASSERT(proc.get()->reset_called); // Proc is ready to be reused
printf("EXIT\n"); printf("EXIT\n");
TESTASSERT(TestObj::copy_counter == 0); TESTASSERT(TestObj::copy_counter == 0);
@ -268,25 +288,25 @@ int test_callback_1()
int test_callback_2() int test_callback_2()
{ {
/* /*
* Description: Test a procedure inserted in a manager list via "proc_manager_list_t::consume_proc(...)" * Description: Test a procedure inserted in a manager list as an r-value
* - check if the proc disappears automatically after it finished * - check if the proc disappears automatically after it finished
*/ */
new_test(); new_test();
printf("\n--- Test %s ---\n", __func__); printf("\n--- Test %s ---\n", __func__);
srslte::proc_manager_list_t callbacks; srslte::proc_manager_list_t callbacks;
srslte::proc_t<custom_proc> proc; srslte::proc_t<custom_proc, int> proc;
TESTASSERT(not proc.is_active()); TESTASSERT(not proc.is_busy());
srslte::proc_future_t<int> fut = proc.get_future();
TESTASSERT(proc.launch(3)); TESTASSERT(proc.launch(3));
TESTASSERT(proc.is_active()); TESTASSERT(proc.is_busy());
TESTASSERT(not proc.is_complete()); callbacks.add_proc(std::move(proc));
callbacks.consume_proc(std::move(proc));
TESTASSERT(callbacks.size() == 1); TESTASSERT(callbacks.size() == 1);
while (callbacks.size() > 0) { while (callbacks.size() > 0) {
callbacks.run(); callbacks.run();
} }
// since the proc was consumed, it is erased without the need for pop() TESTASSERT(fut.is_success() and *fut.value() == 3)
printf("EXIT\n"); printf("EXIT\n");
TESTASSERT(TestObj::copy_counter == 0); TESTASSERT(TestObj::copy_counter == 0);
@ -296,42 +316,6 @@ int test_callback_2()
} }
int test_callback_3() int test_callback_3()
{
/*
* Description: Test a procedure inserted in a manager list via "proc_manager_list_t::defer_proc(...)"
* - check if the proc is cleared automatically after it finished
*/
new_test();
printf("\n--- Test %s ---\n", __func__);
srslte::proc_manager_list_t callbacks;
srslte::proc_t<custom_proc> proc;
TESTASSERT(not proc.is_active());
proc.launch(4);
TESTASSERT(proc.is_active());
TESTASSERT(not proc.is_complete());
callbacks.defer_proc(proc); // we still have access to proc, but we do not need to call pop()
TESTASSERT(callbacks.size() == 1);
TESTASSERT(proc.is_active());
TESTASSERT(not proc.is_complete());
while (callbacks.size() > 0) {
TESTASSERT(proc.is_active());
TESTASSERT(not proc.is_complete());
callbacks.run();
}
TESTASSERT(not proc.is_active());
TESTASSERT(not proc.is_complete());
TESTASSERT(proc.get()->reset_called); // Proc is ready to be reused
printf("EXIT\n");
TESTASSERT(TestObj::copy_counter == 0);
TESTASSERT(TestObj::move_counter == 0);
TESTASSERT(TestObj::dtor_counter == 0); // handler not yet destructed
return 0;
}
int test_callback_4()
{ {
/* /*
* Description: Test for Lambda procedure types * Description: Test for Lambda procedure types
@ -344,7 +328,7 @@ int test_callback_4()
int* counter = new int(5); int* counter = new int(5);
{ {
callbacks.defer_task([counter]() { callbacks.add_task([counter]() {
printf("current counter=%d\n", *counter); printf("current counter=%d\n", *counter);
if (--(*counter) == 0) { if (--(*counter) == 0) {
return proc_outcome_t::success; return proc_outcome_t::success;
@ -357,14 +341,13 @@ int test_callback_4()
callbacks.run(); callbacks.run();
} }
// printf("counter=%d\n", counter);
TESTASSERT(*counter == 0); TESTASSERT(*counter == 0);
delete counter; delete counter;
return 0; return 0;
} }
int test_callback_5() int test_callback_4()
{ {
/* /*
* Description: Test if finished procedure does not get added to the dispatch list * Description: Test if finished procedure does not get added to the dispatch list
@ -372,15 +355,15 @@ int test_callback_5()
new_test(); new_test();
printf("\n--- Test %s ---\n", __func__); printf("\n--- Test %s ---\n", __func__);
srslte::proc_manager_list_t callbacks; srslte::proc_manager_list_t callbacks;
srslte::proc_t<custom_proc> proc; srslte::proc_t<custom_proc, int> proc;
TESTASSERT(proc.launch(5)); TESTASSERT(proc.launch(5));
while (proc.run()) { while (proc.run()) {
TESTASSERT(proc.is_active()); TESTASSERT(proc.is_busy());
} }
TESTASSERT(proc.is_active()); TESTASSERT(proc.is_idle());
TESTASSERT(not proc.get()->reset_called); TESTASSERT(proc.get()->obj.counters.then_counter == 1)
TESTASSERT(proc.is_complete()); TESTASSERT(proc.get()->reset_called);
callbacks.defer_proc(proc); callbacks.add_proc(proc);
TESTASSERT(callbacks.size() == 0); // do not add finished callbacks TESTASSERT(callbacks.size() == 0); // do not add finished callbacks
return 0; return 0;
@ -389,47 +372,79 @@ int test_callback_5()
int test_complete_callback_1() int test_complete_callback_1()
{ {
/* /*
* Description: Test if on_complete() callbacks are correctly called * Description: Test if then() callbacks are correctly called
*/ */
printf("\n--- Test %s ---\n", __func__); printf("\n--- Test %s ---\n", __func__);
srslte::proc_manager_list_t callbacks; srslte::proc_manager_list_t callbacks;
srslte::proc_t<custom_proc2_t> proc; srslte::proc_t<custom_proc2_t, std::string> proc;
std::string run_result; std::string run_result;
auto continuation_task = [&run_result](bool is_success) { run_result = is_success ? "SUCCESS" : "FAILURE"; }; auto continuation_task = [&run_result](const srslte::proc_result_t<std::string>& e) {
std::string results[] = {"", "SUCCESS", "", "SUCCESS", "SUCCESS", "SUCCESS"}; run_result = e.is_success() ? "SUCCESS" : "FAILURE";
};
const std::string results[] = {"", "SUCCESS", "", "SUCCESS", "SUCCESS", "SUCCESS"};
for (uint32_t i = 0; i < 6; ++i) { for (uint32_t i = 0; i < 6; ++i) {
run_result = ""; run_result = "";
if (i == 1) { if (i == 1) {
TESTASSERT(proc.then(continuation_task) == 0); TESTASSERT(proc.then(continuation_task) == 0)
} else if (i == 3) { } else if (i == 3) {
TESTASSERT(proc.then_always(continuation_task) == 0); TESTASSERT(proc.then_always(continuation_task) == 0)
} }
srslte::proc_future_t<std::string> fut = proc.get_future();
TESTASSERT(proc.launch()); TESTASSERT(proc.launch());
TESTASSERT(proc.get()->exit_val == "init"); TESTASSERT(proc.get()->exit_val == "init")
while (proc.run()) { while (proc.run()) {
TESTASSERT(proc.get()->exit_val == "init"); TESTASSERT(proc.get()->exit_val == "init")
TESTASSERT(proc.is_active()); TESTASSERT(proc.is_busy())
} }
TESTASSERT(proc.is_active() and proc.is_complete()); TESTASSERT(proc.is_idle() and proc.get()->exit_val == "success")
srslte::proc_result_t<custom_proc2_t> ret = proc.pop(); TESTASSERT(fut.is_success() and *fut.value() == "success")
TESTASSERT(ret.is_success() and ret.proc()->exit_val == "success");
TESTASSERT(run_result == results[i]); TESTASSERT(run_result == results[i])
} }
return 0; return 0;
} }
int test_event_handler_1()
{
/*
* Description: Test if event handler calls trigger for multiple procedures
*/
printf("\n--- Test %s ---\n", __func__);
srslte::proc_t<custom_proc2_t, std::string> proc, proc2;
srslte::event_handler_t<custom_proc2_t::event_t> ev_handler;
TESTASSERT(proc.launch())
TESTASSERT(proc2.launch())
TESTASSERT(proc.is_busy() and proc2.is_busy())
TESTASSERT(proc.get()->exit_val == "init" and proc2.get()->exit_val == "init")
TESTASSERT(proc.get()->event_val.empty() and proc2.get()->event_val.empty())
ev_handler.on_next_trigger(proc);
ev_handler.on_every_trigger(proc2);
ev_handler.trigger(custom_proc2_t::event_t{"event1"});
TESTASSERT(proc.get()->event_val == "event1" and proc.get()->event_val == "event1")
ev_handler.trigger(custom_proc2_t::event_t{"event2"});
TESTASSERT(proc.get()->event_val == "event1" and proc2.get()->event_val == "event2")
printf("Procedures correctly triggered by event handler\n");
return 0;
}
int main() int main()
{ {
TESTASSERT(test_local_1() == 0); TESTASSERT(test_local_1() == 0)
TESTASSERT(test_callback_1() == 0); TESTASSERT(test_callback_1() == 0)
TESTASSERT(test_callback_2() == 0); TESTASSERT(test_callback_2() == 0)
TESTASSERT(test_callback_3() == 0); TESTASSERT(test_callback_3() == 0)
TESTASSERT(test_callback_4() == 0); TESTASSERT(test_callback_4() == 0)
TESTASSERT(test_callback_5() == 0); TESTASSERT(test_complete_callback_1() == 0)
TESTASSERT(test_complete_callback_1() == 0); TESTASSERT(test_event_handler_1() == 0)
std::cout << "\n---------------\nResult: Success\n";
return 0; return 0;
} }

4
srsue/hdr/stack/rrc/rrc.h
View File

@ -624,10 +624,10 @@ private:
class process_pcch_proc; class process_pcch_proc;
class go_idle_proc; class go_idle_proc;
class cell_reselection_proc; class cell_reselection_proc;
srslte::proc_t<cell_search_proc> cell_searcher; srslte::proc_t<cell_search_proc, phy_interface_rrc_lte::cell_search_ret_t> cell_searcher;
srslte::proc_t<si_acquire_proc> si_acquirer; srslte::proc_t<si_acquire_proc> si_acquirer;
srslte::proc_t<serving_cell_config_proc> serv_cell_cfg; srslte::proc_t<serving_cell_config_proc> serv_cell_cfg;
srslte::proc_t<cell_selection_proc> cell_selector; srslte::proc_t<cell_selection_proc, cs_result_t> cell_selector;
srslte::proc_t<go_idle_proc> idle_setter; srslte::proc_t<go_idle_proc> idle_setter;
srslte::proc_t<process_pcch_proc> pcch_processor; srslte::proc_t<process_pcch_proc> pcch_processor;
srslte::proc_t<connection_request_proc> conn_req_proc; srslte::proc_t<connection_request_proc> conn_req_proc;

37
srsue/hdr/stack/rrc/rrc_procedures.h
View File

@ -41,9 +41,9 @@ public:
explicit cell_search_proc(rrc* parent_); explicit cell_search_proc(rrc* parent_);
srslte::proc_outcome_t init(); srslte::proc_outcome_t init();
srslte::proc_outcome_t step(); srslte::proc_outcome_t step();
srslte::proc_outcome_t trigger_event(const cell_search_event_t& event); srslte::proc_outcome_t react(const cell_search_event_t& event);
phy_interface_rrc_lte::cell_search_ret_t get_cs_ret() const { return search_result.cs_ret; } phy_interface_rrc_lte::cell_search_ret_t get_result() const { return search_result.cs_ret; }
static const char* name() { return "Cell Search"; } static const char* name() { return "Cell Search"; }
private: private:
@ -51,10 +51,10 @@ private:
// conts // conts
rrc* rrc_ptr; rrc* rrc_ptr;
srslte::log* log_h;
// state vars // state vars
cell_search_event_t search_result; cell_search_event_t search_result;
srslte::proc_future_t<void> si_acquire_fut;
state_t state; state_t state;
}; };
@ -100,16 +100,19 @@ private:
// state variables // state variables
enum class search_state_t { next_sib, si_acquire } search_state; enum class search_state_t { next_sib, si_acquire } search_state;
uint32_t req_idx = 0; uint32_t req_idx = 0;
srslte::proc_future_t<void> si_acquire_fut;
}; };
class rrc::cell_selection_proc class rrc::cell_selection_proc
{ {
public: public:
using cell_selection_complete_ev = srslte::proc_result_t<cs_result_t>;
explicit cell_selection_proc(rrc* parent_); explicit cell_selection_proc(rrc* parent_);
srslte::proc_outcome_t init(); srslte::proc_outcome_t init();
srslte::proc_outcome_t step(); srslte::proc_outcome_t step();
void on_complete(bool is_success); void then(const srslte::proc_result_t<cs_result_t>& proc_result) const;
cs_result_t get_cs_result() const { return cs_result; } cs_result_t get_result() const { return cs_result; }
static const char* name() { return "Cell Selection"; } static const char* name() { return "Cell Selection"; }
private: private:
@ -119,13 +122,14 @@ private:
// consts // consts
rrc* rrc_ptr; rrc* rrc_ptr;
srslte::log* log_h;
// state variables // state variables
enum class search_state_t { cell_selection, cell_config, cell_search }; enum class search_state_t { cell_selection, cell_config, cell_search };
cs_result_t cs_result; cs_result_t cs_result;
search_state_t state; search_state_t state;
uint32_t neigh_index; uint32_t neigh_index;
srslte::proc_future_t<phy_interface_rrc_lte::cell_search_ret_t> cell_search_fut;
srslte::proc_future_t<void> serv_cell_cfg_fut;
}; };
class rrc::plmn_search_proc class rrc::plmn_search_proc
@ -134,7 +138,7 @@ public:
explicit plmn_search_proc(rrc* parent_); explicit plmn_search_proc(rrc* parent_);
srslte::proc_outcome_t init(); srslte::proc_outcome_t init();
srslte::proc_outcome_t step(); srslte::proc_outcome_t step();
void on_complete(bool is_success); void then(const srslte::proc_result_t<void>& result) const;
static const char* name() { return "PLMN Search"; } static const char* name() { return "PLMN Search"; }
private: private:
@ -145,22 +149,17 @@ private:
// state variables // state variables
found_plmn_t found_plmns[MAX_FOUND_PLMNS]; found_plmn_t found_plmns[MAX_FOUND_PLMNS];
int nof_plmns = 0; int nof_plmns = 0;
srslte::proc_future_t<phy_interface_rrc_lte::cell_search_ret_t> cell_search_fut;
}; };
class rrc::connection_request_proc class rrc::connection_request_proc
{ {
public: public:
struct cell_selection_complete {
bool is_success;
cs_result_t cs_result;
};
explicit connection_request_proc(rrc* parent_); explicit connection_request_proc(rrc* parent_);
srslte::proc_outcome_t srslte::proc_outcome_t init(srslte::establishment_cause_t cause_, srslte::unique_byte_buffer_t dedicated_info_nas_);
init(srslte::establishment_cause_t cause_, srslte::unique_byte_buffer_t dedicated_info_nas_);
srslte::proc_outcome_t step(); srslte::proc_outcome_t step();
void on_complete(bool is_success); void then(const srslte::proc_result_t<void>& result);
srslte::proc_outcome_t trigger_event(const cell_selection_complete& e); srslte::proc_outcome_t react(const cell_selection_proc::cell_selection_complete_ev& e);
static const char* name() { return "Connection Request"; } static const char* name() { return "Connection Request"; }
private: private:
@ -174,6 +173,7 @@ private:
// state variables // state variables
enum class state_t { cell_selection, config_serving_cell, wait_t300 } state; enum class state_t { cell_selection, config_serving_cell, wait_t300 } state;
cs_result_t cs_ret; cs_result_t cs_ret;
srslte::proc_future_t<void> serv_cfg_fut;
}; };
class rrc::process_pcch_proc class rrc::process_pcch_proc
@ -186,7 +186,7 @@ public:
explicit process_pcch_proc(rrc* parent_); explicit process_pcch_proc(rrc* parent_);
srslte::proc_outcome_t init(const asn1::rrc::paging_s& paging_); srslte::proc_outcome_t init(const asn1::rrc::paging_s& paging_);
srslte::proc_outcome_t step(); srslte::proc_outcome_t step();
srslte::proc_outcome_t trigger_event(paging_complete e); srslte::proc_outcome_t react(paging_complete e);
static const char* name() { return "Process PCCH"; } static const char* name() { return "Process PCCH"; }
private: private:
@ -198,6 +198,7 @@ private:
// vars // vars
uint32_t paging_idx = 0; uint32_t paging_idx = 0;
enum class state_t { next_record, nas_paging, serv_cell_cfg } state; enum class state_t { next_record, nas_paging, serv_cell_cfg } state;
srslte::proc_future_t<void> serv_cfg_fut;
}; };
class rrc::go_idle_proc class rrc::go_idle_proc
@ -225,6 +226,8 @@ public:
private: private:
rrc* rrc_ptr; rrc* rrc_ptr;
srslte::proc_future_t<cs_result_t> cell_selection_fut;
}; };
} // namespace srsue } // namespace srsue

18
srsue/hdr/stack/upper/nas.h
View File

@ -50,7 +50,7 @@ public:
// RRC interface // RRC interface
void left_rrc_connected(); void left_rrc_connected();
void paging(srslte::s_tmsi_t* ue_identity); bool paging(srslte::s_tmsi_t* ue_identity);
void set_barring(barring_t barring); void set_barring(barring_t barring);
void write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t pdu); void write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t pdu);
uint32_t get_k_enb_count(); uint32_t get_k_enb_count();
@ -60,13 +60,11 @@ public:
bool get_ipv6_addr(uint8_t* ipv6_addr); bool get_ipv6_addr(uint8_t* ipv6_addr);
// UE interface // UE interface
void start_attach_request(srslte::proc_state_t* result, srslte::establishment_cause_t cause_) final; void start_attach_request(srslte::proc_result_t<void>* result, srslte::establishment_cause_t cause_) final;
bool detach_request(const bool switch_off) final; bool detach_request(const bool switch_off) final;
void plmn_search_completed(rrc_interface_nas::found_plmn_t found_plmns[rrc_interface_nas::MAX_FOUND_PLMNS], void plmn_search_completed(const rrc_interface_nas::found_plmn_t found_plmns[rrc_interface_nas::MAX_FOUND_PLMNS],
int nof_plmns) final; int nof_plmns) final;
bool start_connection_request(srslte::establishment_cause_t establish_cause,
srslte::unique_byte_buffer_t ded_info_nas);
bool connection_request_completed(bool outcome) final; bool connection_request_completed(bool outcome) final;
// timer callback // timer callback
@ -261,6 +259,7 @@ private:
class rrc_connect_proc class rrc_connect_proc
{ {
public: public:
using rrc_connect_complete_ev = srslte::proc_result_t<void>;
struct connection_request_completed_t { struct connection_request_completed_t {
bool outcome; bool outcome;
}; };
@ -268,6 +267,8 @@ private:
rrc_connect_proc(nas* nas_ptr_) : nas_ptr(nas_ptr_) {} rrc_connect_proc(nas* nas_ptr_) : nas_ptr(nas_ptr_) {}
srslte::proc_outcome_t init(srslte::establishment_cause_t cause_, srslte::unique_byte_buffer_t pdu); srslte::proc_outcome_t init(srslte::establishment_cause_t cause_, srslte::unique_byte_buffer_t pdu);
srslte::proc_outcome_t step(); srslte::proc_outcome_t step();
void then(const srslte::proc_result_t<void>& result);
srslte::proc_outcome_t react(connection_request_completed_t event);
static const char* name() { return "RRC Connect"; } static const char* name() { return "RRC Connect"; }
private: private:
@ -281,7 +282,7 @@ private:
struct plmn_search_complete_t { struct plmn_search_complete_t {
rrc_interface_nas::found_plmn_t found_plmns[rrc_interface_nas::MAX_FOUND_PLMNS]; rrc_interface_nas::found_plmn_t found_plmns[rrc_interface_nas::MAX_FOUND_PLMNS];
int nof_plmns; int nof_plmns;
plmn_search_complete_t(rrc_interface_nas::found_plmn_t* plmns_, int nof_plmns_) : nof_plmns(nof_plmns_) plmn_search_complete_t(const rrc_interface_nas::found_plmn_t* plmns_, int nof_plmns_) : nof_plmns(nof_plmns_)
{ {
if (nof_plmns > 0) { if (nof_plmns > 0) {
std::copy(&plmns_[0], &plmns_[nof_plmns], found_plmns); std::copy(&plmns_[0], &plmns_[nof_plmns], found_plmns);
@ -292,7 +293,9 @@ private:
plmn_search_proc(nas* nas_ptr_) : nas_ptr(nas_ptr_) {} plmn_search_proc(nas* nas_ptr_) : nas_ptr(nas_ptr_) {}
srslte::proc_outcome_t init(); srslte::proc_outcome_t init();
srslte::proc_outcome_t step(); srslte::proc_outcome_t step();
srslte::proc_outcome_t trigger_event(const plmn_search_complete_t& t); void then(const srslte::proc_result_t<void>& result);
srslte::proc_outcome_t react(const plmn_search_complete_t& t);
srslte::proc_outcome_t react(const rrc_connect_proc::rrc_connect_complete_ev& t);
static const char* name() { return "PLMN Search"; } static const char* name() { return "PLMN Search"; }
private: private:
@ -302,7 +305,6 @@ private:
srslte::proc_manager_list_t callbacks; srslte::proc_manager_list_t callbacks;
srslte::proc_t<plmn_search_proc> plmn_searcher; srslte::proc_t<plmn_search_proc> plmn_searcher;
srslte::proc_t<rrc_connect_proc> rrc_connector; srslte::proc_t<rrc_connect_proc> rrc_connector;
srslte::proc_t<srslte::query_proc_t<bool> > conn_req_proc;
}; };
} // namespace srsue } // namespace srsue

16
srsue/src/stack/rrc/rrc.cc
View File

@ -316,7 +316,7 @@ bool rrc::plmn_search()
rrc_log->error("Unable to initiate PLMN search\n"); rrc_log->error("Unable to initiate PLMN search\n");
return false; return false;
} }
callback_list.defer_proc(plmn_searcher); callback_list.add_proc(plmn_searcher);
return true; return true;
} }
@ -345,7 +345,7 @@ bool rrc::connection_request(srslte::establishment_cause_t cause, srslte::unique
rrc_log->error("Failed to initiate connection request procedure\n"); rrc_log->error("Failed to initiate connection request procedure\n");
return false; return false;
} }
callback_list.defer_proc(conn_req_proc); callback_list.add_proc(conn_req_proc);
return true; return true;
} }
@ -1189,7 +1189,7 @@ bool rrc::con_reconfig_ho(asn1::rrc::rrc_conn_recfg_s* reconfig)
void rrc::start_ho() void rrc::start_ho()
{ {
callback_list.defer_task([this]() { callback_list.add_task([this]() {
if (state != RRC_STATE_CONNECTED) { if (state != RRC_STATE_CONNECTED) {
rrc_log->info("HO interrupted, since RRC is no longer in connected state\n"); rrc_log->info("HO interrupted, since RRC is no longer in connected state\n");
return srslte::proc_outcome_t::success; return srslte::proc_outcome_t::success;
@ -1208,7 +1208,7 @@ void rrc::start_go_idle()
rrc_log->info("Failed to set RRC to IDLE\n"); rrc_log->info("Failed to set RRC to IDLE\n");
return; return;
} }
callback_list.defer_proc(idle_setter); callback_list.add_proc(idle_setter);
} }
// Handle RRC Reconfiguration without MobilityInformation Section 5.3.5.3 // Handle RRC Reconfiguration without MobilityInformation Section 5.3.5.3
@ -1478,7 +1478,7 @@ void rrc::start_cell_reselection()
return; return;
} }
if (cell_reselector.is_active()) { if (cell_reselector.is_busy()) {
// it is already running // it is already running
return; return;
} }
@ -1492,7 +1492,7 @@ void rrc::start_cell_reselection()
void rrc::cell_search_completed(const phy_interface_rrc_lte::cell_search_ret_t& cs_ret, void rrc::cell_search_completed(const phy_interface_rrc_lte::cell_search_ret_t& cs_ret,
const phy_interface_rrc_lte::phy_cell_t& found_cell) const phy_interface_rrc_lte::phy_cell_t& found_cell)
{ {
cell_searcher.trigger_event(cell_search_proc::cell_search_event_t{cs_ret, found_cell}); cell_searcher.trigger(cell_search_proc::cell_search_event_t{cs_ret, found_cell});
} }
/******************************************************************************* /*******************************************************************************
@ -1725,7 +1725,7 @@ void rrc::write_pdu_pcch(unique_byte_buffer_t pdu)
void rrc::paging_completed(bool outcome) void rrc::paging_completed(bool outcome)
{ {
pcch_processor.trigger_event(process_pcch_proc::paging_complete{outcome}); pcch_processor.trigger(process_pcch_proc::paging_complete{outcome});
} }
void rrc::process_pcch(unique_byte_buffer_t pdu) void rrc::process_pcch(unique_byte_buffer_t pdu)
@ -1760,7 +1760,7 @@ void rrc::process_pcch(unique_byte_buffer_t pdu)
} }
// we do not care about the outcome // we do not care about the outcome
callback_list.defer_proc(pcch_processor); callback_list.add_proc(pcch_processor);
} }
void rrc::write_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t pdu) void rrc::write_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t pdu)

137
srsue/src/stack/rrc/rrc_procedures.cc
View File

@ -35,7 +35,7 @@ using srslte::proc_outcome_t;
* Cell Search Procedure * Cell Search Procedure
*************************************/ *************************************/
rrc::cell_search_proc::cell_search_proc(rrc* parent_) : rrc_ptr(parent_), log_h(parent_->rrc_log) {} rrc::cell_search_proc::cell_search_proc(rrc* parent_) : rrc_ptr(parent_) {}
/* Searches for a cell in the current frequency and retrieves SIB1 if not retrieved yet */ /* Searches for a cell in the current frequency and retrieves SIB1 if not retrieved yet */
proc_outcome_t rrc::cell_search_proc::init() proc_outcome_t rrc::cell_search_proc::init()
@ -43,7 +43,7 @@ proc_outcome_t rrc::cell_search_proc::init()
Info("Starting...\n"); Info("Starting...\n");
state = state_t::phy_cell_search; state = state_t::phy_cell_search;
rrc_ptr->stack->start_cell_search(); rrc_ptr->stack->start_cell_search();
return proc_outcome_t::repeat; return proc_outcome_t::yield;
} }
/* Implements the SI acquisition procedure. Configures MAC/PHY scheduling to retrieve SI messages.*/ /* Implements the SI acquisition procedure. Configures MAC/PHY scheduling to retrieve SI messages.*/
@ -53,19 +53,16 @@ proc_outcome_t rrc::cell_search_proc::step()
// Waits for cell search to complete // Waits for cell search to complete
return proc_outcome_t::yield; return proc_outcome_t::yield;
} else if (state == state_t::si_acquire) { } else if (state == state_t::si_acquire) {
if (not rrc_ptr->si_acquirer.run()) { if (rrc_ptr->si_acquirer.run()) {
return proc_outcome_t::yield;
}
// SI Acquire has completed // SI Acquire has completed
srslte::proc_result_t<si_acquire_proc> ret = rrc_ptr->si_acquirer.pop(); if (si_acquire_fut.is_error()) {
if (ret.is_error()) {
Error("Failed to trigger SI acquire for SIB0\n"); Error("Failed to trigger SI acquire for SIB0\n");
return proc_outcome_t::error; return proc_outcome_t::error;
} else { }
// if(parent->serving_cell->has_sib(0)) {
// }
return proc_outcome_t::success; return proc_outcome_t::success;
} }
}
}
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
@ -82,7 +79,7 @@ proc_outcome_t rrc::cell_search_proc::handle_cell_found(const phy_interface_rrc_
rrc_ptr->set_serving_cell(new_cell); rrc_ptr->set_serving_cell(new_cell);
if (not rrc_ptr->phy->cell_is_camping()) { if (not rrc_ptr->phy->cell_is_camping()) {
log_h->warning("Could not camp on found cell.\n"); Warning("Could not camp on found cell.\n");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
@ -97,6 +94,7 @@ proc_outcome_t rrc::cell_search_proc::handle_cell_found(const phy_interface_rrc_
Error("SI Acquire is already running...\n"); Error("SI Acquire is already running...\n");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
si_acquire_fut = rrc_ptr->si_acquirer.get_future();
// instruct MAC to look for SIB1 // instruct MAC to look for SIB1
Info("Cell has no SIB1. Obtaining SIB1...\n"); Info("Cell has no SIB1. Obtaining SIB1...\n");
@ -104,7 +102,7 @@ proc_outcome_t rrc::cell_search_proc::handle_cell_found(const phy_interface_rrc_
return proc_outcome_t::repeat; return proc_outcome_t::repeat;
} }
proc_outcome_t rrc::cell_search_proc::trigger_event(const cell_search_event_t& event) proc_outcome_t rrc::cell_search_proc::react(const cell_search_event_t& event)
{ {
if (state != state_t::phy_cell_search) { if (state != state_t::phy_cell_search) {
Error("Received unexpected cell search result\n"); Error("Received unexpected cell search result\n");
@ -279,6 +277,7 @@ proc_outcome_t rrc::serving_cell_config_proc::step()
Error("SI Acquire is already running...\n"); Error("SI Acquire is already running...\n");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
si_acquire_fut = rrc_ptr->si_acquirer.get_future();
search_state = search_state_t::si_acquire; search_state = search_state_t::si_acquire;
return proc_outcome_t::repeat; return proc_outcome_t::repeat;
} else { } else {
@ -301,10 +300,11 @@ proc_outcome_t rrc::serving_cell_config_proc::step()
return proc_outcome_t::success; return proc_outcome_t::success;
} }
} else if (search_state == search_state_t::si_acquire) { } else if (search_state == search_state_t::si_acquire) {
if (rrc_ptr->si_acquirer.run()) {
return proc_outcome_t::yield;
}
uint32_t required_sib = required_sibs[req_idx]; uint32_t required_sib = required_sibs[req_idx];
if (not rrc_ptr->si_acquirer.run()) { if (si_acquire_fut.is_error() or not rrc_ptr->serving_cell->has_sib(required_sib)) {
srslte::proc_result_t<si_acquire_proc> ret = rrc_ptr->si_acquirer.pop();
if (ret.is_error() or not rrc_ptr->serving_cell->has_sib(required_sib)) {
if (required_sib < 2) { if (required_sib < 2) {
log_h->warning("Serving Cell Configuration has failed\n"); log_h->warning("Serving Cell Configuration has failed\n");
return proc_outcome_t::error; return proc_outcome_t::error;
@ -315,7 +315,6 @@ proc_outcome_t rrc::serving_cell_config_proc::step()
req_idx++; req_idx++;
return proc_outcome_t::repeat; return proc_outcome_t::repeat;
} }
}
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
@ -323,7 +322,7 @@ proc_outcome_t rrc::serving_cell_config_proc::step()
* Cell Selection Procedure * Cell Selection Procedure
*************************************/ *************************************/
rrc::cell_selection_proc::cell_selection_proc(rrc* parent_) : rrc_ptr(parent_), log_h(parent_->rrc_log) {} rrc::cell_selection_proc::cell_selection_proc(rrc* parent_) : rrc_ptr(parent_) {}
/* /*
* Cell selection procedure 36.304 5.2.3 * Cell selection procedure 36.304 5.2.3
@ -361,13 +360,14 @@ proc_outcome_t rrc::cell_selection_proc::step_cell_selection()
// Try to select Cell // Try to select Cell
rrc_ptr->set_serving_cell(rrc_ptr->neighbour_cells.at(neigh_index)->phy_cell); rrc_ptr->set_serving_cell(rrc_ptr->neighbour_cells.at(neigh_index)->phy_cell);
Info("Selected cell: %s\n", rrc_ptr->serving_cell->print().c_str()); Info("Selected cell: %s\n", rrc_ptr->serving_cell->print().c_str());
log_h->console("Selected cell: %s\n", rrc_ptr->serving_cell->print().c_str()); rrc_ptr->rrc_log->console("Selected cell: %s\n", rrc_ptr->serving_cell->print().c_str());
/* BLOCKING CALL */ /* BLOCKING CALL */
if (rrc_ptr->phy->cell_select(&rrc_ptr->serving_cell->phy_cell)) { if (rrc_ptr->phy->cell_select(&rrc_ptr->serving_cell->phy_cell)) {
if (not rrc_ptr->serv_cell_cfg.launch(rrc_ptr->ue_required_sibs)) { if (not rrc_ptr->serv_cell_cfg.launch(rrc_ptr->ue_required_sibs)) {
return proc_outcome_t::error; return proc_outcome_t::error;
} }
serv_cell_cfg_fut = rrc_ptr->serv_cell_cfg.get_future();
state = search_state_t::cell_config; state = search_state_t::cell_config;
return proc_outcome_t::repeat; return proc_outcome_t::repeat;
} else { } else {
@ -400,27 +400,25 @@ proc_outcome_t rrc::cell_selection_proc::step_cell_selection()
if (not rrc_ptr->cell_searcher.launch()) { if (not rrc_ptr->cell_searcher.launch()) {
return proc_outcome_t::error; return proc_outcome_t::error;
} }
cell_search_fut = rrc_ptr->cell_searcher.get_future();
state = search_state_t::cell_search; state = search_state_t::cell_search;
return proc_outcome_t::repeat; return proc_outcome_t::repeat;
} }
proc_outcome_t rrc::cell_selection_proc::step_cell_search() proc_outcome_t rrc::cell_selection_proc::step_cell_search()
{ {
if (rrc_ptr->cell_searcher.run()) { if (rrc_ptr->cell_searcher.run()) {
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
srslte::proc_result_t<cell_search_proc> ret = rrc_ptr->cell_searcher.pop(); if (cell_search_fut.is_error()) {
if (ret.is_error()) {
cs_result = cs_result_t::no_cell; cs_result = cs_result_t::no_cell;
return proc_outcome_t::error; return proc_outcome_t::error;
} else { }
cs_result = (ret.proc()->get_cs_ret().found == phy_interface_rrc_lte::cell_search_ret_t::CELL_FOUND) cs_result = (cell_search_fut.value()->found == phy_interface_rrc_lte::cell_search_ret_t::CELL_FOUND)
? cs_result_t::changed_cell ? cs_result_t::changed_cell
: cs_result_t::no_cell; : cs_result_t::no_cell;
Info("Cell Search of cell selection run successfully\n"); Info("Cell Search of cell selection run successfully\n");
return proc_outcome_t::success; return proc_outcome_t::success;
}
} }
proc_outcome_t rrc::cell_selection_proc::step_cell_config() proc_outcome_t rrc::cell_selection_proc::step_cell_config()
@ -428,18 +426,16 @@ proc_outcome_t rrc::cell_selection_proc::step_cell_config()
if (rrc_ptr->serv_cell_cfg.run()) { if (rrc_ptr->serv_cell_cfg.run()) {
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
srslte::proc_result_t<serving_cell_config_proc> ret = rrc_ptr->serv_cell_cfg.pop(); if (serv_cell_cfg_fut.is_success()) {
if (ret.is_success()) {
Info("All SIBs of serving cell obtained successfully\n"); Info("All SIBs of serving cell obtained successfully\n");
cs_result = cs_result_t::changed_cell; cs_result = cs_result_t::changed_cell;
return proc_outcome_t::success; return proc_outcome_t::success;
} else { }
Error("While configuring serving cell\n"); Error("While configuring serving cell\n");
// resume cell selection // resume cell selection
state = search_state_t::cell_selection; state = search_state_t::cell_selection;
++neigh_index; ++neigh_index;
return proc_outcome_t::repeat; return proc_outcome_t::repeat;
}
} }
proc_outcome_t rrc::cell_selection_proc::step() proc_outcome_t rrc::cell_selection_proc::step()
@ -455,13 +451,13 @@ proc_outcome_t rrc::cell_selection_proc::step()
return proc_outcome_t::error; return proc_outcome_t::error;
} }
void rrc::cell_selection_proc::on_complete(bool is_success) void rrc::cell_selection_proc::then(const srslte::proc_result_t<cs_result_t>& proc_result) const
{ {
// Inform Connection Request Procedure // Inform Connection Request Procedure
Info("Completed with %s. Informing proc %s\n", Info("Completed with %s. Informing proc %s\n",
is_success ? "success" : "failure", proc_result.is_success() ? "success" : "failure",
rrc_ptr->conn_req_proc.get()->name()); rrc_ptr->conn_req_proc.get()->name());
rrc_ptr->conn_req_proc.trigger_event(connection_request_proc::cell_selection_complete{is_success, cs_result}); rrc_ptr->conn_req_proc.trigger(proc_result);
} }
/************************************** /**************************************
@ -478,6 +474,7 @@ proc_outcome_t rrc::plmn_search_proc::init()
Error("Failed due to fail to init cell search...\n"); Error("Failed due to fail to init cell search...\n");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
cell_search_fut = rrc_ptr->cell_searcher.get_future();
return proc_outcome_t::repeat; return proc_outcome_t::repeat;
} }
@ -492,16 +489,14 @@ proc_outcome_t rrc::plmn_search_proc::step()
// wait for new TTI // wait for new TTI
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
srslte::proc_result_t<cell_search_proc> ret = rrc_ptr->cell_searcher.pop(); if (cell_search_fut.is_error() or cell_search_fut.value()->found == phy_interface_rrc_lte::cell_search_ret_t::ERROR) {
phy_interface_rrc_lte::cell_search_ret_t cs_ret = ret.proc()->get_cs_ret();
if (ret.is_error() or cs_ret.found == phy_interface_rrc_lte::cell_search_ret_t::ERROR) {
// stop search // stop search
nof_plmns = -1; nof_plmns = -1;
Error("Failed due to failed cell search sub-procedure\n"); Error("Failed due to failed cell search sub-procedure\n");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
if (cs_ret.found == phy_interface_rrc_lte::cell_search_ret_t::CELL_FOUND) { if (cell_search_fut.value()->found == phy_interface_rrc_lte::cell_search_ret_t::CELL_FOUND) {
if (rrc_ptr->serving_cell->has_sib1()) { if (rrc_ptr->serving_cell->has_sib1()) {
// Save PLMN and TAC to NAS // Save PLMN and TAC to NAS
for (uint32_t i = 0; i < rrc_ptr->serving_cell->nof_plmns(); i++) { for (uint32_t i = 0; i < rrc_ptr->serving_cell->nof_plmns(); i++) {
@ -518,7 +513,7 @@ proc_outcome_t rrc::plmn_search_proc::step()
} }
} }
if (cs_ret.last_freq == phy_interface_rrc_lte::cell_search_ret_t::NO_MORE_FREQS) { if (cell_search_fut.value()->last_freq == phy_interface_rrc_lte::cell_search_ret_t::NO_MORE_FREQS) {
Info("completed PLMN search\n"); Info("completed PLMN search\n");
return proc_outcome_t::success; return proc_outcome_t::success;
} }
@ -532,10 +527,10 @@ proc_outcome_t rrc::plmn_search_proc::step()
return proc_outcome_t::repeat; return proc_outcome_t::repeat;
} }
void rrc::plmn_search_proc::on_complete(bool is_success) void rrc::plmn_search_proc::then(const srslte::proc_result_t<void>& result) const
{ {
// on cleanup, call plmn_search_completed // on cleanup, call plmn_search_completed
if (is_success) { if (result.is_success()) {
Info("completed with success\n"); Info("completed with success\n");
rrc_ptr->nas->plmn_search_completed(found_plmns, nof_plmns); rrc_ptr->nas->plmn_search_completed(found_plmns, nof_plmns);
} else { } else {
@ -577,25 +572,15 @@ proc_outcome_t rrc::connection_request_proc::init(srslte::establishment_cause_t
cs_ret = cs_result_t::no_cell; cs_ret = cs_result_t::no_cell;
state = state_t::cell_selection; state = state_t::cell_selection;
if (rrc_ptr->cell_selector.is_idle()) {
// No one is running cell selection
if (not rrc_ptr->cell_selector.launch()) { if (not rrc_ptr->cell_selector.launch()) {
if (not rrc_ptr->cell_selector.is_active()) {
// Launch failed but cell selection was not already running
Error("Failed to initiate cell selection procedure...\n"); Error("Failed to initiate cell selection procedure...\n");
return proc_outcome_t::error; return proc_outcome_t::error;
} else if (not rrc_ptr->cell_selector.is_complete()) {
// In case it was already running, just wait for an cell_selection_complete event trigger
Info("Cell selection proc already on-going. Wait for its result\n");
} else {
// It already completed with success. FIXME: Find more elegant solution
Info("A cell selection procedure has just finished successfully. I am reusing its result\n");
cell_selection_complete e{};
e.cs_result = rrc_ptr->cell_selector.get()->get_cs_result();
e.is_success = e.cs_result == cs_result_t::same_cell or e.cs_result == cs_result_t::changed_cell;
return trigger_event(e);
} }
rrc_ptr->callback_list.add_proc(rrc_ptr->cell_selector);
} else { } else {
// In case we were able to launch it, let the callback list handle it Info("Cell selection proc already on-going. Wait for its result\n");
rrc_ptr->callback_list.defer_proc(rrc_ptr->cell_selector);
} }
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
@ -609,9 +594,7 @@ proc_outcome_t rrc::connection_request_proc::step()
if (rrc_ptr->serv_cell_cfg.run()) { if (rrc_ptr->serv_cell_cfg.run()) {
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
srslte::proc_result_t<serving_cell_config_proc> ret = rrc_ptr->serv_cell_cfg.pop(); if (serv_cfg_fut.is_error()) {
if (ret.is_error()) {
Error("Configuring serving cell\n"); Error("Configuring serving cell\n");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
@ -643,13 +626,13 @@ proc_outcome_t rrc::connection_request_proc::step()
return proc_outcome_t::success; return proc_outcome_t::success;
} else if (rrc_ptr->timers->get(rrc_ptr->t300)->is_expired()) { } else if (rrc_ptr->timers->get(rrc_ptr->t300)->is_expired()) {
// T300 is expired: 5.3.3.6 // T300 is expired: 5.3.3.6
Info("Timer T300 expired: ConnectionRequest timed out\n"); Warning("Timer T300 expired: ConnectionRequest timed out\n");
rrc_ptr->mac->reset(); rrc_ptr->mac->reset();
rrc_ptr->set_mac_default(); rrc_ptr->set_mac_default();
rrc_ptr->rlc->reestablish(); rrc_ptr->rlc->reestablish();
} else { } else {
// T300 is stopped but RRC not Connected is because received Reject: Section 5.3.3.8 // T300 is stopped but RRC not Connected is because received Reject: Section 5.3.3.8
Info("Timer T300 stopped: Received ConnectionReject\n"); Warning("Timer T300 stopped: Received ConnectionReject\n");
rrc_ptr->mac->reset(); rrc_ptr->mac->reset();
rrc_ptr->set_mac_default(); rrc_ptr->set_mac_default();
} }
@ -658,28 +641,27 @@ proc_outcome_t rrc::connection_request_proc::step()
return proc_outcome_t::error; return proc_outcome_t::error;
} }
void rrc::connection_request_proc::on_complete(bool is_success) void rrc::connection_request_proc::then(const srslte::proc_result_t<void>& result)
{ {
if (not is_success) { if (result.is_error()) {
log_h->warning("Could not establish connection. Deallocating dedicatedInfoNAS PDU\n"); log_h->warning("Could not establish connection. Deallocating dedicatedInfoNAS PDU\n");
this->dedicated_info_nas.reset(); this->dedicated_info_nas.reset();
rrc_ptr->nas->connection_request_completed(false);
} else { } else {
Info("Finished connection request procedure successfully.\n"); Info("Finished connection request procedure successfully.\n");
rrc_ptr->nas->connection_request_completed(true);
} }
rrc_ptr->nas->connection_request_completed(result.is_success());
} }
srslte::proc_outcome_t rrc::connection_request_proc::trigger_event(const cell_selection_complete& e) srslte::proc_outcome_t rrc::connection_request_proc::react(const cell_selection_proc::cell_selection_complete_ev& e)
{ {
if (state != state_t::cell_selection) { if (state != state_t::cell_selection) {
// ignore if we are not expecting an cell selection result // ignore if we are not expecting an cell selection result
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
if (not e.is_success) { if (e.is_error()) {
return proc_outcome_t::error; return proc_outcome_t::error;
} }
cs_ret = e.cs_result; cs_ret = *e.value();
// .. and SI acquisition // .. and SI acquisition
if (rrc_ptr->phy->cell_is_camping()) { if (rrc_ptr->phy->cell_is_camping()) {
@ -695,6 +677,7 @@ srslte::proc_outcome_t rrc::connection_request_proc::trigger_event(const cell_se
Error("Attach request failed to configure serving cell...\n"); Error("Attach request failed to configure serving cell...\n");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
serv_cfg_fut = rrc_ptr->serv_cell_cfg.get_future();
state = state_t::config_serving_cell; state = state_t::config_serving_cell;
return proc_outcome_t::repeat; return proc_outcome_t::repeat;
} else { } else {
@ -744,11 +727,14 @@ proc_outcome_t rrc::process_pcch_proc::step()
if (RRC_STATE_IDLE == rrc_ptr->state) { if (RRC_STATE_IDLE == rrc_ptr->state) {
Info("S-TMSI match in paging message\n"); Info("S-TMSI match in paging message\n");
log_h->console("S-TMSI match in paging message\n"); log_h->console("S-TMSI match in paging message\n");
rrc_ptr->nas->paging(&s_tmsi_paged); if (not rrc_ptr->nas->paging(&s_tmsi_paged)) {
Error("Unable to start NAS paging proc\n");
return proc_outcome_t::error;
}
state = state_t::nas_paging; state = state_t::nas_paging;
return proc_outcome_t::repeat; return proc_outcome_t::repeat;
} else { } else {
log_h->warning("Received paging while in CONNECT\n"); Warning("Received paging while in CONNECT\n");
} }
} else { } else {
Info("Received paging for unknown identity\n"); Info("Received paging for unknown identity\n");
@ -764,6 +750,7 @@ proc_outcome_t rrc::process_pcch_proc::step()
Error("Failed to initiate a serving cell configuration procedure\n"); Error("Failed to initiate a serving cell configuration procedure\n");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
serv_cfg_fut = rrc_ptr->serv_cell_cfg.get_future();
} else { } else {
Info("Completed successfully\n"); Info("Completed successfully\n");
return proc_outcome_t::success; return proc_outcome_t::success;
@ -777,8 +764,7 @@ proc_outcome_t rrc::process_pcch_proc::step()
if (rrc_ptr->serv_cell_cfg.run()) { if (rrc_ptr->serv_cell_cfg.run()) {
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
srslte::proc_result_t<serving_cell_config_proc> ret = rrc_ptr->serv_cell_cfg.pop(); if (serv_cfg_fut.is_success()) {
if (ret.is_success()) {
Info("All SIBs of serving cell obtained successfully\n"); Info("All SIBs of serving cell obtained successfully\n");
return proc_outcome_t::success; return proc_outcome_t::success;
} else { } else {
@ -789,8 +775,12 @@ proc_outcome_t rrc::process_pcch_proc::step()
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
proc_outcome_t rrc::process_pcch_proc::trigger_event(paging_complete e) proc_outcome_t rrc::process_pcch_proc::react(paging_complete e)
{ {
if (state != state_t::nas_paging) {
Warning("Received an unexpected paging complete\n");
return proc_outcome_t::yield;
}
if (not e.outcome) { if (not e.outcome) {
Info("NAS Paging has failed\n"); Info("NAS Paging has failed\n");
return proc_outcome_t::error; return proc_outcome_t::error;
@ -826,8 +816,7 @@ proc_outcome_t rrc::go_idle_proc::step()
rrc_ptr->leave_connected(); rrc_ptr->leave_connected();
return proc_outcome_t::success; return proc_outcome_t::success;
} else { } else {
rrc_ptr->rrc_log->debug( Debug("Postponing transition to RRC IDLE (%d ms < %d ms)\n", rlc_flush_counter, rlc_flush_timeout);
"Postponing transition to RRC IDLE (%d ms < %d ms)\n", rlc_flush_counter, rlc_flush_timeout);
} }
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
@ -846,6 +835,7 @@ proc_outcome_t rrc::cell_reselection_proc::init()
Error("Failed to initiate a Cell Selection procedure...\n"); Error("Failed to initiate a Cell Selection procedure...\n");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
cell_selection_fut = rrc_ptr->cell_selector.get_future();
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
@ -855,13 +845,12 @@ proc_outcome_t rrc::cell_reselection_proc::step()
if (rrc_ptr->cell_selector.run()) { if (rrc_ptr->cell_selector.run()) {
return srslte::proc_outcome_t::yield; return srslte::proc_outcome_t::yield;
} }
srslte::proc_result_t<cell_selection_proc> ret = rrc_ptr->cell_selector.pop(); if (cell_selection_fut.is_error()) {
if (ret.is_error()) {
Error("Cell Reselection - Error while selecting a cell\n"); Error("Cell Reselection - Error while selecting a cell\n");
return srslte::proc_outcome_t::error; return srslte::proc_outcome_t::error;
} }
switch (ret.proc()->get_cs_result()) { switch (*cell_selection_fut.value()) {
case cs_result_t::changed_cell: case cs_result_t::changed_cell:
// New cell has been selected, start receiving PCCH // New cell has been selected, start receiving PCCH
rrc_ptr->mac->pcch_start_rx(); rrc_ptr->mac->pcch_start_rx();

189
srsue/src/stack/upper/nas.cc
View File

@ -59,21 +59,34 @@ proc_outcome_t nas::plmn_search_proc::init()
proc_outcome_t nas::plmn_search_proc::step() proc_outcome_t nas::plmn_search_proc::step()
{ {
if (state == state_t::rrc_connect) {
if (nas_ptr->rrc_connector.run()) {
return proc_outcome_t::yield;
}
proc_result_t<rrc_connect_proc> ret = nas_ptr->rrc_connector.pop();
if (ret.is_success()) {
return proc_outcome_t::success;
}
nas_ptr->enter_emm_deregistered();
return proc_outcome_t::error;
}
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
proc_outcome_t nas::plmn_search_proc::trigger_event(const plmn_search_complete_t& t) void nas::plmn_search_proc::then(const srslte::proc_result_t<void>& result)
{
ProcInfo("Completed with %s\n", result.is_success() ? "success" : "failure");
// start T3411
nas_ptr->nas_log->debug("Starting T3411\n");
nas_ptr->timers->get(nas_ptr->t3411)->reset();
nas_ptr->timers->get(nas_ptr->t3411)->run();
if (result.is_error()) {
nas_ptr->enter_emm_deregistered();
}
}
proc_outcome_t nas::plmn_search_proc::react(const rrc_connect_proc::rrc_connect_complete_ev& t)
{
if (state != state_t::rrc_connect) {
// not expecting a rrc connection result
ProcWarning("Received unexpected RRC Connection Result event\n");
return proc_outcome_t::yield;
}
return t.is_success() ? proc_outcome_t::success : proc_outcome_t::error;
}
proc_outcome_t nas::plmn_search_proc::react(const plmn_search_complete_t& t)
{ {
if (state != state_t::plmn_search) { if (state != state_t::plmn_search) {
ProcWarning("PLMN Search Complete was received but PLMN Search is not running.\n"); ProcWarning("PLMN Search Complete was received but PLMN Search is not running.\n");
@ -114,12 +127,13 @@ proc_outcome_t nas::plmn_search_proc::trigger_event(const plmn_search_complete_t
nas_ptr->rrc->plmn_select(nas_ptr->current_plmn); nas_ptr->rrc->plmn_select(nas_ptr->current_plmn);
state = state_t::rrc_connect;
if (not nas_ptr->rrc_connector.launch(srslte::establishment_cause_t::mo_data, nullptr)) { if (not nas_ptr->rrc_connector.launch(srslte::establishment_cause_t::mo_data, nullptr)) {
ProcError("Unable to initiate RRC connection.\n"); ProcError("Unable to initiate RRC connection.\n");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
nas_ptr->callbacks.add_proc(nas_ptr->rrc_connector);
state = state_t::rrc_connect;
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
@ -155,50 +169,56 @@ proc_outcome_t nas::rrc_connect_proc::init(srslte::establishment_cause_t cause_,
ProcInfo("Starting...\n"); ProcInfo("Starting...\n");
state = state_t::conn_req; state = state_t::conn_req;
if (not nas_ptr->start_connection_request(cause_, std::move(pdu))) { if (not nas_ptr->rrc->connection_request(cause_, std::move(pdu))) {
ProcError("Failed to initiate a connection request procedure\n");
return proc_outcome_t::error; return proc_outcome_t::error;
} }
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
proc_outcome_t nas::rrc_connect_proc::step() proc_outcome_t nas::rrc_connect_proc::step()
{ {
if (state == state_t::conn_req) { if (state != state_t::wait_attach) {
if (nas_ptr->conn_req_proc.run()) {
return proc_outcome_t::yield; return proc_outcome_t::yield;
} }
proc_result_t<query_proc_t<bool>> ret = nas_ptr->conn_req_proc.pop();
if (ret.is_error()) {
ProcError("Could not establish RRC connection\n");
return proc_outcome_t::error;
}
ProcInfo("Connection established correctly. Waiting for Attach\n");
wait_timeout = 0;
// Wait until attachment. If doing a service request is already attached
state = state_t::wait_attach;
return proc_outcome_t::repeat;
}
if (state == state_t::wait_attach) {
wait_timeout++; wait_timeout++;
// Wait until attachment. If doing a service request is already attached // Wait until attachment. If doing a service request is already attached
if (wait_timeout >= 5000 or nas_ptr->state == EMM_STATE_REGISTERED or not nas_ptr->running or if (wait_timeout < 5000 and nas_ptr->state != EMM_STATE_REGISTERED and nas_ptr->running and
not nas_ptr->rrc->is_connected()) { nas_ptr->rrc->is_connected()) {
return proc_outcome_t::yield;
}
if (nas_ptr->state == EMM_STATE_REGISTERED) { if (nas_ptr->state == EMM_STATE_REGISTERED) {
ProcInfo("EMM Registered correctly\n"); ProcInfo("Success: EMM Registered correctly.\n");
return proc_outcome_t::success; return proc_outcome_t::success;
} else if (nas_ptr->state == EMM_STATE_DEREGISTERED) { } else if (nas_ptr->state == EMM_STATE_DEREGISTERED) {
ProcError("Timeout or received attach reject while trying to attach\n"); ProcError("Timeout or received attach reject while trying to attach\n");
nas_ptr->nas_log->console("Failed to Attach\n"); nas_ptr->nas_log->console("Failed to Attach\n");
} else if (!nas_ptr->rrc->is_connected()){ } else if (!nas_ptr->rrc->is_connected()) {
ProcError("Was disconnected while attaching\n"); ProcError("Was disconnected while attaching\n");
} else { } else {
ProcError("Timed out while trying to attach\n"); ProcError("Timed out while trying to attach\n");
} }
return proc_outcome_t::error; return proc_outcome_t::error;
}
void nas::rrc_connect_proc::then(const srslte::proc_result_t<void>& result)
{
nas_ptr->plmn_searcher.trigger(result);
}
proc_outcome_t nas::rrc_connect_proc::react(nas::rrc_connect_proc::connection_request_completed_t event)
{
if (state == state_t::conn_req and event.outcome) {
ProcInfo("Connection established correctly. Waiting for Attach\n");
wait_timeout = 0;
// Wait until attachment. If doing a service request is already attached
state = state_t::wait_attach;
// wake up proc
return proc_outcome_t::repeat;
} else {
ProcError("Could not establish RRC connection\n");
return proc_outcome_t::error;
} }
}
return proc_outcome_t::yield;
} }
/********************************************************************* /*********************************************************************
@ -318,7 +338,7 @@ void nas::timer_expired(uint32_t timeout_id)
* The function returns true if the UE could attach correctly or false in case of error or timeout during attachment. * The function returns true if the UE could attach correctly or false in case of error or timeout during attachment.
* *
*/ */
void nas::start_attach_request(srslte::proc_state_t* result, srslte::establishment_cause_t cause_) void nas::start_attach_request(srslte::proc_result_t<void>* result, srslte::establishment_cause_t cause_)
{ {
nas_log->info("Attach Request\n"); nas_log->info("Attach Request\n");
switch (state) { switch (state) {
@ -341,29 +361,20 @@ void nas::start_attach_request(srslte::proc_state_t* result, srslte::establishme
nas_log->info("No PLMN selected. Starting PLMN Search...\n"); nas_log->info("No PLMN selected. Starting PLMN Search...\n");
if (not plmn_searcher.launch()) { if (not plmn_searcher.launch()) {
if (result != nullptr) { if (result != nullptr) {
*result = proc_state_t::error; result->set_error();
} }
return; return;
} }
callbacks.defer_proc(plmn_searcher); plmn_searcher.then([this, result](const proc_result_t<void>& res) {
plmn_searcher.then([this, result](bool is_success) { nas_log->info("Attach Request from PLMN Search %s\n", res.is_success() ? "finished successfully" : "failed");
nas_log->info("Attach Request from PLMN Search %s\n", is_success ? "finished successfully" : "failed");
if (result != nullptr) { if (result != nullptr) {
*result = is_success ? proc_state_t::success : proc_state_t::error; *result = res;
}
// start T3411
nas_log->debug("Starting T3411\n");
timers->get(t3411)->reset();
timers->get(t3411)->run();
if (not is_success) {
enter_emm_deregistered();
} }
}); });
} else { } else {
nas_log->error("PLMN selected in state %s\n", emm_state_text[state]); nas_log->error("PLMN selected in state %s\n", emm_state_text[state]);
if (result != nullptr) { if (result != nullptr) {
*result = proc_state_t::error; result->set_error();
} }
} }
break; break;
@ -371,43 +382,42 @@ void nas::start_attach_request(srslte::proc_state_t* result, srslte::establishme
if (rrc->is_connected()) { if (rrc->is_connected()) {
nas_log->info("NAS is already registered and RRC connected\n"); nas_log->info("NAS is already registered and RRC connected\n");
if (result != nullptr) { if (result != nullptr) {
*result = proc_state_t::success; result->set_val();
} }
} else { } else {
nas_log->info("NAS is already registered but RRC disconnected. Connecting now...\n"); nas_log->info("NAS is already registered but RRC disconnected. Connecting now...\n");
if (not rrc_connector.launch(cause_, nullptr)) { if (not rrc_connector.launch(cause_, nullptr)) {
nas_log->error("Cannot initiate concurrent rrc connection procedures\n"); nas_log->error("Cannot initiate concurrent rrc connection procedures\n");
if (result != nullptr) { if (result != nullptr) {
*result = proc_state_t::error; result->set_error();
} }
return; return;
} }
callbacks.defer_proc(rrc_connector); rrc_connector.then([this, result](const proc_result_t<void>& res) {
rrc_connector.then([this, result](bool is_success) { if (res.is_success()) {
if (is_success) {
nas_log->info("NAS attached successfully\n"); nas_log->info("NAS attached successfully\n");
} else { } else {
nas_log->error("Could not attach from attach_request\n"); nas_log->error("Could not attach from attach_request\n");
} }
if (result != nullptr) { if (result != nullptr) {
*result = is_success ? proc_state_t::success : proc_state_t::error; *result = res;
} }
return proc_outcome_t::success;
}); });
callbacks.add_proc(rrc_connector);
} }
break; break;
default: default:
nas_log->info("Attach request ignored. State = %s\n", emm_state_text[state]); nas_log->info("Attach request ignored. State = %s\n", emm_state_text[state]);
if (result != nullptr) { if (result != nullptr) {
*result = proc_state_t::error; result->set_error();
} }
} }
} }
void nas::plmn_search_completed(rrc_interface_nas::found_plmn_t found_plmns[rrc_interface_nas::MAX_FOUND_PLMNS], void nas::plmn_search_completed(const rrc_interface_nas::found_plmn_t found_plmns[rrc_interface_nas::MAX_FOUND_PLMNS],
int nof_plmns) int nof_plmns)
{ {
plmn_searcher.trigger_event(plmn_search_proc::plmn_search_complete_t(found_plmns, nof_plmns)); plmn_searcher.trigger(plmn_search_proc::plmn_search_complete_t(found_plmns, nof_plmns));
} }
bool nas::detach_request(const bool switch_off) bool nas::detach_request(const bool switch_off)
@ -447,58 +457,41 @@ bool nas::is_attached()
return state == EMM_STATE_REGISTERED; return state == EMM_STATE_REGISTERED;
} }
void nas::paging(s_tmsi_t* ue_identity) bool nas::paging(s_tmsi_t* ue_identity)
{ {
if (state == EMM_STATE_REGISTERED) { if (state == EMM_STATE_REGISTERED) {
nas_log->info("Received paging: requesting RRC connection establishment\n"); nas_log->info("Received paging: requesting RRC connection establishment\n");
if (rrc_connector.is_active()) {
nas_log->error("Cannot initiate concurrent RRC connection establishment procedures\n");
return;
}
if (not rrc_connector.launch(srslte::establishment_cause_t::mt_access, nullptr)) { if (not rrc_connector.launch(srslte::establishment_cause_t::mt_access, nullptr)) {
nas_log->error("Could not launch RRC Connect()\n"); nas_log->error("Could not launch RRC Connect()\n");
return;
}
// once completed, call paging complete
callbacks.defer_task([this]() {
if (rrc_connector.run()) {
return proc_outcome_t::yield;
}
bool success = rrc_connector.pop().is_success();
rrc->paging_completed(success);
return proc_outcome_t::success;
});
} else {
nas_log->warning("Received paging while in state %s\n", emm_state_text[state]);
}
}
void nas::set_barring(barring_t barring) {
current_barring = barring;
}
bool nas::start_connection_request(srslte::establishment_cause_t establish_cause,
srslte::unique_byte_buffer_t ded_info_nas)
{
if (not conn_req_proc.launch()) {
nas_log->error("Failed to initiate a connection request procedure\n");
return false; return false;
} }
if (not rrc->connection_request(establish_cause, std::move(ded_info_nas))) { // once completed, call paging complete
nas_log->error("Failed to initiate a connection request procedure\n"); rrc_connector.then([this](proc_result_t<void> outcome) {
conn_req_proc.pop(); rrc->paging_completed(outcome.is_success());
return proc_outcome_t::success;
});
callbacks.add_proc(rrc_connector);
} else {
nas_log->warning("Received paging while in state %s\n", emm_state_text[state]);
return false; return false;
} }
return true; return true;
} }
bool nas::connection_request_completed(bool outcome) void nas::set_barring(barring_t barring)
{ {
conn_req_proc.trigger_event(outcome); current_barring = barring;
return conn_req_proc.is_active();
} }
void nas::select_plmn() { // Signal from RRC that connection request proc completed
bool nas::connection_request_completed(bool outcome)
{
rrc_connector.trigger(rrc_connect_proc::connection_request_completed_t{outcome});
return true;
}
void nas::select_plmn()
{
plmn_is_selected = false; plmn_is_selected = false;
@ -1786,7 +1779,7 @@ void nas::send_detach_request(bool switch_off)
if (not rrc_connector.launch(establishment_cause_t::mo_sig, std::move(pdu))) { if (not rrc_connector.launch(establishment_cause_t::mo_sig, std::move(pdu))) {
nas_log->error("Failed to initiate RRC Connection Request\n"); nas_log->error("Failed to initiate RRC Connection Request\n");
} }
callbacks.defer_proc(rrc_connector); callbacks.add_proc(rrc_connector);
} }
} }

10
srsue/test/upper/nas_test.cc
View File

@ -119,10 +119,11 @@ public:
printf("NAS generated SDU (len=%d):\n", sdu->N_bytes); printf("NAS generated SDU (len=%d):\n", sdu->N_bytes);
last_sdu_len = sdu->N_bytes; last_sdu_len = sdu->N_bytes;
srslte_vec_fprint_byte(stdout, sdu->msg, sdu->N_bytes); srslte_vec_fprint_byte(stdout, sdu->msg, sdu->N_bytes);
is_connected_flag = true;
nas_ptr->connection_request_completed(true); nas_ptr->connection_request_completed(true);
return true; return true;
} }
bool is_connected() {return false;} bool is_connected() { return is_connected_flag; }
uint16_t get_mcc() { return mcc; } uint16_t get_mcc() { return mcc; }
uint16_t get_mnc() { return mnc; } uint16_t get_mnc() { return mnc; }
@ -134,6 +135,7 @@ private:
nas* nas_ptr; nas* nas_ptr;
uint32_t last_sdu_len; uint32_t last_sdu_len;
found_plmn_t plmns; found_plmn_t plmns;
bool is_connected_flag = false;
}; };
class stack_dummy : public stack_interface_gw, public thread class stack_dummy : public stack_interface_gw, public thread
@ -143,12 +145,12 @@ public:
void init() { start(-1); } void init() { start(-1); }
bool switch_on() final bool switch_on() final
{ {
proc_state_t proc_result = proc_state_t::on_going; proc_result_t<void> proc_result;
nas->start_attach_request(&proc_result, srslte::establishment_cause_t::mo_data); nas->start_attach_request(&proc_result, srslte::establishment_cause_t::mo_data);
while (proc_result == proc_state_t::on_going) { while (not proc_result.is_complete()) {
usleep(1000); usleep(1000);
} }
return proc_result == proc_state_t::success; return proc_result.is_success();
} }
void write_sdu(uint32_t lcid, srslte::unique_byte_buffer_t sdu, bool blocking) void write_sdu(uint32_t lcid, srslte::unique_byte_buffer_t sdu, bool blocking)
{ {