From: adilger <adilger>
Date: Wed, 30 Mar 2005 04:55:21 +0000 (+0000)
Subject: Branch: b1_4
X-Git-Tag: v1_8_0_110~486^7~86
X-Git-Url: https://git.whamcloud.com/?a=commitdiff_plain;h=23c26d99bbc751b43e933a1c4f06503a529944af;p=fs%2Flustre-release.git

Branch: b1_4
For some reason having an inline ll_set_rdonly() with HAVE_OLD_DEV_SET_RDONLY
is causing gcc to miscompile and way overstep the array bounds (2 == 1792
in some cases it seems).  Move this code to a function.

Add some more 64-bit sanity checks (it was do_div() on BGL that broke things
previously).
---

diff --git a/lustre/include/linux/lustre_compat25.h b/lustre/include/linux/lustre_compat25.h
index bfc2ac5..0760eaa 100644
--- a/lustre/include/linux/lustre_compat25.h
+++ b/lustre/include/linux/lustre_compat25.h
@@ -149,7 +149,7 @@ static inline int cleanup_group_info(void)
 #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,
diff --git a/lustre/include/linux/lustre_net.h b/lustre/include/linux/lustre_net.h
index 55946cb..4a711ea 100644
--- a/lustre/include/linux/lustre_net.h
+++ b/lustre/include/linux/lustre_net.h
@@ -285,14 +285,12 @@ struct ptlrpc_request {
                 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;
@@ -317,20 +315,20 @@ struct ptlrpc_request {
         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;
@@ -343,7 +341,7 @@ struct ptlrpc_request {
         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;
 };
 
 
diff --git a/lustre/include/linux/obd.h b/lustre/include/linux/obd.h
index aa79897..4d74a59 100644
--- a/lustre/include/linux/obd.h
+++ b/lustre/include/linux/obd.h
@@ -278,7 +278,7 @@ struct client_obd {
 
         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;
diff --git a/lustre/include/linux/obd_support.h b/lustre/include/linux/obd_support.h
index a492902..4207a5e 100644
--- a/lustre/include/linux/obd_support.h
+++ b/lustre/include/linux/obd_support.h
@@ -240,41 +240,18 @@ do {                                                            \
 #  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)
 {
diff --git a/lustre/obdclass/class_obd.c b/lustre/obdclass/class_obd.c
index 5173165..a99c3f2 100644
--- a/lustre/obdclass/class_obd.c
+++ b/lustre/obdclass/class_obd.c
@@ -102,6 +102,30 @@ unsigned int obd_print_fail_loc(void)
         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)
 {
@@ -372,6 +396,8 @@ void *obd_psdev = NULL;
 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);
@@ -550,7 +576,7 @@ struct file_operations obd_device_list_fops = {
 int obd_init_checks(void)
 {
         long long llval;
-        __u64 u64val;
+        __u64 u64val, div64val;
         char buf[64];
         int len, ret = 0;
 
@@ -562,50 +588,54 @@ int obd_init_checks(void)
         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;
         }
 
@@ -631,6 +661,10 @@ int init_obdclass(void)
         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)
@@ -656,7 +690,6 @@ int init_obdclass(void)
 #ifdef __KERNEL__
         obd_sysctl_init();
 #endif
-        obd_init_checks();
 
 #ifdef LPROCFS
         proc_lustre_root = proc_mkdir("lustre", proc_root_fs);
diff --git a/lustre/obdclass/obd_config.c b/lustre/obdclass/obd_config.c
index f705364..58a0927 100644
--- a/lustre/obdclass/obd_config.c
+++ b/lustre/obdclass/obd_config.c
@@ -361,7 +361,7 @@ out:
 }
 
 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",
@@ -370,14 +370,14 @@ void class_decref(struct obd_device *obd)
                 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)
 {
@@ -564,8 +564,7 @@ int class_process_config(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);
         }