开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
rock.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：16k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

rock.c：源码内容
  1. /*
  2.  *  linux/fs/isofs/rock.c
  3.  *
  4.  *  (C) 1992, 1993  Eric Youngdale
  5.  *
  6.  *  Rock Ridge Extensions to iso9660
  7.  */
  9. #include <linux/stat.h>
  10. #include <linux/sched.h>
  11. #include <linux/iso_fs.h>
  12. #include <linux/string.h>
  13. #include <linux/mm.h>
  14. #include <linux/slab.h>
  15. #include <linux/pagemap.h>
  16. #include <linux/smp_lock.h>
  18. #include "rock.h"
  20. /* These functions are designed to read the system areas of a directory record
  21.  * and extract relevant information.  There are different functions provided
  22.  * depending upon what information we need at the time.  One function fills
  23.  * out an inode structure, a second one extracts a filename, a third one
  24.  * returns a symbolic link name, and a fourth one returns the extent number
  25.  * for the file. */
  27. #define SIG(A,B) ((A) | ((B) << 8)) /* isonum_721() */
  30. /* This is a way of ensuring that we have something in the system
  31.    use fields that is compatible with Rock Ridge */
  32. #define CHECK_SP(FAIL)        
  33.       if(rr->u.SP.magic[0] != 0xbe) FAIL;
  34.       if(rr->u.SP.magic[1] != 0xef) FAIL;       
  35.       inode->i_sb->u.isofs_sb.s_rock_offset=rr->u.SP.skip;
  36. /* We define a series of macros because each function must do exactly the
  37.    same thing in certain places.  We use the macros to ensure that everything
  38.    is done correctly */
  40. #define CONTINUE_DECLS 
  41.   int cont_extent = 0, cont_offset = 0, cont_size = 0;   
  42.   void * buffer = 0
  44. #define CHECK_CE        
  45.       {cont_extent = isonum_733(rr->u.CE.extent); 
  46.       cont_offset = isonum_733(rr->u.CE.offset); 
  47.       cont_size = isonum_733(rr->u.CE.size);}
  49. #define SETUP_ROCK_RIDGE(DE,CHR,LEN)              
  50.   {LEN= sizeof(struct iso_directory_record) + DE->name_len[0];
  51.   if(LEN & 1) LEN++;
  52.   CHR = ((unsigned char *) DE) + LEN;
  53.   LEN = *((unsigned char *) DE) - LEN;                          
  54.   if (inode->i_sb->u.isofs_sb.s_rock_offset!=-1)                
  55.   {                                                             
  56.      LEN-=inode->i_sb->u.isofs_sb.s_rock_offset;                
  57.      CHR+=inode->i_sb->u.isofs_sb.s_rock_offset;                
  58.      if (LEN<0) LEN=0;                                          
  59.   }                                                             
  60. }                                     
  62. #define MAYBE_CONTINUE(LABEL,DEV) 
  63.   {if (buffer) kfree(buffer); 
  64.   if (cont_extent){ 
  65.     int block, offset, offset1; 
  66.     struct buffer_head * pbh; 
  67.     buffer = kmalloc(cont_size,GFP_KERNEL); 
  68.     if (!buffer) goto out; 
  69.     block = cont_extent; 
  70.     offset = cont_offset; 
  71.     offset1 = 0; 
  72.     pbh = sb_bread(DEV->i_sb, block); 
  73.     if(pbh){       
  74.       memcpy(buffer + offset1, pbh->b_data + offset, cont_size - offset1); 
  75.       brelse(pbh); 
  76.       chr = (unsigned char *) buffer; 
  77.       len = cont_size; 
  78.       cont_extent = 0; 
  79.       cont_size = 0; 
  80.       cont_offset = 0; 
  81.       goto LABEL; 
  82.     }    
  83.     printk("Unable to read rock-ridge attributesn");    
  84.   }}
  86. /* This is the inner layer of the get filename routine, and is called
  87.    for each system area and continuation record related to the file */
  89. int find_rock_ridge_relocation(struct iso_directory_record * de, 
  90.        struct inode * inode) {
  91.   int flag;
  92.   int len;
  93.   int retval;
  94.   unsigned char * chr;
  95.   CONTINUE_DECLS;
  96.   flag = 0;
  97.   
  98.   /* If this is a '..' then we are looking for the parent, otherwise we
  99.      are looking for the child */
  100.   
  101.   if (de->name[0]==1 && de->name_len[0]==1) flag = 1;
  102.   /* Return value if we do not find appropriate record. */
  103.   retval = isonum_733 (de->extent);
  104.   
  105.   if (!inode->i_sb->u.isofs_sb.s_rock) return retval;
  107.   SETUP_ROCK_RIDGE(de, chr, len);
  108.  repeat:
  109.   {
  110.     int rrflag, sig;
  111.     struct rock_ridge * rr;
  112.     
  113.     while (len > 1){ /* There may be one byte for padding somewhere */
  114.       rr = (struct rock_ridge *) chr;
  115.       if (rr->len == 0) goto out; /* Something got screwed up here */
  116.       sig = isonum_721(chr);
  117.       chr += rr->len; 
  118.       len -= rr->len;
  120.       switch(sig){
  121.       case SIG('R','R'):
  122. rrflag = rr->u.RR.flags[0];
  123. if (flag && !(rrflag & RR_PL)) goto out;
  124. if (!flag && !(rrflag & RR_CL)) goto out;
  125. break;
  126.       case SIG('S','P'):
  127. CHECK_SP(goto out);
  128. break;
  129.       case SIG('C','L'):
  130. if (flag == 0) {
  131.   retval = isonum_733(rr->u.CL.location);
  132.   goto out;
  133. }
  134. break;
  135.       case SIG('P','L'):
  136. if (flag != 0) {
  137.   retval = isonum_733(rr->u.PL.location);
  138.   goto out;
  139. }
  140. break;
  141.       case SIG('C','E'):
  142. CHECK_CE; /* This tells is if there is a continuation record */
  143. break;
  144.       default:
  145. break;
  146.       }
  147.     }
  148.   }
  149.   MAYBE_CONTINUE(repeat, inode);
  150.   return retval;
  151.  out:
  152.   if(buffer) kfree(buffer);
  153.   return retval;
  154. }
  156. /* return length of name field; 0: not found, -1: to be ignored */
  157. int get_rock_ridge_filename(struct iso_directory_record * de,
  158.     char * retname, struct inode * inode)
  159. {
  160.   int len;
  161.   unsigned char * chr;
  162.   CONTINUE_DECLS;
  163.   int retnamlen = 0, truncate=0;
  164.  
  165.   if (!inode->i_sb->u.isofs_sb.s_rock) return 0;
  166.   *retname = 0;
  168.   SETUP_ROCK_RIDGE(de, chr, len);
  169.  repeat:
  170.   {
  171.     struct rock_ridge * rr;
  172.     int sig;
  173.     
  174.     while (len > 1){ /* There may be one byte for padding somewhere */
  175.       rr = (struct rock_ridge *) chr;
  176.       if (rr->len == 0) goto out; /* Something got screwed up here */
  177.       sig = isonum_721(chr);
  178.       chr += rr->len; 
  179.       len -= rr->len;
  181.       switch(sig){
  182.       case SIG('R','R'):
  183. if((rr->u.RR.flags[0] & RR_NM) == 0) goto out;
  184. break;
  185.       case SIG('S','P'):
  186. CHECK_SP(goto out);
  187. break;
  188.       case SIG('C','E'):
  189. CHECK_CE;
  190. break;
  191.       case SIG('N','M'):
  192. if (truncate) break;
  193.         /*
  194.  * If the flags are 2 or 4, this indicates '.' or '..'.
  195.  * We don't want to do anything with this, because it
  196.  * screws up the code that calls us.  We don't really
  197.  * care anyways, since we can just use the non-RR
  198.  * name.
  199.  */
  200. if (rr->u.NM.flags & 6) {
  201.   break;
  202. }
  204. if (rr->u.NM.flags & ~1) {
  205.   printk("Unsupported NM flag settings (%d)n",rr->u.NM.flags);
  206.   break;
  207. }
  208. if((strlen(retname) + rr->len - 5) >= 254) {
  209.   truncate = 1;
  210.   break;
  211. }
  212. strncat(retname, rr->u.NM.name, rr->len - 5);
  213. retnamlen += rr->len - 5;
  214. break;
  215.       case SIG('R','E'):
  216. if (buffer) kfree(buffer);
  217. return -1;
  218.       default:
  219. break;
  220.       }
  221.     }
  222.   }
  223.   MAYBE_CONTINUE(repeat,inode);
  224.   return retnamlen; /* If 0, this file did not have a NM field */
  225.  out:
  226.   if(buffer) kfree(buffer);
  227.   return 0;
  228. }
  230. int parse_rock_ridge_inode_internal(struct iso_directory_record * de,
  231.             struct inode * inode,int regard_xa){
  232.   int len;
  233.   unsigned char * chr;
  234.   int symlink_len = 0;
  235.   CONTINUE_DECLS;
  237.   if (!inode->i_sb->u.isofs_sb.s_rock) return 0;
  239.   SETUP_ROCK_RIDGE(de, chr, len);
  240.   if (regard_xa)
  241.    {
  242.      chr+=14;
  243.      len-=14;
  244.      if (len<0) len=0;
  245.    };
  246.    
  247.  repeat:
  248.   {
  249.     int cnt, sig;
  250.     struct inode * reloc;
  251.     struct rock_ridge * rr;
  252.     int rootflag;
  253.     
  254.     while (len > 1){ /* There may be one byte for padding somewhere */
  255.       rr = (struct rock_ridge *) chr;
  256.       if (rr->len == 0) goto out; /* Something got screwed up here */
  257.       sig = isonum_721(chr);
  258.       chr += rr->len; 
  259.       len -= rr->len;
  260.       
  261.       switch(sig){
  262. #ifndef CONFIG_ZISOFS /* No flag for SF or ZF */
  263.       case SIG('R','R'):
  264. if((rr->u.RR.flags[0] & 
  265.       (RR_PX | RR_TF | RR_SL | RR_CL)) == 0) goto out;
  266. break;
  267. #endif
  268.       case SIG('S','P'):
  269. CHECK_SP(goto out);
  270. break;
  271.       case SIG('C','E'):
  272. CHECK_CE;
  273. break;
  274.       case SIG('E','R'):
  275. inode->i_sb->u.isofs_sb.s_rock = 1;
  276. printk(KERN_DEBUG "ISO 9660 Extensions: ");
  277. { int p;
  278.   for(p=0;p<rr->u.ER.len_id;p++) printk("%c",rr->u.ER.data[p]);
  279. }
  280.   printk("n");
  281. break;
  282.       case SIG('P','X'):
  283. inode->i_mode  = isonum_733(rr->u.PX.mode);
  284. inode->i_nlink = isonum_733(rr->u.PX.n_links);
  285. inode->i_uid   = isonum_733(rr->u.PX.uid);
  286. inode->i_gid   = isonum_733(rr->u.PX.gid);
  287. break;
  288.       case SIG('P','N'):
  289. { int high, low;
  290.   high = isonum_733(rr->u.PN.dev_high);
  291.   low = isonum_733(rr->u.PN.dev_low);
  292.   /*
  293.    * The Rock Ridge standard specifies that if sizeof(dev_t) <= 4,
  294.    * then the high field is unused, and the device number is completely
  295.    * stored in the low field.  Some writers may ignore this subtlety,
  296.    * and as a result we test to see if the entire device number is
  297.    * stored in the low field, and use that.
  298.    */
  299.   if((low & ~0xff) && high == 0) {
  300.     inode->i_rdev = MKDEV(low >> 8, low & 0xff);
  301.   } else {
  302.     inode->i_rdev = MKDEV(high, low);
  303.   }
  304. }
  305. break;
  306.       case SIG('T','F'):
  307. /* Some RRIP writers incorrectly place ctime in the TF_CREATE field.
  308.    Try to handle this correctly for either case. */
  309. cnt = 0; /* Rock ridge never appears on a High Sierra disk */
  310. if(rr->u.TF.flags & TF_CREATE) 
  311.   inode->i_ctime = iso_date(rr->u.TF.times[cnt++].time, 0);
  312. if(rr->u.TF.flags & TF_MODIFY) 
  313.   inode->i_mtime = iso_date(rr->u.TF.times[cnt++].time, 0);
  314. if(rr->u.TF.flags & TF_ACCESS) 
  315.   inode->i_atime = iso_date(rr->u.TF.times[cnt++].time, 0);
  316. if(rr->u.TF.flags & TF_ATTRIBUTES) 
  317.   inode->i_ctime = iso_date(rr->u.TF.times[cnt++].time, 0);
  318. break;
  319.       case SIG('S','L'):
  320. {int slen;
  321.  struct SL_component * slp;
  322.  struct SL_component * oldslp;
  323.  slen = rr->len - 5;
  324.  slp = &rr->u.SL.link;
  325.  inode->i_size = symlink_len;
  326.  while (slen > 1){
  327.    rootflag = 0;
  328.    switch(slp->flags &~1){
  329.    case 0:
  330.      inode->i_size += slp->len;
  331.      break;
  332.    case 2:
  333.      inode->i_size += 1;
  334.      break;
  335.    case 4:
  336.      inode->i_size += 2;
  337.      break;
  338.    case 8:
  339.      rootflag = 1;
  340.      inode->i_size += 1;
  341.      break;
  342.    default:
  343.      printk("Symlink component flag not implementedn");
  344.    }
  345.    slen -= slp->len + 2;
  346.    oldslp = slp;
  347.    slp = (struct SL_component *) (((char *) slp) + slp->len + 2);
  349.    if(slen < 2) {
  350.      if(    ((rr->u.SL.flags & 1) != 0) 
  351.     && ((oldslp->flags & 1) == 0) ) inode->i_size += 1;
  352.      break;
  353.    }
  355.    /*
  356.     * If this component record isn't continued, then append a '/'.
  357.     */
  358.    if (!rootflag && (oldslp->flags & 1) == 0)
  359.    inode->i_size += 1;
  360.  }
  361. }
  362. symlink_len = inode->i_size;
  363. break;
  364.       case SIG('R','E'):
  365. printk(KERN_WARNING "Attempt to read inode for relocated directoryn");
  366. goto out;
  367.       case SIG('C','L'):
  368. inode->u.isofs_i.i_first_extent = isonum_733(rr->u.CL.location);
  369. reloc = iget(inode->i_sb,
  370.      (inode->u.isofs_i.i_first_extent <<
  371.       inode -> i_sb -> u.isofs_sb.s_log_zone_size));
  372. if (!reloc)
  373. goto out;
  374. inode->i_mode = reloc->i_mode;
  375. inode->i_nlink = reloc->i_nlink;
  376. inode->i_uid = reloc->i_uid;
  377. inode->i_gid = reloc->i_gid;
  378. inode->i_rdev = reloc->i_rdev;
  379. inode->i_size = reloc->i_size;
  380. inode->i_blocks = reloc->i_blocks;
  381. inode->i_atime = reloc->i_atime;
  382. inode->i_ctime = reloc->i_ctime;
  383. inode->i_mtime = reloc->i_mtime;
  384. iput(reloc);
  385. break;
  386. #ifdef CONFIG_ZISOFS
  387.       case SIG('Z','F'):
  388.       if ( !inode->i_sb->u.isofs_sb.s_nocompress ) {
  389.       int algo;
  390.       algo = isonum_721(rr->u.ZF.algorithm);
  391.       if ( algo == SIG('p','z') ) {
  392.       int block_shift = isonum_711(&rr->u.ZF.parms[1]);
  393.       if ( block_shift < PAGE_CACHE_SHIFT || block_shift > 17 ) {
  394.       printk(KERN_WARNING "isofs: Can't handle ZF block size of 2^%dn", block_shift);
  395.       } else {
  396. /* Note: we don't change i_blocks here */
  397.       inode->u.isofs_i.i_file_format = isofs_file_compressed;
  398. /* Parameters to compression algorithm (header size, block size) */
  399.       inode->u.isofs_i.i_format_parm[0] = isonum_711(&rr->u.ZF.parms[0]);
  400.       inode->u.isofs_i.i_format_parm[1] = isonum_711(&rr->u.ZF.parms[1]);
  401.       inode->i_size = isonum_733(rr->u.ZF.real_size);
  402.       }
  403.       } else {
  404.       printk(KERN_WARNING "isofs: Unknown ZF compression algorithm: %c%cn",
  405.      rr->u.ZF.algorithm[0], rr->u.ZF.algorithm[1]);
  406.       }
  407.       }
  408.       break;
  409. #endif
  410.       default:
  411. break;
  412.       }
  413.     }
  414.   }
  415.   MAYBE_CONTINUE(repeat,inode);
  416.   return 0;
  417.  out:
  418.   if(buffer) kfree(buffer);
  419.   return 0;
  420. }
  422. static char *get_symlink_chunk(char *rpnt, struct rock_ridge *rr)
  423. {
  424. int slen;
  425. int rootflag;
  426. struct SL_component *oldslp;
  427. struct SL_component *slp;
  428. slen = rr->len - 5;
  429. slp = &rr->u.SL.link;
  430. while (slen > 1) {
  431. rootflag = 0;
  432. switch (slp->flags & ~1) {
  433. case 0:
  434. memcpy(rpnt, slp->text, slp->len);
  435. rpnt+=slp->len;
  436. break;
  437. case 4:
  438. *rpnt++='.';
  439. /* fallthru */
  440. case 2:
  441. *rpnt++='.';
  442. break;
  443. case 8:
  444. rootflag = 1;
  445. *rpnt++='/';
  446. break;
  447. default:
  448. printk("Symlink component flag not implemented (%d)n",
  449.      slp->flags);
  450. }
  451. slen -= slp->len + 2;
  452. oldslp = slp;
  453. slp = (struct SL_component *) ((char *) slp + slp->len + 2);
  455. if (slen < 2) {
  456. /*
  457.  * If there is another SL record, and this component
  458.  * record isn't continued, then add a slash.
  459.  */
  460. if ((!rootflag) && (rr->u.SL.flags & 1) && !(oldslp->flags & 1))
  461. *rpnt++='/';
  462. break;
  463. }
  465. /*
  466.  * If this component record isn't continued, then append a '/'.
  467.  */
  468. if (!rootflag && !(oldslp->flags & 1))
  469. *rpnt++='/';
  471. }
  472. return rpnt;
  473. }
  475. int parse_rock_ridge_inode(struct iso_directory_record * de,
  476.    struct inode * inode)
  477. {
  478.    int result=parse_rock_ridge_inode_internal(de,inode,0);
  479.    /* if rockridge flag was reset and we didn't look for attributes
  480.     * behind eventual XA attributes, have a look there */
  481.    if ((inode->i_sb->u.isofs_sb.s_rock_offset==-1)
  482.        &&(inode->i_sb->u.isofs_sb.s_rock==2))
  483.      {
  484. result=parse_rock_ridge_inode_internal(de,inode,14);
  485.      };
  486.    return result;
  487. };
  489. /* readpage() for symlinks: reads symlink contents into the page and either
  490.    makes it uptodate and returns 0 or returns error (-EIO) */
  492. static int rock_ridge_symlink_readpage(struct file *file, struct page *page)
  493. {
  494. struct inode *inode = page->mapping->host;
  495. char *link = kmap(page);
  496. unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
  497. unsigned char bufbits = ISOFS_BUFFER_BITS(inode);
  498. struct buffer_head *bh;
  499. char *rpnt = link;
  500. unsigned char *pnt;
  501. struct iso_directory_record *raw_inode;
  502. CONTINUE_DECLS;
  503. int block;
  504. int sig;
  505. int len;
  506. unsigned char *chr;
  507. struct rock_ridge *rr;
  509. if (!inode->i_sb->u.isofs_sb.s_rock)
  510. panic ("Cannot have symlink with high sierra variant of iso filesystemn");
  512. block = inode->i_ino >> bufbits;
  513. lock_kernel();
  514. bh = sb_bread(inode->i_sb, block);
  515. if (!bh)
  516. goto out_noread;
  518. pnt = (unsigned char *) bh->b_data + (inode->i_ino & (bufsize - 1));
  520. raw_inode = (struct iso_directory_record *) pnt;
  522. /*
  523.  * If we go past the end of the buffer, there is some sort of error.
  524.  */
  525. if ((inode->i_ino & (bufsize - 1)) + *pnt > bufsize)
  526. goto out_bad_span;
  528. /* Now test for possible Rock Ridge extensions which will override
  529.    some of these numbers in the inode structure. */
  531. SETUP_ROCK_RIDGE(raw_inode, chr, len);
  533.       repeat:
  534. while (len > 1) { /* There may be one byte for padding somewhere */
  535. rr = (struct rock_ridge *) chr;
  536. if (rr->len == 0)
  537. goto out; /* Something got screwed up here */
  538. sig = isonum_721(chr);
  539. chr += rr->len;
  540. len -= rr->len;
  542. switch (sig) {
  543. case SIG('R', 'R'):
  544. if ((rr->u.RR.flags[0] & RR_SL) == 0)
  545. goto out;
  546. break;
  547. case SIG('S', 'P'):
  548. CHECK_SP(goto out);
  549. break;
  550. case SIG('S', 'L'):
  551. rpnt = get_symlink_chunk(rpnt, rr);
  552. break;
  553. case SIG('C', 'E'):
  554. /* This tells is if there is a continuation record */
  555. CHECK_CE;
  556. default:
  557. break;
  558. }
  559. }
  560. MAYBE_CONTINUE(repeat, inode);
  562. if (rpnt == link)
  563. goto fail;
  564. brelse(bh);
  565. *rpnt = '';
  566. unlock_kernel();
  567. SetPageUptodate(page);
  568. kunmap(page);
  569. UnlockPage(page);
  570. return 0;
  572. /* error exit from macro */
  573.       out:
  574. if (buffer)
  575. kfree(buffer);
  576. goto fail;
  577.       out_noread:
  578. printk("unable to read i-node block");
  579. goto fail;
  580.       out_bad_span:
  581. printk("symlink spans iso9660 blocksn");
  582.       fail:
  583. brelse(bh);
  584. unlock_kernel();
  585. SetPageError(page);
  586. kunmap(page);
  587. UnlockPage(page);
  588. return -EIO;
  589. }
  591. struct address_space_operations isofs_symlink_aops = {
  592. readpage: rock_ridge_symlink_readpage
  593. };