ret = tcf_idr_check_alloc(tn, &index, act, bind);
        if (!ret) {
                ret = tcf_idr_create(tn, index, est, act,
-                                    &act_bpf_ops, bind, true, 0);
+                                    &act_bpf_ops, bind, true, flags);
                if (ret < 0) {
                        tcf_idr_cleanup(tn, index);
                        return ret;
 
        ret = tcf_idr_check_alloc(tn, &index, a, bind);
        if (!ret) {
                ret = tcf_idr_create(tn, index, est, a,
-                                    &act_connmark_ops, bind, false, 0);
+                                    &act_connmark_ops, bind, false, flags);
                if (ret) {
                        tcf_idr_cleanup(tn, index);
                        return ret;
 
        err = tcf_idr_check_alloc(tn, &index, a, bind);
        if (!err) {
                ret = tcf_idr_create(tn, index, est, a,
-                                    &act_ctinfo_ops, bind, false, 0);
+                                    &act_ctinfo_ops, bind, false, flags);
                if (ret) {
                        tcf_idr_cleanup(tn, index);
                        return ret;
 
 
        if (!err) {
                ret = tcf_idr_create(tn, index, est, a,
-                                    &act_gate_ops, bind, false, 0);
+                                    &act_gate_ops, bind, false, flags);
                if (ret) {
                        tcf_idr_cleanup(tn, index);
                        return ret;
 
 
        if (!exists) {
                ret = tcf_idr_create(tn, index, est, a, &act_ife_ops,
-                                    bind, true, 0);
+                                    bind, true, flags);
                if (ret) {
                        tcf_idr_cleanup(tn, index);
                        kfree(p);
 
 
        if (!exists) {
                ret = tcf_idr_create(tn, index, est, a, ops, bind,
-                                    false, 0);
+                                    false, flags);
                if (ret) {
                        tcf_idr_cleanup(tn, index);
                        return ret;
 
 
        if (!exists) {
                ret = tcf_idr_create(tn, index, est, a,
-                                    &act_mpls_ops, bind, true, 0);
+                                    &act_mpls_ops, bind, true, flags);
                if (ret) {
                        tcf_idr_cleanup(tn, index);
                        return ret;
 
        err = tcf_idr_check_alloc(tn, &index, a, bind);
        if (!err) {
                ret = tcf_idr_create(tn, index, est, a,
-                                    &act_nat_ops, bind, false, 0);
+                                    &act_nat_ops, bind, false, flags);
                if (ret) {
                        tcf_idr_cleanup(tn, index);
                        return ret;
 
        err = tcf_idr_check_alloc(tn, &index, a, bind);
        if (!err) {
                ret = tcf_idr_create(tn, index, est, a,
-                                    &act_pedit_ops, bind, false, 0);
+                                    &act_pedit_ops, bind, false, flags);
                if (ret) {
                        tcf_idr_cleanup(tn, index);
                        goto out_free;
 
 
        if (!exists) {
                ret = tcf_idr_create(tn, index, NULL, a,
-                                    &act_police_ops, bind, true, 0);
+                                    &act_police_ops, bind, true, flags);
                if (ret) {
                        tcf_idr_cleanup(tn, index);
                        return ret;
 
 
        if (!exists) {
                ret = tcf_idr_create(tn, index, est, a,
-                                    &act_sample_ops, bind, true, 0);
+                                    &act_sample_ops, bind, true, flags);
                if (ret) {
                        tcf_idr_cleanup(tn, index);
                        return ret;
 
 
        if (!exists) {
                ret = tcf_idr_create(tn, index, est, a,
-                                    &act_simp_ops, bind, false, 0);
+                                    &act_simp_ops, bind, false, flags);
                if (ret) {
                        tcf_idr_cleanup(tn, index);
                        return ret;
 
 
        if (!exists) {
                ret = tcf_idr_create(tn, index, est, a,
-                                    &act_skbedit_ops, bind, true, 0);
+                                    &act_skbedit_ops, bind, true, act_flags);
                if (ret) {
                        tcf_idr_cleanup(tn, index);
                        return ret;
 
 
        if (!exists) {
                ret = tcf_idr_create(tn, index, est, a,
-                                    &act_skbmod_ops, bind, true, 0);
+                                    &act_skbmod_ops, bind, true, flags);
                if (ret) {
                        tcf_idr_cleanup(tn, index);
                        return ret;