1. 31 Aug, 2013 2 commits
    • Rafael J. Wysocki's avatar
      PM / hibernate: Create memory bitmaps after freezing user space · 8fd37a4c
      Rafael J. Wysocki authored
      The hibernation core uses special memory bitmaps during image
      creation and restoration and traditionally those bitmaps are
      allocated before freezing tasks, because in the past GFP_KERNEL
      allocations might not work after all tasks had been frozen.
      
      However, this is an anachronism, because hibernation_snapshot()
      now calls hibernate_preallocate_memory() which allocates memory
      for the image upfront anyway, so the memory bitmaps may be
      allocated after freezing user space safely.
      
      For this reason, move all of the create_basic_memory_bitmaps()
      calls after freeze_processes() and all of the corresponding
      free_basic_memory_bitmaps() calls before thaw_processes().
      
      This will allow us to hold device_hotplug_lock around hibernation
      without the need to worry about freezing issues with user space
      processes attempting to acquire it via sysfs attributes after the
      creation of memory bitmaps and before the freezing of tasks.
      Signed-off-by: default avatarRafael J. Wysocki <rafael.j.wysocki@intel.com>
      Acked-by: default avatarToshi Kani <toshi.kani@hp.com>
      8fd37a4c
    • Rafael J. Wysocki's avatar
      ACPI / scan: Change ordering of locks for device hotplug · e0ae8fee
      Rafael J. Wysocki authored
      Change the ordering of device hotplug locks in scan.c so that
      acpi_scan_lock is always acquired after device_hotplug_lock.
      
      This will make it possible to use device_hotplug_lock around some
      code paths that acquire acpi_scan_lock safely (most importantly
      system suspend and hibernation).  Apart from that, acpi_scan_lock
      is platform-specific and device_hotplug_lock is general, so the
      new ordering appears to be more appropriate from the overall
      design viewpoint.
      Signed-off-by: default avatarRafael J. Wysocki <rafael.j.wysocki@intel.com>
      Acked-by: default avatarToshi Kani <toshi.kani@hp.com>
      e0ae8fee
  2. 29 Aug, 2013 2 commits
    • Rafael J. Wysocki's avatar
      ACPI / hotplug: Remove containers synchronously · f943db40
      Rafael J. Wysocki authored
      The current protocol for handling hot remove of containers is very
      fragile and causes acpi_eject_store() to acquire acpi_scan_lock
      which may deadlock with the removal of the device that it is called
      for (the reason is that device sysfs attributes cannot be removed
      while their callbacks are being executed and ACPI device objects
      are removed under acpi_scan_lock).
      
      The problem is related to the fact that containers are handled by
      acpi_bus_device_eject() in a special way, which is to emit an
      offline uevent instead of just removing the container.  Then, user
      space is expected to handle that uevent and use the container's
      "eject" attribute to actually remove it.  That is fragile, because
      user space may fail to complete the ejection (for example, by not
      using the container's "eject" attribute at all) leaving the BIOS
      kind of in a limbo.  Moreover, if the eject event is not signaled
      for a container itself, but for its parent device object (or
      generally, for an ancestor above it in the ACPI namespace), the
      container will be removed straight away without doing that whole
      dance.
      
      For this reason, modify acpi_bus_device_eject() to remove containers
      synchronously like any other objects (user space will get its uevent
      anyway in case it does some other things in response to it) and
      remove the eject_pending ACPI device flag that is not used any more.
      This way acpi_eject_store() doesn't have a reason to acquire
      acpi_scan_lock any more and one possible deadlock scenario goes
      away (plus the code is simplified a bit).
      Reported-and-tested-by: default avatarGu Zheng <guz.fnst@cn.fujitsu.com>
      Signed-off-by: default avatarRafael J. Wysocki <rafael.j.wysocki@intel.com>
      Acked-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
      Acked-by: default avatarToshi Kani <toshi.kani@hp.com>
      f943db40
    • Rafael J. Wysocki's avatar
      driver core / ACPI: Avoid device hot remove locking issues · 5e33bc41
      Rafael J. Wysocki authored
      device_hotplug_lock is held around the acpi_bus_trim() call in
      acpi_scan_hot_remove() which generally removes devices (it removes
      ACPI device objects at least, but it may also remove "physical"
      device objects through .detach() callbacks of ACPI scan handlers).
      Thus, potentially, device sysfs attributes are removed under that
      lock and to remove those attributes it is necessary to hold the
      s_active references of their directory entries for writing.
      
      On the other hand, the execution of a .show() or .store() callback
      from a sysfs attribute is carried out with that attribute's s_active
      reference held for reading.  Consequently, if any device sysfs
      attribute that may be removed from within acpi_scan_hot_remove()
      through acpi_bus_trim() has a .store() or .show() callback which
      acquires device_hotplug_lock, the execution of that callback may
      deadlock with the removal of the attribute.  [Unfortunately, the
      "online" device attribute of CPUs and memory blocks is one of them.]
      
      To avoid such deadlocks, make all of the sysfs attribute callbacks
      that need to lock device hotplug, for example store_online(), use
      a special function, lock_device_hotplug_sysfs(), to lock device
      hotplug and return the result of that function immediately if it is
      not zero.  This will cause the s_active reference of the directory
      entry in question to be released and the syscall to be restarted
      if device_hotplug_lock cannot be acquired.
      
      [show_online() actually doesn't need to lock device hotplug, but
      it is useful to serialize it with respect to device_offline() and
      device_online() for the same device (in case user space attempts to
      run them concurrently) which can be done with the help of
      device_lock().]
      Reported-by: default avatarYasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
      Reported-and-tested-by: default avatarGu Zheng <guz.fnst@cn.fujitsu.com>
      Suggested-by: default avatarTejun Heo <tj@kernel.org>
      Signed-off-by: default avatarRafael J. Wysocki <rafael.j.wysocki@intel.com>
      Acked-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
      Acked-by: default avatarToshi Kani <toshi.kani@hp.com>
      5e33bc41
  3. 26 Aug, 2013 1 commit
  4. 25 Aug, 2013 4 commits
  5. 24 Aug, 2013 8 commits
  6. 23 Aug, 2013 17 commits
  7. 22 Aug, 2013 6 commits