~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nfs/objlayout/objio_osd.c

Version: ~ [ linux-5.3-rc1 ] ~ [ linux-5.2.2 ] ~ [ linux-5.1.19 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.60 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.134 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.186 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.186 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.70 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  pNFS Objects layout implementation over open-osd initiator library
  3  *
  4  *  Copyright (C) 2009 Panasas Inc. [year of first publication]
  5  *  All rights reserved.
  6  *
  7  *  Benny Halevy <bhalevy@panasas.com>
  8  *  Boaz Harrosh <ooo@electrozaur.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 <linux/module.h>
 41 #include <scsi/osd_ore.h>
 42 
 43 #include "objlayout.h"
 44 #include "../internal.h"
 45 
 46 #define NFSDBG_FACILITY         NFSDBG_PNFS_LD
 47 
 48 struct objio_dev_ent {
 49         struct nfs4_deviceid_node id_node;
 50         struct ore_dev od;
 51 };
 52 
 53 static void
 54 objio_free_deviceid_node(struct nfs4_deviceid_node *d)
 55 {
 56         struct objio_dev_ent *de = container_of(d, struct objio_dev_ent, id_node);
 57 
 58         dprintk("%s: free od=%p\n", __func__, de->od.od);
 59         osduld_put_device(de->od.od);
 60         kfree_rcu(d, rcu);
 61 }
 62 
 63 struct objio_segment {
 64         struct pnfs_layout_segment lseg;
 65 
 66         struct ore_layout layout;
 67         struct ore_components oc;
 68 };
 69 
 70 static inline struct objio_segment *
 71 OBJIO_LSEG(struct pnfs_layout_segment *lseg)
 72 {
 73         return container_of(lseg, struct objio_segment, lseg);
 74 }
 75 
 76 struct objio_state {
 77         /* Generic layer */
 78         struct objlayout_io_res oir;
 79 
 80         bool sync;
 81         /*FIXME: Support for extra_bytes at ore_get_rw_state() */
 82         struct ore_io_state *ios;
 83 };
 84 
 85 /* Send and wait for a get_device_info of devices in the layout,
 86    then look them up with the osd_initiator library */
 87 struct nfs4_deviceid_node *
 88 objio_alloc_deviceid_node(struct nfs_server *server, struct pnfs_device *pdev,
 89                         gfp_t gfp_flags)
 90 {
 91         struct pnfs_osd_deviceaddr *deviceaddr;
 92         struct objio_dev_ent *ode = NULL;
 93         struct osd_dev *od;
 94         struct osd_dev_info odi;
 95         bool retry_flag = true;
 96         __be32 *p;
 97         int err;
 98 
 99         deviceaddr = kzalloc(sizeof(*deviceaddr), gfp_flags);
100         if (!deviceaddr)
101                 return NULL;
102 
103         p = page_address(pdev->pages[0]);
104         pnfs_osd_xdr_decode_deviceaddr(deviceaddr, p);
105 
106         odi.systemid_len = deviceaddr->oda_systemid.len;
107         if (odi.systemid_len > sizeof(odi.systemid)) {
108                 dprintk("%s: odi.systemid_len > sizeof(systemid=%zd)\n",
109                         __func__, sizeof(odi.systemid));
110                 err = -EINVAL;
111                 goto out;
112         } else if (odi.systemid_len)
113                 memcpy(odi.systemid, deviceaddr->oda_systemid.data,
114                        odi.systemid_len);
115         odi.osdname_len  = deviceaddr->oda_osdname.len;
116         odi.osdname      = (u8 *)deviceaddr->oda_osdname.data;
117 
118         if (!odi.osdname_len && !odi.systemid_len) {
119                 dprintk("%s: !odi.osdname_len && !odi.systemid_len\n",
120                         __func__);
121                 err = -ENODEV;
122                 goto out;
123         }
124 
125 retry_lookup:
126         od = osduld_info_lookup(&odi);
127         if (IS_ERR(od)) {
128                 err = PTR_ERR(od);
129                 dprintk("%s: osduld_info_lookup => %d\n", __func__, err);
130                 if (err == -ENODEV && retry_flag) {
131                         err = objlayout_autologin(deviceaddr);
132                         if (likely(!err)) {
133                                 retry_flag = false;
134                                 goto retry_lookup;
135                         }
136                 }
137                 goto out;
138         }
139 
140         dprintk("Adding new dev_id(%llx:%llx)\n",
141                 _DEVID_LO(&pdev->dev_id), _DEVID_HI(&pdev->dev_id));
142 
143         ode = kzalloc(sizeof(*ode), gfp_flags);
144         if (!ode) {
145                 dprintk("%s: -ENOMEM od=%p\n", __func__, od);
146                 goto out;
147         }
148 
149         nfs4_init_deviceid_node(&ode->id_node, server, &pdev->dev_id);
150         kfree(deviceaddr);
151 
152         ode->od.od = od;
153         return &ode->id_node;
154 
155 out:
156         kfree(deviceaddr);
157         return NULL;
158 }
159 
160 static void copy_single_comp(struct ore_components *oc, unsigned c,
161                              struct pnfs_osd_object_cred *src_comp)
162 {
163         struct ore_comp *ocomp = &oc->comps[c];
164 
165         WARN_ON(src_comp->oc_cap_key.cred_len > 0); /* libosd is NO_SEC only */
166         WARN_ON(src_comp->oc_cap.cred_len > sizeof(ocomp->cred));
167 
168         ocomp->obj.partition = src_comp->oc_object_id.oid_partition_id;
169         ocomp->obj.id = src_comp->oc_object_id.oid_object_id;
170 
171         memcpy(ocomp->cred, src_comp->oc_cap.cred, sizeof(ocomp->cred));
172 }
173 
174 static int __alloc_objio_seg(unsigned numdevs, gfp_t gfp_flags,
175                        struct objio_segment **pseg)
176 {
177 /*      This is the in memory structure of the objio_segment
178  *
179  *      struct __alloc_objio_segment {
180  *              struct objio_segment olseg;
181  *              struct ore_dev *ods[numdevs];
182  *              struct ore_comp comps[numdevs];
183  *      } *aolseg;
184  *      NOTE: The code as above compiles and runs perfectly. It is elegant,
185  *      type safe and compact. At some Past time Linus has decided he does not
186  *      like variable length arrays, For the sake of this principal we uglify
187  *      the code as below.
188  */
189         struct objio_segment *lseg;
190         size_t lseg_size = sizeof(*lseg) +
191                         numdevs * sizeof(lseg->oc.ods[0]) +
192                         numdevs * sizeof(*lseg->oc.comps);
193 
194         lseg = kzalloc(lseg_size, gfp_flags);
195         if (unlikely(!lseg)) {
196                 dprintk("%s: Failed allocation numdevs=%d size=%zd\n", __func__,
197                         numdevs, lseg_size);
198                 return -ENOMEM;
199         }
200 
201         lseg->oc.numdevs = numdevs;
202         lseg->oc.single_comp = EC_MULTPLE_COMPS;
203         lseg->oc.ods = (void *)(lseg + 1);
204         lseg->oc.comps = (void *)(lseg->oc.ods + numdevs);
205 
206         *pseg = lseg;
207         return 0;
208 }
209 
210 int objio_alloc_lseg(struct pnfs_layout_segment **outp,
211         struct pnfs_layout_hdr *pnfslay,
212         struct pnfs_layout_range *range,
213         struct xdr_stream *xdr,
214         gfp_t gfp_flags)
215 {
216         struct nfs_server *server = NFS_SERVER(pnfslay->plh_inode);
217         struct objio_segment *objio_seg;
218         struct pnfs_osd_xdr_decode_layout_iter iter;
219         struct pnfs_osd_layout layout;
220         struct pnfs_osd_object_cred src_comp;
221         unsigned cur_comp;
222         int err;
223 
224         err = pnfs_osd_xdr_decode_layout_map(&layout, &iter, xdr);
225         if (unlikely(err))
226                 return err;
227 
228         err = __alloc_objio_seg(layout.olo_num_comps, gfp_flags, &objio_seg);
229         if (unlikely(err))
230                 return err;
231 
232         objio_seg->layout.stripe_unit = layout.olo_map.odm_stripe_unit;
233         objio_seg->layout.group_width = layout.olo_map.odm_group_width;
234         objio_seg->layout.group_depth = layout.olo_map.odm_group_depth;
235         objio_seg->layout.mirrors_p1 = layout.olo_map.odm_mirror_cnt + 1;
236         objio_seg->layout.raid_algorithm = layout.olo_map.odm_raid_algorithm;
237 
238         err = ore_verify_layout(layout.olo_map.odm_num_comps,
239                                           &objio_seg->layout);
240         if (unlikely(err))
241                 goto err;
242 
243         objio_seg->oc.first_dev = layout.olo_comps_index;
244         cur_comp = 0;
245         while (pnfs_osd_xdr_decode_layout_comp(&src_comp, &iter, xdr, &err)) {
246                 struct nfs4_deviceid_node *d;
247                 struct objio_dev_ent *ode;
248 
249                 copy_single_comp(&objio_seg->oc, cur_comp, &src_comp);
250 
251                 d = nfs4_find_get_deviceid(server,
252                                 &src_comp.oc_object_id.oid_device_id,
253                                 pnfslay->plh_lc_cred, gfp_flags);
254                 if (!d) {
255                         err = -ENXIO;
256                         goto err;
257                 }
258 
259                 ode = container_of(d, struct objio_dev_ent, id_node);
260                 objio_seg->oc.ods[cur_comp++] = &ode->od;
261         }
262         /* pnfs_osd_xdr_decode_layout_comp returns false on error */
263         if (unlikely(err))
264                 goto err;
265 
266         *outp = &objio_seg->lseg;
267         return 0;
268 
269 err:
270         kfree(objio_seg);
271         dprintk("%s: Error: return %d\n", __func__, err);
272         *outp = NULL;
273         return err;
274 }
275 
276 void objio_free_lseg(struct pnfs_layout_segment *lseg)
277 {
278         int i;
279         struct objio_segment *objio_seg = OBJIO_LSEG(lseg);
280 
281         for (i = 0; i < objio_seg->oc.numdevs; i++) {
282                 struct ore_dev *od = objio_seg->oc.ods[i];
283                 struct objio_dev_ent *ode;
284 
285                 if (!od)
286                         break;
287                 ode = container_of(od, typeof(*ode), od);
288                 nfs4_put_deviceid_node(&ode->id_node);
289         }
290         kfree(objio_seg);
291 }
292 
293 static int
294 objio_alloc_io_state(struct pnfs_layout_hdr *pnfs_layout_type, bool is_reading,
295         struct pnfs_layout_segment *lseg, struct page **pages, unsigned pgbase,
296         loff_t offset, size_t count, void *rpcdata, gfp_t gfp_flags,
297         struct objio_state **outp)
298 {
299         struct objio_segment *objio_seg = OBJIO_LSEG(lseg);
300         struct ore_io_state *ios;
301         int ret;
302         struct __alloc_objio_state {
303                 struct objio_state objios;
304                 struct pnfs_osd_ioerr ioerrs[objio_seg->oc.numdevs];
305         } *aos;
306 
307         aos = kzalloc(sizeof(*aos), gfp_flags);
308         if (unlikely(!aos))
309                 return -ENOMEM;
310 
311         objlayout_init_ioerrs(&aos->objios.oir, objio_seg->oc.numdevs,
312                         aos->ioerrs, rpcdata, pnfs_layout_type);
313 
314         ret = ore_get_rw_state(&objio_seg->layout, &objio_seg->oc, is_reading,
315                                offset, count, &ios);
316         if (unlikely(ret)) {
317                 kfree(aos);
318                 return ret;
319         }
320 
321         ios->pages = pages;
322         ios->pgbase = pgbase;
323         ios->private = aos;
324         BUG_ON(ios->nr_pages > (pgbase + count + PAGE_SIZE - 1) >> PAGE_SHIFT);
325 
326         aos->objios.sync = 0;
327         aos->objios.ios = ios;
328         *outp = &aos->objios;
329         return 0;
330 }
331 
332 void objio_free_result(struct objlayout_io_res *oir)
333 {
334         struct objio_state *objios = container_of(oir, struct objio_state, oir);
335 
336         ore_put_io_state(objios->ios);
337         kfree(objios);
338 }
339 
340 static enum pnfs_osd_errno osd_pri_2_pnfs_err(enum osd_err_priority oep)
341 {
342         switch (oep) {
343         case OSD_ERR_PRI_NO_ERROR:
344                 return (enum pnfs_osd_errno)0;
345 
346         case OSD_ERR_PRI_CLEAR_PAGES:
347                 BUG_ON(1);
348                 return 0;
349 
350         case OSD_ERR_PRI_RESOURCE:
351                 return PNFS_OSD_ERR_RESOURCE;
352         case OSD_ERR_PRI_BAD_CRED:
353                 return PNFS_OSD_ERR_BAD_CRED;
354         case OSD_ERR_PRI_NO_ACCESS:
355                 return PNFS_OSD_ERR_NO_ACCESS;
356         case OSD_ERR_PRI_UNREACHABLE:
357                 return PNFS_OSD_ERR_UNREACHABLE;
358         case OSD_ERR_PRI_NOT_FOUND:
359                 return PNFS_OSD_ERR_NOT_FOUND;
360         case OSD_ERR_PRI_NO_SPACE:
361                 return PNFS_OSD_ERR_NO_SPACE;
362         default:
363                 WARN_ON(1);
364                 /* fallthrough */
365         case OSD_ERR_PRI_EIO:
366                 return PNFS_OSD_ERR_EIO;
367         }
368 }
369 
370 static void __on_dev_error(struct ore_io_state *ios,
371         struct ore_dev *od, unsigned dev_index, enum osd_err_priority oep,
372         u64 dev_offset, u64  dev_len)
373 {
374         struct objio_state *objios = ios->private;
375         struct pnfs_osd_objid pooid;
376         struct objio_dev_ent *ode = container_of(od, typeof(*ode), od);
377         /* FIXME: what to do with more-then-one-group layouts. We need to
378          * translate from ore_io_state index to oc->comps index
379          */
380         unsigned comp = dev_index;
381 
382         pooid.oid_device_id = ode->id_node.deviceid;
383         pooid.oid_partition_id = ios->oc->comps[comp].obj.partition;
384         pooid.oid_object_id = ios->oc->comps[comp].obj.id;
385 
386         objlayout_io_set_result(&objios->oir, comp,
387                                 &pooid, osd_pri_2_pnfs_err(oep),
388                                 dev_offset, dev_len, !ios->reading);
389 }
390 
391 /*
392  * read
393  */
394 static void _read_done(struct ore_io_state *ios, void *private)
395 {
396         struct objio_state *objios = private;
397         ssize_t status;
398         int ret = ore_check_io(ios, &__on_dev_error);
399 
400         /* FIXME: _io_free(ios) can we dealocate the libosd resources; */
401 
402         if (likely(!ret))
403                 status = ios->length;
404         else
405                 status = ret;
406 
407         objlayout_read_done(&objios->oir, status, objios->sync);
408 }
409 
410 int objio_read_pagelist(struct nfs_pgio_header *hdr)
411 {
412         struct objio_state *objios;
413         int ret;
414 
415         ret = objio_alloc_io_state(NFS_I(hdr->inode)->layout, true,
416                         hdr->lseg, hdr->args.pages, hdr->args.pgbase,
417                         hdr->args.offset, hdr->args.count, hdr,
418                         GFP_KERNEL, &objios);
419         if (unlikely(ret))
420                 return ret;
421 
422         objios->ios->done = _read_done;
423         dprintk("%s: offset=0x%llx length=0x%x\n", __func__,
424                 hdr->args.offset, hdr->args.count);
425         ret = ore_read(objios->ios);
426         if (unlikely(ret))
427                 objio_free_result(&objios->oir);
428         return ret;
429 }
430 
431 /*
432  * write
433  */
434 static void _write_done(struct ore_io_state *ios, void *private)
435 {
436         struct objio_state *objios = private;
437         ssize_t status;
438         int ret = ore_check_io(ios, &__on_dev_error);
439 
440         /* FIXME: _io_free(ios) can we dealocate the libosd resources; */
441 
442         if (likely(!ret)) {
443                 /* FIXME: should be based on the OSD's persistence model
444                  * See OSD2r05 Section 4.13 Data persistence model */
445                 objios->oir.committed = NFS_FILE_SYNC;
446                 status = ios->length;
447         } else {
448                 status = ret;
449         }
450 
451         objlayout_write_done(&objios->oir, status, objios->sync);
452 }
453 
454 static struct page *__r4w_get_page(void *priv, u64 offset, bool *uptodate)
455 {
456         struct objio_state *objios = priv;
457         struct nfs_pgio_header *hdr = objios->oir.rpcdata;
458         struct address_space *mapping = hdr->inode->i_mapping;
459         pgoff_t index = offset / PAGE_SIZE;
460         struct page *page;
461         loff_t i_size = i_size_read(hdr->inode);
462 
463         if (offset >= i_size) {
464                 *uptodate = true;
465                 dprintk("%s: g_zero_page index=0x%lx\n", __func__, index);
466                 return ZERO_PAGE(0);
467         }
468 
469         page = find_get_page(mapping, index);
470         if (!page) {
471                 page = find_or_create_page(mapping, index, GFP_NOFS);
472                 if (unlikely(!page)) {
473                         dprintk("%s: grab_cache_page Failed index=0x%lx\n",
474                                 __func__, index);
475                         return NULL;
476                 }
477                 unlock_page(page);
478         }
479         *uptodate = PageUptodate(page);
480         dprintk("%s: index=0x%lx uptodate=%d\n", __func__, index, *uptodate);
481         return page;
482 }
483 
484 static void __r4w_put_page(void *priv, struct page *page)
485 {
486         dprintk("%s: index=0x%lx\n", __func__,
487                 (page == ZERO_PAGE(0)) ? -1UL : page->index);
488         if (ZERO_PAGE(0) != page)
489                 put_page(page);
490         return;
491 }
492 
493 static const struct _ore_r4w_op _r4w_op = {
494         .get_page = &__r4w_get_page,
495         .put_page = &__r4w_put_page,
496 };
497 
498 int objio_write_pagelist(struct nfs_pgio_header *hdr, int how)
499 {
500         struct objio_state *objios;
501         int ret;
502 
503         ret = objio_alloc_io_state(NFS_I(hdr->inode)->layout, false,
504                         hdr->lseg, hdr->args.pages, hdr->args.pgbase,
505                         hdr->args.offset, hdr->args.count, hdr, GFP_NOFS,
506                         &objios);
507         if (unlikely(ret))
508                 return ret;
509 
510         objios->sync = 0 != (how & FLUSH_SYNC);
511         objios->ios->r4w = &_r4w_op;
512 
513         if (!objios->sync)
514                 objios->ios->done = _write_done;
515 
516         dprintk("%s: offset=0x%llx length=0x%x\n", __func__,
517                 hdr->args.offset, hdr->args.count);
518         ret = ore_write(objios->ios);
519         if (unlikely(ret)) {
520                 objio_free_result(&objios->oir);
521                 return ret;
522         }
523 
524         if (objios->sync)
525                 _write_done(objios->ios, objios);
526 
527         return 0;
528 }
529 
530 /*
531  * Return 0 if @req cannot be coalesced into @pgio, otherwise return the number
532  * of bytes (maximum @req->wb_bytes) that can be coalesced.
533  */
534 static size_t objio_pg_test(struct nfs_pageio_descriptor *pgio,
535                           struct nfs_page *prev, struct nfs_page *req)
536 {
537         struct nfs_pgio_mirror *mirror = nfs_pgio_current_mirror(pgio);
538         unsigned int size;
539 
540         size = pnfs_generic_pg_test(pgio, prev, req);
541 
542         if (!size || mirror->pg_count + req->wb_bytes >
543             (unsigned long)pgio->pg_layout_private)
544                 return 0;
545 
546         return min(size, req->wb_bytes);
547 }
548 
549 static void objio_init_read(struct nfs_pageio_descriptor *pgio, struct nfs_page *req)
550 {
551         pnfs_generic_pg_init_read(pgio, req);
552         if (unlikely(pgio->pg_lseg == NULL))
553                 return; /* Not pNFS */
554 
555         pgio->pg_layout_private = (void *)
556                                 OBJIO_LSEG(pgio->pg_lseg)->layout.max_io_length;
557 }
558 
559 static bool aligned_on_raid_stripe(u64 offset, struct ore_layout *layout,
560                                    unsigned long *stripe_end)
561 {
562         u32 stripe_off;
563         unsigned stripe_size;
564 
565         if (layout->raid_algorithm == PNFS_OSD_RAID_0)
566                 return true;
567 
568         stripe_size = layout->stripe_unit *
569                                 (layout->group_width - layout->parity);
570 
571         div_u64_rem(offset, stripe_size, &stripe_off);
572         if (!stripe_off)
573                 return true;
574 
575         *stripe_end = stripe_size - stripe_off;
576         return false;
577 }
578 
579 static void objio_init_write(struct nfs_pageio_descriptor *pgio, struct nfs_page *req)
580 {
581         unsigned long stripe_end = 0;
582         u64 wb_size;
583 
584         if (pgio->pg_dreq == NULL)
585                 wb_size = i_size_read(pgio->pg_inode) - req_offset(req);
586         else
587                 wb_size = nfs_dreq_bytes_left(pgio->pg_dreq);
588 
589         pnfs_generic_pg_init_write(pgio, req, wb_size);
590         if (unlikely(pgio->pg_lseg == NULL))
591                 return; /* Not pNFS */
592 
593         if (req->wb_offset ||
594             !aligned_on_raid_stripe(req->wb_index * PAGE_SIZE,
595                                &OBJIO_LSEG(pgio->pg_lseg)->layout,
596                                &stripe_end)) {
597                 pgio->pg_layout_private = (void *)stripe_end;
598         } else {
599                 pgio->pg_layout_private = (void *)
600                                 OBJIO_LSEG(pgio->pg_lseg)->layout.max_io_length;
601         }
602 }
603 
604 static const struct nfs_pageio_ops objio_pg_read_ops = {
605         .pg_init = objio_init_read,
606         .pg_test = objio_pg_test,
607         .pg_doio = pnfs_generic_pg_readpages,
608         .pg_cleanup = pnfs_generic_pg_cleanup,
609 };
610 
611 static const struct nfs_pageio_ops objio_pg_write_ops = {
612         .pg_init = objio_init_write,
613         .pg_test = objio_pg_test,
614         .pg_doio = pnfs_generic_pg_writepages,
615         .pg_cleanup = pnfs_generic_pg_cleanup,
616 };
617 
618 static struct pnfs_layoutdriver_type objlayout_type = {
619         .id = LAYOUT_OSD2_OBJECTS,
620         .name = "LAYOUT_OSD2_OBJECTS",
621         .flags                   = PNFS_LAYOUTRET_ON_SETATTR |
622                                    PNFS_LAYOUTRET_ON_ERROR,
623 
624         .max_deviceinfo_size     = PAGE_SIZE,
625         .owner                   = THIS_MODULE,
626         .alloc_layout_hdr        = objlayout_alloc_layout_hdr,
627         .free_layout_hdr         = objlayout_free_layout_hdr,
628 
629         .alloc_lseg              = objlayout_alloc_lseg,
630         .free_lseg               = objlayout_free_lseg,
631 
632         .read_pagelist           = objlayout_read_pagelist,
633         .write_pagelist          = objlayout_write_pagelist,
634         .pg_read_ops             = &objio_pg_read_ops,
635         .pg_write_ops            = &objio_pg_write_ops,
636 
637         .sync                    = pnfs_generic_sync,
638 
639         .free_deviceid_node      = objio_free_deviceid_node,
640 
641         .encode_layoutcommit     = objlayout_encode_layoutcommit,
642         .encode_layoutreturn     = objlayout_encode_layoutreturn,
643 };
644 
645 MODULE_DESCRIPTION("pNFS Layout Driver for OSD2 objects");
646 MODULE_AUTHOR("Benny Halevy <bhalevy@panasas.com>");
647 MODULE_LICENSE("GPL");
648 
649 static int __init
650 objlayout_init(void)
651 {
652         int ret = pnfs_register_layoutdriver(&objlayout_type);
653 
654         if (ret)
655                 printk(KERN_INFO
656                         "NFS: %s: Registering OSD pNFS Layout Driver failed: error=%d\n",
657                         __func__, ret);
658         else
659                 printk(KERN_INFO "NFS: %s: Registered OSD pNFS Layout Driver\n",
660                         __func__);
661         return ret;
662 }
663 
664 static void __exit
665 objlayout_exit(void)
666 {
667         pnfs_unregister_layoutdriver(&objlayout_type);
668         printk(KERN_INFO "NFS: %s: Unregistered OSD pNFS Layout Driver\n",
669                __func__);
670 }
671 
672 MODULE_ALIAS("nfs-layouttype4-2");
673 
674 module_init(objlayout_init);
675 module_exit(objlayout_exit);
676 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp