lib/util/gpfswrap.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  Wrapper for GPFS library
   4  *  Copyright (C) Volker Lendecke 2005
   5  *  Copyright (C) Christof Schmitt 2015
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 3 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include "replace.h"
  22 #include "gpfswrap.h"
  23
  24 static int (*gpfs_set_share_fn)(int fd, unsigned int allow, unsigned int deny);
  25 static int (*gpfs_set_lease_fn)(int fd, unsigned int type);
  26 static int (*gpfs_getacl_fn)(char *pathname, int flags, void *acl);
  27 static int (*gpfs_putacl_fn)(char *pathname, int flags, void *acl);
  28 static int (*gpfs_get_realfilename_path_fn)(char *pathname, char *filenamep,
  29                                             int *len);
  30 static int (*gpfs_set_winattrs_path_fn)(char *pathname, int flags,
  31                                         struct gpfs_winattr *attrs);
  32 static int (*gpfs_get_winattrs_path_fn)(char *pathname,
  33                                         struct gpfs_winattr *attrs);
  34 static int (*gpfs_get_winattrs_fn)(int fd, struct gpfs_winattr *attrs);
  35 static int (*gpfs_prealloc_fn)(int fd, gpfs_off64_t start, gpfs_off64_t bytes);
  36 static int (*gpfs_ftruncate_fn)(int fd, gpfs_off64_t length);
  37 static int (*gpfs_lib_init_fn)(int flags);
  38 static int (*gpfs_set_times_path_fn)(char *pathname, int flags,
  39                                      gpfs_timestruc_t times[4]);
  40 static int (*gpfs_quotactl_fn)(char *pathname, int cmd, int id, void *bufp);
  41 static int (*gpfs_fcntl_fn)(int fd, void *argp);
  42 static int (*gpfs_getfilesetid_fn)(char *pathname, char *name, int *idp);
  43 static int (*gpfs_init_trace_fn)(void);
  44 static int (*gpfs_query_trace_fn)(void);
  45 static void (*gpfs_add_trace_fn)(int level, const char *msg);
  46 static void (*gpfs_fini_trace_fn)(void);
  47
  48 int gpfswrap_init(void)
  49 {
  50         static void *l;
  51
  52         if (l != NULL) {
  53                 return 0;
  54         }
  55
  56         l = dlopen("libgpfs.so", RTLD_LAZY);
  57         if (l == NULL) {
  58                 return -1;
  59         }
  60
  61         gpfs_set_share_fn             = dlsym(l, "gpfs_set_share");
  62         gpfs_set_lease_fn             = dlsym(l, "gpfs_set_lease");
  63         gpfs_getacl_fn                = dlsym(l, "gpfs_getacl");
  64         gpfs_putacl_fn                = dlsym(l, "gpfs_putacl");
  65         gpfs_get_realfilename_path_fn = dlsym(l, "gpfs_get_realfilename_path");
  66         gpfs_set_winattrs_path_fn     = dlsym(l, "gpfs_set_winattrs_path");
  67         gpfs_get_winattrs_path_fn     = dlsym(l, "gpfs_get_winattrs_path");
  68         gpfs_get_winattrs_fn          = dlsym(l, "gpfs_get_winattrs");
  69         gpfs_prealloc_fn              = dlsym(l, "gpfs_prealloc");
  70         gpfs_ftruncate_fn             = dlsym(l, "gpfs_ftruncate");
  71         gpfs_lib_init_fn              = dlsym(l, "gpfs_lib_init");
  72         gpfs_set_times_path_fn        = dlsym(l, "gpfs_set_times_path");
  73         gpfs_quotactl_fn              = dlsym(l, "gpfs_quotactl");
  74         gpfs_fcntl_fn                 = dlsym(l, "gpfs_fcntl");
  75         gpfs_getfilesetid_fn          = dlsym(l, "gpfs_getfilesetid");
  76         gpfs_init_trace_fn            = dlsym(l, "gpfs_init_trace");
  77         gpfs_query_trace_fn           = dlsym(l, "gpfs_query_trace");
  78         gpfs_add_trace_fn             = dlsym(l, "gpfs_add_trace");
  79         gpfs_fini_trace_fn            = dlsym(l, "gpfs_fini_trace");
  80
  81         return 0;
  82 }
  83
  84 int gpfswrap_set_share(int fd, unsigned int allow, unsigned int deny)
  85 {
  86         if (gpfs_set_share_fn == NULL) {
  87                 errno = ENOSYS;
  88                 return -1;
  89         }
  90
  91         return gpfs_set_share_fn(fd, allow, deny);
  92 }
  93
  94 int gpfswrap_set_lease(int fd, unsigned int type)
  95 {
  96         if (gpfs_set_lease_fn == NULL) {
  97                 errno = ENOSYS;
  98                 return -1;
  99         }
 100
 101         return gpfs_set_lease_fn(fd, type);
 102 }
 103
 104 int gpfswrap_getacl(char *pathname, int flags, void *acl)
 105 {
 106         if (gpfs_getacl_fn == NULL) {
 107                 errno = ENOSYS;
 108                 return -1;
 109         }
 110
 111         return gpfs_getacl_fn(pathname, flags, acl);
 112 }
 113
 114 int gpfswrap_putacl(char *pathname, int flags, void *acl)
 115 {
 116         if (gpfs_putacl_fn == NULL) {
 117                 errno = ENOSYS;
 118                 return -1;
 119         }
 120
 121         return gpfs_putacl_fn(pathname, flags, acl);
 122 }
 123
 124 int gpfswrap_get_realfilename_path(char *pathname, char *filenamep, int *len)
 125 {
 126         if (gpfs_get_realfilename_path_fn == NULL) {
 127                 errno = ENOSYS;
 128                 return -1;
 129         }
 130
 131         return gpfs_get_realfilename_path_fn(pathname, filenamep, len);
 132 }
 133
 134 int gpfswrap_set_winattrs_path(char *pathname, int flags,
 135                                struct gpfs_winattr *attrs)
 136 {
 137         if (gpfs_set_winattrs_path_fn == NULL) {
 138                 errno = ENOSYS;
 139                 return -1;
 140         }
 141
 142         return gpfs_set_winattrs_path_fn(pathname, flags, attrs);
 143 }
 144
 145 int gpfswrap_get_winattrs_path(char *pathname, struct gpfs_winattr *attrs)
 146 {
 147         if (gpfs_get_winattrs_path_fn == NULL) {
 148                 errno = ENOSYS;
 149                 return -1;
 150         }
 151
 152         return gpfs_get_winattrs_path_fn(pathname, attrs);
 153 }
 154
 155 int gpfswrap_get_winattrs(int fd, struct gpfs_winattr *attrs)
 156 {
 157         if (gpfs_get_winattrs_fn == NULL) {
 158                 errno = ENOSYS;
 159                 return -1;
 160         }
 161
 162         return gpfs_get_winattrs_fn(fd, attrs);
 163 }
 164
 165 int gpfswrap_prealloc(int fd, gpfs_off64_t start, gpfs_off64_t bytes)
 166 {
 167         if (gpfs_prealloc_fn == NULL) {
 168                 errno = ENOSYS;
 169                 return -1;
 170         }
 171
 172         return gpfs_prealloc_fn(fd, start, bytes);
 173 }
 174
 175 int gpfswrap_ftruncate(int fd, gpfs_off64_t length)
 176 {
 177         if (gpfs_ftruncate_fn == NULL) {
 178                 errno = ENOSYS;
 179                 return -1;
 180         }
 181
 182         return gpfs_ftruncate_fn(fd, length);
 183 }
 184
 185 int gpfswrap_lib_init(int flags)
 186 {
 187         if (gpfs_lib_init_fn == NULL) {
 188                 errno = ENOSYS;
 189                 return -1;
 190         }
 191
 192         return gpfs_lib_init_fn(flags);
 193 }
 194
 195 int gpfswrap_set_times_path(char *pathname, int flags,
 196                             gpfs_timestruc_t times[4])
 197 {
 198         if (gpfs_set_times_path_fn == NULL) {
 199                 errno = ENOSYS;
 200                 return -1;
 201         }
 202
 203         return gpfs_set_times_path_fn(pathname, flags, times);
 204 }
 205
 206 int gpfswrap_quotactl(char *pathname, int cmd, int id, void *bufp)
 207 {
 208         if (gpfs_quotactl_fn == NULL) {
 209                 errno = ENOSYS;
 210                 return -1;
 211         }
 212
 213         return gpfs_quotactl_fn(pathname, cmd, id, bufp);
 214 }
 215
 216 int gpfswrap_fcntl(int fd, void *argp)
 217 {
 218         if (gpfs_fcntl_fn == NULL) {
 219                 errno = ENOSYS;
 220                 return -1;
 221         }
 222
 223         return gpfs_fcntl_fn(fd, argp);
 224 }
 225
 226 int gpfswrap_getfilesetid(char *pathname, char *name, int *idp)
 227 {
 228         if (gpfs_getfilesetid_fn == NULL) {
 229                 errno = ENOSYS;
 230                 return -1;
 231         }
 232
 233         return gpfs_getfilesetid_fn(pathname, name, idp);
 234 }
 235
 236 int gpfswrap_init_trace(void)
 237 {
 238         if (gpfs_init_trace_fn == NULL) {
 239                 errno = ENOSYS;
 240                 return -1;
 241         }
 242
 243         return gpfs_init_trace_fn();
 244 }
 245
 246 int gpfswrap_query_trace(void)
 247 {
 248         if (gpfs_query_trace_fn == NULL) {
 249                 errno = ENOSYS;
 250                 return -1;
 251         }
 252
 253         return gpfs_query_trace_fn();
 254 }
 255
 256 void gpfswrap_add_trace(int level, const char *msg)
 257 {
 258         if (gpfs_add_trace_fn == NULL) {
 259                 return;
 260         }
 261
 262         gpfs_add_trace_fn(level, msg);
 263 }
 264
 265 void gpfswrap_fini_trace(void)
 266 {
 267         if (gpfs_fini_trace_fn == NULL) {
 268                 return;
 269         }
 270
 271         gpfs_fini_trace_fn();
 272 }