| Start/ | End/ | |||
| True | False | - | Line | Source |
| 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 | * | |||
| 12 | * Documentation/filesystems/Exporting | |||
| 13 | * fs/exportfs/expfs.c. | |||
| 14 | */ | |||
| 15 | ||||
| 16 | #include "isofs.h" | |||
| 17 | ||||
| 18 | static struct dentry * | |||
| 0 | 0 | - | 19 | isofs_export_iget(struct super_block *sb, |
| 20 | unsigned long block, | |||
| 21 | unsigned long offset, | |||
| 22 | __u32 generation) | |||
| 23 | { | |||
| 24 | struct inode *inode; | |||
| 25 | struct dentry *result; | |||
| 0 | 0 | - | 26 | if (block == 0) |
| 0 | - | 27 | return ERR_PTR(-ESTALE); | |
| 28 | inode = isofs_iget(sb, block, offset); | |||
| 0 | 0 | - | 29 | if (inode == NULL) |
| 0 | - | 30 | return ERR_PTR(-ENOMEM); | |
| 31 | if (is_bad_inode(inode) | |||
| 0 | 0 | - | 32 | || (generation && inode->i_generation != generation)) |
| 0 | - | 32 | T || (_ && _) | |
| 0 | - | 32 | F || (T && T) | |
| 0 | - | 32 | F || (T && F) | |
| 0 | - | 32 | F || (F && _) | |
| 33 | { | |||
| 34 | iput(inode); | |||
| 0 | - | 35 | return ERR_PTR(-ESTALE); | |
| 36 | } | |||
| 37 | result = d_alloc_anon(inode); | |||
| 0 | 0 | - | 38 | if (!result) { |
| 39 | iput(inode); | |||
| 0 | - | 40 | return ERR_PTR(-ENOMEM); | |
| 41 | } | |||
| 0 | - | 42 | return result; | |
| 43 | } | |||
| 44 | ||||
| 45 | static struct dentry * | |||
| 0 | 0 | - | 46 | isofs_export_get_dentry(struct super_block *sb, void *vobjp) |
| 47 | { | |||
| 48 | __u32 *objp = vobjp; | |||
| 49 | unsigned long block = objp[0]; | |||
| 50 | unsigned long offset = objp[1]; | |||
| 51 | __u32 generation = objp[2]; | |||
| 0 | - | 52 | return isofs_export_iget(sb, block, offset, generation); | |
| 53 | } | |||
| 54 | ||||
| 55 | /* This function is surprisingly simple. The trick is understanding | |||
| 56 | * that "child" is always a directory. So, to find its parent, you | |||
| 57 | * simply need to find its ".." entry, normalize its block and offset, | |||
| 58 | * and return the underlying inode. See the comments for | |||
| 59 | * isofs_normalize_block_and_offset(). */ | |||
| 0 | 0 | - | 60 | static struct dentry *isofs_export_get_parent(struct dentry *child) |
| 61 | { | |||
| 62 | unsigned long parent_block = 0; | |||
| 63 | unsigned long parent_offset = 0; | |||
| 64 | struct inode *child_inode = child->d_inode; | |||
| 65 | struct iso_inode_info *e_child_inode = ISOFS_I(child_inode); | |||
| 66 | struct inode *parent_inode = NULL; | |||
| 67 | struct iso_directory_record *de = NULL; | |||
| 68 | struct buffer_head * bh = NULL; | |||
| 69 | struct dentry *rv = NULL; | |||
| 70 | ||||
| 71 | /* "child" must always be a directory. */ | |||
| 0 | 0 | - | 72 | if (!S_ISDIR(child_inode->i_mode)) { |
| 73 | printk(KERN_ERR "isofs: isofs_export_get_parent(): " | |||
| 74 | "child is not a directory!\n"); | |||
| 75 | rv = ERR_PTR(-EACCES); | |||
| 0 | - | 76 | goto out; | |
| 77 | } | |||
| 78 | ||||
| 79 | /* It is an invariant that the directory offset is zero. If | |||
| 80 | * it is not zero, it means the directory failed to be | |||
| 81 | * normalized for some reason. */ | |||
| 0 | 0 | - | 82 | if (e_child_inode->i_iget5_offset != 0) { |
| 83 | printk(KERN_ERR "isofs: isofs_export_get_parent(): " | |||
| 84 | "child directory not normalized!\n"); | |||
| 85 | rv = ERR_PTR(-EACCES); | |||
| 0 | - | 86 | goto out; | |
| 87 | } | |||
| 88 | ||||
| 89 | /* The child inode has been normalized such that its | |||
| 90 | * i_iget5_block value points to the "." entry. Fortunately, | |||
| 91 | * the ".." entry is located in the same block. */ | |||
| 92 | parent_block = e_child_inode->i_iget5_block; | |||
| 93 | ||||
| 94 | /* Get the block in question. */ | |||
| 95 | bh = sb_bread(child_inode->i_sb, parent_block); | |||
| 0 | 0 | - | 96 | if (bh == NULL) { |
| 97 | rv = ERR_PTR(-EACCES); | |||
| 0 | - | 98 | goto out; | |
| 99 | } | |||
| 100 | ||||
| 101 | /* This is the "." entry. */ | |||
| 102 | de = (struct iso_directory_record*)bh->b_data; | |||
| 103 | ||||
| 104 | /* The ".." entry is always the second entry. */ | |||
| 105 | parent_offset = (unsigned long)isonum_711(de->length); | |||
| 106 | de = (struct iso_directory_record*)(bh->b_data + parent_offset); | |||
| 107 | ||||
| 108 | /* Verify it is in fact the ".." entry. */ | |||
| 0 | 0 | - | 109 | if ((isonum_711(de->name_len) != 1) || (de->name[0] != 1)) { |
| 0 | - | 109 | (T) || (_) | |
| 0 | - | 109 | (F) || (T) | |
| 0 | - | 109 | (F) || (F) | |
| 110 | printk(KERN_ERR "isofs: Unable to find the \"..\" " | |||
| 111 | "directory for NFS.\n"); | |||
| 112 | rv = ERR_PTR(-EACCES); | |||
| 0 | - | 113 | goto out; | |
| 114 | } | |||
| 115 | ||||
| 116 | /* Normalize */ | |||
| 117 | isofs_normalize_block_and_offset(de, &parent_block, &parent_offset); | |||
| 118 | ||||
| 119 | /* Get the inode. */ | |||
| 120 | parent_inode = isofs_iget(child_inode->i_sb, | |||
| 121 | parent_block, | |||
| 122 | parent_offset); | |||
| 0 | 0 | - | 123 | if (parent_inode == NULL) { |
| 124 | rv = ERR_PTR(-EACCES); | |||
| 0 | - | 125 | goto out; | |
| 126 | } | |||
| 127 | ||||
| 128 | /* Allocate the dentry. */ | |||
| 129 | rv = d_alloc_anon(parent_inode); | |||
| 0 | 0 | - | 130 | if (rv == NULL) { |
| 131 | rv = ERR_PTR(-ENOMEM); | |||
| 0 | - | 132 | goto out; | |
| 133 | } | |||
| 134 | ||||
| 135 | out: | |||
| 0 | 0 | - | 136 | if (bh) { |
| 137 | brelse(bh); | |||
| 138 | } | |||
| 0 | - | 139 | return rv; | |
| 140 | } | |||
| 141 | ||||
| 142 | static int | |||
| 0 | 0 | - | 143 | isofs_export_encode_fh(struct dentry *dentry, |
| 144 | __u32 *fh32, | |||
| 145 | int *max_len, | |||
| 146 | int connectable) | |||
| 147 | { | |||
| 148 | struct inode * inode = dentry->d_inode; | |||
| 149 | struct iso_inode_info * ei = ISOFS_I(inode); | |||
| 150 | int len = *max_len; | |||
| 151 | int type = 1; | |||
| 152 | __u16 *fh16 = (__u16*)fh32; | |||
| 153 | ||||
| 154 | /* | |||
| 155 | * WARNING: max_len is 5 for NFSv2. Because of this | |||
| 156 | * limitation, we use the lower 16 bits of fh32[1] to hold the | |||
| 157 | * offset of the inode and the upper 16 bits of fh32[1] to | |||
| 158 | * hold the offset of the parent. | |||
| 159 | */ | |||
| 160 | ||||
| 0 | 0 | - | 161 | if (len < 3 || (connectable && len < 5)) |
| 0 | - | 161 | T || (_ && _) | |
| 0 | - | 161 | F || (T && T) | |
| 0 | - | 161 | F || (T && F) | |
| 0 | - | 161 | F || (F && _) | |
| 0 | - | 162 | return 255; | |
| 163 | ||||
| 164 | len = 3; | |||
| 165 | fh32[0] = ei->i_iget5_block; | |||
| 166 | fh16[2] = (__u16)ei->i_iget5_offset; /* fh16 [sic] */ | |||
| 167 | fh32[2] = inode->i_generation; | |||
| 0 | 0 | - | 168 | if (connectable && !S_ISDIR(inode->i_mode)) { |
| 0 | - | 168 | T && !(F) | |
| 0 | - | 168 | T && !(T) | |
| 0 | - | 168 | F && !(_) | |
| 169 | struct inode *parent; | |||
| 170 | struct iso_inode_info *eparent; | |||
| 171 | spin_lock(&dentry->d_lock); | |||
| 171 | do | |||
| 0 | 0 | - | 171 | do-while (0) |
| 0 | 0 | - | 171 | do-while (0) |
| 172 | parent = dentry->d_parent->d_inode; | |||
| 173 | eparent = ISOFS_I(parent); | |||
| 174 | fh32[3] = eparent->i_iget5_block; | |||
| 175 | fh16[3] = (__u16)eparent->i_iget5_offset; /* fh16 [sic] */ | |||
| 176 | fh32[4] = parent->i_generation; | |||
| 177 | spin_unlock(&dentry->d_lock); | |||
| 177 | do | |||
| 0 | 0 | - | 177 | do-while (0) |
| 0 | 0 | - | 177 | do-while (0) |
| 178 | len = 5; | |||
| 179 | type = 2; | |||
| 180 | } | |||
| 181 | *max_len = len; | |||
| 0 | - | 182 | return type; | |
| 183 | } | |||
| 184 | ||||
| 185 | ||||
| 186 | static struct dentry * | |||
| 0 | 0 | - | 187 | isofs_export_decode_fh(struct super_block *sb, |
| 188 | __u32 *fh32, | |||
| 189 | int fh_len, | |||
| 190 | int fileid_type, | |||
| 191 | int (*acceptable)(void *context, struct dentry *de), | |||
| 192 | void *context) | |||
| 193 | { | |||
| 194 | __u16 *fh16 = (__u16*)fh32; | |||
| 195 | __u32 child[3]; /* The child is what triggered all this. */ | |||
| 196 | __u32 parent[3]; /* The parent is just along for the ride. */ | |||
| 197 | ||||
| 0 | 0 | - | 198 | if (fh_len < 3 || fileid_type > 2) |
| 0 | - | 198 | T || _ | |
| 0 | - | 198 | F || T | |
| 0 | - | 198 | F || F | |
| 0 | - | 199 | return NULL; | |
| 200 | ||||
| 201 | child[0] = fh32[0]; | |||
| 202 | child[1] = fh16[2]; /* fh16 [sic] */ | |||
| 203 | child[2] = fh32[2]; | |||
| 204 | ||||
| 205 | parent[0] = 0; | |||
| 206 | parent[1] = 0; | |||
| 207 | parent[2] = 0; | |||
| 0 | 0 | - | 208 | if (fileid_type == 2) { |
| 0 | 0 | - | 209 | if (fh_len > 2) parent[0] = fh32[3]; |
| 210 | parent[1] = fh16[3]; /* fh16 [sic] */ | |||
| 0 | 0 | - | 211 | if (fh_len > 4) parent[2] = fh32[4]; |
| 212 | } | |||
| 213 | ||||
| 214 | return sb->s_export_op->find_exported_dentry(sb, child, parent, | |||
| 0 | - | 215 | acceptable, context); | |
| 216 | } | |||
| 217 | ||||
| 218 | ||||
| 219 | struct export_operations isofs_export_ops = { | |||
| 220 | .decode_fh = isofs_export_decode_fh, | |||
| 221 | .encode_fh = isofs_export_encode_fh, | |||
| 222 | .get_dentry = isofs_export_get_dentry, | |||
| 223 | .get_parent = isofs_export_get_parent, | |||
| 224 | }; | |||
| ***TER 0% (0/81) of SOURCE FILE export.c | ||||