struct p_data *dp, int data_size);
 extern int drbd_send_ack_ex(struct drbd_conf *mdev, enum drbd_packet cmd,
                            sector_t sector, int blksize, u64 block_id);
-extern int drbd_send_oos(struct drbd_conf *mdev, struct drbd_request *req);
+extern int drbd_send_out_of_sync(struct drbd_conf *, struct drbd_request *);
 extern int drbd_send_block(struct drbd_conf *, enum drbd_packet,
                           struct drbd_peer_request *);
 extern int drbd_send_dblock(struct drbd_conf *mdev, struct drbd_request *req);
 /* maybe rather drbd_main.c ? */
 extern int drbd_md_sync_page_io(struct drbd_conf *mdev,
                struct drbd_backing_dev *bdev, sector_t sector, int rw);
-extern void drbd_ov_oos_found(struct drbd_conf*, sector_t, int);
+extern void drbd_ov_out_of_sync_found(struct drbd_conf *, sector_t, int);
 extern void drbd_rs_controller_reset(struct drbd_conf *mdev);
 
-static inline void ov_oos_print(struct drbd_conf *mdev)
+static inline void ov_out_of_sync_print(struct drbd_conf *mdev)
 {
        if (mdev->ov_last_oos_size) {
                dev_err(DEV, "Out of sync: start=%llu, size=%lu (sectors)\n",
 extern int w_prev_work_done(struct drbd_work *, int);
 extern int w_e_reissue(struct drbd_work *, int);
 extern int w_restart_disk_io(struct drbd_work *, int);
-extern int w_send_oos(struct drbd_work *, int);
+extern int w_send_out_of_sync(struct drbd_work *, int);
 extern int w_start_resync(struct drbd_work *, int);
 
 extern void resync_timer_fn(unsigned long data);
 
        return err;
 }
 
-int drbd_send_oos(struct drbd_conf *mdev, struct drbd_request *req)
+int drbd_send_out_of_sync(struct drbd_conf *mdev, struct drbd_request *req)
 {
        struct p_block_desc p;
 
 
        update_peer_seq(mdev, be32_to_cpu(p->seq_num));
 
        if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC)
-               drbd_ov_oos_found(mdev, sector, size);
+               drbd_ov_out_of_sync_found(mdev, sector, size);
        else
-               ov_oos_print(mdev);
+               ov_out_of_sync_print(mdev);
 
        if (!get_ldev(mdev))
                return true;
                        drbd_queue_work_front(&mdev->tconn->data.work, w);
                } else {
                        dev_err(DEV, "kmalloc(w) failed.");
-                       ov_oos_print(mdev);
+                       ov_out_of_sync_print(mdev);
                        drbd_resync_finished(mdev);
                }
        }
 
 
        case QUEUE_FOR_SEND_OOS:
                req->rq_state |= RQ_NET_QUEUED;
-               req->w.cb =  w_send_oos;
+               req->w.cb =  w_send_out_of_sync;
                drbd_queue_work(&mdev->tconn->data.work, &req->w);
                break;
 
        }
 
        remote = remote && drbd_should_do_remote(mdev->state);
-       send_oos = rw == WRITE && drbd_should_send_oos(mdev->state);
+       send_oos = rw == WRITE && drbd_should_send_out_of_sync(mdev->state);
        D_ASSERT(!(remote && send_oos));
 
        if (!(local || remote) && !is_susp(mdev->state)) {
 
        if (remote || send_oos) {
                remote = drbd_should_do_remote(mdev->state);
-               send_oos = rw == WRITE && drbd_should_send_oos(mdev->state);
+               send_oos = rw == WRITE && drbd_should_send_out_of_sync(mdev->state);
                D_ASSERT(!(remote && send_oos));
 
                if (!(remote || send_oos))
 
           That is equivalent since before 96 IO was frozen in the C_WF_BITMAP*
           states. */
 }
-static inline bool drbd_should_send_oos(union drbd_state s)
+static inline bool drbd_should_send_out_of_sync(union drbd_state s)
 {
        return s.conn == C_AHEAD || s.conn == C_WF_BITMAP_S;
        /* pdsk = D_INCONSISTENT as a consequence. Protocol 96 check not necessary
 
 {
        struct drbd_conf *mdev = w->mdev;
        kfree(w);
-       ov_oos_print(mdev);
+       ov_out_of_sync_print(mdev);
        drbd_resync_finished(mdev);
 
        return 0;
        return err;
 }
 
-void drbd_ov_oos_found(struct drbd_conf *mdev, sector_t sector, int size)
+void drbd_ov_out_of_sync_found(struct drbd_conf *mdev, sector_t sector, int size)
 {
        if (mdev->ov_last_oos_start + mdev->ov_last_oos_size == sector) {
                mdev->ov_last_oos_size += size>>9;
         * drbd_pp_alloc due to pp_in_use > max_buffers. */
        drbd_free_ee(mdev, peer_req);
        if (!eq)
-               drbd_ov_oos_found(mdev, sector, size);
+               drbd_ov_out_of_sync_found(mdev, sector, size);
        else
-               ov_oos_print(mdev);
+               ov_out_of_sync_print(mdev);
 
        err = drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size,
                               eq ? ID_IN_SYNC : ID_OUT_OF_SYNC);
                drbd_advance_rs_marks(mdev, mdev->ov_left);
 
        if (mdev->ov_left == 0) {
-               ov_oos_print(mdev);
+               ov_out_of_sync_print(mdev);
                drbd_resync_finished(mdev);
        }
 
        return drbd_send_short_cmd(mdev, P_UNPLUG_REMOTE);
 }
 
-int w_send_oos(struct drbd_work *w, int cancel)
+int w_send_out_of_sync(struct drbd_work *w, int cancel)
 {
        struct drbd_request *req = container_of(w, struct drbd_request, w);
        struct drbd_conf *mdev = w->mdev;
                return 0;
        }
 
-       err = drbd_send_oos(mdev, req);
+       err = drbd_send_out_of_sync(mdev, req);
        req_mod(req, OOS_HANDED_TO_NETWORK);
 
        return err;