fs/nfs/objlayout/objlayout.c

   1 /*
   2  *  pNFS Objects layout driver high level definitions
   3  *
   4  *  Copyright (C) 2007 Panasas Inc. [year of first publication]
   5  *  All rights reserved.
   6  *
   7  *  Benny Halevy <bhalevy@panasas.com>
   8  *  Boaz Harrosh <bharrosh@panasas.com>
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License version 2
  12  *  See the file COPYING included with this distribution for more details.
  13  *
  14  *  Redistribution and use in source and binary forms, with or without
  15  *  modification, are permitted provided that the following conditions
  16  *  are met:
  17  *
  18  *  1. Redistributions of source code must retain the above copyright
  19  *     notice, this list of conditions and the following disclaimer.
  20  *  2. Redistributions in binary form must reproduce the above copyright
  21  *     notice, this list of conditions and the following disclaimer in the
  22  *     documentation and/or other materials provided with the distribution.
  23  *  3. Neither the name of the Panasas company nor the names of its
  24  *     contributors may be used to endorse or promote products derived
  25  *     from this software without specific prior written permission.
  26  *
  27  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  28  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  29  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  30  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  31  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  32  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  33  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  34  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  35  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  36  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  37  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  38  */
  39
  40 #include <scsi/osd_initiator.h>
  41 #include "objlayout.h"
  42
  43 #define NFSDBG_FACILITY         NFSDBG_PNFS_LD
  44 /*
  45  * Create a objlayout layout structure for the given inode and return it.
  46  */
  47 struct pnfs_layout_hdr *
  48 objlayout_alloc_layout_hdr(struct inode *inode, gfp_t gfp_flags)
  49 {
  50         struct objlayout *objlay;
  51
  52         objlay = kzalloc(sizeof(struct objlayout), gfp_flags);
  53         if (objlay) {
  54                 spin_lock_init(&objlay->lock);
  55                 INIT_LIST_HEAD(&objlay->err_list);
  56         }
  57         dprintk("%s: Return %p\n", __func__, objlay);
  58         return &objlay->pnfs_layout;
  59 }
  60
  61 /*
  62  * Free an objlayout layout structure
  63  */
  64 void
  65 objlayout_free_layout_hdr(struct pnfs_layout_hdr *lo)
  66 {
  67         struct objlayout *objlay = OBJLAYOUT(lo);
  68
  69         dprintk("%s: objlay %p\n", __func__, objlay);
  70
  71         WARN_ON(!list_empty(&objlay->err_list));
  72         kfree(objlay);
  73 }
  74
  75 /*
  76  * Unmarshall layout and store it in pnfslay.
  77  */
  78 struct pnfs_layout_segment *
  79 objlayout_alloc_lseg(struct pnfs_layout_hdr *pnfslay,
  80                      struct nfs4_layoutget_res *lgr,
  81                      gfp_t gfp_flags)
  82 {
  83         int status = -ENOMEM;
  84         struct xdr_stream stream;
  85         struct xdr_buf buf = {
  86                 .pages =  lgr->layoutp->pages,
  87                 .page_len =  lgr->layoutp->len,
  88                 .buflen =  lgr->layoutp->len,
  89                 .len = lgr->layoutp->len,
  90         };
  91         struct page *scratch;
  92         struct pnfs_layout_segment *lseg;
  93
  94         dprintk("%s: Begin pnfslay %p\n", __func__, pnfslay);
  95
  96         scratch = alloc_page(gfp_flags);
  97         if (!scratch)
  98                 goto err_nofree;
  99
 100         xdr_init_decode(&stream, &buf, NULL);
 101         xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
 102
 103         status = objio_alloc_lseg(&lseg, pnfslay, &lgr->range, &stream, gfp_flags);
 104         if (unlikely(status)) {
 105                 dprintk("%s: objio_alloc_lseg Return err %d\n", __func__,
 106                         status);
 107                 goto err;
 108         }
 109
 110         __free_page(scratch);
 111
 112         dprintk("%s: Return %p\n", __func__, lseg);
 113         return lseg;
 114
 115 err:
 116         __free_page(scratch);
 117 err_nofree:
 118         dprintk("%s: Err Return=>%d\n", __func__, status);
 119         return ERR_PTR(status);
 120 }
 121
 122 /*
 123  * Free a layout segement
 124  */
 125 void
 126 objlayout_free_lseg(struct pnfs_layout_segment *lseg)
 127 {
 128         dprintk("%s: freeing layout segment %p\n", __func__, lseg);
 129
 130         if (unlikely(!lseg))
 131                 return;
 132
 133         objio_free_lseg(lseg);
 134 }
 135
 136 /*
 137  * I/O Operations
 138  */
 139 static inline u64
 140 end_offset(u64 start, u64 len)
 141 {
 142         u64 end;
 143
 144         end = start + len;
 145         return end >= start ? end : NFS4_MAX_UINT64;
 146 }
 147
 148 /* last octet in a range */
 149 static inline u64
 150 last_byte_offset(u64 start, u64 len)
 151 {
 152         u64 end;
 153
 154         BUG_ON(!len);
 155         end = start + len;
 156         return end > start ? end - 1 : NFS4_MAX_UINT64;
 157 }
 158
 159 static struct objlayout_io_state *
 160 objlayout_alloc_io_state(struct pnfs_layout_hdr *pnfs_layout_type,
 161                         struct page **pages,
 162                         unsigned pgbase,
 163                         loff_t offset,
 164                         size_t count,
 165                         struct pnfs_layout_segment *lseg,
 166                         void *rpcdata,
 167                         gfp_t gfp_flags)
 168 {
 169         struct objlayout_io_state *state;
 170         u64 lseg_end_offset;
 171
 172         dprintk("%s: allocating io_state\n", __func__);
 173         if (objio_alloc_io_state(lseg, &state, gfp_flags))
 174                 return NULL;
 175
 176         BUG_ON(offset < lseg->pls_range.offset);
 177         lseg_end_offset = end_offset(lseg->pls_range.offset,
 178                                      lseg->pls_range.length);
 179         BUG_ON(offset >= lseg_end_offset);
 180         if (offset + count > lseg_end_offset) {
 181                 count = lseg->pls_range.length -
 182                                 (offset - lseg->pls_range.offset);
 183                 dprintk("%s: truncated count %Zd\n", __func__, count);
 184         }
 185
 186         if (pgbase > PAGE_SIZE) {
 187                 pages += pgbase >> PAGE_SHIFT;
 188                 pgbase &= ~PAGE_MASK;
 189         }
 190
 191         INIT_LIST_HEAD(&state->err_list);
 192         state->lseg = lseg;
 193         state->rpcdata = rpcdata;
 194         state->pages = pages;
 195         state->pgbase = pgbase;
 196         state->nr_pages = (pgbase + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
 197         state->offset = offset;
 198         state->count = count;
 199         state->sync = 0;
 200
 201         return state;
 202 }
 203
 204 static void
 205 objlayout_free_io_state(struct objlayout_io_state *state)
 206 {
 207         dprintk("%s: freeing io_state\n", __func__);
 208         if (unlikely(!state))
 209                 return;
 210
 211         objio_free_io_state(state);
 212 }
 213
 214 /*
 215  * I/O done common code
 216  */
 217 static void
 218 objlayout_iodone(struct objlayout_io_state *state)
 219 {
 220         dprintk("%s: state %p status\n", __func__, state);
 221
 222         if (likely(state->status >= 0)) {
 223                 objlayout_free_io_state(state);
 224         } else {
 225                 struct objlayout *objlay = OBJLAYOUT(state->lseg->pls_layout);
 226
 227                 spin_lock(&objlay->lock);
 228                 objlay->delta_space_valid = OBJ_DSU_INVALID;
 229                 list_add(&objlay->err_list, &state->err_list);
 230                 spin_unlock(&objlay->lock);
 231         }
 232 }
 233
 234 /*
 235  * objlayout_io_set_result - Set an osd_error code on a specific osd comp.
 236  *
 237  * The @index component IO failed (error returned from target). Register
 238  * the error for later reporting at layout-return.
 239  */
 240 void
 241 objlayout_io_set_result(struct objlayout_io_state *state, unsigned index,
 242                         struct pnfs_osd_objid *pooid, int osd_error,
 243                         u64 offset, u64 length, bool is_write)
 244 {
 245         struct pnfs_osd_ioerr *ioerr = &state->ioerrs[index];
 246
 247         BUG_ON(index >= state->num_comps);
 248         if (osd_error) {
 249                 ioerr->oer_component = *pooid;
 250                 ioerr->oer_comp_offset = offset;
 251                 ioerr->oer_comp_length = length;
 252                 ioerr->oer_iswrite = is_write;
 253                 ioerr->oer_errno = osd_error;
 254
 255                 dprintk("%s: err[%d]: errno=%d is_write=%d dev(%llx:%llx) "
 256                         "par=0x%llx obj=0x%llx offset=0x%llx length=0x%llx\n",
 257                         __func__, index, ioerr->oer_errno,
 258                         ioerr->oer_iswrite,
 259                         _DEVID_LO(&ioerr->oer_component.oid_device_id),
 260                         _DEVID_HI(&ioerr->oer_component.oid_device_id),
 261                         ioerr->oer_component.oid_partition_id,
 262                         ioerr->oer_component.oid_object_id,
 263                         ioerr->oer_comp_offset,
 264                         ioerr->oer_comp_length);
 265         } else {
 266                 /* User need not call if no error is reported */
 267                 ioerr->oer_errno = 0;
 268         }
 269 }
 270
 271 /* Function scheduled on rpc workqueue to call ->nfs_readlist_complete().
 272  * This is because the osd completion is called with ints-off from
 273  * the block layer
 274  */
 275 static void _rpc_read_complete(struct work_struct *work)
 276 {
 277         struct rpc_task *task;
 278         struct nfs_read_data *rdata;
 279
 280         dprintk("%s enter\n", __func__);
 281         task = container_of(work, struct rpc_task, u.tk_work);
 282         rdata = container_of(task, struct nfs_read_data, task);
 283
 284         pnfs_ld_read_done(rdata);
 285 }
 286
 287 void
 288 objlayout_read_done(struct objlayout_io_state *state, ssize_t status, bool sync)
 289 {
 290         struct nfs_read_data *rdata = state->rpcdata;
 291
 292         state->status = status;
 293         dprintk("%s: Begin status=%zd eof=%d\n", __func__,
 294                 status, rdata->res.eof);
 295         rdata->task.tk_status = status;
 296         if (status >= 0)
 297                 rdata->res.count = status;
 298         objlayout_iodone(state);
 299         /* must not use state after this point */
 300
 301         if (sync)
 302                 pnfs_ld_read_done(rdata);
 303         else {
 304                 INIT_WORK(&rdata->task.u.tk_work, _rpc_read_complete);
 305                 schedule_work(&rdata->task.u.tk_work);
 306         }
 307 }
 308
 309 /*
 310  * Perform sync or async reads.
 311  */
 312 enum pnfs_try_status
 313 objlayout_read_pagelist(struct nfs_read_data *rdata)
 314 {
 315         loff_t offset = rdata->args.offset;
 316         size_t count = rdata->args.count;
 317         struct objlayout_io_state *state;
 318         ssize_t status = 0;
 319         loff_t eof;
 320
 321         dprintk("%s: Begin inode %p offset %llu count %d\n",
 322                 __func__, rdata->inode, offset, (int)count);
 323
 324         eof = i_size_read(rdata->inode);
 325         if (unlikely(offset + count > eof)) {
 326                 if (offset >= eof) {
 327                         status = 0;
 328                         rdata->res.count = 0;
 329                         rdata->res.eof = 1;
 330                         /*FIXME: do we need to call pnfs_ld_read_done() */
 331                         goto out;
 332                 }
 333                 count = eof - offset;
 334         }
 335
 336         rdata->res.eof = (offset + count) >= eof;
 337
 338         state = objlayout_alloc_io_state(NFS_I(rdata->inode)->layout,
 339                                          rdata->args.pages, rdata->args.pgbase,
 340                                          offset, count,
 341                                          rdata->lseg, rdata,
 342                                          GFP_KERNEL);
 343         if (unlikely(!state)) {
 344                 status = -ENOMEM;
 345                 goto out;
 346         }
 347
 348         status = objio_read_pagelist(state);
 349  out:
 350         dprintk("%s: Return status %Zd\n", __func__, status);
 351         rdata->pnfs_error = status;
 352         return PNFS_ATTEMPTED;
 353 }
 354
 355 /* Function scheduled on rpc workqueue to call ->nfs_writelist_complete().
 356  * This is because the osd completion is called with ints-off from
 357  * the block layer
 358  */
 359 static void _rpc_write_complete(struct work_struct *work)
 360 {
 361         struct rpc_task *task;
 362         struct nfs_write_data *wdata;
 363
 364         dprintk("%s enter\n", __func__);
 365         task = container_of(work, struct rpc_task, u.tk_work);
 366         wdata = container_of(task, struct nfs_write_data, task);
 367
 368         pnfs_ld_write_done(wdata);
 369 }
 370
 371 void
 372 objlayout_write_done(struct objlayout_io_state *state, ssize_t status,
 373                      bool sync)
 374 {
 375         struct nfs_write_data *wdata;
 376
 377         dprintk("%s: Begin\n", __func__);
 378         wdata = state->rpcdata;
 379         state->status = status;
 380         wdata->task.tk_status = status;
 381         if (status >= 0) {
 382                 wdata->res.count = status;
 383                 wdata->verf.committed = state->committed;
 384                 dprintk("%s: Return status %d committed %d\n",
 385                         __func__, wdata->task.tk_status,
 386                         wdata->verf.committed);
 387         } else
 388                 dprintk("%s: Return status %d\n",
 389                         __func__, wdata->task.tk_status);
 390         objlayout_iodone(state);
 391         /* must not use state after this point */
 392
 393         if (sync)
 394                 pnfs_ld_write_done(wdata);
 395         else {
 396                 INIT_WORK(&wdata->task.u.tk_work, _rpc_write_complete);
 397                 schedule_work(&wdata->task.u.tk_work);
 398         }
 399 }
 400
 401 /*
 402  * Perform sync or async writes.
 403  */
 404 enum pnfs_try_status
 405 objlayout_write_pagelist(struct nfs_write_data *wdata,
 406                          int how)
 407 {
 408         struct objlayout_io_state *state;
 409         ssize_t status;
 410
 411         dprintk("%s: Begin inode %p offset %llu count %u\n",
 412                 __func__, wdata->inode, wdata->args.offset, wdata->args.count);
 413
 414         state = objlayout_alloc_io_state(NFS_I(wdata->inode)->layout,
 415                                          wdata->args.pages,
 416                                          wdata->args.pgbase,
 417                                          wdata->args.offset,
 418                                          wdata->args.count,
 419                                          wdata->lseg, wdata,
 420                                          GFP_NOFS);
 421         if (unlikely(!state)) {
 422                 status = -ENOMEM;
 423                 goto out;
 424         }
 425
 426         state->sync = how & FLUSH_SYNC;
 427
 428         status = objio_write_pagelist(state, how & FLUSH_STABLE);
 429  out:
 430         dprintk("%s: Return status %Zd\n", __func__, status);
 431         wdata->pnfs_error = status;
 432         return PNFS_ATTEMPTED;
 433 }
 434
 435 void
 436 objlayout_encode_layoutcommit(struct pnfs_layout_hdr *pnfslay,
 437                               struct xdr_stream *xdr,
 438                               const struct nfs4_layoutcommit_args *args)
 439 {
 440         struct objlayout *objlay = OBJLAYOUT(pnfslay);
 441         struct pnfs_osd_layoutupdate lou;
 442         __be32 *start;
 443
 444         dprintk("%s: Begin\n", __func__);
 445
 446         spin_lock(&objlay->lock);
 447         lou.dsu_valid = (objlay->delta_space_valid == OBJ_DSU_VALID);
 448         lou.dsu_delta = objlay->delta_space_used;
 449         objlay->delta_space_used = 0;
 450         objlay->delta_space_valid = OBJ_DSU_INIT;
 451         lou.olu_ioerr_flag = !list_empty(&objlay->err_list);
 452         spin_unlock(&objlay->lock);
 453
 454         start = xdr_reserve_space(xdr, 4);
 455
 456         BUG_ON(pnfs_osd_xdr_encode_layoutupdate(xdr, &lou));
 457
 458         *start = cpu_to_be32((xdr->p - start - 1) * 4);
 459
 460         dprintk("%s: Return delta_space_used %lld err %d\n", __func__,
 461                 lou.dsu_delta, lou.olu_ioerr_flag);
 462 }
 463
 464 static int
 465 err_prio(u32 oer_errno)
 466 {
 467         switch (oer_errno) {
 468         case 0:
 469                 return 0;
 470
 471         case PNFS_OSD_ERR_RESOURCE:
 472                 return OSD_ERR_PRI_RESOURCE;
 473         case PNFS_OSD_ERR_BAD_CRED:
 474                 return OSD_ERR_PRI_BAD_CRED;
 475         case PNFS_OSD_ERR_NO_ACCESS:
 476                 return OSD_ERR_PRI_NO_ACCESS;
 477         case PNFS_OSD_ERR_UNREACHABLE:
 478                 return OSD_ERR_PRI_UNREACHABLE;
 479         case PNFS_OSD_ERR_NOT_FOUND:
 480                 return OSD_ERR_PRI_NOT_FOUND;
 481         case PNFS_OSD_ERR_NO_SPACE:
 482                 return OSD_ERR_PRI_NO_SPACE;
 483         default:
 484                 WARN_ON(1);
 485                 /* fallthrough */
 486         case PNFS_OSD_ERR_EIO:
 487                 return OSD_ERR_PRI_EIO;
 488         }
 489 }
 490
 491 static void
 492 merge_ioerr(struct pnfs_osd_ioerr *dest_err,
 493             const struct pnfs_osd_ioerr *src_err)
 494 {
 495         u64 dest_end, src_end;
 496
 497         if (!dest_err->oer_errno) {
 498                 *dest_err = *src_err;
 499                 /* accumulated device must be blank */
 500                 memset(&dest_err->oer_component.oid_device_id, 0,
 501                         sizeof(dest_err->oer_component.oid_device_id));
 502
 503                 return;
 504         }
 505
 506         if (dest_err->oer_component.oid_partition_id !=
 507                                 src_err->oer_component.oid_partition_id)
 508                 dest_err->oer_component.oid_partition_id = 0;
 509
 510         if (dest_err->oer_component.oid_object_id !=
 511                                 src_err->oer_component.oid_object_id)
 512                 dest_err->oer_component.oid_object_id = 0;
 513
 514         if (dest_err->oer_comp_offset > src_err->oer_comp_offset)
 515                 dest_err->oer_comp_offset = src_err->oer_comp_offset;
 516
 517         dest_end = end_offset(dest_err->oer_comp_offset,
 518                               dest_err->oer_comp_length);
 519         src_end =  end_offset(src_err->oer_comp_offset,
 520                               src_err->oer_comp_length);
 521         if (dest_end < src_end)
 522                 dest_end = src_end;
 523
 524         dest_err->oer_comp_length = dest_end - dest_err->oer_comp_offset;
 525
 526         if ((src_err->oer_iswrite == dest_err->oer_iswrite) &&
 527             (err_prio(src_err->oer_errno) > err_prio(dest_err->oer_errno))) {
 528                         dest_err->oer_errno = src_err->oer_errno;
 529         } else if (src_err->oer_iswrite) {
 530                 dest_err->oer_iswrite = true;
 531                 dest_err->oer_errno = src_err->oer_errno;
 532         }
 533 }
 534
 535 static void
 536 encode_accumulated_error(struct objlayout *objlay, __be32 *p)
 537 {
 538         struct objlayout_io_state *state, *tmp;
 539         struct pnfs_osd_ioerr accumulated_err = {.oer_errno = 0};
 540
 541         list_for_each_entry_safe(state, tmp, &objlay->err_list, err_list) {
 542                 unsigned i;
 543
 544                 for (i = 0; i < state->num_comps; i++) {
 545                         struct pnfs_osd_ioerr *ioerr = &state->ioerrs[i];
 546
 547                         if (!ioerr->oer_errno)
 548                                 continue;
 549
 550                         printk(KERN_ERR "%s: err[%d]: errno=%d is_write=%d "
 551                                 "dev(%llx:%llx) par=0x%llx obj=0x%llx "
 552                                 "offset=0x%llx length=0x%llx\n",
 553                                 __func__, i, ioerr->oer_errno,
 554                                 ioerr->oer_iswrite,
 555                                 _DEVID_LO(&ioerr->oer_component.oid_device_id),
 556                                 _DEVID_HI(&ioerr->oer_component.oid_device_id),
 557                                 ioerr->oer_component.oid_partition_id,
 558                                 ioerr->oer_component.oid_object_id,
 559                                 ioerr->oer_comp_offset,
 560                                 ioerr->oer_comp_length);
 561
 562                         merge_ioerr(&accumulated_err, ioerr);
 563                 }
 564                 list_del(&state->err_list);
 565                 objlayout_free_io_state(state);
 566         }
 567
 568         pnfs_osd_xdr_encode_ioerr(p, &accumulated_err);
 569 }
 570
 571 void
 572 objlayout_encode_layoutreturn(struct pnfs_layout_hdr *pnfslay,
 573                               struct xdr_stream *xdr,
 574                               const struct nfs4_layoutreturn_args *args)
 575 {
 576         struct objlayout *objlay = OBJLAYOUT(pnfslay);
 577         struct objlayout_io_state *state, *tmp;
 578         __be32 *start;
 579
 580         dprintk("%s: Begin\n", __func__);
 581         start = xdr_reserve_space(xdr, 4);
 582         BUG_ON(!start);
 583
 584         spin_lock(&objlay->lock);
 585
 586         list_for_each_entry_safe(state, tmp, &objlay->err_list, err_list) {
 587                 __be32 *last_xdr = NULL, *p;
 588                 unsigned i;
 589                 int res = 0;
 590
 591                 for (i = 0; i < state->num_comps; i++) {
 592                         struct pnfs_osd_ioerr *ioerr = &state->ioerrs[i];
 593
 594                         if (!ioerr->oer_errno)
 595                                 continue;
 596
 597                         dprintk("%s: err[%d]: errno=%d is_write=%d "
 598                                 "dev(%llx:%llx) par=0x%llx obj=0x%llx "
 599                                 "offset=0x%llx length=0x%llx\n",
 600                                 __func__, i, ioerr->oer_errno,
 601                                 ioerr->oer_iswrite,
 602                                 _DEVID_LO(&ioerr->oer_component.oid_device_id),
 603                                 _DEVID_HI(&ioerr->oer_component.oid_device_id),
 604                                 ioerr->oer_component.oid_partition_id,
 605                                 ioerr->oer_component.oid_object_id,
 606                                 ioerr->oer_comp_offset,
 607                                 ioerr->oer_comp_length);
 608
 609                         p = pnfs_osd_xdr_ioerr_reserve_space(xdr);
 610                         if (unlikely(!p)) {
 611                                 res = -E2BIG;
 612                                 break; /* accumulated_error */
 613                         }
 614
 615                         last_xdr = p;
 616                         pnfs_osd_xdr_encode_ioerr(p, &state->ioerrs[i]);
 617                 }
 618
 619                 /* TODO: use xdr_write_pages */
 620                 if (unlikely(res)) {
 621                         /* no space for even one error descriptor */
 622                         BUG_ON(!last_xdr);
 623
 624                         /* we've encountered a situation with lots and lots of
 625                          * errors and no space to encode them all. Use the last
 626                          * available slot to report the union of all the
 627                          * remaining errors.
 628                          */
 629                         encode_accumulated_error(objlay, last_xdr);
 630                         goto loop_done;
 631                 }
 632                 list_del(&state->err_list);
 633                 objlayout_free_io_state(state);
 634         }
 635 loop_done:
 636         spin_unlock(&objlay->lock);
 637
 638         *start = cpu_to_be32((xdr->p - start - 1) * 4);
 639         dprintk("%s: Return\n", __func__);
 640 }
 641
 642
 643 /*
 644  * Get Device Info API for io engines
 645  */
 646 struct objlayout_deviceinfo {
 647         struct page *page;
 648         struct pnfs_osd_deviceaddr da; /* This must be last */
 649 };
 650
 651 /* Initialize and call nfs_getdeviceinfo, then decode and return a
 652  * "struct pnfs_osd_deviceaddr *" Eventually objlayout_put_deviceinfo()
 653  * should be called.
 654  */
 655 int objlayout_get_deviceinfo(struct pnfs_layout_hdr *pnfslay,
 656         struct nfs4_deviceid *d_id, struct pnfs_osd_deviceaddr **deviceaddr,
 657         gfp_t gfp_flags)
 658 {
 659         struct objlayout_deviceinfo *odi;
 660         struct pnfs_device pd;
 661         struct super_block *sb;
 662         struct page *page, **pages;
 663         u32 *p;
 664         int err;
 665
 666         page = alloc_page(gfp_flags);
 667         if (!page)
 668                 return -ENOMEM;
 669
 670         pages = &page;
 671         pd.pages = pages;
 672
 673         memcpy(&pd.dev_id, d_id, sizeof(*d_id));
 674         pd.layout_type = LAYOUT_OSD2_OBJECTS;
 675         pd.pages = &page;
 676         pd.pgbase = 0;
 677         pd.pglen = PAGE_SIZE;
 678         pd.mincount = 0;
 679
 680         sb = pnfslay->plh_inode->i_sb;
 681         err = nfs4_proc_getdeviceinfo(NFS_SERVER(pnfslay->plh_inode), &pd);
 682         dprintk("%s nfs_getdeviceinfo returned %d\n", __func__, err);
 683         if (err)
 684                 goto err_out;
 685
 686         p = page_address(page);
 687         odi = kzalloc(sizeof(*odi), gfp_flags);
 688         if (!odi) {
 689                 err = -ENOMEM;
 690                 goto err_out;
 691         }
 692         pnfs_osd_xdr_decode_deviceaddr(&odi->da, p);
 693         odi->page = page;
 694         *deviceaddr = &odi->da;
 695         return 0;
 696
 697 err_out:
 698         __free_page(page);
 699         return err;
 700 }
 701
 702 void objlayout_put_deviceinfo(struct pnfs_osd_deviceaddr *deviceaddr)
 703 {
 704         struct objlayout_deviceinfo *odi = container_of(deviceaddr,
 705                                                 struct objlayout_deviceinfo,
 706                                                 da);
 707
 708         __free_page(odi->page);
 709         kfree(odi);
 710 }