Line data    Source code

       1             : /*
       2             :  * vr_offloads_dp.h -- Wrappers for calling offload function with locking in
       3             :  * place.
       4             :  *
       5             :  * Copyright (c) 2018 Netronome Systems, Inc. All rights reserved.
       6             :  */
       7             : 
       8             : #ifndef __VR_OFFLOADS_DP_H__
       9             : #define __VR_OFFLOADS_DP_H__
      10             : #include <vr_offloads.h>
      11             : 
      12             : /* RCU wrappers. */
      13             : #ifdef __linux__
      14             : #ifdef __KERNEL__
      15             : #include <linux/rcupdate.h>
      16             : #else
      17             : #include <urcu-bp.h>
      18             : #endif /* __KERNEL__ */
      19             : 
      20             : #define vr_rcu_dereference(p) rcu_dereference(p)
      21             : #define vr_rcu_read_lock() rcu_read_lock()
      22             : #define vr_rcu_read_unlock() rcu_read_unlock()
      23             : #define vr_synchronize_rcu() synchronize_rcu()
      24             : #define vr_rcu_assign_pointer(x, y) rcu_assign_pointer(x, y)
      25             : #else
      26             : #define vr_rcu_dereference(p) NULL
      27             : #define vr_rcu_read_lock()
      28             : #define vr_rcu_read_unlock()
      29             : #define vr_synchronize_rcu()
      30             : #define vr_rcu_assign_pointer(x, y) (x = y)
      31             : #endif /* __linux__ */
      32             : 
      33             : 
      34           0 : static inline int vr_offload_soft_reset(void)
      35             : {
      36             :     struct vr_offload_ops *offload;
      37           0 :     int ret = 0;
      38             : 
      39           0 :     vr_rcu_read_lock();
      40           0 :     offload = vr_rcu_dereference(offload_ops);
      41           0 :     if (offload && offload->voo_soft_reset)
      42           0 :         ret = offload->voo_soft_reset();
      43           0 :     vr_rcu_read_unlock();
      44             : 
      45           0 :     return ret;
      46             : }
      47             : 
      48         146 : static inline int vr_offload_packet_parse(struct vr_packet *pkt)
      49             : {
      50             :     struct vr_offload_ops *offload;
      51         146 :     int ret = 0;
      52             : 
      53         146 :     vr_rcu_read_lock();
      54         146 :     offload = vr_rcu_dereference(offload_ops);
      55         146 :     if (offload && offload->voo_packet_parse)
      56           0 :         ret = offload->voo_packet_parse(pkt);
      57         146 :     vr_rcu_read_unlock();
      58             : 
      59         146 :     return ret;
      60             : }
      61             : 
      62             : /* Flow offload functions */
      63         222 : static inline int vr_offload_flow_set(struct vr_flow_entry * fe,
      64             :                                        unsigned int fe_index,
      65             :                                        struct vr_flow_entry * rfe)
      66             : {
      67             :     struct vr_offload_ops *offload;
      68         222 :     int ret = 0;
      69             : 
      70         222 :     vr_rcu_read_lock();
      71         222 :     offload = vr_rcu_dereference(offload_ops);
      72         222 :     if (offload && offload->voo_flow_set)
      73           0 :         ret = offload->voo_flow_set(fe, fe_index, rfe);
      74         222 :     vr_rcu_read_unlock();
      75             : 
      76         222 :     return ret;
      77             : }
      78             : 
      79         117 : static inline int vr_offload_flow_del(struct vr_flow_entry * fe)
      80             : {
      81             :     struct vr_offload_ops *offload;
      82         117 :     int ret = 0;
      83             : 
      84         117 :     vr_rcu_read_lock();
      85         117 :     offload = vr_rcu_dereference(offload_ops);
      86         117 :     if (offload && offload->voo_flow_del)
      87           0 :         ret = offload->voo_flow_del(fe);
      88         117 :     vr_rcu_read_unlock();
      89             : 
      90         117 :     return ret;
      91             : }
      92             : 
      93          15 : static inline int vr_offload_flow_stats_update(struct vr_flow_entry * fe)
      94             : {
      95             :     struct vr_offload_ops *offload;
      96          15 :     int ret = 0;
      97             : 
      98          15 :     vr_rcu_read_lock();
      99          15 :     offload = vr_rcu_dereference(offload_ops);
     100          15 :     if (offload && offload->voo_flow_stats_update)
     101           0 :         ret = offload->voo_flow_stats_update(fe);
     102          15 :     vr_rcu_read_unlock();
     103             : 
     104          15 :     return ret;
     105             : }
     106             : 
     107             : /*
     108             :  * Used both to set and reset meta data entry for a flow.
     109             :  */
     110           0 : static inline int vr_offload_flow_meta_data_set(unsigned int fe_index,
     111             :                                                  unsigned int meta_data_len,
     112             :                                                  void *meta_data,
     113             :                                                  unsigned short mir_vrf)
     114             : {
     115             :     struct vr_offload_ops *offload;
     116           0 :     int ret = 0;
     117             : 
     118           0 :     vr_rcu_read_lock();
     119           0 :     offload = vr_rcu_dereference(offload_ops);
     120           0 :     if (offload && offload->voo_flow_meta_data_set)
     121           0 :         ret = offload->voo_flow_meta_data_set(fe_index, meta_data_len,
     122             :                                                    meta_data, mir_vrf);
     123           0 :     vr_rcu_read_unlock();
     124             : 
     125           0 :     return ret;
     126             : }
     127             : 
     128             : /* Dropstats */
     129          11 : static inline int vr_offload_drop_stats_get(vr_drop_stats_req *resp)
     130             : {
     131             :     struct vr_offload_ops *offload;
     132          11 :     int ret = 0;
     133             : 
     134          11 :     vr_rcu_read_lock();
     135          11 :     offload = vr_rcu_dereference(offload_ops);
     136          11 :     if (offload && offload->voo_drop_stats_get)
     137           0 :         ret = offload->voo_drop_stats_get(resp);
     138          11 :     vr_rcu_read_unlock();
     139             : 
     140          11 :     return ret;
     141             : }
     142             : 
     143             : /* interface offload functions */
     144         349 : static inline int vr_offload_interface_add(struct vr_interface * intf)
     145             : {
     146             :     struct vr_offload_ops *offload;
     147         349 :     int ret = 0;
     148             : 
     149         349 :     vr_rcu_read_lock();
     150         349 :     offload = vr_rcu_dereference(offload_ops);
     151         349 :     if (offload && offload->voo_interface_add)
     152           0 :         ret = offload->voo_interface_add(intf);
     153         349 :     vr_rcu_read_unlock();
     154             : 
     155         349 :     return ret;
     156             : }
     157             : 
     158           0 : static inline int vr_offload_interface_get(vr_interface_req *resp)
     159             : {
     160             :     struct vr_offload_ops *offload;
     161           0 :     int ret = 0;
     162             : 
     163           0 :     vr_rcu_read_lock();
     164           0 :     offload = vr_rcu_dereference(offload_ops);
     165           0 :     if (offload && offload->voo_interface_get)
     166           0 :         ret = offload->voo_interface_get(resp);
     167           0 :     vr_rcu_read_unlock();
     168             : 
     169           0 :     return ret;
     170             : }
     171             : 
     172         329 : static inline int vr_offload_interface_del(struct vr_interface * intf)
     173             : {
     174             :     struct vr_offload_ops *offload;
     175         329 :     int ret = 0;
     176             : 
     177         329 :     vr_rcu_read_lock();
     178         329 :     offload = vr_rcu_dereference(offload_ops);
     179         329 :     if (offload && offload->voo_interface_del)
     180           0 :         ret = offload->voo_interface_del(intf);
     181         329 :     vr_rcu_read_unlock();
     182             : 
     183         329 :     return ret;
     184             : }
     185             : 
     186           0 : static inline int vr_offload_vif_vrf_set(vr_vrf_assign_req *req)
     187             : {
     188             :     struct vr_offload_ops *offload;
     189           0 :     int ret = 0;
     190             : 
     191           0 :     vr_rcu_read_lock();
     192           0 :     offload = vr_rcu_dereference(offload_ops);
     193           0 :     if (offload && offload->voo_vif_vrf_set)
     194           0 :        ret = offload->voo_vif_vrf_set(req);
     195           0 :     vr_rcu_read_unlock();
     196             : 
     197           0 :     return ret;
     198             : }
     199             : 
     200             : static inline int vr_offload_vif_vrf_get(vr_vrf_assign_req *resp)
     201             : {
     202             :     struct vr_offload_ops *offload;
     203             :     int ret = 0;
     204             : 
     205             :     vr_rcu_read_lock();
     206             :     offload = vr_rcu_dereference(offload_ops);
     207             :     if (offload && offload->voo_vif_vrf_get)
     208             :         ret = offload->voo_vif_vrf_get(resp);
     209             :     vr_rcu_read_unlock();
     210             : 
     211             :     return ret;
     212             : }
     213             : 
     214         276 : static inline int vr_offload_nexthop_add(struct vr_nexthop * nh)
     215             : {
     216             :     struct vr_offload_ops *offload;
     217         276 :     int ret = 0;
     218             : 
     219         276 :     vr_rcu_read_lock();
     220         276 :     offload = vr_rcu_dereference(offload_ops);
     221         276 :     if (offload && offload->voo_nexthop_add)
     222           0 :         ret = offload->voo_nexthop_add(nh);
     223         276 :     vr_rcu_read_unlock();
     224             : 
     225         276 :     return ret;
     226             : }
     227             : 
     228         263 : static inline int vr_offload_nexthop_del(struct vr_nexthop * nh)
     229             : {
     230             :     struct vr_offload_ops *offload;
     231         263 :     int ret = 0;
     232             : 
     233         263 :     vr_rcu_read_lock();
     234         263 :     offload = vr_rcu_dereference(offload_ops);
     235         263 :     if (offload && offload->voo_nexthop_del)
     236           0 :         ret = offload->voo_nexthop_del(nh);
     237         263 :     vr_rcu_read_unlock();
     238             : 
     239         263 :     return ret;
     240             : }
     241             : 
     242          25 : static inline int vr_offload_nexthop_get(struct vr_nexthop * nh,
     243             :                                           vr_nexthop_req * resp)
     244             : {
     245             :     struct vr_offload_ops *offload;
     246          25 :     int ret = 0;
     247             : 
     248          25 :     vr_rcu_read_lock();
     249          25 :     offload = vr_rcu_dereference(offload_ops);
     250          25 :     if (offload && offload->voo_nexthop_get)
     251           0 :         ret = offload->voo_nexthop_get(nh, resp);
     252          25 :     vr_rcu_read_unlock();
     253             : 
     254          25 :     return ret;
     255             : }
     256             : 
     257           9 : static inline int vr_offload_mpls_add(struct vr_nexthop * nh, int label)
     258             : {
     259             :     struct vr_offload_ops *offload;
     260           9 :     int ret = 0;
     261             : 
     262           9 :     vr_rcu_read_lock();
     263           9 :     offload = vr_rcu_dereference(offload_ops);
     264           9 :     if (offload && offload->voo_mpls_add)
     265           0 :         ret = offload->voo_mpls_add(nh, label);
     266           9 :     vr_rcu_read_unlock();
     267             : 
     268           9 :     return ret;
     269             : }
     270             : 
     271           1 : static inline int vr_offload_mpls_get(vr_mpls_req * resp)
     272             : {
     273             :     struct vr_offload_ops *offload;
     274           1 :     int ret = 0;
     275             : 
     276           1 :     vr_rcu_read_lock();
     277           1 :     offload = vr_rcu_dereference(offload_ops);
     278           1 :     if (offload && offload->voo_mpls_get)
     279           0 :         ret = offload->voo_mpls_get(resp);
     280           1 :     vr_rcu_read_unlock();
     281             : 
     282           1 :     return ret;
     283             : }
     284             : 
     285           9 : static inline int vr_offload_mpls_del(int label)
     286             : {
     287             :     struct vr_offload_ops *offload;
     288           9 :     int ret = 0;
     289             : 
     290           9 :     vr_rcu_read_lock();
     291           9 :     offload = vr_rcu_dereference(offload_ops);
     292           9 :     if (offload && offload->voo_mpls_del)
     293           0 :         ret = offload->voo_mpls_del(label);
     294           9 :     vr_rcu_read_unlock();
     295             : 
     296           9 :     return ret;
     297             : }
     298             : 
     299           2 : static inline int vr_offload_vxlan_add(struct vr_nexthop * nh, int vnid)
     300             : {
     301             :     struct vr_offload_ops *offload;
     302           2 :     int ret = 0;
     303             : 
     304           2 :     vr_rcu_read_lock();
     305           2 :     offload = vr_rcu_dereference(offload_ops);
     306           2 :     if (offload && offload->voo_vxlan_add)
     307           0 :         ret = offload->voo_vxlan_add(nh, vnid);
     308           2 :     vr_rcu_read_unlock();
     309             : 
     310           2 :     return ret;
     311             : }
     312             : 
     313           1 : static inline int vr_offload_vxlan_get(vr_vxlan_req * resp)
     314             : {
     315             :     struct vr_offload_ops *offload;
     316           1 :     int ret = 0;
     317             : 
     318           1 :     vr_rcu_read_lock();
     319           1 :     offload = vr_rcu_dereference(offload_ops);
     320           1 :     if (offload && offload->voo_vxlan_get)
     321           0 :         ret = offload->voo_vxlan_get(resp);
     322           1 :     vr_rcu_read_unlock();
     323             : 
     324           1 :     return ret;
     325             : }
     326             : 
     327           2 : static inline int vr_offload_vxlan_del(int vnid)
     328             : {
     329             :     struct vr_offload_ops *offload;
     330           2 :     int ret = 0;
     331             : 
     332           2 :     vr_rcu_read_lock();
     333           2 :     offload = vr_rcu_dereference(offload_ops);
     334           2 :     if (offload && offload->voo_vxlan_del)
     335           0 :         ret = offload->voo_vxlan_del(vnid);
     336           2 :     vr_rcu_read_unlock();
     337             : 
     338           2 :     return ret;
     339             : }
     340             : 
     341           3 : static inline int vr_offload_mirror_add(struct vr_mirror_entry * mirror,
     342             :                                         unsigned int index)
     343             : {
     344             :     struct vr_offload_ops *offload;
     345           3 :     int ret = 0;
     346             : 
     347           3 :     vr_rcu_read_lock();
     348           3 :     offload = vr_rcu_dereference(offload_ops);
     349           3 :     if (offload && offload->voo_mirror_add)
     350           0 :         ret = offload->voo_mirror_add(mirror, index);
     351           3 :     vr_rcu_read_unlock();
     352             : 
     353           3 :     return ret;
     354             : }
     355             : 
     356           3 : static inline int vr_offload_mirror_del(unsigned int index)
     357             : {
     358             :     struct vr_offload_ops *offload;
     359           3 :     int ret = 0;
     360             : 
     361           3 :     vr_rcu_read_lock();
     362           3 :     offload = vr_rcu_dereference(offload_ops);
     363           3 :     if (offload && offload->voo_mirror_del)
     364           0 :         ret = offload->voo_mirror_del(index);
     365           3 :     vr_rcu_read_unlock();
     366             : 
     367           3 :     return ret;
     368             : }
     369             : 
     370           1 : static inline int vr_offload_mirror_get(vr_mirror_req * resp)
     371             : {
     372             :     struct vr_offload_ops *offload;
     373           1 :     int ret = 0;
     374             : 
     375           1 :     vr_rcu_read_lock();
     376           1 :     offload = vr_rcu_dereference(offload_ops);
     377           1 :     if (offload && offload->voo_mirror_get)
     378           0 :         ret = offload->voo_mirror_get(resp);
     379           1 :     vr_rcu_read_unlock();
     380             : 
     381           1 :     return ret;
     382             : }
     383             : 
     384          14 : static inline int vr_offload_vrf_table_entry_add(struct vr_vrf_table_entry * vrf_entry,
     385             :                                         unsigned int index)
     386             : {
     387             :     struct vr_offload_ops *offload;
     388          14 :     int ret = 0;
     389             : 
     390          14 :     vr_rcu_read_lock();
     391          14 :     offload = vr_rcu_dereference(offload_ops);
     392          14 :     if (offload && offload->voo_vrf_table_entry_add)
     393           0 :         ret = offload->voo_vrf_table_entry_add(vrf_entry, index);
     394          14 :     vr_rcu_read_unlock();
     395             : 
     396          14 :     return ret;
     397             : }
     398             : 
     399          11 : static inline int vr_offload_vrf_table_entry_del(unsigned int index)
     400             : {
     401             :     struct vr_offload_ops *offload;
     402          11 :     int ret = 0;
     403             : 
     404          11 :     vr_rcu_read_lock();
     405          11 :     offload = vr_rcu_dereference(offload_ops);
     406          11 :     if (offload && offload->voo_vrf_table_entry_del)
     407           0 :         ret = offload->voo_vrf_table_entry_del(index);
     408          11 :     vr_rcu_read_unlock();
     409             : 
     410          11 :     return ret;
     411             : }
     412             : 
     413           0 : static inline int vr_offload_vrf_table_entry_get(vr_vrf_req * resp)
     414             : {
     415             :     struct vr_offload_ops *offload;
     416           0 :     int ret = 0;
     417             : 
     418           0 :     vr_rcu_read_lock();
     419           0 :     offload = vr_rcu_dereference(offload_ops);
     420           0 :     if (offload && offload->voo_vrf_table_entry_get)
     421           0 :         ret = offload->voo_vrf_table_entry_get(resp);
     422           0 :     vr_rcu_read_unlock();
     423             : 
     424           0 :     return ret;
     425             : }
     426             : 
     427         109 : static inline int vr_offload_route_del(vr_route_req * req)
     428             : {
     429             :     struct vr_offload_ops *offload;
     430         109 :     int ret = 0;
     431             : 
     432         109 :     vr_rcu_read_lock();
     433         109 :     offload = vr_rcu_dereference(offload_ops);
     434         109 :     if (offload && offload->voo_route_del)
     435           0 :         ret = offload->voo_route_del(req);
     436         109 :     vr_rcu_read_unlock();
     437             : 
     438         109 :     return ret;
     439             : }
     440             : 
     441         218 : static inline int vr_offload_route_add(vr_route_req * req)
     442             : {
     443             :     struct vr_offload_ops *offload;
     444         218 :     int ret = 0;
     445             : 
     446         218 :     vr_rcu_read_lock();
     447         218 :     offload = vr_rcu_dereference(offload_ops);
     448         218 :     if (offload && offload->voo_route_add)
     449           0 :         ret = offload->voo_route_add(req);
     450         218 :     vr_rcu_read_unlock();
     451             : 
     452         218 :     return ret;
     453             : }
     454             : 
     455         331 : static inline int vr_offload_route_get(vr_route_req * req)
     456             : {
     457             :     struct vr_offload_ops *offload;
     458         331 :     int ret = 0;
     459             : 
     460         331 :     vr_rcu_read_lock();
     461         331 :     offload = vr_rcu_dereference(offload_ops);
     462         331 :     if (offload && offload->voo_route_get)
     463           0 :         ret = offload->voo_route_get(req);
     464         331 :     vr_rcu_read_unlock();
     465             : 
     466         331 :     return ret;
     467             : }
     468             : 
     469           0 : static inline int vr_offload_route_dump(struct vr_route_req * req)
     470             : {
     471             :     struct vr_offload_ops *offload;
     472           0 :     int ret = 0;
     473             : 
     474           0 :     vr_rcu_read_lock();
     475           0 :     offload = vr_rcu_dereference(offload_ops);
     476           0 :     if (offload && offload->voo_route_dump)
     477           0 :         ret = offload->voo_route_dump(req);
     478           0 :     vr_rcu_read_unlock();
     479             : 
     480           0 :     return ret;
     481             : }
     482             : 
     483           0 : static inline int vr_offload_fc_map_add(vr_fc_map_req * req)
     484             : {
     485             :     struct vr_offload_ops *offload;
     486           0 :     int ret = 0;
     487             : 
     488           0 :     vr_rcu_read_lock();
     489           0 :     offload = vr_rcu_dereference(offload_ops);
     490           0 :     if (offload && offload->voo_fc_map_add)
     491           0 :         ret = offload->voo_fc_map_add(req);
     492           0 :     vr_rcu_read_unlock();
     493             : 
     494           0 :     return ret;
     495             : }
     496             : 
     497           0 : static inline int vr_offload_fc_map_del(vr_fc_map_req * req)
     498             : {
     499             :     struct vr_offload_ops *offload;
     500           0 :     int ret = 0;
     501             : 
     502           0 :     vr_rcu_read_lock();
     503           0 :     offload = vr_rcu_dereference(offload_ops);
     504           0 :     if (offload && offload->voo_fc_map_del)
     505           0 :         ret = offload->voo_fc_map_del(req);
     506           0 :     vr_rcu_read_unlock();
     507             : 
     508           0 :     return ret;
     509             : }
     510             : 
     511           0 : static inline int vr_offload_fc_map_get(vr_fc_map_req * req)
     512             : {
     513             :     struct vr_offload_ops *offload;
     514           0 :     int ret = 0;
     515             : 
     516           0 :     vr_rcu_read_lock();
     517           0 :     offload = vr_rcu_dereference(offload_ops);
     518           0 :     if (offload && offload->voo_fc_map_get)
     519           0 :         ret = offload->voo_fc_map_get(req);
     520           0 :     vr_rcu_read_unlock();
     521             : 
     522           0 :     return ret;
     523             : }
     524             : 
     525           0 : static inline int vr_offload_qos_map_add(vr_qos_map_req * req)
     526             : {
     527             :     struct vr_offload_ops *offload;
     528           0 :     int ret = 0;
     529             : 
     530           0 :     vr_rcu_read_lock();
     531           0 :     offload = vr_rcu_dereference(offload_ops);
     532           0 :     if (offload && offload->voo_qos_map_add)
     533           0 :         ret = offload->voo_qos_map_add(req);
     534           0 :     vr_rcu_read_unlock();
     535             : 
     536           0 :     return ret;
     537             : }
     538             : 
     539           0 : static inline int vr_offload_qos_map_del(vr_qos_map_req * req)
     540             : {
     541             :     struct vr_offload_ops *offload;
     542           0 :     int ret = 0;
     543             : 
     544           0 :     vr_rcu_read_lock();
     545           0 :     offload = vr_rcu_dereference(offload_ops);
     546           0 :     if (offload && offload->voo_qos_map_del)
     547           0 :         ret = offload->voo_qos_map_del(req);
     548           0 :     vr_rcu_read_unlock();
     549             : 
     550           0 :     return ret;
     551             : }
     552             : 
     553           0 : static inline int vr_offload_qos_map_get(vr_qos_map_req * req)
     554             : {
     555             :     struct vr_offload_ops *offload;
     556           0 :     int ret = 0;
     557             : 
     558           0 :     vr_rcu_read_lock();
     559           0 :     offload = vr_rcu_dereference(offload_ops);
     560           0 :     if (offload && offload->voo_qos_map_get)
     561           0 :         ret = offload->voo_qos_map_get(req);
     562           0 :     vr_rcu_read_unlock();
     563             : 
     564           0 :     return ret;
     565             : }
     566             : #endif /* __VR_OFFLOADS_DP_H__ */