1/*
  2 * (C) 2001 Clemson University and The University of Chicago
  3 *
  4 * See COPYING in top-level directory.
  5 */
  6
  7/*
  8 *  Linux VFS inode operations.
  9 */
 10
 11#include "protocol.h"
 12#include "orangefs-kernel.h"
 13#include "orangefs-bufmap.h"
 14
 15static int read_one_page(struct page *page)
 16{
 17	int ret;
 18	int max_block;
 19	ssize_t bytes_read = 0;
 20	struct inode *inode = page->mapping->host;
 21	const __u32 blocksize = PAGE_SIZE;	/* inode->i_blksize */
 22	const __u32 blockbits = PAGE_SHIFT;	/* inode->i_blkbits */
 23	struct iov_iter to;
 24	struct bio_vec bv = {.bv_page = page, .bv_len = PAGE_SIZE};
 25
 26	iov_iter_bvec(&to, ITER_BVEC | READ, &bv, 1, PAGE_SIZE);
 27
 28	gossip_debug(GOSSIP_INODE_DEBUG,
 29		    "orangefs_readpage called with page %p\n",
 30		     page);
 31
 32	max_block = ((inode->i_size / blocksize) + 1);
 33
 34	if (page->index < max_block) {
 35		loff_t blockptr_offset = (((loff_t) page->index) << blockbits);
 36
 37		bytes_read = orangefs_inode_read(inode,
 38						 &to,
 39						 &blockptr_offset,
 40						 inode->i_size);
 41	}
 42	/* this will only zero remaining unread portions of the page data */
 43	iov_iter_zero(~0U, &to);
 44	/* takes care of potential aliasing */
 45	flush_dcache_page(page);
 46	if (bytes_read < 0) {
 47		ret = bytes_read;
 48		SetPageError(page);
 49	} else {
 50		SetPageUptodate(page);
 51		if (PageError(page))
 52			ClearPageError(page);
 53		ret = 0;
 54	}
 55	/* unlock the page after the ->readpage() routine completes */
 56	unlock_page(page);
 57	return ret;
 58}
 59
 60static int orangefs_readpage(struct file *file, struct page *page)
 61{
 62	return read_one_page(page);
 63}
 64
 65static int orangefs_readpages(struct file *file,
 66			   struct address_space *mapping,
 67			   struct list_head *pages,
 68			   unsigned nr_pages)
 69{
 70	int page_idx;
 71	int ret;
 72
 73	gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_readpages called\n");
 74
 75	for (page_idx = 0; page_idx < nr_pages; page_idx++) {
 76		struct page *page;
 77
 78		page = list_entry(pages->prev, struct page, lru);
 79		list_del(&page->lru);
 80		if (!add_to_page_cache(page,
 81				       mapping,
 82				       page->index,
 83				       GFP_KERNEL)) {
 84			ret = read_one_page(page);
 85			gossip_debug(GOSSIP_INODE_DEBUG,
 86				"failure adding page to cache, read_one_page returned: %d\n",
 87				ret);
 88	      } else {
 89			put_page(page);
 90	      }
 91	}
 92	BUG_ON(!list_empty(pages));
 93	return 0;
 94}
 95
 96static void orangefs_invalidatepage(struct page *page,
 97				 unsigned int offset,
 98				 unsigned int length)
 99{
100	gossip_debug(GOSSIP_INODE_DEBUG,
101		     "orangefs_invalidatepage called on page %p "
102		     "(offset is %u)\n",
103		     page,
104		     offset);
105
106	ClearPageUptodate(page);
107	ClearPageMappedToDisk(page);
108	return;
109
110}
111
112static int orangefs_releasepage(struct page *page, gfp_t foo)
113{
114	gossip_debug(GOSSIP_INODE_DEBUG,
115		     "orangefs_releasepage called on page %p\n",
116		     page);
117	return 0;
118}
119
120/*
121 * Having a direct_IO entry point in the address_space_operations
122 * struct causes the kernel to allows us to use O_DIRECT on
123 * open. Nothing will ever call this thing, but in the future we
124 * will need to be able to use O_DIRECT on open in order to support
125 * AIO. Modeled after NFS, they do this too.
126 */
127/*
128 * static ssize_t orangefs_direct_IO(int rw,
129 *			struct kiocb *iocb,
130 *			struct iov_iter *iter,
131 *			loff_t offset)
132 *{
133 *	gossip_debug(GOSSIP_INODE_DEBUG,
134 *		     "orangefs_direct_IO: %s\n",
135 *		     iocb->ki_filp->f_path.dentry->d_name.name);
136 *
137 *	return -EINVAL;
138 *}
139 */
140
141struct backing_dev_info orangefs_backing_dev_info = {
142	.name = "orangefs",
143	.ra_pages = 0,
144	.capabilities = BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_WRITEBACK,
145};
146
147/** ORANGEFS2 implementation of address space operations */
148const struct address_space_operations orangefs_address_operations = {
149	.readpage = orangefs_readpage,
150	.readpages = orangefs_readpages,
151	.invalidatepage = orangefs_invalidatepage,
152	.releasepage = orangefs_releasepage,
153/*	.direct_IO = orangefs_direct_IO */
154};
155
156static int orangefs_setattr_size(struct inode *inode, struct iattr *iattr)
157{
158	struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
159	struct orangefs_kernel_op_s *new_op;
160	loff_t orig_size;
161	int ret = -EINVAL;
162
163	gossip_debug(GOSSIP_INODE_DEBUG,
164		     "%s: %pU: Handle is %pU | fs_id %d | size is %llu\n",
165		     __func__,
166		     get_khandle_from_ino(inode),
167		     &orangefs_inode->refn.khandle,
168		     orangefs_inode->refn.fs_id,
169		     iattr->ia_size);
170
171	/* Ensure that we have a up to date size, so we know if it changed. */
172	ret = orangefs_inode_getattr(inode, 0, 1);
173	if (ret == -ESTALE)
174		ret = -EIO;
175	if (ret) {
176		gossip_err("%s: orangefs_inode_getattr failed, ret:%d:.\n",
177		    __func__, ret);
178		return ret;
179	}
180	orig_size = i_size_read(inode);
181
182	truncate_setsize(inode, iattr->ia_size);
183
184	new_op = op_alloc(ORANGEFS_VFS_OP_TRUNCATE);
185	if (!new_op)
186		return -ENOMEM;
187
188	new_op->upcall.req.truncate.refn = orangefs_inode->refn;
189	new_op->upcall.req.truncate.size = (__s64) iattr->ia_size;
190
191	ret = service_operation(new_op, __func__,
192				get_interruptible_flag(inode));
193
194	/*
195	 * the truncate has no downcall members to retrieve, but
196	 * the status value tells us if it went through ok or not
197	 */
198	gossip_debug(GOSSIP_INODE_DEBUG,
199		     "orangefs: orangefs_truncate got return value of %d\n",
200		     ret);
201
202	op_release(new_op);
203
204	if (ret != 0)
205		return ret;
206
207	if (orig_size != i_size_read(inode))
208		iattr->ia_valid |= ATTR_CTIME | ATTR_MTIME;
209
210	return ret;
211}
212
213/*
214 * Change attributes of an object referenced by dentry.
215 */
216int orangefs_setattr(struct dentry *dentry, struct iattr *iattr)
217{
218	int ret = -EINVAL;
219	struct inode *inode = dentry->d_inode;
220
221	gossip_debug(GOSSIP_INODE_DEBUG,
222		     "orangefs_setattr: called on %s\n",
223		     dentry->d_name.name);
224
225	ret = inode_change_ok(inode, iattr);
226	if (ret)
227		goto out;
228
229	if ((iattr->ia_valid & ATTR_SIZE) &&
230	    iattr->ia_size != i_size_read(inode)) {
231		ret = orangefs_setattr_size(inode, iattr);
232		if (ret)
233			goto out;
234	}
235
236	setattr_copy(inode, iattr);
237	mark_inode_dirty(inode);
238
239	ret = orangefs_inode_setattr(inode, iattr);
240	gossip_debug(GOSSIP_INODE_DEBUG,
241		     "orangefs_setattr: inode_setattr returned %d\n",
242		     ret);
243
244	if (!ret && (iattr->ia_valid & ATTR_MODE))
245		/* change mod on a file that has ACLs */
246		ret = posix_acl_chmod(inode, inode->i_mode);
247
248out:
249	gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_setattr: returning %d\n", ret);
250	return ret;
251}
252
253/*
254 * Obtain attributes of an object given a dentry
255 */
256int orangefs_getattr(struct vfsmount *mnt,
257		  struct dentry *dentry,
258		  struct kstat *kstat)
259{
260	int ret = -ENOENT;
261	struct inode *inode = dentry->d_inode;
262	struct orangefs_inode_s *orangefs_inode = NULL;
263
264	gossip_debug(GOSSIP_INODE_DEBUG,
265		     "orangefs_getattr: called on %s\n",
266		     dentry->d_name.name);
267
268	ret = orangefs_inode_getattr(inode, 0, 1);
269	if (ret == 0) {
270		generic_fillattr(inode, kstat);
271
272		/* override block size reported to stat */
273		orangefs_inode = ORANGEFS_I(inode);
274		kstat->blksize = orangefs_inode->blksize;
275	}
276	return ret;
277}
278
279int orangefs_permission(struct inode *inode, int mask)
280{
281	int ret;
282
283	if (mask & MAY_NOT_BLOCK)
284		return -ECHILD;
285
286	gossip_debug(GOSSIP_INODE_DEBUG, "%s: refreshing\n", __func__);
287
288	/* Make sure the permission (and other common attrs) are up to date. */
289	ret = orangefs_inode_getattr(inode, 0, 0);
290	if (ret < 0)
291		return ret;
292
293	return generic_permission(inode, mask);
294}
295
296/* ORANGEDS2 implementation of VFS inode operations for files */
297struct inode_operations orangefs_file_inode_operations = {
298	.get_acl = orangefs_get_acl,
299	.set_acl = orangefs_set_acl,
300	.setattr = orangefs_setattr,
301	.getattr = orangefs_getattr,
302	.setxattr = generic_setxattr,
303	.getxattr = generic_getxattr,
304	.listxattr = orangefs_listxattr,
305	.removexattr = generic_removexattr,
306	.permission = orangefs_permission,
307};
308
309static int orangefs_init_iops(struct inode *inode)
310{
311	inode->i_mapping->a_ops = &orangefs_address_operations;
312
313	switch (inode->i_mode & S_IFMT) {
314	case S_IFREG:
315		inode->i_op = &orangefs_file_inode_operations;
316		inode->i_fop = &orangefs_file_operations;
317		inode->i_blkbits = PAGE_SHIFT;
318		break;
319	case S_IFLNK:
320		inode->i_op = &orangefs_symlink_inode_operations;
321		break;
322	case S_IFDIR:
323		inode->i_op = &orangefs_dir_inode_operations;
324		inode->i_fop = &orangefs_dir_operations;
325		break;
326	default:
327		gossip_debug(GOSSIP_INODE_DEBUG,
328			     "%s: unsupported mode\n",
329			     __func__);
330		return -EINVAL;
331	}
332
333	return 0;
334}
335
336/*
337 * Given a ORANGEFS object identifier (fsid, handle), convert it into a ino_t type
338 * that will be used as a hash-index from where the handle will
339 * be searched for in the VFS hash table of inodes.
340 */
341static inline ino_t orangefs_handle_hash(struct orangefs_object_kref *ref)
342{
343	if (!ref)
344		return 0;
345	return orangefs_khandle_to_ino(&(ref->khandle));
346}
347
348/*
349 * Called to set up an inode from iget5_locked.
350 */
351static int orangefs_set_inode(struct inode *inode, void *data)
352{
353	struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data;
354	ORANGEFS_I(inode)->refn.fs_id = ref->fs_id;
355	ORANGEFS_I(inode)->refn.khandle = ref->khandle;
356	return 0;
357}
358
359/*
360 * Called to determine if handles match.
361 */
362static int orangefs_test_inode(struct inode *inode, void *data)
363{
364	struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data;
365	struct orangefs_inode_s *orangefs_inode = NULL;
366
367	orangefs_inode = ORANGEFS_I(inode);
368	return (!ORANGEFS_khandle_cmp(&(orangefs_inode->refn.khandle), &(ref->khandle))
369		&& orangefs_inode->refn.fs_id == ref->fs_id);
370}
371
372/*
373 * Front-end to lookup the inode-cache maintained by the VFS using the ORANGEFS
374 * file handle.
375 *
376 * @sb: the file system super block instance.
377 * @ref: The ORANGEFS object for which we are trying to locate an inode structure.
378 */
379struct inode *orangefs_iget(struct super_block *sb, struct orangefs_object_kref *ref)
380{
381	struct inode *inode = NULL;
382	unsigned long hash;
383	int error;
384
385	hash = orangefs_handle_hash(ref);
386	inode = iget5_locked(sb, hash, orangefs_test_inode, orangefs_set_inode, ref);
387	if (!inode || !(inode->i_state & I_NEW))
388		return inode;
389
390	error = orangefs_inode_getattr(inode, 1, 0);
391	if (error) {
392		iget_failed(inode);
393		return ERR_PTR(error);
394	}
395
396	inode->i_ino = hash;	/* needed for stat etc */
397	orangefs_init_iops(inode);
398	unlock_new_inode(inode);
399
400	gossip_debug(GOSSIP_INODE_DEBUG,
401		     "iget handle %pU, fsid %d hash %ld i_ino %lu\n",
402		     &ref->khandle,
403		     ref->fs_id,
404		     hash,
405		     inode->i_ino);
406
407	return inode;
408}
409
410/*
411 * Allocate an inode for a newly created file and insert it into the inode hash.
412 */
413struct inode *orangefs_new_inode(struct super_block *sb, struct inode *dir,
414		int mode, dev_t dev, struct orangefs_object_kref *ref)
415{
416	unsigned long hash = orangefs_handle_hash(ref);
417	struct inode *inode;
418	int error;
419
420	gossip_debug(GOSSIP_INODE_DEBUG,
421		     "%s:(sb is %p | MAJOR(dev)=%u | MINOR(dev)=%u mode=%o)\n",
422		     __func__,
423		     sb,
424		     MAJOR(dev),
425		     MINOR(dev),
426		     mode);
427
428	inode = new_inode(sb);
429	if (!inode)
430		return NULL;
431
432	orangefs_set_inode(inode, ref);
433	inode->i_ino = hash;	/* needed for stat etc */
434
435	error = orangefs_inode_getattr(inode, 1, 0);
436	if (error)
437		goto out_iput;
438
439	orangefs_init_iops(inode);
440
441	inode->i_mode = mode;
442	inode->i_uid = current_fsuid();
443	inode->i_gid = current_fsgid();
444	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
445	inode->i_size = PAGE_SIZE;
446	inode->i_rdev = dev;
447
448	error = insert_inode_locked4(inode, hash, orangefs_test_inode, ref);
449	if (error < 0)
450		goto out_iput;
451
452	gossip_debug(GOSSIP_INODE_DEBUG,
453		     "Initializing ACL's for inode %pU\n",
454		     get_khandle_from_ino(inode));
455	orangefs_init_acl(inode, dir);
456	return inode;
457
458out_iput:
459	iput(inode);
460	return ERR_PTR(error);
461}