diff options
Diffstat (limited to 'xlators/storage/bdb/src/bdb.c')
| -rw-r--r-- | xlators/storage/bdb/src/bdb.c | 3603 |
1 files changed, 0 insertions, 3603 deletions
diff --git a/xlators/storage/bdb/src/bdb.c b/xlators/storage/bdb/src/bdb.c deleted file mode 100644 index 384094b57ad..00000000000 --- a/xlators/storage/bdb/src/bdb.c +++ /dev/null @@ -1,3603 +0,0 @@ -/* - Copyright (c) 2008-2011 Gluster, Inc. <http://www.gluster.com> - This file is part of GlusterFS. - - GlusterFS is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 3 of the License, - or (at your option) any later version. - - GlusterFS is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see - <http://www.gnu.org/licenses/>. -*/ - -/* bdb based storage translator - named as 'bdb' translator - * - * - * There can be only two modes for files existing on bdb translator: - * 1. DIRECTORY - directories are stored by bdb as regular directories on - * back-end file-system. directories also have an entry in the ns_db.db of - * their parent directory. - * 2. REGULAR FILE - regular files are stored as records in the storage_db.db - * present in the directory. regular files also have an entry in ns_db.db - * - * Internally bdb has a maximum of three different types of logical files - * associated with each directory: - * 1. storage_db.db - storage database, used to store the data corresponding to - * regular files in the form of key/value pair. file-name is the 'key' and - * data is 'value'. - * 2. directory (all subdirectories) - any subdirectory will have a regular - * directory entry. - */ -#ifndef _CONFIG_H -#define _CONFIG_H -#include "config.h" -#endif - -#define __XOPEN_SOURCE 500 - -#include <stdint.h> -#include <sys/time.h> -#include <errno.h> -#include <ftw.h> -#include <libgen.h> - -#include "glusterfs.h" -#include "dict.h" -#include "logging.h" -#include "bdb.h" -#include "xlator.h" -#include "defaults.h" -#include "common-utils.h" - -/* to be used only by fops, nobody else */ -#define BDB_ENV(this) ((((struct bdb_private *)this->private)->b_table)->dbenv) -#define B_TABLE(this) (((struct bdb_private *)this->private)->b_table) - - -int32_t -bdb_mknod (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - mode_t mode, - dev_t dev) -{ - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - char *key_string = NULL; /* after translating path to DB key */ - char *db_path = NULL; - bctx_t *bctx = NULL; - struct stat stbuf = {0,}; - - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - - if (!S_ISREG(mode)) { - gf_log (this->name, GF_LOG_DEBUG, - "MKNOD %"PRId64"/%s (%s): EPERM" - "(mknod supported only for regular files. " - "file mode '%o' not supported)", - loc->parent->ino, loc->name, loc->path, mode); - op_ret = -1; - op_errno = EPERM; - goto out; - } /* if(!S_ISREG(mode)) */ - - bctx = bctx_parent (B_TABLE(this), loc->path); - if (bctx == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "MKNOD %"PRId64"/%s (%s): ENOMEM" - "(failed to lookup database handle)", - loc->parent->ino, loc->name, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - MAKE_REAL_PATH_TO_STORAGE_DB (db_path, this, bctx->directory); - - op_ret = lstat (db_path, &stbuf); - if (op_ret != 0) { - op_errno = EINVAL; - gf_log (this->name, GF_LOG_DEBUG, - "MKNOD %"PRId64"/%s (%s): EINVAL" - "(failed to lookup database handle)", - loc->parent->ino, loc->name, loc->path); - goto out; - } - - MAKE_KEY_FROM_PATH (key_string, loc->path); - op_ret = bdb_db_icreate (bctx, key_string); - if (op_ret > 0) { - /* create successful */ - stbuf.st_ino = bdb_inode_transform (loc->parent->ino, - key_string, - strlen (key_string)); - stbuf.st_mode = mode; - stbuf.st_size = 0; - stbuf.st_blocks = BDB_COUNT_BLOCKS (stbuf.st_size, \ - stbuf.st_blksize); - } else { - gf_log (this->name, GF_LOG_DEBUG, - "MKNOD %"PRId64"/%s (%s): ENOMEM" - "(failed to create database entry)", - loc->parent->ino, loc->name, loc->path); - op_ret = -1; - op_errno = EINVAL; /* TODO: errno sari illa */ - goto out; - }/* if (!op_ret)...else */ - -out: - if (bctx) { - /* NOTE: bctx_unref always returns success, - * see description of bctx_unref for more details */ - bctx_unref (bctx); - } - - STACK_UNWIND (frame, op_ret, op_errno, loc->inode, &stbuf); - return 0; -} - -static inline int32_t -is_dir_empty (xlator_t *this, - loc_t *loc) -{ - int32_t ret = 1; - bctx_t *bctx = NULL; - DIR *dir = NULL; - char *real_path = NULL; - void *dbstat = NULL; - struct dirent *entry = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - - bctx = bctx_lookup (B_TABLE(this), loc->path); - if (bctx == NULL) { - ret = -ENOMEM; - goto out; - } - - dbstat = bdb_db_stat (bctx, NULL, 0); - if (dbstat) { - switch (bctx->table->access_mode) - { - case DB_HASH: - ret = (((DB_HASH_STAT *)dbstat)->hash_nkeys == 0); - break; - case DB_BTREE: - case DB_RECNO: - ret = (((DB_BTREE_STAT *)dbstat)->bt_nkeys == 0); - break; - case DB_QUEUE: - ret = (((DB_QUEUE_STAT *)dbstat)->qs_nkeys == 0); - break; - case DB_UNKNOWN: - gf_log (this->name, GF_LOG_CRITICAL, - "unknown access-mode set for database"); - ret = 0; - } - } else { - ret = -EBUSY; - goto out; - } - - MAKE_REAL_PATH (real_path, this, loc->path); - dir = opendir (real_path); - if (dir == NULL) { - ret = -errno; - goto out; - } - - while ((entry = readdir (dir))) { - if ((!IS_BDB_PRIVATE_FILE(entry->d_name)) && - (!IS_DOT_DOTDOT(entry->d_name))) { - ret = 0; - break; - }/* if(!IS_BDB_PRIVATE_FILE()) */ - } /* while(true) */ - closedir (dir); -out: - if (bctx) { - /* NOTE: bctx_unref always returns success, - * see description of bctx_unref for more details */ - bctx_unref (bctx); - } - - return ret; -} - -int32_t -bdb_rename (call_frame_t *frame, - xlator_t *this, - loc_t *oldloc, - loc_t *newloc) -{ - STACK_UNWIND (frame, -1, EXDEV, NULL); - return 0; -} - -int32_t -bdb_link (call_frame_t *frame, - xlator_t *this, - loc_t *oldloc, - loc_t *newloc) -{ - STACK_UNWIND (frame, -1, EXDEV, NULL, NULL); - return 0; -} - -int32_t -is_space_left (xlator_t *this, - size_t size) -{ - struct bdb_private *private = this->private; - struct statvfs stbuf = {0,}; - int32_t ret = -1; - fsblkcnt_t req_blocks = 0; - fsblkcnt_t usable_blocks = 0; - - ret = statvfs (private->export_path, &stbuf); - if (ret != 0) { - ret = 0; - } else { - req_blocks = (size / stbuf.f_frsize) + 1; - - usable_blocks = (stbuf.f_bfree - BDB_ENOSPC_THRESHOLD); - - if (req_blocks < usable_blocks) - ret = 1; - else - ret = 0; - } - - return ret; -} - -int32_t -bdb_create (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - int32_t flags, - mode_t mode, - fd_t *fd) -{ - int32_t op_ret = -1; - int32_t op_errno = EPERM; - char *db_path = NULL; - struct stat stbuf = {0,}; - bctx_t *bctx = NULL; - struct bdb_private *private = NULL; - char *key_string = NULL; - struct bdb_fd *bfd = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - GF_VALIDATE_OR_GOTO (this->name, fd, out); - - private = this->private; - - bctx = bctx_parent (B_TABLE(this), loc->path); - if (bctx == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "CREATE %"PRId64"/%s (%s): ENOMEM" - "(failed to lookup database handle)", - loc->parent->ino, loc->name, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - MAKE_REAL_PATH_TO_STORAGE_DB (db_path, this, bctx->directory); - op_ret = lstat (db_path, &stbuf); - if (op_ret != 0) { - op_errno = EINVAL; - gf_log (this->name, GF_LOG_DEBUG, - "CREATE %"PRId64"/%s (%s): EINVAL" - "(database file missing)", - loc->parent->ino, loc->name, loc->path); - goto out; - } - - MAKE_KEY_FROM_PATH (key_string, loc->path); - op_ret = bdb_db_icreate (bctx, key_string); - if (op_ret < 0) { - gf_log (this->name, GF_LOG_DEBUG, - "CREATE %"PRId64"/%s (%s): ENOMEM" - "(failed to create database entry)", - loc->parent->ino, loc->name, loc->path); - op_errno = EINVAL; /* TODO: errno sari illa */ - goto out; - } - - /* create successful */ - bfd = GF_CALLOC (1, sizeof (*bfd), gf_bdb_mt_bdb_fd); - if (bfd == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "CREATE %"PRId64"/%s (%s): ENOMEM" - "(failed to allocate memory for internal fd context)", - loc->parent->ino, loc->name, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - /* NOTE: bdb_get_bctx_from () returns bctx with a ref */ - bfd->ctx = bctx; - bfd->key = gf_strdup (key_string); - if (bfd->key == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "CREATE %"PRId64" (%s): ENOMEM" - "(failed to allocate memory for internal fd->key)", - loc->ino, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - BDB_FCTX_SET (fd, this, bfd); - - stbuf.st_ino = bdb_inode_transform (loc->parent->ino, - key_string, - strlen (key_string)); - stbuf.st_mode = private->file_mode; - stbuf.st_size = 0; - stbuf.st_nlink = 1; - stbuf.st_blocks = BDB_COUNT_BLOCKS (stbuf.st_size, stbuf.st_blksize); - op_ret = 0; - op_errno = 0; -out: - STACK_UNWIND (frame, op_ret, op_errno, fd, loc->inode, &stbuf); - - return 0; -} - - -/* bdb_open - * - * as input parameters bdb_open gets the file name, i.e key. bdb_open should - * effectively - * do: store key, open storage db, store storage-db pointer. - * - */ -int32_t -bdb_open (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - int32_t flags, - fd_t *fd, - int32_t wbflags) -{ - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - bctx_t *bctx = NULL; - char *key_string = NULL; - struct bdb_fd *bfd = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - GF_VALIDATE_OR_GOTO (this->name, fd, out); - - bctx = bctx_parent (B_TABLE(this), loc->path); - if (bctx == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "OPEN %"PRId64" (%s): ENOMEM" - "(failed to lookup database handle)", - loc->ino, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - bfd = GF_CALLOC (1, sizeof (*bfd), gf_bdb_mt_bdb_fd); - if (bfd == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "OPEN %"PRId64" (%s): ENOMEM" - "(failed to allocate memory for internal fd context)", - loc->ino, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - /* NOTE: bctx_parent () returns bctx with a ref */ - bfd->ctx = bctx; - - MAKE_KEY_FROM_PATH (key_string, loc->path); - bfd->key = gf_strdup (key_string); - if (bfd->key == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "OPEN %"PRId64" (%s): ENOMEM" - "(failed to allocate memory for internal fd->key)", - loc->ino, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - BDB_FCTX_SET (fd, this, bfd); - op_ret = 0; -out: - STACK_UNWIND (frame, op_ret, op_errno, fd); - - return 0; -} - -int32_t -bdb_readv (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - size_t size, - off_t offset) -{ - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - struct iovec vec = {0,}; - struct stat stbuf = {0,}; - struct bdb_fd *bfd = NULL; - char *db_path = NULL; - int32_t read_size = 0; - struct iobref *iobref = NULL; - struct iobuf *iobuf = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, fd, out); - - BDB_FCTX_GET (fd, this, &bfd); - if (bfd == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "READV %"PRId64" - %"GF_PRI_SIZET",%"PRId64": EBADFD" - "(internal fd not found through fd)", - fd->inode->ino, size, offset); - op_errno = EBADFD; - op_ret = -1; - goto out; - } - - MAKE_REAL_PATH_TO_STORAGE_DB (db_path, this, bfd->ctx->directory); - op_ret = lstat (db_path, &stbuf); - if (op_ret != 0) { - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "READV %"PRId64" - %"GF_PRI_SIZET",%"PRId64": EINVAL" - "(database file missing)", - fd->inode->ino, size, offset); - goto out; - } - - iobuf = iobuf_get (this->ctx->iobuf_pool); - if (!iobuf) { - gf_log (this->name, GF_LOG_ERROR, - "out of memory :("); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - /* we are ready to go */ - op_ret = bdb_db_fread (bfd, iobuf->ptr, size, offset); - read_size = op_ret; - if (op_ret == -1) { - gf_log (this->name, GF_LOG_DEBUG, - "READV %"PRId64" - %"GF_PRI_SIZET",%"PRId64": EBADFD" - "(failed to find entry in database)", - fd->inode->ino, size, offset); - op_ret = -1; - op_errno = ENOENT; - goto out; - } else if (op_ret == 0) { - goto out; - } - - iobref = iobref_new (); - if (iobref == NULL) { - gf_log (this->name, GF_LOG_ERROR, - "out of memory :("); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - if (size < read_size) { - op_ret = size; - read_size = size; - } - - iobref_add (iobref, iobuf); - - vec.iov_base = iobuf->ptr; - vec.iov_len = read_size; - - stbuf.st_ino = fd->inode->ino; - stbuf.st_size = bdb_db_fread (bfd, NULL, 0, 0); - stbuf.st_blocks = BDB_COUNT_BLOCKS (stbuf.st_size, stbuf.st_blksize); - op_ret = size; -out: - STACK_UNWIND (frame, op_ret, op_errno, &vec, 1, &stbuf, iobuf); - - if (iobref) - iobref_unref (iobref); - - if (iobuf) - iobuf_unref (iobuf); - - return 0; -} - - -int32_t -bdb_writev (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - struct iovec *vector, - int32_t count, - off_t offset, - struct iobref *iobref) -{ - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - struct stat stbuf = {0,}; - struct bdb_fd *bfd = NULL; - int32_t idx = 0; - off_t c_off = offset; - int32_t c_ret = -1; - char *db_path = NULL; - size_t total_size = 0; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, fd, out); - GF_VALIDATE_OR_GOTO (this->name, vector, out); - - BDB_FCTX_GET (fd, this, &bfd); - if (bfd == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "WRITEV %"PRId64" - %"PRId32",%"PRId64": EBADFD" - "(internal fd not found through fd)", - fd->inode->ino, count, offset); - op_ret = -1; - op_errno = EBADFD; - goto out; - } - - MAKE_REAL_PATH_TO_STORAGE_DB (db_path, this, bfd->ctx->directory); - op_ret = lstat (db_path, &stbuf); - if (op_ret != 0) { - op_errno = errno; - gf_log (this->name, GF_LOG_ERROR, - "WRITEV %"PRId64" - %"PRId32",%"PRId64": EINVAL" - "(database file missing)", - fd->inode->ino, count, offset); - goto out; - } - - for (idx = 0; idx < count; idx++) - total_size += vector[idx].iov_len; - - if (!is_space_left (this, total_size)) { - gf_log (this->name, GF_LOG_ERROR, - "WRITEV %"PRId64" - %"PRId32" (%"GF_PRI_SIZET"),%" - PRId64": ENOSPC " - "(not enough space after internal measurement)", - fd->inode->ino, count, total_size, offset); - op_ret = -1; - op_errno = ENOSPC; - goto out; - } - - /* we are ready to go */ - for (idx = 0; idx < count; idx++) { - c_ret = bdb_db_fwrite (bfd, vector[idx].iov_base, - vector[idx].iov_len, c_off); - if (c_ret < 0) { - gf_log (this->name, GF_LOG_ERROR, - "WRITEV %"PRId64" - %"PRId32",%"PRId64": EINVAL" - "(database write at %"PRId64" failed)", - fd->inode->ino, count, offset, c_off); - break; - } else { - c_off += vector[idx].iov_len; - } - op_ret += vector[idx].iov_len; - } /* for(idx=0;...)... */ - - if (c_ret) { - /* write failed after a point, not an error */ - stbuf.st_size = bdb_db_fread (bfd, NULL, 0, 0); - stbuf.st_blocks = BDB_COUNT_BLOCKS (stbuf.st_size, - stbuf.st_blksize); - goto out; - } - - /* NOTE: we want to increment stbuf->st_size, as stored in db */ - stbuf.st_size = op_ret; - stbuf.st_blocks = BDB_COUNT_BLOCKS (stbuf.st_size, stbuf.st_blksize); - op_errno = 0; - -out: - STACK_UNWIND (frame, op_ret, op_errno, &stbuf); - return 0; -} - -int32_t -bdb_flush (call_frame_t *frame, - xlator_t *this, - fd_t *fd) -{ - int32_t op_ret = -1; - int32_t op_errno = EPERM; - struct bdb_fd *bfd = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, fd, out); - - BDB_FCTX_GET (fd, this, &bfd); - if (bfd == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "FLUSH %"PRId64": EBADFD" - "(internal fd not found through fd)", - fd->inode->ino); - op_ret = -1; - op_errno = EBADFD; - goto out; - } - - /* do nothing */ - op_ret = 0; - op_errno = 0; - -out: - STACK_UNWIND (frame, op_ret, op_errno); - return 0; -} - -int32_t -bdb_release (xlator_t *this, - fd_t *fd) -{ - int32_t op_ret = -1; - int32_t op_errno = EBADFD; - struct bdb_fd *bfd = NULL; - - BDB_FCTX_GET (fd, this, &bfd); - if (bfd == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "RELEASE %"PRId64": EBADFD" - "(internal fd not found through fd)", - fd->inode->ino); - op_ret = -1; - op_errno = EBADFD; - goto out; - } - - bctx_unref (bfd->ctx); - bfd->ctx = NULL; - - if (bfd->key) - GF_FREE (bfd->key); /* we did strdup() in bdb_open() */ - GF_FREE (bfd); - op_ret = 0; - op_errno = 0; - -out: - return 0; -}/* bdb_release */ - - -int32_t -bdb_fsync (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - int32_t datasync) -{ - STACK_UNWIND (frame, 0, 0); - return 0; -}/* bdb_fsync */ - -static int gf_bdb_lk_log; - -int32_t -bdb_lk (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - int32_t cmd, - struct gf_flock *lock) -{ - struct gf_flock nullock = {0, }; - - if (BDB_TIMED_LOG (ENOTSUP, gf_bdb_lk_log)) { - gf_log (this->name, GF_LOG_DEBUG, - "LK %"PRId64": ENOTSUP " - "(load \"features/locks\" translator to enable " - "lock support)", - fd->inode->ino); - } - - STACK_UNWIND (frame, -1, ENOTSUP, &nullock); - return 0; -}/* bdb_lk */ - -/* bdb_lookup - * - * there are four possibilities for a file being looked up: - * 1. file exists and is a directory. - * 2. file exists and is a symlink. - * 3. file exists and is a regular file. - * 4. file does not exist. - * case 1 and 2 are handled by doing lstat() on the @loc. if the file is a - * directory or symlink, lstat() succeeds. lookup continues to check if the - * @loc belongs to case-3 only if lstat() fails. - * to check for case 3, bdb_lookup does a bdb_db_iread() for the given @loc. - * (see description of bdb_db_iread() for more details on how @loc is transformed - * into db handle and key). if check for case 1, 2 and 3 fail, we proceed to - * conclude that file doesn't exist (case 4). - * - * @frame: call frame. - * @this: xlator_t of this instance of bdb xlator. - * @loc: loc_t specifying the file to operate upon. - * @need_xattr: if need_xattr != 0, we are asked to return all the extended - * attributed of @loc, if any exist, in a dictionary. if @loc is a regular - * file and need_xattr is set, then we look for value of need_xattr. if - * need_xattr > sizo-of-the-file @loc, then the file content of @loc is - * returned in dictionary of xattr with 'glusterfs.content' as dictionary key. - * - * NOTE: bdb currently supports only directories, symlinks and regular files. - * - * NOTE: bdb_lookup returns the 'struct stat' of underlying file itself, in - * case of directory and symlink (st_ino is modified as bdb allocates its own - * set of inodes of all files). for regular files, bdb uses 'struct stat' of - * the database file in which the @loc is stored as templete and modifies - * st_ino (see bdb_inode_transform for more details), st_mode (can be set in - * volfile 'option file-mode <mode>'), st_size (exact size of the @loc - * contents), st_blocks (block count on the underlying filesystem to - * accomodate st_size, see BDB_COUNT_BLOCKS in bdb.h for more details). - */ -int32_t -bdb_lookup (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - dict_t *xattr_req) -{ - struct stat stbuf = {0, }; - int32_t op_ret = -1; - int32_t op_errno = ENOENT; - dict_t *xattr = NULL; - char *pathname = NULL; - char *directory = NULL; - char *real_path = NULL; - bctx_t *bctx = NULL; - char *db_path = NULL; - struct bdb_private *private = NULL; - char *key_string = NULL; - int32_t entry_size = 0; - char *file_content = NULL; - uint64_t need_xattr = 0; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - - private = this->private; - - MAKE_REAL_PATH (real_path, this, loc->path); - - pathname = gf_strdup (loc->path); - GF_VALIDATE_OR_GOTO (this->name, pathname, out); - - directory = dirname (pathname); - GF_VALIDATE_OR_GOTO (this->name, directory, out); - - if (!strcmp (directory, loc->path)) { - /* SPECIAL CASE: looking up root */ - op_ret = lstat (real_path, &stbuf); - if (op_ret != 0) { - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "LOOKUP %"PRId64" (%s): %s", - loc->ino, loc->path, strerror (op_errno)); - goto out; - } - - /* bctx_lookup() returns NULL only when its time to wind up, - * we should shutdown functioning */ - bctx = bctx_lookup (B_TABLE(this), (char *)loc->path); - if (bctx == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "LOOKUP %"PRId64" (%s): ENOMEM" - "(failed to lookup database handle)", - loc->ino, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - stbuf.st_ino = 1; - stbuf.st_mode = private->dir_mode; - - op_ret = 0; - goto out; - } - - MAKE_KEY_FROM_PATH (key_string, loc->path); - op_ret = lstat (real_path, &stbuf); - if ((op_ret == 0) && (S_ISDIR (stbuf.st_mode))){ - bctx = bctx_lookup (B_TABLE(this), (char *)loc->path); - if (bctx == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "LOOKUP %"PRId64"/%s (%s): ENOMEM" - "(failed to lookup database handle)", - loc->parent->ino, loc->name, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - if (loc->ino) { - /* revalidating directory inode */ - stbuf.st_ino = loc->ino; - } else { - stbuf.st_ino = bdb_inode_transform (loc->parent->ino, - key_string, - strlen (key_string)); - } - stbuf.st_mode = private->dir_mode; - - op_ret = 0; - goto out; - - } else if (op_ret == 0) { - /* a symlink */ - bctx = bctx_parent (B_TABLE(this), loc->path); - if (bctx == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "LOOKUP %"PRId64"/%s (%s): ENOMEM" - "(failed to lookup database handle)", - loc->parent->ino, loc->name, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - if (loc->ino) { - stbuf.st_ino = loc->ino; - } else { - stbuf.st_ino = bdb_inode_transform (loc->parent->ino, - key_string, - strlen (key_string)); - } - - stbuf.st_mode = private->symlink_mode; - - op_ret = 0; - goto out; - - } - - /* for regular files */ - bctx = bctx_parent (B_TABLE(this), loc->path); - if (bctx == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "LOOKUP %"PRId64"/%s (%s): ENOMEM" - "(failed to lookup database handle for parent)", - loc->parent->ino, loc->name, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - if (GF_FILE_CONTENT_REQUESTED(xattr_req, &need_xattr)) { - entry_size = bdb_db_iread (bctx, key_string, &file_content); - } else { - entry_size = bdb_db_iread (bctx, key_string, NULL); - } - - op_ret = entry_size; - if (op_ret == -1) { - gf_log (this->name, GF_LOG_DEBUG, - "LOOKUP %"PRId64"/%s (%s): ENOENT" - "(database entry not found)", - loc->parent->ino, loc->name, loc->path); - op_errno = ENOENT; - goto out; - } - - MAKE_REAL_PATH_TO_STORAGE_DB (db_path, this, bctx->directory); - op_ret = lstat (db_path, &stbuf); - if (op_ret != 0) { - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "LOOKUP %"PRId64"/%s (%s): %s", - loc->parent->ino, loc->name, loc->path, - strerror (op_errno)); - goto out; - } - - if (entry_size - && (need_xattr >= entry_size) - && (file_content)) { - xattr = dict_new (); - op_ret = dict_set_dynptr (xattr, "glusterfs.content", - file_content, entry_size); - if (op_ret < 0) { - /* continue without giving file contents */ - GF_FREE (file_content); - } - } else { - if (file_content) - GF_FREE (file_content); - } - - if (loc->ino) { - /* revalidate */ - stbuf.st_ino = loc->ino; - stbuf.st_size = entry_size; - stbuf.st_blocks = BDB_COUNT_BLOCKS (stbuf.st_size, - stbuf.st_blksize); - } else { - /* fresh lookup, create an inode number */ - stbuf.st_ino = bdb_inode_transform (loc->parent->ino, - key_string, - strlen (key_string)); - stbuf.st_size = entry_size; - stbuf.st_blocks = BDB_COUNT_BLOCKS (stbuf.st_size, - stbuf.st_blksize); - }/* if(inode->ino)...else */ - stbuf.st_nlink = 1; - stbuf.st_mode = private->file_mode; - - op_ret = 0; -out: - if (bctx) { - /* NOTE: bctx_unref always returns success, - * see description of bctx_unref for more details */ - bctx_unref (bctx); - } - - if (pathname) - GF_FREE (pathname); - - if (xattr) - dict_ref (xattr); - - STACK_UNWIND (frame, op_ret, op_errno, loc->inode, &stbuf, xattr); - - if (xattr) - dict_unref (xattr); - - return 0; - -}/* bdb_lookup */ - -int32_t -bdb_stat (call_frame_t *frame, - xlator_t *this, - loc_t *loc) -{ - - struct stat stbuf = {0,}; - char *real_path = NULL; - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - struct bdb_private *private = NULL; - char *db_path = NULL; - bctx_t *bctx = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - - private = this->private; - GF_VALIDATE_OR_GOTO (this->name, private, out); - - MAKE_REAL_PATH (real_path, this, loc->path); - - op_ret = lstat (real_path, &stbuf); - op_errno = errno; - if (op_ret == 0) { - /* directory or symlink */ - stbuf.st_ino = loc->inode->ino; - if (S_ISDIR(stbuf.st_mode)) - stbuf.st_mode = private->dir_mode; - else - stbuf.st_mode = private->symlink_mode; - /* we are done, lets unwind the stack */ - goto out; - } - - bctx = bctx_parent (B_TABLE(this), loc->path); - if (bctx == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "STAT %"PRId64" (%s): ENOMEM" - "(no database handle for parent)", - loc->ino, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - MAKE_REAL_PATH_TO_STORAGE_DB (db_path, this, bctx->directory); - op_ret = lstat (db_path, &stbuf); - if (op_ret < 0) { - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "STAT %"PRId64" (%s): %s" - "(failed to stat on database file)", - loc->ino, loc->path, strerror (op_errno)); - goto out; - } - - stbuf.st_size = bdb_db_iread (bctx, loc->path, NULL); - stbuf.st_blocks = BDB_COUNT_BLOCKS (stbuf.st_size, stbuf.st_blksize); - stbuf.st_ino = loc->inode->ino; - -out: - if (bctx) { - /* NOTE: bctx_unref always returns success, - * see description of bctx_unref for more details */ - bctx_unref (bctx); - } - - STACK_UNWIND (frame, op_ret, op_errno, &stbuf); - - return 0; -}/* bdb_stat */ - - - -/* bdb_opendir - in the world of bdb, open/opendir is all about opening - * correspondind databases. opendir in particular, opens the database for the - * directory which is to be opened. after opening the database, a cursor to - * the database is also created. cursor helps us get the dentries one after - * the other, and cursor maintains the state about current positions in - * directory. pack 'pointer to db', 'pointer to the cursor' into - * struct bdb_dir and store it in fd->ctx, we get from our parent xlator. - * - * @frame: call frame - * @this: our information, as we filled during init() - * @loc: location information - * @fd: file descriptor structure (glusterfs internal) - * - * return value - immaterial, async call. - * - */ -int32_t -bdb_opendir (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - fd_t *fd) -{ - char *real_path = NULL; - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - bctx_t *bctx = NULL; - struct bdb_dir *bfd = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - GF_VALIDATE_OR_GOTO (this->name, fd, out); - - MAKE_REAL_PATH (real_path, this, loc->path); - - bctx = bctx_lookup (B_TABLE(this), (char *)loc->path); - if (bctx == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "OPENDIR %"PRId64" (%s): ENOMEM" - "(no database handle for directory)", - loc->ino, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - bfd = GF_CALLOC (1, sizeof (*bfd), gf_bdb_mt_bdb_fd); - if (bfd == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "OPENDIR %"PRId64" (%s): ENOMEM" - "(failed to allocate memory for internal fd)", - loc->ino, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto err; - } - - bfd->dir = opendir (real_path); - if (bfd->dir == NULL) { - op_ret = -1; - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "OPENDIR %"PRId64" (%s): %s", - loc->ino, loc->path, strerror (op_errno)); - goto err; - } - - /* NOTE: bctx_lookup() return bctx with ref */ - bfd->ctx = bctx; - - bfd->path = gf_strdup (real_path); - if (bfd == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "OPENDIR %"PRId64" (%s): ENOMEM" - "(failed to allocate memory for internal fd->path)", - loc->ino, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto err; - } - - BDB_FCTX_SET (fd, this, bfd); - op_ret = 0; -out: - STACK_UNWIND (frame, op_ret, op_errno, fd); - return 0; -err: - if (bctx) - bctx_unref (bctx); - if (bfd) { - if (bfd->dir) - closedir (bfd->dir); - - GF_FREE (bfd); - } - - return 0; -}/* bdb_opendir */ - -int32_t -bdb_getdents (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - size_t size, - off_t off, - int32_t flag) -{ - struct bdb_dir *bfd = NULL; - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - size_t filled = 0; - dir_entry_t entries = {0, }; - dir_entry_t *this_entry = NULL; - char *entry_path = NULL; - struct dirent *dirent = NULL; - off_t in_case = 0; - int32_t this_size = 0; - DBC *cursorp = NULL; - int32_t ret = -1; - int32_t real_path_len = 0; - int32_t entry_path_len = 0; - int32_t count = 0; - off_t offset = 0; - size_t tmp_name_len = 0; - struct stat db_stbuf = {0,}; - struct stat buf = {0,}; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, fd, out); - - BDB_FCTX_GET (fd, this, &bfd); - if (bfd == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "GETDENTS %"PRId64" - %"GF_PRI_SIZET",%"PRId64 - " %o: EBADFD " - "(failed to find internal context in fd)", - fd->inode->ino, size, off, flag); - op_errno = EBADFD; - op_ret = -1; - goto out; - } - - op_ret = bdb_cursor_open (bfd->ctx, &cursorp); - if (op_ret < 0) { - gf_log (this->name, GF_LOG_DEBUG, - "GETDENTS %"PRId64" - %"GF_PRI_SIZET",%"PRId64 - ": EBADFD " - "(failed to open cursor to database handle)", - fd->inode->ino, size, off); - op_errno = EBADFD; - goto out; - } - - if (off) { - DBT sec = {0,}, pri = {0,}, val = {0,}; - sec.data = &(off); - sec.size = sizeof (off); - sec.flags = DB_DBT_USERMEM; - val.dlen = 0; - val.doff = 0; - val.flags = DB_DBT_PARTIAL; - - op_ret = bdb_cursor_get (cursorp, &sec, &pri, &val, DB_SET); - if (op_ret == DB_NOTFOUND) { - offset = off; - goto dir_read; - } - } - - while (filled <= size) { - DBT sec = {0,}, pri = {0,}, val = {0,}; - - this_entry = NULL; - - sec.flags = DB_DBT_MALLOC; - pri.flags = DB_DBT_MALLOC; - val.dlen = 0; - val.doff = 0; - val.flags = DB_DBT_PARTIAL; - op_ret = bdb_cursor_get (cursorp, &sec, &pri, &val, DB_NEXT); - - if (op_ret == DB_NOTFOUND) { - /* we reached end of the directory */ - op_ret = 0; - op_errno = 0; - break; - } else if (op_ret < 0) { - gf_log (this->name, GF_LOG_DEBUG, - "GETDENTS %"PRId64" - %"GF_PRI_SIZET - ",%"PRId64":" - "(failed to read the next entry from database)", - fd->inode->ino, size, off); - op_errno = ENOENT; - break; - } /* if (op_ret == DB_NOTFOUND)...else if...else */ - - if (pri.data == NULL) { - /* NOTE: currently ignore when we get key.data == NULL. - * FIXME: we should not get key.data = NULL */ - gf_log (this->name, GF_LOG_DEBUG, - "GETDENTS %"PRId64" - %"GF_PRI_SIZET - ",%"PRId64":" - "(null key read for entry from database)", - fd->inode->ino, size, off); - continue; - }/* if(key.data)...else */ - - this_entry = GF_CALLOC (1, sizeof (*this_entry), - gf_bdb_mt_dir_entry_t); - if (this_entry == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "GETDENTS %"PRId64" - %"GF_PRI_SIZET",%"PRId64 - " - %s:" - "(failed to allocate memory for an entry)", - fd->inode->ino, size, off, strerror (errno)); - op_errno = ENOMEM; - op_ret = -1; - goto out; - } - - this_entry->name = GF_CALLOC (pri.size + 1, sizeof (char), - gf_bdb_mt_char); - if (this_entry->name == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "GETDENTS %"PRId64" - %"GF_PRI_SIZET",%"PRId64 - " - %s:" - "(failed to allocate memory for an " - "entry->name)", - fd->inode->ino, size, off, strerror (errno)); - op_errno = ENOMEM; - op_ret = -1; - goto out; - } - - memcpy (this_entry->name, pri.data, pri.size); - this_entry->buf = db_stbuf; - this_entry->buf.st_size = bdb_db_iread (bfd->ctx, - this_entry->name, NULL); - this_entry->buf.st_blocks = BDB_COUNT_BLOCKS ( - this_entry->buf.st_size, - this_entry->buf.st_blksize); - - this_entry->buf.st_ino = bdb_inode_transform (fd->inode->ino, - pri.data, - pri.size); - count++; - - this_entry->next = entries.next; - this_entry->link = ""; - entries.next = this_entry; - /* if size is 0, count can never be = size, - * so entire dir is read */ - if (sec.data) - GF_FREE (sec.data); - - if (pri.data) - GF_FREE (pri.data); - - if (count == size) - break; - }/* while */ - bdb_cursor_close (bfd->ctx, cursorp); - op_ret = count; - op_errno = 0; - if (count >= size) - goto out; -dir_read: - /* hungry kyaa? */ - if (!offset) { - rewinddir (bfd->dir); - } else { - seekdir (bfd->dir, offset); - } - - while (filled <= size) { - this_entry = NULL; - this_size = 0; - - in_case = telldir (bfd->dir); - dirent = readdir (bfd->dir); - if (!dirent) - break; - - if (IS_BDB_PRIVATE_FILE(dirent->d_name)) - continue; - - tmp_name_len = strlen (dirent->d_name); - if (entry_path_len < (real_path_len + 1 + (tmp_name_len) + 1)) { - entry_path_len = real_path_len + tmp_name_len + 1024; - entry_path = realloc (entry_path, entry_path_len); - if (entry_path == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "GETDENTS %"PRId64" - %"GF_PRI_SIZET"," - "%"PRId64" - %s: (failed to allocate " - "memory for an entry_path)", - fd->inode->ino, size, off, - strerror (errno)); - op_errno = ENOMEM; - op_ret = -1; - goto out; - } - } - - memcpy (&entry_path[real_path_len+1], dirent->d_name, - tmp_name_len + 1); - op_ret = stat (entry_path, &buf); - if (op_ret < 0) { - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "GETDENTS %"PRId64" - %"GF_PRI_SIZET",%"PRId64 - " - %s:" - " (failed to stat on an entry '%s')", - fd->inode->ino, size, off, - strerror (errno), entry_path); - goto out; /* FIXME: shouldn't we continue here */ - } - - if ((flag == GF_GET_DIR_ONLY) && - ((ret != -1) && (!S_ISDIR(buf.st_mode)))) { - continue; - } - - this_entry = GF_CALLOC (1, sizeof (*this_entry), - gf_bdb_mt_dir_entry_t); - if (this_entry == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "GETDENTS %"PRId64" - %"GF_PRI_SIZET",%"PRId64 - " - %s:" - "(failed to allocate memory for an entry)", - fd->inode->ino, size, off, strerror (errno)); - op_errno = ENOMEM; - op_ret = -1; - goto out; - } - - this_entry->name = gf_strdup (dirent->d_name); - if (this_entry->name == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "GETDENTS %"PRId64" - %"GF_PRI_SIZET",%"PRId64 - " - %s:" - "(failed to allocate memory for an " - "entry->name)", - fd->inode->ino, size, off, strerror (errno)); - op_errno = ENOMEM; - op_ret = -1; - goto out; - } - - this_entry->buf = buf; - - this_entry->buf.st_ino = -1; - if (S_ISLNK(this_entry->buf.st_mode)) { - char linkpath[PATH_MAX] = {0,}; - ret = readlink (entry_path, linkpath, PATH_MAX); - if (ret != -1) { - linkpath[ret] = '\0'; - this_entry->link = gf_strdup (linkpath); - } - } else { - this_entry->link = ""; - } - - count++; - - this_entry->next = entries.next; - entries.next = this_entry; - - /* if size is 0, count can never be = size, - * so entire dir is read */ - if (count == size) - break; - } - op_ret = filled; - op_errno = 0; - -out: - gf_log (this->name, GF_LOG_DEBUG, - "GETDENTS %"PRId64" - %"GF_PRI_SIZET" (%"PRId32")" - "/%"GF_PRI_SIZET",%"PRId64":" - "(failed to read the next entry from database)", - fd->inode->ino, filled, count, size, off); - - STACK_UNWIND (frame, count, op_errno, &entries); - - while (entries.next) { - this_entry = entries.next; - entries.next = entries.next->next; - GF_FREE (this_entry->name); - GF_FREE (this_entry); - } - - return 0; -}/* bdb_getdents */ - - -int32_t -bdb_releasedir (xlator_t *this, - fd_t *fd) -{ - int32_t op_ret = 0; - int32_t op_errno = 0; - struct bdb_dir *bfd = NULL; - - BDB_FCTX_GET (fd, this, &bfd); - if (bfd == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "RELEASEDIR %"PRId64": EBADFD", - fd->inode->ino); - op_errno = EBADFD; - op_ret = -1; - goto out; - } - - if (bfd->path) { - GF_FREE (bfd->path); - } else { - gf_log (this->name, GF_LOG_DEBUG, - "RELEASEDIR %"PRId64": (bfd->path is NULL)", - fd->inode->ino); - } - - if (bfd->dir) { - closedir (bfd->dir); - } else { - gf_log (this->name, GF_LOG_DEBUG, - "RELEASEDIR %"PRId64": (bfd->dir is NULL)", - fd->inode->ino); - } - - if (bfd->ctx) { - bctx_unref (bfd->ctx); - } else { - gf_log (this->name, GF_LOG_DEBUG, - "RELEASEDIR %"PRId64": (bfd->ctx is NULL)", - fd->inode->ino); - } - - GF_FREE (bfd); - -out: - return 0; -}/* bdb_releasedir */ - - -int32_t -bdb_readlink (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - size_t size) -{ - char *dest = NULL; - int32_t op_ret = -1; - int32_t op_errno = EPERM; - char *real_path = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - - dest = alloca (size + 1); - GF_VALIDATE_OR_GOTO (this->name, dest, out); - - MAKE_REAL_PATH (real_path, this, loc->path); - - op_ret = readlink (real_path, dest, size); - - if (op_ret > 0) - dest[op_ret] = 0; - - if (op_ret == -1) { - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "READLINK %"PRId64" (%s): %s", - loc->ino, loc->path, strerror (op_errno)); - } -out: - STACK_UNWIND (frame, op_ret, op_errno, dest); - - return 0; -}/* bdb_readlink */ - - -int32_t -bdb_mkdir (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - mode_t mode) -{ - int32_t op_ret = -1; - int32_t ret = -1; - int32_t op_errno = EINVAL; - char *real_path = NULL; - struct stat stbuf = {0, }; - bctx_t *bctx = NULL; - char *key_string = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - - MAKE_KEY_FROM_PATH (key_string, loc->path); - MAKE_REAL_PATH (real_path, this, loc->path); - - op_ret = mkdir (real_path, mode); - if (op_ret < 0) { - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "MKDIR %"PRId64" (%s): %s", - loc->ino, loc->path, strerror (op_errno)); - goto out; - } - - op_ret = chown (real_path, frame->root->uid, frame->root->gid); - if (op_ret < 0) { - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "MKDIR %"PRId64" (%s): %s " - "(failed to do chmod)", - loc->ino, loc->path, strerror (op_errno)); - goto err; - } - - op_ret = lstat (real_path, &stbuf); - if (op_ret < 0) { - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "MKDIR %"PRId64" (%s): %s " - "(failed to do lstat)", - loc->ino, loc->path, strerror (op_errno)); - goto err; - } - - bctx = bctx_lookup (B_TABLE(this), (char *)loc->path); - if (bctx == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "MKDIR %"PRId64" (%s): ENOMEM" - "(no database handle for parent)", - loc->ino, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto err; - } - - stbuf.st_ino = bdb_inode_transform (loc->parent->ino, key_string, - strlen (key_string)); - - goto out; - -err: - ret = rmdir (real_path); - if (ret < 0) { - gf_log (this->name, GF_LOG_DEBUG, - "MKDIR %"PRId64" (%s): %s" - "(failed to do rmdir)", - loc->ino, loc->path, strerror (errno)); - } - -out: - if (bctx) { - /* NOTE: bctx_unref always returns success, - * see description of bctx_unref for more details */ - bctx_unref (bctx); - } - - STACK_UNWIND (frame, op_ret, op_errno, loc->inode, &stbuf); - - return 0; -}/* bdb_mkdir */ - - -int32_t -bdb_unlink (call_frame_t *frame, - xlator_t *this, - loc_t *loc) -{ - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - bctx_t *bctx = NULL; - char *real_path = NULL; - char *key_string = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - - bctx = bctx_parent (B_TABLE(this), loc->path); - if (bctx == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "UNLINK %"PRId64" (%s): ENOMEM" - "(no database handle for parent)", - loc->ino, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - MAKE_KEY_FROM_PATH (key_string, loc->path); - op_ret = bdb_db_iremove (bctx, key_string); - if (op_ret == DB_NOTFOUND) { - MAKE_REAL_PATH (real_path, this, loc->path); - op_ret = unlink (real_path); - if (op_ret != 0) { - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "UNLINK %"PRId64" (%s): %s" - "(symlink unlink failed)", - loc->ino, loc->path, strerror (op_errno)); - goto out; - } - } else if (op_ret == 0) { - op_errno = 0; - } -out: - if (bctx) { - /* NOTE: bctx_unref always returns success, - * see description of bctx_unref for more details */ - bctx_unref (bctx); - } - - STACK_UNWIND (frame, op_ret, op_errno); - - return 0; -}/* bdb_unlink */ - - - -static int32_t -bdb_do_rmdir (xlator_t *this, - loc_t *loc) -{ - char *real_path = NULL; - int32_t ret = -1; - bctx_t *bctx = NULL; - DB_ENV *dbenv = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - - dbenv = BDB_ENV(this); - GF_VALIDATE_OR_GOTO (this->name, dbenv, out); - - MAKE_REAL_PATH (real_path, this, loc->path); - - bctx = bctx_lookup (B_TABLE(this), loc->path); - if (bctx == NULL) { - ret = -ENOMEM; - goto out; - } - - LOCK(&bctx->lock); - { - if ((bctx->primary == NULL) - || (bctx->secondary == NULL)) { - goto unlock; - } - - ret = bctx->primary->close (bctx->primary, 0); - if (ret < 0) { - ret = -EINVAL; - } - - ret = bctx->secondary->close (bctx->secondary, 0); - if (ret < 0) { - ret = -EINVAL; - } - - ret = dbenv->dbremove (dbenv, NULL, bctx->db_path, - "primary", 0); - if (ret < 0) { - ret = -EBUSY; - } - - ret = dbenv->dbremove (dbenv, NULL, bctx->db_path, - "secondary", 0); - if (ret != 0) { - ret = -EBUSY; - } - } -unlock: - UNLOCK(&bctx->lock); - - if (ret) { - goto out; - } - ret = rmdir (real_path); - -out: - if (bctx) { - /* NOTE: bctx_unref always returns success, - * see description of bctx_unref for more details */ - bctx_unref (bctx); - } - - return ret; -} - -int32_t -bdb_rmdir (call_frame_t *frame, - xlator_t *this, - loc_t *loc) -{ - int32_t op_ret = -1; - int32_t op_errno = 0; - - op_ret = is_dir_empty (this, loc); - if (op_ret < 0) { - op_errno = -op_ret; - gf_log (this->name, GF_LOG_DEBUG, - "RMDIR %"PRId64" (%s): %s" - "(internal rmdir routine returned error)", - loc->ino, loc->path, strerror (op_errno)); - } else if (op_ret == 0) { - op_ret = -1; - op_errno = ENOTEMPTY; - gf_log (this->name, GF_LOG_DEBUG, - "RMDIR %"PRId64" (%s): ENOTEMPTY", - loc->ino, loc->path); - goto out; - } - - op_ret = bdb_do_rmdir (this, loc); - if (op_ret < 0) { - op_errno = -op_ret; - gf_log (this->name, GF_LOG_DEBUG, - "RMDIR %"PRId64" (%s): %s" - "(internal rmdir routine returned error)", - loc->ino, loc->path, strerror (op_errno)); - goto out; - } - -out: - STACK_UNWIND (frame, op_ret, op_errno); - - return 0; -} /* bdb_rmdir */ - -int32_t -bdb_symlink (call_frame_t *frame, - xlator_t *this, - const char *linkname, - loc_t *loc) -{ - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - char *real_path = NULL; - struct stat stbuf = {0,}; - struct bdb_private *private = NULL; - bctx_t *bctx = NULL; - char *key_string = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - GF_VALIDATE_OR_GOTO (this->name, linkname, out); - - private = this->private; - GF_VALIDATE_OR_GOTO (this->name, private, out); - - MAKE_KEY_FROM_PATH (key_string, loc->path); - - MAKE_REAL_PATH (real_path, this, loc->path); - op_ret = symlink (linkname, real_path); - op_errno = errno; - if (op_ret == 0) { - op_ret = lstat (real_path, &stbuf); - if (op_ret != 0) { - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "SYMLINK %"PRId64" (%s): %s", - loc->ino, loc->path, strerror (op_errno)); - goto err; - } - - bctx = bctx_parent (B_TABLE(this), loc->path); - if (bctx == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "SYMLINK %"PRId64" (%s): ENOMEM" - "(no database handle for parent)", - loc->ino, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto err; - } - - stbuf.st_ino = bdb_inode_transform (loc->parent->ino, - key_string, - strlen (key_string)); - stbuf.st_mode = private->symlink_mode; - - goto out; - } -err: - op_ret = unlink (real_path); - op_errno = errno; - if (op_ret != 0) { - gf_log (this->name, GF_LOG_DEBUG, - "SYMLINK %"PRId64" (%s): %s" - "(failed to unlink the created symlink)", - loc->ino, loc->path, strerror (op_errno)); - } - op_ret = -1; - op_errno = ENOENT; -out: - if (bctx) { - /* NOTE: bctx_unref always returns success, - * see description of bctx_unref for more details */ - bctx_unref (bctx); - } - - STACK_UNWIND (frame, op_ret, op_errno, loc->inode, &stbuf); - - return 0; -} /* bdb_symlink */ - -static int -bdb_do_chmod (xlator_t *this, - const char *path, - struct stat *stbuf) -{ - int32_t ret = -1; - - ret = lchmod (path, stbuf->st_mode); - if ((ret == -1) && (errno == ENOSYS)) { - ret = chmod (path, stbuf->st_mode); - } - - return ret; -} - -static int -bdb_do_chown (xlator_t *this, - const char *path, - struct stat *stbuf, - int32_t valid) -{ - int32_t ret = -1; - uid_t uid = -1; - gid_t gid = -1; - - if (valid & GF_SET_ATTR_UID) - uid = stbuf->st_uid; - - if (valid & GF_SET_ATTR_GID) - gid = stbuf->st_gid; - - ret = lchown (path, uid, gid); - - return ret; -} - -static int -bdb_do_utimes (xlator_t *this, - const char *path, - struct stat *stbuf) -{ - int32_t ret = -1; - struct timeval tv[2] = {{0,},{0,}}; - - tv[0].tv_sec = stbuf->st_atime; - tv[0].tv_usec = ST_ATIM_NSEC (stbuf) / 1000; - tv[1].tv_sec = stbuf->st_mtime; - tv[1].tv_usec = ST_ATIM_NSEC (stbuf) / 1000; - - ret = lutimes (path, tv); - - return ret; -} - -int32_t -bdb_setattr (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - struct stat *stbuf, - int32_t valid) -{ - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - char *real_path = NULL; - struct stat preop = {0,}; - struct stat postop = {0,}; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - - MAKE_REAL_PATH (real_path, this, loc->path); - op_ret = lstat (real_path, &preop); - op_errno = errno; - if (op_ret != 0) { - if (op_errno == ENOENT) { - op_errno = EPERM; - } else { - gf_log (this->name, GF_LOG_DEBUG, - "CHMOD %"PRId64" (%s): %s" - "(pre-op lstat failed)", - loc->ino, loc->path, strerror (op_errno)); - } - goto out; - } - - /* directory or symlink */ - if (valid & GF_SET_ATTR_MODE) { - op_ret = bdb_do_chmod (this, real_path, stbuf); - if (op_ret == -1) { - op_errno = errno; - gf_log (this->name, GF_LOG_ERROR, - "setattr (chmod) on %s failed: %s", loc->path, - strerror (op_errno)); - goto out; - } - } - - if (valid & (GF_SET_ATTR_UID | GF_SET_ATTR_GID)){ - op_ret = bdb_do_chown (this, real_path, stbuf, valid); - if (op_ret == -1) { - op_errno = errno; - gf_log (this->name, GF_LOG_ERROR, - "setattr (chown) on %s failed: %s", loc->path, - strerror (op_errno)); - goto out; - } - } - - if (valid & (GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME)) { - op_ret = bdb_do_utimes (this, real_path, stbuf); - if (op_ret == -1) { - op_errno = errno; - gf_log (this->name, GF_LOG_ERROR, - "setattr (utimes) on %s failed: %s", loc->path, - strerror (op_errno)); - goto out; - } - } - - op_ret = lstat (real_path, &postop); - op_errno = errno; - if (op_ret != 0) { - gf_log (this->name, GF_LOG_DEBUG, - "CHMOD %"PRId64" (%s): %s" - "(post-op lstat failed)", - loc->ino, loc->path, strerror (op_errno)); - } - -out: - STACK_UNWIND (frame, op_ret, op_errno, &preop, &postop); - - return 0; -}/* bdb_setattr */ - -int32_t -bdb_fsetattr (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - struct stat *stbuf, - int32_t valid) -{ - int32_t op_ret = -1; - int32_t op_errno = EPERM; - struct stat preop = {0,}; - struct stat postop = {0,}; - - STACK_UNWIND (frame, op_ret, op_errno, &preop, &postop); - - return 0; -}/* bdb_fsetattr */ - - -int32_t -bdb_truncate (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - off_t offset) -{ - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - char *real_path = NULL; - struct stat stbuf = {0,}; - char *db_path = NULL; - bctx_t *bctx = NULL; - char *key_string = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - - bctx = bctx_parent (B_TABLE(this), loc->path); - if (bctx == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "TRUNCATE %"PRId64" (%s): ENOMEM" - "(no database handle for parent)", - loc->ino, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - MAKE_REAL_PATH (real_path, this, loc->path); - MAKE_KEY_FROM_PATH (key_string, loc->path); - - /* now truncate */ - MAKE_REAL_PATH_TO_STORAGE_DB (db_path, this, bctx->directory); - op_ret = lstat (db_path, &stbuf); - if (op_ret != 0) { - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "TRUNCATE %"PRId64" (%s): %s" - "(lstat on database file failed)", - loc->ino, loc->path, strerror (op_errno)); - goto out; - } - - if (loc->inode->ino) { - stbuf.st_ino = loc->inode->ino; - }else { - stbuf.st_ino = bdb_inode_transform (loc->parent->ino, - key_string, - strlen (key_string)); - } - - op_ret = bdb_db_itruncate (bctx, key_string); - if (op_ret < 0) { - gf_log (this->name, GF_LOG_DEBUG, - "TRUNCATE %"PRId64" (%s): EINVAL" - "(truncating entry in database failed - %s)", - loc->ino, loc->path, db_strerror (op_ret)); - op_errno = EINVAL; /* TODO: better errno */ - } - -out: - if (bctx) { - /* NOTE: bctx_unref always returns success, - * see description of bctx_unref for more details */ - bctx_unref (bctx); - } - - STACK_UNWIND (frame, op_ret, op_errno, &stbuf); - - return 0; -}/* bdb_truncate */ - - -int32_t -bdb_statfs (call_frame_t *frame, - xlator_t *this, - loc_t *loc) - -{ - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - char *real_path = NULL; - struct statvfs buf = {0, }; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - - MAKE_REAL_PATH (real_path, this, loc->path); - - op_ret = statvfs (real_path, &buf); - op_errno = errno; -out: - STACK_UNWIND (frame, op_ret, op_errno, &buf); - return 0; -}/* bdb_statfs */ - -static int gf_bdb_xattr_log; - -/* bdb_setxattr - set extended attributes. - * - * bdb allows setxattr operation only on directories. - * bdb reservers 'glusterfs.file.<attribute-name>' to operate on the content - * of the files under the specified directory. - * 'glusterfs.file.<attribute-name>' transforms to contents of file of name - * '<attribute-name>' under specified directory. - * - * @frame: call frame. - * @this: xlator_t of this instance of bdb xlator. - * @loc: loc_t specifying the file to operate upon. - * @dict: list of extended attributes to set on @loc. - * @flags: can be XATTR_REPLACE (replace an existing extended attribute only if - * it exists) or XATTR_CREATE (create an extended attribute only if it - * doesn't already exist). - * - * - */ -int32_t -bdb_setxattr (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - dict_t *dict, - int flags) -{ - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - data_pair_t *trav = dict->members_list; - bctx_t *bctx = NULL; - char *real_path = NULL; - char *key = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - GF_VALIDATE_OR_GOTO (this->name, dict, out); - - MAKE_REAL_PATH (real_path, this, loc->path); - if (!S_ISDIR (loc->inode->st_mode)) { - op_ret = -1; - op_errno = ENOATTR; - goto out; - } - - while (trav) { - if (GF_FILE_CONTENT_REQUEST(trav->key) ) { - key = BDB_KEY_FROM_FREQUEST_KEY(trav->key); - - bctx = bctx_lookup (B_TABLE(this), loc->path); - if (bctx == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "SETXATTR %"PRId64" (%s) - %s: ENOMEM" - "(no database handle for directory)", - loc->ino, loc->path, key); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - if (flags & XATTR_REPLACE) { - op_ret = bdb_db_itruncate (bctx, key); - if (op_ret == -1) { - /* key doesn't exist in database */ - gf_log (this->name, GF_LOG_DEBUG, - "SETXATTR %"PRId64" (%s) - %s:" - " (entry not present in " - "database)", - loc->ino, loc->path, key); - op_ret = -1; - op_errno = ENOATTR; - break; - } - op_ret = bdb_db_iwrite (bctx, key, - trav->value->data, - trav->value->len); - if (op_ret != 0) { - op_ret = -1; - op_errno = ENOATTR; - break; - } - } else { - /* fresh create */ - op_ret = bdb_db_iwrite (bctx, key, - trav->value->data, - trav->value->len); - if (op_ret != 0) { - op_ret = -1; - op_errno = EEXIST; - break; - } else { - op_ret = 0; - op_errno = 0; - } /* if(op_ret!=0)...else */ - } /* if(flags&XATTR_REPLACE)...else */ - if (bctx) { - /* NOTE: bctx_unref always returns success, see - * description of bctx_unref for more details */ - bctx_unref (bctx); - } - } else { - /* do plain setxattr */ - op_ret = lsetxattr (real_path, - trav->key, trav->value->data, - trav->value->len, - flags); - op_errno = errno; - - if ((op_errno == ENOATTR) || (op_errno == EEXIST)) { - /* don't log, normal behaviour */ - ; - } else if (BDB_TIMED_LOG (op_errno, gf_bdb_xattr_log)) { - gf_log (this->name, GF_LOG_DEBUG, - "SETXATTR %"PRId64" (%s) - %s: %s", - loc->ino, loc->path, trav->key, - strerror (op_errno)); - /* do not continue, break out */ - break; - } else { - gf_log (this->name, GF_LOG_DEBUG, - "SETXATTR %"PRId64" (%s) - %s: %s", - loc->ino, loc->path, trav->key, - strerror (op_errno)); - } - } /* if(ZR_FILE_CONTENT_REQUEST())...else */ - trav = trav->next; - }/* while(trav) */ -out: - STACK_UNWIND (frame, op_ret, op_errno); - return 0; -}/* bdb_setxattr */ - - -/* bdb_gettxattr - get extended attributes. - * - * bdb allows getxattr operation only on directories. - * bdb_getxattr retrieves the whole content of the file, when - * glusterfs.file.<attribute-name> is specified. - * - * @frame: call frame. - * @this: xlator_t of this instance of bdb xlator. - * @loc: loc_t specifying the file to operate upon. - * @name: name of extended attributes to get for @loc. - * - * NOTE: see description of bdb_setxattr for details on how - * 'glusterfs.file.<attribute-name>' is handles by bdb. - */ -int32_t -bdb_getxattr (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - const char *name) -{ - int32_t op_ret = 0; - int32_t op_errno = 0; - dict_t *dict = NULL; - bctx_t *bctx = NULL; - char *buf = NULL; - char *key_string = NULL; - int32_t list_offset = 0; - size_t size = 0; - size_t remaining_size = 0; - char *real_path = NULL; - char key[1024] = {0,}; - char *value = NULL; - char *list = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - GF_VALIDATE_OR_GOTO (this->name, name, out); - - dict = dict_new (); - GF_VALIDATE_OR_GOTO (this->name, dict, out); - - if (!S_ISDIR (loc->inode->st_mode)) { - gf_log (this->name, GF_LOG_DEBUG, - "GETXATTR %"PRId64" (%s) - %s: ENOATTR " - "(not a directory)", - loc->ino, loc->path, name); - op_ret = -1; - op_errno = ENOATTR; - goto out; - } - - if (name && GF_FILE_CONTENT_REQUEST(name)) { - bctx = bctx_lookup (B_TABLE(this), loc->path); - if (bctx == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "GETXATTR %"PRId64" (%s) - %s: ENOMEM" - "(no database handle for directory)", - loc->ino, loc->path, name); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - key_string = BDB_KEY_FROM_FREQUEST_KEY(name); - - op_ret = bdb_db_iread (bctx, key_string, &buf); - if (op_ret == -1) { - gf_log (this->name, GF_LOG_DEBUG, - "GETXATTR %"PRId64" (%s) - %s: ENOATTR" - "(attribute not present in database)", - loc->ino, loc->path, name); - op_errno = ENOATTR; - goto out; - } - - op_ret = dict_set_dynptr (dict, (char *)name, buf, op_ret); - if (op_ret < 0) { - gf_log (this->name, GF_LOG_DEBUG, - "GETXATTR %"PRId64" (%s) - %s: ENOATTR" - "(attribute present in database, " - "dict set failed)", - loc->ino, loc->path, name); - op_errno = ENODATA; - } - - goto out; - } - - MAKE_REAL_PATH (real_path, this, loc->path); - size = sys_llistxattr (real_path, NULL, 0); - op_errno = errno; - if (size < 0) { - if (BDB_TIMED_LOG (op_errno, gf_bdb_xattr_log)) { - gf_log (this->name, GF_LOG_DEBUG, - "GETXATTR %"PRId64" (%s) - %s: %s", - loc->ino, loc->path, name, strerror (op_errno)); - } else { - gf_log (this->name, GF_LOG_DEBUG, - "GETXATTR %"PRId64" (%s) - %s: %s", - loc->ino, loc->path, name, strerror (op_errno)); - } - op_ret = -1; - op_errno = ENOATTR; - - goto out; - } - - if (size == 0) - goto done; - - list = alloca (size + 1); - if (list == NULL) { - op_ret = -1; - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "GETXATTR %"PRId64" (%s) - %s: %s", - loc->ino, loc->path, name, strerror (op_errno)); - } - - size = sys_llistxattr (real_path, list, size); - op_ret = size; - if (op_ret == -1) { - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "GETXATTR %"PRId64" (%s) - %s: %s", - loc->ino, loc->path, name, strerror (op_errno)); - goto out; - } - - remaining_size = size; - list_offset = 0; - while (remaining_size > 0) { - if(*(list+list_offset) == '\0') - break; - - strcpy (key, list + list_offset); - - op_ret = sys_lgetxattr (real_path, key, NULL, 0); - if (op_ret == -1) - break; - - value = GF_CALLOC (op_ret + 1, sizeof(char), gf_bdb_mt_char); - GF_VALIDATE_OR_GOTO (this->name, value, out); - - op_ret = sys_lgetxattr (real_path, key, value, - op_ret); - if (op_ret == -1) - break; - value [op_ret] = '\0'; - op_ret = dict_set_dynptr (dict, key, - value, op_ret); - if (op_ret < 0) { - GF_FREE (value); - gf_log (this->name, GF_LOG_DEBUG, - "GETXATTR %"PRId64" (%s) - %s: " - "(skipping key %s)", - loc->ino, loc->path, name, key); - continue; - } - remaining_size -= strlen (key) + 1; - list_offset += strlen (key) + 1; - } /* while(remaining_size>0) */ -done: -out: - if(bctx) { - /* NOTE: bctx_unref always returns success, - * see description of bctx_unref for more details */ - bctx_unref (bctx); - } - - STACK_UNWIND (frame, op_ret, op_errno, dict); - - if (dict) - dict_unref (dict); - - return 0; -}/* bdb_getxattr */ - - -int32_t -bdb_removexattr (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - const char *name) -{ - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - bctx_t *bctx = NULL; - char *real_path = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - GF_VALIDATE_OR_GOTO (this->name, name, out); - - if (!S_ISDIR(loc->inode->st_mode)) { - gf_log (this->name, GF_LOG_DEBUG, - "REMOVEXATTR %"PRId64" (%s) - %s: ENOATTR " - "(not a directory)", - loc->ino, loc->path, name); - op_ret = -1; - op_errno = ENOATTR; - goto out; - } - - if (GF_FILE_CONTENT_REQUEST(name)) { - bctx = bctx_lookup (B_TABLE(this), loc->path); - if (bctx == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "REMOVEXATTR %"PRId64" (%s) - %s: ENOATTR" - "(no database handle for directory)", - loc->ino, loc->path, name); - op_ret = -1; - op_errno = ENOATTR; - goto out; - } - - op_ret = bdb_db_iremove (bctx, name); - if (op_ret == -1) { - gf_log (this->name, GF_LOG_DEBUG, - "REMOVEXATTR %"PRId64" (%s) - %s: ENOATTR" - "(no such attribute in database)", - loc->ino, loc->path, name); - op_errno = ENOATTR; - } - goto out; - } - - MAKE_REAL_PATH(real_path, this, loc->path); - op_ret = lremovexattr (real_path, name); - op_errno = errno; - if (op_ret == -1) { - if (BDB_TIMED_LOG (op_errno, gf_bdb_xattr_log)) { - gf_log (this->name, GF_LOG_DEBUG, - "REMOVEXATTR %"PRId64" (%s) - %s: %s", - loc->ino, loc->path, name, strerror (op_errno)); - } else { - gf_log (this->name, GF_LOG_DEBUG, - "REMOVEXATTR %"PRId64" (%s) - %s: %s", - loc->ino, loc->path, name, strerror (op_errno)); - } - } /* if(op_ret == -1) */ -out: - if (bctx) { - /* NOTE: bctx_unref always returns success, - * see description of bctx_unref for more details */ - bctx_unref (bctx); - } - - STACK_UNWIND (frame, op_ret, op_errno); - return 0; -}/* bdb_removexattr */ - - -int32_t -bdb_fsyncdir (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - int datasync) -{ - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - struct bdb_fd *bfd = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, fd, out); - - BDB_FCTX_GET (fd, this, &bfd); - if (bfd == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "FSYNCDIR %"PRId64": EBADFD" - "(failed to find internal context from fd)", - fd->inode->ino); - op_errno = EBADFD; - op_ret = -1; - } - -out: - STACK_UNWIND (frame, op_ret, op_errno); - - return 0; -}/* bdb_fsycndir */ - - -int32_t -bdb_access (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - int32_t mask) -{ - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - char *real_path = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - - MAKE_REAL_PATH (real_path, this, loc->path); - - op_ret = access (real_path, mask); - op_errno = errno; - /* TODO: implement for db entries */ -out: - STACK_UNWIND (frame, op_ret, op_errno); - return 0; -}/* bdb_access */ - - -int32_t -bdb_ftruncate (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - off_t offset) -{ - int32_t op_ret = -1; - int32_t op_errno = EPERM; - struct stat buf = {0,}; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, fd, out); - /* TODO: impelement */ -out: - STACK_UNWIND (frame, op_ret, op_errno, &buf); - - return 0; -} - - - -int32_t -bdb_setdents (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - int32_t flags, - dir_entry_t *entries, - int32_t count) -{ - int32_t op_ret = -1, op_errno = EINVAL; - char *entry_path = NULL; - int32_t real_path_len = 0; - int32_t entry_path_len = 0; - int32_t ret = 0; - struct bdb_dir *bfd = NULL; - dir_entry_t *trav = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, fd, out); - GF_VALIDATE_OR_GOTO (this->name, entries, out); - - BDB_FCTX_GET (fd, this, &bfd); - if (bfd == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "SETDENTS %"PRId64": EBADFD", - fd->inode->ino); - op_errno = EBADFD; - op_ret = -1; - goto out; - } - - real_path_len = strlen (bfd->path); - entry_path_len = real_path_len + 256; - entry_path = GF_CALLOC (1, entry_path_len, gf_bdb_mt_char); - GF_VALIDATE_OR_GOTO (this->name, entry_path, out); - - strcpy (entry_path, bfd->path); - entry_path[real_path_len] = '/'; - - trav = entries->next; - while (trav) { - char pathname[PATH_MAX] = {0,}; - strcpy (pathname, entry_path); - strcat (pathname, trav->name); - - if (S_ISDIR(trav->buf.st_mode)) { - /* If the entry is directory, create it by calling - * 'mkdir'. If directory is not present, it will be - * created, if its present, no worries even if it fails. - */ - ret = mkdir (pathname, trav->buf.st_mode); - if ((ret == -1) && (errno != EEXIST)) { - op_errno = errno; - op_ret = ret; - gf_log (this->name, GF_LOG_DEBUG, - "SETDENTS %"PRId64" - %s: %s " - "(mkdir failed)", - fd->inode->ino, pathname, - strerror (op_errno)); - goto loop; - } - - /* Change the mode - * NOTE: setdents tries its best to restore the state - * of storage. if chmod and chown fail, they can - * be ignored now */ - ret = chmod (pathname, trav->buf.st_mode); - if (ret < 0) { - op_ret = -1; - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "SETDENTS %"PRId64" - %s: %s " - "(chmod failed)", - fd->inode->ino, pathname, - strerror (op_errno)); - goto loop; - } - /* change the ownership */ - ret = chown (pathname, trav->buf.st_uid, - trav->buf.st_gid); - if (ret != 0) { - op_ret = -1; - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "SETDENTS %"PRId64" - %s: %s " - "(chown failed)", - fd->inode->ino, pathname, - strerror (op_errno)); - goto loop; - } - } else if ((flags == GF_SET_IF_NOT_PRESENT) || - (flags != GF_SET_DIR_ONLY)) { - /* Create a 0 byte file here */ - if (S_ISREG (trav->buf.st_mode)) { - op_ret = bdb_db_icreate (bfd->ctx, - trav->name); - if (op_ret < 0) { - gf_log (this->name, GF_LOG_DEBUG, - "SETDENTS %"PRId64" (%s) - %s: " - "%s (database entry creation" - " failed)", - fd->inode->ino, - bfd->ctx->directory, trav->name, - strerror (op_errno)); - } - } else if (S_ISLNK (trav->buf.st_mode)) { - /* TODO: impelement */; - } else { - gf_log (this->name, GF_LOG_DEBUG, - "SETDENTS %"PRId64" (%s) - %s mode=%o: " - "(unsupported file type)", - fd->inode->ino, - bfd->ctx->directory, trav->name, - trav->buf.st_mode); - } /* if(S_ISREG())...else */ - } /* if(S_ISDIR())...else if */ - loop: - /* consider the next entry */ - trav = trav->next; - } /* while(trav) */ - -out: - STACK_UNWIND (frame, op_ret, op_errno); - - GF_FREE (entry_path); - return 0; -} - -int32_t -bdb_fstat (call_frame_t *frame, - xlator_t *this, - fd_t *fd) -{ - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - struct stat stbuf = {0,}; - struct bdb_fd *bfd = NULL; - bctx_t *bctx = NULL; - char *db_path = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, fd, out); - - BDB_FCTX_GET (fd, this, &bfd); - if (bfd == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "FSTAT %"PRId64": EBADFD " - "(failed to find internal context in fd)", - fd->inode->ino); - op_errno = EBADFD; - op_ret = -1; - goto out; - } - - bctx = bfd->ctx; - - MAKE_REAL_PATH_TO_STORAGE_DB (db_path, this, bctx->directory); - op_ret = lstat (db_path, &stbuf); - op_errno = errno; - if (op_ret != 0) { - gf_log (this->name, GF_LOG_DEBUG, - "FSTAT %"PRId64": %s" - "(failed to stat database file %s)", - fd->inode->ino, strerror (op_errno), db_path); - goto out; - } - - stbuf.st_ino = fd->inode->ino; - stbuf.st_size = bdb_db_fread (bfd, NULL, 0, 0); - stbuf.st_blocks = BDB_COUNT_BLOCKS (stbuf.st_size, stbuf.st_blksize); - -out: - STACK_UNWIND (frame, op_ret, op_errno, &stbuf); - return 0; -} - -gf_dirent_t * -gf_dirent_for_namen (const char *name, - size_t len) -{ - char *tmp_name = NULL; - - tmp_name = alloca (len + 1); - - memcpy (tmp_name, name, len); - - tmp_name[len] = 0; - - return gf_dirent_for_name (tmp_name); -} - -int32_t -bdb_readdir (call_frame_t *frame, - xlator_t *this, - fd_t *fd, - size_t size, - off_t off) -{ - struct bdb_dir *bfd = NULL; - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - size_t filled = 0; - gf_dirent_t *this_entry = NULL; - gf_dirent_t entries; - struct dirent *entry = NULL; - off_t in_case = 0; - int32_t this_size = 0; - DBC *cursorp = NULL; - int32_t count = 0; - off_t offset = 0; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, fd, out); - - INIT_LIST_HEAD (&entries.list); - - BDB_FCTX_GET (fd, this, &bfd); - if (bfd == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "READDIR %"PRId64" - %"GF_PRI_SIZET",%"PRId64": EBADFD " - "(failed to find internal context in fd)", - fd->inode->ino, size, off); - op_errno = EBADFD; - op_ret = -1; - goto out; - } - - op_ret = bdb_cursor_open (bfd->ctx, &cursorp); - if (op_ret < 0) { - gf_log (this->name, GF_LOG_DEBUG, - "READDIR %"PRId64" - %"GF_PRI_SIZET",%"PRId64": EBADFD " - "(failed to open cursor to database handle)", - fd->inode->ino, size, off); - op_errno = EBADFD; - goto out; - } - - if (off) { - DBT sec = {0,}, pri = {0,}, val = {0,}; - sec.data = &(off); - sec.size = sizeof (off); - sec.flags = DB_DBT_USERMEM; - val.dlen = 0; - val.doff = 0; - val.flags = DB_DBT_PARTIAL; - - op_ret = bdb_cursor_get (cursorp, &sec, &pri, &val, DB_SET); - if (op_ret == DB_NOTFOUND) { - offset = off; - goto dir_read; - } - } - - while (filled <= size) { - DBT sec = {0,}, pri = {0,}, val = {0,}; - - this_entry = NULL; - - sec.flags = DB_DBT_MALLOC; - pri.flags = DB_DBT_MALLOC; - val.dlen = 0; - val.doff = 0; - val.flags = DB_DBT_PARTIAL; - op_ret = bdb_cursor_get (cursorp, &sec, &pri, &val, DB_NEXT); - - if (op_ret == DB_NOTFOUND) { - /* we reached end of the directory */ - op_ret = 0; - op_errno = 0; - break; - } else if (op_ret < 0) { - gf_log (this->name, GF_LOG_DEBUG, - "READDIR %"PRId64" - %"GF_PRI_SIZET",%"PRId64":" - "(failed to read the next entry from database)", - fd->inode->ino, size, off); - op_errno = ENOENT; - break; - } /* if (op_ret == DB_NOTFOUND)...else if...else */ - - if (pri.data == NULL) { - /* NOTE: currently ignore when we get key.data == NULL. - * TODO: we should not get key.data = NULL */ - gf_log (this->name, GF_LOG_DEBUG, - "READDIR %"PRId64" - %"GF_PRI_SIZET",%"PRId64":" - "(null key read for entry from database)", - fd->inode->ino, size, off); - continue; - }/* if(key.data)...else */ - count++; - this_size = bdb_dirent_size (&pri); - if (this_size + filled > size) - break; - /* TODO - consider endianness here */ - this_entry = gf_dirent_for_namen ((const char *)pri.data, - pri.size); - - this_entry->d_ino = bdb_inode_transform (fd->inode->ino, - pri.data, - pri.size); - this_entry->d_off = *(uint32_t *)sec.data; - this_entry->d_type = 0; - this_entry->d_len = pri.size + 1; - - if (sec.data) { - GF_FREE (sec.data); - } - - if (pri.data) - GF_FREE (pri.data); - - list_add_tail (&this_entry->list, &entries.list); - - filled += this_size; - }/* while */ - bdb_cursor_close (bfd->ctx, cursorp); - op_ret = filled; - op_errno = 0; - if (filled >= size) { - goto out; - } -dir_read: - /* hungry kyaa? */ - if (!offset) { - rewinddir (bfd->dir); - } else { - seekdir (bfd->dir, offset); - } - - while (filled <= size) { - this_entry = NULL; - entry = NULL; - this_size = 0; - - in_case = telldir (bfd->dir); - entry = readdir (bfd->dir); - if (!entry) - break; - - if (IS_BDB_PRIVATE_FILE(entry->d_name)) - continue; - - this_size = dirent_size (entry); - - if (this_size + filled > size) { - seekdir (bfd->dir, in_case); - break; - } - - count++; - - this_entry = gf_dirent_for_name (entry->d_name); - this_entry->d_ino = entry->d_ino; - - this_entry->d_off = entry->d_off; - - this_entry->d_type = entry->d_type; - this_entry->d_len = entry->d_reclen; - - - list_add_tail (&this_entry->list, &entries.list); - - filled += this_size; - } - op_ret = filled; - op_errno = 0; - -out: - gf_log (this->name, GF_LOG_DEBUG, - "READDIR %"PRId64" - %"GF_PRI_SIZET" (%"PRId32")" - "/%"GF_PRI_SIZET",%"PRId64":" - "(failed to read the next entry from database)", - fd->inode->ino, filled, count, size, off); - - STACK_UNWIND (frame, count, op_errno, &entries); - - gf_dirent_free (&entries); - - return 0; -} - - -int32_t -bdb_stats (call_frame_t *frame, - xlator_t *this, - int32_t flags) - -{ - int32_t op_ret = 0; - int32_t op_errno = 0; - - struct xlator_stats xlstats = {0, }, *stats = NULL; - struct statvfs buf = {0,}; - struct timeval tv; - struct bdb_private *private = NULL; - int64_t avg_read = 0; - int64_t avg_write = 0; - int64_t _time_ms = 0; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - - private = (struct bdb_private *)(this->private); - stats = &xlstats; - - op_ret = statvfs (private->export_path, &buf); - if (op_ret != 0) { - op_errno = errno; - gf_log (this->name, GF_LOG_DEBUG, - "STATS %s: %s", - private->export_path, strerror (op_errno)); - goto out; - } - - stats->nr_files = private->stats.nr_files; - - /* client info is maintained at FSd */ - stats->nr_clients = private->stats.nr_clients; - - /* Number of Free block in the filesystem. */ - stats->free_disk = buf.f_bfree * buf.f_bsize; - stats->total_disk_size = buf.f_blocks * buf.f_bsize; /* */ - stats->disk_usage = (buf.f_blocks - buf.f_bavail) * buf.f_bsize; - - /* Calculate read and write usage */ - gettimeofday (&tv, NULL); - - /* Read */ - _time_ms = (tv.tv_sec - private->init_time.tv_sec) * 1000 + - ((tv.tv_usec - private->init_time.tv_usec) / 1000); - - avg_read = (_time_ms) ? (private->read_value / _time_ms) : 0;/* KBps */ - avg_write = (_time_ms) ? (private->write_value / _time_ms) : 0; - - _time_ms = (tv.tv_sec - private->prev_fetch_time.tv_sec) * 1000 + - ((tv.tv_usec - private->prev_fetch_time.tv_usec) / 1000); - if (_time_ms - && ((private->interval_read / _time_ms) > private->max_read)) { - private->max_read = (private->interval_read / _time_ms); - } - if (_time_ms - && ((private->interval_write / _time_ms) > private->max_write)) { - private->max_write = private->interval_write / _time_ms; - } - - stats->read_usage = avg_read / private->max_read; - stats->write_usage = avg_write / private->max_write; - - gettimeofday (&(private->prev_fetch_time), NULL); - private->interval_read = 0; - private->interval_write = 0; - -out: - STACK_UNWIND (frame, op_ret, op_errno, stats); - return 0; -} - - -int32_t -bdb_inodelk (call_frame_t *frame, xlator_t *this, - const char *volume, loc_t *loc, int32_t cmd, struct gf_flock *lock) -{ - gf_log (this->name, GF_LOG_ERROR, - "glusterfs internal locking request. please load " - "'features/locks' translator to enable glusterfs " - "support"); - - STACK_UNWIND (frame, -1, ENOSYS); - return 0; -} - - -int32_t -bdb_finodelk (call_frame_t *frame, xlator_t *this, - const char *volume, fd_t *fd, int32_t cmd, struct gf_flock *lock) -{ - gf_log (this->name, GF_LOG_ERROR, - "glusterfs internal locking request. please load " - "'features/locks' translator to enable glusterfs " - "support"); - - STACK_UNWIND (frame, -1, ENOSYS); - return 0; -} - - -int32_t -bdb_entrylk (call_frame_t *frame, xlator_t *this, - const char *volume, loc_t *loc, const char *basename, - entrylk_cmd cmd, entrylk_type type) -{ - gf_log (this->name, GF_LOG_ERROR, - "glusterfs internal locking request. please load " - "'features/locks' translator to enable glusterfs " - "support"); - - STACK_UNWIND (frame, -1, ENOSYS); - return 0; -} - - -int32_t -bdb_fentrylk (call_frame_t *frame, xlator_t *this, - const char *volume, fd_t *fd, const char *basename, - entrylk_cmd cmd, entrylk_type type) -{ - gf_log (this->name, GF_LOG_ERROR, - "glusterfs internal locking request. please load " - "'features/locks' translator to enable glusterfs " - "support"); - - STACK_UNWIND (frame, -1, ENOSYS); - return 0; -} - -int32_t -bdb_checksum (call_frame_t *frame, - xlator_t *this, - loc_t *loc, - int32_t flag) -{ - char *real_path = NULL; - DIR *dir = NULL; - struct dirent *dirent = NULL; - uint8_t file_checksum[NAME_MAX] = {0,}; - uint8_t dir_checksum[NAME_MAX] = {0,}; - int32_t op_ret = -1; - int32_t op_errno = EINVAL; - int32_t idx = 0, length = 0; - bctx_t *bctx = NULL; - DBC *cursorp = NULL; - char *data = NULL; - uint8_t no_break = 1; - - GF_VALIDATE_OR_GOTO ("bdb", frame, out); - GF_VALIDATE_OR_GOTO ("bdb", this, out); - GF_VALIDATE_OR_GOTO (this->name, loc, out); - - MAKE_REAL_PATH (real_path, this, loc->path); - - { - dir = opendir (real_path); - op_errno = errno; - GF_VALIDATE_OR_GOTO (this->name, dir, out); - while ((dirent = readdir (dir))) { - if (!dirent) - break; - - if (IS_BDB_PRIVATE_FILE(dirent->d_name)) - continue; - - length = strlen (dirent->d_name); - for (idx = 0; idx < length; idx++) - dir_checksum[idx] ^= dirent->d_name[idx]; - } /* while((dirent...)) */ - closedir (dir); - } - - { - bctx = bctx_lookup (B_TABLE(this), (char *)loc->path); - if (bctx == NULL) { - gf_log (this->name, GF_LOG_DEBUG, - "CHECKSUM %"PRId64" (%s): ENOMEM" - "(failed to lookup database handle)", - loc->inode->ino, loc->path); - op_ret = -1; - op_errno = ENOMEM; - goto out; - } - - op_ret = bdb_cursor_open (bctx, &cursorp); - if (op_ret < 0) { - gf_log (this->name, GF_LOG_DEBUG, - "CHECKSUM %"PRId64" (%s): EBADFD" - "(failed to open cursor to database handle)", - loc->inode->ino, loc->path); - op_ret = -1; - op_errno = EBADFD; - goto out; - } - - - do { - DBT key = {0,}, value = {0,}, sec = {0,}; - - key.flags = DB_DBT_MALLOC; - value.doff = 0; - value.dlen = 0; - op_ret = bdb_cursor_get (cursorp, &sec, &key, - &value, DB_NEXT); - - if (op_ret == DB_NOTFOUND) { - op_ret = 0; - op_errno = 0; - no_break = 0; - } else if (op_ret == 0){ - /* successfully read */ - data = key.data; - length = key.size; - for (idx = 0; idx < length; idx++) - file_checksum[idx] ^= data[idx]; - - GF_FREE (key.data); - } else { - gf_log (this->name, GF_LOG_DEBUG, - "CHECKSUM %"PRId64" (%s)", - loc->inode->ino, loc->path); - op_ret = -1; - op_errno = ENOENT; /* TODO: watch errno */ - no_break = 0; - }/* if(op_ret == DB_NOTFOUND)...else if...else */ - } while (no_break); - bdb_cursor_close (bctx, cursorp); - } -out: - if (bctx) { - /* NOTE: bctx_unref always returns success, - * see description of bctx_unref for more details */ - bctx_unref (bctx); - } - - STACK_UNWIND (frame, op_ret, op_errno, file_checksum, dir_checksum); - - return 0; -} - -/** - * notify - when parent sends PARENT_UP, send CHILD_UP event from here - */ -int32_t -notify (xlator_t *this, - int32_t event, - void *data, - ...) -{ - switch (event) - { - case GF_EVENT_PARENT_UP: - { - /* Tell the parent that bdb xlator is up */ - GF_ASSERT ((this->private != NULL) && - (BDB_ENV(this) != NULL)); - default_notify (this, GF_EVENT_CHILD_UP, data); - } - break; - default: - /* */ - break; - } - return 0; -} - - -int32_t -mem_acct_init (xlator_t *this) -{ - int ret = -1; - - if (!this) - return ret; - - ret = xlator_mem_acct_init (this, gf_bdb_mt_end + 1); - - if (ret != 0) { - gf_log(this->name, GF_LOG_ERROR, "Memory accounting init" - "failed"); - return ret; - } - - return ret; -} - -/** - * init - - */ -int32_t -init (xlator_t *this) -{ - int32_t ret = -1; - struct stat buf = {0,}; - struct bdb_private *_private = NULL; - char *directory = NULL; - bctx_t *bctx = NULL; - - GF_VALIDATE_OR_GOTO ("bdb", this, out); - - if (this->children) { - gf_log (this->name, GF_LOG_ERROR, - "'storage/bdb' translator should be used as leaf node " - "in translator tree. please remove the subvolumes" - " specified and retry."); - goto err; - } - - if (!this->parents) { - gf_log (this->name, GF_LOG_ERROR, - "'storage/bdb' translator needs at least one among " - "'protocol/server' or 'mount/fuse' translator as " - "parent. please add 'protocol/server' or 'mount/fuse' " - "as parent of 'storage/bdb' and retry. or you can also" - " try specifying mount-point on command-line."); - goto err; - } - - _private = GF_CALLOC (1, sizeof (*_private), gf_bdb_mt_bdb_private); - if (_private == NULL) { - gf_log (this->name, GF_LOG_ERROR, - "could not allocate memory for 'storage/bdb' " - "configuration data-structure. cannot continue from " - "here"); - goto err; - } - - - ret = dict_get_str (this->options, "directory", &directory); - if (ret < 0) { - gf_log (this->name, GF_LOG_ERROR, - "'storage/bdb' needs at least " - "'option directory <path-to-export-directory>' as " - "minimal configuration option. please specify an " - "export directory using " - "'option directory <path-to-export-directory>' and " - "retry."); - goto err; - } - - umask (000); /* umask `masking' is done at the client side */ - - /* Check whether the specified directory exists, if not create it. */ - ret = stat (directory, &buf); - if (ret < 0) { - gf_log (this->name, GF_LOG_ERROR, - "specified export path '%s' does not exist. " - "please create the export path '%s' and retry.", - directory, directory); - goto err; - } else if (!S_ISDIR (buf.st_mode)) { - gf_log (this->name, GF_LOG_ERROR, - "specified export path '%s' is not a directory. " - "please specify a valid and existing directory as " - "export directory and retry.", - directory); - goto err; - } else { - ret = 0; - } - - - _private->export_path = gf_strdup (directory); - if (_private->export_path == NULL) { - gf_log (this->name, GF_LOG_ERROR, - "could not allocate memory for 'storage/bdb' " - "configuration data-structure. cannot continue from " - "here"); - goto err; - } - - _private->export_path_length = strlen (_private->export_path); - - { - /* Stats related variables */ - gettimeofday (&_private->init_time, NULL); - gettimeofday (&_private->prev_fetch_time, NULL); - _private->max_read = 1; - _private->max_write = 1; - } - - this->private = (void *)_private; - - { - ret = bdb_db_init (this, this->options); - - if (ret < 0){ - gf_log (this->name, GF_LOG_ERROR, - "database environment initialisation failed. " - "manually run database recovery tool and " - "retry to run glusterfs"); - goto err; - } else { - bctx = bctx_lookup (_private->b_table, "/"); - /* NOTE: we are not doing bctx_unref() for root bctx, - * let it remain in active list forever */ - if (bctx == NULL) { - gf_log (this->name, GF_LOG_ERROR, - "could not allocate memory for " - "'storage/bdb' configuration data-" - "structure. cannot continue from " - "here"); - goto err; - } else { - ret = 0; - goto out; - } - } - } -err: - if (_private) { - if (_private->export_path) - GF_FREE (_private->export_path); - - GF_FREE (_private); - } -out: - return ret; -} - -void -bctx_cleanup (struct list_head *head) -{ - bctx_t *trav = NULL; - bctx_t *tmp = NULL; - DB *storage = NULL; - DB *secondary = NULL; - - list_for_each_entry_safe (trav, tmp, head, list) { - LOCK (&trav->lock); - { - storage = trav->primary; - trav->primary = NULL; - - secondary = trav->secondary; - trav->secondary = NULL; - - list_del_init (&trav->list); - } - UNLOCK (&trav->lock); - - if (storage) { - storage->close (storage, 0); - storage = NULL; - } - - if (secondary) { - secondary->close (secondary, 0); - secondary = NULL; - } - } - return; -} - -void -fini (xlator_t *this) -{ - struct bdb_private *private = NULL; - int32_t ret = 0; - - private = this->private; - - if (B_TABLE(this)) { - /* close all the dbs from lru list */ - bctx_cleanup (&(B_TABLE(this)->b_lru)); - bctx_cleanup (&(B_TABLE(this)->active)); - - if (BDB_ENV(this)) { - LOCK (&private->active_lock); - { - private->active = 0; - } - UNLOCK (&private->active_lock); - - ret = pthread_join (private->checkpoint_thread, NULL); - if (ret != 0) { - gf_log (this->name, GF_LOG_CRITICAL, - "could not complete checkpointing " - "database environment. this might " - "result in inconsistencies in few" - " recent data and meta-data " - "operations"); - } - - BDB_ENV(this)->close (BDB_ENV(this), 0); - } else { - /* impossible to reach here */ - } - - GF_FREE (B_TABLE(this)); - } - GF_FREE (private); - return; -} - - -struct xlator_fops fops = { - .lookup = bdb_lookup, - .stat = bdb_stat, - .opendir = bdb_opendir, - .readdir = bdb_readdir, - .readlink = bdb_readlink, - .mknod = bdb_mknod, - .mkdir = bdb_mkdir, - .unlink = bdb_unlink, - .rmdir = bdb_rmdir, - .symlink = bdb_symlink, - .rename = bdb_rename, - .link = bdb_link, - .truncate = bdb_truncate, - .create = bdb_create, - .open = bdb_open, - .readv = bdb_readv, - .writev = bdb_writev, - .statfs = bdb_statfs, - .flush = bdb_flush, - .fsync = bdb_fsync, - .setxattr = bdb_setxattr, - .getxattr = bdb_getxattr, - .removexattr = bdb_removexattr, - .fsyncdir = bdb_fsyncdir, - .access = bdb_access, - .ftruncate = bdb_ftruncate, - .fstat = bdb_fstat, - .lk = bdb_lk, - .inodelk = bdb_inodelk, - .finodelk = bdb_finodelk, - .entrylk = bdb_entrylk, - .fentrylk = bdb_fentrylk, - .setdents = bdb_setdents, - .getdents = bdb_getdents, - .checksum = bdb_checksum, - .setattr = bdb_setattr, - .fsetattr = bdb_fsetattr, -}; - -struct xlator_cbks cbks = { - .release = bdb_release, - .releasedir = bdb_releasedir -}; - - -struct volume_options options[] = { - { .key = { "directory" }, - .type = GF_OPTION_TYPE_PATH, - .description = "export directory" - }, - { .key = { "logdir" }, - .type = GF_OPTION_TYPE_PATH, - .description = "directory to be used by libdb for writing" - "transaction logs. NOTE: in absence of 'logdir' " - "export directory itself will be used as 'logdir' also" - }, - { .key = { "errfile" }, - .type = GF_OPTION_TYPE_PATH, - .description = "path to be used for libdb error logging. " - "NOTE: absence of 'errfile' will disable any " - "error logging by libdb." - }, - { .key = { "dir-mode" }, - .type = GF_OPTION_TYPE_ANY /* base 8 number */ - }, - { .key = { "file-mode" }, - .type = GF_OPTION_TYPE_ANY, - .description = "file mode for regular files. stat() on a regular file" - " returns the mode specified by this option. " - "NOTE: specify value in octal" - }, - { .key = { "page-size" }, - .type = GF_OPTION_TYPE_SIZET, - .min = 512, - .max = 16384, - .description = "size of pages used to hold data by libdb. set it to " - "block size of exported filesystem for " - "optimal performance" - }, - { .key = { "open-db-lru-limit" }, - .type = GF_OPTION_TYPE_INT, - .min = 1, - .max = 2048, - .description = "maximum number of per directory databases that can " - "be kept open. NOTE: for _advanced_ users only." - }, - { .key = { "lock-timeout" }, - .type = GF_OPTION_TYPE_TIME, - .min = 0, - .max = 4260000, - .description = "define the maximum time a lock request can " - "be blocked by libdb. NOTE: only for _advanced_ users." - " do not specify this option when not sure." - }, - { .key = { "checkpoint-interval" }, - .type = GF_OPTION_TYPE_TIME, - .min = 1, - .max = 86400, - .description = "define the time interval between two consecutive " - "libdb checpoints. setting to lower value will leave " - "bdb perform slowly, but guarantees that minimum data" - " will be lost in case of a crash. NOTE: this option " - "is valid only when " - "'option mode=\"persistent\"' is set." - }, - { .key = { "transaction-timeout" }, - .type = GF_OPTION_TYPE_TIME, - .min = 0, - .max = 4260000, - .description = "maximum time for which a transaction can block " - "waiting for required resources." - }, - { .key = { "mode" }, - .type = GF_OPTION_TYPE_BOOL, - .value = { "cache", "persistent" }, - .description = "cache: data recovery is not guaranteed in case " - "of crash. persistent: data recovery is guaranteed, " - "since all operations are transaction protected." - }, - { .key = { "access-mode" }, - .type = GF_OPTION_TYPE_STR, - .value = {"btree", "hash" }, - .description = "chose the db access method. " - "NOTE: for _advanced_ users. leave the choice to " - "glusterfs when in doubt." - }, - { .key = { NULL } } -}; |