1 /* 2 * net/sched/cls_cgroup.c Control Group Classifier 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public License 6 * as published by the Free Software Foundation; either version 7 * 2 of the License, or (at your option) any later version. 8 * 9 * Authors: Thomas Graf <tgraf@suug.ch> 10 */ 11 12 #include <linux/module.h> 13 #include <linux/slab.h> 14 #include <linux/types.h> 15 #include <linux/string.h> 16 #include <linux/errno.h> 17 #include <linux/skbuff.h> 18 #include <linux/cgroup.h> 19 #include <linux/rcupdate.h> 20 #include <linux/fdtable.h> 21 #include <net/rtnetlink.h> 22 #include <net/pkt_cls.h> 23 #include <net/sock.h> 24 #include <net/cls_cgroup.h> 25 26 static inline struct cgroup_cls_state *css_cls_state(struct cgroup_subsys_state *css) 27 { 28 return css ? container_of(css, struct cgroup_cls_state, css) : NULL; 29 } 30 31 static inline struct cgroup_cls_state *task_cls_state(struct task_struct *p) 32 { 33 return css_cls_state(task_css(p, net_cls_subsys_id)); 34 } 35 36 static struct cgroup_subsys_state * 37 cgrp_css_alloc(struct cgroup_subsys_state *parent_css) 38 { 39 struct cgroup_cls_state *cs; 40 41 cs = kzalloc(sizeof(*cs), GFP_KERNEL); 42 if (!cs) 43 return ERR_PTR(-ENOMEM); 44 return &cs->css; 45 } 46 47 static int cgrp_css_online(struct cgroup_subsys_state *css) 48 { 49 struct cgroup_cls_state *cs = css_cls_state(css); 50 struct cgroup_cls_state *parent = css_cls_state(css_parent(css)); 51 52 if (parent) 53 cs->classid = parent->classid; 54 return 0; 55 } 56 57 static void cgrp_css_free(struct cgroup_subsys_state *css) 58 { 59 kfree(css_cls_state(css)); 60 } 61 62 static int update_classid(const void *v, struct file *file, unsigned n) 63 { 64 int err; 65 struct socket *sock = sock_from_file(file, &err); 66 if (sock) 67 sock->sk->sk_classid = (u32)(unsigned long)v; 68 return 0; 69 } 70 71 static void cgrp_attach(struct cgroup_subsys_state *css, 72 struct cgroup_taskset *tset) 73 { 74 struct task_struct *p; 75 struct cgroup_cls_state *cs = css_cls_state(css); 76 void *v = (void *)(unsigned long)cs->classid; 77 78 cgroup_taskset_for_each(p, css, tset) { 79 task_lock(p); 80 iterate_fd(p->files, 0, update_classid, v); 81 task_unlock(p); 82 } 83 } 84 85 static u64 read_classid(struct cgroup_subsys_state *css, struct cftype *cft) 86 { 87 return css_cls_state(css)->classid; 88 } 89 90 static int write_classid(struct cgroup_subsys_state *css, struct cftype *cft, 91 u64 value) 92 { 93 css_cls_state(css)->classid = (u32) value; 94 return 0; 95 } 96 97 static struct cftype ss_files[] = { 98 { 99 .name = "classid", 100 .read_u64 = read_classid, 101 .write_u64 = write_classid, 102 }, 103 { } /* terminate */ 104 }; 105 106 struct cgroup_subsys net_cls_subsys = { 107 .name = "net_cls", 108 .css_alloc = cgrp_css_alloc, 109 .css_online = cgrp_css_online, 110 .css_free = cgrp_css_free, 111 .attach = cgrp_attach, 112 .subsys_id = net_cls_subsys_id, 113 .base_cftypes = ss_files, 114 .module = THIS_MODULE, 115 }; 116 117 struct cls_cgroup_head { 118 u32 handle; 119 struct tcf_exts exts; 120 struct tcf_ematch_tree ematches; 121 }; 122 123 static int cls_cgroup_classify(struct sk_buff *skb, const struct tcf_proto *tp, 124 struct tcf_result *res) 125 { 126 struct cls_cgroup_head *head = tp->root; 127 u32 classid; 128 129 rcu_read_lock(); 130 classid = task_cls_state(current)->classid; 131 rcu_read_unlock(); 132 133 /* 134 * Due to the nature of the classifier it is required to ignore all 135 * packets originating from softirq context as accessing `current' 136 * would lead to false results. 137 * 138 * This test assumes that all callers of dev_queue_xmit() explicitely 139 * disable bh. Knowing this, it is possible to detect softirq based 140 * calls by looking at the number of nested bh disable calls because 141 * softirqs always disables bh. 142 */ 143 if (in_serving_softirq()) { 144 /* If there is an sk_classid we'll use that. */ 145 if (!skb->sk) 146 return -1; 147 classid = skb->sk->sk_classid; 148 } 149 150 if (!classid) 151 return -1; 152 153 if (!tcf_em_tree_match(skb, &head->ematches, NULL)) 154 return -1; 155 156 res->classid = classid; 157 res->class = 0; 158 return tcf_exts_exec(skb, &head->exts, res); 159 } 160 161 static unsigned long cls_cgroup_get(struct tcf_proto *tp, u32 handle) 162 { 163 return 0UL; 164 } 165 166 static void cls_cgroup_put(struct tcf_proto *tp, unsigned long f) 167 { 168 } 169 170 static int cls_cgroup_init(struct tcf_proto *tp) 171 { 172 return 0; 173 } 174 175 static const struct tcf_ext_map cgroup_ext_map = { 176 .action = TCA_CGROUP_ACT, 177 .police = TCA_CGROUP_POLICE, 178 }; 179 180 static const struct nla_policy cgroup_policy[TCA_CGROUP_MAX + 1] = { 181 [TCA_CGROUP_EMATCHES] = { .type = NLA_NESTED }, 182 }; 183 184 static int cls_cgroup_change(struct net *net, struct sk_buff *in_skb, 185 struct tcf_proto *tp, unsigned long base, 186 u32 handle, struct nlattr **tca, 187 unsigned long *arg) 188 { 189 struct nlattr *tb[TCA_CGROUP_MAX + 1]; 190 struct cls_cgroup_head *head = tp->root; 191 struct tcf_ematch_tree t; 192 struct tcf_exts e; 193 int err; 194 195 if (!tca[TCA_OPTIONS]) 196 return -EINVAL; 197 198 if (head == NULL) { 199 if (!handle) 200 return -EINVAL; 201 202 head = kzalloc(sizeof(*head), GFP_KERNEL); 203 if (head == NULL) 204 return -ENOBUFS; 205 206 head->handle = handle; 207 208 tcf_tree_lock(tp); 209 tp->root = head; 210 tcf_tree_unlock(tp); 211 } 212 213 if (handle != head->handle) 214 return -ENOENT; 215 216 err = nla_parse_nested(tb, TCA_CGROUP_MAX, tca[TCA_OPTIONS], 217 cgroup_policy); 218 if (err < 0) 219 return err; 220 221 err = tcf_exts_validate(net, tp, tb, tca[TCA_RATE], &e, 222 &cgroup_ext_map); 223 if (err < 0) 224 return err; 225 226 err = tcf_em_tree_validate(tp, tb[TCA_CGROUP_EMATCHES], &t); 227 if (err < 0) 228 return err; 229 230 tcf_exts_change(tp, &head->exts, &e); 231 tcf_em_tree_change(tp, &head->ematches, &t); 232 233 return 0; 234 } 235 236 static void cls_cgroup_destroy(struct tcf_proto *tp) 237 { 238 struct cls_cgroup_head *head = tp->root; 239 240 if (head) { 241 tcf_exts_destroy(tp, &head->exts); 242 tcf_em_tree_destroy(tp, &head->ematches); 243 kfree(head); 244 } 245 } 246 247 static int cls_cgroup_delete(struct tcf_proto *tp, unsigned long arg) 248 { 249 return -EOPNOTSUPP; 250 } 251 252 static void cls_cgroup_walk(struct tcf_proto *tp, struct tcf_walker *arg) 253 { 254 struct cls_cgroup_head *head = tp->root; 255 256 if (arg->count < arg->skip) 257 goto skip; 258 259 if (arg->fn(tp, (unsigned long) head, arg) < 0) { 260 arg->stop = 1; 261 return; 262 } 263 skip: 264 arg->count++; 265 } 266 267 static int cls_cgroup_dump(struct tcf_proto *tp, unsigned long fh, 268 struct sk_buff *skb, struct tcmsg *t) 269 { 270 struct cls_cgroup_head *head = tp->root; 271 unsigned char *b = skb_tail_pointer(skb); 272 struct nlattr *nest; 273 274 t->tcm_handle = head->handle; 275 276 nest = nla_nest_start(skb, TCA_OPTIONS); 277 if (nest == NULL) 278 goto nla_put_failure; 279 280 if (tcf_exts_dump(skb, &head->exts, &cgroup_ext_map) < 0 || 281 tcf_em_tree_dump(skb, &head->ematches, TCA_CGROUP_EMATCHES) < 0) 282 goto nla_put_failure; 283 284 nla_nest_end(skb, nest); 285 286 if (tcf_exts_dump_stats(skb, &head->exts, &cgroup_ext_map) < 0) 287 goto nla_put_failure; 288 289 return skb->len; 290 291 nla_put_failure: 292 nlmsg_trim(skb, b); 293 return -1; 294 } 295 296 static struct tcf_proto_ops cls_cgroup_ops __read_mostly = { 297 .kind = "cgroup", 298 .init = cls_cgroup_init, 299 .change = cls_cgroup_change, 300 .classify = cls_cgroup_classify, 301 .destroy = cls_cgroup_destroy, 302 .get = cls_cgroup_get, 303 .put = cls_cgroup_put, 304 .delete = cls_cgroup_delete, 305 .walk = cls_cgroup_walk, 306 .dump = cls_cgroup_dump, 307 .owner = THIS_MODULE, 308 }; 309 310 static int __init init_cgroup_cls(void) 311 { 312 int ret; 313 314 ret = cgroup_load_subsys(&net_cls_subsys); 315 if (ret) 316 goto out; 317 318 ret = register_tcf_proto_ops(&cls_cgroup_ops); 319 if (ret) 320 cgroup_unload_subsys(&net_cls_subsys); 321 322 out: 323 return ret; 324 } 325 326 static void __exit exit_cgroup_cls(void) 327 { 328 unregister_tcf_proto_ops(&cls_cgroup_ops); 329 330 cgroup_unload_subsys(&net_cls_subsys); 331 } 332 333 module_init(init_cgroup_cls); 334 module_exit(exit_cgroup_cls); 335 MODULE_LICENSE("GPL"); 336