Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * fs/isofs/export.c |
| 3 | * |
| 4 | * (C) 2004 Paul Serice - The new inode scheme requires switching |
| 5 | * from iget() to iget5_locked() which means |
| 6 | * the NFS export operations have to be hand |
| 7 | * coded because the default routines rely on |
| 8 | * iget(). |
| 9 | * |
| 10 | * The following files are helpful: |
| 11 | * |
J. Bruce Fields | dc7a081 | 2009-10-27 14:41:35 -0400 | [diff] [blame] | 12 | * Documentation/filesystems/nfs/Exporting |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | * fs/exportfs/expfs.c. |
| 14 | */ |
| 15 | |
Al Viro | 94f2f71 | 2005-04-25 18:32:12 -0700 | [diff] [blame] | 16 | #include "isofs.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | |
| 18 | static struct dentry * |
| 19 | isofs_export_iget(struct super_block *sb, |
| 20 | unsigned long block, |
| 21 | unsigned long offset, |
| 22 | __u32 generation) |
| 23 | { |
| 24 | struct inode *inode; |
Christoph Hellwig | 4400372 | 2008-08-11 15:49:04 +0200 | [diff] [blame] | 25 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | if (block == 0) |
| 27 | return ERR_PTR(-ESTALE); |
| 28 | inode = isofs_iget(sb, block, offset); |
David Howells | c4386c8 | 2008-02-07 00:15:41 -0800 | [diff] [blame] | 29 | if (IS_ERR(inode)) |
| 30 | return ERR_CAST(inode); |
| 31 | if (generation && inode->i_generation != generation) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 32 | iput(inode); |
| 33 | return ERR_PTR(-ESTALE); |
| 34 | } |
Christoph Hellwig | 4400372 | 2008-08-11 15:49:04 +0200 | [diff] [blame] | 35 | return d_obtain_alias(inode); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | } |
| 37 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | /* This function is surprisingly simple. The trick is understanding |
| 39 | * that "child" is always a directory. So, to find its parent, you |
| 40 | * simply need to find its ".." entry, normalize its block and offset, |
| 41 | * and return the underlying inode. See the comments for |
| 42 | * isofs_normalize_block_and_offset(). */ |
| 43 | static struct dentry *isofs_export_get_parent(struct dentry *child) |
| 44 | { |
| 45 | unsigned long parent_block = 0; |
| 46 | unsigned long parent_offset = 0; |
| 47 | struct inode *child_inode = child->d_inode; |
| 48 | struct iso_inode_info *e_child_inode = ISOFS_I(child_inode); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 49 | struct iso_directory_record *de = NULL; |
| 50 | struct buffer_head * bh = NULL; |
| 51 | struct dentry *rv = NULL; |
| 52 | |
| 53 | /* "child" must always be a directory. */ |
| 54 | if (!S_ISDIR(child_inode->i_mode)) { |
| 55 | printk(KERN_ERR "isofs: isofs_export_get_parent(): " |
| 56 | "child is not a directory!\n"); |
| 57 | rv = ERR_PTR(-EACCES); |
| 58 | goto out; |
| 59 | } |
| 60 | |
| 61 | /* It is an invariant that the directory offset is zero. If |
| 62 | * it is not zero, it means the directory failed to be |
| 63 | * normalized for some reason. */ |
| 64 | if (e_child_inode->i_iget5_offset != 0) { |
| 65 | printk(KERN_ERR "isofs: isofs_export_get_parent(): " |
| 66 | "child directory not normalized!\n"); |
| 67 | rv = ERR_PTR(-EACCES); |
| 68 | goto out; |
| 69 | } |
| 70 | |
| 71 | /* The child inode has been normalized such that its |
| 72 | * i_iget5_block value points to the "." entry. Fortunately, |
| 73 | * the ".." entry is located in the same block. */ |
| 74 | parent_block = e_child_inode->i_iget5_block; |
| 75 | |
| 76 | /* Get the block in question. */ |
| 77 | bh = sb_bread(child_inode->i_sb, parent_block); |
| 78 | if (bh == NULL) { |
| 79 | rv = ERR_PTR(-EACCES); |
| 80 | goto out; |
| 81 | } |
| 82 | |
| 83 | /* This is the "." entry. */ |
| 84 | de = (struct iso_directory_record*)bh->b_data; |
| 85 | |
| 86 | /* The ".." entry is always the second entry. */ |
| 87 | parent_offset = (unsigned long)isonum_711(de->length); |
| 88 | de = (struct iso_directory_record*)(bh->b_data + parent_offset); |
| 89 | |
| 90 | /* Verify it is in fact the ".." entry. */ |
| 91 | if ((isonum_711(de->name_len) != 1) || (de->name[0] != 1)) { |
| 92 | printk(KERN_ERR "isofs: Unable to find the \"..\" " |
| 93 | "directory for NFS.\n"); |
| 94 | rv = ERR_PTR(-EACCES); |
| 95 | goto out; |
| 96 | } |
| 97 | |
| 98 | /* Normalize */ |
| 99 | isofs_normalize_block_and_offset(de, &parent_block, &parent_offset); |
| 100 | |
Christoph Hellwig | 4400372 | 2008-08-11 15:49:04 +0200 | [diff] [blame] | 101 | rv = d_obtain_alias(isofs_iget(child_inode->i_sb, parent_block, |
| 102 | parent_offset)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | out: |
Christoph Hellwig | 4400372 | 2008-08-11 15:49:04 +0200 | [diff] [blame] | 104 | if (bh) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | brelse(bh); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | return rv; |
| 107 | } |
| 108 | |
| 109 | static int |
| 110 | isofs_export_encode_fh(struct dentry *dentry, |
| 111 | __u32 *fh32, |
| 112 | int *max_len, |
| 113 | int connectable) |
| 114 | { |
| 115 | struct inode * inode = dentry->d_inode; |
| 116 | struct iso_inode_info * ei = ISOFS_I(inode); |
| 117 | int len = *max_len; |
| 118 | int type = 1; |
| 119 | __u16 *fh16 = (__u16*)fh32; |
| 120 | |
| 121 | /* |
| 122 | * WARNING: max_len is 5 for NFSv2. Because of this |
| 123 | * limitation, we use the lower 16 bits of fh32[1] to hold the |
| 124 | * offset of the inode and the upper 16 bits of fh32[1] to |
| 125 | * hold the offset of the parent. |
| 126 | */ |
Aneesh Kumar K.V | 5fe0c23 | 2011-01-29 18:43:25 +0530 | [diff] [blame] | 127 | if (connectable && (len < 5)) { |
| 128 | *max_len = 5; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 129 | return 255; |
Aneesh Kumar K.V | 5fe0c23 | 2011-01-29 18:43:25 +0530 | [diff] [blame] | 130 | } else if (len < 3) { |
| 131 | *max_len = 3; |
| 132 | return 255; |
| 133 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 134 | |
| 135 | len = 3; |
| 136 | fh32[0] = ei->i_iget5_block; |
| 137 | fh16[2] = (__u16)ei->i_iget5_offset; /* fh16 [sic] */ |
| 138 | fh32[2] = inode->i_generation; |
| 139 | if (connectable && !S_ISDIR(inode->i_mode)) { |
| 140 | struct inode *parent; |
| 141 | struct iso_inode_info *eparent; |
| 142 | spin_lock(&dentry->d_lock); |
| 143 | parent = dentry->d_parent->d_inode; |
| 144 | eparent = ISOFS_I(parent); |
| 145 | fh32[3] = eparent->i_iget5_block; |
| 146 | fh16[3] = (__u16)eparent->i_iget5_offset; /* fh16 [sic] */ |
| 147 | fh32[4] = parent->i_generation; |
| 148 | spin_unlock(&dentry->d_lock); |
| 149 | len = 5; |
| 150 | type = 2; |
| 151 | } |
| 152 | *max_len = len; |
| 153 | return type; |
| 154 | } |
| 155 | |
Christoph Hellwig | 905251a | 2007-10-21 16:42:12 -0700 | [diff] [blame] | 156 | struct isofs_fid { |
| 157 | u32 block; |
| 158 | u16 offset; |
| 159 | u16 parent_offset; |
| 160 | u32 generation; |
| 161 | u32 parent_block; |
| 162 | u32 parent_generation; |
| 163 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 164 | |
Christoph Hellwig | 905251a | 2007-10-21 16:42:12 -0700 | [diff] [blame] | 165 | static struct dentry *isofs_fh_to_dentry(struct super_block *sb, |
| 166 | struct fid *fid, int fh_len, int fh_type) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 167 | { |
Christoph Hellwig | 905251a | 2007-10-21 16:42:12 -0700 | [diff] [blame] | 168 | struct isofs_fid *ifid = (struct isofs_fid *)fid; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 169 | |
Christoph Hellwig | 905251a | 2007-10-21 16:42:12 -0700 | [diff] [blame] | 170 | if (fh_len < 3 || fh_type > 2) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 171 | return NULL; |
| 172 | |
Christoph Hellwig | 905251a | 2007-10-21 16:42:12 -0700 | [diff] [blame] | 173 | return isofs_export_iget(sb, ifid->block, ifid->offset, |
| 174 | ifid->generation); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 175 | } |
| 176 | |
Christoph Hellwig | 905251a | 2007-10-21 16:42:12 -0700 | [diff] [blame] | 177 | static struct dentry *isofs_fh_to_parent(struct super_block *sb, |
| 178 | struct fid *fid, int fh_len, int fh_type) |
| 179 | { |
| 180 | struct isofs_fid *ifid = (struct isofs_fid *)fid; |
| 181 | |
| 182 | if (fh_type != 2) |
| 183 | return NULL; |
| 184 | |
| 185 | return isofs_export_iget(sb, |
| 186 | fh_len > 2 ? ifid->parent_block : 0, |
| 187 | ifid->parent_offset, |
| 188 | fh_len > 4 ? ifid->parent_generation : 0); |
| 189 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | |
Christoph Hellwig | 3965516 | 2007-10-21 16:42:17 -0700 | [diff] [blame] | 191 | const struct export_operations isofs_export_ops = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | .encode_fh = isofs_export_encode_fh, |
Christoph Hellwig | 905251a | 2007-10-21 16:42:12 -0700 | [diff] [blame] | 193 | .fh_to_dentry = isofs_fh_to_dentry, |
| 194 | .fh_to_parent = isofs_fh_to_parent, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | .get_parent = isofs_export_get_parent, |
| 196 | }; |