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

TOMOYO Linux Cross Reference
Linux/fs/xfs/libxfs/xfs_btree.h

Version: ~ [ linux-5.10-rc6 ] ~ [ linux-5.9.12 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.81 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.161 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.210 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.247 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.247 ] ~ [ 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.85 ] ~ [ 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-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 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
  4  * All Rights Reserved.
  5  */
  6 #ifndef __XFS_BTREE_H__
  7 #define __XFS_BTREE_H__
  8 
  9 struct xfs_buf;
 10 struct xfs_inode;
 11 struct xfs_mount;
 12 struct xfs_trans;
 13 
 14 extern kmem_zone_t      *xfs_btree_cur_zone;
 15 
 16 /*
 17  * Generic key, ptr and record wrapper structures.
 18  *
 19  * These are disk format structures, and are converted where necessary
 20  * by the btree specific code that needs to interpret them.
 21  */
 22 union xfs_btree_ptr {
 23         __be32                  s;      /* short form ptr */
 24         __be64                  l;      /* long form ptr */
 25 };
 26 
 27 /*
 28  * The in-core btree key.  Overlapping btrees actually store two keys
 29  * per pointer, so we reserve enough memory to hold both.  The __*bigkey
 30  * items should never be accessed directly.
 31  */
 32 union xfs_btree_key {
 33         struct xfs_bmbt_key             bmbt;
 34         xfs_bmdr_key_t                  bmbr;   /* bmbt root block */
 35         xfs_alloc_key_t                 alloc;
 36         struct xfs_inobt_key            inobt;
 37         struct xfs_rmap_key             rmap;
 38         struct xfs_rmap_key             __rmap_bigkey[2];
 39         struct xfs_refcount_key         refc;
 40 };
 41 
 42 union xfs_btree_rec {
 43         struct xfs_bmbt_rec             bmbt;
 44         xfs_bmdr_rec_t                  bmbr;   /* bmbt root block */
 45         struct xfs_alloc_rec            alloc;
 46         struct xfs_inobt_rec            inobt;
 47         struct xfs_rmap_rec             rmap;
 48         struct xfs_refcount_rec         refc;
 49 };
 50 
 51 /*
 52  * This nonsense is to make -wlint happy.
 53  */
 54 #define XFS_LOOKUP_EQ   ((xfs_lookup_t)XFS_LOOKUP_EQi)
 55 #define XFS_LOOKUP_LE   ((xfs_lookup_t)XFS_LOOKUP_LEi)
 56 #define XFS_LOOKUP_GE   ((xfs_lookup_t)XFS_LOOKUP_GEi)
 57 
 58 #define XFS_BTNUM_BNO   ((xfs_btnum_t)XFS_BTNUM_BNOi)
 59 #define XFS_BTNUM_CNT   ((xfs_btnum_t)XFS_BTNUM_CNTi)
 60 #define XFS_BTNUM_BMAP  ((xfs_btnum_t)XFS_BTNUM_BMAPi)
 61 #define XFS_BTNUM_INO   ((xfs_btnum_t)XFS_BTNUM_INOi)
 62 #define XFS_BTNUM_FINO  ((xfs_btnum_t)XFS_BTNUM_FINOi)
 63 #define XFS_BTNUM_RMAP  ((xfs_btnum_t)XFS_BTNUM_RMAPi)
 64 #define XFS_BTNUM_REFC  ((xfs_btnum_t)XFS_BTNUM_REFCi)
 65 
 66 uint32_t xfs_btree_magic(int crc, xfs_btnum_t btnum);
 67 
 68 /*
 69  * For logging record fields.
 70  */
 71 #define XFS_BB_MAGIC            (1 << 0)
 72 #define XFS_BB_LEVEL            (1 << 1)
 73 #define XFS_BB_NUMRECS          (1 << 2)
 74 #define XFS_BB_LEFTSIB          (1 << 3)
 75 #define XFS_BB_RIGHTSIB         (1 << 4)
 76 #define XFS_BB_BLKNO            (1 << 5)
 77 #define XFS_BB_LSN              (1 << 6)
 78 #define XFS_BB_UUID             (1 << 7)
 79 #define XFS_BB_OWNER            (1 << 8)
 80 #define XFS_BB_NUM_BITS         5
 81 #define XFS_BB_ALL_BITS         ((1 << XFS_BB_NUM_BITS) - 1)
 82 #define XFS_BB_NUM_BITS_CRC     9
 83 #define XFS_BB_ALL_BITS_CRC     ((1 << XFS_BB_NUM_BITS_CRC) - 1)
 84 
 85 /*
 86  * Generic stats interface
 87  */
 88 #define XFS_BTREE_STATS_INC(cur, stat)  \
 89         XFS_STATS_INC_OFF((cur)->bc_mp, (cur)->bc_statoff + __XBTS_ ## stat)
 90 #define XFS_BTREE_STATS_ADD(cur, stat, val)     \
 91         XFS_STATS_ADD_OFF((cur)->bc_mp, (cur)->bc_statoff + __XBTS_ ## stat, val)
 92 
 93 #define XFS_BTREE_MAXLEVELS     9       /* max of all btrees */
 94 
 95 struct xfs_btree_ops {
 96         /* size of the key and record structures */
 97         size_t  key_len;
 98         size_t  rec_len;
 99 
100         /* cursor operations */
101         struct xfs_btree_cur *(*dup_cursor)(struct xfs_btree_cur *);
102         void    (*update_cursor)(struct xfs_btree_cur *src,
103                                  struct xfs_btree_cur *dst);
104 
105         /* update btree root pointer */
106         void    (*set_root)(struct xfs_btree_cur *cur,
107                             union xfs_btree_ptr *nptr, int level_change);
108 
109         /* block allocation / freeing */
110         int     (*alloc_block)(struct xfs_btree_cur *cur,
111                                union xfs_btree_ptr *start_bno,
112                                union xfs_btree_ptr *new_bno,
113                                int *stat);
114         int     (*free_block)(struct xfs_btree_cur *cur, struct xfs_buf *bp);
115 
116         /* update last record information */
117         void    (*update_lastrec)(struct xfs_btree_cur *cur,
118                                   struct xfs_btree_block *block,
119                                   union xfs_btree_rec *rec,
120                                   int ptr, int reason);
121 
122         /* records in block/level */
123         int     (*get_minrecs)(struct xfs_btree_cur *cur, int level);
124         int     (*get_maxrecs)(struct xfs_btree_cur *cur, int level);
125 
126         /* records on disk.  Matter for the root in inode case. */
127         int     (*get_dmaxrecs)(struct xfs_btree_cur *cur, int level);
128 
129         /* init values of btree structures */
130         void    (*init_key_from_rec)(union xfs_btree_key *key,
131                                      union xfs_btree_rec *rec);
132         void    (*init_rec_from_cur)(struct xfs_btree_cur *cur,
133                                      union xfs_btree_rec *rec);
134         void    (*init_ptr_from_cur)(struct xfs_btree_cur *cur,
135                                      union xfs_btree_ptr *ptr);
136         void    (*init_high_key_from_rec)(union xfs_btree_key *key,
137                                           union xfs_btree_rec *rec);
138 
139         /* difference between key value and cursor value */
140         int64_t (*key_diff)(struct xfs_btree_cur *cur,
141                               union xfs_btree_key *key);
142 
143         /*
144          * Difference between key2 and key1 -- positive if key1 > key2,
145          * negative if key1 < key2, and zero if equal.
146          */
147         int64_t (*diff_two_keys)(struct xfs_btree_cur *cur,
148                                    union xfs_btree_key *key1,
149                                    union xfs_btree_key *key2);
150 
151         const struct xfs_buf_ops        *buf_ops;
152 
153         /* check that k1 is lower than k2 */
154         int     (*keys_inorder)(struct xfs_btree_cur *cur,
155                                 union xfs_btree_key *k1,
156                                 union xfs_btree_key *k2);
157 
158         /* check that r1 is lower than r2 */
159         int     (*recs_inorder)(struct xfs_btree_cur *cur,
160                                 union xfs_btree_rec *r1,
161                                 union xfs_btree_rec *r2);
162 };
163 
164 /*
165  * Reasons for the update_lastrec method to be called.
166  */
167 #define LASTREC_UPDATE  0
168 #define LASTREC_INSREC  1
169 #define LASTREC_DELREC  2
170 
171 
172 union xfs_btree_irec {
173         struct xfs_alloc_rec_incore     a;
174         struct xfs_bmbt_irec            b;
175         struct xfs_inobt_rec_incore     i;
176         struct xfs_rmap_irec            r;
177         struct xfs_refcount_irec        rc;
178 };
179 
180 /* Per-AG btree private information. */
181 union xfs_btree_cur_private {
182         struct {
183                 unsigned long   nr_ops;         /* # record updates */
184                 int             shape_changes;  /* # of extent splits */
185         } refc;
186 };
187 
188 /*
189  * Btree cursor structure.
190  * This collects all information needed by the btree code in one place.
191  */
192 typedef struct xfs_btree_cur
193 {
194         struct xfs_trans        *bc_tp; /* transaction we're in, if any */
195         struct xfs_mount        *bc_mp; /* file system mount struct */
196         const struct xfs_btree_ops *bc_ops;
197         uint                    bc_flags; /* btree features - below */
198         union xfs_btree_irec    bc_rec; /* current insert/search record value */
199         struct xfs_buf  *bc_bufs[XFS_BTREE_MAXLEVELS];  /* buf ptr per level */
200         int             bc_ptrs[XFS_BTREE_MAXLEVELS];   /* key/record # */
201         uint8_t         bc_ra[XFS_BTREE_MAXLEVELS];     /* readahead bits */
202 #define XFS_BTCUR_LEFTRA        1       /* left sibling has been read-ahead */
203 #define XFS_BTCUR_RIGHTRA       2       /* right sibling has been read-ahead */
204         uint8_t         bc_nlevels;     /* number of levels in the tree */
205         uint8_t         bc_blocklog;    /* log2(blocksize) of btree blocks */
206         xfs_btnum_t     bc_btnum;       /* identifies which btree type */
207         int             bc_statoff;     /* offset of btre stats array */
208         union {
209                 struct {                        /* needed for BNO, CNT, INO */
210                         struct xfs_buf  *agbp;  /* agf/agi buffer pointer */
211                         xfs_agnumber_t  agno;   /* ag number */
212                         union xfs_btree_cur_private     priv;
213                 } a;
214                 struct {                        /* needed for BMAP */
215                         struct xfs_inode *ip;   /* pointer to our inode */
216                         int             allocated;      /* count of alloced */
217                         short           forksize;       /* fork's inode space */
218                         char            whichfork;      /* data or attr fork */
219                         char            flags;          /* flags */
220 #define XFS_BTCUR_BPRV_WASDEL           (1<<0)          /* was delayed */
221 #define XFS_BTCUR_BPRV_INVALID_OWNER    (1<<1)          /* for ext swap */
222                 } b;
223         }               bc_private;     /* per-btree type data */
224 } xfs_btree_cur_t;
225 
226 /* cursor flags */
227 #define XFS_BTREE_LONG_PTRS             (1<<0)  /* pointers are 64bits long */
228 #define XFS_BTREE_ROOT_IN_INODE         (1<<1)  /* root may be variable size */
229 #define XFS_BTREE_LASTREC_UPDATE        (1<<2)  /* track last rec externally */
230 #define XFS_BTREE_CRC_BLOCKS            (1<<3)  /* uses extended btree blocks */
231 #define XFS_BTREE_OVERLAPPING           (1<<4)  /* overlapping intervals */
232 
233 
234 #define XFS_BTREE_NOERROR       0
235 #define XFS_BTREE_ERROR         1
236 
237 /*
238  * Convert from buffer to btree block header.
239  */
240 #define XFS_BUF_TO_BLOCK(bp)    ((struct xfs_btree_block *)((bp)->b_addr))
241 
242 /*
243  * Internal long and short btree block checks.  They return NULL if the
244  * block is ok or the address of the failed check otherwise.
245  */
246 xfs_failaddr_t __xfs_btree_check_lblock(struct xfs_btree_cur *cur,
247                 struct xfs_btree_block *block, int level, struct xfs_buf *bp);
248 xfs_failaddr_t __xfs_btree_check_sblock(struct xfs_btree_cur *cur,
249                 struct xfs_btree_block *block, int level, struct xfs_buf *bp);
250 
251 /*
252  * Check that block header is ok.
253  */
254 int
255 xfs_btree_check_block(
256         struct xfs_btree_cur    *cur,   /* btree cursor */
257         struct xfs_btree_block  *block, /* generic btree block pointer */
258         int                     level,  /* level of the btree block */
259         struct xfs_buf          *bp);   /* buffer containing block, if any */
260 
261 /*
262  * Check that (long) pointer is ok.
263  */
264 bool                                    /* error (0 or EFSCORRUPTED) */
265 xfs_btree_check_lptr(
266         struct xfs_btree_cur    *cur,   /* btree cursor */
267         xfs_fsblock_t           fsbno,  /* btree block disk address */
268         int                     level); /* btree block level */
269 
270 /*
271  * Check that (short) pointer is ok.
272  */
273 bool                                    /* error (0 or EFSCORRUPTED) */
274 xfs_btree_check_sptr(
275         struct xfs_btree_cur    *cur,   /* btree cursor */
276         xfs_agblock_t           agbno,  /* btree block disk address */
277         int                     level); /* btree block level */
278 
279 /*
280  * Delete the btree cursor.
281  */
282 void
283 xfs_btree_del_cursor(
284         xfs_btree_cur_t         *cur,   /* btree cursor */
285         int                     error); /* del because of error */
286 
287 /*
288  * Duplicate the btree cursor.
289  * Allocate a new one, copy the record, re-get the buffers.
290  */
291 int                                     /* error */
292 xfs_btree_dup_cursor(
293         xfs_btree_cur_t         *cur,   /* input cursor */
294         xfs_btree_cur_t         **ncur);/* output cursor */
295 
296 /*
297  * Get a buffer for the block, return it with no data read.
298  * Long-form addressing.
299  */
300 struct xfs_buf *                                /* buffer for fsbno */
301 xfs_btree_get_bufl(
302         struct xfs_mount        *mp,    /* file system mount point */
303         struct xfs_trans        *tp,    /* transaction pointer */
304         xfs_fsblock_t           fsbno); /* file system block number */
305 
306 /*
307  * Get a buffer for the block, return it with no data read.
308  * Short-form addressing.
309  */
310 struct xfs_buf *                                /* buffer for agno/agbno */
311 xfs_btree_get_bufs(
312         struct xfs_mount        *mp,    /* file system mount point */
313         struct xfs_trans        *tp,    /* transaction pointer */
314         xfs_agnumber_t          agno,   /* allocation group number */
315         xfs_agblock_t           agbno); /* allocation group block number */
316 
317 /*
318  * Check for the cursor referring to the last block at the given level.
319  */
320 int                                     /* 1=is last block, 0=not last block */
321 xfs_btree_islastblock(
322         xfs_btree_cur_t         *cur,   /* btree cursor */
323         int                     level); /* level to check */
324 
325 /*
326  * Compute first and last byte offsets for the fields given.
327  * Interprets the offsets table, which contains struct field offsets.
328  */
329 void
330 xfs_btree_offsets(
331         int64_t                 fields, /* bitmask of fields */
332         const short             *offsets,/* table of field offsets */
333         int                     nbits,  /* number of bits to inspect */
334         int                     *first, /* output: first byte offset */
335         int                     *last); /* output: last byte offset */
336 
337 /*
338  * Get a buffer for the block, return it read in.
339  * Long-form addressing.
340  */
341 int                                     /* error */
342 xfs_btree_read_bufl(
343         struct xfs_mount        *mp,    /* file system mount point */
344         struct xfs_trans        *tp,    /* transaction pointer */
345         xfs_fsblock_t           fsbno,  /* file system block number */
346         struct xfs_buf          **bpp,  /* buffer for fsbno */
347         int                     refval, /* ref count value for buffer */
348         const struct xfs_buf_ops *ops);
349 
350 /*
351  * Read-ahead the block, don't wait for it, don't return a buffer.
352  * Long-form addressing.
353  */
354 void                                    /* error */
355 xfs_btree_reada_bufl(
356         struct xfs_mount        *mp,    /* file system mount point */
357         xfs_fsblock_t           fsbno,  /* file system block number */
358         xfs_extlen_t            count,  /* count of filesystem blocks */
359         const struct xfs_buf_ops *ops);
360 
361 /*
362  * Read-ahead the block, don't wait for it, don't return a buffer.
363  * Short-form addressing.
364  */
365 void                                    /* error */
366 xfs_btree_reada_bufs(
367         struct xfs_mount        *mp,    /* file system mount point */
368         xfs_agnumber_t          agno,   /* allocation group number */
369         xfs_agblock_t           agbno,  /* allocation group block number */
370         xfs_extlen_t            count,  /* count of filesystem blocks */
371         const struct xfs_buf_ops *ops);
372 
373 /*
374  * Initialise a new btree block header
375  */
376 void
377 xfs_btree_init_block(
378         struct xfs_mount *mp,
379         struct xfs_buf  *bp,
380         xfs_btnum_t     btnum,
381         __u16           level,
382         __u16           numrecs,
383         __u64           owner);
384 
385 void
386 xfs_btree_init_block_int(
387         struct xfs_mount        *mp,
388         struct xfs_btree_block  *buf,
389         xfs_daddr_t             blkno,
390         xfs_btnum_t             btnum,
391         __u16                   level,
392         __u16                   numrecs,
393         __u64                   owner,
394         unsigned int            flags);
395 
396 /*
397  * Common btree core entry points.
398  */
399 int xfs_btree_increment(struct xfs_btree_cur *, int, int *);
400 int xfs_btree_decrement(struct xfs_btree_cur *, int, int *);
401 int xfs_btree_lookup(struct xfs_btree_cur *, xfs_lookup_t, int *);
402 int xfs_btree_update(struct xfs_btree_cur *, union xfs_btree_rec *);
403 int xfs_btree_new_iroot(struct xfs_btree_cur *, int *, int *);
404 int xfs_btree_insert(struct xfs_btree_cur *, int *);
405 int xfs_btree_delete(struct xfs_btree_cur *, int *);
406 int xfs_btree_get_rec(struct xfs_btree_cur *, union xfs_btree_rec **, int *);
407 int xfs_btree_change_owner(struct xfs_btree_cur *cur, uint64_t new_owner,
408                            struct list_head *buffer_list);
409 
410 /*
411  * btree block CRC helpers
412  */
413 void xfs_btree_lblock_calc_crc(struct xfs_buf *);
414 bool xfs_btree_lblock_verify_crc(struct xfs_buf *);
415 void xfs_btree_sblock_calc_crc(struct xfs_buf *);
416 bool xfs_btree_sblock_verify_crc(struct xfs_buf *);
417 
418 /*
419  * Internal btree helpers also used by xfs_bmap.c.
420  */
421 void xfs_btree_log_block(struct xfs_btree_cur *, struct xfs_buf *, int);
422 void xfs_btree_log_recs(struct xfs_btree_cur *, struct xfs_buf *, int, int);
423 
424 /*
425  * Helpers.
426  */
427 static inline int xfs_btree_get_numrecs(struct xfs_btree_block *block)
428 {
429         return be16_to_cpu(block->bb_numrecs);
430 }
431 
432 static inline void xfs_btree_set_numrecs(struct xfs_btree_block *block,
433                 uint16_t numrecs)
434 {
435         block->bb_numrecs = cpu_to_be16(numrecs);
436 }
437 
438 static inline int xfs_btree_get_level(struct xfs_btree_block *block)
439 {
440         return be16_to_cpu(block->bb_level);
441 }
442 
443 
444 /*
445  * Min and max functions for extlen, agblock, fileoff, and filblks types.
446  */
447 #define XFS_EXTLEN_MIN(a,b)     min_t(xfs_extlen_t, (a), (b))
448 #define XFS_EXTLEN_MAX(a,b)     max_t(xfs_extlen_t, (a), (b))
449 #define XFS_AGBLOCK_MIN(a,b)    min_t(xfs_agblock_t, (a), (b))
450 #define XFS_AGBLOCK_MAX(a,b)    max_t(xfs_agblock_t, (a), (b))
451 #define XFS_FILEOFF_MIN(a,b)    min_t(xfs_fileoff_t, (a), (b))
452 #define XFS_FILEOFF_MAX(a,b)    max_t(xfs_fileoff_t, (a), (b))
453 #define XFS_FILBLKS_MIN(a,b)    min_t(xfs_filblks_t, (a), (b))
454 #define XFS_FILBLKS_MAX(a,b)    max_t(xfs_filblks_t, (a), (b))
455 
456 xfs_failaddr_t xfs_btree_sblock_v5hdr_verify(struct xfs_buf *bp);
457 xfs_failaddr_t xfs_btree_sblock_verify(struct xfs_buf *bp,
458                 unsigned int max_recs);
459 xfs_failaddr_t xfs_btree_lblock_v5hdr_verify(struct xfs_buf *bp,
460                 uint64_t owner);
461 xfs_failaddr_t xfs_btree_lblock_verify(struct xfs_buf *bp,
462                 unsigned int max_recs);
463 
464 uint xfs_btree_compute_maxlevels(uint *limits, unsigned long len);
465 unsigned long long xfs_btree_calc_size(uint *limits, unsigned long long len);
466 
467 /* return codes */
468 #define XFS_BTREE_QUERY_RANGE_CONTINUE  (XFS_ITER_CONTINUE) /* keep iterating */
469 #define XFS_BTREE_QUERY_RANGE_ABORT     (XFS_ITER_ABORT)    /* stop iterating */
470 typedef int (*xfs_btree_query_range_fn)(struct xfs_btree_cur *cur,
471                 union xfs_btree_rec *rec, void *priv);
472 
473 int xfs_btree_query_range(struct xfs_btree_cur *cur,
474                 union xfs_btree_irec *low_rec, union xfs_btree_irec *high_rec,
475                 xfs_btree_query_range_fn fn, void *priv);
476 int xfs_btree_query_all(struct xfs_btree_cur *cur, xfs_btree_query_range_fn fn,
477                 void *priv);
478 
479 typedef int (*xfs_btree_visit_blocks_fn)(struct xfs_btree_cur *cur, int level,
480                 void *data);
481 int xfs_btree_visit_blocks(struct xfs_btree_cur *cur,
482                 xfs_btree_visit_blocks_fn fn, void *data);
483 
484 int xfs_btree_count_blocks(struct xfs_btree_cur *cur, xfs_extlen_t *blocks);
485 
486 union xfs_btree_rec *xfs_btree_rec_addr(struct xfs_btree_cur *cur, int n,
487                 struct xfs_btree_block *block);
488 union xfs_btree_key *xfs_btree_key_addr(struct xfs_btree_cur *cur, int n,
489                 struct xfs_btree_block *block);
490 union xfs_btree_key *xfs_btree_high_key_addr(struct xfs_btree_cur *cur, int n,
491                 struct xfs_btree_block *block);
492 union xfs_btree_ptr *xfs_btree_ptr_addr(struct xfs_btree_cur *cur, int n,
493                 struct xfs_btree_block *block);
494 int xfs_btree_lookup_get_block(struct xfs_btree_cur *cur, int level,
495                 union xfs_btree_ptr *pp, struct xfs_btree_block **blkp);
496 struct xfs_btree_block *xfs_btree_get_block(struct xfs_btree_cur *cur,
497                 int level, struct xfs_buf **bpp);
498 bool xfs_btree_ptr_is_null(struct xfs_btree_cur *cur, union xfs_btree_ptr *ptr);
499 int64_t xfs_btree_diff_two_ptrs(struct xfs_btree_cur *cur,
500                                 const union xfs_btree_ptr *a,
501                                 const union xfs_btree_ptr *b);
502 void xfs_btree_get_sibling(struct xfs_btree_cur *cur,
503                            struct xfs_btree_block *block,
504                            union xfs_btree_ptr *ptr, int lr);
505 void xfs_btree_get_keys(struct xfs_btree_cur *cur,
506                 struct xfs_btree_block *block, union xfs_btree_key *key);
507 union xfs_btree_key *xfs_btree_high_key_from_key(struct xfs_btree_cur *cur,
508                 union xfs_btree_key *key);
509 int xfs_btree_has_record(struct xfs_btree_cur *cur, union xfs_btree_irec *low,
510                 union xfs_btree_irec *high, bool *exists);
511 bool xfs_btree_has_more_records(struct xfs_btree_cur *cur);
512 
513 #endif  /* __XFS_BTREE_H__ */
514 

~ [ 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