Changes in / [2ac7af3:3a5506a] in mainline


Ignore:
Location:
uspace
Files:
10 deleted
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/mkmfs/mkmfs.c

    r2ac7af3 r3a5506a  
    11/*
     2 * Copyright (c) 2010 Jiri Svoboda
    23 * Copyright (c) 2011 Maurizio Lombardi
    34 * All rights reserved.
    … …  
    5556#define USED    1
    5657
    57 #define UPPER(n, size)          (((n) / (size)) + (((n) % (size)) != 0))
    58 #define NEXT_DENTRY(p, dirsize) (p += (dirsize))
     58#define UPPER(n, size)                  (((n) / (size)) + (((n) % (size)) != 0))
     59#define NEXT_DENTRY(p, dirsize)         (p += (dirsize))
    5960
    6061typedef enum {
    … …  
    6364} help_level_t;
    6465
    65 /* Generic MFS superblock */
     66/*Generic MFS superblock*/
    6667struct mfs_sb_info {
    6768        uint64_t n_inodes;
    … …  
    8384
    8485static void     help_cmd_mkmfs(help_level_t level);
    85 static bool     is_power_of_two(uint32_t n);
     86static int      num_of_set_bits(uint32_t n);
    8687static int      init_superblock(struct mfs_sb_info *sb);
    8788static int      write_superblock(const struct mfs_sb_info *sbi);
    … …  
    117118        struct mfs_sb_info sb;
    118119
    119         /* Default is MinixFS V3 */
     120        /*Default is MinixFS V3*/
    120121        sb.magic = MFS_MAGIC_V3;
    121122        sb.fs_version = 3;
    122123
    123         /* Default block size is 4Kb */
     124        /*Default block size is 4Kb*/
    124125        sb.block_size = MFS_MAX_BLOCKSIZE;
    125126        sb.dirsize = MFS3_DIRSIZE;
    … …  
    135136
    136137        for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
    137                 c = getopt_long(argc, argv, "lh12b:i:",
    138                     long_options, &opt_ind);
     138                c = getopt_long(argc, argv, "lh12b:i:", long_options, &opt_ind);
    139139                switch (c) {
    140140                case 'h':
    … …  
    169169
    170170        if (sb.block_size < MFS_MIN_BLOCKSIZE ||
    171             sb.block_size > MFS_MAX_BLOCKSIZE) {
     171                        sb.block_size > MFS_MAX_BLOCKSIZE) {
    172172                printf(NAME ":Error! Invalid block size.\n");
    173173                exit(0);
    174         } else if (!is_power_of_two(sb.block_size)) {
    175                 /* Block size must be a power of 2. */
     174        } else if (num_of_set_bits(sb.block_size) != 1) {
     175                /*Block size must be a power of 2.*/
    176176                printf(NAME ":Error! Invalid block size.\n");
    177177                exit(0);
    178178        } else if (sb.block_size > MFS_BLOCKSIZE &&
    179             sb.fs_version != 3) {
    180                 printf(NAME ":Error! Block size > 1024 is "
    181                     "supported by V3 filesystem only.\n");
     179                        sb.fs_version != 3) {
     180                printf(NAME ":Error! Block size > 1024 is supported by V3 filesystem only.\n");
    182181                exit(0);
    183182        } else if (sb.fs_version == 3 && sb.longnames) {
    184                 printf(NAME ":Error! Long filenames are supported "
    185                     "by V1/V2 filesystem only.\n");
     183                printf(NAME ":Error! Long filenames are supported by V1/V2 filesystem only.\n");
    186184                exit(0);
    187185        }
    … …  
    223221        rc = block_get_nblocks(service_id, &sb.dev_nblocks);
    224222        if (rc != EOK) {
    225                 printf(NAME ": Warning, failed to obtain "
    226                     "block device size.\n");
     223                printf(NAME ": Warning, failed to obtain block device size.\n");
    227224        } else {
    228225                printf(NAME ": Block device has %" PRIuOFF64 " blocks.\n",
    229                     sb.dev_nblocks);
     226                                sb.dev_nblocks);
    230227        }
    231228
    … …  
    235232        }
    236233
    237         /* Minimum block size is 1 Kb */
     234        /*Minimum block size is 1 Kb*/
    238235        sb.dev_nblocks /= 2;
    239236
    240237        printf(NAME ": Creating Minix file system on device\n");
    241         printf(NAME ": Writing superblock\n");
    242 
    243         /* Initialize superblock */
     238
     239        /*Initialize superblock*/
    244240        if (init_superblock(&sb) != EOK) {
    245241                printf(NAME ": Error. Superblock initialization failed\n");
    … …  
    247243        }
    248244
    249         printf(NAME ": Initializing bitmaps\n");
    250 
    251         /* Initialize bitmaps */
     245        /*Initialize bitmaps*/
    252246        if (init_bitmaps(&sb) != EOK) {
    253247                printf(NAME ": Error. Bitmaps initialization failed\n");
    … …  
    255249        }
    256250
    257         printf(NAME ": Initializing the inode table\n");
    258 
    259         /* Init inode table */
     251        /*Init inode table*/
    260252        if (init_inode_table(&sb) != EOK) {
    261253                printf(NAME ": Error. Inode table initialization failed\n");
    … …  
    263255        }
    264256
    265         printf(NAME ": Creating the root directory inode\n");
    266 
    267         /* Make the root inode */
     257        /*Make the root inode*/
    268258        if (sb.fs_version == 1)
    269259                rc = make_root_ino(&sb);
    … …  
    276266        }
    277267
    278         /* Insert directory entries . and .. */
     268        /*Insert directory entries . and ..*/
    279269        if (insert_dentries(&sb) != EOK) {
    280270                printf(NAME ": Error. Root directory initialization failed\n");
    … …  
    309299
    310300        if (sb->fs_version != 3) {
    311                 /* Directory entries for V1/V2 filesystem */
     301                /*Directory entries for V1/V2 filesystem*/
    312302                struct mfs_dentry *dentry = root_block;
    313303
    … …  
    316306
    317307                dentry = (struct mfs_dentry *) NEXT_DENTRY(dentry_ptr,
    318                     sb->dirsize);
     308                                sb->dirsize);
    319309
    320310                dentry->d_inum = MFS_ROOT_INO;
    321311                memcpy(dentry->d_name, "..\0", 3);
    322312        } else {
    323                 /* Directory entries for V3 filesystem */
     313                /*Directory entries for V3 filesystem*/
    324314                struct mfs3_dentry *dentry = root_block;
    325315
    … …  
    328318
    329319                dentry = (struct mfs3_dentry *) NEXT_DENTRY(dentry_ptr,
    330                     sb->dirsize);
     320                                sb->dirsize);
    331321
    332322                dentry->d_inum = MFS_ROOT_INO;
    … …  
    399389        ino_buf[MFS_ROOT_INO - 1].i_gid = 0;
    400390        ino_buf[MFS_ROOT_INO - 1].i_size = (sb->longnames ? MFSL_DIRSIZE :
    401             MFS_DIRSIZE) * 2;
     391        MFS_DIRSIZE) * 2;
    402392        ino_buf[MFS_ROOT_INO - 1].i_mtime = sec;
    403393        ino_buf[MFS_ROOT_INO - 1].i_nlinks = 2;
    … …  
    421411        int rc;
    422412
    423         /* Compute offset of the first inode table block */
     413        /*Compute offset of the first inode table block*/
    424414        const long itable_off = sb->zbmap_blocks + sb->ibmap_blocks + 2;
    425415
    … …  
    464454
    465455        if (sb->longnames)
    466                 sb->magic = sb->fs_version == 1 ? MFS_MAGIC_V1L :
    467                     MFS_MAGIC_V2L;
    468 
    469         /* Compute the number of zones on disk */
     456                sb->magic = sb->fs_version == 1 ? MFS_MAGIC_V1L : MFS_MAGIC_V2L;
     457
     458        /*Compute the number of zones on disk*/
    470459
    471460        if (sb->fs_version == 1) {
    472                 /* Valid only for MFS V1 */
     461                /*Valid only for MFS V1*/
    473462                sb->n_zones = sb->dev_nblocks > UINT16_MAX ?
    474                     UINT16_MAX : sb->dev_nblocks;
     463                                UINT16_MAX : sb->dev_nblocks;
    475464                ind = MFS_BLOCKSIZE / sizeof(uint16_t);
    476465                ind2 = ind * ind;
    477                 sb->max_file_size = (V1_NR_DIRECT_ZONES + ind + ind2) *
    478                     MFS_BLOCKSIZE;
     466                sb->max_file_size = (V1_NR_DIRECT_ZONES + ind + ind2) * MFS_BLOCKSIZE;
    479467        } else {
    480468                /*Valid for MFS V2/V3*/
    … …  
    484472                else
    485473                        ptrsize = sizeof(uint32_t);
    486 
    487474                ind = sb->block_size / ptrsize;
    488475                ind2 = ind * ind;
    … …  
    490477                sb->max_file_size = zones * sb->block_size;
    491478                sb->n_zones = sb->dev_nblocks > UINT32_MAX ?
    492                     UINT32_MAX : sb->dev_nblocks;
     479                                UINT32_MAX : sb->dev_nblocks;
    493480
    494481                if (sb->fs_version == 3) {
    … …  
    500487        }
    501488
    502         /* Round up the number of inodes to fill block size */
     489        /*Round up the number of inodes to fill block size*/
    503490        if (sb->n_inodes == 0)
    504491                inodes = sb->dev_nblocks / 3;
    … …  
    507494
    508495        if (inodes % sb->ino_per_block)
    509                 inodes = ((inodes / sb->ino_per_block) + 1) *
    510                     sb->ino_per_block;
     496                inodes = ((inodes / sb->ino_per_block) + 1) * sb->ino_per_block;
    511497
    512498        if (sb->fs_version < 3)
    … …  
    515501                sb->n_inodes = inodes > UINT32_MAX ? UINT32_MAX : inodes;
    516502
    517         /* Compute inode bitmap size in blocks */
     503        /*Compute inode bitmap size in blocks*/
    518504        sb->ibmap_blocks = UPPER(sb->n_inodes, sb->block_size * 8);
    519505
    520         /* Compute inode table size */
     506        /*Compute inode table size*/
    521507        sb->itable_size = sb->n_inodes / sb->ino_per_block;
    522508
    523         /* Compute zone bitmap size in blocks */
     509        /*Compute zone bitmap size in blocks*/
    524510        sb->zbmap_blocks = UPPER(sb->n_zones, sb->block_size * 8);
    525511
    526         /* Compute first data zone position */
     512        /*Compute first data zone position*/
    527513        sb->first_data_zone = 2 + sb->itable_size +
    528             sb->zbmap_blocks + sb->ibmap_blocks;
    529 
    530         /* Set log2 of zone to block ratio to zero */
     514                        sb->zbmap_blocks + sb->ibmap_blocks;
     515
     516        /*Set log2 of zone to block ratio to zero*/
    531517        sb->log2_zone_size = 0;
    532518
    533         /* Check for errors */
     519        /*Check for errors*/
    534520        if (sb->first_data_zone >= sb->n_zones) {
    535521                printf(NAME ": Error! Insufficient disk space");
    … …  
    537523        }
    538524
    539         /* Superblock is now ready to be written on disk */
     525        /*Superblock is now ready to be written on disk*/
    540526        printf(NAME ": %d block size\n", sb->block_size);
    541527        printf(NAME ": %d inodes\n", (uint32_t) sb->n_inodes);
    … …  
    544530        printf(NAME ": inode bitmap blocks = %ld\n", sb->ibmap_blocks);
    545531        printf(NAME ": zone bitmap blocks = %ld\n", sb->zbmap_blocks);
    546         printf(NAME ": first data zone = %d\n", (uint32_t)sb->first_data_zone);
     532        printf(NAME ": first data zone = %d\n", (uint32_t) sb->first_data_zone);
    547533        printf(NAME ": max file size = %u\n", sb->max_file_size);
    548534        printf(NAME ": long fnames = %s\n", sb->longnames ? "Yes" : "No");
    … …  
    659645        for (i = 0; i < ibmap_nblocks; ++i) {
    660646                if ((rc = write_block(start_block + i,
    661                     1, (ibmap_buf8 + i * sb->block_size))) != EOK)
     647                                1, (ibmap_buf8 + i * sb->block_size))) != EOK)
    662648                        return rc;
    663649        }
    … …  
    667653        for (i = 0; i < zbmap_nblocks; ++i) {
    668654                if ((rc = write_block(start_block + i,
    669                     1, (zbmap_buf8 + i * sb->block_size))) != EOK)
     655                                1, (zbmap_buf8 + i * sb->block_size))) != EOK)
    670656                        return rc;
    671657        }
    … …  
    706692                uint8_t *data_ptr = (uint8_t *) data;
    707693
    708                 rc = block_write_direct(service_id, tmp_off << 2,
    709                     size << 2, data_ptr);
     694                rc = block_write_direct(service_id, tmp_off << 2, size << 2, data_ptr);
    710695
    711696                if (rc != EOK)
    … …  
    715700                tmp_off++;
    716701
    717                 return block_write_direct(service_id, tmp_off << 2,
    718                     size << 2, data_ptr);
    719         }
    720         return block_write_direct(service_id, off << shift,
    721             size << shift, data);
     702                return block_write_direct(service_id, tmp_off << 2, size << 2, data_ptr);
     703        }
     704        return block_write_direct(service_id, off << shift, size << shift, data);
    722705}
    723706
    … …  
    728711        } else {
    729712                printf("Usage: [options] device\n"
    730                     "-1         Make a Minix version 1 filesystem\n"
    731                     "-2         Make a Minix version 2 filesystem\n"
    732                     "-b ##      Specify the block size in bytes (V3 only),\n"
    733                     "           valid block size values are 1024, 2048 and"
    734                                 " 4096 bytes per block\n"
    735                     "-i ##      Specify the number of inodes"
    736                                 " for the filesystem\n"
    737                     "-l         Use 30-char long filenames (V1/V2 only)\n");
    738         }
    739 }
    740 
    741 /** Check if a given number is a power of two.
    742  *
    743  * @param n     The number to check.
    744  *
    745  * @return      true if it is a power of two, false otherwise.
    746  */
    747 static bool is_power_of_two(uint32_t n)
    748 {
    749         if (n == 0)
    750                 return false;
    751 
    752         return (n & (n - 1)) == 0;
     713                                "-1         Make a Minix version 1 filesystem\n"
     714                                "-2         Make a Minix version 2 filesystem\n"
     715                                "-b ##      Specify the block size in bytes (V3 only),\n"
     716                                "           valid block size values are 1024, 2048 and 4096 bytes per block\n"
     717                                "-i ##      Specify the number of inodes for the filesystem\n"
     718                                "-l         Use 30-char long filenames (V1/V2 only)\n");
     719        }
     720}
     721
     722static int num_of_set_bits(uint32_t n)
     723{
     724        n = n - ((n >> 1) & 0x55555555);
     725        n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
     726        return (((n + (n >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;
    753727}
    754728

  • uspace/srv/fs/mfs/mfs.c

    r2ac7af3 r3a5506a  
    7474
    7575        async_sess_t *vfs_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
    76             SERVICE_VFS, 0, 0);
     76                                SERVICE_VFS, 0, 0);
    7777
    7878        if (!vfs_sess) {

  • uspace/srv/fs/mfs/mfs_balloc.c

    r2ac7af3 r3a5506a  
    3636static int
    3737find_free_bit_and_set(bitchunk_t *b, const int bsize,
    38     const bool native, unsigned start_bit);
     38                      const bool native, unsigned start_bit);
    3939
    4040static int
    … …  
    129129                if (idx > sbi->nzones) {
    130130                        printf(NAME ": Error! Trying to free beyond the" \
    131                             "bitmap max size\n");
     131                               "bitmap max size\n");
    132132                        return -1;
    133133                }
    134134        } else {
    135                 /* bid == BMAP_INODE */
     135                /*bid == BMAP_INODE*/
    136136                search = &sbi->isearch;
    137137                start_block = 2;
    138138                if (idx > sbi->ninodes) {
    139139                        printf(NAME ": Error! Trying to free beyond the" \
    140                             "bitmap max size\n");
     140                               "bitmap max size\n");
    141141                        return -1;
    142142                }
    143143        }
    144144
    145         /* Compute the bitmap block */
     145        /*Compute the bitmap block*/
    146146        uint32_t block = idx / (sbi->block_size * 8) + start_block;
    147147
    … …  
    150150                goto out_err;
    151151
    152         /* Compute the bit index in the block */
     152        /*Compute the bit index in the block*/
    153153        idx %= (sbi->block_size * 8);
    154154        bitchunk_t *ptr = b->data;
    … …  
    220220
    221221                freebit = find_free_bit_and_set(b->data, sbi->block_size,
    222                     sbi->native, tmp);
     222                                                sbi->native, tmp);
    223223                if (freebit == -1) {
    224                         /* No free bit in this block */
     224                        /*No free bit in this block*/
    225225                        r = block_put(b);
    226226                        if (r != EOK)
    … …  
    229229                }
    230230
    231                 /* Free bit found in this block, compute the real index */
     231                /*Free bit found in this block, compute the real index*/
    232232                *idx = freebit + bits_per_block * i;
    233233                if (*idx > limit) {
    234                         /* Index is beyond the limit, it is invalid */
     234                        /*Index is beyond the limit, it is invalid*/
    235235                        r = block_put(b);
    236236                        if (r != EOK)
    … …  
    246246
    247247        if (*search > 0) {
    248                 /* Repeat the search from the first bitmap block */
     248                /*Repeat the search from the first bitmap block*/
    249249                *search = 0;
    250250                goto retry;
    251251        }
    252252
    253         /* Free bit not found, return error */
     253        /*Free bit not found, return error*/
    254254        return ENOSPC;
    255255
    … …  
    260260static int
    261261find_free_bit_and_set(bitchunk_t *b, const int bsize,
    262     const bool native, unsigned start_bit)
     262                      const bool native, unsigned start_bit)
    263263{
    264264        int r = -1;
    … …  
    268268
    269269        for (i = start_bit / chunk_bits;
    270             i < bsize / sizeof(bitchunk_t); ++i) {
    271 
     270             i < bsize / sizeof(bitchunk_t); ++i) {
    272271                if (!(~b[i])) {
    273                         /* No free bit in this chunk */
     272                        /*No free bit in this chunk*/
    274273                        continue;
    275274                }

  • uspace/srv/fs/mfs/mfs_dentry.c

    r2ac7af3 r3a5506a  
    4444int
    4545mfs_read_dentry(struct mfs_node *mnode,
    46     struct mfs_dentry_info *d_info, unsigned index)
     46                     struct mfs_dentry_info *d_info, unsigned index)
    4747{
    4848        const struct mfs_instance *inst = mnode->instance;
    … …  
    5757
    5858        if (block == 0) {
    59                 /* End of the dentries list */
     59                /*End of the dentries list*/
    6060                r = EOK;
    6161                goto out_err;
    … …  
    7979        } else {
    8080                const int namelen = longnames ? MFS_L_MAX_NAME_LEN :
    81                     MFS_MAX_NAME_LEN;
     81                                    MFS_MAX_NAME_LEN;
    8282
    8383                struct mfs_dentry *d;
    8484
    8585                d = b->data + dentry_off * (longnames ? MFSL_DIRSIZE :
    86                     MFS_DIRSIZE);
     86                                            MFS_DIRSIZE);
    8787                d_info->d_inum = conv16(sbi->native, d->d_inum);
    8888                memcpy(d_info->d_name, d->d_name, namelen);
    … …  
    101101/**Write a directory entry on disk.
    102102 *
    103  * @param d_info Pointer to the directory entry structure to write on disk.
    104  *
    105  * @return       EOK on success or a negative error code.
     103 * @param d_info        Pointer to the directory entry structure to write on disk.
     104 *
     105 * @return              EOK on success or a negative error code.
    106106 */
    107107int
    … …  
    178178
    179179                if (name_len == d_name_len &&
    180                     !bcmp(d_info.d_name, d_name, name_len)) {
    181 
     180                                !bcmp(d_info.d_name, d_name, name_len)) {
    182181                        d_info.d_inum = 0;
    183182                        r = mfs_write_dentry(&d_info);
    … …  
    198197 */
    199198int
    200 mfs_insert_dentry(struct mfs_node *mnode, const char *d_name,
    201     fs_index_t d_inum)
     199mfs_insert_dentry(struct mfs_node *mnode, const char *d_name, fs_index_t d_inum)
    202200{
    203201        int r;
    … …  
    211209                return ENAMETOOLONG;
    212210
    213         /* Search for an empty dentry */
     211        /*Search for an empty dentry*/
    214212        unsigned i;
    215213        for (i = 0; i < mnode->ino_i->i_size / sbi->dirsize; ++i) {
    … …  
    219217
    220218                if (d_info.d_inum == 0) {
    221                         /* This entry is not used */
     219                        /*This entry is not used*/
    222220                        empty_dentry_found = true;
    223221                        break;
    … …  
    233231
    234232                if (b == 0) {
    235                         /* Increase the inode size */
     233                        /*Increase the inode size*/
    236234
    237235                        uint32_t dummy;

  • uspace/srv/fs/mfs/mfs_inode.c

    r2ac7af3 r3a5506a  
    4242static int
    4343mfs_read_inode_raw(const struct mfs_instance *instance,
    44     struct mfs_ino_info **ino_ptr, uint16_t inum);
     44                struct mfs_ino_info **ino_ptr, uint16_t inum);
    4545
    4646static int
    4747mfs2_read_inode_raw(const struct mfs_instance *instance,
    48     struct mfs_ino_info **ino_ptr, uint32_t inum);
     48                struct mfs_ino_info **ino_ptr, uint32_t inum);
    4949
    5050/**Read a MINIX inode from disk
    … …  
    5959int
    6060mfs_get_inode(struct mfs_instance *inst, struct mfs_ino_info **ino_i,
    61     fs_index_t index)
     61          fs_index_t index)
    6262{
    6363        struct mfs_sb_info *sbi = inst->sbi;
    … …  
    6565
    6666        if (sbi->fs_version == MFS_VERSION_V1) {
    67                 /* Read a MFS V1 inode */
     67                /*Read a MFS V1 inode*/
    6868                r = mfs_read_inode_raw(inst, ino_i, index);
    6969        } else {
    70                 /* Read a MFS V2/V3 inode */
     70                /*Read a MFS V2/V3 inode*/
    7171                r = mfs2_read_inode_raw(inst, ino_i, index);
    7272        }
    … …  
    7777static int
    7878mfs_read_inode_raw(const struct mfs_instance *instance,
    79     struct mfs_ino_info **ino_ptr, uint16_t inum)
    80 {
     79                struct mfs_ino_info **ino_ptr, uint16_t inum) {
    8180        struct mfs_inode *ino;
    8281        struct mfs_ino_info *ino_i = NULL;
    … …  
    8786        sbi = instance->sbi;
    8887
    89         /* inode 0 does not exist */
     88        /*inode 0 does not exist*/
    9089        inum -= 1;
    9190
    … …  
    102101
    103102        r = block_get(&b, instance->service_id,
    104             itable_off + inum / sbi->ino_per_block,
    105             BLOCK_FLAGS_NONE);
    106 
     103                      itable_off + inum / sbi->ino_per_block,
     104                      BLOCK_FLAGS_NONE);
    107105        if (r != EOK)
    108106                goto out_err;
    … …  
    136134static int
    137135mfs2_read_inode_raw(const struct mfs_instance *instance,
    138     struct mfs_ino_info **ino_ptr, uint32_t inum)
    139 {
     136                struct mfs_ino_info **ino_ptr, uint32_t inum) {
    140137        struct mfs2_inode *ino;
    141138        struct mfs_ino_info *ino_i = NULL;
    … …  
    153150        sbi = instance->sbi;
    154151
    155         /* inode 0 does not exist */
     152        /*inode 0 does not exist*/
    156153        inum -= 1;
    157154
    … …  
    160157
    161158        r = block_get(&b, instance->service_id,
    162             itable_off + inum / sbi->ino_per_block,
    163             BLOCK_FLAGS_NONE);
    164 
     159                      itable_off + inum / sbi->ino_per_block,
     160                      BLOCK_FLAGS_NONE);
    165161        if (r != EOK)
    166162                goto out_err;
    … …  
    326322
    327323        if (size_shrink == 0) {
    328                 /* Nothing to be done */
     324                /*File is empty*/
    329325                return EOK;
    330326        }
    … …  
    337333        ino_i->dirty = true;
    338334
    339         /* Compute the number of zones to free */
     335        /*Compute the number of zones to free*/
    340336        unsigned zones_to_free;
    341337
    … …  
    358354
    359355                if (old_zone == 0)
    360                         continue; /* Sparse block */
     356                        continue; /*Sparse block*/
    361357
    362358                r = mfs_free_zone(mnode->instance, old_zone);

  • uspace/srv/fs/mfs/mfs_ops.c

    r2ac7af3 r3a5506a  
    4343
    4444static bool check_magic_number(uint16_t magic, bool *native,
    45     mfs_version_t *version, bool *longfilenames);
     45                               mfs_version_t *version, bool *longfilenames);
    4646static int mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
    47     fs_index_t index);
     47                             fs_index_t index);
     48
    4849static int mfs_node_put(fs_node_t *fsnode);
    4950static int mfs_node_open(fs_node_t *fsnode);
    … …  
    6364static hash_index_t open_nodes_hash(unsigned long key[]);
    6465static int open_nodes_compare(unsigned long key[], hash_count_t keys,
    65     link_t *item);
     66                link_t *item);
    6667static void open_nodes_remove_cb(link_t *link);
     68
    6769static int mfs_node_get(fs_node_t **rfn, service_id_t service_id,
    68     fs_index_t index);
    69 static int mfs_instance_get(service_id_t service_id,
    70     struct mfs_instance **instance);
     70                        fs_index_t index);
     71static int
     72mfs_instance_get(service_id_t service_id, struct mfs_instance **instance);
    7173
    7274
    … …  
    9496
    9597/* Hash table interface for open nodes hash table */
    96 static hash_index_t
    97 open_nodes_hash(unsigned long key[])
     98static hash_index_t open_nodes_hash(unsigned long key[])
    9899{
    99100        /* TODO: This is very simple and probably can be improved */
    … …  
    101102}
    102103
    103 static int
    104 open_nodes_compare(unsigned long key[], hash_count_t keys,
    105     link_t *item)
     104static int open_nodes_compare(unsigned long key[], hash_count_t keys,
     105                link_t *item)
    106106{
    107107        struct mfs_node *mnode = hash_table_get_instance(item, struct mfs_node, link);
    … …  
    118118}
    119119
    120 static void
    121 open_nodes_remove_cb(link_t *link)
     120static void open_nodes_remove_cb(link_t *link)
    122121{
    123122        /* We don't use remove callback for this hash table */
    … …  
    130129};
    131130
    132 int
    133 mfs_global_init(void)
     131int mfs_global_init(void)
    134132{
    135133        if (!hash_table_create(&open_nodes, OPEN_NODES_BUCKETS,
    136             OPEN_NODES_KEYS, &open_nodes_ops)) {
     134                        OPEN_NODES_KEYS, &open_nodes_ops)) {
    137135                return ENOMEM;
    138136        }
    … …  
    142140static int
    143141mfs_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
    144     aoff64_t *size, unsigned *linkcnt)
     142                aoff64_t *size, unsigned *linkcnt)
    145143{
    146144        enum cache_mode cmode;
    … …  
    165163                return rc;
    166164
    167         /* Allocate space for generic MFS superblock */
     165        /*Allocate space for generic MFS superblock*/
    168166        sbi = malloc(sizeof(*sbi));
    169167        if (!sbi) {
    … …  
    172170        }
    173171
    174         /* Allocate space for filesystem instance */
     172        /*Allocate space for filesystem instance*/
    175173        instance = malloc(sizeof(*instance));
    176174        if (!instance) {
    … …  
    193191
    194192        if (check_magic_number(sb->s_magic, &native, &version, &longnames)) {
    195                 /* This is a V1 or V2 Minix filesystem */
     193                /*This is a V1 or V2 Minix filesystem*/
    196194                magic = sb->s_magic;
    197195        } else if (check_magic_number(sb3->s_magic, &native, &version, &longnames)) {
    198                 /* This is a V3 Minix filesystem */
     196                /*This is a V3 Minix filesystem*/
    199197                magic = sb3->s_magic;
    200198        } else {
    201                 /* Not recognized */
     199                /*Not recognized*/
    202200                mfsdebug("magic number not recognized\n");
    203201                rc = ENOTSUP;
    … …  
    207205        mfsdebug("magic number recognized = %04x\n", magic);
    208206
    209         /* Fill superblock info structure */
     207        /*Fill superblock info structure*/
    210208
    211209        sbi->fs_version = version;
    … …  
    245243                sbi->dirsize = longnames ? MFSL_DIRSIZE : MFS_DIRSIZE;
    246244                sbi->max_name_len = longnames ? MFS_L_MAX_NAME_LEN :
    247                     MFS_MAX_NAME_LEN;
     245                                    MFS_MAX_NAME_LEN;
    248246        }
    249247
    … …  
    269267        }
    270268
    271         /* Initialize the instance structure and remember it */
     269        /*Initialize the instance structure and remember it*/
    272270        instance->service_id = service_id;
    273271        instance->sbi = sbi;
    … …  
    275273        rc = fs_instance_create(service_id, instance);
    276274        if (rc != EOK) {
     275                free(instance);
     276                free(sbi);
    277277                block_cache_fini(service_id);
     278                block_fini(service_id);
    278279                mfsdebug("fs instance creation failed\n");
    279                 goto out_error;
     280                return rc;
    280281        }
    281282
    … …  
    330331}
    331332
    332 service_id_t
    333 mfs_service_get(fs_node_t *fsnode)
     333service_id_t mfs_service_get(fs_node_t *fsnode)
    334334{
    335335        struct mfs_node *node = fsnode->data;
    … …  
    337337}
    338338
    339 static int
    340 mfs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
     339static int mfs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
    341340{
    342341        int r;
    … …  
    352351                return r;
    353352
    354         /* Alloc a new inode */
     353        /*Alloc a new inode*/
    355354        r = mfs_alloc_inode(inst, &inum);
    356355        if (r != EOK)
    … …  
    379378        if (flags & L_DIRECTORY) {
    380379                ino_i->i_mode = S_IFDIR;
    381                 ino_i->i_nlinks = 2; /* This accounts for the '.' dentry */
     380                ino_i->i_nlinks = 2; /*This accounts for the '.' dentry*/
    382381        } else {
    383382                ino_i->i_mode = S_IFREG;
    … …  
    432431}
    433432
    434 static int
    435 mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
     433static int mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    436434{
    437435        struct mfs_node *mnode = pfn->data;
    … …  
    455453
    456454                if (!d_info.d_inum) {
    457                         /* This entry is not used */
     455                        /*This entry is not used*/
    458456                        continue;
    459457                }
    … …  
    462460
    463461                if (comp_size == dentry_name_size &&
    464                     !bcmp(component, d_info.d_name, dentry_name_size)) {
    465                         /* Hit! */
     462                        !bcmp(component, d_info.d_name, dentry_name_size)) {
     463                        /*Hit!*/
    466464                        mfs_node_core_get(rfn, mnode->instance,
    467                             d_info.d_inum);
     465                                          d_info.d_inum);
    468466                        goto found;
    469467                }
    … …  
    474472}
    475473
    476 static aoff64_t
    477 mfs_size_get(fs_node_t *node)
     474static aoff64_t mfs_size_get(fs_node_t *node)
    478475{
    479476        const struct mfs_node *mnode = node->data;
    … …  
    483480static int
    484481mfs_node_get(fs_node_t **rfn, service_id_t service_id,
    485     fs_index_t index)
     482                        fs_index_t index)
    486483{
    487484        int rc;
    … …  
    527524}
    528525
    529 static int
    530 mfs_node_open(fs_node_t *fsnode)
     526static int mfs_node_open(fs_node_t *fsnode)
    531527{
    532528        /*
    … …  
    537533}
    538534
    539 static fs_index_t
    540 mfs_index_get(fs_node_t *fsnode)
     535static fs_index_t mfs_index_get(fs_node_t *fsnode)
    541536{
    542537        struct mfs_node *mnode = fsnode->data;
    … …  
    544539}
    545540
    546 static unsigned
    547 mfs_lnkcnt_get(fs_node_t *fsnode)
     541static unsigned mfs_lnkcnt_get(fs_node_t *fsnode)
    548542{
    549543        struct mfs_node *mnode = fsnode->data;
    … …  
    560554}
    561555
    562 static int
    563 mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
    564     fs_index_t index)
     556static int mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
     557                             fs_index_t index)
    565558{
    566559        fs_node_t *node = NULL;
    … …  
    634627}
    635628
    636 static bool
    637 mfs_is_directory(fs_node_t *fsnode)
     629static bool mfs_is_directory(fs_node_t *fsnode)
    638630{
    639631        const struct mfs_node *node = fsnode->data;
    … …  
    641633}
    642634
    643 static bool
    644 mfs_is_file(fs_node_t *fsnode)
     635static bool mfs_is_file(fs_node_t *fsnode)
    645636{
    646637        struct mfs_node *node = fsnode->data;
    … …  
    648639}
    649640
    650 static int
    651 mfs_root_get(fs_node_t **rfn, service_id_t service_id)
     641static int mfs_root_get(fs_node_t **rfn, service_id_t service_id)
    652642{
    653643        int rc = mfs_node_get(rfn, service_id, MFS_ROOT_INO);
    … …  
    655645}
    656646
    657 static int
    658 mfs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
     647static int mfs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
    659648{
    660649        struct mfs_node *parent = pfn->data;
    … …  
    731720}
    732721
    733 static int
    734 mfs_has_children(bool *has_children, fs_node_t *fsnode)
     722static int mfs_has_children(bool *has_children, fs_node_t *fsnode)
    735723{
    736724        struct mfs_node *mnode = fsnode->data;
    … …  
    753741
    754742                if (d_info.d_inum) {
    755                         /* A valid entry has been found */
     743                        /*A valid entry has been found*/
    756744                        *has_children = true;
    757745                        break;
    … …  
    765753static int
    766754mfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    767     size_t *rbytes)
     755                size_t *rbytes)
    768756{
    769757        int rc;
    … …  
    795783
    796784                if (pos < 2) {
    797                         /* Skip the first two dentries ('.' and '..') */
     785                        /*Skip the first two dentries ('.' and '..')*/
    798786                        pos = 2;
    799787                }
    … …  
    805793
    806794                        if (d_info.d_inum) {
    807                                 /* Dentry found! */
     795                                /*Dentry found!*/
    808796                                goto found;
    809797                        }
    … …  
    821809
    822810                if (pos >= (size_t) ino_i->i_size) {
    823                         /* Trying to read beyond the end of file */
     811                        /*Trying to read beyond the end of file*/
    824812                        bytes = 0;
    825813                        (void) async_data_read_finalize(callid, NULL, 0);
    … …  
    838826
    839827                if (zone == 0) {
    840                         /* sparse file */
     828                        /*sparse file*/
    841829                        uint8_t *buf = malloc(sbi->block_size);
    842830                        if (!buf) {
    … …  
    846834                        memset(buf, 0, sizeof(sbi->block_size));
    847835                        async_data_read_finalize(callid,
    848                             buf + pos % sbi->block_size, bytes);
     836                                                buf + pos % sbi->block_size, bytes);
    849837                        free(buf);
    850838                        goto out_success;
    … …  
    856844
    857845                async_data_read_finalize(callid, b->data +
    858                     pos % sbi->block_size, bytes);
     846                                        pos % sbi->block_size, bytes);
    859847
    860848                rc = block_put(b);
    … …  
    877865static int
    878866mfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    879     size_t *wbytes, aoff64_t *nsize)
     867                size_t *wbytes, aoff64_t *nsize)
    880868{
    881869        fs_node_t *fn;
    … …  
    912900
    913901        if (block == 0) {
     902                /*Writing in a sparse block*/
    914903                uint32_t dummy;
    915904
    … …  
    969958                return ENOENT;
    970959
    971         /* Destroy the inode */
     960        /*Destroy the inode*/
    972961        return mfs_destroy_node(fn);
    973962}
    … …  
    988977        assert(!has_children);
    989978
    990         /* Free the entire inode content */
     979        /*Free the entire inode content*/
    991980        r = mfs_inode_shrink(mnode, mnode->ino_i->i_size);
    992981        if (r != EOK)
    993982                goto out;
    994983
    995         /* Mark the inode as free in the bitmap */
     984        /*Mark the inode as free in the bitmap*/
    996985        r = mfs_free_inode(mnode->instance, mnode->ino_i->index);
    997986
    … …  
    10321021
    10331022        rc = fs_instance_get(service_id, &data);
    1034         if (rc == EOK)
     1023        if (rc == EOK) {
    10351024                *instance = (struct mfs_instance *) data;
    1036         else {
     1025        } else {
    10371026                mfsdebug("instance not found\n");
    10381027        }
    … …  
    10411030}
    10421031
    1043 static bool
    1044 check_magic_number(uint16_t magic, bool *native,
    1045                 mfs_version_t *version, bool *longfilenames)
     1032static bool check_magic_number(uint16_t magic, bool *native,
     1033                               mfs_version_t *version, bool *longfilenames)
    10461034{
    10471035        bool rc = true;

  • uspace/srv/fs/mfs/mfs_rw.c

    r2ac7af3 r3a5506a  
    3636static int
    3737rw_map_ondisk(uint32_t *b, const struct mfs_node *mnode, int rblock,
    38     bool write_mode, uint32_t w_block);
     38              bool write_mode, uint32_t w_block);
    3939
    4040static int
    … …  
    6868        const int block_size = sbi->block_size;
    6969
    70         /* Compute relative block number in file */
     70        /*Compute relative block number in file*/
    7171        int rblock = pos / block_size;
    7272
    7373        if (ROUND_UP(mnode->ino_i->i_size, sbi->block_size) < pos) {
    74                 /* Trying to read beyond the end of file */
     74                /*Trying to read beyond the end of file*/
    7575                r = EOK;
    7676                *b = 0;
    … …  
    8585int
    8686mfs_write_map(struct mfs_node *mnode, const uint32_t pos, uint32_t new_zone,
    87     uint32_t *old_zone)
     87          uint32_t *old_zone)
    8888{
    8989        const struct mfs_sb_info *sbi = mnode->instance->sbi;
    9090
    9191        if (pos >= sbi->max_file_size) {
    92                 /* Can't write beyond the maximum file size */
     92                /*Can't write beyond the maximum file size*/
    9393                return EINVAL;
    9494        }
    9595
    96         /* Compute the relative block number in file */
     96        /*Compute the relative block number in file*/
    9797        int rblock = pos / sbi->block_size;
    9898
    … …  
    102102static int
    103103rw_map_ondisk(uint32_t *b, const struct mfs_node *mnode, int rblock,
    104     bool write_mode, uint32_t w_block)
     104              bool write_mode, uint32_t w_block)
    105105{
    106106        int r, nr_direct;
    … …  
    123123        }
    124124
    125         /* Check if the wanted block is in the direct zones */
     125        /*Check if the wanted block is in the direct zones*/
    126126        if (rblock < nr_direct) {
    127127                *b = ino_i->i_dzone[rblock];
    … …  
    136136
    137137        if (rblock < ptrs_per_block) {
    138                 /* The wanted block is in the single indirect zone chain */
     138                /*The wanted block is in the single indirect zone chain*/
    139139                if (ino_i->i_izone[0] == 0) {
    140140                        if (write_mode && !deleting) {
    … …  
    168168        rblock -= ptrs_per_block;
    169169
    170         /* The wanted block is in the double indirect zone chain */
    171 
    172         /* Read the first indirect zone of the chain */
     170        /*The wanted block is in the double indirect zone chain*/
     171
     172        /*read the first indirect zone of the chain*/
    173173        if (ino_i->i_izone[1] == 0) {
    174174                if (write_mode && !deleting) {
    … …  
    181181                        ino_i->dirty = true;
    182182                } else {
    183                         /* Sparse block */
     183                        /*Sparse block*/
    184184                        *b = 0;
    185185                        return EOK;
    … …  
    192192
    193193        /*
    194          * Compute the position of the second indirect
    195          * zone pointer in the chain.
     194         *Compute the position of the second indirect
     195         *zone pointer in the chain.
    196196         */
    197197        uint32_t ind2_off = rblock / ptrs_per_block;
    198198
    199         /* read the second indirect zone of the chain */
     199        /*read the second indirect zone of the chain*/
    200200        if (ind_zone[ind2_off] == 0) {
    201201                if (write_mode && !deleting) {
    … …  
    208208                        write_ind_zone(inst, ino_i->i_izone[1], ind_zone);
    209209                } else {
    210                         /* Sparse block */
     210                        /*Sparse block*/
    211211                        r = EOK;
    212212                        *b = 0;
    … …  
    264264
    265265        if (rblock < nr_direct) {
    266                 /* Free the single indirect zone */
     266                /*free the single indirect zone*/
    267267                if (ino_i->i_izone[0]) {
    268268                        r = mfs_free_zone(inst, ino_i->i_izone[0]);
    … …  
    282282                ++fzone_to_free;
    283283
    284         /* Free the entire double indirect zone */
     284        /*free the entire double indirect zone*/
    285285        uint32_t *dbl_zone;
    286286
    287287        if (ino_i->i_izone[1] == 0) {
    288                 /* Nothing to be done */
     288                /*Nothing to be done*/
    289289                return EOK;
    290290        }
    … …  
    350350        block_t *b;
    351351        const int max_ind_zone_ptrs = (MFS_MAX_BLOCKSIZE / sizeof(uint16_t)) *
    352             sizeof(uint32_t);
     352                                      sizeof(uint32_t);
    353353
    354354        *ind_zone = malloc(max_ind_zone_ptrs);

  • uspace/srv/fs/mfs/mfs_utils.c

    r2ac7af3 r3a5506a  
    3434#include "mfs.h"
    3535
    36 uint16_t
    37 conv16(bool native, uint16_t n)
     36uint16_t conv16(bool native, uint16_t n)
    3837{
    3938        if (native)
    … …  
    4342}
    4443
    45 uint32_t
    46 conv32(bool native, uint32_t n)
     44uint32_t conv32(bool native, uint32_t n)
    4745{
    4846        if (native)
    … …  
    5250}
    5351
    54 uint64_t
    55 conv64(bool native, uint64_t n)
     52uint64_t conv64(bool native, uint64_t n)
    5653{
    5754        if (native)
Note: See TracChangeset for help on using the changeset viewer.