<feed xmlns='http://www.w3.org/2005/Atom'>
<title>linux/fs/lockd, branch v2.6.26-rc5</title>
<subtitle>Linux kernel source tree</subtitle>
<id>https://git.amat.us/linux/atom/fs/lockd?h=v2.6.26-rc5</id>
<link rel='self' href='https://git.amat.us/linux/atom/fs/lockd?h=v2.6.26-rc5'/>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/'/>
<updated>2008-04-30T15:29:54Z</updated>
<entry>
<title>fs: replace remaining __FUNCTION__ occurrences</title>
<updated>2008-04-30T15:29:54Z</updated>
<author>
<name>Harvey Harrison</name>
<email>harvey.harrison@gmail.com</email>
</author>
<published>2008-04-30T07:55:09Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=8e24eea728068bbeb6a3c500b848f883a20bf225'/>
<id>urn:sha1:8e24eea728068bbeb6a3c500b848f883a20bf225</id>
<content type='text'>
__FUNCTION__ is gcc-specific, use __func__

Signed-off-by: Harvey Harrison &lt;harvey.harrison@gmail.com&gt;
Signed-off-by: Andrew Morton &lt;akpm@linux-foundation.org&gt;
Signed-off-by: Linus Torvalds &lt;torvalds@linux-foundation.org&gt;
</content>
</entry>
<entry>
<title>locks: don't call -&gt;copy_lock methods on return of conflicting locks</title>
<updated>2008-04-25T17:00:11Z</updated>
<author>
<name>J. Bruce Fields</name>
<email>bfields@citi.umich.edu</email>
</author>
<published>2008-04-24T14:08:22Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=1a747ee0cc11a198f9e2435add821bd0dfedb7c1'/>
<id>urn:sha1:1a747ee0cc11a198f9e2435add821bd0dfedb7c1</id>
<content type='text'>
The file_lock structure is used both as a heavy-weight representation of
an active lock, with pointers to reference-counted structures, etc., and
as a simple container for parameters that describe a file lock.

The conflicting lock returned from __posix_lock_file is an example of
the latter; so don't call the filesystem or lock manager callbacks when
copying to it.  This also saves the need for an unnecessary
locks_init_lock in the nfsv4 server.

Thanks to Trond for pointing out the error.

Signed-off-by: J. Bruce Fields &lt;bfields@citi.umich.edu&gt;
Cc: Trond Myklebust &lt;Trond.Myklebust@netapp.com&gt;
</content>
</entry>
<entry>
<title>lockd: unlock lockd locks held for a certain filesystem</title>
<updated>2008-04-25T17:00:11Z</updated>
<author>
<name>Wendy Cheng</name>
<email>wcheng@redhat.com</email>
</author>
<published>2008-01-17T16:10:12Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=17efa372cfe4d189705edf6cd4fbe283827a5dc7'/>
<id>urn:sha1:17efa372cfe4d189705edf6cd4fbe283827a5dc7</id>
<content type='text'>
Add /proc/fs/nfsd/unlock_filesystem, which allows e.g.:

shell&gt; echo /mnt/sfs1 &gt; /proc/fs/nfsd/unlock_filesystem

so that a filesystem can be unmounted before allowing a peer nfsd to
take over nfs service for the filesystem.

Signed-off-by: S. Wendy Cheng &lt;wcheng@redhat.com&gt;
Cc: Lon Hohberger  &lt;lhh@redhat.com&gt;
Cc: Christoph Hellwig &lt;hch@lst.de&gt;
Signed-off-by: J. Bruce Fields &lt;bfields@citi.umich.edu&gt;

 fs/lockd/svcsubs.c          |   66 +++++++++++++++++++++++++++++++++++++++-----
 fs/nfsd/nfsctl.c            |   65 +++++++++++++++++++++++++++++++++++++++++++
 include/linux/lockd/lockd.h |    7 ++++
 3 files changed, 131 insertions(+), 7 deletions(-)
</content>
</entry>
<entry>
<title>lockd: unlock lockd locks associated with a given server ip</title>
<updated>2008-04-25T17:00:10Z</updated>
<author>
<name>Wendy Cheng</name>
<email>wcheng@redhat.com</email>
</author>
<published>2008-01-17T16:10:12Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=4373ea84c84d8a96e99d3da99e813d3e36d1bd11'/>
<id>urn:sha1:4373ea84c84d8a96e99d3da99e813d3e36d1bd11</id>
<content type='text'>
For high-availability NFS service, we generally need to be able to drop
file locks held on the exported filesystem before moving clients to a
new server.  Currently the only way to do that is by shutting down lockd
entirely, which is often undesireable (for example, if you want to
continue exporting other filesystems).

This patch allows the administrator to release all locks held by clients
accessing the client through a given server ip address, by echoing that
address to a new file, /proc/fs/nfsd/unlock_ip, as in:

shell&gt; echo 10.1.1.2 &gt; /proc/fs/nfsd/unlock_ip

The expected sequence of events can be:
1. Tear down the IP address
2. Unexport the path
3. Write IP to /proc/fs/nfsd/unlock_ip to unlock files
4. Signal peer to begin take-over.

For now we only support IPv4 addresses and NFSv2/v3 (NFSv4 locks are not
affected).

Also, if unmounting the filesystem is required, we assume at step 3 that
clients using the given server ip are the only clients holding locks on
the given filesystem; otherwise, an additional patch is required to
allow revoking all locks held by lockd on a given filesystem.

Signed-off-by: S. Wendy Cheng &lt;wcheng@redhat.com&gt;
Cc: Lon Hohberger  &lt;lhh@redhat.com&gt;
Cc: Christoph Hellwig &lt;hch@lst.de&gt;
Signed-off-by: J. Bruce Fields &lt;bfields@citi.umich.edu&gt;

 fs/lockd/svcsubs.c          |   66 +++++++++++++++++++++++++++++++++++++++-----
 fs/nfsd/nfsctl.c            |   65 +++++++++++++++++++++++++++++++++++++++++++
 include/linux/lockd/lockd.h |    7 ++++
 3 files changed, 131 insertions(+), 7 deletions(-)
</content>
</entry>
<entry>
<title>Merge git://git.linux-nfs.org/projects/trondmy/nfs-2.6</title>
<updated>2008-04-24T18:46:16Z</updated>
<author>
<name>Linus Torvalds</name>
<email>torvalds@linux-foundation.org</email>
</author>
<published>2008-04-24T18:46:16Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=563307b2fa15d687abc54bd980b9847ebf0e3231'/>
<id>urn:sha1:563307b2fa15d687abc54bd980b9847ebf0e3231</id>
<content type='text'>
* git://git.linux-nfs.org/projects/trondmy/nfs-2.6: (80 commits)
  SUNRPC: Invalidate the RPCSEC_GSS session if the server dropped the request
  make nfs_automount_list static
  NFS: remove duplicate flags assignment from nfs_validate_mount_data
  NFS - fix potential NULL pointer dereference v2
  SUNRPC: Don't change the RPCSEC_GSS context on a credential that is in use
  SUNRPC: Fix a race in gss_refresh_upcall()
  SUNRPC: Don't disconnect more than once if retransmitting NFSv4 requests
  SUNRPC: Remove the unused export of xprt_force_disconnect
  SUNRPC: remove XS_SENDMSG_RETRY
  SUNRPC: Protect creds against early garbage collection
  NFSv4: Attempt to use machine credentials in SETCLIENTID calls
  NFSv4: Reintroduce machine creds
  NFSv4: Don't use cred-&gt;cr_ops-&gt;cr_name in nfs4_proc_setclientid()
  nfs: fix printout of multiword bitfields
  nfs: return negative error value from nfs{,4}_stat_to_errno
  NLM/lockd: Ensure client locking calls use correct credentials
  NFS: Remove the buggy lock-if-signalled case from do_setlk()
  NLM/lockd: Fix a race when cancelling a blocking lock
  NLM/lockd: Ensure that nlmclnt_cancel() returns results of the CANCEL call
  NLM: Remove the signal masking in nlmclnt_proc/nlmclnt_cancel
  ...
</content>
</entry>
<entry>
<title>NLM: don't let lockd exit on unexpected svc_recv errors (try #2)</title>
<updated>2008-04-23T20:13:43Z</updated>
<author>
<name>Jeff Layton</name>
<email>jlayton@redhat.com</email>
</author>
<published>2008-04-08T19:40:08Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=f97c650dda24e48405399aa0676e90da52408515'/>
<id>urn:sha1:f97c650dda24e48405399aa0676e90da52408515</id>
<content type='text'>
When svc_recv returns an unexpected error, lockd will print a warning
and exit. This problematic for several reasons. In particular, it will
cause the reference counts for the thread to be wrong, and can lead to a
potential BUG() call.

Rather than exiting on error from svc_recv, have the thread do a 1s
sleep and then retry the loop. This is unlikely to cause any harm, and
if the error turns out to be something temporary then it may be able to
recover.

Signed-off-by: Jeff Layton &lt;jlayton@redhat.com&gt;
Signed-off-by: J. Bruce Fields &lt;bfields@citi.umich.edu&gt;
</content>
</entry>
<entry>
<title>lockd: Fix stale nlmsvc_unlink_block comment</title>
<updated>2008-04-23T20:13:42Z</updated>
<author>
<name>J. Bruce Fields</name>
<email>bfields@citi.umich.edu</email>
</author>
<published>2008-04-07T17:05:27Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=3c61eecb607dbc2777074b1a95b8a97e31a96a73'/>
<id>urn:sha1:3c61eecb607dbc2777074b1a95b8a97e31a96a73</id>
<content type='text'>
As of 5996a298da43a03081e9ba2116983d173001c862 ("NLM: don't unlock on
cancel requests") we no longer unlock in this case, so the comment is no
longer accurate.

Thanks to Stuart Friedberg for pointing out the inconsistency.

Cc: Stuart Friedberg &lt;sfriedberg@hp.com&gt;
Signed-off-by: J. Bruce Fields &lt;bfields@citi.umich.edu&gt;
</content>
</entry>
<entry>
<title>lockd: convert nsm_mutex to a spinlock</title>
<updated>2008-04-23T20:13:39Z</updated>
<author>
<name>J. Bruce Fields</name>
<email>bfields@citi.umich.edu</email>
</author>
<published>2008-02-20T20:40:15Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=d8421202121ce74daf4625ca9d1d825bbd7ce66a'/>
<id>urn:sha1:d8421202121ce74daf4625ca9d1d825bbd7ce66a</id>
<content type='text'>
There's no reason for a mutex here, except to allow an allocation under
the lock, which we can avoid with the usual trick of preallocating
memory for the new object and freeing it if it turns out to be
unnecessary.

Signed-off-by: J. Bruce Fields &lt;bfields@citi.umich.edu&gt;
</content>
</entry>
<entry>
<title>lockd: clean up __nsm_find()</title>
<updated>2008-04-23T20:13:39Z</updated>
<author>
<name>J. Bruce Fields</name>
<email>bfields@citi.umich.edu</email>
</author>
<published>2008-02-20T20:27:31Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=a95e56e72c196970a8067cd515c658d064813170'/>
<id>urn:sha1:a95e56e72c196970a8067cd515c658d064813170</id>
<content type='text'>
Use list_for_each_entry().  Also, in keeping with kernel style, make the
normal case (kzalloc succeeds) unindented and handle the abnormal case
with a goto.

Signed-off-by: J. Bruce Fields &lt;bfields@citi.umich.edu&gt;
</content>
</entry>
<entry>
<title>lockd: fix race in nlm_release()</title>
<updated>2008-04-23T20:13:39Z</updated>
<author>
<name>J. Bruce Fields</name>
<email>bfields@citi.umich.edu</email>
</author>
<published>2008-02-20T19:02:47Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/linux/commit/?id=164f98adbbd50c67177b096a59f55c1a56a45c82'/>
<id>urn:sha1:164f98adbbd50c67177b096a59f55c1a56a45c82</id>
<content type='text'>
The sm_count is decremented to zero but left on the nsm_handles list.
So in the space between decrementing sm_count and acquiring nsm_mutex,
it is possible for another task to find this nsm_handle, increment the
use count and then enter nsm_release itself.

Thus there's nothing to prevent the nsm being freed before we acquire
nsm_mutex here.

Signed-off-by: J. Bruce Fields &lt;bfields@citi.umich.edu&gt;
</content>
</entry>
</feed>
