aboutsummaryrefslogtreecommitdiffstats
path: root/fs
diff options
context:
space:
mode:
Diffstat (limited to 'fs')
-rw-r--r--fs/binfmt_elf.c9
-rw-r--r--fs/compat.c4
-rw-r--r--fs/dlm/lowcomms.c27
-rw-r--r--fs/dlm/netlink.c2
-rw-r--r--fs/dlm/plock.c2
-rw-r--r--fs/exec.c12
-rw-r--r--fs/file.c152
-rw-r--r--fs/gfs2/glops.c2
-rw-r--r--fs/gfs2/incore.h1
-rw-r--r--fs/gfs2/inode.c10
-rw-r--r--fs/gfs2/meta_io.c6
-rw-r--r--fs/gfs2/ops_fstype.c4
-rw-r--r--fs/gfs2/ops_super.c16
-rw-r--r--fs/gfs2/rgrp.c2
-rw-r--r--fs/namei.c12
-rw-r--r--fs/nfs/callback.c2
-rw-r--r--fs/nfs/callback_proc.c4
-rw-r--r--fs/nfs/callback_xdr.c40
-rw-r--r--fs/nfs/client.c8
-rw-r--r--fs/nfs/delegation.c4
-rw-r--r--fs/nfs/dir.c18
-rw-r--r--fs/nfs/file.c2
-rw-r--r--fs/nfs/inode.c14
-rw-r--r--fs/nfs/namespace.c11
-rw-r--r--fs/nfs/nfs3proc.c6
-rw-r--r--fs/nfs/nfs4_fs.h1
-rw-r--r--fs/nfs/nfs4namespace.c12
-rw-r--r--fs/nfs/nfs4proc.c38
-rw-r--r--fs/nfs/nfs4renewd.c10
-rw-r--r--fs/nfs/nfs4state.c8
-rw-r--r--fs/nfs/nfs4xdr.c100
-rw-r--r--fs/nfs/proc.c8
-rw-r--r--fs/nfs/read.c2
-rw-r--r--fs/nfs/super.c12
-rw-r--r--fs/nfs/write.c2
-rw-r--r--fs/proc/base.c2
-rw-r--r--fs/sysfs/dir.c6
37 files changed, 371 insertions, 200 deletions
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index b25707fee2cc..0fa95b198e6e 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -256,7 +256,7 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
256 return -EFAULT; 256 return -EFAULT;
257 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN); 257 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
258 if (!len || len > MAX_ARG_STRLEN) 258 if (!len || len > MAX_ARG_STRLEN)
259 return 0; 259 return -EINVAL;
260 p += len; 260 p += len;
261 } 261 }
262 if (__put_user(0, argv)) 262 if (__put_user(0, argv))
@@ -268,7 +268,7 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
268 return -EFAULT; 268 return -EFAULT;
269 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN); 269 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
270 if (!len || len > MAX_ARG_STRLEN) 270 if (!len || len > MAX_ARG_STRLEN)
271 return 0; 271 return -EINVAL;
272 p += len; 272 p += len;
273 } 273 }
274 if (__put_user(0, envp)) 274 if (__put_user(0, envp))
@@ -1900,7 +1900,7 @@ static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file, un
1900 /* alloc memory for large data structures: too large to be on stack */ 1900 /* alloc memory for large data structures: too large to be on stack */
1901 elf = kmalloc(sizeof(*elf), GFP_KERNEL); 1901 elf = kmalloc(sizeof(*elf), GFP_KERNEL);
1902 if (!elf) 1902 if (!elf)
1903 goto cleanup; 1903 goto out;
1904 1904
1905 segs = current->mm->map_count; 1905 segs = current->mm->map_count;
1906#ifdef ELF_CORE_EXTRA_PHDRS 1906#ifdef ELF_CORE_EXTRA_PHDRS
@@ -2034,8 +2034,9 @@ end_coredump:
2034 set_fs(fs); 2034 set_fs(fs);
2035 2035
2036cleanup: 2036cleanup:
2037 kfree(elf);
2038 free_note_info(&info); 2037 free_note_info(&info);
2038 kfree(elf);
2039out:
2039 return has_dumped; 2040 return has_dumped;
2040} 2041}
2041 2042
diff --git a/fs/compat.c b/fs/compat.c
index 332a869d2c53..ed43e17a5dc6 100644
--- a/fs/compat.c
+++ b/fs/compat.c
@@ -1405,7 +1405,7 @@ int compat_do_execve(char * filename,
1405 /* execve success */ 1405 /* execve success */
1406 security_bprm_free(bprm); 1406 security_bprm_free(bprm);
1407 acct_update_integrals(current); 1407 acct_update_integrals(current);
1408 kfree(bprm); 1408 free_bprm(bprm);
1409 return retval; 1409 return retval;
1410 } 1410 }
1411 1411
@@ -1424,7 +1424,7 @@ out_file:
1424 } 1424 }
1425 1425
1426out_kfree: 1426out_kfree:
1427 kfree(bprm); 1427 free_bprm(bprm);
1428 1428
1429out_ret: 1429out_ret:
1430 return retval; 1430 return retval;
diff --git a/fs/dlm/lowcomms.c b/fs/dlm/lowcomms.c
index 7c1e5e5cccd8..637018c891ef 100644
--- a/fs/dlm/lowcomms.c
+++ b/fs/dlm/lowcomms.c
@@ -50,6 +50,7 @@
50#include <linux/pagemap.h> 50#include <linux/pagemap.h>
51#include <linux/idr.h> 51#include <linux/idr.h>
52#include <linux/file.h> 52#include <linux/file.h>
53#include <linux/mutex.h>
53#include <linux/sctp.h> 54#include <linux/sctp.h>
54#include <net/sctp/user.h> 55#include <net/sctp/user.h>
55 56
@@ -138,7 +139,7 @@ static struct workqueue_struct *recv_workqueue;
138static struct workqueue_struct *send_workqueue; 139static struct workqueue_struct *send_workqueue;
139 140
140static DEFINE_IDR(connections_idr); 141static DEFINE_IDR(connections_idr);
141static DECLARE_MUTEX(connections_lock); 142static DEFINE_MUTEX(connections_lock);
142static int max_nodeid; 143static int max_nodeid;
143static struct kmem_cache *con_cache; 144static struct kmem_cache *con_cache;
144 145
@@ -205,9 +206,9 @@ static struct connection *nodeid2con(int nodeid, gfp_t allocation)
205{ 206{
206 struct connection *con; 207 struct connection *con;
207 208
208 down(&connections_lock); 209 mutex_lock(&connections_lock);
209 con = __nodeid2con(nodeid, allocation); 210 con = __nodeid2con(nodeid, allocation);
210 up(&connections_lock); 211 mutex_unlock(&connections_lock);
211 212
212 return con; 213 return con;
213} 214}
@@ -218,15 +219,15 @@ static struct connection *assoc2con(int assoc_id)
218 int i; 219 int i;
219 struct connection *con; 220 struct connection *con;
220 221
221 down(&connections_lock); 222 mutex_lock(&connections_lock);
222 for (i=0; i<=max_nodeid; i++) { 223 for (i=0; i<=max_nodeid; i++) {
223 con = __nodeid2con(i, 0); 224 con = __nodeid2con(i, 0);
224 if (con && con->sctp_assoc == assoc_id) { 225 if (con && con->sctp_assoc == assoc_id) {
225 up(&connections_lock); 226 mutex_unlock(&connections_lock);
226 return con; 227 return con;
227 } 228 }
228 } 229 }
229 up(&connections_lock); 230 mutex_unlock(&connections_lock);
230 return NULL; 231 return NULL;
231} 232}
232 233
@@ -381,7 +382,7 @@ static void sctp_init_failed(void)
381 int i; 382 int i;
382 struct connection *con; 383 struct connection *con;
383 384
384 down(&connections_lock); 385 mutex_lock(&connections_lock);
385 for (i=1; i<=max_nodeid; i++) { 386 for (i=1; i<=max_nodeid; i++) {
386 con = __nodeid2con(i, 0); 387 con = __nodeid2con(i, 0);
387 if (!con) 388 if (!con)
@@ -393,7 +394,7 @@ static void sctp_init_failed(void)
393 } 394 }
394 } 395 }
395 } 396 }
396 up(&connections_lock); 397 mutex_unlock(&connections_lock);
397} 398}
398 399
399/* Something happened to an association */ 400/* Something happened to an association */
@@ -930,7 +931,7 @@ out_err:
930 * errors we try again until the max number of retries is reached. 931 * errors we try again until the max number of retries is reached.
931 */ 932 */
932 if (result != -EHOSTUNREACH && result != -ENETUNREACH && 933 if (result != -EHOSTUNREACH && result != -ENETUNREACH &&
933 result != -ENETDOWN && result != EINVAL 934 result != -ENETDOWN && result != -EINVAL
934 && result != -EPROTONOSUPPORT) { 935 && result != -EPROTONOSUPPORT) {
935 lowcomms_connect_sock(con); 936 lowcomms_connect_sock(con);
936 result = 0; 937 result = 0;
@@ -1417,7 +1418,7 @@ void dlm_lowcomms_stop(void)
1417 /* Set all the flags to prevent any 1418 /* Set all the flags to prevent any
1418 socket activity. 1419 socket activity.
1419 */ 1420 */
1420 down(&connections_lock); 1421 mutex_lock(&connections_lock);
1421 for (i = 0; i <= max_nodeid; i++) { 1422 for (i = 0; i <= max_nodeid; i++) {
1422 con = __nodeid2con(i, 0); 1423 con = __nodeid2con(i, 0);
1423 if (con) { 1424 if (con) {
@@ -1426,11 +1427,11 @@ void dlm_lowcomms_stop(void)
1426 con->sock->sk->sk_user_data = NULL; 1427 con->sock->sk->sk_user_data = NULL;
1427 } 1428 }
1428 } 1429 }
1429 up(&connections_lock); 1430 mutex_unlock(&connections_lock);
1430 1431
1431 work_stop(); 1432 work_stop();
1432 1433
1433 down(&connections_lock); 1434 mutex_lock(&connections_lock);
1434 clean_writequeues(); 1435 clean_writequeues();
1435 1436
1436 for (i = 0; i <= max_nodeid; i++) { 1437 for (i = 0; i <= max_nodeid; i++) {
@@ -1443,7 +1444,7 @@ void dlm_lowcomms_stop(void)
1443 } 1444 }
1444 } 1445 }
1445 max_nodeid = 0; 1446 max_nodeid = 0;
1446 up(&connections_lock); 1447 mutex_unlock(&connections_lock);
1447 kmem_cache_destroy(con_cache); 1448 kmem_cache_destroy(con_cache);
1448 idr_init(&connections_idr); 1449 idr_init(&connections_idr);
1449} 1450}
diff --git a/fs/dlm/netlink.c b/fs/dlm/netlink.c
index 714593621f4f..18bda83cc892 100644
--- a/fs/dlm/netlink.c
+++ b/fs/dlm/netlink.c
@@ -95,7 +95,7 @@ int __init dlm_netlink_init(void)
95 return rv; 95 return rv;
96} 96}
97 97
98void __exit dlm_netlink_exit(void) 98void dlm_netlink_exit(void)
99{ 99{
100 genl_unregister_ops(&family, &dlm_nl_ops); 100 genl_unregister_ops(&family, &dlm_nl_ops);
101 genl_unregister_family(&family); 101 genl_unregister_family(&family);
diff --git a/fs/dlm/plock.c b/fs/dlm/plock.c
index d6d6e370f89c..78878c5781ca 100644
--- a/fs/dlm/plock.c
+++ b/fs/dlm/plock.c
@@ -379,7 +379,7 @@ static ssize_t dev_write(struct file *file, const char __user *u, size_t count,
379 struct plock_xop *xop; 379 struct plock_xop *xop;
380 xop = (struct plock_xop *)op; 380 xop = (struct plock_xop *)op;
381 if (xop->callback) 381 if (xop->callback)
382 count = dlm_plock_callback(op); 382 dlm_plock_callback(op);
383 else 383 else
384 wake_up(&recv_wq); 384 wake_up(&recv_wq);
385 } else 385 } else
diff --git a/fs/exec.c b/fs/exec.c
index 1f8a24aa1f8b..3c2ba7ce11d4 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -1251,6 +1251,12 @@ int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
1251 1251
1252EXPORT_SYMBOL(search_binary_handler); 1252EXPORT_SYMBOL(search_binary_handler);
1253 1253
1254void free_bprm(struct linux_binprm *bprm)
1255{
1256 free_arg_pages(bprm);
1257 kfree(bprm);
1258}
1259
1254/* 1260/*
1255 * sys_execve() executes a new program. 1261 * sys_execve() executes a new program.
1256 */ 1262 */
@@ -1320,17 +1326,15 @@ int do_execve(char * filename,
1320 retval = search_binary_handler(bprm,regs); 1326 retval = search_binary_handler(bprm,regs);
1321 if (retval >= 0) { 1327 if (retval >= 0) {
1322 /* execve success */ 1328 /* execve success */
1323 free_arg_pages(bprm);
1324 security_bprm_free(bprm); 1329 security_bprm_free(bprm);
1325 acct_update_integrals(current); 1330 acct_update_integrals(current);
1326 kfree(bprm); 1331 free_bprm(bprm);
1327 if (displaced) 1332 if (displaced)
1328 put_files_struct(displaced); 1333 put_files_struct(displaced);
1329 return retval; 1334 return retval;
1330 } 1335 }
1331 1336
1332out: 1337out:
1333 free_arg_pages(bprm);
1334 if (bprm->security) 1338 if (bprm->security)
1335 security_bprm_free(bprm); 1339 security_bprm_free(bprm);
1336 1340
@@ -1344,7 +1348,7 @@ out_file:
1344 fput(bprm->file); 1348 fput(bprm->file);
1345 } 1349 }
1346out_kfree: 1350out_kfree:
1347 kfree(bprm); 1351 free_bprm(bprm);
1348 1352
1349out_files: 1353out_files:
1350 if (displaced) 1354 if (displaced)
diff --git a/fs/file.c b/fs/file.c
index 4c6f0ea12c41..7b3887e054d0 100644
--- a/fs/file.c
+++ b/fs/file.c
@@ -26,6 +26,8 @@ struct fdtable_defer {
26}; 26};
27 27
28int sysctl_nr_open __read_mostly = 1024*1024; 28int sysctl_nr_open __read_mostly = 1024*1024;
29int sysctl_nr_open_min = BITS_PER_LONG;
30int sysctl_nr_open_max = 1024 * 1024; /* raised later */
29 31
30/* 32/*
31 * We use this list to defer free fdtables that have vmalloced 33 * We use this list to defer free fdtables that have vmalloced
@@ -119,8 +121,6 @@ static void copy_fdtable(struct fdtable *nfdt, struct fdtable *ofdt)
119 unsigned int cpy, set; 121 unsigned int cpy, set;
120 122
121 BUG_ON(nfdt->max_fds < ofdt->max_fds); 123 BUG_ON(nfdt->max_fds < ofdt->max_fds);
122 if (ofdt->max_fds == 0)
123 return;
124 124
125 cpy = ofdt->max_fds * sizeof(struct file *); 125 cpy = ofdt->max_fds * sizeof(struct file *);
126 set = (nfdt->max_fds - ofdt->max_fds) * sizeof(struct file *); 126 set = (nfdt->max_fds - ofdt->max_fds) * sizeof(struct file *);
@@ -261,6 +261,139 @@ int expand_files(struct files_struct *files, int nr)
261 return expand_fdtable(files, nr); 261 return expand_fdtable(files, nr);
262} 262}
263 263
264static int count_open_files(struct fdtable *fdt)
265{
266 int size = fdt->max_fds;
267 int i;
268
269 /* Find the last open fd */
270 for (i = size/(8*sizeof(long)); i > 0; ) {
271 if (fdt->open_fds->fds_bits[--i])
272 break;
273 }
274 i = (i+1) * 8 * sizeof(long);
275 return i;
276}
277
278/*
279 * Allocate a new files structure and copy contents from the
280 * passed in files structure.
281 * errorp will be valid only when the returned files_struct is NULL.
282 */
283struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)
284{
285 struct files_struct *newf;
286 struct file **old_fds, **new_fds;
287 int open_files, size, i;
288 struct fdtable *old_fdt, *new_fdt;
289
290 *errorp = -ENOMEM;
291 newf = kmem_cache_alloc(files_cachep, GFP_KERNEL);
292 if (!newf)
293 goto out;
294
295 atomic_set(&newf->count, 1);
296
297 spin_lock_init(&newf->file_lock);
298 newf->next_fd = 0;
299 new_fdt = &newf->fdtab;
300 new_fdt->max_fds = NR_OPEN_DEFAULT;
301 new_fdt->close_on_exec = (fd_set *)&newf->close_on_exec_init;
302 new_fdt->open_fds = (fd_set *)&newf->open_fds_init;
303 new_fdt->fd = &newf->fd_array[0];
304 INIT_RCU_HEAD(&new_fdt->rcu);
305 new_fdt->next = NULL;
306
307 spin_lock(&oldf->file_lock);
308 old_fdt = files_fdtable(oldf);
309 open_files = count_open_files(old_fdt);
310
311 /*
312 * Check whether we need to allocate a larger fd array and fd set.
313 */
314 while (unlikely(open_files > new_fdt->max_fds)) {
315 spin_unlock(&oldf->file_lock);
316
317 if (new_fdt != &newf->fdtab) {
318 free_fdarr(new_fdt);
319 free_fdset(new_fdt);
320 kfree(new_fdt);
321 }
322
323 new_fdt = alloc_fdtable(open_files - 1);
324 if (!new_fdt) {
325 *errorp = -ENOMEM;
326 goto out_release;
327 }
328
329 /* beyond sysctl_nr_open; nothing to do */
330 if (unlikely(new_fdt->max_fds < open_files)) {
331 free_fdarr(new_fdt);
332 free_fdset(new_fdt);
333 kfree(new_fdt);
334 *errorp = -EMFILE;
335 goto out_release;
336 }
337
338 /*
339 * Reacquire the oldf lock and a pointer to its fd table
340 * who knows it may have a new bigger fd table. We need
341 * the latest pointer.
342 */
343 spin_lock(&oldf->file_lock);
344 old_fdt = files_fdtable(oldf);
345 open_files = count_open_files(old_fdt);
346 }
347
348 old_fds = old_fdt->fd;
349 new_fds = new_fdt->fd;
350
351 memcpy(new_fdt->open_fds->fds_bits,
352 old_fdt->open_fds->fds_bits, open_files/8);
353 memcpy(new_fdt->close_on_exec->fds_bits,
354 old_fdt->close_on_exec->fds_bits, open_files/8);
355
356 for (i = open_files; i != 0; i--) {
357 struct file *f = *old_fds++;
358 if (f) {
359 get_file(f);
360 } else {
361 /*
362 * The fd may be claimed in the fd bitmap but not yet
363 * instantiated in the files array if a sibling thread
364 * is partway through open(). So make sure that this
365 * fd is available to the new process.
366 */
367 FD_CLR(open_files - i, new_fdt->open_fds);
368 }
369 rcu_assign_pointer(*new_fds++, f);
370 }
371 spin_unlock(&oldf->file_lock);
372
373 /* compute the remainder to be cleared */
374 size = (new_fdt->max_fds - open_files) * sizeof(struct file *);
375
376 /* This is long word aligned thus could use a optimized version */
377 memset(new_fds, 0, size);
378
379 if (new_fdt->max_fds > open_files) {
380 int left = (new_fdt->max_fds-open_files)/8;
381 int start = open_files / (8 * sizeof(unsigned long));
382
383 memset(&new_fdt->open_fds->fds_bits[start], 0, left);
384 memset(&new_fdt->close_on_exec->fds_bits[start], 0, left);
385 }
386
387 rcu_assign_pointer(newf->fdt, new_fdt);
388
389 return newf;
390
391out_release:
392 kmem_cache_free(files_cachep, newf);
393out:
394 return NULL;
395}
396
264static void __devinit fdtable_defer_list_init(int cpu) 397static void __devinit fdtable_defer_list_init(int cpu)
265{ 398{
266 struct fdtable_defer *fddef = &per_cpu(fdtable_defer_list, cpu); 399 struct fdtable_defer *fddef = &per_cpu(fdtable_defer_list, cpu);
@@ -274,4 +407,19 @@ void __init files_defer_init(void)
274 int i; 407 int i;
275 for_each_possible_cpu(i) 408 for_each_possible_cpu(i)
276 fdtable_defer_list_init(i); 409 fdtable_defer_list_init(i);
410 sysctl_nr_open_max = min((size_t)INT_MAX, ~(size_t)0/sizeof(void *)) &
411 -BITS_PER_LONG;
277} 412}
413
414struct files_struct init_files = {
415 .count = ATOMIC_INIT(1),
416 .fdt = &init_files.fdtab,
417 .fdtab = {
418 .max_fds = NR_OPEN_DEFAULT,
419 .fd = &init_files.fd_array[0],
420 .close_on_exec = (fd_set *)&init_files.close_on_exec_init,
421 .open_fds = (fd_set *)&init_files.open_fds_init,
422 .rcu = RCU_HEAD_INIT,
423 },
424 .file_lock = __SPIN_LOCK_UNLOCKED(init_task.file_lock),
425};
diff --git a/fs/gfs2/glops.c b/fs/gfs2/glops.c
index d31badadef8f..07d84d16cda4 100644
--- a/fs/gfs2/glops.c
+++ b/fs/gfs2/glops.c
@@ -249,7 +249,7 @@ static int inode_go_lock(struct gfs2_holder *gh)
249 struct gfs2_inode *ip = gl->gl_object; 249 struct gfs2_inode *ip = gl->gl_object;
250 int error = 0; 250 int error = 0;
251 251
252 if (!ip) 252 if (!ip || (gh->gh_flags & GL_SKIP))
253 return 0; 253 return 0;
254 254
255 if (test_bit(GIF_INVALID, &ip->i_flags)) { 255 if (test_bit(GIF_INVALID, &ip->i_flags)) {
diff --git a/fs/gfs2/incore.h b/fs/gfs2/incore.h
index 9c2c0b90b22a..eabe5eac41da 100644
--- a/fs/gfs2/incore.h
+++ b/fs/gfs2/incore.h
@@ -236,6 +236,7 @@ enum {
236 GIF_INVALID = 0, 236 GIF_INVALID = 0,
237 GIF_QD_LOCKED = 1, 237 GIF_QD_LOCKED = 1,
238 GIF_SW_PAGED = 3, 238 GIF_SW_PAGED = 3,
239 GIF_USER = 4, /* user inode, not metadata addr space */
239}; 240};
240 241
241struct gfs2_dinode_host { 242struct gfs2_dinode_host {
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index 3a9ef526c308..09453d057e41 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -47,8 +47,7 @@ static int iget_test(struct inode *inode, void *opaque)
47 struct gfs2_inode *ip = GFS2_I(inode); 47 struct gfs2_inode *ip = GFS2_I(inode);
48 u64 *no_addr = opaque; 48 u64 *no_addr = opaque;
49 49
50 if (ip->i_no_addr == *no_addr && 50 if (ip->i_no_addr == *no_addr && test_bit(GIF_USER, &ip->i_flags))
51 inode->i_private != NULL)
52 return 1; 51 return 1;
53 52
54 return 0; 53 return 0;
@@ -61,6 +60,7 @@ static int iget_set(struct inode *inode, void *opaque)
61 60
62 inode->i_ino = (unsigned long)*no_addr; 61 inode->i_ino = (unsigned long)*no_addr;
63 ip->i_no_addr = *no_addr; 62 ip->i_no_addr = *no_addr;
63 set_bit(GIF_USER, &ip->i_flags);
64 return 0; 64 return 0;
65} 65}
66 66
@@ -86,7 +86,7 @@ static int iget_skip_test(struct inode *inode, void *opaque)
86 struct gfs2_inode *ip = GFS2_I(inode); 86 struct gfs2_inode *ip = GFS2_I(inode);
87 struct gfs2_skip_data *data = opaque; 87 struct gfs2_skip_data *data = opaque;
88 88
89 if (ip->i_no_addr == data->no_addr && inode->i_private != NULL){ 89 if (ip->i_no_addr == data->no_addr && test_bit(GIF_USER, &ip->i_flags)){
90 if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)){ 90 if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)){
91 data->skipped = 1; 91 data->skipped = 1;
92 return 0; 92 return 0;
@@ -105,6 +105,7 @@ static int iget_skip_set(struct inode *inode, void *opaque)
105 return 1; 105 return 1;
106 inode->i_ino = (unsigned long)(data->no_addr); 106 inode->i_ino = (unsigned long)(data->no_addr);
107 ip->i_no_addr = data->no_addr; 107 ip->i_no_addr = data->no_addr;
108 set_bit(GIF_USER, &ip->i_flags);
108 return 0; 109 return 0;
109} 110}
110 111
@@ -166,7 +167,7 @@ void gfs2_set_iop(struct inode *inode)
166 * Returns: A VFS inode, or an error 167 * Returns: A VFS inode, or an error
167 */ 168 */
168 169
169struct inode *gfs2_inode_lookup(struct super_block *sb, 170struct inode *gfs2_inode_lookup(struct super_block *sb,
170 unsigned int type, 171 unsigned int type,
171 u64 no_addr, 172 u64 no_addr,
172 u64 no_formal_ino, int skip_freeing) 173 u64 no_formal_ino, int skip_freeing)
@@ -187,7 +188,6 @@ struct inode *gfs2_inode_lookup(struct super_block *sb,
187 188
188 if (inode->i_state & I_NEW) { 189 if (inode->i_state & I_NEW) {
189 struct gfs2_sbd *sdp = GFS2_SB(inode); 190 struct gfs2_sbd *sdp = GFS2_SB(inode);
190 inode->i_private = ip;
191 ip->i_no_formal_ino = no_formal_ino; 191 ip->i_no_formal_ino = no_formal_ino;
192 192
193 error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl); 193 error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
diff --git a/fs/gfs2/meta_io.c b/fs/gfs2/meta_io.c
index 85aea27b4a86..78d75f892f82 100644
--- a/fs/gfs2/meta_io.c
+++ b/fs/gfs2/meta_io.c
@@ -1,6 +1,6 @@
1/* 1/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. 3 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
4 * 4 *
5 * This copyrighted material is made available to anyone wishing to use, 5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions 6 * modify, copy, or redistribute it subject to the terms and conditions
@@ -69,13 +69,15 @@ static const struct address_space_operations aspace_aops = {
69struct inode *gfs2_aspace_get(struct gfs2_sbd *sdp) 69struct inode *gfs2_aspace_get(struct gfs2_sbd *sdp)
70{ 70{
71 struct inode *aspace; 71 struct inode *aspace;
72 struct gfs2_inode *ip;
72 73
73 aspace = new_inode(sdp->sd_vfs); 74 aspace = new_inode(sdp->sd_vfs);
74 if (aspace) { 75 if (aspace) {
75 mapping_set_gfp_mask(aspace->i_mapping, GFP_NOFS); 76 mapping_set_gfp_mask(aspace->i_mapping, GFP_NOFS);
76 aspace->i_mapping->a_ops = &aspace_aops; 77 aspace->i_mapping->a_ops = &aspace_aops;
77 aspace->i_size = ~0ULL; 78 aspace->i_size = ~0ULL;
78 aspace->i_private = NULL; 79 ip = GFS2_I(aspace);
80 clear_bit(GIF_USER, &ip->i_flags);
79 insert_inode_hash(aspace); 81 insert_inode_hash(aspace);
80 } 82 }
81 return aspace; 83 return aspace;
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index ef9c6c4f80f6..b2028c82e8d1 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -142,8 +142,8 @@ static int init_names(struct gfs2_sbd *sdp, int silent)
142 if (!table[0]) 142 if (!table[0])
143 table = sdp->sd_vfs->s_id; 143 table = sdp->sd_vfs->s_id;
144 144
145 snprintf(sdp->sd_proto_name, GFS2_FSNAME_LEN, "%s", proto); 145 strlcpy(sdp->sd_proto_name, proto, GFS2_FSNAME_LEN);
146 snprintf(sdp->sd_table_name, GFS2_FSNAME_LEN, "%s", table); 146 strlcpy(sdp->sd_table_name, table, GFS2_FSNAME_LEN);
147 147
148 table = sdp->sd_table_name; 148 table = sdp->sd_table_name;
149 while ((table = strchr(table, '/'))) 149 while ((table = strchr(table, '/')))
diff --git a/fs/gfs2/ops_super.c b/fs/gfs2/ops_super.c
index 2278c68b7e35..0b7cc920eb89 100644
--- a/fs/gfs2/ops_super.c
+++ b/fs/gfs2/ops_super.c
@@ -1,6 +1,6 @@
1/* 1/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. 3 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
4 * 4 *
5 * This copyrighted material is made available to anyone wishing to use, 5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions 6 * modify, copy, or redistribute it subject to the terms and conditions
@@ -52,7 +52,7 @@ static int gfs2_write_inode(struct inode *inode, int sync)
52 struct gfs2_inode *ip = GFS2_I(inode); 52 struct gfs2_inode *ip = GFS2_I(inode);
53 53
54 /* Check this is a "normal" inode */ 54 /* Check this is a "normal" inode */
55 if (inode->i_private) { 55 if (test_bit(GIF_USER, &ip->i_flags)) {
56 if (current->flags & PF_MEMALLOC) 56 if (current->flags & PF_MEMALLOC)
57 return 0; 57 return 0;
58 if (sync) 58 if (sync)
@@ -297,8 +297,9 @@ static int gfs2_remount_fs(struct super_block *sb, int *flags, char *data)
297 */ 297 */
298static void gfs2_drop_inode(struct inode *inode) 298static void gfs2_drop_inode(struct inode *inode)
299{ 299{
300 if (inode->i_private && inode->i_nlink) { 300 struct gfs2_inode *ip = GFS2_I(inode);
301 struct gfs2_inode *ip = GFS2_I(inode); 301
302 if (test_bit(GIF_USER, &ip->i_flags) && inode->i_nlink) {
302 struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl; 303 struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl;
303 if (gl && test_bit(GLF_DEMOTE, &gl->gl_flags)) 304 if (gl && test_bit(GLF_DEMOTE, &gl->gl_flags))
304 clear_nlink(inode); 305 clear_nlink(inode);
@@ -314,12 +315,13 @@ static void gfs2_drop_inode(struct inode *inode)
314 315
315static void gfs2_clear_inode(struct inode *inode) 316static void gfs2_clear_inode(struct inode *inode)
316{ 317{
318 struct gfs2_inode *ip = GFS2_I(inode);
319
317 /* This tells us its a "real" inode and not one which only 320 /* This tells us its a "real" inode and not one which only
318 * serves to contain an address space (see rgrp.c, meta_io.c) 321 * serves to contain an address space (see rgrp.c, meta_io.c)
319 * which therefore doesn't have its own glocks. 322 * which therefore doesn't have its own glocks.
320 */ 323 */
321 if (inode->i_private) { 324 if (test_bit(GIF_USER, &ip->i_flags)) {
322 struct gfs2_inode *ip = GFS2_I(inode);
323 ip->i_gl->gl_object = NULL; 325 ip->i_gl->gl_object = NULL;
324 gfs2_glock_schedule_for_reclaim(ip->i_gl); 326 gfs2_glock_schedule_for_reclaim(ip->i_gl);
325 gfs2_glock_put(ip->i_gl); 327 gfs2_glock_put(ip->i_gl);
@@ -419,7 +421,7 @@ static void gfs2_delete_inode(struct inode *inode)
419 struct gfs2_holder gh; 421 struct gfs2_holder gh;
420 int error; 422 int error;
421 423
422 if (!inode->i_private) 424 if (!test_bit(GIF_USER, &ip->i_flags))
423 goto out; 425 goto out;
424 426
425 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); 427 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c
index 7e8f0b1d6c6e..6387523a3153 100644
--- a/fs/gfs2/rgrp.c
+++ b/fs/gfs2/rgrp.c
@@ -1495,7 +1495,7 @@ u64 gfs2_alloc_block(struct gfs2_inode *ip, unsigned int *n)
1495 1495
1496 al->al_alloced += *n; 1496 al->al_alloced += *n;
1497 1497
1498 gfs2_statfs_change(sdp, 0, -*n, 0); 1498 gfs2_statfs_change(sdp, 0, -(s64)*n, 0);
1499 gfs2_quota_change(ip, *n, ip->i_inode.i_uid, ip->i_inode.i_gid); 1499 gfs2_quota_change(ip, *n, ip->i_inode.i_uid, ip->i_inode.i_gid);
1500 1500
1501 spin_lock(&sdp->sd_rindex_spin); 1501 spin_lock(&sdp->sd_rindex_spin);
diff --git a/fs/namei.c b/fs/namei.c
index 32fd9655485b..c7e43536c49a 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -2003,18 +2003,22 @@ struct dentry *lookup_create(struct nameidata *nd, int is_dir)
2003 if (IS_ERR(dentry)) 2003 if (IS_ERR(dentry))
2004 goto fail; 2004 goto fail;
2005 2005
2006 if (dentry->d_inode)
2007 goto eexist;
2006 /* 2008 /*
2007 * Special case - lookup gave negative, but... we had foo/bar/ 2009 * Special case - lookup gave negative, but... we had foo/bar/
2008 * From the vfs_mknod() POV we just have a negative dentry - 2010 * From the vfs_mknod() POV we just have a negative dentry -
2009 * all is fine. Let's be bastards - you had / on the end, you've 2011 * all is fine. Let's be bastards - you had / on the end, you've
2010 * been asking for (non-existent) directory. -ENOENT for you. 2012 * been asking for (non-existent) directory. -ENOENT for you.
2011 */ 2013 */
2012 if (!is_dir && nd->last.name[nd->last.len] && !dentry->d_inode) 2014 if (unlikely(!is_dir && nd->last.name[nd->last.len])) {
2013 goto enoent; 2015 dput(dentry);
2016 dentry = ERR_PTR(-ENOENT);
2017 }
2014 return dentry; 2018 return dentry;
2015enoent: 2019eexist:
2016 dput(dentry); 2020 dput(dentry);
2017 dentry = ERR_PTR(-ENOENT); 2021 dentry = ERR_PTR(-EEXIST);
2018fail: 2022fail:
2019 return dentry; 2023 return dentry;
2020} 2024}
diff --git a/fs/nfs/callback.c b/fs/nfs/callback.c
index 5606ae3d72d3..c1e7c8300629 100644
--- a/fs/nfs/callback.c
+++ b/fs/nfs/callback.c
@@ -182,7 +182,7 @@ static int nfs_callback_authenticate(struct svc_rqst *rqstp)
182 if (clp == NULL) 182 if (clp == NULL)
183 return SVC_DROP; 183 return SVC_DROP;
184 184
185 dprintk("%s: %s NFSv4 callback!\n", __FUNCTION__, 185 dprintk("%s: %s NFSv4 callback!\n", __func__,
186 svc_print_addr(rqstp, buf, sizeof(buf))); 186 svc_print_addr(rqstp, buf, sizeof(buf)));
187 nfs_put_client(clp); 187 nfs_put_client(clp);
188 188
diff --git a/fs/nfs/callback_proc.c b/fs/nfs/callback_proc.c
index 15f7785048d3..f7e83e23cf9f 100644
--- a/fs/nfs/callback_proc.c
+++ b/fs/nfs/callback_proc.c
@@ -57,7 +57,7 @@ out_iput:
57out_putclient: 57out_putclient:
58 nfs_put_client(clp); 58 nfs_put_client(clp);
59out: 59out:
60 dprintk("%s: exit with status = %d\n", __FUNCTION__, ntohl(res->status)); 60 dprintk("%s: exit with status = %d\n", __func__, ntohl(res->status));
61 return res->status; 61 return res->status;
62} 62}
63 63
@@ -98,6 +98,6 @@ __be32 nfs4_callback_recall(struct cb_recallargs *args, void *dummy)
98 nfs_put_client(prev); 98 nfs_put_client(prev);
99 } while (clp != NULL); 99 } while (clp != NULL);
100out: 100out:
101 dprintk("%s: exit with status = %d\n", __FUNCTION__, ntohl(res)); 101 dprintk("%s: exit with status = %d\n", __func__, ntohl(res));
102 return res; 102 return res;
103} 103}
diff --git a/fs/nfs/callback_xdr.c b/fs/nfs/callback_xdr.c
index 13619d24f023..dd0ef34b5845 100644
--- a/fs/nfs/callback_xdr.c
+++ b/fs/nfs/callback_xdr.c
@@ -141,7 +141,7 @@ static __be32 decode_compound_hdr_arg(struct xdr_stream *xdr, struct cb_compound
141 /* We do not like overly long tags! */ 141 /* We do not like overly long tags! */
142 if (hdr->taglen > CB_OP_TAGLEN_MAXSZ - 12) { 142 if (hdr->taglen > CB_OP_TAGLEN_MAXSZ - 12) {
143 printk("NFSv4 CALLBACK %s: client sent tag of length %u\n", 143 printk("NFSv4 CALLBACK %s: client sent tag of length %u\n",
144 __FUNCTION__, hdr->taglen); 144 __func__, hdr->taglen);
145 return htonl(NFS4ERR_RESOURCE); 145 return htonl(NFS4ERR_RESOURCE);
146 } 146 }
147 p = read_buf(xdr, 12); 147 p = read_buf(xdr, 12);
@@ -151,7 +151,7 @@ static __be32 decode_compound_hdr_arg(struct xdr_stream *xdr, struct cb_compound
151 /* Check minor version is zero. */ 151 /* Check minor version is zero. */
152 if (minor_version != 0) { 152 if (minor_version != 0) {
153 printk(KERN_WARNING "%s: NFSv4 server callback with illegal minor version %u!\n", 153 printk(KERN_WARNING "%s: NFSv4 server callback with illegal minor version %u!\n",
154 __FUNCTION__, minor_version); 154 __func__, minor_version);
155 return htonl(NFS4ERR_MINOR_VERS_MISMATCH); 155 return htonl(NFS4ERR_MINOR_VERS_MISMATCH);
156 } 156 }
157 hdr->callback_ident = ntohl(*p++); 157 hdr->callback_ident = ntohl(*p++);
@@ -179,7 +179,7 @@ static __be32 decode_getattr_args(struct svc_rqst *rqstp, struct xdr_stream *xdr
179 args->addr = svc_addr(rqstp); 179 args->addr = svc_addr(rqstp);
180 status = decode_bitmap(xdr, args->bitmap); 180 status = decode_bitmap(xdr, args->bitmap);
181out: 181out:
182 dprintk("%s: exit with status = %d\n", __FUNCTION__, ntohl(status)); 182 dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
183 return status; 183 return status;
184} 184}
185 185
@@ -200,7 +200,7 @@ static __be32 decode_recall_args(struct svc_rqst *rqstp, struct xdr_stream *xdr,
200 args->truncate = ntohl(*p); 200 args->truncate = ntohl(*p);
201 status = decode_fh(xdr, &args->fh); 201 status = decode_fh(xdr, &args->fh);
202out: 202out:
203 dprintk("%s: exit with status = %d\n", __FUNCTION__, ntohl(status)); 203 dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
204 return status; 204 return status;
205} 205}
206 206
@@ -349,7 +349,7 @@ static __be32 encode_getattr_res(struct svc_rqst *rqstp, struct xdr_stream *xdr,
349 status = encode_attr_mtime(xdr, res->bitmap, &res->mtime); 349 status = encode_attr_mtime(xdr, res->bitmap, &res->mtime);
350 *savep = htonl((unsigned int)((char *)xdr->p - (char *)(savep+1))); 350 *savep = htonl((unsigned int)((char *)xdr->p - (char *)(savep+1)));
351out: 351out:
352 dprintk("%s: exit with status = %d\n", __FUNCTION__, ntohl(status)); 352 dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
353 return status; 353 return status;
354} 354}
355 355
@@ -363,7 +363,7 @@ static __be32 process_op(struct svc_rqst *rqstp,
363 long maxlen; 363 long maxlen;
364 __be32 res; 364 __be32 res;
365 365
366 dprintk("%s: start\n", __FUNCTION__); 366 dprintk("%s: start\n", __func__);
367 status = decode_op_hdr(xdr_in, &op_nr); 367 status = decode_op_hdr(xdr_in, &op_nr);
368 if (likely(status == 0)) { 368 if (likely(status == 0)) {
369 switch (op_nr) { 369 switch (op_nr) {
@@ -392,7 +392,7 @@ static __be32 process_op(struct svc_rqst *rqstp,
392 status = res; 392 status = res;
393 if (op->encode_res != NULL && status == 0) 393 if (op->encode_res != NULL && status == 0)
394 status = op->encode_res(rqstp, xdr_out, resp); 394 status = op->encode_res(rqstp, xdr_out, resp);
395 dprintk("%s: done, status = %d\n", __FUNCTION__, ntohl(status)); 395 dprintk("%s: done, status = %d\n", __func__, ntohl(status));
396 return status; 396 return status;
397} 397}
398 398
@@ -401,37 +401,37 @@ static __be32 process_op(struct svc_rqst *rqstp,
401 */ 401 */
402static __be32 nfs4_callback_compound(struct svc_rqst *rqstp, void *argp, void *resp) 402static __be32 nfs4_callback_compound(struct svc_rqst *rqstp, void *argp, void *resp)
403{ 403{
404 struct cb_compound_hdr_arg hdr_arg; 404 struct cb_compound_hdr_arg hdr_arg = { 0 };
405 struct cb_compound_hdr_res hdr_res; 405 struct cb_compound_hdr_res hdr_res = { NULL };
406 struct xdr_stream xdr_in, xdr_out; 406 struct xdr_stream xdr_in, xdr_out;
407 __be32 *p; 407 __be32 *p;
408 __be32 status; 408 __be32 status;
409 unsigned int nops = 1; 409 unsigned int nops = 0;
410 410
411 dprintk("%s: start\n", __FUNCTION__); 411 dprintk("%s: start\n", __func__);
412 412
413 xdr_init_decode(&xdr_in, &rqstp->rq_arg, rqstp->rq_arg.head[0].iov_base); 413 xdr_init_decode(&xdr_in, &rqstp->rq_arg, rqstp->rq_arg.head[0].iov_base);
414 414
415 p = (__be32*)((char *)rqstp->rq_res.head[0].iov_base + rqstp->rq_res.head[0].iov_len); 415 p = (__be32*)((char *)rqstp->rq_res.head[0].iov_base + rqstp->rq_res.head[0].iov_len);
416 xdr_init_encode(&xdr_out, &rqstp->rq_res, p); 416 xdr_init_encode(&xdr_out, &rqstp->rq_res, p);
417 417
418 decode_compound_hdr_arg(&xdr_in, &hdr_arg); 418 status = decode_compound_hdr_arg(&xdr_in, &hdr_arg);
419 if (status == __constant_htonl(NFS4ERR_RESOURCE))
420 return rpc_garbage_args;
421
419 hdr_res.taglen = hdr_arg.taglen; 422 hdr_res.taglen = hdr_arg.taglen;
420 hdr_res.tag = hdr_arg.tag; 423 hdr_res.tag = hdr_arg.tag;
421 hdr_res.nops = NULL; 424 if (encode_compound_hdr_res(&xdr_out, &hdr_res) != 0)
422 encode_compound_hdr_res(&xdr_out, &hdr_res); 425 return rpc_system_err;
423 426
424 for (;;) { 427 while (status == 0 && nops != hdr_arg.nops) {
425 status = process_op(rqstp, &xdr_in, argp, &xdr_out, resp); 428 status = process_op(rqstp, &xdr_in, argp, &xdr_out, resp);
426 if (status != 0)
427 break;
428 if (nops == hdr_arg.nops)
429 break;
430 nops++; 429 nops++;
431 } 430 }
431
432 *hdr_res.status = status; 432 *hdr_res.status = status;
433 *hdr_res.nops = htonl(nops); 433 *hdr_res.nops = htonl(nops);
434 dprintk("%s: done, status = %u\n", __FUNCTION__, ntohl(status)); 434 dprintk("%s: done, status = %u\n", __func__, ntohl(status));
435 return rpc_success; 435 return rpc_success;
436} 436}
437 437
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 89ac5bb0401c..f2a092ca69b5 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -488,7 +488,7 @@ static int nfs_create_rpc_client(struct nfs_client *clp,
488 clnt = rpc_create(&args); 488 clnt = rpc_create(&args);
489 if (IS_ERR(clnt)) { 489 if (IS_ERR(clnt)) {
490 dprintk("%s: cannot create RPC client. Error = %ld\n", 490 dprintk("%s: cannot create RPC client. Error = %ld\n",
491 __FUNCTION__, PTR_ERR(clnt)); 491 __func__, PTR_ERR(clnt));
492 return PTR_ERR(clnt); 492 return PTR_ERR(clnt);
493 } 493 }
494 494
@@ -576,7 +576,7 @@ static int nfs_init_server_rpcclient(struct nfs_server *server,
576 576
577 server->client = rpc_clone_client(clp->cl_rpcclient); 577 server->client = rpc_clone_client(clp->cl_rpcclient);
578 if (IS_ERR(server->client)) { 578 if (IS_ERR(server->client)) {
579 dprintk("%s: couldn't create rpc_client!\n", __FUNCTION__); 579 dprintk("%s: couldn't create rpc_client!\n", __func__);
580 return PTR_ERR(server->client); 580 return PTR_ERR(server->client);
581 } 581 }
582 582
@@ -590,7 +590,7 @@ static int nfs_init_server_rpcclient(struct nfs_server *server,
590 590
591 auth = rpcauth_create(pseudoflavour, server->client); 591 auth = rpcauth_create(pseudoflavour, server->client);
592 if (IS_ERR(auth)) { 592 if (IS_ERR(auth)) {
593 dprintk("%s: couldn't create credcache!\n", __FUNCTION__); 593 dprintk("%s: couldn't create credcache!\n", __func__);
594 return PTR_ERR(auth); 594 return PTR_ERR(auth);
595 } 595 }
596 } 596 }
@@ -985,7 +985,7 @@ static int nfs4_init_client(struct nfs_client *clp,
985 error = nfs_idmap_new(clp); 985 error = nfs_idmap_new(clp);
986 if (error < 0) { 986 if (error < 0) {
987 dprintk("%s: failed to create idmapper. Error = %d\n", 987 dprintk("%s: failed to create idmapper. Error = %d\n",
988 __FUNCTION__, error); 988 __func__, error);
989 goto error; 989 goto error;
990 } 990 }
991 __set_bit(NFS_CS_IDMAP, &clp->cl_res_state); 991 __set_bit(NFS_CS_IDMAP, &clp->cl_res_state);
diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c
index 00a5e4405e16..cc563cfa6940 100644
--- a/fs/nfs/delegation.c
+++ b/fs/nfs/delegation.c
@@ -60,7 +60,7 @@ static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_
60 switch (status) { 60 switch (status) {
61 default: 61 default:
62 printk(KERN_ERR "%s: unhandled error %d.\n", 62 printk(KERN_ERR "%s: unhandled error %d.\n",
63 __FUNCTION__, status); 63 __func__, status);
64 case -NFS4ERR_EXPIRED: 64 case -NFS4ERR_EXPIRED:
65 /* kill_proc(fl->fl_pid, SIGLOST, 1); */ 65 /* kill_proc(fl->fl_pid, SIGLOST, 1); */
66 case -NFS4ERR_STALE_CLIENTID: 66 case -NFS4ERR_STALE_CLIENTID:
@@ -186,7 +186,7 @@ int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct
186 */ 186 */
187 dfprintk(FILE, "%s: server %s handed out " 187 dfprintk(FILE, "%s: server %s handed out "
188 "a duplicate delegation!\n", 188 "a duplicate delegation!\n",
189 __FUNCTION__, clp->cl_hostname); 189 __func__, clp->cl_hostname);
190 if (delegation->type <= nfsi->delegation->type) { 190 if (delegation->type <= nfsi->delegation->type) {
191 freeme = delegation; 191 freeme = delegation;
192 delegation = NULL; 192 delegation = NULL;
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index f288b3ecab4a..58d43daec084 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -180,7 +180,7 @@ int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page *page)
180 int error; 180 int error;
181 181
182 dfprintk(DIRCACHE, "NFS: %s: reading cookie %Lu into page %lu\n", 182 dfprintk(DIRCACHE, "NFS: %s: reading cookie %Lu into page %lu\n",
183 __FUNCTION__, (long long)desc->entry->cookie, 183 __func__, (long long)desc->entry->cookie,
184 page->index); 184 page->index);
185 185
186 again: 186 again:
@@ -256,7 +256,7 @@ int find_dirent(nfs_readdir_descriptor_t *desc)
256 256
257 while((status = dir_decode(desc)) == 0) { 257 while((status = dir_decode(desc)) == 0) {
258 dfprintk(DIRCACHE, "NFS: %s: examining cookie %Lu\n", 258 dfprintk(DIRCACHE, "NFS: %s: examining cookie %Lu\n",
259 __FUNCTION__, (unsigned long long)entry->cookie); 259 __func__, (unsigned long long)entry->cookie);
260 if (entry->prev_cookie == *desc->dir_cookie) 260 if (entry->prev_cookie == *desc->dir_cookie)
261 break; 261 break;
262 if (loop_count++ > 200) { 262 if (loop_count++ > 200) {
@@ -315,7 +315,7 @@ int find_dirent_page(nfs_readdir_descriptor_t *desc)
315 int status; 315 int status;
316 316
317 dfprintk(DIRCACHE, "NFS: %s: searching page %ld for target %Lu\n", 317 dfprintk(DIRCACHE, "NFS: %s: searching page %ld for target %Lu\n",
318 __FUNCTION__, desc->page_index, 318 __func__, desc->page_index,
319 (long long) *desc->dir_cookie); 319 (long long) *desc->dir_cookie);
320 320
321 /* If we find the page in the page_cache, we cannot be sure 321 /* If we find the page in the page_cache, we cannot be sure
@@ -339,7 +339,7 @@ int find_dirent_page(nfs_readdir_descriptor_t *desc)
339 if (status < 0) 339 if (status < 0)
340 dir_page_release(desc); 340 dir_page_release(desc);
341 out: 341 out:
342 dfprintk(DIRCACHE, "NFS: %s: returns %d\n", __FUNCTION__, status); 342 dfprintk(DIRCACHE, "NFS: %s: returns %d\n", __func__, status);
343 return status; 343 return status;
344} 344}
345 345
@@ -380,7 +380,7 @@ int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
380 } 380 }
381 } 381 }
382 382
383 dfprintk(DIRCACHE, "NFS: %s: returns %d\n", __FUNCTION__, res); 383 dfprintk(DIRCACHE, "NFS: %s: returns %d\n", __func__, res);
384 return res; 384 return res;
385} 385}
386 386
@@ -506,7 +506,7 @@ int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
506 desc->entry->eof = 0; 506 desc->entry->eof = 0;
507 out: 507 out:
508 dfprintk(DIRCACHE, "NFS: %s: returns %d\n", 508 dfprintk(DIRCACHE, "NFS: %s: returns %d\n",
509 __FUNCTION__, status); 509 __func__, status);
510 return status; 510 return status;
511 out_release: 511 out_release:
512 dir_page_release(desc); 512 dir_page_release(desc);
@@ -780,7 +780,7 @@ static int nfs_lookup_revalidate(struct dentry * dentry, struct nameidata *nd)
780 780
781 if (is_bad_inode(inode)) { 781 if (is_bad_inode(inode)) {
782 dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n", 782 dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n",
783 __FUNCTION__, dentry->d_parent->d_name.name, 783 __func__, dentry->d_parent->d_name.name,
784 dentry->d_name.name); 784 dentry->d_name.name);
785 goto out_bad; 785 goto out_bad;
786 } 786 }
@@ -808,7 +808,7 @@ static int nfs_lookup_revalidate(struct dentry * dentry, struct nameidata *nd)
808 unlock_kernel(); 808 unlock_kernel();
809 dput(parent); 809 dput(parent);
810 dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n", 810 dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n",
811 __FUNCTION__, dentry->d_parent->d_name.name, 811 __func__, dentry->d_parent->d_name.name,
812 dentry->d_name.name); 812 dentry->d_name.name);
813 return 1; 813 return 1;
814out_zap_parent: 814out_zap_parent:
@@ -827,7 +827,7 @@ out_zap_parent:
827 unlock_kernel(); 827 unlock_kernel();
828 dput(parent); 828 dput(parent);
829 dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n", 829 dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n",
830 __FUNCTION__, dentry->d_parent->d_name.name, 830 __func__, dentry->d_parent->d_name.name,
831 dentry->d_name.name); 831 dentry->d_name.name);
832 return 0; 832 return 0;
833} 833}
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 3536b01164f9..d84a3d8f32af 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -526,7 +526,7 @@ static int do_vfs_lock(struct file *file, struct file_lock *fl)
526 if (res < 0) 526 if (res < 0)
527 dprintk(KERN_WARNING "%s: VFS is out of sync with lock manager" 527 dprintk(KERN_WARNING "%s: VFS is out of sync with lock manager"
528 " - error %d!\n", 528 " - error %d!\n",
529 __FUNCTION__, res); 529 __func__, res);
530 return res; 530 return res;
531} 531}
532 532
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 5cb3345eb694..596c5d8e86f4 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -541,8 +541,7 @@ static void __put_nfs_open_context(struct nfs_open_context *ctx, int wait)
541 } 541 }
542 if (ctx->cred != NULL) 542 if (ctx->cred != NULL)
543 put_rpccred(ctx->cred); 543 put_rpccred(ctx->cred);
544 dput(ctx->path.dentry); 544 path_put(&ctx->path);
545 mntput(ctx->path.mnt);
546 kfree(ctx); 545 kfree(ctx);
547} 546}
548 547
@@ -707,6 +706,13 @@ int nfs_attribute_timeout(struct inode *inode)
707 706
708 if (nfs_have_delegation(inode, FMODE_READ)) 707 if (nfs_have_delegation(inode, FMODE_READ))
709 return 0; 708 return 0;
709 /*
710 * Special case: if the attribute timeout is set to 0, then always
711 * treat the cache as having expired (unless holding
712 * a delegation).
713 */
714 if (nfsi->attrtimeo == 0)
715 return 1;
710 return !time_in_range(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo); 716 return !time_in_range(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
711} 717}
712 718
@@ -995,7 +1001,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
995 unsigned long now = jiffies; 1001 unsigned long now = jiffies;
996 1002
997 dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n", 1003 dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n",
998 __FUNCTION__, inode->i_sb->s_id, inode->i_ino, 1004 __func__, inode->i_sb->s_id, inode->i_ino,
999 atomic_read(&inode->i_count), fattr->valid); 1005 atomic_read(&inode->i_count), fattr->valid);
1000 1006
1001 if (nfsi->fileid != fattr->fileid) 1007 if (nfsi->fileid != fattr->fileid)
@@ -1119,7 +1125,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1119 * Big trouble! The inode has become a different object. 1125 * Big trouble! The inode has become a different object.
1120 */ 1126 */
1121 printk(KERN_DEBUG "%s: inode %ld mode changed, %07o to %07o\n", 1127 printk(KERN_DEBUG "%s: inode %ld mode changed, %07o to %07o\n",
1122 __FUNCTION__, inode->i_ino, inode->i_mode, fattr->mode); 1128 __func__, inode->i_ino, inode->i_mode, fattr->mode);
1123 out_err: 1129 out_err:
1124 /* 1130 /*
1125 * No need to worry about unhashing the dentry, as the 1131 * No need to worry about unhashing the dentry, as the
diff --git a/fs/nfs/namespace.c b/fs/nfs/namespace.c
index af4d0f1e402c..2f285ef76399 100644
--- a/fs/nfs/namespace.c
+++ b/fs/nfs/namespace.c
@@ -106,7 +106,7 @@ static void * nfs_follow_mountpoint(struct dentry *dentry, struct nameidata *nd)
106 dprintk("--> nfs_follow_mountpoint()\n"); 106 dprintk("--> nfs_follow_mountpoint()\n");
107 107
108 BUG_ON(IS_ROOT(dentry)); 108 BUG_ON(IS_ROOT(dentry));
109 dprintk("%s: enter\n", __FUNCTION__); 109 dprintk("%s: enter\n", __func__);
110 dput(nd->path.dentry); 110 dput(nd->path.dentry);
111 nd->path.dentry = dget(dentry); 111 nd->path.dentry = dget(dentry);
112 112
@@ -137,13 +137,12 @@ static void * nfs_follow_mountpoint(struct dentry *dentry, struct nameidata *nd)
137 goto out_follow; 137 goto out_follow;
138 goto out_err; 138 goto out_err;
139 } 139 }
140 mntput(nd->path.mnt); 140 path_put(&nd->path);
141 dput(nd->path.dentry);
142 nd->path.mnt = mnt; 141 nd->path.mnt = mnt;
143 nd->path.dentry = dget(mnt->mnt_root); 142 nd->path.dentry = dget(mnt->mnt_root);
144 schedule_delayed_work(&nfs_automount_task, nfs_mountpoint_expiry_timeout); 143 schedule_delayed_work(&nfs_automount_task, nfs_mountpoint_expiry_timeout);
145out: 144out:
146 dprintk("%s: done, returned %d\n", __FUNCTION__, err); 145 dprintk("%s: done, returned %d\n", __func__, err);
147 146
148 dprintk("<-- nfs_follow_mountpoint() = %d\n", err); 147 dprintk("<-- nfs_follow_mountpoint() = %d\n", err);
149 return ERR_PTR(err); 148 return ERR_PTR(err);
@@ -230,7 +229,7 @@ static struct vfsmount *nfs_do_submount(const struct vfsmount *mnt_parent,
230 229
231 dprintk("--> nfs_do_submount()\n"); 230 dprintk("--> nfs_do_submount()\n");
232 231
233 dprintk("%s: submounting on %s/%s\n", __FUNCTION__, 232 dprintk("%s: submounting on %s/%s\n", __func__,
234 dentry->d_parent->d_name.name, 233 dentry->d_parent->d_name.name,
235 dentry->d_name.name); 234 dentry->d_name.name);
236 if (page == NULL) 235 if (page == NULL)
@@ -243,7 +242,7 @@ static struct vfsmount *nfs_do_submount(const struct vfsmount *mnt_parent,
243free_page: 242free_page:
244 free_page((unsigned long)page); 243 free_page((unsigned long)page);
245out: 244out:
246 dprintk("%s: done\n", __FUNCTION__); 245 dprintk("%s: done\n", __func__);
247 246
248 dprintk("<-- nfs_do_submount() = %p\n", mnt); 247 dprintk("<-- nfs_do_submount() = %p\n", mnt);
249 return mnt; 248 return mnt;
diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index 549dbce714a4..c3523ad03ed1 100644
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -63,15 +63,15 @@ do_proc_get_root(struct rpc_clnt *client, struct nfs_fh *fhandle,
63 }; 63 };
64 int status; 64 int status;
65 65
66 dprintk("%s: call fsinfo\n", __FUNCTION__); 66 dprintk("%s: call fsinfo\n", __func__);
67 nfs_fattr_init(info->fattr); 67 nfs_fattr_init(info->fattr);
68 status = rpc_call_sync(client, &msg, 0); 68 status = rpc_call_sync(client, &msg, 0);
69 dprintk("%s: reply fsinfo: %d\n", __FUNCTION__, status); 69 dprintk("%s: reply fsinfo: %d\n", __func__, status);
70 if (!(info->fattr->valid & NFS_ATTR_FATTR)) { 70 if (!(info->fattr->valid & NFS_ATTR_FATTR)) {
71 msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR]; 71 msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR];
72 msg.rpc_resp = info->fattr; 72 msg.rpc_resp = info->fattr;
73 status = rpc_call_sync(client, &msg, 0); 73 status = rpc_call_sync(client, &msg, 0);
74 dprintk("%s: reply getattr: %d\n", __FUNCTION__, status); 74 dprintk("%s: reply getattr: %d\n", __func__, status);
75 } 75 }
76 return status; 76 return status;
77} 77}
diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index bd1b9d663fb9..ea790645fda6 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -206,7 +206,6 @@ struct rpc_cred *nfs4_get_renew_cred(struct nfs_client *clp);
206 206
207extern struct nfs4_state_owner * nfs4_get_state_owner(struct nfs_server *, struct rpc_cred *); 207extern struct nfs4_state_owner * nfs4_get_state_owner(struct nfs_server *, struct rpc_cred *);
208extern void nfs4_put_state_owner(struct nfs4_state_owner *); 208extern void nfs4_put_state_owner(struct nfs4_state_owner *);
209extern void nfs4_drop_state_owner(struct nfs4_state_owner *);
210extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state_owner *); 209extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state_owner *);
211extern void nfs4_put_open_state(struct nfs4_state *); 210extern void nfs4_put_open_state(struct nfs4_state *);
212extern void nfs4_close_state(struct path *, struct nfs4_state *, mode_t); 211extern void nfs4_close_state(struct path *, struct nfs4_state *, mode_t);
diff --git a/fs/nfs/nfs4namespace.c b/fs/nfs/nfs4namespace.c
index 5f9ba41ed5bf..b112857301f7 100644
--- a/fs/nfs/nfs4namespace.c
+++ b/fs/nfs/nfs4namespace.c
@@ -86,7 +86,7 @@ static int nfs4_validate_fspath(const struct vfsmount *mnt_parent,
86 86
87 if (strncmp(path, fs_path, strlen(fs_path)) != 0) { 87 if (strncmp(path, fs_path, strlen(fs_path)) != 0) {
88 dprintk("%s: path %s does not begin with fsroot %s\n", 88 dprintk("%s: path %s does not begin with fsroot %s\n",
89 __FUNCTION__, path, fs_path); 89 __func__, path, fs_path);
90 return -ENOENT; 90 return -ENOENT;
91 } 91 }
92 92
@@ -134,7 +134,7 @@ static struct vfsmount *nfs_follow_referral(const struct vfsmount *mnt_parent,
134 if (locations == NULL || locations->nlocations <= 0) 134 if (locations == NULL || locations->nlocations <= 0)
135 goto out; 135 goto out;
136 136
137 dprintk("%s: referral at %s/%s\n", __FUNCTION__, 137 dprintk("%s: referral at %s/%s\n", __func__,
138 dentry->d_parent->d_name.name, dentry->d_name.name); 138 dentry->d_parent->d_name.name, dentry->d_name.name);
139 139
140 page = (char *) __get_free_page(GFP_USER); 140 page = (char *) __get_free_page(GFP_USER);
@@ -204,7 +204,7 @@ static struct vfsmount *nfs_follow_referral(const struct vfsmount *mnt_parent,
204out: 204out:
205 free_page((unsigned long) page); 205 free_page((unsigned long) page);
206 free_page((unsigned long) page2); 206 free_page((unsigned long) page2);
207 dprintk("%s: done\n", __FUNCTION__); 207 dprintk("%s: done\n", __func__);
208 return mnt; 208 return mnt;
209} 209}
210 210
@@ -223,7 +223,7 @@ struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentr
223 int err; 223 int err;
224 224
225 /* BUG_ON(IS_ROOT(dentry)); */ 225 /* BUG_ON(IS_ROOT(dentry)); */
226 dprintk("%s: enter\n", __FUNCTION__); 226 dprintk("%s: enter\n", __func__);
227 227
228 page = alloc_page(GFP_KERNEL); 228 page = alloc_page(GFP_KERNEL);
229 if (page == NULL) 229 if (page == NULL)
@@ -238,7 +238,7 @@ struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentr
238 238
239 parent = dget_parent(dentry); 239 parent = dget_parent(dentry);
240 dprintk("%s: getting locations for %s/%s\n", 240 dprintk("%s: getting locations for %s/%s\n",
241 __FUNCTION__, parent->d_name.name, dentry->d_name.name); 241 __func__, parent->d_name.name, dentry->d_name.name);
242 242
243 err = nfs4_proc_fs_locations(parent->d_inode, &dentry->d_name, fs_locations, page); 243 err = nfs4_proc_fs_locations(parent->d_inode, &dentry->d_name, fs_locations, page);
244 dput(parent); 244 dput(parent);
@@ -252,6 +252,6 @@ out_free:
252 __free_page(page); 252 __free_page(page);
253 kfree(fs_locations); 253 kfree(fs_locations);
254out: 254out:
255 dprintk("%s: done\n", __FUNCTION__); 255 dprintk("%s: done\n", __func__);
256 return mnt; 256 return mnt;
257} 257}
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index dbc09271af02..1293e0acd82b 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -73,7 +73,7 @@ int nfs4_map_errors(int err)
73{ 73{
74 if (err < -1000) { 74 if (err < -1000) {
75 dprintk("%s could not handle NFSv4 error %d\n", 75 dprintk("%s could not handle NFSv4 error %d\n",
76 __FUNCTION__, -err); 76 __func__, -err);
77 return -EIO; 77 return -EIO;
78 } 78 }
79 return err; 79 return err;
@@ -306,8 +306,7 @@ static void nfs4_opendata_free(struct kref *kref)
306 nfs4_put_open_state(p->state); 306 nfs4_put_open_state(p->state);
307 nfs4_put_state_owner(p->owner); 307 nfs4_put_state_owner(p->owner);
308 dput(p->dir); 308 dput(p->dir);
309 dput(p->path.dentry); 309 path_put(&p->path);
310 mntput(p->path.mnt);
311 kfree(p); 310 kfree(p);
312} 311}
313 312
@@ -1210,8 +1209,7 @@ static void nfs4_free_closedata(void *data)
1210 nfs4_put_open_state(calldata->state); 1209 nfs4_put_open_state(calldata->state);
1211 nfs_free_seqid(calldata->arg.seqid); 1210 nfs_free_seqid(calldata->arg.seqid);
1212 nfs4_put_state_owner(sp); 1211 nfs4_put_state_owner(sp);
1213 dput(calldata->path.dentry); 1212 path_put(&calldata->path);
1214 mntput(calldata->path.mnt);
1215 kfree(calldata); 1213 kfree(calldata);
1216} 1214}
1217 1215
@@ -1578,7 +1576,7 @@ static int nfs4_get_referral(struct inode *dir, const struct qstr *name, struct
1578 goto out; 1576 goto out;
1579 /* Make sure server returned a different fsid for the referral */ 1577 /* Make sure server returned a different fsid for the referral */
1580 if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) { 1578 if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) {
1581 dprintk("%s: server did not return a different fsid for a referral at %s\n", __FUNCTION__, name->name); 1579 dprintk("%s: server did not return a different fsid for a referral at %s\n", __func__, name->name);
1582 status = -EIO; 1580 status = -EIO;
1583 goto out; 1581 goto out;
1584 } 1582 }
@@ -2211,7 +2209,7 @@ static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
2211 }; 2209 };
2212 int status; 2210 int status;
2213 2211
2214 dprintk("%s: dentry = %s/%s, cookie = %Lu\n", __FUNCTION__, 2212 dprintk("%s: dentry = %s/%s, cookie = %Lu\n", __func__,
2215 dentry->d_parent->d_name.name, 2213 dentry->d_parent->d_name.name,
2216 dentry->d_name.name, 2214 dentry->d_name.name,
2217 (unsigned long long)cookie); 2215 (unsigned long long)cookie);
@@ -2223,7 +2221,7 @@ static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
2223 2221
2224 nfs_invalidate_atime(dir); 2222 nfs_invalidate_atime(dir);
2225 2223
2226 dprintk("%s: returns %d\n", __FUNCTION__, status); 2224 dprintk("%s: returns %d\n", __func__, status);
2227 return status; 2225 return status;
2228} 2226}
2229 2227
@@ -3342,7 +3340,7 @@ static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
3342 struct nfs4_lockdata *data = calldata; 3340 struct nfs4_lockdata *data = calldata;
3343 struct nfs4_state *state = data->lsp->ls_state; 3341 struct nfs4_state *state = data->lsp->ls_state;
3344 3342
3345 dprintk("%s: begin!\n", __FUNCTION__); 3343 dprintk("%s: begin!\n", __func__);
3346 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0) 3344 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
3347 return; 3345 return;
3348 /* Do we need to do an open_to_lock_owner? */ 3346 /* Do we need to do an open_to_lock_owner? */
@@ -3356,14 +3354,14 @@ static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
3356 data->arg.new_lock_owner = 0; 3354 data->arg.new_lock_owner = 0;
3357 data->timestamp = jiffies; 3355 data->timestamp = jiffies;
3358 rpc_call_start(task); 3356 rpc_call_start(task);
3359 dprintk("%s: done!, ret = %d\n", __FUNCTION__, data->rpc_status); 3357 dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status);
3360} 3358}
3361 3359
3362static void nfs4_lock_done(struct rpc_task *task, void *calldata) 3360static void nfs4_lock_done(struct rpc_task *task, void *calldata)
3363{ 3361{
3364 struct nfs4_lockdata *data = calldata; 3362 struct nfs4_lockdata *data = calldata;
3365 3363
3366 dprintk("%s: begin!\n", __FUNCTION__); 3364 dprintk("%s: begin!\n", __func__);
3367 3365
3368 data->rpc_status = task->tk_status; 3366 data->rpc_status = task->tk_status;
3369 if (RPC_ASSASSINATED(task)) 3367 if (RPC_ASSASSINATED(task))
@@ -3381,14 +3379,14 @@ static void nfs4_lock_done(struct rpc_task *task, void *calldata)
3381 renew_lease(NFS_SERVER(data->ctx->path.dentry->d_inode), data->timestamp); 3379 renew_lease(NFS_SERVER(data->ctx->path.dentry->d_inode), data->timestamp);
3382 } 3380 }
3383out: 3381out:
3384 dprintk("%s: done, ret = %d!\n", __FUNCTION__, data->rpc_status); 3382 dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);
3385} 3383}
3386 3384
3387static void nfs4_lock_release(void *calldata) 3385static void nfs4_lock_release(void *calldata)
3388{ 3386{
3389 struct nfs4_lockdata *data = calldata; 3387 struct nfs4_lockdata *data = calldata;
3390 3388
3391 dprintk("%s: begin!\n", __FUNCTION__); 3389 dprintk("%s: begin!\n", __func__);
3392 nfs_free_seqid(data->arg.open_seqid); 3390 nfs_free_seqid(data->arg.open_seqid);
3393 if (data->cancelled != 0) { 3391 if (data->cancelled != 0) {
3394 struct rpc_task *task; 3392 struct rpc_task *task;
@@ -3396,13 +3394,13 @@ static void nfs4_lock_release(void *calldata)
3396 data->arg.lock_seqid); 3394 data->arg.lock_seqid);
3397 if (!IS_ERR(task)) 3395 if (!IS_ERR(task))
3398 rpc_put_task(task); 3396 rpc_put_task(task);
3399 dprintk("%s: cancelling lock!\n", __FUNCTION__); 3397 dprintk("%s: cancelling lock!\n", __func__);
3400 } else 3398 } else
3401 nfs_free_seqid(data->arg.lock_seqid); 3399 nfs_free_seqid(data->arg.lock_seqid);
3402 nfs4_put_lock_state(data->lsp); 3400 nfs4_put_lock_state(data->lsp);
3403 put_nfs_open_context(data->ctx); 3401 put_nfs_open_context(data->ctx);
3404 kfree(data); 3402 kfree(data);
3405 dprintk("%s: done!\n", __FUNCTION__); 3403 dprintk("%s: done!\n", __func__);
3406} 3404}
3407 3405
3408static const struct rpc_call_ops nfs4_lock_ops = { 3406static const struct rpc_call_ops nfs4_lock_ops = {
@@ -3428,7 +3426,7 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *f
3428 }; 3426 };
3429 int ret; 3427 int ret;
3430 3428
3431 dprintk("%s: begin!\n", __FUNCTION__); 3429 dprintk("%s: begin!\n", __func__);
3432 data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file), 3430 data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),
3433 fl->fl_u.nfs4_fl.owner); 3431 fl->fl_u.nfs4_fl.owner);
3434 if (data == NULL) 3432 if (data == NULL)
@@ -3451,7 +3449,7 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *f
3451 } else 3449 } else
3452 data->cancelled = 1; 3450 data->cancelled = 1;
3453 rpc_put_task(task); 3451 rpc_put_task(task);
3454 dprintk("%s: done, ret = %d!\n", __FUNCTION__, ret); 3452 dprintk("%s: done, ret = %d!\n", __func__, ret);
3455 return ret; 3453 return ret;
3456} 3454}
3457 3455
@@ -3527,7 +3525,7 @@ static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock
3527 /* Note: we always want to sleep here! */ 3525 /* Note: we always want to sleep here! */
3528 request->fl_flags = fl_flags | FL_SLEEP; 3526 request->fl_flags = fl_flags | FL_SLEEP;
3529 if (do_vfs_lock(request->fl_file, request) < 0) 3527 if (do_vfs_lock(request->fl_file, request) < 0)
3530 printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __FUNCTION__); 3528 printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __func__);
3531out_unlock: 3529out_unlock:
3532 up_read(&clp->cl_sem); 3530 up_read(&clp->cl_sem);
3533out: 3531out:
@@ -3665,12 +3663,12 @@ int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name,
3665 }; 3663 };
3666 int status; 3664 int status;
3667 3665
3668 dprintk("%s: start\n", __FUNCTION__); 3666 dprintk("%s: start\n", __func__);
3669 nfs_fattr_init(&fs_locations->fattr); 3667 nfs_fattr_init(&fs_locations->fattr);
3670 fs_locations->server = server; 3668 fs_locations->server = server;
3671 fs_locations->nlocations = 0; 3669 fs_locations->nlocations = 0;
3672 status = rpc_call_sync(server->client, &msg, 0); 3670 status = rpc_call_sync(server->client, &msg, 0);
3673 dprintk("%s: returned status = %d\n", __FUNCTION__, status); 3671 dprintk("%s: returned status = %d\n", __func__, status);
3674 return status; 3672 return status;
3675} 3673}
3676 3674
diff --git a/fs/nfs/nfs4renewd.c b/fs/nfs/nfs4renewd.c
index 5e2e4af1a0e6..3305acbbe2ae 100644
--- a/fs/nfs/nfs4renewd.c
+++ b/fs/nfs/nfs4renewd.c
@@ -66,7 +66,7 @@ nfs4_renew_state(struct work_struct *work)
66 unsigned long last, now; 66 unsigned long last, now;
67 67
68 down_read(&clp->cl_sem); 68 down_read(&clp->cl_sem);
69 dprintk("%s: start\n", __FUNCTION__); 69 dprintk("%s: start\n", __func__);
70 /* Are there any active superblocks? */ 70 /* Are there any active superblocks? */
71 if (list_empty(&clp->cl_superblocks)) 71 if (list_empty(&clp->cl_superblocks))
72 goto out; 72 goto out;
@@ -92,17 +92,17 @@ nfs4_renew_state(struct work_struct *work)
92 spin_lock(&clp->cl_lock); 92 spin_lock(&clp->cl_lock);
93 } else 93 } else
94 dprintk("%s: failed to call renewd. Reason: lease not expired \n", 94 dprintk("%s: failed to call renewd. Reason: lease not expired \n",
95 __FUNCTION__); 95 __func__);
96 if (timeout < 5 * HZ) /* safeguard */ 96 if (timeout < 5 * HZ) /* safeguard */
97 timeout = 5 * HZ; 97 timeout = 5 * HZ;
98 dprintk("%s: requeueing work. Lease period = %ld\n", 98 dprintk("%s: requeueing work. Lease period = %ld\n",
99 __FUNCTION__, (timeout + HZ - 1) / HZ); 99 __func__, (timeout + HZ - 1) / HZ);
100 cancel_delayed_work(&clp->cl_renewd); 100 cancel_delayed_work(&clp->cl_renewd);
101 schedule_delayed_work(&clp->cl_renewd, timeout); 101 schedule_delayed_work(&clp->cl_renewd, timeout);
102 spin_unlock(&clp->cl_lock); 102 spin_unlock(&clp->cl_lock);
103out: 103out:
104 up_read(&clp->cl_sem); 104 up_read(&clp->cl_sem);
105 dprintk("%s: done\n", __FUNCTION__); 105 dprintk("%s: done\n", __func__);
106} 106}
107 107
108/* Must be called with clp->cl_sem locked for writes */ 108/* Must be called with clp->cl_sem locked for writes */
@@ -117,7 +117,7 @@ nfs4_schedule_state_renewal(struct nfs_client *clp)
117 if (timeout < 5 * HZ) 117 if (timeout < 5 * HZ)
118 timeout = 5 * HZ; 118 timeout = 5 * HZ;
119 dprintk("%s: requeueing work. Lease period = %ld\n", 119 dprintk("%s: requeueing work. Lease period = %ld\n",
120 __FUNCTION__, (timeout + HZ - 1) / HZ); 120 __func__, (timeout + HZ - 1) / HZ);
121 cancel_delayed_work(&clp->cl_renewd); 121 cancel_delayed_work(&clp->cl_renewd);
122 schedule_delayed_work(&clp->cl_renewd, timeout); 122 schedule_delayed_work(&clp->cl_renewd, timeout);
123 set_bit(NFS_CS_RENEWD, &clp->cl_res_state); 123 set_bit(NFS_CS_RENEWD, &clp->cl_res_state);
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 46eb624e4f16..856a8934f610 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -282,7 +282,7 @@ nfs4_alloc_state_owner(void)
282 return sp; 282 return sp;
283} 283}
284 284
285void 285static void
286nfs4_drop_state_owner(struct nfs4_state_owner *sp) 286nfs4_drop_state_owner(struct nfs4_state_owner *sp)
287{ 287{
288 if (!RB_EMPTY_NODE(&sp->so_client_node)) { 288 if (!RB_EMPTY_NODE(&sp->so_client_node)) {
@@ -828,7 +828,7 @@ static int nfs4_reclaim_locks(struct nfs4_state_recovery_ops *ops, struct nfs4_s
828 switch (status) { 828 switch (status) {
829 default: 829 default:
830 printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n", 830 printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n",
831 __FUNCTION__, status); 831 __func__, status);
832 case -NFS4ERR_EXPIRED: 832 case -NFS4ERR_EXPIRED:
833 case -NFS4ERR_NO_GRACE: 833 case -NFS4ERR_NO_GRACE:
834 case -NFS4ERR_RECLAIM_BAD: 834 case -NFS4ERR_RECLAIM_BAD:
@@ -869,14 +869,14 @@ static int nfs4_reclaim_open_state(struct nfs4_state_recovery_ops *ops, struct n
869 list_for_each_entry(lock, &state->lock_states, ls_locks) { 869 list_for_each_entry(lock, &state->lock_states, ls_locks) {
870 if (!(lock->ls_flags & NFS_LOCK_INITIALIZED)) 870 if (!(lock->ls_flags & NFS_LOCK_INITIALIZED))
871 printk("%s: Lock reclaim failed!\n", 871 printk("%s: Lock reclaim failed!\n",
872 __FUNCTION__); 872 __func__);
873 } 873 }
874 continue; 874 continue;
875 } 875 }
876 switch (status) { 876 switch (status) {
877 default: 877 default:
878 printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n", 878 printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n",
879 __FUNCTION__, status); 879 __func__, status);
880 case -ENOENT: 880 case -ENOENT:
881 case -NFS4ERR_RECLAIM_BAD: 881 case -NFS4ERR_RECLAIM_BAD:
882 case -NFS4ERR_RECLAIM_CONFLICT: 882 case -NFS4ERR_RECLAIM_CONFLICT:
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index 5a2d64927b35..b916297d2334 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -1831,7 +1831,7 @@ static int nfs4_xdr_enc_readdir(struct rpc_rqst *req, __be32 *p, const struct nf
1831 xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 1831 xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages,
1832 args->pgbase, args->count); 1832 args->pgbase, args->count);
1833 dprintk("%s: inlined page args = (%u, %p, %u, %u)\n", 1833 dprintk("%s: inlined page args = (%u, %p, %u, %u)\n",
1834 __FUNCTION__, replen, args->pages, 1834 __func__, replen, args->pages,
1835 args->pgbase, args->count); 1835 args->pgbase, args->count);
1836 1836
1837out: 1837out:
@@ -2192,9 +2192,9 @@ out:
2192 p = xdr_inline_decode(xdr, nbytes); \ 2192 p = xdr_inline_decode(xdr, nbytes); \
2193 if (unlikely(!p)) { \ 2193 if (unlikely(!p)) { \
2194 dprintk("nfs: %s: prematurely hit end of receive" \ 2194 dprintk("nfs: %s: prematurely hit end of receive" \
2195 " buffer\n", __FUNCTION__); \ 2195 " buffer\n", __func__); \
2196 dprintk("nfs: %s: xdr->p=%p, bytes=%u, xdr->end=%p\n", \ 2196 dprintk("nfs: %s: xdr->p=%p, bytes=%u, xdr->end=%p\n", \
2197 __FUNCTION__, xdr->p, nbytes, xdr->end); \ 2197 __func__, xdr->p, nbytes, xdr->end); \
2198 return -EIO; \ 2198 return -EIO; \
2199 } \ 2199 } \
2200} while (0) 2200} while (0)
@@ -2306,12 +2306,12 @@ static int decode_attr_type(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *
2306 READ_BUF(4); 2306 READ_BUF(4);
2307 READ32(*type); 2307 READ32(*type);
2308 if (*type < NF4REG || *type > NF4NAMEDATTR) { 2308 if (*type < NF4REG || *type > NF4NAMEDATTR) {
2309 dprintk("%s: bad type %d\n", __FUNCTION__, *type); 2309 dprintk("%s: bad type %d\n", __func__, *type);
2310 return -EIO; 2310 return -EIO;
2311 } 2311 }
2312 bitmap[0] &= ~FATTR4_WORD0_TYPE; 2312 bitmap[0] &= ~FATTR4_WORD0_TYPE;
2313 } 2313 }
2314 dprintk("%s: type=0%o\n", __FUNCTION__, nfs_type2fmt[*type].nfs2type); 2314 dprintk("%s: type=0%o\n", __func__, nfs_type2fmt[*type].nfs2type);
2315 return 0; 2315 return 0;
2316} 2316}
2317 2317
@@ -2327,7 +2327,7 @@ static int decode_attr_change(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t
2327 READ64(*change); 2327 READ64(*change);
2328 bitmap[0] &= ~FATTR4_WORD0_CHANGE; 2328 bitmap[0] &= ~FATTR4_WORD0_CHANGE;
2329 } 2329 }
2330 dprintk("%s: change attribute=%Lu\n", __FUNCTION__, 2330 dprintk("%s: change attribute=%Lu\n", __func__,
2331 (unsigned long long)*change); 2331 (unsigned long long)*change);
2332 return 0; 2332 return 0;
2333} 2333}
@@ -2344,7 +2344,7 @@ static int decode_attr_size(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *
2344 READ64(*size); 2344 READ64(*size);
2345 bitmap[0] &= ~FATTR4_WORD0_SIZE; 2345 bitmap[0] &= ~FATTR4_WORD0_SIZE;
2346 } 2346 }
2347 dprintk("%s: file size=%Lu\n", __FUNCTION__, (unsigned long long)*size); 2347 dprintk("%s: file size=%Lu\n", __func__, (unsigned long long)*size);
2348 return 0; 2348 return 0;
2349} 2349}
2350 2350
@@ -2360,7 +2360,7 @@ static int decode_attr_link_support(struct xdr_stream *xdr, uint32_t *bitmap, ui
2360 READ32(*res); 2360 READ32(*res);
2361 bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT; 2361 bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT;
2362 } 2362 }
2363 dprintk("%s: link support=%s\n", __FUNCTION__, *res == 0 ? "false" : "true"); 2363 dprintk("%s: link support=%s\n", __func__, *res == 0 ? "false" : "true");
2364 return 0; 2364 return 0;
2365} 2365}
2366 2366
@@ -2376,7 +2376,7 @@ static int decode_attr_symlink_support(struct xdr_stream *xdr, uint32_t *bitmap,
2376 READ32(*res); 2376 READ32(*res);
2377 bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT; 2377 bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT;
2378 } 2378 }
2379 dprintk("%s: symlink support=%s\n", __FUNCTION__, *res == 0 ? "false" : "true"); 2379 dprintk("%s: symlink support=%s\n", __func__, *res == 0 ? "false" : "true");
2380 return 0; 2380 return 0;
2381} 2381}
2382 2382
@@ -2394,7 +2394,7 @@ static int decode_attr_fsid(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs
2394 READ64(fsid->minor); 2394 READ64(fsid->minor);
2395 bitmap[0] &= ~FATTR4_WORD0_FSID; 2395 bitmap[0] &= ~FATTR4_WORD0_FSID;
2396 } 2396 }
2397 dprintk("%s: fsid=(0x%Lx/0x%Lx)\n", __FUNCTION__, 2397 dprintk("%s: fsid=(0x%Lx/0x%Lx)\n", __func__,
2398 (unsigned long long)fsid->major, 2398 (unsigned long long)fsid->major,
2399 (unsigned long long)fsid->minor); 2399 (unsigned long long)fsid->minor);
2400 return 0; 2400 return 0;
@@ -2412,7 +2412,7 @@ static int decode_attr_lease_time(struct xdr_stream *xdr, uint32_t *bitmap, uint
2412 READ32(*res); 2412 READ32(*res);
2413 bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME; 2413 bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME;
2414 } 2414 }
2415 dprintk("%s: file size=%u\n", __FUNCTION__, (unsigned int)*res); 2415 dprintk("%s: file size=%u\n", __func__, (unsigned int)*res);
2416 return 0; 2416 return 0;
2417} 2417}
2418 2418
@@ -2428,7 +2428,7 @@ static int decode_attr_aclsupport(struct xdr_stream *xdr, uint32_t *bitmap, uint
2428 READ32(*res); 2428 READ32(*res);
2429 bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT; 2429 bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT;
2430 } 2430 }
2431 dprintk("%s: ACLs supported=%u\n", __FUNCTION__, (unsigned int)*res); 2431 dprintk("%s: ACLs supported=%u\n", __func__, (unsigned int)*res);
2432 return 0; 2432 return 0;
2433} 2433}
2434 2434
@@ -2444,7 +2444,7 @@ static int decode_attr_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t
2444 READ64(*fileid); 2444 READ64(*fileid);
2445 bitmap[0] &= ~FATTR4_WORD0_FILEID; 2445 bitmap[0] &= ~FATTR4_WORD0_FILEID;
2446 } 2446 }
2447 dprintk("%s: fileid=%Lu\n", __FUNCTION__, (unsigned long long)*fileid); 2447 dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
2448 return 0; 2448 return 0;
2449} 2449}
2450 2450
@@ -2460,7 +2460,7 @@ static int decode_attr_mounted_on_fileid(struct xdr_stream *xdr, uint32_t *bitma
2460 READ64(*fileid); 2460 READ64(*fileid);
2461 bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID; 2461 bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
2462 } 2462 }
2463 dprintk("%s: fileid=%Lu\n", __FUNCTION__, (unsigned long long)*fileid); 2463 dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
2464 return 0; 2464 return 0;
2465} 2465}
2466 2466
@@ -2477,7 +2477,7 @@ static int decode_attr_files_avail(struct xdr_stream *xdr, uint32_t *bitmap, uin
2477 READ64(*res); 2477 READ64(*res);
2478 bitmap[0] &= ~FATTR4_WORD0_FILES_AVAIL; 2478 bitmap[0] &= ~FATTR4_WORD0_FILES_AVAIL;
2479 } 2479 }
2480 dprintk("%s: files avail=%Lu\n", __FUNCTION__, (unsigned long long)*res); 2480 dprintk("%s: files avail=%Lu\n", __func__, (unsigned long long)*res);
2481 return status; 2481 return status;
2482} 2482}
2483 2483
@@ -2494,7 +2494,7 @@ static int decode_attr_files_free(struct xdr_stream *xdr, uint32_t *bitmap, uint
2494 READ64(*res); 2494 READ64(*res);
2495 bitmap[0] &= ~FATTR4_WORD0_FILES_FREE; 2495 bitmap[0] &= ~FATTR4_WORD0_FILES_FREE;
2496 } 2496 }
2497 dprintk("%s: files free=%Lu\n", __FUNCTION__, (unsigned long long)*res); 2497 dprintk("%s: files free=%Lu\n", __func__, (unsigned long long)*res);
2498 return status; 2498 return status;
2499} 2499}
2500 2500
@@ -2511,7 +2511,7 @@ static int decode_attr_files_total(struct xdr_stream *xdr, uint32_t *bitmap, uin
2511 READ64(*res); 2511 READ64(*res);
2512 bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL; 2512 bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL;
2513 } 2513 }
2514 dprintk("%s: files total=%Lu\n", __FUNCTION__, (unsigned long long)*res); 2514 dprintk("%s: files total=%Lu\n", __func__, (unsigned long long)*res);
2515 return status; 2515 return status;
2516} 2516}
2517 2517
@@ -2569,7 +2569,7 @@ static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, st
2569 status = 0; 2569 status = 0;
2570 if (unlikely(!(bitmap[0] & FATTR4_WORD0_FS_LOCATIONS))) 2570 if (unlikely(!(bitmap[0] & FATTR4_WORD0_FS_LOCATIONS)))
2571 goto out; 2571 goto out;
2572 dprintk("%s: fsroot ", __FUNCTION__); 2572 dprintk("%s: fsroot ", __func__);
2573 status = decode_pathname(xdr, &res->fs_path); 2573 status = decode_pathname(xdr, &res->fs_path);
2574 if (unlikely(status != 0)) 2574 if (unlikely(status != 0))
2575 goto out; 2575 goto out;
@@ -2586,7 +2586,7 @@ static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, st
2586 READ32(m); 2586 READ32(m);
2587 2587
2588 loc->nservers = 0; 2588 loc->nservers = 0;
2589 dprintk("%s: servers ", __FUNCTION__); 2589 dprintk("%s: servers ", __func__);
2590 while (loc->nservers < m) { 2590 while (loc->nservers < m) {
2591 struct nfs4_string *server = &loc->servers[loc->nservers]; 2591 struct nfs4_string *server = &loc->servers[loc->nservers];
2592 status = decode_opaque_inline(xdr, &server->len, &server->data); 2592 status = decode_opaque_inline(xdr, &server->len, &server->data);
@@ -2599,7 +2599,7 @@ static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, st
2599 unsigned int i; 2599 unsigned int i;
2600 dprintk("%s: using first %u of %u servers " 2600 dprintk("%s: using first %u of %u servers "
2601 "returned for location %u\n", 2601 "returned for location %u\n",
2602 __FUNCTION__, 2602 __func__,
2603 NFS4_FS_LOCATION_MAXSERVERS, 2603 NFS4_FS_LOCATION_MAXSERVERS,
2604 m, res->nlocations); 2604 m, res->nlocations);
2605 for (i = loc->nservers; i < m; i++) { 2605 for (i = loc->nservers; i < m; i++) {
@@ -2618,7 +2618,7 @@ static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, st
2618 res->nlocations++; 2618 res->nlocations++;
2619 } 2619 }
2620out: 2620out:
2621 dprintk("%s: fs_locations done, error = %d\n", __FUNCTION__, status); 2621 dprintk("%s: fs_locations done, error = %d\n", __func__, status);
2622 return status; 2622 return status;
2623out_eio: 2623out_eio:
2624 status = -EIO; 2624 status = -EIO;
@@ -2638,7 +2638,7 @@ static int decode_attr_maxfilesize(struct xdr_stream *xdr, uint32_t *bitmap, uin
2638 READ64(*res); 2638 READ64(*res);
2639 bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE; 2639 bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE;
2640 } 2640 }
2641 dprintk("%s: maxfilesize=%Lu\n", __FUNCTION__, (unsigned long long)*res); 2641 dprintk("%s: maxfilesize=%Lu\n", __func__, (unsigned long long)*res);
2642 return status; 2642 return status;
2643} 2643}
2644 2644
@@ -2655,7 +2655,7 @@ static int decode_attr_maxlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_
2655 READ32(*maxlink); 2655 READ32(*maxlink);
2656 bitmap[0] &= ~FATTR4_WORD0_MAXLINK; 2656 bitmap[0] &= ~FATTR4_WORD0_MAXLINK;
2657 } 2657 }
2658 dprintk("%s: maxlink=%u\n", __FUNCTION__, *maxlink); 2658 dprintk("%s: maxlink=%u\n", __func__, *maxlink);
2659 return status; 2659 return status;
2660} 2660}
2661 2661
@@ -2672,7 +2672,7 @@ static int decode_attr_maxname(struct xdr_stream *xdr, uint32_t *bitmap, uint32_
2672 READ32(*maxname); 2672 READ32(*maxname);
2673 bitmap[0] &= ~FATTR4_WORD0_MAXNAME; 2673 bitmap[0] &= ~FATTR4_WORD0_MAXNAME;
2674 } 2674 }
2675 dprintk("%s: maxname=%u\n", __FUNCTION__, *maxname); 2675 dprintk("%s: maxname=%u\n", __func__, *maxname);
2676 return status; 2676 return status;
2677} 2677}
2678 2678
@@ -2693,7 +2693,7 @@ static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_
2693 *res = (uint32_t)maxread; 2693 *res = (uint32_t)maxread;
2694 bitmap[0] &= ~FATTR4_WORD0_MAXREAD; 2694 bitmap[0] &= ~FATTR4_WORD0_MAXREAD;
2695 } 2695 }
2696 dprintk("%s: maxread=%lu\n", __FUNCTION__, (unsigned long)*res); 2696 dprintk("%s: maxread=%lu\n", __func__, (unsigned long)*res);
2697 return status; 2697 return status;
2698} 2698}
2699 2699
@@ -2714,7 +2714,7 @@ static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32
2714 *res = (uint32_t)maxwrite; 2714 *res = (uint32_t)maxwrite;
2715 bitmap[0] &= ~FATTR4_WORD0_MAXWRITE; 2715 bitmap[0] &= ~FATTR4_WORD0_MAXWRITE;
2716 } 2716 }
2717 dprintk("%s: maxwrite=%lu\n", __FUNCTION__, (unsigned long)*res); 2717 dprintk("%s: maxwrite=%lu\n", __func__, (unsigned long)*res);
2718 return status; 2718 return status;
2719} 2719}
2720 2720
@@ -2731,7 +2731,7 @@ static int decode_attr_mode(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *
2731 *mode &= ~S_IFMT; 2731 *mode &= ~S_IFMT;
2732 bitmap[1] &= ~FATTR4_WORD1_MODE; 2732 bitmap[1] &= ~FATTR4_WORD1_MODE;
2733 } 2733 }
2734 dprintk("%s: file mode=0%o\n", __FUNCTION__, (unsigned int)*mode); 2734 dprintk("%s: file mode=0%o\n", __func__, (unsigned int)*mode);
2735 return 0; 2735 return 0;
2736} 2736}
2737 2737
@@ -2747,7 +2747,7 @@ static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t
2747 READ32(*nlink); 2747 READ32(*nlink);
2748 bitmap[1] &= ~FATTR4_WORD1_NUMLINKS; 2748 bitmap[1] &= ~FATTR4_WORD1_NUMLINKS;
2749 } 2749 }
2750 dprintk("%s: nlink=%u\n", __FUNCTION__, (unsigned int)*nlink); 2750 dprintk("%s: nlink=%u\n", __func__, (unsigned int)*nlink);
2751 return 0; 2751 return 0;
2752} 2752}
2753 2753
@@ -2766,13 +2766,13 @@ static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nf
2766 if (len < XDR_MAX_NETOBJ) { 2766 if (len < XDR_MAX_NETOBJ) {
2767 if (nfs_map_name_to_uid(clp, (char *)p, len, uid) != 0) 2767 if (nfs_map_name_to_uid(clp, (char *)p, len, uid) != 0)
2768 dprintk("%s: nfs_map_name_to_uid failed!\n", 2768 dprintk("%s: nfs_map_name_to_uid failed!\n",
2769 __FUNCTION__); 2769 __func__);
2770 } else 2770 } else
2771 dprintk("%s: name too long (%u)!\n", 2771 dprintk("%s: name too long (%u)!\n",
2772 __FUNCTION__, len); 2772 __func__, len);
2773 bitmap[1] &= ~FATTR4_WORD1_OWNER; 2773 bitmap[1] &= ~FATTR4_WORD1_OWNER;
2774 } 2774 }
2775 dprintk("%s: uid=%d\n", __FUNCTION__, (int)*uid); 2775 dprintk("%s: uid=%d\n", __func__, (int)*uid);
2776 return 0; 2776 return 0;
2777} 2777}
2778 2778
@@ -2791,13 +2791,13 @@ static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap, struct nf
2791 if (len < XDR_MAX_NETOBJ) { 2791 if (len < XDR_MAX_NETOBJ) {
2792 if (nfs_map_group_to_gid(clp, (char *)p, len, gid) != 0) 2792 if (nfs_map_group_to_gid(clp, (char *)p, len, gid) != 0)
2793 dprintk("%s: nfs_map_group_to_gid failed!\n", 2793 dprintk("%s: nfs_map_group_to_gid failed!\n",
2794 __FUNCTION__); 2794 __func__);
2795 } else 2795 } else
2796 dprintk("%s: name too long (%u)!\n", 2796 dprintk("%s: name too long (%u)!\n",
2797 __FUNCTION__, len); 2797 __func__, len);
2798 bitmap[1] &= ~FATTR4_WORD1_OWNER_GROUP; 2798 bitmap[1] &= ~FATTR4_WORD1_OWNER_GROUP;
2799 } 2799 }
2800 dprintk("%s: gid=%d\n", __FUNCTION__, (int)*gid); 2800 dprintk("%s: gid=%d\n", __func__, (int)*gid);
2801 return 0; 2801 return 0;
2802} 2802}
2803 2803
@@ -2820,7 +2820,7 @@ static int decode_attr_rdev(struct xdr_stream *xdr, uint32_t *bitmap, dev_t *rde
2820 *rdev = tmp; 2820 *rdev = tmp;
2821 bitmap[1] &= ~ FATTR4_WORD1_RAWDEV; 2821 bitmap[1] &= ~ FATTR4_WORD1_RAWDEV;
2822 } 2822 }
2823 dprintk("%s: rdev=(0x%x:0x%x)\n", __FUNCTION__, major, minor); 2823 dprintk("%s: rdev=(0x%x:0x%x)\n", __func__, major, minor);
2824 return 0; 2824 return 0;
2825} 2825}
2826 2826
@@ -2837,7 +2837,7 @@ static int decode_attr_space_avail(struct xdr_stream *xdr, uint32_t *bitmap, uin
2837 READ64(*res); 2837 READ64(*res);
2838 bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL; 2838 bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL;
2839 } 2839 }
2840 dprintk("%s: space avail=%Lu\n", __FUNCTION__, (unsigned long long)*res); 2840 dprintk("%s: space avail=%Lu\n", __func__, (unsigned long long)*res);
2841 return status; 2841 return status;
2842} 2842}
2843 2843
@@ -2854,7 +2854,7 @@ static int decode_attr_space_free(struct xdr_stream *xdr, uint32_t *bitmap, uint
2854 READ64(*res); 2854 READ64(*res);
2855 bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE; 2855 bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE;
2856 } 2856 }
2857 dprintk("%s: space free=%Lu\n", __FUNCTION__, (unsigned long long)*res); 2857 dprintk("%s: space free=%Lu\n", __func__, (unsigned long long)*res);
2858 return status; 2858 return status;
2859} 2859}
2860 2860
@@ -2871,7 +2871,7 @@ static int decode_attr_space_total(struct xdr_stream *xdr, uint32_t *bitmap, uin
2871 READ64(*res); 2871 READ64(*res);
2872 bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL; 2872 bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL;
2873 } 2873 }
2874 dprintk("%s: space total=%Lu\n", __FUNCTION__, (unsigned long long)*res); 2874 dprintk("%s: space total=%Lu\n", __func__, (unsigned long long)*res);
2875 return status; 2875 return status;
2876} 2876}
2877 2877
@@ -2887,7 +2887,7 @@ static int decode_attr_space_used(struct xdr_stream *xdr, uint32_t *bitmap, uint
2887 READ64(*used); 2887 READ64(*used);
2888 bitmap[1] &= ~FATTR4_WORD1_SPACE_USED; 2888 bitmap[1] &= ~FATTR4_WORD1_SPACE_USED;
2889 } 2889 }
2890 dprintk("%s: space used=%Lu\n", __FUNCTION__, 2890 dprintk("%s: space used=%Lu\n", __func__,
2891 (unsigned long long)*used); 2891 (unsigned long long)*used);
2892 return 0; 2892 return 0;
2893} 2893}
@@ -2918,7 +2918,7 @@ static int decode_attr_time_access(struct xdr_stream *xdr, uint32_t *bitmap, str
2918 status = decode_attr_time(xdr, time); 2918 status = decode_attr_time(xdr, time);
2919 bitmap[1] &= ~FATTR4_WORD1_TIME_ACCESS; 2919 bitmap[1] &= ~FATTR4_WORD1_TIME_ACCESS;
2920 } 2920 }
2921 dprintk("%s: atime=%ld\n", __FUNCTION__, (long)time->tv_sec); 2921 dprintk("%s: atime=%ld\n", __func__, (long)time->tv_sec);
2922 return status; 2922 return status;
2923} 2923}
2924 2924
@@ -2934,7 +2934,7 @@ static int decode_attr_time_metadata(struct xdr_stream *xdr, uint32_t *bitmap, s
2934 status = decode_attr_time(xdr, time); 2934 status = decode_attr_time(xdr, time);
2935 bitmap[1] &= ~FATTR4_WORD1_TIME_METADATA; 2935 bitmap[1] &= ~FATTR4_WORD1_TIME_METADATA;
2936 } 2936 }
2937 dprintk("%s: ctime=%ld\n", __FUNCTION__, (long)time->tv_sec); 2937 dprintk("%s: ctime=%ld\n", __func__, (long)time->tv_sec);
2938 return status; 2938 return status;
2939} 2939}
2940 2940
@@ -2950,7 +2950,7 @@ static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, str
2950 status = decode_attr_time(xdr, time); 2950 status = decode_attr_time(xdr, time);
2951 bitmap[1] &= ~FATTR4_WORD1_TIME_MODIFY; 2951 bitmap[1] &= ~FATTR4_WORD1_TIME_MODIFY;
2952 } 2952 }
2953 dprintk("%s: mtime=%ld\n", __FUNCTION__, (long)time->tv_sec); 2953 dprintk("%s: mtime=%ld\n", __func__, (long)time->tv_sec);
2954 return status; 2954 return status;
2955} 2955}
2956 2956
@@ -2962,7 +2962,7 @@ static int verify_attr_len(struct xdr_stream *xdr, __be32 *savep, uint32_t attrl
2962 if (unlikely(attrwords != nwords)) { 2962 if (unlikely(attrwords != nwords)) {
2963 dprintk("%s: server returned incorrect attribute length: " 2963 dprintk("%s: server returned incorrect attribute length: "
2964 "%u %c %u\n", 2964 "%u %c %u\n",
2965 __FUNCTION__, 2965 __func__,
2966 attrwords << 2, 2966 attrwords << 2,
2967 (attrwords < nwords) ? '<' : '>', 2967 (attrwords < nwords) ? '<' : '>',
2968 nwords << 2); 2968 nwords << 2);
@@ -3067,7 +3067,7 @@ static int decode_server_caps(struct xdr_stream *xdr, struct nfs4_server_caps_re
3067 goto xdr_error; 3067 goto xdr_error;
3068 status = verify_attr_len(xdr, savep, attrlen); 3068 status = verify_attr_len(xdr, savep, attrlen);
3069xdr_error: 3069xdr_error:
3070 dprintk("%s: xdr returned %d!\n", __FUNCTION__, -status); 3070 dprintk("%s: xdr returned %d!\n", __func__, -status);
3071 return status; 3071 return status;
3072} 3072}
3073 3073
@@ -3100,7 +3100,7 @@ static int decode_statfs(struct xdr_stream *xdr, struct nfs_fsstat *fsstat)
3100 3100
3101 status = verify_attr_len(xdr, savep, attrlen); 3101 status = verify_attr_len(xdr, savep, attrlen);
3102xdr_error: 3102xdr_error:
3103 dprintk("%s: xdr returned %d!\n", __FUNCTION__, -status); 3103 dprintk("%s: xdr returned %d!\n", __func__, -status);
3104 return status; 3104 return status;
3105} 3105}
3106 3106
@@ -3125,7 +3125,7 @@ static int decode_pathconf(struct xdr_stream *xdr, struct nfs_pathconf *pathconf
3125 3125
3126 status = verify_attr_len(xdr, savep, attrlen); 3126 status = verify_attr_len(xdr, savep, attrlen);
3127xdr_error: 3127xdr_error:
3128 dprintk("%s: xdr returned %d!\n", __FUNCTION__, -status); 3128 dprintk("%s: xdr returned %d!\n", __func__, -status);
3129 return status; 3129 return status;
3130} 3130}
3131 3131
@@ -3193,7 +3193,7 @@ static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr, cons
3193 if ((status = verify_attr_len(xdr, savep, attrlen)) == 0) 3193 if ((status = verify_attr_len(xdr, savep, attrlen)) == 0)
3194 fattr->valid = NFS_ATTR_FATTR | NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4; 3194 fattr->valid = NFS_ATTR_FATTR | NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4;
3195xdr_error: 3195xdr_error:
3196 dprintk("%s: xdr returned %d\n", __FUNCTION__, -status); 3196 dprintk("%s: xdr returned %d\n", __func__, -status);
3197 return status; 3197 return status;
3198} 3198}
3199 3199
@@ -3226,7 +3226,7 @@ static int decode_fsinfo(struct xdr_stream *xdr, struct nfs_fsinfo *fsinfo)
3226 3226
3227 status = verify_attr_len(xdr, savep, attrlen); 3227 status = verify_attr_len(xdr, savep, attrlen);
3228xdr_error: 3228xdr_error:
3229 dprintk("%s: xdr returned %d!\n", __FUNCTION__, -status); 3229 dprintk("%s: xdr returned %d!\n", __func__, -status);
3230 return status; 3230 return status;
3231} 3231}
3232 3232
@@ -3418,7 +3418,7 @@ static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res)
3418 3418
3419 return decode_delegation(xdr, res); 3419 return decode_delegation(xdr, res);
3420xdr_error: 3420xdr_error:
3421 dprintk("%s: Bitmap too large! Length = %u\n", __FUNCTION__, bmlen); 3421 dprintk("%s: Bitmap too large! Length = %u\n", __func__, bmlen);
3422 return -EIO; 3422 return -EIO;
3423} 3423}
3424 3424
@@ -3575,7 +3575,7 @@ short_pkt:
3575 * the call was successful, but incomplete. The caller can retry the 3575 * the call was successful, but incomplete. The caller can retry the
3576 * readdir starting at the last cookie. 3576 * readdir starting at the last cookie.
3577 */ 3577 */
3578 dprintk("%s: short packet at entry %d\n", __FUNCTION__, nr); 3578 dprintk("%s: short packet at entry %d\n", __func__, nr);
3579 entry[0] = entry[1] = 0; 3579 entry[0] = entry[1] = 0;
3580 if (nr) 3580 if (nr)
3581 goto out; 3581 goto out;
diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
index 5ccf7faee19c..03599bfe81cf 100644
--- a/fs/nfs/proc.c
+++ b/fs/nfs/proc.c
@@ -63,17 +63,17 @@ nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
63 }; 63 };
64 int status; 64 int status;
65 65
66 dprintk("%s: call getattr\n", __FUNCTION__); 66 dprintk("%s: call getattr\n", __func__);
67 nfs_fattr_init(fattr); 67 nfs_fattr_init(fattr);
68 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0); 68 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
69 dprintk("%s: reply getattr: %d\n", __FUNCTION__, status); 69 dprintk("%s: reply getattr: %d\n", __func__, status);
70 if (status) 70 if (status)
71 return status; 71 return status;
72 dprintk("%s: call statfs\n", __FUNCTION__); 72 dprintk("%s: call statfs\n", __func__);
73 msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS]; 73 msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS];
74 msg.rpc_resp = &fsinfo; 74 msg.rpc_resp = &fsinfo;
75 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0); 75 status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
76 dprintk("%s: reply statfs: %d\n", __FUNCTION__, status); 76 dprintk("%s: reply statfs: %d\n", __func__, status);
77 if (status) 77 if (status)
78 return status; 78 return status;
79 info->rtmax = NFS_MAXDATA; 79 info->rtmax = NFS_MAXDATA;
diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index 16f57e0af999..40d17987d0e8 100644
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -329,7 +329,7 @@ int nfs_readpage_result(struct rpc_task *task, struct nfs_read_data *data)
329{ 329{
330 int status; 330 int status;
331 331
332 dprintk("NFS: %s: %5u, (status %d)\n", __FUNCTION__, task->tk_pid, 332 dprintk("NFS: %s: %5u, (status %d)\n", __func__, task->tk_pid,
333 task->tk_status); 333 task->tk_status);
334 334
335 status = NFS_PROTO(data->inode)->read_done(task, data); 335 status = NFS_PROTO(data->inode)->read_done(task, data);
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index 7226a506f3ca..2a4a024a4e7b 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -405,7 +405,7 @@ static int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
405 return 0; 405 return 0;
406 406
407 out_err: 407 out_err:
408 dprintk("%s: statfs error = %d\n", __FUNCTION__, -error); 408 dprintk("%s: statfs error = %d\n", __func__, -error);
409 unlock_kernel(); 409 unlock_kernel();
410 return error; 410 return error;
411} 411}
@@ -2015,6 +2015,10 @@ static int nfs4_get_sb(struct file_system_type *fs_type,
2015 goto error_splat_super; 2015 goto error_splat_super;
2016 } 2016 }
2017 2017
2018 error = security_sb_set_mnt_opts(s, &data.lsm_opts);
2019 if (error)
2020 goto error_splat_root;
2021
2018 s->s_flags |= MS_ACTIVE; 2022 s->s_flags |= MS_ACTIVE;
2019 mnt->mnt_sb = s; 2023 mnt->mnt_sb = s;
2020 mnt->mnt_root = mntroot; 2024 mnt->mnt_root = mntroot;
@@ -2031,6 +2035,8 @@ out_free:
2031 nfs_free_server(server); 2035 nfs_free_server(server);
2032 goto out; 2036 goto out;
2033 2037
2038error_splat_root:
2039 dput(mntroot);
2034error_splat_super: 2040error_splat_super:
2035 up_write(&s->s_umount); 2041 up_write(&s->s_umount);
2036 deactivate_super(s); 2042 deactivate_super(s);
@@ -2114,6 +2120,8 @@ static int nfs4_xdev_get_sb(struct file_system_type *fs_type, int flags,
2114 mnt->mnt_sb = s; 2120 mnt->mnt_sb = s;
2115 mnt->mnt_root = mntroot; 2121 mnt->mnt_root = mntroot;
2116 2122
2123 security_sb_clone_mnt_opts(data->sb, s);
2124
2117 dprintk("<-- nfs4_xdev_get_sb() = 0\n"); 2125 dprintk("<-- nfs4_xdev_get_sb() = 0\n");
2118 return 0; 2126 return 0;
2119 2127
@@ -2197,6 +2205,8 @@ static int nfs4_referral_get_sb(struct file_system_type *fs_type, int flags,
2197 mnt->mnt_sb = s; 2205 mnt->mnt_sb = s;
2198 mnt->mnt_root = mntroot; 2206 mnt->mnt_root = mntroot;
2199 2207
2208 security_sb_clone_mnt_opts(data->sb, s);
2209
2200 dprintk("<-- nfs4_referral_get_sb() = 0\n"); 2210 dprintk("<-- nfs4_referral_get_sb() = 0\n");
2201 return 0; 2211 return 0;
2202 2212
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 1ade11d1ba07..6d8ace3e3259 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -415,7 +415,7 @@ nfs_dirty_request(struct nfs_page *req)
415 415
416 if (page == NULL || test_bit(PG_NEED_COMMIT, &req->wb_flags)) 416 if (page == NULL || test_bit(PG_NEED_COMMIT, &req->wb_flags))
417 return 0; 417 return 0;
418 return !PageWriteback(req->wb_page); 418 return !PageWriteback(page);
419} 419}
420 420
421#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4) 421#if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 808cbdc193d3..c447e0743a3c 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -2441,7 +2441,7 @@ static const struct pid_entry tgid_base_stuff[] = {
2441 REG("oom_adj", S_IRUGO|S_IWUSR, oom_adjust), 2441 REG("oom_adj", S_IRUGO|S_IWUSR, oom_adjust),
2442#ifdef CONFIG_AUDITSYSCALL 2442#ifdef CONFIG_AUDITSYSCALL
2443 REG("loginuid", S_IWUSR|S_IRUGO, loginuid), 2443 REG("loginuid", S_IWUSR|S_IRUGO, loginuid),
2444 REG("sessionid", S_IRUSR, sessionid), 2444 REG("sessionid", S_IRUGO, sessionid),
2445#endif 2445#endif
2446#ifdef CONFIG_FAULT_INJECTION 2446#ifdef CONFIG_FAULT_INJECTION
2447 REG("make-it-fail", S_IRUGO|S_IWUSR, fault_inject), 2447 REG("make-it-fail", S_IRUGO|S_IWUSR, fault_inject),
diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index a1c3a1fab7f0..8c0e4b92574f 100644
--- a/fs/sysfs/dir.c
+++ b/fs/sysfs/dir.c
@@ -419,12 +419,8 @@ void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt,
419 */ 419 */
420int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd) 420int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
421{ 421{
422 if (sysfs_find_dirent(acxt->parent_sd, sd->s_name)) { 422 if (sysfs_find_dirent(acxt->parent_sd, sd->s_name))
423 printk(KERN_WARNING "sysfs: duplicate filename '%s' "
424 "can not be created\n", sd->s_name);
425 WARN_ON(1);
426 return -EEXIST; 423 return -EEXIST;
427 }
428 424
429 sd->s_parent = sysfs_get(acxt->parent_sd); 425 sd->s_parent = sysfs_get(acxt->parent_sd);
430 426
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-04 08:04:44 -0500