batman-adv/files/compat-hacks.h

   1 /* Please avoid adding hacks here - instead add it to mac80211/backports.git */
   2
   3 #undef CONFIG_MODULE_STRIPPED
   4
   5 #include <linux/version.h>      /* LINUX_VERSION_CODE */
   6 #include <linux/types.h>
   7
   8 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 1, 0)
   9
  10 #define dev_get_iflink(_net_dev) ((_net_dev)->iflink)
  11
  12 #endif /* < KERNEL_VERSION(4, 1, 0) */
  13
  14 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 16, 0)
  15
  16 /* Linux 3.15 misses the uapi include.... */
  17 #include <uapi/linux/nl80211.h>
  18
  19 #endif /* < KERNEL_VERSION(3, 16, 0) */
  20
  21 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 9, 0)
  22
  23 #include <linux/netdevice.h>
  24
  25 #define netdev_master_upper_dev_link(dev, upper_dev, upper_priv, upper_info, extack) ({\
  26         BUILD_BUG_ON(upper_priv != NULL); \
  27         BUILD_BUG_ON(upper_info != NULL); \
  28         BUILD_BUG_ON(extack != NULL); \
  29         netdev_set_master(dev, upper_dev); \
  30 })
  31
  32 #elif LINUX_VERSION_CODE < KERNEL_VERSION(4, 5, 0)
  33
  34 #include <linux/netdevice.h>
  35
  36 #define netdev_master_upper_dev_link(dev, upper_dev, upper_priv, upper_info, extack) ({\
  37         BUILD_BUG_ON(upper_priv != NULL); \
  38         BUILD_BUG_ON(upper_info != NULL); \
  39         BUILD_BUG_ON(extack != NULL); \
  40         netdev_master_upper_dev_link(dev, upper_dev); \
  41 })
  42
  43 #elif LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)
  44
  45 #include <linux/netdevice.h>
  46
  47 #define netdev_master_upper_dev_link(dev, upper_dev, upper_priv, upper_info, extack) ({\
  48         BUILD_BUG_ON(extack != NULL); \
  49         netdev_master_upper_dev_link(dev, upper_dev, upper_priv, upper_info); \
  50 })
  51
  52 #endif /* < KERNEL_VERSION(4, 5, 0) */
  53
  54
  55 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0)
  56
  57 /* for batadv_v_elp_get_throughput which would have used
  58  * STATION_INFO_EXPECTED_THROUGHPUT in Linux 4.0.0
  59  */
  60 #define NL80211_STA_INFO_EXPECTED_THROUGHPUT    28
  61
  62 /* wild hack for batadv_getlink_net only */
  63 #define get_link_net get_xstats_size || 1 ? fallback_net : (struct net*)netdev->rtnl_link_ops->get_xstats_size
  64
  65 #endif /* < KERNEL_VERSION(4, 0, 0) */
  66
  67
  68 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 2, 0)
  69
  70 struct sk_buff *skb_checksum_trimmed(struct sk_buff *skb,
  71                                      unsigned int transport_len,
  72                                      __sum16(*skb_chkf)(struct sk_buff *skb));
  73
  74 int ip_mc_check_igmp(struct sk_buff *skb, struct sk_buff **skb_trimmed);
  75
  76 int ipv6_mc_check_mld(struct sk_buff *skb, struct sk_buff **skb_trimmed);
  77
  78 #endif /* < KERNEL_VERSION(4, 2, 0) */
  79
  80 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 3, 0)
  81
  82 #define IFF_NO_QUEUE    0; dev->tx_queue_len = 0
  83
  84 static inline bool hlist_fake(struct hlist_node *h)
  85 {
  86         return h->pprev == &h->next;
  87 }
  88
  89 #endif /* < KERNEL_VERSION(4, 3, 0) */
  90
  91 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 6, 0)
  92
  93 #include <linux/ethtool.h>
  94
  95 #define ethtool_link_ksettings batadv_ethtool_link_ksettings
  96
  97 struct batadv_ethtool_link_ksettings {
  98         struct {
  99                 __u32   speed;
 100                 __u8    duplex;
 101         } base;
 102 };
 103
 104 #define __ethtool_get_link_ksettings(__dev, __link_settings) \
 105         batadv_ethtool_get_link_ksettings(__dev, __link_settings)
 106
 107 static inline int
 108 batadv_ethtool_get_link_ksettings(struct net_device *dev,
 109                                   struct ethtool_link_ksettings *link_ksettings)
 110 {
 111         struct ethtool_cmd cmd;
 112         int ret;
 113
 114         memset(&cmd, 0, sizeof(cmd));
 115         ret = __ethtool_get_settings(dev, &cmd);
 116
 117         if (ret != 0)
 118                 return ret;
 119
 120         link_ksettings->base.duplex = cmd.duplex;
 121         link_ksettings->base.speed = ethtool_cmd_speed(&cmd);
 122
 123         return 0;
 124 }
 125
 126 #endif /* < KERNEL_VERSION(4, 6, 0) */
 127
 128 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 7, 0)
 129
 130 #ifdef netif_trans_update
 131 #undef netif_trans_update
 132 #endif
 133
 134 #define netif_trans_update batadv_netif_trans_update
 135 static inline void batadv_netif_trans_update(struct net_device *dev)
 136 {
 137         dev->trans_start = jiffies;
 138 }
 139
 140 #endif /* < KERNEL_VERSION(4, 7, 0) */
 141
 142
 143 #include_next <linux/netlink.h>
 144
 145 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 7, 0)
 146
 147 #include_next <net/netlink.h>
 148
 149 static inline bool batadv_nla_need_padding_for_64bit(struct sk_buff *skb);
 150
 151 static inline int batadv_nla_align_64bit(struct sk_buff *skb, int padattr)
 152 {
 153         if (batadv_nla_need_padding_for_64bit(skb) &&
 154             !nla_reserve(skb, padattr, 0))
 155                 return -EMSGSIZE;
 156
 157         return 0;
 158 }
 159
 160 static inline struct nlattr *batadv__nla_reserve_64bit(struct sk_buff *skb,
 161                                                        int attrtype,
 162                                                        int attrlen, int padattr)
 163 {
 164         if (batadv_nla_need_padding_for_64bit(skb))
 165                 batadv_nla_align_64bit(skb, padattr);
 166
 167         return __nla_reserve(skb, attrtype, attrlen);
 168 }
 169
 170 static inline void batadv__nla_put_64bit(struct sk_buff *skb, int attrtype,
 171                                          int attrlen, const void *data,
 172                                          int padattr)
 173 {
 174         struct nlattr *nla;
 175
 176         nla = batadv__nla_reserve_64bit(skb, attrtype, attrlen, padattr);
 177         memcpy(nla_data(nla), data, attrlen);
 178 }
 179
 180 static inline bool batadv_nla_need_padding_for_64bit(struct sk_buff *skb)
 181 {
 182 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 183         /* The nlattr header is 4 bytes in size, that's why we test
 184          * if the skb->data _is_ aligned.  A NOP attribute, plus
 185          * nlattr header for next attribute, will make nla_data()
 186          * 8-byte aligned.
 187          */
 188         if (IS_ALIGNED((unsigned long)skb_tail_pointer(skb), 8))
 189                 return true;
 190 #endif
 191         return false;
 192 }
 193
 194 static inline int batadv_nla_total_size_64bit(int payload)
 195 {
 196         return NLA_ALIGN(nla_attr_size(payload))
 197 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 198                 + NLA_ALIGN(nla_attr_size(0))
 199 #endif
 200                 ;
 201 }
 202
 203 static inline int batadv_nla_put_64bit(struct sk_buff *skb, int attrtype,
 204                                        int attrlen, const void *data,
 205                                        int padattr)
 206 {
 207         size_t len;
 208
 209         if (batadv_nla_need_padding_for_64bit(skb))
 210                 len = batadv_nla_total_size_64bit(attrlen);
 211         else
 212                 len = nla_total_size(attrlen);
 213         if (unlikely(skb_tailroom(skb) < len))
 214                 return -EMSGSIZE;
 215
 216         batadv__nla_put_64bit(skb, attrtype, attrlen, data, padattr);
 217         return 0;
 218 }
 219
 220 #ifdef nla_put_u64_64bit
 221 #undef nla_put_u64_64bit
 222 #endif
 223
 224 #define nla_put_u64_64bit(_skb, _attrtype, _value, _padattr) \
 225         batadv_nla_put_u64_64bit(_skb, _attrtype, _value, _padattr)
 226 static inline int batadv_nla_put_u64_64bit(struct sk_buff *skb, int attrtype,
 227                                            u64 value, int padattr)
 228 {
 229         return batadv_nla_put_64bit(skb, attrtype, sizeof(u64), &value,
 230                                     padattr);
 231 }
 232
 233 #endif /* < KERNEL_VERSION(4, 7, 0) */
 234
 235
 236 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 10, 0)
 237
 238 #include_next <linux/cache.h>
 239
 240 /* hack for netlink.c which marked the family ops as ro */
 241 #ifdef __ro_after_init
 242 #undef __ro_after_init
 243 #endif
 244 #define __ro_after_init
 245
 246 #endif /* < KERNEL_VERSION(4, 10, 0) */
 247
 248 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 11, 9)
 249
 250 #include <linux/netdevice.h>
 251
 252 /* work around missing attribute needs_free_netdev and priv_destructor in
 253  * net_device
 254  */
 255 #define ether_setup(dev) \
 256         void batadv_softif_free2(struct net_device *dev) \
 257         { \
 258                 batadv_softif_free(dev); \
 259                 free_netdev(dev); \
 260         } \
 261         void (*t1)(struct net_device *dev) __attribute__((unused)); \
 262         bool t2 __attribute__((unused)); \
 263         ether_setup(dev)
 264 #define needs_free_netdev destructor = batadv_softif_free2; t2
 265 #define priv_destructor destructor = batadv_softif_free2; t1
 266
 267 #endif /* < KERNEL_VERSION(4, 11, 9) */
 268
 269 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 13, 0)
 270
 271 static inline void *batadv_skb_put(struct sk_buff *skb, unsigned int len)
 272 {
 273         return (void *)skb_put(skb, len);
 274 }
 275 #ifdef skb_put
 276 #undef skb_put
 277 #endif
 278
 279 #define skb_put batadv_skb_put
 280
 281 static inline void *batadv_skb_put_zero(struct sk_buff *skb, unsigned int len)
 282 {
 283         void *tmp = skb_put(skb, len);
 284
 285         memset(tmp, 0, len);
 286
 287         return tmp;
 288 }
 289 #ifdef skb_put_zero
 290 #undef skb_put_zero
 291 #endif
 292
 293 #define skb_put_zero batadv_skb_put_zero
 294
 295 static inline void *batadv_skb_put_data(struct sk_buff *skb, const void *data,
 296                                  unsigned int len)
 297 {
 298         void *tmp = skb_put(skb, len);
 299
 300         memcpy(tmp, data, len);
 301
 302         return tmp;
 303 }
 304 #ifdef skb_put_data
 305 #undef skb_put_data
 306 #endif
 307
 308 #define skb_put_data batadv_skb_put_data
 309
 310 #endif /* < KERNEL_VERSION(4, 13, 0) */
 311
 312 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)
 313
 314 #define batadv_softif_slave_add(__dev, __slave_dev, __extack) \
 315         batadv_softif_slave_add(__dev, __slave_dev)
 316
 317 #endif /* < KERNEL_VERSION(4, 15, 0) */
 318
 319 #ifndef from_timer
 320
 321 #define TIMER_DATA_TYPE                unsigned long
 322 #define TIMER_FUNC_TYPE                void (*)(TIMER_DATA_TYPE)
 323
 324 static inline void timer_setup(struct timer_list *timer,
 325                                void (*callback)(struct timer_list *),
 326                                unsigned int flags)
 327 {
 328         __setup_timer(timer, (TIMER_FUNC_TYPE)callback,
 329                       (TIMER_DATA_TYPE)timer, flags);
 330 }
 331
 332 #define from_timer(var, callback_timer, timer_fieldname) \
 333         container_of(callback_timer, typeof(*var), timer_fieldname)
 334
 335 #endif /* !from_timer */
 336
 337 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0)
 338
 339
 340 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 18, 0)
 341
 342 #include <net/cfg80211.h>
 343
 344 /* cfg80211 fix: https://patchwork.kernel.org/patch/10449857/ */
 345 static inline int batadv_cfg80211_get_station(struct net_device *dev,
 346                                               const u8 *mac_addr,
 347                                               struct station_info *sinfo)
 348 {
 349         memset(sinfo, 0, sizeof(*sinfo));
 350         return cfg80211_get_station(dev, mac_addr, sinfo);
 351 }
 352
 353 #define cfg80211_get_station(dev, mac_addr, sinfo) \
 354         batadv_cfg80211_get_station(dev, mac_addr, sinfo)
 355
 356 #endif /* < KERNEL_VERSION(4, 18, 0) */
 357
 358
 359 #ifdef __CHECK_POLL
 360 typedef unsigned __bitwise __poll_t;
 361 #else
 362 typedef unsigned __poll_t;
 363 #endif
 364
 365 #endif /* < KERNEL_VERSION(4, 16, 0) */
 366
 367 /* <DECLARE_EWMA> */
 368
 369 #include <linux/version.h>
 370 #include_next <linux/average.h>
 371
 372 #include <linux/bug.h>
 373
 374 #ifdef DECLARE_EWMA
 375 #undef DECLARE_EWMA
 376 #endif /* DECLARE_EWMA */
 377
 378 /*
 379  * Exponentially weighted moving average (EWMA)
 380  *
 381  * This implements a fixed-precision EWMA algorithm, with both the
 382  * precision and fall-off coefficient determined at compile-time
 383  * and built into the generated helper funtions.
 384  *
 385  * The first argument to the macro is the name that will be used
 386  * for the struct and helper functions.
 387  *
 388  * The second argument, the precision, expresses how many bits are
 389  * used for the fractional part of the fixed-precision values.
 390  *
 391  * The third argument, the weight reciprocal, determines how the
 392  * new values will be weighed vs. the old state, new values will
 393  * get weight 1/weight_rcp and old values 1-1/weight_rcp. Note
 394  * that this parameter must be a power of two for efficiency.
 395  */
 396
 397 #define DECLARE_EWMA(name, _precision, _weight_rcp)                     \
 398         struct ewma_##name {                                            \
 399                 unsigned long internal;                                 \
 400         };                                                              \
 401         static inline void ewma_##name##_init(struct ewma_##name *e)    \
 402         {                                                               \
 403                 BUILD_BUG_ON(!__builtin_constant_p(_precision));        \
 404                 BUILD_BUG_ON(!__builtin_constant_p(_weight_rcp));       \
 405                 /*                                                      \
 406                  * Even if you want to feed it just 0/1 you should have \
 407                  * some bits for the non-fractional part...             \
 408                  */                                                     \
 409                 BUILD_BUG_ON((_precision) > 30);                        \
 410                 BUILD_BUG_ON_NOT_POWER_OF_2(_weight_rcp);               \
 411                 e->internal = 0;                                        \
 412         }                                                               \
 413         static inline unsigned long                                     \
 414         ewma_##name##_read(struct ewma_##name *e)                       \
 415         {                                                               \
 416                 BUILD_BUG_ON(!__builtin_constant_p(_precision));        \
 417                 BUILD_BUG_ON(!__builtin_constant_p(_weight_rcp));       \
 418                 BUILD_BUG_ON((_precision) > 30);                        \
 419                 BUILD_BUG_ON_NOT_POWER_OF_2(_weight_rcp);               \
 420                 return e->internal >> (_precision);                     \
 421         }                                                               \
 422         static inline void ewma_##name##_add(struct ewma_##name *e,     \
 423                                              unsigned long val)         \
 424         {                                                               \
 425                 unsigned long internal = READ_ONCE(e->internal);        \
 426                 unsigned long weight_rcp = ilog2(_weight_rcp);          \
 427                 unsigned long precision = _precision;                   \
 428                                                                         \
 429                 BUILD_BUG_ON(!__builtin_constant_p(_precision));        \
 430                 BUILD_BUG_ON(!__builtin_constant_p(_weight_rcp));       \
 431                 BUILD_BUG_ON((_precision) > 30);                        \
 432                 BUILD_BUG_ON_NOT_POWER_OF_2(_weight_rcp);               \
 433                                                                         \
 434                 WRITE_ONCE(e->internal, internal ?                      \
 435                         (((internal << weight_rcp) - internal) +        \
 436                                 (val << precision)) >> weight_rcp :     \
 437                         (val << precision));                            \
 438         }
 439
 440 /* </DECLARE_EWMA> */