struct drbd_peer_request *, const unsigned,
                                    const int);
 extern int drbd_release_ee(struct drbd_conf *mdev, struct list_head *list);
-extern struct drbd_peer_request *drbd_alloc_ee(struct drbd_conf *,
-                                              u64, sector_t, unsigned int,
-                                              gfp_t) __must_hold(local);
+extern struct drbd_peer_request *drbd_alloc_peer_req(struct drbd_conf *, u64,
+                                                    sector_t, unsigned int,
+                                                    gfp_t) __must_hold(local);
 extern void drbd_free_some_ee(struct drbd_conf *, struct drbd_peer_request *,
                              int);
 #define drbd_free_ee(m,e)      drbd_free_some_ee(m, e, 0)
 
 
 You must not have the req_lock:
  drbd_free_ee()
- drbd_alloc_ee()
+ drbd_alloc_peer_req()
  drbd_release_ee()
  drbd_ee_fix_bhs()
  drbd_process_done_ee()
 */
 
 struct drbd_peer_request *
-drbd_alloc_ee(struct drbd_conf *mdev, u64 id, sector_t sector,
-             unsigned int data_size, gfp_t gfp_mask) __must_hold(local)
+drbd_alloc_peer_req(struct drbd_conf *mdev, u64 id, sector_t sector,
+                   unsigned int data_size, gfp_t gfp_mask) __must_hold(local)
 {
        struct drbd_peer_request *peer_req;
        struct page *page;
        peer_req = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM);
        if (!peer_req) {
                if (!(gfp_mask & __GFP_NOWARN))
-                       dev_err(DEV, "alloc_ee: Allocation of an EE failed\n");
+                       dev_err(DEV, "%s: allocation failed\n", __func__);
                return NULL;
        }
 
        /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD
         * "criss-cross" setup, that might cause write-out on some other DRBD,
         * which in turn might block on the other node at this very place.  */
-       peer_req = drbd_alloc_ee(mdev, id, sector, data_size, GFP_NOIO);
+       peer_req = drbd_alloc_peer_req(mdev, id, sector, data_size, GFP_NOIO);
        if (!peer_req)
                return NULL;
 
        /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD
         * "criss-cross" setup, that might cause write-out on some other DRBD,
         * which in turn might block on the other node at this very place.  */
-       peer_req = drbd_alloc_ee(mdev, p->block_id, sector, size, GFP_NOIO);
+       peer_req = drbd_alloc_peer_req(mdev, p->block_id, sector, size, GFP_NOIO);
        if (!peer_req) {
                put_ldev(mdev);
                return -ENOMEM;
 
 
        /* GFP_TRY, because if there is no memory available right now, this may
         * be rescheduled for later. It is "only" background resync, after all. */
-       peer_req = drbd_alloc_ee(mdev, ID_SYNCER /* unused */, sector, size, GFP_TRY);
+       peer_req = drbd_alloc_peer_req(mdev, ID_SYNCER /* unused */, sector,
+                                      size, GFP_TRY);
        if (!peer_req)
                goto defer;