Merge git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-3.0-nmw

go_dump          | Called to print content of object for debugfs file, or on

                 | error to dump glock to the log.

go_type          | The type of the glock, LM_TYPE_.....

go_min_hold_time | The minimum hold time

go_callback	 | Called if the DLM sends a callback to drop this lock

go_flags	 | GLOF_ASPACE is set, if the glock has an address space

                 | associated with it

The minimum hold time for each lock is the time after a remote lock

grant for which we ignore remote demote requests. This is in order to

go_lock       |       Yes               |       No

go_unlock     |       Yes               |       No

go_dump       |       Sometimes         |       Yes

go_callback   |       Sometimes (N/A)   |       Yes

N.B. Operations must not drop either the bit lock or the spinlock

if its held on entry. go_dump and do_demote_ok must never block.

glock is used in conjunction with the i_nlink field in the inode to

determine the lifetime of the inode in question. Locking of inodes

is on a per-inode basis. Locking of rgrps is on a per rgrp basis.

In general we prefer to lock local locks prior to cluster locks.

                            Glock Statistics

                           ------------------

The stats are divided into two sets: those relating to the

super block and those relating to an individual glock. The

super block stats are done on a per cpu basis in order to

try and reduce the overhead of gathering them. They are also

further divided by glock type. All timings are in nanoseconds.

In the case of both the super block and glock statistics,

the same information is gathered in each case. The super

block timing statistics are used to provide default values for

the glock timing statistics, so that newly created glocks

should have, as far as possible, a sensible starting point.

The per-glock counters are initialised to zero when the

glock is created. The per-glock statistics are lost when

the glock is ejected from memory.

The statistics are divided into three pairs of mean and

variance, plus two counters. The mean/variance pairs are

smoothed exponential estimates and the algorithm used is

one which will be very familiar to those used to calculation

of round trip times in network code. See "TCP/IP Illustrated,

Volume 1", W. Richard Stevens, sect 21.3, "Round-Trip Time Measurement",

p. 299 and onwards. Also, Volume 2, Sect. 25.10, p. 838 and onwards.

Unlike the TCP/IP Illustrated case, the mean and variance are

not scaled, but are in units of integer nanoseconds.

The three pairs of mean/variance measure the following

things:

 1. DLM lock time (non-blocking requests)

 2. DLM lock time (blocking requests)

 3. Inter-request time (again to the DLM)

A non-blocking request is one which will complete right

away, whatever the state of the DLM lock in question. That

currently means any requests when (a) the current state of

the lock is exclusive, i.e. a lock demotion (b) the requested

state is either null or unlocked (again, a demotion) or (c) the

"try lock" flag is set. A blocking request covers all the other

lock requests.

There are two counters. The first is there primarily to show

how many lock requests have been made, and thus how much data

has gone into the mean/variance calculations. The other counter

is counting queuing of holders at the top layer of the glock

code. Hopefully that number will be a lot larger than the number

of dlm lock requests issued.

So why gather these statistics? There are several reasons

we'd like to get a better idea of these timings:

1. To be able to better set the glock "min hold time"

2. To spot performance issues more easily

3. To improve the algorithm for selecting resource groups for

allocation (to base it on lock wait time, rather than blindly

using a "try lock")

Due to the smoothing action of the updates, a step change in

some input quantity being sampled will only fully be taken

into account after 8 samples (or 4 for the variance) and this

needs to be carefully considered when interpreting the

results.

Knowing both the time it takes a lock request to complete and

the average time between lock requests for a glock means we

can compute the total percentage of the time for which the

node is able to use a glock vs. time that the rest of the

cluster has its share. That will be very useful when setting

the lock min hold time.

Great care has been taken to ensure that we

measure exactly the quantities that we want, as accurately

as possible. There are always inaccuracies in any

measuring system, but I hope this is as accurate as we

can reasonably make it.

Per sb stats can be found here:

/sys/kernel/debug/gfs2/<fsname>/sbstats

Per glock stats can be found here:

/sys/kernel/debug/gfs2/<fsname>/glstats

Assuming that debugfs is mounted on /sys/kernel/debug and also

that <fsname> is replaced with the name of the gfs2 filesystem

in question.

The abbreviations used in the output as are follows:

srtt     - Smoothed round trip time for non-blocking dlm requests

srttvar  - Variance estimate for srtt

srttb    - Smoothed round trip time for (potentially) blocking dlm requests

srttvarb - Variance estimate for srttb

sirt     - Smoothed inter-request time (for dlm requests)

sirtvar  - Variance estimate for sirt

dlm      - Number of dlm requests made (dcnt in glstats file)

queue    - Number of glock requests queued (qcnt in glstats file)

The sbstats file contains a set of these stats for each glock type (so 8 lines

for each type) and for each cpu (one column per cpu). The glstats file contains

a set of these stats for each glock in a similar format to the glocks file, but

using the format mean/variance for each of the timing stats.

The gfs2_glock_lock_time tracepoint prints out the current values of the stats

for the glock in question, along with some addition information on each dlm

reply that is received:

status - The status of the dlm request

flags  - The dlm request flags

tdiff  - The time taken by this specific request

(remaining fields as per above list)

Global File System

------------------

http://sources.redhat.com/cluster/wiki/

https://fedorahosted.org/cluster/wiki/HomePage

GFS is a cluster file system. It allows a cluster of computers to

simultaneously use a block device that is shared between them (with FC,

If you are using Fedora, you need to install the gfs2-utils package

and, for lock_dlm, you will also need to install the cman package

and write a cluster.conf as per the documentation.

and write a cluster.conf as per the documentation. For F17 and above

cman has been replaced by the dlm package.

GFS2 is not on-disk compatible with previous versions of GFS, but it

is pretty close.

  fsck.gfs2		to repair a filesystem

  gfs2_grow		to expand a filesystem online

  gfs2_jadd		to add journals to a filesystem online

  gfs2_tool		to manipulate, examine and tune a filesystem

  gfs2_quota	to examine and change quota values in a filesystem

  tunegfs2		to manipulate, examine and tune a filesystem

  gfs2_convert	to convert a gfs filesystem to gfs2 in-place

  mount.gfs2	to help mount(8) mount a filesystem

  mkfs.gfs2		to make a filesystem

	int error = 0;

	if (mode != inode->i_mode) {

		struct iattr iattr;

		iattr.ia_valid = ATTR_MODE;

		iattr.ia_mode = mode;

		error = gfs2_setattr_simple(inode, &iattr);

		inode->i_mode = mode;

		mark_inode_dirty(inode);

	}

	return error;

		return PTR_ERR(acl);

	if (!acl) {

		mode &= ~current_umask();

		if (mode != inode->i_mode)

			error = gfs2_set_mode(inode, mode);

		return error;

		return gfs2_set_mode(inode, mode);

	}

	if (S_ISDIR(inode->i_mode)) {

#include "glops.h"

void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page,

static void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page,

				   unsigned int from, unsigned int to)

{

	struct buffer_head *head = page_buffers(page);

/**

 * gfs2_internal_read - read an internal file

 * @ip: The gfs2 inode

 * @ra_state: The readahead state (or NULL for no readahead)

 * @buf: The buffer to fill

 * @pos: The file position

 * @size: The amount to read

 *

 */

int gfs2_internal_read(struct gfs2_inode *ip, struct file_ra_state *ra_state,

                       char *buf, loff_t *pos, unsigned size)

int gfs2_internal_read(struct gfs2_inode *ip, char *buf, loff_t *pos,

                       unsigned size)

{

	struct address_space *mapping = ip->i_inode.i_mapping;

	unsigned long index = *pos / PAGE_CACHE_SIZE;

	clear_buffer_dirty(bh);

	bd = bh->b_private;

	if (bd) {

		if (!list_empty(&bd->bd_le.le_list) && !buffer_pinned(bh))

			list_del_init(&bd->bd_le.le_list);

		if (!list_empty(&bd->bd_list) && !buffer_pinned(bh))

			list_del_init(&bd->bd_list);

		else

			gfs2_remove_from_journal(bh, current->journal_info, 0);

	}

		bd = bh->b_private;

		if (bd) {

			gfs2_assert_warn(sdp, bd->bd_bh == bh);

			gfs2_assert_warn(sdp, list_empty(&bd->bd_list_tr));

			if (!list_empty(&bd->bd_le.le_list)) {

			if (!list_empty(&bd->bd_list)) {

				if (!buffer_pinned(bh))

					list_del_init(&bd->bd_le.le_list);

					list_del_init(&bd->bd_list);

				else

					bd = NULL;

			}

		if (!dblock)

			return x + 1;

		ret = gfs2_meta_indirect_buffer(ip, x+1, dblock, 0, &mp->mp_bh[x+1]);

		ret = gfs2_meta_indirect_buffer(ip, x+1, dblock, &mp->mp_bh[x+1]);

		if (ret)

			return ret;

	}

		top = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + mp->mp_list[0];

		bottom = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + sdp->sd_diptrs;

	} else {

		error = gfs2_meta_indirect_buffer(ip, height, block, 0, &bh);

		error = gfs2_meta_indirect_buffer(ip, height, block, &bh);

		if (error)

			return error;

	struct buffer_head *dibh;

	struct gfs2_qadata *qa = NULL;

	int error;

	int unstuff = 0;

	if (gfs2_is_stuffed(ip) &&

	    (size > (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)))) {

		error = gfs2_inplace_reserve(ip, 1);

		if (error)

			goto do_grow_qunlock;

		unstuff = 1;

	}

	error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT, 0);

	if (error)

		goto do_grow_release;

	if (qa) {

	if (unstuff) {

		error = gfs2_unstuff_dinode(ip, NULL);

		if (error)

			goto do_end_trans;

do_end_trans:

	gfs2_trans_end(sdp);

do_grow_release:

	if (qa) {

	if (unstuff) {

		gfs2_inplace_release(ip);

do_grow_qunlock:

		gfs2_quota_unlock(ip);