File: | xlators/nfs/server/src/nfs3-helpers.c |
Location: | line 1129, column 25 |
Description: | Value stored to 'dirwcc' during its initialization is never read |
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, }; |
1129 | wcc_data dirwcc = {{0}, }; |
Value stored to 'dirwcc' during its initialization is never read | |
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 | } |