glusterfs

1
/*
2
  Copyright (c) 2017 Red Hat, Inc. <http://www.redhat.com>
3
  This file is part of GlusterFS.
4

5
  This file is licensed to you under your choice of the GNU Lesser
6
  General Public License, version 3 or any later version (LGPLv3 or
7
  later), or the GNU General Public License, version 2 (GPLv2), in all
8
  cases as published by the Free Software Foundation.
9
*/
10

11
#include "server.h"
12
#include "server-helpers.h"
13
#include "rpc-common-xdr.h"
14
#include "glusterfs3.h"
15
#include <glusterfs/compat-errno.h>
16
#include "server-messages.h"
17
#include <glusterfs/default-args.h>
18
#include "server-common.h"
19

20
#ifdef BUILD_GNFS
21
#include "xdr-nfs3.h"
22
#endif
23

24
#define SERVER_REQ_SET_ERROR(req, ret)                                         \
25
    do {                                                                       \
26
        rpcsvc_request_seterr(req, GARBAGE_ARGS);                              \
27
        ret = RPCSVC_ACTOR_ERROR;                                              \
28
    } while (0)
29

30
static int
31
_gf_server_log_setxattr_failure(dict_t *d, char *k, data_t *v, void *tmp)
32
{
33
    server_state_t *state = NULL;
34
    call_frame_t *frame = NULL;
35

36
    frame = tmp;
37
    state = CALL_STATE(frame);
38

39
    gf_msg(THIS->name, GF_LOG_INFO, 0, PS_MSG_SETXATTR_INFO,
40
           "%" PRId64
41
           ": SETXATTR %s (%s) ==> %s, client: %s, "
42
           "error-xlator: %s",
43
           frame->root->unique, state->loc.path, uuid_utoa(state->resolve.gfid),
44
           k, STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
45
    return 0;
46
}
47

48
void
49
forget_inode_if_no_dentry(inode_t *inode)
50
{
51
    if (!inode) {
52
        return;
53
    }
54

55
    if (!inode_has_dentry(inode))
56
        inode_forget(inode, 0);
57

58
    return;
59
}
60

61
static void
62
set_resolve_gfid(client_t *client, uuid_t resolve_gfid, char *on_wire_gfid)
63
{
64
    if (client->subdir_mount && __is_root_gfid((unsigned char *)on_wire_gfid)) {
65
        /* set the subdir_mount's gfid for proper resolution */
66
        gf_uuid_copy(resolve_gfid, client->subdir_gfid);
67
    } else {
68
        memcpy(resolve_gfid, on_wire_gfid, 16);
69
    }
70
}
71

72
static int
73
rpc_receive_common(rpcsvc_request_t *req, call_frame_t **fr,
74
                   server_state_t **st, ssize_t *xdrlen, void *args,
75
                   void *xdrfn, glusterfs_fop_t fop)
76
{
77
    int ret = -1;
78
    ssize_t len = 0;
79

80
    len = xdr_to_generic(req->msg[0], args, (xdrproc_t)xdrfn);
81
    if (len < 0) {
82
        /* failed to decode msg; */
83
        SERVER_REQ_SET_ERROR(req, ret);
84
        goto out;
85
    }
86

87
    /* Few fops use the xdr size to get the vector sizes */
88
    if (xdrlen)
89
        *xdrlen = len;
90

91
    *fr = get_frame_from_request(req);
92
    if (!(*fr)) {
93
        /* something wrong, mostly no memory */
94
        SERVER_REQ_SET_ERROR(req, ret);
95
        goto out;
96
    }
97
    (*fr)->root->op = fop;
98

99
    *st = CALL_STATE((*fr));
100
    if (!(*fr)->root->client->bound_xl) {
101
        /* auth failure, mostly setvolume is not successful */
102
        SERVER_REQ_SET_ERROR(req, ret);
103
        goto out;
104
    }
105

106
    if (!(*fr)->root->client->bound_xl->itable) {
107
        /* inode_table is not allocated successful in server_setvolume */
108
        SERVER_REQ_SET_ERROR(req, ret);
109
        goto out;
110
    }
111

112
    ret = 0;
113

114
out:
115
    return ret;
116
}
117

118
/* Callback function section */
119
int
120
server4_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
121
                   int32_t op_ret, int32_t op_errno, struct statvfs *buf,
122
                   dict_t *xdata)
123
{
124
    gfx_statfs_rsp rsp = {
125
        0,
126
    };
127
    rpcsvc_request_t *req = NULL;
128

129
    dict_to_xdr(xdata, &rsp.xdata);
130

131
    if (op_ret < 0) {
132
        gf_smsg(this->name, GF_LOG_WARNING, op_errno, PS_MSG_STATFS,
133
                "frame=%" PRId64, frame->root->unique, "client=%s",
134
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
135
                STACK_ERR_XL_NAME(frame->root), NULL);
136
        goto out;
137
    }
138

139
    server4_post_statfs(&rsp, buf);
140

141
out:
142
    rsp.op_ret = op_ret;
143
    rsp.op_errno = gf_errno_to_error(op_errno);
144

145
    req = frame->local;
146
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
147
                        (xdrproc_t)xdr_gfx_statfs_rsp);
148

149
    GF_FREE(rsp.xdata.pairs.pairs_val);
150

151
    return 0;
152
}
153

154
int
155
server4_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
156
                   int32_t op_ret, int32_t op_errno, inode_t *inode,
157
                   struct iatt *stbuf, dict_t *xdata, struct iatt *postparent)
158
{
159
    rpcsvc_request_t *req = NULL;
160
    server_state_t *state = NULL;
161
    loc_t fresh_loc = {
162
        0,
163
    };
164
    gfx_common_2iatt_rsp rsp = {
165
        0,
166
    };
167

168
    state = CALL_STATE(frame);
169

170
    if (state->is_revalidate == 1 && op_ret == -1) {
171
        state->is_revalidate = 2;
172
        loc_copy(&fresh_loc, &state->loc);
173
        inode_unref(fresh_loc.inode);
174
        fresh_loc.inode = server_inode_new(state->itable, fresh_loc.gfid);
175

176
        STACK_WIND(frame, server4_lookup_cbk, frame->root->client->bound_xl,
177
                   frame->root->client->bound_xl->fops->lookup, &fresh_loc,
178
                   state->xdata);
179

180
        loc_wipe(&fresh_loc);
181
        return 0;
182
    }
183

184
    gfx_stat_from_iattx(&rsp.poststat, postparent);
185

186
    dict_to_xdr(xdata, &rsp.xdata);
187

188
    if (op_ret) {
189
        if (state->is_revalidate && op_errno == ENOENT) {
190
            if (!__is_root_gfid(state->resolve.gfid)) {
191
                inode_unlink(state->loc.inode, state->loc.parent,
192
                             state->loc.name);
193
                /**
194
                 * If the entry is not present, then just
195
                 * unlinking the associated dentry is not
196
                 * suffecient. This condition should be
197
                 * treated as unlink of the entry. So along
198
                 * with deleting the entry, its also important
199
                 * to forget the inode for it (if the dentry
200
                 * being considered was the last dentry).
201
                 * Otherwise it might lead to inode leak.
202
                 * It also might lead to wrong decisions being
203
                 * taken if the future lookups on this inode are
204
                 * successful since they are able to find the
205
                 * inode in the inode table (at least gfid based
206
                 * lookups will be successful, if the lookup
207
                 * is a soft lookup)
208
                 */
209
                forget_inode_if_no_dentry(state->loc.inode);
210
            }
211
        }
212
        goto out;
213
    }
214

215
    server4_post_lookup(&rsp, frame, state, inode, stbuf, xdata);
216
out:
217
    rsp.op_ret = op_ret;
218
    rsp.op_errno = gf_errno_to_error(op_errno);
219

220
    if (op_ret) {
221
        if (state->resolve.bname) {
222
            gf_smsg(this->name, fop_log_level(GF_FOP_LOOKUP, op_errno),
223
                    op_errno, PS_MSG_LOOKUP_INFO, "frame=%" PRId64,
224
                    frame->root->unique, "path=%s", state->loc.path,
225
                    "uuid_utoa=%s", uuid_utoa(state->resolve.pargfid),
226
                    "bname=%s", state->resolve.bname, "client=%s",
227
                    STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
228
                    STACK_ERR_XL_NAME(frame->root), NULL);
229
        } else {
230
            gf_smsg(this->name, fop_log_level(GF_FOP_LOOKUP, op_errno),
231
                    op_errno, PS_MSG_LOOKUP_INFO, "frame=%" PRId64,
232
                    frame->root->unique, "path=%s", state->loc.path,
233
                    "uuid_utoa=%s", uuid_utoa(state->resolve.gfid), "client=%s",
234
                    STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
235
                    STACK_ERR_XL_NAME(frame->root), NULL);
236
        }
237
    }
238

239
    req = frame->local;
240
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
241
                        (xdrproc_t)xdr_gfx_common_2iatt_rsp);
242

243
    GF_FREE(rsp.xdata.pairs.pairs_val);
244

245
    return 0;
246
}
247

248
int
249
server4_lease_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
250
                  int32_t op_ret, int32_t op_errno, struct gf_lease *lease,
251
                  dict_t *xdata)
252
{
253
    gfx_lease_rsp rsp = {
254
        0,
255
    };
256
    rpcsvc_request_t *req = NULL;
257
    server_state_t *state = NULL;
258

259
    dict_to_xdr(xdata, &rsp.xdata);
260

261
    if (op_ret) {
262
        state = CALL_STATE(frame);
263
        gf_smsg(this->name, fop_log_level(GF_FOP_LEASE, op_errno), op_errno,
264
                PS_MSG_LK_INFO, "frame=%" PRId64, frame->root->unique,
265
                "path=%s", state->loc.path, "uuid_utoa=%s",
266
                uuid_utoa(state->resolve.gfid), "client=%s",
267
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
268
                STACK_ERR_XL_NAME(frame->root), NULL);
269
    }
270
    server4_post_lease(&rsp, lease);
271

272
    rsp.op_ret = op_ret;
273
    rsp.op_errno = gf_errno_to_error(op_errno);
274

275
    req = frame->local;
276
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
277
                        (xdrproc_t)xdr_gfx_lease_rsp);
278

279
    GF_FREE(rsp.xdata.pairs.pairs_val);
280

281
    return 0;
282
}
283

284
int
285
server4_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
286
               int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
287
               dict_t *xdata)
288
{
289
    gfx_lk_rsp rsp = {
290
        0,
291
    };
292
    rpcsvc_request_t *req = NULL;
293
    server_state_t *state = NULL;
294

295
    dict_to_xdr(xdata, &rsp.xdata);
296

297
    if (op_ret) {
298
        state = CALL_STATE(frame);
299
        gf_smsg(this->name, fop_log_level(GF_FOP_LK, op_errno), op_errno,
300
                PS_MSG_LK_INFO, "frame=%" PRId64, frame->root->unique,
301
                "fd_no=%" PRId64, state->resolve.fd_no, "uuid_utoa=%s",
302
                uuid_utoa(state->resolve.gfid), "client=%s",
303
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
304
                STACK_ERR_XL_NAME(frame->root), NULL);
305
        goto out;
306
    }
307

308
    server4_post_lk(this, &rsp, lock);
309
out:
310
    rsp.op_ret = op_ret;
311
    rsp.op_errno = gf_errno_to_error(op_errno);
312

313
    req = frame->local;
314
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
315
                        (xdrproc_t)xdr_gfx_lk_rsp);
316

317
    GF_FREE(rsp.xdata.pairs.pairs_val);
318

319
    return 0;
320
}
321

322
int
323
server4_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
324
                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
325
{
326
    gfx_common_rsp rsp = {
327
        0,
328
    };
329
    server_state_t *state = NULL;
330
    rpcsvc_request_t *req = NULL;
331

332
    dict_to_xdr(xdata, &rsp.xdata);
333

334
    state = CALL_STATE(frame);
335

336
    if (op_ret < 0) {
337
        gf_smsg(this->name, fop_log_level(GF_FOP_INODELK, op_errno), op_errno,
338
                PS_MSG_INODELK_INFO, "frame=%" PRId64, frame->root->unique,
339
                "path=%s", state->loc.path, "uuuid_utoa=%s",
340
                uuid_utoa(state->resolve.gfid), "client=%s",
341
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
342
                STACK_ERR_XL_NAME(frame->root), NULL);
343
        goto out;
344
    }
345

346
out:
347
    rsp.op_ret = op_ret;
348
    rsp.op_errno = gf_errno_to_error(op_errno);
349

350
    req = frame->local;
351
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
352
                        (xdrproc_t)xdr_gfx_common_rsp);
353

354
    GF_FREE(rsp.xdata.pairs.pairs_val);
355

356
    return 0;
357
}
358

359
int
360
server4_finodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
361
                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
362
{
363
    gfx_common_rsp rsp = {
364
        0,
365
    };
366
    server_state_t *state = NULL;
367
    rpcsvc_request_t *req = NULL;
368

369
    dict_to_xdr(xdata, &rsp.xdata);
370

371
    state = CALL_STATE(frame);
372

373
    if (op_ret < 0) {
374
        gf_smsg(this->name, fop_log_level(GF_FOP_FINODELK, op_errno), op_errno,
375
                PS_MSG_INODELK_INFO, "frame=%" PRId64, frame->root->unique,
376
                "FINODELK_fd_no=%" PRId64, state->resolve.fd_no, "uuid_utoa=%s",
377
                uuid_utoa(state->resolve.gfid), "client=%s",
378
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
379
                STACK_ERR_XL_NAME(frame->root), NULL);
380
        goto out;
381
    }
382

383
out:
384
    rsp.op_ret = op_ret;
385
    rsp.op_errno = gf_errno_to_error(op_errno);
386

387
    req = frame->local;
388
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
389
                        (xdrproc_t)xdr_gfx_common_rsp);
390

391
    GF_FREE(rsp.xdata.pairs.pairs_val);
392

393
    return 0;
394
}
395

396
int
397
server4_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
398
                    int32_t op_ret, int32_t op_errno, dict_t *xdata)
399
{
400
    gfx_common_rsp rsp = {
401
        0,
402
    };
403
    server_state_t *state = NULL;
404
    rpcsvc_request_t *req = NULL;
405

406
    dict_to_xdr(xdata, &rsp.xdata);
407

408
    state = CALL_STATE(frame);
409

410
    if (op_ret < 0) {
411
        gf_smsg(this->name, fop_log_level(GF_FOP_ENTRYLK, op_errno), op_errno,
412
                PS_MSG_ENTRYLK_INFO, "frame=%" PRId64, frame->root->unique,
413
                "path=%s", state->loc.path, "uuid_utoa=%s",
414
                uuid_utoa(state->resolve.gfid), "client=%s",
415
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
416
                STACK_ERR_XL_NAME(frame->root), NULL);
417
        goto out;
418
    }
419

420
out:
421
    rsp.op_ret = op_ret;
422
    rsp.op_errno = gf_errno_to_error(op_errno);
423

424
    req = frame->local;
425
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
426
                        (xdrproc_t)xdr_gfx_common_rsp);
427

428
    GF_FREE(rsp.xdata.pairs.pairs_val);
429

430
    return 0;
431
}
432

433
int
434
server4_fentrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
435
                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
436
{
437
    gfx_common_rsp rsp = {
438
        0,
439
    };
440
    server_state_t *state = NULL;
441
    rpcsvc_request_t *req = NULL;
442

443
    dict_to_xdr(xdata, &rsp.xdata);
444

445
    state = CALL_STATE(frame);
446

447
    if (op_ret < 0) {
448
        gf_smsg(this->name, fop_log_level(GF_FOP_FENTRYLK, op_errno), op_errno,
449
                PS_MSG_ENTRYLK_INFO, "frame=%" PRId64, frame->root->unique,
450
                "FENTRYLK_fd_no=%" PRId64, state->resolve.fd_no, "uuid_utoa=%s",
451
                uuid_utoa(state->resolve.gfid), "client=%s",
452
                STACK_CLIENT_NAME(frame->root), "error-xlator: %s",
453
                STACK_ERR_XL_NAME(frame->root), NULL);
454
        goto out;
455
    }
456

457
out:
458
    rsp.op_ret = op_ret;
459
    rsp.op_errno = gf_errno_to_error(op_errno);
460

461
    req = frame->local;
462
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
463
                        (xdrproc_t)xdr_gfx_common_rsp);
464

465
    GF_FREE(rsp.xdata.pairs.pairs_val);
466

467
    return 0;
468
}
469

470
int
471
server4_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
472
                   int32_t op_ret, int32_t op_errno, dict_t *xdata)
473
{
474
    gfx_common_rsp rsp = {
475
        0,
476
    };
477
    rpcsvc_request_t *req = NULL;
478
    server_state_t *state = NULL;
479

480
    dict_to_xdr(xdata, &rsp.xdata);
481

482
    if (op_ret) {
483
        state = CALL_STATE(frame);
484
        gf_smsg(this->name, GF_LOG_INFO, op_errno, PS_MSG_ACCESS_INFO,
485
                "frame=%" PRId64, frame->root->unique, "path=%s",
486
                (state->loc.path) ? state->loc.path : "", "uuid_utoa=%s",
487
                uuid_utoa(state->resolve.gfid), "client=%s",
488
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
489
                STACK_ERR_XL_NAME(frame->root), NULL);
490
        goto out;
491
    }
492

493
out:
494
    rsp.op_ret = op_ret;
495
    rsp.op_errno = gf_errno_to_error(op_errno);
496

497
    req = frame->local;
498
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
499
                        (xdrproc_t)xdr_gfx_common_rsp);
500

501
    GF_FREE(rsp.xdata.pairs.pairs_val);
502

503
    return 0;
504
}
505

506
int
507
server4_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
508
                  int32_t op_ret, int32_t op_errno, struct iatt *preparent,
509
                  struct iatt *postparent, dict_t *xdata)
510
{
511
    gfx_common_2iatt_rsp rsp = {
512
        0,
513
    };
514
    server_state_t *state = NULL;
515
    rpcsvc_request_t *req = NULL;
516

517
    dict_to_xdr(xdata, &rsp.xdata);
518

519
    state = CALL_STATE(frame);
520

521
    if (op_ret) {
522
        gf_smsg(this->name, GF_LOG_INFO, op_errno, PS_MSG_DIR_INFO,
523
                "frame=%" PRId64, frame->root->unique, "RMDIR_pat=%s",
524
                (state->loc.path) ? state->loc.path : "", "uuid_utoa=%s",
525
                uuid_utoa(state->resolve.pargfid), "bname=%s",
526
                state->resolve.bname, "client=%s",
527
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
528
                STACK_ERR_XL_NAME(frame->root), NULL);
529
        goto out;
530
    }
531

532
    server4_post_entry_remove(state, &rsp, preparent, postparent);
533

534
out:
535
    rsp.op_ret = op_ret;
536
    rsp.op_errno = gf_errno_to_error(op_errno);
537

538
    req = frame->local;
539
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
540
                        (xdrproc_t)xdr_gfx_common_2iatt_rsp);
541

542
    GF_FREE(rsp.xdata.pairs.pairs_val);
543

544
    return 0;
545
}
546

547
int
548
server4_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
549
                  int32_t op_ret, int32_t op_errno, inode_t *inode,
550
                  struct iatt *stbuf, struct iatt *preparent,
551
                  struct iatt *postparent, dict_t *xdata)
552
{
553
    gfx_common_3iatt_rsp rsp = {
554
        0,
555
    };
556
    server_state_t *state = NULL;
557
    rpcsvc_request_t *req = NULL;
558

559
    dict_to_xdr(xdata, &rsp.xdata);
560

561
    state = CALL_STATE(frame);
562

563
    if (op_ret < 0) {
564
        gf_smsg(this->name, fop_log_level(GF_FOP_MKDIR, op_errno), op_errno,
565
                PS_MSG_DIR_INFO, "frame=%" PRId64, frame->root->unique,
566
                "MKDIR_path=%s", (state->loc.path) ? state->loc.path : "",
567
                "uuid_utoa=%s", uuid_utoa(state->resolve.pargfid), "bname=%s",
568
                state->resolve.bname, "client=%s",
569
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
570
                STACK_ERR_XL_NAME(frame->root), NULL);
571
        goto out;
572
    }
573

574
    server4_post_common_3iatt(state, &rsp, inode, stbuf, preparent, postparent);
575
out:
576
    rsp.op_ret = op_ret;
577
    rsp.op_errno = gf_errno_to_error(op_errno);
578

579
    req = frame->local;
580
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
581
                        (xdrproc_t)xdr_gfx_common_3iatt_rsp);
582

583
    GF_FREE(rsp.xdata.pairs.pairs_val);
584

585
    return 0;
586
}
587

588
int
589
server4_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
590
                  int32_t op_ret, int32_t op_errno, inode_t *inode,
591
                  struct iatt *stbuf, struct iatt *preparent,
592
                  struct iatt *postparent, dict_t *xdata)
593
{
594
    gfx_common_3iatt_rsp rsp = {
595
        0,
596
    };
597
    server_state_t *state = NULL;
598
    rpcsvc_request_t *req = NULL;
599

600
    dict_to_xdr(xdata, &rsp.xdata);
601

602
    state = CALL_STATE(frame);
603

604
    if (op_ret < 0) {
605
        gf_smsg(this->name, fop_log_level(GF_FOP_MKNOD, op_errno), op_errno,
606
                PS_MSG_MKNOD_INFO, "frame=%" PRId64, frame->root->unique,
607
                "path=%s", state->loc.path, "uuid_utoa=%s",
608
                uuid_utoa(state->resolve.pargfid), "bname=%s",
609
                state->resolve.bname, "client=%s",
610
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
611
                STACK_ERR_XL_NAME(frame->root), NULL);
612
        goto out;
613
    }
614

615
    server4_post_common_3iatt(state, &rsp, inode, stbuf, preparent, postparent);
616
out:
617
    rsp.op_ret = op_ret;
618
    rsp.op_errno = gf_errno_to_error(op_errno);
619

620
    req = frame->local;
621
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
622
                        (xdrproc_t)xdr_gfx_common_3iatt_rsp);
623

624
    GF_FREE(rsp.xdata.pairs.pairs_val);
625

626
    return 0;
627
}
628

629
int
630
server4_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
631
                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
632
{
633
    gfx_common_rsp rsp = {
634
        0,
635
    };
636
    server_state_t *state = NULL;
637
    rpcsvc_request_t *req = NULL;
638

639
    dict_to_xdr(xdata, &rsp.xdata);
640

641
    if (op_ret < 0) {
642
        state = CALL_STATE(frame);
643
        gf_smsg(this->name, fop_log_level(GF_FOP_FSYNCDIR, op_errno), op_errno,
644
                PS_MSG_DIR_INFO, "frame=%" PRId64, frame->root->unique,
645
                "FSYNCDIR_fd_no=%" PRId64, state->resolve.fd_no, "uuid_utoa=%s",
646
                uuid_utoa(state->resolve.gfid), "client=%s",
647
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
648
                STACK_ERR_XL_NAME(frame->root), NULL);
649
        goto out;
650
    }
651

652
out:
653
    rsp.op_ret = op_ret;
654
    rsp.op_errno = gf_errno_to_error(op_errno);
655

656
    req = frame->local;
657
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
658
                        (xdrproc_t)xdr_gfx_common_rsp);
659

660
    GF_FREE(rsp.xdata.pairs.pairs_val);
661

662
    return 0;
663
}
664

665
int
666
server4_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
667
                    int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
668
                    dict_t *xdata)
669
{
670
    gfx_readdir_rsp rsp = {
671
        0,
672
    };
673
    server_state_t *state = NULL;
674
    rpcsvc_request_t *req = NULL;
675
    int ret = 0;
676

677
    dict_to_xdr(xdata, &rsp.xdata);
678

679
    if (op_ret < 0) {
680
        state = CALL_STATE(frame);
681
        gf_smsg(this->name, fop_log_level(GF_FOP_READDIR, op_errno), op_errno,
682
                PS_MSG_DIR_INFO, "frame=%" PRId64, frame->root->unique,
683
                "READDIR_fd_no=%" PRId64, state->resolve.fd_no, "uuid_utoa=%s",
684
                uuid_utoa(state->resolve.gfid), "client=%s",
685
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
686
                STACK_ERR_XL_NAME(frame->root), NULL);
687
        goto out;
688
    }
689

690
    /* (op_ret == 0) is valid, and means EOF */
691
    if (op_ret) {
692
        ret = server4_post_readdir(&rsp, entries);
693
        if (ret == -1) {
694
            op_ret = -1;
695
            op_errno = ENOMEM;
696
            goto out;
697
        }
698
    }
699

700
out:
701
    rsp.op_ret = op_ret;
702
    rsp.op_errno = gf_errno_to_error(op_errno);
703

704
    req = frame->local;
705
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
706
                        (xdrproc_t)xdr_gfx_readdir_rsp_custom);
707

708
    GF_FREE(rsp.xdata.pairs.pairs_val);
709

710
    readdir_rsp_cleanup_v2(&rsp);
711

712
    return 0;
713
}
714

715
int
716
server4_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
717
                    int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
718
{
719
    server_state_t *state = NULL;
720
    rpcsvc_request_t *req = NULL;
721
    gfx_open_rsp rsp = {
722
        0,
723
    };
724
    uint64_t fd_no = 0;
725

726
    dict_to_xdr(xdata, &rsp.xdata);
727

728
    if (op_ret < 0) {
729
        state = CALL_STATE(frame);
730
        gf_smsg(this->name, fop_log_level(GF_FOP_OPENDIR, op_errno), op_errno,
731
                PS_MSG_DIR_INFO, "frame=%" PRId64, frame->root->unique,
732
                "OPENDIR_path=%s", (state->loc.path) ? state->loc.path : "",
733
                "uuid_utoa=%s", uuid_utoa(state->resolve.gfid), "client=%s",
734
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
735
                STACK_ERR_XL_NAME(frame->root), NULL);
736
        goto out;
737
    }
738

739
    op_ret = server4_post_open(frame, this, &rsp, fd);
740
    if (op_ret)
741
        goto out;
742
out:
743
    if (op_ret)
744
        rsp.fd = fd_no;
745
    rsp.op_ret = op_ret;
746
    rsp.op_errno = gf_errno_to_error(op_errno);
747

748
    req = frame->local;
749
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
750
                        (xdrproc_t)xdr_gfx_open_rsp);
751

752
    GF_FREE(rsp.xdata.pairs.pairs_val);
753

754
    return 0;
755
}
756

757
int
758
server4_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
759
                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
760
{
761
    gfx_common_rsp rsp = {
762
        0,
763
    };
764
    rpcsvc_request_t *req = NULL;
765
    server_state_t *state = NULL;
766
    gf_loglevel_t loglevel = GF_LOG_NONE;
767

768
    dict_to_xdr(xdata, &rsp.xdata);
769

770
    if (op_ret == -1) {
771
        state = CALL_STATE(frame);
772
        if (ENODATA == op_errno || ENOATTR == op_errno)
773
            loglevel = GF_LOG_DEBUG;
774
        else
775
            loglevel = GF_LOG_INFO;
776

777
        gf_smsg(this->name, loglevel, op_errno, PS_MSG_REMOVEXATTR_INFO,
778
                "frame=%" PRId64, frame->root->unique, "path=%s",
779
                state->loc.path, "uuid_utoa=%s", uuid_utoa(state->resolve.gfid),
780
                "name=%s", state->name, "client=%s",
781
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
782
                STACK_ERR_XL_NAME(frame->root), NULL);
783
        goto out;
784
    }
785

786
out:
787
    rsp.op_ret = op_ret;
788
    rsp.op_errno = gf_errno_to_error(op_errno);
789

790
    req = frame->local;
791
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
792
                        (xdrproc_t)xdr_gfx_common_rsp);
793

794
    GF_FREE(rsp.xdata.pairs.pairs_val);
795

796
    return 0;
797
}
798

799
int
800
server4_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
801
                         int32_t op_ret, int32_t op_errno, dict_t *xdata)
802
{
803
    gfx_common_rsp rsp = {
804
        0,
805
    };
806
    rpcsvc_request_t *req = NULL;
807
    server_state_t *state = NULL;
808

809
    dict_to_xdr(xdata, &rsp.xdata);
810

811
    if (op_ret == -1) {
812
        state = CALL_STATE(frame);
813
        gf_smsg(this->name, fop_log_level(GF_FOP_FREMOVEXATTR, op_errno),
814
                op_errno, PS_MSG_REMOVEXATTR_INFO, "frame=%" PRId64,
815
                frame->root->unique, "FREMOVEXATTR_fd_no%" PRId64,
816
                state->resolve.fd_no, "uuid_utoa=%s",
817
                uuid_utoa(state->resolve.gfid), "name=%s", state->name,
818
                "client=%s", STACK_CLIENT_NAME(frame->root), "error-xlator: %s",
819
                STACK_ERR_XL_NAME(frame->root), NULL);
820
        goto out;
821
    }
822

823
out:
824
    rsp.op_ret = op_ret;
825
    rsp.op_errno = gf_errno_to_error(op_errno);
826

827
    req = frame->local;
828
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
829
                        (xdrproc_t)xdr_gfx_common_rsp);
830

831
    GF_FREE(rsp.xdata.pairs.pairs_val);
832

833
    return 0;
834
}
835

836
int
837
server4_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
838
                     int32_t op_ret, int32_t op_errno, dict_t *dict,
839
                     dict_t *xdata)
840
{
841
    gfx_common_dict_rsp rsp = {
842
        0,
843
    };
844
    rpcsvc_request_t *req = NULL;
845
    server_state_t *state = NULL;
846

847
    dict_to_xdr(xdata, &rsp.xdata);
848

849
    if (op_ret == -1) {
850
        state = CALL_STATE(frame);
851
        gf_smsg(this->name, fop_log_level(GF_FOP_GETXATTR, op_errno), op_errno,
852
                PS_MSG_GETXATTR_INFO, "frame=%" PRId64, frame->root->unique,
853
                "path=%s", state->loc.path, "uuid_utoa=%s",
854
                uuid_utoa(state->resolve.gfid), "name=%s", state->name,
855
                "client=%s", STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
856
                STACK_ERR_XL_NAME(frame->root), NULL);
857
        goto out;
858
    }
859

860
    dict_to_xdr(dict, &rsp.dict);
861
out:
862
    rsp.op_ret = op_ret;
863
    rsp.op_errno = gf_errno_to_error(op_errno);
864

865
    req = frame->local;
866
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
867
                        (xdrproc_t)xdr_gfx_common_dict_rsp);
868

869
    GF_FREE(rsp.dict.pairs.pairs_val);
870

871
    GF_FREE(rsp.xdata.pairs.pairs_val);
872

873
    return 0;
874
}
875

876
int
877
server4_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
878
                      int32_t op_ret, int32_t op_errno, dict_t *dict,
879
                      dict_t *xdata)
880
{
881
    gfx_common_dict_rsp rsp = {
882
        0,
883
    };
884
    server_state_t *state = NULL;
885
    rpcsvc_request_t *req = NULL;
886

887
    dict_to_xdr(xdata, &rsp.xdata);
888

889
    if (op_ret == -1) {
890
        state = CALL_STATE(frame);
891
        gf_smsg(this->name, fop_log_level(GF_FOP_FGETXATTR, op_errno), op_errno,
892
                PS_MSG_GETXATTR_INFO, "frame=%" PRId64, frame->root->unique,
893
                "FGETXATTR_fd_no=%" PRId64, state->resolve.fd_no,
894
                "uuid_utoa=%s", uuid_utoa(state->resolve.gfid), "name=%s",
895
                state->name, "client=%s", STACK_CLIENT_NAME(frame->root),
896
                "error-xlator=%s", STACK_ERR_XL_NAME(frame->root), NULL);
897
        goto out;
898
    }
899

900
    dict_to_xdr(dict, &rsp.dict);
901
out:
902
    rsp.op_ret = op_ret;
903
    rsp.op_errno = gf_errno_to_error(op_errno);
904

905
    req = frame->local;
906
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
907
                        (xdrproc_t)xdr_gfx_common_dict_rsp);
908

909
    GF_FREE(rsp.dict.pairs.pairs_val);
910

911
    GF_FREE(rsp.xdata.pairs.pairs_val);
912

913
    return 0;
914
}
915

916
int
917
server4_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
918
                     int32_t op_ret, int32_t op_errno, dict_t *xdata)
919
{
920
    gfx_common_rsp rsp = {
921
        0,
922
    };
923
    rpcsvc_request_t *req = NULL;
924
    server_state_t *state = NULL;
925

926
    dict_to_xdr(xdata, &rsp.xdata);
927

928
    state = CALL_STATE(frame);
929

930
    if (op_ret == -1) {
931
        if (op_errno != ENOTSUP)
932
            dict_foreach(state->dict, _gf_server_log_setxattr_failure, frame);
933

934
        if (op_errno == ENOTSUP) {
935
            gf_msg_debug(THIS->name, op_errno, "Failed");
936
        } else {
937
            gf_smsg(THIS->name, GF_LOG_INFO, op_errno, PS_MSG_SETXATTR_INFO,
938
                    "client=%s", STACK_CLIENT_NAME(frame->root),
939
                    "error-xlator=%s", STACK_ERR_XL_NAME(frame->root), NULL);
940
        }
941
        goto out;
942
    }
943

944
    if (dict_get_sizen(state->dict, GF_NAMESPACE_KEY)) {
945
        /* This inode onwards we will set namespace */
946
        gf_msg(THIS->name, GF_LOG_DEBUG, 0, PS_MSG_SETXATTR_INFO,
947
               "client=%s, path=%s", STACK_CLIENT_NAME(frame->root),
948
               state->loc.path);
949
        inode_set_namespace_inode(state->loc.inode, state->loc.inode);
950
    }
951

952
out:
953
    rsp.op_ret = op_ret;
954
    rsp.op_errno = gf_errno_to_error(op_errno);
955

956
    req = frame->local;
957
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
958
                        (xdrproc_t)xdr_gfx_common_rsp);
959

960
    GF_FREE(rsp.xdata.pairs.pairs_val);
961

962
    return 0;
963
}
964

965
int
966
server4_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
967
                      int32_t op_ret, int32_t op_errno, dict_t *xdata)
968
{
969
    gfx_common_rsp rsp = {
970
        0,
971
    };
972
    rpcsvc_request_t *req = NULL;
973
    server_state_t *state = NULL;
974

975
    dict_to_xdr(xdata, &rsp.xdata);
976

977
    if (op_ret == -1) {
978
        state = CALL_STATE(frame);
979
        if (op_errno != ENOTSUP) {
980
            dict_foreach(state->dict, _gf_server_log_setxattr_failure, frame);
981
        }
982
        if (op_errno == ENOTSUP) {
983
            gf_msg_debug(THIS->name, op_errno, "Failed");
984
        } else {
985
            gf_smsg(THIS->name, GF_LOG_INFO, op_errno, PS_MSG_SETXATTR_INFO,
986
                    "client=%s", STACK_CLIENT_NAME(frame->root),
987
                    "error-xlator=%s", STACK_ERR_XL_NAME(frame->root), NULL);
988
        }
989
        goto out;
990
    }
991

992
out:
993
    rsp.op_ret = op_ret;
994
    rsp.op_errno = gf_errno_to_error(op_errno);
995

996
    req = frame->local;
997
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
998
                        (xdrproc_t)xdr_gfx_common_rsp);
999

1000
    GF_FREE(rsp.xdata.pairs.pairs_val);
1001

1002
    return 0;
1003
}
1004

1005
int
1006
server4_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1007
                   int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
1008
                   struct iatt *preoldparent, struct iatt *postoldparent,
1009
                   struct iatt *prenewparent, struct iatt *postnewparent,
1010
                   dict_t *xdata)
1011
{
1012
    gfx_rename_rsp rsp = {
1013
        0,
1014
    };
1015
    server_state_t *state = NULL;
1016
    rpcsvc_request_t *req = NULL;
1017
    char oldpar_str[50] = {
1018
        0,
1019
    };
1020
    char newpar_str[50] = {
1021
        0,
1022
    };
1023

1024
    dict_to_xdr(xdata, &rsp.xdata);
1025

1026
    state = CALL_STATE(frame);
1027

1028
    if (op_ret == -1) {
1029
        uuid_utoa_r(state->resolve.pargfid, oldpar_str);
1030
        uuid_utoa_r(state->resolve2.pargfid, newpar_str);
1031
        gf_smsg(this->name, GF_LOG_INFO, op_errno, PS_MSG_RENAME_INFO,
1032
                "frame=%" PRId64, frame->root->unique, "loc.path=%s",
1033
                state->loc.path, "oldpar_str=%s", oldpar_str, "resolve-name=%s",
1034
                state->resolve.bname, "loc2.path=%s", state->loc2.path,
1035
                "newpar_str=%s", newpar_str, "resolve2=%s",
1036
                state->resolve2.bname, "client=%s",
1037
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1038
                STACK_ERR_XL_NAME(frame->root), NULL);
1039
        goto out;
1040
    }
1041

1042
    server4_post_rename(frame, state, &rsp, stbuf, preoldparent, postoldparent,
1043
                        prenewparent, postnewparent);
1044
out:
1045
    rsp.op_ret = op_ret;
1046
    rsp.op_errno = gf_errno_to_error(op_errno);
1047

1048
    req = frame->local;
1049
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1050
                        (xdrproc_t)xdr_gfx_rename_rsp);
1051

1052
    GF_FREE(rsp.xdata.pairs.pairs_val);
1053

1054
    return 0;
1055
}
1056

1057
int
1058
server4_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1059
                   int32_t op_ret, int32_t op_errno, struct iatt *preparent,
1060
                   struct iatt *postparent, dict_t *xdata)
1061
{
1062
    gfx_common_2iatt_rsp rsp = {
1063
        0,
1064
    };
1065
    server_state_t *state = NULL;
1066
    rpcsvc_request_t *req = NULL;
1067

1068
    dict_to_xdr(xdata, &rsp.xdata);
1069

1070
    state = CALL_STATE(frame);
1071

1072
    if (op_ret) {
1073
        gf_smsg(this->name, fop_log_level(GF_FOP_UNLINK, op_errno), op_errno,
1074
                PS_MSG_LINK_INFO, "frame=%" PRId64, frame->root->unique,
1075
                "UNLINK_path=%s", state->loc.path, "uuid_utoa=%s",
1076
                uuid_utoa(state->resolve.pargfid), "bname=%s",
1077
                state->resolve.bname, "client=%s",
1078
                STACK_CLIENT_NAME(frame->root), "error-xlator: %s",
1079
                STACK_ERR_XL_NAME(frame->root), NULL);
1080
        goto out;
1081
    }
1082

1083
    /* TODO: log gfid of the inodes */
1084
    gf_msg_trace(frame->root->client->bound_xl->name, 0,
1085
                 "%" PRId64
1086
                 ": "
1087
                 "UNLINK_CBK %s",
1088
                 frame->root->unique, state->loc.name);
1089

1090
    server4_post_entry_remove(state, &rsp, preparent, postparent);
1091

1092
out:
1093
    rsp.op_ret = op_ret;
1094
    rsp.op_errno = gf_errno_to_error(op_errno);
1095

1096
    req = frame->local;
1097
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1098
                        (xdrproc_t)xdr_gfx_common_2iatt_rsp);
1099

1100
    GF_FREE(rsp.xdata.pairs.pairs_val);
1101

1102
    return 0;
1103
}
1104

1105
int
1106
server4_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1107
                    int32_t op_ret, int32_t op_errno, inode_t *inode,
1108
                    struct iatt *stbuf, struct iatt *preparent,
1109
                    struct iatt *postparent, dict_t *xdata)
1110
{
1111
    gfx_common_3iatt_rsp rsp = {
1112
        0,
1113
    };
1114
    server_state_t *state = NULL;
1115
    rpcsvc_request_t *req = NULL;
1116

1117
    dict_to_xdr(xdata, &rsp.xdata);
1118

1119
    state = CALL_STATE(frame);
1120

1121
    if (op_ret < 0) {
1122
        gf_smsg(this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
1123
                "frame=%" PRId64, frame->root->unique, "SYMLINK_path= %s",
1124
                (state->loc.path) ? state->loc.path : "", "uuid_utoa=%s",
1125
                uuid_utoa(state->resolve.pargfid), "bname=%s",
1126
                state->resolve.bname, "client=%s",
1127
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1128
                STACK_ERR_XL_NAME(frame->root), NULL);
1129
        goto out;
1130
    }
1131

1132
    server4_post_common_3iatt(state, &rsp, inode, stbuf, preparent, postparent);
1133

1134
out:
1135
    rsp.op_ret = op_ret;
1136
    rsp.op_errno = gf_errno_to_error(op_errno);
1137

1138
    req = frame->local;
1139
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1140
                        (xdrproc_t)xdr_gfx_common_3iatt_rsp);
1141

1142
    GF_FREE(rsp.xdata.pairs.pairs_val);
1143

1144
    return 0;
1145
}
1146

1147
int
1148
server4_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1149
                 int32_t op_ret, int32_t op_errno, inode_t *inode,
1150
                 struct iatt *stbuf, struct iatt *preparent,
1151
                 struct iatt *postparent, dict_t *xdata)
1152
{
1153
    gfx_common_3iatt_rsp rsp = {
1154
        0,
1155
    };
1156
    server_state_t *state = NULL;
1157
    rpcsvc_request_t *req = NULL;
1158
    char gfid_str[50] = {
1159
        0,
1160
    };
1161
    char newpar_str[50] = {
1162
        0,
1163
    };
1164

1165
    dict_to_xdr(xdata, &rsp.xdata);
1166

1167
    state = CALL_STATE(frame);
1168

1169
    if (op_ret) {
1170
        uuid_utoa_r(state->resolve.gfid, gfid_str);
1171
        uuid_utoa_r(state->resolve2.pargfid, newpar_str);
1172

1173
        gf_smsg(this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
1174
                "frame=%" PRId64, frame->root->unique, "LINK_path=%s",
1175
                state->loc.path, "gfid_str=%s", gfid_str, "newpar_str=%s",
1176
                newpar_str, "resolve2.bname=%s", state->resolve2.bname,
1177
                "client=%s", STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1178
                STACK_ERR_XL_NAME(frame->root), NULL);
1179
        goto out;
1180
    }
1181

1182
    server4_post_link(state, &rsp, inode, stbuf, preparent, postparent);
1183

1184
out:
1185
    rsp.op_ret = op_ret;
1186
    rsp.op_errno = gf_errno_to_error(op_errno);
1187

1188
    req = frame->local;
1189
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1190
                        (xdrproc_t)xdr_gfx_common_3iatt_rsp);
1191

1192
    GF_FREE(rsp.xdata.pairs.pairs_val);
1193

1194
    return 0;
1195
}
1196

1197
int
1198
server4_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1199
                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
1200
                     struct iatt *postbuf, dict_t *xdata)
1201
{
1202
    gfx_common_2iatt_rsp rsp = {
1203
        0,
1204
    };
1205
    server_state_t *state = NULL;
1206
    rpcsvc_request_t *req = NULL;
1207

1208
    dict_to_xdr(xdata, &rsp.xdata);
1209

1210
    if (op_ret) {
1211
        state = CALL_STATE(frame);
1212
        gf_smsg(this->name, GF_LOG_INFO, op_errno, PS_MSG_TRUNCATE_INFO,
1213
                "frame=%" PRId64, frame->root->unique, "TRUNCATE_path=%s",
1214
                state->loc.path, "uuid_utoa=%s", uuid_utoa(state->resolve.gfid),
1215
                "client=%s", STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1216
                STACK_ERR_XL_NAME(frame->root), NULL);
1217
        goto out;
1218
    }
1219

1220
    server4_post_common_2iatt(&rsp, prebuf, postbuf);
1221

1222
out:
1223
    rsp.op_ret = op_ret;
1224
    rsp.op_errno = gf_errno_to_error(op_errno);
1225

1226
    req = frame->local;
1227
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1228
                        (xdrproc_t)xdr_gfx_common_2iatt_rsp);
1229

1230
    GF_FREE(rsp.xdata.pairs.pairs_val);
1231

1232
    return 0;
1233
}
1234

1235
int
1236
server4_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1237
                  int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
1238
                  dict_t *xdata)
1239
{
1240
    gfx_common_iatt_rsp rsp = {
1241
        0,
1242
    };
1243
    server_state_t *state = NULL;
1244
    rpcsvc_request_t *req = NULL;
1245

1246
    dict_to_xdr(xdata, &rsp.xdata);
1247

1248
    state = CALL_STATE(frame);
1249
    if (op_ret) {
1250
        gf_smsg(this->name, fop_log_level(GF_FOP_FSTAT, op_errno), op_errno,
1251
                PS_MSG_STAT_INFO, "frame=%" PRId64, frame->root->unique,
1252
                "FSTAT_fd_no=%" PRId64, state->resolve.fd_no, "uuid_utoa=%s",
1253
                uuid_utoa(state->resolve.gfid), "client=%s",
1254
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1255
                STACK_ERR_XL_NAME(frame->root), NULL);
1256
        goto out;
1257
    }
1258

1259
    server4_post_common_iatt(state, &rsp, stbuf);
1260

1261
out:
1262
    rsp.op_ret = op_ret;
1263
    rsp.op_errno = gf_errno_to_error(op_errno);
1264

1265
    req = frame->local;
1266
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1267
                        (xdrproc_t)xdr_gfx_common_iatt_rsp);
1268

1269
    GF_FREE(rsp.xdata.pairs.pairs_val);
1270

1271
    return 0;
1272
}
1273

1274
int
1275
server4_ftruncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1276
                      int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
1277
                      struct iatt *postbuf, dict_t *xdata)
1278
{
1279
    gfx_common_2iatt_rsp rsp = {0};
1280
    server_state_t *state = NULL;
1281
    rpcsvc_request_t *req = NULL;
1282

1283
    dict_to_xdr(xdata, &rsp.xdata);
1284

1285
    if (op_ret) {
1286
        state = CALL_STATE(frame);
1287
        gf_smsg(this->name, fop_log_level(GF_FOP_FTRUNCATE, op_errno), op_errno,
1288
                PS_MSG_TRUNCATE_INFO, "frame=%" PRId64, frame->root->unique,
1289
                "FTRUNCATE_fd_no=%" PRId64, state->resolve.fd_no,
1290
                "uuid_utoa=%s", uuid_utoa(state->resolve.gfid), "client=%s",
1291
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1292
                STACK_ERR_XL_NAME(frame->root), NULL);
1293
        goto out;
1294
    }
1295

1296
    server4_post_common_2iatt(&rsp, prebuf, postbuf);
1297

1298
out:
1299
    rsp.op_ret = op_ret;
1300
    rsp.op_errno = gf_errno_to_error(op_errno);
1301

1302
    req = frame->local;
1303
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1304
                        (xdrproc_t)xdr_gfx_common_2iatt_rsp);
1305

1306
    GF_FREE(rsp.xdata.pairs.pairs_val);
1307

1308
    return 0;
1309
}
1310

1311
int
1312
server4_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1313
                  int32_t op_ret, int32_t op_errno, dict_t *xdata)
1314
{
1315
    gfx_common_rsp rsp = {
1316
        0,
1317
    };
1318
    server_state_t *state = NULL;
1319
    rpcsvc_request_t *req = NULL;
1320

1321
    dict_to_xdr(xdata, &rsp.xdata);
1322

1323
    if (op_ret < 0) {
1324
        state = CALL_STATE(frame);
1325
        gf_smsg(this->name, fop_log_level(GF_FOP_FLUSH, op_errno), op_errno,
1326
                PS_MSG_FLUSH_INFO, "frame=%" PRId64, frame->root->unique,
1327
                "FLUSH_fd_no=%" PRId64, state->resolve.fd_no, "uuid_utoa=%s",
1328
                uuid_utoa(state->resolve.gfid), "client=%s",
1329
                STACK_CLIENT_NAME(frame->root), "error-xlator: %s",
1330
                STACK_ERR_XL_NAME(frame->root), NULL);
1331
        goto out;
1332
    }
1333

1334
out:
1335
    rsp.op_ret = op_ret;
1336
    rsp.op_errno = gf_errno_to_error(op_errno);
1337

1338
    req = frame->local;
1339
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1340
                        (xdrproc_t)xdr_gfx_common_rsp);
1341

1342
    GF_FREE(rsp.xdata.pairs.pairs_val);
1343

1344
    return 0;
1345
}
1346

1347
int
1348
server4_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1349
                  int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
1350
                  struct iatt *postbuf, dict_t *xdata)
1351
{
1352
    gfx_common_2iatt_rsp rsp = {
1353
        0,
1354
    };
1355
    server_state_t *state = NULL;
1356
    rpcsvc_request_t *req = NULL;
1357

1358
    dict_to_xdr(xdata, &rsp.xdata);
1359

1360
    if (op_ret < 0) {
1361
        state = CALL_STATE(frame);
1362
        gf_smsg(this->name, fop_log_level(GF_FOP_FSYNC, op_errno), op_errno,
1363
                PS_MSG_SYNC_INFO, "frame=%" PRId64, frame->root->unique,
1364
                "FSYNC_fd_no=%" PRId64, state->resolve.fd_no, "uuid_utoa=%s",
1365
                uuid_utoa(state->resolve.gfid), "client=%s",
1366
                STACK_CLIENT_NAME(frame->root), "error-xlator: %s",
1367
                STACK_ERR_XL_NAME(frame->root), NULL);
1368
        goto out;
1369
    }
1370

1371
    server4_post_common_2iatt(&rsp, prebuf, postbuf);
1372

1373
out:
1374
    rsp.op_ret = op_ret;
1375
    rsp.op_errno = gf_errno_to_error(op_errno);
1376

1377
    req = frame->local;
1378
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1379
                        (xdrproc_t)xdr_gfx_common_2iatt_rsp);
1380

1381
    GF_FREE(rsp.xdata.pairs.pairs_val);
1382

1383
    return 0;
1384
}
1385

1386
int
1387
server4_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1388
                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
1389
                   struct iatt *postbuf, dict_t *xdata)
1390
{
1391
    gfx_common_2iatt_rsp rsp = {
1392
        0,
1393
    };
1394
    server_state_t *state = NULL;
1395
    rpcsvc_request_t *req = NULL;
1396

1397
    dict_to_xdr(xdata, &rsp.xdata);
1398

1399
    if (op_ret < 0) {
1400
        state = CALL_STATE(frame);
1401
        gf_smsg(this->name, fop_log_level(GF_FOP_WRITE, op_errno), op_errno,
1402
                PS_MSG_WRITE_INFO, "frame=%" PRId64, frame->root->unique,
1403
                "WRITEV_fd_no=%" PRId64, state->resolve.fd_no, "uuid_utoa=%s",
1404
                uuid_utoa(state->resolve.gfid), "client=%s",
1405
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1406
                STACK_ERR_XL_NAME(frame->root), NULL);
1407
        goto out;
1408
    }
1409

1410
    server4_post_common_2iatt(&rsp, prebuf, postbuf);
1411

1412
out:
1413
    rsp.op_ret = op_ret;
1414
    rsp.op_errno = gf_errno_to_error(op_errno);
1415

1416
    req = frame->local;
1417
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1418
                        (xdrproc_t)xdr_gfx_common_2iatt_rsp);
1419

1420
    GF_FREE(rsp.xdata.pairs.pairs_val);
1421

1422
    return 0;
1423
}
1424

1425
int
1426
server4_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1427
                  int32_t op_ret, int32_t op_errno, struct iovec *vector,
1428
                  int32_t count, struct iatt *stbuf, struct iobref *iobref,
1429
                  dict_t *xdata)
1430
{
1431
    gfx_read_rsp rsp = {
1432
        0,
1433
    };
1434
    server_state_t *state = NULL;
1435
    rpcsvc_request_t *req = NULL;
1436

1437
#ifdef GF_TESTING_IO_XDATA
1438
    {
1439
        int ret = 0;
1440
        if (!xdata)
1441
            xdata = dict_new();
1442

1443
        ret = dict_set_str(xdata, "testing-the-xdata-key",
1444
                           "testing-xdata-value");
1445
    }
1446
#endif
1447
    dict_to_xdr(xdata, &rsp.xdata);
1448

1449
    if (op_ret < 0) {
1450
        state = CALL_STATE(frame);
1451
        gf_smsg(this->name, fop_log_level(GF_FOP_READ, op_errno), op_errno,
1452
                PS_MSG_READ_INFO, "frame=%" PRId64, frame->root->unique,
1453
                "READV_fd_no=%" PRId64, state->resolve.fd_no, "uuid_utoa=%s",
1454
                uuid_utoa(state->resolve.gfid), "client=%s",
1455
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1456
                STACK_ERR_XL_NAME(frame->root), NULL);
1457
        goto out;
1458
    }
1459

1460
    server4_post_readv(&rsp, stbuf, op_ret);
1461

1462
out:
1463
    rsp.op_ret = op_ret;
1464
    rsp.op_errno = gf_errno_to_error(op_errno);
1465

1466
    req = frame->local;
1467
    server_submit_reply(frame, req, &rsp, vector, count, iobref,
1468
                        (xdrproc_t)xdr_gfx_read_rsp);
1469

1470
    GF_FREE(rsp.xdata.pairs.pairs_val);
1471

1472
    return 0;
1473
}
1474

1475
int
1476
server4_rchecksum_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1477
                      int32_t op_ret, int32_t op_errno, uint32_t weak_checksum,
1478
                      uint8_t *strong_checksum, dict_t *xdata)
1479
{
1480
    gfx_rchecksum_rsp rsp = {
1481
        0,
1482
    };
1483
    rpcsvc_request_t *req = NULL;
1484
    server_state_t *state = NULL;
1485

1486
    dict_to_xdr(xdata, &rsp.xdata);
1487

1488
    if (op_ret < 0) {
1489
        state = CALL_STATE(frame);
1490
        gf_smsg(this->name, fop_log_level(GF_FOP_RCHECKSUM, op_errno), op_errno,
1491
                PS_MSG_CHKSUM_INFO, "frame=%" PRId64, frame->root->unique,
1492
                "RCHECKSUM_fd_no=%" PRId64, state->resolve.fd_no,
1493
                "uuid_utoa=%s", uuid_utoa(state->resolve.gfid), "client=%s",
1494
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1495
                STACK_ERR_XL_NAME(frame->root), NULL);
1496
        goto out;
1497
    }
1498

1499
    server4_post_rchecksum(&rsp, weak_checksum, strong_checksum);
1500
out:
1501
    rsp.op_ret = op_ret;
1502
    rsp.op_errno = gf_errno_to_error(op_errno);
1503

1504
    req = frame->local;
1505
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1506
                        (xdrproc_t)xdr_gfx_rchecksum_rsp);
1507

1508
    GF_FREE(rsp.xdata.pairs.pairs_val);
1509

1510
    return 0;
1511
}
1512

1513
int
1514
server4_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1515
                 int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
1516
{
1517
    server_state_t *state = NULL;
1518
    rpcsvc_request_t *req = NULL;
1519
    gfx_open_rsp rsp = {
1520
        0,
1521
    };
1522

1523
    dict_to_xdr(xdata, &rsp.xdata);
1524

1525
    if (op_ret < 0) {
1526
        state = CALL_STATE(frame);
1527
        gf_smsg(this->name, fop_log_level(GF_FOP_OPEN, op_errno), op_errno,
1528
                PS_MSG_OPEN_INFO, "frame=%" PRId64, frame->root->unique,
1529
                "OPEN_path=%s", state->loc.path, "uuid_utoa=%s",
1530
                uuid_utoa(state->resolve.gfid), "client=%s",
1531
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1532
                STACK_ERR_XL_NAME(frame->root), NULL);
1533
        goto out;
1534
    }
1535

1536
    op_ret = server4_post_open(frame, this, &rsp, fd);
1537
    if (op_ret)
1538
        goto out;
1539
out:
1540
    rsp.op_ret = op_ret;
1541
    rsp.op_errno = gf_errno_to_error(op_errno);
1542

1543
    req = frame->local;
1544
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1545
                        (xdrproc_t)xdr_gfx_open_rsp);
1546
    GF_FREE(rsp.xdata.pairs.pairs_val);
1547

1548
    return 0;
1549
}
1550

1551
int
1552
server4_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1553
                   int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
1554
                   struct iatt *stbuf, struct iatt *preparent,
1555
                   struct iatt *postparent, dict_t *xdata)
1556
{
1557
    server_state_t *state = NULL;
1558
    rpcsvc_request_t *req = NULL;
1559
    uint64_t fd_no = 0;
1560
    gfx_create_rsp rsp = {
1561
        0,
1562
    };
1563

1564
    dict_to_xdr(xdata, &rsp.xdata);
1565

1566
    state = CALL_STATE(frame);
1567

1568
    if (op_ret < 0) {
1569
        gf_smsg(
1570
            this->name, GF_LOG_INFO, op_errno, PS_MSG_CREATE_INFO,
1571
            "frame=%" PRId64, frame->root->unique, "path=%s", state->loc.path,
1572
            "uuid_utoa=%s", uuid_utoa(state->resolve.pargfid), "bname=%s",
1573
            state->resolve.bname, "client=%s", STACK_CLIENT_NAME(frame->root),
1574
            "error-xlator=%s", STACK_ERR_XL_NAME(frame->root), NULL);
1575
        goto out;
1576
    }
1577

1578
    /* TODO: log gfid too */
1579
    gf_msg_trace(frame->root->client->bound_xl->name, 0,
1580
                 "%" PRId64
1581
                 ": "
1582
                 "CREATE %s (%s)",
1583
                 frame->root->unique, state->loc.name,
1584
                 uuid_utoa(stbuf->ia_gfid));
1585

1586
    op_ret = server4_post_create(frame, &rsp, state, this, fd, inode, stbuf,
1587
                                 preparent, postparent);
1588
    if (op_ret) {
1589
        op_errno = -op_ret;
1590
        op_ret = -1;
1591
        goto out;
1592
    }
1593

1594
out:
1595
    if (op_ret)
1596
        rsp.fd = fd_no;
1597
    rsp.op_ret = op_ret;
1598
    rsp.op_errno = gf_errno_to_error(op_errno);
1599

1600
    req = frame->local;
1601
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1602
                        (xdrproc_t)xdr_gfx_create_rsp);
1603

1604
    GF_FREE(rsp.xdata.pairs.pairs_val);
1605

1606
    return 0;
1607
}
1608

1609
int
1610
server4_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1611
                     int32_t op_ret, int32_t op_errno, const char *buf,
1612
                     struct iatt *stbuf, dict_t *xdata)
1613
{
1614
    gfx_readlink_rsp rsp = {
1615
        0,
1616
    };
1617
    server_state_t *state = NULL;
1618
    rpcsvc_request_t *req = NULL;
1619

1620
    dict_to_xdr(xdata, &rsp.xdata);
1621

1622
    if (op_ret < 0) {
1623
        state = CALL_STATE(frame);
1624
        gf_smsg(this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
1625
                "frame=%" PRId64, frame->root->unique, "READLINK_path=%s",
1626
                state->loc.path, "uuid_utoa=%s", uuid_utoa(state->resolve.gfid),
1627
                "client=%s", STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1628
                STACK_ERR_XL_NAME(frame->root), NULL);
1629
        goto out;
1630
    }
1631

1632
    server4_post_readlink(&rsp, stbuf, buf);
1633
out:
1634
    rsp.op_ret = op_ret;
1635
    rsp.op_errno = gf_errno_to_error(op_errno);
1636
    if (!rsp.path)
1637
        rsp.path = "";
1638

1639
    req = frame->local;
1640
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1641
                        (xdrproc_t)xdr_gfx_readlink_rsp);
1642

1643
    GF_FREE(rsp.xdata.pairs.pairs_val);
1644

1645
    return 0;
1646
}
1647

1648
int
1649
server4_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1650
                 int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
1651
                 dict_t *xdata)
1652
{
1653
    gfx_common_iatt_rsp rsp = {
1654
        0,
1655
    };
1656
    server_state_t *state = NULL;
1657
    rpcsvc_request_t *req = NULL;
1658

1659
    dict_to_xdr(xdata, &rsp.xdata);
1660

1661
    state = CALL_STATE(frame);
1662
    if (op_ret) {
1663
        gf_smsg(this->name, fop_log_level(GF_FOP_STAT, op_errno), op_errno,
1664
                PS_MSG_STAT_INFO, "frame=%" PRId64, frame->root->unique,
1665
                "path=%s", (state->loc.path) ? state->loc.path : "",
1666
                "uuid_utoa=%s", uuid_utoa(state->resolve.gfid), "client=%s",
1667
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1668
                STACK_ERR_XL_NAME(frame->root), NULL);
1669
        goto out;
1670
    }
1671

1672
    server4_post_common_iatt(state, &rsp, stbuf);
1673
out:
1674
    rsp.op_ret = op_ret;
1675
    rsp.op_errno = gf_errno_to_error(op_errno);
1676

1677
    req = frame->local;
1678
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1679
                        (xdrproc_t)xdr_gfx_common_iatt_rsp);
1680

1681
    GF_FREE(rsp.xdata.pairs.pairs_val);
1682

1683
    return 0;
1684
}
1685

1686
int
1687
server4_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1688
                    int32_t op_ret, int32_t op_errno, struct iatt *statpre,
1689
                    struct iatt *statpost, dict_t *xdata)
1690
{
1691
    gfx_common_2iatt_rsp rsp = {
1692
        0,
1693
    };
1694
    server_state_t *state = NULL;
1695
    rpcsvc_request_t *req = NULL;
1696

1697
    dict_to_xdr(xdata, &rsp.xdata);
1698

1699
    if (op_ret) {
1700
        state = CALL_STATE(frame);
1701
        gf_smsg(this->name, GF_LOG_INFO, op_errno, PS_MSG_SETATTR_INFO,
1702
                "frame=%" PRId64, frame->root->unique, "path=%s",
1703
                (state->loc.path) ? state->loc.path : "", "uuid_utoa=%s",
1704
                uuid_utoa(state->resolve.gfid), "client=%s",
1705
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1706
                STACK_ERR_XL_NAME(frame->root), NULL);
1707
        goto out;
1708
    }
1709

1710
    server4_post_common_2iatt(&rsp, statpre, statpost);
1711

1712
out:
1713
    rsp.op_ret = op_ret;
1714
    rsp.op_errno = gf_errno_to_error(op_errno);
1715

1716
    req = frame->local;
1717
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1718
                        (xdrproc_t)xdr_gfx_common_2iatt_rsp);
1719

1720
    GF_FREE(rsp.xdata.pairs.pairs_val);
1721

1722
    return 0;
1723
}
1724

1725
int
1726
server4_fsetattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1727
                     int32_t op_ret, int32_t op_errno, struct iatt *statpre,
1728
                     struct iatt *statpost, dict_t *xdata)
1729
{
1730
    gfx_common_2iatt_rsp rsp = {
1731
        0,
1732
    };
1733
    server_state_t *state = NULL;
1734
    rpcsvc_request_t *req = NULL;
1735

1736
    dict_to_xdr(xdata, &rsp.xdata);
1737

1738
    if (op_ret) {
1739
        state = CALL_STATE(frame);
1740
        gf_smsg(this->name, fop_log_level(GF_FOP_FSETATTR, op_errno), op_errno,
1741
                PS_MSG_SETATTR_INFO, "frame=%" PRId64,
1742
                "FSETATTR_fd_no=%" PRId64, state->resolve.fd_no, "uuid_utoa=%s",
1743
                uuid_utoa(state->resolve.gfid), "client=%s",
1744
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1745
                STACK_ERR_XL_NAME(frame->root), NULL);
1746
        goto out;
1747
    }
1748

1749
    server4_post_common_2iatt(&rsp, statpre, statpost);
1750

1751
out:
1752
    rsp.op_ret = op_ret;
1753
    rsp.op_errno = gf_errno_to_error(op_errno);
1754

1755
    req = frame->local;
1756
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1757
                        (xdrproc_t)xdr_gfx_common_2iatt_rsp);
1758

1759
    GF_FREE(rsp.xdata.pairs.pairs_val);
1760

1761
    return 0;
1762
}
1763

1764
int
1765
server4_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1766
                    int32_t op_ret, int32_t op_errno, dict_t *dict,
1767
                    dict_t *xdata)
1768
{
1769
    gfx_common_dict_rsp rsp = {
1770
        0,
1771
    };
1772
    server_state_t *state = NULL;
1773
    rpcsvc_request_t *req = NULL;
1774

1775
    dict_to_xdr(xdata, &rsp.xdata);
1776

1777
    if (op_ret < 0) {
1778
        state = CALL_STATE(frame);
1779
        gf_smsg(this->name, fop_log_level(GF_FOP_XATTROP, op_errno), op_errno,
1780
                PS_MSG_XATTROP_INFO, "frame=%" PRId64, frame->root->unique,
1781
                "path=%s", state->loc.path, "uuid_utoa=%s",
1782
                uuid_utoa(state->resolve.gfid), "client=%s",
1783
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1784
                STACK_ERR_XL_NAME(frame->root), NULL);
1785
        goto out;
1786
    }
1787

1788
    dict_to_xdr(dict, &rsp.dict);
1789
out:
1790
    rsp.op_ret = op_ret;
1791
    rsp.op_errno = gf_errno_to_error(op_errno);
1792

1793
    req = frame->local;
1794
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1795
                        (xdrproc_t)xdr_gfx_common_dict_rsp);
1796

1797
    GF_FREE(rsp.dict.pairs.pairs_val);
1798

1799
    GF_FREE(rsp.xdata.pairs.pairs_val);
1800

1801
    return 0;
1802
}
1803

1804
int
1805
server4_fxattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1806
                     int32_t op_ret, int32_t op_errno, dict_t *dict,
1807
                     dict_t *xdata)
1808
{
1809
    gfx_common_dict_rsp rsp = {
1810
        0,
1811
    };
1812
    server_state_t *state = NULL;
1813
    rpcsvc_request_t *req = NULL;
1814

1815
    dict_to_xdr(xdata, &rsp.xdata);
1816

1817
    if (op_ret < 0) {
1818
        state = CALL_STATE(frame);
1819
        gf_smsg(this->name, fop_log_level(GF_FOP_FXATTROP, op_errno), op_errno,
1820
                PS_MSG_XATTROP_INFO, "frame=%" PRId64, frame->root->unique,
1821
                "FXATTROP_fd_no=%" PRId64, state->resolve.fd_no, "uuid_utoa=%s",
1822
                uuid_utoa(state->resolve.gfid), "client=%s",
1823
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1824
                STACK_ERR_XL_NAME(frame->root), NULL);
1825
        goto out;
1826
    }
1827

1828
    dict_to_xdr(dict, &rsp.dict);
1829

1830
out:
1831
    rsp.op_ret = op_ret;
1832
    rsp.op_errno = gf_errno_to_error(op_errno);
1833

1834
    req = frame->local;
1835
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1836
                        (xdrproc_t)xdr_gfx_common_dict_rsp);
1837

1838
    GF_FREE(rsp.dict.pairs.pairs_val);
1839

1840
    GF_FREE(rsp.xdata.pairs.pairs_val);
1841

1842
    return 0;
1843
}
1844

1845
int
1846
server4_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1847
                     int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
1848
                     dict_t *xdata)
1849
{
1850
    gfx_readdirp_rsp rsp = {
1851
        0,
1852
    };
1853
    server_state_t *state = NULL;
1854
    rpcsvc_request_t *req = NULL;
1855
    int ret = 0;
1856

1857
    state = CALL_STATE(frame);
1858

1859
    dict_to_xdr(xdata, &rsp.xdata);
1860

1861
    if (op_ret < 0) {
1862
        state = CALL_STATE(frame);
1863
        gf_smsg(this->name, fop_log_level(GF_FOP_READDIRP, op_errno), op_errno,
1864
                PS_MSG_DIR_INFO, "frame=%" PRId64, frame->root->unique,
1865
                "READDIRP_fd_no=%" PRId64, state->resolve.fd_no, "uuid_utoa=%s",
1866
                uuid_utoa(state->resolve.gfid), "client=%s",
1867
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1868
                STACK_ERR_XL_NAME(frame->root), NULL);
1869
        goto out;
1870
    }
1871

1872
    /* (op_ret == 0) is valid, and means EOF */
1873
    if (op_ret) {
1874
        ret = server4_post_readdirp(&rsp, entries);
1875
        if (ret == -1) {
1876
            op_ret = -1;
1877
            op_errno = ENOMEM;
1878
            goto out;
1879
        }
1880
    }
1881

1882
    gf_link_inodes_from_dirent(state->fd->inode, entries);
1883

1884
out:
1885
    rsp.op_ret = op_ret;
1886
    rsp.op_errno = gf_errno_to_error(op_errno);
1887

1888
    req = frame->local;
1889
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1890
                        (xdrproc_t)xdr_gfx_readdirp_rsp_custom);
1891

1892
    GF_FREE(rsp.xdata.pairs.pairs_val);
1893

1894
    readdirp_rsp_cleanup_v2(&rsp);
1895

1896
    return 0;
1897
}
1898

1899
int
1900
server4_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1901
                      int32_t op_ret, int32_t op_errno, struct iatt *statpre,
1902
                      struct iatt *statpost, dict_t *xdata)
1903
{
1904
    gfx_common_2iatt_rsp rsp = {
1905
        0,
1906
    };
1907
    server_state_t *state = NULL;
1908
    rpcsvc_request_t *req = NULL;
1909

1910
    dict_to_xdr(xdata, &rsp.xdata);
1911

1912
    if (op_ret) {
1913
        state = CALL_STATE(frame);
1914
        gf_smsg(this->name, fop_log_level(GF_FOP_FALLOCATE, op_errno), op_errno,
1915
                PS_MSG_ALLOC_INFO, "frame=%" PRId64, frame->root->unique,
1916
                "FALLOCATE_fd_no=%" PRId64, state->resolve.fd_no,
1917
                "uuid_utoa=%s", uuid_utoa(state->resolve.gfid), "client=%s",
1918
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1919
                STACK_ERR_XL_NAME(frame->root), NULL);
1920
        goto out;
1921
    }
1922

1923
    server4_post_common_2iatt(&rsp, statpre, statpost);
1924

1925
out:
1926
    rsp.op_ret = op_ret;
1927
    rsp.op_errno = gf_errno_to_error(op_errno);
1928

1929
    req = frame->local;
1930
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1931
                        (xdrproc_t)xdr_gfx_common_2iatt_rsp);
1932

1933
    GF_FREE(rsp.xdata.pairs.pairs_val);
1934

1935
    return 0;
1936
}
1937

1938
int
1939
server4_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1940
                    int32_t op_ret, int32_t op_errno, struct iatt *statpre,
1941
                    struct iatt *statpost, dict_t *xdata)
1942
{
1943
    gfx_common_2iatt_rsp rsp = {
1944
        0,
1945
    };
1946
    server_state_t *state = NULL;
1947
    rpcsvc_request_t *req = NULL;
1948

1949
    dict_to_xdr(xdata, &rsp.xdata);
1950

1951
    if (op_ret) {
1952
        state = CALL_STATE(frame);
1953
        gf_smsg(this->name, fop_log_level(GF_FOP_DISCARD, op_errno), op_errno,
1954
                PS_MSG_DISCARD_INFO, "frame=%" PRId64, frame->root->unique,
1955
                "fd_no=%" PRId64, state->resolve.fd_no, "uuid_utoa=%s",
1956
                uuid_utoa(state->resolve.gfid), "client=%s",
1957
                STACK_CLIENT_NAME(frame->root), "error-xlator: %s",
1958
                STACK_ERR_XL_NAME(frame->root), NULL);
1959
        goto out;
1960
    }
1961

1962
    server4_post_common_2iatt(&rsp, statpre, statpost);
1963

1964
out:
1965
    rsp.op_ret = op_ret;
1966
    rsp.op_errno = gf_errno_to_error(op_errno);
1967

1968
    req = frame->local;
1969
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
1970
                        (xdrproc_t)xdr_gfx_common_2iatt_rsp);
1971

1972
    GF_FREE(rsp.xdata.pairs.pairs_val);
1973

1974
    return 0;
1975
}
1976

1977
int
1978
server4_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
1979
                     int32_t op_ret, int32_t op_errno, struct iatt *statpre,
1980
                     struct iatt *statpost, dict_t *xdata)
1981
{
1982
    gfx_common_2iatt_rsp rsp = {
1983
        0,
1984
    };
1985
    server_state_t *state = NULL;
1986
    rpcsvc_request_t *req = NULL;
1987

1988
    req = frame->local;
1989
    state = CALL_STATE(frame);
1990

1991
    dict_to_xdr(xdata, &rsp.xdata);
1992

1993
    if (op_ret) {
1994
        gf_smsg(this->name, fop_log_level(GF_FOP_ZEROFILL, op_errno), op_errno,
1995
                PS_MSG_ZEROFILL_INFO, "frame=%" PRId64, frame->root->unique,
1996
                "fd_no=%" PRId64, state->resolve.fd_no, "uuid_utoa=%s",
1997
                uuid_utoa(state->resolve.gfid), "client=%s",
1998
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
1999
                STACK_ERR_XL_NAME(frame->root), NULL);
2000
        goto out;
2001
    }
2002

2003
    server4_post_common_2iatt(&rsp, statpre, statpost);
2004

2005
out:
2006
    rsp.op_ret = op_ret;
2007
    rsp.op_errno = gf_errno_to_error(op_errno);
2008

2009
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
2010
                        (xdrproc_t)xdr_gfx_common_2iatt_rsp);
2011

2012
    GF_FREE(rsp.xdata.pairs.pairs_val);
2013

2014
    return 0;
2015
}
2016

2017
int
2018
server4_ipc_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
2019
                int32_t op_ret, int32_t op_errno, dict_t *xdata)
2020
{
2021
    gfx_common_rsp rsp = {
2022
        0,
2023
    };
2024
    server_state_t *state = NULL;
2025
    rpcsvc_request_t *req = NULL;
2026

2027
    req = frame->local;
2028
    state = CALL_STATE(frame);
2029

2030
    dict_to_xdr(xdata, &rsp.xdata);
2031

2032
    if (op_ret) {
2033
        gf_smsg(this->name, GF_LOG_INFO, op_errno, PS_MSG_SERVER_IPC_INFO,
2034
                "frame=%" PRId64, frame->root->unique, "IPC=%" PRId64,
2035
                state->resolve.fd_no, "uuid_utoa=%s",
2036
                uuid_utoa(state->resolve.gfid), "client=%s",
2037
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
2038
                STACK_ERR_XL_NAME(frame->root), NULL);
2039
        goto out;
2040
    }
2041

2042
out:
2043
    rsp.op_ret = op_ret;
2044
    rsp.op_errno = gf_errno_to_error(op_errno);
2045

2046
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
2047
                        (xdrproc_t)xdr_gfx_common_rsp);
2048

2049
    GF_FREE(rsp.xdata.pairs.pairs_val);
2050

2051
    return 0;
2052
}
2053

2054
int
2055
server4_seek_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
2056
                 int32_t op_ret, int32_t op_errno, off_t offset, dict_t *xdata)
2057
{
2058
    struct gfx_seek_rsp rsp = {
2059
        0,
2060
    };
2061
    server_state_t *state = NULL;
2062
    rpcsvc_request_t *req = NULL;
2063

2064
    req = frame->local;
2065
    state = CALL_STATE(frame);
2066

2067
    dict_to_xdr(xdata, &rsp.xdata);
2068

2069
    if (op_ret) {
2070
        gf_smsg(this->name, fop_log_level(GF_FOP_SEEK, op_errno), op_errno,
2071
                PS_MSG_SEEK_INFO, "frame=%" PRId64, frame->root->unique,
2072
                "fd_no=%" PRId64, state->resolve.fd_no, "uuid_utoa=%s",
2073
                uuid_utoa(state->resolve.gfid), "client=%s",
2074
                STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
2075
                STACK_ERR_XL_NAME(frame->root), NULL);
2076
        goto out;
2077
    }
2078

2079
    server4_post_seek(&rsp, offset);
2080
out:
2081
    rsp.op_ret = op_ret;
2082
    rsp.op_errno = gf_errno_to_error(op_errno);
2083

2084
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
2085
                        (xdrproc_t)xdr_gfx_seek_rsp);
2086

2087
    GF_FREE(rsp.xdata.pairs.pairs_val);
2088

2089
    return 0;
2090
}
2091

2092
static int
2093
server4_setactivelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
2094
                        int32_t op_ret, int32_t op_errno, dict_t *xdata)
2095
{
2096
    gfx_common_rsp rsp = {
2097
        0,
2098
    };
2099
    server_state_t *state = NULL;
2100
    rpcsvc_request_t *req = NULL;
2101

2102
    state = CALL_STATE(frame);
2103

2104
    dict_to_xdr(xdata, &rsp.xdata);
2105

2106
    if (op_ret < 0) {
2107
        state = CALL_STATE(frame);
2108
        gf_smsg(this->name, GF_LOG_INFO, op_errno, PS_MSG_SETACTIVELK_INFO,
2109
                "frame=%" PRId64, frame->root->unique, "path==%s",
2110
                state->loc.path, "uuid_utoa=%s", uuid_utoa(state->resolve.gfid),
2111
                "client=%s", STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
2112
                STACK_ERR_XL_NAME(frame->root), NULL);
2113
        goto out;
2114
    }
2115

2116
out:
2117
    rsp.op_ret = op_ret;
2118
    rsp.op_errno = gf_errno_to_error(op_errno);
2119

2120
    req = frame->local;
2121

2122
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
2123
                        (xdrproc_t)xdr_gfx_common_rsp);
2124

2125
    GF_FREE(rsp.xdata.pairs.pairs_val);
2126

2127
    return 0;
2128
}
2129

2130
int
2131
server4_namelink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
2132
                     int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
2133
                     struct iatt *postbuf, dict_t *xdata)
2134
{
2135
    gfx_common_2iatt_rsp rsp = {
2136
        0,
2137
    };
2138
    rpcsvc_request_t *req = NULL;
2139

2140
    dict_to_xdr(xdata, &rsp.xdata);
2141
    if (op_ret < 0)
2142
        goto out;
2143

2144
    gfx_stat_from_iattx(&rsp.prestat, prebuf);
2145
    gfx_stat_from_iattx(&rsp.poststat, postbuf);
2146

2147
    /**
2148
     * no point in linking inode here -- there's no stbuf anyway and a
2149
     * lookup() for this name entry would be a negative lookup.
2150
     */
2151

2152
out:
2153
    rsp.op_ret = op_ret;
2154
    rsp.op_errno = gf_errno_to_error(op_errno);
2155

2156
    req = frame->local;
2157
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
2158
                        (xdrproc_t)xdr_gfx_common_2iatt_rsp);
2159

2160
    GF_FREE(rsp.xdata.pairs.pairs_val);
2161

2162
    return 0;
2163
}
2164

2165
int
2166
server4_icreate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
2167
                    int32_t op_ret, int32_t op_errno, inode_t *inode,
2168
                    struct iatt *stbuf, dict_t *xdata)
2169
{
2170
    server_state_t *state = NULL;
2171
    inode_t *link_inode = NULL;
2172
    rpcsvc_request_t *req = NULL;
2173
    gfx_common_iatt_rsp rsp = {
2174
        0,
2175
    };
2176

2177
    dict_to_xdr(xdata, &rsp.xdata);
2178
    state = CALL_STATE(frame);
2179

2180
    if (op_ret < 0) {
2181
        gf_smsg(this->name, GF_LOG_INFO, op_errno, PS_MSG_CREATE_INFO,
2182
                "frame=%" PRId64, frame->root->unique, "ICREATE_gfid=%s",
2183
                uuid_utoa(state->resolve.gfid), NULL);
2184
        goto out;
2185
    }
2186

2187
    gf_msg_trace(frame->root->client->bound_xl->name, 0,
2188
                 "%" PRId64
2189
                 ": "
2190
                 "ICREATE [%s]",
2191
                 frame->root->unique, uuid_utoa(stbuf->ia_gfid));
2192

2193
    link_inode = inode_link(inode, state->loc.parent, state->loc.name, stbuf);
2194

2195
    if (!link_inode) {
2196
        op_ret = -1;
2197
        op_errno = ENOENT;
2198
        goto out;
2199
    }
2200

2201
    inode_lookup(link_inode);
2202
    inode_unref(link_inode);
2203

2204
    gfx_stat_from_iattx(&rsp.stat, stbuf);
2205

2206
out:
2207
    rsp.op_ret = op_ret;
2208
    rsp.op_errno = gf_errno_to_error(op_errno);
2209

2210
    req = frame->local;
2211
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
2212
                        (xdrproc_t)xdr_gfx_common_iatt_rsp);
2213

2214
    GF_FREE(rsp.xdata.pairs.pairs_val);
2215

2216
    return 0;
2217
}
2218

2219
int
2220
server4_put_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
2221
                int32_t op_ret, int32_t op_errno, inode_t *inode,
2222
                struct iatt *stbuf, struct iatt *preparent,
2223
                struct iatt *postparent, dict_t *xdata)
2224
{
2225
    server_state_t *state = NULL;
2226
    rpcsvc_request_t *req = NULL;
2227
    gfx_common_3iatt_rsp rsp = {
2228
        0,
2229
    };
2230

2231
    dict_to_xdr(xdata, &rsp.xdata);
2232

2233
    state = CALL_STATE(frame);
2234

2235
    if (op_ret < 0) {
2236
        gf_smsg(
2237
            this->name, GF_LOG_INFO, op_errno, PS_MSG_PUT_INFO,
2238
            "frame=%" PRId64, frame->root->unique, "path=%s", state->loc.path,
2239
            "uuid_utoa=%s", uuid_utoa(state->resolve.pargfid), "bname=%s",
2240
            state->resolve.bname, "client=%s", STACK_CLIENT_NAME(frame->root),
2241
            "error-xlator=%s", STACK_ERR_XL_NAME(frame->root), NULL);
2242
        goto out;
2243
    }
2244

2245
    gf_msg_trace(frame->root->client->bound_xl->name, 0,
2246
                 "%" PRId64
2247
                 ": "
2248
                 "PUT %s (%s)",
2249
                 frame->root->unique, state->loc.name,
2250
                 uuid_utoa(stbuf->ia_gfid));
2251

2252
    server4_post_common_3iatt(state, &rsp, inode, stbuf, preparent, postparent);
2253

2254
out:
2255
    rsp.op_ret = op_ret;
2256
    rsp.op_errno = gf_errno_to_error(op_errno);
2257

2258
    req = frame->local;
2259
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
2260
                        (xdrproc_t)xdr_gfx_common_3iatt_rsp);
2261

2262
    GF_FREE(rsp.xdata.pairs.pairs_val);
2263

2264
    return 0;
2265
}
2266

2267
int
2268
server4_copy_file_range_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
2269
                            int32_t op_ret, int32_t op_errno,
2270
                            struct iatt *stbuf, struct iatt *prebuf_dst,
2271
                            struct iatt *postbuf_dst, dict_t *xdata)
2272
{
2273
    gfx_common_3iatt_rsp rsp = {
2274
        0,
2275
    };
2276
    server_state_t *state = NULL;
2277
    rpcsvc_request_t *req = NULL;
2278
    char in_gfid[GF_UUID_BUF_SIZE] = {0};
2279
    char out_gfid[GF_UUID_BUF_SIZE] = {0};
2280

2281
    dict_to_xdr(xdata, &rsp.xdata);
2282

2283
    if (op_ret < 0) {
2284
        state = CALL_STATE(frame);
2285

2286
        uuid_utoa_r(state->resolve.gfid, in_gfid);
2287
        uuid_utoa_r(state->resolve2.gfid, out_gfid);
2288

2289
        gf_smsg(this->name, fop_log_level(GF_FOP_COPY_FILE_RANGE, op_errno),
2290
                op_errno, PS_MSG_WRITE_INFO, "frame=%" PRId64,
2291
                frame->root->unique, "COPY_FILE_RANGE_fd_no=%" PRId64,
2292
                state->resolve.fd_no, "in_gfid=%s", in_gfid,
2293
                "resolve2_fd_no=%" PRId64, state->resolve2.fd_no, "out_gfid=%s",
2294
                out_gfid, "client=%s", STACK_CLIENT_NAME(frame->root),
2295
                "error-xlator=%s", STACK_ERR_XL_NAME(frame->root), NULL);
2296
        goto out;
2297
    }
2298

2299
    /*
2300
     * server4_post_common_3iatt (ex: used by server4_put_cbk and some
2301
     * other cbks) also performs inode linking along with copying of 3
2302
     * iatt structures to the response. But, for copy_file_range, linking
2303
     * of inode is not needed. Therefore a new function is used to
2304
     * construct the response using 3 iatt structures.
2305
     * @stbuf: iatt or stat of the source file (or fd)
2306
     * @prebuf_dst: iatt or stat of destination file (or fd) before the fop
2307
     * @postbuf_dst: iatt or stat of destination file (or fd) after the fop
2308
     */
2309
    server4_post_common_3iatt_noinode(&rsp, stbuf, prebuf_dst, postbuf_dst);
2310

2311
out:
2312
    rsp.op_ret = op_ret;
2313
    rsp.op_errno = gf_errno_to_error(op_errno);
2314

2315
    req = frame->local;
2316
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
2317
                        (xdrproc_t)xdr_gfx_common_3iatt_rsp);
2318

2319
    GF_FREE(rsp.xdata.pairs.pairs_val);
2320

2321
    return 0;
2322
}
2323

2324
/* Resume function section */
2325

2326
int
2327
server4_rchecksum_resume(call_frame_t *frame, xlator_t *bound_xl)
2328
{
2329
    server_state_t *state = NULL;
2330
    int op_ret = 0;
2331
    int op_errno = EINVAL;
2332

2333
    state = CALL_STATE(frame);
2334

2335
    if (state->resolve.op_ret != 0) {
2336
        op_ret = state->resolve.op_ret;
2337
        op_errno = state->resolve.op_errno;
2338
        goto err;
2339
    }
2340

2341
    STACK_WIND(frame, server4_rchecksum_cbk, bound_xl,
2342
               bound_xl->fops->rchecksum, state->fd, state->offset, state->size,
2343
               state->xdata);
2344

2345
    return 0;
2346
err:
2347
    server4_rchecksum_cbk(frame, NULL, frame->this, op_ret, op_errno, 0, NULL,
2348
                          NULL);
2349

2350
    return 0;
2351
}
2352

2353
int
2354
server4_lease_resume(call_frame_t *frame, xlator_t *bound_xl)
2355
{
2356
    server_state_t *state = NULL;
2357

2358
    state = CALL_STATE(frame);
2359

2360
    if (state->resolve.op_ret != 0)
2361
        goto err;
2362

2363
    STACK_WIND(frame, server4_lease_cbk, bound_xl, bound_xl->fops->lease,
2364
               &state->loc, &state->lease, state->xdata);
2365

2366
    return 0;
2367

2368
err:
2369
    server4_lease_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2370
                      state->resolve.op_errno, NULL, NULL);
2371
    return 0;
2372
}
2373

2374
int
2375
server4_put_resume(call_frame_t *frame, xlator_t *bound_xl)
2376
{
2377
    server_state_t *state = NULL;
2378

2379
    state = CALL_STATE(frame);
2380

2381
    if (state->resolve.op_ret != 0)
2382
        goto err;
2383

2384
    state->loc.inode = inode_new(state->itable);
2385

2386
    STACK_WIND(frame, server4_put_cbk, bound_xl, bound_xl->fops->put,
2387
               &(state->loc), state->mode, state->umask, state->flags,
2388
               state->payload_vector, state->payload_count, state->offset,
2389
               state->iobref, state->dict, state->xdata);
2390

2391
    return 0;
2392
err:
2393
    server4_put_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2394
                    state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
2395
    return 0;
2396
}
2397

2398
int
2399
server4_lk_resume(call_frame_t *frame, xlator_t *bound_xl)
2400
{
2401
    server_state_t *state = NULL;
2402

2403
    state = CALL_STATE(frame);
2404

2405
    if (state->resolve.op_ret != 0)
2406
        goto err;
2407

2408
    STACK_WIND(frame, server4_lk_cbk, bound_xl, bound_xl->fops->lk, state->fd,
2409
               state->cmd, &state->flock, state->xdata);
2410

2411
    return 0;
2412

2413
err:
2414
    server4_lk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2415
                   state->resolve.op_errno, NULL, NULL);
2416
    return 0;
2417
}
2418

2419
int
2420
server4_rename_resume(call_frame_t *frame, xlator_t *bound_xl)
2421
{
2422
    server_state_t *state = NULL;
2423
    int op_ret = 0;
2424
    int op_errno = 0;
2425

2426
    state = CALL_STATE(frame);
2427

2428
    if (state->resolve.op_ret != 0) {
2429
        op_ret = state->resolve.op_ret;
2430
        op_errno = state->resolve.op_errno;
2431
        goto err;
2432
    }
2433

2434
    if (state->resolve2.op_ret != 0) {
2435
        op_ret = state->resolve2.op_ret;
2436
        op_errno = state->resolve2.op_errno;
2437
        goto err;
2438
    }
2439

2440
    if (state->loc.parent->ns_inode != state->loc2.parent->ns_inode) {
2441
        /* lets not allow rename across namespaces */
2442
        op_ret = -1;
2443
        op_errno = EXDEV;
2444
        gf_msg(THIS->name, GF_LOG_ERROR, EXDEV, 0,
2445
               "%s: rename across different namespaces not supported",
2446
               state->loc.path);
2447
        goto err;
2448
    }
2449

2450
    STACK_WIND(frame, server4_rename_cbk, bound_xl, bound_xl->fops->rename,
2451
               &state->loc, &state->loc2, state->xdata);
2452
    return 0;
2453
err:
2454
    server4_rename_cbk(frame, NULL, frame->this, op_ret, op_errno, NULL, NULL,
2455
                       NULL, NULL, NULL, NULL);
2456
    return 0;
2457
}
2458

2459
int
2460
server4_link_resume(call_frame_t *frame, xlator_t *bound_xl)
2461
{
2462
    server_state_t *state = NULL;
2463
    int op_ret = 0;
2464
    int op_errno = 0;
2465

2466
    state = CALL_STATE(frame);
2467

2468
    if (state->resolve.op_ret != 0) {
2469
        op_ret = state->resolve.op_ret;
2470
        op_errno = state->resolve.op_errno;
2471
        goto err;
2472
    }
2473

2474
    if (state->resolve2.op_ret != 0) {
2475
        op_ret = state->resolve2.op_ret;
2476
        op_errno = state->resolve2.op_errno;
2477
        goto err;
2478
    }
2479

2480
    if (state->loc.inode->ns_inode != state->loc2.parent->ns_inode) {
2481
        /* lets not allow linking across namespaces */
2482
        op_ret = -1;
2483
        op_errno = EXDEV;
2484
        gf_msg(THIS->name, GF_LOG_ERROR, EXDEV, 0,
2485
               "%s: linking across different namespaces not supported",
2486
               state->loc.path);
2487
        goto err;
2488
    }
2489

2490
    state->loc2.inode = inode_ref(state->loc.inode);
2491

2492
    STACK_WIND(frame, server4_link_cbk, bound_xl, bound_xl->fops->link,
2493
               &state->loc, &state->loc2, state->xdata);
2494

2495
    return 0;
2496
err:
2497
    server4_link_cbk(frame, NULL, frame->this, op_ret, op_errno, NULL, NULL,
2498
                     NULL, NULL, NULL);
2499
    return 0;
2500
}
2501

2502
int
2503
server4_symlink_resume(call_frame_t *frame, xlator_t *bound_xl)
2504
{
2505
    server_state_t *state = NULL;
2506

2507
    state = CALL_STATE(frame);
2508

2509
    if (state->resolve.op_ret != 0)
2510
        goto err;
2511

2512
    state->loc.inode = inode_new(state->itable);
2513

2514
    STACK_WIND(frame, server4_symlink_cbk, bound_xl, bound_xl->fops->symlink,
2515
               state->name, &state->loc, state->umask, state->xdata);
2516

2517
    return 0;
2518
err:
2519
    server4_symlink_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2520
                        state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
2521
    return 0;
2522
}
2523

2524
int
2525
server4_access_resume(call_frame_t *frame, xlator_t *bound_xl)
2526
{
2527
    server_state_t *state = NULL;
2528

2529
    state = CALL_STATE(frame);
2530

2531
    if (state->resolve.op_ret != 0)
2532
        goto err;
2533

2534
    STACK_WIND(frame, server4_access_cbk, bound_xl, bound_xl->fops->access,
2535
               &state->loc, state->mask, state->xdata);
2536
    return 0;
2537
err:
2538
    server4_access_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2539
                       state->resolve.op_errno, NULL);
2540
    return 0;
2541
}
2542

2543
int
2544
server4_fentrylk_resume(call_frame_t *frame, xlator_t *bound_xl)
2545
{
2546
    GF_UNUSED int ret = -1;
2547
    server_state_t *state = NULL;
2548

2549
    state = CALL_STATE(frame);
2550

2551
    if (state->resolve.op_ret != 0)
2552
        goto err;
2553

2554
    if (!state->xdata)
2555
        state->xdata = dict_new();
2556

2557
    if (state->xdata)
2558
        ret = dict_set_str(state->xdata, "connection-id",
2559
                           frame->root->client->client_uid);
2560

2561
    STACK_WIND(frame, server4_fentrylk_cbk, bound_xl, bound_xl->fops->fentrylk,
2562
               state->volume, state->fd, state->name, state->cmd, state->type,
2563
               state->xdata);
2564

2565
    return 0;
2566
err:
2567
    server4_fentrylk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2568
                         state->resolve.op_errno, NULL);
2569
    return 0;
2570
}
2571

2572
int
2573
server4_entrylk_resume(call_frame_t *frame, xlator_t *bound_xl)
2574
{
2575
    GF_UNUSED int ret = -1;
2576
    server_state_t *state = NULL;
2577

2578
    state = CALL_STATE(frame);
2579

2580
    if (state->resolve.op_ret != 0)
2581
        goto err;
2582

2583
    if (!state->xdata)
2584
        state->xdata = dict_new();
2585

2586
    if (state->xdata)
2587
        ret = dict_set_str(state->xdata, "connection-id",
2588
                           frame->root->client->client_uid);
2589

2590
    STACK_WIND(frame, server4_entrylk_cbk, bound_xl, bound_xl->fops->entrylk,
2591
               state->volume, &state->loc, state->name, state->cmd, state->type,
2592
               state->xdata);
2593
    return 0;
2594
err:
2595
    server4_entrylk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2596
                        state->resolve.op_errno, NULL);
2597
    return 0;
2598
}
2599

2600
int
2601
server4_finodelk_resume(call_frame_t *frame, xlator_t *bound_xl)
2602
{
2603
    GF_UNUSED int ret = -1;
2604
    server_state_t *state = NULL;
2605

2606
    gf_msg_debug(bound_xl->name, 0, "frame %p, xlator %p", frame, bound_xl);
2607

2608
    state = CALL_STATE(frame);
2609

2610
    if (state->resolve.op_ret != 0)
2611
        goto err;
2612

2613
    if (!state->xdata)
2614
        state->xdata = dict_new();
2615

2616
    if (state->xdata)
2617
        ret = dict_set_str(state->xdata, "connection-id",
2618
                           frame->root->client->client_uid);
2619

2620
    STACK_WIND(frame, server4_finodelk_cbk, bound_xl, bound_xl->fops->finodelk,
2621
               state->volume, state->fd, state->cmd, &state->flock,
2622
               state->xdata);
2623

2624
    return 0;
2625
err:
2626
    server4_finodelk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2627
                         state->resolve.op_errno, NULL);
2628

2629
    return 0;
2630
}
2631

2632
int
2633
server4_inodelk_resume(call_frame_t *frame, xlator_t *bound_xl)
2634
{
2635
    GF_UNUSED int ret = -1;
2636
    server_state_t *state = NULL;
2637

2638
    gf_msg_debug(bound_xl->name, 0, "frame %p, xlator %p", frame, bound_xl);
2639

2640
    state = CALL_STATE(frame);
2641

2642
    if (state->resolve.op_ret != 0)
2643
        goto err;
2644

2645
    if (!state->xdata)
2646
        state->xdata = dict_new();
2647

2648
    if (state->xdata)
2649
        ret = dict_set_str(state->xdata, "connection-id",
2650
                           frame->root->client->client_uid);
2651

2652
    STACK_WIND(frame, server4_inodelk_cbk, bound_xl, bound_xl->fops->inodelk,
2653
               state->volume, &state->loc, state->cmd, &state->flock,
2654
               state->xdata);
2655
    return 0;
2656
err:
2657
    server4_inodelk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2658
                        state->resolve.op_errno, NULL);
2659
    return 0;
2660
}
2661

2662
int
2663
server4_rmdir_resume(call_frame_t *frame, xlator_t *bound_xl)
2664
{
2665
    server_state_t *state = NULL;
2666

2667
    state = CALL_STATE(frame);
2668

2669
    if (state->resolve.op_ret != 0)
2670
        goto err;
2671

2672
    STACK_WIND(frame, server4_rmdir_cbk, bound_xl, bound_xl->fops->rmdir,
2673
               &state->loc, state->flags, state->xdata);
2674
    return 0;
2675
err:
2676
    server4_rmdir_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2677
                      state->resolve.op_errno, NULL, NULL, NULL);
2678
    return 0;
2679
}
2680

2681
int
2682
server4_mkdir_resume(call_frame_t *frame, xlator_t *bound_xl)
2683

2684
{
2685
    server_state_t *state = NULL;
2686

2687
    state = CALL_STATE(frame);
2688

2689
    if (state->resolve.op_ret != 0)
2690
        goto err;
2691

2692
    state->loc.inode = inode_new(state->itable);
2693

2694
    STACK_WIND(frame, server4_mkdir_cbk, bound_xl, bound_xl->fops->mkdir,
2695
               &(state->loc), state->mode, state->umask, state->xdata);
2696

2697
    return 0;
2698
err:
2699
    server4_mkdir_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2700
                      state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
2701
    return 0;
2702
}
2703

2704
int
2705
server4_mknod_resume(call_frame_t *frame, xlator_t *bound_xl)
2706
{
2707
    server_state_t *state = NULL;
2708

2709
    state = CALL_STATE(frame);
2710

2711
    if (state->resolve.op_ret != 0)
2712
        goto err;
2713

2714
    state->loc.inode = inode_new(state->itable);
2715

2716
    STACK_WIND(frame, server4_mknod_cbk, bound_xl, bound_xl->fops->mknod,
2717
               &(state->loc), state->mode, state->dev, state->umask,
2718
               state->xdata);
2719

2720
    return 0;
2721
err:
2722
    server4_mknod_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2723
                      state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
2724
    return 0;
2725
}
2726

2727
int
2728
server4_fsyncdir_resume(call_frame_t *frame, xlator_t *bound_xl)
2729
{
2730
    server_state_t *state = NULL;
2731

2732
    state = CALL_STATE(frame);
2733

2734
    if (state->resolve.op_ret != 0)
2735
        goto err;
2736

2737
    STACK_WIND(frame, server4_fsyncdir_cbk, bound_xl, bound_xl->fops->fsyncdir,
2738
               state->fd, state->flags, state->xdata);
2739
    return 0;
2740

2741
err:
2742
    server4_fsyncdir_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2743
                         state->resolve.op_errno, NULL);
2744
    return 0;
2745
}
2746

2747
int
2748
server4_readdir_resume(call_frame_t *frame, xlator_t *bound_xl)
2749
{
2750
    server_state_t *state = NULL;
2751

2752
    state = CALL_STATE(frame);
2753

2754
    if (state->resolve.op_ret != 0)
2755
        goto err;
2756

2757
    GF_ASSERT(state->fd);
2758

2759
    STACK_WIND(frame, server4_readdir_cbk, bound_xl, bound_xl->fops->readdir,
2760
               state->fd, state->size, state->offset, state->xdata);
2761

2762
    return 0;
2763
err:
2764
    server4_readdir_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2765
                        state->resolve.op_errno, NULL, NULL);
2766
    return 0;
2767
}
2768

2769
int
2770
server4_readdirp_resume(call_frame_t *frame, xlator_t *bound_xl)
2771
{
2772
    server_state_t *state = NULL;
2773

2774
    state = CALL_STATE(frame);
2775

2776
    if (state->resolve.op_ret != 0)
2777
        goto err;
2778

2779
    STACK_WIND(frame, server4_readdirp_cbk, bound_xl, bound_xl->fops->readdirp,
2780
               state->fd, state->size, state->offset, state->xdata);
2781

2782
    return 0;
2783
err:
2784
    server4_readdirp_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2785
                         state->resolve.op_errno, NULL, NULL);
2786
    return 0;
2787
}
2788

2789
int
2790
server4_opendir_resume(call_frame_t *frame, xlator_t *bound_xl)
2791
{
2792
    server_state_t *state = NULL;
2793

2794
    state = CALL_STATE(frame);
2795

2796
    if (state->resolve.op_ret != 0)
2797
        goto err;
2798

2799
    state->fd = fd_create(state->loc.inode, frame->root->pid);
2800
    if (!state->fd) {
2801
        gf_smsg("server", GF_LOG_ERROR, 0, PS_MSG_FD_CREATE_FAILED, NULL);
2802
        goto err;
2803
    }
2804

2805
    STACK_WIND(frame, server4_opendir_cbk, bound_xl, bound_xl->fops->opendir,
2806
               &state->loc, state->fd, state->xdata);
2807
    return 0;
2808
err:
2809
    server4_opendir_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2810
                        state->resolve.op_errno, NULL, NULL);
2811
    return 0;
2812
}
2813

2814
int
2815
server4_statfs_resume(call_frame_t *frame, xlator_t *bound_xl)
2816
{
2817
    server_state_t *state = NULL;
2818

2819
    state = CALL_STATE(frame);
2820

2821
    if (state->resolve.op_ret != 0)
2822
        goto err;
2823

2824
    STACK_WIND(frame, server4_statfs_cbk, bound_xl, bound_xl->fops->statfs,
2825
               &state->loc, state->xdata);
2826
    return 0;
2827

2828
err:
2829
    server4_statfs_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2830
                       state->resolve.op_errno, NULL, NULL);
2831
    return 0;
2832
}
2833

2834
int
2835
server4_removexattr_resume(call_frame_t *frame, xlator_t *bound_xl)
2836
{
2837
    server_state_t *state = NULL;
2838

2839
    state = CALL_STATE(frame);
2840

2841
    if (state->resolve.op_ret != 0)
2842
        goto err;
2843

2844
    if (dict_get_sizen(state->xdata, GF_NAMESPACE_KEY) ||
2845
        !strncmp(GF_NAMESPACE_KEY, state->name, sizeof(GF_NAMESPACE_KEY))) {
2846
        gf_msg(bound_xl->name, GF_LOG_ERROR, ENOTSUP, 0,
2847
               "%s: removal of namespace is not allowed", state->loc.path);
2848
        state->resolve.op_errno = ENOTSUP;
2849
        state->resolve.op_ret = -1;
2850
        goto err;
2851
    }
2852

2853
    STACK_WIND(frame, server4_removexattr_cbk, bound_xl,
2854
               bound_xl->fops->removexattr, &state->loc, state->name,
2855
               state->xdata);
2856
    return 0;
2857
err:
2858
    server4_removexattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2859
                            state->resolve.op_errno, NULL);
2860
    return 0;
2861
}
2862

2863
int
2864
server4_fremovexattr_resume(call_frame_t *frame, xlator_t *bound_xl)
2865
{
2866
    server_state_t *state = NULL;
2867

2868
    state = CALL_STATE(frame);
2869

2870
    if (state->resolve.op_ret != 0)
2871
        goto err;
2872

2873
    if (dict_get_sizen(state->xdata, GF_NAMESPACE_KEY) ||
2874
        !strncmp(GF_NAMESPACE_KEY, state->name, sizeof(GF_NAMESPACE_KEY))) {
2875
        gf_msg(bound_xl->name, GF_LOG_ERROR, ENOTSUP, 0,
2876
               "%s: removal of namespace is not allowed",
2877
               uuid_utoa(state->fd->inode->gfid));
2878
        state->resolve.op_errno = ENOTSUP;
2879
        state->resolve.op_ret = -1;
2880
        goto err;
2881
    }
2882
    STACK_WIND(frame, server4_fremovexattr_cbk, bound_xl,
2883
               bound_xl->fops->fremovexattr, state->fd, state->name,
2884
               state->xdata);
2885
    return 0;
2886
err:
2887
    server4_fremovexattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2888
                             state->resolve.op_errno, NULL);
2889
    return 0;
2890
}
2891

2892
int
2893
server4_fgetxattr_resume(call_frame_t *frame, xlator_t *bound_xl)
2894
{
2895
    server_state_t *state = NULL;
2896

2897
    state = CALL_STATE(frame);
2898

2899
    if (state->resolve.op_ret != 0)
2900
        goto err;
2901

2902
    STACK_WIND(frame, server4_fgetxattr_cbk, bound_xl,
2903
               bound_xl->fops->fgetxattr, state->fd, state->name, state->xdata);
2904
    return 0;
2905
err:
2906
    server4_fgetxattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2907
                          state->resolve.op_errno, NULL, NULL);
2908
    return 0;
2909
}
2910

2911
int
2912
server4_xattrop_resume(call_frame_t *frame, xlator_t *bound_xl)
2913
{
2914
    server_state_t *state = NULL;
2915

2916
    state = CALL_STATE(frame);
2917

2918
    if (state->resolve.op_ret != 0)
2919
        goto err;
2920

2921
    STACK_WIND(frame, server4_xattrop_cbk, bound_xl, bound_xl->fops->xattrop,
2922
               &state->loc, state->flags, state->dict, state->xdata);
2923
    return 0;
2924
err:
2925
    server4_xattrop_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2926
                        state->resolve.op_errno, NULL, NULL);
2927
    return 0;
2928
}
2929

2930
int
2931
server4_fxattrop_resume(call_frame_t *frame, xlator_t *bound_xl)
2932
{
2933
    server_state_t *state = NULL;
2934

2935
    state = CALL_STATE(frame);
2936

2937
    if (state->resolve.op_ret != 0)
2938
        goto err;
2939

2940
    STACK_WIND(frame, server4_fxattrop_cbk, bound_xl, bound_xl->fops->fxattrop,
2941
               state->fd, state->flags, state->dict, state->xdata);
2942
    return 0;
2943
err:
2944
    server4_fxattrop_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2945
                         state->resolve.op_errno, NULL, NULL);
2946
    return 0;
2947
}
2948

2949
int
2950
server4_fsetxattr_resume(call_frame_t *frame, xlator_t *bound_xl)
2951
{
2952
    server_state_t *state = NULL;
2953

2954
    state = CALL_STATE(frame);
2955

2956
    if (state->resolve.op_ret != 0)
2957
        goto err;
2958

2959
    STACK_WIND(frame, server4_setxattr_cbk, bound_xl, bound_xl->fops->fsetxattr,
2960
               state->fd, state->dict, state->flags, state->xdata);
2961
    return 0;
2962
err:
2963
    server4_fsetxattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2964
                          state->resolve.op_errno, NULL);
2965

2966
    return 0;
2967
}
2968

2969
int
2970
server4_unlink_resume(call_frame_t *frame, xlator_t *bound_xl)
2971
{
2972
    server_state_t *state = NULL;
2973

2974
    state = CALL_STATE(frame);
2975

2976
    if (state->resolve.op_ret != 0)
2977
        goto err;
2978

2979
    STACK_WIND(frame, server4_unlink_cbk, bound_xl, bound_xl->fops->unlink,
2980
               &state->loc, state->flags, state->xdata);
2981
    return 0;
2982
err:
2983
    server4_unlink_cbk(frame, NULL, frame->this, state->resolve.op_ret,
2984
                       state->resolve.op_errno, NULL, NULL, NULL);
2985
    return 0;
2986
}
2987

2988
int
2989
server4_truncate_resume(call_frame_t *frame, xlator_t *bound_xl)
2990
{
2991
    server_state_t *state = NULL;
2992

2993
    state = CALL_STATE(frame);
2994

2995
    if (state->resolve.op_ret != 0)
2996
        goto err;
2997

2998
    STACK_WIND(frame, server4_truncate_cbk, bound_xl, bound_xl->fops->truncate,
2999
               &state->loc, state->offset, state->xdata);
3000
    return 0;
3001
err:
3002
    server4_truncate_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3003
                         state->resolve.op_errno, NULL, NULL, NULL);
3004
    return 0;
3005
}
3006

3007
int
3008
server4_fstat_resume(call_frame_t *frame, xlator_t *bound_xl)
3009
{
3010
    server_state_t *state = NULL;
3011

3012
    state = CALL_STATE(frame);
3013

3014
    if (state->resolve.op_ret != 0)
3015
        goto err;
3016

3017
    STACK_WIND(frame, server4_fstat_cbk, bound_xl, bound_xl->fops->fstat,
3018
               state->fd, state->xdata);
3019
    return 0;
3020
err:
3021
    server4_fstat_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3022
                      state->resolve.op_errno, NULL, NULL);
3023
    return 0;
3024
}
3025

3026
int
3027
server4_setxattr_resume(call_frame_t *frame, xlator_t *bound_xl)
3028
{
3029
    server_state_t *state = NULL;
3030

3031
    state = CALL_STATE(frame);
3032

3033
    if (state->resolve.op_ret != 0)
3034
        goto err;
3035

3036
    STACK_WIND(frame, server4_setxattr_cbk, bound_xl, bound_xl->fops->setxattr,
3037
               &state->loc, state->dict, state->flags, state->xdata);
3038
    return 0;
3039
err:
3040
    server4_setxattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3041
                         state->resolve.op_errno, NULL);
3042

3043
    return 0;
3044
}
3045

3046
int
3047
server4_getxattr_resume(call_frame_t *frame, xlator_t *bound_xl)
3048
{
3049
    server_state_t *state = NULL;
3050

3051
    state = CALL_STATE(frame);
3052

3053
    if (state->resolve.op_ret != 0)
3054
        goto err;
3055

3056
    STACK_WIND(frame, server4_getxattr_cbk, bound_xl, bound_xl->fops->getxattr,
3057
               &state->loc, state->name, state->xdata);
3058
    return 0;
3059
err:
3060
    server4_getxattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3061
                         state->resolve.op_errno, NULL, NULL);
3062
    return 0;
3063
}
3064

3065
int
3066
server4_ftruncate_resume(call_frame_t *frame, xlator_t *bound_xl)
3067
{
3068
    server_state_t *state = NULL;
3069

3070
    state = CALL_STATE(frame);
3071

3072
    if (state->resolve.op_ret != 0)
3073
        goto err;
3074

3075
    STACK_WIND(frame, server4_ftruncate_cbk, bound_xl,
3076
               bound_xl->fops->ftruncate, state->fd, state->offset,
3077
               state->xdata);
3078
    return 0;
3079
err:
3080
    server4_ftruncate_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3081
                          state->resolve.op_errno, NULL, NULL, NULL);
3082

3083
    return 0;
3084
}
3085

3086
int
3087
server4_flush_resume(call_frame_t *frame, xlator_t *bound_xl)
3088
{
3089
    server_state_t *state = NULL;
3090

3091
    state = CALL_STATE(frame);
3092

3093
    if (state->resolve.op_ret != 0)
3094
        goto err;
3095

3096
    STACK_WIND(frame, server4_flush_cbk, bound_xl, bound_xl->fops->flush,
3097
               state->fd, state->xdata);
3098
    return 0;
3099
err:
3100
    server4_flush_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3101
                      state->resolve.op_errno, NULL);
3102

3103
    return 0;
3104
}
3105

3106
int
3107
server4_fsync_resume(call_frame_t *frame, xlator_t *bound_xl)
3108
{
3109
    server_state_t *state = NULL;
3110

3111
    state = CALL_STATE(frame);
3112

3113
    if (state->resolve.op_ret != 0)
3114
        goto err;
3115

3116
    STACK_WIND(frame, server4_fsync_cbk, bound_xl, bound_xl->fops->fsync,
3117
               state->fd, state->flags, state->xdata);
3118
    return 0;
3119
err:
3120
    server4_fsync_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3121
                      state->resolve.op_errno, NULL, NULL, NULL);
3122

3123
    return 0;
3124
}
3125

3126
int
3127
server4_writev_resume(call_frame_t *frame, xlator_t *bound_xl)
3128
{
3129
    server_state_t *state = NULL;
3130

3131
    state = CALL_STATE(frame);
3132

3133
    if (state->resolve.op_ret != 0)
3134
        goto err;
3135

3136
    STACK_WIND(frame, server4_writev_cbk, bound_xl, bound_xl->fops->writev,
3137
               state->fd, state->payload_vector, state->payload_count,
3138
               state->offset, state->flags, state->iobref, state->xdata);
3139

3140
    return 0;
3141
err:
3142
    server4_writev_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3143
                       state->resolve.op_errno, NULL, NULL, NULL);
3144
    return 0;
3145
}
3146

3147
int
3148
server4_readv_resume(call_frame_t *frame, xlator_t *bound_xl)
3149
{
3150
    server_state_t *state = NULL;
3151

3152
    state = CALL_STATE(frame);
3153

3154
    if (state->resolve.op_ret != 0)
3155
        goto err;
3156

3157
    STACK_WIND(frame, server4_readv_cbk, bound_xl, bound_xl->fops->readv,
3158
               state->fd, state->size, state->offset, state->flags,
3159
               state->xdata);
3160

3161
    return 0;
3162
err:
3163
    server4_readv_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3164
                      state->resolve.op_errno, NULL, 0, NULL, NULL, NULL);
3165
    return 0;
3166
}
3167

3168
int
3169
server4_create_resume(call_frame_t *frame, xlator_t *bound_xl)
3170
{
3171
    server_state_t *state = NULL;
3172

3173
    state = CALL_STATE(frame);
3174

3175
    if (state->resolve.op_ret != 0)
3176
        goto err;
3177

3178
    state->loc.inode = inode_new(state->itable);
3179

3180
    state->fd = fd_create(state->loc.inode, frame->root->pid);
3181
    if (!state->fd) {
3182
        gf_smsg("server", GF_LOG_ERROR, 0, PS_MSG_FD_CREATE_FAILED, "inode=%s",
3183
                state->loc.inode ? uuid_utoa(state->loc.inode->gfid) : NULL,
3184
                NULL);
3185
        state->resolve.op_ret = -1;
3186
        state->resolve.op_errno = ENOMEM;
3187
        goto err;
3188
    }
3189
    state->fd->flags = state->flags;
3190

3191
    STACK_WIND(frame, server4_create_cbk, bound_xl, bound_xl->fops->create,
3192
               &(state->loc), state->flags, state->mode, state->umask,
3193
               state->fd, state->xdata);
3194

3195
    return 0;
3196
err:
3197
    server4_create_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3198
                       state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL,
3199
                       NULL);
3200
    return 0;
3201
}
3202

3203
int
3204
server4_open_resume(call_frame_t *frame, xlator_t *bound_xl)
3205
{
3206
    server_state_t *state = NULL;
3207

3208
    state = CALL_STATE(frame);
3209

3210
    if (state->resolve.op_ret != 0)
3211
        goto err;
3212

3213
    state->fd = fd_create(state->loc.inode, frame->root->pid);
3214
    state->fd->flags = state->flags;
3215

3216
    STACK_WIND(frame, server4_open_cbk, bound_xl, bound_xl->fops->open,
3217
               &state->loc, state->flags, state->fd, state->xdata);
3218

3219
    return 0;
3220
err:
3221
    server4_open_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3222
                     state->resolve.op_errno, NULL, NULL);
3223
    return 0;
3224
}
3225

3226
int
3227
server4_readlink_resume(call_frame_t *frame, xlator_t *bound_xl)
3228
{
3229
    server_state_t *state = NULL;
3230

3231
    state = CALL_STATE(frame);
3232

3233
    if (state->resolve.op_ret != 0)
3234
        goto err;
3235

3236
    STACK_WIND(frame, server4_readlink_cbk, bound_xl, bound_xl->fops->readlink,
3237
               &state->loc, state->size, state->xdata);
3238
    return 0;
3239
err:
3240
    server4_readlink_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3241
                         state->resolve.op_errno, NULL, NULL, NULL);
3242
    return 0;
3243
}
3244

3245
int
3246
server4_fsetattr_resume(call_frame_t *frame, xlator_t *bound_xl)
3247
{
3248
    server_state_t *state = NULL;
3249

3250
    state = CALL_STATE(frame);
3251

3252
    if (state->resolve.op_ret != 0)
3253
        goto err;
3254

3255
    STACK_WIND(frame, server4_fsetattr_cbk, bound_xl, bound_xl->fops->fsetattr,
3256
               state->fd, &state->stbuf, state->valid, state->xdata);
3257
    return 0;
3258
err:
3259
    server4_fsetattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3260
                         state->resolve.op_errno, NULL, NULL, NULL);
3261

3262
    return 0;
3263
}
3264

3265
int
3266
server4_setattr_resume(call_frame_t *frame, xlator_t *bound_xl)
3267
{
3268
    server_state_t *state = NULL;
3269

3270
    state = CALL_STATE(frame);
3271

3272
    if (state->resolve.op_ret != 0)
3273
        goto err;
3274

3275
    STACK_WIND(frame, server4_setattr_cbk, bound_xl, bound_xl->fops->setattr,
3276
               &state->loc, &state->stbuf, state->valid, state->xdata);
3277
    return 0;
3278
err:
3279
    server4_setattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3280
                        state->resolve.op_errno, NULL, NULL, NULL);
3281

3282
    return 0;
3283
}
3284

3285
int
3286
server4_stat_resume(call_frame_t *frame, xlator_t *bound_xl)
3287
{
3288
    server_state_t *state = NULL;
3289

3290
    state = CALL_STATE(frame);
3291

3292
    if (state->resolve.op_ret != 0)
3293
        goto err;
3294

3295
    STACK_WIND(frame, server4_stat_cbk, bound_xl, bound_xl->fops->stat,
3296
               &state->loc, state->xdata);
3297
    return 0;
3298
err:
3299
    server4_stat_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3300
                     state->resolve.op_errno, NULL, NULL);
3301
    return 0;
3302
}
3303

3304
int
3305
server4_lookup_resume(call_frame_t *frame, xlator_t *bound_xl)
3306
{
3307
    server_state_t *state = NULL;
3308
    dict_t *xdata = NULL;
3309

3310
    state = CALL_STATE(frame);
3311

3312
    if (state->resolve.op_ret != 0)
3313
        goto err;
3314

3315
    xdata = state->xdata ? dict_ref(state->xdata) : dict_new();
3316
    if (!xdata) {
3317
        state->resolve.op_ret = -1;
3318
        state->resolve.op_errno = ENOMEM;
3319
        goto err;
3320
    }
3321
    if (!state->loc.inode) {
3322
        state->loc.inode = server_inode_new(state->itable, state->loc.gfid);
3323
        int ret = dict_set_int32(xdata, GF_NAMESPACE_KEY, 1);
3324
        if (ret) {
3325
            gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, 0,
3326
                   "dict set (namespace) failed (path: %s), continuing",
3327
                   state->loc.path);
3328
            state->resolve.op_ret = -1;
3329
            state->resolve.op_errno = ENOMEM;
3330
            goto err;
3331
        }
3332
        if (state->loc.path && (state->loc.path[0] == '<')) {
3333
            /* This is a lookup on gfid : get full-path */
3334
            /* TODO: handle gfid based lookup in a better way. Ref GH PR #1763
3335
             */
3336
            ret = dict_set_int32(xdata, "get-full-path", 1);
3337
            if (ret) {
3338
                gf_msg(THIS->name, GF_LOG_INFO, ENOMEM, 0,
3339
                       "%s: dict set (full-path) failed, continuing",
3340
                       state->loc.path);
3341
            }
3342
        }
3343
    } else {
3344
        state->is_revalidate = 1;
3345
    }
3346

3347
    STACK_WIND(frame, server4_lookup_cbk, bound_xl, bound_xl->fops->lookup,
3348
               &state->loc, xdata);
3349

3350
    dict_unref(xdata);
3351

3352
    return 0;
3353
err:
3354
    server4_lookup_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3355
                       state->resolve.op_errno, NULL, NULL, NULL, NULL);
3356

3357
    if (xdata)
3358
        dict_unref(xdata);
3359
    return 0;
3360
}
3361

3362
int
3363
server4_fallocate_resume(call_frame_t *frame, xlator_t *bound_xl)
3364
{
3365
    server_state_t *state = NULL;
3366

3367
    state = CALL_STATE(frame);
3368

3369
    if (state->resolve.op_ret != 0)
3370
        goto err;
3371

3372
    STACK_WIND(frame, server4_fallocate_cbk, bound_xl,
3373
               bound_xl->fops->fallocate, state->fd, state->flags,
3374
               state->offset, state->size, state->xdata);
3375
    return 0;
3376
err:
3377
    server4_fallocate_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3378
                          state->resolve.op_errno, NULL, NULL, NULL);
3379

3380
    return 0;
3381
}
3382

3383
int
3384
server4_discard_resume(call_frame_t *frame, xlator_t *bound_xl)
3385
{
3386
    server_state_t *state = NULL;
3387

3388
    state = CALL_STATE(frame);
3389

3390
    if (state->resolve.op_ret != 0)
3391
        goto err;
3392

3393
    STACK_WIND(frame, server4_discard_cbk, bound_xl, bound_xl->fops->discard,
3394
               state->fd, state->offset, state->size, state->xdata);
3395
    return 0;
3396
err:
3397
    server4_discard_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3398
                        state->resolve.op_errno, NULL, NULL, NULL);
3399

3400
    return 0;
3401
}
3402

3403
int
3404
server4_zerofill_resume(call_frame_t *frame, xlator_t *bound_xl)
3405
{
3406
    server_state_t *state = NULL;
3407

3408
    state = CALL_STATE(frame);
3409

3410
    if (state->resolve.op_ret != 0)
3411
        goto err;
3412

3413
    STACK_WIND(frame, server4_zerofill_cbk, bound_xl, bound_xl->fops->zerofill,
3414
               state->fd, state->offset, state->size, state->xdata);
3415
    return 0;
3416
err:
3417
    server4_zerofill_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3418
                         state->resolve.op_errno, NULL, NULL, NULL);
3419

3420
    return 0;
3421
}
3422

3423
int
3424
server4_seek_resume(call_frame_t *frame, xlator_t *bound_xl)
3425
{
3426
    server_state_t *state = NULL;
3427

3428
    state = CALL_STATE(frame);
3429

3430
    if (state->resolve.op_ret != 0)
3431
        goto err;
3432

3433
    STACK_WIND(frame, server4_seek_cbk, bound_xl, bound_xl->fops->seek,
3434
               state->fd, state->offset, state->what, state->xdata);
3435
    return 0;
3436
err:
3437
    server4_seek_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3438
                     state->resolve.op_errno, 0, NULL);
3439

3440
    return 0;
3441
}
3442

3443
static int
3444
server4_getactivelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
3445
                        int32_t op_ret, int32_t op_errno,
3446
                        lock_migration_info_t *locklist, dict_t *xdata)
3447
{
3448
    gfx_getactivelk_rsp rsp = {
3449
        0,
3450
    };
3451
    server_state_t *state = NULL;
3452
    rpcsvc_request_t *req = NULL;
3453
    int ret = 0;
3454

3455
    state = CALL_STATE(frame);
3456

3457
    dict_to_xdr(xdata, &rsp.xdata);
3458

3459
    if (op_ret < 0) {
3460
        state = CALL_STATE(frame);
3461

3462
        gf_smsg(this->name, GF_LOG_INFO, op_errno, PS_MSG_GETACTIVELK_INFO,
3463
                "frame=%" PRId64, frame->root->unique, "path=%s",
3464
                state->loc.path, "gfid=%s", uuid_utoa(state->resolve.gfid),
3465
                "client=%s", STACK_CLIENT_NAME(frame->root), "error-xlator=%s",
3466
                STACK_ERR_XL_NAME(frame->root), NULL);
3467

3468
        goto out;
3469
    }
3470

3471
    /* (op_ret == 0) means there are no locks on the file*/
3472
    if (op_ret > 0) {
3473
        ret = serialize_rsp_locklist_v2(locklist, &rsp);
3474
        if (ret == -1) {
3475
            op_ret = -1;
3476
            op_errno = ENOMEM;
3477
            goto out;
3478
        }
3479
    }
3480

3481
out:
3482
    rsp.op_ret = op_ret;
3483
    rsp.op_errno = gf_errno_to_error(op_errno);
3484

3485
    req = frame->local;
3486

3487
    server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
3488
                        (xdrproc_t)xdr_gfx_getactivelk_rsp);
3489

3490
    GF_FREE(rsp.xdata.pairs.pairs_val);
3491

3492
    getactivelkinfo_rsp_cleanup_v2(&rsp);
3493

3494
    return 0;
3495
}
3496

3497
int
3498
server4_getactivelk_resume(call_frame_t *frame, xlator_t *bound_xl)
3499
{
3500
    server_state_t *state = NULL;
3501

3502
    state = CALL_STATE(frame);
3503

3504
    if (state->resolve.op_ret != 0)
3505
        goto err;
3506

3507
    STACK_WIND(frame, server4_getactivelk_cbk, bound_xl,
3508
               bound_xl->fops->getactivelk, &state->loc, state->xdata);
3509
    return 0;
3510
err:
3511
    server4_getactivelk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3512
                            state->resolve.op_errno, NULL, NULL);
3513
    return 0;
3514
}
3515

3516
int
3517
server4_setactivelk_resume(call_frame_t *frame, xlator_t *bound_xl)
3518
{
3519
    server_state_t *state = NULL;
3520

3521
    state = CALL_STATE(frame);
3522

3523
    if (state->resolve.op_ret != 0)
3524
        goto err;
3525

3526
    STACK_WIND(frame, server4_setactivelk_cbk, bound_xl,
3527
               bound_xl->fops->setactivelk, &state->loc, &state->locklist,
3528
               state->xdata);
3529
    return 0;
3530
err:
3531
    server4_setactivelk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3532
                            state->resolve.op_errno, NULL);
3533
    return 0;
3534
}
3535
int
3536
server4_namelink_resume(call_frame_t *frame, xlator_t *bound_xl)
3537
{
3538
    server_state_t *state = NULL;
3539

3540
    state = CALL_STATE(frame);
3541

3542
    if (state->resolve.op_ret != 0)
3543
        goto err;
3544

3545
    state->loc.inode = inode_new(state->itable);
3546

3547
    STACK_WIND(frame, server4_namelink_cbk, bound_xl, bound_xl->fops->namelink,
3548
               &(state->loc), state->xdata);
3549
    return 0;
3550

3551
err:
3552
    server4_namelink_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3553
                         state->resolve.op_errno, NULL, NULL, NULL);
3554
    return 0;
3555
}
3556

3557
int
3558
server4_icreate_resume(call_frame_t *frame, xlator_t *bound_xl)
3559
{
3560
    server_state_t *state = NULL;
3561

3562
    state = CALL_STATE(frame);
3563

3564
    if (state->resolve.op_ret != 0)
3565
        goto err;
3566

3567
    state->loc.inode = inode_new(state->itable);
3568

3569
    STACK_WIND(frame, server4_icreate_cbk, bound_xl, bound_xl->fops->icreate,
3570
               &(state->loc), state->mode, state->xdata);
3571

3572
    return 0;
3573
err:
3574
    server4_icreate_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3575
                        state->resolve.op_errno, NULL, NULL, NULL);
3576
    return 0;
3577
}
3578

3579
int
3580
server4_copy_file_range_resume(call_frame_t *frame, xlator_t *bound_xl)
3581
{
3582
    server_state_t *state = NULL;
3583

3584
    state = CALL_STATE(frame);
3585

3586
    if (state->resolve.op_ret != 0)
3587
        goto err;
3588

3589
    STACK_WIND(frame, server4_copy_file_range_cbk, bound_xl,
3590
               bound_xl->fops->copy_file_range, state->fd, state->off_in,
3591
               state->fd_out, state->off_out, state->size, state->flags,
3592
               state->xdata);
3593

3594
    return 0;
3595
err:
3596
    server4_copy_file_range_cbk(frame, NULL, frame->this, state->resolve.op_ret,
3597
                                state->resolve.op_errno, NULL, NULL, NULL,
3598
                                NULL);
3599
    return 0;
3600
}
3601

3602
int
3603
server4_0_stat(rpcsvc_request_t *req)
3604
{
3605
    server_state_t *state = NULL;
3606
    call_frame_t *frame = NULL;
3607
    gfx_stat_req args = {
3608
        {
3609
            0,
3610
        },
3611
    };
3612
    int ret = -1;
3613

3614
    if (!req)
3615
        return 0;
3616

3617
    /* Initialize args first, then decode */
3618
    ret = rpc_receive_common(req, &frame, &state, NULL, &args, xdr_gfx_stat_req,
3619
                             GF_FOP_STAT);
3620
    if (ret != 0) {
3621
        goto out;
3622
    }
3623

3624
    state->resolve.type = RESOLVE_MUST;
3625
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
3626

3627
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
3628
        SERVER_REQ_SET_ERROR(req, ret);
3629
        goto out;
3630
    }
3631

3632
    ret = 0;
3633
    resolve_and_resume(frame, server4_stat_resume);
3634

3635
out:
3636

3637
    return ret;
3638
}
3639

3640
int
3641
server4_0_setattr(rpcsvc_request_t *req)
3642
{
3643
    server_state_t *state = NULL;
3644
    call_frame_t *frame = NULL;
3645
    gfx_setattr_req args = {
3646
        {
3647
            0,
3648
        },
3649
    };
3650
    int ret = -1;
3651

3652
    if (!req)
3653
        return 0;
3654

3655
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
3656
                             xdr_gfx_setattr_req, GF_FOP_SETATTR);
3657
    if (ret != 0) {
3658
        goto out;
3659
    }
3660

3661
    state->resolve.type = RESOLVE_MUST;
3662
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
3663

3664
    gfx_stat_to_iattx(&args.stbuf, &state->stbuf);
3665
    state->valid = args.valid;
3666

3667
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
3668
        SERVER_REQ_SET_ERROR(req, ret);
3669
        goto out;
3670
    }
3671

3672
    ret = 0;
3673
    resolve_and_resume(frame, server4_setattr_resume);
3674

3675
out:
3676

3677
    return ret;
3678
}
3679

3680
int
3681
server4_0_fallocate(rpcsvc_request_t *req)
3682
{
3683
    server_state_t *state = NULL;
3684
    call_frame_t *frame = NULL;
3685
    gfx_fallocate_req args = {
3686
        {0},
3687
    };
3688
    int ret = -1;
3689

3690
    if (!req)
3691
        return ret;
3692

3693
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
3694
                             xdr_gfx_fallocate_req, GF_FOP_FALLOCATE);
3695
    if (ret != 0) {
3696
        goto out;
3697
    }
3698

3699
    state->resolve.type = RESOLVE_MUST;
3700
    state->resolve.fd_no = args.fd;
3701

3702
    state->flags = args.flags;
3703
    state->offset = args.offset;
3704
    state->size = args.size;
3705
    memcpy(state->resolve.gfid, args.gfid, 16);
3706

3707
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
3708
        SERVER_REQ_SET_ERROR(req, ret);
3709
        goto out;
3710
    }
3711

3712
    ret = 0;
3713
    resolve_and_resume(frame, server4_fallocate_resume);
3714

3715
out:
3716

3717
    return ret;
3718
}
3719

3720
int
3721
server4_0_discard(rpcsvc_request_t *req)
3722
{
3723
    server_state_t *state = NULL;
3724
    call_frame_t *frame = NULL;
3725
    gfx_discard_req args = {
3726
        {0},
3727
    };
3728
    int ret = -1;
3729

3730
    if (!req)
3731
        return ret;
3732

3733
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
3734
                             xdr_gfx_discard_req, GF_FOP_DISCARD);
3735
    if (ret != 0) {
3736
        goto out;
3737
    }
3738

3739
    state->resolve.type = RESOLVE_MUST;
3740
    state->resolve.fd_no = args.fd;
3741

3742
    state->offset = args.offset;
3743
    state->size = args.size;
3744
    memcpy(state->resolve.gfid, args.gfid, 16);
3745

3746
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
3747
        SERVER_REQ_SET_ERROR(req, ret);
3748
        goto out;
3749
    }
3750

3751
    ret = 0;
3752
    resolve_and_resume(frame, server4_discard_resume);
3753

3754
out:
3755

3756
    return ret;
3757
}
3758

3759
int
3760
server4_0_zerofill(rpcsvc_request_t *req)
3761
{
3762
    server_state_t *state = NULL;
3763
    call_frame_t *frame = NULL;
3764
    gfx_zerofill_req args = {
3765
        {0},
3766
    };
3767
    int ret = -1;
3768
    int op_errno = 0;
3769

3770
    if (!req)
3771
        return ret;
3772

3773
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
3774
                             xdr_gfx_zerofill_req, GF_FOP_ZEROFILL);
3775
    if (ret != 0) {
3776
        op_errno = -1;
3777
        goto out;
3778
    }
3779

3780
    state->resolve.type = RESOLVE_MUST;
3781
    state->resolve.fd_no = args.fd;
3782

3783
    state->offset = args.offset;
3784
    state->size = args.size;
3785
    memcpy(state->resolve.gfid, args.gfid, 16);
3786

3787
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
3788
        SERVER_REQ_SET_ERROR(req, ret);
3789
        goto out;
3790
    }
3791
    ret = 0;
3792
    resolve_and_resume(frame, server4_zerofill_resume);
3793

3794
out:
3795
    if (op_errno)
3796
        req->rpc_err = GARBAGE_ARGS;
3797

3798
    return ret;
3799
}
3800

3801
int
3802
server4_0_ipc(rpcsvc_request_t *req)
3803
{
3804
    server_state_t *state = NULL;
3805
    call_frame_t *frame = NULL;
3806
    gfx_ipc_req args = {
3807
        0,
3808
    };
3809
    int ret = -1;
3810
    xlator_t *bound_xl = NULL;
3811

3812
    if (!req)
3813
        return ret;
3814

3815
    ret = rpc_receive_common(req, &frame, &state, NULL, &args, xdr_gfx_ipc_req,
3816
                             GF_FOP_IPC);
3817
    if (ret != 0) {
3818
        goto out;
3819
    }
3820

3821
    bound_xl = frame->root->client->bound_xl;
3822
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
3823
        SERVER_REQ_SET_ERROR(req, ret);
3824
        goto out;
3825
    }
3826
    ret = 0;
3827
    STACK_WIND(frame, server4_ipc_cbk, bound_xl, bound_xl->fops->ipc, args.op,
3828
               state->xdata);
3829

3830
out:
3831

3832
    return ret;
3833
}
3834

3835
int
3836
server4_0_seek(rpcsvc_request_t *req)
3837
{
3838
    server_state_t *state = NULL;
3839
    call_frame_t *frame = NULL;
3840
    gfx_seek_req args = {
3841
        {
3842
            0,
3843
        },
3844
    };
3845
    int ret = -1;
3846

3847
    if (!req)
3848
        return ret;
3849

3850
    ret = rpc_receive_common(req, &frame, &state, NULL, &args, xdr_gfx_seek_req,
3851
                             GF_FOP_SEEK);
3852
    if (ret != 0) {
3853
        goto out;
3854
    }
3855

3856
    state->resolve.type = RESOLVE_MUST;
3857
    state->resolve.fd_no = args.fd;
3858

3859
    state->offset = args.offset;
3860
    state->what = args.what;
3861
    memcpy(state->resolve.gfid, args.gfid, 16);
3862

3863
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
3864
        SERVER_REQ_SET_ERROR(req, ret);
3865
        goto out;
3866
    }
3867

3868
    ret = 0;
3869
    resolve_and_resume(frame, server4_seek_resume);
3870

3871
out:
3872
    return ret;
3873
}
3874

3875
int
3876
server4_0_readlink(rpcsvc_request_t *req)
3877
{
3878
    server_state_t *state = NULL;
3879
    call_frame_t *frame = NULL;
3880
    gfx_readlink_req args = {
3881
        {
3882
            0,
3883
        },
3884
    };
3885
    int ret = -1;
3886

3887
    if (!req)
3888
        return ret;
3889

3890
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
3891
                             xdr_gfx_readlink_req, GF_FOP_READLINK);
3892
    if (ret != 0) {
3893
        goto out;
3894
    }
3895

3896
    state->resolve.type = RESOLVE_MUST;
3897
    memcpy(state->resolve.gfid, args.gfid, 16);
3898

3899
    state->size = args.size;
3900

3901
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
3902
        SERVER_REQ_SET_ERROR(req, ret);
3903
        goto out;
3904
    }
3905

3906
    ret = 0;
3907
    resolve_and_resume(frame, server4_readlink_resume);
3908

3909
out:
3910

3911
    return ret;
3912
}
3913

3914
int
3915
server4_0_create(rpcsvc_request_t *req)
3916
{
3917
    server_state_t *state = NULL;
3918
    call_frame_t *frame = NULL;
3919
    gfx_create_req args = {
3920
        {
3921
            0,
3922
        },
3923
    };
3924
    int ret = -1;
3925

3926
    if (!req)
3927
        return ret;
3928

3929
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
3930
                             xdr_gfx_create_req, GF_FOP_CREATE);
3931
    if (ret != 0) {
3932
        goto out;
3933
    }
3934

3935
    state->resolve.bname = gf_strdup(args.bname);
3936
    state->mode = args.mode;
3937
    state->umask = args.umask;
3938
    state->flags = gf_flags_to_flags(args.flags);
3939

3940
    set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
3941

3942
    if (state->flags & O_EXCL) {
3943
        state->resolve.type = RESOLVE_NOT;
3944
    } else {
3945
        state->resolve.type = RESOLVE_DONTCARE;
3946
    }
3947

3948
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
3949
        SERVER_REQ_SET_ERROR(req, ret);
3950
        goto out;
3951
    }
3952

3953
    ret = 0;
3954
    resolve_and_resume(frame, server4_create_resume);
3955

3956
out:
3957
    free(args.bname);
3958

3959
    return ret;
3960
}
3961

3962
int
3963
server4_0_open(rpcsvc_request_t *req)
3964
{
3965
    server_state_t *state = NULL;
3966
    call_frame_t *frame = NULL;
3967
    gfx_open_req args = {
3968
        {
3969
            0,
3970
        },
3971
    };
3972
    int ret = -1;
3973

3974
    if (!req)
3975
        return ret;
3976

3977
    ret = rpc_receive_common(req, &frame, &state, NULL, &args, xdr_gfx_open_req,
3978
                             GF_FOP_OPEN);
3979
    if (ret != 0) {
3980
        goto out;
3981
    }
3982

3983
    state->resolve.type = RESOLVE_MUST;
3984
    memcpy(state->resolve.gfid, args.gfid, 16);
3985

3986
    state->flags = gf_flags_to_flags(args.flags);
3987

3988
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
3989
        SERVER_REQ_SET_ERROR(req, ret);
3990
        goto out;
3991
    }
3992

3993
    ret = 0;
3994
    resolve_and_resume(frame, server4_open_resume);
3995
out:
3996
    return ret;
3997
}
3998

3999
int
4000
server4_0_readv(rpcsvc_request_t *req)
4001
{
4002
    server_state_t *state = NULL;
4003
    call_frame_t *frame = NULL;
4004
    gfx_read_req args = {
4005
        {
4006
            0,
4007
        },
4008
    };
4009
    int ret = -1;
4010

4011
    if (!req)
4012
        goto out;
4013

4014
    ret = rpc_receive_common(req, &frame, &state, NULL, &args, xdr_gfx_read_req,
4015
                             GF_FOP_READ);
4016
    if (ret != 0) {
4017
        goto out;
4018
    }
4019

4020
    state->resolve.type = RESOLVE_MUST;
4021
    state->resolve.fd_no = args.fd;
4022
    state->size = args.size;
4023
    state->offset = args.offset;
4024
    state->flags = args.flag;
4025

4026
    memcpy(state->resolve.gfid, args.gfid, 16);
4027

4028
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4029
        SERVER_REQ_SET_ERROR(req, ret);
4030
        goto out;
4031
    }
4032

4033
    ret = 0;
4034
    resolve_and_resume(frame, server4_readv_resume);
4035
out:
4036
    return ret;
4037
}
4038

4039
int
4040
server4_0_writev(rpcsvc_request_t *req)
4041
{
4042
    server_state_t *state = NULL;
4043
    call_frame_t *frame = NULL;
4044
    gfx_write_req args = {
4045
        {
4046
            0,
4047
        },
4048
    };
4049
    ssize_t len = 0;
4050
    int i = 0;
4051
    int ret = -1;
4052

4053
    if (!req)
4054
        return ret;
4055

4056
    ret = rpc_receive_common(req, &frame, &state, &len, &args,
4057
                             xdr_gfx_write_req, GF_FOP_WRITE);
4058
    if (ret != 0) {
4059
        goto out;
4060
    }
4061

4062
    state->resolve.type = RESOLVE_MUST;
4063
    state->resolve.fd_no = args.fd;
4064
    state->offset = args.offset;
4065
    state->size = args.size;
4066
    state->flags = args.flag;
4067
    state->iobref = iobref_ref(req->iobref);
4068
    memcpy(state->resolve.gfid, args.gfid, 16);
4069

4070
    if (len < req->msg[0].iov_len) {
4071
        state->payload_vector[0].iov_base = (req->msg[0].iov_base + len);
4072
        state->payload_vector[0].iov_len = req->msg[0].iov_len - len;
4073
        state->payload_count = 1;
4074
    }
4075

4076
    for (i = 1; i < req->count; i++) {
4077
        state->payload_vector[state->payload_count++] = req->msg[i];
4078
    }
4079

4080
    len = iov_length(state->payload_vector, state->payload_count);
4081

4082
    GF_ASSERT(state->size == len);
4083

4084
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4085
        SERVER_REQ_SET_ERROR(req, ret);
4086
        goto out;
4087
    }
4088

4089
#ifdef GF_TESTING_IO_XDATA
4090
    dict_dump_to_log(state->xdata);
4091
#endif
4092

4093
    ret = 0;
4094
    resolve_and_resume(frame, server4_writev_resume);
4095
out:
4096

4097
    return ret;
4098
}
4099

4100
#define SERVER4_0_VECWRITE_START 0
4101
#define SERVER4_0_VECWRITE_READING_HDR 1
4102
#define SERVER4_0_VECWRITE_READING_OPAQUE 2
4103

4104
int
4105
server4_0_writev_vecsizer(int state, ssize_t *readsize, char *base_addr,
4106
                          char *curr_addr)
4107
{
4108
    ssize_t size = 0;
4109
    int nextstate = 0;
4110
    gfx_write_req write_req = {
4111
        {
4112
            0,
4113
        },
4114
    };
4115
    XDR xdr;
4116

4117
    switch (state) {
4118
        case SERVER4_0_VECWRITE_START:
4119
            size = xdr_sizeof((xdrproc_t)xdr_gfx_write_req, &write_req);
4120
            *readsize = size;
4121

4122
            nextstate = SERVER4_0_VECWRITE_READING_HDR;
4123
            break;
4124
        case SERVER4_0_VECWRITE_READING_HDR:
4125
            size = xdr_sizeof((xdrproc_t)xdr_gfx_write_req, &write_req);
4126

4127
            xdrmem_create(&xdr, base_addr, size, XDR_DECODE);
4128

4129
            /* This will fail if there is xdata sent from client, if not,
4130
               well and good */
4131
            xdr_gfx_write_req(&xdr, &write_req);
4132

4133
            /* need to round off to proper roof (%4), as XDR packing pads
4134
               the end of opaque object with '0' */
4135
            size = gf_roof(write_req.xdata.xdr_size, 4);
4136

4137
            *readsize = size;
4138

4139
            if (!size)
4140
                nextstate = SERVER4_0_VECWRITE_START;
4141
            else
4142
                nextstate = SERVER4_0_VECWRITE_READING_OPAQUE;
4143

4144
            free(write_req.xdata.pairs.pairs_val);
4145

4146
            break;
4147

4148
        case SERVER4_0_VECWRITE_READING_OPAQUE:
4149
            *readsize = 0;
4150
            nextstate = SERVER4_0_VECWRITE_START;
4151
            break;
4152
    }
4153

4154
    return nextstate;
4155
}
4156

4157
int
4158
server4_0_release(rpcsvc_request_t *req)
4159
{
4160
    client_t *client = NULL;
4161
    server_ctx_t *serv_ctx = NULL;
4162
    gfx_release_req args = {
4163
        {
4164
            0,
4165
        },
4166
    };
4167
    gfx_common_rsp rsp = {
4168
        0,
4169
    };
4170
    int ret = -1;
4171

4172
    ret = xdr_to_generic(req->msg[0], &args, (xdrproc_t)xdr_gfx_release_req);
4173
    if (ret < 0) {
4174
        SERVER_REQ_SET_ERROR(req, ret);
4175
        goto out;
4176
    }
4177

4178
    client = req->trans->xl_private;
4179
    if (!client) {
4180
        /* Handshake is not complete yet. */
4181
        req->rpc_err = SYSTEM_ERR;
4182
        goto out;
4183
    }
4184

4185
    serv_ctx = server_ctx_get(client, client->this);
4186
    if (serv_ctx == NULL) {
4187
        gf_smsg(req->trans->name, GF_LOG_INFO, 0, PS_MSG_SERVER_CTX_GET_FAILED,
4188
                NULL);
4189
        req->rpc_err = SYSTEM_ERR;
4190
        goto out;
4191
    }
4192

4193
    gf_fd_put(serv_ctx->fdtable, args.fd);
4194

4195
    server_submit_reply(NULL, req, &rsp, NULL, 0, NULL,
4196
                        (xdrproc_t)xdr_gfx_common_rsp);
4197

4198
    ret = 0;
4199
out:
4200
    return ret;
4201
}
4202

4203
int
4204
server4_0_releasedir(rpcsvc_request_t *req)
4205
{
4206
    client_t *client = NULL;
4207
    server_ctx_t *serv_ctx = NULL;
4208
    gfx_releasedir_req args = {
4209
        {
4210
            0,
4211
        },
4212
    };
4213
    gfx_common_rsp rsp = {
4214
        0,
4215
    };
4216
    int ret = -1;
4217

4218
    ret = xdr_to_generic(req->msg[0], &args, (xdrproc_t)xdr_gfx_release_req);
4219
    if (ret < 0) {
4220
        SERVER_REQ_SET_ERROR(req, ret);
4221
        goto out;
4222
    }
4223

4224
    client = req->trans->xl_private;
4225
    if (!client) {
4226
        SERVER_REQ_SET_ERROR(req, ret);
4227
        goto out;
4228
    }
4229

4230
    serv_ctx = server_ctx_get(client, client->this);
4231
    if (serv_ctx == NULL) {
4232
        gf_smsg(req->trans->name, GF_LOG_INFO, 0, PS_MSG_SERVER_CTX_GET_FAILED,
4233
                NULL);
4234
        req->rpc_err = SYSTEM_ERR;
4235
        goto out;
4236
    }
4237

4238
    gf_fd_put(serv_ctx->fdtable, args.fd);
4239

4240
    server_submit_reply(NULL, req, &rsp, NULL, 0, NULL,
4241
                        (xdrproc_t)xdr_gfx_common_rsp);
4242

4243
    ret = 0;
4244
out:
4245
    return ret;
4246
}
4247

4248
int
4249
server4_0_fsync(rpcsvc_request_t *req)
4250
{
4251
    server_state_t *state = NULL;
4252
    call_frame_t *frame = NULL;
4253
    gfx_fsync_req args = {
4254
        {
4255
            0,
4256
        },
4257
    };
4258
    int ret = -1;
4259

4260
    if (!req)
4261
        return ret;
4262

4263
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4264
                             xdr_gfx_fsync_req, GF_FOP_FSYNC);
4265
    if (ret != 0) {
4266
        goto out;
4267
    }
4268

4269
    state->resolve.type = RESOLVE_MUST;
4270
    state->resolve.fd_no = args.fd;
4271
    state->flags = args.data;
4272
    memcpy(state->resolve.gfid, args.gfid, 16);
4273

4274
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4275
        SERVER_REQ_SET_ERROR(req, ret);
4276
        goto out;
4277
    }
4278

4279
    ret = 0;
4280
    resolve_and_resume(frame, server4_fsync_resume);
4281
out:
4282

4283
    return ret;
4284
}
4285

4286
int
4287
server4_0_flush(rpcsvc_request_t *req)
4288
{
4289
    server_state_t *state = NULL;
4290
    call_frame_t *frame = NULL;
4291
    gfx_flush_req args = {
4292
        {
4293
            0,
4294
        },
4295
    };
4296
    int ret = -1;
4297

4298
    if (!req)
4299
        return ret;
4300

4301
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4302
                             xdr_gfx_flush_req, GF_FOP_FLUSH);
4303
    if (ret != 0) {
4304
        goto out;
4305
    }
4306

4307
    state->resolve.type = RESOLVE_MUST;
4308
    state->resolve.fd_no = args.fd;
4309
    memcpy(state->resolve.gfid, args.gfid, 16);
4310

4311
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4312
        SERVER_REQ_SET_ERROR(req, ret);
4313
        goto out;
4314
    }
4315

4316
    ret = 0;
4317
    resolve_and_resume(frame, server4_flush_resume);
4318
out:
4319

4320
    return ret;
4321
}
4322

4323
int
4324
server4_0_ftruncate(rpcsvc_request_t *req)
4325
{
4326
    server_state_t *state = NULL;
4327
    call_frame_t *frame = NULL;
4328
    gfx_ftruncate_req args = {
4329
        {
4330
            0,
4331
        },
4332
    };
4333
    int ret = -1;
4334

4335
    if (!req)
4336
        return ret;
4337

4338
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4339
                             xdr_gfx_ftruncate_req, GF_FOP_FTRUNCATE);
4340
    if (ret != 0) {
4341
        goto out;
4342
    }
4343

4344
    state->resolve.type = RESOLVE_MUST;
4345
    state->resolve.fd_no = args.fd;
4346
    state->offset = args.offset;
4347
    memcpy(state->resolve.gfid, args.gfid, 16);
4348

4349
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4350
        SERVER_REQ_SET_ERROR(req, ret);
4351
        goto out;
4352
    }
4353

4354
    ret = 0;
4355
    resolve_and_resume(frame, server4_ftruncate_resume);
4356
out:
4357

4358
    return ret;
4359
}
4360

4361
int
4362
server4_0_fstat(rpcsvc_request_t *req)
4363
{
4364
    server_state_t *state = NULL;
4365
    call_frame_t *frame = NULL;
4366
    gfx_fstat_req args = {
4367
        {
4368
            0,
4369
        },
4370
    };
4371
    int ret = -1;
4372

4373
    if (!req)
4374
        return ret;
4375

4376
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4377
                             xdr_gfx_fstat_req, GF_FOP_FSTAT);
4378
    if (ret != 0) {
4379
        goto out;
4380
    }
4381

4382
    state->resolve.type = RESOLVE_MUST;
4383
    state->resolve.fd_no = args.fd;
4384
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
4385

4386
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4387
        SERVER_REQ_SET_ERROR(req, ret);
4388
        goto out;
4389
    }
4390

4391
    ret = 0;
4392
    resolve_and_resume(frame, server4_fstat_resume);
4393
out:
4394

4395
    return ret;
4396
}
4397

4398
int
4399
server4_0_truncate(rpcsvc_request_t *req)
4400
{
4401
    server_state_t *state = NULL;
4402
    call_frame_t *frame = NULL;
4403
    gfx_truncate_req args = {
4404
        {
4405
            0,
4406
        },
4407
    };
4408
    int ret = -1;
4409

4410
    if (!req)
4411
        return ret;
4412

4413
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4414
                             xdr_gfx_truncate_req, GF_FOP_TRUNCATE);
4415
    if (ret != 0) {
4416
        goto out;
4417
    }
4418

4419
    state->resolve.type = RESOLVE_MUST;
4420
    memcpy(state->resolve.gfid, args.gfid, 16);
4421
    state->offset = args.offset;
4422

4423
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4424
        SERVER_REQ_SET_ERROR(req, ret);
4425
        goto out;
4426
    }
4427

4428
    ret = 0;
4429
    resolve_and_resume(frame, server4_truncate_resume);
4430
out:
4431

4432
    return ret;
4433
}
4434

4435
int
4436
server4_0_unlink(rpcsvc_request_t *req)
4437
{
4438
    server_state_t *state = NULL;
4439
    call_frame_t *frame = NULL;
4440
    gfx_unlink_req args = {
4441
        {
4442
            0,
4443
        },
4444
    };
4445
    int ret = -1;
4446

4447
    if (!req)
4448
        return ret;
4449

4450
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4451
                             xdr_gfx_unlink_req, GF_FOP_UNLINK);
4452
    if (ret != 0) {
4453
        goto out;
4454
    }
4455

4456
    state->resolve.type = RESOLVE_MUST;
4457
    state->resolve.bname = gf_strdup(args.bname);
4458

4459
    set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
4460

4461
    state->flags = args.xflags;
4462

4463
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4464
        SERVER_REQ_SET_ERROR(req, ret);
4465
        goto out;
4466
    }
4467

4468
    ret = 0;
4469
    resolve_and_resume(frame, server4_unlink_resume);
4470
out:
4471
    free(args.bname);
4472

4473
    return ret;
4474
}
4475

4476
int
4477
server4_0_setxattr(rpcsvc_request_t *req)
4478
{
4479
    server_state_t *state = NULL;
4480
    call_frame_t *frame = NULL;
4481
    gfx_setxattr_req args = {
4482
        {
4483
            0,
4484
        },
4485
    };
4486
    int32_t ret = -1;
4487

4488
    if (!req)
4489
        return ret;
4490

4491
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4492
                             xdr_gfx_setxattr_req, GF_FOP_SETXATTR);
4493
    if (ret != 0) {
4494
        goto out;
4495
    }
4496

4497
    state->resolve.type = RESOLVE_MUST;
4498
    state->flags = args.flags;
4499
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
4500

4501
    if (xdr_to_dict(&args.dict, &state->dict)) {
4502
        SERVER_REQ_SET_ERROR(req, ret);
4503
        goto out;
4504
    }
4505

4506
    /* There can be some commands hidden in key, check and proceed */
4507
    gf_server_check_setxattr_cmd(frame, state->dict);
4508

4509
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4510
        SERVER_REQ_SET_ERROR(req, ret);
4511
        goto out;
4512
    }
4513

4514
    /* Let the namespace setting can happen only from special mounts, this
4515
       should prevent all mounts creating fake namespace. */
4516
    if ((frame->root->pid >= 0) &&
4517
        dict_get_sizen(state->dict, GF_NAMESPACE_KEY)) {
4518
        gf_smsg("server", GF_LOG_ERROR, 0, PS_MSG_SETXATTR_INFO, "path=%s",
4519
                state->loc.path, "key=%s", GF_NAMESPACE_KEY, NULL);
4520
        SERVER_REQ_SET_ERROR(req, ret);
4521
        goto out;
4522
    }
4523

4524
    ret = 0;
4525
    resolve_and_resume(frame, server4_setxattr_resume);
4526

4527
out:
4528
    return ret;
4529
}
4530

4531
int
4532
server4_0_fsetxattr(rpcsvc_request_t *req)
4533
{
4534
    server_state_t *state = NULL;
4535
    call_frame_t *frame = NULL;
4536
    gfx_fsetxattr_req args = {
4537
        {
4538
            0,
4539
        },
4540
    };
4541
    int32_t ret = -1;
4542

4543
    if (!req)
4544
        return ret;
4545

4546
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4547
                             xdr_gfx_fsetxattr_req, GF_FOP_FSETXATTR);
4548
    if (ret != 0) {
4549
        goto out;
4550
    }
4551

4552
    state->resolve.type = RESOLVE_MUST;
4553
    state->resolve.fd_no = args.fd;
4554
    state->flags = args.flags;
4555
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
4556

4557
    if (xdr_to_dict(&args.dict, &state->dict)) {
4558
        SERVER_REQ_SET_ERROR(req, ret);
4559
        goto out;
4560
    }
4561

4562
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4563
        SERVER_REQ_SET_ERROR(req, ret);
4564
        goto out;
4565
    }
4566

4567
    ret = 0;
4568
    resolve_and_resume(frame, server4_fsetxattr_resume);
4569

4570
out:
4571
    return ret;
4572
}
4573

4574
int
4575
server4_0_fxattrop(rpcsvc_request_t *req)
4576
{
4577
    server_state_t *state = NULL;
4578
    call_frame_t *frame = NULL;
4579
    gfx_fxattrop_req args = {
4580
        {
4581
            0,
4582
        },
4583
    };
4584
    int32_t ret = -1;
4585

4586
    if (!req)
4587
        return ret;
4588

4589
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4590
                             xdr_gfx_fxattrop_req, GF_FOP_FXATTROP);
4591
    if (ret != 0) {
4592
        goto out;
4593
    }
4594

4595
    state->resolve.type = RESOLVE_MUST;
4596
    state->resolve.fd_no = args.fd;
4597
    state->flags = args.flags;
4598
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
4599

4600
    if (xdr_to_dict(&args.dict, &state->dict)) {
4601
        SERVER_REQ_SET_ERROR(req, ret);
4602
        goto out;
4603
    }
4604

4605
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4606
        SERVER_REQ_SET_ERROR(req, ret);
4607
        goto out;
4608
    }
4609

4610
    ret = 0;
4611
    resolve_and_resume(frame, server4_fxattrop_resume);
4612

4613
out:
4614
    return ret;
4615
}
4616

4617
int
4618
server4_0_xattrop(rpcsvc_request_t *req)
4619
{
4620
    server_state_t *state = NULL;
4621
    call_frame_t *frame = NULL;
4622
    gfx_xattrop_req args = {
4623
        {
4624
            0,
4625
        },
4626
    };
4627
    int32_t ret = -1;
4628

4629
    if (!req)
4630
        return ret;
4631

4632
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4633
                             xdr_gfx_xattrop_req, GF_FOP_XATTROP);
4634
    if (ret != 0) {
4635
        goto out;
4636
    }
4637

4638
    state->resolve.type = RESOLVE_MUST;
4639
    state->flags = args.flags;
4640
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
4641

4642
    if (xdr_to_dict(&args.dict, &state->dict)) {
4643
        SERVER_REQ_SET_ERROR(req, ret);
4644
        goto out;
4645
    }
4646

4647
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4648
        SERVER_REQ_SET_ERROR(req, ret);
4649
        goto out;
4650
    }
4651

4652
    ret = 0;
4653
    resolve_and_resume(frame, server4_xattrop_resume);
4654

4655
out:
4656
    return ret;
4657
}
4658

4659
int
4660
server4_0_getxattr(rpcsvc_request_t *req)
4661
{
4662
    server_state_t *state = NULL;
4663
    call_frame_t *frame = NULL;
4664
    gfx_getxattr_req args = {
4665
        {
4666
            0,
4667
        },
4668
    };
4669
    int ret = -1;
4670

4671
    if (!req)
4672
        return ret;
4673

4674
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4675
                             xdr_gfx_getxattr_req, GF_FOP_GETXATTR);
4676
    if (ret != 0) {
4677
        goto out;
4678
    }
4679

4680
    state->resolve.type = RESOLVE_MUST;
4681
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
4682

4683
    if (args.namelen) {
4684
        state->name = gf_strdup(args.name);
4685
        /* There can be some commands hidden in key, check and proceed */
4686
        gf_server_check_getxattr_cmd(frame, state->name);
4687
    }
4688

4689
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4690
        SERVER_REQ_SET_ERROR(req, ret);
4691
        goto out;
4692
    }
4693

4694
    ret = 0;
4695
    resolve_and_resume(frame, server4_getxattr_resume);
4696
out:
4697
    free(args.name);
4698

4699
    return ret;
4700
}
4701

4702
int
4703
server4_0_fgetxattr(rpcsvc_request_t *req)
4704
{
4705
    server_state_t *state = NULL;
4706
    call_frame_t *frame = NULL;
4707
    gfx_fgetxattr_req args = {
4708
        {
4709
            0,
4710
        },
4711
    };
4712
    int ret = -1;
4713

4714
    if (!req)
4715
        return ret;
4716

4717
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4718
                             xdr_gfx_fgetxattr_req, GF_FOP_FGETXATTR);
4719
    if (ret != 0) {
4720
        goto out;
4721
    }
4722

4723
    state->resolve.type = RESOLVE_MUST;
4724
    state->resolve.fd_no = args.fd;
4725
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
4726
    if (args.namelen)
4727
        state->name = gf_strdup(args.name);
4728

4729
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4730
        SERVER_REQ_SET_ERROR(req, ret);
4731
        goto out;
4732
    }
4733

4734
    ret = 0;
4735
    resolve_and_resume(frame, server4_fgetxattr_resume);
4736
out:
4737
    free(args.name);
4738

4739
    return ret;
4740
}
4741

4742
int
4743
server4_0_removexattr(rpcsvc_request_t *req)
4744
{
4745
    server_state_t *state = NULL;
4746
    call_frame_t *frame = NULL;
4747
    gfx_removexattr_req args = {
4748
        {
4749
            0,
4750
        },
4751
    };
4752
    int ret = -1;
4753

4754
    if (!req)
4755
        return ret;
4756

4757
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4758
                             xdr_gfx_removexattr_req, GF_FOP_REMOVEXATTR);
4759
    if (ret != 0) {
4760
        goto out;
4761
    }
4762

4763
    state->resolve.type = RESOLVE_MUST;
4764
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
4765
    state->name = gf_strdup(args.name);
4766

4767
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4768
        SERVER_REQ_SET_ERROR(req, ret);
4769
        goto out;
4770
    }
4771

4772
    ret = 0;
4773
    resolve_and_resume(frame, server4_removexattr_resume);
4774
out:
4775
    free(args.name);
4776

4777
    return ret;
4778
}
4779

4780
int
4781
server4_0_fremovexattr(rpcsvc_request_t *req)
4782
{
4783
    server_state_t *state = NULL;
4784
    call_frame_t *frame = NULL;
4785
    gfx_fremovexattr_req args = {
4786
        {
4787
            0,
4788
        },
4789
    };
4790
    int ret = -1;
4791

4792
    if (!req)
4793
        return ret;
4794

4795
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4796
                             xdr_gfx_fremovexattr_req, GF_FOP_FREMOVEXATTR);
4797
    if (ret != 0) {
4798
        goto out;
4799
    }
4800

4801
    state->resolve.type = RESOLVE_MUST;
4802
    state->resolve.fd_no = args.fd;
4803
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
4804
    state->name = gf_strdup(args.name);
4805

4806
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4807
        SERVER_REQ_SET_ERROR(req, ret);
4808
        goto out;
4809
    }
4810

4811
    ret = 0;
4812
    resolve_and_resume(frame, server4_fremovexattr_resume);
4813
out:
4814
    free(args.name);
4815

4816
    return ret;
4817
}
4818

4819
int
4820
server4_0_opendir(rpcsvc_request_t *req)
4821
{
4822
    server_state_t *state = NULL;
4823
    call_frame_t *frame = NULL;
4824
    gfx_opendir_req args = {
4825
        {
4826
            0,
4827
        },
4828
    };
4829
    int ret = -1;
4830

4831
    if (!req)
4832
        return ret;
4833

4834
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4835
                             xdr_gfx_opendir_req, GF_FOP_OPENDIR);
4836
    if (ret != 0) {
4837
        goto out;
4838
    }
4839

4840
    state->resolve.type = RESOLVE_MUST;
4841
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
4842

4843
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4844
        SERVER_REQ_SET_ERROR(req, ret);
4845
        goto out;
4846
    }
4847

4848
    ret = 0;
4849
    resolve_and_resume(frame, server4_opendir_resume);
4850
out:
4851

4852
    return ret;
4853
}
4854

4855
int
4856
server4_0_readdirp(rpcsvc_request_t *req)
4857
{
4858
    server_state_t *state = NULL;
4859
    call_frame_t *frame = NULL;
4860
    gfx_readdirp_req args = {
4861
        {
4862
            0,
4863
        },
4864
    };
4865
    size_t headers_size = 0;
4866
    int ret = -1;
4867

4868
    if (!req)
4869
        return ret;
4870

4871
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4872
                             xdr_gfx_readdirp_req, GF_FOP_READDIRP);
4873
    if (ret != 0) {
4874
        goto out;
4875
    }
4876

4877
    /* FIXME: this should go away when variable sized iobufs are introduced
4878
     * and transport layer can send msgs bigger than current page-size.
4879
     */
4880
    headers_size = sizeof(struct rpc_msg) + sizeof(gfx_readdir_rsp);
4881
    if ((frame->this->ctx->page_size < args.size) ||
4882
        ((frame->this->ctx->page_size - args.size) < headers_size)) {
4883
        state->size = frame->this->ctx->page_size - headers_size;
4884
    } else {
4885
        state->size = args.size;
4886
    }
4887

4888
    state->resolve.type = RESOLVE_MUST;
4889
    state->resolve.fd_no = args.fd;
4890
    state->offset = args.offset;
4891
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
4892

4893
    /* here, dict itself works as xdata */
4894
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4895
        SERVER_REQ_SET_ERROR(req, ret);
4896
        goto out;
4897
    }
4898

4899
    ret = 0;
4900
    resolve_and_resume(frame, server4_readdirp_resume);
4901
out:
4902
    return ret;
4903
}
4904

4905
int
4906
server4_0_readdir(rpcsvc_request_t *req)
4907
{
4908
    server_state_t *state = NULL;
4909
    call_frame_t *frame = NULL;
4910
    gfx_readdir_req args = {
4911
        {
4912
            0,
4913
        },
4914
    };
4915
    size_t headers_size = 0;
4916
    int ret = -1;
4917

4918
    if (!req)
4919
        return ret;
4920

4921
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4922
                             xdr_gfx_readdir_req, GF_FOP_READDIR);
4923
    if (ret != 0) {
4924
        goto out;
4925
    }
4926

4927
    /* FIXME: this should go away when variable sized iobufs are introduced
4928
     * and transport layer can send msgs bigger than current page-size.
4929
     */
4930
    headers_size = sizeof(struct rpc_msg) + sizeof(gfx_readdir_rsp);
4931
    if ((frame->this->ctx->page_size < args.size) ||
4932
        ((frame->this->ctx->page_size - args.size) < headers_size)) {
4933
        state->size = frame->this->ctx->page_size - headers_size;
4934
    } else {
4935
        state->size = args.size;
4936
    }
4937

4938
    state->resolve.type = RESOLVE_MUST;
4939
    state->resolve.fd_no = args.fd;
4940
    state->offset = args.offset;
4941
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
4942

4943
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4944
        SERVER_REQ_SET_ERROR(req, ret);
4945
        goto out;
4946
    }
4947

4948
    ret = 0;
4949
    resolve_and_resume(frame, server4_readdir_resume);
4950
out:
4951

4952
    return ret;
4953
}
4954

4955
int
4956
server4_0_fsyncdir(rpcsvc_request_t *req)
4957
{
4958
    server_state_t *state = NULL;
4959
    call_frame_t *frame = NULL;
4960
    gfx_fsyncdir_req args = {
4961
        {
4962
            0,
4963
        },
4964
    };
4965
    int ret = -1;
4966

4967
    if (!req)
4968
        return ret;
4969

4970
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
4971
                             xdr_gfx_fsyncdir_req, GF_FOP_FSYNCDIR);
4972
    if (ret != 0) {
4973
        goto out;
4974
    }
4975

4976
    state->resolve.type = RESOLVE_MUST;
4977
    state->resolve.fd_no = args.fd;
4978
    state->flags = args.data;
4979
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
4980

4981
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
4982
        SERVER_REQ_SET_ERROR(req, ret);
4983
        goto out;
4984
    }
4985

4986
    ret = 0;
4987
    resolve_and_resume(frame, server4_fsyncdir_resume);
4988
out:
4989

4990
    return ret;
4991
}
4992

4993
int
4994
server4_0_mknod(rpcsvc_request_t *req)
4995
{
4996
    server_state_t *state = NULL;
4997
    call_frame_t *frame = NULL;
4998
    gfx_mknod_req args = {
4999
        {
5000
            0,
5001
        },
5002
    };
5003
    int ret = -1;
5004

5005
    if (!req)
5006
        return ret;
5007

5008
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5009
                             xdr_gfx_mknod_req, GF_FOP_MKNOD);
5010
    if (ret != 0) {
5011
        goto out;
5012
    }
5013

5014
    state->resolve.type = RESOLVE_NOT;
5015
    set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
5016

5017
    state->resolve.bname = gf_strdup(args.bname);
5018

5019
    state->mode = args.mode;
5020
    state->dev = args.dev;
5021
    state->umask = args.umask;
5022

5023
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5024
        SERVER_REQ_SET_ERROR(req, ret);
5025
        goto out;
5026
    }
5027

5028
    ret = 0;
5029
    resolve_and_resume(frame, server4_mknod_resume);
5030

5031
out:
5032
    free(args.bname);
5033

5034
    return ret;
5035
}
5036

5037
int
5038
server4_0_mkdir(rpcsvc_request_t *req)
5039
{
5040
    server_state_t *state = NULL;
5041
    call_frame_t *frame = NULL;
5042
    gfx_mkdir_req args = {
5043
        {
5044
            0,
5045
        },
5046
    };
5047
    int ret = -1;
5048

5049
    if (!req)
5050
        return ret;
5051

5052
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5053
                             xdr_gfx_mkdir_req, GF_FOP_MKDIR);
5054
    if (ret != 0) {
5055
        goto out;
5056
    }
5057

5058
    state->resolve.type = RESOLVE_NOT;
5059
    set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
5060
    state->resolve.bname = gf_strdup(args.bname);
5061

5062
    state->mode = args.mode;
5063
    state->umask = args.umask;
5064

5065
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5066
        SERVER_REQ_SET_ERROR(req, ret);
5067
        goto out;
5068
    }
5069

5070
    ret = 0;
5071
    resolve_and_resume(frame, server4_mkdir_resume);
5072

5073
out:
5074
    free(args.bname);
5075

5076
    return ret;
5077
}
5078

5079
int
5080
server4_0_rmdir(rpcsvc_request_t *req)
5081
{
5082
    server_state_t *state = NULL;
5083
    call_frame_t *frame = NULL;
5084
    gfx_rmdir_req args = {
5085
        {
5086
            0,
5087
        },
5088
    };
5089
    int ret = -1;
5090

5091
    if (!req)
5092
        return ret;
5093

5094
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5095
                             xdr_gfx_rmdir_req, GF_FOP_RMDIR);
5096
    if (ret != 0) {
5097
        goto out;
5098
    }
5099

5100
    state->resolve.type = RESOLVE_MUST;
5101
    set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
5102
    state->resolve.bname = gf_strdup(args.bname);
5103

5104
    state->flags = args.xflags;
5105

5106
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5107
        SERVER_REQ_SET_ERROR(req, ret);
5108
        goto out;
5109
    }
5110

5111
    ret = 0;
5112
    resolve_and_resume(frame, server4_rmdir_resume);
5113
out:
5114
    free(args.bname);
5115

5116
    return ret;
5117
}
5118

5119
int
5120
server4_0_inodelk(rpcsvc_request_t *req)
5121
{
5122
    server_state_t *state = NULL;
5123
    call_frame_t *frame = NULL;
5124
    gfx_inodelk_req args = {
5125
        {
5126
            0,
5127
        },
5128
    };
5129
    int cmd = 0;
5130
    int ret = -1;
5131

5132
    if (!req)
5133
        return ret;
5134

5135
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5136
                             xdr_gfx_inodelk_req, GF_FOP_INODELK);
5137
    if (ret != 0) {
5138
        goto out;
5139
    }
5140

5141
    state->resolve.type = RESOLVE_EXACT;
5142
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
5143

5144
    cmd = args.cmd;
5145
    switch (cmd) {
5146
        case GF_LK_GETLK:
5147
            state->cmd = F_GETLK;
5148
            break;
5149
        case GF_LK_SETLK:
5150
            state->cmd = F_SETLK;
5151
            break;
5152
        case GF_LK_SETLKW:
5153
            state->cmd = F_SETLKW;
5154
            break;
5155
    }
5156

5157
    state->type = args.type;
5158
    state->volume = gf_strdup(args.volume);
5159

5160
    gf_proto_flock_to_flock(&args.flock, &state->flock);
5161

5162
    switch (state->type) {
5163
        case GF_LK_F_RDLCK:
5164
            state->flock.l_type = F_RDLCK;
5165
            break;
5166
        case GF_LK_F_WRLCK:
5167
            state->flock.l_type = F_WRLCK;
5168
            break;
5169
        case GF_LK_F_UNLCK:
5170
            state->flock.l_type = F_UNLCK;
5171
            break;
5172
    }
5173

5174
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5175
        SERVER_REQ_SET_ERROR(req, ret);
5176
        goto out;
5177
    }
5178

5179
    ret = 0;
5180
    resolve_and_resume(frame, server4_inodelk_resume);
5181
out:
5182
    free(args.volume);
5183

5184
    free(args.flock.lk_owner.lk_owner_val);
5185

5186
    return ret;
5187
}
5188

5189
int
5190
server4_0_finodelk(rpcsvc_request_t *req)
5191
{
5192
    server_state_t *state = NULL;
5193
    call_frame_t *frame = NULL;
5194
    gfx_finodelk_req args = {
5195
        {
5196
            0,
5197
        },
5198
    };
5199
    int ret = -1;
5200

5201
    if (!req)
5202
        return ret;
5203

5204
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5205
                             xdr_gfx_finodelk_req, GF_FOP_FINODELK);
5206
    if (ret != 0) {
5207
        goto out;
5208
    }
5209

5210
    state->resolve.type = RESOLVE_EXACT;
5211
    state->volume = gf_strdup(args.volume);
5212
    state->resolve.fd_no = args.fd;
5213
    state->cmd = args.cmd;
5214
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
5215

5216
    switch (state->cmd) {
5217
        case GF_LK_GETLK:
5218
            state->cmd = F_GETLK;
5219
            break;
5220
        case GF_LK_SETLK:
5221
            state->cmd = F_SETLK;
5222
            break;
5223
        case GF_LK_SETLKW:
5224
            state->cmd = F_SETLKW;
5225
            break;
5226
    }
5227

5228
    state->type = args.type;
5229

5230
    gf_proto_flock_to_flock(&args.flock, &state->flock);
5231

5232
    switch (state->type) {
5233
        case GF_LK_F_RDLCK:
5234
            state->flock.l_type = F_RDLCK;
5235
            break;
5236
        case GF_LK_F_WRLCK:
5237
            state->flock.l_type = F_WRLCK;
5238
            break;
5239
        case GF_LK_F_UNLCK:
5240
            state->flock.l_type = F_UNLCK;
5241
            break;
5242
    }
5243

5244
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5245
        SERVER_REQ_SET_ERROR(req, ret);
5246
        goto out;
5247
    }
5248

5249
    ret = 0;
5250
    resolve_and_resume(frame, server4_finodelk_resume);
5251
out:
5252
    free(args.volume);
5253

5254
    free(args.flock.lk_owner.lk_owner_val);
5255

5256
    return ret;
5257
}
5258

5259
int
5260
server4_0_entrylk(rpcsvc_request_t *req)
5261
{
5262
    server_state_t *state = NULL;
5263
    call_frame_t *frame = NULL;
5264
    gfx_entrylk_req args = {
5265
        {
5266
            0,
5267
        },
5268
    };
5269
    int ret = -1;
5270

5271
    if (!req)
5272
        return ret;
5273

5274
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5275
                             xdr_gfx_entrylk_req, GF_FOP_ENTRYLK);
5276
    if (ret != 0) {
5277
        goto out;
5278
    }
5279

5280
    state->resolve.type = RESOLVE_EXACT;
5281
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
5282

5283
    if (args.namelen)
5284
        state->name = gf_strdup(args.name);
5285
    state->volume = gf_strdup(args.volume);
5286

5287
    state->cmd = args.cmd;
5288
    state->type = args.type;
5289

5290
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5291
        SERVER_REQ_SET_ERROR(req, ret);
5292
        goto out;
5293
    }
5294

5295
    ret = 0;
5296
    resolve_and_resume(frame, server4_entrylk_resume);
5297
out:
5298
    free(args.volume);
5299
    free(args.name);
5300

5301
    return ret;
5302
}
5303

5304
int
5305
server4_0_fentrylk(rpcsvc_request_t *req)
5306
{
5307
    server_state_t *state = NULL;
5308
    call_frame_t *frame = NULL;
5309
    gfx_fentrylk_req args = {
5310
        {
5311
            0,
5312
        },
5313
    };
5314
    int ret = -1;
5315

5316
    if (!req)
5317
        return ret;
5318

5319
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5320
                             xdr_gfx_fentrylk_req, GF_FOP_FENTRYLK);
5321
    if (ret != 0) {
5322
        goto out;
5323
    }
5324

5325
    state->resolve.type = RESOLVE_EXACT;
5326
    state->resolve.fd_no = args.fd;
5327
    state->cmd = args.cmd;
5328
    state->type = args.type;
5329
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
5330

5331
    if (args.namelen)
5332
        state->name = gf_strdup(args.name);
5333
    state->volume = gf_strdup(args.volume);
5334

5335
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5336
        SERVER_REQ_SET_ERROR(req, ret);
5337
        goto out;
5338
    }
5339

5340
    ret = 0;
5341
    resolve_and_resume(frame, server4_fentrylk_resume);
5342
out:
5343
    free(args.volume);
5344
    free(args.name);
5345

5346
    return ret;
5347
}
5348

5349
int
5350
server4_0_access(rpcsvc_request_t *req)
5351
{
5352
    server_state_t *state = NULL;
5353
    call_frame_t *frame = NULL;
5354
    gfx_access_req args = {
5355
        {
5356
            0,
5357
        },
5358
    };
5359
    int ret = -1;
5360

5361
    if (!req)
5362
        return ret;
5363

5364
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5365
                             xdr_gfx_access_req, GF_FOP_ACCESS);
5366
    if (ret != 0) {
5367
        goto out;
5368
    }
5369

5370
    state->resolve.type = RESOLVE_MUST;
5371
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
5372
    state->mask = args.mask;
5373

5374
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5375
        SERVER_REQ_SET_ERROR(req, ret);
5376
        goto out;
5377
    }
5378

5379
    ret = 0;
5380
    resolve_and_resume(frame, server4_access_resume);
5381
out:
5382

5383
    return ret;
5384
}
5385

5386
int
5387
server4_0_symlink(rpcsvc_request_t *req)
5388
{
5389
    server_state_t *state = NULL;
5390
    call_frame_t *frame = NULL;
5391
    gfx_symlink_req args = {
5392
        {
5393
            0,
5394
        },
5395
    };
5396
    int ret = -1;
5397

5398
    if (!req)
5399
        return ret;
5400

5401
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5402
                             xdr_gfx_symlink_req, GF_FOP_SYMLINK);
5403
    if (ret != 0) {
5404
        goto out;
5405
    }
5406

5407
    state->resolve.type = RESOLVE_NOT;
5408
    set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
5409
    state->resolve.bname = gf_strdup(args.bname);
5410
    state->name = gf_strdup(args.linkname);
5411
    state->umask = args.umask;
5412

5413
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5414
        SERVER_REQ_SET_ERROR(req, ret);
5415
        goto out;
5416
    }
5417

5418
    ret = 0;
5419
    resolve_and_resume(frame, server4_symlink_resume);
5420

5421
out:
5422
    free(args.bname);
5423
    free(args.linkname);
5424

5425
    return ret;
5426
}
5427

5428
int
5429
server4_0_link(rpcsvc_request_t *req)
5430
{
5431
    server_state_t *state = NULL;
5432
    call_frame_t *frame = NULL;
5433
    gfx_link_req args = {
5434
        {
5435
            0,
5436
        },
5437
    };
5438
    int ret = -1;
5439

5440
    if (!req)
5441
        return ret;
5442

5443
    ret = rpc_receive_common(req, &frame, &state, NULL, &args, xdr_gfx_link_req,
5444
                             GF_FOP_LINK);
5445
    if (ret != 0) {
5446
        goto out;
5447
    }
5448

5449
    state->resolve.type = RESOLVE_MUST;
5450
    memcpy(state->resolve.gfid, args.oldgfid, 16);
5451

5452
    state->resolve2.type = RESOLVE_NOT;
5453
    state->resolve2.bname = gf_strdup(args.newbname);
5454
    set_resolve_gfid(frame->root->client, state->resolve2.pargfid,
5455
                     args.newgfid);
5456

5457
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5458
        SERVER_REQ_SET_ERROR(req, ret);
5459
        goto out;
5460
    }
5461

5462
    ret = 0;
5463
    resolve_and_resume(frame, server4_link_resume);
5464
out:
5465
    free(args.newbname);
5466

5467
    return ret;
5468
}
5469

5470
int
5471
server4_0_rename(rpcsvc_request_t *req)
5472
{
5473
    server_state_t *state = NULL;
5474
    call_frame_t *frame = NULL;
5475
    gfx_rename_req args = {
5476
        {
5477
            0,
5478
        },
5479
    };
5480
    int ret = -1;
5481

5482
    if (!req)
5483
        return ret;
5484

5485
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5486
                             xdr_gfx_rename_req, GF_FOP_RENAME);
5487
    if (ret != 0) {
5488
        goto out;
5489
    }
5490

5491
    state->resolve.type = RESOLVE_MUST;
5492
    state->resolve.bname = gf_strdup(args.oldbname);
5493
    set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.oldgfid);
5494

5495
    state->resolve2.type = RESOLVE_MAY;
5496
    state->resolve2.bname = gf_strdup(args.newbname);
5497
    set_resolve_gfid(frame->root->client, state->resolve2.pargfid,
5498
                     args.newgfid);
5499

5500
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5501
        SERVER_REQ_SET_ERROR(req, ret);
5502
        goto out;
5503
    }
5504

5505
    ret = 0;
5506
    resolve_and_resume(frame, server4_rename_resume);
5507
out:
5508
    free(args.oldbname);
5509
    free(args.newbname);
5510

5511
    return ret;
5512
}
5513

5514
int
5515
server4_0_lease(rpcsvc_request_t *req)
5516
{
5517
    server_state_t *state = NULL;
5518
    call_frame_t *frame = NULL;
5519
    gfx_lease_req args = {
5520
        {
5521
            0,
5522
        },
5523
    };
5524
    int ret = -1;
5525

5526
    if (!req)
5527
        return ret;
5528

5529
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5530
                             xdr_gfx_lease_req, GF_FOP_LEASE);
5531
    if (ret != 0) {
5532
        goto out;
5533
    }
5534

5535
    state->resolve.type = RESOLVE_MUST;
5536
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
5537
    gf_proto_lease_to_lease(&args.lease, &state->lease);
5538

5539
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5540
        SERVER_REQ_SET_ERROR(req, ret);
5541
        goto out;
5542
    }
5543

5544
    ret = 0;
5545
    resolve_and_resume(frame, server4_lease_resume);
5546
out:
5547

5548
    return ret;
5549
}
5550

5551
int
5552
server4_0_lk(rpcsvc_request_t *req)
5553
{
5554
    server_state_t *state = NULL;
5555
    call_frame_t *frame = NULL;
5556
    gfx_lk_req args = {
5557
        {
5558
            0,
5559
        },
5560
    };
5561
    int ret = -1;
5562

5563
    if (!req)
5564
        return ret;
5565

5566
    ret = rpc_receive_common(req, &frame, &state, NULL, &args, xdr_gfx_lk_req,
5567
                             GF_FOP_LK);
5568
    if (ret != 0) {
5569
        goto out;
5570
    }
5571

5572
    state->resolve.fd_no = args.fd;
5573
    state->cmd = args.cmd;
5574
    state->type = args.type;
5575
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
5576

5577
    switch (state->cmd) {
5578
        case GF_LK_GETLK:
5579
            state->cmd = F_GETLK;
5580
            break;
5581
        case GF_LK_SETLK:
5582
            state->cmd = F_SETLK;
5583
            break;
5584
        case GF_LK_SETLKW:
5585
            state->cmd = F_SETLKW;
5586
            break;
5587
        case GF_LK_RESLK_LCK:
5588
            state->cmd = F_RESLK_LCK;
5589
            break;
5590
        case GF_LK_RESLK_LCKW:
5591
            state->cmd = F_RESLK_LCKW;
5592
            break;
5593
        case GF_LK_RESLK_UNLCK:
5594
            state->cmd = F_RESLK_UNLCK;
5595
            break;
5596
        case GF_LK_GETLK_FD:
5597
            state->cmd = F_GETLK_FD;
5598
            break;
5599
    }
5600

5601
    gf_proto_flock_to_flock(&args.flock, &state->flock);
5602

5603
    switch (state->type) {
5604
        case GF_LK_F_RDLCK:
5605
            state->flock.l_type = F_RDLCK;
5606
            break;
5607
        case GF_LK_F_WRLCK:
5608
            state->flock.l_type = F_WRLCK;
5609
            break;
5610
        case GF_LK_F_UNLCK:
5611
            state->flock.l_type = F_UNLCK;
5612
            break;
5613
        default:
5614
            gf_smsg(frame->root->client->bound_xl->name, GF_LOG_ERROR, 0,
5615
                    PS_MSG_LOCK_ERROR, "fd=%" PRId64, state->resolve.fd_no,
5616
                    "uuid_utoa=%s", uuid_utoa(state->fd->inode->gfid),
5617
                    "lock type=" PRId32, state->type, NULL);
5618
            break;
5619
    }
5620

5621
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5622
        SERVER_REQ_SET_ERROR(req, ret);
5623
        goto out;
5624
    }
5625

5626
    ret = 0;
5627
    resolve_and_resume(frame, server4_lk_resume);
5628
out:
5629

5630
    free(args.flock.lk_owner.lk_owner_val);
5631

5632
    return ret;
5633
}
5634

5635
int
5636
server4_0_null(rpcsvc_request_t *req)
5637
{
5638
    gfx_common_rsp rsp = {
5639
        0,
5640
    };
5641

5642
    /* Accepted */
5643
    rsp.op_ret = 0;
5644

5645
    server_submit_reply(NULL, req, &rsp, NULL, 0, NULL,
5646
                        (xdrproc_t)xdr_gfx_common_rsp);
5647

5648
    return 0;
5649
}
5650

5651
int
5652
server4_0_lookup(rpcsvc_request_t *req)
5653
{
5654
    call_frame_t *frame = NULL;
5655
    server_state_t *state = NULL;
5656
    gfx_lookup_req args = {
5657
        {
5658
            0,
5659
        },
5660
    };
5661
    int ret = -1;
5662

5663
    GF_VALIDATE_OR_GOTO("server", req, err);
5664

5665
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5666
                             xdr_gfx_lookup_req, GF_FOP_LOOKUP);
5667
    if (ret != 0) {
5668
        goto err;
5669
    }
5670

5671
    state->resolve.type = RESOLVE_DONTCARE;
5672

5673
    if (args.bname && strcmp(args.bname, "")) {
5674
        set_resolve_gfid(frame->root->client, state->resolve.pargfid,
5675
                         args.pargfid);
5676
        state->resolve.bname = gf_strdup(args.bname);
5677
    } else {
5678
        set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
5679
    }
5680

5681
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5682
        SERVER_REQ_SET_ERROR(req, ret);
5683
        goto err;
5684
    }
5685

5686
    ret = 0;
5687
    resolve_and_resume(frame, server4_lookup_resume);
5688

5689
err:
5690
    free(args.bname);
5691

5692
    return ret;
5693
}
5694

5695
int
5696
server4_0_statfs(rpcsvc_request_t *req)
5697
{
5698
    server_state_t *state = NULL;
5699
    call_frame_t *frame = NULL;
5700
    gfx_statfs_req args = {
5701
        {
5702
            0,
5703
        },
5704
    };
5705
    int ret = -1;
5706

5707
    if (!req)
5708
        return ret;
5709

5710
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5711
                             xdr_gfx_statfs_req, GF_FOP_STATFS);
5712
    if (ret != 0) {
5713
        goto out;
5714
    }
5715

5716
    state->resolve.type = RESOLVE_MUST;
5717
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
5718

5719
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5720
        SERVER_REQ_SET_ERROR(req, ret);
5721
        goto out;
5722
    }
5723

5724
    ret = 0;
5725
    resolve_and_resume(frame, server4_statfs_resume);
5726
out:
5727

5728
    return ret;
5729
}
5730

5731
int
5732
server4_0_getactivelk(rpcsvc_request_t *req)
5733
{
5734
    server_state_t *state = NULL;
5735
    call_frame_t *frame = NULL;
5736
    gfx_getactivelk_req args = {
5737
        {
5738
            0,
5739
        },
5740
    };
5741
    int ret = -1;
5742

5743
    if (!req)
5744
        return ret;
5745

5746
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5747
                             xdr_gfx_getactivelk_req, GF_FOP_GETACTIVELK);
5748
    if (ret != 0) {
5749
        goto out;
5750
    }
5751

5752
    state->resolve.type = RESOLVE_MUST;
5753
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
5754

5755
    /* here, dict itself works as xdata */
5756
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5757
        SERVER_REQ_SET_ERROR(req, ret);
5758
        goto out;
5759
    }
5760

5761
    ret = 0;
5762
    resolve_and_resume(frame, server4_getactivelk_resume);
5763
out:
5764

5765
    return ret;
5766
}
5767

5768
int
5769
server4_0_setactivelk(rpcsvc_request_t *req)
5770
{
5771
    server_state_t *state = NULL;
5772
    call_frame_t *frame = NULL;
5773
    gfx_setactivelk_req args = {
5774
        {
5775
            0,
5776
        },
5777
    };
5778
    int ret = -1;
5779

5780
    if (!req)
5781
        return ret;
5782

5783
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5784
                             xdr_gfx_setactivelk_req, GF_FOP_SETACTIVELK);
5785
    if (ret != 0) {
5786
        goto out;
5787
    }
5788

5789
    state->resolve.type = RESOLVE_MUST;
5790
    set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
5791

5792
    /* here, dict itself works as xdata */
5793
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5794
        SERVER_REQ_SET_ERROR(req, ret);
5795
        goto out;
5796
    }
5797

5798
    ret = unserialize_req_locklist_v2(&args, &state->locklist);
5799
    if (ret)
5800
        goto out;
5801

5802
    ret = 0;
5803

5804
    resolve_and_resume(frame, server4_setactivelk_resume);
5805
out:
5806
    return ret;
5807
}
5808

5809
int
5810
server4_0_namelink(rpcsvc_request_t *req)
5811
{
5812
    server_state_t *state = NULL;
5813
    call_frame_t *frame = NULL;
5814
    gfx_namelink_req args = {
5815
        {
5816
            0,
5817
        },
5818
    };
5819
    int ret = -1;
5820

5821
    if (!req)
5822
        return ret;
5823

5824
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5825
                             xdr_gfx_namelink_req, GF_FOP_NAMELINK);
5826

5827
    if (ret != 0)
5828
        goto out;
5829

5830
    state->resolve.bname = gf_strdup(args.bname);
5831
    memcpy(state->resolve.pargfid, args.pargfid, sizeof(uuid_t));
5832

5833
    state->resolve.type = RESOLVE_NOT;
5834

5835
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5836
        SERVER_REQ_SET_ERROR(req, ret);
5837
        goto out;
5838
    }
5839
    ret = 0;
5840
    resolve_and_resume(frame, server4_namelink_resume);
5841

5842
out:
5843
    return ret;
5844
}
5845

5846
int
5847
server4_0_icreate(rpcsvc_request_t *req)
5848
{
5849
    server_state_t *state = NULL;
5850
    call_frame_t *frame = NULL;
5851
    gfx_icreate_req args = {
5852
        {
5853
            0,
5854
        },
5855
    };
5856
    int ret = -1;
5857
    uuid_t gfid = {
5858
        0,
5859
    };
5860

5861
    if (!req)
5862
        return ret;
5863

5864
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5865
                             xdr_gfx_icreate_req, GF_FOP_ICREATE);
5866

5867
    if (ret != 0)
5868
        goto out;
5869

5870
    memcpy(gfid, args.gfid, sizeof(uuid_t));
5871

5872
    state->mode = args.mode;
5873
    gf_asprintf(&state->resolve.bname, INODE_PATH_FMT, uuid_utoa(gfid));
5874

5875
    /* parent is an auxiliary inode number */
5876
    memset(state->resolve.pargfid, 0, sizeof(uuid_t));
5877
    state->resolve.pargfid[15] = GF_AUXILLARY_PARGFID;
5878

5879
    state->resolve.type = RESOLVE_NOT;
5880

5881
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5882
        SERVER_REQ_SET_ERROR(req, ret);
5883
        goto out;
5884
    }
5885
    ret = 0;
5886
    resolve_and_resume(frame, server4_icreate_resume);
5887

5888
out:
5889
    return ret;
5890
}
5891

5892
int
5893
server4_0_fsetattr(rpcsvc_request_t *req)
5894
{
5895
    server_state_t *state = NULL;
5896
    call_frame_t *frame = NULL;
5897
    gfx_fsetattr_req args = {
5898
        {0},
5899
    };
5900
    int ret = -1;
5901

5902
    if (!req)
5903
        return ret;
5904

5905
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5906
                             xdr_gfx_fsetattr_req, GF_FOP_FSETATTR);
5907
    if (ret != 0) {
5908
        goto out;
5909
    }
5910

5911
    state->resolve.type = RESOLVE_MUST;
5912
    state->resolve.fd_no = args.fd;
5913
    memcpy(state->resolve.gfid, args.gfid, 16);
5914

5915
    gfx_stat_to_iattx(&args.stbuf, &state->stbuf);
5916
    state->valid = args.valid;
5917

5918
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5919
        SERVER_REQ_SET_ERROR(req, ret);
5920
        goto out;
5921
    }
5922
    ret = 0;
5923
    resolve_and_resume(frame, server4_fsetattr_resume);
5924

5925
out:
5926
    return ret;
5927
}
5928

5929
int
5930
server4_0_rchecksum(rpcsvc_request_t *req)
5931
{
5932
    server_state_t *state = NULL;
5933
    call_frame_t *frame = NULL;
5934
    gfx_rchecksum_req args = {
5935
        {0},
5936
    };
5937
    int ret = -1;
5938

5939
    if (!req)
5940
        return ret;
5941

5942
    ret = rpc_receive_common(req, &frame, &state, NULL, &args,
5943
                             xdr_gfx_rchecksum_req, GF_FOP_RCHECKSUM);
5944
    if (ret != 0) {
5945
        goto out;
5946
    }
5947

5948
    state->resolve.type = RESOLVE_MAY;
5949
    state->resolve.fd_no = args.fd;
5950
    state->offset = args.offset;
5951
    state->size = args.len;
5952

5953
    memcpy(state->resolve.gfid, args.gfid, 16);
5954

5955
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
5956
        SERVER_REQ_SET_ERROR(req, ret);
5957
        goto out;
5958
    }
5959
    ret = 0;
5960
    resolve_and_resume(frame, server4_rchecksum_resume);
5961
out:
5962
    return ret;
5963
}
5964

5965
int
5966
server4_0_put(rpcsvc_request_t *req)
5967
{
5968
    server_state_t *state = NULL;
5969
    call_frame_t *frame = NULL;
5970
    gfx_put_req args = {
5971
        {
5972
            0,
5973
        },
5974
    };
5975
    int ret = -1;
5976
    ssize_t len = 0;
5977
    int i = 0;
5978

5979
    if (!req)
5980
        return ret;
5981

5982
    ret = rpc_receive_common(req, &frame, &state, &len, &args, xdr_gfx_put_req,
5983
                             GF_FOP_PUT);
5984
    if (ret != 0) {
5985
        goto out;
5986
    }
5987

5988
    state->resolve.bname = gf_strdup(args.bname);
5989
    state->mode = args.mode;
5990
    state->umask = args.umask;
5991
    state->flags = gf_flags_to_flags(args.flag);
5992
    state->offset = args.offset;
5993
    state->size = args.size;
5994
    state->iobref = iobref_ref(req->iobref);
5995

5996
    if (len < req->msg[0].iov_len) {
5997
        state->payload_vector[0].iov_base = (req->msg[0].iov_base + len);
5998
        state->payload_vector[0].iov_len = req->msg[0].iov_len - len;
5999
        state->payload_count = 1;
6000
    }
6001

6002
    for (i = 1; i < req->count; i++) {
6003
        state->payload_vector[state->payload_count++] = req->msg[i];
6004
    }
6005

6006
    len = iov_length(state->payload_vector, state->payload_count);
6007

6008
    GF_ASSERT(state->size == len);
6009

6010
    set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
6011

6012
    if (state->flags & O_EXCL) {
6013
        state->resolve.type = RESOLVE_NOT;
6014
    } else {
6015
        state->resolve.type = RESOLVE_DONTCARE;
6016
    }
6017

6018
    if (xdr_to_dict(&args.xattr, &state->dict)) {
6019
        SERVER_REQ_SET_ERROR(req, ret);
6020
        goto out;
6021
    }
6022
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
6023
        SERVER_REQ_SET_ERROR(req, ret);
6024
        goto out;
6025
    }
6026

6027
    ret = 0;
6028
    resolve_and_resume(frame, server4_put_resume);
6029

6030
out:
6031
    free(args.bname);
6032

6033
    return ret;
6034
}
6035

6036
int
6037
server4_0_compound(rpcsvc_request_t *req)
6038
{
6039
    int ret = -1;
6040
    SERVER_REQ_SET_ERROR(req, ret);
6041
    return ret;
6042
}
6043

6044
int
6045
server4_0_copy_file_range(rpcsvc_request_t *req)
6046
{
6047
    server_state_t *state = NULL;
6048
    call_frame_t *frame = NULL;
6049
    gfx_copy_file_range_req args = {
6050
        {
6051
            0,
6052
        },
6053
    };
6054
    ssize_t len = 0;
6055
    int ret = -1;
6056

6057
    if (!req)
6058
        return ret;
6059

6060
    ret = rpc_receive_common(req, &frame, &state, &len, &args,
6061
                             xdr_gfx_copy_file_range_req,
6062
                             GF_FOP_COPY_FILE_RANGE);
6063
    if (ret != 0) {
6064
        goto out;
6065
    }
6066

6067
    state->resolve.type = RESOLVE_MUST;
6068
    state->resolve.fd_no = args.fd_in;
6069
    state->resolve2.type = RESOLVE_MUST; /*making this resolve must */
6070
    state->resolve2.fd_no = args.fd_out;
6071
    state->off_in = args.off_in;
6072
    state->off_out = args.off_out;
6073
    state->size = args.size;
6074
    state->flags = args.flag;
6075
    memcpy(state->resolve.gfid, args.gfid1, 16);
6076
    memcpy(state->resolve2.gfid, args.gfid2, 16);
6077

6078
    if (xdr_to_dict(&args.xdata, &state->xdata)) {
6079
        SERVER_REQ_SET_ERROR(req, ret);
6080
        goto out;
6081
    }
6082

6083
    ret = 0;
6084
    resolve_and_resume(frame, server4_copy_file_range_resume);
6085
out:
6086

6087
    return ret;
6088
}
6089

6090
int
6091
server_null(rpcsvc_request_t *req)
6092
{
6093
    gf_common_rsp rsp = {
6094
        0,
6095
    };
6096

6097
    /* Accepted */
6098
    rsp.op_ret = 0;
6099

6100
    server_submit_reply(NULL, req, &rsp, NULL, 0, NULL,
6101
                        (xdrproc_t)xdr_gf_common_rsp);
6102

6103
    return 0;
6104
}
6105

6106
static rpcsvc_actor_t glusterfs4_0_fop_actors[] = {
6107
    [GFS3_OP_NULL] = {"NULL", server_null, NULL, GFS3_OP_NULL, 0},
6108
    [GFS3_OP_STAT] = {"STAT", server4_0_stat, NULL, GFS3_OP_STAT, 0},
6109
    [GFS3_OP_READLINK] = {"READLINK", server4_0_readlink, NULL,
6110
                          GFS3_OP_READLINK, 0},
6111
    [GFS3_OP_MKNOD] = {"MKNOD", server4_0_mknod, NULL, GFS3_OP_MKNOD, 0},
6112
    [GFS3_OP_MKDIR] = {"MKDIR", server4_0_mkdir, NULL, GFS3_OP_MKDIR, 0},
6113
    [GFS3_OP_UNLINK] = {"UNLINK", server4_0_unlink, NULL, GFS3_OP_UNLINK, 0},
6114
    [GFS3_OP_RMDIR] = {"RMDIR", server4_0_rmdir, NULL, GFS3_OP_RMDIR, 0},
6115
    [GFS3_OP_SYMLINK] = {"SYMLINK", server4_0_symlink, NULL, GFS3_OP_SYMLINK,
6116
                         0},
6117
    [GFS3_OP_RENAME] = {"RENAME", server4_0_rename, NULL, GFS3_OP_RENAME, 0},
6118
    [GFS3_OP_LINK] = {"LINK", server4_0_link, NULL, GFS3_OP_LINK, 0},
6119
    [GFS3_OP_TRUNCATE] = {"TRUNCATE", server4_0_truncate, NULL,
6120
                          GFS3_OP_TRUNCATE, 0},
6121
    [GFS3_OP_OPEN] = {"OPEN", server4_0_open, NULL, GFS3_OP_OPEN, 0},
6122
    [GFS3_OP_READ] = {"READ", server4_0_readv, NULL, GFS3_OP_READ, 0},
6123
    [GFS3_OP_WRITE] = {"WRITE", server4_0_writev, server4_0_writev_vecsizer,
6124
                       GFS3_OP_WRITE, 0},
6125
    [GFS3_OP_STATFS] = {"STATFS", server4_0_statfs, NULL, GFS3_OP_STATFS, 0},
6126
    [GFS3_OP_FLUSH] = {"FLUSH", server4_0_flush, NULL, GFS3_OP_FLUSH, 0},
6127
    [GFS3_OP_FSYNC] = {"FSYNC", server4_0_fsync, NULL, GFS3_OP_FSYNC, 0},
6128
    [GFS3_OP_GETXATTR] = {"GETXATTR", server4_0_getxattr, NULL,
6129
                          GFS3_OP_GETXATTR, 0},
6130
    [GFS3_OP_SETXATTR] = {"SETXATTR", server4_0_setxattr, NULL,
6131
                          GFS3_OP_SETXATTR, 0},
6132
    [GFS3_OP_REMOVEXATTR] = {"REMOVEXATTR", server4_0_removexattr, NULL,
6133
                             GFS3_OP_REMOVEXATTR, 0},
6134
    [GFS3_OP_OPENDIR] = {"OPENDIR", server4_0_opendir, NULL, GFS3_OP_OPENDIR,
6135
                         0},
6136
    [GFS3_OP_FSYNCDIR] = {"FSYNCDIR", server4_0_fsyncdir, NULL,
6137
                          GFS3_OP_FSYNCDIR, 0},
6138
    [GFS3_OP_ACCESS] = {"ACCESS", server4_0_access, NULL, GFS3_OP_ACCESS, 0},
6139
    [GFS3_OP_CREATE] = {"CREATE", server4_0_create, NULL, GFS3_OP_CREATE, 0},
6140
    [GFS3_OP_FTRUNCATE] = {"FTRUNCATE", server4_0_ftruncate, NULL,
6141
                           GFS3_OP_FTRUNCATE, 0},
6142
    [GFS3_OP_FSTAT] = {"FSTAT", server4_0_fstat, NULL, GFS3_OP_FSTAT, 0},
6143
    [GFS3_OP_LK] = {"LK", server4_0_lk, NULL, GFS3_OP_LK, 0},
6144
    [GFS3_OP_LOOKUP] = {"LOOKUP", server4_0_lookup, NULL, GFS3_OP_LOOKUP, 0},
6145
    [GFS3_OP_READDIR] = {"READDIR", server4_0_readdir, NULL, GFS3_OP_READDIR,
6146
                         0},
6147
    [GFS3_OP_INODELK] = {"INODELK", server4_0_inodelk, NULL, GFS3_OP_INODELK,
6148
                         0},
6149
    [GFS3_OP_FINODELK] = {"FINODELK", server4_0_finodelk, NULL,
6150
                          GFS3_OP_FINODELK, 0},
6151
    [GFS3_OP_ENTRYLK] = {"ENTRYLK", server4_0_entrylk, NULL, GFS3_OP_ENTRYLK,
6152
                         0},
6153
    [GFS3_OP_FENTRYLK] = {"FENTRYLK", server4_0_fentrylk, NULL,
6154
                          GFS3_OP_FENTRYLK, 0},
6155
    [GFS3_OP_XATTROP] = {"XATTROP", server4_0_xattrop, NULL, GFS3_OP_XATTROP,
6156
                         0},
6157
    [GFS3_OP_FXATTROP] = {"FXATTROP", server4_0_fxattrop, NULL,
6158
                          GFS3_OP_FXATTROP, 0},
6159
    [GFS3_OP_FGETXATTR] = {"FGETXATTR", server4_0_fgetxattr, NULL,
6160
                           GFS3_OP_FGETXATTR, 0},
6161
    [GFS3_OP_FSETXATTR] = {"FSETXATTR", server4_0_fsetxattr, NULL,
6162
                           GFS3_OP_FSETXATTR, 0},
6163
    [GFS3_OP_RCHECKSUM] = {"RCHECKSUM", server4_0_rchecksum, NULL,
6164
                           GFS3_OP_RCHECKSUM, 0},
6165
    [GFS3_OP_SETATTR] = {"SETATTR", server4_0_setattr, NULL, GFS3_OP_SETATTR,
6166
                         0},
6167
    [GFS3_OP_FSETATTR] = {"FSETATTR", server4_0_fsetattr, NULL,
6168
                          GFS3_OP_FSETATTR, 0},
6169
    [GFS3_OP_READDIRP] = {"READDIRP", server4_0_readdirp, NULL,
6170
                          GFS3_OP_READDIRP, 0},
6171
    [GFS3_OP_RELEASE] = {"RELEASE", server4_0_release, NULL, GFS3_OP_RELEASE,
6172
                         0},
6173
    [GFS3_OP_RELEASEDIR] = {"RELEASEDIR", server4_0_releasedir, NULL,
6174
                            GFS3_OP_RELEASEDIR, 0},
6175
    [GFS3_OP_FREMOVEXATTR] = {"FREMOVEXATTR", server4_0_fremovexattr, NULL,
6176
                              GFS3_OP_FREMOVEXATTR, 0},
6177
    [GFS3_OP_FALLOCATE] = {"FALLOCATE", server4_0_fallocate, NULL, DRC_NA,
6178
                           GFS3_OP_FALLOCATE, 0},
6179
    [GFS3_OP_DISCARD] = {"DISCARD", server4_0_discard, NULL, DRC_NA,
6180
                         GFS3_OP_DISCARD, 0},
6181
    [GFS3_OP_ZEROFILL] = {"ZEROFILL", server4_0_zerofill, NULL, DRC_NA,
6182
                          GFS3_OP_ZEROFILL, 0},
6183
    [GFS3_OP_IPC] = {"IPC", server4_0_ipc, NULL, DRC_NA, GFS3_OP_IPC, 0},
6184
    [GFS3_OP_SEEK] = {"SEEK", server4_0_seek, NULL, DRC_NA, GFS3_OP_SEEK, 0},
6185
    [GFS3_OP_LEASE] = {"LEASE", server4_0_lease, NULL, DRC_NA, GFS3_OP_LEASE,
6186
                       0},
6187
    [GFS3_OP_GETACTIVELK] = {"GETACTIVELK", server4_0_getactivelk, NULL, DRC_NA,
6188
                             GFS3_OP_GETACTIVELK, 0},
6189
    [GFS3_OP_SETACTIVELK] = {"SETACTIVELK", server4_0_setactivelk, NULL, DRC_NA,
6190
                             GFS3_OP_SETACTIVELK, 0},
6191
    [GFS3_OP_COMPOUND] = {"COMPOUND", server4_0_compound, NULL, DRC_NA,
6192
                          GFS3_OP_COMPOUND, 0},
6193
    [GFS3_OP_ICREATE] = {"ICREATE", server4_0_icreate, NULL, DRC_NA,
6194
                         GFS3_OP_ICREATE, 0},
6195
    [GFS3_OP_NAMELINK] = {"NAMELINK", server4_0_namelink, NULL, DRC_NA,
6196
                          GFS3_OP_NAMELINK, 0},
6197
    [GFS3_OP_COPY_FILE_RANGE] = {"COPY-FILE-RANGE", server4_0_copy_file_range,
6198
                                 NULL, DRC_NA, GFS3_OP_COPY_FILE_RANGE, 0},
6199
};
6200

6201
struct rpcsvc_program glusterfs4_0_fop_prog = {
6202
    .progname = "GlusterFS 4.x v1",
6203
    .prognum = GLUSTER_FOP_PROGRAM,
6204
    .progver = GLUSTER_FOP_VERSION_v2,
6205
    .numactors = GLUSTER_FOP_PROCCNT,
6206
    .actors = glusterfs4_0_fop_actors,
6207
    .ownthread = _gf_true,
6208
};
6209