An error occurred fetching the project authors.
  1. 14 Mar, 2003 1 commit
  2. 25 Feb, 2003 1 commit
  3. 24 Feb, 2003 3 commits
  4. 10 Feb, 2003 1 commit
    • Andrew Morton's avatar
      [PATCH] Fix synchronous writers to wait properly for the result · 8d49bf3f
      Andrew Morton authored
      Mikulas Patocka <mikulas@artax.karlin.mff.cuni.cz> points out a bug in
      ll_rw_block() usage.
      
      Typical usage is:
      
      	mark_buffer_dirty(bh);
      	ll_rw_block(WRITE, 1, &bh);
      	wait_on_buffer(bh);
      
      the problem is that if the buffer was locked on entry to this code sequence
      (due to in-progress I/O), ll_rw_block() will not wait, and start new I/O.  So
      this code will wait on the _old_ I/O, and will then continue execution,
      leaving the buffer dirty.
      
      It turns out that all callers were only writing one buffer, and they were all
      waiting on that writeout.  So I added a new sync_dirty_buffer() function:
      
      	void sync_dirty_buffer(struct buffer_head *bh)
      	{
      		lock_buffer(bh);
      		if (test_clear_buffer_dirty(bh)) {
      			get_bh(bh);
      			bh->b_end_io = end_buffer_io_sync;
      			submit_bh(WRITE, bh);
      		} else {
      			unlock_buffer(bh);
      		}
      	}
      
      which allowed a fair amount of code to be removed, while adding the desired
      data-integrity guarantees.
      
      UFS has its own wrappers around ll_rw_block() which got in the way, so this
      operation was open-coded in that case.
      8d49bf3f
  5. 07 Dec, 2002 1 commit
  6. 17 Nov, 2002 1 commit
    • Andi Kleen's avatar
      [PATCH] nanosecond stat timefields · 5d62665d
      Andi Kleen authored
      stat64 has been changed to return jiffies granuality as nsec in previously
      unused fields. This allows make to make better decisions on when
      to recompile a file. Follows losely the Solaris API.
      
      CURRENT_TIME has been redefined to return struct timespec.  The users
      who don't use it in a inode/attr context have been changed to use a new
      get_seconds() function.  CURRENT_TIME is implemented by an out-of-line
      function.
      
      There is a small performance penalty in this patch.  The previous
      filemap code had an optimization to flush atime only once a second.
      This is currently gone, which will increase flushes a bit.  I believe
      the correct solution if it should be a problem is to have per super
      block fields that give an arbitary atime flush granuality - so that you
      can set it to be only flushed once a hour if you prefer that.  I will
      work on that later in separate patches if the need should arise.
      
      struct inode and the attr struct has been changed to store struct
      timespec instead of time_t for [cma]time.  Not all file systems support
      this granuality, but some like XFS,NFSv3,CIFS,JFS do.  The others will
      currently truncate the nsec part on flushing to disk.  There was some
      discussion on this rounding on l-k previously.  I went for simple
      truncation because there is not much evidence IMHO that the more
      complicated roundings have any advantages.  In practice application will
      be rather unlikely to notice the rounding anyways - they can only see a
      difference when an inode is flush from memory and reloaded in less than
      a second, which is rather unlikely.
      5d62665d
  7. 09 Oct, 2002 1 commit
    • Andrew Morton's avatar
      [PATCH] 64-bit sector_t - printk changes and sector_t cleanup · be48ef9e
      Andrew Morton authored
      From Peter Chubb
      
      printk changes: A sector_t can be either 64 or 32 bits, so cast it to a
      printable type that is at least as large as 64-bits on all platforms
      (i.e., cast to unsigned long long and use a %llu format)
      
      Transition to 64-bit sector_t: fix isofs_get_blocks by converting the
      (possibly 64-bit) arg to a long.
      
      SCSI 64-bit sector_t cleanup: capacity now stored as sector_t; make
      sure that the READ_CAPACITY command doesn't sign-extend its returned
      value; avoid 64-bit division when printing size in MB.
      
      Still to do:
       - 16-byte SCSI commands
       - Individual scsi drivers.
      be48ef9e
  8. 01 Oct, 2002 1 commit
    • Ingo Molnar's avatar
      [PATCH] Workqueue Abstraction · 6ed12ff8
      Ingo Molnar authored
      This is the next iteration of the workqueue abstraction.
      
      The framework includes:
      
       - per-CPU queueing support.
      
      on SMP there is a per-CPU worker thread (bound to its CPU) and per-CPU
      work queues - this feature is completely transparent to workqueue-users.
      keventd automatically uses this feature. XFS can now update to work-queues
      and have the same per-CPU performance as it had with its per-CPU worker
      threads.
      
       - delayed work submission
      
      there's a new queue_delayed_work(wq, work, delay) function and a new
      schedule_delayed_work(work, delay) function. The later one is used to
      correctly fix former tq_timer users. I've reverted those changes in 2.5.40
      that changed tq_timer uses to schedule_work() - eg. in the case of
      random.c or the tty flip queue it was definitely the wrong thing to do.
      
      delayed work means a timer embedded in struct work_struct.  I considered
      using split struct work_struct and delayed_work_struct types, but lots
      of code actively uses task-queues in both delayed and non-delayed mode,
      so i went for the more generic approach that allows both methods of work
      submission.  Delayed timers do not cause any other overhead in the
      normal submission path otherwise.
      
       - multithreaded run_workqueue() implementation
      
      the run_workqueue() function can now be called from multiple contexts, and
      a worker thread will only use up a single entryy - this property is used
      by the flushing code, and can potentially be used in the future to extend
      the number of per-CPU worker threads.
      
       - more reliable flushing
      
      there's now a 'pending work' counter, which is used to accurately detect
      when the last work-function has finished execution. It's also used to
      correctly flush against timed requests. I'm not convinced whether the old
      keventd implementation got this detail right.
      
       - i switched the arguments of the queueing function(s) per Jeff's
         suggestion, it's more straightforward this way.
      
      
      Driver fixes:
      
      i have converted almost every affected driver to the new framework. This
      cleaned up tons of code. I also fixed a number of drivers that were still
      using BHs (these drivers did not compile in 2.5.40).
      
      while this means lots of changes, it might ease the QA decision whether to
      put this patch into 2.5.
      
      The pach converts roughly 80% of all tqueue-using code to workqueues - and
      all the places that are not converted to workqueues yet are places that do
      not compile in vanilla 2.5.40 anyway, due to unrelated changes. I've
      converted a fair number of drivers that do not compile in 2.5.40, and i
      think i've managed to convert every driver that compiles under 2.5.40.
      6ed12ff8
  9. 29 Sep, 2002 2 commits
    • Ingo Molnar's avatar
      [PATCH] tq_struct removal fixups.. · 24141f21
      Ingo Molnar authored
      Update radeon_irq.c and reiserfs for tq simplifications
      24141f21
    • Ingo Molnar's avatar
      [PATCH] atomic-thread-signals · 5a5ec729
      Ingo Molnar authored
      Avoid racing on signal delivery with thread signal blocking in thread
      groups.
      
      The method to do this is to eliminate the per-thread sigmask_lock, and
      use the per-group (per 'process') siglock for all signal related
      activities.  This immensely simplified some of the locking interactions
      within signal.c, and enabled the fixing of the above category of signal
      delivery races.
      
      This became possible due to the former thread-signal patch, which made
      siglock an irq-safe thing.  (it used to be a process-context-only
      spinlock.) And this is even a speedup for non-threaded applications:
      only one lock is used.
      
      I fixed all places within the kernel except the non-x86 arch sections.
      Even for them the transition is very straightforward, in almost every
      case the following is sufficient in arch/*/kernel/signal.c:
      
      		:1,$s/->sigmask_lock/->sig->siglock/g
      5a5ec729
  10. 20 Aug, 2002 1 commit
  11. 20 Jun, 2002 1 commit
  12. 18 Jun, 2002 1 commit
  13. 11 Jun, 2002 4 commits
  14. 30 May, 2002 5 commits
    • Oleg Drokin's avatar
      journal.c: · 2b85d1d5
      Oleg Drokin authored
        reiserfs: transaction replay status report, using bdevname instead of __bdevname.
      2b85d1d5
    • Oleg Drokin's avatar
      journal.c: · 4bc53d41
      Oleg Drokin authored
        fix reiserfs_breada to read from the correct device when it isn't on the same device as the main filesystem.
      4bc53d41
    • Oleg Drokin's avatar
      reiserfs_fs.h, journal.c: · 913df90a
      Oleg Drokin authored
        renamed journal device buffer head funcs and moved them into reiserfs_fs.h.
      913df90a
    • Oleg Drokin's avatar
      journal.c: · 715403ff
      Oleg Drokin authored
        reiserfs: Fix initialization and cleanup of the external logging (Vladimir Saveliev) , and make sure to call set_blocksize() on the bdev for the external device. (Chris Mason)
      715403ff
    • Oleg Drokin's avatar
      Many files: · 828156c1
      Oleg Drokin authored
        reiserfs: use reiserfs_bdevname(s) instead of s->s_id. From Josh MacDonald.
      828156c1
  15. 29 May, 2002 1 commit
    • Pavel Machek's avatar
      [PATCH] swsusp: cleanup · d72fb463
      Pavel Machek authored
       - use list_for_each in head_of_free_region
       - cleanups from 2.4
       - fix for usb
       - kill broken queueing
      d72fb463
  16. 24 May, 2002 1 commit
    • Pavel Machek's avatar
      [PATCH] swsusp fixes · ce922a4c
      Pavel Machek authored
      This kills unneccessary include from ide-disk.c, kills #ifdef from
      reiserfs/journal.c, makes suspend_device local as it should be,
      abstains from suspending devices two times in a row (typo), and makes
      sure we do not run_task_queue() while we hold spinlock.
      ce922a4c
  17. 23 May, 2002 1 commit
  18. 21 May, 2002 1 commit
    • Pavel Machek's avatar
      [PATCH] suspend-to-{RAM,disk} · 542f96a5
      Pavel Machek authored
      Here's suspend-to-{RAM,disk} combined patch for
      2.5.17. Suspend-to-disk is pretty stable and was tested in
      2.4-ac. Suspend-to-RAM is little more experimental, but works for me,
      and is certainly better than disk-eating version currently in kernel.
      
      Major parts are: process stopper, S3 specific code, S4 specific
      code.
      542f96a5
  19. 20 May, 2002 1 commit
    • Christoph Hellwig's avatar
      [PATCH] get rid of <linux/locks.h> · bd2b0c85
      Christoph Hellwig authored
      The lock.h header contained some hand-crafted lcoking routines from
      the pre-SMP days.  In 2.5 only lock_super/unlock_super are left,
      guarded by a number of completly unrelated (!) includes.
      
      This patch moves lock_super/unlock_super to fs.h, which defined
      struct super_block that is needed for those to operate it, removes
      locks.h and updates all caller to not include it and add the missing,
      previously nested includes where needed.
      bd2b0c85
  20. 18 May, 2002 1 commit
  21. 05 May, 2002 1 commit
    • Christoph Hellwig's avatar
      [PATCH] remove global_bufferlist_lock · 1832e934
      Christoph Hellwig authored
      This patch addresses Andrew's FIXME in buffer.c and adds a spinlock that
      can be passed to the buffer list manipulation functions to the reiserfs
      journal.  This obsoletes the cheks for lock beeing NULL in buffer.c and
      the global_bufferlist_lock.
      
      In addition osync_inode_list is changed to use list_for_each_prev as in 2.4
      instead of a hand-crafted loop.
      
      A little comment to the reiserfs folks:  your code would be _sooo_ much
      easier to understand if you used temporary local variables for often
      referenced fields..
      1832e934
  22. 30 Apr, 2002 2 commits
    • Andrew Morton's avatar
      [PATCH] cleanup of bh->flags · 39e8cdf7
      Andrew Morton authored
      Moves all buffer_head-related stuff out of linux/fs.h and into
      linux/buffer_head.h.  buffer_head.h is currently included at the very
      end of fs.h.  So it is possible to include buffer_head directly from
      all .c files and remove this nested include.
      
      Also rationalises all the set_buffer_foo() and mark_buffer_bar()
      functions.  We have:
      
      	set_buffer_foo(bh)
      	clear_buffer_foo(bh)
      	buffer_foo(bh)
      
      and, in some cases, where needed:
      
      	test_set_buffer_foo(bh)
      	test_clear_buffer_foo(bh)
      
      And that's it.
      
      BUFFER_FNS() and TAS_BUFFER_FNS() macros generate all the above real
      inline functions.  Normally not a big fan of cpp abuse, but in this
      case it fits.  These function-generating macros are available to
      filesystems to expand their own b_state functions.  JBD uses this in
      one case.
      39e8cdf7
    • Andrew Morton's avatar
      [PATCH] writeback from address spaces · 090da372
      Andrew Morton authored
      [ I reversed the order in which writeback walks the superblock's
        dirty inodes.  It sped up dbench's unlink phase greatly.  I'm
        such a sleaze ]
      
      The core writeback patch.  Switches file writeback from the dirty
      buffer LRU over to address_space.dirty_pages.
      
      - The buffer LRU is removed
      
      - The buffer hash is removed (uses blockdev pagecache lookups)
      
      - The bdflush and kupdate functions are implemented against
        address_spaces, via pdflush.
      
      - The relationship between pages and buffers is changed.
      
        - If a page has dirty buffers, it is marked dirty
        - If a page is marked dirty, it *may* have dirty buffers.
        - A dirty page may be "partially dirty".  block_write_full_page
          discovers this.
      
      - A bunch of consistency checks of the form
      
      	if (!something_which_should_be_true())
      		buffer_error();
      
        have been introduced.  These fog the code up but are important for
        ensuring that the new buffer/page code is working correctly.
      
      - New locking (inode.i_bufferlist_lock) is introduced for exclusion
        from try_to_free_buffers().  This is needed because set_page_dirty
        is called under spinlock, so it cannot lock the page.  But it
        needs access to page->buffers to set them all dirty.
      
        i_bufferlist_lock is also used to protect inode.i_dirty_buffers.
      
      - fs/inode.c has been split: all the code related to file data writeback
        has been moved into fs/fs-writeback.c
      
      - Code related to file data writeback at the address_space level is in
        the new mm/page-writeback.c
      
      - try_to_free_buffers() is now non-blocking
      
      - Switches vmscan.c over to understand that all pages with dirty data
        are now marked dirty.
      
      - Introduces a new a_op for VM writeback:
      
      	->vm_writeback(struct page *page, int *nr_to_write)
      
        this is a bit half-baked at present.  The intent is that the address_space
        is given the opportunity to perform clustered writeback.  To allow it to
        opportunistically write out disk-contiguous dirty data which may be in other zones.
        To allow delayed-allocate filesystems to get good disk layout.
      
      - Added address_space.io_pages.  Pages which are being prepared for
        writeback.  This is here for two reasons:
      
        1: It will be needed later, when BIOs are assembled direct
           against pagecache, bypassing the buffer layer.  It avoids a
           deadlock which would occur if someone moved the page back onto the
           dirty_pages list after it was added to the BIO, but before it was
           submitted.  (hmm.  This may not be a problem with PG_writeback logic).
      
        2: Avoids a livelock which would occur if some other thread is continually
           redirtying pages.
      
      - There are two known performance problems in this code:
      
        1: Pages which are locked for writeback cause undesirable
           blocking when they are being overwritten.  A patch which leaves
           pages unlocked during writeback comes later in the series.
      
        2: While inodes are under writeback, they are locked.  This
           causes namespace lookups against the file to get unnecessarily
           blocked in wait_on_inode().  This is a fairly minor problem.
      
           I don't have a fix for this at present - I'll fix this when I
           attach dirty address_spaces direct to super_blocks.
      
      - The patch vastly increases the amount of dirty data which the
        kernel permits highmem machines to maintain.  This is because the
        balancing decisions are made against the amount of memory in the
        machine, not against the amount of buffercache-allocatable memory.
      
        This may be very wrong, although it works fine for me (2.5 gigs).
      
        We can trivially go back to the old-style throttling with
        s/nr_free_pagecache_pages/nr_free_buffer_pages/ in
        balance_dirty_pages().  But better would be to allow blockdev
        mappings to use highmem (I'm thinking about this one, slowly).  And
        to move writer-throttling and writeback decisions into the VM (modulo
        the file-overwriting problem).
      
      - Drops 24 bytes from struct buffer_head.  More to come.
      
      - There's some gunk like super_block.flags:MS_FLUSHING which needs to
        be killed.  Need a better way of providing collision avoidance
        between pdflush threads, to prevent more than one pdflush thread
        working a disk at the same time.
      
        The correct way to do that is to put a flag in the request queue to
        say "there's a pdlfush thread working this disk".  This is easy to
        do: just generalise the "ra_pages" pointer to point at a struct which
        includes ra_pages and the new collision-avoidance flag.
      090da372
  23. 25 Apr, 2002 1 commit
    • Alexander Viro's avatar
      [PATCH] (14/15) big struct block_device * push (first series) · ea394494
      Alexander Viro authored
       - bdevname() switched to struct block_device *.  Old variant (taking
         kdev_t) renamed to __bdevname() (very few callers remain).  This
         allow to drop ->b_dev conveniently - it's duplicated by ->b_bdev
         and most of remaining users were bdevname(bh->b_dev) in various
         places.
      ea394494
  24. 23 Apr, 2002 1 commit
  25. 10 Apr, 2002 3 commits
  26. 03 Apr, 2002 1 commit
  27. 02 Mar, 2002 1 commit