sys/geom/part/g_part_if.m

   1 #-
   2 # Copyright (c) 2006-2009 Marcel Moolenaar
   3 # All rights reserved.
   4 #
   5 # Redistribution and use in source and binary forms, with or without
   6 # modification, are permitted provided that the following conditions
   7 # are met:
   8 #
   9 # 1. Redistributions of source code must retain the above copyright
  10 #    notice, this list of conditions and the following disclaimer.
  11 # 2. Redistributions in binary form must reproduce the above copyright
  12 #    notice, this list of conditions and the following disclaimer in the
  13 #    documentation and/or other materials provided with the distribution.
  14 #
  15 # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16 # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17 # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18 # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19 # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20 # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25 #
  26 # $FreeBSD$
  27
  28 #include <sys/param.h>
  29 #include <sys/lock.h>
  30 #include <sys/malloc.h>
  31 #include <sys/mutex.h>
  32 #include <sys/sbuf.h>
  33 #include <sys/bus.h>
  34 #include <machine/bus.h>
  35 #include <sys/systm.h>
  36 #include <geom/geom.h>
  37 #include <geom/part/g_part.h>
  38
  39 # The G_PART scheme interface.
  40
  41 INTERFACE g_part;
  42
  43 # Default implementations of methods.
  44 CODE {
  45         static void
  46         default_fullname(struct g_part_table *table,
  47             struct g_part_entry *entry, struct sbuf *sb, const char *pfx)
  48         {
  49                 char buf[32];
  50
  51                 sbuf_printf(sb, "%s%s%s", pfx, g_part_separator,
  52                     G_PART_NAME(table, entry, buf, sizeof(buf)));
  53         }
  54
  55         static struct g_provider *
  56         default_new_provider(struct g_part_table *table, struct g_geom *gp,
  57             struct g_part_entry *entry, const char *pfx)
  58         {
  59                 struct g_provider *ret;
  60                 struct sbuf *sb;
  61
  62                 sb = sbuf_new_auto();
  63                 G_PART_FULLNAME(table, entry, sb, pfx);
  64                 sbuf_finish(sb);
  65                 ret = g_new_providerf(gp, "%s", sbuf_data(sb));
  66                 sbuf_delete(sb);
  67                 return (ret);
  68         }
  69
  70         static void
  71         default_add_alias(struct g_part_table *table, struct g_provider *pp,
  72             struct g_part_entry *entry, const char *pfx)
  73         {
  74                 struct sbuf *sb;
  75
  76                 sb = sbuf_new_auto();
  77                 G_PART_FULLNAME(table, entry, sb, pfx);
  78                 sbuf_finish(sb);
  79                 g_provider_add_alias(pp, "%s", sbuf_data(sb));
  80                 sbuf_delete(sb);
  81         }
  82
  83         static int
  84         default_precheck(struct g_part_table *t __unused,
  85             enum g_part_ctl r __unused, struct g_part_parms *p __unused)
  86         {
  87                 return (0);
  88         }
  89
  90         static int
  91         default_resize(struct g_part_table *t __unused,
  92             struct g_part_entry *e __unused, struct g_part_parms *p __unused)
  93         {
  94                 return (ENOSYS);
  95         }
  96
  97         static int
  98         default_recover(struct g_part_table *t __unused)
  99         {
 100                 return (ENOSYS);
 101         }
 102
 103         static int
 104         default_ioctl(struct g_part_table *table __unused, struct g_provider *pp __unused,
 105             u_long cmd __unused, void *data __unused, int fflag __unused,
 106             struct thread *td __unused)
 107         {
 108                 return (ENOIOCTL);
 109         }
 110
 111         static int
 112         default_getattr(struct g_part_table *table __unused,
 113             struct g_part_entry *entry __unused, struct bio *bp __unused)
 114         {
 115                 return (ENOIOCTL);
 116         }
 117 };
 118
 119 # add() - scheme specific processing for the add verb.
 120 METHOD int add {
 121         struct g_part_table *table;
 122         struct g_part_entry *entry;
 123         struct g_part_parms *gpp;
 124 };
 125
 126 # add_alias() - Create aliases for the partition's provider with the given
 127 # alias prefixes.
 128 METHOD void add_alias {
 129         struct g_part_table *table;
 130         struct g_provider *pp;
 131         struct g_part_entry *entry;
 132         const char *pfx;
 133 } DEFAULT default_add_alias;
 134
 135 # bootcode() - scheme specific processing for the bootcode verb.
 136 METHOD int bootcode {
 137         struct g_part_table *table;
 138         struct g_part_parms *gpp;
 139 };
 140
 141 # create() - scheme specific processing for the create verb.
 142 METHOD int create {
 143         struct g_part_table *table;
 144         struct g_part_parms *gpp;
 145 };
 146
 147 # destroy() - scheme specific processing for the destroy verb.
 148 METHOD int destroy {
 149         struct g_part_table *table;
 150         struct g_part_parms *gpp;
 151 };
 152
 153 # dumpconf()
 154 METHOD void dumpconf {
 155         struct g_part_table *table;
 156         struct g_part_entry *entry;
 157         struct sbuf *sb;
 158         const char *indent;
 159 };
 160
 161 # dumpto() - return whether the partition can be used for kernel dumps.
 162 METHOD int dumpto {
 163         struct g_part_table *table;
 164         struct g_part_entry *entry;
 165 };
 166
 167 # fullname() - write the name of the given partition entry to the sbuf.
 168 METHOD void fullname {
 169         struct g_part_table *table;
 170         struct g_part_entry *entry;
 171         struct sbuf *sb;
 172         const char *pfx;
 173 } DEFAULT default_fullname;
 174
 175 # ioctl() - implement historic ioctls, perhaps.
 176 METHOD int ioctl {
 177         struct g_part_table *table;
 178         struct g_provider *pp;
 179         u_long cmd;
 180         void *data;
 181         int fflag;
 182         struct thread *td;
 183 } DEFAULT default_ioctl;
 184
 185 # modify() - scheme specific processing for the modify verb.
 186 METHOD int modify {
 187         struct g_part_table *table;
 188         struct g_part_entry *entry;
 189         struct g_part_parms *gpp;
 190 };
 191
 192 # new_provider() - Create the partition's provider(s).
 193 METHOD struct g_provider * new_provider {
 194         struct g_part_table *table;
 195         struct g_geom *gp;
 196         struct g_part_entry *entry;
 197         const char *pfx;
 198 } DEFAULT default_new_provider;
 199
 200 # resize() - scheme specific processing for the resize verb.
 201 METHOD int resize {
 202         struct g_part_table *table;
 203         struct g_part_entry *entry;
 204         struct g_part_parms *gpp;
 205 } DEFAULT default_resize;
 206
 207 # name() - return the name of the given partition entry.
 208 # Typical names are "p1", "s0" or "c".
 209 METHOD const char * name {
 210         struct g_part_table *table;
 211         struct g_part_entry *entry;
 212         char *buf;
 213         size_t bufsz;
 214 };
 215
 216 # precheck() - method to allow schemes to check the parameters given
 217 # to the mentioned ctl request. This only applies to the requests that
 218 # operate on a GEOM. In other words, it does not apply to the create
 219 # request.
 220 # It is allowed (intended actually) to change the parameters according
 221 # to the schemes needs before they are used. Returning an error will
 222 # terminate the request immediately.
 223 METHOD int precheck {
 224         struct g_part_table *table;
 225         enum g_part_ctl req;
 226         struct g_part_parms *gpp;
 227 } DEFAULT default_precheck;
 228
 229 # probe() - probe the provider attached to the given consumer for the
 230 # existence of the scheme implemented by the G_PART interface handler.
 231 METHOD int probe {
 232         struct g_part_table *table;
 233         struct g_consumer *cp;
 234 };
 235
 236 # read() - read the on-disk partition table into memory.
 237 METHOD int read {
 238         struct g_part_table *table;
 239         struct g_consumer *cp;
 240 };
 241
 242 # recover() - scheme specific processing for the recover verb.
 243 METHOD int recover {
 244         struct g_part_table *table;
 245 } DEFAULT default_recover;
 246
 247 # setunset() - set or unset partition entry attributes.
 248 METHOD int setunset {
 249         struct g_part_table *table;
 250         struct g_part_entry *entry;
 251         const char *attrib;
 252         unsigned int set;
 253 };
 254
 255 # type() - return a string representation of the partition type.
 256 # Preferably, the alias names.
 257 METHOD const char * type {
 258         struct g_part_table *table;
 259         struct g_part_entry *entry;
 260         char *buf;
 261         size_t bufsz;
 262 };
 263
 264 # write() - write the in-memory partition table to disk.
 265 METHOD int write {
 266         struct g_part_table *table;
 267         struct g_consumer *cp;
 268 };
 269
 270 # getattr() - get the specified attribute, if any
 271 METHOD int getattr {
 272         struct g_part_table *table;
 273         struct g_part_entry *entry;
 274         struct bio *bp;
 275 } DEFAULT default_getattr;