off, len);
        vino = ceph_vino(inode);
        req = ceph_osdc_new_request(osdc, &ci->i_layout, vino, off, &len,
-                                   1, CEPH_OSD_OP_READ,
+                                   0, 1, CEPH_OSD_OP_READ,
                                    CEPH_OSD_FLAG_READ, NULL,
                                    ci->i_truncate_seq, ci->i_truncate_size,
                                    false);
        last_snapc = snapc;
 
        while (!done && index <= end) {
-               int num_ops = do_sync ? 2 : 1;
                unsigned i;
                int first;
                pgoff_t next;
                                len = wsize;
                                req = ceph_osdc_new_request(&fsc->client->osdc,
                                                        &ci->i_layout, vino,
-                                                       offset, &len, num_ops,
+                                                       offset, &len, 0,
+                                                       do_sync ? 2 : 1,
                                                        CEPH_OSD_OP_WRITE,
                                                        CEPH_OSD_FLAG_WRITE |
                                                        CEPH_OSD_FLAG_ONDISK,
                                        break;
                                }
 
+                               if (do_sync)
+                                       osd_req_op_init(req, 1, CEPH_OSD_OP_STARTSYNC);
+
                                req->r_callback = writepages_finish;
                                req->r_inode = inode;
 
 
                snapc = ci->i_snap_realm->cached_context;
                vino = ceph_vino(inode);
                req = ceph_osdc_new_request(&fsc->client->osdc, &ci->i_layout,
-                                           vino, pos, &len,
+                                           vino, pos, &len, 0,
                                            2,/*include a 'startsync' command*/
                                            CEPH_OSD_OP_WRITE, flags, snapc,
                                            ci->i_truncate_seq,
                        break;
                }
 
+               osd_req_op_init(req, 1, CEPH_OSD_OP_STARTSYNC);
+
                n = iov_iter_get_pages_alloc(from, &pages, len, &start);
                if (unlikely(n < 0)) {
                        ret = n;
                snapc = ci->i_snap_realm->cached_context;
                vino = ceph_vino(inode);
                req = ceph_osdc_new_request(&fsc->client->osdc, &ci->i_layout,
-                                           vino, pos, &len, 1,
+                                           vino, pos, &len, 0, 1,
                                            CEPH_OSD_OP_WRITE, flags, snapc,
                                            ci->i_truncate_seq,
                                            ci->i_truncate_size,
        req = ceph_osdc_new_request(&fsc->client->osdc, &ci->i_layout,
                                        ceph_vino(inode),
                                        offset, length,
-                                       1, op,
+                                       0, 1, op,
                                        CEPH_OSD_FLAG_WRITE |
                                        CEPH_OSD_FLAG_ONDISK,
                                        NULL, 0, 0, false);
 
 struct ceph_osd_request *ceph_osdc_new_request(struct ceph_osd_client *osdc,
                                               struct ceph_file_layout *layout,
                                               struct ceph_vino vino,
-                                              u64 off, u64 *plen, int num_ops,
+                                              u64 off, u64 *plen,
+                                              unsigned int which, int num_ops,
                                               int opcode, int flags,
                                               struct ceph_snap_context *snapc,
                                               u32 truncate_seq,
        }
 
        if (opcode == CEPH_OSD_OP_CREATE || opcode == CEPH_OSD_OP_DELETE) {
-               osd_req_op_init(req, 0, opcode);
+               osd_req_op_init(req, which, opcode);
        } else {
                u32 object_size = le32_to_cpu(layout->fl_object_size);
                u32 object_base = off - objoff;
                                        truncate_size = object_size;
                        }
                }
-
-               osd_req_op_extent_init(req, 0, opcode, objoff, objlen,
+               osd_req_op_extent_init(req, which, opcode, objoff, objlen,
                                       truncate_size, truncate_seq);
        }
-       /*
-        * A second op in the ops array means the caller wants to
-        * also issue a include a 'startsync' command so that the
-        * osd will flush data quickly.
-        */
-       if (num_ops > 1)
-               osd_req_op_init(req, 1, CEPH_OSD_OP_STARTSYNC);
 
        req->r_base_oloc.pool = ceph_file_layout_pg_pool(*layout);
 
 
        dout("readpages on ino %llx.%llx on %llu~%llu\n", vino.ino,
             vino.snap, off, *plen);
-       req = ceph_osdc_new_request(osdc, layout, vino, off, plen, 1,
+       req = ceph_osdc_new_request(osdc, layout, vino, off, plen, 0, 1,
                                    CEPH_OSD_OP_READ, CEPH_OSD_FLAG_READ,
                                    NULL, truncate_seq, truncate_size,
                                    false);
        int page_align = off & ~PAGE_MASK;
 
        BUG_ON(vino.snap != CEPH_NOSNAP);       /* snapshots aren't writeable */
-       req = ceph_osdc_new_request(osdc, layout, vino, off, &len, 1,
+       req = ceph_osdc_new_request(osdc, layout, vino, off, &len, 0, 1,
                                    CEPH_OSD_OP_WRITE,
                                    CEPH_OSD_FLAG_ONDISK | CEPH_OSD_FLAG_WRITE,
                                    snapc, truncate_seq, truncate_size,