lib/route/class.c

   1 /*
   2  * lib/route/class.c            Queueing Classes
   3  *
   4  *      This library is free software; you can redistribute it and/or
   5  *      modify it under the terms of the GNU Lesser General Public
   6  *      License as published by the Free Software Foundation version 2.1
   7  *      of the License.
   8  *
   9  * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
  10  */
  11
  12 /**
  13  * @ingroup tc
  14  * @defgroup class Queueing Classes
  15  * @{
  16  */
  17
  18 #include <netlink-local.h>
  19 #include <netlink-tc.h>
  20 #include <netlink/netlink.h>
  21 #include <netlink/route/tc.h>
  22 #include <netlink/route/class.h>
  23 #include <netlink/route/class-modules.h>
  24 #include <netlink/route/qdisc.h>
  25 #include <netlink/route/classifier.h>
  26 #include <netlink/utils.h>
  27
  28 static struct nl_cache_ops rtnl_class_ops;
  29
  30 static int class_msg_parser(struct nl_cache_ops *ops, struct sockaddr_nl *who,
  31                             struct nlmsghdr *n, struct nl_parser_param *pp)
  32 {
  33         int err;
  34         struct rtnl_class *class;
  35         struct rtnl_class_ops *cops;
  36
  37         class = rtnl_class_alloc();
  38         if (!class) {
  39                 err = -NLE_NOMEM;
  40                 goto errout;
  41         }
  42         class->ce_msgtype = n->nlmsg_type;
  43
  44         err = tca_msg_parser(n, (struct rtnl_tca *) class);
  45         if (err < 0)
  46                 goto errout_free;
  47
  48         cops = rtnl_class_lookup_ops(class);
  49         if (cops && cops->co_msg_parser) {
  50                 err = cops->co_msg_parser(class);
  51                 if (err < 0)
  52                         goto errout_free;
  53         }
  54
  55         err = pp->pp_cb((struct nl_object *) class, pp);
  56 errout_free:
  57         rtnl_class_put(class);
  58 errout:
  59         return err;
  60 }
  61
  62 static int class_request_update(struct nl_cache *cache, struct nl_sock *sk)
  63 {
  64         struct tcmsg tchdr = {
  65                 .tcm_family = AF_UNSPEC,
  66                 .tcm_ifindex = cache->c_iarg1,
  67         };
  68
  69         return nl_send_simple(sk, RTM_GETTCLASS, NLM_F_DUMP, &tchdr,
  70                               sizeof(tchdr));
  71 }
  72
  73 /**
  74  * @name Addition/Modification
  75  * @{
  76  */
  77
  78 static int class_build(struct rtnl_class *class, int type, int flags,
  79                        struct nl_msg **result)
  80 {
  81         struct rtnl_class_ops *cops;
  82         int err;
  83
  84         err = tca_build_msg((struct rtnl_tca *) class, type, flags, result);
  85         if (err < 0)
  86                 return err;
  87
  88         cops = rtnl_class_lookup_ops(class);
  89         if (cops && cops->co_get_opts) {
  90                 struct nl_msg *opts;
  91
  92                 opts = cops->co_get_opts(class);
  93                 if (opts) {
  94                         err = nla_put_nested(*result, TCA_OPTIONS, opts);
  95                         nlmsg_free(opts);
  96                         if (err < 0)
  97                                 goto errout;
  98                 }
  99         }
 100
 101         return 0;
 102 errout:
 103         nlmsg_free(*result);
 104         return err;
 105 }
 106
 107 /**
 108  * Build a netlink message to add a new class
 109  * @arg class           class to add
 110  * @arg flags           additional netlink message flags
 111  * @arg result          Pointer to store resulting message.
 112  *
 113  * Builds a new netlink message requesting an addition of a class.
 114  * The netlink message header isn't fully equipped with all relevant
 115  * fields and must be sent out via nl_send_auto_complete() or
 116  * supplemented as needed.
 117  *
 118  * Common message flags
 119  *   - NLM_F_REPLACE - replace possibly existing classes
 120  *
 121  * @return 0 on success or a negative error code.
 122  */
 123 int rtnl_class_build_add_request(struct rtnl_class *class, int flags,
 124                                  struct nl_msg **result)
 125 {
 126         return class_build(class, RTM_NEWTCLASS, NLM_F_CREATE | flags, result);
 127 }
 128
 129 /**
 130  * Add a new class
 131  * @arg sk              Netlink socket.
 132  * @arg class           class to delete
 133  * @arg flags           additional netlink message flags
 134  *
 135  * Builds a netlink message by calling rtnl_qdisc_build_add_request(),
 136  * sends the request to the kernel and waits for the next ACK to be
 137  * received and thus blocks until the request has been processed.
 138  *
 139  * Common message flags
 140  *   - NLM_F_REPLACE - replace possibly existing classes
 141  *
 142  * @return 0 on success or a negative error code
 143  */
 144 int rtnl_class_add(struct nl_sock *sk, struct rtnl_class *class, int flags)
 145 {
 146         struct nl_msg *msg;
 147         int err;
 148
 149         if ((err = rtnl_class_build_add_request(class, flags, &msg)) < 0)
 150                 return err;
 151
 152         err = nl_send_auto_complete(sk, msg);
 153         nlmsg_free(msg);
 154         if (err < 0)
 155                 return err;
 156
 157         return wait_for_ack(sk);
 158 }
 159
 160 int rtnl_class_build_delete_request(struct rtnl_class *class,
 161                                                                         struct nl_msg **result)
 162 {
 163         struct nl_msg *msg;
 164         struct tcmsg tchdr;
 165         int required = TCA_ATTR_IFINDEX | TCA_ATTR_PARENT;
 166
 167         if ((class->ce_mask & required) != required)
 168                 BUG();
 169
 170         msg = nlmsg_alloc_simple(RTM_DELTCLASS, 0);
 171         if (!msg)
 172                 return -NLE_NOMEM;
 173
 174         tchdr.tcm_family = AF_UNSPEC;
 175         tchdr.tcm_handle = class->c_handle;
 176         tchdr.tcm_parent = class->c_parent;
 177         tchdr.tcm_ifindex = class->c_ifindex;
 178         if (nlmsg_append(msg, &tchdr, sizeof(tchdr), NLMSG_ALIGNTO) < 0) {
 179                 nlmsg_free(msg);
 180                 return -NLE_MSGSIZE;
 181         }
 182
 183         *result = msg;
 184         return 0;
 185 }
 186
 187 /**
 188  * Delete a class
 189  * @arg sk              Netlink socket.
 190  * @arg class           class to delete
 191  *
 192  * Builds a netlink message by calling rtnl_class_build_delete_request(),
 193  * sends the request to the kernel and waits for the ACK to be
 194  * received and thus blocks until the request has been processed.
 195  *
 196  * @return 0 on success or a negative error code
 197  */
 198 int rtnl_class_delete(struct nl_sock *sk, struct rtnl_class *class)
 199 {
 200         struct nl_msg *msg;
 201         int err;
 202
 203         if ((err = rtnl_class_build_delete_request(class, &msg)) < 0)
 204                 return err;
 205
 206         err = nl_send_auto_complete(sk, msg);
 207         nlmsg_free(msg);
 208         if (err < 0)
 209                 return err;
 210
 211         return wait_for_ack(sk);
 212 }
 213
 214 /** @} */
 215
 216 /**
 217  * @name Cache Management
 218  * @{
 219  */
 220
 221 /**
 222  * Build a class cache including all classes attached to the specified interface
 223  * @arg sk              Netlink socket.
 224  * @arg ifindex         interface index of the link the classes are
 225  *                      attached to.
 226  *
 227  * Allocates a new cache, initializes it properly and updates it to
 228  * include all classes attached to the specified interface.
 229  *
 230  * @return The cache or NULL if an error has occured.
 231  */
 232 int rtnl_class_alloc_cache(struct nl_sock *sk, int ifindex,
 233                            struct nl_cache **result)
 234 {
 235         struct nl_cache * cache;
 236         int err;
 237
 238         cache = nl_cache_alloc(&rtnl_class_ops);
 239         if (!cache)
 240                 return -NLE_NOMEM;
 241
 242         cache->c_iarg1 = ifindex;
 243
 244         if (sk && (err = nl_cache_refill(sk, cache)) < 0) {
 245                 nl_cache_free(cache);
 246                 return err;
 247         }
 248
 249         *result = cache;
 250         return 0;
 251 }
 252
 253 /**
 254  * Look up class by its handle in the provided cache
 255  * @arg cache           class cache
 256  * @arg ifindex         interface the class is attached to
 257  * @arg handle          class handle
 258  * @return pointer to class inside the cache or NULL if no match was found.
 259  */
 260 struct rtnl_class *rtnl_class_get(struct nl_cache *cache, int ifindex,
 261                                                                   uint32_t handle)
 262 {
 263         struct rtnl_class *class;
 264
 265         if (cache->c_ops != &rtnl_class_ops)
 266                 return NULL;
 267
 268         nl_list_for_each_entry(class, &cache->c_items, ce_list) {
 269                 if (class->c_handle == handle && class->c_ifindex == ifindex) {
 270                         nl_object_get((struct nl_object *) class);
 271                         return class;
 272                 }
 273         }
 274         return NULL;
 275 }
 276
 277 /** @} */
 278
 279 static struct nl_cache_ops rtnl_class_ops = {
 280         .co_name                = "route/class",
 281         .co_hdrsize             = sizeof(struct tcmsg),
 282         .co_msgtypes            = {
 283                                         { RTM_NEWTCLASS, NL_ACT_NEW, "new" },
 284                                         { RTM_DELTCLASS, NL_ACT_DEL, "del" },
 285                                         { RTM_GETTCLASS, NL_ACT_GET, "get" },
 286                                         END_OF_MSGTYPES_LIST,
 287                                   },
 288         .co_protocol            = NETLINK_ROUTE,
 289         .co_request_update      = &class_request_update,
 290         .co_msg_parser          = &class_msg_parser,
 291         .co_obj_ops             = &class_obj_ops,
 292 };
 293
 294 static void __init class_init(void)
 295 {
 296         nl_cache_mngt_register(&rtnl_class_ops);
 297 }
 298
 299 static void __exit class_exit(void)
 300 {
 301         nl_cache_mngt_unregister(&rtnl_class_ops);
 302 }
 303
 304 /** @} */