Home | History | Annotate | Download | only in reiserfs
      1 /*
      2     geom_dal.c -- parted device abstraction layer
      3     Copyright (C) 2001, 2002, 2007  Free Software Foundation, Inc.
      4 
      5     This program is free software; you can redistribute it and/or modify
      6     it under the terms of the GNU General Public License as published by
      7     the Free Software Foundation; either version 3 of the License, or
      8     (at your option) any later version.
      9 
     10     This program is distributed in the hope that it will be useful,
     11     but WITHOUT ANY WARRANTY; without even the implied warranty of
     12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     13     GNU General Public License for more details.
     14 
     15     You should have received a copy of the GNU General Public License
     16     along with this program.  If not, see <http://www.gnu.org/licenses/>.
     17 */
     18 
     19 #include <config.h>
     20 
     21 #if (DYNAMIC_LOADING || HAVE_LIBREISERFS) && !DISCOVER_ONLY
     22 
     23 #include "geom_dal.h"
     24 
     25 #include <parted/parted.h>
     26 #include <parted/debug.h>
     27 
     28 static blk_t __len(dal_t *dal) {
     29     PED_ASSERT(dal != NULL, return 0);
     30 
     31     return ((PedGeometry *)dal->dev)->length /
     32 	(dal->block_size / PED_SECTOR_SIZE_DEFAULT);
     33 }
     34 
     35 static int __read(dal_t *dal, void *buff, blk_t block, blk_t count) {
     36     blk_t k;
     37     PedSector block_pos;
     38     PedSector block_count;
     39 
     40     PED_ASSERT(dal != NULL, return 0);
     41 
     42     k = dal->block_size / PED_SECTOR_SIZE_DEFAULT;
     43     block_pos = (PedSector)(block * k);
     44     block_count = (PedSector)(count * k);
     45 
     46     return ped_geometry_read((PedGeometry *)dal->dev, buff, block_pos, block_count);
     47 }
     48 
     49 static int __write(dal_t *dal, void *buff, blk_t block, blk_t count) {
     50     blk_t k;
     51     PedSector block_pos;
     52     PedSector block_count;
     53 
     54     PED_ASSERT(dal != NULL, return 0);
     55 
     56     k = dal->block_size / PED_SECTOR_SIZE_DEFAULT;
     57     block_pos = (PedSector)(block * k);
     58     block_count = (PedSector)(count * k);
     59 
     60     return ped_geometry_write((PedGeometry *)dal->dev, buff, block_pos,
     61 	block_count);
     62 }
     63 
     64 static int __sync(dal_t *dal) {
     65     PED_ASSERT(dal != NULL, return 0);
     66     return ped_geometry_sync((PedGeometry *)dal->dev);
     67 }
     68 
     69 static int __flags(dal_t *dal) {
     70     PED_ASSERT(dal != NULL, return 0);
     71     return dal->flags;
     72 }
     73 
     74 static int __equals(dal_t *dal1, dal_t *dal2) {
     75     PED_ASSERT(dal1 != NULL, return 0);
     76     PED_ASSERT(dal2 != NULL, return 0);
     77 
     78     return ped_geometry_test_equal((PedGeometry *)dal1->dev,
     79 	(PedGeometry *)dal2->dev);
     80 }
     81 
     82 static int __stat(dal_t *dal, struct stat *st) {
     83 
     84     PED_ASSERT(dal != NULL, return 0);
     85     PED_ASSERT(st != NULL, return 0);
     86 
     87     if (stat(((PedGeometry *)dal->dev)->dev->path, st))
     88 	return 0;
     89 
     90     return 1;
     91 }
     92 
     93 static dev_t __dev(dal_t *dal) {
     94     struct stat st;
     95 
     96     if (!__stat(dal, &st))
     97 	return (dev_t)0;
     98 
     99     return st.st_dev;
    100 }
    101 
    102 static struct dal_ops ops = {
    103     __len, __read, __write, __sync,
    104     __flags, __equals, __stat, __dev
    105 };
    106 
    107 dal_t *geom_dal_create(PedGeometry *geom, size_t block_size, int flags) {
    108     dal_t *dal;
    109 
    110     if (!geom)
    111 	return NULL;
    112 
    113     if (!(dal = ped_malloc(sizeof(dal_t))))
    114 	return NULL;
    115 
    116     dal->ops = &ops;
    117     dal->dev = geom;
    118     dal->block_size = block_size;
    119     dal->flags = flags;
    120     dal->len = 0;
    121 
    122     return dal;
    123 }
    124 
    125 int geom_dal_reopen(dal_t *dal, int flags) {
    126 
    127     if (!dal) return 0;
    128     dal->flags = flags;
    129 
    130     return 1;
    131 }
    132 
    133 void geom_dal_free(dal_t *dal) {
    134     PED_ASSERT(dal != NULL, return);
    135     ped_free(dal);
    136 }
    137 
    138 #endif
    139