Merge git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-2.6-nmw (c54febae) · Commits · 戴 / test

fs/gfs2/Makefile

+1 −1

Original line number	Diff line number	Diff line
		obj-$(CONFIG_GFS2_FS) += gfs2.o
		gfs2-y := acl.o bmap.o daemon.o dir.o eaops.o eattr.o glock.o \
		gfs2-y := acl.o bmap.o dir.o eaops.o eattr.o glock.o \
		glops.o inode.o log.o lops.o locking.o main.o meta_io.o \
		mount.o ops_address.o ops_dentry.o ops_export.o ops_file.o \
		ops_fstype.o ops_inode.o ops_super.o quota.o \

fs/gfs2/acl.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -91,7 +91,7 @@ static int acl_get(struct gfs2_inode ip, int access, struct posix_acl *acl,
		struct gfs2_ea_location el_this;
		int error;

		if (!ip->i_di.di_eattr)
		if (!ip->i_eattr)
		return 0;

		memset(&er, 0, sizeof(struct gfs2_ea_request));

fs/gfs2/bmap.c

+21 −56

Original line number	Diff line number	Diff line
		@@ -75,9 +75,9 @@ static int gfs2_unstuffer_page(struct gfs2_inode ip, struct buffer_head dibh,
		void *kaddr = kmap(page);

		memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode),
		ip->i_di.di_size);
		memset(kaddr + ip->i_di.di_size, 0,
		PAGE_CACHE_SIZE - ip->i_di.di_size);
		ip->i_disksize);
		memset(kaddr + ip->i_disksize, 0,
		PAGE_CACHE_SIZE - ip->i_disksize);
		kunmap(page);

		SetPageUptodate(page);
		@@ -132,7 +132,7 @@ int gfs2_unstuff_dinode(struct gfs2_inode ip, struct page page)
		if (error)
		goto out;

		if (ip->i_di.di_size) {
		if (ip->i_disksize) {
		/* Get a free block, fill it with the stuffed data,
		and write it out to disk */

		@@ -159,7 +159,7 @@ int gfs2_unstuff_dinode(struct gfs2_inode ip, struct page page)
		di = (struct gfs2_dinode *)dibh->b_data;
		gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));

		if (ip->i_di.di_size) {
		if (ip->i_disksize) {
		(__be64 )(di + 1) = cpu_to_be64(block);
		gfs2_add_inode_blocks(&ip->i_inode, 1);
		di->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode));
		@@ -926,7 +926,7 @@ static int do_grow(struct gfs2_inode *ip, u64 size)
		}
		}

		ip->i_di.di_size = size;
		ip->i_disksize = size;
		ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
		gfs2_dinode_out(ip, dibh->b_data);
		@@ -1033,7 +1033,7 @@ static int trunc_start(struct gfs2_inode *ip, u64 size)
		goto out;

		if (gfs2_is_stuffed(ip)) {
		ip->i_di.di_size = size;
		ip->i_disksize = size;
		ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
		gfs2_dinode_out(ip, dibh->b_data);
		@@ -1045,9 +1045,9 @@ static int trunc_start(struct gfs2_inode *ip, u64 size)
		error = gfs2_block_truncate_page(ip->i_inode.i_mapping);

		if (!error) {
		ip->i_di.di_size = size;
		ip->i_disksize = size;
		ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
		ip->i_di.di_flags \|= GFS2_DIF_TRUNC_IN_PROG;
		ip->i_diskflags \|= GFS2_DIF_TRUNC_IN_PROG;
		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
		gfs2_dinode_out(ip, dibh->b_data);
		}
		@@ -1114,13 +1114,13 @@ static int trunc_end(struct gfs2_inode *ip)
		if (error)
		goto out;

		if (!ip->i_di.di_size) {
		if (!ip->i_disksize) {
		ip->i_height = 0;
		ip->i_goal = ip->i_no_addr;
		gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
		}
		ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
		ip->i_di.di_flags &= ~GFS2_DIF_TRUNC_IN_PROG;
		ip->i_diskflags &= ~GFS2_DIF_TRUNC_IN_PROG;

		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
		gfs2_dinode_out(ip, dibh->b_data);
		@@ -1205,9 +1205,9 @@ int gfs2_truncatei(struct gfs2_inode *ip, u64 size)
		if (gfs2_assert_warn(GFS2_SB(&ip->i_inode), S_ISREG(ip->i_inode.i_mode)))
		return -EINVAL;

		if (size > ip->i_di.di_size)
		if (size > ip->i_disksize)
		error = do_grow(ip, size);
		else if (size < ip->i_di.di_size)
		else if (size < ip->i_disksize)
		error = do_shrink(ip, size);
		else
		/* update time stamps */
		@@ -1219,7 +1219,7 @@ int gfs2_truncatei(struct gfs2_inode *ip, u64 size)
		int gfs2_truncatei_resume(struct gfs2_inode *ip)
		{
		int error;
		error = trunc_dealloc(ip, ip->i_di.di_size);
		error = trunc_dealloc(ip, ip->i_disksize);
		if (!error)
		error = trunc_end(ip);
		return error;
		@@ -1230,35 +1230,6 @@ int gfs2_file_dealloc(struct gfs2_inode *ip)
		return trunc_dealloc(ip, 0);
		}

		/**
		* gfs2_write_calc_reserv - calculate number of blocks needed to write to a file
		* @ip: the file
		* @len: the number of bytes to be written to the file
		* @data_blocks: returns the number of data blocks required
		* @ind_blocks: returns the number of indirect blocks required
		*
		*/

		void gfs2_write_calc_reserv(struct gfs2_inode *ip, unsigned int len,
		unsigned int data_blocks, unsigned int ind_blocks)
		{
		struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
		unsigned int tmp;

		if (gfs2_is_dir(ip)) {
		*data_blocks = DIV_ROUND_UP(len, sdp->sd_jbsize) + 2;
		ind_blocks = 3 (sdp->sd_max_jheight - 1);
		} else {
		*data_blocks = (len >> sdp->sd_sb.sb_bsize_shift) + 3;
		ind_blocks = 3 (sdp->sd_max_height - 1);
		}

		for (tmp = *data_blocks; tmp > sdp->sd_diptrs;) {
		tmp = DIV_ROUND_UP(tmp, sdp->sd_inptrs);
		*ind_blocks += tmp;
		}
		}

		/**
		* gfs2_write_alloc_required - figure out if a write will require an allocation
		* @ip: the file being written to
		@@ -1276,6 +1247,7 @@ int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,
		struct buffer_head bh;
		unsigned int shift;
		u64 lblock, lblock_stop, size;
		u64 end_of_file;

		*alloc_required = 0;

		@@ -1291,19 +1263,12 @@ int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,

		*alloc_required = 1;
		shift = sdp->sd_sb.sb_bsize_shift;
		if (gfs2_is_dir(ip)) {
		unsigned int bsize = sdp->sd_jbsize;
		lblock = offset;
		do_div(lblock, bsize);
		lblock_stop = offset + len + bsize - 1;
		do_div(lblock_stop, bsize);
		} else {
		u64 end_of_file = (ip->i_di.di_size + sdp->sd_sb.sb_bsize - 1) >> shift;
		BUG_ON(gfs2_is_dir(ip));
		end_of_file = (ip->i_disksize + sdp->sd_sb.sb_bsize - 1) >> shift;
		lblock = offset >> shift;
		lblock_stop = (offset + len + sdp->sd_sb.sb_bsize - 1) >> shift;
		if (lblock_stop > end_of_file)
		return 0;
		}

		size = (lblock_stop - lblock) << shift;
		do {

fs/gfs2/bmap.h

+30 −4

Original line number	Diff line number	Diff line
		@@ -10,10 +10,40 @@
		#ifndef __BMAP_DOT_H__
		#define __BMAP_DOT_H__

		#include "inode.h"

		struct inode;
		struct gfs2_inode;
		struct page;


		/**
		* gfs2_write_calc_reserv - calculate number of blocks needed to write to a file
		* @ip: the file
		* @len: the number of bytes to be written to the file
		* @data_blocks: returns the number of data blocks required
		* @ind_blocks: returns the number of indirect blocks required
		*
		*/

		static inline void gfs2_write_calc_reserv(const struct gfs2_inode *ip,
		unsigned int len,
		unsigned int *data_blocks,
		unsigned int *ind_blocks)
		{
		const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
		unsigned int tmp;

		BUG_ON(gfs2_is_dir(ip));
		*data_blocks = (len >> sdp->sd_sb.sb_bsize_shift) + 3;
		ind_blocks = 3 (sdp->sd_max_height - 1);

		for (tmp = *data_blocks; tmp > sdp->sd_diptrs;) {
		tmp = DIV_ROUND_UP(tmp, sdp->sd_inptrs);
		*ind_blocks += tmp;
		}
		}

		int gfs2_unstuff_dinode(struct gfs2_inode ip, struct page page);
		int gfs2_block_map(struct inode inode, sector_t lblock, struct buffer_head bh, int create);
		int gfs2_extent_map(struct inode inode, u64 lblock, int new, u64 dblock, unsigned extlen);
		@@ -21,10 +51,6 @@ int gfs2_extent_map(struct inode inode, u64 lblock, int new, u64 *dblock, unsi
		int gfs2_truncatei(struct gfs2_inode *ip, u64 size);
		int gfs2_truncatei_resume(struct gfs2_inode *ip);
		int gfs2_file_dealloc(struct gfs2_inode *ip);

		void gfs2_write_calc_reserv(struct gfs2_inode *ip, unsigned int len,
		unsigned int *data_blocks,
		unsigned int *ind_blocks);
		int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,
		unsigned int len, int *alloc_required);

fs/gfs2/daemon.c

deleted100644 → 0

+0 −136

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
		* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
		*
		* This copyrighted material is made available to anyone wishing to use,
		* modify, copy, or redistribute it subject to the terms and conditions
		* of the GNU General Public License version 2.
		*/

		#include <linux/sched.h>
		#include <linux/slab.h>
		#include <linux/spinlock.h>
		#include <linux/completion.h>
		#include <linux/buffer_head.h>
		#include <linux/kthread.h>
		#include <linux/delay.h>
		#include <linux/gfs2_ondisk.h>
		#include <linux/lm_interface.h>
		#include <linux/freezer.h>

		#include "gfs2.h"
		#include "incore.h"
		#include "daemon.h"
		#include "glock.h"
		#include "log.h"
		#include "quota.h"
		#include "recovery.h"
		#include "super.h"
		#include "util.h"

		/* This uses schedule_timeout() instead of msleep() because it's good for
		the daemons to wake up more often than the timeout when unmounting so
		the user's unmount doesn't sit there forever.

		The kthread functions used to start these daemons block and flush signals. */

		/**
		* gfs2_glockd - Reclaim unused glock structures
		* @sdp: Pointer to GFS2 superblock
		*
		* One or more of these daemons run, reclaiming glocks on sd_reclaim_list.
		* Number of daemons can be set by user, with num_glockd mount option.
		*/

		int gfs2_glockd(void *data)
		{
		struct gfs2_sbd *sdp = data;

		while (!kthread_should_stop()) {
		while (atomic_read(&sdp->sd_reclaim_count))
		gfs2_reclaim_glock(sdp);

		wait_event_interruptible(sdp->sd_reclaim_wq,
		(atomic_read(&sdp->sd_reclaim_count) \|\|
		kthread_should_stop()));
		if (freezing(current))
		refrigerator();
		}

		return 0;
		}

		/**
		* gfs2_recoverd - Recover dead machine's journals
		* @sdp: Pointer to GFS2 superblock
		*
		*/

		int gfs2_recoverd(void *data)
		{
		struct gfs2_sbd *sdp = data;
		unsigned long t;

		while (!kthread_should_stop()) {
		gfs2_check_journals(sdp);
		t = gfs2_tune_get(sdp, gt_recoverd_secs) * HZ;
		if (freezing(current))
		refrigerator();
		schedule_timeout_interruptible(t);
		}

		return 0;
		}

		/**
		* gfs2_quotad - Write cached quota changes into the quota file
		* @sdp: Pointer to GFS2 superblock
		*
		*/

		int gfs2_quotad(void *data)
		{
		struct gfs2_sbd *sdp = data;
		unsigned long t;
		int error;

		while (!kthread_should_stop()) {
		/* Update the master statfs file */

		t = sdp->sd_statfs_sync_time +
		gfs2_tune_get(sdp, gt_statfs_quantum) * HZ;

		if (time_after_eq(jiffies, t)) {
		error = gfs2_statfs_sync(sdp);
		if (error &&
		error != -EROFS &&
		!test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
		fs_err(sdp, "quotad: (1) error=%d\n", error);
		sdp->sd_statfs_sync_time = jiffies;
		}

		/* Update quota file */

		t = sdp->sd_quota_sync_time +
		gfs2_tune_get(sdp, gt_quota_quantum) * HZ;

		if (time_after_eq(jiffies, t)) {
		error = gfs2_quota_sync(sdp);
		if (error &&
		error != -EROFS &&
		!test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
		fs_err(sdp, "quotad: (2) error=%d\n", error);
		sdp->sd_quota_sync_time = jiffies;
		}

		gfs2_quota_scan(sdp);

		t = gfs2_tune_get(sdp, gt_quotad_secs) * HZ;
		if (freezing(current))
		refrigerator();
		schedule_timeout_interruptible(t);
		}

		return 0;
		}

Admin message