#define module_put __MOD_DEC_USE_COUNT
#define LTIME_S(time) (time)
#if !defined(CONFIG_RH_2_4_20) && !defined(cpu_online)
-#define cpu_online(cpu) (cpu_online_map & (1<<cpu))
+#define cpu_online(cpu) test_bit(cpu, &(cpu_online_map))
#endif
static inline int ll_path_lookup(const char *path, unsigned flags,
rq_no_resend:1, rq_waiting:1, rq_receiving_reply:1,
rq_no_delay:1, rq_net_err:1;
int rq_phase;
- /* client-side refcount for SENT race */
- atomic_t rq_refcount;
+ atomic_t rq_refcount; /* client-side refcount for SENT race */
- int rq_request_portal; /* XXX FIXME bug 249 */
- int rq_reply_portal; /* XXX FIXME bug 249 */
+ int rq_request_portal; /* XXX FIXME bug 249 */
+ int rq_reply_portal; /* XXX FIXME bug 249 */
- /* client-side # reply bytes actually received */
- int rq_nob_received;
+ int rq_nob_received; /* client-side # reply bytes actually received */
int rq_reqlen;
struct lustre_msg *rq_reqmsg;
struct ptlrpc_cb_id rq_req_cbid;
/* server-side... */
- struct timeval rq_arrival_time; /* request arrival time */
- struct ptlrpc_reply_state *rq_reply_state; /* separated reply state */
- struct ptlrpc_request_buffer_desc *rq_rqbd; /* incoming request buffer */
-
+ struct timeval rq_arrival_time; /* request arrival time */
+ struct ptlrpc_reply_state *rq_reply_state; /* separated reply state */
+ struct ptlrpc_request_buffer_desc *rq_rqbd; /* incoming request buffer*/
+
/* client-only incoming reply */
ptl_handle_md_t rq_reply_md_h;
wait_queue_head_t rq_reply_waitq;
struct ptlrpc_cb_id rq_reply_cbid;
-
- struct ptlrpc_peer rq_peer; /* XXX see service.c can this be factored away? */
+
+ struct ptlrpc_peer rq_peer; /* XXX see service.c can this be removed? */
char rq_peerstr[PTL_NALFMT_SIZE];
struct obd_export *rq_export;
struct obd_import *rq_import;
-
+
void (*rq_replay_cb)(struct ptlrpc_request *);
void (*rq_commit_cb)(struct ptlrpc_request *);
void *rq_cb_data;
struct ptlrpc_request_set *rq_set;
void *rq_interpret_reply; /* Async completion handler */
union ptlrpc_async_args rq_async_args; /* Async completion context */
- void * rq_ptlrpcd_data;
+ void *rq_ptlrpcd_data;
};
struct mdc_rpc_lock *cl_rpc_lock;
struct mdc_rpc_lock *cl_setattr_lock;
- struct osc_creator cl_oscc;
+ struct osc_creator cl_oscc;
/* also protected by the poorly named _loi_list_lock lock above */
struct osc_async_rc cl_ar;
# define ll_lock_kernel
# endif
-
#ifdef HAVE_OLD_DEV_SET_RDONLY
- void dev_set_rdonly(ll_sbdev_type, int no_write);
+ void dev_set_rdonly(ll_sbdev_type dev, int no_write);
void dev_clear_rdonly(int no_write);
#else
- void dev_set_rdonly(ll_sbdev_type);
- void dev_clear_rdonly(ll_sbdev_type);
+ void dev_set_rdonly(ll_sbdev_type dev);
+ void dev_clear_rdonly(ll_sbdev_type dev);
#endif
-int dev_check_rdonly(ll_sbdev_type);
-#define ll_check_rdonly dev_check_rdonly
-
-static inline void ll_set_rdonly(ll_sbdev_type dev)
-{
- CDEBUG(D_IOCTL | D_HA, "set dev %ld rdonly\n", (long)dev);
- ll_sbdev_sync(dev);
-#ifdef HAVE_OLD_DEV_SET_RDONLY
- dev_set_rdonly(dev, 2);
-#else
- dev_set_rdonly(dev);
-#endif
-}
-
-static inline void ll_clear_rdonly(ll_sbdev_type dev)
-{
- CDEBUG(D_IOCTL | D_HA, "unset dev %ld rdonly\n", (long)dev);
- if (dev_check_rdonly(dev)) {
- ll_sbdev_sync(dev);
-#ifdef HAVE_OLD_DEV_SET_RDONLY
- dev_clear_rdonly(2);
-#else
- dev_clear_rdonly(dev);
-#endif
- }
-}
+int dev_check_rdonly(ll_sbdev_type dev);
+#define ll_check_rdonly(dev) dev_check_rdonly(dev)
+void ll_set_rdonly(ll_sbdev_type dev);
+void ll_clear_rdonly(ll_sbdev_type dev);
static inline void OBD_FAIL_WRITE(int id, struct super_block *sb)
{
return obd_fail_loc;
}
+void ll_set_rdonly(ll_sbdev_type dev)
+{
+ CDEBUG(D_IOCTL | D_HA, "set dev %ld rdonly\n", (long)dev);
+ ll_sbdev_sync(dev);
+#ifdef HAVE_OLD_DEV_SET_RDONLY
+ dev_set_rdonly(dev, 2);
+#else
+ dev_set_rdonly(dev);
+#endif
+}
+
+void ll_clear_rdonly(ll_sbdev_type dev)
+{
+ CDEBUG(D_IOCTL | D_HA, "unset dev %ld rdonly\n", (long)dev);
+ if (ll_check_rdonly(dev)) {
+ ll_sbdev_sync(dev);
+#ifdef HAVE_OLD_DEV_SET_RDONLY
+ dev_clear_rdonly(2);
+#else
+ dev_clear_rdonly(dev);
+#endif
+ }
+}
+
/* opening /dev/obd */
static int obd_class_open(struct inode * inode, struct file * file)
{
EXPORT_SYMBOL(obd_dev);
EXPORT_SYMBOL(obdo_cachep);
EXPORT_SYMBOL(obd_fail_loc);
+EXPORT_SYMBOL(ll_set_rdonly);
+EXPORT_SYMBOL(ll_clear_rdonly);
EXPORT_SYMBOL(obd_print_fail_loc);
EXPORT_SYMBOL(obd_race_waitq);
EXPORT_SYMBOL(obd_dump_on_timeout);
int obd_init_checks(void)
{
long long llval;
- __u64 u64val;
+ __u64 u64val, div64val;
char buf[64];
int len, ret = 0;
llval = OBD_OBJECT_EOF;
CDEBUG(D_INFO, "llval OBD_OBJECT_EOF = "LPX64"\n", llval);
if (llval != OBD_OBJECT_EOF) {
- CDEBUG(D_ERROR, "long long "LPX64"(%d) != 0xffffffffffffffff\n",
+ CERROR("long long "LPX64"(%d) != 0xffffffffffffffff\n",
llval, sizeof(llval));
ret = -EINVAL;
}
len = snprintf(buf, sizeof(buf), LPX64, llval);
if (len != 18) {
- CDEBUG(D_WARNING, "LPX64 wrong length! strlen(%s)=%d != 18\n",
- buf, len);
+ CWARN("LPX64 wrong length! strlen(%s)=%d != 18\n", buf, len);
ret = -EINVAL;
}
- u64val = OBD_OBJECT_EOF;
+ u64val = div64val = OBD_OBJECT_EOF;
CDEBUG(D_INFO, "u64val OBD_OBJECT_EOF = "LPX64"\n", u64val);
if (u64val != OBD_OBJECT_EOF) {
- CDEBUG(D_ERROR, "__u64 "LPX64"(%d) != 0xffffffffffffffff\n",
+ CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n",
u64val, sizeof(u64val));
- ret = -EINVAL;
+ ret = -EOVERFLOW;
}
if (u64val >> 8 != OBD_OBJECT_EOF >> 8) {
- CDEBUG(D_ERROR, "__u64 "LPX64"(%d) != 0xffffffffffffffff\n",
+ CERROR("__u64 "LPX64"(%d) != 0xffffffffffffffff\n",
u64val, sizeof(u64val));
- ret = -EINVAL;
+ return -EOVERFLOW;
+ }
+ if (do_div(div64val, 256) != (u64val & 255)) {
+ CERROR("do_div("LPX64",256) != "LPU64"\n", u64val, u64val &255);
+ return -EOVERFLOW;
+ }
+ if (u64val >> 8 != div64val) {
+ CERROR("do_div("LPX64",256) "LPU64" != "LPU64"\n",
+ u64val, div64val, u64val >> 8);
+ return -EOVERFLOW;
}
len = snprintf(buf, sizeof(buf), LPX64, u64val);
if (len != 18) {
- CDEBUG(D_WARNING, "LPX64 wrong length! strlen(%s)=%d != 18\n",
- buf, len);
+ CWARN("LPX64 wrong length! strlen(%s)=%d != 18\n", buf, len);
ret = -EINVAL;
}
len = snprintf(buf, sizeof(buf), LPU64, u64val);
if (len != 20) {
- CDEBUG(D_WARNING, "LPU64 wrong length! strlen(%s)=%d != 20\n",
- buf, len);
+ CWARN("LPU64 wrong length! strlen(%s)=%d != 20\n", buf, len);
ret = -EINVAL;
}
len = snprintf(buf, sizeof(buf), LPD64, u64val);
if (len != 2) {
- CDEBUG(D_WARNING, "LPD64 wrong length! strlen(%s)=%d != 2\n",
- buf, len);
+ CWARN("LPD64 wrong length! strlen(%s)=%d != 2\n", buf, len);
ret = -EINVAL;
}
if ((u64val & ~PAGE_MASK) >= PAGE_SIZE) {
- CDEBUG(D_WARNING, "mask failed: u64val "LPU64" >= %lu\n",
- u64val, PAGE_SIZE);
+ CWARN("mask failed: u64val "LPU64" >= %lu\n", u64val,PAGE_SIZE);
ret = -EINVAL;
}
printk(KERN_INFO "Lustre: OBD class driver Build Version: "
BUILD_VERSION", info@clusterfs.com\n");
+ err = obd_init_checks();
+ if (err == -EOVERFLOW)
+ return err;
+
class_init_uuidlist();
err = class_handle_init();
if (err)
#ifdef __KERNEL__
obd_sysctl_init();
#endif
- obd_init_checks();
#ifdef LPROCFS
proc_lustre_root = proc_mkdir("lustre", proc_root_fs);
}
void class_decref(struct obd_device *obd)
-{
+{
if (atomic_dec_and_test(&obd->obd_refcount)) {
int err;
CDEBUG(D_IOCTL, "finishing cleanup of obd %s (%s)\n",
if (obd->obd_stopping) {
/* If we're not stopping, we never set up */
err = obd_cleanup(obd);
- if (err)
+ if (err)
CERROR("Cleanup returned %d\n", err);
}
err = __class_detach(obd);
- if (err)
+ if (err)
CERROR("Detach returned %d\n", err);
}
-}
+}
int class_add_conn(struct obd_device *obd, struct lustre_cfg *lcfg)
{
}
case LCFG_SET_TIMEOUT: {
CDEBUG(D_IOCTL, "changing lustre timeout from %d to %d\n",
- obd_timeout,
- lcfg->lcfg_num);
+ obd_timeout, lcfg->lcfg_num);
obd_timeout = lcfg->lcfg_num;
GOTO(out, err = 0);
}
git://git.whamcloud.com / fs / lustre-release.git / commitdiff