From e16868dede6455cab644805af6fe1ac312775e13 Mon Sep 17 00:00:00 2001 From: Gluster Ant Date: Wed, 12 Sep 2018 17:52:45 +0530 Subject: Land part 2 of clang-format changes Change-Id: Ia84cc24c8924e6d22d02ac15f611c10e26db99b4 Signed-off-by: Nigel Babu --- xlators/features/quota/src/quota-enforcer-client.c | 702 +- xlators/features/quota/src/quota.c | 8293 ++++++++++---------- xlators/features/quota/src/quotad-aggregator.c | 696 +- xlators/features/quota/src/quotad-helpers.c | 114 +- xlators/features/quota/src/quotad.c | 316 +- 5 files changed, 4996 insertions(+), 5125 deletions(-) (limited to 'xlators/features/quota/src') diff --git a/xlators/features/quota/src/quota-enforcer-client.c b/xlators/features/quota/src/quota-enforcer-client.c index 8011bacdf8c..57105549cf8 100644 --- a/xlators/features/quota/src/quota-enforcer-client.c +++ b/xlators/features/quota/src/quota-enforcer-client.c @@ -44,448 +44,454 @@ extern struct rpc_clnt_program quota_enforcer_clnt; int32_t -quota_validate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *xdata, struct iatt *postparent); +quota_validate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *xdata, struct iatt *postparent); int -quota_enforcer_submit_request (void *req, call_frame_t *frame, - rpc_clnt_prog_t *prog, - int procnum, struct iobref *iobref, - xlator_t *this, fop_cbk_fn_t cbkfn, - xdrproc_t xdrproc) +quota_enforcer_submit_request(void *req, call_frame_t *frame, + rpc_clnt_prog_t *prog, int procnum, + struct iobref *iobref, xlator_t *this, + fop_cbk_fn_t cbkfn, xdrproc_t xdrproc) { - int ret = -1; - int count = 0; - struct iovec iov = {0, }; - struct iobuf *iobuf = NULL; - char new_iobref = 0; - ssize_t xdr_size = 0; - quota_priv_t *priv = NULL; - - GF_ASSERT (this); - - priv = this->private; - - if (req) { - xdr_size = xdr_sizeof (xdrproc, req); - iobuf = iobuf_get2 (this->ctx->iobuf_pool, xdr_size); - if (!iobuf) { - goto out; - } - - if (!iobref) { - iobref = iobref_new (); - if (!iobref) { - goto out; - } - - new_iobref = 1; - } - - iobref_add (iobref, iobuf); - - iov.iov_base = iobuf->ptr; - iov.iov_len = iobuf_size (iobuf); - - /* Create the xdr payload */ - ret = xdr_serialize_generic (iov, req, xdrproc); - if (ret == -1) { - goto out; - } - iov.iov_len = ret; - count = 1; + int ret = -1; + int count = 0; + struct iovec iov = { + 0, + }; + struct iobuf *iobuf = NULL; + char new_iobref = 0; + ssize_t xdr_size = 0; + quota_priv_t *priv = NULL; + + GF_ASSERT(this); + + priv = this->private; + + if (req) { + xdr_size = xdr_sizeof(xdrproc, req); + iobuf = iobuf_get2(this->ctx->iobuf_pool, xdr_size); + if (!iobuf) { + goto out; } - /* Send the msg */ - ret = rpc_clnt_submit (priv->rpc_clnt, prog, procnum, cbkfn, - &iov, count, - NULL, 0, iobref, frame, NULL, 0, NULL, 0, NULL); - ret = 0; + if (!iobref) { + iobref = iobref_new(); + if (!iobref) { + goto out; + } + + new_iobref = 1; + } + + iobref_add(iobref, iobuf); + + iov.iov_base = iobuf->ptr; + iov.iov_len = iobuf_size(iobuf); + + /* Create the xdr payload */ + ret = xdr_serialize_generic(iov, req, xdrproc); + if (ret == -1) { + goto out; + } + iov.iov_len = ret; + count = 1; + } + + /* Send the msg */ + ret = rpc_clnt_submit(priv->rpc_clnt, prog, procnum, cbkfn, &iov, count, + NULL, 0, iobref, frame, NULL, 0, NULL, 0, NULL); + ret = 0; out: - if (new_iobref) - iobref_unref (iobref); - if (iobuf) - iobuf_unref (iobuf); + if (new_iobref) + iobref_unref(iobref); + if (iobuf) + iobuf_unref(iobuf); - return ret; + return ret; } int -quota_enforcer_lookup_cbk (struct rpc_req *req, struct iovec *iov, - int count, void *myframe) +quota_enforcer_lookup_cbk(struct rpc_req *req, struct iovec *iov, int count, + void *myframe) { - quota_local_t *local = NULL; - call_frame_t *frame = NULL; - int ret = 0; - gfs3_lookup_rsp rsp = {0,}; - struct iatt stbuf = {0,}; - struct iatt postparent = {0,}; - int op_errno = EINVAL; - dict_t *xdata = NULL; - inode_t *inode = NULL; - xlator_t *this = NULL; - quota_priv_t *priv = NULL; - struct timespec retry_delay = {0,}; - gf_timer_t *timer = NULL; - - this = THIS; - - frame = myframe; - local = frame->local; - inode = local->validate_loc.inode; - priv = this->private; - - if (-1 == req->rpc_status) { - rsp.op_ret = -1; - op_errno = ENOTCONN; - goto out; - } + quota_local_t *local = NULL; + call_frame_t *frame = NULL; + int ret = 0; + gfs3_lookup_rsp rsp = { + 0, + }; + struct iatt stbuf = { + 0, + }; + struct iatt postparent = { + 0, + }; + int op_errno = EINVAL; + dict_t *xdata = NULL; + inode_t *inode = NULL; + xlator_t *this = NULL; + quota_priv_t *priv = NULL; + struct timespec retry_delay = { + 0, + }; + gf_timer_t *timer = NULL; + + this = THIS; + + frame = myframe; + local = frame->local; + inode = local->validate_loc.inode; + priv = this->private; + + if (-1 == req->rpc_status) { + rsp.op_ret = -1; + op_errno = ENOTCONN; + goto out; + } + + ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gfs3_lookup_rsp); + if (ret < 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, Q_MSG_XDR_DECODING_FAILED, + "XDR decoding failed"); + rsp.op_ret = -1; + op_errno = EINVAL; + goto out; + } - ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gfs3_lookup_rsp); - if (ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, - Q_MSG_XDR_DECODING_FAILED, - "XDR decoding failed"); - rsp.op_ret = -1; - op_errno = EINVAL; - goto out; - } + op_errno = gf_error_to_errno(rsp.op_errno); + gf_stat_to_iatt(&rsp.postparent, &postparent); - op_errno = gf_error_to_errno (rsp.op_errno); - gf_stat_to_iatt (&rsp.postparent, &postparent); + if (rsp.op_ret == -1) + goto out; - if (rsp.op_ret == -1) - goto out; + rsp.op_ret = -1; + gf_stat_to_iatt(&rsp.stat, &stbuf); + GF_PROTOCOL_DICT_UNSERIALIZE(frame->this, xdata, (rsp.xdata.xdata_val), + (rsp.xdata.xdata_len), rsp.op_ret, op_errno, + out); + + if ((!gf_uuid_is_null(inode->gfid)) && + (gf_uuid_compare(stbuf.ia_gfid, inode->gfid) != 0)) { + gf_msg_debug(frame->this->name, ESTALE, "gfid changed for %s", + local->validate_loc.path); rsp.op_ret = -1; - gf_stat_to_iatt (&rsp.stat, &stbuf); - - GF_PROTOCOL_DICT_UNSERIALIZE (frame->this, xdata, (rsp.xdata.xdata_val), - (rsp.xdata.xdata_len), rsp.op_ret, - op_errno, out); - - if ((!gf_uuid_is_null (inode->gfid)) - && (gf_uuid_compare (stbuf.ia_gfid, inode->gfid) != 0)) { - gf_msg_debug (frame->this->name, ESTALE, - "gfid changed for %s", local->validate_loc.path); - rsp.op_ret = -1; - op_errno = ESTALE; - goto out; - } + op_errno = ESTALE; + goto out; + } - rsp.op_ret = 0; + rsp.op_ret = 0; out: - rsp.op_errno = op_errno; - - /* We need to retry connecting to quotad on ENOTCONN error. - * Suppose if there are two volumes vol1 and vol2, - * and quota is enabled and limit is set on vol1. - * Now if IO is happening on vol1 and quota is enabled/disabled - * on vol2, quotad gets restarted and client will receive - * ENOTCONN in the IO path of vol1 - */ - if (rsp.op_ret == -1 && rsp.op_errno == ENOTCONN) { - if (local->quotad_conn_retry >= 12) { - priv->quotad_conn_status = 1; - gf_log (this->name, GF_LOG_WARNING, "failed to connect " - "to quotad after retry count %d)", - local->quotad_conn_retry); - } else { - local->quotad_conn_retry++; - } - - if (priv->quotad_conn_status == 0) { - /* retry connecting after 5secs for 12 retries - * (up to 60sec). - */ - gf_log (this->name, GF_LOG_DEBUG, "retry connecting to " - "quotad (retry count %d)", - local->quotad_conn_retry); - - retry_delay.tv_sec = 5; - retry_delay.tv_nsec = 0; - timer = gf_timer_call_after (this->ctx, retry_delay, - _quota_enforcer_lookup, - (void *) frame); - if (timer == NULL) { - gf_log (this->name, GF_LOG_WARNING, "failed to " - "set quota_enforcer_lookup with timer"); - } else { - goto clean; - } - } + rsp.op_errno = op_errno; + + /* We need to retry connecting to quotad on ENOTCONN error. + * Suppose if there are two volumes vol1 and vol2, + * and quota is enabled and limit is set on vol1. + * Now if IO is happening on vol1 and quota is enabled/disabled + * on vol2, quotad gets restarted and client will receive + * ENOTCONN in the IO path of vol1 + */ + if (rsp.op_ret == -1 && rsp.op_errno == ENOTCONN) { + if (local->quotad_conn_retry >= 12) { + priv->quotad_conn_status = 1; + gf_log(this->name, GF_LOG_WARNING, + "failed to connect " + "to quotad after retry count %d)", + local->quotad_conn_retry); } else { - priv->quotad_conn_status = 0; + local->quotad_conn_retry++; } - if (rsp.op_ret == -1) { - /* any error other than ENOENT */ - if (rsp.op_errno != ENOENT) - gf_msg (this->name, GF_LOG_WARNING, rsp.op_errno, - Q_MSG_LOOKUP_FAILED, - "Getting cluster-wide size of directory failed " - "(path: %s gfid:%s)", local->validate_loc.path, - loc_gfid_utoa (&local->validate_loc)); - else - gf_msg_trace (this->name, ENOENT, - "not found on remote node"); - - } else if (local->quotad_conn_retry) { - gf_log (this->name, GF_LOG_DEBUG, "connected to quotad after " - "retry count %d", local->quotad_conn_retry); + if (priv->quotad_conn_status == 0) { + /* retry connecting after 5secs for 12 retries + * (up to 60sec). + */ + gf_log(this->name, GF_LOG_DEBUG, + "retry connecting to " + "quotad (retry count %d)", + local->quotad_conn_retry); + + retry_delay.tv_sec = 5; + retry_delay.tv_nsec = 0; + timer = gf_timer_call_after(this->ctx, retry_delay, + _quota_enforcer_lookup, (void *)frame); + if (timer == NULL) { + gf_log(this->name, GF_LOG_WARNING, + "failed to " + "set quota_enforcer_lookup with timer"); + } else { + goto clean; + } } + } else { + priv->quotad_conn_status = 0; + } + + if (rsp.op_ret == -1) { + /* any error other than ENOENT */ + if (rsp.op_errno != ENOENT) + gf_msg( + this->name, GF_LOG_WARNING, rsp.op_errno, Q_MSG_LOOKUP_FAILED, + "Getting cluster-wide size of directory failed " + "(path: %s gfid:%s)", + local->validate_loc.path, loc_gfid_utoa(&local->validate_loc)); + else + gf_msg_trace(this->name, ENOENT, "not found on remote node"); + + } else if (local->quotad_conn_retry) { + gf_log(this->name, GF_LOG_DEBUG, + "connected to quotad after " + "retry count %d", + local->quotad_conn_retry); + } - local->validate_cbk (frame, NULL, this, rsp.op_ret, rsp.op_errno, inode, - &stbuf, xdata, &postparent); + local->validate_cbk(frame, NULL, this, rsp.op_ret, rsp.op_errno, inode, + &stbuf, xdata, &postparent); clean: - if (xdata) - dict_unref (xdata); + if (xdata) + dict_unref(xdata); - free (rsp.xdata.xdata_val); + free(rsp.xdata.xdata_val); - return 0; + return 0; } void -_quota_enforcer_lookup (void *data) +_quota_enforcer_lookup(void *data) { - quota_local_t *local = NULL; - gfs3_lookup_req req = {{0,},}; - int ret = 0; - int op_errno = ESTALE; - quota_priv_t *priv = NULL; - call_frame_t *frame = NULL; - loc_t *loc = NULL; - xlator_t *this = NULL; - char *dir_path = NULL; - - frame = data; - local = frame->local; - this = local->this; - loc = &local->validate_loc; - - priv = this->private; - - if (!(loc && loc->inode)) - goto unwind; - - if (!gf_uuid_is_null (loc->inode->gfid)) - memcpy (req.gfid, loc->inode->gfid, 16); - else - memcpy (req.gfid, loc->gfid, 16); - - if (local->validate_xdata) { - GF_PROTOCOL_DICT_SERIALIZE (this, local->validate_xdata, - (&req.xdata.xdata_val), - req.xdata.xdata_len, - op_errno, unwind); - } - - if (loc->name) - req.bname = (char *)loc->name; - else - req.bname = ""; - - if (loc->path) - dir_path = (char *)loc->path; - else - dir_path = ""; - - ret = quota_enforcer_submit_request (&req, frame, - priv->quota_enforcer, - GF_AGGREGATOR_LOOKUP, - NULL, this, - quota_enforcer_lookup_cbk, - (xdrproc_t)xdr_gfs3_lookup_req); - - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, 0, - Q_MSG_RPC_SUBMIT_FAILED, "Couldn't send the request to " - "fetch cluster wide size of directory (path:%s gfid:%s)" - , dir_path, req.gfid); - } - - GF_FREE (req.xdata.xdata_val); - - return; + quota_local_t *local = NULL; + gfs3_lookup_req req = { + { + 0, + }, + }; + int ret = 0; + int op_errno = ESTALE; + quota_priv_t *priv = NULL; + call_frame_t *frame = NULL; + loc_t *loc = NULL; + xlator_t *this = NULL; + char *dir_path = NULL; + + frame = data; + local = frame->local; + this = local->this; + loc = &local->validate_loc; + + priv = this->private; + + if (!(loc && loc->inode)) + goto unwind; + + if (!gf_uuid_is_null(loc->inode->gfid)) + memcpy(req.gfid, loc->inode->gfid, 16); + else + memcpy(req.gfid, loc->gfid, 16); + + if (local->validate_xdata) { + GF_PROTOCOL_DICT_SERIALIZE(this, local->validate_xdata, + (&req.xdata.xdata_val), req.xdata.xdata_len, + op_errno, unwind); + } + + if (loc->name) + req.bname = (char *)loc->name; + else + req.bname = ""; + + if (loc->path) + dir_path = (char *)loc->path; + else + dir_path = ""; + + ret = quota_enforcer_submit_request( + &req, frame, priv->quota_enforcer, GF_AGGREGATOR_LOOKUP, NULL, this, + quota_enforcer_lookup_cbk, (xdrproc_t)xdr_gfs3_lookup_req); + + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, 0, Q_MSG_RPC_SUBMIT_FAILED, + "Couldn't send the request to " + "fetch cluster wide size of directory (path:%s gfid:%s)", + dir_path, req.gfid); + } + + GF_FREE(req.xdata.xdata_val); + + return; unwind: - local->validate_cbk (frame, NULL, this, -1, op_errno, NULL, NULL, NULL, - NULL); + local->validate_cbk(frame, NULL, this, -1, op_errno, NULL, NULL, NULL, + NULL); - GF_FREE (req.xdata.xdata_val); + GF_FREE(req.xdata.xdata_val); - return; + return; } int -quota_enforcer_lookup (call_frame_t *frame, xlator_t *this, dict_t *xdata, - fop_lookup_cbk_t validate_cbk) +quota_enforcer_lookup(call_frame_t *frame, xlator_t *this, dict_t *xdata, + fop_lookup_cbk_t validate_cbk) { - quota_local_t *local = NULL; + quota_local_t *local = NULL; - if (!frame || !this) - goto unwind; + if (!frame || !this) + goto unwind; - local = frame->local; - local->this = this; - local->validate_cbk = validate_cbk; - local->validate_xdata = dict_ref (xdata); + local = frame->local; + local->this = this; + local->validate_cbk = validate_cbk; + local->validate_xdata = dict_ref(xdata); - _quota_enforcer_lookup (frame); + _quota_enforcer_lookup(frame); - return 0; + return 0; unwind: - validate_cbk (frame, NULL, this, -1, ESTALE, NULL, NULL, NULL, NULL); + validate_cbk(frame, NULL, this, -1, ESTALE, NULL, NULL, NULL, NULL); - return 0; + return 0; } int -quota_enforcer_notify (struct rpc_clnt *rpc, void *mydata, - rpc_clnt_event_t event, void *data) +quota_enforcer_notify(struct rpc_clnt *rpc, void *mydata, + rpc_clnt_event_t event, void *data) { - xlator_t *this = NULL; - int ret = 0; + xlator_t *this = NULL; + int ret = 0; - this = mydata; + this = mydata; - switch (event) { - case RPC_CLNT_CONNECT: - { - gf_msg_trace (this->name, 0, "got RPC_CLNT_CONNECT"); - break; + switch (event) { + case RPC_CLNT_CONNECT: { + gf_msg_trace(this->name, 0, "got RPC_CLNT_CONNECT"); + break; } - case RPC_CLNT_DISCONNECT: - { - gf_msg_trace (this->name, 0, "got RPC_CLNT_DISCONNECT"); - break; + case RPC_CLNT_DISCONNECT: { + gf_msg_trace(this->name, 0, "got RPC_CLNT_DISCONNECT"); + break; } default: - gf_msg_trace (this->name, 0, - "got some other RPC event %d", event); - ret = 0; - break; - } + gf_msg_trace(this->name, 0, "got some other RPC event %d", event); + ret = 0; + break; + } - return ret; + return ret; } int -quota_enforcer_blocking_connect (rpc_clnt_t *rpc) +quota_enforcer_blocking_connect(rpc_clnt_t *rpc) { - dict_t *options = NULL; - int ret = -1; + dict_t *options = NULL; + int ret = -1; - options = dict_new (); - if (options == NULL) - goto out; + options = dict_new(); + if (options == NULL) + goto out; - ret = dict_set_str (options, "non-blocking-io", "no"); - if (ret) - goto out; + ret = dict_set_str(options, "non-blocking-io", "no"); + if (ret) + goto out; - rpc->conn.trans->reconfigure (rpc->conn.trans, options); + rpc->conn.trans->reconfigure(rpc->conn.trans, options); - rpc_clnt_start (rpc); + rpc_clnt_start(rpc); - ret = dict_set_str (options, "non-blocking-io", "yes"); - if (ret) - goto out; + ret = dict_set_str(options, "non-blocking-io", "yes"); + if (ret) + goto out; - rpc->conn.trans->reconfigure (rpc->conn.trans, options); + rpc->conn.trans->reconfigure(rpc->conn.trans, options); - ret = 0; + ret = 0; out: - if (options) - dict_unref (options); + if (options) + dict_unref(options); - return ret; + return ret; } -//Returns a started rpc_clnt. Creates a new rpc_clnt if quota_priv doesn't have -//one already +// Returns a started rpc_clnt. Creates a new rpc_clnt if quota_priv doesn't have +// one already struct rpc_clnt * -quota_enforcer_init (xlator_t *this, dict_t *options) +quota_enforcer_init(xlator_t *this, dict_t *options) { - struct rpc_clnt *rpc = NULL; - quota_priv_t *priv = NULL; - int ret = -1; + struct rpc_clnt *rpc = NULL; + quota_priv_t *priv = NULL; + int ret = -1; - priv = this->private; + priv = this->private; - LOCK (&priv->lock); - { - if (priv->rpc_clnt) { - ret = 0; - rpc = priv->rpc_clnt; - } + LOCK(&priv->lock); + { + if (priv->rpc_clnt) { + ret = 0; + rpc = priv->rpc_clnt; } - UNLOCK (&priv->lock); + } + UNLOCK(&priv->lock); - if (rpc) - goto out; + if (rpc) + goto out; - priv->quota_enforcer = "a_enforcer_clnt; + priv->quota_enforcer = "a_enforcer_clnt; - ret = dict_set_str (options, "transport.address-family", "unix"); - if (ret) - goto out; + ret = dict_set_str(options, "transport.address-family", "unix"); + if (ret) + goto out; - ret = dict_set_str (options, "transport-type", "socket"); - if (ret) - goto out; + ret = dict_set_str(options, "transport-type", "socket"); + if (ret) + goto out; - ret = dict_set_str (options, "transport.socket.connect-path", - "/var/run/gluster/quotad.socket"); - if (ret) - goto out; + ret = dict_set_str(options, "transport.socket.connect-path", + "/var/run/gluster/quotad.socket"); + if (ret) + goto out; - rpc = rpc_clnt_new (options, this, this->name, 16); - if (!rpc) { - ret = -1; - goto out; - } + rpc = rpc_clnt_new(options, this, this->name, 16); + if (!rpc) { + ret = -1; + goto out; + } - ret = rpc_clnt_register_notify (rpc, quota_enforcer_notify, this); - if (ret) { - gf_msg ("quota", GF_LOG_ERROR, 0, - Q_MSG_RPCCLNT_REGISTER_NOTIFY_FAILED, - "failed to register notify"); - goto out; - } + ret = rpc_clnt_register_notify(rpc, quota_enforcer_notify, this); + if (ret) { + gf_msg("quota", GF_LOG_ERROR, 0, Q_MSG_RPCCLNT_REGISTER_NOTIFY_FAILED, + "failed to register notify"); + goto out; + } - ret = quota_enforcer_blocking_connect (rpc); - if (ret) - goto out; + ret = quota_enforcer_blocking_connect(rpc); + if (ret) + goto out; - ret = 0; + ret = 0; out: - if (ret) { - if (rpc) - rpc_clnt_unref (rpc); - rpc = NULL; - } + if (ret) { + if (rpc) + rpc_clnt_unref(rpc); + rpc = NULL; + } - return rpc; - } + return rpc; +} struct rpc_clnt_procedure quota_enforcer_actors[GF_AGGREGATOR_MAXVALUE] = { - [GF_AGGREGATOR_NULL] = {"NULL", NULL}, - [GF_AGGREGATOR_LOOKUP] = {"LOOKUP", NULL}, + [GF_AGGREGATOR_NULL] = {"NULL", NULL}, + [GF_AGGREGATOR_LOOKUP] = {"LOOKUP", NULL}, }; struct rpc_clnt_program quota_enforcer_clnt = { - .progname = "Quota enforcer", - .prognum = GLUSTER_AGGREGATOR_PROGRAM, - .progver = GLUSTER_AGGREGATOR_VERSION, - .numproc = GF_AGGREGATOR_MAXVALUE, - .proctable = quota_enforcer_actors, + .progname = "Quota enforcer", + .prognum = GLUSTER_AGGREGATOR_PROGRAM, + .progver = GLUSTER_AGGREGATOR_VERSION, + .numproc = GF_AGGREGATOR_MAXVALUE, + .proctable = quota_enforcer_actors, }; diff --git a/xlators/features/quota/src/quota.c b/xlators/features/quota/src/quota.c index f0c225282a5..af3e8a48b7f 100644 --- a/xlators/features/quota/src/quota.c +++ b/xlators/features/quota/src/quota.c @@ -20,686 +20,683 @@ struct volume_options options[]; static int32_t -__quota_init_inode_ctx (inode_t *inode, xlator_t *this, - quota_inode_ctx_t **context) +__quota_init_inode_ctx(inode_t *inode, xlator_t *this, + quota_inode_ctx_t **context) { - int32_t ret = -1; - quota_inode_ctx_t *ctx = NULL; + int32_t ret = -1; + quota_inode_ctx_t *ctx = NULL; - if (inode == NULL) { - goto out; - } + if (inode == NULL) { + goto out; + } - QUOTA_ALLOC_OR_GOTO (ctx, quota_inode_ctx_t, out); + QUOTA_ALLOC_OR_GOTO(ctx, quota_inode_ctx_t, out); - LOCK_INIT(&ctx->lock); + LOCK_INIT(&ctx->lock); - if (context != NULL) { - *context = ctx; - } + if (context != NULL) { + *context = ctx; + } - INIT_LIST_HEAD (&ctx->parents); + INIT_LIST_HEAD(&ctx->parents); - ret = __inode_ctx_put (inode, this, (uint64_t )(long)ctx); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, 0, - Q_MSG_INODE_CTX_SET_FAILED, "cannot set quota context " - "in inode (gfid:%s)", uuid_utoa (inode->gfid)); - GF_FREE (ctx); - } + ret = __inode_ctx_put(inode, this, (uint64_t)(long)ctx); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, 0, Q_MSG_INODE_CTX_SET_FAILED, + "cannot set quota context " + "in inode (gfid:%s)", + uuid_utoa(inode->gfid)); + GF_FREE(ctx); + } out: - return ret; + return ret; } - static int32_t -quota_inode_ctx_get (inode_t *inode, xlator_t *this, - quota_inode_ctx_t **ctx, char create_if_absent) +quota_inode_ctx_get(inode_t *inode, xlator_t *this, quota_inode_ctx_t **ctx, + char create_if_absent) { - int32_t ret = 0; - uint64_t ctx_int; + int32_t ret = 0; + uint64_t ctx_int; - LOCK (&inode->lock); - { - ret = __inode_ctx_get (inode, this, &ctx_int); + LOCK(&inode->lock); + { + ret = __inode_ctx_get(inode, this, &ctx_int); - if ((ret == 0) && (ctx != NULL)) { - *ctx = (quota_inode_ctx_t *) (unsigned long)ctx_int; - } else if (create_if_absent) { - ret = __quota_init_inode_ctx (inode, this, ctx); - } + if ((ret == 0) && (ctx != NULL)) { + *ctx = (quota_inode_ctx_t *)(unsigned long)ctx_int; + } else if (create_if_absent) { + ret = __quota_init_inode_ctx(inode, this, ctx); } - UNLOCK (&inode->lock); + } + UNLOCK(&inode->lock); - return ret; + return ret; } int -quota_loc_fill (loc_t *loc, inode_t *inode, inode_t *parent, char *path) +quota_loc_fill(loc_t *loc, inode_t *inode, inode_t *parent, char *path) { - int ret = -1; + int ret = -1; - if (!loc || (inode == NULL)) - return ret; + if (!loc || (inode == NULL)) + return ret; - if (inode) { - loc->inode = inode_ref (inode); - gf_uuid_copy (loc->gfid, inode->gfid); - } + if (inode) { + loc->inode = inode_ref(inode); + gf_uuid_copy(loc->gfid, inode->gfid); + } - if (parent) { - loc->parent = inode_ref (parent); - } + if (parent) { + loc->parent = inode_ref(parent); + } - if (path != NULL) { - loc->path = gf_strdup (path); + if (path != NULL) { + loc->path = gf_strdup(path); - loc->name = strrchr (loc->path, '/'); - if (loc->name) { - loc->name++; - } + loc->name = strrchr(loc->path, '/'); + if (loc->name) { + loc->name++; } + } - ret = 0; + ret = 0; - return ret; + return ret; } - int -quota_inode_loc_fill (inode_t *inode, loc_t *loc) +quota_inode_loc_fill(inode_t *inode, loc_t *loc) { - char *resolvedpath = NULL; - inode_t *parent = NULL; - int ret = -1; - xlator_t *this = NULL; + char *resolvedpath = NULL; + inode_t *parent = NULL; + int ret = -1; + xlator_t *this = NULL; - if ((!inode) || (!loc)) { - return ret; - } + if ((!inode) || (!loc)) { + return ret; + } - this = THIS; + this = THIS; - if ((inode) && __is_root_gfid (inode->gfid)) { - loc->parent = NULL; - goto ignore_parent; - } + if ((inode) && __is_root_gfid(inode->gfid)) { + loc->parent = NULL; + goto ignore_parent; + } - parent = inode_parent (inode, 0, NULL); - if (!parent) { - gf_msg_debug (this->name, 0, "cannot find parent for " - "inode (gfid:%s)", uuid_utoa (inode->gfid)); - } + parent = inode_parent(inode, 0, NULL); + if (!parent) { + gf_msg_debug(this->name, 0, + "cannot find parent for " + "inode (gfid:%s)", + uuid_utoa(inode->gfid)); + } ignore_parent: - ret = inode_path (inode, NULL, &resolvedpath); - if (ret < 0) { - gf_msg_debug (this->name, 0, "cannot construct path for " - "inode (gfid:%s)", uuid_utoa (inode->gfid)); - } - - ret = quota_loc_fill (loc, inode, parent, resolvedpath); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, - "cannot fill loc"); - goto err; - } + ret = inode_path(inode, NULL, &resolvedpath); + if (ret < 0) { + gf_msg_debug(this->name, 0, + "cannot construct path for " + "inode (gfid:%s)", + uuid_utoa(inode->gfid)); + } + + ret = quota_loc_fill(loc, inode, parent, resolvedpath); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "cannot fill loc"); + goto err; + } err: - if (parent) { - inode_unref (parent); - } + if (parent) { + inode_unref(parent); + } - GF_FREE (resolvedpath); + GF_FREE(resolvedpath); - return ret; + return ret; } - int32_t -quota_local_cleanup (quota_local_t *local) +quota_local_cleanup(quota_local_t *local) { - if (local == NULL) { - goto out; - } + if (local == NULL) { + goto out; + } - loc_wipe (&local->loc); - loc_wipe (&local->newloc); - loc_wipe (&local->oldloc); - loc_wipe (&local->validate_loc); + loc_wipe(&local->loc); + loc_wipe(&local->newloc); + loc_wipe(&local->oldloc); + loc_wipe(&local->validate_loc); - inode_unref (local->inode); + inode_unref(local->inode); - if (local->xdata) - dict_unref (local->xdata); + if (local->xdata) + dict_unref(local->xdata); - if (local->validate_xdata) - dict_unref (local->validate_xdata); + if (local->validate_xdata) + dict_unref(local->validate_xdata); - if (local->stub) - call_stub_destroy (local->stub); + if (local->stub) + call_stub_destroy(local->stub); - LOCK_DESTROY (&local->lock); + LOCK_DESTROY(&local->lock); - mem_put (local); + mem_put(local); out: - return 0; + return 0; } - static quota_local_t * -quota_local_new () +quota_local_new() { - quota_local_t *local = NULL; - local = mem_get0 (THIS->local_pool); - if (local == NULL) - goto out; + quota_local_t *local = NULL; + local = mem_get0(THIS->local_pool); + if (local == NULL) + goto out; - LOCK_INIT (&local->lock); - local->space_available = -1; + LOCK_INIT(&local->lock); + local->space_available = -1; out: - return local; + return local; } - quota_dentry_t * -__quota_dentry_new (quota_inode_ctx_t *ctx, char *name, uuid_t par) +__quota_dentry_new(quota_inode_ctx_t *ctx, char *name, uuid_t par) { - quota_dentry_t *dentry = NULL; - GF_UNUSED int32_t ret = 0; + quota_dentry_t *dentry = NULL; + GF_UNUSED int32_t ret = 0; - QUOTA_ALLOC_OR_GOTO (dentry, quota_dentry_t, err); + QUOTA_ALLOC_OR_GOTO(dentry, quota_dentry_t, err); - INIT_LIST_HEAD (&dentry->next); + INIT_LIST_HEAD(&dentry->next); - dentry->name = gf_strdup (name); - if (dentry->name == NULL) { - GF_FREE (dentry); - dentry = NULL; - goto err; - } + dentry->name = gf_strdup(name); + if (dentry->name == NULL) { + GF_FREE(dentry); + dentry = NULL; + goto err; + } - gf_uuid_copy (dentry->par, par); + gf_uuid_copy(dentry->par, par); - if (ctx != NULL) - list_add_tail (&dentry->next, &ctx->parents); + if (ctx != NULL) + list_add_tail(&dentry->next, &ctx->parents); err: - return dentry; + return dentry; } - void -__quota_dentry_free (quota_dentry_t *dentry) +__quota_dentry_free(quota_dentry_t *dentry) { - if (dentry == NULL) { - goto out; - } + if (dentry == NULL) { + goto out; + } - list_del_init (&dentry->next); + list_del_init(&dentry->next); - GF_FREE (dentry->name); - GF_FREE (dentry); + GF_FREE(dentry->name); + GF_FREE(dentry); out: - return; + return; } void -__quota_dentry_del (quota_inode_ctx_t *ctx, const char *name, uuid_t par) +__quota_dentry_del(quota_inode_ctx_t *ctx, const char *name, uuid_t par) { - quota_dentry_t *dentry = NULL; - quota_dentry_t *tmp = NULL; - - list_for_each_entry_safe (dentry, tmp, &ctx->parents, next) { - if ((strcmp (dentry->name, name) == 0) && - (gf_uuid_compare (dentry->par, par) == 0)) { - __quota_dentry_free (dentry); - break; - } + quota_dentry_t *dentry = NULL; + quota_dentry_t *tmp = NULL; + + list_for_each_entry_safe(dentry, tmp, &ctx->parents, next) + { + if ((strcmp(dentry->name, name) == 0) && + (gf_uuid_compare(dentry->par, par) == 0)) { + __quota_dentry_free(dentry); + break; } + } } void -quota_dentry_del (quota_inode_ctx_t *ctx, const char *name, uuid_t par) +quota_dentry_del(quota_inode_ctx_t *ctx, const char *name, uuid_t par) { - LOCK (&ctx->lock); - { - __quota_dentry_del (ctx, name, par); - } - UNLOCK (&ctx->lock); + LOCK(&ctx->lock); + { + __quota_dentry_del(ctx, name, par); + } + UNLOCK(&ctx->lock); } -static inode_t* -__quota_inode_parent (inode_t *inode, uuid_t pargfid, const char *name) +static inode_t * +__quota_inode_parent(inode_t *inode, uuid_t pargfid, const char *name) { - inode_t *parent = NULL; + inode_t *parent = NULL; - parent = inode_parent (inode, pargfid, name); - inode_unref (inode); - return parent; + parent = inode_parent(inode, pargfid, name); + inode_unref(inode); + return parent; } -static inode_t* -quota_inode_parent (inode_t *inode, uuid_t pargfid, const char *name) +static inode_t * +quota_inode_parent(inode_t *inode, uuid_t pargfid, const char *name) { - inode_t *parent = NULL; + inode_t *parent = NULL; - parent = __quota_inode_parent (inode, pargfid, name); - if (!parent) - gf_msg_callingfn (THIS->name, GF_LOG_ERROR, 0, - Q_MSG_PARENT_NULL, - "Failed to find " - "ancestor for inode (%s)", - uuid_utoa(inode->gfid)); + parent = __quota_inode_parent(inode, pargfid, name); + if (!parent) + gf_msg_callingfn(THIS->name, GF_LOG_ERROR, 0, Q_MSG_PARENT_NULL, + "Failed to find " + "ancestor for inode (%s)", + uuid_utoa(inode->gfid)); - return parent; + return parent; } int32_t -quota_inode_depth (inode_t *inode) +quota_inode_depth(inode_t *inode) { - int depth = 0; - inode_t *cur_inode = NULL; - - cur_inode = inode_ref (inode); - while (cur_inode && !__is_root_gfid (cur_inode->gfid)) { - depth++; - cur_inode = quota_inode_parent (cur_inode, 0 , NULL); - if (!cur_inode) - depth = -1; - } + int depth = 0; + inode_t *cur_inode = NULL; - if (cur_inode) - inode_unref (cur_inode); + cur_inode = inode_ref(inode); + while (cur_inode && !__is_root_gfid(cur_inode->gfid)) { + depth++; + cur_inode = quota_inode_parent(cur_inode, 0, NULL); + if (!cur_inode) + depth = -1; + } + + if (cur_inode) + inode_unref(cur_inode); - return depth; + return depth; } -int32_t quota_find_common_ancestor (inode_t *inode1, inode_t *inode2, - uuid_t *common_ancestor) +int32_t +quota_find_common_ancestor(inode_t *inode1, inode_t *inode2, + uuid_t *common_ancestor) { - int32_t depth1 = 0; - int32_t depth2 = 0; - int32_t ret = -1; - inode_t *cur_inode1 = NULL; - inode_t *cur_inode2 = NULL; - - depth1 = quota_inode_depth (inode1); - if (depth1 < 0) - goto out; - - depth2 = quota_inode_depth (inode2); - if (depth2 < 0) - goto out; - - cur_inode1 = inode_ref (inode1); - cur_inode2 = inode_ref (inode2); - - while (cur_inode1 && depth1 > depth2) { - cur_inode1 = quota_inode_parent (cur_inode1, 0 , NULL); - depth1--; - } - - while (cur_inode2 && depth2 > depth1) { - cur_inode2 = quota_inode_parent (cur_inode2, 0 , NULL); - depth2--; - } - - while (depth1 && cur_inode1 && cur_inode2 && cur_inode1 != cur_inode2) { - cur_inode1 = quota_inode_parent (cur_inode1, 0 , NULL); - cur_inode2 = quota_inode_parent (cur_inode2, 0 , NULL); - depth1--; - } - - if (cur_inode1 && cur_inode2) { - gf_uuid_copy (*common_ancestor, cur_inode1->gfid); - ret = 0; - } + int32_t depth1 = 0; + int32_t depth2 = 0; + int32_t ret = -1; + inode_t *cur_inode1 = NULL; + inode_t *cur_inode2 = NULL; + + depth1 = quota_inode_depth(inode1); + if (depth1 < 0) + goto out; + + depth2 = quota_inode_depth(inode2); + if (depth2 < 0) + goto out; + + cur_inode1 = inode_ref(inode1); + cur_inode2 = inode_ref(inode2); + + while (cur_inode1 && depth1 > depth2) { + cur_inode1 = quota_inode_parent(cur_inode1, 0, NULL); + depth1--; + } + + while (cur_inode2 && depth2 > depth1) { + cur_inode2 = quota_inode_parent(cur_inode2, 0, NULL); + depth2--; + } + + while (depth1 && cur_inode1 && cur_inode2 && cur_inode1 != cur_inode2) { + cur_inode1 = quota_inode_parent(cur_inode1, 0, NULL); + cur_inode2 = quota_inode_parent(cur_inode2, 0, NULL); + depth1--; + } + + if (cur_inode1 && cur_inode2) { + gf_uuid_copy(*common_ancestor, cur_inode1->gfid); + ret = 0; + } out: - if (cur_inode1) - inode_unref (cur_inode1); + if (cur_inode1) + inode_unref(cur_inode1); - if (cur_inode2) - inode_unref (cur_inode2); + if (cur_inode2) + inode_unref(cur_inode2); - return ret; - } + return ret; +} void -check_ancestory_continue (struct list_head *parents, inode_t *inode, - int32_t op_ret, int32_t op_errno, void *data) +check_ancestory_continue(struct list_head *parents, inode_t *inode, + int32_t op_ret, int32_t op_errno, void *data) { - call_frame_t *frame = NULL; - quota_local_t *local = NULL; - uint32_t link_count = 0; - - frame = data; - local = frame->local; - - if (parents && list_empty (parents)) { - gf_msg (THIS->name, GF_LOG_WARNING, EIO, - Q_MSG_ANCESTRY_BUILD_FAILED, - "Couldn't build ancestry for inode (gfid:%s). " - "Without knowing ancestors till root, quota " - "cannot be enforced. " - "Hence, failing fop with EIO", - uuid_utoa (inode->gfid)); - op_errno = EIO; - op_ret = -1; - } - - LOCK (&local->lock); - { - link_count = --local->link_count; - if (op_ret < 0) { - local->op_ret = op_ret; - local->op_errno = op_errno; - } + call_frame_t *frame = NULL; + quota_local_t *local = NULL; + uint32_t link_count = 0; + + frame = data; + local = frame->local; + + if (parents && list_empty(parents)) { + gf_msg(THIS->name, GF_LOG_WARNING, EIO, Q_MSG_ANCESTRY_BUILD_FAILED, + "Couldn't build ancestry for inode (gfid:%s). " + "Without knowing ancestors till root, quota " + "cannot be enforced. " + "Hence, failing fop with EIO", + uuid_utoa(inode->gfid)); + op_errno = EIO; + op_ret = -1; + } + + LOCK(&local->lock); + { + link_count = --local->link_count; + if (op_ret < 0) { + local->op_ret = op_ret; + local->op_errno = op_errno; } - UNLOCK (&local->lock); + } + UNLOCK(&local->lock); - if (link_count == 0) - local->fop_continue_cbk (frame); + if (link_count == 0) + local->fop_continue_cbk(frame); } void -check_ancestory (call_frame_t *frame, inode_t *inode) +check_ancestory(call_frame_t *frame, inode_t *inode) { - inode_t *cur_inode = NULL; - inode_t *parent = NULL; - - cur_inode = inode_ref (inode); - while (cur_inode && !__is_root_gfid (cur_inode->gfid)) { - parent = inode_parent (cur_inode, 0, NULL); - if (!parent) { - quota_build_ancestry (cur_inode, - check_ancestory_continue, frame); - inode_unref (cur_inode); - return; - } - inode_unref (cur_inode); - cur_inode = parent; - } + inode_t *cur_inode = NULL; + inode_t *parent = NULL; - if (cur_inode) { - inode_unref (cur_inode); - check_ancestory_continue (NULL, NULL, 0, 0, frame); - } else { - check_ancestory_continue (NULL, NULL, -1, ESTALE, frame); - } + cur_inode = inode_ref(inode); + while (cur_inode && !__is_root_gfid(cur_inode->gfid)) { + parent = inode_parent(cur_inode, 0, NULL); + if (!parent) { + quota_build_ancestry(cur_inode, check_ancestory_continue, frame); + inode_unref(cur_inode); + return; + } + inode_unref(cur_inode); + cur_inode = parent; + } + + if (cur_inode) { + inode_unref(cur_inode); + check_ancestory_continue(NULL, NULL, 0, 0, frame); + } else { + check_ancestory_continue(NULL, NULL, -1, ESTALE, frame); + } } void -check_ancestory_2_cbk (struct list_head *parents, inode_t *inode, - int32_t op_ret, int32_t op_errno, void *data) +check_ancestory_2_cbk(struct list_head *parents, inode_t *inode, int32_t op_ret, + int32_t op_errno, void *data) { - inode_t *this_inode = NULL; - quota_inode_ctx_t *ctx = NULL; + inode_t *this_inode = NULL; + quota_inode_ctx_t *ctx = NULL; - this_inode = data; + this_inode = data; - if (op_ret < 0) - goto out; + if (op_ret < 0) + goto out; - if (parents == NULL || list_empty (parents)) { - gf_msg (THIS->name, GF_LOG_WARNING, 0, - Q_MSG_ENFORCEMENT_FAILED, - "Couldn't build ancestry for inode (gfid:%s). " - "Without knowing ancestors till root, quota " - "cannot be enforced.", - uuid_utoa (this_inode->gfid)); - goto out; - } + if (parents == NULL || list_empty(parents)) { + gf_msg(THIS->name, GF_LOG_WARNING, 0, Q_MSG_ENFORCEMENT_FAILED, + "Couldn't build ancestry for inode (gfid:%s). " + "Without knowing ancestors till root, quota " + "cannot be enforced.", + uuid_utoa(this_inode->gfid)); + goto out; + } - quota_inode_ctx_get (this_inode, THIS, &ctx, 0); - if (ctx) - ctx->ancestry_built = _gf_true; + quota_inode_ctx_get(this_inode, THIS, &ctx, 0); + if (ctx) + ctx->ancestry_built = _gf_true; out: - inode_unref (this_inode); + inode_unref(this_inode); } void -check_ancestory_2 (xlator_t *this, quota_local_t *local, inode_t *inode) +check_ancestory_2(xlator_t *this, quota_local_t *local, inode_t *inode) { - inode_t *cur_inode = NULL; - inode_t *parent = NULL; - quota_inode_ctx_t *ctx = NULL; - char *name = NULL; - uuid_t pgfid = {0}; - - name = (char *) local->loc.name; - if (local->loc.parent) { - gf_uuid_copy (pgfid, local->loc.parent->gfid); - } - - cur_inode = inode_ref (inode); - while (cur_inode && !__is_root_gfid (cur_inode->gfid)) { - quota_inode_ctx_get (cur_inode, this, &ctx, 0); - /* build ancestry is required only on the first lookup, - * so stop crawling when the inode_ctx is set for an inode - */ - if (ctx && ctx->ancestry_built) - goto setctx; - - parent = inode_parent (cur_inode, pgfid, name); - if (!parent) { - quota_build_ancestry (cur_inode, check_ancestory_2_cbk, - inode_ref (inode)); - goto out; - } + inode_t *cur_inode = NULL; + inode_t *parent = NULL; + quota_inode_ctx_t *ctx = NULL; + char *name = NULL; + uuid_t pgfid = {0}; + + name = (char *)local->loc.name; + if (local->loc.parent) { + gf_uuid_copy(pgfid, local->loc.parent->gfid); + } + + cur_inode = inode_ref(inode); + while (cur_inode && !__is_root_gfid(cur_inode->gfid)) { + quota_inode_ctx_get(cur_inode, this, &ctx, 0); + /* build ancestry is required only on the first lookup, + * so stop crawling when the inode_ctx is set for an inode + */ + if (ctx && ctx->ancestry_built) + goto setctx; - if (name != NULL) { - name = NULL; - gf_uuid_clear (pgfid); - } + parent = inode_parent(cur_inode, pgfid, name); + if (!parent) { + quota_build_ancestry(cur_inode, check_ancestory_2_cbk, + inode_ref(inode)); + goto out; + } - inode_unref (cur_inode); - cur_inode = parent; + if (name != NULL) { + name = NULL; + gf_uuid_clear(pgfid); } + inode_unref(cur_inode); + cur_inode = parent; + } + setctx: - if (cur_inode && cur_inode != inode) { - quota_inode_ctx_get (inode, this, &ctx, 0); - if (ctx) - ctx->ancestry_built = _gf_true; - } + if (cur_inode && cur_inode != inode) { + quota_inode_ctx_get(inode, this, &ctx, 0); + if (ctx) + ctx->ancestry_built = _gf_true; + } out: - if (cur_inode) - inode_unref (cur_inode); + if (cur_inode) + inode_unref(cur_inode); } static void -quota_link_count_decrement (call_frame_t *frame) +quota_link_count_decrement(call_frame_t *frame) { - call_frame_t *tmpframe = NULL; - quota_local_t *local = NULL; - call_stub_t *stub = NULL; - int link_count = -1; - - local = frame->local; - if (local && local->par_frame) { - local = local->par_frame->local; - tmpframe = frame; - } - - if (local == NULL) - goto out; - - LOCK (&local->lock); - { - link_count = --local->link_count; - if (link_count == 0) { - stub = local->stub; - local->stub = NULL; - } - } - UNLOCK (&local->lock); - - if (stub != NULL) { - call_resume (stub); - } + call_frame_t *tmpframe = NULL; + quota_local_t *local = NULL; + call_stub_t *stub = NULL; + int link_count = -1; + + local = frame->local; + if (local && local->par_frame) { + local = local->par_frame->local; + tmpframe = frame; + } + + if (local == NULL) + goto out; + + LOCK(&local->lock); + { + link_count = --local->link_count; + if (link_count == 0) { + stub = local->stub; + local->stub = NULL; + } + } + UNLOCK(&local->lock); + + if (stub != NULL) { + call_resume(stub); + } out: - if (tmpframe) { - local = tmpframe->local; - tmpframe->local = NULL; + if (tmpframe) { + local = tmpframe->local; + tmpframe->local = NULL; - STACK_DESTROY (frame->root); - if (local) - quota_local_cleanup (local); - } + STACK_DESTROY(frame->root); + if (local) + quota_local_cleanup(local); + } - return; + return; } static void -quota_handle_validate_error (call_frame_t *frame, int32_t op_ret, - int32_t op_errno) +quota_handle_validate_error(call_frame_t *frame, int32_t op_ret, + int32_t op_errno) { - quota_local_t *local; + quota_local_t *local; - local = frame->local; - if (local && local->par_frame) - local = local->par_frame->local; + local = frame->local; + if (local && local->par_frame) + local = local->par_frame->local; - if (local == NULL) - goto out; + if (local == NULL) + goto out; - LOCK (&local->lock); - { - if (op_ret < 0) { - local->op_ret = op_ret; - local->op_errno = op_errno; - } + LOCK(&local->lock); + { + if (op_ret < 0) { + local->op_ret = op_ret; + local->op_errno = op_errno; } - UNLOCK (&local->lock); + } + UNLOCK(&local->lock); - /* we abort checking limits on this path to root */ - quota_link_count_decrement (frame); + /* we abort checking limits on this path to root */ + quota_link_count_decrement(frame); out: - return; + return; } int32_t -quota_validate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *xdata, struct iatt *postparent) +quota_validate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *xdata, struct iatt *postparent) { - quota_local_t *local = NULL; - int32_t ret = 0; - quota_inode_ctx_t *ctx = NULL; - uint64_t value = 0; - quota_meta_t size = {0,}; - - local = frame->local; - - if (op_ret < 0) { - goto unwind; - } - - GF_ASSERT (local); - GF_ASSERT (frame); - GF_VALIDATE_OR_GOTO_WITH_ERROR ("quota", this, unwind, op_errno, - EINVAL); - GF_VALIDATE_OR_GOTO_WITH_ERROR (this->name, xdata, unwind, op_errno, - EINVAL); - - ret = inode_ctx_get (local->validate_loc.inode, this, &value); - - ctx = (quota_inode_ctx_t *)(unsigned long)value; - if ((ret == -1) || (ctx == NULL)) { - gf_msg (this->name, GF_LOG_WARNING, EINVAL, - Q_MSG_INODE_CTX_GET_FAILED, "quota context is" - " not present in inode (gfid:%s)", - uuid_utoa (local->validate_loc.inode->gfid)); - op_errno = EINVAL; - goto unwind; - } - - ret = quota_dict_get_meta (xdata, QUOTA_SIZE_KEY, &size); - if (ret == -1) { - gf_msg (this->name, GF_LOG_WARNING, EINVAL, - Q_MSG_SIZE_KEY_MISSING, "quota size key not present " - "in dict"); - op_errno = EINVAL; - } - - local->just_validated = 1; /* so that we don't go into infinite - * loop of validation and checking - * limit when timeout is zero. - */ - LOCK (&ctx->lock); - { - ctx->size = size.size; - ctx->file_count = size.file_count; - ctx->dir_count = size.dir_count; - gettimeofday (&ctx->tv, NULL); - } - UNLOCK (&ctx->lock); - - quota_check_limit (frame, local->validate_loc.inode, this); - return 0; + quota_local_t *local = NULL; + int32_t ret = 0; + quota_inode_ctx_t *ctx = NULL; + uint64_t value = 0; + quota_meta_t size = { + 0, + }; + + local = frame->local; + + if (op_ret < 0) { + goto unwind; + } + + GF_ASSERT(local); + GF_ASSERT(frame); + GF_VALIDATE_OR_GOTO_WITH_ERROR("quota", this, unwind, op_errno, EINVAL); + GF_VALIDATE_OR_GOTO_WITH_ERROR(this->name, xdata, unwind, op_errno, EINVAL); + + ret = inode_ctx_get(local->validate_loc.inode, this, &value); + + ctx = (quota_inode_ctx_t *)(unsigned long)value; + if ((ret == -1) || (ctx == NULL)) { + gf_msg(this->name, GF_LOG_WARNING, EINVAL, Q_MSG_INODE_CTX_GET_FAILED, + "quota context is" + " not present in inode (gfid:%s)", + uuid_utoa(local->validate_loc.inode->gfid)); + op_errno = EINVAL; + goto unwind; + } + + ret = quota_dict_get_meta(xdata, QUOTA_SIZE_KEY, &size); + if (ret == -1) { + gf_msg(this->name, GF_LOG_WARNING, EINVAL, Q_MSG_SIZE_KEY_MISSING, + "quota size key not present " + "in dict"); + op_errno = EINVAL; + } + + local->just_validated = 1; /* so that we don't go into infinite + * loop of validation and checking + * limit when timeout is zero. + */ + LOCK(&ctx->lock); + { + ctx->size = size.size; + ctx->file_count = size.file_count; + ctx->dir_count = size.dir_count; + gettimeofday(&ctx->tv, NULL); + } + UNLOCK(&ctx->lock); + + quota_check_limit(frame, local->validate_loc.inode, this); + return 0; unwind: - quota_handle_validate_error (frame, op_ret, op_errno); - return 0; + quota_handle_validate_error(frame, op_ret, op_errno); + return 0; } - static uint64_t -quota_time_elapsed (struct timeval *now, struct timeval *then) +quota_time_elapsed(struct timeval *now, struct timeval *then) { - return (now->tv_sec - then->tv_sec); + return (now->tv_sec - then->tv_sec); } - int32_t -quota_timeout (struct timeval *tv, int32_t timeout) +quota_timeout(struct timeval *tv, int32_t timeout) { - struct timeval now = {0,}; - int32_t timed_out = 0; + struct timeval now = { + 0, + }; + int32_t timed_out = 0; - gettimeofday (&now, NULL); + gettimeofday(&now, NULL); - if (quota_time_elapsed (&now, tv) >= timeout) { - timed_out = 1; - } + if (quota_time_elapsed(&now, tv) >= timeout) { + timed_out = 1; + } - return timed_out; + return timed_out; } /* Return: 1 if new entry added * 0 no entry added */ static int32_t -quota_add_parent (struct list_head *list, char *name, uuid_t pgfid) +quota_add_parent(struct list_head *list, char *name, uuid_t pgfid) { - quota_dentry_t *entry = NULL; - gf_boolean_t found = _gf_false; + quota_dentry_t *entry = NULL; + gf_boolean_t found = _gf_false; - if (list == NULL) { - goto out; - } + if (list == NULL) { + goto out; + } - list_for_each_entry (entry, list, next) { - if (gf_uuid_compare (pgfid, entry->par) == 0) { - found = _gf_true; - goto out; - } + list_for_each_entry(entry, list, next) + { + if (gf_uuid_compare(pgfid, entry->par) == 0) { + found = _gf_true; + goto out; } + } - entry = __quota_dentry_new (NULL, name, pgfid); - if (entry) - list_add_tail (&entry->next, list); + entry = __quota_dentry_new(NULL, name, pgfid); + if (entry) + list_add_tail(&entry->next, list); out: - if (found) - return 0; - else - return 1; - + if (found) + return 0; + else + return 1; } /* This function iterates the parent list in inode @@ -707,4063 +704,3942 @@ out: * Returns number of dentry added to the list */ static int32_t -quota_add_parents_from_ctx (quota_inode_ctx_t *ctx, struct list_head *list) +quota_add_parents_from_ctx(quota_inode_ctx_t *ctx, struct list_head *list) { - int ret = 0; - quota_dentry_t *dentry = NULL; - int32_t count = 0; + int ret = 0; + quota_dentry_t *dentry = NULL; + int32_t count = 0; - if (ctx == NULL || list == NULL) - goto out; + if (ctx == NULL || list == NULL) + goto out; - LOCK (&ctx->lock); + LOCK(&ctx->lock); + { + list_for_each_entry(dentry, &ctx->parents, next) { - list_for_each_entry (dentry, &ctx->parents, next) { - ret = quota_add_parent (list, dentry->name, - dentry->par); + ret = quota_add_parent(list, dentry->name, dentry->par); - if (ret == 1) - count++; - } + if (ret == 1) + count++; } - UNLOCK (&ctx->lock); + } + UNLOCK(&ctx->lock); out: - return count; + return count; } int32_t -quota_build_ancestry_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, - gf_dirent_t *entries, dict_t *xdata) +quota_build_ancestry_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, + dict_t *xdata) { - inode_t *parent = NULL; - inode_t *tmp_parent = NULL; - inode_t *linked_inode = NULL; - inode_t *tmp_inode = NULL; - gf_dirent_t *entry = NULL; - loc_t loc = {0, }; - quota_dentry_t *dentry = NULL; - quota_dentry_t *tmp = NULL; - quota_inode_ctx_t *ctx = NULL; - struct list_head parents = {0, }; - quota_local_t *local = NULL; - - INIT_LIST_HEAD (&parents); - - local = frame->local; - frame->local = NULL; - - if (op_ret < 0) - goto err; + inode_t *parent = NULL; + inode_t *tmp_parent = NULL; + inode_t *linked_inode = NULL; + inode_t *tmp_inode = NULL; + gf_dirent_t *entry = NULL; + loc_t loc = { + 0, + }; + quota_dentry_t *dentry = NULL; + quota_dentry_t *tmp = NULL; + quota_inode_ctx_t *ctx = NULL; + struct list_head parents = { + 0, + }; + quota_local_t *local = NULL; + + INIT_LIST_HEAD(&parents); + + local = frame->local; + frame->local = NULL; + + if (op_ret < 0) + goto err; + + if ((op_ret > 0) && (entries != NULL)) { + list_for_each_entry(entry, &entries->list, list) + { + if (__is_root_gfid(entry->inode->gfid)) { + /* The list contains a sub-list for each + * possible path to the target inode. Each + * sub-list starts with the root entry of the + * tree and is followed by the child entries + * for a particular path to the target entry. + * The root entry is an implied sub-list + * delimiter, as it denotes we have started + * processing a new path. Reset the parent + * pointer and continue + */ - if ((op_ret > 0) && (entries != NULL)) { - list_for_each_entry (entry, &entries->list, list) { - if (__is_root_gfid (entry->inode->gfid)) { - /* The list contains a sub-list for each - * possible path to the target inode. Each - * sub-list starts with the root entry of the - * tree and is followed by the child entries - * for a particular path to the target entry. - * The root entry is an implied sub-list - * delimiter, as it denotes we have started - * processing a new path. Reset the parent - * pointer and continue - */ - - tmp_parent = NULL; - } else { - /* For a non-root entry, link this inode */ - linked_inode = inode_link (entry->inode, - tmp_parent, - entry->d_name, - &entry->d_stat); - if (linked_inode) { - tmp_inode = entry->inode; - entry->inode = linked_inode; - inode_unref (tmp_inode); - } else { - gf_msg (this->name, GF_LOG_WARNING, - EINVAL, Q_MSG_PARENT_NULL, - "inode link failed"); - op_errno = EINVAL; - goto err; - } - } - - gf_uuid_copy (loc.gfid, entry->d_stat.ia_gfid); - - loc.inode = inode_ref (entry->inode); - loc.parent = inode_ref (tmp_parent); - loc.name = entry->d_name; - - quota_fill_inodectx (this, entry->inode, entry->dict, - &loc, &entry->d_stat, &op_errno); - - /* For non-directory, posix_get_ancestry_non_directory - * returns all hard-links that are represented by nodes - * adjacent to each other in the dentry-list. - * (Unlike the directory case where adjacent nodes - * either have a parent/child relationship or belong to - * different paths). - */ - if (entry->inode->ia_type == IA_IFDIR) - tmp_parent = entry->inode; - - loc_wipe (&loc); + tmp_parent = NULL; + } else { + /* For a non-root entry, link this inode */ + linked_inode = inode_link(entry->inode, tmp_parent, + entry->d_name, &entry->d_stat); + if (linked_inode) { + tmp_inode = entry->inode; + entry->inode = linked_inode; + inode_unref(tmp_inode); + } else { + gf_msg(this->name, GF_LOG_WARNING, EINVAL, + Q_MSG_PARENT_NULL, "inode link failed"); + op_errno = EINVAL; + goto err; } - } - - parent = inode_parent (local->loc.inode, 0, NULL); - if (parent == NULL) { - gf_msg (this->name, GF_LOG_WARNING, EINVAL, - Q_MSG_PARENT_NULL, "parent is NULL"); - op_errno = EINVAL; - goto err; - } + } - quota_inode_ctx_get (local->loc.inode, this, &ctx, 0); + gf_uuid_copy(loc.gfid, entry->d_stat.ia_gfid); - quota_add_parents_from_ctx (ctx, &parents); + loc.inode = inode_ref(entry->inode); + loc.parent = inode_ref(tmp_parent); + loc.name = entry->d_name; - if (list_empty (&parents)) { - /* we built ancestry for a directory */ - list_for_each_entry (entry, &entries->list, list) { - if (entry->inode == local->loc.inode) - break; - } + quota_fill_inodectx(this, entry->inode, entry->dict, &loc, + &entry->d_stat, &op_errno); - /* Getting assertion here, need to investigate - comment for now - GF_ASSERT (&entry->list != &entries->list); - */ + /* For non-directory, posix_get_ancestry_non_directory + * returns all hard-links that are represented by nodes + * adjacent to each other in the dentry-list. + * (Unlike the directory case where adjacent nodes + * either have a parent/child relationship or belong to + * different paths). + */ + if (entry->inode->ia_type == IA_IFDIR) + tmp_parent = entry->inode; - quota_add_parent (&parents, entry->d_name, parent->gfid); + loc_wipe(&loc); } + } - local->ancestry_cbk (&parents, local->loc.inode, 0, 0, - local->ancestry_data); - goto cleanup; + parent = inode_parent(local->loc.inode, 0, NULL); + if (parent == NULL) { + gf_msg(this->name, GF_LOG_WARNING, EINVAL, Q_MSG_PARENT_NULL, + "parent is NULL"); + op_errno = EINVAL; + goto err; + } -err: - local->ancestry_cbk (NULL, NULL, -1, op_errno, local->ancestry_data); - -cleanup: - STACK_DESTROY (frame->root); - quota_local_cleanup (local); + quota_inode_ctx_get(local->loc.inode, this, &ctx, 0); - if (parent != NULL) { - inode_unref (parent); - parent = NULL; - } + quota_add_parents_from_ctx(ctx, &parents); - list_for_each_entry_safe (dentry, tmp, &parents, next) { - __quota_dentry_free (dentry); + if (list_empty(&parents)) { + /* we built ancestry for a directory */ + list_for_each_entry(entry, &entries->list, list) + { + if (entry->inode == local->loc.inode) + break; } - return 0; -} - -int -quota_build_ancestry (inode_t *inode, quota_ancestry_built_t ancestry_cbk, - void *data) -{ - fd_t *fd = NULL; - quota_local_t *local = NULL; - call_frame_t *new_frame = NULL; - int op_errno = ENOMEM; - int op_ret = -1; - xlator_t *this = NULL; - dict_t *xdata_req = NULL; - - this = THIS; - - xdata_req = dict_new (); - if (xdata_req == NULL) - goto err; - - fd = fd_anonymous (inode); - if (fd == NULL) - goto err; + /* Getting assertion here, need to investigate + comment for now + GF_ASSERT (&entry->list != &entries->list); + */ - new_frame = create_frame (this, this->ctx->pool); - if (new_frame == NULL) - goto err; + quota_add_parent(&parents, entry->d_name, parent->gfid); + } - local = quota_local_new (); - if (local == NULL) - goto err; + local->ancestry_cbk(&parents, local->loc.inode, 0, 0, local->ancestry_data); + goto cleanup; - new_frame->root->uid = new_frame->root->gid = 0; - new_frame->local = local; - local->ancestry_cbk = ancestry_cbk; - local->ancestry_data = data; - local->loc.inode = inode_ref (inode); +err: + local->ancestry_cbk(NULL, NULL, -1, op_errno, local->ancestry_data); - op_ret = dict_set_int8 (xdata_req, QUOTA_LIMIT_KEY, 1); - if (op_ret < 0) { - op_errno = -op_ret; - goto err; - } +cleanup: + STACK_DESTROY(frame->root); + quota_local_cleanup(local); - op_ret = dict_set_int8 (xdata_req, QUOTA_LIMIT_OBJECTS_KEY, 1); - if (op_ret < 0) { - op_errno = -op_ret; - goto err; - } + if (parent != NULL) { + inode_unref(parent); + parent = NULL; + } - op_ret = dict_set_int8 (xdata_req, GET_ANCESTRY_DENTRY_KEY, 1); - if (op_ret < 0) { - op_errno = -op_ret; - goto err; - } + list_for_each_entry_safe(dentry, tmp, &parents, next) + { + __quota_dentry_free(dentry); + } - /* This would ask posix layer to construct dentry chain till root - * We don't need to do a opendir, we can use the anonymous fd - * here for the readidrp. - * avoiding opendir also reduces the window size where another FOP - * can be executed before completion of build ancestry - */ - STACK_WIND (new_frame, quota_build_ancestry_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readdirp, fd, 0, 0, xdata_req); + return 0; +} - op_ret = 0; +int +quota_build_ancestry(inode_t *inode, quota_ancestry_built_t ancestry_cbk, + void *data) +{ + fd_t *fd = NULL; + quota_local_t *local = NULL; + call_frame_t *new_frame = NULL; + int op_errno = ENOMEM; + int op_ret = -1; + xlator_t *this = NULL; + dict_t *xdata_req = NULL; + + this = THIS; + + xdata_req = dict_new(); + if (xdata_req == NULL) + goto err; + + fd = fd_anonymous(inode); + if (fd == NULL) + goto err; + + new_frame = create_frame(this, this->ctx->pool); + if (new_frame == NULL) + goto err; + + local = quota_local_new(); + if (local == NULL) + goto err; + + new_frame->root->uid = new_frame->root->gid = 0; + new_frame->local = local; + local->ancestry_cbk = ancestry_cbk; + local->ancestry_data = data; + local->loc.inode = inode_ref(inode); + + op_ret = dict_set_int8(xdata_req, QUOTA_LIMIT_KEY, 1); + if (op_ret < 0) { + op_errno = -op_ret; + goto err; + } + + op_ret = dict_set_int8(xdata_req, QUOTA_LIMIT_OBJECTS_KEY, 1); + if (op_ret < 0) { + op_errno = -op_ret; + goto err; + } + + op_ret = dict_set_int8(xdata_req, GET_ANCESTRY_DENTRY_KEY, 1); + if (op_ret < 0) { + op_errno = -op_ret; + goto err; + } + + /* This would ask posix layer to construct dentry chain till root + * We don't need to do a opendir, we can use the anonymous fd + * here for the readidrp. + * avoiding opendir also reduces the window size where another FOP + * can be executed before completion of build ancestry + */ + STACK_WIND(new_frame, quota_build_ancestry_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readdirp, fd, 0, 0, xdata_req); + + op_ret = 0; err: - if (fd) - fd_unref (fd); + if (fd) + fd_unref(fd); - if (xdata_req) - dict_unref (xdata_req); - - if (op_ret < 0) { - ancestry_cbk (NULL, NULL, -1, op_errno, data); + if (xdata_req) + dict_unref(xdata_req); - if (new_frame) { - local = new_frame->local; - new_frame->local = NULL; - STACK_DESTROY (new_frame->root); - } + if (op_ret < 0) { + ancestry_cbk(NULL, NULL, -1, op_errno, data); - if (local) - quota_local_cleanup (local); + if (new_frame) { + local = new_frame->local; + new_frame->local = NULL; + STACK_DESTROY(new_frame->root); } - return 0; + if (local) + quota_local_cleanup(local); + } + + return 0; } int -quota_validate (call_frame_t *frame, inode_t *inode, xlator_t *this, - fop_lookup_cbk_t cbk_fn) +quota_validate(call_frame_t *frame, inode_t *inode, xlator_t *this, + fop_lookup_cbk_t cbk_fn) { - quota_local_t *local = NULL; - int ret = 0; - dict_t *xdata = NULL; - quota_priv_t *priv = NULL; - - local = frame->local; - priv = this->private; - - LOCK (&local->lock); - { - loc_wipe (&local->validate_loc); - - ret = quota_inode_loc_fill (inode, &local->validate_loc); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENFORCEMENT_FAILED, - "cannot fill loc for inode (gfid:%s), hence " - "aborting quota-checks and continuing with fop", - uuid_utoa (inode->gfid)); - } - } - UNLOCK (&local->lock); + quota_local_t *local = NULL; + int ret = 0; + dict_t *xdata = NULL; + quota_priv_t *priv = NULL; - if (ret < 0) { - ret = -ENOMEM; - goto err; - } - - xdata = dict_new (); - if (xdata == NULL) { - ret = -ENOMEM; - goto err; - } - - ret = dict_set_int8 (xdata, QUOTA_SIZE_KEY, 1); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "dict set failed"); - ret = -ENOMEM; - goto err; - } + local = frame->local; + priv = this->private; - ret = dict_set_str (xdata, "volume-uuid", priv->volume_uuid); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "dict set failed"); - ret = -ENOMEM; - goto err; - } + LOCK(&local->lock); + { + loc_wipe(&local->validate_loc); - ret = quota_enforcer_lookup (frame, this, xdata, cbk_fn); + ret = quota_inode_loc_fill(inode, &local->validate_loc); if (ret < 0) { - ret = -ENOTCONN; - goto err; - } - - ret = 0; + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENFORCEMENT_FAILED, + "cannot fill loc for inode (gfid:%s), hence " + "aborting quota-checks and continuing with fop", + uuid_utoa(inode->gfid)); + } + } + UNLOCK(&local->lock); + + if (ret < 0) { + ret = -ENOMEM; + goto err; + } + + xdata = dict_new(); + if (xdata == NULL) { + ret = -ENOMEM; + goto err; + } + + ret = dict_set_int8(xdata, QUOTA_SIZE_KEY, 1); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "dict set failed"); + ret = -ENOMEM; + goto err; + } + + ret = dict_set_str(xdata, "volume-uuid", priv->volume_uuid); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "dict set failed"); + ret = -ENOMEM; + goto err; + } + + ret = quota_enforcer_lookup(frame, this, xdata, cbk_fn); + if (ret < 0) { + ret = -ENOTCONN; + goto err; + } + + ret = 0; err: - if (xdata) - dict_unref (xdata); + if (xdata) + dict_unref(xdata); - return ret; + return ret; } void -quota_check_limit_continuation (struct list_head *parents, inode_t *inode, - int32_t op_ret, int32_t op_errno, void *data) +quota_check_limit_continuation(struct list_head *parents, inode_t *inode, + int32_t op_ret, int32_t op_errno, void *data) { - call_frame_t *frame = NULL; - xlator_t *this = NULL; - quota_local_t *local = NULL; - quota_local_t *par_local = NULL; - quota_dentry_t *entry = NULL; - inode_t *parent = NULL; - int parent_count = 0; - - frame = data; - local = frame->local; - this = THIS; - - if (local->par_frame) - par_local = local->par_frame->local; - else - par_local = local; - - - if ((op_ret < 0) || list_empty (parents)) { - if (op_ret >= 0) { - gf_msg (this->name, GF_LOG_WARNING, EIO, - Q_MSG_ANCESTRY_BUILD_FAILED, - "Couldn't build ancestry for inode (gfid:%s). " - "Without knowing ancestors till root, quota" - "cannot be enforced. " - "Hence, failing fop with EIO", - uuid_utoa (inode->gfid)); - op_errno = EIO; - } - - quota_handle_validate_error (frame, -1, op_errno); - goto out; + call_frame_t *frame = NULL; + xlator_t *this = NULL; + quota_local_t *local = NULL; + quota_local_t *par_local = NULL; + quota_dentry_t *entry = NULL; + inode_t *parent = NULL; + int parent_count = 0; + + frame = data; + local = frame->local; + this = THIS; + + if (local->par_frame) + par_local = local->par_frame->local; + else + par_local = local; + + if ((op_ret < 0) || list_empty(parents)) { + if (op_ret >= 0) { + gf_msg(this->name, GF_LOG_WARNING, EIO, Q_MSG_ANCESTRY_BUILD_FAILED, + "Couldn't build ancestry for inode (gfid:%s). " + "Without knowing ancestors till root, quota" + "cannot be enforced. " + "Hence, failing fop with EIO", + uuid_utoa(inode->gfid)); + op_errno = EIO; + } + + quota_handle_validate_error(frame, -1, op_errno); + goto out; + } + + list_for_each_entry(entry, parents, next) { parent_count++; } + + LOCK(&par_local->lock); + { + par_local->link_count += (parent_count - 1); + } + UNLOCK(&par_local->lock); + + if (local->par_frame) { + list_for_each_entry(entry, parents, next) + { + parent = inode_find(inode->table, entry->par); + quota_check_limit(frame, parent, this); + inode_unref(parent); } - - list_for_each_entry (entry, parents, next) { - parent_count++; + } else { + list_for_each_entry(entry, parents, next) + { + parent = do_quota_check_limit(frame, inode, this, entry, _gf_true); + if (parent) + inode_unref(parent); + else + quota_link_count_decrement(frame); } + } + +out: + return; +} - LOCK (&par_local->lock); +int32_t +quota_check_object_limit(call_frame_t *frame, quota_inode_ctx_t *ctx, + quota_priv_t *priv, inode_t *_inode, xlator_t *this, + int32_t *op_errno, int just_validated, + quota_local_t *local, gf_boolean_t *skip_check) +{ + int32_t ret = -1; + uint32_t timeout = 0; + char need_validate = 0; + gf_boolean_t hard_limit_exceeded = 0; + int64_t object_aggr_count = 0; + + GF_ASSERT(frame); + GF_ASSERT(priv); + GF_ASSERT(_inode); + GF_ASSERT(this); + GF_ASSERT(local); + + if (ctx != NULL && (ctx->object_hard_lim > 0 || ctx->object_soft_lim)) { + LOCK(&ctx->lock); { - par_local->link_count += (parent_count - 1); + timeout = priv->soft_timeout; + + object_aggr_count = ctx->file_count + ctx->dir_count + 1; + if (((ctx->object_soft_lim >= 0) && + (object_aggr_count) > ctx->object_soft_lim)) { + timeout = priv->hard_timeout; + } + + if (!just_validated && quota_timeout(&ctx->tv, timeout)) { + need_validate = 1; + } else if ((object_aggr_count) > ctx->object_hard_lim) { + hard_limit_exceeded = 1; + } + } + UNLOCK(&ctx->lock); + + if (need_validate && *skip_check != _gf_true) { + *skip_check = _gf_true; + ret = quota_validate(frame, _inode, this, quota_validate_cbk); + if (ret < 0) { + *op_errno = -ret; + *skip_check = _gf_false; + } + goto out; } - UNLOCK (&par_local->lock); - if (local->par_frame) { - list_for_each_entry (entry, parents, next) { - parent = inode_find (inode->table, entry->par); - quota_check_limit (frame, parent, this); - inode_unref (parent); - } - } else { - list_for_each_entry (entry, parents, next) { - parent = do_quota_check_limit (frame, inode, this, - entry, _gf_true); - if (parent) - inode_unref (parent); - else - quota_link_count_decrement (frame); - } + if (hard_limit_exceeded) { + local->op_ret = -1; + local->op_errno = EDQUOT; + *op_errno = EDQUOT; + goto out; } + /*We log usage only if quota limit is configured on + that inode + */ + quota_log_usage(this, ctx, _inode, 0); + } + + ret = 0; + out: - return; + return ret; } int32_t -quota_check_object_limit (call_frame_t *frame, quota_inode_ctx_t *ctx, - quota_priv_t *priv, inode_t *_inode, xlator_t *this, - int32_t *op_errno, int just_validated, - quota_local_t *local, gf_boolean_t *skip_check) +quota_check_size_limit(call_frame_t *frame, quota_inode_ctx_t *ctx, + quota_priv_t *priv, inode_t *_inode, xlator_t *this, + int32_t *op_errno, int just_validated, int64_t delta, + quota_local_t *local, gf_boolean_t *skip_check) { - int32_t ret = -1; - uint32_t timeout = 0; - char need_validate = 0; - gf_boolean_t hard_limit_exceeded = 0; - int64_t object_aggr_count = 0; - - GF_ASSERT (frame); - GF_ASSERT (priv); - GF_ASSERT (_inode); - GF_ASSERT (this); - GF_ASSERT (local); - - if (ctx != NULL && (ctx->object_hard_lim > 0 || - ctx->object_soft_lim)) { - LOCK (&ctx->lock); - { - timeout = priv->soft_timeout; - - object_aggr_count = ctx->file_count + - ctx->dir_count + 1; - if (((ctx->object_soft_lim >= 0) - && (object_aggr_count) > - ctx->object_soft_lim)) { - timeout = priv->hard_timeout; - } - - if (!just_validated - && quota_timeout (&ctx->tv, timeout)) { - need_validate = 1; - } else if ((object_aggr_count) > - ctx->object_hard_lim) { - hard_limit_exceeded = 1; - } - } - UNLOCK (&ctx->lock); - - if (need_validate && *skip_check != _gf_true) { - *skip_check = _gf_true; - ret = quota_validate (frame, _inode, this, - quota_validate_cbk); - if (ret < 0) { - *op_errno = -ret; - *skip_check = _gf_false; - } - goto out; - } + int32_t ret = -1; + uint32_t timeout = 0; + char need_validate = 0; + gf_boolean_t hard_limit_exceeded = 0; + int64_t space_available = 0; + int64_t wouldbe_size = 0; + + GF_ASSERT(frame); + GF_ASSERT(priv); + GF_ASSERT(_inode); + GF_ASSERT(this); + GF_ASSERT(local); + + if (ctx != NULL && (ctx->hard_lim > 0 || ctx->soft_lim > 0)) { + wouldbe_size = ctx->size + delta; + + LOCK(&ctx->lock); + { + timeout = priv->soft_timeout; + + if ((ctx->soft_lim >= 0) && (wouldbe_size > ctx->soft_lim)) { + timeout = priv->hard_timeout; + } + + if (!just_validated && quota_timeout(&ctx->tv, timeout)) { + need_validate = 1; + } else if (wouldbe_size >= ctx->hard_lim) { + hard_limit_exceeded = 1; + } + } + UNLOCK(&ctx->lock); + + if (need_validate && *skip_check != _gf_true) { + *skip_check = _gf_true; + ret = quota_validate(frame, _inode, this, quota_validate_cbk); + if (ret < 0) { + *op_errno = -ret; + *skip_check = _gf_false; + } + goto out; + } - if (hard_limit_exceeded) { - local->op_ret = -1; - local->op_errno = EDQUOT; - *op_errno = EDQUOT; - goto out; - } + if (hard_limit_exceeded) { + local->op_ret = -1; + local->op_errno = EDQUOT; - /*We log usage only if quota limit is configured on - that inode - */ - quota_log_usage (this, ctx, _inode, 0); + space_available = ctx->hard_lim - ctx->size; + + if (space_available < 0) + space_available = 0; + + if ((local->space_available < 0) || + (local->space_available > space_available)) { + local->space_available = space_available; + } + + if (space_available == 0) { + *op_errno = EDQUOT; + goto out; + } } - ret = 0; + /* We log usage only if quota limit is configured on + that inode. */ + quota_log_usage(this, ctx, _inode, delta); + } + ret = 0; out: - return ret; + return ret; } - int32_t -quota_check_size_limit (call_frame_t *frame, quota_inode_ctx_t *ctx, - quota_priv_t *priv, inode_t *_inode, xlator_t *this, - int32_t *op_errno, int just_validated, int64_t delta, - quota_local_t *local, gf_boolean_t *skip_check) +quota_check_limit(call_frame_t *frame, inode_t *inode, xlator_t *this) { - int32_t ret = -1; - uint32_t timeout = 0; - char need_validate = 0; - gf_boolean_t hard_limit_exceeded = 0; - int64_t space_available = 0; - int64_t wouldbe_size = 0; - - GF_ASSERT (frame); - GF_ASSERT (priv); - GF_ASSERT (_inode); - GF_ASSERT (this); - GF_ASSERT (local); - - if (ctx != NULL && (ctx->hard_lim > 0 || ctx->soft_lim > 0)) { - wouldbe_size = ctx->size + delta; - - LOCK (&ctx->lock); - { - timeout = priv->soft_timeout; - - if ((ctx->soft_lim >= 0) - && (wouldbe_size > ctx->soft_lim)) { - timeout = priv->hard_timeout; - } - - if (!just_validated - && quota_timeout (&ctx->tv, timeout)) { - need_validate = 1; - } else if (wouldbe_size >= ctx->hard_lim) { - hard_limit_exceeded = 1; - } - } - UNLOCK (&ctx->lock); - - if (need_validate && *skip_check != _gf_true) { - *skip_check = _gf_true; - ret = quota_validate (frame, _inode, this, - quota_validate_cbk); - if (ret < 0) { - *op_errno = -ret; - *skip_check = _gf_false; - } - goto out; - } + int32_t ret = -1, op_errno = EINVAL; + inode_t *_inode = NULL, *parent = NULL; + quota_inode_ctx_t *ctx = NULL; + quota_priv_t *priv = NULL; + quota_local_t *local = NULL; + quota_local_t *par_local = NULL; + char just_validated = 0; + int64_t delta = 0; + int8_t object_delta = 0; + uint64_t value = 0; + gf_boolean_t skip_check = _gf_false; + + GF_VALIDATE_OR_GOTO("quota", this, err); + GF_VALIDATE_OR_GOTO(this->name, frame, err); + GF_VALIDATE_OR_GOTO(this->name, inode, err); + + local = frame->local; + GF_VALIDATE_OR_GOTO(this->name, local, err); + + if (local->par_frame) { + par_local = local->par_frame->local; + GF_VALIDATE_OR_GOTO(this->name, par_local, err); + } else { + par_local = local; + } + + delta = par_local->delta; + object_delta = par_local->object_delta; + + GF_VALIDATE_OR_GOTO(this->name, par_local->stub, err); + /* Allow all the trusted clients + * Don't block the gluster internal processes like rebalance, gsyncd, + * self heal etc from the disk quotas. + * + * Method: Allow all the clients with PID negative. This is by the + * assumption that any kernel assigned pid doesn't have the negative + * number. + */ + if (0 > frame->root->pid) { + ret = 0; + quota_link_count_decrement(frame); + goto done; + } - if (hard_limit_exceeded) { - local->op_ret = -1; - local->op_errno = EDQUOT; + priv = this->private; - space_available = ctx->hard_lim - ctx->size; + inode_ctx_get(inode, this, &value); + ctx = (quota_inode_ctx_t *)(unsigned long)value; - if (space_available < 0) - space_available = 0; + _inode = inode_ref(inode); - if ((local->space_available < 0) - || (local->space_available - > space_available)){ - local->space_available - = space_available; + LOCK(&local->lock); + { + just_validated = local->just_validated; + local->just_validated = 0; + } + UNLOCK(&local->lock); - } - - if (space_available == 0) { - *op_errno = EDQUOT; - goto out; - } - } - - /* We log usage only if quota limit is configured on - that inode. */ - quota_log_usage (this, ctx, _inode, delta); + do { + /* In a rename operation, enforce should be stopped at common + ancestor */ + if (!gf_uuid_is_null(par_local->common_ancestor) && + !gf_uuid_compare(_inode->gfid, par_local->common_ancestor)) { + quota_link_count_decrement(frame); + break; } - ret = 0; -out: - return ret; -} - + if (object_delta <= 0) + goto skip_check_object_limit; -int32_t -quota_check_limit (call_frame_t *frame, inode_t *inode, xlator_t *this) -{ - int32_t ret = -1, op_errno = EINVAL; - inode_t *_inode = NULL, *parent = NULL; - quota_inode_ctx_t *ctx = NULL; - quota_priv_t *priv = NULL; - quota_local_t *local = NULL; - quota_local_t *par_local = NULL; - char just_validated = 0; - int64_t delta = 0; - int8_t object_delta = 0; - uint64_t value = 0; - gf_boolean_t skip_check = _gf_false; - - GF_VALIDATE_OR_GOTO ("quota", this, err); - GF_VALIDATE_OR_GOTO (this->name, frame, err); - GF_VALIDATE_OR_GOTO (this->name, inode, err); - - local = frame->local; - GF_VALIDATE_OR_GOTO (this->name, local, err); - - if (local->par_frame) { - par_local = local->par_frame->local; - GF_VALIDATE_OR_GOTO (this->name, par_local, err); - } else { - par_local = local; - } + ret = quota_check_object_limit(frame, ctx, priv, _inode, this, + &op_errno, just_validated, par_local, + &skip_check); + if (skip_check == _gf_true) + goto done; - delta = par_local->delta; - object_delta = par_local->object_delta; - - GF_VALIDATE_OR_GOTO (this->name, par_local->stub, err); - /* Allow all the trusted clients - * Don't block the gluster internal processes like rebalance, gsyncd, - * self heal etc from the disk quotas. - * - * Method: Allow all the clients with PID negative. This is by the - * assumption that any kernel assigned pid doesn't have the negative - * number. - */ - if (0 > frame->root->pid) { - ret = 0; - quota_link_count_decrement (frame); - goto done; + if (ret) { + if (op_errno != EDQUOT) + gf_msg(this->name, GF_LOG_ERROR, 0, Q_MSG_ENFORCEMENT_FAILED, + "Failed to " + "check quota object limit"); + goto err; } - priv = this->private; - - inode_ctx_get (inode, this, &value); - ctx = (quota_inode_ctx_t *)(unsigned long)value; - - _inode = inode_ref (inode); + skip_check_object_limit: + ret = quota_check_size_limit(frame, ctx, priv, _inode, this, &op_errno, + just_validated, delta, par_local, + &skip_check); + if (skip_check == _gf_true) + goto done; - LOCK (&local->lock); - { - just_validated = local->just_validated; - local->just_validated = 0; + if (ret) { + if (op_errno != EDQUOT) + gf_msg(this->name, GF_LOG_ERROR, 0, Q_MSG_ENFORCEMENT_FAILED, + "Failed to " + "check quota size limit"); + goto err; } - UNLOCK (&local->lock); - - do { - /* In a rename operation, enforce should be stopped at common - ancestor */ - if (!gf_uuid_is_null (par_local->common_ancestor) && - !gf_uuid_compare (_inode->gfid, par_local->common_ancestor) - ) { - quota_link_count_decrement (frame); - break; - } - if (object_delta <= 0) - goto skip_check_object_limit; - - ret = quota_check_object_limit (frame, ctx, priv, _inode, this, - &op_errno, just_validated, - par_local, &skip_check); - if (skip_check == _gf_true) - goto done; - - if (ret) { - if (op_errno != EDQUOT) - gf_msg (this->name, GF_LOG_ERROR, 0, - Q_MSG_ENFORCEMENT_FAILED, "Failed to " - "check quota object limit"); - goto err; - } - -skip_check_object_limit: - ret = quota_check_size_limit (frame, ctx, priv, _inode, this, - &op_errno, just_validated, delta, - par_local, &skip_check); - if (skip_check == _gf_true) - goto done; - - if (ret) { - if (op_errno != EDQUOT) - gf_msg (this->name, GF_LOG_ERROR, 0, - Q_MSG_ENFORCEMENT_FAILED, "Failed to " - "check quota size limit"); - goto err; - } + if (__is_root_gfid(_inode->gfid)) { + quota_link_count_decrement(frame); + break; + } - if (__is_root_gfid (_inode->gfid)) { - quota_link_count_decrement (frame); - break; - } + parent = inode_parent(_inode, 0, NULL); + if (parent == NULL) { + ret = quota_build_ancestry(_inode, quota_check_limit_continuation, + frame); + if (ret < 0) { + op_errno = -ret; + goto err; + } - parent = inode_parent (_inode, 0, NULL); - if (parent == NULL) { - ret = quota_build_ancestry (_inode, - quota_check_limit_continuation, - frame); - if (ret < 0) { - op_errno = -ret; - goto err; - } - - break; - } + break; + } - inode_unref (_inode); - _inode = parent; - just_validated = 0; + inode_unref(_inode); + _inode = parent; + just_validated = 0; - value = 0; - inode_ctx_get (_inode, this, &value); - ctx = (quota_inode_ctx_t *)(unsigned long)value; - } while (1); + value = 0; + inode_ctx_get(_inode, this, &value); + ctx = (quota_inode_ctx_t *)(unsigned long)value; + } while (1); done: - if (_inode != NULL) { - inode_unref (_inode); - _inode = NULL; - } - return 0; + if (_inode != NULL) { + inode_unref(_inode); + _inode = NULL; + } + return 0; err: - quota_handle_validate_error (frame, -1, op_errno); + quota_handle_validate_error(frame, -1, op_errno); - inode_unref (_inode); - return 0; + inode_unref(_inode); + return 0; } inode_t * -do_quota_check_limit (call_frame_t *frame, inode_t *inode, xlator_t *this, - quota_dentry_t *dentry, gf_boolean_t force) +do_quota_check_limit(call_frame_t *frame, inode_t *inode, xlator_t *this, + quota_dentry_t *dentry, gf_boolean_t force) { - int32_t ret = -1; - inode_t *parent = NULL; - call_frame_t *new_frame = NULL; - quota_local_t *new_local = NULL; - - parent = inode_parent (inode, dentry->par, dentry->name); - if (parent == NULL) { - if (force) - parent = inode_find (inode->table, dentry->par); - else - goto out; - } - if (parent == NULL) - goto out; + int32_t ret = -1; + inode_t *parent = NULL; + call_frame_t *new_frame = NULL; + quota_local_t *new_local = NULL; + + parent = inode_parent(inode, dentry->par, dentry->name); + if (parent == NULL) { + if (force) + parent = inode_find(inode->table, dentry->par); + else + goto out; + } + if (parent == NULL) + goto out; - new_frame = copy_frame (frame); - if (new_frame == NULL) - goto out; + new_frame = copy_frame(frame); + if (new_frame == NULL) + goto out; - new_local = quota_local_new (); - if (new_local == NULL) - goto out; + new_local = quota_local_new(); + if (new_local == NULL) + goto out; - new_frame->local = new_local; - new_local->par_frame = frame; + new_frame->local = new_local; + new_local->par_frame = frame; - quota_check_limit (new_frame, parent, this); + quota_check_limit(new_frame, parent, this); - ret = 0; + ret = 0; out: - if (ret < 0) { - if (parent) { - /* Caller should decrement link_count, in case parent is - * NULL - */ - quota_handle_validate_error (frame, -1, ENOMEM); - } + if (ret < 0) { + if (parent) { + /* Caller should decrement link_count, in case parent is + * NULL + */ + quota_handle_validate_error(frame, -1, ENOMEM); + } - if (new_frame) { - new_frame->local = NULL; - STACK_DESTROY (new_frame->root); - } + if (new_frame) { + new_frame->local = NULL; + STACK_DESTROY(new_frame->root); } + } - return parent; + return parent; } static int -quota_get_limits (xlator_t *this, dict_t *dict, int64_t *hard_lim, - int64_t *soft_lim, int64_t *object_hard_limit, - int64_t *object_soft_limit) +quota_get_limits(xlator_t *this, dict_t *dict, int64_t *hard_lim, + int64_t *soft_lim, int64_t *object_hard_limit, + int64_t *object_soft_limit) { - quota_limits_t *limit = NULL; - quota_limits_t *object_limit = NULL; - quota_priv_t *priv = NULL; - int64_t soft_lim_percent = 0; - int64_t *ptr = NULL; - int ret = 0; - - if ((this == NULL) || (dict == NULL) || (hard_lim == NULL) - || (soft_lim == NULL)) - goto out; + quota_limits_t *limit = NULL; + quota_limits_t *object_limit = NULL; + quota_priv_t *priv = NULL; + int64_t soft_lim_percent = 0; + int64_t *ptr = NULL; + int ret = 0; - priv = this->private; + if ((this == NULL) || (dict == NULL) || (hard_lim == NULL) || + (soft_lim == NULL)) + goto out; - ret = dict_get_bin (dict, QUOTA_LIMIT_KEY, (void **) &ptr); - limit = (quota_limits_t *)ptr; + priv = this->private; - if (limit) { - *hard_lim = ntoh64 (limit->hl); - soft_lim_percent = ntoh64 (limit->sl); - } + ret = dict_get_bin(dict, QUOTA_LIMIT_KEY, (void **)&ptr); + limit = (quota_limits_t *)ptr; - if (soft_lim_percent < 0) { - soft_lim_percent = priv->default_soft_lim; - } + if (limit) { + *hard_lim = ntoh64(limit->hl); + soft_lim_percent = ntoh64(limit->sl); + } - if ((*hard_lim > 0) && (soft_lim_percent > 0)) { - *soft_lim = (soft_lim_percent * (*hard_lim))/100; - } + if (soft_lim_percent < 0) { + soft_lim_percent = priv->default_soft_lim; + } - ret = dict_get_bin (dict, QUOTA_LIMIT_OBJECTS_KEY, (void **) &ptr); - if (ret) - return 0; - object_limit = (quota_limits_t *)ptr; + if ((*hard_lim > 0) && (soft_lim_percent > 0)) { + *soft_lim = (soft_lim_percent * (*hard_lim)) / 100; + } - if (object_limit) { - *object_hard_limit = ntoh64 (object_limit->hl); - soft_lim_percent = ntoh64 (object_limit->sl); - } + ret = dict_get_bin(dict, QUOTA_LIMIT_OBJECTS_KEY, (void **)&ptr); + if (ret) + return 0; + object_limit = (quota_limits_t *)ptr; - if (soft_lim_percent < 0) { - soft_lim_percent = priv->default_soft_lim; - } + if (object_limit) { + *object_hard_limit = ntoh64(object_limit->hl); + soft_lim_percent = ntoh64(object_limit->sl); + } - if ((*object_hard_limit > 0) && (soft_lim_percent > 0)) { - *object_soft_limit = (soft_lim_percent * - (*object_hard_limit))/100; - } + if (soft_lim_percent < 0) { + soft_lim_percent = priv->default_soft_lim; + } + + if ((*object_hard_limit > 0) && (soft_lim_percent > 0)) { + *object_soft_limit = (soft_lim_percent * (*object_hard_limit)) / 100; + } out: - return 0; + return 0; } int -quota_fill_inodectx (xlator_t *this, inode_t *inode, dict_t *dict, - loc_t *loc, struct iatt *buf, int32_t *op_errno) +quota_fill_inodectx(xlator_t *this, inode_t *inode, dict_t *dict, loc_t *loc, + struct iatt *buf, int32_t *op_errno) { - int32_t ret = -1; - char found = 0; - quota_inode_ctx_t *ctx = NULL; - quota_dentry_t *dentry = NULL; - uint64_t value = 0; - int64_t hard_lim = 0; - int64_t soft_lim = 0; - int64_t object_hard_limit = 0; - int64_t object_soft_limit = 0; - - quota_get_limits (this, dict, &hard_lim, &soft_lim, &object_hard_limit, - &object_soft_limit); - - inode_ctx_get (inode, this, &value); - ctx = (quota_inode_ctx_t *)(unsigned long)value; - - if ((((ctx == NULL) || (ctx->hard_lim == hard_lim)) - && (hard_lim < 0) && !QUOTA_REG_OR_LNK_FILE (buf->ia_type))) { - ret = 0; - goto out; - } - - ret = quota_inode_ctx_get (inode, this, &ctx, 1); - if ((ret == -1) || (ctx == NULL)) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_INODE_CTX_GET_FAILED, "cannot create quota " - "context in inode(gfid:%s)", uuid_utoa (inode->gfid)); - ret = -1; - *op_errno = ENOMEM; - goto out; - } - - LOCK (&ctx->lock); + int32_t ret = -1; + char found = 0; + quota_inode_ctx_t *ctx = NULL; + quota_dentry_t *dentry = NULL; + uint64_t value = 0; + int64_t hard_lim = 0; + int64_t soft_lim = 0; + int64_t object_hard_limit = 0; + int64_t object_soft_limit = 0; + + quota_get_limits(this, dict, &hard_lim, &soft_lim, &object_hard_limit, + &object_soft_limit); + + inode_ctx_get(inode, this, &value); + ctx = (quota_inode_ctx_t *)(unsigned long)value; + + if ((((ctx == NULL) || (ctx->hard_lim == hard_lim)) && (hard_lim < 0) && + !QUOTA_REG_OR_LNK_FILE(buf->ia_type))) { + ret = 0; + goto out; + } + + ret = quota_inode_ctx_get(inode, this, &ctx, 1); + if ((ret == -1) || (ctx == NULL)) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_INODE_CTX_GET_FAILED, + "cannot create quota " + "context in inode(gfid:%s)", + uuid_utoa(inode->gfid)); + ret = -1; + *op_errno = ENOMEM; + goto out; + } + + LOCK(&ctx->lock); + { + ctx->hard_lim = hard_lim; + ctx->soft_lim = soft_lim; + ctx->object_hard_lim = object_hard_limit; + ctx->object_soft_lim = object_soft_limit; + + ctx->buf = *buf; + + if (!QUOTA_REG_OR_LNK_FILE(buf->ia_type)) { + goto unlock; + } + + /* do nothing if it is a nameless lookup */ + if (loc->name == NULL || !loc->parent) + goto unlock; + + list_for_each_entry(dentry, &ctx->parents, next) { - ctx->hard_lim = hard_lim; - ctx->soft_lim = soft_lim; - ctx->object_hard_lim = object_hard_limit; - ctx->object_soft_lim = object_soft_limit; - - ctx->buf = *buf; - - if (!QUOTA_REG_OR_LNK_FILE (buf->ia_type)) { - goto unlock; - } - - /* do nothing if it is a nameless lookup */ - if (loc->name == NULL || !loc->parent) - goto unlock; - - list_for_each_entry (dentry, &ctx->parents, next) { - if ((strcmp (dentry->name, loc->name) == 0) && - (gf_uuid_compare (loc->parent->gfid, - dentry->par) == 0)) { - found = 1; - break; - } - } + if ((strcmp(dentry->name, loc->name) == 0) && + (gf_uuid_compare(loc->parent->gfid, dentry->par) == 0)) { + found = 1; + break; + } + } - if (!found) { - dentry = __quota_dentry_new (ctx, - (char *)loc->name, - loc->parent->gfid); - if (dentry == NULL) { - /* - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, - "cannot create a new dentry (par:%" + if (!found) { + dentry = __quota_dentry_new(ctx, (char *)loc->name, + loc->parent->gfid); + if (dentry == NULL) { + /* + gf_msg (this->name, GF_LOG_WARNING, ENOMEM, + Q_MSG_ENOMEM, + "cannot create a new dentry (par:%" - PRId64", name:%s) for inode(ino:%" - PRId64", gfid:%s)", - uuid_utoa (local->loc.inode->gfid)); - */ - ret = -1; - *op_errno = ENOMEM; - goto unlock; - } - } + */ + ret = -1; + *op_errno = ENOMEM; + goto unlock; + } } + } unlock: - UNLOCK (&ctx->lock); + UNLOCK(&ctx->lock); out: - return ret; + return ret; } /* * return _gf_true if enforcement is needed and _gf_false otherwise */ gf_boolean_t -should_quota_enforce (xlator_t *this, dict_t *dict, glusterfs_fop_t fop) +should_quota_enforce(xlator_t *this, dict_t *dict, glusterfs_fop_t fop) { - int ret = 0; + int ret = 0; - ret = dict_check_flag(dict, GF_INTERNAL_CTX_KEY, GF_DHT_HEAL_DIR); + ret = dict_check_flag(dict, GF_INTERNAL_CTX_KEY, GF_DHT_HEAL_DIR); - if (fop == GF_FOP_MKDIR && ret == DICT_FLAG_SET) { - return _gf_false; - } else if (ret == -ENOENT) { - gf_msg (this->name, GF_LOG_DEBUG, EINVAL, - Q_MSG_INTERNAL_FOP_KEY_MISSING, - "No internal fop context present"); - goto out; - } + if (fop == GF_FOP_MKDIR && ret == DICT_FLAG_SET) { + return _gf_false; + } else if (ret == -ENOENT) { + gf_msg(this->name, GF_LOG_DEBUG, EINVAL, Q_MSG_INTERNAL_FOP_KEY_MISSING, + "No internal fop context present"); + goto out; + } out: - return _gf_true; + return _gf_true; } int32_t -quota_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *dict, struct iatt *postparent) +quota_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *dict, struct iatt *postparent) { - quota_local_t *local = NULL; - inode_t *this_inode = NULL; + quota_local_t *local = NULL; + inode_t *this_inode = NULL; - local = frame->local; - frame->local = NULL; + local = frame->local; + frame->local = NULL; - if (op_ret >= 0 && inode) { - this_inode = inode_ref (inode); + if (op_ret >= 0 && inode) { + this_inode = inode_ref(inode); - op_ret = quota_fill_inodectx (this, inode, dict, &local->loc, - buf, &op_errno); - if (op_ret < 0) - op_errno = ENOMEM; - } + op_ret = quota_fill_inodectx(this, inode, dict, &local->loc, buf, + &op_errno); + if (op_ret < 0) + op_errno = ENOMEM; + } - QUOTA_STACK_UNWIND (lookup, frame, op_ret, op_errno, inode, buf, - dict, postparent); + QUOTA_STACK_UNWIND(lookup, frame, op_ret, op_errno, inode, buf, dict, + postparent); - if (op_ret < 0 || this_inode == NULL || gf_uuid_is_null(this_inode->gfid)) - goto out; + if (op_ret < 0 || this_inode == NULL || gf_uuid_is_null(this_inode->gfid)) + goto out; - check_ancestory_2 (this, local, this_inode); + check_ancestory_2(this, local, this_inode); out: - if (this_inode) - inode_unref (this_inode); + if (this_inode) + inode_unref(this_inode); - quota_local_cleanup (local); + quota_local_cleanup(local); - return 0; + return 0; } int32_t -quota_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *xattr_req) +quota_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req) { - quota_priv_t *priv = NULL; - int32_t ret = -1; - quota_local_t *local = NULL; + quota_priv_t *priv = NULL; + int32_t ret = -1; + quota_local_t *local = NULL; - priv = this->private; + priv = this->private; - WIND_IF_QUOTAOFF (priv->is_quota_on, off); + WIND_IF_QUOTAOFF(priv->is_quota_on, off); - xattr_req = xattr_req ? dict_ref(xattr_req) : dict_new(); - if (!xattr_req) - goto err; + xattr_req = xattr_req ? dict_ref(xattr_req) : dict_new(); + if (!xattr_req) + goto err; - local = quota_local_new (); - if (local == NULL) { - goto err; - } + local = quota_local_new(); + if (local == NULL) { + goto err; + } - frame->local = local; - loc_copy (&local->loc, loc); + frame->local = local; + loc_copy(&local->loc, loc); - ret = dict_set_int8 (xattr_req, QUOTA_LIMIT_KEY, 1); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "dict set of key for " - "hard-limit failed"); - goto err; - } + ret = dict_set_int8(xattr_req, QUOTA_LIMIT_KEY, 1); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "dict set of key for " + "hard-limit failed"); + goto err; + } - ret = dict_set_int8 (xattr_req, QUOTA_LIMIT_OBJECTS_KEY, 1); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, - "dict set of key for quota object limit failed"); - goto err; - } + ret = dict_set_int8(xattr_req, QUOTA_LIMIT_OBJECTS_KEY, 1); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "dict set of key for quota object limit failed"); + goto err; + } - STACK_WIND (frame, quota_lookup_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->lookup, loc, xattr_req); + STACK_WIND(frame, quota_lookup_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->lookup, loc, xattr_req); - ret = 0; + ret = 0; err: - if (xattr_req) - dict_unref (xattr_req); + if (xattr_req) + dict_unref(xattr_req); - if (ret < 0) { - QUOTA_STACK_UNWIND (lookup, frame, -1, ENOMEM, - NULL, NULL, NULL, NULL); - } + if (ret < 0) { + QUOTA_STACK_UNWIND(lookup, frame, -1, ENOMEM, NULL, NULL, NULL, NULL); + } - return 0; + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->lookup, loc, xattr_req); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->lookup, + loc, xattr_req); + return 0; } int32_t -quota_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) +quota_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - int32_t ret = 0; - uint64_t ctx_int = 0; - quota_inode_ctx_t *ctx = NULL; - quota_local_t *local = NULL; - - local = frame->local; - - if ((op_ret < 0) || (local == NULL) || (postbuf == NULL)) { - goto out; - } - - ret = inode_ctx_get (local->loc.inode, this, &ctx_int); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, 0, - Q_MSG_INODE_CTX_GET_FAILED, "%s: failed to get the " - "context", local->loc.path); - goto out; - } - - ctx = (quota_inode_ctx_t *)(unsigned long) ctx_int; - - if (ctx == NULL) { - gf_msg (this->name, GF_LOG_WARNING, 0, - Q_MSG_INODE_CTX_GET_FAILED, - "quota context not set in %s (gfid:%s)", - local->loc.path, uuid_utoa (local->loc.inode->gfid)); - goto out; - } - - LOCK (&ctx->lock); - { - ctx->buf = *postbuf; - } - UNLOCK (&ctx->lock); + int32_t ret = 0; + uint64_t ctx_int = 0; + quota_inode_ctx_t *ctx = NULL; + quota_local_t *local = NULL; + + local = frame->local; + + if ((op_ret < 0) || (local == NULL) || (postbuf == NULL)) { + goto out; + } + + ret = inode_ctx_get(local->loc.inode, this, &ctx_int); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, 0, Q_MSG_INODE_CTX_GET_FAILED, + "%s: failed to get the " + "context", + local->loc.path); + goto out; + } + + ctx = (quota_inode_ctx_t *)(unsigned long)ctx_int; + + if (ctx == NULL) { + gf_msg(this->name, GF_LOG_WARNING, 0, Q_MSG_INODE_CTX_GET_FAILED, + "quota context not set in %s (gfid:%s)", local->loc.path, + uuid_utoa(local->loc.inode->gfid)); + goto out; + } + + LOCK(&ctx->lock); + { + ctx->buf = *postbuf; + } + UNLOCK(&ctx->lock); out: - QUOTA_STACK_UNWIND (writev, frame, op_ret, op_errno, prebuf, postbuf, - xdata); + QUOTA_STACK_UNWIND(writev, frame, op_ret, op_errno, prebuf, postbuf, xdata); - return 0; + return 0; } static int gf_quota_enforcer_log; int32_t -quota_writev_helper (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iovec *vector, int32_t count, off_t off, - uint32_t flags, struct iobref *iobref, dict_t *xdata) +quota_writev_helper(call_frame_t *frame, xlator_t *this, fd_t *fd, + struct iovec *vector, int32_t count, off_t off, + uint32_t flags, struct iobref *iobref, dict_t *xdata) { - quota_local_t *local = NULL; - int32_t op_errno = EINVAL; - struct iovec *new_vector = NULL; - int32_t new_count = 0; - - local = frame->local; - - GF_VALIDATE_OR_GOTO ("quota", local, unwind); - - if (local->op_ret == -1) { - op_errno = local->op_errno; - - if ((op_errno == EDQUOT) && (local->space_available > 0)) { - new_count = iov_subset (vector, count, 0, - local->space_available, NULL); - - new_vector = GF_CALLOC (new_count, - sizeof (struct iovec), - gf_common_mt_iovec); - if (new_vector == NULL) { - local->op_ret = -1; - local->op_errno = ENOMEM; - goto unwind; - } - - new_count = iov_subset (vector, count, 0, - local->space_available, - new_vector); - - vector = new_vector; - count = new_count; - } else if (op_errno == ENOENT || op_errno == ESTALE) { - /* We may get ENOENT/ESTALE in case of below scenario - * fd = open file.txt - * unlink file.txt - * write on fd - * Here build_ancestry can fail as the file is removed. - * For now ignore ENOENT/ESTALE with writes on active fd - * We need to re-visit this code once we understand - * how other file-system behave in this scenario - */ - gf_msg_debug (this->name, 0, "quota enforcer failed " - "with ENOENT/ESTALE on %s, cannot check " - "quota limits and allowing writes", - uuid_utoa (fd->inode->gfid)); - } else if ((op_errno == EINVAL) && - !inode_parent (local->loc.inode, 0, NULL)) { - /* We may get INVAL with parent == NULL, - * in case of below scenario - * 1. enable quota - * 2. glusterfsd stop/start - * 3. nameless lookup - * 4. write on fd - * Here build_ancestry can fail as the file's pgfid - * is't exist. - * For now ignore EINVAL with writes on active fd - * untils the pgfid is created at name lookup - */ - GF_LOG_OCCASIONALLY (gf_quota_enforcer_log, this->name, - GF_LOG_CRITICAL, "Quota cannot be enforced as " + quota_local_t *local = NULL; + int32_t op_errno = EINVAL; + struct iovec *new_vector = NULL; + int32_t new_count = 0; + + local = frame->local; + + GF_VALIDATE_OR_GOTO("quota", local, unwind); + + if (local->op_ret == -1) { + op_errno = local->op_errno; + + if ((op_errno == EDQUOT) && (local->space_available > 0)) { + new_count = iov_subset(vector, count, 0, local->space_available, + NULL); + + new_vector = GF_CALLOC(new_count, sizeof(struct iovec), + gf_common_mt_iovec); + if (new_vector == NULL) { + local->op_ret = -1; + local->op_errno = ENOMEM; + goto unwind; + } + + new_count = iov_subset(vector, count, 0, local->space_available, + new_vector); + + vector = new_vector; + count = new_count; + } else if (op_errno == ENOENT || op_errno == ESTALE) { + /* We may get ENOENT/ESTALE in case of below scenario + * fd = open file.txt + * unlink file.txt + * write on fd + * Here build_ancestry can fail as the file is removed. + * For now ignore ENOENT/ESTALE with writes on active fd + * We need to re-visit this code once we understand + * how other file-system behave in this scenario + */ + gf_msg_debug(this->name, 0, + "quota enforcer failed " + "with ENOENT/ESTALE on %s, cannot check " + "quota limits and allowing writes", + uuid_utoa(fd->inode->gfid)); + } else if ((op_errno == EINVAL) && + !inode_parent(local->loc.inode, 0, NULL)) { + /* We may get INVAL with parent == NULL, + * in case of below scenario + * 1. enable quota + * 2. glusterfsd stop/start + * 3. nameless lookup + * 4. write on fd + * Here build_ancestry can fail as the file's pgfid + * is't exist. + * For now ignore EINVAL with writes on active fd + * untils the pgfid is created at name lookup + */ + GF_LOG_OCCASIONALLY(gf_quota_enforcer_log, this->name, + GF_LOG_CRITICAL, + "Quota cannot be enforced as " "parent is not available and writes are being " "allowed without checking whether they are " "within quota limits. This can happen if Quota " "crawl is not complete. If crawl has been " "completed, please file a bug."); - } else { - goto unwind; - } + } else { + goto unwind; } + } - STACK_WIND (frame, quota_writev_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev, fd, - vector, count, off, flags, iobref, xdata); + STACK_WIND(frame, quota_writev_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->writev, fd, vector, count, off, flags, + iobref, xdata); - if (new_vector != NULL) - GF_FREE (new_vector); + if (new_vector != NULL) + GF_FREE(new_vector); - return 0; + return 0; unwind: - QUOTA_STACK_UNWIND (writev, frame, -1, op_errno, NULL, NULL, NULL); - return 0; + QUOTA_STACK_UNWIND(writev, frame, -1, op_errno, NULL, NULL, NULL); + return 0; } - int32_t -quota_writev (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iovec *vector, int32_t count, off_t off, - uint32_t flags, struct iobref *iobref, dict_t *xdata) +quota_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, + struct iovec *vector, int32_t count, off_t off, uint32_t flags, + struct iobref *iobref, dict_t *xdata) { - quota_priv_t *priv = NULL; - int32_t op_errno = EINVAL; - int32_t parents = 0; - int32_t fail_count = 0; - uint64_t size = 0; - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; - quota_dentry_t *dentry = NULL, *tmp = NULL; - call_stub_t *stub = NULL; - struct list_head head = {0, }; - inode_t *par_inode = NULL; - - priv = this->private; - - WIND_IF_QUOTAOFF (priv->is_quota_on, off); - - INIT_LIST_HEAD (&head); - - GF_ASSERT (frame); - GF_VALIDATE_OR_GOTO ("quota", this, unwind); - GF_VALIDATE_OR_GOTO (this->name, fd, unwind); - - local = quota_local_new (); - if (local == NULL) { - goto unwind; - } - - frame->local = local; - local->loc.inode = inode_ref (fd->inode); - - (void) quota_inode_ctx_get (fd->inode, this, &ctx, 0); - if (ctx == NULL) { - gf_msg_debug (this->name, 0, "quota context is NULL on inode" - " (%s). If quota is not enabled recently and " - "crawler has finished crawling, its an error", - uuid_utoa (fd->inode->gfid)); - } - - stub = fop_writev_stub (frame, quota_writev_helper, fd, vector, count, - off, flags, iobref, xdata); - if (stub == NULL) { - op_errno = ENOMEM; - goto unwind; - } - - priv = this->private; - GF_VALIDATE_OR_GOTO (this->name, priv, unwind); - - size = iov_length (vector, count); - - parents = quota_add_parents_from_ctx (ctx, &head); + quota_priv_t *priv = NULL; + int32_t op_errno = EINVAL; + int32_t parents = 0; + int32_t fail_count = 0; + uint64_t size = 0; + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; + quota_dentry_t *dentry = NULL, *tmp = NULL; + call_stub_t *stub = NULL; + struct list_head head = { + 0, + }; + inode_t *par_inode = NULL; + + priv = this->private; + + WIND_IF_QUOTAOFF(priv->is_quota_on, off); + + INIT_LIST_HEAD(&head); + + GF_ASSERT(frame); + GF_VALIDATE_OR_GOTO("quota", this, unwind); + GF_VALIDATE_OR_GOTO(this->name, fd, unwind); + + local = quota_local_new(); + if (local == NULL) { + goto unwind; + } + + frame->local = local; + local->loc.inode = inode_ref(fd->inode); + + (void)quota_inode_ctx_get(fd->inode, this, &ctx, 0); + if (ctx == NULL) { + gf_msg_debug(this->name, 0, + "quota context is NULL on inode" + " (%s). If quota is not enabled recently and " + "crawler has finished crawling, its an error", + uuid_utoa(fd->inode->gfid)); + } + + stub = fop_writev_stub(frame, quota_writev_helper, fd, vector, count, off, + flags, iobref, xdata); + if (stub == NULL) { + op_errno = ENOMEM; + goto unwind; + } + + priv = this->private; + GF_VALIDATE_OR_GOTO(this->name, priv, unwind); + + size = iov_length(vector, count); + + parents = quota_add_parents_from_ctx(ctx, &head); + + LOCK(&local->lock); + { + local->delta = size; + local->object_delta = 0; + local->link_count = (parents != 0) ? parents : 1; + local->stub = stub; + } + UNLOCK(&local->lock); - LOCK (&local->lock); + if (parents == 0) { + /* nameless lookup on this inode, allow quota to reconstruct + * ancestry as part of check_limit. + */ + quota_check_limit(frame, fd->inode, this); + } else { + list_for_each_entry_safe(dentry, tmp, &head, next) { - local->delta = size; - local->object_delta = 0; - local->link_count = (parents != 0) ? parents : 1; - local->stub = stub; + par_inode = do_quota_check_limit(frame, fd->inode, this, dentry, + _gf_false); + if (par_inode == NULL) { + /* remove stale entry from inode ctx */ + quota_dentry_del(ctx, dentry->name, dentry->par); + parents--; + fail_count++; + } else { + inode_unref(par_inode); + } + __quota_dentry_free(dentry); } - UNLOCK (&local->lock); if (parents == 0) { - /* nameless lookup on this inode, allow quota to reconstruct - * ancestry as part of check_limit. - */ - quota_check_limit (frame, fd->inode, this); - } else { - list_for_each_entry_safe (dentry, tmp, &head, next) { - par_inode = do_quota_check_limit (frame, fd->inode, - this, dentry, - _gf_false); - if (par_inode == NULL) { - /* remove stale entry from inode ctx */ - quota_dentry_del (ctx, dentry->name, - dentry->par); - parents--; - fail_count++; - } else { - inode_unref (par_inode); - } - __quota_dentry_free (dentry); - } - - if (parents == 0) { - LOCK (&local->lock); - { - local->link_count++; - } - UNLOCK (&local->lock); - quota_check_limit (frame, fd->inode, this); - } + LOCK(&local->lock); + { + local->link_count++; + } + UNLOCK(&local->lock); + quota_check_limit(frame, fd->inode, this); + } - while (fail_count != 0) { - quota_link_count_decrement (frame); - fail_count--; - } + while (fail_count != 0) { + quota_link_count_decrement(frame); + fail_count--; } + } - return 0; + return 0; unwind: - QUOTA_STACK_UNWIND (writev, frame, -1, op_errno, NULL, NULL, NULL); - return 0; + QUOTA_STACK_UNWIND(writev, frame, -1, op_errno, NULL, NULL, NULL); + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->writev, fd, - vector, count, off, flags, iobref, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev, + fd, vector, count, off, flags, iobref, xdata); + return 0; } - int32_t -quota_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +quota_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - QUOTA_STACK_UNWIND (mkdir, frame, op_ret, op_errno, inode, - buf, preparent, postparent, xdata); - return 0; + QUOTA_STACK_UNWIND(mkdir, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + return 0; } - int32_t -quota_mkdir_helper (call_frame_t *frame, xlator_t *this, loc_t *loc, - mode_t mode, mode_t umask, dict_t *xdata) +quota_mkdir_helper(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + mode_t umask, dict_t *xdata) { - quota_local_t *local = NULL; - int32_t op_errno = EINVAL; + quota_local_t *local = NULL; + int32_t op_errno = EINVAL; - local = frame->local; + local = frame->local; - GF_VALIDATE_OR_GOTO ("quota", local, unwind); + GF_VALIDATE_OR_GOTO("quota", local, unwind); - op_errno = local->op_errno; + op_errno = local->op_errno; - if (local->op_ret == -1) { - goto unwind; - } + if (local->op_ret == -1) { + goto unwind; + } - STACK_WIND (frame, quota_mkdir_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->mkdir, loc, - mode, umask, xdata); + STACK_WIND(frame, quota_mkdir_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->mkdir, loc, mode, umask, xdata); - return 0; + return 0; unwind: - QUOTA_STACK_UNWIND (mkdir, frame, -1, op_errno, NULL, NULL, - NULL, NULL, NULL); - return 0; + QUOTA_STACK_UNWIND(mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL, + NULL); + return 0; } int32_t -quota_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, - mode_t umask, dict_t *xdata) +quota_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + mode_t umask, dict_t *xdata) { - quota_priv_t *priv = NULL; - int32_t ret = 0, op_errno = 0; - quota_local_t *local = NULL; - call_stub_t *stub = NULL; - - priv = this->private; - WIND_IF_QUOTAOFF (priv->is_quota_on, off); - - if (!should_quota_enforce(this, xdata, GF_FOP_MKDIR)) { - gf_msg (this->name, GF_LOG_DEBUG, 0, - Q_MSG_ENFORCEMENT_SKIPPED, - "Enforcement has been skipped(internal fop)."); - goto off; - } - - local = quota_local_new (); - if (local == NULL) { - op_errno = ENOMEM; - goto err; - } - - frame->local = local; - - ret = loc_copy (&local->loc, loc); - if (ret) { - op_errno = ENOMEM; - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "loc_copy failed"); - goto err; - } - - stub = fop_mkdir_stub (frame, quota_mkdir_helper, loc, mode, umask, - xdata); - if (stub == NULL) { - op_errno = ENOMEM; - goto err; - } - - LOCK (&local->lock); - { - local->stub = stub; - local->delta = 0; - local->object_delta = 1; - local->link_count = 1; - } - UNLOCK (&local->lock); + quota_priv_t *priv = NULL; + int32_t ret = 0, op_errno = 0; + quota_local_t *local = NULL; + call_stub_t *stub = NULL; + + priv = this->private; + WIND_IF_QUOTAOFF(priv->is_quota_on, off); + + if (!should_quota_enforce(this, xdata, GF_FOP_MKDIR)) { + gf_msg(this->name, GF_LOG_DEBUG, 0, Q_MSG_ENFORCEMENT_SKIPPED, + "Enforcement has been skipped(internal fop)."); + goto off; + } + + local = quota_local_new(); + if (local == NULL) { + op_errno = ENOMEM; + goto err; + } + + frame->local = local; + + ret = loc_copy(&local->loc, loc); + if (ret) { + op_errno = ENOMEM; + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "loc_copy failed"); + goto err; + } + + stub = fop_mkdir_stub(frame, quota_mkdir_helper, loc, mode, umask, xdata); + if (stub == NULL) { + op_errno = ENOMEM; + goto err; + } + + LOCK(&local->lock); + { + local->stub = stub; + local->delta = 0; + local->object_delta = 1; + local->link_count = 1; + } + UNLOCK(&local->lock); - quota_check_limit (frame, loc->parent, this); - return 0; + quota_check_limit(frame, loc->parent, this); + return 0; err: - QUOTA_STACK_UNWIND (mkdir, frame, -1, op_errno, NULL, NULL, NULL, - NULL, NULL); + QUOTA_STACK_UNWIND(mkdir, frame, -1, op_errno, NULL, NULL, NULL, NULL, + NULL); - return 0; + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->mkdir, - loc, mode, umask, xdata); + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->mkdir, + loc, mode, umask, xdata); - return 0; + return 0; } - int32_t -quota_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +quota_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - int32_t ret = -1; - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; - quota_dentry_t *dentry = NULL; - - local = frame->local; - if (op_ret < 0) { - goto unwind; - } - - ret = quota_inode_ctx_get (inode, this, &ctx, 1); - if ((ret == -1) || (ctx == NULL)) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_INODE_CTX_GET_FAILED, "cannot create quota " - "context in inode(gfid:%s)", uuid_utoa (inode->gfid)); - op_ret = -1; - op_errno = ENOMEM; - goto unwind; - } - - LOCK (&ctx->lock); - { - ctx->buf = *buf; - - dentry = __quota_dentry_new (ctx, (char *)local->loc.name, - local->loc.parent->gfid); - if (dentry == NULL) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "cannot create a new dentry " - "(name:%s) for inode(gfid:%s)", local->loc.name, - uuid_utoa (local->loc.inode->gfid)); - op_ret = -1; - op_errno = ENOMEM; - goto unlock; - } - } + int32_t ret = -1; + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; + quota_dentry_t *dentry = NULL; + + local = frame->local; + if (op_ret < 0) { + goto unwind; + } + + ret = quota_inode_ctx_get(inode, this, &ctx, 1); + if ((ret == -1) || (ctx == NULL)) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_INODE_CTX_GET_FAILED, + "cannot create quota " + "context in inode(gfid:%s)", + uuid_utoa(inode->gfid)); + op_ret = -1; + op_errno = ENOMEM; + goto unwind; + } + + LOCK(&ctx->lock); + { + ctx->buf = *buf; + + dentry = __quota_dentry_new(ctx, (char *)local->loc.name, + local->loc.parent->gfid); + if (dentry == NULL) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "cannot create a new dentry " + "(name:%s) for inode(gfid:%s)", + local->loc.name, uuid_utoa(local->loc.inode->gfid)); + op_ret = -1; + op_errno = ENOMEM; + goto unlock; + } + } unlock: - UNLOCK (&ctx->lock); + UNLOCK(&ctx->lock); unwind: - QUOTA_STACK_UNWIND (create, frame, op_ret, op_errno, fd, inode, buf, - preparent, postparent, xdata); - return 0; + QUOTA_STACK_UNWIND(create, frame, op_ret, op_errno, fd, inode, buf, + preparent, postparent, xdata); + return 0; } - int32_t -quota_create_helper (call_frame_t *frame, xlator_t *this, loc_t *loc, - int32_t flags, mode_t mode, mode_t umask, fd_t *fd, - dict_t *xdata) +quota_create_helper(call_frame_t *frame, xlator_t *this, loc_t *loc, + int32_t flags, mode_t mode, mode_t umask, fd_t *fd, + dict_t *xdata) { - quota_local_t *local = NULL; - int32_t op_errno = EINVAL; - - local = frame->local; + quota_local_t *local = NULL; + int32_t op_errno = EINVAL; - GF_VALIDATE_OR_GOTO ("quota", local, unwind); + local = frame->local; - if (local->op_ret == -1) { - op_errno = local->op_errno; - goto unwind; - } + GF_VALIDATE_OR_GOTO("quota", local, unwind); + if (local->op_ret == -1) { + op_errno = local->op_errno; + goto unwind; + } - STACK_WIND (frame, quota_create_cbk, - FIRST_CHILD (this), FIRST_CHILD (this)->fops->create, loc, - flags, mode, umask, fd, xdata); - return 0; + STACK_WIND(frame, quota_create_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->create, loc, flags, mode, umask, fd, + xdata); + return 0; unwind: - QUOTA_STACK_UNWIND (create, frame, -1, op_errno, NULL, NULL, - NULL, NULL, NULL, NULL); - return 0; + QUOTA_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL, + NULL, NULL); + return 0; } +int32_t +quota_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, + mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) +{ + quota_priv_t *priv = NULL; + int32_t ret = -1; + quota_local_t *local = NULL; + int32_t op_errno = 0; + call_stub_t *stub = NULL; + + priv = this->private; + + WIND_IF_QUOTAOFF(priv->is_quota_on, off); + QUOTA_WIND_FOR_INTERNAL_FOP(xdata, off); + + local = quota_local_new(); + if (local == NULL) { + op_errno = ENOMEM; + goto err; + } + + frame->local = local; + + ret = loc_copy(&local->loc, loc); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "loc_copy failed"); + op_errno = ENOMEM; + goto err; + } + + stub = fop_create_stub(frame, quota_create_helper, loc, flags, mode, umask, + fd, xdata); + if (stub == NULL) { + goto err; + } + + LOCK(&local->lock); + { + local->link_count = 1; + local->stub = stub; + local->delta = 0; + local->object_delta = 1; + } + UNLOCK(&local->lock); + + quota_check_limit(frame, loc->parent, this); + return 0; +err: + QUOTA_STACK_UNWIND(create, frame, -1, op_errno, NULL, NULL, NULL, NULL, + NULL, NULL); + + return 0; + +off: + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->create, + loc, flags, mode, umask, fd, xdata); + return 0; +} int32_t -quota_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, - mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) +quota_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - quota_priv_t *priv = NULL; - int32_t ret = -1; - quota_local_t *local = NULL; - int32_t op_errno = 0; - call_stub_t *stub = NULL; + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; + uint64_t value = 0; - priv = this->private; + if (op_ret < 0) { + goto out; + } - WIND_IF_QUOTAOFF (priv->is_quota_on, off); - QUOTA_WIND_FOR_INTERNAL_FOP (xdata, off); + local = (quota_local_t *)frame->local; - local = quota_local_new (); - if (local == NULL) { - op_errno = ENOMEM; - goto err; - } + inode_ctx_get(local->loc.inode, this, &value); + ctx = (quota_inode_ctx_t *)(unsigned long)value; - frame->local = local; + if (ctx == NULL) { + gf_msg(this->name, GF_LOG_INFO, EINVAL, Q_MSG_INODE_CTX_GET_FAILED, + "quota context not set inode (gfid:%s)", + uuid_utoa(local->loc.gfid)); + goto out; + } - ret = loc_copy (&local->loc, loc); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "loc_copy failed"); - op_errno = ENOMEM; - goto err; - } - - stub = fop_create_stub (frame, quota_create_helper, loc, flags, mode, - umask, fd, xdata); - if (stub == NULL) { - goto err; - } - - LOCK (&local->lock); - { - local->link_count = 1; - local->stub = stub; - local->delta = 0; - local->object_delta = 1; - } - UNLOCK (&local->lock); - - quota_check_limit (frame, loc->parent, this); - return 0; -err: - QUOTA_STACK_UNWIND (create, frame, -1, op_errno, NULL, NULL, NULL, - NULL, NULL, NULL); - - return 0; - -off: - STACK_WIND_TAIL (frame, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->create, loc, - flags, mode, umask, fd, xdata); - return 0; -} - - -int32_t -quota_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) -{ - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; - uint64_t value = 0; - - if (op_ret < 0) { - goto out; - } - - local = (quota_local_t *) frame->local; - - inode_ctx_get (local->loc.inode, this, &value); - ctx = (quota_inode_ctx_t *)(unsigned long)value; - - if (ctx == NULL) { - gf_msg (this->name, GF_LOG_INFO, EINVAL, - Q_MSG_INODE_CTX_GET_FAILED, - "quota context not set inode (gfid:%s)", - uuid_utoa (local->loc.gfid)); - goto out; - } - - quota_dentry_del (ctx, local->loc.name, local->loc.parent->gfid); + quota_dentry_del(ctx, local->loc.name, local->loc.parent->gfid); out: - QUOTA_STACK_UNWIND (unlink, frame, op_ret, op_errno, preparent, - postparent, xdata); - return 0; + QUOTA_STACK_UNWIND(unlink, frame, op_ret, op_errno, preparent, postparent, + xdata); + return 0; } - int32_t -quota_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag, - dict_t *xdata) +quota_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag, + dict_t *xdata) { - quota_priv_t *priv = NULL; - int32_t ret = -1; - quota_local_t *local = NULL; + quota_priv_t *priv = NULL; + int32_t ret = -1; + quota_local_t *local = NULL; - priv = this->private; + priv = this->private; - WIND_IF_QUOTAOFF (priv->is_quota_on, off); + WIND_IF_QUOTAOFF(priv->is_quota_on, off); - local = quota_local_new (); - if (local == NULL) { - goto err; - } + local = quota_local_new(); + if (local == NULL) { + goto err; + } - frame->local = local; + frame->local = local; - ret = loc_copy (&local->loc, loc); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "loc_copy failed"); - goto err; - } + ret = loc_copy(&local->loc, loc); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "loc_copy failed"); + goto err; + } - STACK_WIND (frame, quota_unlink_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata); + STACK_WIND(frame, quota_unlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata); - ret = 0; + ret = 0; err: - if (ret == -1) { - QUOTA_STACK_UNWIND (unlink, frame, -1, 0, NULL, NULL, NULL); - } + if (ret == -1) { + QUOTA_STACK_UNWIND(unlink, frame, -1, 0, NULL, NULL, NULL); + } - return 0; + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->unlink, + loc, xflag, xdata); + return 0; } - int32_t -quota_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +quota_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - int32_t ret = -1; - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; - quota_dentry_t *dentry = NULL; - char found = 0; - - if (op_ret < 0) { - goto out; - } - - local = (quota_local_t *) frame->local; - - ret = quota_inode_ctx_get (inode, this, &ctx, 0); - if ((ret == -1) || (ctx == NULL)) { - gf_msg_debug (this->name, 0, "quota context is NULL on inode" - " (%s). If quota is not enabled recently and " - "crawler has finished crawling, its an error", - uuid_utoa (inode->gfid)); - goto out; - } - - LOCK (&ctx->lock); + int32_t ret = -1; + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; + quota_dentry_t *dentry = NULL; + char found = 0; + + if (op_ret < 0) { + goto out; + } + + local = (quota_local_t *)frame->local; + + ret = quota_inode_ctx_get(inode, this, &ctx, 0); + if ((ret == -1) || (ctx == NULL)) { + gf_msg_debug(this->name, 0, + "quota context is NULL on inode" + " (%s). If quota is not enabled recently and " + "crawler has finished crawling, its an error", + uuid_utoa(inode->gfid)); + goto out; + } + + LOCK(&ctx->lock); + { + list_for_each_entry(dentry, &ctx->parents, next) { - list_for_each_entry (dentry, &ctx->parents, next) { - if ((strcmp (dentry->name, local->loc.name) == 0) && - (gf_uuid_compare (local->loc.parent->gfid, - dentry->par) == 0)) { - found = 1; - - gf_msg_debug (this->name, 0, "new entry being" - " linked (name:%s) for inode " - "(gfid:%s) is already present " - "in inode-dentry-list", - dentry->name, - uuid_utoa (local->loc.inode->gfid)); - break; - } - } - - if (!found) { - dentry = __quota_dentry_new (ctx, - (char *)local->loc.name, - local->loc.parent->gfid); - if (dentry == NULL) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, - "cannot create a new dentry (name:%s)" - "for inode(gfid:%s)", local->loc.name, - uuid_utoa (local->loc.inode->gfid)); - op_ret = -1; - op_errno = ENOMEM; - goto unlock; - } - } - - ctx->buf = *buf; + if ((strcmp(dentry->name, local->loc.name) == 0) && + (gf_uuid_compare(local->loc.parent->gfid, dentry->par) == 0)) { + found = 1; + + gf_msg_debug(this->name, 0, + "new entry being" + " linked (name:%s) for inode " + "(gfid:%s) is already present " + "in inode-dentry-list", + dentry->name, uuid_utoa(local->loc.inode->gfid)); + break; + } + } + + if (!found) { + dentry = __quota_dentry_new(ctx, (char *)local->loc.name, + local->loc.parent->gfid); + if (dentry == NULL) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "cannot create a new dentry (name:%s)" + "for inode(gfid:%s)", + local->loc.name, uuid_utoa(local->loc.inode->gfid)); + op_ret = -1; + op_errno = ENOMEM; + goto unlock; + } } + + ctx->buf = *buf; + } unlock: - UNLOCK (&ctx->lock); + UNLOCK(&ctx->lock); out: - QUOTA_STACK_UNWIND (link, frame, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); + QUOTA_STACK_UNWIND(link, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); - return 0; + return 0; } - int32_t -quota_link_helper (call_frame_t *frame, xlator_t *this, loc_t *oldloc, - loc_t *newloc, dict_t *xdata) +quota_link_helper(call_frame_t *frame, xlator_t *this, loc_t *oldloc, + loc_t *newloc, dict_t *xdata) { - quota_local_t *local = NULL; - int32_t op_errno = EINVAL; + quota_local_t *local = NULL; + int32_t op_errno = EINVAL; - local = frame->local; + local = frame->local; - GF_VALIDATE_OR_GOTO ("quota", local, unwind); + GF_VALIDATE_OR_GOTO("quota", local, unwind); - op_errno = local->op_errno; + op_errno = local->op_errno; - if (local->op_ret == -1) { - goto unwind; - } + if (local->op_ret == -1) { + goto unwind; + } - STACK_WIND (frame, quota_link_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->link, oldloc, - newloc, xdata); - return 0; + STACK_WIND(frame, quota_link_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata); + return 0; unwind: - QUOTA_STACK_UNWIND (link, frame, -1, op_errno, NULL, NULL, - NULL, NULL, NULL); - return 0; + QUOTA_STACK_UNWIND(link, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL); + return 0; } void -quota_link_continue (call_frame_t *frame) +quota_link_continue(call_frame_t *frame) { - int32_t ret = -1; - int32_t op_errno = EIO; - quota_local_t *local = NULL; - uuid_t common_ancestor = {0}; - xlator_t *this = NULL; - quota_inode_ctx_t *ctx = NULL; - inode_t *src_parent = NULL; - inode_t *dst_parent = NULL; - - local = frame->local; - this = THIS; - - if (local->op_ret < 0) { - op_errno = local->op_errno; - goto err; - } - - if (local->xdata && - dict_get (local->xdata, GLUSTERFS_INTERNAL_FOP_KEY)) { - /* Treat link as rename, crawl upwards only till common ancestor - */ - ret = quota_find_common_ancestor (local->oldloc.inode, - local->newloc.parent, - &common_ancestor); - if (ret < 0 || gf_uuid_is_null(common_ancestor)) { - gf_msg (this->name, GF_LOG_ERROR, ESTALE, - Q_MSG_ANCESTRY_BUILD_FAILED, "failed to get " - "common_ancestor for %s and %s", - local->oldloc.path, local->newloc.path); - op_errno = ESTALE; - goto err; - } - } else { - /* Treat link as a new file. - * TODO: Currently marker accounts twice for the links created - * across directories. - * This needs re-visit if marker accounts only once - * for the links created across directories - */ - if (local->oldloc.parent) - src_parent = inode_ref (local->oldloc.parent); - else - src_parent = inode_parent (local->oldloc.inode, 0, - NULL); - dst_parent = local->newloc.parent; - - /* No need to check quota limit if src and dst parents are same - */ - if (src_parent == dst_parent || - gf_uuid_compare (src_parent->gfid, dst_parent->gfid) == 0) { - inode_unref (src_parent); - goto wind; - } - - inode_unref (src_parent); - } + int32_t ret = -1; + int32_t op_errno = EIO; + quota_local_t *local = NULL; + uuid_t common_ancestor = {0}; + xlator_t *this = NULL; + quota_inode_ctx_t *ctx = NULL; + inode_t *src_parent = NULL; + inode_t *dst_parent = NULL; + + local = frame->local; + this = THIS; + + if (local->op_ret < 0) { + op_errno = local->op_errno; + goto err; + } - quota_inode_ctx_get (local->oldloc.inode, this, &ctx, 0); - if (ctx == NULL) { - gf_msg_debug (this->name, 0, "quota context is NULL on inode" - " (%s). If quota is not enabled recently and " - "crawler has finished crawling, its an error", - uuid_utoa (local->oldloc.inode->gfid)); - } + if (local->xdata && dict_get(local->xdata, GLUSTERFS_INTERNAL_FOP_KEY)) { + /* Treat link as rename, crawl upwards only till common ancestor + */ + ret = quota_find_common_ancestor( + local->oldloc.inode, local->newloc.parent, &common_ancestor); + if (ret < 0 || gf_uuid_is_null(common_ancestor)) { + gf_msg(this->name, GF_LOG_ERROR, ESTALE, + Q_MSG_ANCESTRY_BUILD_FAILED, + "failed to get " + "common_ancestor for %s and %s", + local->oldloc.path, local->newloc.path); + op_errno = ESTALE; + goto err; + } + } else { + /* Treat link as a new file. + * TODO: Currently marker accounts twice for the links created + * across directories. + * This needs re-visit if marker accounts only once + * for the links created across directories + */ + if (local->oldloc.parent) + src_parent = inode_ref(local->oldloc.parent); + else + src_parent = inode_parent(local->oldloc.inode, 0, NULL); + dst_parent = local->newloc.parent; - LOCK (&local->lock); - { - local->link_count = 1; - local->delta = (ctx != NULL) ? ctx->buf.ia_blocks * 512 : 0; - local->object_delta = 1; - gf_uuid_copy (local->common_ancestor, common_ancestor); - } - UNLOCK (&local->lock); + /* No need to check quota limit if src and dst parents are same + */ + if (src_parent == dst_parent || + gf_uuid_compare(src_parent->gfid, dst_parent->gfid) == 0) { + inode_unref(src_parent); + goto wind; + } + + inode_unref(src_parent); + } + + quota_inode_ctx_get(local->oldloc.inode, this, &ctx, 0); + if (ctx == NULL) { + gf_msg_debug(this->name, 0, + "quota context is NULL on inode" + " (%s). If quota is not enabled recently and " + "crawler has finished crawling, its an error", + uuid_utoa(local->oldloc.inode->gfid)); + } + + LOCK(&local->lock); + { + local->link_count = 1; + local->delta = (ctx != NULL) ? ctx->buf.ia_blocks * 512 : 0; + local->object_delta = 1; + gf_uuid_copy(local->common_ancestor, common_ancestor); + } + UNLOCK(&local->lock); - quota_check_limit (frame, local->newloc.parent, this); - return; + quota_check_limit(frame, local->newloc.parent, this); + return; err: - QUOTA_STACK_UNWIND (link, frame, -1, op_errno, NULL, NULL, - NULL, NULL, NULL); - return; + QUOTA_STACK_UNWIND(link, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL); + return; wind: - STACK_WIND (frame, quota_link_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->link, &(local->oldloc), - &(local->newloc), local->xdata); - return; + STACK_WIND(frame, quota_link_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->link, &(local->oldloc), + &(local->newloc), local->xdata); + return; } int32_t -quota_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, - dict_t *xdata) +quota_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, + dict_t *xdata) { - quota_priv_t *priv = NULL; - int32_t ret = -1; - int32_t op_errno = ENOMEM; - quota_local_t *local = NULL; - call_stub_t *stub = NULL; - - priv = this->private; - - WIND_IF_QUOTAOFF (priv->is_quota_on, off); - - local = quota_local_new (); - if (local == NULL) { - goto err; - } - - frame->local = (void *) local; - - if (xdata) - local->xdata = dict_ref (xdata); - - ret = loc_copy (&local->loc, newloc); - if (ret == -1) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "loc_copy failed"); - goto err; - } - - ret = loc_copy (&local->oldloc, oldloc); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, - "loc_copy failed"); - goto err; - } - - ret = loc_copy (&local->newloc, newloc); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, - "loc_copy failed"); - goto err; - } - - /* No need to check quota limit if src and dst parents are same */ - if (oldloc->parent && newloc->parent && - !gf_uuid_compare(oldloc->parent->gfid, newloc->parent->gfid)) { - gf_msg_debug (this->name, GF_LOG_DEBUG, "link %s -> %s are " - "in the same directory, so skip check limit", - oldloc->path, newloc->path); - goto wind; - } - - stub = fop_link_stub (frame, quota_link_helper, oldloc, newloc, xdata); - if (stub == NULL) { - goto err; - } - - LOCK (&local->lock); - { - local->link_count = 2; - local->fop_continue_cbk = quota_link_continue; - local->stub = stub; - } - UNLOCK (&local->lock); + quota_priv_t *priv = NULL; + int32_t ret = -1; + int32_t op_errno = ENOMEM; + quota_local_t *local = NULL; + call_stub_t *stub = NULL; + + priv = this->private; + + WIND_IF_QUOTAOFF(priv->is_quota_on, off); + + local = quota_local_new(); + if (local == NULL) { + goto err; + } + + frame->local = (void *)local; + + if (xdata) + local->xdata = dict_ref(xdata); + + ret = loc_copy(&local->loc, newloc); + if (ret == -1) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "loc_copy failed"); + goto err; + } + + ret = loc_copy(&local->oldloc, oldloc); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "loc_copy failed"); + goto err; + } + + ret = loc_copy(&local->newloc, newloc); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "loc_copy failed"); + goto err; + } + + /* No need to check quota limit if src and dst parents are same */ + if (oldloc->parent && newloc->parent && + !gf_uuid_compare(oldloc->parent->gfid, newloc->parent->gfid)) { + gf_msg_debug(this->name, GF_LOG_DEBUG, + "link %s -> %s are " + "in the same directory, so skip check limit", + oldloc->path, newloc->path); + goto wind; + } + + stub = fop_link_stub(frame, quota_link_helper, oldloc, newloc, xdata); + if (stub == NULL) { + goto err; + } + + LOCK(&local->lock); + { + local->link_count = 2; + local->fop_continue_cbk = quota_link_continue; + local->stub = stub; + } + UNLOCK(&local->lock); - check_ancestory (frame, newloc->parent); + check_ancestory(frame, newloc->parent); - /* source parent can be NULL, so do check_ancestry on a file */ - if (oldloc->parent) - check_ancestory (frame, oldloc->parent); - else - check_ancestory (frame, oldloc->inode); + /* source parent can be NULL, so do check_ancestry on a file */ + if (oldloc->parent) + check_ancestory(frame, oldloc->parent); + else + check_ancestory(frame, oldloc->inode); - return 0; + return 0; err: - QUOTA_STACK_UNWIND (link, frame, -1, op_errno, NULL, NULL, - NULL, NULL, NULL); - return 0; + QUOTA_STACK_UNWIND(link, frame, -1, op_errno, NULL, NULL, NULL, NULL, NULL); + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->link, oldloc, - newloc, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->link, + oldloc, newloc, xdata); + return 0; wind: - STACK_WIND (frame, quota_link_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->link, oldloc, - newloc, xdata); - return 0; + STACK_WIND(frame, quota_link_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata); + return 0; } - int32_t -quota_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - struct iatt *preoldparent, struct iatt *postoldparent, - struct iatt *prenewparent, struct iatt *postnewparent, - dict_t *xdata) +quota_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + struct iatt *preoldparent, struct iatt *postoldparent, + struct iatt *prenewparent, struct iatt *postnewparent, + dict_t *xdata) { - int32_t ret = -1; - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; - quota_dentry_t *old_dentry = NULL, *dentry = NULL; - char new_dentry_found = 0; + int32_t ret = -1; + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; + quota_dentry_t *old_dentry = NULL, *dentry = NULL; + char new_dentry_found = 0; - if (op_ret < 0) { - goto out; - } + if (op_ret < 0) { + goto out; + } - local = frame->local; + local = frame->local; - GF_VALIDATE_OR_GOTO ("quota", local, out); + GF_VALIDATE_OR_GOTO("quota", local, out); - if (!QUOTA_REG_OR_LNK_FILE (local->oldloc.inode->ia_type)) - goto out; + if (!QUOTA_REG_OR_LNK_FILE(local->oldloc.inode->ia_type)) + goto out; - ret = quota_inode_ctx_get (local->oldloc.inode, this, &ctx, 0); - if ((ret == -1) || (ctx == NULL)) { - gf_msg_debug (this->name, 0, "quota context is NULL on inode" - " (%s). If quota is not enabled recently and " - "crawler has finished crawling, its an error", - uuid_utoa (local->oldloc.inode->gfid)); + ret = quota_inode_ctx_get(local->oldloc.inode, this, &ctx, 0); + if ((ret == -1) || (ctx == NULL)) { + gf_msg_debug(this->name, 0, + "quota context is NULL on inode" + " (%s). If quota is not enabled recently and " + "crawler has finished crawling, its an error", + uuid_utoa(local->oldloc.inode->gfid)); - goto out; - } + goto out; + } - LOCK (&ctx->lock); + LOCK(&ctx->lock); + { + list_for_each_entry(dentry, &ctx->parents, next) { - list_for_each_entry (dentry, &ctx->parents, next) { - if ((strcmp (dentry->name, local->oldloc.name) == 0) && - (gf_uuid_compare (local->oldloc.parent->gfid, - dentry->par) == 0)) { - old_dentry = dentry; - } else if ((strcmp (dentry->name, - local->newloc.name) == 0) && - (gf_uuid_compare (local->newloc.parent->gfid, - dentry->par) == 0)) { - new_dentry_found = 1; - gf_msg_debug (this->name, 0, "new entry being " - "linked (name:%s) for inode (gfid:%s) " - "is in inode-dentry-list", dentry->name, - uuid_utoa (local->oldloc.inode->gfid)); - } - - if (old_dentry && new_dentry_found) - break; - } - - if (old_dentry != NULL) { - __quota_dentry_free (old_dentry); - } else { - gf_msg_debug (this->name, 0, "dentry corresponding" - "the path just renamed (name:%s) is not" - " present", local->oldloc.name); - } - - if (!new_dentry_found) { - dentry = __quota_dentry_new (ctx, - (char *)local->newloc.name, - local->newloc.parent->gfid); - if (dentry == NULL) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, - "cannot create a new dentry (name:%s) " - "for inode(gfid:%s)", - local->newloc.name, - uuid_utoa (local->newloc.inode->gfid)); - op_ret = -1; - op_errno = ENOMEM; - goto unlock; - } - } - - ctx->buf = *buf; + if ((strcmp(dentry->name, local->oldloc.name) == 0) && + (gf_uuid_compare(local->oldloc.parent->gfid, dentry->par) == + 0)) { + old_dentry = dentry; + } else if ((strcmp(dentry->name, local->newloc.name) == 0) && + (gf_uuid_compare(local->newloc.parent->gfid, + dentry->par) == 0)) { + new_dentry_found = 1; + gf_msg_debug(this->name, 0, + "new entry being " + "linked (name:%s) for inode (gfid:%s) " + "is in inode-dentry-list", + dentry->name, + uuid_utoa(local->oldloc.inode->gfid)); + } + + if (old_dentry && new_dentry_found) + break; + } + + if (old_dentry != NULL) { + __quota_dentry_free(old_dentry); + } else { + gf_msg_debug(this->name, 0, + "dentry corresponding" + "the path just renamed (name:%s) is not" + " present", + local->oldloc.name); + } + + if (!new_dentry_found) { + dentry = __quota_dentry_new(ctx, (char *)local->newloc.name, + local->newloc.parent->gfid); + if (dentry == NULL) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "cannot create a new dentry (name:%s) " + "for inode(gfid:%s)", + local->newloc.name, + uuid_utoa(local->newloc.inode->gfid)); + op_ret = -1; + op_errno = ENOMEM; + goto unlock; + } } + + ctx->buf = *buf; + } unlock: - UNLOCK (&ctx->lock); + UNLOCK(&ctx->lock); out: - QUOTA_STACK_UNWIND (rename, frame, op_ret, op_errno, buf, preoldparent, - postoldparent, prenewparent, postnewparent, xdata); + QUOTA_STACK_UNWIND(rename, frame, op_ret, op_errno, buf, preoldparent, + postoldparent, prenewparent, postnewparent, xdata); - return 0; + return 0; } - int32_t -quota_rename_helper (call_frame_t *frame, xlator_t *this, loc_t *oldloc, - loc_t *newloc, dict_t *xdata) +quota_rename_helper(call_frame_t *frame, xlator_t *this, loc_t *oldloc, + loc_t *newloc, dict_t *xdata) { - quota_local_t *local = NULL; - int32_t op_errno = EINVAL; + quota_local_t *local = NULL; + int32_t op_errno = EINVAL; - local = frame->local; + local = frame->local; - GF_VALIDATE_OR_GOTO ("quota", local, unwind); + GF_VALIDATE_OR_GOTO("quota", local, unwind); - op_errno = local->op_errno; + op_errno = local->op_errno; - if (local->op_ret == -1) { - goto unwind; - } + if (local->op_ret == -1) { + goto unwind; + } - STACK_WIND (frame, quota_rename_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->rename, oldloc, - newloc, xdata); + STACK_WIND(frame, quota_rename_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->rename, oldloc, newloc, xdata); - return 0; + return 0; unwind: - QUOTA_STACK_UNWIND (rename, frame, -1, op_errno, NULL, NULL, - NULL, NULL, NULL, NULL); - return 0; + QUOTA_STACK_UNWIND(rename, frame, -1, op_errno, NULL, NULL, NULL, NULL, + NULL, NULL); + return 0; } - static int32_t -quota_rename_get_size_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *xdata, - struct iatt *postparent) +quota_rename_get_size_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *xdata, + struct iatt *postparent) { - quota_local_t *local = NULL; - int32_t ret = 0; - int64_t *size = 0; - - GF_ASSERT (frame); - GF_VALIDATE_OR_GOTO_WITH_ERROR ("quota", this, out, op_errno, - EINVAL); - GF_VALIDATE_OR_GOTO_WITH_ERROR (this->name, xdata, out, op_errno, - EINVAL); - local = frame->local; - GF_ASSERT (local); - local->link_count = 1; - - if (op_ret < 0) - goto out; - - - ret = dict_get_bin (xdata, QUOTA_SIZE_KEY, (void **) &size); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, EINVAL, - Q_MSG_SIZE_KEY_MISSING, "size key not present in dict"); - op_errno = EINVAL; - goto out; - } - local->delta = ntoh64 (*size); - local->object_delta = 1; - quota_check_limit (frame, local->newloc.parent, this); - return 0; + quota_local_t *local = NULL; + int32_t ret = 0; + int64_t *size = 0; + + GF_ASSERT(frame); + GF_VALIDATE_OR_GOTO_WITH_ERROR("quota", this, out, op_errno, EINVAL); + GF_VALIDATE_OR_GOTO_WITH_ERROR(this->name, xdata, out, op_errno, EINVAL); + local = frame->local; + GF_ASSERT(local); + local->link_count = 1; + + if (op_ret < 0) + goto out; + + ret = dict_get_bin(xdata, QUOTA_SIZE_KEY, (void **)&size); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, EINVAL, Q_MSG_SIZE_KEY_MISSING, + "size key not present in dict"); + op_errno = EINVAL; + goto out; + } + local->delta = ntoh64(*size); + local->object_delta = 1; + quota_check_limit(frame, local->newloc.parent, this); + return 0; out: - quota_handle_validate_error (frame, -1, op_errno); - return 0; + quota_handle_validate_error(frame, -1, op_errno); + return 0; } void -quota_rename_continue (call_frame_t *frame) +quota_rename_continue(call_frame_t *frame) { - int32_t ret = -1; - int32_t op_errno = EIO; - quota_local_t *local = NULL; - uuid_t common_ancestor = {0}; - xlator_t *this = NULL; - quota_inode_ctx_t *ctx = NULL; - - local = frame->local; - this = THIS; - - if (local->op_ret < 0) { - op_errno = local->op_errno; - goto err; - } - - ret = quota_find_common_ancestor (local->oldloc.parent, - local->newloc.parent, - &common_ancestor); - if (ret < 0 || gf_uuid_is_null(common_ancestor)) { - gf_msg (this->name, GF_LOG_ERROR, ESTALE, - Q_MSG_ANCESTRY_BUILD_FAILED, "failed to get " - "common_ancestor for %s and %s", - local->oldloc.path, local->newloc.path); - op_errno = ESTALE; - goto err; - } + int32_t ret = -1; + int32_t op_errno = EIO; + quota_local_t *local = NULL; + uuid_t common_ancestor = {0}; + xlator_t *this = NULL; + quota_inode_ctx_t *ctx = NULL; - LOCK (&local->lock); - { - local->link_count = 1; - gf_uuid_copy (local->common_ancestor, common_ancestor); - } - UNLOCK (&local->lock); - - if (QUOTA_REG_OR_LNK_FILE (local->oldloc.inode->ia_type)) { - ret = quota_inode_ctx_get (local->oldloc.inode, this, &ctx, 0); - if (ctx == NULL) { - gf_msg (this->name, GF_LOG_WARNING, 0, - Q_MSG_INODE_CTX_GET_FAILED, - "quota context not set in inode (gfid:%s), " - "considering file size as zero while enforcing " - "quota on new ancestry", - uuid_utoa (local->oldloc.inode->gfid)); - - - local->delta = 0; - local->object_delta = 1; - } else { + local = frame->local; + this = THIS; - /* FIXME: We need to account for the size occupied by - * this inode on the target directory. To avoid double - * accounting, we need to modify enforcer to perform - * quota_check_limit only up till the least common - * ancestor directory inode*/ + if (local->op_ret < 0) { + op_errno = local->op_errno; + goto err; + } + + ret = quota_find_common_ancestor(local->oldloc.parent, local->newloc.parent, + &common_ancestor); + if (ret < 0 || gf_uuid_is_null(common_ancestor)) { + gf_msg(this->name, GF_LOG_ERROR, ESTALE, Q_MSG_ANCESTRY_BUILD_FAILED, + "failed to get " + "common_ancestor for %s and %s", + local->oldloc.path, local->newloc.path); + op_errno = ESTALE; + goto err; + } + + LOCK(&local->lock); + { + local->link_count = 1; + gf_uuid_copy(local->common_ancestor, common_ancestor); + } + UNLOCK(&local->lock); - /* FIXME: The following code assumes that regular files - * and link files are present, in their entirety, in a - * single brick. This *assumption is invalid in the - * case of stripe.*/ + if (QUOTA_REG_OR_LNK_FILE(local->oldloc.inode->ia_type)) { + ret = quota_inode_ctx_get(local->oldloc.inode, this, &ctx, 0); + if (ctx == NULL) { + gf_msg(this->name, GF_LOG_WARNING, 0, Q_MSG_INODE_CTX_GET_FAILED, + "quota context not set in inode (gfid:%s), " + "considering file size as zero while enforcing " + "quota on new ancestry", + uuid_utoa(local->oldloc.inode->gfid)); + + local->delta = 0; + local->object_delta = 1; + } else { + /* FIXME: We need to account for the size occupied by + * this inode on the target directory. To avoid double + * accounting, we need to modify enforcer to perform + * quota_check_limit only up till the least common + * ancestor directory inode*/ - local->delta = ctx->buf.ia_blocks * 512; - local->object_delta = 1; - } + /* FIXME: The following code assumes that regular files + * and link files are present, in their entirety, in a + * single brick. This *assumption is invalid in the + * case of stripe.*/ - } else if (IA_ISDIR (local->oldloc.inode->ia_type)) { - ret = quota_validate (frame, local->oldloc.inode, this, - quota_rename_get_size_cbk); - if (ret){ - op_errno = -ret; - goto err; - } + local->delta = ctx->buf.ia_blocks * 512; + local->object_delta = 1; + } - return; + } else if (IA_ISDIR(local->oldloc.inode->ia_type)) { + ret = quota_validate(frame, local->oldloc.inode, this, + quota_rename_get_size_cbk); + if (ret) { + op_errno = -ret; + goto err; } - quota_check_limit (frame, local->newloc.parent, this); return; + } -err: - QUOTA_STACK_UNWIND (rename, frame, -1, op_errno, NULL, - NULL, NULL, NULL, NULL, NULL); - return; + quota_check_limit(frame, local->newloc.parent, this); + return; +err: + QUOTA_STACK_UNWIND(rename, frame, -1, op_errno, NULL, NULL, NULL, NULL, + NULL, NULL); + return; } int32_t -quota_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, - loc_t *newloc, dict_t *xdata) +quota_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, + dict_t *xdata) { - quota_priv_t *priv = NULL; - int32_t ret = -1; - int32_t op_errno = ENOMEM; - quota_local_t *local = NULL; - call_stub_t *stub = NULL; - - priv = this->private; - - WIND_IF_QUOTAOFF (priv->is_quota_on, off); - - local = quota_local_new (); - if (local == NULL) { - goto err; - } - - frame->local = local; - - ret = loc_copy (&local->oldloc, oldloc); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, - "loc_copy failed"); - goto err; - } - - ret = loc_copy (&local->newloc, newloc); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, - "loc_copy failed"); - goto err; - } - - /* No need to check quota limit if src and dst parents are same */ - if (oldloc->parent && newloc->parent && - !gf_uuid_compare(oldloc->parent->gfid, newloc->parent->gfid)) { - gf_msg_debug (this->name, 0, "rename %s -> %s are " - "in the same directory, so skip check limit", - oldloc->path, newloc->path); - goto wind; - } - - stub = fop_rename_stub (frame, quota_rename_helper, oldloc, newloc, - xdata); - if (stub == NULL) { - goto err; - } - - LOCK (&local->lock); - { - /* link_count here tell how many check_ancestry should be done - * before continuing the FOP - */ - local->link_count = 2; - local->stub = stub; - local->fop_continue_cbk = quota_rename_continue; - } - UNLOCK (&local->lock); + quota_priv_t *priv = NULL; + int32_t ret = -1; + int32_t op_errno = ENOMEM; + quota_local_t *local = NULL; + call_stub_t *stub = NULL; + + priv = this->private; + + WIND_IF_QUOTAOFF(priv->is_quota_on, off); + + local = quota_local_new(); + if (local == NULL) { + goto err; + } + + frame->local = local; + + ret = loc_copy(&local->oldloc, oldloc); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "loc_copy failed"); + goto err; + } + + ret = loc_copy(&local->newloc, newloc); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "loc_copy failed"); + goto err; + } + + /* No need to check quota limit if src and dst parents are same */ + if (oldloc->parent && newloc->parent && + !gf_uuid_compare(oldloc->parent->gfid, newloc->parent->gfid)) { + gf_msg_debug(this->name, 0, + "rename %s -> %s are " + "in the same directory, so skip check limit", + oldloc->path, newloc->path); + goto wind; + } + + stub = fop_rename_stub(frame, quota_rename_helper, oldloc, newloc, xdata); + if (stub == NULL) { + goto err; + } + + LOCK(&local->lock); + { + /* link_count here tell how many check_ancestry should be done + * before continuing the FOP + */ + local->link_count = 2; + local->stub = stub; + local->fop_continue_cbk = quota_rename_continue; + } + UNLOCK(&local->lock); - check_ancestory (frame, newloc->parent); - check_ancestory (frame, oldloc->parent); - return 0; + check_ancestory(frame, newloc->parent); + check_ancestory(frame, oldloc->parent); + return 0; err: - QUOTA_STACK_UNWIND (rename, frame, -1, op_errno, NULL, - NULL, NULL, NULL, NULL, NULL); - return 0; + QUOTA_STACK_UNWIND(rename, frame, -1, op_errno, NULL, NULL, NULL, NULL, + NULL, NULL); + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->rename, oldloc, - newloc, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->rename, + oldloc, newloc, xdata); + return 0; wind: - STACK_WIND (frame, quota_rename_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->rename, oldloc, - newloc, xdata); - return 0; + STACK_WIND(frame, quota_rename_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->rename, oldloc, newloc, xdata); + return 0; } - int32_t -quota_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +quota_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) { - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; - quota_dentry_t *dentry = NULL; - int32_t ret = -1; - - if (op_ret < 0) { - goto out; - } - - local = frame->local; - - ret = quota_inode_ctx_get (local->loc.inode, this, &ctx, 1); - if ((ret == -1) || (ctx == NULL)) { - gf_msg_debug (this->name, 0, "quota context is NULL on inode" - " (%s). If quota is not enabled recently and " - "crawler has finished crawling, its an error", - uuid_utoa (local->loc.inode->gfid)); - - goto out; - } - - LOCK (&ctx->lock); - { - ctx->buf = *buf; - - dentry = __quota_dentry_new (ctx, (char *)local->loc.name, - local->loc.parent->gfid); - if (dentry == NULL) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "cannot create " - "a new dentry (name:%s) for inode(gfid:%s)", - local->loc.name, - uuid_utoa (local->loc.inode->gfid)); - op_ret = -1; - op_errno = ENOMEM; - } + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; + quota_dentry_t *dentry = NULL; + int32_t ret = -1; + + if (op_ret < 0) { + goto out; + } + + local = frame->local; + + ret = quota_inode_ctx_get(local->loc.inode, this, &ctx, 1); + if ((ret == -1) || (ctx == NULL)) { + gf_msg_debug(this->name, 0, + "quota context is NULL on inode" + " (%s). If quota is not enabled recently and " + "crawler has finished crawling, its an error", + uuid_utoa(local->loc.inode->gfid)); + + goto out; + } + + LOCK(&ctx->lock); + { + ctx->buf = *buf; + + dentry = __quota_dentry_new(ctx, (char *)local->loc.name, + local->loc.parent->gfid); + if (dentry == NULL) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "cannot create " + "a new dentry (name:%s) for inode(gfid:%s)", + local->loc.name, uuid_utoa(local->loc.inode->gfid)); + op_ret = -1; + op_errno = ENOMEM; } - UNLOCK (&ctx->lock); + } + UNLOCK(&ctx->lock); out: - QUOTA_STACK_UNWIND (symlink, frame, op_ret, op_errno, inode, buf, - preparent, postparent, xdata); + QUOTA_STACK_UNWIND(symlink, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); - return 0; + return 0; } - int -quota_symlink_helper (call_frame_t *frame, xlator_t *this, const char *linkpath, - loc_t *loc, mode_t umask, dict_t *xdata) +quota_symlink_helper(call_frame_t *frame, xlator_t *this, const char *linkpath, + loc_t *loc, mode_t umask, dict_t *xdata) { - quota_local_t *local = NULL; - int32_t op_errno = EINVAL; + quota_local_t *local = NULL; + int32_t op_errno = EINVAL; - local = frame->local; + local = frame->local; - GF_VALIDATE_OR_GOTO ("quota", local, unwind); + GF_VALIDATE_OR_GOTO("quota", local, unwind); - if (local->op_ret == -1) { - op_errno = local->op_errno; - goto unwind; - } + if (local->op_ret == -1) { + op_errno = local->op_errno; + goto unwind; + } - STACK_WIND (frame, quota_symlink_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->symlink, - linkpath, loc, umask, xdata); - return 0; + STACK_WIND(frame, quota_symlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->symlink, linkpath, loc, umask, xdata); + return 0; unwind: - QUOTA_STACK_UNWIND (symlink, frame, -1, op_errno, NULL, NULL, - NULL, NULL, NULL); - return 0; + QUOTA_STACK_UNWIND(symlink, frame, -1, op_errno, NULL, NULL, NULL, NULL, + NULL); + return 0; } - int -quota_symlink (call_frame_t *frame, xlator_t *this, const char *linkpath, - loc_t *loc, mode_t umask, dict_t *xdata) +quota_symlink(call_frame_t *frame, xlator_t *this, const char *linkpath, + loc_t *loc, mode_t umask, dict_t *xdata) { - quota_priv_t *priv = NULL; - int32_t ret = -1; - int32_t op_errno = ENOMEM; - quota_local_t *local = NULL; - call_stub_t *stub = NULL; + quota_priv_t *priv = NULL; + int32_t ret = -1; + int32_t op_errno = ENOMEM; + quota_local_t *local = NULL; + call_stub_t *stub = NULL; - priv = this->private; + priv = this->private; - WIND_IF_QUOTAOFF (priv->is_quota_on, off); + WIND_IF_QUOTAOFF(priv->is_quota_on, off); - local = quota_local_new (); - if (local == NULL) { - goto err; - } + local = quota_local_new(); + if (local == NULL) { + goto err; + } - frame->local = local; + frame->local = local; - ret = loc_copy (&local->loc, loc); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "loc_copy failed"); - goto err; - } + ret = loc_copy(&local->loc, loc); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "loc_copy failed"); + goto err; + } - stub = fop_symlink_stub (frame, quota_symlink_helper, linkpath, loc, - umask, xdata); - if (stub == NULL) { - goto err; - } + stub = fop_symlink_stub(frame, quota_symlink_helper, linkpath, loc, umask, + xdata); + if (stub == NULL) { + goto err; + } - LOCK (&local->lock); - { - local->stub = stub; - local->delta = strlen (linkpath); - local->object_delta = 1; - local->link_count = 1; - } - UNLOCK (&local->lock); + LOCK(&local->lock); + { + local->stub = stub; + local->delta = strlen(linkpath); + local->object_delta = 1; + local->link_count = 1; + } + UNLOCK(&local->lock); - quota_check_limit (frame, loc->parent, this); - return 0; + quota_check_limit(frame, loc->parent, this); + return 0; err: - QUOTA_STACK_UNWIND (symlink, frame, -1, op_errno, NULL, NULL, NULL, - NULL, NULL); + QUOTA_STACK_UNWIND(symlink, frame, -1, op_errno, NULL, NULL, NULL, NULL, + NULL); - return 0; + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->symlink, - linkpath, loc, umask, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->symlink, + linkpath, loc, umask, xdata); + return 0; } - int32_t -quota_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) +quota_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; - if (op_ret < 0) { - goto out; - } + if (op_ret < 0) { + goto out; + } - local = frame->local; + local = frame->local; - GF_VALIDATE_OR_GOTO ("quota", local, out); + GF_VALIDATE_OR_GOTO("quota", local, out); - quota_inode_ctx_get (local->loc.inode, this, &ctx, 0); - if (ctx == NULL) { - gf_msg_debug (this->name, 0, "quota context is NULL on inode" - " (%s). If quota is not enabled recently and " - "crawler has finished crawling, its an error", - uuid_utoa (local->loc.inode->gfid)); - goto out; - } + quota_inode_ctx_get(local->loc.inode, this, &ctx, 0); + if (ctx == NULL) { + gf_msg_debug(this->name, 0, + "quota context is NULL on inode" + " (%s). If quota is not enabled recently and " + "crawler has finished crawling, its an error", + uuid_utoa(local->loc.inode->gfid)); + goto out; + } - LOCK (&ctx->lock); - { - ctx->buf = *postbuf; - } - UNLOCK (&ctx->lock); + LOCK(&ctx->lock); + { + ctx->buf = *postbuf; + } + UNLOCK(&ctx->lock); out: - QUOTA_STACK_UNWIND (truncate, frame, op_ret, op_errno, prebuf, - postbuf, xdata); - return 0; + QUOTA_STACK_UNWIND(truncate, frame, op_ret, op_errno, prebuf, postbuf, + xdata); + return 0; } - int32_t -quota_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, - dict_t *xdata) +quota_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, + dict_t *xdata) { - quota_priv_t *priv = NULL; - int32_t ret = -1; - quota_local_t *local = NULL; + quota_priv_t *priv = NULL; + int32_t ret = -1; + quota_local_t *local = NULL; - priv = this->private; + priv = this->private; - WIND_IF_QUOTAOFF (priv->is_quota_on, off); + WIND_IF_QUOTAOFF(priv->is_quota_on, off); - local = quota_local_new (); - if (local == NULL) { - goto err; - } + local = quota_local_new(); + if (local == NULL) { + goto err; + } - frame->local = local; + frame->local = local; - ret = loc_copy (&local->loc, loc); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "loc_copy failed"); - goto err; - } + ret = loc_copy(&local->loc, loc); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "loc_copy failed"); + goto err; + } - STACK_WIND (frame, quota_truncate_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->truncate, loc, offset, xdata); + STACK_WIND(frame, quota_truncate_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->truncate, loc, offset, xdata); - return 0; + return 0; err: - QUOTA_STACK_UNWIND (truncate, frame, -1, ENOMEM, NULL, NULL, NULL); + QUOTA_STACK_UNWIND(truncate, frame, -1, ENOMEM, NULL, NULL, NULL); - return 0; + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->truncate, loc, offset, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->truncate, + loc, offset, xdata); + return 0; } - int32_t -quota_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) +quota_ftruncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; - if (op_ret < 0) { - goto out; - } + if (op_ret < 0) { + goto out; + } - local = frame->local; + local = frame->local; - GF_VALIDATE_OR_GOTO ("quota", local, out); + GF_VALIDATE_OR_GOTO("quota", local, out); - quota_inode_ctx_get (local->loc.inode, this, &ctx, 0); - if (ctx == NULL) { - gf_msg_debug (this->name, 0, "quota context is NULL on inode" - " (%s). If quota is not enabled recently and " - "crawler has finished crawling, its an error", - uuid_utoa (local->loc.inode->gfid)); - goto out; - } + quota_inode_ctx_get(local->loc.inode, this, &ctx, 0); + if (ctx == NULL) { + gf_msg_debug(this->name, 0, + "quota context is NULL on inode" + " (%s). If quota is not enabled recently and " + "crawler has finished crawling, its an error", + uuid_utoa(local->loc.inode->gfid)); + goto out; + } - LOCK (&ctx->lock); - { - ctx->buf = *postbuf; - } - UNLOCK (&ctx->lock); + LOCK(&ctx->lock); + { + ctx->buf = *postbuf; + } + UNLOCK(&ctx->lock); out: - QUOTA_STACK_UNWIND (ftruncate, frame, op_ret, op_errno, prebuf, - postbuf, xdata); - return 0; + QUOTA_STACK_UNWIND(ftruncate, frame, op_ret, op_errno, prebuf, postbuf, + xdata); + return 0; } - int32_t -quota_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, - dict_t *xdata) +quota_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, + dict_t *xdata) { - quota_priv_t *priv = NULL; - quota_local_t *local = NULL; + quota_priv_t *priv = NULL; + quota_local_t *local = NULL; - priv = this->private; + priv = this->private; - WIND_IF_QUOTAOFF (priv->is_quota_on, off); + WIND_IF_QUOTAOFF(priv->is_quota_on, off); - local = quota_local_new (); - if (local == NULL) - goto err; + local = quota_local_new(); + if (local == NULL) + goto err; - frame->local = local; + frame->local = local; - local->loc.inode = inode_ref (fd->inode); + local->loc.inode = inode_ref(fd->inode); - STACK_WIND (frame, quota_ftruncate_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->ftruncate, fd, - offset, xdata); + STACK_WIND(frame, quota_ftruncate_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata); - return 0; + return 0; err: - QUOTA_STACK_UNWIND (ftruncate, frame, -1, ENOMEM, NULL, NULL, NULL); + QUOTA_STACK_UNWIND(ftruncate, frame, -1, ENOMEM, NULL, NULL, NULL); - return 0; + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->ftruncate, fd, - offset, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata); + return 0; } - int32_t -quota_send_dir_limit_to_cli (call_frame_t *frame, xlator_t *this, - inode_t *inode, const char *name) +quota_send_dir_limit_to_cli(call_frame_t *frame, xlator_t *this, inode_t *inode, + const char *name) { - int32_t ret = 0; - char dir_limit [1024] = {0, }; - dict_t *dict = NULL; - quota_inode_ctx_t *ctx = NULL; - uint64_t value = 0; - quota_priv_t *priv = NULL; - - priv = this->private; - if (!priv->is_quota_on) { - snprintf (dir_limit, 1024, "Quota is disabled please turn on"); - goto dict_set; - } - - ret = inode_ctx_get (inode, this, &value); - if (ret < 0) - goto out; - - ctx = (quota_inode_ctx_t *)(unsigned long)value; - snprintf (dir_limit, 1024, "%"PRId64",%"PRId64, ctx->size, - ctx->hard_lim); + int32_t ret = 0; + char dir_limit[1024] = { + 0, + }; + dict_t *dict = NULL; + quota_inode_ctx_t *ctx = NULL; + uint64_t value = 0; + quota_priv_t *priv = NULL; + + priv = this->private; + if (!priv->is_quota_on) { + snprintf(dir_limit, 1024, "Quota is disabled please turn on"); + goto dict_set; + } + + ret = inode_ctx_get(inode, this, &value); + if (ret < 0) + goto out; + + ctx = (quota_inode_ctx_t *)(unsigned long)value; + snprintf(dir_limit, 1024, "%" PRId64 ",%" PRId64, ctx->size, ctx->hard_lim); dict_set: - dict = dict_new (); - if (dict == NULL) { - ret = -1; - goto out; - } + dict = dict_new(); + if (dict == NULL) { + ret = -1; + goto out; + } - ret = dict_set_str (dict, (char *) name, dir_limit); - if (ret < 0) - goto out; + ret = dict_set_str(dict, (char *)name, dir_limit); + if (ret < 0) + goto out; - gf_msg_debug (this->name, 0, "str = %s", dir_limit); + gf_msg_debug(this->name, 0, "str = %s", dir_limit); - QUOTA_STACK_UNWIND (getxattr, frame, 0, 0, dict, NULL); + QUOTA_STACK_UNWIND(getxattr, frame, 0, 0, dict, NULL); - ret = 0; + ret = 0; out: - if (dict) - dict_unref (dict); - return ret; -} - - -int32_t -quota_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - const char *name, dict_t *xdata) -{ - int32_t ret = 0; - - if (name && strcasecmp (name, "trusted.limit.list") == 0) { - ret = quota_send_dir_limit_to_cli (frame, this, fd->inode, - name); - if (ret == 0) { - return 0; - } - } - - STACK_WIND (frame, default_fgetxattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata); - return 0; -} - - -int32_t -quota_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name, dict_t *xdata) -{ - int32_t ret = 0; - - if ((name != NULL) && strcasecmp (name, "trusted.limit.list") == 0) { - ret = quota_send_dir_limit_to_cli (frame, this, loc->inode, - name); - if (ret == 0) - return 0; - } - - STACK_WIND (frame, default_getxattr_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->getxattr, loc, name, xdata); - return 0; + if (dict) + dict_unref(dict); + return ret; } - int32_t -quota_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, +quota_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name, dict_t *xdata) { - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; - - if (op_ret < 0) { - goto out; - } - - local = frame->local; - - GF_VALIDATE_OR_GOTO ("quota", local, out); - - quota_inode_ctx_get (local->loc.inode, this, &ctx, 0); - if (ctx == NULL) { - if (!IA_ISDIR (buf->ia_type)) { - gf_msg_debug (this->name, 0, "quota context is NULL on inode" - " (%s). If quota is not enabled recently and " - "crawler has finished crawling, its an error", - uuid_utoa (local->loc.inode->gfid)); - } - - goto out; - } - - LOCK (&ctx->lock); - { - if (buf) - ctx->buf = *buf; - } - UNLOCK (&ctx->lock); - -out: - QUOTA_STACK_UNWIND (stat, frame, op_ret, op_errno, buf, xdata); - return 0; -} - - -int32_t -quota_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) -{ - quota_priv_t *priv = NULL; - quota_local_t *local = NULL; - int32_t ret = -1; - - priv = this->private; - - WIND_IF_QUOTAOFF (priv->is_quota_on, off); + int32_t ret = 0; - local = quota_local_new (); - if (local == NULL) { - goto unwind; + if (name && strcasecmp(name, "trusted.limit.list") == 0) { + ret = quota_send_dir_limit_to_cli(frame, this, fd->inode, name); + if (ret == 0) { + return 0; } + } - frame->local = local; - ret = loc_copy (&local->loc, loc); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "loc_copy failed"); - goto unwind; - } + STACK_WIND(frame, default_fgetxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata); + return 0; +} - STACK_WIND (frame, quota_stat_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->stat, loc, - xdata); - return 0; +int32_t +quota_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) +{ + int32_t ret = 0; -unwind: - QUOTA_STACK_UNWIND (stat, frame, -1, ENOMEM, NULL, NULL); - return 0; + if ((name != NULL) && strcasecmp(name, "trusted.limit.list") == 0) { + ret = quota_send_dir_limit_to_cli(frame, this, loc->inode, name); + if (ret == 0) + return 0; + } -off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->stat, loc, - xdata); - return 0; + STACK_WIND(frame, default_getxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->getxattr, loc, name, xdata); + return 0; } - int32_t -quota_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *buf, - dict_t *xdata) +quota_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + dict_t *xdata) { - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; - - if (op_ret < 0) { - goto out; - } + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; - local = frame->local; + if (op_ret < 0) { + goto out; + } - GF_VALIDATE_OR_GOTO ("quota", local, out); + local = frame->local; - quota_inode_ctx_get (local->loc.inode, this, &ctx, 0); - if (ctx == NULL) { - if (!IA_ISDIR (buf->ia_type)) { - gf_msg_debug (this->name, 0, "quota context is NULL on inode" - " (%s). If quota is not enabled recently and " - "crawler has finished crawling, its an error", - uuid_utoa (local->loc.inode->gfid)); - } + GF_VALIDATE_OR_GOTO("quota", local, out); - goto out; + quota_inode_ctx_get(local->loc.inode, this, &ctx, 0); + if (ctx == NULL) { + if (!IA_ISDIR(buf->ia_type)) { + gf_msg_debug(this->name, 0, + "quota context is NULL on inode" + " (%s). If quota is not enabled recently and " + "crawler has finished crawling, its an error", + uuid_utoa(local->loc.inode->gfid)); } - LOCK (&ctx->lock); - { - if (buf) - ctx->buf = *buf; - } - UNLOCK (&ctx->lock); + goto out; + } + + LOCK(&ctx->lock); + { + if (buf) + ctx->buf = *buf; + } + UNLOCK(&ctx->lock); out: - QUOTA_STACK_UNWIND (fstat, frame, op_ret, op_errno, buf, xdata); - return 0; + QUOTA_STACK_UNWIND(stat, frame, op_ret, op_errno, buf, xdata); + return 0; } - int32_t -quota_fstat (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) +quota_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - quota_priv_t *priv = NULL; - quota_local_t *local = NULL; + quota_priv_t *priv = NULL; + quota_local_t *local = NULL; + int32_t ret = -1; - priv = this->private; + priv = this->private; - WIND_IF_QUOTAOFF (priv->is_quota_on, off); - - local = quota_local_new (); - if (local == NULL) { - goto unwind; - } + WIND_IF_QUOTAOFF(priv->is_quota_on, off); - frame->local = local; + local = quota_local_new(); + if (local == NULL) { + goto unwind; + } - local->loc.inode = inode_ref (fd->inode); + frame->local = local; + ret = loc_copy(&local->loc, loc); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "loc_copy failed"); + goto unwind; + } - STACK_WIND (frame, quota_fstat_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->fstat, fd, - xdata); - return 0; + STACK_WIND(frame, quota_stat_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->stat, loc, xdata); + return 0; unwind: - QUOTA_STACK_UNWIND (fstat, frame, -1, ENOMEM, NULL, NULL); - return 0; + QUOTA_STACK_UNWIND(stat, frame, -1, ENOMEM, NULL, NULL); + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fstat, fd, - xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->stat, + loc, xdata); + return 0; } - int32_t -quota_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, const char *path, - struct iatt *buf, dict_t *xdata) +quota_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *buf, + dict_t *xdata) { - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; - if (op_ret < 0) { - goto out; - } + if (op_ret < 0) { + goto out; + } - local = frame->local; + local = frame->local; - GF_VALIDATE_OR_GOTO ("quota", local, out); + GF_VALIDATE_OR_GOTO("quota", local, out); - quota_inode_ctx_get (local->loc.inode, this, &ctx, 0); - if (ctx == NULL) { - gf_msg_debug (this->name, 0, "quota context is NULL on inode" - " (%s). If quota is not enabled recently and " - "crawler has finished crawling, its an error", - uuid_utoa (local->loc.inode->gfid)); - goto out; + quota_inode_ctx_get(local->loc.inode, this, &ctx, 0); + if (ctx == NULL) { + if (!IA_ISDIR(buf->ia_type)) { + gf_msg_debug(this->name, 0, + "quota context is NULL on inode" + " (%s). If quota is not enabled recently and " + "crawler has finished crawling, its an error", + uuid_utoa(local->loc.inode->gfid)); } - LOCK (&ctx->lock); - { - ctx->buf = *buf; - } - UNLOCK (&ctx->lock); + goto out; + } + + LOCK(&ctx->lock); + { + if (buf) + ctx->buf = *buf; + } + UNLOCK(&ctx->lock); out: - QUOTA_STACK_UNWIND (readlink, frame, op_ret, op_errno, path, buf, - xdata); - return 0; + QUOTA_STACK_UNWIND(fstat, frame, op_ret, op_errno, buf, xdata); + return 0; } - int32_t -quota_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, - dict_t *xdata) +quota_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { - quota_priv_t *priv = NULL; - quota_local_t *local = NULL; - int32_t ret = -1; + quota_priv_t *priv = NULL; + quota_local_t *local = NULL; - priv = this->private; + priv = this->private; - WIND_IF_QUOTAOFF (priv->is_quota_on, off); + WIND_IF_QUOTAOFF(priv->is_quota_on, off); - local = quota_local_new (); - if (local == NULL) { - goto unwind; - } + local = quota_local_new(); + if (local == NULL) { + goto unwind; + } - frame->local = local; + frame->local = local; - ret = loc_copy (&local->loc, loc); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "loc_copy failed"); - goto unwind; - } + local->loc.inode = inode_ref(fd->inode); - STACK_WIND (frame, quota_readlink_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->readlink, loc, - size, xdata); - return 0; + STACK_WIND(frame, quota_fstat_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fstat, fd, xdata); + return 0; unwind: - QUOTA_STACK_UNWIND (readlink, frame, -1, ENOMEM, NULL, NULL, NULL); - return 0; + QUOTA_STACK_UNWIND(fstat, frame, -1, ENOMEM, NULL, NULL); + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readlink, loc, - size, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fstat, + fd, xdata); + return 0; } - int32_t -quota_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iovec *vector, - int32_t count, struct iatt *buf, struct iobref *iobref, - dict_t *xdata) +quota_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, const char *path, + struct iatt *buf, dict_t *xdata) { - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; - if (op_ret < 0) { - goto out; - } + if (op_ret < 0) { + goto out; + } - local = frame->local; + local = frame->local; - GF_VALIDATE_OR_GOTO ("quota", local, out); + GF_VALIDATE_OR_GOTO("quota", local, out); - quota_inode_ctx_get (local->loc.inode, this, &ctx, 0); - if (ctx == NULL) { - gf_msg_debug (this->name, 0, "quota context is NULL on inode" - " (%s). If quota is not enabled recently and " - "crawler has finished crawling, its an error", - uuid_utoa (local->loc.inode->gfid)); - goto out; - } + quota_inode_ctx_get(local->loc.inode, this, &ctx, 0); + if (ctx == NULL) { + gf_msg_debug(this->name, 0, + "quota context is NULL on inode" + " (%s). If quota is not enabled recently and " + "crawler has finished crawling, its an error", + uuid_utoa(local->loc.inode->gfid)); + goto out; + } - LOCK (&ctx->lock); - { - ctx->buf = *buf; - } - UNLOCK (&ctx->lock); + LOCK(&ctx->lock); + { + ctx->buf = *buf; + } + UNLOCK(&ctx->lock); out: - QUOTA_STACK_UNWIND (readv, frame, op_ret, op_errno, vector, count, - buf, iobref, xdata); - return 0; + QUOTA_STACK_UNWIND(readlink, frame, op_ret, op_errno, path, buf, xdata); + return 0; } - int32_t -quota_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t offset, uint32_t flags, dict_t *xdata) +quota_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, + dict_t *xdata) { - quota_priv_t *priv = NULL; - quota_local_t *local = NULL; + quota_priv_t *priv = NULL; + quota_local_t *local = NULL; + int32_t ret = -1; - priv = this->private; + priv = this->private; - WIND_IF_QUOTAOFF (priv->is_quota_on, off); + WIND_IF_QUOTAOFF(priv->is_quota_on, off); - local = quota_local_new (); - if (local == NULL) { - goto unwind; - } + local = quota_local_new(); + if (local == NULL) { + goto unwind; + } - frame->local = local; + frame->local = local; - local->loc.inode = inode_ref (fd->inode); + ret = loc_copy(&local->loc, loc); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "loc_copy failed"); + goto unwind; + } - STACK_WIND (frame, quota_readv_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->readv, fd, - size, offset, flags, xdata); - return 0; + STACK_WIND(frame, quota_readlink_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readlink, loc, size, xdata); + return 0; unwind: - QUOTA_STACK_UNWIND (readv, frame, -1, ENOMEM, NULL, -1, NULL, NULL, - NULL); - return 0; + QUOTA_STACK_UNWIND(readlink, frame, -1, ENOMEM, NULL, NULL, NULL); + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readv, fd, - size, offset, flags, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readlink, + loc, size, xdata); + return 0; } - int32_t -quota_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *prebuf, - struct iatt *postbuf, dict_t *xdata) +quota_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iovec *vector, + int32_t count, struct iatt *buf, struct iobref *iobref, + dict_t *xdata) { - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; - if (op_ret < 0) { - goto out; - } + if (op_ret < 0) { + goto out; + } - local = frame->local; + local = frame->local; - GF_VALIDATE_OR_GOTO ("quota", local, out); + GF_VALIDATE_OR_GOTO("quota", local, out); - quota_inode_ctx_get (local->loc.inode, this, &ctx, 0); - if (ctx == NULL) { - gf_msg_debug (this->name, 0, "quota context is NULL on inode" - " (%s). If quota is not enabled recently and " - "crawler has finished crawling, its an error", - uuid_utoa (local->loc.inode->gfid)); - goto out; - } + quota_inode_ctx_get(local->loc.inode, this, &ctx, 0); + if (ctx == NULL) { + gf_msg_debug(this->name, 0, + "quota context is NULL on inode" + " (%s). If quota is not enabled recently and " + "crawler has finished crawling, its an error", + uuid_utoa(local->loc.inode->gfid)); + goto out; + } - LOCK (&ctx->lock); - { - ctx->buf = *postbuf; - } - UNLOCK (&ctx->lock); + LOCK(&ctx->lock); + { + ctx->buf = *buf; + } + UNLOCK(&ctx->lock); out: - QUOTA_STACK_UNWIND (fsync, frame, op_ret, op_errno, prebuf, postbuf, - xdata); - return 0; + QUOTA_STACK_UNWIND(readv, frame, op_ret, op_errno, vector, count, buf, + iobref, xdata); + return 0; } - int32_t -quota_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, - dict_t *xdata) +quota_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, uint32_t flags, dict_t *xdata) { - quota_priv_t *priv = NULL; - quota_local_t *local = NULL; + quota_priv_t *priv = NULL; + quota_local_t *local = NULL; - priv = this->private; + priv = this->private; - WIND_IF_QUOTAOFF (priv->is_quota_on, off); + WIND_IF_QUOTAOFF(priv->is_quota_on, off); - local = quota_local_new (); - if (local == NULL) { - goto unwind; - } + local = quota_local_new(); + if (local == NULL) { + goto unwind; + } - local->loc.inode = inode_ref (fd->inode); + frame->local = local; - frame->local = local; + local->loc.inode = inode_ref(fd->inode); - STACK_WIND (frame, quota_fsync_cbk, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsync, fd, - flags, xdata); - return 0; + STACK_WIND(frame, quota_readv_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readv, fd, size, offset, flags, xdata); + return 0; unwind: - QUOTA_STACK_UNWIND (fsync, frame, -1, ENOMEM, NULL, NULL, NULL); - return 0; + QUOTA_STACK_UNWIND(readv, frame, -1, ENOMEM, NULL, -1, NULL, NULL, NULL); + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsync, fd, - flags, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readv, + fd, size, offset, flags, xdata); + return 0; } - int32_t -quota_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *statpre, - struct iatt *statpost, dict_t *xdata) +quota_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *prebuf, + struct iatt *postbuf, dict_t *xdata) { - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; - - if (op_ret < 0) { - goto out; - } + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; - local = frame->local; + if (op_ret < 0) { + goto out; + } - GF_VALIDATE_OR_GOTO ("quota", local, out); + local = frame->local; - quota_inode_ctx_get (local->loc.inode, this, &ctx, 0); - if (ctx == NULL) { - if (!IA_ISDIR (statpost->ia_type)) { - gf_msg_debug (this->name, 0, "quota context is NULL on inode" - " (%s). If quota is not enabled recently and " - "crawler has finished crawling, its an error", - uuid_utoa (local->loc.inode->gfid)); - } + GF_VALIDATE_OR_GOTO("quota", local, out); - goto out; - } + quota_inode_ctx_get(local->loc.inode, this, &ctx, 0); + if (ctx == NULL) { + gf_msg_debug(this->name, 0, + "quota context is NULL on inode" + " (%s). If quota is not enabled recently and " + "crawler has finished crawling, its an error", + uuid_utoa(local->loc.inode->gfid)); + goto out; + } - LOCK (&ctx->lock); - { - if (statpost) - ctx->buf = *statpost; - } - UNLOCK (&ctx->lock); + LOCK(&ctx->lock); + { + ctx->buf = *postbuf; + } + UNLOCK(&ctx->lock); out: - QUOTA_STACK_UNWIND (setattr, frame, op_ret, op_errno, statpre, - statpost, xdata); - return 0; + QUOTA_STACK_UNWIND(fsync, frame, op_ret, op_errno, prebuf, postbuf, xdata); + return 0; } - int32_t -quota_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - struct iatt *stbuf, int32_t valid, dict_t *xdata) +quota_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, + dict_t *xdata) { - quota_priv_t *priv = NULL; - quota_local_t *local = NULL; - int32_t ret = -1; + quota_priv_t *priv = NULL; + quota_local_t *local = NULL; - priv = this->private; + priv = this->private; - WIND_IF_QUOTAOFF (priv->is_quota_on, off); + WIND_IF_QUOTAOFF(priv->is_quota_on, off); - local = quota_local_new (); - if (local == NULL) { - goto unwind; - } + local = quota_local_new(); + if (local == NULL) { + goto unwind; + } - frame->local = local; + local->loc.inode = inode_ref(fd->inode); - ret = loc_copy (&local->loc, loc); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "loc_copy failed"); - goto unwind; - } + frame->local = local; - STACK_WIND (frame, quota_setattr_cbk, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->setattr, loc, - stbuf, valid, xdata); - return 0; + STACK_WIND(frame, quota_fsync_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsync, fd, flags, xdata); + return 0; unwind: - QUOTA_STACK_UNWIND (setattr, frame, -1, ENOMEM, NULL, NULL, NULL); - return 0; + QUOTA_STACK_UNWIND(fsync, frame, -1, ENOMEM, NULL, NULL, NULL); + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->setattr, loc, - stbuf, valid, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsync, + fd, flags, xdata); + return 0; } - int32_t -quota_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct iatt *statpre, - struct iatt *statpost, dict_t *xdata) +quota_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *statpre, + struct iatt *statpost, dict_t *xdata) { - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; - - if (op_ret < 0) { - goto out; - } + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; - local = frame->local; + if (op_ret < 0) { + goto out; + } - GF_VALIDATE_OR_GOTO ("quota", local, out); + local = frame->local; - quota_inode_ctx_get (local->loc.inode, this, &ctx, 0); - if (ctx == NULL) { - if (!IA_ISDIR (statpost->ia_type)) { - gf_msg_debug (this->name, 0, "quota context is NULL on inode" - " (%s). If quota is not enabled recently and " - "crawler has finished crawling, its an error", - uuid_utoa (local->loc.inode->gfid)); - } + GF_VALIDATE_OR_GOTO("quota", local, out); - goto out; + quota_inode_ctx_get(local->loc.inode, this, &ctx, 0); + if (ctx == NULL) { + if (!IA_ISDIR(statpost->ia_type)) { + gf_msg_debug(this->name, 0, + "quota context is NULL on inode" + " (%s). If quota is not enabled recently and " + "crawler has finished crawling, its an error", + uuid_utoa(local->loc.inode->gfid)); } - LOCK (&ctx->lock); - { - ctx->buf = *statpost; - } - UNLOCK (&ctx->lock); + goto out; + } + + LOCK(&ctx->lock); + { + if (statpost) + ctx->buf = *statpost; + } + UNLOCK(&ctx->lock); out: - QUOTA_STACK_UNWIND (fsetattr, frame, op_ret, op_errno, statpre, - statpost, xdata); - return 0; + QUOTA_STACK_UNWIND(setattr, frame, op_ret, op_errno, statpre, statpost, + xdata); + return 0; } - int32_t -quota_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - struct iatt *stbuf, int32_t valid, dict_t *xdata) +quota_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + struct iatt *stbuf, int32_t valid, dict_t *xdata) { - quota_priv_t *priv = NULL; - quota_local_t *local = NULL; + quota_priv_t *priv = NULL; + quota_local_t *local = NULL; + int32_t ret = -1; - priv = this->private; + priv = this->private; - WIND_IF_QUOTAOFF (priv->is_quota_on, off); + WIND_IF_QUOTAOFF(priv->is_quota_on, off); - local = quota_local_new (); - if (local == NULL) { - goto unwind; - } + local = quota_local_new(); + if (local == NULL) { + goto unwind; + } - frame->local = local; + frame->local = local; - local->loc.inode = inode_ref (fd->inode); + ret = loc_copy(&local->loc, loc); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "loc_copy failed"); + goto unwind; + } - STACK_WIND (frame, quota_fsetattr_cbk, - FIRST_CHILD (this), FIRST_CHILD (this)->fops->fsetattr, fd, - stbuf, valid, xdata); - return 0; + STACK_WIND(frame, quota_setattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid, xdata); + return 0; unwind: - QUOTA_STACK_UNWIND (fsetattr, frame, -1, ENOMEM, NULL, NULL, NULL); - return 0; + QUOTA_STACK_UNWIND(setattr, frame, -1, ENOMEM, NULL, NULL, NULL); + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD (this), - FIRST_CHILD (this)->fops->fsetattr, fd, - stbuf, valid, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setattr, + loc, stbuf, valid, xdata); + return 0; } - int32_t -quota_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, struct iatt *preparent, - struct iatt *postparent, dict_t *xdata) +quota_fsetattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *statpre, + struct iatt *statpost, dict_t *xdata) { - int32_t ret = -1; - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; - quota_dentry_t *dentry = NULL; - - local = frame->local; - if (op_ret < 0) { - goto unwind; - } - - ret = quota_inode_ctx_get (inode, this, &ctx, 1); - if ((ret == -1) || (ctx == NULL)) { - gf_msg (this->name, GF_LOG_WARNING, 0, - Q_MSG_INODE_CTX_GET_FAILED, - "cannot create quota context in " - "inode(gfid:%s)", uuid_utoa (inode->gfid)); - op_ret = -1; - op_errno = ENOMEM; - goto unwind; - } - - LOCK (&ctx->lock); - { - ctx->buf = *buf; - - dentry = __quota_dentry_new (ctx, (char *)local->loc.name, - local->loc.parent->gfid); - if (dentry == NULL) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "cannot create a new dentry " - "(name:%s) for inode(gfid:%s)", local->loc.name, - uuid_utoa (local->loc.inode->gfid)); - op_ret = -1; - op_errno = ENOMEM; - goto unlock; - } - } -unlock: - UNLOCK (&ctx->lock); - -unwind: - QUOTA_STACK_UNWIND (mknod, frame, op_ret, op_errno, inode, - buf, preparent, postparent, xdata); - return 0; -} - + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; -int -quota_mknod_helper (call_frame_t *frame, xlator_t *this, loc_t *loc, - mode_t mode, dev_t rdev, mode_t umask, dict_t *xdata) -{ - quota_local_t *local = NULL; - int32_t op_errno = EINVAL; + if (op_ret < 0) { + goto out; + } - local = frame->local; + local = frame->local; - GF_VALIDATE_OR_GOTO ("quota", local, unwind); + GF_VALIDATE_OR_GOTO("quota", local, out); - if (local->op_ret == -1) { - op_errno = local->op_errno; - goto unwind; + quota_inode_ctx_get(local->loc.inode, this, &ctx, 0); + if (ctx == NULL) { + if (!IA_ISDIR(statpost->ia_type)) { + gf_msg_debug(this->name, 0, + "quota context is NULL on inode" + " (%s). If quota is not enabled recently and " + "crawler has finished crawling, its an error", + uuid_utoa(local->loc.inode->gfid)); } - STACK_WIND (frame, quota_mknod_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod, loc, - mode, rdev, umask, xdata); + goto out; + } - return 0; + LOCK(&ctx->lock); + { + ctx->buf = *statpost; + } + UNLOCK(&ctx->lock); -unwind: - QUOTA_STACK_UNWIND (mknod, frame, -1, op_errno, NULL, NULL, - NULL, NULL, NULL); - return 0; +out: + QUOTA_STACK_UNWIND(fsetattr, frame, op_ret, op_errno, statpre, statpost, + xdata); + return 0; } - -int -quota_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, - dev_t rdev, mode_t umask, dict_t *xdata) +int32_t +quota_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd, + struct iatt *stbuf, int32_t valid, dict_t *xdata) { - quota_priv_t *priv = NULL; - int32_t ret = -1; - quota_local_t *local = NULL; - call_stub_t *stub = NULL; + quota_priv_t *priv = NULL; + quota_local_t *local = NULL; - priv = this->private; + priv = this->private; - WIND_IF_QUOTAOFF (priv->is_quota_on, off); - QUOTA_WIND_FOR_INTERNAL_FOP (xdata, off); + WIND_IF_QUOTAOFF(priv->is_quota_on, off); - local = quota_local_new (); - if (local == NULL) { - goto err; - } + local = quota_local_new(); + if (local == NULL) { + goto unwind; + } - frame->local = local; + frame->local = local; - ret = loc_copy (&local->loc, loc); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "loc_copy failed"); - goto err; - } + local->loc.inode = inode_ref(fd->inode); - stub = fop_mknod_stub (frame, quota_mknod_helper, loc, mode, rdev, - umask, xdata); - if (stub == NULL) { - goto err; - } + STACK_WIND(frame, quota_fsetattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsetattr, fd, stbuf, valid, xdata); + return 0; - LOCK (&local->lock); - { - local->link_count = 1; - local->stub = stub; - local->delta = 0; - local->object_delta = 1; - } - UNLOCK (&local->lock); +unwind: + QUOTA_STACK_UNWIND(fsetattr, frame, -1, ENOMEM, NULL, NULL, NULL); + return 0; - quota_check_limit (frame, loc->parent, this); - return 0; +off: + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetattr, + fd, stbuf, valid, xdata); + return 0; +} -err: - QUOTA_STACK_UNWIND (mknod, frame, -1, ENOMEM, NULL, NULL, NULL, NULL, - NULL); - return 0; +int32_t +quota_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, struct iatt *preparent, + struct iatt *postparent, dict_t *xdata) +{ + int32_t ret = -1; + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; + quota_dentry_t *dentry = NULL; + + local = frame->local; + if (op_ret < 0) { + goto unwind; + } + + ret = quota_inode_ctx_get(inode, this, &ctx, 1); + if ((ret == -1) || (ctx == NULL)) { + gf_msg(this->name, GF_LOG_WARNING, 0, Q_MSG_INODE_CTX_GET_FAILED, + "cannot create quota context in " + "inode(gfid:%s)", + uuid_utoa(inode->gfid)); + op_ret = -1; + op_errno = ENOMEM; + goto unwind; + } + + LOCK(&ctx->lock); + { + ctx->buf = *buf; + + dentry = __quota_dentry_new(ctx, (char *)local->loc.name, + local->loc.parent->gfid); + if (dentry == NULL) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "cannot create a new dentry " + "(name:%s) for inode(gfid:%s)", + local->loc.name, uuid_utoa(local->loc.inode->gfid)); + op_ret = -1; + op_errno = ENOMEM; + goto unlock; + } + } +unlock: + UNLOCK(&ctx->lock); -off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->mknod, loc, - mode, rdev, umask, xdata); - return 0; +unwind: + QUOTA_STACK_UNWIND(mknod, frame, op_ret, op_errno, inode, buf, preparent, + postparent, xdata); + return 0; } int -quota_setxattr_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int op_ret, int op_errno, dict_t *xdata) +quota_mknod_helper(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + dev_t rdev, mode_t umask, dict_t *xdata) { - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; - int ret = 0; + quota_local_t *local = NULL; + int32_t op_errno = EINVAL; - if (op_ret < 0) { - goto out; - } + local = frame->local; - local = frame->local; - if (!local) - goto out; + GF_VALIDATE_OR_GOTO("quota", local, unwind); - ret = quota_inode_ctx_get (local->loc.inode, this, &ctx, 1); - if ((ret < 0) || (ctx == NULL)) { - op_errno = -1; - goto out; - } + if (local->op_ret == -1) { + op_errno = local->op_errno; + goto unwind; + } - LOCK (&ctx->lock); - { - ctx->hard_lim = local->limit.hl; - ctx->soft_lim = local->limit.sl; - ctx->object_hard_lim = local->object_limit.hl; - ctx->object_soft_lim = local->object_limit.sl; - } - UNLOCK (&ctx->lock); + STACK_WIND(frame, quota_mknod_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->mknod, loc, mode, rdev, umask, xdata); -out: - QUOTA_STACK_UNWIND (setxattr, frame, op_ret, op_errno, xdata); - return 0; + return 0; + +unwind: + QUOTA_STACK_UNWIND(mknod, frame, -1, op_errno, NULL, NULL, NULL, NULL, + NULL); + return 0; } int -quota_setxattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, dict_t *dict, int flags, dict_t *xdata) +quota_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, + dev_t rdev, mode_t umask, dict_t *xdata) { - quota_priv_t *priv = NULL; - int op_errno = EINVAL; - int op_ret = -1; - int64_t hard_lim = -1; - int64_t soft_lim = -1; - int64_t object_hard_limit = -1; - int64_t object_soft_limit = -1; - quota_local_t *local = NULL; - gf_boolean_t internal_fop = _gf_false; - - priv = this->private; - - WIND_IF_QUOTAOFF (priv->is_quota_on, off); - - VALIDATE_OR_GOTO (frame, err); - VALIDATE_OR_GOTO (this, err); - VALIDATE_OR_GOTO (loc, err); - - if (xdata && dict_get (xdata, GLUSTERFS_INTERNAL_FOP_KEY)) - internal_fop = _gf_true; - - if (frame->root->pid >= 0 && internal_fop == _gf_false) { - GF_IF_INTERNAL_XATTR_GOTO ("trusted.glusterfs.quota*", dict, - op_errno, err); - GF_IF_INTERNAL_XATTR_GOTO ("trusted.pgfid*", dict, op_errno, - err); - } - - quota_get_limits (this, dict, &hard_lim, &soft_lim, &object_hard_limit, - &object_soft_limit); - - if (hard_lim > 0 || object_hard_limit > 0) { - local = quota_local_new (); - if (local == NULL) { - op_errno = ENOMEM; - goto err; - } - frame->local = local; - loc_copy (&local->loc, loc); - } - - if (hard_lim > 0) { - local->limit.hl = hard_lim; - local->limit.sl = soft_lim; - } + quota_priv_t *priv = NULL; + int32_t ret = -1; + quota_local_t *local = NULL; + call_stub_t *stub = NULL; + + priv = this->private; + + WIND_IF_QUOTAOFF(priv->is_quota_on, off); + QUOTA_WIND_FOR_INTERNAL_FOP(xdata, off); + + local = quota_local_new(); + if (local == NULL) { + goto err; + } + + frame->local = local; + + ret = loc_copy(&local->loc, loc); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "loc_copy failed"); + goto err; + } + + stub = fop_mknod_stub(frame, quota_mknod_helper, loc, mode, rdev, umask, + xdata); + if (stub == NULL) { + goto err; + } + + LOCK(&local->lock); + { + local->link_count = 1; + local->stub = stub; + local->delta = 0; + local->object_delta = 1; + } + UNLOCK(&local->lock); - if (object_hard_limit > 0) { - local->object_limit.hl = object_hard_limit; - local->object_limit.sl = object_soft_limit; - } + quota_check_limit(frame, loc->parent, this); + return 0; - STACK_WIND (frame, quota_setxattr_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->setxattr, loc, - dict, flags, xdata); - return 0; err: - QUOTA_STACK_UNWIND (setxattr, frame, op_ret, op_errno, NULL); - return 0; + QUOTA_STACK_UNWIND(mknod, frame, -1, ENOMEM, NULL, NULL, NULL, NULL, NULL); + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->setxattr, loc, - dict, flags, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod, + loc, mode, rdev, umask, xdata); + return 0; } int -quota_fsetxattr_cbk (call_frame_t *frame, void *cookie, - xlator_t *this, int op_ret, int op_errno, dict_t *xdata) +quota_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, dict_t *xdata) { - quota_inode_ctx_t *ctx = NULL; - quota_local_t *local = NULL; - - if (op_ret < 0) - goto out; - - local = frame->local; - if (!local) - goto out; - - op_ret = quota_inode_ctx_get (local->loc.inode, this, &ctx, 1); - if ((op_ret < 0) || (ctx == NULL)) { - op_errno = ENOMEM; - goto out; - } - - LOCK (&ctx->lock); - { - ctx->hard_lim = local->limit.hl; - ctx->soft_lim = local->limit.sl; - ctx->object_hard_lim = local->object_limit.hl; - ctx->object_soft_lim = local->object_limit.sl; - } - UNLOCK (&ctx->lock); + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; + int ret = 0; + + if (op_ret < 0) { + goto out; + } + + local = frame->local; + if (!local) + goto out; + + ret = quota_inode_ctx_get(local->loc.inode, this, &ctx, 1); + if ((ret < 0) || (ctx == NULL)) { + op_errno = -1; + goto out; + } + + LOCK(&ctx->lock); + { + ctx->hard_lim = local->limit.hl; + ctx->soft_lim = local->limit.sl; + ctx->object_hard_lim = local->object_limit.hl; + ctx->object_soft_lim = local->object_limit.sl; + } + UNLOCK(&ctx->lock); out: - QUOTA_STACK_UNWIND (fsetxattr, frame, op_ret, op_errno, xdata); - return 0; + QUOTA_STACK_UNWIND(setxattr, frame, op_ret, op_errno, xdata); + return 0; } int -quota_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, - dict_t *dict, int flags, dict_t *xdata) +quota_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, + int flags, dict_t *xdata) { - quota_priv_t *priv = NULL; - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - quota_local_t *local = NULL; - int64_t hard_lim = -1; - int64_t soft_lim = -1; - int64_t object_hard_limit = -1; - int64_t object_soft_limit = -1; - - priv = this->private; - - WIND_IF_QUOTAOFF (priv->is_quota_on, off); - - VALIDATE_OR_GOTO (frame, err); - VALIDATE_OR_GOTO (this, err); - VALIDATE_OR_GOTO (fd, err); - - if (0 <= frame->root->pid) { - GF_IF_INTERNAL_XATTR_GOTO ("trusted.glusterfs.quota*", - dict, op_errno, err); - GF_IF_INTERNAL_XATTR_GOTO ("trusted.pgfid*", dict, - op_errno, err); + quota_priv_t *priv = NULL; + int op_errno = EINVAL; + int op_ret = -1; + int64_t hard_lim = -1; + int64_t soft_lim = -1; + int64_t object_hard_limit = -1; + int64_t object_soft_limit = -1; + quota_local_t *local = NULL; + gf_boolean_t internal_fop = _gf_false; + + priv = this->private; + + WIND_IF_QUOTAOFF(priv->is_quota_on, off); + + VALIDATE_OR_GOTO(frame, err); + VALIDATE_OR_GOTO(this, err); + VALIDATE_OR_GOTO(loc, err); + + if (xdata && dict_get(xdata, GLUSTERFS_INTERNAL_FOP_KEY)) + internal_fop = _gf_true; + + if (frame->root->pid >= 0 && internal_fop == _gf_false) { + GF_IF_INTERNAL_XATTR_GOTO("trusted.glusterfs.quota*", dict, op_errno, + err); + GF_IF_INTERNAL_XATTR_GOTO("trusted.pgfid*", dict, op_errno, err); + } + + quota_get_limits(this, dict, &hard_lim, &soft_lim, &object_hard_limit, + &object_soft_limit); + + if (hard_lim > 0 || object_hard_limit > 0) { + local = quota_local_new(); + if (local == NULL) { + op_errno = ENOMEM; + goto err; } + frame->local = local; + loc_copy(&local->loc, loc); + } + + if (hard_lim > 0) { + local->limit.hl = hard_lim; + local->limit.sl = soft_lim; + } + + if (object_hard_limit > 0) { + local->object_limit.hl = object_hard_limit; + local->object_limit.sl = object_soft_limit; + } + + STACK_WIND(frame, quota_setxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setxattr, loc, dict, flags, xdata); + return 0; +err: + QUOTA_STACK_UNWIND(setxattr, frame, op_ret, op_errno, NULL); + return 0; - quota_get_limits (this, dict, &hard_lim, &soft_lim, &object_hard_limit, - &object_soft_limit); +off: + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setxattr, + loc, dict, flags, xdata); + return 0; +} - if (hard_lim > 0 || object_hard_limit > 0) { - local = quota_local_new (); - if (local == NULL) { - op_errno = ENOMEM; - goto err; - } - frame->local = local; - local->loc.inode = inode_ref (fd->inode); - } +int +quota_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, dict_t *xdata) +{ + quota_inode_ctx_t *ctx = NULL; + quota_local_t *local = NULL; + + if (op_ret < 0) + goto out; + + local = frame->local; + if (!local) + goto out; + + op_ret = quota_inode_ctx_get(local->loc.inode, this, &ctx, 1); + if ((op_ret < 0) || (ctx == NULL)) { + op_errno = ENOMEM; + goto out; + } + + LOCK(&ctx->lock); + { + ctx->hard_lim = local->limit.hl; + ctx->soft_lim = local->limit.sl; + ctx->object_hard_lim = local->object_limit.hl; + ctx->object_soft_lim = local->object_limit.sl; + } + UNLOCK(&ctx->lock); - if (hard_lim > 0) { - local->limit.hl = hard_lim; - local->limit.sl = soft_lim; - } +out: + QUOTA_STACK_UNWIND(fsetxattr, frame, op_ret, op_errno, xdata); + return 0; +} - if (object_hard_limit > 0) { - local->object_limit.hl = object_hard_limit; - local->object_limit.sl = object_soft_limit; +int +quota_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict, + int flags, dict_t *xdata) +{ + quota_priv_t *priv = NULL; + int32_t op_ret = -1; + int32_t op_errno = EINVAL; + quota_local_t *local = NULL; + int64_t hard_lim = -1; + int64_t soft_lim = -1; + int64_t object_hard_limit = -1; + int64_t object_soft_limit = -1; + + priv = this->private; + + WIND_IF_QUOTAOFF(priv->is_quota_on, off); + + VALIDATE_OR_GOTO(frame, err); + VALIDATE_OR_GOTO(this, err); + VALIDATE_OR_GOTO(fd, err); + + if (0 <= frame->root->pid) { + GF_IF_INTERNAL_XATTR_GOTO("trusted.glusterfs.quota*", dict, op_errno, + err); + GF_IF_INTERNAL_XATTR_GOTO("trusted.pgfid*", dict, op_errno, err); + } + + quota_get_limits(this, dict, &hard_lim, &soft_lim, &object_hard_limit, + &object_soft_limit); + + if (hard_lim > 0 || object_hard_limit > 0) { + local = quota_local_new(); + if (local == NULL) { + op_errno = ENOMEM; + goto err; } - - STACK_WIND (frame, quota_fsetxattr_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetxattr, fd, - dict, flags, xdata); - return 0; + frame->local = local; + local->loc.inode = inode_ref(fd->inode); + } + + if (hard_lim > 0) { + local->limit.hl = hard_lim; + local->limit.sl = soft_lim; + } + + if (object_hard_limit > 0) { + local->object_limit.hl = object_hard_limit; + local->object_limit.sl = object_soft_limit; + } + + STACK_WIND(frame, quota_fsetxattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata); + return 0; err: - QUOTA_STACK_UNWIND (fsetxattr, frame, op_ret, op_errno, NULL); - return 0; + QUOTA_STACK_UNWIND(fsetxattr, frame, op_ret, op_errno, NULL); + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fsetxattr, fd, - dict, flags, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata); + return 0; } - int -quota_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +quota_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - QUOTA_STACK_UNWIND (removexattr, frame, op_ret, op_errno, xdata); - return 0; + QUOTA_STACK_UNWIND(removexattr, frame, op_ret, op_errno, xdata); + return 0; } int -quota_removexattr (call_frame_t *frame, xlator_t *this, - loc_t *loc, const char *name, dict_t *xdata) +quota_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) { - quota_priv_t *priv = NULL; - int32_t op_errno = EINVAL; + quota_priv_t *priv = NULL; + int32_t op_errno = EINVAL; - priv = this->private; + priv = this->private; - WIND_IF_QUOTAOFF (priv->is_quota_on, off); + WIND_IF_QUOTAOFF(priv->is_quota_on, off); - VALIDATE_OR_GOTO (this, err); + VALIDATE_OR_GOTO(this, err); - /* all quota xattrs can be cleaned up by doing setxattr on special key. - * Hence its ok that we don't allow removexattr on quota keys here. - */ - if (frame->root->pid >= 0) { - GF_IF_NATIVE_XATTR_GOTO ("trusted.glusterfs.quota*", - name, op_errno, err); - GF_IF_NATIVE_XATTR_GOTO ("trusted.pgfid*", name, - op_errno, err); - } + /* all quota xattrs can be cleaned up by doing setxattr on special key. + * Hence its ok that we don't allow removexattr on quota keys here. + */ + if (frame->root->pid >= 0) { + GF_IF_NATIVE_XATTR_GOTO("trusted.glusterfs.quota*", name, op_errno, + err); + GF_IF_NATIVE_XATTR_GOTO("trusted.pgfid*", name, op_errno, err); + } - VALIDATE_OR_GOTO (frame, err); - VALIDATE_OR_GOTO (loc, err); + VALIDATE_OR_GOTO(frame, err); + VALIDATE_OR_GOTO(loc, err); - STACK_WIND (frame, quota_removexattr_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->removexattr, - loc, name, xdata); - return 0; + STACK_WIND(frame, quota_removexattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->removexattr, loc, name, xdata); + return 0; err: - QUOTA_STACK_UNWIND (removexattr, frame, -1, op_errno, NULL); - return 0; + QUOTA_STACK_UNWIND(removexattr, frame, -1, op_errno, NULL); + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->removexattr, - loc, name, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->removexattr, loc, name, xdata); + return 0; } - int -quota_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, dict_t *xdata) +quota_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, dict_t *xdata) { - QUOTA_STACK_UNWIND (fremovexattr, frame, op_ret, op_errno, xdata); - return 0; + QUOTA_STACK_UNWIND(fremovexattr, frame, op_ret, op_errno, xdata); + return 0; } int -quota_fremovexattr (call_frame_t *frame, xlator_t *this, - fd_t *fd, const char *name, dict_t *xdata) +quota_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd, + const char *name, dict_t *xdata) { - quota_priv_t *priv = NULL; - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - - priv = this->private; - - WIND_IF_QUOTAOFF (priv->is_quota_on, off); - - VALIDATE_OR_GOTO (frame, err); - VALIDATE_OR_GOTO (this, err); - VALIDATE_OR_GOTO (fd, err); - - if (frame->root->pid >= 0) { - GF_IF_NATIVE_XATTR_GOTO ("trusted.glusterfs.quota*", - name, op_errno, err); - GF_IF_NATIVE_XATTR_GOTO ("trusted.pgfid*", name, - op_errno, err); - } - STACK_WIND (frame, quota_fremovexattr_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->fremovexattr, - fd, name, xdata); - return 0; + quota_priv_t *priv = NULL; + int32_t op_ret = -1; + int32_t op_errno = EINVAL; + + priv = this->private; + + WIND_IF_QUOTAOFF(priv->is_quota_on, off); + + VALIDATE_OR_GOTO(frame, err); + VALIDATE_OR_GOTO(this, err); + VALIDATE_OR_GOTO(fd, err); + + if (frame->root->pid >= 0) { + GF_IF_NATIVE_XATTR_GOTO("trusted.glusterfs.quota*", name, op_errno, + err); + GF_IF_NATIVE_XATTR_GOTO("trusted.pgfid*", name, op_errno, err); + } + STACK_WIND(frame, quota_fremovexattr_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata); + return 0; err: - QUOTA_STACK_UNWIND (fremovexattr, frame, op_ret, op_errno, NULL); - return 0; + QUOTA_STACK_UNWIND(fremovexattr, frame, op_ret, op_errno, NULL); + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fremovexattr, - fd, name, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata); + return 0; } - int32_t -quota_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, struct statvfs *buf, - dict_t *xdata) +quota_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct statvfs *buf, + dict_t *xdata) { - inode_t *inode = NULL; - uint64_t value = 0; - int64_t usage = -1; - int64_t avail = -1; - int64_t blocks = 0; - quota_inode_ctx_t *ctx = NULL; - int ret = 0; - - inode = cookie; - - /* This fop will fail mostly in case of client disconnect, - * which is already logged. Hence, not logging here */ - if (op_ret == -1) - goto unwind; - /* - * We should never get here unless quota_statfs (below) sent us a - * cookie, and it would only do so if the value was non-NULL. This - * check is therefore just routine defensive coding. - */ - - GF_VALIDATE_OR_GOTO ("quota", inode, unwind); - - inode_ctx_get (inode, this, &value); - ctx = (quota_inode_ctx_t *)(unsigned long)value; - if (!ctx || ctx->hard_lim <= 0) - goto unwind; - - { /* statfs is adjusted in this code block */ - usage = (ctx->size) / buf->f_bsize; - - blocks = ctx->hard_lim / buf->f_bsize; - buf->f_blocks = blocks; - - avail = buf->f_blocks - usage; - avail = max (avail, 0); - - buf->f_bfree = avail; - /* - * We have to assume that the total assigned quota - * won't cause us to dip into the reserved space, - * because dealing with the overcommitted cases is - * just too hairy (especially when different bricks - * might be using different reserved percentages and - * such). - */ - buf->f_bavail = buf->f_bfree; - } + inode_t *inode = NULL; + uint64_t value = 0; + int64_t usage = -1; + int64_t avail = -1; + int64_t blocks = 0; + quota_inode_ctx_t *ctx = NULL; + int ret = 0; + + inode = cookie; + + /* This fop will fail mostly in case of client disconnect, + * which is already logged. Hence, not logging here */ + if (op_ret == -1) + goto unwind; + /* + * We should never get here unless quota_statfs (below) sent us a + * cookie, and it would only do so if the value was non-NULL. This + * check is therefore just routine defensive coding. + */ + + GF_VALIDATE_OR_GOTO("quota", inode, unwind); + + inode_ctx_get(inode, this, &value); + ctx = (quota_inode_ctx_t *)(unsigned long)value; + if (!ctx || ctx->hard_lim <= 0) + goto unwind; + + { /* statfs is adjusted in this code block */ + usage = (ctx->size) / buf->f_bsize; + + blocks = ctx->hard_lim / buf->f_bsize; + buf->f_blocks = blocks; + + avail = buf->f_blocks - usage; + avail = max(avail, 0); + + buf->f_bfree = avail; + /* + * We have to assume that the total assigned quota + * won't cause us to dip into the reserved space, + * because dealing with the overcommitted cases is + * just too hairy (especially when different bricks + * might be using different reserved percentages and + * such). + */ + buf->f_bavail = buf->f_bfree; + } - xdata = xdata ? dict_ref(xdata) : dict_new(); - if (!xdata) - goto unwind; + xdata = xdata ? dict_ref(xdata) : dict_new(); + if (!xdata) + goto unwind; - ret = dict_set_int8 (xdata, "quota-deem-statfs", 1); - if (-1 == ret) - gf_msg (this->name, GF_LOG_ERROR, ENOMEM, - Q_MSG_ENOMEM, "Dict set failed, deem-statfs option may " - "have no effect"); + ret = dict_set_int8(xdata, "quota-deem-statfs", 1); + if (-1 == ret) + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, Q_MSG_ENOMEM, + "Dict set failed, deem-statfs option may " + "have no effect"); unwind: - QUOTA_STACK_UNWIND (statfs, frame, op_ret, op_errno, buf, xdata); + QUOTA_STACK_UNWIND(statfs, frame, op_ret, op_errno, buf, xdata); - if (xdata) - dict_unref (xdata); + if (xdata) + dict_unref(xdata); - return 0; + return 0; } - int32_t -quota_statfs_helper (call_frame_t *frame, xlator_t *this, loc_t *loc, - dict_t *xdata) +quota_statfs_helper(call_frame_t *frame, xlator_t *this, loc_t *loc, + dict_t *xdata) { - quota_local_t *local = frame->local; - int op_errno = EINVAL; + quota_local_t *local = frame->local; + int op_errno = EINVAL; - GF_VALIDATE_OR_GOTO ("quota", local, err); + GF_VALIDATE_OR_GOTO("quota", local, err); - if (-1 == local->op_ret) { - op_errno = local->op_errno; - goto err; - } + if (-1 == local->op_ret) { + op_errno = local->op_errno; + goto err; + } - STACK_WIND_COOKIE (frame, quota_statfs_cbk, local->inode, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->statfs, loc, xdata); - return 0; + STACK_WIND_COOKIE(frame, quota_statfs_cbk, local->inode, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->statfs, loc, xdata); + return 0; err: - QUOTA_STACK_UNWIND (statfs, frame, -1, op_errno, NULL, NULL); + QUOTA_STACK_UNWIND(statfs, frame, -1, op_errno, NULL, NULL); - return 0; + return 0; } int32_t -quota_statfs_validate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *xdata, - struct iatt *postparent) +quota_statfs_validate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, inode_t *inode, + struct iatt *buf, dict_t *xdata, + struct iatt *postparent) { - quota_local_t *local = NULL; - int32_t ret = 0; - quota_inode_ctx_t *ctx = NULL; - uint64_t value = 0; - quota_meta_t size = {0,}; - - local = frame->local; - - if (op_ret < 0) - goto resume; - - GF_ASSERT (local); - GF_ASSERT (frame); - GF_VALIDATE_OR_GOTO_WITH_ERROR ("quota", this, resume, op_errno, - EINVAL); - GF_VALIDATE_OR_GOTO_WITH_ERROR (this->name, xdata, resume, op_errno, - EINVAL); - - ret = inode_ctx_get (local->validate_loc.inode, this, &value); - - ctx = (quota_inode_ctx_t *)(unsigned long)value; - if ((ret == -1) || (ctx == NULL)) { - gf_msg (this->name, GF_LOG_WARNING, EINVAL, - Q_MSG_INODE_CTX_GET_FAILED, - "quota context is not present in inode (gfid:%s)", - uuid_utoa (local->validate_loc.inode->gfid)); - op_errno = EINVAL; - goto resume; - } - - ret = quota_dict_get_meta (xdata, QUOTA_SIZE_KEY, &size); - if (ret == -1) { - gf_msg (this->name, GF_LOG_WARNING, EINVAL, - Q_MSG_SIZE_KEY_MISSING, "size key not present in " - "dict"); - op_errno = EINVAL; - } - - LOCK (&ctx->lock); - { - ctx->size = size.size; - ctx->file_count = size.file_count; - ctx->dir_count = size.dir_count; - gettimeofday (&ctx->tv, NULL); - } - UNLOCK (&ctx->lock); + quota_local_t *local = NULL; + int32_t ret = 0; + quota_inode_ctx_t *ctx = NULL; + uint64_t value = 0; + quota_meta_t size = { + 0, + }; + + local = frame->local; + + if (op_ret < 0) + goto resume; + + GF_ASSERT(local); + GF_ASSERT(frame); + GF_VALIDATE_OR_GOTO_WITH_ERROR("quota", this, resume, op_errno, EINVAL); + GF_VALIDATE_OR_GOTO_WITH_ERROR(this->name, xdata, resume, op_errno, EINVAL); + + ret = inode_ctx_get(local->validate_loc.inode, this, &value); + + ctx = (quota_inode_ctx_t *)(unsigned long)value; + if ((ret == -1) || (ctx == NULL)) { + gf_msg(this->name, GF_LOG_WARNING, EINVAL, Q_MSG_INODE_CTX_GET_FAILED, + "quota context is not present in inode (gfid:%s)", + uuid_utoa(local->validate_loc.inode->gfid)); + op_errno = EINVAL; + goto resume; + } + + ret = quota_dict_get_meta(xdata, QUOTA_SIZE_KEY, &size); + if (ret == -1) { + gf_msg(this->name, GF_LOG_WARNING, EINVAL, Q_MSG_SIZE_KEY_MISSING, + "size key not present in " + "dict"); + op_errno = EINVAL; + } + + LOCK(&ctx->lock); + { + ctx->size = size.size; + ctx->file_count = size.file_count; + ctx->dir_count = size.dir_count; + gettimeofday(&ctx->tv, NULL); + } + UNLOCK(&ctx->lock); resume: - quota_link_count_decrement (frame); - return 0; + quota_link_count_decrement(frame); + return 0; } void -quota_get_limit_dir_continuation (struct list_head *parents, inode_t *inode, - int32_t op_ret, int32_t op_errno, void *data) +quota_get_limit_dir_continuation(struct list_head *parents, inode_t *inode, + int32_t op_ret, int32_t op_errno, void *data) { - call_frame_t *frame = NULL; - xlator_t *this = NULL; - quota_dentry_t *entry = NULL; - inode_t *parent = NULL; - - frame = data; - this = THIS; - - if ((op_ret < 0) || list_empty (parents)) { - if (op_ret >= 0) { - gf_msg (this->name, GF_LOG_WARNING, EIO, - Q_MSG_ANCESTRY_BUILD_FAILED, - "Couldn't build ancestry for inode (gfid:%s). " - "Without knowing ancestors till root, quota " - "cannot be enforced. " - "Hence, failing fop with EIO", - uuid_utoa (inode->gfid)); - op_errno = EIO; - } + call_frame_t *frame = NULL; + xlator_t *this = NULL; + quota_dentry_t *entry = NULL; + inode_t *parent = NULL; - quota_handle_validate_error (frame, -1, op_errno); - goto out; + frame = data; + this = THIS; + + if ((op_ret < 0) || list_empty(parents)) { + if (op_ret >= 0) { + gf_msg(this->name, GF_LOG_WARNING, EIO, Q_MSG_ANCESTRY_BUILD_FAILED, + "Couldn't build ancestry for inode (gfid:%s). " + "Without knowing ancestors till root, quota " + "cannot be enforced. " + "Hence, failing fop with EIO", + uuid_utoa(inode->gfid)); + op_errno = EIO; } - entry = list_entry (parents, quota_dentry_t, next); - parent = inode_find (inode->table, entry->par); + quota_handle_validate_error(frame, -1, op_errno); + goto out; + } - quota_get_limit_dir (frame, parent, this); + entry = list_entry(parents, quota_dentry_t, next); + parent = inode_find(inode->table, entry->par); - inode_unref (parent); + quota_get_limit_dir(frame, parent, this); + + inode_unref(parent); out: - return; + return; } void -quota_statfs_continue (call_frame_t *frame, xlator_t *this, inode_t *inode) +quota_statfs_continue(call_frame_t *frame, xlator_t *this, inode_t *inode) { - quota_local_t *local = frame->local; - int ret = -1; - - LOCK (&local->lock); - { - local->inode = inode_ref (inode); - } - UNLOCK (&local->lock); - - ret = quota_validate (frame, local->inode, this, - quota_statfs_validate_cbk); - if (0 > ret) - quota_handle_validate_error (frame, -1, -ret); + quota_local_t *local = frame->local; + int ret = -1; + + LOCK(&local->lock); + { + local->inode = inode_ref(inode); + } + UNLOCK(&local->lock); + + ret = quota_validate(frame, local->inode, this, quota_statfs_validate_cbk); + if (0 > ret) + quota_handle_validate_error(frame, -1, -ret); } void -quota_get_limit_dir (call_frame_t *frame, inode_t *cur_inode, xlator_t *this) +quota_get_limit_dir(call_frame_t *frame, inode_t *cur_inode, xlator_t *this) { - inode_t *inode = NULL; - inode_t *parent = NULL; - uint64_t value = 0; - quota_inode_ctx_t *ctx = NULL; - quota_local_t *local = frame->local; + inode_t *inode = NULL; + inode_t *parent = NULL; + uint64_t value = 0; + quota_inode_ctx_t *ctx = NULL; + quota_local_t *local = frame->local; - if (!cur_inode) - goto out; + if (!cur_inode) + goto out; - inode = inode_ref (cur_inode); - while (inode) { - value = 0; - inode_ctx_get (inode, this, &value); - - if (value) { - ctx = (quota_inode_ctx_t *)(unsigned long)value; - if (ctx->hard_lim > 0) - break; - } + inode = inode_ref(cur_inode); + while (inode) { + value = 0; + inode_ctx_get(inode, this, &value); - if (__is_root_gfid (inode->gfid)) - goto off; + if (value) { + ctx = (quota_inode_ctx_t *)(unsigned long)value; + if (ctx->hard_lim > 0) + break; + } - parent = inode_parent (inode, 0, NULL); - if (!parent) { - (void) quota_build_ancestry (inode, - quota_get_limit_dir_continuation, - frame); - goto out; - } + if (__is_root_gfid(inode->gfid)) + goto off; - inode_unref (inode); - inode = parent; + parent = inode_parent(inode, 0, NULL); + if (!parent) { + (void)quota_build_ancestry(inode, quota_get_limit_dir_continuation, + frame); + goto out; } - quota_statfs_continue (frame, this, inode); - inode_unref (inode); - return; + inode_unref(inode); + inode = parent; + } + + quota_statfs_continue(frame, this, inode); + inode_unref(inode); + return; off: - gf_msg_debug (this->name, 0, - "No limit set on the inode or it's parents."); + gf_msg_debug(this->name, 0, "No limit set on the inode or it's parents."); - QUOTA_STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->statfs, - &local->loc, local->xdata); + QUOTA_STACK_WIND_TAIL(frame, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->statfs, &local->loc, + local->xdata); out: - inode_unref (inode); + inode_unref(inode); - return; + return; } int32_t -quota_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) +quota_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { - int op_errno = 0; - int ret = -1; - int8_t ignore_deem_statfs = 0; - quota_priv_t *priv = NULL; - quota_local_t *local = NULL; - call_stub_t *stub = NULL; + int op_errno = 0; + int ret = -1; + int8_t ignore_deem_statfs = 0; + quota_priv_t *priv = NULL; + quota_local_t *local = NULL; + call_stub_t *stub = NULL; - priv = this->private; - GF_ASSERT (loc); + priv = this->private; + GF_ASSERT(loc); - WIND_IF_QUOTAOFF (priv->is_quota_on, off); + WIND_IF_QUOTAOFF(priv->is_quota_on, off); - ret = dict_get_int8 (xdata, GF_INTERNAL_IGNORE_DEEM_STATFS, - &ignore_deem_statfs); - ret = 0; + ret = dict_get_int8(xdata, GF_INTERNAL_IGNORE_DEEM_STATFS, + &ignore_deem_statfs); + ret = 0; - if (ignore_deem_statfs) - goto off; + if (ignore_deem_statfs) + goto off; - if (priv->consider_statfs && loc->inode) { - local = quota_local_new (); - if (!local) { - op_errno = ENOMEM; - goto err; - } - frame->local = local; + if (priv->consider_statfs && loc->inode) { + local = quota_local_new(); + if (!local) { + op_errno = ENOMEM; + goto err; + } + frame->local = local; - ret = loc_copy (&local->loc, loc); - if (-1 == ret) { - op_errno = ENOMEM; - goto err; - } + ret = loc_copy(&local->loc, loc); + if (-1 == ret) { + op_errno = ENOMEM; + goto err; + } - if (xdata) - local->xdata = dict_ref (xdata); + if (xdata) + local->xdata = dict_ref(xdata); - stub = fop_statfs_stub (frame, quota_statfs_helper, - &local->loc, local->xdata); - if (!stub) { - op_errno = ENOMEM; - goto err; - } + stub = fop_statfs_stub(frame, quota_statfs_helper, &local->loc, + local->xdata); + if (!stub) { + op_errno = ENOMEM; + goto err; + } - LOCK (&local->lock); - { - local->link_count = 1; - local->stub = stub; - } - UNLOCK (&local->lock); + LOCK(&local->lock); + { + local->link_count = 1; + local->stub = stub; + } + UNLOCK(&local->lock); - quota_get_limit_dir (frame, loc->inode, this); + quota_get_limit_dir(frame, loc->inode, this); - return 0; - } + return 0; + } - /* - * We have to make sure that we never get to quota_statfs_cbk - * with a cookie that points to something other than an inode, - * which is exactly what would happen with STACK_UNWIND using - * that as a callback. Therefore, use default_statfs_cbk in - * this case instead. - * - * Also if the option deem-statfs is not set to "on" don't - * bother calculating quota limit on / in statfs_cbk. - */ - if (priv->consider_statfs) - gf_log (this->name, GF_LOG_ERROR, - "Missing inode, can't adjust for quota"); + /* + * We have to make sure that we never get to quota_statfs_cbk + * with a cookie that points to something other than an inode, + * which is exactly what would happen with STACK_UNWIND using + * that as a callback. Therefore, use default_statfs_cbk in + * this case instead. + * + * Also if the option deem-statfs is not set to "on" don't + * bother calculating quota limit on / in statfs_cbk. + */ + if (priv->consider_statfs) + gf_log(this->name, GF_LOG_ERROR, + "Missing inode, can't adjust for quota"); off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->statfs, loc, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->statfs, + loc, xdata); + return 0; err: - QUOTA_STACK_UNWIND (statfs, frame, -1, op_errno, NULL, NULL); + QUOTA_STACK_UNWIND(statfs, frame, -1, op_errno, NULL, NULL); - return 0; + return 0; } int -quota_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int op_ret, int op_errno, gf_dirent_t *entries, - dict_t *xdata) +quota_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this, + int op_ret, int op_errno, gf_dirent_t *entries, + dict_t *xdata) { - gf_dirent_t *entry = NULL; - quota_local_t *local = NULL; - loc_t loc = {0, }; + gf_dirent_t *entry = NULL; + quota_local_t *local = NULL; + loc_t loc = { + 0, + }; - if (op_ret <= 0) - goto unwind; + if (op_ret <= 0) + goto unwind; - local = frame->local; + local = frame->local; - list_for_each_entry (entry, &entries->list, list) { - if ((strcmp (entry->d_name, ".") == 0) || - (strcmp (entry->d_name, "..") == 0) || - entry->inode == NULL) - continue; + list_for_each_entry(entry, &entries->list, list) + { + if ((strcmp(entry->d_name, ".") == 0) || + (strcmp(entry->d_name, "..") == 0) || entry->inode == NULL) + continue; - gf_uuid_copy (loc.gfid, entry->d_stat.ia_gfid); - loc.inode = inode_ref (entry->inode); - loc.parent = inode_ref (local->loc.inode); - gf_uuid_copy (loc.pargfid, loc.parent->gfid); - loc.name = entry->d_name; + gf_uuid_copy(loc.gfid, entry->d_stat.ia_gfid); + loc.inode = inode_ref(entry->inode); + loc.parent = inode_ref(local->loc.inode); + gf_uuid_copy(loc.pargfid, loc.parent->gfid); + loc.name = entry->d_name; - quota_fill_inodectx (this, entry->inode, entry->dict, - &loc, &entry->d_stat, &op_errno); + quota_fill_inodectx(this, entry->inode, entry->dict, &loc, + &entry->d_stat, &op_errno); - loc_wipe (&loc); - } + loc_wipe(&loc); + } unwind: - QUOTA_STACK_UNWIND (readdirp, frame, op_ret, op_errno, entries, xdata); + QUOTA_STACK_UNWIND(readdirp, frame, op_ret, op_errno, entries, xdata); - return 0; + return 0; } int -quota_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, - off_t offset, dict_t *dict) +quota_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, + off_t offset, dict_t *dict) { - quota_priv_t *priv = NULL; - int ret = 0; - gf_boolean_t new_dict = _gf_false; - quota_local_t *local = NULL; + quota_priv_t *priv = NULL; + int ret = 0; + gf_boolean_t new_dict = _gf_false; + quota_local_t *local = NULL; - priv = this->private; + priv = this->private; - WIND_IF_QUOTAOFF (priv->is_quota_on, off); + WIND_IF_QUOTAOFF(priv->is_quota_on, off); - local = quota_local_new (); + local = quota_local_new(); - if (local == NULL) { - goto err; - } + if (local == NULL) { + goto err; + } - frame->local = local; + frame->local = local; - local->loc.inode = inode_ref (fd->inode); + local->loc.inode = inode_ref(fd->inode); - if (dict == NULL) { - dict = dict_new (); - new_dict = _gf_true; - } + if (dict == NULL) { + dict = dict_new(); + new_dict = _gf_true; + } - if (dict) { - ret = dict_set_int8 (dict, QUOTA_LIMIT_KEY, 1); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, - "dict set of key for hard-limit"); - goto err; - } + if (dict) { + ret = dict_set_int8(dict, QUOTA_LIMIT_KEY, 1); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "dict set of key for hard-limit"); + goto err; } + } - if (dict) { - ret = dict_set_int8 (dict, QUOTA_LIMIT_OBJECTS_KEY, 1); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "dict set of key for hard-limit " - "failed"); - goto err; - } + if (dict) { + ret = dict_set_int8(dict, QUOTA_LIMIT_OBJECTS_KEY, 1); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "dict set of key for hard-limit " + "failed"); + goto err; } + } - STACK_WIND (frame, quota_readdirp_cbk, - FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdirp, fd, - size, offset, dict); + STACK_WIND(frame, quota_readdirp_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->readdirp, fd, size, offset, dict); - if (new_dict) { - dict_unref (dict); - } + if (new_dict) { + dict_unref(dict); + } - return 0; + return 0; err: - STACK_UNWIND_STRICT (readdirp, frame, -1, EINVAL, NULL, NULL); + STACK_UNWIND_STRICT(readdirp, frame, -1, EINVAL, NULL, NULL); - if (new_dict) { - dict_unref (dict); - } + if (new_dict) { + dict_unref(dict); + } - return 0; + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->readdirp, fd, - size, offset, dict); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdirp, + fd, size, offset, dict); + return 0; } int32_t @@ -4771,639 +4647,630 @@ quota_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata) { - int32_t ret = 0; - uint64_t ctx_int = 0; - quota_inode_ctx_t *ctx = NULL; - quota_local_t *local = NULL; - - local = frame->local; - - if ((op_ret < 0) || (local == NULL)) { - goto out; - } - - ret = inode_ctx_get (local->loc.inode, this, &ctx_int); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, 0, - Q_MSG_INODE_CTX_GET_FAILED, - "%s: failed to get the context", local->loc.path); - goto out; - } - - ctx = (quota_inode_ctx_t *)(unsigned long) ctx_int; - - if (ctx == NULL) { - gf_msg (this->name, GF_LOG_WARNING, 0, - Q_MSG_INODE_CTX_GET_FAILED, - "quota context not set in %s (gfid:%s)", - local->loc.path, uuid_utoa (local->loc.inode->gfid)); - goto out; - } - - LOCK (&ctx->lock); - { - ctx->buf = *postbuf; - } - UNLOCK (&ctx->lock); + int32_t ret = 0; + uint64_t ctx_int = 0; + quota_inode_ctx_t *ctx = NULL; + quota_local_t *local = NULL; + + local = frame->local; + + if ((op_ret < 0) || (local == NULL)) { + goto out; + } + + ret = inode_ctx_get(local->loc.inode, this, &ctx_int); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, 0, Q_MSG_INODE_CTX_GET_FAILED, + "%s: failed to get the context", local->loc.path); + goto out; + } + + ctx = (quota_inode_ctx_t *)(unsigned long)ctx_int; + + if (ctx == NULL) { + gf_msg(this->name, GF_LOG_WARNING, 0, Q_MSG_INODE_CTX_GET_FAILED, + "quota context not set in %s (gfid:%s)", local->loc.path, + uuid_utoa(local->loc.inode->gfid)); + goto out; + } + + LOCK(&ctx->lock); + { + ctx->buf = *postbuf; + } + UNLOCK(&ctx->lock); out: - QUOTA_STACK_UNWIND (fallocate, frame, op_ret, op_errno, prebuf, postbuf, - xdata); + QUOTA_STACK_UNWIND(fallocate, frame, op_ret, op_errno, prebuf, postbuf, + xdata); - return 0; + return 0; } - int32_t -quota_fallocate_helper (call_frame_t *frame, xlator_t *this, fd_t *fd, - int32_t mode, off_t offset, size_t len, dict_t *xdata) +quota_fallocate_helper(call_frame_t *frame, xlator_t *this, fd_t *fd, + int32_t mode, off_t offset, size_t len, dict_t *xdata) { - quota_local_t *local = NULL; - int32_t op_errno = EINVAL; - - local = frame->local; - - GF_VALIDATE_OR_GOTO ("quota", local, unwind); - - if (local->op_ret == -1) { - op_errno = local->op_errno; - if (op_errno == ENOENT || op_errno == ESTALE) { - /* We may get ENOENT/ESTALE in case of below scenario - * fd = open file.txt - * unlink file.txt - * fallocate on fd - * Here build_ancestry can fail as the file is removed. - * For now ignore ENOENT/ESTALE on active fd - * We need to re-visit this code once we understand - * how other file-system behave in this scenario - */ - gf_msg_debug (this->name, 0, "quota enforcer failed " - "with ENOENT/ESTALE on %s, cannot check " - "quota limits and allowing fallocate", - uuid_utoa (fd->inode->gfid)); - } else { - goto unwind; - } + quota_local_t *local = NULL; + int32_t op_errno = EINVAL; + + local = frame->local; + + GF_VALIDATE_OR_GOTO("quota", local, unwind); + + if (local->op_ret == -1) { + op_errno = local->op_errno; + if (op_errno == ENOENT || op_errno == ESTALE) { + /* We may get ENOENT/ESTALE in case of below scenario + * fd = open file.txt + * unlink file.txt + * fallocate on fd + * Here build_ancestry can fail as the file is removed. + * For now ignore ENOENT/ESTALE on active fd + * We need to re-visit this code once we understand + * how other file-system behave in this scenario + */ + gf_msg_debug(this->name, 0, + "quota enforcer failed " + "with ENOENT/ESTALE on %s, cannot check " + "quota limits and allowing fallocate", + uuid_utoa(fd->inode->gfid)); + } else { + goto unwind; } + } - STACK_WIND (frame, quota_fallocate_cbk, - FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fallocate, fd, mode, offset, len, - xdata); - return 0; + STACK_WIND(frame, quota_fallocate_cbk, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fallocate, fd, mode, offset, len, + xdata); + return 0; unwind: - QUOTA_STACK_UNWIND (fallocate, frame, -1, op_errno, NULL, NULL, NULL); - return 0; + QUOTA_STACK_UNWIND(fallocate, frame, -1, op_errno, NULL, NULL, NULL); + return 0; } - int32_t quota_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t mode, - off_t offset, size_t len, dict_t *xdata) + off_t offset, size_t len, dict_t *xdata) { - int32_t op_errno = EINVAL; - int32_t parents = 0; - int32_t fail_count = 0; - quota_local_t *local = NULL; - quota_inode_ctx_t *ctx = NULL; - quota_priv_t *priv = NULL; - quota_dentry_t *dentry = NULL; - quota_dentry_t *tmp = NULL; - call_stub_t *stub = NULL; - struct list_head head = {0, }; - inode_t *par_inode = NULL; - - priv = this->private; - GF_VALIDATE_OR_GOTO (this->name, priv, unwind); - - WIND_IF_QUOTAOFF (priv->is_quota_on, off); - - INIT_LIST_HEAD (&head); - - GF_ASSERT (frame); - GF_VALIDATE_OR_GOTO ("quota", this, unwind); - GF_VALIDATE_OR_GOTO (this->name, fd, unwind); - - local = quota_local_new (); - if (local == NULL) { - goto unwind; - } - - frame->local = local; - local->loc.inode = inode_ref (fd->inode); - - (void) quota_inode_ctx_get (fd->inode, this, &ctx, 0); - if (ctx == NULL) { - gf_msg_debug (this->name, 0, "quota context is NULL on inode" - " (%s). If quota is not enabled recently and " - "crawler has finished crawling, its an error", - uuid_utoa (local->loc.inode->gfid)); - } - - stub = fop_fallocate_stub(frame, quota_fallocate_helper, fd, mode, - offset, len, xdata); - if (stub == NULL) { - op_errno = ENOMEM; - goto unwind; + int32_t op_errno = EINVAL; + int32_t parents = 0; + int32_t fail_count = 0; + quota_local_t *local = NULL; + quota_inode_ctx_t *ctx = NULL; + quota_priv_t *priv = NULL; + quota_dentry_t *dentry = NULL; + quota_dentry_t *tmp = NULL; + call_stub_t *stub = NULL; + struct list_head head = { + 0, + }; + inode_t *par_inode = NULL; + + priv = this->private; + GF_VALIDATE_OR_GOTO(this->name, priv, unwind); + + WIND_IF_QUOTAOFF(priv->is_quota_on, off); + + INIT_LIST_HEAD(&head); + + GF_ASSERT(frame); + GF_VALIDATE_OR_GOTO("quota", this, unwind); + GF_VALIDATE_OR_GOTO(this->name, fd, unwind); + + local = quota_local_new(); + if (local == NULL) { + goto unwind; + } + + frame->local = local; + local->loc.inode = inode_ref(fd->inode); + + (void)quota_inode_ctx_get(fd->inode, this, &ctx, 0); + if (ctx == NULL) { + gf_msg_debug(this->name, 0, + "quota context is NULL on inode" + " (%s). If quota is not enabled recently and " + "crawler has finished crawling, its an error", + uuid_utoa(local->loc.inode->gfid)); + } + + stub = fop_fallocate_stub(frame, quota_fallocate_helper, fd, mode, offset, + len, xdata); + if (stub == NULL) { + op_errno = ENOMEM; + goto unwind; + } + + priv = this->private; + GF_VALIDATE_OR_GOTO(this->name, priv, unwind); + + parents = quota_add_parents_from_ctx(ctx, &head); + + /* + * Note that by using len as the delta we're assuming the range from + * offset to offset+len has not already been allocated. This can result + * in ENOSPC errors attempting to allocate an already allocated range. + */ + local->delta = len; + local->object_delta = 0; + local->stub = stub; + local->link_count = parents; + + if (parents == 0) { + local->link_count = 1; + quota_check_limit(frame, fd->inode, this); + } else { + list_for_each_entry_safe(dentry, tmp, &head, next) + { + par_inode = do_quota_check_limit(frame, fd->inode, this, dentry, + _gf_false); + if (par_inode == NULL) { + /* remove stale entry from inode_ctx */ + quota_dentry_del(ctx, dentry->name, dentry->par); + parents--; + fail_count++; + } else { + inode_unref(par_inode); + } + __quota_dentry_free(dentry); } - priv = this->private; - GF_VALIDATE_OR_GOTO (this->name, priv, unwind); - - parents = quota_add_parents_from_ctx (ctx, &head); - - /* - * Note that by using len as the delta we're assuming the range from - * offset to offset+len has not already been allocated. This can result - * in ENOSPC errors attempting to allocate an already allocated range. - */ - local->delta = len; - local->object_delta = 0; - local->stub = stub; - local->link_count = parents; - if (parents == 0) { - local->link_count = 1; - quota_check_limit (frame, fd->inode, this); - } else { - list_for_each_entry_safe (dentry, tmp, &head, next) { - par_inode = do_quota_check_limit (frame, fd->inode, - this, dentry, - _gf_false); - if (par_inode == NULL) { - /* remove stale entry from inode_ctx */ - quota_dentry_del (ctx, dentry->name, - dentry->par); - parents--; - fail_count++; - } else { - inode_unref (par_inode); - } - __quota_dentry_free (dentry); - } - - if (parents == 0) { - LOCK (&local->lock); - { - local->link_count++; - } - UNLOCK (&local->lock); - quota_check_limit (frame, fd->inode, this); - } + LOCK(&local->lock); + { + local->link_count++; + } + UNLOCK(&local->lock); + quota_check_limit(frame, fd->inode, this); + } - while (fail_count != 0) { - quota_link_count_decrement (frame); - fail_count--; - } + while (fail_count != 0) { + quota_link_count_decrement(frame); + fail_count--; } + } - return 0; + return 0; unwind: - QUOTA_STACK_UNWIND (fallocate, frame, -1, op_errno, NULL, NULL, NULL); - return 0; + QUOTA_STACK_UNWIND(fallocate, frame, -1, op_errno, NULL, NULL, NULL); + return 0; off: - STACK_WIND_TAIL (frame, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->fallocate, fd, mode, offset, - len, xdata); - return 0; + STACK_WIND_TAIL(frame, FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fallocate, fd, mode, offset, len, + xdata); + return 0; } void -quota_log_helper (char **usage_str, int64_t cur_size, inode_t *inode, - char **path, struct timeval *cur_time) +quota_log_helper(char **usage_str, int64_t cur_size, inode_t *inode, + char **path, struct timeval *cur_time) { - xlator_t *this = THIS; + xlator_t *this = THIS; - if (!usage_str || !inode || !path || !cur_time) { - gf_log (this->name, GF_LOG_ERROR, "Received null argument"); - return; - } + if (!usage_str || !inode || !path || !cur_time) { + gf_log(this->name, GF_LOG_ERROR, "Received null argument"); + return; + } - *usage_str = gf_uint64_2human_readable (cur_size); - if (!(*usage_str)) - gf_msg (this->name, GF_LOG_ERROR, ENOMEM, Q_MSG_ENOMEM, - "integer to string conversion failed Reason" - ":\"Cannot allocate memory\""); + *usage_str = gf_uint64_2human_readable(cur_size); + if (!(*usage_str)) + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, Q_MSG_ENOMEM, + "integer to string conversion failed Reason" + ":\"Cannot allocate memory\""); - inode_path (inode, NULL, path); - if (!(*path)) - *path = uuid_utoa (inode->gfid); + inode_path(inode, NULL, path); + if (!(*path)) + *path = uuid_utoa(inode->gfid); - gettimeofday (cur_time, NULL); + gettimeofday(cur_time, NULL); } /* Logs if -* i. Usage crossed soft limit -* ii. Usage above soft limit and alert-time elapsed -*/ + * i. Usage crossed soft limit + * ii. Usage above soft limit and alert-time elapsed + */ void -quota_log_usage (xlator_t *this, quota_inode_ctx_t *ctx, inode_t *inode, - int64_t delta) +quota_log_usage(xlator_t *this, quota_inode_ctx_t *ctx, inode_t *inode, + int64_t delta) { - struct timeval cur_time = {0,}; - char *usage_str = NULL; - char *path = NULL; - int64_t cur_size = 0; - quota_priv_t *priv = NULL; - - priv = this->private; - cur_size = ctx->size + delta; - - if ((ctx->soft_lim <= 0) || cur_size < ctx->soft_lim) - return; - - /* Usage crossed/reached soft limit */ - if (DID_REACH_LIMIT (ctx->soft_lim, ctx->size, cur_size)) { - - quota_log_helper (&usage_str, cur_size, inode, - &path, &cur_time); + struct timeval cur_time = { + 0, + }; + char *usage_str = NULL; + char *path = NULL; + int64_t cur_size = 0; + quota_priv_t *priv = NULL; + + priv = this->private; + cur_size = ctx->size + delta; + + if ((ctx->soft_lim <= 0) || cur_size < ctx->soft_lim) + return; - gf_msg (this->name, GF_LOG_ALERT, 0, - Q_MSG_CROSSED_SOFT_LIMIT, "Usage crossed soft limit: " - "%s used by %s", usage_str, path); + /* Usage crossed/reached soft limit */ + if (DID_REACH_LIMIT(ctx->soft_lim, ctx->size, cur_size)) { + quota_log_helper(&usage_str, cur_size, inode, &path, &cur_time); - gf_event (EVENT_QUOTA_CROSSED_SOFT_LIMIT, "Usage=%s;volume=%s;" - "path=%s", usage_str, priv->volume_uuid, path); + gf_msg(this->name, GF_LOG_ALERT, 0, Q_MSG_CROSSED_SOFT_LIMIT, + "Usage crossed soft limit: " + "%s used by %s", + usage_str, path); - ctx->prev_log = cur_time; + gf_event(EVENT_QUOTA_CROSSED_SOFT_LIMIT, + "Usage=%s;volume=%s;" + "path=%s", + usage_str, priv->volume_uuid, path); - } - /* Usage is above soft limit */ - else if (cur_size > ctx->soft_lim && - quota_timeout (&ctx->prev_log, priv->log_timeout)) { + ctx->prev_log = cur_time; - quota_log_helper (&usage_str, cur_size, inode, - &path, &cur_time); + } + /* Usage is above soft limit */ + else if (cur_size > ctx->soft_lim && + quota_timeout(&ctx->prev_log, priv->log_timeout)) { + quota_log_helper(&usage_str, cur_size, inode, &path, &cur_time); - gf_msg (this->name, GF_LOG_ALERT, 0, Q_MSG_CROSSED_SOFT_LIMIT, - "Usage is above soft limit: %s used by %s", - usage_str, path); + gf_msg(this->name, GF_LOG_ALERT, 0, Q_MSG_CROSSED_SOFT_LIMIT, + "Usage is above soft limit: %s used by %s", usage_str, path); - gf_event (EVENT_QUOTA_CROSSED_SOFT_LIMIT, "Usage=%s;volume=%s;" - "path=%s", usage_str, priv->volume_uuid, path); + gf_event(EVENT_QUOTA_CROSSED_SOFT_LIMIT, + "Usage=%s;volume=%s;" + "path=%s", + usage_str, priv->volume_uuid, path); - ctx->prev_log = cur_time; - } + ctx->prev_log = cur_time; + } - if (usage_str) - GF_FREE (usage_str); + if (usage_str) + GF_FREE(usage_str); } int32_t -mem_acct_init (xlator_t *this) +mem_acct_init(xlator_t *this) { - int ret = -1; + int ret = -1; - if (!this) - return ret; - - ret = xlator_mem_acct_init (this, gf_quota_mt_end + 1); + if (!this) + return ret; - if (ret != 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, - "Memory accounting init failed"); - return ret; - } + ret = xlator_mem_acct_init(this, gf_quota_mt_end + 1); + if (ret != 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "Memory accounting init failed"); return ret; -} + } + return ret; +} int32_t -quota_forget (xlator_t *this, inode_t *inode) +quota_forget(xlator_t *this, inode_t *inode) { - int32_t ret = 0; - uint64_t ctx_int = 0; - quota_inode_ctx_t *ctx = NULL; - quota_dentry_t *dentry = NULL, *tmp; + int32_t ret = 0; + uint64_t ctx_int = 0; + quota_inode_ctx_t *ctx = NULL; + quota_dentry_t *dentry = NULL, *tmp; - ret = inode_ctx_del (inode, this, &ctx_int); + ret = inode_ctx_del(inode, this, &ctx_int); - if (ret < 0) { - return 0; - } + if (ret < 0) { + return 0; + } - ctx = (quota_inode_ctx_t *) (long)ctx_int; + ctx = (quota_inode_ctx_t *)(long)ctx_int; - LOCK (&ctx->lock); + LOCK(&ctx->lock); + { + list_for_each_entry_safe(dentry, tmp, &ctx->parents, next) { - list_for_each_entry_safe (dentry, tmp, &ctx->parents, next) { - __quota_dentry_free (dentry); - } + __quota_dentry_free(dentry); } - UNLOCK (&ctx->lock); + } + UNLOCK(&ctx->lock); - LOCK_DESTROY (&ctx->lock); + LOCK_DESTROY(&ctx->lock); - GF_FREE (ctx); + GF_FREE(ctx); - return 0; + return 0; } int32_t -init (xlator_t *this) +init(xlator_t *this) { - int32_t ret = -1; - quota_priv_t *priv = NULL; - rpc_clnt_t *rpc = NULL; - - if ((this->children == NULL) - || this->children->next) { - gf_msg (this->name, GF_LOG_ERROR, 0, - Q_MSG_INVALID_VOLFILE, - "FATAL: quota (%s) not configured with " - "exactly one child", this->name); - return -1; - } - - if (this->parents == NULL) { - gf_msg (this->name, GF_LOG_WARNING, 0, - Q_MSG_INVALID_VOLFILE, - "dangling volume. check volfile"); - } - - QUOTA_ALLOC_OR_GOTO (priv, quota_priv_t, err); - - LOCK_INIT (&priv->lock); - - this->private = priv; - - GF_OPTION_INIT ("deem-statfs", priv->consider_statfs, bool, err); - GF_OPTION_INIT ("server-quota", priv->is_quota_on, bool, err); - GF_OPTION_INIT ("default-soft-limit", priv->default_soft_lim, percent, - err); - GF_OPTION_INIT ("soft-timeout", priv->soft_timeout, time, err); - GF_OPTION_INIT ("hard-timeout", priv->hard_timeout, time, err); - GF_OPTION_INIT ("alert-time", priv->log_timeout, time, err); - GF_OPTION_INIT ("volume-uuid", priv->volume_uuid, str, err); - - this->local_pool = mem_pool_new (quota_local_t, 64); - if (!this->local_pool) { - ret = -1; - gf_msg (this->name, GF_LOG_ERROR, ENOMEM, - Q_MSG_ENOMEM, "failed to create local_t's memory pool"); - goto err; - } - - if (priv->is_quota_on) { - rpc = quota_enforcer_init (this, this->options); - if (rpc == NULL) { - ret = -1; - gf_msg (this->name, GF_LOG_WARNING, 0, - Q_MSG_QUOTA_ENFORCER_RPC_INIT_FAILED, - "quota enforcer rpc init failed"); - goto err; - } - - LOCK (&priv->lock); - { - priv->rpc_clnt = rpc; - } - UNLOCK (&priv->lock); + int32_t ret = -1; + quota_priv_t *priv = NULL; + rpc_clnt_t *rpc = NULL; + + if ((this->children == NULL) || this->children->next) { + gf_msg(this->name, GF_LOG_ERROR, 0, Q_MSG_INVALID_VOLFILE, + "FATAL: quota (%s) not configured with " + "exactly one child", + this->name); + return -1; + } + + if (this->parents == NULL) { + gf_msg(this->name, GF_LOG_WARNING, 0, Q_MSG_INVALID_VOLFILE, + "dangling volume. check volfile"); + } + + QUOTA_ALLOC_OR_GOTO(priv, quota_priv_t, err); + + LOCK_INIT(&priv->lock); + + this->private = priv; + + GF_OPTION_INIT("deem-statfs", priv->consider_statfs, bool, err); + GF_OPTION_INIT("server-quota", priv->is_quota_on, bool, err); + GF_OPTION_INIT("default-soft-limit", priv->default_soft_lim, percent, err); + GF_OPTION_INIT("soft-timeout", priv->soft_timeout, time, err); + GF_OPTION_INIT("hard-timeout", priv->hard_timeout, time, err); + GF_OPTION_INIT("alert-time", priv->log_timeout, time, err); + GF_OPTION_INIT("volume-uuid", priv->volume_uuid, str, err); + + this->local_pool = mem_pool_new(quota_local_t, 64); + if (!this->local_pool) { + ret = -1; + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, Q_MSG_ENOMEM, + "failed to create local_t's memory pool"); + goto err; + } + + if (priv->is_quota_on) { + rpc = quota_enforcer_init(this, this->options); + if (rpc == NULL) { + ret = -1; + gf_msg(this->name, GF_LOG_WARNING, 0, + Q_MSG_QUOTA_ENFORCER_RPC_INIT_FAILED, + "quota enforcer rpc init failed"); + goto err; + } + + LOCK(&priv->lock); + { + priv->rpc_clnt = rpc; } + UNLOCK(&priv->lock); + } - ret = 0; + ret = 0; err: - return ret; + return ret; } int -reconfigure (xlator_t *this, dict_t *options) +reconfigure(xlator_t *this, dict_t *options) { - int32_t ret = -1; - quota_priv_t *priv = NULL; - gf_boolean_t quota_on = _gf_false; - rpc_clnt_t *rpc = NULL; - - priv = this->private; - - GF_OPTION_RECONF ("deem-statfs", priv->consider_statfs, options, bool, - out); - GF_OPTION_RECONF ("server-quota", quota_on, options, bool, - out); - GF_OPTION_RECONF ("default-soft-limit", priv->default_soft_lim, - options, percent, out); - GF_OPTION_RECONF ("alert-time", priv->log_timeout, options, - time, out); - GF_OPTION_RECONF ("soft-timeout", priv->soft_timeout, options, - time, out); - GF_OPTION_RECONF ("hard-timeout", priv->hard_timeout, options, - time, out); - - if (quota_on) { - priv->rpc_clnt = quota_enforcer_init (this, - this->options); - if (priv->rpc_clnt == NULL) { - ret = -1; - gf_msg (this->name, GF_LOG_WARNING, 0, - Q_MSG_QUOTA_ENFORCER_RPC_INIT_FAILED, - "quota enforcer rpc init failed"); - goto out; - } + int32_t ret = -1; + quota_priv_t *priv = NULL; + gf_boolean_t quota_on = _gf_false; + rpc_clnt_t *rpc = NULL; + + priv = this->private; + + GF_OPTION_RECONF("deem-statfs", priv->consider_statfs, options, bool, out); + GF_OPTION_RECONF("server-quota", quota_on, options, bool, out); + GF_OPTION_RECONF("default-soft-limit", priv->default_soft_lim, options, + percent, out); + GF_OPTION_RECONF("alert-time", priv->log_timeout, options, time, out); + GF_OPTION_RECONF("soft-timeout", priv->soft_timeout, options, time, out); + GF_OPTION_RECONF("hard-timeout", priv->hard_timeout, options, time, out); + + if (quota_on) { + priv->rpc_clnt = quota_enforcer_init(this, this->options); + if (priv->rpc_clnt == NULL) { + ret = -1; + gf_msg(this->name, GF_LOG_WARNING, 0, + Q_MSG_QUOTA_ENFORCER_RPC_INIT_FAILED, + "quota enforcer rpc init failed"); + goto out; + } - } else { - LOCK (&priv->lock); - { - rpc = priv->rpc_clnt; - priv->rpc_clnt = NULL; - } - UNLOCK (&priv->lock); - - if (rpc != NULL) { - // Quotad is shutdown when there is no started volume - // which has quota enabled. So, we should disable the - // enforcer client when quota is disabled on a volume, - // to avoid spurious reconnect attempts to a service - // (quotad), that is known to be down. - rpc_clnt_unref (rpc); - } + } else { + LOCK(&priv->lock); + { + rpc = priv->rpc_clnt; + priv->rpc_clnt = NULL; + } + UNLOCK(&priv->lock); + + if (rpc != NULL) { + // Quotad is shutdown when there is no started volume + // which has quota enabled. So, we should disable the + // enforcer client when quota is disabled on a volume, + // to avoid spurious reconnect attempts to a service + // (quotad), that is known to be down. + rpc_clnt_unref(rpc); } + } - priv->is_quota_on = quota_on; + priv->is_quota_on = quota_on; - ret = 0; + ret = 0; out: - return ret; + return ret; } int32_t -quota_priv_dump (xlator_t *this) +quota_priv_dump(xlator_t *this) { - quota_priv_t *priv = NULL; - int32_t ret = -1; - - - GF_ASSERT (this); - - priv = this->private; - if (!priv) - goto out; - - gf_proc_dump_add_section ("xlators.features.quota.priv", this->name); - - ret = TRY_LOCK (&priv->lock); - if (ret) - goto out; - else { - gf_proc_dump_write("soft-timeout", "%d", priv->soft_timeout); - gf_proc_dump_write("hard-timeout", "%d", priv->hard_timeout); - gf_proc_dump_write("alert-time", "%d", priv->log_timeout); - gf_proc_dump_write("quota-on", "%d", priv->is_quota_on); - gf_proc_dump_write("statfs", "%d", priv->consider_statfs); - gf_proc_dump_write("volume-uuid", "%s", priv->volume_uuid); - gf_proc_dump_write("validation-count", "%ld", - priv->validation_count); - } - UNLOCK (&priv->lock); + quota_priv_t *priv = NULL; + int32_t ret = -1; + + GF_ASSERT(this); + + priv = this->private; + if (!priv) + goto out; + + gf_proc_dump_add_section("xlators.features.quota.priv", this->name); + + ret = TRY_LOCK(&priv->lock); + if (ret) + goto out; + else { + gf_proc_dump_write("soft-timeout", "%d", priv->soft_timeout); + gf_proc_dump_write("hard-timeout", "%d", priv->hard_timeout); + gf_proc_dump_write("alert-time", "%d", priv->log_timeout); + gf_proc_dump_write("quota-on", "%d", priv->is_quota_on); + gf_proc_dump_write("statfs", "%d", priv->consider_statfs); + gf_proc_dump_write("volume-uuid", "%s", priv->volume_uuid); + gf_proc_dump_write("validation-count", "%ld", priv->validation_count); + } + UNLOCK(&priv->lock); out: - return 0; + return 0; } void -fini (xlator_t *this) +fini(xlator_t *this) { - quota_priv_t *priv = NULL; - rpc_clnt_t *rpc = NULL; - int i = 0, cnt = 0; - - priv = this->private; - if (!priv) - return; - rpc = priv->rpc_clnt; - priv->rpc_clnt = NULL; - this->private = NULL; - if (rpc) { - cnt = GF_ATOMIC_GET (rpc->refcount); - for (i = 0; i < cnt; i++) - rpc_clnt_unref (rpc); - } - LOCK_DESTROY (&priv->lock); - GF_FREE (priv); - if (this->local_pool) { - mem_pool_destroy (this->local_pool); - this->local_pool = NULL; - } + quota_priv_t *priv = NULL; + rpc_clnt_t *rpc = NULL; + int i = 0, cnt = 0; + + priv = this->private; + if (!priv) return; + rpc = priv->rpc_clnt; + priv->rpc_clnt = NULL; + this->private = NULL; + if (rpc) { + cnt = GF_ATOMIC_GET(rpc->refcount); + for (i = 0; i < cnt; i++) + rpc_clnt_unref(rpc); + } + LOCK_DESTROY(&priv->lock); + GF_FREE(priv); + if (this->local_pool) { + mem_pool_destroy(this->local_pool); + this->local_pool = NULL; + } + return; } - struct xlator_fops fops = { - .statfs = quota_statfs, - .lookup = quota_lookup, - .writev = quota_writev, - .create = quota_create, - .mkdir = quota_mkdir, - .truncate = quota_truncate, - .ftruncate = quota_ftruncate, - .unlink = quota_unlink, - .symlink = quota_symlink, - .link = quota_link, - .rename = quota_rename, - .getxattr = quota_getxattr, - .fgetxattr = quota_fgetxattr, - .stat = quota_stat, - .fstat = quota_fstat, - .readlink = quota_readlink, - .readv = quota_readv, - .fsync = quota_fsync, - .setattr = quota_setattr, - .fsetattr = quota_fsetattr, - .mknod = quota_mknod, - .setxattr = quota_setxattr, - .fsetxattr = quota_fsetxattr, - .removexattr = quota_removexattr, - .fremovexattr = quota_fremovexattr, - .readdirp = quota_readdirp, - .fallocate = quota_fallocate, + .statfs = quota_statfs, + .lookup = quota_lookup, + .writev = quota_writev, + .create = quota_create, + .mkdir = quota_mkdir, + .truncate = quota_truncate, + .ftruncate = quota_ftruncate, + .unlink = quota_unlink, + .symlink = quota_symlink, + .link = quota_link, + .rename = quota_rename, + .getxattr = quota_getxattr, + .fgetxattr = quota_fgetxattr, + .stat = quota_stat, + .fstat = quota_fstat, + .readlink = quota_readlink, + .readv = quota_readv, + .fsync = quota_fsync, + .setattr = quota_setattr, + .fsetattr = quota_fsetattr, + .mknod = quota_mknod, + .setxattr = quota_setxattr, + .fsetxattr = quota_fsetxattr, + .removexattr = quota_removexattr, + .fremovexattr = quota_fremovexattr, + .readdirp = quota_readdirp, + .fallocate = quota_fallocate, }; -struct xlator_cbks cbks = { - .forget = quota_forget -}; +struct xlator_cbks cbks = {.forget = quota_forget}; struct xlator_dumpops dumpops = { - .priv = quota_priv_dump, + .priv = quota_priv_dump, }; struct volume_options options[] = { - {.key = {"enable"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .description = "enable is the volume option that can be used " - "to turn on quota.", - .op_version = {1}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .level = OPT_STATUS_BASIC, - .tags = {}, - }, - {.key = {"deem-statfs"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "on", - .description = "If set to on, it takes quota limits into" - " consideration while estimating fs size. (df command)" - " (Default is on).", - .op_version = {2}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .tags = {}, - }, - {.key = {"server-quota"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "off", - .description = "Skip the quota enforcement if the feature is" - " not turned on. This is not a user exposed option.", - .flags = OPT_FLAG_NONE, - }, - {.key = {"default-soft-limit"}, - .type = GF_OPTION_TYPE_PERCENT, - .default_value = "80%", - .op_version = {3}, - .description = "Soft limit is expressed as a proportion of hard limit." - " Default-soft-limit is the proportion used when the " - " user does not supply any soft limit value.", - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .tags = {}, - }, - {.key = {"soft-timeout"}, - .type = GF_OPTION_TYPE_TIME, - .min = 0, - .max = 1800, - .default_value = "60", - .description = "quota caches the directory sizes on client. " - "soft-timeout indicates the timeout for the validity of" - " cache before soft-limit has been crossed.", - .op_version = {3}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .tags = {}, - }, - {.key = {"hard-timeout"}, - .type = GF_OPTION_TYPE_TIME, - .min = 0, - .max = 60, - .default_value = "5", - .description = "quota caches the directory sizes on client. " - "hard-timeout indicates the timeout for the validity of" - " cache after soft-limit has been crossed.", - .op_version = {3}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .tags = {}, - }, - { .key = {"volume-uuid"}, - .type = GF_OPTION_TYPE_STR, - .default_value = "{{ volume.id }}", - .description = "uuid of the volume this brick is part of." - }, - { .key = {"alert-time"}, - .type = GF_OPTION_TYPE_TIME, - .min = 0, - .max = 7*86400, - .default_value = "86400", - .op_version = {3}, - .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, - .description = "Frequency of limit breach messages in log.", - .tags = {}, - }, - {.key = {NULL}} -}; + { + .key = {"enable"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .description = "enable is the volume option that can be used " + "to turn on quota.", + .op_version = {1}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .level = OPT_STATUS_BASIC, + .tags = {}, + }, + { + .key = {"deem-statfs"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "on", + .description = "If set to on, it takes quota limits into" + " consideration while estimating fs size. (df command)" + " (Default is on).", + .op_version = {2}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .tags = {}, + }, + { + .key = {"server-quota"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "off", + .description = "Skip the quota enforcement if the feature is" + " not turned on. This is not a user exposed option.", + .flags = OPT_FLAG_NONE, + }, + { + .key = {"default-soft-limit"}, + .type = GF_OPTION_TYPE_PERCENT, + .default_value = "80%", + .op_version = {3}, + .description = "Soft limit is expressed as a proportion of hard limit." + " Default-soft-limit is the proportion used when the " + " user does not supply any soft limit value.", + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .tags = {}, + }, + { + .key = {"soft-timeout"}, + .type = GF_OPTION_TYPE_TIME, + .min = 0, + .max = 1800, + .default_value = "60", + .description = "quota caches the directory sizes on client. " + "soft-timeout indicates the timeout for the validity of" + " cache before soft-limit has been crossed.", + .op_version = {3}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .tags = {}, + }, + { + .key = {"hard-timeout"}, + .type = GF_OPTION_TYPE_TIME, + .min = 0, + .max = 60, + .default_value = "5", + .description = "quota caches the directory sizes on client. " + "hard-timeout indicates the timeout for the validity of" + " cache after soft-limit has been crossed.", + .op_version = {3}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .tags = {}, + }, + {.key = {"volume-uuid"}, + .type = GF_OPTION_TYPE_STR, + .default_value = "{{ volume.id }}", + .description = "uuid of the volume this brick is part of."}, + { + .key = {"alert-time"}, + .type = GF_OPTION_TYPE_TIME, + .min = 0, + .max = 7 * 86400, + .default_value = "86400", + .op_version = {3}, + .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC, + .description = "Frequency of limit breach messages in log.", + .tags = {}, + }, + {.key = {NULL}}}; diff --git a/xlators/features/quota/src/quotad-aggregator.c b/xlators/features/quota/src/quotad-aggregator.c index c27b67136a3..d30b8cdedfc 100644 --- a/xlators/features/quota/src/quotad-aggregator.c +++ b/xlators/features/quota/src/quotad-aggregator.c @@ -16,442 +16,440 @@ struct rpcsvc_program quotad_aggregator_prog; struct iobuf * -quotad_serialize_reply (rpcsvc_request_t *req, void *arg, struct iovec *outmsg, - xdrproc_t xdrproc) +quotad_serialize_reply(rpcsvc_request_t *req, void *arg, struct iovec *outmsg, + xdrproc_t xdrproc) { - struct iobuf *iob = NULL; - ssize_t retlen = 0; - ssize_t xdr_size = 0; - - GF_VALIDATE_OR_GOTO ("server", req, ret); - - /* First, get the io buffer into which the reply in arg will - * be serialized. + struct iobuf *iob = NULL; + ssize_t retlen = 0; + ssize_t xdr_size = 0; + + GF_VALIDATE_OR_GOTO("server", req, ret); + + /* First, get the io buffer into which the reply in arg will + * be serialized. + */ + if (arg && xdrproc) { + xdr_size = xdr_sizeof(xdrproc, arg); + iob = iobuf_get2(req->svc->ctx->iobuf_pool, xdr_size); + if (!iob) { + gf_log_callingfn(THIS->name, GF_LOG_ERROR, "Failed to get iobuf"); + goto ret; + }; + + iobuf_to_iovec(iob, outmsg); + /* Use the given serializer to translate the given C structure + * in arg to XDR format which will be written into the buffer + * in outmsg. + */ + /* retlen is used to received the error since size_t is unsigned and we + * need -1 for error notification during encoding. */ - if (arg && xdrproc) { - xdr_size = xdr_sizeof (xdrproc, arg); - iob = iobuf_get2 (req->svc->ctx->iobuf_pool, xdr_size); - if (!iob) { - gf_log_callingfn (THIS->name, GF_LOG_ERROR, - "Failed to get iobuf"); - goto ret; - }; - - iobuf_to_iovec (iob, outmsg); - /* Use the given serializer to translate the given C structure - * in arg to XDR format which will be written into the buffer - * in outmsg. - */ - /* retlen is used to received the error since size_t is unsigned and we - * need -1 for error notification during encoding. - */ - - retlen = xdr_serialize_generic (*outmsg, arg, xdrproc); - if (retlen == -1) { - /* Failed to Encode 'GlusterFS' msg in RPC is not exactly - failure of RPC return values.. Client should get - notified about this, so there are no missing frames */ - gf_log_callingfn ("", GF_LOG_ERROR, "Failed to encode message"); - req->rpc_err = GARBAGE_ARGS; - retlen = 0; - } + + retlen = xdr_serialize_generic(*outmsg, arg, xdrproc); + if (retlen == -1) { + /* Failed to Encode 'GlusterFS' msg in RPC is not exactly + failure of RPC return values.. Client should get + notified about this, so there are no missing frames */ + gf_log_callingfn("", GF_LOG_ERROR, "Failed to encode message"); + req->rpc_err = GARBAGE_ARGS; + retlen = 0; } - outmsg->iov_len = retlen; + } + outmsg->iov_len = retlen; ret: - return iob; + return iob; } int -quotad_aggregator_submit_reply (call_frame_t *frame, rpcsvc_request_t *req, - void *arg, struct iovec *payload, - int payloadcount, struct iobref *iobref, - xdrproc_t xdrproc) +quotad_aggregator_submit_reply(call_frame_t *frame, rpcsvc_request_t *req, + void *arg, struct iovec *payload, + int payloadcount, struct iobref *iobref, + xdrproc_t xdrproc) { - struct iobuf *iob = NULL; - int ret = -1; - struct iovec rsp = {0,}; - quotad_aggregator_state_t *state = NULL; - char new_iobref = 0; + struct iobuf *iob = NULL; + int ret = -1; + struct iovec rsp = { + 0, + }; + quotad_aggregator_state_t *state = NULL; + char new_iobref = 0; - GF_VALIDATE_OR_GOTO ("server", req, ret); + GF_VALIDATE_OR_GOTO("server", req, ret); - if (frame) { - state = frame->root->state; - frame->local = NULL; - } + if (frame) { + state = frame->root->state; + frame->local = NULL; + } + if (!iobref) { + iobref = iobref_new(); if (!iobref) { - iobref = iobref_new (); - if (!iobref) { - goto ret; - } - - new_iobref = 1; + goto ret; } - iob = quotad_serialize_reply (req, arg, &rsp, xdrproc); - if (!iob) { - gf_msg ("", GF_LOG_ERROR, 0, Q_MSG_DICT_SERIALIZE_FAIL, - "Failed to serialize reply"); - goto ret; - } + new_iobref = 1; + } - iobref_add (iobref, iob); + iob = quotad_serialize_reply(req, arg, &rsp, xdrproc); + if (!iob) { + gf_msg("", GF_LOG_ERROR, 0, Q_MSG_DICT_SERIALIZE_FAIL, + "Failed to serialize reply"); + goto ret; + } - ret = rpcsvc_submit_generic (req, &rsp, 1, payload, payloadcount, - iobref); + iobref_add(iobref, iob); - iobuf_unref (iob); + ret = rpcsvc_submit_generic(req, &rsp, 1, payload, payloadcount, iobref); - ret = 0; + iobuf_unref(iob); + + ret = 0; ret: - if (state) { - quotad_aggregator_free_state (state); - } + if (state) { + quotad_aggregator_free_state(state); + } - if (frame) - STACK_DESTROY (frame->root); + if (frame) + STACK_DESTROY(frame->root); - if (new_iobref) { - iobref_unref (iobref); - } + if (new_iobref) { + iobref_unref(iobref); + } - return ret; + return ret; } int -quotad_aggregator_getlimit_cbk (xlator_t *this, call_frame_t *frame, - void *lookup_rsp) +quotad_aggregator_getlimit_cbk(xlator_t *this, call_frame_t *frame, + void *lookup_rsp) { - gfs3_lookup_rsp *rsp = lookup_rsp; - gf_cli_rsp cli_rsp = {0,}; - dict_t *xdata = NULL; - quotad_aggregator_state_t *state = NULL; - int ret = -1; - int type = 0; - - GF_PROTOCOL_DICT_UNSERIALIZE (frame->this, xdata, - (rsp->xdata.xdata_val), - (rsp->xdata.xdata_len), rsp->op_ret, - rsp->op_errno, out); - - if (xdata) { - state = frame->root->state; - ret = dict_get_int32 (state->xdata, "type", &type); - if (ret < 0) - goto out; - - ret = dict_set_int32 (xdata, "type", type); - if (ret < 0) - goto out; - } + gfs3_lookup_rsp *rsp = lookup_rsp; + gf_cli_rsp cli_rsp = { + 0, + }; + dict_t *xdata = NULL; + quotad_aggregator_state_t *state = NULL; + int ret = -1; + int type = 0; + + GF_PROTOCOL_DICT_UNSERIALIZE(frame->this, xdata, (rsp->xdata.xdata_val), + (rsp->xdata.xdata_len), rsp->op_ret, + rsp->op_errno, out); + + if (xdata) { + state = frame->root->state; + ret = dict_get_int32(state->xdata, "type", &type); + if (ret < 0) + goto out; - ret = 0; + ret = dict_set_int32(xdata, "type", type); + if (ret < 0) + goto out; + } + + ret = 0; out: - rsp->op_ret = ret; - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, - Q_MSG_DICT_UNSERIALIZE_FAIL, - "failed to unserialize " - "nameless lookup rsp"); - goto reply; - } - cli_rsp.op_ret = rsp->op_ret; - cli_rsp.op_errno = rsp->op_errno; - cli_rsp.op_errstr = ""; - if (xdata) { - GF_PROTOCOL_DICT_SERIALIZE (frame->this, xdata, - (&cli_rsp.dict.dict_val), - (cli_rsp.dict.dict_len), - cli_rsp.op_errno, reply); - } + rsp->op_ret = ret; + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, Q_MSG_DICT_UNSERIALIZE_FAIL, + "failed to unserialize " + "nameless lookup rsp"); + goto reply; + } + cli_rsp.op_ret = rsp->op_ret; + cli_rsp.op_errno = rsp->op_errno; + cli_rsp.op_errstr = ""; + if (xdata) { + GF_PROTOCOL_DICT_SERIALIZE(frame->this, xdata, (&cli_rsp.dict.dict_val), + (cli_rsp.dict.dict_len), cli_rsp.op_errno, + reply); + } reply: - quotad_aggregator_submit_reply (frame, frame->local, (void*)&cli_rsp, NULL, 0, - NULL, (xdrproc_t)xdr_gf_cli_rsp); + quotad_aggregator_submit_reply(frame, frame->local, (void *)&cli_rsp, NULL, + 0, NULL, (xdrproc_t)xdr_gf_cli_rsp); - dict_unref (xdata); - GF_FREE (cli_rsp.dict.dict_val); - return 0; + dict_unref(xdata); + GF_FREE(cli_rsp.dict.dict_val); + return 0; } int -quotad_aggregator_getlimit (rpcsvc_request_t *req) +quotad_aggregator_getlimit(rpcsvc_request_t *req) { - call_frame_t *frame = NULL; - gf_cli_req cli_req = {{0}, }; - gf_cli_rsp cli_rsp = {0}; - gfs3_lookup_req args = {{0,},}; - quotad_aggregator_state_t *state = NULL; - xlator_t *this = NULL; - dict_t *dict = NULL; - int ret = -1, op_errno = 0; - char *gfid_str = NULL; - uuid_t gfid = {0}; - - GF_VALIDATE_OR_GOTO ("quotad-aggregator", req, err); - - this = THIS; - - ret = xdr_to_generic (req->msg[0], &cli_req, (xdrproc_t)xdr_gf_cli_req); - if (ret < 0) { - //failed to decode msg; - gf_msg ("this->name", GF_LOG_ERROR, 0, Q_MSG_XDR_DECODE_ERROR, - "xdr decoding error"); - req->rpc_err = GARBAGE_ARGS; - goto err; + call_frame_t *frame = NULL; + gf_cli_req cli_req = { + {0}, + }; + gf_cli_rsp cli_rsp = {0}; + gfs3_lookup_req args = { + { + 0, + }, + }; + quotad_aggregator_state_t *state = NULL; + xlator_t *this = NULL; + dict_t *dict = NULL; + int ret = -1, op_errno = 0; + char *gfid_str = NULL; + uuid_t gfid = {0}; + + GF_VALIDATE_OR_GOTO("quotad-aggregator", req, err); + + this = THIS; + + ret = xdr_to_generic(req->msg[0], &cli_req, (xdrproc_t)xdr_gf_cli_req); + if (ret < 0) { + // failed to decode msg; + gf_msg("this->name", GF_LOG_ERROR, 0, Q_MSG_XDR_DECODE_ERROR, + "xdr decoding error"); + req->rpc_err = GARBAGE_ARGS; + goto err; + } + + if (cli_req.dict.dict_len) { + dict = dict_new(); + ret = dict_unserialize(cli_req.dict.dict_val, cli_req.dict.dict_len, + &dict); + if (ret < 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, Q_MSG_DICT_UNSERIALIZE_FAIL, + "Failed to unserialize req-buffer to " + "dictionary"); + goto err; } + } - if (cli_req.dict.dict_len) { - dict = dict_new (); - ret = dict_unserialize (cli_req.dict.dict_val, - cli_req.dict.dict_len, &dict); - if (ret < 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, - Q_MSG_DICT_UNSERIALIZE_FAIL, - "Failed to unserialize req-buffer to " - "dictionary"); - goto err; - } - } + ret = dict_get_str(dict, "gfid", &gfid_str); + if (ret) { + goto err; + } - ret = dict_get_str (dict, "gfid", &gfid_str); - if (ret) { - goto err; - } + gf_uuid_parse((const char *)gfid_str, gfid); - gf_uuid_parse ((const char*)gfid_str, gfid); + frame = quotad_aggregator_get_frame_from_req(req); + if (frame == NULL) { + cli_rsp.op_errno = ENOMEM; + goto errx; + } + state = frame->root->state; + state->xdata = dict; - frame = quotad_aggregator_get_frame_from_req (req); - if (frame == NULL) { - cli_rsp.op_errno = ENOMEM; - goto errx; - } - state = frame->root->state; - state->xdata = dict; - - ret = dict_set_int32 (state->xdata, QUOTA_LIMIT_KEY, 42); - if (ret) - goto err; + ret = dict_set_int32(state->xdata, QUOTA_LIMIT_KEY, 42); + if (ret) + goto err; - ret = dict_set_int32 (state->xdata, QUOTA_LIMIT_OBJECTS_KEY, 42); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, ENOMEM, Q_MSG_ENOMEM, - "Failed to set QUOTA_LIMIT_OBJECTS_KEY"); - goto err; - } + ret = dict_set_int32(state->xdata, QUOTA_LIMIT_OBJECTS_KEY, 42); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, Q_MSG_ENOMEM, + "Failed to set QUOTA_LIMIT_OBJECTS_KEY"); + goto err; + } - ret = dict_set_int32 (state->xdata, QUOTA_SIZE_KEY, 42); - if (ret) - goto err; + ret = dict_set_int32(state->xdata, QUOTA_SIZE_KEY, 42); + if (ret) + goto err; - ret = dict_set_int32 (state->xdata, GET_ANCESTRY_PATH_KEY, 42); - if (ret) - goto err; + ret = dict_set_int32(state->xdata, GET_ANCESTRY_PATH_KEY, 42); + if (ret) + goto err; - memcpy (&args.gfid, &gfid, 16); + memcpy(&args.gfid, &gfid, 16); - args.bname = alloca (req->msg[0].iov_len); - args.xdata.xdata_val = alloca (req->msg[0].iov_len); + args.bname = alloca(req->msg[0].iov_len); + args.xdata.xdata_val = alloca(req->msg[0].iov_len); - ret = qd_nameless_lookup (this, frame, &args, state->xdata, - quotad_aggregator_getlimit_cbk); - if (ret) { - cli_rsp.op_errno = ret; - goto errx; - } + ret = qd_nameless_lookup(this, frame, &args, state->xdata, + quotad_aggregator_getlimit_cbk); + if (ret) { + cli_rsp.op_errno = ret; + goto errx; + } - return ret; + return ret; err: - cli_rsp.op_errno = op_errno; + cli_rsp.op_errno = op_errno; errx: - cli_rsp.op_ret = -1; - cli_rsp.op_errstr = ""; + cli_rsp.op_ret = -1; + cli_rsp.op_errstr = ""; - quotad_aggregator_getlimit_cbk (this, frame, &cli_rsp); - if (dict) - dict_unref (dict); + quotad_aggregator_getlimit_cbk(this, frame, &cli_rsp); + if (dict) + dict_unref(dict); - return ret; + return ret; } int -quotad_aggregator_lookup_cbk (xlator_t *this, call_frame_t *frame, - void *rsp) +quotad_aggregator_lookup_cbk(xlator_t *this, call_frame_t *frame, void *rsp) { - quotad_aggregator_submit_reply (frame, frame->local, rsp, NULL, 0, NULL, - (xdrproc_t)xdr_gfs3_lookup_rsp); + quotad_aggregator_submit_reply(frame, frame->local, rsp, NULL, 0, NULL, + (xdrproc_t)xdr_gfs3_lookup_rsp); - return 0; + return 0; } - int -quotad_aggregator_lookup (rpcsvc_request_t *req) +quotad_aggregator_lookup(rpcsvc_request_t *req) { - call_frame_t *frame = NULL; - gfs3_lookup_req args = {{0,},}; - int ret = -1, op_errno = 0; - gfs3_lookup_rsp rsp = {0,}; - quotad_aggregator_state_t *state = NULL; - xlator_t *this = NULL; - - GF_VALIDATE_OR_GOTO ("quotad-aggregator", req, err); - - this = THIS; - - args.bname = alloca (req->msg[0].iov_len); - args.xdata.xdata_val = alloca (req->msg[0].iov_len); - - ret = xdr_to_generic (req->msg[0], &args, - (xdrproc_t)xdr_gfs3_lookup_req); - if (ret < 0) { - rsp.op_errno = EINVAL; - goto err; - } - - frame = quotad_aggregator_get_frame_from_req (req); - if (frame == NULL) { - rsp.op_errno = ENOMEM; - goto err; - } - - state = frame->root->state; - - GF_PROTOCOL_DICT_UNSERIALIZE (this, state->xdata, - (args.xdata.xdata_val), - (args.xdata.xdata_len), ret, - op_errno, err); - - - ret = qd_nameless_lookup (this, frame, &args, state->xdata, - quotad_aggregator_lookup_cbk); - if (ret) { - rsp.op_errno = ret; - goto err; - } - - return ret; + call_frame_t *frame = NULL; + gfs3_lookup_req args = { + { + 0, + }, + }; + int ret = -1, op_errno = 0; + gfs3_lookup_rsp rsp = { + 0, + }; + quotad_aggregator_state_t *state = NULL; + xlator_t *this = NULL; + + GF_VALIDATE_OR_GOTO("quotad-aggregator", req, err); + + this = THIS; + + args.bname = alloca(req->msg[0].iov_len); + args.xdata.xdata_val = alloca(req->msg[0].iov_len); + + ret = xdr_to_generic(req->msg[0], &args, (xdrproc_t)xdr_gfs3_lookup_req); + if (ret < 0) { + rsp.op_errno = EINVAL; + goto err; + } + + frame = quotad_aggregator_get_frame_from_req(req); + if (frame == NULL) { + rsp.op_errno = ENOMEM; + goto err; + } + + state = frame->root->state; + + GF_PROTOCOL_DICT_UNSERIALIZE(this, state->xdata, (args.xdata.xdata_val), + (args.xdata.xdata_len), ret, op_errno, err); + + ret = qd_nameless_lookup(this, frame, &args, state->xdata, + quotad_aggregator_lookup_cbk); + if (ret) { + rsp.op_errno = ret; + goto err; + } + + return ret; err: - rsp.op_ret = -1; - rsp.op_errno = op_errno; + rsp.op_ret = -1; + rsp.op_errno = op_errno; - quotad_aggregator_lookup_cbk (this, frame, &rsp); - return ret; + quotad_aggregator_lookup_cbk(this, frame, &rsp); + return ret; } int -quotad_aggregator_rpc_notify (rpcsvc_t *rpc, void *xl, rpcsvc_event_t event, - void *data) +quotad_aggregator_rpc_notify(rpcsvc_t *rpc, void *xl, rpcsvc_event_t event, + void *data) { - if (!xl || !data) { - gf_log_callingfn ("server", GF_LOG_WARNING, - "Calling rpc_notify without initializing"); - goto out; - } + if (!xl || !data) { + gf_log_callingfn("server", GF_LOG_WARNING, + "Calling rpc_notify without initializing"); + goto out; + } - switch (event) { + switch (event) { case RPCSVC_EVENT_ACCEPT: - break; + break; case RPCSVC_EVENT_DISCONNECT: - break; + break; default: - break; - } + break; + } out: - return 0; + return 0; } int -quotad_aggregator_init (xlator_t *this) +quotad_aggregator_init(xlator_t *this) { - quota_priv_t *priv = NULL; - int ret = -1; - - priv = this->private; - - if (priv->rpcsvc) { - /* Listener already created */ - return 0; - } - - ret = dict_set_str (this->options, "transport.address-family", "unix"); - if (ret) - goto out; - - ret = dict_set_str (this->options, "transport-type", "socket"); - if (ret) - goto out; - - ret = dict_set_str (this->options, "transport.socket.listen-path", - "/var/run/gluster/quotad.socket"); - if (ret) - goto out; - - /* RPC related */ - priv->rpcsvc = rpcsvc_init (this, this->ctx, this->options, 0); - if (priv->rpcsvc == NULL) { - gf_msg (this->name, GF_LOG_WARNING, 0, - Q_MSG_RPCSVC_INIT_FAILED, - "creation of rpcsvc failed"); - ret = -1; - goto out; - } + quota_priv_t *priv = NULL; + int ret = -1; - ret = rpcsvc_create_listeners (priv->rpcsvc, this->options, - this->name); - if (ret < 1) { - gf_msg (this->name, GF_LOG_WARNING, 0, - Q_MSG_RPCSVC_LISTENER_CREATION_FAILED, - "creation of listener failed"); - ret = -1; - goto out; - } - - priv->quotad_aggregator = "ad_aggregator_prog; - quotad_aggregator_prog.options = this->options; - - ret = rpcsvc_program_register (priv->rpcsvc, "ad_aggregator_prog, - _gf_false); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, 0, - Q_MSG_RPCSVC_REGISTER_FAILED, - "registration of program (name:%s, prognum:%d, " - "progver:%d) failed", quotad_aggregator_prog.progname, - quotad_aggregator_prog.prognum, - quotad_aggregator_prog.progver); - goto out; - } + priv = this->private; - ret = 0; + if (priv->rpcsvc) { + /* Listener already created */ + return 0; + } + + ret = dict_set_str(this->options, "transport.address-family", "unix"); + if (ret) + goto out; + + ret = dict_set_str(this->options, "transport-type", "socket"); + if (ret) + goto out; + + ret = dict_set_str(this->options, "transport.socket.listen-path", + "/var/run/gluster/quotad.socket"); + if (ret) + goto out; + + /* RPC related */ + priv->rpcsvc = rpcsvc_init(this, this->ctx, this->options, 0); + if (priv->rpcsvc == NULL) { + gf_msg(this->name, GF_LOG_WARNING, 0, Q_MSG_RPCSVC_INIT_FAILED, + "creation of rpcsvc failed"); + ret = -1; + goto out; + } + + ret = rpcsvc_create_listeners(priv->rpcsvc, this->options, this->name); + if (ret < 1) { + gf_msg(this->name, GF_LOG_WARNING, 0, + Q_MSG_RPCSVC_LISTENER_CREATION_FAILED, + "creation of listener failed"); + ret = -1; + goto out; + } + + priv->quotad_aggregator = "ad_aggregator_prog; + quotad_aggregator_prog.options = this->options; + + ret = rpcsvc_program_register(priv->rpcsvc, "ad_aggregator_prog, + _gf_false); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, 0, Q_MSG_RPCSVC_REGISTER_FAILED, + "registration of program (name:%s, prognum:%d, " + "progver:%d) failed", + quotad_aggregator_prog.progname, quotad_aggregator_prog.prognum, + quotad_aggregator_prog.progver); + goto out; + } + + ret = 0; out: - if (ret && priv->rpcsvc) { - GF_FREE (priv->rpcsvc); - priv->rpcsvc = NULL; - } + if (ret && priv->rpcsvc) { + GF_FREE(priv->rpcsvc); + priv->rpcsvc = NULL; + } - return ret; + return ret; } rpcsvc_actor_t quotad_aggregator_actors[GF_AGGREGATOR_MAXVALUE] = { - [GF_AGGREGATOR_NULL] = {"NULL", GF_AGGREGATOR_NULL, NULL, NULL, 0, - DRC_NA}, - [GF_AGGREGATOR_LOOKUP] = {"LOOKUP", GF_AGGREGATOR_NULL, - quotad_aggregator_lookup, NULL, 0, DRC_NA}, - [GF_AGGREGATOR_GETLIMIT] = {"GETLIMIT", GF_AGGREGATOR_GETLIMIT, - quotad_aggregator_getlimit, NULL, 0, DRC_NA}, + [GF_AGGREGATOR_NULL] = {"NULL", GF_AGGREGATOR_NULL, NULL, NULL, 0, DRC_NA}, + [GF_AGGREGATOR_LOOKUP] = {"LOOKUP", GF_AGGREGATOR_NULL, + quotad_aggregator_lookup, NULL, 0, DRC_NA}, + [GF_AGGREGATOR_GETLIMIT] = {"GETLIMIT", GF_AGGREGATOR_GETLIMIT, + quotad_aggregator_getlimit, NULL, 0, DRC_NA}, }; - struct rpcsvc_program quotad_aggregator_prog = { - .progname = "GlusterFS 3.3", - .prognum = GLUSTER_AGGREGATOR_PROGRAM, - .progver = GLUSTER_AGGREGATOR_VERSION, - .numactors = GF_AGGREGATOR_MAXVALUE, - .actors = quotad_aggregator_actors -}; + .progname = "GlusterFS 3.3", + .prognum = GLUSTER_AGGREGATOR_PROGRAM, + .progver = GLUSTER_AGGREGATOR_VERSION, + .numactors = GF_AGGREGATOR_MAXVALUE, + .actors = quotad_aggregator_actors}; diff --git a/xlators/features/quota/src/quotad-helpers.c b/xlators/features/quota/src/quotad-helpers.c index 70298fc87f5..be8f9080f14 100644 --- a/xlators/features/quota/src/quotad-helpers.c +++ b/xlators/features/quota/src/quotad-helpers.c @@ -11,97 +11,97 @@ #include "quotad-helpers.h" quotad_aggregator_state_t * -get_quotad_aggregator_state (xlator_t *this, rpcsvc_request_t *req) +get_quotad_aggregator_state(xlator_t *this, rpcsvc_request_t *req) { - quotad_aggregator_state_t *state = NULL; - xlator_t *active_subvol = NULL; - quota_priv_t *priv = NULL; + quotad_aggregator_state_t *state = NULL; + xlator_t *active_subvol = NULL; + quota_priv_t *priv = NULL; - state = (void *)GF_CALLOC (1, sizeof (*state), - gf_quota_mt_aggregator_state_t); - if (!state) - return NULL; + state = (void *)GF_CALLOC(1, sizeof(*state), + gf_quota_mt_aggregator_state_t); + if (!state) + return NULL; - state->this = THIS; - priv = this->private; + state->this = THIS; + priv = this->private; - LOCK (&priv->lock); - { - active_subvol = state->active_subvol = FIRST_CHILD (this); - } - UNLOCK (&priv->lock); + LOCK(&priv->lock); + { + active_subvol = state->active_subvol = FIRST_CHILD(this); + } + UNLOCK(&priv->lock); - if (active_subvol->itable == NULL) - active_subvol->itable = inode_table_new (4096, active_subvol); + if (active_subvol->itable == NULL) + active_subvol->itable = inode_table_new(4096, active_subvol); - state->itable = active_subvol->itable; + state->itable = active_subvol->itable; - state->pool = this->ctx->pool; + state->pool = this->ctx->pool; - return state; + return state; } void -quotad_aggregator_free_state (quotad_aggregator_state_t *state) +quotad_aggregator_free_state(quotad_aggregator_state_t *state) { - if (state->xdata) - dict_unref (state->xdata); + if (state->xdata) + dict_unref(state->xdata); - GF_FREE (state); + GF_FREE(state); } call_frame_t * -quotad_aggregator_alloc_frame (rpcsvc_request_t *req) +quotad_aggregator_alloc_frame(rpcsvc_request_t *req) { - call_frame_t *frame = NULL; - quotad_aggregator_state_t *state = NULL; - xlator_t *this = NULL; + call_frame_t *frame = NULL; + quotad_aggregator_state_t *state = NULL; + xlator_t *this = NULL; - GF_VALIDATE_OR_GOTO ("server", req, out); - GF_VALIDATE_OR_GOTO ("server", req->trans, out); - GF_VALIDATE_OR_GOTO ("server", req->svc, out); - GF_VALIDATE_OR_GOTO ("server", req->svc->ctx, out); + GF_VALIDATE_OR_GOTO("server", req, out); + GF_VALIDATE_OR_GOTO("server", req->trans, out); + GF_VALIDATE_OR_GOTO("server", req->svc, out); + GF_VALIDATE_OR_GOTO("server", req->svc->ctx, out); - this = req->svc->xl; + this = req->svc->xl; - frame = create_frame (this, req->svc->ctx->pool); - if (!frame) - goto out; + frame = create_frame(this, req->svc->ctx->pool); + if (!frame) + goto out; - state = get_quotad_aggregator_state (this, req); - if (!state) - goto out; + state = get_quotad_aggregator_state(this, req); + if (!state) + goto out; - frame->root->state = state; - frame->root->unique = 0; + frame->root->state = state; + frame->root->unique = 0; - frame->this = this; + frame->this = this; out: - return frame; + return frame; } call_frame_t * -quotad_aggregator_get_frame_from_req (rpcsvc_request_t *req) +quotad_aggregator_get_frame_from_req(rpcsvc_request_t *req) { - call_frame_t *frame = NULL; + call_frame_t *frame = NULL; - GF_VALIDATE_OR_GOTO ("server", req, out); + GF_VALIDATE_OR_GOTO("server", req, out); - frame = quotad_aggregator_alloc_frame (req); - if (!frame) - goto out; + frame = quotad_aggregator_alloc_frame(req); + if (!frame) + goto out; - frame->root->op = req->procnum; + frame->root->op = req->procnum; - frame->root->unique = req->xid; + frame->root->unique = req->xid; - frame->root->uid = req->uid; - frame->root->gid = req->gid; - frame->root->pid = req->pid; + frame->root->uid = req->uid; + frame->root->gid = req->gid; + frame->root->pid = req->pid; - frame->root->lk_owner = req->lk_owner; + frame->root->lk_owner = req->lk_owner; - frame->local = req; + frame->local = req; out: - return frame; + return frame; } diff --git a/xlators/features/quota/src/quotad.c b/xlators/features/quota/src/quotad.c index 2c9949fa127..1b61468f183 100644 --- a/xlators/features/quota/src/quotad.c +++ b/xlators/features/quota/src/quotad.c @@ -12,229 +12,229 @@ #include "common-utils.h" int -qd_notify (xlator_t *this, int32_t event, void *data, ...) +qd_notify(xlator_t *this, int32_t event, void *data, ...) { - switch (event) { + switch (event) { case GF_EVENT_PARENT_UP: - quotad_aggregator_init (this); - } + quotad_aggregator_init(this); + } - default_notify (this, event, data); - return 0; + default_notify(this, event, data); + return 0; } int32_t -mem_acct_init (xlator_t *this) +mem_acct_init(xlator_t *this) { - int ret = -1; - - if (!this) - return ret; + int ret = -1; - ret = xlator_mem_acct_init (this, gf_quota_mt_end + 1); + if (!this) + return ret; - if (0 != ret) { - gf_log (this->name, GF_LOG_WARNING, "Memory accounting " - "init failed"); - return ret; - } + ret = xlator_mem_acct_init(this, gf_quota_mt_end + 1); + if (0 != ret) { + gf_log(this->name, GF_LOG_WARNING, + "Memory accounting " + "init failed"); return ret; + } + + return ret; } int32_t -qd_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this, - int32_t op_ret, int32_t op_errno, inode_t *inode, - struct iatt *buf, dict_t *xdata, struct iatt *postparent) +qd_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, + int32_t op_errno, inode_t *inode, struct iatt *buf, dict_t *xdata, + struct iatt *postparent) { - quotad_aggregator_lookup_cbk_t lookup_cbk = NULL; - gfs3_lookup_rsp rsp = {0, }; + quotad_aggregator_lookup_cbk_t lookup_cbk = NULL; + gfs3_lookup_rsp rsp = { + 0, + }; - lookup_cbk = cookie; + lookup_cbk = cookie; - rsp.op_ret = op_ret; - rsp.op_errno = op_errno; + rsp.op_ret = op_ret; + rsp.op_errno = op_errno; - gf_stat_from_iatt (&rsp.postparent, postparent); + gf_stat_from_iatt(&rsp.postparent, postparent); - GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val), - rsp.xdata.xdata_len, rsp.op_errno, out); + GF_PROTOCOL_DICT_SERIALIZE(this, xdata, (&rsp.xdata.xdata_val), + rsp.xdata.xdata_len, rsp.op_errno, out); - gf_stat_from_iatt (&rsp.stat, buf); + gf_stat_from_iatt(&rsp.stat, buf); out: - lookup_cbk (this, frame, &rsp); + lookup_cbk(this, frame, &rsp); - GF_FREE (rsp.xdata.xdata_val); + GF_FREE(rsp.xdata.xdata_val); - inode_unref (inode); + inode_unref(inode); - return 0; + return 0; } xlator_t * -qd_find_subvol (xlator_t *this, char *volume_uuid) +qd_find_subvol(xlator_t *this, char *volume_uuid) { - xlator_list_t *child = NULL; - xlator_t *subvol = NULL; - char key[1024]; - char *optstr = NULL; - - if (!this || !volume_uuid) - goto out; - - for (child = this->children; child; child = child->next) { - snprintf(key, 1024, "%s.volume-id", child->xlator->name); - if (dict_get_str(this->options, key, &optstr) < 0) - continue; - - if (strcmp (optstr, volume_uuid) == 0) { - subvol = child->xlator; - break; - } + xlator_list_t *child = NULL; + xlator_t *subvol = NULL; + char key[1024]; + char *optstr = NULL; + + if (!this || !volume_uuid) + goto out; + + for (child = this->children; child; child = child->next) { + snprintf(key, 1024, "%s.volume-id", child->xlator->name); + if (dict_get_str(this->options, key, &optstr) < 0) + continue; + + if (strcmp(optstr, volume_uuid) == 0) { + subvol = child->xlator; + break; } + } out: - return subvol; + return subvol; } int -qd_nameless_lookup (xlator_t *this, call_frame_t *frame, gfs3_lookup_req *req, - dict_t *xdata, quotad_aggregator_lookup_cbk_t lookup_cbk) +qd_nameless_lookup(xlator_t *this, call_frame_t *frame, gfs3_lookup_req *req, + dict_t *xdata, quotad_aggregator_lookup_cbk_t lookup_cbk) { - gfs3_lookup_rsp rsp = {0, }; - int op_errno = 0, ret = -1; - loc_t loc = {0, }; - quotad_aggregator_state_t *state = NULL; - xlator_t *subvol = NULL; - char *volume_uuid = NULL; - - state = frame->root->state; - - frame->root->op = GF_FOP_LOOKUP; - - loc.inode = inode_new (state->itable); - if (loc.inode == NULL) { - op_errno = ENOMEM; - goto out; - } - - memcpy (loc.gfid, req->gfid, 16); - - ret = dict_get_str (xdata, "volume-uuid", &volume_uuid); - if (ret < 0) { - op_errno = EINVAL; - goto out; - } - - ret = dict_set_int8 (xdata, QUOTA_READ_ONLY_KEY, 1); - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, ENOMEM, - Q_MSG_ENOMEM, "dict set failed"); - ret = -ENOMEM; - goto out; - } - - subvol = qd_find_subvol (this, volume_uuid); - if (subvol == NULL) { - op_errno = EINVAL; - goto out; - } - - STACK_WIND_COOKIE (frame, qd_lookup_cbk, lookup_cbk, subvol, - subvol->fops->lookup, &loc, xdata); - return 0; + gfs3_lookup_rsp rsp = { + 0, + }; + int op_errno = 0, ret = -1; + loc_t loc = { + 0, + }; + quotad_aggregator_state_t *state = NULL; + xlator_t *subvol = NULL; + char *volume_uuid = NULL; + + state = frame->root->state; + + frame->root->op = GF_FOP_LOOKUP; + + loc.inode = inode_new(state->itable); + if (loc.inode == NULL) { + op_errno = ENOMEM; + goto out; + } + + memcpy(loc.gfid, req->gfid, 16); + + ret = dict_get_str(xdata, "volume-uuid", &volume_uuid); + if (ret < 0) { + op_errno = EINVAL; + goto out; + } + + ret = dict_set_int8(xdata, QUOTA_READ_ONLY_KEY, 1); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, ENOMEM, Q_MSG_ENOMEM, + "dict set failed"); + ret = -ENOMEM; + goto out; + } + + subvol = qd_find_subvol(this, volume_uuid); + if (subvol == NULL) { + op_errno = EINVAL; + goto out; + } + + STACK_WIND_COOKIE(frame, qd_lookup_cbk, lookup_cbk, subvol, + subvol->fops->lookup, &loc, xdata); + return 0; out: - rsp.op_ret = -1; - rsp.op_errno = op_errno; + rsp.op_ret = -1; + rsp.op_errno = op_errno; - lookup_cbk (this, frame, &rsp); + lookup_cbk(this, frame, &rsp); - inode_unref (loc.inode); - return 0; + inode_unref(loc.inode); + return 0; } int -qd_reconfigure (xlator_t *this, dict_t *options) +qd_reconfigure(xlator_t *this, dict_t *options) { - /* As of now quotad is restarted upon alteration of volfile */ - return 0; + /* As of now quotad is restarted upon alteration of volfile */ + return 0; } void -qd_fini (xlator_t *this) +qd_fini(xlator_t *this) { - quota_priv_t *priv = NULL; + quota_priv_t *priv = NULL; - if (this == NULL || this->private == NULL) - goto out; + if (this == NULL || this->private == NULL) + goto out; - priv = this->private; + priv = this->private; - if (priv->rpcsvc) { - GF_FREE (priv->rpcsvc); - priv->rpcsvc = NULL; - } + if (priv->rpcsvc) { + GF_FREE(priv->rpcsvc); + priv->rpcsvc = NULL; + } - GF_FREE (priv); + GF_FREE(priv); out: - return; + return; } int32_t -qd_init (xlator_t *this) +qd_init(xlator_t *this) { - int32_t ret = -1; - quota_priv_t *priv = NULL; - - if (NULL == this->children) { - gf_log (this->name, GF_LOG_ERROR, - "FATAL: quota (%s) not configured for min of 1 child", - this->name); - ret = -1; - goto err; - } + int32_t ret = -1; + quota_priv_t *priv = NULL; + + if (NULL == this->children) { + gf_log(this->name, GF_LOG_ERROR, + "FATAL: quota (%s) not configured for min of 1 child", + this->name); + ret = -1; + goto err; + } - QUOTA_ALLOC_OR_GOTO (priv, quota_priv_t, err); - LOCK_INIT (&priv->lock); + QUOTA_ALLOC_OR_GOTO(priv, quota_priv_t, err); + LOCK_INIT(&priv->lock); - this->private = priv; + this->private = priv; - ret = 0; + ret = 0; err: - if (ret) { - GF_FREE (priv); - } - return ret; + if (ret) { + GF_FREE(priv); + } + return ret; } -class_methods_t class_methods = { - .init = qd_init, - .fini = qd_fini, - .reconfigure = qd_reconfigure, - .notify = qd_notify -}; +class_methods_t class_methods = {.init = qd_init, + .fini = qd_fini, + .reconfigure = qd_reconfigure, + .notify = qd_notify}; -struct xlator_fops fops = { -}; +struct xlator_fops fops = {}; -struct xlator_cbks cbks = { -}; +struct xlator_cbks cbks = {}; struct volume_options options[] = { - { .key = {"transport-type"}, - .value = {"rpc", "rpc-over-rdma", "tcp", "socket", "ib-verbs", - "unix", "ib-sdp", "tcp/server", "ib-verbs/server", "rdma", - "rdma*([ \t]),*([ \t])socket", - "rdma*([ \t]),*([ \t])tcp", - "tcp*([ \t]),*([ \t])rdma", - "socket*([ \t]),*([ \t])rdma"}, - .type = GF_OPTION_TYPE_STR - }, - { .key = {"transport.*"}, - .type = GF_OPTION_TYPE_ANY, - }, - {.key = {NULL}} -}; + {.key = {"transport-type"}, + .value = {"rpc", "rpc-over-rdma", "tcp", "socket", "ib-verbs", "unix", + "ib-sdp", "tcp/server", "ib-verbs/server", "rdma", + "rdma*([ \t]),*([ \t])socket", "rdma*([ \t]),*([ \t])tcp", + "tcp*([ \t]),*([ \t])rdma", "socket*([ \t]),*([ \t])rdma"}, + .type = GF_OPTION_TYPE_STR}, + { + .key = {"transport.*"}, + .type = GF_OPTION_TYPE_ANY, + }, + {.key = {NULL}}}; -- cgit