1. 24 7月, 2018 19 次提交
    • L
      PCI: pciehp: Tolerate initially unstable link · 6c35a1ac
      Lukas Wunner 提交于
      When a device is hotplugged, Presence Detect and Link Up events often do
      not occur simultaneously, but with a lag of a few milliseconds.  Only
      the first event received is relevant, the other one can be disregarded.
      
      Moreover, Stefan Roese reports that on certain platforms, Link State and
      Presence Detect may flap for up to 100 ms before stabilizing, suggesting
      that such events should be disregarded for at least this long:
      https://lkml.kernel.org/r/20180130084121.18653-1-sr@denx.de
      
      On slot enablement, pciehp_check_link_status() waits for 100 ms per
      PCIe r4.0, sec 6.7.3.3, then probes the hotplugged device's vendor
      register for up to 1 second.
      
      If this succeeds, the link is definitely up, so ignore any Presence
      Detect or Link State events that occurred up to this point.
      
      pciehp_check_link_status() then checks the Link Training bit in the
      Link Status register.  This is the final opportunity to detect
      inaccessibility of the device and abort slot enablement.  Any link
      or presence change that occurs afterwards will cause the slot to be
      disabled again immediately after attempting to enable it.
      
      The astute reviewer may appreciate that achieving this behavior would be
      more complicated had pciehp not just been converted to enable/disable
      the slot exclusively from the IRQ thread:  When the slot is enabled via
      sysfs, each link or presence flap would otherwise cause the IRQ thread
      to run and it would have to sense that those events are belonging to a
      concurrent slot enablement operation and disregard them.  It would be
      much more difficult than this mere 3 line change.
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      Cc: Stefan Roese <sr@denx.de>
      6c35a1ac
    • L
      PCI: pciehp: Declare pciehp_enable/disable_slot() static · 25c83b84
      Lukas Wunner 提交于
      No callers of pciehp_enable/disable_slot() outside of pciehp_ctrl.c
      remain, so declare the functions static.  For now this requires forward
      declarations.  Those can be eliminated by reshuffling functions once the
      ongoing effort to refactor the driver has settled.
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      25c83b84
    • L
      PCI: pciehp: Drop enable/disable lock · 1656716d
      Lukas Wunner 提交于
      Previously slot enablement and disablement could happen concurrently.
      But now it's under the exclusive control of the IRQ thread, rendering
      the locking obsolete.  Drop it.
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      1656716d
    • L
      PCI: pciehp: Enable/disable exclusively from IRQ thread · 32a8cef2
      Lukas Wunner 提交于
      Besides the IRQ thread, there are several other places in the driver
      which enable or disable the slot:
      
      - pciehp_probe() enables the slot if it's occupied and the pciehp_force
        module parameter is used.
      
      - pciehp_resume() enables or disables the slot after system sleep.
      
      - pciehp_queue_pushbutton_work() enables or disables the slot after the
        5 second delay following an Attention Button press.
      
      - pciehp_sysfs_enable_slot() and pciehp_sysfs_disable_slot() enable or
        disable the slot on sysfs write.
      
      This requires locking and complicates pciehp's state machine.
      
      A simplification can be achieved by enabling and disabling the slot
      exclusively from the IRQ thread.
      
      Amend the functions listed above to request slot enable/disablement from
      the IRQ thread by either synthesizing a Presence Detect Changed event or,
      in the case of a disable user request (via sysfs or an Attention Button
      press), submitting a newly introduced force disable request.  The latter
      is needed because the slot shall be forced off despite being occupied.
      For this force disable request, avoid colliding with Slot Status register
      bits by using a bit number greater than 16.
      
      For synchronous execution of requests (on sysfs write), wait for the
      request to finish and retrieve the result.  There can only ever be one
      sysfs write in flight due to the locking in kernfs_fop_write(), hence
      there is no risk of returning the result of a different sysfs request to
      user space.
      
      The POWERON_STATE and POWEROFF_STATE is now no longer entered by the
      above-listed functions, but solely by the IRQ thread when it begins a
      power transition.  Afterwards, it moves to STATIC_STATE.  The same
      applies to canceling the Attention Button work, it likewise becomes an
      IRQ thread only operation.
      
      An immediate consequence is that the POWERON_STATE and POWEROFF_STATE is
      never observed by the IRQ thread itself, only by functions called in a
      different context, such as pciehp_sysfs_enable_slot().  So remove
      handling of these states from pciehp_handle_button_press() and
      pciehp_handle_link_change() which are exclusively called from the IRQ
      thread.
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      32a8cef2
    • L
      PCI: pciehp: Track enable/disable status · 9590192f
      Lukas Wunner 提交于
      handle_button_press_event() currently determines whether the slot has
      been turned on or off by looking at the Power Controller Control bit in
      the Slot Control register.  This assumes that an attention button
      implies presence of a power controller even though that's not mandated
      by the spec.  Moreover the Power Controller Control bit is unreliable
      when a power fault occurs (PCIe r4.0, sec 6.7.1.8).  This issue has
      existed since the driver was introduced in 2004.
      
      Fix by replacing STATIC_STATE with ON_STATE and OFF_STATE and tracking
      whether the slot has been turned on or off.  This is also a required
      ingredient to make pciehp resilient to missed events, which is the
      object of an upcoming commit.
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      9590192f
    • L
      PCI: pciehp: Publish to user space last on probe · 774d446b
      Lukas Wunner 提交于
      The PCI hotplug core has just been refactored to separate slot
      initialization for in-kernel use from publication to user space.
      
      Take advantage of it in pciehp by publishing to user space last on
      probe.  This will allow enable/disablement of the slot exclusively from
      the IRQ thread because the IRQ is requested after initialization for
      in-kernel use (thereby getting its unique name needed by the IRQ thread)
      but before user space is able to submit enable/disable requests.
      
      On teardown, the order is the same in reverse:  The user space interface
      is removed prior to freeing the IRQ and destroying the slot.
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      774d446b
    • L
      PCI: hotplug: Demidlayer registration with the core · 51bbf9be
      Lukas Wunner 提交于
      When a hotplug driver calls pci_hp_register(), all steps necessary for
      registration are carried out in one go, including creation of a kobject
      and addition to sysfs.  That's a problem for pciehp once it's converted
      to enable/disable the slot exclusively from the IRQ thread:  The thread
      needs to be spawned after creation of the kobject (because it uses the
      kobject's name), but before addition to sysfs (because it will handle
      enable/disable requests submitted via sysfs).
      
      pci_hp_deregister() does offer a ->release callback that's invoked
      after deletion from sysfs and before destruction of the kobject.  But
      because pci_hp_register() doesn't offer a counterpart, hotplug drivers'
      ->probe and ->remove code becomes asymmetric, which is error prone
      as recently discovered use-after-free bugs in pciehp's ->remove hook
      have shown.
      
      In a sense, this appears to be a case of the midlayer antipattern:
      
         "The core thesis of the "midlayer mistake" is that midlayers are
          bad and should not exist.  That common functionality which it is
          so tempting to put in a midlayer should instead be provided as
          library routines which can [be] used, augmented, or ignored by
          each bottom level driver independently.  Thus every subsystem
          that supports multiple implementations (or drivers) should
          provide a very thin top layer which calls directly into the
          bottom layer drivers, and a rich library of support code that
          eases the implementation of those drivers.  This library is
          available to, but not forced upon, those drivers."
              --  Neil Brown (2009), https://lwn.net/Articles/336262/
      
      The presence of midlayer traits in the PCI hotplug core might be ascribed
      to its age:  When it was introduced in February 2002, the blessings of a
      library approach might not have been well known:
      https://git.kernel.org/tglx/history/c/a8a2069f432c
      
      For comparison, the driver core does offer split functions for creating
      a kobject (device_initialize()) and addition to sysfs (device_add()) as
      an alternative to carrying out everything at once (device_register()).
      This was introduced in October 2002:
      https://git.kernel.org/tglx/history/c/8b290eb19962
      
      The odd ->release callback in the PCI hotplug core was added in 2003:
      https://git.kernel.org/tglx/history/c/69f8d663b595
      
      Clearly, a library approach would not force every hotplug driver to
      implement a ->release callback, but rather allow the driver to remove
      the sysfs files, release its data structures and finally destroy the
      kobject.  Alternatively, a driver may choose to remove everything with
      pci_hp_deregister(), then release its data structures.
      
      To this end, offer drivers pci_hp_initialize() and pci_hp_add() as a
      split-up version of pci_hp_register().  Likewise, offer pci_hp_del()
      and pci_hp_destroy() as a split-up version of pci_hp_deregister().
      
      Eliminate the ->release callback and move its code into each driver's
      teardown routine.
      
      Declare pci_hp_deregister() void, in keeping with the usual kernel
      pattern that enablement can fail, but disablement cannot.  It only
      returned an error if the caller passed in a NULL pointer or a slot which
      has never or is no longer registered or is sharing its name with another
      slot.  Those would be bugs, so WARN about them.  Few hotplug drivers
      actually checked the return value and those that did only printed a
      useless error message to dmesg.  Remove that.
      
      For most drivers the conversion was straightforward since it doesn't
      matter whether the code in the ->release callback is executed before or
      after destruction of the kobject.  But in the case of ibmphp, it was
      unclear to me whether setting slot_cur->ctrl and slot_cur->bus_on to
      NULL needs to happen before the kobject is destroyed, so I erred on
      the side of caution and ensured that the order stays the same.  Another
      nontrivial case is pnv_php, I've found the list and kref logic difficult
      to understand, however my impression was that it is safe to delete the
      list element and drop the references until after the kobject is
      destroyed.
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      Acked-by: Andy Shevchenko <andy.shevchenko@gmail.com>  # drivers/platform/x86
      Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
      Cc: Len Brown <lenb@kernel.org>
      Cc: Scott Murray <scott@spiteful.org>
      Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
      Cc: Paul Mackerras <paulus@samba.org>
      Cc: Michael Ellerman <mpe@ellerman.id.au>
      Cc: Gavin Shan <gwshan@linux.vnet.ibm.com>
      Cc: Sebastian Ott <sebott@linux.vnet.ibm.com>
      Cc: Gerald Schaefer <gerald.schaefer@de.ibm.com>
      Cc: Corentin Chary <corentin.chary@gmail.com>
      Cc: Darren Hart <dvhart@infradead.org>
      Cc: Andy Shevchenko <andy@infradead.org>
      51bbf9be
    • L
      PCI: pciehp: Drop slot workqueue · 55a6b7a6
      Lukas Wunner 提交于
      Previously the slot workqueue was used to handle events and enable or
      disable the slot.  That's no longer the case as those tasks are done
      synchronously in the IRQ thread.  The slot workqueue is thus merely used
      to handle a button press after the 5 second delay and only one such work
      item may be in flight at any given time.  A separate workqueue isn't
      necessary for this simple task, so use the system workqueue instead.
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      55a6b7a6
    • L
      PCI: pciehp: Handle events synchronously · 0e94916e
      Lukas Wunner 提交于
      Up until now, pciehp's IRQ handler schedules a work item for each event,
      which in turn schedules a work item to enable or disable the slot.  This
      double indirection was necessary because sleeping wasn't allowed in the
      IRQ handler.
      
      However it is now that pciehp has been converted to threaded IRQ handling
      and polling, so handle events synchronously in pciehp_ist() and remove
      the work item infrastructure (with the exception of work items to handle
      a button press after the 5 second delay).
      
      For link or presence change events, move the register read to determine
      the current link or presence state behind acquisition of the slot lock
      to prevent it from becoming stale while the lock is contended.
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      0e94916e
    • L
      PCI: pciehp: Stop blinking on slot enable failure · b0ccd9dd
      Lukas Wunner 提交于
      If the attention button is pressed to power on the slot AND the user
      powers on the slot via sysfs before 5 seconds have elapsed AND powering
      on the slot fails because either the slot is unoccupied OR the latch is
      open, we neglect turning off the green LED so it keeps on blinking.
      
      That's because the error path of pciehp_sysfs_enable_slot() doesn't call
      pciehp_green_led_off(), unlike pciehp_power_thread() which does.
      The bug has been present since 2004 when the driver was introduced.
      
      Fix by deduplicating common code in pciehp_sysfs_enable_slot() and
      pciehp_power_thread() into a wrapper function pciehp_enable_slot() and
      renaming the existing function to __pciehp_enable_slot().  Same for
      pciehp_disable_slot().  This will also simplify the upcoming rework of
      pciehp's event handling.
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      b0ccd9dd
    • L
      PCI: pciehp: Convert to threaded polling · ec07a447
      Lukas Wunner 提交于
      We've just converted pciehp to threaded IRQ handling, but still cannot
      sleep in pciehp_ist() because the function is also called in poll mode,
      which runs in softirq context (from a timer).
      
      Convert poll mode to a kthread so that pciehp_ist() always runs in task
      context.
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      Cc: Thomas Gleixner <tglx@linutronix.de>
      ec07a447
    • L
      PCI: pciehp: Convert to threaded IRQ · 7b4ce26b
      Lukas Wunner 提交于
      pciehp's IRQ handler queues up a work item for each event signaled by
      the hardware.  A more modern alternative is to let a long running
      kthread service the events.  The IRQ handler's sole job is then to check
      whether the IRQ originated from the device in question, acknowledge its
      receipt to the hardware to quiesce the interrupt and wake up the kthread.
      
      One benefit is reduced latency to handle the IRQ, which is a necessity
      for realtime environments.  Another benefit is that we can make pciehp
      simpler and more robust by handling events synchronously in process
      context, rather than asynchronously by queueing up work items.  pciehp's
      usage of work items is a historic artifact, it predates the introduction
      of threaded IRQ handlers by two years.  (The former was introduced in
      2007 with commit 5d386e1a ("pciehp: Event handling rework"), the
      latter in 2009 with commit 3aa551c9 ("genirq: add threaded interrupt
      handler support").)
      
      Convert pciehp to threaded IRQ handling by retrieving the pending events
      in pciehp_isr(), saving them for later consumption by the thread handler
      pciehp_ist() and clearing them in the Slot Status register.
      
      By clearing the Slot Status (and thereby acknowledging the events) in
      pciehp_isr(), we can avoid requesting the IRQ with IRQF_ONESHOT, which
      would have the unpleasant side effect of starving devices sharing the
      IRQ until pciehp_ist() has finished.
      
      pciehp_isr() does not count how many times each event occurred, but
      merely records the fact *that* an event occurred.  If the same event
      occurs a second time before pciehp_ist() is woken, that second event
      will not be recorded separately, which is problematic according to
      commit fad214b0 ("PCI: pciehp: Process all hotplug events before
      looking for new ones") because we may miss removal of a card in-between
      two back-to-back insertions.  We're about to make pciehp_ist() resilient
      to missed events.  The present commit regresses the driver's behavior
      temporarily in order to separate the changes into reviewable chunks.
      This doesn't affect regular slow-motion hotplug, only plug-unplug-plug
      operations that happen in a timespan shorter than wakeup of the IRQ
      thread.
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      Cc: Thomas Gleixner <tglx@linutronix.de>
      Cc: Mayurkumar Patel <mayurkumar.patel@intel.com>
      Cc: Kenji Kaneshige <kaneshige.kenji@jp.fujitsu.com>
      7b4ce26b
    • L
      PCI: pciehp: Document struct slot and struct controller · 4aed1cd6
      Lukas Wunner 提交于
      Document the driver's data structures to lower the barrier to entry for
      contributors.
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      4aed1cd6
    • L
      PCI: pciehp: Declare pciehp_unconfigure_device() void · 1d2e2673
      Lukas Wunner 提交于
      Since commit 0f4bd801 ("PCI: hotplug: Drop checking of PCI_BRIDGE_
      CONTROL in *_unconfigure_device()"), pciehp_unconfigure_device() can no
      longer fail, so declare it and its sole caller remove_board() void, in
      keeping with the usual kernel pattern that enablement can fail, but
      disablement cannot.  No functional change intended.
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      Cc: Mika Westerberg <mika.westerberg@linux.intel.com>
      1d2e2673
    • L
      PCI: pciehp: Drop unnecessary NULL pointer check · 6641311d
      Lukas Wunner 提交于
      pciehp_disable_slot() checks if the ctrl attribute of the slot is NULL
      and bails out if so.  However the function is not called prior to the
      attribute being set in pcie_init_slot(), and pcie_init_slot() is not
      called if ctrl is NULL.  So the check is unnecessary.  Drop it.
      
      It has been present ever since the driver was introduced in 2004, but it
      was already unnecessary back then:
      https://git.kernel.org/tglx/history/c/c16b4b14d980Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      6641311d
    • L
      PCI: pciehp: Fix unprotected list iteration in IRQ handler · 1204e35b
      Lukas Wunner 提交于
      Commit b440bde7 ("PCI: Add pci_ignore_hotplug() to ignore hotplug
      events for a device") iterates over the devices on a hotplug port's
      subordinate bus in pciehp's IRQ handler without acquiring pci_bus_sem.
      It is thus possible for a user to cause a crash by concurrently
      manipulating the device list, e.g. by disabling slot power via sysfs
      on a different CPU or by initiating a remove/rescan via sysfs.
      
      This can't be fixed by acquiring pci_bus_sem because it may sleep.
      The simplest fix is to avoid the list iteration altogether and just
      check the ignore_hotplug flag on the port itself.  This works because
      pci_ignore_hotplug() sets the flag both on the device as well as on its
      parent bridge.
      
      We do lose the ability to print the name of the device blocking hotplug
      in the debug message, but that's probably bearable.
      
      Fixes: b440bde7 ("PCI: Add pci_ignore_hotplug() to ignore hotplug events for a device")
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      Cc: stable@vger.kernel.org
      1204e35b
    • L
      PCI: pciehp: Fix use-after-free on unplug · 281e878e
      Lukas Wunner 提交于
      When pciehp is unbound (e.g. on unplug of a Thunderbolt device), the
      hotplug_slot struct is deregistered and thus freed before freeing the
      IRQ.  The IRQ handler and the work items it schedules print the slot
      name referenced from the freed structure in various informational and
      debug log messages, each time resulting in a quadruple dereference of
      freed pointers (hotplug_slot -> pci_slot -> kobject -> name).
      
      At best the slot name is logged as "(null)", at worst kernel memory is
      exposed in logs or the driver crashes:
      
        pciehp 0000:10:00.0:pcie204: Slot((null)): Card not present
      
      An attacker may provoke the bug by unplugging multiple devices on a
      Thunderbolt daisy chain at once.  Unplugging can also be simulated by
      powering down slots via sysfs.  The bug is particularly easy to trigger
      in poll mode.
      
      It has been present since the driver's introduction in 2004:
      https://git.kernel.org/tglx/history/c/c16b4b14d980
      
      Fix by rearranging teardown such that the IRQ is freed first.  Run the
      work items queued by the IRQ handler to completion before freeing the
      hotplug_slot struct by draining the work queue from the ->release_slot
      callback which is invoked by pci_hp_deregister().
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      Cc: stable@vger.kernel.org # v2.6.4
      281e878e
    • L
      PCI: hotplug: Don't leak pci_slot on registration failure · 4ce64358
      Lukas Wunner 提交于
      If addition of sysfs files fails on registration of a hotplug slot, the
      struct pci_slot as well as the entry in the slot_list is leaked.  The
      issue has been present since the hotplug core was introduced in 2002:
      https://git.kernel.org/tglx/history/c/a8a2069f432c
      
      Perhaps the idea was that even though sysfs addition fails, the slot
      should still be usable.  But that's not how drivers use the interface,
      they abort probe if a non-zero value is returned.
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      Cc: stable@vger.kernel.org # v2.4.15+
      Cc: Greg Kroah-Hartman <greg@kroah.com>
      4ce64358
    • L
      PCI: hotplug: Delete skeleton driver · b4efce5c
      Lukas Wunner 提交于
      Ten years ago, commit 58319b80 ("PCI: Hotplug core: remove 'name'")
      dropped the name element from struct hotplug_slot but neglected to update
      the skeleton driver.
      
      That same year, commit f46753c5 ("PCI: introduce pci_slot") raised the
      number of arguments to pci_hp_register() from one to four.
      
      Fourteen years ago, historic commit 7ab60fc1b8e7 ("PCI Hotplug skeleton:
      final cleanups") removed all usages of the retval variable from
      pcihp_skel_init() but not the variable itself, provoking a compiler
      warning: https://git.kernel.org/tglx/history/c/7ab60fc1b8e7
      
      It seems fair to assume the driver hasn't been used as a template for a new
      driver in a while.  Per Bjorn's and Christoph's preference, delete it.
      Signed-off-by: NLukas Wunner <lukas@wunner.de>
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      Cc: Christoph Hellwig <hch@lst.de>
      b4efce5c
  2. 27 6月, 2018 1 次提交
    • B
      PCI: shpchp: Separate existence of SHPC and permission to use it · b03799b0
      Bjorn Helgaas 提交于
      The shpchp driver registers for all PCI bridge devices.  Its probe method
      should fail if either (1) the bridge doesn't have an SHPC or (2) the OS
      isn't allowed to use it (the platform firmware may be operating the SHPC
      itself).
      
      Separate these two tests into:
      
        - A new shpc_capable() that looks for the SHPC hardware and is applicable
          on all systems (ACPI and non-ACPI), and
      
        - A simplified acpi_get_hp_hw_control_from_firmware() that we call only
          when we already know an SHPC exists and there may be ACPI methods to
          either request permission to use it (_OSC) or transfer control to the
          OS (OSHP).
      
      acpi_get_hp_hw_control_from_firmware() is implemented when CONFIG_ACPI=y,
      but does nothing if the current platform doesn't support ACPI.
      Signed-off-by: NBjorn Helgaas <bhelgaas@google.com>
      Reviewed-by: NMika Westerberg <mika.westerberg@linux.intel.com>
      b03799b0
  3. 26 6月, 2018 1 次提交
  4. 16 6月, 2018 14 次提交
  5. 15 6月, 2018 5 次提交