Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c1f792a5 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs 

* 'for-linus' of git://oss.sgi.com/xfs/xfs: (49 commits)
  xfs: add size update tracepoint to IO completion
  xfs: convert AIL cursors to use struct list_head
  xfs: remove confusing ail cursor wrapper
  xfs: use a cursor for bulk AIL insertion
  xfs: failure mapping nfs fh to inode should return ESTALE
  xfs: Remove the second parameter to xfs_sb_count()
  xfs: remove the dead XFS_DABUF_DEBUG code
  xfs: remove leftovers of the old btree tracing code
  xfs: remove the dead QUOTADEBUG code
  xfs: remove the unused xfs_buf_delwri_sort function
  xfs: remove wrappers around b_iodone
  xfs: remove wrappers around b_fspriv
  xfs: add a proper transaction pointer to struct xfs_buf
  xfs: factor out xfs_da_grow_inode_int
  xfs: factor out xfs_dir2_leaf_find_stale
  xfs: cleanup struct xfs_dir2_free
  xfs: reshuffle dir2 headers
  xfs: start periodic workers later
  Revert "xfs: fix filesystsem freeze race in xfs_trans_alloc"
  xfs: remove variables that serve no purpose in xfs_alloc_ag_vextent_exact()
  ...
parents 6aaf4404 55fb25d5

fs/xfs/Makefile

+0 −2
Original line number Diff line number Diff line
@@ -88,8 +88,6 @@ xfs-y += xfs_alloc.o \ 
				   xfs_vnodeops.o \

				   xfs_rw.o



xfs-$(CONFIG_XFS_TRACE)		+= xfs_btree_trace.o



# Objects in linux/

xfs-y				+= $(addprefix $(XFS_LINUX)/, \

				   kmem.o \

fs/xfs/linux-2.6/xfs_acl.c

+1 −1
Original line number Diff line number Diff line
@@ -264,7 +264,7 @@ xfs_set_mode(struct inode *inode, mode_t mode) 
		iattr.ia_mode = mode;

		iattr.ia_ctime = current_fs_time(inode->i_sb);



		error = -xfs_setattr(XFS_I(inode), &iattr, XFS_ATTR_NOACL);

		error = -xfs_setattr_nonsize(XFS_I(inode), &iattr, XFS_ATTR_NOACL);

	}



	return error;

fs/xfs/linux-2.6/xfs_aops.c

+5 −15
Original line number Diff line number Diff line
@@ -181,6 +181,7 @@ xfs_setfilesize( 


	isize = xfs_ioend_new_eof(ioend);

	if (isize) {

		trace_xfs_setfilesize(ip, ioend->io_offset, ioend->io_size);

		ip->i_d.di_size = isize;

		xfs_mark_inode_dirty(ip);

	}
@@ -894,11 +895,6 @@ out_invalidate: 
 * For unwritten space on the page we need to start the conversion to

 * regular allocated space.

 * For any other dirty buffer heads on the page we should flush them.

 *

 * If we detect that a transaction would be required to flush the page, we

 * have to check the process flags first, if we are already in a transaction

 * or disk I/O during allocations is off, we need to fail the writepage and

 * redirty the page.

 */

STATIC int

xfs_vm_writepage(
@@ -906,7 +902,6 @@ xfs_vm_writepage( 
	struct writeback_control *wbc)

{

	struct inode		*inode = page->mapping->host;

	int			delalloc, unwritten;

	struct buffer_head	*bh, *head;

	struct xfs_bmbt_irec	imap;

	xfs_ioend_t		*ioend = NULL, *iohead = NULL;
@@ -938,15 +933,10 @@ xfs_vm_writepage( 
		goto redirty;



	/*

	 * We need a transaction if there are delalloc or unwritten buffers

	 * on the page.

	 *

	 * If we need a transaction and the process flags say we are already

	 * in a transaction, or no IO is allowed then mark the page dirty

	 * again and leave the page as is.

	 * Given that we do not allow direct reclaim to call us, we should

	 * never be called while in a filesystem transaction.

	 */

	xfs_count_page_state(page, &delalloc, &unwritten);

	if ((current->flags & PF_FSTRANS) && (delalloc || unwritten))

	if (WARN_ON(current->flags & PF_FSTRANS))

		goto redirty;



	/* Is this page beyond the end of the file? */
@@ -970,7 +960,7 @@ xfs_vm_writepage( 
	offset = page_offset(page);

	type = IO_OVERWRITE;



	if (wbc->sync_mode == WB_SYNC_NONE && wbc->nonblocking)

	if (wbc->sync_mode == WB_SYNC_NONE)

		nonblocking = 1;



	do {

fs/xfs/linux-2.6/xfs_buf.c

+27 −52
Original line number Diff line number Diff line
@@ -499,16 +499,14 @@ found: 
	spin_unlock(&pag->pag_buf_lock);

	xfs_perag_put(pag);



	if (xfs_buf_cond_lock(bp)) {

		/* failed, so wait for the lock if requested. */

		if (!(flags & XBF_TRYLOCK)) {

			xfs_buf_lock(bp);

			XFS_STATS_INC(xb_get_locked_waited);

		} else {

	if (!xfs_buf_trylock(bp)) {

		if (flags & XBF_TRYLOCK) {

			xfs_buf_rele(bp);

			XFS_STATS_INC(xb_busy_locked);

			return NULL;

		}

		xfs_buf_lock(bp);

		XFS_STATS_INC(xb_get_locked_waited);

	}



	/*
@@ -594,10 +592,8 @@ _xfs_buf_read( 
	ASSERT(!(flags & (XBF_DELWRI|XBF_WRITE)));

	ASSERT(bp->b_bn != XFS_BUF_DADDR_NULL);



	bp->b_flags &= ~(XBF_WRITE | XBF_ASYNC | XBF_DELWRI | \

			XBF_READ_AHEAD | _XBF_RUN_QUEUES);

	bp->b_flags |= flags & (XBF_READ | XBF_ASYNC | \

			XBF_READ_AHEAD | _XBF_RUN_QUEUES);

	bp->b_flags &= ~(XBF_WRITE | XBF_ASYNC | XBF_DELWRI | XBF_READ_AHEAD);

	bp->b_flags |= flags & (XBF_READ | XBF_ASYNC | XBF_READ_AHEAD);



	status = xfs_buf_iorequest(bp);

	if (status || XFS_BUF_ISERROR(bp) || (flags & XBF_ASYNC))
@@ -681,7 +677,6 @@ xfs_buf_read_uncached( 
		return NULL;



	/* set up the buffer for a read IO */

	xfs_buf_lock(bp);

	XFS_BUF_SET_ADDR(bp, daddr);

	XFS_BUF_READ(bp);

	XFS_BUF_BUSY(bp);
@@ -816,8 +811,6 @@ xfs_buf_get_uncached( 
		goto fail_free_mem;

	}



	xfs_buf_unlock(bp);



	trace_xfs_buf_get_uncached(bp, _RET_IP_);

	return bp;
@@ -896,8 +889,8 @@ xfs_buf_rele( 
 *	to push on stale inode buffers.

 */

int

xfs_buf_cond_lock(

	xfs_buf_t		*bp)

xfs_buf_trylock(

	struct xfs_buf		*bp)

{

	int			locked;
@@ -907,15 +900,8 @@ xfs_buf_cond_lock( 
	else if (atomic_read(&bp->b_pin_count) && (bp->b_flags & XBF_STALE))

		xfs_log_force(bp->b_target->bt_mount, 0);



	trace_xfs_buf_cond_lock(bp, _RET_IP_);

	return locked ? 0 : -EBUSY;

}



int

xfs_buf_lock_value(

	xfs_buf_t		*bp)

{

	return bp->b_sema.count;

	trace_xfs_buf_trylock(bp, _RET_IP_);

	return locked;

}



/*
@@ -929,7 +915,7 @@ xfs_buf_lock_value( 
 */

void

xfs_buf_lock(

	xfs_buf_t		*bp)

	struct xfs_buf		*bp)

{

	trace_xfs_buf_lock(bp, _RET_IP_);
@@ -950,7 +936,7 @@ xfs_buf_lock( 
 */

void

xfs_buf_unlock(

	xfs_buf_t		*bp)

	struct xfs_buf		*bp)

{

	if ((bp->b_flags & (XBF_DELWRI|_XBF_DELWRI_Q)) == XBF_DELWRI) {

		atomic_inc(&bp->b_hold);
@@ -1121,7 +1107,7 @@ xfs_bioerror_relse( 
	XFS_BUF_UNDELAYWRITE(bp);

	XFS_BUF_DONE(bp);

	XFS_BUF_STALE(bp);

	XFS_BUF_CLR_IODONE_FUNC(bp);

	bp->b_iodone = NULL;

	if (!(fl & XBF_ASYNC)) {

		/*

		 * Mark b_error and B_ERROR _both_.
@@ -1223,23 +1209,21 @@ _xfs_buf_ioapply( 
	total_nr_pages = bp->b_page_count;

	map_i = 0;



	if (bp->b_flags & XBF_ORDERED) {

		ASSERT(!(bp->b_flags & XBF_READ));

		rw = WRITE_FLUSH_FUA;

	} else if (bp->b_flags & XBF_LOG_BUFFER) {

		ASSERT(!(bp->b_flags & XBF_READ_AHEAD));

		bp->b_flags &= ~_XBF_RUN_QUEUES;

		rw = (bp->b_flags & XBF_WRITE) ? WRITE_SYNC : READ_SYNC;

	} else if (bp->b_flags & _XBF_RUN_QUEUES) {

		ASSERT(!(bp->b_flags & XBF_READ_AHEAD));

		bp->b_flags &= ~_XBF_RUN_QUEUES;

		rw = (bp->b_flags & XBF_WRITE) ? WRITE_META : READ_META;

	if (bp->b_flags & XBF_WRITE) {

		if (bp->b_flags & XBF_SYNCIO)

			rw = WRITE_SYNC;

		else

			rw = WRITE;

		if (bp->b_flags & XBF_FUA)

			rw |= REQ_FUA;

		if (bp->b_flags & XBF_FLUSH)

			rw |= REQ_FLUSH;

	} else if (bp->b_flags & XBF_READ_AHEAD) {

		rw = READA;

	} else {

		rw = (bp->b_flags & XBF_WRITE) ? WRITE :

		     (bp->b_flags & XBF_READ_AHEAD) ? READA : READ;

		rw = READ;

	}





next_chunk:

	atomic_inc(&bp->b_io_remaining);

	nr_pages = BIO_MAX_SECTORS >> (PAGE_SHIFT - BBSHIFT);
@@ -1694,15 +1678,14 @@ xfs_buf_delwri_split( 
	list_for_each_entry_safe(bp, n, dwq, b_list) {

		ASSERT(bp->b_flags & XBF_DELWRI);



		if (!XFS_BUF_ISPINNED(bp) && !xfs_buf_cond_lock(bp)) {

		if (!XFS_BUF_ISPINNED(bp) && xfs_buf_trylock(bp)) {

			if (!force &&

			    time_before(jiffies, bp->b_queuetime + age)) {

				xfs_buf_unlock(bp);

				break;

			}



			bp->b_flags &= ~(XBF_DELWRI|_XBF_DELWRI_Q|

					 _XBF_RUN_QUEUES);

			bp->b_flags &= ~(XBF_DELWRI | _XBF_DELWRI_Q);

			bp->b_flags |= XBF_WRITE;

			list_move_tail(&bp->b_list, list);

			trace_xfs_buf_delwri_split(bp, _RET_IP_);
@@ -1738,14 +1721,6 @@ xfs_buf_cmp( 
	return 0;

}



void

xfs_buf_delwri_sort(

	xfs_buftarg_t	*target,

	struct list_head *list)

{

	list_sort(NULL, list, xfs_buf_cmp);

}



STATIC int

xfsbufd(

	void		*data)

fs/xfs/linux-2.6/xfs_buf.h

+24 −40
Original line number Diff line number Diff line
@@ -46,43 +46,46 @@ typedef enum { 


#define XBF_READ	(1 << 0) /* buffer intended for reading from device */

#define XBF_WRITE	(1 << 1) /* buffer intended for writing to device */

#define XBF_MAPPED	(1 << 2) /* buffer mapped (b_addr valid) */

#define XBF_READ_AHEAD	(1 << 2) /* asynchronous read-ahead */

#define XBF_MAPPED	(1 << 3) /* buffer mapped (b_addr valid) */

#define XBF_ASYNC	(1 << 4) /* initiator will not wait for completion */

#define XBF_DONE	(1 << 5) /* all pages in the buffer uptodate */

#define XBF_DELWRI	(1 << 6) /* buffer has dirty pages */

#define XBF_STALE	(1 << 7) /* buffer has been staled, do not find it */

#define XBF_ORDERED	(1 << 11)/* use ordered writes */

#define XBF_READ_AHEAD	(1 << 12)/* asynchronous read-ahead */

#define XBF_LOG_BUFFER	(1 << 13)/* this is a buffer used for the log */



/* I/O hints for the BIO layer */

#define XBF_SYNCIO	(1 << 10)/* treat this buffer as synchronous I/O */

#define XBF_FUA		(1 << 11)/* force cache write through mode */

#define XBF_FLUSH	(1 << 12)/* flush the disk cache before a write */



/* flags used only as arguments to access routines */

#define XBF_LOCK	(1 << 14)/* lock requested */

#define XBF_TRYLOCK	(1 << 15)/* lock requested, but do not wait */

#define XBF_DONT_BLOCK	(1 << 16)/* do not block in current thread */

#define XBF_LOCK	(1 << 15)/* lock requested */

#define XBF_TRYLOCK	(1 << 16)/* lock requested, but do not wait */

#define XBF_DONT_BLOCK	(1 << 17)/* do not block in current thread */



/* flags used only internally */

#define _XBF_PAGES	(1 << 18)/* backed by refcounted pages */

#define	_XBF_RUN_QUEUES	(1 << 19)/* run block device task queue	*/

#define	_XBF_KMEM	(1 << 20)/* backed by heap memory */

#define _XBF_DELWRI_Q	(1 << 21)/* buffer on delwri queue */

#define _XBF_PAGES	(1 << 20)/* backed by refcounted pages */

#define _XBF_KMEM	(1 << 21)/* backed by heap memory */

#define _XBF_DELWRI_Q	(1 << 22)/* buffer on delwri queue */



typedef unsigned int xfs_buf_flags_t;



#define XFS_BUF_FLAGS \

	{ XBF_READ,		"READ" }, \

	{ XBF_WRITE,		"WRITE" }, \

	{ XBF_READ_AHEAD,	"READ_AHEAD" }, \

	{ XBF_MAPPED,		"MAPPED" }, \

	{ XBF_ASYNC,		"ASYNC" }, \

	{ XBF_DONE,		"DONE" }, \

	{ XBF_DELWRI,		"DELWRI" }, \

	{ XBF_STALE,		"STALE" }, \

	{ XBF_ORDERED,		"ORDERED" }, \

	{ XBF_READ_AHEAD,	"READ_AHEAD" }, \

	{ XBF_SYNCIO,		"SYNCIO" }, \

	{ XBF_FUA,		"FUA" }, \

	{ XBF_FLUSH,		"FLUSH" }, \

	{ XBF_LOCK,		"LOCK" },  	/* should never be set */\

	{ XBF_TRYLOCK,		"TRYLOCK" }, 	/* ditto */\

	{ XBF_DONT_BLOCK,	"DONT_BLOCK" },	/* ditto */\

	{ _XBF_PAGES,		"PAGES" }, \

	{ _XBF_RUN_QUEUES,	"RUN_QUEUES" }, \

	{ _XBF_KMEM,		"KMEM" }, \

	{ _XBF_DELWRI_Q,	"DELWRI_Q" }
@@ -91,11 +94,6 @@ typedef enum { 
	XBT_FORCE_FLUSH = 1,

} xfs_buftarg_flags_t;



typedef struct xfs_bufhash {

	struct list_head	bh_list;

	spinlock_t		bh_lock;

} xfs_bufhash_t;



typedef struct xfs_buftarg {

	dev_t			bt_dev;

	struct block_device	*bt_bdev;
@@ -151,7 +149,7 @@ typedef struct xfs_buf { 
	xfs_buf_iodone_t	b_iodone;	/* I/O completion function */

	struct completion	b_iowait;	/* queue for I/O waiters */

	void			*b_fspriv;

	void			*b_fspriv2;

	struct xfs_trans	*b_transp;

	struct page		**b_pages;	/* array of page pointers */

	struct page		*b_page_array[XB_PAGES]; /* inline pages */

	unsigned long		b_queuetime;	/* time buffer was queued */
@@ -192,10 +190,11 @@ extern void xfs_buf_free(xfs_buf_t *); 
extern void xfs_buf_rele(xfs_buf_t *);



/* Locking and Unlocking Buffers */

extern int xfs_buf_cond_lock(xfs_buf_t *);

extern int xfs_buf_lock_value(xfs_buf_t *);

extern int xfs_buf_trylock(xfs_buf_t *);

extern void xfs_buf_lock(xfs_buf_t *);

extern void xfs_buf_unlock(xfs_buf_t *);

#define xfs_buf_islocked(bp) \

	((bp)->b_sema.count <= 0)



/* Buffer Read and Write Routines */

extern int xfs_bwrite(struct xfs_mount *mp, struct xfs_buf *bp);
@@ -234,8 +233,9 @@ extern void xfs_buf_terminate(void); 




#define XFS_BUF_BFLAGS(bp)	((bp)->b_flags)

#define XFS_BUF_ZEROFLAGS(bp)	((bp)->b_flags &= \

		~(XBF_READ|XBF_WRITE|XBF_ASYNC|XBF_DELWRI|XBF_ORDERED))

#define XFS_BUF_ZEROFLAGS(bp) \

	((bp)->b_flags &= ~(XBF_READ|XBF_WRITE|XBF_ASYNC|XBF_DELWRI| \

			    XBF_SYNCIO|XBF_FUA|XBF_FLUSH))



void xfs_buf_stale(struct xfs_buf *bp);

#define XFS_BUF_STALE(bp)	xfs_buf_stale(bp);
@@ -267,10 +267,6 @@ void xfs_buf_stale(struct xfs_buf *bp); 
#define XFS_BUF_UNASYNC(bp)	((bp)->b_flags &= ~XBF_ASYNC)

#define XFS_BUF_ISASYNC(bp)	((bp)->b_flags & XBF_ASYNC)



#define XFS_BUF_ORDERED(bp)	((bp)->b_flags |= XBF_ORDERED)

#define XFS_BUF_UNORDERED(bp)	((bp)->b_flags &= ~XBF_ORDERED)

#define XFS_BUF_ISORDERED(bp)	((bp)->b_flags & XBF_ORDERED)



#define XFS_BUF_HOLD(bp)	xfs_buf_hold(bp)

#define XFS_BUF_READ(bp)	((bp)->b_flags |= XBF_READ)

#define XFS_BUF_UNREAD(bp)	((bp)->b_flags &= ~XBF_READ)
@@ -280,14 +276,6 @@ void xfs_buf_stale(struct xfs_buf *bp); 
#define XFS_BUF_UNWRITE(bp)	((bp)->b_flags &= ~XBF_WRITE)

#define XFS_BUF_ISWRITE(bp)	((bp)->b_flags & XBF_WRITE)



#define XFS_BUF_IODONE_FUNC(bp)			((bp)->b_iodone)

#define XFS_BUF_SET_IODONE_FUNC(bp, func)	((bp)->b_iodone = (func))

#define XFS_BUF_CLR_IODONE_FUNC(bp)		((bp)->b_iodone = NULL)



#define XFS_BUF_FSPRIVATE(bp, type)		((type)(bp)->b_fspriv)

#define XFS_BUF_SET_FSPRIVATE(bp, val)		((bp)->b_fspriv = (void*)(val))

#define XFS_BUF_FSPRIVATE2(bp, type)		((type)(bp)->b_fspriv2)

#define XFS_BUF_SET_FSPRIVATE2(bp, val)		((bp)->b_fspriv2 = (void*)(val))

#define XFS_BUF_SET_START(bp)			do { } while (0)



#define XFS_BUF_PTR(bp)			(xfs_caddr_t)((bp)->b_addr)
@@ -313,10 +301,6 @@ xfs_buf_set_ref( 


#define XFS_BUF_ISPINNED(bp)	atomic_read(&((bp)->b_pin_count))



#define XFS_BUF_VALUSEMA(bp)	xfs_buf_lock_value(bp)

#define XFS_BUF_CPSEMA(bp)	(xfs_buf_cond_lock(bp) == 0)

#define XFS_BUF_VSEMA(bp)	xfs_buf_unlock(bp)

#define XFS_BUF_PSEMA(bp,x)	xfs_buf_lock(bp)

#define XFS_BUF_FINISH_IOWAIT(bp)	complete(&bp->b_iowait);



#define XFS_BUF_SET_TARGET(bp, target)	((bp)->b_target = (target))