imamnurby/smpl_train_seed8 huggingface dataset:
--- initial
+++ final
@@ -1,28 +1,28 @@
 static struct sk_buff *sch_handle_egress(struct sk_buff *skb, int *ret, struct net_device *dev) {
   struct tcf_proto *cl = rcu_dereference_bh(dev->egress_cl_list);
   struct tcf_result cl_res;
   if (!cl) return skb;
   /* qdisc_skb_cb(skb)->pkt_len was already set by the caller. */
   qdisc_bstats_cpu_update(cl->q, skb);
-  switch (tc_classify(skb, cl, &cl_res, false)) {
+  switch (tcf_classify(skb, cl, &cl_res, false)) {
   case TC_ACT_OK:
   case TC_ACT_RECLASSIFY: skb->tc_index = TC_H_MIN(cl_res.classid); break;
   case TC_ACT_SHOT:
     qdisc_qstats_cpu_drop(cl->q);
     *ret = NET_XMIT_DROP;
     kfree_skb(skb);
     return NULL;
   case TC_ACT_STOLEN:
   case TC_ACT_QUEUED:
     *ret = NET_XMIT_SUCCESS;
     consume_skb(skb);
     return NULL;
   case TC_ACT_REDIRECT:
     /* No need to push/pop skb's mac_header here on egress! */
     skb_do_redirect(skb);
     *ret = NET_XMIT_SUCCESS;
     return NULL;
   default: break;
   }
   return skb;
 }<sep>@@
expression e1,e2,e3,e4;
@@

-       tc_classify
+       tcf_classify
	(e1,e2,e3,e4)
--- initial
+++ final
@@ -1,39 +1,39 @@
 static inline struct sk_buff *sch_handle_ingress(struct sk_buff *skb, struct packet_type **pt_prev, int *ret, struct net_device *orig_dev) {
 #ifdef CONFIG_NET_CLS_ACT
   struct tcf_proto *cl = rcu_dereference_bh(skb->dev->ingress_cl_list);
   struct tcf_result cl_res;
   /* If there's at least one ingress present somewhere (so
    * we get here via enabled static key), remaining devices
    * that are not configured with an ingress qdisc will bail
    * out here.
    */
   if (!cl) return skb;
   if (*pt_prev) {
     *ret = deliver_skb(skb, *pt_prev, orig_dev);
     *pt_prev = NULL;
   }
   qdisc_skb_cb(skb)->pkt_len = skb->len;
   skb->tc_at_ingress = 1;
   qdisc_bstats_cpu_update(cl->q, skb);
-  switch (tc_classify(skb, cl, &cl_res, false)) {
+  switch (tcf_classify(skb, cl, &cl_res, false)) {
   case TC_ACT_OK:
   case TC_ACT_RECLASSIFY: skb->tc_index = TC_H_MIN(cl_res.classid); break;
   case TC_ACT_SHOT:
     qdisc_qstats_cpu_drop(cl->q);
     kfree_skb(skb);
     return NULL;
   case TC_ACT_STOLEN:
   case TC_ACT_QUEUED: consume_skb(skb); return NULL;
   case TC_ACT_REDIRECT:
     /* skb_mac_header check was done by cls/act_bpf, so
      * we can safely push the L2 header back before
      * redirecting to another netdev
      */
     __skb_push(skb, skb->mac_len);
     skb_do_redirect(skb);
     return NULL;
   default: break;
   }
 #endif /* CONFIG_NET_CLS_ACT */
   return skb;
 }<sep>@@
expression e1,e2,e3,e4;
@@

-       tc_classify
+       tcf_classify
	(e1,e2,e3,e4)
--- initial
+++ final
@@ -1,68 +1,68 @@
 static int atm_tc_enqueue(struct sk_buff *skb, struct Qdisc *sch, struct sk_buff **to_free) {
   struct atm_qdisc_data *p = qdisc_priv(sch);
   struct atm_flow_data *flow;
   struct tcf_result res;
   int result;
   int ret = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
   pr_debug("atm_tc_enqueue(skb %p,sch %p,[qdisc %p])\n", skb, sch, p);
   result = TC_ACT_OK; /* be nice to gcc */
   flow = NULL;
   if (TC_H_MAJ(skb->priority) != sch->handle || !(flow = (struct atm_flow_data *)atm_tc_get(sch, skb->priority))) {
     struct tcf_proto *fl;
     list_for_each_entry(flow, &p->flows, list) {
       fl = rcu_dereference_bh(flow->filter_list);
       if (fl) {
-        result = tc_classify(skb, fl, &res, true);
+        result = tcf_classify(skb, fl, &res, true);
         if (result < 0) continue;
         flow = (struct atm_flow_data *)res.class;
         if (!flow) flow = lookup_flow(sch, res.classid);
         goto done;
       }
     }
     flow = NULL;
   done:;
   }
   if (!flow) {
     flow = &p->link;
   } else {
     if (flow->vcc) ATM_SKB(skb)->atm_options = flow->vcc->atm_options;
       /*@@@ looks good ... but it's not supposed to work :-) */
 #ifdef CONFIG_NET_CLS_ACT
     switch (result) {
     case TC_ACT_QUEUED:
     case TC_ACT_STOLEN: __qdisc_drop(skb, to_free); return NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
     case TC_ACT_SHOT: __qdisc_drop(skb, to_free); goto drop;
     case TC_ACT_RECLASSIFY:
       if (flow->excess)
         flow = flow->excess;
       else
         ATM_SKB(skb)->atm_options |= ATM_ATMOPT_CLP;
       break;
     }
 #endif
   }
   ret = qdisc_enqueue(skb, flow->q, to_free);
   if (ret != NET_XMIT_SUCCESS) {
   drop:
     __maybe_unused if (net_xmit_drop_count(ret)) {
       qdisc_qstats_drop(sch);
       if (flow) flow->qstats.drops++;
     }
     return ret;
   }
   /*
    * Okay, this may seem weird. We pretend we've dropped the packet if
    * it goes via ATM. The reason for this is that the outer qdisc
    * expects to be able to q->dequeue the packet later on if we return
    * success at this place. Also, sch->q.qdisc needs to reflect whether
    * there is a packet egligible for dequeuing or not. Note that the
    * statistics of the outer qdisc are necessarily wrong because of all
    * this. There's currently no correct solution for this.
    */
   if (flow == &p->link) {
     sch->q.qlen++;
     return NET_XMIT_SUCCESS;
   }
   tasklet_schedule(&p->task);
   return NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
 }<sep>@@
expression e1,e2,e3,e4;
@@

-       tc_classify
+       tcf_classify
	(e1,e2,e3,e4)
--- initial
+++ final
@@ -1,55 +1,55 @@
 static struct cbq_class *cbq_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr) {
   struct cbq_sched_data *q = qdisc_priv(sch);
   struct cbq_class *head = &q->link;
   struct cbq_class **defmap;
   struct cbq_class *cl = NULL;
   u32 prio = skb->priority;
   struct tcf_proto *fl;
   struct tcf_result res;
   /*
    *  Step 1. If skb->priority points to one of our classes, use it.
    */
   if (TC_H_MAJ(prio ^ sch->handle) == 0 && (cl = cbq_class_lookup(q, prio)) != NULL) return cl;
   *qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
   for (;;) {
     int result = 0;
     defmap = head->defaults;
     fl = rcu_dereference_bh(head->filter_list);
     /*
      * Step 2+n. Apply classifier.
      */
-    result = tc_classify(skb, fl, &res, true);
+    result = tcf_classify(skb, fl, &res, true);
     if (!fl || result < 0) goto fallback;
     cl = (void *)res.class;
     if (!cl) {
       if (TC_H_MAJ(res.classid))
         cl = cbq_class_lookup(q, res.classid);
       else if ((cl = defmap[res.classid & TC_PRIO_MAX]) == NULL)
         cl = defmap[TC_PRIO_BESTEFFORT];
       if (cl == NULL) goto fallback;
     }
     if (cl->level >= head->level) goto fallback;
 #ifdef CONFIG_NET_CLS_ACT
     switch (result) {
     case TC_ACT_QUEUED:
     case TC_ACT_STOLEN: *qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
     case TC_ACT_SHOT: return NULL;
     case TC_ACT_RECLASSIFY: return cbq_reclassify(skb, cl);
     }
 #endif
     if (cl->level == 0) return cl;
     /*
      * Step 3+n. If classifier selected a link sharing class,
      *	   apply agency specific classifier.
      *	   Repeat this procdure until we hit a leaf node.
      */
     head = cl;
   }
 fallback:
   cl = head;
   /*
    * Step 4. No success...
    */
   if (TC_H_MAJ(prio) == 0 && !(cl = head->defaults[prio & TC_PRIO_MAX]) && !(cl = head->defaults[TC_PRIO_BESTEFFORT])) return head;
   return cl;
 }<sep>@@
expression e1,e2,e3,e4;
@@

-       tc_classify
+       tcf_classify
	(e1,e2,e3,e4)
--- initial
+++ final
@@ -1,27 +1,27 @@
 static struct drr_class *drr_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr) {
   struct drr_sched *q = qdisc_priv(sch);
   struct drr_class *cl;
   struct tcf_result res;
   struct tcf_proto *fl;
   int result;
   if (TC_H_MAJ(skb->priority ^ sch->handle) == 0) {
     cl = drr_find_class(sch, skb->priority);
     if (cl != NULL) return cl;
   }
   *qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
   fl = rcu_dereference_bh(q->filter_list);
-  result = tc_classify(skb, fl, &res, false);
+  result = tcf_classify(skb, fl, &res, false);
   if (result >= 0) {
 #ifdef CONFIG_NET_CLS_ACT
     switch (result) {
     case TC_ACT_QUEUED:
     case TC_ACT_STOLEN: *qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
     case TC_ACT_SHOT: return NULL;
     }
 #endif
     cl = (struct drr_class *)res.class;
     if (cl == NULL) cl = drr_find_class(sch, res.classid);
     return cl;
   }
   return NULL;
 }<sep>@@
expression e1,e2,e3,e4;
@@

-       tc_classify
+       tcf_classify
	(e1,e2,e3,e4)
--- initial
+++ final
@@ -1,51 +1,51 @@
 static int dsmark_enqueue(struct sk_buff *skb, struct Qdisc *sch, struct sk_buff **to_free) {
   struct dsmark_qdisc_data *p = qdisc_priv(sch);
   int err;
   pr_debug("%s(skb %p,sch %p,[qdisc %p])\n", __func__, skb, sch, p);
   if (p->set_tc_index) {
     int wlen = skb_network_offset(skb);
     switch (tc_skb_protocol(skb)) {
     case htons(ETH_P_IP):
       wlen += sizeof(struct iphdr);
       if (!pskb_may_pull(skb, wlen) || skb_try_make_writable(skb, wlen)) goto drop;
       skb->tc_index = ipv4_get_dsfield(ip_hdr(skb)) & ~INET_ECN_MASK;
       break;
     case htons(ETH_P_IPV6):
       wlen += sizeof(struct ipv6hdr);
       if (!pskb_may_pull(skb, wlen) || skb_try_make_writable(skb, wlen)) goto drop;
       skb->tc_index = ipv6_get_dsfield(ipv6_hdr(skb)) & ~INET_ECN_MASK;
       break;
     default: skb->tc_index = 0; break;
     }
   }
   if (TC_H_MAJ(skb->priority) == sch->handle)
     skb->tc_index = TC_H_MIN(skb->priority);
   else {
     struct tcf_result res;
     struct tcf_proto *fl = rcu_dereference_bh(p->filter_list);
-    int result = tc_classify(skb, fl, &res, false);
+    int result = tcf_classify(skb, fl, &res, false);
     pr_debug("result %d class 0x%04x\n", result, res.classid);
     switch (result) {
 #ifdef CONFIG_NET_CLS_ACT
     case TC_ACT_QUEUED:
     case TC_ACT_STOLEN: __qdisc_drop(skb, to_free); return NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
     case TC_ACT_SHOT: goto drop;
 #endif
     case TC_ACT_OK: skb->tc_index = TC_H_MIN(res.classid); break;
     default:
       if (p->default_index != NO_DEFAULT_INDEX) skb->tc_index = p->default_index;
       break;
     }
   }
   err = qdisc_enqueue(skb, p->q, to_free);
   if (err != NET_XMIT_SUCCESS) {
     if (net_xmit_drop_count(err)) qdisc_qstats_drop(sch);
     return err;
   }
   qdisc_qstats_backlog_inc(sch, skb);
   sch->q.qlen++;
   return NET_XMIT_SUCCESS;
 drop:
   qdisc_drop(skb, sch, to_free);
   return NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
 }<sep>@@
expression e1,e2,e3,e4;
@@

-       tc_classify
+       tcf_classify
	(e1,e2,e3,e4)
--- initial
+++ final
@@ -1,22 +1,22 @@
 static unsigned int fq_codel_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr) {
   struct fq_codel_sched_data *q = qdisc_priv(sch);
   struct tcf_proto *filter;
   struct tcf_result res;
   int result;
   if (TC_H_MAJ(skb->priority) == sch->handle && TC_H_MIN(skb->priority) > 0 && TC_H_MIN(skb->priority) <= q->flows_cnt) return TC_H_MIN(skb->priority);
   filter = rcu_dereference_bh(q->filter_list);
   if (!filter) return fq_codel_hash(q, skb) + 1;
   *qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
-  result = tc_classify(skb, filter, &res, false);
+  result = tcf_classify(skb, filter, &res, false);
   if (result >= 0) {
 #ifdef CONFIG_NET_CLS_ACT
     switch (result) {
     case TC_ACT_STOLEN:
     case TC_ACT_QUEUED: *qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
     case TC_ACT_SHOT: return 0;
     }
 #endif
     if (TC_H_MIN(res.classid) <= q->flows_cnt) return TC_H_MIN(res.classid);
   }
   return 0;
 }<sep>@@
expression e1,e2,e3,e4;
@@

-       tc_classify
+       tcf_classify
	(e1,e2,e3,e4)
--- initial
+++ final
@@ -1,35 +1,35 @@
 static struct hfsc_class *hfsc_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr) {
   struct hfsc_sched *q = qdisc_priv(sch);
   struct hfsc_class *head, *cl;
   struct tcf_result res;
   struct tcf_proto *tcf;
   int result;
   if (TC_H_MAJ(skb->priority ^ sch->handle) == 0 && (cl = hfsc_find_class(skb->priority, sch)) != NULL)
     if (cl->level == 0) return cl;
   *qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
   head = &q->root;
   tcf = rcu_dereference_bh(q->root.filter_list);
-  while (tcf && (result = tc_classify(skb, tcf, &res, false)) >= 0) {
+  while (tcf && (result = tcf_classify(skb, tcf, &res, false)) >= 0) {
 #ifdef CONFIG_NET_CLS_ACT
     switch (result) {
     case TC_ACT_QUEUED:
     case TC_ACT_STOLEN: *qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
     case TC_ACT_SHOT: return NULL;
     }
 #endif
     cl = (struct hfsc_class *)res.class;
     if (!cl) {
       cl = hfsc_find_class(res.classid, sch);
       if (!cl) break;                      /* filter selected invalid classid */
       if (cl->level >= head->level) break; /* filter may only point downwards */
     }
     if (cl->level == 0) return cl; /* hit leaf class */
     /* apply inner filter chain */
     tcf = rcu_dereference_bh(cl->filter_list);
     head = cl;
   }
   /* classification failed, try default class */
   cl = hfsc_find_class(TC_H_MAKE(TC_H_MAJ(sch->handle), q->defcls), sch);
   if (cl == NULL || cl->level > 0) return NULL;
   return cl;
 }<sep>@@
expression e1,e2,e3,e4;
@@

-       tc_classify
+       tcf_classify
	(e1,e2,e3,e4)
--- initial
+++ final
@@ -1,43 +1,43 @@
 static struct htb_class *htb_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr) {
   struct htb_sched *q = qdisc_priv(sch);
   struct htb_class *cl;
   struct tcf_result res;
   struct tcf_proto *tcf;
   int result;
   /* allow to select class by setting skb->priority to valid classid;
    * note that nfmark can be used too by attaching filter fw with no
    * rules in it
    */
   if (skb->priority == sch->handle) return HTB_DIRECT; /* X:0 (direct flow) selected */
   cl = htb_find(skb->priority, sch);
   if (cl) {
     if (cl->level == 0) return cl;
     /* Start with inner filter chain if a non-leaf class is selected */
     tcf = rcu_dereference_bh(cl->filter_list);
   } else {
     tcf = rcu_dereference_bh(q->filter_list);
   }
   *qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
-  while (tcf && (result = tc_classify(skb, tcf, &res, false)) >= 0) {
+  while (tcf && (result = tcf_classify(skb, tcf, &res, false)) >= 0) {
 #ifdef CONFIG_NET_CLS_ACT
     switch (result) {
     case TC_ACT_QUEUED:
     case TC_ACT_STOLEN: *qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
     case TC_ACT_SHOT: return NULL;
     }
 #endif
     cl = (void *)res.class;
     if (!cl) {
       if (res.classid == sch->handle) return HTB_DIRECT; /* X:0 (direct flow) */
       cl = htb_find(res.classid, sch);
       if (!cl) break; /* filter selected invalid classid */
     }
     if (!cl->level) return cl; /* we hit leaf; return it */
     /* we have got inner class; apply inner filter chain */
     tcf = rcu_dereference_bh(cl->filter_list);
   }
   /* classification failed; try to use default class */
   cl = htb_find(TC_H_MAKE(TC_H_MAJ(sch->handle), q->defcls), sch);
   if (!cl || cl->level) return HTB_DIRECT; /* bad default .. this is safe bet */
   return cl;
 }<sep>@@
expression e1,e2,e3,e4;
@@

-       tc_classify
+       tcf_classify
	(e1,e2,e3,e4)
--- initial
+++ final
@@ -1,19 +1,19 @@
 static struct Qdisc *multiq_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr) {
   struct multiq_sched_data *q = qdisc_priv(sch);
   u32 band;
   struct tcf_result res;
   struct tcf_proto *fl = rcu_dereference_bh(q->filter_list);
   int err;
   *qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
-  err = tc_classify(skb, fl, &res, false);
+  err = tcf_classify(skb, fl, &res, false);
 #ifdef CONFIG_NET_CLS_ACT
   switch (err) {
   case TC_ACT_STOLEN:
   case TC_ACT_QUEUED: *qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
   case TC_ACT_SHOT: return NULL;
   }
 #endif
   band = skb_get_queue_mapping(skb);
   if (band >= q->bands) return q->queues[0];
   return q->queues[band];
 }<sep>@@
expression e1,e2,e3,e4;
@@

-       tc_classify
+       tcf_classify
	(e1,e2,e3,e4)
--- initial
+++ final
@@ -1,27 +1,27 @@
 static struct Qdisc *prio_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr) {
   struct prio_sched_data *q = qdisc_priv(sch);
   u32 band = skb->priority;
   struct tcf_result res;
   struct tcf_proto *fl;
   int err;
   *qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
   if (TC_H_MAJ(skb->priority) != sch->handle) {
     fl = rcu_dereference_bh(q->filter_list);
-    err = tc_classify(skb, fl, &res, false);
+    err = tcf_classify(skb, fl, &res, false);
 #ifdef CONFIG_NET_CLS_ACT
     switch (err) {
     case TC_ACT_STOLEN:
     case TC_ACT_QUEUED: *qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
     case TC_ACT_SHOT: return NULL;
     }
 #endif
     if (!fl || err < 0) {
       if (TC_H_MAJ(band)) band = 0;
       return q->queues[q->prio2band[band & TC_PRIO_MAX]];
     }
     band = res.classid;
   }
   band = TC_H_MIN(band) - 1;
   if (band >= q->bands) return q->queues[q->prio2band[0]];
   return q->queues[band];
 }<sep>@@
expression e1,e2,e3,e4;
@@

-       tc_classify
+       tcf_classify
	(e1,e2,e3,e4)
--- initial
+++ final
@@ -1,28 +1,28 @@
 static struct qfq_class *qfq_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr) {
   struct qfq_sched *q = qdisc_priv(sch);
   struct qfq_class *cl;
   struct tcf_result res;
   struct tcf_proto *fl;
   int result;
   if (TC_H_MAJ(skb->priority ^ sch->handle) == 0) {
     pr_debug("qfq_classify: found %d\n", skb->priority);
     cl = qfq_find_class(sch, skb->priority);
     if (cl != NULL) return cl;
   }
   *qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
   fl = rcu_dereference_bh(q->filter_list);
-  result = tc_classify(skb, fl, &res, false);
+  result = tcf_classify(skb, fl, &res, false);
   if (result >= 0) {
 #ifdef CONFIG_NET_CLS_ACT
     switch (result) {
     case TC_ACT_QUEUED:
     case TC_ACT_STOLEN: *qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
     case TC_ACT_SHOT: return NULL;
     }
 #endif
     cl = (struct qfq_class *)res.class;
     if (cl == NULL) cl = qfq_find_class(sch, res.classid);
     return cl;
   }
   return NULL;
 }<sep>@@
expression e1,e2,e3,e4;
@@

-       tc_classify
+       tcf_classify
	(e1,e2,e3,e4)
--- initial
+++ final
@@ -1,17 +1,17 @@
 static bool sfb_classify(struct sk_buff *skb, struct tcf_proto *fl, int *qerr, u32 *salt) {
   struct tcf_result res;
   int result;
-  result = tc_classify(skb, fl, &res, false);
+  result = tcf_classify(skb, fl, &res, false);
   if (result >= 0) {
 #ifdef CONFIG_NET_CLS_ACT
     switch (result) {
     case TC_ACT_STOLEN:
     case TC_ACT_QUEUED: *qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
     case TC_ACT_SHOT: return false;
     }
 #endif
     *salt = TC_H_MIN(res.classid);
     return true;
   }
   return false;
 }<sep>@@
expression e1,e2,e3,e4;
@@

-       tc_classify
+       tcf_classify
	(e1,e2,e3,e4)
--- initial
+++ final
@@ -1,22 +1,22 @@
 static unsigned int sfq_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr) {
   struct sfq_sched_data *q = qdisc_priv(sch);
   struct tcf_result res;
   struct tcf_proto *fl;
   int result;
   if (TC_H_MAJ(skb->priority) == sch->handle && TC_H_MIN(skb->priority) > 0 && TC_H_MIN(skb->priority) <= q->divisor) return TC_H_MIN(skb->priority);
   fl = rcu_dereference_bh(q->filter_list);
   if (!fl) return sfq_hash(q, skb) + 1;
   *qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
-  result = tc_classify(skb, fl, &res, false);
+  result = tcf_classify(skb, fl, &res, false);
   if (result >= 0) {
 #ifdef CONFIG_NET_CLS_ACT
     switch (result) {
     case TC_ACT_STOLEN:
     case TC_ACT_QUEUED: *qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
     case TC_ACT_SHOT: return 0;
     }
 #endif
     if (TC_H_MIN(res.classid) <= q->divisor) return TC_H_MIN(res.classid);
   }
   return 0;
 }<sep>@@
expression e1,e2,e3,e4;
@@

-       tc_classify
+       tcf_classify
	(e1,e2,e3,e4)
--- initial
+++ final
@@ -1,15 +1,15 @@
 int vmw_cmdbuf_res_add(struct vmw_cmdbuf_res_manager *man, enum vmw_cmdbuf_res_type res_type, u32 user_key, struct vmw_resource *res, struct list_head *list) {
   struct vmw_cmdbuf_res *cres;
   int ret;
   cres = kzalloc(sizeof(*cres), GFP_KERNEL);
-  if (unlikely(cres == NULL)) return -ENOMEM;
+  if (unlikely(!cres)) return -ENOMEM;
   cres->hash.key = user_key | (res_type << 24);
   ret = drm_ht_insert_item(&man->resources, &cres->hash);
   if (unlikely(ret != 0)) goto out_invalid_key;
   cres->state = VMW_CMDBUF_RES_ADD;
   cres->res = vmw_resource_reference(res);
   cres->man = man;
   list_add_tail(&cres->head, list);
 out_invalid_key:
   return ret;
 }<sep>@@
expression e1;
statement S1,S2;
@@

        e1 = \(kmalloc\|kmemdup\|kzalloc\)(...);
	if (unlikely(
-       e1 == NULL
+       !e1
	))
	S1 else S2
--- initial
+++ final
@@ -1,12 +1,12 @@
 struct vmw_cmdbuf_res_manager *vmw_cmdbuf_res_man_create(struct vmw_private *dev_priv) {
   struct vmw_cmdbuf_res_manager *man;
   int ret;
   man = kzalloc(sizeof(*man), GFP_KERNEL);
-  if (man == NULL) return ERR_PTR(-ENOMEM);
+  if (!man) return ERR_PTR(-ENOMEM);
   man->dev_priv = dev_priv;
   INIT_LIST_HEAD(&man->list);
   ret = drm_ht_create(&man->resources, VMW_CMDBUF_RES_MAN_HT_ORDER);
   if (ret == 0) return man;
   kfree(man);
   return ERR_PTR(ret);
 }<sep>@@
expression e1;
statement S1,S2;
@@

        e1 = \(kmalloc\|kmemdup\|kzalloc\)(...);
	if (unlikely(
-       e1 == NULL
+       !e1
	))
	S1 else S2

@@
expression e1;
statement S1,S2;
@@

        e1 = \(kmalloc\|kmemdup\|kzalloc\)(...);
	if (
-       e1 == NULL
+       !e1
	)
	S1 else S2
--- initial
+++ final
@@ -1,53 +1,53 @@
 static int vmw_context_define(struct drm_device *dev, void *data, struct drm_file *file_priv, bool dx) {
   struct vmw_private *dev_priv = vmw_priv(dev);
   struct vmw_user_context *ctx;
   struct vmw_resource *res;
   struct vmw_resource *tmp;
   struct drm_vmw_context_arg *arg = (struct drm_vmw_context_arg *)data;
   struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
   int ret;
   if (!dev_priv->has_dx && dx) {
     DRM_ERROR("DX contexts not supported by device.\n");
     return -EINVAL;
   }
   /*
    * Approximate idr memory usage with 128 bytes. It will be limited
    * by maximum number_of contexts anyway.
    */
   if (unlikely(vmw_user_context_size == 0)) vmw_user_context_size = ttm_round_pot(sizeof(*ctx)) + 128 + ((dev_priv->has_mob) ? vmw_cmdbuf_res_man_size() : 0);
   ret = ttm_read_lock(&dev_priv->reservation_sem, true);
   if (unlikely(ret != 0)) return ret;
   ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv), vmw_user_context_size, false, true);
   if (unlikely(ret != 0)) {
     if (ret != -ERESTARTSYS)
       DRM_ERROR("Out of graphics memory for context"
                 " creation.\n");
     goto out_unlock;
   }
   ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
-  if (unlikely(ctx == NULL)) {
+  if (unlikely(!ctx)) {
     ttm_mem_global_free(vmw_mem_glob(dev_priv), vmw_user_context_size);
     ret = -ENOMEM;
     goto out_unlock;
   }
   res = &ctx->res;
   ctx->base.shareable = false;
   ctx->base.tfile = NULL;
   /*
    * From here on, the destructor takes over resource freeing.
    */
   ret = vmw_context_init(dev_priv, res, vmw_user_context_free, dx);
   if (unlikely(ret != 0)) goto out_unlock;
   tmp = vmw_resource_reference(&ctx->res);
   ret = ttm_base_object_init(tfile, &ctx->base, false, VMW_RES_CONTEXT, &vmw_user_context_base_release, NULL);
   if (unlikely(ret != 0)) {
     vmw_resource_unreference(&tmp);
     goto out_err;
   }
   arg->cid = ctx->base.hash.key;
 out_err:
   vmw_resource_unreference(&res);
 out_unlock:
   ttm_read_unlock(&dev_priv->reservation_sem);
   return ret;
 }<sep>@@
expression e1;
statement S1,S2;
@@

        e1 = \(kmalloc\|kmemdup\|kzalloc\)(...);
	if (unlikely(
-       e1 == NULL
+       !e1
	))
	S1 else S2