hadoop-common-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From j..@apache.org
Subject [40/50] [abbrv] hadoop git commit: HDFS-11544: libhdfs++: Revert HDFS-11544.HDFS-8707.001.patch due to invalid memory access regression. Done by James Clampffer
Date Thu, 22 Mar 2018 20:43:26 GMT
HDFS-11544: libhdfs++: Revert HDFS-11544.HDFS-8707.001.patch due to invalid memory access regression.
 Done by James Clampffer


Project: http://git-wip-us.apache.org/repos/asf/hadoop/repo
Commit: http://git-wip-us.apache.org/repos/asf/hadoop/commit/e57b32ae
Tree: http://git-wip-us.apache.org/repos/asf/hadoop/tree/e57b32ae
Diff: http://git-wip-us.apache.org/repos/asf/hadoop/diff/e57b32ae

Branch: refs/heads/HDFS-8707
Commit: e57b32ae5febf78a400f32ca975221ba568a29aa
Parents: 313980e
Author: James Clampffer <james.clampffer@hp.com>
Authored: Fri May 19 15:38:17 2017 -0400
Committer: James Clampffer <james.clampffer@hp.com>
Committed: Thu Mar 22 16:20:45 2018 -0400

----------------------------------------------------------------------
 .../native/libhdfspp/lib/bindings/c/hdfs.cc     | 800 +++++++++----------
 1 file changed, 398 insertions(+), 402 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/hadoop/blob/e57b32ae/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/bindings/c/hdfs.cc
----------------------------------------------------------------------
diff --git a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/bindings/c/hdfs.cc
b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/bindings/c/hdfs.cc
index 4e6c0f3..8c7e34c 100644
--- a/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/bindings/c/hdfs.cc
+++ b/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/lib/bindings/c/hdfs.cc
@@ -41,23 +41,6 @@ using namespace std::placeholders;
 
 static constexpr tPort kDefaultPort = 8020;
 
-// Functions exposed through the C API and extended C API get tagged with no-op
-// defines.  This is to make it really clear what's being exposed in a way that
-// won't blend into the comments.  Can also be used to add attributes or disable
-// the extensions e.g. "#define HDFS_EXT_API static"
-// API declared in hdfs.h shared with libhdfs
-#define HDFS_API
-// API extension functions specific to libhdfs++ declared in hdfs_ext.h
-#define HDFS_EXT_API
-
-// Common catch-all case to get exception and return the appropriate error code
-#define CATCH_AND_REPORT  catch (const std::exception & e) { return ReportException(e);
} \
-                          catch (...) { return ReportCaughtNonException(); }
-
-
-
-
-
 /* Separate the handles used by the C api from the C++ API*/
 struct hdfs_internal {
   hdfs_internal(FileSystem *p) : filesystem_(p), working_directory_("/") {}
@@ -96,14 +79,9 @@ struct hdfsFile_internal {
 thread_local std::string errstr;
 
 /* Fetch last error that happened in this thread */
-HDFS_EXT_API
 int hdfsGetLastError(char *buf, int len) {
   //No error message
   if(errstr.empty()){
-    if(len > 0) {
-      // Null terminator if there is space
-      *buf = 0;
-    }
     return -1;
   }
 
@@ -126,17 +104,6 @@ int hdfsGetLastError(char *buf, int len) {
   return 0;
 }
 
-/* Clear out last error.  This shouldn't need to be public if functions do it themselves
*/
-static void resetErrorForApiCall(const char *location = nullptr) {
-  // POSIX spec says caller should be responsible for resetting errno.
-  // Clearing it here just in case.
-  errno = 0;
-  if(location)
-    errstr = std::string(location) + " has not set an error message";
-  else
-    errstr.clear();
-}
-
 /* Event callbacks for next open calls */
 thread_local std::experimental::optional<fs_event_callback> fsEventCallback;
 thread_local std::experimental::optional<file_event_callback> fileEventCallback;
@@ -288,9 +255,7 @@ optional<std::string> getAbsolutePath(hdfsFS fs, const char* path)
{
  * C API implementations
  **/
 
-HDFS_API
 int hdfsFileIsOpenForRead(hdfsFile file) {
-  resetErrorForApiCall("hdfsFileIsOpenForRead");
   /* files can only be open for reads at the moment, do a quick check */
   if (!CheckHandle(file)){
     return 0;
@@ -298,9 +263,7 @@ int hdfsFileIsOpenForRead(hdfsFile file) {
   return 1; // Update implementation when we get file writing
 }
 
-HDFS_API
 int hdfsFileIsOpenForWrite(hdfsFile file) {
-  resetErrorForApiCall("hdfsFileIsOpenForWrite");
   /* files can only be open for reads at the moment, so return false */
   CheckHandle(file);
   return -1; // Update implementation when we get file writing
@@ -313,7 +276,11 @@ int hdfsConfGetLong(const char *key, int64_t *val)
     errno = 0;
     hdfsBuilder builder;
     return hdfsBuilderConfGetLong(&builder, key, val);
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
 hdfsFS doHdfsConnect(optional<std::string> nn, optional<tPort> port, optional<std::string>
user, const Options & options) {
@@ -365,12 +332,11 @@ hdfsFS doHdfsConnect(optional<std::string> nn, optional<tPort>
port, optional<st
   }
 }
 
-HDFS_EXT_API
 hdfsFS hdfsAllocateFileSystem(struct hdfsBuilder *bld) {
-  resetErrorForApiCall("hdfsAllocateFileSystem");
   // Same idea as the first half of doHdfsConnect, but return the wrapped FS before
   // connecting.
   try {
+    errno = 0;
     std::shared_ptr<IoService> io_service = IoService::MakeShared();
 
     int io_thread_count = bld->config.GetOptions().io_threads_;
@@ -401,9 +367,7 @@ hdfsFS hdfsAllocateFileSystem(struct hdfsBuilder *bld) {
   return nullptr;
 }
 
-HDFS_EXT_API
 int hdfsConnectAllocated(hdfsFS fs, struct hdfsBuilder *bld) {
-  resetErrorForApiCall("hdfsConnectAllocated");
   if(!CheckSystem(fs)) {
     return ENODEV;
   }
@@ -456,35 +420,25 @@ int hdfsConnectAllocated(hdfsFS fs, struct hdfsBuilder *bld) {
   return 0;
 }
 
-HDFS_API
 hdfsFS hdfsConnect(const char *nn, tPort port) {
-  resetErrorForApiCall("hdfsConnect");
-  return doHdfsConnect(std::string(nn), port, std::string(""), Options());
+  return hdfsConnectAsUser(nn, port, "");
 }
 
-HDFS_API
 hdfsFS hdfsConnectAsUser(const char* nn, tPort port, const char *user) {
-  resetErrorForApiCall("hdfsConnectAsUser");
   return doHdfsConnect(std::string(nn), port, std::string(user), Options());
 }
 
-HDFS_API
 hdfsFS hdfsConnectAsUserNewInstance(const char* nn, tPort port, const char *user ) {
-  resetErrorForApiCall("hdfsConnectAsUserNewInstance");
   //libhdfspp always returns a new instance
   return doHdfsConnect(std::string(nn), port, std::string(user), Options());
 }
 
-HDFS_API
 hdfsFS hdfsConnectNewInstance(const char* nn, tPort port) {
-  resetErrorForApiCall("hdfsConnectNewInstance");
   //libhdfspp always returns a new instance
-  return doHdfsConnect(std::string(nn), port, std::string(""), Options());
+  return hdfsConnectAsUser(nn, port, "");
 }
 
-HDFS_EXT_API
 int hdfsCancelPendingConnection(hdfsFS fs) {
-  resetErrorForApiCall("hdfsCancelPendingConnection");
   // todo: stick an enum in hdfs_internal to check the connect state
   if(!CheckSystem(fs)) {
     return ENODEV;
@@ -504,11 +458,10 @@ int hdfsCancelPendingConnection(hdfsFS fs) {
   }
 }
 
-HDFS_API
 int hdfsDisconnect(hdfsFS fs) {
-  resetErrorForApiCall("hdfsDisconnect");
   try
   {
+    errno = 0;
     if (!fs) {
       ReportError(ENODEV, "Cannot disconnect null FS handle.");
       return -1;
@@ -516,15 +469,18 @@ int hdfsDisconnect(hdfsFS fs) {
 
     delete fs;
     return 0;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
-HDFS_API
 hdfsFile hdfsOpenFile(hdfsFS fs, const char *path, int flags, int bufferSize,
                       short replication, tSize blocksize) {
-  resetErrorForApiCall("hdfsOpenFile");
   try
   {
+    errno = 0;
     (void)flags;
     (void)bufferSize;
     (void)replication;
@@ -556,24 +512,26 @@ hdfsFile hdfsOpenFile(hdfsFS fs, const char *path, int flags, int bufferSize,
   }
 }
 
-HDFS_API
 int hdfsCloseFile(hdfsFS fs, hdfsFile file) {
-  resetErrorForApiCall("hdfsCloseFile");
   try
   {
+    errno = 0;
     if (!CheckSystemAndHandle(fs, file)) {
       return -1;
     }
     delete file;
     return 0;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
-HDFS_API
 char* hdfsGetWorkingDirectory(hdfsFS fs, char *buffer, size_t bufferSize) {
-  resetErrorForApiCall("hdfsGetWorkingDirectory");
   try
   {
+    errno = 0;
     if (!CheckSystem(fs)) {
       return nullptr;
     }
@@ -598,11 +556,10 @@ char* hdfsGetWorkingDirectory(hdfsFS fs, char *buffer, size_t bufferSize)
{
   }
 }
 
-HDFS_API
 int hdfsSetWorkingDirectory(hdfsFS fs, const char* path) {
-  resetErrorForApiCall("hdfsSetWorkingDirectory");
   try
   {
+    errno = 0;
     if (!CheckSystem(fs)) {
       return -1;
     }
@@ -618,23 +575,25 @@ int hdfsSetWorkingDirectory(hdfsFS fs, const char* path) {
     }
     fs->set_working_directory(withSlash);
     return 0;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
-HDFS_API
 int hdfsAvailable(hdfsFS fs, hdfsFile file) {
-  resetErrorForApiCall("hdfsAvailable");
   //Since we do not have read ahead implemented, return 0 if fs and file are good;
+  errno = 0;
   if (!CheckSystemAndHandle(fs, file)) {
     return -1;
   }
   return 0;
 }
 
-HDFS_API
 tOffset hdfsGetDefaultBlockSize(hdfsFS fs) {
-  resetErrorForApiCall("hdfsGetDefaultBlockSize");
   try {
+    errno = 0;
     return fs->get_impl()->get_options().block_size;
   } catch (const std::exception & e) {
     ReportException(e);
@@ -645,10 +604,9 @@ tOffset hdfsGetDefaultBlockSize(hdfsFS fs) {
   }
 }
 
-HDFS_API
 tOffset hdfsGetDefaultBlockSizeAtPath(hdfsFS fs, const char *path) {
-  resetErrorForApiCall("hdfsGetDefaultBlockSizeAtPath");
   try {
+    errno = 0;
     if (!CheckSystem(fs)) {
       return -1;
     }
@@ -675,53 +633,58 @@ tOffset hdfsGetDefaultBlockSizeAtPath(hdfsFS fs, const char *path) {
   }
 }
 
-HDFS_API
 int hdfsSetReplication(hdfsFS fs, const char* path, int16_t replication) {
-  resetErrorForApiCall("hdfsSetReplication");
-  try {
-    if (!CheckSystem(fs)) {
-      return -1;
-    }
-    const optional<std::string> abs_path = getAbsolutePath(fs, path);
-    if(!abs_path) {
-      return -1;
-    }
-    if(replication < 1){
-      return Error(Status::InvalidArgument("SetReplication: argument 'replication' cannot
be less than 1"));
-    }
-    Status stat;
-    stat = fs->get_impl()->SetReplication(*abs_path, replication);
-    if (!stat.ok()) {
-      return Error(stat);
+    try {
+      errno = 0;
+      if (!CheckSystem(fs)) {
+        return -1;
+      }
+      const optional<std::string> abs_path = getAbsolutePath(fs, path);
+      if(!abs_path) {
+        return -1;
+      }
+      if(replication < 1){
+        return Error(Status::InvalidArgument("SetReplication: argument 'replication' cannot
be less than 1"));
+      }
+      Status stat;
+      stat = fs->get_impl()->SetReplication(*abs_path, replication);
+      if (!stat.ok()) {
+        return Error(stat);
+      }
+      return 0;
+    } catch (const std::exception & e) {
+      return ReportException(e);
+    } catch (...) {
+      return ReportCaughtNonException();
     }
-    return 0;
-  } CATCH_AND_REPORT
 }
 
-HDFS_API
 int hdfsUtime(hdfsFS fs, const char* path, tTime mtime, tTime atime) {
-  resetErrorForApiCall("hdfsUtime");
-  try {
-    if (!CheckSystem(fs)) {
-      return -1;
-    }
-    const optional<std::string> abs_path = getAbsolutePath(fs, path);
-    if(!abs_path) {
-      return -1;
-    }
-    Status stat;
-    stat = fs->get_impl()->SetTimes(*abs_path, mtime, atime);
-    if (!stat.ok()) {
-      return Error(stat);
+    try {
+      errno = 0;
+      if (!CheckSystem(fs)) {
+        return -1;
+      }
+      const optional<std::string> abs_path = getAbsolutePath(fs, path);
+      if(!abs_path) {
+        return -1;
+      }
+      Status stat;
+      stat = fs->get_impl()->SetTimes(*abs_path, mtime, atime);
+      if (!stat.ok()) {
+        return Error(stat);
+      }
+      return 0;
+    } catch (const std::exception & e) {
+      return ReportException(e);
+    } catch (...) {
+      return ReportCaughtNonException();
     }
-    return 0;
-  } CATCH_AND_REPORT
 }
 
-HDFS_API
 tOffset hdfsGetCapacity(hdfsFS fs) {
-  resetErrorForApiCall("hdfsGetCapacity");
   try {
+    errno = 0;
     if (!CheckSystem(fs)) {
       return -1;
     }
@@ -742,10 +705,9 @@ tOffset hdfsGetCapacity(hdfsFS fs) {
   }
 }
 
-HDFS_API
 tOffset hdfsGetUsed(hdfsFS fs) {
-  resetErrorForApiCall("hdfsGetUsed");
   try {
+    errno = 0;
     if (!CheckSystem(fs)) {
       return -1;
     }
@@ -815,10 +777,9 @@ void StatInfoToHdfsFileInfo(hdfsFileInfo * file_info,
   file_info->mLastAccess = stat_info.access_time;
 }
 
-HDFS_API
 int hdfsExists(hdfsFS fs, const char *path) {
-  resetErrorForApiCall("hdfsExists");
   try {
+    errno = 0;
     if (!CheckSystem(fs)) {
       return -1;
     }
@@ -832,13 +793,16 @@ int hdfsExists(hdfsFS fs, const char *path) {
       return Error(stat);
     }
     return 0;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
-HDFS_API
 hdfsFileInfo *hdfsGetPathInfo(hdfsFS fs, const char* path) {
-  resetErrorForApiCall("hdfsGetPathInfo");
   try {
+    errno = 0;
     if (!CheckSystem(fs)) {
        return nullptr;
     }
@@ -864,64 +828,61 @@ hdfsFileInfo *hdfsGetPathInfo(hdfsFS fs, const char* path) {
   }
 }
 
-HDFS_API
 hdfsFileInfo *hdfsListDirectory(hdfsFS fs, const char* path, int *numEntries) {
-  resetErrorForApiCall("hdfsListDirectory");
   try {
-    if (!CheckSystem(fs)) {
-      *numEntries = 0;
-      return nullptr;
-    }
-    const optional<std::string> abs_path = getAbsolutePath(fs, path);
-    if(!abs_path) {
-      return nullptr;
-    }
-    std::vector<StatInfo> stat_infos;
-    Status stat = fs->get_impl()->GetListing(*abs_path, &stat_infos);
-    if (!stat.ok()) {
-      Error(stat);
+      errno = 0;
+      if (!CheckSystem(fs)) {
+        *numEntries = 0;
+        return nullptr;
+      }
+      const optional<std::string> abs_path = getAbsolutePath(fs, path);
+      if(!abs_path) {
+        return nullptr;
+      }
+      std::vector<StatInfo> stat_infos;
+      Status stat = fs->get_impl()->GetListing(*abs_path, &stat_infos);
+      if (!stat.ok()) {
+        Error(stat);
+        *numEntries = 0;
+        return nullptr;
+      }
+      if(stat_infos.empty()){
+        *numEntries = 0;
+        return nullptr;
+      }
+      *numEntries = stat_infos.size();
+      hdfsFileInfo *file_infos = new hdfsFileInfo[stat_infos.size()];
+      for(std::vector<StatInfo>::size_type i = 0; i < stat_infos.size(); i++) {
+        StatInfoToHdfsFileInfo(&file_infos[i], stat_infos.at(i));
+      }
+
+      return file_infos;
+    } catch (const std::exception & e) {
+      ReportException(e);
       *numEntries = 0;
       return nullptr;
-    }
-    if(stat_infos.empty()){
+    } catch (...) {
+      ReportCaughtNonException();
       *numEntries = 0;
       return nullptr;
     }
-    *numEntries = stat_infos.size();
-    hdfsFileInfo *file_infos = new hdfsFileInfo[stat_infos.size()];
-    for(std::vector<StatInfo>::size_type i = 0; i < stat_infos.size(); i++) {
-      StatInfoToHdfsFileInfo(&file_infos[i], stat_infos.at(i));
-    }
-
-    return file_infos;
-  } catch (const std::exception & e) {
-    ReportException(e);
-    *numEntries = 0;
-    return nullptr;
-  } catch (...) {
-    ReportCaughtNonException();
-    *numEntries = 0;
-    return nullptr;
-  }
 }
 
-HDFS_API
 void hdfsFreeFileInfo(hdfsFileInfo *hdfsFileInfo, int numEntries)
 {
-  resetErrorForApiCall("hdfsFreeFileInfo");
-  int i;
-  for (i = 0; i < numEntries; ++i) {
-    delete[] hdfsFileInfo[i].mName;
-    delete[] hdfsFileInfo[i].mOwner;
-    delete[] hdfsFileInfo[i].mGroup;
-  }
-  delete[] hdfsFileInfo;
+    errno = 0;
+    int i;
+    for (i = 0; i < numEntries; ++i) {
+        delete[] hdfsFileInfo[i].mName;
+        delete[] hdfsFileInfo[i].mOwner;
+        delete[] hdfsFileInfo[i].mGroup;
+    }
+    delete[] hdfsFileInfo;
 }
 
-HDFS_API
 int hdfsCreateDirectory(hdfsFS fs, const char* path) {
-  resetErrorForApiCall("hdfsCreateDirectory");
   try {
+    errno = 0;
     if (!CheckSystem(fs)) {
       return -1;
     }
@@ -930,39 +891,45 @@ int hdfsCreateDirectory(hdfsFS fs, const char* path) {
       return -1;
     }
     Status stat;
-    //Use default permissions and set true for creating all non-existent parent directories
+    //Use default permissions and set true for creating all non-existant parent directories
     stat = fs->get_impl()->Mkdirs(*abs_path, FileSystem::GetDefaultPermissionMask(),
true);
     if (!stat.ok()) {
       return Error(stat);
     }
     return 0;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
-HDFS_API
 int hdfsDelete(hdfsFS fs, const char* path, int recursive) {
-  resetErrorForApiCall("hdfsDelete");
   try {
-    if (!CheckSystem(fs)) {
-      return -1;
-    }
-    const optional<std::string> abs_path = getAbsolutePath(fs, path);
-    if(!abs_path) {
-      return -1;
-    }
-    Status stat;
-    stat = fs->get_impl()->Delete(*abs_path, recursive);
-    if (!stat.ok()) {
-      return Error(stat);
+      errno = 0;
+      if (!CheckSystem(fs)) {
+        return -1;
+      }
+      const optional<std::string> abs_path = getAbsolutePath(fs, path);
+      if(!abs_path) {
+        return -1;
+      }
+      Status stat;
+      stat = fs->get_impl()->Delete(*abs_path, recursive);
+      if (!stat.ok()) {
+        return Error(stat);
+      }
+      return 0;
+    } catch (const std::exception & e) {
+      return ReportException(e);
+    } catch (...) {
+      return ReportCaughtNonException();
     }
-    return 0;
-  } CATCH_AND_REPORT
 }
 
-HDFS_API
 int hdfsRename(hdfsFS fs, const char* oldPath, const char* newPath) {
-  resetErrorForApiCall("hdfsRename");
   try {
+    errno = 0;
     if (!CheckSystem(fs)) {
       return -1;
     }
@@ -977,99 +944,106 @@ int hdfsRename(hdfsFS fs, const char* oldPath, const char* newPath)
{
       return Error(stat);
     }
     return 0;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
-HDFS_API
 int hdfsChmod(hdfsFS fs, const char* path, short mode){
-  resetErrorForApiCall("hdfsChmod");
   try {
-    if (!CheckSystem(fs)) {
-      return -1;
-    }
-    const optional<std::string> abs_path = getAbsolutePath(fs, path);
-    if(!abs_path) {
-      return -1;
-    }
-    Status stat = FileSystem::CheckValidPermissionMask(mode);
-    if (!stat.ok()) {
-      return Error(stat);
-    }
-    stat = fs->get_impl()->SetPermission(*abs_path, mode);
-    if (!stat.ok()) {
-      return Error(stat);
+      errno = 0;
+      if (!CheckSystem(fs)) {
+        return -1;
+      }
+      const optional<std::string> abs_path = getAbsolutePath(fs, path);
+      if(!abs_path) {
+        return -1;
+      }
+      Status stat = FileSystem::CheckValidPermissionMask(mode);
+      if (!stat.ok()) {
+        return Error(stat);
+      }
+      stat = fs->get_impl()->SetPermission(*abs_path, mode);
+      if (!stat.ok()) {
+        return Error(stat);
+      }
+      return 0;
+    } catch (const std::exception & e) {
+      return ReportException(e);
+    } catch (...) {
+      return ReportCaughtNonException();
     }
-    return 0;
-  } CATCH_AND_REPORT
 }
 
-HDFS_API
 int hdfsChown(hdfsFS fs, const char* path, const char *owner, const char *group){
-  resetErrorForApiCall("hdfsChown");
   try {
-    if (!CheckSystem(fs)) {
-      return -1;
-    }
-    const optional<std::string> abs_path = getAbsolutePath(fs, path);
-    if(!abs_path) {
-      return -1;
-    }
-    std::string own = (owner) ? owner : "";
-    std::string grp = (group) ? group : "";
+      errno = 0;
+      if (!CheckSystem(fs)) {
+        return -1;
+      }
+      const optional<std::string> abs_path = getAbsolutePath(fs, path);
+      if(!abs_path) {
+        return -1;
+      }
+      std::string own = (owner) ? owner : "";
+      std::string grp = (group) ? group : "";
 
-    Status stat;
-    stat = fs->get_impl()->SetOwner(*abs_path, own, grp);
-    if (!stat.ok()) {
-      return Error(stat);
+      Status stat;
+      stat = fs->get_impl()->SetOwner(*abs_path, own, grp);
+      if (!stat.ok()) {
+        return Error(stat);
+      }
+      return 0;
+    } catch (const std::exception & e) {
+      return ReportException(e);
+    } catch (...) {
+      return ReportCaughtNonException();
     }
-    return 0;
-  } CATCH_AND_REPORT
 }
 
-HDFS_EXT_API
-hdfsFileInfo * hdfsFind(hdfsFS fs, const char* path, const char* name, uint32_t * numEntries)
-{
-  resetErrorForApiCall("hdfsFind");
+hdfsFileInfo * hdfsFind(hdfsFS fs, const char* path, const char* name, uint32_t * numEntries){
   try {
-    if (!CheckSystem(fs)) {
-      *numEntries = 0;
-      return nullptr;
-    }
+      errno = 0;
+      if (!CheckSystem(fs)) {
+        *numEntries = 0;
+        return nullptr;
+      }
 
-    std::vector<StatInfo>  stat_infos;
-    Status stat = fs->get_impl()->Find(path, name, hdfs::FileSystem::GetDefaultFindMaxDepth(),
&stat_infos);
-    if (!stat.ok()) {
-      Error(stat);
+      std::vector<StatInfo>  stat_infos;
+      Status stat = fs->get_impl()->Find(path, name, hdfs::FileSystem::GetDefaultFindMaxDepth(),
&stat_infos);
+      if (!stat.ok()) {
+        Error(stat);
+        *numEntries = 0;
+        return nullptr;
+      }
+      //Existing API expects nullptr if size is 0
+      if(stat_infos.empty()){
+        *numEntries = 0;
+        return nullptr;
+      }
+      *numEntries = stat_infos.size();
+      hdfsFileInfo *file_infos = new hdfsFileInfo[stat_infos.size()];
+      for(std::vector<StatInfo>::size_type i = 0; i < stat_infos.size(); i++) {
+        StatInfoToHdfsFileInfo(&file_infos[i], stat_infos.at(i));
+      }
+
+      return file_infos;
+    } catch (const std::exception & e) {
+      ReportException(e);
       *numEntries = 0;
       return nullptr;
-    }
-    //Existing API expects nullptr if size is 0
-    if(stat_infos.empty()){
+    } catch (...) {
+      ReportCaughtNonException();
       *numEntries = 0;
       return nullptr;
     }
-    *numEntries = stat_infos.size();
-    hdfsFileInfo *file_infos = new hdfsFileInfo[stat_infos.size()];
-    for(std::vector<StatInfo>::size_type i = 0; i < stat_infos.size(); i++) {
-      StatInfoToHdfsFileInfo(&file_infos[i], stat_infos.at(i));
-    }
-
-    return file_infos;
-  } catch (const std::exception & e) {
-    ReportException(e);
-    *numEntries = 0;
-    return nullptr;
-  } catch (...) {
-    ReportCaughtNonException();
-    *numEntries = 0;
-    return nullptr;
-  }
 }
 
-HDFS_EXT_API
 int hdfsCreateSnapshot(hdfsFS fs, const char* path, const char* name) {
-  resetErrorForApiCall("hdfsCreateSnapshot");
   try {
+    errno = 0;
     if (!CheckSystem(fs)) {
       return -1;
     }
@@ -1087,13 +1061,16 @@ int hdfsCreateSnapshot(hdfsFS fs, const char* path, const char* name)
{
       return Error(stat);
     }
     return 0;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
-HDFS_EXT_API
 int hdfsDeleteSnapshot(hdfsFS fs, const char* path, const char* name) {
-  resetErrorForApiCall("hdfsDeleteSnapshot");
   try {
+    errno = 0;
     if (!CheckSystem(fs)) {
       return -1;
     }
@@ -1110,13 +1087,16 @@ int hdfsDeleteSnapshot(hdfsFS fs, const char* path, const char* name)
{
       return Error(stat);
     }
     return 0;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
-HDFS_EXT_API
 int hdfsAllowSnapshot(hdfsFS fs, const char* path) {
-  resetErrorForApiCall("hdfsAllowSnapshot");
   try {
+    errno = 0;
     if (!CheckSystem(fs)) {
       return -1;
     }
@@ -1130,13 +1110,16 @@ int hdfsAllowSnapshot(hdfsFS fs, const char* path) {
       return Error(stat);
     }
     return 0;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
-HDFS_EXT_API
 int hdfsDisallowSnapshot(hdfsFS fs, const char* path) {
-  resetErrorForApiCall("hdfsDisallowSnapshot");
   try {
+    errno = 0;
     if (!CheckSystem(fs)) {
       return -1;
     }
@@ -1150,15 +1133,18 @@ int hdfsDisallowSnapshot(hdfsFS fs, const char* path) {
       return Error(stat);
     }
     return 0;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
-HDFS_API
 tSize hdfsPread(hdfsFS fs, hdfsFile file, tOffset position, void *buffer,
                 tSize length) {
-  resetErrorForApiCall("hdfsPread");
   try
   {
+    errno = 0;
     if (!CheckSystemAndHandle(fs, file)) {
       return -1;
     }
@@ -1169,14 +1155,17 @@ tSize hdfsPread(hdfsFS fs, hdfsFile file, tOffset position, void *buffer,
       return Error(stat);
     }
     return (tSize)len;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
-HDFS_API
 tSize hdfsRead(hdfsFS fs, hdfsFile file, void *buffer, tSize length) {
-  resetErrorForApiCall("hdfsRead");
   try
   {
+    errno = 0;
     if (!CheckSystemAndHandle(fs, file)) {
       return -1;
     }
@@ -1188,63 +1177,67 @@ tSize hdfsRead(hdfsFS fs, hdfsFile file, void *buffer, tSize length)
{
     }
 
     return (tSize)len;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
-HDFS_API
 int hdfsUnbufferFile(hdfsFile file) {
-  resetErrorForApiCall("hdfsUnbufferFile");
   //Currently we are not doing any buffering
   CheckHandle(file);
   return -1;
 }
 
-HDFS_API
 int hdfsFileGetReadStatistics(hdfsFile file, struct hdfsReadStatistics **stats) {
-  resetErrorForApiCall("hdfsFileGetReadStatistics");
   try
-  {
-    if (!CheckHandle(file)) {
-      return -1;
+    {
+      errno = 0;
+      if (!CheckHandle(file)) {
+        return -1;
+      }
+      *stats = new hdfsReadStatistics;
+      memset(*stats, 0, sizeof(hdfsReadStatistics));
+      (*stats)->totalBytesRead = file->get_impl()->get_bytes_read();
+      return 0;
+    } catch (const std::exception & e) {
+      return ReportException(e);
+    } catch (...) {
+      return ReportCaughtNonException();
     }
-    *stats = new hdfsReadStatistics;
-    memset(*stats, 0, sizeof(hdfsReadStatistics));
-    (*stats)->totalBytesRead = file->get_impl()->get_bytes_read();
-    return 0;
-  } CATCH_AND_REPORT
 }
 
-HDFS_API
 int hdfsFileClearReadStatistics(hdfsFile file) {
-  resetErrorForApiCall("hdfsFileClearReadStatistics");
   try
-  {
-    if (!CheckHandle(file)) {
-      return -1;
+    {
+      errno = 0;
+      if (!CheckHandle(file)) {
+        return -1;
+      }
+      file->get_impl()->clear_bytes_read();
+      return 0;
+    } catch (const std::exception & e) {
+      return ReportException(e);
+    } catch (...) {
+      return ReportCaughtNonException();
     }
-    file->get_impl()->clear_bytes_read();
-    return 0;
-  } CATCH_AND_REPORT
 }
 
-HDFS_API
 int64_t hdfsReadStatisticsGetRemoteBytesRead(const struct hdfsReadStatistics *stats) {
-  resetErrorForApiCall("hdfsReadStatisticsGetRemoteBytesRead");
-  return stats->totalBytesRead - stats->totalLocalBytesRead;
+    return stats->totalBytesRead - stats->totalLocalBytesRead;
 }
 
-HDFS_API
 void hdfsFileFreeReadStatistics(struct hdfsReadStatistics *stats) {
-  resetErrorForApiCall("hdfsFileFreeReadStatistics");
-  delete stats;
+    errno = 0;
+    delete stats;
 }
 
 /* 0 on success, -1 on error*/
-HDFS_API
 int hdfsSeek(hdfsFS fs, hdfsFile file, tOffset desiredPos) {
-  resetErrorForApiCall("hdfsSeek");
   try
   {
+    errno = 0;
     if (!CheckSystemAndHandle(fs, file)) {
       return -1;
     }
@@ -1256,14 +1249,17 @@ int hdfsSeek(hdfsFS fs, hdfsFile file, tOffset desiredPos) {
     }
 
     return 0;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
-HDFS_API
 tOffset hdfsTell(hdfsFS fs, hdfsFile file) {
-  resetErrorForApiCall("hdfsTell");
   try
   {
+    errno = 0;
     if (!CheckSystemAndHandle(fs, file)) {
       return -1;
     }
@@ -1275,30 +1271,36 @@ tOffset hdfsTell(hdfsFS fs, hdfsFile file) {
     }
 
     return offset;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
 /* extended API */
-HDFS_EXT_API
 int hdfsCancel(hdfsFS fs, hdfsFile file) {
-  resetErrorForApiCall("hdfsCancel");
   try
   {
+    errno = 0;
     if (!CheckSystemAndHandle(fs, file)) {
       return -1;
     }
     static_cast<FileHandleImpl*>(file->get_impl())->CancelOperations();
     return 0;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
 
-HDFS_EXT_API
 int hdfsGetBlockLocations(hdfsFS fs, const char *path, struct hdfsBlockLocations ** locations_out)
 {
-  resetErrorForApiCall("hdfsGetBlockLocations");
   try
   {
+    errno = 0;
     if (!CheckSystem(fs)) {
       return -1;
     }
@@ -1362,12 +1364,15 @@ int hdfsGetBlockLocations(hdfsFS fs, const char *path, struct hdfsBlockLocations
     }
 
     return 0;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
-HDFS_EXT_API
 int hdfsFreeBlockLocations(struct hdfsBlockLocations * blockLocations) {
-  resetErrorForApiCall("hdfsFreeBlockLocations");
+  errno = 0;
   if (blockLocations == nullptr)
     return 0;
 
@@ -1386,50 +1391,48 @@ int hdfsFreeBlockLocations(struct hdfsBlockLocations * blockLocations)
{
   return 0;
 }
 
-HDFS_API
 char*** hdfsGetHosts(hdfsFS fs, const char* path, tOffset start, tOffset length) {
-  resetErrorForApiCall("hdfsGetHosts");
   try
-  {
-    if (!CheckSystem(fs)) {
-      return nullptr;
-    }
-    const optional<std::string> abs_path = getAbsolutePath(fs, path);
-    if(!abs_path) {
+    {
+      errno = 0;
+      if (!CheckSystem(fs)) {
+        return nullptr;
+      }
+      const optional<std::string> abs_path = getAbsolutePath(fs, path);
+      if(!abs_path) {
+        return nullptr;
+      }
+      std::shared_ptr<FileBlockLocation> ppLocations;
+      Status stat = fs->get_impl()->GetBlockLocations(*abs_path, start, length, &ppLocations);
+      if (!stat.ok()) {
+        Error(stat);
+        return nullptr;
+      }
+      const std::vector<BlockLocation> & ppBlockLocations = ppLocations->getBlockLocations();
+      char ***hosts = new char**[ppBlockLocations.size() + 1];
+      for (size_t i=0; i < ppBlockLocations.size(); i++) {
+        const std::vector<DNInfo> & ppDNInfos = ppBlockLocations[i].getDataNodes();
+        hosts[i] = new char*[ppDNInfos.size() + 1];
+        for (size_t j=0; j < ppDNInfos.size(); j++) {
+          auto ppDNInfo = ppDNInfos[j];
+          hosts[i][j] = new char[ppDNInfo.getHostname().size() + 1];
+          strncpy(hosts[i][j], ppDNInfo.getHostname().c_str(), ppDNInfo.getHostname().size()
+ 1);
+        }
+        hosts[i][ppDNInfos.size()] = nullptr;
+      }
+      hosts[ppBlockLocations.size()] = nullptr;
+      return hosts;
+    } catch (const std::exception & e) {
+      ReportException(e);
       return nullptr;
-    }
-    std::shared_ptr<FileBlockLocation> ppLocations;
-    Status stat = fs->get_impl()->GetBlockLocations(*abs_path, start, length, &ppLocations);
-    if (!stat.ok()) {
-      Error(stat);
+    } catch (...) {
+      ReportCaughtNonException();
       return nullptr;
     }
-    const std::vector<BlockLocation> & ppBlockLocations = ppLocations->getBlockLocations();
-    char ***hosts = new char**[ppBlockLocations.size() + 1];
-    for (size_t i=0; i < ppBlockLocations.size(); i++) {
-      const std::vector<DNInfo> & ppDNInfos = ppBlockLocations[i].getDataNodes();
-      hosts[i] = new char*[ppDNInfos.size() + 1];
-      for (size_t j=0; j < ppDNInfos.size(); j++) {
-        auto ppDNInfo = ppDNInfos[j];
-        hosts[i][j] = new char[ppDNInfo.getHostname().size() + 1];
-        strncpy(hosts[i][j], ppDNInfo.getHostname().c_str(), ppDNInfo.getHostname().size()
+ 1);
-      }
-      hosts[i][ppDNInfos.size()] = nullptr;
-    }
-    hosts[ppBlockLocations.size()] = nullptr;
-    return hosts;
-  } catch (const std::exception & e) {
-    ReportException(e);
-    return nullptr;
-  } catch (...) {
-    ReportCaughtNonException();
-    return nullptr;
-  }
 }
 
-HDFS_API
 void hdfsFreeHosts(char ***blockHosts) {
-  resetErrorForApiCall("hdfsFreeHosts");
+  errno = 0;
   if (blockHosts == nullptr)
     return;
 
@@ -1492,20 +1495,16 @@ event_response file_callback_glue(libhdfspp_file_event_callback handler,
   return event_response::make_ok();
 }
 
-HDFS_EXT_API
 int hdfsPreAttachFSMonitor(libhdfspp_fs_event_callback handler, int64_t cookie)
 {
-  resetErrorForApiCall("hdfsPreAttachFSMonitor");
   fs_event_callback callback = std::bind(fs_callback_glue, handler, cookie, _1, _2, _3);
   fsEventCallback = callback;
   return 0;
 }
 
 
-HDFS_EXT_API
 int hdfsPreAttachFileMonitor(libhdfspp_file_event_callback handler, int64_t cookie)
 {
-  resetErrorForApiCall("hdfsPreAttachFileMonitor");
   file_event_callback callback = std::bind(file_callback_glue, handler, cookie, _1, _2, _3,
_4);
   fileEventCallback = callback;
   return 0;
@@ -1542,12 +1541,11 @@ hdfsBuilder::hdfsBuilder(const char * directory) :
   config = LoadDefault(loader);
 }
 
-HDFS_API
 struct hdfsBuilder *hdfsNewBuilder(void)
 {
-  resetErrorForApiCall("hdfsNewBuilder");
   try
   {
+    errno = 0;
     return new struct hdfsBuilder();
   } catch (const std::exception & e) {
     ReportException(e);
@@ -1558,42 +1556,37 @@ struct hdfsBuilder *hdfsNewBuilder(void)
   }
 }
 
-HDFS_API
 void hdfsBuilderSetNameNode(struct hdfsBuilder *bld, const char *nn)
 {
-  resetErrorForApiCall("hdfsBuilderSetNameNode");
+  errno = 0;
   bld->overrideHost = std::string(nn);
 }
 
-HDFS_API
 void hdfsBuilderSetNameNodePort(struct hdfsBuilder *bld, tPort port)
 {
-  resetErrorForApiCall("hdfsBuilderSetNameNodePort");
+  errno = 0;
   bld->overridePort = port;
 }
 
-HDFS_API
 void hdfsBuilderSetUserName(struct hdfsBuilder *bld, const char *userName)
 {
-  resetErrorForApiCall("hdfsBuilderSetUserName");
+  errno = 0;
   if (userName && *userName) {
     bld->user = std::string(userName);
   }
 }
 
-HDFS_API
 void hdfsBuilderSetForceNewInstance(struct hdfsBuilder *bld) {
-  resetErrorForApiCall("hdfsBuilderSetForceNewInstance");
   //libhdfspp always returns a new instance, so nothing to do
   (void)bld;
+  errno = 0;
 }
 
-HDFS_API
 void hdfsFreeBuilder(struct hdfsBuilder *bld)
 {
-  resetErrorForApiCall("hdfsFreeBuilder");
   try
   {
+    errno = 0;
     delete bld;
   } catch (const std::exception & e) {
     ReportException(e);
@@ -1602,12 +1595,12 @@ void hdfsFreeBuilder(struct hdfsBuilder *bld)
   }
 }
 
-HDFS_API
-int hdfsBuilderConfSetStr(struct hdfsBuilder *bld, const char *key, const char *val)
+int hdfsBuilderConfSetStr(struct hdfsBuilder *bld, const char *key,
+                          const char *val)
 {
-  resetErrorForApiCall("hdfsBuilderConfSetStr");
   try
   {
+    errno = 0;
     optional<HdfsConfiguration> newConfig = bld->loader.OverlayValue(bld->config,
key, val);
     if (newConfig)
     {
@@ -1619,17 +1612,6 @@ int hdfsBuilderConfSetStr(struct hdfsBuilder *bld, const char *key,
const char *
       ReportError(EINVAL, "Could not change Builder value");
       return -1;
     }
-  } CATCH_AND_REPORT
-}
-
-HDFS_API
-int hdfsConfGetStr(const char *key, char **val)
-{
-  resetErrorForApiCall("hdfsConfGetStr");
-  try
-  {
-    hdfsBuilder builder;
-    return hdfsBuilderConfGetStr(&builder, key, val);
   } catch (const std::exception & e) {
     return ReportException(e);
   } catch (...) {
@@ -1637,39 +1619,52 @@ int hdfsConfGetStr(const char *key, char **val)
   }
 }
 
-HDFS_API
 void hdfsConfStrFree(char *val)
 {
-  resetErrorForApiCall("hdfsConfStrFree");
+  errno = 0;
   free(val);
 }
 
-HDFS_API
 hdfsFS hdfsBuilderConnect(struct hdfsBuilder *bld) {
-  resetErrorForApiCall("hdfsBuilderConnect");
   return doHdfsConnect(bld->overrideHost, bld->overridePort, bld->user, bld->config.GetOptions());
 }
 
-HDFS_API
+int hdfsConfGetStr(const char *key, char **val)
+{
+  try
+  {
+    errno = 0;
+    hdfsBuilder builder;
+    return hdfsBuilderConfGetStr(&builder, key, val);
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
+}
+
 int hdfsConfGetInt(const char *key, int32_t *val)
 {
-  resetErrorForApiCall("hdfsConfGetInt");
   try
   {
+    errno = 0;
     hdfsBuilder builder;
     return hdfsBuilderConfGetInt(&builder, key, val);
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
 //
 //  Extended builder interface
 //
-HDFS_EXT_API
 struct hdfsBuilder *hdfsNewBuilderFromDirectory(const char * configDirectory)
 {
-  resetErrorForApiCall("hdfsNewBuilderFromDirectory");
   try
   {
+    errno = 0;
     return new struct hdfsBuilder(configDirectory);
   } catch (const std::exception & e) {
     ReportException(e);
@@ -1680,12 +1675,12 @@ struct hdfsBuilder *hdfsNewBuilderFromDirectory(const char * configDirectory)
   }
 }
 
-HDFS_EXT_API
-int hdfsBuilderConfGetStr(struct hdfsBuilder *bld, const char *key, char **val)
+int hdfsBuilderConfGetStr(struct hdfsBuilder *bld, const char *key,
+                          char **val)
 {
-  resetErrorForApiCall("hdfsBuilderConfGetStr");
   try
   {
+    errno = 0;
     optional<std::string> value = bld->config.Get(key);
     if (value)
     {
@@ -1698,7 +1693,11 @@ int hdfsBuilderConfGetStr(struct hdfsBuilder *bld, const char *key,
char **val)
       *val = nullptr;
     }
     return 0;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
 // If we're running on a 32-bit platform, we might get 64-bit values that
@@ -1709,12 +1708,11 @@ bool isValidInt(int64_t value)
           value <= std::numeric_limits<int>::max());
 }
 
-HDFS_EXT_API
 int hdfsBuilderConfGetInt(struct hdfsBuilder *bld, const char *key, int32_t *val)
 {
-  resetErrorForApiCall("hdfsBuilderConfGetInt");
   try
   {
+    errno = 0;
     // Pull from default configuration
     optional<int64_t> value = bld->config.GetInt(key);
     if (value)
@@ -1729,15 +1727,18 @@ int hdfsBuilderConfGetInt(struct hdfsBuilder *bld, const char *key,
int32_t *val
     // If not found, don't change val
     ReportError(EINVAL, "Could not get Builder value");
     return 0;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
-HDFS_EXT_API
 int hdfsBuilderConfGetLong(struct hdfsBuilder *bld, const char *key, int64_t *val)
 {
-  resetErrorForApiCall("hdfsBuilderConfGetLong");
   try
   {
+    errno = 0;
     // Pull from default configuration
     optional<int64_t> value = bld->config.GetInt(key);
     if (value)
@@ -1748,7 +1749,11 @@ int hdfsBuilderConfGetLong(struct hdfsBuilder *bld, const char *key,
int64_t *va
     // If not found, don't change val
     ReportError(EINVAL, "Could not get Builder value");
     return 0;
-  } CATCH_AND_REPORT
+  } catch (const std::exception & e) {
+    return ReportException(e);
+  } catch (...) {
+    return ReportCaughtNonException();
+  }
 }
 
 /**
@@ -1824,21 +1829,15 @@ void CForwardingLogger::FreeLogData(LogData *data) {
 }
 
 
-HDFS_EXT_API
 LogData *hdfsCopyLogData(LogData *data) {
-  resetErrorForApiCall("hdfsCopyLogData");
   return CForwardingLogger::CopyLogData(data);
 }
 
-HDFS_EXT_API
 void hdfsFreeLogData(LogData *data) {
-  resetErrorForApiCall("hdfsFreeLogData");
   CForwardingLogger::FreeLogData(data);
 }
 
-HDFS_EXT_API
 void hdfsSetLogFunction(void (*callback)(LogData*)) {
-  resetErrorForApiCall("hdfsSetLogFunction");
   CForwardingLogger *logger = new CForwardingLogger();
   logger->SetCallback(callback);
   LogManager::SetLoggerImplementation(std::unique_ptr<LoggerInterface>(logger));
@@ -1850,8 +1849,8 @@ static bool IsLevelValid(int component) {
   return true;
 }
 
+
 //  should use  __builtin_popcnt as optimization on some platforms
-//    *but maybe not Intel: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=62011
 static int popcnt(int val) {
   int bits = sizeof(val) * 8;
   int count = 0;
@@ -1870,27 +1869,24 @@ static bool IsComponentValid(int component) {
   return true;
 }
 
-HDFS_EXT_API
 int hdfsEnableLoggingForComponent(int component) {
-  resetErrorForApiCall("hdfsEnableLoggingForComponent");
+  errno = 0;
   if(!IsComponentValid(component))
     return -1;
   LogManager::EnableLogForComponent(static_cast<LogSourceComponent>(component));
   return 0;
 }
 
-HDFS_EXT_API
 int hdfsDisableLoggingForComponent(int component) {
-  resetErrorForApiCall("hdfsDisableLoggingForComponent");
+  errno = 0;
   if(!IsComponentValid(component))
     return -1;
   LogManager::DisableLogForComponent(static_cast<LogSourceComponent>(component));
   return 0;
 }
 
-HDFS_EXT_API
 int hdfsSetLoggingLevel(int level) {
-  resetErrorForApiCall("hdfsSetLoggingLevel");
+  errno = 0;
   if(!IsLevelValid(level))
     return -1;
   LogManager::SetLogLevel(static_cast<LogLevel>(level));


---------------------------------------------------------------------
To unsubscribe, e-mail: common-commits-unsubscribe@hadoop.apache.org
For additional commands, e-mail: common-commits-help@hadoop.apache.org


Mime
View raw message