cpu_relax();
 }
 
-static int load_image_and_restore(bool snapshot_test)
+static int load_image_and_restore(void)
 {
        int error;
        unsigned int flags;
        lock_device_hotplug();
        error = create_basic_memory_bitmaps();
        if (error) {
-               swsusp_close(snapshot_test);
+               swsusp_close();
                goto Unlock;
        }
 
        error = swsusp_read(&flags);
-       swsusp_close(snapshot_test);
+       swsusp_close();
        if (!error)
                error = hibernation_restore(flags & SF_PLATFORM_MODE);
 
                pm_pr_dbg("Checking hibernation image\n");
                error = swsusp_check(false);
                if (!error)
-                       error = load_image_and_restore(false);
+                       error = load_image_and_restore();
        }
        thaw_processes();
 
        /* The snapshot device should not be opened while we're running */
        if (!hibernate_acquire()) {
                error = -EBUSY;
-               swsusp_close(true);
+               swsusp_close();
                goto Unlock;
        }
 
                goto Close_Finish;
        }
 
-       error = load_image_and_restore(true);
+       error = load_image_and_restore();
        thaw_processes();
  Finish:
        pm_notifier_call_chain(PM_POST_RESTORE);
        pm_pr_dbg("Hibernation image not present or could not be loaded.\n");
        return error;
  Close_Finish:
-       swsusp_close(true);
+       swsusp_close();
        goto Finish;
 }
 
 
 extern void swsusp_free(void);
 extern int swsusp_read(unsigned int *flags_p);
 extern int swsusp_write(unsigned int flags);
-void swsusp_close(bool exclusive);
+void swsusp_close(void);
 #ifdef CONFIG_SUSPEND
 extern int swsusp_unmark(void);
 #endif
 
 err_rel:
        release_swap_writer(handle);
 err_close:
-       swsusp_close(false);
+       swsusp_close();
        return ret;
 }
 
        if (error)
                free_all_swap_pages(root_swap);
        release_swap_writer(handle);
-       swsusp_close(false);
+       swsusp_close();
 
        return error;
 }
  * @exclusive: Close the resume device which is exclusively opened.
  */
 
-void swsusp_close(bool exclusive)
+void swsusp_close(void)
 {
        if (IS_ERR(hib_resume_bdev_handle)) {
                pr_debug("Image device not initialised\n");