nfs3-helpers.c

Bug Summary

File:	xlators/nfs/server/src/nfs3-helpers.c
Location:	line 1128, column 25
Description:	Value stored to 'poa' during its initialization is never read

Annotated Source Code

1	/*
2	Copyright (c) 2010-2011 Gluster, Inc. <http://www.gluster.com>
3	This file is part of GlusterFS.
4
5	GlusterFS is free software; you can redistribute it and/or modify
6	it under the terms of the GNU General Public License as published
7	by the Free Software Foundation; either version 3 of the License,
8	or (at your option) any later version.
9
10	GlusterFS is distributed in the hope that it will be useful, but
11	WITHOUT ANY WARRANTY; without even the implied warranty of
12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13	General Public License for more details.
14
15	You should have received a copy of the GNU General Public License
16	along with this program. If not, see
17	<http://www.gnu.org/licenses/>.
18	*/
19
20	#ifndef _CONFIG_H
21	#define _CONFIG_H
22	#include "config.h"
23	#endif
24
25	#include <inttypes.h>
26
27	#include "xlator.h"
28	#include "nfs3.h"
29	#include "nfs3-fh.h"
30	#include "msg-nfs3.h"
31	#include "rbthash.h"
32	#include "nfs-fops.h"
33	#include "nfs-inodes.h"
34	#include "nfs-generics.h"
35	#include "nfs3-helpers.h"
36	#include "nfs-mem-types.h"
37	#include "iatt.h"
38	#include "common-utils.h"
39	#include <string.h>
40
41	extern int
42	nfs3_set_root_looked_up (struct nfs3_state nfs3, struct nfs3_fh rootfh);
43
44	extern int
45	nfs3_is_root_looked_up (struct nfs3_state nfs3, struct nfs3_fh rootfh);
46
47
48	#define nfs3_call_resume(cst)do { if (((cst)) && (cst)->resume_fn) (cst)->resume_fn (cst); } while (0) \
49	do { \
50	if (((cst)) && (cst)->resume_fn) \
51	(cst)->resume_fn (cst); \
52	} while (0) \
53
54	#define nfs3_call_resume_estale(csta)do { (csta)->resolve_ret = -1; (csta)->resolve_errno = 116 ; do { if (((csta)) && (csta)->resume_fn) (csta)-> resume_fn (csta); } while (0); } while (0) \
55	do { \
56	(csta)->resolve_ret = -1; \
57	(csta)->resolve_errno = ESTALE116; \
58	nfs3_call_resume (csta)do { if (((csta)) && (csta)->resume_fn) (csta)-> resume_fn (csta); } while (0); \
59	} while (0) \
60
61	struct nfs3stat_strerror {
62	nfsstat3 stat;
63	char strerror[100];
64	};
65
66
67	struct nfs3stat_strerror nfs3stat_strerror_table[] = {
68	{ NFS3_OK, "Call completed successfully." },
69	{ NFS3ERR_PERM, "Not owner" },
70	{ NFS3ERR_NOENT, "No such file or directory" },
71	{ NFS3ERR_IO, "I/O error" },
72	{ NFS3ERR_NXIO, "I/O error" },
73	{ NFS3ERR_ACCES, "Permission denied" },
74	{ NFS3ERR_EXIST, "File exists" },
75	{ NFS3ERR_XDEV, "Attempt to do a cross-device hard link"},
76	{ NFS3ERR_NODEV, "No such device" },
77	{ NFS3ERR_NOTDIR, "Not a directory" },
78	{ NFS3ERR_ISDIR, "Is a directory" },
79	{ NFS3ERR_INVAL, "Invalid argument for operation" },
80	{ NFS3ERR_FBIG, "File too large" },
81	{ NFS3ERR_NOSPC, "No space left on device" },
82	{ NFS3ERR_ROFS, "Read-only file system" },
83	{ NFS3ERR_MLINK, "Too many hard links" },
84	{ NFS3ERR_NAMETOOLONG, "Filename in operation was too long" },
85	{ NFS3ERR_NOTEMPTY, "Directory not empty" },
86	{ NFS3ERR_DQUOT, "Resource (quota) hard limit exceeded" },
87	{ NFS3ERR_STALE, "Invalid file handle" },
88	{ NFS3ERR_REMOTE, "Too many levels of remote in path" },
89	{ NFS3ERR_BADHANDLE, "Illegal NFS file handle" },
90	{ NFS3ERR_NOT_SYNC, "Update synchronization mismatch detected" },
91	{ NFS3ERR_BAD_COOKIE, "READDIR or READDIRPLUS cookie is stale"},
92	{ NFS3ERR_NOTSUPP, "Operation is not supported" },
93	{ NFS3ERR_TOOSMALL, "Buffer or request is too small" },
94	{ NFS3ERR_SERVERFAULT, "Error occurred on the server or IO Error" },
95	{ NFS3ERR_BADTYPE, "Type not supported by the server" },
96	{ NFS3ERR_JUKEBOX, "Cannot complete server initiated request" },
97	{ -1, "IO Error" },
98
99	};
100
101
102	uint64_t
103	nfs3_iatt_gfid_to_ino (struct iatt *buf)
104	{
105	uint64_t ino = 0;
106
107	if (!buf)
108	return 0;
109
110	if (gf_nfs_enable_ino32()((((struct nfs_state )((struct nfs_state )((xlator_t )(__glusterfs_this_location ()))->private))->enable_ino32))) {
111	ino = (uint32_t )nfs_hash_gfid (buf->ia_gfid);
112	goto hashout;
113	}
114
115	/* from posix its guaranteed to send unique ino */
116	ino = buf->ia_ino;
117
118	hashout:
119	return ino;
120	}
121
122
123	void
124	nfs3_map_deviceid_to_statdev (struct iatt *ia, uint64_t deviceid)
125	{
126	if (!ia)
127	return;
128
129	ia->ia_dev = deviceid;
130	}
131
132
133	struct nfs3_fh
134	nfs3_extract_nfs3_fh (nfs_fh3 fh)
135	{
136	struct nfs3_fh gfh;
137
138	memcpy (&gfh, fh.data.data_val, fh.data.data_len);
139	return gfh;
140	}
141
142
143	struct nfs3_fh
144	nfs3_extract_lookup_fh (lookup3args *args)
145	{
146	return nfs3_extract_nfs3_fh(args->what.dir);
147	}
148
149
150	char *
151	nfs3_extract_lookup_name (lookup3args *args)
152	{
153	return args->what.name;
154	}
155
156
157	nfsstat3
158	nfs3_errno_to_nfsstat3 (int errnum)
159	{
160	nfsstat3 stat = NFS3_OK;
161
162	switch (errnum) {
163
164	case 0:
165	stat = NFS3_OK;
166	break;
167
168	case EPERM1:
169	stat = NFS3ERR_PERM;
170	break;
171
172	case ENOENT2:
173	stat = NFS3ERR_NOENT;
174	break;
175
176	case EACCES13:
177	stat = NFS3ERR_ACCES;
178	break;
179
180	case EEXIST17:
181	stat = NFS3ERR_EXIST;
182	break;
183
184	case EXDEV18:
185	stat = NFS3ERR_XDEV;
186	break;
187
188	case ENODEV19:
189	stat = NFS3ERR_NODEV;
190	break;
191
192	case EIO5:
193	stat = NFS3ERR_IO;
194	break;
195
196	case ENXIO6:
197	stat = NFS3ERR_NXIO;
198	break;
199
200	case ENOTDIR20:
201	stat = NFS3ERR_NOTDIR;
202	break;
203
204	case EISDIR21:
205	stat = NFS3ERR_ISDIR;
206	break;
207
208	case EINVAL22:
209	stat = NFS3ERR_INVAL;
210	break;
211
212	case ENOSPC28:
213	stat = NFS3ERR_NOSPC;
214	break;
215
216	case EROFS30:
217	stat = NFS3ERR_ROFS;
218	break;
219
220	case EFBIG27:
221	stat = NFS3ERR_FBIG;
222	break;
223
224	case EMLINK31:
225	stat = NFS3ERR_MLINK;
226	break;
227
228	case ENAMETOOLONG36:
229	stat = NFS3ERR_NAMETOOLONG;
230	break;
231
232	case ENOTEMPTY39:
233	stat = NFS3ERR_NOTEMPTY;
234	break;
235
236	case EFAULT14:
237	stat = NFS3ERR_SERVERFAULT;
238	break;
239
240	case ENOSYS38:
241	stat = NFS3ERR_NOTSUPP;
242	break;
243
244	case EBADF9:
245	stat = NFS3ERR_BADTYPE;
246	break;
247
248	case ESTALE116:
249	stat = NFS3ERR_STALE;
250	break;
251
252	case ENOTCONN107:
253	stat = NFS3ERR_IO;
254	break;
255
256	case EDQUOT122:
257	stat = NFS3ERR_DQUOT;
258	break;
259
260	default:
261	stat = NFS3ERR_SERVERFAULT;
262	break;
263	}
264
265	return stat;
266	}
267
268
269	void
270	nfs3_fill_lookup3res_error (lookup3res *res, nfsstat3 stat,
271	struct iatt *dirstat)
272	{
273
274	memset (res, 0, sizeof (*res));
275	res->status = stat;
276	if (!dirstat) {
277	res->lookup3res_u.resfail.dir_attributes.attributes_follow = FALSE(0);
278	}
279
280	}
281
282	fattr3
283	nfs3_stat_to_fattr3 (struct iatt *buf)
284	{
285	fattr3 fa = {0, };
286
287	if (IA_ISDIR (buf->ia_type)(buf->ia_type == IA_IFDIR))
288	fa.type = NF3DIR;
289	else if (IA_ISREG (buf->ia_type)(buf->ia_type == IA_IFREG))
290	fa.type = NF3REG;
291	else if (IA_ISCHR (buf->ia_type)(buf->ia_type == IA_IFCHR))
292	fa.type = NF3CHR;
293	else if (IA_ISBLK (buf->ia_type)(buf->ia_type == IA_IFBLK))
294	fa.type = NF3BLK;
295	else if (IA_ISFIFO (buf->ia_type)(buf->ia_type == IA_IFIFO))
296	fa.type = NF3FIFO;
297	else if (IA_ISLNK (buf->ia_type)(buf->ia_type == IA_IFLNK))
298	fa.type = NF3LNK;
299	else if (IA_ISSOCK (buf->ia_type)(buf->ia_type == IA_IFSOCK))
300	fa.type = NF3SOCK;
301
302	if (IA_PROT_RUSR (buf->ia_prot)((buf->ia_prot).owner.read == 1))
303	fa.mode \|= NFS3MODE_ROWNER0x00100;
304	if (IA_PROT_WUSR (buf->ia_prot)((buf->ia_prot).owner.write == 1))
305	fa.mode \|= NFS3MODE_WOWNER0x00080;
306	if (IA_PROT_XUSR (buf->ia_prot)((buf->ia_prot).owner.exec == 1))
307	fa.mode \|= NFS3MODE_XOWNER0x00040;
308
309	if (IA_PROT_RGRP (buf->ia_prot)((buf->ia_prot).group.read == 1))
310	fa.mode \|= NFS3MODE_RGROUP0x00020;
311	if (IA_PROT_WGRP (buf->ia_prot)((buf->ia_prot).group.write == 1))
312	fa.mode \|= NFS3MODE_WGROUP0x00010;
313	if (IA_PROT_XGRP (buf->ia_prot)((buf->ia_prot).group.exec == 1))
314	fa.mode \|= NFS3MODE_XGROUP0x00008;
315
316	if (IA_PROT_ROTH (buf->ia_prot)((buf->ia_prot).other.read == 1))
317	fa.mode \|= NFS3MODE_ROTHER0x00004;
318	if (IA_PROT_WOTH (buf->ia_prot)((buf->ia_prot).other.write == 1))
319	fa.mode \|= NFS3MODE_WOTHER0x00002;
320	if (IA_PROT_XOTH (buf->ia_prot)((buf->ia_prot).other.exec == 1))
321	fa.mode \|= NFS3MODE_XOTHER0x00001;
322
323	if (IA_PROT_SUID (buf->ia_prot)((buf->ia_prot).suid == 1))
324	fa.mode \|= NFS3MODE_SETXUID0x00800;
325	if (IA_PROT_SGID (buf->ia_prot)((buf->ia_prot).sgid == 1))
326	fa.mode \|= NFS3MODE_SETXGID0x00400;
327	if (IA_PROT_STCKY (buf->ia_prot)((buf->ia_prot).sticky == 1))
328	fa.mode \|= NFS3MODE_SAVESWAPTXT0x00200;
329
330	fa.nlink = buf->ia_nlink;
331	fa.uid = buf->ia_uid;
332	fa.gid = buf->ia_gid;
333	fa.size = buf->ia_size;
334	fa.used = (buf->ia_blocks * 512);
335
336	if ((IA_ISCHR (buf->ia_type)(buf->ia_type == IA_IFCHR) \|\| IA_ISBLK (buf->ia_type)(buf->ia_type == IA_IFBLK))) {
337	fa.rdev.specdata1 = ia_major (buf->ia_rdev);
338	fa.rdev.specdata2 = ia_minor (buf->ia_rdev);
339	} else {
340	fa.rdev.specdata1 = 0;
341	fa.rdev.specdata2 = 0;
342	}
343
344	fa.fsid = buf->ia_dev;
345	fa.fileid = nfs3_iatt_gfid_to_ino (buf);
346
347	fa.atime.seconds = buf->ia_atime;
348	fa.atime.nseconds = buf->ia_atime_nsec;
349
350	fa.ctime.seconds = buf->ia_ctime;
351	fa.ctime.nseconds = buf->ia_ctime_nsec;
352
353	fa.mtime.seconds = buf->ia_mtime;
354	fa.mtime.nseconds = buf->ia_mtime_nsec;
355
356	return fa;
357	}
358
359
360	post_op_attr
361	nfs3_stat_to_post_op_attr (struct iatt *buf)
362	{
363	post_op_attr attr = {0, };
364	if (!buf)
365	return attr;
366
367	/* Some performance translators return zero-filled stats when they
368	* do not have up-to-date attributes. Need to handle this by not
369	* returning these zeroed out attrs.
370	*/
371	attr.attributes_follow = FALSE(0);
372	if (nfs_zero_filled_stat (buf))
373	goto out;
374
375	attr.post_op_attr_u.attributes = nfs3_stat_to_fattr3 (buf);
376	attr.attributes_follow = TRUE(1);
377
378	out:
379	return attr;
380	}
381
382
383	pre_op_attr
384	nfs3_stat_to_pre_op_attr (struct iatt *pre)
385	{
386	pre_op_attr poa = {0, };
387
388	/* Some performance translators return zero-filled stats when they
389	* do not have up-to-date attributes. Need to handle this by not
390	* returning these zeroed out attrs.
391	*/
392	poa.attributes_follow = FALSE(0);
393	if (nfs_zero_filled_stat (pre))
394	goto out;
395
396	poa.attributes_follow = TRUE(1);
397	poa.pre_op_attr_u.attributes.size = pre->ia_size;
398	poa.pre_op_attr_u.attributes.mtime.seconds = pre->ia_mtime;
399	poa.pre_op_attr_u.attributes.mtime.nseconds = pre->ia_mtime_nsec;
400	poa.pre_op_attr_u.attributes.ctime.seconds = pre->ia_ctime;
401	poa.pre_op_attr_u.attributes.ctime.nseconds = pre->ia_ctime_nsec;
402
403	out:
404	return poa;
405	}
406
407	void
408	nfs3_fill_lookup3res_success (lookup3res *res, nfsstat3 stat,
409	struct nfs3_fh fh, struct iatt buf,
410	struct iatt *postparent)
411	{
412	post_op_attr obj, dir;
413	uint32_t fhlen = 0;
414
415	res->status = stat;
416	if (fh) {
417	res->lookup3res_u.resok.object.data.data_val = (void *)fh;
418	fhlen = nfs3_fh_compute_size (fh);
419	res->lookup3res_u.resok.object.data.data_len = fhlen;
420	}
421
422	obj.attributes_follow = FALSE(0);
423	dir.attributes_follow = FALSE(0);
424	obj = nfs3_stat_to_post_op_attr (buf);
425	dir = nfs3_stat_to_post_op_attr (postparent);
426
427	res->lookup3res_u.resok.obj_attributes = obj;
428	res->lookup3res_u.resok.dir_attributes = dir;
429	}
430
431
432	void
433	nfs3_fill_lookup3res (lookup3res res, nfsstat3 stat, struct nfs3_fh newfh,
434	struct iatt buf, struct iatt postparent,
435	uint64_t deviceid)
436	{
437
438	memset (res, 0, sizeof (*res));
439	nfs3_map_deviceid_to_statdev (buf, deviceid);
440	nfs3_map_deviceid_to_statdev (postparent, deviceid);
441	if (stat != NFS3_OK)
442	nfs3_fill_lookup3res_error (res, stat, postparent);
443	else
444	nfs3_fill_lookup3res_success (res, stat, newfh, buf,
445	postparent);
446	}
447
448	struct nfs3_fh
449	nfs3_extract_getattr_fh (getattr3args *args)
450	{
451	return nfs3_extract_nfs3_fh(args->object);
452	}
453
454
455	void
456	nfs3_fill_getattr3res (getattr3res res, nfsstat3 stat, struct iatt buf,
457	uint64_t deviceid)
458	{
459
460	memset (res, 0, sizeof (*res));
461	res->status = stat;
462	if (stat != NFS3_OK)
463	return;
464
465	nfs3_map_deviceid_to_statdev (buf, deviceid);
466	res->getattr3res_u.resok.obj_attributes = nfs3_stat_to_fattr3 (buf);
467
468	}
469
470
471	struct nfs3_fh
472	nfs3_extract_fsinfo_fh (fsinfo3args *args)
473	{
474	return nfs3_extract_nfs3_fh (args->fsroot);
475	}
476
477
478	void
479	nfs3_fill_fsinfo3res (struct nfs3_state nfs3, fsinfo3res res,
480	nfsstat3 status, struct iatt *fsroot, uint64_t deviceid)
481	{
482	fsinfo3resok resok = {{0}, };
483	nfstime3 tdelta = GF_NFS3_TIMEDELTA_SECS{1,0};
484
485	memset (res, 0, sizeof (*res));
486	res->status = status;
487	if (status != NFS3_OK)
488	return;
489
490	nfs3_map_deviceid_to_statdev (fsroot, deviceid);
491	resok.obj_attributes = nfs3_stat_to_post_op_attr (fsroot);
492	resok.rtmax = nfs3->readsize;
493	resok.rtpref = nfs3->readsize;
494	resok.rtmult = GF_NFS3_RTMULT(4 * 1024ULL);
495	resok.wtmax = nfs3->writesize;
496	resok.wtpref = nfs3->writesize;
497	resok.wtmult = GF_NFS3_WTMULT(4 * 1024ULL);
498	resok.dtpref = nfs3->readdirsize;
499	resok.maxfilesize = GF_NFS3_MAXFILE(1 * 1125899906842624ULL);
500	resok.time_delta = tdelta;
501	resok.properties = GF_NFS3_FS_PROP(0x0001 \| 0x0002 \| 0x0008 \| 0x0010);
502
503	res->fsinfo3res_u.resok = resok;
504
505	}
506
507
508	void
509	nfs3_prep_lookup3args (lookup3args args, struct nfs3_fh fh, char *name)
510	{
511	memset (args, 0, sizeof (*args));
512	args->what.dir.data.data_val = (void *)fh;
513	args->what.name = name;
514	}
515
516
517	void
518	nfs3_prep_getattr3args (getattr3args args, struct nfs3_fh fh)
519	{
520	memset (args, 0, sizeof (*args));
521	args->object.data.data_val = (void *)fh;
522	}
523
524
525	void
526	nfs3_prep_fsinfo3args (fsinfo3args args, struct nfs3_fh root)
527	{
528	memset (args, 0, sizeof (*args));
529	args->fsroot.data.data_val = (void *)root;
530	}
531
532
533	char *
534	nfsstat3_strerror(int stat)
535	{
536	int i;
537	for(i = 0; nfs3stat_strerror_table[i].stat != -1; i++) {
538	if (nfs3stat_strerror_table[i].stat == stat)
539	return nfs3stat_strerror_table[i].strerror;
540	}
541
542	return nfs3stat_strerror_table[i].strerror;
543	}
544
545
546
547	void
548	nfs3_prep_access3args (access3args args, struct nfs3_fh fh)
549	{
550	memset (args, 0, sizeof (*args));
551	args->object.data.data_val = (void *)fh;
552	}
553
554	#define POSIX_READ4 4
555	#define POSIX_WRITE2 2
556	#define POSIX_EXEC1 1
557
558	uint32_t
559	nfs3_accessbits (int32_t accbits)
560	{
561	uint32_t accresult = 0;
562
563	if (accbits & POSIX_READ4)
564	accresult \|= ACCESS3_READ0x0001;
565
566	if (accbits & POSIX_WRITE2)
567	accresult \|= (ACCESS3_MODIFY0x0004 \| ACCESS3_EXTEND0x0008 \| ACCESS3_DELETE0x0010);
568
569	/* lookup on directory allowed only in case of execute permission */
570	if (accbits & POSIX_EXEC1)
571	accresult \|= (ACCESS3_EXECUTE0x0020 \| ACCESS3_LOOKUP0x0002);
572
573	return accresult;
574	}
575
576	uint32_t
577	nfs3_request_to_accessbits (int32_t accbits)
578	{
579	uint32_t acc_request = 0;
580
581	if (accbits & ACCESS3_READ0x0001)
582	acc_request \|= POSIX_READ4;
583
584	if (accbits & (ACCESS3_MODIFY0x0004 \| ACCESS3_EXTEND0x0008 \| ACCESS3_DELETE0x0010))
585	acc_request \|= POSIX_WRITE2;
586
587	/* For lookup on directory check for execute permission */
588	if (accbits & (ACCESS3_EXECUTE0x0020 \| ACCESS3_LOOKUP0x0002))
589	acc_request \|= POSIX_EXEC1;
590
591	return acc_request;
592	}
593	void
594	nfs3_fill_access3res (access3res *res, nfsstat3 status, int32_t accbits,
595	int32_t reqaccbits)
596	{
597	uint32_t accres = 0;
598
599	memset (res, 0, sizeof (*res));
600	res->status = status;
601	if (status != NFS3_OK)
602	return;
603
604	accres = nfs3_accessbits (accbits);
605
606	/* do not answer what was not asked */
607	res->access3res_u.resok.access = accres & reqaccbits;
608	}
609
610	void
611	nfs3_prep_readdir3args (readdir3args ra, struct nfs3_fh fh)
612	{
613	memset (ra, 0, sizeof (*ra));
614	ra->dir.data.data_val = (void *)fh;
615	}
616
617
618	int
619	nfs3_is_dot_entry (char *entry)
620	{
621	int ret = 0;
622
623	if (!entry)
624	return 0;
625
626	if (strcmp (entry, ".") == 0)
627	ret = 1;
628
629	return ret;
630	}
631
632
633	int
634	nfs3_is_parentdir_entry (char *entry)
635	{
636	int ret = 0;
637
638	if (!entry)
639	return 0;
640
641	if (strcmp (entry, "..") == 0)
642	ret = 1;
643
644	return ret;
645	}
646
647
648	void
649	nfs3_funge_root_dotdot_dirent (gf_dirent_t ent, struct nfs3_fh dfh)
650	{
651	if ((!ent) \|\| (!dfh))
652	return;
653
654	if (nfs3_fh_is_root_fh (dfh) &&
655	nfs3_is_parentdir_entry (ent->d_name)) {
656	ent->d_ino = 1;
657	ent->d_stat.ia_ino = 1;
658	}
659
660	if (nfs3_fh_is_root_fh (dfh) &&
661	nfs3_is_dot_entry (ent->d_name)) {
662	ent->d_ino = 1;
663	ent->d_stat.ia_ino = 1;
664	}
665
666	}
667
668
669	entry3 *
670	nfs3_fill_entry3 (gf_dirent_t entry, struct nfs3_fh dfh)
671	{
672	entry3 ent = NULL((void)0);
673	if ((!entry) \|\| (!dfh))
674	return NULL((void*)0);
675
676	ent = GF_CALLOC (1, sizeof (ent), gf_nfs_mt_entry3)__gf_calloc (1, sizeof (ent), gf_nfs_mt_entry3);
677	if (!ent)
678	return NULL((void*)0);
679
680	gf_log (GF_NFS3, GF_LOG_TRACE, "Entry: %s", entry->d_name)do { do { if (0) printf ("Entry: %s", entry->d_name); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 680, GF_LOG_TRACE, "Entry: %s", entry->d_name); } while ( 0);
681
682	/* If the entry is . or .., we need to replace the physical ino and gen
683	* with 1 and 0 respectively if the directory is root. This funging is
684	* needed because there is no parent directory of the root. In that
685	* sense the behavior we provide is similar to the output of the
686	* command: "stat /.."
687	*/
688	entry->d_ino = nfs3_iatt_gfid_to_ino (&entry->d_stat);
689	nfs3_funge_root_dotdot_dirent (entry, dfh);
690	ent->fileid = entry->d_ino;
691	ent->cookie = entry->d_off;
692	ent->name = GF_CALLOC ((strlen (entry->d_name) + 1), sizeof (char),__gf_calloc ((strlen (entry->d_name) + 1), sizeof (char), gf_nfs_mt_char )
693	gf_nfs_mt_char)__gf_calloc ((strlen (entry->d_name) + 1), sizeof (char), gf_nfs_mt_char );
694	if (!ent->name) {
695	GF_FREE (ent)__gf_free (ent);
696	ent = NULL((void*)0);
697	goto err;
698	}
699	strcpy (ent->name, entry->d_name);
700
701	err:
702	return ent;
703	}
704
705
706	void
707	nfs3_fill_post_op_fh3 (struct nfs3_fh fh, post_op_fh3 pfh)
708	{
709	uint32_t fhlen = 0;
710
711	if ((!fh) \|\| (!pfh))
712	return;
713
714	pfh->handle_follows = 1;
715	fhlen = nfs3_fh_compute_size (fh);
716	pfh->post_op_fh3_u.handle.data.data_val = (void *)fh;
717	pfh->post_op_fh3_u.handle.data.data_len = fhlen;
718	}
719
720
721	post_op_fh3
722	nfs3_fh_to_post_op_fh3 (struct nfs3_fh *fh)
723	{
724	post_op_fh3 pfh = {0, };
725	char fhp = NULL((void)0);
726
727	if (!fh)
728	return pfh;
729
730	pfh.handle_follows = 1;
731
732	fhp = GF_CALLOC (1, sizeof (fh), gf_nfs_mt_char)__gf_calloc (1, sizeof (fh), gf_nfs_mt_char);
733	if (!fhp)
734	return pfh;
735
736	memcpy (fhp, fh, sizeof (*fh));
737	nfs3_fill_post_op_fh3 ((struct nfs3_fh *)fhp, &pfh);
738	return pfh;
739	}
740
741
742	entryp3 *
743	nfs3_fill_entryp3 (gf_dirent_t entry, struct nfs3_fh dirfh, uint64_t devid)
744	{
745	entryp3 ent = NULL((void)0);
746	struct nfs3_fh newfh = {{0}, };
747
748	if ((!entry) \|\| (!dirfh))
749	return NULL((void*)0);
750
751	/* If the entry is . or .., we need to replace the physical ino and gen
752	* with 1 and 0 respectively if the directory is root. This funging is
753	* needed because there is no parent directory of the root. In that
754	* sense the behavior we provide is similar to the output of the
755	* command: "stat /.."
756	*/
757	entry->d_ino = nfs3_iatt_gfid_to_ino (&entry->d_stat);
758	nfs3_funge_root_dotdot_dirent (entry, dirfh);
759	gf_log (GF_NFS3, GF_LOG_TRACE, "Entry: %s, ino: %"PRIu64,do { do { if (0) printf ("Entry: %s, ino: %""ll" "u", entry-> d_name, entry->d_ino); } while (0); _gf_log ("nfs""-nfsv3" , "nfs3-helpers.c", __FUNCTION__, 760, GF_LOG_TRACE, "Entry: %s, ino: %" "ll" "u", entry->d_name, entry->d_ino); } while (0)
760	entry->d_name, entry->d_ino)do { do { if (0) printf ("Entry: %s, ino: %""ll" "u", entry-> d_name, entry->d_ino); } while (0); _gf_log ("nfs""-nfsv3" , "nfs3-helpers.c", __FUNCTION__, 760, GF_LOG_TRACE, "Entry: %s, ino: %" "ll" "u", entry->d_name, entry->d_ino); } while (0);
761	ent = GF_CALLOC (1, sizeof (ent), gf_nfs_mt_entryp3)__gf_calloc (1, sizeof (ent), gf_nfs_mt_entryp3);
762	if (!ent)
763	return NULL((void*)0);
764
765	ent->fileid = entry->d_ino;
766	ent->cookie = entry->d_off;
767	ent->name = GF_CALLOC ((strlen (entry->d_name) + 1), sizeof (char),__gf_calloc ((strlen (entry->d_name) + 1), sizeof (char), gf_nfs_mt_char )
768	gf_nfs_mt_char)__gf_calloc ((strlen (entry->d_name) + 1), sizeof (char), gf_nfs_mt_char );
769	if (!ent->name) {
770	GF_FREE (ent)__gf_free (ent);
771	ent = NULL((void*)0);
772	goto err;
773	}
774	strcpy (ent->name, entry->d_name);
775
776	nfs3_fh_build_child_fh (dirfh, &entry->d_stat, &newfh);
777	nfs3_map_deviceid_to_statdev (&entry->d_stat, devid);
778	ent->name_attributes = nfs3_stat_to_post_op_attr (&entry->d_stat);
779	ent->name_handle = nfs3_fh_to_post_op_fh3 (&newfh);
780	err:
781	return ent;
782	}
783
784
785	void
786	nfs3_fill_readdir3res (readdir3res res, nfsstat3 stat, struct nfs3_fh dirfh,
787	uint64_t cverf, struct iatt *dirstat,
788	gf_dirent_t *entries, count3 count, int is_eof,
789	uint64_t deviceid)
790	{
791	post_op_attr dirattr;
792	entry3 ent = NULL((void)0);
793	entry3 headentry = NULL((void)0);
794	entry3 preventry = NULL((void)0);
795	count3 filled = 0;
796	gf_dirent_t listhead = NULL((void)0);
797
798	memset (res, 0, sizeof (*res));
799	res->status = stat;
800	if (stat != NFS3_OK)
801	return;
802
803	nfs3_map_deviceid_to_statdev (dirstat, deviceid);
804	dirattr = nfs3_stat_to_post_op_attr (dirstat);
805	res->readdir3res_u.resok.dir_attributes = dirattr;
806	res->readdir3res_u.resok.reply.eof = (bool_t)is_eof;
807	memcpy (res->readdir3res_u.resok.cookieverf, &cverf, sizeof (cverf));
808
809	filled = NFS3_READDIR_RESOK_SIZE(88 + sizeof (bool_t) + 8);
810	/* First entry is just the list head */
811	listhead = entries;
812	entries = entries->next;
813	while (((entries) && (entries != listhead)) && (filled < count)) {
814	/*
815	if ((strcmp (entries->d_name, ".") == 0) \|\|
816	(strcmp (entries->d_name, "..") == 0))
817	goto nextentry;
818	*/
819	ent = nfs3_fill_entry3 (entries, dirfh);
820	if (!ent)
821	break;
822
823	if (!headentry)
824	headentry = ent;
825
826	if (preventry) {
827	preventry->nextentry = ent;
828	preventry = ent;
829	} else
830	preventry = ent;
831
832	filled += NFS3_ENTRY3_FIXED_SIZE24 + strlen (ent->name);
833	//nextentry:
834	entries = entries->next;
835	}
836
837	res->readdir3res_u.resok.reply.entries = headentry;
838
839	return;
840	}
841
842
843	void
844	nfs3_fill_readdirp3res (readdirp3res *res, nfsstat3 stat,
845	struct nfs3_fh *dirfh, uint64_t cverf,
846	struct iatt dirstat, gf_dirent_t entries,
847	count3 dircount, count3 maxcount, int is_eof,
848	uint64_t deviceid)
849	{
850	post_op_attr dirattr;
851	entryp3 ent = NULL((void)0);
852	entryp3 headentry = NULL((void)0);
853	entryp3 preventry = NULL((void)0);
854	count3 filled = 0;
855	gf_dirent_t listhead = NULL((void)0);
856	int fhlen = 0;
857
858	memset (res, 0, sizeof (*res));
859	res->status = stat;
860	if (stat != NFS3_OK)
861	return;
862
863	nfs3_map_deviceid_to_statdev (dirstat, deviceid);
864	dirattr = nfs3_stat_to_post_op_attr (dirstat);
865	res->readdirp3res_u.resok.dir_attributes = dirattr;
866	res->readdirp3res_u.resok.reply.eof = (bool_t)is_eof;
867	memcpy (res->readdirp3res_u.resok.cookieverf, &cverf, sizeof (cverf));
868
869	filled = NFS3_READDIR_RESOK_SIZE(88 + sizeof (bool_t) + 8);
870	/* First entry is just the list head */
871	listhead = entries;
872	entries = entries->next;
873	while (((entries) && (entries != listhead)) && (filled < maxcount)) {
874	/* Linux does not display . and .. entries unless we provide
875	* these entries here.
876	*/
877	/* if ((strcmp (entries->d_name, ".") == 0) \|\|
878	(strcmp (entries->d_name, "..") == 0))
879	goto nextentry;
880	*/
881	ent = nfs3_fill_entryp3 (entries, dirfh, deviceid);
882	if (!ent)
883	break;
884
885	if (!headentry)
886	headentry = ent;
887
888	if (preventry) {
889	preventry->nextentry = ent;
890	preventry = ent;
891	} else
892	preventry = ent;
893
894	fhlen = ent->name_handle.post_op_fh3_u.handle.data.data_len;
895	filled += NFS3_ENTRYP3_FIXED_SIZE(24 + 88 + (sizeof (bool_t) + sizeof (uint32_t))) + fhlen + strlen (ent->name);
896	//nextentry:
897	entries = entries->next;
898	}
899
900	res->readdirp3res_u.resok.reply.entries = headentry;
901
902	return;
903	}
904
905
906	void
907	nfs3_prep_readdirp3args (readdirp3args ra, struct nfs3_fh fh)
908	{
909	memset (ra, 0, sizeof (*ra));
910	ra->dir.data.data_val = (void *)fh;
911	}
912
913	void
914	nfs3_free_readdirp3res (readdirp3res *res)
915	{
916	entryp3 ent = NULL((void)0);
917	entryp3 next = NULL((void)0);
918
919	if (!res)
920	return;
921
922	ent = res->readdirp3res_u.resok.reply.entries;
923	while (ent) {
924
925	next = ent->nextentry;
926	GF_FREE (ent->name)__gf_free (ent->name);
927	GF_FREE (ent->name_handle.post_op_fh3_u.handle.data.data_val)__gf_free (ent->name_handle.post_op_fh3_u.handle.data.data_val );
928	GF_FREE (ent)__gf_free (ent);
929	ent = next;
930	}
931
932	return;
933	}
934
935
936	void
937	nfs3_free_readdir3res (readdir3res *res)
938	{
939	entry3 ent = NULL((void)0);
940	entry3 next = NULL((void)0);
941
942	if (!res)
943	return;
944
945	ent = res->readdir3res_u.resok.reply.entries;
946	while (ent) {
947
948	next = ent->nextentry;
949	GF_FREE (ent->name)__gf_free (ent->name);
950	GF_FREE (ent)__gf_free (ent);
951	ent = next;
952	}
953
954	return;
955	}
956
957	void
958	nfs3_prep_fsstat3args (fsstat3args args, struct nfs3_fh fh)
959	{
960	memset (args, 0, sizeof (*args));
961	args->fsroot.data.data_val = (char *)fh;
962	}
963
964
965	void
966	nfs3_fill_fsstat3res (fsstat3res res, nfsstat3 stat, struct statvfs fsbuf,
967	struct iatt *postbuf, uint64_t deviceid)
968	{
969	post_op_attr poa;
970	fsstat3resok resok;
971
972	memset (res, 0, sizeof (*res));
973	res->status = stat;
974	if (stat != NFS3_OK)
975	return;
976
977	nfs3_map_deviceid_to_statdev (postbuf, deviceid);
978	poa = nfs3_stat_to_post_op_attr (postbuf);
979	resok.tbytes = (size3)(fsbuf->f_frsize * fsbuf->f_blocks);
980	resok.fbytes = (size3)(fsbuf->f_frsize * fsbuf->f_bfree);
981	resok.abytes = (size3)(fsbuf->f_frsize * fsbuf->f_bavail);
982	resok.tfiles = (size3)(fsbuf->f_files);
983	resok.ffiles = (size3)(fsbuf->f_ffree);
984	resok.afiles = (size3)(fsbuf->f_favail);
985	resok.invarsec = 0;
986
987	resok.obj_attributes = poa;
988	res->fsstat3res_u.resok = resok;
989	}
990
991
992	int32_t
993	nfs3_sattr3_to_setattr_valid (sattr3 sattr, struct iatt buf, mode_t *omode)
994	{
995	int32_t valid = 0;
996	ia_prot_t prot = {0, };
997	mode_t mode = 0;
998
999	if (!sattr)
1000	return 0;
1001
1002	if (sattr->mode.set_it) {
1003	valid \|= GF_SET_ATTR_MODE0x1;
1004
1005	if (sattr->mode.set_mode3_u.mode & NFS3MODE_ROWNER0x00100) {
1006	mode \|= S_IRUSR0400;
1007	prot.owner.read = 1;
1008	}
1009	if (sattr->mode.set_mode3_u.mode & NFS3MODE_WOWNER0x00080) {
1010	mode \|= S_IWUSR0200;
1011	prot.owner.write = 1;
1012	}
1013	if (sattr->mode.set_mode3_u.mode & NFS3MODE_XOWNER0x00040) {
1014	mode \|= S_IXUSR0100;
1015	prot.owner.exec = 1;
1016	}
1017
1018	if (sattr->mode.set_mode3_u.mode & NFS3MODE_RGROUP0x00020) {
1019	mode \|= S_IRGRP(0400 >> 3);
1020	prot.group.read = 1;
1021	}
1022	if (sattr->mode.set_mode3_u.mode & NFS3MODE_WGROUP0x00010) {
1023	mode \|= S_IWGRP(0200 >> 3);
1024	prot.group.write = 1;
1025	}
1026	if (sattr->mode.set_mode3_u.mode & NFS3MODE_XGROUP0x00008) {
1027	mode \|= S_IXGRP(0100 >> 3);
1028	prot.group.exec = 1;
1029	}
1030
1031	if (sattr->mode.set_mode3_u.mode & NFS3MODE_ROTHER0x00004) {
1032	mode \|= S_IROTH((0400 >> 3) >> 3);
1033	prot.other.read = 1;
1034	}
1035	if (sattr->mode.set_mode3_u.mode & NFS3MODE_WOTHER0x00002) {
1036	mode \|= S_IWOTH((0200 >> 3) >> 3);
1037	prot.other.write = 1;
1038	}
1039	if (sattr->mode.set_mode3_u.mode & NFS3MODE_XOTHER0x00001) {
1040	mode \|= S_IXOTH((0100 >> 3) >> 3);
1041	prot.other.exec = 1;
1042	}
1043
1044	if (sattr->mode.set_mode3_u.mode & NFS3MODE_SETXUID0x00800) {
1045	mode \|= S_ISUID04000;
1046	prot.suid = 1;
1047	}
1048	if (sattr->mode.set_mode3_u.mode & NFS3MODE_SETXGID0x00400) {
1049	mode \|= S_ISGID02000;
1050	prot.sgid = 1;
1051	}
1052	if (sattr->mode.set_mode3_u.mode & NFS3MODE_SAVESWAPTXT0x00200) {
1053	mode \|= S_ISVTX01000;
1054	prot.sticky = 1;
1055	}
1056
1057	if (buf)
1058	buf->ia_prot = prot;
1059	/* Create fop still requires the old mode_t style argument. */
1060	if (omode)
1061	*omode = mode;
1062	}
1063
1064	if (sattr->uid.set_it) {
1065	valid \|= GF_SET_ATTR_UID0x2;
1066	if (buf)
1067	buf->ia_uid = sattr->uid.set_uid3_u.uid;
1068	}
1069
1070	if (sattr->gid.set_it) {
1071	valid \|= GF_SET_ATTR_GID0x4;
1072	if (buf)
1073	buf->ia_gid = sattr->gid.set_gid3_u.gid;
1074	}
1075
1076	if (sattr->size.set_it) {
1077	valid \|= GF_SET_ATTR_SIZE0x8;
1078	if (buf)
1079	buf->ia_size = sattr->size.set_size3_u.size;
1080	}
1081
1082	if (sattr->atime.set_it == SET_TO_CLIENT_TIME) {
1083	valid \|= GF_SET_ATTR_ATIME0x10;
1084	if (buf)
1085	buf->ia_atime = sattr->atime.set_atime_u.atime.seconds;
1086	}
1087
1088	if (sattr->atime.set_it == SET_TO_SERVER_TIME) {
1089	valid \|= GF_SET_ATTR_ATIME0x10;
1090	if (buf)
1091	buf->ia_atime = time (NULL((void*)0));
1092	}
1093
1094	if (sattr->mtime.set_it == SET_TO_CLIENT_TIME) {
1095	valid \|= GF_SET_ATTR_MTIME0x20;
1096	if (buf)
1097	buf->ia_mtime = sattr->mtime.set_mtime_u.mtime.seconds;
1098	}
1099
1100	if (sattr->mtime.set_it == SET_TO_SERVER_TIME) {
1101	valid \|= GF_SET_ATTR_MTIME0x20;
1102	if (buf)
1103	buf->ia_mtime = time (NULL((void*)0));
1104	}
1105
1106	return valid;
1107	}
1108
1109
1110	wcc_data
1111	nfs3_stat_to_wcc_data (struct iatt pre, struct iatt post)
1112	{
1113	wcc_data wd = {{0}, };
1114
1115	if (post)
1116	wd.after = nfs3_stat_to_post_op_attr (post);
1117	if (pre)
1118	wd.before = nfs3_stat_to_pre_op_attr (pre);
1119
1120	return wd;
1121	}
1122
1123	void
1124	nfs3_fill_create3res (create3res res, nfsstat3 stat, struct nfs3_fh newfh,
1125	struct iatt newbuf, struct iatt preparent,
1126	struct iatt *postparent, uint64_t deviceid)
1127	{
1128	post_op_attr poa = {0, };
	Value stored to 'poa' during its initialization is never read
1129	wcc_data dirwcc = {{0}, };
1130
1131	memset (res, 0, sizeof (*res));
1132	res->status = stat;
1133	if (stat != NFS3_OK)
1134	return;
1135
1136	nfs3_fill_post_op_fh3 (newfh, &res->create3res_u.resok.obj);
1137	nfs3_map_deviceid_to_statdev (newbuf, deviceid);
1138	poa = nfs3_stat_to_post_op_attr (newbuf);
1139	res->create3res_u.resok.obj_attributes = poa;
1140	nfs3_map_deviceid_to_statdev (preparent, deviceid);
1141	nfs3_map_deviceid_to_statdev (postparent, deviceid);
1142	dirwcc = nfs3_stat_to_wcc_data (preparent, postparent);
1143
1144	res->create3res_u.resok.dir_wcc = dirwcc;
1145	}
1146
1147	void
1148	nfs3_prep_create3args (create3args args, struct nfs3_fh fh, char *name)
1149	{
1150
1151	memset (args, 0, sizeof (*args));
1152	args->where.dir.data.data_val = (void *)fh;
1153	args->where.name = name;
1154	}
1155
1156	void
1157	nfs3_prep_setattr3args (setattr3args args, struct nfs3_fh fh)
1158	{
1159	memset (args, 0, sizeof (*args));
1160	args->object.data.data_val = (void *)fh;
1161	}
1162
1163
1164	void
1165	nfs3_fill_setattr3res (setattr3res res, nfsstat3 stat, struct iatt preop,
1166	struct iatt *postop, uint64_t deviceid)
1167	{
1168	wcc_data wcc;
1169	memset (res, 0, sizeof (*res));
1170	res->status = stat;
1171	if (stat != NFS3_OK)
1172	return;
1173
1174	nfs3_map_deviceid_to_statdev (preop, deviceid);
1175	nfs3_map_deviceid_to_statdev (postop, deviceid);
1176	wcc = nfs3_stat_to_wcc_data (preop, postop);
1177	res->setattr3res_u.resok.obj_wcc = wcc;
1178	}
1179
1180
1181	void
1182	nfs3_prep_mkdir3args (mkdir3args args, struct nfs3_fh dirfh, char *name)
1183	{
1184
1185	memset (args, 0, sizeof (*args));
1186	args->where.dir.data.data_val = (void *)dirfh;
1187	args->where.name = name;
1188	}
1189
1190
1191	void
1192	nfs3_fill_mkdir3res (mkdir3res res, nfsstat3 stat, struct nfs3_fh fh,
1193	struct iatt buf, struct iatt preparent,
1194	struct iatt *postparent, uint64_t deviceid)
1195	{
1196	wcc_data dirwcc;
1197	post_op_attr poa;
1198
1199	memset (res, 0, sizeof (*res));
1200	res->status = stat;
1201	if (stat != NFS3_OK)
1202	return;
1203
1204	nfs3_fill_post_op_fh3 (fh, &res->mkdir3res_u.resok.obj);
1205	nfs3_map_deviceid_to_statdev (buf, deviceid);
1206	poa = nfs3_stat_to_post_op_attr (buf);
1207	nfs3_map_deviceid_to_statdev (preparent, deviceid);
1208	nfs3_map_deviceid_to_statdev (postparent, deviceid);
1209	dirwcc = nfs3_stat_to_wcc_data (preparent, postparent);
1210	res->mkdir3res_u.resok.obj_attributes = poa;
1211	res->mkdir3res_u.resok.dir_wcc = dirwcc;
1212
1213	}
1214
1215
1216	void
1217	nfs3_prep_symlink3args (symlink3args args, struct nfs3_fh dirfh, char *name,
1218	char *target)
1219	{
1220	memset (args, 0, sizeof (*args));
1221	args->where.dir.data.data_val = (void *)dirfh;
1222	args->where.name = name;
1223	args->symlink.symlink_data = target;
1224	}
1225
1226
1227	void
1228	nfs3_fill_symlink3res (symlink3res res, nfsstat3 stat, struct nfs3_fh fh,
1229	struct iatt buf, struct iatt preparent,
1230	struct iatt *postparent, uint64_t deviceid)
1231	{
1232	wcc_data dirwcc;
1233	post_op_attr poa;
1234
1235	memset (res, 0, sizeof (*res));
1236	res->status = stat;
1237	if (stat != NFS3_OK)
1238	return;
1239
1240	nfs3_fill_post_op_fh3 (fh, &res->symlink3res_u.resok.obj);
1241	nfs3_map_deviceid_to_statdev (buf, deviceid);
1242	poa = nfs3_stat_to_post_op_attr (buf);
1243	nfs3_map_deviceid_to_statdev (postparent, deviceid);
1244	nfs3_map_deviceid_to_statdev (preparent, deviceid);
1245	dirwcc = nfs3_stat_to_wcc_data (preparent, postparent);
1246	res->symlink3res_u.resok.obj_attributes = poa;
1247	res->symlink3res_u.resok.dir_wcc = dirwcc;
1248
1249	}
1250
1251
1252	void
1253	nfs3_prep_readlink3args (readlink3args args, struct nfs3_fh fh)
1254	{
1255
1256	memset (args, 0, sizeof (*args));
1257	args->symlink.data.data_val = (void *)fh;
1258	}
1259
1260
1261	void
1262	nfs3_fill_readlink3res (readlink3res res, nfsstat3 stat, char path,
1263	struct iatt *buf, uint64_t deviceid)
1264	{
1265	post_op_attr poa;
1266
1267	memset (res, 0, sizeof (*res));
1268	res->status = stat;
1269
1270	if (stat != NFS3_OK)
1271	return;
1272
1273	nfs3_map_deviceid_to_statdev (buf, deviceid);
1274	poa = nfs3_stat_to_post_op_attr (buf);
1275	res->readlink3res_u.resok.data = (void *)path;
1276	res->readlink3res_u.resok.symlink_attributes = poa;
1277	}
1278
1279
1280	void
1281	nfs3_prep_mknod3args (mknod3args args, struct nfs3_fh fh, char *name)
1282	{
1283	memset (args, 0, sizeof (*args));
1284	args->where.dir.data.data_val = (void *)fh;
1285	args->where.name = name;
1286
1287	}
1288
1289	void
1290	nfs3_fill_mknod3res (mknod3res res, nfsstat3 stat, struct nfs3_fh fh,
1291	struct iatt buf, struct iatt preparent,
1292	struct iatt *postparent, uint64_t deviceid)
1293	{
1294	post_op_attr poa;
1295	wcc_data wccdir;
1296
1297	memset (res, 0, sizeof (*res));
1298	res->status = stat;
1299	if (stat != NFS3_OK)
1300	return;
1301
1302	nfs3_fill_post_op_fh3 (fh, &res->mknod3res_u.resok.obj);
1303	nfs3_map_deviceid_to_statdev (buf, deviceid);
1304	poa = nfs3_stat_to_post_op_attr (buf);
1305	nfs3_map_deviceid_to_statdev (preparent, deviceid);
1306	nfs3_map_deviceid_to_statdev (postparent, deviceid);
1307	wccdir = nfs3_stat_to_wcc_data (preparent, postparent);
1308	res->mknod3res_u.resok.obj_attributes = poa;
1309	res->mknod3res_u.resok.dir_wcc = wccdir;
1310
1311	}
1312
1313
1314	void
1315	nfs3_fill_remove3res (remove3res res, nfsstat3 stat, struct iatt preparent,
1316	struct iatt *postparent, uint64_t deviceid)
1317	{
1318	wcc_data dirwcc;
1319
1320	memset (res, 0, sizeof (*res));
1321	res->status = stat;
1322	if (stat != NFS3_OK)
1323	return;
1324
1325	nfs3_map_deviceid_to_statdev (preparent, deviceid);
1326	nfs3_map_deviceid_to_statdev (postparent, deviceid);
1327	dirwcc = nfs3_stat_to_wcc_data (preparent, postparent);
1328	res->remove3res_u.resok.dir_wcc = dirwcc;
1329	}
1330
1331
1332	void
1333	nfs3_prep_remove3args (remove3args args, struct nfs3_fh fh, char *name)
1334	{
1335	memset (args, 0, sizeof (*args));
1336	args->object.dir.data.data_val = (void *)fh;
1337	args->object.name = name;
1338	}
1339
1340
1341	void
1342	nfs3_prep_rmdir3args (rmdir3args args, struct nfs3_fh fh, char *name)
1343	{
1344	memset (args, 0, sizeof (*args));
1345	args->object.dir.data.data_val = (void *)fh;
1346	args->object.name = name;
1347	}
1348
1349
1350	void
1351	nfs3_fill_rmdir3res (rmdir3res res, nfsstat3 stat, struct iatt preparent,
1352	struct iatt *postparent, uint64_t deviceid)
1353	{
1354	wcc_data dirwcc;
1355	memset (res, 0, sizeof (*res));
1356	res->status = stat;
1357
1358	if (stat != NFS3_OK)
1359	return;
1360
1361	nfs3_map_deviceid_to_statdev (postparent, deviceid);
1362	nfs3_map_deviceid_to_statdev (preparent, deviceid);
1363	dirwcc = nfs3_stat_to_wcc_data (preparent, postparent);
1364	res->rmdir3res_u.resok.dir_wcc = dirwcc;
1365	}
1366
1367
1368	void
1369	nfs3_prep_link3args (link3args args, struct nfs3_fh target,
1370	struct nfs3_fh * dirfh, char *name)
1371	{
1372	memset (args, 0, sizeof (*args));
1373	args->file.data.data_val = (void *)target;
1374	args->link.dir.data.data_val = (void *)dirfh;
1375	args->link.name = name;
1376	}
1377
1378
1379	void
1380	nfs3_fill_link3res (link3res res, nfsstat3 stat, struct iatt buf,
1381	struct iatt preparent, struct iatt postparent,
1382	uint64_t deviceid)
1383	{
1384	post_op_attr poa;
1385	wcc_data dirwcc;
1386
1387	memset (res, 0, sizeof (*res));
1388	res->status = stat;
1389	if (stat != NFS3_OK)
1390	return;
1391
1392	nfs3_map_deviceid_to_statdev (preparent, deviceid);
1393	nfs3_map_deviceid_to_statdev (postparent, deviceid);
1394	nfs3_map_deviceid_to_statdev (buf,deviceid);
1395	poa = nfs3_stat_to_post_op_attr (buf);
1396	dirwcc = nfs3_stat_to_wcc_data (preparent, postparent);
1397	res->link3res_u.resok.file_attributes = poa;
1398	res->link3res_u.resok.linkdir_wcc = dirwcc;
1399	}
1400
1401
1402
1403	void
1404	nfs3_prep_rename3args (rename3args args, struct nfs3_fh olddirfh,
1405	char oldname, struct nfs3_fh newdirfh, char *newname)
1406	{
1407	memset (args, 0, sizeof (*args));
1408
1409	args->from.name = oldname;
1410	args->from.dir.data.data_val = (void *)olddirfh;
1411	args->to.name = newname;
1412	args->to.dir.data.data_val = (void *)newdirfh;
1413
1414	}
1415
1416
1417	void
1418	nfs3_fill_rename3res (rename3res res, nfsstat3 stat, struct iatt buf,
1419	struct iatt preoldparent, struct iatt postoldparent,
1420	struct iatt prenewparent, struct iatt postnewparent,
1421	uint64_t deviceid)
1422
1423	{
1424	wcc_data dirwcc;
1425
1426	memset (res, 0, sizeof (*res));
1427	res->status = stat;
1428	if (stat != NFS3_OK)
1429	return;
1430
1431	nfs3_map_deviceid_to_statdev (preoldparent, deviceid);
1432	nfs3_map_deviceid_to_statdev (postoldparent, deviceid);
1433	nfs3_map_deviceid_to_statdev (prenewparent, deviceid);
1434	nfs3_map_deviceid_to_statdev (postnewparent, deviceid);
1435	nfs3_map_deviceid_to_statdev (buf, deviceid);
1436	dirwcc = nfs3_stat_to_wcc_data (preoldparent, postoldparent);
1437	res->rename3res_u.resok.fromdir_wcc = dirwcc;
1438	dirwcc = nfs3_stat_to_wcc_data (prenewparent, postnewparent);
1439	res->rename3res_u.resok.todir_wcc = dirwcc;
1440	}
1441
1442
1443	void
1444	nfs3_prep_write3args (write3args args, struct nfs3_fh fh)
1445	{
1446	memset (args, 0, sizeof (*args));
1447	args->file.data.data_val = (void *)fh;
1448	}
1449
1450
1451	void
1452	nfs3_fill_write3res (write3res *res, nfsstat3 stat, count3 count,
1453	stable_how stable, uint64_t wverf, struct iatt *prestat,
1454	struct iatt *poststat, uint64_t deviceid)
1455	{
1456	write3resok resok;
1457	memset (res, 0, sizeof (*res));
1458	res->status = stat;
1459	if (stat != NFS3_OK)
1460	return;
1461
1462	nfs3_map_deviceid_to_statdev (prestat, deviceid);
1463	nfs3_map_deviceid_to_statdev (poststat, deviceid);
1464	resok.file_wcc = nfs3_stat_to_wcc_data (prestat, poststat);
1465	resok.count = count;
1466	resok.committed = stable;
1467	memcpy (resok.verf, &wverf, sizeof (wverf));
1468
1469	res->write3res_u.resok = resok;
1470	}
1471
1472
1473	void
1474	nfs3_prep_commit3args (commit3args args, struct nfs3_fh fh)
1475	{
1476	memset (args, 0, sizeof (*args));
1477	args->file.data.data_val = (void *)fh;
1478	}
1479
1480
1481	void
1482	nfs3_fill_commit3res (commit3res *res, nfsstat3 stat, uint64_t wverf,
1483	struct iatt prestat, struct iatt poststat,
1484	uint64_t deviceid)
1485	{
1486	memset (res, 0, sizeof (*res));
1487	res->status = stat;
1488	if (stat != NFS3_OK)
1489	return;
1490
1491	nfs3_map_deviceid_to_statdev (poststat, deviceid);
1492	nfs3_map_deviceid_to_statdev (prestat, deviceid);
1493	res->commit3res_u.resok.file_wcc = nfs3_stat_to_wcc_data (prestat,
1494	poststat);
1495	memcpy (res->commit3res_u.resok.verf, &wverf, sizeof (wverf));
1496	}
1497
1498	void
1499	nfs3_fill_read3res (read3res *res, nfsstat3 stat, count3 count,
1500	struct iatt *poststat, int is_eof, uint64_t deviceid)
1501	{
1502	post_op_attr poa;
1503
1504	memset (res, 0, sizeof (*res));
1505	res->status = stat;
1506	if (stat != NFS3_OK)
1507	return;
1508
1509	nfs3_map_deviceid_to_statdev (poststat, deviceid);
1510	poa = nfs3_stat_to_post_op_attr (poststat);
1511	res->read3res_u.resok.file_attributes = poa;
1512	res->read3res_u.resok.count = count;
1513	res->read3res_u.resok.eof = is_eof;
1514	res->read3res_u.resok.data.data_len = count;
1515	}
1516
1517
1518	void
1519	nfs3_prep_read3args (read3args args, struct nfs3_fh fh)
1520	{
1521	memset (args, 0, sizeof (*args));
1522	args->file.data.data_val = (void *)fh;
1523	}
1524
1525
1526	void
1527	nfs3_fill_pathconf3res (pathconf3res res, nfsstat3 stat, struct iatt buf,
1528	uint64_t deviceid)
1529	{
1530	pathconf3resok resok;
1531
1532	memset (res, 0, sizeof (*res));
1533	res->status = stat;
1534	if (stat != NFS3_OK)
1535	return;
1536
1537	nfs3_map_deviceid_to_statdev (buf, deviceid);
1538	resok.obj_attributes = nfs3_stat_to_post_op_attr (buf);
1539	resok.linkmax = 256;
1540	resok.name_max = NFS_NAME_MAX255;
1541	resok.no_trunc = TRUE(1);
1542	resok.chown_restricted = FALSE(0);
1543	resok.case_insensitive = FALSE(0);
1544	resok.case_preserving = TRUE(1);
1545
1546	res->pathconf3res_u.resok = resok;
1547	}
1548
1549
1550	void
1551	nfs3_prep_pathconf3args (pathconf3args args, struct nfs3_fh fh)
1552	{
1553	memset (args, 0, sizeof (*args));
1554	args->object.data.data_val = (void *)fh;
1555	}
1556
1557
1558	int
1559	nfs3_verify_dircookie (struct nfs3_state nfs3, fd_t dirfd, cookie3 cookie,
1560	uint64_t cverf, nfsstat3 *stat)
1561	{
1562	int ret = -1;
1563
1564	if ((!nfs3) \|\| (!dirfd))
1565	return -1;
1566
1567	/* Can assume that this is first read on the dir, so cookie check
1568	* is successful by default.
1569	*/
1570	if (cookie == 0)
1571	return 0;
1572
1573	gf_log (GF_NFS3, GF_LOG_TRACE, "Verifying cookie: cverf: %"PRIu64do { do { if (0) printf ("Verifying cookie: cverf: %""ll" "u" ", cookie: %""ll" "u", cverf, cookie); } while (0); _gf_log ( "nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1574, GF_LOG_TRACE , "Verifying cookie: cverf: %""ll" "u" ", cookie: %""ll" "u", cverf, cookie); } while (0)
1574	", cookie: %"PRIu64, cverf, cookie)do { do { if (0) printf ("Verifying cookie: cverf: %""ll" "u" ", cookie: %""ll" "u", cverf, cookie); } while (0); _gf_log ( "nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1574, GF_LOG_TRACE , "Verifying cookie: cverf: %""ll" "u" ", cookie: %""ll" "u", cverf, cookie); } while (0);
1575	/* The cookie bad, no way cverf will be zero with a non-zero cookie. */
1576	if ((cverf == 0) && (cookie != 0)) {
1577	gf_log (GF_NFS3, GF_LOG_TRACE, "Bad cookie requested")do { do { if (0) printf ("Bad cookie requested"); } while (0) ; _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1577 , GF_LOG_TRACE, "Bad cookie requested"); } while (0);
1578	if (stat)
1579	*stat = NFS3ERR_BAD_COOKIE;
1580	goto err;
1581	}
1582
1583	/* Yes, its true, our cookie is simply the fd_t address.
1584	* NOTE: We used have the check for cookieverf but VMWare client sends
1585	* a readdirp requests even after we've told it that EOF has been
1586	* reached on the directory. This causes a problem because we close a
1587	* dir fd_t after reaching EOF. The next readdirp sent by VMWare
1588	* contains the address of the closed fd_t as cookieverf. Since we
1589	* closed that fd_t, this readdirp results in a new opendir which will
1590	* give an fd_t that will fail this check below.
1591	*/
1592	/* if ((cverf != (uint64_t)dirfd)) {
1593	gf_log (GF_NFS3, GF_LOG_TRACE, "Cookieverf does not match");
1594	if (stat)
1595	*stat = NFS3ERR_BAD_COOKIE;
1596	goto err;
1597	}
1598	*/
1599	gf_log (GF_NFS3, GF_LOG_TRACE, "Cookie verified")do { do { if (0) printf ("Cookie verified"); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1599, GF_LOG_TRACE , "Cookie verified"); } while (0);
1600	if (stat)
1601	*stat = NFS3_OK;
1602	ret = 0;
1603	err:
1604	return ret;
1605	}
1606
1607
1608	void
1609	nfs3_stat_to_errstr (uint32_t xid, char *op, nfsstat3 stat, int pstat,
1610	char *errstr)
1611	{
1612	if ((!op) \|\| (!errstr))
1613	return;
1614
1615	sprintf (errstr, "XID: %x, %s: NFS: %d(%s), POSIX: %d(%s)", xid, op,
1616	stat, nfsstat3_strerror (stat), pstat, strerror (pstat));
1617	}
1618
1619	void
1620	nfs3_log_common_call (uint32_t xid, char op, struct nfs3_fh fh)
1621	{
1622	char fhstr[1024];
1623
1624	if (THIS(*__glusterfs_this_location())->ctx->log.loglevel < GF_LOG_DEBUG)
1625	return;
1626
1627	nfs3_fh_to_str (fh, fhstr);
1628	gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, %s: args: %s", xid, op,do { do { if (0) printf ("XID: %x, %s: args: %s", xid, op, fhstr ); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__ , 1629, GF_LOG_DEBUG, "XID: %x, %s: args: %s", xid, op, fhstr ); } while (0)
1629	fhstr)do { do { if (0) printf ("XID: %x, %s: args: %s", xid, op, fhstr ); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__ , 1629, GF_LOG_DEBUG, "XID: %x, %s: args: %s", xid, op, fhstr ); } while (0);
1630	}
1631
1632
1633	void
1634	nfs3_log_fh_entry_call (uint32_t xid, char op, struct nfs3_fh fh,
1635	char *name)
1636	{
1637	char fhstr[1024];
1638
1639	if (THIS(*__glusterfs_this_location())->ctx->log.loglevel < GF_LOG_DEBUG)
1640	return;
1641	nfs3_fh_to_str (fh, fhstr);
1642	gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, %s: args: %s, name: %s", xid,do { do { if (0) printf ("XID: %x, %s: args: %s, name: %s", xid , op, fhstr, name); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 1643, GF_LOG_DEBUG, "XID: %x, %s: args: %s, name: %s" , xid, op, fhstr, name); } while (0)
1643	op, fhstr, name)do { do { if (0) printf ("XID: %x, %s: args: %s, name: %s", xid , op, fhstr, name); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 1643, GF_LOG_DEBUG, "XID: %x, %s: args: %s, name: %s" , xid, op, fhstr, name); } while (0);
1644	}
1645
1646
1647	void
1648	nfs3_log_rename_call (uint32_t xid, struct nfs3_fh src, char sname,
1649	struct nfs3_fh dst, char dname)
1650	{
1651	char sfhstr[1024];
1652	char dfhstr[1024];
1653
1654	if (THIS(*__glusterfs_this_location())->ctx->log.loglevel < GF_LOG_DEBUG)
1655	return;
1656	nfs3_fh_to_str (src, sfhstr);
1657	nfs3_fh_to_str (dst, dfhstr);
1658	gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, RENAME: args: Src: %s, "do { do { if (0) printf ("XID: %x, RENAME: args: Src: %s, " "name: %s, Dst: %s, name: %s" , xid, sfhstr, sname, dfhstr, dname); } while (0); _gf_log ("nfs" "-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1660, GF_LOG_DEBUG, "XID: %x, RENAME: args: Src: %s, " "name: %s, Dst: %s, name: %s" , xid, sfhstr, sname, dfhstr, dname); } while (0)
1659	"name: %s, Dst: %s, name: %s", xid, sfhstr, sname, dfhstr,do { do { if (0) printf ("XID: %x, RENAME: args: Src: %s, " "name: %s, Dst: %s, name: %s" , xid, sfhstr, sname, dfhstr, dname); } while (0); _gf_log ("nfs" "-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1660, GF_LOG_DEBUG, "XID: %x, RENAME: args: Src: %s, " "name: %s, Dst: %s, name: %s" , xid, sfhstr, sname, dfhstr, dname); } while (0)
1660	dname)do { do { if (0) printf ("XID: %x, RENAME: args: Src: %s, " "name: %s, Dst: %s, name: %s" , xid, sfhstr, sname, dfhstr, dname); } while (0); _gf_log ("nfs" "-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1660, GF_LOG_DEBUG, "XID: %x, RENAME: args: Src: %s, " "name: %s, Dst: %s, name: %s" , xid, sfhstr, sname, dfhstr, dname); } while (0);
1661	}
1662
1663
1664
1665	void
1666	nfs3_log_create_call (uint32_t xid, struct nfs3_fh fh, char name,
1667	createmode3 mode)
1668	{
1669	char fhstr[1024];
1670	char modestr = NULL((void)0);
1671	char exclmode[] = "EXCLUSIVE";
1672	char unchkd[] = "UNCHECKED";
1673	char guarded[] = "GUARDED";
1674
1675	if (THIS(*__glusterfs_this_location())->ctx->log.loglevel < GF_LOG_DEBUG)
1676	return;
1677	nfs3_fh_to_str (fh, fhstr);
1678	if (mode == EXCLUSIVE)
1679	modestr = exclmode;
1680	else if (mode == GUARDED)
1681	modestr = guarded;
1682	else
1683	modestr = unchkd;
1684
1685	gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, CREATE: args: %s, name: %s,"do { do { if (0) printf ("XID: %x, CREATE: args: %s, name: %s," " mode: %s", xid, fhstr, name, modestr); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1686, GF_LOG_DEBUG , "XID: %x, CREATE: args: %s, name: %s," " mode: %s", xid, fhstr , name, modestr); } while (0)
1686	" mode: %s", xid, fhstr, name, modestr)do { do { if (0) printf ("XID: %x, CREATE: args: %s, name: %s," " mode: %s", xid, fhstr, name, modestr); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1686, GF_LOG_DEBUG , "XID: %x, CREATE: args: %s, name: %s," " mode: %s", xid, fhstr , name, modestr); } while (0);
1687	}
1688
1689
1690	void
1691	nfs3_log_mknod_call (uint32_t xid, struct nfs3_fh fh, char name, int type)
1692	{
1693	char fhstr[1024];
1694	char modestr = NULL((void)0);
1695	char chr[] = "CHAR";
1696	char blk[] = "BLK";
1697	char sock[] = "SOCK";
1698	char fifo[] = "FIFO";
1699
1700	if (THIS(*__glusterfs_this_location())->ctx->log.loglevel < GF_LOG_DEBUG)
1701	return;
1702	nfs3_fh_to_str (fh, fhstr);
1703	if (type == NF3CHR)
1704	modestr = chr;
1705	else if (type == NF3BLK)
1706	modestr = blk;
1707	else if (type == NF3SOCK)
1708	modestr = sock;
1709	else
1710	modestr = fifo;
1711
1712	gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, MKNOD: args: %s, name: %s,"do { do { if (0) printf ("XID: %x, MKNOD: args: %s, name: %s," " type: %s", xid, fhstr, name, modestr); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1713, GF_LOG_DEBUG , "XID: %x, MKNOD: args: %s, name: %s," " type: %s", xid, fhstr , name, modestr); } while (0)
1713	" type: %s", xid, fhstr, name, modestr)do { do { if (0) printf ("XID: %x, MKNOD: args: %s, name: %s," " type: %s", xid, fhstr, name, modestr); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1713, GF_LOG_DEBUG , "XID: %x, MKNOD: args: %s, name: %s," " type: %s", xid, fhstr , name, modestr); } while (0);
1714	}
1715
1716
1717
1718	void
1719	nfs3_log_symlink_call (uint32_t xid, struct nfs3_fh fh, char name, char *tgt)
1720	{
1721	char fhstr[1024];
1722
1723	if (THIS(*__glusterfs_this_location())->ctx->log.loglevel < GF_LOG_DEBUG)
1724	return;
1725	nfs3_fh_to_str (fh, fhstr);
1726	gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, SYMLINK: args: %s, name: %s,"do { do { if (0) printf ("XID: %x, SYMLINK: args: %s, name: %s," " target: %s", xid, fhstr, name, tgt); } while (0); _gf_log ( "nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1727, GF_LOG_DEBUG , "XID: %x, SYMLINK: args: %s, name: %s," " target: %s", xid, fhstr, name, tgt); } while (0)
1727	" target: %s", xid, fhstr, name, tgt)do { do { if (0) printf ("XID: %x, SYMLINK: args: %s, name: %s," " target: %s", xid, fhstr, name, tgt); } while (0); _gf_log ( "nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1727, GF_LOG_DEBUG , "XID: %x, SYMLINK: args: %s, name: %s," " target: %s", xid, fhstr, name, tgt); } while (0);
1728	}
1729
1730
1731	void
1732	nfs3_log_link_call (uint32_t xid, struct nfs3_fh fh, char name,
1733	struct nfs3_fh *tgt)
1734	{
1735	char dfhstr[1024];
1736	char tfhstr[1024];
1737
1738	if (THIS(*__glusterfs_this_location())->ctx->log.loglevel < GF_LOG_DEBUG)
1739	return;
1740	nfs3_fh_to_str (fh, dfhstr);
1741	nfs3_fh_to_str (tgt, tfhstr);
1742	gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, LINK: args: %s, name: %s,"do { do { if (0) printf ("XID: %x, LINK: args: %s, name: %s," " target: %s", xid, dfhstr, name, tfhstr); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1743, GF_LOG_DEBUG , "XID: %x, LINK: args: %s, name: %s," " target: %s", xid, dfhstr , name, tfhstr); } while (0)
1743	" target: %s", xid, dfhstr, name, tfhstr)do { do { if (0) printf ("XID: %x, LINK: args: %s, name: %s," " target: %s", xid, dfhstr, name, tfhstr); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1743, GF_LOG_DEBUG , "XID: %x, LINK: args: %s, name: %s," " target: %s", xid, dfhstr , name, tfhstr); } while (0);
1744	}
1745
1746
1747	void
1748	nfs3_log_rw_call (uint32_t xid, char op, struct nfs3_fh fh, offset3 offt,
1749	count3 count, int stablewrite)
1750	{
1751	char fhstr[1024];
1752
1753	if (THIS(*__glusterfs_this_location())->ctx->log.loglevel < GF_LOG_DEBUG)
1754	return;
1755	nfs3_fh_to_str (fh, fhstr);
1756	if (stablewrite == -1)
1757	gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, %s: args: %s, offset:"do { do { if (0) printf ("XID: %x, %s: args: %s, offset:" " %" "ll" "u"", count: %""u", xid, op, fhstr, offt, count); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1759, GF_LOG_DEBUG, "XID: %x, %s: args: %s, offset:" " %""ll" "u"", count: %""u", xid, op, fhstr, offt, count); } while ( 0)
1758	" %"PRIu64", count: %"PRIu32, xid, op, fhstr, offt,do { do { if (0) printf ("XID: %x, %s: args: %s, offset:" " %" "ll" "u"", count: %""u", xid, op, fhstr, offt, count); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1759, GF_LOG_DEBUG, "XID: %x, %s: args: %s, offset:" " %""ll" "u"", count: %""u", xid, op, fhstr, offt, count); } while ( 0)
1759	count)do { do { if (0) printf ("XID: %x, %s: args: %s, offset:" " %" "ll" "u"", count: %""u", xid, op, fhstr, offt, count); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1759, GF_LOG_DEBUG, "XID: %x, %s: args: %s, offset:" " %""ll" "u"", count: %""u", xid, op, fhstr, offt, count); } while ( 0);
1760	else
1761	gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, %s: args: %s, offset:"do { do { if (0) printf ("XID: %x, %s: args: %s, offset:" " %" "ll" "u"", count: %""u"", %s", xid, op, fhstr, offt, count, ( stablewrite == UNSTABLE)?"UNSTABLE":"STABLE"); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1764, GF_LOG_DEBUG , "XID: %x, %s: args: %s, offset:" " %""ll" "u"", count: %""u" ", %s", xid, op, fhstr, offt, count, (stablewrite == UNSTABLE )?"UNSTABLE":"STABLE"); } while (0)
1762	" %"PRIu64", count: %"PRIu32", %s", xid, op, fhstr,do { do { if (0) printf ("XID: %x, %s: args: %s, offset:" " %" "ll" "u"", count: %""u"", %s", xid, op, fhstr, offt, count, ( stablewrite == UNSTABLE)?"UNSTABLE":"STABLE"); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1764, GF_LOG_DEBUG , "XID: %x, %s: args: %s, offset:" " %""ll" "u"", count: %""u" ", %s", xid, op, fhstr, offt, count, (stablewrite == UNSTABLE )?"UNSTABLE":"STABLE"); } while (0)
1763	offt, count,do { do { if (0) printf ("XID: %x, %s: args: %s, offset:" " %" "ll" "u"", count: %""u"", %s", xid, op, fhstr, offt, count, ( stablewrite == UNSTABLE)?"UNSTABLE":"STABLE"); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1764, GF_LOG_DEBUG , "XID: %x, %s: args: %s, offset:" " %""ll" "u"", count: %""u" ", %s", xid, op, fhstr, offt, count, (stablewrite == UNSTABLE )?"UNSTABLE":"STABLE"); } while (0)
1764	(stablewrite == UNSTABLE)?"UNSTABLE":"STABLE")do { do { if (0) printf ("XID: %x, %s: args: %s, offset:" " %" "ll" "u"", count: %""u"", %s", xid, op, fhstr, offt, count, ( stablewrite == UNSTABLE)?"UNSTABLE":"STABLE"); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 1764, GF_LOG_DEBUG , "XID: %x, %s: args: %s, offset:" " %""ll" "u"", count: %""u" ", %s", xid, op, fhstr, offt, count, (stablewrite == UNSTABLE )?"UNSTABLE":"STABLE"); } while (0);
1765
1766	}
1767
1768
1769	int
1770	nfs3_getattr_loglevel (nfsstat3 stat) {
1771
1772	int ll = GF_LOG_DEBUG;
1773
1774	switch (stat) {
1775
1776	case NFS3ERR_PERM:
1777	ll = GF_LOG_WARNING;
1778	break;
1779
1780	case NFS3ERR_NOENT:
1781	ll = GF_LOG_WARNING;
1782	break;
1783
1784	case NFS3ERR_ACCES:
1785	ll = GF_LOG_WARNING;
1786	break;
1787
1788	case NFS3ERR_EXIST:
1789	ll = GF_LOG_WARNING;
1790	break;
1791
1792	case NFS3ERR_XDEV:
1793	ll = GF_LOG_WARNING;
1794	break;
1795
1796	case NFS3ERR_NODEV:
1797	ll = GF_LOG_WARNING;
1798	break;
1799
1800	case NFS3ERR_IO:
1801	ll = GF_LOG_WARNING;
1802	break;
1803
1804	case NFS3ERR_NXIO:
1805	ll = GF_LOG_WARNING;
1806	break;
1807
1808	case NFS3ERR_NOTDIR:
1809	ll = GF_LOG_WARNING;
1810	break;
1811
1812	case NFS3ERR_ISDIR:
1813	ll = GF_LOG_WARNING;
1814	break;
1815
1816	case NFS3ERR_INVAL:
1817	ll = GF_LOG_WARNING;
1818	break;
1819
1820	case NFS3ERR_NOSPC:
1821	ll = GF_LOG_WARNING;
1822	break;
1823
1824	case NFS3ERR_ROFS:
1825	ll = GF_LOG_WARNING;
1826	break;
1827
1828	case NFS3ERR_FBIG:
1829	ll = GF_LOG_WARNING;
1830	break;
1831
1832	case NFS3ERR_MLINK:
1833	ll = GF_LOG_WARNING;
1834	break;
1835
1836	case NFS3ERR_NAMETOOLONG:
1837	ll = GF_LOG_WARNING;
1838	break;
1839
1840	case NFS3ERR_NOTEMPTY:
1841	ll = GF_LOG_WARNING;
1842	break;
1843
1844	case NFS3ERR_SERVERFAULT:
1845	ll = GF_LOG_WARNING;
1846	break;
1847
1848	case NFS3ERR_NOTSUPP:
1849	ll = GF_LOG_WARNING;
1850	break;
1851
1852	case NFS3ERR_BADHANDLE:
1853	ll = GF_LOG_WARNING;
1854	break;
1855
1856	case NFS3ERR_STALE:
1857	ll = GF_LOG_WARNING;
1858	break;
1859
1860	case NFS3ERR_DQUOT:
1861	ll = GF_LOG_WARNING;
1862	break;
1863
1864	default:
1865	ll = GF_LOG_DEBUG;
1866	break;
1867	}
1868
1869	return ll;
1870	}
1871
1872
1873	int
1874	nfs3_setattr_loglevel (nfsstat3 stat) {
1875
1876	int ll = GF_LOG_DEBUG;
1877
1878	switch (stat) {
1879
1880	case NFS3ERR_NOENT:
1881	ll = GF_LOG_WARNING;
1882	break;
1883
1884	case NFS3ERR_EXIST:
1885	ll = GF_LOG_WARNING;
1886	break;
1887
1888	case NFS3ERR_XDEV:
1889	ll = GF_LOG_WARNING;
1890	break;
1891
1892	case NFS3ERR_NODEV:
1893	ll = GF_LOG_WARNING;
1894	break;
1895
1896	case NFS3ERR_IO:
1897	ll = GF_LOG_WARNING;
1898	break;
1899
1900	case NFS3ERR_NXIO:
1901	ll = GF_LOG_WARNING;
1902	break;
1903
1904	case NFS3ERR_NOTDIR:
1905	ll = GF_LOG_WARNING;
1906	break;
1907
1908	case NFS3ERR_ISDIR:
1909	ll = GF_LOG_WARNING;
1910	break;
1911
1912	case NFS3ERR_INVAL:
1913	ll = GF_LOG_WARNING;
1914	break;
1915
1916	case NFS3ERR_NOSPC:
1917	ll = GF_LOG_WARNING;
1918	break;
1919
1920	case NFS3ERR_ROFS:
1921	ll = GF_LOG_WARNING;
1922	break;
1923
1924	case NFS3ERR_FBIG:
1925	ll = GF_LOG_WARNING;
1926	break;
1927
1928	case NFS3ERR_MLINK:
1929	ll = GF_LOG_WARNING;
1930	break;
1931
1932	case NFS3ERR_NAMETOOLONG:
1933	ll = GF_LOG_WARNING;
1934	break;
1935
1936	case NFS3ERR_NOTEMPTY:
1937	ll = GF_LOG_WARNING;
1938	break;
1939
1940	case NFS3ERR_SERVERFAULT:
1941	ll = GF_LOG_WARNING;
1942	break;
1943
1944	case NFS3ERR_NOTSUPP:
1945	ll = GF_LOG_WARNING;
1946	break;
1947
1948	case NFS3ERR_BADHANDLE:
1949	ll = GF_LOG_WARNING;
1950	break;
1951
1952	case NFS3ERR_STALE:
1953	ll = GF_LOG_WARNING;
1954	break;
1955
1956	case NFS3ERR_DQUOT:
1957	ll = GF_LOG_WARNING;
1958	break;
1959
1960	default:
1961	ll = GF_LOG_DEBUG;
1962	break;
1963	}
1964
1965	return ll;
1966	}
1967
1968
1969	int
1970	nfs3_lookup_loglevel (nfsstat3 stat) {
1971
1972	int ll = GF_LOG_DEBUG;
1973
1974	switch (stat) {
1975
1976	case NFS3ERR_PERM:
1977	ll = GF_LOG_WARNING;
1978	break;
1979
1980	case NFS3ERR_ACCES:
1981	ll = GF_LOG_WARNING;
1982	break;
1983
1984	case NFS3ERR_EXIST:
1985	ll = GF_LOG_WARNING;
1986	break;
1987
1988	case NFS3ERR_XDEV:
1989	ll = GF_LOG_WARNING;
1990	break;
1991
1992	case NFS3ERR_NODEV:
1993	ll = GF_LOG_WARNING;
1994	break;
1995
1996	case NFS3ERR_IO:
1997	ll = GF_LOG_WARNING;
1998	break;
1999
2000	case NFS3ERR_NXIO:
2001	ll = GF_LOG_WARNING;
2002	break;
2003
2004	case NFS3ERR_NOTDIR:
2005	ll = GF_LOG_WARNING;
2006	break;
2007
2008	case NFS3ERR_ISDIR:
2009	ll = GF_LOG_WARNING;
2010	break;
2011
2012	case NFS3ERR_INVAL:
2013	ll = GF_LOG_WARNING;
2014	break;
2015
2016	case NFS3ERR_NOSPC:
2017	ll = GF_LOG_WARNING;
2018	break;
2019
2020	case NFS3ERR_ROFS:
2021	ll = GF_LOG_WARNING;
2022	break;
2023
2024	case NFS3ERR_FBIG:
2025	ll = GF_LOG_WARNING;
2026	break;
2027
2028	case NFS3ERR_MLINK:
2029	ll = GF_LOG_WARNING;
2030	break;
2031
2032	case NFS3ERR_NAMETOOLONG:
2033	ll = GF_LOG_WARNING;
2034	break;
2035
2036	case NFS3ERR_NOTEMPTY:
2037	ll = GF_LOG_WARNING;
2038	break;
2039
2040	case NFS3ERR_SERVERFAULT:
2041	ll = GF_LOG_WARNING;
2042	break;
2043
2044	case NFS3ERR_NOTSUPP:
2045	ll = GF_LOG_WARNING;
2046	break;
2047
2048	case NFS3ERR_BADHANDLE:
2049	ll = GF_LOG_WARNING;
2050	break;
2051
2052	case NFS3ERR_STALE:
2053	ll = GF_LOG_WARNING;
2054	break;
2055
2056	case NFS3ERR_DQUOT:
2057	ll = GF_LOG_WARNING;
2058	break;
2059
2060	default:
2061	ll = GF_LOG_DEBUG;
2062	break;
2063	}
2064
2065	return ll;
2066	}
2067
2068
2069	int
2070	nfs3_access_loglevel (nfsstat3 stat) {
2071
2072	int ll = GF_LOG_DEBUG;
2073
2074	switch (stat) {
2075
2076	case NFS3ERR_NOENT:
2077	ll = GF_LOG_WARNING;
2078	break;
2079
2080	case NFS3ERR_EXIST:
2081	ll = GF_LOG_WARNING;
2082	break;
2083
2084	case NFS3ERR_XDEV:
2085	ll = GF_LOG_WARNING;
2086	break;
2087
2088	case NFS3ERR_NODEV:
2089	ll = GF_LOG_WARNING;
2090	break;
2091
2092	case NFS3ERR_IO:
2093	ll = GF_LOG_WARNING;
2094	break;
2095
2096	case NFS3ERR_NXIO:
2097	ll = GF_LOG_WARNING;
2098	break;
2099
2100	case NFS3ERR_NOTDIR:
2101	ll = GF_LOG_WARNING;
2102	break;
2103
2104	case NFS3ERR_ISDIR:
2105	ll = GF_LOG_WARNING;
2106	break;
2107
2108	case NFS3ERR_INVAL:
2109	ll = GF_LOG_WARNING;
2110	break;
2111
2112	case NFS3ERR_NOSPC:
2113	ll = GF_LOG_WARNING;
2114	break;
2115
2116	case NFS3ERR_ROFS:
2117	ll = GF_LOG_WARNING;
2118	break;
2119
2120	case NFS3ERR_FBIG:
2121	ll = GF_LOG_WARNING;
2122	break;
2123
2124	case NFS3ERR_MLINK:
2125	ll = GF_LOG_WARNING;
2126	break;
2127
2128	case NFS3ERR_NAMETOOLONG:
2129	ll = GF_LOG_WARNING;
2130	break;
2131
2132	case NFS3ERR_NOTEMPTY:
2133	ll = GF_LOG_WARNING;
2134	break;
2135
2136	case NFS3ERR_SERVERFAULT:
2137	ll = GF_LOG_WARNING;
2138	break;
2139
2140	case NFS3ERR_NOTSUPP:
2141	ll = GF_LOG_WARNING;
2142	break;
2143
2144	case NFS3ERR_BADHANDLE:
2145	ll = GF_LOG_WARNING;
2146	break;
2147
2148	case NFS3ERR_STALE:
2149	ll = GF_LOG_WARNING;
2150	break;
2151
2152	case NFS3ERR_DQUOT:
2153	ll = GF_LOG_WARNING;
2154	break;
2155
2156	default:
2157	ll = GF_LOG_DEBUG;
2158	break;
2159	}
2160
2161	return ll;
2162	}
2163
2164
2165	int
2166	nfs3_readlink_loglevel (nfsstat3 stat) {
2167
2168	int ll = GF_LOG_DEBUG;
2169
2170	switch (stat) {
2171
2172	case NFS3ERR_EXIST:
2173	ll = GF_LOG_WARNING;
2174	break;
2175
2176	case NFS3ERR_XDEV:
2177	ll = GF_LOG_WARNING;
2178	break;
2179
2180	case NFS3ERR_NODEV:
2181	ll = GF_LOG_WARNING;
2182	break;
2183
2184	case NFS3ERR_IO:
2185	ll = GF_LOG_WARNING;
2186	break;
2187
2188	case NFS3ERR_NXIO:
2189	ll = GF_LOG_WARNING;
2190	break;
2191
2192	case NFS3ERR_NOTDIR:
2193	ll = GF_LOG_WARNING;
2194	break;
2195
2196	case NFS3ERR_ISDIR:
2197	ll = GF_LOG_WARNING;
2198	break;
2199
2200	case NFS3ERR_INVAL:
2201	ll = GF_LOG_WARNING;
2202	break;
2203
2204	case NFS3ERR_NOSPC:
2205	ll = GF_LOG_WARNING;
2206	break;
2207
2208	case NFS3ERR_ROFS:
2209	ll = GF_LOG_WARNING;
2210	break;
2211
2212	case NFS3ERR_FBIG:
2213	ll = GF_LOG_WARNING;
2214	break;
2215
2216	case NFS3ERR_MLINK:
2217	ll = GF_LOG_WARNING;
2218	break;
2219
2220	case NFS3ERR_NOTEMPTY:
2221	ll = GF_LOG_WARNING;
2222	break;
2223
2224	case NFS3ERR_SERVERFAULT:
2225	ll = GF_LOG_WARNING;
2226	break;
2227
2228	case NFS3ERR_NOTSUPP:
2229	ll = GF_LOG_WARNING;
2230	break;
2231
2232	case NFS3ERR_BADHANDLE:
2233	ll = GF_LOG_WARNING;
2234	break;
2235
2236	case NFS3ERR_STALE:
2237	ll = GF_LOG_WARNING;
2238	break;
2239
2240	case NFS3ERR_DQUOT:
2241	ll = GF_LOG_WARNING;
2242	break;
2243
2244	default:
2245	ll = GF_LOG_DEBUG;
2246	break;
2247	}
2248
2249	return ll;
2250	}
2251
2252	int
2253	nfs3_read_loglevel (nfsstat3 stat) {
2254
2255	int ll = GF_LOG_DEBUG;
2256
2257	switch (stat) {
2258
2259	case NFS3ERR_NOENT:
2260	ll = GF_LOG_WARNING;
2261	break;
2262
2263	case NFS3ERR_EXIST:
2264	ll = GF_LOG_WARNING;
2265	break;
2266
2267	case NFS3ERR_XDEV:
2268	ll = GF_LOG_WARNING;
2269	break;
2270
2271	case NFS3ERR_NODEV:
2272	ll = GF_LOG_WARNING;
2273	break;
2274
2275	case NFS3ERR_IO:
2276	ll = GF_LOG_WARNING;
2277	break;
2278
2279	case NFS3ERR_NXIO:
2280	ll = GF_LOG_WARNING;
2281	break;
2282
2283	case NFS3ERR_NOTDIR:
2284	ll = GF_LOG_WARNING;
2285	break;
2286
2287	case NFS3ERR_ISDIR:
2288	ll = GF_LOG_WARNING;
2289	break;
2290
2291	case NFS3ERR_INVAL:
2292	ll = GF_LOG_WARNING;
2293	break;
2294
2295	case NFS3ERR_NOSPC:
2296	ll = GF_LOG_WARNING;
2297	break;
2298
2299	case NFS3ERR_ROFS:
2300	ll = GF_LOG_WARNING;
2301	break;
2302
2303	case NFS3ERR_FBIG:
2304	ll = GF_LOG_WARNING;
2305	break;
2306
2307	case NFS3ERR_MLINK:
2308	ll = GF_LOG_WARNING;
2309	break;
2310
2311	case NFS3ERR_NAMETOOLONG:
2312	ll = GF_LOG_WARNING;
2313	break;
2314
2315	case NFS3ERR_NOTEMPTY:
2316	ll = GF_LOG_WARNING;
2317	break;
2318
2319	case NFS3ERR_SERVERFAULT:
2320	ll = GF_LOG_WARNING;
2321	break;
2322
2323	case NFS3ERR_NOTSUPP:
2324	ll = GF_LOG_WARNING;
2325	break;
2326
2327	case NFS3ERR_BADHANDLE:
2328	ll = GF_LOG_WARNING;
2329	break;
2330
2331	case NFS3ERR_STALE:
2332	ll = GF_LOG_WARNING;
2333	break;
2334
2335	case NFS3ERR_DQUOT:
2336	ll = GF_LOG_WARNING;
2337	break;
2338
2339	default:
2340	ll = GF_LOG_DEBUG;
2341	break;
2342	}
2343
2344	return ll;
2345	}
2346
2347
2348	int
2349	nfs3_write_loglevel (nfsstat3 stat) {
2350
2351	int ll = GF_LOG_DEBUG;
2352
2353	switch (stat) {
2354
2355	case NFS3ERR_NOENT:
2356	ll = GF_LOG_WARNING;
2357	break;
2358
2359	case NFS3ERR_EXIST:
2360	ll = GF_LOG_WARNING;
2361	break;
2362
2363	case NFS3ERR_XDEV:
2364	ll = GF_LOG_WARNING;
2365	break;
2366
2367	case NFS3ERR_NODEV:
2368	ll = GF_LOG_WARNING;
2369	break;
2370
2371	case NFS3ERR_IO:
2372	ll = GF_LOG_WARNING;
2373	break;
2374
2375	case NFS3ERR_NXIO:
2376	ll = GF_LOG_WARNING;
2377	break;
2378
2379	case NFS3ERR_NOTDIR:
2380	ll = GF_LOG_WARNING;
2381	break;
2382
2383	case NFS3ERR_ISDIR:
2384	ll = GF_LOG_WARNING;
2385	break;
2386
2387	case NFS3ERR_INVAL:
2388	ll = GF_LOG_WARNING;
2389	break;
2390
2391	case NFS3ERR_NOSPC:
2392	ll = GF_LOG_WARNING;
2393	break;
2394
2395	case NFS3ERR_ROFS:
2396	ll = GF_LOG_WARNING;
2397	break;
2398
2399	case NFS3ERR_FBIG:
2400	ll = GF_LOG_WARNING;
2401	break;
2402
2403	case NFS3ERR_MLINK:
2404	ll = GF_LOG_WARNING;
2405	break;
2406
2407	case NFS3ERR_NAMETOOLONG:
2408	ll = GF_LOG_WARNING;
2409	break;
2410
2411	case NFS3ERR_NOTEMPTY:
2412	ll = GF_LOG_WARNING;
2413	break;
2414
2415	case NFS3ERR_SERVERFAULT:
2416	ll = GF_LOG_WARNING;
2417	break;
2418
2419	case NFS3ERR_NOTSUPP:
2420	ll = GF_LOG_WARNING;
2421	break;
2422
2423	case NFS3ERR_BADHANDLE:
2424	ll = GF_LOG_WARNING;
2425	break;
2426
2427	case NFS3ERR_STALE:
2428	ll = GF_LOG_WARNING;
2429	break;
2430
2431	case NFS3ERR_DQUOT:
2432	ll = GF_LOG_WARNING;
2433	break;
2434
2435	default:
2436	ll = GF_LOG_DEBUG;
2437	break;
2438	}
2439
2440	return ll;
2441	}
2442
2443
2444	int
2445	nfs3_create_loglevel (nfsstat3 stat) {
2446
2447	int ll = GF_LOG_DEBUG;
2448
2449	switch (stat) {
2450
2451	case NFS3ERR_NOENT:
2452	ll = GF_LOG_WARNING;
2453	break;
2454
2455	case NFS3ERR_EXIST:
2456	ll = GF_LOG_WARNING;
2457	break;
2458
2459	case NFS3ERR_XDEV:
2460	ll = GF_LOG_WARNING;
2461	break;
2462
2463	case NFS3ERR_NODEV:
2464	ll = GF_LOG_WARNING;
2465	break;
2466
2467	case NFS3ERR_IO:
2468	ll = GF_LOG_WARNING;
2469	break;
2470
2471	case NFS3ERR_NXIO:
2472	ll = GF_LOG_WARNING;
2473	break;
2474
2475	case NFS3ERR_NOTDIR:
2476	ll = GF_LOG_WARNING;
2477	break;
2478
2479	case NFS3ERR_ISDIR:
2480	ll = GF_LOG_WARNING;
2481	break;
2482
2483	case NFS3ERR_INVAL:
2484	ll = GF_LOG_WARNING;
2485	break;
2486
2487	case NFS3ERR_FBIG:
2488	ll = GF_LOG_WARNING;
2489	break;
2490
2491	case NFS3ERR_MLINK:
2492	ll = GF_LOG_WARNING;
2493	break;
2494
2495	case NFS3ERR_NOTEMPTY:
2496	ll = GF_LOG_WARNING;
2497	break;
2498
2499	case NFS3ERR_SERVERFAULT:
2500	ll = GF_LOG_WARNING;
2501	break;
2502
2503	case NFS3ERR_NOTSUPP:
2504	ll = GF_LOG_WARNING;
2505	break;
2506
2507	case NFS3ERR_BADHANDLE:
2508	ll = GF_LOG_WARNING;
2509	break;
2510
2511	case NFS3ERR_STALE:
2512	ll = GF_LOG_WARNING;
2513	break;
2514
2515	default:
2516	ll = GF_LOG_DEBUG;
2517	break;
2518	}
2519
2520	return ll;
2521	}
2522
2523
2524	int
2525	nfs3_mkdir_loglevel (nfsstat3 stat) {
2526
2527	int ll = GF_LOG_DEBUG;
2528
2529	switch (stat) {
2530
2531	case NFS3ERR_NOENT:
2532	ll = GF_LOG_WARNING;
2533	break;
2534
2535	case NFS3ERR_XDEV:
2536	ll = GF_LOG_WARNING;
2537	break;
2538
2539	case NFS3ERR_NODEV:
2540	ll = GF_LOG_WARNING;
2541	break;
2542
2543	case NFS3ERR_IO:
2544	ll = GF_LOG_WARNING;
2545	break;
2546
2547	case NFS3ERR_NXIO:
2548	ll = GF_LOG_WARNING;
2549	break;
2550
2551	case NFS3ERR_NOTDIR:
2552	ll = GF_LOG_WARNING;
2553	break;
2554
2555	case NFS3ERR_ISDIR:
2556	ll = GF_LOG_WARNING;
2557	break;
2558
2559	case NFS3ERR_INVAL:
2560	ll = GF_LOG_WARNING;
2561	break;
2562
2563	case NFS3ERR_FBIG:
2564	ll = GF_LOG_WARNING;
2565	break;
2566
2567	case NFS3ERR_MLINK:
2568	ll = GF_LOG_WARNING;
2569	break;
2570
2571	case NFS3ERR_NOTEMPTY:
2572	ll = GF_LOG_WARNING;
2573	break;
2574
2575	case NFS3ERR_SERVERFAULT:
2576	ll = GF_LOG_WARNING;
2577	break;
2578
2579	case NFS3ERR_NOTSUPP:
2580	ll = GF_LOG_WARNING;
2581	break;
2582
2583	case NFS3ERR_BADHANDLE:
2584	ll = GF_LOG_WARNING;
2585	break;
2586
2587	case NFS3ERR_STALE:
2588	ll = GF_LOG_WARNING;
2589	break;
2590
2591	case NFS3ERR_DQUOT:
2592	ll = GF_LOG_WARNING;
2593	break;
2594
2595	default:
2596	ll = GF_LOG_DEBUG;
2597	break;
2598	}
2599
2600	return ll;
2601	}
2602
2603
2604	int
2605	nfs3_symlink_loglevel (nfsstat3 stat) {
2606
2607	int ll = GF_LOG_DEBUG;
2608
2609	switch (stat) {
2610
2611	case NFS3ERR_XDEV:
2612	ll = GF_LOG_WARNING;
2613	break;
2614
2615	case NFS3ERR_NODEV:
2616	ll = GF_LOG_WARNING;
2617	break;
2618
2619	case NFS3ERR_IO:
2620	ll = GF_LOG_WARNING;
2621	break;
2622
2623	case NFS3ERR_NXIO:
2624	ll = GF_LOG_WARNING;
2625	break;
2626
2627	case NFS3ERR_NOTDIR:
2628	ll = GF_LOG_WARNING;
2629	break;
2630
2631	case NFS3ERR_ISDIR:
2632	ll = GF_LOG_WARNING;
2633	break;
2634
2635	case NFS3ERR_INVAL:
2636	ll = GF_LOG_WARNING;
2637	break;
2638
2639	case NFS3ERR_FBIG:
2640	ll = GF_LOG_WARNING;
2641	break;
2642
2643	case NFS3ERR_MLINK:
2644	ll = GF_LOG_WARNING;
2645	break;
2646
2647	case NFS3ERR_NOTEMPTY:
2648	ll = GF_LOG_WARNING;
2649	break;
2650
2651	case NFS3ERR_SERVERFAULT:
2652	ll = GF_LOG_WARNING;
2653	break;
2654
2655	case NFS3ERR_NOTSUPP:
2656	ll = GF_LOG_WARNING;
2657	break;
2658
2659	case NFS3ERR_BADHANDLE:
2660	ll = GF_LOG_WARNING;
2661	break;
2662
2663	case NFS3ERR_STALE:
2664	ll = GF_LOG_WARNING;
2665	break;
2666
2667	case NFS3ERR_DQUOT:
2668	ll = GF_LOG_WARNING;
2669	break;
2670
2671	default:
2672	ll = GF_LOG_DEBUG;
2673	break;
2674	}
2675
2676	return ll;
2677	}
2678
2679
2680	int
2681	nfs3_mknod_loglevel (nfsstat3 stat) {
2682
2683	int ll = GF_LOG_DEBUG;
2684
2685	switch (stat) {
2686
2687	case NFS3ERR_NOENT:
2688	ll = GF_LOG_WARNING;
2689	break;
2690
2691	case NFS3ERR_XDEV:
2692	ll = GF_LOG_WARNING;
2693	break;
2694
2695	case NFS3ERR_NODEV:
2696	ll = GF_LOG_WARNING;
2697	break;
2698
2699	case NFS3ERR_IO:
2700	ll = GF_LOG_WARNING;
2701	break;
2702
2703	case NFS3ERR_NXIO:
2704	ll = GF_LOG_WARNING;
2705	break;
2706
2707	case NFS3ERR_NOTDIR:
2708	ll = GF_LOG_WARNING;
2709	break;
2710
2711	case NFS3ERR_ISDIR:
2712	ll = GF_LOG_WARNING;
2713	break;
2714
2715	case NFS3ERR_INVAL:
2716	ll = GF_LOG_WARNING;
2717	break;
2718
2719	case NFS3ERR_FBIG:
2720	ll = GF_LOG_WARNING;
2721	break;
2722
2723	case NFS3ERR_MLINK:
2724	ll = GF_LOG_WARNING;
2725	break;
2726
2727	case NFS3ERR_NOTEMPTY:
2728	ll = GF_LOG_WARNING;
2729	break;
2730
2731	case NFS3ERR_SERVERFAULT:
2732	ll = GF_LOG_WARNING;
2733	break;
2734
2735	case NFS3ERR_NOTSUPP:
2736	ll = GF_LOG_WARNING;
2737	break;
2738
2739	case NFS3ERR_BADHANDLE:
2740	ll = GF_LOG_WARNING;
2741	break;
2742
2743	case NFS3ERR_STALE:
2744	ll = GF_LOG_WARNING;
2745	break;
2746
2747	default:
2748	ll = GF_LOG_DEBUG;
2749	break;
2750	}
2751
2752	return ll;
2753	}
2754
2755	int
2756	nfs3_remove_loglevel (nfsstat3 stat) {
2757
2758	int ll = GF_LOG_DEBUG;
2759
2760	switch (stat) {
2761
2762	case NFS3ERR_EXIST:
2763	ll = GF_LOG_WARNING;
2764	break;
2765
2766	case NFS3ERR_XDEV:
2767	ll = GF_LOG_WARNING;
2768	break;
2769
2770	case NFS3ERR_NODEV:
2771	ll = GF_LOG_WARNING;
2772	break;
2773
2774	case NFS3ERR_IO:
2775	ll = GF_LOG_WARNING;
2776	break;
2777
2778	case NFS3ERR_NXIO:
2779	ll = GF_LOG_WARNING;
2780	break;
2781
2782	case NFS3ERR_NOTDIR:
2783	ll = GF_LOG_WARNING;
2784	break;
2785
2786	case NFS3ERR_INVAL:
2787	ll = GF_LOG_WARNING;
2788	break;
2789
2790	case NFS3ERR_NOSPC:
2791	ll = GF_LOG_WARNING;
2792	break;
2793
2794	case NFS3ERR_FBIG:
2795	ll = GF_LOG_WARNING;
2796	break;
2797
2798	case NFS3ERR_MLINK:
2799	ll = GF_LOG_WARNING;
2800	break;
2801
2802	case NFS3ERR_SERVERFAULT:
2803	ll = GF_LOG_WARNING;
2804	break;
2805
2806	case NFS3ERR_NOTSUPP:
2807	ll = GF_LOG_WARNING;
2808	break;
2809
2810	case NFS3ERR_BADHANDLE:
2811	ll = GF_LOG_WARNING;
2812	break;
2813
2814	case NFS3ERR_STALE:
2815	ll = GF_LOG_WARNING;
2816	break;
2817
2818	case NFS3ERR_DQUOT:
2819	ll = GF_LOG_WARNING;
2820	break;
2821
2822	default:
2823	ll = GF_LOG_DEBUG;
2824	break;
2825	}
2826
2827	return ll;
2828	}
2829
2830
2831	int
2832	nfs3_rmdir_loglevel (nfsstat3 stat) {
2833
2834	int ll = GF_LOG_DEBUG;
2835
2836	switch (stat) {
2837
2838	case NFS3ERR_EXIST:
2839	ll = GF_LOG_WARNING;
2840	break;
2841
2842	case NFS3ERR_XDEV:
2843	ll = GF_LOG_WARNING;
2844	break;
2845
2846	case NFS3ERR_NODEV:
2847	ll = GF_LOG_WARNING;
2848	break;
2849
2850	case NFS3ERR_IO:
2851	ll = GF_LOG_WARNING;
2852	break;
2853
2854	case NFS3ERR_NXIO:
2855	ll = GF_LOG_WARNING;
2856	break;
2857
2858	case NFS3ERR_NOTDIR:
2859	ll = GF_LOG_WARNING;
2860	break;
2861
2862	case NFS3ERR_INVAL:
2863	ll = GF_LOG_WARNING;
2864	break;
2865
2866	case NFS3ERR_NOSPC:
2867	ll = GF_LOG_WARNING;
2868	break;
2869
2870	case NFS3ERR_FBIG:
2871	ll = GF_LOG_WARNING;
2872	break;
2873
2874	case NFS3ERR_MLINK:
2875	ll = GF_LOG_WARNING;
2876	break;
2877
2878	case NFS3ERR_SERVERFAULT:
2879	ll = GF_LOG_WARNING;
2880	break;
2881
2882	case NFS3ERR_NOTSUPP:
2883	ll = GF_LOG_WARNING;
2884	break;
2885
2886	case NFS3ERR_BADHANDLE:
2887	ll = GF_LOG_WARNING;
2888	break;
2889
2890	case NFS3ERR_STALE:
2891	ll = GF_LOG_WARNING;
2892	break;
2893
2894	case NFS3ERR_DQUOT:
2895	ll = GF_LOG_WARNING;
2896	break;
2897
2898	default:
2899	ll = GF_LOG_DEBUG;
2900	break;
2901	}
2902
2903	return ll;
2904	}
2905
2906
2907	int
2908	nfs3_rename_loglevel (nfsstat3 stat) {
2909
2910	int ll = GF_LOG_DEBUG;
2911
2912	switch (stat) {
2913
2914	case NFS3ERR_XDEV:
2915	ll = GF_LOG_WARNING;
2916	break;
2917
2918	case NFS3ERR_NODEV:
2919	ll = GF_LOG_WARNING;
2920	break;
2921
2922	case NFS3ERR_IO:
2923	ll = GF_LOG_WARNING;
2924	break;
2925
2926	case NFS3ERR_NXIO:
2927	ll = GF_LOG_WARNING;
2928	break;
2929
2930	case NFS3ERR_NOTDIR:
2931	ll = GF_LOG_WARNING;
2932	break;
2933
2934	case NFS3ERR_ISDIR:
2935	ll = GF_LOG_WARNING;
2936	break;
2937
2938	case NFS3ERR_INVAL:
2939	ll = GF_LOG_WARNING;
2940	break;
2941
2942	case NFS3ERR_NOSPC:
2943	ll = GF_LOG_WARNING;
2944	break;
2945
2946	case NFS3ERR_FBIG:
2947	ll = GF_LOG_WARNING;
2948	break;
2949
2950	case NFS3ERR_MLINK:
2951	ll = GF_LOG_WARNING;
2952	break;
2953
2954	case NFS3ERR_NOTEMPTY:
2955	ll = GF_LOG_WARNING;
2956	break;
2957
2958	case NFS3ERR_SERVERFAULT:
2959	ll = GF_LOG_WARNING;
2960	break;
2961
2962	case NFS3ERR_NOTSUPP:
2963	ll = GF_LOG_WARNING;
2964	break;
2965
2966	case NFS3ERR_BADHANDLE:
2967	ll = GF_LOG_WARNING;
2968	break;
2969
2970	case NFS3ERR_STALE:
2971	ll = GF_LOG_WARNING;
2972	break;
2973
2974	case NFS3ERR_DQUOT:
2975	ll = GF_LOG_WARNING;
2976	break;
2977
2978	default:
2979	ll = GF_LOG_DEBUG;
2980	break;
2981	}
2982
2983	return ll;
2984	}
2985
2986
2987	int
2988	nfs3_link_loglevel (nfsstat3 stat) {
2989
2990	int ll = GF_LOG_DEBUG;
2991
2992	switch (stat) {
2993
2994	case NFS3ERR_XDEV:
2995	ll = GF_LOG_WARNING;
2996	break;
2997
2998	case NFS3ERR_NODEV:
2999	ll = GF_LOG_WARNING;
3000	break;
3001
3002	case NFS3ERR_IO:
3003	ll = GF_LOG_WARNING;
3004	break;
3005
3006	case NFS3ERR_NXIO:
3007	ll = GF_LOG_WARNING;
3008	break;
3009
3010	case NFS3ERR_INVAL:
3011	ll = GF_LOG_WARNING;
3012	break;
3013
3014	case NFS3ERR_FBIG:
3015	ll = GF_LOG_WARNING;
3016	break;
3017
3018	case NFS3ERR_MLINK:
3019	ll = GF_LOG_WARNING;
3020	break;
3021
3022	case NFS3ERR_NOTEMPTY:
3023	ll = GF_LOG_WARNING;
3024	break;
3025
3026	case NFS3ERR_SERVERFAULT:
3027	ll = GF_LOG_WARNING;
3028	break;
3029
3030	case NFS3ERR_NOTSUPP:
3031	ll = GF_LOG_WARNING;
3032	break;
3033
3034	case NFS3ERR_BADHANDLE:
3035	ll = GF_LOG_WARNING;
3036	break;
3037
3038	case NFS3ERR_STALE:
3039	ll = GF_LOG_WARNING;
3040	break;
3041
3042	case NFS3ERR_DQUOT:
3043	ll = GF_LOG_WARNING;
3044	break;
3045
3046	default:
3047	ll = GF_LOG_DEBUG;
3048	break;
3049	}
3050
3051	return ll;
3052	}
3053
3054
3055	int
3056	nfs3_readdir_loglevel (nfsstat3 stat) {
3057
3058	int ll = GF_LOG_DEBUG;
3059
3060	switch (stat) {
3061
3062	case NFS3ERR_NOENT:
3063	ll = GF_LOG_WARNING;
3064	break;
3065
3066	case NFS3ERR_EXIST:
3067	ll = GF_LOG_WARNING;
3068	break;
3069
3070	case NFS3ERR_XDEV:
3071	ll = GF_LOG_WARNING;
3072	break;
3073
3074	case NFS3ERR_NODEV:
3075	ll = GF_LOG_WARNING;
3076	break;
3077
3078	case NFS3ERR_IO:
3079	ll = GF_LOG_WARNING;
3080	break;
3081
3082	case NFS3ERR_NXIO:
3083	ll = GF_LOG_WARNING;
3084	break;
3085
3086	case NFS3ERR_NOTDIR:
3087	ll = GF_LOG_WARNING;
3088	break;
3089
3090	case NFS3ERR_ISDIR:
3091	ll = GF_LOG_WARNING;
3092	break;
3093
3094	case NFS3ERR_INVAL:
3095	ll = GF_LOG_WARNING;
3096	break;
3097
3098	case NFS3ERR_NOSPC:
3099	ll = GF_LOG_WARNING;
3100	break;
3101
3102	case NFS3ERR_ROFS:
3103	ll = GF_LOG_WARNING;
3104	break;
3105
3106	case NFS3ERR_FBIG:
3107	ll = GF_LOG_WARNING;
3108	break;
3109
3110	case NFS3ERR_MLINK:
3111	ll = GF_LOG_WARNING;
3112	break;
3113
3114	case NFS3ERR_NAMETOOLONG:
3115	ll = GF_LOG_WARNING;
3116	break;
3117
3118	case NFS3ERR_NOTEMPTY:
3119	ll = GF_LOG_WARNING;
3120	break;
3121
3122	case NFS3ERR_SERVERFAULT:
3123	ll = GF_LOG_WARNING;
3124	break;
3125
3126	case NFS3ERR_NOTSUPP:
3127	ll = GF_LOG_WARNING;
3128	break;
3129
3130	case NFS3ERR_BADHANDLE:
3131	ll = GF_LOG_WARNING;
3132	break;
3133
3134	case NFS3ERR_STALE:
3135	ll = GF_LOG_WARNING;
3136	break;
3137
3138	case NFS3ERR_DQUOT:
3139	ll = GF_LOG_WARNING;
3140	break;
3141
3142	default:
3143	ll = GF_LOG_DEBUG;
3144	break;
3145	}
3146
3147	return ll;
3148	}
3149
3150
3151	int
3152	nfs3_fsstat_loglevel (nfsstat3 stat) {
3153
3154	int ll = GF_LOG_DEBUG;
3155
3156	switch (stat) {
3157
3158	case NFS3ERR_PERM:
3159	ll = GF_LOG_WARNING;
3160	break;
3161
3162	case NFS3ERR_NOENT:
3163	ll = GF_LOG_WARNING;
3164	break;
3165
3166	case NFS3ERR_ACCES:
3167	ll = GF_LOG_WARNING;
3168	break;
3169
3170	case NFS3ERR_EXIST:
3171	ll = GF_LOG_WARNING;
3172	break;
3173
3174	case NFS3ERR_XDEV:
3175	ll = GF_LOG_WARNING;
3176	break;
3177
3178	case NFS3ERR_NODEV:
3179	ll = GF_LOG_WARNING;
3180	break;
3181
3182	case NFS3ERR_IO:
3183	ll = GF_LOG_WARNING;
3184	break;
3185
3186	case NFS3ERR_NXIO:
3187	ll = GF_LOG_WARNING;
3188	break;
3189
3190	case NFS3ERR_NOTDIR:
3191	ll = GF_LOG_WARNING;
3192	break;
3193
3194	case NFS3ERR_ISDIR:
3195	ll = GF_LOG_WARNING;
3196	break;
3197
3198	case NFS3ERR_INVAL:
3199	ll = GF_LOG_WARNING;
3200	break;
3201
3202	case NFS3ERR_NOSPC:
3203	ll = GF_LOG_WARNING;
3204	break;
3205
3206	case NFS3ERR_ROFS:
3207	ll = GF_LOG_WARNING;
3208	break;
3209
3210	case NFS3ERR_FBIG:
3211	ll = GF_LOG_WARNING;
3212	break;
3213
3214	case NFS3ERR_MLINK:
3215	ll = GF_LOG_WARNING;
3216	break;
3217
3218	case NFS3ERR_NAMETOOLONG:
3219	ll = GF_LOG_WARNING;
3220	break;
3221
3222	case NFS3ERR_NOTEMPTY:
3223	ll = GF_LOG_WARNING;
3224	break;
3225
3226	case NFS3ERR_SERVERFAULT:
3227	ll = GF_LOG_WARNING;
3228	break;
3229
3230	case NFS3ERR_NOTSUPP:
3231	ll = GF_LOG_WARNING;
3232	break;
3233
3234	case NFS3ERR_BADHANDLE:
3235	ll = GF_LOG_WARNING;
3236	break;
3237
3238	case NFS3ERR_STALE:
3239	ll = GF_LOG_WARNING;
3240	break;
3241
3242	case NFS3ERR_DQUOT:
3243	ll = GF_LOG_WARNING;
3244	break;
3245
3246	default:
3247	ll = GF_LOG_DEBUG;
3248	break;
3249	}
3250
3251	return ll;
3252	}
3253
3254	struct nfs3op_str {
3255	int op;
3256	char str[100];
3257	};
3258
3259	struct nfs3op_str nfs3op_strings[] = {
3260	{ NFS3_NULL0, "NULL"},
3261	{ NFS3_GETATTR1, "GETATTR"},
3262	{ NFS3_SETATTR2, "SETATTR"},
3263	{ NFS3_LOOKUP3, "LOOKUP"},
3264	{ NFS3_ACCESS4, "ACCESS"},
3265	{ NFS3_READLINK5, "READLINK"},
3266	{ NFS3_READ6, "READ"},
3267	{ NFS3_WRITE7, "WRITE"},
3268	{ NFS3_CREATE8, "CREATE"},
3269	{ NFS3_MKDIR9, "MKDIR"},
3270	{ NFS3_SYMLINK10, "SYMLINK"},
3271	{ NFS3_MKNOD11, "MKNOD"},
3272	{ NFS3_REMOVE12, "REMOVE"},
3273	{ NFS3_RMDIR13, "RMDIR"},
3274	{ NFS3_RENAME14, "RENAME"},
3275	{ NFS3_LINK15, "LINK"},
3276	{ NFS3_READDIR16, "READDIR"},
3277	{ NFS3_READDIRP17, "READDIRP"},
3278	{ NFS3_FSSTAT18, "FSSTAT"},
3279	{ NFS3_FSINFO19, "FSINFO"},
3280	{ NFS3_PATHCONF20, "PATHCONF"},
3281	{ NFS3_COMMIT21, "COMMIT"},
3282	};
3283
3284	int
3285	nfs3_loglevel (int nfs_op, nfsstat3 stat) {
3286
3287	int ll = GF_LOG_DEBUG;
3288
3289	switch (nfs_op) {
3290	case NFS3_GETATTR1:
3291	ll = nfs3_getattr_loglevel (stat);
3292	break;
3293
3294	case NFS3_SETATTR2:
3295	ll = nfs3_setattr_loglevel (stat);
3296	break;
3297
3298	case NFS3_LOOKUP3:
3299	ll = nfs3_lookup_loglevel (stat);
3300	break;
3301
3302	case NFS3_ACCESS4:
3303	ll = nfs3_access_loglevel (stat);
3304	break;
3305
3306	case NFS3_READLINK5:
3307	ll = nfs3_readlink_loglevel (stat);
3308	break;
3309
3310	case NFS3_READ6:
3311	ll = nfs3_read_loglevel (stat);
3312	break;
3313
3314	case NFS3_WRITE7:
3315	ll = nfs3_write_loglevel (stat);
3316	break;
3317
3318	case NFS3_CREATE8:
3319	ll = nfs3_create_loglevel (stat);
3320	break;
3321
3322	case NFS3_MKDIR9:
3323	ll = nfs3_mkdir_loglevel (stat);
3324	break;
3325
3326	case NFS3_SYMLINK10:
3327	ll = nfs3_symlink_loglevel (stat);
3328	break;
3329
3330	case NFS3_MKNOD11:
3331	ll = nfs3_mknod_loglevel (stat);
3332	break;
3333
3334	case NFS3_REMOVE12:
3335	ll = nfs3_remove_loglevel (stat);
3336	break;
3337
3338	case NFS3_RMDIR13:
3339	ll = nfs3_rmdir_loglevel (stat);
3340	break;
3341
3342	case NFS3_RENAME14:
3343	ll = nfs3_rename_loglevel (stat);
3344	break;
3345
3346	case NFS3_LINK15:
3347	ll = nfs3_link_loglevel (stat);
3348	break;
3349
3350	case NFS3_READDIR16:
3351	ll = nfs3_readdir_loglevel (stat);
3352	break;
3353
3354	case NFS3_READDIRP17:
3355	ll = nfs3_readdir_loglevel (stat);
3356	break;
3357
3358	case NFS3_FSSTAT18:
3359	ll = nfs3_fsstat_loglevel (stat);
3360	break;
3361
3362	case NFS3_FSINFO19:
3363	ll = nfs3_fsstat_loglevel (stat);
3364	break;
3365
3366	case NFS3_PATHCONF20:
3367	ll = nfs3_fsstat_loglevel (stat);
3368	break;
3369
3370	case NFS3_COMMIT21:
3371	ll = nfs3_write_loglevel (stat);
3372	break;
3373
3374	default:
3375	ll = GF_LOG_DEBUG;
3376	break;
3377	}
3378
3379	return ll;
3380	}
3381
3382	void
3383	nfs3_log_common_res (uint32_t xid, int op, nfsstat3 stat, int pstat)
3384	{
3385	char errstr[1024];
3386	int ll = nfs3_loglevel (op, stat);
3387
3388	if (THIS(*__glusterfs_this_location())->ctx->log.loglevel < ll)
3389	return;
3390	nfs3_stat_to_errstr (xid, nfs3op_strings[op].str, stat, pstat, errstr);
3391	gf_log (GF_NFS3, ll, "%s", errstr)do { do { if (0) printf ("%s", errstr); } while (0); _gf_log ( "nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3391, ll, "%s" , errstr); } while (0);
3392	}
3393
3394	void
3395	nfs3_log_readlink_res (uint32_t xid, nfsstat3 stat, int pstat, char *linkpath)
3396	{
3397	char errstr[1024];
3398	int ll = nfs3_loglevel (NFS3_READLINK5, stat);
3399
3400	if (THIS(*__glusterfs_this_location())->ctx->log.loglevel < ll)
3401	return;
3402
3403	nfs3_stat_to_errstr (xid, "READLINK", stat, pstat, errstr);
3404	gf_log (GF_NFS3, ll, "%s, target: %s",do { do { if (0) printf ("%s, target: %s", errstr, linkpath); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__ , 3405, ll, "%s, target: %s", errstr, linkpath); } while (0)
3405	errstr, linkpath)do { do { if (0) printf ("%s, target: %s", errstr, linkpath); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__ , 3405, ll, "%s, target: %s", errstr, linkpath); } while (0);
3406
3407	}
3408
3409	void
3410	nfs3_log_read_res (uint32_t xid, nfsstat3 stat, int pstat, count3 count,
3411	int is_eof, struct iovec *vec, int32_t veccount)
3412	{
3413	char errstr[1024];
3414	int ll = GF_LOG_DEBUG;
3415
3416	ll = nfs3_loglevel (NFS3_READ6, stat);
3417	if (THIS(*__glusterfs_this_location())->ctx->log.loglevel < ll)
3418	return;
3419	nfs3_stat_to_errstr (xid, "READ", stat, pstat, errstr);
3420	if (vec)
3421	gf_log (GF_NFS3, ll, "%s, count: %"PRIu32", is_eof:"do { do { if (0) printf ("%s, count: %""u"", is_eof:" " %d, vector: count: %d, len: %zd" , errstr, count, is_eof, veccount, vec->iov_len); } while ( 0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3423 , ll, "%s, count: %""u"", is_eof:" " %d, vector: count: %d, len: %zd" , errstr, count, is_eof, veccount, vec->iov_len); } while ( 0)
3422	" %d, vector: count: %d, len: %zd", errstr, count,do { do { if (0) printf ("%s, count: %""u"", is_eof:" " %d, vector: count: %d, len: %zd" , errstr, count, is_eof, veccount, vec->iov_len); } while ( 0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3423 , ll, "%s, count: %""u"", is_eof:" " %d, vector: count: %d, len: %zd" , errstr, count, is_eof, veccount, vec->iov_len); } while ( 0)
3423	is_eof, veccount, vec->iov_len)do { do { if (0) printf ("%s, count: %""u"", is_eof:" " %d, vector: count: %d, len: %zd" , errstr, count, is_eof, veccount, vec->iov_len); } while ( 0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3423 , ll, "%s, count: %""u"", is_eof:" " %d, vector: count: %d, len: %zd" , errstr, count, is_eof, veccount, vec->iov_len); } while ( 0);
3424	else
3425	gf_log (GF_NFS3, ll, "%s, count: %"PRIu32", is_eof:"do { do { if (0) printf ("%s, count: %""u"", is_eof:" " %d", errstr , count, is_eof); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3426, ll, "%s, count: %""u"", is_eof:" " %d", errstr, count, is_eof); } while (0)
3426	" %d", errstr, count, is_eof)do { do { if (0) printf ("%s, count: %""u"", is_eof:" " %d", errstr , count, is_eof); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3426, ll, "%s, count: %""u"", is_eof:" " %d", errstr, count, is_eof); } while (0);
3427	}
3428
3429
3430	void
3431	nfs3_log_write_res (uint32_t xid, nfsstat3 stat, int pstat, count3 count,
3432	int stable, uint64_t wverf)
3433	{
3434	char errstr[1024];
3435	int ll = nfs3_loglevel (NFS3_WRITE7, stat);
3436
3437	if (THIS(*__glusterfs_this_location())->ctx->log.loglevel < ll)
3438	return;
3439
3440	nfs3_stat_to_errstr (xid, "WRITE", stat, pstat, errstr);
3441	gf_log (GF_NFS3, ll, "%s, count: %"PRIu32", %s,wverf: %"PRIu64do { do { if (0) printf ("%s, count: %""u"", %s,wverf: %""ll" "u" , errstr, count, (stable == UNSTABLE)?"UNSTABLE":"STABLE" , wverf); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3443, ll, "%s, count: %""u"", %s,wverf: %""ll" "u" , errstr, count, (stable == UNSTABLE)?"UNSTABLE":"STABLE" , wverf); } while (0)
3442	, errstr, count, (stable == UNSTABLE)?"UNSTABLE":"STABLE",do { do { if (0) printf ("%s, count: %""u"", %s,wverf: %""ll" "u" , errstr, count, (stable == UNSTABLE)?"UNSTABLE":"STABLE" , wverf); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3443, ll, "%s, count: %""u"", %s,wverf: %""ll" "u" , errstr, count, (stable == UNSTABLE)?"UNSTABLE":"STABLE" , wverf); } while (0)
3443	wverf)do { do { if (0) printf ("%s, count: %""u"", %s,wverf: %""ll" "u" , errstr, count, (stable == UNSTABLE)?"UNSTABLE":"STABLE" , wverf); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3443, ll, "%s, count: %""u"", %s,wverf: %""ll" "u" , errstr, count, (stable == UNSTABLE)?"UNSTABLE":"STABLE" , wverf); } while (0);
3444	}
3445
3446
3447	void
3448	nfs3_log_newfh_res (uint32_t xid, int op, nfsstat3 stat, int pstat,
3449	struct nfs3_fh *newfh)
3450	{
3451	char errstr[1024];
3452	char fhstr[1024];
3453	int ll = nfs3_loglevel (op, stat);
3454
3455	if (THIS(*__glusterfs_this_location())->ctx->log.loglevel < ll)
3456	return;
3457	nfs3_stat_to_errstr (xid, nfs3op_strings[op].str, stat, pstat, errstr);
3458	nfs3_fh_to_str (newfh, fhstr);
3459
3460	gf_log (GF_NFS3, nfs3_loglevel (op, stat), "%s, %s", errstr, fhstr)do { do { if (0) printf ("%s, %s", errstr, fhstr); } while (0 ); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3460 , nfs3_loglevel (op, stat), "%s, %s", errstr, fhstr); } while (0);
3461	}
3462
3463
3464	void
3465	nfs3_log_readdir_res (uint32_t xid, nfsstat3 stat, int pstat, uint64_t cverf,
3466	count3 count, int is_eof)
3467	{
3468	char errstr[1024];
3469	int ll = nfs3_loglevel (NFS3_READDIR16, stat);
3470
3471	if (THIS(*__glusterfs_this_location())->ctx->log.loglevel < ll)
3472	return;
3473	nfs3_stat_to_errstr (xid, "READDIR", stat, pstat, errstr);
3474	gf_log (GF_NFS3, ll, "%s, count: %"PRIu32", cverf: %"PRIu64do { do { if (0) printf ("%s, count: %""u"", cverf: %""ll" "u" ", is_eof: %d", errstr, count, cverf, is_eof); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3475, ll, "%s, count: %" "u"", cverf: %""ll" "u" ", is_eof: %d", errstr, count, cverf, is_eof); } while (0)
3475	", is_eof: %d", errstr, count, cverf, is_eof)do { do { if (0) printf ("%s, count: %""u"", cverf: %""ll" "u" ", is_eof: %d", errstr, count, cverf, is_eof); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3475, ll, "%s, count: %" "u"", cverf: %""ll" "u" ", is_eof: %d", errstr, count, cverf, is_eof); } while (0);
3476	}
3477
3478
3479	void
3480	nfs3_log_readdirp_res (uint32_t xid, nfsstat3 stat, int pstat, uint64_t cverf,
3481	count3 dircount, count3 maxcount, int is_eof)
3482	{
3483	char errstr[1024];
3484	int ll = nfs3_loglevel (NFS3_READDIRP17, stat);
3485
3486	if (THIS(*__glusterfs_this_location())->ctx->log.loglevel < ll)
3487	return;
3488	nfs3_stat_to_errstr (xid, "READDIRPLUS", stat, pstat, errstr);
3489	gf_log (GF_NFS3, ll, "%s, dircount: %"PRIu32", maxcount: %"do { do { if (0) printf ("%s, dircount: %""u"", maxcount: %" "u" ", cverf: %""ll" "u"", is_eof: %d", errstr, dircount, maxcount , cverf, is_eof); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3491, ll, "%s, dircount: %""u"", maxcount: %" "u"", cverf: %""ll" "u"", is_eof: %d", errstr, dircount, maxcount , cverf, is_eof); } while (0)
3490	PRIu32", cverf: %"PRIu64", is_eof: %d", errstr, dircount,do { do { if (0) printf ("%s, dircount: %""u"", maxcount: %" "u" ", cverf: %""ll" "u"", is_eof: %d", errstr, dircount, maxcount , cverf, is_eof); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3491, ll, "%s, dircount: %""u"", maxcount: %" "u"", cverf: %""ll" "u"", is_eof: %d", errstr, dircount, maxcount , cverf, is_eof); } while (0)
3491	maxcount, cverf, is_eof)do { do { if (0) printf ("%s, dircount: %""u"", maxcount: %" "u" ", cverf: %""ll" "u"", is_eof: %d", errstr, dircount, maxcount , cverf, is_eof); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3491, ll, "%s, dircount: %""u"", maxcount: %" "u"", cverf: %""ll" "u"", is_eof: %d", errstr, dircount, maxcount , cverf, is_eof); } while (0);
3492	}
3493
3494
3495	void
3496	nfs3_log_commit_res (uint32_t xid, nfsstat3 stat, int pstat, uint64_t wverf)
3497	{
3498	char errstr[1024];
3499	int ll = nfs3_loglevel (NFS3_COMMIT21, stat);
3500
3501	if (THIS(*__glusterfs_this_location())->ctx->log.loglevel < ll)
3502	return;
3503	nfs3_stat_to_errstr (xid, "COMMIT", stat, pstat, errstr);
3504	gf_log (GF_NFS3, ll, "%s, wverf: %"PRIu64, errstr, wverf)do { do { if (0) printf ("%s, wverf: %""ll" "u", errstr, wverf ); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__ , 3504, ll, "%s, wverf: %""ll" "u", errstr, wverf); } while ( 0);
3505	}
3506
3507
3508	void
3509	nfs3_log_readdir_call (uint32_t xid, struct nfs3_fh *fh, count3 dircount,
3510	count3 maxcount)
3511	{
3512	char fhstr[1024];
3513
3514	if (THIS(*__glusterfs_this_location())->ctx->log.loglevel < GF_LOG_DEBUG)
3515	return;
3516
3517	nfs3_fh_to_str (fh, fhstr);
3518
3519	if (maxcount == 0)
3520	gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, READDIR: args: %s,"do { do { if (0) printf ("XID: %x, READDIR: args: %s," " count: %d" , xid, fhstr, (uint32_t)dircount); } while (0); _gf_log ("nfs" "-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3521, GF_LOG_DEBUG, "XID: %x, READDIR: args: %s," " count: %d", xid, fhstr, (uint32_t )dircount); } while (0)
3521	" count: %d", xid, fhstr, (uint32_t)dircount)do { do { if (0) printf ("XID: %x, READDIR: args: %s," " count: %d" , xid, fhstr, (uint32_t)dircount); } while (0); _gf_log ("nfs" "-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3521, GF_LOG_DEBUG, "XID: %x, READDIR: args: %s," " count: %d", xid, fhstr, (uint32_t )dircount); } while (0);
3522	else
3523	gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, READDIRPLUS: args: %s,"do { do { if (0) printf ("XID: %x, READDIRPLUS: args: %s," " dircount: %d, maxcount: %d" , xid, fhstr, (uint32_t)dircount, (uint32_t)maxcount); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3525, GF_LOG_DEBUG, "XID: %x, READDIRPLUS: args: %s," " dircount: %d, maxcount: %d" , xid, fhstr, (uint32_t)dircount, (uint32_t)maxcount); } while (0)
3524	" dircount: %d, maxcount: %d", xid, fhstr,do { do { if (0) printf ("XID: %x, READDIRPLUS: args: %s," " dircount: %d, maxcount: %d" , xid, fhstr, (uint32_t)dircount, (uint32_t)maxcount); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3525, GF_LOG_DEBUG, "XID: %x, READDIRPLUS: args: %s," " dircount: %d, maxcount: %d" , xid, fhstr, (uint32_t)dircount, (uint32_t)maxcount); } while (0)
3525	(uint32_t)dircount, (uint32_t)maxcount)do { do { if (0) printf ("XID: %x, READDIRPLUS: args: %s," " dircount: %d, maxcount: %d" , xid, fhstr, (uint32_t)dircount, (uint32_t)maxcount); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3525, GF_LOG_DEBUG, "XID: %x, READDIRPLUS: args: %s," " dircount: %d, maxcount: %d" , xid, fhstr, (uint32_t)dircount, (uint32_t)maxcount); } while (0);
3526	}
3527
3528
3529	int
3530	nfs3_fh_resolve_inode_done (nfs3_call_state_t cs, inode_t inode)
3531	{
3532	int ret = -EFAULT14;
3533
3534	if ((!cs) \|\| (!inode))
3535	return ret;
3536
3537	gf_log (GF_NFS3, GF_LOG_TRACE, "FH inode resolved")do { do { if (0) printf ("FH inode resolved"); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3537, GF_LOG_TRACE , "FH inode resolved"); } while (0);
3538	ret = nfs_inode_loc_fill (inode, &cs->resolvedloc, NFS_RESOLVE_EXIST1);
3539	if (ret < 0) {
3540	gf_log (GF_NFS3, GF_LOG_ERROR, "inode loc fill failed")do { do { if (0) printf ("inode loc fill failed"); } while (0 ); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3540 , GF_LOG_ERROR, "inode loc fill failed"); } while (0);
3541	goto err;
3542	}
3543
3544	nfs3_call_resume (cs)do { if (((cs)) && (cs)->resume_fn) (cs)->resume_fn (cs); } while (0);
3545
3546	err:
3547	return ret;
3548	}
3549
3550
3551	int32_t
3552	nfs3_fh_resolve_entry_lookup_cbk (call_frame_t frame, void cookie,
3553	xlator_t *this, int32_t op_ret,
3554	int32_t op_errno, inode_t *inode,
3555	struct iatt buf, dict_t xattr,
3556	struct iatt *postparent)
3557	{
3558	nfs3_call_state_t cs = NULL((void)0);
3559	inode_t linked_inode = NULL((void)0);
3560
3561	cs = frame->local;
3562	cs->resolve_ret = op_ret;
3563	cs->resolve_errno = op_errno;
3564
3565	if (op_ret == -1) {
3566	gf_log (GF_NFS3, (op_errno == ENOENT ? GF_LOG_TRACE : GF_LOG_ERROR),do { do { if (0) printf ("Lookup failed: %s: %s", cs->resolvedloc .path, strerror (op_errno)); } while (0); _gf_log ("nfs""-nfsv3" , "nfs3-helpers.c", __FUNCTION__, 3568, (op_errno == 2 ? GF_LOG_TRACE : GF_LOG_ERROR), "Lookup failed: %s: %s", cs->resolvedloc .path, strerror (op_errno)); } while (0)
3567	"Lookup failed: %s: %s",do { do { if (0) printf ("Lookup failed: %s: %s", cs->resolvedloc .path, strerror (op_errno)); } while (0); _gf_log ("nfs""-nfsv3" , "nfs3-helpers.c", __FUNCTION__, 3568, (op_errno == 2 ? GF_LOG_TRACE : GF_LOG_ERROR), "Lookup failed: %s: %s", cs->resolvedloc .path, strerror (op_errno)); } while (0)
3568	cs->resolvedloc.path, strerror (op_errno))do { do { if (0) printf ("Lookup failed: %s: %s", cs->resolvedloc .path, strerror (op_errno)); } while (0); _gf_log ("nfs""-nfsv3" , "nfs3-helpers.c", __FUNCTION__, 3568, (op_errno == 2 ? GF_LOG_TRACE : GF_LOG_ERROR), "Lookup failed: %s: %s", cs->resolvedloc .path, strerror (op_errno)); } while (0);
3569	goto err;
3570	} else
3571	gf_log (GF_NFS3, GF_LOG_TRACE, "Entry looked up: %s",do { do { if (0) printf ("Entry looked up: %s", cs->resolvedloc .path); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3572, GF_LOG_TRACE, "Entry looked up: %s", cs ->resolvedloc.path); } while (0)
3572	cs->resolvedloc.path)do { do { if (0) printf ("Entry looked up: %s", cs->resolvedloc .path); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3572, GF_LOG_TRACE, "Entry looked up: %s", cs ->resolvedloc.path); } while (0);
3573
3574	memcpy (&cs->stbuf, buf, sizeof (*buf));
3575	memcpy (&cs->postparent, postparent, sizeof (*postparent));
3576	linked_inode = inode_link (inode, cs->resolvedloc.parent,
3577	cs->resolvedloc.name, buf);
3578	if (linked_inode) {
3579	inode_lookup (linked_inode);
3580	inode_unref (cs->resolvedloc.inode);
3581	cs->resolvedloc.inode = linked_inode;
3582	}
3583	err:
3584	nfs3_call_resume (cs)do { if (((cs)) && (cs)->resume_fn) (cs)->resume_fn (cs); } while (0);
3585	return 0;
3586	}
3587
3588
3589	int32_t
3590	nfs3_fh_resolve_inode_lookup_cbk (call_frame_t frame, void cookie,
3591	xlator_t *this, int32_t op_ret,
3592	int32_t op_errno, inode_t *inode,
3593	struct iatt buf, dict_t xattr,
3594	struct iatt *postparent)
3595	{
3596	nfs3_call_state_t cs = NULL((void)0);
3597	inode_t linked_inode = NULL((void)0);
3598
3599	cs = frame->local;
3600	cs->resolve_ret = op_ret;
3601	cs->resolve_errno = op_errno;
3602
3603	if (op_ret == -1) {
3604	gf_log (GF_NFS3, (op_errno == ENOENT ? GF_LOG_TRACE : GF_LOG_ERROR),do { do { if (0) printf ("Lookup failed: %s: %s", cs->resolvedloc .path, strerror (op_errno)); } while (0); _gf_log ("nfs""-nfsv3" , "nfs3-helpers.c", __FUNCTION__, 3606, (op_errno == 2 ? GF_LOG_TRACE : GF_LOG_ERROR), "Lookup failed: %s: %s", cs->resolvedloc .path, strerror (op_errno)); } while (0)
3605	"Lookup failed: %s: %s",do { do { if (0) printf ("Lookup failed: %s: %s", cs->resolvedloc .path, strerror (op_errno)); } while (0); _gf_log ("nfs""-nfsv3" , "nfs3-helpers.c", __FUNCTION__, 3606, (op_errno == 2 ? GF_LOG_TRACE : GF_LOG_ERROR), "Lookup failed: %s: %s", cs->resolvedloc .path, strerror (op_errno)); } while (0)
3606	cs->resolvedloc.path, strerror (op_errno))do { do { if (0) printf ("Lookup failed: %s: %s", cs->resolvedloc .path, strerror (op_errno)); } while (0); _gf_log ("nfs""-nfsv3" , "nfs3-helpers.c", __FUNCTION__, 3606, (op_errno == 2 ? GF_LOG_TRACE : GF_LOG_ERROR), "Lookup failed: %s: %s", cs->resolvedloc .path, strerror (op_errno)); } while (0);
3607	nfs3_call_resume (cs)do { if (((cs)) && (cs)->resume_fn) (cs)->resume_fn (cs); } while (0);
3608	goto err;
3609	}
3610
3611	memcpy (&cs->stbuf, buf, sizeof(*buf));
3612	memcpy (&cs->postparent, buf, sizeof(*postparent));
3613	linked_inode = inode_link (inode, cs->resolvedloc.parent,
3614	cs->resolvedloc.name, buf);
3615	if (linked_inode) {
3616	inode_lookup (linked_inode);
3617	inode_unref (cs->resolvedloc.inode);
3618	cs->resolvedloc.inode = linked_inode;
3619	}
3620
3621	/* If it is an entry lookup and we landed in the callback for hard
3622	* inode resolution, it means the parent inode was not available and
3623	* had to be resolved first. Now that is done, lets head back into
3624	* entry resolution.
3625	*/
3626	if (cs->resolventry)
3627	nfs3_fh_resolve_entry_hard (cs);
3628	else
3629	nfs3_call_resume (cs)do { if (((cs)) && (cs)->resume_fn) (cs)->resume_fn (cs); } while (0);
3630	err:
3631	return 0;
3632	}
3633
3634
3635
3636	/* Needs no extra argument since it knows that the fh to be resolved is in
3637	* resolvefh and that it needs to start looking from the root.
3638	*/
3639	int
3640	nfs3_fh_resolve_inode_hard (nfs3_call_state_t *cs)
3641	{
3642	int ret = -EFAULT14;
3643	nfs_user_t nfu = {0, };
3644
3645	if (!cs)
3646	return ret;
3647
3648	gf_log (GF_NFS3, GF_LOG_TRACE, "FH hard resolution for: gfid 0x%s",do { do { if (0) printf ("FH hard resolution for: gfid 0x%s", uuid_utoa (cs->resolvefh.gfid)); } while (0); _gf_log ("nfs" "-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3649, GF_LOG_TRACE, "FH hard resolution for: gfid 0x%s", uuid_utoa (cs->resolvefh .gfid)); } while (0)
3649	uuid_utoa (cs->resolvefh.gfid))do { do { if (0) printf ("FH hard resolution for: gfid 0x%s", uuid_utoa (cs->resolvefh.gfid)); } while (0); _gf_log ("nfs" "-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3649, GF_LOG_TRACE, "FH hard resolution for: gfid 0x%s", uuid_utoa (cs->resolvefh .gfid)); } while (0);
3650	cs->hardresolved = 1;
3651	nfs_loc_wipe (&cs->resolvedloc);
3652	ret = nfs_gfid_loc_fill (cs->vol->itable, cs->resolvefh.gfid,
3653	&cs->resolvedloc, NFS_RESOLVE_CREATE2);
3654	if (ret < 0) {
3655	gf_log (GF_NFS3, GF_LOG_ERROR, "Failed to fill loc using gfid: "do { do { if (0) printf ("Failed to fill loc using gfid: " "%s" , strerror (-ret)); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3656, GF_LOG_ERROR, "Failed to fill loc using gfid: " "%s", strerror (-ret)); } while (0)
3656	"%s", strerror (-ret))do { do { if (0) printf ("Failed to fill loc using gfid: " "%s" , strerror (-ret)); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3656, GF_LOG_ERROR, "Failed to fill loc using gfid: " "%s", strerror (-ret)); } while (0);
3657	goto out;
3658	}
3659
3660	nfs_user_root_create (&nfu);
3661	ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
3662	nfs3_fh_resolve_inode_lookup_cbk, cs);
3663
3664	out:
3665	return ret;
3666	}
3667
3668
3669	int
3670	nfs3_fh_resolve_entry_hard (nfs3_call_state_t *cs)
3671	{
3672	int ret = -EFAULT14;
3673	nfs_user_t nfu = {0, };
3674
3675	if (!cs)
3676	return ret;
3677
3678	nfs_loc_wipe (&cs->resolvedloc);
3679	nfs_user_root_create (&nfu);
3680	gf_log (GF_NFS3, GF_LOG_TRACE, "FH hard resolution: gfid: %s "do { do { if (0) printf ("FH hard resolution: gfid: %s " ", entry: %s" , uuid_utoa (cs->resolvefh.gfid), cs->resolventry); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3682, GF_LOG_TRACE, "FH hard resolution: gfid: %s " ", entry: %s" , uuid_utoa (cs->resolvefh.gfid), cs->resolventry); } while (0)
3681	", entry: %s", uuid_utoa (cs->resolvefh.gfid),do { do { if (0) printf ("FH hard resolution: gfid: %s " ", entry: %s" , uuid_utoa (cs->resolvefh.gfid), cs->resolventry); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3682, GF_LOG_TRACE, "FH hard resolution: gfid: %s " ", entry: %s" , uuid_utoa (cs->resolvefh.gfid), cs->resolventry); } while (0)
3682	cs->resolventry)do { do { if (0) printf ("FH hard resolution: gfid: %s " ", entry: %s" , uuid_utoa (cs->resolvefh.gfid), cs->resolventry); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3682, GF_LOG_TRACE, "FH hard resolution: gfid: %s " ", entry: %s" , uuid_utoa (cs->resolvefh.gfid), cs->resolventry); } while (0);
3683
3684	ret = nfs_entry_loc_fill (cs->vol->itable, cs->resolvefh.gfid,
3685	cs->resolventry, &cs->resolvedloc,
3686	NFS_RESOLVE_CREATE2);
3687
3688	if (ret == -2) {
3689	gf_log (GF_NFS3, GF_LOG_TRACE, "Entry needs lookup: %s",do { do { if (0) printf ("Entry needs lookup: %s", cs->resolvedloc .path); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3690, GF_LOG_TRACE, "Entry needs lookup: %s", cs->resolvedloc.path); } while (0)
3690	cs->resolvedloc.path)do { do { if (0) printf ("Entry needs lookup: %s", cs->resolvedloc .path); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3690, GF_LOG_TRACE, "Entry needs lookup: %s", cs->resolvedloc.path); } while (0);
3691	/* If the NFS op is lookup, let the resume callback
3692	* handle the sending of the lookup fop. Similarly,
3693	* if the NFS op is create, let the create call
3694	* go ahead in the resume callback so that an EEXIST gets
3695	* handled at posix without an extra fop at this point.
3696	*/
3697	if (nfs3_lookup_op (cs)((((cs->req)->procnum)) == 3) \|\|
3698	(nfs3_create_op (cs)((((cs->req)->procnum)) == 8) && !nfs3_create_exclusive_op (cs)((cs)->createmode == EXCLUSIVE))) {
3699	cs->lookuptype = GF_NFS3_FRESH;
3700	cs->resolve_ret = 0;
3701	nfs3_call_resume (cs)do { if (((cs)) && (cs)->resume_fn) (cs)->resume_fn (cs); } while (0);
3702	} else {
3703	cs->hardresolved = 1;
3704	nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
3705	nfs3_fh_resolve_entry_lookup_cbk, cs);
3706	}
3707	ret = 0;
3708	} else if (ret == -1) {
3709	gf_log (GF_NFS3, GF_LOG_TRACE, "Entry needs parent lookup: %s",do { do { if (0) printf ("Entry needs parent lookup: %s", cs-> resolvedloc.path); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3710, GF_LOG_TRACE, "Entry needs parent lookup: %s" , cs->resolvedloc.path); } while (0)
3710	cs->resolvedloc.path)do { do { if (0) printf ("Entry needs parent lookup: %s", cs-> resolvedloc.path); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3710, GF_LOG_TRACE, "Entry needs parent lookup: %s" , cs->resolvedloc.path); } while (0);
3711	ret = nfs3_fh_resolve_inode_hard (cs);
3712	} else if (ret == 0) {
3713	cs->resolve_ret = 0;
3714	nfs3_call_resume (cs)do { if (((cs)) && (cs)->resume_fn) (cs)->resume_fn (cs); } while (0);
3715	}
3716
3717	return ret;
3718	}
3719
3720	int
3721	nfs3_fh_resolve_inode (nfs3_call_state_t *cs)
3722	{
3723	inode_t inode = NULL((void)0);
3724	int ret = -EFAULT14;
3725
3726	if (!cs)
3727	return ret;
3728
3729	gf_log (GF_NFS3, GF_LOG_TRACE, "FH needs inode resolution")do { do { if (0) printf ("FH needs inode resolution"); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3729, GF_LOG_TRACE, "FH needs inode resolution"); } while (0 );
3730	uuid_copy (cs->resolvedloc.gfid, cs->resolvefh.gfid);
3731	inode = inode_find (cs->vol->itable, cs->resolvefh.gfid);
3732	if (!inode)
3733	ret = nfs3_fh_resolve_inode_hard (cs);
3734	else
3735	ret = nfs3_fh_resolve_inode_done (cs, inode);
3736
3737	if (inode)
3738	inode_unref (inode);
3739
3740	return ret;
3741	}
3742
3743	int
3744	nfs3_fh_resolve_entry (nfs3_call_state_t *cs)
3745	{
3746	int ret = -EFAULT14;
3747
3748	if (!cs)
3749	return ret;
3750
3751	return nfs3_fh_resolve_entry_hard (cs);
3752	}
3753
3754
3755	int
3756	nfs3_fh_resolve_resume (nfs3_call_state_t *cs)
3757	{
3758	int ret = -EFAULT14;
3759
3760	if (!cs)
3761	return ret;
3762
3763	if (cs->resolve_ret < 0)
3764	goto err_resume_call;
3765
3766	if (!cs->resolventry)
3767	ret = nfs3_fh_resolve_inode (cs);
3768	else
3769	ret = nfs3_fh_resolve_entry (cs);
3770
3771	err_resume_call:
3772	if (ret < 0) {
3773	cs->resolve_ret = -1;
3774	cs->resolve_errno = EFAULT14;
3775	nfs3_call_resume (cs)do { if (((cs)) && (cs)->resume_fn) (cs)->resume_fn (cs); } while (0);
3776	ret = 0;
3777	}
3778
3779	return ret;
3780	}
3781
3782
3783	int32_t
3784	nfs3_fh_resolve_root_lookup_cbk (call_frame_t frame, void cookie,
3785	xlator_t *this, int32_t op_ret,
3786	int32_t op_errno, inode_t *inode,
3787	struct iatt buf, dict_t xattr,
3788	struct iatt *postparent)
3789	{
3790	nfs3_call_state_t cs = NULL((void)0);
3791
3792	cs = frame->local;
3793	cs->resolve_ret = op_ret;
3794	cs->resolve_errno = op_errno;
3795
3796	if (op_ret == -1) {
3797	gf_log (GF_NFS3, GF_LOG_ERROR, "Root lookup failed: %s",do { do { if (0) printf ("Root lookup failed: %s", strerror ( op_errno)); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3798, GF_LOG_ERROR, "Root lookup failed: %s", strerror (op_errno)); } while (0)
3798	strerror (op_errno))do { do { if (0) printf ("Root lookup failed: %s", strerror ( op_errno)); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3798, GF_LOG_ERROR, "Root lookup failed: %s", strerror (op_errno)); } while (0);
3799	goto err;
3800	} else
3801	gf_log (GF_NFS3, GF_LOG_TRACE, "Root looked up: %s",do { do { if (0) printf ("Root looked up: %s", cs->resolvedloc .path); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3802, GF_LOG_TRACE, "Root looked up: %s", cs-> resolvedloc.path); } while (0)
3802	cs->resolvedloc.path)do { do { if (0) printf ("Root looked up: %s", cs->resolvedloc .path); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3802, GF_LOG_TRACE, "Root looked up: %s", cs-> resolvedloc.path); } while (0);
3803
3804	nfs3_set_root_looked_up (cs->nfs3state, &cs->resolvefh);
3805	err:
3806	nfs3_fh_resolve_resume (cs);
3807	return 0;
3808	}
3809
3810
3811	int
3812	nfs3_fh_resolve_root (nfs3_call_state_t *cs)
3813	{
3814	int ret = -EFAULT14;
3815	nfs_user_t nfu = {0, };
3816
3817	if (!cs)
3818	return ret;
3819
3820	if (nfs3_is_root_looked_up (cs->nfs3state, &cs->resolvefh)) {
3821	ret = nfs3_fh_resolve_resume (cs);
3822	goto out;
3823	}
3824
3825	nfs_user_root_create (&nfu);
3826	gf_log (GF_NFS3, GF_LOG_TRACE, "Root needs lookup")do { do { if (0) printf ("Root needs lookup"); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c", __FUNCTION__, 3826, GF_LOG_TRACE , "Root needs lookup"); } while (0);
3827	ret = nfs_root_loc_fill (cs->vol->itable, &cs->resolvedloc);
3828	if (ret < 0) {
3829	gf_log (GF_NFS3, GF_LOG_ERROR, "Failed to lookup root from itable: %s",do { do { if (0) printf ("Failed to lookup root from itable: %s" , strerror (-ret)); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3830, GF_LOG_ERROR, "Failed to lookup root from itable: %s" , strerror (-ret)); } while (0)
3830	strerror (-ret))do { do { if (0) printf ("Failed to lookup root from itable: %s" , strerror (-ret)); } while (0); _gf_log ("nfs""-nfsv3", "nfs3-helpers.c" , __FUNCTION__, 3830, GF_LOG_ERROR, "Failed to lookup root from itable: %s" , strerror (-ret)); } while (0);
3831	goto out;
3832	}
3833
3834	ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
3835	nfs3_fh_resolve_root_lookup_cbk, cs);
3836
3837	out:
3838	return ret;
3839	}
3840
3841
3842	int
3843	nfs3_fh_resolve_and_resume (nfs3_call_state_t cs, struct nfs3_fh fh,
3844	char *entry, nfs3_resume_fn_t resum_fn)
3845	{
3846	int ret = -EFAULT14;
3847
3848	if ((!cs) \|\| (!fh))
3849	return ret;
3850
3851	cs->resume_fn = resum_fn;
3852	cs->resolvefh = *fh;
3853	cs->hashidx = 0;
3854
3855	/* Check if the resolution is:
3856	* a. fh resolution
3857	*
3858	* or
3859	*
3860	* b. (fh, basename) resolution
3861	*/
3862	if (entry) { /* b */
3863	cs->resolventry = gf_strdup (entry);
3864	if (!cs->resolventry)
3865	goto err;
3866	}
3867
3868	ret = nfs3_fh_resolve_root (cs);
3869	err:
3870	return ret;
3871	}