endian.h

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*
    2  * linux/fs/befs/endian.h
    3  *
    4  * Copyright (C) 2001 Will Dyson <will_dyson@pobox.com>
    5  *
    6  * Partially based on similar funtions in the sysv driver.
    7  */
    8 
    9 #ifndef LINUX_BEFS_ENDIAN
   10 #define LINUX_BEFS_ENDIAN
   11 
   12 #include <linux/byteorder/generic.h>
   13 
   14 static inline u64
   15 fs64_to_cpu(const struct super_block *sb, u64 n)
   16 {
   17         if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE)
   18                 return le64_to_cpu(n);
   19         else
   20                 return be64_to_cpu(n);
   21 }
   22 
   23 static inline u64
   24 cpu_to_fs64(const struct super_block *sb, u64 n)
   25 {
   26         if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE)
   27                 return cpu_to_le64(n);
   28         else
   29                 return cpu_to_be64(n);
   30 }
   31 
   32 static inline u32
   33 fs32_to_cpu(const struct super_block *sb, u32 n)
   34 {
   35         if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE)
   36                 return le32_to_cpu(n);
   37         else
   38                 return be32_to_cpu(n);
   39 }
   40 
   41 static inline u32
   42 cpu_to_fs32(const struct super_block *sb, u32 n)
   43 {
   44         if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE)
   45                 return cpu_to_le32(n);
   46         else
   47                 return cpu_to_be32(n);
   48 }
   49 
   50 static inline u16
   51 fs16_to_cpu(const struct super_block *sb, u16 n)
   52 {
   53         if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE)
   54                 return le16_to_cpu(n);
   55         else
   56                 return be16_to_cpu(n);
   57 }
   58 
   59 static inline u16
   60 cpu_to_fs16(const struct super_block *sb, u16 n)
   61 {
   62         if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE)
   63                 return cpu_to_le16(n);
   64         else
   65                 return cpu_to_be16(n);
   66 }
   67 
   68 /* Composite types below here */
   69 
   70 static inline befs_block_run
   71 fsrun_to_cpu(const struct super_block *sb, befs_block_run n)
   72 {
   73         befs_block_run run;
   74 
   75         if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE) {
   76                 run.allocation_group = le32_to_cpu(n.allocation_group);
   77                 run.start = le16_to_cpu(n.start);
   78                 run.len = le16_to_cpu(n.len);
   79         } else {
   80                 run.allocation_group = be32_to_cpu(n.allocation_group);
   81                 run.start = be16_to_cpu(n.start);
   82                 run.len = be16_to_cpu(n.len);
   83         }
   84         return run;
   85 }
   86 
   87 static inline befs_block_run
   88 cpu_to_fsrun(const struct super_block *sb, befs_block_run n)
   89 {
   90         befs_block_run run;
   91 
   92         if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE) {
   93                 run.allocation_group = cpu_to_le32(n.allocation_group);
   94                 run.start = cpu_to_le16(n.start);
   95                 run.len = cpu_to_le16(n.len);
   96         } else {
   97                 run.allocation_group = cpu_to_be32(n.allocation_group);
   98                 run.start = cpu_to_be16(n.start);
   99                 run.len = cpu_to_be16(n.len);
  100         }
  101         return run;
  102 }
  103 
  104 static inline befs_data_stream
  105 fsds_to_cpu(const struct super_block *sb, befs_data_stream n)
  106 {
  107         befs_data_stream data;
  108         int i;
  109 
  110         for (i = 0; i < BEFS_NUM_DIRECT_BLOCKS; ++i)
  111                 data.direct[i] = fsrun_to_cpu(sb, n.direct[i]);
  112 
  113         data.max_direct_range = fs64_to_cpu(sb, n.max_direct_range);
  114         data.indirect = fsrun_to_cpu(sb, n.indirect);
  115         data.max_indirect_range = fs64_to_cpu(sb, n.max_indirect_range);
  116         data.double_indirect = fsrun_to_cpu(sb, n.double_indirect);
  117         data.max_double_indirect_range = fs64_to_cpu(sb,
  118                                                      n.
  119                                                      max_double_indirect_range);
  120         data.size = fs64_to_cpu(sb, n.size);
  121 
  122         return data;
  123 }
  124 
  125 #endif                          //LINUX_BEFS_ENDIAN

Cache object: 0fbde82c8cc9f729e5f58ac36007bfea

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/fs/befs/endian.h

FreeBSD/Linux Kernel Cross Reference
sys/fs/befs/endian.h