--- initial
+++ final
@@ -1,73 +1,73 @@
 static int check_journal_end(struct reiserfs_transaction_handle *th, int flags) {
-  time_t now;
+  time64_t now;
   int flush = flags & FLUSH_ALL;
   int commit_now = flags & COMMIT_NOW;
   int wait_on_commit = flags & WAIT;
   struct reiserfs_journal_list *jl;
   struct super_block *sb = th->t_super;
   struct reiserfs_journal *journal = SB_JOURNAL(sb);
   BUG_ON(!th->t_trans_id);
   if (th->t_trans_id != journal->j_trans_id) { reiserfs_panic(th->t_super, "journal-1577", "handle trans id %ld != current trans id %ld", th->t_trans_id, journal->j_trans_id); }
   journal->j_len_alloc -= (th->t_blocks_allocated - th->t_blocks_logged);
   /* <= 0 is allowed.  unmounting might not call begin */
   if (atomic_read(&journal->j_wcount) > 0) atomic_dec(&journal->j_wcount);
   /*
    * BUG, deal with case where j_len is 0, but people previously
    * freed blocks need to be released will be dealt with by next
    * transaction that actually writes something, but should be taken
    * care of in this trans
    */
   BUG_ON(journal->j_len == 0);
   /*
    * if wcount > 0, and we are called to with flush or commit_now,
    * we wait on j_join_wait.  We will wake up when the last writer has
    * finished the transaction, and started it on its way to the disk.
    * Then, we flush the commit or journal list, and just return 0
    * because the rest of journal end was already done for this
    * transaction.
    */
   if (atomic_read(&journal->j_wcount) > 0) {
     if (flush || commit_now) {
       unsigned trans_id;
       jl = journal->j_current_jl;
       trans_id = jl->j_trans_id;
       if (wait_on_commit) jl->j_state |= LIST_COMMIT_PENDING;
       atomic_set(&journal->j_jlock, 1);
       if (flush) { journal->j_next_full_flush = 1; }
       unlock_journal(sb);
       /*
        * sleep while the current transaction is
        * still j_jlocked
        */
       while (journal->j_trans_id == trans_id) {
         if (atomic_read(&journal->j_jlock)) {
           queue_log_writer(sb);
         } else {
           lock_journal(sb);
           if (journal->j_trans_id == trans_id) { atomic_set(&journal->j_jlock, 1); }
           unlock_journal(sb);
         }
       }
       BUG_ON(journal->j_trans_id == trans_id);
       if (commit_now && journal_list_still_alive(sb, trans_id) && wait_on_commit) { flush_commit_list(sb, jl, 1); }
       return 0;
     }
     unlock_journal(sb);
     return 0;
   }
   /* deal with old transactions where we are the last writers */
-  now = get_seconds();
+  now = ktime_get_seconds();
   if ((now - journal->j_trans_start_time) > journal->j_max_trans_age) {
     commit_now = 1;
     journal->j_next_async_flush = 1;
   }
   /* don't batch when someone is waiting on j_join_wait */
   /* don't batch when syncing the commit or flushing the whole trans */
   if (!(journal->j_must_wait > 0) && !(atomic_read(&journal->j_jlock)) && !flush && !commit_now && (journal->j_len < journal->j_max_batch) && journal->j_len_alloc < journal->j_max_batch && journal->j_cnode_free > (journal->j_trans_max * 3)) {
     journal->j_bcount++;
     unlock_journal(sb);
     return 0;
   }
   if (journal->j_start > SB_ONDISK_JOURNAL_SIZE(sb)) { reiserfs_panic(sb, "journal-003", "j_start (%ld) is too high", journal->j_start); }
   return 1;
 }<sep>@@
identifier time;
@@
-       time_t time;
+       time64_t time;
	<+...
	time =
-       get_seconds()
+       ktime_get_seconds()
	...+>