imamnurby/smpl_train_seed8 huggingface dataset:
--- initial
+++ final
@@ -1,50 +1,49 @@
 static int __init loop_init(void) {
   struct rc_dev *rc;
   int ret;
-  rc = rc_allocate_device();
+  rc = rc_allocate_device(RC_DRIVER_IR_RAW);
   if (!rc) {
     printk(KERN_ERR DRIVER_NAME ": rc_dev allocation failed\n");
     return -ENOMEM;
   }
   rc->input_name = "rc-core loopback device";
   rc->input_phys = "rc-core/virtual";
   rc->input_id.bustype = BUS_VIRTUAL;
   rc->input_id.version = 1;
   rc->driver_name = DRIVER_NAME;
   rc->map_name = RC_MAP_EMPTY;
   rc->priv = &loopdev;
-  rc->driver_type = RC_DRIVER_IR_RAW;
   rc->allowed_protocols = RC_BIT_ALL_IR_DECODER;
   rc->allowed_wakeup_protocols = RC_BIT_ALL_IR_ENCODER;
   rc->encode_wakeup = true;
   rc->timeout = 100 * 1000 * 1000; /* 100 ms */
   rc->min_timeout = 1;
   rc->max_timeout = UINT_MAX;
   rc->rx_resolution = 1000;
   rc->tx_resolution = 1000;
   rc->s_tx_mask = loop_set_tx_mask;
   rc->s_tx_carrier = loop_set_tx_carrier;
   rc->s_tx_duty_cycle = loop_set_tx_duty_cycle;
   rc->s_rx_carrier_range = loop_set_rx_carrier_range;
   rc->tx_ir = loop_tx_ir;
   rc->s_idle = loop_set_idle;
   rc->s_learning_mode = loop_set_learning_mode;
   rc->s_carrier_report = loop_set_carrier_report;
   rc->s_wakeup_filter = loop_set_wakeup_filter;
   loopdev.txmask = RXMASK_REGULAR;
   loopdev.txcarrier = 36000;
   loopdev.txduty = 50;
   loopdev.rxcarriermin = 1;
   loopdev.rxcarriermax = ~0;
   loopdev.idle = true;
   loopdev.learning = false;
   loopdev.carrierreport = false;
   ret = rc_register_device(rc);
   if (ret < 0) {
     printk(KERN_ERR DRIVER_NAME ": rc_dev registration failed\n");
     rc_free_device(rc);
     return ret;
   }
   loopdev.dev = rc;
   return 0;
 }<sep>@@
expression rdev,e;
@@
-       rdev = rc_allocate_device();
+       rdev = rc_allocate_device(e);
	...
-       rdev->driver_type      = e;
--- initial
+++ final
@@ -1,36 +1,35 @@
 static struct rc_dev *redrat3_init_rc_dev(struct redrat3_dev *rr3) {
   struct device *dev = rr3->dev;
   struct rc_dev *rc;
   int ret;
   u16 prod = le16_to_cpu(rr3->udev->descriptor.idProduct);
-  rc = rc_allocate_device();
+  rc = rc_allocate_device(RC_DRIVER_IR_RAW);
   if (!rc) return NULL;
   snprintf(rr3->name, sizeof(rr3->name), "RedRat3%s Infrared Remote Transceiver", prod == USB_RR3IIUSB_PRODUCT_ID ? "-II" : "");
   usb_make_path(rr3->udev, rr3->phys, sizeof(rr3->phys));
   rc->input_name = rr3->name;
   rc->input_phys = rr3->phys;
   usb_to_input_id(rr3->udev, &rc->input_id);
   rc->dev.parent = dev;
   rc->priv = rr3;
-  rc->driver_type = RC_DRIVER_IR_RAW;
   rc->allowed_protocols = RC_BIT_ALL_IR_DECODER;
   rc->min_timeout = MS_TO_NS(RR3_RX_MIN_TIMEOUT);
   rc->max_timeout = MS_TO_NS(RR3_RX_MAX_TIMEOUT);
   rc->timeout = US_TO_NS(redrat3_get_timeout(rr3));
   rc->s_timeout = redrat3_set_timeout;
   rc->tx_ir = redrat3_transmit_ir;
   rc->s_tx_carrier = redrat3_set_tx_carrier;
   rc->s_carrier_report = redrat3_wideband_receiver;
   rc->driver_name = DRIVER_NAME;
   rc->rx_resolution = US_TO_NS(2);
   rc->map_name = RC_MAP_HAUPPAUGE;
   ret = rc_register_device(rc);
   if (ret < 0) {
     dev_err(dev, "remote dev registration failed\n");
     goto out;
   }
   return rc;
 out:
   rc_free_device(rc);
   return NULL;
 }<sep>@@
expression rdev,e;
@@
-       rdev = rc_allocate_device();
+       rdev = rc_allocate_device(e);
	...
-       rdev->driver_type      = e;
--- initial
+++ final
@@ -1,30 +1,29 @@
 int smi_ir_init(struct smi_dev *dev) {
   int ret;
   struct rc_dev *rc_dev;
   struct smi_rc *ir = &dev->ir;
-  rc_dev = rc_allocate_device();
+  rc_dev = rc_allocate_device(RC_DRIVER_SCANCODE);
   if (!rc_dev) return -ENOMEM;
   /* init input device */
   snprintf(ir->input_name, sizeof(ir->input_name), "IR (%s)", dev->info->name);
   snprintf(ir->input_phys, sizeof(ir->input_phys), "pci-%s/ir0", pci_name(dev->pci_dev));
   rc_dev->driver_name = "SMI_PCIe";
   rc_dev->input_phys = ir->input_phys;
   rc_dev->input_name = ir->input_name;
   rc_dev->input_id.bustype = BUS_PCI;
   rc_dev->input_id.version = 1;
   rc_dev->input_id.vendor = dev->pci_dev->subsystem_vendor;
   rc_dev->input_id.product = dev->pci_dev->subsystem_device;
   rc_dev->dev.parent = &dev->pci_dev->dev;
-  rc_dev->driver_type = RC_DRIVER_SCANCODE;
   rc_dev->map_name = dev->info->rc_map;
   ir->rc_dev = rc_dev;
   ir->dev = dev;
   INIT_WORK(&ir->work, smi_ir_decode);
   smi_ir_disableInterrupt(ir);
   ret = rc_register_device(rc_dev);
   if (ret) goto ir_err;
   return 0;
 ir_err:
   rc_free_device(rc_dev);
   return ret;
 }<sep>@@
expression rdev,e;
@@
-       rdev = rc_allocate_device();
+       rdev = rc_allocate_device(e);
	...
-       rdev->driver_type      = e;
--- initial
+++ final
@@ -1,38 +1,37 @@
 int sms_ir_init(struct smscore_device_t *coredev) {
   int err;
   int board_id = smscore_get_board_id(coredev);
   struct rc_dev *dev;
   pr_debug("Allocating rc device\n");
-  dev = rc_allocate_device();
+  dev = rc_allocate_device(RC_DRIVER_IR_RAW);
   if (!dev) return -ENOMEM;
   coredev->ir.controller = 0; /* Todo: vega/nova SPI number */
   coredev->ir.timeout = IR_DEFAULT_TIMEOUT;
   pr_debug("IR port %d, timeout %d ms\n", coredev->ir.controller, coredev->ir.timeout);
   snprintf(coredev->ir.name, sizeof(coredev->ir.name), "SMS IR (%s)", sms_get_board(board_id)->name);
   strlcpy(coredev->ir.phys, coredev->devpath, sizeof(coredev->ir.phys));
   strlcat(coredev->ir.phys, "/ir0", sizeof(coredev->ir.phys));
   dev->input_name = coredev->ir.name;
   dev->input_phys = coredev->ir.phys;
   dev->dev.parent = coredev->device;
 #if 0
 	/* TODO: properly initialize the parameters below */
 	dev->input_id.bustype = BUS_USB;
 	dev->input_id.version = 1;
 	dev->input_id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor);
 	dev->input_id.product = le16_to_cpu(dev->udev->descriptor.idProduct);
 #endif
   dev->priv = coredev;
-  dev->driver_type = RC_DRIVER_IR_RAW;
   dev->allowed_protocols = RC_BIT_ALL_IR_DECODER;
   dev->map_name = sms_get_board(board_id)->rc_codes;
   dev->driver_name = MODULE_NAME;
   pr_debug("Input device (IR) %s is set for key events\n", dev->input_name);
   err = rc_register_device(dev);
   if (err < 0) {
     pr_err("Failed to register device\n");
     rc_free_device(dev);
     return err;
   }
   coredev->ir.dev = dev;
   return 0;
 }<sep>@@
expression rdev,e;
@@
-       rdev = rc_allocate_device();
+       rdev = rc_allocate_device(e);
	...
-       rdev->driver_type      = e;
--- initial
+++ final
@@ -1,31 +1,30 @@
 static struct rc_dev *streamzap_init_rc_dev(struct streamzap_ir *sz) {
   struct rc_dev *rdev;
   struct device *dev = sz->dev;
   int ret;
-  rdev = rc_allocate_device();
+  rdev = rc_allocate_device(RC_DRIVER_IR_RAW);
   if (!rdev) {
     dev_err(dev, "remote dev allocation failed\n");
     goto out;
   }
   snprintf(sz->name, sizeof(sz->name), "Streamzap PC Remote Infrared Receiver (%04x:%04x)", le16_to_cpu(sz->usbdev->descriptor.idVendor), le16_to_cpu(sz->usbdev->descriptor.idProduct));
   usb_make_path(sz->usbdev, sz->phys, sizeof(sz->phys));
   strlcat(sz->phys, "/input0", sizeof(sz->phys));
   rdev->input_name = sz->name;
   rdev->input_phys = sz->phys;
   usb_to_input_id(sz->usbdev, &rdev->input_id);
   rdev->dev.parent = dev;
   rdev->priv = sz;
-  rdev->driver_type = RC_DRIVER_IR_RAW;
   rdev->allowed_protocols = RC_BIT_ALL_IR_DECODER;
   rdev->driver_name = DRIVER_NAME;
   rdev->map_name = RC_MAP_STREAMZAP;
   ret = rc_register_device(rdev);
   if (ret < 0) {
     dev_err(dev, "remote input device register failed\n");
     goto out;
   }
   return rdev;
 out:
   rc_free_device(rdev);
   return NULL;
 }<sep>@@
expression rdev,e;
@@
-       rdev = rc_allocate_device();
+       rdev = rc_allocate_device(e);
	...
-       rdev->driver_type      = e;
--- initial
+++ final
@@ -1,57 +1,56 @@
 int tm6000_ir_init(struct tm6000_core *dev) {
   struct tm6000_IR *ir;
   struct rc_dev *rc;
   int err = -ENOMEM;
   u64 rc_type;
   if (!enable_ir) return -ENODEV;
   if (!dev->caps.has_remote) return 0;
   if (!dev->ir_codes) return 0;
   ir = kzalloc(sizeof(*ir), GFP_ATOMIC);
-  rc = rc_allocate_device();
+  rc = rc_allocate_device(RC_DRIVER_SCANCODE);
   if (!ir || !rc) goto out;
   dprintk(2, "%s\n", __func__);
   /* record handles to ourself */
   ir->dev = dev;
   dev->ir = ir;
   ir->rc = rc;
   /* input setup */
   rc->allowed_protocols = RC_BIT_RC5 | RC_BIT_NEC;
   /* Neded, in order to support NEC remotes with 24 or 32 bits */
   rc->scancode_mask = 0xffff;
   rc->priv = ir;
   rc->change_protocol = tm6000_ir_change_protocol;
   if (dev->int_in.endp) {
     rc->open = __tm6000_ir_int_start;
     rc->close = __tm6000_ir_int_stop;
     INIT_DELAYED_WORK(&ir->work, tm6000_ir_int_work);
   } else {
     rc->open = tm6000_ir_start;
     rc->close = tm6000_ir_stop;
     ir->polling = 50;
     INIT_DELAYED_WORK(&ir->work, tm6000_ir_handle_key);
   }
-  rc->driver_type = RC_DRIVER_SCANCODE;
   snprintf(ir->name, sizeof(ir->name), "tm5600/60x0 IR (%s)", dev->name);
   usb_make_path(dev->udev, ir->phys, sizeof(ir->phys));
   strlcat(ir->phys, "/input0", sizeof(ir->phys));
   rc_type = RC_BIT_UNKNOWN;
   tm6000_ir_change_protocol(rc, &rc_type);
   rc->input_name = ir->name;
   rc->input_phys = ir->phys;
   rc->input_id.bustype = BUS_USB;
   rc->input_id.version = 1;
   rc->input_id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor);
   rc->input_id.product = le16_to_cpu(dev->udev->descriptor.idProduct);
   rc->map_name = dev->ir_codes;
   rc->driver_name = "tm6000";
   rc->dev.parent = &dev->udev->dev;
   /* ir register */
   err = rc_register_device(rc);
   if (err) goto out;
   return 0;
 out:
   dev->ir = NULL;
   rc_free_device(rc);
   kfree(ir);
   return err;
 }<sep>@@
expression rdev,e;
@@
-       rdev = rc_allocate_device();
+       rdev = rc_allocate_device(e);
	...
-       rdev->driver_type      = e;
--- initial
+++ final
@@ -1,30 +1,30 @@
 void acct_collect(long exitcode, int group_dead) {
   struct pacct_struct *pacct = &current->signal->pacct;
   cputime_t utime, stime;
   unsigned long vsize = 0;
   if (group_dead && current->mm) {
     struct vm_area_struct *vma;
     down_read(&current->mm->mmap_sem);
     vma = current->mm->mmap;
     while (vma) {
       vsize += vma->vm_end - vma->vm_start;
       vma = vma->vm_next;
     }
     up_read(&current->mm->mmap_sem);
   }
   spin_lock_irq(&current->sighand->siglock);
   if (group_dead) pacct->ac_mem = vsize / 1024;
   if (thread_group_leader(current)) {
     pacct->ac_exitcode = exitcode;
     if (current->flags & PF_FORKNOEXEC) pacct->ac_flag |= AFORK;
   }
   if (current->flags & PF_SUPERPRIV) pacct->ac_flag |= ASU;
   if (current->flags & PF_DUMPCORE) pacct->ac_flag |= ACORE;
   if (current->flags & PF_SIGNALED) pacct->ac_flag |= AXSIG;
-  task_cputime(current, &utime, &stime);
+  task_cputime_t(current, &utime, &stime);
   pacct->ac_utime += utime;
   pacct->ac_stime += stime;
   pacct->ac_minflt += current->min_flt;
   pacct->ac_majflt += current->maj_flt;
   spin_unlock_irq(&current->sighand->siglock);
 }<sep>@@
expression e1,e2,e3;
@@
-       task_cputime
+       task_cputime_t
		(e1,e2,e3)
--- initial
+++ final
@@ -1,52 +1,52 @@
 static int apm_cpu_idle(struct cpuidle_device *dev, struct cpuidle_driver *drv, int index) {
   static int use_apm_idle;          /* = 0 */
   static unsigned int last_jiffies; /* = 0 */
   static unsigned int last_stime;   /* = 0 */
   cputime_t stime, utime;
   int apm_idle_done = 0;
   unsigned int jiffies_since_last_check = jiffies - last_jiffies;
   unsigned int bucket;
 recalc:
-  task_cputime(current, &utime, &stime);
+  task_cputime_t(current, &utime, &stime);
   if (jiffies_since_last_check > IDLE_CALC_LIMIT) {
     use_apm_idle = 0;
   } else if (jiffies_since_last_check > idle_period) {
     unsigned int idle_percentage;
     idle_percentage = cputime_to_jiffies(stime - last_stime);
     idle_percentage *= 100;
     idle_percentage /= jiffies_since_last_check;
     use_apm_idle = (idle_percentage > idle_threshold);
     if (apm_info.forbid_idle) use_apm_idle = 0;
   }
   last_jiffies = jiffies;
   last_stime = stime;
   bucket = IDLE_LEAKY_MAX;
   while (!need_resched()) {
     if (use_apm_idle) {
       unsigned int t;
       t = jiffies;
       switch (apm_do_idle()) {
       case 0:
         apm_idle_done = 1;
         if (t != jiffies) {
           if (bucket) {
             bucket = IDLE_LEAKY_MAX;
             continue;
           }
         } else if (bucket) {
           bucket--;
           continue;
         }
         break;
       case 1: apm_idle_done = 1; break;
       default: /* BIOS refused */ break;
       }
     }
     default_idle();
     local_irq_disable();
     jiffies_since_last_check = jiffies - last_jiffies;
     if (jiffies_since_last_check > idle_period) goto recalc;
   }
   if (apm_idle_done) apm_do_busy();
   return index;
 }<sep>@@
expression e1,e2,e3;
@@
-       task_cputime
+       task_cputime_t
		(e1,e2,e3)
--- initial
+++ final
@@ -1,30 +1,30 @@
 static void fill_prstatus(struct elf_prstatus *prstatus, struct task_struct *p, long signr) {
   prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
   prstatus->pr_sigpend = p->pending.signal.sig[0];
   prstatus->pr_sighold = p->blocked.sig[0];
   rcu_read_lock();
   prstatus->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
   rcu_read_unlock();
   prstatus->pr_pid = task_pid_vnr(p);
   prstatus->pr_pgrp = task_pgrp_vnr(p);
   prstatus->pr_sid = task_session_vnr(p);
   if (thread_group_leader(p)) {
-    struct task_cputime cputime;
+    struct task_cputime_t cputime;
     /*
      * This is the record for the group leader.  It shows the
      * group-wide total, not its individual thread total.
      */
-    thread_group_cputime(p, &cputime);
+    thread_group_cputime_t(p, &cputime);
     cputime_to_timeval(cputime.utime, &prstatus->pr_utime);
     cputime_to_timeval(cputime.stime, &prstatus->pr_stime);
   } else {
     cputime_t utime, stime;
-    task_cputime(p, &utime, &stime);
+    task_cputime_t(p, &utime, &stime);
     cputime_to_timeval(utime, &prstatus->pr_utime);
     cputime_to_timeval(stime, &prstatus->pr_stime);
   }
   cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);
   cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);
   prstatus->pr_exec_fdpic_loadmap = p->mm->context.exec_fdpic_loadmap;
   prstatus->pr_interp_fdpic_loadmap = p->mm->context.interp_fdpic_loadmap;
 }<sep>@@
expression e1,e2,e3;
@@
-       task_cputime
+       task_cputime_t
		(e1,e2,e3)

@@
identifier cputime;
expression p;
@@

-	struct task_cputime cputime;
+	struct task_cputime_t cputime;
 <...
-		thread_group_cputime(p, &cputime);
+		thread_group_cputime_t(p, &cputime);
 ...>
--- initial
+++ final
@@ -1,28 +1,28 @@
 static void fill_prstatus(struct elf_prstatus *prstatus, struct task_struct *p, long signr) {
   prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
   prstatus->pr_sigpend = p->pending.signal.sig[0];
   prstatus->pr_sighold = p->blocked.sig[0];
   rcu_read_lock();
   prstatus->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
   rcu_read_unlock();
   prstatus->pr_pid = task_pid_vnr(p);
   prstatus->pr_pgrp = task_pgrp_vnr(p);
   prstatus->pr_sid = task_session_vnr(p);
   if (thread_group_leader(p)) {
-    struct task_cputime cputime;
+    struct task_cputime_t cputime;
     /*
      * This is the record for the group leader.  It shows the
      * group-wide total, not its individual thread total.
      */
-    thread_group_cputime(p, &cputime);
+    thread_group_cputime_t(p, &cputime);
     cputime_to_timeval(cputime.utime, &prstatus->pr_utime);
     cputime_to_timeval(cputime.stime, &prstatus->pr_stime);
   } else {
     cputime_t utime, stime;
-    task_cputime(p, &utime, &stime);
+    task_cputime_t(p, &utime, &stime);
     cputime_to_timeval(utime, &prstatus->pr_utime);
     cputime_to_timeval(stime, &prstatus->pr_stime);
   }
   cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);
   cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);
 }<sep>@@
expression e1,e2,e3;
@@
-       task_cputime
+       task_cputime_t
		(e1,e2,e3)

@@
identifier cputime;
expression p;
@@

-	struct task_cputime cputime;
+	struct task_cputime_t cputime;
 <...
-		thread_group_cputime(p, &cputime);
+		thread_group_cputime_t(p, &cputime);
 ...>
--- initial
+++ final
@@ -1,39 +1,39 @@
 int __delayacct_add_tsk(struct taskstats *d, struct task_struct *tsk) {
   cputime_t utime, stime, stimescaled, utimescaled;
   unsigned long long t2, t3;
   unsigned long flags, t1;
   s64 tmp;
-  task_cputime(tsk, &utime, &stime);
+  task_cputime_t(tsk, &utime, &stime);
   tmp = (s64)d->cpu_run_real_total;
   tmp += cputime_to_nsecs(utime + stime);
   d->cpu_run_real_total = (tmp < (s64)d->cpu_run_real_total) ? 0 : tmp;
-  task_cputime_scaled(tsk, &utimescaled, &stimescaled);
+  task_cputime_t_scaled(tsk, &utimescaled, &stimescaled);
   tmp = (s64)d->cpu_scaled_run_real_total;
   tmp += cputime_to_nsecs(utimescaled + stimescaled);
   d->cpu_scaled_run_real_total = (tmp < (s64)d->cpu_scaled_run_real_total) ? 0 : tmp;
   /*
    * No locking available for sched_info (and too expensive to add one)
    * Mitigate by taking snapshot of values
    */
   t1 = tsk->sched_info.pcount;
   t2 = tsk->sched_info.run_delay;
   t3 = tsk->se.sum_exec_runtime;
   d->cpu_count += t1;
   tmp = (s64)d->cpu_delay_total + t2;
   d->cpu_delay_total = (tmp < (s64)d->cpu_delay_total) ? 0 : tmp;
   tmp = (s64)d->cpu_run_virtual_total + t3;
   d->cpu_run_virtual_total = (tmp < (s64)d->cpu_run_virtual_total) ? 0 : tmp;
   /* zero XXX_total, non-zero XXX_count implies XXX stat overflowed */
   spin_lock_irqsave(&tsk->delays->lock, flags);
   tmp = d->blkio_delay_total + tsk->delays->blkio_delay;
   d->blkio_delay_total = (tmp < d->blkio_delay_total) ? 0 : tmp;
   tmp = d->swapin_delay_total + tsk->delays->swapin_delay;
   d->swapin_delay_total = (tmp < d->swapin_delay_total) ? 0 : tmp;
   tmp = d->freepages_delay_total + tsk->delays->freepages_delay;
   d->freepages_delay_total = (tmp < d->freepages_delay_total) ? 0 : tmp;
   d->blkio_count += tsk->delays->blkio_count;
   d->swapin_count += tsk->delays->swapin_count;
   d->freepages_count += tsk->delays->freepages_count;
   spin_unlock_irqrestore(&tsk->delays->lock, flags);
   return 0;
 }<sep>@@
expression e1,e2,e3;
@@
-       task_cputime
+       task_cputime_t
		(e1,e2,e3)

@@
expression e1,e2,e3;
@@
-       task_cputime_scaled
+       task_cputime_t_scaled
		(e1,e2,e3)
--- initial
+++ final
@@ -1,24 +1,24 @@
 static void get_cpu_itimer(struct task_struct *tsk, unsigned int clock_id, struct itimerval *const value) {
   cputime_t cval, cinterval;
   struct cpu_itimer *it = &tsk->signal->it[clock_id];
   spin_lock_irq(&tsk->sighand->siglock);
   cval = it->expires;
   cinterval = it->incr;
   if (cval) {
-    struct task_cputime cputime;
+    struct task_cputime_t cputime;
     cputime_t t;
     thread_group_cputimer(tsk, &cputime);
     if (clock_id == CPUCLOCK_PROF)
       t = cputime.utime + cputime.stime;
     else
       /* CPUCLOCK_VIRT */
       t = cputime.utime;
     if (cval < t) /* about to fire */
       cval = cputime_one_jiffy;
     else
       cval = cval - t;
   }
   spin_unlock_irq(&tsk->sighand->siglock);
   cputime_to_timeval(cval, &value->it_value);
   cputime_to_timeval(cinterval, &value->it_interval);
 }<sep>@@
identifier cputime;
expression p;
@@

-	struct task_cputime cputime;
+	struct task_cputime_t cputime;
 <...
-		thread_group_cputime(p, &cputime);
+		thread_group_cputime_t(p, &cputime);
 ...>
--- initial
+++ final
@@ -1,45 +1,45 @@
 static void arm_timer(struct k_itimer *timer) {
   struct task_struct *p = timer->it.cpu.task;
   struct list_head *head, *listpos;
-  struct task_cputime *cputime_expires;
+  struct task_cputime_t *cputime_expires;
   struct cpu_timer_list *const nt = &timer->it.cpu;
   struct cpu_timer_list *next;
   if (CPUCLOCK_PERTHREAD(timer->it_clock)) {
     head = p->cpu_timers;
     cputime_expires = &p->cputime_expires;
   } else {
     head = p->signal->cpu_timers;
     cputime_expires = &p->signal->cputime_expires;
   }
   head += CPUCLOCK_WHICH(timer->it_clock);
   listpos = head;
   list_for_each_entry(next, head, entry) {
     if (nt->expires < next->expires) break;
     listpos = &next->entry;
   }
   list_add(&nt->entry, listpos);
   if (listpos == head) {
     unsigned long long exp = nt->expires;
     /*
      * We are the new earliest-expiring POSIX 1.b timer, hence
      * need to update expiration cache. Take into account that
      * for process timers we share expiration cache with itimers
      * and RLIMIT_CPU and for thread timers with RLIMIT_RTTIME.
      */
     switch (CPUCLOCK_WHICH(timer->it_clock)) {
     case CPUCLOCK_PROF:
       if (expires_gt(cputime_expires->prof_exp, expires_to_cputime(exp))) cputime_expires->prof_exp = expires_to_cputime(exp);
       break;
     case CPUCLOCK_VIRT:
       if (expires_gt(cputime_expires->virt_exp, expires_to_cputime(exp))) cputime_expires->virt_exp = expires_to_cputime(exp);
       break;
     case CPUCLOCK_SCHED:
       if (cputime_expires->sched_exp == 0 || cputime_expires->sched_exp > exp) cputime_expires->sched_exp = exp;
       break;
     }
     if (CPUCLOCK_PERTHREAD(timer->it_clock))
       tick_dep_set_task(p, TICK_DEP_BIT_POSIX_TIMER);
     else
       tick_dep_set_signal(p->signal, TICK_DEP_BIT_POSIX_TIMER);
   }
 }<sep>@@
identifier cputime;
expression p;
@@

-	struct task_cputime *cputime;
+	struct task_cputime_t *cputime;
 <...
-		thread_group_cputime(p, cputime);
+		thread_group_cputime_t(p, cputime);
 ...>
--- initial
+++ final
@@ -1,64 +1,64 @@
 static void check_process_timers(struct task_struct *tsk, struct list_head *firing) {
   struct signal_struct *const sig = tsk->signal;
   unsigned long long utime, ptime, virt_expires, prof_expires;
   unsigned long long sum_sched_runtime, sched_expires;
   struct list_head *timers = sig->cpu_timers;
-  struct task_cputime cputime;
+  struct task_cputime_t cputime;
   unsigned long soft;
   /*
    * If cputimer is not running, then there are no active
    * process wide timers (POSIX 1.b, itimers, RLIMIT_CPU).
    */
   if (!READ_ONCE(tsk->signal->cputimer.running)) return;
   /*
    * Signify that a thread is checking for process timers.
    * Write access to this field is protected by the sighand lock.
    */
   sig->cputimer.checking_timer = true;
   /*
    * Collect the current process totals.
    */
   thread_group_cputimer(tsk, &cputime);
   utime = cputime_to_expires(cputime.utime);
   ptime = utime + cputime_to_expires(cputime.stime);
   sum_sched_runtime = cputime.sum_exec_runtime;
   prof_expires = check_timers_list(timers, firing, ptime);
   virt_expires = check_timers_list(++timers, firing, utime);
   sched_expires = check_timers_list(++timers, firing, sum_sched_runtime);
   /*
    * Check for the special case process timers.
    */
   check_cpu_itimer(tsk, &sig->it[CPUCLOCK_PROF], &prof_expires, ptime, SIGPROF);
   check_cpu_itimer(tsk, &sig->it[CPUCLOCK_VIRT], &virt_expires, utime, SIGVTALRM);
   soft = READ_ONCE(sig->rlim[RLIMIT_CPU].rlim_cur);
   if (soft != RLIM_INFINITY) {
     unsigned long psecs = cputime_to_secs(ptime);
     unsigned long hard = READ_ONCE(sig->rlim[RLIMIT_CPU].rlim_max);
     cputime_t x;
     if (psecs >= hard) {
       /*
        * At the hard limit, we just die.
        * No need to calculate anything else now.
        */
       __group_send_sig_info(SIGKILL, SEND_SIG_PRIV, tsk);
       return;
     }
     if (psecs >= soft) {
       /*
        * At the soft limit, send a SIGXCPU every second.
        */
       __group_send_sig_info(SIGXCPU, SEND_SIG_PRIV, tsk);
       if (soft < hard) {
         soft++;
         sig->rlim[RLIMIT_CPU].rlim_cur = soft;
       }
     }
     x = secs_to_cputime(soft);
     if (!prof_expires || x < prof_expires) { prof_expires = x; }
   }
   sig->cputime_expires.prof_exp = expires_to_cputime(prof_expires);
   sig->cputime_expires.virt_exp = expires_to_cputime(virt_expires);
   sig->cputime_expires.sched_exp = sched_expires;
   if (task_cputime_zero(&sig->cputime_expires)) stop_process_timers(sig);
   sig->cputimer.checking_timer = false;
 }<sep>@@
identifier cputime;
expression p;
@@

-	struct task_cputime cputime;
+	struct task_cputime_t cputime;
 <...
-		thread_group_cputime(p, &cputime);
+		thread_group_cputime_t(p, &cputime);
 ...>