source3/modules/vfs_ceph.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Wrap disk only vfs functions to sidestep dodgy compilers.
   4    Copyright (C) Tim Potter 1998
   5    Copyright (C) Jeremy Allison 2007
   6    Copyright (C) Brian Chrisman 2011 <bchrisman@gmail.com>
   7    Copyright (C) Richard Sharpe 2011 <realrichardsharpe@gmail.com>
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 /*
  24  * This VFS only works with the libceph.so user-space client. It is not needed
  25  * if you are using the kernel client or the FUSE client.
  26  *
  27  * Add the following smb.conf parameter to each share that will be hosted on
  28  * Ceph:
  29  *
  30  *   vfs objects = ceph [any others you need go here]
  31  */
  32
  33 #include "includes.h"
  34 #include "smbd/smbd.h"
  35 #include <dirent.h>
  36 #include <sys/statvfs.h>
  37 #include "cephfs/libcephfs.h"
  38 #include "smbprofile.h"
  39
  40 #undef DBGC_CLASS
  41 #define DBGC_CLASS DBGC_VFS
  42
  43 /*
  44  * Use %llu whenever we have a 64bit unsigned int, and cast to (long long unsigned)
  45  */
  46 #define llu(_var) ((long long unsigned)_var)
  47
  48 /*
  49  * Note, libceph's return code model is to return -errno! So we have to convert
  50  * to what Samba expects, with is set errno to -return and return -1
  51  */
  52 #define WRAP_RETURN(_res) \
  53         errno = 0; \
  54         if (_res < 0) { \
  55                 errno = -_res; \
  56                 return -1; \
  57         } \
  58         return _res \
  59
  60 /*
  61  * We mount only one file system and then all shares are assumed to be in that.
  62  * FIXME: If we want to support more than one FS, then we have to deal with
  63  * this differently.
  64  *
  65  * So, cmount tells us if we have been this way before and whether
  66  * we need to mount ceph and cmount_cnt tells us how many times we have
  67  * connected
  68  */
  69 static struct ceph_mount_info * cmount = NULL;
  70 static uint32_t cmount_cnt = 0;
  71
  72 /* Check for NULL pointer parameters in cephwrap_* functions */
  73
  74 /* We don't want to have NULL function pointers lying around.  Someone
  75    is sure to try and execute them.  These stubs are used to prevent
  76    this possibility. */
  77
  78 static int cephwrap_connect(struct vfs_handle_struct *handle,  const char *service, const char *user)
  79 {
  80         int ret;
  81         char buf[256];
  82
  83         const char * conf_file;
  84
  85         if (cmount) {
  86                 handle->data = cmount; /* We have been here before */
  87                 cmount_cnt++;
  88                 return 0;
  89         }
  90
  91         conf_file = lp_parm_const_string(SNUM(handle->conn), "ceph", "config_file", NULL);
  92
  93         DEBUG(2, ( "[CEPH] calling: ceph_create\n" ));
  94         ret = ceph_create(&cmount, NULL);
  95         if (ret)
  96                 goto err_out;
  97
  98         if (conf_file) {
  99                 /* Override the config file */
 100                 DEBUG(2, ( "[CEPH] calling: ceph_conf_read_file\n" ));
 101                 ret = ceph_conf_read_file(cmount, conf_file);
 102         } else {
 103
 104                 DEBUG(2, ( "[CEPH] calling: ceph_conf_read_file with %s\n", conf_file));
 105                 ret = ceph_conf_read_file(cmount, NULL);
 106         }
 107
 108         if (ret)
 109                 goto err_out;
 110
 111         DEBUG(2, ( "[CEPH] calling: ceph_conf_get\n" ));
 112         ret = ceph_conf_get(cmount, "log file", buf, sizeof(buf));
 113         if (ret < 0)
 114                 goto err_out;
 115
 116         DEBUG(2, ("[CEPH] calling: ceph_mount\n"));
 117         ret = ceph_mount(cmount, NULL);
 118         if (ret < 0)
 119                 goto err_out;
 120
 121
 122         /*
 123          * encode mount context/state into our vfs/connection holding structure
 124          * cmount is a ceph_mount_t*
 125          */
 126         handle->data = cmount;
 127         cmount_cnt++;
 128
 129         return 0;
 130
 131 err_out:
 132         /*
 133          * Handle the error correctly. Ceph returns -errno.
 134          */
 135         DEBUG(2, ("[CEPH] Error return: %s\n", strerror(-ret)));
 136         WRAP_RETURN(ret);
 137 }
 138
 139 static void cephwrap_disconnect(struct vfs_handle_struct *handle)
 140 {
 141         if (!cmount) {
 142                 DEBUG(0, ("[CEPH] Error, ceph not mounted\n"));
 143                 return;
 144         }
 145
 146         /* Should we unmount/shutdown? Only if the last disconnect? */
 147         if (--cmount_cnt) {
 148                 DEBUG(10, ("[CEPH] Not shuting down CEPH because still more connections\n"));
 149                 return;
 150         }
 151
 152         ceph_shutdown(cmount);
 153
 154         cmount = NULL;  /* Make it safe */
 155 }
 156
 157 /* Disk operations */
 158
 159 static uint64_t cephwrap_disk_free(struct vfs_handle_struct *handle,  const char *path, bool small_query, uint64_t *bsize,
 160                                uint64_t *dfree, uint64_t *dsize)
 161 {
 162         struct statvfs statvfs_buf;
 163         int ret;
 164
 165         if (!(ret = ceph_statfs(handle->data, path, &statvfs_buf))) {
 166                 /*
 167                  * Provide all the correct values.
 168                  */
 169                 *bsize = statvfs_buf.f_bsize;
 170                 *dfree = statvfs_buf.f_bsize * statvfs_buf.f_bavail;
 171                 *dsize = statvfs_buf.f_bsize * statvfs_buf.f_blocks;
 172                 DEBUG(10, ("[CEPH] bsize: %llu, dfree: %llu, dsize: %llu\n",
 173                         llu(*bsize), llu(*dfree), llu(*dsize)));
 174                 return *dfree;
 175         } else {
 176                 DEBUG(10, ("[CEPH] ceph_statfs returned %d\n", ret));
 177                 WRAP_RETURN(ret);
 178         }
 179 }
 180
 181 static int cephwrap_get_quota(struct vfs_handle_struct *handle,  enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
 182 {
 183         /* libceph: Ceph does not implement this */
 184 #if 0
 185 /* was ifdef HAVE_SYS_QUOTAS */
 186         int ret;
 187
 188         ret = ceph_get_quota(handle->conn->connectpath, qtype, id, qt);
 189
 190         if (ret) {
 191                 errno = -ret;
 192                 ret = -1;
 193         }
 194
 195         return ret;
 196 #else
 197         errno = ENOSYS;
 198         return -1;
 199 #endif
 200 }
 201
 202 static int cephwrap_set_quota(struct vfs_handle_struct *handle,  enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
 203 {
 204         /* libceph: Ceph does not implement this */
 205 #if 0
 206 /* was ifdef HAVE_SYS_QUOTAS */
 207         int ret;
 208
 209         ret = ceph_set_quota(handle->conn->connectpath, qtype, id, qt);
 210         if (ret) {
 211                 errno = -ret;
 212                 ret = -1;
 213         }
 214
 215         return ret;
 216 #else
 217         WRAP_RETURN(-ENOSYS);
 218 #endif
 219 }
 220
 221 static int cephwrap_statvfs(struct vfs_handle_struct *handle,  const char *path, vfs_statvfs_struct *statbuf)
 222 {
 223         struct statvfs statvfs_buf;
 224         int ret;
 225
 226         ret = ceph_statfs(handle->data, path, &statvfs_buf);
 227         if (ret < 0) {
 228                 WRAP_RETURN(ret);
 229         } else {
 230                 statbuf->OptimalTransferSize = statvfs_buf.f_frsize;
 231                 statbuf->BlockSize = statvfs_buf.f_bsize;
 232                 statbuf->TotalBlocks = statvfs_buf.f_blocks;
 233                 statbuf->BlocksAvail = statvfs_buf.f_bfree;
 234                 statbuf->UserBlocksAvail = statvfs_buf.f_bavail;
 235                 statbuf->TotalFileNodes = statvfs_buf.f_files;
 236                 statbuf->FreeFileNodes = statvfs_buf.f_ffree;
 237                 statbuf->FsIdentifier = statvfs_buf.f_fsid;
 238                 DEBUG(10, ("[CEPH] f_bsize: %ld, f_blocks: %ld, f_bfree: %ld, f_bavail: %ld\n",
 239                         (long int)statvfs_buf.f_bsize, (long int)statvfs_buf.f_blocks,
 240                         (long int)statvfs_buf.f_bfree, (long int)statvfs_buf.f_bavail));
 241         }
 242         return ret;
 243 }
 244
 245 /* Directory operations */
 246
 247 static DIR *cephwrap_opendir(struct vfs_handle_struct *handle,  const char *fname, const char *mask, uint32 attr)
 248 {
 249         int ret = 0;
 250         struct ceph_dir_result *result;
 251         DEBUG(10, ("[CEPH] opendir(%p, %s)\n", handle, fname));
 252
 253         /* Returns NULL if it does not exist or there are problems ? */
 254         ret = ceph_opendir(handle->data, fname, &result);
 255         if (ret < 0) {
 256                 result = NULL;
 257                 errno = -ret; /* We return result which is NULL in this case */
 258         }
 259
 260         DEBUG(10, ("[CEPH] opendir(...) = %d\n", ret));
 261         return (DIR *) result;
 262 }
 263
 264 static DIR *cephwrap_fdopendir(struct vfs_handle_struct *handle,
 265                                struct files_struct *fsp,
 266                                const char *mask,
 267                                uint32 attributes)
 268 {
 269         int ret = 0;
 270         struct ceph_dir_result *result;
 271         DEBUG(10, ("[CEPH] fdopendir(%p, %p)\n", handle, fsp));
 272
 273         ret = ceph_opendir(handle->data, fsp->fsp_name->base_name, &result);
 274         if (ret < 0) {
 275                 result = NULL;
 276                 errno = -ret; /* We return result which is NULL in this case */
 277         }
 278
 279         DEBUG(10, ("[CEPH] fdopendir(...) = %d\n", ret));
 280         return (DIR *) result;
 281 }
 282
 283 static struct dirent *cephwrap_readdir(struct vfs_handle_struct *handle,
 284                                        DIR *dirp,
 285                                        SMB_STRUCT_STAT *sbuf)
 286 {
 287         struct dirent *result;
 288
 289         DEBUG(10, ("[CEPH] readdir(%p, %p)\n", handle, dirp));
 290         result = ceph_readdir(handle->data, (struct ceph_dir_result *) dirp);
 291         DEBUG(10, ("[CEPH] readdir(...) = %p\n", result));
 292
 293         /* Default Posix readdir() does not give us stat info.
 294          * Set to invalid to indicate we didn't return this info. */
 295         if (sbuf)
 296                 SET_STAT_INVALID(*sbuf);
 297         return result;
 298 }
 299
 300 static void cephwrap_seekdir(struct vfs_handle_struct *handle, DIR *dirp, long offset)
 301 {
 302         DEBUG(10, ("[CEPH] seekdir(%p, %p, %ld)\n", handle, dirp, offset));
 303         ceph_seekdir(handle->data, (struct ceph_dir_result *) dirp, offset);
 304 }
 305
 306 static long cephwrap_telldir(struct vfs_handle_struct *handle, DIR *dirp)
 307 {
 308         long ret;
 309         DEBUG(10, ("[CEPH] telldir(%p, %p)\n", handle, dirp));
 310         ret = ceph_telldir(handle->data, (struct ceph_dir_result *) dirp);
 311         DEBUG(10, ("[CEPH] telldir(...) = %ld\n", ret));
 312         WRAP_RETURN(ret);
 313 }
 314
 315 static void cephwrap_rewinddir(struct vfs_handle_struct *handle, DIR *dirp)
 316 {
 317         DEBUG(10, ("[CEPH] rewinddir(%p, %p)\n", handle, dirp));
 318         ceph_rewinddir(handle->data, (struct ceph_dir_result *) dirp);
 319 }
 320
 321 static int cephwrap_mkdir(struct vfs_handle_struct *handle,  const char *path, mode_t mode)
 322 {
 323         int result;
 324         bool has_dacl = False;
 325         char *parent = NULL;
 326
 327         DEBUG(10, ("[CEPH] mkdir(%p, %s)\n", handle, path));
 328
 329         if (lp_inherit_acls(SNUM(handle->conn))
 330             && parent_dirname(talloc_tos(), path, &parent, NULL)
 331             && (has_dacl = directory_has_default_acl(handle->conn, parent)))
 332                 mode = 0777;
 333
 334         TALLOC_FREE(parent);
 335
 336         result = ceph_mkdir(handle->data, path, mode);
 337
 338         /*
 339          * Note. This order is important
 340          */
 341         if (result) {
 342                 WRAP_RETURN(result);
 343         } else if (result == 0 && !has_dacl) {
 344                 /*
 345                  * We need to do this as the default behavior of POSIX ACLs
 346                  * is to set the mask to be the requested group permission
 347                  * bits, not the group permission bits to be the requested
 348                  * group permission bits. This is not what we want, as it will
 349                  * mess up any inherited ACL bits that were set. JRA.
 350                  */
 351                 int saved_errno = errno; /* We may get ENOSYS */
 352                 if ((SMB_VFS_CHMOD_ACL(handle->conn, path, mode) == -1) && (errno == ENOSYS))
 353                         errno = saved_errno;
 354         }
 355
 356         return result;
 357 }
 358
 359 static int cephwrap_rmdir(struct vfs_handle_struct *handle,  const char *path)
 360 {
 361         int result;
 362
 363         DEBUG(10, ("[CEPH] rmdir(%p, %s)\n", handle, path));
 364         result = ceph_rmdir(handle->data, path);
 365         DEBUG(10, ("[CEPH] rmdir(...) = %d\n", result));
 366         WRAP_RETURN(result);
 367 }
 368
 369 static int cephwrap_closedir(struct vfs_handle_struct *handle, DIR *dirp)
 370 {
 371         int result;
 372
 373         DEBUG(10, ("[CEPH] closedir(%p, %p)\n", handle, dirp));
 374         result = ceph_closedir(handle->data, (struct ceph_dir_result *) dirp);
 375         DEBUG(10, ("[CEPH] closedir(...) = %d\n", result));
 376         WRAP_RETURN(result);
 377 }
 378
 379 /* File operations */
 380
 381 static int cephwrap_open(struct vfs_handle_struct *handle,
 382                         struct smb_filename *smb_fname,
 383                         files_struct *fsp, int flags, mode_t mode)
 384 {
 385         int result = -ENOENT;
 386         DEBUG(10, ("[CEPH] open(%p, %s, %p, %d, %d)\n", handle, smb_fname_str_dbg(smb_fname), fsp, flags, mode));
 387
 388         if (smb_fname->stream_name) {
 389                 goto out;
 390         }
 391
 392         result = ceph_open(handle->data, smb_fname->base_name, flags, mode);
 393 out:
 394         DEBUG(10, ("[CEPH] open(...) = %d\n", result));
 395         WRAP_RETURN(result);
 396 }
 397
 398 static int cephwrap_close(struct vfs_handle_struct *handle, files_struct *fsp)
 399 {
 400         int result;
 401
 402         DEBUG(10, ("[CEPH] close(%p, %p)\n", handle, fsp));
 403         result = ceph_close(handle->data, fsp->fh->fd);
 404         DEBUG(10, ("[CEPH] close(...) = %d\n", result));
 405
 406         WRAP_RETURN(result);
 407 }
 408
 409 static ssize_t cephwrap_read(struct vfs_handle_struct *handle, files_struct *fsp, void *data, size_t n)
 410 {
 411         ssize_t result;
 412
 413         DEBUG(10, ("[CEPH] read(%p, %p, %p, %llu)\n", handle, fsp, data, llu(n)));
 414
 415         /* Using -1 for the offset means read/write rather than pread/pwrite */
 416         result = ceph_read(handle->data, fsp->fh->fd, data, n, -1);
 417         DEBUG(10, ("[CEPH] read(...) = %llu\n", llu(result)));
 418         WRAP_RETURN(result);
 419 }
 420
 421 static ssize_t cephwrap_pread(struct vfs_handle_struct *handle, files_struct *fsp, void *data,
 422                         size_t n, off_t offset)
 423 {
 424         ssize_t result;
 425
 426         DEBUG(10, ("[CEPH] pread(%p, %p, %p, %llu, %llu)\n", handle, fsp, data, llu(n), llu(offset)));
 427
 428         result = ceph_read(handle->data, fsp->fh->fd, data, n, offset);
 429         DEBUG(10, ("[CEPH] pread(...) = %llu\n", llu(result)));
 430         WRAP_RETURN(result);
 431 }
 432
 433
 434 static ssize_t cephwrap_write(struct vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n)
 435 {
 436         ssize_t result;
 437
 438         DEBUG(10, ("[CEPH] write(%p, %p, %p, %llu)\n", handle, fsp, data, llu(n)));
 439
 440         result = ceph_write(handle->data, fsp->fh->fd, data, n, -1);
 441
 442         DEBUG(10, ("[CEPH] write(...) = %llu\n", llu(result)));
 443         if (result < 0) {
 444                 WRAP_RETURN(result);
 445         }
 446         fsp->fh->pos += result;
 447         return result;
 448 }
 449
 450 static ssize_t cephwrap_pwrite(struct vfs_handle_struct *handle, files_struct *fsp, const void *data,
 451                         size_t n, off_t offset)
 452 {
 453         ssize_t result;
 454
 455         DEBUG(10, ("[CEPH] pwrite(%p, %p, %p, %llu, %llu)\n", handle, fsp, data, llu(n), llu(offset)));
 456         result = ceph_write(handle->data, fsp->fh->fd, data, n, offset);
 457         DEBUG(10, ("[CEPH] pwrite(...) = %llu\n", llu(result)));
 458         WRAP_RETURN(result);
 459 }
 460
 461 static off_t cephwrap_lseek(struct vfs_handle_struct *handle, files_struct *fsp, off_t offset, int whence)
 462 {
 463         off_t result = 0;
 464
 465         DEBUG(10, ("[CEPH] cephwrap_lseek\n"));
 466         /* Cope with 'stat' file opens. */
 467         if (fsp->fh->fd != -1) {
 468                 result = ceph_lseek(handle->data, fsp->fh->fd, offset, whence);
 469         }
 470         WRAP_RETURN(result);
 471 }
 472
 473 static ssize_t cephwrap_sendfile(struct vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr,
 474                         off_t offset, size_t n)
 475 {
 476         /*
 477          * We cannot support sendfile because libceph is in user space.
 478          */
 479         DEBUG(10, ("[CEPH] cephwrap_sendfile\n"));
 480         errno = ENOTSUP;
 481         return -1;
 482 }
 483
 484 static ssize_t cephwrap_recvfile(struct vfs_handle_struct *handle,
 485                         int fromfd,
 486                         files_struct *tofsp,
 487                         off_t offset,
 488                         size_t n)
 489 {
 490         /*
 491          * We cannot support recvfile because libceph is in user space.
 492          */
 493         DEBUG(10, ("[CEPH] cephwrap_recvfile\n"));
 494         errno=ENOTSUP;
 495         return -1;
 496 }
 497
 498 static int cephwrap_rename(struct vfs_handle_struct *handle,
 499                           const struct smb_filename *smb_fname_src,
 500                           const struct smb_filename *smb_fname_dst)
 501 {
 502         int result = -1;
 503         DEBUG(10, ("[CEPH] cephwrap_rename\n"));
 504         if (smb_fname_src->stream_name || smb_fname_dst->stream_name) {
 505                 errno = ENOENT;
 506                 return result;
 507         }
 508
 509         result = ceph_rename(handle->data, smb_fname_src->base_name, smb_fname_dst->base_name);
 510         WRAP_RETURN(result);
 511 }
 512
 513 static int cephwrap_fsync(struct vfs_handle_struct *handle, files_struct *fsp)
 514 {
 515         int result;
 516         DEBUG(10, ("[CEPH] cephwrap_fsync\n"));
 517         result = ceph_fsync(handle->data, fsp->fh->fd, false);
 518         WRAP_RETURN(result);
 519 }
 520
 521 static void cephwrap_init_stat_ex_from_stat(struct stat_ex *dst, const struct stat *src)
 522 {
 523         ZERO_STRUCT(*dst);
 524
 525         dst->st_ex_dev = src->st_dev;
 526         dst->st_ex_ino = src->st_ino;
 527         dst->st_ex_mode = src->st_mode;
 528         dst->st_ex_nlink = src->st_nlink;
 529         dst->st_ex_uid = src->st_uid;
 530         dst->st_ex_gid = src->st_gid;
 531         dst->st_ex_rdev = src->st_rdev;
 532         dst->st_ex_size = src->st_size;
 533         dst->st_ex_atime.tv_sec = src->st_atime;
 534         dst->st_ex_mtime.tv_sec = src->st_mtime;
 535         dst->st_ex_ctime.tv_sec = src->st_ctime;
 536         dst->st_ex_btime.tv_sec = src->st_mtime;
 537         dst->st_ex_blksize = src->st_blksize;
 538         dst->st_ex_blocks = src->st_blocks;
 539 }
 540
 541 static int cephwrap_stat(struct vfs_handle_struct *handle,
 542                         struct smb_filename *smb_fname)
 543 {
 544         int result = -1;
 545         struct stat stbuf;
 546
 547         DEBUG(10, ("[CEPH] stat(%p, %s)\n", handle, smb_fname_str_dbg(smb_fname)));
 548
 549         if (smb_fname->stream_name) {
 550                 errno = ENOENT;
 551                 return result;
 552         }
 553
 554         result = ceph_stat(handle->data, smb_fname->base_name, (struct stat *) &stbuf);
 555         DEBUG(10, ("[CEPH] stat(...) = %d\n", result));
 556         if (result < 0) {
 557                 WRAP_RETURN(result);
 558         } else {
 559                 DEBUG(10, ("[CEPH]\tstbuf = {dev = %llu, ino = %llu, mode = 0x%x, nlink = %llu, "
 560                            "uid = %d, gid = %d, rdev = %llu, size = %llu, blksize = %llu, "
 561                            "blocks = %llu, atime = %llu, mtime = %llu, ctime = %llu}\n",
 562                            llu(stbuf.st_dev), llu(stbuf.st_ino), stbuf.st_mode, llu(stbuf.st_nlink),
 563                            stbuf.st_uid, stbuf.st_gid, llu(stbuf.st_rdev), llu(stbuf.st_size), llu(stbuf.st_blksize),
 564                            llu(stbuf.st_blocks), llu(stbuf.st_atime), llu(stbuf.st_mtime), llu(stbuf.st_ctime)));
 565         }
 566         cephwrap_init_stat_ex_from_stat(&(smb_fname->st), &stbuf);
 567         DEBUG(10, ("[CEPH] mode = 0x%x\n", smb_fname->st.st_ex_mode));
 568         return result;
 569 }
 570
 571 static int cephwrap_fstat(struct vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
 572 {
 573         int result = -1;
 574         struct stat stbuf;
 575
 576         DEBUG(10, ("[CEPH] fstat(%p, %d)\n", handle, fsp->fh->fd));
 577         result = ceph_fstat(handle->data, fsp->fh->fd, (struct stat *) &stbuf);
 578         DEBUG(10, ("[CEPH] fstat(...) = %d\n", result));
 579         if (result < 0) {
 580                 WRAP_RETURN(result);
 581         } else {
 582                 DEBUG(10, ("[CEPH]\tstbuf = {dev = %llu, ino = %llu, mode = 0x%x, nlink = %llu, "
 583                            "uid = %d, gid = %d, rdev = %llu, size = %llu, blksize = %llu, "
 584                            "blocks = %llu, atime = %llu, mtime = %llu, ctime = %llu}\n",
 585                            llu(stbuf.st_dev), llu(stbuf.st_ino), stbuf.st_mode, llu(stbuf.st_nlink),
 586                            stbuf.st_uid, stbuf.st_gid, llu(stbuf.st_rdev), llu(stbuf.st_size), llu(stbuf.st_blksize),
 587                            llu(stbuf.st_blocks), llu(stbuf.st_atime), llu(stbuf.st_mtime), llu(stbuf.st_ctime)));
 588         }
 589
 590         cephwrap_init_stat_ex_from_stat(sbuf, &stbuf);
 591         DEBUG(10, ("[CEPH] mode = 0x%x\n", sbuf->st_ex_mode));
 592         return result;
 593 }
 594
 595 static int cephwrap_lstat(struct vfs_handle_struct *handle,
 596                          struct smb_filename *smb_fname)
 597 {
 598         int result = -1;
 599         struct stat stbuf;
 600
 601         DEBUG(10, ("[CEPH] lstat(%p, %s)\n", handle, smb_fname_str_dbg(smb_fname)));
 602
 603         if (smb_fname->stream_name) {
 604                 errno = ENOENT;
 605                 return result;
 606         }
 607
 608         result = ceph_lstat(handle->data, smb_fname->base_name, &stbuf);
 609         DEBUG(10, ("[CEPH] lstat(...) = %d\n", result));
 610         if (result < 0) {
 611                 WRAP_RETURN(result);
 612         }
 613         cephwrap_init_stat_ex_from_stat(&(smb_fname->st), &stbuf);
 614         return result;
 615 }
 616
 617 static int cephwrap_unlink(struct vfs_handle_struct *handle,
 618                           const struct smb_filename *smb_fname)
 619 {
 620         int result = -1;
 621
 622         DEBUG(10, ("[CEPH] unlink(%p, %s)\n", handle, smb_fname_str_dbg(smb_fname)));
 623         if (smb_fname->stream_name) {
 624                 errno = ENOENT;
 625                 return result;
 626         }
 627         result = ceph_unlink(handle->data, smb_fname->base_name);
 628         DEBUG(10, ("[CEPH] unlink(...) = %d\n", result));
 629         WRAP_RETURN(result);
 630 }
 631
 632 static int cephwrap_chmod(struct vfs_handle_struct *handle,  const char *path, mode_t mode)
 633 {
 634         int result;
 635
 636         DEBUG(10, ("[CEPH] chmod(%p, %s, %d)\n", handle, path, mode));
 637
 638         /*
 639          * We need to do this due to the fact that the default POSIX ACL
 640          * chmod modifies the ACL *mask* for the group owner, not the
 641          * group owner bits directly. JRA.
 642          */
 643
 644
 645         {
 646                 int saved_errno = errno; /* We might get ENOSYS */
 647                 if ((result = SMB_VFS_CHMOD_ACL(handle->conn, path, mode)) == 0) {
 648                         return result;
 649                 }
 650                 /* Error - return the old errno. */
 651                 errno = saved_errno;
 652         }
 653
 654         result = ceph_chmod(handle->data, path, mode);
 655         DEBUG(10, ("[CEPH] chmod(...) = %d\n", result));
 656         WRAP_RETURN(result);
 657 }
 658
 659 static int cephwrap_fchmod(struct vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
 660 {
 661         int result;
 662
 663         DEBUG(10, ("[CEPH] fchmod(%p, %p, %d)\n", handle, fsp, mode));
 664
 665         /*
 666          * We need to do this due to the fact that the default POSIX ACL
 667          * chmod modifies the ACL *mask* for the group owner, not the
 668          * group owner bits directly. JRA.
 669          */
 670
 671         {
 672                 int saved_errno = errno; /* We might get ENOSYS */
 673                 if ((result = SMB_VFS_FCHMOD_ACL(fsp, mode)) == 0) {
 674                         return result;
 675                 }
 676                 /* Error - return the old errno. */
 677                 errno = saved_errno;
 678         }
 679
 680 #if defined(HAVE_FCHMOD)
 681         result = ceph_fchmod(handle->data, fsp->fh->fd, mode);
 682         DEBUG(10, ("[CEPH] fchmod(...) = %d\n", result));
 683         WRAP_RETURN(result);
 684 #else
 685         errno = ENOSYS;
 686 #endif
 687         return -1;
 688 }
 689
 690 static int cephwrap_chown(struct vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
 691 {
 692         int result;
 693         DEBUG(10, ("[CEPH] chown(%p, %s, %d, %d)\n", handle, path, uid, gid));
 694         result = ceph_chown(handle->data, path, uid, gid);
 695         DEBUG(10, ("[CEPH] chown(...) = %d\n", result));
 696         WRAP_RETURN(result);
 697 }
 698
 699 static int cephwrap_fchown(struct vfs_handle_struct *handle, files_struct *fsp, uid_t uid, gid_t gid)
 700 {
 701         int result;
 702 #ifdef HAVE_FCHOWN
 703
 704         DEBUG(10, ("[CEPH] fchown(%p, %p, %d, %d)\n", handle, fsp, uid, gid));
 705         result = ceph_fchown(handle->data, fsp->fh->fd, uid, gid);
 706         DEBUG(10, ("[CEPH] fchown(...) = %d\n", result));
 707         WRAP_RETURN(result);
 708 #else
 709         errno = ENOSYS;
 710         result = -1;
 711 #endif
 712         return result;
 713 }
 714
 715 static int cephwrap_lchown(struct vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
 716 {
 717         int result;
 718
 719         DEBUG(10, ("[CEPH] lchown(%p, %s, %d, %d)\n", handle, path, uid, gid));
 720         result = ceph_lchown(handle->data, path, uid, gid);
 721         DEBUG(10, ("[CEPH] lchown(...) = %d\n", result));
 722         WRAP_RETURN(result);
 723 }
 724
 725 static int cephwrap_chdir(struct vfs_handle_struct *handle,  const char *path)
 726 {
 727         int result = -1;
 728         DEBUG(10, ("[CEPH] chdir(%p, %s)\n", handle, path));
 729         /*
 730          * If the path is just / use chdir because Ceph is below / and
 731          * cannot deal with changing directory above its mount point
 732          */
 733         if (path && !strcmp(path, "/"))
 734                 return chdir(path);
 735
 736         result = ceph_chdir(handle->data, path);
 737         DEBUG(10, ("[CEPH] chdir(...) = %d\n", result));
 738         WRAP_RETURN(result);
 739 }
 740
 741 static char *cephwrap_getwd(struct vfs_handle_struct *handle)
 742 {
 743         const char *cwd = ceph_getcwd(handle->data);
 744         DEBUG(10, ("[CEPH] getwd(%p) = %s\n", handle, cwd));
 745         return SMB_STRDUP(cwd);
 746 }
 747
 748 static int cephwrap_ntimes(struct vfs_handle_struct *handle,
 749                          const struct smb_filename *smb_fname,
 750                          struct smb_file_time *ft)
 751 {
 752         struct utimbuf buf;
 753         buf.actime = ft->atime.tv_sec;
 754         buf.modtime = ft->mtime.tv_sec;
 755         int result = ceph_utime(handle->data, smb_fname->base_name, &buf);
 756         DEBUG(10, ("[CEPH] ntimes(%p, %s, {%ld, %ld, %ld, %ld}) = %d\n", handle, smb_fname_str_dbg(smb_fname),
 757                                 ft->mtime.tv_sec, ft->atime.tv_sec, ft->ctime.tv_sec,
 758                                 ft->create_time.tv_sec, result));
 759         return result;
 760 }
 761
 762 static int strict_allocate_ftruncate(struct vfs_handle_struct *handle, files_struct *fsp, off_t len)
 763 {
 764         off_t space_to_write;
 765         uint64_t space_avail;
 766         uint64_t bsize,dfree,dsize;
 767         int ret;
 768         NTSTATUS status;
 769         SMB_STRUCT_STAT *pst;
 770
 771         status = vfs_stat_fsp(fsp);
 772         if (!NT_STATUS_IS_OK(status)) {
 773                 return -1;
 774         }
 775         pst = &fsp->fsp_name->st;
 776
 777 #ifdef S_ISFIFO
 778         if (S_ISFIFO(pst->st_ex_mode))
 779                 return 0;
 780 #endif
 781
 782         if (pst->st_ex_size == len)
 783                 return 0;
 784
 785         /* Shrink - just ftruncate. */
 786         if (pst->st_ex_size > len)
 787                 return ftruncate(fsp->fh->fd, len);
 788
 789         space_to_write = len - pst->st_ex_size;
 790
 791         /* for allocation try fallocate first. This can fail on some
 792            platforms e.g. when the filesystem doesn't support it and no
 793            emulation is being done by the libc (like on AIX with JFS1). In that
 794            case we do our own emulation. fallocate implementations can
 795            return ENOTSUP or EINVAL in cases like that. */
 796         ret = SMB_VFS_FALLOCATE(fsp, VFS_FALLOCATE_EXTEND_SIZE,
 797                                 pst->st_ex_size, space_to_write);
 798         if (ret == -1 && errno == ENOSPC) {
 799                 return -1;
 800         }
 801         if (ret == 0) {
 802                 return 0;
 803         }
 804         DEBUG(10,("[CEPH] strict_allocate_ftruncate: SMB_VFS_FALLOCATE failed with "
 805                 "error %d. Falling back to slow manual allocation\n", errno));
 806
 807         /* available disk space is enough or not? */
 808         space_avail = get_dfree_info(fsp->conn,
 809                                      fsp->fsp_name->base_name, false,
 810                                      &bsize,&dfree,&dsize);
 811         /* space_avail is 1k blocks */
 812         if (space_avail == (uint64_t)-1 ||
 813                         ((uint64_t)space_to_write/1024 > space_avail) ) {
 814                 errno = ENOSPC;
 815                 return -1;
 816         }
 817
 818         /* Write out the real space on disk. */
 819         return vfs_slow_fallocate(fsp, pst->st_ex_size, space_to_write);
 820 }
 821
 822 static int cephwrap_ftruncate(struct vfs_handle_struct *handle, files_struct *fsp, off_t len)
 823 {
 824         int result = -1;
 825         SMB_STRUCT_STAT st;
 826         char c = 0;
 827         off_t currpos;
 828
 829         DEBUG(10, ("[CEPH] ftruncate(%p, %p, %llu\n", handle, fsp, llu(len)));
 830
 831         if (lp_strict_allocate(SNUM(fsp->conn))) {
 832                 result = strict_allocate_ftruncate(handle, fsp, len);
 833                 return result;
 834         }
 835
 836         /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
 837            sys_ftruncate if the system supports it. Then I discovered that
 838            you can have some filesystems that support ftruncate
 839            expansion and some that don't! On Linux fat can't do
 840            ftruncate extend but ext2 can. */
 841
 842         result = ceph_ftruncate(handle->data, fsp->fh->fd, len);
 843         if (result == 0)
 844                 goto done;
 845
 846         /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
 847            extend a file with ftruncate. Provide alternate implementation
 848            for this */
 849         currpos = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
 850         if (currpos == -1) {
 851                 goto done;
 852         }
 853
 854         /* Do an fstat to see if the file is longer than the requested
 855            size in which case the ftruncate above should have
 856            succeeded or shorter, in which case seek to len - 1 and
 857            write 1 byte of zero */
 858         if (SMB_VFS_FSTAT(fsp, &st) == -1) {
 859                 goto done;
 860         }
 861
 862 #ifdef S_ISFIFO
 863         if (S_ISFIFO(st.st_ex_mode)) {
 864                 result = 0;
 865                 goto done;
 866         }
 867 #endif
 868
 869         if (st.st_ex_size == len) {
 870                 result = 0;
 871                 goto done;
 872         }
 873
 874         if (st.st_ex_size > len) {
 875                 /* the sys_ftruncate should have worked */
 876                 goto done;
 877         }
 878
 879         if (SMB_VFS_LSEEK(fsp, len-1, SEEK_SET) != len -1)
 880                 goto done;
 881
 882         if (SMB_VFS_WRITE(fsp, &c, 1)!=1)
 883                 goto done;
 884
 885         /* Seek to where we were */
 886         if (SMB_VFS_LSEEK(fsp, currpos, SEEK_SET) != currpos)
 887                 goto done;
 888         result = 0;
 889
 890   done:
 891
 892         return result;
 893 }
 894
 895 static bool cephwrap_lock(struct vfs_handle_struct *handle, files_struct *fsp, int op, off_t offset, off_t count, int type)
 896 {
 897         DEBUG(10, ("[CEPH] lock\n"));
 898         return true;
 899 }
 900
 901 static int cephwrap_kernel_flock(struct vfs_handle_struct *handle, files_struct *fsp,
 902                                 uint32 share_mode, uint32 access_mask)
 903 {
 904         DEBUG(10, ("[CEPH] kernel_flock\n"));
 905         /*
 906          * We must return zero here and pretend all is good.
 907          * One day we might have this in CEPH.
 908          */
 909         return 0;
 910 }
 911
 912 static bool cephwrap_getlock(struct vfs_handle_struct *handle, files_struct *fsp, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
 913 {
 914         DEBUG(10, ("[CEPH] getlock returning false and errno=0\n"));
 915
 916         errno = 0;
 917         return false;
 918 }
 919
 920 /*
 921  * We cannot let this fall through to the default, because the file might only
 922  * be accessible from libceph (which is a user-space client) but the fd might
 923  * be for some file the kernel knows about.
 924  */
 925 static int cephwrap_linux_setlease(struct vfs_handle_struct *handle, files_struct *fsp,
 926                                 int leasetype)
 927 {
 928         int result = -1;
 929
 930         DEBUG(10, ("[CEPH] linux_setlease\n"));
 931         errno = ENOSYS;
 932         return result;
 933 }
 934
 935 static int cephwrap_symlink(struct vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
 936 {
 937         int result = -1;
 938         DEBUG(10, ("[CEPH] symlink(%p, %s, %s)\n", handle, oldpath, newpath));
 939         result = ceph_symlink(handle->data, oldpath, newpath);
 940         DEBUG(10, ("[CEPH] symlink(...) = %d\n", result));
 941         WRAP_RETURN(result);
 942 }
 943
 944 static int cephwrap_readlink(struct vfs_handle_struct *handle,  const char *path, char *buf, size_t bufsiz)
 945 {
 946         int result = -1;
 947         DEBUG(10, ("[CEPH] readlink(%p, %s, %p, %llu)\n", handle, path, buf, llu(bufsiz)));
 948         result = ceph_readlink(handle->data, path, buf, bufsiz);
 949         DEBUG(10, ("[CEPH] readlink(...) = %d\n", result));
 950         WRAP_RETURN(result);
 951 }
 952
 953 static int cephwrap_link(struct vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
 954 {
 955         int result = -1;
 956         DEBUG(10, ("[CEPH] link(%p, %s, %s)\n", handle, oldpath, newpath));
 957         result = ceph_link(handle->data, oldpath, newpath);
 958         DEBUG(10, ("[CEPH] link(...) = %d\n", result));
 959         WRAP_RETURN(result);
 960 }
 961
 962 static int cephwrap_mknod(struct vfs_handle_struct *handle,  const char *pathname, mode_t mode, SMB_DEV_T dev)
 963 {
 964         int result = -1;
 965         DEBUG(10, ("[CEPH] mknod(%p, %s)\n", handle, pathname));
 966         result = ceph_mknod(handle->data, pathname, mode, dev);
 967         DEBUG(10, ("[CEPH] mknod(...) = %d\n", result));
 968         WRAP_RETURN(result);
 969 }
 970
 971 /*
 972  * This is a simple version of real-path ... a better version is needed to
 973  * ask libceph about symbolic links.
 974  */
 975 static char *cephwrap_realpath(struct vfs_handle_struct *handle,  const char *path)
 976 {
 977         char *result;
 978         size_t len = strlen(path);
 979
 980         result = SMB_MALLOC_ARRAY(char, PATH_MAX+1);
 981         if (len && (path[0] == '/')) {
 982                 int r = asprintf(&result, "%s", path);
 983                 if (r < 0) return NULL;
 984         } else if ((len >= 2) && (path[0] == '.') && (path[1] == '/')) {
 985                 if (len == 2) {
 986                         int r = asprintf(&result, "%s",
 987                                         handle->conn->connectpath);
 988                         if (r < 0) return NULL;
 989                 } else {
 990                         int r = asprintf(&result, "%s/%s",
 991                                         handle->conn->connectpath, &path[2]);
 992                         if (r < 0) return NULL;
 993                 }
 994         } else {
 995                 int r = asprintf(&result, "%s/%s",
 996                                 handle->conn->connectpath, path);
 997                 if (r < 0) return NULL;
 998         }
 999         DEBUG(10, ("[CEPH] realpath(%p, %s) = %s\n", handle, path, result));
1000         return result;
1001 }
1002
1003 static NTSTATUS cephwrap_notify_watch(struct vfs_handle_struct *vfs_handle,
1004                                      struct sys_notify_context *ctx,
1005                                      const char *path,
1006                                      uint32_t *filter,
1007                                      uint32_t *subdir_filter,
1008                                      void (*callback)(struct sys_notify_context *ctx,
1009                                                       void *private_data,
1010                                                       struct notify_event *ev),
1011                                      void *private_data,
1012                                      void *handle_p)
1013 {
1014         /*
1015          * We cannot call inotify on files the kernel does not know about
1016          */
1017         return NT_STATUS_OK;
1018 }
1019
1020 static int cephwrap_chflags(struct vfs_handle_struct *handle, const char *path,
1021                            unsigned int flags)
1022 {
1023         errno = ENOSYS;
1024         return -1;
1025 }
1026
1027 static int cephwrap_get_real_filename(struct vfs_handle_struct *handle,
1028                                      const char *path,
1029                                      const char *name,
1030                                      TALLOC_CTX *mem_ctx,
1031                                      char **found_name)
1032 {
1033         /*
1034          * Don't fall back to get_real_filename so callers can differentiate
1035          * between a full directory scan and an actual case-insensitive stat.
1036          */
1037         errno = EOPNOTSUPP;
1038         return -1;
1039 }
1040
1041 static const char *cephwrap_connectpath(struct vfs_handle_struct *handle,
1042                                        const char *fname)
1043 {
1044         return handle->conn->connectpath;
1045 }
1046
1047 /****************************************************************
1048  Extended attribute operations.
1049 *****************************************************************/
1050
1051 static ssize_t cephwrap_getxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1052 {
1053         DEBUG(10, ("[CEPH] getxattr(%p, %s, %s, %p, %llu)\n", handle, path, name, value, llu(size)));
1054         int ret = ceph_getxattr(handle->data, path, name, value, size);
1055         DEBUG(10, ("[CEPH] getxattr(...) = %d\n", ret));
1056         if (ret < 0) {
1057                 WRAP_RETURN(ret);
1058         } else {
1059                 return (ssize_t)ret;
1060         }
1061 }
1062
1063 static ssize_t cephwrap_fgetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, void *value, size_t size)
1064 {
1065         DEBUG(10, ("[CEPH] fgetxattr(%p, %p, %s, %p, %llu)\n", handle, fsp, name, value, llu(size)));
1066         int ret = ceph_getxattr(handle->data, fsp->fsp_name->base_name, name, value, size);
1067         DEBUG(10, ("[CEPH] fgetxattr(...) = %d\n", ret));
1068         if (ret < 0) {
1069                 WRAP_RETURN(ret);
1070         } else {
1071                 return (ssize_t)ret;
1072         }
1073 }
1074
1075 static ssize_t cephwrap_listxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1076 {
1077         DEBUG(10, ("[CEPH] listxattr(%p, %s, %p, %llu)\n", handle, path, list, llu(size)));
1078         int ret = ceph_listxattr(handle->data, path, list, size);
1079         DEBUG(10, ("[CEPH] listxattr(...) = %d\n", ret));
1080         if (ret < 0) {
1081                 WRAP_RETURN(ret);
1082         } else {
1083                 return (ssize_t)ret;
1084         }
1085 }
1086
1087 #if 0
1088 static ssize_t cephwrap_llistxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1089 {
1090         DEBUG(10, ("[CEPH] llistxattr(%p, %s, %p, %llu)\n", handle, path, list, llu(size)));
1091         int ret = ceph_llistxattr(handle->data, path, list, size);
1092         DEBUG(10, ("[CEPH] listxattr(...) = %d\n", ret));
1093         if (ret < 0) {
1094                 WRAP_RETURN(ret);
1095         } else {
1096                 return (ssize_t)ret;
1097         }
1098 }
1099 #endif
1100
1101 static ssize_t cephwrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
1102 {
1103         DEBUG(10, ("[CEPH] flistxattr(%p, %p, %s, %llu)\n", handle, fsp, list, llu(size)));
1104         int ret = ceph_listxattr(handle->data, fsp->fsp_name->base_name, list, size);
1105         DEBUG(10, ("[CEPH] flistxattr(...) = %d\n", ret));
1106         if (ret < 0) {
1107                 WRAP_RETURN(ret);
1108         } else {
1109                 return (ssize_t)ret;
1110         }
1111 }
1112
1113 static int cephwrap_removexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1114 {
1115         DEBUG(10, ("[CEPH] removexattr(%p, %s, %s)\n", handle, path, name));
1116         int ret = ceph_removexattr(handle->data, path, name);
1117         DEBUG(10, ("[CEPH] removexattr(...) = %d\n", ret));
1118         WRAP_RETURN(ret);
1119 }
1120
1121 static int cephwrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name)
1122 {
1123         DEBUG(10, ("[CEPH] fremovexattr(%p, %p, %s)\n", handle, fsp, name));
1124         int ret = ceph_removexattr(handle->data, fsp->fsp_name->base_name, name);
1125         DEBUG(10, ("[CEPH] fremovexattr(...) = %d\n", ret));
1126         WRAP_RETURN(ret);
1127 }
1128
1129 static int cephwrap_setxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1130 {
1131         DEBUG(10, ("[CEPH] setxattr(%p, %s, %s, %p, %llu, %d)\n", handle, path, name, value, llu(size), flags));
1132         int ret = ceph_setxattr(handle->data, path, name, value, size, flags);
1133         DEBUG(10, ("[CEPH] setxattr(...) = %d\n", ret));
1134         WRAP_RETURN(ret);
1135 }
1136
1137 static int cephwrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags)
1138 {
1139         DEBUG(10, ("[CEPH] fsetxattr(%p, %p, %s, %p, %llu, %d)\n", handle, fsp, name, value, llu(size), flags));
1140         int ret = ceph_setxattr(handle->data, fsp->fsp_name->base_name, name, value, size, flags);
1141         DEBUG(10, ("[CEPH] fsetxattr(...) = %d\n", ret));
1142         WRAP_RETURN(ret);
1143 }
1144
1145 static bool cephwrap_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
1146 {
1147
1148         /*
1149          * We do not support AIO yet.
1150          */
1151
1152         DEBUG(10, ("[CEPH] cephwrap_aio_force(%p, %p) = false (errno = ENOTSUP)\n", handle, fsp));
1153         errno = ENOTSUP;
1154         return false;
1155 }
1156
1157 static bool cephwrap_is_offline(struct vfs_handle_struct *handle,
1158                                 const struct smb_filename *fname,
1159                                 SMB_STRUCT_STAT *sbuf)
1160 {
1161         return false;
1162 }
1163
1164 static int cephwrap_set_offline(struct vfs_handle_struct *handle,
1165                                 const struct smb_filename *fname)
1166 {
1167         errno = ENOTSUP;
1168         return -1;
1169 }
1170
1171 static struct vfs_fn_pointers ceph_fns = {
1172         /* Disk operations */
1173
1174         .connect_fn = cephwrap_connect,
1175         .disconnect_fn = cephwrap_disconnect,
1176         .disk_free_fn = cephwrap_disk_free,
1177         .get_quota_fn = cephwrap_get_quota,
1178         .set_quota_fn = cephwrap_set_quota,
1179         .statvfs_fn = cephwrap_statvfs,
1180
1181         /* Directory operations */
1182
1183         .opendir_fn = cephwrap_opendir,
1184         .fdopendir_fn = cephwrap_fdopendir,
1185         .readdir_fn = cephwrap_readdir,
1186         .seekdir_fn = cephwrap_seekdir,
1187         .telldir_fn = cephwrap_telldir,
1188         .rewind_dir_fn = cephwrap_rewinddir,
1189         .mkdir_fn = cephwrap_mkdir,
1190         .rmdir_fn = cephwrap_rmdir,
1191         .closedir_fn = cephwrap_closedir,
1192
1193         /* File operations */
1194
1195         .open_fn = cephwrap_open,
1196         .close_fn = cephwrap_close,
1197         .read_fn = cephwrap_read,
1198         .pread_fn = cephwrap_pread,
1199         .write_fn = cephwrap_write,
1200         .pwrite_fn = cephwrap_pwrite,
1201         .lseek_fn = cephwrap_lseek,
1202         .sendfile_fn = cephwrap_sendfile,
1203         .recvfile_fn = cephwrap_recvfile,
1204         .rename_fn = cephwrap_rename,
1205         .fsync_fn = cephwrap_fsync,
1206         .stat_fn = cephwrap_stat,
1207         .fstat_fn = cephwrap_fstat,
1208         .lstat_fn = cephwrap_lstat,
1209         .unlink_fn = cephwrap_unlink,
1210         .chmod_fn = cephwrap_chmod,
1211         .fchmod_fn = cephwrap_fchmod,
1212         .chown_fn = cephwrap_chown,
1213         .fchown_fn = cephwrap_fchown,
1214         .lchown_fn = cephwrap_lchown,
1215         .chdir_fn = cephwrap_chdir,
1216         .getwd_fn = cephwrap_getwd,
1217         .ntimes_fn = cephwrap_ntimes,
1218         .ftruncate_fn = cephwrap_ftruncate,
1219         .lock_fn = cephwrap_lock,
1220         .kernel_flock_fn = cephwrap_kernel_flock,
1221         .linux_setlease_fn = cephwrap_linux_setlease,
1222         .getlock_fn = cephwrap_getlock,
1223         .symlink_fn = cephwrap_symlink,
1224         .readlink_fn = cephwrap_readlink,
1225         .link_fn = cephwrap_link,
1226         .mknod_fn = cephwrap_mknod,
1227         .realpath_fn = cephwrap_realpath,
1228         .notify_watch_fn = cephwrap_notify_watch,
1229         .chflags_fn = cephwrap_chflags,
1230         .get_real_filename_fn = cephwrap_get_real_filename,
1231         .connectpath_fn = cephwrap_connectpath,
1232
1233         /* EA operations. */
1234         .getxattr_fn = cephwrap_getxattr,
1235         .fgetxattr_fn = cephwrap_fgetxattr,
1236         .listxattr_fn = cephwrap_listxattr,
1237         .flistxattr_fn = cephwrap_flistxattr,
1238         .removexattr_fn = cephwrap_removexattr,
1239         .fremovexattr_fn = cephwrap_fremovexattr,
1240         .setxattr_fn = cephwrap_setxattr,
1241         .fsetxattr_fn = cephwrap_fsetxattr,
1242
1243         /* aio operations */
1244         .aio_force_fn = cephwrap_aio_force,
1245
1246         /* offline operations */
1247         .is_offline_fn = cephwrap_is_offline,
1248         .set_offline_fn = cephwrap_set_offline
1249 };
1250
1251 NTSTATUS vfs_ceph_init(void);
1252 NTSTATUS vfs_ceph_init(void)
1253 {
1254         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
1255                                 "ceph", &ceph_fns);
1256 }