contrib/subversion/subversion/libsvn_fs_fs/temp_serializer.h

   1 /* temp_serializer.h : serialization functions for caching of FSFS structures
   2  *
   3  * ====================================================================
   4  *    Licensed to the Apache Software Foundation (ASF) under one
   5  *    or more contributor license agreements.  See the NOTICE file
   6  *    distributed with this work for additional information
   7  *    regarding copyright ownership.  The ASF licenses this file
   8  *    to you under the Apache License, Version 2.0 (the
   9  *    "License"); you may not use this file except in compliance
  10  *    with the License.  You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  *    Unless required by applicable law or agreed to in writing,
  15  *    software distributed under the License is distributed on an
  16  *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  *    KIND, either express or implied.  See the License for the
  18  *    specific language governing permissions and limitations
  19  *    under the License.
  20  * ====================================================================
  21  */
  22
  23 #ifndef SVN_LIBSVN_FS__TEMP_SERIALIZER_H
  24 #define SVN_LIBSVN_FS__TEMP_SERIALIZER_H
  25
  26 #include "fs.h"
  27
  28 /**
  29  * Prepend the @a number to the @a string in a space efficient way such that
  30  * no other (number,string) combination can produce the same result.
  31  * Allocate temporaries as well as the result from @a pool.
  32  */
  33 const char*
  34 svn_fs_fs__combine_number_and_string(apr_int64_t number,
  35                                      const char *string,
  36                                      apr_pool_t *pool);
  37
  38 /**
  39  * Serialize a @a noderev_p within the serialization @a context.
  40  */
  41 void
  42 svn_fs_fs__noderev_serialize(struct svn_temp_serializer__context_t *context,
  43                              node_revision_t * const *noderev_p);
  44
  45 /**
  46  * Deserialize a @a noderev_p within the @a buffer.
  47  */
  48 void
  49 svn_fs_fs__noderev_deserialize(void *buffer,
  50                                node_revision_t **noderev_p);
  51
  52
  53 /**
  54  * Adds position information to the raw window data in WINDOW.
  55  */
  56 typedef struct
  57 {
  58   /* the (unprocessed) txdelta window byte sequence cached / to be cached */
  59   svn_string_t window;
  60
  61   /* the offset within the representation right after reading the window */
  62   apr_off_t end_offset;
  63
  64   /* svndiff version */
  65   int ver;
  66 } svn_fs_fs__raw_cached_window_t;
  67
  68 /**
  69  * Implements #svn_cache__serialize_func_t for
  70  * #svn_fs_fs__raw_cached_window_t.
  71  */
  72 svn_error_t *
  73 svn_fs_fs__serialize_raw_window(void **buffer,
  74                                 apr_size_t *buffer_size,
  75                                 void *item,
  76                                 apr_pool_t *pool);
  77
  78 /**
  79  * Implements #svn_cache__deserialize_func_t for
  80  * #svn_fs_fs__raw_cached_window_t.
  81  */
  82 svn_error_t *
  83 svn_fs_fs__deserialize_raw_window(void **item,
  84                                   void *buffer,
  85                                   apr_size_t buffer_size,
  86                                   apr_pool_t *pool);
  87
  88 /**
  89  * #svn_txdelta_window_t is not sufficient for caching the data it
  90  * represents because data read process needs auxiliary information.
  91  */
  92 typedef struct
  93 {
  94   /* the txdelta window information cached / to be cached */
  95   svn_txdelta_window_t *window;
  96
  97   /* the revision file read pointer position right after reading the window */
  98   apr_off_t end_offset;
  99 } svn_fs_fs__txdelta_cached_window_t;
 100
 101 /**
 102  * Implements #svn_cache__serialize_func_t for
 103  * #svn_fs_fs__txdelta_cached_window_t.
 104  */
 105 svn_error_t *
 106 svn_fs_fs__serialize_txdelta_window(void **buffer,
 107                                     apr_size_t *buffer_size,
 108                                     void *item,
 109                                     apr_pool_t *pool);
 110
 111 /**
 112  * Implements #svn_cache__deserialize_func_t for
 113  * #svn_fs_fs__txdelta_cached_window_t.
 114  */
 115 svn_error_t *
 116 svn_fs_fs__deserialize_txdelta_window(void **item,
 117                                       void *buffer,
 118                                       apr_size_t buffer_size,
 119                                       apr_pool_t *pool);
 120
 121 /**
 122  * Implements #svn_cache__serialize_func_t for a manifest
 123  * (@a in is an #apr_array_header_t of apr_off_t elements).
 124  */
 125 svn_error_t *
 126 svn_fs_fs__serialize_manifest(void **data,
 127                               apr_size_t *data_len,
 128                               void *in,
 129                               apr_pool_t *pool);
 130
 131 /**
 132  * Implements #svn_cache__deserialize_func_t for a manifest
 133  * (@a *out is an #apr_array_header_t of apr_off_t elements).
 134  */
 135 svn_error_t *
 136 svn_fs_fs__deserialize_manifest(void **out,
 137                                 void *data,
 138                                 apr_size_t data_len,
 139                                 apr_pool_t *pool);
 140
 141 /**
 142  * Implements #svn_cache__serialize_func_t for a properties hash
 143  * (@a in is an #apr_hash_t of svn_string_t elements, keyed by const char*).
 144  */
 145 svn_error_t *
 146 svn_fs_fs__serialize_properties(void **data,
 147                                 apr_size_t *data_len,
 148                                 void *in,
 149                                 apr_pool_t *pool);
 150
 151 /**
 152  * Implements #svn_cache__deserialize_func_t for a properties hash
 153  * (@a *out is an #apr_hash_t of svn_string_t elements, keyed by const char*).
 154  */
 155 svn_error_t *
 156 svn_fs_fs__deserialize_properties(void **out,
 157                                   void *data,
 158                                   apr_size_t data_len,
 159                                   apr_pool_t *pool);
 160
 161 /**
 162  * Implements #svn_cache__serialize_func_t for a properties hash
 163  * (@a in is an #apr_hash_t of svn_string_t elements, keyed by const char*).
 164  */
 165 svn_error_t *
 166 svn_fs_fs__serialize_revprops(void **data,
 167                               apr_size_t *data_len,
 168                               void *in,
 169                               apr_pool_t *pool);
 170
 171 /**
 172  * Implements #svn_cache__deserialize_func_t for a properties hash
 173  * (@a *out is an #apr_hash_t of svn_string_t elements, keyed by const char*).
 174  */
 175 svn_error_t *
 176 svn_fs_fs__deserialize_revprops(void **out,
 177                                 void *data,
 178                                 apr_size_t data_len,
 179                                 apr_pool_t *pool);
 180
 181 /**
 182  * Implements #svn_cache__serialize_func_t for #svn_fs_id_t
 183  */
 184 svn_error_t *
 185 svn_fs_fs__serialize_id(void **data,
 186                         apr_size_t *data_len,
 187                         void *in,
 188                         apr_pool_t *pool);
 189
 190 /**
 191  * Implements #svn_cache__deserialize_func_t for #svn_fs_id_t
 192  */
 193 svn_error_t *
 194 svn_fs_fs__deserialize_id(void **out,
 195                           void *data,
 196                           apr_size_t data_len,
 197                           apr_pool_t *pool);
 198
 199 /**
 200  * Implements #svn_cache__serialize_func_t for #node_revision_t
 201  */
 202 svn_error_t *
 203 svn_fs_fs__serialize_node_revision(void **buffer,
 204                                    apr_size_t *buffer_size,
 205                                    void *item,
 206                                    apr_pool_t *pool);
 207
 208 /**
 209  * Implements #svn_cache__deserialize_func_t for #node_revision_t
 210  */
 211 svn_error_t *
 212 svn_fs_fs__deserialize_node_revision(void **item,
 213                                      void *buffer,
 214                                      apr_size_t buffer_size,
 215                                      apr_pool_t *pool);
 216
 217 /**
 218  * Implements #svn_cache__serialize_func_t for a #svn_fs_fs__dir_data_t
 219  */
 220 svn_error_t *
 221 svn_fs_fs__serialize_dir_entries(void **data,
 222                                  apr_size_t *data_len,
 223                                  void *in,
 224                                  apr_pool_t *pool);
 225
 226 /**
 227  * Same as svn_fs_fs__serialize_dir_entries but allocates extra room for
 228  * in-place modification.
 229  */
 230 svn_error_t *
 231 svn_fs_fs__serialize_txndir_entries(void **data,
 232                                     apr_size_t *data_len,
 233                                     void *in,
 234                                     apr_pool_t *pool);
 235
 236 /**
 237  * Implements #svn_cache__deserialize_func_t for a #svn_fs_fs__dir_data_t
 238  */
 239 svn_error_t *
 240 svn_fs_fs__deserialize_dir_entries(void **out,
 241                                    void *data,
 242                                    apr_size_t data_len,
 243                                    apr_pool_t *pool);
 244
 245 /**
 246  * Implements #svn_cache__partial_getter_func_t.  Set (apr_off_t) @a *out
 247  * to the element indexed by (apr_int64_t) @a *baton within the
 248  * serialized manifest array @a data and @a data_len. */
 249 svn_error_t *
 250 svn_fs_fs__get_sharded_offset(void **out,
 251                               const void *data,
 252                               apr_size_t data_len,
 253                               void *baton,
 254                               apr_pool_t *pool);
 255
 256 /**
 257  * Implements #svn_cache__partial_getter_func_t.
 258  * Set (svn_filesize_t) @a *out to the filesize info stored with the
 259  * serialized directory in @a data of @a data_len.  @a baton is unused.
 260  */
 261 svn_error_t *
 262 svn_fs_fs__extract_dir_filesize(void **out,
 263                                 const void *data,
 264                                 apr_size_t data_len,
 265                                 void *baton,
 266                                 apr_pool_t *pool);
 267
 268 /**
 269  * Describes the entry to be found in a directory: Identifies the entry
 270  * by @a name and requires the directory file size to be @a filesize.
 271  */
 272 typedef struct extract_dir_entry_baton_t
 273 {
 274   /** name of the directory entry to return */
 275   const char *name;
 276
 277   /** Current length of the in-txn in-disk representation of the directory.
 278    * SVN_INVALID_FILESIZE if unknown. */
 279   svn_filesize_t txn_filesize;
 280
 281   /** Will be set by the callback.  If FALSE, the cached data is out of date.
 282    * We need this indicator because the svn_cache__t interface will always
 283    * report the lookup as a success (FOUND==TRUE) if the generic lookup was
 284    * successful -- regardless of what the entry extraction callback does. */
 285   svn_boolean_t out_of_date;
 286 } extract_dir_entry_baton_t;
 287
 288
 289 /**
 290  * Implements #svn_cache__partial_getter_func_t for a single
 291  * #svn_fs_dirent_t within a serialized directory contents hash,
 292  * identified by its name (in (extract_dir_entry_baton_t *) @a *baton).
 293  * If the filesize specified in the baton does not match the cached
 294  * value for this directory, @a *out will be NULL as well.
 295  */
 296 svn_error_t *
 297 svn_fs_fs__extract_dir_entry(void **out,
 298                              const void *data,
 299                              apr_size_t data_len,
 300                              void *baton,
 301                              apr_pool_t *pool);
 302
 303 /**
 304  * Describes the change to be done to a directory: Set the entry
 305  * identify by @a name to the value @a new_entry. If the latter is
 306  * @c NULL, the entry shall be removed if it exists. Otherwise it
 307  * will be replaced or automatically added, respectively.  The
 308  * @a filesize allows readers to identify stale cache data (e.g.
 309  * due to concurrent access to txns); writers use it to update the
 310  * cached file size info.
 311  */
 312 typedef struct replace_baton_t
 313 {
 314   /** name of the directory entry to modify */
 315   const char *name;
 316
 317   /** directory entry to insert instead */
 318   svn_fs_dirent_t *new_entry;
 319
 320   /** Current length of the in-txn in-disk representation of the directory.
 321    * SVN_INVALID_FILESIZE if unknown. */
 322   svn_filesize_t txn_filesize;
 323 } replace_baton_t;
 324
 325 /**
 326  * Implements #svn_cache__partial_setter_func_t for a single
 327  * #svn_fs_dirent_t within a serialized directory contents hash,
 328  * identified by its name in the #replace_baton_t in @a baton.
 329  */
 330 svn_error_t *
 331 svn_fs_fs__replace_dir_entry(void **data,
 332                              apr_size_t *data_len,
 333                              void *baton,
 334                              apr_pool_t *pool);
 335
 336 /**
 337  * Implements #svn_cache__partial_setter_func_t for a #svn_fs_fs__dir_data_t
 338  * at @a *data, resetting its txn_filesize field to SVN_INVALID_FILESIZE.
 339  * &a baton should be NULL.
 340  */
 341 svn_error_t *
 342 svn_fs_fs__reset_txn_filesize(void **data,
 343                               apr_size_t *data_len,
 344                               void *baton,
 345                               apr_pool_t *pool);
 346
 347 /**
 348  * Implements #svn_cache__serialize_func_t for a #svn_fs_fs__rep_header_t.
 349  */
 350 svn_error_t *
 351 svn_fs_fs__serialize_rep_header(void **data,
 352                                 apr_size_t *data_len,
 353                                 void *in,
 354                                 apr_pool_t *pool);
 355
 356 /**
 357  * Implements #svn_cache__deserialize_func_t for a #svn_fs_fs__rep_header_t.
 358  */
 359 svn_error_t *
 360 svn_fs_fs__deserialize_rep_header(void **out,
 361                                   void *data,
 362                                   apr_size_t data_len,
 363                                   apr_pool_t *pool);
 364
 365 /*** Block of changes in a changed paths list. */
 366 typedef struct svn_fs_fs__changes_list_t
 367 {
 368   /* Offset of the first element in CHANGES within the changed paths list
 369      on disk. */
 370   apr_off_t start_offset;
 371
 372   /* Offset of the first element behind CHANGES within the changed paths
 373      list on disk. */
 374   apr_off_t end_offset;
 375
 376   /* End of list reached? This may have false negatives in case the number
 377      of elements in the list is a multiple of our block / range size. */
 378   svn_boolean_t eol;
 379
 380   /* Array of #svn_fs_x__change_t * representing a consecutive sub-range of
 381      elements in a changed paths list. */
 382
 383   /* number of entries in the array */
 384   int count;
 385
 386   /* reference to the changes */
 387   change_t **changes;
 388
 389 } svn_fs_fs__changes_list_t;
 390
 391 /**
 392  * Implements #svn_cache__serialize_func_t for a #svn_fs_fs__changes_list_t.
 393  */
 394 svn_error_t *
 395 svn_fs_fs__serialize_changes(void **data,
 396                              apr_size_t *data_len,
 397                              void *in,
 398                              apr_pool_t *pool);
 399
 400 /**
 401  * Implements #svn_cache__deserialize_func_t for a #svn_fs_fs__changes_list_t.
 402  */
 403 svn_error_t *
 404 svn_fs_fs__deserialize_changes(void **out,
 405                                void *data,
 406                                apr_size_t data_len,
 407                                apr_pool_t *pool);
 408
 409 /**
 410  * Implements #svn_cache__serialize_func_t for #svn_mergeinfo_t objects.
 411  */
 412 svn_error_t *
 413 svn_fs_fs__serialize_mergeinfo(void **data,
 414                                apr_size_t *data_len,
 415                                void *in,
 416                                apr_pool_t *pool);
 417
 418 /**
 419  * Implements #svn_cache__deserialize_func_t for #svn_mergeinfo_t objects.
 420  */
 421 svn_error_t *
 422 svn_fs_fs__deserialize_mergeinfo(void **out,
 423                                  void *data,
 424                                  apr_size_t data_len,
 425                                  apr_pool_t *pool);
 426
 427 #endif