imamnurby/smpl_train_seed8 huggingface dataset:
--- initial
+++ final
@@ -1,31 +1,31 @@
 static int zx_vga_connector_get_modes(struct drm_connector *connector) {
   struct zx_vga *vga = to_zx_vga(connector);
   struct edid *edid;
   int ret;
   /*
    * Clear both detection bits to switch I2C bus from device
    * detecting to EDID reading.
    */
   zx_writel(vga->mmio + VGA_AUTO_DETECT_SEL, 0);
   edid = drm_get_edid(connector, &vga->ddc->adap);
   if (!edid) {
     /*
      * If EDID reading fails, we set the device state into
      * disconnected.  Locking is not required here, since the
      * VGA_AUTO_DETECT_SEL register write in irq handler cannot
      * be triggered when both detection bits are cleared as above.
      */
     zx_writel(vga->mmio + VGA_AUTO_DETECT_SEL, VGA_DETECT_SEL_NO_DEVICE);
     vga->connected = false;
     return 0;
   }
   /*
    * As edid reading succeeds, device must be connected, so we set
    * up detection bit for unplug interrupt here.
    */
   zx_writel(vga->mmio + VGA_AUTO_DETECT_SEL, VGA_DETECT_SEL_HAS_DEVICE);
-  drm_mode_connector_update_edid_property(connector, edid);
+  drm_connector_update_edid_property(connector, edid);
   ret = drm_add_edid_modes(connector, edid);
   kfree(edid);
   return ret;
 }<sep>@@
expression e1,e2;
@@
-       drm_mode_connector_update_edid_property
+       drm_connector_update_edid_property
		(e1,e2)
--- initial
+++ final
@@ -1,6 +1,6 @@
 static void hypfs_update_update(struct super_block *sb) {
   struct hypfs_sb_info *sb_info = sb->s_fs_info;
   struct inode *inode = d_inode(sb_info->update_file);
-  sb_info->last_update = get_seconds();
+  sb_info->last_update = ktime_get_seconds();
   inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
 }<sep>@@
@@
-       get_seconds()
+       ktime_get_seconds()
--- initial
+++ final
@@ -1,37 +1,37 @@
 static ssize_t hypfs_write_iter(struct kiocb *iocb, struct iov_iter *from) {
   int rc;
   struct super_block *sb = file_inode(iocb->ki_filp)->i_sb;
   struct hypfs_sb_info *fs_info = sb->s_fs_info;
   size_t count = iov_iter_count(from);
   /*
    * Currently we only allow one update per second for two reasons:
    * 1. diag 204 is VERY expensive
    * 2. If several processes do updates in parallel and then read the
    *    hypfs data, the likelihood of collisions is reduced, if we restrict
    *    the minimum update interval. A collision occurs, if during the
    *    data gathering of one process another process triggers an update
    *    If the first process wants to ensure consistent data, it has
    *    to restart data collection in this case.
    */
   mutex_lock(&fs_info->lock);
-  if (fs_info->last_update == get_seconds()) {
+  if (fs_info->last_update == ktime_get_seconds()) {
     rc = -EBUSY;
     goto out;
   }
   hypfs_delete_tree(sb->s_root);
   if (MACHINE_IS_VM)
     rc = hypfs_vm_create_files(sb->s_root);
   else
     rc = hypfs_diag_create_files(sb->s_root);
   if (rc) {
     pr_err("Updating the hypfs tree failed\n");
     hypfs_delete_tree(sb->s_root);
     goto out;
   }
   hypfs_update_update(sb);
   rc = count;
   iov_iter_advance(from, count);
 out:
   mutex_unlock(&fs_info->lock);
   return rc;
 }<sep>@@
@@
-       get_seconds()
+       ktime_get_seconds()
--- initial
+++ final
@@ -1,31 +1,31 @@
 static int rcu_torture_stall(void *args) {
   unsigned long stop_at;
   VERBOSE_TOROUT_STRING("rcu_torture_stall task started");
   if (stall_cpu_holdoff > 0) {
     VERBOSE_TOROUT_STRING("rcu_torture_stall begin holdoff");
     schedule_timeout_interruptible(stall_cpu_holdoff * HZ);
     VERBOSE_TOROUT_STRING("rcu_torture_stall end holdoff");
   }
   if (!kthread_should_stop()) {
-    stop_at = get_seconds() + stall_cpu;
+    stop_at = ktime_get_seconds() + stall_cpu;
     /* RCU CPU stall is expected behavior in following code. */
     rcu_read_lock();
     if (stall_cpu_irqsoff)
       local_irq_disable();
     else
       preempt_disable();
     pr_alert("rcu_torture_stall start on CPU %d.\n", smp_processor_id());
-    while (ULONG_CMP_LT(get_seconds(), stop_at))
+    while (ULONG_CMP_LT((unsigned long)ktime_get_seconds(), stop_at))
       continue; /* Induce RCU CPU stall warning. */
     if (stall_cpu_irqsoff)
       local_irq_enable();
     else
       preempt_enable();
     rcu_read_unlock();
     pr_alert("rcu_torture_stall end.\n");
   }
   torture_shutdown_absorb("rcu_torture_stall");
   while (!kthread_should_stop())
     schedule_timeout_interruptible(10 * HZ);
   return 0;
 }<sep>@@
expression stop_at;
typedef u32;
@@

ULONG_CMP_LT(
-            get_seconds()
+            (unsigned long) ktime_get_seconds()
           , stop_at)

@@
@@
-       get_seconds()
+       ktime_get_seconds()
--- initial
+++ final
@@ -1,46 +1,46 @@
 int zd_chip_control_leds(struct zd_chip *chip, enum led_status status) {
   const zd_addr_t a[] = {
       fw_reg_addr(chip, FW_REG_LED_LINK_STATUS),
       CR_LED,
   };
   int r;
   u16 v[ARRAY_SIZE(a)];
   struct zd_ioreq16 ioreqs[ARRAY_SIZE(a)] = {
       [0] = {fw_reg_addr(chip, FW_REG_LED_LINK_STATUS)},
       [1] = {CR_LED},
   };
   u16 other_led;
   mutex_lock(&chip->mutex);
   r = zd_ioread16v_locked(chip, v, (const zd_addr_t *)a, ARRAY_SIZE(a));
   if (r) goto out;
   other_led = chip->link_led == LED1 ? LED2 : LED1;
   switch (status) {
   case ZD_LED_OFF:
     ioreqs[0].value = FW_LINK_OFF;
     ioreqs[1].value = v[1] & ~(LED1 | LED2);
     break;
   case ZD_LED_SCANNING:
     ioreqs[0].value = FW_LINK_OFF;
     ioreqs[1].value = v[1] & ~other_led;
-    if (get_seconds() % 3 == 0) {
+    if (ktime_get_seconds() % 3 == 0) {
       ioreqs[1].value &= ~chip->link_led;
     } else {
       ioreqs[1].value |= chip->link_led;
     }
     break;
   case ZD_LED_ASSOCIATED:
     ioreqs[0].value = FW_LINK_TX;
     ioreqs[1].value = v[1] & ~other_led;
     ioreqs[1].value |= chip->link_led;
     break;
   default: r = -EINVAL; goto out;
   }
   if (v[0] != ioreqs[0].value || v[1] != ioreqs[1].value) {
     r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
     if (r) goto out;
   }
   r = 0;
 out:
   mutex_unlock(&chip->mutex);
   return r;
 }<sep>@@
@@
-       get_seconds()
+       ktime_get_seconds()
--- initial
+++ final
@@ -1,54 +1,54 @@
 static void lpfc_reset_stats(struct Scsi_Host *shost) {
   struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
   struct lpfc_hba *phba = vport->phba;
   struct lpfc_sli *psli = &phba->sli;
   struct lpfc_lnk_stat *lso = &psli->lnk_stat_offsets;
   LPFC_MBOXQ_t *pmboxq;
   MAILBOX_t *pmb;
   int rc = 0;
   if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) return;
   pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
   if (!pmboxq) return;
   memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
   pmb = &pmboxq->u.mb;
   pmb->mbxCommand = MBX_READ_STATUS;
   pmb->mbxOwner = OWN_HOST;
   pmb->un.varWords[0] = 0x1; /* reset request */
   pmboxq->context1 = NULL;
   pmboxq->vport = vport;
   if ((vport->fc_flag & FC_OFFLINE_MODE) || (!(psli->sli_flag & LPFC_SLI_ACTIVE)))
     rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
   else
     rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
   if (rc != MBX_SUCCESS) {
     if (rc != MBX_TIMEOUT) mempool_free(pmboxq, phba->mbox_mem_pool);
     return;
   }
   memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
   pmb->mbxCommand = MBX_READ_LNK_STAT;
   pmb->mbxOwner = OWN_HOST;
   pmboxq->context1 = NULL;
   pmboxq->vport = vport;
   if ((vport->fc_flag & FC_OFFLINE_MODE) || (!(psli->sli_flag & LPFC_SLI_ACTIVE)))
     rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
   else
     rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
   if (rc != MBX_SUCCESS) {
     if (rc != MBX_TIMEOUT) mempool_free(pmboxq, phba->mbox_mem_pool);
     return;
   }
   lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
   lso->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
   lso->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
   lso->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
   lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
   lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
   lso->error_frames = pmb->un.varRdLnk.crcCnt;
   if (phba->hba_flag & HBA_FCOE_MODE)
     lso->link_events = (phba->link_events >> 1);
   else
     lso->link_events = (phba->fc_eventTag >> 1);
-  psli->stats_start = get_seconds();
+  psli->stats_start = ktime_get_seconds();
   mempool_free(pmboxq, phba->mbox_mem_pool);
   return;
 }<sep>@@
@@
-       get_seconds()
+       ktime_get_seconds()
--- initial
+++ final
@@ -1,42 +1,42 @@
 static int lpfc_sli_brdrestart_s3(struct lpfc_hba *phba) {
   MAILBOX_t *mb;
   struct lpfc_sli *psli;
   volatile uint32_t word0;
   void __iomem *to_slim;
   uint32_t hba_aer_enabled;
   spin_lock_irq(&phba->hbalock);
   /* Take PCIe device Advanced Error Reporting (AER) state */
   hba_aer_enabled = phba->hba_flag & HBA_AER_ENABLED;
   psli = &phba->sli;
   /* Restart HBA */
   lpfc_printf_log(phba, KERN_INFO, LOG_SLI, "0337 Restart HBA Data: x%x x%x\n", (phba->pport) ? phba->pport->port_state : 0, psli->sli_flag);
   word0 = 0;
   mb = (MAILBOX_t *)&word0;
   mb->mbxCommand = MBX_RESTART;
   mb->mbxHc = 1;
   lpfc_reset_barrier(phba);
   to_slim = phba->MBslimaddr;
   writel(*(uint32_t *)mb, to_slim);
   readl(to_slim); /* flush */
   /* Only skip post after fc_ffinit is completed */
   if (phba->pport && phba->pport->port_state)
     word0 = 1; /* This is really setting up word1 */
   else
     word0 = 0; /* This is really setting up word1 */
   to_slim = phba->MBslimaddr + sizeof(uint32_t);
   writel(*(uint32_t *)mb, to_slim);
   readl(to_slim); /* flush */
   lpfc_sli_brdreset(phba);
   if (phba->pport) phba->pport->stopped = 0;
   phba->link_state = LPFC_INIT_START;
   phba->hba_flag = 0;
   spin_unlock_irq(&phba->hbalock);
   memset(&psli->lnk_stat_offsets, 0, sizeof(psli->lnk_stat_offsets));
-  psli->stats_start = get_seconds();
+  psli->stats_start = ktime_get_seconds();
   /* Give the INITFF and Post time to settle. */
   mdelay(100);
   /* Reset HBA AER if it was enabled, note hba_flag was reset above */
   if (hba_aer_enabled) pci_disable_pcie_error_reporting(phba->pcidev);
   lpfc_hba_down_post(phba);
   return 0;
 }<sep>@@
@@
-       get_seconds()
+       ktime_get_seconds()
--- initial
+++ final
@@ -1,22 +1,22 @@
 static int lpfc_sli_brdrestart_s4(struct lpfc_hba *phba) {
   struct lpfc_sli *psli = &phba->sli;
   uint32_t hba_aer_enabled;
   int rc;
   /* Restart HBA */
   lpfc_printf_log(phba, KERN_INFO, LOG_SLI, "0296 Restart HBA Data: x%x x%x\n", phba->pport->port_state, psli->sli_flag);
   /* Take PCIe device Advanced Error Reporting (AER) state */
   hba_aer_enabled = phba->hba_flag & HBA_AER_ENABLED;
   rc = lpfc_sli4_brdreset(phba);
   spin_lock_irq(&phba->hbalock);
   phba->pport->stopped = 0;
   phba->link_state = LPFC_INIT_START;
   phba->hba_flag = 0;
   spin_unlock_irq(&phba->hbalock);
   memset(&psli->lnk_stat_offsets, 0, sizeof(psli->lnk_stat_offsets));
-  psli->stats_start = get_seconds();
+  psli->stats_start = ktime_get_seconds();
   /* Reset HBA AER if it was enabled, note hba_flag was reset above */
   if (hba_aer_enabled) pci_disable_pcie_error_reporting(phba->pcidev);
   lpfc_hba_down_post(phba);
   lpfc_sli4_queue_destroy(phba);
   return rc;
 }<sep>@@
@@
-       get_seconds()
+       ktime_get_seconds()
--- initial
+++ final
@@ -1,7 +1,7 @@
 static void chtls_timewait(struct sock *sk) {
   struct tcp_sock *tp = tcp_sk(sk);
   tp->rcv_nxt++;
-  tp->rx_opt.ts_recent_stamp = get_seconds();
+  tp->rx_opt.ts_recent_stamp = ktime_get_seconds();
   tp->srtt_us = 0;
   tcp_time_wait(sk, TCP_TIME_WAIT, 0);
 }<sep>@@
@@
-       get_seconds()
+       ktime_get_seconds()
--- initial
+++ final
@@ -1,4 +1,4 @@
 static void tcp_store_ts_recent(struct tcp_sock *tp) {
   tp->rx_opt.ts_recent = tp->rx_opt.rcv_tsval;
-  tp->rx_opt.ts_recent_stamp = get_seconds();
+  tp->rx_opt.ts_recent_stamp = ktime_get_seconds();
 }<sep>@@
@@
-       get_seconds()
+       ktime_get_seconds()
--- initial
+++ final
@@ -1,41 +1,41 @@
 int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp) {
   const struct inet_timewait_sock *tw = inet_twsk(sktw);
   const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
   struct tcp_sock *tp = tcp_sk(sk);
   int reuse = sock_net(sk)->ipv4.sysctl_tcp_tw_reuse;
   if (reuse == 2) {
     /* Still does not detect *everything* that goes through
      * lo, since we require a loopback src or dst address
      * or direct binding to 'lo' interface.
      */
     bool loopback = false;
     if (tw->tw_bound_dev_if == LOOPBACK_IFINDEX) loopback = true;
 #if IS_ENABLED(CONFIG_IPV6)
     if (tw->tw_family == AF_INET6) {
       if (ipv6_addr_loopback(&tw->tw_v6_daddr) || (ipv6_addr_v4mapped(&tw->tw_v6_daddr) && (tw->tw_v6_daddr.s6_addr[12] == 127)) || ipv6_addr_loopback(&tw->tw_v6_rcv_saddr) || (ipv6_addr_v4mapped(&tw->tw_v6_rcv_saddr) && (tw->tw_v6_rcv_saddr.s6_addr[12] == 127))) loopback = true;
     } else
 #endif
     {
       if (ipv4_is_loopback(tw->tw_daddr) || ipv4_is_loopback(tw->tw_rcv_saddr)) loopback = true;
     }
     if (!loopback) reuse = 0;
   }
   /* With PAWS, it is safe from the viewpoint
      of data integrity. Even without PAWS it is safe provided sequence
      spaces do not overlap i.e. at data rates <= 80Mbit/sec.
      Actually, the idea is close to VJ's one, only timestamp cache is
      held not per host, but per port pair and TW bucket is used as state
      holder.
      If TW bucket has been already destroyed we fall back to VJ's scheme
      and use initial timestamp retrieved from peer table.
    */
-  if (tcptw->tw_ts_recent_stamp && (!twp || (reuse && get_seconds() - tcptw->tw_ts_recent_stamp > 1))) {
+  if (tcptw->tw_ts_recent_stamp && (!twp || (reuse && ktime_get_seconds() - tcptw->tw_ts_recent_stamp > 1))) {
     tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
     if (tp->write_seq == 0) tp->write_seq = 1;
     tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
     tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
     sock_hold(sktw);
     return 1;
   }
   return 0;
 }<sep>@@
@@
-       get_seconds()
+       ktime_get_seconds()
--- initial
+++ final
@@ -1,61 +1,61 @@
 static int shrink_tnc(struct ubifs_info *c, int nr, int age, int *contention) {
   int total_freed = 0;
   struct ubifs_znode *znode, *zprev;
-  int time = get_seconds();
+  time64_t time = ktime_get_seconds();
   ubifs_assert(mutex_is_locked(&c->umount_mutex));
   ubifs_assert(mutex_is_locked(&c->tnc_mutex));
   if (!c->zroot.znode || atomic_long_read(&c->clean_zn_cnt) == 0) return 0;
   /*
    * Traverse the TNC tree in levelorder manner, so that it is possible
    * to destroy large sub-trees. Indeed, if a znode is old, then all its
    * children are older or of the same age.
    *
    * Note, we are holding 'c->tnc_mutex', so we do not have to lock the
    * 'c->space_lock' when _reading_ 'c->clean_zn_cnt', because it is
    * changed only when the 'c->tnc_mutex' is held.
    */
   zprev = NULL;
   znode = ubifs_tnc_levelorder_next(c->zroot.znode, NULL);
   while (znode && total_freed < nr && atomic_long_read(&c->clean_zn_cnt) > 0) {
     int freed;
     /*
      * If the znode is clean, but it is in the 'c->cnext' list, this
      * means that this znode has just been written to flash as a
      * part of commit and was marked clean. They will be removed
      * from the list at end commit. We cannot change the list,
      * because it is not protected by any mutex (design decision to
      * make commit really independent and parallel to main I/O). So
      * we just skip these znodes.
      *
      * Note, the 'clean_zn_cnt' counters are not updated until
      * after the commit, so the UBIFS shrinker does not report
      * the znodes which are in the 'c->cnext' list as freeable.
      *
      * Also note, if the root of a sub-tree is not in 'c->cnext',
      * then the whole sub-tree is not in 'c->cnext' as well, so it
      * is safe to dump whole sub-tree.
      */
     if (znode->cnext) {
       /*
        * Very soon these znodes will be removed from the list
        * and become freeable.
        */
       *contention = 1;
     } else if (!ubifs_zn_dirty(znode) && abs(time - znode->time) >= age) {
       if (znode->parent)
         znode->parent->zbranch[znode->iip].znode = NULL;
       else
         c->zroot.znode = NULL;
       freed = ubifs_destroy_tnc_subtree(znode);
       atomic_long_sub(freed, &ubifs_clean_zn_cnt);
       atomic_long_sub(freed, &c->clean_zn_cnt);
       total_freed += freed;
       znode = zprev;
     }
     if (unlikely(!c->zroot.znode)) break;
     zprev = znode;
     znode = ubifs_tnc_levelorder_next(c->zroot.znode, znode);
     cond_resched();
   }
   return total_freed;
 }<sep>@@
identifier time;
@@
-       int time = get_seconds();
+       time64_t time = ktime_get_seconds();
--- initial
+++ final
@@ -1,60 +1,60 @@
 static int lookup_level0_dirty(struct ubifs_info *c, const union ubifs_key *key, struct ubifs_znode **zn, int *n) {
   int err, exact;
   struct ubifs_znode *znode;
-  unsigned long time = get_seconds();
+  time64_t time = ktime_get_seconds();
   dbg_tnck(key, "search and dirty key ");
   znode = c->zroot.znode;
   if (unlikely(!znode)) {
     znode = ubifs_load_znode(c, &c->zroot, NULL, 0);
     if (IS_ERR(znode)) return PTR_ERR(znode);
   }
   znode = dirty_cow_znode(c, &c->zroot);
   if (IS_ERR(znode)) return PTR_ERR(znode);
   znode->time = time;
   while (1) {
     struct ubifs_zbranch *zbr;
     exact = ubifs_search_zbranch(c, znode, key, n);
     if (znode->level == 0) break;
     if (*n < 0) *n = 0;
     zbr = &znode->zbranch[*n];
     if (zbr->znode) {
       znode->time = time;
       znode = dirty_cow_znode(c, zbr);
       if (IS_ERR(znode)) return PTR_ERR(znode);
       continue;
     }
     /* znode is not in TNC cache, load it from the media */
     znode = ubifs_load_znode(c, zbr, znode, *n);
     if (IS_ERR(znode)) return PTR_ERR(znode);
     znode = dirty_cow_znode(c, zbr);
     if (IS_ERR(znode)) return PTR_ERR(znode);
   }
   *zn = znode;
   if (exact || !is_hash_key(c, key) || *n != -1) {
     dbg_tnc("found %d, lvl %d, n %d", exact, znode->level, *n);
     return exact;
   }
   /*
    * See huge comment at 'lookup_level0_dirty()' what is the rest of the
    * code.
    */
   err = tnc_prev(c, &znode, n);
   if (err == -ENOENT) {
     *n = -1;
     dbg_tnc("found 0, lvl %d, n -1", znode->level);
     return 0;
   }
   if (unlikely(err < 0)) return err;
   if (keys_cmp(c, key, &znode->zbranch[*n].key)) {
     *n = -1;
     dbg_tnc("found 0, lvl %d, n -1", znode->level);
     return 0;
   }
   if (znode->cnext || !ubifs_zn_dirty(znode)) {
     znode = dirty_cow_bottom_up(c, znode);
     if (IS_ERR(znode)) return PTR_ERR(znode);
   }
   dbg_tnc("found 1, lvl %d, n %d", znode->level, *n);
   *zn = znode;
   return 1;
 }<sep>@@
identifier time;
@@
-       unsigned long time = get_seconds();
+       time64_t time = ktime_get_seconds();
--- initial
+++ final
@@ -1,29 +1,29 @@
 struct ubifs_znode *ubifs_load_znode(struct ubifs_info *c, struct ubifs_zbranch *zbr, struct ubifs_znode *parent, int iip) {
   int err;
   struct ubifs_znode *znode;
   ubifs_assert(!zbr->znode);
   /*
    * A slab cache is not presently used for znodes because the znode size
    * depends on the fanout which is stored in the superblock.
    */
   znode = kzalloc(c->max_znode_sz, GFP_NOFS);
   if (!znode) return ERR_PTR(-ENOMEM);
   err = read_znode(c, zbr->lnum, zbr->offs, zbr->len, znode);
   if (err) goto out;
   atomic_long_inc(&c->clean_zn_cnt);
   /*
    * Increment the global clean znode counter as well. It is OK that
    * global and per-FS clean znode counters may be inconsistent for some
    * short time (because we might be preempted at this point), the global
    * one is only used in shrinker.
    */
   atomic_long_inc(&ubifs_clean_zn_cnt);
   zbr->znode = znode;
   znode->parent = parent;
-  znode->time = get_seconds();
+  znode->time = ktime_get_seconds();
   znode->iip = iip;
   return znode;
 out:
   kfree(znode);
   return ERR_PTR(err);
 }<sep>@@
@@
-       get_seconds()
+       ktime_get_seconds()
--- initial
+++ final
@@ -1,11 +1,11 @@
 int journal_transaction_should_end(struct reiserfs_transaction_handle *th, int new_alloc) {
   struct reiserfs_journal *journal = SB_JOURNAL(th->t_super);
-  time_t now = get_seconds();
+  time64_t now = ktime_get_seconds();
   /* cannot restart while nested */
   BUG_ON(!th->t_trans_id);
   if (th->t_refcount > 1) return 0;
   if (journal->j_must_wait > 0 || (journal->j_len_alloc + new_alloc) >= journal->j_max_batch || atomic_read(&journal->j_jlock) || (now - journal->j_trans_start_time) > journal->j_max_trans_age || journal->j_cnode_free < (journal->j_trans_max * 3)) { return 1; }
   journal->j_len_alloc += new_alloc;
   th->t_blocks_allocated += new_alloc;
   return 0;
 }<sep>@@
identifier time;
@@
-       time_t time = get_seconds();
+       time64_t time = ktime_get_seconds();
--- initial
+++ final
@@ -1,27 +1,27 @@
 void reiserfs_flush_old_commits(struct super_block *sb) {
-  time_t now;
+  time64_t now;
   struct reiserfs_transaction_handle th;
   struct reiserfs_journal *journal = SB_JOURNAL(sb);
-  now = get_seconds();
+  now = ktime_get_seconds();
   /*
    * safety check so we don't flush while we are replaying the log during
    * mount
    */
   if (list_empty(&journal->j_journal_list)) return;
   /*
    * check the current transaction.  If there are no writers, and it is
    * too old, finish it, and force the commit blocks to disk
    */
   if (atomic_read(&journal->j_wcount) <= 0 && journal->j_trans_start_time > 0 && journal->j_len > 0 && (now - journal->j_trans_start_time) > journal->j_max_trans_age) {
     if (!journal_join(&th, sb)) {
       reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb), 1);
       journal_mark_dirty(&th, SB_BUFFER_WITH_SB(sb));
       /*
        * we're only being called from kreiserfsd, it makes
        * no sense to do an async commit so that kreiserfsd
        * can do it later
        */
       do_journal_end(&th, COMMIT_NOW | WAIT);
     }
   }
 }<sep>@@
identifier time;
@@
-       time_t time;
+       time64_t time;
	<+...
	time =
-       get_seconds()
+       ktime_get_seconds()
	...+>