1. 15 7月, 2022 1 次提交
  2. 06 7月, 2022 5 次提交
  3. 17 6月, 2022 2 次提交
  4. 16 6月, 2022 2 次提交
  5. 15 6月, 2022 2 次提交
  6. 14 6月, 2022 2 次提交
  7. 12 6月, 2022 1 次提交
  8. 11 6月, 2022 2 次提交
    • D
      netfs: Rename the netfs_io_request cleanup op and give it an op pointer · 40a81101
      David Howells 提交于
      The netfs_io_request cleanup op is now always in a position to be given a
      pointer to a netfs_io_request struct, so this can be passed in instead of
      the mapping and private data arguments (both of which are included in the
      struct).
      
      So rename the ->cleanup op to ->free_request (to match ->init_request) and
      pass in the I/O pointer.
      Signed-off-by: NDavid Howells <dhowells@redhat.com>
      Reviewed-by: NJeff Layton <jlayton@kernel.org>
      cc: linux-cachefs@redhat.com
      40a81101
    • L
      netfs: Further cleanups after struct netfs_inode wrapper introduced · e81fb419
      Linus Torvalds 提交于
      Change the signature of netfs helper functions to take a struct netfs_inode
      pointer rather than a struct inode pointer where appropriate, thereby
      relieving the need for the network filesystem to convert its internal inode
      format down to the VFS inode only for netfslib to bounce it back up.  For
      type safety, it's better not to do that (and it's less typing too).
      
      Give netfs_write_begin() an extra argument to pass in a pointer to the
      netfs_inode struct rather than deriving it internally from the file
      pointer.  Note that the ->write_begin() and ->write_end() ops are intended
      to be replaced in the future by netfslib code that manages this without the
      need to call in twice for each page.
      
      netfs_readpage() and similar are intended to be pointed at directly by the
      address_space_operations table, so must stick to the signature dictated by
      the function pointers there.
      
      Changes
      =======
      - Updated the kerneldoc comments and documentation [DH].
      Signed-off-by: NDavid Howells <dhowells@redhat.com>
      cc: linux-cachefs@redhat.com
      Link: https://lore.kernel.org/r/CAHk-=wgkwKyNmNdKpQkqZ6DnmUL-x9hp0YBnUGjaPFEAdxDTbw@mail.gmail.com/
      e81fb419
  9. 10 6月, 2022 8 次提交
  10. 09 6月, 2022 5 次提交
  11. 08 6月, 2022 2 次提交
    • W
      workqueue: Fix type of cpu in trace event · 873a4009
      Wonhyuk Yang 提交于
      The trace event "workqueue_queue_work" use unsigned int type for
      req_cpu, cpu. This casue confusing cpu number like below log.
      
      $ cat /sys/kernel/debug/tracing/trace
      cat-317  [001] ...: workqueue_queue_work: ... req_cpu=8192 cpu=4294967295
      
      So, change unsigned type to signed type in the trace event. After
      applying this patch, cpu number will be printed as -1 instead of
      4294967295 as folllows.
      
      $ cat /sys/kernel/debug/tracing/trace
      cat-1338  [002] ...: workqueue_queue_work: ... req_cpu=8192 cpu=-1
      
      Cc: Baik Song An <bsahn@etri.re.kr>
      Cc: Hong Yeon Kim <kimhy@etri.re.kr>
      Cc: Taeung Song <taeung@reallinux.co.kr>
      Cc: linuxgeek@linuxgeek.io
      Signed-off-by: NWonhyuk Yang <vvghjk1234@gmail.com>
      Signed-off-by: NTejun Heo <tj@kernel.org>
      873a4009
    • T
      workqueue: Wrap flush_workqueue() using a macro · c4f135d6
      Tetsuo Handa 提交于
      Since flush operation synchronously waits for completion, flushing
      system-wide WQs (e.g. system_wq) might introduce possibility of deadlock
      due to unexpected locking dependency. Tejun Heo commented at [1] that it
      makes no sense at all to call flush_workqueue() on the shared WQs as the
      caller has no idea what it's gonna end up waiting for.
      
      Although there is flush_scheduled_work() which flushes system_wq WQ with
      "Think twice before calling this function! It's very easy to get into
      trouble if you don't take great care." warning message, syzbot found a
      circular locking dependency caused by flushing system_wq WQ [2].
      
      Therefore, let's change the direction to that developers had better use
      their local WQs if flush_scheduled_work()/flush_workqueue(system_*_wq) is
      inevitable.
      
      Steps for converting system-wide WQs into local WQs are explained at [3],
      and a conversion to stop flushing system-wide WQs is in progress. Now we
      want some mechanism for preventing developers who are not aware of this
      conversion from again start flushing system-wide WQs.
      
      Since I found that WARN_ON() is complete but awkward approach for teaching
      developers about this problem, let's use __compiletime_warning() for
      incomplete but handy approach. For completeness, we will also insert
      WARN_ON() into __flush_workqueue() after all in-tree users stopped calling
      flush_scheduled_work().
      
      Link: https://lore.kernel.org/all/YgnQGZWT%2Fn3VAITX@slm.duckdns.org/ [1]
      Link: https://syzkaller.appspot.com/bug?extid=bde0f89deacca7c765b8 [2]
      Link: https://lkml.kernel.org/r/49925af7-78a8-a3dd-bce6-cfc02e1a9236@I-love.SAKURA.ne.jp [3]
      Signed-off-by: NTetsuo Handa <penguin-kernel@I-love.SAKURA.ne.jp>
      Signed-off-by: NTejun Heo <tj@kernel.org>
      c4f135d6
  12. 07 6月, 2022 3 次提交
  13. 06 6月, 2022 5 次提交