--- initial
+++ final
@@ -1,90 +1,90 @@
 static int do_journal_begin_r(struct reiserfs_transaction_handle *th, struct super_block *sb, unsigned long nblocks, int join) {
-  time_t now = get_seconds();
+  time64_t now = ktime_get_seconds();
   unsigned int old_trans_id;
   struct reiserfs_journal *journal = SB_JOURNAL(sb);
   struct reiserfs_transaction_handle myth;
   int sched_count = 0;
   int retval;
   int depth;
   reiserfs_check_lock_depth(sb, "journal_begin");
   BUG_ON(nblocks > journal->j_trans_max);
   PROC_INFO_INC(sb, journal.journal_being);
   /* set here for journal_join */
   th->t_refcount = 1;
   th->t_super = sb;
 relock:
   lock_journal(sb);
   if (join != JBEGIN_ABORT && reiserfs_is_journal_aborted(journal)) {
     unlock_journal(sb);
     retval = journal->j_errno;
     goto out_fail;
   }
   journal->j_bcount++;
   if (test_bit(J_WRITERS_BLOCKED, &journal->j_state)) {
     unlock_journal(sb);
     depth = reiserfs_write_unlock_nested(sb);
     reiserfs_wait_on_write_block(sb);
     reiserfs_write_lock_nested(sb, depth);
     PROC_INFO_INC(sb, journal.journal_relock_writers);
     goto relock;
   }
-  now = get_seconds();
+  now = ktime_get_seconds();
   /*
    * if there is no room in the journal OR
    * if this transaction is too old, and we weren't called joinable,
    * wait for it to finish before beginning we don't sleep if there
    * aren't other writers
    */
   if ((!join && journal->j_must_wait > 0) || (!join && (journal->j_len_alloc + nblocks + 2) >= journal->j_max_batch) || (!join && atomic_read(&journal->j_wcount) > 0 && journal->j_trans_start_time > 0 && (now - journal->j_trans_start_time) > journal->j_max_trans_age) || (!join && atomic_read(&journal->j_jlock)) || (!join && journal->j_cnode_free < (journal->j_trans_max * 3))) {
     old_trans_id = journal->j_trans_id;
     /* allow others to finish this transaction */
     unlock_journal(sb);
     if (!join && (journal->j_len_alloc + nblocks + 2) >= journal->j_max_batch && ((journal->j_len + nblocks + 2) * 100) < (journal->j_len_alloc * 75)) {
       if (atomic_read(&journal->j_wcount) > 10) {
         sched_count++;
         queue_log_writer(sb);
         goto relock;
       }
     }
     /*
      * don't mess with joining the transaction if all we
      * have to do is wait for someone else to do a commit
      */
     if (atomic_read(&journal->j_jlock)) {
       while (journal->j_trans_id == old_trans_id && atomic_read(&journal->j_jlock)) {
         queue_log_writer(sb);
       }
       goto relock;
     }
     retval = journal_join(&myth, sb);
     if (retval) goto out_fail;
     /* someone might have ended the transaction while we joined */
     if (old_trans_id != journal->j_trans_id) {
       retval = do_journal_end(&myth, 0);
     } else {
       retval = do_journal_end(&myth, COMMIT_NOW);
     }
     if (retval) goto out_fail;
     PROC_INFO_INC(sb, journal.journal_relock_wcount);
     goto relock;
   }
   /* we are the first writer, set trans_id */
-  if (journal->j_trans_start_time == 0) { journal->j_trans_start_time = get_seconds(); }
+  if (journal->j_trans_start_time == 0) { journal->j_trans_start_time = ktime_get_seconds(); }
   atomic_inc(&journal->j_wcount);
   journal->j_len_alloc += nblocks;
   th->t_blocks_logged = 0;
   th->t_blocks_allocated = nblocks;
   th->t_trans_id = journal->j_trans_id;
   unlock_journal(sb);
   INIT_LIST_HEAD(&th->t_list);
   return 0;
 out_fail:
   memset(th, 0, sizeof(*th));
   /*
    * Re-set th->t_super, so we can properly keep track of how many
    * persistent transactions there are. We need to do this so if this
    * call is part of a failed restart_transaction, we can free it later
    */
   th->t_super = sb;
   return retval;
 }<sep>@@
identifier time;
@@
-       time_t time = get_seconds();
+       time64_t time = ktime_get_seconds();

@@
@@
-       get_seconds()
+       ktime_get_seconds()