From 9d93ec6c59934c09feefe7dd1e8864a954118852 Mon Sep 17 00:00:00 2001 From: Manikandan Selvaganesh Date: Mon, 13 Apr 2015 12:21:09 +0530 Subject: nfs / mount files : porting log messages to a new framework Backport of http://review.gluster.org/#/c/10210/ Porting log messages to a new framework for mount3udp_svc.c, mount3.c, mount3-auth.c files. Cherry picked from ee6cd10ce947787bf6ea589bca1cb259c4bb214d > Change-Id: I1e9cab500b6052bfac43c5ae1c82278e20d2f898 > BUG: 1194640 > Signed-off-by: Manikandan Selvaganesh > Reviewed-on: http://review.gluster.org/10210 > Tested-by: Gluster Build System > Reviewed-by: Niels de Vos Change-Id: I1e9cab500b6052bfac43c5ae1c82278e20d2f898 BUG: 1217722 Signed-off-by: Manikandan Selvaganesh Reviewed-on: http://review.gluster.org/10551 Tested-by: Gluster Build System Reviewed-by: jiffin tony Thottan Reviewed-by: Niels de Vos --- xlators/nfs/server/src/mount3-auth.c | 17 +- xlators/nfs/server/src/mount3.c | 524 +++++++++++++++++++-------------- xlators/nfs/server/src/mount3udp_svc.c | 32 +- 3 files changed, 339 insertions(+), 234 deletions(-) (limited to 'xlators/nfs/server') diff --git a/xlators/nfs/server/src/mount3-auth.c b/xlators/nfs/server/src/mount3-auth.c index 25246f96ab1..97c95cbfd23 100644 --- a/xlators/nfs/server/src/mount3-auth.c +++ b/xlators/nfs/server/src/mount3-auth.c @@ -39,6 +39,7 @@ #include "exports.h" #include "netgroups.h" #include "mem-pool.h" +#include "nfs-messages.h" /** * mnt3_auth_params_init -- Initialize the mount3 authorization parameters @@ -121,7 +122,8 @@ mnt3_auth_set_exports_auth (struct mnt3_auth_params *auth_params, /* Parse the exports file and set the auth parameter */ ret = exp_file_parse (filename, &expfile, auth_params->ms); if (ret < 0) { - gf_log (GF_MNT_AUTH, GF_LOG_ERROR, "Failed to load & parse file" + gf_msg (GF_MNT_AUTH, GF_LOG_ERROR, 0, NFS_MSG_LOAD_PARSE_ERROR, + "Failed to load & parse file" " %s, see logs for more information", filename); goto out; } @@ -159,8 +161,9 @@ mnt3_auth_set_netgroups_auth (struct mnt3_auth_params *auth_params, ngfile = ng_file_parse (filename); if (!ngfile) { - gf_log (GF_MNT_AUTH, GF_LOG_ERROR, "Failed to load file" - " %s, see logs for more information", filename); + gf_msg (GF_MNT_AUTH, GF_LOG_ERROR, 0, NFS_MSG_LOAD_PARSE_ERROR, + "Failed to load file %s, see logs for more " + "information", filename); ret = -1; goto out; } @@ -348,8 +351,8 @@ __netgroup_dict_search (dict_t *dict, char *key, data_t *val, void *data) /* If it was found, log the message, mark the search * params dict as found and return. */ - gf_log (GF_MNT_AUTH, GF_LOG_DEBUG, - "key %s was hashed and found", key); + gf_msg_debug (GF_MNT_AUTH, errno, "key %s was hashed " + "and found", key); ngsa->found = _gf_true; ngsa->found_entry = (struct netgroup_entry *)hdata->data; goto out; @@ -429,8 +432,8 @@ __export_dir_lookup_netgroup (dict_t *dict, char *key, data_t *val, /* We use ++key here because keys start with '@' for ngs */ ngentry = ng_file_get_netgroup (nfile, (key + 1)); if (!ngentry) { - gf_log (GF_MNT_AUTH, GF_LOG_DEBUG, "%s not found in %s", - key, nfile->filename); + gf_msg_debug (GF_MNT_AUTH, 0, "%s not found in %s", + key, nfile->filename); goto out; } diff --git a/xlators/nfs/server/src/mount3.c b/xlators/nfs/server/src/mount3.c index 9c443135d95..b053efd3af3 100644 --- a/xlators/nfs/server/src/mount3.c +++ b/xlators/nfs/server/src/mount3.c @@ -35,6 +35,7 @@ #include "glfs.h" #include "mount3-auth.h" #include "hashfn.h" +#include "nfs-messages.h" #include #include @@ -95,7 +96,8 @@ mnt3svc_submit_reply (rpcsvc_request_t *req, void *arg, mnt3_serializer sfunc) ms = (struct mount3_state *)rpcsvc_request_program_private (req); if (!ms) { - gf_log (GF_MNT, GF_LOG_ERROR, "mount state not found"); + gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, + NFS_MSG_MNT_STATE_NOT_FOUND, "mount state not found"); goto ret; } @@ -105,7 +107,8 @@ mnt3svc_submit_reply (rpcsvc_request_t *req, void *arg, mnt3_serializer sfunc) /* TODO: use 'xdrproc_t' instead of 'sfunc' to get the xdr-size */ iob = iobuf_get (ms->iobpool); if (!iob) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to get iobuf"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to get iobuf"); goto ret; } @@ -115,27 +118,31 @@ mnt3svc_submit_reply (rpcsvc_request_t *req, void *arg, mnt3_serializer sfunc) */ msglen = sfunc (outmsg, arg); if (msglen < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to encode message"); + gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ENCODE_MSG_FAIL, + "Failed to encode message"); goto ret; } outmsg.iov_len = msglen; iobref = iobref_new (); if (iobref == NULL) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to get iobref"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to get iobref"); goto ret; } ret = iobref_add (iobref, iob); if (ret) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to add iob to iobref"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to add iob to iobref"); goto ret; } /* Then, submit the message for transmission. */ ret = rpcsvc_submit_message (req, &outmsg, 1, NULL, 0, iobref); if (ret == -1) { - gf_log (GF_MNT, GF_LOG_ERROR, "Reply submission failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_REP_SUBMIT_FAIL, + "Reply submission failed"); goto ret; } @@ -187,8 +194,7 @@ __mountdict_insert (struct mount3_state *ms, struct mountentry *me) medata = bin_to_data (me, sizeof (*me)); dict_set (ms->mountdict, me->hashkey, medata); - gf_log (GF_MNT, GF_LOG_TRACE, "Inserted into mountdict: %s", - me->hashkey); + gf_msg_trace (GF_MNT, 0, "Inserted into mountdict: %s", me->hashkey); out: return; } @@ -307,8 +313,8 @@ __mount_read_rmtab (gf_store_handle_t *sh, struct list_head *mountlist, GF_ASSERT (sh && mountlist); if (!gf_store_locked_local (sh)) { - gf_log (GF_MNT, GF_LOG_WARNING, "Not reading unlocked %s", - sh->path); + gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_READ_LOCKED, + "Not reading unlocked %s", sh->path); return -1; } @@ -340,7 +346,8 @@ __mount_read_rmtab (gf_store_handle_t *sh, struct list_head *mountlist, dont_add: me = GF_CALLOC (1, sizeof (*me), gf_nfs_mt_mountentry); if (!me) { - gf_log (GF_MNT, GF_LOG_ERROR, "Out of memory"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, + NFS_MSG_NO_MEMORY, "Out of memory"); ret = -1; goto out; } @@ -362,9 +369,10 @@ dont_add: GF_FREE (value); idx++; - gf_log (GF_MNT, GF_LOG_TRACE, "Read entries %s:%s", me->hostname, me->exname); + gf_msg_trace (GF_MNT, 0, "Read entries %s:%s", + me->hostname, me->exname); } - gf_log (GF_MNT, GF_LOG_DEBUG, "Read %d entries from '%s'", idx, sh->path); + gf_msg_debug (GF_MNT, 0, "Read %d entries from '%s'", idx, sh->path); GF_FREE (me); out: return ret; @@ -382,14 +390,15 @@ __mount_rewrite_rmtab(struct mount3_state *ms, gf_store_handle_t *sh) unsigned int idx = 0; if (!gf_store_locked_local (sh)) { - gf_log (GF_MNT, GF_LOG_WARNING, "Not modifying unlocked %s", - sh->path); + gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_MODIFY_LOCKED, + "Not modifying unlocked %s", sh->path); return; } fd = gf_store_mkstemp (sh); if (fd == -1) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to open %s", sh->path); + gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Failed to open %s", sh->path); return; } @@ -407,16 +416,18 @@ __mount_rewrite_rmtab(struct mount3_state *ms, gf_store_handle_t *sh) idx++; } - gf_log (GF_MNT, GF_LOG_DEBUG, "Updated rmtab with %d entries", idx); + gf_msg_debug (GF_MNT, 0, "Updated rmtab with %d entries", idx); if (gf_store_rename_tmppath (sh)) - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to overwrite rwtab %s", - sh->path); + gf_msg (GF_MNT, GF_LOG_ERROR, errno, + NFS_MSG_RWTAB_OVERWRITE_FAIL, + "Failed to overwrite rwtab %s", sh->path); return; fail: - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to update %s", sh->path); + gf_msg (GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_UPDATE_FAIL, + "Failed to update %s", sh->path); gf_store_unlink_tmppath (sh); } @@ -455,8 +466,8 @@ mount_read_rmtab (struct mount3_state *ms) return; if (gf_store_lock (sh)) { - gf_log (GF_MNT, GF_LOG_WARNING, "Failed to lock '%s'", - nfs->rmtab); + gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_LOCK_FAIL, + "Failed to lock '%s'", nfs->rmtab); goto out; } @@ -500,22 +511,23 @@ mount_rewrite_rmtab (struct mount3_state *ms, char *new_rmtab) return; if (got_old_rmtab && gf_store_lock (sh)) { - gf_log (GF_MNT, GF_LOG_WARNING, "Not rewriting '%s'", - nfs->rmtab); + gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_REWRITE_ERROR, + "Not rewriting '%s'", nfs->rmtab); goto free_sh; } if (new_rmtab) { ret = gf_store_handle_new (new_rmtab, &nsh); if (ret) { - gf_log (GF_MNT, GF_LOG_WARNING, "Failed to open '%s'", - new_rmtab); + gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_OPEN_FAIL, + "Failed to open '%s'", new_rmtab); goto unlock_sh; } if (gf_store_lock (nsh)) { - gf_log (GF_MNT, GF_LOG_WARNING, "Not rewriting '%s'", - new_rmtab); + gf_msg (GF_MNT, GF_LOG_WARNING, 0, + NFS_MSG_REWRITE_ERROR, + "Not rewriting '%s'", new_rmtab); goto free_nsh; } } @@ -532,8 +544,9 @@ mount_rewrite_rmtab (struct mount3_state *ms, char *new_rmtab) /* replace the nfs->rmtab reference to the new rmtab */ rmtab = gf_strdup(new_rmtab); if (rmtab == NULL) { - gf_log (GF_MNT, GF_LOG_ERROR, "Out of memory, keeping " - "%s as rmtab", nfs->rmtab); + gf_msg (GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_NO_MEMORY, + "Out of memory, keeping %s as rmtab", + nfs->rmtab); } else { GF_FREE (nfs->rmtab); nfs->rmtab = rmtab; @@ -619,8 +632,9 @@ mnt3svc_update_mountlist (struct mount3_state *ms, rpcsvc_request_t *req, { /* in case locking fails, we just don't write the rmtab */ if (update_rmtab && gf_store_lock (sh)) { - gf_log (GF_MNT, GF_LOG_WARNING, "Failed to lock '%s'" - ", changes will not be written", nfs->rmtab); + gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_LOCK_FAIL, + "Failed to lock '%s', changes will not be " + "written", nfs->rmtab); } else if (update_rmtab) { __mount_read_rmtab (sh, &ms->mountlist, _gf_false); } @@ -697,8 +711,8 @@ __mnt3_build_mountid_from_path (const char *path, uuid_t mountid) hashed_path = SuperFastHash (path, strlen (path)); if (hashed_path == 1) { - gf_log (GF_MNT, GF_LOG_WARNING, "failed to hash path: %s", - path); + gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_HASH_PATH_FAIL, + "failed to hash path: %s", path); goto out; } @@ -722,8 +736,8 @@ __mnt3_get_mount_id (xlator_t *mntxl, uuid_t mountid) hashed_path = SuperFastHash (mntxl->name, strlen (mntxl->name)); if (hashed_path == 1) { - gf_log (GF_MNT, GF_LOG_WARNING, "failed to hash xlator name: %s", - mntxl->name); + gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_HASH_XLATOR_FAIL, + "failed to hash xlator name: %s", mntxl->name); goto out; } @@ -762,13 +776,17 @@ mnt3svc_lookup_mount_cbk (call_frame_t *frame, void *cookie, mntxl = (xlator_t *)cookie; ms = (struct mount3_state *)rpcsvc_request_program_private (req); if (!ms) { - gf_log (GF_MNT, GF_LOG_ERROR, "mount state not found"); + gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, + NFS_MSG_MNT_STATE_NOT_FOUND, + "mount state not found"); op_ret = -1; op_errno = EINVAL; } if (op_ret == -1) { - gf_log (GF_NFS, GF_LOG_ERROR, "error=%s", strerror (op_errno)); + gf_msg (GF_NFS, GF_LOG_ERROR, op_errno, + NFS_MSG_LOOKUP_MNT_ERROR, "error=%s", + strerror (op_errno)); status = mnt3svc_errno_to_mnterr (op_errno); } if (status != MNT3_OK) @@ -776,7 +794,8 @@ mnt3svc_lookup_mount_cbk (call_frame_t *frame, void *cookie, path = GF_CALLOC (PATH_MAX, sizeof (char), gf_nfs_mt_char); if (!path) { - gf_log (GF_MNT, GF_LOG_ERROR, "Out of memory"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Out of memory"); goto xmit_res; } @@ -794,8 +813,8 @@ mnt3svc_lookup_mount_cbk (call_frame_t *frame, void *cookie, xmit_res: nfs3_fh_to_str (&fh, fhstr, sizeof (fhstr)); - gf_log (GF_MNT, GF_LOG_DEBUG, "MNT reply: fh %s, status: %d", fhstr, - status); + gf_msg_debug (GF_MNT, 0, "MNT reply: fh %s, status: %d", fhstr, + status); if (op_ret == 0) { svc = rpcsvc_request_service (req); autharrlen = rpcsvc_auth_array (svc, mntxl->name, autharr, @@ -873,7 +892,8 @@ mnt3svc_mount_inode (rpcsvc_request_t *req, struct mount3_state *ms, ret = nfs_inode_loc_fill (exportinode, &exportloc, NFS_RESOLVE_EXIST); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, "Loc fill failed for export inode" + gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_INODE_LOC_FILL_ERROR, + "Loc fill failed for export inode" ": gfid %s, volume: %s", uuid_utoa (exportinode->gfid), xl->name); goto err; @@ -912,7 +932,9 @@ mnt3svc_volume_mount (rpcsvc_request_t *req, struct mount3_state *ms, rootgfid[15] = 1; exportinode = inode_find (exp->vol->itable, rootgfid); if (!exportinode) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to get root inode"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOENT, + NFS_MSG_GET_ROOT_INODE_FAIL, + "Failed to get root inode"); ret = -ENOENT; goto err; } @@ -1047,8 +1069,9 @@ __mnt3_resolve_export_subdir_comp (mnt3_resolve_t *mres) ret = nfs_entry_loc_fill (mres->exp->vol->itable, gfid, nextcomp, &mres->resolveloc, NFS_RESOLVE_CREATE); if ((ret < 0) && (ret != -2)) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to resolve and create " - "inode: parent gfid %s, entry %s", + gf_msg (GF_MNT, GF_LOG_ERROR, EFAULT, + NFS_MSG_RESOLVE_INODE_FAIL, "Failed to resolve and " + "create inode: parent gfid %s, entry %s", uuid_utoa (gfid), nextcomp); ret = -EFAULT; goto err; @@ -1058,8 +1081,8 @@ __mnt3_resolve_export_subdir_comp (mnt3_resolve_t *mres) if (IA_ISLNK (mres->resolveloc.inode->ia_type)) { ret = nfs_readlink (mres->mstate->nfsx, mres->exp->vol, &nfu, &mres->resolveloc, mnt3_readlink_cbk, mres); - gf_log (GF_MNT, GF_LOG_DEBUG, "Symlink found , need to resolve" - " into directory handle"); + gf_msg_debug (GF_MNT, 0, "Symlink found , need to resolve" + " into directory handle"); goto err; } ret = nfs_lookup (mres->mstate->nfsx, mres->exp->vol, &nfu, @@ -1094,7 +1117,8 @@ mnt3_resolve_subdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, ms = mres->mstate; mntxl = (xlator_t *)cookie; if (op_ret == -1) { - gf_log (GF_NFS, GF_LOG_ERROR, "path=%s (%s)", + gf_msg (GF_NFS, GF_LOG_ERROR, op_errno, + NFS_MSG_RESOLVE_SUBDIR_FAIL, "path=%s (%s)", mres->resolveloc.path, strerror (op_errno)); mntstat = mnt3svc_errno_to_mnterr (op_errno); goto err; @@ -1115,7 +1139,8 @@ mnt3_resolve_subdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, mres->exp->fullpath = GF_CALLOC (alloclen, sizeof (char), gf_nfs_mt_char); if (!mres->exp->fullpath) { - gf_log (GF_MNT, GF_LOG_CRITICAL, "Allocation failed."); + gf_msg (GF_MNT, GF_LOG_CRITICAL, ENOMEM, + NFS_MSG_NO_MEMORY, "Allocation failed."); goto err; } snprintf (mres->exp->fullpath, alloclen, "%s%s", @@ -1129,16 +1154,16 @@ mnt3_resolve_subdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, FALSE); if (authcode != 0) { mntstat = MNT3ERR_ACCES; - gf_log (GF_MNT, GF_LOG_DEBUG, - "Client mount not allowed"); + gf_msg_debug (GF_MNT, 0, "Client mount not allowed"); op_ret = -1; goto err; } path = GF_CALLOC (PATH_MAX, sizeof (char), gf_nfs_mt_char); if (!path) { - gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation " - "failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, + NFS_MSG_NO_MEMORY, + "Memory allocation failed"); goto err; } /* Build mountid from the authorized path and stick it in the @@ -1160,8 +1185,7 @@ mnt3_resolve_subdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, } err: if (op_ret == -1) { - gf_log (GF_MNT, GF_LOG_DEBUG, "Mount reply status: %d", - mntstat); + gf_msg_debug (GF_MNT, 0, "Mount reply status: %d", mntstat); svc = rpcsvc_request_service (mres->req); autharrlen = rpcsvc_auth_array (svc, mntxl->name, autharr, 10); @@ -1238,10 +1262,11 @@ mnt3_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, /* Resolving into absolute path */ ret = gf_build_absolute_path (parent_path, relative_path, &absolute_path); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, "Cannot resolve symlink, path" - "is out of boundary from current location %s" - "and with relative path %s pointed by symlink", - parent_path, relative_path); + gf_msg (GF_MNT, GF_LOG_ERROR, ret, + NFS_MSG_RESOLVE_SYMLINK_ERROR, + "Cannot resolve symlink, path is out of boundary " + "from current location %s and with relative path " + "%s pointed by symlink", parent_path, relative_path); goto mnterr; } @@ -1262,9 +1287,9 @@ mnt3_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, if (strlen (mres->remainingdir) > 0) strcat (real_loc, mres->remainingdir); - gf_log (GF_MNT, GF_LOG_DEBUG, "Resolved path is : %s%s " - "and actual mount path is %s", - absolute_path, mres->remainingdir, real_loc); + gf_msg_debug (GF_MNT, 0, "Resolved path is : %s%s " + "and actual mount path is %s", + absolute_path, mres->remainingdir, real_loc); /* After the resolving the symlink , parsing should be done * for the populated mount path @@ -1272,7 +1297,7 @@ mnt3_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this, ret = mnt3_parse_dir_exports (mres->req, mres->mstate, real_loc); if (ret) { - gf_log (GF_MNT, GF_LOG_ERROR, + gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_RESOLVE_ERROR, "Resolved into an unknown path %s%s " "from the current location of symlink %s", absolute_path, mres->remainingdir, parent_path); @@ -1290,7 +1315,7 @@ mnterr: mntstat = mnt3svc_errno_to_mnterr (-ret); mnt3svc_mnt_error_reply (mres->req, mntstat); } else - gf_log (GF_MNT, GF_LOG_CRITICAL, + gf_msg (GF_MNT, GF_LOG_CRITICAL, EINVAL, NFS_MSG_INVALID_ENTRY, "mres == NULL, this should *never* happen"); if (absolute_path) GF_FREE (absolute_path); @@ -1334,8 +1359,10 @@ __mnt3_resolve_subdir (mnt3_resolve_t *mres) ret = nfs_entry_loc_fill (mres->exp->vol->itable, rootgfid, firstcomp, &mres->resolveloc, NFS_RESOLVE_CREATE); if ((ret < 0) && (ret != -2)) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to resolve and create " - "inode for volume root: %s", mres->exp->vol->name); + gf_msg (GF_MNT, GF_LOG_ERROR, EFAULT, + NFS_MSG_RESOLVE_INODE_FAIL, "Failed to resolve and " + "create inode for volume root: %s", + mres->exp->vol->name); ret = -EFAULT; goto err; } @@ -1344,8 +1371,8 @@ __mnt3_resolve_subdir (mnt3_resolve_t *mres) if (IA_ISLNK (mres->resolveloc.inode->ia_type)) { ret = nfs_readlink (mres->mstate->nfsx, mres->exp->vol, &nfu, &mres->resolveloc, mnt3_readlink_cbk, mres); - gf_log (GF_MNT, GF_LOG_DEBUG, "Symlink found , need to resolve " - "into directory handle"); + gf_msg_debug (GF_MNT, 0, "Symlink found , need to resolve " + "into directory handle"); goto err; } ret = nfs_lookup (mres->mstate->nfsx, mres->exp->vol, &nfu, @@ -1404,7 +1431,8 @@ mnt3_verify_auth (struct sockaddr_in *client_addr, struct mnt3_export *export) if ((NULL == client_addr) || (NULL == export) || (NULL == export->hostspec)) { - gf_log (GF_MNT, GF_LOG_ERROR, "Invalid argument"); + gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Invalid argument"); return retvalue; } @@ -1415,7 +1443,8 @@ mnt3_verify_auth (struct sockaddr_in *client_addr, struct mnt3_export *export) * TODO: IPv6 subnetwork i.e. AF_INET6. */ if (client_addr->sin_family != AF_INET) { - gf_log (GF_MNT, GF_LOG_ERROR, + gf_msg (GF_MNT, GF_LOG_ERROR, EAFNOSUPPORT, + NFS_MSG_UNSUPPORTED_VERSION, "Only IPv4 is supported for subdir-auth"); return retvalue; } @@ -1437,15 +1466,16 @@ mnt3_verify_auth (struct sockaddr_in *client_addr, struct mnt3_export *export) * getaddrinfo() FAILED for the host IP addr. Continue * to search other allowed hosts in the hostspec list. */ - gf_log (GF_MNT, GF_LOG_DEBUG, - "getaddrinfo: %s\n", gai_strerror (ret)); + gf_msg_debug (GF_MNT, 0, "getaddrinfo: %s\n", + gai_strerror (ret)); host = host->next; continue; } allowed_addr = (struct sockaddr_in *)(allowed_addrinfo->ai_addr); if (NULL == allowed_addr) { - gf_log (GF_MNT, GF_LOG_ERROR, "Invalid structure"); + gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, + NFS_MSG_INVALID_ENTRY, "Invalid structure"); break; } @@ -1487,15 +1517,17 @@ mnt3_resolve_subdir (rpcsvc_request_t *req, struct mount3_state *ms, if (NULL != exp->hostspec) { ret = mnt3_verify_auth (sin, exp); if (0 != ret) { - gf_log (GF_MNT,GF_LOG_ERROR, - "AUTH verification failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, EACCES, + NFS_MSG_AUTH_VERIFY_FAILED, + "AUTH verification failed"); return ret; } } mres = GF_CALLOC (1, sizeof (mnt3_resolve_t), gf_nfs_mt_mnt3_resolve); if (!mres) { - gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); goto err; } @@ -1513,7 +1545,7 @@ mnt3_resolve_subdir (rpcsvc_request_t *req, struct mount3_state *ms, mres->parentfh = pfh; ret = __mnt3_resolve_subdir (mres); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, + gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RESOLVE_SUBDIR_FAIL, "Failed to resolve export dir: %s", mres->exp->expname); GF_FREE (mres); } @@ -1539,7 +1571,7 @@ mnt3_resolve_export_subdir (rpcsvc_request_t *req, struct mount3_state *ms, ret = mnt3_resolve_subdir (req, ms, exp, volume_subdir); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, + gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RESOLVE_SUBDIR_FAIL, "Failed to resolve export dir: %s", exp->expname); goto err; } @@ -1592,13 +1624,13 @@ mnt3_mntpath_to_export (struct mount3_state *ms, const char *dirpath, if (mnt3_match_dirpath_export (exp->expname, dirpath, export_parsing_match)) { found = exp; - gf_log (GF_MNT, GF_LOG_DEBUG, "Found export volume: " - "%s", exp->vol->name); + gf_msg_debug (GF_MNT, 0, "Found export volume: " + "%s", exp->vol->name); goto foundexp; } } - gf_log (GF_MNT, GF_LOG_DEBUG, "Export not found"); + gf_msg_debug (GF_MNT, 0, "Export not found"); foundexp: UNLOCK (&ms->mountlock); return found; @@ -1616,13 +1648,15 @@ mnt3_check_client_net_check (rpcsvc_t *svc, char *expvol, ret = rpcsvc_auth_check (svc, expvol, ipaddr); if (ret == RPCSVC_AUTH_REJECT) { - gf_log (GF_MNT, GF_LOG_INFO, "Peer %s not allowed", ipaddr); + gf_msg (GF_MNT, GF_LOG_INFO, 0, NFS_MSG_PEER_NOT_ALLOWED, + "Peer %s not allowed", ipaddr); goto err; } ret = rpcsvc_transport_privport_check (svc, expvol, port); if (ret == RPCSVC_AUTH_REJECT) { - gf_log (GF_MNT, GF_LOG_INFO, "Peer %s rejected. Unprivileged " + gf_msg (GF_MNT, GF_LOG_INFO, errno, NFS_MSG_PEER_NOT_ALLOWED, + "Peer %s rejected. Unprivileged " "port %d not allowed", ipaddr, port); goto err; } @@ -1655,9 +1689,9 @@ mnt3_check_client_net_tcp (rpcsvc_request_t *req, char *volname) ret = rpcsvc_transport_peeraddr (trans, peer, RPCSVC_PEER_STRLEN, &sock_union.storage, socksize); if (ret != 0) { - gf_log (GF_MNT, GF_LOG_WARNING, - "Failed to get peer addr: %s", - gai_strerror (ret)); + gf_msg (GF_MNT, GF_LOG_WARNING, ENOENT, + NFS_MSG_GET_PEER_ADDR_FAIL, "Failed to get peer " + "addr: %s", gai_strerror (ret)); ret = RPCSVC_AUTH_REJECT; goto err; } @@ -1731,21 +1765,21 @@ mnt3_parse_dir_exports (rpcsvc_request_t *req, struct mount3_state *ms, goto err; if (!nfs_subvolume_started (nfs, exp->vol)) { - gf_log (GF_MNT, GF_LOG_DEBUG, - "Volume %s not started", exp->vol->name); + gf_msg_debug (GF_MNT, 0, "Volume %s not started", + exp->vol->name); goto err; } ret = mnt3_check_client_net_tcp (req, exp->vol->name); if (ret == RPCSVC_AUTH_REJECT) { - gf_log (GF_MNT, GF_LOG_DEBUG, "Client mount not allowed"); + gf_msg_debug (GF_MNT, 0, "Client mount not allowed"); ret = -EACCES; goto err; } ret = mnt3_resolve_subdir (req, ms, exp, subdir); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, + gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RESOLVE_SUBDIR_FAIL, "Failed to resolve export dir: %s", subdir); goto err; } @@ -1767,12 +1801,13 @@ mnt3_find_export (rpcsvc_request_t *req, char *path, struct mnt3_export **e) ms = (struct mount3_state *) rpcsvc_request_program_private (req); if (!ms) { - gf_log (GF_MNT, GF_LOG_ERROR, "Mount state not present"); + gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, + NFS_MSG_MNT_STATE_NOT_FOUND, "Mount state not present"); rpcsvc_request_seterr (req, SYSTEM_ERR); goto err; } - gf_log (GF_MNT, GF_LOG_DEBUG, "dirpath: %s", path); + gf_msg_debug (GF_MNT, 0, "dirpath: %s", path); exp = mnt3_mntpath_to_export (ms, path, _gf_false); if (exp) { ret = 0; @@ -1842,7 +1877,8 @@ _mnt3_get_host_from_peer (const char *peer_addr) colon = strchr (peer_addr, ':'); if (!colon) { - gf_log (GF_MNT, GF_LOG_ERROR, "Bad peer %s", peer_addr); + gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_BAD_PEER, + "Bad peer %s", peer_addr); goto out; } @@ -1850,7 +1886,8 @@ _mnt3_get_host_from_peer (const char *peer_addr) if (host_len < RPCSVC_PEER_STRLEN) part = gf_strndup (peer_addr, host_len); else - gf_log (GF_MNT, GF_LOG_ERROR, "Peer too long %s", peer_addr); + gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_PEER_TOO_LONG, + "Peer too long %s", peer_addr); out: return part; } @@ -1926,8 +1963,8 @@ _mnt3_authenticate_req (struct mount3_state *ms, rpcsvc_request_t *req, /* Check if the filehandle is cached */ fh_cached = mnt3_check_cached_fh (ms, fh, host_addr_ip, is_write_op); if (fh_cached) { - gf_log (GF_MNT, GF_LOG_TRACE, "Found cached FH for %s", - host_addr_ip); + gf_msg_trace (GF_MNT, 0, "Found cached FH for %s", + host_addr_ip); auth_status_code = 0; goto free_and_out; } @@ -1961,13 +1998,15 @@ _mnt3_authenticate_req (struct mount3_state *ms, rpcsvc_request_t *req, if (!fh && auth_status_code == 0) { *authorized_export = gf_strdup (pathdup); if (!*authorized_export) - gf_log (GF_MNT, GF_LOG_CRITICAL, + gf_msg (GF_MNT, GF_LOG_CRITICAL, ENOMEM, + NFS_MSG_NO_MEMORY, "Allocation error when copying " "authorized path"); *authorized_host = gf_strdup (auth_host); if (!*authorized_host) - gf_log (GF_MNT, GF_LOG_CRITICAL, + gf_msg (GF_MNT, GF_LOG_CRITICAL, ENOMEM, + NFS_MSG_NO_MEMORY, "Allocation error when copying " "authorized host"); } @@ -2087,21 +2126,24 @@ mnt3svc_mnt (rpcsvc_request_t *req) pvec.iov_len = MNTPATHLEN; ret = xdr_to_mountpath (pvec, req->msg[0]); if (ret == -1) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to decode args"); + gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Failed to decode args"); rpcsvc_request_seterr (req, GARBAGE_ARGS); goto rpcerr; } ms = (struct mount3_state *)rpcsvc_request_program_private (req); if (!ms) { - gf_log (GF_MNT, GF_LOG_ERROR, "Mount state not present"); + gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, + NFS_MSG_MNT_STATE_NOT_FOUND, + "Mount state not present"); rpcsvc_request_seterr (req, SYSTEM_ERR); ret = -1; goto rpcerr; } nfs = (struct nfs_state *)ms->nfsx->private; - gf_log (GF_MNT, GF_LOG_DEBUG, "dirpath: %s", path); + gf_msg_debug (GF_MNT, 0, "dirpath: %s", path); ret = mnt3_find_export (req, path, &exp); if (ret < 0) { mntstat = mnt3svc_errno_to_mnterr (-ret); @@ -2123,8 +2165,8 @@ mnt3svc_mnt (rpcsvc_request_t *req) } if (!nfs_subvolume_started (nfs, exp->vol)) { - gf_log (GF_MNT, GF_LOG_DEBUG, "Volume %s not started", - exp->vol->name); + gf_msg_debug (GF_MNT, 0, "Volume %s not started", + exp->vol->name); ret = -1; mntstat = MNT3ERR_NOENT; goto mnterr; @@ -2133,7 +2175,7 @@ mnt3svc_mnt (rpcsvc_request_t *req) ret = mnt3_check_client_net_tcp (req, exp->vol->name); if (ret == RPCSVC_AUTH_REJECT) { mntstat = MNT3ERR_ACCES; - gf_log (GF_MNT, GF_LOG_DEBUG, "Client mount not allowed"); + gf_msg_debug (GF_MNT, 0, "Client mount not allowed"); ret = -1; goto mnterr; } @@ -2145,7 +2187,7 @@ mnt3svc_mnt (rpcsvc_request_t *req) NULL, _gf_false); if (authcode != 0) { mntstat = MNT3ERR_ACCES; - gf_log (GF_MNT, GF_LOG_DEBUG, "Client mount not allowed"); + gf_msg_debug (GF_MNT, 0, "Client mount not allowed"); ret = -1; goto mnterr; } @@ -2171,7 +2213,8 @@ mnt3svc_null (rpcsvc_request_t *req) struct iovec dummyvec = {0, }; if (!req) { - gf_log (GF_MNT, GF_LOG_ERROR, "Got NULL request!"); + gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, + "Got NULL request!"); return 0; } rpcsvc_submit_generic (req, &dummyvec, 1, NULL, 0, NULL); @@ -2196,13 +2239,13 @@ __build_mountlist (struct mount3_state *ms, int *count) mount_read_rmtab(ms); *count = 0; - gf_log (GF_MNT, GF_LOG_DEBUG, "Building mount list:"); + gf_msg_debug (GF_MNT, 0, "Building mount list:"); list_for_each_entry (me, &ms->mountlist, mlist) { namelen = strlen (me->exname); mlist = GF_CALLOC (1, sizeof (*mlist), gf_nfs_mt_mountbody); if (!mlist) { - gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation" - " failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, + NFS_MSG_NO_MEMORY, "Memory allocation failed"); goto free_list; } if (!first) @@ -2211,8 +2254,8 @@ __build_mountlist (struct mount3_state *ms, int *count) mlist->ml_directory = GF_CALLOC (namelen + 2, sizeof (char), gf_nfs_mt_char); if (!mlist->ml_directory) { - gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation" - " failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, + NFS_MSG_NO_MEMORY, "Memory allocation failed"); goto free_list; } @@ -2222,15 +2265,15 @@ __build_mountlist (struct mount3_state *ms, int *count) mlist->ml_hostname = GF_CALLOC (namelen + 2, sizeof (char), gf_nfs_mt_char); if (!mlist->ml_hostname) { - gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation" - " failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, + NFS_MSG_NO_MEMORY, "Memory allocation failed"); goto free_list; } strcat (mlist->ml_hostname, me->hostname); - gf_log (GF_MNT, GF_LOG_DEBUG, "mount entry: dir: %s, host: %s", - mlist->ml_directory, mlist->ml_hostname); + gf_msg_debug (GF_MNT, 0, "mount entry: dir: %s, host: %s", + mlist->ml_directory, mlist->ml_hostname); if (prev) { prev->ml_next = mlist; prev = mlist; @@ -2357,15 +2400,15 @@ mnt3svc_umount (struct mount3_state *ms, char *dirpath, char *hostname) * the one we're looking for. */ if (ret == -1) {/* Not found in list. */ - gf_log (GF_MNT, GF_LOG_TRACE, "Export not found"); + gf_msg_trace (GF_MNT, 0, "Export not found"); goto out_unlock; } if (!me) goto out_unlock; - gf_log (GF_MNT, GF_LOG_DEBUG, "Unmounting: dir %s, host: %s", - me->exname, me->hostname); + gf_msg_debug (GF_MNT, 0, "Unmounting: dir %s, host: %s", + me->exname, me->hostname); list_del (&me->mlist); GF_FREE (me); @@ -2406,14 +2449,16 @@ mnt3svc_umnt (rpcsvc_request_t *req) pvec.iov_len = MNTPATHLEN; ret = xdr_to_mountpath (pvec, req->msg[0]); if (ret == -1) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed decode args"); + gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ARGS_DECODE_ERROR, + "Failed decode args"); rpcsvc_request_seterr (req, GARBAGE_ARGS); goto rpcerr; } ms = (struct mount3_state *)rpcsvc_request_program_private (req); if (!ms) { - gf_log (GF_MNT, GF_LOG_ERROR, "Mount state not present"); + gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, + NFS_MSG_MNT_STATE_NOT_FOUND, "Mount state not present"); rpcsvc_request_seterr (req, SYSTEM_ERR); ret = -1; goto rpcerr; @@ -2421,8 +2466,9 @@ mnt3svc_umnt (rpcsvc_request_t *req) ret = rpcsvc_transport_peername (req->trans, hostname, MNTPATHLEN); if (ret != 0) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to get remote name: %s", - gai_strerror (ret)); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOENT, + NFS_MSG_GET_REMOTE_NAME_FAIL, + "Failed to get remote name: %s", gai_strerror (ret)); goto rpcerr; } @@ -2430,8 +2476,8 @@ mnt3svc_umnt (rpcsvc_request_t *req) if (colon) { *colon= '\0'; } - gf_log (GF_MNT, GF_LOG_DEBUG, "dirpath: %s, hostname: %s", dirpath, - hostname); + gf_msg_debug (GF_MNT, 0, "dirpath: %s, hostname: %s", dirpath, + hostname); ret = mnt3svc_umount (ms, dirpath, hostname); if (ret == -1) { @@ -2502,7 +2548,8 @@ mnt3svc_umntall (rpcsvc_request_t *req) ms = (struct mount3_state *)rpcsvc_request_program_private (req); if (!ms) { - gf_log (GF_MNT, GF_LOG_ERROR, "Mount state not present"); + gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, + NFS_MSG_MNT_STATE_NOT_FOUND, "Mount state not present"); rpcsvc_request_seterr (req, SYSTEM_ERR); goto rpcerr; } @@ -2548,8 +2595,8 @@ mnt3_xlchildren_to_exports (rpcsvc_t *svc, struct mount3_state *ms) namelen = strlen (ent->expname) + 1; elist = GF_CALLOC (1, sizeof (*elist), gf_nfs_mt_exportnode); if (!elist) { - gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation" - " failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, + NFS_MSG_NO_MEMORY, "Memory allocation failed"); goto free_list; } if (!first) @@ -2557,8 +2604,8 @@ mnt3_xlchildren_to_exports (rpcsvc_t *svc, struct mount3_state *ms) elist->ex_dir = GF_CALLOC (namelen + 2, sizeof (char), gf_nfs_mt_char); if (!elist->ex_dir) { - gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation" - " failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, + NFS_MSG_NO_MEMORY, "Memory allocation failed"); goto free_list; } strcpy (elist->ex_dir, ent->expname); @@ -2568,8 +2615,8 @@ mnt3_xlchildren_to_exports (rpcsvc_t *svc, struct mount3_state *ms) elist->ex_groups = GF_CALLOC (1, sizeof (struct groupnode), gf_nfs_mt_groupnode); if (!elist->ex_groups) { - gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation" - " failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, + NFS_MSG_NO_MEMORY, "Memory allocation failed"); goto free_list; } /*This check has to be done after checking @@ -2616,7 +2663,8 @@ mnt3svc_export (rpcsvc_request_t *req) ms = (struct mount3_state *)rpcsvc_request_program_private (req); if (!ms) { - gf_log (GF_MNT, GF_LOG_ERROR, "mount state not found"); + gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, + NFS_MSG_MNT_STATE_NOT_FOUND, "mount state not found"); rpcsvc_request_seterr (req, SYSTEM_ERR); goto err; } @@ -2696,7 +2744,8 @@ __mnt3udp_get_export_subdir_inode (struct svc_req *req, char *subdir, struct sockaddr_in *sin = svc_getcaller (req->rq_xprt); ret = mnt3_verify_auth (sin, exp); if (ret) { - gf_log (GF_MNT,GF_LOG_ERROR, + gf_msg (GF_MNT, GF_LOG_ERROR, EACCES, + NFS_MSG_AUTH_VERIFY_FAILED, "AUTH(nfs.export-dir) verification failed"); errno = EACCES; return NULL; @@ -2848,7 +2897,8 @@ nfs3_rootfh (struct svc_req *req, xlator_t *nfsx, default: /* Never reachable */ - gf_log (GF_MNT, GF_LOG_ERROR, "Unknown MOUNT3 type"); + gf_msg (GF_MNT, GF_LOG_ERROR, EFAULT, NFS_MSG_UNKNOWN_MNT_TYPE, + "Unknown MOUNT3 type"); errno = EFAULT; goto err; } @@ -2949,7 +2999,8 @@ mnt3_export_fill_hostspec (struct host_auth_spec* hostspec, const char* hostip) */ ipdupstr = gf_strdup (hostip); if (NULL == ipdupstr) { - gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); goto err; } @@ -2960,14 +3011,15 @@ mnt3_export_fill_hostspec (struct host_auth_spec* hostspec, const char* hostip) length = strlen (ip); if ((!valid_ipv4_address (ip, (int)length, _gf_false)) && (!valid_host_name (ip, (int)length))) { - gf_log (GF_MNT, GF_LOG_ERROR, + gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, NFS_MSG_INVALID_ENTRY, "Invalid hostname or IPv4 address: %s", ip); goto err; } hostspec->host_addr = gf_strdup (ip); if (NULL == hostspec->host_addr) { - gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); goto err; } @@ -2991,8 +3043,9 @@ mnt3_export_fill_hostspec (struct host_auth_spec* hostspec, const char* hostip) prefixlen = strtol (token, &endptr, 10); if ((errno != 0) || (*endptr != '\0') || (prefixlen < 0) || (prefixlen > IPv4_ADDR_SIZE)) { - gf_log (THIS->name, GF_LOG_WARNING, - "Invalid IPv4 subnetwork mask"); + gf_msg (THIS->name, GF_LOG_WARNING, EINVAL, + NFS_MSG_INVALID_ENTRY, + "Invalid IPv4 subnetwork mask"); goto err; } } @@ -3057,7 +3110,8 @@ mnt3_export_parse_auth_param (struct mnt3_export* exp, char* exportpath) sizeof (*(exp->hostspec)), gf_nfs_mt_auth_spec); if (NULL == exp->hostspec){ - gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); return -1; } @@ -3071,8 +3125,9 @@ mnt3_export_parse_auth_param (struct mnt3_export* exp, char* exportpath) while (NULL != hostip){ ret = mnt3_export_fill_hostspec (host, hostip); if (0 != ret) { - gf_log(GF_MNT, GF_LOG_WARNING, - "Failed to parse hostspec: %s", hostip); + gf_msg (GF_MNT, GF_LOG_WARNING, 0, + NFS_MSG_PARSE_HOSTSPEC_FAIL, + "Failed to parse hostspec: %s", hostip); goto err; } @@ -3084,8 +3139,9 @@ mnt3_export_parse_auth_param (struct mnt3_export* exp, char* exportpath) host->next = GF_CALLOC (1, sizeof (*(host)), gf_nfs_mt_auth_spec); if (NULL == host->next){ - gf_log (GF_MNT,GF_LOG_ERROR, - "Memory allocation failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, + NFS_MSG_NO_MEMORY, + "Memory allocation failed"); goto err; } host = host->next; @@ -3118,7 +3174,8 @@ mnt3_init_export_ent (struct mount3_state *ms, xlator_t *xl, char *exportpath, exp = GF_CALLOC (1, sizeof (*exp), gf_nfs_mt_mnt3_export); if (!exp) { - gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); return NULL; } @@ -3129,8 +3186,9 @@ mnt3_init_export_ent (struct mount3_state *ms, xlator_t *xl, char *exportpath, * structure. */ if (0 != mnt3_export_parse_auth_param (exp, exportpath)){ - gf_log (GF_MNT, GF_LOG_ERROR, - "Failed to parse auth param"); + gf_msg (GF_MNT, GF_LOG_ERROR, 0, + NFS_MSG_PARSE_AUTH_PARAM_FAIL, + "Failed to parse auth param"); goto err; } } @@ -3144,24 +3202,25 @@ mnt3_init_export_ent (struct mount3_state *ms, xlator_t *xl, char *exportpath, exp->expname = GF_CALLOC (alloclen, sizeof (char), gf_nfs_mt_char); if (!exp->expname) { - gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); goto err; } if (exportpath) { - gf_log (GF_MNT, GF_LOG_TRACE, "Initing dir export: %s:%s", - xl->name, exportpath); + gf_msg_trace (GF_MNT, 0, "Initing dir export: %s:%s", + xl->name, exportpath); exp->exptype = MNT3_EXPTYPE_DIR; ret = snprintf (exp->expname, alloclen, "/%s%s", xl->name, exportpath); } else { - gf_log (GF_MNT, GF_LOG_TRACE, "Initing volume export: %s", - xl->name); + gf_msg_trace (GF_MNT, 0, "Initing volume export: %s", + xl->name); exp->exptype = MNT3_EXPTYPE_VOLUME; ret = snprintf (exp->expname, alloclen, "/%s", xl->name); } if (ret < 0) { - gf_log (xl->name, GF_LOG_ERROR, + gf_msg (xl->name, GF_LOG_ERROR, ret, NFS_MSG_SET_EXP_FAIL, "Failed to set the export name"); goto err; } @@ -3204,7 +3263,8 @@ __mnt3_init_volume_direxports (struct mount3_state *ms, xlator_t *xlator, while (token) { newexp = mnt3_init_export_ent (ms, xlator, token, volumeid); if (!newexp) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to init dir " + gf_msg (GF_MNT, GF_LOG_ERROR, 0, + NFS_MSG_INIT_DIR_EXP_FAIL, "Failed to init dir " "export: %s", token); ret = -1; goto err; @@ -3238,7 +3298,8 @@ __mnt3_init_volume (struct mount3_state *ms, dict_t *opts, xlator_t *xlator) ret = snprintf (searchstr, 1024, "nfs3.%s.volume-id", xlator->name); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, "snprintf failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_SNPRINTF_FAIL, + "snprintf failed"); ret = -1; goto err; } @@ -3246,13 +3307,15 @@ __mnt3_init_volume (struct mount3_state *ms, dict_t *opts, xlator_t *xlator) if (dict_get (opts, searchstr)) { ret = dict_get_str (opts, searchstr, &optstr); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to read option" - ": %s", searchstr); + gf_msg (GF_MNT, GF_LOG_ERROR, ret, + NFS_MSG_DICT_GET_FAILED, "Failed to read " + "option: %s", searchstr); ret = -1; goto err; } } else { - gf_log (GF_MNT, GF_LOG_ERROR, "DVM is on but volume-id not " + gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_VOLID_MISSING, + "DVM is on but volume-id not " "given for volume: %s", xlator->name); ret = -1; goto err; @@ -3261,8 +3324,9 @@ __mnt3_init_volume (struct mount3_state *ms, dict_t *opts, xlator_t *xlator) if (optstr) { ret = gf_uuid_parse (optstr, volumeid); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to parse volume " - "UUID"); + gf_msg (GF_MNT, GF_LOG_ERROR, ret, + NFS_MSG_PARSE_VOL_UUID_FAIL, "Failed to parse " + "volume UUID"); ret = -1; goto err; } @@ -3271,7 +3335,8 @@ __mnt3_init_volume (struct mount3_state *ms, dict_t *opts, xlator_t *xlator) no_dvm: ret = snprintf (searchstr, 1024, "nfs3.%s.export-dir", xlator->name); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, "snprintf failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_SNPRINTF_FAIL, + "snprintf failed"); ret = -1; goto err; } @@ -3279,8 +3344,9 @@ no_dvm: if (dict_get (opts, searchstr)) { ret = dict_get_str (opts, searchstr, &optstr); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to read option: " - "%s", searchstr); + gf_msg (GF_MNT, GF_LOG_ERROR, ret, + NFS_MSG_DICT_GET_FAILED, "Failed to read " + "option: %s", searchstr); ret = -1; goto err; } @@ -3288,8 +3354,9 @@ no_dvm: ret = __mnt3_init_volume_direxports (ms, xlator, optstr, volumeid); if (ret == -1) { - gf_log (GF_MNT, GF_LOG_ERROR, "Dir export setup failed" - " for volume: %s", xlator->name); + gf_msg (GF_MNT, GF_LOG_ERROR, 0, + NFS_MSG_DIR_EXP_SETUP_FAIL, "Dir export " + "setup failed for volume: %s", xlator->name); goto err; } } @@ -3329,24 +3396,24 @@ __mnt3_init_volume_export (struct mount3_state *ms, dict_t *opts) ret = dict_get_str (opts, "nfs3.export-volumes", &optstr); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to read option: " - "nfs3.export-volumes"); + gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_DICT_GET_FAILED, + "Failed to read option: nfs3.export-volumes"); ret = -1; goto err; } ret = gf_string2boolean (optstr, &boolt); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to convert" - " string to boolean"); + gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_STR2BOOL_FAIL, + "Failed to convert string to boolean"); } err: if (boolt == _gf_false) { - gf_log (GF_MNT, GF_LOG_TRACE, "Volume exports disabled"); + gf_msg_trace (GF_MNT, 0, "Volume exports disabled"); ms->export_volumes = 0; } else { - gf_log (GF_MNT, GF_LOG_TRACE, "Volume exports enabled"); + gf_msg_trace (GF_MNT, 0, "Volume exports enabled"); ms->export_volumes = 1; } @@ -3372,24 +3439,24 @@ __mnt3_init_dir_export (struct mount3_state *ms, dict_t *opts) ret = dict_get_str (opts, "nfs3.export-dirs", &optstr); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to read option: " - "nfs3.export-dirs"); + gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_DICT_GET_FAILED, + "Failed to read option: nfs3.export-dirs"); ret = -1; goto err; } ret = gf_string2boolean (optstr, &boolt); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, "Failed to convert" - " string to boolean"); + gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_STR2BOOL_FAIL, + "Failed to convert string to boolean"); } err: if (boolt == _gf_false) { - gf_log (GF_MNT, GF_LOG_TRACE, "Dir exports disabled"); + gf_msg_trace (GF_MNT, 0, "Dir exports disabled"); ms->export_dirs = 0; } else { - gf_log (GF_MNT, GF_LOG_TRACE, "Dir exports enabled"); + gf_msg_trace (GF_MNT, 0, "Dir exports enabled"); ms->export_dirs = 1; } @@ -3410,11 +3477,13 @@ mnt3_init_options (struct mount3_state *ms, dict_t *options) __mnt3_init_dir_export (ms, options); volentry = ms->nfsx->children; while (volentry) { - gf_log (GF_MNT, GF_LOG_TRACE, "Initing options for: %s", - volentry->xlator->name); + gf_msg_trace (GF_MNT, 0, "Initing options for: %s", + volentry->xlator->name); ret = __mnt3_init_volume (ms, options, volentry->xlator); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, "Volume init failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ret, + NFS_MSG_VOL_INIT_FAIL, + "Volume init failed"); goto err; } @@ -3438,7 +3507,8 @@ mnt3_init_state (xlator_t *nfsx) ms = GF_CALLOC (1, sizeof (*ms), gf_nfs_mt_mount3_state); if (!ms) { - gf_log (GF_MNT, GF_LOG_ERROR, "Memory allocation failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Memory allocation failed"); return NULL; } @@ -3447,7 +3517,8 @@ mnt3_init_state (xlator_t *nfsx) INIT_LIST_HEAD (&ms->exportlist); ret = mnt3_init_options (ms, nfsx->options); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, "Options init failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_OPT_INIT_FAIL, + "Options init failed"); return NULL; } @@ -3470,8 +3541,8 @@ mount_init_state (xlator_t *nfsx) /*Maintaining global state for MOUNT1 and MOUNT3*/ nfs->mstate = mnt3_init_state (nfsx); if (!nfs->mstate) { - gf_log (GF_NFS, GF_LOG_ERROR, "Failed to allocate" - "mount state"); + gf_msg (GF_NFS, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Failed to allocate mount state"); goto out; } ret = 0; @@ -3526,7 +3597,7 @@ __mnt3_mounted_exports_walk (dict_t *dict, char *key, data_t *val, void *tmp) struct mnt3_auth_params *auth_params = NULL; int auth_status_code = 0; - gf_log (GF_MNT, GF_LOG_TRACE, "Checking if key %s is authorized.", key); + gf_msg_trace (GF_MNT, 0, "Checking if key %s is authorized.", key); auth_params = (struct mnt3_auth_params *)tmp; @@ -3552,9 +3623,9 @@ __mnt3_mounted_exports_walk (dict_t *dict, char *key, data_t *val, void *tmp) auth_status_code = mnt3_auth_host (auth_params, host_addr_ip, NULL, path, _gf_false, NULL); if (auth_status_code != 0) { - gf_log (GF_MNT, GF_LOG_ERROR, - "%s is no longer authorized for %s", - host_addr_ip, path); + gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_AUTH_ERROR, + "%s is no longer authorized for %s", + host_addr_ip, path); mnt3svc_umount (auth_params->ms, path, host_addr_ip); } return 0; @@ -3571,7 +3642,7 @@ __mnt3_mounted_exports_walk (dict_t *dict, char *key, data_t *val, void *tmp) void _mnt3_invalidate_old_mounts (struct mount3_state *ms) { - gf_log (GF_MNT, GF_LOG_DEBUG, "Invalidating old mounts ..."); + gf_msg_debug (GF_MNT, 0, "Invalidating old mounts ..."); dict_foreach (ms->mountdict, __mnt3_mounted_exports_walk, ms->auth_params); } @@ -3653,28 +3724,30 @@ _mnt3_auth_param_refresh_thread (void *argv) sleep (mstate->nfs->auth_refresh_time_secs); if (_mnt3_has_file_changed (exp_file_path, &exp_time)) { - gf_log (GF_MNT, GF_LOG_INFO, "File %s changed, " - "updating exports,", + gf_msg (GF_MNT, GF_LOG_INFO, 0, NFS_MSG_UPDATING_EXP, + "File %s changed, updating exports,", exp_file_path); ret = mnt3_auth_set_exports_auth (mstate->auth_params, exp_file_path); if (ret) - gf_log (GF_MNT, GF_LOG_ERROR, + gf_msg (GF_MNT, GF_LOG_ERROR, 0, + NFS_MSG_SET_EXP_AUTH_PARAM_FAIL, "Failed to set export auth params."); else any_file_changed = _gf_true; } if (_mnt3_has_file_changed (ng_file_path, &ng_time)) { - gf_log (GF_MNT, GF_LOG_INFO, "File %s changed," - "updating netgroups", - ng_file_path); + gf_msg (GF_MNT, GF_LOG_INFO, 0, + NFS_MSG_UPDATING_NET_GRP, "File %s changed," + "updating netgroups", ng_file_path); ret = mnt3_auth_set_netgroups_auth (mstate->auth_params, ng_file_path); if (ret) - gf_log (GF_MNT, GF_LOG_ERROR, + gf_msg (GF_MNT, GF_LOG_ERROR, 0, + NFS_MSG_SET_NET_GRP_FAIL, "Failed to set netgroup auth params."); else any_file_changed = _gf_true; @@ -3684,7 +3757,8 @@ _mnt3_auth_param_refresh_thread (void *argv) if (!any_file_changed) continue; - gf_log (GF_MNT, GF_LOG_INFO, "Purging auth cache."); + gf_msg (GF_MNT, GF_LOG_INFO, 0, NFS_MSG_PURGING_AUTH_CACHE, + "Purging auth cache."); auth_cache_purge (mstate->authcache); /* Walk through mounts that are no longer authorized @@ -3721,7 +3795,7 @@ _mnt3_init_auth_params (struct mount3_state *mstate) mstate->auth_params = mnt3_auth_params_init (mstate); if (!mstate->auth_params) { - gf_log (GF_MNT, GF_LOG_ERROR, + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, "Failed to init mount auth params."); ret = -ENOMEM; goto out; @@ -3733,7 +3807,8 @@ _mnt3_init_auth_params (struct mount3_state *mstate) ret = mnt3_auth_set_exports_auth (mstate->auth_params, exp_file_path); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, + gf_msg (GF_MNT, GF_LOG_ERROR, ret, + NFS_MSG_SET_EXP_AUTH_PARAM_FAIL, "Failed to set export auth params."); goto out; } @@ -3744,7 +3819,8 @@ _mnt3_init_auth_params (struct mount3_state *mstate) ret = mnt3_auth_set_netgroups_auth (mstate->auth_params, ng_file_path); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, + gf_msg (GF_MNT, GF_LOG_ERROR, ret, + NFS_MSG_SET_EXP_AUTH_PARAM_FAIL, "Failed to set netgroup auth params."); goto out; } @@ -3802,10 +3878,11 @@ mnt3svc_init (xlator_t *nfsx) nfs = (struct nfs_state *)nfsx->private; - gf_log (GF_MNT, GF_LOG_DEBUG, "Initing Mount v3 state"); + gf_msg_debug (GF_MNT, 0, "Initing Mount v3 state"); mstate = (struct mount3_state *)nfs->mstate; if (!mstate) { - gf_log (GF_MNT, GF_LOG_ERROR, "Mount v3 state init failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_MNT_STATE_INIT_FAIL, + "Mount v3 state init failed"); goto err; } @@ -3813,7 +3890,7 @@ mnt3svc_init (xlator_t *nfsx) mstate->mountdict = dict_new (); if (!mstate->mountdict) { - gf_log (GF_MNT, GF_LOG_ERROR, + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, "Failed to setup mount dict. Allocation error."); goto err; } @@ -3833,8 +3910,8 @@ mnt3svc_init (xlator_t *nfsx) pthread_create (&mstate->auth_refresh_thread, NULL, _mnt3_auth_param_refresh_thread, mstate); } else - gf_log (GF_MNT, GF_LOG_WARNING, "Exports auth has been " - "disabled!"); + gf_msg (GF_MNT, GF_LOG_WARNING, 0, NFS_MSG_EXP_AUTH_DISABLED, + "Exports auth has been disabled!"); mnt3prog.private = mstate; options = dict_new (); @@ -3850,26 +3927,31 @@ mnt3svc_init (xlator_t *nfsx) ret = dict_set_str (options, "transport-type", "socket"); if (ret == -1) { - gf_log (GF_NFS, GF_LOG_ERROR, "dict_set_str error"); + gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); goto err; } if (nfs->allow_insecure) { ret = dict_set_str (options, "rpc-auth-allow-insecure", "on"); if (ret == -1) { - gf_log (GF_NFS, GF_LOG_ERROR, "dict_set_str error"); + gf_msg (GF_NFS, GF_LOG_ERROR, errno, + NFS_MSG_DICT_SET_FAILED, "dict_set_str error"); goto err; } ret = dict_set_str (options, "rpc-auth.ports.insecure", "on"); if (ret == -1) { - gf_log (GF_NFS, GF_LOG_ERROR, "dict_set_str error"); + gf_msg (GF_NFS, GF_LOG_ERROR, errno, + NFS_MSG_DICT_SET_FAILED, "dict_set_str error"); goto err; } } ret= rpcsvc_create_listeners (nfs->rpcsvc, options, nfsx->name); if (ret == -1) { - gf_log (GF_NFS, GF_LOG_ERROR, "Unable to create listeners"); + gf_msg (GF_NFS, GF_LOG_ERROR, errno, + NFS_MSG_LISTENERS_CREATE_FAIL, + "Unable to create listeners"); dict_unref (options); goto err; } @@ -3918,10 +4000,12 @@ mnt1svc_init (xlator_t *nfsx) nfs = (struct nfs_state *)nfsx->private; - gf_log (GF_MNT, GF_LOG_DEBUG, "Initing Mount v1 state"); + gf_msg_debug (GF_MNT, GF_LOG_DEBUG, "Initing Mount v1 state"); mstate = (struct mount3_state *)nfs->mstate; if (!mstate) { - gf_log (GF_MNT, GF_LOG_ERROR, "Mount v3 state init failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, EINVAL, + NFS_MSG_MNT_STATE_INIT_FAIL, + "Mount v3 state init failed"); goto err; } @@ -3938,26 +4022,33 @@ mnt1svc_init (xlator_t *nfsx) goto err; ret = dict_set_str (options, "transport-type", "socket"); if (ret == -1) { - gf_log (GF_NFS, GF_LOG_ERROR, "dict_set_str error"); + gf_msg (GF_NFS, GF_LOG_ERROR, errno, NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); goto err; } if (nfs->allow_insecure) { ret = dict_set_str (options, "rpc-auth-allow-insecure", "on"); if (ret == -1) { - gf_log (GF_NFS, GF_LOG_ERROR, "dict_set_str error"); + gf_msg (GF_NFS, GF_LOG_ERROR, errno, + NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); goto err; } ret = dict_set_str (options, "rpc-auth.ports.insecure", "on"); if (ret == -1) { - gf_log (GF_NFS, GF_LOG_ERROR, "dict_set_str error"); + gf_msg (GF_NFS, GF_LOG_ERROR, errno, + NFS_MSG_DICT_SET_FAILED, + "dict_set_str error"); goto err; } } ret = rpcsvc_create_listeners (nfs->rpcsvc, options, nfsx->name); if (ret == -1) { - gf_log (GF_NFS, GF_LOG_ERROR, "Unable to create listeners"); + gf_msg (GF_NFS, GF_LOG_ERROR, errno, + NFS_MSG_LISTENERS_CREATE_FAIL, + "Unable to create listeners"); dict_unref (options); goto err; } @@ -4001,7 +4092,8 @@ mount_reconfigure_state (xlator_t *nfsx, dict_t *options) UNLOCK (&ms->mountlock); if (ret < 0) { - gf_log (GF_MNT, GF_LOG_ERROR, "Options reconfigure failed"); + gf_msg (GF_MNT, GF_LOG_ERROR, ret, NFS_MSG_RECONF_FAIL, + "Options reconfigure failed"); return (-1); } diff --git a/xlators/nfs/server/src/mount3udp_svc.c b/xlators/nfs/server/src/mount3udp_svc.c index 4ad8e11ad49..e8e226e953e 100644 --- a/xlators/nfs/server/src/mount3udp_svc.c +++ b/xlators/nfs/server/src/mount3udp_svc.c @@ -13,6 +13,7 @@ #include "logging.h" #include "mem-pool.h" #include "nfs-mem-types.h" +#include "nfs-messages.h" #include "mount3.h" #include #include @@ -63,12 +64,14 @@ mountudpproc3_mnt_3_svc(dirpath **dpp, struct svc_req *req) res = GF_CALLOC (1, sizeof(*res), gf_nfs_mt_mountres3); if (res == NULL) { - gf_log (GF_MNT, GF_LOG_ERROR, "Unable to allocate memory"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Unable to allocate memory"); goto err; } autharr = GF_CALLOC (MNT3UDP_AUTH_LEN, sizeof(int), gf_nfs_mt_int); if (autharr == NULL) { - gf_log (GF_MNT, GF_LOG_ERROR, "Unable to allocate memory"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Unable to allocate memory"); goto err; } @@ -78,7 +81,8 @@ mountudpproc3_mnt_3_svc(dirpath **dpp, struct svc_req *req) /* FAILURE: No FH */ if (fh == NULL) { - gf_log (GF_MNT, GF_LOG_ERROR, "Unable to get fh for %s", mpath); + gf_msg (GF_MNT, GF_LOG_ERROR, errno, NFS_MSG_GET_FH_FAIL, + "Unable to get fh for %s", mpath); if (errno) stat = mnt3svc_errno_to_mnterr (errno); *res = mnt3svc_set_mountres3 (stat, NULL /* fh */, @@ -108,7 +112,8 @@ mountudpproc3_umnt_3_svc(dirpath **dp, struct svc_req *req) stat = GF_CALLOC (1, sizeof(mountstat3), gf_nfs_mt_mountstat3); if (stat == NULL) { - gf_log (GF_MNT, GF_LOG_ERROR, "Unable to allocate memory"); + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_NO_MEMORY, + "Unable to allocate memory"); return NULL; } *stat = MNT3_OK; @@ -163,17 +168,19 @@ mountudp_program_3(struct svc_req *rqstp, register SVCXPRT *transp) } result = (*local)((char *)&argument, rqstp); if (result == NULL) { - gf_log (GF_MNT, GF_LOG_DEBUG, "PROC returned error"); + gf_msg_debug (GF_MNT, 0, "PROC returned error"); svcerr_systemerr (transp); } if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) { - gf_log (GF_MNT, GF_LOG_ERROR, "svc_sendreply returned error"); + gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_ERROR, + "svc_sendreply returned error"); svcerr_systemerr (transp); } if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) { - gf_log (GF_MNT, GF_LOG_ERROR, "Unable to free arguments"); + gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_ARG_FREE_FAIL, + "Unable to free arguments"); } if (result == NULL) return; @@ -202,23 +209,26 @@ mount3udp_thread (void *argv) GF_ASSERT (nfsx); if (glusterfs_this_set(nfsx)) { - gf_log (GF_MNT, GF_LOG_ERROR, + gf_msg (GF_MNT, GF_LOG_ERROR, ENOMEM, NFS_MSG_XLATOR_SET_FAIL, "Failed to set xlator, nfs.mount-udp will not work"); return NULL; } transp = svcudp_create(RPC_ANYSOCK); if (transp == NULL) { - gf_log (GF_MNT, GF_LOG_ERROR, "svcudp_create error"); + gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_ERROR, + "svcudp_create error"); return NULL; } if (!svc_register(transp, MOUNT_PROGRAM, MOUNT_V3, mountudp_program_3, IPPROTO_UDP)) { - gf_log (GF_MNT, GF_LOG_ERROR, "svc_register error"); + gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_ERROR, + "svc_register error"); return NULL; } svc_run (); - gf_log (GF_MNT, GF_LOG_ERROR, "svc_run returned"); + gf_msg (GF_MNT, GF_LOG_ERROR, 0, NFS_MSG_SVC_RUN_RETURNED, + "svc_run returned"); return NULL; } -- cgit