ialloc.c

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  * ialloc.c
    3  *
    4  * PURPOSE
    5  *      Inode allocation handling routines for the OSTA-UDF(tm) filesystem.
    6  *
    7  * COPYRIGHT
    8  *      This file is distributed under the terms of the GNU General Public
    9  *      License (GPL). Copies of the GPL can be obtained from:
   10  *              ftp://prep.ai.mit.edu/pub/gnu/GPL
   11  *      Each contributing author retains all rights to their own work.
   12  *
   13  *  (C) 1998-2001 Ben Fennema
   14  *
   15  * HISTORY
   16  *
   17  *  02/24/99 blf  Created.
   18  *
   19  */
   20 
   21 #include "udfdecl.h"
   22 #include <linux/fs.h>
   23 #include <linux/sched.h>
   24 #include <linux/slab.h>
   25 
   26 #include "udf_i.h"
   27 #include "udf_sb.h"
   28 
   29 void udf_free_inode(struct inode *inode)
   30 {
   31         struct super_block *sb = inode->i_sb;
   32         struct udf_sb_info *sbi = UDF_SB(sb);
   33 
   34         mutex_lock(&sbi->s_alloc_mutex);
   35         if (sbi->s_lvid_bh) {
   36                 struct logicalVolIntegrityDescImpUse *lvidiu =
   37                                                         udf_sb_lvidiu(sbi);
   38                 if (S_ISDIR(inode->i_mode))
   39                         le32_add_cpu(&lvidiu->numDirs, -1);
   40                 else
   41                         le32_add_cpu(&lvidiu->numFiles, -1);
   42                 udf_updated_lvid(sb);
   43         }
   44         mutex_unlock(&sbi->s_alloc_mutex);
   45 
   46         udf_free_blocks(sb, NULL, &UDF_I(inode)->i_location, 0, 1);
   47 }
   48 
   49 struct inode *udf_new_inode(struct inode *dir, umode_t mode, int *err)
   50 {
   51         struct super_block *sb = dir->i_sb;
   52         struct udf_sb_info *sbi = UDF_SB(sb);
   53         struct inode *inode;
   54         int block;
   55         uint32_t start = UDF_I(dir)->i_location.logicalBlockNum;
   56         struct udf_inode_info *iinfo;
   57         struct udf_inode_info *dinfo = UDF_I(dir);
   58 
   59         inode = new_inode(sb);
   60 
   61         if (!inode) {
   62                 *err = -ENOMEM;
   63                 return NULL;
   64         }
   65         *err = -ENOSPC;
   66 
   67         iinfo = UDF_I(inode);
   68         if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_EXTENDED_FE)) {
   69                 iinfo->i_efe = 1;
   70                 if (UDF_VERS_USE_EXTENDED_FE > sbi->s_udfrev)
   71                         sbi->s_udfrev = UDF_VERS_USE_EXTENDED_FE;
   72                 iinfo->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -
   73                                             sizeof(struct extendedFileEntry),
   74                                             GFP_KERNEL);
   75         } else {
   76                 iinfo->i_efe = 0;
   77                 iinfo->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -
   78                                             sizeof(struct fileEntry),
   79                                             GFP_KERNEL);
   80         }
   81         if (!iinfo->i_ext.i_data) {
   82                 iput(inode);
   83                 *err = -ENOMEM;
   84                 return NULL;
   85         }
   86 
   87         block = udf_new_block(dir->i_sb, NULL,
   88                               dinfo->i_location.partitionReferenceNum,
   89                               start, err);
   90         if (*err) {
   91                 iput(inode);
   92                 return NULL;
   93         }
   94 
   95         if (sbi->s_lvid_bh) {
   96                 struct logicalVolIntegrityDescImpUse *lvidiu;
   97 
   98                 iinfo->i_unique = lvid_get_unique_id(sb);
   99                 mutex_lock(&sbi->s_alloc_mutex);
  100                 lvidiu = udf_sb_lvidiu(sbi);
  101                 if (S_ISDIR(mode))
  102                         le32_add_cpu(&lvidiu->numDirs, 1);
  103                 else
  104                         le32_add_cpu(&lvidiu->numFiles, 1);
  105                 udf_updated_lvid(sb);
  106                 mutex_unlock(&sbi->s_alloc_mutex);
  107         }
  108 
  109         inode_init_owner(inode, dir, mode);
  110 
  111         iinfo->i_location.logicalBlockNum = block;
  112         iinfo->i_location.partitionReferenceNum =
  113                                 dinfo->i_location.partitionReferenceNum;
  114         inode->i_ino = udf_get_lb_pblock(sb, &iinfo->i_location, 0);
  115         inode->i_blocks = 0;
  116         iinfo->i_lenEAttr = 0;
  117         iinfo->i_lenAlloc = 0;
  118         iinfo->i_use = 0;
  119         iinfo->i_checkpoint = 1;
  120         if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_AD_IN_ICB))
  121                 iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
  122         else if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
  123                 iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
  124         else
  125                 iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
  126         inode->i_mtime = inode->i_atime = inode->i_ctime =
  127                 iinfo->i_crtime = current_fs_time(inode->i_sb);
  128         insert_inode_hash(inode);
  129         mark_inode_dirty(inode);
  130 
  131         *err = 0;
  132         return inode;
  133 }

Cache object: e925808187a025f90bd3169dca57caac

[ 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/udf/ialloc.c

FreeBSD/Linux Kernel Cross Reference
sys/fs/udf/ialloc.c