fs/udf/directory.c

   1 /*
   2  * directory.c
   3  *
   4  * PURPOSE
   5  *      Directory related functions
   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
  14 #include "udfdecl.h"
  15 #include "udf_i.h"
  16
  17 #include <linux/fs.h>
  18 #include <linux/string.h>
  19 #include <linux/bio.h>
  20 #include <linux/crc-itu-t.h>
  21 #include <linux/iversion.h>
  22
  23 static int udf_verify_fi(struct udf_fileident_iter *iter)
  24 {
  25         unsigned int len;
  26
  27         if (iter->fi.descTag.tagIdent != cpu_to_le16(TAG_IDENT_FID)) {
  28                 udf_err(iter->dir->i_sb,
  29                         "directory (ino %lu) has entry at pos %llu with incorrect tag %x\n",
  30                         iter->dir->i_ino, (unsigned long long)iter->pos,
  31                         le16_to_cpu(iter->fi.descTag.tagIdent));
  32                 return -EFSCORRUPTED;
  33         }
  34         len = udf_dir_entry_len(&iter->fi);
  35         if (le16_to_cpu(iter->fi.lengthOfImpUse) & 3) {
  36                 udf_err(iter->dir->i_sb,
  37                         "directory (ino %lu) has entry at pos %llu with unaligned lenght of impUse field\n",
  38                         iter->dir->i_ino, (unsigned long long)iter->pos);
  39                 return -EFSCORRUPTED;
  40         }
  41         /*
  42          * This is in fact allowed by the spec due to long impUse field but
  43          * we don't support it. If there is real media with this large impUse
  44          * field, support can be added.
  45          */
  46         if (len > 1 << iter->dir->i_blkbits) {
  47                 udf_err(iter->dir->i_sb,
  48                         "directory (ino %lu) has too big (%u) entry at pos %llu\n",
  49                         iter->dir->i_ino, len, (unsigned long long)iter->pos);
  50                 return -EFSCORRUPTED;
  51         }
  52         if (iter->pos + len > iter->dir->i_size) {
  53                 udf_err(iter->dir->i_sb,
  54                         "directory (ino %lu) has entry past directory size at pos %llu\n",
  55                         iter->dir->i_ino, (unsigned long long)iter->pos);
  56                 return -EFSCORRUPTED;
  57         }
  58         if (udf_dir_entry_len(&iter->fi) !=
  59             sizeof(struct tag) + le16_to_cpu(iter->fi.descTag.descCRCLength)) {
  60                 udf_err(iter->dir->i_sb,
  61                         "directory (ino %lu) has entry where CRC length (%u) does not match entry length (%u)\n",
  62                         iter->dir->i_ino,
  63                         (unsigned)le16_to_cpu(iter->fi.descTag.descCRCLength),
  64                         (unsigned)(udf_dir_entry_len(&iter->fi) -
  65                                                         sizeof(struct tag)));
  66                 return -EFSCORRUPTED;
  67         }
  68         return 0;
  69 }
  70
  71 static int udf_copy_fi(struct udf_fileident_iter *iter)
  72 {
  73         struct udf_inode_info *iinfo = UDF_I(iter->dir);
  74         int blksize = 1 << iter->dir->i_blkbits;
  75         int err, off, len, nameoff;
  76
  77         /* Skip copying when we are at EOF */
  78         if (iter->pos >= iter->dir->i_size) {
  79                 iter->name = NULL;
  80                 return 0;
  81         }
  82         if (iter->dir->i_size < iter->pos + sizeof(struct fileIdentDesc)) {
  83                 udf_err(iter->dir->i_sb,
  84                         "directory (ino %lu) has entry straddling EOF\n",
  85                         iter->dir->i_ino);
  86                 return -EFSCORRUPTED;
  87         }
  88         if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
  89                 memcpy(&iter->fi, iinfo->i_data + iinfo->i_lenEAttr + iter->pos,
  90                        sizeof(struct fileIdentDesc));
  91                 err = udf_verify_fi(iter);
  92                 if (err < 0)
  93                         return err;
  94                 iter->name = iinfo->i_data + iinfo->i_lenEAttr + iter->pos +
  95                         sizeof(struct fileIdentDesc) +
  96                         le16_to_cpu(iter->fi.lengthOfImpUse);
  97                 return 0;
  98         }
  99
 100         off = iter->pos & (blksize - 1);
 101         len = min_t(int, sizeof(struct fileIdentDesc), blksize - off);
 102         memcpy(&iter->fi, iter->bh[0]->b_data + off, len);
 103         if (len < sizeof(struct fileIdentDesc))
 104                 memcpy((char *)(&iter->fi) + len, iter->bh[1]->b_data,
 105                        sizeof(struct fileIdentDesc) - len);
 106         err = udf_verify_fi(iter);
 107         if (err < 0)
 108                 return err;
 109
 110         /* Handle directory entry name */
 111         nameoff = off + sizeof(struct fileIdentDesc) +
 112                                 le16_to_cpu(iter->fi.lengthOfImpUse);
 113         if (off + udf_dir_entry_len(&iter->fi) <= blksize) {
 114                 iter->name = iter->bh[0]->b_data + nameoff;
 115         } else if (nameoff >= blksize) {
 116                 iter->name = iter->bh[1]->b_data + (nameoff - blksize);
 117         } else {
 118                 iter->name = iter->namebuf;
 119                 len = blksize - nameoff;
 120                 memcpy(iter->name, iter->bh[0]->b_data + nameoff, len);
 121                 memcpy(iter->name + len, iter->bh[1]->b_data,
 122                        iter->fi.lengthFileIdent - len);
 123         }
 124         return 0;
 125 }
 126
 127 /* Readahead 8k once we are at 8k boundary */
 128 static void udf_readahead_dir(struct udf_fileident_iter *iter)
 129 {
 130         unsigned int ralen = 16 >> (iter->dir->i_blkbits - 9);
 131         struct buffer_head *tmp, *bha[16];
 132         int i, num;
 133         udf_pblk_t blk;
 134
 135         if (iter->loffset & (ralen - 1))
 136                 return;
 137
 138         if (iter->loffset + ralen > (iter->elen >> iter->dir->i_blkbits))
 139                 ralen = (iter->elen >> iter->dir->i_blkbits) - iter->loffset;
 140         num = 0;
 141         for (i = 0; i < ralen; i++) {
 142                 blk = udf_get_lb_pblock(iter->dir->i_sb, &iter->eloc,
 143                                         iter->loffset + i);
 144                 tmp = udf_tgetblk(iter->dir->i_sb, blk);
 145                 if (tmp && !buffer_uptodate(tmp) && !buffer_locked(tmp))
 146                         bha[num++] = tmp;
 147                 else
 148                         brelse(tmp);
 149         }
 150         if (num) {
 151                 bh_readahead_batch(num, bha, REQ_RAHEAD);
 152                 for (i = 0; i < num; i++)
 153                         brelse(bha[i]);
 154         }
 155 }
 156
 157 static struct buffer_head *udf_fiiter_bread_blk(struct udf_fileident_iter *iter)
 158 {
 159         udf_pblk_t blk;
 160
 161         udf_readahead_dir(iter);
 162         blk = udf_get_lb_pblock(iter->dir->i_sb, &iter->eloc, iter->loffset);
 163         return udf_tread(iter->dir->i_sb, blk);
 164 }
 165
 166 /*
 167  * Updates loffset to point to next directory block; eloc, elen & epos are
 168  * updated if we need to traverse to the next extent as well.
 169  */
 170 static int udf_fiiter_advance_blk(struct udf_fileident_iter *iter)
 171 {
 172         iter->loffset++;
 173         if (iter->loffset < iter->elen >> iter->dir->i_blkbits)
 174                 return 0;
 175
 176         iter->loffset = 0;
 177         if (udf_next_aext(iter->dir, &iter->epos, &iter->eloc, &iter->elen, 1)
 178                         != (EXT_RECORDED_ALLOCATED >> 30)) {
 179                 if (iter->pos == iter->dir->i_size) {
 180                         iter->elen = 0;
 181                         return 0;
 182                 }
 183                 udf_err(iter->dir->i_sb,
 184                         "extent after position %llu not allocated in directory (ino %lu)\n",
 185                         (unsigned long long)iter->pos, iter->dir->i_ino);
 186                 return -EFSCORRUPTED;
 187         }
 188         return 0;
 189 }
 190
 191 static int udf_fiiter_load_bhs(struct udf_fileident_iter *iter)
 192 {
 193         int blksize = 1 << iter->dir->i_blkbits;
 194         int off = iter->pos & (blksize - 1);
 195         int err;
 196         struct fileIdentDesc *fi;
 197
 198         /* Is there any further extent we can map from? */
 199         if (!iter->bh[0] && iter->elen) {
 200                 iter->bh[0] = udf_fiiter_bread_blk(iter);
 201                 if (!iter->bh[0]) {
 202                         err = -ENOMEM;
 203                         goto out_brelse;
 204                 }
 205                 if (!buffer_uptodate(iter->bh[0])) {
 206                         err = -EIO;
 207                         goto out_brelse;
 208                 }
 209         }
 210         /* There's no next block so we are done */
 211         if (iter->pos >= iter->dir->i_size)
 212                 return 0;
 213         /* Need to fetch next block as well? */
 214         if (off + sizeof(struct fileIdentDesc) > blksize)
 215                 goto fetch_next;
 216         fi = (struct fileIdentDesc *)(iter->bh[0]->b_data + off);
 217         /* Need to fetch next block to get name? */
 218         if (off + udf_dir_entry_len(fi) > blksize) {
 219 fetch_next:
 220                 udf_fiiter_advance_blk(iter);
 221                 iter->bh[1] = udf_fiiter_bread_blk(iter);
 222                 if (!iter->bh[1]) {
 223                         err = -ENOMEM;
 224                         goto out_brelse;
 225                 }
 226                 if (!buffer_uptodate(iter->bh[1])) {
 227                         err = -EIO;
 228                         goto out_brelse;
 229                 }
 230         }
 231         return 0;
 232 out_brelse:
 233         brelse(iter->bh[0]);
 234         brelse(iter->bh[1]);
 235         iter->bh[0] = iter->bh[1] = NULL;
 236         return err;
 237 }
 238
 239 int udf_fiiter_init(struct udf_fileident_iter *iter, struct inode *dir,
 240                     loff_t pos)
 241 {
 242         struct udf_inode_info *iinfo = UDF_I(dir);
 243         int err = 0;
 244
 245         iter->dir = dir;
 246         iter->bh[0] = iter->bh[1] = NULL;
 247         iter->pos = pos;
 248         iter->elen = 0;
 249         iter->epos.bh = NULL;
 250         iter->name = NULL;
 251         iter->namebuf = kmalloc(UDF_NAME_LEN_CS0, GFP_KERNEL);
 252         if (!iter->namebuf)
 253                 return -ENOMEM;
 254
 255         if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
 256                 err = udf_copy_fi(iter);
 257                 goto out;
 258         }
 259
 260         if (inode_bmap(dir, iter->pos >> dir->i_blkbits, &iter->epos,
 261                        &iter->eloc, &iter->elen, &iter->loffset) !=
 262             (EXT_RECORDED_ALLOCATED >> 30)) {
 263                 if (pos == dir->i_size)
 264                         return 0;
 265                 udf_err(dir->i_sb,
 266                         "position %llu not allocated in directory (ino %lu)\n",
 267                         (unsigned long long)pos, dir->i_ino);
 268                 err = -EFSCORRUPTED;
 269                 goto out;
 270         }
 271         err = udf_fiiter_load_bhs(iter);
 272         if (err < 0)
 273                 goto out;
 274         err = udf_copy_fi(iter);
 275 out:
 276         if (err < 0)
 277                 udf_fiiter_release(iter);
 278         return err;
 279 }
 280
 281 int udf_fiiter_advance(struct udf_fileident_iter *iter)
 282 {
 283         unsigned int oldoff, len;
 284         int blksize = 1 << iter->dir->i_blkbits;
 285         int err;
 286
 287         oldoff = iter->pos & (blksize - 1);
 288         len = udf_dir_entry_len(&iter->fi);
 289         iter->pos += len;
 290         if (UDF_I(iter->dir)->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
 291                 if (oldoff + len >= blksize) {
 292                         brelse(iter->bh[0]);
 293                         iter->bh[0] = NULL;
 294                         /* Next block already loaded? */
 295                         if (iter->bh[1]) {
 296                                 iter->bh[0] = iter->bh[1];
 297                                 iter->bh[1] = NULL;
 298                         } else {
 299                                 udf_fiiter_advance_blk(iter);
 300                         }
 301                 }
 302                 err = udf_fiiter_load_bhs(iter);
 303                 if (err < 0)
 304                         return err;
 305         }
 306         return udf_copy_fi(iter);
 307 }
 308
 309 void udf_fiiter_release(struct udf_fileident_iter *iter)
 310 {
 311         iter->dir = NULL;
 312         brelse(iter->bh[0]);
 313         brelse(iter->bh[1]);
 314         iter->bh[0] = iter->bh[1] = NULL;
 315         kfree(iter->namebuf);
 316         iter->namebuf = NULL;
 317 }
 318
 319 static void udf_copy_to_bufs(void *buf1, int len1, void *buf2, int len2,
 320                              int off, void *src, int len)
 321 {
 322         int copy;
 323
 324         if (off >= len1) {
 325                 off -= len1;
 326         } else {
 327                 copy = min(off + len, len1) - off;
 328                 memcpy(buf1 + off, src, copy);
 329                 src += copy;
 330                 len -= copy;
 331                 off = 0;
 332         }
 333         if (len > 0) {
 334                 if (WARN_ON_ONCE(off + len > len2 || !buf2))
 335                         return;
 336                 memcpy(buf2 + off, src, len);
 337         }
 338 }
 339
 340 static uint16_t udf_crc_fi_bufs(void *buf1, int len1, void *buf2, int len2,
 341                                 int off, int len)
 342 {
 343         int copy;
 344         uint16_t crc = 0;
 345
 346         if (off >= len1) {
 347                 off -= len1;
 348         } else {
 349                 copy = min(off + len, len1) - off;
 350                 crc = crc_itu_t(crc, buf1 + off, copy);
 351                 len -= copy;
 352                 off = 0;
 353         }
 354         if (len > 0) {
 355                 if (WARN_ON_ONCE(off + len > len2 || !buf2))
 356                         return 0;
 357                 crc = crc_itu_t(crc, buf2 + off, len);
 358         }
 359         return crc;
 360 }
 361
 362 static void udf_copy_fi_to_bufs(char *buf1, int len1, char *buf2, int len2,
 363                                 int off, struct fileIdentDesc *fi,
 364                                 uint8_t *impuse, uint8_t *name)
 365 {
 366         uint16_t crc;
 367         int fioff = off;
 368         int crcoff = off + sizeof(struct tag);
 369         unsigned int crclen = udf_dir_entry_len(fi) - sizeof(struct tag);
 370
 371         udf_copy_to_bufs(buf1, len1, buf2, len2, off, fi,
 372                          sizeof(struct fileIdentDesc));
 373         off += sizeof(struct fileIdentDesc);
 374         if (impuse)
 375                 udf_copy_to_bufs(buf1, len1, buf2, len2, off, impuse,
 376                                  le16_to_cpu(fi->lengthOfImpUse));
 377         off += le16_to_cpu(fi->lengthOfImpUse);
 378         if (name)
 379                 udf_copy_to_bufs(buf1, len1, buf2, len2, off, name,
 380                                  fi->lengthFileIdent);
 381
 382         crc = udf_crc_fi_bufs(buf1, len1, buf2, len2, crcoff, crclen);
 383         fi->descTag.descCRC = cpu_to_le16(crc);
 384         fi->descTag.descCRCLength = cpu_to_le16(crclen);
 385         fi->descTag.tagChecksum = udf_tag_checksum(&fi->descTag);
 386
 387         udf_copy_to_bufs(buf1, len1, buf2, len2, fioff, fi, sizeof(struct tag));
 388 }
 389
 390 void udf_fiiter_write_fi(struct udf_fileident_iter *iter, uint8_t *impuse)
 391 {
 392         struct udf_inode_info *iinfo = UDF_I(iter->dir);
 393         void *buf1, *buf2 = NULL;
 394         int len1, len2 = 0, off;
 395         int blksize = 1 << iter->dir->i_blkbits;
 396
 397         off = iter->pos & (blksize - 1);
 398         if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
 399                 buf1 = iinfo->i_data + iinfo->i_lenEAttr;
 400                 len1 = iter->dir->i_size;
 401         } else {
 402                 buf1 = iter->bh[0]->b_data;
 403                 len1 = blksize;
 404                 if (iter->bh[1]) {
 405                         buf2 = iter->bh[1]->b_data;
 406                         len2 = blksize;
 407                 }
 408         }
 409
 410         udf_copy_fi_to_bufs(buf1, len1, buf2, len2, off, &iter->fi, impuse,
 411                             iter->name == iter->namebuf ? iter->name : NULL);
 412
 413         if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
 414                 mark_inode_dirty(iter->dir);
 415         } else {
 416                 mark_buffer_dirty_inode(iter->bh[0], iter->dir);
 417                 if (iter->bh[1])
 418                         mark_buffer_dirty_inode(iter->bh[1], iter->dir);
 419         }
 420         inode_inc_iversion(iter->dir);
 421 }
 422
 423 void udf_fiiter_update_elen(struct udf_fileident_iter *iter, uint32_t new_elen)
 424 {
 425         struct udf_inode_info *iinfo = UDF_I(iter->dir);
 426         int diff = new_elen - iter->elen;
 427
 428         /* Skip update when we already went past the last extent */
 429         if (!iter->elen)
 430                 return;
 431         iter->elen = new_elen;
 432         if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
 433                 iter->epos.offset -= sizeof(struct short_ad);
 434         else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
 435                 iter->epos.offset -= sizeof(struct long_ad);
 436         udf_write_aext(iter->dir, &iter->epos, &iter->eloc, iter->elen, 1);
 437         iinfo->i_lenExtents += diff;
 438         mark_inode_dirty(iter->dir);
 439 }
 440
 441 /* Append new block to directory. @iter is expected to point at EOF */
 442 int udf_fiiter_append_blk(struct udf_fileident_iter *iter)
 443 {
 444         struct udf_inode_info *iinfo = UDF_I(iter->dir);
 445         int blksize = 1 << iter->dir->i_blkbits;
 446         struct buffer_head *bh;
 447         sector_t block;
 448         uint32_t old_elen = iter->elen;
 449         int err;
 450
 451         if (WARN_ON_ONCE(iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB))
 452                 return -EINVAL;
 453
 454         /* Round up last extent in the file */
 455         udf_fiiter_update_elen(iter, ALIGN(iter->elen, blksize));
 456
 457         /* Allocate new block and refresh mapping information */
 458         block = iinfo->i_lenExtents >> iter->dir->i_blkbits;
 459         bh = udf_bread(iter->dir, block, 1, &err);
 460         if (!bh) {
 461                 udf_fiiter_update_elen(iter, old_elen);
 462                 return err;
 463         }
 464         if (inode_bmap(iter->dir, block, &iter->epos, &iter->eloc, &iter->elen,
 465                        &iter->loffset) != (EXT_RECORDED_ALLOCATED >> 30)) {
 466                 udf_err(iter->dir->i_sb,
 467                         "block %llu not allocated in directory (ino %lu)\n",
 468                         (unsigned long long)block, iter->dir->i_ino);
 469                 return -EFSCORRUPTED;
 470         }
 471         if (!(iter->pos & (blksize - 1))) {
 472                 brelse(iter->bh[0]);
 473                 iter->bh[0] = bh;
 474         } else {
 475                 iter->bh[1] = bh;
 476         }
 477         return 0;
 478 }
 479
 480 struct short_ad *udf_get_fileshortad(uint8_t *ptr, int maxoffset, uint32_t *offset,
 481                               int inc)
 482 {
 483         struct short_ad *sa;
 484
 485         if ((!ptr) || (!offset)) {
 486                 pr_err("%s: invalidparms\n", __func__);
 487                 return NULL;
 488         }
 489
 490         if ((*offset + sizeof(struct short_ad)) > maxoffset)
 491                 return NULL;
 492         else {
 493                 sa = (struct short_ad *)ptr;
 494                 if (sa->extLength == 0)
 495                         return NULL;
 496         }
 497
 498         if (inc)
 499                 *offset += sizeof(struct short_ad);
 500         return sa;
 501 }
 502
 503 struct long_ad *udf_get_filelongad(uint8_t *ptr, int maxoffset, uint32_t *offset, int inc)
 504 {
 505         struct long_ad *la;
 506
 507         if ((!ptr) || (!offset)) {
 508                 pr_err("%s: invalidparms\n", __func__);
 509                 return NULL;
 510         }
 511
 512         if ((*offset + sizeof(struct long_ad)) > maxoffset)
 513                 return NULL;
 514         else {
 515                 la = (struct long_ad *)ptr;
 516                 if (la->extLength == 0)
 517                         return NULL;
 518         }
 519
 520         if (inc)
 521                 *offset += sizeof(struct long_ad);
 522         return la;
 523 }