{
if (cfs_time_after(cfs_time_current(),
cfs_time_add(now, cfs_time_seconds(15))))
- CERROR("slow %s %lu sec\n", msg,
+ CERROR("slow %s "CFS_TIME_T" sec\n", msg,
cfs_duration_sec(cfs_time_sub(cfs_time_current(),now)));
}
#endif
#include <stdarg.h>
-#include <libcfs/linux/linux-mem.h>
#include <libcfs/linux/linux-time.h>
+#include <libcfs/linux/linux-mem.h>
#include <libcfs/linux/linux-prim.h>
#include <libcfs/linux/linux-lock.h>
#include <libcfs/linux/linux-fs.h>
typedef struct file cfs_file_t;
typedef struct dentry cfs_dentry_t;
+typedef struct dirent64 cfs_dirent_t;
#ifdef __KERNEL__
#define cfs_filp_size(f) (i_size_read((f)->f_dentry->d_inode))
/*
* Liblustre. time(2) based implementation.
*/
+
+#define CFS_TIME_T "%lu"
+
#include <libcfs/user-time.h>
+
#endif /* __KERNEL__ */
/* __LIBCFS_LINUX_LINUX_TIME_H__ */
#include <pthread.h>
#endif
-#ifndef PAGE_SIZE
-
-#define PAGE_SIZE (getpagesize())
-static __inline__ int getpageshift()
-{
- int pagesize = getpagesize();
-#if (__GNUC__ >= 4) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))
- /* unsigned int is 32 bits on all our architectures */
- return (__builtin_clz(pagesize) ^ 31);
-#else
- register int pageshift = -1;
- while (pagesize) { pagesize >>= 1; pageshift++; }
- return pageshift;
-#endif
-}
-
-#undef PAGE_MASK
-#define PAGE_MASK (~(PAGE_SIZE-1))
-#undef PAGE_SHIFT
-#define PAGE_SHIFT (getpageshift())
-
-#endif
/*
* Wait Queue. No-op implementation.
typedef struct page cfs_page_t;
+#ifndef PAGE_SIZE
+
+/* 4K */
+#define CFS_PAGE_SHIFT 12
+#define CFS_PAGE_SIZE (1UL << CFS_PAGE_SHIFT)
+#define CFS_PAGE_MASK (~((__u64)CFS_PAGE_SIZE-1))
+
+#else
+
#define CFS_PAGE_SIZE PAGE_SIZE
#define CFS_PAGE_SHIFT PAGE_SHIFT
#define CFS_PAGE_MASK (~((__u64)CFS_PAGE_SIZE-1))
+#endif
+
cfs_page_t *cfs_alloc_page(unsigned int flags);
void cfs_free_page(cfs_page_t *pg);
void *cfs_page_address(cfs_page_t *pg);
#define cfs_time_before_64 cfs_time_before
#define cfs_time_beforeq_64 cfs_time_beforeq
-#define CFS_TIME_T "%lu"
+#ifndef CFS_TIME_T
+#define CFS_TIME_T "%u"
+#endif
+
#define CFS_DURATION_T "%ld"
/* !__KERNEL__ */
if (debug_file_name[0] == '\0' && debug_file_path[0] != '\0')
snprintf(debug_file_name, sizeof(debug_file_name) - 1,
- "%s-%s-%lu.log", debug_file_path, source_nid, time(0));
+ "%s-%s-"CFS_TIME_T".log", debug_file_path, source_nid, time(0));
if (strcmp(debug_file_name, "stdout") == 0 ||
strcmp(debug_file_name, "-") == 0) {
int nob;
int remain;
va_list ap;
- char buf[PAGE_SIZE]; /* size 4096 used for compatimble with linux,
- * where message can`t be exceed PAGE_SIZE */
+ char buf[CFS_PAGE_SIZE]; /* size 4096 used for compatimble
+ * with linux, where message can`t
+ * be exceed PAGE_SIZE */
int console = 0;
char *prefix = "Lustre";
gettimeofday(&tv, NULL);
- fprintf(debug_file_fd, "%lu.%06lu:%u:%s:(%s:%d:%s()): %s",
+ fprintf(debug_file_fd, CFS_TIME_T".%06lu:%u:%s:(%s:%d:%s()): %s",
tv.tv_sec, tv.tv_usec, source_pid, source_nid,
file, line, fn, buf);
#ifndef __KERNEL__
+#include <libcfs/libcfs.h>
+#include <libcfs/kp30.h>
+
#include <sys/mman.h>
#ifndef __CYGWIN__
#include <stdint.h>
#include <signal.h>
#include <errno.h>
#include <sys/stat.h>
+#ifdef HAVE_SYS_VFS_H
#include <sys/vfs.h>
-
-#include <libcfs/libcfs.h>
-#include <libcfs/kp30.h>
+#endif
/*
* Sleep channel. No-op implementation.
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-#ifndef __KERNEL__
-#ifndef REDSTORM
+#if !defined(__KERNEL__) || !defined(REDSTORM)
+
+#include <libcfs/libcfs.h>
+#include <libcfs/kp30.h>
+
#include <sys/socket.h>
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
#include <netinet/tcp.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <sys/syscall.h>
#endif
-#include <libcfs/libcfs.h>
-#include <libcfs/kp30.h>
-
/*
* Functions to get network interfaces info
*/
libcfs_sock_ioctl(int cmd, unsigned long arg)
{
int fd, rc;
-
- fd = socket(AF_INET, SOCK_STREAM, 0);
+
+ fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0) {
rc = -errno;
return rc;
}
-#endif /* !defined(REDSTORM) */
-#endif /* !__KERNEL__ */
+#endif /* !__KERNEL__ || !defined(REDSTORM) */
#define LNET_ONLY
#ifndef __KERNEL__
+/* XXX workaround XXX */
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
#include <liblustre.h> /* userland spinlock_t and atomic_t */
#endif
#include <libcfs/kp30.h>
#include <sys/types.h>
#include <sys/socket.h>
-#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/utsname.h>
if (argc > 1 && raw)
strcpy(filename, argv[1]);
else
- sprintf(filename, "/tmp/lustre-log.%lu.%u",time(NULL),getpid());
+ sprintf(filename, "/tmp/lustre-log."CFS_TIME_T".%u",
+ time(NULL),getpid());
if (stat(filename, &st) == 0 && S_ISREG(st.st_mode))
unlink(filename);
* RHEL 4 and RHEL 5/SLES 10 clients behaves differently on 'cd' to a
removed cwd "./" (refer to Bugzilla 14399).
+Severity : enhancement
+Bugzilla : 14929
+Description: using special macro for print time and cleanup in includes.
+
Severity : normal
Bugzilla : 12888
Description: mds_mfd_close() ASSERTION(rc == 0)
ENTRY;
spin_lock_init(&m->cmm_tgt_guard);
- INIT_LIST_HEAD(&m->cmm_targets);
+ CFS_INIT_LIST_HEAD(&m->cmm_targets);
m->cmm_tgt_count = 0;
m->cmm_child = lu2md_dev(next);
#define __LINUX_SPINLOCK_H
#endif
+#include <libcfs/list.h>
+#include <lnet/lnet.h>
+#include <libcfs/kp30.h>
+#include <libcfs/user-bitops.h>
+
#include <sys/mman.h>
#ifdef HAVE_STDINT_H
# include <stdint.h>
#ifdef __CYGWIN__
-#define CFS_PAGE_SHIFT 12
-#define CFS_PAGE_SIZE (1UL << CFS_PAGE_SHIFT)
-#define CFS_PAGE_MASK (~((__u64)CFS_PAGE_SIZE-1))
#define loff_t long long
#define ERESTART 2001
typedef unsigned short umode_t;
typedef int (write_proc_t)(struct file *file, const char *buffer,
unsigned long count, void *data);
-#define NIPQUAD(addr) \
- ((unsigned char *)&addr)[0], \
- ((unsigned char *)&addr)[1], \
- ((unsigned char *)&addr)[2], \
- ((unsigned char *)&addr)[3]
-
-#if defined(__LITTLE_ENDIAN)
-#define HIPQUAD(addr) \
- ((unsigned char *)&addr)[3], \
- ((unsigned char *)&addr)[2], \
- ((unsigned char *)&addr)[1], \
- ((unsigned char *)&addr)[0]
-#elif defined(__BIG_ENDIAN)
-#define HIPQUAD NIPQUAD
-#else
-#error "Undefined byteorder??"
-#endif /* __LITTLE_ENDIAN */
-
/* bits ops */
/* a long can be more than 32 bits, so use BITS_PER_LONG
#define LLOG_LVFS
-/* lvfs.c */
-int obd_alloc_fail(const void *ptr, const char *name, const char *type,
- size_t size, const char *file, int line);
-
/* simple.c */
struct lvfs_ucred {
#include <libcfs/kp30.h>
-#if defined(__linux__)
-#include <linux/lustre_types.h>
-#elif defined(__APPLE__)
-#include <darwin/lustre_types.h>
-#elif defined(__WINNT__)
-#include <winnt/lustre_types.h>
-#else
-#error Unsupported operating system.
-#endif
+#include <lustre/types.h>
/* Defn's shared with user-space. */
#include <lustre/lustre_user.h>
int __obd_fail_check_set(__u32 id, __u32 value, int set);
+/* lvfs.c */
+int obd_alloc_fail(const void *ptr, const char *name, const char *type,
+ size_t size, const char *file, int line);
+
/* Timeout definitions */
#define LDLM_TIMEOUT_DEFAULT 20
#define OBD_TIMEOUT_DEFAULT 100
ldlm_error_t *err, struct list_head *work_list)
{
struct ldlm_resource *res = lock->l_resource;
- struct list_head rpc_list = CFS_LIST_HEAD_INIT(rpc_list);
+ CFS_LIST_HEAD(rpc_list);
int rc, rc2;
int contended_locks = 0;
ENTRY;
#define l_flock_waitq l_lru
-static struct list_head ldlm_flock_waitq = CFS_LIST_HEAD_INIT(ldlm_flock_waitq);
+static CFS_LIST_HEAD(ldlm_flock_waitq);
int ldlm_flock_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
void *data, int flag);
* but only once because first_enq will be false from
* ldlm_reprocess_queue. */
if ((mode == LCK_NL) && overlaps) {
- struct list_head rpc_list
- = CFS_LIST_HEAD_INIT(rpc_list);
+ CFS_LIST_HEAD(rpc_list);
int rc;
restart:
ldlm_reprocess_queue(res, &res->lr_waiting,
struct list_head *work_list)
{
struct ldlm_resource *res = lock->l_resource;
- struct list_head rpc_list = CFS_LIST_HEAD_INIT(rpc_list);
+ CFS_LIST_HEAD(rpc_list);
int rc;
ENTRY;
t = cfs_timer_deadline(&target->obd_recovery_timer);
t = cfs_time_sub(t, cfs_time_current());
CERROR("%s: denying connection for new client %s (%s): "
- "%d clients in recovery for %lds\n",
+ "%d clients in recovery for "CFS_TIME_T"s\n",
target->obd_name,
libcfs_nid2str(req->rq_peer.nid), cluuid.uuid,
target->obd_recoverable_clients,
//data->ocd_connect_flags &= OBD_CONNECT_SUPPORTED;
*tmpdata = *data;
}
-
+
/* If all else goes well, this is our RPC return code. */
req->rq_status = 0;
&lock->l_enqueued_time, NULL);
if (total_enqueue_wait / 1000000 > obd_timeout)
- LDLM_ERROR(lock, "enqueue wait took %luus from %lu",
+ LDLM_ERROR(lock, "enqueue wait took %luus from "CFS_TIME_T,
total_enqueue_wait, lock->l_enqueued_time.tv_sec);
req = ptlrpc_request_alloc(lock->l_export->exp_imp_reverse,
ldlm_error_t *err, struct list_head *work_list)
{
struct ldlm_resource *res = lock->l_resource;
- struct list_head rpc_list = CFS_LIST_HEAD_INIT(rpc_list);
+ CFS_LIST_HEAD(rpc_list);
int rc;
ENTRY;
if (ptlrpc_check_suspend())
RETURN(0);
- LDLM_ERROR(lock, "lock timed out (enqueued at %lu, %lus ago); "
- "not entering recovery in server code, just going "
- "back to sleep", lock->l_enqueued_time.tv_sec,
+ LDLM_ERROR(lock, "lock timed out (enqueued at "CFS_TIME_T", "
+ CFS_DURATION_T"s ago); not entering recovery in "
+ "server code, just going back to sleep",
+ lock->l_enqueued_time.tv_sec,
cfs_time_current_sec() - lock->l_enqueued_time.tv_sec);
if (cfs_time_after(cfs_time_current(), next_dump)) {
last_dump = next_dump;
obd = lock->l_conn_export->exp_obd;
imp = obd->u.cli.cl_import;
ptlrpc_fail_import(imp, lwd->lwd_conn_cnt);
- LDLM_ERROR(lock, "lock timed out (enqueued at %lu, %lus ago), entering "
- "recovery for %s@%s", lock->l_enqueued_time.tv_sec,
- cfs_time_current_sec() - lock->l_enqueued_time.tv_sec,
- obd2cli_tgt(obd), imp->imp_connection->c_remote_uuid.uuid);
+ LDLM_ERROR(lock, "lock timed out (enqueued at "CFS_TIME_T", "
+ CFS_DURATION_T"s ago), entering recovery for %s@%s",
+ lock->l_enqueued_time.tv_sec,
+ cfs_time_current_sec() - lock->l_enqueued_time.tv_sec,
+ obd2cli_tgt(obd), imp->imp_connection->c_remote_uuid.uuid);
RETURN(0);
}
int ldlm_replay_locks(struct obd_import *imp)
{
struct ldlm_namespace *ns = imp->imp_obd->obd_namespace;
- struct list_head list;
+ CFS_LIST_HEAD(list);
struct ldlm_lock *lock, *next;
int rc = 0;
ENTRY;
- CFS_INIT_LIST_HEAD(&list);
LASSERT(atomic_read(&imp->imp_replay_inflight) == 0);
atomic_t ldlm_cli_namespace_nr = ATOMIC_INIT(0);
struct semaphore ldlm_srv_namespace_lock;
-struct list_head ldlm_srv_namespace_list =
- CFS_LIST_HEAD_INIT(ldlm_srv_namespace_list);
+CFS_LIST_HEAD(ldlm_srv_namespace_list);
struct semaphore ldlm_cli_namespace_lock;
-struct list_head ldlm_cli_namespace_list =
- CFS_LIST_HEAD_INIT(ldlm_cli_namespace_list);
+CFS_LIST_HEAD(ldlm_cli_namespace_list);
cfs_proc_dir_entry_t *ldlm_type_proc_dir = NULL;
cfs_proc_dir_entry_t *ldlm_ns_proc_dir = NULL;
const char *name, int namelen, loff_t offset,
ino_t ino, unsigned int d_type, int *filled)
{
- struct dirent64 *dirent = (struct dirent64 *) (buf + *filled);
+ cfs_dirent_t *dirent = (cfs_dirent_t *) (buf + *filled);
int reclen = ROUND_UP64(NAME_OFFSET(dirent) + namelen + 1);
/* check overflow */
return 1;
dirent->d_ino = ino;
+#ifdef _DIRENT_HAVE_D_OFF
dirent->d_off = offset;
+#endif
dirent->d_reclen = reclen;
-#ifndef _AIX
+#ifdef _DIRENT_HAVE_D_TYPE
dirent->d_type = (unsigned short) d_type;
#endif
memcpy(dirent->d_name, name, namelen);
valid &= src->o_valid;
if (valid & (OBD_MD_FLCTIME | OBD_MD_FLMTIME))
- CDEBUG(D_INODE,"valid "LPX64", cur time %lu/%lu, new %lu/%lu\n",
+ CDEBUG(D_INODE,"valid "LPX64", cur time "CFS_TIME_T"/"CFS_TIME_T
+ ", new %lu/%lu\n",
src->o_valid, LTIME_S(st->st_mtime),
LTIME_S(st->st_ctime),
(long)src->o_mtime, (long)src->o_ctime);
valid &= src->o_valid;
if (valid & (OBD_MD_FLCTIME | OBD_MD_FLMTIME))
- CDEBUG(D_INODE,"valid "LPX64", cur time %lu/%lu, new %lu/%lu\n",
+ CDEBUG(D_INODE,"valid "LPX64", cur time "CFS_TIME_T"/"CFS_TIME_T
+ ", new %lu/%lu\n",
src->o_valid,
LTIME_S(st->st_mtime), LTIME_S(st->st_ctime),
(long)src->o_mtime, (long)src->o_ctime);
obd_flag newvalid = 0;
if (valid & (OBD_MD_FLCTIME | OBD_MD_FLMTIME))
- CDEBUG(D_INODE, "valid %x, new time %lu/%lu\n",
+ CDEBUG(D_INODE, "valid %x, new time "CFS_TIME_T"/"CFS_TIME_T"\n",
valid, LTIME_S(st->st_mtime),
LTIME_S(st->st_ctime));
}
if (attr->ia_valid & (ATTR_MTIME | ATTR_CTIME))
- CDEBUG(D_INODE, "setting mtime %lu, ctime %lu, now = %lu\n",
+ CDEBUG(D_INODE, "setting mtime "CFS_TIME_T", ctime "CFS_TIME_T
+ ", now = "CFS_TIME_T"\n",
LTIME_S(attr->ia_mtime), LTIME_S(attr->ia_ctime),
LTIME_S(CURRENT_TIME));
struct obd_info oinfo = { { { 0 } } };
struct obdo oa;
- CDEBUG(D_INODE, "set mtime on OST inode %llu to %lu\n",
+ CDEBUG(D_INODE, "set mtime on OST inode %llu to "CFS_TIME_T"\n",
(long long)st->st_ino, LTIME_S(attr->ia_mtime));
oa.o_id = lsm->lsm_object_id;
oa.o_gr = lsm->lsm_object_gr;
char buf[1024];
const int nfiles = 256;
char *prefix = "test14_filename_long_prefix_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA___";
- struct dirent64 *ent;
+ cfs_dirent_t *ent;
int fd, i, rc, pos, index;
loff_t base = 0;
ENTER(">1 block(4k) directory readdir");
while (pos < rc) {
char *item;
- ent = (struct dirent64 *) ((char*) buf + pos);
+ ent = (void *) buf + pos;
item = (char *) ent->d_name;
if (!strcmp(item, ".") || !strcmp(item, ".."))
goto iter;
{
char path[MAX_PATH_LENGTH];
int fd;
- long long ret;
- long long off;
+ off_t ret;
+ off_t off;
ENTER("handle seek > 2GB");
snprintf(path, MAX_PATH_LENGTH, "%s/f%s", lustre_path, name);
size_t nbytes;
off_t basep = 0;
ssize_t rc = 0;
- struct dirent dir;
+ cfs_dirent_t dir;
ENTER("getdirentries should fail if nbytes is too small");
#include <utime.h>
#include <stdarg.h>
+#include <liblustre.h>
+
#include "test_common.h"
int exit_on_err = 1;
void t_ls(int fd, char *buf, int size)
{
- struct dirent64 *ent;
+ cfs_dirent_t *ent;
int rc, pos;
loff_t base = 0;
while ((rc = getdirentries64(fd, buf, size, &base)) > 0) {
pos = 0;
while (pos < rc) {
- ent = (struct dirent64 *) ((char*) buf + pos);
+ ent = (cfs_dirent_t *) ((char*) buf + pos);
printf("%s\n", ent->d_name);
pos += ent->d_reclen;
}
obd_off *lov_off, unsigned long *swidth)
{
if (swidth)
- *swidth = (ulong)lsm->lsm_stripe_size * lsm->lsm_stripe_count;
+ *swidth = (unsigned long)lsm->lsm_stripe_size * lsm->lsm_stripe_count;
}
static void
obd_off *lov_off, unsigned long *swidth)
{
if (swidth)
- *swidth = (ulong)lsm->lsm_stripe_size * lsm->lsm_stripe_count;
+ *swidth = (unsigned long)lsm->lsm_stripe_size * lsm->lsm_stripe_count;
}
static obd_off
*stripeno -= le->le_loi_idx;
if (swidth)
- *swidth = (ulong)lsm->lsm_stripe_size * le->le_stripe_count;
+ *swidth = (unsigned long)lsm->lsm_stripe_size * le->le_stripe_count;
if (lov_off) {
struct lov_extent *lov_le = lovea_off2le(lsm, *lov_off);
*stripeno -= le->le_loi_idx;
if (swidth)
- *swidth = (ulong)lsm->lsm_stripe_size * le->le_stripe_count;
+ *swidth = (unsigned long)lsm->lsm_stripe_size * le->le_stripe_count;
}
static obd_off
#include <libcfs/kp30.h>
#include <lustre_fsfilt.h>
-LIST_HEAD(fsfilt_types);
+CFS_LIST_HEAD(fsfilt_types);
static struct fsfilt_operations *fsfilt_search_type(const char *type)
{
}
if (op_data->op_attr.ia_valid & (ATTR_MTIME | ATTR_CTIME))
- CDEBUG(D_INODE, "setting mtime %lu, ctime %lu\n",
+ CDEBUG(D_INODE, "setting mtime "CFS_TIME_T
+ ", ctime "CFS_TIME_T"\n",
LTIME_S(op_data->op_attr.ia_mtime),
LTIME_S(op_data->op_attr.ia_ctime));
mdc_setattr_pack(req, op_data, ea, ealen, ea2, ea2len);
mdd->mdd_txn_cb.dtc_txn_stop = mdd_txn_stop_cb;
mdd->mdd_txn_cb.dtc_txn_commit = mdd_txn_commit_cb;
mdd->mdd_txn_cb.dtc_cookie = mdd;
- INIT_LIST_HEAD(&mdd->mdd_txn_cb.dtc_linkage);
+ CFS_INIT_LIST_HEAD(&mdd->mdd_txn_cb.dtc_linkage);
mdd->mdd_atime_diff = MAX_ATIME_DIFF;
rc = mdd_procfs_init(mdd, name);
{
struct mds_export_data *med = &exp->exp_mds_data;
- INIT_LIST_HEAD(&med->med_open_head);
+ CFS_INIT_LIST_HEAD(&med->med_open_head);
spin_lock_init(&med->med_open_lock);
spin_lock(&exp->exp_lock);
atomic_set(&mfd->mfd_refcount, 2);
- INIT_LIST_HEAD(&mfd->mfd_handle.h_link);
- INIT_LIST_HEAD(&mfd->mfd_list);
+ CFS_INIT_LIST_HEAD(&mfd->mfd_handle.h_link);
+ CFS_INIT_LIST_HEAD(&mfd->mfd_list);
class_handle_hash(&mfd->mfd_handle, mds_mfd_addref);
return mfd;
struct mds_obd *mds = mds_req2mds(req);
struct obd_device *obd = req->rq_export->exp_obd;
struct mds_file_data *mfd = NULL;
- struct lov_mds_md *lmm; /* object IDs created */
+ struct lov_mds_md *lmm = NULL; /* object IDs created */
int rc = 0;
ENTRY;
if (IS_ERR(file))
GOTO(err_pop, rc = PTR_ERR(file));
- INIT_LIST_HEAD(&dentry_list);
+ CFS_INIT_LIST_HEAD(&dentry_list);
rc = l_readdir(file, &dentry_list);
filp_close(file, 0);
if (rc < 0)
struct mdt_export_data *med = &exp->exp_mdt_data;
ENTRY;
- INIT_LIST_HEAD(&med->med_open_head);
+ CFS_INIT_LIST_HEAD(&med->med_open_head);
spin_lock_init(&med->med_open_lock);
sema_init(&med->med_idmap_sem, 1);
med->med_idmap = NULL;
OBD_ALLOC_PTR(mfd);
if (mfd != NULL) {
- INIT_LIST_HEAD(&mfd->mfd_handle.h_link);
- INIT_LIST_HEAD(&mfd->mfd_list);
+ CFS_INIT_LIST_HEAD(&mfd->mfd_handle.h_link);
+ CFS_INIT_LIST_HEAD(&mfd->mfd_list);
class_handle_hash(&mfd->mfd_handle, mdt_mfd_get);
}
RETURN(mfd);
mdt->mdt_txn_cb.dtc_txn_stop = mdt_txn_stop_cb;
mdt->mdt_txn_cb.dtc_txn_commit = mdt_txn_commit_cb;
mdt->mdt_txn_cb.dtc_cookie = mdt;
- INIT_LIST_HEAD(&mdt->mdt_txn_cb.dtc_linkage);
+ CFS_INIT_LIST_HEAD(&mdt->mdt_txn_cb.dtc_linkage);
dt_txn_callback_add(mdt->mdt_bottom, &mdt->mdt_txn_cb);
/* dentry_open_it() drops the dentry, mnt refs */
GOTO(out_pop, rc = PTR_ERR(file));
- INIT_LIST_HEAD(dentry_list);
+ CFS_INIT_LIST_HEAD(dentry_list);
rc = l_readdir(file, dentry_list);
filp_close(file, 0);
/* filp_close->fput() drops the dentry, mnt refs */
int mgs_init_fsdb_list(struct obd_device *obd)
{
struct mgs_obd *mgs = &obd->u.mgs;
- INIT_LIST_HEAD(&mgs->mgs_fs_db_list);
+ CFS_INIT_LIST_HEAD(&mgs->mgs_fs_db_list);
return 0;
}
ret = -EINVAL;
}
if ((u64val & ~CFS_PAGE_MASK) >= CFS_PAGE_SIZE) {
- CWARN("mask failed: u64val "LPU64" >= %lu\n", u64val,
- CFS_PAGE_SIZE);
+ CWARN("mask failed: u64val "LPU64" >= "LPU64"\n", u64val,
+ (__u64)CFS_PAGE_SIZE);
ret = -EINVAL;
}
if (e == NULL)
return NULL;
- INIT_LIST_HEAD(&e->lie_rmt_uid_hash);
- INIT_LIST_HEAD(&e->lie_lcl_uid_hash);
- INIT_LIST_HEAD(&e->lie_rmt_gid_hash);
- INIT_LIST_HEAD(&e->lie_lcl_gid_hash);
+ CFS_INIT_LIST_HEAD(&e->lie_rmt_uid_hash);
+ CFS_INIT_LIST_HEAD(&e->lie_lcl_uid_hash);
+ CFS_INIT_LIST_HEAD(&e->lie_rmt_gid_hash);
+ CFS_INIT_LIST_HEAD(&e->lie_lcl_gid_hash);
e->lie_rmt_uid = rmt_uid;
e->lie_lcl_uid = lcl_uid;
e->lie_rmt_gid = rmt_gid;
* necessary, because lu_object_header is freed together with the
* top-level slice.
*/
- INIT_LIST_HEAD(&splice);
+ CFS_INIT_LIST_HEAD(&splice);
list_splice_init(&o->lo_header->loh_layers, &splice);
while (!list_empty(&splice)) {
o = container_of0(splice.next, struct lu_object, lo_linkage);
struct lu_object_header *h;
struct lu_object_header *temp;
- INIT_LIST_HEAD(&dispose);
+ CFS_INIT_LIST_HEAD(&dispose);
/*
* Under LRU list lock, scan LRU list and move unreferenced objects to
* the dispose list, removing them from LRU and hash table.
/*
* Global list of all sites on this node
*/
-static LIST_HEAD(lu_sites);
+static CFS_LIST_HEAD(lu_sites);
static DECLARE_MUTEX(lu_sites_guard);
/*
struct lu_site *tmp;
int cached = 0;
int remain = nr;
- LIST_HEAD(splice);
+ CFS_LIST_HEAD(splice);
if (nr != 0 && !(gfp_mask & __GFP_FS))
return -1;
/* Delete the nids for one uuid if specified, otherwise delete all */
int class_del_uuid(const char *uuid)
{
- struct list_head deathrow;
+ CFS_LIST_HEAD(deathrow);
struct uuid_nid_data *data;
int found = 0;
- CFS_INIT_LIST_HEAD (&deathrow);
-
spin_lock (&g_uuid_lock);
if (uuid == NULL) {
list_splice_init(&g_uuid_list, &deathrow);
{
spin_lock_init(&exp->exp_filter_data.fed_lock);
CFS_INIT_LIST_HEAD(&exp->exp_filter_data.fed_mod_list);
-
+
spin_lock(&exp->exp_lock);
exp->exp_connecting = 1;
spin_unlock(&exp->exp_lock);
struct ldlm_lock **lockp, void *req_cookie,
ldlm_mode_t mode, int flags, void *data)
{
- struct list_head rpc_list = CFS_LIST_HEAD_INIT(rpc_list);
+ CFS_LIST_HEAD(rpc_list);
struct ptlrpc_request *req = req_cookie;
struct ldlm_lock *lock = *lockp, *l = NULL;
struct ldlm_resource *res = lock->l_resource;
OBD_ALLOC_PTR(k);
if (!k)
RETURN(-ENOMEM);
- INIT_LIST_HEAD(&k->k_list);
+ CFS_INIT_LIST_HEAD(&k->k_list);
}
spin_lock(&capa_lock);
int rc = 0;
ENTRY;
- DEBUG_REQ(D_ERROR|D_NETERROR, req, "%s (sent at %lu, %lus ago)",
+ DEBUG_REQ(D_ERROR|D_NETERROR, req, "%s (sent at %lu, "CFS_DURATION_T"s ago)",
req->rq_net_err ? "network error" : "timeout",
(long)req->rq_sent, cfs_time_current_sec() - req->rq_sent);
#include "ptlrpc_internal.h"
struct semaphore pinger_sem;
-static struct list_head pinger_imports = CFS_LIST_HEAD_INIT(pinger_imports);
+static CFS_LIST_HEAD(pinger_imports);
int ptlrpc_ping(struct obd_import *imp)
{
if (exp->exp_flvr_expire[0] >= cfs_time_current_sec()) {
if (flavor_allowed(&exp->exp_flvr_old[0], req)) {
CDEBUG(D_SEC, "exp %p (%x|%x|%x): match the "
- "middle one (%lu)\n", exp,
+ "middle one ("CFS_DURATION_T")\n", exp,
exp->exp_flvr.sf_rpc,
exp->exp_flvr_old[0].sf_rpc,
exp->exp_flvr_old[1].sf_rpc,
if (exp->exp_flvr_expire[1] >= cfs_time_current_sec()) {
if (flavor_allowed(&exp->exp_flvr_old[1], req)) {
CDEBUG(D_SEC, "exp %p (%x|%x|%x): match the "
- "oldest one (%lu)\n", exp,
+ "oldest one ("CFS_DURATION_T")\n", exp,
exp->exp_flvr.sf_rpc,
exp->exp_flvr_old[0].sf_rpc,
exp->exp_flvr_old[1].sf_rpc,
/* forward ref */
static int ptlrpc_server_post_idle_rqbds (struct ptlrpc_service *svc);
-static CFS_LIST_HEAD (ptlrpc_all_services);
+static CFS_LIST_HEAD(ptlrpc_all_services);
spinlock_t ptlrpc_all_services_lock;
static char *
exp->exp_last_request_time = max(exp->exp_last_request_time,
cfs_time_current_sec() + extra_delay);
- CDEBUG(D_HA, "updating export %s at %ld exp %p\n",
+ CDEBUG(D_HA, "updating export %s at "CFS_TIME_T" exp %p\n",
exp->exp_client_uuid.uuid,
exp->exp_last_request_time, exp);
* we better wait for 3. */
exp->exp_obd->obd_eviction_timer = cfs_time_current_sec() +
3 * PING_INTERVAL;
- CDEBUG(D_HA, "%s: Think about evicting %s from %ld\n",
+ CDEBUG(D_HA, "%s: Think about evicting %s from "CFS_TIME_T"\n",
exp->exp_obd->obd_name, obd_export_nid2str(exp),
oldest_time);
}
#endif
#include <libcfs/libcfs.h>
-
+#include <liblustre.h>
#include <lustre/libiam.h>
typedef __u32 lvar_hash_t;
}
typedef int (semantic_func_t)(char *path, DIR *parent, DIR *d,
- void *data, struct dirent64 *de);
+ void *data, cfs_dirent_t *de);
#define MAX_LOV_UUID_COUNT max(LOV_MAX_STRIPE_COUNT, 1000)
#define OBD_NOT_FOUND (-1)
static int llapi_semantic_traverse(char *path, int size, DIR *parent,
semantic_func_t sem_init,
semantic_func_t sem_fini, void *data,
- struct dirent64 *de)
+ cfs_dirent_t *de)
{
- struct dirent64 *dent;
+ cfs_dirent_t *dent;
int len, ret;
DIR *d, *p = NULL;
}
static int cb_find_init(char *path, DIR *parent, DIR *dir,
- void *data, struct dirent64 *de)
+ void *data, cfs_dirent_t *de)
{
struct find_param *param = (struct find_param *)data;
int decision = 1; /* 1 is accepted; -1 is rejected. */
}
static int cb_common_fini(char *path, DIR *parent, DIR *d, void *data,
- struct dirent64 *de)
+ cfs_dirent_t *de)
{
struct find_param *param = (struct find_param *)data;
param->depth--;
}
static int cb_getstripe(char *path, DIR *parent, DIR *d, void *data,
- struct dirent64 *de)
+ cfs_dirent_t *de)
{
struct find_param *param = (struct find_param *)data;
int ret = 0;
}
static int cb_quotachown(char *path, DIR *parent, DIR *d, void *data,
- struct dirent64 *de)
+ cfs_dirent_t *de)
{
struct find_param *param = (struct find_param *)data;
lstat_t *st;
*/
#include <sys/types.h>
+#if defined (__linux__)
#include <sys/vfs.h>
+#endif
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>
*/
#include <sys/types.h>
+#if defined (__linux__)
#include <sys/vfs.h>
+#endif
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>
if ((ret_val = read_string(file_path, file_data,sizeof(file_data))) == SUCCESS) {
tmp = atoll(file_data) * factor;
- c64->low = (ulong) (0x0FFFFFFFF & tmp);
+ c64->low = (unsigned long) (0x0FFFFFFFF & tmp);
tmp >>= 32; /* Shift right by 4 bytes */
- c64->high = (ulong) (0x0FFFFFFFF & tmp);
+ c64->high = (unsigned long) (0x0FFFFFFFF & tmp);
}
return ret_val;
}
git://git.whamcloud.com / fs / lustre-release.git / commitdiff