1. 06 Mar, 2003 1 commit
  2. 04 Mar, 2003 23 commits
  3. 28 Feb, 2003 3 commits
  4. 27 Feb, 2003 1 commit
  5. 24 Feb, 2003 1 commit
  6. 12 Feb, 2003 1 commit
  7. 11 Feb, 2003 4 commits
  8. 10 Feb, 2003 6 commits
    • David Mosberger's avatar
      ia64: Make signal deliver work when the current register frame is · 15a0c0ef
      David Mosberger authored
      	incomplete (as a result of a faulting mandatory RSE load).
      15a0c0ef
    • David Mosberger's avatar
      ia64: Minor cleanups. · 2ee7e4a3
      David Mosberger authored
      2ee7e4a3
    • Randy Dunlap's avatar
      [PATCH] checker bounds/limits fixes · 498b9cb8
      Randy Dunlap authored
      Part of the bounds checking bugs found by the Stanford checker.
      
      The 4 fixes below have been acked by their maintainers.
      498b9cb8
    • Andrew Morton's avatar
      [PATCH] de4x5 compile fix · e3b4a0e0
      Andrew Morton authored
      Move the definition of version[] down to where __initdata has been defined.
      e3b4a0e0
    • Andrew Morton's avatar
      [PATCH] ncpfs compile fix · 2cece07e
      Andrew Morton authored
      Patch from Joel Becker <Joel.Becker@oracle.com>
      
      The task_struct->sig -> task_struct->signal bits.
      2cece07e
    • 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